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