[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.76 and 1.89

version 1.76, 2013/03/20 22:24:37 version 1.89, 2014/07/17 08:07:23
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.13    RPL/2 (R) version 4.1.19
   Copyright (C) 1989-2013 Dr. BERTRAND Joël    Copyright (C) 1989-2014 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 850  instruction_read(struct_processus *s_eta Line 850  instruction_read(struct_processus *s_eta
   
     int                             c;      int                             c;
     int                             ios;      int                             ios;
       int                             timeout;
   
     integer8                        element;      integer8                        element;
     integer8                        i;      integer8                        i;
     integer8                        id;      integer8                        id;
       integer8                        index;
       integer8                        longueur;
     integer8                        position_clef;      integer8                        position_clef;
   
     integer8                        longueur_effective;      integer8                        longueur_effective;
     integer8                        longueur_enregistrement;      integer8                        longueur_enregistrement;
     integer8                        longueur_questure;      integer8                        longueur_questure;
Line 863  instruction_read(struct_processus *s_eta Line 867  instruction_read(struct_processus *s_eta
     integer8                        position_finale;      integer8                        position_finale;
     integer8                        position_initiale;      integer8                        position_initiale;
   
       logical1                        device;
     logical1                        format_degenere;      logical1                        format_degenere;
     logical1                        indicateur_48;      logical1                        indicateur_48;
     logical1                        presence_chaine;      logical1                        presence_chaine;
     logical1                        presence_indicateur;      logical1                        presence_indicateur;
     logical1                        trame_complete;      logical1                        trame_complete;
   
     long                            longueur;  
   
     socklen_t                       longueur_adresse;      socklen_t                       longueur_adresse;
   
     sqlite3_stmt                    *ppStmt;      sqlite3_stmt                    *ppStmt;
   
     struct flock                    lock;      struct flock                    lock;
   
       struct pollfd                   fds[1];
   
     struct sockaddr_un              adresse_unix;      struct sockaddr_un              adresse_unix;
     struct sockaddr_in              adresse_ipv4;      struct sockaddr_in              adresse_ipv4;
 #   ifdef IPV6  #   ifdef IPV6
     struct sockaddr_in6             adresse_ipv6;      struct sockaddr_in6             adresse_ipv6;
 #   endif  #   endif
   
     struct pollfd                   poll_fd;      struct termios                  tc;
   
     struct timespec                 attente;      struct timespec                 attente;
   
Line 907  instruction_read(struct_processus *s_eta Line 912  instruction_read(struct_processus *s_eta
     unsigned char                   *tampon_lecture;      unsigned char                   *tampon_lecture;
     unsigned char                   *tampon;      unsigned char                   *tampon;
     unsigned char                   *tampon2;      unsigned char                   *tampon2;
       unsigned char                   *tampon3;
   
       int                             vitesses[] =
                           {
                               50, 75, 110, 134, 150, 200, 300, 600,
                               1200, 1800, 2400, 4800, 9600, 19200, 38400,
   #ifdef B57600
                               57600,
   #endif
   #ifdef B115200
                               115200,
   #endif
   #ifdef B230400
                               230400,
   #endif
                               0
                           };
   
       tcflag_t                        vitesses_constantes[] =
                           {
                               B50, B75, B110, B134, B150, B200, B300, B600,
                               B1200, B1800, B2400, B4800, B9600, B19200, B38400,
   #ifdef B57600
                               B57600,
   #endif
   #ifdef B115200
                               B115200,
   #endif
   #ifdef B230400
                               B230400,
   #endif
                               0
                           };
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 1111  instruction_read(struct_processus *s_eta Line 1149  instruction_read(struct_processus *s_eta
                 presence_chaine = d_faux;                  presence_chaine = d_faux;
                 niveau = 1;                  niveau = 1;
   
                 if (fseek((*descripteur).descripteur_c, position_finale,                  if (fseek((*descripteur).descripteur_c, (long) position_finale,
                         SEEK_SET) != 0)                          SEEK_SET) != 0)
                 {                  {
                     liberation(s_etat_processus, s_objet_argument_1);                      liberation(s_etat_processus, s_objet_argument_1);
Line 1201  instruction_read(struct_processus *s_eta Line 1239  instruction_read(struct_processus *s_eta
                     return;                      return;
                 }                  }
   
                 if (fseek((*descripteur).descripteur_c, position_initiale,                  if (fseek((*descripteur).descripteur_c,
                         SEEK_SET) != 0)                          (long) position_initiale, SEEK_SET) != 0)
                 {                  {
                     liberation(s_etat_processus, s_objet_argument_1);                      liberation(s_etat_processus, s_objet_argument_1);
                     free(tampon_lecture);                      free(tampon_lecture);
Line 1976  instruction_read(struct_processus *s_eta Line 2014  instruction_read(struct_processus *s_eta
                 BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));                  BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
                 longueur_enregistrement = 0;                  longueur_enregistrement = 0;
   
                   device = d_faux;
   
                 if ((position_initiale = ftell((*descripteur).descripteur_c))                  if ((position_initiale = ftell((*descripteur).descripteur_c))
                         == -1)                          == -1)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      if (errno == ESPIPE)
                     return;                      {
                           device = d_vrai;
                       }
                       else
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                           return;
                       }
                 }                  }
   
                 l_element_courant_format = (struct_liste_chainee *)                  l_element_courant_format = (struct_liste_chainee *)
Line 2052  instruction_read(struct_processus *s_eta Line 2100  instruction_read(struct_processus *s_eta
                         // Détermination de la longueur                          // Détermination de la longueur
                         format_degenere = d_faux;                          format_degenere = d_faux;
   
                         if (sscanf(&(format_chaine[8]), "%ld", &longueur) != 1)                          if (sscanf(&(format_chaine[8]), "%lld", &longueur) != 1)
                         {                          {
                             liberation(s_etat_processus, s_objet_argument_1);                              liberation(s_etat_processus, s_objet_argument_1);
                             liberation(s_etat_processus, s_objet_resultat);                              liberation(s_etat_processus, s_objet_resultat);
Line 2065  instruction_read(struct_processus *s_eta Line 2113  instruction_read(struct_processus *s_eta
                     }                      }
   
                     free(format_chaine);                      free(format_chaine);
                       tampon3 = NULL;
   
                     if (format_degenere == d_vrai)                      if (format_degenere == d_vrai)
                     {                      {
                           if (device == d_vrai)
                           {
                               longueur_questure = 4096;
                               index = 0;
   
                               if ((tampon3 = malloc(((size_t) longueur_questure) *
                                       sizeof(unsigned char))) == NULL)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_allocation_memoire;
                                   return;
                               }
   
                               tampon3[index] = d_code_fin_chaine;
   
                               fds[0].fd = fileno((*descripteur).descripteur_c);
                               fds[0].events = POLLIN;
                               fds[0].revents = 0;
   
                               tcgetattr(fileno((*descripteur).descripteur_c),
                                       &tc);
                               timeout = 0;
   
                               for(i = 0; vitesses[i] != 0; i++)
                               {
                                   if (cfgetispeed(&tc) == vitesses_constantes[i])
                                   {
                                       // La durée entre deux caractères sur le
                                       // périphérique série ne doit pas dépasser
                                       // la moitié de la durée de transmission
                                       // d'un caractère complet.
   
                                       timeout = (int) (((double) 1000) /
                                               (((double) vitesses_constantes[i]) /
                                               4));
                                       break;
                                   }
                               }
                           }
   
                         do                          do
                         {                          {
                               if (device == d_vrai)
                               {
                                   if (poll(fds, 1, timeout) == 0)
                                   {
                                       break;
                                   }
                               }
   
                             c = getc((*descripteur).descripteur_c);                              c = getc((*descripteur).descripteur_c);
                             longueur_enregistrement++;                              longueur_enregistrement++;
                         } while((c != '\n') && (c != EOF));  
   
                         if (fseek((*descripteur).descripteur_c,                              if (device == d_vrai)
                                 position_initiale, SEEK_SET) != 0)                              {
                                   if (longueur_enregistrement >=
                                           longueur_questure)
                                   {
                                       if ((tampon3 = realloc(tampon3,
                                               (size_t) (longueur_questure *= 2)))
                                               == NULL)
                                       {
                                           (*s_etat_processus).erreur_systeme =
                                                   d_es_allocation_memoire;
                                           return;
                                       }
                                   }
   
                                   tampon3[index++] = (unsigned char) c;
                               }
                           } while(c != EOF);
   
                           if (device == d_faux)
                         {                          {
                             liberation(s_etat_processus, s_objet_argument_1);                              if (fseek((*descripteur).descripteur_c,
                             liberation(s_etat_processus, s_objet_resultat);                                      (long) position_initiale, SEEK_SET) != 0)
                               {
                                   liberation(s_etat_processus,
                                           s_objet_argument_1);
                                   liberation(s_etat_processus, s_objet_resultat);
   
                             (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                     d_es_erreur_fichier;                                          d_es_erreur_fichier;
                             return;                                  return;
                               }
                         }                          }
                     }                      }
                     else                      else
Line 2090  instruction_read(struct_processus *s_eta Line 2209  instruction_read(struct_processus *s_eta
                         longueur_enregistrement = longueur;                          longueur_enregistrement = longueur;
                     }                      }
   
                     if ((tampon_lecture = malloc(((size_t)                      if ((device == d_vrai) && (format_degenere == d_vrai))
                             longueur_enregistrement) * sizeof(unsigned char)))  
                             == NULL)  
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          longueur_effective = longueur_enregistrement;
                                 d_es_allocation_memoire;                          tampon_lecture = tampon3;
                         return;  
                     }                      }
                       else
                       {
                           if ((tampon_lecture = malloc(((size_t)
                                   longueur_enregistrement) *
                                   sizeof(unsigned char))) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return;
                           }
   
                     longueur_effective = (integer8) fread(tampon_lecture,                          longueur_effective = (integer8) fread(tampon_lecture,
                             sizeof(unsigned char),                                  sizeof(unsigned char),
                             (size_t) longueur_enregistrement,                                  (size_t) longueur_enregistrement,
                             (*descripteur).descripteur_c);                                  (*descripteur).descripteur_c);
                       }
   
                     if (l_element_courant == NULL)                      if (l_element_courant == NULL)
                     {                      {
Line 2142  instruction_read(struct_processus *s_eta Line 2269  instruction_read(struct_processus *s_eta
   
                     if (format_degenere == d_vrai)                      if (format_degenere == d_vrai)
                     {                      {
                         if (((*(*l_element_courant).donnee).objet =                          if (device == d_faux)
                             analyse_flux(s_etat_processus, tampon_lecture,  
                             longueur_enregistrement - 1)) == NULL)  
                         {                          {
                             return;                              if (((*(*l_element_courant).donnee).objet =
                                   analyse_flux(s_etat_processus, tampon_lecture,
                                   longueur_enregistrement - 1)) == NULL)
                               {
                                   return;
                               }
                           }
                           else
                           {
                               if (((*(*l_element_courant).donnee).objet =
                                   analyse_flux(s_etat_processus, tampon_lecture,
                                   longueur_enregistrement)) == NULL)
                               {
                                   return;
                               }
                         }                          }
                     }                      }
                     else                      else
Line 2498  instruction_read(struct_processus *s_eta Line 2637  instruction_read(struct_processus *s_eta
                     }                      }
                     else                      else
                     {                      {
                         // Installation d'un timeout pour sortir de                          // Si on a lu toute une trame et qu'on n'a pas
                         // l'instruction dans le cas où la transmission serait                          // réussi à en trouver la structure, on remonte
                         // invalide et que la trame reçue serait erronée.                          // une erreur de syntaxe.
   
                         poll_fd.fd = (*((struct_socket *)  
                                 (*s_objet_argument_1).objet)).socket;  
                         poll_fd.events = POLLIN;  
   
                         while((ios = poll(&poll_fd, 1, 10000)) <= 0)                          if (longueur_effective == ios)
                         {                          {
                             // La fin de la trame n'est pas atteinte.                              if ((*((struct_socket *) (*s_objet_argument_1)
                                       .objet)).domaine == PF_UNIX)
                             switch(ios)  
                             {                              {
                                 case EINTR:                                  do
                                 {                                  {
                                     if ((*s_etat_processus)                                      longueur_adresse = sizeof(adresse_unix);
                                             .var_volatile_requete_arret == -1)                                      recvfrom((*((struct_socket *)
                                     {                                              (*s_objet_argument_1).objet))
                                         liberation(s_etat_processus,                                              .socket, tampon_lecture,
                                                 s_objet_argument_1);                                              (size_t) longueur_effective,
                                         free(tampon_lecture);                                              0, (struct sockaddr *)
                                         return;                                              &adresse_unix, &longueur_adresse);
                                     }                                  } while((ios == -1) && (errno == EINTR));
                               }
                                     break;                              else if ((*((struct_socket *) (*s_objet_argument_1)
                                       .objet)).domaine == PF_INET)
                               {
                                   do
                                   {
                                       longueur_adresse = sizeof(adresse_ipv4);
                                       recvfrom((*((struct_socket *)
                                               (*s_objet_argument_1).objet))
                                               .socket, tampon_lecture,
                                               (size_t) longueur_effective,
                                               0, (struct sockaddr *)
                                               &adresse_ipv4, &longueur_adresse);
                                   } while((ios == -1) && (errno == EINTR));
                               }
                               else if ((*((struct_socket *) (*s_objet_argument_1)
                                       .objet)) .domaine == PF_INET6)
                               {
   #                               ifdef IPV6
                                   do
                                   {
                                       longueur_adresse = sizeof(adresse_ipv6);
                                       recvfrom((*((struct_socket *)
                                               (*s_objet_argument_1).objet))
                                               .socket, tampon_lecture,
                                               (size_t) longueur_effective,
                                               0, (struct sockaddr *)
                                               &adresse_ipv6, &longueur_adresse);
                                   } while((ios == -1) && (errno == EINTR));
   #                               else
                                   if ((*s_etat_processus).langue == 'F')
                                   {
                                       printf("+++Attention : Support du protocole"
                                               " IPv6 indisponible\n");
                                 }                                  }
                                   else
                                 case 0:  
                                 {                                  {
                                     liberation(s_etat_processus,                                      printf("+++Warning : IPv6 support "
                                             s_objet_argument_1);                                              "unavailable\n");
                                     free(tampon_lecture);  
   
                                     (*s_etat_processus).erreur_execution =  
                                             d_ex_fin_de_fichier_atteinte;  
                                     return;  
                                 }                                  }
   
   #                               endif
                             }                              }
   
                               liberation(s_etat_processus, s_objet_argument_1);
                               free(tampon_lecture);
   
                               (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                               return;
                         }                          }
                     }                      }
                 }                  }
Removed from v.1.76  
changed lines
  Added in v.1.89

CVSweb interface <joel.bertrand@systella.fr>