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