Un demonio, daemon o dæmon (de sus siglas en inglés Disk And Execution MONitor), es un tipo especial de proceso informático no interactivo, es decir, que se ejecuta en segundo plano en vez de ser controlado directamente por el usuario. Este tipo de programas se ejecutan de forma continua (infinita), vale decir, que aunque se intente cerrar o matar el proceso, este continuará en ejecución o se reiniciará automáticamente. Todo esto sin intervención de terceros y sin dependencia de consola alguna.

Un ejemplo de demonio es Apache, permanece en ejecución en segundo plano esperando peticiones de páginas web para ser servidas. O cron que es un demonio temporal, es decir, realiza acciones basadas en el tiempo.

El primer paso que debemos tener en cuenta es qué va a realizar el demonio, Linux basa su programación en que cada programa resuelve un único problema pero lo hace bien. Para ilustrar esta entrada construiremos un demonio que supervise si el demonio Apache está funcionando.

Requisitos

Necesitamos un compilador de C, normalmente GCC, y las cabezeras de C para linux, esto en Debian se consigue con:

# apt-get install build-essential

Necesitaremos también un editor para escribir el código.

Estructura básica de un demonio

Durante la ejecución del demonio debemos realizar algunas tareas básicas que se resumen en:

• Hacer fork del proceso padre.
• Cambiar la máscara de fichero.
• Abrir los archivos de registros necesarios.
• Crear un identificador de sesión único.
• Cambiar el directorio de trabajo hacia un sitio más seguro.
• Cerrar los descriptores de ficheros estandard.
• Escribir el código del demonio propiamente.

El código

He comentado el código con lo más importante y está bastante autoexplicativo:

#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <syslog.h>
#include <string.h>

int main(void) {

  pid_t pid, sid;
  int apachePIDfile, apachePIDread, apachePID, daemonLogFileDesc;
  char buf[5], filename[255];        

  /* Forkeamos el proceso padre */
  pid = fork();
  if (pid < 0) {
    exit(EXIT_FAILURE);
  }
  /* Cuando tenemos un PID correcto podemos cerrar
   * el proceso padre.
   * Atención al control de errores, es una buena
   * técnica de programación comprobar todas las
   * situaciones donde se pueden dar errores. */
  if (pid > 0) {
    exit(EXIT_SUCCESS);
  }

  /* Cambiamos el modo de la mascara de ficheros */
  /* Hacemos esto para que los fichero generados por el
   * demonio sean accesibles por todo el mundo */
  umask(0);

  /* Abrimos los ficheros de logs del demonio */
  /* Esto es opcional pero como vamos a cerrar los descriptores
   * hacemos esto para que exista algo de comunicación con el demonio */
  daemonLogFileDesc = open ("log", O_WRONLY | O_CREAT, 0600);
  if (daemonLogFileDesc == -1) {
    perror ("Error en la apertura del log");
    exit (EXIT_FAILURE);
  }

  /* Creamos un nuevo SID */
  /* Esto se hace porque al haber matado al padre el hijo puede quedarse
   * en el sistema como un proceso zombie, generando un nuevo SID hacemos
   * que el sistema se haga cargo del proceso huérfano otorgándole un nuevo SID */
  sid = setsid();
  if (sid < 0) {
    perror("new SID failed");
    exit(EXIT_FAILURE);
  }

  /* Por seguridad, cambiamos el directorio de trabajo */
  if ((chdir("/")) < 0) {
    perror("Change the current work directory failed");
    exit(EXIT_FAILURE);
  }

  /* Cerramos los descriptores standard */
  /* El demonio no puede usar la terminal, por lo que estos
   * descriptores son inútiles y un posible riesgo de seguridad.*/
  close(STDIN_FILENO);
  close(STDOUT_FILENO);
  close(STDERR_FILENO);

  /* El código del demonio */
  /* Obtenemos el PID con el que está corriendo el proceso apache */
  apachePIDfile = open("/var/run/apache2.pid", O_RDONLY, 0600);
  if (apachePIDfile == -1) {
    perror("Error en la apertura del fichero");
    exit(EXIT_FAILURE);
  }
  apachePIDread = read (apachePIDfile, buf, sizeof(buf));

  /* El gran bucle! */
  /* El demonio ejecutara este bucle toda su vida,
   * abrirá un archivo del pseudo sistema de ficheros /proc
   * y comprobará que existe, si existe Apache está corriendo y lo escribe
   * en el log, en caso contrario sale. */
  while (1) {
    apachePID = atoi (buf);
    snprintf(filename, sizeof(filename), "/proc/%d/cmdline", apachePID);

    if ((open (filename, O_RDONLY, 0600)) == -1) {
      perror ("No puedo abrir el fichero en proc");
      exit(EXIT_FAILURE);
    } else {
      write (daemonLogFileDesc, "Apache running\n", 15);
      sleep(30); /* espera 30 segundos */
    }
  }
  exit(EXIT_SUCCESS);
}

