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