csum-file.c

   1 /*
   2  * csum-file.c
   3  *
   4  * Copyright (C) 2005 Linus Torvalds
   5  *
   6  * Simple file write infrastructure for writing SHA1-summed
   7  * files. Useful when you write a file that you want to be
   8  * able to verify hasn't been messed with afterwards.
   9  */
  10 #include "cache.h"
  11 #include "csum-file.h"
  12
  13 static void sha1flush(struct sha1file *f, unsigned int count)
  14 {
  15         void *buf = f->buffer;
  16
  17         for (;;) {
  18                 int ret = xwrite(f->fd, buf, count);
  19                 if (ret > 0) {
  20                         buf = (char *) buf + ret;
  21                         count -= ret;
  22                         if (count)
  23                                 continue;
  24                         return;
  25                 }
  26                 if (!ret)
  27                         die("sha1 file '%s' write error. Out of diskspace", f->name);
  28                 die("sha1 file '%s' write error (%s)", f->name, strerror(errno));
  29         }
  30 }
  31
  32 int sha1close(struct sha1file *f, unsigned char *result, int final)
  33 {
  34         unsigned offset = f->offset;
  35         if (offset) {
  36                 SHA1_Update(&f->ctx, f->buffer, offset);
  37                 sha1flush(f, offset);
  38                 f->offset = 0;
  39         }
  40         if (!final)
  41                 return 0;       /* only want to flush (no checksum write, no close) */
  42         SHA1_Final(f->buffer, &f->ctx);
  43         if (result)
  44                 hashcpy(result, f->buffer);
  45         sha1flush(f, 20);
  46         if (close(f->fd))
  47                 die("%s: sha1 file error on close (%s)", f->name, strerror(errno));
  48         free(f);
  49         return 0;
  50 }
  51
  52 int sha1write(struct sha1file *f, void *buf, unsigned int count)
  53 {
  54         if (f->do_crc)
  55                 f->crc32 = crc32(f->crc32, buf, count);
  56         while (count) {
  57                 unsigned offset = f->offset;
  58                 unsigned left = sizeof(f->buffer) - offset;
  59                 unsigned nr = count > left ? left : count;
  60
  61                 memcpy(f->buffer + offset, buf, nr);
  62                 count -= nr;
  63                 offset += nr;
  64                 buf = (char *) buf + nr;
  65                 left -= nr;
  66                 if (!left) {
  67                         SHA1_Update(&f->ctx, f->buffer, offset);
  68                         sha1flush(f, offset);
  69                         offset = 0;
  70                 }
  71                 f->offset = offset;
  72         }
  73         return 0;
  74 }
  75
  76 struct sha1file *sha1fd(int fd, const char *name)
  77 {
  78         struct sha1file *f;
  79         unsigned len;
  80
  81         f = xmalloc(sizeof(*f));
  82
  83         len = strlen(name);
  84         if (len >= PATH_MAX)
  85                 die("you wascally wabbit, you");
  86         f->namelen = len;
  87         memcpy(f->name, name, len+1);
  88
  89         f->fd = fd;
  90         f->error = 0;
  91         f->offset = 0;
  92         f->do_crc = 0;
  93         SHA1_Init(&f->ctx);
  94         return f;
  95 }
  96
  97 void crc32_begin(struct sha1file *f)
  98 {
  99         f->crc32 = crc32(0, Z_NULL, 0);
 100         f->do_crc = 1;
 101 }
 102
 103 uint32_t crc32_end(struct sha1file *f)
 104 {
 105         f->do_crc = 0;
 106         return f->crc32;
 107 }