Return to chainage.c CVS log

Up to [local] / rpl / src

Ajout d'une fonction controle_integrite() encapsulant les contrôles
sha1 et md5 des exécutables. Cette fonction est dans rpl.c (recompilé à chaque
compilation) pour éviter les résidus des anciennes compilations.

    1: /*
    2: ================================================================================
    3:   RPL/2 (R) version 4.1.5
    4:   Copyright (C) 1989-2011 Dr. BERTRAND Joël
    5: 
    6:   This file is part of RPL/2.
    7: 
    8:   RPL/2 is free software; you can redistribute it and/or modify it
    9:   under the terms of the CeCILL V2 License as published by the french
   10:   CEA, CNRS and INRIA.
   11:  
   12:   RPL/2 is distributed in the hope that it will be useful, but WITHOUT
   13:   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   14:   FITNESS FOR A PARTICULAR PURPOSE.  See the CeCILL V2 License
   15:   for more details.
   16:  
   17:   You should have received a copy of the CeCILL License
   18:   along with RPL/2. If not, write to info@cecill.info.
   19: ================================================================================
   20: */
   21: 
   22: 
   23: #include "rpl-conv.h"
   24: 
   25: 
   26: /*
   27: ================================================================================
   28:   Routine de chaînage du programme (lecture du fichier puis constitution
   29:   de la chaîne exécutable)
   30: ================================================================================
   31:   Entrées: structure processus
   32: --------------------------------------------------------------------------------
   33:   Sortie: drapeau d'erreur
   34: --------------------------------------------------------------------------------
   35:   Effets de bord: néant
   36: ================================================================================
   37: */
   38: 
   39: logical1
   40: chainage(struct_processus *s_etat_processus)
   41: {
   42:     char                    *nom_fichier_temporaire;
   43: 
   44:     file                    *f_source;
   45: 
   46:     int                     caractere;
   47:     int                     erreur;
   48:     int                     erreur_os;
   49: 
   50:     logical1                drapeau_fin;
   51:     logical1                existence;
   52:     logical1                initialisation;
   53:     logical1                ouverture;
   54:     logical1                presence_chaine;
   55: 
   56:     long                    i;
   57:     long                    nombre_caracteres_source;
   58: 
   59:     unsigned char           *commande;
   60:     unsigned char           *executable_candidat;
   61: 
   62: #   ifndef OS2
   63:     unsigned char           *instructions = "%s/bin/%s %s | "
   64:                                     "%s/bin/rpliconv `%s/bin/rplfile "
   65:                                     "-m %s/share/rplfiles -i %s | "
   66:                                     "%s/bin/rplawk "
   67:                                     "'{ print $3; }' | %s/bin/rplawk -F= "
   68:                                     "'{ if ($2 != \"\") printf(\"-f %%s\", "
   69:                                     "$2); }'` -t %s//IGNORE > %s";
   70: #   else
   71:     unsigned char           *instructions = BOURNE_SHELL " -c \""
   72:                                     "%s/bin/%s %s | "
   73:                                     "%s/bin/rpliconv `%s/bin/rplfile "
   74:                                     "-m %s/share/rplfiles -i %s | "
   75:                                     "%s/bin/rplawk "
   76:                                     "'{ print $3; }' | %s/bin/rplawk -F= "
   77:                                     "'{ if ($2 != \\\"\\\") "
   78:                                     "printf(\\\"-f %%s\\\", "
   79:                                     "$2); }'` -t %s//IGNORE > %s\"";
   80: #   endif
   81: 
   82:     unsigned long           unite_fichier;
   83: 
   84:     if ((*s_etat_processus).debug == d_vrai)
   85:         if (((*s_etat_processus).type_debug & d_debug_analyse) != 0)
   86:     {
   87:         printf("\n");
   88: 
   89:         if ((*s_etat_processus).langue == 'F')
   90:         {
   91:             printf("[%d] Appel au préprocesseur\n", (int) getpid());
   92:         }
   93:         else
   94:         {
   95:             printf("[%d] Preprocessing\n", (int) getpid());
   96:         }
   97: 
   98:         fflush(stdout);
   99:     }
  100: 
  101:     erreur = caracteristiques_fichier(s_etat_processus,
  102:             (*s_etat_processus).nom_fichier_source, &existence,
  103:             &ouverture, &unite_fichier);
  104: 
  105:     erreur_os = d_absence_erreur;
  106: 
  107:     if ((existence == d_vrai) && (erreur == 0))
  108:     {
  109:         if ((nom_fichier_temporaire = creation_nom_fichier(
  110:                 s_etat_processus, (*s_etat_processus)
  111:                 .chemin_fichiers_temporaires)) == NULL)
  112:         {
  113:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  114:             return(d_erreur);
  115:         }
  116: 
  117:         // Avant d'exécuter la commande, on teste les sommes de hashage
  118:         // des utilitaires de la famille RPL/2.
  119: 
  120:         if ((*s_etat_processus).rpl_home == NULL)
  121:         {
  122:             if ((commande = (unsigned char *) malloc((strlen(ds_preprocesseur) +
  123:                     (2 * strlen((*s_etat_processus).nom_fichier_source)) +
  124:                     (6 * strlen(d_exec_path)) + strlen(d_locale) +
  125:                     strlen(nom_fichier_temporaire) + strlen(instructions) - 21)
  126:                     * sizeof(unsigned char))) == NULL)
  127:             {
  128:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  129: 
  130:                 free(nom_fichier_temporaire);
  131:                 return(d_erreur);
  132:             }
  133: 
  134:             sprintf(commande, instructions,
  135:                     d_exec_path, ds_preprocesseur,
  136:                     (*s_etat_processus).nom_fichier_source,
  137:                     d_exec_path, d_exec_path,
  138:                     d_exec_path, (*s_etat_processus).nom_fichier_source,
  139:                     d_exec_path, d_exec_path, d_locale, nom_fichier_temporaire);
  140: 
  141:             if (alsprintf(&executable_candidat, "%s/bin/rpliconv",
  142:                     d_exec_path) < 0)
  143:             {
  144:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  145:                 return(d_erreur);
  146:             }
  147: 
  148:             if (controle_integrite(s_etat_processus, executable_candidat,
  149:                         "rpliconv") != d_vrai)
  150:             {
  151:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  152:                 return(d_erreur);
  153:             }
  154: 
  155:             free(executable_candidat);
  156: 
  157:             if (alsprintf(&executable_candidat, "%s/bin/rplfile",
  158:                     d_exec_path) < 0)
  159:             {
  160:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  161:                 return(d_erreur);
  162:             }
  163: 
  164:             if (controle_integrite(s_etat_processus, executable_candidat,
  165:                     "rplfile") != d_vrai)
  166:             {
  167:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  168:                 return(d_erreur);
  169:             }
  170: 
  171:             free(executable_candidat);
  172: 
  173:             if (alsprintf(&executable_candidat, "%s/bin/rplpp",
  174:                     d_exec_path) < 0)
  175:             {
  176:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  177:                 return(d_erreur);
  178:             }
  179: 
  180:             if (controle_integrite(s_etat_processus, executable_candidat,
  181:                     "rplpp") != d_vrai)
  182:             {
  183:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  184:                 return(d_erreur);
  185:             }
  186: 
  187:             free(executable_candidat);
  188: 
  189:             if (alsprintf(&executable_candidat, "%s/bin/rplawk",
  190:                     d_exec_path) < 0)
  191:             {
  192:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  193:                 return(d_erreur);
  194:             }
  195: 
  196:             if (controle_integrite(s_etat_processus, executable_candidat,
  197:                     "rplawk") != d_vrai)
  198:             {
  199:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  200:                 return(d_erreur);
  201:             }
  202: 
  203:             free(executable_candidat);
  204:         }
  205:         else
  206:         {
  207:             if ((commande = (unsigned char *) malloc((strlen(ds_preprocesseur) +
  208:                     (2 * strlen((*s_etat_processus).nom_fichier_source)) +
  209:                     (6 * strlen((*s_etat_processus).rpl_home)) +
  210:                     strlen(d_locale) +
  211:                     strlen(nom_fichier_temporaire) + strlen(instructions) - 21)
  212:                     * sizeof(unsigned char))) == NULL)
  213:             {
  214:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  215: 
  216:                 free(nom_fichier_temporaire);
  217:                 return(d_erreur);
  218:             }
  219: 
  220:             sprintf(commande, instructions,
  221:                     (*s_etat_processus).rpl_home, ds_preprocesseur,
  222:                     (*s_etat_processus).nom_fichier_source,
  223:                     (*s_etat_processus).rpl_home,
  224:                     (*s_etat_processus).rpl_home,
  225:                     (*s_etat_processus).rpl_home,
  226:                     (*s_etat_processus).nom_fichier_source,
  227:                     (*s_etat_processus).rpl_home,
  228:                     (*s_etat_processus).rpl_home,
  229:                     d_locale, nom_fichier_temporaire);
  230: 
  231:             if (alsprintf(&executable_candidat, "%s/bin/rpliconv",
  232:                     (*s_etat_processus).rpl_home) < 0)
  233:             {
  234:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  235:                 return(d_erreur);
  236:             }
  237: 
  238:             if (controle_integrite(s_etat_processus, executable_candidat,
  239:                     "rpliconv") != d_vrai)
  240:             {
  241:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  242:                 return(d_erreur);
  243:             }
  244: 
  245:             free(executable_candidat);
  246: 
  247:             if (alsprintf(&executable_candidat, "%s/bin/rplfile",
  248:                     (*s_etat_processus).rpl_home) < 0)
  249:             {
  250:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  251:                 return(d_erreur);
  252:             }
  253: 
  254:             if (controle_integrite(s_etat_processus, executable_candidat,
  255:                     "rplfile") != d_vrai)
  256:             {
  257:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  258:                 return(d_erreur);
  259:             }
  260: 
  261:             free(executable_candidat);
  262: 
  263:             if (alsprintf(&executable_candidat, "%s/bin/rplpp",
  264:                     (*s_etat_processus).rpl_home) < 0)
  265:             {
  266:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  267:                 return(d_erreur);
  268:             }
  269: 
  270:             if (controle_integrite(s_etat_processus, executable_candidat,
  271:                     "rplpp") != d_vrai)
  272:             {
  273:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  274:                 return(d_erreur);
  275:             }
  276: 
  277:             free(executable_candidat);
  278: 
  279:             if (alsprintf(&executable_candidat, "%s/bin/rplawk",
  280:                     (*s_etat_processus).rpl_home) < 0)
  281:             {
  282:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  283:                 return(d_erreur);
  284:             }
  285: 
  286:             if (controle_integrite(s_etat_processus, executable_candidat,
  287:                     "rplawk") != d_vrai)
  288:             {
  289:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  290:                 return(d_erreur);
  291:             }
  292: 
  293:             free(executable_candidat);
  294:         }
  295: 
  296:         if ((f_source = popen(commande, "r")) == NULL)
  297:         {
  298:             (*s_etat_processus).erreur_systeme = d_es_processus;
  299: 
  300:             free(nom_fichier_temporaire);
  301:             return(d_erreur);
  302:         }
  303: 
  304:         if (pclose(f_source) != EXIT_SUCCESS)
  305:         {
  306:             (*s_etat_processus).erreur_systeme = d_es_processus;
  307: 
  308:             free(nom_fichier_temporaire);
  309:             return(d_erreur);
  310:         }
  311: 
  312:         free(commande);
  313: 
  314:         if ((f_source = fopen(nom_fichier_temporaire, "r")) == NULL)
  315:         {
  316:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  317: 
  318:             if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
  319:             {
  320:                 free(nom_fichier_temporaire);
  321:                 return(d_erreur);
  322:             }
  323: 
  324:             free(nom_fichier_temporaire);
  325:             return(d_erreur);
  326:         }
  327: 
  328:         nombre_caracteres_source = 0;
  329: 
  330:         while(getc(f_source) != EOF)
  331:         {
  332:             nombre_caracteres_source++;
  333:         }
  334: 
  335:         (*s_etat_processus).definitions_chainees = (unsigned char *)
  336:                 malloc((nombre_caracteres_source + 1) * sizeof(unsigned char));
  337:         
  338:         if ((*s_etat_processus).definitions_chainees == NULL)
  339:         {
  340:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  341: 
  342:             if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
  343:             {
  344:                 free(nom_fichier_temporaire);
  345:                 return(d_erreur);
  346:             }
  347: 
  348:             return(d_erreur);
  349:         }
  350:         else
  351:         {
  352:             rewind(f_source);
  353:             presence_chaine = d_faux;
  354: 
  355:             i = 0;
  356:             drapeau_fin = d_faux;
  357:             initialisation = d_vrai;
  358: 
  359:             /*
  360:              * Élimination du sharp-bang si nécessaire et des caractères
  361:              * inutiles. Conversion de caractères.
  362:              */
  363: 
  364:             while(drapeau_fin == d_faux)
  365:             {
  366:                 if ((caractere = getc(f_source)) != EOF)
  367:                 {
  368:                     if (initialisation == d_vrai)
  369:                     {
  370:                         if (caractere == '#')
  371:                         {
  372:                             if ((caractere = getc(f_source)) != EOF)
  373:                             {
  374:                                 if (caractere == '!')
  375:                                 {
  376:                                     do
  377:                                     {
  378:                                         caractere = getc(f_source);
  379:                                     } while((caractere != EOF) &&
  380:                                             (caractere !=
  381:                                             d_code_retour_chariot));
  382:                                 }
  383:                                 else
  384:                                 {
  385:                                     rewind(f_source);
  386:                                     caractere = getc(f_source);
  387:                                 }
  388:                             }
  389:                         }
  390: 
  391:                         initialisation = d_faux;
  392:                     }
  393: 
  394:                     if ((caractere == d_code_retour_chariot) ||
  395:                             (caractere == d_code_tabulation) ||
  396:                             ((caractere == d_code_espace) &&
  397:                             (presence_chaine == d_faux)))
  398:                     {
  399:                         do
  400:                         {
  401:                             caractere = getc(f_source);
  402:                         } while(((caractere == d_code_retour_chariot) ||
  403:                                 (caractere == d_code_tabulation) ||
  404:                                 ((caractere == d_code_espace) &&
  405:                                 (presence_chaine == d_faux))) &&
  406:                                 (caractere != EOF));
  407: 
  408:                         if (caractere != EOF)
  409:                         {
  410:                             ((*s_etat_processus).definitions_chainees)[i++] =
  411:                                     d_code_espace;
  412:                         }
  413:                         else
  414:                         {
  415:                             drapeau_fin = d_vrai;
  416:                         }
  417:                     }
  418: 
  419:                     if ((((*s_etat_processus).definitions_chainees)[i] =
  420:                             caractere) == '\"')
  421:                     {
  422:                         if (i > 0)
  423:                         {
  424:                             if (((*s_etat_processus).definitions_chainees)
  425:                                     [i - 1] != '\\')
  426:                             {
  427:                                 presence_chaine = (presence_chaine == d_faux)
  428:                                         ? d_vrai : d_faux;
  429:                             }
  430:                         }
  431: 
  432:                         i++;
  433:                     }
  434:                     else
  435:                     {
  436:                         i++;
  437:                     }
  438:                 }
  439:                 else
  440:                 {
  441:                     drapeau_fin = d_vrai;
  442:                 }
  443:             }
  444: 
  445:             if ((caractere == EOF) && (i > 0))
  446:             {
  447:                 i--;
  448:             }
  449: 
  450:             ((*s_etat_processus).definitions_chainees)[i] = d_code_fin_chaine;
  451: 
  452:             erreur_os = d_absence_erreur;
  453:         }
  454: 
  455:         (*s_etat_processus).longueur_definitions_chainees =
  456:                 strlen((*s_etat_processus).definitions_chainees);
  457: 
  458:         if (fclose(f_source) != 0)
  459:         {
  460:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  461: 
  462:             if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
  463:             {
  464:                 free(nom_fichier_temporaire);
  465:                 return(d_erreur);
  466:             }
  467: 
  468:             free(nom_fichier_temporaire);
  469:             return(d_erreur);
  470:         }
  471: 
  472:         if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
  473:         {
  474:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  475: 
  476:             free(nom_fichier_temporaire);
  477:             return(d_erreur);
  478:         }
  479: 
  480:         free(nom_fichier_temporaire);
  481:     }
  482:     else
  483:     {
  484:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  485:         erreur_os = d_erreur;
  486:     }
  487: 
  488:     if (((*s_etat_processus).definitions_chainees =
  489:             realloc((*s_etat_processus).definitions_chainees,
  490:             ((*s_etat_processus).longueur_definitions_chainees + 1) *
  491:             sizeof(unsigned char))) == NULL)
  492:     {
  493:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  494:         return(d_erreur);
  495:     }
  496: 
  497:     return(erreur_os);
  498: }
  499: 
  500: 
  501: /*
  502: ================================================================================
  503:   Routine de compactage d'une chaîne de caractères
  504:   Tous les espaces et les retours à ligne surnuméraires sont enlevés.
  505: ================================================================================
  506:   Entrées: structure processus
  507: --------------------------------------------------------------------------------
  508:   Sortie: drapeau d'erreur
  509: --------------------------------------------------------------------------------
  510:   Effets de bord: néant
  511: ================================================================================
  512: */
  513: 
  514: unsigned char *
  515: compactage(unsigned char *chaine)
  516: {
  517:     logical1        drapeau_fin;
  518:     logical1        presence_chaine;
  519: 
  520:     unsigned char   caractere;
  521:     unsigned char   *ptr_ecriture;
  522:     unsigned char   *ptr_lecture;
  523: 
  524:     if (chaine == NULL)
  525:     {
  526:         return(NULL);
  527:     }
  528: 
  529:     presence_chaine = d_faux;
  530: 
  531:     drapeau_fin = d_faux;
  532:     ptr_lecture = chaine;
  533:     ptr_ecriture = chaine;
  534: 
  535:     while(drapeau_fin == d_faux)
  536:     {
  537:         if ((caractere = (*ptr_lecture++)) != d_code_fin_chaine)
  538:         {
  539:             if ((caractere == d_code_retour_chariot) ||
  540:                     (caractere == d_code_tabulation) ||
  541:                     ((caractere == d_code_espace) &&
  542:                     (presence_chaine == d_faux)))
  543:             {
  544:                 do
  545:                 {
  546:                     caractere = (*ptr_lecture++);
  547:                 } while(((caractere == d_code_retour_chariot) ||
  548:                         (caractere == d_code_tabulation) ||
  549:                         ((caractere == d_code_espace) &&
  550:                         (presence_chaine == d_faux))) &&
  551:                         (caractere != d_code_fin_chaine));
  552: 
  553:                 if (caractere != d_code_fin_chaine)
  554:                 {
  555:                     (*ptr_ecriture++) = d_code_espace;
  556:                 }
  557:                 else
  558:                 {
  559:                     drapeau_fin = d_vrai;
  560:                 }
  561:             }
  562: 
  563:             if (((*ptr_ecriture++) = caractere) == '\"')
  564:             {
  565:                 presence_chaine = (presence_chaine == d_faux)
  566:                         ? d_vrai : d_faux;
  567:             }
  568:         }
  569:         else
  570:         {
  571:             drapeau_fin = d_vrai;
  572:         }
  573:     }
  574: 
  575:     (*ptr_ecriture) = d_code_fin_chaine;
  576: 
  577:     return(realloc(chaine, (strlen(chaine) + 1) * sizeof(unsigned char)));
  578: }
  579: 
  580: // vim: ts=4