Una buena práctica para que aparezcamos antes en Google es añadir a estos servicios de actualización la URL blogsearch de Google.

Todos los desarrolladores que no quieran utilizar Wordpress y crean mejor sus propios blogs o proyectos deben de tener en cuenta los ping XML-RPC para avisar de su nuevo contenido. Así que hoy he tenido que realizar una función que realice ping de forma automática como lo hace Wordpress. Para empezar buscaremos la función de Wordpress que se encarga los ping XML-RPC y la extraeremos y modificaremos a nuestro gusto. Empecemos:

¿Que son los ping XML-RPC?

Una forma clara de poder explicar los ping XML-RPC es imaginarse dos ordenadores, uno de ellos sera un cliente, nuestro caso es donde tenemos nuestro blog, y el ordenador un servidor que se encargara de recibir el ping. El ordenador cliente mandará una petición, comunicándose mediante Internet usando el estándar XML. El servidor ejecutará esta petición examinando que clase o método debe llamar para procesar la petición. Una vez terminado de ejecutar, el servidor enviará la respuesta hacia el cliente. Para más información puedes visitar la Wikipedia

¿Cómo puedo hacer ping XML-RPC con PHP?

Una vez extraída la función weblog_ping de Wordpress implementarla para nuestros proyectos es realmente sencillo. Primero deberemos de descargar la librería encargada de realizar los ping XML-RPC, llamada IXR y su sitio oficial para descargar es scripts.incutio.

Cuando hayamos descargado la librería IXR la incluiremos en nuestro proyecto para poderla llamar desde nuestra propia función weblog_ping, que será la encargada de realizar los ping a las distintas URL.

