git.oblomov.eu Git - git/blob - 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, 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         if (!use_sideband)
 751                 /* Closed by start_command() */
 752                 xd[0] = -1;
 753
 754         ret = finish_command(&cmd);
 755         if (!ret || (args->check_self_contained_and_connected && ret == 1))
 756                 args->self_contained_and_connected =
 757                         args->check_self_contained_and_connected &&
 758                         ret == 0;
 759         else
 760                 die("%s failed", cmd_name);
 761         if (use_sideband && finish_async(&demux))
 762                 die("error in sideband demultiplexer");
 763         return 0;
 764 }
 765
 766 static int cmp_ref_by_name(const void *a_, const void *b_)
 767 {
 768         const struct ref *a = *((const struct ref **)a_);
 769         const struct ref *b = *((const struct ref **)b_);
 770         return strcmp(a->name, b->name);
 771 }
 772
 773 static struct ref *do_fetch_pack(struct fetch_pack_args *args,
 774                                  int fd[2],
 775                                  const struct ref *orig_ref,
 776                                  struct ref **sought, int nr_sought,
 777                                  char **pack_lockfile)
 778 {
 779         struct ref *ref = copy_ref_list(orig_ref);
 780         unsigned char sha1[20];
 781         const char *agent_feature;
 782         int agent_len;
 783
 784         sort_ref_list(&ref, ref_compare_name);
 785         qsort(sought, nr_sought, sizeof(*sought), cmp_ref_by_name);
 786
 787         if (is_repository_shallow() && !server_supports("shallow"))
 788                 die("Server does not support shallow clients");
 789         if (server_supports("multi_ack_detailed")) {
 790                 if (args->verbose)
 791                         fprintf(stderr, "Server supports multi_ack_detailed\n");
 792                 multi_ack = 2;
 793                 if (server_supports("no-done")) {
 794                         if (args->verbose)
 795                                 fprintf(stderr, "Server supports no-done\n");
 796                         if (args->stateless_rpc)
 797                                 no_done = 1;
 798                 }
 799         }
 800         else if (server_supports("multi_ack")) {
 801                 if (args->verbose)
 802                         fprintf(stderr, "Server supports multi_ack\n");
 803                 multi_ack = 1;
 804         }
 805         if (server_supports("side-band-64k")) {
 806                 if (args->verbose)
 807                         fprintf(stderr, "Server supports side-band-64k\n");
 808                 use_sideband = 2;
 809         }
 810         else if (server_supports("side-band")) {
 811                 if (args->verbose)
 812                         fprintf(stderr, "Server supports side-band\n");
 813                 use_sideband = 1;
 814         }
 815         if (server_supports("allow-tip-sha1-in-want")) {
 816                 if (args->verbose)
 817                         fprintf(stderr, "Server supports allow-tip-sha1-in-want\n");
 818                 allow_tip_sha1_in_want = 1;
 819         }
 820         if (!server_supports("thin-pack"))
 821                 args->use_thin_pack = 0;
 822         if (!server_supports("no-progress"))
 823                 args->no_progress = 0;
 824         if (!server_supports("include-tag"))
 825                 args->include_tag = 0;
 826         if (server_supports("ofs-delta")) {
 827                 if (args->verbose)
 828                         fprintf(stderr, "Server supports ofs-delta\n");
 829         } else
 830                 prefer_ofs_delta = 0;
 831
 832         if ((agent_feature = server_feature_value("agent", &agent_len))) {
 833                 agent_supported = 1;
 834                 if (args->verbose && agent_len)
 835                         fprintf(stderr, "Server version is %.*s\n",
 836                                 agent_len, agent_feature);
 837         }
 838
 839         if (everything_local(args, &ref, sought, nr_sought)) {
 840                 packet_flush(fd[1]);
 841                 goto all_done;
 842         }
 843         if (find_common(args, fd, sha1, ref) < 0)
 844                 if (!args->keep_pack)
 845                         /* When cloning, it is not unusual to have
 846                          * no common commit.
 847                          */
 848                         warning("no common commits");
 849
 850         if (args->stateless_rpc)
 851                 packet_flush(fd[1]);
 852         if (args->depth > 0)
 853                 setup_alternate_shallow(&shallow_lock, &alternate_shallow_file);
 854         else
 855                 alternate_shallow_file = NULL;
 856         if (get_pack(args, fd, pack_lockfile))
 857                 die("git fetch-pack: fetch failed.");
 858
 859  all_done:
 860         return ref;
 861 }
 862
 863 static int fetch_pack_config(const char *var, const char *value, void *cb)
 864 {
 865         if (strcmp(var, "fetch.unpacklimit") == 0) {
 866                 fetch_unpack_limit = git_config_int(var, value);
 867                 return 0;
 868         }
 869
 870         if (strcmp(var, "transfer.unpacklimit") == 0) {
 871                 transfer_unpack_limit = git_config_int(var, value);
 872                 return 0;
 873         }
 874
 875         if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
 876                 prefer_ofs_delta = git_config_bool(var, value);
 877                 return 0;
 878         }
 879
 880         if (!strcmp(var, "fetch.fsckobjects")) {
 881                 fetch_fsck_objects = git_config_bool(var, value);
 882                 return 0;
 883         }
 884
 885         if (!strcmp(var, "transfer.fsckobjects")) {
 886                 transfer_fsck_objects = git_config_bool(var, value);
 887                 return 0;
 888         }
 889
 890         return git_default_config(var, value, cb);
 891 }
 892
 893 static void fetch_pack_setup(void)
 894 {
 895         static int did_setup;
 896         if (did_setup)
 897                 return;
 898         git_config(fetch_pack_config, NULL);
 899         if (0 <= transfer_unpack_limit)
 900                 unpack_limit = transfer_unpack_limit;
 901         else if (0 <= fetch_unpack_limit)
 902                 unpack_limit = fetch_unpack_limit;
 903         did_setup = 1;
 904 }
 905
 906 static int remove_duplicates_in_refs(struct ref **ref, int nr)
 907 {
 908         struct string_list names = STRING_LIST_INIT_NODUP;
 909         int src, dst;
 910
 911         for (src = dst = 0; src < nr; src++) {
 912                 struct string_list_item *item;
 913                 item = string_list_insert(&names, ref[src]->name);
 914                 if (item->util)
 915                         continue; /* already have it */
 916                 item->util = ref[src];
 917                 if (src != dst)
 918                         ref[dst] = ref[src];
 919                 dst++;
 920         }
 921         for (src = dst; src < nr; src++)
 922                 ref[src] = NULL;
 923         string_list_clear(&names, 0);
 924         return dst;
 925 }
 926
 927 struct ref *fetch_pack(struct fetch_pack_args *args,
 928                        int fd[], struct child_process *conn,
 929                        const struct ref *ref,
 930                        const char *dest,
 931                        struct ref **sought, int nr_sought,
 932                        char **pack_lockfile)
 933 {
 934         struct ref *ref_cpy;
 935
 936         fetch_pack_setup();
 937         if (nr_sought)
 938                 nr_sought = remove_duplicates_in_refs(sought, nr_sought);
 939
 940         if (!ref) {
 941                 packet_flush(fd[1]);
 942                 die("no matching remote head");
 943         }
 944         ref_cpy = do_fetch_pack(args, fd, ref, sought, nr_sought, pack_lockfile);
 945
 946         if (args->depth > 0 && alternate_shallow_file) {
 947                 if (*alternate_shallow_file == '\0') { /* --unshallow */
 948                         unlink_or_warn(git_path("shallow"));
 949                         rollback_lock_file(&shallow_lock);
 950                 } else
 951                         commit_lock_file(&shallow_lock);
 952         }
 953
 954         reprepare_packed_git();
 955         return ref_cpy;
 956 }