Andrew's git / gitweb.git / builtin/receive-pack.c
?
builtin / receive-pack.con commit memory_limit: use git_env_ulong() to parse GIT_ALLOC_LIMIT (9927d96)
   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(&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 (!starts_with(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 && starts_with(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            starts_with(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                if (cmd->error_string || cmd->did_not_exist)
 618                        continue;
 619                argv[argc] = xstrdup(cmd->ref_name);
 620                argc++;
 621        }
 622        argv[argc] = NULL;
 623
 624        memset(&proc, 0, sizeof(proc));
 625        proc.no_stdin = 1;
 626        proc.stdout_to_stderr = 1;
 627        proc.err = use_sideband ? -1 : 0;
 628        proc.argv = argv;
 629
 630        if (!start_command(&proc)) {
 631                if (use_sideband)
 632                        copy_to_sideband(proc.err, -1, NULL);
 633                finish_command(&proc);
 634        }
 635}
 636
 637static void check_aliased_update(struct command *cmd, struct string_list *list)
 638{
 639        struct strbuf buf = STRBUF_INIT;
 640        const char *dst_name;
 641        struct string_list_item *item;
 642        struct command *dst_cmd;
 643        unsigned char sha1[20];
 644        char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
 645        int flag;
 646
 647        strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
 648        dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
 649        strbuf_release(&buf);
 650
 651        if (!(flag & REF_ISSYMREF))
 652                return;
 653
 654        dst_name = strip_namespace(dst_name);
 655        if (!dst_name) {
 656                rp_error("refusing update to broken symref '%s'", cmd->ref_name);
 657                cmd->skip_update = 1;
 658                cmd->error_string = "broken symref";
 659                return;
 660        }
 661
 662        if ((item = string_list_lookup(list, dst_name)) == NULL)
 663                return;
 664
 665        cmd->skip_update = 1;
 666
 667        dst_cmd = (struct command *) item->util;
 668
 669        if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
 670            !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
 671                return;
 672
 673        dst_cmd->skip_update = 1;
 674
 675        strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
 676        strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
 677        strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
 678        strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
 679        rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
 680                 " its target '%s' (%s..%s)",
 681                 cmd->ref_name, cmd_oldh, cmd_newh,
 682                 dst_cmd->ref_name, dst_oldh, dst_newh);
 683
 684        cmd->error_string = dst_cmd->error_string =
 685                "inconsistent aliased update";
 686}
 687
 688static void check_aliased_updates(struct command *commands)
 689{
 690        struct command *cmd;
 691        struct string_list ref_list = STRING_LIST_INIT_NODUP;
 692
 693        for (cmd = commands; cmd; cmd = cmd->next) {
 694                struct string_list_item *item =
 695                        string_list_append(&ref_list, cmd->ref_name);
 696                item->util = (void *)cmd;
 697        }
 698        sort_string_list(&ref_list);
 699
 700        for (cmd = commands; cmd; cmd = cmd->next) {
 701                if (!cmd->error_string)
 702                        check_aliased_update(cmd, &ref_list);
 703        }
 704
 705        string_list_clear(&ref_list, 0);
 706}
 707
 708static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
 709{
 710        struct command **cmd_list = cb_data;
 711        struct command *cmd = *cmd_list;
 712
 713        if (!cmd || is_null_sha1(cmd->new_sha1))
 714                return -1; /* end of list */
 715        *cmd_list = NULL; /* this returns only one */
 716        hashcpy(sha1, cmd->new_sha1);
 717        return 0;
 718}
 719
 720static void set_connectivity_errors(struct command *commands,
 721                                    struct shallow_info *si)
 722{
 723        struct command *cmd;
 724
 725        for (cmd = commands; cmd; cmd = cmd->next) {
 726                struct command *singleton = cmd;
 727                if (shallow_update && si->shallow_ref[cmd->index])
 728                        /* to be checked in update_shallow_ref() */
 729                        continue;
 730                if (!check_everything_connected(command_singleton_iterator,
 731                                                0, &singleton))
 732                        continue;
 733                cmd->error_string = "missing necessary objects";
 734        }
 735}
 736
 737struct iterate_data {
 738        struct command *cmds;
 739        struct shallow_info *si;
 740};
 741
 742static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
 743{
 744        struct iterate_data *data = cb_data;
 745        struct command **cmd_list = &data->cmds;
 746        struct command *cmd = *cmd_list;
 747
 748        for (; cmd; cmd = cmd->next) {
 749                if (shallow_update && data->si->shallow_ref[cmd->index])
 750                        /* to be checked in update_shallow_ref() */
 751                        continue;
 752                if (!is_null_sha1(cmd->new_sha1) && !cmd->skip_update) {
 753                        hashcpy(sha1, cmd->new_sha1);
 754                        *cmd_list = cmd->next;
 755                        return 0;
 756                }
 757        }
 758        *cmd_list = NULL;
 759        return -1; /* end of list */
 760}
 761
 762static void reject_updates_to_hidden(struct command *commands)
 763{
 764        struct command *cmd;
 765
 766        for (cmd = commands; cmd; cmd = cmd->next) {
 767                if (cmd->error_string || !ref_is_hidden(cmd->ref_name))
 768                        continue;
 769                if (is_null_sha1(cmd->new_sha1))
 770                        cmd->error_string = "deny deleting a hidden ref";
 771                else
 772                        cmd->error_string = "deny updating a hidden ref";
 773        }
 774}
 775
 776static void execute_commands(struct command *commands,
 777                             const char *unpacker_error,
 778                             struct shallow_info *si)
 779{
 780        int checked_connectivity;
 781        struct command *cmd;
 782        unsigned char sha1[20];
 783        struct iterate_data data;
 784
 785        if (unpacker_error) {
 786                for (cmd = commands; cmd; cmd = cmd->next)
 787                        cmd->error_string = "unpacker error";
 788                return;
 789        }
 790
 791        data.cmds = commands;
 792        data.si = si;
 793        if (check_everything_connected(iterate_receive_command_list, 0, &data))
 794                set_connectivity_errors(commands, si);
 795
 796        reject_updates_to_hidden(commands);
 797
 798        if (run_receive_hook(commands, "pre-receive", 0)) {
 799                for (cmd = commands; cmd; cmd = cmd->next) {
 800                        if (!cmd->error_string)
 801                                cmd->error_string = "pre-receive hook declined";
 802                }
 803                return;
 804        }
 805
 806        check_aliased_updates(commands);
 807
 808        free(head_name_to_free);
 809        head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
 810
 811        checked_connectivity = 1;
 812        for (cmd = commands; cmd; cmd = cmd->next) {
 813                if (cmd->error_string)
 814                        continue;
 815
 816                if (cmd->skip_update)
 817                        continue;
 818
 819                cmd->error_string = update(cmd, si);
 820                if (shallow_update && !cmd->error_string &&
 821                    si->shallow_ref[cmd->index]) {
 822                        error("BUG: connectivity check has not been run on ref %s",
 823                              cmd->ref_name);
 824                        checked_connectivity = 0;
 825                }
 826        }
 827
 828        if (shallow_update && !checked_connectivity)
 829                error("BUG: run 'git fsck' for safety.\n"
 830                      "If there are errors, try to remove "
 831                      "the reported refs above");
 832}
 833
 834static struct command *read_head_info(struct sha1_array *shallow)
 835{
 836        struct command *commands = NULL;
 837        struct command **p = &commands;
 838        for (;;) {
 839                char *line;
 840                unsigned char old_sha1[20], new_sha1[20];
 841                struct command *cmd;
 842                char *refname;
 843                int len, reflen;
 844
 845                line = packet_read_line(0, &len);
 846                if (!line)
 847                        break;
 848
 849                if (len == 48 && starts_with(line, "shallow ")) {
 850                        if (get_sha1_hex(line + 8, old_sha1))
 851                                die("protocol error: expected shallow sha, got '%s'", line + 8);
 852                        sha1_array_append(shallow, old_sha1);
 853                        continue;
 854                }
 855
 856                if (len < 83 ||
 857                    line[40] != ' ' ||
 858                    line[81] != ' ' ||
 859                    get_sha1_hex(line, old_sha1) ||
 860                    get_sha1_hex(line + 41, new_sha1))
 861                        die("protocol error: expected old/new/ref, got '%s'",
 862                            line);
 863
 864                refname = line + 82;
 865                reflen = strlen(refname);
 866                if (reflen + 82 < len) {
 867                        const char *feature_list = refname + reflen + 1;
 868                        if (parse_feature_request(feature_list, "report-status"))
 869                                report_status = 1;
 870                        if (parse_feature_request(feature_list, "side-band-64k"))
 871                                use_sideband = LARGE_PACKET_MAX;
 872                        if (parse_feature_request(feature_list, "quiet"))
 873                                quiet = 1;
 874                }
 875                cmd = xcalloc(1, sizeof(struct command) + len - 80);
 876                hashcpy(cmd->old_sha1, old_sha1);
 877                hashcpy(cmd->new_sha1, new_sha1);
 878                memcpy(cmd->ref_name, line + 82, len - 81);
 879                *p = cmd;
 880                p = &cmd->next;
 881        }
 882        return commands;
 883}
 884
 885static const char *parse_pack_header(struct pack_header *hdr)
 886{
 887        switch (read_pack_header(0, hdr)) {
 888        case PH_ERROR_EOF:
 889                return "eof before pack header was fully read";
 890
 891        case PH_ERROR_PACK_SIGNATURE:
 892                return "protocol error (pack signature mismatch detected)";
 893
 894        case PH_ERROR_PROTOCOL:
 895                return "protocol error (pack version unsupported)";
 896
 897        default:
 898                return "unknown error in parse_pack_header";
 899
 900        case 0:
 901                return NULL;
 902        }
 903}
 904
 905static const char *pack_lockfile;
 906
 907static const char *unpack(int err_fd, struct shallow_info *si)
 908{
 909        struct pack_header hdr;
 910        struct argv_array av = ARGV_ARRAY_INIT;
 911        const char *hdr_err;
 912        int status;
 913        char hdr_arg[38];
 914        struct child_process child;
 915        int fsck_objects = (receive_fsck_objects >= 0
 916                            ? receive_fsck_objects
 917                            : transfer_fsck_objects >= 0
 918                            ? transfer_fsck_objects
 919                            : 0);
 920
 921        hdr_err = parse_pack_header(&hdr);
 922        if (hdr_err) {
 923                if (err_fd > 0)
 924                        close(err_fd);
 925                return hdr_err;
 926        }
 927        snprintf(hdr_arg, sizeof(hdr_arg),
 928                        "--pack_header=%"PRIu32",%"PRIu32,
 929                        ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
 930
 931        if (si->nr_ours || si->nr_theirs) {
 932                alt_shallow_file = setup_temporary_shallow(si->shallow);
 933                argv_array_pushl(&av, "--shallow-file", alt_shallow_file, NULL);
 934        }
 935
 936        memset(&child, 0, sizeof(child));
 937        if (ntohl(hdr.hdr_entries) < unpack_limit) {
 938                argv_array_pushl(&av, "unpack-objects", hdr_arg, NULL);
 939                if (quiet)
 940                        argv_array_push(&av, "-q");
 941                if (fsck_objects)
 942                        argv_array_push(&av, "--strict");
 943                child.argv = av.argv;
 944                child.no_stdout = 1;
 945                child.err = err_fd;
 946                child.git_cmd = 1;
 947                status = run_command(&child);
 948                if (status)
 949                        return "unpack-objects abnormal exit";
 950        } else {
 951                int s;
 952                char keep_arg[256];
 953
 954                s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
 955                if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 956                        strcpy(keep_arg + s, "localhost");
 957
 958                argv_array_pushl(&av, "index-pack",
 959                                 "--stdin", hdr_arg, keep_arg, NULL);
 960                if (fsck_objects)
 961                        argv_array_push(&av, "--strict");
 962                if (fix_thin)
 963                        argv_array_push(&av, "--fix-thin");
 964                child.argv = av.argv;
 965                child.out = -1;
 966                child.err = err_fd;
 967                child.git_cmd = 1;
 968                status = start_command(&child);
 969                if (status)
 970                        return "index-pack fork failed";
 971                pack_lockfile = index_pack_lockfile(child.out);
 972                close(child.out);
 973                status = finish_command(&child);
 974                if (status)
 975                        return "index-pack abnormal exit";
 976                reprepare_packed_git();
 977        }
 978        return NULL;
 979}
 980
 981static const char *unpack_with_sideband(struct shallow_info *si)
 982{
 983        struct async muxer;
 984        const char *ret;
 985
 986        if (!use_sideband)
 987                return unpack(0, si);
 988
 989        memset(&muxer, 0, sizeof(muxer));
 990        muxer.proc = copy_to_sideband;
 991        muxer.in = -1;
 992        if (start_async(&muxer))
 993                return NULL;
 994
 995        ret = unpack(muxer.in, si);
 996
 997        finish_async(&muxer);
 998        return ret;
 999}
1000
1001static void prepare_shallow_update(struct command *commands,
1002                                   struct shallow_info *si)
1003{
1004        int i, j, k, bitmap_size = (si->ref->nr + 31) / 32;
1005
1006        si->used_shallow = xmalloc(sizeof(*si->used_shallow) *
1007                                   si->shallow->nr);
1008        assign_shallow_commits_to_refs(si, si->used_shallow, NULL);
1009
1010        si->need_reachability_test =
1011                xcalloc(si->shallow->nr, sizeof(*si->need_reachability_test));
1012        si->reachable =
1013                xcalloc(si->shallow->nr, sizeof(*si->reachable));
1014        si->shallow_ref = xcalloc(si->ref->nr, sizeof(*si->shallow_ref));
1015
1016        for (i = 0; i < si->nr_ours; i++)
1017                si->need_reachability_test[si->ours[i]] = 1;
1018
1019        for (i = 0; i < si->shallow->nr; i++) {
1020                if (!si->used_shallow[i])
1021                        continue;
1022                for (j = 0; j < bitmap_size; j++) {
1023                        if (!si->used_shallow[i][j])
1024                                continue;
1025                        si->need_reachability_test[i]++;
1026                        for (k = 0; k < 32; k++)
1027                                if (si->used_shallow[i][j] & (1 << k))
1028                                        si->shallow_ref[j * 32 + k]++;
1029                }
1030
1031                /*
1032                 * true for those associated with some refs and belong
1033                 * in "ours" list aka "step 7 not done yet"
1034                 */
1035                si->need_reachability_test[i] =
1036                        si->need_reachability_test[i] > 1;
1037        }
1038
1039        /*
1040         * keep hooks happy by forcing a temporary shallow file via
1041         * env variable because we can't add --shallow-file to every
1042         * command. check_everything_connected() will be done with
1043         * true .git/shallow though.
1044         */
1045        setenv(GIT_SHALLOW_FILE_ENVIRONMENT, alt_shallow_file, 1);
1046}
1047
1048static void update_shallow_info(struct command *commands,
1049                                struct shallow_info *si,
1050                                struct sha1_array *ref)
1051{
1052        struct command *cmd;
1053        int *ref_status;
1054        remove_nonexistent_theirs_shallow(si);
1055        if (!si->nr_ours && !si->nr_theirs) {
1056                shallow_update = 0;
1057                return;
1058        }
1059
1060        for (cmd = commands; cmd; cmd = cmd->next) {
1061                if (is_null_sha1(cmd->new_sha1))
1062                        continue;
1063                sha1_array_append(ref, cmd->new_sha1);
1064                cmd->index = ref->nr - 1;
1065        }
1066        si->ref = ref;
1067
1068        if (shallow_update) {
1069                prepare_shallow_update(commands, si);
1070                return;
1071        }
1072
1073        ref_status = xmalloc(sizeof(*ref_status) * ref->nr);
1074        assign_shallow_commits_to_refs(si, NULL, ref_status);
1075        for (cmd = commands; cmd; cmd = cmd->next) {
1076                if (is_null_sha1(cmd->new_sha1))
1077                        continue;
1078                if (ref_status[cmd->index]) {
1079                        cmd->error_string = "shallow update not allowed";
1080                        cmd->skip_update = 1;
1081                }
1082        }
1083        free(ref_status);
1084}
1085
1086static void report(struct command *commands, const char *unpack_status)
1087{
1088        struct command *cmd;
1089        struct strbuf buf = STRBUF_INIT;
1090
1091        packet_buf_write(&buf, "unpack %s\n",
1092                         unpack_status ? unpack_status : "ok");
1093        for (cmd = commands; cmd; cmd = cmd->next) {
1094                if (!cmd->error_string)
1095                        packet_buf_write(&buf, "ok %s\n",
1096                                         cmd->ref_name);
1097                else
1098                        packet_buf_write(&buf, "ng %s %s\n",
1099                                         cmd->ref_name, cmd->error_string);
1100        }
1101        packet_buf_flush(&buf);
1102
1103        if (use_sideband)
1104                send_sideband(1, 1, buf.buf, buf.len, use_sideband);
1105        else
1106                write_or_die(1, buf.buf, buf.len);
1107        strbuf_release(&buf);
1108}
1109
1110static int delete_only(struct command *commands)
1111{
1112        struct command *cmd;
1113        for (cmd = commands; cmd; cmd = cmd->next) {
1114                if (!is_null_sha1(cmd->new_sha1))
1115                        return 0;
1116        }
1117        return 1;
1118}
1119
1120int cmd_receive_pack(int argc, const char **argv, const char *prefix)
1121{
1122        int advertise_refs = 0;
1123        int stateless_rpc = 0;
1124        int i;
1125        const char *dir = NULL;
1126        struct command *commands;
1127        struct sha1_array shallow = SHA1_ARRAY_INIT;
1128        struct sha1_array ref = SHA1_ARRAY_INIT;
1129        struct shallow_info si;
1130
1131        packet_trace_identity("receive-pack");
1132
1133        argv++;
1134        for (i = 1; i < argc; i++) {
1135                const char *arg = *argv++;
1136
1137                if (*arg == '-') {
1138                        if (!strcmp(arg, "--quiet")) {
1139                                quiet = 1;
1140                                continue;
1141                        }
1142
1143                        if (!strcmp(arg, "--advertise-refs")) {
1144                                advertise_refs = 1;
1145                                continue;
1146                        }
1147                        if (!strcmp(arg, "--stateless-rpc")) {
1148                                stateless_rpc = 1;
1149                                continue;
1150                        }
1151                        if (!strcmp(arg, "--reject-thin-pack-for-testing")) {
1152                                fix_thin = 0;
1153                                continue;
1154                        }
1155
1156                        usage(receive_pack_usage);
1157                }
1158                if (dir)
1159                        usage(receive_pack_usage);
1160                dir = arg;
1161        }
1162        if (!dir)
1163                usage(receive_pack_usage);
1164
1165        setup_path();
1166
1167        if (!enter_repo(dir, 0))
1168                die("'%s' does not appear to be a git repository", dir);
1169
1170        git_config(receive_pack_config, NULL);
1171
1172        if (0 <= transfer_unpack_limit)
1173                unpack_limit = transfer_unpack_limit;
1174        else if (0 <= receive_unpack_limit)
1175                unpack_limit = receive_unpack_limit;
1176
1177        if (advertise_refs || !stateless_rpc) {
1178                write_head_info();
1179        }
1180        if (advertise_refs)
1181                return 0;
1182
1183        if ((commands = read_head_info(&shallow)) != NULL) {
1184                const char *unpack_status = NULL;
1185
1186                prepare_shallow_info(&si, &shallow);
1187                if (!si.nr_ours && !si.nr_theirs)
1188                        shallow_update = 0;
1189                if (!delete_only(commands)) {
1190                        unpack_status = unpack_with_sideband(&si);
1191                        update_shallow_info(commands, &si, &ref);
1192                }
1193                execute_commands(commands, unpack_status, &si);
1194                if (pack_lockfile)
1195                        unlink_or_warn(pack_lockfile);
1196                if (report_status)
1197                        report(commands, unpack_status);
1198                run_receive_hook(commands, "post-receive", 1);
1199                run_update_post_hook(commands);
1200                if (auto_gc) {
1201                        const char *argv_gc_auto[] = {
1202                                "gc", "--auto", "--quiet", NULL,
1203                        };
1204                        int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1205                        run_command_v_opt(argv_gc_auto, opt);
1206                }
1207                if (auto_update_server_info)
1208                        update_server_info(0);
1209                clear_shallow_info(&si);
1210        }
1211        if (use_sideband)
1212                packet_flush(1);
1213        sha1_array_clear(&shallow);
1214        sha1_array_clear(&ref);
1215        return 0;
1216}