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 update)
  33 {
  34         unsigned offset = f->offset;
  35         if (offset) {
  36                 SHA1_Update(&f->ctx, f->buffer, offset);
  37                 sha1flush(f, offset);
  38         }
  39         SHA1_Final(f->buffer, &f->ctx);
  40         if (result)
  41                 hashcpy(result, f->buffer);
  42         if (update)
  43                 sha1flush(f, 20);
  44         if (close(f->fd))
  45                 die("%s: sha1 file error on close (%s)", f->name, strerror(errno));
  46         free(f);
  47         return 0;
  48 }
  49
  50 int sha1write(struct sha1file *f, void *buf, unsigned int count)
  51 {
  52         if (f->do_crc)
  53                 f->crc32 = crc32(f->crc32, buf, count);
  54         while (count) {
  55                 unsigned offset = f->offset;
  56                 unsigned left = sizeof(f->buffer) - offset;
  57                 unsigned nr = count > left ? left : count;
  58
  59                 memcpy(f->buffer + offset, buf, nr);
  60                 count -= nr;
  61                 offset += nr;
  62                 buf = (char *) buf + nr;
  63                 left -= nr;
  64                 if (!left) {
  65                         SHA1_Update(&f->ctx, f->buffer, offset);
  66                         sha1flush(f, offset);
  67                         offset = 0;
  68                 }
  69                 f->offset = offset;
  70         }
  71         return 0;
  72 }
  73
  74 struct sha1file *sha1create(const char *fmt, ...)
  75 {
  76         struct sha1file *f;
  77         unsigned len;
  78         va_list arg;
  79         int fd;
  80
  81         f = xmalloc(sizeof(*f));
  82
  83         va_start(arg, fmt);
  84         len = vsnprintf(f->name, sizeof(f->name), fmt, arg);
  85         va_end(arg);
  86         if (len >= PATH_MAX)
  87                 die("you wascally wabbit, you");
  88         f->namelen = len;
  89
  90         fd = open(f->name, O_CREAT | O_EXCL | O_WRONLY, 0666);
  91         if (fd < 0)
  92                 die("unable to open %s (%s)", f->name, strerror(errno));
  93         f->fd = fd;
  94         f->error = 0;
  95         f->offset = 0;
  96         f->do_crc = 0;
  97         SHA1_Init(&f->ctx);
  98         return f;
  99 }
 100
 101 struct sha1file *sha1fd(int fd, const char *name)
 102 {
 103         struct sha1file *f;
 104         unsigned len;
 105
 106         f = xmalloc(sizeof(*f));
 107
 108         len = strlen(name);
 109         if (len >= PATH_MAX)
 110                 die("you wascally wabbit, you");
 111         f->namelen = len;
 112         memcpy(f->name, name, len+1);
 113
 114         f->fd = fd;
 115         f->error = 0;
 116         f->offset = 0;
 117         f->do_crc = 0;
 118         SHA1_Init(&f->ctx);
 119         return f;
 120 }
 121
 122 int sha1write_compressed(struct sha1file *f, void *in, unsigned int size, int level)
 123 {
 124         z_stream stream;
 125         unsigned long maxsize;
 126         void *out;
 127
 128         memset(&stream, 0, sizeof(stream));
 129         deflateInit(&stream, level);
 130         maxsize = deflateBound(&stream, size);
 131         out = xmalloc(maxsize);
 132
 133         /* Compress it */
 134         stream.next_in = in;
 135         stream.avail_in = size;
 136
 137         stream.next_out = out;
 138         stream.avail_out = maxsize;
 139
 140         while (deflate(&stream, Z_FINISH) == Z_OK)
 141                 /* nothing */;
 142         deflateEnd(&stream);
 143
 144         size = stream.total_out;
 145         sha1write(f, out, size);
 146         free(out);
 147         return size;
 148 }
 149
 150 void crc32_begin(struct sha1file *f)
 151 {
 152         f->crc32 = crc32(0, Z_NULL, 0);
 153         f->do_crc = 1;
 154 }
 155
 156 uint32_t crc32_end(struct sha1file *f)
 157 {
 158         f->do_crc = 0;
 159         return f->crc32;
 160 }