--- rpl/src/interruptions.c	2010/03/04 10:17:54	1.4
+++ rpl/src/interruptions.c	2010/08/25 09:06:49	1.35
@@ -1,6 +1,6 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.12
+  RPL/2 (R) version 4.0.18
   Copyright (C) 1989-2010 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
@@ -20,7 +20,7 @@
 */
 
 
-#include "rpl.conv.h"
+#include "rpl-conv.h"
 
 
 /*
@@ -82,22 +82,9 @@ insertion_thread(struct_processus *s_eta
 	sigfillset(&set);
 	pthread_sigmask(SIG_BLOCK, &set, &oldset);
 
-	while(sem_wait(&semaphore_liste_threads) == -1)
-	{
-		if (errno != EINTR)
-		{
-			pthread_sigmask(SIG_SETMASK, &oldset, NULL);
-			sigpending(&set);
-
-			(*s_etat_processus).erreur_systeme = d_es_processus;
-			return;
-		}
-	}
-
 	if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))
 			== NULL)
 	{
-		sem_post(&semaphore_liste_threads);
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		sigpending(&set);
 
@@ -105,11 +92,8 @@ insertion_thread(struct_processus *s_eta
 		return;
 	}
 
-	(*l_nouvel_objet).suivant = liste_threads;
-
 	if (((*l_nouvel_objet).donnee = malloc(sizeof(struct_thread))) == NULL)
 	{
-		sem_post(&semaphore_liste_threads);
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		sigpending(&set);
 
@@ -124,9 +108,30 @@ insertion_thread(struct_processus *s_eta
 	(*((struct_thread *) (*l_nouvel_objet).donnee)).s_etat_processus =
 			s_etat_processus;
 
+#	ifndef SEMAPHORES_NOMMES
+	while(sem_wait(&semaphore_liste_threads) == -1)
+#	else
+	while(sem_wait(semaphore_liste_threads) == -1)
+#	endif
+	{
+		if (errno != EINTR)
+		{
+			pthread_sigmask(SIG_SETMASK, &oldset, NULL);
+			sigpending(&set);
+
+			(*s_etat_processus).erreur_systeme = d_es_processus;
+			return;
+		}
+	}
+
+	(*l_nouvel_objet).suivant = liste_threads;
 	liste_threads = l_nouvel_objet;
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_post(&semaphore_liste_threads) != 0)
+#	else
+	if (sem_post(semaphore_liste_threads) != 0)
+#	endif
 	{
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		sigpending(&set);
@@ -152,7 +157,21 @@ insertion_thread_surveillance(struct_pro
 	sigfillset(&set);
 	pthread_sigmask(SIG_BLOCK, &set, &oldset);
 
+	if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))
+			== NULL)
+	{
+		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
+		sigpending(&set);
+
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+#	ifndef SEMAPHORES_NOMMES
 	while(sem_wait(&semaphore_liste_threads) == -1)
+#	else
+	while(sem_wait(semaphore_liste_threads) == -1)
+#	endif
 	{
 		if (errno != EINTR)
 		{
@@ -164,23 +183,20 @@ insertion_thread_surveillance(struct_pro
 		}
 	}
 
-	if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))
-			== NULL)
-	{
-		sem_post(&semaphore_liste_threads);
-		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
-		sigpending(&set);
-
-		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-		return;
-	}
+	pthread_mutex_lock(&((*s_argument_thread).mutex));
+	(*s_argument_thread).nombre_references++;
+	pthread_mutex_unlock(&((*s_argument_thread).mutex));
 
 	(*l_nouvel_objet).suivant = liste_threads_surveillance;
 	(*l_nouvel_objet).donnee = (void *) s_argument_thread;
 
 	liste_threads_surveillance = l_nouvel_objet;
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_post(&semaphore_liste_threads) != 0)
+#	else
+	if (sem_post(semaphore_liste_threads) != 0)
+#	endif
 	{
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		sigpending(&set);
@@ -206,7 +222,11 @@ retrait_thread(struct_processus *s_etat_
 	sigfillset(&set);
 	pthread_sigmask(SIG_BLOCK, &set, &oldset);
 
+#	ifndef SEMAPHORES_NOMMES
 	while(sem_wait(&semaphore_liste_threads) == -1)
+#	else
+	while(sem_wait(semaphore_liste_threads) == -1)
+#	endif
 	{
 		if (errno != EINTR)
 		{
@@ -236,7 +256,11 @@ retrait_thread(struct_processus *s_etat_
 
 	if (l_element_courant == NULL)
 	{
+#		ifndef SEMAPHORES_NOMMES
 		sem_post(&semaphore_liste_threads);
+#		else
+		sem_post(semaphore_liste_threads);
+#		endif
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		sigpending(&set);
 
@@ -253,20 +277,25 @@ retrait_thread(struct_processus *s_etat_
 		(*l_element_precedent).suivant = (*l_element_courant).suivant;
 	}
 
-	free((void *) (*l_element_courant).donnee);
-	free((struct_liste_chainee_volatile *) l_element_courant);
-
 	if (pthread_setspecific(semaphore_fork_processus_courant, NULL) != 0)
 	{
 		(*s_etat_processus).erreur_systeme = d_es_processus;
 
+#		ifndef SEMAPHORES_NOMMES
 		sem_post(&semaphore_liste_threads);
+#		else
+		sem_post(semaphore_liste_threads);
+#		endif
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		sigpending(&set);
 		return;
 	}
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_post(&semaphore_liste_threads) != 0)
+#	else
+	if (sem_post(semaphore_liste_threads) != 0)
+#	endif
 	{
 		(*s_etat_processus).erreur_systeme = d_es_processus;
 
@@ -275,6 +304,9 @@ retrait_thread(struct_processus *s_etat_
 		return;
 	}
 
+	free((void *) (*l_element_courant).donnee);
+	free((struct_liste_chainee_volatile *) l_element_courant);
+
 	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 	sigpending(&set);
 	return;
@@ -293,7 +325,11 @@ retrait_thread_surveillance(struct_proce
 	sigfillset(&set);
 	pthread_sigmask(SIG_BLOCK, &set, &oldset);
 
+#	ifndef SEMAPHORES_NOMMES
 	while(sem_wait(&semaphore_liste_threads) == -1)
+#	else
+	while(sem_wait(semaphore_liste_threads) == -1)
+#	endif
 	{
 		if (errno != EINTR)
 		{
@@ -321,7 +357,11 @@ retrait_thread_surveillance(struct_proce
 
 	if (l_element_courant == NULL)
 	{
+#		ifndef SEMAPHORES_NOMMES
 		sem_post(&semaphore_liste_threads);
+#		else
+		sem_post(semaphore_liste_threads);
+#		endif
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		sigpending(&set);
 
@@ -338,10 +378,13 @@ retrait_thread_surveillance(struct_proce
 		(*l_element_precedent).suivant = (*l_element_courant).suivant;
 	}
 
-	free((struct_liste_chainee_volatile *) l_element_courant);
-
 	if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)
 	{
+#		ifndef SEMAPHORES_NOMMES
+		sem_post(&semaphore_liste_threads);
+#		else
+		sem_post(semaphore_liste_threads);
+#		endif
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		sigpending(&set);
 
@@ -359,6 +402,11 @@ retrait_thread_surveillance(struct_proce
 	{
 		if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)
 		{
+#			ifndef SEMAPHORES_NOMMES
+			sem_post(&semaphore_liste_threads);
+#			else
+			sem_post(semaphore_liste_threads);
+#			endif
 			pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 			sigpending(&set);
 
@@ -373,6 +421,11 @@ retrait_thread_surveillance(struct_proce
 	{
 		if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)
 		{
+#			ifndef SEMAPHORES_NOMMES
+			sem_post(&semaphore_liste_threads);
+#			else
+			sem_post(semaphore_liste_threads);
+#			endif
 			pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 			sigpending(&set);
 
@@ -381,7 +434,11 @@ retrait_thread_surveillance(struct_proce
 		}
 	}
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_post(&semaphore_liste_threads) != 0)
+#	else
+	if (sem_post(semaphore_liste_threads) != 0)
+#	endif
 	{
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		sigpending(&set);
@@ -390,8 +447,11 @@ retrait_thread_surveillance(struct_proce
 		return;
 	}
 
+	free((struct_liste_chainee_volatile *) l_element_courant);
+
 	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 	sigpending(&set);
+
 	return;
 }
 
@@ -400,7 +460,11 @@ verrouillage_threads_concurrents(struct_
 {
 	volatile struct_liste_chainee_volatile	*l_element_courant;
 
+#	ifndef SEMAPHORES_NOMMES
 	while(sem_wait(&semaphore_liste_threads) == -1)
+#	else
+	while(sem_wait(semaphore_liste_threads) == -1)
+#	endif
 	{
 		if (errno != EINTR)
 		{
@@ -417,8 +481,13 @@ verrouillage_threads_concurrents(struct_
 				== getpid()) && (pthread_equal((*((struct_thread *)
 				(*l_element_courant).donnee)).tid, pthread_self()) == 0))
 		{
+#			ifndef SEMAPHORES_NOMMES
 			while(sem_wait(&((*(*((struct_thread *) (*l_element_courant)
 					.donnee)).s_etat_processus).semaphore_fork)) == -1)
+#			else
+			while(sem_wait((*(*((struct_thread *) (*l_element_courant)
+					.donnee)).s_etat_processus).semaphore_fork) == -1)
+#			endif
 			{
 				if (errno != EINTR)
 				{
@@ -447,15 +516,29 @@ deverrouillage_threads_concurrents(struc
 				== getpid()) && (pthread_equal((*((struct_thread *)
 				(*l_element_courant).donnee)).tid, pthread_self()) == 0))
 		{
+#			ifndef SEMAPHORES_NOMMES
 			if (sem_post(&((*(*((struct_thread *)
 					(*l_element_courant).donnee)).s_etat_processus)
 					.semaphore_fork)) != 0)
+#			else
+			if (sem_post((*(*((struct_thread *)
+					(*l_element_courant).donnee)).s_etat_processus)
+					.semaphore_fork) != 0)
+#			endif
 			{
+#				ifndef SEMAPHORES_NOMMES
 				if (sem_post(&semaphore_liste_threads) != 0)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_processus;
 					return;
 				}
+#				else
+				if (sem_post(semaphore_liste_threads) != 0)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_processus;
+					return;
+				}
+#				endif
 
 				(*s_etat_processus).erreur_systeme = d_es_processus;
 				return;
@@ -465,7 +548,11 @@ deverrouillage_threads_concurrents(struc
 		l_element_courant = (*l_element_courant).suivant;
 	}
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_post(&semaphore_liste_threads) != 0)
+#	else
+	if (sem_post(semaphore_liste_threads) != 0)
+#	endif
 	{
 		(*s_etat_processus).erreur_systeme = d_es_processus;
 		return;
@@ -498,7 +585,11 @@ liberation_threads(struct_processus *s_e
 	sigfillset(&set);
 	pthread_sigmask(SIG_BLOCK, &set, &oldset);
 
+#	ifndef SEMAPHORES_NOMMES
 	while(sem_wait(&semaphore_liste_threads) == -1)
+#	else
+	while(sem_wait(semaphore_liste_threads) == -1)
+#	endif
 	{
 		if (errno != EINTR)
 		{
@@ -539,6 +630,8 @@ liberation_threads(struct_processus *s_e
 			close((*s_etat_processus).pipe_nombre_objets_attente);
 			close((*s_etat_processus).pipe_nombre_interruptions_attente);
 
+			liberation(s_etat_processus, (*s_etat_processus).at_exit);
+
 			if ((*s_etat_processus).nom_fichier_impression != NULL)
 			{
 				free((*s_etat_processus).nom_fichier_impression);
@@ -580,18 +673,73 @@ liberation_threads(struct_processus *s_e
 					.l_base_pile_processus;
 			while(element_courant != NULL)
 			{
-				pthread_mutex_trylock(&((*(*((struct_liste_chainee *)
-						element_courant)).donnee).mutex));
-				pthread_mutex_unlock(&((*(*((struct_liste_chainee *)
-						element_courant)).donnee).mutex));
-				liberation(s_etat_processus,
-						(*((struct_liste_chainee *) element_courant)).donnee);
+				s_argument_thread = (struct_descripteur_thread *)
+						(*((struct_liste_chainee *) element_courant)).donnee;
+
+				if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_processus;
+					sem_post(&semaphore_liste_threads);
+					return;
+				}
+
+				(*s_argument_thread).nombre_references--;
+
+				BUG((*s_argument_thread).nombre_references < 0,
+						printf("(*s_argument_thread).nombre_references = %d\n",
+						(int) (*s_argument_thread).nombre_references));
+
+				if ((*s_argument_thread).nombre_references == 0)
+				{
+					close((*s_argument_thread).pipe_objets[0]);
+					close((*s_argument_thread).pipe_acquittement[1]);
+					close((*s_argument_thread).pipe_injections[1]);
+					close((*s_argument_thread).pipe_nombre_injections[1]);
+					close((*s_argument_thread).pipe_nombre_objets_attente[0]);
+					close((*s_argument_thread).pipe_interruptions[0]);
+					close((*s_argument_thread)
+							.pipe_nombre_interruptions_attente[0]);
+
+					if (pthread_mutex_unlock(&((*s_argument_thread).mutex))
+							!= 0)
+					{
+						(*s_etat_processus).erreur_systeme = d_es_processus;
+						sem_post(&semaphore_liste_threads);
+						return;
+					}
+
+					pthread_mutex_destroy(&((*s_argument_thread).mutex));
+
+					if ((*s_argument_thread).processus_detache == d_faux)
+					{
+						if ((*s_argument_thread).destruction_objet == d_vrai)
+						{
+							liberation(s_etat_processus, (*s_argument_thread)
+									.argument);
+						}
+					}
+
+					free(s_argument_thread);
+				}
+				else
+				{
+					if (pthread_mutex_unlock(&((*s_argument_thread).mutex))
+							!= 0)
+					{
+						(*s_etat_processus).erreur_systeme = d_es_processus;
+						sem_post(&semaphore_liste_threads);
+						return;
+					}
+				}
+
 				element_suivant = (*((struct_liste_chainee *) element_courant))
 						.suivant;
-				free((struct_liste_chainee *) element_courant);
+				free(element_courant);
 				element_courant = element_suivant;
 			}
 
+			(*s_etat_processus).l_base_pile_processus = NULL;
+
 			pthread_mutex_trylock(&((*(*s_etat_processus).indep).mutex));
 			pthread_mutex_unlock(&((*(*s_etat_processus).indep).mutex));
 			liberation(s_etat_processus, (*s_etat_processus).indep);
@@ -916,12 +1064,6 @@ liberation_threads(struct_processus *s_e
 				{
 					if (((*((struct_descripteur_fichier *)
 							(*((struct_liste_chainee *) element_courant))
-							.donnee)).descripteur ==
-							(*((struct_descripteur_fichier *)
-							(*((struct_liste_chainee *) element_candidat))
-							.donnee)).descripteur) &&
-							((*((struct_descripteur_fichier *)
-							(*((struct_liste_chainee *) element_courant))
 							.donnee)).pid ==
 							(*((struct_descripteur_fichier *)
 							(*((struct_liste_chainee *) element_candidat))
@@ -932,7 +1074,52 @@ liberation_threads(struct_processus *s_e
 							(*((struct_liste_chainee *) element_candidat))
 							.donnee)).tid) != 0))
 					{
-						break;
+						if ((*((struct_descripteur_fichier *)
+								(*((struct_liste_chainee *) element_courant))
+								.donnee)).type ==
+								(*((struct_descripteur_fichier *)
+								(*((struct_liste_chainee *) element_candidat))
+								.donnee)).type)
+						{
+							if ((*((struct_descripteur_fichier *)
+									(*((struct_liste_chainee *)
+									element_candidat)).donnee)).type == 'C')
+							{
+								if ((*((struct_descripteur_fichier *)
+										(*((struct_liste_chainee *)
+										element_courant)).donnee))
+										.descripteur_c ==
+										(*((struct_descripteur_fichier *)
+										(*((struct_liste_chainee *)
+										element_candidat)).donnee))
+										.descripteur_c)
+								{
+									break;
+								}
+							}
+							else
+							{
+								if (((*((struct_descripteur_fichier *)
+										(*((struct_liste_chainee *)
+										element_courant)).donnee))
+										.descripteur_sqlite ==
+										(*((struct_descripteur_fichier *)
+										(*((struct_liste_chainee *)
+										element_candidat)).donnee))
+										.descripteur_sqlite) &&
+										((*((struct_descripteur_fichier *)
+										(*((struct_liste_chainee *)
+										element_courant)).donnee))
+										.descripteur_c ==
+										(*((struct_descripteur_fichier *)
+										(*((struct_liste_chainee *)
+										element_candidat)).donnee))
+										.descripteur_c))
+								{
+									break;
+								}
+							}
+						}
 					}
 
 					element_candidat = (*((struct_liste_chainee *)
@@ -943,7 +1130,16 @@ liberation_threads(struct_processus *s_e
 				{
 					fclose((*((struct_descripteur_fichier *)
 							(*((struct_liste_chainee *) element_courant))
-							.donnee)).descripteur);
+							.donnee)).descripteur_c);
+
+					if ((*((struct_descripteur_fichier *)
+							(*((struct_liste_chainee *) element_courant))
+							.donnee)).type != 'C')
+					{
+						sqlite3_close((*((struct_descripteur_fichier *)
+								(*((struct_liste_chainee *) element_courant))
+								.donnee)).descripteur_sqlite);
+					}
 				}
 
 				free((*((struct_descripteur_fichier *)
@@ -1018,6 +1214,12 @@ liberation_threads(struct_processus *s_e
 				element_courant = element_suivant;
 			}
 
+/*
+================================================================================
+  À noter : on ne ferme pas la connexion car la conséquence immédiate est
+  une destruction de l'objet pour le processus père.
+================================================================================
+
 			element_courant = (*s_etat_processus).s_connecteurs_sql;
 			while(element_courant != NULL)
 			{
@@ -1101,6 +1303,9 @@ liberation_threads(struct_processus *s_e
 
 				element_courant = element_suivant;
 			}
+*/
+
+			(*s_etat_processus).s_connecteurs_sql = NULL;
 
 			element_courant = (*s_etat_processus).s_marques;
 			while(element_courant != NULL)
