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