Untitled

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

int nombreSIGNAUX = 16;

void HandlerSIGUSR1();
void HandlerSIGRTMIN();
void HandlerSIGRTMAX();


void FonctionFils();
void SortieErreur();

int compteurSIGUSR1 = 1;   // Compteur pour SIGUSR1
int compteurSIGRTMIN = 1 ; // Compteur pour SIGRTMIN
int compteurSIGRTMAX = 1 ; // Compteur pour SIGRTMAX

int main()
{
	int idFils;
	int i;

	if ((idFils = fork()) == -1)SortieErreur();
	if (!idFils)FonctionFils();

	sleep(1); //Laisser le temps au fils d'armer ses signaux

	/* ----------------------------------------------------
			 ENVOI D'UN SIGNAL DONNE A UN PROCESSUS
			 SIGNAL				: SIGUSR1,
			 PROCESSUS			: idFils.
	----------------------------------------------------- */
	for (i = 0; i < nombreSIGNAUX ; i++)
	{
		printf ("Main >> Envoi du signal SIGUSR1 %d !\n", i+1);
		if ((kill (idFils, SIGUSR1)) == -1)SortieErreur();
	}

	/* ----------------------------------------------------
			ENVOI D'UN SIGNAL DONNE A UN PROCESSUS
			SIGNAL				: SIGRTMIN,
			PROCESSUS			: idFils.
	----------------------------------------------------- */
	for (i = 0; i < nombreSIGNAUX; i++)
	{
		printf ("Main >> Envoi du signal SIGRTMIN %d !\n", i+1);
		if ((kill (idFils, SIGRTMIN)) == -1)SortieErreur();
	}

	/* ----------------------------------------------------
			ENVOI D'UN SIGNAL DONNE A UN PROCESSUS
			SIGNAL				: SIGRTMAX,
			PROCESSUS			: idFils.
	----------------------------------------------------- */
	for (i = 0; i < nombreSIGNAUX; i++)
	{
		printf ("Main >> Envoi du signal SIGRTMAX %d !\n", i+1);
		if ((kill (idFils, SIGRTMAX)) == -1)SortieErreur();
	}
	return 0;
}

void FonctionFils()
{
	/* DECLARATION POUR L'UTILISATION DES SIGNAUX */
	struct sigaction sigact;
	sigset_t mask;
	sigfillset(&mask);
	sigprocmask(SIG_SETMASK, &mask, NULL);

	/* ----------------------------------------------------
			DEFINIR LE COMPORTEMENT DU PROCESSUS COURANT
			POUR UN SIGNAL DONNE
			COMPORTEMENT		: HANDLER
								  HandlerSIGUSR1,
			 SIGNAL				: SIGUSR1,
			 FLAGS				: SA_SIGINFO.
	----------------------------------------------------- */
	sigact.sa_handler = HandlerSIGUSR1;
	//sigact.sa_flags = SA_SIGINFO;	// Permet le queining, éviter de perdre les signaux
	if ((sigaction(SIGUSR1, &sigact,0))==-1)SortieErreur();

	/* ----------------------------------------------------
			 DEFINIR LE COMPORTEMENT DU PROCESSUS COURANT
			 POUR UN SIGNAL DONNE
			 COMPORTEMENT		: HANDLER
								  HandlerSIGRTMIN,
			 SIGNAL				: SIGRTMIN,
			 FLAGS				: SA_SIGINFO.
	----------------------------------------------------- */
	sigact.sa_handler = HandlerSIGRTMIN;
//	sigact.sa_flags = SA_SIGINFO;	// Permet le queining, éviter de perdre les signaux
	if ((sigaction(SIGRTMIN, &sigact,0))==-1)SortieErreur();

	/* ----------------------------------------------------
			 DEFINIR LE COMPORTEMENT DU PROCESSUS COURANT
			 POUR UN SIGNAL DONNE
			 COMPORTEMENT		: HANDLER
								  HandlerSIGRTMAX,
			 SIGNAL				: SIGRTMMAX,
			 FLAGS				: SA_SIGINFO.
	----------------------------------------------------- */
	sigact.sa_handler = HandlerSIGRTMAX;
//	sigact.sa_flags = SA_SIGINFO;	// Permet le queining, éviter de perdre les signaux
	if ((sigaction(SIGRTMAX, &sigact,0))==-1)SortieErreur();

	sleep(5);//Laisser le temps au père d'envoyer ses signaux

	sigfillset(&mask);
	sigdelset(&mask, SIGUSR1); 	// SIGUSR1 peut recevoir
	sigdelset(&mask, SIGRTMIN); // SIGRTMIN peut recevoir
	sigdelset(&mask, SIGRTMAX);	// SIGRTMAX peut recevoir
	sigprocmask(SIG_SETMASK, &mask, NULL); // On applique le masque

	sleep(50);
	exit(0);
}

/* ----------------------------------------------------
 	 GESTIONNAIRE DE SIGNAUX.
----------------------------------------------------- */
void HandlerSIGUSR1()
{
	printf("HandlerSIGUSR1 >> Signal %d recu !\n",compteurSIGUSR1++);
}
void HandlerSIGRTMIN()
{
	printf ("HandlerSIGRTMIN >> Signal %d recu !\n",compteurSIGRTMIN++);
}

void HandlerSIGRTMAX()
{
	printf ("HandlerSIGRTMAX >> Signal %d recu !\n",compteurSIGRTMAX++);
}

void SortieErreur()
{
	perror("");
	exit(0);
}