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