Andrew's git - gitweb.git/blob

   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
  13static 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
  32int 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
  52int 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
  76struct sha1file *sha1create(const char *fmt, ...)
  77{
  78        struct sha1file *f;
  79        unsigned len;
  80        va_list arg;
  81        int fd;
  82
  83        f = xmalloc(sizeof(*f));
  84
  85        va_start(arg, fmt);
  86        len = vsnprintf(f->name, sizeof(f->name), fmt, arg);
  87        va_end(arg);
  88        if (len >= PATH_MAX)
  89                die("you wascally wabbit, you");
  90        f->namelen = len;
  91
  92        fd = open(f->name, O_CREAT | O_EXCL | O_WRONLY, 0666);
  93        if (fd < 0)
  94                die("unable to open %s (%s)", f->name, strerror(errno));
  95        f->fd = fd;
  96        f->error = 0;
  97        f->offset = 0;
  98        f->do_crc = 0;
  99        SHA1_Init(&f->ctx);
 100        return f;
 101}
 102
 103struct sha1file *sha1fd(int fd, const char *name)
 104{
 105        struct sha1file *f;
 106        unsigned len;
 107
 108        f = xmalloc(sizeof(*f));
 109
 110        len = strlen(name);
 111        if (len >= PATH_MAX)
 112                die("you wascally wabbit, you");
 113        f->namelen = len;
 114        memcpy(f->name, name, len+1);
 115
 116        f->fd = fd;
 117        f->error = 0;
 118        f->offset = 0;
 119        f->do_crc = 0;
 120        SHA1_Init(&f->ctx);
 121        return f;
 122}
 123
 124int sha1write_compressed(struct sha1file *f, void *in, unsigned int size, int level)
 125{
 126        z_stream stream;
 127        unsigned long maxsize;
 128        void *out;
 129
 130        memset(&stream, 0, sizeof(stream));
 131        deflateInit(&stream, level);
 132        maxsize = deflateBound(&stream, size);
 133        out = xmalloc(maxsize);
 134
 135        /* Compress it */
 136        stream.next_in = in;
 137        stream.avail_in = size;
 138
 139        stream.next_out = out;
 140        stream.avail_out = maxsize;
 141
 142        while (deflate(&stream, Z_FINISH) == Z_OK)
 143                /* nothing */;
 144        deflateEnd(&stream);
 145
 146        size = stream.total_out;
 147        sha1write(f, out, size);
 148        free(out);
 149        return size;
 150}
 151
 152void crc32_begin(struct sha1file *f)
 153{
 154        f->crc32 = crc32(0, Z_NULL, 0);
 155        f->do_crc = 1;
 156}
 157
 158uint32_t crc32_end(struct sha1file *f)
 159{
 160        f->do_crc = 0;
 161        return f->crc32;
 162}