Webeame Snippets

Permite enviar un formulario directamente desde un array de datos en PHP.

/**
* function enviaPOST (string $host, string $url, array $datos, boolean $error = false)
*
* Envia un formulario a una url remota y obtiene el resultado
*
* @$host: Servidor de destino
* @$url: Url del fichero que recibirá el formulario
* @$datos: Datos que se enviarán, en formato $datos['clave'] = 'valor';
* @$error: Enseñar el error en caso de problemas en el envío
*
* return string
*/
 
function enviaPOST ($host, $url, $datos, $error = false) {
	$da = fsockopen($host, 80, $errno, $errstr);
	$postdata = '';
 
	if (!$da) {
		return false;
	}
 
	if (is_array($datos) && (count($datos) > 0)) {
		foreach ($datos as $k => $v) {
			$postdata .= rawurlencode($k).'='.rawurlencode($v).'&';
		}
 
		$postdata = substr($postdata, 0, -1);
	}
 
	$respuesta = '';
	$salida = 'POST '.$url.' HTTP/1.1'
		."\r\n".'Host: '.$host
		."\r\n".'User-Agent: PHP Script'
		."\r\n".'Content-Type: application/x-www-form-urlencoded'
		."\r\n".'Content-Length: '.strlen($postdata)
		."\r\n".'Accept-Charset: ISO-8859-1, utf-8;q=0.66, *;q=0.66'
		."\r\n".'Connection: close'
		."\r\n\r\n".$postdata;
 
	fwrite($da, $salida);
 
	while (!feof($da)) {
		$respuesta .= fgets($da, 1024);
	}
 
	fclose($da);
 
	$respuesta = explode("\r\n\r\n", $respuesta);
	$header = array_shift($respuesta);
	$contenido = implode('', $respuesta);
 
	if (($error == true) || (strstr($header, 'Transfer-Encoding: chunked') == false)) {
		return trim($contenido);
	}
 
	return false;
}

Genera un arbol de directorios de manera recursiva.

/**
* function dir_recursivo (string $destino)
*
* Crea un arbol de directorios de manera recursiva
*
* return boolean
*/
function dir_recursivo ($destino) {
	if (is_dir($destino)) {
		return true;
	}
 
	$dirs = explode('/', $destino);
	$dir = '';
 
	foreach ($dirs as $part) {
		if (empty($part) || ($part == '.')) {
			continue;
		}
 
		$dir .= '/'.$part;
 
		if ($part == '..') {
			continue;
		}
 
		if (!is_dir($dir)) {
			$ok = @mkdir($dir, 0755);
 
			if (!$ok) {
				return false;
			}
		}
	}
 
	clearstatcache();
 
	return is_dir($destino);
}

Cambia todo tipo de carácteres extraños por letras o símbolos equivalentes para poder usarlo como complemento en las URL's

/**
* function palabra_simple (string $texto, boolean $min, boolean $html = false)
*
* Cambia las letras con tildes, eñes o caracteres raros por su concordancia natural.
* En caso de que min sea true devolvera el texto en minúsculas.
*
* @$min: true/false para devolver el resultado en minúsculas
* @$html: true/false si la cadena de texto que recibe está formateada con htmlentities
*
* return string
*/
function palabra_simple ($texto, $min = true, $html = false) {
	if (!$html) {
		$texto = htmlentities($texto, ENT_QUOTES, 'ISO-8859-1');
	}
 
	$texto = preg_replace('/&([a-zA-Z])(uml|acute|grave|circ|tilde);/i', '$1', $texto);
	$texto = html_entity_decode($texto, ENT_QUOTES, 'ISO-8859-1');
 
	$texto = preg_replace(array('/[^a-z0-9_-]/i', '/-+/', '/^-/', '/-$/',), array('-', '-', '', ''), $texto);
 
	return $min?strtolower($texto):$texto;
}

Corta un texto por el limite seleccionado y devuelve el resultado. Esta función es útil para crear el texto de entradillas ya que no incluye las etiquetas HTML como enlaces, strong y demás y para sistemas que usen entidades HTML para los acentos, comprueba que no corte ninguna de estas entidades.

