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