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