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