function weblog_ping($server = "") 
{
	// Incluimos la clase IXR
	include_once ("class-IXR.php");

	// Realizamos la conexión con la URL
	$client = new IXR_Client($server, false);
	// Esperamos un tiempo de respuesta de 3 segundos
	$client->timeout = 3;
	// Useragent que queramos por el cual nos identifique el servidor, podeis poner cualquiera.
	$client->useragent .= " -- El useragent que queramos utilizar";

	// Deberemos decir False ya que si no nos mostrara toda la peticion desde que sale del cliente hasta la respuesta del cliente
	// Si teneis problemas habilitarla para ver que esta pasando
	$client->debug = false;

	// Ejecutamos la peticion al servidor indicando que deseamos que ejecute el procedimiento extendedPing del servidor, que sera el encargado de recorrer nuestra URL en busca de cambios
	if( $client->query("weblogUpdates.extendedPing", "El nombre de nuestro blog", "URL de nuestro blog", "URL de nuestro RSS" )
		echo "Servidor: " . $server . " OK";
	else
		echo "Servidor: " . $server . " ERROR";
}

Finalmente para que nuestro blog llame a las distintas URL de servicios de actualización deberemos llamar a la función weblog_ping pasándole como argumento a que servidor queremos realizar el ping XML-RPC.

// Ping a bitacoras
weblog_ping("http://ping.bitacoras.com");

// Ping a technorati
weblog_ping("http://rpc.technorati.com/rpc/ping");

// Ping a blogalaxia
weblog_ping("http://ping.blogalaxia.com");

// Ping a google
weblog_ping("http://blogsearch.google.com/ping/RPC2");

Ya solo nos queda realizar por ejemplo una tabla con distintas URL de ping o un campo en una tabla opciones con varias URL y luego extraer la información de la base de datos y finalizarlo con un bucle para que llame a las distintas URL de forma dinámica. Pero ya estas pinceladas es a gusto de cada uno.

Más información: Javieraroche o blogterrier

Antes que nada necesitaremos descargarnos dos ficheros que contendrán la información de los diferentes países y el método para detectarlos. Los ficheros se tratan de geoip.inc y GeoIP.dat.

Una vez que nos hagamos con los ficheros, vamos a crear un fichero llamado geoIP.php (por ejemplo) y colocaremos los ficheros descargados en el mismo sitio. A continuación debemos incluir el siguiente código PHP en el fichero geoIP.php que nos devolverá el País al que pertenece el usuario por la IP:

function geoIP()

{
	// Incluimos la libreria
	require( 'geoip.inc' );

	// Variables

	$gIP = null;
	$sGeo = null;

	// Instanciamos la variable y le indicamos el fichero .dat y el tipo de Geolocalizacion
	$gIP = geoip_open( 'GeoIP.dat', GEOIP_STANDARD );

	// Obtenemos el Pais por la IP
	$sGeo = geoip_country_name_by_addr( $gIP, $_SERVER['REMOTE_ADDR'] );

	// Cerramos
	geoip_close( $gIP );

	return $sGeo;

}

Con ésta sencilla función podremos obtener la procedencia de un visitante a través de la IP, ya lo que hagamos con ésta información es cosa nuestra.

Fuente: ManualDePHP

Solucionar error Fatal error Allowed memory size

Deberemos modificar nuestro php.ini con el editor que más nos guste, en mi caso el editor nano. En este servidor tengo instalado Xampp y editaremos el archivo php.ini de la siguiente forma:

nano /opt/lampp/etc/php.ini

Una vez abierto buscaremos la línea que contenga “memory_limit = XXM” en mi caso “memory_limit = 32M” y lo sustituimos por “memory_limit = 64M”. De esta forma reservaremos memoria suficiente para poder instalar Symfony y poder ejecutar los Script que necesiten más memoria en su procesamiento.

Una vez editado el archivo y guardado deberemos reiniciar Apache para que los cambios realizados hagan efecto. Ahora cuando ejecutemos un Script que necesite más memoria se podrá realizar sin ningún tipo de problema. En mi caso sólo necesitaba 64M, pero si estas realizando un gran Script puedes poner el tamaño que más se amolde a tus necesidades

Las figuras que nos deja dibujar PHP con la librería GD son las más básicas, como puede traernos cualquier editor de imágenes básico. Vamos a ver como se crean las siguientes figuras: rectángulo, cuadrado, y círculo. Para ello necesitamos tener habilitado la librería GD para nuestro servidor PHP. Antes de empezar podéis echar un vistazo a como crear imágenes en Html mediante PHP GD.

¿Como dibujar un rectángulo en PHP GD?

Una de las figuras más simples que todos conocemos, y para crearlo utilizaremos la función “imagefilledrectangle” para crear un rectángulo con relleno o la función “imagerectangle” para dibujar solo el contorno.

// Tamaño de la imagen
$imImage = @imagecreate( 600, 100 );
// Color de fondo en RGB
$imFondo  = imagecolorallocate( $imImage, 255, 255, 255 );
// Color de relleno en RGB
$imRelleno = imagecolorallocate( $imImage, 141, 203, 61 );

// Creamos la instancia del rectangulo
imagefilledrectangle( $imImage, 0, 0, 300, 50, $imRelleno );

// Cabecera php para mostrar imagenes
header("Content-type: image/png");
// Imprimimos la imagen en PNG
imagepng( $imImage );
// Liberamos la memoria usada para crear la imagen
imagedestroy( $imImage );

¿Como dibujar un cuadrado en PHP GD?

Las funciones para realizar un cuadrado son exactamente iguales que realizar un rectángulo pero lógicamente añadiremos el mismo ancho y alto.

// Tamaño de la imagen
$imImage = @imagecreate( 600, 100 );
// Color de fondo en RGB
$imFondo  = imagecolorallocate( $imImage, 255, 255, 255 );
// Color de relleno en RGB
$imRelleno = imagecolorallocate( $imImage, 141, 203, 61 );

// Creamos la instancia del cuadrado
imagefilledrectangle( $imImage, 0, 0, 50, 50, $imRelleno );

// Cabecera php para mostrar imagenes
header("Content-type: image/png");
// Imprimimos la imagen en PNG
imagepng( $imImage );
// Liberamos la memoria usada para crear la imagen
imagedestroy( $imImage );

¿Como dibujar un circulo en PHP GD?

Para dibujar un circulo tendremos que utilizar la función “imageellipse” para realizar el contorno y “imagefilledellipse” para rellenarla de color.

// Tamaño de la imagen
$imImage = @imagecreate( 600, 100 );
// Color de fondo en RGB
$imFondo  = imagecolorallocate( $imImage, 255, 255, 255 );
// Color de relleno en RGB
$imRelleno = imagecolorallocate( $imImage, 141, 203, 61 );
// $imImage : identificador de la imagen creado
// 25: Coordenada horizontal del centro del ciruclo
// 25: Coordenada vertical del centro del circulo
// 50: Ancho del circulo
// 50: Alto del circulo
// $imRelleno: Color del relleno
imagefilledellipse( $imImage, 25, 25, 50, 50, $imRelleno );
// Cabecera php para mostrar imagenes
header("Content-type: image/png");
// Imprimimos la imagen en PNG
imagepng( $imImage );
// Liberamos la memoria usada para crear la imagen
imagedestroy( $imImage );

Para crear nuevas figuras, como por ejemplo un arco tenéis más funciones. Podéis pasaros por el fantástico manual de PHP GD y ver todas las funcionalidades de la libreria GD.

Mostrar fecha y hora con formato “Hace x horas, x minutos, x segundos” en PHP

Primero debemos de convertir el valor del campo timestamp en fecha de unix (segundos desde 1970-01-01 00:00:00 GMT), usando la función UNIX_TIMESTAMP de SQL.

SELECT *, UNIX_TIMESTAMP( CAMPO_FECHA_HORA ) FROM TABLA

A continuación, a la hora de mostrar dicho campo, pasaremos el resultado del campo “CAMPO_FECHA_HORA” por esta función:

function hace($fecha_unix)
        //obtener la hora en formato unix
        $ahora=time();
        
        //obtener la diferencia de segundos
        $segundos=$ahora-$fecha_unix;
        
        //dias es la division de n segs entre 86400 segundos que representa un dia;
        $dias=floor($segundos/86400);

        //mod_hora es el sobrante, en horas, de la division de días;    
        $mod_hora=$segundos%86400;
        
        //hora es la division entre el sobrante de horas y 3600 segundos que representa una hora;
        $horas=floor($mod_hora/3600);
        
        //mod_minuto es el sobrante, en minutos, de la division de horas;       
        $mod_minuto=$mod_hora%3600;
        
        //minuto es la division entre el sobrante y 60 segundos que representa un minuto;
        $minutos=floor($mod_minuto/60);
        
        if($horas<=0){
                echo $minutos." minutos";
        }elseif($dias<=0){
                echo $horas." horas ".$minutos." minutos";
        }else{
                echo $dias." dias ".$horas." horas ".$minutos." minutos";
        }

De esta manera, usando esta función, tendremos el campo fecha hora en un formato mucho más amigable para el usuario. También hay que saber donde aplicar este tipo de formato y donde encaja mejor un formato clásico, pero siempre es bueno tener una alternativa útil de cara al usuario.

Fuente: RibosoMatic

¿Que son las directivas open basedir y Safe Mode?

El Modo Seguro de PHP (Safe Mode) es un intento para resolver el problemas de seguridad en un servidor compartido. Trata de resolver este problema a nivel de PHP verificando si el dueño del script actual coincide con el dueño del fichero a ser operado por una función de fichero (readfile(), mkdir(), etc).

Mientras que la directiva open basedir limita la interacción de los archivos con archivos fuera de la carpeta donde se está ejecutándose el script actual.

¿Como “salto la protección” open basedir y Safe Mode para Curl en servidores compartidos?

En servidores compartidos, como por ejemplo 000webhost, tenemos este problema a la hora de ejecutar un script Curl con FollowLocation. Desde el manual oficial de PHP encuentro que el usuario eion ha realizado una función para corregir este problema. Para entender la función y simplificar su explicación lo que realiza realmente es la primera petición curl obteniendo solo la cabecera, donde en ella podemos encontrar la redirección 301. Volverá a realizar la petición pero esta vez a la redirección y así sucesivamente. Es una buena alternativa para “saltarse” open basedir y Safe Mode para Curl en servidores como 000webhost.

Obtener función Curl para que PHP realize el “salto de protección” open basedir y Safe Mode

El anterior post, “Curl en PHP“, dispone de esta función dando la posibilidad de realizar peticiones Curl en servidores como 000webhost que no disponen de open basedir Or Safe Mode.

Enlace: Descargar Curl para PHP

Función Curl para PHP

function followLocation($crCurl, &$crInfo)
{
    // Variables
    static $nCurlLoops = 0;
    $nCurlMaxLoops     = 20;

    $sPage             = null;
    $aMatches          = null;
    $aLastUrl          = null;
    $aUrl              = null;
    $sHeader           = null;

    // Si hemos realizado 20 redirecciones paramos

    if( $nCurlLoops >= $nCurlMaxLoops )
        return false;

    // Obligamos que la petición nos nuestre la cabecera para poder ver donde nos llevara la redireccion

    curl_setopt( $crCurl, CURLOPT_HEADER, 1 );

    // Ejecutamos curl
    $sPage = curl_exec( $crCurl );

    // Obtenemos información sobre la petición

    $crInfo = curl_getinfo( $crCurl );

    // Separamos la cabecera de lo que esl contenido de la página

    list( $sHeader, $sPage ) = explode( "\n\n", $sPage, 2 );

    if( in_array( $crInfo["http_code"], array( 301, 302 ) ) )

    {
        // Obtenemos la dirección donde se iba a realizar la redicción
        $aMatches = array();
        preg_match( "/Location:(.*?)\n/", $sHeader, $aMatches );

        $aUrl = @parse_url( trim( array_pop( $aMatches ) ) );

        // Comprobamos sea un array valido, de no serlo no podremos realizar la redirección

        if( ! is_array( $aUrl) )
            return $sPage;

        // Obtenemos desde donde se va hacer la redirección
        $aLastUrl = parse_url( curl_getinfo( $crCurl, CURLINFO_EFFECTIVE_URL ) );

        // Contruimos la url de la redirección
        if( ! $aUrl["scheme"] )
            $aUrl["scheme"] = $aLastUrl["scheme"];

        if( ! $aUrl["host"] )
            $aUrl["host"] = $aLastUrl["host"];

        if( ! $aUrl["path"] )

            $aUrl["path"] = $aLastUrl["path"];

        // Realizamos la petición con la nueva URL obtenida que sera la redicción

        curl_setopt( $crCurl, CURLOPT_URL, $aUrl["scheme"] . "://" . $aUrl["host"] . $aUrl["path"] . ($aUrl["query"]? "?" . $aUrl["query"] : "") );

        // Sumamos la redirección
        ++$nCurlLoops;

        return followLocation( $crCurl, $crInfo);
    }
    else
    {
        $crInfo["redirect_count"] = $nCurlLoops;

        return $sPage;
    }
}

function curl($aArgumentos, &$crInfo = false)
{
    // Variables
    $sUrl        = (! empty( $aArgumentos["url"] ) ? $aArgumentos["url"] : null);

    $sPostField  = (! empty( $aArgumentos["post"] ) ? http_build_query( $aArgumentos["post"] ) : null);
    $ckCookie    = (! empty( $aArgumentos["cookie"] ) ? $aArgumentos["cookie"] : null);

    $nHeader     = (! empty( $aArgumentos["header"] ) ? $aArgumentos["header"] : 0);
    $nReturn     = (! empty( $aArgumentos["return_transfer"] ) ? $aArgumentos["return_transfer"] : 1);

    $nTimeOut    = (! empty( $aArgumentos["time_out"] ) ? $aArgumentos["time_out"] : 30);
    $sAgent      = (! empty( $aArgumentos["agent"] ) ? $aArgumentos["agent"] : "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.0.8) Gecko/2009032609 Firefox/3.0.8");

    $sReferer    = (! empty( $aArgumentos["referer"] ) ? urlencode( $aArgumentos["referer"] ) : "-");

    $aReferer    = (! empty( $aArgumentos["aReferer"] ) ? $aArgumentos["aReferer"] : array() );
    $aProxys     = (! empty( $aArgumentos["proxy"] ) ? $aArgumentos["proxy"] : array() );

    $sUserPasswd = (! empty( $aArgumentos["user_passwd"] ) ? $aArgumentos["user_passwd"] : null);
    $aProxy      = null;

    $nRandom     = null;
    $crCurl      = curl_init();
    $sPage       = null;
    $aHeader     = array( "Accept: image/gif, image/x-bitmap, image/jpeg, image/pjpeg", "Connection: Keep-Alive", "Content-type: application/x-www-form-urlencoded;charset=UTF-8" );

    $nRandomRf   = null;

    // Comprobamos si nos han pasado un array con referers para modificar el referer

    if( count( $aReferer ) )
    {
        // Referer aleatorio
        $nRandomRf = rand( 0, count( $aReferer ) -1 );

        $sReferer  = str_replace( "[curl_text]" , $sReferer, $aReferer[$nRandomRf] );
    }

    // Opciones
    curl_setopt( $crCurl, CURLOPT_URL, $sUrl );
    curl_setopt( $crCurl, CURLOPT_HEADER, $nHeader );

    curl_setopt( $crCurl, CURLOPT_RETURNTRANSFER, $nReturn );
    curl_setopt( $crCurl, CURLOPT_HTTPHEADER, $aHeader );
    curl_setopt( $crCurl, CURLOPT_CONNECTTIMEOUT, $nTimeOut );
    curl_setopt( $crCurl, CURLOPT_REFERER, $sReferer );

    curl_setopt( $crCurl, CURLOPT_USERAGENT, $sAgent);

    if( $sUserPasswd )
        curl_setopt( $crCurl, CURLOPT_USERPWD, $sUserPasswd );

    if( count( $aProxys ) )

    {
        // Usamos un random para ir cambiando de proxys
        $nRandom = rand( 0, count( $aProxys ) - 1 );

        $aProxy  = explode( ":", $aProxys[$nRandom] );

        curl_setopt( $crCurl, CURLOPT_CONNECTTIMEOUT, 60 );

        curl_setopt( $crCurl, CURLOPT_PROXY, $aProxys[$nRandom] );

        curl_setopt( $crCurl, CURLOPT_HTTPPROXYTUNNEL, 0);
    }

    if( $sPostField )
    {
        curl_setopt( $crCurl, CURLOPT_POST, 1 );
        curl_setopt( $crCurl, CURLOPT_POSTFIELDS, $sPostField );

    }

    if( $ckCookie )
    {
        curl_setopt( $crCurl, CURLOPT_COOKIEJAR, $ckCookie );
        curl_setopt( $crCurl, CURLOPT_COOKIEFILE, $ckCookie );
    }

    // open basedir Or Safe Mode

    if( ini_get( "open_basedir" ) == "" && ini_get( "safe_mode" == "Off" ) )
    {
        curl_setopt( $crCurl, CURLOPT_FOLLOWLOCATION, 1 );

        $sPage = curl_exec( $crCurl );

        $crInfo = curl_getinfo( $crCurl );
    }
    else
        return followLocation( $crCurl, $crInfo );

    // Comprobamos si ha sido exitosa la conexion de no serlo volvemos hacerla
    if( ! in_array( $crInfo["http_code"], array( 200, 302, 301 ) ) )

        curl( $aArgumentos );

    // Si la conexión ha sido posible cerramos
    if( in_array( $crInfo["http_code"], array( 200, 302, 301 ) ) )

        curl_close( $crCurl );

    return( $sPage );
}

Argumentos para la función Curl

Ejemplo: Cambiar estado de Twitter mediante Curl

curl(array( "url"         => "http://twitter.com/statuses/update.json",
            "post"        => array( "status" => "Hola desde PHP!" ),

            "user_passwd" => "keldrox:password"
));

Una simple función Curl para PHP que nos ayudará a la hora de desarrollar scripts que necesiten realizar muchas peticiones. Ya que su simpleza enviando solo argumentos nos ayuda estar escribiendo muchas líneas de opciones para las peticiones Curl, aparte de tener un código más simple.

Enlace: Descargar Curl para PHP

Subir o realizar upload de archivos a un servidor es una de las tareas más complicadas a mi parecer para los formularios HTML, ya que es un proceso que necesita interactuar con el usuario que sube el archivo, mostrando un porcentaje y confirmando de que el archivo ha sido subido (sin contar temas de seguridad, cosa que añade más dificultad si cabe). Todo esto para que quede acorde con nuestros diseños y de una apariencia más de aplicación de escritorio, necesitamos realizarlo mediante Javascript. Anieto2k publica un interesante enlace en el que podremos arrastrar imágenes desde nuestro escritorio al explorador con la beta 1 de Firefox 3.6. El realizar Drag & Drop desde el escritorio es posible gracias al FileAPI, propuesta por la W3C, y la subida del archivo sin recargar viene de la mano del objeto XMLHttpRequest (Ajax). Veamos varios ejemplos de como subir archivos con Javascript, flash y FileApi W3C:

Subir archivos mediante Mootools

Sin duda Mootools es una de mis librerías preferidas, además cuenta con bastantes plugins. Uno de ellos es FancyUpload que nos permite subir múltiples archivos hacia nuestro servidor.

Descargar FancyUpload

Demo de FancyUpload

Subir archivos mediante Jquery

Uploadify es un plugin para Jquery que convierte los input file de nuestro formulario a objetos flash para poder realizar la subida de nuestros archivos. Permite la subida sola de un archivo o de múltiples.

Descargar Uploadify

Demo de Uploadify

Subir archivos mediante Flash

Unijimpe creó hace tiempo un sencillo script en FLash que nos permite subir archivos hacia nuestro servidor. Permite la subida de un solo archivo, pero como ejemplo y ver como realmente funciona la clase FileReference de Flash para subir archivos tenéis estos enlaces.

Descargar Upload Flash

Demo Upload Flash

Subir archivos mediante FileApi W3C

Con la salida de los nuevos estándares disponemos de FileApi, la encargada de poder arrastrar nuestros archivos desde el escritorio hacia el explorador y poder subirlos. Para utilizar la demo necesitamos de la versión beta 1 de Firefox 3.6.

Descargar FileApi

Demo FileApi

Como vemos, el proceso de subir un fichero a la web no es fácil, pero gracias a estas útiles herramientas tenemos a nuestra disposición un mundo de interactividad. Además, con la salida de los nuevos estándares, nos acercamos más a la interactividad entre hombre, computador y web; finalidad de la evolución de Internet y las comunicaciones.

Html que obtendremos mediante DOMDocument

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" 
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" dir="ltr" lang="es-ES">
	<head>
		<title>Ejemplo</title>
		<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
		<meta name="language" content="es" />
	</head>
	<body>
		<table>
			<tr><td>Soy una</td></tr>
			<tr><td>tabla</td></tr>
		</table>
	</body>
</html>

Ejemplo práctico en PHP para obtener Html de un DOMElement

<?php
	// Variables
	$dcDocument = new DOMDocument();
	$dmTabla    = null;

	// Cargamos el HTML
	$dcDocument->loadHTML( "<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
							<html xmlns="http://www.w3.org/1999/xhtml" dir="ltr" lang="es-ES">
								<head>
									<title>Ejemplo</title>
									<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
									<meta name="language" content="es" />
								</head>
								<body>
									<table>
										<tr><td>Soy una</td></tr>
										<tr><td>tabla</td></tr>
									</table>
								</body>
							</html>" );

	// Nos posicionamos en la tabla
	$dmTabla = $dcDocument->getElementsByTagName( "table" )->item(0);

	// Pintaremos solo la tabla pasando el objeto DOMElement para obtener el Html
	echo getHtml( $dmTabla );

function getHtml($dcNode)
{
    $dcAux = new DOMDocument( "1.0" );
    $dcNodeAux = $dcAux->importNode( $dcNode->cloneNode( true ), true );
    $dcAux->appendChild($dcNodeAux);

    return $dcAux->saveHTML();
}
?>

Función que realiza el paso DOMElement to Html

function getHtml($dcNode)
{
    $dcAux = new DOMDocument( "1.0" );
    $dcNodeAux = $dcAux->importNode( $dcNode->cloneNode( true ), true );
    $dcAux->appendChild($dcNodeAux);

    return $dcAux->saveHTML();
}

Una sencilla solución basada en el comentario de Daniel Morlock en la documentación de PHP.

Como utilizar variables PHP en CSS

Añadimos a nuestra cabecera la hoja de estilo

<link rel='stylesheet' type='text/css' href='estilo.css' />

Archivo estilo.css

<?php
    header("Content-type: text/css; charset: UTF-8");

   $color1 = '#FFFFFF';
   $color2 = '#FFCC33';
?>

#cabecera
{
   background-color: <?php echo $color1; ?>;
}

a
{
  color: <?php echo $color2; ?>;
}

Archivo .htaccess

<FilesMatch "^.*?estilo.*?$">
SetHandler php5-script
</FilesMatch>

Como vemos al poder usar variables PHP dentro del CSS se pueden extender otras ideas como, compresión por GZIP, atacar a MYSQL, etc. La configuración del archivo .htaccess es importante para que el archivo CSS sea procesado como un archivo PHP y así poder utilizar las variables.