Andrew's git - gitweb.git/blob - builtin/receive-pack.c

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