Andrew's git / gitweb.git / builtin/receive-pack.c
?
builtin / receive-pack.con commit reset: optionally setup worktree and refresh index on --mixed (b7756d4)
   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        /* EOF */
 182        packet_flush(1);
 183}
 184
 185struct command {
 186        struct command *next;
 187        const char *error_string;
 188        unsigned int skip_update:1,
 189                     did_not_exist:1;
 190        unsigned char old_sha1[20];
 191        unsigned char new_sha1[20];
 192        char ref_name[FLEX_ARRAY]; /* more */
 193};
 194
 195static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
 196static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
 197
 198static void report_message(const char *prefix, const char *err, va_list params)
 199{
 200        int sz = strlen(prefix);
 201        char msg[4096];
 202
 203        strncpy(msg, prefix, sz);
 204        sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
 205        if (sz > (sizeof(msg) - 1))
 206                sz = sizeof(msg) - 1;
 207        msg[sz++] = '\n';
 208
 209        if (use_sideband)
 210                send_sideband(1, 2, msg, sz, use_sideband);
 211        else
 212                xwrite(2, msg, sz);
 213}
 214
 215static void rp_warning(const char *err, ...)
 216{
 217        va_list params;
 218        va_start(params, err);
 219        report_message("warning: ", err, params);
 220        va_end(params);
 221}
 222
 223static void rp_error(const char *err, ...)
 224{
 225        va_list params;
 226        va_start(params, err);
 227        report_message("error: ", err, params);
 228        va_end(params);
 229}
 230
 231static int copy_to_sideband(int in, int out, void *arg)
 232{
 233        char data[128];
 234        while (1) {
 235                ssize_t sz = xread(in, data, sizeof(data));
 236                if (sz <= 0)
 237                        break;
 238                send_sideband(1, 2, data, sz, use_sideband);
 239        }
 240        close(in);
 241        return 0;
 242}
 243
 244typedef int (*feed_fn)(void *, const char **, size_t *);
 245static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
 246{
 247        struct child_process proc;
 248        struct async muxer;
 249        const char *argv[2];
 250        int code;
 251
 252        argv[0] = find_hook(hook_name);
 253        if (!argv[0])
 254                return 0;
 255
 256        argv[1] = NULL;
 257
 258        memset(&proc, 0, sizeof(proc));
 259        proc.argv = argv;
 260        proc.in = -1;
 261        proc.stdout_to_stderr = 1;
 262
 263        if (use_sideband) {
 264                memset(&muxer, 0, sizeof(muxer));
 265                muxer.proc = copy_to_sideband;
 266                muxer.in = -1;
 267                code = start_async(&muxer);
 268                if (code)
 269                        return code;
 270                proc.err = muxer.in;
 271        }
 272
 273        code = start_command(&proc);
 274        if (code) {
 275                if (use_sideband)
 276                        finish_async(&muxer);
 277                return code;
 278        }
 279
 280        while (1) {
 281                const char *buf;
 282                size_t n;
 283                if (feed(feed_state, &buf, &n))
 284                        break;
 285                if (write_in_full(proc.in, buf, n) != n)
 286                        break;
 287        }
 288        close(proc.in);
 289        if (use_sideband)
 290                finish_async(&muxer);
 291        return finish_command(&proc);
 292}
 293
 294struct receive_hook_feed_state {
 295        struct command *cmd;
 296        int skip_broken;
 297        struct strbuf buf;
 298};
 299
 300static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
 301{
 302        struct receive_hook_feed_state *state = state_;
 303        struct command *cmd = state->cmd;
 304
 305        while (cmd &&
 306               state->skip_broken && (cmd->error_string || cmd->did_not_exist))
 307                cmd = cmd->next;
 308        if (!cmd)
 309                return -1; /* EOF */
 310        strbuf_reset(&state->buf);
 311        strbuf_addf(&state->buf, "%s %s %s\n",
 312                    sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
 313                    cmd->ref_name);
 314        state->cmd = cmd->next;
 315        if (bufp) {
 316                *bufp = state->buf.buf;
 317                *sizep = state->buf.len;
 318        }
 319        return 0;
 320}
 321
 322static int run_receive_hook(struct command *commands, const char *hook_name,
 323                            int skip_broken)
 324{
 325        struct receive_hook_feed_state state;
 326        int status;
 327
 328        strbuf_init(&state.buf, 0);
 329        state.cmd = commands;
 330        state.skip_broken = skip_broken;
 331        if (feed_receive_hook(&state, NULL, NULL))
 332                return 0;
 333        state.cmd = commands;
 334        status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
 335        strbuf_release(&state.buf);
 336        return status;
 337}
 338
 339static int run_update_hook(struct command *cmd)
 340{
 341        const char *argv[5];
 342        struct child_process proc;
 343        int code;
 344
 345        argv[0] = find_hook("update");
 346        if (!argv[0])
 347                return 0;
 348
 349        argv[1] = cmd->ref_name;
 350        argv[2] = sha1_to_hex(cmd->old_sha1);
 351        argv[3] = sha1_to_hex(cmd->new_sha1);
 352        argv[4] = NULL;
 353
 354        memset(&proc, 0, sizeof(proc));
 355        proc.no_stdin = 1;
 356        proc.stdout_to_stderr = 1;
 357        proc.err = use_sideband ? -1 : 0;
 358        proc.argv = argv;
 359
 360        code = start_command(&proc);
 361        if (code)
 362                return code;
 363        if (use_sideband)
 364                copy_to_sideband(proc.err, -1, NULL);
 365        return finish_command(&proc);
 366}
 367
 368static int is_ref_checked_out(const char *ref)
 369{
 370        if (is_bare_repository())
 371                return 0;
 372
 373        if (!head_name)
 374                return 0;
 375        return !strcmp(head_name, ref);
 376}
 377
 378static char *refuse_unconfigured_deny_msg[] = {
 379        "By default, updating the current branch in a non-bare repository",
 380        "is denied, because it will make the index and work tree inconsistent",
 381        "with what you pushed, and will require 'git reset --hard' to match",
 382        "the work tree to HEAD.",
 383        "",
 384        "You can set 'receive.denyCurrentBranch' configuration variable to",
 385        "'ignore' or 'warn' in the remote repository to allow pushing into",
 386        "its current branch; however, this is not recommended unless you",
 387        "arranged to update its work tree to match what you pushed in some",
 388        "other way.",
 389        "",
 390        "To squelch this message and still keep the default behaviour, set",
 391        "'receive.denyCurrentBranch' configuration variable to 'refuse'."
 392};
 393
 394static void refuse_unconfigured_deny(void)
 395{
 396        int i;
 397        for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
 398                rp_error("%s", refuse_unconfigured_deny_msg[i]);
 399}
 400
 401static char *refuse_unconfigured_deny_delete_current_msg[] = {
 402        "By default, deleting the current branch is denied, because the next",
 403        "'git clone' won't result in any file checked out, causing confusion.",
 404        "",
 405        "You can set 'receive.denyDeleteCurrent' configuration variable to",
 406        "'warn' or 'ignore' in the remote repository to allow deleting the",
 407        "current branch, with or without a warning message.",
 408        "",
 409        "To squelch this message, you can set it to 'refuse'."
 410};
 411
 412static void refuse_unconfigured_deny_delete_current(void)
 413{
 414        int i;
 415        for (i = 0;
 416             i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
 417             i++)
 418                rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
 419}
 420
 421static const char *update(struct command *cmd)
 422{
 423        const char *name = cmd->ref_name;
 424        struct strbuf namespaced_name_buf = STRBUF_INIT;
 425        const char *namespaced_name;
 426        unsigned char *old_sha1 = cmd->old_sha1;
 427        unsigned char *new_sha1 = cmd->new_sha1;
 428        struct ref_lock *lock;
 429
 430        /* only refs/... are allowed */
 431        if (prefixcmp(name, "refs/") || check_refname_format(name + 5, 0)) {
 432                rp_error("refusing to create funny ref '%s' remotely", name);
 433                return "funny refname";
 434        }
 435
 436        strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
 437        namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
 438
 439        if (is_ref_checked_out(namespaced_name)) {
 440                switch (deny_current_branch) {
 441                case DENY_IGNORE:
 442                        break;
 443                case DENY_WARN:
 444                        rp_warning("updating the current branch");
 445                        break;
 446                case DENY_REFUSE:
 447                case DENY_UNCONFIGURED:
 448                        rp_error("refusing to update checked out branch: %s", name);
 449                        if (deny_current_branch == DENY_UNCONFIGURED)
 450                                refuse_unconfigured_deny();
 451                        return "branch is currently checked out";
 452                }
 453        }
 454
 455        if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
 456                error("unpack should have generated %s, "
 457                      "but I can't find it!", sha1_to_hex(new_sha1));
 458                return "bad pack";
 459        }
 460
 461        if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
 462                if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
 463                        rp_error("denying ref deletion for %s", name);
 464                        return "deletion prohibited";
 465                }
 466
 467                if (!strcmp(namespaced_name, head_name)) {
 468                        switch (deny_delete_current) {
 469                        case DENY_IGNORE:
 470                                break;
 471                        case DENY_WARN:
 472                                rp_warning("deleting the current branch");
 473                                break;
 474                        case DENY_REFUSE:
 475                        case DENY_UNCONFIGURED:
 476                                if (deny_delete_current == DENY_UNCONFIGURED)
 477                                        refuse_unconfigured_deny_delete_current();
 478                                rp_error("refusing to delete the current branch: %s", name);
 479                                return "deletion of the current branch prohibited";
 480                        }
 481                }
 482        }
 483
 484        if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
 485            !is_null_sha1(old_sha1) &&
 486            !prefixcmp(name, "refs/heads/")) {
 487                struct object *old_object, *new_object;
 488                struct commit *old_commit, *new_commit;
 489
 490                old_object = parse_object(old_sha1);
 491                new_object = parse_object(new_sha1);
 492
 493                if (!old_object || !new_object ||
 494                    old_object->type != OBJ_COMMIT ||
 495                    new_object->type != OBJ_COMMIT) {
 496                        error("bad sha1 objects for %s", name);
 497                        return "bad ref";
 498                }
 499                old_commit = (struct commit *)old_object;
 500                new_commit = (struct commit *)new_object;
 501                if (!in_merge_bases(old_commit, new_commit)) {
 502                        rp_error("denying non-fast-forward %s"
 503                                 " (you should pull first)", name);
 504                        return "non-fast-forward";
 505                }
 506        }
 507        if (run_update_hook(cmd)) {
 508                rp_error("hook declined to update %s", name);
 509                return "hook declined";
 510        }
 511
 512        if (is_null_sha1(new_sha1)) {
 513                if (!parse_object(old_sha1)) {
 514                        old_sha1 = NULL;
 515                        if (ref_exists(name)) {
 516                                rp_warning("Allowing deletion of corrupt ref.");
 517                        } else {
 518                                rp_warning("Deleting a non-existent ref.");
 519                                cmd->did_not_exist = 1;
 520                        }
 521                }
 522                if (delete_ref(namespaced_name, old_sha1, 0)) {
 523                        rp_error("failed to delete %s", name);
 524                        return "failed to delete";
 525                }
 526                return NULL; /* good */
 527        }
 528        else {
 529                lock = lock_any_ref_for_update(namespaced_name, old_sha1,
 530                                               0, NULL);
 531                if (!lock) {
 532                        rp_error("failed to lock %s", name);
 533                        return "failed to lock";
 534                }
 535                if (write_ref_sha1(lock, new_sha1, "push")) {
 536                        return "failed to write"; /* error() already called */
 537                }
 538                return NULL; /* good */
 539        }
 540}
 541
 542static void run_update_post_hook(struct command *commands)
 543{
 544        struct command *cmd;
 545        int argc;
 546        const char **argv;
 547        struct child_process proc;
 548        char *hook;
 549
 550        hook = find_hook("post-update");
 551        for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
 552                if (cmd->error_string || cmd->did_not_exist)
 553                        continue;
 554                argc++;
 555        }
 556        if (!argc || !hook)
 557                return;
 558
 559        argv = xmalloc(sizeof(*argv) * (2 + argc));
 560        argv[0] = 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", 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                char *line;
 761                unsigned char old_sha1[20], new_sha1[20];
 762                struct command *cmd;
 763                char *refname;
 764                int len, reflen;
 765
 766                line = packet_read_line(0, &len);
 767                if (!line)
 768                        break;
 769                if (len < 83 ||
 770                    line[40] != ' ' ||
 771                    line[81] != ' ' ||
 772                    get_sha1_hex(line, old_sha1) ||
 773                    get_sha1_hex(line + 41, new_sha1))
 774                        die("protocol error: expected old/new/ref, got '%s'",
 775                            line);
 776
 777                refname = line + 82;
 778                reflen = strlen(refname);
 779                if (reflen + 82 < len) {
 780                        const char *feature_list = refname + reflen + 1;
 781                        if (parse_feature_request(feature_list, "report-status"))
 782                                report_status = 1;
 783                        if (parse_feature_request(feature_list, "side-band-64k"))
 784                                use_sideband = LARGE_PACKET_MAX;
 785                        if (parse_feature_request(feature_list, "quiet"))
 786                                quiet = 1;
 787                }
 788                cmd = xcalloc(1, sizeof(struct command) + len - 80);
 789                hashcpy(cmd->old_sha1, old_sha1);
 790                hashcpy(cmd->new_sha1, new_sha1);
 791                memcpy(cmd->ref_name, line + 82, len - 81);
 792                *p = cmd;
 793                p = &cmd->next;
 794        }
 795        return commands;
 796}
 797
 798static const char *parse_pack_header(struct pack_header *hdr)
 799{
 800        switch (read_pack_header(0, hdr)) {
 801        case PH_ERROR_EOF:
 802                return "eof before pack header was fully read";
 803
 804        case PH_ERROR_PACK_SIGNATURE:
 805                return "protocol error (pack signature mismatch detected)";
 806
 807        case PH_ERROR_PROTOCOL:
 808                return "protocol error (pack version unsupported)";
 809
 810        default:
 811                return "unknown error in parse_pack_header";
 812
 813        case 0:
 814                return NULL;
 815        }
 816}
 817
 818static const char *pack_lockfile;
 819
 820static const char *unpack(int err_fd)
 821{
 822        struct pack_header hdr;
 823        const char *hdr_err;
 824        char hdr_arg[38];
 825        int fsck_objects = (receive_fsck_objects >= 0
 826                            ? receive_fsck_objects
 827                            : transfer_fsck_objects >= 0
 828                            ? transfer_fsck_objects
 829                            : 0);
 830
 831        hdr_err = parse_pack_header(&hdr);
 832        if (hdr_err) {
 833                if (err_fd > 0)
 834                        close(err_fd);
 835                return hdr_err;
 836        }
 837        snprintf(hdr_arg, sizeof(hdr_arg),
 838                        "--pack_header=%"PRIu32",%"PRIu32,
 839                        ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
 840
 841        if (ntohl(hdr.hdr_entries) < unpack_limit) {
 842                int code, i = 0;
 843                struct child_process child;
 844                const char *unpacker[5];
 845                unpacker[i++] = "unpack-objects";
 846                if (quiet)
 847                        unpacker[i++] = "-q";
 848                if (fsck_objects)
 849                        unpacker[i++] = "--strict";
 850                unpacker[i++] = hdr_arg;
 851                unpacker[i++] = NULL;
 852                memset(&child, 0, sizeof(child));
 853                child.argv = unpacker;
 854                child.no_stdout = 1;
 855                child.err = err_fd;
 856                child.git_cmd = 1;
 857                code = run_command(&child);
 858                if (!code)
 859                        return NULL;
 860                return "unpack-objects abnormal exit";
 861        } else {
 862                const char *keeper[7];
 863                int s, status, i = 0;
 864                char keep_arg[256];
 865                struct child_process ip;
 866
 867                s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
 868                if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 869                        strcpy(keep_arg + s, "localhost");
 870
 871                keeper[i++] = "index-pack";
 872                keeper[i++] = "--stdin";
 873                if (fsck_objects)
 874                        keeper[i++] = "--strict";
 875                if (fix_thin)
 876                        keeper[i++] = "--fix-thin";
 877                keeper[i++] = hdr_arg;
 878                keeper[i++] = keep_arg;
 879                keeper[i++] = NULL;
 880                memset(&ip, 0, sizeof(ip));
 881                ip.argv = keeper;
 882                ip.out = -1;
 883                ip.err = err_fd;
 884                ip.git_cmd = 1;
 885                status = start_command(&ip);
 886                if (status) {
 887                        return "index-pack fork failed";
 888                }
 889                pack_lockfile = index_pack_lockfile(ip.out);
 890                close(ip.out);
 891                status = finish_command(&ip);
 892                if (!status) {
 893                        reprepare_packed_git();
 894                        return NULL;
 895                }
 896                return "index-pack abnormal exit";
 897        }
 898}
 899
 900static const char *unpack_with_sideband(void)
 901{
 902        struct async muxer;
 903        const char *ret;
 904
 905        if (!use_sideband)
 906                return unpack(0);
 907
 908        memset(&muxer, 0, sizeof(muxer));
 909        muxer.proc = copy_to_sideband;
 910        muxer.in = -1;
 911        if (start_async(&muxer))
 912                return NULL;
 913
 914        ret = unpack(muxer.in);
 915
 916        finish_async(&muxer);
 917        return ret;
 918}
 919
 920static void report(struct command *commands, const char *unpack_status)
 921{
 922        struct command *cmd;
 923        struct strbuf buf = STRBUF_INIT;
 924
 925        packet_buf_write(&buf, "unpack %s\n",
 926                         unpack_status ? unpack_status : "ok");
 927        for (cmd = commands; cmd; cmd = cmd->next) {
 928                if (!cmd->error_string)
 929                        packet_buf_write(&buf, "ok %s\n",
 930                                         cmd->ref_name);
 931                else
 932                        packet_buf_write(&buf, "ng %s %s\n",
 933                                         cmd->ref_name, cmd->error_string);
 934        }
 935        packet_buf_flush(&buf);
 936
 937        if (use_sideband)
 938                send_sideband(1, 1, buf.buf, buf.len, use_sideband);
 939        else
 940                write_or_die(1, buf.buf, buf.len);
 941        strbuf_release(&buf);
 942}
 943
 944static int delete_only(struct command *commands)
 945{
 946        struct command *cmd;
 947        for (cmd = commands; cmd; cmd = cmd->next) {
 948                if (!is_null_sha1(cmd->new_sha1))
 949                        return 0;
 950        }
 951        return 1;
 952}
 953
 954int cmd_receive_pack(int argc, const char **argv, const char *prefix)
 955{
 956        int advertise_refs = 0;
 957        int stateless_rpc = 0;
 958        int i;
 959        char *dir = NULL;
 960        struct command *commands;
 961
 962        packet_trace_identity("receive-pack");
 963
 964        argv++;
 965        for (i = 1; i < argc; i++) {
 966                const char *arg = *argv++;
 967
 968                if (*arg == '-') {
 969                        if (!strcmp(arg, "--quiet")) {
 970                                quiet = 1;
 971                                continue;
 972                        }
 973
 974                        if (!strcmp(arg, "--advertise-refs")) {
 975                                advertise_refs = 1;
 976                                continue;
 977                        }
 978                        if (!strcmp(arg, "--stateless-rpc")) {
 979                                stateless_rpc = 1;
 980                                continue;
 981                        }
 982                        if (!strcmp(arg, "--reject-thin-pack-for-testing")) {
 983                                fix_thin = 0;
 984                                continue;
 985                        }
 986
 987                        usage(receive_pack_usage);
 988                }
 989                if (dir)
 990                        usage(receive_pack_usage);
 991                dir = xstrdup(arg);
 992        }
 993        if (!dir)
 994                usage(receive_pack_usage);
 995
 996        setup_path();
 997
 998        if (!enter_repo(dir, 0))
 999                die("'%s' does not appear to be a git repository", dir);
1000
1001        if (is_repository_shallow())
1002                die("attempt to push into a shallow repository");
1003
1004        git_config(receive_pack_config, NULL);
1005
1006        if (0 <= transfer_unpack_limit)
1007                unpack_limit = transfer_unpack_limit;
1008        else if (0 <= receive_unpack_limit)
1009                unpack_limit = receive_unpack_limit;
1010
1011        if (advertise_refs || !stateless_rpc) {
1012                write_head_info();
1013        }
1014        if (advertise_refs)
1015                return 0;
1016
1017        if ((commands = read_head_info()) != NULL) {
1018                const char *unpack_status = NULL;
1019
1020                if (!delete_only(commands))
1021                        unpack_status = unpack_with_sideband();
1022                execute_commands(commands, unpack_status);
1023                if (pack_lockfile)
1024                        unlink_or_warn(pack_lockfile);
1025                if (report_status)
1026                        report(commands, unpack_status);
1027                run_receive_hook(commands, "post-receive", 1);
1028                run_update_post_hook(commands);
1029                if (auto_gc) {
1030                        const char *argv_gc_auto[] = {
1031                                "gc", "--auto", "--quiet", NULL,
1032                        };
1033                        int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1034                        run_command_v_opt(argv_gc_auto, opt);
1035                }
1036                if (auto_update_server_info)
1037                        update_server_info(0);
1038        }
1039        if (use_sideband)
1040                packet_flush(1);
1041        return 0;
1042}