@@ -1115,8 +1320,13 @@ liberation_threads(struct_processus *s_e
 
 			liberation_allocateur(s_etat_processus);
 
+#			ifndef SEMAPHORES_NOMMES
 			sem_post(&((*s_etat_processus).semaphore_fork));
 			sem_destroy(&((*s_etat_processus).semaphore_fork));
+#			else
+			sem_post((*s_etat_processus).semaphore_fork);
+			sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork);
+#			endif
 
 			free(s_etat_processus);
 
@@ -1140,17 +1350,10 @@ liberation_threads(struct_processus *s_e
 		s_argument_thread = (struct_descripteur_thread *)
 				(*l_element_courant).donnee;
 
-		close((*s_argument_thread).pipe_objets[0]);
-		close((*s_argument_thread).pipe_acquittement[1]);
-		close((*s_argument_thread).pipe_injections[1]);
-		close((*s_argument_thread).pipe_nombre_injections[1]);
-		close((*s_argument_thread).pipe_nombre_objets_attente[0]);
-		close((*s_argument_thread).pipe_interruptions[0]);
-		close((*s_argument_thread).pipe_nombre_interruptions_attente[0]);
-
 		if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_processus;
+			sem_post(&semaphore_liste_threads);
 			return;
 		}
 
@@ -1162,13 +1365,31 @@ liberation_threads(struct_processus *s_e
 
 		if ((*s_argument_thread).nombre_references == 0)
 		{
+			close((*s_argument_thread).pipe_objets[0]);
+			close((*s_argument_thread).pipe_acquittement[1]);
+			close((*s_argument_thread).pipe_injections[1]);
+			close((*s_argument_thread).pipe_nombre_injections[1]);
+			close((*s_argument_thread).pipe_nombre_objets_attente[0]);
+			close((*s_argument_thread).pipe_interruptions[0]);
+			close((*s_argument_thread).pipe_nombre_interruptions_attente[0]);
+
 			if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_processus;
+				sem_post(&semaphore_liste_threads);
 				return;
 			}
 
 			pthread_mutex_destroy(&((*s_argument_thread).mutex));
+
+			if ((*s_argument_thread).processus_detache == d_faux)
+			{
+				if ((*s_argument_thread).destruction_objet == d_vrai)
+				{
+					liberation(s_etat_processus, (*s_argument_thread).argument);
+				}
+			}
+
 			free(s_argument_thread);
 		}
 		else
