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