]>
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 | ||
310 | void * unpack_sha1_file(void *map, unsigned long mapsize, char *type, unsigned long *size) | |
311 | { | |
312 | int ret, bytes; | |
313 | z_stream stream; | |
314 | char buffer[8192]; | |
bf0f910d | 315 | unsigned char *buf; |
0fcfd160 LT |
316 | |
317 | /* Get the data stream */ | |
318 | memset(&stream, 0, sizeof(stream)); | |
319 | stream.next_in = map; | |
320 | stream.avail_in = mapsize; | |
bf0f910d | 321 | stream.next_out = (unsigned char *)buffer; |
0fcfd160 LT |
322 | stream.avail_out = sizeof(buffer); |
323 | ||
324 | inflateInit(&stream); | |
325 | ret = inflate(&stream, 0); | |
a44c9a5e LT |
326 | if (ret < Z_OK) |
327 | return NULL; | |
0fcfd160 LT |
328 | if (sscanf(buffer, "%10s %lu", type, size) != 2) |
329 | return NULL; | |
330 | ||
331 | bytes = strlen(buffer) + 1; | |
e871b649 | 332 | buf = xmalloc(1+*size); |
0fcfd160 LT |
333 | |
334 | memcpy(buf, buffer + bytes, stream.total_out - bytes); | |
335 | bytes = stream.total_out - bytes; | |
336 | if (bytes < *size && ret == Z_OK) { | |
337 | stream.next_out = buf + bytes; | |
338 | stream.avail_out = *size - bytes; | |
339 | while (inflate(&stream, Z_FINISH) == Z_OK) | |
340 | /* nothing */; | |
341 | } | |
e871b649 | 342 | buf[*size] = 0; |
0fcfd160 LT |
343 | inflateEnd(&stream); |
344 | return buf; | |
345 | } | |
346 | ||
347 | void * read_sha1_file(const unsigned char *sha1, char *type, unsigned long *size) | |
348 | { | |
349 | unsigned long mapsize; | |
350 | void *map, *buf; | |
351 | ||
352 | map = map_sha1_file(sha1, &mapsize); | |
353 | if (map) { | |
354 | buf = unpack_sha1_file(map, mapsize, type, size); | |
355 | munmap(map, mapsize); | |
91d7b8af NP |
356 | if (buf && !strcmp(type, "delta")) { |
357 | void *ref = NULL, *delta = buf; | |
358 | unsigned long ref_size, delta_size = *size; | |
359 | buf = NULL; | |
360 | if (delta_size > 20) | |
361 | ref = read_sha1_file(delta, type, &ref_size); | |
362 | if (ref) | |
363 | buf = patch_delta(ref, ref_size, | |
364 | delta+20, delta_size-20, | |
365 | size); | |
366 | free(delta); | |
367 | free(ref); | |
368 | } | |
0fcfd160 LT |
369 | return buf; |
370 | } | |
371 | return NULL; | |
372 | } | |
373 | ||
40469ee9 | 374 | void *read_object_with_reference(const unsigned char *sha1, |
bf0f910d | 375 | const char *required_type, |
40469ee9 JH |
376 | unsigned long *size, |
377 | unsigned char *actual_sha1_return) | |
f4913f91 JH |
378 | { |
379 | char type[20]; | |
380 | void *buffer; | |
381 | unsigned long isize; | |
40469ee9 | 382 | unsigned char actual_sha1[20]; |
f4913f91 | 383 | |
40469ee9 JH |
384 | memcpy(actual_sha1, sha1, 20); |
385 | while (1) { | |
386 | int ref_length = -1; | |
387 | const char *ref_type = NULL; | |
f4913f91 | 388 | |
40469ee9 JH |
389 | buffer = read_sha1_file(actual_sha1, type, &isize); |
390 | if (!buffer) | |
391 | return NULL; | |
392 | if (!strcmp(type, required_type)) { | |
393 | *size = isize; | |
394 | if (actual_sha1_return) | |
395 | memcpy(actual_sha1_return, actual_sha1, 20); | |
396 | return buffer; | |
397 | } | |
398 | /* Handle references */ | |
399 | else if (!strcmp(type, "commit")) | |
400 | ref_type = "tree "; | |
401 | else if (!strcmp(type, "tag")) | |
402 | ref_type = "object "; | |
403 | else { | |
404 | free(buffer); | |
405 | return NULL; | |
406 | } | |
407 | ref_length = strlen(ref_type); | |
f4913f91 | 408 | |
40469ee9 JH |
409 | if (memcmp(buffer, ref_type, ref_length) || |
410 | get_sha1_hex(buffer + ref_length, actual_sha1)) { | |
411 | free(buffer); | |
412 | return NULL; | |
413 | } | |
414 | /* Now we have the ID of the referred-to object in | |
415 | * actual_sha1. Check again. */ | |
f4913f91 | 416 | } |
f4913f91 JH |
417 | } |
418 | ||
bf0f910d | 419 | int write_sha1_file(void *buf, unsigned long len, const char *type, unsigned char *returnsha1) |
0fcfd160 LT |
420 | { |
421 | int size; | |
bf0f910d | 422 | unsigned char *compressed; |
0fcfd160 LT |
423 | z_stream stream; |
424 | unsigned char sha1[20]; | |
425 | SHA_CTX c; | |
706bc531 | 426 | char *filename; |
aac17941 | 427 | static char tmpfile[PATH_MAX]; |
bf0f910d | 428 | unsigned char hdr[50]; |
aac17941 | 429 | int fd, hdrlen, ret; |
a44c9a5e LT |
430 | |
431 | /* Generate the header */ | |
bf0f910d | 432 | hdrlen = sprintf((char *)hdr, "%s %lu", type, len)+1; |
0fcfd160 | 433 | |
d98b46f8 LT |
434 | /* Sha1.. */ |
435 | SHA1_Init(&c); | |
a44c9a5e | 436 | SHA1_Update(&c, hdr, hdrlen); |
d98b46f8 LT |
437 | SHA1_Update(&c, buf, len); |
438 | SHA1_Final(sha1, &c); | |
439 | ||
706bc531 LT |
440 | if (returnsha1) |
441 | memcpy(returnsha1, sha1, 20); | |
442 | ||
443 | filename = sha1_file_name(sha1); | |
aac17941 LT |
444 | fd = open(filename, O_RDONLY); |
445 | if (fd >= 0) { | |
706bc531 | 446 | /* |
aac17941 LT |
447 | * FIXME!!! We might do collision checking here, but we'd |
448 | * need to uncompress the old file and check it. Later. | |
706bc531 | 449 | */ |
aac17941 | 450 | close(fd); |
706bc531 LT |
451 | return 0; |
452 | } | |
453 | ||
aac17941 LT |
454 | if (errno != ENOENT) { |
455 | fprintf(stderr, "sha1 file %s: %s", filename, strerror(errno)); | |
456 | return -1; | |
457 | } | |
458 | ||
459 | snprintf(tmpfile, sizeof(tmpfile), "%s/obj_XXXXXX", get_object_directory()); | |
ace1534d | 460 | |
aac17941 LT |
461 | fd = mkstemp(tmpfile); |
462 | if (fd < 0) { | |
463 | fprintf(stderr, "unable to create temporary sha1 filename %s: %s", tmpfile, strerror(errno)); | |
464 | return -1; | |
465 | } | |
466 | ||
0fcfd160 LT |
467 | /* Set it up */ |
468 | memset(&stream, 0, sizeof(stream)); | |
469 | deflateInit(&stream, Z_BEST_COMPRESSION); | |
a44c9a5e | 470 | size = deflateBound(&stream, len+hdrlen); |
812666c8 | 471 | compressed = xmalloc(size); |
0fcfd160 LT |
472 | |
473 | /* Compress it */ | |
0fcfd160 LT |
474 | stream.next_out = compressed; |
475 | stream.avail_out = size; | |
a44c9a5e LT |
476 | |
477 | /* First header.. */ | |
478 | stream.next_in = hdr; | |
479 | stream.avail_in = hdrlen; | |
480 | while (deflate(&stream, 0) == Z_OK) | |
6ffcee88 | 481 | /* nothing */; |
a44c9a5e LT |
482 | |
483 | /* Then the data itself.. */ | |
484 | stream.next_in = buf; | |
485 | stream.avail_in = len; | |
0fcfd160 LT |
486 | while (deflate(&stream, Z_FINISH) == Z_OK) |
487 | /* nothing */; | |
488 | deflateEnd(&stream); | |
489 | size = stream.total_out; | |
490 | ||
706bc531 LT |
491 | if (write(fd, compressed, size) != size) |
492 | die("unable to write file"); | |
aac17941 | 493 | fchmod(fd, 0444); |
706bc531 | 494 | close(fd); |
383f85b7 | 495 | free(compressed); |
0fcfd160 | 496 | |
aac17941 | 497 | ret = link(tmpfile, filename); |
a31c6d02 | 498 | if (ret < 0) { |
aac17941 | 499 | ret = errno; |
a31c6d02 LT |
500 | |
501 | /* | |
502 | * Coda hack - coda doesn't like cross-directory links, | |
503 | * so we fall back to a rename, which will mean that it | |
504 | * won't be able to check collisions, but that's not a | |
505 | * big deal. | |
506 | * | |
507 | * When this succeeds, we just return 0. We have nothing | |
508 | * left to unlink. | |
509 | */ | |
510 | if (ret == EXDEV && !rename(tmpfile, filename)) | |
511 | return 0; | |
512 | } | |
aac17941 LT |
513 | unlink(tmpfile); |
514 | if (ret) { | |
515 | if (ret != EEXIST) { | |
516 | fprintf(stderr, "unable to write sha1 filename %s: %s", filename, strerror(ret)); | |
0fcfd160 | 517 | return -1; |
aac17941 LT |
518 | } |
519 | /* FIXME!!! Collision check here ? */ | |
0fcfd160 | 520 | } |
aac17941 | 521 | |
0fcfd160 LT |
522 | return 0; |
523 | } | |
8237b185 DB |
524 | |
525 | int write_sha1_from_fd(const unsigned char *sha1, int fd) | |
526 | { | |
527 | char *filename = sha1_file_name(sha1); | |
528 | ||
529 | int local; | |
530 | z_stream stream; | |
531 | unsigned char real_sha1[20]; | |
bf0f910d BG |
532 | unsigned char buf[4096]; |
533 | unsigned char discard[4096]; | |
8237b185 DB |
534 | int ret; |
535 | SHA_CTX c; | |
536 | ||
537 | local = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0666); | |
538 | ||
539 | if (local < 0) | |
540 | return error("Couldn't open %s\n", filename); | |
541 | ||
542 | memset(&stream, 0, sizeof(stream)); | |
543 | ||
544 | inflateInit(&stream); | |
545 | ||
546 | SHA1_Init(&c); | |
547 | ||
548 | do { | |
549 | ssize_t size; | |
550 | size = read(fd, buf, 4096); | |
551 | if (size <= 0) { | |
552 | close(local); | |
553 | unlink(filename); | |
554 | if (!size) | |
555 | return error("Connection closed?"); | |
556 | perror("Reading from connection"); | |
557 | return -1; | |
558 | } | |
559 | write(local, buf, size); | |
560 | stream.avail_in = size; | |
561 | stream.next_in = buf; | |
562 | do { | |
563 | stream.next_out = discard; | |
564 | stream.avail_out = sizeof(discard); | |
565 | ret = inflate(&stream, Z_SYNC_FLUSH); | |
566 | SHA1_Update(&c, discard, sizeof(discard) - | |
567 | stream.avail_out); | |
568 | } while (stream.avail_in && ret == Z_OK); | |
569 | ||
570 | } while (ret == Z_OK); | |
571 | inflateEnd(&stream); | |
572 | ||
573 | close(local); | |
574 | SHA1_Final(real_sha1, &c); | |
575 | if (ret != Z_STREAM_END) { | |
576 | unlink(filename); | |
577 | return error("File %s corrupted", sha1_to_hex(sha1)); | |
578 | } | |
579 | if (memcmp(sha1, real_sha1, 20)) { | |
580 | unlink(filename); | |
581 | return error("File %s has bad hash\n", sha1_to_hex(sha1)); | |
582 | } | |
583 | ||
584 | return 0; | |
585 | } | |
586 | ||
587 | int has_sha1_file(const unsigned char *sha1) | |
588 | { | |
8237b185 | 589 | struct stat st; |
ace1534d | 590 | return !!find_sha1_file(sha1, &st); |
8237b185 | 591 | } |
74400e71 JH |
592 | |
593 | int index_fd(unsigned char *sha1, int fd, struct stat *st) | |
594 | { | |
74400e71 | 595 | unsigned long size = st->st_size; |
aac17941 LT |
596 | void *buf; |
597 | int ret; | |
74400e71 | 598 | |
aac17941 | 599 | buf = ""; |
74400e71 | 600 | if (size) |
aac17941 | 601 | buf = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0); |
74400e71 | 602 | close(fd); |
aac17941 | 603 | if ((int)(long)buf == -1) |
74400e71 JH |
604 | return -1; |
605 | ||
aac17941 LT |
606 | ret = write_sha1_file(buf, size, "blob", sha1); |
607 | if (size) | |
608 | munmap(buf, size); | |
609 | return ret; | |
74400e71 | 610 | } |