Andrew's git / gitweb.git / builtin/fetch-pack.c
?
builtin / fetch-pack.con commit Merge branch 'aw/rebase-i-stop-on-failure-to-amend' into maint (d9d73b3)
   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 order = path_match(ref->name, nr_match, match);
 560                        if (order) {
 561                                return_refs[order-1] = ref;
 562                                continue; /* we will link it later */
 563                        }
 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 int everything_local(struct ref **refs, int nr_match, char **match)
 585{
 586        struct ref *ref;
 587        int retval;
 588        unsigned long cutoff = 0;
 589
 590        save_commit_buffer = 0;
 591
 592        for (ref = *refs; ref; ref = ref->next) {
 593                struct object *o;
 594
 595                o = parse_object(ref->old_sha1);
 596                if (!o)
 597                        continue;
 598
 599                /* We already have it -- which may mean that we were
 600                 * in sync with the other side at some time after
 601                 * that (it is OK if we guess wrong here).
 602                 */
 603                if (o->type == OBJ_COMMIT) {
 604                        struct commit *commit = (struct commit *)o;
 605                        if (!cutoff || cutoff < commit->date)
 606                                cutoff = commit->date;
 607                }
 608        }
 609
 610        if (!args.depth) {
 611                for_each_ref(mark_complete, NULL);
 612                if (cutoff)
 613                        mark_recent_complete_commits(cutoff);
 614        }
 615
 616        /*
 617         * Mark all complete remote refs as common refs.
 618         * Don't mark them common yet; the server has to be told so first.
 619         */
 620        for (ref = *refs; ref; ref = ref->next) {
 621                struct object *o = deref_tag(lookup_object(ref->old_sha1),
 622                                             NULL, 0);
 623
 624                if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
 625                        continue;
 626
 627                if (!(o->flags & SEEN)) {
 628                        rev_list_push((struct commit *)o, COMMON_REF | SEEN);
 629
 630                        mark_common((struct commit *)o, 1, 1);
 631                }
 632        }
 633
 634        filter_refs(refs, nr_match, match);
 635
 636        for (retval = 1, ref = *refs; ref ; ref = ref->next) {
 637                const unsigned char *remote = ref->old_sha1;
 638                unsigned char local[20];
 639                struct object *o;
 640
 641                o = lookup_object(remote);
 642                if (!o || !(o->flags & COMPLETE)) {
 643                        retval = 0;
 644                        if (!args.verbose)
 645                                continue;
 646                        fprintf(stderr,
 647                                "want %s (%s)\n", sha1_to_hex(remote),
 648                                ref->name);
 649                        continue;
 650                }
 651
 652                hashcpy(ref->new_sha1, local);
 653                if (!args.verbose)
 654                        continue;
 655                fprintf(stderr,
 656                        "already have %s (%s)\n", sha1_to_hex(remote),
 657                        ref->name);
 658        }
 659        return retval;
 660}
 661
 662static int sideband_demux(int in, int out, void *data)
 663{
 664        int *xd = data;
 665
 666        int ret = recv_sideband("fetch-pack", xd[0], out);
 667        close(out);
 668        return ret;
 669}
 670
 671static int get_pack(int xd[2], char **pack_lockfile)
 672{
 673        struct async demux;
 674        const char *argv[20];
 675        char keep_arg[256];
 676        char hdr_arg[256];
 677        const char **av;
 678        int do_keep = args.keep_pack;
 679        struct child_process cmd;
 680
 681        memset(&demux, 0, sizeof(demux));
 682        if (use_sideband) {
 683                /* xd[] is talking with upload-pack; subprocess reads from
 684                 * xd[0], spits out band#2 to stderr, and feeds us band#1
 685                 * through demux->out.
 686                 */
 687                demux.proc = sideband_demux;
 688                demux.data = xd;
 689                demux.out = -1;
 690                if (start_async(&demux))
 691                        die("fetch-pack: unable to fork off sideband"
 692                            " demultiplexer");
 693        }
 694        else
 695                demux.out = xd[0];
 696
 697        memset(&cmd, 0, sizeof(cmd));
 698        cmd.argv = argv;
 699        av = argv;
 700        *hdr_arg = 0;
 701        if (!args.keep_pack && unpack_limit) {
 702                struct pack_header header;
 703
 704                if (read_pack_header(demux.out, &header))
 705                        die("protocol error: bad pack header");
 706                snprintf(hdr_arg, sizeof(hdr_arg),
 707                         "--pack_header=%"PRIu32",%"PRIu32,
 708                         ntohl(header.hdr_version), ntohl(header.hdr_entries));
 709                if (ntohl(header.hdr_entries) < unpack_limit)
 710                        do_keep = 0;
 711                else
 712                        do_keep = 1;
 713        }
 714
 715        if (do_keep) {
 716                if (pack_lockfile)
 717                        cmd.out = -1;
 718                *av++ = "index-pack";
 719                *av++ = "--stdin";
 720                if (!args.quiet && !args.no_progress)
 721                        *av++ = "-v";
 722                if (args.use_thin_pack)
 723                        *av++ = "--fix-thin";
 724                if (args.lock_pack || unpack_limit) {
 725                        int s = sprintf(keep_arg,
 726                                        "--keep=fetch-pack %"PRIuMAX " on ", (uintmax_t) getpid());
 727                        if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 728                                strcpy(keep_arg + s, "localhost");
 729                        *av++ = keep_arg;
 730                }
 731        }
 732        else {
 733                *av++ = "unpack-objects";
 734                if (args.quiet)
 735                        *av++ = "-q";
 736        }
 737        if (*hdr_arg)
 738                *av++ = hdr_arg;
 739        if (fetch_fsck_objects >= 0
 740            ? fetch_fsck_objects
 741            : transfer_fsck_objects >= 0
 742            ? transfer_fsck_objects
 743            : 0)
 744                *av++ = "--strict";
 745        *av++ = NULL;
 746
 747        cmd.in = demux.out;
 748        cmd.git_cmd = 1;
 749        if (start_command(&cmd))
 750                die("fetch-pack: unable to fork off %s", argv[0]);
 751        if (do_keep && pack_lockfile) {
 752                *pack_lockfile = index_pack_lockfile(cmd.out);
 753                close(cmd.out);
 754        }
 755
 756        if (finish_command(&cmd))
 757                die("%s failed", argv[0]);
 758        if (use_sideband && finish_async(&demux))
 759                die("error in sideband demultiplexer");
 760        return 0;
 761}
 762
 763static struct ref *do_fetch_pack(int fd[2],
 764                const struct ref *orig_ref,
 765                int nr_match,
 766                char **match,
 767                char **pack_lockfile)
 768{
 769        struct ref *ref = copy_ref_list(orig_ref);
 770        unsigned char sha1[20];
 771
 772        if (is_repository_shallow() && !server_supports("shallow"))
 773                die("Server does not support shallow clients");
 774        if (server_supports("multi_ack_detailed")) {
 775                if (args.verbose)
 776                        fprintf(stderr, "Server supports multi_ack_detailed\n");
 777                multi_ack = 2;
 778                if (server_supports("no-done")) {
 779                        if (args.verbose)
 780                                fprintf(stderr, "Server supports no-done\n");
 781                        if (args.stateless_rpc)
 782                                no_done = 1;
 783                }
 784        }
 785        else if (server_supports("multi_ack")) {
 786                if (args.verbose)
 787                        fprintf(stderr, "Server supports multi_ack\n");
 788                multi_ack = 1;
 789        }
 790        if (server_supports("side-band-64k")) {
 791                if (args.verbose)
 792                        fprintf(stderr, "Server supports side-band-64k\n");
 793                use_sideband = 2;
 794        }
 795        else if (server_supports("side-band")) {
 796                if (args.verbose)
 797                        fprintf(stderr, "Server supports side-band\n");
 798                use_sideband = 1;
 799        }
 800        if (server_supports("ofs-delta")) {
 801                if (args.verbose)
 802                        fprintf(stderr, "Server supports ofs-delta\n");
 803        } else
 804                prefer_ofs_delta = 0;
 805        if (everything_local(&ref, nr_match, match)) {
 806                packet_flush(fd[1]);
 807                goto all_done;
 808        }
 809        if (find_common(fd, sha1, ref) < 0)
 810                if (!args.keep_pack)
 811                        /* When cloning, it is not unusual to have
 812                         * no common commit.
 813                         */
 814                        warning("no common commits");
 815
 816        if (args.stateless_rpc)
 817                packet_flush(fd[1]);
 818        if (get_pack(fd, pack_lockfile))
 819                die("git fetch-pack: fetch failed.");
 820
 821 all_done:
 822        return ref;
 823}
 824
 825static int remove_duplicates(int nr_heads, char **heads)
 826{
 827        int src, dst;
 828
 829        for (src = dst = 0; src < nr_heads; src++) {
 830                /* If heads[src] is different from any of
 831                 * heads[0..dst], push it in.
 832                 */
 833                int i;
 834                for (i = 0; i < dst; i++) {
 835                        if (!strcmp(heads[i], heads[src]))
 836                                break;
 837                }
 838                if (i < dst)
 839                        continue;
 840                if (src != dst)
 841                        heads[dst] = heads[src];
 842                dst++;
 843        }
 844        return dst;
 845}
 846
 847static int fetch_pack_config(const char *var, const char *value, void *cb)
 848{
 849        if (strcmp(var, "fetch.unpacklimit") == 0) {
 850                fetch_unpack_limit = git_config_int(var, value);
 851                return 0;
 852        }
 853
 854        if (strcmp(var, "transfer.unpacklimit") == 0) {
 855                transfer_unpack_limit = git_config_int(var, value);
 856                return 0;
 857        }
 858
 859        if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
 860                prefer_ofs_delta = git_config_bool(var, value);
 861                return 0;
 862        }
 863
 864        if (!strcmp(var, "fetch.fsckobjects")) {
 865                fetch_fsck_objects = git_config_bool(var, value);
 866                return 0;
 867        }
 868
 869        if (!strcmp(var, "transfer.fsckobjects")) {
 870                transfer_fsck_objects = git_config_bool(var, value);
 871                return 0;
 872        }
 873
 874        return git_default_config(var, value, cb);
 875}
 876
 877static struct lock_file lock;
 878
 879static void fetch_pack_setup(void)
 880{
 881        static int did_setup;
 882        if (did_setup)
 883                return;
 884        git_config(fetch_pack_config, NULL);
 885        if (0 <= transfer_unpack_limit)
 886                unpack_limit = transfer_unpack_limit;
 887        else if (0 <= fetch_unpack_limit)
 888                unpack_limit = fetch_unpack_limit;
 889        did_setup = 1;
 890}
 891
 892int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
 893{
 894        int i, ret, nr_heads;
 895        struct ref *ref = NULL;
 896        char *dest = NULL, **heads;
 897        int fd[2];
 898        char *pack_lockfile = NULL;
 899        char **pack_lockfile_ptr = NULL;
 900        struct child_process *conn;
 901
 902        packet_trace_identity("fetch-pack");
 903
 904        nr_heads = 0;
 905        heads = NULL;
 906        for (i = 1; i < argc; i++) {
 907                const char *arg = argv[i];
 908
 909                if (*arg == '-') {
 910                        if (!prefixcmp(arg, "--upload-pack=")) {
 911                                args.uploadpack = arg + 14;
 912                                continue;
 913                        }
 914                        if (!prefixcmp(arg, "--exec=")) {
 915                                args.uploadpack = arg + 7;
 916                                continue;
 917                        }
 918                        if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
 919                                args.quiet = 1;
 920                                continue;
 921                        }
 922                        if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
 923                                args.lock_pack = args.keep_pack;
 924                                args.keep_pack = 1;
 925                                continue;
 926                        }
 927                        if (!strcmp("--thin", arg)) {
 928                                args.use_thin_pack = 1;
 929                                continue;
 930                        }
 931                        if (!strcmp("--include-tag", arg)) {
 932                                args.include_tag = 1;
 933                                continue;
 934                        }
 935                        if (!strcmp("--all", arg)) {
 936                                args.fetch_all = 1;
 937                                continue;
 938                        }
 939                        if (!strcmp("-v", arg)) {
 940                                args.verbose = 1;
 941                                continue;
 942                        }
 943                        if (!prefixcmp(arg, "--depth=")) {
 944                                args.depth = strtol(arg + 8, NULL, 0);
 945                                continue;
 946                        }
 947                        if (!strcmp("--no-progress", arg)) {
 948                                args.no_progress = 1;
 949                                continue;
 950                        }
 951                        if (!strcmp("--stateless-rpc", arg)) {
 952                                args.stateless_rpc = 1;
 953                                continue;
 954                        }
 955                        if (!strcmp("--lock-pack", arg)) {
 956                                args.lock_pack = 1;
 957                                pack_lockfile_ptr = &pack_lockfile;
 958                                continue;
 959                        }
 960                        usage(fetch_pack_usage);
 961                }
 962                dest = (char *)arg;
 963                heads = (char **)(argv + i + 1);
 964                nr_heads = argc - i - 1;
 965                break;
 966        }
 967        if (!dest)
 968                usage(fetch_pack_usage);
 969
 970        if (args.stateless_rpc) {
 971                conn = NULL;
 972                fd[0] = 0;
 973                fd[1] = 1;
 974        } else {
 975                conn = git_connect(fd, (char *)dest, args.uploadpack,
 976                                   args.verbose ? CONNECT_VERBOSE : 0);
 977        }
 978
 979        get_remote_heads(fd[0], &ref, 0, NULL, 0, NULL);
 980
 981        ref = fetch_pack(&args, fd, conn, ref, dest,
 982                nr_heads, heads, pack_lockfile_ptr);
 983        if (pack_lockfile) {
 984                printf("lock %s\n", pack_lockfile);
 985                fflush(stdout);
 986        }
 987        close(fd[0]);
 988        close(fd[1]);
 989        if (finish_connect(conn))
 990                ref = NULL;
 991        ret = !ref;
 992
 993        if (!ret && nr_heads) {
 994                /* If the heads to pull were given, we should have
 995                 * consumed all of them by matching the remote.
 996                 * Otherwise, 'git fetch remote no-such-ref' would
 997                 * silently succeed without issuing an error.
 998                 */
 999                for (i = 0; i < nr_heads; i++)
1000                        if (heads[i] && heads[i][0]) {
1001                                error("no such remote ref %s", heads[i]);
1002                                ret = 1;
1003                        }
1004        }
1005        while (ref) {
1006                printf("%s %s\n",
1007                       sha1_to_hex(ref->old_sha1), ref->name);
1008                ref = ref->next;
1009        }
1010
1011        return ret;
1012}
1013
1014struct ref *fetch_pack(struct fetch_pack_args *my_args,
1015                       int fd[], struct child_process *conn,
1016                       const struct ref *ref,
1017                const char *dest,
1018                int nr_heads,
1019                char **heads,
1020                char **pack_lockfile)
1021{
1022        struct stat st;
1023        struct ref *ref_cpy;
1024
1025        fetch_pack_setup();
1026        if (&args != my_args)
1027                memcpy(&args, my_args, sizeof(args));
1028        if (args.depth > 0) {
1029                if (stat(git_path("shallow"), &st))
1030                        st.st_mtime = 0;
1031        }
1032
1033        if (heads && nr_heads)
1034                nr_heads = remove_duplicates(nr_heads, heads);
1035        if (!ref) {
1036                packet_flush(fd[1]);
1037                die("no matching remote head");
1038        }
1039        ref_cpy = do_fetch_pack(fd, ref, nr_heads, heads, pack_lockfile);
1040
1041        if (args.depth > 0) {
1042                struct cache_time mtime;
1043                struct strbuf sb = STRBUF_INIT;
1044                char *shallow = git_path("shallow");
1045                int fd;
1046
1047                mtime.sec = st.st_mtime;
1048                mtime.nsec = ST_MTIME_NSEC(st);
1049                if (stat(shallow, &st)) {
1050                        if (mtime.sec)
1051                                die("shallow file was removed during fetch");
1052                } else if (st.st_mtime != mtime.sec
1053#ifdef USE_NSEC
1054                                || ST_MTIME_NSEC(st) != mtime.nsec
1055#endif
1056                          )
1057                        die("shallow file was changed during fetch");
1058
1059                fd = hold_lock_file_for_update(&lock, shallow,
1060                                               LOCK_DIE_ON_ERROR);
1061                if (!write_shallow_commits(&sb, 0)
1062                 || write_in_full(fd, sb.buf, sb.len) != sb.len) {
1063                        unlink_or_warn(shallow);
1064                        rollback_lock_file(&lock);
1065                } else {
1066                        commit_lock_file(&lock);
1067                }
1068                strbuf_release(&sb);
1069        }
1070
1071        reprepare_packed_git();
1072        return ref_cpy;
1073}