--- rpl/src/instructions_w1.c	2011/07/25 07:44:59	1.45
+++ rpl/src/instructions_w1.c	2012/01/17 14:44:12	1.58
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.2
-  Copyright (C) 1989-2011 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.6
+  Copyright (C) 1989-2012 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -262,26 +262,22 @@ instruction_wait(struct_processus *s_eta
 		do
 		{
 #			ifndef SEMAPHORES_NOMMES
-			if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
+				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #			else
-			if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+				if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#			endif
 			{
 				(*s_etat_processus).erreur_systeme = d_es_processus;
 				return;
 			}
-#			endif
 
 			code_retour = nanosleep(&temporisation, &temporisation);
 			erreur = errno;
 
 #			ifndef SEMAPHORES_NOMMES
-			while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+				while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #			else
-			while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+				while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #			endif
 			{
 				if (errno != EINTR)
@@ -1332,6 +1328,27 @@ instruction_write(struct_processus *s_et
 			{
 				BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n"));
 
+				if ((*s_objet_argument_2).type != LST)
+				{
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_type_argument;
+					return;
+				}
+
+				if ((*((struct_liste_chainee *) (*s_objet_argument_2).objet))
+						.donnee == NULL)
+				{
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_type_argument;
+					return;
+				}
+
 				if ((*((*((struct_liste_chainee *) (*s_objet_argument_2).objet))
 						.donnee)).type != CHN)
 				{
@@ -1460,9 +1477,9 @@ instruction_write(struct_processus *s_et
 			}
 
 #			ifndef SEMAPHORES_NOMMES
-			if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
+				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #			else
-			if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+				if (sem_post((*s_etat_processus).semaphore_fork) != 0)
 #			endif
 			{
 				if (sigaction(SIGPIPE, &registre, NULL) != 0)
@@ -1487,9 +1504,9 @@ instruction_write(struct_processus *s_et
 				}
 
 #				ifndef SEMAPHORES_NOMMES
-				while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+					while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #				else
-				while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+					while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #				endif
 				{
 					if (errno != EINTR)
@@ -1511,9 +1528,9 @@ instruction_write(struct_processus *s_et
 			}
 
 #			ifndef SEMAPHORES_NOMMES
-			while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+				while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #			else
-			while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+				while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #			endif
 			{
 				if (errno != EINTR)
@@ -1568,18 +1585,14 @@ instruction_write(struct_processus *s_et
 						d_code_fin_chaine;
 
 #				ifndef SEMAPHORES_NOMMES
-				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
-				{
-					(*s_etat_processus).erreur_systeme = d_es_processus;
-					return;
-				}
+					if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #				else
-				if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+					if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#				endif
 				{
 					(*s_etat_processus).erreur_systeme = d_es_processus;
 					return;
 				}
-#				endif
 
 				if (sendto((*((struct_socket *)
 						(*s_objet_argument_1).objet)).socket, chaine,
@@ -1589,17 +1602,15 @@ instruction_write(struct_processus *s_et
 					ios = errno;
 
 #					ifndef SEMAPHORES_NOMMES
-					while(sem_wait(&((*s_etat_processus)
-							.semaphore_fork)) == -1)
+						while(sem_wait(&((*s_etat_processus).semaphore_fork))
+								!= 0)
 #					else
-					while(sem_wait((*s_etat_processus)
-							.semaphore_fork) == -1)
+						while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #					endif
 					{
 						if (errno != EINTR)
 						{
-							(*s_etat_processus).erreur_systeme =
-									d_es_processus;
+							(*s_etat_processus).erreur_systeme = d_es_processus;
 							return;
 						}
 					}
@@ -1617,9 +1628,9 @@ instruction_write(struct_processus *s_et
 				}
 
 #				ifndef SEMAPHORES_NOMMES
-				while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+					while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #				else
-				while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+					while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #				endif
 				{
 					if (errno != EINTR)
@@ -1648,19 +1659,15 @@ instruction_write(struct_processus *s_et
 					adresse_ipv4.sin_addr.s_addr = htonl(calcul_adresse);
 
 #					ifndef SEMAPHORES_NOMMES
-					if (sem_post(&((*s_etat_processus)
-							.semaphore_fork)) != 0)
-					{
-						(*s_etat_processus).erreur_systeme = d_es_processus;
-						return;
-					}
+						if (sem_post(&((*s_etat_processus).semaphore_fork))
+								!= 0)
 #					else
-					if (sem_post((*s_etat_processus) .semaphore_fork) != 0)
+						if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#					endif
 					{
 						(*s_etat_processus).erreur_systeme = d_es_processus;
 						return;
 					}
-#					endif
 
 					if (sendto((*((struct_socket *)
 							(*s_objet_argument_1).objet)).socket, chaine,
@@ -1668,11 +1675,11 @@ instruction_write(struct_processus *s_et
 							&adresse_ipv4, sizeof(adresse_ipv4)) < 0)
 					{
 #						ifndef SEMAPHORES_NOMMES
-						while(sem_wait(&((*s_etat_processus)
-								.semaphore_fork)) == -1)
+							while(sem_wait(&((*s_etat_processus)
+									.semaphore_fork)) != 0)
 #						else
-						while(sem_wait((*s_etat_processus)
-								.semaphore_fork) == -1)
+							while(sem_wait((*s_etat_processus)
+									.semaphore_fork) != 0)
 #						endif
 						{
 							if (errno != EINTR)
@@ -1689,17 +1696,15 @@ instruction_write(struct_processus *s_et
 					}
 
 #					ifndef SEMAPHORES_NOMMES
-					while(sem_wait(&((*s_etat_processus)
-							.semaphore_fork)) == -1)
+						while(sem_wait(&((*s_etat_processus).semaphore_fork))
+								!= 0)
 #					else
-					while(sem_wait((*s_etat_processus)
-							.semaphore_fork) == -1)
+						while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #					endif
 					{
 						if (errno != EINTR)
 						{
-							(*s_etat_processus).erreur_systeme =
-									d_es_processus;
+							(*s_etat_processus).erreur_systeme = d_es_processus;
 							return;
 						}
 					}
@@ -1737,19 +1742,15 @@ instruction_write(struct_processus *s_et
 							adresse[i], i++);
 
 #					ifndef SEMAPHORES_NOMMES
-					if (sem_post(&((*s_etat_processus)
-							.semaphore_fork)) != 0)
-					{
-						(*s_etat_processus).erreur_systeme = d_es_processus;
-						return;
-					}
+						if (sem_post(&((*s_etat_processus).semaphore_fork))
+								!= 0)
 #					else
-					if (sem_post((*s_etat_processus) .semaphore_fork) != 0)
+						if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#					endif
 					{
 						(*s_etat_processus).erreur_systeme = d_es_processus;
 						return;
 					}
-#					endif
 
 					if (sendto((*((struct_socket *)
 							(*s_objet_argument_1).objet)).socket, chaine,
@@ -1757,11 +1758,11 @@ instruction_write(struct_processus *s_et
 							&adresse_ipv6, sizeof(adresse_ipv6)) < 0)
 					{
 #						ifndef SEMAPHORES_NOMMES
-						while(sem_wait(&((*s_etat_processus)
-								.semaphore_fork)) == -1)
+							while(sem_wait(&((*s_etat_processus)
+									.semaphore_fork)) != 0)
 #						else
-						while(sem_wait((*s_etat_processus)
-								.semaphore_fork) == -1)
+							while(sem_wait((*s_etat_processus)
+									.semaphore_fork) != 0)
 #						endif
 						{
 							if (errno != EINTR)
@@ -1778,11 +1779,10 @@ instruction_write(struct_processus *s_et
 					}
 
 #					ifndef SEMAPHORES_NOMMES
-					while(sem_wait(&((*s_etat_processus)
-							.semaphore_fork)) == -1)
+						while(sem_wait(&((*s_etat_processus).semaphore_fork))
+								!= 0)
 #					else
-					while(sem_wait((*s_etat_processus)
-							.semaphore_fork) == -1)
+						while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #					endif
 					{
 						if (errno != EINTR)
@@ -1988,23 +1988,19 @@ instruction_wflock(struct_processus *s_e
 			}
 
 #			ifndef SEMAPHORES_NOMMES
-			if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
+				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #			else
-			if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+				if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#			endif
 			{
 				(*s_etat_processus).erreur_systeme = d_es_processus;
 				return;
 			}
-#			endif
 
 #			ifndef SEMAPHORES_NOMMES
-			while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+				while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #			else
-			while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+				while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #			endif
 			{
 				if (errno != EINTR)
@@ -2228,9 +2224,9 @@ instruction_wfproc(struct_processus *s_e
 				if ((*(*((struct_processus_fils *) (*(*l_element_courant)
 						.donnee).objet)).thread).processus_detache == d_vrai)
 				{
-					if (kill((*(*((struct_processus_fils *)
+					if (envoi_signal_processus((*(*((struct_processus_fils *)
 							(*(*l_element_courant).donnee).objet)).thread).pid,
-							0) != 0)
+							rpl_signull) != 0)
 					{
 						drapeau_fin = d_vrai;
 					}
@@ -2315,25 +2311,23 @@ instruction_wfproc(struct_processus *s_e
 					}
 
 #					ifndef SEMAPHORES_NOMMES
-					if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
-					{
-						(*s_etat_processus).erreur_systeme = d_es_processus;
-						return;
-					}
+						if (sem_post(&((*s_etat_processus).semaphore_fork))
+								!= 0)
 #					else
-					if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+						if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#					endif
 					{
 						(*s_etat_processus).erreur_systeme = d_es_processus;
 						return;
 					}
-#					endif
 
 					nanosleep(&attente, NULL);
 
 #					ifndef SEMAPHORES_NOMMES
-					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+						while(sem_wait(&((*s_etat_processus).semaphore_fork))
+								!= 0)
 #					else
-					while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+						while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #					endif
 					{
 						if (errno != EINTR)
@@ -2586,25 +2580,23 @@ instruction_wfdata(struct_processus *s_e
 					}
 
 #					ifndef SEMAPHORES_NOMMES
-					if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
-					{
-						(*s_etat_processus).erreur_systeme = d_es_processus;
-						return;
-					}
+						if (sem_post(&((*s_etat_processus).semaphore_fork))
+								!= 0)
 #					else
-					if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+						if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#					endif
 					{
 						(*s_etat_processus).erreur_systeme = d_es_processus;
 						return;
 					}
-#					endif
 
 					nanosleep(&attente, NULL);
 
 #					ifndef SEMAPHORES_NOMMES
-					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+						while(sem_wait(&((*s_etat_processus).semaphore_fork))
+								!= 0)
 #					else
-					while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+						while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #					endif
 					{
 						if (errno != EINTR)
@@ -2714,6 +2706,8 @@ instruction_wfsock(struct_processus *s_e
 	struct_objet			*s_objet_argument;
 	struct_objet			*s_objet_resultat;
 
+	struct pollfd			s_poll;
+
 	struct sockaddr_in		adresse_ipv4;
 #	ifdef IPV6
 	struct sockaddr_in6		adresse_ipv6;
@@ -2767,25 +2761,18 @@ instruction_wfsock(struct_processus *s_e
 				"STREAM") != 0) && (strcmp((*((struct_socket *)
 				(*s_objet_argument).objet)).type, "SEQUENTIAL DATAGRAM") != 0))
 		{
-			liberation(s_etat_processus, s_objet_argument);
+			// Mode non connecté : l'attente se fait sur un poll()
 
-			(*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
-			return;
-		}
-
-		if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument,
-				'O')) == NULL)
-		{
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			return;
-		}
-
-		(*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute = 'N';
-		(*((struct_socket *) (*s_objet_resultat).objet)).effacement = 'N';
+			if ((s_objet_resultat = copie_objet(s_etat_processus,
+					s_objet_argument, 'P')) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
 
-		if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine == PF_INET)
-		{
-			longueur = sizeof(adresse_ipv4);
+			s_poll.fd = (*((struct_socket *) (*s_objet_argument).objet)).socket;
+			s_poll.events = POLLIN;
+			s_poll.revents = 0;
 
 			do
 			{
@@ -2793,37 +2780,25 @@ instruction_wfsock(struct_processus *s_e
 
 #				ifndef SEMAPHORES_NOMMES
 				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
-				{
-					(*s_etat_processus).erreur_systeme = d_es_processus;
-					return;
-				}
 #				else
 				if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#				endif
 				{
 					(*s_etat_processus).erreur_systeme = d_es_processus;
 					return;
 				}
-#				endif
 
-				if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =
-						accept((*((struct_socket *) (*s_objet_argument).objet))
-						.socket, (struct sockaddr *) &adresse_ipv4, &longueur))
-						< 0)
+				if (poll(&s_poll, 1, -1) < 0)
 				{
 					erreur = errno;
 
 #					ifndef SEMAPHORES_NOMMES
-					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+					while(sem_wait(&((*s_etat_processus)
+							.semaphore_fork)) != 0)
 #					else
-					while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+					while(sem_wait((*s_etat_processus).semaphore_fork)
+							!= 0)
 #					endif
-					{
-						if (errno != EINTR)
-						{
-							(*s_etat_processus).erreur_systeme = d_es_processus;
-							return;
-						}
-					}
 
 					if (erreur != EINTR)
 					{
@@ -2849,299 +2824,424 @@ instruction_wfsock(struct_processus *s_e
 				else
 				{
 #					ifndef SEMAPHORES_NOMMES
-					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+						while(sem_wait(&((*s_etat_processus)
+								.semaphore_fork)) != 0)
 #					else
-					while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+						while(sem_wait((*s_etat_processus).semaphore_fork)
+								!= 0)
 #					endif
 					{
 						if (errno != EINTR)
 						{
-							(*s_etat_processus).erreur_systeme = d_es_processus;
+							(*s_etat_processus).erreur_systeme =
+									d_es_processus;
 							return;
 						}
 					}
 				}
 			} while(drapeau == d_faux);
 
-			if (((*((struct_socket *) (*s_objet_resultat).objet))
-					.adresse_distante = malloc(22 *
-					sizeof(unsigned char))) == NULL)
+			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					s_objet_argument) == d_erreur)
 			{
-				(*s_etat_processus).erreur_systeme =
-						d_es_allocation_memoire;
 				return;
 			}
 
-			sprintf((*((struct_socket *) (*s_objet_resultat).objet))
-					.adresse_distante, "%d.%d.%d.%d(%d)",
-					(ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF,
-					(ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF,
-					(ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF,
-					ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF,
-					ntohs(adresse_ipv4.sin_port));
+			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					s_objet_resultat) == d_erreur)
+			{
+				return;
+			}
 		}
-		else if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine ==
-				PF_INET6)
+		else
 		{
-#			ifdef IPV6
-			longueur = sizeof(adresse_ipv6);
+			// Mode connecté
 
-			do
+			if ((s_objet_resultat = copie_objet(s_etat_processus,
+					s_objet_argument, 'O')) == NULL)
 			{
-				drapeau = d_vrai;
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
 
-#				ifndef SEMAPHORES_NOMMES
-				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
+			(*((struct_socket *) (*s_objet_resultat).objet)).effacement = 'N';
+			(*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute
+					= 'N';
+
+			if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine ==
+					PF_INET)
+			{
+				longueur = sizeof(adresse_ipv4);
+
+				do
 				{
-					(*s_etat_processus).erreur_systeme = d_es_processus;
-					return;
-				}
+					drapeau = d_vrai;
+
+#				ifndef SEMAPHORES_NOMMES
+						if (sem_post(&((*s_etat_processus).semaphore_fork))
+								!= 0)
 #				else
-				if (sem_post((*s_etat_processus).semaphore_fork) != 0)
-				{
-					(*s_etat_processus).erreur_systeme = d_es_processus;
-					return;
-				}
+						if (sem_post((*s_etat_processus).semaphore_fork) != 0)
 #				endif
+					{
+						(*s_etat_processus).erreur_systeme = d_es_processus;
+						return;
+					}
 
-				if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =
-						accept((*((struct_socket *) (*s_objet_argument).objet))
-						.socket, (struct sockaddr *) &adresse_ipv6, &longueur))
-						< 0)
-				{
-					erreur = errno;
+					if (((*((struct_socket *) (*s_objet_resultat).objet))
+							.socket = accept((*((struct_socket *)
+							(*s_objet_argument).objet)).socket,
+							(struct sockaddr *) &adresse_ipv4, &longueur))
+							< 0)
+					{
+						erreur = errno;
 
+#						ifndef SEMAPHORES_NOMMES
+						while(sem_wait(&((*s_etat_processus)
+								.semaphore_fork)) != 0)
+#						else
+						while(sem_wait((*s_etat_processus).semaphore_fork)
+								!= 0)
+#						endif
+						{
+							if (errno != EINTR)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+								return;
+							}
+						}
+
+						if (erreur != EINTR)
+						{
+							liberation(s_etat_processus, s_objet_argument);
+							liberation(s_etat_processus, s_objet_resultat);
+
+							(*s_etat_processus).erreur_execution =
+									d_ex_erreur_acces_fichier;
+							return;
+						}
+
+						scrutation_injection(s_etat_processus);
+
+						if ((*s_etat_processus).var_volatile_requete_arret != 0)
+						{
+							drapeau = d_vrai;
+						}
+						else
+						{
+							drapeau = d_faux;
+						}
+					}
+					else
+					{
 #					ifndef SEMAPHORES_NOMMES
-					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+							while(sem_wait(&((*s_etat_processus)
+									.semaphore_fork)) != 0)
 #					else
-					while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+							while(sem_wait((*s_etat_processus).semaphore_fork)
+									!= 0)
 #					endif
-					{
-						if (errno != EINTR)
 						{
-							(*s_etat_processus).erreur_systeme = d_es_processus;
-							return;
+							if (errno != EINTR)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+								return;
+							}
 						}
 					}
+				} while(drapeau == d_faux);
 
-					if (erreur != EINTR)
-					{
-						liberation(s_etat_processus, s_objet_argument);
-						liberation(s_etat_processus, s_objet_resultat);
+				if (((*((struct_socket *) (*s_objet_resultat).objet))
+						.adresse_distante = malloc(22 *
+						sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
 
-						(*s_etat_processus).erreur_execution =
-								d_ex_erreur_acces_fichier;
+				sprintf((*((struct_socket *) (*s_objet_resultat).objet))
+						.adresse_distante, "%d.%d.%d.%d(%d)",
+						(ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF,
+						(ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF,
+						(ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF,
+						ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF,
+						ntohs(adresse_ipv4.sin_port));
+			}
+			else if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine ==
+					PF_INET6)
+			{
+#			ifdef IPV6
+				longueur = sizeof(adresse_ipv6);
+
+				do
+				{
+					drapeau = d_vrai;
+
+#				ifndef SEMAPHORES_NOMMES
+						if (sem_post(&((*s_etat_processus).semaphore_fork))
+								!= 0)
+#				else
+						if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#				endif
+					{
+						(*s_etat_processus).erreur_systeme = d_es_processus;
 						return;
 					}
 
-					scrutation_injection(s_etat_processus);
-
-					if ((*s_etat_processus).var_volatile_requete_arret != 0)
+					if (((*((struct_socket *) (*s_objet_resultat).objet))
+							.socket = accept((*((struct_socket *)
+							(*s_objet_argument).objet)).socket,
+							(struct sockaddr *) &adresse_ipv6, &longueur)) < 0)
 					{
-						drapeau = d_vrai;
+						erreur = errno;
+
+#					ifndef SEMAPHORES_NOMMES
+							while(sem_wait(&((*s_etat_processus)
+									.semaphore_fork)) != 0)
+#					else
+							while(sem_wait((*s_etat_processus).semaphore_fork)
+									!= 0)
+#					endif
+						{
+							if (errno != EINTR)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+								return;
+							}
+						}
+
+						if (erreur != EINTR)
+						{
+							liberation(s_etat_processus, s_objet_argument);
+							liberation(s_etat_processus, s_objet_resultat);
+
+							(*s_etat_processus).erreur_execution =
+									d_ex_erreur_acces_fichier;
+							return;
+						}
+
+						scrutation_injection(s_etat_processus);
+
+						if ((*s_etat_processus).var_volatile_requete_arret != 0)
+						{
+							drapeau = d_vrai;
+						}
+						else
+						{
+							drapeau = d_faux;
+						}
 					}
 					else
 					{
-						drapeau = d_faux;
-					}
-				}
-				else
-				{
 #					ifndef SEMAPHORES_NOMMES
-					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+							while(sem_wait(&((*s_etat_processus)
+									.semaphore_fork)) != 0)
 #					else
-					while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+							while(sem_wait((*s_etat_processus).semaphore_fork)
+									!= 0)
 #					endif
-					{
-						if (errno != EINTR)
 						{
-							(*s_etat_processus).erreur_systeme = d_es_processus;
-							return;
+							if (errno != EINTR)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+								return;
+							}
 						}
 					}
+				} while(drapeau == d_faux);
+
+				if (((*((struct_socket *) (*s_objet_resultat).objet))
+						.adresse_distante = malloc(55 *
+						sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
 				}
-			} while(drapeau == d_faux);
 
-			if (((*((struct_socket *) (*s_objet_resultat).objet))
-					.adresse_distante = malloc(55 *
-					sizeof(unsigned char))) == NULL)
-			{
-				(*s_etat_processus).erreur_systeme =
-						d_es_allocation_memoire;
-				return;
-			}
+				(*((struct_socket *) (*s_objet_resultat).objet))
+						.adresse_distante = d_code_fin_chaine;
 
-			(*((struct_socket *) (*s_objet_resultat).objet))
-					.adresse_distante = d_code_fin_chaine;
+				for(i = 0; i < 16; i++)
+				{
+					sprintf((*((struct_socket *) (*s_objet_resultat)
+							.objet)).adresse_distante, (i == 0) ? "%s%X"
+							: "%s:%X", (*((struct_socket *) (*s_objet_resultat)
+							.objet)).adresse_distante,
+							adresse_ipv6.sin6_addr.s6_addr[i]);
+				}
 
-			for(i = 0; i < 16; i++)
-			{
 				sprintf((*((struct_socket *) (*s_objet_resultat)
-						.objet)).adresse_distante, (i == 0) ? "%s%X" : "%s:%X",
+						.objet)).adresse_distante, "%s(%u)",
 						(*((struct_socket *) (*s_objet_resultat)
 						.objet)).adresse_distante,
-						adresse_ipv6.sin6_addr.s6_addr[i]);
-			}
-
-			sprintf((*((struct_socket *) (*s_objet_resultat)
-					.objet)).adresse_distante, "%s(%u)",
-					(*((struct_socket *) (*s_objet_resultat)
-					.objet)).adresse_distante, ntohs(adresse_ipv6.sin6_port));
+						ntohs(adresse_ipv6.sin6_port));
 #			else
-			if ((*s_etat_processus).langue == 'F')
-			{
-				printf("+++Attention : Support du protocole"
-						" IPv6 indisponible\n");
+				if ((*s_etat_processus).langue == 'F')
+				{
+					printf("+++Attention : Support du protocole"
+							" IPv6 indisponible\n");
+				}
+				else
+				{
+					printf("+++Warning : IPv6 support "
+							"unavailable\n");
+				}
+#			endif
 			}
 			else
 			{
-				printf("+++Warning : IPv6 support "
-						"unavailable\n");
-			}
-#			endif
-		}
-		else
-		{
-			longueur = 0;
+				longueur = 0;
 
-			do
-			{
-				drapeau = d_vrai;
+				do
+				{
+					drapeau = d_vrai;
 
 #				ifndef SEMAPHORES_NOMMES
-				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
-				{
-					(*s_etat_processus).erreur_systeme = d_es_processus;
-					return;
-				}
+						if (sem_post(&((*s_etat_processus).semaphore_fork))
+								!= 0)
 #				else
-				if (sem_post((*s_etat_processus).semaphore_fork) != 0)
-				{
-					(*s_etat_processus).erreur_systeme = d_es_processus;
-					return;
-				}
+						if (sem_post((*s_etat_processus).semaphore_fork) != 0)
 #				endif
+					{
+						(*s_etat_processus).erreur_systeme = d_es_processus;
+						return;
+					}
 
-				if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =
-						accept((*((struct_socket *) (*s_objet_argument).objet))
-						.socket, NULL, &longueur)) < 0)
-				{
-					erreur = errno;
+					if (((*((struct_socket *) (*s_objet_resultat).objet))
+							.socket = accept((*((struct_socket *)
+							(*s_objet_argument).objet)).socket, NULL,
+							&longueur)) < 0)
+					{
+						erreur = errno;
 
 #					ifndef SEMAPHORES_NOMMES
-					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+							while(sem_wait(&((*s_etat_processus)
+									.semaphore_fork)) != 0)
 #					else
-					while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+							while(sem_wait((*s_etat_processus).semaphore_fork)
+									!= 0)
 #					endif
-					{
-						if (errno != EINTR)
 						{
-							(*s_etat_processus).erreur_systeme = d_es_processus;
-							return;
+							if (errno != EINTR)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+								return;
+							}
 						}
-					}
 
-					if (erreur != EINTR)
-					{
-						liberation(s_etat_processus, s_objet_argument);
-						liberation(s_etat_processus, s_objet_resultat);
+						if (erreur != EINTR)
+						{
+							liberation(s_etat_processus, s_objet_argument);
+							liberation(s_etat_processus, s_objet_resultat);
 
-						(*s_etat_processus).erreur_execution =
-								d_ex_erreur_acces_fichier;
-						return;
-					}
+							(*s_etat_processus).erreur_execution =
+									d_ex_erreur_acces_fichier;
+							return;
+						}
 
-					scrutation_injection(s_etat_processus);
+						scrutation_injection(s_etat_processus);
 
-					if ((*s_etat_processus).var_volatile_requete_arret != 0)
-					{
-						drapeau = d_vrai;
+						if ((*s_etat_processus).var_volatile_requete_arret != 0)
+						{
+							drapeau = d_vrai;
+						}
+						else
+						{
+							drapeau = d_faux;
+						}
 					}
 					else
 					{
-						drapeau = d_faux;
-					}
-				}
-				else
-				{
 #					ifndef SEMAPHORES_NOMMES
-					while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+							while(sem_wait(&((*s_etat_processus)
+									.semaphore_fork)) != 0)
 #					else
-					while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+							while(sem_wait((*s_etat_processus).semaphore_fork)
+									!= 0)
 #					endif
-					{
-						if (errno != EINTR)
 						{
-							(*s_etat_processus).erreur_systeme = d_es_processus;
-							return;
+							if (errno != EINTR)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+								return;
+							}
 						}
 					}
-				}
-			} while(drapeau == d_faux);
-		}
-
-		// Si accept() renvoie une erreur non récupérée, il ne peut s'agir
-		// que de EINTR sachant qu'une requête d'arrêt est en court de
-		// traitement.
+				} while(drapeau == d_faux);
+			}
 
-		if ((*((struct_socket *) (*s_objet_resultat).objet)).socket >= 0)
-		{
-			l_element_courant = (*s_etat_processus).s_sockets;
+			// Si accept() renvoie une erreur non récupérée, il ne peut s'agir
+			// que de EINTR sachant qu'une requête d'arrêt est en court de
+			// traitement.
 
-			if (l_element_courant == NULL)
+			if ((*((struct_socket *) (*s_objet_resultat).objet)).socket >= 0)
 			{
-				if (((*s_etat_processus).s_sockets =
-						allocation_maillon(s_etat_processus)) == NULL)
+				l_element_courant = (*s_etat_processus).s_sockets;
+
+				if (l_element_courant == NULL)
 				{
-					(*s_etat_processus).erreur_systeme =
-							d_es_allocation_memoire;
-					return;
+					if (((*s_etat_processus).s_sockets =
+							allocation_maillon(s_etat_processus)) == NULL)
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return;
+					}
+
+					(*(*s_etat_processus).s_sockets).suivant = NULL;
+					l_element_courant = (*s_etat_processus).s_sockets;
 				}
+				else
+				{
+					/*
+					 * Ajout d'un élément à la fin de la liste chaînée
+					 */
 
-				(*(*s_etat_processus).s_sockets).suivant = NULL;
-				l_element_courant = (*s_etat_processus).s_sockets;
-			}
-			else
-			{
-				/*
-				 * Ajout d'un élément à la fin de la liste chaînée
-				 */
+					while((*l_element_courant).suivant != NULL)
+					{
+						l_element_courant = (*l_element_courant).suivant;
+					}
+
+					if (((*l_element_courant).suivant =
+							allocation_maillon(s_etat_processus)) == NULL)
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return;
+					}
 
-				while((*l_element_courant).suivant != NULL)
-				{
 					l_element_courant = (*l_element_courant).suivant;
+					(*l_element_courant).suivant = NULL;
 				}
 
-				if (((*l_element_courant).suivant =
-						allocation_maillon(s_etat_processus)) == NULL)
+				if (((*l_element_courant).donnee = copie_objet(s_etat_processus,
+						s_objet_resultat, 'O')) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
 					return;
 				}
-
-				l_element_courant = (*l_element_courant).suivant;
-				(*l_element_courant).suivant = NULL;
 			}
 
-			if (((*l_element_courant).donnee = copie_objet(s_etat_processus,
-					s_objet_resultat, 'O')) == NULL)
+			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					s_objet_argument) == d_erreur)
 			{
-				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
 			}
-		}
 
-		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-				s_objet_argument) == d_erreur)
-		{
-			return;
-		}
-
-		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-				s_objet_resultat) == d_erreur)
-		{
-			return;
+			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					s_objet_resultat) == d_erreur)
+			{
+				return;
+			}
 		}
 	}
 	else
@@ -3355,25 +3455,21 @@ instruction_wfpoke(struct_processus *s_e
 	do
 	{
 #		ifndef SEMAPHORES_NOMMES
-		if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
-		{
-			(*s_etat_processus).erreur_systeme = d_es_processus;
-			return;
-		}
+			if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #		else
-		if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+			if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#		endif
 		{
 			(*s_etat_processus).erreur_systeme = d_es_processus;
 			return;
 		}
-#		endif
 
 		nanosleep(&attente, NULL);
 
 #		ifndef SEMAPHORES_NOMMES
-		while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+			while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #		else
-		while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+			while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #		endif
 		{
 			if (errno != EINTR)
@@ -3517,26 +3613,22 @@ instruction_wfack(struct_processus *s_et
 		}
 
 #		ifndef SEMAPHORES_NOMMES
-		if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
-		{
-			(*s_etat_processus).erreur_systeme = d_es_processus;
-			return;
-		}
+			if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #		else
-		if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+			if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#		endif
 		{
 			(*s_etat_processus).erreur_systeme = d_es_processus;
 			return;
 		}
-#		endif
 
 		nanosleep(&attente, NULL);
 		INCR_GRANULARITE(attente.tv_nsec);
 
 #		ifndef SEMAPHORES_NOMMES
-		while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+			while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #		else
-		while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+			while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #		endif
 		{
 			if (errno != EINTR)