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