Merge 1.5.1.5 in
[git] / 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)
123 {
124         z_stream stream;
125         unsigned long maxsize;
126         void *out;
127
128         memset(&stream, 0, sizeof(stream));
129         deflateInit(&stream, zlib_compression_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 }