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