Webeame Snippets

Como complemento a la función getHeaders, esta función permite revisar si una dirección web devuelve un 404 de inexistente.

/**
* function valida_enlace (string $url, boolean $formato = true)
*
* Comprueba si un enlace no devuelve un 404
*
* return boolean
*/
function valida_enlace ($url, $formato = true) {
	$head = getHeaders($url, $formato);
 
	return (is_array($head) && strlen($head[0]) && !stristr($head[0], '404'))?$head:false;
}

Devuelve las cabeceras de una dirección web

/**
* function getHeaders (string $url, boolean $formato = true)
*
* Devuelve las cabeceras de una dirección web
* Solo acepta HTTP como metodo
*
* Si $formato es true devuelve un array asociativo,
* de lo contrario, un array de claves simples
*
* return array
*/
function getHeaders ($url, $formato = true) {
	if (function_exists('get_headers')) {
		return @get_headers($url, $formato);
	} 
 
	$partes = @parse_url($url);
 
	if (empty($partes['host'])) {
		return false;
	} 
 
	if (empty($partes['path'])) {
		$path = '/';
	} else {
		$path = $partes['path'];
	}
 
	if (!empty($partes['query'])) {
		$path .= '?'.$partes['query'];
	}
 
	$partes['port'] = isset($partes['port'])?$partes['port']:80;
 
	$socket = fsockopen($partes['host'], $partes['port'], $errno, $errstr, 30);
 
	if (!$socket) {
		return false;
	}
 
	$header = 'HEAD '.$path.' HTTP/1.1'."\r\n"
		.'Host: '.$partes['host'].(empty($partes['port'])?'':(':'.$partes['port']))."\r\n"
		.'Connection: Close'."\r\n\r\n";
 
	fwrite($socket, $header);
 
	$datos = array();
	$fin = false;
 
	while (!feof($socket) or ($fin == true)) {
		if ($header = fgets($socket, 1024)) {
			if ($header == "\r\n") {
				$fin = true;
				break;
			} else {
				$header = trim($header);
			}
 
			if ($formato == 1) {
				$key = explode(':', $header);
				$key = array_shift($key);
 
				if ($key == $header) {
					$datos[] = $header;
				} else {
					$datos[$key] = substr($header,strlen($key)+2);
				}
 
				unset($key);
			} else {
				$datos[] = $header;
			}
		}
	}
 
	fclose($socket);
 
	return $datos;
}

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