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

Diff for /rpl/src/instructions_w1.c between versions 1.11 and 1.95

version 1.11, 2010/04/07 13:45:09 version 1.95, 2015/02/19 11:01:28
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.14    RPL/2 (R) version 4.1.21
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2015 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 20 Line 20
 */  */
   
   
 #include "rpl.conv.h"  #include "rpl-conv.h"
   
   
 /*  /*
Line 124  instruction_while(struct_processus *s_et Line 124  instruction_while(struct_processus *s_et
 void  void
 instruction_warranty(struct_processus *s_etat_processus)  instruction_warranty(struct_processus *s_etat_processus)
 {  {
 #   include                 "garanties.conv.h"  #   include                 "garanties-conv.h"
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 226  instruction_wait(struct_processus *s_eta Line 226  instruction_wait(struct_processus *s_eta
         return;          return;
     }      }
           
     if (((*s_objet).type == INT) ||      if (((*s_objet).type == INT) || ((*s_objet).type == REL))
             ((*s_objet).type == REL))  
     {      {
         if ((*s_objet).type == INT)          if ((*s_objet).type == INT)
         {          {
Line 246  instruction_wait(struct_processus *s_eta Line 245  instruction_wait(struct_processus *s_eta
             return;              return;
         }          }
   
         temporisation.tv_sec = (long) floor((double) attente);          temporisation.tv_sec = (time_t) floor((double) attente);
         temporisation.tv_nsec = (attente - temporisation.tv_sec) *          temporisation.tv_nsec = (long) ((attente -
                 (long) 1000000000;                  ((real8) temporisation.tv_sec)) * (integer8) 1000000000);
   
         if ((*s_etat_processus).profilage == d_vrai)          if ((*s_etat_processus).profilage == d_vrai)
         {          {
Line 262  instruction_wait(struct_processus *s_eta Line 261  instruction_wait(struct_processus *s_eta
   
         do          do
         {          {
             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)  #           ifndef SEMAPHORES_NOMMES
                   if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
   #           else
                   if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #           endif
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
Line 271  instruction_wait(struct_processus *s_eta Line 274  instruction_wait(struct_processus *s_eta
             code_retour = nanosleep(&temporisation, &temporisation);              code_retour = nanosleep(&temporisation, &temporisation);
             erreur = errno;              erreur = errno;
   
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  #           ifndef SEMAPHORES_NOMMES
                   while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
   #           else
                   while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
   #           endif
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
                 {                  {
Line 282  instruction_wait(struct_processus *s_eta Line 289  instruction_wait(struct_processus *s_eta
   
             scrutation_injection(s_etat_processus);              scrutation_injection(s_etat_processus);
   
               if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions)
                       != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   
             if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)              if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
             {              {
                 affectation_interruptions_logicielles(s_etat_processus);                  affectation_interruptions_logicielles(s_etat_processus);
             }              }
   
               if (pthread_mutex_unlock(&(*s_etat_processus).mutex_interruptions)
                       != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   
             if ((*s_etat_processus).nombre_interruptions_en_queue != 0)              if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
             {              {
                 traitement_interruptions_logicielles(s_etat_processus);                  traitement_interruptions_logicielles(s_etat_processus);
Line 378  instruction_write(struct_processus *s_et Line 399  instruction_write(struct_processus *s_et
   
     int                                 adresse[16];      int                                 adresse[16];
     int                                 port;      int                                 port;
       int                                 sqlite_status;
   
     integer8                            clef;      integer8                            clef;
     integer8                            compteur;      integer8                            compteur;
     integer8                            id;      integer8                            id;
       integer8                            longueur;
       integer8                            longueur_effective;
     integer8                            ordre;      integer8                            ordre;
       integer8                            recursivite;
   
       logical1                            format_degenere;
     logical1                            mise_a_jour;      logical1                            mise_a_jour;
   
     long                                longueur_effective;  
     long                                recursivite;  
   
     sqlite3_stmt                        *ppStmt;      sqlite3_stmt                        *ppStmt;
   
Line 408  instruction_write(struct_processus *s_et Line 432  instruction_write(struct_processus *s_et
     struct sigaction                    registre;      struct sigaction                    registre;
   
     struct sockaddr_in                  adresse_ipv4;      struct sockaddr_in                  adresse_ipv4;
   #   ifdef IPV6
     struct sockaddr_in6                 adresse_ipv6;      struct sockaddr_in6                 adresse_ipv6;
   #   endif
     struct sockaddr_un                  adresse_unix;      struct sockaddr_un                  adresse_unix;
   
     struct flock                        lock;      struct flock                        lock;
   
       struct timespec                     attente;
   
     uint32_t                            calcul_adresse;      uint32_t                            calcul_adresse;
   
     unsigned char                       *chaine;      unsigned char                       *chaine;
     unsigned char                       *chaine_utf8;      unsigned char                       *chaine_utf8;
     unsigned char                       *clef_utf8;      unsigned char                       *clef_utf8;
     unsigned char                       *commande;      unsigned char                       *commande;
       unsigned char                       *format_chaine;
   
     unsigned long                       i;      unsigned long                       i;
   
Line 577  instruction_write(struct_processus *s_et Line 606  instruction_write(struct_processus *s_et
                 if ((chaine = formateur_fichier(s_etat_processus,                  if ((chaine = formateur_fichier(s_etat_processus,
                         s_objet_argument_2, (*((struct_fichier *)                          s_objet_argument_2, (*((struct_fichier *)
                         (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F',                          (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F',
                         &longueur_effective, &recursivite)) == NULL)                          &longueur_effective, &recursivite, d_vrai)) == NULL)
                 {                  {
                     liberation(s_etat_processus, s_objet_argument_2);                      liberation(s_etat_processus, s_objet_argument_2);
                     liberation(s_etat_processus, s_objet_argument_1);                      liberation(s_etat_processus, s_objet_argument_1);
Line 659  instruction_write(struct_processus *s_et Line 688  instruction_write(struct_processus *s_et
                 if ((chaine = formateur_fichier(s_etat_processus,                  if ((chaine = formateur_fichier(s_etat_processus,
                         s_objet_argument_3, (*((struct_fichier *)                          s_objet_argument_3, (*((struct_fichier *)
                         (*s_objet_argument_1).objet)).format, 0, 0, ' ',                          (*s_objet_argument_1).objet)).format, 0, 0, ' ',
                         'F', &longueur_effective, &recursivite)) == NULL)                          'F', &longueur_effective, &recursivite, d_vrai))
                           == NULL)
                 {                  {
                     liberation(s_etat_processus, s_objet_argument_3);                      liberation(s_etat_processus, s_objet_argument_3);
                     liberation(s_etat_processus, s_objet_argument_2);                      liberation(s_etat_processus, s_objet_argument_2);
Line 682  instruction_write(struct_processus *s_et Line 712  instruction_write(struct_processus *s_et
   
                 free(chaine);                  free(chaine);
   
                 if (alsprintf(&commande, "insert or replace into data "                  if (alsprintf(s_etat_processus, &commande,
                           "insert or replace into data "
                         "(id, data) values (%lld, '%s')", (*((integer8 *)                          "(id, data) values (%lld, '%s')", (*((integer8 *)
                         (*s_objet_argument_2).objet)), chaine_utf8) < 0)                          (*s_objet_argument_2).objet)), chaine_utf8) < 0)
                 {                  {
Line 694  instruction_write(struct_processus *s_et Line 725  instruction_write(struct_processus *s_et
                 free(chaine_utf8);                  free(chaine_utf8);
   
                 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 732  instruction_write(struct_processus *s_et Line 763  instruction_write(struct_processus *s_et
   
                 // 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 741  instruction_write(struct_processus *s_et Line 772  instruction_write(struct_processus *s_et
                 }                  }
   
                 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;                      sqlite_status = sqlite3_step(ppStmt);
                     return;  
                 }                      if (sqlite_status == SQLITE_ROW)
                       {
                           break;
                       }
                       else if ((sqlite_status == SQLITE_BUSY) ||
                               (sqlite_status == SQLITE_LOCKED))
                       {
                           nanosleep(&attente, NULL);
                           INCR_GRANULARITE(attente.tv_nsec);
                       }
                       else
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                           return;
                       }
                   } while(sqlite_status != SQLITE_ROW);
   
                 if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)                  if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
                 {                  {
Line 863  instruction_write(struct_processus *s_et Line 913  instruction_write(struct_processus *s_et
   
                 if ((chaine = formateur_fichier(s_etat_processus,                  if ((chaine = formateur_fichier(s_etat_processus,
                         s_element, s_format, 0, 0, ' ',                          s_element, s_format, 0, 0, ' ',
                         'F', &longueur_effective, &recursivite)) == NULL)                          'F', &longueur_effective, &recursivite, d_vrai))
                           == NULL)
                 {                  {
                     liberation(s_etat_processus, s_element);                      liberation(s_etat_processus, s_element);
                     liberation(s_etat_processus, s_format);                      liberation(s_etat_processus, s_format);
Line 889  instruction_write(struct_processus *s_et Line 940  instruction_write(struct_processus *s_et
   
                 // 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 898  instruction_write(struct_processus *s_et Line 949  instruction_write(struct_processus *s_et
                 }                  }
   
                 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:                      switch(sqlite_status = sqlite3_step(ppStmt))
                     {                      {
                         // Une clef existe.                          case SQLITE_ROW:
                           {
                               // Une clef existe.
   
                         mise_a_jour = d_vrai;                              mise_a_jour = d_vrai;
                         break;                              break;
                     }                          }
   
                     case SQLITE_DONE:                          case SQLITE_DONE:
                     {                          {
                         // Aucune clef n'existe.                              // Aucune clef n'existe.
   
                         mise_a_jour = d_faux;                              mise_a_jour = d_faux;
   
                         if (sqlite3_finalize(ppStmt) != SQLITE_OK)                              if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                         {                              {
                             (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                     d_es_erreur_fichier;                                          d_es_erreur_fichier;
                             return;                                  return;
                         }                              }
   
                         free(commande);                              free(commande);
   
                         if (alsprintf(&commande, "insert into key "                              if (alsprintf(s_etat_processus, &commande,
                                 "(key) values ('%s')", clef_utf8) < 0)                                      "insert into key (key) values ('%s')",
                         {                                      clef_utf8) < 0)
                             (*s_etat_processus).erreur_systeme =                              {
                                     d_es_allocation_memoire;                                  (*s_etat_processus).erreur_systeme =
                             return;                                          d_es_allocation_memoire;
                         }                                  return;
                               }
   
                         if (sqlite3_prepare_v2((*descripteur)                              if (sqlite3_prepare_v2((*descripteur)
                                 .descripteur_sqlite,                                      .descripteur_sqlite, commande,
                                 commande, strlen(commande), &ppStmt, &queue)                                      (int) strlen(commande), &ppStmt, &queue)
                                 != SQLITE_OK)                                      != SQLITE_OK)
                         {                              {
                             (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                     d_es_erreur_fichier;                                          d_es_erreur_fichier;
                             return;                                  return;
                         }                              }
   
                         if (sqlite3_step(ppStmt) != SQLITE_DONE)                              if (sqlite3_step(ppStmt) != SQLITE_DONE)
                         {                              {
                             (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                     d_es_erreur_fichier;                                          d_es_erreur_fichier;
                             return;                                  return;
                         }                              }
   
                         if (sqlite3_finalize(ppStmt) != SQLITE_OK)                              if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                         {                              {
                             (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                     d_es_erreur_fichier;                                          d_es_erreur_fichier;
                             return;                                  return;
                         }                              }
   
                         free(commande);                              free(commande);
   
                         if (alsprintf(&commande, "select id from key "                              if (alsprintf(s_etat_processus, &commande,
                                 "where key = '%s'", clef_utf8) < 0)                                      "select id from key where key = '%s'",
                         {                                      clef_utf8) < 0)
                             (*s_etat_processus).erreur_systeme =                              {
                                     d_es_allocation_memoire;                                  (*s_etat_processus).erreur_systeme =
                             return;                                          d_es_allocation_memoire;
                                   return;
                               }
   
                               if (sqlite3_prepare_v2((*descripteur)
                                       .descripteur_sqlite, commande,
                                       (int) strlen(commande), &ppStmt, &queue)
                                       != SQLITE_OK)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_erreur_fichier;
                                   return;
                               }
   
                               break;
                         }                          }
   
                         if (sqlite3_prepare_v2((*descripteur)                          case SQLITE_BUSY:
                                 .descripteur_sqlite,                          case SQLITE_LOCKED:
                                 commande, strlen(commande), &ppStmt, &queue)  
                                 != SQLITE_OK)  
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              nanosleep(&attente, NULL);
                                     d_es_erreur_fichier;                              INCR_GRANULARITE(attente.tv_nsec);
                             return;                              break;
                         }                          }
   
                         if (sqlite3_step(ppStmt) != SQLITE_ROW)                          default:
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              (*s_etat_processus).erreur_systeme =
                                     d_es_erreur_fichier;                                      d_es_erreur_fichier;
                             return;                              return;
                         }                          }
   
                         break;  
                     }                      }
                   } while(sqlite_status != SQLITE_ROW);
                     default:  
                     {  
                         (*s_etat_processus).erreur_systeme =  
                                 d_es_erreur_fichier;  
                         return;  
                     }  
                 }  
   
                 if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)                  if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
                 {                  {
Line 1026  instruction_write(struct_processus *s_et Line 1086  instruction_write(struct_processus *s_et
   
                 if (mise_a_jour == d_vrai)                  if (mise_a_jour == d_vrai)
                 {                  {
                     if (alsprintf(&commande, "update key set key = '%s' where "                      if (alsprintf(s_etat_processus, &commande,
                             "id = %lld", clef_utf8, id) < 0)                              "update key set key = '%s' where id = %lld",
                               clef_utf8, id) < 0)
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
                                 d_es_allocation_memoire;                                  d_es_allocation_memoire;
Line 1035  instruction_write(struct_processus *s_et Line 1096  instruction_write(struct_processus *s_et
                     }                      }
   
                     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 =                          (*s_etat_processus).erreur_systeme =
Line 1062  instruction_write(struct_processus *s_et Line 1123  instruction_write(struct_processus *s_et
   
                 // Effacement de l'enregistrement existant                  // Effacement de l'enregistrement existant
   
                 if (alsprintf(&commande, "delete from data where "                  if (alsprintf(s_etat_processus, &commande,
                         "key_id = %lld", id) < 0)                          "delete from data where key_id = %lld", id) < 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 1071  instruction_write(struct_processus *s_et Line 1132  instruction_write(struct_processus *s_et
                 }                  }
   
                 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 1170  instruction_write(struct_processus *s_et Line 1231  instruction_write(struct_processus *s_et
   
                     if ((chaine = formateur_fichier(s_etat_processus,                      if ((chaine = formateur_fichier(s_etat_processus,
                             s_element, s_format, 0, 0, ' ',                              s_element, s_format, 0, 0, ' ',
                             'F', &longueur_effective, &recursivite)) == NULL)                              'F', &longueur_effective, &recursivite, d_vrai))
                               == NULL)
                     {                      {
                         free(clef_utf8);                          free(clef_utf8);
   
Line 1196  instruction_write(struct_processus *s_et Line 1258  instruction_write(struct_processus *s_et
   
                     free(chaine);                      free(chaine);
   
                     if (alsprintf(&commande, "insert into data "                      if (alsprintf(s_etat_processus, &commande,
                             "(data, key_id, sequence) values "                              "insert into data (data, key_id, sequence) values "
                             "('%s', %lld, %lld)", chaine_utf8, id, ordre) < 0)                              "('%s', %lld, %lld)", chaine_utf8, id, ordre) < 0)
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
Line 1206  instruction_write(struct_processus *s_et Line 1268  instruction_write(struct_processus *s_et
                     }                      }
   
                     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 =                          (*s_etat_processus).erreur_systeme =
Line 1263  instruction_write(struct_processus *s_et Line 1325  instruction_write(struct_processus *s_et
              * Fichiers non formatés               * Fichiers non formatés
              */               */
   
             if ((chaine = formateur_fichier(s_etat_processus,  
                     s_objet_argument_2, (*((struct_fichier *)  
                     (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',  
                     &longueur_effective, &recursivite)) == NULL)  
             {  
                 liberation(s_etat_processus, s_objet_argument_2);  
                 liberation(s_etat_processus, s_objet_argument_1);  
   
                 return;  
             }  
   
             if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces              if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
                     == 'S')                      == 'S')
             {              {
                   if ((*s_objet_argument_2).type != LST)
                   {
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_type_argument;
                       return;
                   }
   
                   if ((chaine = formateur_fichier(s_etat_processus,
                           s_objet_argument_2, (*((struct_fichier *)
                           (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',
                           &longueur_effective, &recursivite, d_vrai)) == NULL)
                   {
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       return;
                   }
   
                 BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n"));                  BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n"));
   
                 if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_END)                  if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_END)
Line 1289  instruction_write(struct_processus *s_et Line 1361  instruction_write(struct_processus *s_et
                     return;                      return;
                 }                  }
   
                 if (fwrite(chaine, sizeof(unsigned char), longueur_effective,                  if (fwrite(chaine, sizeof(unsigned char),
                           (size_t) longueur_effective,
                         (*descripteur).descripteur_c) !=                          (*descripteur).descripteur_c) !=
                         (size_t) longueur_effective)                          (size_t) longueur_effective)
                 {                  {
Line 1300  instruction_write(struct_processus *s_et Line 1373  instruction_write(struct_processus *s_et
             else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces              else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
                     == 'D')                      == 'D')
             {              {
                   if ((*s_objet_argument_2).type != INT)
                   {
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_type_argument;
                       return;
                   }
   
                   if (depilement(s_etat_processus, &((*s_etat_processus)
                           .l_base_pile), &s_objet_argument_3) == d_erreur)
                   {
                       (*s_etat_processus).erreur_execution = d_ex_manque_argument;
                       return;
                   }
   
                   if ((*s_objet_argument_3).type != LST)
                   {
                       liberation(s_etat_processus, s_objet_argument_3);
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_type_argument;
                       return;
                   }
   
                   if ((chaine = formateur_fichier(s_etat_processus,
                           s_objet_argument_2, (*((struct_fichier *)
                           (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',
                           &longueur_effective, &recursivite, d_faux)) == NULL)
                   {
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       return;
                   }
             }              }
             else              else // Fichiers indexés
             {              {
                 /* Fichiers indexés : panique totale ! */                  if ((*s_objet_argument_2).type != LST)
                   {
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_type_argument;
                       return;
                   }
   
                   if ((chaine = formateur_fichier(s_etat_processus,
                           s_objet_argument_2, (*((struct_fichier *)
                           (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',
                           &longueur_effective, &recursivite, d_faux)) == NULL)
                   {
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       return;
                   }
             }              }
   
             free(chaine);              free(chaine);
Line 1313  instruction_write(struct_processus *s_et Line 1443  instruction_write(struct_processus *s_et
             /*              /*
              * Fichiers de type FLOW               * Fichiers de type FLOW
              */               */
   
               if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
                       == 'S')
               {
                   BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n"));
   
                   if ((*s_objet_argument_2).type != LST)
                   {
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_type_argument;
                       return;
                   }
   
                   if ((*((struct_liste_chainee *) (*s_objet_argument_2).objet))
                           .donnee == NULL)
                   {
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_type_argument;
                       return;
                   }
   
                   l_element_courant = (*s_objet_argument_2).objet;
                   l_element_courant_format = (struct_liste_chainee *)
                           (*(*((struct_fichier *) (*s_objet_argument_1).objet))
                           .format).objet;
   
                   while((l_element_courant != NULL) &&
                           (l_element_courant_format != NULL))
                   {
                       if ((*(*l_element_courant).donnee).type != CHN)
                       {
                           liberation(s_etat_processus, s_objet_argument_2);
                           liberation(s_etat_processus, s_objet_argument_1);
   
                           (*s_etat_processus).erreur_execution =
                                   d_ex_erreur_type_argument;
                           return;
                       }
   
                       if ((*(*l_element_courant_format).donnee).type != CHN)
                       {
                           liberation(s_etat_processus, s_objet_argument_2);
                           liberation(s_etat_processus, s_objet_argument_1);
   
                           (*s_etat_processus).erreur_execution =
                                   d_ex_erreur_type_argument;
                           return;
                       }
   
                       if ((format_chaine = conversion_majuscule(s_etat_processus,
                               (unsigned char *) (*(*l_element_courant_format)
                               .donnee).objet)) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       if (strncmp("LENGTH*(", format_chaine, 8) != 0)
                       {
                           free(format_chaine);
   
                           liberation(s_etat_processus, s_objet_argument_2);
                           liberation(s_etat_processus, s_objet_argument_1);
   
                           (*s_etat_processus).erreur_execution =
                                   d_ex_erreur_format_fichier;
                           return;
                       }
   
                       longueur = (integer8) strlen(format_chaine);
   
                       if (format_chaine[longueur - 1] != ')')
                       {
                           free(format_chaine);
   
                           liberation(s_etat_processus, s_objet_argument_2);
                           liberation(s_etat_processus, s_objet_argument_1);
   
                           (*s_etat_processus).erreur_execution =
                                   d_ex_erreur_format_fichier;
                           return;
                       }
   
                       format_chaine[longueur] = d_code_fin_chaine;
   
                       if (format_chaine[8] == '*')
                       {
                           format_degenere = d_vrai;
                       }
                       else
                       {
                           // Détermination de la longueur
                           format_degenere = d_faux;
   
                           if (sscanf(&(format_chaine[8]), "%lld", &longueur) != 1)
                           {
                               free(format_chaine);
   
                               liberation(s_etat_processus, s_objet_argument_2);
                               liberation(s_etat_processus, s_objet_argument_1);
   
                               (*s_etat_processus).erreur_execution =
                                       d_ex_erreur_format_fichier;
                               return;
                           }
                       }
   
                       free(format_chaine);
   
                       if ((chaine = formateur_flux(s_etat_processus,
                               (unsigned char *) (*(*l_element_courant).donnee)
                               .objet, &longueur_effective)) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       if ((format_degenere == d_vrai) ||
                               (longueur_effective < longueur))
                       {
                           if (fwrite(chaine, sizeof(unsigned char),
                                   (size_t) longueur_effective,
                                   (*descripteur).descripteur_c) !=
                                   (size_t) longueur_effective)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
                       }
                       else
                       {
                           if (fwrite(chaine, sizeof(unsigned char),
                                   (size_t) longueur_effective,
                                   (*descripteur).descripteur_c) !=
                                   (size_t) longueur)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
                       }
   
                       free(chaine);
   
                       l_element_courant = (*l_element_courant).suivant;
                       l_element_courant_format = (*l_element_courant_format)
                               .suivant;
                   }
   
                   if ((l_element_courant_format != NULL) ||
                           (l_element_courant != NULL))
                   {
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_format_fichier;
                       return;
                   }
               }
               else
               {
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_type_fichier;
                   return;
               }
         }          }
     }      }
     else if (((*s_objet_argument_2).type == LST) &&      else if (((*s_objet_argument_2).type == LST) &&
Line 1341  instruction_write(struct_processus *s_et Line 1649  instruction_write(struct_processus *s_et
             if ((chaine = formateur_fichier(s_etat_processus,              if ((chaine = formateur_fichier(s_etat_processus,
                     s_objet_argument_2, (*((struct_socket *)                      s_objet_argument_2, (*((struct_socket *)
                     (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F',                      (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F',
                     &longueur_effective, &recursivite)) == NULL)                      &longueur_effective, &recursivite, d_faux)) == NULL)
             {              {
                 liberation(s_etat_processus, s_objet_argument_2);                  liberation(s_etat_processus, s_objet_argument_2);
                 liberation(s_etat_processus, s_objet_argument_1);                  liberation(s_etat_processus, s_objet_argument_1);
   
                 return;                  return;
             }              }
           }
           else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire
                   == 'Y')
           {
               /*
                * Sockets non formatées
                */
   
             if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,              if ((chaine = formateur_fichier(s_etat_processus,
                     "STREAM") == 0) || (strcmp((*((struct_socket *)                      s_objet_argument_2, (*((struct_socket *)
                     (*s_objet_argument_1).objet)).type,                      (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',
                     "SEQUENTIAL DATAGRAM") == 0))                      &longueur_effective, &recursivite, d_faux)) == NULL)
             { // Sockets connectées              {
                   liberation(s_etat_processus, s_objet_argument_2);
                   liberation(s_etat_processus, s_objet_argument_1);
   
                   return;
               }
           }
           else
           {
               /*
                *  Sockets de type FLOW
                */
   
                 action.sa_handler = SIG_IGN;              if ((*((*((struct_liste_chainee *) (*s_objet_argument_2).objet))
                 action.sa_flags = SA_ONSTACK;                      .donnee)).type != CHN)
               {
                   liberation(s_etat_processus, s_objet_argument_2);
                   liberation(s_etat_processus, s_objet_argument_1);
   
                 if (sigaction(SIGPIPE, &action, &registre) != 0)                  (*s_etat_processus).erreur_execution =
                           d_ex_erreur_type_argument;
                   return;
               }
   
               if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
                       (*((*((struct_liste_chainee *) (*s_objet_argument_2)
                       .objet)).donnee)).objet, &longueur_effective)) == NULL)
               {
                   liberation(s_etat_processus, s_objet_argument_2);
                   liberation(s_etat_processus, s_objet_argument_1);
   
                   return;
               }
           }
   
           if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,
                   "STREAM") == 0) || (strcmp((*((struct_socket *)
                   (*s_objet_argument_1).objet)).type,
                   "SEQUENTIAL DATAGRAM") == 0))
           { // Sockets connectées
   
               action.sa_handler = SIG_IGN;
               action.sa_flags = SA_ONSTACK;
   
               if (sigaction(SIGPIPE, &action, &registre) != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_signal;
                   return;
               }
   
   #           ifndef SEMAPHORES_NOMMES
                   if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
   #           else
                   if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #           endif
               {
                   if (sigaction(SIGPIPE, &registre, NULL) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_signal;                      (*s_etat_processus).erreur_systeme = d_es_signal;
                     return;                      return;
                 }                  }
   
                 if (sem_post(&((*s_etat_processus).semaphore_fork))                  (*s_etat_processus).erreur_systeme = d_es_processus;
                         != 0)                  return;
               }
   
               if (send((*((struct_socket *) (*s_objet_argument_1).objet))
                       .socket, chaine, (size_t) longueur_effective, 0) < 0)
               {
                   ios = errno;
   
                   if (sigaction(SIGPIPE, &registre, NULL) != 0)
                 {                  {
                     if (sigaction(SIGPIPE, &registre, NULL) != 0)                      (*s_etat_processus).erreur_systeme = d_es_signal;
                       return;
                   }
   
   #               ifndef SEMAPHORES_NOMMES
                       while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
   #               else
                       while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
   #               endif
                   {
                       if (errno != EINTR)
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es_signal;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
                     }                      }
                   }
   
                     (*s_etat_processus).erreur_systeme = d_es_processus;                  if ((ios == EPIPE) || (ios == ECONNRESET))
                   {
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_acces_fichier;
                     return;                      return;
                 }                  }
   
                 if (send((*((struct_socket *) (*s_objet_argument_1).objet))                  (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                         .socket, chaine, strlen(chaine), 0) < 0)                  return;
                 {              }
                     ios = errno;  
   
   #           ifndef SEMAPHORES_NOMMES
                   while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
   #           else
                   while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
   #           endif
               {
                   if (errno != EINTR)
                   {
                     if (sigaction(SIGPIPE, &registre, NULL) != 0)                      if (sigaction(SIGPIPE, &registre, NULL) != 0)
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es_signal;                          (*s_etat_processus).erreur_systeme = d_es_signal;
                         return;                          return;
                     }                      }
   
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                      (*s_etat_processus).erreur_systeme = d_es_processus;
                       return;
                   }
               }
   
               if (sigaction(SIGPIPE, &registre, NULL) != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_signal;
                   return;
               }
           }
           else
           { // Sockets non connectées
   
               /*
                * Vérification de l'adresse distante
                */
   
               if (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
                       .adresse_distante, "") == 0)
               {
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_acces_fichier;
                   return;
               }
   
               /*
                * Création de l'adresse logique
                */
   
               if ((*((struct_socket *) (*s_objet_argument_1).objet))
                       .domaine == PF_UNIX)
               {
                   adresse_unix.sun_family = AF_UNIX;
                   strncpy(adresse_unix.sun_path, (*((struct_socket *)
                           (*s_objet_argument_1).objet)).adresse_distante,
                           UNIX_PATH_MAX);
                   adresse_unix.sun_path[UNIX_PATH_MAX - 1] =
                           d_code_fin_chaine;
   
   #               ifndef SEMAPHORES_NOMMES
                       if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
   #               else
                       if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #               endif
                   {
                       (*s_etat_processus).erreur_systeme = d_es_processus;
                       return;
                   }
   
                   if (sendto((*((struct_socket *)
                           (*s_objet_argument_1).objet)).socket, chaine,
                           (size_t) longueur_effective, 0, (struct sockaddr *)
                           &adresse_unix, sizeof(adresse_unix)) < 0)
                   {
                       ios = errno;
   
   #                   ifndef SEMAPHORES_NOMMES
                           while(sem_wait(&((*s_etat_processus).semaphore_fork))
                                   != 0)
   #                   else
                           while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
   #                   endif
                     {                      {
                         if (errno != EINTR)                          if (errno != EINTR)
                         {                          {
Line 1397  instruction_write(struct_processus *s_et Line 1857  instruction_write(struct_processus *s_et
                         }                          }
                     }                      }
   
                     if (ios == EPIPE)                      if ((ios == EPIPE) || (ios == ECONNRESET))
                     {                      {
                         (*s_etat_processus).erreur_execution =                          (*s_etat_processus).erreur_execution =
                                 d_ex_erreur_acces_fichier;                                  d_ex_erreur_acces_fichier;
                         return;                          return;
                     }                      }
   
                       if (ios == EMSGSIZE)
                       {
                           (*s_etat_processus).erreur_execution =
                                   d_ex_taille_message;
                           return;
                       }
   
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                     return;                      return;
                 }                  }
   
                 while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  #               ifndef SEMAPHORES_NOMMES
                       while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
   #               else
                       while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
   #               endif
                 {                  {
                     if (errno != EINTR)                      if (errno != EINTR)
                     {                      {
                         if (sigaction(SIGPIPE, &registre, NULL) != 0)  
                         {  
                             (*s_etat_processus).erreur_systeme = d_es_signal;  
                             return;  
                         }  
   
                         (*s_etat_processus).erreur_systeme = d_es_processus;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
                     }                      }
                 }                  }
   
                 if (sigaction(SIGPIPE, &registre, NULL) != 0)  
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_signal;  
                     return;  
                 }  
             }              }
             else              else if ((*((struct_socket *) (*s_objet_argument_1).objet))
             { // Sockets non connectées                      .domaine == PF_INET)
               {
                 /*                  if (sscanf((*((struct_socket *)
                  * Vérification de l'adresse distante                          (*s_objet_argument_1).objet))
                  */                          .adresse_distante, "%d.%d.%d.%d(%d)",
                           &(adresse[0]), &(adresse[1]), &(adresse[2]),
                 if (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))                          &(adresse[3]), &port) == 5)
                         .adresse_distante, "") == 0)                  { // Adresse IPv4
                 {                      calcul_adresse = 0;
                     liberation(s_etat_processus, s_objet_argument_1);                      for(i = 0; i < 4; calcul_adresse =
                     liberation(s_etat_processus, s_objet_argument_2);                              (256 * calcul_adresse) +
                               ((unsigned char) adresse[i++]));
                     (*s_etat_processus).erreur_execution =  
                             d_ex_erreur_acces_fichier;                      memset(&adresse_ipv4, 0, sizeof(adresse_ipv4));
                     return;                      adresse_ipv4.sin_family = AF_INET;
                 }                      adresse_ipv4.sin_port = htons((uint16_t) port);
                       adresse_ipv4.sin_addr.s_addr = htonl(calcul_adresse);
                 /*  
                  * Création de l'adresse logique  #                   ifndef SEMAPHORES_NOMMES
                  */                          if (sem_post(&((*s_etat_processus).semaphore_fork))
                                   != 0)
                 if ((*((struct_socket *) (*s_objet_argument_1).objet))  #                   else
                         .domaine == PF_UNIX)                          if (sem_post((*s_etat_processus).semaphore_fork) != 0)
                 {  #                   endif
                     adresse_unix.sun_family = AF_UNIX;  
                     strncpy(adresse_unix.sun_path, (*((struct_socket *)  
                             (*s_objet_argument_1).objet)).adresse_distante,  
                             108);  
                     adresse_unix.sun_path[108 - 1] = d_code_fin_chaine;  
   
                     if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)  
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es_processus;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
Line 1468  instruction_write(struct_processus *s_et Line 1920  instruction_write(struct_processus *s_et
   
                     if (sendto((*((struct_socket *)                      if (sendto((*((struct_socket *)
                             (*s_objet_argument_1).objet)).socket, chaine,                              (*s_objet_argument_1).objet)).socket, chaine,
                             strlen(chaine), 0, (struct sockaddr *)                              (size_t) longueur_effective, 0, (struct sockaddr *)
                             &adresse_unix, sizeof(adresse_unix)) < 0)                              &adresse_ipv4, sizeof(adresse_ipv4)) < 0)
                     {                      {
                         while(sem_wait(&((*s_etat_processus)                          ios = errno;
                                 .semaphore_fork)) == -1)  
   #                       ifndef SEMAPHORES_NOMMES
                               while(sem_wait(&((*s_etat_processus)
                                       .semaphore_fork)) != 0)
   #                       else
                               while(sem_wait((*s_etat_processus)
                                       .semaphore_fork) != 0)
   #                       endif
                         {                          {
                             if (errno != EINTR)                              if (errno != EINTR)
                             {                              {
Line 1482  instruction_write(struct_processus *s_et Line 1941  instruction_write(struct_processus *s_et
                             }                              }
                         }                          }
   
                           if ((ios == EPIPE) || (ios == ECONNRESET))
                           {
                               (*s_etat_processus).erreur_execution =
                                       d_ex_erreur_acces_fichier;
                               return;
                           }
   
                           if (ios == EMSGSIZE)
                           {
                               (*s_etat_processus).erreur_execution =
                                       d_ex_taille_message;
                               return;
                           }
   
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
                                 d_es_erreur_fichier;                                  d_es_erreur_fichier;
                         return;                          return;
                     }                      }
   
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  #                   ifndef SEMAPHORES_NOMMES
                           while(sem_wait(&((*s_etat_processus).semaphore_fork))
                                   != 0)
   #                   else
                           while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
   #                   endif
                     {                      {
                         if (errno != EINTR)                          if (errno != EINTR)
                         {                          {
Line 1496  instruction_write(struct_processus *s_et Line 1974  instruction_write(struct_processus *s_et
                         }                          }
                     }                      }
                 }                  }
                 else if ((*((struct_socket *) (*s_objet_argument_1).objet))                  else
                         .domaine == PF_INET)  
                 {                  {
                     if (sscanf((*((struct_socket *)                      liberation(s_etat_processus, s_objet_argument_1);
                             (*s_objet_argument_1).objet))                      liberation(s_etat_processus, s_objet_argument_2);
                             .adresse_distante, "%d.%d.%d.%d(%d)",  
                             &(adresse[0]), &(adresse[1]), &(adresse[2]),  
                             &(adresse[3]), &port) == 5)  
                     { // Adresse IPv4  
                         calcul_adresse = 0;  
                         for(i = 0; i < 4; calcul_adresse =  
                                 (256 * calcul_adresse) + adresse[i++]);  
   
                         memset(&adresse_ipv4, 0, sizeof(adresse_ipv4));  
                         adresse_ipv4.sin_family = AF_INET;  
                         adresse_ipv4.sin_port = htons(port);  
                         adresse_ipv4.sin_addr.s_addr = htonl(calcul_adresse);  
   
                         if (sem_post(&((*s_etat_processus)  
                                 .semaphore_fork)) != 0)  
                         {  
                             (*s_etat_processus).erreur_systeme = d_es_processus;  
                             return;  
                         }  
   
                         if (sendto((*((struct_socket *)                      (*s_etat_processus).erreur_execution =
                                 (*s_objet_argument_1).objet)).socket, chaine,                              d_ex_erreur_parametre_fichier;
                                 strlen(chaine), 0, (struct sockaddr *)                      return;
                                 &adresse_ipv4, sizeof(adresse_ipv4)) < 0)                  }
                         {              }
                             while(sem_wait(&((*s_etat_processus)              else if ((*((struct_socket *) (*s_objet_argument_1).objet))
                                     .semaphore_fork)) == -1)                      .domaine == PF_INET6)
                             {              {
                                 if (errno != EINTR)                  if (sscanf((*((struct_socket *) (*s_objet_argument_1)
                                 {                          .objet)).adresse_distante, "%X:%X:%X:%X:%X:"
                                     (*s_etat_processus).erreur_systeme =                          "%X:%X:%X:%X:%X:%X:%X:%X:%X:%X:%X(%d)",
                                             d_es_processus;                          &(adresse[0]), &(adresse[1]), &(adresse[2]),
                                     return;                          &(adresse[3]), &(adresse[4]), &(adresse[5]),
                                 }                          &(adresse[6]), &(adresse[7]), &(adresse[8]),
                             }                          &(adresse[9]), &(adresse[10]), &(adresse[11]),
                           &(adresse[12]), &(adresse[13]), &(adresse[14]),
                           &(adresse[15]), &port)== 17)
                   { // Adresse IPv6
   #                   ifdef IPV6
                       memset(&adresse_ipv6, 0, sizeof(adresse_ipv6));
                       adresse_ipv6.sin6_family = AF_INET6;
                       adresse_ipv6.sin6_port = htons((uint16_t) port);
   
                       for(i = 0; i < 16;
                               adresse_ipv6.sin6_addr.s6_addr[i] =
                               (unsigned char) adresse[i], i++);
   
   #                   ifndef SEMAPHORES_NOMMES
                           if (sem_post(&((*s_etat_processus).semaphore_fork))
                                   != 0)
   #                   else
                           if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #                   endif
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
   
                             (*s_etat_processus).erreur_systeme =                      if (sendto((*((struct_socket *)
                                     d_es_erreur_fichier;                              (*s_objet_argument_1).objet)).socket, chaine,
                             return;                              (size_t) longueur_effective, 0, (struct sockaddr *)
                         }                              &adresse_ipv6, sizeof(adresse_ipv6)) < 0)
                       {
                           ios = errno;
   
                         while(sem_wait(&((*s_etat_processus)  #                       ifndef SEMAPHORES_NOMMES
                                 .semaphore_fork)) == -1)                              while(sem_wait(&((*s_etat_processus)
                                       .semaphore_fork)) != 0)
   #                       else
                               while(sem_wait((*s_etat_processus)
                                       .semaphore_fork) != 0)
   #                       endif
                         {                          {
                             if (errno != EINTR)                              if (errno != EINTR)
                             {                              {
Line 1552  instruction_write(struct_processus *s_et Line 2039  instruction_write(struct_processus *s_et
                                 return;                                  return;
                             }                              }
                         }                          }
                     }  
                     else  
                     {  
                         liberation(s_etat_processus, s_objet_argument_1);  
                         liberation(s_etat_processus, s_objet_argument_2);  
   
                         (*s_etat_processus).erreur_execution =                          if ((ios == EPIPE) || (ios == ECONNRESET))
                                 d_ex_erreur_parametre_fichier;  
                         return;  
                     }  
                 }  
                 else if ((*((struct_socket *) (*s_objet_argument_1).objet))  
                         .domaine == PF_INET6)  
                 {  
                     if (sscanf((*((struct_socket *) (*s_objet_argument_1)  
                             .objet)).adresse_distante, "%X:%X:%X:%X:%X:"  
                             "%X:%X:%X:%X:%X:%X:%X:%X:%X:%X:%X(%d)",  
                             &(adresse[0]), &(adresse[1]), &(adresse[2]),  
                             &(adresse[3]), &(adresse[4]), &(adresse[5]),  
                             &(adresse[6]), &(adresse[7]), &(adresse[8]),  
                             &(adresse[9]), &(adresse[10]), &(adresse[11]),  
                             &(adresse[12]), &(adresse[13]), &(adresse[14]),  
                             &(adresse[15]), &port)== 17)  
                     { // Adresse IPv6  
                         memset(&adresse_ipv6, 0, sizeof(adresse_ipv6));  
                         adresse_ipv6.sin6_family = AF_INET6;  
                         adresse_ipv6.sin6_port = htons((uint16_t) port);  
   
                         for(i = 0; i < 16;  
                                 adresse_ipv6.sin6_addr.s6_addr[i] =  
                                 adresse[i], i++);  
   
                         if (sem_post(&((*s_etat_processus)  
                                 .semaphore_fork)) != 0)  
                         {                          {
                             (*s_etat_processus).erreur_systeme = d_es_processus;                              (*s_etat_processus).erreur_execution =
                                       d_ex_erreur_acces_fichier;
                             return;                              return;
                         }                          }
   
                         if (sendto((*((struct_socket *)                          if (ios == EMSGSIZE)
                                 (*s_objet_argument_1).objet)).socket, chaine,  
                                 strlen(chaine), 0, (struct sockaddr *)  
                                 &adresse_ipv6, sizeof(adresse_ipv6)) < 0)  
                         {                          {
                             while(sem_wait(&((*s_etat_processus)                              (*s_etat_processus).erreur_execution =
                                     .semaphore_fork)) == -1)                                      d_ex_taille_message;
                             {  
                                 if (errno != EINTR)  
                                 {  
                                     (*s_etat_processus).erreur_systeme =  
                                             d_es_processus;  
                                     return;  
                                 }  
                             }  
   
                             (*s_etat_processus).erreur_systeme =  
                                     d_es_erreur_fichier;  
                             return;                              return;
                         }                          }
   
                         while(sem_wait(&((*s_etat_processus)                          (*s_etat_processus).erreur_systeme =
                                 .semaphore_fork)) == -1)                                  d_es_erreur_fichier;
                           return;
                       }
   
   #                   ifndef SEMAPHORES_NOMMES
                           while(sem_wait(&((*s_etat_processus).semaphore_fork))
                                   != 0)
   #                   else
                           while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
   #                   endif
                       {
                           if (errno != EINTR)
                         {                          {
                             if (errno != EINTR)                              (*s_etat_processus).erreur_systeme =
                             {                                      d_es_processus;
                                 (*s_etat_processus).erreur_systeme =                              return;
                                         d_es_processus;  
                                 return;  
                             }  
                         }                          }
                     }                      }
   #                   else
                       if ((*s_etat_processus).langue == 'F')
                       {
                           printf("+++Attention : Support du protocole"
                                   " IPv6 indisponible\n");
                       }
                     else                      else
                     {                      {
                         liberation(s_etat_processus, s_objet_argument_1);                          printf("+++Warning : IPv6 support "
                         liberation(s_etat_processus, s_objet_argument_2);                                  "unavailable\n");
   
                         (*s_etat_processus).erreur_execution =  
                                 d_ex_erreur_parametre_fichier;  
                         return;  
                     }                      }
   #                   endif
                 }                  }
                 else                   else
                 {                  {
                     liberation(s_etat_processus, s_objet_argument_1);                      liberation(s_etat_processus, s_objet_argument_1);
                     liberation(s_etat_processus, s_objet_argument_2);                      liberation(s_etat_processus, s_objet_argument_2);
Line 1643  instruction_write(struct_processus *s_et Line 2096  instruction_write(struct_processus *s_et
                     return;                      return;
                 }                  }
             }              }
               else 
               {
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
   
             free(chaine);                  (*s_etat_processus).erreur_execution =
         }                          d_ex_erreur_parametre_fichier;
         else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire                  return;
                 == 'Y')              }
         {  
             /*  
              * Sockets non formatées  
              */  
         }  
         else  
         {  
             /*  
              *  Sockets de type FLOW  
              */  
         }          }
   
           free(chaine);
     }      }
     else      else
     {      {
Line 1766  instruction_wflock(struct_processus *s_e Line 2215  instruction_wflock(struct_processus *s_e
   
         do          do
         {          {
             if ((chaine = conversion_majuscule((unsigned char *)              if ((chaine = conversion_majuscule(s_etat_processus,
                     (*s_objet_argument_1).objet)) == NULL)                      (unsigned char *) (*s_objet_argument_1).objet)) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
Line 1819  instruction_wflock(struct_processus *s_e Line 2268  instruction_wflock(struct_processus *s_e
                 return;                  return;
             }              }
   
             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)  #           ifndef SEMAPHORES_NOMMES
                   if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
   #           else
                   if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #           endif
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
   
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  #           ifndef SEMAPHORES_NOMMES
                   while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
   #           else
                   while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
   #           endif
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
                 {                  {
Line 1840  instruction_wflock(struct_processus *s_e Line 2297  instruction_wflock(struct_processus *s_e
             }              }
             else              else
             {              {
                   if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions)
                           != 0)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_processus;
                       return;
                   }
   
                 if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)                  if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
                 {                  {
                     affectation_interruptions_logicielles(s_etat_processus);                      affectation_interruptions_logicielles(s_etat_processus);
                 }                  }
   
                 if ((*s_etat_processus).nombre_interruptions_en_queue                  if (pthread_mutex_unlock(&(*s_etat_processus)
                         != 0)                          .mutex_interruptions) != 0)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_processus;
                       return;
                   }
   
                   if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
                 {                  {
                     registre_instruction_valide =                      registre_instruction_valide =
                             (*s_etat_processus).instruction_valide;                              (*s_etat_processus).instruction_valide;
Line 1960  instruction_wfproc(struct_processus *s_e Line 2430  instruction_wfproc(struct_processus *s_e
             }              }
         }          }
   
         if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)          if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus))
                   != 0)
         {          {
             if ((*s_etat_processus).profilage == d_vrai)              if ((*s_etat_processus).profilage == d_vrai)
             {              {
Line 2025  instruction_wfproc(struct_processus *s_e Line 2496  instruction_wfproc(struct_processus *s_e
                     profilage(s_etat_processus, NULL);                      profilage(s_etat_processus, NULL);
                 }                  }
   
                 if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)                  if (pthread_mutex_unlock(&((*s_etat_processus)
                           .mutex_pile_processus)) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
Line 2048  instruction_wfproc(struct_processus *s_e Line 2520  instruction_wfproc(struct_processus *s_e
                 if ((*(*((struct_processus_fils *) (*(*l_element_courant)                  if ((*(*((struct_processus_fils *) (*(*l_element_courant)
                         .donnee).objet)).thread).processus_detache == d_vrai)                          .donnee).objet)).thread).processus_detache == d_vrai)
                 {                  {
                     if (kill((*(*((struct_processus_fils *)                      if (envoi_signal_processus((*(*((struct_processus_fils *)
                             (*(*l_element_courant).donnee).objet)).thread).pid,                              (*(*l_element_courant).donnee).objet)).thread).pid,
                             0) != 0)                              rpl_signull) != 0)
                     {                      {
                         drapeau_fin = d_vrai;                          drapeau_fin = d_vrai;
                     }                      }
Line 2105  instruction_wfproc(struct_processus *s_e Line 2577  instruction_wfproc(struct_processus *s_e
                      * Le processus n'est pas terminé                       * Le processus n'est pas terminé
                      */                       */
   
                     if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)                      if (pthread_mutex_lock(&((*s_etat_processus)
                               .mutex_interruptions)) != 0)
                     {                      {
                           pthread_mutex_unlock(&((*s_etat_processus)
                                   .mutex_pile_processus));
   
                         if ((*s_etat_processus).profilage == d_vrai)                          if ((*s_etat_processus).profilage == d_vrai)
                         {                          {
                             profilage(s_etat_processus, NULL);                              profilage(s_etat_processus, NULL);
Line 2123  instruction_wfproc(struct_processus *s_e Line 2599  instruction_wfproc(struct_processus *s_e
                         affectation_interruptions_logicielles(s_etat_processus);                          affectation_interruptions_logicielles(s_etat_processus);
                     }                      }
   
                     if ((*s_etat_processus).nombre_interruptions_en_queue                      if (pthread_mutex_unlock(&((*s_etat_processus)
                             != 0)                              .mutex_interruptions)) != 0)
                       {
                           pthread_mutex_unlock(&((*s_etat_processus)
                                   .mutex_pile_processus));
   
                           if ((*s_etat_processus).profilage == d_vrai)
                           {
                               profilage(s_etat_processus, NULL);
                           }
   
                           (*s_etat_processus).erreur_systeme =
                                   d_es_processus;
                           return;
                       }
   
                       if (pthread_mutex_unlock(&((*s_etat_processus)
                               .mutex_pile_processus)) != 0)
                       {
                           if ((*s_etat_processus).profilage == d_vrai)
                           {
                               profilage(s_etat_processus, NULL);
                           }
   
                           (*s_etat_processus).erreur_systeme =
                                   d_es_processus;
                           return;
                       }
   
                       if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
                     {                      {
                         registre_instruction_valide =                          registre_instruction_valide =
                                 (*s_etat_processus).instruction_valide;                                  (*s_etat_processus).instruction_valide;
Line 2134  instruction_wfproc(struct_processus *s_e Line 2638  instruction_wfproc(struct_processus *s_e
                                 registre_instruction_valide;                                  registre_instruction_valide;
                     }                      }
   
                     if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)  #                   ifndef SEMAPHORES_NOMMES
                           if (sem_post(&((*s_etat_processus).semaphore_fork))
                                   != 0)
   #                   else
                           if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #                   endif
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es_processus;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
Line 2142  instruction_wfproc(struct_processus *s_e Line 2651  instruction_wfproc(struct_processus *s_e
   
                     nanosleep(&attente, NULL);                      nanosleep(&attente, NULL);
   
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  #                   ifndef SEMAPHORES_NOMMES
                           while(sem_wait(&((*s_etat_processus).semaphore_fork))
                                   != 0)
   #                   else
                           while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
   #                   endif
                     {                      {
                         if (errno != EINTR)                          if (errno != EINTR)
                         {                          {
Line 2153  instruction_wfproc(struct_processus *s_e Line 2667  instruction_wfproc(struct_processus *s_e
   
                     scrutation_injection(s_etat_processus);                      scrutation_injection(s_etat_processus);
   
                     if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)                      if (pthread_mutex_lock(&((*s_etat_processus)
                               .mutex_pile_processus)) != 0)
                     {                      {
                         if ((*s_etat_processus).profilage == d_vrai)                          if ((*s_etat_processus).profilage == d_vrai)
                         {                          {
Line 2175  instruction_wfproc(struct_processus *s_e Line 2690  instruction_wfproc(struct_processus *s_e
             profilage(s_etat_processus, NULL);              profilage(s_etat_processus, NULL);
         }          }
   
         if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)          if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus))
                   != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
Line 2278  instruction_wfdata(struct_processus *s_e Line 2794  instruction_wfdata(struct_processus *s_e
             }              }
         }          }
   
         if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)          if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus))
                   != 0)
         {          {
             if ((*s_etat_processus).profilage == d_vrai)              if ((*s_etat_processus).profilage == d_vrai)
             {              {
Line 2338  instruction_wfdata(struct_processus *s_e Line 2855  instruction_wfdata(struct_processus *s_e
                     profilage(s_etat_processus, NULL);                      profilage(s_etat_processus, NULL);
                 }                  }
   
                 if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)                  if (pthread_mutex_unlock(&((*s_etat_processus)
                           .mutex_pile_processus)) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
Line 2381  instruction_wfdata(struct_processus *s_e Line 2899  instruction_wfdata(struct_processus *s_e
                         return;                          return;
                     }                      }
   
                     if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)                      if (pthread_mutex_unlock(&((*s_etat_processus)
                               .mutex_pile_processus)) != 0)
                     {                      {
                         if ((*s_etat_processus).profilage == d_vrai)                          if ((*s_etat_processus).profilage == d_vrai)
                         {                          {
Line 2393  instruction_wfdata(struct_processus *s_e Line 2912  instruction_wfdata(struct_processus *s_e
                         return;                          return;
                     }                      }
   
                     if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)  #                   ifndef SEMAPHORES_NOMMES
                           if (sem_post(&((*s_etat_processus).semaphore_fork))
                                   != 0)
   #                   else
                           if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #                   endif
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es_processus;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
Line 2401  instruction_wfdata(struct_processus *s_e Line 2925  instruction_wfdata(struct_processus *s_e
   
                     nanosleep(&attente, NULL);                      nanosleep(&attente, NULL);
   
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  #                   ifndef SEMAPHORES_NOMMES
                           while(sem_wait(&((*s_etat_processus).semaphore_fork))
                                   != 0)
   #                   else
                           while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
   #                   endif
                     {                      {
                         if (errno != EINTR)                          if (errno != EINTR)
                         {                          {
Line 2412  instruction_wfdata(struct_processus *s_e Line 2941  instruction_wfdata(struct_processus *s_e
   
                     scrutation_injection(s_etat_processus);                      scrutation_injection(s_etat_processus);
   
                       if (pthread_mutex_lock(&(*s_etat_processus)
                               .mutex_interruptions) != 0)
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
   
                     if ((*s_etat_processus).nombre_interruptions_non_affectees                      if ((*s_etat_processus).nombre_interruptions_non_affectees
                             != 0)                              != 0)
                     {                      {
                         affectation_interruptions_logicielles(s_etat_processus);                          affectation_interruptions_logicielles(s_etat_processus);
                     }                      }
   
                       if (pthread_mutex_unlock(&(*s_etat_processus)
                               .mutex_interruptions) != 0)
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
   
                     if ((*s_etat_processus).nombre_interruptions_en_queue != 0)                      if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
                     {                      {
                         registre_instruction_valide =                          registre_instruction_valide =
Line 2437  instruction_wfdata(struct_processus *s_e Line 2980  instruction_wfdata(struct_processus *s_e
                         return;                          return;
                     }                      }
   
                     if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)                      if (pthread_mutex_lock(&((*s_etat_processus)
                               .mutex_pile_processus)) != 0)
                     {                      {
                         if ((*s_etat_processus).profilage == d_vrai)                          if ((*s_etat_processus).profilage == d_vrai)
                         {                          {
Line 2464  instruction_wfdata(struct_processus *s_e Line 3008  instruction_wfdata(struct_processus *s_e
             profilage(s_etat_processus, NULL);              profilage(s_etat_processus, NULL);
         }          }
   
         if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)          if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus))
                   != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
Line 2510  instruction_wfsock(struct_processus *s_e Line 3055  instruction_wfsock(struct_processus *s_e
     struct_objet            *s_objet_argument;      struct_objet            *s_objet_argument;
     struct_objet            *s_objet_resultat;      struct_objet            *s_objet_resultat;
   
       struct pollfd           s_poll;
   
     struct sockaddr_in      adresse_ipv4;      struct sockaddr_in      adresse_ipv4;
   #   ifdef IPV6
     struct sockaddr_in6     adresse_ipv6;      struct sockaddr_in6     adresse_ipv6;
   #   endif
   
     unsigned long           i;      unsigned long           i;
   
Line 2561  instruction_wfsock(struct_processus *s_e Line 3110  instruction_wfsock(struct_processus *s_e
                 "STREAM") != 0) && (strcmp((*((struct_socket *)                  "STREAM") != 0) && (strcmp((*((struct_socket *)
                 (*s_objet_argument).objet)).type, "SEQUENTIAL DATAGRAM") != 0))                  (*s_objet_argument).objet)).type, "SEQUENTIAL DATAGRAM") != 0))
         {          {
             liberation(s_etat_processus, s_objet_argument);              // Mode non connecté : l'attente se fait sur un poll()
   
             (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;              if ((s_objet_resultat = copie_objet(s_etat_processus,
             return;                      s_objet_argument, 'P')) == NULL)
         }              {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
         if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument,                  return;
                 'O')) == NULL)              }
         {  
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
             return;  
         }  
   
         (*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute = 'N';              s_poll.fd = (*((struct_socket *) (*s_objet_argument).objet)).socket;
         (*((struct_socket *) (*s_objet_resultat).objet)).effacement = 'N';              s_poll.events = POLLIN;
               s_poll.revents = 0;
         if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine == PF_INET)  
         {  
             longueur = sizeof(adresse_ipv4);  
   
             do              do
             {              {
                 drapeau = d_vrai;                  drapeau = d_vrai;
   
   #               ifndef SEMAPHORES_NOMMES
                 if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                  if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
   #               else
                   if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #               endif
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
                 }                  }
   
                 if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =                  if (poll(&s_poll, 1, -1) < 0)
                         accept((*((struct_socket *) (*s_objet_argument).objet))  
                         .socket, (struct sockaddr *) &adresse_ipv4, &longueur))  
                         < 0)  
                 {                  {
                     erreur = errno;                      erreur = errno;
   
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  #                   ifndef SEMAPHORES_NOMMES
                     {                      while(sem_wait(&((*s_etat_processus)
                         if (errno != EINTR)                              .semaphore_fork)) != 0)
                         {  #                   else
                             (*s_etat_processus).erreur_systeme = d_es_processus;                      while(sem_wait((*s_etat_processus).semaphore_fork)
                             return;                              != 0)
                         }  #                   endif
                     }  
   
                     if (erreur != EINTR)                      if (erreur != EINTR)
                     {                      {
Line 2630  instruction_wfsock(struct_processus *s_e Line 3172  instruction_wfsock(struct_processus *s_e
                 }                  }
                 else                  else
                 {                  {
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  #                   ifndef SEMAPHORES_NOMMES
                           while(sem_wait(&((*s_etat_processus)
                                   .semaphore_fork)) != 0)
   #                   else
                           while(sem_wait((*s_etat_processus).semaphore_fork)
                                   != 0)
   #                   endif
                     {                      {
                         if (errno != EINTR)                          if (errno != EINTR)
                         {                          {
                             (*s_etat_processus).erreur_systeme = d_es_processus;                              (*s_etat_processus).erreur_systeme =
                                       d_es_processus;
                             return;                              return;
                         }                          }
                     }                      }
                 }                  }
             } while(drapeau == d_faux);              } while(drapeau == d_faux);
   
             if (((*((struct_socket *) (*s_objet_resultat).objet))              if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                     .adresse_distante = malloc(22 *                      s_objet_argument) == d_erreur)
                     sizeof(unsigned char))) == NULL)  
             {              {
                 (*s_etat_processus).erreur_systeme =  
                         d_es_allocation_memoire;  
                 return;                  return;
             }              }
   
             sprintf((*((struct_socket *) (*s_objet_resultat).objet))              if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                     .adresse_distante, "%d.%d.%d.%d(%d)",                      s_objet_resultat) == d_erreur)
                     (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF,              {
                     (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF,                  return;
                     (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF,              }
                     ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF,  
                     ntohs(adresse_ipv4.sin_port));  
         }          }
         else if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine ==          else
                 PF_INET6)  
         {          {
             longueur = sizeof(adresse_ipv6);              // Mode connecté
   
             do              if ((s_objet_resultat = copie_objet(s_etat_processus,
                       s_objet_argument, 'O')) == NULL)
             {              {
                 drapeau = d_vrai;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
                 if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)              (*((struct_socket *) (*s_objet_resultat).objet)).effacement = 'N';
                 {              (*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      = 'N';
                     return;  
                 }  
   
                 if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =              if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine ==
                         accept((*((struct_socket *) (*s_objet_argument).objet))                      PF_INET)
                         .socket, (struct sockaddr *) &adresse_ipv6, &longueur))              {
                         < 0)                  longueur = sizeof(adresse_ipv4);
   
                   do
                 {                  {
                     erreur = errno;                      drapeau = d_vrai;
   
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  #               ifndef SEMAPHORES_NOMMES
                           if (sem_post(&((*s_etat_processus).semaphore_fork))
                                   != 0)
   #               else
                           if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #               endif
                     {                      {
                         if (errno != EINTR)                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         {                          return;
                             (*s_etat_processus).erreur_systeme = d_es_processus;  
                             return;  
                         }  
                     }                      }
   
                     if (erreur != EINTR)                      if (((*((struct_socket *) (*s_objet_resultat).objet))
                               .socket = accept((*((struct_socket *)
                               (*s_objet_argument).objet)).socket,
                               (struct sockaddr *) &adresse_ipv4, &longueur))
                               < 0)
                     {                      {
                         liberation(s_etat_processus, s_objet_argument);                          erreur = errno;
                         liberation(s_etat_processus, s_objet_resultat);  
   
                         (*s_etat_processus).erreur_execution =  #                       ifndef SEMAPHORES_NOMMES
                                 d_ex_erreur_acces_fichier;                          while(sem_wait(&((*s_etat_processus)
                         return;                                  .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;
                               }
                           }
   
                     scrutation_injection(s_etat_processus);                          if (erreur != EINTR)
                           {
                               liberation(s_etat_processus, s_objet_argument);
                               liberation(s_etat_processus, s_objet_resultat);
   
                     if ((*s_etat_processus).var_volatile_requete_arret != 0)                              (*s_etat_processus).erreur_execution =
                     {                                      d_ex_erreur_acces_fichier;
                         drapeau = d_vrai;                              return;
                           }
   
                           scrutation_injection(s_etat_processus);
   
                           if ((*s_etat_processus).var_volatile_requete_arret != 0)
                           {
                               drapeau = d_vrai;
                           }
                           else
                           {
                               drapeau = d_faux;
                           }
                     }                      }
                     else                      else
                     {                      {
                         drapeau = d_faux;  #                   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;
                               }
                           }
                     }                      }
                 }                  } while(drapeau == d_faux);
                 else  
                   if (((*((struct_socket *) (*s_objet_resultat).objet))
                           .adresse_distante = malloc(22 *
                           sizeof(unsigned char))) == NULL)
                 {                  {
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                      (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   sprintf((*((struct_socket *) (*s_objet_resultat).objet))
                           .adresse_distante, "%d.%d.%d.%d(%d)",
                           (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF,
                           (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF,
                           (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF,
                           ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF,
                           ntohs(adresse_ipv4.sin_port));
               }
               else if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine ==
                       PF_INET6)
               {
   #           ifdef IPV6
                   longueur = sizeof(adresse_ipv6);
   
                   do
                   {
                       drapeau = d_vrai;
   
   #               ifndef SEMAPHORES_NOMMES
                           if (sem_post(&((*s_etat_processus).semaphore_fork))
                                   != 0)
   #               else
                           if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #               endif
                     {                      {
                         if (errno != EINTR)                          (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
   
                       if (((*((struct_socket *) (*s_objet_resultat).objet))
                               .socket = accept((*((struct_socket *)
                               (*s_objet_argument).objet)).socket,
                               (struct sockaddr *) &adresse_ipv6, &longueur)) < 0)
                       {
                           erreur = errno;
   
   #                   ifndef SEMAPHORES_NOMMES
                               while(sem_wait(&((*s_etat_processus)
                                       .semaphore_fork)) != 0)
   #                   else
                               while(sem_wait((*s_etat_processus).semaphore_fork)
                                       != 0)
   #                   endif
                         {                          {
                             (*s_etat_processus).erreur_systeme = d_es_processus;                              if (errno != EINTR)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_processus;
                                   return;
                               }
                           }
   
                           if (erreur != EINTR)
                           {
                               liberation(s_etat_processus, s_objet_argument);
                               liberation(s_etat_processus, s_objet_resultat);
   
                               (*s_etat_processus).erreur_execution =
                                       d_ex_erreur_acces_fichier;
                             return;                              return;
                         }                          }
   
                           scrutation_injection(s_etat_processus);
   
                           if ((*s_etat_processus).var_volatile_requete_arret != 0)
                           {
                               drapeau = d_vrai;
                           }
                           else
                           {
                               drapeau = d_faux;
                           }
                     }                      }
                       else
                       {
   #                   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;
                               }
                           }
                       }
                   } while(drapeau == d_faux);
   
                   if (((*((struct_socket *) (*s_objet_resultat).objet))
                           .adresse_distante = malloc(55 *
                           sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                 }                  }
             } while(drapeau == d_faux);  
   
             if (((*((struct_socket *) (*s_objet_resultat).objet))                  (*((struct_socket *) (*s_objet_resultat).objet))
                     .adresse_distante = malloc(55 *                          .adresse_distante = d_code_fin_chaine;
                     sizeof(unsigned char))) == NULL)  
             {  
                 (*s_etat_processus).erreur_systeme =  
                         d_es_allocation_memoire;  
                 return;  
             }  
   
             (*((struct_socket *) (*s_objet_resultat).objet))                  for(i = 0; i < 16; i++)
                     .adresse_distante = d_code_fin_chaine;                  {
                       sprintf((*((struct_socket *) (*s_objet_resultat)
                               .objet)).adresse_distante, (i == 0) ? "%s%X"
                               : "%s:%X", (*((struct_socket *) (*s_objet_resultat)
                               .objet)).adresse_distante,
                               adresse_ipv6.sin6_addr.s6_addr[i]);
                   }
   
             for(i = 0; i < 16; i++)  
             {  
                 sprintf((*((struct_socket *) (*s_objet_resultat)                  sprintf((*((struct_socket *) (*s_objet_resultat)
                         .objet)).adresse_distante, (i == 0) ? "%s%X" : "%s:%X",                          .objet)).adresse_distante, "%s(%u)",
                         (*((struct_socket *) (*s_objet_resultat)                          (*((struct_socket *) (*s_objet_resultat)
                         .objet)).adresse_distante,                          .objet)).adresse_distante,
                         adresse_ipv6.sin6_addr.s6_addr[i]);                          ntohs(adresse_ipv6.sin6_port));
   #           else
                   if ((*s_etat_processus).langue == 'F')
                   {
                       printf("+++Attention : Support du protocole"
                               " IPv6 indisponible\n");
                   }
                   else
                   {
                       printf("+++Warning : IPv6 support "
                               "unavailable\n");
                   }
   #           endif
             }              }
               else
             sprintf((*((struct_socket *) (*s_objet_resultat)  
                     .objet)).adresse_distante, "%s(%u)",  
                     (*((struct_socket *) (*s_objet_resultat)  
                     .objet)).adresse_distante, ntohs(adresse_ipv6.sin6_port));  
         }  
         else  
         {  
             longueur = 0;  
   
             do  
             {              {
                 drapeau = d_vrai;                  longueur = 0;
   
                 if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                  do
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      drapeau = d_vrai;
                     return;  
                 }  
   
                 if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =  #               ifndef SEMAPHORES_NOMMES
                         accept((*((struct_socket *) (*s_objet_argument).objet))                          if (sem_post(&((*s_etat_processus).semaphore_fork))
                         .socket, NULL, &longueur)) < 0)                                  != 0)
                 {  #               else
                     erreur = errno;                          if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #               endif
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
   
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                      if (((*((struct_socket *) (*s_objet_resultat).objet))
                               .socket = accept((*((struct_socket *)
                               (*s_objet_argument).objet)).socket, NULL,
                               &longueur)) < 0)
                     {                      {
                         if (errno != EINTR)                          erreur = errno;
   
   #                   ifndef SEMAPHORES_NOMMES
                               while(sem_wait(&((*s_etat_processus)
                                       .semaphore_fork)) != 0)
   #                   else
                               while(sem_wait((*s_etat_processus).semaphore_fork)
                                       != 0)
   #                   endif
                         {                          {
                             (*s_etat_processus).erreur_systeme = d_es_processus;                              if (errno != EINTR)
                             return;                              {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_processus;
                                   return;
                               }
                         }                          }
                     }  
   
                     if (erreur != EINTR)                          if (erreur != EINTR)
                     {                          {
                         liberation(s_etat_processus, s_objet_argument);                              liberation(s_etat_processus, s_objet_argument);
                         liberation(s_etat_processus, s_objet_resultat);                              liberation(s_etat_processus, s_objet_resultat);
   
                         (*s_etat_processus).erreur_execution =                              (*s_etat_processus).erreur_execution =
                                 d_ex_erreur_acces_fichier;                                      d_ex_erreur_acces_fichier;
                         return;                              return;
                     }                          }
   
                     scrutation_injection(s_etat_processus);                          scrutation_injection(s_etat_processus);
   
                     if ((*s_etat_processus).var_volatile_requete_arret != 0)                          if ((*s_etat_processus).var_volatile_requete_arret != 0)
                     {                          {
                         drapeau = d_vrai;                              drapeau = d_vrai;
                           }
                           else
                           {
                               drapeau = d_faux;
                           }
                     }                      }
                     else                      else
                     {                      {
                         drapeau = d_faux;  #                   ifndef SEMAPHORES_NOMMES
                     }                              while(sem_wait(&((*s_etat_processus)
                 }                                      .semaphore_fork)) != 0)
                 else  #                   else
                 {                              while(sem_wait((*s_etat_processus).semaphore_fork)
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                                      != 0)
                     {  #                   endif
                         if (errno != EINTR)  
                         {                          {
                             (*s_etat_processus).erreur_systeme = d_es_processus;                              if (errno != EINTR)
                             return;                              {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_processus;
                                   return;
                               }
                         }                          }
                     }                      }
                 }                  } while(drapeau == d_faux);
             } while(drapeau == d_faux);              }
         }  
   
         // Si accept() renvoie une erreur non récupérée, il ne peut s'agir  
         // que de EINTR sachant qu'une requête d'arrêt est en court de  
         // traitement.  
   
         if ((*((struct_socket *) (*s_objet_resultat).objet)).socket >= 0)              // Si accept() renvoie une erreur non récupérée, il ne peut s'agir
         {              // que de EINTR sachant qu'une requête d'arrêt est en court de
             l_element_courant = (*s_etat_processus).s_sockets;              // traitement.
   
             if (l_element_courant == NULL)              if ((*((struct_socket *) (*s_objet_resultat).objet)).socket >= 0)
             {              {
                 if (((*s_etat_processus).s_sockets =                  l_element_courant = (*s_etat_processus).s_sockets;
                         allocation_maillon(s_etat_processus)) == NULL)  
                   if (l_element_courant == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      if (((*s_etat_processus).s_sockets =
                             d_es_allocation_memoire;                              allocation_maillon(s_etat_processus)) == NULL)
                     return;                      {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       (*(*s_etat_processus).s_sockets).suivant = NULL;
                       l_element_courant = (*s_etat_processus).s_sockets;
                 }                  }
                   else
                   {
                       /*
                        * Ajout d'un élément à la fin de la liste chaînée
                        */
   
                 (*(*s_etat_processus).s_sockets).suivant = NULL;                      while((*l_element_courant).suivant != NULL)
                 l_element_courant = (*s_etat_processus).s_sockets;                      {
             }                          l_element_courant = (*l_element_courant).suivant;
             else                      }
             {  
                 /*                      if (((*l_element_courant).suivant =
                  * Ajout d'un élément à la fin de la liste chaînée                              allocation_maillon(s_etat_processus)) == NULL)
                  */                      {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                 while((*l_element_courant).suivant != NULL)  
                 {  
                     l_element_courant = (*l_element_courant).suivant;                      l_element_courant = (*l_element_courant).suivant;
                       (*l_element_courant).suivant = NULL;
                 }                  }
   
                 if (((*l_element_courant).suivant =                  if (((*l_element_courant).donnee = copie_objet(s_etat_processus,
                         allocation_maillon(s_etat_processus)) == NULL)                          s_objet_resultat, 'O')) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
                     return;                      return;
                 }                  }
   
                 l_element_courant = (*l_element_courant).suivant;  
                 (*l_element_courant).suivant = NULL;  
             }              }
   
             if (((*l_element_courant).donnee = copie_objet(s_etat_processus,              if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                     s_objet_resultat, 'O')) == NULL)                      s_objet_argument) == d_erreur)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
                 return;                  return;
             }              }
         }  
   
         if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),              if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                 s_objet_argument) == d_erreur)                      s_objet_resultat) == d_erreur)
         {              {
             return;                  return;
         }              }
   
         if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),  
                 s_objet_resultat) == d_erreur)  
         {  
             return;  
         }          }
     }      }
     else      else
Line 2977  instruction_wfswi(struct_processus *s_et Line 3693  instruction_wfswi(struct_processus *s_et
                 return;                  return;
             }              }
   
               if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions)
                       != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   
             if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)              if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
             {              {
                 affectation_interruptions_logicielles(s_etat_processus);                  affectation_interruptions_logicielles(s_etat_processus);
             }              }
   
               if (pthread_mutex_unlock(&(*s_etat_processus).mutex_interruptions)
                       != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   
             if ((*s_etat_processus).queue_interruptions[interruption - 1] > 0)              if ((*s_etat_processus).queue_interruptions[interruption - 1] > 0)
             {              {
                 drapeau_fin = d_vrai;                  drapeau_fin = d_vrai;
Line 3087  instruction_wfpoke(struct_processus *s_e Line 3817  instruction_wfpoke(struct_processus *s_e
   
     do      do
     {      {
         if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)  #       ifndef SEMAPHORES_NOMMES
               if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
   #       else
               if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #       endif
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
Line 3095  instruction_wfpoke(struct_processus *s_e Line 3829  instruction_wfpoke(struct_processus *s_e
   
         nanosleep(&attente, NULL);          nanosleep(&attente, NULL);
   
         while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  #       ifndef SEMAPHORES_NOMMES
               while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
   #       else
               while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
   #       endif
         {          {
             if (errno != EINTR)              if (errno != EINTR)
             {              {
Line 3106  instruction_wfpoke(struct_processus *s_e Line 3844  instruction_wfpoke(struct_processus *s_e
   
         scrutation_injection(s_etat_processus);          scrutation_injection(s_etat_processus);
   
           if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
   
         if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)          if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
         {          {
             affectation_interruptions_logicielles(s_etat_processus);              affectation_interruptions_logicielles(s_etat_processus);
         }          }
   
           if (pthread_mutex_unlock(&(*s_etat_processus).mutex_interruptions) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
   
         if ((*s_etat_processus).nombre_interruptions_en_queue != 0)          if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
         {          {
             registre_instruction_valide =              registre_instruction_valide =
Line 3213  instruction_wfack(struct_processus *s_et Line 3963  instruction_wfack(struct_processus *s_et
     {      {
         scrutation_injection(s_etat_processus);          scrutation_injection(s_etat_processus);
   
           if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
   
         if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)          if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
         {          {
             affectation_interruptions_logicielles(s_etat_processus);              affectation_interruptions_logicielles(s_etat_processus);
         }          }
   
           if (pthread_mutex_unlock(&(*s_etat_processus).mutex_interruptions) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
   
         if ((*s_etat_processus).nombre_interruptions_en_queue != 0)          if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
         {          {
             registre_instruction_valide =              registre_instruction_valide =
Line 3237  instruction_wfack(struct_processus *s_et Line 3999  instruction_wfack(struct_processus *s_et
             return;              return;
         }          }
   
         if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)  #       ifndef SEMAPHORES_NOMMES
               if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
   #       else
               if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #       endif
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
Line 3246  instruction_wfack(struct_processus *s_et Line 4012  instruction_wfack(struct_processus *s_et
         nanosleep(&attente, NULL);          nanosleep(&attente, NULL);
         INCR_GRANULARITE(attente.tv_nsec);          INCR_GRANULARITE(attente.tv_nsec);
   
         while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  #       ifndef SEMAPHORES_NOMMES
               while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
   #       else
               while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
   #       endif
         {          {
             if (errno != EINTR)              if (errno != EINTR)
             {              {
Removed from v.1.11  
changed lines
  Added in v.1.95

CVSweb interface <joel.bertrand@systella.fr>