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