--- rpl/src/interruptions.c	2010/03/09 10:18:49	1.6
+++ rpl/src/interruptions.c	2010/08/17 11:59:28	1.30
@@ -1,6 +1,6 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.13
+  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);
@@ -1066,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)
 			{
@@ -1149,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)
@@ -1163,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);
 
@@ -1188,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;
 		}
 
@@ -1210,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
@@ -1224,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;
 			}
 		}
@@ -1235,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;
@@ -1330,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
@@ -1358,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)
 		{
@@ -1368,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"));
@@ -1397,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))
 			{
@@ -1441,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)
 		{
@@ -1451,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)
 		{
@@ -1468,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"));
@@ -1491,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);
 
@@ -1506,28 +1724,463 @@ deverrouillage_gestionnaire_signaux()
 	return;
 }
 
+#ifdef _BROKEN_SIGINFO
+
+static int				*fifos;
+static int				segment;
+static int				segment_mutexes;
+static int				longueur_queue;
+static int				nombre_queues;
+
+static pthread_mutex_t	*mutexes;
+
+static unsigned char	*chemin = NULL;
+
+unsigned char *
+nom_segment(unsigned char *chemin, pid_t pid)
+{
+	unsigned char				*fichier;
+
+	if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) *
+			sizeof(unsigned char))) == NULL)
+	{
+		return(NULL);
+	}
+
+	sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid);
+
+	return(fichier);
+}
+
+unsigned char *
+nom_segment_mutexes(unsigned char *chemin, pid_t pid)
+{
+	unsigned char				*fichier;
+
+	if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) *
+			sizeof(unsigned char))) == NULL)
+	{
+		return(NULL);
+	}
+
+	sprintf(fichier, "%s/RPL-SIGMUTEXES-%d", chemin, (int) pid);
+
+	return(fichier);
+}
+
+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);
+	}
+
+	return(-1);
+}
+
+void
+creation_fifos_signaux(struct_processus *s_etat_processus)
+{
+	file							*desc;
+
+	int								i;
+
+	key_t							clef;
+
+	pthread_mutexattr_t				attributs_mutex;
+
+	unsigned char					*nom;
+
+	/*
+	 * Signaux utilisés
+	 * SIGINT, SIGTSTP, SIGCONT, SIGURG, SIGPIPE, SIGALRM, SIGFSTOP,
+	 * SIGSTART, SIGINJECT, SIGABORT, SIGFABORT
+	 */
+
+	// 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;
+	}
+
+	/*
+	 * 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)
+	 * 5 : mutex
+	 */
+
+	nombre_queues = 11;
+	longueur_queue = 256;
+
+	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 * (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))
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	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;
+	}
+
+	if ((nom = nom_segment_mutexes((*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_mutexes = shmget(clef,
+			nombre_queues * sizeof(pthread_mutex_t),
+			IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	mutexes = shmat(segment_mutexes, NULL, 0);
+
+	if (((void *) mutexes) == ((void *) -1))
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	/*
+	 * Création et initialisation d'un mutex par queue. Ce mutex n'est pas
+	 * dans le premier segment parce qu'il peut y avoir des problèmes
+	 * d'alignements sur certaines architectures.
+	 */
+
+	pthread_mutexattr_init(&attributs_mutex);
+	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
+
+	for(i = 0; i < nombre_queues; i++)
+	{
+		pthread_mutex_init(&(mutexes[i]), &attributs_mutex);
+	}
+
+	pthread_mutexattr_destroy(&attributs_mutex);
+	return;
+}
+
 void
-interruption1(int signal, siginfo_t *siginfo, void *context)
+liberation_fifos_signaux(struct_processus *s_etat_processus)
 {
+	if (shmdt(fifos) == -1)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	if (shmdt(mutexes) == -1)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	return;
+}
+
+void
+destruction_fifos_signaux(struct_processus *s_etat_processus)
+{
+	int					i;
+	unsigned char		*nom;
+
+	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;
+	}
+
+	for(i = 0; i < nombre_queues; i++)
+	{
+		pthread_mutex_destroy(&(mutexes[i]));
+	}
+
+	if (shmdt(mutexes) == -1)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	if (shmctl(segment_mutexes, IPC_RMID, 0) == -1)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	if ((nom = nom_segment_mutexes((*s_etat_processus)
+			.chemin_fichiers_temporaires, getpid())) == NULL)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	unlink(nom);
+	free(nom);
+
+	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);
+
+	return;
+}
+
+int
+queue_in(pid_t pid, int signal)
+{
+	int				*base;
+	int				*buffer;
+	int				*projection_fifos;
+	int				queue;
+	int				identifiant;
+
+	key_t			clef;
+
+	pthread_mutex_t	*projection_mutexes;
+
+	unsigned char	*nom;
+
+	queue = queue_de_signal(signal);
+
+	// Ouverture des projections
+
+	if ((nom = nom_segment(chemin, pid)) == NULL)
+	{
+		return(-1);
+	}
+
+	if ((clef = ftok(nom, 1)) == -1)
+	{
+		free(nom);
+		return(-1);
+	}
+
+	free(nom);
+
+	while((identifiant = shmget(clef,
+			nombre_queues * (longueur_queue + 4) * sizeof(int),
+			S_IRUSR | S_IWUSR)) == -1);
+
+	projection_fifos = shmat(identifiant, NULL, 0);
+
+	if ((nom = nom_segment_mutexes(chemin, pid)) == NULL)
+	{
+		return(-1);
+	}
+
+	if ((clef = ftok(nom, 1)) == -1)
+	{
+		free(nom);
+		return(-1);
+	}
+
+	free(nom);
+
+	while((identifiant = shmget(clef,
+			nombre_queues * sizeof(pthread_mutex_t),
+			S_IRUSR | S_IWUSR)) == -1);
+
+	projection_mutexes = shmat(identifiant, NULL, 0);
+
+	if (pthread_mutex_lock(&(projection_mutexes[queue])) != 0)
+	{
+		return(-1);
+	}
+
+	base = &(projection_fifos[(longueur_queue + 4) * queue]);
+	buffer = &(base[4]);
+
+	// base[1] contient le prochain élément à écrire
+	buffer[base[1]++] = (int) pid;
+	base[1] %= base[2];
+
+	// base[3] contient le nombre d'éléments non lus
+	if (base[3] <= 0)
+	{
+		pthread_mutex_unlock(&(projection_mutexes[queue]));
+		shmdt(projection_mutexes);
+		shmdt(projection_fifos);
+		return(-1);
+	}
+
+	base[3]--;
+
+	if (pthread_mutex_unlock(&(projection_mutexes[queue])) != 0)
+	{
+		shmdt(projection_mutexes);
+		shmdt(projection_fifos);
+		return(-1);
+	}
+
+	// Fermeture des projections
+	shmdt(projection_mutexes);
+	shmdt(projection_fifos);
+	return(0);
+}
+
+pid_t
+origine_signal(int signal)
+{
+	int				*base;
+	int				*buffer;
+	int				pid;
+	int				queue;
+
+	queue = queue_de_signal(signal);
+
+	BUG(queue == -1, uprintf("[%d] Unknown signal %d in this context\n",
+			(int) getpid(), signal));
+
+	if (pthread_mutex_lock(&(mutexes[queue])) != 0)
+	{
+		perror("lock");
+		return(-1);
+	}
+
+	base = &(fifos[(longueur_queue + 4) * queue]);
+	buffer = &(base[4]);
+	pid = buffer[base[0]++];
+	base[0] %= base[2];
+	base[3]++;
+
+	if (base[3] > base[2])
+	{
+		uprintf("Base\n");
+		pthread_mutex_unlock(&(mutexes[queue]));
+		return(-1);
+	}
+	if (pthread_mutex_unlock(&(mutexes[queue])) != 0)
+	{
+		perror("unlock");
+		return(-1);
+	}
+
+	return((pid_t) pid);
+}
+
+#endif
+
+void
+interruption1(SIGHANDLER_ARGS)
+{
+	pid_t					pid;
+
 	pthread_t				thread;
 
 	struct_processus		*s_etat_processus;
 
 	volatile sig_atomic_t	exclusion = 0;
 
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
 	verrouillage_gestionnaire_signaux();
 
 	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)
@@ -1566,11 +2219,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)
@@ -1645,13 +2301,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;
 
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
 	verrouillage_gestionnaire_signaux();
 
+#	ifndef _BROKEN_SIGINFO
 	if (siginfo == NULL)
 	{
 		/*
@@ -1669,7 +2335,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)
@@ -1717,12 +2385,20 @@ 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;
 
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
 	verrouillage_gestionnaire_signaux();
 
 	if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
@@ -1777,10 +2453,18 @@ 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;
 
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
 	verrouillage_gestionnaire_signaux();
 
 	if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
@@ -1805,14 +2489,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;
 
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
 	verrouillage_gestionnaire_signaux();
 
-	if ((*siginfo).si_pid == getpid())
+	if (pid == getpid())
 	{
 		if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
 				== NULL)
@@ -1846,11 +2539,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;
 		}
@@ -1861,10 +2561,18 @@ 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;
 
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
 	verrouillage_gestionnaire_signaux();
 
 	if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
@@ -1885,10 +2593,18 @@ 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;
 
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
 	verrouillage_gestionnaire_signaux();
 
 	if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
@@ -1912,14 +2628,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;
 
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
 	verrouillage_gestionnaire_signaux();
 
-	if ((*siginfo).si_pid == getpid())
+	if (pid == getpid())
 	{
 		if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
 				== NULL)
@@ -1955,10 +2680,18 @@ 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;
 
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
 	verrouillage_gestionnaire_signaux();
 
 	if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
@@ -1974,20 +2707,38 @@ interruption9(int signal, siginfo_t *sig
 		fflush(stdout);
 	}
 
-	pthread_kill((*s_etat_processus).tid_processus_pere, SIGFSTOP);
 	deverrouillage_gestionnaire_signaux();
+
+#	ifdef _BROKEN_SIGINFO
+	if (queue_in(getpid(), signal) != 0)
+	{
+		return;
+	}
+
+	interruption11(signal);
+#	else
+	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];
 
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
 	verrouillage_gestionnaire_signaux();
 
 	if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
@@ -2021,6 +2772,82 @@ interruption10(int signal, siginfo_t *si
 }
 
 void
+interruption11(SIGHANDLER_ARGS)
+{
+	pid_t					pid;
+
+	pthread_t				thread;
+
+	struct_processus		*s_etat_processus;
+
+#	ifdef _BROKEN_SIGINFO
+	pid = origine_signal(signal);
+#	else
+	pid = (*siginfo).si_pid;
+#	endif
+
+	verrouillage_gestionnaire_signaux();
+
+	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)
 {
@@ -2039,4 +2866,45 @@ traitement_exceptions_gsl(const char *re
 	return;
 }
 
+#ifdef _BROKEN_SIGINFO
+
+#undef kill
+#undef pthread_kill
+
+int
+rpl_kill(pid_t pid, int signal)
+{
+	/*
+	 * Lorsqu'on veut interrompre le processus pid, on ouvre le segment
+	 * correspondant au processus en question et ou ajoute le pid dans la
+	 * queue.
+	 */
+
+	if (signal != 0)
+	{
+		if (queue_in(pid, signal) != 0)
+		{
+			return(-1);
+		}
+	}
+
+	return(kill(pid, signal));
+}
+
+int
+rpl_pthread_kill(pthread_t tid, int signal)
+{
+	if (signal != 0)
+	{
+		if (queue_in(getpid(), signal) != 0)
+		{
+			return(-1);
+		}
+	}
+
+	return(pthread_kill(tid, signal));
+}
+
+#endif
+
 // vim: ts=4