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