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