]>
Commit | Line | Data |
---|---|---|
0fcfd160 LT |
1 | /* |
2 | * GIT - The information manager from hell | |
3 | * | |
4 | * Copyright (C) Linus Torvalds, 2005 | |
5 | * | |
6 | * This handles basic git sha1 object files - packing, unpacking, | |
7 | * creation etc. | |
8 | */ | |
0fcfd160 | 9 | #include "cache.h" |
91d7b8af | 10 | #include "delta.h" |
0fcfd160 | 11 | |
144bde78 LT |
12 | #ifndef O_NOATIME |
13 | #if defined(__linux__) && (defined(__i386__) || defined(__PPC__)) | |
14 | #define O_NOATIME 01000000 | |
15 | #else | |
16 | #define O_NOATIME 0 | |
17 | #endif | |
18 | #endif | |
19 | ||
20 | static unsigned int sha1_file_open_flag = O_NOATIME; | |
21 | ||
0fcfd160 LT |
22 | static unsigned hexval(char c) |
23 | { | |
24 | if (c >= '0' && c <= '9') | |
25 | return c - '0'; | |
26 | if (c >= 'a' && c <= 'f') | |
27 | return c - 'a' + 10; | |
28 | if (c >= 'A' && c <= 'F') | |
29 | return c - 'A' + 10; | |
30 | return ~0; | |
31 | } | |
32 | ||
33 | int get_sha1_hex(const char *hex, unsigned char *sha1) | |
34 | { | |
35 | int i; | |
36 | for (i = 0; i < 20; i++) { | |
37 | unsigned int val = (hexval(hex[0]) << 4) | hexval(hex[1]); | |
38 | if (val & ~0xff) | |
39 | return -1; | |
40 | *sha1++ = val; | |
41 | hex += 2; | |
42 | } | |
43 | return 0; | |
44 | } | |
45 | ||
e99d59ff | 46 | static int get_sha1_file(const char *path, unsigned char *result) |
3c249c95 LT |
47 | { |
48 | char buffer[60]; | |
49 | int fd = open(path, O_RDONLY); | |
50 | int len; | |
51 | ||
52 | if (fd < 0) | |
53 | return -1; | |
54 | len = read(fd, buffer, sizeof(buffer)); | |
55 | close(fd); | |
56 | if (len < 40) | |
57 | return -1; | |
58 | return get_sha1_hex(buffer, result); | |
59 | } | |
60 | ||
8ac069ac JH |
61 | static char *git_dir, *git_object_dir, *git_index_file; |
62 | static void setup_git_env(void) | |
63 | { | |
64 | git_dir = gitenv(GIT_DIR_ENVIRONMENT); | |
65 | if (!git_dir) | |
66 | git_dir = DEFAULT_GIT_DIR_ENVIRONMENT; | |
67 | git_object_dir = gitenv(DB_ENVIRONMENT); | |
68 | if (!git_object_dir) { | |
69 | git_object_dir = xmalloc(strlen(git_dir) + 9); | |
70 | sprintf(git_object_dir, "%s/objects", git_dir); | |
71 | } | |
72 | git_index_file = gitenv(INDEX_ENVIRONMENT); | |
73 | if (!git_index_file) { | |
74 | git_index_file = xmalloc(strlen(git_dir) + 7); | |
75 | sprintf(git_index_file, "%s/index", git_dir); | |
76 | } | |
77 | } | |
78 | ||
79 | char *get_object_directory(void) | |
80 | { | |
81 | if (!git_object_dir) | |
82 | setup_git_env(); | |
83 | return git_object_dir; | |
84 | } | |
85 | ||
86 | char *get_index_file(void) | |
87 | { | |
88 | if (!git_index_file) | |
89 | setup_git_env(); | |
90 | return git_index_file; | |
91 | } | |
92 | ||
3c249c95 LT |
93 | int get_sha1(const char *str, unsigned char *sha1) |
94 | { | |
95 | static char pathname[PATH_MAX]; | |
35ad3382 LT |
96 | static const char *prefix[] = { |
97 | "", | |
98 | "refs", | |
99 | "refs/tags", | |
100 | "refs/heads", | |
101 | "refs/snap", | |
102 | NULL | |
103 | }; | |
35ad3382 | 104 | const char **p; |
3c249c95 LT |
105 | |
106 | if (!get_sha1_hex(str, sha1)) | |
107 | return 0; | |
35ad3382 | 108 | |
8ac069ac JH |
109 | if (!git_dir) |
110 | setup_git_env(); | |
35ad3382 | 111 | for (p = prefix; *p; p++) { |
8ac069ac JH |
112 | snprintf(pathname, sizeof(pathname), "%s/%s/%s", |
113 | git_dir, *p, str); | |
35ad3382 LT |
114 | if (!get_sha1_file(pathname, sha1)) |
115 | return 0; | |
116 | } | |
117 | ||
3c249c95 LT |
118 | return -1; |
119 | } | |
120 | ||
0fcfd160 LT |
121 | char * sha1_to_hex(const unsigned char *sha1) |
122 | { | |
123 | static char buffer[50]; | |
124 | static const char hex[] = "0123456789abcdef"; | |
125 | char *buf = buffer; | |
126 | int i; | |
127 | ||
128 | for (i = 0; i < 20; i++) { | |
129 | unsigned int val = *sha1++; | |
130 | *buf++ = hex[val >> 4]; | |
131 | *buf++ = hex[val & 0xf]; | |
132 | } | |
133 | return buffer; | |
134 | } | |
135 | ||
ace1534d JH |
136 | static void fill_sha1_path(char *pathbuf, const unsigned char *sha1) |
137 | { | |
138 | int i; | |
139 | for (i = 0; i < 20; i++) { | |
140 | static char hex[] = "0123456789abcdef"; | |
141 | unsigned int val = sha1[i]; | |
142 | char *pos = pathbuf + i*2 + (i > 0); | |
143 | *pos++ = hex[val >> 4]; | |
144 | *pos = hex[val & 0xf]; | |
145 | } | |
146 | } | |
147 | ||
0fcfd160 LT |
148 | /* |
149 | * NOTE! This returns a statically allocated buffer, so you have to be | |
150 | * careful about using it. Do a "strdup()" if you need to save the | |
151 | * filename. | |
ace1534d JH |
152 | * |
153 | * Also note that this returns the location for creating. Reading | |
154 | * SHA1 file can happen from any alternate directory listed in the | |
d19938ab | 155 | * DB_ENVIRONMENT environment variable if it is not found in |
ace1534d | 156 | * the primary object database. |
0fcfd160 LT |
157 | */ |
158 | char *sha1_file_name(const unsigned char *sha1) | |
159 | { | |
0fcfd160 LT |
160 | static char *name, *base; |
161 | ||
162 | if (!base) { | |
d19938ab | 163 | const char *sha1_file_directory = get_object_directory(); |
0fcfd160 | 164 | int len = strlen(sha1_file_directory); |
812666c8 | 165 | base = xmalloc(len + 60); |
0fcfd160 LT |
166 | memcpy(base, sha1_file_directory, len); |
167 | memset(base+len, 0, 60); | |
168 | base[len] = '/'; | |
169 | base[len+3] = '/'; | |
170 | name = base + len + 1; | |
171 | } | |
ace1534d | 172 | fill_sha1_path(name, sha1); |
0fcfd160 LT |
173 | return base; |
174 | } | |
175 | ||
ddd5d056 | 176 | static struct alternate_object_database { |
ace1534d JH |
177 | char *base; |
178 | char *name; | |
179 | } *alt_odb; | |
180 | ||
ddd5d056 JH |
181 | /* |
182 | * Prepare alternate object database registry. | |
183 | * alt_odb points at an array of struct alternate_object_database. | |
184 | * This array is terminated with an element that has both its base | |
185 | * and name set to NULL. alt_odb[n] comes from n'th non-empty | |
d19938ab | 186 | * element from colon separated ALTERNATE_DB_ENVIRONMENT environment |
ddd5d056 JH |
187 | * variable, and its base points at a statically allocated buffer |
188 | * that contains "/the/directory/corresponding/to/.git/objects/...", | |
189 | * while its name points just after the slash at the end of | |
190 | * ".git/objects/" in the example above, and has enough space to hold | |
191 | * 40-byte hex SHA1, an extra slash for the first level indirection, | |
192 | * and the terminating NUL. | |
193 | * This function allocates the alt_odb array and all the strings | |
194 | * pointed by base fields of the array elements with one xmalloc(); | |
195 | * the string pool immediately follows the array. | |
196 | */ | |
ace1534d JH |
197 | static void prepare_alt_odb(void) |
198 | { | |
199 | int pass, totlen, i; | |
ace1534d | 200 | const char *cp, *last; |
e99d59ff | 201 | char *op = NULL; |
d19938ab | 202 | const char *alt = gitenv(ALTERNATE_DB_ENVIRONMENT) ? : ""; |
ace1534d | 203 | |
ddd5d056 JH |
204 | /* The first pass counts how large an area to allocate to |
205 | * hold the entire alt_odb structure, including array of | |
206 | * structs and path buffers for them. The second pass fills | |
207 | * the structure and prepares the path buffers for use by | |
208 | * fill_sha1_path(). | |
209 | */ | |
ace1534d JH |
210 | for (totlen = pass = 0; pass < 2; pass++) { |
211 | last = alt; | |
212 | i = 0; | |
213 | do { | |
214 | cp = strchr(last, ':') ? : last + strlen(last); | |
215 | if (last != cp) { | |
216 | /* 43 = 40-byte + 2 '/' + terminating NUL */ | |
217 | int pfxlen = cp - last; | |
218 | int entlen = pfxlen + 43; | |
219 | if (pass == 0) | |
220 | totlen += entlen; | |
221 | else { | |
222 | alt_odb[i].base = op; | |
223 | alt_odb[i].name = op + pfxlen + 1; | |
224 | memcpy(op, last, pfxlen); | |
225 | op[pfxlen] = op[pfxlen + 3] = '/'; | |
226 | op[entlen-1] = 0; | |
227 | op += entlen; | |
228 | } | |
229 | i++; | |
230 | } | |
231 | while (*cp && *cp == ':') | |
232 | cp++; | |
233 | last = cp; | |
234 | } while (*cp); | |
235 | if (pass) | |
236 | break; | |
ddd5d056 | 237 | alt_odb = xmalloc(sizeof(*alt_odb) * (i + 1) + totlen); |
e99d59ff | 238 | alt_odb[i].base = alt_odb[i].name = NULL; |
ace1534d JH |
239 | op = (char*)(&alt_odb[i+1]); |
240 | } | |
241 | } | |
242 | ||
243 | static char *find_sha1_file(const unsigned char *sha1, struct stat *st) | |
244 | { | |
245 | int i; | |
246 | char *name = sha1_file_name(sha1); | |
247 | ||
248 | if (!stat(name, st)) | |
249 | return name; | |
250 | if (!alt_odb) | |
251 | prepare_alt_odb(); | |
252 | for (i = 0; (name = alt_odb[i].name) != NULL; i++) { | |
253 | fill_sha1_path(name, sha1); | |
254 | if (!stat(alt_odb[i].base, st)) | |
255 | return alt_odb[i].base; | |
256 | } | |
257 | return NULL; | |
258 | } | |
259 | ||
d98b46f8 | 260 | int check_sha1_signature(unsigned char *sha1, void *map, unsigned long size, const char *type) |
0fcfd160 | 261 | { |
d98b46f8 | 262 | char header[100]; |
0fcfd160 LT |
263 | unsigned char real_sha1[20]; |
264 | SHA_CTX c; | |
265 | ||
266 | SHA1_Init(&c); | |
d98b46f8 | 267 | SHA1_Update(&c, header, 1+sprintf(header, "%s %lu", type, size)); |
0fcfd160 LT |
268 | SHA1_Update(&c, map, size); |
269 | SHA1_Final(real_sha1, &c); | |
270 | return memcmp(sha1, real_sha1, 20) ? -1 : 0; | |
271 | } | |
272 | ||
273 | void *map_sha1_file(const unsigned char *sha1, unsigned long *size) | |
274 | { | |
0fcfd160 LT |
275 | struct stat st; |
276 | void *map; | |
144bde78 | 277 | int fd; |
ace1534d JH |
278 | char *filename = find_sha1_file(sha1, &st); |
279 | ||
280 | if (!filename) { | |
281 | error("cannot map sha1 file %s", sha1_to_hex(sha1)); | |
282 | return NULL; | |
283 | } | |
0fcfd160 | 284 | |
144bde78 | 285 | fd = open(filename, O_RDONLY | sha1_file_open_flag); |
0fcfd160 | 286 | if (fd < 0) { |
144bde78 LT |
287 | /* See if it works without O_NOATIME */ |
288 | switch (sha1_file_open_flag) { | |
289 | default: | |
290 | fd = open(filename, O_RDONLY); | |
291 | if (fd >= 0) | |
292 | break; | |
293 | /* Fallthrough */ | |
294 | case 0: | |
295 | perror(filename); | |
296 | return NULL; | |
297 | } | |
298 | ||
299 | /* If it failed once, it will probably fail again. Stop using O_NOATIME */ | |
300 | sha1_file_open_flag = 0; | |
0fcfd160 | 301 | } |
0fcfd160 LT |
302 | map = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0); |
303 | close(fd); | |
304 | if (-1 == (int)(long)map) | |
305 | return NULL; | |
306 | *size = st.st_size; | |
307 | return map; | |
308 | } | |
309 | ||
c4483576 LT |
310 | int unpack_sha1_header(z_stream *stream, void *map, unsigned long mapsize, void *buffer, unsigned long size) |
311 | { | |
312 | /* Get the data stream */ | |
313 | memset(stream, 0, sizeof(*stream)); | |
314 | stream->next_in = map; | |
315 | stream->avail_in = mapsize; | |
316 | stream->next_out = buffer; | |
317 | stream->avail_out = size; | |
318 | ||
319 | inflateInit(stream); | |
320 | return inflate(stream, 0); | |
321 | } | |
322 | ||
0fcfd160 LT |
323 | void * unpack_sha1_file(void *map, unsigned long mapsize, char *type, unsigned long *size) |
324 | { | |
325 | int ret, bytes; | |
326 | z_stream stream; | |
327 | char buffer[8192]; | |
bf0f910d | 328 | unsigned char *buf; |
0fcfd160 | 329 | |
c4483576 LT |
330 | ret = unpack_sha1_header(&stream, map, mapsize, buffer, sizeof(buffer)); |
331 | if (ret < Z_OK || sscanf(buffer, "%10s %lu", type, size) != 2) | |
0fcfd160 LT |
332 | return NULL; |
333 | ||
334 | bytes = strlen(buffer) + 1; | |
e871b649 | 335 | buf = xmalloc(1+*size); |
0fcfd160 LT |
336 | |
337 | memcpy(buf, buffer + bytes, stream.total_out - bytes); | |
338 | bytes = stream.total_out - bytes; | |
339 | if (bytes < *size && ret == Z_OK) { | |
340 | stream.next_out = buf + bytes; | |
341 | stream.avail_out = *size - bytes; | |
342 | while (inflate(&stream, Z_FINISH) == Z_OK) | |
343 | /* nothing */; | |
344 | } | |
e871b649 | 345 | buf[*size] = 0; |
0fcfd160 LT |
346 | inflateEnd(&stream); |
347 | return buf; | |
348 | } | |
349 | ||
350 | void * read_sha1_file(const unsigned char *sha1, char *type, unsigned long *size) | |
351 | { | |
352 | unsigned long mapsize; | |
353 | void *map, *buf; | |
354 | ||
355 | map = map_sha1_file(sha1, &mapsize); | |
356 | if (map) { | |
357 | buf = unpack_sha1_file(map, mapsize, type, size); | |
358 | munmap(map, mapsize); | |
91d7b8af NP |
359 | if (buf && !strcmp(type, "delta")) { |
360 | void *ref = NULL, *delta = buf; | |
361 | unsigned long ref_size, delta_size = *size; | |
362 | buf = NULL; | |
363 | if (delta_size > 20) | |
364 | ref = read_sha1_file(delta, type, &ref_size); | |
365 | if (ref) | |
366 | buf = patch_delta(ref, ref_size, | |
367 | delta+20, delta_size-20, | |
368 | size); | |
369 | free(delta); | |
370 | free(ref); | |
371 | } | |
0fcfd160 LT |
372 | return buf; |
373 | } | |
374 | return NULL; | |
375 | } | |
376 | ||
40469ee9 | 377 | void *read_object_with_reference(const unsigned char *sha1, |
bf0f910d | 378 | const char *required_type, |
40469ee9 JH |
379 | unsigned long *size, |
380 | unsigned char *actual_sha1_return) | |
f4913f91 JH |
381 | { |
382 | char type[20]; | |
383 | void *buffer; | |
384 | unsigned long isize; | |
40469ee9 | 385 | unsigned char actual_sha1[20]; |
f4913f91 | 386 | |
40469ee9 JH |
387 | memcpy(actual_sha1, sha1, 20); |
388 | while (1) { | |
389 | int ref_length = -1; | |
390 | const char *ref_type = NULL; | |
f4913f91 | 391 | |
40469ee9 JH |
392 | buffer = read_sha1_file(actual_sha1, type, &isize); |
393 | if (!buffer) | |
394 | return NULL; | |
395 | if (!strcmp(type, required_type)) { | |
396 | *size = isize; | |
397 | if (actual_sha1_return) | |
398 | memcpy(actual_sha1_return, actual_sha1, 20); | |
399 | return buffer; | |
400 | } | |
401 | /* Handle references */ | |
402 | else if (!strcmp(type, "commit")) | |
403 | ref_type = "tree "; | |
404 | else if (!strcmp(type, "tag")) | |
405 | ref_type = "object "; | |
406 | else { | |
407 | free(buffer); | |
408 | return NULL; | |
409 | } | |
410 | ref_length = strlen(ref_type); | |
f4913f91 | 411 | |
40469ee9 JH |
412 | if (memcmp(buffer, ref_type, ref_length) || |
413 | get_sha1_hex(buffer + ref_length, actual_sha1)) { | |
414 | free(buffer); | |
415 | return NULL; | |
416 | } | |
417 | /* Now we have the ID of the referred-to object in | |
418 | * actual_sha1. Check again. */ | |
f4913f91 | 419 | } |
f4913f91 JH |
420 | } |
421 | ||
bf0f910d | 422 | int write_sha1_file(void *buf, unsigned long len, const char *type, unsigned char *returnsha1) |
0fcfd160 LT |
423 | { |
424 | int size; | |
bf0f910d | 425 | unsigned char *compressed; |
0fcfd160 LT |
426 | z_stream stream; |
427 | unsigned char sha1[20]; | |
428 | SHA_CTX c; | |
706bc531 | 429 | char *filename; |
aac17941 | 430 | static char tmpfile[PATH_MAX]; |
bf0f910d | 431 | unsigned char hdr[50]; |
aac17941 | 432 | int fd, hdrlen, ret; |
a44c9a5e LT |
433 | |
434 | /* Generate the header */ | |
bf0f910d | 435 | hdrlen = sprintf((char *)hdr, "%s %lu", type, len)+1; |
0fcfd160 | 436 | |
d98b46f8 LT |
437 | /* Sha1.. */ |
438 | SHA1_Init(&c); | |
a44c9a5e | 439 | SHA1_Update(&c, hdr, hdrlen); |
d98b46f8 LT |
440 | SHA1_Update(&c, buf, len); |
441 | SHA1_Final(sha1, &c); | |
442 | ||
706bc531 LT |
443 | if (returnsha1) |
444 | memcpy(returnsha1, sha1, 20); | |
445 | ||
446 | filename = sha1_file_name(sha1); | |
aac17941 LT |
447 | fd = open(filename, O_RDONLY); |
448 | if (fd >= 0) { | |
706bc531 | 449 | /* |
aac17941 LT |
450 | * FIXME!!! We might do collision checking here, but we'd |
451 | * need to uncompress the old file and check it. Later. | |
706bc531 | 452 | */ |
aac17941 | 453 | close(fd); |
706bc531 LT |
454 | return 0; |
455 | } | |
456 | ||
aac17941 LT |
457 | if (errno != ENOENT) { |
458 | fprintf(stderr, "sha1 file %s: %s", filename, strerror(errno)); | |
459 | return -1; | |
460 | } | |
461 | ||
462 | snprintf(tmpfile, sizeof(tmpfile), "%s/obj_XXXXXX", get_object_directory()); | |
ace1534d | 463 | |
aac17941 LT |
464 | fd = mkstemp(tmpfile); |
465 | if (fd < 0) { | |
466 | fprintf(stderr, "unable to create temporary sha1 filename %s: %s", tmpfile, strerror(errno)); | |
467 | return -1; | |
468 | } | |
469 | ||
0fcfd160 LT |
470 | /* Set it up */ |
471 | memset(&stream, 0, sizeof(stream)); | |
472 | deflateInit(&stream, Z_BEST_COMPRESSION); | |
a44c9a5e | 473 | size = deflateBound(&stream, len+hdrlen); |
812666c8 | 474 | compressed = xmalloc(size); |
0fcfd160 LT |
475 | |
476 | /* Compress it */ | |
0fcfd160 LT |
477 | stream.next_out = compressed; |
478 | stream.avail_out = size; | |
a44c9a5e LT |
479 | |
480 | /* First header.. */ | |
481 | stream.next_in = hdr; | |
482 | stream.avail_in = hdrlen; | |
483 | while (deflate(&stream, 0) == Z_OK) | |
6ffcee88 | 484 | /* nothing */; |
a44c9a5e LT |
485 | |
486 | /* Then the data itself.. */ | |
487 | stream.next_in = buf; | |
488 | stream.avail_in = len; | |
0fcfd160 LT |
489 | while (deflate(&stream, Z_FINISH) == Z_OK) |
490 | /* nothing */; | |
491 | deflateEnd(&stream); | |
492 | size = stream.total_out; | |
493 | ||
706bc531 LT |
494 | if (write(fd, compressed, size) != size) |
495 | die("unable to write file"); | |
aac17941 | 496 | fchmod(fd, 0444); |
706bc531 | 497 | close(fd); |
383f85b7 | 498 | free(compressed); |
0fcfd160 | 499 | |
aac17941 | 500 | ret = link(tmpfile, filename); |
a31c6d02 | 501 | if (ret < 0) { |
aac17941 | 502 | ret = errno; |
a31c6d02 LT |
503 | |
504 | /* | |
505 | * Coda hack - coda doesn't like cross-directory links, | |
506 | * so we fall back to a rename, which will mean that it | |
507 | * won't be able to check collisions, but that's not a | |
508 | * big deal. | |
509 | * | |
510 | * When this succeeds, we just return 0. We have nothing | |
511 | * left to unlink. | |
512 | */ | |
513 | if (ret == EXDEV && !rename(tmpfile, filename)) | |
514 | return 0; | |
515 | } | |
aac17941 LT |
516 | unlink(tmpfile); |
517 | if (ret) { | |
518 | if (ret != EEXIST) { | |
519 | fprintf(stderr, "unable to write sha1 filename %s: %s", filename, strerror(ret)); | |
0fcfd160 | 520 | return -1; |
aac17941 LT |
521 | } |
522 | /* FIXME!!! Collision check here ? */ | |
0fcfd160 | 523 | } |
aac17941 | 524 | |
0fcfd160 LT |
525 | return 0; |
526 | } | |
8237b185 DB |
527 | |
528 | int write_sha1_from_fd(const unsigned char *sha1, int fd) | |
529 | { | |
530 | char *filename = sha1_file_name(sha1); | |
531 | ||
532 | int local; | |
533 | z_stream stream; | |
534 | unsigned char real_sha1[20]; | |
bf0f910d BG |
535 | unsigned char buf[4096]; |
536 | unsigned char discard[4096]; | |
8237b185 DB |
537 | int ret; |
538 | SHA_CTX c; | |
539 | ||
540 | local = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0666); | |
541 | ||
542 | if (local < 0) | |
543 | return error("Couldn't open %s\n", filename); | |
544 | ||
545 | memset(&stream, 0, sizeof(stream)); | |
546 | ||
547 | inflateInit(&stream); | |
548 | ||
549 | SHA1_Init(&c); | |
550 | ||
551 | do { | |
552 | ssize_t size; | |
553 | size = read(fd, buf, 4096); | |
554 | if (size <= 0) { | |
555 | close(local); | |
556 | unlink(filename); | |
557 | if (!size) | |
558 | return error("Connection closed?"); | |
559 | perror("Reading from connection"); | |
560 | return -1; | |
561 | } | |
562 | write(local, buf, size); | |
563 | stream.avail_in = size; | |
564 | stream.next_in = buf; | |
565 | do { | |
566 | stream.next_out = discard; | |
567 | stream.avail_out = sizeof(discard); | |
568 | ret = inflate(&stream, Z_SYNC_FLUSH); | |
569 | SHA1_Update(&c, discard, sizeof(discard) - | |
570 | stream.avail_out); | |
571 | } while (stream.avail_in && ret == Z_OK); | |
572 | ||
573 | } while (ret == Z_OK); | |
574 | inflateEnd(&stream); | |
575 | ||
576 | close(local); | |
577 | SHA1_Final(real_sha1, &c); | |
578 | if (ret != Z_STREAM_END) { | |
579 | unlink(filename); | |
580 | return error("File %s corrupted", sha1_to_hex(sha1)); | |
581 | } | |
582 | if (memcmp(sha1, real_sha1, 20)) { | |
583 | unlink(filename); | |
584 | return error("File %s has bad hash\n", sha1_to_hex(sha1)); | |
585 | } | |
586 | ||
587 | return 0; | |
588 | } | |
589 | ||
590 | int has_sha1_file(const unsigned char *sha1) | |
591 | { | |
8237b185 | 592 | struct stat st; |
ace1534d | 593 | return !!find_sha1_file(sha1, &st); |
8237b185 | 594 | } |
74400e71 JH |
595 | |
596 | int index_fd(unsigned char *sha1, int fd, struct stat *st) | |
597 | { | |
74400e71 | 598 | unsigned long size = st->st_size; |
aac17941 LT |
599 | void *buf; |
600 | int ret; | |
74400e71 | 601 | |
aac17941 | 602 | buf = ""; |
74400e71 | 603 | if (size) |
aac17941 | 604 | buf = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0); |
74400e71 | 605 | close(fd); |
aac17941 | 606 | if ((int)(long)buf == -1) |
74400e71 JH |
607 | return -1; |
608 | ||
aac17941 LT |
609 | ret = write_sha1_file(buf, size, "blob", sha1); |
610 | if (size) | |
611 | munmap(buf, size); | |
612 | return ret; | |
74400e71 | 613 | } |