--- rpl/src/instructions_o1.c	2013/03/20 22:54:01	1.67
+++ rpl/src/instructions_o1.c	2019/02/03 14:40:46	1.98
@@ -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.31
+  Copyright (C) 1989-2019 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -114,35 +114,35 @@ instruction_over(struct_processus *s_eta
 				"       %s, %s, %s, %s, %s,\n"
 				"       %s, %s, %s, %s, %s,\n"
 				"       %s, %s, %s, %s,\n"
-				"       %s, %s\n",
+				"       %s, %s, %s\n",
 				d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
 				d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
-				d_SQL, d_SLB, d_PRC, d_MTX);
+				d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
 		printf("    1: %s, %s, %s, %s, %s, %s,\n"
 				"       %s, %s, %s, %s, %s,\n"
 				"       %s, %s, %s, %s, %s,\n"
 				"       %s, %s, %s, %s,\n"
-				"       %s, %s\n",
+				"       %s, %s, %s\n",
 				d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
 				d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
-				d_SQL, d_SLB, d_PRC, d_MTX);
+				d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
 		printf("->  3: %s, %s, %s, %s, %s, %s,\n"
 				"       %s, %s, %s, %s, %s,\n"
 				"       %s, %s, %s, %s, %s,\n"
 				"       %s, %s, %s, %s,\n"
-				"       %s, %s\n",
+				"       %s, %s, %s\n",
 				d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
 				d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
-				d_SQL, d_SLB, d_PRC, d_MTX);
+				d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
 		printf("    ...\n");
 		printf("    1: %s, %s, %s, %s, %s, %s,\n"
 				"       %s, %s, %s, %s, %s,\n"
 				"       %s, %s, %s, %s, %s,\n"
 				"       %s, %s, %s, %s,\n"
-				"       %s, %s\n",
+				"       %s, %s, %s\n",
 				d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
 				d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
-				d_SQL, d_SLB, d_PRC, d_MTX);
+				d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
 
 		return;
 	}
