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