Andrew's git / gitweb.git / builtin/receive-pack.c
?
builtin / receive-pack.con commit upload/receive-pack: allow hiding ref hierarchies (daebaa7)
   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 "transport.h"
  12#include "string-list.h"
  13#include "sha1-array.h"
  14#include "connected.h"
  15#include "version.h"
  16
  17static const char receive_pack_usage[] = "git receive-pack <git-dir>";
  18
  19enum deny_action {
  20        DENY_UNCONFIGURED,
  21        DENY_IGNORE,
  22        DENY_WARN,
  23        DENY_REFUSE
  24};
  25
  26static int deny_deletes;
  27static int deny_non_fast_forwards;
  28static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
  29static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
  30static int receive_fsck_objects = -1;
  31static int transfer_fsck_objects = -1;
  32static int receive_unpack_limit = -1;
  33static int transfer_unpack_limit = -1;
  34static int unpack_limit = 100;
  35static int report_status;
  36static int use_sideband;
  37static int quiet;
  38static int prefer_ofs_delta = 1;
  39static int auto_update_server_info;
  40static int auto_gc = 1;
  41static const char *head_name;
  42static void *head_name_to_free;
  43static int sent_capabilities;
  44
  45static enum deny_action parse_deny_action(const char *var, const char *value)
  46{
  47        if (value) {
  48                if (!strcasecmp(value, "ignore"))
  49                        return DENY_IGNORE;
  50                if (!strcasecmp(value, "warn"))
  51                        return DENY_WARN;
  52                if (!strcasecmp(value, "refuse"))
  53                        return DENY_REFUSE;
  54        }
  55        if (git_config_bool(var, value))
  56                return DENY_REFUSE;
  57        return DENY_IGNORE;
  58}
  59
  60static int receive_pack_config(const char *var, const char *value, void *cb)
  61{
  62        int status = parse_hide_refs_config(var, value, "receive");
  63
  64        if (status)
  65                return status;
  66
  67        if (strcmp(var, "receive.denydeletes") == 0) {
  68                deny_deletes = git_config_bool(var, value);
  69                return 0;
  70        }
  71
  72        if (strcmp(var, "receive.denynonfastforwards") == 0) {
  73                deny_non_fast_forwards = git_config_bool(var, value);
  74                return 0;
  75        }
  76
  77        if (strcmp(var, "receive.unpacklimit") == 0) {
  78                receive_unpack_limit = git_config_int(var, value);
  79                return 0;
  80        }
  81
  82        if (strcmp(var, "transfer.unpacklimit") == 0) {
  83                transfer_unpack_limit = git_config_int(var, value);
  84                return 0;
  85        }
  86
  87        if (strcmp(var, "receive.fsckobjects") == 0) {
  88                receive_fsck_objects = git_config_bool(var, value);
  89                return 0;
  90        }
  91
  92        if (strcmp(var, "transfer.fsckobjects") == 0) {
  93                transfer_fsck_objects = git_config_bool(var, value);
  94                return 0;
  95        }
  96
  97        if (!strcmp(var, "receive.denycurrentbranch")) {
  98                deny_current_branch = parse_deny_action(var, value);
  99                return 0;
 100        }
 101
 102        if (strcmp(var, "receive.denydeletecurrent") == 0) {
 103                deny_delete_current = parse_deny_action(var, value);
 104                return 0;
 105        }
 106
 107        if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
 108                prefer_ofs_delta = git_config_bool(var, value);
 109                return 0;
 110        }
 111
 112        if (strcmp(var, "receive.updateserverinfo") == 0) {
 113                auto_update_server_info = git_config_bool(var, value);
 114                return 0;
 115        }
 116
 117        if (strcmp(var, "receive.autogc") == 0) {
 118                auto_gc = git_config_bool(var, value);
 119                return 0;
 120        }
 121
 122        return git_default_config(var, value, cb);
 123}
 124
 125static void show_ref(const char *path, const unsigned char *sha1)
 126{
 127        if (ref_is_hidden(path))
 128                return;
 129
 130        if (sent_capabilities)
 131                packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
 132        else
 133                packet_write(1, "%s %s%c%s%s agent=%s\n",
 134                             sha1_to_hex(sha1), path, 0,
 135                             " report-status delete-refs side-band-64k quiet",
 136                             prefer_ofs_delta ? " ofs-delta" : "",
 137                             git_user_agent_sanitized());
 138        sent_capabilities = 1;
 139}
 140
 141static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
 142{
 143        path = strip_namespace(path);
 144        /*
 145         * Advertise refs outside our current namespace as ".have"
 146         * refs, so that the client can use them to minimize data
 147         * transfer but will otherwise ignore them. This happens to
 148         * cover ".have" that are thrown in by add_one_alternate_ref()
 149         * to mark histories that are complete in our alternates as
 150         * well.
 151         */
 152        if (!path)
 153                path = ".have";
 154        show_ref(path, sha1);
 155        return 0;
 156}
 157
 158static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
 159{
 160        show_ref(".have", sha1);
 161}
 162
 163static void collect_one_alternate_ref(const struct ref *ref, void *data)
 164{
 165        struct sha1_array *sa = data;
 166        sha1_array_append(sa, ref->old_sha1);
 167}
 168
 169static void write_head_info(void)
 170{
 171        struct sha1_array sa = SHA1_ARRAY_INIT;
 172        for_each_alternate_ref(collect_one_alternate_ref, &sa);
 173        sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
 174        sha1_array_clear(&sa);
 175        for_each_ref(show_ref_cb, NULL);
 176        if (!sent_capabilities)
 177                show_ref("capabilities^{}", null_sha1);
 178
 179        /* EOF */
 180        packet_flush(1);
 181}
 182
 183struct command {
 184        struct command *next;
 185        const char *error_string;
 186        unsigned int skip_update:1,
 187                     did_not_exist:1;
 188        unsigned char old_sha1[20];
 189        unsigned char new_sha1[20];
 190        char ref_name[FLEX_ARRAY]; /* more */
 191};
 192
 193static const char pre_receive_hook[] = "hooks/pre-receive";
 194static const char post_receive_hook[] = "hooks/post-receive";
 195
 196static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
 197static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
 198
 199static void report_message(const char *prefix, const char *err, va_list params)
 200{
 201        int sz = strlen(prefix);
 202        char msg[4096];
 203
 204        strncpy(msg, prefix, sz);
 205        sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
 206        if (sz > (sizeof(msg) - 1))
 207                sz = sizeof(msg) - 1;
 208        msg[sz++] = '\n';
 209
 210        if (use_sideband)
 211                send_sideband(1, 2, msg, sz, use_sideband);
 212        else
 213                xwrite(2, msg, sz);
 214}
 215
 216static void rp_warning(const char *err, ...)
 217{
 218        va_list params;
 219        va_start(params, err);
 220        report_message("warning: ", err, params);
 221        va_end(params);
 222}
 223
 224static void rp_error(const char *err, ...)
 225{
 226        va_list params;
 227        va_start(params, err);
 228        report_message("error: ", err, params);
 229        va_end(params);
 230}
 231
 232static int copy_to_sideband(int in, int out, void *arg)
 233{
 234        char data[128];
 235        while (1) {
 236                ssize_t sz = xread(in, data, sizeof(data));
 237                if (sz <= 0)
 238                        break;
 239                send_sideband(1, 2, data, sz, use_sideband);
 240        }
 241        close(in);
 242        return 0;
 243}
 244
 245typedef int (*feed_fn)(void *, const char **, size_t *);
 246static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
 247{
 248        struct child_process proc;
 249        struct async muxer;
 250        const char *argv[2];
 251        int code;
 252
 253        if (access(hook_name, X_OK) < 0)
 254                return 0;
 255
 256        argv[0] = hook_name;
 257        argv[1] = NULL;
 258
 259        memset(&proc, 0, sizeof(proc));
 260        proc.argv = argv;
 261        proc.in = -1;
 262        proc.stdout_to_stderr = 1;
 263
 264        if (use_sideband) {
 265                memset(&muxer, 0, sizeof(muxer));
 266                muxer.proc = copy_to_sideband;
 267                muxer.in = -1;
 268                code = start_async(&muxer);
 269                if (code)
 270                        return code;
 271                proc.err = muxer.in;
 272        }
 273
 274        code = start_command(&proc);
 275        if (code) {
 276                if (use_sideband)
 277                        finish_async(&muxer);
 278                return code;
 279        }
 280
 281        while (1) {
 282                const char *buf;
 283                size_t n;
 284                if (feed(feed_state, &buf, &n))
 285                        break;
 286                if (write_in_full(proc.in, buf, n) != n)
 287                        break;
 288        }
 289        close(proc.in);
 290        if (use_sideband)
 291                finish_async(&muxer);
 292        return finish_command(&proc);
 293}
 294
 295struct receive_hook_feed_state {
 296        struct command *cmd;
 297        int skip_broken;
 298        struct strbuf buf;
 299};
 300
 301static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
 302{
 303        struct receive_hook_feed_state *state = state_;
 304        struct command *cmd = state->cmd;
 305
 306        while (cmd &&
 307               state->skip_broken && (cmd->error_string || cmd->did_not_exist))
 308                cmd = cmd->next;
 309        if (!cmd)
 310                return -1; /* EOF */
 311        strbuf_reset(&state->buf);
 312        strbuf_addf(&state->buf, "%s %s %s\n",
 313                    sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
 314                    cmd->ref_name);
 315        state->cmd = cmd->next;
 316        if (bufp) {
 317                *bufp = state->buf.buf;
 318                *sizep = state->buf.len;
 319        }
 320        return 0;
 321}
 322
 323static int run_receive_hook(struct command *commands, const char *hook_name,
 324                            int skip_broken)
 325{
 326        struct receive_hook_feed_state state;
 327        int status;
 328
 329        strbuf_init(&state.buf, 0);
 330        state.cmd = commands;
 331        state.skip_broken = skip_broken;
 332        if (feed_receive_hook(&state, NULL, NULL))
 333                return 0;
 334        state.cmd = commands;
 335        status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
 336        strbuf_release(&state.buf);
 337        return status;
 338}
 339
 340static int run_update_hook(struct command *cmd)
 341{
 342        static const char update_hook[] = "hooks/update";
 343        const char *argv[5];
 344        struct child_process proc;
 345        int code;
 346
 347        if (access(update_hook, X_OK) < 0)
 348                return 0;
 349
 350        argv[0] = update_hook;
 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, 0);
 532                if (!lock) {
 533                        rp_error("failed to lock %s", name);
 534                        return "failed to lock";
 535                }
 536                if (write_ref_sha1(lock, new_sha1, "push")) {
 537                        return "failed to write"; /* error() already called */
 538                }
 539                return NULL; /* good */
 540        }
 541}
 542
 543static char update_post_hook[] = "hooks/post-update";
 544
 545static void run_update_post_hook(struct command *commands)
 546{
 547        struct command *cmd;
 548        int argc;
 549        const char **argv;
 550        struct child_process proc;
 551
 552        for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
 553                if (cmd->error_string || cmd->did_not_exist)
 554                        continue;
 555                argc++;
 556        }
 557        if (!argc || access(update_post_hook, X_OK) < 0)
 558                return;
 559        argv = xmalloc(sizeof(*argv) * (2 + argc));
 560        argv[0] = update_post_hook;
 561
 562        for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
 563                char *p;
 564                if (cmd->error_string || cmd->did_not_exist)
 565                        continue;
 566                p = xmalloc(strlen(cmd->ref_name) + 1);
 567                strcpy(p, cmd->ref_name);
 568                argv[argc] = p;
 569                argc++;
 570        }
 571        argv[argc] = NULL;
 572
 573        memset(&proc, 0, sizeof(proc));
 574        proc.no_stdin = 1;
 575        proc.stdout_to_stderr = 1;
 576        proc.err = use_sideband ? -1 : 0;
 577        proc.argv = argv;
 578
 579        if (!start_command(&proc)) {
 580                if (use_sideband)
 581                        copy_to_sideband(proc.err, -1, NULL);
 582                finish_command(&proc);
 583        }
 584}
 585
 586static void check_aliased_update(struct command *cmd, struct string_list *list)
 587{
 588        struct strbuf buf = STRBUF_INIT;
 589        const char *dst_name;
 590        struct string_list_item *item;
 591        struct command *dst_cmd;
 592        unsigned char sha1[20];
 593        char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
 594        int flag;
 595
 596        strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
 597        dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
 598        strbuf_release(&buf);
 599
 600        if (!(flag & REF_ISSYMREF))
 601                return;
 602
 603        dst_name = strip_namespace(dst_name);
 604        if (!dst_name) {
 605                rp_error("refusing update to broken symref '%s'", cmd->ref_name);
 606                cmd->skip_update = 1;
 607                cmd->error_string = "broken symref";
 608                return;
 609        }
 610
 611        if ((item = string_list_lookup(list, dst_name)) == NULL)
 612                return;
 613
 614        cmd->skip_update = 1;
 615
 616        dst_cmd = (struct command *) item->util;
 617
 618        if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
 619            !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
 620                return;
 621
 622        dst_cmd->skip_update = 1;
 623
 624        strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
 625        strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
 626        strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
 627        strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
 628        rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
 629                 " its target '%s' (%s..%s)",
 630                 cmd->ref_name, cmd_oldh, cmd_newh,
 631                 dst_cmd->ref_name, dst_oldh, dst_newh);
 632
 633        cmd->error_string = dst_cmd->error_string =
 634                "inconsistent aliased update";
 635}
 636
 637static void check_aliased_updates(struct command *commands)
 638{
 639        struct command *cmd;
 640        struct string_list ref_list = STRING_LIST_INIT_NODUP;
 641
 642        for (cmd = commands; cmd; cmd = cmd->next) {
 643                struct string_list_item *item =
 644                        string_list_append(&ref_list, cmd->ref_name);
 645                item->util = (void *)cmd;
 646        }
 647        sort_string_list(&ref_list);
 648
 649        for (cmd = commands; cmd; cmd = cmd->next) {
 650                if (!cmd->error_string)
 651                        check_aliased_update(cmd, &ref_list);
 652        }
 653
 654        string_list_clear(&ref_list, 0);
 655}
 656
 657static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
 658{
 659        struct command **cmd_list = cb_data;
 660        struct command *cmd = *cmd_list;
 661
 662        if (!cmd || is_null_sha1(cmd->new_sha1))
 663                return -1; /* end of list */
 664        *cmd_list = NULL; /* this returns only one */
 665        hashcpy(sha1, cmd->new_sha1);
 666        return 0;
 667}
 668
 669static void set_connectivity_errors(struct command *commands)
 670{
 671        struct command *cmd;
 672
 673        for (cmd = commands; cmd; cmd = cmd->next) {
 674                struct command *singleton = cmd;
 675                if (!check_everything_connected(command_singleton_iterator,
 676                                                0, &singleton))
 677                        continue;
 678                cmd->error_string = "missing necessary objects";
 679        }
 680}
 681
 682static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
 683{
 684        struct command **cmd_list = cb_data;
 685        struct command *cmd = *cmd_list;
 686
 687        while (cmd) {
 688                if (!is_null_sha1(cmd->new_sha1)) {
 689                        hashcpy(sha1, cmd->new_sha1);
 690                        *cmd_list = cmd->next;
 691                        return 0;
 692                }
 693                cmd = cmd->next;
 694        }
 695        *cmd_list = NULL;
 696        return -1; /* end of list */
 697}
 698
 699static void reject_updates_to_hidden(struct command *commands)
 700{
 701        struct command *cmd;
 702
 703        for (cmd = commands; cmd; cmd = cmd->next) {
 704                if (cmd->error_string || !ref_is_hidden(cmd->ref_name))
 705                        continue;
 706                if (is_null_sha1(cmd->new_sha1))
 707                        cmd->error_string = "deny deleting a hidden ref";
 708                else
 709                        cmd->error_string = "deny updating a hidden ref";
 710        }
 711}
 712
 713static void execute_commands(struct command *commands, const char *unpacker_error)
 714{
 715        struct command *cmd;
 716        unsigned char sha1[20];
 717
 718        if (unpacker_error) {
 719                for (cmd = commands; cmd; cmd = cmd->next)
 720                        cmd->error_string = "unpacker error";
 721                return;
 722        }
 723
 724        cmd = commands;
 725        if (check_everything_connected(iterate_receive_command_list,
 726                                       0, &cmd))
 727                set_connectivity_errors(commands);
 728
 729        reject_updates_to_hidden(commands);
 730
 731        if (run_receive_hook(commands, pre_receive_hook, 0)) {
 732                for (cmd = commands; cmd; cmd = cmd->next) {
 733                        if (!cmd->error_string)
 734                                cmd->error_string = "pre-receive hook declined";
 735                }
 736                return;
 737        }
 738
 739        check_aliased_updates(commands);
 740
 741        free(head_name_to_free);
 742        head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
 743
 744        for (cmd = commands; cmd; cmd = cmd->next) {
 745                if (cmd->error_string)
 746                        continue;
 747
 748                if (cmd->skip_update)
 749                        continue;
 750
 751                cmd->error_string = update(cmd);
 752        }
 753}
 754
 755static struct command *read_head_info(void)
 756{
 757        struct command *commands = NULL;
 758        struct command **p = &commands;
 759        for (;;) {
 760                static char line[1000];
 761                unsigned char old_sha1[20], new_sha1[20];
 762                struct command *cmd;
 763                char *refname;
 764                int len, reflen;
 765
 766                len = packet_read_line(0, line, sizeof(line));
 767                if (!len)
 768                        break;
 769                if (line[len-1] == '\n')
 770                        line[--len] = 0;
 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                return hdr_err;
 836        snprintf(hdr_arg, sizeof(hdr_arg),
 837                        "--pack_header=%"PRIu32",%"PRIu32,
 838                        ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
 839
 840        if (ntohl(hdr.hdr_entries) < unpack_limit) {
 841                int code, i = 0;
 842                struct child_process child;
 843                const char *unpacker[5];
 844                unpacker[i++] = "unpack-objects";
 845                if (quiet)
 846                        unpacker[i++] = "-q";
 847                if (fsck_objects)
 848                        unpacker[i++] = "--strict";
 849                unpacker[i++] = hdr_arg;
 850                unpacker[i++] = NULL;
 851                memset(&child, 0, sizeof(child));
 852                child.argv = unpacker;
 853                child.no_stdout = 1;
 854                child.err = err_fd;
 855                child.git_cmd = 1;
 856                code = run_command(&child);
 857                if (!code)
 858                        return NULL;
 859                return "unpack-objects abnormal exit";
 860        } else {
 861                const char *keeper[7];
 862                int s, status, i = 0;
 863                char keep_arg[256];
 864                struct child_process ip;
 865
 866                s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
 867                if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 868                        strcpy(keep_arg + s, "localhost");
 869
 870                keeper[i++] = "index-pack";
 871                keeper[i++] = "--stdin";
 872                if (fsck_objects)
 873                        keeper[i++] = "--strict";
 874                keeper[i++] = "--fix-thin";
 875                keeper[i++] = hdr_arg;
 876                keeper[i++] = keep_arg;
 877                keeper[i++] = NULL;
 878                memset(&ip, 0, sizeof(ip));
 879                ip.argv = keeper;
 880                ip.out = -1;
 881                ip.err = err_fd;
 882                ip.git_cmd = 1;
 883                status = start_command(&ip);
 884                if (status) {
 885                        return "index-pack fork failed";
 886                }
 887                pack_lockfile = index_pack_lockfile(ip.out);
 888                close(ip.out);
 889                status = finish_command(&ip);
 890                if (!status) {
 891                        reprepare_packed_git();
 892                        return NULL;
 893                }
 894                return "index-pack abnormal exit";
 895        }
 896}
 897
 898static const char *unpack_with_sideband(void)
 899{
 900        struct async muxer;
 901        const char *ret;
 902
 903        if (!use_sideband)
 904                return unpack(0);
 905
 906        memset(&muxer, 0, sizeof(muxer));
 907        muxer.proc = copy_to_sideband;
 908        muxer.in = -1;
 909        if (start_async(&muxer))
 910                return NULL;
 911
 912        ret = unpack(muxer.in);
 913
 914        finish_async(&muxer);
 915        return ret;
 916}
 917
 918static void report(struct command *commands, const char *unpack_status)
 919{
 920        struct command *cmd;
 921        struct strbuf buf = STRBUF_INIT;
 922
 923        packet_buf_write(&buf, "unpack %s\n",
 924                         unpack_status ? unpack_status : "ok");
 925        for (cmd = commands; cmd; cmd = cmd->next) {
 926                if (!cmd->error_string)
 927                        packet_buf_write(&buf, "ok %s\n",
 928                                         cmd->ref_name);
 929                else
 930                        packet_buf_write(&buf, "ng %s %s\n",
 931                                         cmd->ref_name, cmd->error_string);
 932        }
 933        packet_buf_flush(&buf);
 934
 935        if (use_sideband)
 936                send_sideband(1, 1, buf.buf, buf.len, use_sideband);
 937        else
 938                safe_write(1, buf.buf, buf.len);
 939        strbuf_release(&buf);
 940}
 941
 942static int delete_only(struct command *commands)
 943{
 944        struct command *cmd;
 945        for (cmd = commands; cmd; cmd = cmd->next) {
 946                if (!is_null_sha1(cmd->new_sha1))
 947                        return 0;
 948        }
 949        return 1;
 950}
 951
 952int cmd_receive_pack(int argc, const char **argv, const char *prefix)
 953{
 954        int advertise_refs = 0;
 955        int stateless_rpc = 0;
 956        int i;
 957        char *dir = NULL;
 958        struct command *commands;
 959
 960        packet_trace_identity("receive-pack");
 961
 962        argv++;
 963        for (i = 1; i < argc; i++) {
 964                const char *arg = *argv++;
 965
 966                if (*arg == '-') {
 967                        if (!strcmp(arg, "--quiet")) {
 968                                quiet = 1;
 969                                continue;
 970                        }
 971
 972                        if (!strcmp(arg, "--advertise-refs")) {
 973                                advertise_refs = 1;
 974                                continue;
 975                        }
 976                        if (!strcmp(arg, "--stateless-rpc")) {
 977                                stateless_rpc = 1;
 978                                continue;
 979                        }
 980
 981                        usage(receive_pack_usage);
 982                }
 983                if (dir)
 984                        usage(receive_pack_usage);
 985                dir = xstrdup(arg);
 986        }
 987        if (!dir)
 988                usage(receive_pack_usage);
 989
 990        setup_path();
 991
 992        if (!enter_repo(dir, 0))
 993                die("'%s' does not appear to be a git repository", dir);
 994
 995        if (is_repository_shallow())
 996                die("attempt to push into a shallow repository");
 997
 998        git_config(receive_pack_config, NULL);
 999
1000        if (0 <= transfer_unpack_limit)
1001                unpack_limit = transfer_unpack_limit;
1002        else if (0 <= receive_unpack_limit)
1003                unpack_limit = receive_unpack_limit;
1004
1005        if (advertise_refs || !stateless_rpc) {
1006                write_head_info();
1007        }
1008        if (advertise_refs)
1009                return 0;
1010
1011        if ((commands = read_head_info()) != NULL) {
1012                const char *unpack_status = NULL;
1013
1014                if (!delete_only(commands))
1015                        unpack_status = unpack_with_sideband();
1016                execute_commands(commands, unpack_status);
1017                if (pack_lockfile)
1018                        unlink_or_warn(pack_lockfile);
1019                if (report_status)
1020                        report(commands, unpack_status);
1021                run_receive_hook(commands, post_receive_hook, 1);
1022                run_update_post_hook(commands);
1023                if (auto_gc) {
1024                        const char *argv_gc_auto[] = {
1025                                "gc", "--auto", "--quiet", NULL,
1026                        };
1027                        int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1028                        run_command_v_opt(argv_gc_auto, opt);
1029                }
1030                if (auto_update_server_info)
1031                        update_server_info(0);
1032        }
1033        if (use_sideband)
1034                packet_flush(1);
1035        return 0;
1036}