--- rpl/src/instructions_r4.c 2010/04/21 13:45:49 1.13 +++ rpl/src/instructions_r4.c 2011/11/15 07:01:37 1.46 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.0.15 - Copyright (C) 1989-2010 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.4 + Copyright (C) 1989-2011 Dr. BERTRAND Joël This file is part of RPL/2. @@ -20,7 +20,7 @@ */ -#include "rpl.conv.h" +#include "rpl-conv.h" /* @@ -848,24 +848,26 @@ instruction_read(struct_processus *s_eta { const char *queue; + int c; int ios; integer8 element; + integer8 i; integer8 id; integer8 position_clef; + integer8 longueur_effective; + integer8 longueur_enregistrement; + integer8 longueur_questure; + integer8 niveau; + integer8 pointeur; + integer8 position_finale; + integer8 position_initiale; + logical1 indicateur_48; logical1 presence_chaine; logical1 presence_indicateur; - long longueur_effective; - long longueur_enregistrement; - long longueur_questure; - long niveau; - long pointeur; - long position_finale; - long position_initiale; - socklen_t longueur_adresse; sqlite3_stmt *ppStmt; @@ -874,7 +876,9 @@ instruction_read(struct_processus *s_eta struct sockaddr_un adresse_unix; struct sockaddr_in adresse_ipv4; +# ifdef IPV6 struct sockaddr_in6 adresse_ipv6; +# endif struct timespec attente; @@ -882,27 +886,26 @@ instruction_read(struct_processus *s_eta struct_liste_chainee *l_element_courant; struct_liste_chainee *l_element_inclus; + struct_liste_chainee *l_element_suivant; struct_objet *s_objet_adresse; struct_objet *s_objet_argument_1; struct_objet *s_objet_argument_2; + struct_objet *s_objet_element; struct_objet *s_objet_resultat; struct_objet *s_objet_type; unsigned char caractere; unsigned char *clef_utf8; unsigned char *commande; + unsigned char *ptr; unsigned char *tampon_lecture; unsigned char *tampon; unsigned char *tampon2; - - unsigned long i; + unsigned char type_enregistrement; (*s_etat_processus).erreur_execution = d_ex; - attente.tv_sec = 0; - attente.tv_nsec = GRANULARITE_us * 1000; - if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n READ "); @@ -1857,12 +1860,315 @@ instruction_read(struct_processus *s_eta /* * Fichiers non formatés */ + + if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces + == 'S') + { + /* + * Fichiers séquentiels + * + * Les fichiers séquentiels non formatés contiennent comme + * les fichiers séquentiels formatés leurs enregistrements + * sous la forme de listes les unes derrières les autres. + * + * Le quartet de poids fort du premier octet à lire + * doit donc être égal à 0100. Si ce n'est pas le cas, + * il sera impossible de lire le fichier et on renvoie + * immédiatement une erreur. Si on lit dans le fichier + * la valeur attendue, on récupère la longueur en octet + * de l'enregistrement puis on le lit. + */ + + BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n")); + + if (fread(&type_enregistrement, (size_t) sizeof(unsigned char), + 1, (*descripteur).descripteur_c) != 1) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + if ((type_enregistrement & 0xF0) != 0x40) + { + // L'enregistrement trouvé n'est pas une liste. + // Tout porte à croire que le fichier est corrompu. + (*s_etat_processus).erreur_execution = + d_ex_fichier_corrompu; + return; + } + + switch(type_enregistrement) + { + unsigned char taille_enregistrement[8]; + + case 0x48: + { + if (fread(taille_enregistrement, + (size_t) sizeof(unsigned char), + 1, (*descripteur).descripteur_c) != 1) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + + longueur_enregistrement = taille_enregistrement[0]; + break; + } + + case 0x49: + { + if (fread(taille_enregistrement, + (size_t) sizeof(unsigned char), + 2, (*descripteur).descripteur_c) != 2) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + +// A FAIRE conversion de taille_enregistrement en longueur_enregistrement + break; + } + + case 0x4A: + { + if (fread(taille_enregistrement, + (size_t) sizeof(unsigned char), + 4, (*descripteur).descripteur_c) != 4) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + +// A FAIRE conversion de taille_enregistrement en longueur_enregistrement + break; + } + + case 0x4B: + { + if (fread(taille_enregistrement, + (size_t) sizeof(unsigned char), + 8, (*descripteur).descripteur_c) != 8) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + +// A FAIRE conversion de taille_enregistrement en longueur_enregistrement + break; + } + + default: + { + longueur_enregistrement = type_enregistrement & 0x07; + } + } + +printf("L=%d\n", longueur_enregistrement); + // La variable longueur_enregistrement contient le nombre + // d'éléments à lire dans le fichier pour générer la liste + // contenant l'enregistrement. + + if ((s_objet_resultat = allocation(s_etat_processus, LST)) + == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + for(i = 0; i < longueur_enregistrement; i++) + { + /* A FAIRE + s_objet_element = decodage_enregistrement(s_etat_processus, + (*descripteur).descripteur_c); + */ + s_objet_element = NULL; + + if (s_objet_element == NULL) + { + liberation(s_etat_processus, s_objet_resultat); + return; + } + + if ((*s_objet_resultat).objet == NULL) + { + 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_element; + l_element_courant = (*s_objet_resultat).objet; + } + else + { + if ((l_element_suivant = allocation_maillon( + s_etat_processus)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + (*l_element_courant).suivant = l_element_suivant; + (*l_element_suivant).donnee = s_objet_element; + l_element_courant = l_element_suivant; + } + } + + // On saute les caractère des gestion de la commande + // BACKSPACE. + // A FAIRE + } } else { /* * Fichiers de type FLOW */ + + if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces + == 'S') + { + /* + * Fichiers séquentiels + */ + + BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n")); + longueur_enregistrement = 0; + + if ((position_initiale = ftell((*descripteur).descripteur_c)) + == -1) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + do + { + c = getc((*descripteur).descripteur_c); + longueur_enregistrement++; + } while((c != '\n') && (c != EOF)); + + if (fseek((*descripteur).descripteur_c, position_initiale, + SEEK_SET) != 0) + { + liberation(s_etat_processus, s_objet_argument_1); + + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + if ((tampon_lecture = malloc((longueur_enregistrement + 1) + * sizeof(unsigned char))) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + longueur_effective = fread(tampon_lecture, + (size_t) sizeof(unsigned char), + (size_t) longueur_enregistrement, + (*descripteur).descripteur_c); + + 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)) + .suivant = NULL; + + if (((*((struct_liste_chainee *) (*s_objet_resultat).objet)) + .donnee = allocation(s_etat_processus, CHN)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + longueur_enregistrement = 1; + + for(i = 0; i < longueur_effective; i++) + { + if (isprint(tampon_lecture[i]) != 0) + { + longueur_enregistrement += 4; + } + else + { + longueur_enregistrement++; + } + } + + if ((tampon = malloc(longueur_enregistrement * + sizeof(unsigned char))) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + ptr = tampon; + + for(i = 0; i < longueur_effective; i++) + { + if (isprint(tampon_lecture[i]) != 0) + { + (*ptr) = tampon_lecture[i]; + ptr++; + } + else + { + (*ptr) = '\\'; + ptr++; + (*ptr) = 'x'; + ptr++; + sprintf(ptr, "%02X", tampon_lecture[i]); + ptr += 2; + } + } + + (*ptr) = d_code_fin_chaine; + free(tampon_lecture); + ((*(*((struct_liste_chainee *) (*s_objet_resultat).objet)) + .donnee)).objet = tampon; + + if (empilement(s_etat_processus, + &((*s_etat_processus).l_base_pile), + s_objet_resultat) == d_erreur) + { + return; + } + } + else + { + liberation(s_etat_processus, s_objet_argument_1); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_fichier; + return; + } } } else if ((*s_objet_argument_1).type == SCK) @@ -1914,18 +2220,17 @@ instruction_read(struct_processus *s_eta } # ifndef SEMAPHORES_NOMMES - if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) - { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } + if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) # else - if (sem_post((*s_etat_processus).semaphore_fork) != 0) + if (sem_post((*s_etat_processus).semaphore_fork) != 0) +# endif { (*s_etat_processus).erreur_systeme = d_es_processus; return; } -# endif + + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; for(;;) { @@ -1952,12 +2257,26 @@ instruction_read(struct_processus *s_eta else if ((*((struct_socket *) (*s_objet_argument_1).objet)) .domaine == PF_INET6) { +# ifdef IPV6 longueur_adresse = sizeof(adresse_ipv6); longueur_effective = recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, tampon_lecture, longueur_questure, MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) &adresse_ipv6, &longueur_adresse); + +# else + if ((*s_etat_processus).langue == 'F') + { + printf("+++Attention : Support du protocole" + " IPv6 indisponible\n"); + } + else + { + printf("+++Warning : IPv6 support " + "unavailable\n"); + } +# endif } else { @@ -1965,19 +2284,15 @@ instruction_read(struct_processus *s_eta liberation(s_etat_processus, s_objet_argument_1); # ifndef SEMAPHORES_NOMMES - while(sem_wait(&((*s_etat_processus) - .semaphore_fork)) == -1) + while(sem_wait(&((*s_etat_processus) + .semaphore_fork)) != 0) # else - while(sem_wait((*s_etat_processus) - .semaphore_fork) == -1) + while(sem_wait((*s_etat_processus) + .semaphore_fork) != 0) # endif { - if (errno != EINTR) - { - (*s_etat_processus).erreur_systeme = - d_es_processus; - return; - } + (*s_etat_processus).erreur_systeme = + d_es_processus; } (*s_etat_processus).erreur_execution = @@ -1988,9 +2303,12 @@ instruction_read(struct_processus *s_eta if (longueur_effective < 0) { nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); scrutation_injection(s_etat_processus); } + // Une donnée a été reçue. + if (((*s_etat_processus).var_volatile_requete_arret == -1) || (longueur_effective >= 0)) { @@ -1999,12 +2317,12 @@ instruction_read(struct_processus *s_eta } # ifndef SEMAPHORES_NOMMES - while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) + while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) # else - while(sem_wait((*s_etat_processus).semaphore_fork) == -1) + while(sem_wait((*s_etat_processus).semaphore_fork) != 0) # endif { - if (errno != EINTR) + if (errno == EINTR) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -2202,6 +2520,459 @@ instruction_read(struct_processus *s_eta longueur_adresse = 0; recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, tampon_lecture, + longueur_effective, MSG_DONTWAIT, + NULL, &longueur_adresse); + + (*s_objet_adresse).objet = NULL; + } + else if ((*((struct_socket *) (*s_objet_argument_1).objet)) + .domaine == PF_INET) + { + longueur_adresse = sizeof(adresse_ipv4); + recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, tampon_lecture, + longueur_effective, MSG_DONTWAIT, + (struct sockaddr *) &adresse_ipv4, &longueur_adresse); + + 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 + longueur_adresse = sizeof(adresse_ipv6); + recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, tampon_lecture, + longueur_effective, MSG_DONTWAIT, + (struct sockaddr *) &adresse_ipv6, &longueur_adresse); + + 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 if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire + == 'Y') + { // UNFORMATTED + } + else + { // FLOW + longueur_questure = 256; + + do + { + if ((tampon_lecture = malloc((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; + } + + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + for(;;) + { + if ((*((struct_socket *) (*s_objet_argument_1).objet)) + .domaine == PF_UNIX) + { + longueur_adresse = sizeof(adresse_unix); + longueur_effective = recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, + tampon_lecture, longueur_questure, + MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) + &adresse_unix, &longueur_adresse); + } + else if ((*((struct_socket *) (*s_objet_argument_1).objet)) + .domaine == PF_INET) + { + longueur_adresse = sizeof(adresse_ipv4); + longueur_effective = recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, + tampon_lecture, longueur_questure, + MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) + &adresse_ipv4, &longueur_adresse); + } + else if ((*((struct_socket *) (*s_objet_argument_1).objet)) + .domaine == PF_INET6) + { +# ifdef IPV6 + longueur_adresse = sizeof(adresse_ipv6); + longueur_effective = recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, + tampon_lecture, longueur_questure, + MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) + &adresse_ipv6, &longueur_adresse); +# else + if ((*s_etat_processus).langue == 'F') + { + printf("+++Attention : Support du protocole" + " IPv6 indisponible\n"); + } + else + { + printf("+++Warning : IPv6 support " + "unavailable\n"); + } +# 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 + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = + d_es_processus; + return; + } + } + + (*s_etat_processus).erreur_execution = + d_ex_erreur_acces_fichier; + return; + } + + if (longueur_effective < 0) + { + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + scrutation_injection(s_etat_processus); + } + + if (((*s_etat_processus).var_volatile_requete_arret == -1) + || (longueur_effective >= 0)) + { + break; + } + } + +# 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; + } + + if (longueur_effective == longueur_questure) + { + free(tampon_lecture); + longueur_questure *= 2; + } + } while(longueur_effective == longueur_questure); + + longueur_enregistrement = 1; + + for(i = 0; i < longueur_effective; i++) + { + if (isprint(tampon_lecture[i]) != 0) + { + longueur_enregistrement += 4; + } + else + { + longueur_enregistrement++; + } + } + + /* + * Création de la liste de sortie + */ + + if ((s_objet_type = allocation(s_etat_processus, CHN)) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + if (((*s_objet_type).objet = malloc(longueur_enregistrement * + sizeof(unsigned char))) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + ptr = (*s_objet_type).objet; + + for(i = 0; i < longueur_effective; i++) + { + if (isprint(tampon_lecture[i]) != 0) + { + (*ptr) = tampon_lecture[i]; + ptr++; + } + else + { + (*ptr) = '\\'; + ptr++; + (*ptr) = 'x'; + ptr++; + sprintf(ptr, "%02X", tampon_lecture[i]); + ptr += 2; + } + } + + (*ptr) = d_code_fin_chaine; + + 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 que les domaines sont + * 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)) + { + // POSITION_FINALE peut être utilisée sans être initialisée ! + // virer position_finale pour longueur_effective + longueur_adresse = 0; + recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, tampon_lecture, position_finale, MSG_DONTWAIT, NULL, &longueur_adresse); @@ -2289,6 +3060,7 @@ instruction_read(struct_processus *s_eta else if ((*((struct_socket *) (*s_objet_argument_1).objet)) .domaine == PF_INET6) { +# ifdef IPV6 longueur_adresse = sizeof(adresse_ipv6); recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, tampon_lecture, @@ -2355,6 +3127,18 @@ instruction_read(struct_processus *s_eta (*(*((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 { @@ -2373,10 +3157,6 @@ instruction_read(struct_processus *s_eta return; } } - else - { - /* FLOW ou UNFORMATTED */ - } } else {