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