Webeame Snippets

Intenta conocer la IP real de un visitante aunque se encuentre tras un proxy

/**
* function ip (void)
*
* devuelve la IP de un usuario remoto
*
* return string
*/
function ip () {
	$s_hxff = $_SERVER['HTTP_X_FORWARDED_FOR'];
	$s_ra = $_SERVER['REMOTE_ADDR'];
	$e_ra = $_ENV['REMOTE_ADDR'];
	$client_ip = empty($s_ra)?(empty($e_ra)?'unknown':$e_ra):$s_ra;
 
	if ($s_hxff) {
		// los proxys van añadiendo al final de esta cabecera
		// las direcciones ip que van "ocultando". Para localizar la ip real
		// del usuario se comienza a mirar por el principio hasta encontrar
		// una dirección ip que no sea del rango privado. En caso de no
		// encontrarse ninguna se toma como valor el REMOTE_ADDR
 
		$entries = split('[, ]', $s_hxff);
 
		reset($entries);
 
		while (list(, $entry) = each($entries)) {
			$entry = trim($entry);
 
			if (preg_match('/^([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/', $entry, $client_ip)) {
				// http://www.faqs.org/rfcs/rfc1918.html
				$private_ip = array(
					'/^(00)?0\./',
					'/^127\.(00)?0\.(00)?0\.(00)?1/',
					'/^192\.168\..*/',
					'/^172\.0?((1[6-9])|(2[0-9])|(3[0-1]))\..*/',
					'/^0?10\..*/'
				);
 
				$found_ip = preg_replace($private_ip, $client_ip, $ip_list[1]);
 
				if ($client_ip != $found_ip) {
					$client_ip = $found_ip;
					break;
				}
			}
		}
	}
 
	return addslashes($client_ip);
}

Script para generación de contraseñas aleatorias

<?php
/**
* function texto_aleatorio (integer $long = 5, boolean $lestras_min = true, boolean $letras_max = true, boolean $num = true))
*
* Permite generar contrasenhas de manera aleatoria.
*
* @$long: Especifica la longitud de la contrasenha
* @$letras_min: Podra usar letas en minusculas
* @$letras_max: Podra usar letas en mayusculas
* @$num: Podra usar numeros
*
* return string
*/
function texto_aleatorio ($long = 5, $letras_min = true, $letras_max = true, $num = true) {
	$salt = $letras_min?'abchefghknpqrstuvwxyz':'';
	$salt .= $letras_max?'ACDEFHKNPRSTUVWXYZ':'';
	$salt .= $num?(strlen($salt)?'2345679':'0123456789'):'';
 
	if (strlen($salt) == 0) {
		return '';
	}
 
	$i = 0;
	$str = '';
 
	srand((double)microtime()*1000000);
 
	while ($i < $long) {
		$num = rand(0, strlen($salt)-1);
		$str .= substr($salt, $num, 1);
		$i++;
	}
 
	return $str;
}
?>

function abrir($url) 
{
	$sesion = curl_init($url);
 
	curl_setopt($sesion, CURLOPT_RETURNTRANSFER, 1);
	curl_setopt($sesion, CURLOPT_FOLLOWLOCATION, 1);
	curl_setopt($sesion, CURLOPT_TIMEOUT, 5);
	curl_setopt($sesion, CURLOPT_CONNECTTIMEOUT, 5);
 
	// Nos hacemos pasar por el Firefox
	curl_setopt($sesion, CURLOPT_USERAGENT, 'Mozilla/5.0 (Windows; U; Windows NT 5.1; es-ES; rv:1.8.1.7) Gecko/20070914 Firefox/2.0.0.7');
 
	$resultado = curl_exec($sesion);
 
	curl_close($sesion);
 
	return $resultado;
}

function validarIP($ip)
{
	if (($longip = ip2long($ip)) !== false)
	{
		if ($ip == long2ip($longip))
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	} 
}

// introduce aquí la descripción código necesario para la utilización de una imagen png en IE 6 y su modo de inclusión en el resto de los navegadores

// inserta aquí el código
#contenedor { transparent url(../img/bck_trans.png) repeat scroll left top }
 
