[BACK]Return to instructions_r4.c CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/instructions_r4.c between versions 1.2 and 1.56

version 1.2, 2010/01/27 22:22:15 version 1.56, 2012/06/19 09:59:34
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.10    RPL/2 (R) version 4.1.9
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2012 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 20 Line 20
 */  */
   
   
 #include "rpl.conv.h"  #include "rpl-conv.h"
   
   
 /*  /*
Line 751  instruction_relax(struct_processus *s_et Line 751  instruction_relax(struct_processus *s_et
 void  void
 instruction_rewind(struct_processus *s_etat_processus)  instruction_rewind(struct_processus *s_etat_processus)
 {  {
     file                            *descripteur;      struct_descripteur_fichier      *descripteur;
   
     struct_objet                    *s_objet_argument;      struct_objet                    *s_objet_argument;
   
Line 803  instruction_rewind(struct_processus *s_e Line 803  instruction_rewind(struct_processus *s_e
             return;              return;
         }          }
   
         if (fseek(descripteur, (long) 0, SEEK_SET) != 0)          if ((*descripteur).type == 'C')
           {
               if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_SET) != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   return;
               }
           }
           else
         {          {
             liberation(s_etat_processus, s_objet_argument);              liberation(s_etat_processus, s_objet_argument);
   
             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;              (*s_etat_processus).erreur_execution = d_ex_erreur_type_fichier;
             return;              return;
         }          }
     }      }
Line 838  instruction_rewind(struct_processus *s_e Line 846  instruction_rewind(struct_processus *s_e
 void  void
 instruction_read(struct_processus *s_etat_processus)  instruction_read(struct_processus *s_etat_processus)
 {  {
     file                            *descripteur;      const char                      *queue;
   
       int                             c;
       int                             ios;
   
       integer8                        ancienne_longueur_effective;
       integer8                        element;
       integer8                        i;
       integer8                        id;
       integer8                        position_clef;
       integer8                        longueur_effective;
       integer8                        longueur_enregistrement;
       integer8                        longueur_questure;
       integer8                        niveau;
       integer8                        pointeur;
       integer8                        position_finale;
       integer8                        position_initiale;
   
     logical1                        indicateur_48;      logical1                        indicateur_48;
     logical1                        presence_chaine;      logical1                        presence_chaine;
     logical1                        presence_indicateur;      logical1                        presence_indicateur;
   
     long                            longueur_effective;  
     long                            longueur_enregistrement;  
     long                            longueur_questure;  
     long                            niveau;  
     long                            pointeur;  
     long                            position_finale;  
     long                            position_initiale;  
   
     socklen_t                       longueur_adresse;      socklen_t                       longueur_adresse;
   
       sqlite3_stmt                    *ppStmt;
   
     struct flock                    lock;      struct flock                    lock;
   
       struct pollfd                   poll_fd;
   
     struct sockaddr_un              adresse_unix;      struct sockaddr_un              adresse_unix;
     struct sockaddr_in              adresse_ipv4;      struct sockaddr_in              adresse_ipv4;
   #   ifdef IPV6
     struct sockaddr_in6             adresse_ipv6;      struct sockaddr_in6             adresse_ipv6;
   #   endif
   
     struct timespec                 attente;      struct timespec                 attente;
   
       struct_descripteur_fichier      *descripteur;
   
       struct_liste_chainee            *l_element_courant;
       struct_liste_chainee            *l_element_inclus;
       struct_liste_chainee            *l_element_suivant;
   
     struct_objet                    *s_objet_adresse;      struct_objet                    *s_objet_adresse;
     struct_objet                    *s_objet_argument;      struct_objet                    *s_objet_argument_1;
       struct_objet                    *s_objet_argument_2;
       struct_objet                    *s_objet_element;
     struct_objet                    *s_objet_resultat;      struct_objet                    *s_objet_resultat;
     struct_objet                    *s_objet_type;      struct_objet                    *s_objet_type;
   
     unsigned char                   caractere;      unsigned char                   caractere;
       unsigned char                   *clef_utf8;
       unsigned char                   *commande;
       unsigned char                   poubelle[256];
       unsigned char                   *ptr;
     unsigned char                   *tampon_lecture;      unsigned char                   *tampon_lecture;
     unsigned char                   *tampon;      unsigned char                   *tampon;
       unsigned char                   *tampon2;
     unsigned long                   i;      unsigned char                   type_enregistrement;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
     attente.tv_sec = 0;  
     attente.tv_nsec = GRANULARITE_us * 1000;  
   
     if ((*s_etat_processus).affichage_arguments == 'Y')      if ((*s_etat_processus).affichage_arguments == 'Y')
     {      {
         printf("\n  READ ");          printf("\n  READ ");
Line 891  instruction_read(struct_processus *s_eta Line 922  instruction_read(struct_processus *s_eta
             printf("(read a record of a file)\n\n");              printf("(read a record of a file)\n\n");
         }          }
   
         printf("    1: %s, %s\n", d_FCH, d_SCK);          printf("    1: %s, %s\n\n", d_FCH, d_SCK);
         printf("    To be fixed !\n");  
   
           printf("    2: %s, %s\n", d_INT, d_CHN);
           printf("    1: %s\n", d_FCH);
         return;          return;
     }      }
     else if ((*s_etat_processus).test_instruction == 'Y')      else if ((*s_etat_processus).test_instruction == 'Y')
Line 904  instruction_read(struct_processus *s_eta Line 936  instruction_read(struct_processus *s_eta
   
     if (test_cfsf(s_etat_processus, 31) == d_vrai)      if (test_cfsf(s_etat_processus, 31) == d_vrai)
     {      {
         if (empilement_pile_last(s_etat_processus, 1) == d_erreur)          if ((*s_etat_processus).l_base_pile == NULL)
         {          {
               (*s_etat_processus).erreur_execution = d_ex_manque_argument;
             return;              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),      if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
             &s_objet_argument) == d_erreur)              &s_objet_argument_1) == d_erreur)
     {      {
         (*s_etat_processus).erreur_execution = d_ex_manque_argument;          (*s_etat_processus).erreur_execution = d_ex_manque_argument;
         return;          return;
     }      }
   
     if ((*s_objet_argument).type == FCH)      if ((*s_objet_argument_1).type == FCH)
     {      {
           if ((descripteur = descripteur_fichier(s_etat_processus,
                   (struct_fichier *) (*s_objet_argument_1).objet)) == NULL)
           {
               return;
           }
   
         /*          /*
          * Vérification des verrous           * Vérification des verrous
          */           */
