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