/* estilo para IE 6 en una hoja condicional - OJO que la ruta de imagen es diferente */
#contenedor { background-image:none; filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(enabled=true, sizingMethod=scale, src='img/bck_trans.png');  }

function load_counter() {
    if (file_exists('counter.txt')){
        $n = file_get_contents('counter.txt');
        return intval($n);
    }
    return 0;
}
 
function update_counter($i=1) {
 
    $n = load_counter();
    $n += $i;
 
    $fp = fopen('counter.txt', "w+");
    fwrite($fp, $n);
    fclose($fp);
 
    return $n;
}

Uso

// count the current visit and output the count
$visits = update_counter();
 
// just load the counter data
$visits = load_counter();

// introduce aquí la descripción

# Open file to write:
open(FILEHANDLE, ">fichero.txt") or die 'cannot open file!';  
 
# Modes:
#
# >   = Write mode (overwrites file content)
# >>  = Append mode - adds the content to the file
# <   = read only mode
# +>> = read/append mode
# +>  = read/write mode
 
# write to File
print FILEHANDLE "Line 1n";
print FILEHANDLE "Line 2n";
 
# close file handle
close(FILEHANDLE);

El patrón Singleton se aplica a situaciones en las cuales hay la necesidad de tener una sola instancia de una clase. El ejemplo más común de esto es una conexión de base de datos. Tendremos una simple instancia fácilmente accesible a muchos otros objetos.

<?php
class Example
{
    // Hold an instance of the class
    private static $instance;
 
    // A private constructor; prevents direct creation of object
    private function __construct() 
    {
        echo 'I am constructed';
    }
 
    // The singleton method
    public static function singleton() 
    {
        if (!isset(self::$instance)) {
            $c = __CLASS__;
            self::$instance = new $c;
        }
 
        return self::$instance;
    }
 
    // Example method
    public function bark()
    {
        echo 'Woof!';
    }
 
    // Prevent users to clone the instance
    public function __clone()
    {
        trigger_error('Clone is not allowed.', E_USER_ERROR);
    }
 
}
 
?>

Esto permite que se obtenga una simple instancia de la clase Example.

<?php
// Error porque el constructor es privado
$test = new Example;
 
// Devuelve siempre la misma instancia
$test = Example::singleton();
$test->bark();
 
// Lanzará un error
$test_clone = clone($test);
 
?>

El patrón Factory permita la instancia de objetos en tiempo de ejecución. Es llamado el patrón Factory puesto que es responsable de "manufacturar" un objeto.

<?php
class Example
{
    // The factory method
    public static function &factory($type)
    {
        if (include_once 'Drivers/' . $type . '.php') {
            $classname = 'Driver_' . $type;
            return new $classname;
        } else {
            throw new Exception ('Driver not found');
        }
    }
}
?>

Al definir este método en una clase se nos permite que los drivers sean cargados al vuelo. Si la clase Example fuera una clase de abstracción de base de datos, cargar un manejador de MySQL y SQLite podría ser hecho como sigue:

<?php
// Load a MySQL Driver
$mysql = Example::factory('MySQL');
 
// Load a SQLite Driver
$sqlite = Example::factory('SQLite');
?>

<?php
 
// Definimos los headers
header("Content-type: image/gif");
 
// Creamos la imagen
$imagen = imagecreate(400,300);
 
// Agregamos contenido
$blanco = imagecolorallocate($imagen,255,255,255);
$negro = imagecolorallocate($imagen,0,0,0);
$rojo = imagecolorallocate($imagen,200,0,0);
$verde = imagecolorallocate($imagen,0,130,0);
$gris = imagecolorallocate($imagen,140,140,140);
 
imagefilledrectangle($imagen,50,50,145,250,$verde);
imagefilledrectangle($imagen,255,50,350,250,$rojo);
imagefilledellipse($imagen,200,150,80,80,$gris);
imagerectangle($imagen,50,50,350,250,$negro);
 
// Damos salida a la imagen
imagegif($imagen);
 
// Destruimos la imagen
imagedestroy($imagen);
 
?>

http://www.washeebo.com/sargento/03_php/0301/0301.php