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