--- rpl/src/instructions_r4.c	2013/03/10 17:01:05	1.72
+++ rpl/src/instructions_r4.c	2013/03/11 15:41:05	1.73
@@ -2849,10 +2849,640 @@ instruction_read(struct_processus *s_eta
 		}
 		else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire
 				== 'Y')
-		{ // UNFORMATTED
+		{ // socket non formatée
+			longueur_questure = 4096;
+			longueur_effective = 0;
+			tampon_lecture = NULL;
+
+			attente.tv_sec = 0;
+			attente.tv_nsec = GRANULARITE_us * 1000;
+
+			trame_complete = d_faux;
+			position_initiale = 0;
+			position_finale = 0;
+
+			do
+			{
+				presence_indicateur = d_faux;
+
+				if ((tampon_lecture = realloc(tampon_lecture,
+						(longueur_effective + longueur_questure + 1)
+					   	* sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+#				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;
+				}
+
+				if ((*((struct_socket *) (*s_objet_argument_1).objet))
+						.domaine == PF_UNIX)
+				{
+					longueur_adresse = sizeof(adresse_unix);
+
+					do
+					{
+						ios = recvfrom((*((struct_socket *)
+								(*s_objet_argument_1).objet)).socket,
+								tampon_lecture,
+								longueur_effective + longueur_questure,
+								MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
+								&adresse_unix, &longueur_adresse);
+					} while((ios == -1) && (errno == EINTR));
+				}
+				else if ((*((struct_socket *) (*s_objet_argument_1).objet))
+						.domaine == PF_INET)
+				{
+					longueur_adresse = sizeof(adresse_ipv4);
+
+					do
+					{
+						ios = recvfrom((*((struct_socket *)
+								(*s_objet_argument_1).objet)).socket,
+								tampon_lecture,
+								longueur_effective + longueur_questure,
+								MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
+								&adresse_ipv4, &longueur_adresse);
+					} while((ios == -1) && (errno == EINTR));
+				}
+				else if ((*((struct_socket *) (*s_objet_argument_1).objet))
+						.domaine == PF_INET6)
+				{
+#					ifdef IPV6
+					longueur_adresse = sizeof(adresse_ipv6);
+					
+					do
+					{
+						ios = recvfrom((*((struct_socket *)
+								(*s_objet_argument_1).objet)).socket,
+								tampon_lecture,
+								longueur_effective + longueur_questure,
+								MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
+								&adresse_ipv6, &longueur_adresse);
+					} while((ios == -1) && (errno == EINTR));
+#					else
+					if ((*s_etat_processus).langue == 'F')
+					{
+						printf("+++Attention : Support du protocole"
+								" IPv6 indisponible\n");
+					}
+					else
+					{
+						printf("+++Warning : IPv6 support "
+								"unavailable\n");
+					}
+
+					longueur_adresse = 0;
+					longueur_effective = 0;
+					ios = 0;
+#					endif
+				}
+				else
+				{
+					free(tampon_lecture);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+#					ifndef SEMAPHORES_NOMMES
+						while(sem_wait(&((*s_etat_processus)
+								.semaphore_fork)) != 0)
+#					else
+						while(sem_wait((*s_etat_processus)
+								.semaphore_fork) != 0)
+#					endif
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_processus;
+					}
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_acces_fichier;
+					return;
+				}
+
+				if (ios < 0)
+				{
+					nanosleep(&attente, NULL);
+					INCR_GRANULARITE(attente.tv_nsec);
+					scrutation_injection(s_etat_processus);
+				}
+				else
+				{
+					attente.tv_sec = 0;
+					attente.tv_nsec = GRANULARITE_us * 1000;
+				}
+
+				if ((*s_etat_processus).var_volatile_requete_arret == -1)
+				{
+					if (ios >= 0)
+					{
+						longueur_effective += ios;
+					}
+
+					break;
+				}
+
+				// Une donnée a été reçue.
+
+				if (ios >= 0)
+				{
+					longueur_effective += ios;
+					position_initiale = 0;
+					presence_indicateur = d_faux;
+
+					do
+					{
+						if (tampon_lecture[position_initiale] == '{')
+						{
+							presence_indicateur = d_vrai;
+							break;
+						}
+
+						position_initiale++;
+					} while(position_initiale < longueur_effective);
+
+					if (presence_indicateur == d_vrai)
+					{
+						position_finale = position_initiale + 1;
+						presence_chaine = d_faux;
+						presence_indicateur = d_faux;
+						niveau = 1;
+
+						while(position_finale < longueur_effective)
+						{
+							caractere = tampon_lecture[position_finale];
+
+							if (caractere == '"')
+							{
+								if (position_finale > 0)
+								{
+									if (tampon_lecture[position_finale - 1]
+											!= '\\')
+									{
+										presence_chaine = (presence_chaine ==
+												d_vrai) ? d_faux : d_vrai;
+									}
+								}
+								else
+								{
+									presence_chaine =
+											(presence_chaine == d_vrai)
+											? d_faux : d_vrai;
+								}
+							}
+							else
+							{
+								if (presence_chaine == d_faux)
+								{
+									if (caractere == '{')
+									{
+										niveau++;
+									}
+									else if (caractere == '}')
+									{
+										niveau--;
+									}
+								}
+							}
+
+							if (niveau == 0)
+							{
+								presence_indicateur = d_vrai;
+								trame_complete = d_vrai;
+								break;
+							}
+
+							position_finale++;
+						}
+					}
+
+					// On retire une trame du buffer.
+
+					if (trame_complete == d_vrai)
+					{
+						if ((*((struct_socket *) (*s_objet_argument_1).objet))
+								.domaine == PF_UNIX)
+						{
+							do
+							{
+								longueur_adresse = sizeof(adresse_unix);
+								recvfrom((*((struct_socket *)
+										(*s_objet_argument_1).objet)).socket,
+										tampon_lecture, longueur_effective,
+										0, (struct sockaddr *)
+										&adresse_unix, &longueur_adresse);
+							} while((ios == -1) && (errno == EINTR));
+						}
+						else if ((*((struct_socket *) (*s_objet_argument_1)
+								.objet)).domaine == PF_INET)
+						{
+							do
+							{
+								longueur_adresse = sizeof(adresse_ipv4);
+								recvfrom((*((struct_socket *)
+										(*s_objet_argument_1).objet)).socket,
+										tampon_lecture, longueur_effective,
+										0, (struct sockaddr *)
+										&adresse_ipv4, &longueur_adresse);
+							} while((ios == -1) && (errno == EINTR));
+						}
+						else if ((*((struct_socket *) (*s_objet_argument_1)
+								.objet)) .domaine == PF_INET6)
+						{
+#							ifdef IPV6
+							do
+							{
+								longueur_adresse = sizeof(adresse_ipv6);
+								recvfrom((*((struct_socket *)
+										(*s_objet_argument_1).objet)).socket,
+										tampon_lecture, longueur_effective,
+										0, (struct sockaddr *)
+										&adresse_ipv6, &longueur_adresse);
+							} while((ios == -1) && (errno == EINTR));
+#							else
+							if ((*s_etat_processus).langue == 'F')
+							{
+								printf("+++Attention : Support du protocole"
+										" IPv6 indisponible\n");
+							}
+							else
+							{
+								printf("+++Warning : IPv6 support "
+										"unavailable\n");
+							}
+
+#							endif
+						}
+
+						longueur_effective = ios;
+					}
+					else
+					{
+						// Installation d'un timeout pour sortir de
+						// l'instruction dans le cas où la transmission serait
+						// invalide et que la trame reçue serait erronée.
+
+						poll_fd.fd = (*((struct_socket *)
+								(*s_objet_argument_1).objet)).socket;
+						poll_fd.events = POLLIN;
+
+						while((ios = poll(&poll_fd, 1, 10000)) <= 0)
+						{
+							// La fin de la trame n'est pas atteinte.
+
+							switch(ios)
+							{
+								case EINTR:
+								{
+									if ((*s_etat_processus)
+											.var_volatile_requete_arret == -1)
+									{
+										liberation(s_etat_processus,
+												s_objet_argument_1);
+										free(tampon_lecture);
+										return;
+									}
+
+									break;
+								}
+
+								case 0:
+								{
+									liberation(s_etat_processus,
+											s_objet_argument_1);
+									free(tampon_lecture);
+
+									(*s_etat_processus).erreur_execution =
+											d_ex_fin_de_fichier_atteinte;
+									return;
+								}
+							}
+						}
+					}
+				}
+
+#				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 ((*s_etat_processus).var_volatile_requete_arret == -1)
+				{
+
+					/*
+					 * Si le père tue le processus courant grâce au signal
+					 * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
+					 * correspond à l'utilisation de STOP sur le processus
+					 * en cours. La variable longueur_effective vaut '-1'.
+					 */
+
+					free(tampon_lecture);
+					liberation(s_etat_processus, s_objet_argument_1);
+					return;
+				}
+
+				if (longueur_effective == -1)
+				{
+					free(tampon_lecture);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_acces_fichier;
+					return;
+				}
+			} while(trame_complete == d_faux);
+
+			tampon_lecture[++position_finale] = d_code_fin_chaine;
+			tampon = (*s_etat_processus).instruction_courante;
+			(*s_etat_processus).instruction_courante = tampon_lecture;
+
+			indicateur_48 = test_cfsf(s_etat_processus, 48);
+			cf(s_etat_processus, 48);
+
+			recherche_type(s_etat_processus);
+
+			if ((*s_etat_processus).erreur_execution != d_ex)
+			{
+				(*s_etat_processus).instruction_courante = tampon;
+				free(tampon_lecture);
+				
+				if (indicateur_48 == d_vrai)
+				{
+					sf(s_etat_processus, 48);
+				}
+				else
+				{
+					cf(s_etat_processus, 48);
+				}
+
+				if ((*s_etat_processus).var_volatile_requete_arret == -1)
+				{
+					(*s_etat_processus).erreur_execution = d_ex;
+				}
+
+				liberation(s_etat_processus, s_objet_argument_1);
+				return;
+			}
+
+			if (indicateur_48 == d_vrai)
+			{
+				sf(s_etat_processus, 48);
+			}
+			else
+			{
+				cf(s_etat_processus, 48);
+			}
+
+			(*s_etat_processus).instruction_courante = tampon;
+
+			/*
+			 * Création de la liste de sortie
+			 */
+
+			if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					&s_objet_type) == d_erreur)
+			{
+				(*s_etat_processus).erreur_execution = d_ex_manque_argument;
+				return;
+			}
+
+			if ((s_objet_resultat = allocation(s_etat_processus, LST))
+					== NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			if (((*s_objet_resultat).objet =
+					allocation_maillon(s_etat_processus)) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			(*((struct_liste_chainee *) (*s_objet_resultat).objet))
+					.donnee = s_objet_type;
+
+			if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
+					.suivant = allocation_maillon(s_etat_processus)) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			(*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
+					.suivant = NULL;
+
+			if ((s_objet_adresse = allocation(s_etat_processus, LST))
+					== NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			(*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
+					.donnee = s_objet_adresse;
+
+			/*
+			 * Les informations concernant la cible sont valides si
+			 * la socket est non connectée et des domaines INET ou INET6.
+			 * Dans tous les autres cas, on renvoie une liste vide.
+			 */
+
+			if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
+					== PF_UNIX) || (strcmp((*((struct_socket *)
+					(*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
+					(strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
+					.type, "SEQUENTIAL DATAGRAM") == 0))
+			{
+				(*s_objet_adresse).objet = NULL;
+			}
+			else if ((*((struct_socket *) (*s_objet_argument_1).objet))
+					.domaine == PF_INET)
+			{
+				if (((*s_objet_adresse).objet =
+						allocation_maillon(s_etat_processus)) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.donnee = allocation(s_etat_processus, VIN)) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				(*((struct_vecteur *) (*(*((struct_liste_chainee *)
+						(*s_objet_adresse).objet)).donnee).objet)).taille = 4;
+
+				if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
+						(*s_objet_adresse).objet)).donnee).objet)).tableau =
+						malloc(4 * sizeof(integer8))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				((integer8 *) (*((struct_vecteur *)
+						(*(*((struct_liste_chainee *) (*s_objet_adresse)
+						.objet)).donnee).objet)).tableau)[0] =
+						(ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
+				((integer8 *) (*((struct_vecteur *)
+						(*(*((struct_liste_chainee *) (*s_objet_adresse)
+						.objet)).donnee).objet)).tableau)[1] =
+						(ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
+				((integer8 *) (*((struct_vecteur *)
+						(*(*((struct_liste_chainee *) (*s_objet_adresse)
+						.objet)).donnee).objet)).tableau)[2] =
+						(ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
+				((integer8 *) (*((struct_vecteur *)
+						(*(*((struct_liste_chainee *) (*s_objet_adresse)
+						.objet)).donnee).objet)).tableau)[3] =
+						ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
+
+				if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.suivant = allocation_maillon(s_etat_processus))
+						== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.suivant).donnee = allocation(s_etat_processus, INT))
+						== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				(*((integer8 *) (*(*(*((struct_liste_chainee *)
+						(*s_objet_adresse).objet)).suivant).donnee).objet)) =
+						(integer8) ntohs(adresse_ipv4.sin_port);
+
+				(*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.suivant).suivant = NULL;
+			}
+			else if ((*((struct_socket *) (*s_objet_argument_1).objet))
+					.domaine == PF_INET6)
+			{
+#				ifdef IPV6
+				if (((*s_objet_adresse).objet =
+						allocation_maillon(s_etat_processus)) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.donnee = allocation(s_etat_processus, VIN)) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				(*((struct_vecteur *) (*(*((struct_liste_chainee *)
+						(*s_objet_adresse).objet)).donnee).objet)).taille = 16;
+
+				if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
+						(*s_objet_adresse).objet)).donnee).objet)).tableau =
+						malloc(16 * sizeof(integer8))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				for(i = 0; i < 16; i++)
+				{
+					((integer8 *) (*((struct_vecteur *)
+							(*(*((struct_liste_chainee *) (*s_objet_adresse)
+							.objet)).donnee).objet)).tableau)[0] =
+							adresse_ipv6.sin6_addr.s6_addr[i];
+				}
+
+				if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.suivant = allocation_maillon(s_etat_processus))
+						== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.suivant).donnee = allocation(s_etat_processus, INT))
+						== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				(*((integer8 *) (*(*(*((struct_liste_chainee *)
+						(*s_objet_adresse).objet)).suivant).donnee).objet)) =
+						(integer8) ntohs(adresse_ipv6.sin6_port);
+
+				(*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
+						.suivant).suivant = NULL;
+#				else
+				if ((*s_etat_processus).langue == 'F')
+				{
+					printf("+++Attention : Support du protocole"
+							" IPv6 indisponible\n");
+				}
+				else
+				{
+					printf("+++Warning : IPv6 support "
+							"unavailable\n");
+				}
+#				endif
+			}
+			else
+			{
+				longueur_adresse = 0;
+				recvfrom((*((struct_socket *)
+						(*s_objet_argument_1).objet)).socket, tampon_lecture,
+						position_finale, MSG_DONTWAIT,
+						NULL, &longueur_adresse);
+			}
+
+			free(tampon_lecture);
+
+			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					s_objet_resultat) == d_erreur)
+			{
+				return;
+			}
 		}
 		else
 		{ // FLOW
+#if 0
 			longueur_questure = 256;
 
 			do
@@ -3302,6 +3932,7 @@ instruction_read(struct_processus *s_eta
 			{
 				return;
 			}
+#endif
 		}
 	}
 	else