--- rpl/src/interruptions.c	2011/09/15 19:30:38	1.71
+++ rpl/src/interruptions.c	2011/09/20 07:16:40	1.76
@@ -59,7 +59,7 @@ static volatile struct_liste_chainee_vol
 		= NULL;
 static volatile int								code_erreur_gsl = 0;
 
-static unsigned char							*racine_segment;
+unsigned char									*racine_segment;
 
 static pthread_mutex_t							mutex_interruptions
 		= PTHREAD_MUTEX_INITIALIZER;
@@ -2251,7 +2251,11 @@ scrutation_interruptions(struct_processu
 	// à lire. Les pointeurs d'écriture pointent sur les prochains éléments à
 	// écrire.
 
-	if (sem_trywait(&((*s_queue_signaux).semaphore)) == 0)
+#	ifndef SEMAPHORES_NOMMES
+		if (sem_trywait(&((*s_queue_signaux).semaphore)) == 0)
+#	else
+		if (sem_trywait(semaphore_queue_signaux) == 0)
+#	endif
 	{
 		if ((*s_queue_signaux).pointeur_lecture !=
 				(*s_queue_signaux).pointeur_ecriture)
@@ -2268,7 +2272,11 @@ scrutation_interruptions(struct_processu
 					% LONGUEUR_QUEUE_SIGNAUX;
 		}
 
-		sem_post(&((*s_queue_signaux).semaphore));
+#		ifndef SEMAPHORES_NOMMES
+			sem_post(&((*s_queue_signaux).semaphore));
+#		else
+			sem_post(semaphore_queue_signaux);
+#		endif
 	}
 
 	// Interruptions qui arrivent depuis le groupe courant de threads.
@@ -2364,6 +2372,15 @@ envoi_signal_processus(pid_t pid, enum s
 {
 	int								segment;
 
+#	ifndef IPCS_SYSV
+#		ifdef SEMAPHORES_NOMMES
+			sem_t					*semaphore;
+#		endif
+#	else
+		int							desc;
+		key_t						clef;
+#	endif
+
 	struct_queue_signaux			*queue;
 
 	unsigned char					*nom;
@@ -2380,7 +2397,11 @@ envoi_signal_processus(pid_t pid, enum s
 			return(1);
 		}
 
-		if (sem_wait(&((*s_queue_signaux).semaphore)) != 0)
+#		ifndef SEMAPHORES_NOMMES
+			if (sem_wait(&((*s_queue_signaux).semaphore)) != 0)
+#		else
+			if (sem_wait(semaphore_queue_signaux) != 0)
+#		endif
 		{
 			return(1);
 		}
@@ -2394,7 +2415,11 @@ envoi_signal_processus(pid_t pid, enum s
 				((*s_queue_signaux).pointeur_ecriture + 1)
 				% LONGUEUR_QUEUE_SIGNAUX;
 
-		if (sem_post(&((*s_queue_signaux).semaphore)) != 0)
+#		ifndef SEMAPHORES_NOMMES
+			if (sem_post(&((*s_queue_signaux).semaphore)) != 0)
+#		else
+			if (sem_post(semaphore_queue_signaux) != 0)
+#		endif
 		{
 			return(1);
 		}
@@ -2403,31 +2428,84 @@ envoi_signal_processus(pid_t pid, enum s
 	{
 		// Le signal est envoyé depuis un processus distinct.
 
-		if ((nom = nom_segment(racine_segment, pid)) == NULL)
-		{
-			return(1);
-		}
+#		ifdef IPCS_SYSV
+			if ((nom = nom_segment(racine_segment, pid)) == NULL)
+			{
+				return(1);
+			}
+
+			if ((desc = open(nom, O_RDWR)) == -1)
+			{
+				free(nom);
+				return(1);
+			}
+
+			close(desc);
+
+			if ((clef = ftok(nom, 1)) == -1)
+			{
+				free(nom);
+				return(1);
+			}
 
-		if ((segment = shm_open(nom, O_RDWR, 0)) == -1)
-		{
 			free(nom);
-			return(1);
-		}
 
-		free(nom);
+			if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0)) == -1)
+			{
+				return(1);
+			}
 
-		if ((queue = mmap(NULL, sizeof(struct_queue_signaux),
-				PROT_READ | PROT_WRITE, MAP_SHARED, segment, 0)) ==
-				MAP_FAILED)
-		{
-			close(segment);
-			return(1);
-		}
+			queue = shmat(segment, NULL, 0);
+#		else // POSIX
+			if ((nom = nom_segment(racine_segment, pid)) == NULL)
+			{
+				return(1);
+			}
 
-		if (sem_wait(&((*queue).semaphore)) != 0)
-		{
-			return(1);
-		}
+			if ((segment = shm_open(nom, O_RDWR, 0)) == -1)
+			{
+				free(nom);
+				return(1);
+			}
+
+			free(nom);
+
+			if ((queue = mmap(NULL, sizeof(struct_queue_signaux),
+					PROT_READ | PROT_WRITE, MAP_SHARED, segment, 0)) ==
+					MAP_FAILED)
+			{
+				close(segment);
+				return(1);
+			}
+#		endif
+
+			// À ce moment, le segment de mémoire partagée est projeté
+			// dans l'espace du processus.
+
+#		ifndef IPCS_SYSV // POSIX
+#			ifndef SEMAPHORES_NOMMES
+				if (sem_wait(&((*queue).semaphore)) != 0)
+				{
+					return(1);
+				}
+#			else
+				if ((semaphore = sem_open2(pid)) == SEM_FAILED)
+				{
+					return(1);
+				}
+
+				if (sem_wait(semaphore) != 0)
+				{
+					sem_close(semaphore);
+					return(1);
+				}
+#			endif
+#		else // IPCS_SYSV
+			if (sem_wait(&((*queue).semaphore)) != 0)
+			{
+				return(1);
+			}
+#		endif
 
 		(*queue).queue[(*queue).pointeur_ecriture].pid = getpid();
 		(*queue).queue[(*queue).pointeur_ecriture].signal = signal;
@@ -2435,18 +2513,41 @@ envoi_signal_processus(pid_t pid, enum s
 		(*queue).pointeur_ecriture = ((*queue).pointeur_ecriture + 1)
 				% LONGUEUR_QUEUE_SIGNAUX;
 
-		if (sem_post(&((*queue).semaphore)) != 0)
-		{
-			return(1);
-		}
+#		ifndef IPCS_SYSV // POSIX
+#			ifndef SEMAPHORES_NOMMES
+				if (sem_post(&((*queue).semaphore)) != 0)
+				{
+					return(1);
+				}
+#			else
+				if (sem_post(semaphore) != 0)
+				{
+					sem_close(semaphore);
+					return(1);
+				}
 
-		if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
-		{
-			close(segment);
-			return(1);
-		}
+				if (sem_close(semaphore) != 0)
+				{
+					return(1);
+				}
+#			endif
+
+			if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
+			{
+				close(segment);
+				return(1);
+			}
+#		else // IPCS_SYSV
+			if (sem_post(&((*queue).semaphore)) != 0)
+			{
+				return(1);
+			}
 
-		close(segment);
+			if (shmdt(queue) != 0)
+			{
+				return(1);
+			}
+#		endif
 	}
 
 	return(0);
@@ -2593,13 +2694,12 @@ creation_queue_signaux(struct_processus
 		}
 
 		free(nom);
+
 #		ifndef SEMAPHORES_NOMMES
 			sem_init(&((*s_queue_signaux).semaphore), 1, 1);
 #		else
-			(*s_queue_signaux).semaphore = sem_init2(0,
-					sem_gestionnaires_signaux);
-
-			if ((*s_queue_signaux).semaphore == SEM_FAILED)
+			if ((semaphore_queue_signaux = sem_init2(1, getpid()))
+					== SEM_FAILED)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_processus;
 				return;
@@ -2614,17 +2714,16 @@ creation_queue_signaux(struct_processus
 			(*s_etat_processus).erreur_systeme = d_es_processus;
 			return;
 		}
-#	else // SystemV
+#	else // IPCS_SYSV
 #		ifndef OS2
-			file							*desc;
+			int								segment;
+			int								support;
 
 			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)
 			{
@@ -2632,35 +2731,35 @@ creation_queue_signaux(struct_processus
 				return;
 			}
 
-			if ((desc = fopen(nom, "w")) == NULL)
+			if ((support = open(nom, O_RDWR | O_CREAT | O_EXCL,
+					S_IRUSR | S_IWUSR)) == -1)
 			{
 				(*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;
 			}
 
+			close(support);
 			free(nom);
 
-			if ((segment = shmget(clef,
-					nombre_queues * ((2 * longueur_queue) + 4) * sizeof(int),
+			if ((segment = shmget(clef, sizeof(struct_queue_signaux),
 					IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
 			}
 
-			fifos = shmat(segment, NULL, 0);
+			s_queue_signaux = shmat(segment, NULL, 0);
+			f_queue_signaux = segment;
 
-			if (((void *) fifos) == ((void *) -1))
+			if (((void *) s_queue_signaux) == ((void *) -1))
 			{
-				if (shmctl(segment, IPC_RMID, 0) == -1)
+				if (shmctl(f_queue_signaux, IPC_RMID, 0) == -1)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
@@ -2670,6 +2769,10 @@ creation_queue_signaux(struct_processus
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
 			}
+
+			sem_init(&((*s_queue_signaux).semaphore), 1, 1);
+			(*s_queue_signaux).pointeur_lecture = 0;
+			(*s_queue_signaux).pointeur_ecriture = 0;
 #		else // OS/2
 			if ((nom = nom_segment(NULL, getpid())) == NULL)
 			{
@@ -2713,10 +2816,19 @@ liberation_queue_signaux(struct_processu
 {
 #	ifdef IPCS_SYSV // SystemV
 #		ifndef OS2
+			if (shmdt(s_queue_signaux) == -1)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
 #		else // OS/2
 #		endif
 #	else // POSIX
-		sem_close(&((*s_queue_signaux).semaphore));
+#		ifndef SEMAPHORES_NOMMES
+			sem_close(&((*s_queue_signaux).semaphore));
+#		else
+			sem_close(semaphore_queue_signaux);
+#		endif
 
 		if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)
 		{
@@ -2751,13 +2863,23 @@ destruction_queue_signaux(struct_process
 
 #	ifdef IPCS_SYSV // SystemV
 #		ifndef OS2
-			if (shmdt(fifos) == -1)
+			// Il faut commencer par éliminer le sémaphore.
+
+			if (semctl((*s_queue_signaux).semaphore.sem, 0, IPC_RMID) == -1)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_processus;
+				return;
+			}
+
+			unlink((*s_queue_signaux).semaphore.path);
+
+			if (shmdt(s_queue_signaux) == -1)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
 			}
 
-			if (shmctl(segment, IPC_RMID, 0) == -1)
+			if (shmctl(f_queue_signaux, IPC_RMID, 0) == -1)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -2770,8 +2892,6 @@ destruction_queue_signaux(struct_process
 				return;
 			}
 
-			// FERMER LE FICHIER
-
 			unlink(nom);
 			free(nom);
 #		else
@@ -2785,8 +2905,13 @@ destruction_queue_signaux(struct_process
 
 #		endif
 #	else // POSIX
-		sem_close(&((*s_queue_signaux).semaphore));
-		sem_destroy(&((*s_queue_signaux).semaphore));
+#		ifndef SEMAPHORES_NOMMES
+			sem_close(&((*s_queue_signaux).semaphore));
+			sem_destroy(&((*s_queue_signaux).semaphore));
+#		else
+			sem_close(semaphore_queue_signaux);
+			sem_destroy2(semaphore_queue_signaux, getpid());
+#		endif
 
 		if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)
 		{