Andrew's git / gitweb.git / builtin/fetch-pack.c
?
builtin / fetch-pack.con commit Merge branch 'rs/combine-diff-zero-context-at-the-beginning' (f84e8b6)
   1#include "builtin.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
  14static int transfer_unpack_limit = -1;
  15static int fetch_unpack_limit = -1;
  16static int unpack_limit = 100;
  17static int prefer_ofs_delta = 1;
  18static int no_done;
  19static int fetch_fsck_objects = -1;
  20static int transfer_fsck_objects = -1;
  21static struct fetch_pack_args args = {
  22        /* .uploadpack = */ "git-upload-pack",
  23};
  24
  25static const char fetch_pack_usage[] =
  26"git fetch-pack [--all] [--quiet|-q] [--keep|-k] [--thin] [--include-tag] [--upload-pack=<git-upload-pack>] [--depth=<n>] [--no-progress] [-v] [<host>:]<directory> [<refs>...]";
  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
  34static 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
  42static struct commit_list *rev_list;
  43static int non_common_revs, multi_ack, use_sideband;
  44
  45static 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                commit_list_insert_by_date(commit, &rev_list);
  55
  56                if (!(commit->object.flags & COMMON))
  57                        non_common_revs++;
  58        }
  59}
  60
  61static 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
  71static 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
  87static 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
 119static 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 == NULL || non_common_revs == 0)
 128                        return NULL;
 129
 130                commit = rev_list->item;
 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                rev_list = rev_list->next;
 159        }
 160
 161        return commit->object.sha1;
 162}
 163
 164enum ack_type {
 165        NAK = 0,
 166        ACK,
 167        ACK_continue,
 168        ACK_common,
 169        ACK_ready
 170};
 171
 172static void consume_shallow_list(int fd)
 173{
 174        if (args.stateless_rpc && args.depth > 0) {
 175                /* If we sent a depth we will get back "duplicate"
 176                 * shallow and unshallow commands every time there
 177                 * is a block of have lines exchanged.
 178                 */
 179                char line[1000];
 180                while (packet_read_line(fd, line, sizeof(line))) {
 181                        if (!prefixcmp(line, "shallow "))
 182                                continue;
 183                        if (!prefixcmp(line, "unshallow "))
 184                                continue;
 185                        die("git fetch-pack: expected shallow list");
 186                }
 187        }
 188}
 189
 190struct write_shallow_data {
 191        struct strbuf *out;
 192        int use_pack_protocol;
 193        int count;
 194};
 195
 196static int write_one_shallow(const struct commit_graft *graft, void *cb_data)
 197{
 198        struct write_shallow_data *data = cb_data;
 199        const char *hex = sha1_to_hex(graft->sha1);
 200        data->count++;
 201        if (data->use_pack_protocol)
 202                packet_buf_write(data->out, "shallow %s", hex);
 203        else {
 204                strbuf_addstr(data->out, hex);
 205                strbuf_addch(data->out, '\n');
 206        }
 207        return 0;
 208}
 209
 210static int write_shallow_commits(struct strbuf *out, int use_pack_protocol)
 211{
 212        struct write_shallow_data data;
 213        data.out = out;
 214        data.use_pack_protocol = use_pack_protocol;
 215        data.count = 0;
 216        for_each_commit_graft(write_one_shallow, &data);
 217        return data.count;
 218}
 219
 220static enum ack_type get_ack(int fd, unsigned char *result_sha1)
 221{
 222        static char line[1000];
 223        int len = packet_read_line(fd, line, sizeof(line));
 224
 225        if (!len)
 226                die("git fetch-pack: expected ACK/NAK, got EOF");
 227        if (line[len-1] == '\n')
 228                line[--len] = 0;
 229        if (!strcmp(line, "NAK"))
 230                return NAK;
 231        if (!prefixcmp(line, "ACK ")) {
 232                if (!get_sha1_hex(line+4, result_sha1)) {
 233                        if (strstr(line+45, "continue"))
 234                                return ACK_continue;
 235                        if (strstr(line+45, "common"))
 236                                return ACK_common;
 237                        if (strstr(line+45, "ready"))
 238                                return ACK_ready;
 239                        return ACK;
 240                }
 241        }
 242        die("git fetch_pack: expected ACK/NAK, got '%s'", line);
 243}
 244
 245static void send_request(int fd, struct strbuf *buf)
 246{
 247        if (args.stateless_rpc) {
 248                send_sideband(fd, -1, buf->buf, buf->len, LARGE_PACKET_MAX);
 249                packet_flush(fd);
 250        } else
 251                safe_write(fd, buf->buf, buf->len);
 252}
 253
 254static void insert_one_alternate_ref(const struct ref *ref, void *unused)
 255{
 256        rev_list_insert_ref(NULL, ref->old_sha1, 0, NULL);
 257}
 258
 259#define INITIAL_FLUSH 16
 260#define PIPESAFE_FLUSH 32
 261#define LARGE_FLUSH 1024
 262
 263static int next_flush(int count)
 264{
 265        int flush_limit = args.stateless_rpc ? LARGE_FLUSH : PIPESAFE_FLUSH;
 266
 267        if (count < flush_limit)
 268                count <<= 1;
 269        else
 270                count += flush_limit;
 271        return count;
 272}
 273
 274static int find_common(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                        packet_buf_write(&req_buf, "want %s%s\n", remote_hex, c.buf);
 329                        strbuf_release(&c);
 330                } else
 331                        packet_buf_write(&req_buf, "want %s\n", remote_hex);
 332                fetching++;
 333        }
 334
 335        if (!fetching) {
 336                strbuf_release(&req_buf);
 337                packet_flush(fd[1]);
 338                return 1;
 339        }
 340
 341        if (is_repository_shallow())
 342                write_shallow_commits(&req_buf, 1);
 343        if (args.depth > 0)
 344                packet_buf_write(&req_buf, "deepen %d", args.depth);
 345        packet_buf_flush(&req_buf);
 346        state_len = req_buf.len;
 347
 348        if (args.depth > 0) {
 349                char line[1024];
 350                unsigned char sha1[20];
 351
 352                send_request(fd[1], &req_buf);
 353                while (packet_read_line(fd[0], line, sizeof(line))) {
 354                        if (!prefixcmp(line, "shallow ")) {
 355                                if (get_sha1_hex(line + 8, sha1))
 356                                        die("invalid shallow line: %s", line);
 357                                register_shallow(sha1);
 358                                continue;
 359                        }
 360                        if (!prefixcmp(line, "unshallow ")) {
 361                                if (get_sha1_hex(line + 10, sha1))
 362                                        die("invalid unshallow line: %s", line);
 363                                if (!lookup_object(sha1))
 364                                        die("object not found: %s", line);
 365                                /* make sure that it is parsed as shallow */
 366                                if (!parse_object(sha1))
 367                                        die("error in object: %s", line);
 368                                if (unregister_shallow(sha1))
 369                                        die("no shallow found: %s", line);
 370                                continue;
 371                        }
 372                        die("expected shallow/unshallow, got %s", line);
 373                }
 374        } else if (!args.stateless_rpc)
 375                send_request(fd[1], &req_buf);
 376
 377        if (!args.stateless_rpc) {
 378                /* If we aren't using the stateless-rpc interface
 379                 * we don't need to retain the headers.
 380                 */
 381                strbuf_setlen(&req_buf, 0);
 382                state_len = 0;
 383        }
 384
 385        flushes = 0;
 386        retval = -1;
 387        while ((sha1 = get_rev())) {
 388                packet_buf_write(&req_buf, "have %s\n", sha1_to_hex(sha1));
 389                if (args.verbose)
 390                        fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
 391                in_vain++;
 392                if (flush_at <= ++count) {
 393                        int ack;
 394
 395                        packet_buf_flush(&req_buf);
 396                        send_request(fd[1], &req_buf);
 397                        strbuf_setlen(&req_buf, state_len);
 398                        flushes++;
 399                        flush_at = next_flush(count);
 400
 401                        /*
 402                         * We keep one window "ahead" of the other side, and
 403                         * will wait for an ACK only on the next one
 404                         */
 405                        if (!args.stateless_rpc && count == INITIAL_FLUSH)
 406                                continue;
 407
 408                        consume_shallow_list(fd[0]);
 409                        do {
 410                                ack = get_ack(fd[0], result_sha1);
 411                                if (args.verbose && ack)
 412                                        fprintf(stderr, "got ack %d %s\n", ack,
 413                                                        sha1_to_hex(result_sha1));
 414                                switch (ack) {
 415                                case ACK:
 416                                        flushes = 0;
 417                                        multi_ack = 0;
 418                                        retval = 0;
 419                                        goto done;
 420                                case ACK_common:
 421                                case ACK_ready:
 422                                case ACK_continue: {
 423                                        struct commit *commit =
 424                                                lookup_commit(result_sha1);
 425                                        if (!commit)
 426                                                die("invalid commit %s", sha1_to_hex(result_sha1));
 427                                        if (args.stateless_rpc
 428                                         && ack == ACK_common
 429                                         && !(commit->object.flags & COMMON)) {
 430                                                /* We need to replay the have for this object
 431                                                 * on the next RPC request so the peer knows
 432                                                 * it is in common with us.
 433                                                 */
 434                                                const char *hex = sha1_to_hex(result_sha1);
 435                                                packet_buf_write(&req_buf, "have %s\n", hex);
 436                                                state_len = req_buf.len;
 437                                        }
 438                                        mark_common(commit, 0, 1);
 439                                        retval = 0;
 440                                        in_vain = 0;
 441                                        got_continue = 1;
 442                                        if (ack == ACK_ready) {
 443                                                rev_list = NULL;
 444                                                got_ready = 1;
 445                                        }
 446                                        break;
 447                                        }
 448                                }
 449                        } while (ack);
 450                        flushes--;
 451                        if (got_continue && MAX_IN_VAIN < in_vain) {
 452                                if (args.verbose)
 453                                        fprintf(stderr, "giving up\n");
 454                                break; /* give up */
 455                        }
 456                }
 457        }
 458done:
 459        if (!got_ready || !no_done) {
 460                packet_buf_write(&req_buf, "done\n");
 461                send_request(fd[1], &req_buf);
 462        }
 463        if (args.verbose)
 464                fprintf(stderr, "done\n");
 465        if (retval != 0) {
 466                multi_ack = 0;
 467                flushes++;
 468        }
 469        strbuf_release(&req_buf);
 470
 471        consume_shallow_list(fd[0]);
 472        while (flushes || multi_ack) {
 473                int ack = get_ack(fd[0], result_sha1);
 474                if (ack) {
 475                        if (args.verbose)
 476                                fprintf(stderr, "got ack (%d) %s\n", ack,
 477                                        sha1_to_hex(result_sha1));
 478                        if (ack == ACK)
 479                                return 0;
 480                        multi_ack = 1;
 481                        continue;
 482                }
 483                flushes--;
 484        }
 485        /* it is no error to fetch into a completely empty repo */
 486        return count ? retval : 0;
 487}
 488
 489static struct commit_list *complete;
 490
 491static int mark_complete(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
 492{
 493        struct object *o = parse_object(sha1);
 494
 495        while (o && o->type == OBJ_TAG) {
 496                struct tag *t = (struct tag *) o;
 497                if (!t->tagged)
 498                        break; /* broken repository */
 499                o->flags |= COMPLETE;
 500                o = parse_object(t->tagged->sha1);
 501        }
 502        if (o && o->type == OBJ_COMMIT) {
 503                struct commit *commit = (struct commit *)o;
 504                if (!(commit->object.flags & COMPLETE)) {
 505                        commit->object.flags |= COMPLETE;
 506                        commit_list_insert_by_date(commit, &complete);
 507                }
 508        }
 509        return 0;
 510}
 511
 512static void mark_recent_complete_commits(unsigned long cutoff)
 513{
 514        while (complete && cutoff <= complete->item->date) {
 515                if (args.verbose)
 516                        fprintf(stderr, "Marking %s as complete\n",
 517                                sha1_to_hex(complete->item->object.sha1));
 518                pop_most_recent_commit(&complete, COMPLETE);
 519        }
 520}
 521
 522static void filter_refs(struct ref **refs, int nr_match, char **match)
 523{
 524        struct ref **return_refs;
 525        struct ref *newlist = NULL;
 526        struct ref **newtail = &newlist;
 527        struct ref *ref, *next;
 528        struct ref *fastarray[32];
 529
 530        if (nr_match && !args.fetch_all) {
 531                if (ARRAY_SIZE(fastarray) < nr_match)
 532                        return_refs = xcalloc(nr_match, sizeof(struct ref *));
 533                else {
 534                        return_refs = fastarray;
 535                        memset(return_refs, 0, sizeof(struct ref *) * nr_match);
 536                }
 537        }
 538        else
 539                return_refs = NULL;
 540
 541        for (ref = *refs; ref; ref = next) {
 542                next = ref->next;
 543                if (!memcmp(ref->name, "refs/", 5) &&
 544                    check_refname_format(ref->name + 5, 0))
 545                        ; /* trash */
 546                else if (args.fetch_all &&
 547                         (!args.depth || prefixcmp(ref->name, "refs/tags/") )) {
 548                        *newtail = ref;
 549                        ref->next = NULL;
 550                        newtail = &ref->next;
 551                        continue;
 552                }
 553                else {
 554                        int i;
 555                        for (i = 0; i < nr_match; i++) {
 556                                if (!strcmp(ref->name, match[i])) {
 557                                        match[i][0] = '\0';
 558                                        return_refs[i] = ref;
 559                                        break;
 560                                }
 561                        }
 562                        if (i < nr_match)
 563                                continue; /* we will link it later */
 564                }
 565                free(ref);
 566        }
 567
 568        if (!args.fetch_all) {
 569                int i;
 570                for (i = 0; i < nr_match; i++) {
 571                        ref = return_refs[i];
 572                        if (ref) {
 573                                *newtail = ref;
 574                                ref->next = NULL;
 575                                newtail = &ref->next;
 576                        }
 577                }
 578                if (return_refs != fastarray)
 579                        free(return_refs);
 580        }
 581        *refs = newlist;
 582}
 583
 584static void mark_alternate_complete(const struct ref *ref, void *unused)
 585{
 586        mark_complete(NULL, ref->old_sha1, 0, NULL);
 587}
 588
 589static int everything_local(struct ref **refs, int nr_match, char **match)
 590{
 591        struct ref *ref;
 592        int retval;
 593        unsigned long cutoff = 0;
 594
 595        save_commit_buffer = 0;
 596
 597        for (ref = *refs; ref; ref = ref->next) {
 598                struct object *o;
 599
 600                o = parse_object(ref->old_sha1);
 601                if (!o)
 602                        continue;
 603
 604                /* We already have it -- which may mean that we were
 605                 * in sync with the other side at some time after
 606                 * that (it is OK if we guess wrong here).
 607                 */
 608                if (o->type == OBJ_COMMIT) {
 609                        struct commit *commit = (struct commit *)o;
 610                        if (!cutoff || cutoff < commit->date)
 611                                cutoff = commit->date;
 612                }
 613        }
 614
 615        if (!args.depth) {
 616                for_each_ref(mark_complete, NULL);
 617                for_each_alternate_ref(mark_alternate_complete, NULL);
 618                if (cutoff)
 619                        mark_recent_complete_commits(cutoff);
 620        }
 621
 622        /*
 623         * Mark all complete remote refs as common refs.
 624         * Don't mark them common yet; the server has to be told so first.
 625         */
 626        for (ref = *refs; ref; ref = ref->next) {
 627                struct object *o = deref_tag(lookup_object(ref->old_sha1),
 628                                             NULL, 0);
 629
 630                if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
 631                        continue;
 632
 633                if (!(o->flags & SEEN)) {
 634                        rev_list_push((struct commit *)o, COMMON_REF | SEEN);
 635
 636                        mark_common((struct commit *)o, 1, 1);
 637                }
 638        }
 639
 640        filter_refs(refs, nr_match, match);
 641
 642        for (retval = 1, ref = *refs; ref ; ref = ref->next) {
 643                const unsigned char *remote = ref->old_sha1;
 644                unsigned char local[20];
 645                struct object *o;
 646
 647                o = lookup_object(remote);
 648                if (!o || !(o->flags & COMPLETE)) {
 649                        retval = 0;
 650                        if (!args.verbose)
 651                                continue;
 652                        fprintf(stderr,
 653                                "want %s (%s)\n", sha1_to_hex(remote),
 654                                ref->name);
 655                        continue;
 656                }
 657
 658                hashcpy(ref->new_sha1, local);
 659                if (!args.verbose)
 660                        continue;
 661                fprintf(stderr,
 662                        "already have %s (%s)\n", sha1_to_hex(remote),
 663                        ref->name);
 664        }
 665        return retval;
 666}
 667
 668static int sideband_demux(int in, int out, void *data)
 669{
 670        int *xd = data;
 671
 672        int ret = recv_sideband("fetch-pack", xd[0], out);
 673        close(out);
 674        return ret;
 675}
 676
 677static int get_pack(int xd[2], char **pack_lockfile)
 678{
 679        struct async demux;
 680        const char *argv[20];
 681        char keep_arg[256];
 682        char hdr_arg[256];
 683        const char **av;
 684        int do_keep = args.keep_pack;
 685        struct child_process cmd;
 686
 687        memset(&demux, 0, sizeof(demux));
 688        if (use_sideband) {
 689                /* xd[] is talking with upload-pack; subprocess reads from
 690                 * xd[0], spits out band#2 to stderr, and feeds us band#1
 691                 * through demux->out.
 692                 */
 693                demux.proc = sideband_demux;
 694                demux.data = xd;
 695                demux.out = -1;
 696                if (start_async(&demux))
 697                        die("fetch-pack: unable to fork off sideband"
 698                            " demultiplexer");
 699        }
 700        else
 701                demux.out = xd[0];
 702
 703        memset(&cmd, 0, sizeof(cmd));
 704        cmd.argv = argv;
 705        av = argv;
 706        *hdr_arg = 0;
 707        if (!args.keep_pack && unpack_limit) {
 708                struct pack_header header;
 709
 710                if (read_pack_header(demux.out, &header))
 711                        die("protocol error: bad pack header");
 712                snprintf(hdr_arg, sizeof(hdr_arg),
 713                         "--pack_header=%"PRIu32",%"PRIu32,
 714                         ntohl(header.hdr_version), ntohl(header.hdr_entries));
 715                if (ntohl(header.hdr_entries) < unpack_limit)
 716                        do_keep = 0;
 717                else
 718                        do_keep = 1;
 719        }
 720
 721        if (do_keep) {
 722                if (pack_lockfile)
 723                        cmd.out = -1;
 724                *av++ = "index-pack";
 725                *av++ = "--stdin";
 726                if (!args.quiet && !args.no_progress)
 727                        *av++ = "-v";
 728                if (args.use_thin_pack)
 729                        *av++ = "--fix-thin";
 730                if (args.lock_pack || unpack_limit) {
 731                        int s = sprintf(keep_arg,
 732                                        "--keep=fetch-pack %"PRIuMAX " on ", (uintmax_t) getpid());
 733                        if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 734                                strcpy(keep_arg + s, "localhost");
 735                        *av++ = keep_arg;
 736                }
 737        }
 738        else {
 739                *av++ = "unpack-objects";
 740                if (args.quiet || args.no_progress)
 741                        *av++ = "-q";
 742        }
 743        if (*hdr_arg)
 744                *av++ = hdr_arg;
 745        if (fetch_fsck_objects >= 0
 746            ? fetch_fsck_objects
 747            : transfer_fsck_objects >= 0
 748            ? transfer_fsck_objects
 749            : 0)
 750                *av++ = "--strict";
 751        *av++ = NULL;
 752
 753        cmd.in = demux.out;
 754        cmd.git_cmd = 1;
 755        if (start_command(&cmd))
 756                die("fetch-pack: unable to fork off %s", argv[0]);
 757        if (do_keep && pack_lockfile) {
 758                *pack_lockfile = index_pack_lockfile(cmd.out);
 759                close(cmd.out);
 760        }
 761
 762        if (finish_command(&cmd))
 763                die("%s failed", argv[0]);
 764        if (use_sideband && finish_async(&demux))
 765                die("error in sideband demultiplexer");
 766        return 0;
 767}
 768
 769static struct ref *do_fetch_pack(int fd[2],
 770                const struct ref *orig_ref,
 771                int nr_match,
 772                char **match,
 773                char **pack_lockfile)
 774{
 775        struct ref *ref = copy_ref_list(orig_ref);
 776        unsigned char sha1[20];
 777
 778        if (is_repository_shallow() && !server_supports("shallow"))
 779                die("Server does not support shallow clients");
 780        if (server_supports("multi_ack_detailed")) {
 781                if (args.verbose)
 782                        fprintf(stderr, "Server supports multi_ack_detailed\n");
 783                multi_ack = 2;
 784                if (server_supports("no-done")) {
 785                        if (args.verbose)
 786                                fprintf(stderr, "Server supports no-done\n");
 787                        if (args.stateless_rpc)
 788                                no_done = 1;
 789                }
 790        }
 791        else if (server_supports("multi_ack")) {
 792                if (args.verbose)
 793                        fprintf(stderr, "Server supports multi_ack\n");
 794                multi_ack = 1;
 795        }
 796        if (server_supports("side-band-64k")) {
 797                if (args.verbose)
 798                        fprintf(stderr, "Server supports side-band-64k\n");
 799                use_sideband = 2;
 800        }
 801        else if (server_supports("side-band")) {
 802                if (args.verbose)
 803                        fprintf(stderr, "Server supports side-band\n");
 804                use_sideband = 1;
 805        }
 806        if (server_supports("ofs-delta")) {
 807                if (args.verbose)
 808                        fprintf(stderr, "Server supports ofs-delta\n");
 809        } else
 810                prefer_ofs_delta = 0;
 811        if (everything_local(&ref, nr_match, match)) {
 812                packet_flush(fd[1]);
 813                goto all_done;
 814        }
 815        if (find_common(fd, sha1, ref) < 0)
 816                if (!args.keep_pack)
 817                        /* When cloning, it is not unusual to have
 818                         * no common commit.
 819                         */
 820                        warning("no common commits");
 821
 822        if (args.stateless_rpc)
 823                packet_flush(fd[1]);
 824        if (get_pack(fd, pack_lockfile))
 825                die("git fetch-pack: fetch failed.");
 826
 827 all_done:
 828        return ref;
 829}
 830
 831static int remove_duplicates(int nr_heads, char **heads)
 832{
 833        int src, dst;
 834
 835        for (src = dst = 0; src < nr_heads; src++) {
 836                /* If heads[src] is different from any of
 837                 * heads[0..dst], push it in.
 838                 */
 839                int i;
 840                for (i = 0; i < dst; i++) {
 841                        if (!strcmp(heads[i], heads[src]))
 842                                break;
 843                }
 844                if (i < dst)
 845                        continue;
 846                if (src != dst)
 847                        heads[dst] = heads[src];
 848                dst++;
 849        }
 850        return dst;
 851}
 852
 853static int fetch_pack_config(const char *var, const char *value, void *cb)
 854{
 855        if (strcmp(var, "fetch.unpacklimit") == 0) {
 856                fetch_unpack_limit = git_config_int(var, value);
 857                return 0;
 858        }
 859
 860        if (strcmp(var, "transfer.unpacklimit") == 0) {
 861                transfer_unpack_limit = git_config_int(var, value);
 862                return 0;
 863        }
 864
 865        if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
 866                prefer_ofs_delta = git_config_bool(var, value);
 867                return 0;
 868        }
 869
 870        if (!strcmp(var, "fetch.fsckobjects")) {
 871                fetch_fsck_objects = git_config_bool(var, value);
 872                return 0;
 873        }
 874
 875        if (!strcmp(var, "transfer.fsckobjects")) {
 876                transfer_fsck_objects = git_config_bool(var, value);
 877                return 0;
 878        }
 879
 880        return git_default_config(var, value, cb);
 881}
 882
 883static struct lock_file lock;
 884
 885static void fetch_pack_setup(void)
 886{
 887        static int did_setup;
 888        if (did_setup)
 889                return;
 890        git_config(fetch_pack_config, NULL);
 891        if (0 <= transfer_unpack_limit)
 892                unpack_limit = transfer_unpack_limit;
 893        else if (0 <= fetch_unpack_limit)
 894                unpack_limit = fetch_unpack_limit;
 895        did_setup = 1;
 896}
 897
 898int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
 899{
 900        int i, ret, nr_heads;
 901        struct ref *ref = NULL;
 902        char *dest = NULL, **heads;
 903        int fd[2];
 904        char *pack_lockfile = NULL;
 905        char **pack_lockfile_ptr = NULL;
 906        struct child_process *conn;
 907
 908        packet_trace_identity("fetch-pack");
 909
 910        nr_heads = 0;
 911        heads = NULL;
 912        for (i = 1; i < argc; i++) {
 913                const char *arg = argv[i];
 914
 915                if (*arg == '-') {
 916                        if (!prefixcmp(arg, "--upload-pack=")) {
 917                                args.uploadpack = arg + 14;
 918                                continue;
 919                        }
 920                        if (!prefixcmp(arg, "--exec=")) {
 921                                args.uploadpack = arg + 7;
 922                                continue;
 923                        }
 924                        if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
 925                                args.quiet = 1;
 926                                continue;
 927                        }
 928                        if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
 929                                args.lock_pack = args.keep_pack;
 930                                args.keep_pack = 1;
 931                                continue;
 932                        }
 933                        if (!strcmp("--thin", arg)) {
 934                                args.use_thin_pack = 1;
 935                                continue;
 936                        }
 937                        if (!strcmp("--include-tag", arg)) {
 938                                args.include_tag = 1;
 939                                continue;
 940                        }
 941                        if (!strcmp("--all", arg)) {
 942                                args.fetch_all = 1;
 943                                continue;
 944                        }
 945                        if (!strcmp("-v", arg)) {
 946                                args.verbose = 1;
 947                                continue;
 948                        }
 949                        if (!prefixcmp(arg, "--depth=")) {
 950                                args.depth = strtol(arg + 8, NULL, 0);
 951                                continue;
 952                        }
 953                        if (!strcmp("--no-progress", arg)) {
 954                                args.no_progress = 1;
 955                                continue;
 956                        }
 957                        if (!strcmp("--stateless-rpc", arg)) {
 958                                args.stateless_rpc = 1;
 959                                continue;
 960                        }
 961                        if (!strcmp("--lock-pack", arg)) {
 962                                args.lock_pack = 1;
 963                                pack_lockfile_ptr = &pack_lockfile;
 964                                continue;
 965                        }
 966                        usage(fetch_pack_usage);
 967                }
 968                dest = (char *)arg;
 969                heads = (char **)(argv + i + 1);
 970                nr_heads = argc - i - 1;
 971                break;
 972        }
 973        if (!dest)
 974                usage(fetch_pack_usage);
 975
 976        if (args.stateless_rpc) {
 977                conn = NULL;
 978                fd[0] = 0;
 979                fd[1] = 1;
 980        } else {
 981                conn = git_connect(fd, (char *)dest, args.uploadpack,
 982                                   args.verbose ? CONNECT_VERBOSE : 0);
 983        }
 984
 985        get_remote_heads(fd[0], &ref, 0, NULL);
 986
 987        ref = fetch_pack(&args, fd, conn, ref, dest,
 988                nr_heads, heads, pack_lockfile_ptr);
 989        if (pack_lockfile) {
 990                printf("lock %s\n", pack_lockfile);
 991                fflush(stdout);
 992        }
 993        close(fd[0]);
 994        close(fd[1]);
 995        if (finish_connect(conn))
 996                ref = NULL;
 997        ret = !ref;
 998
 999        if (!ret && nr_heads) {
1000                /* If the heads to pull were given, we should have
1001                 * consumed all of them by matching the remote.
1002                 * Otherwise, 'git fetch remote no-such-ref' would
1003                 * silently succeed without issuing an error.
1004                 */
1005                for (i = 0; i < nr_heads; i++)
1006                        if (heads[i] && heads[i][0]) {
1007                                error("no such remote ref %s", heads[i]);
1008                                ret = 1;
1009                        }
1010        }
1011        while (ref) {
1012                printf("%s %s\n",
1013                       sha1_to_hex(ref->old_sha1), ref->name);
1014                ref = ref->next;
1015        }
1016
1017        return ret;
1018}
1019
1020struct ref *fetch_pack(struct fetch_pack_args *my_args,
1021                       int fd[], struct child_process *conn,
1022                       const struct ref *ref,
1023                const char *dest,
1024                int nr_heads,
1025                char **heads,
1026                char **pack_lockfile)
1027{
1028        struct stat st;
1029        struct ref *ref_cpy;
1030
1031        fetch_pack_setup();
1032        if (&args != my_args)
1033                memcpy(&args, my_args, sizeof(args));
1034        if (args.depth > 0) {
1035                if (stat(git_path("shallow"), &st))
1036                        st.st_mtime = 0;
1037        }
1038
1039        if (heads && nr_heads)
1040                nr_heads = remove_duplicates(nr_heads, heads);
1041        if (!ref) {
1042                packet_flush(fd[1]);
1043                die("no matching remote head");
1044        }
1045        ref_cpy = do_fetch_pack(fd, ref, nr_heads, heads, pack_lockfile);
1046
1047        if (args.depth > 0) {
1048                struct cache_time mtime;
1049                struct strbuf sb = STRBUF_INIT;
1050                char *shallow = git_path("shallow");
1051                int fd;
1052
1053                mtime.sec = st.st_mtime;
1054                mtime.nsec = ST_MTIME_NSEC(st);
1055                if (stat(shallow, &st)) {
1056                        if (mtime.sec)
1057                                die("shallow file was removed during fetch");
1058                } else if (st.st_mtime != mtime.sec
1059#ifdef USE_NSEC
1060                                || ST_MTIME_NSEC(st) != mtime.nsec
1061#endif
1062                          )
1063                        die("shallow file was changed during fetch");
1064
1065                fd = hold_lock_file_for_update(&lock, shallow,
1066                                               LOCK_DIE_ON_ERROR);
1067                if (!write_shallow_commits(&sb, 0)
1068                 || write_in_full(fd, sb.buf, sb.len) != sb.len) {
1069                        unlink_or_warn(shallow);
1070                        rollback_lock_file(&lock);
1071                } else {
1072                        commit_lock_file(&lock);
1073                }
1074                strbuf_release(&sb);
1075        }
1076
1077        reprepare_packed_git();
1078        return ref_cpy;
1079}