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