--- rpl/src/instructions_w1.c 2010/03/06 18:29:07 1.5 +++ rpl/src/instructions_w1.c 2019/02/09 13:36:41 1.115 @@ -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.31 + Copyright (C) 1989-2019 Dr. BERTRAND Joël This file is part of RPL/2. @@ -20,7 +20,7 @@ */ -#include "rpl.conv.h" +#include "rpl-conv.h" /* @@ -124,7 +124,7 @@ instruction_while(struct_processus *s_et void instruction_warranty(struct_processus *s_etat_processus) { -# include "garanties.conv.h" +# include "garanties-conv.h" (*s_etat_processus).erreur_execution = d_ex; @@ -226,8 +226,7 @@ instruction_wait(struct_processus *s_eta return; } - if (((*s_objet).type == INT) || - ((*s_objet).type == REL)) + if (((*s_objet).type == INT) || ((*s_objet).type == REL)) { if ((*s_objet).type == INT) { @@ -246,9 +245,9 @@ instruction_wait(struct_processus *s_eta return; } - temporisation.tv_sec = (long) floor((double) attente); - temporisation.tv_nsec = (attente - temporisation.tv_sec) * - (long) 1000000000; + temporisation.tv_sec = (time_t) floor((double) attente); + temporisation.tv_nsec = (long) ((attente - + ((real8) temporisation.tv_sec)) * (integer8) 1000000000); if ((*s_etat_processus).profilage == d_vrai) { @@ -262,7 +261,11 @@ instruction_wait(struct_processus *s_eta do { - 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; @@ -271,7 +274,11 @@ instruction_wait(struct_processus *s_eta code_retour = nanosleep(&temporisation, &temporisation); erreur = errno; - 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) { @@ -282,11 +289,25 @@ instruction_wait(struct_processus *s_eta scrutation_injection(s_etat_processus); + if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions) + != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + if ((*s_etat_processus).nombre_interruptions_non_affectees != 0) { affectation_interruptions_logicielles(s_etat_processus); } + if (pthread_mutex_unlock(&(*s_etat_processus).mutex_interruptions) + != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + if ((*s_etat_processus).nombre_interruptions_en_queue != 0) { traitement_interruptions_logicielles(s_etat_processus); @@ -374,32 +395,59 @@ instruction_wireframe(struct_processus * void instruction_write(struct_processus *s_etat_processus) { + const char *queue; + int adresse[16]; int port; + int sqlite_status; + + integer8 clef; + integer8 compteur; + integer8 id; + integer8 longueur; + integer8 longueur_effective; + integer8 ordre; + integer8 recursivite; + + logical1 format_degenere; + logical1 format_oriente_ligne; + logical1 mise_a_jour; - long longueur_effective; - long recursivite; + sqlite3_stmt *ppStmt; ssize_t ios; struct_descripteur_fichier *descripteur; - struct_objet *s_objet_argument_2; + struct_liste_chainee *l_element_courant; + struct_liste_chainee *l_element_courant_format; + + struct_objet *s_format; + struct_objet *s_element; struct_objet *s_objet_argument_1; + struct_objet *s_objet_argument_2; + struct_objet *s_objet_argument_3; struct sigaction action; struct sigaction registre; struct sockaddr_in adresse_ipv4; +# ifdef IPV6 struct sockaddr_in6 adresse_ipv6; +# endif struct sockaddr_un adresse_unix; struct flock lock; + struct timespec attente; + uint32_t calcul_adresse; unsigned char *chaine; unsigned char *chaine_utf8; + unsigned char *clef_utf8; + unsigned char *commande; + unsigned char *format_chaine; unsigned long i; @@ -419,8 +467,11 @@ instruction_write(struct_processus *s_et } printf(" 2: %s\n", d_LST); - printf(" 1: %s, %s\n", d_FCH, d_SCK); + printf(" 1: %s, %s\n\n", d_FCH, d_SCK); + printf(" 3: %s\n", d_LST); + printf(" 2: %s\n", d_INT); + printf(" 1: %s\n", d_FCH); return; } else if ((*s_etat_processus).test_instruction == 'Y') @@ -431,10 +482,37 @@ instruction_write(struct_processus *s_et if (test_cfsf(s_etat_processus, 31) == d_vrai) { - if (empilement_pile_last(s_etat_processus, 2) == 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 == 'D') + { + if (empilement_pile_last(s_etat_processus, 3) == d_erreur) + { + return; + } + } + else + { + if (empilement_pile_last(s_etat_processus, 2) == d_erreur) + { + return; + } + } + } + else + { + if (empilement_pile_last(s_etat_processus, 2) == d_erreur) + { + return; + } + } } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), @@ -453,8 +531,7 @@ instruction_write(struct_processus *s_et return; } - if (((*s_objet_argument_2).type == LST) && - ((*s_objet_argument_1).type == FCH)) + if ((*s_objet_argument_1).type == FCH) { if ((descripteur = descripteur_fichier(s_etat_processus, (struct_fichier *) (*s_objet_argument_1).objet)) == NULL) @@ -513,20 +590,30 @@ instruction_write(struct_processus *s_et * Fichiers formatés */ - if ((chaine = formateur_fichier(s_etat_processus, - s_objet_argument_2, (*((struct_fichier *) - (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F', - &longueur_effective, &recursivite)) == NULL) - { - liberation(s_etat_processus, s_objet_argument_2); - liberation(s_etat_processus, s_objet_argument_1); - - return; - } - if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces == 'S') { + if ((*s_objet_argument_2).type != LST) + { + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_argument; + return; + } + + if ((chaine = formateur_fichier(s_etat_processus, + s_objet_argument_2, (*((struct_fichier *) + (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F', + &longueur_effective, &recursivite, d_vrai)) == NULL) + { + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + return; + } + BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n")); if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_END) @@ -542,13 +629,18 @@ instruction_write(struct_processus *s_et if ((chaine_utf8 = transliteration(s_etat_processus, chaine, d_locale, "UTF-8")) == NULL) { + free(chaine); + liberation(s_etat_processus, s_objet_argument_2); liberation(s_etat_processus, s_objet_argument_1); return; } - if (fprintf((*descripteur).descripteur_c, "%s\n", chaine) < 0) + free(chaine); + + if (fprintf((*descripteur).descripteur_c, "%s\n", chaine_utf8) + < 0) { free(chaine_utf8); @@ -561,13 +653,670 @@ instruction_write(struct_processus *s_et else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces == 'D') { + BUG(((*descripteur).type != 'S'), uprintf("Bad filetype !\n")); + + if ((*s_objet_argument_2).type != INT) + { + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_argument; + return; + } + + if (depilement(s_etat_processus, &((*s_etat_processus) + .l_base_pile), &s_objet_argument_3) == d_erreur) + { + (*s_etat_processus).erreur_execution = d_ex_manque_argument; + return; + } + + if ((*s_objet_argument_3).type != LST) + { + liberation(s_etat_processus, s_objet_argument_3); + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_argument; + return; + } + + // Modification ou création d'un nouvel enregistrement + + if ((chaine = formateur_fichier(s_etat_processus, + s_objet_argument_3, (*((struct_fichier *) + (*s_objet_argument_1).objet)).format, 0, 0, ' ', + 'F', &longueur_effective, &recursivite, d_vrai)) + == NULL) + { + liberation(s_etat_processus, s_objet_argument_3); + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + return; + } + + if ((chaine_utf8 = transliteration(s_etat_processus, + chaine, d_locale, "UTF-8")) == NULL) + { + free(chaine); + + liberation(s_etat_processus, s_objet_argument_3); + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + return; + } + + free(chaine); + + if (alsprintf(s_etat_processus, &commande, + "insert or replace into data " + "(id, data) values (%lld, '%s')", (*((integer8 *) + (*s_objet_argument_2).objet)), chaine_utf8) < 0) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + free(chaine_utf8); + + 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; + } + + 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; + } + + liberation(s_etat_processus, s_objet_argument_3); + free(commande); } - else + else // Fichiers indexés { - /* Fichiers indexés : panique totale ! */ - } + BUG(((*descripteur).type != 'S'), uprintf("Bad filetype !\n")); - free(chaine); + if ((*s_objet_argument_2).type != LST) + { + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + (*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 + { + sqlite_status = sqlite3_step(ppStmt); + + if (sqlite_status == SQLITE_ROW) + { + break; + } + else if ((sqlite_status == SQLITE_BUSY) || + (sqlite_status == SQLITE_LOCKED)) + { + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + } + else + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + } while(sqlite_status != SQLITE_ROW); + + if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + 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); + + l_element_courant = (struct_liste_chainee *) + (*s_objet_argument_2).objet; + l_element_courant_format = (struct_liste_chainee *) + (*(*((struct_fichier *) (*s_objet_argument_1).objet)) + .format).objet; + compteur = 1; + + while((l_element_courant != NULL) && + (l_element_courant_format != NULL)) + { + if (compteur == clef) + { + break; + } + + l_element_courant = (*l_element_courant).suivant; + l_element_courant_format = (*l_element_courant_format) + .suivant; + compteur++; + } + + if ((l_element_courant == NULL) || + (l_element_courant_format == NULL)) + { + (*s_etat_processus).erreur_execution = + d_ex_clef_inexistante; + + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + return; + } + + if ((s_element = allocation(s_etat_processus, LST)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (((*s_element).objet = allocation_maillon(s_etat_processus)) + == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + (*((struct_liste_chainee *) (*s_element).objet)).suivant = NULL; + + if (((*((struct_liste_chainee *) (*s_element).objet)) + .donnee = copie_objet(s_etat_processus, + (*l_element_courant).donnee, 'N')) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if ((s_format = allocation(s_etat_processus, LST)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (((*s_format).objet = allocation_maillon(s_etat_processus)) + == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + (*((struct_liste_chainee *) (*s_format).objet)).suivant = NULL; + + if (((*((struct_liste_chainee *) (*s_format).objet)) + .donnee = copie_objet(s_etat_processus, + (*l_element_courant_format).donnee, 'N')) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if ((chaine = formateur_fichier(s_etat_processus, + s_element, s_format, 0, 0, ' ', + 'F', &longueur_effective, &recursivite, d_vrai)) + == NULL) + { + liberation(s_etat_processus, s_element); + liberation(s_etat_processus, s_format); + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + return; + } + + liberation(s_etat_processus, s_element); + liberation(s_etat_processus, s_format); + + if ((clef_utf8 = transliteration(s_etat_processus, + chaine, d_locale, "UTF-8")) == NULL) + { + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + return; + } + + free(chaine); + + // 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 + { + switch(sqlite_status = sqlite3_step(ppStmt)) + { + case SQLITE_ROW: + { + // Une clef existe. + + mise_a_jour = d_vrai; + break; + } + + case SQLITE_DONE: + { + // Aucune clef n'existe. + + mise_a_jour = d_faux; + + if (sqlite3_finalize(ppStmt) != SQLITE_OK) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + + free(commande); + + if (alsprintf(s_etat_processus, &commande, + "insert into key (key) values ('%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; + } + + 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 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; + } + + 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(sqlite_status != SQLITE_ROW); + + if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER) + { + (*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); + + // Modification de la clef + + if (mise_a_jour == d_vrai) + { + if (alsprintf(s_etat_processus, &commande, + "update key set key = '%s' where id = %lld", + clef_utf8, 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; + } + + 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); + } + + // Effacement de l'enregistrement existant + + if (alsprintf(s_etat_processus, &commande, + "delete from data where key_id = %lld", 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; + } + + 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); + + // Modification ou création d'un nouvel enregistrement + + l_element_courant = (struct_liste_chainee *) + (*s_objet_argument_2).objet; + l_element_courant_format = (struct_liste_chainee *) + (*(*((struct_fichier *) (*s_objet_argument_1).objet)) + .format).objet; + compteur = 1; + ordre = 1; + + while((l_element_courant != NULL) && + (l_element_courant_format != NULL)) + { + if (compteur == clef) + { + l_element_courant = (*l_element_courant).suivant; + l_element_courant_format = (*l_element_courant_format) + .suivant; + compteur++; + continue; + } + + if ((s_element = allocation(s_etat_processus, LST)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (((*s_element).objet = + allocation_maillon(s_etat_processus)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + (*((struct_liste_chainee *) (*s_element).objet)).suivant + = NULL; + + if ((s_format = allocation(s_etat_processus, LST)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (((*s_format).objet = + allocation_maillon(s_etat_processus)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + (*((struct_liste_chainee *) (*s_format).objet)).suivant + = NULL; + + if (((*((struct_liste_chainee *) (*s_element).objet)) + .donnee = copie_objet(s_etat_processus, + (*l_element_courant).donnee, 'N')) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (((*((struct_liste_chainee *) (*s_format).objet)) + .donnee = copie_objet(s_etat_processus, + (*l_element_courant_format).donnee, 'N')) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if ((chaine = formateur_fichier(s_etat_processus, + s_element, s_format, 0, 0, ' ', + 'F', &longueur_effective, &recursivite, d_vrai)) + == NULL) + { + free(clef_utf8); + + liberation(s_etat_processus, s_element); + liberation(s_etat_processus, s_format); + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + return; + } + + if ((chaine_utf8 = transliteration(s_etat_processus, + chaine, d_locale, "UTF-8")) == NULL) + { + free(clef_utf8); + free(chaine); + + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + return; + } + + free(chaine); + + if (alsprintf(s_etat_processus, &commande, + "insert into data (data, key_id, sequence) values " + "('%s', %lld, %lld)", chaine_utf8, id, ordre) < 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; + } + + 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); + free(chaine_utf8); + + liberation(s_etat_processus, s_element); + liberation(s_etat_processus, s_format); + + l_element_courant = (*l_element_courant).suivant; + l_element_courant_format = (*l_element_courant_format) + .suivant; + + compteur++; + ordre++; + } + + free(clef_utf8); + + if ((l_element_courant != NULL) || + (l_element_courant_format != NULL)) + { + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_format_fichier; + return; + } + } } else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'Y') @@ -576,20 +1325,30 @@ instruction_write(struct_processus *s_et * Fichiers non formatés */ - if ((chaine = formateur_fichier(s_etat_processus, - s_objet_argument_2, (*((struct_fichier *) - (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U', - &longueur_effective, &recursivite)) == NULL) - { - liberation(s_etat_processus, s_objet_argument_2); - liberation(s_etat_processus, s_objet_argument_1); - - return; - } - if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces == 'S') { + if ((*s_objet_argument_2).type != LST) + { + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_argument; + return; + } + + if ((chaine = formateur_fichier(s_etat_processus, + s_objet_argument_2, (*((struct_fichier *) + (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U', + &longueur_effective, &recursivite, d_vrai)) == NULL) + { + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + return; + } + BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n")); if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_END) @@ -602,7 +1361,8 @@ instruction_write(struct_processus *s_et return; } - if (fwrite(chaine, sizeof(unsigned char), longueur_effective, + if (fwrite(chaine, sizeof(unsigned char), + (size_t) longueur_effective, (*descripteur).descripteur_c) != (size_t) longueur_effective) { @@ -613,10 +1373,67 @@ instruction_write(struct_processus *s_et else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces == 'D') { + if ((*s_objet_argument_2).type != INT) + { + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_argument; + return; + } + + if (depilement(s_etat_processus, &((*s_etat_processus) + .l_base_pile), &s_objet_argument_3) == d_erreur) + { + (*s_etat_processus).erreur_execution = d_ex_manque_argument; + return; + } + + if ((*s_objet_argument_3).type != LST) + { + liberation(s_etat_processus, s_objet_argument_3); + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_argument; + return; + } + + if ((chaine = formateur_fichier(s_etat_processus, + s_objet_argument_2, (*((struct_fichier *) + (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U', + &longueur_effective, &recursivite, d_faux)) == NULL) + { + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + return; + } } - else + else // Fichiers indexés { - /* Fichiers indexés : panique totale ! */ + if ((*s_objet_argument_2).type != LST) + { + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_argument; + return; + } + + if ((chaine = formateur_fichier(s_etat_processus, + s_objet_argument_2, (*((struct_fichier *) + (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U', + &longueur_effective, &recursivite, d_faux)) == NULL) + { + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + return; + } } free(chaine); @@ -626,6 +1443,208 @@ instruction_write(struct_processus *s_et /* * Fichiers de type FLOW */ + + if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces + == 'S') + { + BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n")); + + if ((*s_objet_argument_2).type != LST) + { + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_argument; + return; + } + + if ((*((struct_liste_chainee *) (*s_objet_argument_2).objet)) + .donnee == NULL) + { + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_argument; + return; + } + + l_element_courant = (*s_objet_argument_2).objet; + l_element_courant_format = (struct_liste_chainee *) + (*(*((struct_fichier *) (*s_objet_argument_1).objet)) + .format).objet; + + while((l_element_courant != NULL) && + (l_element_courant_format != NULL)) + { + if ((*(*l_element_courant).donnee).type != CHN) + { + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_argument; + return; + } + + if ((*(*l_element_courant_format).donnee).type != CHN) + { + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + (*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 (strcmp("LINE*(*)", format_chaine) == 0) + { + format_oriente_ligne = d_vrai; + format_degenere = d_vrai; + } + else + { + format_oriente_ligne = d_faux; + + if (strncmp("LENGTH*(", format_chaine, 8) != 0) + { + free(format_chaine); + + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_format_fichier; + return; + } + + longueur = (integer8) strlen(format_chaine); + + if (format_chaine[longueur - 1] != ')') + { + free(format_chaine); + + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + (*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) + { + free(format_chaine); + + liberation(s_etat_processus, + s_objet_argument_2); + liberation(s_etat_processus, + s_objet_argument_1); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_format_fichier; + return; + } + } + } + + free(format_chaine); + + if ((chaine = formateur_flux(s_etat_processus, + (unsigned char *) (*(*l_element_courant).donnee) + .objet, &longueur_effective)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if ((format_degenere == d_vrai) || + (longueur_effective < longueur)) + { + if (fwrite(chaine, sizeof(unsigned char), + (size_t) longueur_effective, + (*descripteur).descripteur_c) != + (size_t) longueur_effective) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + } + else + { + if (fwrite(chaine, sizeof(unsigned char), + (size_t) longueur_effective, + (*descripteur).descripteur_c) != + (size_t) longueur) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + } + + free(chaine); + + if (format_oriente_ligne == d_vrai) + { + if (fwrite("\n", 1, 1, (*descripteur).descripteur_c) + != 1) + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + return; + } + } + + l_element_courant = (*l_element_courant).suivant; + l_element_courant_format = (*l_element_courant_format) + .suivant; + } + + if ((l_element_courant_format != NULL) || + (l_element_courant != NULL)) + { + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_format_fichier; + return; + } + } + else + { + 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_fichier; + return; + } } } else if (((*s_objet_argument_2).type == LST) && @@ -654,54 +1673,206 @@ instruction_write(struct_processus *s_et if ((chaine = formateur_fichier(s_etat_processus, s_objet_argument_2, (*((struct_socket *) (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F', - &longueur_effective, &recursivite)) == NULL) + &longueur_effective, &recursivite, d_faux)) == NULL) { liberation(s_etat_processus, s_objet_argument_2); liberation(s_etat_processus, s_objet_argument_1); return; } + } + else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire + == 'Y') + { + /* + * Sockets non formatées + */ - if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type, - "STREAM") == 0) || (strcmp((*((struct_socket *) - (*s_objet_argument_1).objet)).type, - "SEQUENTIAL DATAGRAM") == 0)) - { // Sockets connectées + if ((chaine = formateur_fichier(s_etat_processus, + s_objet_argument_2, (*((struct_socket *) + (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U', + &longueur_effective, &recursivite, d_faux)) == NULL) + { + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); - action.sa_handler = SIG_IGN; - action.sa_flags = SA_ONSTACK; + return; + } + } + else + { + /* + * Sockets de type FLOW + */ + + if ((*((*((struct_liste_chainee *) (*s_objet_argument_2).objet)) + .donnee)).type != CHN) + { + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_argument; + return; + } + + if ((chaine = formateur_flux(s_etat_processus, (unsigned char *) + (*((*((struct_liste_chainee *) (*s_objet_argument_2) + .objet)).donnee)).objet, &longueur_effective)) == NULL) + { + liberation(s_etat_processus, s_objet_argument_2); + liberation(s_etat_processus, s_objet_argument_1); + + return; + } + } - if (sigaction(SIGPIPE, &action, ®istre) != 0) + if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type, + "STREAM") == 0) || (strcmp((*((struct_socket *) + (*s_objet_argument_1).objet)).type, + "SEQUENTIAL DATAGRAM") == 0)) + { // Sockets connectées + + action.sa_handler = SIG_IGN; + action.sa_flags = 0; + + if (sigaction(SIGPIPE, &action, ®istre) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_signal; + return; + } + +# ifndef SEMAPHORES_NOMMES + if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) +# else + if (sem_post((*s_etat_processus).semaphore_fork) != 0) +# endif + { + if (sigaction(SIGPIPE, ®istre, NULL) != 0) { (*s_etat_processus).erreur_systeme = d_es_signal; return; } - if (sem_post(&((*s_etat_processus).semaphore_fork)) - != 0) + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + if (send((*((struct_socket *) (*s_objet_argument_1).objet)) + .socket, chaine, (size_t) longueur_effective, 0) < 0) + { + ios = errno; + + if (sigaction(SIGPIPE, ®istre, NULL) != 0) { - if (sigaction(SIGPIPE, ®istre, NULL) != 0) + (*s_etat_processus).erreur_systeme = d_es_signal; + 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_signal; + (*s_etat_processus).erreur_systeme = d_es_processus; return; } + } - (*s_etat_processus).erreur_systeme = d_es_processus; + if ((ios == EPIPE) || (ios == ECONNRESET)) + { + (*s_etat_processus).erreur_execution = + d_ex_erreur_acces_fichier; return; } - if (send((*((struct_socket *) (*s_objet_argument_1).objet)) - .socket, chaine, strlen(chaine), 0) < 0) - { - ios = errno; + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + 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) + { if (sigaction(SIGPIPE, ®istre, NULL) != 0) { (*s_etat_processus).erreur_systeme = d_es_signal; return; } - while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } + + if (sigaction(SIGPIPE, ®istre, NULL) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_signal; + return; + } + } + else + { // Sockets non connectées + + /* + * Vérification de l'adresse distante + */ + + if (strcmp((*((struct_socket *) (*s_objet_argument_1).objet)) + .adresse_distante, "") == 0) + { + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_acces_fichier; + return; + } + + /* + * Création de l'adresse logique + */ + + if ((*((struct_socket *) (*s_objet_argument_1).objet)) + .domaine == PF_UNIX) + { + adresse_unix.sun_family = AF_UNIX; + strncpy(adresse_unix.sun_path, (*((struct_socket *) + (*s_objet_argument_1).objet)).adresse_distante, + UNIX_PATH_MAX); + adresse_unix.sun_path[UNIX_PATH_MAX - 1] = + d_code_fin_chaine; + +# 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 (sendto((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, chaine, + (size_t) longueur_effective, 0, (struct sockaddr *) + &adresse_unix, sizeof(adresse_unix)) < 0) + { + ios = errno; + +# 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) { @@ -710,70 +1881,62 @@ instruction_write(struct_processus *s_et } } - if (ios == EPIPE) + if ((ios == EPIPE) || (ios == ECONNRESET)) { (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier; return; } + if (ios == EMSGSIZE) + { + (*s_etat_processus).erreur_execution = + d_ex_taille_message; + return; + } + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } - 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) { - if (sigaction(SIGPIPE, ®istre, NULL) != 0) - { - (*s_etat_processus).erreur_systeme = d_es_signal; - return; - } - (*s_etat_processus).erreur_systeme = d_es_processus; return; } } - - if (sigaction(SIGPIPE, ®istre, NULL) != 0) - { - (*s_etat_processus).erreur_systeme = d_es_signal; - return; - } } - else - { // Sockets non connectées - - /* - * Vérification de l'adresse distante - */ - - if (strcmp((*((struct_socket *) (*s_objet_argument_1).objet)) - .adresse_distante, "") == 0) - { - liberation(s_etat_processus, s_objet_argument_1); - liberation(s_etat_processus, s_objet_argument_2); - - (*s_etat_processus).erreur_execution = - d_ex_erreur_acces_fichier; - return; - } - - /* - * Création de l'adresse logique - */ - - if ((*((struct_socket *) (*s_objet_argument_1).objet)) - .domaine == PF_UNIX) - { - adresse_unix.sun_family = AF_UNIX; - strncpy(adresse_unix.sun_path, (*((struct_socket *) - (*s_objet_argument_1).objet)).adresse_distante, - 108); - adresse_unix.sun_path[108 - 1] = d_code_fin_chaine; - - if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) + else if ((*((struct_socket *) (*s_objet_argument_1).objet)) + .domaine == PF_INET) + { + if (sscanf((*((struct_socket *) + (*s_objet_argument_1).objet)) + .adresse_distante, "%d.%d.%d.%d(%d)", + &(adresse[0]), &(adresse[1]), &(adresse[2]), + &(adresse[3]), &port) == 5) + { // Adresse IPv4 + calcul_adresse = 0; + for(i = 0; i < 4; calcul_adresse = + (256 * calcul_adresse) + + ((unsigned char) adresse[i++])); + + memset(&adresse_ipv4, 0, sizeof(adresse_ipv4)); + adresse_ipv4.sin_family = AF_INET; + adresse_ipv4.sin_port = htons((uint16_t) port); + adresse_ipv4.sin_addr.s_addr = htonl(calcul_adresse); + +# 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; @@ -781,11 +1944,18 @@ instruction_write(struct_processus *s_et if (sendto((*((struct_socket *) (*s_objet_argument_1).objet)).socket, chaine, - strlen(chaine), 0, (struct sockaddr *) - &adresse_unix, sizeof(adresse_unix)) < 0) + (size_t) longueur_effective, 0, (struct sockaddr *) + &adresse_ipv4, sizeof(adresse_ipv4)) < 0) { - while(sem_wait(&((*s_etat_processus) - .semaphore_fork)) == -1) + ios = errno; + +# 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) { @@ -795,12 +1965,31 @@ instruction_write(struct_processus *s_et } } + if ((ios == EPIPE) || (ios == ECONNRESET)) + { + (*s_etat_processus).erreur_execution = + d_ex_erreur_acces_fichier; + return; + } + + if (ios == EMSGSIZE) + { + (*s_etat_processus).erreur_execution = + d_ex_taille_message; + return; + } + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } - 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) { @@ -809,54 +1998,63 @@ instruction_write(struct_processus *s_et } } } - else if ((*((struct_socket *) (*s_objet_argument_1).objet)) - .domaine == PF_INET) + else { - if (sscanf((*((struct_socket *) - (*s_objet_argument_1).objet)) - .adresse_distante, "%d.%d.%d.%d(%d)", - &(adresse[0]), &(adresse[1]), &(adresse[2]), - &(adresse[3]), &port) == 5) - { // Adresse IPv4 - calcul_adresse = 0; - for(i = 0; i < 4; calcul_adresse = - (256 * calcul_adresse) + adresse[i++]); - - memset(&adresse_ipv4, 0, sizeof(adresse_ipv4)); - adresse_ipv4.sin_family = AF_INET; - adresse_ipv4.sin_port = htons(port); - adresse_ipv4.sin_addr.s_addr = htonl(calcul_adresse); - - if (sem_post(&((*s_etat_processus) - .semaphore_fork)) != 0) - { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); - if (sendto((*((struct_socket *) - (*s_objet_argument_1).objet)).socket, chaine, - strlen(chaine), 0, (struct sockaddr *) - &adresse_ipv4, sizeof(adresse_ipv4)) < 0) - { - while(sem_wait(&((*s_etat_processus) - .semaphore_fork)) == -1) - { - if (errno != EINTR) - { - (*s_etat_processus).erreur_systeme = - d_es_processus; - return; - } - } + (*s_etat_processus).erreur_execution = + d_ex_erreur_parametre_fichier; + return; + } + } + else if ((*((struct_socket *) (*s_objet_argument_1).objet)) + .domaine == PF_INET6) + { + if (sscanf((*((struct_socket *) (*s_objet_argument_1) + .objet)).adresse_distante, "%X:%X:%X:%X:%X:" + "%X:%X:%X:%X:%X:%X:%X:%X:%X:%X:%X(%d)", + &(adresse[0]), &(adresse[1]), &(adresse[2]), + &(adresse[3]), &(adresse[4]), &(adresse[5]), + &(adresse[6]), &(adresse[7]), &(adresse[8]), + &(adresse[9]), &(adresse[10]), &(adresse[11]), + &(adresse[12]), &(adresse[13]), &(adresse[14]), + &(adresse[15]), &port)== 17) + { // Adresse IPv6 +# ifdef IPV6 + memset(&adresse_ipv6, 0, sizeof(adresse_ipv6)); + adresse_ipv6.sin6_family = AF_INET6; + adresse_ipv6.sin6_port = htons((uint16_t) port); + + for(i = 0; i < 16; + adresse_ipv6.sin6_addr.s6_addr[i] = + (unsigned char) adresse[i], i++); + +# 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; + } - (*s_etat_processus).erreur_systeme = - d_es_erreur_fichier; - return; - } + if (sendto((*((struct_socket *) + (*s_objet_argument_1).objet)).socket, chaine, + (size_t) longueur_effective, 0, (struct sockaddr *) + &adresse_ipv6, sizeof(adresse_ipv6)) < 0) + { + ios = errno; - 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) { @@ -865,88 +2063,54 @@ instruction_write(struct_processus *s_et return; } } - } - else - { - liberation(s_etat_processus, s_objet_argument_1); - liberation(s_etat_processus, s_objet_argument_2); - (*s_etat_processus).erreur_execution = - d_ex_erreur_parametre_fichier; - return; - } - } - else if ((*((struct_socket *) (*s_objet_argument_1).objet)) - .domaine == PF_INET6) - { - if (sscanf((*((struct_socket *) (*s_objet_argument_1) - .objet)).adresse_distante, "%X:%X:%X:%X:%X:" - "%X:%X:%X:%X:%X:%X:%X:%X:%X:%X:%X(%d)", - &(adresse[0]), &(adresse[1]), &(adresse[2]), - &(adresse[3]), &(adresse[4]), &(adresse[5]), - &(adresse[6]), &(adresse[7]), &(adresse[8]), - &(adresse[9]), &(adresse[10]), &(adresse[11]), - &(adresse[12]), &(adresse[13]), &(adresse[14]), - &(adresse[15]), &port)== 17) - { // Adresse IPv6 - memset(&adresse_ipv6, 0, sizeof(adresse_ipv6)); - adresse_ipv6.sin6_family = AF_INET6; - adresse_ipv6.sin6_port = htons((uint16_t) port); - - for(i = 0; i < 16; - adresse_ipv6.sin6_addr.s6_addr[i] = - adresse[i], i++); - - if (sem_post(&((*s_etat_processus) - .semaphore_fork)) != 0) + if ((ios == EPIPE) || (ios == ECONNRESET)) { - (*s_etat_processus).erreur_systeme = d_es_processus; + (*s_etat_processus).erreur_execution = + d_ex_erreur_acces_fichier; return; } - if (sendto((*((struct_socket *) - (*s_objet_argument_1).objet)).socket, chaine, - strlen(chaine), 0, (struct sockaddr *) - &adresse_ipv6, sizeof(adresse_ipv6)) < 0) + if (ios == EMSGSIZE) { - while(sem_wait(&((*s_etat_processus) - .semaphore_fork)) == -1) - { - if (errno != EINTR) - { - (*s_etat_processus).erreur_systeme = - d_es_processus; - return; - } - } - - (*s_etat_processus).erreur_systeme = - d_es_erreur_fichier; + (*s_etat_processus).erreur_execution = + d_ex_taille_message; return; } - while(sem_wait(&((*s_etat_processus) - .semaphore_fork)) == -1) + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + 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) { - if (errno != EINTR) - { - (*s_etat_processus).erreur_systeme = - d_es_processus; - return; - } + (*s_etat_processus).erreur_systeme = + d_es_processus; + return; } } +# else + if ((*s_etat_processus).langue == 'F') + { + printf("+++Attention : Support du protocole" + " IPv6 indisponible\n"); + } else { - liberation(s_etat_processus, s_objet_argument_1); - liberation(s_etat_processus, s_objet_argument_2); - - (*s_etat_processus).erreur_execution = - d_ex_erreur_parametre_fichier; - return; + printf("+++Warning : IPv6 support " + "unavailable\n"); } +# endif } - else + else { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); @@ -956,22 +2120,18 @@ instruction_write(struct_processus *s_et return; } } + else + { + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); - free(chaine); - } - else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire - == 'Y') - { - /* - * Sockets non formatées - */ - } - else - { - /* - * Sockets de type FLOW - */ + (*s_etat_processus).erreur_execution = + d_ex_erreur_parametre_fichier; + return; + } } + + free(chaine); } else { @@ -1079,8 +2239,8 @@ instruction_wflock(struct_processus *s_e do { - if ((chaine = conversion_majuscule((unsigned char *) - (*s_objet_argument_1).objet)) == NULL) + if ((chaine = conversion_majuscule(s_etat_processus, + (unsigned char *) (*s_objet_argument_1).objet)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -1132,13 +2292,21 @@ instruction_wflock(struct_processus *s_e 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; } - 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) { @@ -1153,13 +2321,26 @@ instruction_wflock(struct_processus *s_e } else { + if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions) + != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + if ((*s_etat_processus).nombre_interruptions_non_affectees != 0) { affectation_interruptions_logicielles(s_etat_processus); } - if ((*s_etat_processus).nombre_interruptions_en_queue - != 0) + if (pthread_mutex_unlock(&(*s_etat_processus) + .mutex_interruptions) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + if ((*s_etat_processus).nombre_interruptions_en_queue != 0) { registre_instruction_valide = (*s_etat_processus).instruction_valide; @@ -1273,7 +2454,8 @@ instruction_wfproc(struct_processus *s_e } } - if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) + if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus)) + != 0) { if ((*s_etat_processus).profilage == d_vrai) { @@ -1338,7 +2520,8 @@ instruction_wfproc(struct_processus *s_e profilage(s_etat_processus, NULL); } - if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) + if (pthread_mutex_unlock(&((*s_etat_processus) + .mutex_pile_processus)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -1361,9 +2544,9 @@ instruction_wfproc(struct_processus *s_e if ((*(*((struct_processus_fils *) (*(*l_element_courant) .donnee).objet)).thread).processus_detache == d_vrai) { - if (kill((*(*((struct_processus_fils *) + if (envoi_signal_processus((*(*((struct_processus_fils *) (*(*l_element_courant).donnee).objet)).thread).pid, - 0) != 0) + rpl_signull, d_faux) != 0) { drapeau_fin = d_vrai; } @@ -1418,8 +2601,12 @@ instruction_wfproc(struct_processus *s_e * Le processus n'est pas terminé */ - if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) + if (pthread_mutex_lock(&((*s_etat_processus) + .mutex_interruptions)) != 0) { + pthread_mutex_unlock(&((*s_etat_processus) + .mutex_pile_processus)); + if ((*s_etat_processus).profilage == d_vrai) { profilage(s_etat_processus, NULL); @@ -1436,8 +2623,36 @@ instruction_wfproc(struct_processus *s_e affectation_interruptions_logicielles(s_etat_processus); } - if ((*s_etat_processus).nombre_interruptions_en_queue - != 0) + if (pthread_mutex_unlock(&((*s_etat_processus) + .mutex_interruptions)) != 0) + { + pthread_mutex_unlock(&((*s_etat_processus) + .mutex_pile_processus)); + + if ((*s_etat_processus).profilage == d_vrai) + { + profilage(s_etat_processus, NULL); + } + + (*s_etat_processus).erreur_systeme = + d_es_processus; + return; + } + + if (pthread_mutex_unlock(&((*s_etat_processus) + .mutex_pile_processus)) != 0) + { + if ((*s_etat_processus).profilage == d_vrai) + { + profilage(s_etat_processus, NULL); + } + + (*s_etat_processus).erreur_systeme = + d_es_processus; + return; + } + + if ((*s_etat_processus).nombre_interruptions_en_queue != 0) { registre_instruction_valide = (*s_etat_processus).instruction_valide; @@ -1447,7 +2662,12 @@ instruction_wfproc(struct_processus *s_e registre_instruction_valide; } - 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; @@ -1455,7 +2675,12 @@ instruction_wfproc(struct_processus *s_e nanosleep(&attente, NULL); - 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) { @@ -1466,7 +2691,8 @@ instruction_wfproc(struct_processus *s_e scrutation_injection(s_etat_processus); - if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) + if (pthread_mutex_lock(&((*s_etat_processus) + .mutex_pile_processus)) != 0) { if ((*s_etat_processus).profilage == d_vrai) { @@ -1488,7 +2714,8 @@ instruction_wfproc(struct_processus *s_e profilage(s_etat_processus, NULL); } - if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) + if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus)) + != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -1591,7 +2818,8 @@ instruction_wfdata(struct_processus *s_e } } - if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) + if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus)) + != 0) { if ((*s_etat_processus).profilage == d_vrai) { @@ -1651,7 +2879,8 @@ instruction_wfdata(struct_processus *s_e profilage(s_etat_processus, NULL); } - if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) + if (pthread_mutex_unlock(&((*s_etat_processus) + .mutex_pile_processus)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -1694,7 +2923,8 @@ instruction_wfdata(struct_processus *s_e return; } - if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) + if (pthread_mutex_unlock(&((*s_etat_processus) + .mutex_pile_processus)) != 0) { if ((*s_etat_processus).profilage == d_vrai) { @@ -1706,7 +2936,12 @@ instruction_wfdata(struct_processus *s_e 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; @@ -1714,7 +2949,12 @@ instruction_wfdata(struct_processus *s_e nanosleep(&attente, NULL); - 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) { @@ -1725,12 +2965,26 @@ instruction_wfdata(struct_processus *s_e scrutation_injection(s_etat_processus); + if (pthread_mutex_lock(&(*s_etat_processus) + .mutex_interruptions) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + if ((*s_etat_processus).nombre_interruptions_non_affectees != 0) { affectation_interruptions_logicielles(s_etat_processus); } + if (pthread_mutex_unlock(&(*s_etat_processus) + .mutex_interruptions) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + if ((*s_etat_processus).nombre_interruptions_en_queue != 0) { registre_instruction_valide = @@ -1750,7 +3004,8 @@ instruction_wfdata(struct_processus *s_e return; } - if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) + if (pthread_mutex_lock(&((*s_etat_processus) + .mutex_pile_processus)) != 0) { if ((*s_etat_processus).profilage == d_vrai) { @@ -1777,7 +3032,8 @@ instruction_wfdata(struct_processus *s_e profilage(s_etat_processus, NULL); } - if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) + if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus)) + != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -1809,6 +3065,121 @@ instruction_wfdata(struct_processus *s_e ================================================================================ */ +static inline logical1 +options_sockets(struct_processus *s_etat_processus, struct_socket *s_socket) +{ + int drapeau; + + if (((*s_socket).options & (1 << d_BROADCAST)) != 0) + { + if (setsockopt((*s_socket).socket, SOL_SOCKET, SO_BROADCAST, &drapeau, + sizeof(drapeau)) != 0) + { + return(d_erreur); + } + } + + if (((*s_socket).options & (1 << d_DONT_ROUTE)) != 0) + { + if (setsockopt((*s_socket).socket, SOL_SOCKET, SO_DONTROUTE, &drapeau, + sizeof(drapeau)) != 0) + { + return(d_erreur); + } + } + + if (((*s_socket).options & (1 << d_KEEP_ALIVE)) != 0) + { + if (setsockopt((*s_socket).socket, SOL_SOCKET, SO_KEEPALIVE, &drapeau, + sizeof(drapeau)) != 0) + { + return(d_erreur); + } + } + +# ifdef SO_PRIORITY + if (((*s_socket).options & (1 << d_PRIORITY)) != 0) + { + if (setsockopt((*s_socket).socket, SOL_SOCKET, SO_PRIORITY, + &((*s_socket).priorite), sizeof((*s_socket).priorite)) != 0) + { + return(d_erreur); + } + } +# endif + + // Les deux options suivantes ne peuvent être positionnées simultanément. + + if (((*s_socket).options & (1 << d_RECEIVE_BUFFER)) != 0) + { + if (setsockopt((*s_socket).socket, SOL_SOCKET, SO_RCVBUF, + &((*s_socket).buffer_reception), + sizeof((*s_socket).buffer_reception)) != 0) + { + return(d_erreur); + } + } + +# ifdef SO_RCVBUFFORCE + if (((*s_socket).options & (1 << d_FORCE_RECEIVE_BUFFER)) != 0) + { + if (setsockopt((*s_socket).socket, SOL_SOCKET, SO_RCVBUFFORCE, + &((*s_socket).buffer_reception), + sizeof((*s_socket).buffer_reception)) != 0) + { + return(d_erreur); + } + } +# endif + + // Même remarque + + if (((*s_socket).options & (1 << d_SEND_BUFFER)) != 0) + { + if (setsockopt((*s_socket).socket, SOL_SOCKET, SO_SNDBUF, + &((*s_socket).buffer_emission), + sizeof((*s_socket).buffer_emission)) != 0) + { + return(d_erreur); + } + } + +# ifdef SO_SNDBUFFORCE + if (((*s_socket).options & (1 << d_FORCE_SEND_BUFFER)) != 0) + { + if (setsockopt((*s_socket).socket, SOL_SOCKET, SO_SNDBUFFORCE, + &((*s_socket).buffer_emission), + sizeof((*s_socket).buffer_emission)) != 0) + { + return(d_erreur); + } + } +# endif + + if (((*s_socket).options & (1 << d_RECEIVING_TIMEOUT)) != 0) + { + if (setsockopt((*s_socket).socket, SOL_SOCKET, SO_RCVTIMEO, + &((*s_socket).timeout_emission), + sizeof((*s_socket).timeout_emission)) != 0) + { + return(d_erreur); + } + } + + if (((*s_socket).options & (1 << d_SENDING_TIMEOUT)) != 0) + { + if (setsockopt((*s_socket).socket, SOL_SOCKET, SO_SNDTIMEO, + &((*s_socket).timeout_emission), + sizeof((*s_socket).timeout_emission)) != 0) + { + return(d_erreur); + } + } + + return(d_absence_erreur);; +} + + void instruction_wfsock(struct_processus *s_etat_processus) { @@ -1823,10 +3194,12 @@ instruction_wfsock(struct_processus *s_e struct_objet *s_objet_argument; struct_objet *s_objet_resultat; + struct pollfd s_poll; + struct sockaddr_in adresse_ipv4; +# ifdef IPV6 struct sockaddr_in6 adresse_ipv6; - - unsigned long i; +# endif if ((*s_etat_processus).affichage_arguments == 'Y') { @@ -1874,51 +3247,44 @@ instruction_wfsock(struct_processus *s_e "STREAM") != 0) && (strcmp((*((struct_socket *) (*s_objet_argument).objet)).type, "SEQUENTIAL DATAGRAM") != 0)) { - liberation(s_etat_processus, s_objet_argument); + // Mode non connecté : l'attente se fait sur un poll() - (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier; - return; - } - - if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument, - 'O')) == NULL) - { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; - } - - (*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute = 'N'; - (*((struct_socket *) (*s_objet_resultat).objet)).effacement = 'N'; + if ((s_objet_resultat = copie_objet(s_etat_processus, + s_objet_argument, 'P')) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } - if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine == PF_INET) - { - longueur = sizeof(adresse_ipv4); + s_poll.fd = (*((struct_socket *) (*s_objet_argument).objet)).socket; + s_poll.events = POLLIN; + s_poll.revents = 0; do { drapeau = d_vrai; +# 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_resultat).objet)).socket = - accept((*((struct_socket *) (*s_objet_argument).objet)) - .socket, (struct sockaddr *) &adresse_ipv4, &longueur)) - < 0) + if (poll(&s_poll, 1, -1) < 0) { erreur = errno; - while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) - { - if (errno != EINTR) - { - (*s_etat_processus).erreur_systeme = d_es_processus; - 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 (erreur != EINTR) { @@ -1943,251 +3309,462 @@ instruction_wfsock(struct_processus *s_e } else { - 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) { - (*s_etat_processus).erreur_systeme = d_es_processus; + (*s_etat_processus).erreur_systeme = + d_es_processus; return; } } } } while(drapeau == d_faux); - if (((*((struct_socket *) (*s_objet_resultat).objet)) - .adresse_distante = malloc(22 * - sizeof(unsigned char))) == NULL) + if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), + s_objet_argument) == d_erreur) { - (*s_etat_processus).erreur_systeme = - d_es_allocation_memoire; return; } - sprintf((*((struct_socket *) (*s_objet_resultat).objet)) - .adresse_distante, "%d.%d.%d.%d(%d)", - (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF, - (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF, - (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF, - ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF, - ntohs(adresse_ipv4.sin_port)); + if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), + s_objet_resultat) == d_erreur) + { + return; + } } - else if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine == - PF_INET6) + else { - longueur = sizeof(adresse_ipv6); + // Mode connecté - do + if ((s_objet_resultat = copie_objet(s_etat_processus, + s_objet_argument, 'O')) == NULL) { - drapeau = d_vrai; + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } - if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) - { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } + (*((struct_socket *) (*s_objet_resultat).objet)).effacement = 'N'; + (*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute + = 'N'; - if (((*((struct_socket *) (*s_objet_resultat).objet)).socket = - accept((*((struct_socket *) (*s_objet_argument).objet)) - .socket, (struct sockaddr *) &adresse_ipv6, &longueur)) - < 0) + if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine == + PF_INET) + { + longueur = sizeof(adresse_ipv4); + + do { - erreur = errno; + drapeau = d_vrai; - while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) +# ifndef SEMAPHORES_NOMMES + if (sem_post(&((*s_etat_processus).semaphore_fork)) + != 0) +# else + if (sem_post((*s_etat_processus).semaphore_fork) != 0) +# endif { - if (errno != EINTR) + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + if (((*((struct_socket *) (*s_objet_resultat).objet)) + .socket = accept((*((struct_socket *) + (*s_objet_argument).objet)).socket, + (struct sockaddr *) &adresse_ipv4, &longueur)) + < 0) + { + erreur = errno; + +# 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; + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = + d_es_processus; + return; + } + } + + if (erreur != EINTR) + { + liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_resultat); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_acces_fichier; return; } - } - if (erreur != EINTR) + scrutation_injection(s_etat_processus); + + if ((*s_etat_processus).var_volatile_requete_arret != 0) + { + drapeau = d_vrai; + } + else + { + drapeau = d_faux; + } + } + else { - liberation(s_etat_processus, s_objet_argument); - liberation(s_etat_processus, s_objet_resultat); +# ifndef SEMAPHORES_NOMMES + while(sem_wait(&((*s_etat_processus) + .semaphore_fork)) != 0) +# else + while(sem_wait((*s_etat_processus).semaphore_fork) + != 0) +# endif + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = + d_es_processus; + return; + } + } - (*s_etat_processus).erreur_execution = - d_ex_erreur_acces_fichier; - return; + if (options_sockets(s_etat_processus, + (*s_objet_resultat).objet) != d_absence_erreur) + { + liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_resultat); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_parametre_fichier; + return; + } } + } while(drapeau == d_faux); - scrutation_injection(s_etat_processus); + if (((*((struct_socket *) (*s_objet_resultat).objet)) + .adresse_distante = malloc(22 * + sizeof(unsigned char))) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } - if ((*s_etat_processus).var_volatile_requete_arret != 0) + sprintf((*((struct_socket *) (*s_objet_resultat).objet)) + .adresse_distante, "%d.%d.%d.%d(%d)", + (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF, + (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF, + (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF, + ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF, + ntohs(adresse_ipv4.sin_port)); + } + else if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine == + PF_INET6) + { +# ifdef IPV6 + longueur = sizeof(adresse_ipv6); + + do + { + drapeau = d_vrai; + +# ifndef SEMAPHORES_NOMMES + if (sem_post(&((*s_etat_processus).semaphore_fork)) + != 0) +# else + if (sem_post((*s_etat_processus).semaphore_fork) != 0) +# endif { - drapeau = d_vrai; + (*s_etat_processus).erreur_systeme = d_es_processus; + return; } - else + + if (((*((struct_socket *) (*s_objet_resultat).objet)) + .socket = accept((*((struct_socket *) + (*s_objet_argument).objet)).socket, + (struct sockaddr *) &adresse_ipv6, &longueur)) < 0) { - drapeau = d_faux; + erreur = errno; + +# 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 (erreur != EINTR) + { + liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_resultat); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_acces_fichier; + return; + } + + scrutation_injection(s_etat_processus); + + if ((*s_etat_processus).var_volatile_requete_arret != 0) + { + drapeau = d_vrai; + } + else + { + drapeau = d_faux; + } } - } - else - { - while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) + else { - if (errno != EINTR) +# 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; + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = + d_es_processus; + return; + } + } + + if (options_sockets(s_etat_processus, + (*s_objet_resultat).objet) != d_absence_erreur) + { + liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_resultat); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_parametre_fichier; return; } } - } - } while(drapeau == d_faux); + } while(drapeau == d_faux); - if (((*((struct_socket *) (*s_objet_resultat).objet)) - .adresse_distante = malloc(55 * - sizeof(unsigned char))) == NULL) - { - (*s_etat_processus).erreur_systeme = - d_es_allocation_memoire; - return; - } - - (*((struct_socket *) (*s_objet_resultat).objet)) - .adresse_distante = d_code_fin_chaine; + if (((*((struct_socket *) (*s_objet_resultat).objet)) + .adresse_distante = malloc(47 * + sizeof(unsigned char))) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } - for(i = 0; i < 16; i++) - { sprintf((*((struct_socket *) (*s_objet_resultat) - .objet)).adresse_distante, (i == 0) ? "%s%X" : "%s:%X", - (*((struct_socket *) (*s_objet_resultat) .objet)).adresse_distante, - adresse_ipv6.sin6_addr.s6_addr[i]); + "%02X%02X:%02X%02X:%02X%02X:%02X%02X:" + "%02X%02X:%02X%02X:%02X%02X:%02X%02X(%u)", + adresse_ipv6.sin6_addr.s6_addr[0], + adresse_ipv6.sin6_addr.s6_addr[1], + adresse_ipv6.sin6_addr.s6_addr[2], + adresse_ipv6.sin6_addr.s6_addr[3], + adresse_ipv6.sin6_addr.s6_addr[4], + adresse_ipv6.sin6_addr.s6_addr[5], + adresse_ipv6.sin6_addr.s6_addr[6], + adresse_ipv6.sin6_addr.s6_addr[7], + adresse_ipv6.sin6_addr.s6_addr[8], + adresse_ipv6.sin6_addr.s6_addr[9], + adresse_ipv6.sin6_addr.s6_addr[10], + adresse_ipv6.sin6_addr.s6_addr[11], + adresse_ipv6.sin6_addr.s6_addr[12], + adresse_ipv6.sin6_addr.s6_addr[13], + adresse_ipv6.sin6_addr.s6_addr[14], + adresse_ipv6.sin6_addr.s6_addr[15], + ntohs(adresse_ipv6.sin6_port)); +# else + if ((*s_etat_processus).langue == 'F') + { + printf("+++Attention : Support du protocole" + " IPv6 indisponible\n"); + } + else + { + printf("+++Warning : IPv6 support " + "unavailable\n"); + } +# endif } - - sprintf((*((struct_socket *) (*s_objet_resultat) - .objet)).adresse_distante, "%s(%u)", - (*((struct_socket *) (*s_objet_resultat) - .objet)).adresse_distante, ntohs(adresse_ipv6.sin6_port)); - } - else - { - longueur = 0; - - do + else { - drapeau = d_vrai; + longueur = 0; - if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) + do { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } + drapeau = d_vrai; - if (((*((struct_socket *) (*s_objet_resultat).objet)).socket = - accept((*((struct_socket *) (*s_objet_argument).objet)) - .socket, NULL, &longueur)) < 0) - { - erreur = errno; +# 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; + } - while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) + if (((*((struct_socket *) (*s_objet_resultat).objet)) + .socket = accept((*((struct_socket *) + (*s_objet_argument).objet)).socket, NULL, + &longueur)) < 0) { - if (errno != EINTR) + erreur = errno; + +# 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; - return; + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = + d_es_processus; + return; + } } - } - if (erreur != EINTR) - { - liberation(s_etat_processus, s_objet_argument); - liberation(s_etat_processus, s_objet_resultat); + if (erreur != EINTR) + { + liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_resultat); - (*s_etat_processus).erreur_execution = - d_ex_erreur_acces_fichier; - return; - } + (*s_etat_processus).erreur_execution = + d_ex_erreur_acces_fichier; + return; + } - scrutation_injection(s_etat_processus); + scrutation_injection(s_etat_processus); - if ((*s_etat_processus).var_volatile_requete_arret != 0) - { - drapeau = d_vrai; + if ((*s_etat_processus).var_volatile_requete_arret != 0) + { + drapeau = d_vrai; + } + else + { + drapeau = d_faux; + } } else { - drapeau = d_faux; - } - } - else - { - while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) - { - if (errno != EINTR) +# 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; + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = + d_es_processus; + return; + } + } + + if (options_sockets(s_etat_processus, + (*s_objet_resultat).objet) != d_absence_erreur) + { + liberation(s_etat_processus, s_objet_argument); + liberation(s_etat_processus, s_objet_resultat); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_parametre_fichier; return; } } - } - } while(drapeau == d_faux); - } + } while(drapeau == d_faux); + } - // Si accept() renvoie une erreur non récupérée, il ne peut s'agir - // que de EINTR sachant qu'une requête d'arrêt est en court de - // traitement. + // Si accept() renvoie une erreur non récupérée, il ne peut s'agir + // que de EINTR sachant qu'une requête d'arrêt est en court de + // traitement. - if ((*((struct_socket *) (*s_objet_resultat).objet)).socket >= 0) - { - l_element_courant = (*s_etat_processus).s_sockets; - - if (l_element_courant == NULL) + if ((*((struct_socket *) (*s_objet_resultat).objet)).socket >= 0) { - if (((*s_etat_processus).s_sockets = - allocation_maillon(s_etat_processus)) == NULL) + l_element_courant = (*s_etat_processus).s_sockets; + + if (l_element_courant == NULL) { - (*s_etat_processus).erreur_systeme = - d_es_allocation_memoire; - return; + if (((*s_etat_processus).s_sockets = + allocation_maillon(s_etat_processus)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + (*(*s_etat_processus).s_sockets).suivant = NULL; + l_element_courant = (*s_etat_processus).s_sockets; } + else + { + /* + * Ajout d'un élément à la fin de la liste chaînée + */ - (*(*s_etat_processus).s_sockets).suivant = NULL; - l_element_courant = (*s_etat_processus).s_sockets; - } - else - { - /* - * Ajout d'un élément à la fin de la liste chaînée - */ + while((*l_element_courant).suivant != NULL) + { + l_element_courant = (*l_element_courant).suivant; + } + + if (((*l_element_courant).suivant = + allocation_maillon(s_etat_processus)) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } - while((*l_element_courant).suivant != NULL) - { l_element_courant = (*l_element_courant).suivant; + (*l_element_courant).suivant = NULL; } - if (((*l_element_courant).suivant = - allocation_maillon(s_etat_processus)) == NULL) + if (((*l_element_courant).donnee = copie_objet(s_etat_processus, + s_objet_resultat, 'O')) == 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 = copie_objet(s_etat_processus, - s_objet_resultat, 'O')) == NULL) + if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), + s_objet_argument) == d_erreur) { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } - } - - if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), - s_objet_argument) == d_erreur) - { - return; - } - if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), - s_objet_resultat) == d_erreur) - { - return; + if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), + s_objet_resultat) == d_erreur) + { + return; + } } } else @@ -2290,11 +3867,25 @@ instruction_wfswi(struct_processus *s_et return; } + if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions) + != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + if ((*s_etat_processus).nombre_interruptions_non_affectees != 0) { affectation_interruptions_logicielles(s_etat_processus); } + if (pthread_mutex_unlock(&(*s_etat_processus).mutex_interruptions) + != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + if ((*s_etat_processus).queue_interruptions[interruption - 1] > 0) { drapeau_fin = d_vrai; @@ -2400,7 +3991,11 @@ instruction_wfpoke(struct_processus *s_e do { - 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; @@ -2408,7 +4003,11 @@ instruction_wfpoke(struct_processus *s_e nanosleep(&attente, NULL); - 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) { @@ -2419,11 +4018,23 @@ instruction_wfpoke(struct_processus *s_e scrutation_injection(s_etat_processus); + if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + if ((*s_etat_processus).nombre_interruptions_non_affectees != 0) { affectation_interruptions_logicielles(s_etat_processus); } + if (pthread_mutex_unlock(&(*s_etat_processus).mutex_interruptions) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + if ((*s_etat_processus).nombre_interruptions_en_queue != 0) { registre_instruction_valide = @@ -2526,11 +4137,23 @@ instruction_wfack(struct_processus *s_et { scrutation_injection(s_etat_processus); + if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + if ((*s_etat_processus).nombre_interruptions_non_affectees != 0) { affectation_interruptions_logicielles(s_etat_processus); } + if (pthread_mutex_unlock(&(*s_etat_processus).mutex_interruptions) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + if ((*s_etat_processus).nombre_interruptions_en_queue != 0) { registre_instruction_valide = @@ -2550,7 +4173,11 @@ instruction_wfack(struct_processus *s_et 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; @@ -2559,7 +4186,11 @@ instruction_wfack(struct_processus *s_et nanosleep(&attente, NULL); INCR_GRANULARITE(attente.tv_nsec); - 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) {