upload-pack.con commit Merge branch 'sb/string-list-remove-unused' (f8649f8)
   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-reach.h"
  28
  29/* Remember to update object flag allocation in object.h */
  30#define THEY_HAVE       (1u << 11)
  31#define OUR_REF         (1u << 12)
  32#define WANTED          (1u << 13)
  33#define COMMON_KNOWN    (1u << 14)
  34
  35#define SHALLOW         (1u << 16)
  36#define NOT_SHALLOW     (1u << 17)
  37#define CLIENT_SHALLOW  (1u << 18)
  38#define HIDDEN_REF      (1u << 19)
  39
  40static timestamp_t oldest_have;
  41
  42static int deepen_relative;
  43static int multi_ack;
  44static int no_done;
  45static int use_thin_pack, use_ofs_delta, use_include_tag;
  46static int no_progress, daemon_mode;
  47/* Allow specifying sha1 if it is a ref tip. */
  48#define ALLOW_TIP_SHA1  01
  49/* Allow request of a sha1 if it is reachable from a ref (possibly hidden ref). */
  50#define ALLOW_REACHABLE_SHA1    02
  51/* Allow request of any sha1. Implies ALLOW_TIP_SHA1 and ALLOW_REACHABLE_SHA1. */
  52#define ALLOW_ANY_SHA1  07
  53static unsigned int allow_unadvertised_object_request;
  54static int shallow_nr;
  55static struct object_array have_obj;
  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(void)
 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{
 308        struct object *o;
 309        int we_knew_they_have = 0;
 310
 311        if (get_oid_hex(hex, oid))
 312                die("git upload-pack: expected SHA1 object, got '%s'", hex);
 313        if (!has_object_file(oid))
 314                return -1;
 315
 316        o = parse_object(the_repository, oid);
 317        if (!o)
 318                die("oops (%s)", oid_to_hex(oid));
 319        if (o->type == OBJ_COMMIT) {
 320                struct commit_list *parents;
 321                struct commit *commit = (struct commit *)o;
 322                if (o->flags & THEY_HAVE)
 323                        we_knew_they_have = 1;
 324                else
 325                        o->flags |= THEY_HAVE;
 326                if (!oldest_have || (commit->date < oldest_have))
 327                        oldest_have = commit->date;
 328                for (parents = commit->parents;
 329                     parents;
 330                     parents = parents->next)
 331                        parents->item->object.flags |= THEY_HAVE;
 332        }
 333        if (!we_knew_they_have) {
 334                add_object_array(o, NULL, &have_obj);
 335                return 1;
 336        }
 337        return 0;
 338}
 339
 340static int ok_to_give_up(void)
 341{
 342        uint32_t min_generation = GENERATION_NUMBER_ZERO;
 343
 344        if (!have_obj.nr)
 345                return 0;
 346
 347        return can_all_from_reach_with_flag(&want_obj, THEY_HAVE,
 348                                            COMMON_KNOWN, oldest_have,
 349                                            min_generation);
 350}
 351
 352static int get_common_commits(void)
 353{
 354        struct object_id oid;
 355        char last_hex[GIT_MAX_HEXSZ + 1];
 356        int got_common = 0;
 357        int got_other = 0;
 358        int sent_ready = 0;
 359
 360        save_commit_buffer = 0;
 361
 362        for (;;) {
 363                char *line = packet_read_line(0, NULL);
 364                const char *arg;
 365
 366                reset_timeout();
 367
 368                if (!line) {
 369                        if (multi_ack == 2 && got_common
 370                            && !got_other && ok_to_give_up()) {
 371                                sent_ready = 1;
 372                                packet_write_fmt(1, "ACK %s ready\n", last_hex);
 373                        }
 374                        if (have_obj.nr == 0 || multi_ack)
 375                                packet_write_fmt(1, "NAK\n");
 376
 377                        if (no_done && sent_ready) {
 378                                packet_write_fmt(1, "ACK %s\n", last_hex);
 379                                return 0;
 380                        }
 381                        if (stateless_rpc)
 382                                exit(0);
 383                        got_common = 0;
 384                        got_other = 0;
 385                        continue;
 386                }
 387                if (skip_prefix(line, "have ", &arg)) {
 388                        switch (got_oid(arg, &oid)) {
 389                        case -1: /* they have what we do not */
 390                                got_other = 1;
 391                                if (multi_ack && ok_to_give_up()) {
 392                                        const char *hex = oid_to_hex(&oid);
 393                                        if (multi_ack == 2) {
 394                                                sent_ready = 1;
 395                                                packet_write_fmt(1, "ACK %s ready\n", hex);
 396                                        } else
 397                                                packet_write_fmt(1, "ACK %s continue\n", hex);
 398                                }
 399                                break;
 400                        default:
 401                                got_common = 1;
 402                                oid_to_hex_r(last_hex, &oid);
 403                                if (multi_ack == 2)
 404                                        packet_write_fmt(1, "ACK %s common\n", last_hex);
 405                                else if (multi_ack)
 406                                        packet_write_fmt(1, "ACK %s continue\n", last_hex);
 407                                else if (have_obj.nr == 1)
 408                                        packet_write_fmt(1, "ACK %s\n", last_hex);
 409                                break;
 410                        }
 411                        continue;
 412                }
 413                if (!strcmp(line, "done")) {
 414                        if (have_obj.nr > 0) {
 415                                if (multi_ack)
 416                                        packet_write_fmt(1, "ACK %s\n", last_hex);
 417                                return 0;
 418                        }
 419                        packet_write_fmt(1, "NAK\n");
 420                        return -1;
 421                }
 422                die("git upload-pack: expected SHA1 list, got '%s'", line);
 423        }
 424}
 425
 426static int is_our_ref(struct object *o)
 427{
 428        int allow_hidden_ref = (allow_unadvertised_object_request &
 429                        (ALLOW_TIP_SHA1 | ALLOW_REACHABLE_SHA1));
 430        return o->flags & ((allow_hidden_ref ? HIDDEN_REF : 0) | OUR_REF);
 431}
 432
 433/*
 434 * on successful case, it's up to the caller to close cmd->out
 435 */
 436static int do_reachable_revlist(struct child_process *cmd,
 437                                struct object_array *src,
 438                                struct object_array *reachable)
 439{
 440        static const char *argv[] = {
 441                "rev-list", "--stdin", NULL,
 442        };
 443        struct object *o;
 444        char namebuf[GIT_MAX_HEXSZ + 2]; /* ^ + hash + LF */
 445        int i;
 446
 447        cmd->argv = argv;
 448        cmd->git_cmd = 1;
 449        cmd->no_stderr = 1;
 450        cmd->in = -1;
 451        cmd->out = -1;
 452
 453        /*
 454         * If the next rev-list --stdin encounters an unknown commit,
 455         * it terminates, which will cause SIGPIPE in the write loop
 456         * below.
 457         */
 458        sigchain_push(SIGPIPE, SIG_IGN);
 459
 460        if (start_command(cmd))
 461                goto error;
 462
 463        namebuf[0] = '^';
 464        namebuf[GIT_SHA1_HEXSZ + 1] = '\n';
 465        for (i = get_max_object_index(); 0 < i; ) {
 466                o = get_indexed_object(--i);
 467                if (!o)
 468                        continue;
 469                if (reachable && o->type == OBJ_COMMIT)
 470                        o->flags &= ~TMP_MARK;
 471                if (!is_our_ref(o))
 472                        continue;
 473                memcpy(namebuf + 1, oid_to_hex(&o->oid), GIT_SHA1_HEXSZ);
 474                if (write_in_full(cmd->in, namebuf, GIT_SHA1_HEXSZ + 2) < 0)
 475                        goto error;
 476        }
 477        namebuf[GIT_SHA1_HEXSZ] = '\n';
 478        for (i = 0; i < src->nr; i++) {
 479                o = src->objects[i].item;
 480                if (is_our_ref(o)) {
 481                        if (reachable)
 482                                add_object_array(o, NULL, reachable);
 483                        continue;
 484                }
 485                if (reachable && o->type == OBJ_COMMIT)
 486                        o->flags |= TMP_MARK;
 487                memcpy(namebuf, oid_to_hex(&o->oid), GIT_SHA1_HEXSZ);
 488                if (write_in_full(cmd->in, namebuf, GIT_SHA1_HEXSZ + 1) < 0)
 489                        goto error;
 490        }
 491        close(cmd->in);
 492        cmd->in = -1;
 493        sigchain_pop(SIGPIPE);
 494
 495        return 0;
 496
 497error:
 498        sigchain_pop(SIGPIPE);
 499
 500        if (cmd->in >= 0)
 501                close(cmd->in);
 502        if (cmd->out >= 0)
 503                close(cmd->out);
 504        return -1;
 505}
 506
 507static int get_reachable_list(struct object_array *src,
 508                              struct object_array *reachable)
 509{
 510        struct child_process cmd = CHILD_PROCESS_INIT;
 511        int i;
 512        struct object *o;
 513        char namebuf[GIT_MAX_HEXSZ + 2]; /* ^ + hash + LF */
 514        const unsigned hexsz = the_hash_algo->hexsz;
 515
 516        if (do_reachable_revlist(&cmd, src, reachable) < 0)
 517                return -1;
 518
 519        while ((i = read_in_full(cmd.out, namebuf, hexsz + 1)) == hexsz + 1) {
 520                struct object_id sha1;
 521                const char *p;
 522
 523                if (parse_oid_hex(namebuf, &sha1, &p) || *p != '\n')
 524                        break;
 525
 526                o = lookup_object(the_repository, sha1.hash);
 527                if (o && o->type == OBJ_COMMIT) {
 528                        o->flags &= ~TMP_MARK;
 529                }
 530        }
 531        for (i = get_max_object_index(); 0 < i; i--) {
 532                o = get_indexed_object(i - 1);
 533                if (o && o->type == OBJ_COMMIT &&
 534                    (o->flags & TMP_MARK)) {
 535                        add_object_array(o, NULL, reachable);
 536                                o->flags &= ~TMP_MARK;
 537                }
 538        }
 539        close(cmd.out);
 540
 541        if (finish_command(&cmd))
 542                return -1;
 543
 544        return 0;
 545}
 546
 547static int has_unreachable(struct object_array *src)
 548{
 549        struct child_process cmd = CHILD_PROCESS_INIT;
 550        char buf[1];
 551        int i;
 552
 553        if (do_reachable_revlist(&cmd, src, NULL) < 0)
 554                return 1;
 555
 556        /*
 557         * The commits out of the rev-list are not ancestors of
 558         * our ref.
 559         */
 560        i = read_in_full(cmd.out, buf, 1);
 561        if (i)
 562                goto error;
 563        close(cmd.out);
 564        cmd.out = -1;
 565
 566        /*
 567         * rev-list may have died by encountering a bad commit
 568         * in the history, in which case we do want to bail out
 569         * even when it showed no commit.
 570         */
 571        if (finish_command(&cmd))
 572                goto error;
 573
 574        /* All the non-tip ones are ancestors of what we advertised */
 575        return 0;
 576
 577error:
 578        sigchain_pop(SIGPIPE);
 579        if (cmd.out >= 0)
 580                close(cmd.out);
 581        return 1;
 582}
 583
 584static void check_non_tip(void)
 585{
 586        int i;
 587
 588        /*
 589         * In the normal in-process case without
 590         * uploadpack.allowReachableSHA1InWant,
 591         * non-tip requests can never happen.
 592         */
 593        if (!stateless_rpc && !(allow_unadvertised_object_request & ALLOW_REACHABLE_SHA1))
 594                goto error;
 595        if (!has_unreachable(&want_obj))
 596                /* All the non-tip ones are ancestors of what we advertised */
 597                return;
 598
 599error:
 600        /* Pick one of them (we know there at least is one) */
 601        for (i = 0; i < want_obj.nr; i++) {
 602                struct object *o = want_obj.objects[i].item;
 603                if (!is_our_ref(o))
 604                        die("git upload-pack: not our ref %s",
 605                            oid_to_hex(&o->oid));
 606        }
 607}
 608
 609static void send_shallow(struct commit_list *result)
 610{
 611        while (result) {
 612                struct object *object = &result->item->object;
 613                if (!(object->flags & (CLIENT_SHALLOW|NOT_SHALLOW))) {
 614                        packet_write_fmt(1, "shallow %s",
 615                                         oid_to_hex(&object->oid));
 616                        register_shallow(the_repository, &object->oid);
 617                        shallow_nr++;
 618                }
 619                result = result->next;
 620        }
 621}
 622
 623static void send_unshallow(const struct object_array *shallows)
 624{
 625        int i;
 626
 627        for (i = 0; i < shallows->nr; i++) {
 628                struct object *object = shallows->objects[i].item;
 629                if (object->flags & NOT_SHALLOW) {
 630                        struct commit_list *parents;
 631                        packet_write_fmt(1, "unshallow %s",
 632                                         oid_to_hex(&object->oid));
 633                        object->flags &= ~CLIENT_SHALLOW;
 634                        /*
 635                         * We want to _register_ "object" as shallow, but we
 636                         * also need to traverse object's parents to deepen a
 637                         * shallow clone. Unregister it for now so we can
 638                         * parse and add the parents to the want list, then
 639                         * re-register it.
 640                         */
 641                        unregister_shallow(&object->oid);
 642                        object->parsed = 0;
 643                        parse_commit_or_die((struct commit *)object);
 644                        parents = ((struct commit *)object)->parents;
 645                        while (parents) {
 646                                add_object_array(&parents->item->object,
 647                                                 NULL, &want_obj);
 648                                parents = parents->next;
 649                        }
 650                        add_object_array(object, NULL, &extra_edge_obj);
 651                }
 652                /* make sure commit traversal conforms to client */
 653                register_shallow(the_repository, &object->oid);
 654        }
 655}
 656
 657static void deepen(int depth, int deepen_relative,
 658                   struct object_array *shallows)
 659{
 660        if (depth == INFINITE_DEPTH && !is_repository_shallow(the_repository)) {
 661                int i;
 662
 663                for (i = 0; i < shallows->nr; i++) {
 664                        struct object *object = shallows->objects[i].item;
 665                        object->flags |= NOT_SHALLOW;
 666                }
 667        } else if (deepen_relative) {
 668                struct object_array reachable_shallows = OBJECT_ARRAY_INIT;
 669                struct commit_list *result;
 670
 671                get_reachable_list(shallows, &reachable_shallows);
 672                result = get_shallow_commits(&reachable_shallows,
 673                                             depth + 1,
 674                                             SHALLOW, NOT_SHALLOW);
 675                send_shallow(result);
 676                free_commit_list(result);
 677                object_array_clear(&reachable_shallows);
 678        } else {
 679                struct commit_list *result;
 680
 681                result = get_shallow_commits(&want_obj, depth,
 682                                             SHALLOW, NOT_SHALLOW);
 683                send_shallow(result);
 684                free_commit_list(result);
 685        }
 686
 687        send_unshallow(shallows);
 688}
 689
 690static void deepen_by_rev_list(int ac, const char **av,
 691                               struct object_array *shallows)
 692{
 693        struct commit_list *result;
 694
 695        result = get_shallow_commits_by_rev_list(ac, av, SHALLOW, NOT_SHALLOW);
 696        send_shallow(result);
 697        free_commit_list(result);
 698        send_unshallow(shallows);
 699}
 700
 701/* Returns 1 if a shallow list is sent or 0 otherwise */
 702static int send_shallow_list(int depth, int deepen_rev_list,
 703                             timestamp_t deepen_since,
 704                             struct string_list *deepen_not,
 705                             struct object_array *shallows)
 706{
 707        int ret = 0;
 708
 709        if (depth > 0 && deepen_rev_list)
 710                die("git upload-pack: deepen and deepen-since (or deepen-not) cannot be used together");
 711        if (depth > 0) {
 712                deepen(depth, deepen_relative, shallows);
 713                ret = 1;
 714        } else if (deepen_rev_list) {
 715                struct argv_array av = ARGV_ARRAY_INIT;
 716                int i;
 717
 718                argv_array_push(&av, "rev-list");
 719                if (deepen_since)
 720                        argv_array_pushf(&av, "--max-age=%"PRItime, deepen_since);
 721                if (deepen_not->nr) {
 722                        argv_array_push(&av, "--not");
 723                        for (i = 0; i < deepen_not->nr; i++) {
 724                                struct string_list_item *s = deepen_not->items + i;
 725                                argv_array_push(&av, s->string);
 726                        }
 727                        argv_array_push(&av, "--not");
 728                }
 729                for (i = 0; i < want_obj.nr; i++) {
 730                        struct object *o = want_obj.objects[i].item;
 731                        argv_array_push(&av, oid_to_hex(&o->oid));
 732                }
 733                deepen_by_rev_list(av.argc, av.argv, shallows);
 734                argv_array_clear(&av);
 735                ret = 1;
 736        } else {
 737                if (shallows->nr > 0) {
 738                        int i;
 739                        for (i = 0; i < shallows->nr; i++)
 740                                register_shallow(the_repository,
 741                                                 &shallows->objects[i].item->oid);
 742                }
 743        }
 744
 745        shallow_nr += shallows->nr;
 746        return ret;
 747}
 748
 749static int process_shallow(const char *line, struct object_array *shallows)
 750{
 751        const char *arg;
 752        if (skip_prefix(line, "shallow ", &arg)) {
 753                struct object_id oid;
 754                struct object *object;
 755                if (get_oid_hex(arg, &oid))
 756                        die("invalid shallow line: %s", line);
 757                object = parse_object(the_repository, &oid);
 758                if (!object)
 759                        return 1;
 760                if (object->type != OBJ_COMMIT)
 761                        die("invalid shallow object %s", oid_to_hex(&oid));
 762                if (!(object->flags & CLIENT_SHALLOW)) {
 763                        object->flags |= CLIENT_SHALLOW;
 764                        add_object_array(object, NULL, shallows);
 765                }
 766                return 1;
 767        }
 768
 769        return 0;
 770}
 771
 772static int process_deepen(const char *line, int *depth)
 773{
 774        const char *arg;
 775        if (skip_prefix(line, "deepen ", &arg)) {
 776                char *end = NULL;
 777                *depth = (int)strtol(arg, &end, 0);
 778                if (!end || *end || *depth <= 0)
 779                        die("Invalid deepen: %s", line);
 780                return 1;
 781        }
 782
 783        return 0;
 784}
 785
 786static int process_deepen_since(const char *line, timestamp_t *deepen_since, int *deepen_rev_list)
 787{
 788        const char *arg;
 789        if (skip_prefix(line, "deepen-since ", &arg)) {
 790                char *end = NULL;
 791                *deepen_since = parse_timestamp(arg, &end, 0);
 792                if (!end || *end || !deepen_since ||
 793                    /* revisions.c's max_age -1 is special */
 794                    *deepen_since == -1)
 795                        die("Invalid deepen-since: %s", line);
 796                *deepen_rev_list = 1;
 797                return 1;
 798        }
 799        return 0;
 800}
 801
 802static int process_deepen_not(const char *line, struct string_list *deepen_not, int *deepen_rev_list)
 803{
 804        const char *arg;
 805        if (skip_prefix(line, "deepen-not ", &arg)) {
 806                char *ref = NULL;
 807                struct object_id oid;
 808                if (expand_ref(arg, strlen(arg), &oid, &ref) != 1)
 809                        die("git upload-pack: ambiguous deepen-not: %s", line);
 810                string_list_append(deepen_not, ref);
 811                free(ref);
 812                *deepen_rev_list = 1;
 813                return 1;
 814        }
 815        return 0;
 816}
 817
 818static void receive_needs(void)
 819{
 820        struct object_array shallows = OBJECT_ARRAY_INIT;
 821        struct string_list deepen_not = STRING_LIST_INIT_DUP;
 822        int depth = 0;
 823        int has_non_tip = 0;
 824        timestamp_t deepen_since = 0;
 825        int deepen_rev_list = 0;
 826
 827        shallow_nr = 0;
 828        for (;;) {
 829                struct object *o;
 830                const char *features;
 831                struct object_id oid_buf;
 832                char *line = packet_read_line(0, NULL);
 833                const char *arg;
 834
 835                reset_timeout();
 836                if (!line)
 837                        break;
 838
 839                if (process_shallow(line, &shallows))
 840                        continue;
 841                if (process_deepen(line, &depth))
 842                        continue;
 843                if (process_deepen_since(line, &deepen_since, &deepen_rev_list))
 844                        continue;
 845                if (process_deepen_not(line, &deepen_not, &deepen_rev_list))
 846                        continue;
 847
 848                if (skip_prefix(line, "filter ", &arg)) {
 849                        if (!filter_capability_requested)
 850                                die("git upload-pack: filtering capability not negotiated");
 851                        parse_list_objects_filter(&filter_options, arg);
 852                        continue;
 853                }
 854
 855                if (!skip_prefix(line, "want ", &arg) ||
 856                    parse_oid_hex(arg, &oid_buf, &features))
 857                        die("git upload-pack: protocol error, "
 858                            "expected to get object ID, not '%s'", line);
 859
 860                if (parse_feature_request(features, "deepen-relative"))
 861                        deepen_relative = 1;
 862                if (parse_feature_request(features, "multi_ack_detailed"))
 863                        multi_ack = 2;
 864                else if (parse_feature_request(features, "multi_ack"))
 865                        multi_ack = 1;
 866                if (parse_feature_request(features, "no-done"))
 867                        no_done = 1;
 868                if (parse_feature_request(features, "thin-pack"))
 869                        use_thin_pack = 1;
 870                if (parse_feature_request(features, "ofs-delta"))
 871                        use_ofs_delta = 1;
 872                if (parse_feature_request(features, "side-band-64k"))
 873                        use_sideband = LARGE_PACKET_MAX;
 874                else if (parse_feature_request(features, "side-band"))
 875                        use_sideband = DEFAULT_PACKET_MAX;
 876                if (parse_feature_request(features, "no-progress"))
 877                        no_progress = 1;
 878                if (parse_feature_request(features, "include-tag"))
 879                        use_include_tag = 1;
 880                if (allow_filter && parse_feature_request(features, "filter"))
 881                        filter_capability_requested = 1;
 882
 883                o = parse_object(the_repository, &oid_buf);
 884                if (!o) {
 885                        packet_write_fmt(1,
 886                                         "ERR upload-pack: not our ref %s",
 887                                         oid_to_hex(&oid_buf));
 888                        die("git upload-pack: not our ref %s",
 889                            oid_to_hex(&oid_buf));
 890                }
 891                if (!(o->flags & WANTED)) {
 892                        o->flags |= WANTED;
 893                        if (!((allow_unadvertised_object_request & ALLOW_ANY_SHA1) == ALLOW_ANY_SHA1
 894                              || is_our_ref(o)))
 895                                has_non_tip = 1;
 896                        add_object_array(o, NULL, &want_obj);
 897                }
 898        }
 899
 900        /*
 901         * We have sent all our refs already, and the other end
 902         * should have chosen out of them. When we are operating
 903         * in the stateless RPC mode, however, their choice may
 904         * have been based on the set of older refs advertised
 905         * by another process that handled the initial request.
 906         */
 907        if (has_non_tip)
 908                check_non_tip();
 909
 910        if (!use_sideband && daemon_mode)
 911                no_progress = 1;
 912
 913        if (depth == 0 && !deepen_rev_list && shallows.nr == 0)
 914                return;
 915
 916        if (send_shallow_list(depth, deepen_rev_list, deepen_since,
 917                              &deepen_not, &shallows))
 918                packet_flush(1);
 919        object_array_clear(&shallows);
 920}
 921
 922/* return non-zero if the ref is hidden, otherwise 0 */
 923static int mark_our_ref(const char *refname, const char *refname_full,
 924                        const struct object_id *oid)
 925{
 926        struct object *o = lookup_unknown_object(oid->hash);
 927
 928        if (ref_is_hidden(refname, refname_full)) {
 929                o->flags |= HIDDEN_REF;
 930                return 1;
 931        }
 932        o->flags |= OUR_REF;
 933        return 0;
 934}
 935
 936static int check_ref(const char *refname_full, const struct object_id *oid,
 937                     int flag, void *cb_data)
 938{
 939        const char *refname = strip_namespace(refname_full);
 940
 941        mark_our_ref(refname, refname_full, oid);
 942        return 0;
 943}
 944
 945static void format_symref_info(struct strbuf *buf, struct string_list *symref)
 946{
 947        struct string_list_item *item;
 948
 949        if (!symref->nr)
 950                return;
 951        for_each_string_list_item(item, symref)
 952                strbuf_addf(buf, " symref=%s:%s", item->string, (char *)item->util);
 953}
 954
 955static int send_ref(const char *refname, const struct object_id *oid,
 956                    int flag, void *cb_data)
 957{
 958        static const char *capabilities = "multi_ack thin-pack side-band"
 959                " side-band-64k ofs-delta shallow deepen-since deepen-not"
 960                " deepen-relative no-progress include-tag multi_ack_detailed";
 961        const char *refname_nons = strip_namespace(refname);
 962        struct object_id peeled;
 963
 964        if (mark_our_ref(refname_nons, refname, oid))
 965                return 0;
 966
 967        if (capabilities) {
 968                struct strbuf symref_info = STRBUF_INIT;
 969
 970                format_symref_info(&symref_info, cb_data);
 971                packet_write_fmt(1, "%s %s%c%s%s%s%s%s%s agent=%s\n",
 972                             oid_to_hex(oid), refname_nons,
 973                             0, capabilities,
 974                             (allow_unadvertised_object_request & ALLOW_TIP_SHA1) ?
 975                                     " allow-tip-sha1-in-want" : "",
 976                             (allow_unadvertised_object_request & ALLOW_REACHABLE_SHA1) ?
 977                                     " allow-reachable-sha1-in-want" : "",
 978                             stateless_rpc ? " no-done" : "",
 979                             symref_info.buf,
 980                             allow_filter ? " filter" : "",
 981                             git_user_agent_sanitized());
 982                strbuf_release(&symref_info);
 983        } else {
 984                packet_write_fmt(1, "%s %s\n", oid_to_hex(oid), refname_nons);
 985        }
 986        capabilities = NULL;
 987        if (!peel_ref(refname, &peeled))
 988                packet_write_fmt(1, "%s %s^{}\n", oid_to_hex(&peeled), refname_nons);
 989        return 0;
 990}
 991
 992static int find_symref(const char *refname, const struct object_id *oid,
 993                       int flag, void *cb_data)
 994{
 995        const char *symref_target;
 996        struct string_list_item *item;
 997
 998        if ((flag & REF_ISSYMREF) == 0)
 999                return 0;
1000        symref_target = resolve_ref_unsafe(refname, 0, NULL, &flag);
1001        if (!symref_target || (flag & REF_ISSYMREF) == 0)
1002                die("'%s' is a symref but it is not?", refname);
1003        item = string_list_append(cb_data, refname);
1004        item->util = xstrdup(symref_target);
1005        return 0;
1006}
1007
1008static int upload_pack_config(const char *var, const char *value, void *unused)
1009{
1010        if (!strcmp("uploadpack.allowtipsha1inwant", var)) {
1011                if (git_config_bool(var, value))
1012                        allow_unadvertised_object_request |= ALLOW_TIP_SHA1;
1013                else
1014                        allow_unadvertised_object_request &= ~ALLOW_TIP_SHA1;
1015        } else if (!strcmp("uploadpack.allowreachablesha1inwant", var)) {
1016                if (git_config_bool(var, value))
1017                        allow_unadvertised_object_request |= ALLOW_REACHABLE_SHA1;
1018                else
1019                        allow_unadvertised_object_request &= ~ALLOW_REACHABLE_SHA1;
1020        } else if (!strcmp("uploadpack.allowanysha1inwant", var)) {
1021                if (git_config_bool(var, value))
1022                        allow_unadvertised_object_request |= ALLOW_ANY_SHA1;
1023                else
1024                        allow_unadvertised_object_request &= ~ALLOW_ANY_SHA1;
1025        } else if (!strcmp("uploadpack.keepalive", var)) {
1026                keepalive = git_config_int(var, value);
1027                if (!keepalive)
1028                        keepalive = -1;
1029        } else if (current_config_scope() != CONFIG_SCOPE_REPO) {
1030                if (!strcmp("uploadpack.packobjectshook", var))
1031                        return git_config_string(&pack_objects_hook, var, value);
1032        } else if (!strcmp("uploadpack.allowfilter", var)) {
1033                allow_filter = git_config_bool(var, value);
1034        } else if (!strcmp("uploadpack.allowrefinwant", var)) {
1035                allow_ref_in_want = git_config_bool(var, value);
1036        }
1037        return parse_hide_refs_config(var, value, "uploadpack");
1038}
1039
1040void upload_pack(struct upload_pack_options *options)
1041{
1042        struct string_list symref = STRING_LIST_INIT_DUP;
1043
1044        stateless_rpc = options->stateless_rpc;
1045        timeout = options->timeout;
1046        daemon_mode = options->daemon_mode;
1047
1048        git_config(upload_pack_config, NULL);
1049
1050        head_ref_namespaced(find_symref, &symref);
1051
1052        if (options->advertise_refs || !stateless_rpc) {
1053                reset_timeout();
1054                head_ref_namespaced(send_ref, &symref);
1055                for_each_namespaced_ref(send_ref, &symref);
1056                advertise_shallow_grafts(1);
1057                packet_flush(1);
1058        } else {
1059                head_ref_namespaced(check_ref, NULL);
1060                for_each_namespaced_ref(check_ref, NULL);
1061        }
1062        string_list_clear(&symref, 1);
1063        if (options->advertise_refs)
1064                return;
1065
1066        receive_needs();
1067        if (want_obj.nr) {
1068                get_common_commits();
1069                create_pack_file();
1070        }
1071}
1072
1073struct upload_pack_data {
1074        struct object_array wants;
1075        struct string_list wanted_refs;
1076        struct oid_array haves;
1077
1078        struct object_array shallows;
1079        struct string_list deepen_not;
1080        int depth;
1081        timestamp_t deepen_since;
1082        int deepen_rev_list;
1083        int deepen_relative;
1084
1085        unsigned stateless_rpc : 1;
1086
1087        unsigned use_thin_pack : 1;
1088        unsigned use_ofs_delta : 1;
1089        unsigned no_progress : 1;
1090        unsigned use_include_tag : 1;
1091        unsigned done : 1;
1092};
1093
1094static void upload_pack_data_init(struct upload_pack_data *data)
1095{
1096        struct object_array wants = OBJECT_ARRAY_INIT;
1097        struct string_list wanted_refs = STRING_LIST_INIT_DUP;
1098        struct oid_array haves = OID_ARRAY_INIT;
1099        struct object_array shallows = OBJECT_ARRAY_INIT;
1100        struct string_list deepen_not = STRING_LIST_INIT_DUP;
1101
1102        memset(data, 0, sizeof(*data));
1103        data->wants = wants;
1104        data->wanted_refs = wanted_refs;
1105        data->haves = haves;
1106        data->shallows = shallows;
1107        data->deepen_not = deepen_not;
1108}
1109
1110static void upload_pack_data_clear(struct upload_pack_data *data)
1111{
1112        object_array_clear(&data->wants);
1113        string_list_clear(&data->wanted_refs, 1);
1114        oid_array_clear(&data->haves);
1115        object_array_clear(&data->shallows);
1116        string_list_clear(&data->deepen_not, 0);
1117}
1118
1119static int parse_want(const char *line)
1120{
1121        const char *arg;
1122        if (skip_prefix(line, "want ", &arg)) {
1123                struct object_id oid;
1124                struct object *o;
1125
1126                if (get_oid_hex(arg, &oid))
1127                        die("git upload-pack: protocol error, "
1128                            "expected to get oid, not '%s'", line);
1129
1130                o = parse_object(the_repository, &oid);
1131                if (!o) {
1132                        packet_write_fmt(1,
1133                                         "ERR upload-pack: not our ref %s",
1134                                         oid_to_hex(&oid));
1135                        die("git upload-pack: not our ref %s",
1136                            oid_to_hex(&oid));
1137                }
1138
1139                if (!(o->flags & WANTED)) {
1140                        o->flags |= WANTED;
1141                        add_object_array(o, NULL, &want_obj);
1142                }
1143
1144                return 1;
1145        }
1146
1147        return 0;
1148}
1149
1150static int parse_want_ref(const char *line, struct string_list *wanted_refs)
1151{
1152        const char *arg;
1153        if (skip_prefix(line, "want-ref ", &arg)) {
1154                struct object_id oid;
1155                struct string_list_item *item;
1156                struct object *o;
1157
1158                if (read_ref(arg, &oid)) {
1159                        packet_write_fmt(1, "ERR unknown ref %s", arg);
1160                        die("unknown ref %s", arg);
1161                }
1162
1163                item = string_list_append(wanted_refs, arg);
1164                item->util = oiddup(&oid);
1165
1166                o = parse_object_or_die(&oid, arg);
1167                if (!(o->flags & WANTED)) {
1168                        o->flags |= WANTED;
1169                        add_object_array(o, NULL, &want_obj);
1170                }
1171
1172                return 1;
1173        }
1174
1175        return 0;
1176}
1177
1178static int parse_have(const char *line, struct oid_array *haves)
1179{
1180        const char *arg;
1181        if (skip_prefix(line, "have ", &arg)) {
1182                struct object_id oid;
1183
1184                if (get_oid_hex(arg, &oid))
1185                        die("git upload-pack: expected SHA1 object, got '%s'", arg);
1186                oid_array_append(haves, &oid);
1187                return 1;
1188        }
1189
1190        return 0;
1191}
1192
1193static void process_args(struct packet_reader *request,
1194                         struct upload_pack_data *data)
1195{
1196        while (packet_reader_read(request) != PACKET_READ_FLUSH) {
1197                const char *arg = request->line;
1198                const char *p;
1199
1200                /* process want */
1201                if (parse_want(arg))
1202                        continue;
1203                if (allow_ref_in_want && parse_want_ref(arg, &data->wanted_refs))
1204                        continue;
1205                /* process have line */
1206                if (parse_have(arg, &data->haves))
1207                        continue;
1208
1209                /* process args like thin-pack */
1210                if (!strcmp(arg, "thin-pack")) {
1211                        use_thin_pack = 1;
1212                        continue;
1213                }
1214                if (!strcmp(arg, "ofs-delta")) {
1215                        use_ofs_delta = 1;
1216                        continue;
1217                }
1218                if (!strcmp(arg, "no-progress")) {
1219                        no_progress = 1;
1220                        continue;
1221                }
1222                if (!strcmp(arg, "include-tag")) {
1223                        use_include_tag = 1;
1224                        continue;
1225                }
1226                if (!strcmp(arg, "done")) {
1227                        data->done = 1;
1228                        continue;
1229                }
1230
1231                /* Shallow related arguments */
1232                if (process_shallow(arg, &data->shallows))
1233                        continue;
1234                if (process_deepen(arg, &data->depth))
1235                        continue;
1236                if (process_deepen_since(arg, &data->deepen_since,
1237                                         &data->deepen_rev_list))
1238                        continue;
1239                if (process_deepen_not(arg, &data->deepen_not,
1240                                       &data->deepen_rev_list))
1241                        continue;
1242                if (!strcmp(arg, "deepen-relative")) {
1243                        data->deepen_relative = 1;
1244                        continue;
1245                }
1246
1247                if (allow_filter && skip_prefix(arg, "filter ", &p)) {
1248                        parse_list_objects_filter(&filter_options, p);
1249                        continue;
1250                }
1251
1252                /* ignore unknown lines maybe? */
1253                die("unexpected line: '%s'", arg);
1254        }
1255}
1256
1257static int process_haves(struct oid_array *haves, struct oid_array *common)
1258{
1259        int i;
1260
1261        /* Process haves */
1262        for (i = 0; i < haves->nr; i++) {
1263                const struct object_id *oid = &haves->oid[i];
1264                struct object *o;
1265                int we_knew_they_have = 0;
1266
1267                if (!has_object_file(oid))
1268                        continue;
1269
1270                oid_array_append(common, oid);
1271
1272                o = parse_object(the_repository, oid);
1273                if (!o)
1274                        die("oops (%s)", oid_to_hex(oid));
1275                if (o->type == OBJ_COMMIT) {
1276                        struct commit_list *parents;
1277                        struct commit *commit = (struct commit *)o;
1278                        if (o->flags & THEY_HAVE)
1279                                we_knew_they_have = 1;
1280                        else
1281                                o->flags |= THEY_HAVE;
1282                        if (!oldest_have || (commit->date < oldest_have))
1283                                oldest_have = commit->date;
1284                        for (parents = commit->parents;
1285                             parents;
1286                             parents = parents->next)
1287                                parents->item->object.flags |= THEY_HAVE;
1288                }
1289                if (!we_knew_they_have)
1290                        add_object_array(o, NULL, &have_obj);
1291        }
1292
1293        return 0;
1294}
1295
1296static int send_acks(struct oid_array *acks, struct strbuf *response)
1297{
1298        int i;
1299
1300        packet_buf_write(response, "acknowledgments\n");
1301
1302        /* Send Acks */
1303        if (!acks->nr)
1304                packet_buf_write(response, "NAK\n");
1305
1306        for (i = 0; i < acks->nr; i++) {
1307                packet_buf_write(response, "ACK %s\n",
1308                                 oid_to_hex(&acks->oid[i]));
1309        }
1310
1311        if (ok_to_give_up()) {
1312                /* Send Ready */
1313                packet_buf_write(response, "ready\n");
1314                return 1;
1315        }
1316
1317        return 0;
1318}
1319
1320static int process_haves_and_send_acks(struct upload_pack_data *data)
1321{
1322        struct oid_array common = OID_ARRAY_INIT;
1323        struct strbuf response = STRBUF_INIT;
1324        int ret = 0;
1325
1326        process_haves(&data->haves, &common);
1327        if (data->done) {
1328                ret = 1;
1329        } else if (send_acks(&common, &response)) {
1330                packet_buf_delim(&response);
1331                ret = 1;
1332        } else {
1333                /* Add Flush */
1334                packet_buf_flush(&response);
1335                ret = 0;
1336        }
1337
1338        /* Send response */
1339        write_or_die(1, response.buf, response.len);
1340        strbuf_release(&response);
1341
1342        oid_array_clear(&data->haves);
1343        oid_array_clear(&common);
1344        return ret;
1345}
1346
1347static void send_wanted_ref_info(struct upload_pack_data *data)
1348{
1349        const struct string_list_item *item;
1350
1351        if (!data->wanted_refs.nr)
1352                return;
1353
1354        packet_write_fmt(1, "wanted-refs\n");
1355
1356        for_each_string_list_item(item, &data->wanted_refs) {
1357                packet_write_fmt(1, "%s %s\n",
1358                                 oid_to_hex(item->util),
1359                                 item->string);
1360        }
1361
1362        packet_delim(1);
1363}
1364
1365static void send_shallow_info(struct upload_pack_data *data)
1366{
1367        /* No shallow info needs to be sent */
1368        if (!data->depth && !data->deepen_rev_list && !data->shallows.nr &&
1369            !is_repository_shallow(the_repository))
1370                return;
1371
1372        packet_write_fmt(1, "shallow-info\n");
1373
1374        if (!send_shallow_list(data->depth, data->deepen_rev_list,
1375                               data->deepen_since, &data->deepen_not,
1376                               &data->shallows) &&
1377            is_repository_shallow(the_repository))
1378                deepen(INFINITE_DEPTH, data->deepen_relative, &data->shallows);
1379
1380        packet_delim(1);
1381}
1382
1383enum fetch_state {
1384        FETCH_PROCESS_ARGS = 0,
1385        FETCH_SEND_ACKS,
1386        FETCH_SEND_PACK,
1387        FETCH_DONE,
1388};
1389
1390int upload_pack_v2(struct repository *r, struct argv_array *keys,
1391                   struct packet_reader *request)
1392{
1393        enum fetch_state state = FETCH_PROCESS_ARGS;
1394        struct upload_pack_data data;
1395
1396        git_config(upload_pack_config, NULL);
1397
1398        upload_pack_data_init(&data);
1399        use_sideband = LARGE_PACKET_MAX;
1400
1401        while (state != FETCH_DONE) {
1402                switch (state) {
1403                case FETCH_PROCESS_ARGS:
1404                        process_args(request, &data);
1405
1406                        if (!want_obj.nr) {
1407                                /*
1408                                 * Request didn't contain any 'want' lines,
1409                                 * guess they didn't want anything.
1410                                 */
1411                                state = FETCH_DONE;
1412                        } else if (data.haves.nr) {
1413                                /*
1414                                 * Request had 'have' lines, so lets ACK them.
1415                                 */
1416                                state = FETCH_SEND_ACKS;
1417                        } else {
1418                                /*
1419                                 * Request had 'want's but no 'have's so we can
1420                                 * immedietly go to construct and send a pack.
1421                                 */
1422                                state = FETCH_SEND_PACK;
1423                        }
1424                        break;
1425                case FETCH_SEND_ACKS:
1426                        if (process_haves_and_send_acks(&data))
1427                                state = FETCH_SEND_PACK;
1428                        else
1429                                state = FETCH_DONE;
1430                        break;
1431                case FETCH_SEND_PACK:
1432                        send_wanted_ref_info(&data);
1433                        send_shallow_info(&data);
1434
1435                        packet_write_fmt(1, "packfile\n");
1436                        create_pack_file();
1437                        state = FETCH_DONE;
1438                        break;
1439                case FETCH_DONE:
1440                        continue;
1441                }
1442        }
1443
1444        upload_pack_data_clear(&data);
1445        return 0;
1446}
1447
1448int upload_pack_advertise(struct repository *r,
1449                          struct strbuf *value)
1450{
1451        if (value) {
1452                int allow_filter_value;
1453                int allow_ref_in_want;
1454
1455                strbuf_addstr(value, "shallow");
1456
1457                if (!repo_config_get_bool(the_repository,
1458                                         "uploadpack.allowfilter",
1459                                         &allow_filter_value) &&
1460                    allow_filter_value)
1461                        strbuf_addstr(value, " filter");
1462
1463                if (!repo_config_get_bool(the_repository,
1464                                         "uploadpack.allowrefinwant",
1465                                         &allow_ref_in_want) &&
1466                    allow_ref_in_want)
1467                        strbuf_addstr(value, " ref-in-want");
1468        }
1469
1470        return 1;
1471}