Return to controle.c CVS log

Up to [local] / rpl / src

En route vers la 4.1.20.

    1: /*
    2: ================================================================================
    3:   RPL/2 (R) version 4.1.20
    4:   Copyright (C) 1989-2015 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((size_t) 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, (size_t) taille_fichier))
  121:             != (ssize_t) taille_fichier)
  122:     {
  123: #       ifndef OS2
  124:         close(in_fd);
  125:         free(chaine);
  126: 
  127:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  128:         return(d_faux);
  129: #       endif
  130:     }
  131: 
  132:     close(in_fd);
  133: 
  134:     if (strcmp(type, "md5") == 0)
  135:     {
  136:         if (EVP_DigestInit(&contexte, EVP_md5()) != 1)
  137:         {
  138:             close(in_fd);
  139:             free(chaine);
  140: 
  141:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  142:             return(d_faux);
  143:         }
  144: 
  145:         if (EVP_DigestUpdate(&contexte, chaine, (size_t) taille_fichier) != 1)
  146:         {
  147:             close(in_fd);
  148:             free(chaine);
  149: 
  150:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  151:             return(d_faux);
  152:         }
  153: 
  154:         if (EVP_DigestFinal_ex(&contexte, somme, &longueur_somme) != 1)
  155:         {
  156:             close(in_fd);
  157:             free(chaine);
  158: 
  159:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  160:             return(d_faux);
  161:         }
  162:     }
  163:     else if (strcmp(type, "sha1") == 0)
  164:     {
  165:         if (EVP_DigestInit(&contexte, EVP_sha1()) != 1)
  166:         {
  167:             close(in_fd);
  168:             free(chaine);
  169: 
  170:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  171:             return(d_faux);
  172:         }
  173: 
  174:         if (EVP_DigestUpdate(&contexte, chaine, (size_t) taille_fichier) != 1)
  175:         {
  176:             close(in_fd);
  177:             free(chaine);
  178: 
  179:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  180:             return(d_faux);
  181:         }
  182: 
  183:         if (EVP_DigestFinal_ex(&contexte, somme, &longueur_somme) != 1)
  184:         {
  185:             close(in_fd);
  186:             free(chaine);
  187: 
  188:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  189:             return(d_faux);
  190:         }
  191:     }
  192:     else
  193:     {
  194:         return(d_faux);
  195:     }
  196: 
  197:     EVP_MD_CTX_cleanup(&contexte);
  198:     free(chaine);
  199: 
  200:     for(i = 0; i < longueur_somme; i++)
  201:     {
  202:         sprintf(&(somme_hexadecimale[2 * i]), "%02x", somme[i]);
  203:     }
  204: 
  205:     if (strcmp(somme_candidate, somme_hexadecimale) == 0)
  206:     {
  207:         drapeau = d_vrai;
  208:     }
  209:     else
  210:     {
  211:         if ((*s_etat_processus).langue == 'F')
  212:         {
  213:             printf("+++Fatal : Somme de contrôle invalide\n");
  214:             printf("Fonction %s(%s)\n", type, registre);
  215:             printf("Résultat obtenu  : %s\n", somme_hexadecimale);
  216:             printf("Résultat attendu : %s\n", somme_candidate);
  217:         }
  218:         else
  219:         {
  220:             printf("+++Fatal : Hash code mismatch\n");
  221:             printf("Function %s(%s)\n", type, registre);
  222:             printf("Computed hash code : %s\n", somme_hexadecimale);
  223:             printf("Expected hash code : %s\n", somme_candidate);
  224:         }
  225: 
  226:         drapeau = d_faux;
  227:     }
  228: 
  229:     return(drapeau);
  230: }
  231: 
  232: // vim: ts=4