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

Diff for /rpl/src/instructions_o1.c between versions 1.46 and 1.94

version 1.46, 2012/02/23 15:38:29 version 1.94, 2018/12/21 10:56:17
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.6    RPL/2 (R) version 4.1.29
   Copyright (C) 1989-2012 Dr. BERTRAND Joël    Copyright (C) 1989-2018 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 210  instruction_or(struct_processus *s_etat_ Line 210  instruction_or(struct_processus *s_etat_
     struct_objet                *s_objet_argument_2;      struct_objet                *s_objet_argument_2;
     struct_objet                *s_objet_resultat;      struct_objet                *s_objet_resultat;
   
     unsigned long               nombre_elements;      integer8                    nombre_elements;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 869  instruction_or(struct_processus *s_etat_ Line 869  instruction_or(struct_processus *s_etat_
 ================================================================================  ================================================================================
 */  */
   
   
   static inline logical1
   options_socket(struct_processus *s_etat_processus,
           struct_objet *s_objet_resultat, unsigned char *options,
           unsigned char *peripherique, int *priorite,
           int *buffer_emission, int *buffer_reception,
           int *timeout_emission, int *timeout_reception)
   {
       int             drapeau;
   
       /*
        * Options des sockets
        */
   
       drapeau = -1;
   
   #   define WARNING(message) { \
       if ((*s_etat_processus).langue != 'F') \
           printf("+++Warning : %s unavailable on host system\n", message); \
       else \
           printf("+++Attention : %s non disponible sur le système hôte\n", \
                   message); } while(0)
   
       if (options[d_BIND_TO_DEVICE] == 'Y')
       {
   #       ifdef SO_BINDTODEVICE
               if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet))
                       .socket, SOL_SOCKET, SO_BINDTODEVICE, peripherique,
                       (socklen_t) strlen(peripherique)) != 0)
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_parametre_fichier;
                   return(d_erreur);
               }
   
               (*((struct_socket *) (*s_objet_resultat).objet)).options |=
                       ((integer8) 1) << d_BIND_TO_DEVICE;
   #       else
               WARNING("BIND TO DEVICE");
   #       endif
       }
   
       if (options[d_BROADCAST] == 'Y')
       {
           if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet)).socket,
                   SOL_SOCKET, SO_BROADCAST, &drapeau, sizeof(drapeau)) != 0)
           {
               (*s_etat_processus).erreur_execution =
                       d_ex_erreur_parametre_fichier;
               return(d_erreur);
           }
   
           (*((struct_socket *) (*s_objet_resultat).objet)).options |=
                   ((integer8) 1) << d_BROADCAST;
       }
   
       if (options[d_DONT_ROUTE] == 'Y')
       {
           if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet)).socket,
                   SOL_SOCKET, SO_DONTROUTE, &drapeau, sizeof(drapeau)) != 0)
           {
               (*s_etat_processus).erreur_execution =
                       d_ex_erreur_parametre_fichier;
               return(d_erreur);
           }
   
           (*((struct_socket *) (*s_objet_resultat).objet)).options |=
                   ((integer8) 1) << d_DONT_ROUTE;
       }
   
       if (options[d_KEEP_ALIVE] == 'Y')
       {
           if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet)).socket,
                   SOL_SOCKET, SO_KEEPALIVE, &drapeau, sizeof(drapeau)) != 0)
           {
               (*s_etat_processus).erreur_execution =
                       d_ex_erreur_parametre_fichier;
               return(d_erreur);
           }
       }
   
       if (options[d_PRIORITY] == 'Y')
       {
   #       ifdef SO_PRIORITY
               if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet))
                   .socket, SOL_SOCKET, SO_PRIORITY, priorite,
                   sizeof((*priorite))) != 0)
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_parametre_fichier;
                   return(d_erreur);
               }
   
               (*((struct_socket *) (*s_objet_resultat).objet)).options |=
                       ((integer8) 1) << d_PRIORITY;
               (*((struct_socket *) (*s_objet_resultat).objet)).priorite =
                       (*priorite);
   #       else
               WARNING("PRIORITY");
   #       endif
       }
   
       if (options[d_RECEIVE_BUFFER] == 'Y')
       {
           if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet)).socket,
                   SOL_SOCKET, SO_RCVBUF, buffer_reception,
                   sizeof((*buffer_reception))) != 0)
           {
               (*s_etat_processus).erreur_execution =
                       d_ex_erreur_parametre_fichier;
               return(d_erreur);
           }
   
           (*((struct_socket *) (*s_objet_resultat).objet)).options |=
                   ((integer8) 1) << d_RECEIVE_BUFFER;
           (*((struct_socket *) (*s_objet_resultat).objet)).buffer_reception =
                   (*buffer_reception);
       }
   
       if (options[d_FORCE_RECEIVE_BUFFER] == 'Y')
       {
   #       ifdef SO_RCVBUFFORCE
               if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet))
                       .socket, SOL_SOCKET, SO_RCVBUFFORCE,
                       buffer_reception, sizeof((*buffer_reception))) != 0)
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_parametre_fichier;
                   return(d_erreur);
               }
   
               (*((struct_socket *) (*s_objet_resultat).objet)).options |=
                       ((integer8) 1) << d_FORCE_RECEIVE_BUFFER;
               (*((struct_socket *) (*s_objet_resultat).objet)).buffer_reception =
                       (*buffer_reception);
   #       else
               WARNING("FORCE_RECEIVE_BUFFER");
   #       endif
       }
   
       if (options[d_SEND_BUFFER] == 'Y')
       {
           if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet)).socket,
                   SOL_SOCKET, SO_SNDBUF, buffer_emission,
                   sizeof((*buffer_emission))) != 0)
           {
               (*s_etat_processus).erreur_execution =
                       d_ex_erreur_parametre_fichier;
               return(d_erreur);
           }
   
           (*((struct_socket *) (*s_objet_resultat).objet)).options |=
                   ((integer8) 1) << d_SEND_BUFFER;
           (*((struct_socket *) (*s_objet_resultat).objet)).buffer_emission =
                   (*buffer_emission);
       }
   
       if (options[d_FORCE_SEND_BUFFER] == 'Y')
       {
   #       ifdef SO_SNDBUFFORCE
               if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet))
                       .socket, SOL_SOCKET, SO_SNDBUFFORCE, buffer_emission,
                       sizeof((*buffer_emission))) != 0)
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_parametre_fichier;
                   return(d_erreur);
               }
   
               (*((struct_socket *) (*s_objet_resultat).objet)).options |=
                       ((integer8) 1) << d_FORCE_SEND_BUFFER;
               (*((struct_socket *) (*s_objet_resultat).objet)).buffer_emission =
                       (*buffer_emission);
   #       else
               WARNING("FORCE_SEND_BUFFER");
   #       endif
       }
   
       if (options[d_RECEIVING_TIMEOUT] == 'Y')
       {
           if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet)).socket,
                   SOL_SOCKET, SO_RCVTIMEO,
                   timeout_reception, sizeof((*timeout_reception))) != 0)
           {
               (*s_etat_processus).erreur_execution =
                       d_ex_erreur_parametre_fichier;
               return(d_erreur);
           }
   
           (*((struct_socket *) (*s_objet_resultat).objet)).options |=
                   ((integer8) 1) << d_RECEIVING_TIMEOUT;
           (*((struct_socket *) (*s_objet_resultat).objet)).timeout_reception =
                   (*timeout_reception);
       }
   
       if (options[d_SENDING_TIMEOUT] == 'Y')
       {
           if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet)).socket,
                   SOL_SOCKET, SO_SNDTIMEO,
                   timeout_emission, sizeof((*timeout_emission))) != 0)
           {
               (*s_etat_processus).erreur_execution =
                       d_ex_erreur_parametre_fichier;
               return(d_erreur);
           }
   
           (*((struct_socket *) (*s_objet_resultat).objet)).options |=
                   ((integer8) 1) << d_SENDING_TIMEOUT;
           (*((struct_socket *) (*s_objet_resultat).objet)).timeout_emission =
                   (*timeout_emission);
       }
   
       if (options[d_REUSE_ADDRESS] == 'Y')
       {
           if (setsockopt((*((struct_socket *) (*s_objet_resultat).objet)).socket,
                   SOL_SOCKET, SO_REUSEADDR, &drapeau, sizeof(drapeau)) != 0)
           {
               (*s_etat_processus).erreur_execution =
                       d_ex_erreur_parametre_fichier;
               return(d_erreur);
           }
   
           (*((struct_socket *) (*s_objet_resultat).objet)).options |=
                   ((integer8) 1) << d_REUSE_ADDRESS;
       }
   
       return(d_absence_erreur);
   #   undef   WARNING
   }
   
   
 void  void
 instruction_open(struct_processus *s_etat_processus)  instruction_open(struct_processus *s_etat_processus)
 {  {
Line 905  instruction_open(struct_processus *s_eta Line 1136  instruction_open(struct_processus *s_eta
   
     int                         buffer_emission;      int                         buffer_emission;
     int                         buffer_reception;      int                         buffer_reception;
     int                         drapeau;  
     int                         priorite;      int                         priorite;
       int                         prochain_descripteur;
     int                         protocole_numerique;      int                         protocole_numerique;
     int                         timeout_emission;      int                         timeout_emission;
     int                         timeout_reception;      int                         timeout_reception;
Line 919  instruction_open(struct_processus *s_eta Line 1150  instruction_open(struct_processus *s_eta
   
     logical1                    erreur;      logical1                    erreur;
     logical1                    existence;      logical1                    existence;
       logical1                    negation;
     logical1                    ouverture;      logical1                    ouverture;
     logical1                    presence_port;      logical1                    presence_port;
   
Line 972  instruction_open(struct_processus *s_eta Line 1204  instruction_open(struct_processus *s_eta
   
     unsigned long               i;      unsigned long               i;
     unsigned long               nombre_elements;      unsigned long               nombre_elements;
     unsigned long               prochain_descripteur;  
     unsigned long               unite;      unsigned long               unite;
   
 #   define                      d_BIND_TO_DEVICE        0  
 #   define                      d_BROADCAST             1  
 #   define                      d_DONT_ROUTE            2  
 #   define                      d_KEEP_ALIVE            3  
 #   define                      d_PRIORITY              4  
 #   define                      d_RECEIVE_BUFFER        5  
 #   define                      d_FORCE_RECEIVE_BUFFER  6  
 #   define                      d_SEND_BUFFER           7  
 #   define                      d_FORCE_SEND_BUFFER     8  
 #   define                      d_RECEIVING_TIMEOUT     9  
 #   define                      d_SENDING_TIMEOUT       10  
 #   define                      d_REUSE_ADDRESS         11  
   
     /*      /*
      * Argument : { "ouverture" "accès" "format" [ { "nom" } 'protection' ] }       * Argument : { "ouverture" "accès" "format" [ { "nom" } 'protection' ] }
      */       */
Line 1027  instruction_open(struct_processus *s_eta Line 1245  instruction_open(struct_processus *s_eta
                 "\"file name\" } \"protection\" } OPEN\n");                  "\"file name\" } \"protection\" } OPEN\n");
         printf("    { \"filetype\" \"access\" \"format\" { \"name\" "          printf("    { \"filetype\" \"access\" \"format\" { \"name\" "
                 "\"file name\" } \n"                  "\"file name\" } \n"
                 "           { \"stty\" { \"stty parameters\" ... } } } OPEN\n");                  "           { \"stty\" \"speed,bits,parity,stop\"\n"
                   "           { \"stty parameters\" ... } } } OPEN\n");
         printf("    { \"sockettype\" { \"name\" \"local name\" } } OPEN\n");          printf("    { \"sockettype\" { \"name\" \"local name\" } } OPEN\n");
         printf("    { \"sockettype\" \"socketdomain\" \"protection\" } OPEN\n");          printf("    { \"sockettype\" \"socketdomain\" \"protection\" } OPEN\n");
         printf("    \"/semaphore\" OPEN\n");          printf("    \"/semaphore\" OPEN\n\n");
   
         printf("    File type       : NEW/OLD/REPLACE/UNKNOWN/SCRATCH\n");          printf("    File type       : NEW/OLD/REPLACE/UNKNOWN/SCRATCH\n");
         printf("    File access     : SEQUENTIAL/DIRECT/KEYED\n");          printf("    File access     : SEQUENTIAL/DIRECT/KEYED\n");
Line 1046  instruction_open(struct_processus *s_eta Line 1265  instruction_open(struct_processus *s_eta
         printf("            IMAXBEL, OPOST, ONLCR, OCRNL, ONOCR, ONLRET,\n");          printf("            IMAXBEL, OPOST, ONLCR, OCRNL, ONOCR, ONLRET,\n");
         printf("            OFILL, HUPCL, CLOCAL, CRTSCTS, ISIG, ICANON,\n");          printf("            OFILL, HUPCL, CLOCAL, CRTSCTS, ISIG, ICANON,\n");
         printf("            ECHO, ECHOE, ECHOK, ECHONL, NOFLSH, TOSTOP,\n");          printf("            ECHO, ECHOE, ECHOK, ECHONL, NOFLSH, TOSTOP,\n");
         printf("            IEXTEN, VEOF, VEOL, VERASE, VINTR, VKILL,\n");          printf("            IEXTEN\n");
         printf("            VQUIT, VSTART, VSTOP, VSUSP\n");  
   
         printf("    Address         : { \"ADDRESS\" [ 127 0 0 1 ] }\n");          printf("    Address         : { \"ADDRESS\" [ 127 0 0 1 ] }\n");
         printf("                      { \"HOST\" \"hostname\" }\n");          printf("                      { \"HOST\" \"hostname\" }\n");
Line 1069  instruction_open(struct_processus *s_eta Line 1287  instruction_open(struct_processus *s_eta
         printf("    Port            : { \"PORT\" port number }\n");          printf("    Port            : { \"PORT\" port number }\n");
         printf("    Protocol        : { \"PROTOCOL\" \"protocol\" }\n\n");          printf("    Protocol        : { \"PROTOCOL\" \"protocol\" }\n\n");
   
         printf("    { { \"NAME\" \"filename\" } } OPEN\n");          printf("    { { \"NAME\" \"filename\" } \"SEQUENTIAL\" } OPEN\n");
         printf("    { \"SCRATCH\" } OPEN\n");          printf("    { \"SCRATCH\" } OPEN\n");
         printf("    { { \"NAME\" \"filename\" } \"UNKNOWN\" \"FORMATTED\" "          printf("    { { \"NAME\" \"filename\" } \"UNKNOWN\" \"FORMATTED\" "
                 "\"DIRECT\" } OPEN\n");                  "\"DIRECT\" } OPEN\n");
Line 1078  instruction_open(struct_processus *s_eta Line 1296  instruction_open(struct_processus *s_eta
         printf("    { \"STREAM\" \"READWRITE\" } OPEN\n");          printf("    { \"STREAM\" \"READWRITE\" } OPEN\n");
         printf("    { \"FOREIGN\" \"DATAGRAM\" } OPEN\n");          printf("    { \"FOREIGN\" \"DATAGRAM\" } OPEN\n");
         printf("    { \"LOCAL\" { \"NAME\" \"socket.sock\" } } OPEN\n");          printf("    { \"LOCAL\" { \"NAME\" \"socket.sock\" } } OPEN\n");
         printf("    { \"/dev/ttyS1\" { \"STTY\" { \"9600,8,N,1\" "          printf("    { { \"NAME\" \"/dev/ttyS1\" } { \"STTY\" \"9600,8,N,1\" "
                 "\"NO ICANON\" \"IGNBRK\" } }\n");                  "\n            { \"NO ICANON\" \"IGNBRK\" } } } OPEN\n");
   
         return;          return;
     }      }
Line 1139  instruction_open(struct_processus *s_eta Line 1357  instruction_open(struct_processus *s_eta
         buffer_reception = 0;          buffer_reception = 0;
         timeout_emission = 0;          timeout_emission = 0;
         timeout_reception = 0;          timeout_reception = 0;
         drapeau = -1;  
         s_parametres_tty = NULL;          s_parametres_tty = NULL;
   
         for(i = 0; i < 12; options[i++] = 'N');          for(i = 0; i < 12; options[i++] = 'N');
Line 1148  instruction_open(struct_processus *s_eta Line 1365  instruction_open(struct_processus *s_eta
         {          {
             if ((*(*l_element_courant).donnee).type == CHN)              if ((*(*l_element_courant).donnee).type == CHN)
             {              {
                 if ((argument_majuscule = conversion_majuscule((unsigned char *)                  if ((argument_majuscule = conversion_majuscule(s_etat_processus,
                         (*(*l_element_courant).donnee).objet)) == NULL)                          (unsigned char *) (*(*l_element_courant).donnee).objet))
                           == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 1763  instruction_open(struct_processus *s_eta Line 1981  instruction_open(struct_processus *s_eta
                     if ((*(*l_element_courant_sous_objet).donnee).type == CHN)                      if ((*(*l_element_courant_sous_objet).donnee).type == CHN)
                     {                      {
                         if ((argument_majuscule = conversion_majuscule(                          if ((argument_majuscule = conversion_majuscule(
                                 (unsigned char *)                                  s_etat_processus, (unsigned char *)
                                 (*(*l_element_courant_sous_objet)                                  (*(*l_element_courant_sous_objet)
                                 .donnee).objet)) == NULL)                                  .donnee).objet)) == NULL)
                         {                          {
Line 1829  instruction_open(struct_processus *s_eta Line 2047  instruction_open(struct_processus *s_eta
                             free(argument_majuscule);                              free(argument_majuscule);
   
                             if ((argument_majuscule = conversion_majuscule(                              if ((argument_majuscule = conversion_majuscule(
                                     (unsigned char *)                                      s_etat_processus, (unsigned char *)
                                     (*(*l_element_courant_sous_objet)                                      (*(*l_element_courant_sous_objet)
                                     .donnee).objet)) == NULL)                                      .donnee).objet)) == NULL)
                             {                              {
Line 1998  instruction_open(struct_processus *s_eta Line 2216  instruction_open(struct_processus *s_eta
                                     if ((protocole_socket[i] >= 'a') &&                                      if ((protocole_socket[i] >= 'a') &&
                                             (protocole_socket[i] <= 'z'))                                              (protocole_socket[i] <= 'z'))
                                     {                                      {
                                         protocole_socket[i] -= 'a' - 'A';                                          protocole_socket[i] = (unsigned char)
                                                   (protocole_socket[i]
                                                   - ('a' - 'A'));
                                     }                                      }
                                 }                                  }
                             }                              }
Line 2272  instruction_open(struct_processus *s_eta Line 2492  instruction_open(struct_processus *s_eta
                         else if (strcmp(argument_majuscule, "STTY") == 0)                          else if (strcmp(argument_majuscule, "STTY") == 0)
                         {                          {
                             if ((*(*l_element_courant_sous_objet)                              if ((*(*l_element_courant_sous_objet)
                                     .donnee).type == LST)                                      .donnee).type == CHN)
                             {                              {
                                 if (type_arguments == ' ')                                  if (type_arguments == ' ')
                                 {                                  {
Line 2289  instruction_open(struct_processus *s_eta Line 2509  instruction_open(struct_processus *s_eta
                                     return;                                      return;
                                 }                                  }
   
                                 s_parametres_tty =                                  s_parametres_tty = (*l_element_courant).donnee;
                                         (*l_element_courant_sous_objet).donnee;  
                             }                              }
                         }                          }
                         else                          else
Line 2319  instruction_open(struct_processus *s_eta Line 2538  instruction_open(struct_processus *s_eta
                     if ((*(*l_element_courant_sous_objet).donnee).type == CHN)                      if ((*(*l_element_courant_sous_objet).donnee).type == CHN)
                     {                      {
                         if ((argument_majuscule = conversion_majuscule(                          if ((argument_majuscule = conversion_majuscule(
                                 (unsigned char *)                                  s_etat_processus, (unsigned char *)
                                 (*(*l_element_courant_sous_objet)                                  (*(*l_element_courant_sous_objet)
                                 .donnee).objet)) == NULL)                                  .donnee).objet)) == NULL)
                         {                          {
Line 2360  instruction_open(struct_processus *s_eta Line 2579  instruction_open(struct_processus *s_eta
                             }                              }
   
                             if ((argument_majuscule = conversion_majuscule(                              if ((argument_majuscule = conversion_majuscule(
                                     (unsigned char *)                                      s_etat_processus, (unsigned char *)
                                     (*(*l_element_courant_sous_objet)                                      (*(*l_element_courant_sous_objet)
                                     .donnee).objet)) == NULL)                                      .donnee).objet)) == NULL)
                             {                              {
Line 2646  instruction_open(struct_processus *s_eta Line 2865  instruction_open(struct_processus *s_eta
   
                             free(argument_majuscule);                              free(argument_majuscule);
                         }                          }
                           else if (strcmp(argument_majuscule, "STTY") == 0)
                           {
                               if (type_arguments == ' ')
                               {
                                   type_arguments = 'F';
                               }
                               else if (type_arguments == 'S')
                               {
                                   liberation(s_etat_processus, s_objet_argument);
                                   free(argument_majuscule);
   
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_erreur_parametre_fichier;
                                   return;
                               }
   
                               free(argument_majuscule);
   
                               l_element_courant_sous_objet =
                                       (*l_element_courant_sous_objet).suivant;
   
                               if ((*(*l_element_courant_sous_objet)
                                       .donnee).type != CHN)
                               {
                                   liberation(s_etat_processus, s_objet_argument);
   
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_erreur_parametre_fichier;
                                   return;
                               }
   
                               l_element_courant_sous_objet =
                                       (*l_element_courant_sous_objet).suivant;
   
                               if ((*(*l_element_courant_sous_objet)
                                       .donnee).type != LST)
                               {
                                   liberation(s_etat_processus, s_objet_argument);
   
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_erreur_parametre_fichier;
                                   return;
                               }
   
                               s_parametres_tty = (*l_element_courant).donnee;
                           }
                         else                          else
                         {                          {
                             liberation(s_etat_processus, s_objet_argument);                              liberation(s_etat_processus, s_objet_argument);
Line 2686  instruction_open(struct_processus *s_eta Line 2951  instruction_open(struct_processus *s_eta
             l_element_courant = (*l_element_courant).suivant;              l_element_courant = (*l_element_courant).suivant;
         }          }
   
           // Si aucun paramètre n'est discriminant, l'instruction ouvre
           // par défaut un fichier.
   
           if (type_arguments == ' ')
           {
               type_arguments = 'F';
           }
   
         if (type_arguments == 'F')          if (type_arguments == 'F')
         {          {
             /*              /*
Line 3537  instruction_open(struct_processus *s_eta Line 3810  instruction_open(struct_processus *s_eta
                     return;                      return;
                 }                  }
   
                 parametre_courant = (*s_parametres_tty).objet;                  // Un test a déjà été fait pour vérifier que s_parametres_tty
                   // contient deux ou trois arguments.
   
                   parametre_courant = ((*(struct_liste_chainee *)
                           (*s_parametres_tty).objet)).suivant;
   
                 // Le premier paramètre concerne la vitesse du port. Il doit                  // Le premier paramètre concerne la vitesse du port. Il doit
                 // toujours être présent.                  // toujours être présent.
Line 3563  instruction_open(struct_processus *s_eta Line 3840  instruction_open(struct_processus *s_eta
                 }                  }
   
                 if ((parametre_courant_majuscule = conversion_majuscule(                  if ((parametre_courant_majuscule = conversion_majuscule(
                         (*(*parametre_courant).donnee).objet)) == NULL)                          s_etat_processus, (*(*parametre_courant).donnee).objet))
                           == NULL)
                 {                  {
                     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);
Line 3600  instruction_open(struct_processus *s_eta Line 3878  instruction_open(struct_processus *s_eta
                 // Vitesse                  // Vitesse
   
                 unsigned char   *vitesses[] =                  unsigned char   *vitesses[] =
                         { "B0", "B50", "B75", "B110", "B134", "B150",                          { "50", "75", "110", "134", "150",
                         "B200", "B300", "B600", "B1200", "B1800", "B2400",                          "200", "300", "600", "1200", "1800", "2400",
                         "B4800", "B9600", "B19200", "B38400", "B57600",                          "4800", "9600", "19200", "38400",
                         "B115200", "B230400", NULL };  #ifdef B57600
                 int             vitesses_constantes[] =                          "57600",
                         { B0, B50, B75, B110, B134, B150, B200, B300, B600,  #endif
   #ifdef B115200
                           "115200",
   #endif
   #ifdef B230400
                           "230400",
   #endif
                           NULL };
                   tcflag_t        vitesses_constantes[] =
                           { B50, B75, B110, B134, B150, B200, B300, B600,
                         B1200, B1800, B2400, B4800, B9600, B19200, B38400,                          B1200, B1800, B2400, B4800, B9600, B19200, B38400,
                         B57600, B115200, B230400, 0 };  #ifdef B57600
                           B57600,
   #endif
   #ifdef B115200
                           B115200,
   #endif
   #ifdef B230400
                           B230400,
   #endif
                           0 };
                 unsigned int    vitesse_courante;                  unsigned int    vitesse_courante;
   
                 vitesse_courante = 0;                  vitesse_courante = 0;
Line 3620  instruction_open(struct_processus *s_eta Line 3916  instruction_open(struct_processus *s_eta
                         if (position[strlen(vitesses[vitesse_courante])] ==                          if (position[strlen(vitesses[vitesse_courante])] ==
                                 d_code_espace)                                  d_code_espace)
                         {                          {
                             tc.c_cflag &= ~CBAUD;  #ifdef CBAUD
                               tc.c_cflag &= ~((tcflag_t) CBAUD);
                             tc.c_cflag |= vitesses_constantes[vitesse_courante];                              tc.c_cflag |= vitesses_constantes[vitesse_courante];
   #else // POSIX
                               cfsetispeed(&tc,
                                       vitesses_constantes[vitesse_courante]);
                               cfsetospeed(&tc,
                                       vitesses_constantes[vitesse_courante]);
   #endif
                             position += strlen(vitesses[vitesse_courante]);                              position += strlen(vitesses[vitesse_courante]);
   
                             break;                              break;
Line 3660  instruction_open(struct_processus *s_eta Line 3963  instruction_open(struct_processus *s_eta
                 {                  {
                     case '5':                      case '5':
                     {                      {
                         tc.c_cflag &= ~CSIZE;                          tc.c_cflag &= ~((tcflag_t) CSIZE);
                         tc.c_cflag |= CS5;                          tc.c_cflag |= CS5;
                         break;                          break;
                     }                      }
   
                     case '6':                      case '6':
                     {                      {
                         tc.c_cflag &= ~CSIZE;                          tc.c_cflag &= ~((tcflag_t) CSIZE);
                         tc.c_cflag |= CS6;                          tc.c_cflag |= CS6;
                         break;                          break;
                     }                      }
   
                     case '7':                      case '7':
                     {                      {
                         tc.c_cflag &= ~CSIZE;                          tc.c_cflag &= ~((tcflag_t) CSIZE);
                         tc.c_cflag |= CS7;                          tc.c_cflag |= CS7;
                         break;                          break;
                     }                      }
   
                     case '8':                      case '8':
                     {                      {
                         tc.c_cflag &= ~CSIZE;                          tc.c_cflag &= ~((tcflag_t) CSIZE);
                         tc.c_cflag |= CS8;                          tc.c_cflag |= CS8;
                         break;                          break;
                     }                      }
Line 3727  instruction_open(struct_processus *s_eta Line 4030  instruction_open(struct_processus *s_eta
                 {                  {
                     case 'N':                      case 'N':
                     {                      {
                         tc.c_cflag &= ~PARENB;                          tc.c_cflag &= ~((tcflag_t) PARENB);
                         break;                          break;
                     }                      }
   
Line 3741  instruction_open(struct_processus *s_eta Line 4044  instruction_open(struct_processus *s_eta
                     case 'E':                      case 'E':
                     {                      {
                         tc.c_cflag |= PARENB;                          tc.c_cflag |= PARENB;
                         tc.c_cflag &= ~PARODD;                          tc.c_cflag &= ~((tcflag_t) PARODD);
                         break;                          break;
                     }                      }
   
Line 3757  instruction_open(struct_processus *s_eta Line 4060  instruction_open(struct_processus *s_eta
                     }                      }
                 }                  }
   
                   position++;
   
                 if ((*position) != d_code_espace)                  if ((*position) != d_code_espace)
                 {                  {
                     free(parametre_courant_majuscule);                      free(parametre_courant_majuscule);
Line 3784  instruction_open(struct_processus *s_eta Line 4089  instruction_open(struct_processus *s_eta
                 {                  {
                     case '1':                      case '1':
                     {                      {
                         tc.c_cflag &= ~CSTOPB;                          tc.c_cflag &= ~((tcflag_t) CSTOPB);
                         break;                          break;
                     }                      }
   
Line 3809  instruction_open(struct_processus *s_eta Line 4114  instruction_open(struct_processus *s_eta
                 // S'il reste autre chose que des espaces, il y a un                  // S'il reste autre chose que des espaces, il y a un
                 // problème de paramètres.                  // problème de paramètres.
   
                   position++;
   
                 while((*position) != d_code_fin_chaine)                  while((*position) != d_code_fin_chaine)
                 {                  {
                     if ((*position) != d_code_espace)                      if ((*position) != d_code_espace)
Line 3828  instruction_open(struct_processus *s_eta Line 4135  instruction_open(struct_processus *s_eta
                 // Autres paramètres                  // Autres paramètres
   
                 free(parametre_courant_majuscule);                  free(parametre_courant_majuscule);
                   parametre_courant = (*parametre_courant).suivant;
   
                   if (parametre_courant != NULL)
                   {
                       parametre_courant = (*(*parametre_courant).donnee).objet;
                   }
   
                 while(parametre_courant != NULL)                  while(parametre_courant != NULL)
                 {                  {
                       if ((*(*parametre_courant).donnee).type != CHN)
                       {
                           liberation(s_etat_processus, s_objet_argument);
                           liberation(s_etat_processus, s_objet_resultat);
   
                           (*s_etat_processus).erreur_execution =
                                   d_ex_erreur_parametre_fichier;
                           return;
                       }
   
                       if ((parametre_courant_majuscule = conversion_majuscule(
                               s_etat_processus, (*(*parametre_courant).donnee)
                               .objet)) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       position = parametre_courant_majuscule;
                       negation = d_faux;
   
                       unsigned char   *fonctions[] =
                               { "IGNBRK", "BRKINT", "IGNPAR", "PARMRK",
                               "INPCK", "ISTRIP", "INLCR", "IGNCR", "ICRNL",
                               "IXON",
   #ifdef IXANY
                               "IXANY",
   #endif
                               "IXOFF", "OPOST",
                               "ONLCR", "OCRNL", "ONOCR", "ONLRET",
   #ifdef OFILL
                               "OFILL",
   #endif
                               "HUPCL", "CLOCAL",
   #ifdef CRTSCTS
                               "CRTSCTS",
   #endif
                               "ISIG", "ICANON", "ECHO", "ECHOE", "ECHOK",
                               "ECHONL", "NOFLSH", "TOSTOP", "IEXTEN", NULL };
                       tcflag_t        fonctions_constantes[] =
                               { /* c_iflag */
                               1, IGNBRK, 1, BRKINT, 1, IGNPAR, 1, PARMRK,
                               1, INPCK, 1, ISTRIP, 1, INLCR, 1, IGNCR, 1, ICRNL,
                               1, IXON,
   #ifdef IXANY
                               1, IXANY,
   #endif
                               1, IXOFF,
                               /* c_oflag */
                               2 , OPOST, 2, ONLCR, 2, OCRNL, 2, ONOCR, 2, ONLRET,
   #ifdef OFILL
                               2, OFILL,
   #endif
                               2, HUPCL,
                               /* c_cflag */
                               3, CLOCAL,
   #ifdef CRTSCTS
                               3, CRTSCTS,
   #endif
                               /* c_lfkag */
                               4, ISIG, 4, ICANON, 4, ECHO, 4, ECHOE, 4, ECHOK,
                               4, ECHONL, 4, NOFLSH, 4, TOSTOP, 4, IEXTEN };
                       unsigned int    fonction_courante;
   
                       // On vient de trouver quelque chose à interpréter.
   
                       if (strncmp(position, "NO ", 3) == 0)
                       {
                           position += 3;
                           negation = d_vrai;
                       }
   
                       for(fonction_courante = 0;
                               fonctions[fonction_courante] != NULL;
                               fonction_courante++)
                       {
                           if (strcmp(fonctions[fonction_courante], position)
                                   == 0)
                           {
                               if (negation == d_vrai)
                               {
                                   switch(fonctions_constantes
                                           [fonction_courante * 2])
                                   {
                                       case 1:
                                       {
                                           tc.c_iflag &= ~fonctions_constantes
                                                   [(fonction_courante * 2) + 1];
                                           break;
                                       }
   
                                       case 2:
                                       {
                                           tc.c_oflag &= ~fonctions_constantes
                                                   [(fonction_courante * 2) + 1];
                                           break;
                                       }
   
                                       case 3:
                                       {
                                           tc.c_cflag &= ~fonctions_constantes
                                                   [(fonction_courante * 2) + 1];
                                           break;
                                       }
   
                                       case 4:
                                       {
                                           tc.c_lflag &= ~fonctions_constantes
                                                   [(fonction_courante * 2) + 1];
                                           break;
                                       }
                                   }
                               }
                               else
                               {
                                   switch(fonctions_constantes
                                           [fonction_courante * 2])
                                   {
                                       case 1:
                                       {
                                           tc.c_iflag |= fonctions_constantes
                                                   [(fonction_courante * 2) + 1];
                                           break;
                                       }
   
                                       case 2:
                                       {
                                           tc.c_oflag |= fonctions_constantes
                                                   [(fonction_courante * 2) + 1];
                                           break;
                                       }
   
                                       case 3:
                                       {
                                           tc.c_cflag |= fonctions_constantes
                                                   [(fonction_courante * 2) + 1];
                                           break;
                                       }
   
                                       case 4:
                                       {
                                           tc.c_lflag |= fonctions_constantes
                                                   [(fonction_courante * 2) + 1];
                                           break;
                                       }
                                   }
                               }
   
                               break;
                           }
                       }
   
                       if (fonctions[fonction_courante] == NULL)
                       {
                           free(parametre_courant_majuscule);
                           liberation(s_etat_processus, s_objet_argument);
                           liberation(s_etat_processus, s_objet_resultat);
   
                           (*s_etat_processus).erreur_execution =
                                   d_ex_erreur_parametre_fichier;
                           return;
                       }
   
                       free(parametre_courant_majuscule);
                     parametre_courant = (*parametre_courant).suivant;                      parametre_courant = (*parametre_courant).suivant;
                 }                  }
   
                   if (tcsetattr(fileno(descripteur), TCSANOW, &tc) != 0)
                   {
                       liberation(s_etat_processus, s_objet_argument);
                       liberation(s_etat_processus, s_objet_resultat);
   
                       (*s_etat_processus).erreur_systeme =
                               d_ex_erreur_fichier;
                       return;
                   }
             }              }
   
             strcpy((*((struct_fichier *) (*s_objet_resultat).objet)).nom, nom);              strcpy((*((struct_fichier *) (*s_objet_resultat).objet)).nom, nom);
Line 4041  instruction_open(struct_processus *s_eta Line 4529  instruction_open(struct_processus *s_eta
                     return;                      return;
                 }                  }
   
                 prochain_descripteur = i;                  prochain_descripteur = (int) i;
   
                 /*                  /*
                  * Ajout d'un élément à la fin de la liste chaînée                   * Ajout d'un élément à la fin de la liste chaînée
Line 4111  instruction_open(struct_processus *s_eta Line 4599  instruction_open(struct_processus *s_eta
              * Traitement des sockets               * Traitement des sockets
              */               */
   
   
             inline logical1 options_socket()  
             {  
                 /*  
                  * Options des sockets  
                  */  
   
 #               define WARNING(message) \  
                 if ((*s_etat_processus).langue != 'F') \  
                     printf("+++Warning : %s unavailable on host system\n", \  
                             message); \  
                 else \  
                     printf("+++Attention : %s non disponible sur le système " \  
                             "hôte\n", message)  
   
                 if (options[d_BIND_TO_DEVICE] == 'Y')  
                 {  
 #                   ifdef SO_BINDTODEVICE  
                         if (setsockopt((*((struct_socket *) (*s_objet_resultat)  
                                 .objet)).socket, SOL_SOCKET, SO_BINDTODEVICE,  
                                 peripherique, strlen(peripherique)) != 0)  
                         {  
                             liberation(s_etat_processus, s_objet_argument);  
                             liberation(s_etat_processus, s_objet_resultat);  
   
                             (*s_etat_processus).erreur_execution =  
                                     d_ex_erreur_parametre_fichier;  
                             return(d_erreur);  
                         }  
 #                   else  
                         WARNING("BIND TO DEVICE");  
 #                   endif  
                 }  
   
                 if (options[d_BROADCAST] == 'Y')  
                 {  
                     if (setsockopt((*((struct_socket *) (*s_objet_resultat)  
                             .objet)).socket, SOL_SOCKET, SO_BROADCAST,  
                             &drapeau, sizeof(drapeau)) != 0)  
                     {  
                         liberation(s_etat_processus, s_objet_argument);  
                         liberation(s_etat_processus, s_objet_resultat);  
   
                         (*s_etat_processus).erreur_execution =  
                                 d_ex_erreur_parametre_fichier;  
                         return(d_erreur);  
                     }  
                 }  
   
                 if (options[d_DONT_ROUTE] == 'Y')  
                 {  
                     if (setsockopt((*((struct_socket *) (*s_objet_resultat)  
                             .objet)).socket, SOL_SOCKET, SO_DONTROUTE,  
                             &drapeau, sizeof(drapeau)) != 0)  
                     {  
                         liberation(s_etat_processus, s_objet_argument);  
                         liberation(s_etat_processus, s_objet_resultat);  
   
                         (*s_etat_processus).erreur_execution =  
                                 d_ex_erreur_parametre_fichier;  
                         return(d_erreur);  
                     }  
                 }  
   
                 if (options[d_KEEP_ALIVE] == 'Y')  
                 {  
                     if (setsockopt((*((struct_socket *) (*s_objet_resultat)  
                             .objet)).socket, SOL_SOCKET, SO_KEEPALIVE,  
                             &drapeau, sizeof(drapeau)) != 0)  
                     {  
                         liberation(s_etat_processus, s_objet_argument);  
                         liberation(s_etat_processus, s_objet_resultat);  
   
                         (*s_etat_processus).erreur_execution =  
                                 d_ex_erreur_parametre_fichier;  
                         return(d_erreur);  
                     }  
                 }  
   
                 if (options[d_PRIORITY] == 'Y')  
                 {  
 #                   ifdef SO_PRIORITY  
                         if (setsockopt((*((struct_socket *) (*s_objet_resultat)  
                                 .objet)).socket, SOL_SOCKET, SO_PRIORITY,  
                                 &priorite, sizeof(priorite)) != 0)  
                         {  
                             liberation(s_etat_processus, s_objet_argument);  
                             liberation(s_etat_processus, s_objet_resultat);  
   
                             (*s_etat_processus).erreur_execution =  
                                     d_ex_erreur_parametre_fichier;  
                             return(d_erreur);  
                         }  
 #                   else  
                         WARNING("PRIORITY");  
 #                   endif  
                 }  
   
                 if (options[d_RECEIVE_BUFFER] == 'Y')  
                 {  
                     if (setsockopt((*((struct_socket *) (*s_objet_resultat)  
                             .objet)).socket, SOL_SOCKET, SO_RCVBUF,  
                             &buffer_reception, sizeof(buffer_reception)) != 0)  
                     {  
                         liberation(s_etat_processus, s_objet_argument);  
                         liberation(s_etat_processus, s_objet_resultat);  
   
                         (*s_etat_processus).erreur_execution =  
                                 d_ex_erreur_parametre_fichier;  
                         return(d_erreur);  
                     }  
                 }  
   
                 if (options[d_FORCE_RECEIVE_BUFFER] == 'Y')  
                 {  
 #                   ifdef SO_RCVBUFFORCE  
                         if (setsockopt((*((struct_socket *) (*s_objet_resultat)  
                                 .objet)).socket, SOL_SOCKET, SO_RCVBUFFORCE,  
                                 &buffer_reception, sizeof(buffer_reception))  
                                 != 0)  
                         {  
                             liberation(s_etat_processus, s_objet_argument);  
                             liberation(s_etat_processus, s_objet_resultat);  
   
                             (*s_etat_processus).erreur_execution =  
                                     d_ex_erreur_parametre_fichier;  
                             return(d_erreur);  
                         }  
 #                   else  
                         WARNING("FORCE_RECEIVE_BUFFER");  
 #                   endif  
                 }  
   
                 if (options[d_SEND_BUFFER] == 'Y')  
                 {  
                     if (setsockopt((*((struct_socket *) (*s_objet_resultat)  
                             .objet)).socket, SOL_SOCKET, SO_SNDBUF,  
                             &buffer_emission, sizeof(buffer_emission)) != 0)  
                     {  
                         liberation(s_etat_processus, s_objet_argument);  
                         liberation(s_etat_processus, s_objet_resultat);  
   
                         (*s_etat_processus).erreur_execution =  
                                 d_ex_erreur_parametre_fichier;  
                         return(d_erreur);  
                     }  
                 }  
   
                 if (options[d_FORCE_SEND_BUFFER] == 'Y')  
                 {  
 #                   ifdef SO_SNDBUFFORCE  
                         if (setsockopt((*((struct_socket *) (*s_objet_resultat)  
                                 .objet)).socket, SOL_SOCKET, SO_SNDBUFFORCE,  
                                 &buffer_emission, sizeof(buffer_emission)) != 0)  
                         {  
                             liberation(s_etat_processus, s_objet_argument);  
                             liberation(s_etat_processus, s_objet_resultat);  
   
                             (*s_etat_processus).erreur_execution =  
                                     d_ex_erreur_parametre_fichier;  
                             return(d_erreur);  
                         }  
 #                   else  
                         WARNING("FORCE_SEND_BUFFER");  
 #                   endif  
                 }  
   
                 if (options[d_RECEIVING_TIMEOUT] == 'Y')  
                 {  
                     if (setsockopt((*((struct_socket *) (*s_objet_resultat)  
                             .objet)).socket, SOL_SOCKET, SO_RCVTIMEO,  
                             &timeout_reception, sizeof(timeout_reception)) != 0)  
                     {  
                         liberation(s_etat_processus, s_objet_argument);  
                         liberation(s_etat_processus, s_objet_resultat);  
   
                         (*s_etat_processus).erreur_execution =  
                                 d_ex_erreur_parametre_fichier;  
                         return(d_erreur);  
                     }  
                 }  
   
                 if (options[d_SENDING_TIMEOUT] == 'Y')  
                 {  
                     if (setsockopt((*((struct_socket *) (*s_objet_resultat)  
                             .objet)).socket, SOL_SOCKET, SO_SNDTIMEO,  
                             &timeout_emission, sizeof(timeout_emission)) != 0)  
                     {  
                         liberation(s_etat_processus, s_objet_argument);  
                         liberation(s_etat_processus, s_objet_resultat);  
   
                         (*s_etat_processus).erreur_execution =  
                                 d_ex_erreur_parametre_fichier;  
                         return(d_erreur);  
                     }  
                 }  
   
                 if (options[d_REUSE_ADDRESS] == 'Y')  
                 {  
                     if (setsockopt((*((struct_socket *) (*s_objet_resultat)  
                             .objet)).socket, SOL_SOCKET, SO_REUSEADDR,  
                             &drapeau, sizeof(drapeau)) != 0)  
                     {  
                         liberation(s_etat_processus, s_objet_argument);  
                         liberation(s_etat_processus, s_objet_resultat);  
   
                         (*s_etat_processus).erreur_execution =  
                                 d_ex_erreur_parametre_fichier;  
                         return(d_erreur);  
                     }  
                 }  
   
                 return(d_absence_erreur);  
 #undef          WARNING  
             }  
   
             /*              /*
              * Vérification de la cohérence des arguments et traitement               * Vérification de la cohérence des arguments et traitement
              * des valeurs par défaut.               * des valeurs par défaut.
Line 4425  instruction_open(struct_processus *s_eta Line 4697  instruction_open(struct_processus *s_eta
                     for(i = 0; i < 16; adresse[i++] = 0);                      for(i = 0; i < 16; adresse[i++] = 0);
                     type_adresse = '6';                      type_adresse = '6';
                 }                  }
                 else                  else if (strcmp(protocole, "UNIX") != 0)
                 {                  {
                     liberation(s_etat_processus, s_objet_argument);                      liberation(s_etat_processus, s_objet_argument);
   
Line 4469  instruction_open(struct_processus *s_eta Line 4741  instruction_open(struct_processus *s_eta
                 if (strcmp(protocole_socket, "IPV4") == 0)                  if (strcmp(protocole_socket, "IPV4") == 0)
                 {                  {
                     protocole_socket[2] = d_code_fin_chaine;                      protocole_socket[2] = d_code_fin_chaine;
                       protocole_numerique = 0;
                 }                  }
                   else
                 if ((s_protocole = getprotobyname(protocole_socket)) == NULL)  
                 {                  {
                     liberation(s_etat_processus, s_objet_argument);                      if ((s_protocole = getprotobyname(protocole_socket))
                               == NULL)
                       {
                           liberation(s_etat_processus, s_objet_argument);
   
                     (*s_etat_processus).erreur_execution =                          (*s_etat_processus).erreur_execution =
                             d_ex_erreur_parametre_fichier;                                  d_ex_erreur_parametre_fichier;
                     return;                          return;
                 }                      }
   
                 protocole_numerique = (*s_protocole).p_proto;                      protocole_numerique = (*s_protocole).p_proto;
                   }
             }              }
   
             if ((s_objet_resultat = allocation(s_etat_processus, SCK))              if ((s_objet_resultat = allocation(s_etat_processus, SCK))
Line 4502  instruction_open(struct_processus *s_eta Line 4778  instruction_open(struct_processus *s_eta
                     = protection;                      = protection;
             (*(*((struct_socket *) (*s_objet_resultat).objet))              (*(*((struct_socket *) (*s_objet_resultat).objet))
                     .format).objet = NULL;                      .format).objet = NULL;
               (*((struct_socket *) (*s_objet_resultat).objet)).adresse = NULL;
   
             switch(type_socket)              switch(type_socket)
             {              {
Line 4599  instruction_open(struct_processus *s_eta Line 4876  instruction_open(struct_processus *s_eta
                     = 'Y';                      = 'Y';
             (*((struct_socket *) (*s_objet_resultat).objet)).socket_connectee              (*((struct_socket *) (*s_objet_resultat).objet)).socket_connectee
                     = d_faux;                      = d_faux;
               (*((struct_socket *) (*s_objet_resultat).objet)).options = 0;
   
             if (type_domaine == 'L')              if (type_domaine == 'L')
             { // Socket serveur              { // Socket serveur
Line 4638  instruction_open(struct_processus *s_eta Line 4916  instruction_open(struct_processus *s_eta
                     strncpy(socket_unix.sun_path, pointeur, UNIX_PATH_MAX);                      strncpy(socket_unix.sun_path, pointeur, UNIX_PATH_MAX);
                     socket_unix.sun_path[UNIX_PATH_MAX - 1] = d_code_fin_chaine;                      socket_unix.sun_path[UNIX_PATH_MAX - 1] = d_code_fin_chaine;
   
                     if (options_socket() == d_erreur)                      if (options_socket(s_etat_processus, s_objet_resultat,
                               options, peripherique, &priorite,
                               &buffer_emission, &buffer_reception,
                               &timeout_emission, &timeout_reception) == d_erreur)
                     {                      {
                         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);
Line 4742  instruction_open(struct_processus *s_eta Line 5023  instruction_open(struct_processus *s_eta
                                     (*resolution_courante).ai_addr))                                      (*resolution_courante).ai_addr))
                                     .sin_addr.s_addr;                                      .sin_addr.s_addr;
   
                             if (options_socket() == d_erreur)                              if (options_socket(s_etat_processus,
                                       s_objet_resultat,
                                       options, peripherique, &priorite,
                                       &buffer_emission, &buffer_reception,
                                       &timeout_emission, &timeout_reception)
                                       == d_erreur)
                             {                              {
                                 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);
Line 4765  instruction_open(struct_processus *s_eta Line 5051  instruction_open(struct_processus *s_eta
                                 return;                                  return;
                             }                              }
   
                               free((*((struct_socket *) (*s_objet_resultat)
                                       .objet)).adresse);
   
                             if (((*((struct_socket *) (*s_objet_resultat)                              if (((*((struct_socket *) (*s_objet_resultat)
                                     .objet)).adresse = malloc(22 *                                      .objet)).adresse = malloc(23 *
                                     sizeof(unsigned char))) == NULL)                                      sizeof(unsigned char))) == NULL)
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
Line 4775  instruction_open(struct_processus *s_eta Line 5064  instruction_open(struct_processus *s_eta
                             }                              }
   
                             sprintf((*((struct_socket *) (*s_objet_resultat)                              sprintf((*((struct_socket *) (*s_objet_resultat)
                                     .objet)).adresse, "%d.%d.%d.%d",                                      .objet)).adresse, "%d.%d.%d.%d(%u)",
                                     (ntohl((*((struct sockaddr_in *)                                      (ntohl((*((struct sockaddr_in *)
                                     (*resolution_courante).ai_addr)).sin_addr                                      (*resolution_courante).ai_addr)).sin_addr
                                     .s_addr) >> 24) & 0xFF,                                      .s_addr) >> 24) & 0xFF,
Line 4787  instruction_open(struct_processus *s_eta Line 5076  instruction_open(struct_processus *s_eta
                                     .s_addr) >> 8) & 0xFF,                                      .s_addr) >> 8) & 0xFF,
                                     ntohl((*((struct sockaddr_in *)                                      ntohl((*((struct sockaddr_in *)
                                     (*resolution_courante).ai_addr)).sin_addr                                      (*resolution_courante).ai_addr)).sin_addr
                                     .s_addr) & 0xFF);                                      .s_addr) & 0xFF,
                                       (unsigned int) port);
                         }                          }
                         else                          else
                         { // Accès en IPv6                          { // Accès en IPv6
Line 4846  instruction_open(struct_processus *s_eta Line 5136  instruction_open(struct_processus *s_eta
                                     (*resolution_courante).ai_addr))                                      (*resolution_courante).ai_addr))
                                     .sin6_addr.s6_addr[i], i++);                                      .sin6_addr.s6_addr[i], i++);
   
                             if (options_socket() == d_erreur)                              if (options_socket(s_etat_processus,
                                       s_objet_resultat,
                                       options, peripherique, &priorite,
                                       &buffer_emission, &buffer_reception,
                                       &timeout_emission, &timeout_reception)
                                       == d_erreur)
                             {                              {
                                 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);
Line 4869  instruction_open(struct_processus *s_eta Line 5164  instruction_open(struct_processus *s_eta
                                 return;                                  return;
                             }                              }
   
                               free((*((struct_socket *) (*s_objet_resultat)
                                       .objet)).adresse);
   
                               /*
                                * Longueur de la chaîne :
                                * Adresse IPv6 : 16 octets soit 128 bits.
                                * => 32 chiffres en hexadécimal
                                * Par groupe de 4, 8 groupes
                                * => 7 ":"
                                * Port : (%u)
                                * => 7
                                * ==> 32 + 7 + 7 + 1 = 47
                                */
   
                             if (((*((struct_socket *) (*s_objet_resultat)                              if (((*((struct_socket *) (*s_objet_resultat)
                                     .objet)).adresse = malloc(55 *                                      .objet)).adresse = malloc(47 *
                                     sizeof(unsigned char))) == NULL)                                      sizeof(unsigned char))) == NULL)
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
Line 4878  instruction_open(struct_processus *s_eta Line 5187  instruction_open(struct_processus *s_eta
                                 return;                                  return;
                             }                              }
   
                             for(i = 0; i < 16; i++)                              sprintf((*((struct_socket *) (*s_objet_resultat)
                             {                                      .objet)).adresse,
                                 sprintf((*((struct_socket *) (*s_objet_resultat)                                      "%02X%02X:%02X%02X:%02X%02X:%02X%02X:"
                                         .objet)).adresse,                                      "%02X%02X:%02X%02X:%02X%02X:%02X%02X(%u)",
                                         (i == 0) ? "%s%X" : "%s:%X",                                      (*((struct sockaddr_in6 *)
                                         (*((struct_socket *) (*s_objet_resultat)                                      (*resolution_courante).ai_addr)).sin6_addr
                                         .objet)).adresse,                                      .s6_addr[0],
                                         (*((struct sockaddr_in6 *)                                      (*((struct sockaddr_in6 *)
                                         (*resolution_courante).ai_addr))                                      (*resolution_courante).ai_addr)).sin6_addr
                                         .sin6_addr.s6_addr[i]);                                      .s6_addr[1],
                             }                                      (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[2],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[3],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[4],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[5],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[6],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[7],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[8],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[9],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[10],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[11],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[12],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[13],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[14],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[15],
                                       (unsigned int) port);
 #                           else  #                           else
                             if ((*s_etat_processus).langue == 'F')                              if ((*s_etat_processus).langue == 'F')
                             {                              {
Line 4900  instruction_open(struct_processus *s_eta Line 5251  instruction_open(struct_processus *s_eta
                                 printf("+++Warning : IPv6 support "                                  printf("+++Warning : IPv6 support "
                                         "unavailable\n");                                          "unavailable\n");
                             }                              }
   
                               liberation(s_etat_processus, s_objet_argument);
                               liberation(s_etat_processus, s_objet_resultat);
   
                               freeaddrinfo(resolution);
   
                               (*s_etat_processus).erreur_execution =
                                       d_ex_instruction_indisponible;
                               return;
 #                           endif  #                           endif
                         }                          }
   
                         freeaddrinfo(resolution);                          freeaddrinfo(resolution);
   
                         sprintf((*((struct_socket *) (*s_objet_resultat)  
                                 .objet)).adresse, "%s(%u)",  
                                 (*((struct_socket *) (*s_objet_resultat)  
                                 .objet)).adresse, (unsigned int) port);  
                     }                      }
                     else                      else
                     { // Hôte défini par une adresse                      { // Hôte défini par une adresse
                         if (strcmp(protocole, "IPV4") == 0)                          if (strcmp(protocole, "IPV4") == 0)
                         { // Accès en IPv4                          { // Accès en IPv4
                               free((*((struct_socket *) (*s_objet_resultat)
                                       .objet)).adresse);
   
                             if (((*((struct_socket *) (*s_objet_resultat)                              if (((*((struct_socket *) (*s_objet_resultat)
                                     .objet)).adresse = malloc(22 *                                      .objet)).adresse = malloc(23 *
                                     sizeof(unsigned char))) == NULL)                                      sizeof(unsigned char))) == NULL)
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
Line 4923  instruction_open(struct_processus *s_eta Line 5281  instruction_open(struct_processus *s_eta
                                 return;                                  return;
                             }                              }
   
                             (*((struct_socket *) (*s_objet_resultat).objet))  
                                     .adresse[0] = d_code_fin_chaine;  
   
                             for(i = 0; i < 4; i++)  
                             {  
                                 sprintf((*((struct_socket *) (*s_objet_resultat)  
                                         .objet)).adresse,  
                                         (i == 0) ? "%s%d" : "%s.%d",  
                                         (*((struct_socket *) (*s_objet_resultat)  
                                         .objet)).adresse, (int) adresse[i]);  
                             }  
   
                             sprintf((*((struct_socket *) (*s_objet_resultat)                              sprintf((*((struct_socket *) (*s_objet_resultat)
                                     .objet)).adresse, "%s(%u)",                                      .objet)).adresse, "%d.%d.%d.%d(%u)",
                                     (*((struct_socket *) (*s_objet_resultat)                                      (int) adresse[0], (int) adresse[1],
                                     .objet)).adresse, (unsigned int) port);                                      (int) adresse[2], (int) adresse[3],
                                       (unsigned int) port);
   
                             if (((*((struct_socket *)                              if (((*((struct_socket *)
                                     (*s_objet_resultat).objet))                                      (*s_objet_resultat).objet))
Line 4962  instruction_open(struct_processus *s_eta Line 5309  instruction_open(struct_processus *s_eta
   
                             adresse_ipv4 = 0;                              adresse_ipv4 = 0;
                             for(i = 0; i < 4; adresse_ipv4 =                              for(i = 0; i < 4; adresse_ipv4 =
                                     (256 * adresse_ipv4) + adresse[i++]);                                      (256 * adresse_ipv4) +
                                       ((unsigned char) adresse[i++]));
   
                             socket_ipv4.sin_addr.s_addr = htonl(adresse_ipv4);                              socket_ipv4.sin_addr.s_addr = htonl(adresse_ipv4);
   
                             if (options_socket() == d_erreur)                              if (options_socket(s_etat_processus,
                                       s_objet_resultat,
                                       options, peripherique, &priorite,
                                       &buffer_emission, &buffer_reception,
                                       &timeout_emission, &timeout_reception)
                                       == d_erreur)
                             {                              {
                                 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);
Line 4989  instruction_open(struct_processus *s_eta Line 5342  instruction_open(struct_processus *s_eta
                         else                          else
                         { // Accès en IPv6                          { // Accès en IPv6
 #                           ifdef IPV6  #                           ifdef IPV6
                               free((*((struct_socket *) (*s_objet_resultat)
                                       .objet)).adresse);
   
                             if (((*((struct_socket *) (*s_objet_resultat)                              if (((*((struct_socket *) (*s_objet_resultat)
                                     .objet)).adresse = malloc(55 *                                      .objet)).adresse = malloc(47 *
                                     sizeof(unsigned char))) == NULL)                                      sizeof(unsigned char))) == NULL)
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
Line 4998  instruction_open(struct_processus *s_eta Line 5354  instruction_open(struct_processus *s_eta
                                 return;                                  return;
                             }                              }
   
                             (*((struct_socket *) (*s_objet_resultat).objet))  
                                     .adresse[0] = d_code_fin_chaine;  
   
                             for(i = 0; i < 16; i++)  
                             {  
                                 sprintf((*((struct_socket *) (*s_objet_resultat)  
                                         .objet)).adresse,  
                                         (i == 0) ? "%s%X" : "%s:%X",  
                                         (*((struct_socket *) (*s_objet_resultat)  
                                         .objet)).adresse, (unsigned int)  
                                         adresse[i]);  
                             }  
   
                             sprintf((*((struct_socket *) (*s_objet_resultat)                              sprintf((*((struct_socket *) (*s_objet_resultat)
                                     .objet)).adresse, "%s(%u)",                                      .objet)).adresse,
                                     (*((struct_socket *) (*s_objet_resultat)                                      "%02X%02X:%02X%02X:%02X%02X:%02X%02X:"
                                     .objet)).adresse, (unsigned int) port);                                      "%02X%02X:%02X%02X:%02X%02X:%02X%02X(%u)",
                                       (unsigned int) adresse[0],
                                       (unsigned int) adresse[1],
                                       (unsigned int) adresse[2],
                                       (unsigned int) adresse[3],
                                       (unsigned int) adresse[4],
                                       (unsigned int) adresse[5],
                                       (unsigned int) adresse[6],
                                       (unsigned int) adresse[7],
                                       (unsigned int) adresse[8],
                                       (unsigned int) adresse[9],
                                       (unsigned int) adresse[10],
                                       (unsigned int) adresse[11],
                                       (unsigned int) adresse[12],
                                       (unsigned int) adresse[13],
                                       (unsigned int) adresse[14],
                                       (unsigned int) adresse[15],
                                       (unsigned int) port);
   
                             if (((*((struct_socket *)                              if (((*((struct_socket *)
                                     (*s_objet_resultat).objet))                                      (*s_objet_resultat).objet))
Line 5040  instruction_open(struct_processus *s_eta Line 5400  instruction_open(struct_processus *s_eta
                                     socket_ipv6.sin6_addr.s6_addr[i] =                                      socket_ipv6.sin6_addr.s6_addr[i] =
                                     (unsigned char) (adresse[i]), i++);                                      (unsigned char) (adresse[i]), i++);
   
                             if (options_socket() == d_erreur)                              if (options_socket(s_etat_processus,
                                       s_objet_resultat,
                                       options, peripherique, &priorite,
                                       &buffer_emission, &buffer_reception,
                                       &timeout_emission, &timeout_reception)
                                       == d_erreur)
                             {                              {
                                 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);
Line 5070  instruction_open(struct_processus *s_eta Line 5435  instruction_open(struct_processus *s_eta
                                 printf("+++Warning : IPv6 support "                                  printf("+++Warning : IPv6 support "
                                         "unavailable\n");                                          "unavailable\n");
                             }                              }
                               
                               liberation(s_etat_processus, s_objet_argument);
                               liberation(s_etat_processus, s_objet_resultat);
   
                               (*s_etat_processus).erreur_execution =
                                       d_ex_instruction_indisponible;
                               return;
 #                           endif  #                           endif
                         }                          }
                     }                      }
Line 5303  instruction_open(struct_processus *s_eta Line 5675  instruction_open(struct_processus *s_eta
                                         .socket_en_ecoute = 'N';                                          .socket_en_ecoute = 'N';
                             }                              }
   
                               free((*((struct_socket *) (*s_objet_resultat)
                                       .objet)).adresse);
   
                             if (((*((struct_socket *) (*s_objet_resultat)                              if (((*((struct_socket *) (*s_objet_resultat)
                                     .objet)).adresse = malloc(22 *                                      .objet)).adresse = malloc(23 *
                                     sizeof(unsigned char))) == NULL)                                      sizeof(unsigned char))) == NULL)
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
Line 5313  instruction_open(struct_processus *s_eta Line 5688  instruction_open(struct_processus *s_eta
                             }                              }
   
                             sprintf((*((struct_socket *) (*s_objet_resultat)                              sprintf((*((struct_socket *) (*s_objet_resultat)
                                     .objet)).adresse, "%d.%d.%d.%d",                                      .objet)).adresse, "%d.%d.%d.%d(%u)",
                                     (ntohl((*((struct sockaddr_in *)                                      (ntohl((*((struct sockaddr_in *)
                                     (*resolution_courante).ai_addr)).sin_addr                                      (*resolution_courante).ai_addr)).sin_addr
                                     .s_addr) >> 24) & 0xFF,                                      .s_addr) >> 24) & 0xFF,
Line 5325  instruction_open(struct_processus *s_eta Line 5700  instruction_open(struct_processus *s_eta
                                     .s_addr) >> 8) & 0xFF,                                      .s_addr) >> 8) & 0xFF,
                                     ntohl((*((struct sockaddr_in *)                                      ntohl((*((struct sockaddr_in *)
                                     (*resolution_courante).ai_addr)).sin_addr                                      (*resolution_courante).ai_addr)).sin_addr
                                     .s_addr) & 0xFF);                                      .s_addr) & 0xFF,
                                       (unsigned int) port);
                         }                          }
                         else                          else
                         { // Accès en IPv6                          { // Accès en IPv6
Line 5409  instruction_open(struct_processus *s_eta Line 5785  instruction_open(struct_processus *s_eta
                                         .socket_en_ecoute = 'N';                                          .socket_en_ecoute = 'N';
                             }                              }
   
                               free((*((struct_socket *) (*s_objet_resultat)
                                       .objet)).adresse);
   
                             if (((*((struct_socket *) (*s_objet_resultat)                              if (((*((struct_socket *) (*s_objet_resultat)
                                     .objet)).adresse = malloc(55 *                                      .objet)).adresse = malloc(47 *
                                     sizeof(unsigned char))) == NULL)                                      sizeof(unsigned char))) == NULL)
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
Line 5418  instruction_open(struct_processus *s_eta Line 5797  instruction_open(struct_processus *s_eta
                                 return;                                  return;
                             }                              }
   
                             for(i = 0; i < 16; i++)                              sprintf((*((struct_socket *) (*s_objet_resultat)
                             {                                      .objet)).adresse,
                                 sprintf((*((struct_socket *) (*s_objet_resultat)                                      "%02X%02X:%02X%02X:%02X%02X:%02X%02X:"
                                         .objet)).adresse,                                      "%02X%02X:%02X%02X:%02X%02X:%02X%02X(%u)",
                                         (i == 0) ? "%s%X" : "%s:%X",                                      (*((struct sockaddr_in6 *)
                                         (*((struct_socket *) (*s_objet_resultat)                                      (*resolution_courante).ai_addr)).sin6_addr
                                         .objet)).adresse,                                      .s6_addr[0],
                                         (*((struct sockaddr_in6 *)                                      (*((struct sockaddr_in6 *)
                                         (*resolution_courante).ai_addr))                                      (*resolution_courante).ai_addr)).sin6_addr
                                         .sin6_addr.s6_addr[i]);                                      .s6_addr[1],
                             }                                      (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[2],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[3],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[4],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[5],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[6],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[7],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[8],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[9],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[10],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[11],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[12],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[13],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[14],
                                       (*((struct sockaddr_in6 *)
                                       (*resolution_courante).ai_addr)).sin6_addr
                                       .s6_addr[15],
                                       (unsigned int) port);
 #                           else  #                           else
                             if ((*s_etat_processus).langue == 'F')                              if ((*s_etat_processus).langue == 'F')
                             {                              {
Line 5440  instruction_open(struct_processus *s_eta Line 5861  instruction_open(struct_processus *s_eta
                                 printf("+++Warning : IPv6 support "                                  printf("+++Warning : IPv6 support "
                                         "unavailable\n");                                          "unavailable\n");
                             }                              }
   
                               liberation(s_etat_processus, s_objet_argument);
                               liberation(s_etat_processus, s_objet_resultat);
   
                               freeaddrinfo(resolution);
   
                               (*s_etat_processus).erreur_execution =
                                       d_ex_instruction_indisponible;
                               return;
 #                           endif  #                           endif
                         }                          }
   
                         freeaddrinfo(resolution);                          freeaddrinfo(resolution);
   
                         sprintf((*((struct_socket *) (*s_objet_resultat)  
                                 .objet)).adresse, "%s(%u)",  
                                 (*((struct_socket *) (*s_objet_resultat)  
                                 .objet)).adresse, (unsigned int) port);  
                     }                      }
                     else                      else
                     { // Hôte défini par une adresse                      { // Hôte défini par une adresse
Line 5456  instruction_open(struct_processus *s_eta Line 5881  instruction_open(struct_processus *s_eta
                         { // Accès en IPv4                          { // Accès en IPv4
                             if (type_adresse == '4')                              if (type_adresse == '4')
                             {                              {
                                   free((*((struct_socket *) (*s_objet_resultat)
                                           .objet)).adresse);
   
                                 if (((*((struct_socket *) (*s_objet_resultat)                                  if (((*((struct_socket *) (*s_objet_resultat)
                                         .objet)).adresse = malloc(22 *                                          .objet)).adresse = malloc(23 *
                                         sizeof(unsigned char))) == NULL)                                          sizeof(unsigned char))) == NULL)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 5465  instruction_open(struct_processus *s_eta Line 5893  instruction_open(struct_processus *s_eta
                                     return;                                      return;
                                 }                                  }
   
                                 (*((struct_socket *) (*s_objet_resultat).objet))  
                                         .adresse[0] = d_code_fin_chaine;  
   
                                 for(i = 0; i < 4; i++)  
                                 {  
                                     sprintf((*((struct_socket *)  
                                             (*s_objet_resultat).objet)).adresse,  
                                             (i == 0) ? "%s%d" : "%s.%d",  
                                             (*((struct_socket *)  
                                             (*s_objet_resultat)  
                                             .objet)).adresse, (int) adresse[i]);  
                                 }  
   
                                 sprintf((*((struct_socket *) (*s_objet_resultat)                                  sprintf((*((struct_socket *) (*s_objet_resultat)
                                         .objet)).adresse, "%s(%u)",                                          .objet)).adresse, "%d.%d.%d.%d(%u)",
                                         (*((struct_socket *) (*s_objet_resultat)                                          (int) adresse[0], (int) adresse[1],
                                         .objet)).adresse, (unsigned int) port);                                          (int) adresse[2], (int) adresse[3],
                                           (unsigned int) port);
                             }                              }
                             else                              else
                             {                              {
                                   free((*((struct_socket *) (*s_objet_resultat)
                                           .objet)).adresse);
   
                                 if (((*((struct_socket *) (*s_objet_resultat)                                  if (((*((struct_socket *) (*s_objet_resultat)
                                         .objet)).adresse = malloc(                                          .objet)).adresse = malloc(
                                         sizeof(unsigned char))) == NULL)                                          sizeof(unsigned char))) == NULL)
Line 5520  instruction_open(struct_processus *s_eta Line 5939  instruction_open(struct_processus *s_eta
   
                             adresse_ipv4 = 0;                              adresse_ipv4 = 0;
                             for(i = 0; i < 4; adresse_ipv4 =                              for(i = 0; i < 4; adresse_ipv4 =
                                     (256 * adresse_ipv4) + adresse[i++]);                                      (256 * adresse_ipv4)
                                       + ((unsigned char) adresse[i++]));
   
                             socket_ipv4.sin_addr.s_addr = htonl(adresse_ipv4);                              socket_ipv4.sin_addr.s_addr = htonl(adresse_ipv4);
   
Line 5552  instruction_open(struct_processus *s_eta Line 5972  instruction_open(struct_processus *s_eta
 #                           ifdef IPV6  #                           ifdef IPV6
                             if (type_adresse == '6')                              if (type_adresse == '6')
                             {                              {
                                   free((*((struct_socket *) (*s_objet_resultat)
                                           .objet)).adresse);
   
                                 if (((*((struct_socket *) (*s_objet_resultat)                                  if (((*((struct_socket *) (*s_objet_resultat)
                                         .objet)).adresse = malloc(55 *                                          .objet)).adresse = malloc(47 *
                                         sizeof(unsigned char))) == NULL)                                          sizeof(unsigned char))) == NULL)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 5561  instruction_open(struct_processus *s_eta Line 5984  instruction_open(struct_processus *s_eta
                                     return;                                      return;
                                 }                                  }
   
                                 (*((struct_socket *) (*s_objet_resultat).objet))  
                                         .adresse[0] = d_code_fin_chaine;  
   
                                 for(i = 0; i < 16; i++)  
                                 {  
                                     sprintf((*((struct_socket *)  
                                             (*s_objet_resultat).objet)).adresse,  
                                             (i == 0) ? "%s%X" : "%s:%X",  
                                             (*((struct_socket *)  
                                             (*s_objet_resultat)  
                                             .objet)).adresse, (unsigned int)  
                                             adresse[i]);  
                                 }  
   
                                 sprintf((*((struct_socket *) (*s_objet_resultat)                                  sprintf((*((struct_socket *) (*s_objet_resultat)
                                         .objet)).adresse, "%s(%u)",                                          .objet)).adresse,
                                         (*((struct_socket *) (*s_objet_resultat)                                          "%02X%02X:%02X%02X:%02X%02X:%02X%02X:"
                                         .objet)).adresse, (unsigned int) port);                                          "%02X%02X:%02X%02X:%02X%02X:%02X%02X"
                                           "(%u)",
                                           (unsigned int) adresse[0],
                                           (unsigned int) adresse[1],
                                           (unsigned int) adresse[2],
                                           (unsigned int) adresse[3],
                                           (unsigned int) adresse[4],
                                           (unsigned int) adresse[5],
                                           (unsigned int) adresse[6],
                                           (unsigned int) adresse[7],
                                           (unsigned int) adresse[8],
                                           (unsigned int) adresse[9],
                                           (unsigned int) adresse[10],
                                           (unsigned int) adresse[11],
                                           (unsigned int) adresse[12],
                                           (unsigned int) adresse[13],
                                           (unsigned int) adresse[14],
                                           (unsigned int) adresse[15],
                                           (unsigned int) port);
                             }                              }
                             else                              else
                             {                              {
                                   free((*((struct_socket *) (*s_objet_resultat)
                                           .objet)).adresse);
   
                                 if (((*((struct_socket *) (*s_objet_resultat)                                  if (((*((struct_socket *) (*s_objet_resultat)
                                         .objet)).adresse = malloc(                                          .objet)).adresse = malloc(
                                         sizeof(unsigned char))) == NULL)                                          sizeof(unsigned char))) == NULL)
Line 5652  instruction_open(struct_processus *s_eta Line 6082  instruction_open(struct_processus *s_eta
                                 printf("+++Warning : IPv6 support "                                  printf("+++Warning : IPv6 support "
                                         "unavailable\n");                                          "unavailable\n");
                             }                              }
   
                               liberation(s_etat_processus, s_objet_argument);
                               liberation(s_etat_processus, s_objet_resultat);
   
                               (*s_etat_processus).erreur_execution =
                                       d_ex_instruction_indisponible;
                               return;
 #                           endif  #                           endif
                         }                          }
                         else                          else
                         { // Socket UNIX                          { // Socket UNIX
                               free((*((struct_socket *) (*s_objet_resultat)
                                       .objet)).adresse);
   
                             if (((*((struct_socket *) (*s_objet_resultat)                              if (((*((struct_socket *) (*s_objet_resultat)
                                     .objet)).adresse = malloc(                                      .objet)).adresse = malloc(
                                     sizeof(unsigned char))) == NULL)                                      sizeof(unsigned char))) == NULL)
Removed from v.1.46  
changed lines
  Added in v.1.94

CVSweb interface <joel.bertrand@systella.fr>