En los títulos y los textos vais a encontrar unas cuantas citaciones cinematográficas (y si, soy un cinéfilo). Si no os interesan podéis fingir no verlas, ya que no son fundamentales para la comprensión de los post...

Este blog es la versión en Español de mi blog en Italiano L'arte della programmazione in C. Espero que mis traducciones sean comprensibles...

miércoles, 21 de noviembre de 2012

El último Apache II - El regreso
cómo escribir un módulo Apache en C - pt.2

Ok, lo admito, el título es preocupante, ya que se parece mucho a esto, pero, al ser la segunda parte de un discurso abierto, no se me ha ocurrido nada mejor. Tal vez me estoy haciendo viejo. Y si en un futuro post me plagio a mi mismo en el texto (así como en el título) avisadme, así cierro el blog antes de que sea demasiado tarde.

Sin embargo, como prometí, hoy voy a explicar cómo escribir, instalar y probar un módulo de Apache elemental. Así que si a alguien le apasiona el argumento, con esta base (¡que funciona!), podrá divertirse en escribir otros más complejos en la cara de aquellos que dicen "C no sirve para el desarrollo Web".

Nuestro modulo básico lo llamaremos, por ejemplo, myapmod. Vamos a empezar con el código, por supuesto:
#include <httpd.h>
#include <http_protocol.h>
#include <http_config.h>

// handler del modulo
static int myapmodHandler(
    request_rec *reqrec)
{
    // test handler
    if (! reqrec->handler || strcmp(reqrec->handler, "myapmod"))
        return DECLINED;

    // test metodo http
    if (reqrec->method_number != M_GET)
        return HTTP_METHOD_NOT_ALLOWED;

    // html output
    ap_set_content_type(reqrec, "text/html;charset=ascii");
    ap_rputs("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\">\n", 
                        reqrec);
    ap_rputs("<html>",  reqrec);
    ap_rputs("<head>",  reqrec);
    ap_rputs("<title>Modulo Apache Elementare</title>", reqrec);
    ap_rputs("</head>", reqrec);
    ap_rputs("<body>",  reqrec);
    ap_rputs("<h1>myapmod: il mio Modulo Apache elementare</h1>", 
                        reqrec);
    ap_rputs("</body>", reqrec);
    ap_rputs("</html>", reqrec);

    // salgo con OK
    return OK;
}

// register hooks del modulo
static void myapmodHooks(
    apr_pool_t *pool)
{
    // set hook handler
    ap_hook_handler(myapmodHandler, NULL, NULL, APR_HOOK_MIDDLE);
}

// estructura global del modulo
module AP_MODULE_DECLARE_DATA myapmod_module = {
    STANDARD20_MODULE_STUFF,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    myapmodHooks
};
¿Sencillo no? Y he añadido los oportunos comentarios en el código (un poco concisos, debo admitir), así que ni siquiera tengo que explicar cómo funciona. Y, como podréis ver cuando lo uséis por primera vez, el código HTML contenido en este documento se muestra correctamente por el navegador (ohhh... milagro).

Ahora pasamos a la compilación e instalación. Para mayor comodidad y gusto personal propongo una guía para Linux, pero os aseguro que el módulo básico se puede hacer también (si de verdad queréis sufrir) en Windows.

El requisito previo es, por supuesto, tener Apache instalado en el sistema. Buscad, con nuestro amigo Google, una de las millones de guías para convertir tu ordenador en un servidor LAMP (o WAMP) (no voy a describir el procedimiento para no alargar demasiado el discurso, pero, os lo garantizo, es bastante simple). Una vez instalado el servidor Apache hay que asegurarse de que el sistema también está preparado para compilar módulos de Apache: debe estar disponible el paquete apache2-prefork-dev, así que, para verificarlo, ejecutad:
dpkg -l | grep apache2
Y, si en la lista de paquetes que se muestra allí no está el paquete indicado, instaladlo con:
sudo apt-get install apache2-prefork-dev
Y ahora, por fin, podemos compilar e instalar con:
sudo apxs2 -c mod_myapmod.c 
sudo apxs2 -i mod_myapmod.la
Luego, necesitamos crear y editar dos archivos nuevos en el directory /etc/apache2/mods-available. Creamos/abrimos el primero con:
sudo gedit /etc/apache2/mods-available/myapmod.load
y dentro escribimos:
LoadModule myapmod_module /usr/lib/apache2/modules/mod_myapmod.so
A continuación, creamos/abrimos el segundo con:
sudo gedit /etc/apache2/mods-available/myapmod.conf
y dentro escribimos:
<Location /myapmod>
SetHandler myapmod
</Location>
A este punto no nos queda nada más que habilitar nuestro nuevo módulo y reiniciar el servidor Apache (lo que hará que arranquen todos los módulos habilitados, incluido nuestro myapmod):
sudo a2enmod myapmod
sudo /etc/init.d/apache2 restart
Si todo se hace correctamente, navegando con un browser a la URL http://localhost/myapmod se mostrará el código HTML insertado en nuestro módulo. Y si no funciona, entonces probad todos los pasos desde el principio, asegurándoos de que no os habéis perdido algunos errores reportados por el sistema. Buena suerte... (Yo, por supuesto, he probado todo el procedimiento antes de publicar el post, y estoy seguro de que funciona).

