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