Podeis consultarlo en http://dev.dubasdey.com/dic_es_as/

El error es debido a que las cabeceras de coreo se procesan como datos de 7 bits. Para corregir esto hemos de codificar la linea subject para usar otra codificación, la mas típica es la Base64 (“B”).

Para la codificación del subject en Base 64 debemos simplemente de crear una nueva cadena de Subject con el formato


=?CHARSET?B?CODIGOBASE64=?=


donde CHARSET es la codificación de la cadena (Ej: UTF-8 o ISO-8859-1) la B indica que la cadena ira codificada en Base64 y en el espacio donde eta CODIGOBASE64 ira la cadena del subject codificada.

de modo que quedaría algo tal que así en la cabecera (para la cadena “Acentos á é í ó &úacute; ñ ñ á é í ó &úacute;” y con codificación UTF-8 usando Base64):


Subject: Acentos =?UTF-8?B?w6Egw6kgw60gw7Mgw7ogw7Egw5Egw4Egw4kgw40gw5Mgw5o=?=


Otra cosa que podemos ver en este ejemplo es que no todo el Subject esta codificado, la palabra “Acentos” esta fuera de la codificación, se pueden codificar solo partes del Subject y no el Subject entero.

Esto es muy &úacute;til especialmente en PHP , donde el envío de email se realiza a bajo nivel y no codifica automáticamente la cabecera.

Para realizar la codificación en Base64 en PHP tenemos la función base64_encode lo que nos hace el proceso mucho mas sencillo.

Como ya me comentaron en menéame acerca del anterior articulo, también existen otras funciones basadas en PERL , que son más potentes, pero no son tan compatibles como las pintan, ya que la mayoría de los servidores traen desactivada la compatibilidad con ellas. Por ello decidí usar solo las funciones nativas de PHP.

El ejemplo que vamos a usar es el de eliminar HTML de unos ficticios comentarios de cara a su almacenamiento en una DB. Para ello ya existe la función strip_tags($cadena,[excepciones]), pero haremos como si no existiera para probar las Expresiones Regulares.

Lo primero que tenemos que tener claro es que patrón debemos simular: Buscamos una cadena de caracteres "encerrada" entre unas posibles etiquetas de HTML (que pueden ser reales o no). Por ejemplo: <b>Texto</b> ó <melkorcete>Texto</melkorcete>. Pero también vamos a poder eliminar etiquetas de XHTML como <img src="ola" />. Con esto lograremos una Expresión Regular bastante completa.

Vamos a desglosarla por partes para ir poco a poco.


// Por definición, debe comenzar por < seguido de cualquier caracter distinto a
// < y que se puede repetir de una a infinitas veces. Se cierra con > o sin él
// (de cara al XHTML se usa ? y no *)
$expresion = "<[^>]+>?";

// Lo que nos deja en total:
$expresion = "<[^>]+>?([^>|^<]*)]*>";


Una vez conseguido el patrón, ahora vamos a crear nuestra función en PHP. Esta debe tener un comportamiento recurrente para solventar un posible anidamiento de etiquetas. Es decir, que también reemplace <b><i>hola</i></b> o casos parecidos:


