--- rpl/src/instructions_r4.c 2010/03/04 10:17:52 1.4 +++ rpl/src/instructions_r4.c 2011/04/20 08:26:04 1.30 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.0.12 - Copyright (C) 1989-2010 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.0.prerelease.0 + Copyright (C) 1989-2011 Dr. BERTRAND Joël This file is part of RPL/2. @@ -20,7 +20,7 @@ */ -#include "rpl.conv.h" +#include "rpl-conv.h" /* @@ -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,12 +846,20 @@ instruction_rewind(struct_processus *s_e void instruction_read(struct_processus *s_etat_processus) { - file *descripteur; + const char *queue; + + int c; + int ios; + + integer8 element; + integer8 id; + integer8 position_clef; logical1 indicateur_48; logical1 presence_chaine; logical1 presence_indicateur; + long i; long longueur_effective; long longueur_enregistrement; long longueur_questure; @@ -854,30 +870,39 @@ instruction_read(struct_processus *s_eta socklen_t longueur_adresse; + sqlite3_stmt *ppStmt; + struct flock lock; struct sockaddr_un adresse_unix; struct sockaddr_in adresse_ipv4; +# ifdef IPV6 struct sockaddr_in6 adresse_ipv6; +# endif struct timespec attente; + struct_descripteur_fichier *descripteur; + + struct_liste_chainee *l_element_courant; + 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 *ptr; unsigned char *tampon_lecture; unsigned char *tampon; - - unsigned long i; + unsigned char *tampon2; (*s_etat_processus).erreur_execution = d_ex; - attente.tv_sec = 0; - attente.tv_nsec = GRANULARITE_us * 1000; - if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n READ "); @@ -891,9 +916,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 +930,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 +988,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 +999,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,30 +1010,35 @@ 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 @@ -995,7 +1054,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; @@ -1005,7 +1067,7 @@ instruction_read(struct_processus *s_eta { longueur_effective = fread(tampon_lecture, (size_t) sizeof(unsigned char), longueur_questure, - descripteur); + (*descripteur).descripteur_c); pointeur = 0; presence_indicateur = d_faux; @@ -1030,7 +1092,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 +1104,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, 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; @@ -1055,7 +1118,7 @@ instruction_read(struct_processus *s_eta { longueur_effective = fread(tampon_lecture, (size_t) sizeof(unsigned char), longueur_questure, - descripteur); + (*descripteur).descripteur_c); pointeur = 0; presence_indicateur = d_faux; @@ -1064,8 +1127,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 +1174,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 = @@ -1119,9 +1193,10 @@ instruction_read(struct_processus *s_eta return; } - if (fseek(descripteur, position_initiale, SEEK_SET) != 0) + if (fseek((*descripteur).descripteur_c, 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; @@ -1131,7 +1206,7 @@ instruction_read(struct_processus *s_eta longueur_effective = fread(tampon_lecture, (size_t) sizeof(unsigned char), (size_t) longueur_enregistrement, - descripteur); + (*descripteur).descripteur_c); if (longueur_effective != longueur_enregistrement) { @@ -1141,20 +1216,38 @@ 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); 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,15 +1263,595 @@ 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(&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, strlen(commande), &ppStmt, &queue) + != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + switch(sqlite3_step(ppStmt)) + { + 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; + } + + default: + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + } + + 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); + + 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(&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, strlen(commande), &ppStmt, &queue) + != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + if (sqlite3_step(ppStmt) != SQLITE_ROW) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + 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(&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, strlen(commande), &ppStmt, &queue) + != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + switch(sqlite3_step(ppStmt)) + { + 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; + } + + default: + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + } + + 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(&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, strlen(commande), &ppStmt, &queue) + != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + element = 1; + + 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); + + 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(&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); + + 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; + } + + 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') { /* @@ -1190,17 +1863,153 @@ instruction_read(struct_processus *s_eta /* * Fichiers de type FLOW */ + + if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces + == 'S') + { + /* + * Fichiers séquentiels + */ + + BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n")); + longueur_enregistrement = 0; + + if ((position_initiale = ftell((*descripteur).descripteur_c)) + == -1) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + do + { + c = getc((*descripteur).descripteur_c); + longueur_enregistrement++; + } while((c != '\n') && (c != EOF)); + + if (fseek((*descripteur).descripteur_c, position_initiale, + SEEK_SET) != 0) + { + liberation(s_etat_processus, s_objet_argument_1); + + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + if ((tampon_lecture = malloc((longueur_enregistrement + 1) + * sizeof(unsigned char))) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + longueur_effective = fread(tampon_lecture, + (size_t) sizeof(unsigned char), + (size_t) longueur_enregistrement, + (*descripteur).descripteur_c); + + if ((s_objet_resultat = allocation(s_etat_processus, LST)) + == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (((*s_objet_resultat).objet = + allocation_maillon(s_etat_processus)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + (*((struct_liste_chainee *) (*s_objet_resultat).objet)) + .suivant = NULL; + + if (((*((struct_liste_chainee *) (*s_objet_resultat).objet)) + .donnee = allocation(s_etat_processus, CHN)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + longueur_enregistrement = 1; + + for(i = 0; i < longueur_effective; i++) + { + if (isprint(tampon_lecture[i]) != 0) + { + longueur_enregistrement += 4; + } + else + { + longueur_enregistrement++; + } + } + + if ((tampon = malloc(longueur_enregistrement * + sizeof(unsigned char))) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + ptr = tampon; + + for(i = 0; i < longueur_effective; i++) + { + if (isprint(tampon_lecture[i]) != 0) + { + (*ptr) = tampon_lecture[i]; + ptr++; + } + else + { + (*ptr) = '\\'; + ptr++; + (*ptr) = 'x'; + ptr++; + sprintf(ptr, "%02X", tampon_lecture[i]); + ptr += 2; + } + } + + (*ptr) = d_code_fin_chaine; + free(tampon_lecture); + ((*(*((struct_liste_chainee *) (*s_objet_resultat).objet)) + .donnee)).objet = tampon; + + if (empilement(s_etat_processus, + &((*s_etat_processus).l_base_pile), + s_objet_resultat) == d_erreur) + { + return; + } + } + else + { + liberation(s_etat_processus, s_objet_argument_1); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_fichier; + return; + } } } - else if ((*s_objet_argument).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,21 +2019,22 @@ 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 = 256; @@ -1238,51 +2048,81 @@ instruction_read(struct_processus *s_eta return; } +# ifndef SEMAPHORES_NOMMES if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } +# else + if (sem_post((*s_etat_processus).semaphore_fork) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } +# endif + + 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"); + } +# endif } else { free(tampon_lecture); - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); +# ifndef SEMAPHORES_NOMMES while(sem_wait(&((*s_etat_processus) .semaphore_fork)) == -1) +# else + while(sem_wait((*s_etat_processus) + .semaphore_fork) == -1) +# endif { if (errno != EINTR) { @@ -1300,9 +2140,12 @@ instruction_read(struct_processus *s_eta if (longueur_effective < 0) { nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); scrutation_injection(s_etat_processus); } + // Une donnée a été reçue. + if (((*s_etat_processus).var_volatile_requete_arret == -1) || (longueur_effective >= 0)) { @@ -1310,8 +2153,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)) == -1) +# else + while(sem_wait((*s_etat_processus).semaphore_fork) == -1) +# endif { if (errno != EINTR) { @@ -1331,14 +2177,14 @@ 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; @@ -1405,7 +2251,7 @@ instruction_read(struct_processus *s_eta { if (longueur_effective < longueur_questure) { - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); free(tampon_lecture); (*s_etat_processus).erreur_execution = @@ -1433,8 +2279,7 @@ instruction_read(struct_processus *s_eta (*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; } @@ -1503,26 +2348,483 @@ instruction_read(struct_processus *s_eta * 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_1).objet)).type, "STREAM") == 0) || + (strcmp((*((struct_socket *) (*s_objet_argument_1).objet)) + .type, "SEQUENTIAL DATAGRAM") == 0)) + { + longueur_adresse = 0; + recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, tampon_lecture, + longueur_effective, MSG_DONTWAIT, + NULL, &longueur_adresse); + + (*s_objet_adresse).objet = NULL; + } + else if ((*((struct_socket *) (*s_objet_argument_1).objet)) + .domaine == PF_INET) + { + longueur_adresse = sizeof(adresse_ipv4); + recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, tampon_lecture, + longueur_effective, MSG_DONTWAIT, + (struct sockaddr *) &adresse_ipv4, &longueur_adresse); + + if (((*s_objet_adresse).objet = + allocation_maillon(s_etat_processus)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) + .donnee = allocation(s_etat_processus, VIN)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + (*((struct_vecteur *) (*(*((struct_liste_chainee *) + (*s_objet_adresse).objet)).donnee).objet)).taille = 4; + + if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) + (*s_objet_adresse).objet)).donnee).objet)).tableau = + malloc(4 * sizeof(integer8))) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + ((integer8 *) (*((struct_vecteur *) + (*(*((struct_liste_chainee *) (*s_objet_adresse) + .objet)).donnee).objet)).tableau)[0] = + (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF; + ((integer8 *) (*((struct_vecteur *) + (*(*((struct_liste_chainee *) (*s_objet_adresse) + .objet)).donnee).objet)).tableau)[1] = + (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF; + ((integer8 *) (*((struct_vecteur *) + (*(*((struct_liste_chainee *) (*s_objet_adresse) + .objet)).donnee).objet)).tableau)[2] = + (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF; + ((integer8 *) (*((struct_vecteur *) + (*(*((struct_liste_chainee *) (*s_objet_adresse) + .objet)).donnee).objet)).tableau)[3] = + ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF; + + if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) + .suivant = allocation_maillon(s_etat_processus)) + == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) + .suivant).donnee = allocation(s_etat_processus, INT)) + == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + (*((integer8 *) (*(*(*((struct_liste_chainee *) + (*s_objet_adresse).objet)).suivant).donnee).objet)) = + (integer8) ntohs(adresse_ipv4.sin_port); + + (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) + .suivant).suivant = NULL; + } + else if ((*((struct_socket *) (*s_objet_argument_1).objet)) + .domaine == PF_INET6) + { +# ifdef IPV6 + longueur_adresse = sizeof(adresse_ipv6); + recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, tampon_lecture, + longueur_effective, MSG_DONTWAIT, + (struct sockaddr *) &adresse_ipv6, &longueur_adresse); + + if (((*s_objet_adresse).objet = + allocation_maillon(s_etat_processus)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) + .donnee = allocation(s_etat_processus, VIN)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + (*((struct_vecteur *) (*(*((struct_liste_chainee *) + (*s_objet_adresse).objet)).donnee).objet)).taille = 16; + + if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) + (*s_objet_adresse).objet)).donnee).objet)).tableau = + malloc(16 * sizeof(integer8))) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + for(i = 0; i < 16; i++) + { + ((integer8 *) (*((struct_vecteur *) + (*(*((struct_liste_chainee *) (*s_objet_adresse) + .objet)).donnee).objet)).tableau)[0] = + adresse_ipv6.sin6_addr.s6_addr[i]; + } + + if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) + .suivant = allocation_maillon(s_etat_processus)) + == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) + .suivant).donnee = allocation(s_etat_processus, INT)) + == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + (*((integer8 *) (*(*(*((struct_liste_chainee *) + (*s_objet_adresse).objet)).suivant).donnee).objet)) = + (integer8) ntohs(adresse_ipv6.sin6_port); + + (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) + .suivant).suivant = NULL; +# else + if ((*s_etat_processus).langue == 'F') + { + printf("+++Attention : Support du protocole" + " IPv6 indisponible\n"); + } + else + { + printf("+++Warning : IPv6 support " + "unavailable\n"); + } +# endif + } + else + { + longueur_adresse = 0; + recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, tampon_lecture, + position_finale, MSG_DONTWAIT, + NULL, &longueur_adresse); + } + + free(tampon_lecture); + + if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), + s_objet_resultat) == d_erreur) + { + return; + } + } + else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire + == 'Y') + { // UNFORMATTED + } + else + { // FLOW + longueur_questure = 256; + + do + { + if ((tampon_lecture = malloc((longueur_questure + 1) * + sizeof(unsigned char))) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + +# ifndef SEMAPHORES_NOMMES + if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } +# else + if (sem_post((*s_etat_processus).semaphore_fork) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } +# endif + + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + for(;;) + { + if ((*((struct_socket *) (*s_objet_argument_1).objet)) + .domaine == PF_UNIX) + { + longueur_adresse = sizeof(adresse_unix); + longueur_effective = recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, + tampon_lecture, longueur_questure, + MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) + &adresse_unix, &longueur_adresse); + } + else if ((*((struct_socket *) (*s_objet_argument_1).objet)) + .domaine == PF_INET) + { + longueur_adresse = sizeof(adresse_ipv4); + longueur_effective = recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, + tampon_lecture, longueur_questure, + MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) + &adresse_ipv4, &longueur_adresse); + } + else if ((*((struct_socket *) (*s_objet_argument_1).objet)) + .domaine == PF_INET6) + { +# ifdef IPV6 + longueur_adresse = sizeof(adresse_ipv6); + longueur_effective = recvfrom((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, + tampon_lecture, longueur_questure, + MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) + &adresse_ipv6, &longueur_adresse); +# else + if ((*s_etat_processus).langue == 'F') + { + printf("+++Attention : Support du protocole" + " IPv6 indisponible\n"); + } + else + { + printf("+++Warning : IPv6 support " + "unavailable\n"); + } +# endif + } + else + { + free(tampon_lecture); + liberation(s_etat_processus, s_objet_argument_1); + +# ifndef SEMAPHORES_NOMMES + while(sem_wait(&((*s_etat_processus) + .semaphore_fork)) == -1) +# else + while(sem_wait((*s_etat_processus) + .semaphore_fork) == -1) +# endif + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = + d_es_processus; + return; + } + } + + (*s_etat_processus).erreur_execution = + d_ex_erreur_acces_fichier; + return; + } + + if (longueur_effective < 0) + { + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + scrutation_injection(s_etat_processus); + } + + if (((*s_etat_processus).var_volatile_requete_arret == -1) + || (longueur_effective >= 0)) + { + break; + } + } + +# ifndef SEMAPHORES_NOMMES + while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) +# else + while(sem_wait((*s_etat_processus).semaphore_fork) == -1) +# endif + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } + + if ((*s_etat_processus).var_volatile_requete_arret == -1) + { + + /* + * Si le père tue le processus courant grâce au signal + * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement + * correspond à l'utilisation de STOP sur le processus + * en cours. La variable longueur_effective vaut '-1'. + */ + + free(tampon_lecture); + liberation(s_etat_processus, s_objet_argument_1); + return; + } + + if (longueur_effective == -1) + { + free(tampon_lecture); + liberation(s_etat_processus, s_objet_argument_1); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_acces_fichier; + return; + } + + if (longueur_effective == longueur_questure) + { + free(tampon_lecture); + longueur_questure *= 2; + } + } while(longueur_effective == longueur_questure); + + longueur_enregistrement = 1; + + for(i = 0; i < longueur_effective; i++) + { + if (isprint(tampon_lecture[i]) != 0) + { + longueur_enregistrement += 4; + } + else + { + longueur_enregistrement++; + } + } + + /* + * Création de la liste de sortie + */ + + if ((s_objet_type = allocation(s_etat_processus, CHN)) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + if (((*s_objet_type).objet = malloc(longueur_enregistrement * + sizeof(unsigned char))) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + ptr = (*s_objet_type).objet; + + for(i = 0; i < longueur_effective; i++) + { + if (isprint(tampon_lecture[i]) != 0) + { + (*ptr) = tampon_lecture[i]; + ptr++; + } + else + { + (*ptr) = '\\'; + ptr++; + (*ptr) = 'x'; + ptr++; + sprintf(ptr, "%02X", tampon_lecture[i]); + ptr += 2; + } + } + + (*ptr) = d_code_fin_chaine; + + if ((s_objet_resultat = allocation(s_etat_processus, LST)) + == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + if (((*s_objet_resultat).objet = + allocation_maillon(s_etat_processus)) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + (*((struct_liste_chainee *) (*s_objet_resultat).objet)) + .donnee = s_objet_type; + + if (((*((struct_liste_chainee *) (*s_objet_resultat).objet)) + .suivant = allocation_maillon(s_etat_processus)) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) + .suivant = NULL; + + if ((s_objet_adresse = allocation(s_etat_processus, LST)) + == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) + .donnee = s_objet_adresse; + + /* + * Les informations concernant la cible sont valides si + * la socket est non connectée et que les domaines sont + * INET ou INET6. + * Dans tous les autres cas, on renvoie une liste vide. + */ + + if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine == PF_UNIX) || (strcmp((*((struct_socket *) - (*s_objet_argument).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 +2892,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 +2963,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); } @@ -1683,10 +2998,6 @@ instruction_read(struct_processus *s_eta return; } } - else - { - /* FLOW ou UNFORMATTED */ - } } else { @@ -1694,7 +3005,7 @@ instruction_read(struct_processus *s_eta return; } - liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_argument_1); return; }