git.oblomov.eu Git - git/blob - builtin/receive-pack.c

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