Return to controle.c CVS log

Up to [local] / rpl / src

Correction d'une réinitialisation sauvage de la pile des variables par niveau
dans la copie de la structure de description du processus. Cela corrige
la fonction SPAWN qui échouait sur un segmentation fault car la pile des
variables par niveau était vide alors même que l'arbre des variables contenait
bien les variables. Passage à la prerelease 2.

    1: /*
    2: ================================================================================
    3:   RPL/2 (R) version 4.1.0.prerelease.2
    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:   Calcul des sommes de contrôle avant le lancement d'un exécutable
   29:   de la famille RPL/2 (rpliconv, rplconvert, rplfile et rplpp).
   30: ================================================================================
   31:   Entrée :
   32:     - chaîne de caractères sur le fichier à contrôler
   33:     - chaîne de caractères contenant la somme à contrôler
   34:     - type de somme de contrôle
   35: --------------------------------------------------------------------------------
   36:   Sortie : drapeau
   37: --------------------------------------------------------------------------------
   38:   Effets de bord : néant
   39: ================================================================================
   40: */
   41: 
   42: logical1
   43: controle(struct_processus *s_etat_processus, unsigned char *fichier,
   44:         unsigned char *type, unsigned char *somme_candidate)
   45: {
   46:     EVP_MD_CTX          contexte;
   47: 
   48:     int                 in_fd;
   49: 
   50:     logical1            drapeau;
   51: 
   52:     off_t               taille_fichier;
   53: 
   54:     ssize_t             octets_lus;
   55: 
   56:     struct stat         stat_buf;
   57: 
   58:     unsigned char       *chaine;
   59:     unsigned char       *registre;
   60:     unsigned char       somme[EVP_MAX_MD_SIZE];
   61:     unsigned char       somme_hexadecimale[2 * EVP_MAX_MD_SIZE];
   62: 
   63:     unsigned int        i;
   64:     unsigned int        longueur_somme;
   65: 
   66:     registre = fichier;
   67: 
   68: #   ifdef OS2
   69:     unsigned char       *tampon;
   70: 
   71:     if ((tampon = malloc((strlen(fichier) + 5) * sizeof(unsigned char)))
   72:             == NULL)
   73:     {
   74:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
   75:         return(d_faux);
   76:     }
   77: 
   78:     sprintf(tampon, "%s.exe", fichier);
   79:     fichier = tampon;
   80: #   endif
   81: 
   82:     if (stat(fichier, &stat_buf) != 0)
   83:     {
   84: #       ifdef OS2
   85:         free(fichier);
   86: #       endif
   87: 
   88:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
   89:         return(d_faux);
   90:     }
   91: 
   92:     taille_fichier = stat_buf.st_size;
   93: 
   94:     if ((chaine = malloc(taille_fichier)) == NULL)
   95:     {
   96: #       ifdef OS2
   97:         free(fichier);
   98: #       endif
   99: 
  100:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  101:         return(d_faux);
  102:     }
  103: 
  104:     if ((in_fd = open(fichier, 0, O_RDONLY)) < 0)
  105:     {
  106: #       ifdef OS2
  107:         free(fichier);
  108: #       endif
  109: 
  110:         free(chaine);
  111: 
  112:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  113:         return(d_faux);
  114:     }
  115: 
  116: #   ifdef OS2
  117:     free(fichier);
  118: #   endif
  119: 
  120:     if ((octets_lus = read(in_fd, chaine, taille_fichier)) != taille_fichier)
  121:     {
  122: #       ifndef OS2
  123:         close(in_fd);
  124:         free(chaine);
  125: 
  126:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  127:         return(d_faux);
  128: #       endif
  129:     }
  130: 
  131:     close(in_fd);
  132: 
  133:     if (strcmp(type, "md5") == 0)
  134:     {
  135:         if (EVP_DigestInit(&contexte, EVP_md5()) != 1)
  136:         {
  137:             close(in_fd);
  138:             free(chaine);
  139: 
  140:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  141:             return(d_faux);
  142:         }
  143: 
  144:         if (EVP_DigestUpdate(&contexte, chaine, taille_fichier) != 1)
  145:         {
  146:             close(in_fd);
  147:             free(chaine);
  148: 
  149:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  150:             return(d_faux);
  151:         }
  152: 
  153:         if (EVP_DigestFinal_ex(&contexte, somme, &longueur_somme) != 1)
  154:         {
  155:             close(in_fd);
  156:             free(chaine);
  157: 
  158:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  159:             return(d_faux);
  160:         }
  161:     }
  162:     else if (strcmp(type, "sha1") == 0)
  163:     {
  164:         if (EVP_DigestInit(&contexte, EVP_sha1()) != 1)
  165:         {
  166:             close(in_fd);
  167:             free(chaine);
  168: 
  169:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  170:             return(d_faux);
  171:         }
  172: 
  173:         if (EVP_DigestUpdate(&contexte, chaine, taille_fichier) != 1)
  174:         {
  175:             close(in_fd);
  176:             free(chaine);
  177: 
  178:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  179:             return(d_faux);
  180:         }
  181: 
  182:         if (EVP_DigestFinal_ex(&contexte, somme, &longueur_somme) != 1)
  183:         {
  184:             close(in_fd);
  185:             free(chaine);
  186: 
  187:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  188:             return(d_faux);
  189:         }
  190:     }
  191:     else
  192:     {
  193:         return(d_faux);
  194:     }
  195: 
  196:     EVP_MD_CTX_cleanup(&contexte);
  197:     free(chaine);
  198: 
  199:     for(i = 0; i < longueur_somme; i++)
  200:     {
  201:         sprintf(&(somme_hexadecimale[2 * i]), "%02x", somme[i]);
  202:     }
  203: 
  204:     if (strcmp(somme_candidate, somme_hexadecimale) == 0)
  205:     {
  206:         drapeau = d_vrai;
  207:     }
  208:     else
  209:     {
  210:         if ((*s_etat_processus).langue == 'F')
  211:         {
  212:             printf("+++Fatal : Somme de contrôle invalide\n");
  213:             printf("Fonction %s(%s)\n", type, registre);
  214:             printf("Résultat obtenu  : %s\n", somme_hexadecimale);
  215:             printf("Résultat attendu : %s\n", somme_candidate);
  216:         }
  217:         else
  218:         {
  219:             printf("+++Fatal : Hash code mismatch\n");
  220:             printf("Function %s(%s)\n", type, registre);
  221:             printf("Computed hash code : %s\n", somme_hexadecimale);
  222:             printf("Expected hash code : %s\n", somme_candidate);
  223:         }
  224: 
  225:         drapeau = d_faux;
  226:     }
  227: 
  228:     return(drapeau);
  229: }
  230: 
  231: // vim: ts=4