@@ -1176,6 +1397,7 @@ liberation_threads(struct_processus *s_e
 			if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_processus;
+				sem_post(&semaphore_liste_threads);
 				return;
 			}
 		}
@@ -1187,7 +1409,11 @@ liberation_threads(struct_processus *s_e
 
 	liste_threads_surveillance = NULL;
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_post(&semaphore_liste_threads) != 0)
+#	else
+	if (sem_post(semaphore_liste_threads) != 0)
+#	endif
 	{
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		(*s_etat_processus).erreur_systeme = d_es_processus;
@@ -1282,7 +1508,7 @@ recherche_thread_principal(pid_t pid, pt
 */
 
 // Les routines suivantes sont uniquement appelées depuis les gestionnaires
-// des signaux asynchrones. Elles de doivent pas bloquer dans le cas où
+// des signaux asynchrones. Elles ne doivent pas bloquer dans le cas où
 // les sémaphores sont déjà bloqués par un gestionnaire de signal.
 
 static inline void
@@ -1310,7 +1536,11 @@ verrouillage_gestionnaire_signaux()
 	sigfillset(&set);
 	pthread_sigmask(SIG_BLOCK, &set, &oldset);
 
+#	ifndef SEMAPHORES_NOMMES
 	while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1)
+#	else
+	while(sem_wait(semaphore_gestionnaires_signaux_atomique) == -1)
+#	endif
 	{
 		if (errno != EINTR)
 		{
@@ -1320,21 +1550,33 @@ verrouillage_gestionnaire_signaux()
 		}
 	}
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_post(&semaphore_gestionnaires_signaux) == -1)
+#	else
+	if (sem_post(semaphore_gestionnaires_signaux) == -1)
+#	endif
 	{
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		BUG(1, uprintf("Lock error !\n"));
 		return;
 	}
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0)
+#	else
+	if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
+#	endif
 	{
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		BUG(1, uprintf("Lock error !\n"));
 		return;
 	}
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0)
+#	else
+	if (sem_post(semaphore_gestionnaires_signaux_atomique) != 0)
+#	endif
 	{
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		BUG(1, uprintf("Unlock error !\n"));
@@ -1349,7 +1591,11 @@ verrouillage_gestionnaire_signaux()
 		// par un thread concurrent. On essaye donc de le bloquer jusqu'à
 		// ce que ce soit possible.
 
+#		ifndef SEMAPHORES_NOMMES
 		while(sem_trywait(&semaphore_liste_threads) == -1)
+#		else
+		while(sem_trywait(semaphore_liste_threads) == -1)
+#		endif
 		{
 			if ((errno != EINTR) && (errno != EAGAIN))
 			{
@@ -1393,7 +1639,11 @@ deverrouillage_gestionnaire_signaux()
 	sigfillset(&set);
 	pthread_sigmask(SIG_BLOCK, &set, &oldset);
 
+#	ifndef SEMAPHORES_NOMMES
 	while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1)
+#	else
+	while(sem_wait(semaphore_gestionnaires_signaux_atomique) == -1)
+#	endif
 	{
 		if (errno != EINTR)
 		{
@@ -1403,14 +1653,22 @@ deverrouillage_gestionnaire_signaux()
 		}
 	}
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0)
+#	else
+	if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
+#	endif
 	{
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		BUG(1, uprintf("Unlock error !\n"));
 		return;
 	}
 
+#	ifndef SEMAPHORES_NOMMES
 	while(sem_wait(&semaphore_gestionnaires_signaux) == -1)
+#	else
+	while(sem_wait(semaphore_gestionnaires_signaux) == -1)
+#	endif
 	{
 		if (errno != EINTR)
 		{
@@ -1420,7 +1678,11 @@ deverrouillage_gestionnaire_signaux()
 		}
 	}
 
+#	ifndef SEMAPHORES_NOMMES
 	if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0)
