[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.81 and 1.82

version 1.81, 2015/02/19 11:01:25 version 1.82, 2015/06/08 07:15:31
Line 869  instruction_or(struct_processus *s_etat_ Line 869  instruction_or(struct_processus *s_etat_
 ================================================================================  ================================================================================
 */  */
   
   
   #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
   
   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);
               }
   #       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);
           }
       }
   
       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);
           }
       }
   
       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);
               }
   #       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);
           }
       }
   
       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);
               }
   #       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);
           }
       }
   
       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);
               }
   #       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);
           }
       }
   
       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);
           }
       }
   
       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);
           }
       }
   
       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 1102  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                         prochain_descripteur;
     int                         protocole_numerique;      int                         protocole_numerique;
Line 976  instruction_open(struct_processus *s_eta Line 1172  instruction_open(struct_processus *s_eta
     unsigned long               nombre_elements;      unsigned long               nombre_elements;
     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 1140  instruction_open(struct_processus *s_eta Line 1323  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 4382  instruction_open(struct_processus *s_eta Line 4564  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, (socklen_t) 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 4915  instruction_open(struct_processus *s_eta Line 4880  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 5019  instruction_open(struct_processus *s_eta Line 4987  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 5126  instruction_open(struct_processus *s_eta Line 5099  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 5262  instruction_open(struct_processus *s_eta Line 5240  instruction_open(struct_processus *s_eta
   
                             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 5339  instruction_open(struct_processus *s_eta Line 5322  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);
Removed from v.1.81  
changed lines
  Added in v.1.82

CVSweb interface <joel.bertrand@systella.fr>