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