--- rpl/src/instructions_w1.c	2013/03/11 11:07:25	1.76
+++ rpl/src/instructions_w1.c	2023/11/24 08:10:19	1.127
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.13
-  Copyright (C) 1989-2013 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.35
+  Copyright (C) 1989-2023 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -245,9 +245,9 @@ instruction_wait(struct_processus *s_eta
 			return;
 		}
 
-		temporisation.tv_sec = (long) floor((double) attente);
-		temporisation.tv_nsec = (attente - temporisation.tv_sec) *
-				(long) 1000000000;
+		temporisation.tv_sec = (time_t) floor((double) attente);
+		temporisation.tv_nsec = (long) ((attente -
+				((real8) temporisation.tv_sec)) * (integer8) 1000000000);
 
 		if ((*s_etat_processus).profilage == d_vrai)
 		{
@@ -289,11 +289,25 @@ instruction_wait(struct_processus *s_eta
 
 			scrutation_injection(s_etat_processus);
 
+			if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions)
+					!= 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_processus;
+				return;
+			}
+
 			if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
 			{
 				affectation_interruptions_logicielles(s_etat_processus);
 			}
 
+			if (pthread_mutex_unlock(&(*s_etat_processus).mutex_interruptions)
+					!= 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_processus;
+				return;
+			}
+
 			if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
 			{
 				traitement_interruptions_logicielles(s_etat_processus);
@@ -390,15 +404,15 @@ instruction_write(struct_processus *s_et
 	integer8							clef;
 	integer8							compteur;
 	integer8							id;
+	integer8							longueur;
+	integer8							longueur_effective;
 	integer8							ordre;
+	integer8							recursivite;
 
 	logical1							format_degenere;
+	logical1							format_oriente_ligne;
 	logical1							mise_a_jour;
 
-	long								longueur;
-	long								longueur_effective;
-	long								recursivite;
-
 	sqlite3_stmt						*ppStmt;
 
 	ssize_t								ios;
@@ -698,7 +712,8 @@ instruction_write(struct_processus *s_et
 
 				free(chaine);
 
-				if (alsprintf(&commande, "insert or replace into data "
+				if (alsprintf(s_etat_processus, &commande,
+						"insert or replace into data "
 						"(id, data) values (%lld, '%s')", (*((integer8 *)
 						(*s_objet_argument_2).objet)), chaine_utf8) < 0)
 				{
@@ -710,7 +725,7 @@ instruction_write(struct_processus *s_et
 				free(chaine_utf8);
 
 				if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
-						commande, strlen(commande), &ppStmt, &queue)
+						commande, (int) strlen(commande), &ppStmt, &queue)
 						!= SQLITE_OK)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
@@ -748,8 +763,8 @@ instruction_write(struct_processus *s_et
 
 				// Récupération de la position de la clef
 
-				if (alsprintf(&commande, "select key from control "
-						"where id = 1") < 0)
+				if (alsprintf(s_etat_processus, &commande,
+						"select key from control where id = 1") < 0)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
@@ -757,7 +772,7 @@ instruction_write(struct_processus *s_et
 				}
 
 				if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
-						commande, strlen(commande), &ppStmt, &queue)
+						commande, (int) strlen(commande), &ppStmt, &queue)
 						!= SQLITE_OK)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
@@ -925,8 +940,8 @@ instruction_write(struct_processus *s_et
 
 				// Récupération de l'identifiant de la clef
 
-				if (alsprintf(&commande, "select id from key where key = "
-						"'%s'", clef_utf8) < 0)
+				if (alsprintf(s_etat_processus, &commande,
+						"select id from key where key = '%s'", clef_utf8) < 0)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
@@ -934,7 +949,7 @@ instruction_write(struct_processus *s_et
 				}
 
 				if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
-						commande, strlen(commande), &ppStmt, &queue)
+						commande, (int) strlen(commande), &ppStmt, &queue)
 						!= SQLITE_OK)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
