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