Foro - Perl en Español

En el Perl Cookbook, hay un capítulo entero (el 17, de la segunda edición) completamente dedicado al tema de Sockets, servidores, etc. La receta número 17 se dedica precisamente a cómo crear un servidor como si fuera un demonio:

17.17.1 Problem
You want your program to run as a daemon.

17.17.2 Solution
If you are paranoid and running as root, chroot to a safe directory:
chroot("/var/daemon")
or die "Couldn't chroot to /var/daemon: $!";
Fork once, and let the parent exit:
$pid = fork;
exit if $pid;
die "Couldn't fork: $!" unless defined($pid);
Close the three standard filehandles by reopening them to /dev/null:
for my $handle (*STDIN, *STDOUT, *STDERR) {
open($handle, "+<", "/dev/null")
|| die "can't reopen $handle to /dev/null: $!";
}
Dissociate from the controlling terminal that started us and stop being part of whatever process group we had been a member of:
use POSIX;

POSIX::setsid( )
or die "Can't start a new session: $!";
Trap fatal signals, setting a flag to indicate that we need to gracefully exit:
$time_to_die = 0;

sub signal_handler {
$time_to_die = 1;
}

$SIG{INT} = $SIG{TERM} = $SIG{HUP} = \&signal_handler;
# trap or ignore $SIG{PIPE}
Wrap your actual server code in a loop:
until ($time_to_die) {
# ...
}

En la receta que te he puesto están descritos los pasos necesarios para crear un demonio:
Traducido:

1.- Si eres paranoico y estás corriendo como root, chroot a un directorio seguro:


2.- fork() una vez, y deja que el padre termine:


3.- Cierra los tres manejadores de ficheros estándares reabriéndoles hacia /dev/null:


4.- Disóciate de la terminal que estás usando que se usó para arrancar y deja de formar parte del grupo de procesos del que fuimos miembros:


5.- Atrapa señales fatales, activando una bandera para indicar que necesitamos una forma amable de terminar:


6.- Cubre tu código actual con un bucle:


(Luego sigue una explicación larga de estos pasos y por qué)

Como ves, se trata de una serie de reglas para desligar al proceso demonio del que fuera su padre, su grupo de procesos, de la terminal que lo arrancó y de los canales de entrada y salida que su padre le abrió. Luego, capturas las señales fatales para saber cuándo tienes que morir. Y finalmente, el programa entra en un bucle sin fin, atendiendo a sus tareas, hasta que le dicen que se tiene que terminar.

Eso es lo que no he visto en tu código (al menos, de forma clara. Quizás me equivoque).

Quizás pase algo tan sencillo como que el hijo que crea el demonio para atender a las peticiones no cierra la conexión.

En ese caso, quizás tengas que usar shutdown() en lugar de close(), como indica la receta 17.9 (cerrar un socket después de hacer un fork()):

Imagine a server that wants to read its client's request until end-of-file, and then send an answer. If the client calls close, that socket is now invalid for I/O, so no answer would ever come back. Instead, the client should use shutdown to half-close the connection.

que quiere decir:

Imagina un servidor que quiere leer las peticiones de su cliente hasta el fin-del-fichero, y entonces envía una respuesta. Si el cliente llama a close(), este socket es ahora inválido para E/S, así que ninguna respuesta regresará. En lugar de eso, el cliente debería usar shutdown para medio-cerrar la conexión.

No entiendo por qué en las líneas 78 y 80 haces dos llamadas fork().

Si no me equivoco, pasa esto:



Vamos, que al final quien continúa es el nieto... no creo que sea necesario crear tanta descendencia