[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.45 and 1.48

version 1.45, 2012/02/23 13:05:08 version 1.48, 2012/02/24 15:02:54
Line 919  instruction_open(struct_processus *s_eta Line 919  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 926  instruction_open(struct_processus *s_eta Line 927  instruction_open(struct_processus *s_eta
   
     struct_liste_chainee        *l_element_courant;      struct_liste_chainee        *l_element_courant;
     struct_liste_chainee        *l_element_courant_sous_objet;      struct_liste_chainee        *l_element_courant_sous_objet;
       struct_liste_chainee        *parametre_courant;
   
     struct flock                lock;      struct flock                lock;
   
Line 955  instruction_open(struct_processus *s_eta Line 957  instruction_open(struct_processus *s_eta
     unsigned char               *nom;      unsigned char               *nom;
     unsigned char               *nom_temporaire;      unsigned char               *nom_temporaire;
     unsigned char               options[12];      unsigned char               options[12];
       unsigned char               *parametre_courant_majuscule;
     unsigned char               *peripherique;      unsigned char               *peripherique;
     unsigned char               *pointeur;      unsigned char               *pointeur;
       unsigned char               *position;
     unsigned char               protection;      unsigned char               protection;
     unsigned char               protocole[16 + 1];      unsigned char               protocole[16 + 1];
     unsigned char               *protocole_socket;      unsigned char               *protocole_socket;
Line 1043  instruction_open(struct_processus *s_eta Line 1047  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 3528  instruction_open(struct_processus *s_eta Line 3531  instruction_open(struct_processus *s_eta
                 {                  {
                     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);
   
                       (*s_etat_processus).erreur_systeme =
                               d_ex_erreur_fichier;
                       return;
                   }
   
                   parametre_courant = (*s_parametres_tty).objet;
   
                   // Le premier paramètre concerne la vitesse du port. Il doit
                   // toujours être présent.
   
                   if (parametre_courant == NULL)
                   {
                       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).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(
                           (*(*parametre_courant).donnee).objet)) == NULL)
                   {
                       liberation(s_etat_processus, s_objet_argument);
                       liberation(s_etat_processus, s_objet_resultat);
   
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   position = parametre_courant_majuscule;
   
                   while((*position) != d_code_fin_chaine)
                   {
                       if ((*position) == ',')
                       {
                           (*position) = ' ';
                       }
   
                       position++;
                   }
   
                   position = parametre_courant_majuscule;
   
                   while((*position) != d_code_fin_chaine)
                   {
                       if (isalnum((*position)) != 0)
                       {
                           break;
                       }
   
                       position++;
                   }
   
                   // Vitesse
   
                   unsigned char   *vitesses[] =
                           { "B0", "B50", "B75", "B110", "B134", "B150",
                           "B200", "B300", "B600", "B1200", "B1800", "B2400",
                           "B4800", "B9600", "B19200", "B38400", "B57600",
                           "B115200", "B230400", NULL };
                   int             vitesses_constantes[] =
                           { B0, B50, B75, B110, B134, B150, B200, B300, B600,
                           B1200, B1800, B2400, B4800, B9600, B19200, B38400,
                           B57600, B115200, B230400, 0 };
                   unsigned int    vitesse_courante;
   
                   vitesse_courante = 0;
   
                   while(vitesses[vitesse_courante] != NULL)
                   {
                       if (strncmp(position, vitesses[vitesse_courante],
                               strlen(vitesses[vitesse_courante])) == 0)
                       {
                           if (position[strlen(vitesses[vitesse_courante])] ==
                                   d_code_espace)
                           {
                               tc.c_cflag &= ~CBAUD;
                               tc.c_cflag |= vitesses_constantes[vitesse_courante];
                               position += strlen(vitesses[vitesse_courante]);
   
                               break;
                           }
                       }
   
                       vitesse_courante++;
                   }
   
                   if (vitesses[vitesse_courante] == NULL)
                   {
                       // La vitesse indiquée n'est pas une vitesse autorisée.
   
                       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;
                   }
   
                   // Nombre de bits par caractère.
   
                   while((*position) != d_code_fin_chaine)
                   {
                       if (isalnum((*position)) != 0)
                       {
                           break;
                       }
   
                       position++;
                   }
   
                   switch((*position))
                   {
                       case '5':
                       {
                           tc.c_cflag &= ~CSIZE;
                           tc.c_cflag |= CS5;
                           break;
                       }
   
                       case '6':
                       {
                           tc.c_cflag &= ~CSIZE;
                           tc.c_cflag |= CS6;
                           break;
                       }
   
                       case '7':
                       {
                           tc.c_cflag &= ~CSIZE;
                           tc.c_cflag |= CS7;
                           break;
                       }
   
                       case '8':
                       {
                           tc.c_cflag &= ~CSIZE;
                           tc.c_cflag |= CS8;
                           break;
                       }
   
                       default:
                       {
                           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;
                       }
                   }
   
                   position++;
   
                   if ((*position) != d_code_espace)
                   {
                       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;
                   }
   
                   // Parité
   
                   while((*position) != d_code_fin_chaine)
                   {
                       if (isalnum((*position)) != 0)
                       {
                           break;
                       }
   
                       position++;
                   }
   
                   switch((*position))
                   {
                       case 'N':
                       {
                           tc.c_cflag &= ~PARENB;
                           break;
                       }
   
                       case 'O':
                       {
                           tc.c_cflag |= PARENB;
                           tc.c_cflag |= PARODD;
                           break;
                       }
   
                       case 'E':
                       {
                           tc.c_cflag |= PARENB;
                           tc.c_cflag &= ~PARODD;
                           break;
                       }
   
                       default:
                       {
                           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;
                       }
                   }
   
                   if ((*position) != d_code_espace)
                   {
                       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;
                   }
   
                   // Bits de stop
   
                   while((*position) != d_code_fin_chaine)
                   {
                       if (isalnum((*position)) != 0)
                       {
                           break;
                       }
   
                       position++;
                   }
   
                   switch((*position))
                   {
                       case '1':
                       {
                           tc.c_cflag &= ~CSTOPB;
                           break;
                       }
   
                       case '2':
                       {
                           tc.c_cflag |= CSTOPB;
                           break;
                       }
   
                       default:
                       {
                           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;
                       }
                   }
   
                   // S'il reste autre chose que des espaces, il y a un
                   // problème de paramètres.
   
                   while((*position) != d_code_fin_chaine)
                   {
                       if ((*position) != d_code_espace)
                       {
                           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;
                       }
   
                       position++;
                   }
   
                   // Autres paramètres
   
                   free(parametre_courant_majuscule);
                   parametre_courant = (*parametre_courant).suivant;
   
                   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(
                               (*(*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", "IXANY", "IXOFF", "OPOST",
                               "ONLCR", "OCRNL", "ONOCR", "ONLRET",
                               "OFILL", "HUPCL", "CLOCAL", "CRTSCTS",
                               "ISIG", "ICANON", "ECHO", "ECHOE", "ECHOK",
                               "ECHONL", "NOFLSH", "TOSTOP", "IEXTEN", NULL };
                       int             fonctions_constantes[] =
                               { /* c_iflag */
                               1, IGNBRK, 1, BRKINT, 1, IGNPAR, 1, PARMRK,
                               1, INPCK, 1, ISTRIP, 1, INLCR, 1, IGNCR, 1, ICRNL,
                               1, IXON, 1, IXANY, 1, IXOFF,
                               /* c_oflag */
                               2 , OPOST, 2, ONLCR, 2, OCRNL, 2, ONOCR, 2, ONLRET,
                               2, OFILL, 2, HUPCL,
                               /* c_cflag */
                               3, CLOCAL, 3, CRTSCTS,
                               /* c_lfkag */
                               4, ISIG, 4, ICANON, 4, ECHO, 4, ECHOE, 4, ECHOK,
                               4, ECHONL, 4, NOFLSH, 4, TOSTOP, 4, IEXTEN };
                       unsigned int    fonction_courante;
   
                       if (isalnum((*position)) != 0)
                       {
                           // 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;
                   }
   
                   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 =                      (*s_etat_processus).erreur_systeme =
                             d_ex_erreur_fichier;                              d_ex_erreur_fichier;
Removed from v.1.45  
changed lines
  Added in v.1.48

CVSweb interface <joel.bertrand@systella.fr>