Andrew's git / gitweb.git / builtin/receive-pack.c
?
builtin / receive-pack.con commit receive-pack: allow hooks to ignore its standard input stream (ec7dbd1)
   1#include "builtin.h"
   2#include "pack.h"
   3#include "refs.h"
   4#include "pkt-line.h"
   5#include "sideband.h"
   6#include "run-command.h"
   7#include "exec_cmd.h"
   8#include "commit.h"
   9#include "object.h"
  10#include "remote.h"
  11#include "connect.h"
  12#include "transport.h"
  13#include "string-list.h"
  14#include "sha1-array.h"
  15#include "connected.h"
  16#include "argv-array.h"
  17#include "version.h"
  18#include "sigchain.h"
  19
  20static const char receive_pack_usage[] = "git receive-pack <git-dir>";
  21
  22enum deny_action {
  23        DENY_UNCONFIGURED,
  24        DENY_IGNORE,
  25        DENY_WARN,
  26        DENY_REFUSE
  27};
  28
  29static int deny_deletes;
  30static int deny_non_fast_forwards;
  31static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
  32static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
  33static int receive_fsck_objects = -1;
  34static int transfer_fsck_objects = -1;
  35static int receive_unpack_limit = -1;
  36static int transfer_unpack_limit = -1;
  37static int unpack_limit = 100;
  38static int report_status;
  39static int use_sideband;
  40static int quiet;
  41static int prefer_ofs_delta = 1;
  42static int auto_update_server_info;
  43static int auto_gc = 1;
  44static int fix_thin = 1;
  45static const char *head_name;
  46static void *head_name_to_free;
  47static int sent_capabilities;
  48static int shallow_update;
  49static const char *alt_shallow_file;
  50
  51static enum deny_action parse_deny_action(const char *var, const char *value)
  52{
  53        if (value) {
  54                if (!strcasecmp(value, "ignore"))
  55                        return DENY_IGNORE;
  56                if (!strcasecmp(value, "warn"))
  57                        return DENY_WARN;
  58                if (!strcasecmp(value, "refuse"))
  59                        return DENY_REFUSE;
  60        }
  61        if (git_config_bool(var, value))
  62                return DENY_REFUSE;
  63        return DENY_IGNORE;
  64}
  65
  66static int receive_pack_config(const char *var, const char *value, void *cb)
  67{
  68        int status = parse_hide_refs_config(var, value, "receive");
  69
  70        if (status)
  71                return status;
  72
  73        if (strcmp(var, "receive.denydeletes") == 0) {
  74                deny_deletes = git_config_bool(var, value);
  75                return 0;
  76        }
  77
  78        if (strcmp(var, "receive.denynonfastforwards") == 0) {
  79                deny_non_fast_forwards = git_config_bool(var, value);
  80                return 0;
  81        }
  82
  83        if (strcmp(var, "receive.unpacklimit") == 0) {
  84                receive_unpack_limit = git_config_int(var, value);
  85                return 0;
  86        }
  87
  88        if (strcmp(var, "transfer.unpacklimit") == 0) {
  89                transfer_unpack_limit = git_config_int(var, value);
  90                return 0;
  91        }
  92
  93        if (strcmp(var, "receive.fsckobjects") == 0) {
  94                receive_fsck_objects = git_config_bool(var, value);
  95                return 0;
  96        }
  97
  98        if (strcmp(var, "transfer.fsckobjects") == 0) {
  99                transfer_fsck_objects = git_config_bool(var, value);
 100                return 0;
 101        }
 102
 103        if (!strcmp(var, "receive.denycurrentbranch")) {
 104                deny_current_branch = parse_deny_action(var, value);
 105                return 0;
 106        }
 107
 108        if (strcmp(var, "receive.denydeletecurrent") == 0) {
 109                deny_delete_current = parse_deny_action(var, value);
 110                return 0;
 111        }
 112
 113        if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
 114                prefer_ofs_delta = git_config_bool(var, value);
 115                return 0;
 116        }
 117
 118        if (strcmp(var, "receive.updateserverinfo") == 0) {
 119                auto_update_server_info = git_config_bool(var, value);
 120                return 0;
 121        }
 122
 123        if (strcmp(var, "receive.autogc") == 0) {
 124                auto_gc = git_config_bool(var, value);
 125                return 0;
 126        }
 127
 128        if (strcmp(var, "receive.shallowupdate") == 0) {
 129                shallow_update = git_config_bool(var, value);
 130                return 0;
 131        }
 132
 133        return git_default_config(var, value, cb);
 134}
 135
 136static void show_ref(const char *path, const unsigned char *sha1)
 137{
 138        if (ref_is_hidden(path))
 139                return;
 140
 141        if (sent_capabilities)
 142                packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
 143        else
 144                packet_write(1, "%s %s%c%s%s agent=%s\n",
 145                             sha1_to_hex(sha1), path, 0,
 146                             " report-status delete-refs side-band-64k quiet",
 147                             prefer_ofs_delta ? " ofs-delta" : "",
 148                             git_user_agent_sanitized());
 149        sent_capabilities = 1;
 150}
 151
 152static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
 153{
 154        path = strip_namespace(path);
 155        /*
 156         * Advertise refs outside our current namespace as ".have"
 157         * refs, so that the client can use them to minimize data
 158         * transfer but will otherwise ignore them. This happens to
 159         * cover ".have" that are thrown in by add_one_alternate_ref()
 160         * to mark histories that are complete in our alternates as
 161         * well.
 162         */
 163        if (!path)
 164                path = ".have";
 165        show_ref(path, sha1);
 166        return 0;
 167}
 168
 169static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
 170{
 171        show_ref(".have", sha1);
 172}
 173
 174static void collect_one_alternate_ref(const struct ref *ref, void *data)
 175{
 176        struct sha1_array *sa = data;
 177        sha1_array_append(sa, ref->old_sha1);
 178}
 179
 180static void write_head_info(void)
 181{
 182        struct sha1_array sa = SHA1_ARRAY_INIT;
 183        for_each_alternate_ref(collect_one_alternate_ref, &sa);
 184        sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
 185        sha1_array_clear(&sa);
 186        for_each_ref(show_ref_cb, NULL);
 187        if (!sent_capabilities)
 188                show_ref("capabilities^{}", null_sha1);
 189
 190        advertise_shallow_grafts(1);
 191
 192        /* EOF */
 193        packet_flush(1);
 194}
 195
 196struct command {
 197        struct command *next;
 198        const char *error_string;
 199        unsigned int skip_update:1,
 200                     did_not_exist:1;
 201        int index;
 202        unsigned char old_sha1[20];
 203        unsigned char new_sha1[20];
 204        char ref_name[FLEX_ARRAY]; /* more */
 205};
 206
 207static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
 208static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
 209
 210static void report_message(const char *prefix, const char *err, va_list params)
 211{
 212        int sz = strlen(prefix);
 213        char msg[4096];
 214
 215        strncpy(msg, prefix, sz);
 216        sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
 217        if (sz > (sizeof(msg) - 1))
 218                sz = sizeof(msg) - 1;
 219        msg[sz++] = '\n';
 220
 221        if (use_sideband)
 222                send_sideband(1, 2, msg, sz, use_sideband);
 223        else
 224                xwrite(2, msg, sz);
 225}
 226
 227static void rp_warning(const char *err, ...)
 228{
 229        va_list params;
 230        va_start(params, err);
 231        report_message("warning: ", err, params);
 232        va_end(params);
 233}
 234
 235static void rp_error(const char *err, ...)
 236{
 237        va_list params;
 238        va_start(params, err);
 239        report_message("error: ", err, params);
 240        va_end(params);
 241}
 242
 243static int copy_to_sideband(int in, int out, void *arg)
 244{
 245        char data[128];
 246        while (1) {
 247                ssize_t sz = xread(in, data, sizeof(data));
 248                if (sz <= 0)
 249                        break;
 250                send_sideband(1, 2, data, sz, use_sideband);
 251        }
 252        close(in);
 253        return 0;
 254}
 255
 256typedef int (*feed_fn)(void *, const char **, size_t *);
 257static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
 258{
 259        struct child_process proc;
 260        struct async muxer;
 261        const char *argv[2];
 262        int code;
 263
 264        argv[0] = find_hook(hook_name);
 265        if (!argv[0])
 266                return 0;
 267
 268        argv[1] = NULL;
 269
 270        memset(&proc, 0, sizeof(proc));
 271        proc.argv = argv;
 272        proc.in = -1;
 273        proc.stdout_to_stderr = 1;
 274
 275        if (use_sideband) {
 276                memset(&muxer, 0, sizeof(muxer));
 277                muxer.proc = copy_to_sideband;
 278                muxer.in = -1;
 279                code = start_async(&muxer);
 280                if (code)
 281                        return code;
 282                proc.err = muxer.in;
 283        }
 284
 285        code = start_command(&proc);
 286        if (code) {
 287                if (use_sideband)
 288                        finish_async(&muxer);
 289                return code;
 290        }
 291
 292        sigchain_push(SIGPIPE, SIG_IGN);
 293
 294        while (1) {
 295                const char *buf;
 296                size_t n;
 297                if (feed(feed_state, &buf, &n))
 298                        break;
 299                if (write_in_full(proc.in, buf, n) != n)
 300                        break;
 301        }
 302        close(proc.in);
 303        if (use_sideband)
 304                finish_async(&muxer);
 305
 306        sigchain_pop(SIGPIPE);
 307
 308        return finish_command(&proc);
 309}
 310
 311struct receive_hook_feed_state {
 312        struct command *cmd;
 313        int skip_broken;
 314        struct strbuf buf;
 315};
 316
 317static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
 318{
 319        struct receive_hook_feed_state *state = state_;
 320        struct command *cmd = state->cmd;
 321
 322        while (cmd &&
 323               state->skip_broken && (cmd->error_string || cmd->did_not_exist))
 324                cmd = cmd->next;
 325        if (!cmd)
 326                return -1; /* EOF */
 327        strbuf_reset(&state->buf);
 328        strbuf_addf(&state->buf, "%s %s %s\n",
 329                    sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
 330                    cmd->ref_name);
 331        state->cmd = cmd->next;
 332        if (bufp) {
 333                *bufp = state->buf.buf;
 334                *sizep = state->buf.len;
 335        }
 336        return 0;
 337}
 338
 339static int run_receive_hook(struct command *commands, const char *hook_name,
 340                            int skip_broken)
 341{
 342        struct receive_hook_feed_state state;
 343        int status;
 344
 345        strbuf_init(&state.buf, 0);
 346        state.cmd = commands;
 347        state.skip_broken = skip_broken;
 348        if (feed_receive_hook(&state, NULL, NULL))
 349                return 0;
 350        state.cmd = commands;
 351        status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
 352        strbuf_release(&state.buf);
 353        return status;
 354}
 355
 356static int run_update_hook(struct command *cmd)
 357{
 358        const char *argv[5];
 359        struct child_process proc;
 360        int code;
 361
 362        argv[0] = find_hook("update");
 363        if (!argv[0])
 364                return 0;
 365
 366        argv[1] = cmd->ref_name;
 367        argv[2] = sha1_to_hex(cmd->old_sha1);
 368        argv[3] = sha1_to_hex(cmd->new_sha1);
 369        argv[4] = NULL;
 370
 371        memset(&proc, 0, sizeof(proc));
 372        proc.no_stdin = 1;
 373        proc.stdout_to_stderr = 1;
 374        proc.err = use_sideband ? -1 : 0;
 375        proc.argv = argv;
 376
 377        code = start_command(&proc);
 378        if (code)
 379                return code;
 380        if (use_sideband)
 381                copy_to_sideband(proc.err, -1, NULL);
 382        return finish_command(&proc);
 383}
 384
 385static int is_ref_checked_out(const char *ref)
 386{
 387        if (is_bare_repository())
 388                return 0;
 389
 390        if (!head_name)
 391                return 0;
 392        return !strcmp(head_name, ref);
 393}
 394
 395static char *refuse_unconfigured_deny_msg[] = {
 396        "By default, updating the current branch in a non-bare repository",
 397        "is denied, because it will make the index and work tree inconsistent",
 398        "with what you pushed, and will require 'git reset --hard' to match",
 399        "the work tree to HEAD.",
 400        "",
 401        "You can set 'receive.denyCurrentBranch' configuration variable to",
 402        "'ignore' or 'warn' in the remote repository to allow pushing into",
 403        "its current branch; however, this is not recommended unless you",
 404        "arranged to update its work tree to match what you pushed in some",
 405        "other way.",
 406        "",
 407        "To squelch this message and still keep the default behaviour, set",
 408        "'receive.denyCurrentBranch' configuration variable to 'refuse'."
 409};
 410
 411static void refuse_unconfigured_deny(void)
 412{
 413        int i;
 414        for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
 415                rp_error("%s", refuse_unconfigured_deny_msg[i]);
 416}
 417
 418static char *refuse_unconfigured_deny_delete_current_msg[] = {
 419        "By default, deleting the current branch is denied, because the next",
 420        "'git clone' won't result in any file checked out, causing confusion.",
 421        "",
 422        "You can set 'receive.denyDeleteCurrent' configuration variable to",
 423        "'warn' or 'ignore' in the remote repository to allow deleting the",
 424        "current branch, with or without a warning message.",
 425        "",
 426        "To squelch this message, you can set it to 'refuse'."
 427};
 428
 429static void refuse_unconfigured_deny_delete_current(void)
 430{
 431        int i;
 432        for (i = 0;
 433             i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
 434             i++)
 435                rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
 436}
 437
 438static int command_singleton_iterator(void *cb_data, unsigned char sha1[20]);
 439static int update_shallow_ref(struct command *cmd, struct shallow_info *si)
 440{
 441        static struct lock_file shallow_lock;
 442        struct sha1_array extra = SHA1_ARRAY_INIT;
 443        const char *alt_file;
 444        uint32_t mask = 1 << (cmd->index % 32);
 445        int i;
 446
 447        trace_printf_key(&trace_shallow,
 448                         "shallow: update_shallow_ref %s\n", cmd->ref_name);
 449        for (i = 0; i < si->shallow->nr; i++)
 450                if (si->used_shallow[i] &&
 451                    (si->used_shallow[i][cmd->index / 32] & mask) &&
 452                    !delayed_reachability_test(si, i))
 453                        sha1_array_append(&extra, si->shallow->sha1[i]);
 454
 455        setup_alternate_shallow(&shallow_lock, &alt_file, &extra);
 456        if (check_shallow_connected(command_singleton_iterator,
 457                                    0, cmd, alt_file)) {
 458                rollback_lock_file(&shallow_lock);
 459                sha1_array_clear(&extra);
 460                return -1;
 461        }
 462
 463        commit_lock_file(&shallow_lock);
 464
 465        /*
 466         * Make sure setup_alternate_shallow() for the next ref does
 467         * not lose these new roots..
 468         */
 469        for (i = 0; i < extra.nr; i++)
 470                register_shallow(extra.sha1[i]);
 471
 472        si->shallow_ref[cmd->index] = 0;
 473        sha1_array_clear(&extra);
 474        return 0;
 475}
 476
 477static const char *update(struct command *cmd, struct shallow_info *si)
 478{
 479        const char *name = cmd->ref_name;
 480        struct strbuf namespaced_name_buf = STRBUF_INIT;
 481        const char *namespaced_name;
 482        unsigned char *old_sha1 = cmd->old_sha1;
 483        unsigned char *new_sha1 = cmd->new_sha1;
 484        struct ref_lock *lock;
 485
 486        /* only refs/... are allowed */
 487        if (!starts_with(name, "refs/") || check_refname_format(name + 5, 0)) {
 488                rp_error("refusing to create funny ref '%s' remotely", name);
 489                return "funny refname";
 490        }
 491
 492        strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
 493        namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
 494
 495        if (is_ref_checked_out(namespaced_name)) {
 496                switch (deny_current_branch) {
 497                case DENY_IGNORE:
 498                        break;
 499                case DENY_WARN:
 500                        rp_warning("updating the current branch");
 501                        break;
 502                case DENY_REFUSE:
 503                case DENY_UNCONFIGURED:
 504                        rp_error("refusing to update checked out branch: %s", name);
 505                        if (deny_current_branch == DENY_UNCONFIGURED)
 506                                refuse_unconfigured_deny();
 507                        return "branch is currently checked out";
 508                }
 509        }
 510
 511        if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
 512                error("unpack should have generated %s, "
 513                      "but I can't find it!", sha1_to_hex(new_sha1));
 514                return "bad pack";
 515        }
 516
 517        if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
 518                if (deny_deletes && starts_with(name, "refs/heads/")) {
 519                        rp_error("denying ref deletion for %s", name);
 520                        return "deletion prohibited";
 521                }
 522
 523                if (!strcmp(namespaced_name, head_name)) {
 524                        switch (deny_delete_current) {
 525                        case DENY_IGNORE:
 526                                break;
 527                        case DENY_WARN:
 528                                rp_warning("deleting the current branch");
 529                                break;
 530                        case DENY_REFUSE:
 531                        case DENY_UNCONFIGURED:
 532                                if (deny_delete_current == DENY_UNCONFIGURED)
 533                                        refuse_unconfigured_deny_delete_current();
 534                                rp_error("refusing to delete the current branch: %s", name);
 535                                return "deletion of the current branch prohibited";
 536                        }
 537                }
 538        }
 539
 540        if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
 541            !is_null_sha1(old_sha1) &&
 542            starts_with(name, "refs/heads/")) {
 543                struct object *old_object, *new_object;
 544                struct commit *old_commit, *new_commit;
 545
 546                old_object = parse_object(old_sha1);
 547                new_object = parse_object(new_sha1);
 548
 549                if (!old_object || !new_object ||
 550                    old_object->type != OBJ_COMMIT ||
 551                    new_object->type != OBJ_COMMIT) {
 552                        error("bad sha1 objects for %s", name);
 553                        return "bad ref";
 554                }
 555                old_commit = (struct commit *)old_object;
 556                new_commit = (struct commit *)new_object;
 557                if (!in_merge_bases(old_commit, new_commit)) {
 558                        rp_error("denying non-fast-forward %s"
 559                                 " (you should pull first)", name);
 560                        return "non-fast-forward";
 561                }
 562        }
 563        if (run_update_hook(cmd)) {
 564                rp_error("hook declined to update %s", name);
 565                return "hook declined";
 566        }
 567
 568        if (is_null_sha1(new_sha1)) {
 569                if (!parse_object(old_sha1)) {
 570                        old_sha1 = NULL;
 571                        if (ref_exists(name)) {
 572                                rp_warning("Allowing deletion of corrupt ref.");
 573                        } else {
 574                                rp_warning("Deleting a non-existent ref.");
 575                                cmd->did_not_exist = 1;
 576                        }
 577                }
 578                if (delete_ref(namespaced_name, old_sha1, 0)) {
 579                        rp_error("failed to delete %s", name);
 580                        return "failed to delete";
 581                }
 582                return NULL; /* good */
 583        }
 584        else {
 585                if (shallow_update && si->shallow_ref[cmd->index] &&
 586                    update_shallow_ref(cmd, si))
 587                        return "shallow error";
 588
 589                lock = lock_any_ref_for_update(namespaced_name, old_sha1,
 590                                               0, NULL);
 591                if (!lock) {
 592                        rp_error("failed to lock %s", name);
 593                        return "failed to lock";
 594                }
 595                if (write_ref_sha1(lock, new_sha1, "push")) {
 596                        return "failed to write"; /* error() already called */
 597                }
 598                return NULL; /* good */
 599        }
 600}
 601
 602static void run_update_post_hook(struct command *commands)
 603{
 604        struct command *cmd;
 605        int argc;
 606        const char **argv;
 607        struct child_process proc;
 608        char *hook;
 609
 610        hook = find_hook("post-update");
 611        for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
 612                if (cmd->error_string || cmd->did_not_exist)
 613                        continue;
 614                argc++;
 615        }
 616        if (!argc || !hook)
 617                return;
 618
 619        argv = xmalloc(sizeof(*argv) * (2 + argc));
 620        argv[0] = hook;
 621
 622        for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
 623                if (cmd->error_string || cmd->did_not_exist)
 624                        continue;
 625                argv[argc] = xstrdup(cmd->ref_name);
 626                argc++;
 627        }
 628        argv[argc] = NULL;
 629
 630        memset(&proc, 0, sizeof(proc));
 631        proc.no_stdin = 1;
 632        proc.stdout_to_stderr = 1;
 633        proc.err = use_sideband ? -1 : 0;
 634        proc.argv = argv;
 635
 636        if (!start_command(&proc)) {
 637                if (use_sideband)
 638                        copy_to_sideband(proc.err, -1, NULL);
 639                finish_command(&proc);
 640        }
 641}
 642
 643static void check_aliased_update(struct command *cmd, struct string_list *list)
 644{
 645        struct strbuf buf = STRBUF_INIT;
 646        const char *dst_name;
 647        struct string_list_item *item;
 648        struct command *dst_cmd;
 649        unsigned char sha1[20];
 650        char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
 651        int flag;
 652
 653        strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
 654        dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
 655        strbuf_release(&buf);
 656
 657        if (!(flag & REF_ISSYMREF))
 658                return;
 659
 660        dst_name = strip_namespace(dst_name);
 661        if (!dst_name) {
 662                rp_error("refusing update to broken symref '%s'", cmd->ref_name);
 663                cmd->skip_update = 1;
 664                cmd->error_string = "broken symref";
 665                return;
 666        }
 667
 668        if ((item = string_list_lookup(list, dst_name)) == NULL)
 669                return;
 670
 671        cmd->skip_update = 1;
 672
 673        dst_cmd = (struct command *) item->util;
 674
 675        if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
 676            !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
 677                return;
 678
 679        dst_cmd->skip_update = 1;
 680
 681        strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
 682        strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
 683        strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
 684        strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
 685        rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
 686                 " its target '%s' (%s..%s)",
 687                 cmd->ref_name, cmd_oldh, cmd_newh,
 688                 dst_cmd->ref_name, dst_oldh, dst_newh);
 689
 690        cmd->error_string = dst_cmd->error_string =
 691                "inconsistent aliased update";
 692}
 693
 694static void check_aliased_updates(struct command *commands)
 695{
 696        struct command *cmd;
 697        struct string_list ref_list = STRING_LIST_INIT_NODUP;
 698
 699        for (cmd = commands; cmd; cmd = cmd->next) {
 700                struct string_list_item *item =
 701                        string_list_append(&ref_list, cmd->ref_name);
 702                item->util = (void *)cmd;
 703        }
 704        sort_string_list(&ref_list);
 705
 706        for (cmd = commands; cmd; cmd = cmd->next) {
 707                if (!cmd->error_string)
 708                        check_aliased_update(cmd, &ref_list);
 709        }
 710
 711        string_list_clear(&ref_list, 0);
 712}
 713
 714static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
 715{
 716        struct command **cmd_list = cb_data;
 717        struct command *cmd = *cmd_list;
 718
 719        if (!cmd || is_null_sha1(cmd->new_sha1))
 720                return -1; /* end of list */
 721        *cmd_list = NULL; /* this returns only one */
 722        hashcpy(sha1, cmd->new_sha1);
 723        return 0;
 724}
 725
 726static void set_connectivity_errors(struct command *commands,
 727                                    struct shallow_info *si)
 728{
 729        struct command *cmd;
 730
 731        for (cmd = commands; cmd; cmd = cmd->next) {
 732                struct command *singleton = cmd;
 733                if (shallow_update && si->shallow_ref[cmd->index])
 734                        /* to be checked in update_shallow_ref() */
 735                        continue;
 736                if (!check_everything_connected(command_singleton_iterator,
 737                                                0, &singleton))
 738                        continue;
 739                cmd->error_string = "missing necessary objects";
 740        }
 741}
 742
 743struct iterate_data {
 744        struct command *cmds;
 745        struct shallow_info *si;
 746};
 747
 748static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
 749{
 750        struct iterate_data *data = cb_data;
 751        struct command **cmd_list = &data->cmds;
 752        struct command *cmd = *cmd_list;
 753
 754        for (; cmd; cmd = cmd->next) {
 755                if (shallow_update && data->si->shallow_ref[cmd->index])
 756                        /* to be checked in update_shallow_ref() */
 757                        continue;
 758                if (!is_null_sha1(cmd->new_sha1) && !cmd->skip_update) {
 759                        hashcpy(sha1, cmd->new_sha1);
 760                        *cmd_list = cmd->next;
 761                        return 0;
 762                }
 763        }
 764        *cmd_list = NULL;
 765        return -1; /* end of list */
 766}
 767
 768static void reject_updates_to_hidden(struct command *commands)
 769{
 770        struct command *cmd;
 771
 772        for (cmd = commands; cmd; cmd = cmd->next) {
 773                if (cmd->error_string || !ref_is_hidden(cmd->ref_name))
 774                        continue;
 775                if (is_null_sha1(cmd->new_sha1))
 776                        cmd->error_string = "deny deleting a hidden ref";
 777                else
 778                        cmd->error_string = "deny updating a hidden ref";
 779        }
 780}
 781
 782static void execute_commands(struct command *commands,
 783                             const char *unpacker_error,
 784                             struct shallow_info *si)
 785{
 786        int checked_connectivity;
 787        struct command *cmd;
 788        unsigned char sha1[20];
 789        struct iterate_data data;
 790
 791        if (unpacker_error) {
 792                for (cmd = commands; cmd; cmd = cmd->next)
 793                        cmd->error_string = "unpacker error";
 794                return;
 795        }
 796
 797        data.cmds = commands;
 798        data.si = si;
 799        if (check_everything_connected(iterate_receive_command_list, 0, &data))
 800                set_connectivity_errors(commands, si);
 801
 802        reject_updates_to_hidden(commands);
 803
 804        if (run_receive_hook(commands, "pre-receive", 0)) {
 805                for (cmd = commands; cmd; cmd = cmd->next) {
 806                        if (!cmd->error_string)
 807                                cmd->error_string = "pre-receive hook declined";
 808                }
 809                return;
 810        }
 811
 812        check_aliased_updates(commands);
 813
 814        free(head_name_to_free);
 815        head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
 816
 817        checked_connectivity = 1;
 818        for (cmd = commands; cmd; cmd = cmd->next) {
 819                if (cmd->error_string)
 820                        continue;
 821
 822                if (cmd->skip_update)
 823                        continue;
 824
 825                cmd->error_string = update(cmd, si);
 826                if (shallow_update && !cmd->error_string &&
 827                    si->shallow_ref[cmd->index]) {
 828                        error("BUG: connectivity check has not been run on ref %s",
 829                              cmd->ref_name);
 830                        checked_connectivity = 0;
 831                }
 832        }
 833
 834        if (shallow_update && !checked_connectivity)
 835                error("BUG: run 'git fsck' for safety.\n"
 836                      "If there are errors, try to remove "
 837                      "the reported refs above");
 838}
 839
 840static struct command *read_head_info(struct sha1_array *shallow)
 841{
 842        struct command *commands = NULL;
 843        struct command **p = &commands;
 844        for (;;) {
 845                char *line;
 846                unsigned char old_sha1[20], new_sha1[20];
 847                struct command *cmd;
 848                char *refname;
 849                int len, reflen;
 850
 851                line = packet_read_line(0, &len);
 852                if (!line)
 853                        break;
 854
 855                if (len == 48 && starts_with(line, "shallow ")) {
 856                        if (get_sha1_hex(line + 8, old_sha1))
 857                                die("protocol error: expected shallow sha, got '%s'", line + 8);
 858                        sha1_array_append(shallow, old_sha1);
 859                        continue;
 860                }
 861
 862                if (len < 83 ||
 863                    line[40] != ' ' ||
 864                    line[81] != ' ' ||
 865                    get_sha1_hex(line, old_sha1) ||
 866                    get_sha1_hex(line + 41, new_sha1))
 867                        die("protocol error: expected old/new/ref, got '%s'",
 868                            line);
 869
 870                refname = line + 82;
 871                reflen = strlen(refname);
 872                if (reflen + 82 < len) {
 873                        const char *feature_list = refname + reflen + 1;
 874                        if (parse_feature_request(feature_list, "report-status"))
 875                                report_status = 1;
 876                        if (parse_feature_request(feature_list, "side-band-64k"))
 877                                use_sideband = LARGE_PACKET_MAX;
 878                        if (parse_feature_request(feature_list, "quiet"))
 879                                quiet = 1;
 880                }
 881                cmd = xcalloc(1, sizeof(struct command) + len - 80);
 882                hashcpy(cmd->old_sha1, old_sha1);
 883                hashcpy(cmd->new_sha1, new_sha1);
 884                memcpy(cmd->ref_name, line + 82, len - 81);
 885                *p = cmd;
 886                p = &cmd->next;
 887        }
 888        return commands;
 889}
 890
 891static const char *parse_pack_header(struct pack_header *hdr)
 892{
 893        switch (read_pack_header(0, hdr)) {
 894        case PH_ERROR_EOF:
 895                return "eof before pack header was fully read";
 896
 897        case PH_ERROR_PACK_SIGNATURE:
 898                return "protocol error (pack signature mismatch detected)";
 899
 900        case PH_ERROR_PROTOCOL:
 901                return "protocol error (pack version unsupported)";
 902
 903        default:
 904                return "unknown error in parse_pack_header";
 905
 906        case 0:
 907                return NULL;
 908        }
 909}
 910
 911static const char *pack_lockfile;
 912
 913static const char *unpack(int err_fd, struct shallow_info *si)
 914{
 915        struct pack_header hdr;
 916        struct argv_array av = ARGV_ARRAY_INIT;
 917        const char *hdr_err;
 918        int status;
 919        char hdr_arg[38];
 920        struct child_process child;
 921        int fsck_objects = (receive_fsck_objects >= 0
 922                            ? receive_fsck_objects
 923                            : transfer_fsck_objects >= 0
 924                            ? transfer_fsck_objects
 925                            : 0);
 926
 927        hdr_err = parse_pack_header(&hdr);
 928        if (hdr_err) {
 929                if (err_fd > 0)
 930                        close(err_fd);
 931                return hdr_err;
 932        }
 933        snprintf(hdr_arg, sizeof(hdr_arg),
 934                        "--pack_header=%"PRIu32",%"PRIu32,
 935                        ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
 936
 937        if (si->nr_ours || si->nr_theirs) {
 938                alt_shallow_file = setup_temporary_shallow(si->shallow);
 939                argv_array_pushl(&av, "--shallow-file", alt_shallow_file, NULL);
 940        }
 941
 942        memset(&child, 0, sizeof(child));
 943        if (ntohl(hdr.hdr_entries) < unpack_limit) {
 944                argv_array_pushl(&av, "unpack-objects", hdr_arg, NULL);
 945                if (quiet)
 946                        argv_array_push(&av, "-q");
 947                if (fsck_objects)
 948                        argv_array_push(&av, "--strict");
 949                child.argv = av.argv;
 950                child.no_stdout = 1;
 951                child.err = err_fd;
 952                child.git_cmd = 1;
 953                status = run_command(&child);
 954                if (status)
 955                        return "unpack-objects abnormal exit";
 956        } else {
 957                int s;
 958                char keep_arg[256];
 959
 960                s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
 961                if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 962                        strcpy(keep_arg + s, "localhost");
 963
 964                argv_array_pushl(&av, "index-pack",
 965                                 "--stdin", hdr_arg, keep_arg, NULL);
 966                if (fsck_objects)
 967                        argv_array_push(&av, "--strict");
 968                if (fix_thin)
 969                        argv_array_push(&av, "--fix-thin");
 970                child.argv = av.argv;
 971                child.out = -1;
 972                child.err = err_fd;
 973                child.git_cmd = 1;
 974                status = start_command(&child);
 975                if (status)
 976                        return "index-pack fork failed";
 977                pack_lockfile = index_pack_lockfile(child.out);
 978                close(child.out);
 979                status = finish_command(&child);
 980                if (status)
 981                        return "index-pack abnormal exit";
 982                reprepare_packed_git();
 983        }
 984        return NULL;
 985}
 986
 987static const char *unpack_with_sideband(struct shallow_info *si)
 988{
 989        struct async muxer;
 990        const char *ret;
 991
 992        if (!use_sideband)
 993                return unpack(0, si);
 994
 995        memset(&muxer, 0, sizeof(muxer));
 996        muxer.proc = copy_to_sideband;
 997        muxer.in = -1;
 998        if (start_async(&muxer))
 999                return NULL;
1000
1001        ret = unpack(muxer.in, si);
1002
1003        finish_async(&muxer);
1004        return ret;
1005}
1006
1007static void prepare_shallow_update(struct command *commands,
1008                                   struct shallow_info *si)
1009{
1010        int i, j, k, bitmap_size = (si->ref->nr + 31) / 32;
1011
1012        si->used_shallow = xmalloc(sizeof(*si->used_shallow) *
1013                                   si->shallow->nr);
1014        assign_shallow_commits_to_refs(si, si->used_shallow, NULL);
1015
1016        si->need_reachability_test =
1017                xcalloc(si->shallow->nr, sizeof(*si->need_reachability_test));
1018        si->reachable =
1019                xcalloc(si->shallow->nr, sizeof(*si->reachable));
1020        si->shallow_ref = xcalloc(si->ref->nr, sizeof(*si->shallow_ref));
1021
1022        for (i = 0; i < si->nr_ours; i++)
1023                si->need_reachability_test[si->ours[i]] = 1;
1024
1025        for (i = 0; i < si->shallow->nr; i++) {
1026                if (!si->used_shallow[i])
1027                        continue;
1028                for (j = 0; j < bitmap_size; j++) {
1029                        if (!si->used_shallow[i][j])
1030                                continue;
1031                        si->need_reachability_test[i]++;
1032                        for (k = 0; k < 32; k++)
1033                                if (si->used_shallow[i][j] & (1 << k))
1034                                        si->shallow_ref[j * 32 + k]++;
1035                }
1036
1037                /*
1038                 * true for those associated with some refs and belong
1039                 * in "ours" list aka "step 7 not done yet"
1040                 */
1041                si->need_reachability_test[i] =
1042                        si->need_reachability_test[i] > 1;
1043        }
1044
1045        /*
1046         * keep hooks happy by forcing a temporary shallow file via
1047         * env variable because we can't add --shallow-file to every
1048         * command. check_everything_connected() will be done with
1049         * true .git/shallow though.
1050         */
1051        setenv(GIT_SHALLOW_FILE_ENVIRONMENT, alt_shallow_file, 1);
1052}
1053
1054static void update_shallow_info(struct command *commands,
1055                                struct shallow_info *si,
1056                                struct sha1_array *ref)
1057{
1058        struct command *cmd;
1059        int *ref_status;
1060        remove_nonexistent_theirs_shallow(si);
1061        if (!si->nr_ours && !si->nr_theirs) {
1062                shallow_update = 0;
1063                return;
1064        }
1065
1066        for (cmd = commands; cmd; cmd = cmd->next) {
1067                if (is_null_sha1(cmd->new_sha1))
1068                        continue;
1069                sha1_array_append(ref, cmd->new_sha1);
1070                cmd->index = ref->nr - 1;
1071        }
1072        si->ref = ref;
1073
1074        if (shallow_update) {
1075                prepare_shallow_update(commands, si);
1076                return;
1077        }
1078
1079        ref_status = xmalloc(sizeof(*ref_status) * ref->nr);
1080        assign_shallow_commits_to_refs(si, NULL, ref_status);
1081        for (cmd = commands; cmd; cmd = cmd->next) {
1082                if (is_null_sha1(cmd->new_sha1))
1083                        continue;
1084                if (ref_status[cmd->index]) {
1085                        cmd->error_string = "shallow update not allowed";
1086                        cmd->skip_update = 1;
1087                }
1088        }
1089        free(ref_status);
1090}
1091
1092static void report(struct command *commands, const char *unpack_status)
1093{
1094        struct command *cmd;
1095        struct strbuf buf = STRBUF_INIT;
1096
1097        packet_buf_write(&buf, "unpack %s\n",
1098                         unpack_status ? unpack_status : "ok");
1099        for (cmd = commands; cmd; cmd = cmd->next) {
1100                if (!cmd->error_string)
1101                        packet_buf_write(&buf, "ok %s\n",
1102                                         cmd->ref_name);
1103                else
1104                        packet_buf_write(&buf, "ng %s %s\n",
1105                                         cmd->ref_name, cmd->error_string);
1106        }
1107        packet_buf_flush(&buf);
1108
1109        if (use_sideband)
1110                send_sideband(1, 1, buf.buf, buf.len, use_sideband);
1111        else
1112                write_or_die(1, buf.buf, buf.len);
1113        strbuf_release(&buf);
1114}
1115
1116static int delete_only(struct command *commands)
1117{
1118        struct command *cmd;
1119        for (cmd = commands; cmd; cmd = cmd->next) {
1120                if (!is_null_sha1(cmd->new_sha1))
1121                        return 0;
1122        }
1123        return 1;
1124}
1125
1126int cmd_receive_pack(int argc, const char **argv, const char *prefix)
1127{
1128        int advertise_refs = 0;
1129        int stateless_rpc = 0;
1130        int i;
1131        const char *dir = NULL;
1132        struct command *commands;
1133        struct sha1_array shallow = SHA1_ARRAY_INIT;
1134        struct sha1_array ref = SHA1_ARRAY_INIT;
1135        struct shallow_info si;
1136
1137        packet_trace_identity("receive-pack");
1138
1139        argv++;
1140        for (i = 1; i < argc; i++) {
1141                const char *arg = *argv++;
1142
1143                if (*arg == '-') {
1144                        if (!strcmp(arg, "--quiet")) {
1145                                quiet = 1;
1146                                continue;
1147                        }
1148
1149                        if (!strcmp(arg, "--advertise-refs")) {
1150                                advertise_refs = 1;
1151                                continue;
1152                        }
1153                        if (!strcmp(arg, "--stateless-rpc")) {
1154                                stateless_rpc = 1;
1155                                continue;
1156                        }
1157                        if (!strcmp(arg, "--reject-thin-pack-for-testing")) {
1158                                fix_thin = 0;
1159                                continue;
1160                        }
1161
1162                        usage(receive_pack_usage);
1163                }
1164                if (dir)
1165                        usage(receive_pack_usage);
1166                dir = arg;
1167        }
1168        if (!dir)
1169                usage(receive_pack_usage);
1170
1171        setup_path();
1172
1173        if (!enter_repo(dir, 0))
1174                die("'%s' does not appear to be a git repository", dir);
1175
1176        git_config(receive_pack_config, NULL);
1177
1178        if (0 <= transfer_unpack_limit)
1179                unpack_limit = transfer_unpack_limit;
1180        else if (0 <= receive_unpack_limit)
1181                unpack_limit = receive_unpack_limit;
1182
1183        if (advertise_refs || !stateless_rpc) {
1184                write_head_info();
1185        }
1186        if (advertise_refs)
1187                return 0;
1188
1189        if ((commands = read_head_info(&shallow)) != NULL) {
1190                const char *unpack_status = NULL;
1191
1192                prepare_shallow_info(&si, &shallow);
1193                if (!si.nr_ours && !si.nr_theirs)
1194                        shallow_update = 0;
1195                if (!delete_only(commands)) {
1196                        unpack_status = unpack_with_sideband(&si);
1197                        update_shallow_info(commands, &si, &ref);
1198                }
1199                execute_commands(commands, unpack_status, &si);
1200                if (pack_lockfile)
1201                        unlink_or_warn(pack_lockfile);
1202                if (report_status)
1203                        report(commands, unpack_status);
1204                run_receive_hook(commands, "post-receive", 1);
1205                run_update_post_hook(commands);
1206                if (auto_gc) {
1207                        const char *argv_gc_auto[] = {
1208                                "gc", "--auto", "--quiet", NULL,
1209                        };
1210                        int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1211                        run_command_v_opt(argv_gc_auto, opt);
1212                }
1213                if (auto_update_server_info)
1214                        update_server_info(0);
1215                clear_shallow_info(&si);
1216        }
1217        if (use_sideband)
1218                packet_flush(1);
1219        sha1_array_clear(&shallow);
1220        sha1_array_clear(&ref);
1221        return 0;
1222}