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