upload-pack.con commit index: make index.threads=true enable ieot and eoie (2a9dede)
   1#include "cache.h"
   2#include "config.h"
   3#include "refs.h"
   4#include "pkt-line.h"
   5#include "sideband.h"
   6#include "repository.h"
   7#include "object-store.h"
   8#include "tag.h"
   9#include "object.h"
  10#include "commit.h"
  11#include "diff.h"
  12#include "revision.h"
  13#include "list-objects.h"
  14#include "list-objects-filter.h"
  15#include "list-objects-filter-options.h"
  16#include "run-command.h"
  17#include "connect.h"
  18#include "sigchain.h"
  19#include "version.h"
  20#include "string-list.h"
  21#include "argv-array.h"
  22#include "prio-queue.h"
  23#include "protocol.h"
  24#include "quote.h"
  25#include "upload-pack.h"
  26#include "serve.h"
  27#include "commit-graph.h"
  28#include "commit-reach.h"
  29
  30/* Remember to update object flag allocation in object.h */
  31#define THEY_HAVE       (1u << 11)
  32#define OUR_REF         (1u << 12)
  33#define WANTED          (1u << 13)
  34#define COMMON_KNOWN    (1u << 14)
  35
  36#define SHALLOW         (1u << 16)
  37#define NOT_SHALLOW     (1u << 17)
  38#define CLIENT_SHALLOW  (1u << 18)
  39#define HIDDEN_REF      (1u << 19)
  40
  41#define ALL_FLAGS (THEY_HAVE | OUR_REF | WANTED | COMMON_KNOWN | SHALLOW | \
  42                NOT_SHALLOW | CLIENT_SHALLOW | HIDDEN_REF)
  43
  44static timestamp_t oldest_have;
  45
  46static int deepen_relative;
  47static int multi_ack;
  48static int no_done;
  49static int use_thin_pack, use_ofs_delta, use_include_tag;
  50static int no_progress, daemon_mode;
  51/* Allow specifying sha1 if it is a ref tip. */
  52#define ALLOW_TIP_SHA1  01
  53/* Allow request of a sha1 if it is reachable from a ref (possibly hidden ref). */
  54#define ALLOW_REACHABLE_SHA1    02
  55/* Allow request of any sha1. Implies ALLOW_TIP_SHA1 and ALLOW_REACHABLE_SHA1. */
  56#define ALLOW_ANY_SHA1  07
  57static unsigned int allow_unadvertised_object_request;
  58static int shallow_nr;
  59static struct object_array extra_edge_obj;
  60static unsigned int timeout;
  61static int keepalive = 5;
  62/* 0 for no sideband,
  63 * otherwise maximum packet size (up to 65520 bytes).
  64 */
  65static int use_sideband;
  66static int stateless_rpc;
  67static const char *pack_objects_hook;
  68
  69static int filter_capability_requested;
  70static int allow_filter;
  71static int allow_ref_in_want;
  72static struct list_objects_filter_options filter_options;
  73
  74static void reset_timeout(void)
  75{
  76        alarm(timeout);
  77}
  78
  79static void send_client_data(int fd, const char *data, ssize_t sz)
  80{
  81        if (use_sideband) {
  82                send_sideband(1, fd, data, sz, use_sideband);
  83                return;
  84        }
  85        if (fd == 3)
  86                /* emergency quit */
  87                fd = 2;
  88        if (fd == 2) {
  89                /* XXX: are we happy to lose stuff here? */
  90                xwrite(fd, data, sz);
  91                return;
  92        }
  93        write_or_die(fd, data, sz);
  94}
  95
  96static int write_one_shallow(const struct commit_graft *graft, void *cb_data)
  97{
  98        FILE *fp = cb_data;
  99        if (graft->nr_parent == -1)
 100                fprintf(fp, "--shallow %s\n", oid_to_hex(&graft->oid));
 101        return 0;
 102}
 103
 104static void create_pack_file(const struct object_array *have_obj,
 105                             const struct object_array *want_obj)
 106{
 107        struct child_process pack_objects = CHILD_PROCESS_INIT;
 108        char data[8193], progress[128];
 109        char abort_msg[] = "aborting due to possible repository "
 110                "corruption on the remote side.";
 111        int buffered = -1;
 112        ssize_t sz;
 113        int i;
 114        FILE *pipe_fd;
 115
 116        if (!pack_objects_hook)
 117                pack_objects.git_cmd = 1;
 118        else {
 119                argv_array_push(&pack_objects.args, pack_objects_hook);
 120                argv_array_push(&pack_objects.args, "git");
 121                pack_objects.use_shell = 1;
 122        }
 123
 124        if (shallow_nr) {
 125                argv_array_push(&pack_objects.args, "--shallow-file");
 126                argv_array_push(&pack_objects.args, "");
 127        }
 128        argv_array_push(&pack_objects.args, "pack-objects");
 129        argv_array_push(&pack_objects.args, "--revs");
 130        if (use_thin_pack)
 131                argv_array_push(&pack_objects.args, "--thin");
 132
 133        argv_array_push(&pack_objects.args, "--stdout");
 134        if (shallow_nr)
 135                argv_array_push(&pack_objects.args, "--shallow");
 136        if (!no_progress)
 137                argv_array_push(&pack_objects.args, "--progress");
 138        if (use_ofs_delta)
 139                argv_array_push(&pack_objects.args, "--delta-base-offset");
 140        if (use_include_tag)
 141                argv_array_push(&pack_objects.args, "--include-tag");
 142        if (filter_options.filter_spec) {
 143                if (pack_objects.use_shell) {
 144                        struct strbuf buf = STRBUF_INIT;
 145                        sq_quote_buf(&buf, filter_options.filter_spec);
 146                        argv_array_pushf(&pack_objects.args, "--filter=%s", buf.buf);
 147                        strbuf_release(&buf);
 148                } else {
 149                        argv_array_pushf(&pack_objects.args, "--filter=%s",
 150                                         filter_options.filter_spec);
 151                }
 152        }
 153
 154        pack_objects.in = -1;
 155        pack_objects.out = -1;
 156        pack_objects.err = -1;
 157
 158        if (start_command(&pack_objects))
 159                die("git upload-pack: unable to fork git-pack-objects");
 160
 161        pipe_fd = xfdopen(pack_objects.in, "w");
 162
 163        if (shallow_nr)
 164                for_each_commit_graft(write_one_shallow, pipe_fd);
 165
 166        for (i = 0; i < want_obj->nr; i++)
 167                fprintf(pipe_fd, "%s\n",
 168                        oid_to_hex(&want_obj->objects[i].item->oid));
 169        fprintf(pipe_fd, "--not\n");
 170        for (i = 0; i < have_obj->nr; i++)
 171                fprintf(pipe_fd, "%s\n",
 172                        oid_to_hex(&have_obj->objects[i].item->oid));
 173        for (i = 0; i < extra_edge_obj.nr; i++)
 174                fprintf(pipe_fd, "%s\n",
 175                        oid_to_hex(&extra_edge_obj.objects[i].item->oid));
 176        fprintf(pipe_fd, "\n");
 177        fflush(pipe_fd);
 178        fclose(pipe_fd);
 179
 180        /* We read from pack_objects.err to capture stderr output for
 181         * progress bar, and pack_objects.out to capture the pack data.
 182         */
 183
 184        while (1) {
 185                struct pollfd pfd[2];
 186                int pe, pu, pollsize;
 187                int ret;
 188
 189                reset_timeout();
 190
 191                pollsize = 0;
 192                pe = pu = -1;
 193
 194                if (0 <= pack_objects.out) {
 195                        pfd[pollsize].fd = pack_objects.out;
 196                        pfd[pollsize].events = POLLIN;
 197                        pu = pollsize;
 198                        pollsize++;
 199                }
 200                if (0 <= pack_objects.err) {
 201                        pfd[pollsize].fd = pack_objects.err;
 202                        pfd[pollsize].events = POLLIN;
 203                        pe = pollsize;
 204                        pollsize++;
 205                }
 206
 207                if (!pollsize)
 208                        break;
 209
 210                ret = poll(pfd, pollsize,
 211                        keepalive < 0 ? -1 : 1000 * keepalive);
 212
 213                if (ret < 0) {
 214                        if (errno != EINTR) {
 215                                error_errno("poll failed, resuming");
 216                                sleep(1);
 217                        }
 218                        continue;
 219                }
 220                if (0 <= pe && (pfd[pe].revents & (POLLIN|POLLHUP))) {
 221                        /* Status ready; we ship that in the side-band
 222                         * or dump to the standard error.
 223                         */
 224                        sz = xread(pack_objects.err, progress,
 225                                  sizeof(progress));
 226                        if (0 < sz)
 227                                send_client_data(2, progress, sz);
 228                        else if (sz == 0) {
 229                                close(pack_objects.err);
 230                                pack_objects.err = -1;
 231                        }
 232                        else
 233                                goto fail;
 234                        /* give priority to status messages */
 235                        continue;
 236                }
 237                if (0 <= pu && (pfd[pu].revents & (POLLIN|POLLHUP))) {
 238                        /* Data ready; we keep the last byte to ourselves
 239                         * in case we detect broken rev-list, so that we
 240                         * can leave the stream corrupted.  This is
 241                         * unfortunate -- unpack-objects would happily
 242                         * accept a valid packdata with trailing garbage,
 243                         * so appending garbage after we pass all the
 244                         * pack data is not good enough to signal
 245                         * breakage to downstream.
 246                         */
 247                        char *cp = data;
 248                        ssize_t outsz = 0;
 249                        if (0 <= buffered) {
 250                                *cp++ = buffered;
 251                                outsz++;
 252                        }
 253                        sz = xread(pack_objects.out, cp,
 254                                  sizeof(data) - outsz);
 255                        if (0 < sz)
 256                                ;
 257                        else if (sz == 0) {
 258                                close(pack_objects.out);
 259                                pack_objects.out = -1;
 260                        }
 261                        else
 262                                goto fail;
 263                        sz += outsz;
 264                        if (1 < sz) {
 265                                buffered = data[sz-1] & 0xFF;
 266                                sz--;
 267                        }
 268                        else
 269                                buffered = -1;
 270                        send_client_data(1, data, sz);
 271                }
 272
 273                /*
 274                 * We hit the keepalive timeout without saying anything; send
 275                 * an empty message on the data sideband just to let the other
 276                 * side know we're still working on it, but don't have any data
 277                 * yet.
 278                 *
 279                 * If we don't have a sideband channel, there's no room in the
 280                 * protocol to say anything, so those clients are just out of
 281                 * luck.
 282                 */
 283                if (!ret && use_sideband) {
 284                        static const char buf[] = "0005\1";
 285                        write_or_die(1, buf, 5);
 286                }
 287        }
 288
 289        if (finish_command(&pack_objects)) {
 290                error("git upload-pack: git-pack-objects died with error.");
 291                goto fail;
 292        }
 293
 294        /* flush the data */
 295        if (0 <= buffered) {
 296                data[0] = buffered;
 297                send_client_data(1, data, 1);
 298                fprintf(stderr, "flushed.\n");
 299        }
 300        if (use_sideband)
 301                packet_flush(1);
 302        return;
 303
 304 fail:
 305        send_client_data(3, abort_msg, sizeof(abort_msg));
 306        die("git upload-pack: %s", abort_msg);
 307}
 308
 309static int got_oid(const char *hex, struct object_id *oid,
 310                   struct object_array *have_obj)
 311{
 312        struct object *o;
 313        int we_knew_they_have = 0;
 314
 315        if (get_oid_hex(hex, oid))
 316                die("git upload-pack: expected SHA1 object, got '%s'", hex);
 317        if (!has_object_file(oid))
 318                return -1;
 319
 320        o = parse_object(the_repository, oid);
 321        if (!o)
 322                die("oops (%s)", oid_to_hex(oid));
 323        if (o->type == OBJ_COMMIT) {
 324                struct commit_list *parents;
 325                struct commit *commit = (struct commit *)o;
 326                if (o->flags & THEY_HAVE)
 327                        we_knew_they_have = 1;
 328                else
 329                        o->flags |= THEY_HAVE;
 330                if (!oldest_have || (commit->date < oldest_have))
 331                        oldest_have = commit->date;
 332                for (parents = commit->parents;
 333                     parents;
 334                     parents = parents->next)
 335                        parents->item->object.flags |= THEY_HAVE;
 336        }
 337        if (!we_knew_they_have) {
 338                add_object_array(o, NULL, have_obj);
 339                return 1;
 340        }
 341        return 0;
 342}
 343
 344static int ok_to_give_up(const struct object_array *have_obj,
 345                         struct object_array *want_obj)
 346{
 347        uint32_t min_generation = GENERATION_NUMBER_ZERO;
 348
 349        if (!have_obj->nr)
 350                return 0;
 351
 352        return can_all_from_reach_with_flag(want_obj, THEY_HAVE,
 353                                            COMMON_KNOWN, oldest_have,
 354                                            min_generation);
 355}
 356
 357static int get_common_commits(struct object_array *have_obj,
 358                              struct object_array *want_obj)
 359{
 360        struct object_id oid;
 361        char last_hex[GIT_MAX_HEXSZ + 1];
 362        int got_common = 0;
 363        int got_other = 0;
 364        int sent_ready = 0;
 365
 366        save_commit_buffer = 0;
 367
 368        for (;;) {
 369                char *line = packet_read_line(0, NULL);
 370                const char *arg;
 371
 372                reset_timeout();
 373
 374                if (!line) {
 375                        if (multi_ack == 2 && got_common
 376                            && !got_other && ok_to_give_up(have_obj, want_obj)) {
 377                                sent_ready = 1;
 378                                packet_write_fmt(1, "ACK %s ready\n", last_hex);
 379                        }
 380                        if (have_obj->nr == 0 || multi_ack)
 381                                packet_write_fmt(1, "NAK\n");
 382
 383                        if (no_done && sent_ready) {
 384                                packet_write_fmt(1, "ACK %s\n", last_hex);
 385                                return 0;
 386                        }
 387                        if (stateless_rpc)
 388                                exit(0);
 389                        got_common = 0;
 390                        got_other = 0;
 391                        continue;
 392                }
 393                if (skip_prefix(line, "have ", &arg)) {
 394                        switch (got_oid(arg, &oid, have_obj)) {
 395                        case -1: /* they have what we do not */
 396                                got_other = 1;
 397                                if (multi_ack && ok_to_give_up(have_obj, want_obj)) {
 398                                        const char *hex = oid_to_hex(&oid);
 399                                        if (multi_ack == 2) {
 400                                                sent_ready = 1;
 401                                                packet_write_fmt(1, "ACK %s ready\n", hex);
 402                                        } else
 403                                                packet_write_fmt(1, "ACK %s continue\n", hex);
 404                                }
 405                                break;
 406                        default:
 407                                got_common = 1;
 408                                oid_to_hex_r(last_hex, &oid);
 409                                if (multi_ack == 2)
 410                                        packet_write_fmt(1, "ACK %s common\n", last_hex);
 411                                else if (multi_ack)
 412                                        packet_write_fmt(1, "ACK %s continue\n", last_hex);
 413                                else if (have_obj->nr == 1)
 414                                        packet_write_fmt(1, "ACK %s\n", last_hex);
 415                                break;
 416                        }
 417                        continue;
 418                }
 419                if (!strcmp(line, "done")) {
 420                        if (have_obj->nr > 0) {
 421                                if (multi_ack)
 422                                        packet_write_fmt(1, "ACK %s\n", last_hex);
 423                                return 0;
 424                        }
 425                        packet_write_fmt(1, "NAK\n");
 426                        return -1;
 427                }
 428                die("git upload-pack: expected SHA1 list, got '%s'", line);
 429        }
 430}
 431
 432static int is_our_ref(struct object *o)
 433{
 434        int allow_hidden_ref = (allow_unadvertised_object_request &
 435                        (ALLOW_TIP_SHA1 | ALLOW_REACHABLE_SHA1));
 436        return o->flags & ((allow_hidden_ref ? HIDDEN_REF : 0) | OUR_REF);
 437}
 438
 439/*
 440 * on successful case, it's up to the caller to close cmd->out
 441 */
 442static int do_reachable_revlist(struct child_process *cmd,
 443                                struct object_array *src,
 444                                struct object_array *reachable)
 445{
 446        static const char *argv[] = {
 447                "rev-list", "--stdin", NULL,
 448        };
 449        struct object *o;
 450        char namebuf[GIT_MAX_HEXSZ + 2]; /* ^ + hash + LF */
 451        int i;
 452        const unsigned hexsz = the_hash_algo->hexsz;
 453
 454        cmd->argv = argv;
 455        cmd->git_cmd = 1;
 456        cmd->no_stderr = 1;
 457        cmd->in = -1;
 458        cmd->out = -1;
 459
 460        /*
 461         * If the next rev-list --stdin encounters an unknown commit,
 462         * it terminates, which will cause SIGPIPE in the write loop
 463         * below.
 464         */
 465        sigchain_push(SIGPIPE, SIG_IGN);
 466
 467        if (start_command(cmd))
 468                goto error;
 469
 470        namebuf[0] = '^';
 471        namebuf[hexsz + 1] = '\n';
 472        for (i = get_max_object_index(); 0 < i; ) {
 473                o = get_indexed_object(--i);
 474                if (!o)
 475                        continue;
 476                if (reachable && o->type == OBJ_COMMIT)
 477                        o->flags &= ~TMP_MARK;
 478                if (!is_our_ref(o))
 479                        continue;
 480                memcpy(namebuf + 1, oid_to_hex(&o->oid), hexsz);
 481                if (write_in_full(cmd->in, namebuf, hexsz + 2) < 0)
 482                        goto error;
 483        }
 484        namebuf[hexsz] = '\n';
 485        for (i = 0; i < src->nr; i++) {
 486                o = src->objects[i].item;
 487                if (is_our_ref(o)) {
 488                        if (reachable)
 489                                add_object_array(o, NULL, reachable);
 490                        continue;
 491                }
 492                if (reachable && o->type == OBJ_COMMIT)
 493                        o->flags |= TMP_MARK;
 494                memcpy(namebuf, oid_to_hex(&o->oid), hexsz);
 495                if (write_in_full(cmd->in, namebuf, hexsz + 1) < 0)
 496                        goto error;
 497        }
 498        close(cmd->in);
 499        cmd->in = -1;
 500        sigchain_pop(SIGPIPE);
 501
 502        return 0;
 503
 504error:
 505        sigchain_pop(SIGPIPE);
 506
 507        if (cmd->in >= 0)
 508                close(cmd->in);
 509        if (cmd->out >= 0)
 510                close(cmd->out);
 511        return -1;
 512}
 513
 514static int get_reachable_list(struct object_array *src,
 515                              struct object_array *reachable)
 516{
 517        struct child_process cmd = CHILD_PROCESS_INIT;
 518        int i;
 519        struct object *o;
 520        char namebuf[GIT_MAX_HEXSZ + 2]; /* ^ + hash + LF */
 521        const unsigned hexsz = the_hash_algo->hexsz;
 522
 523        if (do_reachable_revlist(&cmd, src, reachable) < 0)
 524                return -1;
 525
 526        while ((i = read_in_full(cmd.out, namebuf, hexsz + 1)) == hexsz + 1) {
 527                struct object_id sha1;
 528                const char *p;
 529
 530                if (parse_oid_hex(namebuf, &sha1, &p) || *p != '\n')
 531                        break;
 532
 533                o = lookup_object(the_repository, sha1.hash);
 534                if (o && o->type == OBJ_COMMIT) {
 535                        o->flags &= ~TMP_MARK;
 536                }
 537        }
 538        for (i = get_max_object_index(); 0 < i; i--) {
 539                o = get_indexed_object(i - 1);
 540                if (o && o->type == OBJ_COMMIT &&
 541                    (o->flags & TMP_MARK)) {
 542                        add_object_array(o, NULL, reachable);
 543                                o->flags &= ~TMP_MARK;
 544                }
 545        }
 546        close(cmd.out);
 547
 548        if (finish_command(&cmd))
 549                return -1;
 550
 551        return 0;
 552}
 553
 554static int has_unreachable(struct object_array *src)
 555{
 556        struct child_process cmd = CHILD_PROCESS_INIT;
 557        char buf[1];
 558        int i;
 559
 560        if (do_reachable_revlist(&cmd, src, NULL) < 0)
 561                return 1;
 562
 563        /*
 564         * The commits out of the rev-list are not ancestors of
 565         * our ref.
 566         */
 567        i = read_in_full(cmd.out, buf, 1);
 568        if (i)
 569                goto error;
 570        close(cmd.out);
 571        cmd.out = -1;
 572
 573        /*
 574         * rev-list may have died by encountering a bad commit
 575         * in the history, in which case we do want to bail out
 576         * even when it showed no commit.
 577         */
 578        if (finish_command(&cmd))
 579                goto error;
 580
 581        /* All the non-tip ones are ancestors of what we advertised */
 582        return 0;
 583
 584error:
 585        sigchain_pop(SIGPIPE);
 586        if (cmd.out >= 0)
 587                close(cmd.out);
 588        return 1;
 589}
 590
 591static void check_non_tip(struct object_array *want_obj)
 592{
 593        int i;
 594
 595        /*
 596         * In the normal in-process case without
 597         * uploadpack.allowReachableSHA1InWant,
 598         * non-tip requests can never happen.
 599         */
 600        if (!stateless_rpc && !(allow_unadvertised_object_request & ALLOW_REACHABLE_SHA1))
 601                goto error;
 602        if (!has_unreachable(want_obj))
 603                /* All the non-tip ones are ancestors of what we advertised */
 604                return;
 605
 606error:
 607        /* Pick one of them (we know there at least is one) */
 608        for (i = 0; i < want_obj->nr; i++) {
 609                struct object *o = want_obj->objects[i].item;
 610                if (!is_our_ref(o))
 611                        die("git upload-pack: not our ref %s",
 612                            oid_to_hex(&o->oid));
 613        }
 614}
 615
 616static void send_shallow(struct commit_list *result)
 617{
 618        while (result) {
 619                struct object *object = &result->item->object;
 620                if (!(object->flags & (CLIENT_SHALLOW|NOT_SHALLOW))) {
 621                        packet_write_fmt(1, "shallow %s",
 622                                         oid_to_hex(&object->oid));
 623                        register_shallow(the_repository, &object->oid);
 624                        shallow_nr++;
 625                }
 626                result = result->next;
 627        }
 628}
 629
 630static void send_unshallow(const struct object_array *shallows,
 631                           struct object_array *want_obj)
 632{
 633        int i;
 634
 635        for (i = 0; i < shallows->nr; i++) {
 636                struct object *object = shallows->objects[i].item;
 637                if (object->flags & NOT_SHALLOW) {
 638                        struct commit_list *parents;
 639                        packet_write_fmt(1, "unshallow %s",
 640                                         oid_to_hex(&object->oid));
 641                        object->flags &= ~CLIENT_SHALLOW;
 642                        /*
 643                         * We want to _register_ "object" as shallow, but we
 644                         * also need to traverse object's parents to deepen a
 645                         * shallow clone. Unregister it for now so we can
 646                         * parse and add the parents to the want list, then
 647                         * re-register it.
 648                         */
 649                        unregister_shallow(&object->oid);
 650                        object->parsed = 0;
 651                        parse_commit_or_die((struct commit *)object);
 652                        parents = ((struct commit *)object)->parents;
 653                        while (parents) {
 654                                add_object_array(&parents->item->object,
 655                                                 NULL, want_obj);
 656                                parents = parents->next;
 657                        }
 658                        add_object_array(object, NULL, &extra_edge_obj);
 659                }
 660                /* make sure commit traversal conforms to client */
 661                register_shallow(the_repository, &object->oid);
 662        }
 663}
 664
 665static void deepen(int depth, int deepen_relative,
 666                   struct object_array *shallows, struct object_array *want_obj)
 667{
 668        if (depth == INFINITE_DEPTH && !is_repository_shallow(the_repository)) {
 669                int i;
 670
 671                for (i = 0; i < shallows->nr; i++) {
 672                        struct object *object = shallows->objects[i].item;
 673                        object->flags |= NOT_SHALLOW;
 674                }
 675        } else if (deepen_relative) {
 676                struct object_array reachable_shallows = OBJECT_ARRAY_INIT;
 677                struct commit_list *result;
 678
 679                get_reachable_list(shallows, &reachable_shallows);
 680                result = get_shallow_commits(&reachable_shallows,
 681                                             depth + 1,
 682                                             SHALLOW, NOT_SHALLOW);
 683                send_shallow(result);
 684                free_commit_list(result);
 685                object_array_clear(&reachable_shallows);
 686        } else {
 687                struct commit_list *result;
 688
 689                result = get_shallow_commits(want_obj, depth,
 690                                             SHALLOW, NOT_SHALLOW);
 691                send_shallow(result);
 692                free_commit_list(result);
 693        }
 694
 695        send_unshallow(shallows, want_obj);
 696}
 697
 698static void deepen_by_rev_list(int ac, const char **av,
 699                               struct object_array *shallows,
 700                               struct object_array *want_obj)
 701{
 702        struct commit_list *result;
 703
 704        close_commit_graph(the_repository);
 705        result = get_shallow_commits_by_rev_list(ac, av, SHALLOW, NOT_SHALLOW);
 706        send_shallow(result);
 707        free_commit_list(result);
 708        send_unshallow(shallows, want_obj);
 709}
 710
 711/* Returns 1 if a shallow list is sent or 0 otherwise */
 712static int send_shallow_list(int depth, int deepen_rev_list,
 713                             timestamp_t deepen_since,
 714                             struct string_list *deepen_not,
 715                             struct object_array *shallows,
 716                             struct object_array *want_obj)
 717{
 718        int ret = 0;
 719
 720        if (depth > 0 && deepen_rev_list)
 721                die("git upload-pack: deepen and deepen-since (or deepen-not) cannot be used together");
 722        if (depth > 0) {
 723                deepen(depth, deepen_relative, shallows, want_obj);
 724                ret = 1;
 725        } else if (deepen_rev_list) {
 726                struct argv_array av = ARGV_ARRAY_INIT;
 727                int i;
 728
 729                argv_array_push(&av, "rev-list");
 730                if (deepen_since)
 731                        argv_array_pushf(&av, "--max-age=%"PRItime, deepen_since);
 732                if (deepen_not->nr) {
 733                        argv_array_push(&av, "--not");
 734                        for (i = 0; i < deepen_not->nr; i++) {
 735                                struct string_list_item *s = deepen_not->items + i;
 736                                argv_array_push(&av, s->string);
 737                        }
 738                        argv_array_push(&av, "--not");
 739                }
 740                for (i = 0; i < want_obj->nr; i++) {
 741                        struct object *o = want_obj->objects[i].item;
 742                        argv_array_push(&av, oid_to_hex(&o->oid));
 743                }
 744                deepen_by_rev_list(av.argc, av.argv, shallows, want_obj);
 745                argv_array_clear(&av);
 746                ret = 1;
 747        } else {
 748                if (shallows->nr > 0) {
 749                        int i;
 750                        for (i = 0; i < shallows->nr; i++)
 751                                register_shallow(the_repository,
 752                                                 &shallows->objects[i].item->oid);
 753                }
 754        }
 755
 756        shallow_nr += shallows->nr;
 757        return ret;
 758}
 759
 760static int process_shallow(const char *line, struct object_array *shallows)
 761{
 762        const char *arg;
 763        if (skip_prefix(line, "shallow ", &arg)) {
 764                struct object_id oid;
 765                struct object *object;
 766                if (get_oid_hex(arg, &oid))
 767                        die("invalid shallow line: %s", line);
 768                object = parse_object(the_repository, &oid);
 769                if (!object)
 770                        return 1;
 771                if (object->type != OBJ_COMMIT)
 772                        die("invalid shallow object %s", oid_to_hex(&oid));
 773                if (!(object->flags & CLIENT_SHALLOW)) {
 774                        object->flags |= CLIENT_SHALLOW;
 775                        add_object_array(object, NULL, shallows);
 776                }
 777                return 1;
 778        }
 779
 780        return 0;
 781}
 782
 783static int process_deepen(const char *line, int *depth)
 784{
 785        const char *arg;
 786        if (skip_prefix(line, "deepen ", &arg)) {
 787                char *end = NULL;
 788                *depth = (int)strtol(arg, &end, 0);
 789                if (!end || *end || *depth <= 0)
 790                        die("Invalid deepen: %s", line);
 791                return 1;
 792        }
 793
 794        return 0;
 795}
 796
 797static int process_deepen_since(const char *line, timestamp_t *deepen_since, int *deepen_rev_list)
 798{
 799        const char *arg;
 800        if (skip_prefix(line, "deepen-since ", &arg)) {
 801                char *end = NULL;
 802                *deepen_since = parse_timestamp(arg, &end, 0);
 803                if (!end || *end || !deepen_since ||
 804                    /* revisions.c's max_age -1 is special */
 805                    *deepen_since == -1)
 806                        die("Invalid deepen-since: %s", line);
 807                *deepen_rev_list = 1;
 808                return 1;
 809        }
 810        return 0;
 811}
 812
 813static int process_deepen_not(const char *line, struct string_list *deepen_not, int *deepen_rev_list)
 814{
 815        const char *arg;
 816        if (skip_prefix(line, "deepen-not ", &arg)) {
 817                char *ref = NULL;
 818                struct object_id oid;
 819                if (expand_ref(arg, strlen(arg), &oid, &ref) != 1)
 820                        die("git upload-pack: ambiguous deepen-not: %s", line);
 821                string_list_append(deepen_not, ref);
 822                free(ref);
 823                *deepen_rev_list = 1;
 824                return 1;
 825        }
 826        return 0;
 827}
 828
 829static void receive_needs(struct object_array *want_obj)
 830{
 831        struct object_array shallows = OBJECT_ARRAY_INIT;
 832        struct string_list deepen_not = STRING_LIST_INIT_DUP;
 833        int depth = 0;
 834        int has_non_tip = 0;
 835        timestamp_t deepen_since = 0;
 836        int deepen_rev_list = 0;
 837
 838        shallow_nr = 0;
 839        for (;;) {
 840                struct object *o;
 841                const char *features;
 842                struct object_id oid_buf;
 843                char *line = packet_read_line(0, NULL);
 844                const char *arg;
 845
 846                reset_timeout();
 847                if (!line)
 848                        break;
 849
 850                if (process_shallow(line, &shallows))
 851                        continue;
 852                if (process_deepen(line, &depth))
 853                        continue;
 854                if (process_deepen_since(line, &deepen_since, &deepen_rev_list))
 855                        continue;
 856                if (process_deepen_not(line, &deepen_not, &deepen_rev_list))
 857                        continue;
 858
 859                if (skip_prefix(line, "filter ", &arg)) {
 860                        if (!filter_capability_requested)
 861                                die("git upload-pack: filtering capability not negotiated");
 862                        parse_list_objects_filter(&filter_options, arg);
 863                        continue;
 864                }
 865
 866                if (!skip_prefix(line, "want ", &arg) ||
 867                    parse_oid_hex(arg, &oid_buf, &features))
 868                        die("git upload-pack: protocol error, "
 869                            "expected to get object ID, not '%s'", line);
 870
 871                if (parse_feature_request(features, "deepen-relative"))
 872                        deepen_relative = 1;
 873                if (parse_feature_request(features, "multi_ack_detailed"))
 874                        multi_ack = 2;
 875                else if (parse_feature_request(features, "multi_ack"))
 876                        multi_ack = 1;
 877                if (parse_feature_request(features, "no-done"))
 878                        no_done = 1;
 879                if (parse_feature_request(features, "thin-pack"))
 880                        use_thin_pack = 1;
 881                if (parse_feature_request(features, "ofs-delta"))
 882                        use_ofs_delta = 1;
 883                if (parse_feature_request(features, "side-band-64k"))
 884                        use_sideband = LARGE_PACKET_MAX;
 885                else if (parse_feature_request(features, "side-band"))
 886                        use_sideband = DEFAULT_PACKET_MAX;
 887                if (parse_feature_request(features, "no-progress"))
 888                        no_progress = 1;
 889                if (parse_feature_request(features, "include-tag"))
 890                        use_include_tag = 1;
 891                if (allow_filter && parse_feature_request(features, "filter"))
 892                        filter_capability_requested = 1;
 893
 894                o = parse_object(the_repository, &oid_buf);
 895                if (!o) {
 896                        packet_write_fmt(1,
 897                                         "ERR upload-pack: not our ref %s",
 898                                         oid_to_hex(&oid_buf));
 899                        die("git upload-pack: not our ref %s",
 900                            oid_to_hex(&oid_buf));
 901                }
 902                if (!(o->flags & WANTED)) {
 903                        o->flags |= WANTED;
 904                        if (!((allow_unadvertised_object_request & ALLOW_ANY_SHA1) == ALLOW_ANY_SHA1
 905                              || is_our_ref(o)))
 906                                has_non_tip = 1;
 907                        add_object_array(o, NULL, want_obj);
 908                }
 909        }
 910
 911        /*
 912         * We have sent all our refs already, and the other end
 913         * should have chosen out of them. When we are operating
 914         * in the stateless RPC mode, however, their choice may
 915         * have been based on the set of older refs advertised
 916         * by another process that handled the initial request.
 917         */
 918        if (has_non_tip)
 919                check_non_tip(want_obj);
 920
 921        if (!use_sideband && daemon_mode)
 922                no_progress = 1;
 923
 924        if (depth == 0 && !deepen_rev_list && shallows.nr == 0)
 925                return;
 926
 927        if (send_shallow_list(depth, deepen_rev_list, deepen_since,
 928                              &deepen_not, &shallows, want_obj))
 929                packet_flush(1);
 930        object_array_clear(&shallows);
 931}
 932
 933/* return non-zero if the ref is hidden, otherwise 0 */
 934static int mark_our_ref(const char *refname, const char *refname_full,
 935                        const struct object_id *oid)
 936{
 937        struct object *o = lookup_unknown_object(oid->hash);
 938
 939        if (ref_is_hidden(refname, refname_full)) {
 940                o->flags |= HIDDEN_REF;
 941                return 1;
 942        }
 943        o->flags |= OUR_REF;
 944        return 0;
 945}
 946
 947static int check_ref(const char *refname_full, const struct object_id *oid,
 948                     int flag, void *cb_data)
 949{
 950        const char *refname = strip_namespace(refname_full);
 951
 952        mark_our_ref(refname, refname_full, oid);
 953        return 0;
 954}
 955
 956static void format_symref_info(struct strbuf *buf, struct string_list *symref)
 957{
 958        struct string_list_item *item;
 959
 960        if (!symref->nr)
 961                return;
 962        for_each_string_list_item(item, symref)
 963                strbuf_addf(buf, " symref=%s:%s", item->string, (char *)item->util);
 964}
 965
 966static int send_ref(const char *refname, const struct object_id *oid,
 967                    int flag, void *cb_data)
 968{
 969        static const char *capabilities = "multi_ack thin-pack side-band"
 970                " side-band-64k ofs-delta shallow deepen-since deepen-not"
 971                " deepen-relative no-progress include-tag multi_ack_detailed";
 972        const char *refname_nons = strip_namespace(refname);
 973        struct object_id peeled;
 974
 975        if (mark_our_ref(refname_nons, refname, oid))
 976                return 0;
 977
 978        if (capabilities) {
 979                struct strbuf symref_info = STRBUF_INIT;
 980
 981                format_symref_info(&symref_info, cb_data);
 982                packet_write_fmt(1, "%s %s%c%s%s%s%s%s%s agent=%s\n",
 983                             oid_to_hex(oid), refname_nons,
 984                             0, capabilities,
 985                             (allow_unadvertised_object_request & ALLOW_TIP_SHA1) ?
 986                                     " allow-tip-sha1-in-want" : "",
 987                             (allow_unadvertised_object_request & ALLOW_REACHABLE_SHA1) ?
 988                                     " allow-reachable-sha1-in-want" : "",
 989                             stateless_rpc ? " no-done" : "",
 990                             symref_info.buf,
 991                             allow_filter ? " filter" : "",
 992                             git_user_agent_sanitized());
 993                strbuf_release(&symref_info);
 994        } else {
 995                packet_write_fmt(1, "%s %s\n", oid_to_hex(oid), refname_nons);
 996        }
 997        capabilities = NULL;
 998        if (!peel_ref(refname, &peeled))
 999                packet_write_fmt(1, "%s %s^{}\n", oid_to_hex(&peeled), refname_nons);
1000        return 0;
1001}
1002
1003static int find_symref(const char *refname, const struct object_id *oid,
1004                       int flag, void *cb_data)
1005{
1006        const char *symref_target;
1007        struct string_list_item *item;
1008
1009        if ((flag & REF_ISSYMREF) == 0)
1010                return 0;
1011        symref_target = resolve_ref_unsafe(refname, 0, NULL, &flag);
1012        if (!symref_target || (flag & REF_ISSYMREF) == 0)
1013                die("'%s' is a symref but it is not?", refname);
1014        item = string_list_append(cb_data, refname);
1015        item->util = xstrdup(symref_target);
1016        return 0;
1017}
1018
1019static int upload_pack_config(const char *var, const char *value, void *unused)
1020{
1021        if (!strcmp("uploadpack.allowtipsha1inwant", var)) {
1022                if (git_config_bool(var, value))
1023                        allow_unadvertised_object_request |= ALLOW_TIP_SHA1;
1024                else
1025                        allow_unadvertised_object_request &= ~ALLOW_TIP_SHA1;
1026        } else if (!strcmp("uploadpack.allowreachablesha1inwant", var)) {
1027                if (git_config_bool(var, value))
1028                        allow_unadvertised_object_request |= ALLOW_REACHABLE_SHA1;
1029                else
1030                        allow_unadvertised_object_request &= ~ALLOW_REACHABLE_SHA1;
1031        } else if (!strcmp("uploadpack.allowanysha1inwant", var)) {
1032                if (git_config_bool(var, value))
1033                        allow_unadvertised_object_request |= ALLOW_ANY_SHA1;
1034                else
1035                        allow_unadvertised_object_request &= ~ALLOW_ANY_SHA1;
1036        } else if (!strcmp("uploadpack.keepalive", var)) {
1037                keepalive = git_config_int(var, value);
1038                if (!keepalive)
1039                        keepalive = -1;
1040        } else if (!strcmp("uploadpack.allowfilter", var)) {
1041                allow_filter = git_config_bool(var, value);
1042        } else if (!strcmp("uploadpack.allowrefinwant", var)) {
1043                allow_ref_in_want = git_config_bool(var, value);
1044        }
1045
1046        if (current_config_scope() != CONFIG_SCOPE_REPO) {
1047                if (!strcmp("uploadpack.packobjectshook", var))
1048                        return git_config_string(&pack_objects_hook, var, value);
1049        }
1050
1051        return parse_hide_refs_config(var, value, "uploadpack");
1052}
1053
1054void upload_pack(struct upload_pack_options *options)
1055{
1056        struct string_list symref = STRING_LIST_INIT_DUP;
1057        struct object_array want_obj = OBJECT_ARRAY_INIT;
1058
1059        stateless_rpc = options->stateless_rpc;
1060        timeout = options->timeout;
1061        daemon_mode = options->daemon_mode;
1062
1063        git_config(upload_pack_config, NULL);
1064
1065        head_ref_namespaced(find_symref, &symref);
1066
1067        if (options->advertise_refs || !stateless_rpc) {
1068                reset_timeout();
1069                head_ref_namespaced(send_ref, &symref);
1070                for_each_namespaced_ref(send_ref, &symref);
1071                advertise_shallow_grafts(1);
1072                packet_flush(1);
1073        } else {
1074                head_ref_namespaced(check_ref, NULL);
1075                for_each_namespaced_ref(check_ref, NULL);
1076        }
1077        string_list_clear(&symref, 1);
1078        if (options->advertise_refs)
1079                return;
1080
1081        receive_needs(&want_obj);
1082        if (want_obj.nr) {
1083                struct object_array have_obj = OBJECT_ARRAY_INIT;
1084                get_common_commits(&have_obj, &want_obj);
1085                create_pack_file(&have_obj, &want_obj);
1086        }
1087}
1088
1089struct upload_pack_data {
1090        struct object_array wants;
1091        struct string_list wanted_refs;
1092        struct oid_array haves;
1093
1094        struct object_array shallows;
1095        struct string_list deepen_not;
1096        int depth;
1097        timestamp_t deepen_since;
1098        int deepen_rev_list;
1099        int deepen_relative;
1100
1101        unsigned stateless_rpc : 1;
1102
1103        unsigned use_thin_pack : 1;
1104        unsigned use_ofs_delta : 1;
1105        unsigned no_progress : 1;
1106        unsigned use_include_tag : 1;
1107        unsigned done : 1;
1108};
1109
1110static void upload_pack_data_init(struct upload_pack_data *data)
1111{
1112        struct object_array wants = OBJECT_ARRAY_INIT;
1113        struct string_list wanted_refs = STRING_LIST_INIT_DUP;
1114        struct oid_array haves = OID_ARRAY_INIT;
1115        struct object_array shallows = OBJECT_ARRAY_INIT;
1116        struct string_list deepen_not = STRING_LIST_INIT_DUP;
1117
1118        memset(data, 0, sizeof(*data));
1119        data->wants = wants;
1120        data->wanted_refs = wanted_refs;
1121        data->haves = haves;
1122        data->shallows = shallows;
1123        data->deepen_not = deepen_not;
1124}
1125
1126static void upload_pack_data_clear(struct upload_pack_data *data)
1127{
1128        object_array_clear(&data->wants);
1129        string_list_clear(&data->wanted_refs, 1);
1130        oid_array_clear(&data->haves);
1131        object_array_clear(&data->shallows);
1132        string_list_clear(&data->deepen_not, 0);
1133}
1134
1135static int parse_want(const char *line, struct object_array *want_obj)
1136{
1137        const char *arg;
1138        if (skip_prefix(line, "want ", &arg)) {
1139                struct object_id oid;
1140                struct object *o;
1141
1142                if (get_oid_hex(arg, &oid))
1143                        die("git upload-pack: protocol error, "
1144                            "expected to get oid, not '%s'", line);
1145
1146                o = parse_object(the_repository, &oid);
1147                if (!o) {
1148                        packet_write_fmt(1,
1149                                         "ERR upload-pack: not our ref %s",
1150                                         oid_to_hex(&oid));
1151                        die("git upload-pack: not our ref %s",
1152                            oid_to_hex(&oid));
1153                }
1154
1155                if (!(o->flags & WANTED)) {
1156                        o->flags |= WANTED;
1157                        add_object_array(o, NULL, want_obj);
1158                }
1159
1160                return 1;
1161        }
1162
1163        return 0;
1164}
1165
1166static int parse_want_ref(const char *line, struct string_list *wanted_refs,
1167                          struct object_array *want_obj)
1168{
1169        const char *arg;
1170        if (skip_prefix(line, "want-ref ", &arg)) {
1171                struct object_id oid;
1172                struct string_list_item *item;
1173                struct object *o;
1174
1175                if (read_ref(arg, &oid)) {
1176                        packet_write_fmt(1, "ERR unknown ref %s", arg);
1177                        die("unknown ref %s", arg);
1178                }
1179
1180                item = string_list_append(wanted_refs, arg);
1181                item->util = oiddup(&oid);
1182
1183                o = parse_object_or_die(&oid, arg);
1184                if (!(o->flags & WANTED)) {
1185                        o->flags |= WANTED;
1186                        add_object_array(o, NULL, want_obj);
1187                }
1188
1189                return 1;
1190        }
1191
1192        return 0;
1193}
1194
1195static int parse_have(const char *line, struct oid_array *haves)
1196{
1197        const char *arg;
1198        if (skip_prefix(line, "have ", &arg)) {
1199                struct object_id oid;
1200
1201                if (get_oid_hex(arg, &oid))
1202                        die("git upload-pack: expected SHA1 object, got '%s'", arg);
1203                oid_array_append(haves, &oid);
1204                return 1;
1205        }
1206
1207        return 0;
1208}
1209
1210static void process_args(struct packet_reader *request,
1211                         struct upload_pack_data *data,
1212                         struct object_array *want_obj)
1213{
1214        while (packet_reader_read(request) != PACKET_READ_FLUSH) {
1215                const char *arg = request->line;
1216                const char *p;
1217
1218                /* process want */
1219                if (parse_want(arg, want_obj))
1220                        continue;
1221                if (allow_ref_in_want &&
1222                    parse_want_ref(arg, &data->wanted_refs, want_obj))
1223                        continue;
1224                /* process have line */
1225                if (parse_have(arg, &data->haves))
1226                        continue;
1227
1228                /* process args like thin-pack */
1229                if (!strcmp(arg, "thin-pack")) {
1230                        use_thin_pack = 1;
1231                        continue;
1232                }
1233                if (!strcmp(arg, "ofs-delta")) {
1234                        use_ofs_delta = 1;
1235                        continue;
1236                }
1237                if (!strcmp(arg, "no-progress")) {
1238                        no_progress = 1;
1239                        continue;
1240                }
1241                if (!strcmp(arg, "include-tag")) {
1242                        use_include_tag = 1;
1243                        continue;
1244                }
1245                if (!strcmp(arg, "done")) {
1246                        data->done = 1;
1247                        continue;
1248                }
1249
1250                /* Shallow related arguments */
1251                if (process_shallow(arg, &data->shallows))
1252                        continue;
1253                if (process_deepen(arg, &data->depth))
1254                        continue;
1255                if (process_deepen_since(arg, &data->deepen_since,
1256                                         &data->deepen_rev_list))
1257                        continue;
1258                if (process_deepen_not(arg, &data->deepen_not,
1259                                       &data->deepen_rev_list))
1260                        continue;
1261                if (!strcmp(arg, "deepen-relative")) {
1262                        data->deepen_relative = 1;
1263                        continue;
1264                }
1265
1266                if (allow_filter && skip_prefix(arg, "filter ", &p)) {
1267                        parse_list_objects_filter(&filter_options, p);
1268                        continue;
1269                }
1270
1271                /* ignore unknown lines maybe? */
1272                die("unexpected line: '%s'", arg);
1273        }
1274}
1275
1276static int process_haves(struct oid_array *haves, struct oid_array *common,
1277                         struct object_array *have_obj)
1278{
1279        int i;
1280
1281        /* Process haves */
1282        for (i = 0; i < haves->nr; i++) {
1283                const struct object_id *oid = &haves->oid[i];
1284                struct object *o;
1285                int we_knew_they_have = 0;
1286
1287                if (!has_object_file(oid))
1288                        continue;
1289
1290                oid_array_append(common, oid);
1291
1292                o = parse_object(the_repository, oid);
1293                if (!o)
1294                        die("oops (%s)", oid_to_hex(oid));
1295                if (o->type == OBJ_COMMIT) {
1296                        struct commit_list *parents;
1297                        struct commit *commit = (struct commit *)o;
1298                        if (o->flags & THEY_HAVE)
1299                                we_knew_they_have = 1;
1300                        else
1301                                o->flags |= THEY_HAVE;
1302                        if (!oldest_have || (commit->date < oldest_have))
1303                                oldest_have = commit->date;
1304                        for (parents = commit->parents;
1305                             parents;
1306                             parents = parents->next)
1307                                parents->item->object.flags |= THEY_HAVE;
1308                }
1309                if (!we_knew_they_have)
1310                        add_object_array(o, NULL, have_obj);
1311        }
1312
1313        return 0;
1314}
1315
1316static int send_acks(struct oid_array *acks, struct strbuf *response,
1317                     const struct object_array *have_obj,
1318                     struct object_array *want_obj)
1319{
1320        int i;
1321
1322        packet_buf_write(response, "acknowledgments\n");
1323
1324        /* Send Acks */
1325        if (!acks->nr)
1326                packet_buf_write(response, "NAK\n");
1327
1328        for (i = 0; i < acks->nr; i++) {
1329                packet_buf_write(response, "ACK %s\n",
1330                                 oid_to_hex(&acks->oid[i]));
1331        }
1332
1333        if (ok_to_give_up(have_obj, want_obj)) {
1334                /* Send Ready */
1335                packet_buf_write(response, "ready\n");
1336                return 1;
1337        }
1338
1339        return 0;
1340}
1341
1342static int process_haves_and_send_acks(struct upload_pack_data *data,
1343                                       struct object_array *have_obj,
1344                                       struct object_array *want_obj)
1345{
1346        struct oid_array common = OID_ARRAY_INIT;
1347        struct strbuf response = STRBUF_INIT;
1348        int ret = 0;
1349
1350        process_haves(&data->haves, &common, have_obj);
1351        if (data->done) {
1352                ret = 1;
1353        } else if (send_acks(&common, &response, have_obj, want_obj)) {
1354                packet_buf_delim(&response);
1355                ret = 1;
1356        } else {
1357                /* Add Flush */
1358                packet_buf_flush(&response);
1359                ret = 0;
1360        }
1361
1362        /* Send response */
1363        write_or_die(1, response.buf, response.len);
1364        strbuf_release(&response);
1365
1366        oid_array_clear(&data->haves);
1367        oid_array_clear(&common);
1368        return ret;
1369}
1370
1371static void send_wanted_ref_info(struct upload_pack_data *data)
1372{
1373        const struct string_list_item *item;
1374
1375        if (!data->wanted_refs.nr)
1376                return;
1377
1378        packet_write_fmt(1, "wanted-refs\n");
1379
1380        for_each_string_list_item(item, &data->wanted_refs) {
1381                packet_write_fmt(1, "%s %s\n",
1382                                 oid_to_hex(item->util),
1383                                 item->string);
1384        }
1385
1386        packet_delim(1);
1387}
1388
1389static void send_shallow_info(struct upload_pack_data *data,
1390                              struct object_array *want_obj)
1391{
1392        /* No shallow info needs to be sent */
1393        if (!data->depth && !data->deepen_rev_list && !data->shallows.nr &&
1394            !is_repository_shallow(the_repository))
1395                return;
1396
1397        packet_write_fmt(1, "shallow-info\n");
1398
1399        if (!send_shallow_list(data->depth, data->deepen_rev_list,
1400                               data->deepen_since, &data->deepen_not,
1401                               &data->shallows, want_obj) &&
1402            is_repository_shallow(the_repository))
1403                deepen(INFINITE_DEPTH, data->deepen_relative, &data->shallows,
1404                       want_obj);
1405
1406        packet_delim(1);
1407}
1408
1409enum fetch_state {
1410        FETCH_PROCESS_ARGS = 0,
1411        FETCH_SEND_ACKS,
1412        FETCH_SEND_PACK,
1413        FETCH_DONE,
1414};
1415
1416int upload_pack_v2(struct repository *r, struct argv_array *keys,
1417                   struct packet_reader *request)
1418{
1419        enum fetch_state state = FETCH_PROCESS_ARGS;
1420        struct upload_pack_data data;
1421        struct object_array have_obj = OBJECT_ARRAY_INIT;
1422        struct object_array want_obj = OBJECT_ARRAY_INIT;
1423
1424        clear_object_flags(ALL_FLAGS);
1425
1426        git_config(upload_pack_config, NULL);
1427
1428        upload_pack_data_init(&data);
1429        use_sideband = LARGE_PACKET_MAX;
1430
1431        while (state != FETCH_DONE) {
1432                switch (state) {
1433                case FETCH_PROCESS_ARGS:
1434                        process_args(request, &data, &want_obj);
1435
1436                        if (!want_obj.nr) {
1437                                /*
1438                                 * Request didn't contain any 'want' lines,
1439                                 * guess they didn't want anything.
1440                                 */
1441                                state = FETCH_DONE;
1442                        } else if (data.haves.nr) {
1443                                /*
1444                                 * Request had 'have' lines, so lets ACK them.
1445                                 */
1446                                state = FETCH_SEND_ACKS;
1447                        } else {
1448                                /*
1449                                 * Request had 'want's but no 'have's so we can
1450                                 * immedietly go to construct and send a pack.
1451                                 */
1452                                state = FETCH_SEND_PACK;
1453                        }
1454                        break;
1455                case FETCH_SEND_ACKS:
1456                        if (process_haves_and_send_acks(&data, &have_obj,
1457                                                        &want_obj))
1458                                state = FETCH_SEND_PACK;
1459                        else
1460                                state = FETCH_DONE;
1461                        break;
1462                case FETCH_SEND_PACK:
1463                        send_wanted_ref_info(&data);
1464                        send_shallow_info(&data, &want_obj);
1465
1466                        packet_write_fmt(1, "packfile\n");
1467                        create_pack_file(&have_obj, &want_obj);
1468                        state = FETCH_DONE;
1469                        break;
1470                case FETCH_DONE:
1471                        continue;
1472                }
1473        }
1474
1475        upload_pack_data_clear(&data);
1476        object_array_clear(&have_obj);
1477        object_array_clear(&want_obj);
1478        return 0;
1479}
1480
1481int upload_pack_advertise(struct repository *r,
1482                          struct strbuf *value)
1483{
1484        if (value) {
1485                int allow_filter_value;
1486                int allow_ref_in_want;
1487
1488                strbuf_addstr(value, "shallow");
1489
1490                if (!repo_config_get_bool(the_repository,
1491                                         "uploadpack.allowfilter",
1492                                         &allow_filter_value) &&
1493                    allow_filter_value)
1494                        strbuf_addstr(value, " filter");
1495
1496                if (!repo_config_get_bool(the_repository,
1497                                         "uploadpack.allowrefinwant",
1498                                         &allow_ref_in_want) &&
1499                    allow_ref_in_want)
1500                        strbuf_addstr(value, " ref-in-want");
1501        }
1502
1503        return 1;
1504}