[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.65 and 1.106

version 1.65, 2012/12/18 13:19:38 version 1.106, 2018/06/01 09:57:27
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.12    RPL/2 (R) version 4.1.29
   Copyright (C) 1989-2012 Dr. BERTRAND Joël    Copyright (C) 1989-2018 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 96  instruction_r_vers_b(struct_processus *s Line 96  instruction_r_vers_b(struct_processus *s
         }          }
         else          else
         {          {
             (*((logical8 *) (*s_objet_resultat).objet)) = (*((integer8 *)              (*((logical8 *) (*s_objet_resultat).objet)) = (logical8)
                     (*s_objet_argument).objet));                      (*((integer8 *) (*s_objet_argument).objet));
         }          }
     }      }
     else      else
Line 850  instruction_read(struct_processus *s_eta Line 850  instruction_read(struct_processus *s_eta
   
     int                             c;      int                             c;
     int                             ios;      int                             ios;
       int                             timeout;
   
     integer8                        ancienne_longueur_effective;  
     integer8                        element;      integer8                        element;
     integer8                        i;      integer8                        i;
     integer8                        id;      integer8                        id;
       integer8                        index;
       integer8                        longueur;
     integer8                        position_clef;      integer8                        position_clef;
   
     integer8                        longueur_effective;      integer8                        longueur_effective;
     integer8                        longueur_enregistrement;      integer8                        longueur_enregistrement;
     integer8                        longueur_questure;      integer8                        longueur_questure;
Line 864  instruction_read(struct_processus *s_eta Line 867  instruction_read(struct_processus *s_eta
     integer8                        position_finale;      integer8                        position_finale;
     integer8                        position_initiale;      integer8                        position_initiale;
   
       logical1                        device;
     logical1                        format_degenere;      logical1                        format_degenere;
       logical1                        format_oriente_ligne;
     logical1                        indicateur_48;      logical1                        indicateur_48;
     logical1                        presence_chaine;      logical1                        presence_chaine;
     logical1                        presence_indicateur;      logical1                        presence_indicateur;
     logical1                        trame_complete;      logical1                        trame_complete;
   
     long                            longueur;  
   
     socklen_t                       longueur_adresse;      socklen_t                       longueur_adresse;
   
     sqlite3_stmt                    *ppStmt;      sqlite3_stmt                    *ppStmt;
   
     struct flock                    lock;      struct flock                    lock;
   
     struct pollfd                   poll_fd;      struct pollfd                   fds[1];
   
     struct sockaddr_un              adresse_unix;      struct sockaddr_un              adresse_unix;
     struct sockaddr_in              adresse_ipv4;      struct sockaddr_in              adresse_ipv4;
Line 886  instruction_read(struct_processus *s_eta Line 889  instruction_read(struct_processus *s_eta
     struct sockaddr_in6             adresse_ipv6;      struct sockaddr_in6             adresse_ipv6;
 #   endif  #   endif
   
       struct termios                  tc;
   
     struct timespec                 attente;      struct timespec                 attente;
   
     struct_descripteur_fichier      *descripteur;      struct_descripteur_fichier      *descripteur;
Line 893  instruction_read(struct_processus *s_eta Line 898  instruction_read(struct_processus *s_eta
     struct_liste_chainee            *l_element_courant;      struct_liste_chainee            *l_element_courant;
     struct_liste_chainee            *l_element_courant_format;      struct_liste_chainee            *l_element_courant_format;
     struct_liste_chainee            *l_element_inclus;      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_1;      struct_objet                    *s_objet_argument_1;
     struct_objet                    *s_objet_argument_2;      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;
   
Line 906  instruction_read(struct_processus *s_eta Line 909  instruction_read(struct_processus *s_eta
     unsigned char                   *clef_utf8;      unsigned char                   *clef_utf8;
     unsigned char                   *commande;      unsigned char                   *commande;
     unsigned char                   *format_chaine;      unsigned char                   *format_chaine;
     unsigned char                   poubelle[256];  
     unsigned char                   *ptr;      unsigned char                   *ptr;
     unsigned char                   *tampon_lecture;      unsigned char                   *tampon_lecture;
     unsigned char                   *tampon;      unsigned char                   *tampon;
     unsigned char                   *tampon2;      unsigned char                   *tampon2;
     unsigned char                   type_enregistrement;      unsigned char                   *tampon3;
   
       int                             vitesses[] =
                           {
                               50, 75, 110, 134, 150, 200, 300, 600,
                               1200, 1800, 2400, 4800, 9600, 19200, 38400,
   #ifdef B57600
                               57600,
   #endif
   #ifdef B115200
                               115200,
   #endif
   #ifdef B230400
                               230400,
   #endif
                               0
                           };
   
       tcflag_t                        vitesses_constantes[] =
                           {
                               B50, B75, B110, B134, B150, B200, B300, B600,
                               B1200, B1800, B2400, B4800, B9600, B19200, B38400,
   #ifdef B57600
                               B57600,
   #endif
   #ifdef B115200
                               B115200,
   #endif
   #ifdef B230400
                               B230400,
   #endif
                               0
                           };
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 1056  instruction_read(struct_processus *s_eta Line 1090  instruction_read(struct_processus *s_eta
                  * Fichiers séquentiels                   * Fichiers séquentiels
                  */                   */
   
                 longueur_questure = 256;                  longueur_questure = 4096;
   
                 if ((tampon_lecture = malloc(longueur_questure *                  if ((tampon_lecture = malloc(((size_t) longueur_questure) *
                         sizeof(unsigned char))) == NULL)                          sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 1077  instruction_read(struct_processus *s_eta Line 1111  instruction_read(struct_processus *s_eta
   
                 do                  do
                 {                  {
                     longueur_effective = fread(tampon_lecture,                      longueur_effective = (integer8) fread(tampon_lecture,
                             (size_t) sizeof(unsigned char), longueur_questure,                              sizeof(unsigned char), (size_t) longueur_questure,
                             (*descripteur).descripteur_c);                              (*descripteur).descripteur_c);
   
                     pointeur = 0;                      pointeur = 0;
Line 1116  instruction_read(struct_processus *s_eta Line 1150  instruction_read(struct_processus *s_eta
                 presence_chaine = d_faux;                  presence_chaine = d_faux;
                 niveau = 1;                  niveau = 1;
   
                 if (fseek((*descripteur).descripteur_c, position_finale,                  if (fseek((*descripteur).descripteur_c, (long) position_finale,
                         SEEK_SET) != 0)                          SEEK_SET) != 0)
                 {                  {
                     liberation(s_etat_processus, s_objet_argument_1);                      liberation(s_etat_processus, s_objet_argument_1);
Line 1128  instruction_read(struct_processus *s_eta Line 1162  instruction_read(struct_processus *s_eta
   
                 do                  do
                 {                  {
                     longueur_effective = fread(tampon_lecture,                      longueur_effective = (integer8) fread(tampon_lecture,
                             (size_t) sizeof(unsigned char), longueur_questure,                              sizeof(unsigned char), (size_t) longueur_questure,
                             (*descripteur).descripteur_c);                              (*descripteur).descripteur_c);
   
                     pointeur = 0;                      pointeur = 0;
Line 1197  instruction_read(struct_processus *s_eta Line 1231  instruction_read(struct_processus *s_eta
                 free(tampon_lecture);                  free(tampon_lecture);
                 longueur_enregistrement = position_finale - position_initiale;                  longueur_enregistrement = position_finale - position_initiale;
   
                 if ((tampon_lecture = malloc((longueur_enregistrement + 1) *                  if ((tampon_lecture = malloc(((size_t)
                           (longueur_enregistrement + 1)) *
                         sizeof(unsigned char))) == NULL)                          sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 1205  instruction_read(struct_processus *s_eta Line 1240  instruction_read(struct_processus *s_eta
                     return;                      return;
                 }                  }
   
                 if (fseek((*descripteur).descripteur_c, position_initiale,                  if (fseek((*descripteur).descripteur_c,
                         SEEK_SET) != 0)                          (long) position_initiale, SEEK_SET) != 0)
                 {                  {
                     liberation(s_etat_processus, s_objet_argument_1);                      liberation(s_etat_processus, s_objet_argument_1);
                     free(tampon_lecture);                      free(tampon_lecture);
Line 1215  instruction_read(struct_processus *s_eta Line 1250  instruction_read(struct_processus *s_eta
                     return;                      return;
                 }                  }
   
                 longueur_effective = fread(tampon_lecture,                  longueur_effective = (integer8) fread(tampon_lecture,
                         (size_t) sizeof(unsigned char),                          sizeof(unsigned char), (size_t) longueur_enregistrement,
                         (size_t) longueur_enregistrement,  
                         (*descripteur).descripteur_c);                          (*descripteur).descripteur_c);
   
                 if (longueur_effective != longueur_enregistrement)                  if (longueur_effective != longueur_enregistrement)
Line 1242  instruction_read(struct_processus *s_eta Line 1276  instruction_read(struct_processus *s_eta
                 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);
   
                   (*s_etat_processus).type_en_cours = NON;
                 recherche_type(s_etat_processus);                  recherche_type(s_etat_processus);
                 free((*s_etat_processus).instruction_courante);                  free((*s_etat_processus).instruction_courante);
   
Line 1297  instruction_read(struct_processus *s_eta Line 1332  instruction_read(struct_processus *s_eta
                     return;                      return;
                 }                  }
   
                 if (alsprintf(&commande, "select data from data where "                  if (alsprintf(s_etat_processus, &commande,
                         "id = %lld", (*((integer8 *) (*s_objet_argument_2)                          "select data from data where id = %lld",
                         .objet))) < 0)                          (*((integer8 *) (*s_objet_argument_2).objet))) < 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 1307  instruction_read(struct_processus *s_eta Line 1342  instruction_read(struct_processus *s_eta
                 }                  }
   
                 if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,                  if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
                         commande, strlen(commande), &ppStmt, &queue)                          commande, (int) strlen(commande), &ppStmt, &queue)
                         != SQLITE_OK)                          != SQLITE_OK)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                     return;                      return;
                 }                  }
                   
                 switch(sqlite3_step(ppStmt))                  attente.tv_sec = 0;
                   attente.tv_nsec = GRANULARITE_us * 1000;
   
                   do
                 {                  {
                     case SQLITE_ROW:                      ios = sqlite3_step(ppStmt);
                     {  
                         // Résultat attendu  
                         break;  
                     }  
   
                     case SQLITE_DONE:                      switch(ios)
                     {                      {
                         // Aucun enregistrement                          case SQLITE_ROW:
                         if (sqlite3_finalize(ppStmt) != SQLITE_OK)  
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              // Résultat attendu
                                     d_es_erreur_fichier;                              break;
                             return;  
                         }                          }
   
                         free(commande);                          case SQLITE_DONE:
                           {
                               // Aucun enregistrement
                               if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_erreur_fichier;
                                   return;
                               }
   
                         liberation(s_etat_processus, s_objet_argument_1);                              free(commande);
                         liberation(s_etat_processus, s_objet_argument_2);  
   
                         (*s_etat_processus).erreur_execution =                              liberation(s_etat_processus, s_objet_argument_1);
                                 d_ex_enregistrement_inexistant;                              liberation(s_etat_processus, s_objet_argument_2);
                         return;  
                     }  
   
                     default:                              (*s_etat_processus).erreur_execution =
                     {                                      d_ex_enregistrement_inexistant;
                         (*s_etat_processus).erreur_systeme =                              return;
                                 d_es_erreur_fichier;                          }
                         return;  
                           case SQLITE_BUSY:
                           case SQLITE_LOCKED:
                           {
                               nanosleep(&attente, NULL);
                               INCR_GRANULARITE(attente.tv_nsec);
                               break;
                           }
   
                           default:
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
                     }                      }
                 }                  } while(ios != SQLITE_ROW);
   
                 if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)                  if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
                 {                  {
Line 1380  instruction_read(struct_processus *s_eta Line 1431  instruction_read(struct_processus *s_eta
                 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);
   
                   (*s_etat_processus).type_en_cours = NON;
                 recherche_type(s_etat_processus);                  recherche_type(s_etat_processus);
   
                 if ((*s_etat_processus).erreur_execution != d_ex)                  if ((*s_etat_processus).erreur_execution != d_ex)
Line 1453  instruction_read(struct_processus *s_eta Line 1505  instruction_read(struct_processus *s_eta
   
                 // Récupération de la position de la clef                  // Récupération de la position de la clef
   
                 if (alsprintf(&commande, "select key from control "                  if (alsprintf(s_etat_processus, &commande,
                         "where id = 1") < 0)                          "select key from control where id = 1") < 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 1462  instruction_read(struct_processus *s_eta Line 1514  instruction_read(struct_processus *s_eta
                 }                  }
   
                 if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,                  if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
                         commande, strlen(commande), &ppStmt, &queue)                          commande, (int) strlen(commande), &ppStmt, &queue)
                         != SQLITE_OK)                          != SQLITE_OK)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                     return;                      return;
                 }                  }
   
                 if (sqlite3_step(ppStmt) != SQLITE_ROW)                  attente.tv_sec = 0;
                   attente.tv_nsec = GRANULARITE_us * 1000;
   
                   do
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      ios = sqlite3_step(ppStmt);
                     return;  
                 }                      if (ios == SQLITE_ROW)
                       {
                           break;
                       }
                       else if ((ios == SQLITE_BUSY) || (ios == SQLITE_LOCKED))
                       {
                           nanosleep(&attente, NULL);
                           INCR_GRANULARITE(attente.tv_nsec);
                       }
                       else
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                           return;
                       }
                   } while(ios != SQLITE_ROW);
   
                 if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)                  if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
                 {                  {
Line 1509  instruction_read(struct_processus *s_eta Line 1579  instruction_read(struct_processus *s_eta
   
                 // Récupération de l'identifiant de la clef                  // Récupération de l'identifiant de la clef
   
                 if (alsprintf(&commande, "select id from key where key = "                  if (alsprintf(s_etat_processus, &commande,
                         "'{ \"%s\" }'", clef_utf8) < 0)                          "select id from key where key = '{ \"%s\" }'",
                           clef_utf8) < 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 1518  instruction_read(struct_processus *s_eta Line 1589  instruction_read(struct_processus *s_eta
                 }                  }
   
                 if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,                  if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
                         commande, strlen(commande), &ppStmt, &queue)                          commande, (int) strlen(commande), &ppStmt, &queue)
                         != SQLITE_OK)                          != SQLITE_OK)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                     return;                      return;
                 }                  }
   
                 switch(sqlite3_step(ppStmt))                  attente.tv_sec = 0;
                   attente.tv_nsec = GRANULARITE_us * 1000;
   
                   do
                 {                  {
                     case SQLITE_ROW:                      ios = sqlite3_step(ppStmt);
                     {  
                         // Résultat attendu : une clef correspond.  
                         break;  
                     }  
   
                     case SQLITE_DONE:                      switch(ios)
                     {                      {
                         // Aucun enregistrement                          case SQLITE_ROW:
                         if (sqlite3_finalize(ppStmt) != SQLITE_OK)  
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              // Résultat attendu : une clef correspond.
                                     d_es_erreur_fichier;                              break;
                             return;  
                         }                          }
   
                         free(clef_utf8);                          case SQLITE_DONE:
                         free(commande);                          {
                               // Aucun enregistrement
                               if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_erreur_fichier;
                                   return;
                               }
   
                         liberation(s_etat_processus, s_objet_argument_1);                              free(clef_utf8);
                         liberation(s_etat_processus, s_objet_argument_2);                              free(commande);
   
                         (*s_etat_processus).erreur_execution =                              liberation(s_etat_processus, s_objet_argument_1);
                                 d_ex_enregistrement_inexistant;                              liberation(s_etat_processus, s_objet_argument_2);
                         return;  
                     }  
   
                     default:                              (*s_etat_processus).erreur_execution =
                     {                                      d_ex_enregistrement_inexistant;
                         (*s_etat_processus).erreur_systeme =                              return;
                                 d_es_erreur_fichier;                          }
                         return;  
                           case SQLITE_BUSY:
                           case SQLITE_LOCKED:
                           {
                               nanosleep(&attente, NULL);
                               INCR_GRANULARITE(attente.tv_nsec);
                               break;
                           }
   
                           default:
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
                     }                      }
                 }                  } while(ios != SQLITE_ROW);
   
                 if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)                  if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
                 {                  {
Line 1586  instruction_read(struct_processus *s_eta Line 1673  instruction_read(struct_processus *s_eta
   
                 free(commande);                  free(commande);
   
                 if (alsprintf(&commande, "select data from data where "                  if (alsprintf(s_etat_processus, &commande,
                           "select data from data where "
                         "key_id = %lld order by sequence asc", id) < 0)                          "key_id = %lld order by sequence asc", id) < 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 1595  instruction_read(struct_processus *s_eta Line 1683  instruction_read(struct_processus *s_eta
                 }                  }
   
                 if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,                  if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
                         commande, strlen(commande), &ppStmt, &queue)                          commande, (int) strlen(commande), &ppStmt, &queue)
                         != SQLITE_OK)                          != SQLITE_OK)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
Line 1604  instruction_read(struct_processus *s_eta Line 1692  instruction_read(struct_processus *s_eta
   
                 element = 1;                  element = 1;
   
                   attente.tv_sec = 0;
                   attente.tv_nsec = GRANULARITE_us * 1000;
   
                 do                  do
                 {                  {
                     switch(ios = sqlite3_step(ppStmt))                      switch(ios = sqlite3_step(ppStmt))
Line 1650  instruction_read(struct_processus *s_eta Line 1741  instruction_read(struct_processus *s_eta
                             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);
   
                               (*s_etat_processus).type_en_cours = NON;
                             recherche_type(s_etat_processus);                              recherche_type(s_etat_processus);
   
                             if ((*s_etat_processus).erreur_execution != d_ex)                              if ((*s_etat_processus).erreur_execution != d_ex)
Line 1712  instruction_read(struct_processus *s_eta Line 1804  instruction_read(struct_processus *s_eta
                                     return;                                      return;
                                 }                                  }
   
                                 if (alsprintf(&tampon2, "{ \"%s\" }",                                  if (alsprintf(s_etat_processus, &tampon2,
                                         (*s_etat_processus)                                          "{ \"%s\" }", (*s_etat_processus)
                                         .instruction_courante) < 0)                                          .instruction_courante) < 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 1728  instruction_read(struct_processus *s_eta Line 1820  instruction_read(struct_processus *s_eta
                                 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);
   
                                   (*s_etat_processus).type_en_cours = NON;
                                 recherche_type(s_etat_processus);                                  recherche_type(s_etat_processus);
   
                                 if ((*s_etat_processus).erreur_execution                                  if ((*s_etat_processus).erreur_execution
Line 1782  instruction_read(struct_processus *s_eta Line 1875  instruction_read(struct_processus *s_eta
                             break;                              break;
                         }                          }
   
                           case SQLITE_BUSY:
                           case SQLITE_LOCKED:
                           {
                               nanosleep(&attente, NULL);
                               INCR_GRANULARITE(attente.tv_nsec);
                               break;
                           }
   
                         default:                          default:
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              (*s_etat_processus).erreur_systeme =
Line 1789  instruction_read(struct_processus *s_eta Line 1890  instruction_read(struct_processus *s_eta
                             return;                              return;
                         }                          }
                     }                      }
   
                 } while(ios != SQLITE_DONE);                  } while(ios != SQLITE_DONE);
   
                 if (sqlite3_finalize(ppStmt) != SQLITE_OK)                  if (sqlite3_finalize(ppStmt) != SQLITE_OK)
Line 1890  instruction_read(struct_processus *s_eta Line 1990  instruction_read(struct_processus *s_eta
   
                 BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));                  BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
   
                 if (fread(&type_enregistrement, (size_t) sizeof(unsigned char),                  if ((s_objet_resultat = lecture_fichier_non_formate(
                         1, (*descripteur).descripteur_c) != 1)                          s_etat_processus, (*descripteur).descripteur_c, -1,
                           d_faux)) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;  
                     return;                      return;
                 }                  }
   
                 if ((type_enregistrement & 0xF0) != 0x40)                  if (empilement(s_etat_processus,
                 {                          &((*s_etat_processus).l_base_pile),
                     // L'enregistrement trouvé n'est pas une liste.                          s_objet_resultat) == d_erreur)
                     // 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;                      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
Line 2054  printf("L=%d\n", longueur_enregistrement Line 2021  printf("L=%d\n", longueur_enregistrement
                 BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));                  BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
                 longueur_enregistrement = 0;                  longueur_enregistrement = 0;
   
                   device = d_faux;
   
                 if ((position_initiale = ftell((*descripteur).descripteur_c))                  if ((position_initiale = ftell((*descripteur).descripteur_c))
                         == -1)                          == -1)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      if (errno == ESPIPE)
                     return;                      {
                           device = d_vrai;
                       }
                       else
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                           return;
                       }
                 }                  }
   
                 l_element_courant_format = (struct_liste_chainee *)                  l_element_courant_format = (struct_liste_chainee *)
Line 2086  printf("L=%d\n", longueur_enregistrement Line 2063  printf("L=%d\n", longueur_enregistrement
                         return;                          return;
                     }                      }
   
                     if ((format_chaine = conversion_majuscule((unsigned char *)                      if ((format_chaine = conversion_majuscule(
                               s_etat_processus, (unsigned char *)
                             (*(*l_element_courant_format).donnee).objet))                              (*(*l_element_courant_format).donnee).objet))
                             == NULL)                              == NULL)
                     {                      {
Line 2095  printf("L=%d\n", longueur_enregistrement Line 2073  printf("L=%d\n", longueur_enregistrement
                         return;                          return;
                     }                      }
   
                     if (strncmp("LENGTH*(", format_chaine, 8) != 0)                      if (strcmp("LINE*(*)", format_chaine) == 0)
                     {                      {
                         liberation(s_etat_processus, s_objet_argument_1);                          format_degenere = d_vrai;
                         liberation(s_etat_processus, s_objet_resultat);                          format_oriente_ligne = d_vrai;
                         free(format_chaine);  
   
                         (*s_etat_processus).erreur_execution =  
                                 d_ex_erreur_format_fichier;  
                         return;  
                     }                      }
                       else
                     longueur = strlen(format_chaine);  
   
                     if (format_chaine[longueur - 1] != ')')  
                     {                      {
                         liberation(s_etat_processus, s_objet_argument_1);                          format_oriente_ligne = d_faux;
                         liberation(s_etat_processus, s_objet_resultat);  
                         free(format_chaine);  
   
                         (*s_etat_processus).erreur_execution =                          if (strncmp("LENGTH*(", format_chaine, 8) != 0)
                                 d_ex_erreur_format_fichier;                          {
                         return;                              liberation(s_etat_processus, s_objet_argument_1);
                     }                              liberation(s_etat_processus, s_objet_resultat);
                               free(format_chaine);
   
                     format_chaine[longueur] = d_code_fin_chaine;                              (*s_etat_processus).erreur_execution =
                                       d_ex_erreur_format_fichier;
                               return;
                           }
   
                     if (format_chaine[8] == '*')                          longueur = (integer8) strlen(format_chaine);
                     {  
                         format_degenere = d_vrai;  
                     }  
                     else  
                     {  
                         // Détermination de la longueur  
                         format_degenere = d_faux;  
   
                         if (sscanf(&(format_chaine[8]), "%ld", &longueur) != 1)                          if (format_chaine[longueur - 1] != ')')
                         {                          {
                             liberation(s_etat_processus, s_objet_argument_1);                              liberation(s_etat_processus, s_objet_argument_1);
                             liberation(s_etat_processus, s_objet_resultat);                              liberation(s_etat_processus, s_objet_resultat);
Line 2140  printf("L=%d\n", longueur_enregistrement Line 2105  printf("L=%d\n", longueur_enregistrement
                                     d_ex_erreur_format_fichier;                                      d_ex_erreur_format_fichier;
                             return;                              return;
                         }                          }
   
                           format_chaine[longueur] = d_code_fin_chaine;
   
                           if (format_chaine[8] == '*')
                           {
                               format_degenere = d_vrai;
                           }
                           else
                           {
                               // Détermination de la longueur
                               format_degenere = d_faux;
   
                               if (sscanf(&(format_chaine[8]), "%lld", &longueur)
                                       != 1)
                               {
                                   liberation(s_etat_processus, s_objet_argument_1);
                                   liberation(s_etat_processus, s_objet_resultat);
                                   free(format_chaine);
   
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_erreur_format_fichier;
                                   return;
                               }
                           }
                     }                      }
   
                     free(format_chaine);                      free(format_chaine);
                       tampon3 = NULL;
   
                     if (format_degenere == d_vrai)                      if (format_degenere == d_vrai)
                     {                      {
                           if (device == d_vrai)
                           {
                               longueur_questure = 4096;
                               index = 0;
   
                               if ((tampon3 = malloc(((size_t) longueur_questure) *
                                       sizeof(unsigned char))) == NULL)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_allocation_memoire;
                                   return;
                               }
   
                               tampon3[index] = d_code_fin_chaine;
   
                               fds[0].fd = fileno((*descripteur).descripteur_c);
                               fds[0].events = POLLIN;
                               fds[0].revents = 0;
   
                               tcgetattr(fileno((*descripteur).descripteur_c),
                                       &tc);
                               timeout = 0;
   
                               for(i = 0; vitesses[i] != 0; i++)
                               {
                                   if (cfgetispeed(&tc) == vitesses_constantes[i])
                                   {
                                       // La durée entre deux caractères sur le
                                       // périphérique série ne doit pas dépasser
                                       // la moitié de la durée de transmission
                                       // d'un caractère complet.
   
                                       timeout = (int) (((double) 1000) /
                                               (((double) vitesses_constantes[i]) /
                                               4));
                                       break;
                                   }
                               }
                           }
                           else
                           {
                               // Évite un warning de gcc.
                               longueur_questure = 0;
                               index = 0;
                               timeout = 0;
                           }
   
                         do                          do
                         {                          {
                               if (device == d_vrai)
                               {
                                   if (poll(fds, 1, timeout) == 0)
                                   {
                                       break;
                                   }
                               }
   
                             c = getc((*descripteur).descripteur_c);                              c = getc((*descripteur).descripteur_c);
                             longueur_enregistrement++;                              longueur_enregistrement++;
                         } while((c != '\n') && (c != EOF));  
   
                         if (fseek((*descripteur).descripteur_c,                              if (device == d_vrai)
                                 position_initiale, SEEK_SET) != 0)                              {
                                   if (longueur_enregistrement >=
                                           longueur_questure)
                                   {
                                       if ((tampon3 = realloc(tampon3,
                                               (size_t) (longueur_questure *= 2)))
                                               == NULL)
                                       {
                                           (*s_etat_processus).erreur_systeme =
                                                   d_es_allocation_memoire;
                                           return;
                                       }
                                   }
   
                                   tampon3[index++] = (unsigned char) c;
                               }
   
                               if (format_oriente_ligne == d_vrai)
                               {
                                   if (c == '\n')
                                   {
                                       break;
                                   }
                               }
                           } while(c != EOF);
   
                           if (device == d_faux)
                         {                          {
                             liberation(s_etat_processus, s_objet_argument_1);                              if (fseek((*descripteur).descripteur_c,
                             liberation(s_etat_processus, s_objet_resultat);                                      (long) position_initiale, SEEK_SET) != 0)
                               {
                                   liberation(s_etat_processus,
                                           s_objet_argument_1);
                                   liberation(s_etat_processus, s_objet_resultat);
   
                             (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                     d_es_erreur_fichier;                                          d_es_erreur_fichier;
                             return;                                  return;
                               }
                         }                          }
                     }                      }
                     else                      else
Line 2168  printf("L=%d\n", longueur_enregistrement Line 2243  printf("L=%d\n", longueur_enregistrement
                         longueur_enregistrement = longueur;                          longueur_enregistrement = longueur;
                     }                      }
   
                     if ((tampon_lecture = malloc((longueur_enregistrement)                      if ((device == d_vrai) && (format_degenere == d_vrai))
                             * sizeof(unsigned char))) == NULL)  
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          longueur_effective = longueur_enregistrement;
                                 d_es_allocation_memoire;                          tampon_lecture = tampon3;
                         return;  
                     }                      }
                       else
                       {
                           if ((tampon_lecture = malloc(((size_t)
                                   longueur_enregistrement) *
                                   sizeof(unsigned char))) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return;
                           }
   
                     longueur_effective = fread(tampon_lecture,                          longueur_effective = (integer8) fread(tampon_lecture,
                             (size_t) sizeof(unsigned char),                                  sizeof(unsigned char),
                             (size_t) longueur_enregistrement,                                  (size_t) longueur_enregistrement,
                             (*descripteur).descripteur_c);                                  (*descripteur).descripteur_c);
                       }
   
                     if (l_element_courant == NULL)                      if (l_element_courant == NULL)
                     {                      {
Line 2219  printf("L=%d\n", longueur_enregistrement Line 2303  printf("L=%d\n", longueur_enregistrement
   
                     if (format_degenere == d_vrai)                      if (format_degenere == d_vrai)
                     {                      {
                         if (((*(*l_element_courant).donnee).objet =                          if (device == d_faux)
                             analyse_flux(s_etat_processus, tampon_lecture,  
                             longueur_enregistrement - 1)) == NULL)  
                         {                          {
                             return;                              if (((*(*l_element_courant).donnee).objet =
                                   analyse_flux(s_etat_processus, tampon_lecture,
                                   longueur_enregistrement - 1)) == NULL)
                               {
                                   return;
                               }
                           }
                           else
                           {
                               if (((*(*l_element_courant).donnee).objet =
                                   analyse_flux(s_etat_processus, tampon_lecture,
                                   longueur_enregistrement)) == NULL)
                               {
                                   return;
                               }
                         }                          }
                     }                      }
                     else                      else
Line 2295  printf("L=%d\n", longueur_enregistrement Line 2391  printf("L=%d\n", longueur_enregistrement
   
         if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N')          if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N')
         { // Socket formatée          { // Socket formatée
             longueur_questure = 256;              longueur_questure = 4096;
             longueur_effective = 0;              longueur_effective = 0;
             tampon_lecture = NULL;              tampon_lecture = NULL;
   
Line 2311  printf("L=%d\n", longueur_enregistrement Line 2407  printf("L=%d\n", longueur_enregistrement
                 presence_indicateur = d_faux;                  presence_indicateur = d_faux;
   
                 if ((tampon_lecture = realloc(tampon_lecture,                  if ((tampon_lecture = realloc(tampon_lecture,
                         (longueur_effective + longueur_questure + 1)                          ((size_t) (longueur_effective + longueur_questure + 1))
                         * sizeof(unsigned char))) == NULL)                          * sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 2336  printf("L=%d\n", longueur_enregistrement Line 2432  printf("L=%d\n", longueur_enregistrement
   
                     do                      do
                     {                      {
                         ios = recvfrom((*((struct_socket *)                          ios = (int) recvfrom((*((struct_socket *)
                                 (*s_objet_argument_1).objet)).socket,                                  (*s_objet_argument_1).objet)).socket,
                                 tampon_lecture + longueur_effective,                                  tampon_lecture, (size_t) (longueur_effective +
                                 longueur_questure,                                  longueur_questure),
                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)                                  MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                 &adresse_unix, &longueur_adresse);                                  &adresse_unix, &longueur_adresse);
                     } while((ios == -1) && (errno == EINTR));                      } while((ios == -1) && (errno == EINTR));
Line 2351  printf("L=%d\n", longueur_enregistrement Line 2447  printf("L=%d\n", longueur_enregistrement
   
                     do                      do
                     {                      {
                         ios = recvfrom((*((struct_socket *)                          ios = (int) recvfrom((*((struct_socket *)
                                 (*s_objet_argument_1).objet)).socket,                                  (*s_objet_argument_1).objet)).socket,
                                 tampon_lecture + longueur_effective,                                  tampon_lecture, (size_t) (longueur_effective +
                                 longueur_questure,                                  longueur_questure),
                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)                                  MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                 &adresse_ipv4, &longueur_adresse);                                  &adresse_ipv4, &longueur_adresse);
                     } while((ios == -1) && (errno == EINTR));                      } while((ios == -1) && (errno == EINTR));
Line 2367  printf("L=%d\n", longueur_enregistrement Line 2463  printf("L=%d\n", longueur_enregistrement
                                           
                     do                      do
                     {                      {
                         ios = recvfrom((*((struct_socket *)                          ios = (int) recvfrom((*((struct_socket *)
                                 (*s_objet_argument_1).objet)).socket,                                  (*s_objet_argument_1).objet)).socket,
                                 tampon_lecture + longueur_effective,                                  tampon_lecture, (size_t) (longueur_effective +
                                 longueur_questure,                                  longueur_questure),
                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)                                  MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                 &adresse_ipv6, &longueur_adresse);                                  &adresse_ipv6, &longueur_adresse);
                     } while((ios == -1) && (errno == EINTR));                      } while((ios == -1) && (errno == EINTR));
Line 2413  printf("L=%d\n", longueur_enregistrement Line 2509  printf("L=%d\n", longueur_enregistrement
                     return;                      return;
                 }                  }
   
                 if (ios < 0)                  if (ios <= 0)
                 {                  {
                     nanosleep(&attente, NULL);                      nanosleep(&attente, NULL);
                     INCR_GRANULARITE(attente.tv_nsec);                      INCR_GRANULARITE(attente.tv_nsec);
                     scrutation_injection(s_etat_processus);  
                 }                  }
                 else                  else
                 {                  {
Line 2425  printf("L=%d\n", longueur_enregistrement Line 2520  printf("L=%d\n", longueur_enregistrement
                     attente.tv_nsec = GRANULARITE_us * 1000;                      attente.tv_nsec = GRANULARITE_us * 1000;
                 }                  }
   
                   scrutation_injection(s_etat_processus);
   
                 if ((*s_etat_processus).var_volatile_requete_arret == -1)                  if ((*s_etat_processus).var_volatile_requete_arret == -1)
                 {                  {
                     if (ios >= 0)                      if (ios >= 0)
                     {                      {
                         longueur_effective += ios;                          longueur_effective = ios;
                     }                      }
   
                     break;                      break;
Line 2439  printf("L=%d\n", longueur_enregistrement Line 2536  printf("L=%d\n", longueur_enregistrement
   
                 if (ios >= 0)                  if (ios >= 0)
                 {                  {
                     ancienne_longueur_effective = longueur_effective;                      longueur_effective = ios;
                     longueur_effective += ios;  
                     position_initiale = 0;                      position_initiale = 0;
                     presence_indicateur = d_faux;                      presence_indicateur = d_faux;
   
Line 2510  printf("L=%d\n", longueur_enregistrement Line 2606  printf("L=%d\n", longueur_enregistrement
                         }                          }
                     }                      }
   
                     // On retire du buffer position_finale -                      // On retire une trame du buffer.
                     // ancienne_longueur_effective octets.  
   
                     if ((*((struct_socket *) (*s_objet_argument_1).objet))  
                             .domaine == PF_UNIX)  
                     {  
                         longueur_adresse = sizeof(adresse_unix);  
   
                         do  
                         {  
                             ios = recvfrom((*((struct_socket *)  
                                     (*s_objet_argument_1).objet)).socket,  
                                     poubelle, position_finale  
                                     - ancienne_longueur_effective,  
                                     MSG_DONTWAIT, (struct sockaddr *)  
                                     &adresse_unix, &longueur_adresse);  
                         } while((ios == -1) && (errno == EINTR));  
                     }  
                     else if ((*((struct_socket *) (*s_objet_argument_1)  
                             .objet)).domaine == PF_INET)  
                     {  
                         longueur_adresse = sizeof(adresse_ipv4);  
   
                         do                      if (trame_complete == d_vrai)
                         {  
                             ios = recvfrom((*((struct_socket *)  
                                     (*s_objet_argument_1).objet)).socket,  
                                     poubelle, position_finale  
                                     - ancienne_longueur_effective,  
                                     MSG_DONTWAIT, (struct sockaddr *)  
                                     &adresse_ipv4, &longueur_adresse);  
                         } while((ios == -1) && (errno == EINTR));  
                     }  
                     else if ((*((struct_socket *) (*s_objet_argument_1)  
                             .objet)) .domaine == PF_INET6)  
                     {                      {
 #                       ifdef IPV6                          if ((*((struct_socket *) (*s_objet_argument_1).objet))
                         longueur_adresse = sizeof(adresse_ipv6);                                  .domaine == PF_UNIX)
   
                         do  
                         {                          {
                             ios = recvfrom((*((struct_socket *)                              do
                                     (*s_objet_argument_1).objet)).socket,                              {
                                     poubelle, position_finale                                  longueur_adresse = sizeof(adresse_unix);
                                     - ancienne_longueur_effective,                                  recvfrom((*((struct_socket *)
                                     MSG_DONTWAIT, (struct sockaddr *)                                          (*s_objet_argument_1).objet)).socket,
                                     &adresse_ipv6, &longueur_adresse);                                          tampon_lecture,
                         } while((ios == -1) && (errno == EINTR));                                          (size_t) longueur_effective,
 #                       else                                          0, (struct sockaddr *)
                         if ((*s_etat_processus).langue == 'F')                                          &adresse_unix, &longueur_adresse);
                               } while((ios == -1) && (errno == EINTR));
                           }
                           else if ((*((struct_socket *) (*s_objet_argument_1)
                                   .objet)).domaine == PF_INET)
                         {                          {
                             printf("+++Attention : Support du protocole"                              do
                                     " IPv6 indisponible\n");                              {
                                   longueur_adresse = sizeof(adresse_ipv4);
                                   recvfrom((*((struct_socket *)
                                           (*s_objet_argument_1).objet)).socket,
                                           tampon_lecture,
                                           (size_t) longueur_effective,
                                           0, (struct sockaddr *)
                                           &adresse_ipv4, &longueur_adresse);
                               } while((ios == -1) && (errno == EINTR));
                         }                          }
                         else                          else if ((*((struct_socket *) (*s_objet_argument_1)
                                   .objet)) .domaine == PF_INET6)
                         {                          {
                             printf("+++Warning : IPv6 support "  #                           ifdef IPV6
                                     "unavailable\n");                              do
                               {
                                   longueur_adresse = sizeof(adresse_ipv6);
                                   recvfrom((*((struct_socket *)
                                           (*s_objet_argument_1).objet)).socket,
                                           tampon_lecture,
                                           (size_t) longueur_effective,
                                           0, (struct sockaddr *)
                                           &adresse_ipv6, &longueur_adresse);
                               } while((ios == -1) && (errno == EINTR));
   #                           else
                               if ((*s_etat_processus).langue == 'F')
                               {
                                   printf("+++Attention : Support du protocole"
                                           " IPv6 indisponible\n");
                               }
                               else
                               {
                                   printf("+++Warning : IPv6 support "
                                           "unavailable\n");
                               }
   
   #                           endif
                         }                          }
   
                         longueur_adresse = 0;                          longueur_effective = ios;
 #                       endif  
                     }                      }
                       else
                     if (presence_indicateur == d_faux)  
                     {                      {
                         poll_fd.fd = (*((struct_socket *)                          // Si on a lu toute une trame et qu'on n'a pas
                                 (*s_objet_argument_1).objet)).socket;                          // réussi à en trouver la structure, on remonte
                         poll_fd.events = POLLIN;                          // une erreur de syntaxe.
   
                         while((ios = poll(&poll_fd, 1, 10000)) <= 0)                          if (longueur_effective == ios)
                         {                          {
                             // La fin de la trame n'est pas atteinte                              if ((*((struct_socket *) (*s_objet_argument_1)
                             // et il reste quelque chose à lire.                                      .objet)).domaine == PF_UNIX)
   
                             switch(ios)  
                             {                              {
                                 case EINTR:                                  do
                                 {                                  {
                                     if ((*s_etat_processus)                                      longueur_adresse = sizeof(adresse_unix);
                                             .var_volatile_requete_arret == -1)                                      recvfrom((*((struct_socket *)
                                     {                                              (*s_objet_argument_1).objet))
                                         liberation(s_etat_processus,                                              .socket, tampon_lecture,
                                                 s_objet_argument_1);                                              (size_t) longueur_effective,
                                         free(tampon_lecture);                                              0, (struct sockaddr *)
                                         return;                                              &adresse_unix, &longueur_adresse);
                                     }                                  } while((ios == -1) && (errno == EINTR));
                               }
                                     break;                              else if ((*((struct_socket *) (*s_objet_argument_1)
                                       .objet)).domaine == PF_INET)
                               {
                                   do
                                   {
                                       longueur_adresse = sizeof(adresse_ipv4);
                                       recvfrom((*((struct_socket *)
                                               (*s_objet_argument_1).objet))
                                               .socket, tampon_lecture,
                                               (size_t) longueur_effective,
                                               0, (struct sockaddr *)
                                               &adresse_ipv4, &longueur_adresse);
                                   } while((ios == -1) && (errno == EINTR));
                               }
                               else if ((*((struct_socket *) (*s_objet_argument_1)
                                       .objet)) .domaine == PF_INET6)
                               {
   #                               ifdef IPV6
                                   do
                                   {
                                       longueur_adresse = sizeof(adresse_ipv6);
                                       recvfrom((*((struct_socket *)
                                               (*s_objet_argument_1).objet))
                                               .socket, tampon_lecture,
                                               (size_t) longueur_effective,
                                               0, (struct sockaddr *)
                                               &adresse_ipv6, &longueur_adresse);
                                   } while((ios == -1) && (errno == EINTR));
   #                               else
                                   if ((*s_etat_processus).langue == 'F')
                                   {
                                       printf("+++Attention : Support du protocole"
                                               " IPv6 indisponible\n");
                                 }                                  }
                                   else
                                 case 0:  
                                 {                                  {
                                     liberation(s_etat_processus,                                      printf("+++Warning : IPv6 support "
                                             s_objet_argument_1);                                              "unavailable\n");
                                     free(tampon_lecture);  
   
                                     (*s_etat_processus).erreur_execution =  
                                             d_ex_fin_de_fichier_atteinte;  
                                     return;  
                                 }                                  }
   
   #                               endif
                             }                              }
   
                               liberation(s_etat_processus, s_objet_argument_1);
                               free(tampon_lecture);
   
                               (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                               return;
                         }                          }
                     }                      }
                 }                  }
Line 2657  printf("L=%d\n", longueur_enregistrement Line 2784  printf("L=%d\n", longueur_enregistrement
   
             tampon_lecture[++position_finale] = d_code_fin_chaine;              tampon_lecture[++position_finale] = d_code_fin_chaine;
             tampon = (*s_etat_processus).instruction_courante;              tampon = (*s_etat_processus).instruction_courante;
             (*s_etat_processus).instruction_courante = &(tampon_lecture              (*s_etat_processus).instruction_courante = tampon_lecture;
                     [position_initiale]);  
   
             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);
   
               (*s_etat_processus).type_en_cours = NON;
             recherche_type(s_etat_processus);              recherche_type(s_etat_processus);
   
             if ((*s_etat_processus).erreur_execution != d_ex)              if ((*s_etat_processus).erreur_execution != d_ex)
Line 2916  printf("L=%d\n", longueur_enregistrement Line 3043  printf("L=%d\n", longueur_enregistrement
                 longueur_adresse = 0;                  longueur_adresse = 0;
                 recvfrom((*((struct_socket *)                  recvfrom((*((struct_socket *)
                         (*s_objet_argument_1).objet)).socket, tampon_lecture,                          (*s_objet_argument_1).objet)).socket, tampon_lecture,
                         position_finale, MSG_DONTWAIT,                          (size_t) position_finale, MSG_DONTWAIT,
                         NULL, &longueur_adresse);                          NULL, &longueur_adresse);
             }              }
   
Line 2930  printf("L=%d\n", longueur_enregistrement Line 3057  printf("L=%d\n", longueur_enregistrement
         }          }
         else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire          else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire
                 == 'Y')                  == 'Y')
         { // UNFORMATTED          { // socket non formatée
               longueur_questure = 4096;
               longueur_effective = 0;
               tampon_lecture = NULL;
   
               attente.tv_sec = 0;
               attente.tv_nsec = GRANULARITE_us * 1000;
   
               trame_complete = d_faux;
               position_initiale = 0;
               position_finale = 0;
   
               do
               {
                   presence_indicateur = d_faux;
   
                   if ((tampon_lecture = realloc(tampon_lecture,
                           ((size_t) (longueur_effective + longueur_questure) + 1)
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
   #               ifndef SEMAPHORES_NOMMES
                       if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
   #               else
                       if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #               endif
                   {
                       (*s_etat_processus).erreur_systeme = d_es_processus;
                       return;
                   }
   
                   if ((*((struct_socket *) (*s_objet_argument_1).objet))
                           .domaine == PF_UNIX)
                   {
                       longueur_adresse = sizeof(adresse_unix);
   
                       do
                       {
                           ios = (int) recvfrom((*((struct_socket *)
                                   (*s_objet_argument_1).objet)).socket,
                                   tampon_lecture, (size_t)
                                   (longueur_effective + longueur_questure),
                                   MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                   &adresse_unix, &longueur_adresse);
                       } while((ios == -1) && (errno == EINTR));
                   }
                   else if ((*((struct_socket *) (*s_objet_argument_1).objet))
                           .domaine == PF_INET)
                   {
                       longueur_adresse = sizeof(adresse_ipv4);
   
                       do
                       {
                           ios = (int) recvfrom((*((struct_socket *)
                                   (*s_objet_argument_1).objet)).socket,
                                   tampon_lecture, (size_t)
                                   (longueur_effective + longueur_questure),
                                   MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                   &adresse_ipv4, &longueur_adresse);
                       } while((ios == -1) && (errno == EINTR));
                   }
                   else if ((*((struct_socket *) (*s_objet_argument_1).objet))
                           .domaine == PF_INET6)
                   {
   #                   ifdef IPV6
                       longueur_adresse = sizeof(adresse_ipv6);
                       
                       do
                       {
                           ios = (int) recvfrom((*((struct_socket *)
                                   (*s_objet_argument_1).objet)).socket,
                                   tampon_lecture, (size_t)
                                   (longueur_effective + longueur_questure),
                                   MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                   &adresse_ipv6, &longueur_adresse);
                       } while((ios == -1) && (errno == EINTR));
   #                   else
                       if ((*s_etat_processus).langue == 'F')
                       {
                           printf("+++Attention : Support du protocole"
                                   " IPv6 indisponible\n");
                       }
                       else
                       {
                           printf("+++Warning : IPv6 support "
                                   "unavailable\n");
                       }
   
                       longueur_adresse = 0;
                       longueur_effective = 0;
                       ios = 0;
   #                   endif
                   }
                   else
                   {
                       free(tampon_lecture);
                       liberation(s_etat_processus, s_objet_argument_1);
   
   #                   ifndef SEMAPHORES_NOMMES
                           while(sem_wait(&((*s_etat_processus)
                                   .semaphore_fork)) != 0)
   #                   else
                           while(sem_wait((*s_etat_processus)
                                   .semaphore_fork) != 0)
   #                   endif
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_processus;
                       }
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_acces_fichier;
                       return;
                   }
   
                   if (ios <= 0)
                   {
                       nanosleep(&attente, NULL);
                       INCR_GRANULARITE(attente.tv_nsec);
                   }
                   else
                   {
                       attente.tv_sec = 0;
                       attente.tv_nsec = GRANULARITE_us * 1000;
                   }
   
                   scrutation_injection(s_etat_processus);
   
                   if ((*s_etat_processus).var_volatile_requete_arret == -1)
                   {
                       if (ios >= 0)
                       {
                           longueur_effective += ios;
                       }
   
                       break;
                   }
   
                   // Une donnée a été reçue.
   
                   if (ios == (longueur_effective + longueur_questure))
                   {
                       longueur_effective = ios;
                       position_initiale = 0;
                       presence_indicateur = d_faux;
                   }
                   else if (ios > 0)
                   {
                       // On retire une trame du buffer.
   
                       if ((*((struct_socket *) (*s_objet_argument_1).objet))
                               .domaine == PF_UNIX)
                       {
                           do
                           {
                               longueur_adresse = sizeof(adresse_unix);
                               recvfrom((*((struct_socket *)
                                       (*s_objet_argument_1).objet)).socket,
                                       tampon_lecture, (size_t) longueur_effective,
                                       0, (struct sockaddr *)
                                       &adresse_unix, &longueur_adresse);
                           } while((ios == -1) && (errno == EINTR));
                       }
                       else if ((*((struct_socket *) (*s_objet_argument_1)
                               .objet)).domaine == PF_INET)
                       {
                           do
                           {
                               longueur_adresse = sizeof(adresse_ipv4);
                               recvfrom((*((struct_socket *)
                                       (*s_objet_argument_1).objet)).socket,
                                       tampon_lecture, (size_t) longueur_effective,
                                       0, (struct sockaddr *)
                                       &adresse_ipv4, &longueur_adresse);
                           } while((ios == -1) && (errno == EINTR));
                       }
                       else if ((*((struct_socket *) (*s_objet_argument_1)
                               .objet)) .domaine == PF_INET6)
                       {
   #                       ifdef IPV6
                           do
                           {
                               longueur_adresse = sizeof(adresse_ipv6);
                               recvfrom((*((struct_socket *)
                                       (*s_objet_argument_1).objet)).socket,
                                       tampon_lecture, (size_t) longueur_effective,
                                       0, (struct sockaddr *)
                                       &adresse_ipv6, &longueur_adresse);
                           } while((ios == -1) && (errno == EINTR));
   #                       else
                           if ((*s_etat_processus).langue == 'F')
                           {
                               printf("+++Attention : Support du protocole"
                                       " IPv6 indisponible\n");
                           }
                           else
                           {
                               printf("+++Warning : IPv6 support "
                                       "unavailable\n");
                           }
   #                       endif
                       }
   
                       longueur_effective = ios;
                       trame_complete = d_vrai;
                   }
   
   #               ifndef SEMAPHORES_NOMMES
                       while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
   #               else
                       while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
   #               endif
                   {
                       if (errno == EINTR)
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
                   }
   
                   if ((*s_etat_processus).var_volatile_requete_arret == -1)
                   {
   
                       /*
                        * Si le père tue le processus courant grâce au signal
                        * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
                        * correspond à l'utilisation de STOP sur le processus
                        * en cours. La variable longueur_effective vaut '-1'.
                        */
   
                       free(tampon_lecture);
                       liberation(s_etat_processus, s_objet_argument_1);
                       return;
                   }
   
                   if (longueur_effective == -1)
                   {
                       free(tampon_lecture);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_acces_fichier;
                       return;
                   }
               } while(trame_complete == d_faux);
   
               /*
                * Création de la liste de sortie
                */
   
               ptr = tampon_lecture;
   
               if ((s_objet_type = lecture_fichier_non_formate(s_etat_processus,
                       &ptr, longueur_effective, d_faux)) == NULL)
               {
                   free(tampon_lecture);
   
                   (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                   return;
               }
   
               if ((s_objet_resultat = allocation(s_etat_processus, LST))
                       == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               if (((*s_objet_resultat).objet =
                       allocation_maillon(s_etat_processus)) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               (*((struct_liste_chainee *) (*s_objet_resultat).objet))
                       .donnee = s_objet_type;
   
               if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
                       .suivant = allocation_maillon(s_etat_processus)) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
                       .suivant = NULL;
   
               if ((s_objet_adresse = allocation(s_etat_processus, LST))
                       == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
                       .donnee = s_objet_adresse;
   
               /*
                * Les informations concernant la cible sont valides si
                * la socket est non connectée et des domaines INET ou INET6.
                * Dans tous les autres cas, on renvoie une liste vide.
                */
   
               if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
                       == PF_UNIX) || (strcmp((*((struct_socket *)
                       (*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
                       (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
                       .type, "SEQUENTIAL DATAGRAM") == 0))
               {
                   (*s_objet_adresse).objet = NULL;
               }
               else if ((*((struct_socket *) (*s_objet_argument_1).objet))
                       .domaine == PF_INET)
               {
                   if (((*s_objet_adresse).objet =
                           allocation_maillon(s_etat_processus)) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
                           .donnee = allocation(s_etat_processus, VIN)) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   (*((struct_vecteur *) (*(*((struct_liste_chainee *)
                           (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
   
                   if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
                           (*s_objet_adresse).objet)).donnee).objet)).tableau =
                           malloc(4 * sizeof(integer8))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   ((integer8 *) (*((struct_vecteur *)
                           (*(*((struct_liste_chainee *) (*s_objet_adresse)
                           .objet)).donnee).objet)).tableau)[0] =
                           (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
                   ((integer8 *) (*((struct_vecteur *)
                           (*(*((struct_liste_chainee *) (*s_objet_adresse)
                           .objet)).donnee).objet)).tableau)[1] =
                           (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
                   ((integer8 *) (*((struct_vecteur *)
                           (*(*((struct_liste_chainee *) (*s_objet_adresse)
                           .objet)).donnee).objet)).tableau)[2] =
                           (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
                   ((integer8 *) (*((struct_vecteur *)
                           (*(*((struct_liste_chainee *) (*s_objet_adresse)
                           .objet)).donnee).objet)).tableau)[3] =
                           ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
   
                   if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
                           .suivant = allocation_maillon(s_etat_processus))
                           == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
                           .suivant).donnee = allocation(s_etat_processus, INT))
                           == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   (*((integer8 *) (*(*(*((struct_liste_chainee *)
                           (*s_objet_adresse).objet)).suivant).donnee).objet)) =
                           (integer8) ntohs(adresse_ipv4.sin_port);
   
                   (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
                           .suivant).suivant = NULL;
               }
               else if ((*((struct_socket *) (*s_objet_argument_1).objet))
                       .domaine == PF_INET6)
               {
   #               ifdef IPV6
                   if (((*s_objet_adresse).objet =
                           allocation_maillon(s_etat_processus)) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
                           .donnee = allocation(s_etat_processus, VIN)) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   (*((struct_vecteur *) (*(*((struct_liste_chainee *)
                           (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
   
                   if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
                           (*s_objet_adresse).objet)).donnee).objet)).tableau =
                           malloc(16 * sizeof(integer8))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   for(i = 0; i < 16; i++)
                   {
                       ((integer8 *) (*((struct_vecteur *)
                               (*(*((struct_liste_chainee *) (*s_objet_adresse)
                               .objet)).donnee).objet)).tableau)[0] =
                               adresse_ipv6.sin6_addr.s6_addr[i];
                   }
   
                   if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
                           .suivant = allocation_maillon(s_etat_processus))
                           == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
                           .suivant).donnee = allocation(s_etat_processus, INT))
                           == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   (*((integer8 *) (*(*(*((struct_liste_chainee *)
                           (*s_objet_adresse).objet)).suivant).donnee).objet)) =
                           (integer8) ntohs(adresse_ipv6.sin6_port);
   
                   (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
                           .suivant).suivant = NULL;
   #               else
                   if ((*s_etat_processus).langue == 'F')
                   {
                       printf("+++Attention : Support du protocole"
                               " IPv6 indisponible\n");
                   }
                   else
                   {
                       printf("+++Warning : IPv6 support "
                               "unavailable\n");
                   }
   #               endif
               }
               else
               {
                   longueur_adresse = 0;
                   recvfrom((*((struct_socket *)
                           (*s_objet_argument_1).objet)).socket, tampon_lecture,
                           (size_t) position_finale, MSG_DONTWAIT,
                           NULL, &longueur_adresse);
               }
   
               free(tampon_lecture);
   
               if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                       s_objet_resultat) == d_erreur)
               {
                   return;
               }
         }          }
         else          else
         { // FLOW          { // FLOW
Line 2938  printf("L=%d\n", longueur_enregistrement Line 3546  printf("L=%d\n", longueur_enregistrement
   
             do              do
             {              {
                 if ((tampon_lecture = malloc((longueur_questure + 1) *                  if ((tampon_lecture = malloc((((long long unsigned int)
                           longueur_questure) + 1) *
                         sizeof(unsigned char))) == NULL)                          sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 2967  printf("L=%d\n", longueur_enregistrement Line 3576  printf("L=%d\n", longueur_enregistrement
                         longueur_adresse = sizeof(adresse_unix);                          longueur_adresse = sizeof(adresse_unix);
                         longueur_effective = recvfrom((*((struct_socket *)                          longueur_effective = recvfrom((*((struct_socket *)
                                 (*s_objet_argument_1).objet)).socket,                                  (*s_objet_argument_1).objet)).socket,
                                 tampon_lecture, longueur_questure,                                  tampon_lecture, (long unsigned int)
                                   longueur_questure,
                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)                                  MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                 &adresse_unix, &longueur_adresse);                                  &adresse_unix, &longueur_adresse);
                     }                      }
Line 2977  printf("L=%d\n", longueur_enregistrement Line 3587  printf("L=%d\n", longueur_enregistrement
                         longueur_adresse = sizeof(adresse_ipv4);                          longueur_adresse = sizeof(adresse_ipv4);
                         longueur_effective = recvfrom((*((struct_socket *)                          longueur_effective = recvfrom((*((struct_socket *)
                                 (*s_objet_argument_1).objet)).socket,                                  (*s_objet_argument_1).objet)).socket,
                                 tampon_lecture, longueur_questure,                                  tampon_lecture, (long unsigned int)
                                   longueur_questure,
                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)                                  MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                 &adresse_ipv4, &longueur_adresse);                                  &adresse_ipv4, &longueur_adresse);
                     }                      }
Line 2988  printf("L=%d\n", longueur_enregistrement Line 3599  printf("L=%d\n", longueur_enregistrement
                         longueur_adresse = sizeof(adresse_ipv6);                          longueur_adresse = sizeof(adresse_ipv6);
                         longueur_effective = recvfrom((*((struct_socket *)                          longueur_effective = recvfrom((*((struct_socket *)
                                 (*s_objet_argument_1).objet)).socket,                                  (*s_objet_argument_1).objet)).socket,
                                 tampon_lecture, longueur_questure,                                  tampon_lecture, (long unsigned int)
                                   longueur_questure,
                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)                                  MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                 &adresse_ipv6, &longueur_adresse);                                  &adresse_ipv6, &longueur_adresse);
 #                       else  #                       else
Line 3116  printf("L=%d\n", longueur_enregistrement Line 3728  printf("L=%d\n", longueur_enregistrement
                 return;                  return;
             }              }
   
             if (((*s_objet_type).objet = malloc(longueur_enregistrement *              if (((*s_objet_type).objet = malloc((long long unsigned int)
                       longueur_enregistrement *
                     sizeof(unsigned char))) == NULL)                      sizeof(unsigned char))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3200  printf("L=%d\n", longueur_enregistrement Line 3813  printf("L=%d\n", longueur_enregistrement
                 longueur_adresse = 0;                  longueur_adresse = 0;
                 recvfrom((*((struct_socket *)                  recvfrom((*((struct_socket *)
                         (*s_objet_argument_1).objet)).socket, tampon_lecture,                          (*s_objet_argument_1).objet)).socket, tampon_lecture,
                         position_finale, MSG_DONTWAIT,                          (long unsigned int) longueur_effective, MSG_DONTWAIT,
                         NULL, &longueur_adresse);                          NULL, &longueur_adresse);
   
                 (*s_objet_adresse).objet = NULL;                  (*s_objet_adresse).objet = NULL;
Line 3211  printf("L=%d\n", longueur_enregistrement Line 3824  printf("L=%d\n", longueur_enregistrement
                 longueur_adresse = sizeof(adresse_ipv4);                  longueur_adresse = sizeof(adresse_ipv4);
                 recvfrom((*((struct_socket *)                  recvfrom((*((struct_socket *)
                         (*s_objet_argument_1).objet)).socket, tampon_lecture,                          (*s_objet_argument_1).objet)).socket, tampon_lecture,
                         position_finale, MSG_DONTWAIT,                          (long unsigned int) longueur_effective, MSG_DONTWAIT,
                         (struct sockaddr *) &adresse_ipv4, &longueur_adresse);                          (struct sockaddr *) &adresse_ipv4, &longueur_adresse);
   
                 if (((*s_objet_adresse).objet =                  if (((*s_objet_adresse).objet =
Line 3291  printf("L=%d\n", longueur_enregistrement Line 3904  printf("L=%d\n", longueur_enregistrement
                 longueur_adresse = sizeof(adresse_ipv6);                  longueur_adresse = sizeof(adresse_ipv6);
                 recvfrom((*((struct_socket *)                  recvfrom((*((struct_socket *)
                         (*s_objet_argument_1).objet)).socket, tampon_lecture,                          (*s_objet_argument_1).objet)).socket, tampon_lecture,
                         position_finale, MSG_DONTWAIT,                          (long unsigned int) longueur_effective, MSG_DONTWAIT,
                         (struct sockaddr *) &adresse_ipv6, &longueur_adresse);                          (struct sockaddr *) &adresse_ipv6, &longueur_adresse);
   
                 if (((*s_objet_adresse).objet =                  if (((*s_objet_adresse).objet =
Line 3372  printf("L=%d\n", longueur_enregistrement Line 3985  printf("L=%d\n", longueur_enregistrement
                 longueur_adresse = 0;                  longueur_adresse = 0;
                 recvfrom((*((struct_socket *)                  recvfrom((*((struct_socket *)
                         (*s_objet_argument_1).objet)).socket, tampon_lecture,                          (*s_objet_argument_1).objet)).socket, tampon_lecture,
                         position_finale, MSG_DONTWAIT,                          (long unsigned int) longueur_effective, MSG_DONTWAIT,
                         NULL, &longueur_adresse);                          NULL, &longueur_adresse);
             }              }
   
Removed from v.1.65  
changed lines
  Added in v.1.106

CVSweb interface <joel.bertrand@systella.fr>