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