--- rpl/src/instructions_r4.c 2010/01/27 22:22:15 1.2 +++ rpl/src/instructions_r4.c 2017/01/18 15:44:22 1.101 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.0.10 - Copyright (C) 1989-2010 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.26 + Copyright (C) 1989-2017 Dr. BERTRAND Joël This file is part of RPL/2. @@ -20,7 +20,7 @@ */ -#include "rpl.conv.h" +#include "rpl-conv.h" /* @@ -96,8 +96,8 @@ instruction_r_vers_b(struct_processus *s } else { - (*((logical8 *) (*s_objet_resultat).objet)) = (*((integer8 *) - (*s_objet_argument).objet)); + (*((logical8 *) (*s_objet_resultat).objet)) = (logical8) + (*((integer8 *) (*s_objet_argument).objet)); } } else @@ -751,7 +751,7 @@ instruction_relax(struct_processus *s_et void instruction_rewind(struct_processus *s_etat_processus) { - file *descripteur; + struct_descripteur_fichier *descripteur; struct_objet *s_objet_argument; @@ -803,11 +803,19 @@ instruction_rewind(struct_processus *s_e return; } - if (fseek(descripteur, (long) 0, SEEK_SET) != 0) + if ((*descripteur).type == 'C') + { + if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_SET) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + } + else { liberation(s_etat_processus, s_objet_argument); - (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + (*s_etat_processus).erreur_execution = d_ex_erreur_type_fichier; return; } } @@ -838,45 +846,107 @@ instruction_rewind(struct_processus *s_e void instruction_read(struct_processus *s_etat_processus) { - file *descripteur; + const char *queue; + + int c; + int ios; + int timeout; + + integer8 element; + integer8 i; + integer8 id; + integer8 index; + integer8 longueur; + integer8 position_clef; + + integer8 longueur_effective; + integer8 longueur_enregistrement; + integer8 longueur_questure; + integer8 niveau; + integer8 pointeur; + integer8 position_finale; + integer8 position_initiale; + logical1 device; + logical1 format_degenere; 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; + logical1 trame_complete; socklen_t longueur_adresse; + sqlite3_stmt *ppStmt; + struct flock lock; + struct pollfd fds[1]; + struct sockaddr_un adresse_unix; struct sockaddr_in adresse_ipv4; +# ifdef IPV6 struct sockaddr_in6 adresse_ipv6; +# endif + + struct termios tc; struct timespec attente; + struct_descripteur_fichier *descripteur; + + struct_liste_chainee *l_element_courant; + struct_liste_chainee *l_element_courant_format; + struct_liste_chainee *l_element_inclus; + struct_objet *s_objet_adresse; - struct_objet *s_objet_argument; + struct_objet *s_objet_argument_1; + struct_objet *s_objet_argument_2; 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 *ptr; unsigned char *tampon_lecture; unsigned char *tampon; + unsigned char *tampon2; + unsigned char *tampon3; - unsigned long i; + int vitesses[] = + { + 50, 75, 110, 134, 150, 200, 300, 600, + 1200, 1800, 2400, 4800, 9600, 19200, 38400, +#ifdef B57600 + 57600, +#endif +#ifdef B115200 + 115200, +#endif +#ifdef B230400 + 230400, +#endif + 0 + }; - (*s_etat_processus).erreur_execution = d_ex; + tcflag_t vitesses_constantes[] = + { + B50, B75, B110, B134, B150, B200, B300, B600, + B1200, B1800, B2400, B4800, B9600, B19200, B38400, +#ifdef B57600 + B57600, +#endif +#ifdef B115200 + B115200, +#endif +#ifdef B230400 + B230400, +#endif + 0 + }; - attente.tv_sec = 0; - attente.tv_nsec = GRANULARITE_us * 1000; + (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { @@ -891,9 +961,10 @@ instruction_read(struct_processus *s_eta printf("(read a record of a file)\n\n"); } - printf(" 1: %s, %s\n", d_FCH, d_SCK); - printf(" To be fixed !\n"); + printf(" 1: %s, %s\n\n", d_FCH, d_SCK); + printf(" 2: %s, %s\n", d_INT, d_CHN); + printf(" 1: %s\n", d_FCH); return; } else if ((*s_etat_processus).test_instruction == 'Y') @@ -904,21 +975,54 @@ instruction_read(struct_processus *s_eta if (test_cfsf(s_etat_processus, 31) == d_vrai) { - if (empilement_pile_last(s_etat_processus, 1) == d_erreur) + if ((*s_etat_processus).l_base_pile == NULL) { + (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } + + if ((*(*(*s_etat_processus).l_base_pile).donnee).type == FCH) + { + if ((*((struct_fichier *) (*(*(*s_etat_processus).l_base_pile) + .donnee).objet)).acces == 'S') + { + if (empilement_pile_last(s_etat_processus, 1) == d_erreur) + { + return; + } + } + else + { + if (empilement_pile_last(s_etat_processus, 2) == d_erreur) + { + return; + } + } + } + else + { + if (empilement_pile_last(s_etat_processus, 1) == d_erreur) + { + return; + } + } } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), - &s_objet_argument) == d_erreur) + &s_objet_argument_1) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } - if ((*s_objet_argument).type == FCH) + if ((*s_objet_argument_1).type == FCH) { + if ((descripteur = descripteur_fichier(s_etat_processus, + (struct_fichier *) (*s_objet_argument_1).objet)) == NULL) + { + return; + } + /* * Vérification des verrous */ @@ -929,15 +1033,10 @@ instruction_read(struct_processus *s_eta lock.l_len = 0; lock.l_pid = getpid(); - if ((descripteur = descripteur_fichier(s_etat_processus, - (struct_fichier *) (*s_objet_argument).objet)) == NULL) - { - return; - } - - if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1) + if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock) + == -1) { - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; @@ -945,7 +1044,7 @@ instruction_read(struct_processus *s_eta if (lock.l_type != F_UNLCK) { - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_execution = d_ex_fichier_verrouille; @@ -956,38 +1055,43 @@ instruction_read(struct_processus *s_eta * Vérification de l'autorisation de lecture */ - if ((*((struct_fichier *) (*s_objet_argument).objet)).protection == 'W') + if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection + == 'W') { - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier; return; } - else if ((*((struct_fichier *) (*s_objet_argument).objet)).protection + else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection == 'N') { - if (fflush(descripteur) != 0) + if ((*descripteur).type == 'C') { - (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; - return; + if (fflush((*descripteur).descripteur_c) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } } } - if ((*((struct_fichier *) (*s_objet_argument).objet)).binaire == 'N') + if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'N') { /* * Fichiers formatés */ - if ((*((struct_fichier *) (*s_objet_argument).objet)).acces == 'S') + if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces + == 'S') { /* * Fichiers séquentiels */ - longueur_questure = 256; + longueur_questure = 4096; - if ((tampon_lecture = malloc(longueur_questure * + if ((tampon_lecture = malloc(((size_t) longueur_questure) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = @@ -995,7 +1099,10 @@ instruction_read(struct_processus *s_eta return; } - if ((position_initiale = ftell(descripteur)) == -1) + BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n")); + + if ((position_initiale = ftell((*descripteur).descripteur_c)) + == -1) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; @@ -1003,9 +1110,9 @@ instruction_read(struct_processus *s_eta do { - longueur_effective = fread(tampon_lecture, - (size_t) sizeof(unsigned char), longueur_questure, - descripteur); + longueur_effective = (integer8) fread(tampon_lecture, + sizeof(unsigned char), (size_t) longueur_questure, + (*descripteur).descripteur_c); pointeur = 0; presence_indicateur = d_faux; @@ -1030,7 +1137,7 @@ instruction_read(struct_processus *s_eta if (presence_indicateur == d_faux) { - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); free(tampon_lecture); (*s_etat_processus).erreur_execution = @@ -1042,9 +1149,10 @@ instruction_read(struct_processus *s_eta presence_chaine = d_faux; niveau = 1; - if (fseek(descripteur, position_finale, SEEK_SET) != 0) + if (fseek((*descripteur).descripteur_c, (long) position_finale, + SEEK_SET) != 0) { - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); free(tampon_lecture); (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; @@ -1053,9 +1161,9 @@ instruction_read(struct_processus *s_eta do { - longueur_effective = fread(tampon_lecture, - (size_t) sizeof(unsigned char), longueur_questure, - descripteur); + longueur_effective = (integer8) fread(tampon_lecture, + sizeof(unsigned char), (size_t) longueur_questure, + (*descripteur).descripteur_c); pointeur = 0; presence_indicateur = d_faux; @@ -1064,8 +1172,19 @@ instruction_read(struct_processus *s_eta { if (tampon_lecture[pointeur] == '"') { - presence_chaine = (presence_chaine == d_vrai) - ? d_faux : d_vrai; + if (pointeur > 0) + { + if (tampon_lecture[pointeur - 1] != '\\') + { + presence_chaine = (presence_chaine == + d_vrai) ? d_faux : d_vrai; + } + } + else + { + presence_chaine = (presence_chaine == d_vrai) + ? d_faux : d_vrai; + } } else { @@ -1100,7 +1219,7 @@ instruction_read(struct_processus *s_eta if (presence_indicateur == d_faux) { - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); free(tampon_lecture); (*s_etat_processus).erreur_execution = @@ -1111,7 +1230,8 @@ instruction_read(struct_processus *s_eta free(tampon_lecture); longueur_enregistrement = position_finale - position_initiale; - if ((tampon_lecture = malloc((longueur_enregistrement + 1) * + if ((tampon_lecture = malloc(((size_t) + (longueur_enregistrement + 1)) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = @@ -1119,19 +1239,19 @@ instruction_read(struct_processus *s_eta return; } - if (fseek(descripteur, position_initiale, SEEK_SET) != 0) + if (fseek((*descripteur).descripteur_c, + (long) position_initiale, SEEK_SET) != 0) { - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); free(tampon_lecture); (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } - longueur_effective = fread(tampon_lecture, - (size_t) sizeof(unsigned char), - (size_t) longueur_enregistrement, - descripteur); + longueur_effective = (integer8) fread(tampon_lecture, + sizeof(unsigned char), (size_t) longueur_enregistrement, + (*descripteur).descripteur_c); if (longueur_effective != longueur_enregistrement) { @@ -1141,20 +1261,39 @@ instruction_read(struct_processus *s_eta tampon_lecture[longueur_enregistrement] = d_code_fin_chaine; tampon = (*s_etat_processus).instruction_courante; - (*s_etat_processus).instruction_courante = tampon_lecture; + + if (((*s_etat_processus).instruction_courante = + transliteration(s_etat_processus, tampon_lecture, + "UTF-8", d_locale)) == NULL) + { + (*s_etat_processus).instruction_courante = tampon; + liberation(s_etat_processus, s_objet_argument_1); + free(tampon_lecture); + return; + } indicateur_48 = test_cfsf(s_etat_processus, 48); cf(s_etat_processus, 48); + (*s_etat_processus).type_en_cours = NON; recherche_type(s_etat_processus); + free((*s_etat_processus).instruction_courante); if ((*s_etat_processus).erreur_execution != d_ex) { + if (indicateur_48 == d_vrai) + { + sf(s_etat_processus, 48); + } + else + { + cf(s_etat_processus, 48); + } + (*s_etat_processus).instruction_courante = tampon; free(tampon_lecture); - liberation(s_etat_processus, s_objet_argument); - + liberation(s_etat_processus, s_objet_argument_1); return; } @@ -1170,37 +1309,1042 @@ instruction_read(struct_processus *s_eta (*s_etat_processus).instruction_courante = tampon; free(tampon_lecture); } - else if ((*((struct_fichier *) (*s_objet_argument).objet)).acces + else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces == 'D') { + BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n")); + + if (depilement(s_etat_processus, &((*s_etat_processus) + .l_base_pile), &s_objet_argument_2) == d_erreur) + { + (*s_etat_processus).erreur_execution = d_ex_manque_argument; + return; + } + + if ((*s_objet_argument_2).type != INT) + { + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_argument; + return; + } + + if (alsprintf(s_etat_processus, &commande, + "select data from data where id = %lld", + (*((integer8 *) (*s_objet_argument_2).objet))) < 0) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, + commande, (int) strlen(commande), &ppStmt, &queue) + != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + do + { + ios = sqlite3_step(ppStmt); + + switch(ios) + { + case SQLITE_ROW: + { + // Résultat attendu + break; + } + + case SQLITE_DONE: + { + // Aucun enregistrement + if (sqlite3_finalize(ppStmt) != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + + free(commande); + + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + (*s_etat_processus).erreur_execution = + d_ex_enregistrement_inexistant; + return; + } + + case SQLITE_BUSY: + case SQLITE_LOCKED: + { + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + break; + } + + default: + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + } + } while(ios != SQLITE_ROW); + + if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + tampon = (*s_etat_processus).instruction_courante; + + if ((tampon_lecture = (unsigned char *) + sqlite3_column_text(ppStmt, 0)) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + if (((*s_etat_processus).instruction_courante = + transliteration(s_etat_processus, tampon_lecture, + "UTF-8", d_locale)) == NULL) + { + (*s_etat_processus).instruction_courante = tampon; + + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + free(commande); + return; + } + + indicateur_48 = test_cfsf(s_etat_processus, 48); + cf(s_etat_processus, 48); + + (*s_etat_processus).type_en_cours = NON; + recherche_type(s_etat_processus); + + if ((*s_etat_processus).erreur_execution != d_ex) + { + if (indicateur_48 == d_vrai) + { + sf(s_etat_processus, 48); + } + else + { + cf(s_etat_processus, 48); + } + + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + free((*s_etat_processus).instruction_courante); + free(commande); + + (*s_etat_processus).instruction_courante = tampon; + return; + } + + if (indicateur_48 == d_vrai) + { + sf(s_etat_processus, 48); + } + else + { + cf(s_etat_processus, 48); + } + + free((*s_etat_processus).instruction_courante); + liberation(s_etat_processus, s_objet_argument_2); + (*s_etat_processus).instruction_courante = tampon; + + if (sqlite3_step(ppStmt) != SQLITE_DONE) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + if (sqlite3_finalize(ppStmt) != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + free(commande); } else { + BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n")); + + if (depilement(s_etat_processus, &((*s_etat_processus) + .l_base_pile), &s_objet_argument_2) == d_erreur) + { + (*s_etat_processus).erreur_execution = d_ex_manque_argument; + return; + } + + if ((*s_objet_argument_2).type != CHN) + { + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_argument; + return; + } + + // Récupération de la position de la clef + + if (alsprintf(s_etat_processus, &commande, + "select key from control where id = 1") < 0) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, + commande, (int) strlen(commande), &ppStmt, &queue) + != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + do + { + ios = sqlite3_step(ppStmt); + + if (ios == SQLITE_ROW) + { + break; + } + else if ((ios == SQLITE_BUSY) || (ios == SQLITE_LOCKED)) + { + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + } + else + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + } while(ios != SQLITE_ROW); + + if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + position_clef = sqlite3_column_int64(ppStmt, 0); + + if (sqlite3_step(ppStmt) != SQLITE_DONE) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + if (sqlite3_finalize(ppStmt) != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + free(commande); + + if ((clef_utf8 = transliteration(s_etat_processus, + (unsigned char *) (*s_objet_argument_2).objet, + d_locale, "UTF-8")) == NULL) + { + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + return; + } + + // Récupération de l'identifiant de la clef + + if (alsprintf(s_etat_processus, &commande, + "select id from key where key = '{ \"%s\" }'", + clef_utf8) < 0) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, + commande, (int) strlen(commande), &ppStmt, &queue) + != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + do + { + ios = sqlite3_step(ppStmt); + + switch(ios) + { + case SQLITE_ROW: + { + // Résultat attendu : une clef correspond. + break; + } + + case SQLITE_DONE: + { + // Aucun enregistrement + if (sqlite3_finalize(ppStmt) != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + + free(clef_utf8); + free(commande); + + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + (*s_etat_processus).erreur_execution = + d_ex_enregistrement_inexistant; + return; + } + + case SQLITE_BUSY: + case SQLITE_LOCKED: + { + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + break; + } + + default: + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + } + } while(ios != SQLITE_ROW); + + if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER) + { + free(clef_utf8); + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + id = sqlite3_column_int64(ppStmt, 0); + + if (sqlite3_step(ppStmt) != SQLITE_DONE) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + if (sqlite3_finalize(ppStmt) != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + + free(commande); + + if (alsprintf(s_etat_processus, &commande, + "select data from data where " + "key_id = %lld order by sequence asc", id) < 0) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, + commande, (int) strlen(commande), &ppStmt, &queue) + != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + element = 1; + + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + do + { + switch(ios = sqlite3_step(ppStmt)) + { + case SQLITE_ROW: + { + // Donnée supplémentaire + + if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + + tampon = (*s_etat_processus).instruction_courante; + + if ((tampon_lecture = (unsigned char *) + sqlite3_column_text(ppStmt, 0)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + + if (((*s_etat_processus).instruction_courante = + transliteration(s_etat_processus, + tampon_lecture, + "UTF-8", d_locale)) == NULL) + { + (*s_etat_processus).instruction_courante = + tampon; + + liberation(s_etat_processus, + s_objet_argument_1); + liberation(s_etat_processus, + s_objet_argument_2); + + free(commande); + free(clef_utf8); + return; + } + + indicateur_48 = test_cfsf(s_etat_processus, 48); + cf(s_etat_processus, 48); + + (*s_etat_processus).type_en_cours = NON; + recherche_type(s_etat_processus); + + if ((*s_etat_processus).erreur_execution != d_ex) + { + if (indicateur_48 == d_vrai) + { + sf(s_etat_processus, 48); + } + else + { + cf(s_etat_processus, 48); + } + + liberation(s_etat_processus, + s_objet_argument_1); + liberation(s_etat_processus, + s_objet_argument_2); + + free((*s_etat_processus).instruction_courante); + free(commande); + free(clef_utf8); + + (*s_etat_processus).instruction_courante = + tampon; + return; + } + + if (indicateur_48 == d_vrai) + { + sf(s_etat_processus, 48); + } + else + { + cf(s_etat_processus, 48); + } + + free((*s_etat_processus).instruction_courante); + (*s_etat_processus).instruction_courante = tampon; + + element++; + + // Inscription de la clef + + if (element == position_clef) + { + if (((*s_etat_processus).instruction_courante = + transliteration(s_etat_processus, + clef_utf8, "UTF-8", d_locale)) == NULL) + { + (*s_etat_processus).instruction_courante = + tampon; + + liberation(s_etat_processus, + s_objet_argument_1); + liberation(s_etat_processus, + s_objet_argument_2); + + free(commande); + free(clef_utf8); + return; + } + + if (alsprintf(s_etat_processus, &tampon2, + "{ \"%s\" }", (*s_etat_processus) + .instruction_courante) < 0) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + free((*s_etat_processus).instruction_courante); + (*s_etat_processus).instruction_courante + = tampon2; + + indicateur_48 = test_cfsf(s_etat_processus, 48); + cf(s_etat_processus, 48); + + (*s_etat_processus).type_en_cours = NON; + recherche_type(s_etat_processus); + + if ((*s_etat_processus).erreur_execution + != d_ex) + { + if (indicateur_48 == d_vrai) + { + sf(s_etat_processus, 48); + } + else + { + cf(s_etat_processus, 48); + } + + liberation(s_etat_processus, + s_objet_argument_1); + liberation(s_etat_processus, + s_objet_argument_2); + + free((*s_etat_processus) + .instruction_courante); + free(commande); + free(clef_utf8); + + (*s_etat_processus).instruction_courante = + tampon; + return; + } + + if (indicateur_48 == d_vrai) + { + sf(s_etat_processus, 48); + } + else + { + cf(s_etat_processus, 48); + } + + free((*s_etat_processus).instruction_courante); + (*s_etat_processus).instruction_courante = + tampon; + + element++; + } + + break; + } + + case SQLITE_DONE: + { + // Fin de la liste + break; + } + + case SQLITE_BUSY: + case SQLITE_LOCKED: + { + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + break; + } + + default: + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + } + } while(ios != SQLITE_DONE); + + if (sqlite3_finalize(ppStmt) != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + free(commande); + free(clef_utf8); + + liberation(s_etat_processus, s_objet_argument_2); + + if ((s_objet_resultat = allocation(s_etat_processus, LST)) + == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + l_element_courant = NULL; + l_element_inclus = NULL; + + for(element--; element > 0; element--) + { + if (depilement(s_etat_processus, &((*s_etat_processus) + .l_base_pile), &s_objet_argument_2) == d_erreur) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + + if ((*s_objet_argument_2).type != LST) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + + l_element_inclus = (*s_objet_argument_2).objet; + + if (l_element_inclus != NULL) + { + while(l_element_inclus != NULL) + { + if ((*l_element_inclus).suivant == NULL) + { + (*l_element_inclus).suivant = l_element_courant; + break; + } + + l_element_inclus = (*l_element_inclus).suivant; + } + + l_element_courant = (*s_objet_argument_2).objet; + (*s_objet_argument_2).objet = NULL; + } + + liberation(s_etat_processus, s_objet_argument_2); + } + + (*s_objet_resultat).objet = l_element_inclus; + + if (empilement(s_etat_processus, + &((*s_etat_processus).l_base_pile), + s_objet_resultat) == d_erreur) + { + return; + } } } - else if ((*((struct_fichier *) (*s_objet_argument).objet)).binaire + else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'Y') { /* * 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 ((s_objet_resultat = lecture_fichier_non_formate( + s_etat_processus, (*descripteur).descripteur_c, -1, + d_faux)) == NULL) + { + return; + } + + if (empilement(s_etat_processus, + &((*s_etat_processus).l_base_pile), + s_objet_resultat) == d_erreur) + { + return; + } + } } 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; + + device = d_faux; + + if ((position_initiale = ftell((*descripteur).descripteur_c)) + == -1) + { + if (errno == ESPIPE) + { + device = d_vrai; + } + else + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + } + + l_element_courant_format = (struct_liste_chainee *) + (*(*((struct_fichier *) (*s_objet_argument_1).objet)) + .format).objet; + l_element_courant = NULL; + + if ((s_objet_resultat = allocation(s_etat_processus, LST)) + == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + while(l_element_courant_format != NULL) + { + 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( + s_etat_processus, (unsigned char *) + (*(*l_element_courant_format).donnee).objet)) + == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (strncmp("LENGTH*(", format_chaine, 8) != 0) + { + 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 = (integer8) strlen(format_chaine); + + if (format_chaine[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; + } + + format_chaine[longueur] = d_code_fin_chaine; + + if (format_chaine[8] == '*') + { + format_degenere = d_vrai; + } + else + { + // Détermination de la longueur + format_degenere = d_faux; + + if (sscanf(&(format_chaine[8]), "%lld", &longueur) != 1) + { + 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; + } + } + + free(format_chaine); + tampon3 = NULL; + + if (format_degenere == d_vrai) + { + if (device == d_vrai) + { + longueur_questure = 4096; + index = 0; + + if ((tampon3 = malloc(((size_t) longueur_questure) * + sizeof(unsigned char))) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + tampon3[index] = d_code_fin_chaine; + + fds[0].fd = fileno((*descripteur).descripteur_c); + fds[0].events = POLLIN; + fds[0].revents = 0; + + tcgetattr(fileno((*descripteur).descripteur_c), + &tc); + timeout = 0; + + for(i = 0; vitesses[i] != 0; i++) + { + if (cfgetispeed(&tc) == vitesses_constantes[i]) + { + // La durée entre deux caractères sur le + // périphérique série ne doit pas dépasser + // la moitié de la durée de transmission + // d'un caractère complet. + + timeout = (int) (((double) 1000) / + (((double) vitesses_constantes[i]) / + 4)); + break; + } + } + } + else + { + // Évite un warning de gcc. + longueur_questure = 0; + index = 0; + timeout = 0; + } + + do + { + if (device == d_vrai) + { + if (poll(fds, 1, timeout) == 0) + { + break; + } + } + + c = getc((*descripteur).descripteur_c); + longueur_enregistrement++; + + if (device == d_vrai) + { + if (longueur_enregistrement >= + longueur_questure) + { + if ((tampon3 = realloc(tampon3, + (size_t) (longueur_questure *= 2))) + == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + } + + tampon3[index++] = (unsigned char) c; + } + } while(c != EOF); + + if (device == d_faux) + { + if (fseek((*descripteur).descripteur_c, + (long) 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 ((device == d_vrai) && (format_degenere == d_vrai)) + { + longueur_effective = longueur_enregistrement; + tampon_lecture = tampon3; + } + else + { + if ((tampon_lecture = malloc(((size_t) + longueur_enregistrement) * + sizeof(unsigned char))) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + longueur_effective = (integer8) fread(tampon_lecture, + sizeof(unsigned char), + (size_t) longueur_enregistrement, + (*descripteur).descripteur_c); + } + + if (l_element_courant == NULL) + { + // 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 + { + 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; + } + + (*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 (device == d_faux) + { + 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; + } + } + } + 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), + 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).type == SCK) + else if ((*s_objet_argument_1).type == SCK) { /* * Vérification de l'autorisation de lecture */ - if ((*((struct_socket *) (*s_objet_argument).objet)).protection == 'W') + if ((*((struct_socket *) (*s_objet_argument_1).objet)).protection + == 'W') { - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier; return; @@ -1210,22 +2354,1175 @@ instruction_read(struct_processus *s_eta * Vérification de l'écoute de la socket si celle-ci est connectée */ - if ((strcmp((*((struct_socket *) (*s_objet_argument).objet)).type, + if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type, "STREAM") == 0) || (strcmp((*((struct_socket *) - (*s_objet_argument).objet)).type, "SEQUENTIAL DATAGRAM") == 0)) + (*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM") + == 0)) { - if ((*((struct_socket *) (*s_objet_argument).objet)) + if ((*((struct_socket *) (*s_objet_argument_1).objet)) .socket_en_ecoute == 'Y') { - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_execution = d_ex_socket_en_ecoute; return; } } - if ((*((struct_socket *) (*s_objet_argument).objet)).binaire == 'N') + if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N') { // Socket 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, + ((size_t) (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 = (int) recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, + tampon_lecture, (size_t) (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 = (int) recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, + tampon_lecture, (size_t) (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 = (int) recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, + tampon_lecture, (size_t) (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); + } + else + { + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + } + + scrutation_injection(s_etat_processus); + + 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, + (size_t) 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, + (size_t) 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, + (size_t) 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 + { + // Si on a lu toute une trame et qu'on n'a pas + // réussi à en trouver la structure, on remonte + // une erreur de syntaxe. + + if (longueur_effective == ios) + { + 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, + (size_t) 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, + (size_t) 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, + (size_t) 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 + } + + liberation(s_etat_processus, s_objet_argument_1); + free(tampon_lecture); + + (*s_etat_processus).erreur_execution = d_ex_syntaxe; + 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); + + (*s_etat_processus).type_en_cours = NON; + 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, + (size_t) 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') + { // 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, + ((size_t) (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 = (int) recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, + tampon_lecture, (size_t) + (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 = (int) recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, + tampon_lecture, (size_t) + (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 = (int) recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, + tampon_lecture, (size_t) + (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); + } + else + { + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + } + + scrutation_injection(s_etat_processus); + + 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 == (longueur_effective + longueur_questure)) + { + longueur_effective = ios; + position_initiale = 0; + presence_indicateur = d_faux; + } + else if (ios > 0) + { + // On retire une trame du buffer. + + 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, (size_t) 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, (size_t) 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, (size_t) 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; + trame_complete = d_vrai; + } + +# ifndef SEMAPHORES_NOMMES + while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) +# else + while(sem_wait((*s_etat_processus).semaphore_fork) != 0) +# endif + { + 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); + + /* + * Création de la liste de sortie + */ + + ptr = tampon_lecture; + + if ((s_objet_type = lecture_fichier_non_formate(s_etat_processus, + &ptr, longueur_effective, d_faux)) == NULL) + { + free(tampon_lecture); + + (*s_etat_processus).erreur_execution = d_ex_syntaxe; + 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, + (size_t) 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 @@ -1238,51 +3535,79 @@ instruction_read(struct_processus *s_eta return; } - if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) +# 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).objet)).domaine - == PF_UNIX) + if ((*((struct_socket *) (*s_objet_argument_1).objet)) + .domaine == PF_UNIX) { longueur_adresse = sizeof(adresse_unix); longueur_effective = recvfrom((*((struct_socket *) - (*s_objet_argument).objet)).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).objet)) + 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).objet)).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).objet)) + 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).objet)).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"); + } + + longueur_adresse = 0; + longueur_effective = 0; +# endif } else { free(tampon_lecture); - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); - while(sem_wait(&((*s_etat_processus) - .semaphore_fork)) == -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) { @@ -1300,6 +3625,7 @@ instruction_read(struct_processus *s_eta if (longueur_effective < 0) { nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); scrutation_injection(s_etat_processus); } @@ -1310,8 +3636,11 @@ instruction_read(struct_processus *s_eta } } - while(sem_wait(&((*s_etat_processus).semaphore_fork)) - == -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) { @@ -1331,135 +3660,80 @@ instruction_read(struct_processus *s_eta */ free(tampon_lecture); - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); return; } if (longueur_effective == -1) { free(tampon_lecture); - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier; return; } - position_initiale = 0; - presence_indicateur = d_faux; - - do + if (longueur_effective == longueur_questure) { - if (tampon_lecture[position_initiale] == '{') - { - presence_indicateur = d_vrai; - break; - } - - position_initiale++; - } while(position_initiale < longueur_effective); + free(tampon_lecture); + longueur_questure *= 2; + } + } while(longueur_effective == longueur_questure); + longueur_enregistrement = 1; - if (presence_indicateur == d_vrai) + for(i = 0; i < longueur_effective; i++) + { + if (isprint(tampon_lecture[i]) != 0) { - 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++; - } + longueur_enregistrement += 4; } - - if (presence_indicateur == d_faux) + else { - if (longueur_effective < longueur_questure) - { - liberation(s_etat_processus, s_objet_argument); - free(tampon_lecture); - - (*s_etat_processus).erreur_execution = - d_ex_fin_de_fichier_atteinte; - return; - } - - free(tampon_lecture); - longueur_questure *= 2; + longueur_enregistrement++; } - } while(presence_indicateur == d_faux); - - tampon_lecture[++position_finale] = d_code_fin_chaine; - tampon = (*s_etat_processus).instruction_courante; - (*s_etat_processus).instruction_courante = &(tampon_lecture - [position_initiale]); - - indicateur_48 = test_cfsf(s_etat_processus, 48); - cf(s_etat_processus, 48); + } - recherche_type(s_etat_processus); + /* + * Création de la liste de sortie + */ - if ((*s_etat_processus).erreur_execution != d_ex) + if ((s_objet_type = allocation(s_etat_processus, CHN)) == NULL) { - (*s_etat_processus).instruction_courante = tampon; - free(tampon_lecture); - - liberation(s_etat_processus, s_objet_argument); - + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } - if (indicateur_48 == d_vrai) - { - sf(s_etat_processus, 48); - } - else + if (((*s_objet_type).objet = malloc(longueur_enregistrement * + sizeof(unsigned char))) == NULL) { - cf(s_etat_processus, 48); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; } - (*s_etat_processus).instruction_courante = tampon; - - /* - * Création de la liste de sortie - */ + ptr = (*s_objet_type).objet; - if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), - &s_objet_type) == d_erreur) + for(i = 0; i < longueur_effective; i++) { - (*s_etat_processus).erreur_execution = d_ex_manque_argument; - return; + 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) { @@ -1499,30 +3773,33 @@ instruction_read(struct_processus *s_eta /* * Les informations concernant la cible sont valides si - * la socket est non connectée et des domaines INET ou INET6. + * 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).objet)).domaine + if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine == PF_UNIX) || (strcmp((*((struct_socket *) - (*s_objet_argument).objet)).type, "STREAM") == 0) || - (strcmp((*((struct_socket *) (*s_objet_argument).objet)) + (*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).objet)).socket, tampon_lecture, + (*s_objet_argument_1).objet)).socket, tampon_lecture, position_finale, MSG_DONTWAIT, NULL, &longueur_adresse); (*s_objet_adresse).objet = NULL; } - else if ((*((struct_socket *) (*s_objet_argument).objet)) + else if ((*((struct_socket *) (*s_objet_argument_1).objet)) .domaine == PF_INET) { longueur_adresse = sizeof(adresse_ipv4); recvfrom((*((struct_socket *) - (*s_objet_argument).objet)).socket, tampon_lecture, + (*s_objet_argument_1).objet)).socket, tampon_lecture, position_finale, MSG_DONTWAIT, (struct sockaddr *) &adresse_ipv4, &longueur_adresse); @@ -1590,18 +3867,19 @@ instruction_read(struct_processus *s_eta } (*((integer8 *) (*(*(*((struct_liste_chainee *) - (*s_objet_adresse) .objet)).suivant).donnee).objet)) = + (*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).objet)) + 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).objet)).socket, tampon_lecture, + (*s_objet_argument_1).objet)).socket, tampon_lecture, position_finale, MSG_DONTWAIT, (struct sockaddr *) &adresse_ipv6, &longueur_adresse); @@ -1660,17 +3938,29 @@ instruction_read(struct_processus *s_eta } (*((integer8 *) (*(*(*((struct_liste_chainee *) - (*s_objet_adresse) .objet)).suivant).donnee).objet)) = + (*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).objet)).socket, tampon_lecture, + (*s_objet_argument_1).objet)).socket, tampon_lecture, position_finale, MSG_DONTWAIT, NULL, &longueur_adresse); } @@ -1682,10 +3972,7 @@ instruction_read(struct_processus *s_eta { return; } - } - else - { - /* FLOW ou UNFORMATTED */ +#endif } } else @@ -1694,7 +3981,7 @@ instruction_read(struct_processus *s_eta return; } - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); return; }