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