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 = CHILD_PROCESS_INIT;
 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         proc.argv = argv;
 270         proc.in = -1;
 271         proc.stdout_to_stderr = 1;
 272
 273         if (use_sideband) {
 274                 memset(&muxer, 0, sizeof(muxer));
 275                 muxer.proc = copy_to_sideband;
 276                 muxer.in = -1;
 277                 code = start_async(&muxer);
 278                 if (code)
 279                         return code;
 280                 proc.err = muxer.in;
 281         }
 282
 283         code = start_command(&proc);
 284         if (code) {
 285                 if (use_sideband)
 286                         finish_async(&muxer);
 287                 return code;
 288         }
 289
 290         while (1) {
 291                 const char *buf;
 292                 size_t n;
 293                 if (feed(feed_state, &buf, &n))
 294                         break;
 295                 if (write_in_full(proc.in, buf, n) != n)
 296                         break;
 297         }
 298         close(proc.in);
 299         if (use_sideband)
 300                 finish_async(&muxer);
 301         return finish_command(&proc);
 302 }
 303
 304 struct receive_hook_feed_state {
 305         struct command *cmd;
 306         int skip_broken;
 307         struct strbuf buf;
 308 };
 309
 310 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
 311 {
 312         struct receive_hook_feed_state *state = state_;
 313         struct command *cmd = state->cmd;
 314
 315         while (cmd &&
 316                state->skip_broken && (cmd->error_string || cmd->did_not_exist))
 317                 cmd = cmd->next;
 318         if (!cmd)
 319                 return -1; /* EOF */
 320         strbuf_reset(&state->buf);
 321         strbuf_addf(&state->buf, "%s %s %s\n",
 322                     sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
 323                     cmd->ref_name);
 324         state->cmd = cmd->next;
 325         if (bufp) {
 326                 *bufp = state->buf.buf;
 327                 *sizep = state->buf.len;
 328         }
 329         return 0;
 330 }
 331
 332 static int run_receive_hook(struct command *commands, const char *hook_name,
 333                             int skip_broken)
 334 {
 335         struct receive_hook_feed_state state;
 336         int status;
 337
 338         strbuf_init(&state.buf, 0);
 339         state.cmd = commands;
 340         state.skip_broken = skip_broken;
 341         if (feed_receive_hook(&state, NULL, NULL))
 342                 return 0;
 343         state.cmd = commands;
 344         status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
 345         strbuf_release(&state.buf);
 346         return status;
 347 }
 348
 349 static int run_update_hook(struct command *cmd)
 350 {
 351         const char *argv[5];
 352         struct child_process proc = CHILD_PROCESS_INIT;
 353         int code;
 354
 355         argv[0] = find_hook("update");
 356         if (!argv[0])
 357                 return 0;
 358
 359         argv[1] = cmd->ref_name;
 360         argv[2] = sha1_to_hex(cmd->old_sha1);
 361         argv[3] = sha1_to_hex(cmd->new_sha1);
 362         argv[4] = NULL;
 363
 364         proc.no_stdin = 1;
 365         proc.stdout_to_stderr = 1;
 366         proc.err = use_sideband ? -1 : 0;
 367         proc.argv = argv;
 368
 369         code = start_command(&proc);
 370         if (code)
 371                 return code;
 372         if (use_sideband)
 373                 copy_to_sideband(proc.err, -1, NULL);
 374         return finish_command(&proc);
 375 }
 376
 377 static int is_ref_checked_out(const char *ref)
 378 {
 379         if (is_bare_repository())
 380                 return 0;
 381
 382         if (!head_name)
 383                 return 0;
 384         return !strcmp(head_name, ref);
 385 }
 386
 387 static char *refuse_unconfigured_deny_msg[] = {
 388         "By default, updating the current branch in a non-bare repository",
 389         "is denied, because it will make the index and work tree inconsistent",
 390         "with what you pushed, and will require 'git reset --hard' to match",
 391         "the work tree to HEAD.",
 392         "",
 393         "You can set 'receive.denyCurrentBranch' configuration variable to",
 394         "'ignore' or 'warn' in the remote repository to allow pushing into",
 395         "its current branch; however, this is not recommended unless you",
 396         "arranged to update its work tree to match what you pushed in some",
 397         "other way.",
 398         "",
 399         "To squelch this message and still keep the default behaviour, set",
 400         "'receive.denyCurrentBranch' configuration variable to 'refuse'."
 401 };
 402
 403 static void refuse_unconfigured_deny(void)
 404 {
 405         int i;
 406         for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
 407                 rp_error("%s", refuse_unconfigured_deny_msg[i]);
 408 }
 409
 410 static char *refuse_unconfigured_deny_delete_current_msg[] = {
 411         "By default, deleting the current branch is denied, because the next",
 412         "'git clone' won't result in any file checked out, causing confusion.",
 413         "",
 414         "You can set 'receive.denyDeleteCurrent' configuration variable to",
 415         "'warn' or 'ignore' in the remote repository to allow deleting the",
 416         "current branch, with or without a warning message.",
 417         "",
 418         "To squelch this message, you can set it to 'refuse'."
 419 };
 420
 421 static void refuse_unconfigured_deny_delete_current(void)
 422 {
 423         int i;
 424         for (i = 0;
 425              i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
 426              i++)
 427                 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
 428 }
 429
 430 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20]);
 431 static int update_shallow_ref(struct command *cmd, struct shallow_info *si)
 432 {
 433         static struct lock_file shallow_lock;
 434         struct sha1_array extra = SHA1_ARRAY_INIT;
 435         const char *alt_file;
 436         uint32_t mask = 1 << (cmd->index % 32);
 437         int i;
 438
 439         trace_printf_key(&trace_shallow,
 440                          "shallow: update_shallow_ref %s\n", cmd->ref_name);
 441         for (i = 0; i < si->shallow->nr; i++)
 442                 if (si->used_shallow[i] &&
 443                     (si->used_shallow[i][cmd->index / 32] & mask) &&
 444                     !delayed_reachability_test(si, i))
 445                         sha1_array_append(&extra, si->shallow->sha1[i]);
 446
 447         setup_alternate_shallow(&shallow_lock, &alt_file, &extra);
 448         if (check_shallow_connected(command_singleton_iterator,
 449                                     0, cmd, alt_file)) {
 450                 rollback_lock_file(&shallow_lock);
 451                 sha1_array_clear(&extra);
 452                 return -1;
 453         }
 454
 455         commit_lock_file(&shallow_lock);
 456
 457         /*
 458          * Make sure setup_alternate_shallow() for the next ref does
 459          * not lose these new roots..
 460          */
 461         for (i = 0; i < extra.nr; i++)
 462                 register_shallow(extra.sha1[i]);
 463
 464         si->shallow_ref[cmd->index] = 0;
 465         sha1_array_clear(&extra);
 466         return 0;
 467 }
 468
 469 static const char *update(struct command *cmd, struct shallow_info *si)
 470 {
 471         const char *name = cmd->ref_name;
 472         struct strbuf namespaced_name_buf = STRBUF_INIT;
 473         const char *namespaced_name;
 474         unsigned char *old_sha1 = cmd->old_sha1;
 475         unsigned char *new_sha1 = cmd->new_sha1;
 476         struct ref_lock *lock;
 477
 478         /* only refs/... are allowed */
 479         if (!starts_with(name, "refs/") || check_refname_format(name + 5, 0)) {
 480                 rp_error("refusing to create funny ref '%s' remotely", name);
 481                 return "funny refname";
 482         }
 483
 484         strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
 485         namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
 486
 487         if (is_ref_checked_out(namespaced_name)) {
 488                 switch (deny_current_branch) {
 489                 case DENY_IGNORE:
 490                         break;
 491                 case DENY_WARN:
 492                         rp_warning("updating the current branch");
 493                         break;
 494                 case DENY_REFUSE:
 495                 case DENY_UNCONFIGURED:
 496                         rp_error("refusing to update checked out branch: %s", name);
 497                         if (deny_current_branch == DENY_UNCONFIGURED)
 498                                 refuse_unconfigured_deny();
 499                         return "branch is currently checked out";
 500                 }
 501         }
 502
 503         if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
 504                 error("unpack should have generated %s, "
 505                       "but I can't find it!", sha1_to_hex(new_sha1));
 506                 return "bad pack";
 507         }
 508
 509         if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
 510                 if (deny_deletes && starts_with(name, "refs/heads/")) {
 511                         rp_error("denying ref deletion for %s", name);
 512                         return "deletion prohibited";
 513                 }
 514
 515                 if (!strcmp(namespaced_name, head_name)) {
 516                         switch (deny_delete_current) {
 517                         case DENY_IGNORE:
 518                                 break;
 519                         case DENY_WARN:
 520                                 rp_warning("deleting the current branch");
 521                                 break;
 522                         case DENY_REFUSE:
 523                         case DENY_UNCONFIGURED:
 524                                 if (deny_delete_current == DENY_UNCONFIGURED)
 525                                         refuse_unconfigured_deny_delete_current();
 526                                 rp_error("refusing to delete the current branch: %s", name);
 527                                 return "deletion of the current branch prohibited";
 528                         }
 529                 }
 530         }
 531
 532         if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
 533             !is_null_sha1(old_sha1) &&
 534             starts_with(name, "refs/heads/")) {
 535                 struct object *old_object, *new_object;
 536                 struct commit *old_commit, *new_commit;
 537
 538                 old_object = parse_object(old_sha1);
 539                 new_object = parse_object(new_sha1);
 540
 541                 if (!old_object || !new_object ||
 542                     old_object->type != OBJ_COMMIT ||
 543                     new_object->type != OBJ_COMMIT) {
 544                         error("bad sha1 objects for %s", name);
 545                         return "bad ref";
 546                 }
 547                 old_commit = (struct commit *)old_object;
 548                 new_commit = (struct commit *)new_object;
 549                 if (!in_merge_bases(old_commit, new_commit)) {
 550                         rp_error("denying non-fast-forward %s"
 551                                  " (you should pull first)", name);
 552                         return "non-fast-forward";
 553                 }
 554         }
 555         if (run_update_hook(cmd)) {
 556                 rp_error("hook declined to update %s", name);
 557                 return "hook declined";
 558         }
 559
 560         if (is_null_sha1(new_sha1)) {
 561                 if (!parse_object(old_sha1)) {
 562                         old_sha1 = NULL;
 563                         if (ref_exists(name)) {
 564                                 rp_warning("Allowing deletion of corrupt ref.");
 565                         } else {
 566                                 rp_warning("Deleting a non-existent ref.");
 567                                 cmd->did_not_exist = 1;
 568                         }
 569                 }
 570                 if (delete_ref(namespaced_name, old_sha1, 0)) {
 571                         rp_error("failed to delete %s", name);
 572                         return "failed to delete";
 573                 }
 574                 return NULL; /* good */
 575         }
 576         else {
 577                 if (shallow_update && si->shallow_ref[cmd->index] &&
 578                     update_shallow_ref(cmd, si))
 579                         return "shallow error";
 580
 581                 lock = lock_any_ref_for_update(namespaced_name, old_sha1,
 582                                                0, NULL);
 583                 if (!lock) {
 584                         rp_error("failed to lock %s", name);
 585                         return "failed to lock";
 586                 }
 587                 if (write_ref_sha1(lock, new_sha1, "push")) {
 588                         return "failed to write"; /* error() already called */
 589                 }
 590                 return NULL; /* good */
 591         }
 592 }
 593
 594 static void run_update_post_hook(struct command *commands)
 595 {
 596         struct command *cmd;
 597         int argc;
 598         const char **argv;
 599         struct child_process proc = CHILD_PROCESS_INIT;
 600         char *hook;
 601
 602         hook = find_hook("post-update");
 603         for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
 604                 if (cmd->error_string || cmd->did_not_exist)
 605                         continue;
 606                 argc++;
 607         }
 608         if (!argc || !hook)
 609                 return;
 610
 611         argv = xmalloc(sizeof(*argv) * (2 + argc));
 612         argv[0] = hook;
 613
 614         for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
 615                 if (cmd->error_string || cmd->did_not_exist)
 616                         continue;
 617                 argv[argc] = xstrdup(cmd->ref_name);
 618                 argc++;
 619         }
 620         argv[argc] = NULL;
 621
 622         proc.no_stdin = 1;
 623         proc.stdout_to_stderr = 1;
 624         proc.err = use_sideband ? -1 : 0;
 625         proc.argv = argv;
 626
 627         if (!start_command(&proc)) {
 628                 if (use_sideband)
 629                         copy_to_sideband(proc.err, -1, NULL);
 630                 finish_command(&proc);
 631         }
 632 }
 633
 634 static void check_aliased_update(struct command *cmd, struct string_list *list)
 635 {
 636         struct strbuf buf = STRBUF_INIT;
 637         const char *dst_name;
 638         struct string_list_item *item;
 639         struct command *dst_cmd;
 640         unsigned char sha1[20];
 641         char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
 642         int flag;
 643
 644         strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
 645         dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
 646         strbuf_release(&buf);
 647
 648         if (!(flag & REF_ISSYMREF))
 649                 return;
 650
 651         dst_name = strip_namespace(dst_name);
 652         if (!dst_name) {
 653                 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
 654                 cmd->skip_update = 1;
 655                 cmd->error_string = "broken symref";
 656                 return;
 657         }
 658
 659         if ((item = string_list_lookup(list, dst_name)) == NULL)
 660                 return;
 661
 662         cmd->skip_update = 1;
 663
 664         dst_cmd = (struct command *) item->util;
 665
 666         if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
 667             !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
 668                 return;
 669
 670         dst_cmd->skip_update = 1;
 671
 672         strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
 673         strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
 674         strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
 675         strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
 676         rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
 677                  " its target '%s' (%s..%s)",
 678                  cmd->ref_name, cmd_oldh, cmd_newh,
 679                  dst_cmd->ref_name, dst_oldh, dst_newh);
 680
 681         cmd->error_string = dst_cmd->error_string =
 682                 "inconsistent aliased update";
 683 }
 684
 685 static void check_aliased_updates(struct command *commands)
 686 {
 687         struct command *cmd;
 688         struct string_list ref_list = STRING_LIST_INIT_NODUP;
 689
 690         for (cmd = commands; cmd; cmd = cmd->next) {
 691                 struct string_list_item *item =
 692                         string_list_append(&ref_list, cmd->ref_name);
 693                 item->util = (void *)cmd;
 694         }
 695         sort_string_list(&ref_list);
 696
 697         for (cmd = commands; cmd; cmd = cmd->next) {
 698                 if (!cmd->error_string)
 699                         check_aliased_update(cmd, &ref_list);
 700         }
 701
 702         string_list_clear(&ref_list, 0);
 703 }
 704
 705 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
 706 {
 707         struct command **cmd_list = cb_data;
 708         struct command *cmd = *cmd_list;
 709
 710         if (!cmd || is_null_sha1(cmd->new_sha1))
 711                 return -1; /* end of list */
 712         *cmd_list = NULL; /* this returns only one */
 713         hashcpy(sha1, cmd->new_sha1);
 714         return 0;
 715 }
 716
 717 static void set_connectivity_errors(struct command *commands,
 718                                     struct shallow_info *si)
 719 {
 720         struct command *cmd;
 721
 722         for (cmd = commands; cmd; cmd = cmd->next) {
 723                 struct command *singleton = cmd;
 724                 if (shallow_update && si->shallow_ref[cmd->index])
 725                         /* to be checked in update_shallow_ref() */
 726                         continue;
 727                 if (!check_everything_connected(command_singleton_iterator,
 728                                                 0, &singleton))
 729                         continue;
 730                 cmd->error_string = "missing necessary objects";
 731         }
 732 }
 733
 734 struct iterate_data {
 735         struct command *cmds;
 736         struct shallow_info *si;
 737 };
 738
 739 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
 740 {
 741         struct iterate_data *data = cb_data;
 742         struct command **cmd_list = &data->cmds;
 743         struct command *cmd = *cmd_list;
 744
 745         for (; cmd; cmd = cmd->next) {
 746                 if (shallow_update && data->si->shallow_ref[cmd->index])
 747                         /* to be checked in update_shallow_ref() */
 748                         continue;
 749                 if (!is_null_sha1(cmd->new_sha1) && !cmd->skip_update) {
 750                         hashcpy(sha1, cmd->new_sha1);
 751                         *cmd_list = cmd->next;
 752                         return 0;
 753                 }
 754         }
 755         *cmd_list = NULL;
 756         return -1; /* end of list */
 757 }
 758
 759 static void reject_updates_to_hidden(struct command *commands)
 760 {
 761         struct command *cmd;
 762
 763         for (cmd = commands; cmd; cmd = cmd->next) {
 764                 if (cmd->error_string || !ref_is_hidden(cmd->ref_name))
 765                         continue;
 766                 if (is_null_sha1(cmd->new_sha1))
 767                         cmd->error_string = "deny deleting a hidden ref";
 768                 else
 769                         cmd->error_string = "deny updating a hidden ref";
 770         }
 771 }
 772
 773 static void execute_commands(struct command *commands,
 774                              const char *unpacker_error,
 775                              struct shallow_info *si)
 776 {
 777         int checked_connectivity;
 778         struct command *cmd;
 779         unsigned char sha1[20];
 780         struct iterate_data data;
 781
 782         if (unpacker_error) {
 783                 for (cmd = commands; cmd; cmd = cmd->next)
 784                         cmd->error_string = "unpacker error";
 785                 return;
 786         }
 787
 788         data.cmds = commands;
 789         data.si = si;
 790         if (check_everything_connected(iterate_receive_command_list, 0, &data))
 791                 set_connectivity_errors(commands, si);
 792
 793         reject_updates_to_hidden(commands);
 794
 795         if (run_receive_hook(commands, "pre-receive", 0)) {
 796                 for (cmd = commands; cmd; cmd = cmd->next) {
 797                         if (!cmd->error_string)
 798                                 cmd->error_string = "pre-receive hook declined";
 799                 }
 800                 return;
 801         }
 802
 803         check_aliased_updates(commands);
 804
 805         free(head_name_to_free);
 806         head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
 807
 808         checked_connectivity = 1;
 809         for (cmd = commands; cmd; cmd = cmd->next) {
 810                 if (cmd->error_string)
 811                         continue;
 812
 813                 if (cmd->skip_update)
 814                         continue;
 815
 816                 cmd->error_string = update(cmd, si);
 817                 if (shallow_update && !cmd->error_string &&
 818                     si->shallow_ref[cmd->index]) {
 819                         error("BUG: connectivity check has not been run on ref %s",
 820                               cmd->ref_name);
 821                         checked_connectivity = 0;
 822                 }
 823         }
 824
 825         if (shallow_update && !checked_connectivity)
 826                 error("BUG: run 'git fsck' for safety.\n"
 827                       "If there are errors, try to remove "
 828                       "the reported refs above");
 829 }
 830
 831 static struct command *read_head_info(struct sha1_array *shallow)
 832 {
 833         struct command *commands = NULL;
 834         struct command **p = &commands;
 835         for (;;) {
 836                 char *line;
 837                 unsigned char old_sha1[20], new_sha1[20];
 838                 struct command *cmd;
 839                 char *refname;
 840                 int len, reflen;
 841
 842                 line = packet_read_line(0, &len);
 843                 if (!line)
 844                         break;
 845
 846                 if (len == 48 && starts_with(line, "shallow ")) {
 847                         if (get_sha1_hex(line + 8, old_sha1))
 848                                 die("protocol error: expected shallow sha, got '%s'", line + 8);
 849                         sha1_array_append(shallow, old_sha1);
 850                         continue;
 851                 }
 852
 853                 if (len < 83 ||
 854                     line[40] != ' ' ||
 855                     line[81] != ' ' ||
 856                     get_sha1_hex(line, old_sha1) ||
 857                     get_sha1_hex(line + 41, new_sha1))
 858                         die("protocol error: expected old/new/ref, got '%s'",
 859                             line);
 860
 861                 refname = line + 82;
 862                 reflen = strlen(refname);
 863                 if (reflen + 82 < len) {
 864                         const char *feature_list = refname + reflen + 1;
 865                         if (parse_feature_request(feature_list, "report-status"))
 866                                 report_status = 1;
 867                         if (parse_feature_request(feature_list, "side-band-64k"))
 868                                 use_sideband = LARGE_PACKET_MAX;
 869                         if (parse_feature_request(feature_list, "quiet"))
 870                                 quiet = 1;
 871                 }
 872                 cmd = xcalloc(1, sizeof(struct command) + len - 80);
 873                 hashcpy(cmd->old_sha1, old_sha1);
 874                 hashcpy(cmd->new_sha1, new_sha1);
 875                 memcpy(cmd->ref_name, line + 82, len - 81);
 876                 *p = cmd;
 877                 p = &cmd->next;
 878         }
 879         return commands;
 880 }
 881
 882 static const char *parse_pack_header(struct pack_header *hdr)
 883 {
 884         switch (read_pack_header(0, hdr)) {
 885         case PH_ERROR_EOF:
 886                 return "eof before pack header was fully read";
 887
 888         case PH_ERROR_PACK_SIGNATURE:
 889                 return "protocol error (pack signature mismatch detected)";
 890
 891         case PH_ERROR_PROTOCOL:
 892                 return "protocol error (pack version unsupported)";
 893
 894         default:
 895                 return "unknown error in parse_pack_header";
 896
 897         case 0:
 898                 return NULL;
 899         }
 900 }
 901
 902 static const char *pack_lockfile;
 903
 904 static const char *unpack(int err_fd, struct shallow_info *si)
 905 {
 906         struct pack_header hdr;
 907         struct argv_array av = ARGV_ARRAY_INIT;
 908         const char *hdr_err;
 909         int status;
 910         char hdr_arg[38];
 911         struct child_process child = CHILD_PROCESS_INIT;
 912         int fsck_objects = (receive_fsck_objects >= 0
 913                             ? receive_fsck_objects
 914                             : transfer_fsck_objects >= 0
 915                             ? transfer_fsck_objects
 916                             : 0);
 917
 918         hdr_err = parse_pack_header(&hdr);
 919         if (hdr_err) {
 920                 if (err_fd > 0)
 921                         close(err_fd);
 922                 return hdr_err;
 923         }
 924         snprintf(hdr_arg, sizeof(hdr_arg),
 925                         "--pack_header=%"PRIu32",%"PRIu32,
 926                         ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
 927
 928         if (si->nr_ours || si->nr_theirs) {
 929                 alt_shallow_file = setup_temporary_shallow(si->shallow);
 930                 argv_array_pushl(&av, "--shallow-file", alt_shallow_file, NULL);
 931         }
 932
 933         if (ntohl(hdr.hdr_entries) < unpack_limit) {
 934                 argv_array_pushl(&av, "unpack-objects", hdr_arg, NULL);
 935                 if (quiet)
 936                         argv_array_push(&av, "-q");
 937                 if (fsck_objects)
 938                         argv_array_push(&av, "--strict");
 939                 child.argv = av.argv;
 940                 child.no_stdout = 1;
 941                 child.err = err_fd;
 942                 child.git_cmd = 1;
 943                 status = run_command(&child);
 944                 if (status)
 945                         return "unpack-objects abnormal exit";
 946         } else {
 947                 int s;
 948                 char keep_arg[256];
 949
 950                 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
 951                 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 952                         strcpy(keep_arg + s, "localhost");
 953
 954                 argv_array_pushl(&av, "index-pack",
 955                                  "--stdin", hdr_arg, keep_arg, NULL);
 956                 if (fsck_objects)
 957                         argv_array_push(&av, "--strict");
 958                 if (fix_thin)
 959                         argv_array_push(&av, "--fix-thin");
 960                 child.argv = av.argv;
 961                 child.out = -1;
 962                 child.err = err_fd;
 963                 child.git_cmd = 1;
 964                 status = start_command(&child);
 965                 if (status)
 966                         return "index-pack fork failed";
 967                 pack_lockfile = index_pack_lockfile(child.out);
 968                 close(child.out);
 969                 status = finish_command(&child);
 970                 if (status)
 971                         return "index-pack abnormal exit";
 972                 reprepare_packed_git();
 973         }
 974         return NULL;
 975 }
 976
 977 static const char *unpack_with_sideband(struct shallow_info *si)
 978 {
 979         struct async muxer;
 980         const char *ret;
 981
 982         if (!use_sideband)
 983                 return unpack(0, si);
 984
 985         memset(&muxer, 0, sizeof(muxer));
 986         muxer.proc = copy_to_sideband;
 987         muxer.in = -1;
 988         if (start_async(&muxer))
 989                 return NULL;
 990
 991         ret = unpack(muxer.in, si);
 992
 993         finish_async(&muxer);
 994         return ret;
 995 }
 996
 997 static void prepare_shallow_update(struct command *commands,
 998                                    struct shallow_info *si)
 999 {
1000         int i, j, k, bitmap_size = (si->ref->nr + 31) / 32;
1001
1002         si->used_shallow = xmalloc(sizeof(*si->used_shallow) *
1003                                    si->shallow->nr);
1004         assign_shallow_commits_to_refs(si, si->used_shallow, NULL);
1005
1006         si->need_reachability_test =
1007                 xcalloc(si->shallow->nr, sizeof(*si->need_reachability_test));
1008         si->reachable =
1009                 xcalloc(si->shallow->nr, sizeof(*si->reachable));
1010         si->shallow_ref = xcalloc(si->ref->nr, sizeof(*si->shallow_ref));
1011
1012         for (i = 0; i < si->nr_ours; i++)
1013                 si->need_reachability_test[si->ours[i]] = 1;
1014
1015         for (i = 0; i < si->shallow->nr; i++) {
1016                 if (!si->used_shallow[i])
1017                         continue;
1018                 for (j = 0; j < bitmap_size; j++) {
1019                         if (!si->used_shallow[i][j])
1020                                 continue;
1021                         si->need_reachability_test[i]++;
1022                         for (k = 0; k < 32; k++)
1023                                 if (si->used_shallow[i][j] & (1 << k))
1024                                         si->shallow_ref[j * 32 + k]++;
1025                 }
1026
1027                 /*
1028                  * true for those associated with some refs and belong
1029                  * in "ours" list aka "step 7 not done yet"
1030                  */
1031                 si->need_reachability_test[i] =
1032                         si->need_reachability_test[i] > 1;
1033         }
1034
1035         /*
1036          * keep hooks happy by forcing a temporary shallow file via
1037          * env variable because we can't add --shallow-file to every
1038          * command. check_everything_connected() will be done with
1039          * true .git/shallow though.
1040          */
1041         setenv(GIT_SHALLOW_FILE_ENVIRONMENT, alt_shallow_file, 1);
1042 }
1043
1044 static void update_shallow_info(struct command *commands,
1045                                 struct shallow_info *si,
1046                                 struct sha1_array *ref)
1047 {
1048         struct command *cmd;
1049         int *ref_status;
1050         remove_nonexistent_theirs_shallow(si);
1051         if (!si->nr_ours && !si->nr_theirs) {
1052                 shallow_update = 0;
1053                 return;
1054         }
1055
1056         for (cmd = commands; cmd; cmd = cmd->next) {
1057                 if (is_null_sha1(cmd->new_sha1))
1058                         continue;
1059                 sha1_array_append(ref, cmd->new_sha1);
1060                 cmd->index = ref->nr - 1;
1061         }
1062         si->ref = ref;
1063
1064         if (shallow_update) {
1065                 prepare_shallow_update(commands, si);
1066                 return;
1067         }
1068
1069         ref_status = xmalloc(sizeof(*ref_status) * ref->nr);
1070         assign_shallow_commits_to_refs(si, NULL, ref_status);
1071         for (cmd = commands; cmd; cmd = cmd->next) {
1072                 if (is_null_sha1(cmd->new_sha1))
1073                         continue;
1074                 if (ref_status[cmd->index]) {
1075                         cmd->error_string = "shallow update not allowed";
1076                         cmd->skip_update = 1;
1077                 }
1078         }
1079         free(ref_status);
1080 }
1081
1082 static void report(struct command *commands, const char *unpack_status)
1083 {
1084         struct command *cmd;
1085         struct strbuf buf = STRBUF_INIT;
1086
1087         packet_buf_write(&buf, "unpack %s\n",
1088                          unpack_status ? unpack_status : "ok");
1089         for (cmd = commands; cmd; cmd = cmd->next) {
1090                 if (!cmd->error_string)
1091                         packet_buf_write(&buf, "ok %s\n",
1092                                          cmd->ref_name);
1093                 else
1094                         packet_buf_write(&buf, "ng %s %s\n",
1095                                          cmd->ref_name, cmd->error_string);
1096         }
1097         packet_buf_flush(&buf);
1098
1099         if (use_sideband)
1100                 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
1101         else
1102                 write_or_die(1, buf.buf, buf.len);
1103         strbuf_release(&buf);
1104 }
1105
1106 static int delete_only(struct command *commands)
1107 {
1108         struct command *cmd;
1109         for (cmd = commands; cmd; cmd = cmd->next) {
1110                 if (!is_null_sha1(cmd->new_sha1))
1111                         return 0;
1112         }
1113         return 1;
1114 }
1115
1116 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
1117 {
1118         int advertise_refs = 0;
1119         int stateless_rpc = 0;
1120         int i;
1121         const char *dir = NULL;
1122         struct command *commands;
1123         struct sha1_array shallow = SHA1_ARRAY_INIT;
1124         struct sha1_array ref = SHA1_ARRAY_INIT;
1125         struct shallow_info si;
1126
1127         packet_trace_identity("receive-pack");
1128
1129         argv++;
1130         for (i = 1; i < argc; i++) {
1131                 const char *arg = *argv++;
1132
1133                 if (*arg == '-') {
1134                         if (!strcmp(arg, "--quiet")) {
1135                                 quiet = 1;
1136                                 continue;
1137                         }
1138
1139                         if (!strcmp(arg, "--advertise-refs")) {
1140                                 advertise_refs = 1;
1141                                 continue;
1142                         }
1143                         if (!strcmp(arg, "--stateless-rpc")) {
1144                                 stateless_rpc = 1;
1145                                 continue;
1146                         }
1147                         if (!strcmp(arg, "--reject-thin-pack-for-testing")) {
1148                                 fix_thin = 0;
1149                                 continue;
1150                         }
1151
1152                         usage(receive_pack_usage);
1153                 }
1154                 if (dir)
1155                         usage(receive_pack_usage);
1156                 dir = arg;
1157         }
1158         if (!dir)
1159                 usage(receive_pack_usage);
1160
1161         setup_path();
1162
1163         if (!enter_repo(dir, 0))
1164                 die("'%s' does not appear to be a git repository", dir);
1165
1166         git_config(receive_pack_config, NULL);
1167
1168         if (0 <= transfer_unpack_limit)
1169                 unpack_limit = transfer_unpack_limit;
1170         else if (0 <= receive_unpack_limit)
1171                 unpack_limit = receive_unpack_limit;
1172
1173         if (advertise_refs || !stateless_rpc) {
1174                 write_head_info();
1175         }
1176         if (advertise_refs)
1177                 return 0;
1178
1179         if ((commands = read_head_info(&shallow)) != NULL) {
1180                 const char *unpack_status = NULL;
1181
1182                 prepare_shallow_info(&si, &shallow);
1183                 if (!si.nr_ours && !si.nr_theirs)
1184                         shallow_update = 0;
1185                 if (!delete_only(commands)) {
1186                         unpack_status = unpack_with_sideband(&si);
1187                         update_shallow_info(commands, &si, &ref);
1188                 }
1189                 execute_commands(commands, unpack_status, &si);
1190                 if (pack_lockfile)
1191                         unlink_or_warn(pack_lockfile);
1192                 if (report_status)
1193                         report(commands, unpack_status);
1194                 run_receive_hook(commands, "post-receive", 1);
1195                 run_update_post_hook(commands);
1196                 if (auto_gc) {
1197                         const char *argv_gc_auto[] = {
1198                                 "gc", "--auto", "--quiet", NULL,
1199                         };
1200                         int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1201                         run_command_v_opt(argv_gc_auto, opt);
1202                 }
1203                 if (auto_update_server_info)
1204                         update_server_info(0);
1205                 clear_shallow_info(&si);
1206         }
1207         if (use_sideband)
1208                 packet_flush(1);
1209         sha1_array_clear(&shallow);
1210         sha1_array_clear(&ref);
1211         return 0;
1212 }