+#	else
+	if (sem_post(semaphore_gestionnaires_signaux_atomique) != 0)
+#	endif
 	{
 		pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 		BUG(1, uprintf("Unlock error !\n"));
@@ -1443,7 +1705,11 @@ deverrouillage_gestionnaire_signaux()
 
 	if (semaphore == 1)
 	{
+#		ifndef SEMAPHORES_NOMMES
 		if (sem_post(&semaphore_liste_threads) != 0)
+#		else
+		if (sem_post(semaphore_liste_threads) != 0)
+#		endif
 		{
 			pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 
@@ -1458,9 +1724,731 @@ deverrouillage_gestionnaire_signaux()
 	return;
 }
 
+#ifdef _BROKEN_SIGINFO
+
+#define	longueur_queue	256
+#define nombre_queues	13
+
+static int				*fifos;
+static int				markov;
+static int				segment;
+static sem_t			*semaphores[nombre_queues];
+static sem_t			*semaphore_global;
+
+#ifdef IPCS_SYSV
+static unsigned char	*chemin = NULL;
+#endif
+
+unsigned char *
+nom_segment(unsigned char *chemin, pid_t pid)
+{
+	unsigned char				*fichier;
+
+#	ifdef IPCS_SYSV
+	if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) *
+			sizeof(unsigned char))) == NULL)
+	{
+		return(NULL);
+	}
+
+	sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid);
+#	else
+	if ((fichier = malloc((1 + 256 + 1) *
+			sizeof(unsigned char))) == NULL)
+	{
+		return(NULL);
+	}
+
+	sprintf(fichier, "/RPL-SIGQUEUES-%d", (int) pid);
+#	endif
+
+	return(fichier);
+}
+
+unsigned char *
+nom_semaphore(pid_t pid, int queue)
+{
+	unsigned char				*fichier;
+
+	if ((fichier = malloc((256 + 1) * sizeof(unsigned char))) == NULL)
+	{
+		return(NULL);
+	}
+
+	sprintf(fichier, "/RPL-SIGESMAPHORES-%d-%d", (int) pid, queue);
+
+	return(fichier);
+}
+
+inline int
+queue_de_signal(int signal)
+{
+	switch(signal)
+	{
+		case SIGINT:
+			return(0);
+		case SIGTSTP:
+			return(1);
+		case SIGCONT:
+			return(2);
+		case SIGURG:
+			return(3);
+		case SIGPIPE:
+			return(4);
+		case SIGALRM:
+			return(5);
+		case SIGFSTOP:
+			return(6);
+		case SIGSTART:
+			return(7);
+		case SIGINJECT:
+			return(8);
+		case SIGABORT:
+			return(9);
+		case SIGFABORT:
+			return(10);
+		case SIGSEGV:
+			return(11);
+		case SIGBUS:
+			return(12);
+	}
+
+	return(-1);
+}
+
 void
