Andrew's git / gitweb.git / fetch-pack.c
?
fetch-pack.con commit reflog: use parse_config_key in config callback (b3873c3)
   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                o = parse_object(ref->old_sha1);
 598                if (!o)
 599                        continue;
 600
 601                /* We already have it -- which may mean that we were
 602                 * in sync with the other side at some time after
 603                 * that (it is OK if we guess wrong here).
 604                 */
 605                if (o->type == OBJ_COMMIT) {
 606                        struct commit *commit = (struct commit *)o;
 607                        if (!cutoff || cutoff < commit->date)
 608                                cutoff = commit->date;
 609                }
 610        }
 611
 612        if (!args->depth) {
 613                for_each_ref(mark_complete, NULL);
 614                for_each_alternate_ref(mark_alternate_complete, NULL);
 615                if (cutoff)
 616                        mark_recent_complete_commits(args, cutoff);
 617        }
 618
 619        /*
 620         * Mark all complete remote refs as common refs.
 621         * Don't mark them common yet; the server has to be told so first.
 622         */
 623        for (ref = *refs; ref; ref = ref->next) {
 624                struct object *o = deref_tag(lookup_object(ref->old_sha1),
 625                                             NULL, 0);
 626
 627                if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
 628                        continue;
 629
 630                if (!(o->flags & SEEN)) {
 631                        rev_list_push((struct commit *)o, COMMON_REF | SEEN);
 632
 633                        mark_common((struct commit *)o, 1, 1);
 634                }
 635        }
 636
 637        filter_refs(args, refs, sought);
 638
 639        for (retval = 1, ref = *refs; ref ; ref = ref->next) {
 640                const unsigned char *remote = ref->old_sha1;
 641                unsigned char local[20];
 642                struct object *o;
 643
 644                o = lookup_object(remote);
 645                if (!o || !(o->flags & COMPLETE)) {
 646                        retval = 0;
 647                        if (!args->verbose)
 648                                continue;
 649                        fprintf(stderr,
 650                                "want %s (%s)\n", sha1_to_hex(remote),
 651                                ref->name);
 652                        continue;
 653                }
 654
 655                hashcpy(ref->new_sha1, local);
 656                if (!args->verbose)
 657                        continue;
 658                fprintf(stderr,
 659                        "already have %s (%s)\n", sha1_to_hex(remote),
 660                        ref->name);
 661        }
 662        return retval;
 663}
 664
 665static int sideband_demux(int in, int out, void *data)
 666{
 667        int *xd = data;
 668
 669        int ret = recv_sideband("fetch-pack", xd[0], out);
 670        close(out);
 671        return ret;
 672}
 673
 674static int get_pack(struct fetch_pack_args *args,
 675                    int xd[2], char **pack_lockfile)
 676{
 677        struct async demux;
 678        const char *argv[20];
 679        char keep_arg[256];
 680        char hdr_arg[256];
 681        const char **av;
 682        int do_keep = args->keep_pack;
 683        struct child_process cmd;
 684
 685        memset(&demux, 0, sizeof(demux));
 686        if (use_sideband) {
 687                /* xd[] is talking with upload-pack; subprocess reads from
 688                 * xd[0], spits out band#2 to stderr, and feeds us band#1
 689                 * through demux->out.
 690                 */
 691                demux.proc = sideband_demux;
 692                demux.data = xd;
 693                demux.out = -1;
 694                if (start_async(&demux))
 695                        die("fetch-pack: unable to fork off sideband"
 696                            " demultiplexer");
 697        }
 698        else
 699                demux.out = xd[0];
 700
 701        memset(&cmd, 0, sizeof(cmd));
 702        cmd.argv = argv;
 703        av = argv;
 704        *hdr_arg = 0;
 705        if (!args->keep_pack && unpack_limit) {
 706                struct pack_header header;
 707
 708                if (read_pack_header(demux.out, &header))
 709                        die("protocol error: bad pack header");
 710                snprintf(hdr_arg, sizeof(hdr_arg),
 711                         "--pack_header=%"PRIu32",%"PRIu32,
 712                         ntohl(header.hdr_version), ntohl(header.hdr_entries));
 713                if (ntohl(header.hdr_entries) < unpack_limit)
 714                        do_keep = 0;
 715                else
 716                        do_keep = 1;
 717        }
 718
 719        if (do_keep) {
 720                if (pack_lockfile)
 721                        cmd.out = -1;
 722                *av++ = "index-pack";
 723                *av++ = "--stdin";
 724                if (!args->quiet && !args->no_progress)
 725                        *av++ = "-v";
 726                if (args->use_thin_pack)
 727                        *av++ = "--fix-thin";
 728                if (args->lock_pack || unpack_limit) {
 729                        int s = sprintf(keep_arg,
 730                                        "--keep=fetch-pack %"PRIuMAX " on ", (uintmax_t) getpid());
 731                        if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 732                                strcpy(keep_arg + s, "localhost");
 733                        *av++ = keep_arg;
 734                }
 735        }
 736        else {
 737                *av++ = "unpack-objects";
 738                if (args->quiet || args->no_progress)
 739                        *av++ = "-q";
 740        }
 741        if (*hdr_arg)
 742                *av++ = hdr_arg;
 743        if (fetch_fsck_objects >= 0
 744            ? fetch_fsck_objects
 745            : transfer_fsck_objects >= 0
 746            ? transfer_fsck_objects
 747            : 0)
 748                *av++ = "--strict";
 749        *av++ = NULL;
 750
 751        cmd.in = demux.out;
 752        cmd.git_cmd = 1;
 753        if (start_command(&cmd))
 754                die("fetch-pack: unable to fork off %s", argv[0]);
 755        if (do_keep && pack_lockfile) {
 756                *pack_lockfile = index_pack_lockfile(cmd.out);
 757                close(cmd.out);
 758        }
 759
 760        if (finish_command(&cmd))
 761                die("%s failed", argv[0]);
 762        if (use_sideband && finish_async(&demux))
 763                die("error in sideband demultiplexer");
 764        return 0;
 765}
 766
 767static struct ref *do_fetch_pack(struct fetch_pack_args *args,
 768                                 int fd[2],
 769                                 const struct ref *orig_ref,
 770                                 struct string_list *sought,
 771                                 char **pack_lockfile)
 772{
 773        struct ref *ref = copy_ref_list(orig_ref);
 774        unsigned char sha1[20];
 775        const char *agent_feature;
 776        int agent_len;
 777
 778        sort_ref_list(&ref, ref_compare_name);
 779
 780        if (is_repository_shallow() && !server_supports("shallow"))
 781                die("Server does not support shallow clients");
 782        if (server_supports("multi_ack_detailed")) {
 783                if (args->verbose)
 784                        fprintf(stderr, "Server supports multi_ack_detailed\n");
 785                multi_ack = 2;
 786                if (server_supports("no-done")) {
 787                        if (args->verbose)
 788                                fprintf(stderr, "Server supports no-done\n");
 789                        if (args->stateless_rpc)
 790                                no_done = 1;
 791                }
 792        }
 793        else if (server_supports("multi_ack")) {
 794                if (args->verbose)
 795                        fprintf(stderr, "Server supports multi_ack\n");
 796                multi_ack = 1;
 797        }
 798        if (server_supports("side-band-64k")) {
 799                if (args->verbose)
 800                        fprintf(stderr, "Server supports side-band-64k\n");
 801                use_sideband = 2;
 802        }
 803        else if (server_supports("side-band")) {
 804                if (args->verbose)
 805                        fprintf(stderr, "Server supports side-band\n");
 806                use_sideband = 1;
 807        }
 808        if (!server_supports("thin-pack"))
 809                args->use_thin_pack = 0;
 810        if (!server_supports("no-progress"))
 811                args->no_progress = 0;
 812        if (!server_supports("include-tag"))
 813                args->include_tag = 0;
 814        if (server_supports("ofs-delta")) {
 815                if (args->verbose)
 816                        fprintf(stderr, "Server supports ofs-delta\n");
 817        } else
 818                prefer_ofs_delta = 0;
 819
 820        if ((agent_feature = server_feature_value("agent", &agent_len))) {
 821                agent_supported = 1;
 822                if (args->verbose && agent_len)
 823                        fprintf(stderr, "Server version is %.*s\n",
 824                                agent_len, agent_feature);
 825        }
 826
 827        if (everything_local(args, &ref, sought)) {
 828                packet_flush(fd[1]);
 829                goto all_done;
 830        }
 831        if (find_common(args, fd, sha1, ref) < 0)
 832                if (!args->keep_pack)
 833                        /* When cloning, it is not unusual to have
 834                         * no common commit.
 835                         */
 836                        warning("no common commits");
 837
 838        if (args->stateless_rpc)
 839                packet_flush(fd[1]);
 840        if (get_pack(args, fd, pack_lockfile))
 841                die("git fetch-pack: fetch failed.");
 842
 843 all_done:
 844        return ref;
 845}
 846
 847static int fetch_pack_config(const char *var, const char *value, void *cb)
 848{
 849        if (strcmp(var, "fetch.unpacklimit") == 0) {
 850                fetch_unpack_limit = git_config_int(var, value);
 851                return 0;
 852        }
 853
 854        if (strcmp(var, "transfer.unpacklimit") == 0) {
 855                transfer_unpack_limit = git_config_int(var, value);
 856                return 0;
 857        }
 858
 859        if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
 860                prefer_ofs_delta = git_config_bool(var, value);
 861                return 0;
 862        }
 863
 864        if (!strcmp(var, "fetch.fsckobjects")) {
 865                fetch_fsck_objects = git_config_bool(var, value);
 866                return 0;
 867        }
 868
 869        if (!strcmp(var, "transfer.fsckobjects")) {
 870                transfer_fsck_objects = git_config_bool(var, value);
 871                return 0;
 872        }
 873
 874        return git_default_config(var, value, cb);
 875}
 876
 877static void fetch_pack_setup(void)
 878{
 879        static int did_setup;
 880        if (did_setup)
 881                return;
 882        git_config(fetch_pack_config, NULL);
 883        if (0 <= transfer_unpack_limit)
 884                unpack_limit = transfer_unpack_limit;
 885        else if (0 <= fetch_unpack_limit)
 886                unpack_limit = fetch_unpack_limit;
 887        did_setup = 1;
 888}
 889
 890struct ref *fetch_pack(struct fetch_pack_args *args,
 891                       int fd[], struct child_process *conn,
 892                       const struct ref *ref,
 893                       const char *dest,
 894                       struct string_list *sought,
 895                       char **pack_lockfile)
 896{
 897        struct stat st;
 898        struct ref *ref_cpy;
 899
 900        fetch_pack_setup();
 901        if (args->depth > 0) {
 902                if (stat(git_path("shallow"), &st))
 903                        st.st_mtime = 0;
 904        }
 905
 906        if (sought->nr) {
 907                sort_string_list(sought);
 908                string_list_remove_duplicates(sought, 0);
 909        }
 910
 911        if (!ref) {
 912                packet_flush(fd[1]);
 913                die("no matching remote head");
 914        }
 915        ref_cpy = do_fetch_pack(args, fd, ref, sought, pack_lockfile);
 916
 917        if (args->depth > 0) {
 918                static struct lock_file lock;
 919                struct cache_time mtime;
 920                struct strbuf sb = STRBUF_INIT;
 921                char *shallow = git_path("shallow");
 922                int fd;
 923
 924                mtime.sec = st.st_mtime;
 925                mtime.nsec = ST_MTIME_NSEC(st);
 926                if (stat(shallow, &st)) {
 927                        if (mtime.sec)
 928                                die("shallow file was removed during fetch");
 929                } else if (st.st_mtime != mtime.sec
 930#ifdef USE_NSEC
 931                                || ST_MTIME_NSEC(st) != mtime.nsec
 932#endif
 933                          )
 934                        die("shallow file was changed during fetch");
 935
 936                fd = hold_lock_file_for_update(&lock, shallow,
 937                                               LOCK_DIE_ON_ERROR);
 938                if (!write_shallow_commits(&sb, 0)
 939                 || write_in_full(fd, sb.buf, sb.len) != sb.len) {
 940                        unlink_or_warn(shallow);
 941                        rollback_lock_file(&lock);
 942                } else {
 943                        commit_lock_file(&lock);
 944                }
 945                strbuf_release(&sb);
 946        }
 947
 948        reprepare_packed_git();
 949        return ref_cpy;
 950}