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