Compilamos

Para compilar hacemos lo siguiente:

# cc daemon1.c -o daemon1

A falta de un nombre más original, he llamado al demonio daemon1.

Ejecución

Para ejecutarlo hacemos:

# ./daemon1

Podemos ver que está corriendo tanto en el lista de procesos con ps como mirando el fichero log que hemos creado.

tailf log
...
Apache running
Apache running
Apache running
...

Referencias

Es una traducción/adaptación de la guía Linux Daemon Writing HOWTO, que es más teórica y aquí he querido dar una aplicación práctica, aunque es obvio que existe demonios de monitorización más avanzado quería marcar bien los conceptos de la construcción de un demonio aplicados a un caso particular.

Introducción

No entramos en detalles sobre el hardware de la máquina, ya está instalado un sistema GNU/Linux Debian Squezee. Hemos contratado un servidor que incluye nombre DNS para nuestro dominio midominio.com.

El usuario

La ejecución del servidor debe ser bajo un usuario no privilegiado y sin shell válida en el sistema. En Debian, tras instalar Apache, se crea un usuario www-data para esta tarea, pero lo vamos a cambiar por otro por no mantener, en la medida de lo posible, los valores por defecto. Nuestro usuario será webuser que es bastante descriptivo de la labor que tendrá.

Creamos el grupo y el usuario y le asignamos contraseña:

# groupadd webuser
# useradd -d /home/webuser -s /bin/false -g webuser -m webuser
# passwd webuser
Introduzca la nueva contraseña de UNIX:
Vuelva a escribir la nueva contraseña de UNIX:
passwd: contraseña actualizada correctamente

Con esto contamos con el usuario, vamos a instalar Apache.

Instalando Apache

Vamos a instalarlo mediante la utilidad tasksel que es gráfica de consola y nos ahorra escribir.

# tasksel

De las opciones disponibles, elegimos la de Servidor Web, como vemos en la imagen, luego le damos a aceptar.

Tasksel

Instalará Apache y todas las dependencias.

Instalando

Ya podemos pasar a configurar el servidor.

Configurando Apache

La configuración que trae Debian para Apache es la que me hace elegir esta distribución frente a otras como CentOS que también es conocida por estar presente en muchos servidores web de internet. El primer fichero que vamos a configurar es /etc/apache2/envvars y añadimos el usuario y grupo que hemos creado.

# vim /etc/apache2/envvars

[...]
export APACHE_RUN_USER=webuser
export APACHE_RUN_GROUP=webuser
[...]

A continuación deshabilitamos los VirtualHosts que vienen por defecto para crear el nuestro, podemos crear tantos como sean necesarios.

# a2dissite 000-default
Site default disabled.
Run '/etc/init.d/apache2 reload' to activate new configuration!

Ahora creamos nuestro sitio empezando por crear la estructura de directorios. Para ello vamos a crear siguiendo la filosofía que vi en SuSE y me gustó.

# mkdir -p /server/midominio.com 

De esta forma, contamos con el directorio /server y de él colgaran todos los servidores virtuales.

Ajustamos los permisos del directorio:

# chown -R webuser.webuser /server

Configuramos ahora las stanzas para nuestro servidor, para ello creamos un nuevo fichero /etc/apache2/sites-available/misitio.

# vim /etc/apache2/sites-available/midominio.com

