git.oblomov.eu Git - git/blob - 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 "version.h"
  17
  18 static const char receive_pack_usage[] = "git receive-pack <git-dir>";
  19
  20 enum deny_action {
  21         DENY_UNCONFIGURED,
  22         DENY_IGNORE,
  23         DENY_WARN,
  24         DENY_REFUSE
  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 int fix_thin = 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         int status = parse_hide_refs_config(var, value, "receive");
  65
  66         if (status)
  67                 return status;
  68
  69         if (strcmp(var, "receive.denydeletes") == 0) {
  70                 deny_deletes = git_config_bool(var, value);
  71                 return 0;
  72         }
  73
  74         if (strcmp(var, "receive.denynonfastforwards") == 0) {
  75                 deny_non_fast_forwards = git_config_bool(var, value);
  76                 return 0;
  77         }
  78
  79         if (strcmp(var, "receive.unpacklimit") == 0) {
  80                 receive_unpack_limit = git_config_int(var, value);
  81                 return 0;
  82         }
  83
  84         if (strcmp(var, "transfer.unpacklimit") == 0) {
  85                 transfer_unpack_limit = git_config_int(var, value);
  86                 return 0;
  87         }
  88
  89         if (strcmp(var, "receive.fsckobjects") == 0) {
  90                 receive_fsck_objects = git_config_bool(var, value);
  91                 return 0;
  92         }
  93
  94         if (strcmp(var, "transfer.fsckobjects") == 0) {
  95                 transfer_fsck_objects = git_config_bool(var, value);
  96                 return 0;
  97         }
  98
  99         if (!strcmp(var, "receive.denycurrentbranch")) {
 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 (ref_is_hidden(path))
 130                 return;
 131
 132         if (sent_capabilities)
 133                 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
 134         else
 135                 packet_write(1, "%s %s%c%s%s agent=%s\n",
 136                              sha1_to_hex(sha1), path, 0,
 137                              " report-status delete-refs side-band-64k quiet",
 138                              prefer_ofs_delta ? " ofs-delta" : "",
 139                              git_user_agent_sanitized());
 140         sent_capabilities = 1;
 141 }
 142
 143 static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
 144 {
 145         path = strip_namespace(path);
 146         /*
 147          * Advertise refs outside our current namespace as ".have"
 148          * refs, so that the client can use them to minimize data
 149          * transfer but will otherwise ignore them. This happens to
 150          * cover ".have" that are thrown in by add_one_alternate_ref()
 151          * to mark histories that are complete in our alternates as
 152          * well.
 153          */
 154         if (!path)
 155                 path = ".have";
 156         show_ref(path, sha1);
 157         return 0;
 158 }
 159
 160 static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
 161 {
 162         show_ref(".have", sha1);
 163 }
 164
 165 static void collect_one_alternate_ref(const struct ref *ref, void *data)
 166 {
 167         struct sha1_array *sa = data;
 168         sha1_array_append(sa, ref->old_sha1);
 169 }
 170
 171 static void write_head_info(void)
 172 {
 173         struct sha1_array sa = SHA1_ARRAY_INIT;
 174         for_each_alternate_ref(collect_one_alternate_ref, &sa);
 175         sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
 176         sha1_array_clear(&sa);
 177         for_each_ref(show_ref_cb, NULL);
 178         if (!sent_capabilities)
 179                 show_ref("capabilities^{}", null_sha1);
 180
 181         /* EOF */
 182         packet_flush(1);
 183 }
 184
 185 struct command {
 186         struct command *next;
 187         const char *error_string;
 188         unsigned int skip_update:1,
 189                      did_not_exist:1;
 190         unsigned char old_sha1[20];
 191         unsigned char new_sha1[20];
 192         char ref_name[FLEX_ARRAY]; /* more */
 193 };
 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         argv[0] = find_hook(hook_name);
 253         if (!argv[0])
 254                 return 0;
 255
 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         const char *argv[5];
 342         struct child_process proc;
 343         int code;
 344
 345         argv[0] = find_hook("update");
 346         if (!argv[0])
 347                 return 0;
 348
 349         argv[1] = cmd->ref_name;
 350         argv[2] = sha1_to_hex(cmd->old_sha1);
 351         argv[3] = sha1_to_hex(cmd->new_sha1);
 352         argv[4] = NULL;
 353
 354         memset(&proc, 0, sizeof(proc));
 355         proc.no_stdin = 1;
 356         proc.stdout_to_stderr = 1;
 357         proc.err = use_sideband ? -1 : 0;
 358         proc.argv = argv;
 359
 360         code = start_command(&proc);
 361         if (code)
 362                 return code;
 363         if (use_sideband)
 364                 copy_to_sideband(proc.err, -1, NULL);
 365         return finish_command(&proc);
 366 }
 367
 368 static int is_ref_checked_out(const char *ref)
 369 {
 370         if (is_bare_repository())
 371                 return 0;
 372
 373         if (!head_name)
 374                 return 0;
 375         return !strcmp(head_name, ref);
 376 }
 377
 378 static char *refuse_unconfigured_deny_msg[] = {
 379         "By default, updating the current branch in a non-bare repository",
 380         "is denied, because it will make the index and work tree inconsistent",
 381         "with what you pushed, and will require 'git reset --hard' to match",
 382         "the work tree to HEAD.",
 383         "",
 384         "You can set 'receive.denyCurrentBranch' configuration variable to",
 385         "'ignore' or 'warn' in the remote repository to allow pushing into",
 386         "its current branch; however, this is not recommended unless you",
 387         "arranged to update its work tree to match what you pushed in some",
 388         "other way.",
 389         "",
 390         "To squelch this message and still keep the default behaviour, set",
 391         "'receive.denyCurrentBranch' configuration variable to 'refuse'."
 392 };
 393
 394 static void refuse_unconfigured_deny(void)
 395 {
 396         int i;
 397         for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
 398                 rp_error("%s", refuse_unconfigured_deny_msg[i]);
 399 }
 400
 401 static char *refuse_unconfigured_deny_delete_current_msg[] = {
 402         "By default, deleting the current branch is denied, because the next",
 403         "'git clone' won't result in any file checked out, causing confusion.",
 404         "",
 405         "You can set 'receive.denyDeleteCurrent' configuration variable to",
 406         "'warn' or 'ignore' in the remote repository to allow deleting the",
 407         "current branch, with or without a warning message.",
 408         "",
 409         "To squelch this message, you can set it to 'refuse'."
 410 };
 411
 412 static void refuse_unconfigured_deny_delete_current(void)
 413 {
 414         int i;
 415         for (i = 0;
 416              i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
 417              i++)
 418                 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
 419 }
 420
 421 static const char *update(struct command *cmd)
 422 {
 423         const char *name = cmd->ref_name;
 424         struct strbuf namespaced_name_buf = STRBUF_INIT;
 425         const char *namespaced_name;
 426         unsigned char *old_sha1 = cmd->old_sha1;
 427         unsigned char *new_sha1 = cmd->new_sha1;
 428         struct ref_lock *lock;
 429
 430         /* only refs/... are allowed */
 431         if (!starts_with(name, "refs/") || check_refname_format(name + 5, 0)) {
 432                 rp_error("refusing to create funny ref '%s' remotely", name);
 433                 return "funny refname";
 434         }
 435
 436         strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
 437         namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
 438
 439         if (is_ref_checked_out(namespaced_name)) {
 440                 switch (deny_current_branch) {
 441                 case DENY_IGNORE:
 442                         break;
 443                 case DENY_WARN:
 444                         rp_warning("updating the current branch");
 445                         break;
 446                 case DENY_REFUSE:
 447                 case DENY_UNCONFIGURED:
 448                         rp_error("refusing to update checked out branch: %s", name);
 449                         if (deny_current_branch == DENY_UNCONFIGURED)
 450                                 refuse_unconfigured_deny();
 451                         return "branch is currently checked out";
 452                 }
 453         }
 454
 455         if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
 456                 error("unpack should have generated %s, "
 457                       "but I can't find it!", sha1_to_hex(new_sha1));
 458                 return "bad pack";
 459         }
 460
 461         if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
 462                 if (deny_deletes && starts_with(name, "refs/heads/")) {
 463                         rp_error("denying ref deletion for %s", name);
 464                         return "deletion prohibited";
 465                 }
 466
 467                 if (!strcmp(namespaced_name, head_name)) {
 468                         switch (deny_delete_current) {
 469                         case DENY_IGNORE:
 470                                 break;
 471                         case DENY_WARN:
 472                                 rp_warning("deleting the current branch");
 473                                 break;
 474                         case DENY_REFUSE:
 475                         case DENY_UNCONFIGURED:
 476                                 if (deny_delete_current == DENY_UNCONFIGURED)
 477                                         refuse_unconfigured_deny_delete_current();
 478                                 rp_error("refusing to delete the current branch: %s", name);
 479                                 return "deletion of the current branch prohibited";
 480                         }
 481                 }
 482         }
 483
 484         if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
 485             !is_null_sha1(old_sha1) &&
 486             starts_with(name, "refs/heads/")) {
 487                 struct object *old_object, *new_object;
 488                 struct commit *old_commit, *new_commit;
 489
 490                 old_object = parse_object(old_sha1);
 491                 new_object = parse_object(new_sha1);
 492
 493                 if (!old_object || !new_object ||
 494                     old_object->type != OBJ_COMMIT ||
 495                     new_object->type != OBJ_COMMIT) {
 496                         error("bad sha1 objects for %s", name);
 497                         return "bad ref";
 498                 }
 499                 old_commit = (struct commit *)old_object;
 500                 new_commit = (struct commit *)new_object;
 501                 if (!in_merge_bases(old_commit, new_commit)) {
 502                         rp_error("denying non-fast-forward %s"
 503                                  " (you should pull first)", name);
 504                         return "non-fast-forward";
 505                 }
 506         }
 507         if (run_update_hook(cmd)) {
 508                 rp_error("hook declined to update %s", name);
 509                 return "hook declined";
 510         }
 511
 512         if (is_null_sha1(new_sha1)) {
 513                 if (!parse_object(old_sha1)) {
 514                         old_sha1 = NULL;
 515                         if (ref_exists(name)) {
 516                                 rp_warning("Allowing deletion of corrupt ref.");
 517                         } else {
 518                                 rp_warning("Deleting a non-existent ref.");
 519                                 cmd->did_not_exist = 1;
 520                         }
 521                 }
 522                 if (delete_ref(namespaced_name, old_sha1, 0)) {
 523                         rp_error("failed to delete %s", name);
 524                         return "failed to delete";
 525                 }
 526                 return NULL; /* good */
 527         }
 528         else {
 529                 lock = lock_any_ref_for_update(namespaced_name, old_sha1,
 530                                                0, NULL);
 531                 if (!lock) {
 532                         rp_error("failed to lock %s", name);
 533                         return "failed to lock";
 534                 }
 535                 if (write_ref_sha1(lock, new_sha1, "push")) {
 536                         return "failed to write"; /* error() already called */
 537                 }
 538                 return NULL; /* good */
 539         }
 540 }
 541
 542 static void run_update_post_hook(struct command *commands)
 543 {
 544         struct command *cmd;
 545         int argc;
 546         const char **argv;
 547         struct child_process proc;
 548         char *hook;
 549
 550         hook = find_hook("post-update");
 551         for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
 552                 if (cmd->error_string || cmd->did_not_exist)
 553                         continue;
 554                 argc++;
 555         }
 556         if (!argc || !hook)
 557                 return;
 558
 559         argv = xmalloc(sizeof(*argv) * (2 + argc));
 560         argv[0] = hook;
 561
 562         for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
 563                 char *p;
 564                 if (cmd->error_string || cmd->did_not_exist)
 565                         continue;
 566                 p = xmalloc(strlen(cmd->ref_name) + 1);
 567                 strcpy(p, cmd->ref_name);
 568                 argv[argc] = p;
 569                 argc++;
 570         }
 571         argv[argc] = NULL;
 572
 573         memset(&proc, 0, sizeof(proc));
 574         proc.no_stdin = 1;
 575         proc.stdout_to_stderr = 1;
 576         proc.err = use_sideband ? -1 : 0;
 577         proc.argv = argv;
 578
 579         if (!start_command(&proc)) {
 580                 if (use_sideband)
 581                         copy_to_sideband(proc.err, -1, NULL);
 582                 finish_command(&proc);
 583         }
 584 }
 585
 586 static void check_aliased_update(struct command *cmd, struct string_list *list)
 587 {
 588         struct strbuf buf = STRBUF_INIT;
 589         const char *dst_name;
 590         struct string_list_item *item;
 591         struct command *dst_cmd;
 592         unsigned char sha1[20];
 593         char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
 594         int flag;
 595
 596         strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
 597         dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
 598         strbuf_release(&buf);
 599
 600         if (!(flag & REF_ISSYMREF))
 601                 return;
 602
 603         dst_name = strip_namespace(dst_name);
 604         if (!dst_name) {
 605                 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
 606                 cmd->skip_update = 1;
 607                 cmd->error_string = "broken symref";
 608                 return;
 609         }
 610
 611         if ((item = string_list_lookup(list, dst_name)) == NULL)
 612                 return;
 613
 614         cmd->skip_update = 1;
 615
 616         dst_cmd = (struct command *) item->util;
 617
 618         if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
 619             !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
 620                 return;
 621
 622         dst_cmd->skip_update = 1;
 623
 624         strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
 625         strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
 626         strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
 627         strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
 628         rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
 629                  " its target '%s' (%s..%s)",
 630                  cmd->ref_name, cmd_oldh, cmd_newh,
 631                  dst_cmd->ref_name, dst_oldh, dst_newh);
 632
 633         cmd->error_string = dst_cmd->error_string =
 634                 "inconsistent aliased update";
 635 }
 636
 637 static void check_aliased_updates(struct command *commands)
 638 {
 639         struct command *cmd;
 640         struct string_list ref_list = STRING_LIST_INIT_NODUP;
 641
 642         for (cmd = commands; cmd; cmd = cmd->next) {
 643                 struct string_list_item *item =
 644                         string_list_append(&ref_list, cmd->ref_name);
 645                 item->util = (void *)cmd;
 646         }
 647         sort_string_list(&ref_list);
 648
 649         for (cmd = commands; cmd; cmd = cmd->next) {
 650                 if (!cmd->error_string)
 651                         check_aliased_update(cmd, &ref_list);
 652         }
 653
 654         string_list_clear(&ref_list, 0);
 655 }
 656
 657 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
 658 {
 659         struct command **cmd_list = cb_data;
 660         struct command *cmd = *cmd_list;
 661
 662         if (!cmd || is_null_sha1(cmd->new_sha1))
 663                 return -1; /* end of list */
 664         *cmd_list = NULL; /* this returns only one */
 665         hashcpy(sha1, cmd->new_sha1);
 666         return 0;
 667 }
 668
 669 static void set_connectivity_errors(struct command *commands)
 670 {
 671         struct command *cmd;
 672
 673         for (cmd = commands; cmd; cmd = cmd->next) {
 674                 struct command *singleton = cmd;
 675                 if (!check_everything_connected(command_singleton_iterator,
 676                                                 0, &singleton))
 677                         continue;
 678                 cmd->error_string = "missing necessary objects";
 679         }
 680 }
 681
 682 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
 683 {
 684         struct command **cmd_list = cb_data;
 685         struct command *cmd = *cmd_list;
 686
 687         while (cmd) {
 688                 if (!is_null_sha1(cmd->new_sha1)) {
 689                         hashcpy(sha1, cmd->new_sha1);
 690                         *cmd_list = cmd->next;
 691                         return 0;
 692                 }
 693                 cmd = cmd->next;
 694         }
 695         *cmd_list = NULL;
 696         return -1; /* end of list */
 697 }
 698
 699 static void reject_updates_to_hidden(struct command *commands)
 700 {
 701         struct command *cmd;
 702
 703         for (cmd = commands; cmd; cmd = cmd->next) {
 704                 if (cmd->error_string || !ref_is_hidden(cmd->ref_name))
 705                         continue;
 706                 if (is_null_sha1(cmd->new_sha1))
 707                         cmd->error_string = "deny deleting a hidden ref";
 708                 else
 709                         cmd->error_string = "deny updating a hidden ref";
 710         }
 711 }
 712
 713 static void execute_commands(struct command *commands, const char *unpacker_error)
 714 {
 715         struct command *cmd;
 716         unsigned char sha1[20];
 717
 718         if (unpacker_error) {
 719                 for (cmd = commands; cmd; cmd = cmd->next)
 720                         cmd->error_string = "unpacker error";
 721                 return;
 722         }
 723
 724         cmd = commands;
 725         if (check_everything_connected(iterate_receive_command_list,
 726                                        0, &cmd))
 727                 set_connectivity_errors(commands);
 728
 729         reject_updates_to_hidden(commands);
 730
 731         if (run_receive_hook(commands, "pre-receive", 0)) {
 732                 for (cmd = commands; cmd; cmd = cmd->next) {
 733                         if (!cmd->error_string)
 734                                 cmd->error_string = "pre-receive hook declined";
 735                 }
 736                 return;
 737         }
 738
 739         check_aliased_updates(commands);
 740
 741         free(head_name_to_free);
 742         head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
 743
 744         for (cmd = commands; cmd; cmd = cmd->next) {
 745                 if (cmd->error_string)
 746                         continue;
 747
 748                 if (cmd->skip_update)
 749                         continue;
 750
 751                 cmd->error_string = update(cmd);
 752         }
 753 }
 754
 755 static struct command *read_head_info(void)
 756 {
 757         struct command *commands = NULL;
 758         struct command **p = &commands;
 759         for (;;) {
 760                 char *line;
 761                 unsigned char old_sha1[20], new_sha1[20];
 762                 struct command *cmd;
 763                 char *refname;
 764                 int len, reflen;
 765
 766                 line = packet_read_line(0, &len);
 767                 if (!line)
 768                         break;
 769                 if (len < 83 ||
 770                     line[40] != ' ' ||
 771                     line[81] != ' ' ||
 772                     get_sha1_hex(line, old_sha1) ||
 773                     get_sha1_hex(line + 41, new_sha1))
 774                         die("protocol error: expected old/new/ref, got '%s'",
 775                             line);
 776
 777                 refname = line + 82;
 778                 reflen = strlen(refname);
 779                 if (reflen + 82 < len) {
 780                         const char *feature_list = refname + reflen + 1;
 781                         if (parse_feature_request(feature_list, "report-status"))
 782                                 report_status = 1;
 783                         if (parse_feature_request(feature_list, "side-band-64k"))
 784                                 use_sideband = LARGE_PACKET_MAX;
 785                         if (parse_feature_request(feature_list, "quiet"))
 786                                 quiet = 1;
 787                 }
 788                 cmd = xcalloc(1, sizeof(struct command) + len - 80);
 789                 hashcpy(cmd->old_sha1, old_sha1);
 790                 hashcpy(cmd->new_sha1, new_sha1);
 791                 memcpy(cmd->ref_name, line + 82, len - 81);
 792                 *p = cmd;
 793                 p = &cmd->next;
 794         }
 795         return commands;
 796 }
 797
 798 static const char *parse_pack_header(struct pack_header *hdr)
 799 {
 800         switch (read_pack_header(0, hdr)) {
 801         case PH_ERROR_EOF:
 802                 return "eof before pack header was fully read";
 803
 804         case PH_ERROR_PACK_SIGNATURE:
 805                 return "protocol error (pack signature mismatch detected)";
 806
 807         case PH_ERROR_PROTOCOL:
 808                 return "protocol error (pack version unsupported)";
 809
 810         default:
 811                 return "unknown error in parse_pack_header";
 812
 813         case 0:
 814                 return NULL;
 815         }
 816 }
 817
 818 static const char *pack_lockfile;
 819
 820 static const char *unpack(int err_fd)
 821 {
 822         struct pack_header hdr;
 823         const char *hdr_err;
 824         char hdr_arg[38];
 825         int fsck_objects = (receive_fsck_objects >= 0
 826                             ? receive_fsck_objects
 827                             : transfer_fsck_objects >= 0
 828                             ? transfer_fsck_objects
 829                             : 0);
 830
 831         hdr_err = parse_pack_header(&hdr);
 832         if (hdr_err) {
 833                 if (err_fd > 0)
 834                         close(err_fd);
 835                 return hdr_err;
 836         }
 837         snprintf(hdr_arg, sizeof(hdr_arg),
 838                         "--pack_header=%"PRIu32",%"PRIu32,
 839                         ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
 840
 841         if (ntohl(hdr.hdr_entries) < unpack_limit) {
 842                 int code, i = 0;
 843                 struct child_process child;
 844                 const char *unpacker[5];
 845                 unpacker[i++] = "unpack-objects";
 846                 if (quiet)
 847                         unpacker[i++] = "-q";
 848                 if (fsck_objects)
 849                         unpacker[i++] = "--strict";
 850                 unpacker[i++] = hdr_arg;
 851                 unpacker[i++] = NULL;
 852                 memset(&child, 0, sizeof(child));
 853                 child.argv = unpacker;
 854                 child.no_stdout = 1;
 855                 child.err = err_fd;
 856                 child.git_cmd = 1;
 857                 code = run_command(&child);
 858                 if (!code)
 859                         return NULL;
 860                 return "unpack-objects abnormal exit";
 861         } else {
 862                 const char *keeper[7];
 863                 int s, status, i = 0;
 864                 char keep_arg[256];
 865                 struct child_process ip;
 866
 867                 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
 868                 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 869                         strcpy(keep_arg + s, "localhost");
 870
 871                 keeper[i++] = "index-pack";
 872                 keeper[i++] = "--stdin";
 873                 if (fsck_objects)
 874                         keeper[i++] = "--strict";
 875                 if (fix_thin)
 876                         keeper[i++] = "--fix-thin";
 877                 keeper[i++] = hdr_arg;
 878                 keeper[i++] = keep_arg;
 879                 keeper[i++] = NULL;
 880                 memset(&ip, 0, sizeof(ip));
 881                 ip.argv = keeper;
 882                 ip.out = -1;
 883                 ip.err = err_fd;
 884                 ip.git_cmd = 1;
 885                 status = start_command(&ip);
 886                 if (status) {
 887                         return "index-pack fork failed";
 888                 }
 889                 pack_lockfile = index_pack_lockfile(ip.out);
 890                 close(ip.out);
 891                 status = finish_command(&ip);
 892                 if (!status) {
 893                         reprepare_packed_git();
 894                         return NULL;
 895                 }
 896                 return "index-pack abnormal exit";
 897         }
 898 }
 899
 900 static const char *unpack_with_sideband(void)
 901 {
 902         struct async muxer;
 903         const char *ret;
 904
 905         if (!use_sideband)
 906                 return unpack(0);
 907
 908         memset(&muxer, 0, sizeof(muxer));
 909         muxer.proc = copy_to_sideband;
 910         muxer.in = -1;
 911         if (start_async(&muxer))
 912                 return NULL;
 913
 914         ret = unpack(muxer.in);
 915
 916         finish_async(&muxer);
 917         return ret;
 918 }
 919
 920 static void report(struct command *commands, const char *unpack_status)
 921 {
 922         struct command *cmd;
 923         struct strbuf buf = STRBUF_INIT;
 924
 925         packet_buf_write(&buf, "unpack %s\n",
 926                          unpack_status ? unpack_status : "ok");
 927         for (cmd = commands; cmd; cmd = cmd->next) {
 928                 if (!cmd->error_string)
 929                         packet_buf_write(&buf, "ok %s\n",
 930                                          cmd->ref_name);
 931                 else
 932                         packet_buf_write(&buf, "ng %s %s\n",
 933                                          cmd->ref_name, cmd->error_string);
 934         }
 935         packet_buf_flush(&buf);
 936
 937         if (use_sideband)
 938                 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
 939         else
 940                 write_or_die(1, buf.buf, buf.len);
 941         strbuf_release(&buf);
 942 }
 943
 944 static int delete_only(struct command *commands)
 945 {
 946         struct command *cmd;
 947         for (cmd = commands; cmd; cmd = cmd->next) {
 948                 if (!is_null_sha1(cmd->new_sha1))
 949                         return 0;
 950         }
 951         return 1;
 952 }
 953
 954 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
 955 {
 956         int advertise_refs = 0;
 957         int stateless_rpc = 0;
 958         int i;
 959         char *dir = NULL;
 960         struct command *commands;
 961
 962         packet_trace_identity("receive-pack");
 963
 964         argv++;
 965         for (i = 1; i < argc; i++) {
 966                 const char *arg = *argv++;
 967
 968                 if (*arg == '-') {
 969                         if (!strcmp(arg, "--quiet")) {
 970                                 quiet = 1;
 971                                 continue;
 972                         }
 973
 974                         if (!strcmp(arg, "--advertise-refs")) {
 975                                 advertise_refs = 1;
 976                                 continue;
 977                         }
 978                         if (!strcmp(arg, "--stateless-rpc")) {
 979                                 stateless_rpc = 1;
 980                                 continue;
 981                         }
 982                         if (!strcmp(arg, "--reject-thin-pack-for-testing")) {
 983                                 fix_thin = 0;
 984                                 continue;
 985                         }
 986
 987                         usage(receive_pack_usage);
 988                 }
 989                 if (dir)
 990                         usage(receive_pack_usage);
 991                 dir = xstrdup(arg);
 992         }
 993         if (!dir)
 994                 usage(receive_pack_usage);
 995
 996         setup_path();
 997
 998         if (!enter_repo(dir, 0))
 999                 die("'%s' does not appear to be a git repository", dir);
1000
1001         if (is_repository_shallow())
1002                 die("attempt to push into a shallow repository");
1003
1004         git_config(receive_pack_config, NULL);
1005
1006         if (0 <= transfer_unpack_limit)
1007                 unpack_limit = transfer_unpack_limit;
1008         else if (0 <= receive_unpack_limit)
1009                 unpack_limit = receive_unpack_limit;
1010
1011         if (advertise_refs || !stateless_rpc) {
1012                 write_head_info();
1013         }
1014         if (advertise_refs)
1015                 return 0;
1016
1017         if ((commands = read_head_info()) != NULL) {
1018                 const char *unpack_status = NULL;
1019
1020                 if (!delete_only(commands))
1021                         unpack_status = unpack_with_sideband();
1022                 execute_commands(commands, unpack_status);
1023                 if (pack_lockfile)
1024                         unlink_or_warn(pack_lockfile);
1025                 if (report_status)
1026                         report(commands, unpack_status);
1027                 run_receive_hook(commands, "post-receive", 1);
1028                 run_update_post_hook(commands);
1029                 if (auto_gc) {
1030                         const char *argv_gc_auto[] = {
1031                                 "gc", "--auto", "--quiet", NULL,
1032                         };
1033                         int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1034                         run_command_v_opt(argv_gc_auto, opt);
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 }