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(int quiet)
 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 (quiet)
 657                         unpacker[i++] = "-q";
 658                 if (receive_fsck_objects)
 659                         unpacker[i++] = "--strict";
 660                 unpacker[i++] = hdr_arg;
 661                 unpacker[i++] = NULL;
 662                 code = run_command_v_opt(unpacker, RUN_GIT_CMD);
 663                 if (!code)
 664                         return NULL;
 665                 return "unpack-objects abnormal exit";
 666         } else {
 667                 const char *keeper[7];
 668                 int s, status, i = 0;
 669                 char keep_arg[256];
 670                 struct child_process ip;
 671
 672                 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
 673                 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 674                         strcpy(keep_arg + s, "localhost");
 675
 676                 keeper[i++] = "index-pack";
 677                 keeper[i++] = "--stdin";
 678                 if (receive_fsck_objects)
 679                         keeper[i++] = "--strict";
 680                 keeper[i++] = "--fix-thin";
 681                 keeper[i++] = hdr_arg;
 682                 keeper[i++] = keep_arg;
 683                 keeper[i++] = NULL;
 684                 memset(&ip, 0, sizeof(ip));
 685                 ip.argv = keeper;
 686                 ip.out = -1;
 687                 ip.git_cmd = 1;
 688                 status = start_command(&ip);
 689                 if (status) {
 690                         return "index-pack fork failed";
 691                 }
 692                 pack_lockfile = index_pack_lockfile(ip.out);
 693                 close(ip.out);
 694                 status = finish_command(&ip);
 695                 if (!status) {
 696                         reprepare_packed_git();
 697                         return NULL;
 698                 }
 699                 return "index-pack abnormal exit";
 700         }
 701 }
 702
 703 static void report(struct command *commands, const char *unpack_status)
 704 {
 705         struct command *cmd;
 706         struct strbuf buf = STRBUF_INIT;
 707
 708         packet_buf_write(&buf, "unpack %s\n",
 709                          unpack_status ? unpack_status : "ok");
 710         for (cmd = commands; cmd; cmd = cmd->next) {
 711                 if (!cmd->error_string)
 712                         packet_buf_write(&buf, "ok %s\n",
 713                                          cmd->ref_name);
 714                 else
 715                         packet_buf_write(&buf, "ng %s %s\n",
 716                                          cmd->ref_name, cmd->error_string);
 717         }
 718         packet_buf_flush(&buf);
 719
 720         if (use_sideband)
 721                 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
 722         else
 723                 safe_write(1, buf.buf, buf.len);
 724         strbuf_release(&buf);
 725 }
 726
 727 static int delete_only(struct command *commands)
 728 {
 729         struct command *cmd;
 730         for (cmd = commands; cmd; cmd = cmd->next) {
 731                 if (!is_null_sha1(cmd->new_sha1))
 732                         return 0;
 733         }
 734         return 1;
 735 }
 736
 737 static void add_one_alternate_sha1(const unsigned char sha1[20], void *unused)
 738 {
 739         add_extra_ref(".have", sha1, 0);
 740 }
 741
 742 static void collect_one_alternate_ref(const struct ref *ref, void *data)
 743 {
 744         struct sha1_array *sa = data;
 745         sha1_array_append(sa, ref->old_sha1);
 746 }
 747
 748 static void add_alternate_refs(void)
 749 {
 750         struct sha1_array sa = SHA1_ARRAY_INIT;
 751         for_each_alternate_ref(collect_one_alternate_ref, &sa);
 752         sha1_array_for_each_unique(&sa, add_one_alternate_sha1, NULL);
 753         sha1_array_clear(&sa);
 754 }
 755
 756 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
 757 {
 758         int quiet = 0;
 759         int advertise_refs = 0;
 760         int stateless_rpc = 0;
 761         int i;
 762         char *dir = NULL;
 763         struct command *commands;
 764
 765         packet_trace_identity("receive-pack");
 766
 767         argv++;
 768         for (i = 1; i < argc; i++) {
 769                 const char *arg = *argv++;
 770
 771                 if (*arg == '-') {
 772                         if (!strcmp(arg, "--quiet")) {
 773                                 quiet = 1;
 774                                 continue;
 775                         }
 776
 777                         if (!strcmp(arg, "--advertise-refs")) {
 778                                 advertise_refs = 1;
 779                                 continue;
 780                         }
 781                         if (!strcmp(arg, "--stateless-rpc")) {
 782                                 stateless_rpc = 1;
 783                                 continue;
 784                         }
 785
 786                         usage(receive_pack_usage);
 787                 }
 788                 if (dir)
 789                         usage(receive_pack_usage);
 790                 dir = xstrdup(arg);
 791         }
 792         if (!dir)
 793                 usage(receive_pack_usage);
 794
 795         setup_path();
 796
 797         if (!enter_repo(dir, 0))
 798                 die("'%s' does not appear to be a git repository", dir);
 799
 800         if (is_repository_shallow())
 801                 die("attempt to push into a shallow repository");
 802
 803         git_config(receive_pack_config, NULL);
 804
 805         if (0 <= transfer_unpack_limit)
 806                 unpack_limit = transfer_unpack_limit;
 807         else if (0 <= receive_unpack_limit)
 808                 unpack_limit = receive_unpack_limit;
 809
 810         if (advertise_refs || !stateless_rpc) {
 811                 add_alternate_refs();
 812                 write_head_info();
 813                 clear_extra_refs();
 814
 815                 /* EOF */
 816                 packet_flush(1);
 817         }
 818         if (advertise_refs)
 819                 return 0;
 820
 821         if ((commands = read_head_info()) != NULL) {
 822                 const char *unpack_status = NULL;
 823
 824                 if (!delete_only(commands))
 825                         unpack_status = unpack(quiet);
 826                 execute_commands(commands, unpack_status);
 827                 if (pack_lockfile)
 828                         unlink_or_warn(pack_lockfile);
 829                 if (report_status)
 830                         report(commands, unpack_status);
 831                 run_receive_hook(commands, post_receive_hook);
 832                 run_update_post_hook(commands);
 833                 if (auto_gc) {
 834                         const char *argv_gc_auto[] = {
 835                                 "gc", "--auto", "--quiet", NULL,
 836                         };
 837                         run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
 838                 }
 839                 if (auto_update_server_info)
 840                         update_server_info(0);
 841         }
 842         if (use_sideband)
 843                 packet_flush(1);
 844         return 0;
 845 }