builtin/receive-pack.c

   1 #include "builtin.h"
   2 #include "lockfile.h"
   3 #include "pack.h"
   4 #include "refs.h"
   5 #include "pkt-line.h"
   6 #include "sideband.h"
   7 #include "run-command.h"
   8 #include "exec_cmd.h"
   9 #include "commit.h"
  10 #include "object.h"
  11 #include "remote.h"
  12 #include "connect.h"
  13 #include "transport.h"
  14 #include "string-list.h"
  15 #include "sha1-array.h"
  16 #include "connected.h"
  17 #include "argv-array.h"
  18 #include "version.h"
  19 #include "sigchain.h"
  20
  21 static const char receive_pack_usage[] = "git receive-pack <git-dir>";
  22
  23 enum deny_action {
  24         DENY_UNCONFIGURED,
  25         DENY_IGNORE,
  26         DENY_WARN,
  27         DENY_REFUSE
  28 };
  29
  30 static int deny_deletes;
  31 static int deny_non_fast_forwards;
  32 static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
  33 static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
  34 static int receive_fsck_objects = -1;
  35 static int transfer_fsck_objects = -1;
  36 static int receive_unpack_limit = -1;
  37 static int transfer_unpack_limit = -1;
  38 static int unpack_limit = 100;
  39 static int report_status;
  40 static int use_sideband;
  41 static int quiet;
  42 static int prefer_ofs_delta = 1;
  43 static int auto_update_server_info;
  44 static int auto_gc = 1;
  45 static int fix_thin = 1;
  46 static const char *head_name;
  47 static void *head_name_to_free;
  48 static int sent_capabilities;
  49 static int shallow_update;
  50 static const char *alt_shallow_file;
  51
  52 static enum deny_action parse_deny_action(const char *var, const char *value)
  53 {
  54         if (value) {
  55                 if (!strcasecmp(value, "ignore"))
  56                         return DENY_IGNORE;
  57                 if (!strcasecmp(value, "warn"))
  58                         return DENY_WARN;
  59                 if (!strcasecmp(value, "refuse"))
  60                         return DENY_REFUSE;
  61         }
  62         if (git_config_bool(var, value))
  63                 return DENY_REFUSE;
  64         return DENY_IGNORE;
  65 }
  66
  67 static int receive_pack_config(const char *var, const char *value, void *cb)
  68 {
  69         int status = parse_hide_refs_config(var, value, "receive");
  70
  71         if (status)
  72                 return status;
  73
  74         if (strcmp(var, "receive.denydeletes") == 0) {
  75                 deny_deletes = git_config_bool(var, value);
  76                 return 0;
  77         }
  78
  79         if (strcmp(var, "receive.denynonfastforwards") == 0) {
  80                 deny_non_fast_forwards = git_config_bool(var, value);
  81                 return 0;
  82         }
  83
  84         if (strcmp(var, "receive.unpacklimit") == 0) {
  85                 receive_unpack_limit = git_config_int(var, value);
  86                 return 0;
  87         }
  88
  89         if (strcmp(var, "transfer.unpacklimit") == 0) {
  90                 transfer_unpack_limit = git_config_int(var, value);
  91                 return 0;
  92         }
  93
  94         if (strcmp(var, "receive.fsckobjects") == 0) {
  95                 receive_fsck_objects = git_config_bool(var, value);
  96                 return 0;
  97         }
  98
  99         if (strcmp(var, "transfer.fsckobjects") == 0) {
 100                 transfer_fsck_objects = git_config_bool(var, value);
 101                 return 0;
 102         }
 103
 104         if (!strcmp(var, "receive.denycurrentbranch")) {
 105                 deny_current_branch = parse_deny_action(var, value);
 106                 return 0;
 107         }
 108
 109         if (strcmp(var, "receive.denydeletecurrent") == 0) {
 110                 deny_delete_current = parse_deny_action(var, value);
 111                 return 0;
 112         }
 113
 114         if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
 115                 prefer_ofs_delta = git_config_bool(var, value);
 116                 return 0;
 117         }
 118
 119         if (strcmp(var, "receive.updateserverinfo") == 0) {
 120                 auto_update_server_info = git_config_bool(var, value);
 121                 return 0;
 122         }
 123
 124         if (strcmp(var, "receive.autogc") == 0) {
 125                 auto_gc = git_config_bool(var, value);
 126                 return 0;
 127         }
 128
 129         if (strcmp(var, "receive.shallowupdate") == 0) {
 130                 shallow_update = git_config_bool(var, value);
 131                 return 0;
 132         }
 133
 134         return git_default_config(var, value, cb);
 135 }
 136
 137 static void show_ref(const char *path, const unsigned char *sha1)
 138 {
 139         if (ref_is_hidden(path))
 140                 return;
 141
 142         if (sent_capabilities)
 143                 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
 144         else
 145                 packet_write(1, "%s %s%c%s%s agent=%s\n",
 146                              sha1_to_hex(sha1), path, 0,
 147                              " report-status delete-refs side-band-64k quiet",
 148                              prefer_ofs_delta ? " ofs-delta" : "",
 149                              git_user_agent_sanitized());
 150         sent_capabilities = 1;
 151 }
 152
 153 static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
 154 {
 155         path = strip_namespace(path);
 156         /*
 157          * Advertise refs outside our current namespace as ".have"
 158          * refs, so that the client can use them to minimize data
 159          * transfer but will otherwise ignore them. This happens to
 160          * cover ".have" that are thrown in by add_one_alternate_ref()
 161          * to mark histories that are complete in our alternates as
 162          * well.
 163          */
 164         if (!path)
 165                 path = ".have";
 166         show_ref(path, sha1);
 167         return 0;
 168 }
 169
 170 static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
 171 {
 172         show_ref(".have", sha1);
 173 }
 174
 175 static void collect_one_alternate_ref(const struct ref *ref, void *data)
 176 {
 177         struct sha1_array *sa = data;
 178         sha1_array_append(sa, ref->old_sha1);
 179 }
 180
 181 static void write_head_info(void)
 182 {
 183         struct sha1_array sa = SHA1_ARRAY_INIT;
 184         for_each_alternate_ref(collect_one_alternate_ref, &sa);
 185         sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
 186         sha1_array_clear(&sa);
 187         for_each_ref(show_ref_cb, NULL);
 188         if (!sent_capabilities)
 189                 show_ref("capabilities^{}", null_sha1);
 190
 191         advertise_shallow_grafts(1);
 192
 193         /* EOF */
 194         packet_flush(1);
 195 }
 196
 197 struct command {
 198         struct command *next;
 199         const char *error_string;
 200         unsigned int skip_update:1,
 201                      did_not_exist:1;
 202         int index;
 203         unsigned char old_sha1[20];
 204         unsigned char new_sha1[20];
 205         char ref_name[FLEX_ARRAY]; /* more */
 206 };
 207
 208 static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
 209 static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
 210
 211 static void report_message(const char *prefix, const char *err, va_list params)
 212 {
 213         int sz = strlen(prefix);
 214         char msg[4096];
 215
 216         strncpy(msg, prefix, sz);
 217         sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
 218         if (sz > (sizeof(msg) - 1))
 219                 sz = sizeof(msg) - 1;
 220         msg[sz++] = '\n';
 221
 222         if (use_sideband)
 223                 send_sideband(1, 2, msg, sz, use_sideband);
 224         else
 225                 xwrite(2, msg, sz);
 226 }
 227
 228 static void rp_warning(const char *err, ...)
 229 {
 230         va_list params;
 231         va_start(params, err);
 232         report_message("warning: ", err, params);
 233         va_end(params);
 234 }
 235
 236 static void rp_error(const char *err, ...)
 237 {
 238         va_list params;
 239         va_start(params, err);
 240         report_message("error: ", err, params);
 241         va_end(params);
 242 }
 243
 244 static int copy_to_sideband(int in, int out, void *arg)
 245 {
 246         char data[128];
 247         while (1) {
 248                 ssize_t sz = xread(in, data, sizeof(data));
 249                 if (sz <= 0)
 250                         break;
 251                 send_sideband(1, 2, data, sz, use_sideband);
 252         }
 253         close(in);
 254         return 0;
 255 }
 256
 257 typedef int (*feed_fn)(void *, const char **, size_t *);
 258 static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
 259 {
 260         struct child_process proc = CHILD_PROCESS_INIT;
 261         struct async muxer;
 262         const char *argv[2];
 263         int code;
 264
 265         argv[0] = find_hook(hook_name);
 266         if (!argv[0])
 267                 return 0;
 268
 269         argv[1] = NULL;
 270
 271         proc.argv = argv;
 272         proc.in = -1;
 273         proc.stdout_to_stderr = 1;
 274
 275         if (use_sideband) {
 276                 memset(&muxer, 0, sizeof(muxer));
 277                 muxer.proc = copy_to_sideband;
 278                 muxer.in = -1;
 279                 code = start_async(&muxer);
 280                 if (code)
 281                         return code;
 282                 proc.err = muxer.in;
 283         }
 284
 285         code = start_command(&proc);
 286         if (code) {
 287                 if (use_sideband)
 288                         finish_async(&muxer);
 289                 return code;
 290         }
 291
 292         sigchain_push(SIGPIPE, SIG_IGN);
 293
 294         while (1) {
 295                 const char *buf;
 296                 size_t n;
 297                 if (feed(feed_state, &buf, &n))
 298                         break;
 299                 if (write_in_full(proc.in, buf, n) != n)
 300                         break;
 301         }
 302         close(proc.in);
 303         if (use_sideband)
 304                 finish_async(&muxer);
 305
 306         sigchain_pop(SIGPIPE);
 307
 308         return finish_command(&proc);
 309 }
 310
 311 struct receive_hook_feed_state {
 312         struct command *cmd;
 313         int skip_broken;
 314         struct strbuf buf;
 315 };
 316
 317 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
 318 {
 319         struct receive_hook_feed_state *state = state_;
 320         struct command *cmd = state->cmd;
 321
 322         while (cmd &&
 323                state->skip_broken && (cmd->error_string || cmd->did_not_exist))
 324                 cmd = cmd->next;
 325         if (!cmd)
 326                 return -1; /* EOF */
 327         strbuf_reset(&state->buf);
 328         strbuf_addf(&state->buf, "%s %s %s\n",
 329                     sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
 330                     cmd->ref_name);
 331         state->cmd = cmd->next;
 332         if (bufp) {
 333                 *bufp = state->buf.buf;
 334                 *sizep = state->buf.len;
 335         }
 336         return 0;
 337 }
 338
 339 static int run_receive_hook(struct command *commands, const char *hook_name,
 340                             int skip_broken)
 341 {
 342         struct receive_hook_feed_state state;
 343         int status;
 344
 345         strbuf_init(&state.buf, 0);
 346         state.cmd = commands;
 347         state.skip_broken = skip_broken;
 348         if (feed_receive_hook(&state, NULL, NULL))
 349                 return 0;
 350         state.cmd = commands;
 351         status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
 352         strbuf_release(&state.buf);
 353         return status;
 354 }
 355
 356 static int run_update_hook(struct command *cmd)
 357 {
 358         const char *argv[5];
 359         struct child_process proc = CHILD_PROCESS_INIT;
 360         int code;
 361
 362         argv[0] = find_hook("update");
 363         if (!argv[0])
 364                 return 0;
 365
 366         argv[1] = cmd->ref_name;
 367         argv[2] = sha1_to_hex(cmd->old_sha1);
 368         argv[3] = sha1_to_hex(cmd->new_sha1);
 369         argv[4] = NULL;
 370
 371         proc.no_stdin = 1;
 372         proc.stdout_to_stderr = 1;
 373         proc.err = use_sideband ? -1 : 0;
 374         proc.argv = argv;
 375
 376         code = start_command(&proc);
 377         if (code)
 378                 return code;
 379         if (use_sideband)
 380                 copy_to_sideband(proc.err, -1, NULL);
 381         return finish_command(&proc);
 382 }
 383
 384 static int is_ref_checked_out(const char *ref)
 385 {
 386         if (is_bare_repository())
 387                 return 0;
 388
 389         if (!head_name)
 390                 return 0;
 391         return !strcmp(head_name, ref);
 392 }
 393
 394 static char *refuse_unconfigured_deny_msg[] = {
 395         "By default, updating the current branch in a non-bare repository",
 396         "is denied, because it will make the index and work tree inconsistent",
 397         "with what you pushed, and will require 'git reset --hard' to match",
 398         "the work tree to HEAD.",
 399         "",
 400         "You can set 'receive.denyCurrentBranch' configuration variable to",
 401         "'ignore' or 'warn' in the remote repository to allow pushing into",
 402         "its current branch; however, this is not recommended unless you",
 403         "arranged to update its work tree to match what you pushed in some",
 404         "other way.",
 405         "",
 406         "To squelch this message and still keep the default behaviour, set",
 407         "'receive.denyCurrentBranch' configuration variable to 'refuse'."
 408 };
 409
 410 static void refuse_unconfigured_deny(void)
 411 {
 412         int i;
 413         for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
 414                 rp_error("%s", refuse_unconfigured_deny_msg[i]);
 415 }
 416
 417 static char *refuse_unconfigured_deny_delete_current_msg[] = {
 418         "By default, deleting the current branch is denied, because the next",
 419         "'git clone' won't result in any file checked out, causing confusion.",
 420         "",
 421         "You can set 'receive.denyDeleteCurrent' configuration variable to",
 422         "'warn' or 'ignore' in the remote repository to allow deleting the",
 423         "current branch, with or without a warning message.",
 424         "",
 425         "To squelch this message, you can set it to 'refuse'."
 426 };
 427
 428 static void refuse_unconfigured_deny_delete_current(void)
 429 {
 430         int i;
 431         for (i = 0;
 432              i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
 433              i++)
 434                 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
 435 }
 436
 437 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20]);
 438 static int update_shallow_ref(struct command *cmd, struct shallow_info *si)
 439 {
 440         static struct lock_file shallow_lock;
 441         struct sha1_array extra = SHA1_ARRAY_INIT;
 442         const char *alt_file;
 443         uint32_t mask = 1 << (cmd->index % 32);
 444         int i;
 445
 446         trace_printf_key(&trace_shallow,
 447                          "shallow: update_shallow_ref %s\n", cmd->ref_name);
 448         for (i = 0; i < si->shallow->nr; i++)
 449                 if (si->used_shallow[i] &&
 450                     (si->used_shallow[i][cmd->index / 32] & mask) &&
 451                     !delayed_reachability_test(si, i))
 452                         sha1_array_append(&extra, si->shallow->sha1[i]);
 453
 454         setup_alternate_shallow(&shallow_lock, &alt_file, &extra);
 455         if (check_shallow_connected(command_singleton_iterator,
 456                                     0, cmd, alt_file)) {
 457                 rollback_lock_file(&shallow_lock);
 458                 sha1_array_clear(&extra);
 459                 return -1;
 460         }
 461
 462         commit_lock_file(&shallow_lock);
 463
 464         /*
 465          * Make sure setup_alternate_shallow() for the next ref does
 466          * not lose these new roots..
 467          */
 468         for (i = 0; i < extra.nr; i++)
 469                 register_shallow(extra.sha1[i]);
 470
 471         si->shallow_ref[cmd->index] = 0;
 472         sha1_array_clear(&extra);
 473         return 0;
 474 }
 475
 476 static const char *update(struct command *cmd, struct shallow_info *si)
 477 {
 478         const char *name = cmd->ref_name;
 479         struct strbuf namespaced_name_buf = STRBUF_INIT;
 480         const char *namespaced_name;
 481         unsigned char *old_sha1 = cmd->old_sha1;
 482         unsigned char *new_sha1 = cmd->new_sha1;
 483
 484         /* only refs/... are allowed */
 485         if (!starts_with(name, "refs/") || check_refname_format(name + 5, 0)) {
 486                 rp_error("refusing to create funny ref '%s' remotely", name);
 487                 return "funny refname";
 488         }
 489
 490         strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
 491         namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
 492
 493         if (is_ref_checked_out(namespaced_name)) {
 494                 switch (deny_current_branch) {
 495                 case DENY_IGNORE:
 496                         break;
 497                 case DENY_WARN:
 498                         rp_warning("updating the current branch");
 499                         break;
 500                 case DENY_REFUSE:
 501                 case DENY_UNCONFIGURED:
 502                         rp_error("refusing to update checked out branch: %s", name);
 503                         if (deny_current_branch == DENY_UNCONFIGURED)
 504                                 refuse_unconfigured_deny();
 505                         return "branch is currently checked out";
 506                 }
 507         }
 508
 509         if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
 510                 error("unpack should have generated %s, "
 511                       "but I can't find it!", sha1_to_hex(new_sha1));
 512                 return "bad pack";
 513         }
 514
 515         if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
 516                 if (deny_deletes && starts_with(name, "refs/heads/")) {
 517                         rp_error("denying ref deletion for %s", name);
 518                         return "deletion prohibited";
 519                 }
 520
 521                 if (!strcmp(namespaced_name, head_name)) {
 522                         switch (deny_delete_current) {
 523                         case DENY_IGNORE:
 524                                 break;
 525                         case DENY_WARN:
 526                                 rp_warning("deleting the current branch");
 527                                 break;
 528                         case DENY_REFUSE:
 529                         case DENY_UNCONFIGURED:
 530                                 if (deny_delete_current == DENY_UNCONFIGURED)
 531                                         refuse_unconfigured_deny_delete_current();
 532                                 rp_error("refusing to delete the current branch: %s", name);
 533                                 return "deletion of the current branch prohibited";
 534                         }
 535                 }
 536         }
 537
 538         if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
 539             !is_null_sha1(old_sha1) &&
 540             starts_with(name, "refs/heads/")) {
 541                 struct object *old_object, *new_object;
 542                 struct commit *old_commit, *new_commit;
 543
 544                 old_object = parse_object(old_sha1);
 545                 new_object = parse_object(new_sha1);
 546
 547                 if (!old_object || !new_object ||
 548                     old_object->type != OBJ_COMMIT ||
 549                     new_object->type != OBJ_COMMIT) {
 550                         error("bad sha1 objects for %s", name);
 551                         return "bad ref";
 552                 }
 553                 old_commit = (struct commit *)old_object;
 554                 new_commit = (struct commit *)new_object;
 555                 if (!in_merge_bases(old_commit, new_commit)) {
 556                         rp_error("denying non-fast-forward %s"
 557                                  " (you should pull first)", name);
 558                         return "non-fast-forward";
 559                 }
 560         }
 561         if (run_update_hook(cmd)) {
 562                 rp_error("hook declined to update %s", name);
 563                 return "hook declined";
 564         }
 565
 566         if (is_null_sha1(new_sha1)) {
 567                 if (!parse_object(old_sha1)) {
 568                         old_sha1 = NULL;
 569                         if (ref_exists(name)) {
 570                                 rp_warning("Allowing deletion of corrupt ref.");
 571                         } else {
 572                                 rp_warning("Deleting a non-existent ref.");
 573                                 cmd->did_not_exist = 1;
 574                         }
 575                 }
 576                 if (delete_ref(namespaced_name, old_sha1, 0)) {
 577                         rp_error("failed to delete %s", name);
 578                         return "failed to delete";
 579                 }
 580                 return NULL; /* good */
 581         }
 582         else {
 583                 struct strbuf err = STRBUF_INIT;
 584                 struct ref_transaction *transaction;
 585
 586                 if (shallow_update && si->shallow_ref[cmd->index] &&
 587                     update_shallow_ref(cmd, si))
 588                         return "shallow error";
 589
 590                 transaction = ref_transaction_begin(&err);
 591                 if (!transaction ||
 592                     ref_transaction_update(transaction, namespaced_name,
 593                                            new_sha1, old_sha1, 0, 1, &err) ||
 594                     ref_transaction_commit(transaction, "push", &err)) {
 595                         ref_transaction_free(transaction);
 596
 597                         rp_error("%s", err.buf);
 598                         strbuf_release(&err);
 599                         return "failed to update ref";
 600                 }
 601
 602                 ref_transaction_free(transaction);
 603                 strbuf_release(&err);
 604                 return NULL; /* good */
 605         }
 606 }
 607
 608 static void run_update_post_hook(struct command *commands)
 609 {
 610         struct command *cmd;
 611         int argc;
 612         const char **argv;
 613         struct child_process proc = CHILD_PROCESS_INIT;
 614         char *hook;
 615
 616         hook = find_hook("post-update");
 617         for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
 618                 if (cmd->error_string || cmd->did_not_exist)
 619                         continue;
 620                 argc++;
 621         }
 622         if (!argc || !hook)
 623                 return;
 624
 625         argv = xmalloc(sizeof(*argv) * (2 + argc));
 626         argv[0] = hook;
 627
 628         for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
 629                 if (cmd->error_string || cmd->did_not_exist)
 630                         continue;
 631                 argv[argc] = xstrdup(cmd->ref_name);
 632                 argc++;
 633         }
 634         argv[argc] = NULL;
 635
 636         proc.no_stdin = 1;
 637         proc.stdout_to_stderr = 1;
 638         proc.err = use_sideband ? -1 : 0;
 639         proc.argv = argv;
 640
 641         if (!start_command(&proc)) {
 642                 if (use_sideband)
 643                         copy_to_sideband(proc.err, -1, NULL);
 644                 finish_command(&proc);
 645         }
 646 }
 647
 648 static void check_aliased_update(struct command *cmd, struct string_list *list)
 649 {
 650         struct strbuf buf = STRBUF_INIT;
 651         const char *dst_name;
 652         struct string_list_item *item;
 653         struct command *dst_cmd;
 654         unsigned char sha1[20];
 655         char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
 656         int flag;
 657
 658         strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
 659         dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
 660         strbuf_release(&buf);
 661
 662         if (!(flag & REF_ISSYMREF))
 663                 return;
 664
 665         dst_name = strip_namespace(dst_name);
 666         if (!dst_name) {
 667                 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
 668                 cmd->skip_update = 1;
 669                 cmd->error_string = "broken symref";
 670                 return;
 671         }
 672
 673         if ((item = string_list_lookup(list, dst_name)) == NULL)
 674                 return;
 675
 676         cmd->skip_update = 1;
 677
 678         dst_cmd = (struct command *) item->util;
 679
 680         if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
 681             !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
 682                 return;
 683
 684         dst_cmd->skip_update = 1;
 685
 686         strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
 687         strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
 688         strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
 689         strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
 690         rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
 691                  " its target '%s' (%s..%s)",
 692                  cmd->ref_name, cmd_oldh, cmd_newh,
 693                  dst_cmd->ref_name, dst_oldh, dst_newh);
 694
 695         cmd->error_string = dst_cmd->error_string =
 696                 "inconsistent aliased update";
 697 }
 698
 699 static void check_aliased_updates(struct command *commands)
 700 {
 701         struct command *cmd;
 702         struct string_list ref_list = STRING_LIST_INIT_NODUP;
 703
 704         for (cmd = commands; cmd; cmd = cmd->next) {
 705                 struct string_list_item *item =
 706                         string_list_append(&ref_list, cmd->ref_name);
 707                 item->util = (void *)cmd;
 708         }
 709         sort_string_list(&ref_list);
 710
 711         for (cmd = commands; cmd; cmd = cmd->next) {
 712                 if (!cmd->error_string)
 713                         check_aliased_update(cmd, &ref_list);
 714         }
 715
 716         string_list_clear(&ref_list, 0);
 717 }
 718
 719 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
 720 {
 721         struct command **cmd_list = cb_data;
 722         struct command *cmd = *cmd_list;
 723
 724         if (!cmd || is_null_sha1(cmd->new_sha1))
 725                 return -1; /* end of list */
 726         *cmd_list = NULL; /* this returns only one */
 727         hashcpy(sha1, cmd->new_sha1);
 728         return 0;
 729 }
 730
 731 static void set_connectivity_errors(struct command *commands,
 732                                     struct shallow_info *si)
 733 {
 734         struct command *cmd;
 735
 736         for (cmd = commands; cmd; cmd = cmd->next) {
 737                 struct command *singleton = cmd;
 738                 if (shallow_update && si->shallow_ref[cmd->index])
 739                         /* to be checked in update_shallow_ref() */
 740                         continue;
 741                 if (!check_everything_connected(command_singleton_iterator,
 742                                                 0, &singleton))
 743                         continue;
 744                 cmd->error_string = "missing necessary objects";
 745         }
 746 }
 747
 748 struct iterate_data {
 749         struct command *cmds;
 750         struct shallow_info *si;
 751 };
 752
 753 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
 754 {
 755         struct iterate_data *data = cb_data;
 756         struct command **cmd_list = &data->cmds;
 757         struct command *cmd = *cmd_list;
 758
 759         for (; cmd; cmd = cmd->next) {
 760                 if (shallow_update && data->si->shallow_ref[cmd->index])
 761                         /* to be checked in update_shallow_ref() */
 762                         continue;
 763                 if (!is_null_sha1(cmd->new_sha1) && !cmd->skip_update) {
 764                         hashcpy(sha1, cmd->new_sha1);
 765                         *cmd_list = cmd->next;
 766                         return 0;
 767                 }
 768         }
 769         *cmd_list = NULL;
 770         return -1; /* end of list */
 771 }
 772
 773 static void reject_updates_to_hidden(struct command *commands)
 774 {
 775         struct command *cmd;
 776
 777         for (cmd = commands; cmd; cmd = cmd->next) {
 778                 if (cmd->error_string || !ref_is_hidden(cmd->ref_name))
 779                         continue;
 780                 if (is_null_sha1(cmd->new_sha1))
 781                         cmd->error_string = "deny deleting a hidden ref";
 782                 else
 783                         cmd->error_string = "deny updating a hidden ref";
 784         }
 785 }
 786
 787 static void execute_commands(struct command *commands,
 788                              const char *unpacker_error,
 789                              struct shallow_info *si)
 790 {
 791         int checked_connectivity;
 792         struct command *cmd;
 793         unsigned char sha1[20];
 794         struct iterate_data data;
 795
 796         if (unpacker_error) {
 797                 for (cmd = commands; cmd; cmd = cmd->next)
 798                         cmd->error_string = "unpacker error";
 799                 return;
 800         }
 801
 802         data.cmds = commands;
 803         data.si = si;
 804         if (check_everything_connected(iterate_receive_command_list, 0, &data))
 805                 set_connectivity_errors(commands, si);
 806
 807         reject_updates_to_hidden(commands);
 808
 809         if (run_receive_hook(commands, "pre-receive", 0)) {
 810                 for (cmd = commands; cmd; cmd = cmd->next) {
 811                         if (!cmd->error_string)
 812                                 cmd->error_string = "pre-receive hook declined";
 813                 }
 814                 return;
 815         }
 816
 817         check_aliased_updates(commands);
 818
 819         free(head_name_to_free);
 820         head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
 821
 822         checked_connectivity = 1;
 823         for (cmd = commands; cmd; cmd = cmd->next) {
 824                 if (cmd->error_string)
 825                         continue;
 826
 827                 if (cmd->skip_update)
 828                         continue;
 829
 830                 cmd->error_string = update(cmd, si);
 831                 if (shallow_update && !cmd->error_string &&
 832                     si->shallow_ref[cmd->index]) {
 833                         error("BUG: connectivity check has not been run on ref %s",
 834                               cmd->ref_name);
 835                         checked_connectivity = 0;
 836                 }
 837         }
 838
 839         if (shallow_update && !checked_connectivity)
 840                 error("BUG: run 'git fsck' for safety.\n"
 841                       "If there are errors, try to remove "
 842                       "the reported refs above");
 843 }
 844
 845 static struct command *read_head_info(struct sha1_array *shallow)
 846 {
 847         struct command *commands = NULL;
 848         struct command **p = &commands;
 849         for (;;) {
 850                 char *line;
 851                 unsigned char old_sha1[20], new_sha1[20];
 852                 struct command *cmd;
 853                 char *refname;
 854                 int len, reflen;
 855
 856                 line = packet_read_line(0, &len);
 857                 if (!line)
 858                         break;
 859
 860                 if (len == 48 && starts_with(line, "shallow ")) {
 861                         if (get_sha1_hex(line + 8, old_sha1))
 862                                 die("protocol error: expected shallow sha, got '%s'", line + 8);
 863                         sha1_array_append(shallow, old_sha1);
 864                         continue;
 865                 }
 866
 867                 if (len < 83 ||
 868                     line[40] != ' ' ||
 869                     line[81] != ' ' ||
 870                     get_sha1_hex(line, old_sha1) ||
 871                     get_sha1_hex(line + 41, new_sha1))
 872                         die("protocol error: expected old/new/ref, got '%s'",
 873                             line);
 874
 875                 refname = line + 82;
 876                 reflen = strlen(refname);
 877                 if (reflen + 82 < len) {
 878                         const char *feature_list = refname + reflen + 1;
 879                         if (parse_feature_request(feature_list, "report-status"))
 880                                 report_status = 1;
 881                         if (parse_feature_request(feature_list, "side-band-64k"))
 882                                 use_sideband = LARGE_PACKET_MAX;
 883                         if (parse_feature_request(feature_list, "quiet"))
 884                                 quiet = 1;
 885                 }
 886                 cmd = xcalloc(1, sizeof(struct command) + len - 80);
 887                 hashcpy(cmd->old_sha1, old_sha1);
 888                 hashcpy(cmd->new_sha1, new_sha1);
 889                 memcpy(cmd->ref_name, line + 82, len - 81);
 890                 *p = cmd;
 891                 p = &cmd->next;
 892         }
 893         return commands;
 894 }
 895
 896 static const char *parse_pack_header(struct pack_header *hdr)
 897 {
 898         switch (read_pack_header(0, hdr)) {
 899         case PH_ERROR_EOF:
 900                 return "eof before pack header was fully read";
 901
 902         case PH_ERROR_PACK_SIGNATURE:
 903                 return "protocol error (pack signature mismatch detected)";
 904
 905         case PH_ERROR_PROTOCOL:
 906                 return "protocol error (pack version unsupported)";
 907
 908         default:
 909                 return "unknown error in parse_pack_header";
 910
 911         case 0:
 912                 return NULL;
 913         }
 914 }
 915
 916 static const char *pack_lockfile;
 917
 918 static const char *unpack(int err_fd, struct shallow_info *si)
 919 {
 920         struct pack_header hdr;
 921         struct argv_array av = ARGV_ARRAY_INIT;
 922         const char *hdr_err;
 923         int status;
 924         char hdr_arg[38];
 925         struct child_process child = CHILD_PROCESS_INIT;
 926         int fsck_objects = (receive_fsck_objects >= 0
 927                             ? receive_fsck_objects
 928                             : transfer_fsck_objects >= 0
 929                             ? transfer_fsck_objects
 930                             : 0);
 931
 932         hdr_err = parse_pack_header(&hdr);
 933         if (hdr_err) {
 934                 if (err_fd > 0)
 935                         close(err_fd);
 936                 return hdr_err;
 937         }
 938         snprintf(hdr_arg, sizeof(hdr_arg),
 939                         "--pack_header=%"PRIu32",%"PRIu32,
 940                         ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
 941
 942         if (si->nr_ours || si->nr_theirs) {
 943                 alt_shallow_file = setup_temporary_shallow(si->shallow);
 944                 argv_array_pushl(&av, "--shallow-file", alt_shallow_file, NULL);
 945         }
 946
 947         if (ntohl(hdr.hdr_entries) < unpack_limit) {
 948                 argv_array_pushl(&av, "unpack-objects", hdr_arg, NULL);
 949                 if (quiet)
 950                         argv_array_push(&av, "-q");
 951                 if (fsck_objects)
 952                         argv_array_push(&av, "--strict");
 953                 child.argv = av.argv;
 954                 child.no_stdout = 1;
 955                 child.err = err_fd;
 956                 child.git_cmd = 1;
 957                 status = run_command(&child);
 958                 if (status)
 959                         return "unpack-objects abnormal exit";
 960         } else {
 961                 int s;
 962                 char keep_arg[256];
 963
 964                 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
 965                 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 966                         strcpy(keep_arg + s, "localhost");
 967
 968                 argv_array_pushl(&av, "index-pack",
 969                                  "--stdin", hdr_arg, keep_arg, NULL);
 970                 if (fsck_objects)
 971                         argv_array_push(&av, "--strict");
 972                 if (fix_thin)
 973                         argv_array_push(&av, "--fix-thin");
 974                 child.argv = av.argv;
 975                 child.out = -1;
 976                 child.err = err_fd;
 977                 child.git_cmd = 1;
 978                 status = start_command(&child);
 979                 if (status)
 980                         return "index-pack fork failed";
 981                 pack_lockfile = index_pack_lockfile(child.out);
 982                 close(child.out);
 983                 status = finish_command(&child);
 984                 if (status)
 985                         return "index-pack abnormal exit";
 986                 reprepare_packed_git();
 987         }
 988         return NULL;
 989 }
 990
 991 static const char *unpack_with_sideband(struct shallow_info *si)
 992 {
 993         struct async muxer;
 994         const char *ret;
 995
 996         if (!use_sideband)
 997                 return unpack(0, si);
 998
 999         memset(&muxer, 0, sizeof(muxer));
1000         muxer.proc = copy_to_sideband;
1001         muxer.in = -1;
1002         if (start_async(&muxer))
1003                 return NULL;
1004
1005         ret = unpack(muxer.in, si);
1006
1007         finish_async(&muxer);
1008         return ret;
1009 }
1010
1011 static void prepare_shallow_update(struct command *commands,
1012                                    struct shallow_info *si)
1013 {
1014         int i, j, k, bitmap_size = (si->ref->nr + 31) / 32;
1015
1016         si->used_shallow = xmalloc(sizeof(*si->used_shallow) *
1017                                    si->shallow->nr);
1018         assign_shallow_commits_to_refs(si, si->used_shallow, NULL);
1019
1020         si->need_reachability_test =
1021                 xcalloc(si->shallow->nr, sizeof(*si->need_reachability_test));
1022         si->reachable =
1023                 xcalloc(si->shallow->nr, sizeof(*si->reachable));
1024         si->shallow_ref = xcalloc(si->ref->nr, sizeof(*si->shallow_ref));
1025
1026         for (i = 0; i < si->nr_ours; i++)
1027                 si->need_reachability_test[si->ours[i]] = 1;
1028
1029         for (i = 0; i < si->shallow->nr; i++) {
1030                 if (!si->used_shallow[i])
1031                         continue;
1032                 for (j = 0; j < bitmap_size; j++) {
1033                         if (!si->used_shallow[i][j])
1034                                 continue;
1035                         si->need_reachability_test[i]++;
1036                         for (k = 0; k < 32; k++)
1037                                 if (si->used_shallow[i][j] & (1 << k))
1038                                         si->shallow_ref[j * 32 + k]++;
1039                 }
1040
1041                 /*
1042                  * true for those associated with some refs and belong
1043                  * in "ours" list aka "step 7 not done yet"
1044                  */
1045                 si->need_reachability_test[i] =
1046                         si->need_reachability_test[i] > 1;
1047         }
1048
1049         /*
1050          * keep hooks happy by forcing a temporary shallow file via
1051          * env variable because we can't add --shallow-file to every
1052          * command. check_everything_connected() will be done with
1053          * true .git/shallow though.
1054          */
1055         setenv(GIT_SHALLOW_FILE_ENVIRONMENT, alt_shallow_file, 1);
1056 }
1057
1058 static void update_shallow_info(struct command *commands,
1059                                 struct shallow_info *si,
1060                                 struct sha1_array *ref)
1061 {
1062         struct command *cmd;
1063         int *ref_status;
1064         remove_nonexistent_theirs_shallow(si);
1065         if (!si->nr_ours && !si->nr_theirs) {
1066                 shallow_update = 0;
1067                 return;
1068         }
1069
1070         for (cmd = commands; cmd; cmd = cmd->next) {
1071                 if (is_null_sha1(cmd->new_sha1))
1072                         continue;
1073                 sha1_array_append(ref, cmd->new_sha1);
1074                 cmd->index = ref->nr - 1;
1075         }
1076         si->ref = ref;
1077
1078         if (shallow_update) {
1079                 prepare_shallow_update(commands, si);
1080                 return;
1081         }
1082
1083         ref_status = xmalloc(sizeof(*ref_status) * ref->nr);
1084         assign_shallow_commits_to_refs(si, NULL, ref_status);
1085         for (cmd = commands; cmd; cmd = cmd->next) {
1086                 if (is_null_sha1(cmd->new_sha1))
1087                         continue;
1088                 if (ref_status[cmd->index]) {
1089                         cmd->error_string = "shallow update not allowed";
1090                         cmd->skip_update = 1;
1091                 }
1092         }
1093         free(ref_status);
1094 }
1095
1096 static void report(struct command *commands, const char *unpack_status)
1097 {
1098         struct command *cmd;
1099         struct strbuf buf = STRBUF_INIT;
1100
1101         packet_buf_write(&buf, "unpack %s\n",
1102                          unpack_status ? unpack_status : "ok");
1103         for (cmd = commands; cmd; cmd = cmd->next) {
1104                 if (!cmd->error_string)
1105                         packet_buf_write(&buf, "ok %s\n",
1106                                          cmd->ref_name);
1107                 else
1108                         packet_buf_write(&buf, "ng %s %s\n",
1109                                          cmd->ref_name, cmd->error_string);
1110         }
1111         packet_buf_flush(&buf);
1112
1113         if (use_sideband)
1114                 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
1115         else
1116                 write_or_die(1, buf.buf, buf.len);
1117         strbuf_release(&buf);
1118 }
1119
1120 static int delete_only(struct command *commands)
1121 {
1122         struct command *cmd;
1123         for (cmd = commands; cmd; cmd = cmd->next) {
1124                 if (!is_null_sha1(cmd->new_sha1))
1125                         return 0;
1126         }
1127         return 1;
1128 }
1129
1130 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
1131 {
1132         int advertise_refs = 0;
1133         int stateless_rpc = 0;
1134         int i;
1135         const char *dir = NULL;
1136         struct command *commands;
1137         struct sha1_array shallow = SHA1_ARRAY_INIT;
1138         struct sha1_array ref = SHA1_ARRAY_INIT;
1139         struct shallow_info si;
1140
1141         packet_trace_identity("receive-pack");
1142
1143         argv++;
1144         for (i = 1; i < argc; i++) {
1145                 const char *arg = *argv++;
1146
1147                 if (*arg == '-') {
1148                         if (!strcmp(arg, "--quiet")) {
1149                                 quiet = 1;
1150                                 continue;
1151                         }
1152
1153                         if (!strcmp(arg, "--advertise-refs")) {
1154                                 advertise_refs = 1;
1155                                 continue;
1156                         }
1157                         if (!strcmp(arg, "--stateless-rpc")) {
1158                                 stateless_rpc = 1;
1159                                 continue;
1160                         }
1161                         if (!strcmp(arg, "--reject-thin-pack-for-testing")) {
1162                                 fix_thin = 0;
1163                                 continue;
1164                         }
1165
1166                         usage(receive_pack_usage);
1167                 }
1168                 if (dir)
1169                         usage(receive_pack_usage);
1170                 dir = arg;
1171         }
1172         if (!dir)
1173                 usage(receive_pack_usage);
1174
1175         setup_path();
1176
1177         if (!enter_repo(dir, 0))
1178                 die("'%s' does not appear to be a git repository", dir);
1179
1180         git_config(receive_pack_config, NULL);
1181
1182         if (0 <= transfer_unpack_limit)
1183                 unpack_limit = transfer_unpack_limit;
1184         else if (0 <= receive_unpack_limit)
1185                 unpack_limit = receive_unpack_limit;
1186
1187         if (advertise_refs || !stateless_rpc) {
1188                 write_head_info();
1189         }
1190         if (advertise_refs)
1191                 return 0;
1192
1193         if ((commands = read_head_info(&shallow)) != NULL) {
1194                 const char *unpack_status = NULL;
1195
1196                 prepare_shallow_info(&si, &shallow);
1197                 if (!si.nr_ours && !si.nr_theirs)
1198                         shallow_update = 0;
1199                 if (!delete_only(commands)) {
1200                         unpack_status = unpack_with_sideband(&si);
1201                         update_shallow_info(commands, &si, &ref);
1202                 }
1203                 execute_commands(commands, unpack_status, &si);
1204                 if (pack_lockfile)
1205                         unlink_or_warn(pack_lockfile);
1206                 if (report_status)
1207                         report(commands, unpack_status);
1208                 run_receive_hook(commands, "post-receive", 1);
1209                 run_update_post_hook(commands);
1210                 if (auto_gc) {
1211                         const char *argv_gc_auto[] = {
1212                                 "gc", "--auto", "--quiet", NULL,
1213                         };
1214                         int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1215                         run_command_v_opt(argv_gc_auto, opt);
1216                 }
1217                 if (auto_update_server_info)
1218                         update_server_info(0);
1219                 clear_shallow_info(&si);
1220         }
1221         if (use_sideband)
1222                 packet_flush(1);
1223         sha1_array_clear(&shallow);
1224         sha1_array_clear(&ref);
1225         return 0;
1226 }