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