@@ -971,8 +986,9 @@ instruction_write(struct_processus *s_et
 
 							free(commande);
 
-							if (alsprintf(&commande, "insert into key "
-									"(key) values ('%s')", clef_utf8) < 0)
+							if (alsprintf(s_etat_processus, &commande,
+									"insert into key (key) values ('%s')",
+									clef_utf8) < 0)
 							{
 								(*s_etat_processus).erreur_systeme =
 										d_es_allocation_memoire;
@@ -980,8 +996,8 @@ instruction_write(struct_processus *s_et
 							}
 
 							if (sqlite3_prepare_v2((*descripteur)
-									.descripteur_sqlite,
-									commande, strlen(commande), &ppStmt, &queue)
+									.descripteur_sqlite, commande,
+									(int) strlen(commande), &ppStmt, &queue)
 									!= SQLITE_OK)
 							{
 								(*s_etat_processus).erreur_systeme =
@@ -1005,8 +1021,9 @@ instruction_write(struct_processus *s_et
 
 							free(commande);
 
-							if (alsprintf(&commande, "select id from key "
-									"where key = '%s'", clef_utf8) < 0)
+							if (alsprintf(s_etat_processus, &commande,
+									"select id from key where key = '%s'",
+									clef_utf8) < 0)
 							{
 								(*s_etat_processus).erreur_systeme =
 										d_es_allocation_memoire;
@@ -1014,8 +1031,8 @@ instruction_write(struct_processus *s_et
 							}
 
 							if (sqlite3_prepare_v2((*descripteur)
-									.descripteur_sqlite,
-									commande, strlen(commande), &ppStmt, &queue)
+									.descripteur_sqlite, commande,
+									(int) strlen(commande), &ppStmt, &queue)
 									!= SQLITE_OK)
 							{
 								(*s_etat_processus).erreur_systeme =
@@ -1069,8 +1086,9 @@ instruction_write(struct_processus *s_et
 
 				if (mise_a_jour == d_vrai)
 				{
-					if (alsprintf(&commande, "update key set key = '%s' where "
-							"id = %lld", clef_utf8, id) < 0)
+					if (alsprintf(s_etat_processus, &commande,
+							"update key set key = '%s' where id = %lld",
+							clef_utf8, id) < 0)
 					{
 						(*s_etat_processus).erreur_systeme =
 								d_es_allocation_memoire;
@@ -1078,7 +1096,7 @@ instruction_write(struct_processus *s_et
 					}
 
 					if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
-							commande, strlen(commande), &ppStmt, &queue)
+							commande, (int) strlen(commande), &ppStmt, &queue)
 							!= SQLITE_OK)
 					{
 						(*s_etat_processus).erreur_systeme =
@@ -1105,8 +1123,8 @@ instruction_write(struct_processus *s_et
 
 				// Effacement de l'enregistrement existant
 
-				if (alsprintf(&commande, "delete from data where "
-						"key_id = %lld", id) < 0)
+				if (alsprintf(s_etat_processus, &commande,
+						"delete from data where key_id = %lld", id) < 0)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
@@ -1114,7 +1132,7 @@ instruction_write(struct_processus *s_et
 				}
 
 				if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
-						commande, strlen(commande), &ppStmt, &queue)
+						commande, (int) strlen(commande), &ppStmt, &queue)
 						!= SQLITE_OK)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
@@ -1240,8 +1258,8 @@ instruction_write(struct_processus *s_et
 
 					free(chaine);
 
-					if (alsprintf(&commande, "insert into data "
-							"(data, key_id, sequence) values "
+					if (alsprintf(s_etat_processus, &commande,
+							"insert into data (data, key_id, sequence) values "
 							"('%s', %lld, %lld)", chaine_utf8, id, ordre) < 0)
 					{
 						(*s_etat_processus).erreur_systeme =
@@ -1250,7 +1268,7 @@ instruction_write(struct_processus *s_et
 					}
 
 					if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
-							commande, strlen(commande), &ppStmt, &queue)
+							commande, (int) strlen(commande), &ppStmt, &queue)
 							!= SQLITE_OK)
 					{
 						(*s_etat_processus).erreur_systeme =
@@ -1343,9 +1361,9 @@ instruction_write(struct_processus *s_et
 					return;
 				}
 
-				if (fwrite(chaine, sizeof(unsigned char), longueur_effective,
-						(*descripteur).descripteur_c) !=
-						(size_t) longueur_effective)
+				if (write(fileno((*descripteur).descripteur_c),
+						chaine, (size_t) longueur_effective) !=
+						(ssize_t) longueur_effective)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 					return;
@@ -1479,53 +1497,39 @@ instruction_write(struct_processus *s_et
 						return;
 					}
 
-					if ((format_chaine = conversion_majuscule((unsigned char *)
-							(*(*l_element_courant_format).donnee).objet))
-							== NULL)
+					if ((format_chaine = conversion_majuscule(s_etat_processus,
+							(unsigned char *) (*(*l_element_courant_format)
+							.donnee).objet)) == NULL)
 					{
 						(*s_etat_processus).erreur_systeme =
 								d_es_allocation_memoire;
 						return;
 					}
 
-					if (strncmp("LENGTH*(", format_chaine, 8) != 0)
+					if (strcmp("LINE*(*)", format_chaine) == 0)
 					{
-						free(format_chaine);
-
-						liberation(s_etat_processus, s_objet_argument_2);
-						liberation(s_etat_processus, s_objet_argument_1);
-
-						(*s_etat_processus).erreur_execution =
-								d_ex_erreur_format_fichier;
-						return;
+						format_oriente_ligne = d_vrai;
+						format_degenere = d_vrai;
 					}
-
-					longueur = strlen(format_chaine);
-
-					if (format_chaine[longueur - 1] != ')')
+					else
 					{
-						free(format_chaine);
-
-						liberation(s_etat_processus, s_objet_argument_2);
-						liberation(s_etat_processus, s_objet_argument_1);
+						format_oriente_ligne = d_faux;
+						
+						if (strncmp("LENGTH*(", format_chaine, 8) != 0)
+						{
+							free(format_chaine);
 
-						(*s_etat_processus).erreur_execution =
-								d_ex_erreur_format_fichier;
-						return;
-					}
+							liberation(s_etat_processus, s_objet_argument_2);
+							liberation(s_etat_processus, s_objet_argument_1);
 
-					format_chaine[longueur] = d_code_fin_chaine;
+							(*s_etat_processus).erreur_execution =
+									d_ex_erreur_format_fichier;
+							return;
+						}
 
-					if (format_chaine[8] == '*')
-					{
-						format_degenere = d_vrai;
-					}
-					else
-					{
-						// Détermination de la longueur
-						format_degenere = d_faux;
+						longueur = (integer8) strlen(format_chaine);
 
-						if (sscanf(&(format_chaine[8]), "%ld", &longueur) != 1)
+						if (format_chaine[longueur - 1] != ')')
 						{
 							free(format_chaine);
 
@@ -1536,6 +1540,33 @@ instruction_write(struct_processus *s_et
 									d_ex_erreur_format_fichier;
 							return;
 						}
+
+						format_chaine[longueur] = d_code_fin_chaine;
+
+						if (format_chaine[8] == '*')
+						{
+							format_degenere = d_vrai;
+						}
+						else
+						{
+							// Détermination de la longueur
+							format_degenere = d_faux;
+
+							if (sscanf(&(format_chaine[8]), "%lld", &longueur)
+									!= 1)
+							{
+								free(format_chaine);
+
+								liberation(s_etat_processus,
+										s_objet_argument_2);
+								liberation(s_etat_processus,
+										s_objet_argument_1);
+
+								(*s_etat_processus).erreur_execution =
+										d_ex_erreur_format_fichier;
+								return;
+							}
+						}
 					}
 
 					free(format_chaine);
@@ -1552,10 +1583,9 @@ instruction_write(struct_processus *s_et
 					if ((format_degenere == d_vrai) ||
 							(longueur_effective < longueur))
 					{
-						if (fwrite(chaine, sizeof(unsigned char),
-								longueur_effective,
-								(*descripteur).descripteur_c) !=
-								(size_t) longueur_effective)
+						if (write(fileno((*descripteur).descripteur_c),
+								chaine, (size_t) longueur_effective)
+								!= (ssize_t) longueur_effective)
 						{
 							(*s_etat_processus).erreur_systeme =
 									d_es_erreur_fichier;
@@ -1564,10 +1594,9 @@ instruction_write(struct_processus *s_et
 					}
 					else
 					{
-						if (fwrite(chaine, sizeof(unsigned char),
-								longueur_effective,
-								(*descripteur).descripteur_c) !=
-								(size_t) longueur)
+						if (write(fileno((*descripteur).descripteur_c),
+								chaine, (size_t) longueur_effective)
+								!= (ssize_t) longueur)
 						{
 							(*s_etat_processus).erreur_systeme =
 									d_es_erreur_fichier;
@@ -1577,6 +1606,17 @@ instruction_write(struct_processus *s_et
 
 					free(chaine);
 
+					if (format_oriente_ligne == d_vrai)
+					{
+						if (write(fileno((*descripteur).descripteur_c),
+								"\n", 1) != 1)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_erreur_fichier;
+							return;
+						}
+					}
+
 					l_element_courant = (*l_element_courant).suivant;
 					l_element_courant_format = (*l_element_courant_format)
 							.suivant;
@@ -1645,7 +1685,16 @@ instruction_write(struct_processus *s_et
 			 * Sockets non formatées
 			 */
 
-			chaine = NULL;
+			if ((chaine = formateur_fichier(s_etat_processus,
+					s_objet_argument_2, (*((struct_socket *)
+					(*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',
+					&longueur_effective, &recursivite, d_faux)) == NULL)
+			{
+				liberation(s_etat_processus, s_objet_argument_2);
+				liberation(s_etat_processus, s_objet_argument_1);
+
+				return;
+			}
 		}
 		else
 		{
@@ -1680,43 +1729,50 @@ instruction_write(struct_processus *s_et
 				(*s_objet_argument_1).objet)).type,
 				"SEQUENTIAL DATAGRAM") == 0))
 		{ // Sockets connectées
-
-			action.sa_handler = SIG_IGN;
-			action.sa_flags = SA_ONSTACK;
-
-			if (sigaction(SIGPIPE, &action, &registre) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_signal;
-				return;
-			}
-
 #			ifndef SEMAPHORES_NOMMES
 				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #			else
 				if (sem_post((*s_etat_processus).semaphore_fork) != 0)
 #			endif
 			{
-				if (sigaction(SIGPIPE, &registre, NULL) != 0)
-				{
-					(*s_etat_processus).erreur_systeme = d_es_signal;
-					return;
-				}
+				(*s_etat_processus).erreur_systeme = d_es_processus;
+				return;
+			}
 
+			if (pthread_mutex_lock(&mutex_sigaction) != 0)
+			{
 				(*s_etat_processus).erreur_systeme = d_es_processus;
 				return;
 			}
 
+			action.sa_handler = SIG_IGN;
+			action.sa_flags = 0;
+
+			if (sigaction(SIGPIPE, &action, &registre) != 0)
+			{
+				pthread_mutex_unlock(&mutex_sigaction);
+				(*s_etat_processus).erreur_systeme = d_es_signal;
+				return;
+			}
+
 			if (send((*((struct_socket *) (*s_objet_argument_1).objet))
-					.socket, chaine, longueur_effective, 0) < 0)
+					.socket, chaine, (size_t) longueur_effective, 0) < 0)
 			{
 				ios = errno;
 
 				if (sigaction(SIGPIPE, &registre, NULL) != 0)
 				{
+					pthread_mutex_unlock(&mutex_sigaction);
 					(*s_etat_processus).erreur_systeme = d_es_signal;
 					return;
 				}
 
+				if (pthread_mutex_unlock(&mutex_sigaction) != 0)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_processus;
+					return;
+				}
+
 #				ifndef SEMAPHORES_NOMMES
 					while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #				else
@@ -1741,6 +1797,41 @@ instruction_write(struct_processus *s_et
 				return;
 			}
 
+			if (sigaction(SIGPIPE, &registre, NULL) != 0)
+			{
+				pthread_mutex_unlock(&mutex_sigaction);
+
+#				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)
+					{
+						if (sigaction(SIGPIPE, &registre, NULL) != 0)
+						{
+							pthread_mutex_unlock(&mutex_sigaction);
+							(*s_etat_processus).erreur_systeme = d_es_signal;
+							return;
+						}
+
+						pthread_mutex_unlock(&mutex_sigaction);
+						(*s_etat_processus).erreur_systeme = d_es_processus;
+						return;
+					}
+				}
+
+				(*s_etat_processus).erreur_systeme = d_es_signal;
+				return;
+			}
+
+			if (pthread_mutex_unlock(&mutex_sigaction) != 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_processus;
+				return;
+			}
+
 #			ifndef SEMAPHORES_NOMMES
 				while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #			else
@@ -1759,12 +1850,6 @@ instruction_write(struct_processus *s_et
 					return;
 				}
 			}
-
-			if (sigaction(SIGPIPE, &registre, NULL) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_signal;
-				return;
-			}
 		}
 		else
 		{ // Sockets non connectées
@@ -1810,7 +1895,7 @@ instruction_write(struct_processus *s_et
 
 				if (sendto((*((struct_socket *)
 						(*s_objet_argument_1).objet)).socket, chaine,
-						longueur_effective, 0, (struct sockaddr *)
+						(size_t) longueur_effective, 0, (struct sockaddr *)
 						&adresse_unix, sizeof(adresse_unix)) < 0)
 				{
 					ios = errno;
@@ -1871,11 +1956,12 @@ instruction_write(struct_processus *s_et
 				{ // Adresse IPv4
 					calcul_adresse = 0;
 					for(i = 0; i < 4; calcul_adresse =
-							(256 * calcul_adresse) + adresse[i++]);
+							(256 * calcul_adresse) +
+							((unsigned char) adresse[i++]));
 
 					memset(&adresse_ipv4, 0, sizeof(adresse_ipv4));
 					adresse_ipv4.sin_family = AF_INET;
-					adresse_ipv4.sin_port = htons(port);
+					adresse_ipv4.sin_port = htons((uint16_t) port);
 					adresse_ipv4.sin_addr.s_addr = htonl(calcul_adresse);
 
 #					ifndef SEMAPHORES_NOMMES
@@ -1891,7 +1977,7 @@ instruction_write(struct_processus *s_et
 
 					if (sendto((*((struct_socket *)
 							(*s_objet_argument_1).objet)).socket, chaine,
-							longueur_effective, 0, (struct sockaddr *)
+							(size_t) longueur_effective, 0, (struct sockaddr *)
 							&adresse_ipv4, sizeof(adresse_ipv4)) < 0)
 					{
 						ios = errno;
@@ -1975,7 +2061,7 @@ instruction_write(struct_processus *s_et
 
 					for(i = 0; i < 16;
 							adresse_ipv6.sin6_addr.s6_addr[i] =
-							adresse[i], i++);
+							(unsigned char) adresse[i], i++);
 
 #					ifndef SEMAPHORES_NOMMES
 						if (sem_post(&((*s_etat_processus).semaphore_fork))
@@ -1990,7 +2076,7 @@ instruction_write(struct_processus *s_et
 
 					if (sendto((*((struct_socket *)
 							(*s_objet_argument_1).objet)).socket, chaine,
-							longueur_effective, 0, (struct sockaddr *)
+							(size_t) longueur_effective, 0, (struct sockaddr *)
 							&adresse_ipv6, sizeof(adresse_ipv6)) < 0)
 					{
 						ios = errno;
@@ -2186,8 +2272,8 @@ instruction_wflock(struct_processus *s_e
 
 		do
 		{
-			if ((chaine = conversion_majuscule((unsigned char *)
-					(*s_objet_argument_1).objet)) == NULL)
+			if ((chaine = conversion_majuscule(s_etat_processus,
+					(unsigned char *) (*s_objet_argument_1).objet)) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -2239,42 +2325,32 @@ instruction_wflock(struct_processus *s_e
 				return;
 			}
 
-#			ifndef SEMAPHORES_NOMMES
-				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
-#			else
-				if (sem_post((*s_etat_processus).semaphore_fork) != 0)
-#			endif
+			if (lock.l_type == F_UNLCK)
 			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
+				drapeau = d_vrai;
 			}
-
-#			ifndef SEMAPHORES_NOMMES
-				while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
-#			else
-				while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
-#			endif
+			else
 			{
-				if (errno != EINTR)
+				if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions)
+						!= 0)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_processus;
 					return;
 				}
-			}
 
-			if (lock.l_type == F_UNLCK)
-			{
-				drapeau = d_vrai;
-			}
-			else
-			{
 				if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
 				{
 					affectation_interruptions_logicielles(s_etat_processus);
 				}
 
-				if ((*s_etat_processus).nombre_interruptions_en_queue
-						!= 0)
+				if (pthread_mutex_unlock(&(*s_etat_processus)
+						.mutex_interruptions) != 0)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_processus;
+					return;
+				}
+
+				if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
 				{
 					registre_instruction_valide =
 							(*s_etat_processus).instruction_valide;
@@ -2284,10 +2360,34 @@ instruction_wflock(struct_processus *s_e
 							registre_instruction_valide;
 				}
 
-				nanosleep(&attente, NULL);
 				scrutation_injection(s_etat_processus);
 
+#				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;
+				}
+
+				nanosleep(&attente, NULL);
+
 				INCR_GRANULARITE(attente.tv_nsec);
+
+#				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;
+					}
+				}
 			}
 		} while((drapeau == d_faux) && ((*s_etat_processus)
 				.var_volatile_requete_arret != -1));
@@ -2388,7 +2488,8 @@ instruction_wfproc(struct_processus *s_e
 			}
 		}
 
-		if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
+		if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus))
+				!= 0)
 		{
 			if ((*s_etat_processus).profilage == d_vrai)
 			{
@@ -2453,7 +2554,8 @@ instruction_wfproc(struct_processus *s_e
 					profilage(s_etat_processus, NULL);
 				}
 
-				if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
+				if (pthread_mutex_unlock(&((*s_etat_processus)
+						.mutex_pile_processus)) != 0)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_processus;
 					return;
@@ -2478,7 +2580,7 @@ instruction_wfproc(struct_processus *s_e
 				{
 					if (envoi_signal_processus((*(*((struct_processus_fils *)
 							(*(*l_element_courant).donnee).objet)).thread).pid,
-							rpl_signull) != 0)
+							rpl_signull, d_faux) != 0)
 					{
 						drapeau_fin = d_vrai;
 					}
@@ -2533,8 +2635,12 @@ instruction_wfproc(struct_processus *s_e
 					 * Le processus n'est pas terminé
 					 */
 
-					if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
+					if (pthread_mutex_lock(&((*s_etat_processus)
+							.mutex_interruptions)) != 0)
 					{
+						pthread_mutex_unlock(&((*s_etat_processus)
+								.mutex_pile_processus));
+
 						if ((*s_etat_processus).profilage == d_vrai)
 						{
 							profilage(s_etat_processus, NULL);
@@ -2551,8 +2657,36 @@ instruction_wfproc(struct_processus *s_e
 						affectation_interruptions_logicielles(s_etat_processus);
 					}
 
-					if ((*s_etat_processus).nombre_interruptions_en_queue
-							!= 0)
+					if (pthread_mutex_unlock(&((*s_etat_processus)
+							.mutex_interruptions)) != 0)
+					{
+						pthread_mutex_unlock(&((*s_etat_processus)
+								.mutex_pile_processus));
+
+						if ((*s_etat_processus).profilage == d_vrai)
+						{
+							profilage(s_etat_processus, NULL);
+						}
+
+						(*s_etat_processus).erreur_systeme =
+								d_es_processus;
+						return;
+					}
+
+					if (pthread_mutex_unlock(&((*s_etat_processus)
+							.mutex_pile_processus)) != 0)
+					{
+						if ((*s_etat_processus).profilage == d_vrai)
+						{
+							profilage(s_etat_processus, NULL);
+						}
+
+						(*s_etat_processus).erreur_systeme =
+								d_es_processus;
+						return;
+					}
+
+					if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
 					{
 						registre_instruction_valide =
 								(*s_etat_processus).instruction_valide;
@@ -2591,7 +2725,8 @@ instruction_wfproc(struct_processus *s_e
 
 					scrutation_injection(s_etat_processus);
 
-					if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
+					if (pthread_mutex_lock(&((*s_etat_processus)
+							.mutex_pile_processus)) != 0)
 					{
 						if ((*s_etat_processus).profilage == d_vrai)
 						{
@@ -2613,7 +2748,8 @@ instruction_wfproc(struct_processus *s_e
 			profilage(s_etat_processus, NULL);
 		}
 
-		if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
+		if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus))
+				!= 0)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_processus;
 			return;
@@ -2716,7 +2852,8 @@ instruction_wfdata(struct_processus *s_e
 			}
 		}
 
-		if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
+		if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus))
+				!= 0)
 		{
 			if ((*s_etat_processus).profilage == d_vrai)
 			{
@@ -2776,7 +2913,8 @@ instruction_wfdata(struct_processus *s_e
 					profilage(s_etat_processus, NULL);
 				}
 
-				if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
+				if (pthread_mutex_unlock(&((*s_etat_processus)
+						.mutex_pile_processus)) != 0)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_processus;
 					return;
@@ -2819,7 +2957,8 @@ instruction_wfdata(struct_processus *s_e
 						return;
 					}
 
-					if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
+					if (pthread_mutex_unlock(&((*s_etat_processus)
+							.mutex_pile_processus)) != 0)
 					{
 						if ((*s_etat_processus).profilage == d_vrai)
 						{
@@ -2860,12 +2999,26 @@ instruction_wfdata(struct_processus *s_e
 
 					scrutation_injection(s_etat_processus);
 
+					if (pthread_mutex_lock(&(*s_etat_processus)
+							.mutex_interruptions) != 0)
+					{
+						(*s_etat_processus).erreur_systeme = d_es_processus;
+						return;
+					}
+
 					if ((*s_etat_processus).nombre_interruptions_non_affectees
 							!= 0)
 					{
 						affectation_interruptions_logicielles(s_etat_processus);
 					}
 
+					if (pthread_mutex_unlock(&(*s_etat_processus)
+							.mutex_interruptions) != 0)
+					{
+						(*s_etat_processus).erreur_systeme = d_es_processus;
+						return;
+					}
+
 					if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
 					{
 						registre_instruction_valide =
@@ -2885,7 +3038,8 @@ instruction_wfdata(struct_processus *s_e
 						return;
 					}
 
-					if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
+					if (pthread_mutex_lock(&((*s_etat_processus)
+							.mutex_pile_processus)) != 0)
 					{
 						if ((*s_etat_processus).profilage == d_vrai)
 						{
@@ -2912,7 +3066,8 @@ instruction_wfdata(struct_processus *s_e
 			profilage(s_etat_processus, NULL);
 		}
 
-		if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
+		if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus))
+				!= 0)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_processus;
 			return;
@@ -2944,6 +3099,119 @@ instruction_wfdata(struct_processus *s_e
 ================================================================================
 */
 
+static inline logical1
+options_sockets(struct_processus *s_etat_processus, struct_socket *s_socket)
+{
+	if (((*s_socket).options & (1 << d_BROADCAST)) != 0)
+	{
+		if (setsockopt((*s_socket).socket, SOL_SOCKET, SO_BROADCAST, NULL, 0)
+				!= 0)
+		{
+			return(d_erreur);
+		}
+	}
+
+	if (((*s_socket).options & (1 << d_DONT_ROUTE)) != 0)
+	{
+		if (setsockopt((*s_socket).socket, SOL_SOCKET, SO_DONTROUTE, NULL, 0)
+				!= 0)
+		{
+			return(d_erreur);
+		}
+	}
+
+	if (((*s_socket).options & (1 << d_KEEP_ALIVE)) != 0)
+	{
+		if (setsockopt((*s_socket).socket, SOL_SOCKET, SO_KEEPALIVE, NULL, 0)
+				!= 0)
+		{
+			return(d_erreur);
+		}
+	}
+
+#	ifdef SO_PRIORITY
+	if (((*s_socket).options & (1 << d_PRIORITY)) != 0)
+	{
+		if (setsockopt((*s_socket).socket, SOL_SOCKET, SO_PRIORITY,
+				&((*s_socket).priorite), sizeof((*s_socket).priorite)) != 0)
+		{
+			return(d_erreur);
+		}
+	}
+#	endif
+
+	// Les deux options suivantes ne peuvent être positionnées simultanément.
+
+	if (((*s_socket).options & (1 << d_RECEIVE_BUFFER)) != 0)
+	{
+		if (setsockopt((*s_socket).socket, SOL_SOCKET, SO_RCVBUF,
+				&((*s_socket).buffer_reception),
+				sizeof((*s_socket).buffer_reception)) != 0)
+		{
+			return(d_erreur);
+		}
+	}
+
+#	ifdef SO_RCVBUFFORCE
+	if (((*s_socket).options & (1 << d_FORCE_RECEIVE_BUFFER)) != 0)
+	{
+		if (setsockopt((*s_socket).socket, SOL_SOCKET, SO_RCVBUFFORCE,
+				&((*s_socket).buffer_reception),
+				sizeof((*s_socket).buffer_reception)) != 0)
+		{
+			return(d_erreur);
+		}
+	}
+#	endif
+
+	// Même remarque
+
+	if (((*s_socket).options & (1 << d_SEND_BUFFER)) != 0)
+	{
+		if (setsockopt((*s_socket).socket, SOL_SOCKET, SO_SNDBUF,
+				&((*s_socket).buffer_emission),
+				sizeof((*s_socket).buffer_emission)) != 0)
+		{
+			return(d_erreur);
+		}
+	}
+
+#	ifdef SO_SNDBUFFORCE
+	if (((*s_socket).options & (1 << d_FORCE_SEND_BUFFER)) != 0)
+	{
+		if (setsockopt((*s_socket).socket, SOL_SOCKET, SO_SNDBUFFORCE,
+				&((*s_socket).buffer_emission),
+				sizeof((*s_socket).buffer_emission)) != 0)
+		{
+			return(d_erreur);
+		}
+	}
+#	endif
+
+	if (((*s_socket).options & (1 << d_RECEIVING_TIMEOUT)) != 0)
+	{
+		if (setsockopt((*s_socket).socket, SOL_SOCKET, SO_RCVTIMEO,
+				&((*s_socket).timeout_emission),
+				sizeof((*s_socket).timeout_emission)) != 0)
+		{
+			return(d_erreur);
+		}
+	}
+
+	if (((*s_socket).options & (1 << d_SENDING_TIMEOUT)) != 0)
+	{
+		if (setsockopt((*s_socket).socket, SOL_SOCKET, SO_SNDTIMEO,
+				&((*s_socket).timeout_emission),
+				sizeof((*s_socket).timeout_emission)) != 0)
+		{
+			return(d_erreur);
+		}
+	}
+
+	return(d_absence_erreur);;
+}
+
+
 void
 instruction_wfsock(struct_processus *s_etat_processus)
 {
@@ -2965,8 +3233,6 @@ instruction_wfsock(struct_processus *s_e
 	struct sockaddr_in6		adresse_ipv6;
 #	endif
 
-	unsigned long			i;
-
 	if ((*s_etat_processus).affichage_arguments == 'Y')
 	{
 		printf("\n  WFSOCK ");
@@ -3014,7 +3280,7 @@ instruction_wfsock(struct_processus *s_e
 				(*s_objet_argument).objet)).type, "SEQUENTIAL DATAGRAM") != 0))
 		{
 			// Mode non connecté : l'attente se fait sur un poll()
-
+#define DEBUG_RETURN
 			if ((s_objet_resultat = copie_objet(s_etat_processus,
 					s_objet_argument, 'P')) == NULL)
 			{
@@ -3129,12 +3395,12 @@ instruction_wfsock(struct_processus *s_e
 				{
 					drapeau = d_vrai;
 
-#				ifndef SEMAPHORES_NOMMES
+#					ifndef SEMAPHORES_NOMMES
 						if (sem_post(&((*s_etat_processus).semaphore_fork))
 								!= 0)
-#				else
+#					else
 						if (sem_post((*s_etat_processus).semaphore_fork) != 0)
-#				endif
+#					endif
 					{
 						(*s_etat_processus).erreur_systeme = d_es_processus;
 						return;
@@ -3149,11 +3415,11 @@ instruction_wfsock(struct_processus *s_e
 						erreur = errno;
 
 #						ifndef SEMAPHORES_NOMMES
-						while(sem_wait(&((*s_etat_processus)
-								.semaphore_fork)) != 0)
+							while(sem_wait(&((*s_etat_processus)
+									.semaphore_fork)) != 0)
 #						else
-						while(sem_wait((*s_etat_processus).semaphore_fork)
-								!= 0)
+							while(sem_wait((*s_etat_processus).semaphore_fork)
+									!= 0)
 #						endif
 						{
 							if (errno != EINTR)
@@ -3187,13 +3453,13 @@ instruction_wfsock(struct_processus *s_e
 					}
 					else
 					{
-#					ifndef SEMAPHORES_NOMMES
+#						ifndef SEMAPHORES_NOMMES
 							while(sem_wait(&((*s_etat_processus)
 									.semaphore_fork)) != 0)
-#					else
+#						else
 							while(sem_wait((*s_etat_processus).semaphore_fork)
 									!= 0)
-#					endif
+#						endif
 						{
 							if (errno != EINTR)
 							{
@@ -3202,9 +3468,21 @@ instruction_wfsock(struct_processus *s_e
 								return;
 							}
 						}
+
+						if (options_sockets(s_etat_processus,
+								(*s_objet_resultat).objet) != d_absence_erreur)
+						{
+							liberation(s_etat_processus, s_objet_argument);
+							liberation(s_etat_processus, s_objet_resultat);
+
+							(*s_etat_processus).erreur_execution =
+									d_ex_erreur_parametre_fichier;
+							return;
+						}
 					}
 				} while(drapeau == d_faux);
 
+printf("socket: %d\n", (*((struct_socket *) (*s_objet_resultat).objet)).socket);
 				if (((*((struct_socket *) (*s_objet_resultat).objet))
 						.adresse_distante = malloc(22 *
 						sizeof(unsigned char))) == NULL)
@@ -3232,12 +3510,12 @@ instruction_wfsock(struct_processus *s_e
 				{
 					drapeau = d_vrai;
 
-#				ifndef SEMAPHORES_NOMMES
+#					ifndef SEMAPHORES_NOMMES
 						if (sem_post(&((*s_etat_processus).semaphore_fork))
 								!= 0)
-#				else
+#					else
 						if (sem_post((*s_etat_processus).semaphore_fork) != 0)
-#				endif
+#					endif
 					{
 						(*s_etat_processus).erreur_systeme = d_es_processus;
 						return;
@@ -3250,13 +3528,13 @@ instruction_wfsock(struct_processus *s_e
 					{
 						erreur = errno;
 
-#					ifndef SEMAPHORES_NOMMES
+#						ifndef SEMAPHORES_NOMMES
 							while(sem_wait(&((*s_etat_processus)
 									.semaphore_fork)) != 0)
-#					else
+#						else
 							while(sem_wait((*s_etat_processus).semaphore_fork)
 									!= 0)
-#					endif
+#						endif
 						{
 							if (errno != EINTR)
 							{
@@ -3289,13 +3567,13 @@ instruction_wfsock(struct_processus *s_e
 					}
 					else
 					{
-#					ifndef SEMAPHORES_NOMMES
+#						ifndef SEMAPHORES_NOMMES
 							while(sem_wait(&((*s_etat_processus)
 									.semaphore_fork)) != 0)
-#					else
+#						else
 							while(sem_wait((*s_etat_processus).semaphore_fork)
 									!= 0)
-#					endif
+#						endif
 						{
 							if (errno != EINTR)
 							{
@@ -3304,11 +3582,22 @@ instruction_wfsock(struct_processus *s_e
 								return;
 							}
 						}
+
+						if (options_sockets(s_etat_processus,
+								(*s_objet_resultat).objet) != d_absence_erreur)
+						{
+							liberation(s_etat_processus, s_objet_argument);
+							liberation(s_etat_processus, s_objet_resultat);
+
+							(*s_etat_processus).erreur_execution =
+									d_ex_erreur_parametre_fichier;
+							return;
+						}
 					}
 				} while(drapeau == d_faux);
 
 				if (((*((struct_socket *) (*s_objet_resultat).objet))
-						.adresse_distante = malloc(55 *
+						.adresse_distante = malloc(47 *
 						sizeof(unsigned char))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -3316,22 +3605,26 @@ instruction_wfsock(struct_processus *s_e
 					return;
 				}
 
-				(*((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]);
-				}
-
 				sprintf((*((struct_socket *) (*s_objet_resultat)
-						.objet)).adresse_distante, "%s(%u)",
-						(*((struct_socket *) (*s_objet_resultat)
 						.objet)).adresse_distante,
+						"%02X%02X:%02X%02X:%02X%02X:%02X%02X:"
+						"%02X%02X:%02X%02X:%02X%02X:%02X%02X(%u)",
+						adresse_ipv6.sin6_addr.s6_addr[0],
+						adresse_ipv6.sin6_addr.s6_addr[1],
+						adresse_ipv6.sin6_addr.s6_addr[2],
+						adresse_ipv6.sin6_addr.s6_addr[3],
+						adresse_ipv6.sin6_addr.s6_addr[4],
+						adresse_ipv6.sin6_addr.s6_addr[5],
+						adresse_ipv6.sin6_addr.s6_addr[6],
+						adresse_ipv6.sin6_addr.s6_addr[7],
+						adresse_ipv6.sin6_addr.s6_addr[8],
+						adresse_ipv6.sin6_addr.s6_addr[9],
+						adresse_ipv6.sin6_addr.s6_addr[10],
+						adresse_ipv6.sin6_addr.s6_addr[11],
+						adresse_ipv6.sin6_addr.s6_addr[12],
+						adresse_ipv6.sin6_addr.s6_addr[13],
+						adresse_ipv6.sin6_addr.s6_addr[14],
+						adresse_ipv6.sin6_addr.s6_addr[15],
 						ntohs(adresse_ipv6.sin6_port));
 #			else
 				if ((*s_etat_processus).langue == 'F')
@@ -3354,12 +3647,12 @@ instruction_wfsock(struct_processus *s_e
 				{
 					drapeau = d_vrai;
 
-#				ifndef SEMAPHORES_NOMMES
+#					ifndef SEMAPHORES_NOMMES
 						if (sem_post(&((*s_etat_processus).semaphore_fork))
 								!= 0)
-#				else
+#					else
 						if (sem_post((*s_etat_processus).semaphore_fork) != 0)
-#				endif
+#					endif
 					{
 						(*s_etat_processus).erreur_systeme = d_es_processus;
 						return;
@@ -3372,13 +3665,13 @@ instruction_wfsock(struct_processus *s_e
 					{
 						erreur = errno;
 
-#					ifndef SEMAPHORES_NOMMES
+#						ifndef SEMAPHORES_NOMMES
 							while(sem_wait(&((*s_etat_processus)
 									.semaphore_fork)) != 0)
-#					else
+#						else
 							while(sem_wait((*s_etat_processus).semaphore_fork)
 									!= 0)
-#					endif
+#						endif
 						{
 							if (errno != EINTR)
 							{
@@ -3411,13 +3704,13 @@ instruction_wfsock(struct_processus *s_e
 					}
 					else
 					{
-#					ifndef SEMAPHORES_NOMMES
+#						ifndef SEMAPHORES_NOMMES
 							while(sem_wait(&((*s_etat_processus)
 									.semaphore_fork)) != 0)
-#					else
+#						else
 							while(sem_wait((*s_etat_processus).semaphore_fork)
 									!= 0)
-#					endif
+#						endif
 						{
 							if (errno != EINTR)
 							{
@@ -3426,6 +3719,17 @@ instruction_wfsock(struct_processus *s_e
 								return;
 							}
 						}
+
+						if (options_sockets(s_etat_processus,
+								(*s_objet_resultat).objet) != d_absence_erreur)
+						{
+							liberation(s_etat_processus, s_objet_argument);
+							liberation(s_etat_processus, s_objet_resultat);
+
+							(*s_etat_processus).erreur_execution =
+									d_ex_erreur_parametre_fichier;
+							return;
+						}
 					}
 				} while(drapeau == d_faux);
 			}
@@ -3596,18 +3900,55 @@ instruction_wfswi(struct_processus *s_et
 				return;
 			}
 
+			if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions)
+					!= 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_processus;
+				return;
+			}
+
 			if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
 			{
 				affectation_interruptions_logicielles(s_etat_processus);
 			}
 
+			if (pthread_mutex_unlock(&(*s_etat_processus).mutex_interruptions)
+					!= 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_processus;
+				return;
+			}
+
 			if ((*s_etat_processus).queue_interruptions[interruption - 1] > 0)
 			{
 				drapeau_fin = d_vrai;
 			}
 			else
 			{
+#				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;
+				}
 				nanosleep(&attente, NULL);
+
+#				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;
+					}
+				}
+
 				scrutation_injection(s_etat_processus);
 				INCR_GRANULARITE(attente.tv_nsec);
 			}
@@ -3733,11 +4074,23 @@ instruction_wfpoke(struct_processus *s_e
 
 		scrutation_injection(s_etat_processus);
 
+		if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions) != 0)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_processus;
+			return;
+		}
+
 		if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
 		{
 			affectation_interruptions_logicielles(s_etat_processus);
 		}
 
+		if (pthread_mutex_unlock(&(*s_etat_processus).mutex_interruptions) != 0)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_processus;
+			return;
+		}
+
 		if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
 		{
 			registre_instruction_valide =
@@ -3840,11 +4193,23 @@ instruction_wfack(struct_processus *s_et
 	{
 		scrutation_injection(s_etat_processus);
 
+		if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions) != 0)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_processus;
+			return;
+		}
+
 		if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
 		{
 			affectation_interruptions_logicielles(s_etat_processus);
 		}
 
+		if (pthread_mutex_unlock(&(*s_etat_processus).mutex_interruptions) != 0)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_processus;
+			return;
+		}
+
 		if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
 		{
 			registre_instruction_valide =