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 int fix_thin = 1;
  42 static const char *head_name;
  43 static void *head_name_to_free;
  44 static int sent_capabilities;
  45
  46 static enum deny_action parse_deny_action(const char *var, const char *value)
  47 {
  48         if (value) {
  49                 if (!strcasecmp(value, "ignore"))
  50                         return DENY_IGNORE;
  51                 if (!strcasecmp(value, "warn"))
  52                         return DENY_WARN;
  53                 if (!strcasecmp(value, "refuse"))
  54                         return DENY_REFUSE;
  55         }
  56         if (git_config_bool(var, value))
  57                 return DENY_REFUSE;
  58         return DENY_IGNORE;
  59 }
  60
  61 static int receive_pack_config(const char *var, const char *value, void *cb)
  62 {
  63         int status = parse_hide_refs_config(var, value, "receive");
  64
  65         if (status)
  66                 return status;
  67
  68         if (strcmp(var, "receive.denydeletes") == 0) {
  69                 deny_deletes = git_config_bool(var, value);
  70                 return 0;
  71         }
  72
  73         if (strcmp(var, "receive.denynonfastforwards") == 0) {
  74                 deny_non_fast_forwards = git_config_bool(var, value);
  75                 return 0;
  76         }
  77
  78         if (strcmp(var, "receive.unpacklimit") == 0) {
  79                 receive_unpack_limit = git_config_int(var, value);
  80                 return 0;
  81         }
  82
  83         if (strcmp(var, "transfer.unpacklimit") == 0) {
  84                 transfer_unpack_limit = git_config_int(var, value);
  85                 return 0;
  86         }
  87
  88         if (strcmp(var, "receive.fsckobjects") == 0) {
  89                 receive_fsck_objects = git_config_bool(var, value);
  90                 return 0;
  91         }
  92
  93         if (strcmp(var, "transfer.fsckobjects") == 0) {
  94                 transfer_fsck_objects = git_config_bool(var, value);
  95                 return 0;
  96         }
  97
  98         if (!strcmp(var, "receive.denycurrentbranch")) {
  99                 deny_current_branch = parse_deny_action(var, value);
 100                 return 0;
 101         }
 102
 103         if (strcmp(var, "receive.denydeletecurrent") == 0) {
 104                 deny_delete_current = parse_deny_action(var, value);
 105                 return 0;
 106         }
 107
 108         if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
 109                 prefer_ofs_delta = git_config_bool(var, value);
 110                 return 0;
 111         }
 112
 113         if (strcmp(var, "receive.updateserverinfo") == 0) {
 114                 auto_update_server_info = git_config_bool(var, value);
 115                 return 0;
 116         }
 117
 118         if (strcmp(var, "receive.autogc") == 0) {
 119                 auto_gc = git_config_bool(var, value);
 120                 return 0;
 121         }
 122
 123         return git_default_config(var, value, cb);
 124 }
 125
 126 static void show_ref(const char *path, const unsigned char *sha1)
 127 {
 128         if (ref_is_hidden(path))
 129                 return;
 130
 131         if (sent_capabilities)
 132                 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
 133         else
 134                 packet_write(1, "%s %s%c%s%s agent=%s\n",
 135                              sha1_to_hex(sha1), path, 0,
 136                              " report-status delete-refs side-band-64k quiet",
 137                              prefer_ofs_delta ? " ofs-delta" : "",
 138                              git_user_agent_sanitized());
 139         sent_capabilities = 1;
 140 }
 141
 142 static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
 143 {
 144         path = strip_namespace(path);
 145         /*
 146          * Advertise refs outside our current namespace as ".have"
 147          * refs, so that the client can use them to minimize data
 148          * transfer but will otherwise ignore them. This happens to
 149          * cover ".have" that are thrown in by add_one_alternate_ref()
 150          * to mark histories that are complete in our alternates as
 151          * well.
 152          */
 153         if (!path)
 154                 path = ".have";
 155         show_ref(path, sha1);
 156         return 0;
 157 }
 158
 159 static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
 160 {
 161         show_ref(".have", sha1);
 162 }
 163
 164 static void collect_one_alternate_ref(const struct ref *ref, void *data)
 165 {
 166         struct sha1_array *sa = data;
 167         sha1_array_append(sa, ref->old_sha1);
 168 }
 169
 170 static void write_head_info(void)
 171 {
 172         struct sha1_array sa = SHA1_ARRAY_INIT;
 173         for_each_alternate_ref(collect_one_alternate_ref, &sa);
 174         sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
 175         sha1_array_clear(&sa);
 176         for_each_ref(show_ref_cb, NULL);
 177         if (!sent_capabilities)
 178                 show_ref("capabilities^{}", null_sha1);
 179
 180         /* EOF */
 181         packet_flush(1);
 182 }
 183
 184 struct command {
 185         struct command *next;
 186         const char *error_string;
 187         unsigned int skip_update:1,
 188                      did_not_exist:1;
 189         unsigned char old_sha1[20];
 190         unsigned char new_sha1[20];
 191         char ref_name[FLEX_ARRAY]; /* more */
 192 };
 193
 194 static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
 195 static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
 196
 197 static void report_message(const char *prefix, const char *err, va_list params)
 198 {
 199         int sz = strlen(prefix);
 200         char msg[4096];
 201
 202         strncpy(msg, prefix, sz);
 203         sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
 204         if (sz > (sizeof(msg) - 1))
 205                 sz = sizeof(msg) - 1;
 206         msg[sz++] = '\n';
 207
 208         if (use_sideband)
 209                 send_sideband(1, 2, msg, sz, use_sideband);
 210         else
 211                 xwrite(2, msg, sz);
 212 }
 213
 214 static void rp_warning(const char *err, ...)
 215 {
 216         va_list params;
 217         va_start(params, err);
 218         report_message("warning: ", err, params);
 219         va_end(params);
 220 }
 221
 222 static void rp_error(const char *err, ...)
 223 {
 224         va_list params;
 225         va_start(params, err);
 226         report_message("error: ", err, params);
 227         va_end(params);
 228 }
 229
 230 static int copy_to_sideband(int in, int out, void *arg)
 231 {
 232         char data[128];
 233         while (1) {
 234                 ssize_t sz = xread(in, data, sizeof(data));
 235                 if (sz <= 0)
 236                         break;
 237                 send_sideband(1, 2, data, sz, use_sideband);
 238         }
 239         close(in);
 240         return 0;
 241 }
 242
 243 typedef int (*feed_fn)(void *, const char **, size_t *);
 244 static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
 245 {
 246         struct child_process proc;
 247         struct async muxer;
 248         const char *argv[2];
 249         int code;
 250
 251         argv[0] = find_hook(hook_name);
 252         if (!argv[0])
 253                 return 0;
 254
 255         argv[1] = NULL;
 256
 257         memset(&proc, 0, sizeof(proc));
 258         proc.argv = argv;
 259         proc.in = -1;
 260         proc.stdout_to_stderr = 1;
 261
 262         if (use_sideband) {
 263                 memset(&muxer, 0, sizeof(muxer));
 264                 muxer.proc = copy_to_sideband;
 265                 muxer.in = -1;
 266                 code = start_async(&muxer);
 267                 if (code)
 268                         return code;
 269                 proc.err = muxer.in;
 270         }
 271
 272         code = start_command(&proc);
 273         if (code) {
 274                 if (use_sideband)
 275                         finish_async(&muxer);
 276                 return code;
 277         }
 278
 279         while (1) {
 280                 const char *buf;
 281                 size_t n;
 282                 if (feed(feed_state, &buf, &n))
 283                         break;
 284                 if (write_in_full(proc.in, buf, n) != n)
 285                         break;
 286         }
 287         close(proc.in);
 288         if (use_sideband)
 289                 finish_async(&muxer);
 290         return finish_command(&proc);
 291 }
 292
 293 struct receive_hook_feed_state {
 294         struct command *cmd;
 295         int skip_broken;
 296         struct strbuf buf;
 297 };
 298
 299 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
 300 {
 301         struct receive_hook_feed_state *state = state_;
 302         struct command *cmd = state->cmd;
 303
 304         while (cmd &&
 305                state->skip_broken && (cmd->error_string || cmd->did_not_exist))
 306                 cmd = cmd->next;
 307         if (!cmd)
 308                 return -1; /* EOF */
 309         strbuf_reset(&state->buf);
 310         strbuf_addf(&state->buf, "%s %s %s\n",
 311                     sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
 312                     cmd->ref_name);
 313         state->cmd = cmd->next;
 314         if (bufp) {
 315                 *bufp = state->buf.buf;
 316                 *sizep = state->buf.len;
 317         }
 318         return 0;
 319 }
 320
 321 static int run_receive_hook(struct command *commands, const char *hook_name,
 322                             int skip_broken)
 323 {
 324         struct receive_hook_feed_state state;
 325         int status;
 326
 327         strbuf_init(&state.buf, 0);
 328         state.cmd = commands;
 329         state.skip_broken = skip_broken;
 330         if (feed_receive_hook(&state, NULL, NULL))
 331                 return 0;
 332         state.cmd = commands;
 333         status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
 334         strbuf_release(&state.buf);
 335         return status;
 336 }
 337
 338 static int run_update_hook(struct command *cmd)
 339 {
 340         const char *argv[5];
 341         struct child_process proc;
 342         int code;
 343
 344         argv[0] = find_hook("update");
 345         if (!argv[0])
 346                 return 0;
 347
 348         argv[1] = cmd->ref_name;
 349         argv[2] = sha1_to_hex(cmd->old_sha1);
 350         argv[3] = sha1_to_hex(cmd->new_sha1);
 351         argv[4] = NULL;
 352
 353         memset(&proc, 0, sizeof(proc));
 354         proc.no_stdin = 1;
 355         proc.stdout_to_stderr = 1;
 356         proc.err = use_sideband ? -1 : 0;
 357         proc.argv = argv;
 358
 359         code = start_command(&proc);
 360         if (code)
 361                 return code;
 362         if (use_sideband)
 363                 copy_to_sideband(proc.err, -1, NULL);
 364         return finish_command(&proc);
 365 }
 366
 367 static int is_ref_checked_out(const char *ref)
 368 {
 369         if (is_bare_repository())
 370                 return 0;
 371
 372         if (!head_name)
 373                 return 0;
 374         return !strcmp(head_name, ref);
 375 }
 376
 377 static char *refuse_unconfigured_deny_msg[] = {
 378         "By default, updating the current branch in a non-bare repository",
 379         "is denied, because it will make the index and work tree inconsistent",
 380         "with what you pushed, and will require 'git reset --hard' to match",
 381         "the work tree to HEAD.",
 382         "",
 383         "You can set 'receive.denyCurrentBranch' configuration variable to",
 384         "'ignore' or 'warn' in the remote repository to allow pushing into",
 385         "its current branch; however, this is not recommended unless you",
 386         "arranged to update its work tree to match what you pushed in some",
 387         "other way.",
 388         "",
 389         "To squelch this message and still keep the default behaviour, set",
 390         "'receive.denyCurrentBranch' configuration variable to 'refuse'."
 391 };
 392
 393 static void refuse_unconfigured_deny(void)
 394 {
 395         int i;
 396         for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
 397                 rp_error("%s", refuse_unconfigured_deny_msg[i]);
 398 }
 399
 400 static char *refuse_unconfigured_deny_delete_current_msg[] = {
 401         "By default, deleting the current branch is denied, because the next",
 402         "'git clone' won't result in any file checked out, causing confusion.",
 403         "",
 404         "You can set 'receive.denyDeleteCurrent' configuration variable to",
 405         "'warn' or 'ignore' in the remote repository to allow deleting the",
 406         "current branch, with or without a warning message.",
 407         "",
 408         "To squelch this message, you can set it to 'refuse'."
 409 };
 410
 411 static void refuse_unconfigured_deny_delete_current(void)
 412 {
 413         int i;
 414         for (i = 0;
 415              i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
 416              i++)
 417                 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
 418 }
 419
 420 static const char *update(struct command *cmd)
 421 {
 422         const char *name = cmd->ref_name;
 423         struct strbuf namespaced_name_buf = STRBUF_INIT;
 424         const char *namespaced_name;
 425         unsigned char *old_sha1 = cmd->old_sha1;
 426         unsigned char *new_sha1 = cmd->new_sha1;
 427         struct ref_lock *lock;
 428
 429         /* only refs/... are allowed */
 430         if (prefixcmp(name, "refs/") || check_refname_format(name + 5, 0)) {
 431                 rp_error("refusing to create funny ref '%s' remotely", name);
 432                 return "funny refname";
 433         }
 434
 435         strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
 436         namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
 437
 438         if (is_ref_checked_out(namespaced_name)) {
 439                 switch (deny_current_branch) {
 440                 case DENY_IGNORE:
 441                         break;
 442                 case DENY_WARN:
 443                         rp_warning("updating the current branch");
 444                         break;
 445                 case DENY_REFUSE:
 446                 case DENY_UNCONFIGURED:
 447                         rp_error("refusing to update checked out branch: %s", name);
 448                         if (deny_current_branch == DENY_UNCONFIGURED)
 449                                 refuse_unconfigured_deny();
 450                         return "branch is currently checked out";
 451                 }
 452         }
 453
 454         if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
 455                 error("unpack should have generated %s, "
 456                       "but I can't find it!", sha1_to_hex(new_sha1));
 457                 return "bad pack";
 458         }
 459
 460         if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
 461                 if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
 462                         rp_error("denying ref deletion for %s", name);
 463                         return "deletion prohibited";
 464                 }
 465
 466                 if (!strcmp(namespaced_name, head_name)) {
 467                         switch (deny_delete_current) {
 468                         case DENY_IGNORE:
 469                                 break;
 470                         case DENY_WARN:
 471                                 rp_warning("deleting the current branch");
 472                                 break;
 473                         case DENY_REFUSE:
 474                         case DENY_UNCONFIGURED:
 475                                 if (deny_delete_current == DENY_UNCONFIGURED)
 476                                         refuse_unconfigured_deny_delete_current();
 477                                 rp_error("refusing to delete the current branch: %s", name);
 478                                 return "deletion of the current branch prohibited";
 479                         }
 480                 }
 481         }
 482
 483         if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
 484             !is_null_sha1(old_sha1) &&
 485             !prefixcmp(name, "refs/heads/")) {
 486                 struct object *old_object, *new_object;
 487                 struct commit *old_commit, *new_commit;
 488
 489                 old_object = parse_object(old_sha1);
 490                 new_object = parse_object(new_sha1);
 491
 492                 if (!old_object || !new_object ||
 493                     old_object->type != OBJ_COMMIT ||
 494                     new_object->type != OBJ_COMMIT) {
 495                         error("bad sha1 objects for %s", name);
 496                         return "bad ref";
 497                 }
 498                 old_commit = (struct commit *)old_object;
 499                 new_commit = (struct commit *)new_object;
 500                 if (!in_merge_bases(old_commit, new_commit)) {
 501                         rp_error("denying non-fast-forward %s"
 502                                  " (you should pull first)", name);
 503                         return "non-fast-forward";
 504                 }
 505         }
 506         if (run_update_hook(cmd)) {
 507                 rp_error("hook declined to update %s", name);
 508                 return "hook declined";
 509         }
 510
 511         if (is_null_sha1(new_sha1)) {
 512                 if (!parse_object(old_sha1)) {
 513                         old_sha1 = NULL;
 514                         if (ref_exists(name)) {
 515                                 rp_warning("Allowing deletion of corrupt ref.");
 516                         } else {
 517                                 rp_warning("Deleting a non-existent ref.");
 518                                 cmd->did_not_exist = 1;
 519                         }
 520                 }
 521                 if (delete_ref(namespaced_name, old_sha1, 0)) {
 522                         rp_error("failed to delete %s", name);
 523                         return "failed to delete";
 524                 }
 525                 return NULL; /* good */
 526         }
 527         else {
 528                 lock = lock_any_ref_for_update(namespaced_name, old_sha1, 0);
 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                 if (fix_thin)
 874                         keeper[i++] = "--fix-thin";
 875                 keeper[i++] = hdr_arg;
 876                 keeper[i++] = keep_arg;
 877                 keeper[i++] = NULL;
 878                 memset(&ip, 0, sizeof(ip));
 879                 ip.argv = keeper;
 880                 ip.out = -1;
 881                 ip.err = err_fd;
 882                 ip.git_cmd = 1;
 883                 status = start_command(&ip);
 884                 if (status) {
 885                         return "index-pack fork failed";
 886                 }
 887                 pack_lockfile = index_pack_lockfile(ip.out);
 888                 close(ip.out);
 889                 status = finish_command(&ip);
 890                 if (!status) {
 891                         reprepare_packed_git();
 892                         return NULL;
 893                 }
 894                 return "index-pack abnormal exit";
 895         }
 896 }
 897
 898 static const char *unpack_with_sideband(void)
 899 {
 900         struct async muxer;
 901         const char *ret;
 902
 903         if (!use_sideband)
 904                 return unpack(0);
 905
 906         memset(&muxer, 0, sizeof(muxer));
 907         muxer.proc = copy_to_sideband;
 908         muxer.in = -1;
 909         if (start_async(&muxer))
 910                 return NULL;
 911
 912         ret = unpack(muxer.in);
 913
 914         finish_async(&muxer);
 915         return ret;
 916 }
 917
 918 static void report(struct command *commands, const char *unpack_status)
 919 {
 920         struct command *cmd;
 921         struct strbuf buf = STRBUF_INIT;
 922
 923         packet_buf_write(&buf, "unpack %s\n",
 924                          unpack_status ? unpack_status : "ok");
 925         for (cmd = commands; cmd; cmd = cmd->next) {
 926                 if (!cmd->error_string)
 927                         packet_buf_write(&buf, "ok %s\n",
 928                                          cmd->ref_name);
 929                 else
 930                         packet_buf_write(&buf, "ng %s %s\n",
 931                                          cmd->ref_name, cmd->error_string);
 932         }
 933         packet_buf_flush(&buf);
 934
 935         if (use_sideband)
 936                 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
 937         else
 938                 write_or_die(1, buf.buf, buf.len);
 939         strbuf_release(&buf);
 940 }
 941
 942 static int delete_only(struct command *commands)
 943 {
 944         struct command *cmd;
 945         for (cmd = commands; cmd; cmd = cmd->next) {
 946                 if (!is_null_sha1(cmd->new_sha1))
 947                         return 0;
 948         }
 949         return 1;
 950 }
 951
 952 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
 953 {
 954         int advertise_refs = 0;
 955         int stateless_rpc = 0;
 956         int i;
 957         char *dir = NULL;
 958         struct command *commands;
 959
 960         packet_trace_identity("receive-pack");
 961
 962         argv++;
 963         for (i = 1; i < argc; i++) {
 964                 const char *arg = *argv++;
 965
 966                 if (*arg == '-') {
 967                         if (!strcmp(arg, "--quiet")) {
 968                                 quiet = 1;
 969                                 continue;
 970                         }
 971
 972                         if (!strcmp(arg, "--advertise-refs")) {
 973                                 advertise_refs = 1;
 974                                 continue;
 975                         }
 976                         if (!strcmp(arg, "--stateless-rpc")) {
 977                                 stateless_rpc = 1;
 978                                 continue;
 979                         }
 980                         if (!strcmp(arg, "--reject-thin-pack-for-testing")) {
 981                                 fix_thin = 0;
 982                                 continue;
 983                         }
 984
 985                         usage(receive_pack_usage);
 986                 }
 987                 if (dir)
 988                         usage(receive_pack_usage);
 989                 dir = xstrdup(arg);
 990         }
 991         if (!dir)
 992                 usage(receive_pack_usage);
 993
 994         setup_path();
 995
 996         if (!enter_repo(dir, 0))
 997                 die("'%s' does not appear to be a git repository", dir);
 998
 999         if (is_repository_shallow())
1000                 die("attempt to push into a shallow repository");
1001
1002         git_config(receive_pack_config, NULL);
1003
1004         if (0 <= transfer_unpack_limit)
1005                 unpack_limit = transfer_unpack_limit;
1006         else if (0 <= receive_unpack_limit)
1007                 unpack_limit = receive_unpack_limit;
1008
1009         if (advertise_refs || !stateless_rpc) {
1010                 write_head_info();
1011         }
1012         if (advertise_refs)
1013                 return 0;
1014
1015         if ((commands = read_head_info()) != NULL) {
1016                 const char *unpack_status = NULL;
1017
1018                 if (!delete_only(commands))
1019                         unpack_status = unpack_with_sideband();
1020                 execute_commands(commands, unpack_status);
1021                 if (pack_lockfile)
1022                         unlink_or_warn(pack_lockfile);
1023                 if (report_status)
1024                         report(commands, unpack_status);
1025                 run_receive_hook(commands, "post-receive", 1);
1026                 run_update_post_hook(commands);
1027                 if (auto_gc) {
1028                         const char *argv_gc_auto[] = {
1029                                 "gc", "--auto", "--quiet", NULL,
1030                         };
1031                         int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1032                         run_command_v_opt(argv_gc_auto, opt);
1033                 }
1034                 if (auto_update_server_info)
1035                         update_server_info(0);
1036         }
1037         if (use_sideband)
1038                 packet_flush(1);
1039         return 0;
1040 }