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                 int len;
 221
 222                 while ((len = packet_read_line(fd[0], line, sizeof(line)))) {
 223                         if (!prefixcmp(line, "shallow ")) {
 224                                 if (get_sha1_hex(line + 8, sha1))
 225                                         die("invalid shallow line: %s", line);
 226                                 register_shallow(sha1);
 227                                 continue;
 228                         }
 229                         if (!prefixcmp(line, "unshallow ")) {
 230                                 if (get_sha1_hex(line + 10, sha1))
 231                                         die("invalid unshallow line: %s", line);
 232                                 if (!lookup_object(sha1))
 233                                         die("object not found: %s", line);
 234                                 /* make sure that it is parsed as shallow */
 235                                 if (!parse_object(sha1))
 236                                         die("error in object: %s", line);
 237                                 if (unregister_shallow(sha1))
 238                                         die("no shallow found: %s", line);
 239                                 continue;
 240                         }
 241                         die("expected shallow/unshallow, got %s", line);
 242                 }
 243         }
 244
 245         flushes = 0;
 246         retval = -1;
 247         while ((sha1 = get_rev())) {
 248                 packet_write(fd[1], "have %s\n", sha1_to_hex(sha1));
 249                 if (args.verbose)
 250                         fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
 251                 in_vain++;
 252                 if (!(31 & ++count)) {
 253                         int ack;
 254
 255                         packet_flush(fd[1]);
 256                         flushes++;
 257
 258                         /*
 259                          * We keep one window "ahead" of the other side, and
 260                          * will wait for an ACK only on the next one
 261                          */
 262                         if (count == 32)
 263                                 continue;
 264
 265                         do {
 266                                 ack = get_ack(fd[0], result_sha1);
 267                                 if (args.verbose && ack)
 268                                         fprintf(stderr, "got ack %d %s\n", ack,
 269                                                         sha1_to_hex(result_sha1));
 270                                 if (ack == 1) {
 271                                         flushes = 0;
 272                                         multi_ack = 0;
 273                                         retval = 0;
 274                                         goto done;
 275                                 } else if (ack == 2) {
 276                                         struct commit *commit =
 277                                                 lookup_commit(result_sha1);
 278                                         mark_common(commit, 0, 1);
 279                                         retval = 0;
 280                                         in_vain = 0;
 281                                         got_continue = 1;
 282                                 }
 283                         } while (ack);
 284                         flushes--;
 285                         if (got_continue && MAX_IN_VAIN < in_vain) {
 286                                 if (args.verbose)
 287                                         fprintf(stderr, "giving up\n");
 288                                 break; /* give up */
 289                         }
 290                 }
 291         }
 292 done:
 293         packet_write(fd[1], "done\n");
 294         if (args.verbose)
 295                 fprintf(stderr, "done\n");
 296         if (retval != 0) {
 297                 multi_ack = 0;
 298                 flushes++;
 299         }
 300         while (flushes || multi_ack) {
 301                 int ack = get_ack(fd[0], result_sha1);
 302                 if (ack) {
 303                         if (args.verbose)
 304                                 fprintf(stderr, "got ack (%d) %s\n", ack,
 305                                         sha1_to_hex(result_sha1));
 306                         if (ack == 1)
 307                                 return 0;
 308                         multi_ack = 1;
 309                         continue;
 310                 }
 311                 flushes--;
 312         }
 313         /* it is no error to fetch into a completely empty repo */
 314         return count ? retval : 0;
 315 }
 316
 317 static struct commit_list *complete;
 318
 319 static int mark_complete(const char *path, const unsigned char *sha1, int flag, void *cb_data)
 320 {
 321         struct object *o = parse_object(sha1);
 322
 323         while (o && o->type == OBJ_TAG) {
 324                 struct tag *t = (struct tag *) o;
 325                 if (!t->tagged)
 326                         break; /* broken repository */
 327                 o->flags |= COMPLETE;
 328                 o = parse_object(t->tagged->sha1);
 329         }
 330         if (o && o->type == OBJ_COMMIT) {
 331                 struct commit *commit = (struct commit *)o;
 332                 commit->object.flags |= COMPLETE;
 333                 insert_by_date(commit, &complete);
 334         }
 335         return 0;
 336 }
 337
 338 static void mark_recent_complete_commits(unsigned long cutoff)
 339 {
 340         while (complete && cutoff <= complete->item->date) {
 341                 if (args.verbose)
 342                         fprintf(stderr, "Marking %s as complete\n",
 343                                 sha1_to_hex(complete->item->object.sha1));
 344                 pop_most_recent_commit(&complete, COMPLETE);
 345         }
 346 }
 347
 348 static void filter_refs(struct ref **refs, int nr_match, char **match)
 349 {
 350         struct ref **return_refs;
 351         struct ref *newlist = NULL;
 352         struct ref **newtail = &newlist;
 353         struct ref *ref, *next;
 354         struct ref *fastarray[32];
 355
 356         if (nr_match && !args.fetch_all) {
 357                 if (ARRAY_SIZE(fastarray) < nr_match)
 358                         return_refs = xcalloc(nr_match, sizeof(struct ref *));
 359                 else {
 360                         return_refs = fastarray;
 361                         memset(return_refs, 0, sizeof(struct ref *) * nr_match);
 362                 }
 363         }
 364         else
 365                 return_refs = NULL;
 366
 367         for (ref = *refs; ref; ref = next) {
 368                 next = ref->next;
 369                 if (!memcmp(ref->name, "refs/", 5) &&
 370                     check_ref_format(ref->name + 5))
 371                         ; /* trash */
 372                 else if (args.fetch_all &&
 373                          (!args.depth || prefixcmp(ref->name, "refs/tags/") )) {
 374                         *newtail = ref;
 375                         ref->next = NULL;
 376                         newtail = &ref->next;
 377                         continue;
 378                 }
 379                 else {
 380                         int order = path_match(ref->name, nr_match, match);
 381                         if (order) {
 382                                 return_refs[order-1] = ref;
 383                                 continue; /* we will link it later */
 384                         }
 385                 }
 386                 free(ref);
 387         }
 388
 389         if (!args.fetch_all) {
 390                 int i;
 391                 for (i = 0; i < nr_match; i++) {
 392                         ref = return_refs[i];
 393                         if (ref) {
 394                                 *newtail = ref;
 395                                 ref->next = NULL;
 396                                 newtail = &ref->next;
 397                         }
 398                 }
 399                 if (return_refs != fastarray)
 400                         free(return_refs);
 401         }
 402         *refs = newlist;
 403 }
 404
 405 static int everything_local(struct ref **refs, int nr_match, char **match)
 406 {
 407         struct ref *ref;
 408         int retval;
 409         unsigned long cutoff = 0;
 410
 411         save_commit_buffer = 0;
 412
 413         for (ref = *refs; ref; ref = ref->next) {
 414                 struct object *o;
 415
 416                 o = parse_object(ref->old_sha1);
 417                 if (!o)
 418                         continue;
 419
 420                 /* We already have it -- which may mean that we were
 421                  * in sync with the other side at some time after
 422                  * that (it is OK if we guess wrong here).
 423                  */
 424                 if (o->type == OBJ_COMMIT) {
 425                         struct commit *commit = (struct commit *)o;
 426                         if (!cutoff || cutoff < commit->date)
 427                                 cutoff = commit->date;
 428                 }
 429         }
 430
 431         if (!args.depth) {
 432                 for_each_ref(mark_complete, NULL);
 433                 if (cutoff)
 434                         mark_recent_complete_commits(cutoff);
 435         }
 436
 437         /*
 438          * Mark all complete remote refs as common refs.
 439          * Don't mark them common yet; the server has to be told so first.
 440          */
 441         for (ref = *refs; ref; ref = ref->next) {
 442                 struct object *o = deref_tag(lookup_object(ref->old_sha1),
 443                                              NULL, 0);
 444
 445                 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
 446                         continue;
 447
 448                 if (!(o->flags & SEEN)) {
 449                         rev_list_push((struct commit *)o, COMMON_REF | SEEN);
 450
 451                         mark_common((struct commit *)o, 1, 1);
 452                 }
 453         }
 454
 455         filter_refs(refs, nr_match, match);
 456
 457         for (retval = 1, ref = *refs; ref ; ref = ref->next) {
 458                 const unsigned char *remote = ref->old_sha1;
 459                 unsigned char local[20];
 460                 struct object *o;
 461
 462                 o = lookup_object(remote);
 463                 if (!o || !(o->flags & COMPLETE)) {
 464                         retval = 0;
 465                         if (!args.verbose)
 466                                 continue;
 467                         fprintf(stderr,
 468                                 "want %s (%s)\n", sha1_to_hex(remote),
 469                                 ref->name);
 470                         continue;
 471                 }
 472
 473                 hashcpy(ref->new_sha1, local);
 474                 if (!args.verbose)
 475                         continue;
 476                 fprintf(stderr,
 477                         "already have %s (%s)\n", sha1_to_hex(remote),
 478                         ref->name);
 479         }
 480         return retval;
 481 }
 482
 483 static int sideband_demux(int fd, void *data)
 484 {
 485         int *xd = data;
 486
 487         return recv_sideband("fetch-pack", xd[0], fd, 2);
 488 }
 489
 490 static int get_pack(int xd[2], char **pack_lockfile)
 491 {
 492         struct async demux;
 493         const char *argv[20];
 494         char keep_arg[256];
 495         char hdr_arg[256];
 496         const char **av;
 497         int do_keep = args.keep_pack;
 498         struct child_process cmd;
 499
 500         memset(&demux, 0, sizeof(demux));
 501         if (use_sideband) {
 502                 /* xd[] is talking with upload-pack; subprocess reads from
 503                  * xd[0], spits out band#2 to stderr, and feeds us band#1
 504                  * through demux->out.
 505                  */
 506                 demux.proc = sideband_demux;
 507                 demux.data = xd;
 508                 if (start_async(&demux))
 509                         die("fetch-pack: unable to fork off sideband"
 510                             " demultiplexer");
 511         }
 512         else
 513                 demux.out = xd[0];
 514
 515         memset(&cmd, 0, sizeof(cmd));
 516         cmd.argv = argv;
 517         av = argv;
 518         *hdr_arg = 0;
 519         if (!args.keep_pack && unpack_limit) {
 520                 struct pack_header header;
 521
 522                 if (read_pack_header(demux.out, &header))
 523                         die("protocol error: bad pack header");
 524                 snprintf(hdr_arg, sizeof(hdr_arg),
 525                          "--pack_header=%"PRIu32",%"PRIu32,
 526                          ntohl(header.hdr_version), ntohl(header.hdr_entries));
 527                 if (ntohl(header.hdr_entries) < unpack_limit)
 528                         do_keep = 0;
 529                 else
 530                         do_keep = 1;
 531         }
 532
 533         if (do_keep) {
 534                 if (pack_lockfile)
 535                         cmd.out = -1;
 536                 *av++ = "index-pack";
 537                 *av++ = "--stdin";
 538                 if (!args.quiet && !args.no_progress)
 539                         *av++ = "-v";
 540                 if (args.use_thin_pack)
 541                         *av++ = "--fix-thin";
 542                 if (args.lock_pack || unpack_limit) {
 543                         int s = sprintf(keep_arg,
 544                                         "--keep=fetch-pack %"PRIuMAX " on ", (uintmax_t) getpid());
 545                         if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 546                                 strcpy(keep_arg + s, "localhost");
 547                         *av++ = keep_arg;
 548                 }
 549         }
 550         else {
 551                 *av++ = "unpack-objects";
 552                 if (args.quiet)
 553                         *av++ = "-q";
 554         }
 555         if (*hdr_arg)
 556                 *av++ = hdr_arg;
 557         *av++ = NULL;
 558
 559         cmd.in = demux.out;
 560         cmd.git_cmd = 1;
 561         if (start_command(&cmd))
 562                 die("fetch-pack: unable to fork off %s", argv[0]);
 563         if (do_keep && pack_lockfile) {
 564                 *pack_lockfile = index_pack_lockfile(cmd.out);
 565                 close(cmd.out);
 566         }
 567
 568         if (finish_command(&cmd))
 569                 die("%s failed", argv[0]);
 570         if (use_sideband && finish_async(&demux))
 571                 die("error in sideband demultiplexer");
 572         return 0;
 573 }
 574
 575 static struct ref *do_fetch_pack(int fd[2],
 576                 const struct ref *orig_ref,
 577                 int nr_match,
 578                 char **match,
 579                 char **pack_lockfile)
 580 {
 581         struct ref *ref = copy_ref_list(orig_ref);
 582         unsigned char sha1[20];
 583
 584         if (is_repository_shallow() && !server_supports("shallow"))
 585                 die("Server does not support shallow clients");
 586         if (server_supports("multi_ack")) {
 587                 if (args.verbose)
 588                         fprintf(stderr, "Server supports multi_ack\n");
 589                 multi_ack = 1;
 590         }
 591         if (server_supports("side-band-64k")) {
 592                 if (args.verbose)
 593                         fprintf(stderr, "Server supports side-band-64k\n");
 594                 use_sideband = 2;
 595         }
 596         else if (server_supports("side-band")) {
 597                 if (args.verbose)
 598                         fprintf(stderr, "Server supports side-band\n");
 599                 use_sideband = 1;
 600         }
 601         if (server_supports("ofs-delta")) {
 602                 if (args.verbose)
 603                         fprintf(stderr, "Server supports ofs-delta\n");
 604         } else
 605                 prefer_ofs_delta = 0;
 606         if (everything_local(&ref, nr_match, match)) {
 607                 packet_flush(fd[1]);
 608                 goto all_done;
 609         }
 610         if (find_common(fd, sha1, ref) < 0)
 611                 if (!args.keep_pack)
 612                         /* When cloning, it is not unusual to have
 613                          * no common commit.
 614                          */
 615                         fprintf(stderr, "warning: no common commits\n");
 616
 617         if (get_pack(fd, pack_lockfile))
 618                 die("git fetch-pack: fetch failed.");
 619
 620  all_done:
 621         return ref;
 622 }
 623
 624 static int remove_duplicates(int nr_heads, char **heads)
 625 {
 626         int src, dst;
 627
 628         for (src = dst = 0; src < nr_heads; src++) {
 629                 /* If heads[src] is different from any of
 630                  * heads[0..dst], push it in.
 631                  */
 632                 int i;
 633                 for (i = 0; i < dst; i++) {
 634                         if (!strcmp(heads[i], heads[src]))
 635                                 break;
 636                 }
 637                 if (i < dst)
 638                         continue;
 639                 if (src != dst)
 640                         heads[dst] = heads[src];
 641                 dst++;
 642         }
 643         return dst;
 644 }
 645
 646 static int fetch_pack_config(const char *var, const char *value, void *cb)
 647 {
 648         if (strcmp(var, "fetch.unpacklimit") == 0) {
 649                 fetch_unpack_limit = git_config_int(var, value);
 650                 return 0;
 651         }
 652
 653         if (strcmp(var, "transfer.unpacklimit") == 0) {
 654                 transfer_unpack_limit = git_config_int(var, value);
 655                 return 0;
 656         }
 657
 658         if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
 659                 prefer_ofs_delta = git_config_bool(var, value);
 660                 return 0;
 661         }
 662
 663         return git_default_config(var, value, cb);
 664 }
 665
 666 static struct lock_file lock;
 667
 668 static void fetch_pack_setup(void)
 669 {
 670         static int did_setup;
 671         if (did_setup)
 672                 return;
 673         git_config(fetch_pack_config, NULL);
 674         if (0 <= transfer_unpack_limit)
 675                 unpack_limit = transfer_unpack_limit;
 676         else if (0 <= fetch_unpack_limit)
 677                 unpack_limit = fetch_unpack_limit;
 678         did_setup = 1;
 679 }
 680
 681 int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
 682 {
 683         int i, ret, nr_heads;
 684         struct ref *ref = NULL;
 685         char *dest = NULL, **heads;
 686         int fd[2];
 687         struct child_process *conn;
 688
 689         nr_heads = 0;
 690         heads = NULL;
 691         for (i = 1; i < argc; i++) {
 692                 const char *arg = argv[i];
 693
 694                 if (*arg == '-') {
 695                         if (!prefixcmp(arg, "--upload-pack=")) {
 696                                 args.uploadpack = arg + 14;
 697                                 continue;
 698                         }
 699                         if (!prefixcmp(arg, "--exec=")) {
 700                                 args.uploadpack = arg + 7;
 701                                 continue;
 702                         }
 703                         if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
 704                                 args.quiet = 1;
 705                                 continue;
 706                         }
 707                         if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
 708                                 args.lock_pack = args.keep_pack;
 709                                 args.keep_pack = 1;
 710                                 continue;
 711                         }
 712                         if (!strcmp("--thin", arg)) {
 713                                 args.use_thin_pack = 1;
 714                                 continue;
 715                         }
 716                         if (!strcmp("--include-tag", arg)) {
 717                                 args.include_tag = 1;
 718                                 continue;
 719                         }
 720                         if (!strcmp("--all", arg)) {
 721                                 args.fetch_all = 1;
 722                                 continue;
 723                         }
 724                         if (!strcmp("-v", arg)) {
 725                                 args.verbose = 1;
 726                                 continue;
 727                         }
 728                         if (!prefixcmp(arg, "--depth=")) {
 729                                 args.depth = strtol(arg + 8, NULL, 0);
 730                                 continue;
 731                         }
 732                         if (!strcmp("--no-progress", arg)) {
 733                                 args.no_progress = 1;
 734                                 continue;
 735                         }
 736                         usage(fetch_pack_usage);
 737                 }
 738                 dest = (char *)arg;
 739                 heads = (char **)(argv + i + 1);
 740                 nr_heads = argc - i - 1;
 741                 break;
 742         }
 743         if (!dest)
 744                 usage(fetch_pack_usage);
 745
 746         conn = git_connect(fd, (char *)dest, args.uploadpack,
 747                            args.verbose ? CONNECT_VERBOSE : 0);
 748         if (conn) {
 749                 get_remote_heads(fd[0], &ref, 0, NULL, 0, NULL);
 750
 751                 ref = fetch_pack(&args, fd, conn, ref, dest, nr_heads, heads, NULL);
 752                 close(fd[0]);
 753                 close(fd[1]);
 754                 if (finish_connect(conn))
 755                         ref = NULL;
 756         } else {
 757                 ref = NULL;
 758         }
 759         ret = !ref;
 760
 761         if (!ret && nr_heads) {
 762                 /* If the heads to pull were given, we should have
 763                  * consumed all of them by matching the remote.
 764                  * Otherwise, 'git fetch remote no-such-ref' would
 765                  * silently succeed without issuing an error.
 766                  */
 767                 for (i = 0; i < nr_heads; i++)
 768                         if (heads[i] && heads[i][0]) {
 769                                 error("no such remote ref %s", heads[i]);
 770                                 ret = 1;
 771                         }
 772         }
 773         while (ref) {
 774                 printf("%s %s\n",
 775                        sha1_to_hex(ref->old_sha1), ref->name);
 776                 ref = ref->next;
 777         }
 778
 779         return ret;
 780 }
 781
 782 struct ref *fetch_pack(struct fetch_pack_args *my_args,
 783                        int fd[], struct child_process *conn,
 784                        const struct ref *ref,
 785                 const char *dest,
 786                 int nr_heads,
 787                 char **heads,
 788                 char **pack_lockfile)
 789 {
 790         struct stat st;
 791         struct ref *ref_cpy;
 792
 793         fetch_pack_setup();
 794         if (&args != my_args)
 795                 memcpy(&args, my_args, sizeof(args));
 796         if (args.depth > 0) {
 797                 if (stat(git_path("shallow"), &st))
 798                         st.st_mtime = 0;
 799         }
 800
 801         if (heads && nr_heads)
 802                 nr_heads = remove_duplicates(nr_heads, heads);
 803         if (!ref) {
 804                 packet_flush(fd[1]);
 805                 die("no matching remote head");
 806         }
 807         ref_cpy = do_fetch_pack(fd, ref, nr_heads, heads, pack_lockfile);
 808
 809         if (args.depth > 0) {
 810                 struct cache_time mtime;
 811                 char *shallow = git_path("shallow");
 812                 int fd;
 813
 814                 mtime.sec = st.st_mtime;
 815 #ifdef USE_NSEC
 816                 mtime.usec = st.st_mtim.usec;
 817 #endif
 818                 if (stat(shallow, &st)) {
 819                         if (mtime.sec)
 820                                 die("shallow file was removed during fetch");
 821                 } else if (st.st_mtime != mtime.sec
 822 #ifdef USE_NSEC
 823                                 || st.st_mtim.usec != mtime.usec
 824 #endif
 825                           )
 826                         die("shallow file was changed during fetch");
 827
 828                 fd = hold_lock_file_for_update(&lock, shallow,
 829                                                LOCK_DIE_ON_ERROR);
 830                 if (!write_shallow_commits(fd, 0)) {
 831                         unlink(shallow);
 832                         rollback_lock_file(&lock);
 833                 } else {
 834                         commit_lock_file(&lock);
 835                 }
 836         }
 837
 838         reprepare_packed_git();
 839         return ref_cpy;
 840 }