[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.34.2.4 and 1.64

version 1.34.2.4, 2011/05/09 13:52:22 version 1.64, 2012/06/22 10:12:19
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.24    RPL/2 (R) version 4.1.9
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2012 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 262  instruction_wait(struct_processus *s_eta Line 262  instruction_wait(struct_processus *s_eta
         do          do
         {          {
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                  if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
 #           else  #           else
             if (sem_post((*s_etat_processus).semaphore_fork) != 0)                  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;
             }              }
 #           endif  
   
             code_retour = nanosleep(&temporisation, &temporisation);              code_retour = nanosleep(&temporisation, &temporisation);
             erreur = errno;              erreur = errno;
   
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                  while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #           else  #           else
             while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                  while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #           endif  #           endif
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
Line 395  instruction_write(struct_processus *s_et Line 391  instruction_write(struct_processus *s_et
     integer8                            id;      integer8                            id;
     integer8                            ordre;      integer8                            ordre;
   
       logical1                            format_degenere;
     logical1                            mise_a_jour;      logical1                            mise_a_jour;
   
       long                                longueur;
     long                                longueur_effective;      long                                longueur_effective;
     long                                recursivite;      long                                recursivite;
   
Line 432  instruction_write(struct_processus *s_et Line 430  instruction_write(struct_processus *s_et
     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 1332  instruction_write(struct_processus *s_et Line 1331  instruction_write(struct_processus *s_et
             {              {
                 BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n"));                  BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n"));
   
                 if ((*((*((struct_liste_chainee *) (*s_objet_argument_2).objet))                  if ((*s_objet_argument_2).type != LST)
                         .donnee)).type != CHN)  
                 {                  {
                     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 1343  instruction_write(struct_processus *s_et Line 1341  instruction_write(struct_processus *s_et
                     return;                      return;
                 }                  }
   
                 if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)                  if ((*((struct_liste_chainee *) (*s_objet_argument_2).objet))
                         (*((*((struct_liste_chainee *) (*s_objet_argument_2)                          .donnee == NULL)
                         .objet)).donnee)).objet, &longueur_effective)) == NULL)  
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      liberation(s_etat_processus, s_objet_argument_2);
                             d_es_allocation_memoire;                      liberation(s_etat_processus, s_objet_argument_1);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_type_argument;
                     return;                      return;
                 }                  }
   
                 if (fwrite(chaine, sizeof(unsigned char), longueur_effective,                  l_element_courant = (*s_objet_argument_2).objet;
                         (*descripteur).descripteur_c) !=                  l_element_courant_format = (struct_liste_chainee *)
                         (size_t) longueur_effective)                          (*(*((struct_fichier *) (*s_objet_argument_1).objet))
                           .format).objet;
   
                   while((l_element_courant != NULL) &&
                           (l_element_courant_format != NULL))
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      if ((*(*l_element_courant).donnee).type != CHN)
                     return;                      {
                           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((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 = strlen(format_chaine);
   
                       if (format_chaine[longueur] != ')')
                       {
                           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]), "%ld", &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),
                                   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),
                                   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;
                 }                  }
   
                 free(chaine);                  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              else
             {              {
Line 1460  instruction_write(struct_processus *s_et Line 1592  instruction_write(struct_processus *s_et
             }              }
   
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                  if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #           else  #           else
             if (sem_post((*s_etat_processus).semaphore_fork) != 0)                  if (sem_post((*s_etat_processus).semaphore_fork) != 0)
 #           endif  #           endif
             {              {
                 if (sigaction(SIGPIPE, &registre, NULL) != 0)                  if (sigaction(SIGPIPE, &registre, NULL) != 0)
Line 1487  instruction_write(struct_processus *s_et Line 1619  instruction_write(struct_processus *s_et
                 }                  }
   
 #               ifndef SEMAPHORES_NOMMES  #               ifndef SEMAPHORES_NOMMES
                 while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                      while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #               else  #               else
                 while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                      while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #               endif  #               endif
                 {                  {
                     if (errno != EINTR)                      if (errno != EINTR)
Line 1511  instruction_write(struct_processus *s_et Line 1643  instruction_write(struct_processus *s_et
             }              }
   
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                  while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #           else  #           else
             while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                  while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #           endif  #           endif
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
Line 1568  instruction_write(struct_processus *s_et Line 1700  instruction_write(struct_processus *s_et
                         d_code_fin_chaine;                          d_code_fin_chaine;
   
 #               ifndef SEMAPHORES_NOMMES  #               ifndef SEMAPHORES_NOMMES
                 if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                      if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
 #               else  #               else
                 if (sem_post((*s_etat_processus).semaphore_fork) != 0)                      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;
                 }                  }
 #               endif  
   
                 if (sendto((*((struct_socket *)                  if (sendto((*((struct_socket *)
                         (*s_objet_argument_1).objet)).socket, chaine,                          (*s_objet_argument_1).objet)).socket, chaine,
Line 1589  instruction_write(struct_processus *s_et Line 1717  instruction_write(struct_processus *s_et
                     ios = errno;                      ios = errno;
   
 #                   ifndef SEMAPHORES_NOMMES  #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus)                          while(sem_wait(&((*s_etat_processus).semaphore_fork))
                             .semaphore_fork)) == -1)                                  != 0)
 #                   else  #                   else
                     while(sem_wait((*s_etat_processus)                          while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
                             .semaphore_fork) == -1)  
 #                   endif  #                   endif
                     {                      {
                         if (errno != EINTR)                          if (errno != EINTR)
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              (*s_etat_processus).erreur_systeme = d_es_processus;
                                     d_es_processus;  
                             return;                              return;
                         }                          }
                     }                      }
Line 1617  instruction_write(struct_processus *s_et Line 1743  instruction_write(struct_processus *s_et
                 }                  }
   
 #               ifndef SEMAPHORES_NOMMES  #               ifndef SEMAPHORES_NOMMES
                 while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                      while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #               else  #               else
                 while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                      while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #               endif  #               endif
                 {                  {
                     if (errno != EINTR)                      if (errno != EINTR)
Line 1648  instruction_write(struct_processus *s_et Line 1774  instruction_write(struct_processus *s_et
                     adresse_ipv4.sin_addr.s_addr = htonl(calcul_adresse);                      adresse_ipv4.sin_addr.s_addr = htonl(calcul_adresse);
   
 #                   ifndef SEMAPHORES_NOMMES  #                   ifndef SEMAPHORES_NOMMES
                     if (sem_post(&((*s_etat_processus)                          if (sem_post(&((*s_etat_processus).semaphore_fork))
                             .semaphore_fork)) != 0)                                  != 0)
                     {  
                         (*s_etat_processus).erreur_systeme = d_es_processus;  
                         return;  
                     }  
 #                   else  #                   else
                     if (sem_post((*s_etat_processus) .semaphore_fork) != 0)                          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;
                     }                      }
 #                   endif  
   
                     if (sendto((*((struct_socket *)                      if (sendto((*((struct_socket *)
                             (*s_objet_argument_1).objet)).socket, chaine,                              (*s_objet_argument_1).objet)).socket, chaine,
Line 1668  instruction_write(struct_processus *s_et Line 1790  instruction_write(struct_processus *s_et
                             &adresse_ipv4, sizeof(adresse_ipv4)) < 0)                              &adresse_ipv4, sizeof(adresse_ipv4)) < 0)
                     {                      {
 #                       ifndef SEMAPHORES_NOMMES  #                       ifndef SEMAPHORES_NOMMES
                         while(sem_wait(&((*s_etat_processus)                              while(sem_wait(&((*s_etat_processus)
                                 .semaphore_fork)) == -1)                                      .semaphore_fork)) != 0)
 #                       else  #                       else
                         while(sem_wait((*s_etat_processus)                              while(sem_wait((*s_etat_processus)
                                 .semaphore_fork) == -1)                                      .semaphore_fork) != 0)
 #                       endif  #                       endif
                         {                          {
                             if (errno != EINTR)                              if (errno != EINTR)
Line 1689  instruction_write(struct_processus *s_et Line 1811  instruction_write(struct_processus *s_et
                     }                      }
   
 #                   ifndef SEMAPHORES_NOMMES  #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus)                          while(sem_wait(&((*s_etat_processus).semaphore_fork))
                             .semaphore_fork)) == -1)                                  != 0)
 #                   else  #                   else
                     while(sem_wait((*s_etat_processus)                          while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
                             .semaphore_fork) == -1)  
 #                   endif  #                   endif
                     {                      {
                         if (errno != EINTR)                          if (errno != EINTR)
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              (*s_etat_processus).erreur_systeme = d_es_processus;
                                     d_es_processus;  
                             return;                              return;
                         }                          }
                     }                      }
Line 1737  instruction_write(struct_processus *s_et Line 1857  instruction_write(struct_processus *s_et
                             adresse[i], i++);                              adresse[i], i++);
   
 #                   ifndef SEMAPHORES_NOMMES  #                   ifndef SEMAPHORES_NOMMES
                     if (sem_post(&((*s_etat_processus)                          if (sem_post(&((*s_etat_processus).semaphore_fork))
                             .semaphore_fork)) != 0)                                  != 0)
                     {  
                         (*s_etat_processus).erreur_systeme = d_es_processus;  
                         return;  
                     }  
 #                   else  #                   else
                     if (sem_post((*s_etat_processus) .semaphore_fork) != 0)                          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;
                     }                      }
 #                   endif  
   
                     if (sendto((*((struct_socket *)                      if (sendto((*((struct_socket *)
                             (*s_objet_argument_1).objet)).socket, chaine,                              (*s_objet_argument_1).objet)).socket, chaine,
Line 1757  instruction_write(struct_processus *s_et Line 1873  instruction_write(struct_processus *s_et
                             &adresse_ipv6, sizeof(adresse_ipv6)) < 0)                              &adresse_ipv6, sizeof(adresse_ipv6)) < 0)
                     {                      {
 #                       ifndef SEMAPHORES_NOMMES  #                       ifndef SEMAPHORES_NOMMES
                         while(sem_wait(&((*s_etat_processus)                              while(sem_wait(&((*s_etat_processus)
                                 .semaphore_fork)) == -1)                                      .semaphore_fork)) != 0)
 #                       else  #                       else
                         while(sem_wait((*s_etat_processus)                              while(sem_wait((*s_etat_processus)
                                 .semaphore_fork) == -1)                                      .semaphore_fork) != 0)
 #                       endif  #                       endif
                         {                          {
                             if (errno != EINTR)                              if (errno != EINTR)
Line 1778  instruction_write(struct_processus *s_et Line 1894  instruction_write(struct_processus *s_et
                     }                      }
   
 #                   ifndef SEMAPHORES_NOMMES  #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus)                          while(sem_wait(&((*s_etat_processus).semaphore_fork))
                             .semaphore_fork)) == -1)                                  != 0)
 #                   else  #                   else
                     while(sem_wait((*s_etat_processus)                          while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
                             .semaphore_fork) == -1)  
 #                   endif  #                   endif
                     {                      {
                         if (errno != EINTR)                          if (errno != EINTR)
Line 1988  instruction_wflock(struct_processus *s_e Line 2103  instruction_wflock(struct_processus *s_e
             }              }
   
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                  if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
 #           else  #           else
             if (sem_post((*s_etat_processus).semaphore_fork) != 0)                  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;
             }              }
 #           endif  
   
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                  while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #           else  #           else
             while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                  while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #           endif  #           endif
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
Line 2228  instruction_wfproc(struct_processus *s_e Line 2339  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 2315  instruction_wfproc(struct_processus *s_e Line 2426  instruction_wfproc(struct_processus *s_e
                     }                      }
   
 #                   ifndef SEMAPHORES_NOMMES  #                   ifndef SEMAPHORES_NOMMES
                     if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                          if (sem_post(&((*s_etat_processus).semaphore_fork))
                     {                                  != 0)
                         (*s_etat_processus).erreur_systeme = d_es_processus;  
                         return;  
                     }  
 #                   else  #                   else
                     if (sem_post((*s_etat_processus).semaphore_fork) != 0)                          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;
                     }                      }
 #                   endif  
   
                     nanosleep(&attente, NULL);                      nanosleep(&attente, NULL);
   
 #                   ifndef SEMAPHORES_NOMMES  #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                          while(sem_wait(&((*s_etat_processus).semaphore_fork))
                                   != 0)
 #                   else  #                   else
                     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                          while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #                   endif  #                   endif
                     {                      {
                         if (errno != EINTR)                          if (errno != EINTR)
Line 2586  instruction_wfdata(struct_processus *s_e Line 2695  instruction_wfdata(struct_processus *s_e
                     }                      }
   
 #                   ifndef SEMAPHORES_NOMMES  #                   ifndef SEMAPHORES_NOMMES
                     if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                          if (sem_post(&((*s_etat_processus).semaphore_fork))
                     {                                  != 0)
                         (*s_etat_processus).erreur_systeme = d_es_processus;  
                         return;  
                     }  
 #                   else  #                   else
                     if (sem_post((*s_etat_processus).semaphore_fork) != 0)                          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;
                     }                      }
 #                   endif  
   
                     nanosleep(&attente, NULL);                      nanosleep(&attente, NULL);
   
 #                   ifndef SEMAPHORES_NOMMES  #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                          while(sem_wait(&((*s_etat_processus).semaphore_fork))
                                   != 0)
 #                   else  #                   else
                     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                          while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #                   endif  #                   endif
                     {                      {
                         if (errno != EINTR)                          if (errno != EINTR)
Line 2714  instruction_wfsock(struct_processus *s_e Line 2821  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  #   ifdef IPV6
     struct sockaddr_in6     adresse_ipv6;      struct sockaddr_in6     adresse_ipv6;
Line 2767  instruction_wfsock(struct_processus *s_e Line 2876  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;  
             return;  
         }  
   
         if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument,              if ((s_objet_resultat = copie_objet(s_etat_processus,
                 'O')) == NULL)                      s_objet_argument, 'P')) == NULL)
         {              {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;                  return;
         }              }
   
         (*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute = 'N';  
         (*((struct_socket *) (*s_objet_resultat).objet)).effacement = 'N';  
   
         if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine == PF_INET)              s_poll.fd = (*((struct_socket *) (*s_objet_argument).objet)).socket;
         {              s_poll.events = POLLIN;
             longueur = sizeof(adresse_ipv4);              s_poll.revents = 0;
   
             do              do
             {              {
Line 2793  instruction_wfsock(struct_processus *s_e Line 2895  instruction_wfsock(struct_processus *s_e
   
 #               ifndef SEMAPHORES_NOMMES  #               ifndef SEMAPHORES_NOMMES
                 if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                  if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
 #               else  #               else
                 if (sem_post((*s_etat_processus).semaphore_fork) != 0)                  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;
                 }                  }
 #               endif  
   
                 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;
   
 #                   ifndef SEMAPHORES_NOMMES  #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                      while(sem_wait(&((*s_etat_processus)
                               .semaphore_fork)) != 0)
 #                   else  #                   else
                     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                      while(sem_wait((*s_etat_processus).semaphore_fork)
                               != 0)
 #                   endif  #                   endif
                     {  
                         if (errno != EINTR)  
                         {  
                             (*s_etat_processus).erreur_systeme = d_es_processus;  
                             return;  
                         }  
                     }  
   
                     if (erreur != EINTR)                      if (erreur != EINTR)
                     {                      {
Line 2849  instruction_wfsock(struct_processus *s_e Line 2939  instruction_wfsock(struct_processus *s_e
                 else                  else
                 {                  {
 #                   ifndef SEMAPHORES_NOMMES  #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                          while(sem_wait(&((*s_etat_processus)
                                   .semaphore_fork)) != 0)
 #                   else  #                   else
                     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                          while(sem_wait((*s_etat_processus).semaphore_fork)
                                   != 0)
 #                   endif  #                   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)  
         {          {
 #           ifdef IPV6              // Mode connecté
             longueur = sizeof(adresse_ipv6);  
   
             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;
               }
   
 #               ifndef SEMAPHORES_NOMMES              (*((struct_socket *) (*s_objet_resultat).objet)).effacement = 'N';
                 if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)              (*((struct_socket *) (*s_objet_resultat).objet)).socket_en_ecoute
                       = 'N';
   
               if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine ==
                       PF_INET)
               {
                   longueur = sizeof(adresse_ipv4);
   
                   do
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      drapeau = d_vrai;
                     return;  
                 }  #               ifndef SEMAPHORES_NOMMES
                           if (sem_post(&((*s_etat_processus).semaphore_fork))
                                   != 0)
 #               else  #               else
                 if (sem_post((*s_etat_processus).semaphore_fork) != 0)                          if (sem_post((*s_etat_processus).semaphore_fork) != 0)
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
 #               endif  #               endif
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
   
                 if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =                      if (((*((struct_socket *) (*s_objet_resultat).objet))
                         accept((*((struct_socket *) (*s_objet_argument).objet))                              .socket = accept((*((struct_socket *)
                         .socket, (struct sockaddr *) &adresse_ipv6, &longueur))                              (*s_objet_argument).objet)).socket,
                         < 0)                              (struct sockaddr *) &adresse_ipv4, &longueur))
                 {                              < 0)
                     erreur = errno;                      {
                           erreur = errno;
   
   #                       ifndef SEMAPHORES_NOMMES
                           while(sem_wait(&((*s_etat_processus)
                                   .semaphore_fork)) != 0)
   #                       else
                           while(sem_wait((*s_etat_processus).semaphore_fork)
                                   != 0)
   #                       endif
                           {
                               if (errno != EINTR)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_processus;
                                   return;
                               }
                           }
   
                           if (erreur != EINTR)
                           {
                               liberation(s_etat_processus, s_objet_argument);
                               liberation(s_etat_processus, s_objet_resultat);
   
                               (*s_etat_processus).erreur_execution =
                                       d_ex_erreur_acces_fichier;
                               return;
                           }
   
                           scrutation_injection(s_etat_processus);
   
                           if ((*s_etat_processus).var_volatile_requete_arret != 0)
                           {
                               drapeau = d_vrai;
                           }
                           else
                           {
                               drapeau = d_faux;
                           }
                       }
                       else
                       {
 #                   ifndef SEMAPHORES_NOMMES  #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                              while(sem_wait(&((*s_etat_processus)
                                       .semaphore_fork)) != 0)
 #                   else  #                   else
                     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                              while(sem_wait((*s_etat_processus).semaphore_fork)
                                       != 0)
 #                   endif  #                   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);
   
                     if (erreur != EINTR)                  if (((*((struct_socket *) (*s_objet_resultat).objet))
                     {                          .adresse_distante = malloc(22 *
                         liberation(s_etat_processus, s_objet_argument);                          sizeof(unsigned char))) == NULL)
                         liberation(s_etat_processus, s_objet_resultat);                  {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                         (*s_etat_processus).erreur_execution =                  sprintf((*((struct_socket *) (*s_objet_resultat).objet))
                                 d_ex_erreur_acces_fichier;                          .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
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
                     }                      }
   
                     scrutation_injection(s_etat_processus);                      if (((*((struct_socket *) (*s_objet_resultat).objet))
                               .socket = accept((*((struct_socket *)
                     if ((*s_etat_processus).var_volatile_requete_arret != 0)                              (*s_objet_argument).objet)).socket,
                               (struct sockaddr *) &adresse_ipv6, &longueur)) < 0)
                     {                      {
                         drapeau = d_vrai;                          erreur = errno;
   
   #                   ifndef SEMAPHORES_NOMMES
                               while(sem_wait(&((*s_etat_processus)
                                       .semaphore_fork)) != 0)
   #                   else
                               while(sem_wait((*s_etat_processus).semaphore_fork)
                                       != 0)
   #                   endif
                           {
                               if (errno != EINTR)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_processus;
                                   return;
                               }
                           }
   
                           if (erreur != EINTR)
                           {
                               liberation(s_etat_processus, s_objet_argument);
                               liberation(s_etat_processus, s_objet_resultat);
   
                               (*s_etat_processus).erreur_execution =
                                       d_ex_erreur_acces_fichier;
                               return;
                           }
   
                           scrutation_injection(s_etat_processus);
   
                           if ((*s_etat_processus).var_volatile_requete_arret != 0)
                           {
                               drapeau = d_vrai;
                           }
                           else
                           {
                               drapeau = d_faux;
                           }
                     }                      }
                     else                      else
                     {                      {
                         drapeau = d_faux;  
                     }  
                 }  
                 else  
                 {  
 #                   ifndef SEMAPHORES_NOMMES  #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                              while(sem_wait(&((*s_etat_processus)
                                       .semaphore_fork)) != 0)
 #                   else  #                   else
                     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                              while(sem_wait((*s_etat_processus).semaphore_fork)
                                       != 0)
 #                   endif  #                   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);
   
                   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));
             }  
   
             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  #           else
             if ((*s_etat_processus).langue == 'F')                  if ((*s_etat_processus).langue == 'F')
             {                  {
                 printf("+++Attention : Support du protocole"                      printf("+++Attention : Support du protocole"
                         " IPv6 indisponible\n");                              " IPv6 indisponible\n");
                   }
                   else
                   {
                       printf("+++Warning : IPv6 support "
                               "unavailable\n");
                   }
   #           endif
             }              }
             else              else
             {              {
                 printf("+++Warning : IPv6 support "                  longueur = 0;
                         "unavailable\n");  
             }  
 #           endif  
         }  
         else  
         {  
             longueur = 0;  
   
             do                  do
             {                  {
                 drapeau = d_vrai;                      drapeau = d_vrai;
   
 #               ifndef SEMAPHORES_NOMMES  #               ifndef SEMAPHORES_NOMMES
                 if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                          if (sem_post(&((*s_etat_processus).semaphore_fork))
                 {                                  != 0)
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
 #               else  #               else
                 if (sem_post((*s_etat_processus).semaphore_fork) != 0)                          if (sem_post((*s_etat_processus).semaphore_fork) != 0)
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
 #               endif  #               endif
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
   
                 if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =                      if (((*((struct_socket *) (*s_objet_resultat).objet))
                         accept((*((struct_socket *) (*s_objet_argument).objet))                              .socket = accept((*((struct_socket *)
                         .socket, NULL, &longueur)) < 0)                              (*s_objet_argument).objet)).socket, NULL,
                 {                              &longueur)) < 0)
                     erreur = errno;                      {
                           erreur = errno;
   
 #                   ifndef SEMAPHORES_NOMMES  #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                              while(sem_wait(&((*s_etat_processus)
                                       .semaphore_fork)) != 0)
 #                   else  #                   else
                     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                              while(sem_wait((*s_etat_processus).semaphore_fork)
                                       != 0)
 #                   endif  #                   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;
                               }
                         }                          }
                     }  
   
                     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;  
                     }  
                 }  
                 else  
                 {  
 #                   ifndef SEMAPHORES_NOMMES  #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                              while(sem_wait(&((*s_etat_processus)
                                       .semaphore_fork)) != 0)
 #                   else  #                   else
                     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                              while(sem_wait((*s_etat_processus).semaphore_fork)
                                       != 0)
 #                   endif  #                   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              // 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              // que de EINTR sachant qu'une requête d'arrêt est en court de
         // traitement.              // traitement.
   
         if ((*((struct_socket *) (*s_objet_resultat).objet)).socket >= 0)              if ((*((struct_socket *) (*s_objet_resultat).objet)).socket >= 0)
         {  
             l_element_courant = (*s_etat_processus).s_sockets;  
   
             if (l_element_courant == NULL)  
             {              {
                 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),  
                 s_objet_argument) == d_erreur)  
         {  
             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_resultat) == d_erreur)                      s_objet_resultat) == d_erreur)
         {              {
             return;                  return;
               }
         }          }
     }      }
     else      else
