77eb181b5f3aba8dfd5dd40ae8c3349d78c75706
[git/git.git] / builtin-fetch-pack.c
1 #include "cache.h"
2 #include "refs.h"
3 #include "pkt-line.h"
4 #include "commit.h"
5 #include "tag.h"
6 #include "exec_cmd.h"
7 #include "pack.h"
8 #include "sideband.h"
9 #include "fetch-pack.h"
10
11 static int transfer_unpack_limit = -1;
12 static int fetch_unpack_limit = -1;
13 static int unpack_limit = 100;
14 static struct fetch_pack_args args;
15
16 static const char fetch_pack_usage[] =
17 "git-fetch-pack [--all] [--quiet|-q] [--keep|-k] [--thin] [--upload-pack=<git-upload-pack>] [--depth=<n>] [--no-progress] [-v] [<host>:]<directory> [<refs>...]";
18 static const char *uploadpack = "git-upload-pack";
19
20 #define COMPLETE (1U << 0)
21 #define COMMON (1U << 1)
22 #define COMMON_REF (1U << 2)
23 #define SEEN (1U << 3)
24 #define POPPED (1U << 4)
25
26 /*
27 * After sending this many "have"s if we do not get any new ACK , we
28 * give up traversing our history.
29 */
30 #define MAX_IN_VAIN 256
31
32 static struct commit_list *rev_list;
33 static int non_common_revs, multi_ack, use_thin_pack, use_sideband;
34
35 static void rev_list_push(struct commit *commit, int mark)
36 {
37 if (!(commit->object.flags & mark)) {
38 commit->object.flags |= mark;
39
40 if (!(commit->object.parsed))
41 parse_commit(commit);
42
43 insert_by_date(commit, &rev_list);
44
45 if (!(commit->object.flags & COMMON))
46 non_common_revs++;
47 }
48 }
49
50 static int rev_list_insert_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
51 {
52 struct object *o = deref_tag(parse_object(sha1), path, 0);
53
54 if (o && o->type == OBJ_COMMIT)
55 rev_list_push((struct commit *)o, SEEN);
56
57 return 0;
58 }
59
60 /*
61 This function marks a rev and its ancestors as common.
62 In some cases, it is desirable to mark only the ancestors (for example
63 when only the server does not yet know that they are common).
64 */
65
66 static void mark_common(struct commit *commit,
67 int ancestors_only, int dont_parse)
68 {
69 if (commit != NULL && !(commit->object.flags & COMMON)) {
70 struct object *o = (struct object *)commit;
71
72 if (!ancestors_only)
73 o->flags |= COMMON;
74
75 if (!(o->flags & SEEN))
76 rev_list_push(commit, SEEN);
77 else {
78 struct commit_list *parents;
79
80 if (!ancestors_only && !(o->flags & POPPED))
81 non_common_revs--;
82 if (!o->parsed && !dont_parse)
83 parse_commit(commit);
84
85 for (parents = commit->parents;
86 parents;
87 parents = parents->next)
88 mark_common(parents->item, 0, dont_parse);
89 }
90 }
91 }
92
93 /*
94 Get the next rev to send, ignoring the common.
95 */
96
97 static const unsigned char* get_rev(void)
98 {
99 struct commit *commit = NULL;
100
101 while (commit == NULL) {
102 unsigned int mark;
103 struct commit_list* parents;
104
105 if (rev_list == NULL || non_common_revs == 0)
106 return NULL;
107
108 commit = rev_list->item;
109 if (!(commit->object.parsed))
110 parse_commit(commit);
111 commit->object.flags |= POPPED;
112 if (!(commit->object.flags & COMMON))
113 non_common_revs--;
114
115 parents = commit->parents;
116
117 if (commit->object.flags & COMMON) {
118 /* do not send "have", and ignore ancestors */
119 commit = NULL;
120 mark = COMMON | SEEN;
121 } else if (commit->object.flags & COMMON_REF)
122 /* send "have", and ignore ancestors */
123 mark = COMMON | SEEN;
124 else
125 /* send "have", also for its ancestors */
126 mark = SEEN;
127
128 while (parents) {
129 if (!(parents->item->object.flags & SEEN))
130 rev_list_push(parents->item, mark);
131 if (mark & COMMON)
132 mark_common(parents->item, 1, 0);
133 parents = parents->next;
134 }
135
136 rev_list = rev_list->next;
137 }
138
139 return commit->object.sha1;
140 }
141
142 static int find_common(int fd[2], unsigned char *result_sha1,
143 struct ref *refs)
144 {
145 int fetching;
146 int count = 0, flushes = 0, retval;
147 const unsigned char *sha1;
148 unsigned in_vain = 0;
149 int got_continue = 0;
150
151 for_each_ref(rev_list_insert_ref, NULL);
152
153 fetching = 0;
154 for ( ; refs ; refs = refs->next) {
155 unsigned char *remote = refs->old_sha1;
156 struct object *o;
157
158 /*
159 * If that object is complete (i.e. it is an ancestor of a
160 * local ref), we tell them we have it but do not have to
161 * tell them about its ancestors, which they already know
162 * about.
163 *
164 * We use lookup_object here because we are only
165 * interested in the case we *know* the object is
166 * reachable and we have already scanned it.
167 */
168 if (((o = lookup_object(remote)) != NULL) &&
169 (o->flags & COMPLETE)) {
170 continue;
171 }
172
173 if (!fetching)
174 packet_write(fd[1], "want %s%s%s%s%s%s%s\n",
175 sha1_to_hex(remote),
176 (multi_ack ? " multi_ack" : ""),
177 (use_sideband == 2 ? " side-band-64k" : ""),
178 (use_sideband == 1 ? " side-band" : ""),
179 (use_thin_pack ? " thin-pack" : ""),
180 (args.no_progress ? " no-progress" : ""),
181 " ofs-delta");
182 else
183 packet_write(fd[1], "want %s\n", sha1_to_hex(remote));
184 fetching++;
185 }
186 if (is_repository_shallow())
187 write_shallow_commits(fd[1], 1);
188 if (args.depth > 0)
189 packet_write(fd[1], "deepen %d", args.depth);
190 packet_flush(fd[1]);
191 if (!fetching)
192 return 1;
193
194 if (args.depth > 0) {
195 char line[1024];
196 unsigned char sha1[20];
197 int len;
198
199 while ((len = packet_read_line(fd[0], line, sizeof(line)))) {
200 if (!prefixcmp(line, "shallow ")) {
201 if (get_sha1_hex(line + 8, sha1))
202 die("invalid shallow line: %s", line);
203 register_shallow(sha1);
204 continue;
205 }
206 if (!prefixcmp(line, "unshallow ")) {
207 if (get_sha1_hex(line + 10, sha1))
208 die("invalid unshallow line: %s", line);
209 if (!lookup_object(sha1))
210 die("object not found: %s", line);
211 /* make sure that it is parsed as shallow */
212 parse_object(sha1);
213 if (unregister_shallow(sha1))
214 die("no shallow found: %s", line);
215 continue;
216 }
217 die("expected shallow/unshallow, got %s", line);
218 }
219 }
220
221 flushes = 0;
222 retval = -1;
223 while ((sha1 = get_rev())) {
224 packet_write(fd[1], "have %s\n", sha1_to_hex(sha1));
225 if (args.verbose)
226 fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
227 in_vain++;
228 if (!(31 & ++count)) {
229 int ack;
230
231 packet_flush(fd[1]);
232 flushes++;
233
234 /*
235 * We keep one window "ahead" of the other side, and
236 * will wait for an ACK only on the next one
237 */
238 if (count == 32)
239 continue;
240
241 do {
242 ack = get_ack(fd[0], result_sha1);
243 if (args.verbose && ack)
244 fprintf(stderr, "got ack %d %s\n", ack,
245 sha1_to_hex(result_sha1));
246 if (ack == 1) {
247 flushes = 0;
248 multi_ack = 0;
249 retval = 0;
250 goto done;
251 } else if (ack == 2) {
252 struct commit *commit =
253 lookup_commit(result_sha1);
254 mark_common(commit, 0, 1);
255 retval = 0;
256 in_vain = 0;
257 got_continue = 1;
258 }
259 } while (ack);
260 flushes--;
261 if (got_continue && MAX_IN_VAIN < in_vain) {
262 if (args.verbose)
263 fprintf(stderr, "giving up\n");
264 break; /* give up */
265 }
266 }
267 }
268 done:
269 packet_write(fd[1], "done\n");
270 if (args.verbose)
271 fprintf(stderr, "done\n");
272 if (retval != 0) {
273 multi_ack = 0;
274 flushes++;
275 }
276 while (flushes || multi_ack) {
277 int ack = get_ack(fd[0], result_sha1);
278 if (ack) {
279 if (args.verbose)
280 fprintf(stderr, "got ack (%d) %s\n", ack,
281 sha1_to_hex(result_sha1));
282 if (ack == 1)
283 return 0;
284 multi_ack = 1;
285 continue;
286 }
287 flushes--;
288 }
289 return retval;
290 }
291
292 static struct commit_list *complete;
293
294 static int mark_complete(const char *path, const unsigned char *sha1, int flag, void *cb_data)
295 {
296 struct object *o = parse_object(sha1);
297
298 while (o && o->type == OBJ_TAG) {
299 struct tag *t = (struct tag *) o;
300 if (!t->tagged)
301 break; /* broken repository */
302 o->flags |= COMPLETE;
303 o = parse_object(t->tagged->sha1);
304 }
305 if (o && o->type == OBJ_COMMIT) {
306 struct commit *commit = (struct commit *)o;
307 commit->object.flags |= COMPLETE;
308 insert_by_date(commit, &complete);
309 }
310 return 0;
311 }
312
313 static void mark_recent_complete_commits(unsigned long cutoff)
314 {
315 while (complete && cutoff <= complete->item->date) {
316 if (args.verbose)
317 fprintf(stderr, "Marking %s as complete\n",
318 sha1_to_hex(complete->item->object.sha1));
319 pop_most_recent_commit(&complete, COMPLETE);
320 }
321 }
322
323 static void filter_refs(struct ref **refs, int nr_match, char **match)
324 {
325 struct ref **return_refs;
326 struct ref *newlist = NULL;
327 struct ref **newtail = &newlist;
328 struct ref *ref, *next;
329 struct ref *fastarray[32];
330
331 if (nr_match && !args.fetch_all) {
332 if (ARRAY_SIZE(fastarray) < nr_match)
333 return_refs = xcalloc(nr_match, sizeof(struct ref *));
334 else {
335 return_refs = fastarray;
336 memset(return_refs, 0, sizeof(struct ref *) * nr_match);
337 }
338 }
339 else
340 return_refs = NULL;
341
342 for (ref = *refs; ref; ref = next) {
343 next = ref->next;
344 if (!memcmp(ref->name, "refs/", 5) &&
345 check_ref_format(ref->name + 5))
346 ; /* trash */
347 else if (args.fetch_all &&
348 (!args.depth || prefixcmp(ref->name, "refs/tags/") )) {
349 *newtail = ref;
350 ref->next = NULL;
351 newtail = &ref->next;
352 continue;
353 }
354 else {
355 int order = path_match(ref->name, nr_match, match);
356 if (order) {
357 return_refs[order-1] = ref;
358 continue; /* we will link it later */
359 }
360 }
361 free(ref);
362 }
363
364 if (!args.fetch_all) {
365 int i;
366 for (i = 0; i < nr_match; i++) {
367 ref = return_refs[i];
368 if (ref) {
369 *newtail = ref;
370 ref->next = NULL;
371 newtail = &ref->next;
372 }
373 }
374 if (return_refs != fastarray)
375 free(return_refs);
376 }
377 *refs = newlist;
378 }
379
380 static int everything_local(struct ref **refs, int nr_match, char **match)
381 {
382 struct ref *ref;
383 int retval;
384 unsigned long cutoff = 0;
385
386 track_object_refs = 0;
387 save_commit_buffer = 0;
388
389 for (ref = *refs; ref; ref = ref->next) {
390 struct object *o;
391
392 o = parse_object(ref->old_sha1);
393 if (!o)
394 continue;
395
396 /* We already have it -- which may mean that we were
397 * in sync with the other side at some time after
398 * that (it is OK if we guess wrong here).
399 */
400 if (o->type == OBJ_COMMIT) {
401 struct commit *commit = (struct commit *)o;
402 if (!cutoff || cutoff < commit->date)
403 cutoff = commit->date;
404 }
405 }
406
407 if (!args.depth) {
408 for_each_ref(mark_complete, NULL);
409 if (cutoff)
410 mark_recent_complete_commits(cutoff);
411 }
412
413 /*
414 * Mark all complete remote refs as common refs.
415 * Don't mark them common yet; the server has to be told so first.
416 */
417 for (ref = *refs; ref; ref = ref->next) {
418 struct object *o = deref_tag(lookup_object(ref->old_sha1),
419 NULL, 0);
420
421 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
422 continue;
423
424 if (!(o->flags & SEEN)) {
425 rev_list_push((struct commit *)o, COMMON_REF | SEEN);
426
427 mark_common((struct commit *)o, 1, 1);
428 }
429 }
430
431 filter_refs(refs, nr_match, match);
432
433 for (retval = 1, ref = *refs; ref ; ref = ref->next) {
434 const unsigned char *remote = ref->old_sha1;
435 unsigned char local[20];
436 struct object *o;
437
438 o = lookup_object(remote);
439 if (!o || !(o->flags & COMPLETE)) {
440 retval = 0;
441 if (!args.verbose)
442 continue;
443 fprintf(stderr,
444 "want %s (%s)\n", sha1_to_hex(remote),
445 ref->name);
446 continue;
447 }
448
449 hashcpy(ref->new_sha1, local);
450 if (!args.verbose)
451 continue;
452 fprintf(stderr,
453 "already have %s (%s)\n", sha1_to_hex(remote),
454 ref->name);
455 }
456 return retval;
457 }
458
459 static pid_t setup_sideband(int fd[2], int xd[2])
460 {
461 pid_t side_pid;
462
463 if (!use_sideband) {
464 fd[0] = xd[0];
465 fd[1] = xd[1];
466 return 0;
467 }
468 /* xd[] is talking with upload-pack; subprocess reads from
469 * xd[0], spits out band#2 to stderr, and feeds us band#1
470 * through our fd[0].
471 */
472 if (pipe(fd) < 0)
473 die("fetch-pack: unable to set up pipe");
474 side_pid = fork();
475 if (side_pid < 0)
476 die("fetch-pack: unable to fork off sideband demultiplexer");
477 if (!side_pid) {
478 /* subprocess */
479 close(fd[0]);
480 if (xd[0] != xd[1])
481 close(xd[1]);
482 if (recv_sideband("fetch-pack", xd[0], fd[1], 2))
483 exit(1);
484 exit(0);
485 }
486 close(xd[0]);
487 close(fd[1]);
488 fd[1] = xd[1];
489 return side_pid;
490 }
491
492 static int get_pack(int xd[2], char **pack_lockfile)
493 {
494 int status;
495 pid_t pid, side_pid;
496 int fd[2];
497 const char *argv[20];
498 char keep_arg[256];
499 char hdr_arg[256];
500 const char **av;
501 int do_keep = args.keep_pack;
502 int keep_pipe[2];
503
504 side_pid = setup_sideband(fd, xd);
505
506 av = argv;
507 *hdr_arg = 0;
508 if (!args.keep_pack && unpack_limit) {
509 struct pack_header header;
510
511 if (read_pack_header(fd[0], &header))
512 die("protocol error: bad pack header");
513 snprintf(hdr_arg, sizeof(hdr_arg), "--pack_header=%u,%u",
514 ntohl(header.hdr_version), ntohl(header.hdr_entries));
515 if (ntohl(header.hdr_entries) < unpack_limit)
516 do_keep = 0;
517 else
518 do_keep = 1;
519 }
520
521 if (do_keep) {
522 if (pack_lockfile && pipe(keep_pipe))
523 die("fetch-pack: pipe setup failure: %s", strerror(errno));
524 *av++ = "index-pack";
525 *av++ = "--stdin";
526 if (!args.quiet && !args.no_progress)
527 *av++ = "-v";
528 if (args.use_thin_pack)
529 *av++ = "--fix-thin";
530 if (args.lock_pack || unpack_limit) {
531 int s = sprintf(keep_arg,
532 "--keep=fetch-pack %d on ", getpid());
533 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
534 strcpy(keep_arg + s, "localhost");
535 *av++ = keep_arg;
536 }
537 }
538 else {
539 *av++ = "unpack-objects";
540 if (args.quiet)
541 *av++ = "-q";
542 }
543 if (*hdr_arg)
544 *av++ = hdr_arg;
545 *av++ = NULL;
546
547 pid = fork();
548 if (pid < 0)
549 die("fetch-pack: unable to fork off %s", argv[0]);
550 if (!pid) {
551 dup2(fd[0], 0);
552 if (do_keep && pack_lockfile) {
553 dup2(keep_pipe[1], 1);
554 close(keep_pipe[0]);
555 close(keep_pipe[1]);
556 }
557 close(fd[0]);
558 close(fd[1]);
559 execv_git_cmd(argv);
560 die("%s exec failed", argv[0]);
561 }
562 close(fd[0]);
563 close(fd[1]);
564 if (do_keep && pack_lockfile) {
565 close(keep_pipe[1]);
566 *pack_lockfile = index_pack_lockfile(keep_pipe[0]);
567 close(keep_pipe[0]);
568 }
569 while (waitpid(pid, &status, 0) < 0) {
570 if (errno != EINTR)
571 die("waiting for %s: %s", argv[0], strerror(errno));
572 }
573 if (WIFEXITED(status)) {
574 int code = WEXITSTATUS(status);
575 if (code)
576 die("%s died with error code %d", argv[0], code);
577 return 0;
578 }
579 if (WIFSIGNALED(status)) {
580 int sig = WTERMSIG(status);
581 die("%s died of signal %d", argv[0], sig);
582 }
583 die("%s died of unnatural causes %d", argv[0], status);
584 }
585
586 static struct ref *do_fetch_pack(int fd[2],
587 int nr_match,
588 char **match,
589 char **pack_lockfile)
590 {
591 struct ref *ref;
592 unsigned char sha1[20];
593
594 get_remote_heads(fd[0], &ref, 0, NULL, 0);
595 if (is_repository_shallow() && !server_supports("shallow"))
596 die("Server does not support shallow clients");
597 if (server_supports("multi_ack")) {
598 if (args.verbose)
599 fprintf(stderr, "Server supports multi_ack\n");
600 multi_ack = 1;
601 }
602 if (server_supports("side-band-64k")) {
603 if (args.verbose)
604 fprintf(stderr, "Server supports side-band-64k\n");
605 use_sideband = 2;
606 }
607 else if (server_supports("side-band")) {
608 if (args.verbose)
609 fprintf(stderr, "Server supports side-band\n");
610 use_sideband = 1;
611 }
612 if (!ref) {
613 packet_flush(fd[1]);
614 die("no matching remote head");
615 }
616 if (everything_local(&ref, nr_match, match)) {
617 packet_flush(fd[1]);
618 goto all_done;
619 }
620 if (find_common(fd, sha1, ref) < 0)
621 if (!args.keep_pack)
622 /* When cloning, it is not unusual to have
623 * no common commit.
624 */
625 fprintf(stderr, "warning: no common commits\n");
626
627 if (get_pack(fd, pack_lockfile))
628 die("git-fetch-pack: fetch failed.");
629
630 all_done:
631 return ref;
632 }
633
634 static int remove_duplicates(int nr_heads, char **heads)
635 {
636 int src, dst;
637
638 for (src = dst = 0; src < nr_heads; src++) {
639 /* If heads[src] is different from any of
640 * heads[0..dst], push it in.
641 */
642 int i;
643 for (i = 0; i < dst; i++) {
644 if (!strcmp(heads[i], heads[src]))
645 break;
646 }
647 if (i < dst)
648 continue;
649 if (src != dst)
650 heads[dst] = heads[src];
651 dst++;
652 }
653 return dst;
654 }
655
656 static int fetch_pack_config(const char *var, const char *value)
657 {
658 if (strcmp(var, "fetch.unpacklimit") == 0) {
659 fetch_unpack_limit = git_config_int(var, value);
660 return 0;
661 }
662
663 if (strcmp(var, "transfer.unpacklimit") == 0) {
664 transfer_unpack_limit = git_config_int(var, value);
665 return 0;
666 }
667
668 return git_default_config(var, value);
669 }
670
671 static struct lock_file lock;
672
673 int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
674 {
675 int i, ret, nr_heads;
676 struct ref *ref;
677 char *dest = NULL, **heads;
678
679 git_config(fetch_pack_config);
680
681 if (0 <= transfer_unpack_limit)
682 unpack_limit = transfer_unpack_limit;
683 else if (0 <= fetch_unpack_limit)
684 unpack_limit = fetch_unpack_limit;
685
686 nr_heads = 0;
687 heads = NULL;
688 for (i = 1; i < argc; i++) {
689 const char *arg = argv[i];
690
691 if (*arg == '-') {
692 if (!prefixcmp(arg, "--upload-pack=")) {
693 args.uploadpack = arg + 14;
694 continue;
695 }
696 if (!prefixcmp(arg, "--exec=")) {
697 args.uploadpack = arg + 7;
698 continue;
699 }
700 if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
701 args.quiet = 1;
702 continue;
703 }
704 if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
705 args.lock_pack = args.keep_pack;
706 args.keep_pack = 1;
707 continue;
708 }
709 if (!strcmp("--thin", arg)) {
710 args.use_thin_pack = 1;
711 continue;
712 }
713 if (!strcmp("--all", arg)) {
714 args.fetch_all = 1;
715 continue;
716 }
717 if (!strcmp("-v", arg)) {
718 args.verbose = 1;
719 continue;
720 }
721 if (!prefixcmp(arg, "--depth=")) {
722 args.depth = strtol(arg + 8, NULL, 0);
723 continue;
724 }
725 if (!strcmp("--no-progress", arg)) {
726 args.no_progress = 1;
727 continue;
728 }
729 usage(fetch_pack_usage);
730 }
731 dest = (char *)arg;
732 heads = (char **)(argv + i + 1);
733 nr_heads = argc - i - 1;
734 break;
735 }
736 if (!dest)
737 usage(fetch_pack_usage);
738
739 ref = fetch_pack(&args, dest, nr_heads, heads, NULL);
740 ret = !ref;
741
742 while (ref) {
743 printf("%s %s\n",
744 sha1_to_hex(ref->old_sha1), ref->name);
745 ref = ref->next;
746 }
747
748 return ret;
749 }
750
751 struct ref *fetch_pack(struct fetch_pack_args *my_args,
752 const char *dest,
753 int nr_heads,
754 char **heads,
755 char **pack_lockfile)
756 {
757 int i, ret;
758 int fd[2];
759 pid_t pid;
760 struct ref *ref;
761 struct stat st;
762
763 memcpy(&args, my_args, sizeof(args));
764 if (args.depth > 0) {
765 if (stat(git_path("shallow"), &st))
766 st.st_mtime = 0;
767 }
768
769 pid = git_connect(fd, (char *)dest, uploadpack,
770 args.verbose ? CONNECT_VERBOSE : 0);
771 if (pid < 0)
772 return NULL;
773 if (heads && nr_heads)
774 nr_heads = remove_duplicates(nr_heads, heads);
775 ref = do_fetch_pack(fd, nr_heads, heads, pack_lockfile);
776 close(fd[0]);
777 close(fd[1]);
778 ret = finish_connect(pid);
779
780 if (!ret && nr_heads) {
781 /* If the heads to pull were given, we should have
782 * consumed all of them by matching the remote.
783 * Otherwise, 'git-fetch remote no-such-ref' would
784 * silently succeed without issuing an error.
785 */
786 for (i = 0; i < nr_heads; i++)
787 if (heads[i] && heads[i][0]) {
788 error("no such remote ref %s", heads[i]);
789 ret = 1;
790 }
791 }
792
793 if (!ret && args.depth > 0) {
794 struct cache_time mtime;
795 char *shallow = git_path("shallow");
796 int fd;
797
798 mtime.sec = st.st_mtime;
799 #ifdef USE_NSEC
800 mtime.usec = st.st_mtim.usec;
801 #endif
802 if (stat(shallow, &st)) {
803 if (mtime.sec)
804 die("shallow file was removed during fetch");
805 } else if (st.st_mtime != mtime.sec
806 #ifdef USE_NSEC
807 || st.st_mtim.usec != mtime.usec
808 #endif
809 )
810 die("shallow file was changed during fetch");
811
812 fd = hold_lock_file_for_update(&lock, shallow, 1);
813 if (!write_shallow_commits(fd, 0)) {
814 unlink(shallow);
815 rollback_lock_file(&lock);
816 } else {
817 close(fd);
818 commit_lock_file(&lock);
819 }
820 }
821
822 if (ret)
823 ref = NULL;
824
825 return ref;
826 }