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