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