git.oblomov.eu Git - git/blob - 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 #include "string-list.h"
  13
  14 static const char receive_pack_usage[] = "git receive-pack <git-dir>";
  15
  16 enum deny_action {
  17         DENY_UNCONFIGURED,
  18         DENY_IGNORE,
  19         DENY_WARN,
  20         DENY_REFUSE
  21 };
  22
  23 static int deny_deletes;
  24 static int deny_non_fast_forwards;
  25 static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
  26 static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
  27 static int receive_fsck_objects;
  28 static int receive_unpack_limit = -1;
  29 static int transfer_unpack_limit = -1;
  30 static int unpack_limit = 100;
  31 static int report_status;
  32 static int use_sideband;
  33 static int prefer_ofs_delta = 1;
  34 static int auto_update_server_info;
  35 static int auto_gc = 1;
  36 static const char *head_name;
  37 static int sent_capabilities;
  38
  39 static enum deny_action parse_deny_action(const char *var, const char *value)
  40 {
  41         if (value) {
  42                 if (!strcasecmp(value, "ignore"))
  43                         return DENY_IGNORE;
  44                 if (!strcasecmp(value, "warn"))
  45                         return DENY_WARN;
  46                 if (!strcasecmp(value, "refuse"))
  47                         return DENY_REFUSE;
  48         }
  49         if (git_config_bool(var, value))
  50                 return DENY_REFUSE;
  51         return DENY_IGNORE;
  52 }
  53
  54 static int receive_pack_config(const char *var, const char *value, void *cb)
  55 {
  56         if (strcmp(var, "receive.denydeletes") == 0) {
  57                 deny_deletes = git_config_bool(var, value);
  58                 return 0;
  59         }
  60
  61         if (strcmp(var, "receive.denynonfastforwards") == 0) {
  62                 deny_non_fast_forwards = git_config_bool(var, value);
  63                 return 0;
  64         }
  65
  66         if (strcmp(var, "receive.unpacklimit") == 0) {
  67                 receive_unpack_limit = git_config_int(var, value);
  68                 return 0;
  69         }
  70
  71         if (strcmp(var, "transfer.unpacklimit") == 0) {
  72                 transfer_unpack_limit = git_config_int(var, value);
  73                 return 0;
  74         }
  75
  76         if (strcmp(var, "receive.fsckobjects") == 0) {
  77                 receive_fsck_objects = git_config_bool(var, value);
  78                 return 0;
  79         }
  80
  81         if (!strcmp(var, "receive.denycurrentbranch")) {
  82                 deny_current_branch = parse_deny_action(var, value);
  83                 return 0;
  84         }
  85
  86         if (strcmp(var, "receive.denydeletecurrent") == 0) {
  87                 deny_delete_current = parse_deny_action(var, value);
  88                 return 0;
  89         }
  90
  91         if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
  92                 prefer_ofs_delta = git_config_bool(var, value);
  93                 return 0;
  94         }
  95
  96         if (strcmp(var, "receive.updateserverinfo") == 0) {
  97                 auto_update_server_info = git_config_bool(var, value);
  98                 return 0;
  99         }
 100
 101         if (strcmp(var, "receive.autogc") == 0) {
 102                 auto_gc = git_config_bool(var, value);
 103                 return 0;
 104         }
 105
 106         return git_default_config(var, value, cb);
 107 }
 108
 109 static int show_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
 110 {
 111         if (sent_capabilities)
 112                 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
 113         else
 114                 packet_write(1, "%s %s%c%s%s\n",
 115                              sha1_to_hex(sha1), path, 0,
 116                              " report-status delete-refs side-band-64k",
 117                              prefer_ofs_delta ? " ofs-delta" : "");
 118         sent_capabilities = 1;
 119         return 0;
 120 }
 121
 122 static void write_head_info(void)
 123 {
 124         for_each_ref(show_ref, NULL);
 125         if (!sent_capabilities)
 126                 show_ref("capabilities^{}", null_sha1, 0, NULL);
 127
 128 }
 129
 130 struct command {
 131         struct command *next;
 132         const char *error_string;
 133         unsigned int skip_update;
 134         unsigned char old_sha1[20];
 135         unsigned char new_sha1[20];
 136         char ref_name[FLEX_ARRAY]; /* more */
 137 };
 138
 139 static const char pre_receive_hook[] = "hooks/pre-receive";
 140 static const char post_receive_hook[] = "hooks/post-receive";
 141
 142 static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
 143 static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
 144
 145 static void report_message(const char *prefix, const char *err, va_list params)
 146 {
 147         int sz = strlen(prefix);
 148         char msg[4096];
 149
 150         strncpy(msg, prefix, sz);
 151         sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
 152         if (sz > (sizeof(msg) - 1))
 153                 sz = sizeof(msg) - 1;
 154         msg[sz++] = '\n';
 155
 156         if (use_sideband)
 157                 send_sideband(1, 2, msg, sz, use_sideband);
 158         else
 159                 xwrite(2, msg, sz);
 160 }
 161
 162 static void rp_warning(const char *err, ...)
 163 {
 164         va_list params;
 165         va_start(params, err);
 166         report_message("warning: ", err, params);
 167         va_end(params);
 168 }
 169
 170 static void rp_error(const char *err, ...)
 171 {
 172         va_list params;
 173         va_start(params, err);
 174         report_message("error: ", err, params);
 175         va_end(params);
 176 }
 177
 178 static int copy_to_sideband(int in, int out, void *arg)
 179 {
 180         char data[128];
 181         while (1) {
 182                 ssize_t sz = xread(in, data, sizeof(data));
 183                 if (sz <= 0)
 184                         break;
 185                 send_sideband(1, 2, data, sz, use_sideband);
 186         }
 187         close(in);
 188         return 0;
 189 }
 190
 191 static int run_receive_hook(struct command *commands, const char *hook_name)
 192 {
 193         static char buf[sizeof(commands->old_sha1) * 2 + PATH_MAX + 4];
 194         struct command *cmd;
 195         struct child_process proc;
 196         struct async muxer;
 197         const char *argv[2];
 198         int have_input = 0, code;
 199
 200         for (cmd = commands; !have_input && cmd; cmd = cmd->next) {
 201                 if (!cmd->error_string)
 202                         have_input = 1;
 203         }
 204
 205         if (!have_input || access(hook_name, X_OK) < 0)
 206                 return 0;
 207
 208         argv[0] = hook_name;
 209         argv[1] = NULL;
 210
 211         memset(&proc, 0, sizeof(proc));
 212         proc.argv = argv;
 213         proc.in = -1;
 214         proc.stdout_to_stderr = 1;
 215
 216         if (use_sideband) {
 217                 memset(&muxer, 0, sizeof(muxer));
 218                 muxer.proc = copy_to_sideband;
 219                 muxer.in = -1;
 220                 code = start_async(&muxer);
 221                 if (code)
 222                         return code;
 223                 proc.err = muxer.in;
 224         }
 225
 226         code = start_command(&proc);
 227         if (code) {
 228                 if (use_sideband)
 229                         finish_async(&muxer);
 230                 return code;
 231         }
 232
 233         for (cmd = commands; cmd; cmd = cmd->next) {
 234                 if (!cmd->error_string) {
 235                         size_t n = snprintf(buf, sizeof(buf), "%s %s %s\n",
 236                                 sha1_to_hex(cmd->old_sha1),
 237                                 sha1_to_hex(cmd->new_sha1),
 238                                 cmd->ref_name);
 239                         if (write_in_full(proc.in, buf, n) != n)
 240                                 break;
 241                 }
 242         }
 243         close(proc.in);
 244         if (use_sideband)
 245                 finish_async(&muxer);
 246         return finish_command(&proc);
 247 }
 248
 249 static int run_update_hook(struct command *cmd)
 250 {
 251         static const char update_hook[] = "hooks/update";
 252         const char *argv[5];
 253         struct child_process proc;
 254         int code;
 255
 256         if (access(update_hook, X_OK) < 0)
 257                 return 0;
 258
 259         argv[0] = update_hook;
 260         argv[1] = cmd->ref_name;
 261         argv[2] = sha1_to_hex(cmd->old_sha1);
 262         argv[3] = sha1_to_hex(cmd->new_sha1);
 263         argv[4] = NULL;
 264
 265         memset(&proc, 0, sizeof(proc));
 266         proc.no_stdin = 1;
 267         proc.stdout_to_stderr = 1;
 268         proc.err = use_sideband ? -1 : 0;
 269         proc.argv = argv;
 270
 271         code = start_command(&proc);
 272         if (code)
 273                 return code;
 274         if (use_sideband)
 275                 copy_to_sideband(proc.err, -1, NULL);
 276         return finish_command(&proc);
 277 }
 278
 279 static int is_ref_checked_out(const char *ref)
 280 {
 281         if (is_bare_repository())
 282                 return 0;
 283
 284         if (!head_name)
 285                 return 0;
 286         return !strcmp(head_name, ref);
 287 }
 288
 289 static char *refuse_unconfigured_deny_msg[] = {
 290         "By default, updating the current branch in a non-bare repository",
 291         "is denied, because it will make the index and work tree inconsistent",
 292         "with what you pushed, and will require 'git reset --hard' to match",
 293         "the work tree to HEAD.",
 294         "",
 295         "You can set 'receive.denyCurrentBranch' configuration variable to",
 296         "'ignore' or 'warn' in the remote repository to allow pushing into",
 297         "its current branch; however, this is not recommended unless you",
 298         "arranged to update its work tree to match what you pushed in some",
 299         "other way.",
 300         "",
 301         "To squelch this message and still keep the default behaviour, set",
 302         "'receive.denyCurrentBranch' configuration variable to 'refuse'."
 303 };
 304
 305 static void refuse_unconfigured_deny(void)
 306 {
 307         int i;
 308         for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
 309                 rp_error("%s", refuse_unconfigured_deny_msg[i]);
 310 }
 311
 312 static char *refuse_unconfigured_deny_delete_current_msg[] = {
 313         "By default, deleting the current branch is denied, because the next",
 314         "'git clone' won't result in any file checked out, causing confusion.",
 315         "",
 316         "You can set 'receive.denyDeleteCurrent' configuration variable to",
 317         "'warn' or 'ignore' in the remote repository to allow deleting the",
 318         "current branch, with or without a warning message.",
 319         "",
 320         "To squelch this message, you can set it to 'refuse'."
 321 };
 322
 323 static void refuse_unconfigured_deny_delete_current(void)
 324 {
 325         int i;
 326         for (i = 0;
 327              i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
 328              i++)
 329                 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
 330 }
 331
 332 static const char *update(struct command *cmd)
 333 {
 334         const char *name = cmd->ref_name;
 335         unsigned char *old_sha1 = cmd->old_sha1;
 336         unsigned char *new_sha1 = cmd->new_sha1;
 337         struct ref_lock *lock;
 338
 339         /* only refs/... are allowed */
 340         if (prefixcmp(name, "refs/") || check_ref_format(name + 5)) {
 341                 rp_error("refusing to create funny ref '%s' remotely", name);
 342                 return "funny refname";
 343         }
 344
 345         if (is_ref_checked_out(name)) {
 346                 switch (deny_current_branch) {
 347                 case DENY_IGNORE:
 348                         break;
 349                 case DENY_WARN:
 350                         rp_warning("updating the current branch");
 351                         break;
 352                 case DENY_REFUSE:
 353                 case DENY_UNCONFIGURED:
 354                         rp_error("refusing to update checked out branch: %s", name);
 355                         if (deny_current_branch == DENY_UNCONFIGURED)
 356                                 refuse_unconfigured_deny();
 357                         return "branch is currently checked out";
 358                 }
 359         }
 360
 361         if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
 362                 error("unpack should have generated %s, "
 363                       "but I can't find it!", sha1_to_hex(new_sha1));
 364                 return "bad pack";
 365         }
 366
 367         if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
 368                 if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
 369                         rp_error("denying ref deletion for %s", name);
 370                         return "deletion prohibited";
 371                 }
 372
 373                 if (!strcmp(name, head_name)) {
 374                         switch (deny_delete_current) {
 375                         case DENY_IGNORE:
 376                                 break;
 377                         case DENY_WARN:
 378                                 rp_warning("deleting the current branch");
 379                                 break;
 380                         case DENY_REFUSE:
 381                         case DENY_UNCONFIGURED:
 382                                 if (deny_delete_current == DENY_UNCONFIGURED)
 383                                         refuse_unconfigured_deny_delete_current();
 384                                 rp_error("refusing to delete the current branch: %s", name);
 385                                 return "deletion of the current branch prohibited";
 386                         }
 387                 }
 388         }
 389
 390         if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
 391             !is_null_sha1(old_sha1) &&
 392             !prefixcmp(name, "refs/heads/")) {
 393                 struct object *old_object, *new_object;
 394                 struct commit *old_commit, *new_commit;
 395                 struct commit_list *bases, *ent;
 396
 397                 old_object = parse_object(old_sha1);
 398                 new_object = parse_object(new_sha1);
 399
 400                 if (!old_object || !new_object ||
 401                     old_object->type != OBJ_COMMIT ||
 402                     new_object->type != OBJ_COMMIT) {
 403                         error("bad sha1 objects for %s", name);
 404                         return "bad ref";
 405                 }
 406                 old_commit = (struct commit *)old_object;
 407                 new_commit = (struct commit *)new_object;
 408                 bases = get_merge_bases(old_commit, new_commit, 1);
 409                 for (ent = bases; ent; ent = ent->next)
 410                         if (!hashcmp(old_sha1, ent->item->object.sha1))
 411                                 break;
 412                 free_commit_list(bases);
 413                 if (!ent) {
 414                         rp_error("denying non-fast-forward %s"
 415                                  " (you should pull first)", name);
 416                         return "non-fast-forward";
 417                 }
 418         }
 419         if (run_update_hook(cmd)) {
 420                 rp_error("hook declined to update %s", name);
 421                 return "hook declined";
 422         }
 423
 424         if (is_null_sha1(new_sha1)) {
 425                 if (!parse_object(old_sha1)) {
 426                         rp_warning("Allowing deletion of corrupt ref.");
 427                         old_sha1 = NULL;
 428                 }
 429                 if (delete_ref(name, old_sha1, 0)) {
 430                         rp_error("failed to delete %s", name);
 431                         return "failed to delete";
 432                 }
 433                 return NULL; /* good */
 434         }
 435         else {
 436                 lock = lock_any_ref_for_update(name, old_sha1, 0);
 437                 if (!lock) {
 438                         rp_error("failed to lock %s", name);
 439                         return "failed to lock";
 440                 }
 441                 if (write_ref_sha1(lock, new_sha1, "push")) {
 442                         return "failed to write"; /* error() already called */
 443                 }
 444                 return NULL; /* good */
 445         }
 446 }
 447
 448 static char update_post_hook[] = "hooks/post-update";
 449
 450 static void run_update_post_hook(struct command *commands)
 451 {
 452         struct command *cmd;
 453         int argc;
 454         const char **argv;
 455         struct child_process proc;
 456
 457         for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
 458                 if (cmd->error_string)
 459                         continue;
 460                 argc++;
 461         }
 462         if (!argc || access(update_post_hook, X_OK) < 0)
 463                 return;
 464         argv = xmalloc(sizeof(*argv) * (2 + argc));
 465         argv[0] = update_post_hook;
 466
 467         for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
 468                 char *p;
 469                 if (cmd->error_string)
 470                         continue;
 471                 p = xmalloc(strlen(cmd->ref_name) + 1);
 472                 strcpy(p, cmd->ref_name);
 473                 argv[argc] = p;
 474                 argc++;
 475         }
 476         argv[argc] = NULL;
 477
 478         memset(&proc, 0, sizeof(proc));
 479         proc.no_stdin = 1;
 480         proc.stdout_to_stderr = 1;
 481         proc.err = use_sideband ? -1 : 0;
 482         proc.argv = argv;
 483
 484         if (!start_command(&proc)) {
 485                 if (use_sideband)
 486                         copy_to_sideband(proc.err, -1, NULL);
 487                 finish_command(&proc);
 488         }
 489 }
 490
 491 static void check_aliased_update(struct command *cmd, struct string_list *list)
 492 {
 493         struct string_list_item *item;
 494         struct command *dst_cmd;
 495         unsigned char sha1[20];
 496         char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
 497         int flag;
 498
 499         const char *dst_name = resolve_ref(cmd->ref_name, sha1, 0, &flag);
 500
 501         if (!(flag & REF_ISSYMREF))
 502                 return;
 503
 504         if ((item = string_list_lookup(list, dst_name)) == NULL)
 505                 return;
 506
 507         cmd->skip_update = 1;
 508
 509         dst_cmd = (struct command *) item->util;
 510
 511         if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
 512             !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
 513                 return;
 514
 515         dst_cmd->skip_update = 1;
 516
 517         strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
 518         strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
 519         strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
 520         strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
 521         rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
 522                  " its target '%s' (%s..%s)",
 523                  cmd->ref_name, cmd_oldh, cmd_newh,
 524                  dst_cmd->ref_name, dst_oldh, dst_newh);
 525
 526         cmd->error_string = dst_cmd->error_string =
 527                 "inconsistent aliased update";
 528 }
 529
 530 static void check_aliased_updates(struct command *commands)
 531 {
 532         struct command *cmd;
 533         struct string_list ref_list = STRING_LIST_INIT_NODUP;
 534
 535         for (cmd = commands; cmd; cmd = cmd->next) {
 536                 struct string_list_item *item =
 537                         string_list_append(&ref_list, cmd->ref_name);
 538                 item->util = (void *)cmd;
 539         }
 540         sort_string_list(&ref_list);
 541
 542         for (cmd = commands; cmd; cmd = cmd->next)
 543                 check_aliased_update(cmd, &ref_list);
 544
 545         string_list_clear(&ref_list, 0);
 546 }
 547
 548 static void execute_commands(struct command *commands, const char *unpacker_error)
 549 {
 550         struct command *cmd;
 551         unsigned char sha1[20];
 552
 553         if (unpacker_error) {
 554                 for (cmd = commands; cmd; cmd = cmd->next)
 555                         cmd->error_string = "n/a (unpacker error)";
 556                 return;
 557         }
 558
 559         if (run_receive_hook(commands, pre_receive_hook)) {
 560                 for (cmd = commands; cmd; cmd = cmd->next)
 561                         cmd->error_string = "pre-receive hook declined";
 562                 return;
 563         }
 564
 565         check_aliased_updates(commands);
 566
 567         head_name = resolve_ref("HEAD", sha1, 0, NULL);
 568
 569         for (cmd = commands; cmd; cmd = cmd->next)
 570                 if (!cmd->skip_update)
 571                         cmd->error_string = update(cmd);
 572 }
 573
 574 static struct command *read_head_info(void)
 575 {
 576         struct command *commands = NULL;
 577         struct command **p = &commands;
 578         for (;;) {
 579                 static char line[1000];
 580                 unsigned char old_sha1[20], new_sha1[20];
 581                 struct command *cmd;
 582                 char *refname;
 583                 int len, reflen;
 584
 585                 len = packet_read_line(0, line, sizeof(line));
 586                 if (!len)
 587                         break;
 588                 if (line[len-1] == '\n')
 589                         line[--len] = 0;
 590                 if (len < 83 ||
 591                     line[40] != ' ' ||
 592                     line[81] != ' ' ||
 593                     get_sha1_hex(line, old_sha1) ||
 594                     get_sha1_hex(line + 41, new_sha1))
 595                         die("protocol error: expected old/new/ref, got '%s'",
 596                             line);
 597
 598                 refname = line + 82;
 599                 reflen = strlen(refname);
 600                 if (reflen + 82 < len) {
 601                         if (strstr(refname + reflen + 1, "report-status"))
 602                                 report_status = 1;
 603                         if (strstr(refname + reflen + 1, "side-band-64k"))
 604                                 use_sideband = LARGE_PACKET_MAX;
 605                 }
 606                 cmd = xcalloc(1, sizeof(struct command) + len - 80);
 607                 hashcpy(cmd->old_sha1, old_sha1);
 608                 hashcpy(cmd->new_sha1, new_sha1);
 609                 memcpy(cmd->ref_name, line + 82, len - 81);
 610                 *p = cmd;
 611                 p = &cmd->next;
 612         }
 613         return commands;
 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(struct command *commands, 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 *commands)
 725 {
 726         struct command *cmd;
 727         for (cmd = commands; cmd; cmd = cmd->next) {
 728                 if (!is_null_sha1(cmd->new_sha1))
 729                         return 0;
 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(real_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         struct command *commands;
 780
 781         argv++;
 782         for (i = 1; i < argc; i++) {
 783                 const char *arg = *argv++;
 784
 785                 if (*arg == '-') {
 786                         if (!strcmp(arg, "--advertise-refs")) {
 787                                 advertise_refs = 1;
 788                                 continue;
 789                         }
 790                         if (!strcmp(arg, "--stateless-rpc")) {
 791                                 stateless_rpc = 1;
 792                                 continue;
 793                         }
 794
 795                         usage(receive_pack_usage);
 796                 }
 797                 if (dir)
 798                         usage(receive_pack_usage);
 799                 dir = xstrdup(arg);
 800         }
 801         if (!dir)
 802                 usage(receive_pack_usage);
 803
 804         setup_path();
 805
 806         if (!enter_repo(dir, 0))
 807                 die("'%s' does not appear to be a git repository", dir);
 808
 809         if (is_repository_shallow())
 810                 die("attempt to push into a shallow repository");
 811
 812         git_config(receive_pack_config, NULL);
 813
 814         if (0 <= transfer_unpack_limit)
 815                 unpack_limit = transfer_unpack_limit;
 816         else if (0 <= receive_unpack_limit)
 817                 unpack_limit = receive_unpack_limit;
 818
 819         if (advertise_refs || !stateless_rpc) {
 820                 add_alternate_refs();
 821                 write_head_info();
 822                 clear_extra_refs();
 823
 824                 /* EOF */
 825                 packet_flush(1);
 826         }
 827         if (advertise_refs)
 828                 return 0;
 829
 830         if ((commands = read_head_info()) != NULL) {
 831                 const char *unpack_status = NULL;
 832
 833                 if (!delete_only(commands))
 834                         unpack_status = unpack();
 835                 execute_commands(commands, unpack_status);
 836                 if (pack_lockfile)
 837                         unlink_or_warn(pack_lockfile);
 838                 if (report_status)
 839                         report(commands, unpack_status);
 840                 run_receive_hook(commands, 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 }