NameVirtualHost *:80
<VirtualHost *:80>
        ServerName midominio.com
        ServerAlias www.midominio.com
        ServerAdmin Email protegido.

        DocumentRoot /server/midominio.com/
        <Directory />
                Options FollowSymLinks
                AllowOverride all
        </Directory>
        <Directory /server/midominio.com/>
                Options FollowSymLinks Multiviews Indexes
                AllowOverride all
                Order allow,deny
                allow from all
        </Directory>

        ErrorLog /var/log/apache2/error.midominio.com.log
        LogLevel warn
        CustomLog /var/log/apache2/error.midominio.com.log combined
        ServerSignature Off
</VirtualHost>

Comentamos que permitimos AllowOverride a all para que podamos customizar el sitio a través de .htaccess y no tener que tocar mucho la configuración del servidor. También personalizamos los archivos de logs por si añadimos más servidores distinguir entre ellos.

Habilitamos el sitio.

# a2ensite misitio

Ya podemos arrancar el servidor.

# apache2ctl graceful

Ahora ya podemos abrir un navegador web y entrar en el sitio, aunque no tiene contenido, cosa que resolveremos ahora.

En nuestro panel de control habilitamos que tanto midominio.com como www.midominio.com resuelvan a nuestra web, luego podemos usar un truco como este para que por defecto se utilice las uves dobles que es mejor desde el punto de vista SEO.

Añadir contenido, el servidor FTP

El usuario no tiene shell, luego no podemos iniciar una sesión en el servidor para crear los archivos html que queramos servir ni copiarlos por ssh, así que desplegamos un servidor FTP, por razones más históricas que otra cosa, uso Proftpd que tiene una configuración modular similar a la de Apache. Tiene soporte de VirtualHost pero la limitación del protocolo hace que no se pueda usar el mismo puerto en todos los servidores, esto es, cada VirtualHost que configures estará asociado a un puerto.

Pasamos a instalarlo.

# apt-get install proftpd

Lo instalamos como servidor independiente.

La configuración es esta:

# /etc/proftpd/proftpd.conf -- This is a basic ProFTPD configuration file.
# To really apply changes reload proftpd after modifications.

# Includes DSO modules
Include /etc/proftpd/modules.conf

# Set off to disable IPv6 support which is annoying on IPv4 only boxes.
UseIPv6				off
# If set on you can experience a longer connection delay in many cases.
IdentLookups			off

ServerName			"Mi servidor FTP"
ServerType			standalone
DeferWelcome			off

MultilineRFC2228		on
DefaultServer			on
ShowSymlinks			on

TimeoutNoTransfer		600
TimeoutStalled			600
TimeoutIdle			1200

DisplayLogin                    welcome.msg
DisplayChdir               	.message true
ListOptions                	"-l"

DenyFilter			\*.*/

# Use this to jail all users in their homes
# DefaultRoot			~

# Users require a valid shell listed in /etc/shells to login.
# Use this directive to release that constrain.
# RequireValidShell		off

# Port 21 is the standard FTP port.
Port				0

# In some cases you have to specify passive ports range to by-pass
# firewall limitations. Ephemeral ports can be used for that, but
# feel free to use a more narrow range.
PassivePorts                  49152 65534

# If your host was NATted, this option is useful in order to
# allow passive tranfers to work. You have to use your public
# address and opening the passive ports used on your firewall as well.
# MasqueradeAddress		1.2.3.4

# This is useful for masquerading address with dynamic IPs:
# refresh any configured MasqueradeAddress directives every 8 hours
<IfModule mod_dynmasq.c>
# DynMasqRefresh 28800
</IfModule>

# To prevent DoS attacks, set the maximum number of child processes
# to 30.  If you need to allow more than 30 concurrent connections
# at once, simply increase this value.  Note that this ONLY works
# in standalone mode, in inetd mode you should use an inetd server
# that allows you to limit maximum number of processes per service
# (such as xinetd)
MaxInstances			30

# Set the user and group that the server normally runs at.
User				webuser
Group				webuser

# Umask 022 is a good standard umask to prevent new files and dirs
# (second parm) from being group and world writable.
Umask				022  022
# Normally, we want files to be overwriteable.
AllowOverwrite			on

# Uncomment this if you are using NIS or LDAP via NSS to retrieve passwords:
# PersistentPasswd		off

# This is required to use both PAM-based authentication and local passwords
# AuthOrder			mod_auth_pam.c* mod_auth_unix.c

