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