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