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 (prefixcmp(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 && !prefixcmp(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             !prefixcmp(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, 0);
 530                 if (!lock) {
 531                         rp_error("failed to lock %s", name);
 532                         return "failed to lock";
 533                 }
 534                 if (write_ref_sha1(lock, new_sha1, "push")) {
 535                         return "failed to write"; /* error() already called */
 536                 }
 537                 return NULL; /* good */
 538         }
 539 }
 540
 541 static void run_update_post_hook(struct command *commands)
 542 {
 543         struct command *cmd;
 544         int argc;
 545         const char **argv;
 546         struct child_process proc;
 547         char *hook;
 548
 549         hook = find_hook("post-update");
 550         for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
 551                 if (cmd->error_string || cmd->did_not_exist)
 552                         continue;
 553                 argc++;
 554         }
 555         if (!argc || !hook)
 556                 return;
 557
 558         argv = xmalloc(sizeof(*argv) * (2 + argc));
 559         argv[0] = hook;
 560
 561         for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
 562                 char *p;
 563                 if (cmd->error_string || cmd->did_not_exist)
 564                         continue;
 565                 p = xmalloc(strlen(cmd->ref_name) + 1);
 566                 strcpy(p, cmd->ref_name);
 567                 argv[argc] = p;
 568                 argc++;
 569         }
 570         argv[argc] = NULL;
 571
 572         memset(&proc, 0, sizeof(proc));
 573         proc.no_stdin = 1;
 574         proc.stdout_to_stderr = 1;
 575         proc.err = use_sideband ? -1 : 0;
 576         proc.argv = argv;
 577
 578         if (!start_command(&proc)) {
 579                 if (use_sideband)
 580                         copy_to_sideband(proc.err, -1, NULL);
 581                 finish_command(&proc);
 582         }
 583 }
 584
 585 static void check_aliased_update(struct command *cmd, struct string_list *list)
 586 {
 587         struct strbuf buf = STRBUF_INIT;
 588         const char *dst_name;
 589         struct string_list_item *item;
 590         struct command *dst_cmd;
 591         unsigned char sha1[20];
 592         char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
 593         int flag;
 594
 595         strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
 596         dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
 597         strbuf_release(&buf);
 598
 599         if (!(flag & REF_ISSYMREF))
 600                 return;
 601
 602         dst_name = strip_namespace(dst_name);
 603         if (!dst_name) {
 604                 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
 605                 cmd->skip_update = 1;
 606                 cmd->error_string = "broken symref";
 607                 return;
 608         }
 609
 610         if ((item = string_list_lookup(list, dst_name)) == NULL)
 611                 return;
 612
 613         cmd->skip_update = 1;
 614
 615         dst_cmd = (struct command *) item->util;
 616
 617         if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
 618             !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
 619                 return;
 620
 621         dst_cmd->skip_update = 1;
 622
 623         strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
 624         strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
 625         strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
 626         strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
 627         rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
 628                  " its target '%s' (%s..%s)",
 629                  cmd->ref_name, cmd_oldh, cmd_newh,
 630                  dst_cmd->ref_name, dst_oldh, dst_newh);
 631
 632         cmd->error_string = dst_cmd->error_string =
 633                 "inconsistent aliased update";
 634 }
 635
 636 static void check_aliased_updates(struct command *commands)
 637 {
 638         struct command *cmd;
 639         struct string_list ref_list = STRING_LIST_INIT_NODUP;
 640
 641         for (cmd = commands; cmd; cmd = cmd->next) {
 642                 struct string_list_item *item =
 643                         string_list_append(&ref_list, cmd->ref_name);
 644                 item->util = (void *)cmd;
 645         }
 646         sort_string_list(&ref_list);
 647
 648         for (cmd = commands; cmd; cmd = cmd->next) {
 649                 if (!cmd->error_string)
 650                         check_aliased_update(cmd, &ref_list);
 651         }
 652
 653         string_list_clear(&ref_list, 0);
 654 }
 655
 656 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
 657 {
 658         struct command **cmd_list = cb_data;
 659         struct command *cmd = *cmd_list;
 660
 661         if (!cmd || is_null_sha1(cmd->new_sha1))
 662                 return -1; /* end of list */
 663         *cmd_list = NULL; /* this returns only one */
 664         hashcpy(sha1, cmd->new_sha1);
 665         return 0;
 666 }
 667
 668 static void set_connectivity_errors(struct command *commands)
 669 {
 670         struct command *cmd;
 671
 672         for (cmd = commands; cmd; cmd = cmd->next) {
 673                 struct command *singleton = cmd;
 674                 if (!check_everything_connected(command_singleton_iterator,
 675                                                 0, &singleton))
 676                         continue;
 677                 cmd->error_string = "missing necessary objects";
 678         }
 679 }
 680
 681 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
 682 {
 683         struct command **cmd_list = cb_data;
 684         struct command *cmd = *cmd_list;
 685
 686         while (cmd) {
 687                 if (!is_null_sha1(cmd->new_sha1)) {
 688                         hashcpy(sha1, cmd->new_sha1);
 689                         *cmd_list = cmd->next;
 690                         return 0;
 691                 }
 692                 cmd = cmd->next;
 693         }
 694         *cmd_list = NULL;
 695         return -1; /* end of list */
 696 }
 697
 698 static void reject_updates_to_hidden(struct command *commands)
 699 {
 700         struct command *cmd;
 701
 702         for (cmd = commands; cmd; cmd = cmd->next) {
 703                 if (cmd->error_string || !ref_is_hidden(cmd->ref_name))
 704                         continue;
 705                 if (is_null_sha1(cmd->new_sha1))
 706                         cmd->error_string = "deny deleting a hidden ref";
 707                 else
 708                         cmd->error_string = "deny updating a hidden ref";
 709         }
 710 }
 711
 712 static void execute_commands(struct command *commands, const char *unpacker_error)
 713 {
 714         struct command *cmd;
 715         unsigned char sha1[20];
 716
 717         if (unpacker_error) {
 718                 for (cmd = commands; cmd; cmd = cmd->next)
 719                         cmd->error_string = "unpacker error";
 720                 return;
 721         }
 722
 723         cmd = commands;
 724         if (check_everything_connected(iterate_receive_command_list,
 725                                        0, &cmd))
 726                 set_connectivity_errors(commands);
 727
 728         reject_updates_to_hidden(commands);
 729
 730         if (run_receive_hook(commands, "pre-receive", 0)) {
 731                 for (cmd = commands; cmd; cmd = cmd->next) {
 732                         if (!cmd->error_string)
 733                                 cmd->error_string = "pre-receive hook declined";
 734                 }
 735                 return;
 736         }
 737
 738         check_aliased_updates(commands);
 739
 740         free(head_name_to_free);
 741         head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
 742
 743         for (cmd = commands; cmd; cmd = cmd->next) {
 744                 if (cmd->error_string)
 745                         continue;
 746
 747                 if (cmd->skip_update)
 748                         continue;
 749
 750                 cmd->error_string = update(cmd);
 751         }
 752 }
 753
 754 static struct command *read_head_info(void)
 755 {
 756         struct command *commands = NULL;
 757         struct command **p = &commands;
 758         for (;;) {
 759                 char *line;
 760                 unsigned char old_sha1[20], new_sha1[20];
 761                 struct command *cmd;
 762                 char *refname;
 763                 int len, reflen;
 764
 765                 line = packet_read_line(0, &len);
 766                 if (!line)
 767                         break;
 768                 if (len < 83 ||
 769                     line[40] != ' ' ||
 770                     line[81] != ' ' ||
 771                     get_sha1_hex(line, old_sha1) ||
 772                     get_sha1_hex(line + 41, new_sha1))
 773                         die("protocol error: expected old/new/ref, got '%s'",
 774                             line);
 775
 776                 refname = line + 82;
 777                 reflen = strlen(refname);
 778                 if (reflen + 82 < len) {
 779                         const char *feature_list = refname + reflen + 1;
 780                         if (parse_feature_request(feature_list, "report-status"))
 781                                 report_status = 1;
 782                         if (parse_feature_request(feature_list, "side-band-64k"))
 783                                 use_sideband = LARGE_PACKET_MAX;
 784                         if (parse_feature_request(feature_list, "quiet"))
 785                                 quiet = 1;
 786                 }
 787                 cmd = xcalloc(1, sizeof(struct command) + len - 80);
 788                 hashcpy(cmd->old_sha1, old_sha1);
 789                 hashcpy(cmd->new_sha1, new_sha1);
 790                 memcpy(cmd->ref_name, line + 82, len - 81);
 791                 *p = cmd;
 792                 p = &cmd->next;
 793         }
 794         return commands;
 795 }
 796
 797 static const char *parse_pack_header(struct pack_header *hdr)
 798 {
 799         switch (read_pack_header(0, hdr)) {
 800         case PH_ERROR_EOF:
 801                 return "eof before pack header was fully read";
 802
 803         case PH_ERROR_PACK_SIGNATURE:
 804                 return "protocol error (pack signature mismatch detected)";
 805
 806         case PH_ERROR_PROTOCOL:
 807                 return "protocol error (pack version unsupported)";
 808
 809         default:
 810                 return "unknown error in parse_pack_header";
 811
 812         case 0:
 813                 return NULL;
 814         }
 815 }
 816
 817 static const char *pack_lockfile;
 818
 819 static const char *unpack(int err_fd)
 820 {
 821         struct pack_header hdr;
 822         const char *hdr_err;
 823         char hdr_arg[38];
 824         int fsck_objects = (receive_fsck_objects >= 0
 825                             ? receive_fsck_objects
 826                             : transfer_fsck_objects >= 0
 827                             ? transfer_fsck_objects
 828                             : 0);
 829
 830         hdr_err = parse_pack_header(&hdr);
 831         if (hdr_err) {
 832                 if (err_fd > 0)
 833                         close(err_fd);
 834                 return hdr_err;
 835         }
 836         snprintf(hdr_arg, sizeof(hdr_arg),
 837                         "--pack_header=%"PRIu32",%"PRIu32,
 838                         ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
 839
 840         if (ntohl(hdr.hdr_entries) < unpack_limit) {
 841                 int code, i = 0;
 842                 struct child_process child;
 843                 const char *unpacker[5];
 844                 unpacker[i++] = "unpack-objects";
 845                 if (quiet)
 846                         unpacker[i++] = "-q";
 847                 if (fsck_objects)
 848                         unpacker[i++] = "--strict";
 849                 unpacker[i++] = hdr_arg;
 850                 unpacker[i++] = NULL;
 851                 memset(&child, 0, sizeof(child));
 852                 child.argv = unpacker;
 853                 child.no_stdout = 1;
 854                 child.err = err_fd;
 855                 child.git_cmd = 1;
 856                 code = run_command(&child);
 857                 if (!code)
 858                         return NULL;
 859                 return "unpack-objects abnormal exit";
 860         } else {
 861                 const char *keeper[7];
 862                 int s, status, i = 0;
 863                 char keep_arg[256];
 864                 struct child_process ip;
 865
 866                 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
 867                 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 868                         strcpy(keep_arg + s, "localhost");
 869
 870                 keeper[i++] = "index-pack";
 871                 keeper[i++] = "--stdin";
 872                 if (fsck_objects)
 873                         keeper[i++] = "--strict";
 874                 if (fix_thin)
 875                         keeper[i++] = "--fix-thin";
 876                 keeper[i++] = hdr_arg;
 877                 keeper[i++] = keep_arg;
 878                 keeper[i++] = NULL;
 879                 memset(&ip, 0, sizeof(ip));
 880                 ip.argv = keeper;
 881                 ip.out = -1;
 882                 ip.err = err_fd;
 883                 ip.git_cmd = 1;
 884                 status = start_command(&ip);
 885                 if (status) {
 886                         return "index-pack fork failed";
 887                 }
 888                 pack_lockfile = index_pack_lockfile(ip.out);
 889                 close(ip.out);
 890                 status = finish_command(&ip);
 891                 if (!status) {
 892                         reprepare_packed_git();
 893                         return NULL;
 894                 }
 895                 return "index-pack abnormal exit";
 896         }
 897 }
 898
 899 static const char *unpack_with_sideband(void)
 900 {
 901         struct async muxer;
 902         const char *ret;
 903
 904         if (!use_sideband)
 905                 return unpack(0);
 906
 907         memset(&muxer, 0, sizeof(muxer));
 908         muxer.proc = copy_to_sideband;
 909         muxer.in = -1;
 910         if (start_async(&muxer))
 911                 return NULL;
 912
 913         ret = unpack(muxer.in);
 914
 915         finish_async(&muxer);
 916         return ret;
 917 }
 918
 919 static void report(struct command *commands, const char *unpack_status)
 920 {
 921         struct command *cmd;
 922         struct strbuf buf = STRBUF_INIT;
 923
 924         packet_buf_write(&buf, "unpack %s\n",
 925                          unpack_status ? unpack_status : "ok");
 926         for (cmd = commands; cmd; cmd = cmd->next) {
 927                 if (!cmd->error_string)
 928                         packet_buf_write(&buf, "ok %s\n",
 929                                          cmd->ref_name);
 930                 else
 931                         packet_buf_write(&buf, "ng %s %s\n",
 932                                          cmd->ref_name, cmd->error_string);
 933         }
 934         packet_buf_flush(&buf);
 935
 936         if (use_sideband)
 937                 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
 938         else
 939                 write_or_die(1, buf.buf, buf.len);
 940         strbuf_release(&buf);
 941 }
 942
 943 static int delete_only(struct command *commands)
 944 {
 945         struct command *cmd;
 946         for (cmd = commands; cmd; cmd = cmd->next) {
 947                 if (!is_null_sha1(cmd->new_sha1))
 948                         return 0;
 949         }
 950         return 1;
 951 }
 952
 953 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
 954 {
 955         int advertise_refs = 0;
 956         int stateless_rpc = 0;
 957         int i;
 958         char *dir = NULL;
 959         struct command *commands;
 960
 961         packet_trace_identity("receive-pack");
 962
 963         argv++;
 964         for (i = 1; i < argc; i++) {
 965                 const char *arg = *argv++;
 966
 967                 if (*arg == '-') {
 968                         if (!strcmp(arg, "--quiet")) {
 969                                 quiet = 1;
 970                                 continue;
 971                         }
 972
 973                         if (!strcmp(arg, "--advertise-refs")) {
 974                                 advertise_refs = 1;
 975                                 continue;
 976                         }
 977                         if (!strcmp(arg, "--stateless-rpc")) {
 978                                 stateless_rpc = 1;
 979                                 continue;
 980                         }
 981                         if (!strcmp(arg, "--reject-thin-pack-for-testing")) {
 982                                 fix_thin = 0;
 983                                 continue;
 984                         }
 985
 986                         usage(receive_pack_usage);
 987                 }
 988                 if (dir)
 989                         usage(receive_pack_usage);
 990                 dir = xstrdup(arg);
 991         }
 992         if (!dir)
 993                 usage(receive_pack_usage);
 994
 995         setup_path();
 996
 997         if (!enter_repo(dir, 0))
 998                 die("'%s' does not appear to be a git repository", dir);
 999
1000         if (is_repository_shallow())
1001                 die("attempt to push into a shallow repository");
1002
1003         git_config(receive_pack_config, NULL);
1004
1005         if (0 <= transfer_unpack_limit)
1006                 unpack_limit = transfer_unpack_limit;
1007         else if (0 <= receive_unpack_limit)
1008                 unpack_limit = receive_unpack_limit;
1009
1010         if (advertise_refs || !stateless_rpc) {
1011                 write_head_info();
1012         }
1013         if (advertise_refs)
1014                 return 0;
1015
1016         if ((commands = read_head_info()) != NULL) {
1017                 const char *unpack_status = NULL;
1018
1019                 if (!delete_only(commands))
1020                         unpack_status = unpack_with_sideband();
1021                 execute_commands(commands, unpack_status);
1022                 if (pack_lockfile)
1023                         unlink_or_warn(pack_lockfile);
1024                 if (report_status)
1025                         report(commands, unpack_status);
1026                 run_receive_hook(commands, "post-receive", 1);
1027                 run_update_post_hook(commands);
1028                 if (auto_gc) {
1029                         const char *argv_gc_auto[] = {
1030                                 "gc", "--auto", "--quiet", NULL,
1031                         };
1032                         int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1033                         run_command_v_opt(argv_gc_auto, opt);
1034                 }
1035                 if (auto_update_server_info)
1036                         update_server_info(0);
1037         }
1038         if (use_sideband)
1039                 packet_flush(1);
1040         return 0;
1041 }