read_info_alternates: warn on non-trivial errors
[git/git.git] / sha1_file.c
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 */
9 #include "cache.h"
10 #include "config.h"
11 #include "string-list.h"
12 #include "lockfile.h"
13 #include "delta.h"
14 #include "pack.h"
15 #include "blob.h"
16 #include "commit.h"
17 #include "run-command.h"
18 #include "tag.h"
19 #include "tree.h"
20 #include "tree-walk.h"
21 #include "refs.h"
22 #include "pack-revindex.h"
23 #include "sha1-lookup.h"
24 #include "bulk-checkin.h"
25 #include "streaming.h"
26 #include "dir.h"
27 #include "mru.h"
28 #include "list.h"
29 #include "mergesort.h"
30 #include "quote.h"
31
32 #define SZ_FMT PRIuMAX
33 static inline uintmax_t sz_fmt(size_t s) { return s; }
34
35 const unsigned char null_sha1[20];
36 const struct object_id null_oid;
37 const struct object_id empty_tree_oid = {
38 EMPTY_TREE_SHA1_BIN_LITERAL
39 };
40 const struct object_id empty_blob_oid = {
41 EMPTY_BLOB_SHA1_BIN_LITERAL
42 };
43
44 /*
45 * This is meant to hold a *small* number of objects that you would
46 * want read_sha1_file() to be able to return, but yet you do not want
47 * to write them into the object store (e.g. a browse-only
48 * application).
49 */
50 static struct cached_object {
51 unsigned char sha1[20];
52 enum object_type type;
53 void *buf;
54 unsigned long size;
55 } *cached_objects;
56 static int cached_object_nr, cached_object_alloc;
57
58 static struct cached_object empty_tree = {
59 EMPTY_TREE_SHA1_BIN_LITERAL,
60 OBJ_TREE,
61 "",
62 0
63 };
64
65 static struct cached_object *find_cached_object(const unsigned char *sha1)
66 {
67 int i;
68 struct cached_object *co = cached_objects;
69
70 for (i = 0; i < cached_object_nr; i++, co++) {
71 if (!hashcmp(co->sha1, sha1))
72 return co;
73 }
74 if (!hashcmp(sha1, empty_tree.sha1))
75 return &empty_tree;
76 return NULL;
77 }
78
79 int mkdir_in_gitdir(const char *path)
80 {
81 if (mkdir(path, 0777)) {
82 int saved_errno = errno;
83 struct stat st;
84 struct strbuf sb = STRBUF_INIT;
85
86 if (errno != EEXIST)
87 return -1;
88 /*
89 * Are we looking at a path in a symlinked worktree
90 * whose original repository does not yet have it?
91 * e.g. .git/rr-cache pointing at its original
92 * repository in which the user hasn't performed any
93 * conflict resolution yet?
94 */
95 if (lstat(path, &st) || !S_ISLNK(st.st_mode) ||
96 strbuf_readlink(&sb, path, st.st_size) ||
97 !is_absolute_path(sb.buf) ||
98 mkdir(sb.buf, 0777)) {
99 strbuf_release(&sb);
100 errno = saved_errno;
101 return -1;
102 }
103 strbuf_release(&sb);
104 }
105 return adjust_shared_perm(path);
106 }
107
108 enum scld_error safe_create_leading_directories(char *path)
109 {
110 char *next_component = path + offset_1st_component(path);
111 enum scld_error ret = SCLD_OK;
112
113 while (ret == SCLD_OK && next_component) {
114 struct stat st;
115 char *slash = next_component, slash_character;
116
117 while (*slash && !is_dir_sep(*slash))
118 slash++;
119
120 if (!*slash)
121 break;
122
123 next_component = slash + 1;
124 while (is_dir_sep(*next_component))
125 next_component++;
126 if (!*next_component)
127 break;
128
129 slash_character = *slash;
130 *slash = '\0';
131 if (!stat(path, &st)) {
132 /* path exists */
133 if (!S_ISDIR(st.st_mode)) {
134 errno = ENOTDIR;
135 ret = SCLD_EXISTS;
136 }
137 } else if (mkdir(path, 0777)) {
138 if (errno == EEXIST &&
139 !stat(path, &st) && S_ISDIR(st.st_mode))
140 ; /* somebody created it since we checked */
141 else if (errno == ENOENT)
142 /*
143 * Either mkdir() failed because
144 * somebody just pruned the containing
145 * directory, or stat() failed because
146 * the file that was in our way was
147 * just removed. Either way, inform
148 * the caller that it might be worth
149 * trying again:
150 */
151 ret = SCLD_VANISHED;
152 else
153 ret = SCLD_FAILED;
154 } else if (adjust_shared_perm(path)) {
155 ret = SCLD_PERMS;
156 }
157 *slash = slash_character;
158 }
159 return ret;
160 }
161
162 enum scld_error safe_create_leading_directories_const(const char *path)
163 {
164 int save_errno;
165 /* path points to cache entries, so xstrdup before messing with it */
166 char *buf = xstrdup(path);
167 enum scld_error result = safe_create_leading_directories(buf);
168
169 save_errno = errno;
170 free(buf);
171 errno = save_errno;
172 return result;
173 }
174
175 int raceproof_create_file(const char *path, create_file_fn fn, void *cb)
176 {
177 /*
178 * The number of times we will try to remove empty directories
179 * in the way of path. This is only 1 because if another
180 * process is racily creating directories that conflict with
181 * us, we don't want to fight against them.
182 */
183 int remove_directories_remaining = 1;
184
185 /*
186 * The number of times that we will try to create the
187 * directories containing path. We are willing to attempt this
188 * more than once, because another process could be trying to
189 * clean up empty directories at the same time as we are
190 * trying to create them.
191 */
192 int create_directories_remaining = 3;
193
194 /* A scratch copy of path, filled lazily if we need it: */
195 struct strbuf path_copy = STRBUF_INIT;
196
197 int ret, save_errno;
198
199 /* Sanity check: */
200 assert(*path);
201
202 retry_fn:
203 ret = fn(path, cb);
204 save_errno = errno;
205 if (!ret)
206 goto out;
207
208 if (errno == EISDIR && remove_directories_remaining-- > 0) {
209 /*
210 * A directory is in the way. Maybe it is empty; try
211 * to remove it:
212 */
213 if (!path_copy.len)
214 strbuf_addstr(&path_copy, path);
215
216 if (!remove_dir_recursively(&path_copy, REMOVE_DIR_EMPTY_ONLY))
217 goto retry_fn;
218 } else if (errno == ENOENT && create_directories_remaining-- > 0) {
219 /*
220 * Maybe the containing directory didn't exist, or
221 * maybe it was just deleted by a process that is
222 * racing with us to clean up empty directories. Try
223 * to create it:
224 */
225 enum scld_error scld_result;
226
227 if (!path_copy.len)
228 strbuf_addstr(&path_copy, path);
229
230 do {
231 scld_result = safe_create_leading_directories(path_copy.buf);
232 if (scld_result == SCLD_OK)
233 goto retry_fn;
234 } while (scld_result == SCLD_VANISHED && create_directories_remaining-- > 0);
235 }
236
237 out:
238 strbuf_release(&path_copy);
239 errno = save_errno;
240 return ret;
241 }
242
243 static void fill_sha1_path(struct strbuf *buf, const unsigned char *sha1)
244 {
245 int i;
246 for (i = 0; i < 20; i++) {
247 static char hex[] = "0123456789abcdef";
248 unsigned int val = sha1[i];
249 strbuf_addch(buf, hex[val >> 4]);
250 strbuf_addch(buf, hex[val & 0xf]);
251 if (!i)
252 strbuf_addch(buf, '/');
253 }
254 }
255
256 const char *sha1_file_name(const unsigned char *sha1)
257 {
258 static struct strbuf buf = STRBUF_INIT;
259
260 strbuf_reset(&buf);
261 strbuf_addf(&buf, "%s/", get_object_directory());
262
263 fill_sha1_path(&buf, sha1);
264 return buf.buf;
265 }
266
267 struct strbuf *alt_scratch_buf(struct alternate_object_database *alt)
268 {
269 strbuf_setlen(&alt->scratch, alt->base_len);
270 return &alt->scratch;
271 }
272
273 static const char *alt_sha1_path(struct alternate_object_database *alt,
274 const unsigned char *sha1)
275 {
276 struct strbuf *buf = alt_scratch_buf(alt);
277 fill_sha1_path(buf, sha1);
278 return buf->buf;
279 }
280
281 char *odb_pack_name(struct strbuf *buf,
282 const unsigned char *sha1,
283 const char *ext)
284 {
285 strbuf_reset(buf);
286 strbuf_addf(buf, "%s/pack/pack-%s.%s", get_object_directory(),
287 sha1_to_hex(sha1), ext);
288 return buf->buf;
289 }
290
291 char *sha1_pack_name(const unsigned char *sha1)
292 {
293 static struct strbuf buf = STRBUF_INIT;
294 return odb_pack_name(&buf, sha1, "pack");
295 }
296
297 char *sha1_pack_index_name(const unsigned char *sha1)
298 {
299 static struct strbuf buf = STRBUF_INIT;
300 return odb_pack_name(&buf, sha1, "idx");
301 }
302
303 struct alternate_object_database *alt_odb_list;
304 static struct alternate_object_database **alt_odb_tail;
305
306 /*
307 * Return non-zero iff the path is usable as an alternate object database.
308 */
309 static int alt_odb_usable(struct strbuf *path, const char *normalized_objdir)
310 {
311 struct alternate_object_database *alt;
312
313 /* Detect cases where alternate disappeared */
314 if (!is_directory(path->buf)) {
315 error("object directory %s does not exist; "
316 "check .git/objects/info/alternates.",
317 path->buf);
318 return 0;
319 }
320
321 /*
322 * Prevent the common mistake of listing the same
323 * thing twice, or object directory itself.
324 */
325 for (alt = alt_odb_list; alt; alt = alt->next) {
326 if (!fspathcmp(path->buf, alt->path))
327 return 0;
328 }
329 if (!fspathcmp(path->buf, normalized_objdir))
330 return 0;
331
332 return 1;
333 }
334
335 /*
336 * Prepare alternate object database registry.
337 *
338 * The variable alt_odb_list points at the list of struct
339 * alternate_object_database. The elements on this list come from
340 * non-empty elements from colon separated ALTERNATE_DB_ENVIRONMENT
341 * environment variable, and $GIT_OBJECT_DIRECTORY/info/alternates,
342 * whose contents is similar to that environment variable but can be
343 * LF separated. Its base points at a statically allocated buffer that
344 * contains "/the/directory/corresponding/to/.git/objects/...", while
345 * its name points just after the slash at the end of ".git/objects/"
346 * in the example above, and has enough space to hold 40-byte hex
347 * SHA1, an extra slash for the first level indirection, and the
348 * terminating NUL.
349 */
350 static void read_info_alternates(const char * relative_base, int depth);
351 static int link_alt_odb_entry(const char *entry, const char *relative_base,
352 int depth, const char *normalized_objdir)
353 {
354 struct alternate_object_database *ent;
355 struct strbuf pathbuf = STRBUF_INIT;
356
357 if (!is_absolute_path(entry) && relative_base) {
358 strbuf_realpath(&pathbuf, relative_base, 1);
359 strbuf_addch(&pathbuf, '/');
360 }
361 strbuf_addstr(&pathbuf, entry);
362
363 if (strbuf_normalize_path(&pathbuf) < 0 && relative_base) {
364 error("unable to normalize alternate object path: %s",
365 pathbuf.buf);
366 strbuf_release(&pathbuf);
367 return -1;
368 }
369
370 /*
371 * The trailing slash after the directory name is given by
372 * this function at the end. Remove duplicates.
373 */
374 while (pathbuf.len && pathbuf.buf[pathbuf.len - 1] == '/')
375 strbuf_setlen(&pathbuf, pathbuf.len - 1);
376
377 if (!alt_odb_usable(&pathbuf, normalized_objdir)) {
378 strbuf_release(&pathbuf);
379 return -1;
380 }
381
382 ent = alloc_alt_odb(pathbuf.buf);
383
384 /* add the alternate entry */
385 *alt_odb_tail = ent;
386 alt_odb_tail = &(ent->next);
387 ent->next = NULL;
388
389 /* recursively add alternates */
390 read_info_alternates(pathbuf.buf, depth + 1);
391
392 strbuf_release(&pathbuf);
393 return 0;
394 }
395
396 static const char *parse_alt_odb_entry(const char *string,
397 int sep,
398 struct strbuf *out)
399 {
400 const char *end;
401
402 strbuf_reset(out);
403
404 if (*string == '#') {
405 /* comment; consume up to next separator */
406 end = strchrnul(string, sep);
407 } else if (*string == '"' && !unquote_c_style(out, string, &end)) {
408 /*
409 * quoted path; unquote_c_style has copied the
410 * data for us and set "end". Broken quoting (e.g.,
411 * an entry that doesn't end with a quote) falls
412 * back to the unquoted case below.
413 */
414 } else {
415 /* normal, unquoted path */
416 end = strchrnul(string, sep);
417 strbuf_add(out, string, end - string);
418 }
419
420 if (*end)
421 end++;
422 return end;
423 }
424
425 static void link_alt_odb_entries(const char *alt, int sep,
426 const char *relative_base, int depth)
427 {
428 struct strbuf objdirbuf = STRBUF_INIT;
429 struct strbuf entry = STRBUF_INIT;
430
431 if (depth > 5) {
432 error("%s: ignoring alternate object stores, nesting too deep.",
433 relative_base);
434 return;
435 }
436
437 strbuf_add_absolute_path(&objdirbuf, get_object_directory());
438 if (strbuf_normalize_path(&objdirbuf) < 0)
439 die("unable to normalize object directory: %s",
440 objdirbuf.buf);
441
442 while (*alt) {
443 alt = parse_alt_odb_entry(alt, sep, &entry);
444 if (!entry.len)
445 continue;
446 link_alt_odb_entry(entry.buf, relative_base, depth, objdirbuf.buf);
447 }
448 strbuf_release(&entry);
449 strbuf_release(&objdirbuf);
450 }
451
452 static void read_info_alternates(const char * relative_base, int depth)
453 {
454 char *path;
455 struct strbuf buf = STRBUF_INIT;
456
457 path = xstrfmt("%s/info/alternates", relative_base);
458 if (strbuf_read_file(&buf, path, 1024) < 0) {
459 warn_on_fopen_errors(path);
460 free(path);
461 return;
462 }
463
464 link_alt_odb_entries(buf.buf, '\n', relative_base, depth);
465 strbuf_release(&buf);
466 free(path);
467 }
468
469 struct alternate_object_database *alloc_alt_odb(const char *dir)
470 {
471 struct alternate_object_database *ent;
472
473 FLEX_ALLOC_STR(ent, path, dir);
474 strbuf_init(&ent->scratch, 0);
475 strbuf_addf(&ent->scratch, "%s/", dir);
476 ent->base_len = ent->scratch.len;
477
478 return ent;
479 }
480
481 void add_to_alternates_file(const char *reference)
482 {
483 struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
484 char *alts = git_pathdup("objects/info/alternates");
485 FILE *in, *out;
486
487 hold_lock_file_for_update(lock, alts, LOCK_DIE_ON_ERROR);
488 out = fdopen_lock_file(lock, "w");
489 if (!out)
490 die_errno("unable to fdopen alternates lockfile");
491
492 in = fopen(alts, "r");
493 if (in) {
494 struct strbuf line = STRBUF_INIT;
495 int found = 0;
496
497 while (strbuf_getline(&line, in) != EOF) {
498 if (!strcmp(reference, line.buf)) {
499 found = 1;
500 break;
501 }
502 fprintf_or_die(out, "%s\n", line.buf);
503 }
504
505 strbuf_release(&line);
506 fclose(in);
507
508 if (found) {
509 rollback_lock_file(lock);
510 lock = NULL;
511 }
512 }
513 else if (errno != ENOENT)
514 die_errno("unable to read alternates file");
515
516 if (lock) {
517 fprintf_or_die(out, "%s\n", reference);
518 if (commit_lock_file(lock))
519 die_errno("unable to move new alternates file into place");
520 if (alt_odb_tail)
521 link_alt_odb_entries(reference, '\n', NULL, 0);
522 }
523 free(alts);
524 }
525
526 void add_to_alternates_memory(const char *reference)
527 {
528 /*
529 * Make sure alternates are initialized, or else our entry may be
530 * overwritten when they are.
531 */
532 prepare_alt_odb();
533
534 link_alt_odb_entries(reference, '\n', NULL, 0);
535 }
536
537 /*
538 * Compute the exact path an alternate is at and returns it. In case of
539 * error NULL is returned and the human readable error is added to `err`
540 * `path` may be relative and should point to $GITDIR.
541 * `err` must not be null.
542 */
543 char *compute_alternate_path(const char *path, struct strbuf *err)
544 {
545 char *ref_git = NULL;
546 const char *repo, *ref_git_s;
547 int seen_error = 0;
548
549 ref_git_s = real_path_if_valid(path);
550 if (!ref_git_s) {
551 seen_error = 1;
552 strbuf_addf(err, _("path '%s' does not exist"), path);
553 goto out;
554 } else
555 /*
556 * Beware: read_gitfile(), real_path() and mkpath()
557 * return static buffer
558 */
559 ref_git = xstrdup(ref_git_s);
560
561 repo = read_gitfile(ref_git);
562 if (!repo)
563 repo = read_gitfile(mkpath("%s/.git", ref_git));
564 if (repo) {
565 free(ref_git);
566 ref_git = xstrdup(repo);
567 }
568
569 if (!repo && is_directory(mkpath("%s/.git/objects", ref_git))) {
570 char *ref_git_git = mkpathdup("%s/.git", ref_git);
571 free(ref_git);
572 ref_git = ref_git_git;
573 } else if (!is_directory(mkpath("%s/objects", ref_git))) {
574 struct strbuf sb = STRBUF_INIT;
575 seen_error = 1;
576 if (get_common_dir(&sb, ref_git)) {
577 strbuf_addf(err,
578 _("reference repository '%s' as a linked "
579 "checkout is not supported yet."),
580 path);
581 goto out;
582 }
583
584 strbuf_addf(err, _("reference repository '%s' is not a "
585 "local repository."), path);
586 goto out;
587 }
588
589 if (!access(mkpath("%s/shallow", ref_git), F_OK)) {
590 strbuf_addf(err, _("reference repository '%s' is shallow"),
591 path);
592 seen_error = 1;
593 goto out;
594 }
595
596 if (!access(mkpath("%s/info/grafts", ref_git), F_OK)) {
597 strbuf_addf(err,
598 _("reference repository '%s' is grafted"),
599 path);
600 seen_error = 1;
601 goto out;
602 }
603
604 out:
605 if (seen_error) {
606 FREE_AND_NULL(ref_git);
607 }
608
609 return ref_git;
610 }
611
612 int foreach_alt_odb(alt_odb_fn fn, void *cb)
613 {
614 struct alternate_object_database *ent;
615 int r = 0;
616
617 prepare_alt_odb();
618 for (ent = alt_odb_list; ent; ent = ent->next) {
619 r = fn(ent, cb);
620 if (r)
621 break;
622 }
623 return r;
624 }
625
626 void prepare_alt_odb(void)
627 {
628 const char *alt;
629
630 if (alt_odb_tail)
631 return;
632
633 alt = getenv(ALTERNATE_DB_ENVIRONMENT);
634 if (!alt) alt = "";
635
636 alt_odb_tail = &alt_odb_list;
637 link_alt_odb_entries(alt, PATH_SEP, NULL, 0);
638
639 read_info_alternates(get_object_directory(), 0);
640 }
641
642 /* Returns 1 if we have successfully freshened the file, 0 otherwise. */
643 static int freshen_file(const char *fn)
644 {
645 struct utimbuf t;
646 t.actime = t.modtime = time(NULL);
647 return !utime(fn, &t);
648 }
649
650 /*
651 * All of the check_and_freshen functions return 1 if the file exists and was
652 * freshened (if freshening was requested), 0 otherwise. If they return
653 * 0, you should not assume that it is safe to skip a write of the object (it
654 * either does not exist on disk, or has a stale mtime and may be subject to
655 * pruning).
656 */
657 int check_and_freshen_file(const char *fn, int freshen)
658 {
659 if (access(fn, F_OK))
660 return 0;
661 if (freshen && !freshen_file(fn))
662 return 0;
663 return 1;
664 }
665
666 static int check_and_freshen_local(const unsigned char *sha1, int freshen)
667 {
668 return check_and_freshen_file(sha1_file_name(sha1), freshen);
669 }
670
671 static int check_and_freshen_nonlocal(const unsigned char *sha1, int freshen)
672 {
673 struct alternate_object_database *alt;
674 prepare_alt_odb();
675 for (alt = alt_odb_list; alt; alt = alt->next) {
676 const char *path = alt_sha1_path(alt, sha1);
677 if (check_and_freshen_file(path, freshen))
678 return 1;
679 }
680 return 0;
681 }
682
683 static int check_and_freshen(const unsigned char *sha1, int freshen)
684 {
685 return check_and_freshen_local(sha1, freshen) ||
686 check_and_freshen_nonlocal(sha1, freshen);
687 }
688
689 int has_loose_object_nonlocal(const unsigned char *sha1)
690 {
691 return check_and_freshen_nonlocal(sha1, 0);
692 }
693
694 static int has_loose_object(const unsigned char *sha1)
695 {
696 return check_and_freshen(sha1, 0);
697 }
698
699 static unsigned int pack_used_ctr;
700 static unsigned int pack_mmap_calls;
701 static unsigned int peak_pack_open_windows;
702 static unsigned int pack_open_windows;
703 static unsigned int pack_open_fds;
704 static unsigned int pack_max_fds;
705 static size_t peak_pack_mapped;
706 static size_t pack_mapped;
707 struct packed_git *packed_git;
708
709 static struct mru packed_git_mru_storage;
710 struct mru *packed_git_mru = &packed_git_mru_storage;
711
712 void pack_report(void)
713 {
714 fprintf(stderr,
715 "pack_report: getpagesize() = %10" SZ_FMT "\n"
716 "pack_report: core.packedGitWindowSize = %10" SZ_FMT "\n"
717 "pack_report: core.packedGitLimit = %10" SZ_FMT "\n",
718 sz_fmt(getpagesize()),
719 sz_fmt(packed_git_window_size),
720 sz_fmt(packed_git_limit));
721 fprintf(stderr,
722 "pack_report: pack_used_ctr = %10u\n"
723 "pack_report: pack_mmap_calls = %10u\n"
724 "pack_report: pack_open_windows = %10u / %10u\n"
725 "pack_report: pack_mapped = "
726 "%10" SZ_FMT " / %10" SZ_FMT "\n",
727 pack_used_ctr,
728 pack_mmap_calls,
729 pack_open_windows, peak_pack_open_windows,
730 sz_fmt(pack_mapped), sz_fmt(peak_pack_mapped));
731 }
732
733 /*
734 * Open and mmap the index file at path, perform a couple of
735 * consistency checks, then record its information to p. Return 0 on
736 * success.
737 */
738 static int check_packed_git_idx(const char *path, struct packed_git *p)
739 {
740 void *idx_map;
741 struct pack_idx_header *hdr;
742 size_t idx_size;
743 uint32_t version, nr, i, *index;
744 int fd = git_open(path);
745 struct stat st;
746
747 if (fd < 0)
748 return -1;
749 if (fstat(fd, &st)) {
750 close(fd);
751 return -1;
752 }
753 idx_size = xsize_t(st.st_size);
754 if (idx_size < 4 * 256 + 20 + 20) {
755 close(fd);
756 return error("index file %s is too small", path);
757 }
758 idx_map = xmmap(NULL, idx_size, PROT_READ, MAP_PRIVATE, fd, 0);
759 close(fd);
760
761 hdr = idx_map;
762 if (hdr->idx_signature == htonl(PACK_IDX_SIGNATURE)) {
763 version = ntohl(hdr->idx_version);
764 if (version < 2 || version > 2) {
765 munmap(idx_map, idx_size);
766 return error("index file %s is version %"PRIu32
767 " and is not supported by this binary"
768 " (try upgrading GIT to a newer version)",
769 path, version);
770 }
771 } else
772 version = 1;
773
774 nr = 0;
775 index = idx_map;
776 if (version > 1)
777 index += 2; /* skip index header */
778 for (i = 0; i < 256; i++) {
779 uint32_t n = ntohl(index[i]);
780 if (n < nr) {
781 munmap(idx_map, idx_size);
782 return error("non-monotonic index %s", path);
783 }
784 nr = n;
785 }
786
787 if (version == 1) {
788 /*
789 * Total size:
790 * - 256 index entries 4 bytes each
791 * - 24-byte entries * nr (20-byte sha1 + 4-byte offset)
792 * - 20-byte SHA1 of the packfile
793 * - 20-byte SHA1 file checksum
794 */
795 if (idx_size != 4*256 + nr * 24 + 20 + 20) {
796 munmap(idx_map, idx_size);
797 return error("wrong index v1 file size in %s", path);
798 }
799 } else if (version == 2) {
800 /*
801 * Minimum size:
802 * - 8 bytes of header
803 * - 256 index entries 4 bytes each
804 * - 20-byte sha1 entry * nr
805 * - 4-byte crc entry * nr
806 * - 4-byte offset entry * nr
807 * - 20-byte SHA1 of the packfile
808 * - 20-byte SHA1 file checksum
809 * And after the 4-byte offset table might be a
810 * variable sized table containing 8-byte entries
811 * for offsets larger than 2^31.
812 */
813 unsigned long min_size = 8 + 4*256 + nr*(20 + 4 + 4) + 20 + 20;
814 unsigned long max_size = min_size;
815 if (nr)
816 max_size += (nr - 1)*8;
817 if (idx_size < min_size || idx_size > max_size) {
818 munmap(idx_map, idx_size);
819 return error("wrong index v2 file size in %s", path);
820 }
821 if (idx_size != min_size &&
822 /*
823 * make sure we can deal with large pack offsets.
824 * 31-bit signed offset won't be enough, neither
825 * 32-bit unsigned one will be.
826 */
827 (sizeof(off_t) <= 4)) {
828 munmap(idx_map, idx_size);
829 return error("pack too large for current definition of off_t in %s", path);
830 }
831 }
832
833 p->index_version = version;
834 p->index_data = idx_map;
835 p->index_size = idx_size;
836 p->num_objects = nr;
837 return 0;
838 }
839
840 int open_pack_index(struct packed_git *p)
841 {
842 char *idx_name;
843 size_t len;
844 int ret;
845
846 if (p->index_data)
847 return 0;
848
849 if (!strip_suffix(p->pack_name, ".pack", &len))
850 die("BUG: pack_name does not end in .pack");
851 idx_name = xstrfmt("%.*s.idx", (int)len, p->pack_name);
852 ret = check_packed_git_idx(idx_name, p);
853 free(idx_name);
854 return ret;
855 }
856
857 static void scan_windows(struct packed_git *p,
858 struct packed_git **lru_p,
859 struct pack_window **lru_w,
860 struct pack_window **lru_l)
861 {
862 struct pack_window *w, *w_l;
863
864 for (w_l = NULL, w = p->windows; w; w = w->next) {
865 if (!w->inuse_cnt) {
866 if (!*lru_w || w->last_used < (*lru_w)->last_used) {
867 *lru_p = p;
868 *lru_w = w;
869 *lru_l = w_l;
870 }
871 }
872 w_l = w;
873 }
874 }
875
876 static int unuse_one_window(struct packed_git *current)
877 {
878 struct packed_git *p, *lru_p = NULL;
879 struct pack_window *lru_w = NULL, *lru_l = NULL;
880
881 if (current)
882 scan_windows(current, &lru_p, &lru_w, &lru_l);
883 for (p = packed_git; p; p = p->next)
884 scan_windows(p, &lru_p, &lru_w, &lru_l);
885 if (lru_p) {
886 munmap(lru_w->base, lru_w->len);
887 pack_mapped -= lru_w->len;
888 if (lru_l)
889 lru_l->next = lru_w->next;
890 else
891 lru_p->windows = lru_w->next;
892 free(lru_w);
893 pack_open_windows--;
894 return 1;
895 }
896 return 0;
897 }
898
899 void release_pack_memory(size_t need)
900 {
901 size_t cur = pack_mapped;
902 while (need >= (cur - pack_mapped) && unuse_one_window(NULL))
903 ; /* nothing */
904 }
905
906 static void mmap_limit_check(size_t length)
907 {
908 static size_t limit = 0;
909 if (!limit) {
910 limit = git_env_ulong("GIT_MMAP_LIMIT", 0);
911 if (!limit)
912 limit = SIZE_MAX;
913 }
914 if (length > limit)
915 die("attempting to mmap %"PRIuMAX" over limit %"PRIuMAX,
916 (uintmax_t)length, (uintmax_t)limit);
917 }
918
919 void *xmmap_gently(void *start, size_t length,
920 int prot, int flags, int fd, off_t offset)
921 {
922 void *ret;
923
924 mmap_limit_check(length);
925 ret = mmap(start, length, prot, flags, fd, offset);
926 if (ret == MAP_FAILED) {
927 if (!length)
928 return NULL;
929 release_pack_memory(length);
930 ret = mmap(start, length, prot, flags, fd, offset);
931 }
932 return ret;
933 }
934
935 void *xmmap(void *start, size_t length,
936 int prot, int flags, int fd, off_t offset)
937 {
938 void *ret = xmmap_gently(start, length, prot, flags, fd, offset);
939 if (ret == MAP_FAILED)
940 die_errno("mmap failed");
941 return ret;
942 }
943
944 void close_pack_windows(struct packed_git *p)
945 {
946 while (p->windows) {
947 struct pack_window *w = p->windows;
948
949 if (w->inuse_cnt)
950 die("pack '%s' still has open windows to it",
951 p->pack_name);
952 munmap(w->base, w->len);
953 pack_mapped -= w->len;
954 pack_open_windows--;
955 p->windows = w->next;
956 free(w);
957 }
958 }
959
960 static int close_pack_fd(struct packed_git *p)
961 {
962 if (p->pack_fd < 0)
963 return 0;
964
965 close(p->pack_fd);
966 pack_open_fds--;
967 p->pack_fd = -1;
968
969 return 1;
970 }
971
972 static void close_pack(struct packed_git *p)
973 {
974 close_pack_windows(p);
975 close_pack_fd(p);
976 close_pack_index(p);
977 }
978
979 void close_all_packs(void)
980 {
981 struct packed_git *p;
982
983 for (p = packed_git; p; p = p->next)
984 if (p->do_not_close)
985 die("BUG: want to close pack marked 'do-not-close'");
986 else
987 close_pack(p);
988 }
989
990
991 /*
992 * The LRU pack is the one with the oldest MRU window, preferring packs
993 * with no used windows, or the oldest mtime if it has no windows allocated.
994 */
995 static void find_lru_pack(struct packed_git *p, struct packed_git **lru_p, struct pack_window **mru_w, int *accept_windows_inuse)
996 {
997 struct pack_window *w, *this_mru_w;
998 int has_windows_inuse = 0;
999
1000 /*
1001 * Reject this pack if it has windows and the previously selected
1002 * one does not. If this pack does not have windows, reject
1003 * it if the pack file is newer than the previously selected one.
1004 */
1005 if (*lru_p && !*mru_w && (p->windows || p->mtime > (*lru_p)->mtime))
1006 return;
1007
1008 for (w = this_mru_w = p->windows; w; w = w->next) {
1009 /*
1010 * Reject this pack if any of its windows are in use,
1011 * but the previously selected pack did not have any
1012 * inuse windows. Otherwise, record that this pack
1013 * has windows in use.
1014 */
1015 if (w->inuse_cnt) {
1016 if (*accept_windows_inuse)
1017 has_windows_inuse = 1;
1018 else
1019 return;
1020 }
1021
1022 if (w->last_used > this_mru_w->last_used)
1023 this_mru_w = w;
1024
1025 /*
1026 * Reject this pack if it has windows that have been
1027 * used more recently than the previously selected pack.
1028 * If the previously selected pack had windows inuse and
1029 * we have not encountered a window in this pack that is
1030 * inuse, skip this check since we prefer a pack with no
1031 * inuse windows to one that has inuse windows.
1032 */
1033 if (*mru_w && *accept_windows_inuse == has_windows_inuse &&
1034 this_mru_w->last_used > (*mru_w)->last_used)
1035 return;
1036 }
1037
1038 /*
1039 * Select this pack.
1040 */
1041 *mru_w = this_mru_w;
1042 *lru_p = p;
1043 *accept_windows_inuse = has_windows_inuse;
1044 }
1045
1046 static int close_one_pack(void)
1047 {
1048 struct packed_git *p, *lru_p = NULL;
1049 struct pack_window *mru_w = NULL;
1050 int accept_windows_inuse = 1;
1051
1052 for (p = packed_git; p; p = p->next) {
1053 if (p->pack_fd == -1)
1054 continue;
1055 find_lru_pack(p, &lru_p, &mru_w, &accept_windows_inuse);
1056 }
1057
1058 if (lru_p)
1059 return close_pack_fd(lru_p);
1060
1061 return 0;
1062 }
1063
1064 void unuse_pack(struct pack_window **w_cursor)
1065 {
1066 struct pack_window *w = *w_cursor;
1067 if (w) {
1068 w->inuse_cnt--;
1069 *w_cursor = NULL;
1070 }
1071 }
1072
1073 void close_pack_index(struct packed_git *p)
1074 {
1075 if (p->index_data) {
1076 munmap((void *)p->index_data, p->index_size);
1077 p->index_data = NULL;
1078 }
1079 }
1080
1081 static unsigned int get_max_fd_limit(void)
1082 {
1083 #ifdef RLIMIT_NOFILE
1084 {
1085 struct rlimit lim;
1086
1087 if (!getrlimit(RLIMIT_NOFILE, &lim))
1088 return lim.rlim_cur;
1089 }
1090 #endif
1091
1092 #ifdef _SC_OPEN_MAX
1093 {
1094 long open_max = sysconf(_SC_OPEN_MAX);
1095 if (0 < open_max)
1096 return open_max;
1097 /*
1098 * Otherwise, we got -1 for one of the two
1099 * reasons:
1100 *
1101 * (1) sysconf() did not understand _SC_OPEN_MAX
1102 * and signaled an error with -1; or
1103 * (2) sysconf() said there is no limit.
1104 *
1105 * We _could_ clear errno before calling sysconf() to
1106 * tell these two cases apart and return a huge number
1107 * in the latter case to let the caller cap it to a
1108 * value that is not so selfish, but letting the
1109 * fallback OPEN_MAX codepath take care of these cases
1110 * is a lot simpler.
1111 */
1112 }
1113 #endif
1114
1115 #ifdef OPEN_MAX
1116 return OPEN_MAX;
1117 #else
1118 return 1; /* see the caller ;-) */
1119 #endif
1120 }
1121
1122 /*
1123 * Do not call this directly as this leaks p->pack_fd on error return;
1124 * call open_packed_git() instead.
1125 */
1126 static int open_packed_git_1(struct packed_git *p)
1127 {
1128 struct stat st;
1129 struct pack_header hdr;
1130 unsigned char sha1[20];
1131 unsigned char *idx_sha1;
1132 long fd_flag;
1133
1134 if (!p->index_data && open_pack_index(p))
1135 return error("packfile %s index unavailable", p->pack_name);
1136
1137 if (!pack_max_fds) {
1138 unsigned int max_fds = get_max_fd_limit();
1139
1140 /* Save 3 for stdin/stdout/stderr, 22 for work */
1141 if (25 < max_fds)
1142 pack_max_fds = max_fds - 25;
1143 else
1144 pack_max_fds = 1;
1145 }
1146
1147 while (pack_max_fds <= pack_open_fds && close_one_pack())
1148 ; /* nothing */
1149
1150 p->pack_fd = git_open(p->pack_name);
1151 if (p->pack_fd < 0 || fstat(p->pack_fd, &st))
1152 return -1;
1153 pack_open_fds++;
1154
1155 /* If we created the struct before we had the pack we lack size. */
1156 if (!p->pack_size) {
1157 if (!S_ISREG(st.st_mode))
1158 return error("packfile %s not a regular file", p->pack_name);
1159 p->pack_size = st.st_size;
1160 } else if (p->pack_size != st.st_size)
1161 return error("packfile %s size changed", p->pack_name);
1162
1163 /* We leave these file descriptors open with sliding mmap;
1164 * there is no point keeping them open across exec(), though.
1165 */
1166 fd_flag = fcntl(p->pack_fd, F_GETFD, 0);
1167 if (fd_flag < 0)
1168 return error("cannot determine file descriptor flags");
1169 fd_flag |= FD_CLOEXEC;
1170 if (fcntl(p->pack_fd, F_SETFD, fd_flag) == -1)
1171 return error("cannot set FD_CLOEXEC");
1172
1173 /* Verify we recognize this pack file format. */
1174 if (read_in_full(p->pack_fd, &hdr, sizeof(hdr)) != sizeof(hdr))
1175 return error("file %s is far too short to be a packfile", p->pack_name);
1176 if (hdr.hdr_signature != htonl(PACK_SIGNATURE))
1177 return error("file %s is not a GIT packfile", p->pack_name);
1178 if (!pack_version_ok(hdr.hdr_version))
1179 return error("packfile %s is version %"PRIu32" and not"
1180 " supported (try upgrading GIT to a newer version)",
1181 p->pack_name, ntohl(hdr.hdr_version));
1182
1183 /* Verify the pack matches its index. */
1184 if (p->num_objects != ntohl(hdr.hdr_entries))
1185 return error("packfile %s claims to have %"PRIu32" objects"
1186 " while index indicates %"PRIu32" objects",
1187 p->pack_name, ntohl(hdr.hdr_entries),
1188 p->num_objects);
1189 if (lseek(p->pack_fd, p->pack_size - sizeof(sha1), SEEK_SET) == -1)
1190 return error("end of packfile %s is unavailable", p->pack_name);
1191 if (read_in_full(p->pack_fd, sha1, sizeof(sha1)) != sizeof(sha1))
1192 return error("packfile %s signature is unavailable", p->pack_name);
1193 idx_sha1 = ((unsigned char *)p->index_data) + p->index_size - 40;
1194 if (hashcmp(sha1, idx_sha1))
1195 return error("packfile %s does not match index", p->pack_name);
1196 return 0;
1197 }
1198
1199 static int open_packed_git(struct packed_git *p)
1200 {
1201 if (!open_packed_git_1(p))
1202 return 0;
1203 close_pack_fd(p);
1204 return -1;
1205 }
1206
1207 static int in_window(struct pack_window *win, off_t offset)
1208 {
1209 /* We must promise at least 20 bytes (one hash) after the
1210 * offset is available from this window, otherwise the offset
1211 * is not actually in this window and a different window (which
1212 * has that one hash excess) must be used. This is to support
1213 * the object header and delta base parsing routines below.
1214 */
1215 off_t win_off = win->offset;
1216 return win_off <= offset
1217 && (offset + 20) <= (win_off + win->len);
1218 }
1219
1220 unsigned char *use_pack(struct packed_git *p,
1221 struct pack_window **w_cursor,
1222 off_t offset,
1223 unsigned long *left)
1224 {
1225 struct pack_window *win = *w_cursor;
1226
1227 /* Since packfiles end in a hash of their content and it's
1228 * pointless to ask for an offset into the middle of that
1229 * hash, and the in_window function above wouldn't match
1230 * don't allow an offset too close to the end of the file.
1231 */
1232 if (!p->pack_size && p->pack_fd == -1 && open_packed_git(p))
1233 die("packfile %s cannot be accessed", p->pack_name);
1234 if (offset > (p->pack_size - 20))
1235 die("offset beyond end of packfile (truncated pack?)");
1236 if (offset < 0)
1237 die(_("offset before end of packfile (broken .idx?)"));
1238
1239 if (!win || !in_window(win, offset)) {
1240 if (win)
1241 win->inuse_cnt--;
1242 for (win = p->windows; win; win = win->next) {
1243 if (in_window(win, offset))
1244 break;
1245 }
1246 if (!win) {
1247 size_t window_align = packed_git_window_size / 2;
1248 off_t len;
1249
1250 if (p->pack_fd == -1 && open_packed_git(p))
1251 die("packfile %s cannot be accessed", p->pack_name);
1252
1253 win = xcalloc(1, sizeof(*win));
1254 win->offset = (offset / window_align) * window_align;
1255 len = p->pack_size - win->offset;
1256 if (len > packed_git_window_size)
1257 len = packed_git_window_size;
1258 win->len = (size_t)len;
1259 pack_mapped += win->len;
1260 while (packed_git_limit < pack_mapped
1261 && unuse_one_window(p))
1262 ; /* nothing */
1263 win->base = xmmap(NULL, win->len,
1264 PROT_READ, MAP_PRIVATE,
1265 p->pack_fd, win->offset);
1266 if (win->base == MAP_FAILED)
1267 die_errno("packfile %s cannot be mapped",
1268 p->pack_name);
1269 if (!win->offset && win->len == p->pack_size
1270 && !p->do_not_close)
1271 close_pack_fd(p);
1272 pack_mmap_calls++;
1273 pack_open_windows++;
1274 if (pack_mapped > peak_pack_mapped)
1275 peak_pack_mapped = pack_mapped;
1276 if (pack_open_windows > peak_pack_open_windows)
1277 peak_pack_open_windows = pack_open_windows;
1278 win->next = p->windows;
1279 p->windows = win;
1280 }
1281 }
1282 if (win != *w_cursor) {
1283 win->last_used = pack_used_ctr++;
1284 win->inuse_cnt++;
1285 *w_cursor = win;
1286 }
1287 offset -= win->offset;
1288 if (left)
1289 *left = win->len - xsize_t(offset);
1290 return win->base + offset;
1291 }
1292
1293 static struct packed_git *alloc_packed_git(int extra)
1294 {
1295 struct packed_git *p = xmalloc(st_add(sizeof(*p), extra));
1296 memset(p, 0, sizeof(*p));
1297 p->pack_fd = -1;
1298 return p;
1299 }
1300
1301 static void try_to_free_pack_memory(size_t size)
1302 {
1303 release_pack_memory(size);
1304 }
1305
1306 struct packed_git *add_packed_git(const char *path, size_t path_len, int local)
1307 {
1308 static int have_set_try_to_free_routine;
1309 struct stat st;
1310 size_t alloc;
1311 struct packed_git *p;
1312
1313 if (!have_set_try_to_free_routine) {
1314 have_set_try_to_free_routine = 1;
1315 set_try_to_free_routine(try_to_free_pack_memory);
1316 }
1317
1318 /*
1319 * Make sure a corresponding .pack file exists and that
1320 * the index looks sane.
1321 */
1322 if (!strip_suffix_mem(path, &path_len, ".idx"))
1323 return NULL;
1324
1325 /*
1326 * ".pack" is long enough to hold any suffix we're adding (and
1327 * the use xsnprintf double-checks that)
1328 */
1329 alloc = st_add3(path_len, strlen(".pack"), 1);
1330 p = alloc_packed_git(alloc);
1331 memcpy(p->pack_name, path, path_len);
1332
1333 xsnprintf(p->pack_name + path_len, alloc - path_len, ".keep");
1334 if (!access(p->pack_name, F_OK))
1335 p->pack_keep = 1;
1336
1337 xsnprintf(p->pack_name + path_len, alloc - path_len, ".pack");
1338 if (stat(p->pack_name, &st) || !S_ISREG(st.st_mode)) {
1339 free(p);
1340 return NULL;
1341 }
1342
1343 /* ok, it looks sane as far as we can check without
1344 * actually mapping the pack file.
1345 */
1346 p->pack_size = st.st_size;
1347 p->pack_local = local;
1348 p->mtime = st.st_mtime;
1349 if (path_len < 40 || get_sha1_hex(path + path_len - 40, p->sha1))
1350 hashclr(p->sha1);
1351 return p;
1352 }
1353
1354 struct packed_git *parse_pack_index(unsigned char *sha1, const char *idx_path)
1355 {
1356 const char *path = sha1_pack_name(sha1);
1357 size_t alloc = st_add(strlen(path), 1);
1358 struct packed_git *p = alloc_packed_git(alloc);
1359
1360 memcpy(p->pack_name, path, alloc); /* includes NUL */
1361 hashcpy(p->sha1, sha1);
1362 if (check_packed_git_idx(idx_path, p)) {
1363 free(p);
1364 return NULL;
1365 }
1366
1367 return p;
1368 }
1369
1370 void install_packed_git(struct packed_git *pack)
1371 {
1372 if (pack->pack_fd != -1)
1373 pack_open_fds++;
1374
1375 pack->next = packed_git;
1376 packed_git = pack;
1377 }
1378
1379 void (*report_garbage)(unsigned seen_bits, const char *path);
1380
1381 static void report_helper(const struct string_list *list,
1382 int seen_bits, int first, int last)
1383 {
1384 if (seen_bits == (PACKDIR_FILE_PACK|PACKDIR_FILE_IDX))
1385 return;
1386
1387 for (; first < last; first++)
1388 report_garbage(seen_bits, list->items[first].string);
1389 }
1390
1391 static void report_pack_garbage(struct string_list *list)
1392 {
1393 int i, baselen = -1, first = 0, seen_bits = 0;
1394
1395 if (!report_garbage)
1396 return;
1397
1398 string_list_sort(list);
1399
1400 for (i = 0; i < list->nr; i++) {
1401 const char *path = list->items[i].string;
1402 if (baselen != -1 &&
1403 strncmp(path, list->items[first].string, baselen)) {
1404 report_helper(list, seen_bits, first, i);
1405 baselen = -1;
1406 seen_bits = 0;
1407 }
1408 if (baselen == -1) {
1409 const char *dot = strrchr(path, '.');
1410 if (!dot) {
1411 report_garbage(PACKDIR_FILE_GARBAGE, path);
1412 continue;
1413 }
1414 baselen = dot - path + 1;
1415 first = i;
1416 }
1417 if (!strcmp(path + baselen, "pack"))
1418 seen_bits |= 1;
1419 else if (!strcmp(path + baselen, "idx"))
1420 seen_bits |= 2;
1421 }
1422 report_helper(list, seen_bits, first, list->nr);
1423 }
1424
1425 static void prepare_packed_git_one(char *objdir, int local)
1426 {
1427 struct strbuf path = STRBUF_INIT;
1428 size_t dirnamelen;
1429 DIR *dir;
1430 struct dirent *de;
1431 struct string_list garbage = STRING_LIST_INIT_DUP;
1432
1433 strbuf_addstr(&path, objdir);
1434 strbuf_addstr(&path, "/pack");
1435 dir = opendir(path.buf);
1436 if (!dir) {
1437 if (errno != ENOENT)
1438 error_errno("unable to open object pack directory: %s",
1439 path.buf);
1440 strbuf_release(&path);
1441 return;
1442 }
1443 strbuf_addch(&path, '/');
1444 dirnamelen = path.len;
1445 while ((de = readdir(dir)) != NULL) {
1446 struct packed_git *p;
1447 size_t base_len;
1448
1449 if (is_dot_or_dotdot(de->d_name))
1450 continue;
1451
1452 strbuf_setlen(&path, dirnamelen);
1453 strbuf_addstr(&path, de->d_name);
1454
1455 base_len = path.len;
1456 if (strip_suffix_mem(path.buf, &base_len, ".idx")) {
1457 /* Don't reopen a pack we already have. */
1458 for (p = packed_git; p; p = p->next) {
1459 size_t len;
1460 if (strip_suffix(p->pack_name, ".pack", &len) &&
1461 len == base_len &&
1462 !memcmp(p->pack_name, path.buf, len))
1463 break;
1464 }
1465 if (p == NULL &&
1466 /*
1467 * See if it really is a valid .idx file with
1468 * corresponding .pack file that we can map.
1469 */
1470 (p = add_packed_git(path.buf, path.len, local)) != NULL)
1471 install_packed_git(p);
1472 }
1473
1474 if (!report_garbage)
1475 continue;
1476
1477 if (ends_with(de->d_name, ".idx") ||
1478 ends_with(de->d_name, ".pack") ||
1479 ends_with(de->d_name, ".bitmap") ||
1480 ends_with(de->d_name, ".keep"))
1481 string_list_append(&garbage, path.buf);
1482 else
1483 report_garbage(PACKDIR_FILE_GARBAGE, path.buf);
1484 }
1485 closedir(dir);
1486 report_pack_garbage(&garbage);
1487 string_list_clear(&garbage, 0);
1488 strbuf_release(&path);
1489 }
1490
1491 static int approximate_object_count_valid;
1492
1493 /*
1494 * Give a fast, rough count of the number of objects in the repository. This
1495 * ignores loose objects completely. If you have a lot of them, then either
1496 * you should repack because your performance will be awful, or they are
1497 * all unreachable objects about to be pruned, in which case they're not really
1498 * interesting as a measure of repo size in the first place.
1499 */
1500 unsigned long approximate_object_count(void)
1501 {
1502 static unsigned long count;
1503 if (!approximate_object_count_valid) {
1504 struct packed_git *p;
1505
1506 prepare_packed_git();
1507 count = 0;
1508 for (p = packed_git; p; p = p->next) {
1509 if (open_pack_index(p))
1510 continue;
1511 count += p->num_objects;
1512 }
1513 }
1514 return count;
1515 }
1516
1517 static void *get_next_packed_git(const void *p)
1518 {
1519 return ((const struct packed_git *)p)->next;
1520 }
1521
1522 static void set_next_packed_git(void *p, void *next)
1523 {
1524 ((struct packed_git *)p)->next = next;
1525 }
1526
1527 static int sort_pack(const void *a_, const void *b_)
1528 {
1529 const struct packed_git *a = a_;
1530 const struct packed_git *b = b_;
1531 int st;
1532
1533 /*
1534 * Local packs tend to contain objects specific to our
1535 * variant of the project than remote ones. In addition,
1536 * remote ones could be on a network mounted filesystem.
1537 * Favor local ones for these reasons.
1538 */
1539 st = a->pack_local - b->pack_local;
1540 if (st)
1541 return -st;
1542
1543 /*
1544 * Younger packs tend to contain more recent objects,
1545 * and more recent objects tend to get accessed more
1546 * often.
1547 */
1548 if (a->mtime < b->mtime)
1549 return 1;
1550 else if (a->mtime == b->mtime)
1551 return 0;
1552 return -1;
1553 }
1554
1555 static void rearrange_packed_git(void)
1556 {
1557 packed_git = llist_mergesort(packed_git, get_next_packed_git,
1558 set_next_packed_git, sort_pack);
1559 }
1560
1561 static void prepare_packed_git_mru(void)
1562 {
1563 struct packed_git *p;
1564
1565 mru_clear(packed_git_mru);
1566 for (p = packed_git; p; p = p->next)
1567 mru_append(packed_git_mru, p);
1568 }
1569
1570 static int prepare_packed_git_run_once = 0;
1571 void prepare_packed_git(void)
1572 {
1573 struct alternate_object_database *alt;
1574
1575 if (prepare_packed_git_run_once)
1576 return;
1577 prepare_packed_git_one(get_object_directory(), 1);
1578 prepare_alt_odb();
1579 for (alt = alt_odb_list; alt; alt = alt->next)
1580 prepare_packed_git_one(alt->path, 0);
1581 rearrange_packed_git();
1582 prepare_packed_git_mru();
1583 prepare_packed_git_run_once = 1;
1584 }
1585
1586 void reprepare_packed_git(void)
1587 {
1588 approximate_object_count_valid = 0;
1589 prepare_packed_git_run_once = 0;
1590 prepare_packed_git();
1591 }
1592
1593 static void mark_bad_packed_object(struct packed_git *p,
1594 const unsigned char *sha1)
1595 {
1596 unsigned i;
1597 for (i = 0; i < p->num_bad_objects; i++)
1598 if (!hashcmp(sha1, p->bad_object_sha1 + GIT_SHA1_RAWSZ * i))
1599 return;
1600 p->bad_object_sha1 = xrealloc(p->bad_object_sha1,
1601 st_mult(GIT_MAX_RAWSZ,
1602 st_add(p->num_bad_objects, 1)));
1603 hashcpy(p->bad_object_sha1 + GIT_SHA1_RAWSZ * p->num_bad_objects, sha1);
1604 p->num_bad_objects++;
1605 }
1606
1607 static const struct packed_git *has_packed_and_bad(const unsigned char *sha1)
1608 {
1609 struct packed_git *p;
1610 unsigned i;
1611
1612 for (p = packed_git; p; p = p->next)
1613 for (i = 0; i < p->num_bad_objects; i++)
1614 if (!hashcmp(sha1, p->bad_object_sha1 + 20 * i))
1615 return p;
1616 return NULL;
1617 }
1618
1619 /*
1620 * With an in-core object data in "map", rehash it to make sure the
1621 * object name actually matches "sha1" to detect object corruption.
1622 * With "map" == NULL, try reading the object named with "sha1" using
1623 * the streaming interface and rehash it to do the same.
1624 */
1625 int check_sha1_signature(const unsigned char *sha1, void *map,
1626 unsigned long size, const char *type)
1627 {
1628 unsigned char real_sha1[20];
1629 enum object_type obj_type;
1630 struct git_istream *st;
1631 git_SHA_CTX c;
1632 char hdr[32];
1633 int hdrlen;
1634
1635 if (map) {
1636 hash_sha1_file(map, size, type, real_sha1);
1637 return hashcmp(sha1, real_sha1) ? -1 : 0;
1638 }
1639
1640 st = open_istream(sha1, &obj_type, &size, NULL);
1641 if (!st)
1642 return -1;
1643
1644 /* Generate the header */
1645 hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %lu", typename(obj_type), size) + 1;
1646
1647 /* Sha1.. */
1648 git_SHA1_Init(&c);
1649 git_SHA1_Update(&c, hdr, hdrlen);
1650 for (;;) {
1651 char buf[1024 * 16];
1652 ssize_t readlen = read_istream(st, buf, sizeof(buf));
1653
1654 if (readlen < 0) {
1655 close_istream(st);
1656 return -1;
1657 }
1658 if (!readlen)
1659 break;
1660 git_SHA1_Update(&c, buf, readlen);
1661 }
1662 git_SHA1_Final(real_sha1, &c);
1663 close_istream(st);
1664 return hashcmp(sha1, real_sha1) ? -1 : 0;
1665 }
1666
1667 int git_open_cloexec(const char *name, int flags)
1668 {
1669 int fd;
1670 static int o_cloexec = O_CLOEXEC;
1671
1672 fd = open(name, flags | o_cloexec);
1673 if ((o_cloexec & O_CLOEXEC) && fd < 0 && errno == EINVAL) {
1674 /* Try again w/o O_CLOEXEC: the kernel might not support it */
1675 o_cloexec &= ~O_CLOEXEC;
1676 fd = open(name, flags | o_cloexec);
1677 }
1678
1679 #if defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
1680 {
1681 static int fd_cloexec = FD_CLOEXEC;
1682
1683 if (!o_cloexec && 0 <= fd && fd_cloexec) {
1684 /* Opened w/o O_CLOEXEC? try with fcntl(2) to add it */
1685 int flags = fcntl(fd, F_GETFD);
1686 if (fcntl(fd, F_SETFD, flags | fd_cloexec))
1687 fd_cloexec = 0;
1688 }
1689 }
1690 #endif
1691 return fd;
1692 }
1693
1694 /*
1695 * Find "sha1" as a loose object in the local repository or in an alternate.
1696 * Returns 0 on success, negative on failure.
1697 *
1698 * The "path" out-parameter will give the path of the object we found (if any).
1699 * Note that it may point to static storage and is only valid until another
1700 * call to sha1_file_name(), etc.
1701 */
1702 static int stat_sha1_file(const unsigned char *sha1, struct stat *st,
1703 const char **path)
1704 {
1705 struct alternate_object_database *alt;
1706
1707 *path = sha1_file_name(sha1);
1708 if (!lstat(*path, st))
1709 return 0;
1710
1711 prepare_alt_odb();
1712 errno = ENOENT;
1713 for (alt = alt_odb_list; alt; alt = alt->next) {
1714 *path = alt_sha1_path(alt, sha1);
1715 if (!lstat(*path, st))
1716 return 0;
1717 }
1718
1719 return -1;
1720 }
1721
1722 /*
1723 * Like stat_sha1_file(), but actually open the object and return the
1724 * descriptor. See the caveats on the "path" parameter above.
1725 */
1726 static int open_sha1_file(const unsigned char *sha1, const char **path)
1727 {
1728 int fd;
1729 struct alternate_object_database *alt;
1730 int most_interesting_errno;
1731
1732 *path = sha1_file_name(sha1);
1733 fd = git_open(*path);
1734 if (fd >= 0)
1735 return fd;
1736 most_interesting_errno = errno;
1737
1738 prepare_alt_odb();
1739 for (alt = alt_odb_list; alt; alt = alt->next) {
1740 *path = alt_sha1_path(alt, sha1);
1741 fd = git_open(*path);
1742 if (fd >= 0)
1743 return fd;
1744 if (most_interesting_errno == ENOENT)
1745 most_interesting_errno = errno;
1746 }
1747 errno = most_interesting_errno;
1748 return -1;
1749 }
1750
1751 /*
1752 * Map the loose object at "path" if it is not NULL, or the path found by
1753 * searching for a loose object named "sha1".
1754 */
1755 static void *map_sha1_file_1(const char *path,
1756 const unsigned char *sha1,
1757 unsigned long *size)
1758 {
1759 void *map;
1760 int fd;
1761
1762 if (path)
1763 fd = git_open(path);
1764 else
1765 fd = open_sha1_file(sha1, &path);
1766 map = NULL;
1767 if (fd >= 0) {
1768 struct stat st;
1769
1770 if (!fstat(fd, &st)) {
1771 *size = xsize_t(st.st_size);
1772 if (!*size) {
1773 /* mmap() is forbidden on empty files */
1774 error("object file %s is empty", path);
1775 return NULL;
1776 }
1777 map = xmmap(NULL, *size, PROT_READ, MAP_PRIVATE, fd, 0);
1778 }
1779 close(fd);
1780 }
1781 return map;
1782 }
1783
1784 void *map_sha1_file(const unsigned char *sha1, unsigned long *size)
1785 {
1786 return map_sha1_file_1(NULL, sha1, size);
1787 }
1788
1789 unsigned long unpack_object_header_buffer(const unsigned char *buf,
1790 unsigned long len, enum object_type *type, unsigned long *sizep)
1791 {
1792 unsigned shift;
1793 unsigned long size, c;
1794 unsigned long used = 0;
1795
1796 c = buf[used++];
1797 *type = (c >> 4) & 7;
1798 size = c & 15;
1799 shift = 4;
1800 while (c & 0x80) {
1801 if (len <= used || bitsizeof(long) <= shift) {
1802 error("bad object header");
1803 size = used = 0;
1804 break;
1805 }
1806 c = buf[used++];
1807 size += (c & 0x7f) << shift;
1808 shift += 7;
1809 }
1810 *sizep = size;
1811 return used;
1812 }
1813
1814 static int unpack_sha1_short_header(git_zstream *stream,
1815 unsigned char *map, unsigned long mapsize,
1816 void *buffer, unsigned long bufsiz)
1817 {
1818 /* Get the data stream */
1819 memset(stream, 0, sizeof(*stream));
1820 stream->next_in = map;
1821 stream->avail_in = mapsize;
1822 stream->next_out = buffer;
1823 stream->avail_out = bufsiz;
1824
1825 git_inflate_init(stream);
1826 return git_inflate(stream, 0);
1827 }
1828
1829 int unpack_sha1_header(git_zstream *stream,
1830 unsigned char *map, unsigned long mapsize,
1831 void *buffer, unsigned long bufsiz)
1832 {
1833 int status = unpack_sha1_short_header(stream, map, mapsize,
1834 buffer, bufsiz);
1835
1836 if (status < Z_OK)
1837 return status;
1838
1839 /* Make sure we have the terminating NUL */
1840 if (!memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer))
1841 return -1;
1842 return 0;
1843 }
1844
1845 static int unpack_sha1_header_to_strbuf(git_zstream *stream, unsigned char *map,
1846 unsigned long mapsize, void *buffer,
1847 unsigned long bufsiz, struct strbuf *header)
1848 {
1849 int status;
1850
1851 status = unpack_sha1_short_header(stream, map, mapsize, buffer, bufsiz);
1852 if (status < Z_OK)
1853 return -1;
1854
1855 /*
1856 * Check if entire header is unpacked in the first iteration.
1857 */
1858 if (memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer))
1859 return 0;
1860
1861 /*
1862 * buffer[0..bufsiz] was not large enough. Copy the partial
1863 * result out to header, and then append the result of further
1864 * reading the stream.
1865 */
1866 strbuf_add(header, buffer, stream->next_out - (unsigned char *)buffer);
1867 stream->next_out = buffer;
1868 stream->avail_out = bufsiz;
1869
1870 do {
1871 status = git_inflate(stream, 0);
1872 strbuf_add(header, buffer, stream->next_out - (unsigned char *)buffer);
1873 if (memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer))
1874 return 0;
1875 stream->next_out = buffer;
1876 stream->avail_out = bufsiz;
1877 } while (status != Z_STREAM_END);
1878 return -1;
1879 }
1880
1881 static void *unpack_sha1_rest(git_zstream *stream, void *buffer, unsigned long size, const unsigned char *sha1)
1882 {
1883 int bytes = strlen(buffer) + 1;
1884 unsigned char *buf = xmallocz(size);
1885 unsigned long n;
1886 int status = Z_OK;
1887
1888 n = stream->total_out - bytes;
1889 if (n > size)
1890 n = size;
1891 memcpy(buf, (char *) buffer + bytes, n);
1892 bytes = n;
1893 if (bytes <= size) {
1894 /*
1895 * The above condition must be (bytes <= size), not
1896 * (bytes < size). In other words, even though we
1897 * expect no more output and set avail_out to zero,
1898 * the input zlib stream may have bytes that express
1899 * "this concludes the stream", and we *do* want to
1900 * eat that input.
1901 *
1902 * Otherwise we would not be able to test that we
1903 * consumed all the input to reach the expected size;
1904 * we also want to check that zlib tells us that all
1905 * went well with status == Z_STREAM_END at the end.
1906 */
1907 stream->next_out = buf + bytes;
1908 stream->avail_out = size - bytes;
1909 while (status == Z_OK)
1910 status = git_inflate(stream, Z_FINISH);
1911 }
1912 if (status == Z_STREAM_END && !stream->avail_in) {
1913 git_inflate_end(stream);
1914 return buf;
1915 }
1916
1917 if (status < 0)
1918 error("corrupt loose object '%s'", sha1_to_hex(sha1));
1919 else if (stream->avail_in)
1920 error("garbage at end of loose object '%s'",
1921 sha1_to_hex(sha1));
1922 free(buf);
1923 return NULL;
1924 }
1925
1926 /*
1927 * We used to just use "sscanf()", but that's actually way
1928 * too permissive for what we want to check. So do an anal
1929 * object header parse by hand.
1930 */
1931 static int parse_sha1_header_extended(const char *hdr, struct object_info *oi,
1932 unsigned int flags)
1933 {
1934 const char *type_buf = hdr;
1935 unsigned long size;
1936 int type, type_len = 0;
1937
1938 /*
1939 * The type can be of any size but is followed by
1940 * a space.
1941 */
1942 for (;;) {
1943 char c = *hdr++;
1944 if (!c)
1945 return -1;
1946 if (c == ' ')
1947 break;
1948 type_len++;
1949 }
1950
1951 type = type_from_string_gently(type_buf, type_len, 1);
1952 if (oi->typename)
1953 strbuf_add(oi->typename, type_buf, type_len);
1954 /*
1955 * Set type to 0 if its an unknown object and
1956 * we're obtaining the type using '--allow-unknown-type'
1957 * option.
1958 */
1959 if ((flags & OBJECT_INFO_ALLOW_UNKNOWN_TYPE) && (type < 0))
1960 type = 0;
1961 else if (type < 0)
1962 die("invalid object type");
1963 if (oi->typep)
1964 *oi->typep = type;
1965
1966 /*
1967 * The length must follow immediately, and be in canonical
1968 * decimal format (ie "010" is not valid).
1969 */
1970 size = *hdr++ - '0';
1971 if (size > 9)
1972 return -1;
1973 if (size) {
1974 for (;;) {
1975 unsigned long c = *hdr - '0';
1976 if (c > 9)
1977 break;
1978 hdr++;
1979 size = size * 10 + c;
1980 }
1981 }
1982
1983 if (oi->sizep)
1984 *oi->sizep = size;
1985
1986 /*
1987 * The length must be followed by a zero byte
1988 */
1989 return *hdr ? -1 : type;
1990 }
1991
1992 int parse_sha1_header(const char *hdr, unsigned long *sizep)
1993 {
1994 struct object_info oi = OBJECT_INFO_INIT;
1995
1996 oi.sizep = sizep;
1997 return parse_sha1_header_extended(hdr, &oi, 0);
1998 }
1999
2000 unsigned long get_size_from_delta(struct packed_git *p,
2001 struct pack_window **w_curs,
2002 off_t curpos)
2003 {
2004 const unsigned char *data;
2005 unsigned char delta_head[20], *in;
2006 git_zstream stream;
2007 int st;
2008
2009 memset(&stream, 0, sizeof(stream));
2010 stream.next_out = delta_head;
2011 stream.avail_out = sizeof(delta_head);
2012
2013 git_inflate_init(&stream);
2014 do {
2015 in = use_pack(p, w_curs, curpos, &stream.avail_in);
2016 stream.next_in = in;
2017 st = git_inflate(&stream, Z_FINISH);
2018 curpos += stream.next_in - in;
2019 } while ((st == Z_OK || st == Z_BUF_ERROR) &&
2020 stream.total_out < sizeof(delta_head));
2021 git_inflate_end(&stream);
2022 if ((st != Z_STREAM_END) && stream.total_out != sizeof(delta_head)) {
2023 error("delta data unpack-initial failed");
2024 return 0;
2025 }
2026
2027 /* Examine the initial part of the delta to figure out
2028 * the result size.
2029 */
2030 data = delta_head;
2031
2032 /* ignore base size */
2033 get_delta_hdr_size(&data, delta_head+sizeof(delta_head));
2034
2035 /* Read the result size */
2036 return get_delta_hdr_size(&data, delta_head+sizeof(delta_head));
2037 }
2038
2039 static off_t get_delta_base(struct packed_git *p,
2040 struct pack_window **w_curs,
2041 off_t *curpos,
2042 enum object_type type,
2043 off_t delta_obj_offset)
2044 {
2045 unsigned char *base_info = use_pack(p, w_curs, *curpos, NULL);
2046 off_t base_offset;
2047
2048 /* use_pack() assured us we have [base_info, base_info + 20)
2049 * as a range that we can look at without walking off the
2050 * end of the mapped window. Its actually the hash size
2051 * that is assured. An OFS_DELTA longer than the hash size
2052 * is stupid, as then a REF_DELTA would be smaller to store.
2053 */
2054 if (type == OBJ_OFS_DELTA) {
2055 unsigned used = 0;
2056 unsigned char c = base_info[used++];
2057 base_offset = c & 127;
2058 while (c & 128) {
2059 base_offset += 1;
2060 if (!base_offset || MSB(base_offset, 7))
2061 return 0; /* overflow */
2062 c = base_info[used++];
2063 base_offset = (base_offset << 7) + (c & 127);
2064 }
2065 base_offset = delta_obj_offset - base_offset;
2066 if (base_offset <= 0 || base_offset >= delta_obj_offset)
2067 return 0; /* out of bound */
2068 *curpos += used;
2069 } else if (type == OBJ_REF_DELTA) {
2070 /* The base entry _must_ be in the same pack */
2071 base_offset = find_pack_entry_one(base_info, p);
2072 *curpos += 20;
2073 } else
2074 die("I am totally screwed");
2075 return base_offset;
2076 }
2077
2078 /*
2079 * Like get_delta_base above, but we return the sha1 instead of the pack
2080 * offset. This means it is cheaper for REF deltas (we do not have to do
2081 * the final object lookup), but more expensive for OFS deltas (we
2082 * have to load the revidx to convert the offset back into a sha1).
2083 */
2084 static const unsigned char *get_delta_base_sha1(struct packed_git *p,
2085 struct pack_window **w_curs,
2086 off_t curpos,
2087 enum object_type type,
2088 off_t delta_obj_offset)
2089 {
2090 if (type == OBJ_REF_DELTA) {
2091 unsigned char *base = use_pack(p, w_curs, curpos, NULL);
2092 return base;
2093 } else if (type == OBJ_OFS_DELTA) {
2094 struct revindex_entry *revidx;
2095 off_t base_offset = get_delta_base(p, w_curs, &curpos,
2096 type, delta_obj_offset);
2097
2098 if (!base_offset)
2099 return NULL;
2100
2101 revidx = find_pack_revindex(p, base_offset);
2102 if (!revidx)
2103 return NULL;
2104
2105 return nth_packed_object_sha1(p, revidx->nr);
2106 } else
2107 return NULL;
2108 }
2109
2110 int unpack_object_header(struct packed_git *p,
2111 struct pack_window **w_curs,
2112 off_t *curpos,
2113 unsigned long *sizep)
2114 {
2115 unsigned char *base;
2116 unsigned long left;
2117 unsigned long used;
2118 enum object_type type;
2119
2120 /* use_pack() assures us we have [base, base + 20) available
2121 * as a range that we can look at. (Its actually the hash
2122 * size that is assured.) With our object header encoding
2123 * the maximum deflated object size is 2^137, which is just
2124 * insane, so we know won't exceed what we have been given.
2125 */
2126 base = use_pack(p, w_curs, *curpos, &left);
2127 used = unpack_object_header_buffer(base, left, &type, sizep);
2128 if (!used) {
2129 type = OBJ_BAD;
2130 } else
2131 *curpos += used;
2132
2133 return type;
2134 }
2135
2136 static int retry_bad_packed_offset(struct packed_git *p, off_t obj_offset)
2137 {
2138 int type;
2139 struct revindex_entry *revidx;
2140 const unsigned char *sha1;
2141 revidx = find_pack_revindex(p, obj_offset);
2142 if (!revidx)
2143 return OBJ_BAD;
2144 sha1 = nth_packed_object_sha1(p, revidx->nr);
2145 mark_bad_packed_object(p, sha1);
2146 type = sha1_object_info(sha1, NULL);
2147 if (type <= OBJ_NONE)
2148 return OBJ_BAD;
2149 return type;
2150 }
2151
2152 #define POI_STACK_PREALLOC 64
2153
2154 static enum object_type packed_to_object_type(struct packed_git *p,
2155 off_t obj_offset,
2156 enum object_type type,
2157 struct pack_window **w_curs,
2158 off_t curpos)
2159 {
2160 off_t small_poi_stack[POI_STACK_PREALLOC];
2161 off_t *poi_stack = small_poi_stack;
2162 int poi_stack_nr = 0, poi_stack_alloc = POI_STACK_PREALLOC;
2163
2164 while (type == OBJ_OFS_DELTA || type == OBJ_REF_DELTA) {
2165 off_t base_offset;
2166 unsigned long size;
2167 /* Push the object we're going to leave behind */
2168 if (poi_stack_nr >= poi_stack_alloc && poi_stack == small_poi_stack) {
2169 poi_stack_alloc = alloc_nr(poi_stack_nr);
2170 ALLOC_ARRAY(poi_stack, poi_stack_alloc);
2171 memcpy(poi_stack, small_poi_stack, sizeof(off_t)*poi_stack_nr);
2172 } else {
2173 ALLOC_GROW(poi_stack, poi_stack_nr+1, poi_stack_alloc);
2174 }
2175 poi_stack[poi_stack_nr++] = obj_offset;
2176 /* If parsing the base offset fails, just unwind */
2177 base_offset = get_delta_base(p, w_curs, &curpos, type, obj_offset);
2178 if (!base_offset)
2179 goto unwind;
2180 curpos = obj_offset = base_offset;
2181 type = unpack_object_header(p, w_curs, &curpos, &size);
2182 if (type <= OBJ_NONE) {
2183 /* If getting the base itself fails, we first
2184 * retry the base, otherwise unwind */
2185 type = retry_bad_packed_offset(p, base_offset);
2186 if (type > OBJ_NONE)
2187 goto out;
2188 goto unwind;
2189 }
2190 }
2191
2192 switch (type) {
2193 case OBJ_BAD:
2194 case OBJ_COMMIT:
2195 case OBJ_TREE:
2196 case OBJ_BLOB:
2197 case OBJ_TAG:
2198 break;
2199 default:
2200 error("unknown object type %i at offset %"PRIuMAX" in %s",
2201 type, (uintmax_t)obj_offset, p->pack_name);
2202 type = OBJ_BAD;
2203 }
2204
2205 out:
2206 if (poi_stack != small_poi_stack)
2207 free(poi_stack);
2208 return type;
2209
2210 unwind:
2211 while (poi_stack_nr) {
2212 obj_offset = poi_stack[--poi_stack_nr];
2213 type = retry_bad_packed_offset(p, obj_offset);
2214 if (type > OBJ_NONE)
2215 goto out;
2216 }
2217 type = OBJ_BAD;
2218 goto out;
2219 }
2220
2221 static struct hashmap delta_base_cache;
2222 static size_t delta_base_cached;
2223
2224 static LIST_HEAD(delta_base_cache_lru);
2225
2226 struct delta_base_cache_key {
2227 struct packed_git *p;
2228 off_t base_offset;
2229 };
2230
2231 struct delta_base_cache_entry {
2232 struct hashmap hash;
2233 struct delta_base_cache_key key;
2234 struct list_head lru;
2235 void *data;
2236 unsigned long size;
2237 enum object_type type;
2238 };
2239
2240 static unsigned int pack_entry_hash(struct packed_git *p, off_t base_offset)
2241 {
2242 unsigned int hash;
2243
2244 hash = (unsigned int)(intptr_t)p + (unsigned int)base_offset;
2245 hash += (hash >> 8) + (hash >> 16);
2246 return hash;
2247 }
2248
2249 static struct delta_base_cache_entry *
2250 get_delta_base_cache_entry(struct packed_git *p, off_t base_offset)
2251 {
2252 struct hashmap_entry entry;
2253 struct delta_base_cache_key key;
2254
2255 if (!delta_base_cache.cmpfn)
2256 return NULL;
2257
2258 hashmap_entry_init(&entry, pack_entry_hash(p, base_offset));
2259 key.p = p;
2260 key.base_offset = base_offset;
2261 return hashmap_get(&delta_base_cache, &entry, &key);
2262 }
2263
2264 static int delta_base_cache_key_eq(const struct delta_base_cache_key *a,
2265 const struct delta_base_cache_key *b)
2266 {
2267 return a->p == b->p && a->base_offset == b->base_offset;
2268 }
2269
2270 static int delta_base_cache_hash_cmp(const void *unused_cmp_data,
2271 const void *va, const void *vb,
2272 const void *vkey)
2273 {
2274 const struct delta_base_cache_entry *a = va, *b = vb;
2275 const struct delta_base_cache_key *key = vkey;
2276 if (key)
2277 return !delta_base_cache_key_eq(&a->key, key);
2278 else
2279 return !delta_base_cache_key_eq(&a->key, &b->key);
2280 }
2281
2282 static int in_delta_base_cache(struct packed_git *p, off_t base_offset)
2283 {
2284 return !!get_delta_base_cache_entry(p, base_offset);
2285 }
2286
2287 /*
2288 * Remove the entry from the cache, but do _not_ free the associated
2289 * entry data. The caller takes ownership of the "data" buffer, and
2290 * should copy out any fields it wants before detaching.
2291 */
2292 static void detach_delta_base_cache_entry(struct delta_base_cache_entry *ent)
2293 {
2294 hashmap_remove(&delta_base_cache, ent, &ent->key);
2295 list_del(&ent->lru);
2296 delta_base_cached -= ent->size;
2297 free(ent);
2298 }
2299
2300 static void *cache_or_unpack_entry(struct packed_git *p, off_t base_offset,
2301 unsigned long *base_size, enum object_type *type)
2302 {
2303 struct delta_base_cache_entry *ent;
2304
2305 ent = get_delta_base_cache_entry(p, base_offset);
2306 if (!ent)
2307 return unpack_entry(p, base_offset, type, base_size);
2308
2309 if (type)
2310 *type = ent->type;
2311 if (base_size)
2312 *base_size = ent->size;
2313 return xmemdupz(ent->data, ent->size);
2314 }
2315
2316 static inline void release_delta_base_cache(struct delta_base_cache_entry *ent)
2317 {
2318 free(ent->data);
2319 detach_delta_base_cache_entry(ent);
2320 }
2321
2322 void clear_delta_base_cache(void)
2323 {
2324 struct list_head *lru, *tmp;
2325 list_for_each_safe(lru, tmp, &delta_base_cache_lru) {
2326 struct delta_base_cache_entry *entry =
2327 list_entry(lru, struct delta_base_cache_entry, lru);
2328 release_delta_base_cache(entry);
2329 }
2330 }
2331
2332 static void add_delta_base_cache(struct packed_git *p, off_t base_offset,
2333 void *base, unsigned long base_size, enum object_type type)
2334 {
2335 struct delta_base_cache_entry *ent = xmalloc(sizeof(*ent));
2336 struct list_head *lru, *tmp;
2337
2338 delta_base_cached += base_size;
2339
2340 list_for_each_safe(lru, tmp, &delta_base_cache_lru) {
2341 struct delta_base_cache_entry *f =
2342 list_entry(lru, struct delta_base_cache_entry, lru);
2343 if (delta_base_cached <= delta_base_cache_limit)
2344 break;
2345 release_delta_base_cache(f);
2346 }
2347
2348 ent->key.p = p;
2349 ent->key.base_offset = base_offset;
2350 ent->type = type;
2351 ent->data = base;
2352 ent->size = base_size;
2353 list_add_tail(&ent->lru, &delta_base_cache_lru);
2354
2355 if (!delta_base_cache.cmpfn)
2356 hashmap_init(&delta_base_cache, delta_base_cache_hash_cmp, NULL, 0);
2357 hashmap_entry_init(ent, pack_entry_hash(p, base_offset));
2358 hashmap_add(&delta_base_cache, ent);
2359 }
2360
2361 int packed_object_info(struct packed_git *p, off_t obj_offset,
2362 struct object_info *oi)
2363 {
2364 struct pack_window *w_curs = NULL;
2365 unsigned long size;
2366 off_t curpos = obj_offset;
2367 enum object_type type;
2368
2369 /*
2370 * We always get the representation type, but only convert it to
2371 * a "real" type later if the caller is interested.
2372 */
2373 if (oi->contentp) {
2374 *oi->contentp = cache_or_unpack_entry(p, obj_offset, oi->sizep,
2375 &type);
2376 if (!*oi->contentp)
2377 type = OBJ_BAD;
2378 } else {
2379 type = unpack_object_header(p, &w_curs, &curpos, &size);
2380 }
2381
2382 if (!oi->contentp && oi->sizep) {
2383 if (type == OBJ_OFS_DELTA || type == OBJ_REF_DELTA) {
2384 off_t tmp_pos = curpos;
2385 off_t base_offset = get_delta_base(p, &w_curs, &tmp_pos,
2386 type, obj_offset);
2387 if (!base_offset) {
2388 type = OBJ_BAD;
2389 goto out;
2390 }
2391 *oi->sizep = get_size_from_delta(p, &w_curs, tmp_pos);
2392 if (*oi->sizep == 0) {
2393 type = OBJ_BAD;
2394 goto out;
2395 }
2396 } else {
2397 *oi->sizep = size;
2398 }
2399 }
2400
2401 if (oi->disk_sizep) {
2402 struct revindex_entry *revidx = find_pack_revindex(p, obj_offset);
2403 *oi->disk_sizep = revidx[1].offset - obj_offset;
2404 }
2405
2406 if (oi->typep || oi->typename) {
2407 enum object_type ptot;
2408 ptot = packed_to_object_type(p, obj_offset, type, &w_curs,
2409 curpos);
2410 if (oi->typep)
2411 *oi->typep = ptot;
2412 if (oi->typename) {
2413 const char *tn = typename(ptot);
2414 if (tn)
2415 strbuf_addstr(oi->typename, tn);
2416 }
2417 if (ptot < 0) {
2418 type = OBJ_BAD;
2419 goto out;
2420 }
2421 }
2422
2423 if (oi->delta_base_sha1) {
2424 if (type == OBJ_OFS_DELTA || type == OBJ_REF_DELTA) {
2425 const unsigned char *base;
2426
2427 base = get_delta_base_sha1(p, &w_curs, curpos,
2428 type, obj_offset);
2429 if (!base) {
2430 type = OBJ_BAD;
2431 goto out;
2432 }
2433
2434 hashcpy(oi->delta_base_sha1, base);
2435 } else
2436 hashclr(oi->delta_base_sha1);
2437 }
2438
2439 out:
2440 unuse_pack(&w_curs);
2441 return type;
2442 }
2443
2444 static void *unpack_compressed_entry(struct packed_git *p,
2445 struct pack_window **w_curs,
2446 off_t curpos,
2447 unsigned long size)
2448 {
2449 int st;
2450 git_zstream stream;
2451 unsigned char *buffer, *in;
2452
2453 buffer = xmallocz_gently(size);
2454 if (!buffer)
2455 return NULL;
2456 memset(&stream, 0, sizeof(stream));
2457 stream.next_out = buffer;
2458 stream.avail_out = size + 1;
2459
2460 git_inflate_init(&stream);
2461 do {
2462 in = use_pack(p, w_curs, curpos, &stream.avail_in);
2463 stream.next_in = in;
2464 st = git_inflate(&stream, Z_FINISH);
2465 if (!stream.avail_out)
2466 break; /* the payload is larger than it should be */
2467 curpos += stream.next_in - in;
2468 } while (st == Z_OK || st == Z_BUF_ERROR);
2469 git_inflate_end(&stream);
2470 if ((st != Z_STREAM_END) || stream.total_out != size) {
2471 free(buffer);
2472 return NULL;
2473 }
2474
2475 return buffer;
2476 }
2477
2478 static void *read_object(const unsigned char *sha1, enum object_type *type,
2479 unsigned long *size);
2480
2481 static void write_pack_access_log(struct packed_git *p, off_t obj_offset)
2482 {
2483 static struct trace_key pack_access = TRACE_KEY_INIT(PACK_ACCESS);
2484 trace_printf_key(&pack_access, "%s %"PRIuMAX"\n",
2485 p->pack_name, (uintmax_t)obj_offset);
2486 }
2487
2488 int do_check_packed_object_crc;
2489
2490 #define UNPACK_ENTRY_STACK_PREALLOC 64
2491 struct unpack_entry_stack_ent {
2492 off_t obj_offset;
2493 off_t curpos;
2494 unsigned long size;
2495 };
2496
2497 void *unpack_entry(struct packed_git *p, off_t obj_offset,
2498 enum object_type *final_type, unsigned long *final_size)
2499 {
2500 struct pack_window *w_curs = NULL;
2501 off_t curpos = obj_offset;
2502 void *data = NULL;
2503 unsigned long size;
2504 enum object_type type;
2505 struct unpack_entry_stack_ent small_delta_stack[UNPACK_ENTRY_STACK_PREALLOC];
2506 struct unpack_entry_stack_ent *delta_stack = small_delta_stack;
2507 int delta_stack_nr = 0, delta_stack_alloc = UNPACK_ENTRY_STACK_PREALLOC;
2508 int base_from_cache = 0;
2509
2510 write_pack_access_log(p, obj_offset);
2511
2512 /* PHASE 1: drill down to the innermost base object */
2513 for (;;) {
2514 off_t base_offset;
2515 int i;
2516 struct delta_base_cache_entry *ent;
2517
2518 ent = get_delta_base_cache_entry(p, curpos);
2519 if (ent) {
2520 type = ent->type;
2521 data = ent->data;
2522 size = ent->size;
2523 detach_delta_base_cache_entry(ent);
2524 base_from_cache = 1;
2525 break;
2526 }
2527
2528 if (do_check_packed_object_crc && p->index_version > 1) {
2529 struct revindex_entry *revidx = find_pack_revindex(p, obj_offset);
2530 off_t len = revidx[1].offset - obj_offset;
2531 if (check_pack_crc(p, &w_curs, obj_offset, len, revidx->nr)) {
2532 const unsigned char *sha1 =
2533 nth_packed_object_sha1(p, revidx->nr);
2534 error("bad packed object CRC for %s",
2535 sha1_to_hex(sha1));
2536 mark_bad_packed_object(p, sha1);
2537 data = NULL;
2538 goto out;
2539 }
2540 }
2541
2542 type = unpack_object_header(p, &w_curs, &curpos, &size);
2543 if (type != OBJ_OFS_DELTA && type != OBJ_REF_DELTA)
2544 break;
2545
2546 base_offset = get_delta_base(p, &w_curs, &curpos, type, obj_offset);
2547 if (!base_offset) {
2548 error("failed to validate delta base reference "
2549 "at offset %"PRIuMAX" from %s",
2550 (uintmax_t)curpos, p->pack_name);
2551 /* bail to phase 2, in hopes of recovery */
2552 data = NULL;
2553 break;
2554 }
2555
2556 /* push object, proceed to base */
2557 if (delta_stack_nr >= delta_stack_alloc
2558 && delta_stack == small_delta_stack) {
2559 delta_stack_alloc = alloc_nr(delta_stack_nr);
2560 ALLOC_ARRAY(delta_stack, delta_stack_alloc);
2561 memcpy(delta_stack, small_delta_stack,
2562 sizeof(*delta_stack)*delta_stack_nr);
2563 } else {
2564 ALLOC_GROW(delta_stack, delta_stack_nr+1, delta_stack_alloc);
2565 }
2566 i = delta_stack_nr++;
2567 delta_stack[i].obj_offset = obj_offset;
2568 delta_stack[i].curpos = curpos;
2569 delta_stack[i].size = size;
2570
2571 curpos = obj_offset = base_offset;
2572 }
2573
2574 /* PHASE 2: handle the base */
2575 switch (type) {
2576 case OBJ_OFS_DELTA:
2577 case OBJ_REF_DELTA:
2578 if (data)
2579 die("BUG: unpack_entry: left loop at a valid delta");
2580 break;
2581 case OBJ_COMMIT:
2582 case OBJ_TREE:
2583 case OBJ_BLOB:
2584 case OBJ_TAG:
2585 if (!base_from_cache)
2586 data = unpack_compressed_entry(p, &w_curs, curpos, size);
2587 break;
2588 default:
2589 data = NULL;
2590 error("unknown object type %i at offset %"PRIuMAX" in %s",
2591 type, (uintmax_t)obj_offset, p->pack_name);
2592 }
2593
2594 /* PHASE 3: apply deltas in order */
2595
2596 /* invariants:
2597 * 'data' holds the base data, or NULL if there was corruption
2598 */
2599 while (delta_stack_nr) {
2600 void *delta_data;
2601 void *base = data;
2602 void *external_base = NULL;
2603 unsigned long delta_size, base_size = size;
2604 int i;
2605
2606 data = NULL;
2607
2608 if (base)
2609 add_delta_base_cache(p, obj_offset, base, base_size, type);
2610
2611 if (!base) {
2612 /*
2613 * We're probably in deep shit, but let's try to fetch
2614 * the required base anyway from another pack or loose.
2615 * This is costly but should happen only in the presence
2616 * of a corrupted pack, and is better than failing outright.
2617 */
2618 struct revindex_entry *revidx;
2619 const unsigned char *base_sha1;
2620 revidx = find_pack_revindex(p, obj_offset);
2621 if (revidx) {
2622 base_sha1 = nth_packed_object_sha1(p, revidx->nr);
2623 error("failed to read delta base object %s"
2624 " at offset %"PRIuMAX" from %s",
2625 sha1_to_hex(base_sha1), (uintmax_t)obj_offset,
2626 p->pack_name);
2627 mark_bad_packed_object(p, base_sha1);
2628 base = read_object(base_sha1, &type, &base_size);
2629 external_base = base;
2630 }
2631 }
2632
2633 i = --delta_stack_nr;
2634 obj_offset = delta_stack[i].obj_offset;
2635 curpos = delta_stack[i].curpos;
2636 delta_size = delta_stack[i].size;
2637
2638 if (!base)
2639 continue;
2640
2641 delta_data = unpack_compressed_entry(p, &w_curs, curpos, delta_size);
2642
2643 if (!delta_data) {
2644 error("failed to unpack compressed delta "
2645 "at offset %"PRIuMAX" from %s",
2646 (uintmax_t)curpos, p->pack_name);
2647 data = NULL;
2648 free(external_base);
2649 continue;
2650 }
2651
2652 data = patch_delta(base, base_size,
2653 delta_data, delta_size,
2654 &size);
2655
2656 /*
2657 * We could not apply the delta; warn the user, but keep going.
2658 * Our failure will be noticed either in the next iteration of
2659 * the loop, or if this is the final delta, in the caller when
2660 * we return NULL. Those code paths will take care of making
2661 * a more explicit warning and retrying with another copy of
2662 * the object.
2663 */
2664 if (!data)
2665 error("failed to apply delta");
2666
2667 free(delta_data);
2668 free(external_base);
2669 }
2670
2671 if (final_type)
2672 *final_type = type;
2673 if (final_size)
2674 *final_size = size;
2675
2676 out:
2677 unuse_pack(&w_curs);
2678
2679 if (delta_stack != small_delta_stack)
2680 free(delta_stack);
2681
2682 return data;
2683 }
2684
2685 const unsigned char *nth_packed_object_sha1(struct packed_git *p,
2686 uint32_t n)
2687 {
2688 const unsigned char *index = p->index_data;
2689 if (!index) {
2690 if (open_pack_index(p))
2691 return NULL;
2692 index = p->index_data;
2693 }
2694 if (n >= p->num_objects)
2695 return NULL;
2696 index += 4 * 256;
2697 if (p->index_version == 1) {
2698 return index + 24 * n + 4;
2699 } else {
2700 index += 8;
2701 return index + 20 * n;
2702 }
2703 }
2704
2705 const struct object_id *nth_packed_object_oid(struct object_id *oid,
2706 struct packed_git *p,
2707 uint32_t n)
2708 {
2709 const unsigned char *hash = nth_packed_object_sha1(p, n);
2710 if (!hash)
2711 return NULL;
2712 hashcpy(oid->hash, hash);
2713 return oid;
2714 }
2715
2716 void check_pack_index_ptr(const struct packed_git *p, const void *vptr)
2717 {
2718 const unsigned char *ptr = vptr;
2719 const unsigned char *start = p->index_data;
2720 const unsigned char *end = start + p->index_size;
2721 if (ptr < start)
2722 die(_("offset before start of pack index for %s (corrupt index?)"),
2723 p->pack_name);
2724 /* No need to check for underflow; .idx files must be at least 8 bytes */
2725 if (ptr >= end - 8)
2726 die(_("offset beyond end of pack index for %s (truncated index?)"),
2727 p->pack_name);
2728 }
2729
2730 off_t nth_packed_object_offset(const struct packed_git *p, uint32_t n)
2731 {
2732 const unsigned char *index = p->index_data;
2733 index += 4 * 256;
2734 if (p->index_version == 1) {
2735 return ntohl(*((uint32_t *)(index + 24 * n)));
2736 } else {
2737 uint32_t off;
2738 index += 8 + p->num_objects * (20 + 4);
2739 off = ntohl(*((uint32_t *)(index + 4 * n)));
2740 if (!(off & 0x80000000))
2741 return off;
2742 index += p->num_objects * 4 + (off & 0x7fffffff) * 8;
2743 check_pack_index_ptr(p, index);
2744 return (((uint64_t)ntohl(*((uint32_t *)(index + 0)))) << 32) |
2745 ntohl(*((uint32_t *)(index + 4)));
2746 }
2747 }
2748
2749 off_t find_pack_entry_one(const unsigned char *sha1,
2750 struct packed_git *p)
2751 {
2752 const uint32_t *level1_ofs = p->index_data;
2753 const unsigned char *index = p->index_data;
2754 unsigned hi, lo, stride;
2755 static int use_lookup = -1;
2756 static int debug_lookup = -1;
2757
2758 if (debug_lookup < 0)
2759 debug_lookup = !!getenv("GIT_DEBUG_LOOKUP");
2760
2761 if (!index) {
2762 if (open_pack_index(p))
2763 return 0;
2764 level1_ofs = p->index_data;
2765 index = p->index_data;
2766 }
2767 if (p->index_version > 1) {
2768 level1_ofs += 2;
2769 index += 8;
2770 }
2771 index += 4 * 256;
2772 hi = ntohl(level1_ofs[*sha1]);
2773 lo = ((*sha1 == 0x0) ? 0 : ntohl(level1_ofs[*sha1 - 1]));
2774 if (p->index_version > 1) {
2775 stride = 20;
2776 } else {
2777 stride = 24;
2778 index += 4;
2779 }
2780
2781 if (debug_lookup)
2782 printf("%02x%02x%02x... lo %u hi %u nr %"PRIu32"\n",
2783 sha1[0], sha1[1], sha1[2], lo, hi, p->num_objects);
2784
2785 if (use_lookup < 0)
2786 use_lookup = !!getenv("GIT_USE_LOOKUP");
2787 if (use_lookup) {
2788 int pos = sha1_entry_pos(index, stride, 0,
2789 lo, hi, p->num_objects, sha1);
2790 if (pos < 0)
2791 return 0;
2792 return nth_packed_object_offset(p, pos);
2793 }
2794
2795 while (lo < hi) {
2796 unsigned mi = (lo + hi) / 2;
2797 int cmp = hashcmp(index + mi * stride, sha1);
2798
2799 if (debug_lookup)
2800 printf("lo %u hi %u rg %u mi %u\n",
2801 lo, hi, hi - lo, mi);
2802 if (!cmp)
2803 return nth_packed_object_offset(p, mi);
2804 if (cmp > 0)
2805 hi = mi;
2806 else
2807 lo = mi+1;
2808 }
2809 return 0;
2810 }
2811
2812 int is_pack_valid(struct packed_git *p)
2813 {
2814 /* An already open pack is known to be valid. */
2815 if (p->pack_fd != -1)
2816 return 1;
2817
2818 /* If the pack has one window completely covering the
2819 * file size, the pack is known to be valid even if
2820 * the descriptor is not currently open.
2821 */
2822 if (p->windows) {
2823 struct pack_window *w = p->windows;
2824
2825 if (!w->offset && w->len == p->pack_size)
2826 return 1;
2827 }
2828
2829 /* Force the pack to open to prove its valid. */
2830 return !open_packed_git(p);
2831 }
2832
2833 static int fill_pack_entry(const unsigned char *sha1,
2834 struct pack_entry *e,
2835 struct packed_git *p)
2836 {
2837 off_t offset;
2838
2839 if (p->num_bad_objects) {
2840 unsigned i;
2841 for (i = 0; i < p->num_bad_objects; i++)
2842 if (!hashcmp(sha1, p->bad_object_sha1 + 20 * i))
2843 return 0;
2844 }
2845
2846 offset = find_pack_entry_one(sha1, p);
2847 if (!offset)
2848 return 0;
2849
2850 /*
2851 * We are about to tell the caller where they can locate the
2852 * requested object. We better make sure the packfile is
2853 * still here and can be accessed before supplying that
2854 * answer, as it may have been deleted since the index was
2855 * loaded!
2856 */
2857 if (!is_pack_valid(p))
2858 return 0;
2859 e->offset = offset;
2860 e->p = p;
2861 hashcpy(e->sha1, sha1);
2862 return 1;
2863 }
2864
2865 /*
2866 * Iff a pack file contains the object named by sha1, return true and
2867 * store its location to e.
2868 */
2869 static int find_pack_entry(const unsigned char *sha1, struct pack_entry *e)
2870 {
2871 struct mru_entry *p;
2872
2873 prepare_packed_git();
2874 if (!packed_git)
2875 return 0;
2876
2877 for (p = packed_git_mru->head; p; p = p->next) {
2878 if (fill_pack_entry(sha1, e, p->item)) {
2879 mru_mark(packed_git_mru, p);
2880 return 1;
2881 }
2882 }
2883 return 0;
2884 }
2885
2886 struct packed_git *find_sha1_pack(const unsigned char *sha1,
2887 struct packed_git *packs)
2888 {
2889 struct packed_git *p;
2890
2891 for (p = packs; p; p = p->next) {
2892 if (find_pack_entry_one(sha1, p))
2893 return p;
2894 }
2895 return NULL;
2896
2897 }
2898
2899 static int sha1_loose_object_info(const unsigned char *sha1,
2900 struct object_info *oi,
2901 int flags)
2902 {
2903 int status = 0;
2904 unsigned long mapsize;
2905 void *map;
2906 git_zstream stream;
2907 char hdr[32];
2908 struct strbuf hdrbuf = STRBUF_INIT;
2909 unsigned long size_scratch;
2910
2911 if (oi->delta_base_sha1)
2912 hashclr(oi->delta_base_sha1);
2913
2914 /*
2915 * If we don't care about type or size, then we don't
2916 * need to look inside the object at all. Note that we
2917 * do not optimize out the stat call, even if the
2918 * caller doesn't care about the disk-size, since our
2919 * return value implicitly indicates whether the
2920 * object even exists.
2921 */
2922 if (!oi->typep && !oi->typename && !oi->sizep && !oi->contentp) {
2923 const char *path;
2924 struct stat st;
2925 if (stat_sha1_file(sha1, &st, &path) < 0)
2926 return -1;
2927 if (oi->disk_sizep)
2928 *oi->disk_sizep = st.st_size;
2929 return 0;
2930 }
2931
2932 map = map_sha1_file(sha1, &mapsize);
2933 if (!map)
2934 return -1;
2935
2936 if (!oi->sizep)
2937 oi->sizep = &size_scratch;
2938
2939 if (oi->disk_sizep)
2940 *oi->disk_sizep = mapsize;
2941 if ((flags & OBJECT_INFO_ALLOW_UNKNOWN_TYPE)) {
2942 if (unpack_sha1_header_to_strbuf(&stream, map, mapsize, hdr, sizeof(hdr), &hdrbuf) < 0)
2943 status = error("unable to unpack %s header with --allow-unknown-type",
2944 sha1_to_hex(sha1));
2945 } else if (unpack_sha1_header(&stream, map, mapsize, hdr, sizeof(hdr)) < 0)
2946 status = error("unable to unpack %s header",
2947 sha1_to_hex(sha1));
2948 if (status < 0)
2949 ; /* Do nothing */
2950 else if (hdrbuf.len) {
2951 if ((status = parse_sha1_header_extended(hdrbuf.buf, oi, flags)) < 0)
2952 status = error("unable to parse %s header with --allow-unknown-type",
2953 sha1_to_hex(sha1));
2954 } else if ((status = parse_sha1_header_extended(hdr, oi, flags)) < 0)
2955 status = error("unable to parse %s header", sha1_to_hex(sha1));
2956
2957 if (status >= 0 && oi->contentp)
2958 *oi->contentp = unpack_sha1_rest(&stream, hdr,
2959 *oi->sizep, sha1);
2960 else
2961 git_inflate_end(&stream);
2962
2963 munmap(map, mapsize);
2964 if (status && oi->typep)
2965 *oi->typep = status;
2966 if (oi->sizep == &size_scratch)
2967 oi->sizep = NULL;
2968 strbuf_release(&hdrbuf);
2969 return (status < 0) ? status : 0;
2970 }
2971
2972 int sha1_object_info_extended(const unsigned char *sha1, struct object_info *oi, unsigned flags)
2973 {
2974 static struct object_info blank_oi = OBJECT_INFO_INIT;
2975 struct pack_entry e;
2976 int rtype;
2977 const unsigned char *real = (flags & OBJECT_INFO_LOOKUP_REPLACE) ?
2978 lookup_replace_object(sha1) :
2979 sha1;
2980
2981 if (!oi)
2982 oi = &blank_oi;
2983
2984 if (!(flags & OBJECT_INFO_SKIP_CACHED)) {
2985 struct cached_object *co = find_cached_object(real);
2986 if (co) {
2987 if (oi->typep)
2988 *(oi->typep) = co->type;
2989 if (oi->sizep)
2990 *(oi->sizep) = co->size;
2991 if (oi->disk_sizep)
2992 *(oi->disk_sizep) = 0;
2993 if (oi->delta_base_sha1)
2994 hashclr(oi->delta_base_sha1);
2995 if (oi->typename)
2996 strbuf_addstr(oi->typename, typename(co->type));
2997 if (oi->contentp)
2998 *oi->contentp = xmemdupz(co->buf, co->size);
2999 oi->whence = OI_CACHED;
3000 return 0;
3001 }
3002 }
3003
3004 if (!find_pack_entry(real, &e)) {
3005 /* Most likely it's a loose object. */
3006 if (!sha1_loose_object_info(real, oi, flags)) {
3007 oi->whence = OI_LOOSE;
3008 return 0;
3009 }
3010
3011 /* Not a loose object; someone else may have just packed it. */
3012 if (flags & OBJECT_INFO_QUICK) {
3013 return -1;
3014 } else {
3015 reprepare_packed_git();
3016 if (!find_pack_entry(real, &e))
3017 return -1;
3018 }
3019 }
3020
3021 if (oi == &blank_oi)
3022 /*
3023 * We know that the caller doesn't actually need the
3024 * information below, so return early.
3025 */
3026 return 0;
3027
3028 rtype = packed_object_info(e.p, e.offset, oi);
3029 if (rtype < 0) {
3030 mark_bad_packed_object(e.p, real);
3031 return sha1_object_info_extended(real, oi, 0);
3032 } else if (in_delta_base_cache(e.p, e.offset)) {
3033 oi->whence = OI_DBCACHED;
3034 } else {
3035 oi->whence = OI_PACKED;
3036 oi->u.packed.offset = e.offset;
3037 oi->u.packed.pack = e.p;
3038 oi->u.packed.is_delta = (rtype == OBJ_REF_DELTA ||
3039 rtype == OBJ_OFS_DELTA);
3040 }
3041
3042 return 0;
3043 }
3044
3045 /* returns enum object_type or negative */
3046 int sha1_object_info(const unsigned char *sha1, unsigned long *sizep)
3047 {
3048 enum object_type type;
3049 struct object_info oi = OBJECT_INFO_INIT;
3050
3051 oi.typep = &type;
3052 oi.sizep = sizep;
3053 if (sha1_object_info_extended(sha1, &oi,
3054 OBJECT_INFO_LOOKUP_REPLACE) < 0)
3055 return -1;
3056 return type;
3057 }
3058
3059 static void *read_packed_sha1(const unsigned char *sha1,
3060 enum object_type *type, unsigned long *size)
3061 {
3062 struct pack_entry e;
3063 void *data;
3064
3065 if (!find_pack_entry(sha1, &e))
3066 return NULL;
3067 data = cache_or_unpack_entry(e.p, e.offset, size, type);
3068 if (!data) {
3069 /*
3070 * We're probably in deep shit, but let's try to fetch
3071 * the required object anyway from another pack or loose.
3072 * This should happen only in the presence of a corrupted
3073 * pack, and is better than failing outright.
3074 */
3075 error("failed to read object %s at offset %"PRIuMAX" from %s",
3076 sha1_to_hex(sha1), (uintmax_t)e.offset, e.p->pack_name);
3077 mark_bad_packed_object(e.p, sha1);
3078 data = read_object(sha1, type, size);
3079 }
3080 return data;
3081 }
3082
3083 int pretend_sha1_file(void *buf, unsigned long len, enum object_type type,
3084 unsigned char *sha1)
3085 {
3086 struct cached_object *co;
3087
3088 hash_sha1_file(buf, len, typename(type), sha1);
3089 if (has_sha1_file(sha1) || find_cached_object(sha1))
3090 return 0;
3091 ALLOC_GROW(cached_objects, cached_object_nr + 1, cached_object_alloc);
3092 co = &cached_objects[cached_object_nr++];
3093 co->size = len;
3094 co->type = type;
3095 co->buf = xmalloc(len);
3096 memcpy(co->buf, buf, len);
3097 hashcpy(co->sha1, sha1);
3098 return 0;
3099 }
3100
3101 static void *read_object(const unsigned char *sha1, enum object_type *type,
3102 unsigned long *size)
3103 {
3104 struct object_info oi = OBJECT_INFO_INIT;
3105 void *content;
3106 oi.typep = type;
3107 oi.sizep = size;
3108 oi.contentp = &content;
3109
3110 if (sha1_object_info_extended(sha1, &oi, 0) < 0)
3111 return NULL;
3112 return content;
3113 }
3114
3115 /*
3116 * This function dies on corrupt objects; the callers who want to
3117 * deal with them should arrange to call read_object() and give error
3118 * messages themselves.
3119 */
3120 void *read_sha1_file_extended(const unsigned char *sha1,
3121 enum object_type *type,
3122 unsigned long *size,
3123 int lookup_replace)
3124 {
3125 void *data;
3126 const struct packed_git *p;
3127 const char *path;
3128 struct stat st;
3129 const unsigned char *repl = lookup_replace ? lookup_replace_object(sha1)
3130 : sha1;
3131
3132 errno = 0;
3133 data = read_object(repl, type, size);
3134 if (data)
3135 return data;
3136
3137 if (errno && errno != ENOENT)
3138 die_errno("failed to read object %s", sha1_to_hex(sha1));
3139
3140 /* die if we replaced an object with one that does not exist */
3141 if (repl != sha1)
3142 die("replacement %s not found for %s",
3143 sha1_to_hex(repl), sha1_to_hex(sha1));
3144
3145 if (!stat_sha1_file(repl, &st, &path))
3146 die("loose object %s (stored in %s) is corrupt",
3147 sha1_to_hex(repl), path);
3148
3149 if ((p = has_packed_and_bad(repl)) != NULL)
3150 die("packed object %s (stored in %s) is corrupt",
3151 sha1_to_hex(repl), p->pack_name);
3152
3153 return NULL;
3154 }
3155
3156 void *read_object_with_reference(const unsigned char *sha1,
3157 const char *required_type_name,
3158 unsigned long *size,
3159 unsigned char *actual_sha1_return)
3160 {
3161 enum object_type type, required_type;
3162 void *buffer;
3163 unsigned long isize;
3164 unsigned char actual_sha1[20];
3165
3166 required_type = type_from_string(required_type_name);
3167 hashcpy(actual_sha1, sha1);
3168 while (1) {
3169 int ref_length = -1;
3170 const char *ref_type = NULL;
3171
3172 buffer = read_sha1_file(actual_sha1, &type, &isize);
3173 if (!buffer)
3174 return NULL;
3175 if (type == required_type) {
3176 *size = isize;
3177 if (actual_sha1_return)
3178 hashcpy(actual_sha1_return, actual_sha1);
3179 return buffer;
3180 }
3181 /* Handle references */
3182 else if (type == OBJ_COMMIT)
3183 ref_type = "tree ";
3184 else if (type == OBJ_TAG)
3185 ref_type = "object ";
3186 else {
3187 free(buffer);
3188 return NULL;
3189 }
3190 ref_length = strlen(ref_type);
3191
3192 if (ref_length + 40 > isize ||
3193 memcmp(buffer, ref_type, ref_length) ||
3194 get_sha1_hex((char *) buffer + ref_length, actual_sha1)) {
3195 free(buffer);
3196 return NULL;
3197 }
3198 free(buffer);
3199 /* Now we have the ID of the referred-to object in
3200 * actual_sha1. Check again. */
3201 }
3202 }
3203
3204 static void write_sha1_file_prepare(const void *buf, unsigned long len,
3205 const char *type, unsigned char *sha1,
3206 char *hdr, int *hdrlen)
3207 {
3208 git_SHA_CTX c;
3209
3210 /* Generate the header */
3211 *hdrlen = xsnprintf(hdr, *hdrlen, "%s %lu", type, len)+1;
3212
3213 /* Sha1.. */
3214 git_SHA1_Init(&c);
3215 git_SHA1_Update(&c, hdr, *hdrlen);
3216 git_SHA1_Update(&c, buf, len);
3217 git_SHA1_Final(sha1, &c);
3218 }
3219
3220 /*
3221 * Move the just written object into its final resting place.
3222 */
3223 int finalize_object_file(const char *tmpfile, const char *filename)
3224 {
3225 int ret = 0;
3226
3227 if (object_creation_mode == OBJECT_CREATION_USES_RENAMES)
3228 goto try_rename;
3229 else if (link(tmpfile, filename))
3230 ret = errno;
3231
3232 /*
3233 * Coda hack - coda doesn't like cross-directory links,
3234 * so we fall back to a rename, which will mean that it
3235 * won't be able to check collisions, but that's not a
3236 * big deal.
3237 *
3238 * The same holds for FAT formatted media.
3239 *
3240 * When this succeeds, we just return. We have nothing
3241 * left to unlink.
3242 */
3243 if (ret && ret != EEXIST) {
3244 try_rename:
3245 if (!rename(tmpfile, filename))
3246 goto out;
3247 ret = errno;
3248 }
3249 unlink_or_warn(tmpfile);
3250 if (ret) {
3251 if (ret != EEXIST) {
3252 return error_errno("unable to write sha1 filename %s", filename);
3253 }
3254 /* FIXME!!! Collision check here ? */
3255 }
3256
3257 out:
3258 if (adjust_shared_perm(filename))
3259 return error("unable to set permission to '%s'", filename);
3260 return 0;
3261 }
3262
3263 static int write_buffer(int fd, const void *buf, size_t len)
3264 {
3265 if (write_in_full(fd, buf, len) < 0)
3266 return error_errno("file write error");
3267 return 0;
3268 }
3269
3270 int hash_sha1_file(const void *buf, unsigned long len, const char *type,
3271 unsigned char *sha1)
3272 {
3273 char hdr[32];
3274 int hdrlen = sizeof(hdr);
3275 write_sha1_file_prepare(buf, len, type, sha1, hdr, &hdrlen);
3276 return 0;
3277 }
3278
3279 /* Finalize a file on disk, and close it. */
3280 static void close_sha1_file(int fd)
3281 {
3282 if (fsync_object_files)
3283 fsync_or_die(fd, "sha1 file");
3284 if (close(fd) != 0)
3285 die_errno("error when closing sha1 file");
3286 }
3287
3288 /* Size of directory component, including the ending '/' */
3289 static inline int directory_size(const char *filename)
3290 {
3291 const char *s = strrchr(filename, '/');
3292 if (!s)
3293 return 0;
3294 return s - filename + 1;
3295 }
3296
3297 /*
3298 * This creates a temporary file in the same directory as the final
3299 * 'filename'
3300 *
3301 * We want to avoid cross-directory filename renames, because those
3302 * can have problems on various filesystems (FAT, NFS, Coda).
3303 */
3304 static int create_tmpfile(struct strbuf *tmp, const char *filename)
3305 {
3306 int fd, dirlen = directory_size(filename);
3307
3308 strbuf_reset(tmp);
3309 strbuf_add(tmp, filename, dirlen);
3310 strbuf_addstr(tmp, "tmp_obj_XXXXXX");
3311 fd = git_mkstemp_mode(tmp->buf, 0444);
3312 if (fd < 0 && dirlen && errno == ENOENT) {
3313 /*
3314 * Make sure the directory exists; note that the contents
3315 * of the buffer are undefined after mkstemp returns an
3316 * error, so we have to rewrite the whole buffer from
3317 * scratch.
3318 */
3319 strbuf_reset(tmp);
3320 strbuf_add(tmp, filename, dirlen - 1);
3321 if (mkdir(tmp->buf, 0777) && errno != EEXIST)
3322 return -1;
3323 if (adjust_shared_perm(tmp->buf))
3324 return -1;
3325
3326 /* Try again */
3327 strbuf_addstr(tmp, "/tmp_obj_XXXXXX");
3328 fd = git_mkstemp_mode(tmp->buf, 0444);
3329 }
3330 return fd;
3331 }
3332
3333 static int write_loose_object(const unsigned char *sha1, char *hdr, int hdrlen,
3334 const void *buf, unsigned long len, time_t mtime)
3335 {
3336 int fd, ret;
3337 unsigned char compressed[4096];
3338 git_zstream stream;
3339 git_SHA_CTX c;
3340 unsigned char parano_sha1[20];
3341 static struct strbuf tmp_file = STRBUF_INIT;
3342 const char *filename = sha1_file_name(sha1);
3343
3344 fd = create_tmpfile(&tmp_file, filename);
3345 if (fd < 0) {
3346 if (errno == EACCES)
3347 return error("insufficient permission for adding an object to repository database %s", get_object_directory());
3348 else
3349 return error_errno("unable to create temporary file");
3350 }
3351
3352 /* Set it up */
3353 git_deflate_init(&stream, zlib_compression_level);
3354 stream.next_out = compressed;
3355 stream.avail_out = sizeof(compressed);
3356 git_SHA1_Init(&c);
3357
3358 /* First header.. */
3359 stream.next_in = (unsigned char *)hdr;
3360 stream.avail_in = hdrlen;
3361 while (git_deflate(&stream, 0) == Z_OK)
3362 ; /* nothing */
3363 git_SHA1_Update(&c, hdr, hdrlen);
3364
3365 /* Then the data itself.. */
3366 stream.next_in = (void *)buf;
3367 stream.avail_in = len;
3368 do {
3369 unsigned char *in0 = stream.next_in;
3370 ret = git_deflate(&stream, Z_FINISH);
3371 git_SHA1_Update(&c, in0, stream.next_in - in0);
3372 if (write_buffer(fd, compressed, stream.next_out - compressed) < 0)
3373 die("unable to write sha1 file");
3374 stream.next_out = compressed;
3375 stream.avail_out = sizeof(compressed);
3376 } while (ret == Z_OK);
3377
3378 if (ret != Z_STREAM_END)
3379 die("unable to deflate new object %s (%d)", sha1_to_hex(sha1), ret);
3380 ret = git_deflate_end_gently(&stream);
3381 if (ret != Z_OK)
3382 die("deflateEnd on object %s failed (%d)", sha1_to_hex(sha1), ret);
3383 git_SHA1_Final(parano_sha1, &c);
3384 if (hashcmp(sha1, parano_sha1) != 0)
3385 die("confused by unstable object source data for %s", sha1_to_hex(sha1));
3386
3387 close_sha1_file(fd);
3388
3389 if (mtime) {
3390 struct utimbuf utb;
3391 utb.actime = mtime;
3392 utb.modtime = mtime;
3393 if (utime(tmp_file.buf, &utb) < 0)
3394 warning_errno("failed utime() on %s", tmp_file.buf);
3395 }
3396
3397 return finalize_object_file(tmp_file.buf, filename);
3398 }
3399
3400 static int freshen_loose_object(const unsigned char *sha1)
3401 {
3402 return check_and_freshen(sha1, 1);
3403 }
3404
3405 static int freshen_packed_object(const unsigned char *sha1)
3406 {
3407 struct pack_entry e;
3408 if (!find_pack_entry(sha1, &e))
3409 return 0;
3410 if (e.p->freshened)
3411 return 1;
3412 if (!freshen_file(e.p->pack_name))
3413 return 0;
3414 e.p->freshened = 1;
3415 return 1;
3416 }
3417
3418 int write_sha1_file(const void *buf, unsigned long len, const char *type, unsigned char *sha1)
3419 {
3420 char hdr[32];
3421 int hdrlen = sizeof(hdr);
3422
3423 /* Normally if we have it in the pack then we do not bother writing
3424 * it out into .git/objects/??/?{38} file.
3425 */
3426 write_sha1_file_prepare(buf, len, type, sha1, hdr, &hdrlen);
3427 if (freshen_packed_object(sha1) || freshen_loose_object(sha1))
3428 return 0;
3429 return write_loose_object(sha1, hdr, hdrlen, buf, len, 0);
3430 }
3431
3432 int hash_sha1_file_literally(const void *buf, unsigned long len, const char *type,
3433 unsigned char *sha1, unsigned flags)
3434 {
3435 char *header;
3436 int hdrlen, status = 0;
3437
3438 /* type string, SP, %lu of the length plus NUL must fit this */
3439 hdrlen = strlen(type) + 32;
3440 header = xmalloc(hdrlen);
3441 write_sha1_file_prepare(buf, len, type, sha1, header, &hdrlen);
3442
3443 if (!(flags & HASH_WRITE_OBJECT))
3444 goto cleanup;
3445 if (freshen_packed_object(sha1) || freshen_loose_object(sha1))
3446 goto cleanup;
3447 status = write_loose_object(sha1, header, hdrlen, buf, len, 0);
3448
3449 cleanup:
3450 free(header);
3451 return status;
3452 }
3453
3454 int force_object_loose(const unsigned char *sha1, time_t mtime)
3455 {
3456 void *buf;
3457 unsigned long len;
3458 enum object_type type;
3459 char hdr[32];
3460 int hdrlen;
3461 int ret;
3462
3463 if (has_loose_object(sha1))
3464 return 0;
3465 buf = read_packed_sha1(sha1, &type, &len);
3466 if (!buf)
3467 return error("cannot read sha1_file for %s", sha1_to_hex(sha1));
3468 hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %lu", typename(type), len) + 1;
3469 ret = write_loose_object(sha1, hdr, hdrlen, buf, len, mtime);
3470 free(buf);
3471
3472 return ret;
3473 }
3474
3475 int has_pack_index(const unsigned char *sha1)
3476 {
3477 struct stat st;
3478 if (stat(sha1_pack_index_name(sha1), &st))
3479 return 0;
3480 return 1;
3481 }
3482
3483 int has_sha1_pack(const unsigned char *sha1)
3484 {
3485 struct pack_entry e;
3486 return find_pack_entry(sha1, &e);
3487 }
3488
3489 int has_sha1_file_with_flags(const unsigned char *sha1, int flags)
3490 {
3491 if (!startup_info->have_repository)
3492 return 0;
3493 return sha1_object_info_extended(sha1, NULL,
3494 flags | OBJECT_INFO_SKIP_CACHED) >= 0;
3495 }
3496
3497 int has_object_file(const struct object_id *oid)
3498 {
3499 return has_sha1_file(oid->hash);
3500 }
3501
3502 int has_object_file_with_flags(const struct object_id *oid, int flags)
3503 {
3504 return has_sha1_file_with_flags(oid->hash, flags);
3505 }
3506
3507 static void check_tree(const void *buf, size_t size)
3508 {
3509 struct tree_desc desc;
3510 struct name_entry entry;
3511
3512 init_tree_desc(&desc, buf, size);
3513 while (tree_entry(&desc, &entry))
3514 /* do nothing
3515 * tree_entry() will die() on malformed entries */
3516 ;
3517 }
3518
3519 static void check_commit(const void *buf, size_t size)
3520 {
3521 struct commit c;
3522 memset(&c, 0, sizeof(c));
3523 if (parse_commit_buffer(&c, buf, size))
3524 die("corrupt commit");
3525 }
3526
3527 static void check_tag(const void *buf, size_t size)
3528 {
3529 struct tag t;
3530 memset(&t, 0, sizeof(t));
3531 if (parse_tag_buffer(&t, buf, size))
3532 die("corrupt tag");
3533 }
3534
3535 static int index_mem(unsigned char *sha1, void *buf, size_t size,
3536 enum object_type type,
3537 const char *path, unsigned flags)
3538 {
3539 int ret, re_allocated = 0;
3540 int write_object = flags & HASH_WRITE_OBJECT;
3541
3542 if (!type)
3543 type = OBJ_BLOB;
3544
3545 /*
3546 * Convert blobs to git internal format
3547 */
3548 if ((type == OBJ_BLOB) && path) {
3549 struct strbuf nbuf = STRBUF_INIT;
3550 if (convert_to_git(&the_index, path, buf, size, &nbuf,
3551 write_object ? safe_crlf : SAFE_CRLF_FALSE)) {
3552 buf = strbuf_detach(&nbuf, &size);
3553 re_allocated = 1;
3554 }
3555 }
3556 if (flags & HASH_FORMAT_CHECK) {
3557 if (type == OBJ_TREE)
3558 check_tree(buf, size);
3559 if (type == OBJ_COMMIT)
3560 check_commit(buf, size);
3561 if (type == OBJ_TAG)
3562 check_tag(buf, size);
3563 }
3564
3565 if (write_object)
3566 ret = write_sha1_file(buf, size, typename(type), sha1);
3567 else
3568 ret = hash_sha1_file(buf, size, typename(type), sha1);
3569 if (re_allocated)
3570 free(buf);
3571 return ret;
3572 }
3573
3574 static int index_stream_convert_blob(unsigned char *sha1, int fd,
3575 const char *path, unsigned flags)
3576 {
3577 int ret;
3578 const int write_object = flags & HASH_WRITE_OBJECT;
3579 struct strbuf sbuf = STRBUF_INIT;
3580
3581 assert(path);
3582 assert(would_convert_to_git_filter_fd(path));
3583
3584 convert_to_git_filter_fd(&the_index, path, fd, &sbuf,
3585 write_object ? safe_crlf : SAFE_CRLF_FALSE);
3586
3587 if (write_object)
3588 ret = write_sha1_file(sbuf.buf, sbuf.len, typename(OBJ_BLOB),
3589 sha1);
3590 else
3591 ret = hash_sha1_file(sbuf.buf, sbuf.len, typename(OBJ_BLOB),
3592 sha1);
3593 strbuf_release(&sbuf);
3594 return ret;
3595 }
3596
3597 static int index_pipe(unsigned char *sha1, int fd, enum object_type type,
3598 const char *path, unsigned flags)
3599 {
3600 struct strbuf sbuf = STRBUF_INIT;
3601 int ret;
3602
3603 if (strbuf_read(&sbuf, fd, 4096) >= 0)
3604 ret = index_mem(sha1, sbuf.buf, sbuf.len, type, path, flags);
3605 else
3606 ret = -1;
3607 strbuf_release(&sbuf);
3608 return ret;
3609 }
3610
3611 #define SMALL_FILE_SIZE (32*1024)
3612
3613 static int index_core(unsigned char *sha1, int fd, size_t size,
3614 enum object_type type, const char *path,
3615 unsigned flags)
3616 {
3617 int ret;
3618
3619 if (!size) {
3620 ret = index_mem(sha1, "", size, type, path, flags);
3621 } else if (size <= SMALL_FILE_SIZE) {
3622 char *buf = xmalloc(size);
3623 if (size == read_in_full(fd, buf, size))
3624 ret = index_mem(sha1, buf, size, type, path, flags);
3625 else
3626 ret = error_errno("short read");
3627 free(buf);
3628 } else {
3629 void *buf = xmmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
3630 ret = index_mem(sha1, buf, size, type, path, flags);
3631 munmap(buf, size);
3632 }
3633 return ret;
3634 }
3635
3636 /*
3637 * This creates one packfile per large blob unless bulk-checkin
3638 * machinery is "plugged".
3639 *
3640 * This also bypasses the usual "convert-to-git" dance, and that is on
3641 * purpose. We could write a streaming version of the converting
3642 * functions and insert that before feeding the data to fast-import
3643 * (or equivalent in-core API described above). However, that is
3644 * somewhat complicated, as we do not know the size of the filter
3645 * result, which we need to know beforehand when writing a git object.
3646 * Since the primary motivation for trying to stream from the working
3647 * tree file and to avoid mmaping it in core is to deal with large
3648 * binary blobs, they generally do not want to get any conversion, and
3649 * callers should avoid this code path when filters are requested.
3650 */
3651 static int index_stream(unsigned char *sha1, int fd, size_t size,
3652 enum object_type type, const char *path,
3653 unsigned flags)
3654 {
3655 return index_bulk_checkin(sha1, fd, size, type, path, flags);
3656 }
3657
3658 int index_fd(unsigned char *sha1, int fd, struct stat *st,
3659 enum object_type type, const char *path, unsigned flags)
3660 {
3661 int ret;
3662
3663 /*
3664 * Call xsize_t() only when needed to avoid potentially unnecessary
3665 * die() for large files.
3666 */
3667 if (type == OBJ_BLOB && path && would_convert_to_git_filter_fd(path))
3668 ret = index_stream_convert_blob(sha1, fd, path, flags);
3669 else if (!S_ISREG(st->st_mode))
3670 ret = index_pipe(sha1, fd, type, path, flags);
3671 else if (st->st_size <= big_file_threshold || type != OBJ_BLOB ||
3672 (path && would_convert_to_git(&the_index, path)))
3673 ret = index_core(sha1, fd, xsize_t(st->st_size), type, path,
3674 flags);
3675 else
3676 ret = index_stream(sha1, fd, xsize_t(st->st_size), type, path,
3677 flags);
3678 close(fd);
3679 return ret;
3680 }
3681
3682 int index_path(unsigned char *sha1, const char *path, struct stat *st, unsigned flags)
3683 {
3684 int fd;
3685 struct strbuf sb = STRBUF_INIT;
3686
3687 switch (st->st_mode & S_IFMT) {
3688 case S_IFREG:
3689 fd = open(path, O_RDONLY);
3690 if (fd < 0)
3691 return error_errno("open(\"%s\")", path);
3692 if (index_fd(sha1, fd, st, OBJ_BLOB, path, flags) < 0)
3693 return error("%s: failed to insert into database",
3694 path);
3695 break;
3696 case S_IFLNK:
3697 if (strbuf_readlink(&sb, path, st->st_size))
3698 return error_errno("readlink(\"%s\")", path);
3699 if (!(flags & HASH_WRITE_OBJECT))
3700 hash_sha1_file(sb.buf, sb.len, blob_type, sha1);
3701 else if (write_sha1_file(sb.buf, sb.len, blob_type, sha1))
3702 return error("%s: failed to insert into database",
3703 path);
3704 strbuf_release(&sb);
3705 break;
3706 case S_IFDIR:
3707 return resolve_gitlink_ref(path, "HEAD", sha1);
3708 default:
3709 return error("%s: unsupported file type", path);
3710 }
3711 return 0;
3712 }
3713
3714 int read_pack_header(int fd, struct pack_header *header)
3715 {
3716 if (read_in_full(fd, header, sizeof(*header)) < sizeof(*header))
3717 /* "eof before pack header was fully read" */
3718 return PH_ERROR_EOF;
3719
3720 if (header->hdr_signature != htonl(PACK_SIGNATURE))
3721 /* "protocol error (pack signature mismatch detected)" */
3722 return PH_ERROR_PACK_SIGNATURE;
3723 if (!pack_version_ok(header->hdr_version))
3724 /* "protocol error (pack version unsupported)" */
3725 return PH_ERROR_PROTOCOL;
3726 return 0;
3727 }
3728
3729 void assert_sha1_type(const unsigned char *sha1, enum object_type expect)
3730 {
3731 enum object_type type = sha1_object_info(sha1, NULL);
3732 if (type < 0)
3733 die("%s is not a valid object", sha1_to_hex(sha1));
3734 if (type != expect)
3735 die("%s is not a valid '%s' object", sha1_to_hex(sha1),
3736 typename(expect));
3737 }
3738
3739 int for_each_file_in_obj_subdir(unsigned int subdir_nr,
3740 struct strbuf *path,
3741 each_loose_object_fn obj_cb,
3742 each_loose_cruft_fn cruft_cb,
3743 each_loose_subdir_fn subdir_cb,
3744 void *data)
3745 {
3746 size_t origlen, baselen;
3747 DIR *dir;
3748 struct dirent *de;
3749 int r = 0;
3750
3751 if (subdir_nr > 0xff)
3752 BUG("invalid loose object subdirectory: %x", subdir_nr);
3753
3754 origlen = path->len;
3755 strbuf_complete(path, '/');
3756 strbuf_addf(path, "%02x", subdir_nr);
3757 baselen = path->len;
3758
3759 dir = opendir(path->buf);
3760 if (!dir) {
3761 if (errno != ENOENT)
3762 r = error_errno("unable to open %s", path->buf);
3763 strbuf_setlen(path, origlen);
3764 return r;
3765 }
3766
3767 while ((de = readdir(dir))) {
3768 if (is_dot_or_dotdot(de->d_name))
3769 continue;
3770
3771 strbuf_setlen(path, baselen);
3772 strbuf_addf(path, "/%s", de->d_name);
3773
3774 if (strlen(de->d_name) == GIT_SHA1_HEXSZ - 2) {
3775 char hex[GIT_MAX_HEXSZ+1];
3776 struct object_id oid;
3777
3778 xsnprintf(hex, sizeof(hex), "%02x%s",
3779 subdir_nr, de->d_name);
3780 if (!get_oid_hex(hex, &oid)) {
3781 if (obj_cb) {
3782 r = obj_cb(&oid, path->buf, data);
3783 if (r)
3784 break;
3785 }
3786 continue;
3787 }
3788 }
3789
3790 if (cruft_cb) {
3791 r = cruft_cb(de->d_name, path->buf, data);
3792 if (r)
3793 break;
3794 }
3795 }
3796 closedir(dir);
3797
3798 strbuf_setlen(path, baselen);
3799 if (!r && subdir_cb)
3800 r = subdir_cb(subdir_nr, path->buf, data);
3801
3802 strbuf_setlen(path, origlen);
3803
3804 return r;
3805 }
3806
3807 int for_each_loose_file_in_objdir_buf(struct strbuf *path,
3808 each_loose_object_fn obj_cb,
3809 each_loose_cruft_fn cruft_cb,
3810 each_loose_subdir_fn subdir_cb,
3811 void *data)
3812 {
3813 int r = 0;
3814 int i;
3815
3816 for (i = 0; i < 256; i++) {
3817 r = for_each_file_in_obj_subdir(i, path, obj_cb, cruft_cb,
3818 subdir_cb, data);
3819 if (r)
3820 break;
3821 }
3822
3823 return r;
3824 }
3825
3826 int for_each_loose_file_in_objdir(const char *path,
3827 each_loose_object_fn obj_cb,
3828 each_loose_cruft_fn cruft_cb,
3829 each_loose_subdir_fn subdir_cb,
3830 void *data)
3831 {
3832 struct strbuf buf = STRBUF_INIT;
3833 int r;
3834
3835 strbuf_addstr(&buf, path);
3836 r = for_each_loose_file_in_objdir_buf(&buf, obj_cb, cruft_cb,
3837 subdir_cb, data);
3838 strbuf_release(&buf);
3839
3840 return r;
3841 }
3842
3843 struct loose_alt_odb_data {
3844 each_loose_object_fn *cb;
3845 void *data;
3846 };
3847
3848 static int loose_from_alt_odb(struct alternate_object_database *alt,
3849 void *vdata)
3850 {
3851 struct loose_alt_odb_data *data = vdata;
3852 struct strbuf buf = STRBUF_INIT;
3853 int r;
3854
3855 strbuf_addstr(&buf, alt->path);
3856 r = for_each_loose_file_in_objdir_buf(&buf,
3857 data->cb, NULL, NULL,
3858 data->data);
3859 strbuf_release(&buf);
3860 return r;
3861 }
3862
3863 int for_each_loose_object(each_loose_object_fn cb, void *data, unsigned flags)
3864 {