/**
* function corta_texto (string $txt, integer $limite = 150, string $fin = '...', string $encontrar = ' ')
*
* Corta un texto por el limite seleccionado y devuelve el resultado.
*
* @$txt: Texto a cortar
* @$limite: Límite máximo de caractere que se permiten al texto
* @$fin: Cadena para finalizar el texto cortado
* @$encontrar: Busca la última posición de esta cadena en dentro del límite de texto y lo corta en esa posición. Por defecto un espacio.
*	 
* return string
*/
function corta_texto ($txt, $limite = 150, $fin = '...', $encontrar = ' ') {
	// Primero elimino todas las etiquetas de HTML
	$txt = preg_replace('/<[^>]+>/', '', $txt);
 
	// Si la cadena es más corta que el límite
	if (strlen($txt) <= $limite) {
		// Quito los saltos de linea y los paso a HTML
		return preg_replace("/\n/s",'<br />', preg_replace("/(\r\n|\r)/s","\n", $txt));
	}
 
	// Si no encuentra ninguna entidad HTML corta el texto y devuelve el resultado
	if (strstr($txt, '&') === false) {
		return substr($txt, 0, $limite).$fin;
	}
 
	$caracteres = preg_split('/(&[^;\s]+;)|/', $txt, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_OFFSET_CAPTURE);
	$longitud = count($caracteres);
 
	if ($longitud === 0) {
		return '';
	}
 
	$inicio = max(0, -$longitud);
	$inicio_real = $caracteres[$longitud + $inicio][1];
 
	if (($inicio + $limite) >= $longitud) {
		$txt = substr($txt, $inicio_real).$fin;
	} else {
		$remate = $caracteres[max($inicio, 0) + $limite][1] - $inicio_real;
 
		while (($remate >= 0) && (!preg_match('/[ ,\.\;]/', $txt[$remate]))) {
			$remate--;
		}
 
		$txt = substr($txt, $inicio_real, $remate).$fin;
	}
 
	// Si no se define una cadena de texto a encontrar.
	if (empty($encontrar)) {
		return preg_replace("/\n/s",'<br />', preg_replace("/(\r\n|\r)/s","\n", $txt)).$fin;
	}
 
	$pos = strrpos($txt, $encontrar);
 
	if ($pos === false) {
		return preg_replace("/\n/s",'<br />', preg_replace("/(\r\n|\r)/s","\n", $txt)).$fin;
	} else {
		return preg_replace("/\n/s",'<br />', preg_replace("/(\r\n|\r)/s","\n", substr($txt, 0, $pos))).$fin;
	}
}

Codifica los correos electrónicos encontrados en un texto para evitar el spam

/**
* function codifica_email (string $txt)
*
* Codifica los correos electrónicos encontrados en un texto para evitar el spam
*
* return string
*/
function codifica_email ($txt) {
	if (strstr($txt, '@')) {
		$txt = preg_replace_callback(
			'/([a-z0-9\._-]+@[^"\s\',\$\;]+)/ie',
			create_function(
				'$encontrado',
				'
					$long = strlen($encontrado[1]);
					$correo = "";
 
					for ($i = 0; $i < $long; $i++) {
						$correo .= "&#".ord($encontrado[1][$i]).";";
					}
 
					return $correo;
				'
			),
			$txt
		);
 
		$txt = str_replace('mailto:', '&#109;&#097;&#105;&#108;&#116;&#111;&#058;', $txt);
	}
 
	return $txt;
}

Función que recoge un array y lo devuelve ordenado aleatoriamente

/**
* function array2rand (array $array)
*
* Devuelve un array ordenado aleatoriamente
*
* return array
*/
function array2rand ($array) {
	if (!is_array($array)) {
		return array();
	}
 
	srand((float) microtime() * 10000000);
 
	$claves = array_rand($array, count($array));
	$resultado = array();
 
	foreach ($claves as $v) {
		$resultado[$v] = $array[$v];
	}
 
	return $resultado;
}

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;
	} 
}