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