Andrew's git / gitweb.git / fetch-pack.c
?
fetch-pack.con commit pkt-line: move a misplaced comment (e148542)
   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#include "transport.h"
  13#include "version.h"
  14
  15static int transfer_unpack_limit = -1;
  16static int fetch_unpack_limit = -1;
  17static int unpack_limit = 100;
  18static int prefer_ofs_delta = 1;
  19static int no_done;
  20static int fetch_fsck_objects = -1;
  21static int transfer_fsck_objects = -1;
  22static int agent_supported;
  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                commit_list_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 *refname, const unsigned char *sha1, int flag, void *cb_data)
  58{
  59        struct object *o = deref_tag(parse_object(sha1), refname, 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 *refname, const unsigned char *sha1, int flag, void *cb_data)
  68{
  69        struct object *o = deref_tag(parse_object(sha1), refname, 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(struct fetch_pack_args *args, 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
 186struct write_shallow_data {
 187        struct strbuf *out;
 188        int use_pack_protocol;
 189        int count;
 190};
 191
 192static int write_one_shallow(const struct commit_graft *graft, void *cb_data)
 193{
 194        struct write_shallow_data *data = cb_data;
 195        const char *hex = sha1_to_hex(graft->sha1);
 196        data->count++;
 197        if (data->use_pack_protocol)
 198                packet_buf_write(data->out, "shallow %s", hex);
 199        else {
 200                strbuf_addstr(data->out, hex);
 201                strbuf_addch(data->out, '\n');
 202        }
 203        return 0;
 204}
 205
 206static int write_shallow_commits(struct strbuf *out, int use_pack_protocol)
 207{
 208        struct write_shallow_data data;
 209        data.out = out;
 210        data.use_pack_protocol = use_pack_protocol;
 211        data.count = 0;
 212        for_each_commit_graft(write_one_shallow, &data);
 213        return data.count;
 214}
 215
 216static enum ack_type get_ack(int fd, unsigned char *result_sha1)
 217{
 218        static char line[1000];
 219        int len = packet_read_line(fd, line, sizeof(line));
 220
 221        if (!len)
 222                die("git fetch-pack: expected ACK/NAK, got EOF");
 223        if (line[len-1] == '\n')
 224                line[--len] = 0;
 225        if (!strcmp(line, "NAK"))
 226                return NAK;
 227        if (!prefixcmp(line, "ACK ")) {
 228                if (!get_sha1_hex(line+4, result_sha1)) {
 229                        if (len < 45)
 230                                return ACK;
 231                        if (strstr(line+45, "continue"))
 232                                return ACK_continue;
 233                        if (strstr(line+45, "common"))
 234                                return ACK_common;
 235                        if (strstr(line+45, "ready"))
 236                                return ACK_ready;
 237                        return ACK;
 238                }
 239        }
 240        die("git fetch_pack: expected ACK/NAK, got '%s'", line);
 241}
 242
 243static void send_request(struct fetch_pack_args *args,
 244                         int fd, struct strbuf *buf)
 245{
 246        if (args->stateless_rpc) {
 247                send_sideband(fd, -1, buf->buf, buf->len, LARGE_PACKET_MAX);
 248                packet_flush(fd);
 249        } else
 250                safe_write(fd, buf->buf, buf->len);
 251}
 252
 253static void insert_one_alternate_ref(const struct ref *ref, void *unused)
 254{
 255        rev_list_insert_ref(NULL, ref->old_sha1, 0, NULL);
 256}
 257
 258#define INITIAL_FLUSH 16
 259#define PIPESAFE_FLUSH 32
 260#define LARGE_FLUSH 1024
 261
 262static int next_flush(struct fetch_pack_args *args, int count)
 263{
 264        int flush_limit = args->stateless_rpc ? LARGE_FLUSH : PIPESAFE_FLUSH;
 265
 266        if (count < flush_limit)
 267                count <<= 1;
 268        else
 269                count += flush_limit;
 270        return count;
 271}
 272
 273static int find_common(struct fetch_pack_args *args,
 274                       int fd[2], unsigned char *result_sha1,
 275                       struct ref *refs)
 276{
 277        int fetching;
 278        int count = 0, flushes = 0, flush_at = INITIAL_FLUSH, retval;
 279        const unsigned char *sha1;
 280        unsigned in_vain = 0;
 281        int got_continue = 0;
 282        int got_ready = 0;
 283        struct strbuf req_buf = STRBUF_INIT;
 284        size_t state_len = 0;
 285
 286        if (args->stateless_rpc && multi_ack == 1)
 287                die("--stateless-rpc requires multi_ack_detailed");
 288        if (marked)
 289                for_each_ref(clear_marks, NULL);
 290        marked = 1;
 291
 292        for_each_ref(rev_list_insert_ref, NULL);
 293        for_each_alternate_ref(insert_one_alternate_ref, NULL);
 294
 295        fetching = 0;
 296        for ( ; refs ; refs = refs->next) {
 297                unsigned char *remote = refs->old_sha1;
 298                const char *remote_hex;
 299                struct object *o;
 300
 301                /*
 302                 * If that object is complete (i.e. it is an ancestor of a
 303                 * local ref), we tell them we have it but do not have to
 304                 * tell them about its ancestors, which they already know
 305                 * about.
 306                 *
 307                 * We use lookup_object here because we are only
 308                 * interested in the case we *know* the object is
 309                 * reachable and we have already scanned it.
 310                 */
 311                if (((o = lookup_object(remote)) != NULL) &&
 312                                (o->flags & COMPLETE)) {
 313                        continue;
 314                }
 315
 316                remote_hex = sha1_to_hex(remote);
 317                if (!fetching) {
 318                        struct strbuf c = STRBUF_INIT;
 319                        if (multi_ack == 2)     strbuf_addstr(&c, " multi_ack_detailed");
 320                        if (multi_ack == 1)     strbuf_addstr(&c, " multi_ack");
 321                        if (no_done)            strbuf_addstr(&c, " no-done");
 322                        if (use_sideband == 2)  strbuf_addstr(&c, " side-band-64k");
 323                        if (use_sideband == 1)  strbuf_addstr(&c, " side-band");
 324                        if (args->use_thin_pack) strbuf_addstr(&c, " thin-pack");
 325                        if (args->no_progress)   strbuf_addstr(&c, " no-progress");
 326                        if (args->include_tag)   strbuf_addstr(&c, " include-tag");
 327                        if (prefer_ofs_delta)   strbuf_addstr(&c, " ofs-delta");
 328                        if (agent_supported)    strbuf_addf(&c, " agent=%s",
 329                                                            git_user_agent_sanitized());
 330                        packet_buf_write(&req_buf, "want %s%s\n", remote_hex, c.buf);
 331                        strbuf_release(&c);
 332                } else
 333                        packet_buf_write(&req_buf, "want %s\n", remote_hex);
 334                fetching++;
 335        }
 336
 337        if (!fetching) {
 338                strbuf_release(&req_buf);
 339                packet_flush(fd[1]);
 340                return 1;
 341        }
 342
 343        if (is_repository_shallow())
 344                write_shallow_commits(&req_buf, 1);
 345        if (args->depth > 0)
 346                packet_buf_write(&req_buf, "deepen %d", args->depth);
 347        packet_buf_flush(&req_buf);
 348        state_len = req_buf.len;
 349
 350        if (args->depth > 0) {
 351                char line[1024];
 352                unsigned char sha1[20];
 353
 354                send_request(args, fd[1], &req_buf);
 355                while (packet_read_line(fd[0], line, sizeof(line))) {
 356                        if (!prefixcmp(line, "shallow ")) {
 357                                if (get_sha1_hex(line + 8, sha1))
 358                                        die("invalid shallow line: %s", line);
 359                                register_shallow(sha1);
 360                                continue;
 361                        }
 362                        if (!prefixcmp(line, "unshallow ")) {
 363                                if (get_sha1_hex(line + 10, sha1))
 364                                        die("invalid unshallow line: %s", line);
 365                                if (!lookup_object(sha1))
 366                                        die("object not found: %s", line);
 367                                /* make sure that it is parsed as shallow */
 368                                if (!parse_object(sha1))
 369                                        die("error in object: %s", line);
 370                                if (unregister_shallow(sha1))
 371                                        die("no shallow found: %s", line);
 372                                continue;
 373                        }
 374                        die("expected shallow/unshallow, got %s", line);
 375                }
 376        } else if (!args->stateless_rpc)
 377                send_request(args, fd[1], &req_buf);
 378
 379        if (!args->stateless_rpc) {
 380                /* If we aren't using the stateless-rpc interface
 381                 * we don't need to retain the headers.
 382                 */
 383                strbuf_setlen(&req_buf, 0);
 384                state_len = 0;
 385        }
 386
 387        flushes = 0;
 388        retval = -1;
 389        while ((sha1 = get_rev())) {
 390                packet_buf_write(&req_buf, "have %s\n", sha1_to_hex(sha1));
 391                if (args->verbose)
 392                        fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
 393                in_vain++;
 394                if (flush_at <= ++count) {
 395                        int ack;
 396
 397                        packet_buf_flush(&req_buf);
 398                        send_request(args, fd[1], &req_buf);
 399                        strbuf_setlen(&req_buf, state_len);
 400                        flushes++;
 401                        flush_at = next_flush(args, count);
 402
 403                        /*
 404                         * We keep one window "ahead" of the other side, and
 405                         * will wait for an ACK only on the next one
 406                         */
 407                        if (!args->stateless_rpc && count == INITIAL_FLUSH)
 408                                continue;
 409
 410                        consume_shallow_list(args, fd[0]);
 411                        do {
 412                                ack = get_ack(fd[0], result_sha1);
 413                                if (args->verbose && ack)
 414                                        fprintf(stderr, "got ack %d %s\n", ack,
 415                                                        sha1_to_hex(result_sha1));
 416                                switch (ack) {
 417                                case ACK:
 418                                        flushes = 0;
 419                                        multi_ack = 0;
 420                                        retval = 0;
 421                                        goto done;
 422                                case ACK_common:
 423                                case ACK_ready:
 424                                case ACK_continue: {
 425                                        struct commit *commit =
 426                                                lookup_commit(result_sha1);
 427                                        if (!commit)
 428                                                die("invalid commit %s", sha1_to_hex(result_sha1));
 429                                        if (args->stateless_rpc
 430                                         && ack == ACK_common
 431                                         && !(commit->object.flags & COMMON)) {
 432                                                /* We need to replay the have for this object
 433                                                 * on the next RPC request so the peer knows
 434                                                 * it is in common with us.
 435                                                 */
 436                                                const char *hex = sha1_to_hex(result_sha1);
 437                                                packet_buf_write(&req_buf, "have %s\n", hex);
 438                                                state_len = req_buf.len;
 439                                        }
 440                                        mark_common(commit, 0, 1);
 441                                        retval = 0;
 442                                        in_vain = 0;
 443                                        got_continue = 1;
 444                                        if (ack == ACK_ready) {
 445                                                rev_list = NULL;
 446                                                got_ready = 1;
 447                                        }
 448                                        break;
 449                                        }
 450                                }
 451                        } while (ack);
 452                        flushes--;
 453                        if (got_continue && MAX_IN_VAIN < in_vain) {
 454                                if (args->verbose)
 455                                        fprintf(stderr, "giving up\n");
 456                                break; /* give up */
 457                        }
 458                }
 459        }
 460done:
 461        if (!got_ready || !no_done) {
 462                packet_buf_write(&req_buf, "done\n");
 463                send_request(args, fd[1], &req_buf);
 464        }
 465        if (args->verbose)
 466                fprintf(stderr, "done\n");
 467        if (retval != 0) {
 468                multi_ack = 0;
 469                flushes++;
 470        }
 471        strbuf_release(&req_buf);
 472
 473        consume_shallow_list(args, fd[0]);
 474        while (flushes || multi_ack) {
 475                int ack = get_ack(fd[0], result_sha1);
 476                if (ack) {
 477                        if (args->verbose)
 478                                fprintf(stderr, "got ack (%d) %s\n", ack,
 479                                        sha1_to_hex(result_sha1));
 480                        if (ack == ACK)
 481                                return 0;
 482                        multi_ack = 1;
 483                        continue;
 484                }
 485                flushes--;
 486        }
 487        /* it is no error to fetch into a completely empty repo */
 488        return count ? retval : 0;
 489}
 490
 491static struct commit_list *complete;
 492
 493static int mark_complete(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
 494{
 495        struct object *o = parse_object(sha1);
 496
 497        while (o && o->type == OBJ_TAG) {
 498                struct tag *t = (struct tag *) o;
 499                if (!t->tagged)
 500                        break; /* broken repository */
 501                o->flags |= COMPLETE;
 502                o = parse_object(t->tagged->sha1);
 503        }
 504        if (o && o->type == OBJ_COMMIT) {
 505                struct commit *commit = (struct commit *)o;
 506                if (!(commit->object.flags & COMPLETE)) {
 507                        commit->object.flags |= COMPLETE;
 508                        commit_list_insert_by_date(commit, &complete);
 509                }
 510        }
 511        return 0;
 512}
 513
 514static void mark_recent_complete_commits(struct fetch_pack_args *args,
 515                                         unsigned long cutoff)
 516{
 517        while (complete && cutoff <= complete->item->date) {
 518                if (args->verbose)
 519                        fprintf(stderr, "Marking %s as complete\n",
 520                                sha1_to_hex(complete->item->object.sha1));
 521                pop_most_recent_commit(&complete, COMPLETE);
 522        }
 523}
 524
 525static int non_matching_ref(struct string_list_item *item, void *unused)
 526{
 527        if (item->util) {
 528                item->util = NULL;
 529                return 0;
 530        }
 531        else
 532                return 1;
 533}
 534
 535static void filter_refs(struct fetch_pack_args *args,
 536                        struct ref **refs, struct string_list *sought)
 537{
 538        struct ref *newlist = NULL;
 539        struct ref **newtail = &newlist;
 540        struct ref *ref, *next;
 541        int sought_pos;
 542
 543        sought_pos = 0;
 544        for (ref = *refs; ref; ref = next) {
 545                int keep = 0;
 546                next = ref->next;
 547                if (!memcmp(ref->name, "refs/", 5) &&
 548                    check_refname_format(ref->name + 5, 0))
 549                        ; /* trash */
 550                else {
 551                        while (sought_pos < sought->nr) {
 552                                int cmp = strcmp(ref->name, sought->items[sought_pos].string);
 553                                if (cmp < 0)
 554                                        break; /* definitely do not have it */
 555                                else if (cmp == 0) {
 556                                        keep = 1; /* definitely have it */
 557                                        sought->items[sought_pos++].util = "matched";
 558                                        break;
 559                                }
 560                                else
 561                                        sought_pos++; /* might have it; keep looking */
 562                        }
 563                }
 564
 565                if (! keep && args->fetch_all &&
 566                    (!args->depth || prefixcmp(ref->name, "refs/tags/")))
 567                        keep = 1;
 568
 569                if (keep) {
 570                        *newtail = ref;
 571                        ref->next = NULL;
 572                        newtail = &ref->next;
 573                } else {
 574                        free(ref);
 575                }
 576        }
 577
 578        filter_string_list(sought, 0, non_matching_ref, NULL);
 579        *refs = newlist;
 580}
 581
 582static void mark_alternate_complete(const struct ref *ref, void *unused)
 583{
 584        mark_complete(NULL, ref->old_sha1, 0, NULL);
 585}
 586
 587static int everything_local(struct fetch_pack_args *args,
 588                            struct ref **refs, struct string_list *sought)
 589{
 590        struct ref *ref;
 591        int retval;
 592        unsigned long cutoff = 0;
 593
 594        save_commit_buffer = 0;
 595
 596        for (ref = *refs; ref; ref = ref->next) {
 597                struct object *o;
 598
 599                if (!has_sha1_file(ref->old_sha1))
 600                        continue;
 601
 602                o = parse_object(ref->old_sha1);
 603                if (!o)
 604                        continue;
 605
 606                /* We already have it -- which may mean that we were
 607                 * in sync with the other side at some time after
 608                 * that (it is OK if we guess wrong here).
 609                 */
 610                if (o->type == OBJ_COMMIT) {
 611                        struct commit *commit = (struct commit *)o;
 612                        if (!cutoff || cutoff < commit->date)
 613                                cutoff = commit->date;
 614                }
 615        }
 616
 617        if (!args->depth) {
 618                for_each_ref(mark_complete, NULL);
 619                for_each_alternate_ref(mark_alternate_complete, NULL);
 620                if (cutoff)
 621                        mark_recent_complete_commits(args, cutoff);
 622        }
 623
 624        /*
 625         * Mark all complete remote refs as common refs.
 626         * Don't mark them common yet; the server has to be told so first.
 627         */
 628        for (ref = *refs; ref; ref = ref->next) {
 629                struct object *o = deref_tag(lookup_object(ref->old_sha1),
 630                                             NULL, 0);
 631
 632                if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
 633                        continue;
 634
 635                if (!(o->flags & SEEN)) {
 636                        rev_list_push((struct commit *)o, COMMON_REF | SEEN);
 637
 638                        mark_common((struct commit *)o, 1, 1);
 639                }
 640        }
 641
 642        filter_refs(args, refs, sought);
 643
 644        for (retval = 1, ref = *refs; ref ; ref = ref->next) {
 645                const unsigned char *remote = ref->old_sha1;
 646                unsigned char local[20];
 647                struct object *o;
 648
 649                o = lookup_object(remote);
 650                if (!o || !(o->flags & COMPLETE)) {
 651                        retval = 0;
 652                        if (!args->verbose)
 653                                continue;
 654                        fprintf(stderr,
 655                                "want %s (%s)\n", sha1_to_hex(remote),
 656                                ref->name);
 657                        continue;
 658                }
 659
 660                hashcpy(ref->new_sha1, local);
 661                if (!args->verbose)
 662                        continue;
 663                fprintf(stderr,
 664                        "already have %s (%s)\n", sha1_to_hex(remote),
 665                        ref->name);
 666        }
 667        return retval;
 668}
 669
 670static int sideband_demux(int in, int out, void *data)
 671{
 672        int *xd = data;
 673
 674        int ret = recv_sideband("fetch-pack", xd[0], out);
 675        close(out);
 676        return ret;
 677}
 678
 679static int get_pack(struct fetch_pack_args *args,
 680                    int xd[2], char **pack_lockfile)
 681{
 682        struct async demux;
 683        const char *argv[20];
 684        char keep_arg[256];
 685        char hdr_arg[256];
 686        const char **av;
 687        int do_keep = args->keep_pack;
 688        struct child_process cmd;
 689
 690        memset(&demux, 0, sizeof(demux));
 691        if (use_sideband) {
 692                /* xd[] is talking with upload-pack; subprocess reads from
 693                 * xd[0], spits out band#2 to stderr, and feeds us band#1
 694                 * through demux->out.
 695                 */
 696                demux.proc = sideband_demux;
 697                demux.data = xd;
 698                demux.out = -1;
 699                if (start_async(&demux))
 700                        die("fetch-pack: unable to fork off sideband"
 701                            " demultiplexer");
 702        }
 703        else
 704                demux.out = xd[0];
 705
 706        memset(&cmd, 0, sizeof(cmd));
 707        cmd.argv = argv;
 708        av = argv;
 709        *hdr_arg = 0;
 710        if (!args->keep_pack && unpack_limit) {
 711                struct pack_header header;
 712
 713                if (read_pack_header(demux.out, &header))
 714                        die("protocol error: bad pack header");
 715                snprintf(hdr_arg, sizeof(hdr_arg),
 716                         "--pack_header=%"PRIu32",%"PRIu32,
 717                         ntohl(header.hdr_version), ntohl(header.hdr_entries));
 718                if (ntohl(header.hdr_entries) < unpack_limit)
 719                        do_keep = 0;
 720                else
 721                        do_keep = 1;
 722        }
 723
 724        if (do_keep) {
 725                if (pack_lockfile)
 726                        cmd.out = -1;
 727                *av++ = "index-pack";
 728                *av++ = "--stdin";
 729                if (!args->quiet && !args->no_progress)
 730                        *av++ = "-v";
 731                if (args->use_thin_pack)
 732                        *av++ = "--fix-thin";
 733                if (args->lock_pack || unpack_limit) {
 734                        int s = sprintf(keep_arg,
 735                                        "--keep=fetch-pack %"PRIuMAX " on ", (uintmax_t) getpid());
 736                        if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 737                                strcpy(keep_arg + s, "localhost");
 738                        *av++ = keep_arg;
 739                }
 740        }
 741        else {
 742                *av++ = "unpack-objects";
 743                if (args->quiet || args->no_progress)
 744                        *av++ = "-q";
 745        }
 746        if (*hdr_arg)
 747                *av++ = hdr_arg;
 748        if (fetch_fsck_objects >= 0
 749            ? fetch_fsck_objects
 750            : transfer_fsck_objects >= 0
 751            ? transfer_fsck_objects
 752            : 0)
 753                *av++ = "--strict";
 754        *av++ = NULL;
 755
 756        cmd.in = demux.out;
 757        cmd.git_cmd = 1;
 758        if (start_command(&cmd))
 759                die("fetch-pack: unable to fork off %s", argv[0]);
 760        if (do_keep && pack_lockfile) {
 761                *pack_lockfile = index_pack_lockfile(cmd.out);
 762                close(cmd.out);
 763        }
 764
 765        if (finish_command(&cmd))
 766                die("%s failed", argv[0]);
 767        if (use_sideband && finish_async(&demux))
 768                die("error in sideband demultiplexer");
 769        return 0;
 770}
 771
 772static struct ref *do_fetch_pack(struct fetch_pack_args *args,
 773                                 int fd[2],
 774                                 const struct ref *orig_ref,
 775                                 struct string_list *sought,
 776                                 char **pack_lockfile)
 777{
 778        struct ref *ref = copy_ref_list(orig_ref);
 779        unsigned char sha1[20];
 780        const char *agent_feature;
 781        int agent_len;
 782
 783        sort_ref_list(&ref, ref_compare_name);
 784
 785        if (is_repository_shallow() && !server_supports("shallow"))
 786                die("Server does not support shallow clients");
 787        if (server_supports("multi_ack_detailed")) {
 788                if (args->verbose)
 789                        fprintf(stderr, "Server supports multi_ack_detailed\n");
 790                multi_ack = 2;
 791                if (server_supports("no-done")) {
 792                        if (args->verbose)
 793                                fprintf(stderr, "Server supports no-done\n");
 794                        if (args->stateless_rpc)
 795                                no_done = 1;
 796                }
 797        }
 798        else if (server_supports("multi_ack")) {
 799                if (args->verbose)
 800                        fprintf(stderr, "Server supports multi_ack\n");
 801                multi_ack = 1;
 802        }
 803        if (server_supports("side-band-64k")) {
 804                if (args->verbose)
 805                        fprintf(stderr, "Server supports side-band-64k\n");
 806                use_sideband = 2;
 807        }
 808        else if (server_supports("side-band")) {
 809                if (args->verbose)
 810                        fprintf(stderr, "Server supports side-band\n");
 811                use_sideband = 1;
 812        }
 813        if (!server_supports("thin-pack"))
 814                args->use_thin_pack = 0;
 815        if (!server_supports("no-progress"))
 816                args->no_progress = 0;
 817        if (!server_supports("include-tag"))
 818                args->include_tag = 0;
 819        if (server_supports("ofs-delta")) {
 820                if (args->verbose)
 821                        fprintf(stderr, "Server supports ofs-delta\n");
 822        } else
 823                prefer_ofs_delta = 0;
 824
 825        if ((agent_feature = server_feature_value("agent", &agent_len))) {
 826                agent_supported = 1;
 827                if (args->verbose && agent_len)
 828                        fprintf(stderr, "Server version is %.*s\n",
 829                                agent_len, agent_feature);
 830        }
 831
 832        if (everything_local(args, &ref, sought)) {
 833                packet_flush(fd[1]);
 834                goto all_done;
 835        }
 836        if (find_common(args, fd, sha1, ref) < 0)
 837                if (!args->keep_pack)
 838                        /* When cloning, it is not unusual to have
 839                         * no common commit.
 840                         */
 841                        warning("no common commits");
 842
 843        if (args->stateless_rpc)
 844                packet_flush(fd[1]);
 845        if (get_pack(args, fd, pack_lockfile))
 846                die("git fetch-pack: fetch failed.");
 847
 848 all_done:
 849        return ref;
 850}
 851
 852static int fetch_pack_config(const char *var, const char *value, void *cb)
 853{
 854        if (strcmp(var, "fetch.unpacklimit") == 0) {
 855                fetch_unpack_limit = git_config_int(var, value);
 856                return 0;
 857        }
 858
 859        if (strcmp(var, "transfer.unpacklimit") == 0) {
 860                transfer_unpack_limit = git_config_int(var, value);
 861                return 0;
 862        }
 863
 864        if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
 865                prefer_ofs_delta = git_config_bool(var, value);
 866                return 0;
 867        }
 868
 869        if (!strcmp(var, "fetch.fsckobjects")) {
 870                fetch_fsck_objects = git_config_bool(var, value);
 871                return 0;
 872        }
 873
 874        if (!strcmp(var, "transfer.fsckobjects")) {
 875                transfer_fsck_objects = git_config_bool(var, value);
 876                return 0;
 877        }
 878
 879        return git_default_config(var, value, cb);
 880}
 881
 882static void fetch_pack_setup(void)
 883{
 884        static int did_setup;
 885        if (did_setup)
 886                return;
 887        git_config(fetch_pack_config, NULL);
 888        if (0 <= transfer_unpack_limit)
 889                unpack_limit = transfer_unpack_limit;
 890        else if (0 <= fetch_unpack_limit)
 891                unpack_limit = fetch_unpack_limit;
 892        did_setup = 1;
 893}
 894
 895struct ref *fetch_pack(struct fetch_pack_args *args,
 896                       int fd[], struct child_process *conn,
 897                       const struct ref *ref,
 898                       const char *dest,
 899                       struct string_list *sought,
 900                       char **pack_lockfile)
 901{
 902        struct stat st;
 903        struct ref *ref_cpy;
 904
 905        fetch_pack_setup();
 906        if (args->depth > 0) {
 907                if (stat(git_path("shallow"), &st))
 908                        st.st_mtime = 0;
 909        }
 910
 911        if (sought->nr) {
 912                sort_string_list(sought);
 913                string_list_remove_duplicates(sought, 0);
 914        }
 915
 916        if (!ref) {
 917                packet_flush(fd[1]);
 918                die("no matching remote head");
 919        }
 920        ref_cpy = do_fetch_pack(args, fd, ref, sought, pack_lockfile);
 921
 922        if (args->depth > 0) {
 923                static struct lock_file lock;
 924                struct cache_time mtime;
 925                struct strbuf sb = STRBUF_INIT;
 926                char *shallow = git_path("shallow");
 927                int fd;
 928
 929                mtime.sec = st.st_mtime;
 930                mtime.nsec = ST_MTIME_NSEC(st);
 931                if (stat(shallow, &st)) {
 932                        if (mtime.sec)
 933                                die("shallow file was removed during fetch");
 934                } else if (st.st_mtime != mtime.sec
 935#ifdef USE_NSEC
 936                                || ST_MTIME_NSEC(st) != mtime.nsec
 937#endif
 938                          )
 939                        die("shallow file was changed during fetch");
 940
 941                fd = hold_lock_file_for_update(&lock, shallow,
 942                                               LOCK_DIE_ON_ERROR);
 943                if (!write_shallow_commits(&sb, 0)
 944                 || write_in_full(fd, sb.buf, sb.len) != sb.len) {
 945                        unlink_or_warn(shallow);
 946                        rollback_lock_file(&lock);
 947                } else {
 948                        commit_lock_file(&lock);
 949                }
 950                strbuf_release(&sb);
 951        }
 952
 953        reprepare_packed_git();
 954        return ref_cpy;
 955}