-interruption1(int signal, siginfo_t *siginfo, void *context)
+creation_fifos_signaux(struct_processus *s_etat_processus)
 {
+	/*
+	 * Signaux utilisés
+	 * SIGINT, SIGTSTP, SIGCONT, SIGURG, SIGPIPE, SIGALRM, SIGFSTOP,
+	 * SIGSTART, SIGINJECT, SIGABORT, SIGFABORT
+	 */
+
+	int								i;
+
+	unsigned char					*nom;
+
+#	ifndef IPCS_SYSV // POSIX
+
+	if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires,
+			getpid())) == NULL)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	if ((segment = shm_open(nom, O_RDWR | O_CREAT | O_EXCL,
+			S_IRUSR | S_IWUSR)) == -1)
+	{
+		free(nom);
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	if (ftruncate(segment, nombre_queues * ((2 * longueur_queue) + 4) *
+			sizeof(int)) == -1)
+	{
+		free(nom);
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	fifos = mmap(NULL, nombre_queues * ((2 * longueur_queue) + 4) * sizeof(int),
+			PROT_READ | PROT_WRITE, MAP_SHARED, segment, 0);
+	close(segment);
+
+	if (((void *) fifos) == ((void *) -1))
+	{
+		if (shm_unlink(nom) == -1)
+		{
+			free(nom);
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
+
+		free(nom);
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	free(nom);
+
+#	else // SystemV
+
+	file							*desc;
+
+	key_t							clef;
+
+	// Création d'un segment de données associé au PID du processus courant
+
+	chemin = (*s_etat_processus).chemin_fichiers_temporaires;
+
+	if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires,
+			getpid())) == NULL)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	if ((desc = fopen(nom, "w")) == NULL)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+		return;
+	}
+
+	fclose(desc);
+
+	if ((clef = ftok(nom, 1)) == -1)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	free(nom);
+
+	if ((segment = shmget(clef,
+			nombre_queues * ((2 * longueur_queue) + 4) * sizeof(int),
+			IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	fifos = shmat(segment, NULL, 0);
+
+	if (((void *) fifos) == ((void *) -1))
+	{
+		if (shmctl(segment, IPC_RMID, 0) == -1)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
+
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+#	endif
+
+	/*
+	 * Structure d'une queue
+	 * 0 : pointeur en lecture sur le premier emplacement libre (int)
+	 * 1 : pointeur en écriture sur le premier emplacement à lire (int)
+	 * 2 : longueur de la queue (int)
+	 * 3 : éléments restants (int)
+	 * 4 à 4 + (2) : queue (int)
+	 * 4 + (2) + 1 ) 4 + 2 * (2) : horodatage en centième de secondes.
+	 */
+
+	for(i = 0; i < nombre_queues; i++)
+	{
+		fifos[(i * (longueur_queue + 4))] = 0;
+		fifos[(i * (longueur_queue + 4)) + 1] = 0;
+		fifos[(i * (longueur_queue + 4)) + 2] = longueur_queue;
+		fifos[(i * (longueur_queue + 4)) + 3] = longueur_queue;
+	}
+
+	// Création des sémaphores : un sémaphore par signal et par queue
+	// plus un sémaphore global pour tous les threads.
+
+	for(i = 0; i < nombre_queues; i++)
+	{
+		if ((nom = nom_semaphore(getpid(), i)) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
+
+		// Le sémaphore est créé en écrasant si nécessaire un sémaphore
+		// préexistant. Comme le nom du sémaphore contient l'identifiant du
+		// processus, il est anormal d'avoir un sémaphore de même nom
+		// préexistant.
+
+		if ((semaphores[i] = sem_open(nom, O_CREAT, S_IRUSR | S_IWUSR,
+				1)) == SEM_FAILED)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_semaphore;
+			return;
+		}
+
+		free(nom);
+	}
+
+
+	if ((nom = nom_semaphore(getpid(), nombre_queues)) == NULL)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	if ((semaphore_global = sem_open(nom, O_CREAT, S_IRUSR | S_IWUSR,
+			1)) == SEM_FAILED)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_semaphore;
+		return;
+	}
+
+	free(nom);
+
+	markov = 0;
+
+	return;
+}
+
+void
+liberation_fifos_signaux(struct_processus *s_etat_processus)
+{
+	int					i;
+
+#	ifdef IPCS_SYSV // SystemV
+
+	if (shmdt(fifos) == -1)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+#	else // POSIX
+
+	if (munmap(fifos, nombre_queues * ((2 * longueur_queue) + 4) * sizeof(int))
+			!= 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+#	endif
+
+	for(i = 0; i < nombre_queues; i++)
+	{
+		if (sem_close(semaphores[i]) != 0)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_semaphore;
+			return;
+		}
+	}
+
+	if (sem_close(semaphore_global) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_semaphore;
+		return;
+	}
+
+	return;
+}
+
+void
+destruction_fifos_signaux(struct_processus *s_etat_processus)
+{
+	int					i;
+
+	unsigned char		*nom;
+
+#	ifdef IPCS_SYSV // SystemV
+
+	if (shmdt(fifos) == -1)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	if (shmctl(segment, IPC_RMID, 0) == -1)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires,
+			getpid())) == NULL)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	unlink(nom);
+	free(nom);
+
+#	else // POSIX
+
+	if (munmap(fifos, nombre_queues * ((2 * longueur_queue) + 4) * sizeof(int))
+			!= 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	if ((nom = nom_segment(NULL, getpid())) == NULL)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	if (shm_unlink(nom) != 0)
+	{
+		free(nom);
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	free(nom);
+
+#	endif
+
+	for(i = 0; i < nombre_queues; i++)
+	{
+		if ((nom = nom_semaphore(getpid(), i)) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
+
+		if (sem_unlink(nom) != 0)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_semaphore;
+			return;
+		}
+
+		free(nom);
+	}
+
+	if ((nom = nom_semaphore(getpid(), nombre_queues)) == NULL)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	if (sem_unlink(nom) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_semaphore;
+		return;
+	}
+
+	free(nom);
+
+	return;
+}
+
+inline int
+horodatage()
+{
+	int				ts;
+
+	struct timeval	tv;
+
+	gettimeofday(&tv, NULL);
+	ts = (int) ((tv.tv_sec * 100) + (tv.tv_usec / 10000));
+
+	return(ts);
+}
+
+int
+queue_in(pid_t pid, int signal)
+{
+	int				queue;
+	int				*base;
+	int				*buffer;
+	int				horodatage_initial;
+	int				identifiant;
+	int				*projection_fifos;
+
+	sem_t			*semaphore;
+
+	queue = queue_de_signal(signal);
+
+	unsigned char	*nom;
+
+#	ifndef IPCS_SYSV
+
+	// Ouverture des projections
+
+	if ((nom = nom_segment(NULL, pid)) == NULL)
+	{
+		return(-1);
+	}
+
+	// Dans le cas de SIGSTART, premier signal envoyé à un processus fils,
+	// il convient d'attendre que le fichier support soit effectivement
+	// accessible. Dans tous les autres cas, ce fichier doit exister. S'il
+	// n'existe plus, le processus associé n'existe plus.
+
+	if (signal == SIGSTART)
+	{
+		horodatage_initial = horodatage();
+
+		while((identifiant = shm_open(nom, O_RDWR, S_IRUSR | S_IWUSR)) == -1)
+		{
+			if (abs(horodatage_initial - horodatage()) > 500)
+			{
+				return(-1);
+			}
+		}
+	}
+	else
+	{
+		if ((identifiant = shm_open(nom, O_RDWR, S_IRUSR | S_IWUSR)) == -1)
+		{
+			return(-1);
+		}
+	}
+
+	projection_fifos = mmap(NULL, nombre_queues * ((2 * longueur_queue) + 4)
+			* sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, identifiant, 0);
+	close(identifiant);
+
+	if (((void *) projection_fifos) == ((void *) -1))
+	{
+		return(-1);
+	}
+
+#	else // Traitement à l'aide d'IPCS SystemV
+
+	key_t			clef;
+
+	struct stat		s_stat;
+
+	// Ouverture des projections
+
+	if ((nom = nom_segment(chemin, pid)) == NULL)
+	{
+		return(-1);
+	}
+
+	// Dans le cas de SIGSTART, premier signal envoyé à un processus fils,
+	// il convient d'attendre que le fichier support soit effectivement
+	// accessible. Dans tous les autres cas, ce fichier doit exister. S'il
+	// n'existe plus, le processus associé n'existe plus.
+
+	if (signal == SIGSTART)
+	{
+		// On attend que le fichier sois présent
+
+		horodatage_initial = horodatage();
+
+		while(stat(nom, &s_stat) != 0)
+		{
+			if (abs(horodatage_initial - horodatage()) > 500)
+			{
+				return(-1);
+			}
+		}
+	}
+
+	if ((clef = ftok(nom, 1)) == -1)
+	{
+		return(-1);
+	}
+
+	free(nom);
+
+	if (signal == SIGSTART)
+	{
+		while((identifiant = shmget(clef,
+				nombre_queues * ((2 * longueur_queue) + 4) * sizeof(int),
+				S_IRUSR | S_IWUSR)) == -1);
+	}
+	else
+	{
+		if ((identifiant = shmget(clef,
+				nombre_queues * ((2 * longueur_queue) + 4) * sizeof(int),
+				S_IRUSR | S_IWUSR)) == -1)
+		{
+			return(-1);
+		}
+	}
+
+	projection_fifos = shmat(identifiant, NULL, 0);
+
+	if (((void *) projection_fifos) == ((void *) -1))
+	{
+		return(-1);
+	}
+
+#	endif
+
+	if ((nom = nom_semaphore(pid, queue)) == NULL)
+	{
+#		ifdef IPCS_SYSV
+		shmdt(projection_fifos);
+#		else
+		munmap(projection_fifos, nombre_queues * ((2 * longueur_queue) + 4)
+				* sizeof(int));
+#		endif
+		return(-1);
+	}
+
+	while((semaphore = sem_open(nom, 0)) == SEM_FAILED);
+	free(nom);
+
+	while(sem_wait(semaphore) != 0)
+	{
+		if (errno != EINTR)
+		{
+#			ifdef IPCS_SYSV
+			shmdt(projection_fifos);
+#			else
+			munmap(projection_fifos, nombre_queues * ((2 * longueur_queue) + 4)
+					* sizeof(int));
+#			endif
+			return(-1);
+		}
+	}
+
+	base = &(projection_fifos[(longueur_queue + 4) * queue]);
+	buffer = &(base[4]);
+
+	// base[3] contient le nombre d'éléments restants
+
+	if (base[3] <= 0)
+	{
+		sem_post(semaphore);
+		sem_close(semaphore);
+#		ifdef IPCS_SYSV
+		shmdt(projection_fifos);
+#		else
+		munmap(projection_fifos, nombre_queues * ((2 * longueur_queue) + 4)
+				* sizeof(int));
+#		endif
+		return(-1);
+	}
+
+	base[3]--;
+
+	// base[1] contient le prochain élément à écrire
+
+	buffer[base[1] + (nombre_queues * base[2])] = horodatage();
+	buffer[base[1]++] = (int) pid;
+	base[1] %= base[2];
+
+	if (sem_post(semaphore) != 0)
+	{
+#		ifdef IPCS_SYSV
+		shmdt(projection_fifos);
+#		else
+		munmap(projection_fifos, nombre_queues * ((2 * longueur_queue) + 4)
+				* sizeof(int));
+#		endif
+		sem_close(semaphore);
+		return(-1);
+	}
+
+	sem_close(semaphore);
+
+	// Fermeture des projections
+#	ifdef IPCS_SYSV
+	shmdt(projection_fifos);
+#	else
+	munmap(projection_fifos, nombre_queues * ((2 * longueur_queue) + 4)
+			* sizeof(int));
+#	endif
+
+	return(0);
+}
+
+inline int
+chaine_markov(int markov, int delta)
+{
+	double		memoire = 0.9;
+	int			valeur;
+
+	valeur = (int) ((memoire * markov) + ((1 - memoire) * delta));
+	valeur = (valeur < 10) ? 10 : valeur;
+
+	return(valeur);
+}
+
+pid_t
+origine_signal(int signal)
+{
+	logical1		drapeau;
+
+	int				*base;
+	int				*buffer;
+	int				delta;
+	int				pid;
+	int				queue;
+
+	queue = queue_de_signal(signal);
+
+	BUG(queue == -1, uprintf("[%d] Unknown signal %d in this context\n",
+			(int) getpid(), signal));
+
+	while(sem_wait(semaphores[queue]) != 0)
+	{
+		if (errno != EINTR)
+		{
+			return(-1);
+		}
+	}
+
+	// On retire les interruptions anciennes qui ont été ratées sauf s'il
+	// s'agit de la dernière dans la queue.
+
+	base = &(fifos[(longueur_queue + 4) * queue]);
+	buffer = &(base[4]);
+
+	if (base[3] == (base[2] - 1))
+	{
+		delta = abs(horodatage() -
+				 buffer[base[0] + (nombre_queues * base[2])]);
+		// Une seule interruption dans la queue.
+		pid = buffer[base[0]++];
+		base[0] %= base[2];
+		base[3]++;
+
+		markov = chaine_markov(markov, delta);
+	}
+	else if (base[3] >= base[2])
+	{
+		// Aucune interruption n'est dans la queue.
+		// On a retiré trop d'interruptions de la queue.
+
+		// (base[3] - base[2]) + 1 : nombre d'interruptions manquantes
+		// base[0] - 1             : dernière interruption lue
+		pid = buffer[((((base[0] + base[2] - 1) % base[2])
+				- ((base[3] - base[2]) + 1)) + base[2]) % base[2]];
+	}
+	else
+	{
+		// Plusieurs interruptions à distribuer.
+		drapeau = d_vrai;
+
+		do
+		{
+			delta = abs(horodatage() -
+					 buffer[base[0] + (nombre_queues * base[2])]);
+			pid = buffer[base[0]++];
+			base[0] %= base[2];
+			base[3]++;
+
+			if ((delta > (2 * markov)) && (base[3] < base[2]))
+			{
+				drapeau = d_vrai;
+			}
+			else
+			{
+				drapeau = d_faux;
+			}
+		} while(drapeau == d_vrai);
+
+		markov = chaine_markov(markov, delta);
+	}
+
+	if (sem_post(semaphores[queue]) != 0)
+	{
+		return(-1);
+	}
+
+	return((pid_t) pid);
+}
+
+#endif
+
+void
+interruption1(SIGHANDLER_ARGS)
+{
+	pid_t					pid;
+
 	pthread_t				thread;
 
 	struct_processus		*s_etat_processus;
@@ -1469,17 +2457,33 @@ interruption1(int signal, siginfo_t *sig
 
 	verrouillage_gestionnaire_signaux();
 
+#	ifdef _BROKEN_SIGINFO
+	if (signal == SIGINT)
+	{
+		// Si l'interruption provient du clavier, il n'y a pas eu d'appel
+		// à queue_in().
+
+		pid = getpid();
+	}
+	else
+	{
+		pid = origine_signal(signal);
+	}
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
 	switch(signal)
 	{
 		case SIGALRM :
 		{
-			if ((*siginfo).si_pid == getpid())
+			if (pid == getpid())
 			{
 				if ((s_etat_processus = recherche_thread(getpid(),
 						pthread_self())) == NULL)
 				{
 					deverrouillage_gestionnaire_signaux();
-					return;
+					 return;
 				}
 
 				if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
@@ -1518,11 +2522,14 @@ interruption1(int signal, siginfo_t *sig
 			 * Solaris suit en particulier cette spécification.
 			 */
 
+#			ifndef _BROKEN_SIGINFO
 			if (siginfo == NULL)
 			{
 				kill(getpid(), signal);
 			}
-			else if ((*siginfo).si_pid == getpid())
+			else
+#			endif
+			if (pid == getpid())
 			{
 				if ((s_etat_processus = recherche_thread(getpid(),
 						pthread_self())) == NULL)
@@ -1597,13 +2604,23 @@ interruption1(int signal, siginfo_t *sig
 }
 
 void
-interruption2(int signal, siginfo_t *siginfo, void *context)
+interruption2(SIGHANDLER_ARGS)
 {
+	pid_t					pid;
+
 	pthread_t				thread;
+
 	struct_processus		*s_etat_processus;
 
 	verrouillage_gestionnaire_signaux();
 
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
+#	ifndef _BROKEN_SIGINFO
 	if (siginfo == NULL)
 	{
 		/*
@@ -1621,7 +2638,9 @@ interruption2(int signal, siginfo_t *sig
 			return;
 		}
 	}
-	else if ((*siginfo).si_pid == getpid())
+	else
+#	endif
+	if (pid == getpid())
 	{
 		if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
 				== NULL)
@@ -1669,14 +2688,22 @@ interruption2(int signal, siginfo_t *sig
 }
 
 void
-interruption3(int signal, siginfo_t *siginfo, void *context)
+interruption3(SIGHANDLER_ARGS)
 {
+	pid_t					pid;
+
 	struct_processus		*s_etat_processus;
 
 	static int				compteur = 0;
 
 	verrouillage_gestionnaire_signaux();
 
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
 	if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
 	{
 		deverrouillage_gestionnaire_signaux();
@@ -1729,12 +2756,20 @@ interruption3(int signal, siginfo_t *sig
 }
 
 void
-interruption4(int signal, siginfo_t *siginfo, void *context)
+interruption4(SIGHANDLER_ARGS)
 {
+	pid_t					pid;
+
 	struct_processus		*s_etat_processus;
 
 	verrouillage_gestionnaire_signaux();
 
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
 	if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
 	{
 		deverrouillage_gestionnaire_signaux();
@@ -1757,14 +2792,23 @@ interruption4(int signal, siginfo_t *sig
 }
 
 void
-interruption5(int signal, siginfo_t *siginfo, void *context)
+interruption5(SIGHANDLER_ARGS)
 {
+	pid_t					pid;
+
 	pthread_t				thread;
+
 	struct_processus		*s_etat_processus;
 
 	verrouillage_gestionnaire_signaux();
 
-	if ((*siginfo).si_pid == getpid())
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
+	if (pid == getpid())
 	{
 		if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
 				== NULL)
@@ -1798,11 +2842,18 @@ interruption5(int signal, siginfo_t *sig
 	}
 	else
 	{
+		if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
+				== NULL)
+		{
+			deverrouillage_gestionnaire_signaux();
+			return;
+		}
+
 		// Envoi d'un signal au thread maître du groupe.
 
 		if (recherche_thread_principal(getpid(), &thread) == d_vrai)
 		{
-			pthread_kill(thread, SIGFSTOP);
+			pthread_kill(thread, signal);
 			deverrouillage_gestionnaire_signaux();
 			return;
 		}
@@ -1813,12 +2864,20 @@ interruption5(int signal, siginfo_t *sig
 }
 
 void
-interruption6(int signal, siginfo_t *siginfo, void *context)
+interruption6(SIGHANDLER_ARGS)
 {
+	pid_t					pid;
+
 	struct_processus		*s_etat_processus;
 
 	verrouillage_gestionnaire_signaux();
 
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
 	if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
 	{
 		deverrouillage_gestionnaire_signaux();
@@ -1837,12 +2896,20 @@ interruption6(int signal, siginfo_t *sig
 }
 
 void
-interruption7(int signal, siginfo_t *siginfo, void *context)
+interruption7(SIGHANDLER_ARGS)
 {
+	pid_t					pid;
+
 	struct_processus		*s_etat_processus;
 
 	verrouillage_gestionnaire_signaux();
 
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
 	if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
 	{
 		deverrouillage_gestionnaire_signaux();
@@ -1864,14 +2931,23 @@ interruption7(int signal, siginfo_t *sig
 }
 
 void
-interruption8(int signal, siginfo_t *siginfo, void *context)
+interruption8(SIGHANDLER_ARGS)
 {
+	pid_t					pid;
+
 	pthread_t				thread;
+
 	struct_processus		*s_etat_processus;
 
 	verrouillage_gestionnaire_signaux();
 
-	if ((*siginfo).si_pid == getpid())
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
+	if (pid == getpid())
 	{
 		if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
 				== NULL)
@@ -1907,12 +2983,20 @@ interruption8(int signal, siginfo_t *sig
 }
 
 void
-interruption9(int signal, siginfo_t *siginfo, void *context)
+interruption9(SIGHANDLER_ARGS)
 {
+	pid_t					pid;
+
 	struct_processus		*s_etat_processus;
 
 	verrouillage_gestionnaire_signaux();
 
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
 	if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
 	{
 		deverrouillage_gestionnaire_signaux();
@@ -1926,22 +3010,40 @@ interruption9(int signal, siginfo_t *sig
 		fflush(stdout);
 	}
 
-	pthread_kill((*s_etat_processus).tid_processus_pere, SIGFSTOP);
+#	ifdef _BROKEN_SIGINFO
+	if (queue_in(getpid(), signal) != 0)
+	{
+		return;
+	}
+
+	deverrouillage_gestionnaire_signaux();
+	interruption11(signal);
+#	else
 	deverrouillage_gestionnaire_signaux();
+	interruption11(signal, siginfo, context);
+#	endif
 	return;
 }
 
 void
-interruption10(int signal, siginfo_t *siginfo, void *context)
+interruption10(SIGHANDLER_ARGS)
 {
 	file					*fichier;
 
+	pid_t					pid;
+
 	struct_processus		*s_etat_processus;
 
 	unsigned char			nom[8 + 64 + 1];
 
 	verrouillage_gestionnaire_signaux();
 
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
 	if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
 	{
 		deverrouillage_gestionnaire_signaux();
@@ -1973,6 +3075,82 @@ interruption10(int signal, siginfo_t *si
 }
 
 void
+interruption11(SIGHANDLER_ARGS)
+{
+	pid_t					pid;
+
+	pthread_t				thread;
+
+	struct_processus		*s_etat_processus;
+
+	verrouillage_gestionnaire_signaux();
+
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
+	if (pid == getpid())
+	{
+		if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
+				== NULL)
+		{
+			deverrouillage_gestionnaire_signaux();
+			return;
+		}
+
+		(*s_etat_processus).arret_depuis_abort = -1;
+
+		if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
+		{
+			printf("[%d] SIGFABORT (thread %llu)\n", (int) getpid(),
+					(unsigned long long) pthread_self());
+			fflush(stdout);
+		}
+
+		/*
+		 * var_globale_traitement_retarde_stop :
+		 *  0 -> traitement immédiat
+		 *  1 -> traitement retardé (aucun signal reçu)
+		 * -1 -> traitement retardé (un ou plusieurs signaux stop reçus)
+		 */
+
+		if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0)
+		{
+			(*s_etat_processus).var_volatile_requete_arret = -1;
+		}
+		else
+		{
+			(*s_etat_processus).var_volatile_traitement_retarde_stop = -1;
+		}
+	}
+	else
+	{
+		if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
+				== NULL)
+		{
+			deverrouillage_gestionnaire_signaux();
+			return;
+		}
+
+		(*s_etat_processus).arret_depuis_abort = -1;
+
+		// Envoi d'un signal au thread maître du groupe.
+
+		if (recherche_thread_principal(getpid(), &thread) == d_vrai)
+		{
+			pthread_kill(thread, signal);
+			deverrouillage_gestionnaire_signaux();
+			return;
+		}
+	}
+
+	deverrouillage_gestionnaire_signaux();
+	return;
+}
+
+void
 traitement_exceptions_gsl(const char *reason, const char *file,
 		int line, int gsl_errno)
 {
@@ -1991,4 +3169,111 @@ traitement_exceptions_gsl(const char *re
 	return;
 }
 
+#ifdef _BROKEN_SIGINFO
+
+#undef kill
+#undef pthread_kill
+
+int
+kill_broken_siginfo(pid_t pid, int signal)
+{
+	int					ios;
+
+	sem_t				*semaphore;
+
+	unsigned char		*nom;
+
+	/*
+	 * Lorsqu'on veut interrompre le processus pid, on ouvre le segment
+	 * correspondant au processus en question et ou ajoute le pid dans la
+	 * queue.
+	 *
+	 * Le sémaphore global à tous les threads d'un même processus sert
+	 * à garantir que les signaux seront traités dans l'ordre de ce qui est
+	 * effectivement mis dans la queue.
+	 */
+
+	// Sémaphore acquis
+
+	if ((nom = nom_semaphore(getpid(), nombre_queues)) == NULL)
+	{
+		return(-1);
+	}
+
+	while((semaphore = sem_open(nom, 0)) == SEM_FAILED);
+	free(nom);
+
+	while(sem_wait(semaphore) != 0)
+	{
+		if (errno != EINTR)
+		{
+			return(-1);
+		}
+	}
+
+	if ((signal != 0) && (signal != SIGINT))
+	{
+		if (queue_in(pid, signal) != 0)
+		{
+			sem_post(semaphore);
+			sem_close(semaphore);
+			return(-1);
+		}
+	}
+
+	ios = kill(pid, signal);
+
+	// Sémaphore relâché
+
+	sem_post(semaphore);
+	sem_close(semaphore);
+
+	return(ios);
+}
+
+int
+pthread_kill_broken_siginfo(pthread_t tid, int signal)
+{
+	int					ios;
+
+	sem_t				*semaphore;
+
+	unsigned char		*nom;
+
+	if ((nom = nom_semaphore(getpid(), nombre_queues)) == NULL)
+	{
+		return(-1);
+	}
+
+	while((semaphore = sem_open(nom, 0)) == SEM_FAILED);
+	free(nom);
+
+	while(sem_wait(semaphore) != 0)
+	{
+		if (errno != EINTR)
+		{
+			return(-1);
+		}
+	}
+
+	if ((signal != 0) && (signal != SIGINT))
+	{
+		if (queue_in(getpid(), signal) != 0)
+		{
+			sem_post(semaphore);
+			sem_close(semaphore);
+			return(-1);
+		}
+	}
+
+	ios = pthread_kill(tid, signal);
+
+	sem_post(semaphore);
+	sem_close(semaphore);
+
+	return(ios);
+}
+
+#endif
+
 // vim: ts=4