[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.13 and 1.49

version 1.13, 2010/04/21 13:45:49 version 1.49, 2011/09/20 08:56:24
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.15    RPL/2 (R) version 4.1.3
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2011 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 262  instruction_wait(struct_processus *s_eta Line 261  instruction_wait(struct_processus *s_eta
   
         do          do
         {          {
 #           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;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
 #           else  
             if (sem_post((*s_etat_processus).semaphore_fork) != 0)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
 #           endif  
   
             code_retour = nanosleep(&temporisation, &temporisation);              code_retour = nanosleep(&temporisation, &temporisation);
             erreur = errno;              erreur = errno;
   
 #           ifndef SEMAPHORES_NOMMES              if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #           else  
             while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #           endif  
             {              {
                 if (errno != EINTR)                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 {                  return;
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
             }              }
   
             scrutation_injection(s_etat_processus);              scrutation_injection(s_etat_processus);
Line 420  instruction_write(struct_processus *s_et Line 404  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;
Line 1325  instruction_write(struct_processus *s_et Line 1311  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 ((*((*((struct_liste_chainee *) (*s_objet_argument_2).objet))
                           .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 ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
                           (*((*((struct_liste_chainee *) (*s_objet_argument_2)
                           .objet)).donnee)).objet, &longueur_effective)) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   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;
                   }
   
                   free(chaine);
               }
               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 1360  instruction_write(struct_processus *s_et Line 1391  instruction_write(struct_processus *s_et
   
                 return;                  return;
             }              }
           }
           else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire
                   == 'Y')
           {
               /*
                * Sockets non formatées
                */
   
               chaine = NULL;
           }
           else
           {
               /*
                *  Sockets de type FLOW
                */
   
               if ((*((*((struct_liste_chainee *) (*s_objet_argument_2).objet))
                       .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 ((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,          if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,
                     "STREAM") == 0) || (strcmp((*((struct_socket *)                  "STREAM") == 0) || (strcmp((*((struct_socket *)
                     (*s_objet_argument_1).objet)).type,                  (*s_objet_argument_1).objet)).type,
                     "SEQUENTIAL DATAGRAM") == 0))                  "SEQUENTIAL DATAGRAM") == 0))
             { // Sockets connectées          { // Sockets connectées
   
                 action.sa_handler = SIG_IGN;              action.sa_handler = SIG_IGN;
                 action.sa_flags = SA_ONSTACK;              action.sa_flags = SA_ONSTACK;
   
                 if (sigaction(SIGPIPE, &action, &registre) != 0)              if (sigaction(SIGPIPE, &action, &registre) != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_signal;
                   return;
               }
   
               if (sem_post(&((*s_etat_processus).semaphore_fork)) != 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;
                 }                  }
   
 #               ifndef SEMAPHORES_NOMMES                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                  return;
 #               else              }
                 if (sem_post((*s_etat_processus).semaphore_fork) != 0)  
 #               endif              if (send((*((struct_socket *) (*s_objet_argument_1).objet))
                       .socket, chaine, longueur_effective, 0) < 0)
               {
                   ios = errno;
   
                   if (sigaction(SIGPIPE, &registre, NULL) != 0)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_signal;
                       return;
                   }
   
                   if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_processus;
                       return;
                   }
   
                   if ((ios == EPIPE) || (ios == ECONNRESET))
                   {
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_acces_fichier;
                       return;
                   }
   
                   (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   return;
               }
   
               if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
               {
                   if (errno != EINTR)
                 {                  {
                     if (sigaction(SIGPIPE, &registre, NULL) != 0)                      if (sigaction(SIGPIPE, &registre, NULL) != 0)
                     {                      {
Line 1391  instruction_write(struct_processus *s_et Line 1497  instruction_write(struct_processus *s_et
                     (*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
           { // 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;
   
                   if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_processus;
                       return;
                   }
   
                 if (send((*((struct_socket *) (*s_objet_argument_1).objet))                  if (sendto((*((struct_socket *)
                         .socket, chaine, strlen(chaine), 0) < 0)                          (*s_objet_argument_1).objet)).socket, chaine,
                           longueur_effective, 0, (struct sockaddr *)
                           &adresse_unix, sizeof(adresse_unix)) < 0)
                 {                  {
                     ios = errno;                      ios = errno;
   
                     if (sigaction(SIGPIPE, &registre, NULL) != 0)                      if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es_signal;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
                     }                      }
   
 #                   ifndef SEMAPHORES_NOMMES                      if ((ios == EPIPE) || (ios == ECONNRESET))
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #                   else  
                     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #                   endif  
                     {  
                         if (errno != EINTR)  
                         {  
                             (*s_etat_processus).erreur_systeme = d_es_processus;  
                             return;  
                         }  
                     }  
   
                     if (ios == EPIPE)  
                     {                      {
                         (*s_etat_processus).erreur_execution =                          (*s_etat_processus).erreur_execution =
                                 d_ex_erreur_acces_fichier;                                  d_ex_erreur_acces_fichier;
                         return;                          return;
                     }                      }
   
   
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                     return;                      return;
                 }                  }
   
 #               ifndef SEMAPHORES_NOMMES                  if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
                 while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #               else  
                 while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #               endif  
                 {                  {
                     if (errno != EINTR)                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     {  
                         if (sigaction(SIGPIPE, &registre, NULL) != 0)  
                         {  
                             (*s_etat_processus).erreur_systeme = d_es_signal;  
                             return;  
                         }  
   
                         (*s_etat_processus).erreur_systeme = d_es_processus;  
                         return;  
                     }  
                 }  
   
                 if (sigaction(SIGPIPE, &registre, NULL) != 0)  
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_signal;  
                     return;                      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) + adresse[i++]);
   
                     (*s_etat_processus).erreur_execution =                      memset(&adresse_ipv4, 0, sizeof(adresse_ipv4));
                             d_ex_erreur_acces_fichier;                      adresse_ipv4.sin_family = AF_INET;
                     return;                      adresse_ipv4.sin_port = htons(port);
                 }                      adresse_ipv4.sin_addr.s_addr = htonl(calcul_adresse);
   
                 /*  
                  * 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,  
                             108);  
                     adresse_unix.sun_path[108 - 1] = d_code_fin_chaine;  
   
 #                   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;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
                     }                      }
 #                   else  
                     if (sem_post((*s_etat_processus).semaphore_fork) != 0)  
                     {  
                         (*s_etat_processus).erreur_systeme = d_es_processus;  
                         return;  
                     }  
 #                   endif  
   
                     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 *)                              longueur_effective, 0, (struct sockaddr *)
                             &adresse_unix, sizeof(adresse_unix)) < 0)                              &adresse_ipv4, sizeof(adresse_ipv4)) < 0)
                     {                      {
 #                       ifndef SEMAPHORES_NOMMES                          if (sem_wait(&((*s_etat_processus)
                         while(sem_wait(&((*s_etat_processus)                                  .semaphore_fork)) != 0)
                                 .semaphore_fork)) == -1)  
 #                       else  
                         while(sem_wait((*s_etat_processus)  
                                 .semaphore_fork) == -1)  
 #                       endif  
                         {                          {
                             if (errno != EINTR)                              (*s_etat_processus).erreur_systeme = d_es_processus;
                             {                              return;
                                 (*s_etat_processus).erreur_systeme =  
                                         d_es_processus;  
                                 return;  
                             }  
                         }                          }
   
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
Line 1523  instruction_write(struct_processus *s_et Line 1615  instruction_write(struct_processus *s_et
                         return;                          return;
                     }                      }
   
 #                   ifndef SEMAPHORES_NOMMES                      if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #                   else  
                     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #                   endif  
                     {                      {
                         if (errno != EINTR)                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         {                          return;
                             (*s_etat_processus).erreur_systeme = d_es_processus;  
                             return;  
                         }  
                     }                      }
                 }                  }
                 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);  
   
 #                       ifndef SEMAPHORES_NOMMES  
                         if (sem_post(&((*s_etat_processus)  
                                 .semaphore_fork)) != 0)  
                         {  
                             (*s_etat_processus).erreur_systeme = d_es_processus;  
                             return;  
                         }  
 #                       else  
                         if (sem_post((*s_etat_processus) .semaphore_fork) != 0)  
                         {  
                             (*s_etat_processus).erreur_systeme = d_es_processus;  
                             return;  
                         }  
 #                       endif  
   
                         if (sendto((*((struct_socket *)  
                                 (*s_objet_argument_1).objet)).socket, chaine,  
                                 strlen(chaine), 0, (struct sockaddr *)  
                                 &adresse_ipv4, sizeof(adresse_ipv4)) < 0)  
                         {  
 #                           ifndef SEMAPHORES_NOMMES  
                             while(sem_wait(&((*s_etat_processus)  
                                     .semaphore_fork)) == -1)  
 #                           else  
                             while(sem_wait((*s_etat_processus)  
                                     .semaphore_fork) == -1)  
 #                           endif  
                             {  
                                 if (errno != EINTR)  
                                 {  
                                     (*s_etat_processus).erreur_systeme =  
                                             d_es_processus;  
                                     return;  
                                 }  
                             }  
   
                             (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_execution =
                                     d_es_erreur_fichier;                              d_ex_erreur_parametre_fichier;
                             return;                      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
   #                   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] =
                               adresse[i], i++);
   
 #                       ifndef SEMAPHORES_NOMMES                      if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
                         while(sem_wait(&((*s_etat_processus)  
                                 .semaphore_fork)) == -1)  
 #                       else  
                         while(sem_wait((*s_etat_processus)  
                                 .semaphore_fork) == -1)  
 #                       endif  
                         {  
                             if (errno != EINTR)  
                             {  
                                 (*s_etat_processus).erreur_systeme =  
                                         d_es_processus;  
                                 return;  
                             }  
                         }  
                     }  
                     else  
                     {                      {
                         liberation(s_etat_processus, s_objet_argument_1);                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         liberation(s_etat_processus, s_objet_argument_2);  
   
                         (*s_etat_processus).erreur_execution =  
                                 d_ex_erreur_parametre_fichier;  
                         return;                          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++);  
   
 #                       ifndef SEMAPHORES_NOMMES                      if (sendto((*((struct_socket *)
                         if (sem_post(&((*s_etat_processus)                              (*s_objet_argument_1).objet)).socket, chaine,
                               longueur_effective, 0, (struct sockaddr *)
                               &adresse_ipv6, sizeof(adresse_ipv6)) < 0)
                       {
                           if (sem_wait(&((*s_etat_processus)
                                 .semaphore_fork)) != 0)                                  .semaphore_fork)) != 0)
                         {                          {
                             (*s_etat_processus).erreur_systeme = d_es_processus;  
                             return;  
                         }  
 #                       else  
                         if (sem_post((*s_etat_processus) .semaphore_fork) != 0)  
                         {  
                             (*s_etat_processus).erreur_systeme = d_es_processus;  
                             return;  
                         }  
 #                       endif  
   
                         if (sendto((*((struct_socket *)  
                                 (*s_objet_argument_1).objet)).socket, chaine,  
                                 strlen(chaine), 0, (struct sockaddr *)  
                                 &adresse_ipv6, sizeof(adresse_ipv6)) < 0)  
                         {  
 #                           ifndef SEMAPHORES_NOMMES  
                             while(sem_wait(&((*s_etat_processus)  
                                     .semaphore_fork)) == -1)  
 #                           else  
                             while(sem_wait((*s_etat_processus)  
                                     .semaphore_fork) == -1)  
 #                           endif  
                             {  
                                 if (errno != EINTR)  
                                 {  
                                     (*s_etat_processus).erreur_systeme =  
                                             d_es_processus;  
                                     return;  
                                 }  
                             }  
   
                             (*s_etat_processus).erreur_systeme =                              (*s_etat_processus).erreur_systeme =
                                     d_es_erreur_fichier;                                      d_es_processus;
                             return;                              return;
                         }                          }
   
 #                       ifndef SEMAPHORES_NOMMES                          (*s_etat_processus).erreur_systeme =
                         while(sem_wait(&((*s_etat_processus)                                  d_es_erreur_fichier;
                                 .semaphore_fork)) == -1)                          return;
 #                       else  
                         while(sem_wait((*s_etat_processus)  
                                 .semaphore_fork) == -1)  
 #                       endif  
                         {  
                             if (errno != EINTR)  
                             {  
                                 (*s_etat_processus).erreur_systeme =  
                                         d_es_processus;  
                                 return;  
                             }  
                         }  
                     }                      }
                     else  
                     {  
                         liberation(s_etat_processus, s_objet_argument_1);  
                         liberation(s_etat_processus, s_objet_argument_2);  
   
                         (*s_etat_processus).erreur_execution =                      if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
                                 d_ex_erreur_parametre_fichier;                      {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_processus;
                         return;                          return;
                     }                      }
   #                   else
                       if ((*s_etat_processus).langue == 'F')
                       {
                           printf("+++Attention : Support du protocole"
                                   " IPv6 indisponible\n");
                       }
                       else
                       {
                           printf("+++Warning : IPv6 support "
                                   "unavailable\n");
                       }
   #                   endif
                 }                  }
                 else                   else
                 {                  {
                     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 1719  instruction_write(struct_processus *s_et Line 1706  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 1895  instruction_wflock(struct_processus *s_e Line 1878  instruction_wflock(struct_processus *s_e
                 return;                  return;
             }              }
   
 #           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;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
 #           else  
             if (sem_post((*s_etat_processus).semaphore_fork) != 0)              if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
 #           endif  
   
 #           ifndef SEMAPHORES_NOMMES  
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #           else  
             while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #           endif  
             {  
                 if (errno != EINTR)  
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
             }  
   
             if (lock.l_type == F_UNLCK)              if (lock.l_type == F_UNLCK)
             {              {
Line 2136  instruction_wfproc(struct_processus *s_e Line 2104  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 2222  instruction_wfproc(struct_processus *s_e Line 2190  instruction_wfproc(struct_processus *s_e
                                 registre_instruction_valide;                                  registre_instruction_valide;
                     }                      }
   
 #                   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;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
                     }                      }
 #                   else  
                     if (sem_post((*s_etat_processus).semaphore_fork) != 0)  
                     {  
                         (*s_etat_processus).erreur_systeme = d_es_processus;  
                         return;  
                     }  
 #                   endif  
   
                     nanosleep(&attente, NULL);                      nanosleep(&attente, NULL);
   
 #                   ifndef SEMAPHORES_NOMMES                      if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #                   else  
                     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #                   endif  
                     {                      {
                         if (errno != EINTR)                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         {                          return;
                             (*s_etat_processus).erreur_systeme = d_es_processus;  
                             return;  
                         }  
                     }                      }
   
                     scrutation_injection(s_etat_processus);                      scrutation_injection(s_etat_processus);
Line 2493  instruction_wfdata(struct_processus *s_e Line 2446  instruction_wfdata(struct_processus *s_e
                         return;                          return;
                     }                      }
   
 #                   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;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
                     }                      }
 #                   else  
                     if (sem_post((*s_etat_processus).semaphore_fork) != 0)  
                     {  
                         (*s_etat_processus).erreur_systeme = d_es_processus;  
                         return;  
                     }  
 #                   endif  
   
                     nanosleep(&attente, NULL);                      nanosleep(&attente, NULL);
   
 #                   ifndef SEMAPHORES_NOMMES                      if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #                   else  
                     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #                   endif  
                     {                      {
                         if (errno != EINTR)                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         {                          return;
                             (*s_etat_processus).erreur_systeme = d_es_processus;  
                             return;  
                         }  
                     }                      }
   
                     scrutation_injection(s_etat_processus);                      scrutation_injection(s_etat_processus);
Line 2623  instruction_wfsock(struct_processus *s_e Line 2561  instruction_wfsock(struct_processus *s_e
     struct_objet            *s_objet_resultat;      struct_objet            *s_objet_resultat;
   
     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 2697  instruction_wfsock(struct_processus *s_e Line 2637  instruction_wfsock(struct_processus *s_e
             {              {
                 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)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
                 }                  }
 #               else  
                 if (sem_post((*s_etat_processus).semaphore_fork) != 0)  
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
 #               endif  
   
                 if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =                  if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =
                         accept((*((struct_socket *) (*s_objet_argument).objet))                          accept((*((struct_socket *) (*s_objet_argument).objet))
Line 2718  instruction_wfsock(struct_processus *s_e Line 2650  instruction_wfsock(struct_processus *s_e
                 {                  {
                     erreur = errno;                      erreur = errno;
   
 #                   ifndef SEMAPHORES_NOMMES                      if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #                   else  
                     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #                   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 (erreur != EINTR)
Line 2754  instruction_wfsock(struct_processus *s_e Line 2679  instruction_wfsock(struct_processus *s_e
                 }                  }
                 else                  else
                 {                  {
 #                   ifndef SEMAPHORES_NOMMES                      if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #                   else  
                     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #                   endif  
                     {                      {
                         if (errno != EINTR)                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         {                          return;
                             (*s_etat_processus).erreur_systeme = d_es_processus;  
                             return;  
                         }  
                     }                      }
                 }                  }
             } while(drapeau == d_faux);              } while(drapeau == d_faux);
Line 2789  instruction_wfsock(struct_processus *s_e Line 2707  instruction_wfsock(struct_processus *s_e
         else if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine ==          else if ((*((struct_socket *) (*s_objet_resultat).objet)).domaine ==
                 PF_INET6)                  PF_INET6)
         {          {
   #           ifdef IPV6
             longueur = sizeof(adresse_ipv6);              longueur = sizeof(adresse_ipv6);
   
             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)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
                 }                  }
 #               else  
                 if (sem_post((*s_etat_processus).semaphore_fork) != 0)  
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
 #               endif  
   
                 if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =                  if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =
                         accept((*((struct_socket *) (*s_objet_argument).objet))                          accept((*((struct_socket *) (*s_objet_argument).objet))
Line 2816  instruction_wfsock(struct_processus *s_e Line 2727  instruction_wfsock(struct_processus *s_e
                 {                  {
                     erreur = errno;                      erreur = errno;
   
 #                   ifndef SEMAPHORES_NOMMES                      if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #                   else  
                     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #                   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 (erreur != EINTR)
Line 2852  instruction_wfsock(struct_processus *s_e Line 2756  instruction_wfsock(struct_processus *s_e
                 }                  }
                 else                  else
                 {                  {
 #                   ifndef SEMAPHORES_NOMMES                      if (sem_wait(&((*s_etat_processus).semaphore_fork))
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                              != 0)
 #                   else  
                     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #                   endif  
                     {                      {
                         if (errno != EINTR)                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         {                          return;
                             (*s_etat_processus).erreur_systeme = d_es_processus;  
                             return;  
                         }  
                     }                      }
                 }                  }
             } while(drapeau == d_faux);              } while(drapeau == d_faux);
Line 2892  instruction_wfsock(struct_processus *s_e Line 2790  instruction_wfsock(struct_processus *s_e
                     .objet)).adresse_distante, "%s(%u)",                      .objet)).adresse_distante, "%s(%u)",
                     (*((struct_socket *) (*s_objet_resultat)                      (*((struct_socket *) (*s_objet_resultat)
                     .objet)).adresse_distante, ntohs(adresse_ipv6.sin6_port));                      .objet)).adresse_distante, 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          else
         {          {
Line 2901  instruction_wfsock(struct_processus *s_e Line 2811  instruction_wfsock(struct_processus *s_e
             {              {
                 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)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
                 }                  }
 #               else  
                 if (sem_post((*s_etat_processus).semaphore_fork) != 0)  
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
 #               endif  
   
                 if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =                  if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =
                         accept((*((struct_socket *) (*s_objet_argument).objet))                          accept((*((struct_socket *) (*s_objet_argument).objet))
Line 2921  instruction_wfsock(struct_processus *s_e Line 2823  instruction_wfsock(struct_processus *s_e
                 {                  {
                     erreur = errno;                      erreur = errno;
   
 #                   ifndef SEMAPHORES_NOMMES                      if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #                   else  
                     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #                   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 (erreur != EINTR)
Line 2957  instruction_wfsock(struct_processus *s_e Line 2852  instruction_wfsock(struct_processus *s_e
                 }                  }
                 else                  else
                 {                  {
 #                   ifndef SEMAPHORES_NOMMES                      if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #                   else  
                     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #                   endif  
                     {                      {
                         if (errno != EINTR)                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         {                          return;
                             (*s_etat_processus).erreur_systeme = d_es_processus;  
                             return;  
                         }  
                     }                      }
                 }                  }
             } while(drapeau == d_faux);              } while(drapeau == d_faux);
Line 3247  instruction_wfpoke(struct_processus *s_e Line 3135  instruction_wfpoke(struct_processus *s_e
   
     do      do
     {      {
 #       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;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
 #       else  
         if (sem_post((*s_etat_processus).semaphore_fork) != 0)  
         {  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
             return;  
         }  
 #       endif  
   
         nanosleep(&attente, NULL);          nanosleep(&attente, NULL);
   
 #       ifndef SEMAPHORES_NOMMES          if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
         while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #       else  
         while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #       endif  
         {          {
             if (errno != EINTR)              (*s_etat_processus).erreur_systeme = d_es_processus;
             {              return;
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
         }          }
   
         scrutation_injection(s_etat_processus);          scrutation_injection(s_etat_processus);
Line 3409  instruction_wfack(struct_processus *s_et Line 3282  instruction_wfack(struct_processus *s_et
             return;              return;
         }          }
   
 #       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;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
 #       else  
         if (sem_post((*s_etat_processus).semaphore_fork) != 0)  
         {  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
             return;  
         }  
 #       endif  
   
         nanosleep(&attente, NULL);          nanosleep(&attente, NULL);
         INCR_GRANULARITE(attente.tv_nsec);          INCR_GRANULARITE(attente.tv_nsec);
   
 #       ifndef SEMAPHORES_NOMMES          if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
         while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #       else  
         while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #       endif  
         {          {
             if (errno != EINTR)              (*s_etat_processus).erreur_systeme = d_es_processus;
             {              return;
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
         }          }
     }      }
   
Removed from v.1.13  
changed lines
  Added in v.1.49

CVSweb interface <joel.bertrand@systella.fr>