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