# Be warned: use of this directive impacts CPU average load!
# Uncomment this if you like to see progress and transfer rate with ftpwho
# in downloads. That is not needed for uploads rates.
#
# UseSendFile			off

TransferLog /var/log/proftpd/xferlog
SystemLog   /var/log/proftpd/proftpd.log

<IfModule mod_quotatab.c>
QuotaEngine off
</IfModule>

<IfModule mod_ratio.c>
Ratios off
</IfModule>

# Delay engine reduces impact of the so-called Timing Attack described in
# http://security.lss.hr/index.php?page=details&ID=LSS-2004-10-02
# It is on by default.
<IfModule mod_delay.c>
DelayEngine on
</IfModule>

<IfModule mod_ctrls.c>
ControlsEngine        off
ControlsMaxClients    2
ControlsLog           /var/log/proftpd/controls.log
ControlsInterval      5
ControlsSocket        /var/run/proftpd/proftpd.sock
</IfModule>

<IfModule mod_ctrls_admin.c>
AdminControlsEngine off
</IfModule>

<VirtualHost midominio.com>
        ServerName "midominio.com"
        Port 21
        DefaultRoot /server/midominio
        <Limit LOGIN>
                AllowUser webuser
                AllowGroup webuser
                DenyAll
        </Limit>
        RequireValidShell off
        AllowOverwrite on
</VirtualHost>

Hemos cambiado el puerto FTP por el 0 para usar el 21 para el VirtualHost e indicamos que el usuario (webuser) no requiere de una shell valida.

Ahora podemos usar un cliente FTP, por ejemplo Filezilla para subir ficheros al servidor.

Y ya hemos terminado, hemos creado un servidor web desde cero, aun quedan cosas por hacer pero lo básico está cubierto, os invito a seguir navegando por el blog y veáis como configurar mod_deflate para servir contenido comprimido, mod_evasive para evitar ataques DDOS, o mod_expires para almacenar contenido estático en la caché del usuario.

Partimos de la misma configuración, tenemos dos servidores, cluster01 y cluster02 con las IPs 192.168.2.98 y 192.168.2.99 y una IP flotante 192.168.2.100

Configuradas ambas máquinas, instalamos los paquetes necesarios:

# apt-get install apache2

En nuestro caso, para la configuración de Apache editamos /etc/apache2/ports.conf y añadimos la IP flotante a la línea de NameVirtualHost así:

NameVirtualHost 192.168.2.100:80

Para que Apache no se levante al inicio ya que queremos que el que se encargue de esto es Heartbeat escribimos:

# update-rc.d apache2 remove

Y detenemos el servicio:

# /etc/init.d/apache2 stop

A continuación instalamos Heartbeat.

# apt-get install heartbeat

Y configuramos, estos ficheros de configuración se encuentran todos en /etc/ha.d/ y disponemos de plantillas para configurarlos en /usr/share/doc/heartbeat/. Podemos tomar ejemplo para configuraciones más específica.

Para el archivo ha.cf usamos la misma:

logfile /var/log/cluster.log
logfacility local0
warntime 5
deadtime 30
initdead 120
keepalive 2
bcast eth0
udpport 694
auto_failback on
node cluster01
node cluster02

La explicación

• logfile y logfacility: Fichero de log y nivel.
• warntime: Heartbeat avisará cuando un nodo falle tras 5 segundos.
• deadtime: Hearbeat confirmará que un nodo ha caído, 30 segundos.
• initdead: Tiempo máximo que Heartbeat esperará a que un nodo arranque, 60 segundos.
• keepalive: Especifica cada cuanto tiempo Heartbeat enviará paquetes para comprobar la disponibilidad de los nodos, 2 segundos.
• Las dos últimas líneas son las listas de nodos que conforman el cluster.

Para el fichero authkeys que es donde configuramos la comunicación entre los nodos del clúster, también para Debian podemos usar la original:

auth 2
2 sha1 clu$ter-4uth

Le asignamos los permisos para que sólo root tenga acceso.

# chmod 600 /etc/ha.d/authkeys

El último fichero cambia en Debian y es el haresources que queda con este aspecto:

cluster01 IPaddr2::192.168.2.100/24/eth0 apache2

Cambia la forma de escribir la IP flotante que está de una forma más completa y el script de inicio de Apache que en Debian es apache2.