@@ -869,6 +869,237 @@ instruction_or(struct_processus *s_etat_
 ================================================================================
 */
 
+
+static inline logical1
+options_socket(struct_processus *s_etat_processus,
+		struct_objet *s_objet_resultat, unsigned char *options,
+		unsigned char *peripherique, int *priorite,
+		int *buffer_emission, int *buffer_reception,
+		int *timeout_emission, int *timeout_reception)
+{
+	int				drapeau;
+
+	/*
+	 * Options des sockets
+	 */
+
+	drapeau = -1;
+
+#	define WARNING(message) { \
+	if ((*s_etat_processus).langue != 'F') \
+		printf("+++Warning : %s unavailable on host system\n", message); \
+	else \
+		printf("+++Attention : %s non disponible sur le système hôte\n", \
+				message); } while(0)
+
+	if (options[d_BIND_TO_DEVICE] == 'Y')
+	{
+#		ifdef SO_BINDTODEVICE
+			if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet))
+					.socket, SOL_SOCKET, SO_BINDTODEVICE, peripherique,
+					(socklen_t) strlen(peripherique)) != 0)
+			{
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_parametre_fichier;
+				return(d_erreur);
+			}
+
+			(*((struct_socket *) (*s_objet_resultat).objet)).options |=
+					((integer8) 1) << d_BIND_TO_DEVICE;
+#		else
+			WARNING("BIND TO DEVICE");
+#		endif
+	}
+
+	if (options[d_BROADCAST] == 'Y')
+	{
+		if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet)).socket,
+				SOL_SOCKET, SO_BROADCAST, &drapeau, sizeof(drapeau)) != 0)
+		{
+			(*s_etat_processus).erreur_execution =
+					d_ex_erreur_parametre_fichier;
+			return(d_erreur);
+		}
+
+		(*((struct_socket *) (*s_objet_resultat).objet)).options |=
+				((integer8) 1) << d_BROADCAST;
+	}
+
+	if (options[d_DONT_ROUTE] == 'Y')
+	{
+		if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet)).socket,
+				SOL_SOCKET, SO_DONTROUTE, &drapeau, sizeof(drapeau)) != 0)
+		{
+			(*s_etat_processus).erreur_execution =
+					d_ex_erreur_parametre_fichier;
+			return(d_erreur);
+		}
+
+		(*((struct_socket *) (*s_objet_resultat).objet)).options |=
+				((integer8) 1) << d_DONT_ROUTE;
+	}
+
+	if (options[d_KEEP_ALIVE] == 'Y')
+	{
+		if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet)).socket,
+				SOL_SOCKET, SO_KEEPALIVE, &drapeau, sizeof(drapeau)) != 0)
+		{
+			(*s_etat_processus).erreur_execution =
+					d_ex_erreur_parametre_fichier;
+			return(d_erreur);
+		}
+	}
+
+	if (options[d_PRIORITY] == 'Y')
+	{
+#		ifdef SO_PRIORITY
+			if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet))
+				.socket, SOL_SOCKET, SO_PRIORITY, priorite,
+				sizeof((*priorite))) != 0)
+			{
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_parametre_fichier;
+				return(d_erreur);
+			}
+
+			(*((struct_socket *) (*s_objet_resultat).objet)).options |=
+					((integer8) 1) << d_PRIORITY;
+			(*((struct_socket *) (*s_objet_resultat).objet)).priorite =
+					(*priorite);
+#		else
+			WARNING("PRIORITY");
+#		endif
+	}
+
+	if (options[d_RECEIVE_BUFFER] == 'Y')
+	{
+		if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet)).socket,
+				SOL_SOCKET, SO_RCVBUF, buffer_reception,
+				sizeof((*buffer_reception))) != 0)
+		{
+			(*s_etat_processus).erreur_execution =
+					d_ex_erreur_parametre_fichier;
+			return(d_erreur);
+		}
+
+		(*((struct_socket *) (*s_objet_resultat).objet)).options |=
+				((integer8) 1) << d_RECEIVE_BUFFER;
+		(*((struct_socket *) (*s_objet_resultat).objet)).buffer_reception =
+				(*buffer_reception);
+	}
+
+	if (options[d_FORCE_RECEIVE_BUFFER] == 'Y')
+	{
+#		ifdef SO_RCVBUFFORCE
+			if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet))
+					.socket, SOL_SOCKET, SO_RCVBUFFORCE,
+					buffer_reception, sizeof((*buffer_reception))) != 0)
+			{
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_parametre_fichier;
+				return(d_erreur);
+			}
+
+			(*((struct_socket *) (*s_objet_resultat).objet)).options |=
+					((integer8) 1) << d_FORCE_RECEIVE_BUFFER;
+			(*((struct_socket *) (*s_objet_resultat).objet)).buffer_reception =
+					(*buffer_reception);
+#		else
+			WARNING("FORCE_RECEIVE_BUFFER");
+#		endif
+	}
+
+	if (options[d_SEND_BUFFER] == 'Y')
+	{
+		if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet)).socket,
+				SOL_SOCKET, SO_SNDBUF, buffer_emission,
+				sizeof((*buffer_emission))) != 0)
+		{
+			(*s_etat_processus).erreur_execution =
+					d_ex_erreur_parametre_fichier;
+			return(d_erreur);
+		}
+
+		(*((struct_socket *) (*s_objet_resultat).objet)).options |=
+				((integer8) 1) << d_SEND_BUFFER;
+		(*((struct_socket *) (*s_objet_resultat).objet)).buffer_emission =
+				(*buffer_emission);
+	}
+
+	if (options[d_FORCE_SEND_BUFFER] == 'Y')
+	{
+#		ifdef SO_SNDBUFFORCE
+			if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet))
+					.socket, SOL_SOCKET, SO_SNDBUFFORCE, buffer_emission,
+					sizeof((*buffer_emission))) != 0)
+			{
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_parametre_fichier;
+				return(d_erreur);
+			}
+
+			(*((struct_socket *) (*s_objet_resultat).objet)).options |=
+					((integer8) 1) << d_FORCE_SEND_BUFFER;
+			(*((struct_socket *) (*s_objet_resultat).objet)).buffer_emission =
+					(*buffer_emission);
+#		else
+			WARNING("FORCE_SEND_BUFFER");
+#		endif
+	}
+
+	if (options[d_RECEIVING_TIMEOUT] == 'Y')
+	{
+		if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet)).socket,
+				SOL_SOCKET, SO_RCVTIMEO,
+				timeout_reception, sizeof((*timeout_reception))) != 0)
+		{
+			(*s_etat_processus).erreur_execution =
+					d_ex_erreur_parametre_fichier;
+			return(d_erreur);
+		}
+
+		(*((struct_socket *) (*s_objet_resultat).objet)).options |=
+				((integer8) 1) << d_RECEIVING_TIMEOUT;
+		(*((struct_socket *) (*s_objet_resultat).objet)).timeout_reception =
+				(*timeout_reception);
+	}
+
+	if (options[d_SENDING_TIMEOUT] == 'Y')
+	{
+		if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet)).socket,
+				SOL_SOCKET, SO_SNDTIMEO,
+				timeout_emission, sizeof((*timeout_emission))) != 0)
+		{
+			(*s_etat_processus).erreur_execution =
+					d_ex_erreur_parametre_fichier;
+			return(d_erreur);
+		}
+
+		(*((struct_socket *) (*s_objet_resultat).objet)).options |=
+				((integer8) 1) << d_SENDING_TIMEOUT;
+		(*((struct_socket *) (*s_objet_resultat).objet)).timeout_emission =
+				(*timeout_emission);
+	}
+
+	if (options[d_REUSE_ADDRESS] == 'Y')
+	{
+		if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet)).socket,
+				SOL_SOCKET, SO_REUSEADDR, &drapeau, sizeof(drapeau)) != 0)
+		{
+			(*s_etat_processus).erreur_execution =
+					d_ex_erreur_parametre_fichier;
+			return(d_erreur);
+		}
+
+		(*((struct_socket *) (*s_objet_resultat).objet)).options |=
+				((integer8) 1) << d_REUSE_ADDRESS;
+	}
+
+	return(d_absence_erreur);
+#	undef	WARNING
+}
+
+
 void
 instruction_open(struct_processus *s_etat_processus)
 {
@@ -905,7 +1136,6 @@ instruction_open(struct_processus *s_eta
 
 	int							buffer_emission;
 	int							buffer_reception;
-	int							drapeau;
 	int							priorite;
 	int							prochain_descripteur;
 	int							protocole_numerique;
@@ -976,19 +1206,6 @@ instruction_open(struct_processus *s_eta
 	unsigned long				nombre_elements;
 	unsigned long				unite;
 
-#	define						d_BIND_TO_DEVICE		0
-#	define						d_BROADCAST				1
-#	define						d_DONT_ROUTE			2
-#	define						d_KEEP_ALIVE			3
-#	define						d_PRIORITY				4
-#	define						d_RECEIVE_BUFFER		5
-#	define						d_FORCE_RECEIVE_BUFFER	6
-#	define						d_SEND_BUFFER			7
-#	define						d_FORCE_SEND_BUFFER		8
-#	define						d_RECEIVING_TIMEOUT		9
-#	define						d_SENDING_TIMEOUT		10
-#	define						d_REUSE_ADDRESS			11
-
 	/*
 	 * Argument : { "ouverture" "accès" "format" [ { "nom" } 'protection' ] }
 	 */
@@ -1028,7 +1245,8 @@ instruction_open(struct_processus *s_eta
 				"\"file name\" } \"protection\" } OPEN\n");
 		printf("    { \"filetype\" \"access\" \"format\" { \"name\" "
 				"\"file name\" } \n"
-				"			{ \"stty\" { \"stty parameters\" ... } } } OPEN\n");
+				"			{ \"stty\" \"speed,bits,parity,stop\"\n"
+				"           { \"stty parameters\" ... } } } OPEN\n");
 		printf("    { \"sockettype\" { \"name\" \"local name\" } } OPEN\n");
 		printf("    { \"sockettype\" \"socketdomain\" \"protection\" } OPEN\n");
 		printf("    \"/semaphore\" OPEN\n\n");
@@ -1078,7 +1296,7 @@ instruction_open(struct_processus *s_eta
 		printf("    { \"STREAM\" \"READWRITE\" } OPEN\n");
 		printf("    { \"FOREIGN\" \"DATAGRAM\" } OPEN\n");
 		printf("    { \"LOCAL\" { \"NAME\" \"socket.sock\" } } OPEN\n");
-		printf("    { { \"NAME\" \"/dev/ttyS1\" } { \"STTY\" { \"9600,8,N,1\" "
+		printf("    { { \"NAME\" \"/dev/ttyS1\" } { \"STTY\" \"9600,8,N,1\" "
 				"\n            { \"NO ICANON\" \"IGNBRK\" } } } OPEN\n");
 
 		return;
@@ -1139,7 +1357,6 @@ instruction_open(struct_processus *s_eta
 		buffer_reception = 0;
 		timeout_emission = 0;
 		timeout_reception = 0;
-		drapeau = -1;
 		s_parametres_tty = NULL;
 
 		for(i = 0; i < 12; options[i++] = 'N');
@@ -1148,8 +1365,9 @@ instruction_open(struct_processus *s_eta
 		{
 			if ((*(*l_element_courant).donnee).type == CHN)
 			{
-				if ((argument_majuscule = conversion_majuscule((unsigned char *)
-						(*(*l_element_courant).donnee).objet)) == NULL)
+				if ((argument_majuscule = conversion_majuscule(s_etat_processus,
+						(unsigned char *) (*(*l_element_courant).donnee).objet))
+						== NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
@@ -1763,7 +1981,7 @@ instruction_open(struct_processus *s_eta
 					if ((*(*l_element_courant_sous_objet).donnee).type == CHN)
 					{
 						if ((argument_majuscule = conversion_majuscule(
-								(unsigned char *)
+								s_etat_processus, (unsigned char *)
 								(*(*l_element_courant_sous_objet)
 								.donnee).objet)) == NULL)
 						{
@@ -1829,7 +2047,7 @@ instruction_open(struct_processus *s_eta
 							free(argument_majuscule);
 
 							if ((argument_majuscule = conversion_majuscule(
-									(unsigned char *)
+									s_etat_processus, (unsigned char *)
 									(*(*l_element_courant_sous_objet)
 									.donnee).objet)) == NULL)
 							{
@@ -2320,7 +2538,7 @@ instruction_open(struct_processus *s_eta
 					if ((*(*l_element_courant_sous_objet).donnee).type == CHN)
 					{
 						if ((argument_majuscule = conversion_majuscule(
-								(unsigned char *)
+								s_etat_processus, (unsigned char *)
 								(*(*l_element_courant_sous_objet)
 								.donnee).objet)) == NULL)
 						{
@@ -2361,7 +2579,7 @@ instruction_open(struct_processus *s_eta
 							}
 
 							if ((argument_majuscule = conversion_majuscule(
-									(unsigned char *)
+									s_etat_processus, (unsigned char *)
 									(*(*l_element_courant_sous_objet)
 									.donnee).objet)) == NULL)
 							{
@@ -3622,7 +3840,8 @@ instruction_open(struct_processus *s_eta
 				}
 
 				if ((parametre_courant_majuscule = conversion_majuscule(
-						(*(*parametre_courant).donnee).objet)) == NULL)
+						s_etat_processus, (*(*parametre_courant).donnee).objet))
+						== NULL)
 				{
 					liberation(s_etat_processus, s_objet_argument);
 					liberation(s_etat_processus, s_objet_resultat);
@@ -3659,7 +3878,7 @@ instruction_open(struct_processus *s_eta
 				// Vitesse
 
 				unsigned char	*vitesses[] =
-						{ "0", "50", "75", "110", "134", "150",
+						{ "50", "75", "110", "134", "150",
 						"200", "300", "600", "1200", "1800", "2400",
 						"4800", "9600", "19200", "38400",
 #ifdef B57600
@@ -3673,7 +3892,7 @@ instruction_open(struct_processus *s_eta
 #endif
 						NULL };
 				tcflag_t		vitesses_constantes[] =
-						{ B0, B50, B75, B110, B134, B150, B200, B300, B600,
+						{ B50, B75, B110, B134, B150, B200, B300, B600,
 						B1200, B1800, B2400, B4800, B9600, B19200, B38400,
 #ifdef B57600
 						B57600,
@@ -3936,7 +4155,8 @@ instruction_open(struct_processus *s_eta
 					}
 
 					if ((parametre_courant_majuscule = conversion_majuscule(
-							(*(*parametre_courant).donnee).objet)) == NULL)
+							s_etat_processus, (*(*parametre_courant).donnee)
+							.objet)) == NULL)
 					{
 						(*s_etat_processus).erreur_systeme =
 								d_es_allocation_memoire;
@@ -4379,223 +4599,6 @@ instruction_open(struct_processus *s_eta
 			 * Traitement des sockets
 			 */
 
-
-			inline logical1 options_socket()
-			{
-				/*
-				 * Options des sockets
-				 */
-
-#				define WARNING(message) \
-				if ((*s_etat_processus).langue != 'F') \
-					printf("+++Warning : %s unavailable on host system\n", \
-							message); \
-				else \
-					printf("+++Attention : %s non disponible sur le système " \
-							"hôte\n", message)
-
-				if (options[d_BIND_TO_DEVICE] == 'Y')
-				{
-#					ifdef SO_BINDTODEVICE
-						if (setsockopt((*((struct_socket *) (*s_objet_resultat)
-								.objet)).socket, SOL_SOCKET, SO_BINDTODEVICE,
-								peripherique, (socklen_t) strlen(peripherique))
-								!= 0)
-						{
-							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(d_erreur);
-						}
-#					else
-						WARNING("BIND TO DEVICE");
-#					endif
-				}
-
-				if (options[d_BROADCAST] == 'Y')
-				{
-					if (setsockopt((*((struct_socket *) (*s_objet_resultat)
-							.objet)).socket, SOL_SOCKET, SO_BROADCAST,
-							&drapeau, sizeof(drapeau)) != 0)
-					{
-						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(d_erreur);
-					}
-				}
-
-				if (options[d_DONT_ROUTE] == 'Y')
-				{
-					if (setsockopt((*((struct_socket *) (*s_objet_resultat)
-							.objet)).socket, SOL_SOCKET, SO_DONTROUTE,
-							&drapeau, sizeof(drapeau)) != 0)
-					{
-						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(d_erreur);
-					}
-				}
-
-				if (options[d_KEEP_ALIVE] == 'Y')
-				{
-					if (setsockopt((*((struct_socket *) (*s_objet_resultat)
-							.objet)).socket, SOL_SOCKET, SO_KEEPALIVE,
-							&drapeau, sizeof(drapeau)) != 0)
-					{
-						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(d_erreur);
-					}
-				}
-
-				if (options[d_PRIORITY] == 'Y')
-				{
-#					ifdef SO_PRIORITY
-						if (setsockopt((*((struct_socket *) (*s_objet_resultat)
-								.objet)).socket, SOL_SOCKET, SO_PRIORITY,
-								&priorite, sizeof(priorite)) != 0)
-						{
-							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(d_erreur);
-						}
-#					else
-						WARNING("PRIORITY");
-#					endif
-				}
-
-				if (options[d_RECEIVE_BUFFER] == 'Y')
-				{
-					if (setsockopt((*((struct_socket *) (*s_objet_resultat)
-							.objet)).socket, SOL_SOCKET, SO_RCVBUF,
-							&buffer_reception, sizeof(buffer_reception)) != 0)
-					{
-						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(d_erreur);
-					}
-				}
-
-				if (options[d_FORCE_RECEIVE_BUFFER] == 'Y')
-				{
-#					ifdef SO_RCVBUFFORCE
-						if (setsockopt((*((struct_socket *) (*s_objet_resultat)
-								.objet)).socket, SOL_SOCKET, SO_RCVBUFFORCE,
-								&buffer_reception, sizeof(buffer_reception))
-								!= 0)
-						{
-							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(d_erreur);
-						}
-#					else
-						WARNING("FORCE_RECEIVE_BUFFER");
-#					endif
-				}
-
-				if (options[d_SEND_BUFFER] == 'Y')
-				{
-					if (setsockopt((*((struct_socket *) (*s_objet_resultat)
-							.objet)).socket, SOL_SOCKET, SO_SNDBUF,
-							&buffer_emission, sizeof(buffer_emission)) != 0)
-					{
-						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(d_erreur);
-					}
-				}
-
-				if (options[d_FORCE_SEND_BUFFER] == 'Y')
-				{
-#					ifdef SO_SNDBUFFORCE
-						if (setsockopt((*((struct_socket *) (*s_objet_resultat)
-								.objet)).socket, SOL_SOCKET, SO_SNDBUFFORCE,
-								&buffer_emission, sizeof(buffer_emission)) != 0)
-						{
-							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(d_erreur);
-						}
-#					else
-						WARNING("FORCE_SEND_BUFFER");
-#					endif
-				}
-
-				if (options[d_RECEIVING_TIMEOUT] == 'Y')
-				{
-					if (setsockopt((*((struct_socket *) (*s_objet_resultat)
-							.objet)).socket, SOL_SOCKET, SO_RCVTIMEO,
-							&timeout_reception, sizeof(timeout_reception)) != 0)
-					{
-						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(d_erreur);
-					}
-				}
-
-				if (options[d_SENDING_TIMEOUT] == 'Y')
-				{
-					if (setsockopt((*((struct_socket *) (*s_objet_resultat)
-							.objet)).socket, SOL_SOCKET, SO_SNDTIMEO,
-							&timeout_emission, sizeof(timeout_emission)) != 0)
-					{
-						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(d_erreur);
-					}
-				}
-
-				if (options[d_REUSE_ADDRESS] == 'Y')
-				{
-					if (setsockopt((*((struct_socket *) (*s_objet_resultat)
-							.objet)).socket, SOL_SOCKET, SO_REUSEADDR,
-							&drapeau, sizeof(drapeau)) != 0)
-					{
-						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(d_erreur);
-					}
-				}
-
-				return(d_absence_erreur);
-#undef			WARNING
-			}
-
 			/*
 			 * Vérification de la cohérence des arguments et traitement
 			 * des valeurs par défaut.
@@ -4873,6 +4876,7 @@ instruction_open(struct_processus *s_eta
 					= 'Y';
 			(*((struct_socket *) (*s_objet_resultat).objet)).socket_connectee
 					= d_faux;
+			(*((struct_socket *) (*s_objet_resultat).objet)).options = 0;
 
 			if (type_domaine == 'L')
 			{ // Socket serveur
@@ -4912,7 +4916,10 @@ instruction_open(struct_processus *s_eta
 					strncpy(socket_unix.sun_path, pointeur, UNIX_PATH_MAX);
 					socket_unix.sun_path[UNIX_PATH_MAX - 1] = d_code_fin_chaine;
 
-					if (options_socket() == d_erreur)
+					if (options_socket(s_etat_processus, s_objet_resultat,
+							options, peripherique, &priorite,
+							&buffer_emission, &buffer_reception,
+							&timeout_emission, &timeout_reception) == d_erreur)
 					{
 						liberation(s_etat_processus, s_objet_argument);
 						liberation(s_etat_processus, s_objet_resultat);
@@ -5016,7 +5023,12 @@ instruction_open(struct_processus *s_eta
 									(*resolution_courante).ai_addr))
 									.sin_addr.s_addr;
 
-							if (options_socket() == d_erreur)
+							if (options_socket(s_etat_processus,
+									s_objet_resultat,
+									options, peripherique, &priorite,
+									&buffer_emission, &buffer_reception,
+									&timeout_emission, &timeout_reception)
+									== d_erreur)
 							{
 								liberation(s_etat_processus, s_objet_argument);
 								liberation(s_etat_processus, s_objet_resultat);
@@ -5043,7 +5055,7 @@ instruction_open(struct_processus *s_eta
 									.objet)).adresse);
 
 							if (((*((struct_socket *) (*s_objet_resultat)
-									.objet)).adresse = malloc(22 *
+									.objet)).adresse = malloc(23 *
 									sizeof(unsigned char))) == NULL)
 							{
 								(*s_etat_processus).erreur_systeme =
@@ -5052,7 +5064,7 @@ instruction_open(struct_processus *s_eta
 							}
 
 							sprintf((*((struct_socket *) (*s_objet_resultat)
-									.objet)).adresse, "%d.%d.%d.%d",
+									.objet)).adresse, "%d.%d.%d.%d(%u)",
 									(ntohl((*((struct sockaddr_in *)
 									(*resolution_courante).ai_addr)).sin_addr
 									.s_addr) >> 24) & 0xFF,
@@ -5064,7 +5076,8 @@ instruction_open(struct_processus *s_eta
 									.s_addr) >> 8) & 0xFF,
 									ntohl((*((struct sockaddr_in *)
 									(*resolution_courante).ai_addr)).sin_addr
-									.s_addr) & 0xFF);
+									.s_addr) & 0xFF,
+									(unsigned int) port);
 						}
 						else
 						{ // Accès en IPv6
@@ -5123,7 +5136,12 @@ instruction_open(struct_processus *s_eta
 									(*resolution_courante).ai_addr))
 									.sin6_addr.s6_addr[i], i++);
 
-							if (options_socket() == d_erreur)
+							if (options_socket(s_etat_processus,
+									s_objet_resultat,
+									options, peripherique, &priorite,
+									&buffer_emission, &buffer_reception,
+									&timeout_emission, &timeout_reception)
+									== d_erreur)
 							{
 								liberation(s_etat_processus, s_objet_argument);
 								liberation(s_etat_processus, s_objet_resultat);
@@ -5149,8 +5167,19 @@ instruction_open(struct_processus *s_eta
 							free((*((struct_socket *) (*s_objet_resultat)
 									.objet)).adresse);
 
+							/*
+							 * Longueur de la chaîne :
+							 * Adresse IPv6 : 16 octets soit 128 bits.
+							 * => 32 chiffres en hexadécimal
+							 * Par groupe de 4, 8 groupes
+							 * => 7 ":"
+							 * Port : (%u)
+							 * => 7
+							 * ==> 32 + 7 + 7 + 1 = 47
+							 */
+
 							if (((*((struct_socket *) (*s_objet_resultat)
-									.objet)).adresse = malloc(55 *
+									.objet)).adresse = malloc(47 *
 									sizeof(unsigned char))) == NULL)
 							{
 								(*s_etat_processus).erreur_systeme =
@@ -5158,17 +5187,59 @@ instruction_open(struct_processus *s_eta
 								return;
 							}
 
-							for(i = 0; i < 16; i++)
-							{
-								sprintf((*((struct_socket *) (*s_objet_resultat)
-										.objet)).adresse,
-										(i == 0) ? "%s%X" : "%s:%X",
-										(*((struct_socket *) (*s_objet_resultat)
-										.objet)).adresse,
-										(*((struct sockaddr_in6 *)
-										(*resolution_courante).ai_addr))
-										.sin6_addr.s6_addr[i]);
-							}
+							sprintf((*((struct_socket *) (*s_objet_resultat)
+									.objet)).adresse,
+									"%02X%02X:%02X%02X:%02X%02X:%02X%02X:"
+									"%02X%02X:%02X%02X:%02X%02X:%02X%02X(%u)",
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[0],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[1],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[2],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[3],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[4],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[5],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[6],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[7],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[8],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[9],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[10],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[11],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[12],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[13],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[14],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[15],
+									(unsigned int) port);
 #							else
 							if ((*s_etat_processus).langue == 'F')
 							{
@@ -5193,11 +5264,6 @@ instruction_open(struct_processus *s_eta
 						}
 
 						freeaddrinfo(resolution);
-
-						sprintf((*((struct_socket *) (*s_objet_resultat)
-								.objet)).adresse, "%s(%u)",
-								(*((struct_socket *) (*s_objet_resultat)
-								.objet)).adresse, (unsigned int) port);
 					}
 					else
 					{ // Hôte défini par une adresse
@@ -5207,7 +5273,7 @@ instruction_open(struct_processus *s_eta
 									.objet)).adresse);
 
 							if (((*((struct_socket *) (*s_objet_resultat)
-									.objet)).adresse = malloc(22 *
+									.objet)).adresse = malloc(23 *
 									sizeof(unsigned char))) == NULL)
 							{
 								(*s_etat_processus).erreur_systeme =
@@ -5215,22 +5281,11 @@ instruction_open(struct_processus *s_eta
 								return;
 							}
 
-							(*((struct_socket *) (*s_objet_resultat).objet))
-									.adresse[0] = d_code_fin_chaine;
-
-							for(i = 0; i < 4; i++)
-							{
-								sprintf((*((struct_socket *) (*s_objet_resultat)
-										.objet)).adresse,
-										(i == 0) ? "%s%d" : "%s.%d",
-										(*((struct_socket *) (*s_objet_resultat)
-										.objet)).adresse, (int) adresse[i]);
-							}
-
 							sprintf((*((struct_socket *) (*s_objet_resultat)
-									.objet)).adresse, "%s(%u)",
-									(*((struct_socket *) (*s_objet_resultat)
-									.objet)).adresse, (unsigned int) port);
+									.objet)).adresse, "%d.%d.%d.%d(%u)",
+									(int) adresse[0], (int) adresse[1],
+									(int) adresse[2], (int) adresse[3],
+									(unsigned int) port);
 
 							if (((*((struct_socket *)
 									(*s_objet_resultat).objet))
@@ -5259,7 +5314,12 @@ instruction_open(struct_processus *s_eta
 
 							socket_ipv4.sin_addr.s_addr = htonl(adresse_ipv4);
 
-							if (options_socket() == d_erreur)
+							if (options_socket(s_etat_processus,
+									s_objet_resultat,
+									options, peripherique, &priorite,
+									&buffer_emission, &buffer_reception,
+									&timeout_emission, &timeout_reception)
+									== d_erreur)
 							{
 								liberation(s_etat_processus, s_objet_argument);
 								liberation(s_etat_processus, s_objet_resultat);
@@ -5286,7 +5346,7 @@ instruction_open(struct_processus *s_eta
 									.objet)).adresse);
 
 							if (((*((struct_socket *) (*s_objet_resultat)
-									.objet)).adresse = malloc(55 *
+									.objet)).adresse = malloc(47 *
 									sizeof(unsigned char))) == NULL)
 							{
 								(*s_etat_processus).erreur_systeme =
@@ -5294,23 +5354,27 @@ instruction_open(struct_processus *s_eta
 								return;
 							}
 
-							(*((struct_socket *) (*s_objet_resultat).objet))
-									.adresse[0] = d_code_fin_chaine;
-
-							for(i = 0; i < 16; i++)
-							{
-								sprintf((*((struct_socket *) (*s_objet_resultat)
-										.objet)).adresse,
-										(i == 0) ? "%s%X" : "%s:%X",
-										(*((struct_socket *) (*s_objet_resultat)
-										.objet)).adresse, (unsigned int)
-										adresse[i]);
-							}
-
 							sprintf((*((struct_socket *) (*s_objet_resultat)
-									.objet)).adresse, "%s(%u)",
-									(*((struct_socket *) (*s_objet_resultat)
-									.objet)).adresse, (unsigned int) port);
+									.objet)).adresse,
+									"%02X%02X:%02X%02X:%02X%02X:%02X%02X:"
+									"%02X%02X:%02X%02X:%02X%02X:%02X%02X(%u)",
+									(unsigned int) adresse[0],
+									(unsigned int) adresse[1],
+									(unsigned int) adresse[2],
+									(unsigned int) adresse[3],
+									(unsigned int) adresse[4],
+									(unsigned int) adresse[5],
+									(unsigned int) adresse[6],
+									(unsigned int) adresse[7],
+									(unsigned int) adresse[8],
+									(unsigned int) adresse[9],
+									(unsigned int) adresse[10],
+									(unsigned int) adresse[11],
+									(unsigned int) adresse[12],
+									(unsigned int) adresse[13],
+									(unsigned int) adresse[14],
+									(unsigned int) adresse[15],
+									(unsigned int) port);
 
 							if (((*((struct_socket *)
 									(*s_objet_resultat).objet))
@@ -5336,7 +5400,12 @@ instruction_open(struct_processus *s_eta
 									socket_ipv6.sin6_addr.s6_addr[i] =
 									(unsigned char) (adresse[i]), i++);
 
-							if (options_socket() == d_erreur)
+							if (options_socket(s_etat_processus,
+									s_objet_resultat,
+									options, peripherique, &priorite,
+									&buffer_emission, &buffer_reception,
+									&timeout_emission, &timeout_reception)
+									== d_erreur)
 							{
 								liberation(s_etat_processus, s_objet_argument);
 								liberation(s_etat_processus, s_objet_resultat);
@@ -5610,7 +5679,7 @@ instruction_open(struct_processus *s_eta
 									.objet)).adresse);
 
 							if (((*((struct_socket *) (*s_objet_resultat)
-									.objet)).adresse = malloc(22 *
+									.objet)).adresse = malloc(23 *
 									sizeof(unsigned char))) == NULL)
 							{
 								(*s_etat_processus).erreur_systeme =
@@ -5619,7 +5688,7 @@ instruction_open(struct_processus *s_eta
 							}
 
 							sprintf((*((struct_socket *) (*s_objet_resultat)
-									.objet)).adresse, "%d.%d.%d.%d",
+									.objet)).adresse, "%d.%d.%d.%d(%u)",
 									(ntohl((*((struct sockaddr_in *)
 									(*resolution_courante).ai_addr)).sin_addr
 									.s_addr) >> 24) & 0xFF,
@@ -5631,7 +5700,8 @@ instruction_open(struct_processus *s_eta
 									.s_addr) >> 8) & 0xFF,
 									ntohl((*((struct sockaddr_in *)
 									(*resolution_courante).ai_addr)).sin_addr
-									.s_addr) & 0xFF);
+									.s_addr) & 0xFF,
+									(unsigned int) port);
 						}
 						else
 						{ // Accès en IPv6
@@ -5719,7 +5789,7 @@ instruction_open(struct_processus *s_eta
 									.objet)).adresse);
 
 							if (((*((struct_socket *) (*s_objet_resultat)
-									.objet)).adresse = malloc(55 *
+									.objet)).adresse = malloc(47 *
 									sizeof(unsigned char))) == NULL)
 							{
 								(*s_etat_processus).erreur_systeme =
@@ -5727,17 +5797,59 @@ instruction_open(struct_processus *s_eta
 								return;
 							}
 
-							for(i = 0; i < 16; i++)
-							{
-								sprintf((*((struct_socket *) (*s_objet_resultat)
-										.objet)).adresse,
-										(i == 0) ? "%s%X" : "%s:%X",
-										(*((struct_socket *) (*s_objet_resultat)
-										.objet)).adresse,
-										(*((struct sockaddr_in6 *)
-										(*resolution_courante).ai_addr))
-										.sin6_addr.s6_addr[i]);
-							}
+							sprintf((*((struct_socket *) (*s_objet_resultat)
+									.objet)).adresse,
+									"%02X%02X:%02X%02X:%02X%02X:%02X%02X:"
+									"%02X%02X:%02X%02X:%02X%02X:%02X%02X(%u)",
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[0],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[1],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[2],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[3],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[4],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[5],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[6],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[7],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[8],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[9],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[10],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[11],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[12],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[13],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[14],
+									(*((struct sockaddr_in6 *)
+									(*resolution_courante).ai_addr)).sin6_addr
+									.s6_addr[15],
+									(unsigned int) port);
 #							else
 							if ((*s_etat_processus).langue == 'F')
 							{
@@ -5762,11 +5874,6 @@ instruction_open(struct_processus *s_eta
 						}
 
 						freeaddrinfo(resolution);
-
-						sprintf((*((struct_socket *) (*s_objet_resultat)
-								.objet)).adresse, "%s(%u)",
-								(*((struct_socket *) (*s_objet_resultat)
-								.objet)).adresse, (unsigned int) port);
 					}
 					else
 					{ // Hôte défini par une adresse
@@ -5778,7 +5885,7 @@ instruction_open(struct_processus *s_eta
 										.objet)).adresse);
 
 								if (((*((struct_socket *) (*s_objet_resultat)
-										.objet)).adresse = malloc(22 *
+										.objet)).adresse = malloc(23 *
 										sizeof(unsigned char))) == NULL)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -5786,23 +5893,11 @@ instruction_open(struct_processus *s_eta
 									return;
 								}
 
-								(*((struct_socket *) (*s_objet_resultat).objet))
-										.adresse[0] = d_code_fin_chaine;
-
-								for(i = 0; i < 4; i++)
-								{
-									sprintf((*((struct_socket *)
-											(*s_objet_resultat).objet)).adresse,
-											(i == 0) ? "%s%d" : "%s.%d",
-											(*((struct_socket *)
-											(*s_objet_resultat)
-											.objet)).adresse, (int) adresse[i]);
-								}
-
 								sprintf((*((struct_socket *) (*s_objet_resultat)
-										.objet)).adresse, "%s(%u)",
-										(*((struct_socket *) (*s_objet_resultat)
-										.objet)).adresse, (unsigned int) port);
+										.objet)).adresse, "%d.%d.%d.%d(%u)",
+										(int) adresse[0], (int) adresse[1],
+										(int) adresse[2], (int) adresse[3],
+										(unsigned int) port);
 							}
 							else
 							{
@@ -5881,7 +5976,7 @@ instruction_open(struct_processus *s_eta
 										.objet)).adresse);
 
 								if (((*((struct_socket *) (*s_objet_resultat)
-										.objet)).adresse = malloc(55 *
+										.objet)).adresse = malloc(47 *
 										sizeof(unsigned char))) == NULL)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -5889,24 +5984,28 @@ instruction_open(struct_processus *s_eta
 									return;
 								}
 
-								(*((struct_socket *) (*s_objet_resultat).objet))
-										.adresse[0] = d_code_fin_chaine;
-
-								for(i = 0; i < 16; i++)
-								{
-									sprintf((*((struct_socket *)
-											(*s_objet_resultat).objet)).adresse,
-											(i == 0) ? "%s%X" : "%s:%X",
-											(*((struct_socket *)
-											(*s_objet_resultat)
-											.objet)).adresse, (unsigned int)
-											adresse[i]);
-								}
-
 								sprintf((*((struct_socket *) (*s_objet_resultat)
-										.objet)).adresse, "%s(%u)",
-										(*((struct_socket *) (*s_objet_resultat)
-										.objet)).adresse, (unsigned int) port);
+										.objet)).adresse,
+										"%02X%02X:%02X%02X:%02X%02X:%02X%02X:"
+										"%02X%02X:%02X%02X:%02X%02X:%02X%02X"
+										"(%u)",
+										(unsigned int) adresse[0],
+										(unsigned int) adresse[1],
+										(unsigned int) adresse[2],
+										(unsigned int) adresse[3],
+										(unsigned int) adresse[4],
+										(unsigned int) adresse[5],
+										(unsigned int) adresse[6],
+										(unsigned int) adresse[7],
+										(unsigned int) adresse[8],
+										(unsigned int) adresse[9],
+										(unsigned int) adresse[10],
+										(unsigned int) adresse[11],
+										(unsigned int) adresse[12],
+										(unsigned int) adresse[13],
+										(unsigned int) adresse[14],
+										(unsigned int) adresse[15],
+										(unsigned int) port);
 							}
 							else
 							{