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