Seguimos la entrada y la propagación se hace ejecutando el siguiente comando:

# /usr/share/heartbeat/ha_propagate

Levantamos el servicio.

/etc/init.d/heartbeat start

Ya está todo configurado, podemos probar a desactivar la interface de cluster01 y ver como al poco tiempo (el que hemos configurado) se levanta cluster02 para seguir sirviendo páginas.

La configuración entre CentOS y Debian es prácticamente la misma, pero tiene los suficientes detalles como para que los escriba aquí para no olvidar como se hace.

Lo he probado en Debian tanto Lenny con Apache/2.2.9 como Squezee con Apache/2.2.16.

mod_expires

El módulo viene de serie en ambas instalaciones y para activarlo simplemente hacemos:

# a2enmod expires

Y nos cargará el módulo. Pasamos a configurarlo, tenemos varias opciones que nos lo cuenta la entrada en la documentación de Apache:

Context: server config, virtual host, directory, .htaccess

Lo he probado en server config, virtual host y .htaccess tan sólo cambia donde vamos a escribir las reglas de vida de los tipos de archivo. En server config lo escribiriamos en un archivo:

# vim /etc/apache2/mods-available/expires.conf

y añadiríamos el siguiente contenido:

<IfModule mod_expires.c>
          ExpiresActive on
          ExpiresByType image/jpg "access plus 60 days"
          ExpiresByType image/png "access plus 60 days"
          ExpiresByType image/gif "access plus 60 days"
          ExpiresByType image/jpeg "access plus 60 days"
          ExpiresByType text/css "access plus 1 days"
          ExpiresByType image/x-icon "access plus 1 month"
          ExpiresByType application/pdf "access plus 1 month"
          ExpiresByType audio/x-wav "access plus 1 month"
          ExpiresByType audio/mpeg "access plus 1 month"
          ExpiresByType video/mpeg "access plus 1 month"
          ExpiresByType video/mp4 "access plus 1 month"
          ExpiresByType video/quicktime "access plus 1 month"
          ExpiresByType video/x-ms-wmv "access plus 1 month"
          ExpiresByType application/x-shockwave-flash "access 1 month"
          ExpiresByType text/javascript "access plus 1 week"
          ExpiresByType application/x-javascript "access plus 1 week"
          ExpiresByType application/javascript "access plus 1 week"
</IfModule>

La sintaxis es sencilla, sigue la siguiente regla:

ExpiresByType mime.type "<base> [plus] {<num> <type>}*"

donde

• base: Puede ser access, now o modification. now es igual a access.
• La clave plus es opcional. num debe ser un entero y type es uno de los siguiente:

• years
• months
• weeks
• days
• hours
• minutes
• seconds

Así, por ejemplo, le estamos diciendo al navegador del usuario que almacene los archivos de imágenes durante 60 días desde el primer acceso, los archivos multimedia durante un mes y así.

Una vez ajustados estos tiempos conforme a nuestras necesidades hacemos un enlace del archivo de configuración dentro de mods-enabled

# ln -s /etc/apache2/mods-available/expires.conf /etc/apache2/mods-enabled/

y reiniciamos el servidor.

# /etc/init.d/apache2 restart

Un error que me dio en este punto fue que no encontraba el archivo de mime types en la raiz del servidor, por si os encontrais este problema, el archivo está en la documentación de Apache del servidor y lo obtenemos así:

# zcat /usr/share/doc/apache2.2-common/examples/apache2/mime.types.gz > /etc/apache2/mime.types

Si nos decidimos a configurarlo a nivel de Virtual Host tenemos que añadir la configuración dentro de las directiva Directory

Y si preferimos que nuestros propios usuarios del servidor definan la esperanza de vida en sus .htaccess tenemos que permitir el Allow Override a Indexes para que la configuración del servidor pueda ser sobrescrita con las directivas incluidas en este archivo.

mod_deflate

Enviar todo lo que podamos de forma comprimida nos hará ahorrar ancho de banda y nuestro usuarios con conexiones lentas nos lo agradecerán, por eso vamos a habilitar el módulo encargado de hacer esto.

 # a2enmod deflate 

Este módulo ya viene con un fichero de configuración que se enlaza en mods-enabled por lo que sólo tenemos que añadir:

# vim /etc/apache2/mods-available/deflate.conf

  SetOutputFilter DEFLATE
  SetEnvIfNoCase Request_URI \.(?:gif|jpe?g|png)$ no-gzip dont-vary
  SetEnvIfNoCase Request_URI \.(?:exe|t?gz|zip|bz2|sit|rar)$ no-gzip dont-vary
  SetEnvIfNoCase Request_URI \.pdf$ no-gzip dont-vary

En esta configuración le decimos que comprima todo excepto imágenes, archivos ya comprimidos y pdf’s, podemos hacer que lo comprima todo pero para estos archivos específicos no nos merece la pena y sería un gasto de computación innecesario.

Resultados

Para comprobar los resultado podemos usar el mismo plugin de PageSpeed o instalarnos el plugin para Firefox LiveHeader y ver si nos dice la fecha en la que expira el contenido y si la codificación del contenido es gzip, como podemos ver en la siguiente imagen:

Live Header

También lo podemos comprobar por línea de comando así:

$ curl -I http://www.muspells.net/images/logo.png
HTTP/1.1 200 OK
Date: Mon, 01 Aug 2011 11:15:39 GMT
Server: Apache
Last-Modified: Wed, 09 Mar 2011 18:36:27 GMT
ETag: "1b1e197-1b3e-49e1101b340c0"
Accept-Ranges: bytes
Content-Length: 6974
Cache-Control: max-age=5184000
Expires: Fri, 30 Sep 2011 11:15:39 GMT
Content-Type: image/png

Requerimientos:

1. Tener activado mod_rewrite en nuestro servidor
2. PHP5-GD para trabajar con imágenes
3. Una imagen que será la marca de agua

Lo primero que hacemos es añadir a nuestro .htaccess las nuevas reglas para mod_rewrite que son las básicamente las mismas que en Tu Receta pero cambiamos la RewriteRule así:

RewriteEngine on
RewriteBase /
RewriteCond %{HTTP_REFERER} !^$
RewriteCond %{HTTP_REFERER} !^http://www.muspells.net/.*$      [NC]
RewriteCond %{HTTP_REFERER} !^http://www.muspells.net$      [NC]
RewriteRule ^(.*)\.(gif|jpg|png)$ image_script.php?image=$1\.$2   [R]

Cambiamos la regla de reescritura para que apunte a un script de PHP donde editaremos al vuelo la imagen para devolverla al REFERER con una marca de agua.

Hemos llamado al script image_script y lo hemos colocado en la raíz de documentos,

<?php

// En WordPress por ejemplo las imagenes se guardan en directorios,
// necesitamos el PATH completo a la imagen.
$URI = $_GET['image'];
$URI_PARSER = explode ('/', $URI);
$image = "/path/to/DocumentRoot/".$URI_PARSER[count($URI_PARSER) - 1];

switch (TRUE) {
   case stristr($image,'jpg'):
      $photoImage = ImageCreateFromJpeg("$image");
      break;
   case stristr($image,'gif'):
      $photoImage = ImageCreateFromGIF("$image");
      break;
   case stristr($image,'png'):
      $photoImage = ImageCreateFromPNG("$image");
      break;
}

ImageAlphaBlending($photoImage, true); 

// Añadimos aquí el fichero de marca de agua.
$logoImage = ImageCreateFromPNG("watermark.png");
$logoW = ImageSX($logoImage);
$logoH = ImageSY($logoImage); 

// Los 1's representan el margen con el margen superior izquierdo
ImageCopy($photoImage, $logoImage, 1, 1, 0, 0, $logoW, $logoH); 

ImagePNG($photoImage); // output to browser 

ImageDestroy($photoImage);
ImageDestroy($logoImage);
?>

El script colocará la imagen watermark.png en la esquina superior izquierda.

Cuando accedemos a alguna imagen de nuestro sitio de forma legítima la veremos así:

GNU

Mientras que si accedemos enlazando directamente la veremos así:

Fuentes:

1. Tu Receta: Evitar Hot-linking con .htaccess
2. El script
]]> http://www.muspells.net/blog/2011/02/anadiendo-marcas-de-agua-al-vuelo-para-evitar-hotlinking/feed/ 4