--- rpl/src/instructions_r4.c 2012/06/22 10:12:19 1.59 +++ rpl/src/instructions_r4.c 2014/04/25 07:37:33 1.88 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.9 - Copyright (C) 1989-2012 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.18 + Copyright (C) 1989-2014 Dr. BERTRAND Joël This file is part of RPL/2. @@ -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 @@ -850,12 +850,15 @@ instruction_read(struct_processus *s_eta int c; int ios; + int timeout; - integer8 ancienne_longueur_effective; integer8 element; integer8 i; integer8 id; + integer8 index; + integer8 longueur; integer8 position_clef; + integer8 longueur_effective; integer8 longueur_enregistrement; integer8 longueur_questure; @@ -864,21 +867,20 @@ instruction_read(struct_processus *s_eta integer8 position_finale; integer8 position_initiale; + logical1 device; logical1 format_degenere; logical1 indicateur_48; logical1 presence_chaine; logical1 presence_indicateur; logical1 trame_complete; - long longueur; - socklen_t longueur_adresse; sqlite3_stmt *ppStmt; struct flock lock; - struct pollfd poll_fd; + struct pollfd fds[1]; struct sockaddr_un adresse_unix; struct sockaddr_in adresse_ipv4; @@ -886,6 +888,8 @@ instruction_read(struct_processus *s_eta struct sockaddr_in6 adresse_ipv6; # endif + struct termios tc; + struct timespec attente; struct_descripteur_fichier *descripteur; @@ -893,12 +897,10 @@ instruction_read(struct_processus *s_eta 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; @@ -906,12 +908,43 @@ instruction_read(struct_processus *s_eta 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; + unsigned char *tampon3; + + 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 + }; + + 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 + }; (*s_etat_processus).erreur_execution = d_ex; @@ -1056,9 +1089,9 @@ instruction_read(struct_processus *s_eta * 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 = @@ -1077,8 +1110,8 @@ instruction_read(struct_processus *s_eta do { - longueur_effective = fread(tampon_lecture, - (size_t) sizeof(unsigned char), longueur_questure, + longueur_effective = (integer8) fread(tampon_lecture, + sizeof(unsigned char), (size_t) longueur_questure, (*descripteur).descripteur_c); pointeur = 0; @@ -1116,7 +1149,7 @@ instruction_read(struct_processus *s_eta presence_chaine = d_faux; niveau = 1; - if (fseek((*descripteur).descripteur_c, position_finale, + if (fseek((*descripteur).descripteur_c, (long) position_finale, SEEK_SET) != 0) { liberation(s_etat_processus, s_objet_argument_1); @@ -1128,8 +1161,8 @@ instruction_read(struct_processus *s_eta do { - longueur_effective = fread(tampon_lecture, - (size_t) sizeof(unsigned char), longueur_questure, + longueur_effective = (integer8) fread(tampon_lecture, + sizeof(unsigned char), (size_t) longueur_questure, (*descripteur).descripteur_c); pointeur = 0; @@ -1197,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 = @@ -1205,8 +1239,8 @@ instruction_read(struct_processus *s_eta return; } - if (fseek((*descripteur).descripteur_c, position_initiale, - SEEK_SET) != 0) + if (fseek((*descripteur).descripteur_c, + (long) position_initiale, SEEK_SET) != 0) { liberation(s_etat_processus, s_objet_argument_1); free(tampon_lecture); @@ -1215,9 +1249,8 @@ instruction_read(struct_processus *s_eta return; } - longueur_effective = fread(tampon_lecture, - (size_t) sizeof(unsigned char), - (size_t) longueur_enregistrement, + longueur_effective = (integer8) fread(tampon_lecture, + sizeof(unsigned char), (size_t) longueur_enregistrement, (*descripteur).descripteur_c); if (longueur_effective != longueur_enregistrement) @@ -1307,48 +1340,64 @@ instruction_read(struct_processus *s_eta } if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, - commande, strlen(commande), &ppStmt, &queue) + commande, (int) strlen(commande), &ppStmt, &queue) != SQLITE_OK) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } - - switch(sqlite3_step(ppStmt)) + + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + do { - case SQLITE_ROW: - { - // Résultat attendu - break; - } + ios = sqlite3_step(ppStmt); - case SQLITE_DONE: + switch(ios) { - // Aucun enregistrement - if (sqlite3_finalize(ppStmt) != SQLITE_OK) + case SQLITE_ROW: { - (*s_etat_processus).erreur_systeme = - d_es_erreur_fichier; - return; + // Résultat attendu + break; } - free(commande); + case SQLITE_DONE: + { + // Aucun enregistrement + if (sqlite3_finalize(ppStmt) != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } - liberation(s_etat_processus, s_objet_argument_1); - liberation(s_etat_processus, s_objet_argument_2); + free(commande); - (*s_etat_processus).erreur_execution = - d_ex_enregistrement_inexistant; - return; - } + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); - default: - { - (*s_etat_processus).erreur_systeme = - d_es_erreur_fichier; - return; + (*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) { @@ -1462,18 +1511,36 @@ instruction_read(struct_processus *s_eta } if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, - commande, strlen(commande), &ppStmt, &queue) + commande, (int) strlen(commande), &ppStmt, &queue) != SQLITE_OK) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } - if (sqlite3_step(ppStmt) != SQLITE_ROW) + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + do { - (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; - return; - } + 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) { @@ -1518,49 +1585,65 @@ instruction_read(struct_processus *s_eta } if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, - commande, strlen(commande), &ppStmt, &queue) + commande, (int) strlen(commande), &ppStmt, &queue) != SQLITE_OK) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } - switch(sqlite3_step(ppStmt)) + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + do { - case SQLITE_ROW: - { - // Résultat attendu : une clef correspond. - break; - } + ios = sqlite3_step(ppStmt); - case SQLITE_DONE: + switch(ios) { - // Aucun enregistrement - if (sqlite3_finalize(ppStmt) != SQLITE_OK) + case SQLITE_ROW: { - (*s_etat_processus).erreur_systeme = - d_es_erreur_fichier; - return; + // Résultat attendu : une clef correspond. + break; } - free(clef_utf8); - free(commande); + case SQLITE_DONE: + { + // Aucun enregistrement + if (sqlite3_finalize(ppStmt) != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } - liberation(s_etat_processus, s_objet_argument_1); - liberation(s_etat_processus, s_objet_argument_2); + free(clef_utf8); + free(commande); - (*s_etat_processus).erreur_execution = - d_ex_enregistrement_inexistant; - return; - } + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); - default: - { - (*s_etat_processus).erreur_systeme = - d_es_erreur_fichier; - return; + (*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) { @@ -1595,7 +1678,7 @@ instruction_read(struct_processus *s_eta } if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, - commande, strlen(commande), &ppStmt, &queue) + commande, (int) strlen(commande), &ppStmt, &queue) != SQLITE_OK) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; @@ -1604,6 +1687,9 @@ instruction_read(struct_processus *s_eta element = 1; + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + do { switch(ios = sqlite3_step(ppStmt)) @@ -1782,6 +1868,14 @@ instruction_read(struct_processus *s_eta break; } + case SQLITE_BUSY: + case SQLITE_LOCKED: + { + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + break; + } + default: { (*s_etat_processus).erreur_systeme = @@ -1789,7 +1883,6 @@ instruction_read(struct_processus *s_eta return; } } - } while(ios != SQLITE_DONE); if (sqlite3_finalize(ppStmt) != SQLITE_OK) @@ -1890,152 +1983,19 @@ instruction_read(struct_processus *s_eta BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n")); - if (fread(&type_enregistrement, (size_t) sizeof(unsigned char), - 1, (*descripteur).descripteur_c) != 1) + if ((s_objet_resultat = lecture_fichier_non_formate( + s_etat_processus, (*descripteur).descripteur_c, -1, + d_faux)) == NULL) { - (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } - if ((type_enregistrement & 0xF0) != 0x40) - { - // L'enregistrement trouvé n'est pas une liste. - // Tout porte à croire que le fichier est corrompu. - (*s_etat_processus).erreur_execution = - d_ex_fichier_corrompu; - return; - } - - switch(type_enregistrement) - { - unsigned char taille_enregistrement[8]; - - case 0x48: - { - if (fread(taille_enregistrement, - (size_t) sizeof(unsigned char), - 1, (*descripteur).descripteur_c) != 1) - { - (*s_etat_processus).erreur_systeme = - d_es_erreur_fichier; - return; - } - - longueur_enregistrement = taille_enregistrement[0]; - break; - } - - case 0x49: - { - if (fread(taille_enregistrement, - (size_t) sizeof(unsigned char), - 2, (*descripteur).descripteur_c) != 2) - { - (*s_etat_processus).erreur_systeme = - d_es_erreur_fichier; - return; - } - -// A FAIRE conversion de taille_enregistrement en longueur_enregistrement - break; - } - - case 0x4A: - { - if (fread(taille_enregistrement, - (size_t) sizeof(unsigned char), - 4, (*descripteur).descripteur_c) != 4) - { - (*s_etat_processus).erreur_systeme = - d_es_erreur_fichier; - return; - } - -// A FAIRE conversion de taille_enregistrement en longueur_enregistrement - break; - } - - case 0x4B: - { - if (fread(taille_enregistrement, - (size_t) sizeof(unsigned char), - 8, (*descripteur).descripteur_c) != 8) - { - (*s_etat_processus).erreur_systeme = - d_es_erreur_fichier; - return; - } - -// A FAIRE conversion de taille_enregistrement en longueur_enregistrement - break; - } - - default: - { - longueur_enregistrement = type_enregistrement & 0x07; - } - } - -printf("L=%d\n", longueur_enregistrement); - // La variable longueur_enregistrement contient le nombre - // d'éléments à lire dans le fichier pour générer la liste - // contenant l'enregistrement. - - if ((s_objet_resultat = allocation(s_etat_processus, LST)) - == NULL) + if (empilement(s_etat_processus, + &((*s_etat_processus).l_base_pile), + s_objet_resultat) == d_erreur) { - (*s_etat_processus).erreur_systeme = - d_es_allocation_memoire; return; } - - for(i = 0; i < longueur_enregistrement; i++) - { - /* A FAIRE - s_objet_element = decodage_enregistrement(s_etat_processus, - (*descripteur).descripteur_c); - */ - s_objet_element = NULL; - - if (s_objet_element == NULL) - { - liberation(s_etat_processus, s_objet_resultat); - return; - } - - if ((*s_objet_resultat).objet == NULL) - { - if (((*s_objet_resultat).objet = allocation_maillon( - s_etat_processus)) == NULL) - { - (*s_etat_processus).erreur_systeme = - d_es_allocation_memoire; - return; - } - - (*((struct_liste_chainee *) (*s_objet_resultat).objet)) - .donnee = s_objet_element; - l_element_courant = (*s_objet_resultat).objet; - } - else - { - if ((l_element_suivant = allocation_maillon( - s_etat_processus)) == NULL) - { - (*s_etat_processus).erreur_systeme = - d_es_allocation_memoire; - return; - } - - (*l_element_courant).suivant = l_element_suivant; - (*l_element_suivant).donnee = s_objet_element; - l_element_courant = l_element_suivant; - } - } - - // On saute les caractère des gestion de la commande - // BACKSPACE. - // A FAIRE } } else @@ -2054,11 +2014,21 @@ printf("L=%d\n", longueur_enregistrement BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n")); longueur_enregistrement = 0; + device = d_faux; + if ((position_initiale = ftell((*descripteur).descripteur_c)) == -1) { - (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; - return; + if (errno == ESPIPE) + { + device = d_vrai; + } + else + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } } l_element_courant_format = (struct_liste_chainee *) @@ -2106,9 +2076,9 @@ printf("L=%d\n", longueur_enregistrement return; } - longueur = strlen(format_chaine); + longueur = (integer8) strlen(format_chaine); - if (format_chaine[longueur] != ')') + if (format_chaine[longueur - 1] != ')') { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_resultat); @@ -2130,7 +2100,7 @@ printf("L=%d\n", longueur_enregistrement // Détermination de la longueur format_degenere = d_faux; - if (sscanf(&(format_chaine[8]), "%ld", &longueur) != 1) + if (sscanf(&(format_chaine[8]), "%lld", &longueur) != 1) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_resultat); @@ -2143,24 +2113,95 @@ printf("L=%d\n", longueur_enregistrement } 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; + } + } + } + do { + if (device == d_vrai) + { + if (poll(fds, 1, timeout) == 0) + { + break; + } + } + c = getc((*descripteur).descripteur_c); longueur_enregistrement++; - } while((c != '\n') && (c != EOF)); - if (fseek((*descripteur).descripteur_c, - position_initiale, SEEK_SET) != 0) + 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) { - liberation(s_etat_processus, s_objet_argument_1); - liberation(s_etat_processus, s_objet_resultat); + 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; + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } } } else @@ -2168,18 +2209,27 @@ printf("L=%d\n", longueur_enregistrement longueur_enregistrement = longueur; } - if ((tampon_lecture = malloc((longueur_enregistrement) - * sizeof(unsigned char))) == NULL) + if ((device == d_vrai) && (format_degenere == d_vrai)) { - (*s_etat_processus).erreur_systeme = - d_es_allocation_memoire; - return; + 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 = fread(tampon_lecture, - (size_t) sizeof(unsigned char), - (size_t) longueur_enregistrement, - (*descripteur).descripteur_c); + longueur_effective = (integer8) fread(tampon_lecture, + sizeof(unsigned char), + (size_t) longueur_enregistrement, + (*descripteur).descripteur_c); + } if (l_element_courant == NULL) { @@ -2219,11 +2269,23 @@ printf("L=%d\n", longueur_enregistrement if (format_degenere == d_vrai) { - if (((*(*l_element_courant).donnee).objet = - analyse_flux(s_etat_processus, tampon_lecture, - longueur_enregistrement - 1)) == NULL) + if (device == d_faux) { - return; + 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 @@ -2295,7 +2357,7 @@ printf("L=%d\n", longueur_enregistrement if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N') { // Socket formatée - longueur_questure = 256; + longueur_questure = 4096; longueur_effective = 0; tampon_lecture = NULL; @@ -2311,7 +2373,7 @@ printf("L=%d\n", longueur_enregistrement presence_indicateur = d_faux; if ((tampon_lecture = realloc(tampon_lecture, - (longueur_effective + longueur_questure + 1) + ((size_t) (longueur_effective + longueur_questure + 1)) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = @@ -2336,10 +2398,10 @@ printf("L=%d\n", longueur_enregistrement do { - ios = recvfrom((*((struct_socket *) + ios = (int) recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, - tampon_lecture + longueur_effective, - longueur_questure, + tampon_lecture, (size_t) (longueur_effective + + longueur_questure), MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) &adresse_unix, &longueur_adresse); } while((ios == -1) && (errno == EINTR)); @@ -2351,10 +2413,10 @@ printf("L=%d\n", longueur_enregistrement do { - ios = recvfrom((*((struct_socket *) + ios = (int) recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, - tampon_lecture + longueur_effective, - longueur_questure, + tampon_lecture, (size_t) (longueur_effective + + longueur_questure), MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) &adresse_ipv4, &longueur_adresse); } while((ios == -1) && (errno == EINTR)); @@ -2367,10 +2429,10 @@ printf("L=%d\n", longueur_enregistrement do { - ios = recvfrom((*((struct_socket *) + ios = (int) recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, - tampon_lecture + longueur_effective, - longueur_questure, + tampon_lecture, (size_t) (longueur_effective + + longueur_questure), MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) &adresse_ipv6, &longueur_adresse); } while((ios == -1) && (errno == EINTR)); @@ -2413,11 +2475,10 @@ printf("L=%d\n", longueur_enregistrement return; } - if (ios < 0) + if (ios <= 0) { nanosleep(&attente, NULL); INCR_GRANULARITE(attente.tv_nsec); - scrutation_injection(s_etat_processus); } else { @@ -2425,9 +2486,15 @@ printf("L=%d\n", longueur_enregistrement attente.tv_nsec = GRANULARITE_us * 1000; } + scrutation_injection(s_etat_processus); + if ((*s_etat_processus).var_volatile_requete_arret == -1) { - longueur_effective += ios; + if (ios >= 0) + { + longueur_effective = ios; + } + break; } @@ -2435,8 +2502,7 @@ printf("L=%d\n", longueur_enregistrement if (ios >= 0) { - ancienne_longueur_effective = longueur_effective; - longueur_effective += ios; + longueur_effective = ios; position_initiale = 0; presence_indicateur = d_faux; @@ -2506,102 +2572,139 @@ printf("L=%d\n", longueur_enregistrement } } - // On retire du buffer position_finale - - // ancienne_longueur_effective octets. + // On retire une trame du buffer. - if ((*((struct_socket *) (*s_objet_argument_1).objet)) - .domaine == PF_UNIX) + if (trame_complete == d_vrai) { - longueur_adresse = sizeof(adresse_unix); - - do + if ((*((struct_socket *) (*s_objet_argument_1).objet)) + .domaine == PF_UNIX) { - 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) - { - longueur_adresse = sizeof(adresse_ipv4); - - 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) - { -# ifdef IPV6 - longueur_adresse = sizeof(adresse_ipv6); - - 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); + 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)); } - while((ios == -1) && (errno == EINTR)); -# else - if ((*s_etat_processus).langue == 'F') + else if ((*((struct_socket *) (*s_objet_argument_1) + .objet)).domaine == PF_INET) { - printf("+++Attention : Support du protocole" - " IPv6 indisponible\n"); + 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 + else if ((*((struct_socket *) (*s_objet_argument_1) + .objet)) .domaine == PF_INET6) { - printf("+++Warning : IPv6 support " - "unavailable\n"); +# 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_adresse = 0; -# endif + longueur_effective = ios; } - - if (presence_indicateur == d_faux) + else { - poll_fd.fd = (*((struct_socket *) - (*s_objet_argument_1).objet)).socket; - poll_fd.events = POLLIN; + // 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. - while((ios = poll(&poll_fd, 1, 100)) <= 0) + if (longueur_effective == ios) { - // La fin de la trame n'est pas atteinte - // et il reste quelque chose à lire. - - switch(ios) + if ((*((struct_socket *) (*s_objet_argument_1) + .objet)).domaine == PF_UNIX) { - case EINTR: + do { - break; + 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"); } - - case 0: + else { - liberation(s_etat_processus, - s_objet_argument_1); - free(tampon_lecture); - - (*s_etat_processus).erreur_execution = - d_ex_fin_de_fichier_atteinte; - return; + 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; } } } @@ -2647,8 +2750,7 @@ printf("L=%d\n", longueur_enregistrement tampon_lecture[++position_finale] = d_code_fin_chaine; tampon = (*s_etat_processus).instruction_courante; - (*s_etat_processus).instruction_courante = &(tampon_lecture - [position_initiale]); + (*s_etat_processus).instruction_courante = tampon_lecture; indicateur_48 = test_cfsf(s_etat_processus, 48); cf(s_etat_processus, 48); @@ -2906,7 +3008,7 @@ printf("L=%d\n", longueur_enregistrement longueur_adresse = 0; recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, tampon_lecture, - position_finale, MSG_DONTWAIT, + (size_t) position_finale, MSG_DONTWAIT, NULL, &longueur_adresse); } @@ -2920,10 +3022,492 @@ printf("L=%d\n", longueur_enregistrement } else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'Y') - { // UNFORMATTED + { // socket non formatée + longueur_questure = 4096; + longueur_effective = 0; + tampon_lecture = NULL; + + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + trame_complete = d_faux; + position_initiale = 0; + position_finale = 0; + + do + { + presence_indicateur = d_faux; + + if ((tampon_lecture = realloc(tampon_lecture, + ((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 @@ -3373,6 +3957,7 @@ printf("L=%d\n", longueur_enregistrement { return; } +#endif } } else