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