/* ================================================================================ RPL/2 (R) version 4.1.32 Copyright (C) 1989-2020 Dr. BERTRAND Joël This file is part of RPL/2. RPL/2 is free software; you can redistribute it and/or modify it under the terms of the CeCILL V2 License as published by the french CEA, CNRS and INRIA. RPL/2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License for more details. You should have received a copy of the CeCILL License along with RPL/2. If not, write to info@cecill.info. ================================================================================ */ #include "rpl-conv.h" /* ================================================================================ Fonction 'r->b' ================================================================================ Entrées : pointeur sur une structure struct_processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_r_vers_b(struct_processus *s_etat_processus) { struct_objet *s_objet_argument; struct_objet *s_objet_resultat; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n R->B "); if ((*s_etat_processus).langue == 'F') { printf("(réel vers binaire)\n\n"); } else { printf("(real to binary)\n\n"); } printf(" 1: %s\n", d_INT); printf("-> 1: %s\n", d_BIN); return; } else if ((*s_etat_processus).test_instruction == 'Y') { (*s_etat_processus).nombre_arguments = -1; return; } if (test_cfsf(s_etat_processus, 31) == d_vrai) { 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_etat_processus).erreur_execution = d_ex_manque_argument; return; } if ((*s_objet_argument).type == INT) { if ((s_objet_resultat = allocation(s_etat_processus, BIN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*((integer8 *) (*s_objet_argument).objet)) < 0) { (*((logical8 *) (*s_objet_resultat).objet)) = 0; } else { (*((logical8 *) (*s_objet_resultat).objet)) = (logical8) (*((integer8 *) (*s_objet_argument).objet)); } } else { liberation(s_etat_processus, s_objet_argument); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_objet_resultat) == d_erreur) { return; } liberation(s_etat_processus, s_objet_argument); return; } /* ================================================================================ Fonction 'rl' ================================================================================ Entrées : pointeur sur une structure struct_processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_rl(struct_processus *s_etat_processus) { logical8 masque; logical8 tampon; struct_objet *s_copie; struct_objet *s_objet; unsigned long i; unsigned long j; unsigned long longueur; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n RL "); if ((*s_etat_processus).langue == 'F') { printf("(rotation à gauche)\n\n"); } else { printf("(rotate left)\n\n"); } printf(" 1: %s\n", d_BIN); printf("-> 1: %s\n", d_BIN); return; } else if ((*s_etat_processus).test_instruction == 'Y') { (*s_etat_processus).nombre_arguments = -1; return; } if (test_cfsf(s_etat_processus, 31) == d_vrai) { if (empilement_pile_last(s_etat_processus, 1) == d_erreur) { return; } } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } if ((*s_objet).type == BIN) { if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } longueur = 1; j = 1; for(i = 37; i <= 42; i++) { longueur += (test_cfsf(s_etat_processus, (unsigned char) i) == d_vrai) ? j : 0; j *= 2; } tampon = (*((logical8 *) (*s_copie).objet)); masque = ((logical8) 1) << (longueur - 1); if ((tampon & masque) == 0) { tampon <<= 1; } else { tampon <<= 1; tampon |= (logical8) 1; } for(masque = 0, i = 0; i < longueur; i++) { masque <<= 1; masque |= (logical8) 1; } tampon &= masque; (*((logical8 *) (*s_copie).objet)) = tampon; if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_copie) == d_erreur) { return; } } else { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } liberation(s_etat_processus, s_objet); return; } /* ================================================================================ Fonction 'rlb' ================================================================================ Entrées : pointeur sur une structure struct_processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_rlb(struct_processus *s_etat_processus) { struct_liste_chainee *l_base_pile; unsigned long i; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n RLB "); if ((*s_etat_processus).langue == 'F') { printf("(rotation d'un octet vers la gauche)\n\n"); } else { printf("(rotate left byte)\n\n"); } printf(" 1: %s\n", d_BIN); printf("-> 1: %s\n", d_BIN); return; } else if ((*s_etat_processus).test_instruction == 'Y') { (*s_etat_processus).nombre_arguments = -1; return; } if (test_cfsf(s_etat_processus, 31) == d_vrai) { if (empilement_pile_last(s_etat_processus, 1) == d_erreur) { return; } } l_base_pile = (*s_etat_processus).l_base_pile_last; (*s_etat_processus).l_base_pile_last = NULL; for(i = 0; i < 8; i++) { instruction_rl(s_etat_processus); if (((*s_etat_processus).erreur_systeme != d_es) || ((*s_etat_processus).erreur_execution != d_ex)) { break; } } if (test_cfsf(s_etat_processus, 31) == d_vrai) { if (empilement_pile_last(s_etat_processus, 0) == d_erreur) { return; } } (*s_etat_processus).l_base_pile_last = l_base_pile; return; } /* ================================================================================ Fonction 'rr' ================================================================================ Entrées : pointeur sur une structure struct_processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_rr(struct_processus *s_etat_processus) { logical8 masque; logical8 tampon; struct_objet *s_copie; struct_objet *s_objet; unsigned long i; unsigned long j; unsigned long longueur; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n RR "); if ((*s_etat_processus).langue == 'F') { printf("(rotation à droite)\n\n"); } else { printf("(rotate right)\n\n"); } printf(" 1: %s\n", d_BIN); printf("-> 1: %s\n", d_BIN); return; } else if ((*s_etat_processus).test_instruction == 'Y') { (*s_etat_processus).nombre_arguments = -1; return; } if (test_cfsf(s_etat_processus, 31) == d_vrai) { if (empilement_pile_last(s_etat_processus, 1) == d_erreur) { return; } } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } if ((*s_objet).type == BIN) { if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } longueur = 1; j = 1; for(i = 37; i <= 42; i++) { longueur += (test_cfsf(s_etat_processus, (unsigned char) i) == d_vrai) ? j : 0; j *= 2; } tampon = (*((logical8 *) (*s_copie).objet)); masque = (logical8) 1; if ((tampon & masque) == 0) { tampon >>= 1; } else { tampon >>= 1; tampon |= (((logical8) 1) << (longueur - 1)); } for(masque = 0, i = 0; i < longueur; i++) { masque <<= 1; masque |= 1; } tampon &= masque; (*((logical8 *) (*s_copie).objet)) = tampon; if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_copie) == d_erreur) { return; } } else { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } liberation(s_etat_processus, s_objet); return; } /* ================================================================================ Fonction 'rrb' ================================================================================ Entrées : pointeur sur une structure struct_processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_rrb(struct_processus *s_etat_processus) { struct_liste_chainee *l_base_pile; unsigned long i; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n RRB "); if ((*s_etat_processus).langue == 'F') { printf("(rotation d'un octet vers la droite)\n\n"); } else { printf("(rotate right byte)\n\n"); } printf(" 1: %s\n", d_BIN); printf("-> 1: %s\n", d_BIN); return; } else if ((*s_etat_processus).test_instruction == 'Y') { (*s_etat_processus).nombre_arguments = -1; return; } if (test_cfsf(s_etat_processus, 31) == d_vrai) { if (empilement_pile_last(s_etat_processus, 1) == d_erreur) { return; } } l_base_pile = (*s_etat_processus).l_base_pile_last; (*s_etat_processus).l_base_pile_last = NULL; for(i = 0; i < 8; i++) { instruction_rr(s_etat_processus); if (((*s_etat_processus).erreur_systeme != d_es) || ((*s_etat_processus).erreur_execution != d_ex)) { break; } } if (test_cfsf(s_etat_processus, 31) == d_vrai) { if (empilement_pile_last(s_etat_processus, 0) == d_erreur) { return; } } (*s_etat_processus).l_base_pile_last = l_base_pile; return; } /* ================================================================================ Fonction 'redraw' ================================================================================ Entrées : pointeur sur une structure struct_processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_redraw(struct_processus *s_etat_processus) { (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n REDRAW "); if ((*s_etat_processus).langue == 'F') { printf("(redessine une courbe)\n\n"); printf(" Aucun argument\n"); } else { printf("(redraw a graphic)\n\n"); printf(" No argument\n"); } return; } else if ((*s_etat_processus).test_instruction == 'Y') { (*s_etat_processus).nombre_arguments = -1; return; } if (test_cfsf(s_etat_processus, 31) == d_vrai) { if (empilement_pile_last(s_etat_processus, 0) == d_erreur) { return; } } if ((*s_etat_processus).mise_a_jour_trace_requise == d_vrai) { (*s_etat_processus).erreur_execution = d_ex_graphique_memorise; return; } if ((*s_etat_processus).fichiers_graphiques != NULL) { appel_gnuplot(s_etat_processus, 'N'); } return; } /* ================================================================================ Fonction 'remove' ================================================================================ Entrées : pointeur sur une structure struct_processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_remove(struct_processus *s_etat_processus) { struct_objet *s_objet_argument; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n REMOVE "); if ((*s_etat_processus).langue == 'F') { printf("(retrait d'une bibliothèque dynamique)\n\n"); } else { printf("(remove a shared library)\n\n"); } printf(" 1: %s\n", d_SLB); return; } else if ((*s_etat_processus).test_instruction == 'Y') { (*s_etat_processus).nombre_arguments = -1; return; } if (test_cfsf(s_etat_processus, 31) == d_vrai) { 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_etat_processus).erreur_execution = d_ex_manque_argument; return; } if ((*s_objet_argument).type == SLB) { /* * On ne décharge que les bibliothèques qui ont été chargées dans * le couple pid/tid courant. */ if (((*((struct_bibliotheque *) (*s_objet_argument).objet)).pid == getpid()) && (pthread_equal((*((struct_bibliotheque *) (*s_objet_argument).objet)).tid, pthread_self()) != 0)) { if (retrait_bibliotheque(s_etat_processus, (*s_objet_argument).objet) == d_erreur) { liberation(s_etat_processus, s_objet_argument); return; } } } else { liberation(s_etat_processus, s_objet_argument); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } liberation(s_etat_processus, s_objet_argument); return; } /* ================================================================================ Fonction 'relax' ================================================================================ Entrées : pointeur sur une structure struct_processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_relax(struct_processus *s_etat_processus) { (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n RELAX "); if ((*s_etat_processus).langue == 'F') { printf("(ne fait rien)\n\n"); printf(" Aucun argument\n"); } else { printf("(do nothing)\n\n"); printf(" No argument\n"); } return; } else if ((*s_etat_processus).test_instruction == 'Y') { (*s_etat_processus).nombre_arguments = 1; return; } /* * Cette instruction ne fait rien. Elle existe pour être symétrique * à l'instruction CHS et permet de traiter les équations de façon * simple (Ex : '+pi'). En principe, elle n'a pas a être appelée * directement par l'utilisateur. */ return; } /* ================================================================================ Fonction 'rewind' ================================================================================ Entrées : pointeur sur une structure struct_processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_rewind(struct_processus *s_etat_processus) { struct_descripteur_fichier *descripteur; struct_objet *s_objet_argument; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n REWIND "); if ((*s_etat_processus).langue == 'F') { printf("(retour au début d'un fichier)\n\n"); } else { printf("(rewind a file)\n\n"); } printf(" 1: %s\n", d_FCH); return; } else if ((*s_etat_processus).test_instruction == 'Y') { (*s_etat_processus).nombre_arguments = -1; return; } if (test_cfsf(s_etat_processus, 31) == d_vrai) { 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_etat_processus).erreur_execution = d_ex_manque_argument; return; } if ((*s_objet_argument).type == FCH) { if ((descripteur = descripteur_fichier(s_etat_processus, (struct_fichier *) (*s_objet_argument).objet)) == NULL) { return; } 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_execution = d_ex_erreur_type_fichier; return; } } else { (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } liberation(s_etat_processus, s_objet_argument); return; } /* ================================================================================ Fonction 'read' ================================================================================ Entrées : pointeur sur une structure struct_processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_read(struct_processus *s_etat_processus) { const char *queue; int c; int ios; int timeout; integer8 element; integer8 i; integer8 id; integer8 index; integer8 longueur; integer8 position_clef; integer8 longueur_effective; integer8 longueur_enregistrement; integer8 longueur_questure; integer8 niveau; integer8 pointeur; integer8 position_finale; integer8 position_initiale; logical1 device; logical1 format_degenere; logical1 format_oriente_ligne; logical1 indicateur_48; logical1 presence_chaine; logical1 presence_indicateur; logical1 trame_complete; socklen_t longueur_adresse; sqlite3_stmt *ppStmt; struct flock lock; struct pollfd fds[1]; struct sockaddr_un adresse_unix; struct sockaddr_in adresse_ipv4; # ifdef IPV6 struct sockaddr_in6 adresse_ipv6; # endif struct termios tc; struct timespec attente; struct_descripteur_fichier *descripteur; struct_liste_chainee *l_element_courant; struct_liste_chainee *l_element_courant_format; struct_liste_chainee *l_element_inclus; struct_objet *s_objet_adresse; struct_objet *s_objet_argument_1; struct_objet *s_objet_argument_2; struct_objet *s_objet_resultat; struct_objet *s_objet_type; unsigned char caractere; unsigned char *clef_utf8; unsigned char *commande; unsigned char *format_chaine; unsigned char *ptr; unsigned char *tampon_lecture; unsigned char *tampon; unsigned char *tampon2; unsigned char *tampon3; int vitesses[] = { 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800, 9600, 19200, 38400, #ifdef B57600 57600, #endif #ifdef B115200 115200, #endif #ifdef B230400 230400, #endif 0 }; tcflag_t vitesses_constantes[] = { B50, B75, B110, B134, B150, B200, B300, B600, B1200, B1800, B2400, B4800, B9600, B19200, B38400, #ifdef B57600 B57600, #endif #ifdef B115200 B115200, #endif #ifdef B230400 B230400, #endif 0 }; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n READ "); if ((*s_etat_processus).langue == 'F') { printf("(lecture d'un enregistrement d'un fichier)\n\n"); } else { printf("(read a record of a file)\n\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') { (*s_etat_processus).nombre_arguments = -1; return; } if (test_cfsf(s_etat_processus, 31) == d_vrai) { 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_1) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } 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 */ lock.l_type = F_RDLCK; lock.l_whence = SEEK_SET; lock.l_start = 0; lock.l_len = 0; lock.l_pid = getpid(); if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock) == -1) { liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } if (lock.l_type != F_UNLCK) { liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_execution = d_ex_fichier_verrouille; return; } /* * Vérification de l'autorisation de lecture */ if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection == 'W') { 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_1).objet)).protection == 'N') { if ((*descripteur).type == 'C') { if (fflush((*descripteur).descripteur_c) != 0) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } } } if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'N') { /* * Fichiers formatés */ if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces == 'S') { /* * Fichiers séquentiels */ longueur_questure = 4096; if ((tampon_lecture = malloc(((size_t) longueur_questure) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } 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; } do { longueur_effective = (integer8) fread(tampon_lecture, sizeof(unsigned char), (size_t) longueur_questure, (*descripteur).descripteur_c); pointeur = 0; presence_indicateur = d_faux; while(pointeur < longueur_effective) { if (tampon_lecture[pointeur] == '{') { presence_indicateur = d_vrai; break; } position_initiale++; pointeur++; } if (presence_indicateur == d_vrai) { break; } } while(longueur_effective == longueur_questure); if (presence_indicateur == d_faux) { liberation(s_etat_processus, s_objet_argument_1); free(tampon_lecture); (*s_etat_processus).erreur_execution = d_ex_fin_de_fichier_atteinte; return; } position_finale = position_initiale + 1; presence_chaine = d_faux; niveau = 1; if (fseek((*descripteur).descripteur_c, (long) position_finale, SEEK_SET) != 0) { liberation(s_etat_processus, s_objet_argument_1); free(tampon_lecture); (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } do { longueur_effective = (integer8) fread(tampon_lecture, sizeof(unsigned char), (size_t) longueur_questure, (*descripteur).descripteur_c); pointeur = 0; presence_indicateur = d_faux; while(pointeur < longueur_effective) { if (tampon_lecture[pointeur] == '"') { 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 { if (presence_chaine == d_faux) { if (tampon_lecture[pointeur] == '{') { niveau++; } else if (tampon_lecture[pointeur] == '}') { niveau--; } } } position_finale++; pointeur++; if (niveau == 0) { presence_indicateur = d_vrai; break; } } if (presence_indicateur == d_vrai) { break; } } while(longueur_effective == longueur_questure); if (presence_indicateur == d_faux) { liberation(s_etat_processus, s_objet_argument_1); free(tampon_lecture); (*s_etat_processus).erreur_execution = d_ex_fin_de_fichier_atteinte; return; } free(tampon_lecture); longueur_enregistrement = position_finale - position_initiale; if ((tampon_lecture = malloc(((size_t) (longueur_enregistrement + 1)) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (fseek((*descripteur).descripteur_c, (long) position_initiale, SEEK_SET) != 0) { liberation(s_etat_processus, s_objet_argument_1); free(tampon_lecture); (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } longueur_effective = (integer8) fread(tampon_lecture, sizeof(unsigned char), (size_t) longueur_enregistrement, (*descripteur).descripteur_c); if (longueur_effective != longueur_enregistrement) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } tampon_lecture[longueur_enregistrement] = d_code_fin_chaine; tampon = (*s_etat_processus).instruction_courante; if (((*s_etat_processus).instruction_courante = transliteration(s_etat_processus, tampon_lecture, "UTF-8", d_locale)) == NULL) { (*s_etat_processus).instruction_courante = tampon; liberation(s_etat_processus, s_objet_argument_1); free(tampon_lecture); return; } indicateur_48 = test_cfsf(s_etat_processus, 48); cf(s_etat_processus, 48); (*s_etat_processus).type_en_cours = NON; recherche_type(s_etat_processus); free((*s_etat_processus).instruction_courante); if ((*s_etat_processus).erreur_execution != d_ex) { if (indicateur_48 == d_vrai) { sf(s_etat_processus, 48); } else { cf(s_etat_processus, 48); } (*s_etat_processus).instruction_courante = tampon; free(tampon_lecture); liberation(s_etat_processus, s_objet_argument_1); return; } 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); } else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces == 'D') { BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n")); if (depilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), &s_objet_argument_2) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } if ((*s_objet_argument_2).type != INT) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } if (alsprintf(s_etat_processus, &commande, "select data from data where id = %lld", (*((integer8 *) (*s_objet_argument_2).objet))) < 0) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, commande, (int) strlen(commande), &ppStmt, &queue) != SQLITE_OK) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } attente.tv_sec = 0; attente.tv_nsec = GRANULARITE_us * 1000; do { ios = sqlite3_step(ppStmt); switch(ios) { case SQLITE_ROW: { // Résultat attendu break; } case SQLITE_DONE: { // Aucun enregistrement if (sqlite3_finalize(ppStmt) != SQLITE_OK) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } free(commande); liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_enregistrement_inexistant; return; } case SQLITE_BUSY: case SQLITE_LOCKED: { nanosleep(&attente, NULL); INCR_GRANULARITE(attente.tv_nsec); break; } default: { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } } } while(ios != SQLITE_ROW); if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } tampon = (*s_etat_processus).instruction_courante; if ((tampon_lecture = (unsigned char *) sqlite3_column_text(ppStmt, 0)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } if (((*s_etat_processus).instruction_courante = transliteration(s_etat_processus, tampon_lecture, "UTF-8", d_locale)) == NULL) { (*s_etat_processus).instruction_courante = tampon; liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); free(commande); return; } indicateur_48 = test_cfsf(s_etat_processus, 48); cf(s_etat_processus, 48); (*s_etat_processus).type_en_cours = NON; recherche_type(s_etat_processus); if ((*s_etat_processus).erreur_execution != d_ex) { if (indicateur_48 == d_vrai) { sf(s_etat_processus, 48); } else { cf(s_etat_processus, 48); } liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); free((*s_etat_processus).instruction_courante); free(commande); (*s_etat_processus).instruction_courante = tampon; return; } if (indicateur_48 == d_vrai) { sf(s_etat_processus, 48); } else { cf(s_etat_processus, 48); } free((*s_etat_processus).instruction_courante); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).instruction_courante = tampon; if (sqlite3_step(ppStmt) != SQLITE_DONE) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } if (sqlite3_finalize(ppStmt) != SQLITE_OK) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } free(commande); } else { BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n")); if (depilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), &s_objet_argument_2) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } if ((*s_objet_argument_2).type != CHN) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } // Récupération de la position de la clef if (alsprintf(s_etat_processus, &commande, "select key from control where id = 1") < 0) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, commande, (int) strlen(commande), &ppStmt, &queue) != SQLITE_OK) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } attente.tv_sec = 0; attente.tv_nsec = GRANULARITE_us * 1000; do { ios = sqlite3_step(ppStmt); if (ios == SQLITE_ROW) { break; } else if ((ios == SQLITE_BUSY) || (ios == SQLITE_LOCKED)) { nanosleep(&attente, NULL); INCR_GRANULARITE(attente.tv_nsec); } else { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } } while(ios != SQLITE_ROW); if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } position_clef = sqlite3_column_int64(ppStmt, 0); if (sqlite3_step(ppStmt) != SQLITE_DONE) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } if (sqlite3_finalize(ppStmt) != SQLITE_OK) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } free(commande); if ((clef_utf8 = transliteration(s_etat_processus, (unsigned char *) (*s_objet_argument_2).objet, d_locale, "UTF-8")) == NULL) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); return; } // Récupération de l'identifiant de la clef if (alsprintf(s_etat_processus, &commande, "select id from key where key = '{ \"%s\" }'", clef_utf8) < 0) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, commande, (int) strlen(commande), &ppStmt, &queue) != SQLITE_OK) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } attente.tv_sec = 0; attente.tv_nsec = GRANULARITE_us * 1000; do { ios = sqlite3_step(ppStmt); switch(ios) { case SQLITE_ROW: { // Résultat attendu : une clef correspond. break; } case SQLITE_DONE: { // Aucun enregistrement if (sqlite3_finalize(ppStmt) != SQLITE_OK) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } free(clef_utf8); free(commande); liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_enregistrement_inexistant; return; } case SQLITE_BUSY: case SQLITE_LOCKED: { nanosleep(&attente, NULL); INCR_GRANULARITE(attente.tv_nsec); break; } default: { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } } } while(ios != SQLITE_ROW); if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER) { free(clef_utf8); (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } id = sqlite3_column_int64(ppStmt, 0); if (sqlite3_step(ppStmt) != SQLITE_DONE) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } if (sqlite3_finalize(ppStmt) != SQLITE_OK) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } free(commande); if (alsprintf(s_etat_processus, &commande, "select data from data where " "key_id = %lld order by sequence asc", id) < 0) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite, commande, (int) strlen(commande), &ppStmt, &queue) != SQLITE_OK) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } element = 1; attente.tv_sec = 0; attente.tv_nsec = GRANULARITE_us * 1000; do { switch(ios = sqlite3_step(ppStmt)) { case SQLITE_ROW: { // Donnée supplémentaire if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } tampon = (*s_etat_processus).instruction_courante; if ((tampon_lecture = (unsigned char *) sqlite3_column_text(ppStmt, 0)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } if (((*s_etat_processus).instruction_courante = transliteration(s_etat_processus, tampon_lecture, "UTF-8", d_locale)) == NULL) { (*s_etat_processus).instruction_courante = tampon; liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); free(commande); free(clef_utf8); return; } indicateur_48 = test_cfsf(s_etat_processus, 48); cf(s_etat_processus, 48); (*s_etat_processus).type_en_cours = NON; recherche_type(s_etat_processus); if ((*s_etat_processus).erreur_execution != d_ex) { if (indicateur_48 == d_vrai) { sf(s_etat_processus, 48); } else { cf(s_etat_processus, 48); } liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); free((*s_etat_processus).instruction_courante); free(commande); free(clef_utf8); (*s_etat_processus).instruction_courante = tampon; return; } if (indicateur_48 == d_vrai) { sf(s_etat_processus, 48); } else { cf(s_etat_processus, 48); } free((*s_etat_processus).instruction_courante); (*s_etat_processus).instruction_courante = tampon; element++; // Inscription de la clef if (element == position_clef) { if (((*s_etat_processus).instruction_courante = transliteration(s_etat_processus, clef_utf8, "UTF-8", d_locale)) == NULL) { (*s_etat_processus).instruction_courante = tampon; liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); free(commande); free(clef_utf8); return; } if (alsprintf(s_etat_processus, &tampon2, "{ \"%s\" }", (*s_etat_processus) .instruction_courante) < 0) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } free((*s_etat_processus).instruction_courante); (*s_etat_processus).instruction_courante = tampon2; indicateur_48 = test_cfsf(s_etat_processus, 48); cf(s_etat_processus, 48); (*s_etat_processus).type_en_cours = NON; recherche_type(s_etat_processus); if ((*s_etat_processus).erreur_execution != d_ex) { if (indicateur_48 == d_vrai) { sf(s_etat_processus, 48); } else { cf(s_etat_processus, 48); } liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); free((*s_etat_processus) .instruction_courante); free(commande); free(clef_utf8); (*s_etat_processus).instruction_courante = tampon; return; } if (indicateur_48 == d_vrai) { sf(s_etat_processus, 48); } else { cf(s_etat_processus, 48); } free((*s_etat_processus).instruction_courante); (*s_etat_processus).instruction_courante = tampon; element++; } break; } case SQLITE_DONE: { // Fin de la liste break; } case SQLITE_BUSY: case SQLITE_LOCKED: { nanosleep(&attente, NULL); INCR_GRANULARITE(attente.tv_nsec); break; } default: { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } } } while(ios != SQLITE_DONE); if (sqlite3_finalize(ppStmt) != SQLITE_OK) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } free(commande); free(clef_utf8); liberation(s_etat_processus, s_objet_argument_2); if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = NULL; l_element_inclus = NULL; for(element--; element > 0; element--) { if (depilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), &s_objet_argument_2) == d_erreur) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } if ((*s_objet_argument_2).type != LST) { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } l_element_inclus = (*s_objet_argument_2).objet; if (l_element_inclus != NULL) { while(l_element_inclus != NULL) { if ((*l_element_inclus).suivant == NULL) { (*l_element_inclus).suivant = l_element_courant; break; } l_element_inclus = (*l_element_inclus).suivant; } l_element_courant = (*s_objet_argument_2).objet; (*s_objet_argument_2).objet = NULL; } liberation(s_etat_processus, s_objet_argument_2); } (*s_objet_resultat).objet = l_element_inclus; if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_objet_resultat) == d_erreur) { return; } } } else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'Y') { /* * Fichiers non formatés */ if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces == 'S') { /* * Fichiers séquentiels * * Les fichiers séquentiels non formatés contiennent comme * les fichiers séquentiels formatés leurs enregistrements * sous la forme de listes les unes derrières les autres. * * Le quartet de poids fort du premier octet à lire * doit donc être égal à 0100. Si ce n'est pas le cas, * il sera impossible de lire le fichier et on renvoie * immédiatement une erreur. Si on lit dans le fichier * la valeur attendue, on récupère la longueur en octet * de l'enregistrement puis on le lit. */ BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n")); if ((s_objet_resultat = lecture_fichier_non_formate( s_etat_processus, (*descripteur).descripteur_c, -1, d_faux)) == NULL) { return; } if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_objet_resultat) == d_erreur) { return; } } } else { /* * Fichiers de type FLOW */ if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces == 'S') { /* * Fichiers séquentiels */ BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n")); longueur_enregistrement = 0; device = d_faux; if ((position_initiale = ftell((*descripteur).descripteur_c)) == -1) { if (errno == ESPIPE) { device = d_vrai; } else { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } } l_element_courant_format = (struct_liste_chainee *) (*(*((struct_fichier *) (*s_objet_argument_1).objet)) .format).objet; l_element_courant = NULL; if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } while(l_element_courant_format != NULL) { if ((*(*l_element_courant_format).donnee).type != CHN) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } if ((format_chaine = conversion_majuscule( s_etat_processus, (unsigned char *) (*(*l_element_courant_format).donnee).objet)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (strcmp("LINE*(*)", format_chaine) == 0) { format_degenere = d_vrai; format_oriente_ligne = d_vrai; } else { format_oriente_ligne = d_faux; if (strncmp("LENGTH*(", format_chaine, 8) != 0) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_resultat); free(format_chaine); (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return; } longueur = (integer8) strlen(format_chaine); if (format_chaine[longueur - 1] != ')') { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_resultat); free(format_chaine); (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return; } format_chaine[longueur] = d_code_fin_chaine; if (format_chaine[8] == '*') { format_degenere = d_vrai; } else { // Détermination de la longueur format_degenere = d_faux; if (sscanf(&(format_chaine[8]), "%lld", &longueur) != 1) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_resultat); free(format_chaine); (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return; } } } free(format_chaine); tampon3 = NULL; if (format_degenere == d_vrai) { if (device == d_vrai) { longueur_questure = 4096; index = 0; if ((tampon3 = malloc(((size_t) longueur_questure) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } tampon3[index] = d_code_fin_chaine; fds[0].fd = fileno((*descripteur).descripteur_c); fds[0].events = POLLIN; fds[0].revents = 0; tcgetattr(fileno((*descripteur).descripteur_c), &tc); timeout = 0; for(i = 0; vitesses[i] != 0; i++) { if (cfgetispeed(&tc) == vitesses_constantes[i]) { // La durée entre deux caractères sur le // périphérique série ne doit pas dépasser // la moitié de la durée de transmission // d'un caractère complet. timeout = (int) (((double) 1000) / (((double) vitesses_constantes[i]) / 4)); break; } } } else { // Évite un warning de gcc. longueur_questure = 0; index = 0; timeout = 0; } do { if (device == d_vrai) { if (poll(fds, 1, timeout) == 0) { break; } } c = getc((*descripteur).descripteur_c); longueur_enregistrement++; if (device == d_vrai) { if (longueur_enregistrement >= longueur_questure) { if ((tampon3 = realloc(tampon3, (size_t) (longueur_questure *= 2))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } } tampon3[index++] = (unsigned char) c; } if (format_oriente_ligne == d_vrai) { if (c == '\n') { break; } } } while(c != EOF); if (device == d_faux) { if (fseek((*descripteur).descripteur_c, (long) position_initiale, SEEK_SET) != 0) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; return; } } } else { longueur_enregistrement = longueur; } if ((device == d_vrai) && (format_degenere == d_vrai)) { longueur_effective = longueur_enregistrement; tampon_lecture = tampon3; } else { if ((tampon_lecture = malloc(((size_t) longueur_enregistrement) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } longueur_effective = (integer8) fread(tampon_lecture, sizeof(unsigned char), (size_t) longueur_enregistrement, (*descripteur).descripteur_c); } if (l_element_courant == NULL) { // Premier maillon de la liste if (((*s_objet_resultat).objet = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*s_objet_resultat).objet; } else { if (((*l_element_courant).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; } (*l_element_courant).suivant = NULL; if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (format_degenere == d_vrai) { if (device == d_faux) { if (((*(*l_element_courant).donnee).objet = analyse_flux(s_etat_processus, tampon_lecture, longueur_enregistrement - 1)) == NULL) { return; } } else { if (((*(*l_element_courant).donnee).objet = analyse_flux(s_etat_processus, tampon_lecture, longueur_enregistrement)) == NULL) { return; } } } else { if (((*(*l_element_courant).donnee).objet = analyse_flux(s_etat_processus, tampon_lecture, longueur_enregistrement)) == NULL) { return; } } free(tampon_lecture); l_element_courant_format = (*l_element_courant_format).suivant; } if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_objet_resultat) == d_erreur) { return; } } else { liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_execution = d_ex_erreur_type_fichier; return; } } } else if ((*s_objet_argument_1).type == SCK) { /* * Vérification de l'autorisation de lecture */ if ((*((struct_socket *) (*s_objet_argument_1).objet)).protection == 'W') { liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier; return; } /* * Vérification de l'écoute de la socket si celle-ci est connectée */ if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type, "STREAM") == 0) || (strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM") == 0)) { if ((*((struct_socket *) (*s_objet_argument_1).objet)) .socket_en_ecoute == 'Y') { 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_1).objet)).binaire == 'N') { // Socket formatée longueur_questure = 4096; longueur_effective = 0; tampon_lecture = NULL; attente.tv_sec = 0; attente.tv_nsec = GRANULARITE_us * 1000; trame_complete = d_faux; position_initiale = 0; position_finale = 0; do { presence_indicateur = d_faux; if ((tampon_lecture = realloc(tampon_lecture, ((size_t) (longueur_effective + longueur_questure + 1)) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } # ifndef SEMAPHORES_NOMMES if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) # else if (sem_post((*s_etat_processus).semaphore_fork) != 0) # endif { (*s_etat_processus).erreur_systeme = d_es_processus; return; } if ((*((struct_socket *) (*s_objet_argument_1).objet)) .domaine == PF_UNIX) { longueur_adresse = sizeof(adresse_unix); do { ios = (int) recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, tampon_lecture, (size_t) (longueur_effective + longueur_questure), MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) &adresse_unix, &longueur_adresse); } while((ios == -1) && (errno == EINTR)); } else if ((*((struct_socket *) (*s_objet_argument_1).objet)) .domaine == PF_INET) { longueur_adresse = sizeof(adresse_ipv4); do { ios = (int) recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, tampon_lecture, (size_t) (longueur_effective + longueur_questure), MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) &adresse_ipv4, &longueur_adresse); } while((ios == -1) && (errno == EINTR)); } else if ((*((struct_socket *) (*s_objet_argument_1).objet)) .domaine == PF_INET6) { # ifdef IPV6 longueur_adresse = sizeof(adresse_ipv6); do { ios = (int) recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, tampon_lecture, (size_t) (longueur_effective + longueur_questure), MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) &adresse_ipv6, &longueur_adresse); } while((ios == -1) && (errno == EINTR)); # else if ((*s_etat_processus).langue == 'F') { printf("+++Attention : Support du protocole" " IPv6 indisponible\n"); } else { printf("+++Warning : IPv6 support " "unavailable\n"); } longueur_adresse = 0; longueur_effective = 0; ios = 0; # endif } else { free(tampon_lecture); liberation(s_etat_processus, s_objet_argument_1); # ifndef SEMAPHORES_NOMMES while(sem_wait(&((*s_etat_processus) .semaphore_fork)) != 0) # else while(sem_wait((*s_etat_processus) .semaphore_fork) != 0) # endif { (*s_etat_processus).erreur_systeme = d_es_processus; } (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier; return; } if (ios <= 0) { nanosleep(&attente, NULL); INCR_GRANULARITE(attente.tv_nsec); } else { attente.tv_sec = 0; attente.tv_nsec = GRANULARITE_us * 1000; } scrutation_injection(s_etat_processus); if ((*s_etat_processus).var_volatile_requete_arret == -1) { if (ios >= 0) { longueur_effective = ios; } break; } // Une donnée a été reçue. if (ios >= 0) { longueur_effective = ios; position_initiale = 0; presence_indicateur = d_faux; do { if (tampon_lecture[position_initiale] == '{') { presence_indicateur = d_vrai; break; } position_initiale++; } while(position_initiale < longueur_effective); if (presence_indicateur == d_vrai) { position_finale = position_initiale + 1; presence_chaine = d_faux; presence_indicateur = d_faux; niveau = 1; while(position_finale < longueur_effective) { caractere = tampon_lecture[position_finale]; if (caractere == '"') { if (position_finale > 0) { if (tampon_lecture[position_finale - 1] != '\\') { presence_chaine = (presence_chaine == d_vrai) ? d_faux : d_vrai; } } else { presence_chaine = (presence_chaine == d_vrai) ? d_faux : d_vrai; } } else { if (presence_chaine == d_faux) { if (caractere == '{') { niveau++; } else if (caractere == '}') { niveau--; } } } if (niveau == 0) { presence_indicateur = d_vrai; trame_complete = d_vrai; break; } position_finale++; } } // On retire une trame du buffer. if (trame_complete == d_vrai) { if ((*((struct_socket *) (*s_objet_argument_1).objet)) .domaine == PF_UNIX) { do { longueur_adresse = sizeof(adresse_unix); recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, tampon_lecture, (size_t) longueur_effective, 0, (struct sockaddr *) &adresse_unix, &longueur_adresse); } while((ios == -1) && (errno == EINTR)); } else if ((*((struct_socket *) (*s_objet_argument_1) .objet)).domaine == PF_INET) { do { longueur_adresse = sizeof(adresse_ipv4); recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, tampon_lecture, (size_t) longueur_effective, 0, (struct sockaddr *) &adresse_ipv4, &longueur_adresse); } while((ios == -1) && (errno == EINTR)); } else if ((*((struct_socket *) (*s_objet_argument_1) .objet)) .domaine == PF_INET6) { # ifdef IPV6 do { longueur_adresse = sizeof(adresse_ipv6); recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, tampon_lecture, (size_t) longueur_effective, 0, (struct sockaddr *) &adresse_ipv6, &longueur_adresse); } while((ios == -1) && (errno == EINTR)); # else if ((*s_etat_processus).langue == 'F') { printf("+++Attention : Support du protocole" " IPv6 indisponible\n"); } else { printf("+++Warning : IPv6 support " "unavailable\n"); } # endif } longueur_effective = ios; } else { // Si on a lu toute une trame et qu'on n'a pas // réussi à en trouver la structure, on remonte // une erreur de syntaxe. if (longueur_effective == ios) { if ((*((struct_socket *) (*s_objet_argument_1) .objet)).domaine == PF_UNIX) { do { longueur_adresse = sizeof(adresse_unix); recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)) .socket, tampon_lecture, (size_t) longueur_effective, 0, (struct sockaddr *) &adresse_unix, &longueur_adresse); } while((ios == -1) && (errno == EINTR)); } else if ((*((struct_socket *) (*s_objet_argument_1) .objet)).domaine == PF_INET) { do { longueur_adresse = sizeof(adresse_ipv4); recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)) .socket, tampon_lecture, (size_t) longueur_effective, 0, (struct sockaddr *) &adresse_ipv4, &longueur_adresse); } while((ios == -1) && (errno == EINTR)); } else if ((*((struct_socket *) (*s_objet_argument_1) .objet)) .domaine == PF_INET6) { # ifdef IPV6 do { longueur_adresse = sizeof(adresse_ipv6); recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)) .socket, tampon_lecture, (size_t) longueur_effective, 0, (struct sockaddr *) &adresse_ipv6, &longueur_adresse); } while((ios == -1) && (errno == EINTR)); # else if ((*s_etat_processus).langue == 'F') { printf("+++Attention : Support du protocole" " IPv6 indisponible\n"); } else { printf("+++Warning : IPv6 support " "unavailable\n"); } # endif } liberation(s_etat_processus, s_objet_argument_1); free(tampon_lecture); (*s_etat_processus).erreur_execution = d_ex_syntaxe; return; } } } # ifndef SEMAPHORES_NOMMES while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) # else while(sem_wait((*s_etat_processus).semaphore_fork) != 0) # endif { if (errno == EINTR) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } } if ((*s_etat_processus).var_volatile_requete_arret == -1) { /* * Si le père tue le processus courant grâce au signal * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement * correspond à l'utilisation de STOP sur le processus * en cours. La variable longueur_effective vaut '-1'. */ free(tampon_lecture); liberation(s_etat_processus, s_objet_argument_1); return; } if (longueur_effective == -1) { free(tampon_lecture); liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier; return; } } while(trame_complete == d_faux); tampon_lecture[++position_finale] = d_code_fin_chaine; tampon = (*s_etat_processus).instruction_courante; (*s_etat_processus).instruction_courante = tampon_lecture; indicateur_48 = test_cfsf(s_etat_processus, 48); cf(s_etat_processus, 48); (*s_etat_processus).type_en_cours = NON; recherche_type(s_etat_processus); if ((*s_etat_processus).erreur_execution != d_ex) { (*s_etat_processus).instruction_courante = tampon; free(tampon_lecture); if (indicateur_48 == d_vrai) { sf(s_etat_processus, 48); } else { cf(s_etat_processus, 48); } if ((*s_etat_processus).var_volatile_requete_arret == -1) { (*s_etat_processus).erreur_execution = d_ex; } liberation(s_etat_processus, s_objet_argument_1); return; } if (indicateur_48 == d_vrai) { sf(s_etat_processus, 48); } else { cf(s_etat_processus, 48); } (*s_etat_processus).instruction_courante = tampon; /* * Création de la liste de sortie */ if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet_type) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*s_objet_resultat).objet = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_liste_chainee *) (*s_objet_resultat).objet)) .donnee = s_objet_type; if (((*((struct_liste_chainee *) (*s_objet_resultat).objet)) .suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) .suivant = NULL; if ((s_objet_adresse = allocation(s_etat_processus, LST)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) .donnee = s_objet_adresse; /* * Les informations concernant la cible sont valides si * la socket est non connectée et des domaines INET ou INET6. * Dans tous les autres cas, on renvoie une liste vide. */ if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine == PF_UNIX) || (strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type, "STREAM") == 0) || (strcmp((*((struct_socket *) (*s_objet_argument_1).objet)) .type, "SEQUENTIAL DATAGRAM") == 0)) { (*s_objet_adresse).objet = NULL; } else if ((*((struct_socket *) (*s_objet_argument_1).objet)) .domaine == PF_INET) { if (((*s_objet_adresse).objet = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) .donnee = allocation(s_etat_processus, VIN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_vecteur *) (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)).donnee).objet)).taille = 4; if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)).donnee).objet)).tableau = malloc(4 * sizeof(integer8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } ((integer8 *) (*((struct_vecteur *) (*(*((struct_liste_chainee *) (*s_objet_adresse) .objet)).donnee).objet)).tableau)[0] = (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF; ((integer8 *) (*((struct_vecteur *) (*(*((struct_liste_chainee *) (*s_objet_adresse) .objet)).donnee).objet)).tableau)[1] = (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF; ((integer8 *) (*((struct_vecteur *) (*(*((struct_liste_chainee *) (*s_objet_adresse) .objet)).donnee).objet)).tableau)[2] = (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF; ((integer8 *) (*((struct_vecteur *) (*(*((struct_liste_chainee *) (*s_objet_adresse) .objet)).donnee).objet)).tableau)[3] = ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF; if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) .suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) .suivant).donnee = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((integer8 *) (*(*(*((struct_liste_chainee *) (*s_objet_adresse).objet)).suivant).donnee).objet)) = (integer8) ntohs(adresse_ipv4.sin_port); (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) .suivant).suivant = NULL; } else if ((*((struct_socket *) (*s_objet_argument_1).objet)) .domaine == PF_INET6) { # ifdef IPV6 if (((*s_objet_adresse).objet = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) .donnee = allocation(s_etat_processus, VIN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_vecteur *) (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)).donnee).objet)).taille = 16; if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)).donnee).objet)).tableau = malloc(16 * sizeof(integer8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < 16; i++) { ((integer8 *) (*((struct_vecteur *) (*(*((struct_liste_chainee *) (*s_objet_adresse) .objet)).donnee).objet)).tableau)[0] = adresse_ipv6.sin6_addr.s6_addr[i]; } if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) .suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) .suivant).donnee = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((integer8 *) (*(*(*((struct_liste_chainee *) (*s_objet_adresse).objet)).suivant).donnee).objet)) = (integer8) ntohs(adresse_ipv6.sin6_port); (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) .suivant).suivant = NULL; # else if ((*s_etat_processus).langue == 'F') { printf("+++Attention : Support du protocole" " IPv6 indisponible\n"); } else { printf("+++Warning : IPv6 support " "unavailable\n"); } # endif } else { longueur_adresse = 0; recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, tampon_lecture, (size_t) position_finale, MSG_DONTWAIT, NULL, &longueur_adresse); } free(tampon_lecture); if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_objet_resultat) == d_erreur) { return; } } else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'Y') { // socket non formatée longueur_questure = 4096; longueur_effective = 0; tampon_lecture = NULL; attente.tv_sec = 0; attente.tv_nsec = GRANULARITE_us * 1000; trame_complete = d_faux; position_initiale = 0; position_finale = 0; do { presence_indicateur = d_faux; if ((tampon_lecture = realloc(tampon_lecture, ((size_t) (longueur_effective + longueur_questure) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } # ifndef SEMAPHORES_NOMMES if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) # else if (sem_post((*s_etat_processus).semaphore_fork) != 0) # endif { (*s_etat_processus).erreur_systeme = d_es_processus; return; } if ((*((struct_socket *) (*s_objet_argument_1).objet)) .domaine == PF_UNIX) { longueur_adresse = sizeof(adresse_unix); do { ios = (int) recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, tampon_lecture, (size_t) (longueur_effective + longueur_questure), MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) &adresse_unix, &longueur_adresse); } while((ios == -1) && (errno == EINTR)); } else if ((*((struct_socket *) (*s_objet_argument_1).objet)) .domaine == PF_INET) { longueur_adresse = sizeof(adresse_ipv4); do { ios = (int) recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, tampon_lecture, (size_t) (longueur_effective + longueur_questure), MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) &adresse_ipv4, &longueur_adresse); } while((ios == -1) && (errno == EINTR)); } else if ((*((struct_socket *) (*s_objet_argument_1).objet)) .domaine == PF_INET6) { # ifdef IPV6 longueur_adresse = sizeof(adresse_ipv6); do { ios = (int) recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, tampon_lecture, (size_t) (longueur_effective + longueur_questure), MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) &adresse_ipv6, &longueur_adresse); } while((ios == -1) && (errno == EINTR)); # else if ((*s_etat_processus).langue == 'F') { printf("+++Attention : Support du protocole" " IPv6 indisponible\n"); } else { printf("+++Warning : IPv6 support " "unavailable\n"); } longueur_adresse = 0; longueur_effective = 0; ios = 0; # endif } else { free(tampon_lecture); liberation(s_etat_processus, s_objet_argument_1); # ifndef SEMAPHORES_NOMMES while(sem_wait(&((*s_etat_processus) .semaphore_fork)) != 0) # else while(sem_wait((*s_etat_processus) .semaphore_fork) != 0) # endif { (*s_etat_processus).erreur_systeme = d_es_processus; } (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier; return; } if (ios <= 0) { nanosleep(&attente, NULL); INCR_GRANULARITE(attente.tv_nsec); } else { attente.tv_sec = 0; attente.tv_nsec = GRANULARITE_us * 1000; } scrutation_injection(s_etat_processus); if ((*s_etat_processus).var_volatile_requete_arret == -1) { if (ios >= 0) { longueur_effective += ios; } break; } // Une donnée a été reçue. if (ios == (longueur_effective + longueur_questure)) { longueur_effective = ios; position_initiale = 0; presence_indicateur = d_faux; } else if (ios > 0) { // On retire une trame du buffer. if ((*((struct_socket *) (*s_objet_argument_1).objet)) .domaine == PF_UNIX) { do { longueur_adresse = sizeof(adresse_unix); recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, tampon_lecture, (size_t) longueur_effective, 0, (struct sockaddr *) &adresse_unix, &longueur_adresse); } while((ios == -1) && (errno == EINTR)); } else if ((*((struct_socket *) (*s_objet_argument_1) .objet)).domaine == PF_INET) { do { longueur_adresse = sizeof(adresse_ipv4); recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, tampon_lecture, (size_t) longueur_effective, 0, (struct sockaddr *) &adresse_ipv4, &longueur_adresse); } while((ios == -1) && (errno == EINTR)); } else if ((*((struct_socket *) (*s_objet_argument_1) .objet)) .domaine == PF_INET6) { # ifdef IPV6 do { longueur_adresse = sizeof(adresse_ipv6); recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, tampon_lecture, (size_t) longueur_effective, 0, (struct sockaddr *) &adresse_ipv6, &longueur_adresse); } while((ios == -1) && (errno == EINTR)); # else if ((*s_etat_processus).langue == 'F') { printf("+++Attention : Support du protocole" " IPv6 indisponible\n"); } else { printf("+++Warning : IPv6 support " "unavailable\n"); } # endif } longueur_effective = ios; trame_complete = d_vrai; } # ifndef SEMAPHORES_NOMMES while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) # else while(sem_wait((*s_etat_processus).semaphore_fork) != 0) # endif { if (errno == EINTR) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } } if ((*s_etat_processus).var_volatile_requete_arret == -1) { /* * Si le père tue le processus courant grâce au signal * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement * correspond à l'utilisation de STOP sur le processus * en cours. La variable longueur_effective vaut '-1'. */ free(tampon_lecture); liberation(s_etat_processus, s_objet_argument_1); return; } if (longueur_effective == -1) { free(tampon_lecture); liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier; return; } } while(trame_complete == d_faux); /* * Création de la liste de sortie */ ptr = tampon_lecture; if ((s_objet_type = lecture_fichier_non_formate(s_etat_processus, &ptr, longueur_effective, d_faux)) == NULL) { free(tampon_lecture); (*s_etat_processus).erreur_execution = d_ex_syntaxe; return; } if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*s_objet_resultat).objet = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_liste_chainee *) (*s_objet_resultat).objet)) .donnee = s_objet_type; if (((*((struct_liste_chainee *) (*s_objet_resultat).objet)) .suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) .suivant = NULL; if ((s_objet_adresse = allocation(s_etat_processus, LST)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant) .donnee = s_objet_adresse; /* * Les informations concernant la cible sont valides si * la socket est non connectée et des domaines INET ou INET6. * Dans tous les autres cas, on renvoie une liste vide. */ if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine == PF_UNIX) || (strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type, "STREAM") == 0) || (strcmp((*((struct_socket *) (*s_objet_argument_1).objet)) .type, "SEQUENTIAL DATAGRAM") == 0)) { (*s_objet_adresse).objet = NULL; } else if ((*((struct_socket *) (*s_objet_argument_1).objet)) .domaine == PF_INET) { if (((*s_objet_adresse).objet = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) .donnee = allocation(s_etat_processus, VIN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_vecteur *) (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)).donnee).objet)).taille = 4; if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)).donnee).objet)).tableau = malloc(4 * sizeof(integer8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } ((integer8 *) (*((struct_vecteur *) (*(*((struct_liste_chainee *) (*s_objet_adresse) .objet)).donnee).objet)).tableau)[0] = (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF; ((integer8 *) (*((struct_vecteur *) (*(*((struct_liste_chainee *) (*s_objet_adresse) .objet)).donnee).objet)).tableau)[1] = (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF; ((integer8 *) (*((struct_vecteur *) (*(*((struct_liste_chainee *) (*s_objet_adresse) .objet)).donnee).objet)).tableau)[2] = (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF; ((integer8 *) (*((struct_vecteur *) (*(*((struct_liste_chainee *) (*s_objet_adresse) .objet)).donnee).objet)).tableau)[3] = ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF; if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) .suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) .suivant).donnee = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((integer8 *) (*(*(*((struct_liste_chainee *) (*s_objet_adresse).objet)).suivant).donnee).objet)) = (integer8) ntohs(adresse_ipv4.sin_port); (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) .suivant).suivant = NULL; } else if ((*((struct_socket *) (*s_objet_argument_1).objet)) .domaine == PF_INET6) { # ifdef IPV6 if (((*s_objet_adresse).objet = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) .donnee = allocation(s_etat_processus, VIN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_vecteur *) (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)).donnee).objet)).taille = 16; if (((*((struct_vecteur *) (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)).donnee).objet)).tableau = malloc(16 * sizeof(integer8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < 16; i++) { ((integer8 *) (*((struct_vecteur *) (*(*((struct_liste_chainee *) (*s_objet_adresse) .objet)).donnee).objet)).tableau)[0] = adresse_ipv6.sin6_addr.s6_addr[i]; } if (((*((struct_liste_chainee *) (*s_objet_adresse).objet)) .suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) .suivant).donnee = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((integer8 *) (*(*(*((struct_liste_chainee *) (*s_objet_adresse).objet)).suivant).donnee).objet)) = (integer8) ntohs(adresse_ipv6.sin6_port); (*(*((struct_liste_chainee *) (*s_objet_adresse).objet)) .suivant).suivant = NULL; # else if ((*s_etat_processus).langue == 'F') { printf("+++Attention : Support du protocole" " IPv6 indisponible\n"); } else { printf("+++Warning : IPv6 support " "unavailable\n"); } # endif } else { longueur_adresse = 0; recvfrom((*((struct_socket *) (*s_objet_argument_1).objet)).socket, tampon_lecture, (size_t) position_finale, MSG_DONTWAIT, NULL, &longueur_adresse); } free(tampon_lecture); if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_objet_resultat) == d_erreur) { return; } } else { // FLOW longueur_questure = 256; do { if ((tampon_lecture = malloc((((size_t) longueur_questure) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } # ifndef SEMAPHORES_NOMMES if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) # else if (sem_post((*s_etat_processus).semaphore_fork) != 0) # endif { (*s_etat_processus).erreur_systeme = d_es_processus; return; } 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, (long unsigned int) 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, (long unsigned int) 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, (long unsigned int) longueur_questure, MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *) &adresse_ipv6, &longueur_adresse); # else if ((*s_etat_processus).langue == 'F') { printf("+++Attention : Support du protocole" " IPv6 indisponible\n"); } else { printf("+++Warning : IPv6 support " "unavailable\n"); } longueur_adresse = 0; longueur_effective = 0; # endif } else { free(tampon_lecture); liberation(s_etat_processus, s_objet_argument_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; 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)) != 0) # else while(sem_wait((*s_etat_processus).semaphore_fork) != 0) # endif { if (errno != EINTR) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } } if ((*s_etat_processus).var_volatile_requete_arret == -1) { /* * Si le père tue le processus courant grâce au signal * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement * correspond à l'utilisation de STOP sur le processus * en cours. La variable longueur_effective vaut '-1'. */ free(tampon_lecture); liberation(s_etat_processus, s_objet_argument_1); return; } if (longueur_effective == -1) { free(tampon_lecture); liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier; return; } 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((size_t) 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_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_1).objet)).socket, tampon_lecture, (long unsigned int) 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, (long unsigned int) 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, (long unsigned int) 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, (long unsigned int) longueur_effective, 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 { (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } liberation(s_etat_processus, s_objet_argument_1); return; } // vim: ts=4