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