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