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