Code

Merge branch 'jc/rebase-limit'
[git.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"
13 static int sha1flush(struct sha1file *f, unsigned int count)
14 {
15         void *buf = f->buffer;
17         for (;;) {
18                 int ret = xwrite(f->fd, buf, count);
19                 if (ret > 0) {
20                         buf += ret;
21                         count -= ret;
22                         if (count)
23                                 continue;
24                         return 0;
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 }
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                 memcpy(result, f->buffer, 20);
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 }
50 int sha1write(struct sha1file *f, void *buf, unsigned int count)
51 {
52         while (count) {
53                 unsigned offset = f->offset;
54                 unsigned left = sizeof(f->buffer) - offset;
55                 unsigned nr = count > left ? left : count;
57                 memcpy(f->buffer + offset, buf, nr);
58                 count -= nr;
59                 offset += nr;
60                 buf += nr;
61                 left -= nr;
62                 if (!left) {
63                         SHA1_Update(&f->ctx, f->buffer, offset);
64                         sha1flush(f, offset);
65                         offset = 0;
66                 }
67                 f->offset = offset;
68         }
69         return 0;
70 }
72 struct sha1file *sha1create(const char *fmt, ...)
73 {
74         struct sha1file *f;
75         unsigned len;
76         va_list arg;
77         int fd;
79         f = xmalloc(sizeof(*f));
81         va_start(arg, fmt);
82         len = vsnprintf(f->name, sizeof(f->name), fmt, arg);
83         va_end(arg);
84         if (len >= PATH_MAX)
85                 die("you wascally wabbit, you");
86         f->namelen = len;
88         fd = open(f->name, O_CREAT | O_EXCL | O_WRONLY, 0666);
89         if (fd < 0)
90                 die("unable to open %s (%s)", f->name, strerror(errno));
91         f->fd = fd;
92         f->error = 0;
93         f->offset = 0;
94         SHA1_Init(&f->ctx);
95         return f;
96 }
98 struct sha1file *sha1fd(int fd, const char *name)
99 {
100         struct sha1file *f;
101         unsigned len;
103         f = xmalloc(sizeof(*f));
105         len = strlen(name);
106         if (len >= PATH_MAX)
107                 die("you wascally wabbit, you");
108         f->namelen = len;
109         memcpy(f->name, name, len+1);
111         f->fd = fd;
112         f->error = 0;
113         f->offset = 0;
114         SHA1_Init(&f->ctx);
115         return f;
118 int sha1write_compressed(struct sha1file *f, void *in, unsigned int size)
120         z_stream stream;
121         unsigned long maxsize;
122         void *out;
124         memset(&stream, 0, sizeof(stream));
125         deflateInit(&stream, Z_DEFAULT_COMPRESSION);
126         maxsize = deflateBound(&stream, size);
127         out = xmalloc(maxsize);
129         /* Compress it */
130         stream.next_in = in;
131         stream.avail_in = size;
133         stream.next_out = out;
134         stream.avail_out = maxsize;
136         while (deflate(&stream, Z_FINISH) == Z_OK)
137                 /* nothing */;
138         deflateEnd(&stream);
140         size = stream.total_out;
141         sha1write(f, out, size);
142         free(out);
143         return size;