upload-pack.con commit Merge branch 'sg/completion-ctags' (ccf680d)
   1#include "cache.h"
   2#include "refs.h"
   3#include "pkt-line.h"
   4#include "sideband.h"
   5#include "tag.h"
   6#include "object.h"
   7#include "commit.h"
   8#include "exec_cmd.h"
   9#include "diff.h"
  10#include "revision.h"
  11#include "list-objects.h"
  12#include "run-command.h"
  13#include "connect.h"
  14#include "sigchain.h"
  15#include "version.h"
  16#include "string-list.h"
  17#include "parse-options.h"
  18#include "argv-array.h"
  19#include "prio-queue.h"
  20
  21static const char * const upload_pack_usage[] = {
  22        N_("git upload-pack [<options>] <dir>"),
  23        NULL
  24};
  25
  26/* Remember to update object flag allocation in object.h */
  27#define THEY_HAVE       (1u << 11)
  28#define OUR_REF         (1u << 12)
  29#define WANTED          (1u << 13)
  30#define COMMON_KNOWN    (1u << 14)
  31#define REACHABLE       (1u << 15)
  32
  33#define SHALLOW         (1u << 16)
  34#define NOT_SHALLOW     (1u << 17)
  35#define CLIENT_SHALLOW  (1u << 18)
  36#define HIDDEN_REF      (1u << 19)
  37
  38static unsigned long oldest_have;
  39
  40static int deepen_relative;
  41static int multi_ack;
  42static int no_done;
  43static int use_thin_pack, use_ofs_delta, use_include_tag;
  44static int no_progress, daemon_mode;
  45/* Allow specifying sha1 if it is a ref tip. */
  46#define ALLOW_TIP_SHA1  01
  47/* Allow request of a sha1 if it is reachable from a ref (possibly hidden ref). */
  48#define ALLOW_REACHABLE_SHA1    02
  49/* Allow request of any sha1. Implies ALLOW_TIP_SHA1 and ALLOW_REACHABLE_SHA1. */
  50#define ALLOW_ANY_SHA1  07
  51static unsigned int allow_unadvertised_object_request;
  52static int shallow_nr;
  53static struct object_array have_obj;
  54static struct object_array want_obj;
  55static struct object_array extra_edge_obj;
  56static unsigned int timeout;
  57static int keepalive = 5;
  58/* 0 for no sideband,
  59 * otherwise maximum packet size (up to 65520 bytes).
  60 */
  61static int use_sideband;
  62static int advertise_refs;
  63static int stateless_rpc;
  64static const char *pack_objects_hook;
  65
  66static void reset_timeout(void)
  67{
  68        alarm(timeout);
  69}
  70
  71static void send_client_data(int fd, const char *data, ssize_t sz)
  72{
  73        if (use_sideband) {
  74                send_sideband(1, fd, data, sz, use_sideband);
  75                return;
  76        }
  77        if (fd == 3)
  78                /* emergency quit */
  79                fd = 2;
  80        if (fd == 2) {
  81                /* XXX: are we happy to lose stuff here? */
  82                xwrite(fd, data, sz);
  83                return;
  84        }
  85        write_or_die(fd, data, sz);
  86}
  87
  88static int write_one_shallow(const struct commit_graft *graft, void *cb_data)
  89{
  90        FILE *fp = cb_data;
  91        if (graft->nr_parent == -1)
  92                fprintf(fp, "--shallow %s\n", oid_to_hex(&graft->oid));
  93        return 0;
  94}
  95
  96static void create_pack_file(void)
  97{
  98        struct child_process pack_objects = CHILD_PROCESS_INIT;
  99        char data[8193], progress[128];
 100        char abort_msg[] = "aborting due to possible repository "
 101                "corruption on the remote side.";
 102        int buffered = -1;
 103        ssize_t sz;
 104        int i;
 105        FILE *pipe_fd;
 106
 107        if (!pack_objects_hook)
 108                pack_objects.git_cmd = 1;
 109        else {
 110                argv_array_push(&pack_objects.args, pack_objects_hook);
 111                argv_array_push(&pack_objects.args, "git");
 112                pack_objects.use_shell = 1;
 113        }
 114
 115        if (shallow_nr) {
 116                argv_array_push(&pack_objects.args, "--shallow-file");
 117                argv_array_push(&pack_objects.args, "");
 118        }
 119        argv_array_push(&pack_objects.args, "pack-objects");
 120        argv_array_push(&pack_objects.args, "--revs");
 121        if (use_thin_pack)
 122                argv_array_push(&pack_objects.args, "--thin");
 123
 124        argv_array_push(&pack_objects.args, "--stdout");
 125        if (shallow_nr)
 126                argv_array_push(&pack_objects.args, "--shallow");
 127        if (!no_progress)
 128                argv_array_push(&pack_objects.args, "--progress");
 129        if (use_ofs_delta)
 130                argv_array_push(&pack_objects.args, "--delta-base-offset");
 131        if (use_include_tag)
 132                argv_array_push(&pack_objects.args, "--include-tag");
 133
 134        pack_objects.in = -1;
 135        pack_objects.out = -1;
 136        pack_objects.err = -1;
 137
 138        if (start_command(&pack_objects))
 139                die("git upload-pack: unable to fork git-pack-objects");
 140
 141        pipe_fd = xfdopen(pack_objects.in, "w");
 142
 143        if (shallow_nr)
 144                for_each_commit_graft(write_one_shallow, pipe_fd);
 145
 146        for (i = 0; i < want_obj.nr; i++)
 147                fprintf(pipe_fd, "%s\n",
 148                        oid_to_hex(&want_obj.objects[i].item->oid));
 149        fprintf(pipe_fd, "--not\n");
 150        for (i = 0; i < have_obj.nr; i++)
 151                fprintf(pipe_fd, "%s\n",
 152                        oid_to_hex(&have_obj.objects[i].item->oid));
 153        for (i = 0; i < extra_edge_obj.nr; i++)
 154                fprintf(pipe_fd, "%s\n",
 155                        oid_to_hex(&extra_edge_obj.objects[i].item->oid));
 156        fprintf(pipe_fd, "\n");
 157        fflush(pipe_fd);
 158        fclose(pipe_fd);
 159
 160        /* We read from pack_objects.err to capture stderr output for
 161         * progress bar, and pack_objects.out to capture the pack data.
 162         */
 163
 164        while (1) {
 165                struct pollfd pfd[2];
 166                int pe, pu, pollsize;
 167                int ret;
 168
 169                reset_timeout();
 170
 171                pollsize = 0;
 172                pe = pu = -1;
 173
 174                if (0 <= pack_objects.out) {
 175                        pfd[pollsize].fd = pack_objects.out;
 176                        pfd[pollsize].events = POLLIN;
 177                        pu = pollsize;
 178                        pollsize++;
 179                }
 180                if (0 <= pack_objects.err) {
 181                        pfd[pollsize].fd = pack_objects.err;
 182                        pfd[pollsize].events = POLLIN;
 183                        pe = pollsize;
 184                        pollsize++;
 185                }
 186
 187                if (!pollsize)
 188                        break;
 189
 190                ret = poll(pfd, pollsize,
 191                        keepalive < 0 ? -1 : 1000 * keepalive);
 192
 193                if (ret < 0) {
 194                        if (errno != EINTR) {
 195                                error_errno("poll failed, resuming");
 196                                sleep(1);
 197                        }
 198                        continue;
 199                }
 200                if (0 <= pe && (pfd[pe].revents & (POLLIN|POLLHUP))) {
 201                        /* Status ready; we ship that in the side-band
 202                         * or dump to the standard error.
 203                         */
 204                        sz = xread(pack_objects.err, progress,
 205                                  sizeof(progress));
 206                        if (0 < sz)
 207                                send_client_data(2, progress, sz);
 208                        else if (sz == 0) {
 209                                close(pack_objects.err);
 210                                pack_objects.err = -1;
 211                        }
 212                        else
 213                                goto fail;
 214                        /* give priority to status messages */
 215                        continue;
 216                }
 217                if (0 <= pu && (pfd[pu].revents & (POLLIN|POLLHUP))) {
 218                        /* Data ready; we keep the last byte to ourselves
 219                         * in case we detect broken rev-list, so that we
 220                         * can leave the stream corrupted.  This is
 221                         * unfortunate -- unpack-objects would happily
 222                         * accept a valid packdata with trailing garbage,
 223                         * so appending garbage after we pass all the
 224                         * pack data is not good enough to signal
 225                         * breakage to downstream.
 226                         */
 227                        char *cp = data;
 228                        ssize_t outsz = 0;
 229                        if (0 <= buffered) {
 230                                *cp++ = buffered;
 231                                outsz++;
 232                        }
 233                        sz = xread(pack_objects.out, cp,
 234                                  sizeof(data) - outsz);
 235                        if (0 < sz)
 236                                ;
 237                        else if (sz == 0) {
 238                                close(pack_objects.out);
 239                                pack_objects.out = -1;
 240                        }
 241                        else
 242                                goto fail;
 243                        sz += outsz;
 244                        if (1 < sz) {
 245                                buffered = data[sz-1] & 0xFF;
 246                                sz--;
 247                        }
 248                        else
 249                                buffered = -1;
 250                        send_client_data(1, data, sz);
 251                }
 252
 253                /*
 254                 * We hit the keepalive timeout without saying anything; send
 255                 * an empty message on the data sideband just to let the other
 256                 * side know we're still working on it, but don't have any data
 257                 * yet.
 258                 *
 259                 * If we don't have a sideband channel, there's no room in the
 260                 * protocol to say anything, so those clients are just out of
 261                 * luck.
 262                 */
 263                if (!ret && use_sideband) {
 264                        static const char buf[] = "0005\1";
 265                        write_or_die(1, buf, 5);
 266                }
 267        }
 268
 269        if (finish_command(&pack_objects)) {
 270                error("git upload-pack: git-pack-objects died with error.");
 271                goto fail;
 272        }
 273
 274        /* flush the data */
 275        if (0 <= buffered) {
 276                data[0] = buffered;
 277                send_client_data(1, data, 1);
 278                fprintf(stderr, "flushed.\n");
 279        }
 280        if (use_sideband)
 281                packet_flush(1);
 282        return;
 283
 284 fail:
 285        send_client_data(3, abort_msg, sizeof(abort_msg));
 286        die("git upload-pack: %s", abort_msg);
 287}
 288
 289static int got_sha1(const char *hex, unsigned char *sha1)
 290{
 291        struct object *o;
 292        int we_knew_they_have = 0;
 293
 294        if (get_sha1_hex(hex, sha1))
 295                die("git upload-pack: expected SHA1 object, got '%s'", hex);
 296        if (!has_sha1_file(sha1))
 297                return -1;
 298
 299        o = parse_object(sha1);
 300        if (!o)
 301                die("oops (%s)", sha1_to_hex(sha1));
 302        if (o->type == OBJ_COMMIT) {
 303                struct commit_list *parents;
 304                struct commit *commit = (struct commit *)o;
 305                if (o->flags & THEY_HAVE)
 306                        we_knew_they_have = 1;
 307                else
 308                        o->flags |= THEY_HAVE;
 309                if (!oldest_have || (commit->date < oldest_have))
 310                        oldest_have = commit->date;
 311                for (parents = commit->parents;
 312                     parents;
 313                     parents = parents->next)
 314                        parents->item->object.flags |= THEY_HAVE;
 315        }
 316        if (!we_knew_they_have) {
 317                add_object_array(o, NULL, &have_obj);
 318                return 1;
 319        }
 320        return 0;
 321}
 322
 323static int reachable(struct commit *want)
 324{
 325        struct prio_queue work = { compare_commits_by_commit_date };
 326
 327        prio_queue_put(&work, want);
 328        while (work.nr) {
 329                struct commit_list *list;
 330                struct commit *commit = prio_queue_get(&work);
 331
 332                if (commit->object.flags & THEY_HAVE) {
 333                        want->object.flags |= COMMON_KNOWN;
 334                        break;
 335                }
 336                if (!commit->object.parsed)
 337                        parse_object(commit->object.oid.hash);
 338                if (commit->object.flags & REACHABLE)
 339                        continue;
 340                commit->object.flags |= REACHABLE;
 341                if (commit->date < oldest_have)
 342                        continue;
 343                for (list = commit->parents; list; list = list->next) {
 344                        struct commit *parent = list->item;
 345                        if (!(parent->object.flags & REACHABLE))
 346                                prio_queue_put(&work, parent);
 347                }
 348        }
 349        want->object.flags |= REACHABLE;
 350        clear_commit_marks(want, REACHABLE);
 351        clear_prio_queue(&work);
 352        return (want->object.flags & COMMON_KNOWN);
 353}
 354
 355static int ok_to_give_up(void)
 356{
 357        int i;
 358
 359        if (!have_obj.nr)
 360                return 0;
 361
 362        for (i = 0; i < want_obj.nr; i++) {
 363                struct object *want = want_obj.objects[i].item;
 364
 365                if (want->flags & COMMON_KNOWN)
 366                        continue;
 367                want = deref_tag(want, "a want line", 0);
 368                if (!want || want->type != OBJ_COMMIT) {
 369                        /* no way to tell if this is reachable by
 370                         * looking at the ancestry chain alone, so
 371                         * leave a note to ourselves not to worry about
 372                         * this object anymore.
 373                         */
 374                        want_obj.objects[i].item->flags |= COMMON_KNOWN;
 375                        continue;
 376                }
 377                if (!reachable((struct commit *)want))
 378                        return 0;
 379        }
 380        return 1;
 381}
 382
 383static int get_common_commits(void)
 384{
 385        unsigned char sha1[20];
 386        char last_hex[41];
 387        int got_common = 0;
 388        int got_other = 0;
 389        int sent_ready = 0;
 390
 391        save_commit_buffer = 0;
 392
 393        for (;;) {
 394                char *line = packet_read_line(0, NULL);
 395                const char *arg;
 396
 397                reset_timeout();
 398
 399                if (!line) {
 400                        if (multi_ack == 2 && got_common
 401                            && !got_other && ok_to_give_up()) {
 402                                sent_ready = 1;
 403                                packet_write_fmt(1, "ACK %s ready\n", last_hex);
 404                        }
 405                        if (have_obj.nr == 0 || multi_ack)
 406                                packet_write_fmt(1, "NAK\n");
 407
 408                        if (no_done && sent_ready) {
 409                                packet_write_fmt(1, "ACK %s\n", last_hex);
 410                                return 0;
 411                        }
 412                        if (stateless_rpc)
 413                                exit(0);
 414                        got_common = 0;
 415                        got_other = 0;
 416                        continue;
 417                }
 418                if (skip_prefix(line, "have ", &arg)) {
 419                        switch (got_sha1(arg, sha1)) {
 420                        case -1: /* they have what we do not */
 421                                got_other = 1;
 422                                if (multi_ack && ok_to_give_up()) {
 423                                        const char *hex = sha1_to_hex(sha1);
 424                                        if (multi_ack == 2) {
 425                                                sent_ready = 1;
 426                                                packet_write_fmt(1, "ACK %s ready\n", hex);
 427                                        } else
 428                                                packet_write_fmt(1, "ACK %s continue\n", hex);
 429                                }
 430                                break;
 431                        default:
 432                                got_common = 1;
 433                                memcpy(last_hex, sha1_to_hex(sha1), 41);
 434                                if (multi_ack == 2)
 435                                        packet_write_fmt(1, "ACK %s common\n", last_hex);
 436                                else if (multi_ack)
 437                                        packet_write_fmt(1, "ACK %s continue\n", last_hex);
 438                                else if (have_obj.nr == 1)
 439                                        packet_write_fmt(1, "ACK %s\n", last_hex);
 440                                break;
 441                        }
 442                        continue;
 443                }
 444                if (!strcmp(line, "done")) {
 445                        if (have_obj.nr > 0) {
 446                                if (multi_ack)
 447                                        packet_write_fmt(1, "ACK %s\n", last_hex);
 448                                return 0;
 449                        }
 450                        packet_write_fmt(1, "NAK\n");
 451                        return -1;
 452                }
 453                die("git upload-pack: expected SHA1 list, got '%s'", line);
 454        }
 455}
 456
 457static int is_our_ref(struct object *o)
 458{
 459        int allow_hidden_ref = (allow_unadvertised_object_request &
 460                        (ALLOW_TIP_SHA1 | ALLOW_REACHABLE_SHA1));
 461        return o->flags & ((allow_hidden_ref ? HIDDEN_REF : 0) | OUR_REF);
 462}
 463
 464/*
 465 * on successful case, it's up to the caller to close cmd->out
 466 */
 467static int do_reachable_revlist(struct child_process *cmd,
 468                                struct object_array *src,
 469                                struct object_array *reachable)
 470{
 471        static const char *argv[] = {
 472                "rev-list", "--stdin", NULL,
 473        };
 474        struct object *o;
 475        char namebuf[42]; /* ^ + SHA-1 + LF */
 476        int i;
 477
 478        cmd->argv = argv;
 479        cmd->git_cmd = 1;
 480        cmd->no_stderr = 1;
 481        cmd->in = -1;
 482        cmd->out = -1;
 483
 484        /*
 485         * If the next rev-list --stdin encounters an unknown commit,
 486         * it terminates, which will cause SIGPIPE in the write loop
 487         * below.
 488         */
 489        sigchain_push(SIGPIPE, SIG_IGN);
 490
 491        if (start_command(cmd))
 492                goto error;
 493
 494        namebuf[0] = '^';
 495        namebuf[41] = '\n';
 496        for (i = get_max_object_index(); 0 < i; ) {
 497                o = get_indexed_object(--i);
 498                if (!o)
 499                        continue;
 500                if (reachable && o->type == OBJ_COMMIT)
 501                        o->flags &= ~TMP_MARK;
 502                if (!is_our_ref(o))
 503                        continue;
 504                memcpy(namebuf + 1, oid_to_hex(&o->oid), GIT_SHA1_HEXSZ);
 505                if (write_in_full(cmd->in, namebuf, 42) < 0)
 506                        goto error;
 507        }
 508        namebuf[40] = '\n';
 509        for (i = 0; i < src->nr; i++) {
 510                o = src->objects[i].item;
 511                if (is_our_ref(o)) {
 512                        if (reachable)
 513                                add_object_array(o, NULL, reachable);
 514                        continue;
 515                }
 516                if (reachable && o->type == OBJ_COMMIT)
 517                        o->flags |= TMP_MARK;
 518                memcpy(namebuf, oid_to_hex(&o->oid), GIT_SHA1_HEXSZ);
 519                if (write_in_full(cmd->in, namebuf, 41) < 0)
 520                        goto error;
 521        }
 522        close(cmd->in);
 523        cmd->in = -1;
 524        sigchain_pop(SIGPIPE);
 525
 526        return 0;
 527
 528error:
 529        sigchain_pop(SIGPIPE);
 530
 531        if (cmd->in >= 0)
 532                close(cmd->in);
 533        if (cmd->out >= 0)
 534                close(cmd->out);
 535        return -1;
 536}
 537
 538static int get_reachable_list(struct object_array *src,
 539                              struct object_array *reachable)
 540{
 541        struct child_process cmd = CHILD_PROCESS_INIT;
 542        int i;
 543        struct object *o;
 544        char namebuf[42]; /* ^ + SHA-1 + LF */
 545
 546        if (do_reachable_revlist(&cmd, src, reachable) < 0)
 547                return -1;
 548
 549        while ((i = read_in_full(cmd.out, namebuf, 41)) == 41) {
 550                struct object_id sha1;
 551
 552                if (namebuf[40] != '\n' || get_oid_hex(namebuf, &sha1))
 553                        break;
 554
 555                o = lookup_object(sha1.hash);
 556                if (o && o->type == OBJ_COMMIT) {
 557                        o->flags &= ~TMP_MARK;
 558                }
 559        }
 560        for (i = get_max_object_index(); 0 < i; i--) {
 561                o = get_indexed_object(i - 1);
 562                if (o && o->type == OBJ_COMMIT &&
 563                    (o->flags & TMP_MARK)) {
 564                        add_object_array(o, NULL, reachable);
 565                                o->flags &= ~TMP_MARK;
 566                }
 567        }
 568        close(cmd.out);
 569
 570        if (finish_command(&cmd))
 571                return -1;
 572
 573        return 0;
 574}
 575
 576static int has_unreachable(struct object_array *src)
 577{
 578        struct child_process cmd = CHILD_PROCESS_INIT;
 579        char buf[1];
 580        int i;
 581
 582        if (do_reachable_revlist(&cmd, src, NULL) < 0)
 583                return 1;
 584
 585        /*
 586         * The commits out of the rev-list are not ancestors of
 587         * our ref.
 588         */
 589        i = read_in_full(cmd.out, buf, 1);
 590        if (i)
 591                goto error;
 592        close(cmd.out);
 593        cmd.out = -1;
 594
 595        /*
 596         * rev-list may have died by encountering a bad commit
 597         * in the history, in which case we do want to bail out
 598         * even when it showed no commit.
 599         */
 600        if (finish_command(&cmd))
 601                goto error;
 602
 603        /* All the non-tip ones are ancestors of what we advertised */
 604        return 0;
 605
 606error:
 607        sigchain_pop(SIGPIPE);
 608        if (cmd.out >= 0)
 609                close(cmd.out);
 610        return 1;
 611}
 612
 613static void check_non_tip(void)
 614{
 615        int i;
 616
 617        /*
 618         * In the normal in-process case without
 619         * uploadpack.allowReachableSHA1InWant,
 620         * non-tip requests can never happen.
 621         */
 622        if (!stateless_rpc && !(allow_unadvertised_object_request & ALLOW_REACHABLE_SHA1))
 623                goto error;
 624        if (!has_unreachable(&want_obj))
 625                /* All the non-tip ones are ancestors of what we advertised */
 626                return;
 627
 628error:
 629        /* Pick one of them (we know there at least is one) */
 630        for (i = 0; i < want_obj.nr; i++) {
 631                struct object *o = want_obj.objects[i].item;
 632                if (!is_our_ref(o))
 633                        die("git upload-pack: not our ref %s",
 634                            oid_to_hex(&o->oid));
 635        }
 636}
 637
 638static void send_shallow(struct commit_list *result)
 639{
 640        while (result) {
 641                struct object *object = &result->item->object;
 642                if (!(object->flags & (CLIENT_SHALLOW|NOT_SHALLOW))) {
 643                        packet_write_fmt(1, "shallow %s",
 644                                         oid_to_hex(&object->oid));
 645                        register_shallow(object->oid.hash);
 646                        shallow_nr++;
 647                }
 648                result = result->next;
 649        }
 650}
 651
 652static void send_unshallow(const struct object_array *shallows)
 653{
 654        int i;
 655
 656        for (i = 0; i < shallows->nr; i++) {
 657                struct object *object = shallows->objects[i].item;
 658                if (object->flags & NOT_SHALLOW) {
 659                        struct commit_list *parents;
 660                        packet_write_fmt(1, "unshallow %s",
 661                                         oid_to_hex(&object->oid));
 662                        object->flags &= ~CLIENT_SHALLOW;
 663                        /*
 664                         * We want to _register_ "object" as shallow, but we
 665                         * also need to traverse object's parents to deepen a
 666                         * shallow clone. Unregister it for now so we can
 667                         * parse and add the parents to the want list, then
 668                         * re-register it.
 669                         */
 670                        unregister_shallow(object->oid.hash);
 671                        object->parsed = 0;
 672                        parse_commit_or_die((struct commit *)object);
 673                        parents = ((struct commit *)object)->parents;
 674                        while (parents) {
 675                                add_object_array(&parents->item->object,
 676                                                 NULL, &want_obj);
 677                                parents = parents->next;
 678                        }
 679                        add_object_array(object, NULL, &extra_edge_obj);
 680                }
 681                /* make sure commit traversal conforms to client */
 682                register_shallow(object->oid.hash);
 683        }
 684}
 685
 686static void deepen(int depth, int deepen_relative,
 687                   struct object_array *shallows)
 688{
 689        if (depth == INFINITE_DEPTH && !is_repository_shallow()) {
 690                int i;
 691
 692                for (i = 0; i < shallows->nr; i++) {
 693                        struct object *object = shallows->objects[i].item;
 694                        object->flags |= NOT_SHALLOW;
 695                }
 696        } else if (deepen_relative) {
 697                struct object_array reachable_shallows = OBJECT_ARRAY_INIT;
 698                struct commit_list *result;
 699
 700                get_reachable_list(shallows, &reachable_shallows);
 701                result = get_shallow_commits(&reachable_shallows,
 702                                             depth + 1,
 703                                             SHALLOW, NOT_SHALLOW);
 704                send_shallow(result);
 705                free_commit_list(result);
 706                object_array_clear(&reachable_shallows);
 707        } else {
 708                struct commit_list *result;
 709
 710                result = get_shallow_commits(&want_obj, depth,
 711                                             SHALLOW, NOT_SHALLOW);
 712                send_shallow(result);
 713                free_commit_list(result);
 714        }
 715
 716        send_unshallow(shallows);
 717        packet_flush(1);
 718}
 719
 720static void deepen_by_rev_list(int ac, const char **av,
 721                               struct object_array *shallows)
 722{
 723        struct commit_list *result;
 724
 725        result = get_shallow_commits_by_rev_list(ac, av, SHALLOW, NOT_SHALLOW);
 726        send_shallow(result);
 727        free_commit_list(result);
 728        send_unshallow(shallows);
 729        packet_flush(1);
 730}
 731
 732static void receive_needs(void)
 733{
 734        struct object_array shallows = OBJECT_ARRAY_INIT;
 735        struct string_list deepen_not = STRING_LIST_INIT_DUP;
 736        int depth = 0;
 737        int has_non_tip = 0;
 738        unsigned long deepen_since = 0;
 739        int deepen_rev_list = 0;
 740
 741        shallow_nr = 0;
 742        for (;;) {
 743                struct object *o;
 744                const char *features;
 745                unsigned char sha1_buf[20];
 746                char *line = packet_read_line(0, NULL);
 747                const char *arg;
 748
 749                reset_timeout();
 750                if (!line)
 751                        break;
 752
 753                if (skip_prefix(line, "shallow ", &arg)) {
 754                        unsigned char sha1[20];
 755                        struct object *object;
 756                        if (get_sha1_hex(arg, sha1))
 757                                die("invalid shallow line: %s", line);
 758                        object = parse_object(sha1);
 759                        if (!object)
 760                                continue;
 761                        if (object->type != OBJ_COMMIT)
 762                                die("invalid shallow object %s", sha1_to_hex(sha1));
 763                        if (!(object->flags & CLIENT_SHALLOW)) {
 764                                object->flags |= CLIENT_SHALLOW;
 765                                add_object_array(object, NULL, &shallows);
 766                        }
 767                        continue;
 768                }
 769                if (skip_prefix(line, "deepen ", &arg)) {
 770                        char *end = NULL;
 771                        depth = strtol(arg, &end, 0);
 772                        if (!end || *end || depth <= 0)
 773                                die("Invalid deepen: %s", line);
 774                        continue;
 775                }
 776                if (skip_prefix(line, "deepen-since ", &arg)) {
 777                        char *end = NULL;
 778                        deepen_since = strtoul(arg, &end, 0);
 779                        if (!end || *end || !deepen_since ||
 780                            /* revisions.c's max_age -1 is special */
 781                            deepen_since == -1)
 782                                die("Invalid deepen-since: %s", line);
 783                        deepen_rev_list = 1;
 784                        continue;
 785                }
 786                if (skip_prefix(line, "deepen-not ", &arg)) {
 787                        char *ref = NULL;
 788                        unsigned char sha1[20];
 789                        if (expand_ref(arg, strlen(arg), sha1, &ref) != 1)
 790                                die("git upload-pack: ambiguous deepen-not: %s", line);
 791                        string_list_append(&deepen_not, ref);
 792                        free(ref);
 793                        deepen_rev_list = 1;
 794                        continue;
 795                }
 796                if (!skip_prefix(line, "want ", &arg) ||
 797                    get_sha1_hex(arg, sha1_buf))
 798                        die("git upload-pack: protocol error, "
 799                            "expected to get sha, not '%s'", line);
 800
 801                features = arg + 40;
 802
 803                if (parse_feature_request(features, "deepen-relative"))
 804                        deepen_relative = 1;
 805                if (parse_feature_request(features, "multi_ack_detailed"))
 806                        multi_ack = 2;
 807                else if (parse_feature_request(features, "multi_ack"))
 808                        multi_ack = 1;
 809                if (parse_feature_request(features, "no-done"))
 810                        no_done = 1;
 811                if (parse_feature_request(features, "thin-pack"))
 812                        use_thin_pack = 1;
 813                if (parse_feature_request(features, "ofs-delta"))
 814                        use_ofs_delta = 1;
 815                if (parse_feature_request(features, "side-band-64k"))
 816                        use_sideband = LARGE_PACKET_MAX;
 817                else if (parse_feature_request(features, "side-band"))
 818                        use_sideband = DEFAULT_PACKET_MAX;
 819                if (parse_feature_request(features, "no-progress"))
 820                        no_progress = 1;
 821                if (parse_feature_request(features, "include-tag"))
 822                        use_include_tag = 1;
 823
 824                o = parse_object(sha1_buf);
 825                if (!o) {
 826                        packet_write_fmt(1,
 827                                         "ERR upload-pack: not our ref %s",
 828                                         sha1_to_hex(sha1_buf));
 829                        die("git upload-pack: not our ref %s",
 830                            sha1_to_hex(sha1_buf));
 831                }
 832                if (!(o->flags & WANTED)) {
 833                        o->flags |= WANTED;
 834                        if (!((allow_unadvertised_object_request & ALLOW_ANY_SHA1) == ALLOW_ANY_SHA1
 835                              || is_our_ref(o)))
 836                                has_non_tip = 1;
 837                        add_object_array(o, NULL, &want_obj);
 838                }
 839        }
 840
 841        /*
 842         * We have sent all our refs already, and the other end
 843         * should have chosen out of them. When we are operating
 844         * in the stateless RPC mode, however, their choice may
 845         * have been based on the set of older refs advertised
 846         * by another process that handled the initial request.
 847         */
 848        if (has_non_tip)
 849                check_non_tip();
 850
 851        if (!use_sideband && daemon_mode)
 852                no_progress = 1;
 853
 854        if (depth == 0 && !deepen_rev_list && shallows.nr == 0)
 855                return;
 856        if (depth > 0 && deepen_rev_list)
 857                die("git upload-pack: deepen and deepen-since (or deepen-not) cannot be used together");
 858        if (depth > 0)
 859                deepen(depth, deepen_relative, &shallows);
 860        else if (deepen_rev_list) {
 861                struct argv_array av = ARGV_ARRAY_INIT;
 862                int i;
 863
 864                argv_array_push(&av, "rev-list");
 865                if (deepen_since)
 866                        argv_array_pushf(&av, "--max-age=%lu", deepen_since);
 867                if (deepen_not.nr) {
 868                        argv_array_push(&av, "--not");
 869                        for (i = 0; i < deepen_not.nr; i++) {
 870                                struct string_list_item *s = deepen_not.items + i;
 871                                argv_array_push(&av, s->string);
 872                        }
 873                        argv_array_push(&av, "--not");
 874                }
 875                for (i = 0; i < want_obj.nr; i++) {
 876                        struct object *o = want_obj.objects[i].item;
 877                        argv_array_push(&av, oid_to_hex(&o->oid));
 878                }
 879                deepen_by_rev_list(av.argc, av.argv, &shallows);
 880                argv_array_clear(&av);
 881        }
 882        else
 883                if (shallows.nr > 0) {
 884                        int i;
 885                        for (i = 0; i < shallows.nr; i++)
 886                                register_shallow(shallows.objects[i].item->oid.hash);
 887                }
 888
 889        shallow_nr += shallows.nr;
 890        free(shallows.objects);
 891}
 892
 893/* return non-zero if the ref is hidden, otherwise 0 */
 894static int mark_our_ref(const char *refname, const char *refname_full,
 895                        const struct object_id *oid)
 896{
 897        struct object *o = lookup_unknown_object(oid->hash);
 898
 899        if (ref_is_hidden(refname, refname_full)) {
 900                o->flags |= HIDDEN_REF;
 901                return 1;
 902        }
 903        o->flags |= OUR_REF;
 904        return 0;
 905}
 906
 907static int check_ref(const char *refname_full, const struct object_id *oid,
 908                     int flag, void *cb_data)
 909{
 910        const char *refname = strip_namespace(refname_full);
 911
 912        mark_our_ref(refname, refname_full, oid);
 913        return 0;
 914}
 915
 916static void format_symref_info(struct strbuf *buf, struct string_list *symref)
 917{
 918        struct string_list_item *item;
 919
 920        if (!symref->nr)
 921                return;
 922        for_each_string_list_item(item, symref)
 923                strbuf_addf(buf, " symref=%s:%s", item->string, (char *)item->util);
 924}
 925
 926static int send_ref(const char *refname, const struct object_id *oid,
 927                    int flag, void *cb_data)
 928{
 929        static const char *capabilities = "multi_ack thin-pack side-band"
 930                " side-band-64k ofs-delta shallow deepen-since deepen-not"
 931                " deepen-relative no-progress include-tag multi_ack_detailed";
 932        const char *refname_nons = strip_namespace(refname);
 933        struct object_id peeled;
 934
 935        if (mark_our_ref(refname_nons, refname, oid))
 936                return 0;
 937
 938        if (capabilities) {
 939                struct strbuf symref_info = STRBUF_INIT;
 940
 941                format_symref_info(&symref_info, cb_data);
 942                packet_write_fmt(1, "%s %s%c%s%s%s%s%s agent=%s\n",
 943                             oid_to_hex(oid), refname_nons,
 944                             0, capabilities,
 945                             (allow_unadvertised_object_request & ALLOW_TIP_SHA1) ?
 946                                     " allow-tip-sha1-in-want" : "",
 947                             (allow_unadvertised_object_request & ALLOW_REACHABLE_SHA1) ?
 948                                     " allow-reachable-sha1-in-want" : "",
 949                             stateless_rpc ? " no-done" : "",
 950                             symref_info.buf,
 951                             git_user_agent_sanitized());
 952                strbuf_release(&symref_info);
 953        } else {
 954                packet_write_fmt(1, "%s %s\n", oid_to_hex(oid), refname_nons);
 955        }
 956        capabilities = NULL;
 957        if (!peel_ref(refname, peeled.hash))
 958                packet_write_fmt(1, "%s %s^{}\n", oid_to_hex(&peeled), refname_nons);
 959        return 0;
 960}
 961
 962static int find_symref(const char *refname, const struct object_id *oid,
 963                       int flag, void *cb_data)
 964{
 965        const char *symref_target;
 966        struct string_list_item *item;
 967        struct object_id unused;
 968
 969        if ((flag & REF_ISSYMREF) == 0)
 970                return 0;
 971        symref_target = resolve_ref_unsafe(refname, 0, unused.hash, &flag);
 972        if (!symref_target || (flag & REF_ISSYMREF) == 0)
 973                die("'%s' is a symref but it is not?", refname);
 974        item = string_list_append(cb_data, refname);
 975        item->util = xstrdup(symref_target);
 976        return 0;
 977}
 978
 979static void upload_pack(void)
 980{
 981        struct string_list symref = STRING_LIST_INIT_DUP;
 982
 983        head_ref_namespaced(find_symref, &symref);
 984
 985        if (advertise_refs || !stateless_rpc) {
 986                reset_timeout();
 987                head_ref_namespaced(send_ref, &symref);
 988                for_each_namespaced_ref(send_ref, &symref);
 989                advertise_shallow_grafts(1);
 990                packet_flush(1);
 991        } else {
 992                head_ref_namespaced(check_ref, NULL);
 993                for_each_namespaced_ref(check_ref, NULL);
 994        }
 995        string_list_clear(&symref, 1);
 996        if (advertise_refs)
 997                return;
 998
 999        receive_needs();
1000        if (want_obj.nr) {
1001                get_common_commits();
1002                create_pack_file();
1003        }
1004}
1005
1006static int upload_pack_config(const char *var, const char *value, void *unused)
1007{
1008        if (!strcmp("uploadpack.allowtipsha1inwant", var)) {
1009                if (git_config_bool(var, value))
1010                        allow_unadvertised_object_request |= ALLOW_TIP_SHA1;
1011                else
1012                        allow_unadvertised_object_request &= ~ALLOW_TIP_SHA1;
1013        } else if (!strcmp("uploadpack.allowreachablesha1inwant", var)) {
1014                if (git_config_bool(var, value))
1015                        allow_unadvertised_object_request |= ALLOW_REACHABLE_SHA1;
1016                else
1017                        allow_unadvertised_object_request &= ~ALLOW_REACHABLE_SHA1;
1018        } else if (!strcmp("uploadpack.allowanysha1inwant", var)) {
1019                if (git_config_bool(var, value))
1020                        allow_unadvertised_object_request |= ALLOW_ANY_SHA1;
1021                else
1022                        allow_unadvertised_object_request &= ~ALLOW_ANY_SHA1;
1023        } else if (!strcmp("uploadpack.keepalive", var)) {
1024                keepalive = git_config_int(var, value);
1025                if (!keepalive)
1026                        keepalive = -1;
1027        } else if (current_config_scope() != CONFIG_SCOPE_REPO) {
1028                if (!strcmp("uploadpack.packobjectshook", var))
1029                        return git_config_string(&pack_objects_hook, var, value);
1030        }
1031        return parse_hide_refs_config(var, value, "uploadpack");
1032}
1033
1034int cmd_main(int argc, const char **argv)
1035{
1036        const char *dir;
1037        int strict = 0;
1038        struct option options[] = {
1039                OPT_BOOL(0, "stateless-rpc", &stateless_rpc,
1040                         N_("quit after a single request/response exchange")),
1041                OPT_BOOL(0, "advertise-refs", &advertise_refs,
1042                         N_("exit immediately after initial ref advertisement")),
1043                OPT_BOOL(0, "strict", &strict,
1044                         N_("do not try <directory>/.git/ if <directory> is no Git directory")),
1045                OPT_INTEGER(0, "timeout", &timeout,
1046                            N_("interrupt transfer after <n> seconds of inactivity")),
1047                OPT_END()
1048        };
1049
1050        packet_trace_identity("upload-pack");
1051        check_replace_refs = 0;
1052
1053        argc = parse_options(argc, argv, NULL, options, upload_pack_usage, 0);
1054
1055        if (argc != 1)
1056                usage_with_options(upload_pack_usage, options);
1057
1058        if (timeout)
1059                daemon_mode = 1;
1060
1061        setup_path();
1062
1063        dir = argv[0];
1064
1065        if (!enter_repo(dir, strict))
1066                die("'%s' does not appear to be a git repository", dir);
1067
1068        git_config(upload_pack_config, NULL);
1069        upload_pack();
1070        return 0;
1071}