Andrew's git / gitweb.git / builtin/receive-pack.c
?
builtin / receive-pack.con commit update-ref: add test cases covering --stdin signature (c6268bc)
   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,
 528                                               0, NULL);
 529                if (!lock) {
 530                        rp_error("failed to lock %s", name);
 531                        return "failed to lock";
 532                }
 533                if (write_ref_sha1(lock, new_sha1, "push")) {
 534                        return "failed to write"; /* error() already called */
 535                }
 536                return NULL; /* good */
 537        }
 538}
 539
 540static void run_update_post_hook(struct command *commands)
 541{
 542        struct command *cmd;
 543        int argc;
 544        const char **argv;
 545        struct child_process proc;
 546        char *hook;
 547
 548        hook = find_hook("post-update");
 549        for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
 550                if (cmd->error_string || cmd->did_not_exist)
 551                        continue;
 552                argc++;
 553        }
 554        if (!argc || !hook)
 555                return;
 556
 557        argv = xmalloc(sizeof(*argv) * (2 + argc));
 558        argv[0] = hook;
 559
 560        for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
 561                char *p;
 562                if (cmd->error_string || cmd->did_not_exist)
 563                        continue;
 564                p = xmalloc(strlen(cmd->ref_name) + 1);
 565                strcpy(p, cmd->ref_name);
 566                argv[argc] = p;
 567                argc++;
 568        }
 569        argv[argc] = NULL;
 570
 571        memset(&proc, 0, sizeof(proc));
 572        proc.no_stdin = 1;
 573        proc.stdout_to_stderr = 1;
 574        proc.err = use_sideband ? -1 : 0;
 575        proc.argv = argv;
 576
 577        if (!start_command(&proc)) {
 578                if (use_sideband)
 579                        copy_to_sideband(proc.err, -1, NULL);
 580                finish_command(&proc);
 581        }
 582}
 583
 584static void check_aliased_update(struct command *cmd, struct string_list *list)
 585{
 586        struct strbuf buf = STRBUF_INIT;
 587        const char *dst_name;
 588        struct string_list_item *item;
 589        struct command *dst_cmd;
 590        unsigned char sha1[20];
 591        char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
 592        int flag;
 593
 594        strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
 595        dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
 596        strbuf_release(&buf);
 597
 598        if (!(flag & REF_ISSYMREF))
 599                return;
 600
 601        dst_name = strip_namespace(dst_name);
 602        if (!dst_name) {
 603                rp_error("refusing update to broken symref '%s'", cmd->ref_name);
 604                cmd->skip_update = 1;
 605                cmd->error_string = "broken symref";
 606                return;
 607        }
 608
 609        if ((item = string_list_lookup(list, dst_name)) == NULL)
 610                return;
 611
 612        cmd->skip_update = 1;
 613
 614        dst_cmd = (struct command *) item->util;
 615
 616        if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
 617            !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
 618                return;
 619
 620        dst_cmd->skip_update = 1;
 621
 622        strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
 623        strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
 624        strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
 625        strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
 626        rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
 627                 " its target '%s' (%s..%s)",
 628                 cmd->ref_name, cmd_oldh, cmd_newh,
 629                 dst_cmd->ref_name, dst_oldh, dst_newh);
 630
 631        cmd->error_string = dst_cmd->error_string =
 632                "inconsistent aliased update";
 633}
 634
 635static void check_aliased_updates(struct command *commands)
 636{
 637        struct command *cmd;
 638        struct string_list ref_list = STRING_LIST_INIT_NODUP;
 639
 640        for (cmd = commands; cmd; cmd = cmd->next) {
 641                struct string_list_item *item =
 642                        string_list_append(&ref_list, cmd->ref_name);
 643                item->util = (void *)cmd;
 644        }
 645        sort_string_list(&ref_list);
 646
 647        for (cmd = commands; cmd; cmd = cmd->next) {
 648                if (!cmd->error_string)
 649                        check_aliased_update(cmd, &ref_list);
 650        }
 651
 652        string_list_clear(&ref_list, 0);
 653}
 654
 655static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
 656{
 657        struct command **cmd_list = cb_data;
 658        struct command *cmd = *cmd_list;
 659
 660        if (!cmd || is_null_sha1(cmd->new_sha1))
 661                return -1; /* end of list */
 662        *cmd_list = NULL; /* this returns only one */
 663        hashcpy(sha1, cmd->new_sha1);
 664        return 0;
 665}
 666
 667static void set_connectivity_errors(struct command *commands)
 668{
 669        struct command *cmd;
 670
 671        for (cmd = commands; cmd; cmd = cmd->next) {
 672                struct command *singleton = cmd;
 673                if (!check_everything_connected(command_singleton_iterator,
 674                                                0, &singleton))
 675                        continue;
 676                cmd->error_string = "missing necessary objects";
 677        }
 678}
 679
 680static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
 681{
 682        struct command **cmd_list = cb_data;
 683        struct command *cmd = *cmd_list;
 684
 685        while (cmd) {
 686                if (!is_null_sha1(cmd->new_sha1)) {
 687                        hashcpy(sha1, cmd->new_sha1);
 688                        *cmd_list = cmd->next;
 689                        return 0;
 690                }
 691                cmd = cmd->next;
 692        }
 693        *cmd_list = NULL;
 694        return -1; /* end of list */
 695}
 696
 697static void reject_updates_to_hidden(struct command *commands)
 698{
 699        struct command *cmd;
 700
 701        for (cmd = commands; cmd; cmd = cmd->next) {
 702                if (cmd->error_string || !ref_is_hidden(cmd->ref_name))
 703                        continue;
 704                if (is_null_sha1(cmd->new_sha1))
 705                        cmd->error_string = "deny deleting a hidden ref";
 706                else
 707                        cmd->error_string = "deny updating a hidden ref";
 708        }
 709}
 710
 711static void execute_commands(struct command *commands, const char *unpacker_error)
 712{
 713        struct command *cmd;
 714        unsigned char sha1[20];
 715
 716        if (unpacker_error) {
 717                for (cmd = commands; cmd; cmd = cmd->next)
 718                        cmd->error_string = "unpacker error";
 719                return;
 720        }
 721
 722        cmd = commands;
 723        if (check_everything_connected(iterate_receive_command_list,
 724                                       0, &cmd))
 725                set_connectivity_errors(commands);
 726
 727        reject_updates_to_hidden(commands);
 728
 729        if (run_receive_hook(commands, "pre-receive", 0)) {
 730                for (cmd = commands; cmd; cmd = cmd->next) {
 731                        if (!cmd->error_string)
 732                                cmd->error_string = "pre-receive hook declined";
 733                }
 734                return;
 735        }
 736
 737        check_aliased_updates(commands);
 738
 739        free(head_name_to_free);
 740        head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
 741
 742        for (cmd = commands; cmd; cmd = cmd->next) {
 743                if (cmd->error_string)
 744                        continue;
 745
 746                if (cmd->skip_update)
 747                        continue;
 748
 749                cmd->error_string = update(cmd);
 750        }
 751}
 752
 753static struct command *read_head_info(void)
 754{
 755        struct command *commands = NULL;
 756        struct command **p = &commands;
 757        for (;;) {
 758                char *line;
 759                unsigned char old_sha1[20], new_sha1[20];
 760                struct command *cmd;
 761                char *refname;
 762                int len, reflen;
 763
 764                line = packet_read_line(0, &len);
 765                if (!line)
 766                        break;
 767                if (len < 83 ||
 768                    line[40] != ' ' ||
 769                    line[81] != ' ' ||
 770                    get_sha1_hex(line, old_sha1) ||
 771                    get_sha1_hex(line + 41, new_sha1))
 772                        die("protocol error: expected old/new/ref, got '%s'",
 773                            line);
 774
 775                refname = line + 82;
 776                reflen = strlen(refname);
 777                if (reflen + 82 < len) {
 778                        const char *feature_list = refname + reflen + 1;
 779                        if (parse_feature_request(feature_list, "report-status"))
 780                                report_status = 1;
 781                        if (parse_feature_request(feature_list, "side-band-64k"))
 782                                use_sideband = LARGE_PACKET_MAX;
 783                        if (parse_feature_request(feature_list, "quiet"))
 784                                quiet = 1;
 785                }
 786                cmd = xcalloc(1, sizeof(struct command) + len - 80);
 787                hashcpy(cmd->old_sha1, old_sha1);
 788                hashcpy(cmd->new_sha1, new_sha1);
 789                memcpy(cmd->ref_name, line + 82, len - 81);
 790                *p = cmd;
 791                p = &cmd->next;
 792        }
 793        return commands;
 794}
 795
 796static const char *parse_pack_header(struct pack_header *hdr)
 797{
 798        switch (read_pack_header(0, hdr)) {
 799        case PH_ERROR_EOF:
 800                return "eof before pack header was fully read";
 801
 802        case PH_ERROR_PACK_SIGNATURE:
 803                return "protocol error (pack signature mismatch detected)";
 804
 805        case PH_ERROR_PROTOCOL:
 806                return "protocol error (pack version unsupported)";
 807
 808        default:
 809                return "unknown error in parse_pack_header";
 810
 811        case 0:
 812                return NULL;
 813        }
 814}
 815
 816static const char *pack_lockfile;
 817
 818static const char *unpack(int err_fd)
 819{
 820        struct pack_header hdr;
 821        const char *hdr_err;
 822        char hdr_arg[38];
 823        int fsck_objects = (receive_fsck_objects >= 0
 824                            ? receive_fsck_objects
 825                            : transfer_fsck_objects >= 0
 826                            ? transfer_fsck_objects
 827                            : 0);
 828
 829        hdr_err = parse_pack_header(&hdr);
 830        if (hdr_err) {
 831                if (err_fd > 0)
 832                        close(err_fd);
 833                return hdr_err;
 834        }
 835        snprintf(hdr_arg, sizeof(hdr_arg),
 836                        "--pack_header=%"PRIu32",%"PRIu32,
 837                        ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
 838
 839        if (ntohl(hdr.hdr_entries) < unpack_limit) {
 840                int code, i = 0;
 841                struct child_process child;
 842                const char *unpacker[5];
 843                unpacker[i++] = "unpack-objects";
 844                if (quiet)
 845                        unpacker[i++] = "-q";
 846                if (fsck_objects)
 847                        unpacker[i++] = "--strict";
 848                unpacker[i++] = hdr_arg;
 849                unpacker[i++] = NULL;
 850                memset(&child, 0, sizeof(child));
 851                child.argv = unpacker;
 852                child.no_stdout = 1;
 853                child.err = err_fd;
 854                child.git_cmd = 1;
 855                code = run_command(&child);
 856                if (!code)
 857                        return NULL;
 858                return "unpack-objects abnormal exit";
 859        } else {
 860                const char *keeper[7];
 861                int s, status, i = 0;
 862                char keep_arg[256];
 863                struct child_process ip;
 864
 865                s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
 866                if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 867                        strcpy(keep_arg + s, "localhost");
 868
 869                keeper[i++] = "index-pack";
 870                keeper[i++] = "--stdin";
 871                if (fsck_objects)
 872                        keeper[i++] = "--strict";
 873                keeper[i++] = "--fix-thin";
 874                keeper[i++] = hdr_arg;
 875                keeper[i++] = keep_arg;
 876                keeper[i++] = NULL;
 877                memset(&ip, 0, sizeof(ip));
 878                ip.argv = keeper;
 879                ip.out = -1;
 880                ip.err = err_fd;
 881                ip.git_cmd = 1;
 882                status = start_command(&ip);
 883                if (status) {
 884                        return "index-pack fork failed";
 885                }
 886                pack_lockfile = index_pack_lockfile(ip.out);
 887                close(ip.out);
 888                status = finish_command(&ip);
 889                if (!status) {
 890                        reprepare_packed_git();
 891                        return NULL;
 892                }
 893                return "index-pack abnormal exit";
 894        }
 895}
 896
 897static const char *unpack_with_sideband(void)
 898{
 899        struct async muxer;
 900        const char *ret;
 901
 902        if (!use_sideband)
 903                return unpack(0);
 904
 905        memset(&muxer, 0, sizeof(muxer));
 906        muxer.proc = copy_to_sideband;
 907        muxer.in = -1;
 908        if (start_async(&muxer))
 909                return NULL;
 910
 911        ret = unpack(muxer.in);
 912
 913        finish_async(&muxer);
 914        return ret;
 915}
 916
 917static void report(struct command *commands, const char *unpack_status)
 918{
 919        struct command *cmd;
 920        struct strbuf buf = STRBUF_INIT;
 921
 922        packet_buf_write(&buf, "unpack %s\n",
 923                         unpack_status ? unpack_status : "ok");
 924        for (cmd = commands; cmd; cmd = cmd->next) {
 925                if (!cmd->error_string)
 926                        packet_buf_write(&buf, "ok %s\n",
 927                                         cmd->ref_name);
 928                else
 929                        packet_buf_write(&buf, "ng %s %s\n",
 930                                         cmd->ref_name, cmd->error_string);
 931        }
 932        packet_buf_flush(&buf);
 933
 934        if (use_sideband)
 935                send_sideband(1, 1, buf.buf, buf.len, use_sideband);
 936        else
 937                write_or_die(1, buf.buf, buf.len);
 938        strbuf_release(&buf);
 939}
 940
 941static int delete_only(struct command *commands)
 942{
 943        struct command *cmd;
 944        for (cmd = commands; cmd; cmd = cmd->next) {
 945                if (!is_null_sha1(cmd->new_sha1))
 946                        return 0;
 947        }
 948        return 1;
 949}
 950
 951int cmd_receive_pack(int argc, const char **argv, const char *prefix)
 952{
 953        int advertise_refs = 0;
 954        int stateless_rpc = 0;
 955        int i;
 956        char *dir = NULL;
 957        struct command *commands;
 958
 959        packet_trace_identity("receive-pack");
 960
 961        argv++;
 962        for (i = 1; i < argc; i++) {
 963                const char *arg = *argv++;
 964
 965                if (*arg == '-') {
 966                        if (!strcmp(arg, "--quiet")) {
 967                                quiet = 1;
 968                                continue;
 969                        }
 970
 971                        if (!strcmp(arg, "--advertise-refs")) {
 972                                advertise_refs = 1;
 973                                continue;
 974                        }
 975                        if (!strcmp(arg, "--stateless-rpc")) {
 976                                stateless_rpc = 1;
 977                                continue;
 978                        }
 979
 980                        usage(receive_pack_usage);
 981                }
 982                if (dir)
 983                        usage(receive_pack_usage);
 984                dir = xstrdup(arg);
 985        }
 986        if (!dir)
 987                usage(receive_pack_usage);
 988
 989        setup_path();
 990
 991        if (!enter_repo(dir, 0))
 992                die("'%s' does not appear to be a git repository", dir);
 993
 994        if (is_repository_shallow())
 995                die("attempt to push into a shallow repository");
 996
 997        git_config(receive_pack_config, NULL);
 998
 999        if (0 <= transfer_unpack_limit)
1000                unpack_limit = transfer_unpack_limit;
1001        else if (0 <= receive_unpack_limit)
1002                unpack_limit = receive_unpack_limit;
1003
1004        if (advertise_refs || !stateless_rpc) {
1005                write_head_info();
1006        }
1007        if (advertise_refs)
1008                return 0;
1009
1010        if ((commands = read_head_info()) != NULL) {
1011                const char *unpack_status = NULL;
1012
1013                if (!delete_only(commands))
1014                        unpack_status = unpack_with_sideband();
1015                execute_commands(commands, unpack_status);
1016                if (pack_lockfile)
1017                        unlink_or_warn(pack_lockfile);
1018                if (report_status)
1019                        report(commands, unpack_status);
1020                run_receive_hook(commands, "post-receive", 1);
1021                run_update_post_hook(commands);
1022                if (auto_gc) {
1023                        const char *argv_gc_auto[] = {
1024                                "gc", "--auto", "--quiet", NULL,
1025                        };
1026                        int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1027                        run_command_v_opt(argv_gc_auto, opt);
1028                }
1029                if (auto_update_server_info)
1030                        update_server_info(0);
1031        }
1032        if (use_sideband)
1033                packet_flush(1);
1034        return 0;
1035}