Es evidente que con este post no pretendo reinventar la rueda, ya que, si buscais en Google cómo construir un módulo elemental de Apache, vais a descubrir que muchos otros han publicado mucho antes que yo guías similares. ¿Pero queréis compararlo con leer la misma cosa escrita por vuestro C-blogger favorito?

Hasta el próximo post. 

jueves, 15 de noviembre de 2012

El último Apache
cómo escribir un módulo Apache en C - pt.1

De acuerdo, con un título como el de arriba, esto no puede ser, por supuesto, el post (prometido) sobre la optimización de código. Todavía estoy trabajando en ello, y yo no sé cuándo voy a terminar, así que mientras tanto, voy a publicar unos posts mas sencillos. Reitero el consejo de no contener la respiración esperando ese post (puede tardar mucho tiempo ...).

Vayamos al grano: esta vez voy a tratar de disipar un mito (aquí vamos otra vez): aquel del C en la programación Web.

He escuchado decir "C es un lenguaje universal, permite hacer casi cualquier cosa (bla, bla, bla ...), pero no se puede utilizar en el desarrollo Web, hacen falta otros lenguajes." Risa (controlada). Otra risa (larga, esta vez).

En mi opinión, de hecho, un (buen) programador C puede entrar en el mundo Web por la puerta grande: para empezar, la mayoría de los lenguajes utilizados en el desarrollo web son C-like (es decir, sus creadores se inspiraron en la sintaxis de C cuando los diseñaron): PHP, Java, C#, JavaScript, por nombrar sólo algunos. Y si son C-like son fácilmente asimilables por un experto en C. Y si nuestro experto sabe (al menos un poco) también de C++ (algo común entre los buenos programadores C) también el lado OOP de los lenguajes indicados será fácil de interpretar.

Entonces­, un (buen) programador C puede entrar en el mundo de la web muy rápidamente (aunque sólo sea por la forma mentís que posee), y os lo digo por experiencia personal, ya que he pasado por eso (¿entonces estoy diciendo que soy un buen programador de C?). Y, para señalar y completar el discurso (y sin querer ofender a nadie), no creo que el paso inverso sea tan simple (un programador Web puro que rápidamente se convierte en un buen desarrollador C). Sobre esta última afirmación, estoy, sin embargo, muy abierto a comentarios, objeciones e impresiones diferentes de las mias. Tal vez me equivoque.

Dejando, pues, el discurso del lenguaje puro y duro, paso al argumento aplicaciones (y, así, explicaremos el misterioso título de este post): la Web vive de Apache y Apache significa C. Se sabe que alrededor del 70% de los servidores web están basados en Apache (es un hecho), y, si bien es cierto que se puede trabajar durante mucho tiempo en el mundo Web sin tener que escribir un módulo de Apache, también es cierto que alguien tiene que haber escrito los módulos existentes y, tarde o temprano (y por diversas razones), alguien necesitará un modulo ad-hoc para una actividad particular o tendrá que tocar el código de un módulo existente: en este caso se necesitan buenos programadores C. También en el mundo Web. Y ya no hace falta decir nada más.

En mi próximo post voy a presentar un módulo elemental de Apache (que ya lo tengo casi listo), así veremos en práctica que significa lo que he dicho aquí arriba.

Hasta el próximo post.

viernes, 2 de noviembre de 2012

Still Alive

En el caso que alguna alma buena se haya preocupado por mi (relativamente) larga ausencia de estas páginas, quiero asegurarle: I'm still alive (en Inglés suena bien, ¿verdad?).

El hecho es que escribo este blog en mi tiempo libre, y, a veces, no lo tengo.

Otro hecho, más importante aún, es que siempre me gustaría escribir cosas interesantes (de escribir y, sobre todo, de leer) y, a veces, no me viene la inspiración.

El último hecho (sí, el último, así no se aburre nadie) es que, a veces, encuentras un buen argumento, pero te das cuenta de que, para describirlo bien, se necesita una gran cantidad de trabajo preparatorio (como escribir un programa de prueba complejo) y, debido al hecho numero 1 (véase más arriba), los tiempos se alargan...

OK: estoy escribiendo un post (para mí) interesante, del que (spoiler alert) os anticipo el tema: la optimización del código. Existe una amplia literatura sobre esto, pero cuantos se la han leído atentamente? Y cuántos ejemplos reales (con resultados de test) se describen en la literatura? Bueno, ya que hay muchas leyendas urbanas sobre el tema, y a menudo sazonadas con consejos de dudoso valor, he pensado presentar unos cuantos datos reales (espero) indiscutibles.

Y, ya que estoy, os voy a contar (escuchar, escuchar!) un pequeño percance que tuve, personalmente, sobre el tema.

Quedaros a la espera con confianza, pero, mientras tanto, no contengáis la respiración, porque todavía me falta un poco...


Hasta el próximo post.