builtin/receive-pack.c

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