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