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