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