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

Diff for /rpl/src/instructions_r4.c between versions 1.9 and 1.43

version 1.9, 2010/03/09 09:19:49 version 1.43, 2011/09/20 09:51:42
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.12    RPL/2 (R) version 4.1.3
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2011 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 20 Line 20
 */  */
   
   
 #include "rpl.conv.h"  #include "rpl-conv.h"
   
   
 /*  /*
Line 848  instruction_read(struct_processus *s_eta Line 848  instruction_read(struct_processus *s_eta
 {  {
     const char                      *queue;      const char                      *queue;
   
       int                             c;
     int                             ios;      int                             ios;
   
     integer8                        element;      integer8                        element;
Line 858  instruction_read(struct_processus *s_eta Line 859  instruction_read(struct_processus *s_eta
     logical1                        presence_chaine;      logical1                        presence_chaine;
     logical1                        presence_indicateur;      logical1                        presence_indicateur;
   
       long                            i;
     long                            longueur_effective;      long                            longueur_effective;
     long                            longueur_enregistrement;      long                            longueur_enregistrement;
     long                            longueur_questure;      long                            longueur_questure;
Line 874  instruction_read(struct_processus *s_eta Line 876  instruction_read(struct_processus *s_eta
   
     struct sockaddr_un              adresse_unix;      struct sockaddr_un              adresse_unix;
     struct sockaddr_in              adresse_ipv4;      struct sockaddr_in              adresse_ipv4;
   #   ifdef IPV6
     struct sockaddr_in6             adresse_ipv6;      struct sockaddr_in6             adresse_ipv6;
   #   endif
   
     struct timespec                 attente;      struct timespec                 attente;
   
Line 892  instruction_read(struct_processus *s_eta Line 896  instruction_read(struct_processus *s_eta
     unsigned char                   caractere;      unsigned char                   caractere;
     unsigned char                   *clef_utf8;      unsigned char                   *clef_utf8;
     unsigned char                   *commande;      unsigned char                   *commande;
       unsigned char                   *ptr;
     unsigned char                   *tampon_lecture;      unsigned char                   *tampon_lecture;
     unsigned char                   *tampon;      unsigned char                   *tampon;
     unsigned char                   *tampon2;      unsigned char                   *tampon2;
   
     unsigned long                   i;  
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
     attente.tv_sec = 0;  
     attente.tv_nsec = GRANULARITE_us * 1000;  
   
     if ((*s_etat_processus).affichage_arguments == 'Y')      if ((*s_etat_processus).affichage_arguments == 'Y')
     {      {
         printf("\n  READ ");          printf("\n  READ ");
Line 1863  instruction_read(struct_processus *s_eta Line 1863  instruction_read(struct_processus *s_eta
             /*              /*
              * Fichiers de type FLOW               * Fichiers de type FLOW
              */               */
   
               if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
                       == 'S')
               {
                   /*
                    * Fichiers séquentiels
                    */
   
                   BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
                   longueur_enregistrement = 0;
   
                   if ((position_initiale = ftell((*descripteur).descripteur_c))
                           == -1)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   do
                   {
                       c = getc((*descripteur).descripteur_c);
                       longueur_enregistrement++;
                   } while((c != '\n') && (c != EOF));
   
                   if (fseek((*descripteur).descripteur_c, position_initiale,
                           SEEK_SET) != 0)
                   {
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   if ((tampon_lecture = malloc((longueur_enregistrement + 1)
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   longueur_effective = fread(tampon_lecture,
                           (size_t) sizeof(unsigned char),
                           (size_t) longueur_enregistrement,
                           (*descripteur).descripteur_c);
   
                   if ((s_objet_resultat = allocation(s_etat_processus, LST))
                           == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if (((*s_objet_resultat).objet =
                           allocation_maillon(s_etat_processus)) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   (*((struct_liste_chainee *) (*s_objet_resultat).objet))
                           .suivant = NULL;
   
                   if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
                           .donnee = allocation(s_etat_processus, CHN)) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   longueur_enregistrement = 1;
   
                   for(i = 0; i < longueur_effective; i++)
                   {
                       if (isprint(tampon_lecture[i]) != 0)
                       {
                           longueur_enregistrement += 4;
                       }
                       else
                       {
                           longueur_enregistrement++;
                       }
                   }
   
                   if ((tampon = malloc(longueur_enregistrement *
                           sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   ptr = tampon;
   
                   for(i = 0; i < longueur_effective; i++)
                   {
                       if (isprint(tampon_lecture[i]) != 0)
                       {
                           (*ptr) = tampon_lecture[i];
                           ptr++;
                       }
                       else
                       {
                           (*ptr) = '\\';
                           ptr++;
                           (*ptr) = 'x';
                           ptr++;
                           sprintf(ptr, "%02X", tampon_lecture[i]);
                           ptr += 2;
                       }
                   }
   
                   (*ptr) = d_code_fin_chaine;
                   free(tampon_lecture);
                   ((*(*((struct_liste_chainee *) (*s_objet_resultat).objet))
                           .donnee)).objet = tampon;
   
                   if (empilement(s_etat_processus,
                           &((*s_etat_processus).l_base_pile),
                           s_objet_resultat) == d_erreur)
                   {
                       return;
                   }
               }
               else
               {
                   liberation(s_etat_processus, s_objet_argument_1);
   
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_type_fichier;
                   return;
               }
         }          }
     }      }
     else if ((*s_objet_argument_1).type == SCK)       else if ((*s_objet_argument_1).type == SCK) 
Line 1919  instruction_read(struct_processus *s_eta Line 2054  instruction_read(struct_processus *s_eta
                     return;                      return;
                 }                  }
   
                   attente.tv_sec = 0;
                   attente.tv_nsec = GRANULARITE_us * 1000;
   
                 for(;;)                  for(;;)
                 {                  {
                     if ((*((struct_socket *) (*s_objet_argument_1).objet))                      if ((*((struct_socket *) (*s_objet_argument_1).objet))
Line 1944  instruction_read(struct_processus *s_eta Line 2082  instruction_read(struct_processus *s_eta
                     else if ((*((struct_socket *) (*s_objet_argument_1).objet))                      else if ((*((struct_socket *) (*s_objet_argument_1).objet))
                             .domaine == PF_INET6)                              .domaine == PF_INET6)
                     {                      {
   #                       ifdef IPV6
                         longueur_adresse = sizeof(adresse_ipv6);                          longueur_adresse = sizeof(adresse_ipv6);
                         longueur_effective = recvfrom((*((struct_socket *)                          longueur_effective = recvfrom((*((struct_socket *)
                                 (*s_objet_argument_1).objet)).socket,                                  (*s_objet_argument_1).objet)).socket,
                                 tampon_lecture, longueur_questure,                                  tampon_lecture, longueur_questure,
                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)                                  MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                 &adresse_ipv6, &longueur_adresse);                                  &adresse_ipv6, &longueur_adresse);
   
   #                       else
                           if ((*s_etat_processus).langue == 'F')
                           {
                               printf("+++Attention : Support du protocole"
                                       " IPv6 indisponible\n");
                           }
                           else
                           {
                               printf("+++Warning : IPv6 support "
                                       "unavailable\n");
                           }
   #                       endif
                     }                      }
                     else                      else
                     {                      {
Line 1957  instruction_read(struct_processus *s_eta Line 2109  instruction_read(struct_processus *s_eta
                         liberation(s_etat_processus, s_objet_argument_1);                          liberation(s_etat_processus, s_objet_argument_1);
   
                         while(sem_wait(&((*s_etat_processus)                          while(sem_wait(&((*s_etat_processus)
                                 .semaphore_fork)) == -1)                                  .semaphore_fork)) != 0)
                         {                          {
                             if (errno != EINTR)                              (*s_etat_processus).erreur_systeme =
                             {                                      d_es_processus;
                                 (*s_etat_processus).erreur_systeme =  
                                         d_es_processus;  
                                 return;  
                             }  
                         }                          }
   
                         (*s_etat_processus).erreur_execution =                          (*s_etat_processus).erreur_execution =
Line 1975  instruction_read(struct_processus *s_eta Line 2123  instruction_read(struct_processus *s_eta
                     if (longueur_effective < 0)                      if (longueur_effective < 0)
                     {                      {
                         nanosleep(&attente, NULL);                          nanosleep(&attente, NULL);
                           INCR_GRANULARITE(attente.tv_nsec);
                         scrutation_injection(s_etat_processus);                          scrutation_injection(s_etat_processus);
                     }                      }
   
                       // Une donnée a été reçue.
   
                     if (((*s_etat_processus).var_volatile_requete_arret == -1)                      if (((*s_etat_processus).var_volatile_requete_arret == -1)
                             || (longueur_effective >= 0))                              || (longueur_effective >= 0))
                     {                      {
Line 1985  instruction_read(struct_processus *s_eta Line 2136  instruction_read(struct_processus *s_eta
                     }                      }
                 }                  }
   
                 while(sem_wait(&((*s_etat_processus).semaphore_fork))                  while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
                         == -1)  
                 {                  {
                     if (errno != EINTR)                      if (errno = EINTR)
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es_processus;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
Line 2186  instruction_read(struct_processus *s_eta Line 2336  instruction_read(struct_processus *s_eta
                 longueur_adresse = 0;                  longueur_adresse = 0;
                 recvfrom((*((struct_socket *)                  recvfrom((*((struct_socket *)
                         (*s_objet_argument_1).objet)).socket, tampon_lecture,                          (*s_objet_argument_1).objet)).socket, tampon_lecture,
                           longueur_effective, MSG_DONTWAIT,
                           NULL, &longueur_adresse);
   
                   (*s_objet_adresse).objet = NULL;
               }
               else if ((*((struct_socket *) (*s_objet_argument_1).objet))
                       .domaine == PF_INET)
               {
                   longueur_adresse = sizeof(adresse_ipv4);
                   recvfrom((*((struct_socket *)
                           (*s_objet_argument_1).objet)).socket, tampon_lecture,
                           longueur_effective, MSG_DONTWAIT,
                           (struct sockaddr *) &adresse_ipv4, &longueur_adresse);
   
                   if (((*s_objet_adresse).objet =
                           allocation_maillon(s_etat_processus)) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
                           .donnee = allocation(s_etat_processus, VIN)) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   (*((struct_vecteur *) (*(*((struct_liste_chainee *)
                           (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
   
                   if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
                           (*s_objet_adresse).objet)).donnee).objet)).tableau =
                           malloc(4 * sizeof(integer8))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   ((integer8 *) (*((struct_vecteur *)
                           (*(*((struct_liste_chainee *) (*s_objet_adresse)
                           .objet)).donnee).objet)).tableau)[0] =
                           (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
                   ((integer8 *) (*((struct_vecteur *)
                           (*(*((struct_liste_chainee *) (*s_objet_adresse)
                           .objet)).donnee).objet)).tableau)[1] =
                           (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
                   ((integer8 *) (*((struct_vecteur *)
                           (*(*((struct_liste_chainee *) (*s_objet_adresse)
                           .objet)).donnee).objet)).tableau)[2] =
                           (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
                   ((integer8 *) (*((struct_vecteur *)
                           (*(*((struct_liste_chainee *) (*s_objet_adresse)
                           .objet)).donnee).objet)).tableau)[3] =
                           ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
   
                   if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
                           .suivant = allocation_maillon(s_etat_processus))
                           == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
                           .suivant).donnee = allocation(s_etat_processus, INT))
                           == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   (*((integer8 *) (*(*(*((struct_liste_chainee *)
                           (*s_objet_adresse).objet)).suivant).donnee).objet)) =
                           (integer8) ntohs(adresse_ipv4.sin_port);
   
                   (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
                           .suivant).suivant = NULL;
               }
               else if ((*((struct_socket *) (*s_objet_argument_1).objet))
                       .domaine == PF_INET6)
               {
   #               ifdef IPV6
                   longueur_adresse = sizeof(adresse_ipv6);
                   recvfrom((*((struct_socket *)
                           (*s_objet_argument_1).objet)).socket, tampon_lecture,
                           longueur_effective, MSG_DONTWAIT,
                           (struct sockaddr *) &adresse_ipv6, &longueur_adresse);
   
                   if (((*s_objet_adresse).objet =
                           allocation_maillon(s_etat_processus)) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
                           .donnee = allocation(s_etat_processus, VIN)) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   (*((struct_vecteur *) (*(*((struct_liste_chainee *)
                           (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
   
                   if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
                           (*s_objet_adresse).objet)).donnee).objet)).tableau =
                           malloc(16 * sizeof(integer8))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   for(i = 0; i < 16; i++)
                   {
                       ((integer8 *) (*((struct_vecteur *)
                               (*(*((struct_liste_chainee *) (*s_objet_adresse)
                               .objet)).donnee).objet)).tableau)[0] =
                               adresse_ipv6.sin6_addr.s6_addr[i];
                   }
   
                   if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
                           .suivant = allocation_maillon(s_etat_processus))
                           == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
                           .suivant).donnee = allocation(s_etat_processus, INT))
                           == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   (*((integer8 *) (*(*(*((struct_liste_chainee *)
                           (*s_objet_adresse).objet)).suivant).donnee).objet)) =
                           (integer8) ntohs(adresse_ipv6.sin6_port);
   
                   (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
                           .suivant).suivant = NULL;
   #               else
                   if ((*s_etat_processus).langue == 'F')
                   {
                       printf("+++Attention : Support du protocole"
                               " IPv6 indisponible\n");
                   }
                   else
                   {
                       printf("+++Warning : IPv6 support "
                               "unavailable\n");
                   }
   #               endif
               }
               else
               {
                   longueur_adresse = 0;
                   recvfrom((*((struct_socket *)
                           (*s_objet_argument_1).objet)).socket, tampon_lecture,
                           position_finale, MSG_DONTWAIT,
                           NULL, &longueur_adresse);
               }
   
               free(tampon_lecture);
   
               if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                       s_objet_resultat) == d_erreur)
               {
                   return;
               }
           }
           else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire
                   == 'Y')
           { // UNFORMATTED
           }
           else
           { // FLOW
               longueur_questure = 256;
   
               do
               {
                   if ((tampon_lecture = malloc((longueur_questure + 1) *
                           sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_processus;
                       return;
                   }
   
                   attente.tv_sec = 0;
                   attente.tv_nsec = GRANULARITE_us * 1000;
   
                   for(;;)
                   {
                       if ((*((struct_socket *) (*s_objet_argument_1).objet))
                               .domaine == PF_UNIX)
                       {
                           longueur_adresse = sizeof(adresse_unix);
                           longueur_effective = recvfrom((*((struct_socket *)
                                   (*s_objet_argument_1).objet)).socket,
                                   tampon_lecture, longueur_questure,
                                   MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                   &adresse_unix, &longueur_adresse);
                       }
                       else if ((*((struct_socket *) (*s_objet_argument_1).objet))
                               .domaine == PF_INET)
                       {
                           longueur_adresse = sizeof(adresse_ipv4);
                           longueur_effective = recvfrom((*((struct_socket *)
                                   (*s_objet_argument_1).objet)).socket,
                                   tampon_lecture, longueur_questure,
                                   MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                   &adresse_ipv4, &longueur_adresse);
                       }
                       else if ((*((struct_socket *) (*s_objet_argument_1).objet))
                               .domaine == PF_INET6)
                       {
   #                       ifdef IPV6
                           longueur_adresse = sizeof(adresse_ipv6);
                           longueur_effective = recvfrom((*((struct_socket *)
                                   (*s_objet_argument_1).objet)).socket,
                                   tampon_lecture, longueur_questure,
                                   MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                   &adresse_ipv6, &longueur_adresse);
   #                       else
                           if ((*s_etat_processus).langue == 'F')
                           {
                               printf("+++Attention : Support du protocole"
                                       " IPv6 indisponible\n");
                           }
                           else
                           {
                               printf("+++Warning : IPv6 support "
                                       "unavailable\n");
                           }
   #                       endif
                       }
                       else
                       {
                           free(tampon_lecture);
                           liberation(s_etat_processus, s_objet_argument_1);
   
                           while(sem_wait(&((*s_etat_processus)
                                   .semaphore_fork)) != 0)
                           {
                               if (errno != EINTR)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_processus;
                                   return;
                               }
                           }
   
                           (*s_etat_processus).erreur_execution =
                                   d_ex_erreur_acces_fichier;
                           return;
                       }
   
                       if (longueur_effective < 0)
                       {
                           nanosleep(&attente, NULL);
                           INCR_GRANULARITE(attente.tv_nsec);
                           scrutation_injection(s_etat_processus);
                       }
   
                       if (((*s_etat_processus).var_volatile_requete_arret == -1)
                               || (longueur_effective >= 0))
                       {
                           break;
                       }
                   }
   
                   while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
                   {
                       if (errno != EINTR)
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
                   }
   
                   if ((*s_etat_processus).var_volatile_requete_arret == -1)
                   {
   
                       /*
                        * Si le père tue le processus courant grâce au signal
                        * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
                        * correspond à l'utilisation de STOP sur le processus
                        * en cours. La variable longueur_effective vaut '-1'.
                        */
   
                       free(tampon_lecture);
                       liberation(s_etat_processus, s_objet_argument_1);
                       return;
                   }
   
                   if (longueur_effective == -1)
                   {
                       free(tampon_lecture);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_acces_fichier;
                       return;
                   }
   
                   if (longueur_effective == longueur_questure)
                   {
                       free(tampon_lecture);
                       longueur_questure *= 2;
                   }
               } while(longueur_effective == longueur_questure);
   
               longueur_enregistrement = 1;
   
               for(i = 0; i < longueur_effective; i++)
               {
                   if (isprint(tampon_lecture[i]) != 0)
                   {
                       longueur_enregistrement += 4;
                   }
                   else
                   {
                       longueur_enregistrement++;
                   }
               }
   
               /*
                * Création de la liste de sortie
                */
   
               if ((s_objet_type = allocation(s_etat_processus, CHN)) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               if (((*s_objet_type).objet = malloc(longueur_enregistrement *
                       sizeof(unsigned char))) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               ptr = (*s_objet_type).objet;
   
               for(i = 0; i < longueur_effective; i++)
               {
                   if (isprint(tampon_lecture[i]) != 0)
                   {
                       (*ptr) = tampon_lecture[i];
                       ptr++;
                   }
                   else
                   {
                       (*ptr) = '\\';
                       ptr++;
                       (*ptr) = 'x';
                       ptr++;
                       sprintf(ptr, "%02X", tampon_lecture[i]);
                       ptr += 2;
                   }
               }
   
               (*ptr) = d_code_fin_chaine;
   
               if ((s_objet_resultat = allocation(s_etat_processus, LST))
                       == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               if (((*s_objet_resultat).objet =
                       allocation_maillon(s_etat_processus)) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               (*((struct_liste_chainee *) (*s_objet_resultat).objet))
                       .donnee = s_objet_type;
   
               if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
                       .suivant = allocation_maillon(s_etat_processus)) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
                       .suivant = NULL;
   
               if ((s_objet_adresse = allocation(s_etat_processus, LST))
                       == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
                       .donnee = s_objet_adresse;
   
               /*
                * Les informations concernant la cible sont valides si
                * la socket est non connectée et que les domaines sont
                * INET ou INET6.
                * Dans tous les autres cas, on renvoie une liste vide.
                */
   
               if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
                       == PF_UNIX) || (strcmp((*((struct_socket *)
                       (*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
                       (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
                       .type, "SEQUENTIAL DATAGRAM") == 0))
               {
                   // POSITION_FINALE peut être utilisée sans être initialisée !
                   // virer position_finale pour longueur_effective
                   longueur_adresse = 0;
                   recvfrom((*((struct_socket *)
                           (*s_objet_argument_1).objet)).socket, tampon_lecture,
                         position_finale, MSG_DONTWAIT,                          position_finale, MSG_DONTWAIT,
                         NULL, &longueur_adresse);                          NULL, &longueur_adresse);
   
Line 2273  instruction_read(struct_processus *s_eta Line 2863  instruction_read(struct_processus *s_eta
             else if ((*((struct_socket *) (*s_objet_argument_1).objet))              else if ((*((struct_socket *) (*s_objet_argument_1).objet))
                     .domaine == PF_INET6)                      .domaine == PF_INET6)
             {              {
   #               ifdef IPV6
                 longueur_adresse = sizeof(adresse_ipv6);                  longueur_adresse = sizeof(adresse_ipv6);
                 recvfrom((*((struct_socket *)                  recvfrom((*((struct_socket *)
                         (*s_objet_argument_1).objet)).socket, tampon_lecture,                          (*s_objet_argument_1).objet)).socket, tampon_lecture,
Line 2339  instruction_read(struct_processus *s_eta Line 2930  instruction_read(struct_processus *s_eta
   
                 (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))                  (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
                         .suivant).suivant = NULL;                          .suivant).suivant = NULL;
   #               else
                   if ((*s_etat_processus).langue == 'F')
                   {
                       printf("+++Attention : Support du protocole"
                               " IPv6 indisponible\n");
                   }
                   else
                   {
                       printf("+++Warning : IPv6 support "
                               "unavailable\n");
                   }
   #               endif
             }              }
             else              else
             {              {
Line 2357  instruction_read(struct_processus *s_eta Line 2960  instruction_read(struct_processus *s_eta
                 return;                  return;
             }              }
         }          }
         else  
         {  
             /* FLOW ou UNFORMATTED */  
         }  
     }      }
     else      else
     {      {
Removed from v.1.9  
changed lines
  Added in v.1.43

CVSweb interface <joel.bertrand@systella.fr>