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