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