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