Andrew's git / gitweb.git / builtin/receive-pack.c
?
builtin / receive-pack.con commit Merge branch 'ph/tag-force-no-warn-on-creation' (33c1506)
   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                static char line[1000];
 758                unsigned char old_sha1[20], new_sha1[20];
 759                struct command *cmd;
 760                char *refname;
 761                int len, reflen;
 762
 763                len = packet_read_line(0, line, sizeof(line));
 764                if (!len)
 765                        break;
 766                if (line[len-1] == '\n')
 767                        line[--len] = 0;
 768                if (len < 83 ||
 769                    line[40] != ' ' ||
 770                    line[81] != ' ' ||
 771                    get_sha1_hex(line, old_sha1) ||
 772                    get_sha1_hex(line + 41, new_sha1))
 773                        die("protocol error: expected old/new/ref, got '%s'",
 774                            line);
 775
 776                refname = line + 82;
 777                reflen = strlen(refname);
 778                if (reflen + 82 < len) {
 779                        const char *feature_list = refname + reflen + 1;
 780                        if (parse_feature_request(feature_list, "report-status"))
 781                                report_status = 1;
 782                        if (parse_feature_request(feature_list, "side-band-64k"))
 783                                use_sideband = LARGE_PACKET_MAX;
 784                        if (parse_feature_request(feature_list, "quiet"))
 785                                quiet = 1;
 786                }
 787                cmd = xcalloc(1, sizeof(struct command) + len - 80);
 788                hashcpy(cmd->old_sha1, old_sha1);
 789                hashcpy(cmd->new_sha1, new_sha1);
 790                memcpy(cmd->ref_name, line + 82, len - 81);
 791                *p = cmd;
 792                p = &cmd->next;
 793        }
 794        return commands;
 795}
 796
 797static const char *parse_pack_header(struct pack_header *hdr)
 798{
 799        switch (read_pack_header(0, hdr)) {
 800        case PH_ERROR_EOF:
 801                return "eof before pack header was fully read";
 802
 803        case PH_ERROR_PACK_SIGNATURE:
 804                return "protocol error (pack signature mismatch detected)";
 805
 806        case PH_ERROR_PROTOCOL:
 807                return "protocol error (pack version unsupported)";
 808
 809        default:
 810                return "unknown error in parse_pack_header";
 811
 812        case 0:
 813                return NULL;
 814        }
 815}
 816
 817static const char *pack_lockfile;
 818
 819static const char *unpack(int err_fd)
 820{
 821        struct pack_header hdr;
 822        const char *hdr_err;
 823        char hdr_arg[38];
 824        int fsck_objects = (receive_fsck_objects >= 0
 825                            ? receive_fsck_objects
 826                            : transfer_fsck_objects >= 0
 827                            ? transfer_fsck_objects
 828                            : 0);
 829
 830        hdr_err = parse_pack_header(&hdr);
 831        if (hdr_err)
 832                return hdr_err;
 833        snprintf(hdr_arg, sizeof(hdr_arg),
 834                        "--pack_header=%"PRIu32",%"PRIu32,
 835                        ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
 836
 837        if (ntohl(hdr.hdr_entries) < unpack_limit) {
 838                int code, i = 0;
 839                struct child_process child;
 840                const char *unpacker[5];
 841                unpacker[i++] = "unpack-objects";
 842                if (quiet)
 843                        unpacker[i++] = "-q";
 844                if (fsck_objects)
 845                        unpacker[i++] = "--strict";
 846                unpacker[i++] = hdr_arg;
 847                unpacker[i++] = NULL;
 848                memset(&child, 0, sizeof(child));
 849                child.argv = unpacker;
 850                child.no_stdout = 1;
 851                child.err = err_fd;
 852                child.git_cmd = 1;
 853                code = run_command(&child);
 854                if (!code)
 855                        return NULL;
 856                return "unpack-objects abnormal exit";
 857        } else {
 858                const char *keeper[7];
 859                int s, status, i = 0;
 860                char keep_arg[256];
 861                struct child_process ip;
 862
 863                s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
 864                if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 865                        strcpy(keep_arg + s, "localhost");
 866
 867                keeper[i++] = "index-pack";
 868                keeper[i++] = "--stdin";
 869                if (fsck_objects)
 870                        keeper[i++] = "--strict";
 871                keeper[i++] = "--fix-thin";
 872                keeper[i++] = hdr_arg;
 873                keeper[i++] = keep_arg;
 874                keeper[i++] = NULL;
 875                memset(&ip, 0, sizeof(ip));
 876                ip.argv = keeper;
 877                ip.out = -1;
 878                ip.err = err_fd;
 879                ip.git_cmd = 1;
 880                status = start_command(&ip);
 881                if (status) {
 882                        return "index-pack fork failed";
 883                }
 884                pack_lockfile = index_pack_lockfile(ip.out);
 885                close(ip.out);
 886                status = finish_command(&ip);
 887                if (!status) {
 888                        reprepare_packed_git();
 889                        return NULL;
 890                }
 891                return "index-pack abnormal exit";
 892        }
 893}
 894
 895static const char *unpack_with_sideband(void)
 896{
 897        struct async muxer;
 898        const char *ret;
 899
 900        if (!use_sideband)
 901                return unpack(0);
 902
 903        memset(&muxer, 0, sizeof(muxer));
 904        muxer.proc = copy_to_sideband;
 905        muxer.in = -1;
 906        if (start_async(&muxer))
 907                return NULL;
 908
 909        ret = unpack(muxer.in);
 910
 911        finish_async(&muxer);
 912        return ret;
 913}
 914
 915static void report(struct command *commands, const char *unpack_status)
 916{
 917        struct command *cmd;
 918        struct strbuf buf = STRBUF_INIT;
 919
 920        packet_buf_write(&buf, "unpack %s\n",
 921                         unpack_status ? unpack_status : "ok");
 922        for (cmd = commands; cmd; cmd = cmd->next) {
 923                if (!cmd->error_string)
 924                        packet_buf_write(&buf, "ok %s\n",
 925                                         cmd->ref_name);
 926                else
 927                        packet_buf_write(&buf, "ng %s %s\n",
 928                                         cmd->ref_name, cmd->error_string);
 929        }
 930        packet_buf_flush(&buf);
 931
 932        if (use_sideband)
 933                send_sideband(1, 1, buf.buf, buf.len, use_sideband);
 934        else
 935                safe_write(1, buf.buf, buf.len);
 936        strbuf_release(&buf);
 937}
 938
 939static int delete_only(struct command *commands)
 940{
 941        struct command *cmd;
 942        for (cmd = commands; cmd; cmd = cmd->next) {
 943                if (!is_null_sha1(cmd->new_sha1))
 944                        return 0;
 945        }
 946        return 1;
 947}
 948
 949int cmd_receive_pack(int argc, const char **argv, const char *prefix)
 950{
 951        int advertise_refs = 0;
 952        int stateless_rpc = 0;
 953        int i;
 954        char *dir = NULL;
 955        struct command *commands;
 956
 957        packet_trace_identity("receive-pack");
 958
 959        argv++;
 960        for (i = 1; i < argc; i++) {
 961                const char *arg = *argv++;
 962
 963                if (*arg == '-') {
 964                        if (!strcmp(arg, "--quiet")) {
 965                                quiet = 1;
 966                                continue;
 967                        }
 968
 969                        if (!strcmp(arg, "--advertise-refs")) {
 970                                advertise_refs = 1;
 971                                continue;
 972                        }
 973                        if (!strcmp(arg, "--stateless-rpc")) {
 974                                stateless_rpc = 1;
 975                                continue;
 976                        }
 977
 978                        usage(receive_pack_usage);
 979                }
 980                if (dir)
 981                        usage(receive_pack_usage);
 982                dir = xstrdup(arg);
 983        }
 984        if (!dir)
 985                usage(receive_pack_usage);
 986
 987        setup_path();
 988
 989        if (!enter_repo(dir, 0))
 990                die("'%s' does not appear to be a git repository", dir);
 991
 992        if (is_repository_shallow())
 993                die("attempt to push into a shallow repository");
 994
 995        git_config(receive_pack_config, NULL);
 996
 997        if (0 <= transfer_unpack_limit)
 998                unpack_limit = transfer_unpack_limit;
 999        else if (0 <= receive_unpack_limit)
1000                unpack_limit = receive_unpack_limit;
1001
1002        if (advertise_refs || !stateless_rpc) {
1003                write_head_info();
1004        }
1005        if (advertise_refs)
1006                return 0;
1007
1008        if ((commands = read_head_info()) != NULL) {
1009                const char *unpack_status = NULL;
1010
1011                if (!delete_only(commands))
1012                        unpack_status = unpack_with_sideband();
1013                execute_commands(commands, unpack_status);
1014                if (pack_lockfile)
1015                        unlink_or_warn(pack_lockfile);
1016                if (report_status)
1017                        report(commands, unpack_status);
1018                run_receive_hook(commands, "post-receive", 1);
1019                run_update_post_hook(commands);
1020                if (auto_gc) {
1021                        const char *argv_gc_auto[] = {
1022                                "gc", "--auto", "--quiet", NULL,
1023                        };
1024                        int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1025                        run_command_v_opt(argv_gc_auto, opt);
1026                }
1027                if (auto_update_server_info)
1028                        update_server_info(0);
1029        }
1030        if (use_sideband)
1031                packet_flush(1);
1032        return 0;
1033}