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 static void fetch_pack_setup(void)
 674 {
 675         static int did_setup;
 676         if (did_setup)
 677                 return;
 678         git_config(fetch_pack_config);
 679         if (0 <= transfer_unpack_limit)
 680                 unpack_limit = transfer_unpack_limit;
 681         else if (0 <= fetch_unpack_limit)
 682                 unpack_limit = fetch_unpack_limit;
 683         did_setup = 1;
 684 }
 685
 686 int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
 687 {
 688         int i, ret, nr_heads;
 689         struct ref *ref;
 690         char *dest = NULL, **heads;
 691
 692         nr_heads = 0;
 693         heads = NULL;
 694         for (i = 1; i < argc; i++) {
 695                 const char *arg = argv[i];
 696
 697                 if (*arg == '-') {
 698                         if (!prefixcmp(arg, "--upload-pack=")) {
 699                                 args.uploadpack = arg + 14;
 700                                 continue;
 701                         }
 702                         if (!prefixcmp(arg, "--exec=")) {
 703                                 args.uploadpack = arg + 7;
 704                                 continue;
 705                         }
 706                         if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
 707                                 args.quiet = 1;
 708                                 continue;
 709                         }
 710                         if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
 711                                 args.lock_pack = args.keep_pack;
 712                                 args.keep_pack = 1;
 713                                 continue;
 714                         }
 715                         if (!strcmp("--thin", arg)) {
 716                                 args.use_thin_pack = 1;
 717                                 continue;
 718                         }
 719                         if (!strcmp("--all", arg)) {
 720                                 args.fetch_all = 1;
 721                                 continue;
 722                         }
 723                         if (!strcmp("-v", arg)) {
 724                                 args.verbose = 1;
 725                                 continue;
 726                         }
 727                         if (!prefixcmp(arg, "--depth=")) {
 728                                 args.depth = strtol(arg + 8, NULL, 0);
 729                                 continue;
 730                         }
 731                         if (!strcmp("--no-progress", arg)) {
 732                                 args.no_progress = 1;
 733                                 continue;
 734                         }
 735                         usage(fetch_pack_usage);
 736                 }
 737                 dest = (char *)arg;
 738                 heads = (char **)(argv + i + 1);
 739                 nr_heads = argc - i - 1;
 740                 break;
 741         }
 742         if (!dest)
 743                 usage(fetch_pack_usage);
 744
 745         ref = fetch_pack(&args, dest, nr_heads, heads, NULL);
 746         ret = !ref;
 747
 748         while (ref) {
 749                 printf("%s %s\n",
 750                        sha1_to_hex(ref->old_sha1), ref->name);
 751                 ref = ref->next;
 752         }
 753
 754         return ret;
 755 }
 756
 757 struct ref *fetch_pack(struct fetch_pack_args *my_args,
 758                 const char *dest,
 759                 int nr_heads,
 760                 char **heads,
 761                 char **pack_lockfile)
 762 {
 763         int i, ret;
 764         int fd[2];
 765         struct child_process *conn;
 766         struct ref *ref;
 767         struct stat st;
 768
 769         fetch_pack_setup();
 770         memcpy(&args, my_args, sizeof(args));
 771         if (args.depth > 0) {
 772                 if (stat(git_path("shallow"), &st))
 773                         st.st_mtime = 0;
 774         }
 775
 776         conn = git_connect(fd, (char *)dest, uploadpack,
 777                           args.verbose ? CONNECT_VERBOSE : 0);
 778         if (heads && nr_heads)
 779                 nr_heads = remove_duplicates(nr_heads, heads);
 780         ref = do_fetch_pack(fd, nr_heads, heads, pack_lockfile);
 781         close(fd[0]);
 782         close(fd[1]);
 783         ret = finish_connect(conn);
 784
 785         if (!ret && nr_heads) {
 786                 /* If the heads to pull were given, we should have
 787                  * consumed all of them by matching the remote.
 788                  * Otherwise, 'git-fetch remote no-such-ref' would
 789                  * silently succeed without issuing an error.
 790                  */
 791                 for (i = 0; i < nr_heads; i++)
 792                         if (heads[i] && heads[i][0]) {
 793                                 error("no such remote ref %s", heads[i]);
 794                                 ret = 1;
 795                         }
 796         }
 797
 798         if (!ret && args.depth > 0) {
 799                 struct cache_time mtime;
 800                 char *shallow = git_path("shallow");
 801                 int fd;
 802
 803                 mtime.sec = st.st_mtime;
 804 #ifdef USE_NSEC
 805                 mtime.usec = st.st_mtim.usec;
 806 #endif
 807                 if (stat(shallow, &st)) {
 808                         if (mtime.sec)
 809                                 die("shallow file was removed during fetch");
 810                 } else if (st.st_mtime != mtime.sec
 811 #ifdef USE_NSEC
 812                                 || st.st_mtim.usec != mtime.usec
 813 #endif
 814                           )
 815                         die("shallow file was changed during fetch");
 816
 817                 fd = hold_lock_file_for_update(&lock, shallow, 1);
 818                 if (!write_shallow_commits(fd, 0)) {
 819                         unlink(shallow);
 820                         rollback_lock_file(&lock);
 821                 } else {
 822                         close(fd);
 823                         commit_lock_file(&lock);
 824                 }
 825         }
 826
 827         if (ret)
 828                 ref = NULL;
 829
 830         return ref;
 831 }