signal: SIGALRM

[GagleKas]

El siguiente codigo es solo un ejemplo para ver que si que se puede usar la misma interrupcion con diferentes procesos, porque al hacer el fork se crea una copia identica (menos el pid), por lo que las variables globales e interrupciones no generan problemas.

No he hecho 2 contadores con un unico SIGALRM porque para ver el resultado por pantalla tendria que modificar ciertas cosas que podrian causar confusion con el objetivo del programa.

Código C:

#include <signal.h>
#include <stdio.h>
 
int n = 0;
 
void intSIGUSR1 (){
        printf ("%d\n", n);
}
 
int main (){
        int pidHijo1, pidHijo2;
 
        pidHijo1 = fork ();
 
        if (pidHijo1 == 0){
                //Hijo
                signal (SIGUSR1, intSIGUSR1);
                n = 1;
                kill (getpid (), SIGUSR1);
 
                exit (0);
        }else if (pidHijo1 < 0){
                //Error
                exit (-1);
        }
 
        pidHijo2 = fork ();
 
        if (pidHijo2 == 0){
                //Hijo
                signal (SIGUSR1, intSIGUSR1);
                n = 2;
                kill (getpid (), SIGUSR1);
 
                exit (0);
        }else if (pidHijo2 > 0){
                //Padre
                waitpid (pidHijo1, NULL, 0);
                waitpid (pidHijo2, NULL, 0);
        }else{
                //Error
                exit (-1);
        }
 
        return 0;
}
 

Este programa solo muestra 1 y 2 por pantalla, o 2 y 1, si el scheduler asi lo decide.

En lugar de la variable global n, ahi pondria la variable del socket.

Primero haria el accept (). Una vez llega un cliente esta funcion me devuelve el fd del socket. Este fd lo copio en la variable global y genero un hijo para atender al cliente. Listo, el hijo tendra el fd del socket en la variable global con el que se comunicara con el cliente y a la vez se podra usar para enviar timeouts.

Si llegan mas conexiones de clientes pues no pasa nada. De la misma forma se guarda en la variable global el fd del socket creado con accept () y se crea el hijo, el cual tendra en esta variable global el fd del socket con el que se comunicara con el cliente.

Puede que al principio se piense que se esta usando memoria compartida (la variable global) entre proceso padre e hijo, pero no es asi. El siguiente codigo lo deja mas claro:

Código C:

#include <stdio.h>
 
int main (){
        int x = 0, pidHijo;
 
        pidHijo = fork ();
 
        if (pidHijo == 0){
                //Hijo
                printf ("Hijo: %d\n", x); //muestra 0 por pantalla
                exit (0);
        }else if (pidHijo > 0){
                //Padre
                x = 1;
                printf ("Padre: %d\n", x); //muestra 1 por pantalla
                waitpid (pidHijo, NULL, 0);
        }else{
                //Error
                return -1;
        }
 
        return 0;
}
 

Ahora en lugar de la x pon la variable global. La idea es la misma.




Bueno, espero que quien tenga el mismo problema que yo y use el google, le salga este post. xDDD


Saludos.