--- rpl/src/interruptions.c	2012/10/09 15:27:45	1.105
+++ rpl/src/interruptions.c	2012/10/14 21:37:11	1.106
@@ -121,8 +121,14 @@ thread_surveillance_signaux(void *argume
 			if ((*s_queue_signaux).pointeur_lecture !=
 					(*s_queue_signaux).pointeur_ecriture)
 			{
+				// Attention : raise() envoit le signal au thread appelant !
+				// kill() l'envoie au processus appelant, donc dans notre
+				// cas à un thread aléatoire du processus, ce qui nous
+				// convient tout à fait puisqu'il s'agit de débloquer les
+				// appels système lents.
+
 				nombre_signaux_envoyes++;
-				raise(SIGALRM);
+				kill(getpid(), SIGALRM);
 			}
 
 #			if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)
@@ -1604,9 +1610,126 @@ deverrouillage_gestionnaire_signaux(stru
 	return;
 }
 
+/*
+================================================================================
+  Fonctions de gestion des signaux dans les threads.
+
+  Lorsqu'un processus reçoit un signal, il appelle le gestionnaire de signal
+  associé qui ne fait qu'envoyer au travers de write() le signal
+  reçus dans un pipe. Un second thread est bloqué sur ce pipe et
+  effectue le traitement adéquat pour le signal donné.
+================================================================================
+*/
+
 #define test_signal(signal) \
 	if (signal_test == SIGTEST) { signal_test = signal; return; }
 
+static int			pipe_signaux;
+
+logical1
+lancement_thread_signaux(struct_processus *s_etat_processus)
+{
+	pthread_attr_t					attributs;
+
+	void							*argument;
+
+	if (pipe((*s_etat_processus).pipe_signaux) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return(d_erreur);
+	}
+
+	pipe_signaux = (*s_etat_processus).pipe_signaux[1];
+
+	if (pthread_attr_init(&attributs) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return(d_erreur);
+	}
+
+	if (pthread_attr_setdetachstate(&attributs, PTHREAD_CREATE_JOINABLE) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return(d_erreur);
+	}
+
+	argument = (*s_etat_processus).pipe_signaux;
+
+	if (pthread_create(&((*s_etat_processus).thread_signaux), &attributs,
+			thread_signaux, argument) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return(d_erreur);
+	}
+
+	return(d_absence_erreur);
+}
+
+logical1
+arret_thread_signaux(struct_processus *s_etat_processus)
+{
+	unsigned char		signal;
+	ssize_t				n;
+
+	signal = (unsigned char ) (rpl_sigmax & 0xFF);
+
+	do
+	{
+		n = write((*s_etat_processus).pipe_signaux[1], &signal, sizeof(signal));
+
+		if (n < 0)
+		{
+			return(d_erreur);
+		}
+	} while(n != 1);
+
+	pthread_join((*s_etat_processus).thread_signaux, NULL);
+
+	close((*s_etat_processus).pipe_signaux[0]);
+	close((*s_etat_processus).pipe_signaux[1]);
+
+	return(d_absence_erreur);
+}
+
+void *
+thread_signaux(void *argument)
+{
+	int						*pipe;
+
+	sigset_t				masque;
+
+	struct pollfd			fds;
+
+	unsigned char			signal;
+
+	pipe = (int *) argument;
+	fds.fd = pipe[0];
+	fds.events = POLLIN;
+	fds.revents = 0;
+
+	sigfillset(&masque);
+	pthread_sigmask(SIG_BLOCK, &masque, NULL);
+
+	do
+	{
+		if (poll(&fds, 1, -1) == -1)
+		{
+			pthread_exit(NULL);
+		}
+
+		read(fds.fd, &signal, 1);
+
+		if (signal != (0xFF & rpl_sigmax))
+		{
+			envoi_signal_processus(getpid(), signal);
+			// Un signal SIGALRM est envoyé par le thread de surveillance
+			// des signaux jusqu'à ce que les signaux soient tous traités.
+		}
+	} while(signal != (0xFF & rpl_sigmax));
+
+	pthread_exit(NULL);
+}
+
 // Récupération des signaux
 // - SIGINT  (arrêt au clavier)
 // - SIGTERM (signal d'arrêt en provenance du système)
@@ -1614,20 +1737,25 @@ deverrouillage_gestionnaire_signaux(stru
 void
 interruption1(int signal)
 {
+	unsigned char		signal_tronque;
+
 	test_signal(signal);
 
 	switch(signal)
 	{
 		case SIGINT:
-			envoi_signal_processus(getpid(), rpl_sigint);
+			signal_tronque = (unsigned char) (rpl_sigint & 0xFF);
+			write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
 			break;
 
 		case SIGTERM:
-			envoi_signal_processus(getpid(), rpl_sigterm);
+			signal_tronque = (unsigned char) (rpl_sigterm & 0xFF);
+			write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
 			break;
 
 		case SIGUSR1:
-			envoi_signal_processus(getpid(), rpl_sigalrm);
+			signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF);
+			write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
 			break;
 
 		default:
@@ -1638,6 +1766,96 @@ interruption1(int signal)
 	return;
 }
 
+// Récupération des signaux
+// - SIGFSTP
+//
+// ATTENTION :
+// Le signal SIGFSTP provient de la mort du processus de contrôle.
+// Sous certains systèmes (Linux...), la mort du terminal de contrôle
+// se traduit par l'envoi d'un SIGHUP au processus. Sur d'autres
+// (SunOS), le processus reçoit un SIGFSTP avec une structure siginfo
+// non initialisée (pointeur NULL) issue de TERMIO.
+
+void
+interruption2(int signal)
+{
+	unsigned char		signal_tronque;
+
+	test_signal(signal);
+
+	signal_tronque = (unsigned char) (rpl_sigtstp & 0xFF);
+	write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
+	return;
+}
+
+void
+interruption3(int signal)
+{
+	// Si on passe par ici, c'est qu'il est impossible de récupérer
+	// l'erreur d'accès à la mémoire. On sort donc du programme quitte à
+	// ce qu'il reste des processus orphelins.
+
+	unsigned char		message_1[] = "+++System : Uncaught access violation\n"
+								"+++System : Aborting !\n";
+	unsigned char		message_2[] = "+++System : Stack overflow\n"
+								"+++System : Aborting !\n";
+
+	test_signal(signal);
+
+	if (pid_processus_pere == getpid())
+	{
+		kill(pid_processus_pere, SIGUSR1);
+	}
+
+	if (signal != SIGUSR2)
+	{
+		write(STDERR_FILENO, message_1, strlen(message_1));
+	}
+	else
+	{
+		write(STDERR_FILENO, message_2, strlen(message_2));
+	}
+
+	_exit(EXIT_FAILURE);
+}
+
+// Récupération des signaux
+// - SIGHUP
+
+void
+interruption4(int signal)
+{
+	unsigned char		signal_tronque;
+
+	test_signal(signal);
+
+	signal_tronque = (unsigned char) (rpl_sighup & 0xFF);
+	write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
+	return;
+}
+
+// Récupération des signaux
+// - SIGPIPE
+
+void
+interruption5(int signal)
+{
+	unsigned char		message[] = "+++System : SIGPIPE\n"
+								"+++System : Aborting !\n";
+	unsigned char		signal_tronque;
+
+	test_signal(signal);
+
+	if (pid_processus_pere == getpid())
+	{
+		signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF);
+		write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
+	}
+
+	write(STDERR_FILENO, message, strlen(message));
+	return;
+}
+
 inline static void
 signal_alrm(struct_processus *s_etat_processus, pid_t pid)
 {
@@ -1807,24 +2025,6 @@ signal_int(struct_processus *s_etat_proc
 	return;
 }
 
-// Récupération des signaux
-// - SIGFSTP
-//
-// ATTENTION :
-// Le signal SIGFSTP provient de la mort du processus de contrôle.
-// Sous certains systèmes (Linux...), la mort du terminal de contrôle
-// se traduit par l'envoi d'un SIGHUP au processus. Sur d'autres
-// (SunOS), le processus reçoit un SIGFSTP avec une structure siginfo
-// non initialisée (pointeur NULL) issue de TERMIO.
-
-void
-interruption2(int signal)
-{
-	test_signal(signal);
-	envoi_signal_processus(getpid(), rpl_sigtstp);
-	return;
-}
-
 static inline void
 signal_tstp(struct_processus *s_etat_processus, pid_t pid)
 {
@@ -1872,38 +2072,6 @@ signal_tstp(struct_processus *s_etat_pro
 	return;
 }
 
-void
-interruption3(int signal)
-{
-	// Si on passe par ici, c'est qu'il est impossible de récupérer
-	// l'erreur d'accès à la mémoire. On sort donc du programme quitte à
-	// ce qu'il reste des processus orphelins.
-
-	unsigned char		message_1[] = "+++System : Uncaught access violation\n"
-								"+++System : Aborting !\n";
-	unsigned char		message_2[] = "+++System : Stack overflow\n"
-								"+++System : Aborting !\n";
-
-	test_signal(signal);
-
-	if (pid_processus_pere == getpid())
-	{
-		kill(pid_processus_pere, SIGUSR1);
-	}
-
-	if (signal != SIGUSR2)
-	{
-		write(STDERR_FILENO, message_1, strlen(message_1));
-	}
-	else
-	{
-		write(STDERR_FILENO, message_2, strlen(message_2));
-	}
-
-	_exit(EXIT_FAILURE);
-}
-
-
 static void
 sortie_interruption_depassement_pile(void *arg1, void *arg2, void *arg3)
 {
@@ -1921,7 +2089,6 @@ sortie_interruption_depassement_pile(voi
 	return;
 }
 
-
 void
 interruption_depassement_pile(int urgence, stackoverflow_context_t scp)
 {
@@ -1939,7 +2106,6 @@ interruption_depassement_pile(int urgenc
 	return;
 }
 
-
 int
 interruption_violation_access(void *adresse_fautive, int gravite)
 {
@@ -2115,25 +2281,6 @@ signal_inject(struct_processus *s_etat_p
 	return;
 }
 
-// Récupération des signaux
-// - SIGPIPE
-
-void
-interruption5(int signal)
-{
-	unsigned char		message[] = "+++System : SIGPIPE\n"
-								"+++System : Aborting !\n";
-
-	test_signal(signal);
-
-	if (pid_processus_pere == getpid())
-	{
-		envoi_signal_processus(pid_processus_pere, rpl_sigalrm);
-	}
-
-	write(STDERR_FILENO, message, strlen(message));
-	return;
-}
 
 static inline void
 signal_urg(struct_processus *s_etat_processus, pid_t pid)
@@ -2228,16 +2375,6 @@ signal_abort(struct_processus *s_etat_pr
 	return;
 }
 
-// Récupération des signaux
-// - SIGHUP
-
-void
-interruption4(int signal)
-{
-	test_signal(signal);
-	envoi_signal_processus(getpid(), rpl_sighup);
-	return;
-}
 
 static inline void
 signal_hup(struct_processus *s_etat_processus, pid_t pid)