Andrew's git / gitweb.git / builtin/receive-pack.c
?
builtin / receive-pack.con commit Merge branch 'maint' of https://github.com/ralfth/git-po-de into maint (173c173)
   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 = "n/a (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(void)
 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                const char *unpacker[5];
 825                unpacker[i++] = "unpack-objects";
 826                if (quiet)
 827                        unpacker[i++] = "-q";
 828                if (fsck_objects)
 829                        unpacker[i++] = "--strict";
 830                unpacker[i++] = hdr_arg;
 831                unpacker[i++] = NULL;
 832                code = run_command_v_opt(unpacker, RUN_GIT_CMD);
 833                if (!code)
 834                        return NULL;
 835                return "unpack-objects abnormal exit";
 836        } else {
 837                const char *keeper[7];
 838                int s, status, i = 0;
 839                char keep_arg[256];
 840                struct child_process ip;
 841
 842                s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
 843                if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 844                        strcpy(keep_arg + s, "localhost");
 845
 846                keeper[i++] = "index-pack";
 847                keeper[i++] = "--stdin";
 848                if (fsck_objects)
 849                        keeper[i++] = "--strict";
 850                keeper[i++] = "--fix-thin";
 851                keeper[i++] = hdr_arg;
 852                keeper[i++] = keep_arg;
 853                keeper[i++] = NULL;
 854                memset(&ip, 0, sizeof(ip));
 855                ip.argv = keeper;
 856                ip.out = -1;
 857                ip.git_cmd = 1;
 858                status = start_command(&ip);
 859                if (status) {
 860                        return "index-pack fork failed";
 861                }
 862                pack_lockfile = index_pack_lockfile(ip.out);
 863                close(ip.out);
 864                status = finish_command(&ip);
 865                if (!status) {
 866                        reprepare_packed_git();
 867                        return NULL;
 868                }
 869                return "index-pack abnormal exit";
 870        }
 871}
 872
 873static void report(struct command *commands, const char *unpack_status)
 874{
 875        struct command *cmd;
 876        struct strbuf buf = STRBUF_INIT;
 877
 878        packet_buf_write(&buf, "unpack %s\n",
 879                         unpack_status ? unpack_status : "ok");
 880        for (cmd = commands; cmd; cmd = cmd->next) {
 881                if (!cmd->error_string)
 882                        packet_buf_write(&buf, "ok %s\n",
 883                                         cmd->ref_name);
 884                else
 885                        packet_buf_write(&buf, "ng %s %s\n",
 886                                         cmd->ref_name, cmd->error_string);
 887        }
 888        packet_buf_flush(&buf);
 889
 890        if (use_sideband)
 891                send_sideband(1, 1, buf.buf, buf.len, use_sideband);
 892        else
 893                safe_write(1, buf.buf, buf.len);
 894        strbuf_release(&buf);
 895}
 896
 897static int delete_only(struct command *commands)
 898{
 899        struct command *cmd;
 900        for (cmd = commands; cmd; cmd = cmd->next) {
 901                if (!is_null_sha1(cmd->new_sha1))
 902                        return 0;
 903        }
 904        return 1;
 905}
 906
 907int cmd_receive_pack(int argc, const char **argv, const char *prefix)
 908{
 909        int advertise_refs = 0;
 910        int stateless_rpc = 0;
 911        int i;
 912        char *dir = NULL;
 913        struct command *commands;
 914
 915        packet_trace_identity("receive-pack");
 916
 917        argv++;
 918        for (i = 1; i < argc; i++) {
 919                const char *arg = *argv++;
 920
 921                if (*arg == '-') {
 922                        if (!strcmp(arg, "--quiet")) {
 923                                quiet = 1;
 924                                continue;
 925                        }
 926
 927                        if (!strcmp(arg, "--advertise-refs")) {
 928                                advertise_refs = 1;
 929                                continue;
 930                        }
 931                        if (!strcmp(arg, "--stateless-rpc")) {
 932                                stateless_rpc = 1;
 933                                continue;
 934                        }
 935
 936                        usage(receive_pack_usage);
 937                }
 938                if (dir)
 939                        usage(receive_pack_usage);
 940                dir = xstrdup(arg);
 941        }
 942        if (!dir)
 943                usage(receive_pack_usage);
 944
 945        setup_path();
 946
 947        if (!enter_repo(dir, 0))
 948                die("'%s' does not appear to be a git repository", dir);
 949
 950        if (is_repository_shallow())
 951                die("attempt to push into a shallow repository");
 952
 953        git_config(receive_pack_config, NULL);
 954
 955        if (0 <= transfer_unpack_limit)
 956                unpack_limit = transfer_unpack_limit;
 957        else if (0 <= receive_unpack_limit)
 958                unpack_limit = receive_unpack_limit;
 959
 960        if (advertise_refs || !stateless_rpc) {
 961                write_head_info();
 962        }
 963        if (advertise_refs)
 964                return 0;
 965
 966        if ((commands = read_head_info()) != NULL) {
 967                const char *unpack_status = NULL;
 968
 969                if (!delete_only(commands))
 970                        unpack_status = unpack();
 971                execute_commands(commands, unpack_status);
 972                if (pack_lockfile)
 973                        unlink_or_warn(pack_lockfile);
 974                if (report_status)
 975                        report(commands, unpack_status);
 976                run_receive_hook(commands, post_receive_hook, 1);
 977                run_update_post_hook(commands);
 978                if (auto_gc) {
 979                        const char *argv_gc_auto[] = {
 980                                "gc", "--auto", "--quiet", NULL,
 981                        };
 982                        int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
 983                        run_command_v_opt(argv_gc_auto, opt);
 984                }
 985                if (auto_update_server_info)
 986                        update_server_info(0);
 987        }
 988        if (use_sideband)
 989                packet_flush(1);
 990        return 0;
 991}