src/sha256sum.c

   1 /*
   2  * Copyright (C) 2013-2014 Intel Corporation.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  17  *
  18  * Authors:
  19  *       José Bollo <jose.bollo@open.eurogiciel.org>
  20  *       Stéphane Desneux <stephane.desneux@open.eurogiciel.org>
  21  *       Jean-Benoit Martin <jean-benoit.martin@open.eurogiciel.org>
  22  *
  23  */
  24 #define _GNU_SOURCE
  25
  26 #ifdef HAVE_CONFIG_H
  27 # include "config.h"
  28 #endif
  29
  30 #include <stdlib.h>
  31 #include <errno.h>
  32 #include <unistd.h>
  33 #include <sys/types.h>
  34 #include <sys/wait.h>
  35 #include <fcntl.h>
  36 #include <string.h>
  37
  38 #include "sha256sum.h"
  39
  40 static const char *arg[2] = { "/usr/bin/sha256sum", NULL };
  41
  42 struct sha256sum {
  43         enum { RUNNING, FAILED, SUCCESSED } state;
  44         pid_t pid;
  45         int tofd;
  46         int fromfd;
  47         char result[32];
  48 };
  49
  50 struct sha256sum *sha256sum_create()
  51 {
  52         int fds1[2];
  53         int fds2[2];
  54         pid_t pid;
  55         int sts;
  56         struct sha256sum *result;
  57
  58         result = malloc(sizeof * result);
  59         if (result == NULL)
  60                 return NULL;
  61
  62         sts = pipe(fds1);
  63         if (sts != 0) {
  64                 free(result);
  65                 return NULL;
  66         }
  67
  68         sts = pipe(fds2);
  69         if (sts != 0) {
  70                 close(fds1[0]);
  71                 close(fds1[1]);
  72                 free(result);
  73                 return NULL;
  74         }
  75
  76         pid = fork();
  77         if (pid == -1) {
  78                 close(fds1[0]);
  79                 close(fds1[1]);
  80                 close(fds2[0]);
  81                 close(fds2[1]);
  82                 free(result);
  83                 return NULL;
  84         }
  85
  86         if (pid == 0) {
  87                 dup2(fds1[0], 0);
  88                 dup2(fds2[1], 1);
  89                 close(fds1[0]);
  90                 close(fds1[1]);
  91                 close(fds2[0]);
  92                 close(fds2[1]);
  93                 execve(arg[0], (char**)arg, environ);
  94                 exit(1);
  95         }
  96
  97         close(fds1[0]);
  98         close(fds2[1]);
  99         result->state = RUNNING;
 100         result->pid = pid;
 101         result->tofd = fds1[1];
 102         result->fromfd = fds2[0];
 103         return result;
 104 }
 105
 106 void sha256sum_destroy(struct sha256sum *s)
 107 {
 108         int sts;
 109
 110         if (s->state == RUNNING) {
 111                 close(s->fromfd);
 112                 close(s->tofd);
 113                 waitpid(s->pid, &sts, 0);
 114         }
 115         free(s);
 116 }
 117
 118 int sha256sum_add_data(struct sha256sum *s, const void *data, size_t length)
 119 {
 120         ssize_t sl;
 121         int sts;
 122
 123         if (s->state != RUNNING)
 124                 return -1;
 125
 126         while (length) {
 127                 do {
 128                         sl = write(s->tofd, data, length);
 129                 } while (sl == -1 && (errno == EINTR || errno == EAGAIN));
 130                 if (sl == -1) {
 131                         s->state = FAILED;
 132                         close(s->fromfd);
 133                         close(s->tofd);
 134                         waitpid(s->pid, &sts, 0);
 135                         return -1;
 136                 }
 137                 length -= (size_t)sl;
 138                 data = (const void*)((const char*)data + (size_t)sl);
 139         }
 140         return 0;
 141 }
 142
 143 int sha256sum_add_file(struct sha256sum *s, const char *filename)
 144 {
 145         char buffer[16384];
 146         int fd;
 147         ssize_t rd;
 148
 149         fd = open(filename, O_RDONLY);
 150         if (fd < 0)
 151                 return -1;
 152
 153         for (;;) {
 154                 do {
 155                         rd = read(fd, buffer, sizeof buffer);
 156                 } while (rd == -1 && (errno == EINTR || errno == EAGAIN));
 157                 if (rd == -1) {
 158                         close(fd);
 159                         return -1;
 160                 }
 161                 if (rd == 0) {
 162                         close(fd);
 163                         return 0;
 164                 }
 165                 if (sha256sum_add_data(s, buffer, (size_t)rd)) {
 166                         close(fd);
 167                         return -1;
 168                 }
 169         }
 170 }
 171
 172 int sha256sum_get(struct sha256sum *s, char result[32])
 173 {
 174         int sts;
 175         int j;
 176         char buffer[65];
 177         char c1;
 178         char c2;
 179
 180         if (s->state == RUNNING) {
 181                 s->state = FAILED;
 182                 close(s->tofd);
 183                 waitpid(s->pid, &sts, 0);
 184                 if (WIFEXITED(sts) && WEXITSTATUS(sts) == 0) {
 185                         sts = read(s->fromfd, buffer, 65);
 186                         if (sts == 65 && buffer[64] == ' ') {
 187                                 s->state = SUCCESSED;
 188                                 for (j = 0 ; j < 32 ; j++) {
 189                                         c1 = buffer[j+j];
 190                                         if ('0' <= c1 && c1 <= '9')
 191                                                 c1 = c1 - '0';
 192                                         else if ('a' <= c1 && c1 <= 'f')
 193                                                 c1 = c1 - 'a' + '\012';
 194                                         else if ('A' <= c1 && c1 <= 'F')
 195                                                 c1 = c1 - 'A' + '\012';
 196                                         else {
 197                                                 s->state = FAILED;
 198                                                 break;
 199                                         }
 200                                         c2 = buffer[j+j+1];
 201                                         if ('0' <= c2 && c2 <= '9')
 202                                                 c2 = c2 - '0';
 203                                         else if ('a' <= c2 && c2 <= 'f')
 204                                                 c2 = c2 - 'a' + '\012';
 205                                         else if ('A' <= c2 && c2 <= 'F')
 206                                                 c2 = c2 - 'A' + '\012';
 207                                         else {
 208                                                 s->state = FAILED;
 209                                                 break;
 210                                         }
 211                                         s->result[j] = (c1 << 4) | c2;
 212                                 }
 213                         }
 214                 }
 215                 close(s->fromfd);
 216         }
 217
 218         if (s->state == FAILED)
 219                 return -1;
 220
 221         memcpy(result, s->result, 32);
 222
 223         return 0;
 224 }
 225
 226 #ifdef TEST
 227 #include <stdio.h>
 228 #include <assert.h>
 229 int main(int argc, char **argv)
 230 {
 231         char sum[32];
 232         int j, r;
 233         struct sha256sum *s;
 234
 235         while (*++argv) {
 236                 s = sha256sum_create();
 237                 assert(s != NULL);
 238                 r = sha256sum_add_file(s, *argv);
 239                 assert(r == 0);
 240                 r = sha256sum_get(s, sum);
 241                 assert(r == 0);
 242                 sha256sum_destroy(s);
 243                 for (j = 0 ; j < 32 ; j++)
 244                         printf("%02x", (int)(unsigned char)sum[j]);
 245                 printf("  %s\n", *argv);
 246         }
 247         return 0;
 248 }
 249 #endif
 250