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