Andrew's git / gitweb.git / builtin/receive-pack.c
?
builtin / receive-pack.con commit Merge branch 'tg/index-struct-sizes' (b0d974d)
   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 const char *head_name;
  43static void *head_name_to_free;
  44static int sent_capabilities;
  45
  46static enum deny_action parse_deny_action(const char *var, const char *value)
  47{
  48        if (value) {
  49                if (!strcasecmp(value, "ignore"))
  50                        return DENY_IGNORE;
  51                if (!strcasecmp(value, "warn"))
  52                        return DENY_WARN;
  53                if (!strcasecmp(value, "refuse"))
  54                        return DENY_REFUSE;
  55        }
  56        if (git_config_bool(var, value))
  57                return DENY_REFUSE;
  58        return DENY_IGNORE;
  59}
  60
  61static int receive_pack_config(const char *var, const char *value, void *cb)
  62{
  63        int status = parse_hide_refs_config(var, value, "receive");
  64
  65        if (status)
  66                return status;
  67
  68        if (strcmp(var, "receive.denydeletes") == 0) {
  69                deny_deletes = git_config_bool(var, value);
  70                return 0;
  71        }
  72
  73        if (strcmp(var, "receive.denynonfastforwards") == 0) {
  74                deny_non_fast_forwards = git_config_bool(var, value);
  75                return 0;
  76        }
  77
  78        if (strcmp(var, "receive.unpacklimit") == 0) {
  79                receive_unpack_limit = git_config_int(var, value);
  80                return 0;
  81        }
  82
  83        if (strcmp(var, "transfer.unpacklimit") == 0) {
  84                transfer_unpack_limit = git_config_int(var, value);
  85                return 0;
  86        }
  87
  88        if (strcmp(var, "receive.fsckobjects") == 0) {
  89                receive_fsck_objects = git_config_bool(var, value);
  90                return 0;
  91        }
  92
  93        if (strcmp(var, "transfer.fsckobjects") == 0) {
  94                transfer_fsck_objects = git_config_bool(var, value);
  95                return 0;
  96        }
  97
  98        if (!strcmp(var, "receive.denycurrentbranch")) {
  99                deny_current_branch = parse_deny_action(var, value);
 100                return 0;
 101        }
 102
 103        if (strcmp(var, "receive.denydeletecurrent") == 0) {
 104                deny_delete_current = parse_deny_action(var, value);
 105                return 0;
 106        }
 107
 108        if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
 109                prefer_ofs_delta = git_config_bool(var, value);
 110                return 0;
 111        }
 112
 113        if (strcmp(var, "receive.updateserverinfo") == 0) {
 114                auto_update_server_info = git_config_bool(var, value);
 115                return 0;
 116        }
 117
 118        if (strcmp(var, "receive.autogc") == 0) {
 119                auto_gc = git_config_bool(var, value);
 120                return 0;
 121        }
 122
 123        return git_default_config(var, value, cb);
 124}
 125
 126static void show_ref(const char *path, const unsigned char *sha1)
 127{
 128        if (ref_is_hidden(path))
 129                return;
 130
 131        if (sent_capabilities)
 132                packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
 133        else
 134                packet_write(1, "%s %s%c%s%s agent=%s\n",
 135                             sha1_to_hex(sha1), path, 0,
 136                             " report-status delete-refs side-band-64k quiet",
 137                             prefer_ofs_delta ? " ofs-delta" : "",
 138                             git_user_agent_sanitized());
 139        sent_capabilities = 1;
 140}
 141
 142static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
 143{
 144        path = strip_namespace(path);
 145        /*
 146         * Advertise refs outside our current namespace as ".have"
 147         * refs, so that the client can use them to minimize data
 148         * transfer but will otherwise ignore them. This happens to
 149         * cover ".have" that are thrown in by add_one_alternate_ref()
 150         * to mark histories that are complete in our alternates as
 151         * well.
 152         */
 153        if (!path)
 154                path = ".have";
 155        show_ref(path, sha1);
 156        return 0;
 157}
 158
 159static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
 160{
 161        show_ref(".have", sha1);
 162}
 163
 164static void collect_one_alternate_ref(const struct ref *ref, void *data)
 165{
 166        struct sha1_array *sa = data;
 167        sha1_array_append(sa, ref->old_sha1);
 168}
 169
 170static void write_head_info(void)
 171{
 172        struct sha1_array sa = SHA1_ARRAY_INIT;
 173        for_each_alternate_ref(collect_one_alternate_ref, &sa);
 174        sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
 175        sha1_array_clear(&sa);
 176        for_each_ref(show_ref_cb, NULL);
 177        if (!sent_capabilities)
 178                show_ref("capabilities^{}", null_sha1);
 179
 180        /* EOF */
 181        packet_flush(1);
 182}
 183
 184struct command {
 185        struct command *next;
 186        const char *error_string;
 187        unsigned int skip_update:1,
 188                     did_not_exist:1;
 189        unsigned char old_sha1[20];
 190        unsigned char new_sha1[20];
 191        char ref_name[FLEX_ARRAY]; /* more */
 192};
 193
 194static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
 195static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
 196
 197static void report_message(const char *prefix, const char *err, va_list params)
 198{
 199        int sz = strlen(prefix);
 200        char msg[4096];
 201
 202        strncpy(msg, prefix, sz);
 203        sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
 204        if (sz > (sizeof(msg) - 1))
 205                sz = sizeof(msg) - 1;
 206        msg[sz++] = '\n';
 207
 208        if (use_sideband)
 209                send_sideband(1, 2, msg, sz, use_sideband);
 210        else
 211                xwrite(2, msg, sz);
 212}
 213
 214static void rp_warning(const char *err, ...)
 215{
 216        va_list params;
 217        va_start(params, err);
 218        report_message("warning: ", err, params);
 219        va_end(params);
 220}
 221
 222static void rp_error(const char *err, ...)
 223{
 224        va_list params;
 225        va_start(params, err);
 226        report_message("error: ", err, params);
 227        va_end(params);
 228}
 229
 230static int copy_to_sideband(int in, int out, void *arg)
 231{
 232        char data[128];
 233        while (1) {
 234                ssize_t sz = xread(in, data, sizeof(data));
 235                if (sz <= 0)
 236                        break;
 237                send_sideband(1, 2, data, sz, use_sideband);
 238        }
 239        close(in);
 240        return 0;
 241}
 242
 243typedef int (*feed_fn)(void *, const char **, size_t *);
 244static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
 245{
 246        struct child_process proc;
 247        struct async muxer;
 248        const char *argv[2];
 249        int code;
 250
 251        argv[0] = find_hook(hook_name);
 252        if (!argv[0])
 253                return 0;
 254
 255        argv[1] = NULL;
 256
 257        memset(&proc, 0, sizeof(proc));
 258        proc.argv = argv;
 259        proc.in = -1;
 260        proc.stdout_to_stderr = 1;
 261
 262        if (use_sideband) {
 263                memset(&muxer, 0, sizeof(muxer));
 264                muxer.proc = copy_to_sideband;
 265                muxer.in = -1;
 266                code = start_async(&muxer);
 267                if (code)
 268                        return code;
 269                proc.err = muxer.in;
 270        }
 271
 272        code = start_command(&proc);
 273        if (code) {
 274                if (use_sideband)
 275                        finish_async(&muxer);
 276                return code;
 277        }
 278
 279        while (1) {
 280                const char *buf;
 281                size_t n;
 282                if (feed(feed_state, &buf, &n))
 283                        break;
 284                if (write_in_full(proc.in, buf, n) != n)
 285                        break;
 286        }
 287        close(proc.in);
 288        if (use_sideband)
 289                finish_async(&muxer);
 290        return finish_command(&proc);
 291}
 292
 293struct receive_hook_feed_state {
 294        struct command *cmd;
 295        int skip_broken;
 296        struct strbuf buf;
 297};
 298
 299static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
 300{
 301        struct receive_hook_feed_state *state = state_;
 302        struct command *cmd = state->cmd;
 303
 304        while (cmd &&
 305               state->skip_broken && (cmd->error_string || cmd->did_not_exist))
 306                cmd = cmd->next;
 307        if (!cmd)
 308                return -1; /* EOF */
 309        strbuf_reset(&state->buf);
 310        strbuf_addf(&state->buf, "%s %s %s\n",
 311                    sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
 312                    cmd->ref_name);
 313        state->cmd = cmd->next;
 314        if (bufp) {
 315                *bufp = state->buf.buf;
 316                *sizep = state->buf.len;
 317        }
 318        return 0;
 319}
 320
 321static int run_receive_hook(struct command *commands, const char *hook_name,
 322                            int skip_broken)
 323{
 324        struct receive_hook_feed_state state;
 325        int status;
 326
 327        strbuf_init(&state.buf, 0);
 328        state.cmd = commands;
 329        state.skip_broken = skip_broken;
 330        if (feed_receive_hook(&state, NULL, NULL))
 331                return 0;
 332        state.cmd = commands;
 333        status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
 334        strbuf_release(&state.buf);
 335        return status;
 336}
 337
 338static int run_update_hook(struct command *cmd)
 339{
 340        const char *argv[5];
 341        struct child_process proc;
 342        int code;
 343
 344        argv[0] = find_hook("update");
 345        if (!argv[0])
 346                return 0;
 347
 348        argv[1] = cmd->ref_name;
 349        argv[2] = sha1_to_hex(cmd->old_sha1);
 350        argv[3] = sha1_to_hex(cmd->new_sha1);
 351        argv[4] = NULL;
 352
 353        memset(&proc, 0, sizeof(proc));
 354        proc.no_stdin = 1;
 355        proc.stdout_to_stderr = 1;
 356        proc.err = use_sideband ? -1 : 0;
 357        proc.argv = argv;
 358
 359        code = start_command(&proc);
 360        if (code)
 361                return code;
 362        if (use_sideband)
 363                copy_to_sideband(proc.err, -1, NULL);
 364        return finish_command(&proc);
 365}
 366
 367static int is_ref_checked_out(const char *ref)
 368{
 369        if (is_bare_repository())
 370                return 0;
 371
 372        if (!head_name)
 373                return 0;
 374        return !strcmp(head_name, ref);
 375}
 376
 377static char *refuse_unconfigured_deny_msg[] = {
 378        "By default, updating the current branch in a non-bare repository",
 379        "is denied, because it will make the index and work tree inconsistent",
 380        "with what you pushed, and will require 'git reset --hard' to match",
 381        "the work tree to HEAD.",
 382        "",
 383        "You can set 'receive.denyCurrentBranch' configuration variable to",
 384        "'ignore' or 'warn' in the remote repository to allow pushing into",
 385        "its current branch; however, this is not recommended unless you",
 386        "arranged to update its work tree to match what you pushed in some",
 387        "other way.",
 388        "",
 389        "To squelch this message and still keep the default behaviour, set",
 390        "'receive.denyCurrentBranch' configuration variable to 'refuse'."
 391};
 392
 393static void refuse_unconfigured_deny(void)
 394{
 395        int i;
 396        for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
 397                rp_error("%s", refuse_unconfigured_deny_msg[i]);
 398}
 399
 400static char *refuse_unconfigured_deny_delete_current_msg[] = {
 401        "By default, deleting the current branch is denied, because the next",
 402        "'git clone' won't result in any file checked out, causing confusion.",
 403        "",
 404        "You can set 'receive.denyDeleteCurrent' configuration variable to",
 405        "'warn' or 'ignore' in the remote repository to allow deleting the",
 406        "current branch, with or without a warning message.",
 407        "",
 408        "To squelch this message, you can set it to 'refuse'."
 409};
 410
 411static void refuse_unconfigured_deny_delete_current(void)
 412{
 413        int i;
 414        for (i = 0;
 415             i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
 416             i++)
 417                rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
 418}
 419
 420static const char *update(struct command *cmd)
 421{
 422        const char *name = cmd->ref_name;
 423        struct strbuf namespaced_name_buf = STRBUF_INIT;
 424        const char *namespaced_name;
 425        unsigned char *old_sha1 = cmd->old_sha1;
 426        unsigned char *new_sha1 = cmd->new_sha1;
 427        struct ref_lock *lock;
 428
 429        /* only refs/... are allowed */
 430        if (prefixcmp(name, "refs/") || check_refname_format(name + 5, 0)) {
 431                rp_error("refusing to create funny ref '%s' remotely", name);
 432                return "funny refname";
 433        }
 434
 435        strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
 436        namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
 437
 438        if (is_ref_checked_out(namespaced_name)) {
 439                switch (deny_current_branch) {
 440                case DENY_IGNORE:
 441                        break;
 442                case DENY_WARN:
 443                        rp_warning("updating the current branch");
 444                        break;
 445                case DENY_REFUSE:
 446                case DENY_UNCONFIGURED:
 447                        rp_error("refusing to update checked out branch: %s", name);
 448                        if (deny_current_branch == DENY_UNCONFIGURED)
 449                                refuse_unconfigured_deny();
 450                        return "branch is currently checked out";
 451                }
 452        }
 453
 454        if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
 455                error("unpack should have generated %s, "
 456                      "but I can't find it!", sha1_to_hex(new_sha1));
 457                return "bad pack";
 458        }
 459
 460        if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
 461                if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
 462                        rp_error("denying ref deletion for %s", name);
 463                        return "deletion prohibited";
 464                }
 465
 466                if (!strcmp(namespaced_name, head_name)) {
 467                        switch (deny_delete_current) {
 468                        case DENY_IGNORE:
 469                                break;
 470                        case DENY_WARN:
 471                                rp_warning("deleting the current branch");
 472                                break;
 473                        case DENY_REFUSE:
 474                        case DENY_UNCONFIGURED:
 475                                if (deny_delete_current == DENY_UNCONFIGURED)
 476                                        refuse_unconfigured_deny_delete_current();
 477                                rp_error("refusing to delete the current branch: %s", name);
 478                                return "deletion of the current branch prohibited";
 479                        }
 480                }
 481        }
 482
 483        if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
 484            !is_null_sha1(old_sha1) &&
 485            !prefixcmp(name, "refs/heads/")) {
 486                struct object *old_object, *new_object;
 487                struct commit *old_commit, *new_commit;
 488
 489                old_object = parse_object(old_sha1);
 490                new_object = parse_object(new_sha1);
 491
 492                if (!old_object || !new_object ||
 493                    old_object->type != OBJ_COMMIT ||
 494                    new_object->type != OBJ_COMMIT) {
 495                        error("bad sha1 objects for %s", name);
 496                        return "bad ref";
 497                }
 498                old_commit = (struct commit *)old_object;
 499                new_commit = (struct commit *)new_object;
 500                if (!in_merge_bases(old_commit, new_commit)) {
 501                        rp_error("denying non-fast-forward %s"
 502                                 " (you should pull first)", name);
 503                        return "non-fast-forward";
 504                }
 505        }
 506        if (run_update_hook(cmd)) {
 507                rp_error("hook declined to update %s", name);
 508                return "hook declined";
 509        }
 510
 511        if (is_null_sha1(new_sha1)) {
 512                if (!parse_object(old_sha1)) {
 513                        old_sha1 = NULL;
 514                        if (ref_exists(name)) {
 515                                rp_warning("Allowing deletion of corrupt ref.");
 516                        } else {
 517                                rp_warning("Deleting a non-existent ref.");
 518                                cmd->did_not_exist = 1;
 519                        }
 520                }
 521                if (delete_ref(namespaced_name, old_sha1, 0)) {
 522                        rp_error("failed to delete %s", name);
 523                        return "failed to delete";
 524                }
 525                return NULL; /* good */
 526        }
 527        else {
 528                lock = lock_any_ref_for_update(namespaced_name, old_sha1, 0);
 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}