--- rpl/src/instructions_r4.c 2011/07/22 07:38:39 1.38 +++ rpl/src/instructions_r4.c 2012/06/22 10:12:19 1.59 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.1 - Copyright (C) 1989-2011 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.9 + Copyright (C) 1989-2012 Dr. BERTRAND Joël This file is part of RPL/2. @@ -851,22 +851,26 @@ instruction_read(struct_processus *s_eta int c; int ios; + integer8 ancienne_longueur_effective; 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 format_degenere; logical1 indicateur_48; logical1 presence_chaine; logical1 presence_indicateur; + logical1 trame_complete; - long i; - long longueur_effective; - long longueur_enregistrement; - long longueur_questure; - long niveau; - long pointeur; - long position_finale; - long position_initiale; + long longueur; socklen_t longueur_adresse; @@ -874,6 +878,8 @@ instruction_read(struct_processus *s_eta struct flock lock; + struct pollfd poll_fd; + struct sockaddr_un adresse_unix; struct sockaddr_in adresse_ipv4; # ifdef IPV6 @@ -885,21 +891,27 @@ instruction_read(struct_processus *s_eta struct_descripteur_fichier *descripteur; struct_liste_chainee *l_element_courant; + struct_liste_chainee *l_element_courant_format; 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 *format_chaine; + unsigned char poubelle[256]; unsigned char *ptr; unsigned char *tampon_lecture; unsigned char *tampon; unsigned char *tampon2; + unsigned char type_enregistrement; (*s_etat_processus).erreur_execution = d_ex; @@ -1857,57 +1869,117 @@ instruction_read(struct_processus *s_eta /* * Fichiers non formatés */ - } - else - { - /* - * Fichiers de type FLOW - */ 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")); - longueur_enregistrement = 0; - if ((position_initiale = ftell((*descripteur).descripteur_c)) - == -1) + if (fread(&type_enregistrement, (size_t) sizeof(unsigned char), + 1, (*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) + if ((type_enregistrement & 0xF0) != 0x40) { - liberation(s_etat_processus, s_objet_argument_1); - - (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + // 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; } - if ((tampon_lecture = malloc((longueur_enregistrement + 1) - * sizeof(unsigned char))) == NULL) + switch(type_enregistrement) { - (*s_etat_processus).erreur_systeme = - d_es_allocation_memoire; - return; + 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; + } } - longueur_effective = fread(tampon_lecture, - (size_t) sizeof(unsigned char), - (size_t) longueur_enregistrement, - (*descripteur).descripteur_c); +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) @@ -1917,71 +1989,258 @@ instruction_read(struct_processus *s_eta return; } - if (((*s_objet_resultat).objet = - allocation_maillon(s_etat_processus)) == NULL) + for(i = 0; i < longueur_enregistrement; i++) { - (*s_etat_processus).erreur_systeme = - d_es_allocation_memoire; + /* 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; } - (*((struct_liste_chainee *) (*s_objet_resultat).objet)) - .suivant = NULL; + l_element_courant_format = (struct_liste_chainee *) + (*(*((struct_fichier *) (*s_objet_argument_1).objet)) + .format).objet; + l_element_courant = NULL; - if (((*((struct_liste_chainee *) (*s_objet_resultat).objet)) - .donnee = allocation(s_etat_processus, CHN)) == NULL) + if ((s_objet_resultat = allocation(s_etat_processus, LST)) + == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } - longueur_enregistrement = 1; - - for(i = 0; i < longueur_effective; i++) + while(l_element_courant_format != NULL) { - if (isprint(tampon_lecture[i]) != 0) + if ((*(*l_element_courant_format).donnee).type != CHN) + { + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_resultat); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_argument; + return; + } + + if ((format_chaine = conversion_majuscule((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) + { + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_resultat); + free(format_chaine); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_format_fichier; + return; + } + + longueur = strlen(format_chaine); + + if (format_chaine[longueur] != ')') + { + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_resultat); + free(format_chaine); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_format_fichier; + return; + } + + format_chaine[longueur] = d_code_fin_chaine; + + if (format_chaine[8] == '*') { - longueur_enregistrement += 4; + format_degenere = d_vrai; } else { - longueur_enregistrement++; + // Détermination de la longueur + format_degenere = d_faux; + + if (sscanf(&(format_chaine[8]), "%ld", &longueur) != 1) + { + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_resultat); + free(format_chaine); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_format_fichier; + return; + } } - } - if ((tampon = malloc(longueur_enregistrement * - sizeof(unsigned char))) == NULL) - { - (*s_etat_processus).erreur_systeme = - d_es_allocation_memoire; - return; - } + free(format_chaine); - ptr = tampon; + if (format_degenere == d_vrai) + { + do + { + c = getc((*descripteur).descripteur_c); + longueur_enregistrement++; + } while((c != '\n') && (c != EOF)); - for(i = 0; i < longueur_effective; i++) - { - if (isprint(tampon_lecture[i]) != 0) + if (fseek((*descripteur).descripteur_c, + position_initiale, SEEK_SET) != 0) + { + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_resultat); + + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + } + else + { + longueur_enregistrement = longueur; + } + + if ((tampon_lecture = malloc((longueur_enregistrement) + * 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 (l_element_courant == NULL) { - (*ptr) = tampon_lecture[i]; - ptr++; + // Premier maillon de la liste + if (((*s_objet_resultat).objet = + allocation_maillon(s_etat_processus)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + l_element_courant = (*s_objet_resultat).objet; } else { - (*ptr) = '\\'; - ptr++; - (*ptr) = 'x'; - ptr++; - sprintf(ptr, "%02X", tampon_lecture[i]); - ptr += 2; + if (((*l_element_courant).suivant = + allocation_maillon(s_etat_processus)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + l_element_courant = (*l_element_courant).suivant; } - } - (*ptr) = d_code_fin_chaine; - free(tampon_lecture); - ((*(*((struct_liste_chainee *) (*s_objet_resultat).objet)) - .donnee)).objet = tampon; + (*l_element_courant).suivant = NULL; + + if (((*l_element_courant).donnee = + allocation(s_etat_processus, CHN)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (format_degenere == d_vrai) + { + if (((*(*l_element_courant).donnee).objet = + analyse_flux(s_etat_processus, tampon_lecture, + longueur_enregistrement - 1)) == NULL) + { + return; + } + } + else + { + if (((*(*l_element_courant).donnee).objet = + analyse_flux(s_etat_processus, tampon_lecture, + longueur_enregistrement)) == NULL) + { + return; + } + } + + free(tampon_lecture); + + l_element_courant_format = + (*l_element_courant_format).suivant; + } if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), @@ -2037,11 +2296,23 @@ instruction_read(struct_processus *s_eta if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N') { // Socket formatée longueur_questure = 256; + 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 { - if ((tampon_lecture = malloc((longueur_questure + 1) * - sizeof(unsigned char))) == NULL) + 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; @@ -2049,55 +2320,243 @@ instruction_read(struct_processus *s_eta } # ifndef SEMAPHORES_NOMMES - if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) + if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) +# else + if (sem_post((*s_etat_processus).semaphore_fork) != 0) +# endif { (*s_etat_processus).erreur_systeme = d_es_processus; return; } -# else - if (sem_post((*s_etat_processus).semaphore_fork) != 0) + + if ((*((struct_socket *) (*s_objet_argument_1).objet)) + .domaine == PF_UNIX) { - (*s_etat_processus).erreur_systeme = d_es_processus; + 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; } -# endif - attente.tv_sec = 0; - attente.tv_nsec = GRANULARITE_us * 1000; + 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; + } - for(;;) + if ((*s_etat_processus).var_volatile_requete_arret == -1) { + longueur_effective += ios; + break; + } + + // Une donnée a été reçue. + + if (ios >= 0) + { + ancienne_longueur_effective = longueur_effective; + 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 du buffer position_finale - + // ancienne_longueur_effective octets. + 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); + + do + { + ios = recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, + poubelle, position_finale + - ancienne_longueur_effective, + 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) + 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); + + do + { + ios = recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, + poubelle, position_finale + - ancienne_longueur_effective, + 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) + 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); + do + { + ios = recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, + poubelle, position_finale + - ancienne_longueur_effective, + MSG_DONTWAIT, (struct sockaddr *) + &adresse_ipv6, &longueur_adresse); + } + while((ios == -1) && (errno == EINTR)); # else if ((*s_etat_processus).langue == 'F') { @@ -2109,57 +2568,51 @@ instruction_read(struct_processus *s_eta printf("+++Warning : IPv6 support " "unavailable\n"); } + + longueur_adresse = 0; # endif } - else + + if (presence_indicateur == d_faux) { - free(tampon_lecture); - liberation(s_etat_processus, s_objet_argument_1); + poll_fd.fd = (*((struct_socket *) + (*s_objet_argument_1).objet)).socket; + poll_fd.events = POLLIN; -# ifndef SEMAPHORES_NOMMES - while(sem_wait(&((*s_etat_processus) - .semaphore_fork)) == -1) -# else - while(sem_wait((*s_etat_processus) - .semaphore_fork) == -1) -# endif + while((ios = poll(&poll_fd, 1, 100)) <= 0) { - if (errno != EINTR) - { - (*s_etat_processus).erreur_systeme = - d_es_processus; - return; - } - } + // La fin de la trame n'est pas atteinte + // et il reste quelque chose à lire. - (*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); - } + switch(ios) + { + case EINTR: + { + break; + } - // Une donnée a été reçue. + case 0: + { + liberation(s_etat_processus, + s_objet_argument_1); + free(tampon_lecture); - if (((*s_etat_processus).var_volatile_requete_arret == -1) - || (longueur_effective >= 0)) - { - break; + (*s_etat_processus).erreur_execution = + d_ex_fin_de_fichier_atteinte; + return; + } + } + } } } # 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; @@ -2190,79 +2643,7 @@ instruction_read(struct_processus *s_eta d_ex_erreur_acces_fichier; return; } - - 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 == '"') - { - 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; - break; - } - - position_finale++; - } - } - - if (presence_indicateur == d_faux) - { - if (longueur_effective < longueur_questure) - { - liberation(s_etat_processus, s_objet_argument_1); - free(tampon_lecture); - - (*s_etat_processus).erreur_execution = - d_ex_fin_de_fichier_atteinte; - return; - } - - free(tampon_lecture); - longueur_questure *= 2; - } - } while(presence_indicateur == d_faux); + } while(trame_complete == d_faux); tampon_lecture[++position_finale] = d_code_fin_chaine; tampon = (*s_etat_processus).instruction_courante; @@ -2279,6 +2660,20 @@ instruction_read(struct_processus *s_eta (*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; } @@ -2354,23 +2749,11 @@ instruction_read(struct_processus *s_eta (strcmp((*((struct_socket *) (*s_objet_argument_1).objet)) .type, "SEQUENTIAL DATAGRAM") == 0)) { - 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) { @@ -2445,12 +2828,6 @@ instruction_read(struct_processus *s_eta .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) { @@ -2560,18 +2937,14 @@ 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; @@ -2619,6 +2992,9 @@ instruction_read(struct_processus *s_eta printf("+++Warning : IPv6 support " "unavailable\n"); } + + longueur_adresse = 0; + longueur_effective = 0; # endif } else @@ -2627,11 +3003,11 @@ 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) @@ -2662,9 +3038,9 @@ 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)