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