Line 3355  instruction_wfpoke(struct_processus *s_e Line 3570  instruction_wfpoke(struct_processus *s_e
     do      do
     {      {
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)              if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
         {  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
             return;  
         }  
 #       else  #       else
         if (sem_post((*s_etat_processus).semaphore_fork) != 0)              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;
         }          }
 #       endif  
   
         nanosleep(&attente, NULL);          nanosleep(&attente, NULL);
   
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)              while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #       else  #       else
         while(sem_wait((*s_etat_processus).semaphore_fork) == -1)              while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #       endif  #       endif
         {          {
             if (errno != EINTR)              if (errno != EINTR)
Line 3517  instruction_wfack(struct_processus *s_et Line 3728  instruction_wfack(struct_processus *s_et
         }          }
   
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)              if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
         {  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
             return;  
         }  
 #       else  #       else
         if (sem_post((*s_etat_processus).semaphore_fork) != 0)              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;
         }          }
 #       endif  
   
         nanosleep(&attente, NULL);          nanosleep(&attente, NULL);
         INCR_GRANULARITE(attente.tv_nsec);          INCR_GRANULARITE(attente.tv_nsec);
   
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)              while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #       else  #       else
         while(sem_wait((*s_etat_processus).semaphore_fork) == -1)              while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #       endif  #       endif
         {          {
             if (errno != EINTR)              if (errno != EINTR)
Removed from v.1.34.2.4  
changed lines
  Added in v.1.64

CVSweb interface <joel.bertrand@systella.fr>