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