// Limpiar HTML de una funcion
// $opcion define si la cadena de salida usara previamente un htmlentities();
function limpiarHTML($cadena,$opcion) {
$expresion = "<[^>]+>?([^>|^<]*)]*>";

if ($opcion) {
return htmlentities($cadena);
} else {
return $cadena;
}


Con esta función ya tendríamos lo que necesitamos, que mientras que ereg() devuelva true (encontró una etiqueta) vaya reemplazando toda la etiqueta por solo el contenido.

Con esto creo que ya podéis haceros una idea del uso de las Expresiones Regulares , no obstante, próximamente pondré un artículo relacionado con .NET y las Regex.

Por lo general, si guardas los datos de tu página en una Base de Datos como MySQL, te habrás percatado de que al volcar los datos directamente con un print $fila["Columna"], no respetaba los saltos de carro (tecla enter) que no fueran creados en XHTML con <br />.

A partir de ahora no tendras ese problema, sólo tienes que usar esta función:

// Creamos la consulta y la ejecutamos
 $resultado = mysql_query("select * from posts where idpost = 2") or die (mysql_error());
 $fila = mysql_fetch_array($resultado);

 // Si solo quereis convertir el /n en  :
 print nl2br( $fila["POST"]);

// Si ademas quereis convertir el XHTML para evitar que se interprete:
 print nl2br(htmlentities($fila["POST"]));

A los que os preocupe un posible fallo de validación de XHTML, no os preocupeis, se renderiza con <br /> no con <br> así que es perfectamente válido.

Ahora que en la Web 2.0 se han puesto de moda las comunidades de promoción de noticias, todos tenemos que dejar de una manera accesible al usuario la posibilidad de enviar el permalink de nuestra web.

Por lógica también seria útil poder situarlos en nuestro RSS así que crearemos una función que genere el acceso a estos servicios sin repetir código.

 // Comunidades
 function getComunities($postid) {
     $posturl = "http://www.melkorcete.com/index.php?p="; // Tu web hasta la variable $_GET
     $url = htmlentities( $posturl.$postid);                               // De cara a validacion
     ?>
         <a href="http://del.icio.us/post?url=<?= $url ?>" target="_blank">
             <img src="icos/delicious_s.gif" alt="Add to del.icio.us" />
         </a>
         <a href="http://meneame.net/submit.php?url=<?= $url ?>" target="_blank">
             <img src="icos/menealo.png" alt="Menéalo" />
         </a>
         <a href="http://digg.com/submit?phase=2&url=<?= $url ?>" target="_blank">
             <img src="icos/digg.png" alt="Digg" />
         </a>
         <a href="http://tec.fresqui.com/post?url=<?= $url ?>" target="_blank">
             <img src="icos/fresqui.png" alt="Fresqui" />
         </a>
         <a href="http://www.blogmemes.com/post.php?url=<?= $url ?>" target="_blank">
             <img src="icos/blogmemes.png" alt="BlogMemes" />
         </a>
         <a href="http://furl.net/storeIt.jsp?&u=<?= $url ?>" target="_blank">
             <img src="icos/toonfuse.png" alt="Furl" />
         </a>
         <a href="http://www.neodiario.net/submit.php?url=<?= $url ?>" target="_blank">
             <img src="icos/neodiario.png" alt="NeoDiario" />
         </a>
         <a href="http://www.melkorcete.com/index.php?p=<?= $postid ?>" target="_blank">
             <img src="icos/permalink.png" alt="Permalink" />
         </a>
     <?
 }

Ahora solo faltaría hace la llamada a esa función donde queráis que se incluyan nuestros enlaces. Estos ya están preparados para enviar correctamente, y los iconos podéis copiarlos de esta misma web, con click derecho / guardar imagen como…

Espero que os sea de utilidad.


$random = rand(1,lastPostID());
while (!postExist($random)) {
$random = rand(1,lastPostID());
}
header("Location: http://www.web.com/index.php?p=".$random);
?>


Después de esto solo quedaría explicar que significa lastPostID() y postExist(). Son dos funciones simples que utilizaremos para obtener el ultimo ID de nuestros posts de cara a saber la longitud máxima del random, y para saber si el random en cuestión existe o no. Mientras no exista seguirá recalculándose y volviendo a generar un random. Cuando una exista, lanzara el header y redireccionará la página. Aquí os dejo las funciones.


// Comprobar si un post existe
function postExist($idpost) {
if (is_numeric($idpost)) {
$resultado = mysql_query("select * from posts where idpost=".$idpost);
while ($fila=mysql_fetch_array($resultado)) {
return true;
}
}
return false;
}

// Obtener el ultimo POSTID
function lastPostID() {
$resultado = mysql_query("select max(IDPOST) as IDPOST from posts");
$fila=mysql_fetch_array($resultado);
return $fila["IDPOST"];
}


Sencillo ¿verdad? Ya no hay excusa para no estar a la última

\r\n Para empezar, el archivo será un .php para que el servidor ejecute nuestro código, pero para ello necesitamos engañar al navegador cambiando el content type del archivo, para que una vez ejecutado se interprete como XML y no como XHTML o HTML.


header("Content-type: text/xml; charset=ISO-8859-1",true);
print "";
?>


Inmediatamente después, comenzaríamos rellenando la información del channel manualmente excepto el <pubDate> que puede automatizarse. La parte interesante llega con los <item>. Haremos una consulta que nos devuelva las ultimas 25 entradas de nuestra página (esta os toca hacerla a vosotros, ya que cada modelo de datos es diferente, y no funcionaria una en general). Será del estilo a esta:


SELECT * FROM POSTS ORDER BY POSTID DESC LIMIT 0,25


Ahora utilizaremos esa consulta para recorrer los resultados generando un <item> por cada fila que nos devuelva. Para ello usaremos la conexión entre PHP y MySQL.\r\n

// Objeto de Conexión
$conexion = mysql_pconnect(\’RUTA_SERVIDOR\’,\’USUARIO\’,\’CONTRASEñA\’);
mysql_select_db(\’NOMBRE_BD\’,$conexion) or die(mysql_error());

?>


Como ya avise antes, hay que tener cuidado con las con las fechas del <pubDate>, para eso utilizo una función que me paso dubas que soluciona ese problemilla convirtiendo la fecha al formato de RFC 822 válido.


function makeDate($date) {
$dm=explode(\’ \’,$date);
$f=explode(\’-\’,$dm[0]);
$h=explode(":",$dm[1]);
return mktime($h[0],$h[1],$h[2],$f[1],$f[2],$f[0]);
}


Con esto ya tendríais la base de vuestro RSS, otras cosas que podéis añadirle, es controlar si se introducen valores por $_GET (rss.php?c=1) para tener RSS que filtre por categorías. Eso ya os lo dejo a vuestro criterio.

Cuando estaba haciendo el sistema de estadísticas de la web, me vino a la mente que muchos usuarios de los que tengo constancia que visitan o iban a visitar en un futuro la página navegan habitualmente tras un proxy. Yo quería almacenar las IPs de cara a una futura ampliación de las estadísticas en las que añadiera una localización geográfica, además de distinguir y eliminar mis propias visitas para una mayor transparencia dichas estadísticas.

Buscando información acerca de obtener la IP real (en los casos en los que fuera posible) me tropecé con un artículo interesante sobre como los distintos proxies alteran los datos del navegador para enmascarar su propia IP.

Por lo general el navegador envía la cabecera $_SERVER[\'REMOTE_ADDR\'] al servidor con la IP original del usuario. Si este no estuviera detrás de un proxy, esa sería la IP deseada, pero… ¿Cómo altera el proxy esta cabecera para ocultar los datos reales?

Todo depende del tipo de proxy que se esté utilizando. Un proxy Transparente, copia el contenido de $_SERVER[\'REMOTE_ADDR\'] en la cabecera $_SERVER[\'HTTP_X_FORWARDED_FOR\'] para justo a continuación colocar la suya propia en el $_SERVER[\'REMOTE_ADDR\'] confundiendo en el mayor de los casos a las páginas visitadas.

El resto de proxies son bastante más seguros, y no dan lugar a la obtención de la IP original (lo que en principio es lógico, ya que la mayoría de la gente los utiliza para ello). Los proxies Anónimos pueden ser de varios tipos, y cada uno de ellos oculta la información de una manera característica. Los simples, añaden su IP en ambas cabeceras, los ruidosos van un paso mas lejos, tratan de engañar aún más generando de forma aleatoria una IP para el \'HTTP_X_FORWARDED_FOR\' y ponen la suya en el \'REMOTE_ADDR\' ergo a los ojos de la página seria difícil discernir de un proxy de tipo transparente.

Los mas complejos son los de alta anonimicidad, ya que únicamente cambian la cabecera \'REMOTE_ADDR\' con su propia IP y dejan \'HTTP_X_FORWARDED_FOR\' en blanco, por lo que es prácticamente imposible determinar si se esta usando un proxy o no.

Después de esto ya estamos listos para enfrentarnos al código que comparte con nosotros Patxi Echarte en su página y que en encontrado de lo más útil.

function getRealIP()
{
         if ( $_SERVER['HTTP_X_FORWARDED_FOR'] != '' )
    {
        $client_ip =
            ( !empty($_SERVER['REMOTE_ADDR']) ) ?
                $_SERVER['REMOTE_ADDR']
                :
                ( ( !empty($_ENV['REMOTE_ADDR']) ) ?
                    $_ENV['REMOTE_ADDR']
                    :
                    "unknown" );
    
        // 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('[, ]', $_SERVER['HTTP_X_FORWARDED_FOR']);
    
        reset($entries);
        while (list(, $entry) = each($entries))
        {
            $entry = trim($entry);
            if ( preg_match("/^([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/", $entry, $ip_list) )
            {
                // http://www.faqs.org/rfcs/rfc1918.html
                $private_ip = array(
                        '/^0\./',
                        '/^127\.0\.0\.1/',
                        '/^192\.168\..*/',
                        '/^172\.((1[6-9])|(2[0-9])|(3[0-1]))\..*/',
                        '/^10\..*/');
    
                $found_ip = preg_replace($private_ip, $client_ip, $ip_list[1]);
    
                if ($client_ip != $found_ip)
                {
                    $client_ip = $found_ip;
                    break;
                }
            }
        }
    }
    else
    {
        $client_ip =
            ( !empty($_SERVER['REMOTE_ADDR']) ) ?
                $_SERVER['REMOTE_ADDR']
                :
                ( ( !empty($_ENV['REMOTE_ADDR']) ) ?
                    $_ENV['REMOTE_ADDR']
                    :
                    "unknown" );
    }
    
    return $client_ip;
    
}

Espero que os sea de utilidad y gracias de nuevo a Patxi por su artículo.

Apache : descarga gratuita.

PHP : descarga gratuita.

MySQL : descarga gratuita.

Instalación PHP:

Con diferencia la más sencilla de las tres instalaciones. Se descarga el archivo comprimido, mismamente en c:\\php\\, se copia el archivo php4ts.dll de c:\\php\\ a c:\\%SYSTEMROOT%\\SYSTEM32 (ya sea WINNT o WINDOWS), y finalmente se renombra el php.ini-dist a php.ini y se coloca en c:\\%SYSTEMROOT%\\ . Y listo, aunque como añadido también debéis saber que para conectar PHP con algunas SBD\’s es necesario descomentar en el php.ini la dll de conexión. Por ejemplo en ORACLE: extension=php_oci8.dll

Instalación Apache:

Esta vez dispondremos de un ejecutable (tras descomprimir si estuviera comprimido), solo tendremos que ejecutarlo y rellenar tres casillas. Network Domain -> 127.0.0.1 ; Server Name -> 127.0.0.1 ; Administrator\'s Email -> sumail@suproveedor.com. Después seleccionamos la instalación completa y listo. Por defecto os quedará instalado como un servício y con arranque automático. Para modificar esto Inicio / Ejecutar / services.msc , seleccionáis el Apache y doble click. Y ponéis la configuración que queráis. Además del Apache os agrega un acceso directo a Arrancar, Reiniciar y Parar el servicio de Apache. El de reiniciar es muy útil, ya que cada cambio que se haga en la configuración requerirá un reinicio.

El primero de estos cambios será añadirle la carga del módulo de PHP (para que el Apache pueda ejecutar el código PHP). Basta con abrir desde el menú de inicio el archivo httpd.conf que viene con el propio Apache y añadir abajo del todo estas dos líneas:


LoadModule php4_module c:/php/sapi/php4apache.dll
AddType application/x-httpd-php .php


También es recomendable crear una carpeta para el contenido del server (por ejemplo: "c:\\apache"), y cambiar el parámetro DocumentRoot "c:\\apache\\".

Ahora reiniciar el Servidor Apache con el acceso directo mismamente y aseguraros de tener abierto el puerto 80 (a no ser que queráis cambiarlo, también en el php.ini, la opción Listen: 80) para que tengan acceso a vuestro server desde fuera de la red local.

Para hacer una prueba podéis usar cualquiera de los clásicos:


<?php
phpinfo();
?>

<?php
echo "Hello World!";
?>


Si entráis al localhost directamente debería deciros el ya mítico mensaje:

“¡Funcionó! ¡El Servidor de Red Apache ha sido instalado en ese sitio!", y luego si ejecutáis el código, deberá mostraros el mensaje de Hola Mundo, o la información del sistema.

Instalación MySQL:

Ahora nos toca finalizar con la instalación del AMP, y es el turno del SBD MySQL. Para la instalación, descomprimimos el archivo descargado, ejecutamos el setup.exe y les decimos que instale mismamente en c:\\mysql\\ (sobre todo de cara a evitar posteriores cambios en la configuración). Tras la instalación, lo más útil para su posterior manejo, es convertir el servidor en un servicio de windows. Para ello basta con ejecutar: c:\\mysql\\bin\\mysqld --install . Así pues, podéis crearos unos bat para manejarlo simplemente con las órdenes net start mysql para arrancarlo y net stop mysql para detenerlo.

Pues solo con estos sencillos pasos tendréis instalado todo lo necesario para empezar a programar en PHP sobre Apache con bases de datos de MySQL. A disfrutar y no os perdáis algunos trucos que pondre por aquí.

En PHP las clases se pueden serializar en una cadena de datos mediante la función serialize de PHP, la cual convierte los datos de nuestra clase en una cadena de valores.

Así mismo las clases serializadas se pueden volver a recuperar con la función unserialize devolviendo los valores de la clase otra vez a la misma para recuperar su estado.

Hasta aquí todo bien, pero que pasa si queremos realizar alguna función extra, o por ejemplo que nuestra clase se conecte con una base de datos y queramos restaurar el recurso de la conexión, ya que aunque tengamos la variable que indica el recurso del enlace de conexión este no seguirá activo. Pues bien, que no cunda el pánico, ya que hay unas funciones “mágicas” para ello en PHP que nos permiten hacer operaciones antes de serializar y después de serializar, con las que podemos guardar información a las variables globales y preparar nuestra clase para serializarse con todos los parámetros que necesitemos, y para después volver a restaurar correctamente la clase.

Antes de serializar usando la clase con serialize, si se trata de una clase, PHP llamara a la función mágica __sleep() de nuestra clase (que nosotros crearemos), en ella haremos todas las operaciones que necesitemos grabando los datos en variables de la clase, y posteriormente se serializara dicha clase.

Por el contrario al restaurar la clase con unserialize, este restaurara primero los valores de las variables y procederá a llamar (si existe) a la función __wakeup() para que realice el proceso que se requiera para la restauración de la clase.

Un ejemplo de una clase de conexión serializable.

class Connection {
var $link;
var $server;
var $username;
var $password;
var $db;

public function __wakeup(){
$this->connect();
}
}


Un ejemplo de la serialización y guardado en un archivo de una clase

// Creamos nuestra clase de conexion
$con = new Conexion("localhost","root","root","test");

// guardamos en un archivo la clase
$gestor = fopen("clase.txt", 'a'));
fwrite($gestor, $miClaseparaGuardar );
fclose($gestor);


Y un ejemplo de como recuperamos la clase anteriormente serializada

// Recuperamos los datos de la clase
$gestor = fopen("clase.txt", 'r'));
$contenido = fread($gestor, filesize("clase.txt"));
fclose($gestor);

// Volvemos a su estado la clase. (debe existir la definición de la clase lógicamente xD)
$con = unserialize($con);