builtin/receive-pack.c

   1 #include "cache.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
  13 static const char receive_pack_usage[] = "git receive-pack <git-dir>";
  14
  15 enum deny_action {
  16         DENY_UNCONFIGURED,
  17         DENY_IGNORE,
  18         DENY_WARN,
  19         DENY_REFUSE,
  20         DENY_UPDATE_INSTEAD,
  21         DENY_DETACH_INSTEAD,
  22 };
  23
  24 static int deny_deletes;
  25 static int deny_non_fast_forwards;
  26 static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
  27 static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
  28 static int receive_fsck_objects;
  29 static int receive_unpack_limit = -1;
  30 static int transfer_unpack_limit = -1;
  31 static int unpack_limit = 100;
  32 static int report_status;
  33 static int use_sideband;
  34 static int prefer_ofs_delta = 1;
  35 static int auto_update_server_info;
  36 static int auto_gc = 1;
  37 static const char *head_name;
  38 static int sent_capabilities;
  39
  40 static enum deny_action parse_deny_action(const char *var, const char *value)
  41 {
  42         if (value) {
  43                 if (!strcasecmp(value, "ignore"))
  44                         return DENY_IGNORE;
  45                 if (!strcasecmp(value, "warn"))
  46                         return DENY_WARN;
  47                 if (!strcasecmp(value, "refuse"))
  48                         return DENY_REFUSE;
  49         }
  50         if (git_config_bool(var, value))
  51                 return DENY_REFUSE;
  52         return DENY_IGNORE;
  53 }
  54
  55 static int receive_pack_config(const char *var, const char *value, void *cb)
  56 {
  57         if (strcmp(var, "receive.denydeletes") == 0) {
  58                 deny_deletes = git_config_bool(var, value);
  59                 return 0;
  60         }
  61
  62         if (strcmp(var, "receive.denynonfastforwards") == 0) {
  63                 deny_non_fast_forwards = git_config_bool(var, value);
  64                 return 0;
  65         }
  66
  67         if (strcmp(var, "receive.unpacklimit") == 0) {
  68                 receive_unpack_limit = git_config_int(var, value);
  69                 return 0;
  70         }
  71
  72         if (strcmp(var, "transfer.unpacklimit") == 0) {
  73                 transfer_unpack_limit = git_config_int(var, value);
  74                 return 0;
  75         }
  76
  77         if (strcmp(var, "receive.fsckobjects") == 0) {
  78                 receive_fsck_objects = git_config_bool(var, value);
  79                 return 0;
  80         }
  81
  82         if (!strcmp(var, "receive.denycurrentbranch")) {
  83                 if (value && !strcasecmp(value, "updateinstead"))
  84                         deny_current_branch = DENY_UPDATE_INSTEAD;
  85                 else if (value && !strcasecmp(value, "detachinstead"))
  86                         deny_current_branch = DENY_DETACH_INSTEAD;
  87                 else
  88                         deny_current_branch = parse_deny_action(var, value);
  89                 return 0;
  90         }
  91
  92         if (strcmp(var, "receive.denydeletecurrent") == 0) {
  93                 deny_delete_current = parse_deny_action(var, value);
  94                 return 0;
  95         }
  96
  97         if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
  98                 prefer_ofs_delta = git_config_bool(var, value);
  99                 return 0;
 100         }
 101
 102         if (strcmp(var, "receive.updateserverinfo") == 0) {
 103                 auto_update_server_info = git_config_bool(var, value);
 104                 return 0;
 105         }
 106
 107         if (strcmp(var, "receive.autogc") == 0) {
 108                 auto_gc = git_config_bool(var, value);
 109                 return 0;
 110         }
 111
 112         return git_default_config(var, value, cb);
 113 }
 114
 115 static int show_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
 116 {
 117         if (sent_capabilities)
 118                 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
 119         else
 120                 packet_write(1, "%s %s%c%s%s\n",
 121                              sha1_to_hex(sha1), path, 0,
 122                              " report-status delete-refs side-band-64k",
 123                              prefer_ofs_delta ? " ofs-delta" : "");
 124         sent_capabilities = 1;
 125         return 0;
 126 }
 127
 128 static void write_head_info(void)
 129 {
 130         for_each_ref(show_ref, NULL);
 131         if (!sent_capabilities)
 132                 show_ref("capabilities^{}", null_sha1, 0, NULL);
 133
 134 }
 135
 136 struct command {
 137         struct command *next;
 138         const char *error_string;
 139         unsigned char old_sha1[20];
 140         unsigned char new_sha1[20];
 141         char ref_name[FLEX_ARRAY]; /* more */
 142 };
 143
 144 static struct command *commands;
 145
 146 static const char pre_receive_hook[] = "hooks/pre-receive";
 147 static const char post_receive_hook[] = "hooks/post-receive";
 148
 149 static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
 150 static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
 151
 152 static void report_message(const char *prefix, const char *err, va_list params)
 153 {
 154         int sz = strlen(prefix);
 155         char msg[4096];
 156
 157         strncpy(msg, prefix, sz);
 158         sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
 159         if (sz > (sizeof(msg) - 1))
 160                 sz = sizeof(msg) - 1;
 161         msg[sz++] = '\n';
 162
 163         if (use_sideband)
 164                 send_sideband(1, 2, msg, sz, use_sideband);
 165         else
 166                 xwrite(2, msg, sz);
 167 }
 168
 169 static void rp_warning(const char *err, ...)
 170 {
 171         va_list params;
 172         va_start(params, err);
 173         report_message("warning: ", err, params);
 174         va_end(params);
 175 }
 176
 177 static void rp_error(const char *err, ...)
 178 {
 179         va_list params;
 180         va_start(params, err);
 181         report_message("error: ", err, params);
 182         va_end(params);
 183 }
 184
 185 static int copy_to_sideband(int in, int out, void *arg)
 186 {
 187         char data[128];
 188         while (1) {
 189                 ssize_t sz = xread(in, data, sizeof(data));
 190                 if (sz <= 0)
 191                         break;
 192                 send_sideband(1, 2, data, sz, use_sideband);
 193         }
 194         close(in);
 195         return 0;
 196 }
 197
 198 static int run_receive_hook(const char *hook_name)
 199 {
 200         static char buf[sizeof(commands->old_sha1) * 2 + PATH_MAX + 4];
 201         struct command *cmd;
 202         struct child_process proc;
 203         struct async muxer;
 204         const char *argv[2];
 205         int have_input = 0, code;
 206
 207         for (cmd = commands; !have_input && cmd; cmd = cmd->next) {
 208                 if (!cmd->error_string)
 209                         have_input = 1;
 210         }
 211
 212         if (!have_input || access(hook_name, X_OK) < 0)
 213                 return 0;
 214
 215         argv[0] = hook_name;
 216         argv[1] = NULL;
 217
 218         memset(&proc, 0, sizeof(proc));
 219         proc.argv = argv;
 220         proc.in = -1;
 221         proc.stdout_to_stderr = 1;
 222
 223         if (use_sideband) {
 224                 memset(&muxer, 0, sizeof(muxer));
 225                 muxer.proc = copy_to_sideband;
 226                 muxer.in = -1;
 227                 code = start_async(&muxer);
 228                 if (code)
 229                         return code;
 230                 proc.err = muxer.in;
 231         }
 232
 233         code = start_command(&proc);
 234         if (code) {
 235                 if (use_sideband)
 236                         finish_async(&muxer);
 237                 return code;
 238         }
 239
 240         for (cmd = commands; cmd; cmd = cmd->next) {
 241                 if (!cmd->error_string) {
 242                         size_t n = snprintf(buf, sizeof(buf), "%s %s %s\n",
 243                                 sha1_to_hex(cmd->old_sha1),
 244                                 sha1_to_hex(cmd->new_sha1),
 245                                 cmd->ref_name);
 246                         if (write_in_full(proc.in, buf, n) != n)
 247                                 break;
 248                 }
 249         }
 250         close(proc.in);
 251         if (use_sideband)
 252                 finish_async(&muxer);
 253         return finish_command(&proc);
 254 }
 255
 256 static int run_update_hook(struct command *cmd)
 257 {
 258         static const char update_hook[] = "hooks/update";
 259         const char *argv[5];
 260         struct child_process proc;
 261         int code;
 262
 263         if (access(update_hook, X_OK) < 0)
 264                 return 0;
 265
 266         argv[0] = update_hook;
 267         argv[1] = cmd->ref_name;
 268         argv[2] = sha1_to_hex(cmd->old_sha1);
 269         argv[3] = sha1_to_hex(cmd->new_sha1);
 270         argv[4] = NULL;
 271
 272         memset(&proc, 0, sizeof(proc));
 273         proc.no_stdin = 1;
 274         proc.stdout_to_stderr = 1;
 275         proc.err = use_sideband ? -1 : 0;
 276         proc.argv = argv;
 277
 278         code = start_command(&proc);
 279         if (code)
 280                 return code;
 281         if (use_sideband)
 282                 copy_to_sideband(proc.err, -1, NULL);
 283         return finish_command(&proc);
 284 }
 285
 286 static int is_ref_checked_out(const char *ref)
 287 {
 288         if (is_bare_repository())
 289                 return 0;
 290
 291         if (!head_name)
 292                 return 0;
 293         return !strcmp(head_name, ref);
 294 }
 295
 296 static char *refuse_unconfigured_deny_msg[] = {
 297         "By default, updating the current branch in a non-bare repository",
 298         "is denied, because it will make the index and work tree inconsistent",
 299         "with what you pushed, and will require 'git reset --hard' to match",
 300         "the work tree to HEAD.",
 301         "",
 302         "You can set 'receive.denyCurrentBranch' configuration variable to",
 303         "'ignore' or 'warn' in the remote repository to allow pushing into",
 304         "its current branch; however, this is not recommended unless you",
 305         "arranged to update its work tree to match what you pushed in some",
 306         "other way.",
 307         "",
 308         "To squelch this message and still keep the default behaviour, set",
 309         "'receive.denyCurrentBranch' configuration variable to 'refuse'."
 310 };
 311
 312 static void refuse_unconfigured_deny(void)
 313 {
 314         int i;
 315         for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
 316                 rp_error("%s", refuse_unconfigured_deny_msg[i]);
 317 }
 318
 319 static char *refuse_unconfigured_deny_delete_current_msg[] = {
 320         "By default, deleting the current branch is denied, because the next",
 321         "'git clone' won't result in any file checked out, causing confusion.",
 322         "",
 323         "You can set 'receive.denyDeleteCurrent' configuration variable to",
 324         "'warn' or 'ignore' in the remote repository to allow deleting the",
 325         "current branch, with or without a warning message.",
 326         "",
 327         "To squelch this message, you can set it to 'refuse'."
 328 };
 329
 330 static void refuse_unconfigured_deny_delete_current(void)
 331 {
 332         int i;
 333         for (i = 0;
 334              i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
 335              i++)
 336                 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
 337 }
 338
 339 static void merge_worktree(unsigned char *sha1)
 340 {
 341         const char *update_refresh[] = {
 342                 "update-index", "--refresh", NULL
 343         };
 344         const char *read_tree[] = {
 345                 "read-tree", "-u", "-m", sha1_to_hex(sha1), NULL
 346         };
 347         struct child_process child;
 348         struct strbuf git_env = STRBUF_INIT;
 349         const char *env[2];
 350
 351         if (is_bare_repository())
 352                 die ("denyCurrentBranch = updateInstead needs a worktree");
 353
 354         strbuf_addf(&git_env, "GIT_DIR=%s", make_absolute_path(get_git_dir()));
 355         env[0] = git_env.buf;
 356         env[1] = NULL;
 357
 358         memset(&child, 0, sizeof(child));
 359         child.argv = update_refresh;
 360         child.env = env;
 361         child.dir = git_work_tree_cfg ? git_work_tree_cfg : "..";
 362         child.stdout_to_stderr = 1;
 363         child.git_cmd = 1;
 364         if (run_command(&child))
 365                 die ("Could not refresh the index");
 366
 367         child.argv = read_tree;
 368         child.no_stdin = 1;
 369         child.no_stdout = 1;
 370         child.stdout_to_stderr = 0;
 371         if (run_command(&child))
 372                 die ("Could not merge working tree with new HEAD.  Good luck.");
 373
 374         strbuf_release(&git_env);
 375 }
 376
 377 static const char *update(struct command *cmd)
 378 {
 379         const char *name = cmd->ref_name;
 380         unsigned char *old_sha1 = cmd->old_sha1;
 381         unsigned char *new_sha1 = cmd->new_sha1;
 382         struct ref_lock *lock;
 383
 384         /* only refs/... are allowed */
 385         if (prefixcmp(name, "refs/") || check_ref_format(name + 5)) {
 386                 rp_error("refusing to create funny ref '%s' remotely", name);
 387                 return "funny refname";
 388         }
 389
 390         if (is_ref_checked_out(name)) {
 391                 switch (deny_current_branch) {
 392                 case DENY_IGNORE:
 393                         break;
 394                 case DENY_WARN:
 395                         rp_warning("updating the current branch");
 396                         break;
 397                 case DENY_REFUSE:
 398                 case DENY_UNCONFIGURED:
 399                         rp_error("refusing to update checked out branch: %s", name);
 400                         if (deny_current_branch == DENY_UNCONFIGURED)
 401                                 refuse_unconfigured_deny();
 402                         return "branch is currently checked out";
 403                 case DENY_UPDATE_INSTEAD:
 404                         merge_worktree(new_sha1);
 405                         break;
 406                 case DENY_DETACH_INSTEAD:
 407                         update_ref("push into current branch (detach)", "HEAD",
 408                                 old_sha1, NULL, REF_NODEREF, DIE_ON_ERR);
 409                         break;
 410                 }
 411         }
 412
 413         if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
 414                 error("unpack should have generated %s, "
 415                       "but I can't find it!", sha1_to_hex(new_sha1));
 416                 return "bad pack";
 417         }
 418
 419         if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
 420                 if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
 421                         rp_error("denying ref deletion for %s", name);
 422                         return "deletion prohibited";
 423                 }
 424
 425                 if (!strcmp(name, head_name)) {
 426                         switch (deny_delete_current) {
 427                         case DENY_IGNORE:
 428                                 break;
 429                         case DENY_WARN:
 430                                 rp_warning("deleting the current branch");
 431                                 break;
 432                         case DENY_REFUSE:
 433                         case DENY_UNCONFIGURED:
 434                                 if (deny_delete_current == DENY_UNCONFIGURED)
 435                                         refuse_unconfigured_deny_delete_current();
 436                                 rp_error("refusing to delete the current branch: %s", name);
 437                                 return "deletion of the current branch prohibited";
 438                         default:
 439                                 die ("Invalid denyDeleteCurrent setting");
 440                         }
 441                 }
 442         }
 443
 444         if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
 445             !is_null_sha1(old_sha1) &&
 446             !prefixcmp(name, "refs/heads/")) {
 447                 struct object *old_object, *new_object;
 448                 struct commit *old_commit, *new_commit;
 449                 struct commit_list *bases, *ent;
 450
 451                 old_object = parse_object(old_sha1);
 452                 new_object = parse_object(new_sha1);
 453
 454                 if (!old_object || !new_object ||
 455                     old_object->type != OBJ_COMMIT ||
 456                     new_object->type != OBJ_COMMIT) {
 457                         error("bad sha1 objects for %s", name);
 458                         return "bad ref";
 459                 }
 460                 old_commit = (struct commit *)old_object;
 461                 new_commit = (struct commit *)new_object;
 462                 bases = get_merge_bases(old_commit, new_commit, 1);
 463                 for (ent = bases; ent; ent = ent->next)
 464                         if (!hashcmp(old_sha1, ent->item->object.sha1))
 465                                 break;
 466                 free_commit_list(bases);
 467                 if (!ent) {
 468                         rp_error("denying non-fast-forward %s"
 469                                  " (you should pull first)", name);
 470                         return "non-fast-forward";
 471                 }
 472         }
 473         if (run_update_hook(cmd)) {
 474                 rp_error("hook declined to update %s", name);
 475                 return "hook declined";
 476         }
 477
 478         if (is_null_sha1(new_sha1)) {
 479                 if (!parse_object(old_sha1)) {
 480                         rp_warning("Allowing deletion of corrupt ref.");
 481                         old_sha1 = NULL;
 482                 }
 483                 if (delete_ref(name, old_sha1, 0)) {
 484                         rp_error("failed to delete %s", name);
 485                         return "failed to delete";
 486                 }
 487                 return NULL; /* good */
 488         }
 489         else {
 490                 lock = lock_any_ref_for_update(name, old_sha1, 0);
 491                 if (!lock) {
 492                         rp_error("failed to lock %s", name);
 493                         return "failed to lock";
 494                 }
 495                 if (write_ref_sha1(lock, new_sha1, "push")) {
 496                         return "failed to write"; /* error() already called */
 497                 }
 498                 return NULL; /* good */
 499         }
 500 }
 501
 502 static char update_post_hook[] = "hooks/post-update";
 503
 504 static void run_update_post_hook(struct command *cmd)
 505 {
 506         struct command *cmd_p;
 507         int argc;
 508         const char **argv;
 509         struct child_process proc;
 510
 511         for (argc = 0, cmd_p = cmd; cmd_p; cmd_p = cmd_p->next) {
 512                 if (cmd_p->error_string)
 513                         continue;
 514                 argc++;
 515         }
 516         if (!argc || access(update_post_hook, X_OK) < 0)
 517                 return;
 518         argv = xmalloc(sizeof(*argv) * (2 + argc));
 519         argv[0] = update_post_hook;
 520
 521         for (argc = 1, cmd_p = cmd; cmd_p; cmd_p = cmd_p->next) {
 522                 char *p;
 523                 if (cmd_p->error_string)
 524                         continue;
 525                 p = xmalloc(strlen(cmd_p->ref_name) + 1);
 526                 strcpy(p, cmd_p->ref_name);
 527                 argv[argc] = p;
 528                 argc++;
 529         }
 530         argv[argc] = NULL;
 531
 532         memset(&proc, 0, sizeof(proc));
 533         proc.no_stdin = 1;
 534         proc.stdout_to_stderr = 1;
 535         proc.err = use_sideband ? -1 : 0;
 536         proc.argv = argv;
 537
 538         if (!start_command(&proc)) {
 539                 if (use_sideband)
 540                         copy_to_sideband(proc.err, -1, NULL);
 541                 finish_command(&proc);
 542         }
 543 }
 544
 545 static void execute_commands(const char *unpacker_error)
 546 {
 547         struct command *cmd = commands;
 548         unsigned char sha1[20];
 549
 550         if (unpacker_error) {
 551                 while (cmd) {
 552                         cmd->error_string = "n/a (unpacker error)";
 553                         cmd = cmd->next;
 554                 }
 555                 return;
 556         }
 557
 558         if (run_receive_hook(pre_receive_hook)) {
 559                 while (cmd) {
 560                         cmd->error_string = "pre-receive hook declined";
 561                         cmd = cmd->next;
 562                 }
 563                 return;
 564         }
 565
 566         head_name = resolve_ref("HEAD", sha1, 0, NULL);
 567
 568         while (cmd) {
 569                 cmd->error_string = update(cmd);
 570                 cmd = cmd->next;
 571         }
 572 }
 573
 574 static void read_head_info(void)
 575 {
 576         struct command **p = &commands;
 577         for (;;) {
 578                 static char line[1000];
 579                 unsigned char old_sha1[20], new_sha1[20];
 580                 struct command *cmd;
 581                 char *refname;
 582                 int len, reflen;
 583
 584                 len = packet_read_line(0, line, sizeof(line));
 585                 if (!len)
 586                         break;
 587                 if (line[len-1] == '\n')
 588                         line[--len] = 0;
 589                 if (len < 83 ||
 590                     line[40] != ' ' ||
 591                     line[81] != ' ' ||
 592                     get_sha1_hex(line, old_sha1) ||
 593                     get_sha1_hex(line + 41, new_sha1))
 594                         die("protocol error: expected old/new/ref, got '%s'",
 595                             line);
 596
 597                 refname = line + 82;
 598                 reflen = strlen(refname);
 599                 if (reflen + 82 < len) {
 600                         if (strstr(refname + reflen + 1, "report-status"))
 601                                 report_status = 1;
 602                         if (strstr(refname + reflen + 1, "side-band-64k"))
 603                                 use_sideband = LARGE_PACKET_MAX;
 604                 }
 605                 cmd = xmalloc(sizeof(struct command) + len - 80);
 606                 hashcpy(cmd->old_sha1, old_sha1);
 607                 hashcpy(cmd->new_sha1, new_sha1);
 608                 memcpy(cmd->ref_name, line + 82, len - 81);
 609                 cmd->error_string = NULL;
 610                 cmd->next = NULL;
 611                 *p = cmd;
 612                 p = &cmd->next;
 613         }
 614 }
 615
 616 static const char *parse_pack_header(struct pack_header *hdr)
 617 {
 618         switch (read_pack_header(0, hdr)) {
 619         case PH_ERROR_EOF:
 620                 return "eof before pack header was fully read";
 621
 622         case PH_ERROR_PACK_SIGNATURE:
 623                 return "protocol error (pack signature mismatch detected)";
 624
 625         case PH_ERROR_PROTOCOL:
 626                 return "protocol error (pack version unsupported)";
 627
 628         default:
 629                 return "unknown error in parse_pack_header";
 630
 631         case 0:
 632                 return NULL;
 633         }
 634 }
 635
 636 static const char *pack_lockfile;
 637
 638 static const char *unpack(void)
 639 {
 640         struct pack_header hdr;
 641         const char *hdr_err;
 642         char hdr_arg[38];
 643
 644         hdr_err = parse_pack_header(&hdr);
 645         if (hdr_err)
 646                 return hdr_err;
 647         snprintf(hdr_arg, sizeof(hdr_arg),
 648                         "--pack_header=%"PRIu32",%"PRIu32,
 649                         ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
 650
 651         if (ntohl(hdr.hdr_entries) < unpack_limit) {
 652                 int code, i = 0;
 653                 const char *unpacker[4];
 654                 unpacker[i++] = "unpack-objects";
 655                 if (receive_fsck_objects)
 656                         unpacker[i++] = "--strict";
 657                 unpacker[i++] = hdr_arg;
 658                 unpacker[i++] = NULL;
 659                 code = run_command_v_opt(unpacker, RUN_GIT_CMD);
 660                 if (!code)
 661                         return NULL;
 662                 return "unpack-objects abnormal exit";
 663         } else {
 664                 const char *keeper[7];
 665                 int s, status, i = 0;
 666                 char keep_arg[256];
 667                 struct child_process ip;
 668
 669                 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
 670                 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 671                         strcpy(keep_arg + s, "localhost");
 672
 673                 keeper[i++] = "index-pack";
 674                 keeper[i++] = "--stdin";
 675                 if (receive_fsck_objects)
 676                         keeper[i++] = "--strict";
 677                 keeper[i++] = "--fix-thin";
 678                 keeper[i++] = hdr_arg;
 679                 keeper[i++] = keep_arg;
 680                 keeper[i++] = NULL;
 681                 memset(&ip, 0, sizeof(ip));
 682                 ip.argv = keeper;
 683                 ip.out = -1;
 684                 ip.git_cmd = 1;
 685                 status = start_command(&ip);
 686                 if (status) {
 687                         return "index-pack fork failed";
 688                 }
 689                 pack_lockfile = index_pack_lockfile(ip.out);
 690                 close(ip.out);
 691                 status = finish_command(&ip);
 692                 if (!status) {
 693                         reprepare_packed_git();
 694                         return NULL;
 695                 }
 696                 return "index-pack abnormal exit";
 697         }
 698 }
 699
 700 static void report(const char *unpack_status)
 701 {
 702         struct command *cmd;
 703         struct strbuf buf = STRBUF_INIT;
 704
 705         packet_buf_write(&buf, "unpack %s\n",
 706                          unpack_status ? unpack_status : "ok");
 707         for (cmd = commands; cmd; cmd = cmd->next) {
 708                 if (!cmd->error_string)
 709                         packet_buf_write(&buf, "ok %s\n",
 710                                          cmd->ref_name);
 711                 else
 712                         packet_buf_write(&buf, "ng %s %s\n",
 713                                          cmd->ref_name, cmd->error_string);
 714         }
 715         packet_buf_flush(&buf);
 716
 717         if (use_sideband)
 718                 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
 719         else
 720                 safe_write(1, buf.buf, buf.len);
 721         strbuf_release(&buf);
 722 }
 723
 724 static int delete_only(struct command *cmd)
 725 {
 726         while (cmd) {
 727                 if (!is_null_sha1(cmd->new_sha1))
 728                         return 0;
 729                 cmd = cmd->next;
 730         }
 731         return 1;
 732 }
 733
 734 static int add_refs_from_alternate(struct alternate_object_database *e, void *unused)
 735 {
 736         char *other;
 737         size_t len;
 738         struct remote *remote;
 739         struct transport *transport;
 740         const struct ref *extra;
 741
 742         e->name[-1] = '\0';
 743         other = xstrdup(make_absolute_path(e->base));
 744         e->name[-1] = '/';
 745         len = strlen(other);
 746
 747         while (other[len-1] == '/')
 748                 other[--len] = '\0';
 749         if (len < 8 || memcmp(other + len - 8, "/objects", 8))
 750                 return 0;
 751         /* Is this a git repository with refs? */
 752         memcpy(other + len - 8, "/refs", 6);
 753         if (!is_directory(other))
 754                 return 0;
 755         other[len - 8] = '\0';
 756         remote = remote_get(other);
 757         transport = transport_get(remote, other);
 758         for (extra = transport_get_remote_refs(transport);
 759              extra;
 760              extra = extra->next) {
 761                 add_extra_ref(".have", extra->old_sha1, 0);
 762         }
 763         transport_disconnect(transport);
 764         free(other);
 765         return 0;
 766 }
 767
 768 static void add_alternate_refs(void)
 769 {
 770         foreach_alt_odb(add_refs_from_alternate, NULL);
 771 }
 772
 773 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
 774 {
 775         int advertise_refs = 0;
 776         int stateless_rpc = 0;
 777         int i;
 778         char *dir = NULL;
 779
 780         argv++;
 781         for (i = 1; i < argc; i++) {
 782                 const char *arg = *argv++;
 783
 784                 if (*arg == '-') {
 785                         if (!strcmp(arg, "--advertise-refs")) {
 786                                 advertise_refs = 1;
 787                                 continue;
 788                         }
 789                         if (!strcmp(arg, "--stateless-rpc")) {
 790                                 stateless_rpc = 1;
 791                                 continue;
 792                         }
 793
 794                         usage(receive_pack_usage);
 795                 }
 796                 if (dir)
 797                         usage(receive_pack_usage);
 798                 dir = xstrdup(arg);
 799         }
 800         if (!dir)
 801                 usage(receive_pack_usage);
 802
 803         setup_path();
 804
 805         if (!enter_repo(dir, 0))
 806                 die("'%s' does not appear to be a git repository", dir);
 807
 808         if (is_repository_shallow())
 809                 die("attempt to push into a shallow repository");
 810
 811         git_config(receive_pack_config, NULL);
 812
 813         if (0 <= transfer_unpack_limit)
 814                 unpack_limit = transfer_unpack_limit;
 815         else if (0 <= receive_unpack_limit)
 816                 unpack_limit = receive_unpack_limit;
 817
 818         if (advertise_refs || !stateless_rpc) {
 819                 add_alternate_refs();
 820                 write_head_info();
 821                 clear_extra_refs();
 822
 823                 /* EOF */
 824                 packet_flush(1);
 825         }
 826         if (advertise_refs)
 827                 return 0;
 828
 829         read_head_info();
 830         if (commands) {
 831                 const char *unpack_status = NULL;
 832
 833                 if (!delete_only(commands))
 834                         unpack_status = unpack();
 835                 execute_commands(unpack_status);
 836                 if (pack_lockfile)
 837                         unlink_or_warn(pack_lockfile);
 838                 if (report_status)
 839                         report(unpack_status);
 840                 run_receive_hook(post_receive_hook);
 841                 run_update_post_hook(commands);
 842                 if (auto_gc) {
 843                         const char *argv_gc_auto[] = {
 844                                 "gc", "--auto", "--quiet", NULL,
 845                         };
 846                         run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
 847                 }
 848                 if (auto_update_server_info)
 849                         update_server_info(0);
 850         }
 851         if (use_sideband)
 852                 packet_flush(1);
 853         return 0;
 854 }