Line 929  instruction_read(struct_processus *s_eta Line 994  instruction_read(struct_processus *s_eta
         lock.l_len = 0;          lock.l_len = 0;
         lock.l_pid = getpid();          lock.l_pid = getpid();
   
         if ((descripteur = descripteur_fichier(s_etat_processus,          if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock)
                 (struct_fichier *) (*s_objet_argument).objet)) == NULL)                  == -1)
         {  
             return;  
         }  
   
         if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)  
         {          {
             liberation(s_etat_processus, s_objet_argument);              liberation(s_etat_processus, s_objet_argument_1);
   
             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;              (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
             return;              return;
Line 945  instruction_read(struct_processus *s_eta Line 1005  instruction_read(struct_processus *s_eta
   
         if (lock.l_type != F_UNLCK)          if (lock.l_type != F_UNLCK)
         {          {
             liberation(s_etat_processus, s_objet_argument);              liberation(s_etat_processus, s_objet_argument_1);
   
             (*s_etat_processus).erreur_execution =              (*s_etat_processus).erreur_execution =
                     d_ex_fichier_verrouille;                      d_ex_fichier_verrouille;
Line 956  instruction_read(struct_processus *s_eta Line 1016  instruction_read(struct_processus *s_eta
          * Vérification de l'autorisation de lecture           * Vérification de l'autorisation de lecture
          */           */
   
         if ((*((struct_fichier *) (*s_objet_argument).objet)).protection == 'W')          if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection
                   == 'W')
         {          {
             liberation(s_etat_processus, s_objet_argument);              liberation(s_etat_processus, s_objet_argument_1);
   
             (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;              (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
             return;              return;
         }          }
         else if ((*((struct_fichier *) (*s_objet_argument).objet)).protection          else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection
                 == 'N')                  == 'N')
         {          {
             if (fflush(descripteur) != 0)              if ((*descripteur).type == 'C')
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                  if (fflush((*descripteur).descripteur_c) != 0)
                 return;                  {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
             }              }
         }          }
   
         if ((*((struct_fichier *) (*s_objet_argument).objet)).binaire == 'N')          if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'N')
         {          {
             /*              /*
              * Fichiers formatés               * Fichiers formatés
              */               */
   
             if ((*((struct_fichier *) (*s_objet_argument).objet)).acces == 'S')              if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
                       == 'S')
             {              {
                 /*                  /*
                  * Fichiers séquentiels                   * Fichiers séquentiels
Line 995  instruction_read(struct_processus *s_eta Line 1060  instruction_read(struct_processus *s_eta
                     return;                      return;
                 }                  }
   
                 if ((position_initiale = ftell(descripteur)) == -1)                  BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
   
                   if ((position_initiale = ftell((*descripteur).descripteur_c))
                           == -1)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                     return;                      return;
Line 1005  instruction_read(struct_processus *s_eta Line 1073  instruction_read(struct_processus *s_eta
                 {                  {
                     longueur_effective = fread(tampon_lecture,                      longueur_effective = fread(tampon_lecture,
                             (size_t) sizeof(unsigned char), longueur_questure,                              (size_t) sizeof(unsigned char), longueur_questure,
                             descripteur);                              (*descripteur).descripteur_c);
   
                     pointeur = 0;                      pointeur = 0;
                     presence_indicateur = d_faux;                      presence_indicateur = d_faux;
Line 1030  instruction_read(struct_processus *s_eta Line 1098  instruction_read(struct_processus *s_eta
   
                 if (presence_indicateur == d_faux)                  if (presence_indicateur == d_faux)
                 {                  {
                     liberation(s_etat_processus, s_objet_argument);                      liberation(s_etat_processus, s_objet_argument_1);
                     free(tampon_lecture);                      free(tampon_lecture);
   
                     (*s_etat_processus).erreur_execution =                      (*s_etat_processus).erreur_execution =
Line 1042  instruction_read(struct_processus *s_eta Line 1110  instruction_read(struct_processus *s_eta
                 presence_chaine = d_faux;                  presence_chaine = d_faux;
                 niveau = 1;                  niveau = 1;
   
                 if (fseek(descripteur, position_finale, SEEK_SET) != 0)                  if (fseek((*descripteur).descripteur_c, position_finale,
                           SEEK_SET) != 0)
                 {                  {
                     liberation(s_etat_processus, s_objet_argument);                      liberation(s_etat_processus, s_objet_argument_1);
                     free(tampon_lecture);                      free(tampon_lecture);
   
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
Line 1055  instruction_read(struct_processus *s_eta Line 1124  instruction_read(struct_processus *s_eta
                 {                  {
                     longueur_effective = fread(tampon_lecture,                      longueur_effective = fread(tampon_lecture,
                             (size_t) sizeof(unsigned char), longueur_questure,                              (size_t) sizeof(unsigned char), longueur_questure,
                             descripteur);                              (*descripteur).descripteur_c);
   
                     pointeur = 0;                      pointeur = 0;
                     presence_indicateur = d_faux;                      presence_indicateur = d_faux;
Line 1064  instruction_read(struct_processus *s_eta Line 1133  instruction_read(struct_processus *s_eta
                     {                      {
                         if (tampon_lecture[pointeur] == '"')                          if (tampon_lecture[pointeur] == '"')
                         {                          {
                             presence_chaine = (presence_chaine == d_vrai)                              if (pointeur > 0)
                                     ? d_faux : d_vrai;                              {
                                   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                          else
                         {                          {
Line 1100  instruction_read(struct_processus *s_eta Line 1180  instruction_read(struct_processus *s_eta
   
                 if (presence_indicateur == d_faux)                  if (presence_indicateur == d_faux)
                 {                  {
                     liberation(s_etat_processus, s_objet_argument);                      liberation(s_etat_processus, s_objet_argument_1);
                     free(tampon_lecture);                      free(tampon_lecture);
   
                     (*s_etat_processus).erreur_execution =                      (*s_etat_processus).erreur_execution =
Line 1119  instruction_read(struct_processus *s_eta Line 1199  instruction_read(struct_processus *s_eta
                     return;                      return;
                 }                  }
   
                 if (fseek(descripteur, position_initiale, SEEK_SET) != 0)                  if (fseek((*descripteur).descripteur_c, position_initiale,
                           SEEK_SET) != 0)
                 {                  {
                     liberation(s_etat_processus, s_objet_argument);                      liberation(s_etat_processus, s_objet_argument_1);
                     free(tampon_lecture);                      free(tampon_lecture);
   
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
Line 1131  instruction_read(struct_processus *s_eta Line 1212  instruction_read(struct_processus *s_eta
                 longueur_effective = fread(tampon_lecture,                  longueur_effective = fread(tampon_lecture,
                         (size_t) sizeof(unsigned char),                          (size_t) sizeof(unsigned char),
                         (size_t) longueur_enregistrement,                          (size_t) longueur_enregistrement,
                         descripteur);                          (*descripteur).descripteur_c);
   
                 if (longueur_effective != longueur_enregistrement)                  if (longueur_effective != longueur_enregistrement)
                 {                  {
Line 1141  instruction_read(struct_processus *s_eta Line 1222  instruction_read(struct_processus *s_eta
   
                 tampon_lecture[longueur_enregistrement] = d_code_fin_chaine;                  tampon_lecture[longueur_enregistrement] = d_code_fin_chaine;
                 tampon = (*s_etat_processus).instruction_courante;                  tampon = (*s_etat_processus).instruction_courante;
                 (*s_etat_processus).instruction_courante = tampon_lecture;  
                   if (((*s_etat_processus).instruction_courante =
                           transliteration(s_etat_processus, tampon_lecture,
                           "UTF-8", d_locale)) == NULL)
                   {
                       (*s_etat_processus).instruction_courante = tampon;
                       liberation(s_etat_processus, s_objet_argument_1);
                       free(tampon_lecture);
                       return;
                   }
   
                 indicateur_48 = test_cfsf(s_etat_processus, 48);                  indicateur_48 = test_cfsf(s_etat_processus, 48);
                 cf(s_etat_processus, 48);                  cf(s_etat_processus, 48);
   
                 recherche_type(s_etat_processus);                  recherche_type(s_etat_processus);
                   free((*s_etat_processus).instruction_courante);
   
                 if ((*s_etat_processus).erreur_execution != d_ex)                  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;                      (*s_etat_processus).instruction_courante = tampon;
                     free(tampon_lecture);                      free(tampon_lecture);
                                           
                     liberation(s_etat_processus, s_objet_argument);                      liberation(s_etat_processus, s_objet_argument_1);
   
                     return;                      return;
                 }                  }
   
Line 1170  instruction_read(struct_processus *s_eta Line 1269  instruction_read(struct_processus *s_eta
                 (*s_etat_processus).instruction_courante = tampon;                  (*s_etat_processus).instruction_courante = tampon;
                 free(tampon_lecture);                  free(tampon_lecture);
             }              }
             else if ((*((struct_fichier *) (*s_objet_argument).objet)).acces              else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
                     == 'D')                      == 'D')
             {              {
                   BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n"));
   
                   if (depilement(s_etat_processus, &((*s_etat_processus)
                           .l_base_pile), &s_objet_argument_2) == d_erreur)
                   {
                       (*s_etat_processus).erreur_execution = d_ex_manque_argument;
                       return;
                   }
   
                   if ((*s_objet_argument_2).type != INT)
                   {
                       liberation(s_etat_processus, s_objet_argument_1);
                       liberation(s_etat_processus, s_objet_argument_2);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_type_argument;
                       return;
                   }
   
                   if (alsprintf(&commande, "select data from data where "
                           "id = %lld", (*((integer8 *) (*s_objet_argument_2)
                           .objet))) < 0)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
                           commande, strlen(commande), &ppStmt, &queue)
                           != SQLITE_OK)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
                   
                   switch(sqlite3_step(ppStmt))
                   {
                       case SQLITE_ROW:
                       {
                           // Résultat attendu
                           break;
                       }
   
                       case SQLITE_DONE:
                       {
                           // Aucun enregistrement
                           if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
   
                           free(commande);
   
                           liberation(s_etat_processus, s_objet_argument_1);
                           liberation(s_etat_processus, s_objet_argument_2);
   
                           (*s_etat_processus).erreur_execution =
                                   d_ex_enregistrement_inexistant;
                           return;
                       }
   
                       default:
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                           return;
                       }
                   }
   
                   if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   tampon = (*s_etat_processus).instruction_courante;
   
                   if ((tampon_lecture = (unsigned char *)
                           sqlite3_column_text(ppStmt, 0)) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   if (((*s_etat_processus).instruction_courante =
                           transliteration(s_etat_processus, tampon_lecture,
                           "UTF-8", d_locale)) == NULL)
                   {
                       (*s_etat_processus).instruction_courante = tampon;
   
                       liberation(s_etat_processus, s_objet_argument_1);
                       liberation(s_etat_processus, s_objet_argument_2);
                       free(commande);
                       return;
                   }
   
                   indicateur_48 = test_cfsf(s_etat_processus, 48);
                   cf(s_etat_processus, 48);
   
                   recherche_type(s_etat_processus);
   
                   if ((*s_etat_processus).erreur_execution != d_ex)
                   {
                       if (indicateur_48 == d_vrai)
                       {
                           sf(s_etat_processus, 48);
                       }
                       else
                       {
                           cf(s_etat_processus, 48);
                       }
   
                       liberation(s_etat_processus, s_objet_argument_1);
                       liberation(s_etat_processus, s_objet_argument_2);
   
                       free((*s_etat_processus).instruction_courante);
                       free(commande);
   
                       (*s_etat_processus).instruction_courante = tampon;
                       return;
                   }
   
                   if (indicateur_48 == d_vrai)
                   {
                       sf(s_etat_processus, 48);
                   }
                   else
                   {
                       cf(s_etat_processus, 48);
                   }
   
                   free((*s_etat_processus).instruction_courante);
                   liberation(s_etat_processus, s_objet_argument_2);
                   (*s_etat_processus).instruction_courante = tampon;
   
                   if (sqlite3_step(ppStmt) != SQLITE_DONE)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   free(commande);
             }              }
             else              else
             {              {
                   BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n"));
   
                   if (depilement(s_etat_processus, &((*s_etat_processus)
                           .l_base_pile), &s_objet_argument_2) == d_erreur)
                   {
                       (*s_etat_processus).erreur_execution = d_ex_manque_argument;
                       return;
                   }
   
                   if ((*s_objet_argument_2).type != CHN)
                   {
                       liberation(s_etat_processus, s_objet_argument_1);
                       liberation(s_etat_processus, s_objet_argument_2);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_type_argument;
                       return;
                   }
   
                   // Récupération de la position de la clef
   
                   if (alsprintf(&commande, "select key from control "
                           "where id = 1") < 0)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
                           commande, strlen(commande), &ppStmt, &queue)
                           != SQLITE_OK)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   if (sqlite3_step(ppStmt) != SQLITE_ROW)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   position_clef = sqlite3_column_int64(ppStmt, 0);
   
                   if (sqlite3_step(ppStmt) != SQLITE_DONE)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   free(commande);
   
                   if ((clef_utf8 = transliteration(s_etat_processus,
                           (unsigned char *) (*s_objet_argument_2).objet,
                           d_locale, "UTF-8")) == NULL)
                   {
                       liberation(s_etat_processus, s_objet_argument_1);
                       liberation(s_etat_processus, s_objet_argument_2);
   
                       return;
                   }
   
                   // Récupération de l'identifiant de la clef
   
                   if (alsprintf(&commande, "select id from key where key = "
                           "'{ \"%s\" }'", clef_utf8) < 0)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
                           commande, strlen(commande), &ppStmt, &queue)
                           != SQLITE_OK)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   switch(sqlite3_step(ppStmt))
                   {
                       case SQLITE_ROW:
                       {
                           // Résultat attendu : une clef correspond.
                           break;
                       }
   
                       case SQLITE_DONE:
                       {
                           // Aucun enregistrement
                           if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
   
                           free(clef_utf8);
                           free(commande);
   
                           liberation(s_etat_processus, s_objet_argument_1);
                           liberation(s_etat_processus, s_objet_argument_2);
   
                           (*s_etat_processus).erreur_execution =
                                   d_ex_enregistrement_inexistant;
                           return;
                       }
   
                       default:
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                           return;
                       }
                   }
   
                   if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
                   {
                       free(clef_utf8);
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   id = sqlite3_column_int64(ppStmt, 0);
   
                   if (sqlite3_step(ppStmt) != SQLITE_DONE)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_erreur_fichier;
                       return;
                   }
   
                   free(commande);
   
                   if (alsprintf(&commande, "select data from data where "
                           "key_id = %lld order by sequence asc", id) < 0)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
                           commande, strlen(commande), &ppStmt, &queue)
                           != SQLITE_OK)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   element = 1;
   
                   do
                   {
                       switch(ios = sqlite3_step(ppStmt))
                       {
                           case SQLITE_ROW:
                           {
                               // Donnée supplémentaire
   
                               if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_erreur_fichier;
                                   return;
                               }
   
                               tampon = (*s_etat_processus).instruction_courante;
   
                               if ((tampon_lecture = (unsigned char *)
                                       sqlite3_column_text(ppStmt, 0)) == NULL)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_erreur_fichier;
                                   return;
                               }
   
                               if (((*s_etat_processus).instruction_courante =
                                       transliteration(s_etat_processus,
                                       tampon_lecture,
                                       "UTF-8", d_locale)) == NULL)
                               {
                                   (*s_etat_processus).instruction_courante =
                                           tampon;
   
                                   liberation(s_etat_processus,
                                           s_objet_argument_1);
                                   liberation(s_etat_processus,
                                           s_objet_argument_2);
   
                                   free(commande);
                                   free(clef_utf8);
                                   return;
                               }
   
                               indicateur_48 = test_cfsf(s_etat_processus, 48);
                               cf(s_etat_processus, 48);
   
                               recherche_type(s_etat_processus);
   
                               if ((*s_etat_processus).erreur_execution != d_ex)
                               {
                                   if (indicateur_48 == d_vrai)
                                   {
                                       sf(s_etat_processus, 48);
                                   }
                                   else
                                   {
                                       cf(s_etat_processus, 48);
                                   }
   
                                   liberation(s_etat_processus,
                                           s_objet_argument_1);
                                   liberation(s_etat_processus,
                                           s_objet_argument_2);
   
                                   free((*s_etat_processus).instruction_courante);
                                   free(commande);
                                   free(clef_utf8);
   
                                   (*s_etat_processus).instruction_courante =
                                           tampon;
                                   return;
                               }
   
                               if (indicateur_48 == d_vrai)
                               {
                                   sf(s_etat_processus, 48);
                               }
                               else
                               {
                                   cf(s_etat_processus, 48);
                               }
   
                               free((*s_etat_processus).instruction_courante);
                               (*s_etat_processus).instruction_courante = tampon;
   
                               element++;
   
                               // Inscription de la clef
   
                               if (element == position_clef)
                               {
                                   if (((*s_etat_processus).instruction_courante =
                                           transliteration(s_etat_processus,
                                           clef_utf8, "UTF-8", d_locale)) == NULL)
                                   {
                                       (*s_etat_processus).instruction_courante =
                                               tampon;
   
                                       liberation(s_etat_processus,
                                               s_objet_argument_1);
                                       liberation(s_etat_processus,
                                               s_objet_argument_2);
   
                                       free(commande);
                                       free(clef_utf8);
                                       return;
                                   }
   
                                   if (alsprintf(&tampon2, "{ \"%s\" }",
                                           (*s_etat_processus)
                                           .instruction_courante) < 0)
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_allocation_memoire;
                                       return;
                                   }
   
                                   free((*s_etat_processus).instruction_courante);
                                   (*s_etat_processus).instruction_courante
                                           = tampon2;
   
                                   indicateur_48 = test_cfsf(s_etat_processus, 48);
                                   cf(s_etat_processus, 48);
   
                                   recherche_type(s_etat_processus);
   
                                   if ((*s_etat_processus).erreur_execution
                                           != d_ex)
                                   {
                                       if (indicateur_48 == d_vrai)
                                       {
                                           sf(s_etat_processus, 48);
                                       }
                                       else
                                       {
                                           cf(s_etat_processus, 48);
                                       }
   
                                       liberation(s_etat_processus,
                                               s_objet_argument_1);
                                       liberation(s_etat_processus,
                                               s_objet_argument_2);
   
                                       free((*s_etat_processus)
                                               .instruction_courante);
                                       free(commande);
                                       free(clef_utf8);
   
                                       (*s_etat_processus).instruction_courante =
                                               tampon;
                                       return;
                                   }
   
                                   if (indicateur_48 == d_vrai)
                                   {
                                       sf(s_etat_processus, 48);
                                   }
                                   else
                                   {
                                       cf(s_etat_processus, 48);
                                   }
   
                                   free((*s_etat_processus).instruction_courante);
                                   (*s_etat_processus).instruction_courante =
                                           tampon;
   
                                   element++;
                               }
   
                               break;
                           }
   
                           case SQLITE_DONE:
                           {
                               // Fin de la liste
                               break;
                           }
   
                           default:
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
                       }
   
                   } while(ios != SQLITE_DONE);
   
                   if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   free(commande);
                   free(clef_utf8);
   
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   if ((s_objet_resultat = allocation(s_etat_processus, LST))
                           == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   l_element_courant = NULL;
                   l_element_inclus = NULL;
   
                   for(element--; element > 0; element--)
                   {
                       if (depilement(s_etat_processus, &((*s_etat_processus)
                               .l_base_pile), &s_objet_argument_2) == d_erreur)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                           return;
                       }
   
                       if ((*s_objet_argument_2).type != LST)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                           return;
                       }
   
                       l_element_inclus = (*s_objet_argument_2).objet;
   
                       if (l_element_inclus != NULL)
                       {
                           while(l_element_inclus != NULL)
                           {
                               if ((*l_element_inclus).suivant == NULL)
                               {
                                   (*l_element_inclus).suivant = l_element_courant;
                                   break;
                               }
   
                               l_element_inclus = (*l_element_inclus).suivant;
                           }
   
                           l_element_courant = (*s_objet_argument_2).objet;
                           (*s_objet_argument_2).objet = NULL;
                       }
   
                       liberation(s_etat_processus, s_objet_argument_2);
                   }
   
                   (*s_objet_resultat).objet = l_element_inclus;
   
                   if (empilement(s_etat_processus,
                           &((*s_etat_processus).l_base_pile),
                           s_objet_resultat) == d_erreur)
                   {
                       return;
                   }
             }              }
         }          }
         else if ((*((struct_fichier *) (*s_objet_argument).objet)).binaire          else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire
                 == 'Y')                  == 'Y')
         {          {
             /*              /*
              * Fichiers non formatés               * 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 (fread(&type_enregistrement, (size_t) sizeof(unsigned char),
                           1, (*descripteur).descripteur_c) != 1)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   if ((type_enregistrement & 0xF0) != 0x40)
                   {
                       // L'enregistrement trouvé n'est pas une liste.
                       // Tout porte à croire que le fichier est corrompu.
                       (*s_etat_processus).erreur_execution =
                               d_ex_fichier_corrompu;
                       return;
                   }
   
                   switch(type_enregistrement)
                   {
                       unsigned char       taille_enregistrement[8];
   
                       case 0x48:
                       {
                           if (fread(taille_enregistrement,
                                   (size_t) sizeof(unsigned char),
                                   1, (*descripteur).descripteur_c) != 1)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
   
                           longueur_enregistrement = taille_enregistrement[0];
                           break;
                       }
   
                       case 0x49:
                       {
                           if (fread(taille_enregistrement,
                                   (size_t) sizeof(unsigned char),
                                   2, (*descripteur).descripteur_c) != 2)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
   
   // A FAIRE conversion de taille_enregistrement en longueur_enregistrement
                           break;
                       }
   
                       case 0x4A:
                       {
                           if (fread(taille_enregistrement,
                                   (size_t) sizeof(unsigned char),
                                   4, (*descripteur).descripteur_c) != 4)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
   
   // A FAIRE conversion de taille_enregistrement en longueur_enregistrement
                           break;
                       }
   
                       case 0x4B:
                       {
                           if (fread(taille_enregistrement,
                                   (size_t) sizeof(unsigned char),
                                   8, (*descripteur).descripteur_c) != 8)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
   
   // A FAIRE conversion de taille_enregistrement en longueur_enregistrement
                           break;
                       }
   
                       default:
                       {
                           longueur_enregistrement = type_enregistrement & 0x07;
                       }
                   }
   
   printf("L=%d\n", longueur_enregistrement);
                   // La variable longueur_enregistrement contient le nombre
                   // d'éléments à lire dans le fichier pour générer la liste
                   // contenant l'enregistrement.
   
                   if ((s_objet_resultat = allocation(s_etat_processus, LST))
                           == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   for(i = 0; i < longueur_enregistrement; i++)
                   {
                       /* A FAIRE
                       s_objet_element = decodage_enregistrement(s_etat_processus,
                               (*descripteur).descripteur_c);
                               */
                       s_objet_element = NULL;
   
                       if (s_objet_element == NULL)
                       {
                           liberation(s_etat_processus, s_objet_resultat);
                           return;
                       }
   
                       if ((*s_objet_resultat).objet == NULL)
                       {
                           if (((*s_objet_resultat).objet = allocation_maillon(
                                   s_etat_processus)) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return;
                           }
   
                           (*((struct_liste_chainee *) (*s_objet_resultat).objet))
                                   .donnee = s_objet_element;
                           l_element_courant = (*s_objet_resultat).objet;
                       }
                       else
                       {
                           if ((l_element_suivant = allocation_maillon(
                                   s_etat_processus)) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return;
                           }
   
                           (*l_element_courant).suivant = l_element_suivant;
                           (*l_element_suivant).donnee = s_objet_element;
                           l_element_courant = l_element_suivant;
                       }
                   }
   
                   // On saute les caractère des gestion de la commande
                   // BACKSPACE.
                   // A FAIRE
               }
         }          }
         else          else
         {          {
             /*              /*
              * Fichiers de type FLOW               * Fichiers de type FLOW
              */               */
   
               if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
                       == 'S')
               {
                   /*
                    * Fichiers séquentiels
                    */
   
                   BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
                   longueur_enregistrement = 0;
   
                   if ((position_initiale = ftell((*descripteur).descripteur_c))
                           == -1)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   do
                   {
                       c = getc((*descripteur).descripteur_c);
                       longueur_enregistrement++;
                   } while((c != '\n') && (c != EOF));
   
                   if (fseek((*descripteur).descripteur_c, position_initiale,
                           SEEK_SET) != 0)
                   {
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   if ((tampon_lecture = malloc((longueur_enregistrement + 1)
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   longueur_effective = fread(tampon_lecture,
                           (size_t) sizeof(unsigned char),
                           (size_t) longueur_enregistrement,
                           (*descripteur).descripteur_c);
   
                   if ((s_objet_resultat = allocation(s_etat_processus, LST))
                           == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if (((*s_objet_resultat).objet =
                           allocation_maillon(s_etat_processus)) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   (*((struct_liste_chainee *) (*s_objet_resultat).objet))
                           .suivant = NULL;
   
                   if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
                           .donnee = allocation(s_etat_processus, CHN)) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   longueur_enregistrement = 1;
   
                   for(i = 0; i < longueur_effective; i++)
                   {
                       if (isprint(tampon_lecture[i]) != 0)
                       {
                           longueur_enregistrement += 4;
                       }
                       else
                       {
                           longueur_enregistrement++;
                       }
                   }
   
                   if ((tampon = malloc(longueur_enregistrement *
                           sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   ptr = tampon;
   
                   for(i = 0; i < longueur_effective; i++)
                   {
                       if (isprint(tampon_lecture[i]) != 0)
                       {
                           (*ptr) = tampon_lecture[i];
                           ptr++;
                       }
                       else
                       {
                           (*ptr) = '\\';
                           ptr++;
                           (*ptr) = 'x';
                           ptr++;
                           sprintf(ptr, "%02X", tampon_lecture[i]);
                           ptr += 2;
                       }
                   }
   
                   (*ptr) = d_code_fin_chaine;
                   free(tampon_lecture);
                   ((*(*((struct_liste_chainee *) (*s_objet_resultat).objet))
                           .donnee)).objet = tampon;
   
                   if (empilement(s_etat_processus,
                           &((*s_etat_processus).l_base_pile),
                           s_objet_resultat) == d_erreur)
                   {
                       return;
                   }
               }
               else
               {
                   liberation(s_etat_processus, s_objet_argument_1);
   
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_type_fichier;
                   return;
               }
         }          }
     }      }
     else if ((*s_objet_argument).type == SCK)       else if ((*s_objet_argument_1).type == SCK) 
     {      {
         /*          /*
          * Vérification de l'autorisation de lecture           * Vérification de l'autorisation de lecture
          */           */
   
         if ((*((struct_socket *) (*s_objet_argument).objet)).protection == 'W')          if ((*((struct_socket *) (*s_objet_argument_1).objet)).protection
                   == 'W')
         {          {
             liberation(s_etat_processus, s_objet_argument);              liberation(s_etat_processus, s_objet_argument_1);
   
             (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;              (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
             return;              return;
Line 1210  instruction_read(struct_processus *s_eta Line 2193  instruction_read(struct_processus *s_eta
          * Vérification de l'écoute de la socket si celle-ci est connectée           * Vérification de l'écoute de la socket si celle-ci est connectée
          */           */
   
         if ((strcmp((*((struct_socket *) (*s_objet_argument).objet)).type,          if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,
                 "STREAM") == 0) || (strcmp((*((struct_socket *)                  "STREAM") == 0) || (strcmp((*((struct_socket *)
                 (*s_objet_argument).objet)).type, "SEQUENTIAL DATAGRAM") == 0))                  (*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM")
                   == 0))
         {          {
             if ((*((struct_socket *) (*s_objet_argument).objet))              if ((*((struct_socket *) (*s_objet_argument_1).objet))
                     .socket_en_ecoute == 'Y')                       .socket_en_ecoute == 'Y') 
             {              {
                 liberation(s_etat_processus, s_objet_argument);                  liberation(s_etat_processus, s_objet_argument_1);
   
                 (*s_etat_processus).erreur_execution = d_ex_socket_en_ecoute;                  (*s_etat_processus).erreur_execution = d_ex_socket_en_ecoute;
                 return;                  return;
             }              }
         }          }
   
         if ((*((struct_socket *) (*s_objet_argument).objet)).binaire == 'N')          if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N')
         { // Socket formatée          { // Socket formatée
             longueur_questure = 256;              longueur_questure = 256;
               longueur_effective = 0;
               tampon_lecture = NULL;
   
               attente.tv_sec = 0;
               attente.tv_nsec = GRANULARITE_us * 1000;
   
               do
               {
                   presence_indicateur = d_faux;
   
                   if ((tampon_lecture = realloc(tampon_lecture,
                           (longueur_effective + longueur_questure)
                           * 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);
                       ios = recvfrom((*((struct_socket *)
                               (*s_objet_argument_1).objet)).socket,
                               tampon_lecture + longueur_effective,
                               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);
                       ios = recvfrom((*((struct_socket *)
                               (*s_objet_argument_1).objet)).socket,
                               tampon_lecture + longueur_effective,
                               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);
                       ios = recvfrom((*((struct_socket *)
                               (*s_objet_argument_1).objet)).socket,
                               tampon_lecture + longueur_effective,
                               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;
                       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);
                       scrutation_injection(s_etat_processus);
                   }
                   else
                   {
                       attente.tv_sec = 0;
                       attente.tv_nsec = GRANULARITE_us * 1000;
                   }
   
                   if ((*s_etat_processus).var_volatile_requete_arret == -1)
                   {
                       longueur_effective += ios;
                       break;
                   }
   
                   // Une donnée a été reçue.
   
                   if (ios >= 0)
                   {
                       ancienne_longueur_effective = longueur_effective;
                       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 == '"')
                               {
                                   presence_chaine =
                                           (presence_chaine == d_vrai)
                                           ? d_faux : d_vrai;
                               }
                               else
                               {
                                   if (presence_chaine == d_faux)
                                   {
                                       if (caractere == '{')
                                       {
                                           niveau++;
                                       }
                                       else if (caractere == '}')
                                       {
                                           niveau--;
                                       }
                                   }
                               }
   
                               if (niveau == 0)
                               {
                                   presence_indicateur = d_vrai;
                                   break;
                               }
   
                               position_finale++;
                           }
                       }
   
                       // On retire du buffer position_finale -
                       // ancienne_longueur_effective octets.
   
                       if ((*((struct_socket *) (*s_objet_argument_1).objet))
                               .domaine == PF_UNIX)
                       {
                           longueur_adresse = sizeof(adresse_unix);
                           ios = recvfrom((*((struct_socket *)
                                   (*s_objet_argument_1).objet)).socket,
                                   poubelle, position_finale
                                   - ancienne_longueur_effective,
                                   MSG_DONTWAIT, (struct sockaddr *)
                                   &adresse_unix, &longueur_adresse);
                       }
                       else if ((*((struct_socket *) (*s_objet_argument_1)
                               .objet)).domaine == PF_INET)
                       {
                           longueur_adresse = sizeof(adresse_ipv4);
                           ios = recvfrom((*((struct_socket *)
                                   (*s_objet_argument_1).objet)).socket,
                                   poubelle, position_finale
                                   - ancienne_longueur_effective,
                                   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);
                           ios = recvfrom((*((struct_socket *)
                                   (*s_objet_argument_1).objet)).socket,
                                   poubelle, position_finale
                                   - ancienne_longueur_effective,
                                   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;
   #                       endif
                       }
   
                       if (presence_indicateur == d_faux)
                       {
                           poll_fd.fd = (*((struct_socket *)
                                   (*s_objet_argument_1).objet)).socket;
                           poll_fd.events = POLLIN;
   
                           while((ios = poll(&poll_fd, 1, 100)) <= 0)
                           {
                               // La fin de la trame n'est pas atteinte
                               // et il reste quelque chose à lire.
   
                               switch(ios)
                               {
                                   case EINTR:
                                   {
                                       break;
                                   }
   
                                   case 0:
                                   {
                                       liberation(s_etat_processus,
                                               s_objet_argument_1);
                                       free(tampon_lecture);
   
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_fin_de_fichier_atteinte;
                                       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(presence_indicateur == d_faux);
   
               tampon_lecture[++position_finale] = d_code_fin_chaine;
               tampon = (*s_etat_processus).instruction_courante;
               (*s_etat_processus).instruction_courante = &(tampon_lecture
                       [position_initiale]);
   
               indicateur_48 = test_cfsf(s_etat_processus, 48);
               cf(s_etat_processus, 48);
   
               recherche_type(s_etat_processus);
   
               if ((*s_etat_processus).erreur_execution != d_ex)
               {
                   (*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;
   
               /*
                * 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,
                           position_finale, MSG_DONTWAIT,
                           NULL, &longueur_adresse);
               }
   
               free(tampon_lecture);
   
               if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                       s_objet_resultat) == d_erreur)
               {
                   return;
               }
           }
           else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire
                   == 'Y')
           { // UNFORMATTED
           }
           else
           { // FLOW
               longueur_questure = 256;
   
             do              do
             {              {
Line 1238  instruction_read(struct_processus *s_eta Line 2793  instruction_read(struct_processus *s_eta
                     return;                      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;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
                 }                  }
   
                   attente.tv_sec = 0;
                   attente.tv_nsec = GRANULARITE_us * 1000;
   
                 for(;;)                  for(;;)
                 {                  {
                     if ((*((struct_socket *) (*s_objet_argument).objet)).domaine                      if ((*((struct_socket *) (*s_objet_argument_1).objet))
                             == PF_UNIX)                              .domaine == PF_UNIX)
                     {                      {
                         longueur_adresse = sizeof(adresse_unix);                          longueur_adresse = sizeof(adresse_unix);
                         longueur_effective = recvfrom((*((struct_socket *)                          longueur_effective = recvfrom((*((struct_socket *)
                                 (*s_objet_argument).objet)).socket,                                  (*s_objet_argument_1).objet)).socket,
                                 tampon_lecture, longueur_questure,                                  tampon_lecture, longueur_questure,
                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)                                  MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                 &adresse_unix, &longueur_adresse);                                  &adresse_unix, &longueur_adresse);
                     }                      }
                     else if ((*((struct_socket *) (*s_objet_argument).objet))                      else if ((*((struct_socket *) (*s_objet_argument_1).objet))
                             .domaine == PF_INET)                              .domaine == PF_INET)
                     {                      {
                         longueur_adresse = sizeof(adresse_ipv4);                          longueur_adresse = sizeof(adresse_ipv4);
                         longueur_effective = recvfrom((*((struct_socket *)                          longueur_effective = recvfrom((*((struct_socket *)
                                 (*s_objet_argument).objet)).socket,                                  (*s_objet_argument_1).objet)).socket,
                                 tampon_lecture, longueur_questure,                                  tampon_lecture, longueur_questure,
                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)                                  MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                 &adresse_ipv4, &longueur_adresse);                                  &adresse_ipv4, &longueur_adresse);
                     }                      }
                     else if ((*((struct_socket *) (*s_objet_argument).objet))                      else if ((*((struct_socket *) (*s_objet_argument_1).objet))
                             .domaine == PF_INET6)                              .domaine == PF_INET6)
                     {                      {
   #                       ifdef IPV6
                         longueur_adresse = sizeof(adresse_ipv6);                          longueur_adresse = sizeof(adresse_ipv6);
                         longueur_effective = recvfrom((*((struct_socket *)                          longueur_effective = recvfrom((*((struct_socket *)
                                 (*s_objet_argument).objet)).socket,                                  (*s_objet_argument_1).objet)).socket,
                                 tampon_lecture, longueur_questure,                                  tampon_lecture, longueur_questure,
                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)                                  MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                 &adresse_ipv6, &longueur_adresse);                                  &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                      else
                     {                      {
                         free(tampon_lecture);                          free(tampon_lecture);
                         liberation(s_etat_processus, s_objet_argument);                          liberation(s_etat_processus, s_objet_argument_1);
   
                         while(sem_wait(&((*s_etat_processus)  #                       ifndef SEMAPHORES_NOMMES
                                 .semaphore_fork)) == -1)                              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)
                             {                              {
Line 1300  instruction_read(struct_processus *s_eta Line 2883  instruction_read(struct_processus *s_eta
                     if (longueur_effective < 0)                      if (longueur_effective < 0)
                     {                      {
                         nanosleep(&attente, NULL);                          nanosleep(&attente, NULL);
                           INCR_GRANULARITE(attente.tv_nsec);
                         scrutation_injection(s_etat_processus);                          scrutation_injection(s_etat_processus);
                     }                      }
   
Line 1310  instruction_read(struct_processus *s_eta Line 2894  instruction_read(struct_processus *s_eta
                     }                      }
                 }                  }
   
                 while(sem_wait(&((*s_etat_processus).semaphore_fork))  #               ifndef SEMAPHORES_NOMMES
                         == -1)                      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)
                     {                      {
Line 1331  instruction_read(struct_processus *s_eta Line 2918  instruction_read(struct_processus *s_eta
                      */                       */
   
                     free(tampon_lecture);                      free(tampon_lecture);
                     liberation(s_etat_processus, s_objet_argument);                      liberation(s_etat_processus, s_objet_argument_1);
                     return;                      return;
                 }                  }
   
                 if (longueur_effective == -1)                  if (longueur_effective == -1)
                 {                  {
                     free(tampon_lecture);                      free(tampon_lecture);
                     liberation(s_etat_processus, s_objet_argument);                      liberation(s_etat_processus, s_objet_argument_1);
   
                     (*s_etat_processus).erreur_execution =                      (*s_etat_processus).erreur_execution =
                             d_ex_erreur_acces_fichier;                              d_ex_erreur_acces_fichier;
                     return;                      return;
                 }                  }
   
                 position_initiale = 0;                  if (longueur_effective == longueur_questure)
                 presence_indicateur = d_faux;  
   
                 do  
                 {                  {
                     if (tampon_lecture[position_initiale] == '{')                      free(tampon_lecture);
                     {                      longueur_questure *= 2;
                         presence_indicateur = d_vrai;                  }
                         break;              } while(longueur_effective == longueur_questure);
                     }  
   
                     position_initiale++;  
                 } while(position_initiale < longueur_effective);  
   
               longueur_enregistrement = 1;
   
                 if (presence_indicateur == d_vrai)              for(i = 0; i < longueur_effective; i++)
               {
                   if (isprint(tampon_lecture[i]) != 0)
                 {                  {
                     position_finale = position_initiale + 1;                      longueur_enregistrement += 4;
                     presence_chaine = d_faux;  
                     presence_indicateur = d_faux;  
                     niveau = 1;  
   
                     while(position_finale < longueur_effective)  
                     {  
                         caractere = tampon_lecture[position_finale];  
   
                         if (caractere == '"')  
                         {  
                             presence_chaine = (presence_chaine == d_vrai)  
                                     ? d_faux : d_vrai;  
                         }  
                         else  
                         {  
                             if (presence_chaine == d_faux)  
                             {  
                                 if (caractere == '{')  
                                 {  
                                     niveau++;  
                                 }  
                                 else if (caractere == '}')  
                                 {  
                                     niveau--;  
                                 }  
                             }  
                         }  
   
                         if (niveau == 0)  
                         {  
                             presence_indicateur = d_vrai;  
                             break;  
                         }  
   
                         position_finale++;  
                     }  
                 }                  }
                   else
                 if (presence_indicateur == d_faux)  
                 {                  {
                     if (longueur_effective < longueur_questure)                      longueur_enregistrement++;
                     {  
                         liberation(s_etat_processus, s_objet_argument);  
                         free(tampon_lecture);  
   
                         (*s_etat_processus).erreur_execution =  
                                 d_ex_fin_de_fichier_atteinte;  
                         return;  
                     }  
   
                     free(tampon_lecture);  
                     longueur_questure *= 2;  
                 }                  }
             } while(presence_indicateur == d_faux);              }
   
             tampon_lecture[++position_finale] = d_code_fin_chaine;  
             tampon = (*s_etat_processus).instruction_courante;  
             (*s_etat_processus).instruction_courante = &(tampon_lecture  
                     [position_initiale]);  
   
             indicateur_48 = test_cfsf(s_etat_processus, 48);  
             cf(s_etat_processus, 48);  
   
             recherche_type(s_etat_processus);              /*
                * Création de la liste de sortie
                */
   
             if ((*s_etat_processus).erreur_execution != d_ex)              if ((s_objet_type = allocation(s_etat_processus, CHN)) == NULL)
             {              {
                 (*s_etat_processus).instruction_courante = tampon;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 free(tampon_lecture);  
                   
                 liberation(s_etat_processus, s_objet_argument);  
   
                 return;                  return;
             }              }
   
             if (indicateur_48 == d_vrai)              if (((*s_objet_type).objet = malloc(longueur_enregistrement *
             {                      sizeof(unsigned char))) == NULL)
                 sf(s_etat_processus, 48);  
             }  
             else  
             {              {
                 cf(s_etat_processus, 48);                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
             }              }
   
             (*s_etat_processus).instruction_courante = tampon;              ptr = (*s_objet_type).objet;
   
             /*              for(i = 0; i < longueur_effective; i++)
              * 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;                  if (isprint(tampon_lecture[i]) != 0)
                 return;                  {
                       (*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))              if ((s_objet_resultat = allocation(s_etat_processus, LST))
                     == NULL)                      == NULL)
             {              {
Line 1499  instruction_read(struct_processus *s_eta Line 3031  instruction_read(struct_processus *s_eta
   
             /*              /*
              * Les informations concernant la cible sont valides si               * Les informations concernant la cible sont valides si
              * la socket est non connectée et des domaines INET ou INET6.               * la socket est non connectée et que les domaines sont
                * INET ou INET6.
              * Dans tous les autres cas, on renvoie une liste vide.               * Dans tous les autres cas, on renvoie une liste vide.
              */               */
   
             if (((*((struct_socket *) (*s_objet_argument).objet)).domaine              if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
                     == PF_UNIX) || (strcmp((*((struct_socket *)                      == PF_UNIX) || (strcmp((*((struct_socket *)
                     (*s_objet_argument).objet)).type, "STREAM") == 0) ||                      (*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
                     (strcmp((*((struct_socket *) (*s_objet_argument).objet))                      (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
                     .type, "SEQUENTIAL DATAGRAM") == 0))                      .type, "SEQUENTIAL DATAGRAM") == 0))
             {              {
                   // POSITION_FINALE peut être utilisée sans être initialisée !
                   // virer position_finale pour longueur_effective
                 longueur_adresse = 0;                  longueur_adresse = 0;
                 recvfrom((*((struct_socket *)                  recvfrom((*((struct_socket *)
                         (*s_objet_argument).objet)).socket, tampon_lecture,                          (*s_objet_argument_1).objet)).socket, tampon_lecture,
                         position_finale, MSG_DONTWAIT,                          position_finale, MSG_DONTWAIT,
                         NULL, &longueur_adresse);                          NULL, &longueur_adresse);
   
                 (*s_objet_adresse).objet = NULL;                  (*s_objet_adresse).objet = NULL;
             }              }
             else if ((*((struct_socket *) (*s_objet_argument).objet))              else if ((*((struct_socket *) (*s_objet_argument_1).objet))
                     .domaine == PF_INET)                      .domaine == PF_INET)
             {              {
                 longueur_adresse = sizeof(adresse_ipv4);                  longueur_adresse = sizeof(adresse_ipv4);
                 recvfrom((*((struct_socket *)                  recvfrom((*((struct_socket *)
                         (*s_objet_argument).objet)).socket, tampon_lecture,                          (*s_objet_argument_1).objet)).socket, tampon_lecture,
                         position_finale, MSG_DONTWAIT,                          position_finale, MSG_DONTWAIT,
                         (struct sockaddr *) &adresse_ipv4, &longueur_adresse);                          (struct sockaddr *) &adresse_ipv4, &longueur_adresse);
   
Line 1590  instruction_read(struct_processus *s_eta Line 3125  instruction_read(struct_processus *s_eta
                 }                  }
   
                 (*((integer8 *) (*(*(*((struct_liste_chainee *)                  (*((integer8 *) (*(*(*((struct_liste_chainee *)
                         (*s_objet_adresse) .objet)).suivant).donnee).objet)) =                          (*s_objet_adresse).objet)).suivant).donnee).objet)) =
                         (integer8) ntohs(adresse_ipv4.sin_port);                          (integer8) ntohs(adresse_ipv4.sin_port);
   
                 (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))                  (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
                         .suivant).suivant = NULL;                          .suivant).suivant = NULL;
             }              }
             else if ((*((struct_socket *) (*s_objet_argument).objet))              else if ((*((struct_socket *) (*s_objet_argument_1).objet))
                     .domaine == PF_INET6)                      .domaine == PF_INET6)
             {              {
   #               ifdef IPV6
                 longueur_adresse = sizeof(adresse_ipv6);                  longueur_adresse = sizeof(adresse_ipv6);
                 recvfrom((*((struct_socket *)                  recvfrom((*((struct_socket *)
                         (*s_objet_argument).objet)).socket, tampon_lecture,                          (*s_objet_argument_1).objet)).socket, tampon_lecture,
                         position_finale, MSG_DONTWAIT,                          position_finale, MSG_DONTWAIT,
                         (struct sockaddr *) &adresse_ipv6, &longueur_adresse);                          (struct sockaddr *) &adresse_ipv6, &longueur_adresse);
   
Line 1660  instruction_read(struct_processus *s_eta Line 3196  instruction_read(struct_processus *s_eta
                 }                  }
   
                 (*((integer8 *) (*(*(*((struct_liste_chainee *)                  (*((integer8 *) (*(*(*((struct_liste_chainee *)
                         (*s_objet_adresse) .objet)).suivant).donnee).objet)) =                          (*s_objet_adresse).objet)).suivant).donnee).objet)) =
                         (integer8) ntohs(adresse_ipv6.sin6_port);                          (integer8) ntohs(adresse_ipv6.sin6_port);
   
                 (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))                  (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
                         .suivant).suivant = NULL;                          .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              else
             {              {
                 longueur_adresse = 0;                  longueur_adresse = 0;
                 recvfrom((*((struct_socket *)                  recvfrom((*((struct_socket *)
                         (*s_objet_argument).objet)).socket, tampon_lecture,                          (*s_objet_argument_1).objet)).socket, tampon_lecture,
                         position_finale, MSG_DONTWAIT,                          position_finale, MSG_DONTWAIT,
                         NULL, &longueur_adresse);                          NULL, &longueur_adresse);
             }              }
Line 1683  instruction_read(struct_processus *s_eta Line 3231  instruction_read(struct_processus *s_eta
                 return;                  return;
             }              }
         }          }
         else  
         {  
             /* FLOW ou UNFORMATTED */  
         }  
     }      }
     else      else
     {      {
Line 1694  instruction_read(struct_processus *s_eta Line 3238  instruction_read(struct_processus *s_eta
         return;          return;
     }      }
   
     liberation(s_etat_processus, s_objet_argument);      liberation(s_etat_processus, s_objet_argument_1);
   
     return;      return;
 }  }
Removed from v.1.2  
changed lines
  Added in v.1.56

CVSweb interface <joel.bertrand@systella.fr>