git.oblomov.eu Git - git/blob - builtin/receive-pack.c

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