builtin/receive-pack.c

   1 #include "builtin.h"
   2 #include "pack.h"
   3 #include "refs.h"
   4 #include "pkt-line.h"
   5 #include "sideband.h"
   6 #include "run-command.h"
   7 #include "exec_cmd.h"
   8 #include "commit.h"
   9 #include "object.h"
  10 #include "remote.h"
  11 #include "transport.h"
  12 #include "string-list.h"
  13 #include "sha1-array.h"
  14 #include "connected.h"
  15 #include "version.h"
  16
  17 static const char receive_pack_usage[] = "git receive-pack <git-dir>";
  18
  19 enum deny_action {
  20         DENY_UNCONFIGURED,
  21         DENY_IGNORE,
  22         DENY_WARN,
  23         DENY_REFUSE,
  24         DENY_UPDATE_INSTEAD,
  25         DENY_DETACH_INSTEAD,
  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 const char *head_name;
  44 static void *head_name_to_free;
  45 static int sent_capabilities;
  46
  47 static enum deny_action parse_deny_action(const char *var, const char *value)
  48 {
  49         if (value) {
  50                 if (!strcasecmp(value, "ignore"))
  51                         return DENY_IGNORE;
  52                 if (!strcasecmp(value, "warn"))
  53                         return DENY_WARN;
  54                 if (!strcasecmp(value, "refuse"))
  55                         return DENY_REFUSE;
  56         }
  57         if (git_config_bool(var, value))
  58                 return DENY_REFUSE;
  59         return DENY_IGNORE;
  60 }
  61
  62 static int receive_pack_config(const char *var, const char *value, void *cb)
  63 {
  64         if (strcmp(var, "receive.denydeletes") == 0) {
  65                 deny_deletes = git_config_bool(var, value);
  66                 return 0;
  67         }
  68
  69         if (strcmp(var, "receive.denynonfastforwards") == 0) {
  70                 deny_non_fast_forwards = git_config_bool(var, value);
  71                 return 0;
  72         }
  73
  74         if (strcmp(var, "receive.unpacklimit") == 0) {
  75                 receive_unpack_limit = git_config_int(var, value);
  76                 return 0;
  77         }
  78
  79         if (strcmp(var, "transfer.unpacklimit") == 0) {
  80                 transfer_unpack_limit = git_config_int(var, value);
  81                 return 0;
  82         }
  83
  84         if (strcmp(var, "receive.fsckobjects") == 0) {
  85                 receive_fsck_objects = git_config_bool(var, value);
  86                 return 0;
  87         }
  88
  89         if (strcmp(var, "transfer.fsckobjects") == 0) {
  90                 transfer_fsck_objects = git_config_bool(var, value);
  91                 return 0;
  92         }
  93
  94         if (!strcmp(var, "receive.denycurrentbranch")) {
  95                 if (value && !strcasecmp(value, "updateinstead"))
  96                         deny_current_branch = DENY_UPDATE_INSTEAD;
  97                 else if (value && !strcasecmp(value, "detachinstead"))
  98                         deny_current_branch = DENY_DETACH_INSTEAD;
  99                 else
 100                         deny_current_branch = parse_deny_action(var, value);
 101                 return 0;
 102         }
 103
 104         if (strcmp(var, "receive.denydeletecurrent") == 0) {
 105                 deny_delete_current = parse_deny_action(var, value);
 106                 return 0;
 107         }
 108
 109         if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
 110                 prefer_ofs_delta = git_config_bool(var, value);
 111                 return 0;
 112         }
 113
 114         if (strcmp(var, "receive.updateserverinfo") == 0) {
 115                 auto_update_server_info = git_config_bool(var, value);
 116                 return 0;
 117         }
 118
 119         if (strcmp(var, "receive.autogc") == 0) {
 120                 auto_gc = git_config_bool(var, value);
 121                 return 0;
 122         }
 123
 124         return git_default_config(var, value, cb);
 125 }
 126
 127 static void show_ref(const char *path, const unsigned char *sha1)
 128 {
 129         if (sent_capabilities)
 130                 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
 131         else
 132                 packet_write(1, "%s %s%c%s%s agent=%s\n",
 133                              sha1_to_hex(sha1), path, 0,
 134                              " report-status delete-refs side-band-64k quiet",
 135                              prefer_ofs_delta ? " ofs-delta" : "",
 136                              git_user_agent_sanitized());
 137         sent_capabilities = 1;
 138 }
 139
 140 static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
 141 {
 142         path = strip_namespace(path);
 143         /*
 144          * Advertise refs outside our current namespace as ".have"
 145          * refs, so that the client can use them to minimize data
 146          * transfer but will otherwise ignore them. This happens to
 147          * cover ".have" that are thrown in by add_one_alternate_ref()
 148          * to mark histories that are complete in our alternates as
 149          * well.
 150          */
 151         if (!path)
 152                 path = ".have";
 153         show_ref(path, sha1);
 154         return 0;
 155 }
 156
 157 static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
 158 {
 159         show_ref(".have", sha1);
 160 }
 161
 162 static void collect_one_alternate_ref(const struct ref *ref, void *data)
 163 {
 164         struct sha1_array *sa = data;
 165         sha1_array_append(sa, ref->old_sha1);
 166 }
 167
 168 static void write_head_info(void)
 169 {
 170         struct sha1_array sa = SHA1_ARRAY_INIT;
 171         for_each_alternate_ref(collect_one_alternate_ref, &sa);
 172         sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
 173         sha1_array_clear(&sa);
 174         for_each_ref(show_ref_cb, NULL);
 175         if (!sent_capabilities)
 176                 show_ref("capabilities^{}", null_sha1);
 177
 178         /* EOF */
 179         packet_flush(1);
 180 }
 181
 182 struct command {
 183         struct command *next;
 184         const char *error_string;
 185         unsigned int skip_update:1,
 186                      did_not_exist:1;
 187         unsigned char old_sha1[20];
 188         unsigned char new_sha1[20];
 189         char ref_name[FLEX_ARRAY]; /* more */
 190 };
 191
 192 static const char pre_receive_hook[] = "hooks/pre-receive";
 193 static const char post_receive_hook[] = "hooks/post-receive";
 194
 195 static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
 196 static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
 197
 198 static void report_message(const char *prefix, const char *err, va_list params)
 199 {
 200         int sz = strlen(prefix);
 201         char msg[4096];
 202
 203         strncpy(msg, prefix, sz);
 204         sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
 205         if (sz > (sizeof(msg) - 1))
 206                 sz = sizeof(msg) - 1;
 207         msg[sz++] = '\n';
 208
 209         if (use_sideband)
 210                 send_sideband(1, 2, msg, sz, use_sideband);
 211         else
 212                 xwrite(2, msg, sz);
 213 }
 214
 215 static void rp_warning(const char *err, ...)
 216 {
 217         va_list params;
 218         va_start(params, err);
 219         report_message("warning: ", err, params);
 220         va_end(params);
 221 }
 222
 223 static void rp_error(const char *err, ...)
 224 {
 225         va_list params;
 226         va_start(params, err);
 227         report_message("error: ", err, params);
 228         va_end(params);
 229 }
 230
 231 static int copy_to_sideband(int in, int out, void *arg)
 232 {
 233         char data[128];
 234         while (1) {
 235                 ssize_t sz = xread(in, data, sizeof(data));
 236                 if (sz <= 0)
 237                         break;
 238                 send_sideband(1, 2, data, sz, use_sideband);
 239         }
 240         close(in);
 241         return 0;
 242 }
 243
 244 typedef int (*feed_fn)(void *, const char **, size_t *);
 245 static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
 246 {
 247         struct child_process proc;
 248         struct async muxer;
 249         const char *argv[2];
 250         int code;
 251
 252         if (access(hook_name, X_OK) < 0)
 253                 return 0;
 254
 255         argv[0] = hook_name;
 256         argv[1] = NULL;
 257
 258         memset(&proc, 0, sizeof(proc));
 259         proc.argv = argv;
 260         proc.in = -1;
 261         proc.stdout_to_stderr = 1;
 262
 263         if (use_sideband) {
 264                 memset(&muxer, 0, sizeof(muxer));
 265                 muxer.proc = copy_to_sideband;
 266                 muxer.in = -1;
 267                 code = start_async(&muxer);
 268                 if (code)
 269                         return code;
 270                 proc.err = muxer.in;
 271         }
 272
 273         code = start_command(&proc);
 274         if (code) {
 275                 if (use_sideband)
 276                         finish_async(&muxer);
 277                 return code;
 278         }
 279
 280         while (1) {
 281                 const char *buf;
 282                 size_t n;
 283                 if (feed(feed_state, &buf, &n))
 284                         break;
 285                 if (write_in_full(proc.in, buf, n) != n)
 286                         break;
 287         }
 288         close(proc.in);
 289         if (use_sideband)
 290                 finish_async(&muxer);
 291         return finish_command(&proc);
 292 }
 293
 294 struct receive_hook_feed_state {
 295         struct command *cmd;
 296         int skip_broken;
 297         struct strbuf buf;
 298 };
 299
 300 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
 301 {
 302         struct receive_hook_feed_state *state = state_;
 303         struct command *cmd = state->cmd;
 304
 305         while (cmd &&
 306                state->skip_broken && (cmd->error_string || cmd->did_not_exist))
 307                 cmd = cmd->next;
 308         if (!cmd)
 309                 return -1; /* EOF */
 310         strbuf_reset(&state->buf);
 311         strbuf_addf(&state->buf, "%s %s %s\n",
 312                     sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
 313                     cmd->ref_name);
 314         state->cmd = cmd->next;
 315         if (bufp) {
 316                 *bufp = state->buf.buf;
 317                 *sizep = state->buf.len;
 318         }
 319         return 0;
 320 }
 321
 322 static int run_receive_hook(struct command *commands, const char *hook_name,
 323                             int skip_broken)
 324 {
 325         struct receive_hook_feed_state state;
 326         int status;
 327
 328         strbuf_init(&state.buf, 0);
 329         state.cmd = commands;
 330         state.skip_broken = skip_broken;
 331         if (feed_receive_hook(&state, NULL, NULL))
 332                 return 0;
 333         state.cmd = commands;
 334         status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
 335         strbuf_release(&state.buf);
 336         return status;
 337 }
 338
 339 static int run_update_hook(struct command *cmd)
 340 {
 341         static const char update_hook[] = "hooks/update";
 342         const char *argv[5];
 343         struct child_process proc;
 344         int code;
 345
 346         if (access(update_hook, X_OK) < 0)
 347                 return 0;
 348
 349         argv[0] = update_hook;
 350         argv[1] = cmd->ref_name;
 351         argv[2] = sha1_to_hex(cmd->old_sha1);
 352         argv[3] = sha1_to_hex(cmd->new_sha1);
 353         argv[4] = NULL;
 354
 355         memset(&proc, 0, sizeof(proc));
 356         proc.no_stdin = 1;
 357         proc.stdout_to_stderr = 1;
 358         proc.err = use_sideband ? -1 : 0;
 359         proc.argv = argv;
 360
 361         code = start_command(&proc);
 362         if (code)
 363                 return code;
 364         if (use_sideband)
 365                 copy_to_sideband(proc.err, -1, NULL);
 366         return finish_command(&proc);
 367 }
 368
 369 static int is_ref_checked_out(const char *ref)
 370 {
 371         if (is_bare_repository())
 372                 return 0;
 373
 374         if (!head_name)
 375                 return 0;
 376         return !strcmp(head_name, ref);
 377 }
 378
 379 static char *refuse_unconfigured_deny_msg[] = {
 380         "By default, updating the current branch in a non-bare repository",
 381         "is denied, because it will make the index and work tree inconsistent",
 382         "with what you pushed, and will require 'git reset --hard' to match",
 383         "the work tree to HEAD.",
 384         "",
 385         "You can set 'receive.denyCurrentBranch' configuration variable to",
 386         "'ignore' or 'warn' in the remote repository to allow pushing into",
 387         "its current branch; however, this is not recommended unless you",
 388         "arranged to update its work tree to match what you pushed in some",
 389         "other way.",
 390         "",
 391         "To squelch this message and still keep the default behaviour, set",
 392         "'receive.denyCurrentBranch' configuration variable to 'refuse'."
 393 };
 394
 395 static void refuse_unconfigured_deny(void)
 396 {
 397         int i;
 398         for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
 399                 rp_error("%s", refuse_unconfigured_deny_msg[i]);
 400 }
 401
 402 static char *refuse_unconfigured_deny_delete_current_msg[] = {
 403         "By default, deleting the current branch is denied, because the next",
 404         "'git clone' won't result in any file checked out, causing confusion.",
 405         "",
 406         "You can set 'receive.denyDeleteCurrent' configuration variable to",
 407         "'warn' or 'ignore' in the remote repository to allow deleting the",
 408         "current branch, with or without a warning message.",
 409         "",
 410         "To squelch this message, you can set it to 'refuse'."
 411 };
 412
 413 static void refuse_unconfigured_deny_delete_current(void)
 414 {
 415         int i;
 416         for (i = 0;
 417              i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
 418              i++)
 419                 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
 420 }
 421
 422 static void merge_worktree(unsigned char *sha1)
 423 {
 424         const char *update_refresh[] = {
 425                 "update-index", "--ignore-submodules", "--refresh", NULL
 426         };
 427         const char *read_tree[] = {
 428                 "read-tree", "-u", "-m", sha1_to_hex(sha1), NULL
 429         };
 430         struct child_process child;
 431         struct strbuf git_env = STRBUF_INIT;
 432         const char *env[2];
 433
 434         if (is_bare_repository())
 435                 die ("denyCurrentBranch = updateInstead needs a worktree");
 436
 437         strbuf_addf(&git_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
 438         env[0] = git_env.buf;
 439         env[1] = NULL;
 440
 441         memset(&child, 0, sizeof(child));
 442         child.argv = update_refresh;
 443         child.env = env;
 444         child.dir = git_work_tree_cfg ? git_work_tree_cfg : "..";
 445         child.stdout_to_stderr = 1;
 446         child.git_cmd = 1;
 447         if (run_command(&child))
 448                 die ("Could not refresh the index");
 449
 450         child.argv = read_tree;
 451         child.no_stdin = 1;
 452         child.no_stdout = 1;
 453         child.stdout_to_stderr = 0;
 454         if (run_command(&child))
 455                 die ("Could not merge working tree with new HEAD.  Good luck.");
 456
 457         strbuf_release(&git_env);
 458 }
 459
 460 static const char *update(struct command *cmd)
 461 {
 462         const char *name = cmd->ref_name;
 463         struct strbuf namespaced_name_buf = STRBUF_INIT;
 464         const char *namespaced_name;
 465         unsigned char *old_sha1 = cmd->old_sha1;
 466         unsigned char *new_sha1 = cmd->new_sha1;
 467         struct ref_lock *lock;
 468
 469         /* only refs/... are allowed */
 470         if (prefixcmp(name, "refs/") || check_refname_format(name + 5, 0)) {
 471                 rp_error("refusing to create funny ref '%s' remotely", name);
 472                 return "funny refname";
 473         }
 474
 475         strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
 476         namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
 477
 478         if (is_ref_checked_out(namespaced_name)) {
 479                 switch (deny_current_branch) {
 480                 case DENY_IGNORE:
 481                         break;
 482                 case DENY_WARN:
 483                         rp_warning("updating the current branch");
 484                         break;
 485                 case DENY_REFUSE:
 486                 case DENY_UNCONFIGURED:
 487                         rp_error("refusing to update checked out branch: %s", name);
 488                         if (deny_current_branch == DENY_UNCONFIGURED)
 489                                 refuse_unconfigured_deny();
 490                         return "branch is currently checked out";
 491                 case DENY_UPDATE_INSTEAD:
 492                         merge_worktree(new_sha1);
 493                         break;
 494                 case DENY_DETACH_INSTEAD:
 495                         update_ref("push into current branch (detach)", "HEAD",
 496                                 old_sha1, NULL, REF_NODEREF, DIE_ON_ERR);
 497                         break;
 498                 }
 499         }
 500
 501         if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
 502                 error("unpack should have generated %s, "
 503                       "but I can't find it!", sha1_to_hex(new_sha1));
 504                 return "bad pack";
 505         }
 506
 507         if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
 508                 if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
 509                         rp_error("denying ref deletion for %s", name);
 510                         return "deletion prohibited";
 511                 }
 512
 513                 if (!strcmp(namespaced_name, head_name)) {
 514                         switch (deny_delete_current) {
 515                         case DENY_IGNORE:
 516                                 break;
 517                         case DENY_WARN:
 518                                 rp_warning("deleting the current branch");
 519                                 break;
 520                         case DENY_REFUSE:
 521                         case DENY_UNCONFIGURED:
 522                                 if (deny_delete_current == DENY_UNCONFIGURED)
 523                                         refuse_unconfigured_deny_delete_current();
 524                                 rp_error("refusing to delete the current branch: %s", name);
 525                                 return "deletion of the current branch prohibited";
 526                         default:
 527                                 die ("Invalid denyDeleteCurrent setting");
 528                         }
 529                 }
 530         }
 531
 532         if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
 533             !is_null_sha1(old_sha1) &&
 534             !prefixcmp(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                 lock = lock_any_ref_for_update(namespaced_name, old_sha1, 0);
 578                 if (!lock) {
 579                         rp_error("failed to lock %s", name);
 580                         return "failed to lock";
 581                 }
 582                 if (write_ref_sha1(lock, new_sha1, "push")) {
 583                         return "failed to write"; /* error() already called */
 584                 }
 585                 return NULL; /* good */
 586         }
 587 }
 588
 589 static char update_post_hook[] = "hooks/post-update";
 590
 591 static void run_update_post_hook(struct command *commands)
 592 {
 593         struct command *cmd;
 594         int argc;
 595         const char **argv;
 596         struct child_process proc;
 597
 598         for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
 599                 if (cmd->error_string || cmd->did_not_exist)
 600                         continue;
 601                 argc++;
 602         }
 603         if (!argc || access(update_post_hook, X_OK) < 0)
 604                 return;
 605         argv = xmalloc(sizeof(*argv) * (2 + argc));
 606         argv[0] = update_post_hook;
 607
 608         for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
 609                 char *p;
 610                 if (cmd->error_string || cmd->did_not_exist)
 611                         continue;
 612                 p = xmalloc(strlen(cmd->ref_name) + 1);
 613                 strcpy(p, cmd->ref_name);
 614                 argv[argc] = p;
 615                 argc++;
 616         }
 617         argv[argc] = NULL;
 618
 619         memset(&proc, 0, sizeof(proc));
 620         proc.no_stdin = 1;
 621         proc.stdout_to_stderr = 1;
 622         proc.err = use_sideband ? -1 : 0;
 623         proc.argv = argv;
 624
 625         if (!start_command(&proc)) {
 626                 if (use_sideband)
 627                         copy_to_sideband(proc.err, -1, NULL);
 628                 finish_command(&proc);
 629         }
 630 }
 631
 632 static void check_aliased_update(struct command *cmd, struct string_list *list)
 633 {
 634         struct strbuf buf = STRBUF_INIT;
 635         const char *dst_name;
 636         struct string_list_item *item;
 637         struct command *dst_cmd;
 638         unsigned char sha1[20];
 639         char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
 640         int flag;
 641
 642         strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
 643         dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
 644         strbuf_release(&buf);
 645
 646         if (!(flag & REF_ISSYMREF))
 647                 return;
 648
 649         dst_name = strip_namespace(dst_name);
 650         if (!dst_name) {
 651                 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
 652                 cmd->skip_update = 1;
 653                 cmd->error_string = "broken symref";
 654                 return;
 655         }
 656
 657         if ((item = string_list_lookup(list, dst_name)) == NULL)
 658                 return;
 659
 660         cmd->skip_update = 1;
 661
 662         dst_cmd = (struct command *) item->util;
 663
 664         if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
 665             !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
 666                 return;
 667
 668         dst_cmd->skip_update = 1;
 669
 670         strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
 671         strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
 672         strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
 673         strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
 674         rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
 675                  " its target '%s' (%s..%s)",
 676                  cmd->ref_name, cmd_oldh, cmd_newh,
 677                  dst_cmd->ref_name, dst_oldh, dst_newh);
 678
 679         cmd->error_string = dst_cmd->error_string =
 680                 "inconsistent aliased update";
 681 }
 682
 683 static void check_aliased_updates(struct command *commands)
 684 {
 685         struct command *cmd;
 686         struct string_list ref_list = STRING_LIST_INIT_NODUP;
 687
 688         for (cmd = commands; cmd; cmd = cmd->next) {
 689                 struct string_list_item *item =
 690                         string_list_append(&ref_list, cmd->ref_name);
 691                 item->util = (void *)cmd;
 692         }
 693         sort_string_list(&ref_list);
 694
 695         for (cmd = commands; cmd; cmd = cmd->next) {
 696                 if (!cmd->error_string)
 697                         check_aliased_update(cmd, &ref_list);
 698         }
 699
 700         string_list_clear(&ref_list, 0);
 701 }
 702
 703 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
 704 {
 705         struct command **cmd_list = cb_data;
 706         struct command *cmd = *cmd_list;
 707
 708         if (!cmd || is_null_sha1(cmd->new_sha1))
 709                 return -1; /* end of list */
 710         *cmd_list = NULL; /* this returns only one */
 711         hashcpy(sha1, cmd->new_sha1);
 712         return 0;
 713 }
 714
 715 static void set_connectivity_errors(struct command *commands)
 716 {
 717         struct command *cmd;
 718
 719         for (cmd = commands; cmd; cmd = cmd->next) {
 720                 struct command *singleton = cmd;
 721                 if (!check_everything_connected(command_singleton_iterator,
 722                                                 0, &singleton))
 723                         continue;
 724                 cmd->error_string = "missing necessary objects";
 725         }
 726 }
 727
 728 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
 729 {
 730         struct command **cmd_list = cb_data;
 731         struct command *cmd = *cmd_list;
 732
 733         while (cmd) {
 734                 if (!is_null_sha1(cmd->new_sha1)) {
 735                         hashcpy(sha1, cmd->new_sha1);
 736                         *cmd_list = cmd->next;
 737                         return 0;
 738                 }
 739                 cmd = cmd->next;
 740         }
 741         *cmd_list = NULL;
 742         return -1; /* end of list */
 743 }
 744
 745 static void execute_commands(struct command *commands, const char *unpacker_error)
 746 {
 747         struct command *cmd;
 748         unsigned char sha1[20];
 749
 750         if (unpacker_error) {
 751                 for (cmd = commands; cmd; cmd = cmd->next)
 752                         cmd->error_string = "unpacker error";
 753                 return;
 754         }
 755
 756         cmd = commands;
 757         if (check_everything_connected(iterate_receive_command_list,
 758                                        0, &cmd))
 759                 set_connectivity_errors(commands);
 760
 761         if (run_receive_hook(commands, pre_receive_hook, 0)) {
 762                 for (cmd = commands; cmd; cmd = cmd->next) {
 763                         if (!cmd->error_string)
 764                                 cmd->error_string = "pre-receive hook declined";
 765                 }
 766                 return;
 767         }
 768
 769         check_aliased_updates(commands);
 770
 771         free(head_name_to_free);
 772         head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
 773
 774         for (cmd = commands; cmd; cmd = cmd->next) {
 775                 if (cmd->error_string)
 776                         continue;
 777
 778                 if (cmd->skip_update)
 779                         continue;
 780
 781                 cmd->error_string = update(cmd);
 782         }
 783 }
 784
 785 static struct command *read_head_info(void)
 786 {
 787         struct command *commands = NULL;
 788         struct command **p = &commands;
 789         for (;;) {
 790                 static char line[1000];
 791                 unsigned char old_sha1[20], new_sha1[20];
 792                 struct command *cmd;
 793                 char *refname;
 794                 int len, reflen;
 795
 796                 len = packet_read_line(0, line, sizeof(line));
 797                 if (!len)
 798                         break;
 799                 if (line[len-1] == '\n')
 800                         line[--len] = 0;
 801                 if (len < 83 ||
 802                     line[40] != ' ' ||
 803                     line[81] != ' ' ||
 804                     get_sha1_hex(line, old_sha1) ||
 805                     get_sha1_hex(line + 41, new_sha1))
 806                         die("protocol error: expected old/new/ref, got '%s'",
 807                             line);
 808
 809                 refname = line + 82;
 810                 reflen = strlen(refname);
 811                 if (reflen + 82 < len) {
 812                         const char *feature_list = refname + reflen + 1;
 813                         if (parse_feature_request(feature_list, "report-status"))
 814                                 report_status = 1;
 815                         if (parse_feature_request(feature_list, "side-band-64k"))
 816                                 use_sideband = LARGE_PACKET_MAX;
 817                         if (parse_feature_request(feature_list, "quiet"))
 818                                 quiet = 1;
 819                 }
 820                 cmd = xcalloc(1, sizeof(struct command) + len - 80);
 821                 hashcpy(cmd->old_sha1, old_sha1);
 822                 hashcpy(cmd->new_sha1, new_sha1);
 823                 memcpy(cmd->ref_name, line + 82, len - 81);
 824                 *p = cmd;
 825                 p = &cmd->next;
 826         }
 827         return commands;
 828 }
 829
 830 static const char *parse_pack_header(struct pack_header *hdr)
 831 {
 832         switch (read_pack_header(0, hdr)) {
 833         case PH_ERROR_EOF:
 834                 return "eof before pack header was fully read";
 835
 836         case PH_ERROR_PACK_SIGNATURE:
 837                 return "protocol error (pack signature mismatch detected)";
 838
 839         case PH_ERROR_PROTOCOL:
 840                 return "protocol error (pack version unsupported)";
 841
 842         default:
 843                 return "unknown error in parse_pack_header";
 844
 845         case 0:
 846                 return NULL;
 847         }
 848 }
 849
 850 static const char *pack_lockfile;
 851
 852 static const char *unpack(int err_fd)
 853 {
 854         struct pack_header hdr;
 855         const char *hdr_err;
 856         char hdr_arg[38];
 857         int fsck_objects = (receive_fsck_objects >= 0
 858                             ? receive_fsck_objects
 859                             : transfer_fsck_objects >= 0
 860                             ? transfer_fsck_objects
 861                             : 0);
 862
 863         hdr_err = parse_pack_header(&hdr);
 864         if (hdr_err)
 865                 return hdr_err;
 866         snprintf(hdr_arg, sizeof(hdr_arg),
 867                         "--pack_header=%"PRIu32",%"PRIu32,
 868                         ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
 869
 870         if (ntohl(hdr.hdr_entries) < unpack_limit) {
 871                 int code, i = 0;
 872                 struct child_process child;
 873                 const char *unpacker[5];
 874                 unpacker[i++] = "unpack-objects";
 875                 if (quiet)
 876                         unpacker[i++] = "-q";
 877                 if (fsck_objects)
 878                         unpacker[i++] = "--strict";
 879                 unpacker[i++] = hdr_arg;
 880                 unpacker[i++] = NULL;
 881                 memset(&child, 0, sizeof(child));
 882                 child.argv = unpacker;
 883                 child.no_stdout = 1;
 884                 child.err = err_fd;
 885                 child.git_cmd = 1;
 886                 code = run_command(&child);
 887                 if (!code)
 888                         return NULL;
 889                 return "unpack-objects abnormal exit";
 890         } else {
 891                 const char *keeper[7];
 892                 int s, status, i = 0;
 893                 char keep_arg[256];
 894                 struct child_process ip;
 895
 896                 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
 897                 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 898                         strcpy(keep_arg + s, "localhost");
 899
 900                 keeper[i++] = "index-pack";
 901                 keeper[i++] = "--stdin";
 902                 if (fsck_objects)
 903                         keeper[i++] = "--strict";
 904                 keeper[i++] = "--fix-thin";
 905                 keeper[i++] = hdr_arg;
 906                 keeper[i++] = keep_arg;
 907                 keeper[i++] = NULL;
 908                 memset(&ip, 0, sizeof(ip));
 909                 ip.argv = keeper;
 910                 ip.out = -1;
 911                 ip.err = err_fd;
 912                 ip.git_cmd = 1;
 913                 status = start_command(&ip);
 914                 if (status) {
 915                         return "index-pack fork failed";
 916                 }
 917                 pack_lockfile = index_pack_lockfile(ip.out);
 918                 close(ip.out);
 919                 status = finish_command(&ip);
 920                 if (!status) {
 921                         reprepare_packed_git();
 922                         return NULL;
 923                 }
 924                 return "index-pack abnormal exit";
 925         }
 926 }
 927
 928 static const char *unpack_with_sideband(void)
 929 {
 930         struct async muxer;
 931         const char *ret;
 932
 933         if (!use_sideband)
 934                 return unpack(0);
 935
 936         memset(&muxer, 0, sizeof(muxer));
 937         muxer.proc = copy_to_sideband;
 938         muxer.in = -1;
 939         if (start_async(&muxer))
 940                 return NULL;
 941
 942         ret = unpack(muxer.in);
 943
 944         finish_async(&muxer);
 945         return ret;
 946 }
 947
 948 static void report(struct command *commands, const char *unpack_status)
 949 {
 950         struct command *cmd;
 951         struct strbuf buf = STRBUF_INIT;
 952
 953         packet_buf_write(&buf, "unpack %s\n",
 954                          unpack_status ? unpack_status : "ok");
 955         for (cmd = commands; cmd; cmd = cmd->next) {
 956                 if (!cmd->error_string)
 957                         packet_buf_write(&buf, "ok %s\n",
 958                                          cmd->ref_name);
 959                 else
 960                         packet_buf_write(&buf, "ng %s %s\n",
 961                                          cmd->ref_name, cmd->error_string);
 962         }
 963         packet_buf_flush(&buf);
 964
 965         if (use_sideband)
 966                 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
 967         else
 968                 safe_write(1, buf.buf, buf.len);
 969         strbuf_release(&buf);
 970 }
 971
 972 static int delete_only(struct command *commands)
 973 {
 974         struct command *cmd;
 975         for (cmd = commands; cmd; cmd = cmd->next) {
 976                 if (!is_null_sha1(cmd->new_sha1))
 977                         return 0;
 978         }
 979         return 1;
 980 }
 981
 982 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
 983 {
 984         int advertise_refs = 0;
 985         int stateless_rpc = 0;
 986         int i;
 987         char *dir = NULL;
 988         struct command *commands;
 989
 990         packet_trace_identity("receive-pack");
 991
 992         argv++;
 993         for (i = 1; i < argc; i++) {
 994                 const char *arg = *argv++;
 995
 996                 if (*arg == '-') {
 997                         if (!strcmp(arg, "--quiet")) {
 998                                 quiet = 1;
 999                                 continue;
1000                         }
1001
1002                         if (!strcmp(arg, "--advertise-refs")) {
1003                                 advertise_refs = 1;
1004                                 continue;
1005                         }
1006                         if (!strcmp(arg, "--stateless-rpc")) {
1007                                 stateless_rpc = 1;
1008                                 continue;
1009                         }
1010
1011                         usage(receive_pack_usage);
1012                 }
1013                 if (dir)
1014                         usage(receive_pack_usage);
1015                 dir = xstrdup(arg);
1016         }
1017         if (!dir)
1018                 usage(receive_pack_usage);
1019
1020         setup_path();
1021
1022         if (!enter_repo(dir, 0))
1023                 die("'%s' does not appear to be a git repository", dir);
1024
1025         if (is_repository_shallow())
1026                 die("attempt to push into a shallow repository");
1027
1028         git_config(receive_pack_config, NULL);
1029
1030         if (0 <= transfer_unpack_limit)
1031                 unpack_limit = transfer_unpack_limit;
1032         else if (0 <= receive_unpack_limit)
1033                 unpack_limit = receive_unpack_limit;
1034
1035         if (advertise_refs || !stateless_rpc) {
1036                 write_head_info();
1037         }
1038         if (advertise_refs)
1039                 return 0;
1040
1041         if ((commands = read_head_info()) != NULL) {
1042                 const char *unpack_status = NULL;
1043
1044                 if (!delete_only(commands))
1045                         unpack_status = unpack_with_sideband();
1046                 execute_commands(commands, unpack_status);
1047                 if (pack_lockfile)
1048                         unlink_or_warn(pack_lockfile);
1049                 if (report_status)
1050                         report(commands, unpack_status);
1051                 run_receive_hook(commands, post_receive_hook, 1);
1052                 run_update_post_hook(commands);
1053                 if (auto_gc) {
1054                         const char *argv_gc_auto[] = {
1055                                 "gc", "--auto", "--quiet", NULL,
1056                         };
1057                         int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1058                         run_command_v_opt(argv_gc_auto, opt);
1059                 }
1060                 if (auto_update_server_info)
1061                         update_server_info(0);
1062         }
1063         if (use_sideband)
1064                 packet_flush(1);
1065         return 0;
1066 }