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 int sent_capabilities;
  41
  42 static enum deny_action parse_deny_action(const char *var, const char *value)
  43 {
  44         if (value) {
  45                 if (!strcasecmp(value, "ignore"))
  46                         return DENY_IGNORE;
  47                 if (!strcasecmp(value, "warn"))
  48                         return DENY_WARN;
  49                 if (!strcasecmp(value, "refuse"))
  50                         return DENY_REFUSE;
  51         }
  52         if (git_config_bool(var, value))
  53                 return DENY_REFUSE;
  54         return DENY_IGNORE;
  55 }
  56
  57 static int receive_pack_config(const char *var, const char *value, void *cb)
  58 {
  59         if (strcmp(var, "receive.denydeletes") == 0) {
  60                 deny_deletes = git_config_bool(var, value);
  61                 return 0;
  62         }
  63
  64         if (strcmp(var, "receive.denynonfastforwards") == 0) {
  65                 deny_non_fast_forwards = git_config_bool(var, value);
  66                 return 0;
  67         }
  68
  69         if (strcmp(var, "receive.unpacklimit") == 0) {
  70                 receive_unpack_limit = git_config_int(var, value);
  71                 return 0;
  72         }
  73
  74         if (strcmp(var, "transfer.unpacklimit") == 0) {
  75                 transfer_unpack_limit = git_config_int(var, value);
  76                 return 0;
  77         }
  78
  79         if (strcmp(var, "receive.fsckobjects") == 0) {
  80                 receive_fsck_objects = git_config_bool(var, value);
  81                 return 0;
  82         }
  83
  84         if (strcmp(var, "transfer.fsckobjects") == 0) {
  85                 transfer_fsck_objects = git_config_bool(var, value);
  86                 return 0;
  87         }
  88
  89         if (!strcmp(var, "receive.denycurrentbranch")) {
  90                 deny_current_branch = parse_deny_action(var, value);
  91                 return 0;
  92         }
  93
  94         if (strcmp(var, "receive.denydeletecurrent") == 0) {
  95                 deny_delete_current = parse_deny_action(var, value);
  96                 return 0;
  97         }
  98
  99         if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
 100                 prefer_ofs_delta = git_config_bool(var, value);
 101                 return 0;
 102         }
 103
 104         if (strcmp(var, "receive.updateserverinfo") == 0) {
 105                 auto_update_server_info = git_config_bool(var, value);
 106                 return 0;
 107         }
 108
 109         if (strcmp(var, "receive.autogc") == 0) {
 110                 auto_gc = git_config_bool(var, value);
 111                 return 0;
 112         }
 113
 114         return git_default_config(var, value, cb);
 115 }
 116
 117 static int show_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
 118 {
 119         if (sent_capabilities)
 120                 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
 121         else
 122                 packet_write(1, "%s %s%c%s%s\n",
 123                              sha1_to_hex(sha1), path, 0,
 124                              " report-status delete-refs side-band-64k",
 125                              prefer_ofs_delta ? " ofs-delta" : "");
 126         sent_capabilities = 1;
 127         return 0;
 128 }
 129
 130 static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *cb_data)
 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         return show_ref(path, sha1, flag, cb_data);
 144 }
 145
 146 static void add_one_alternate_sha1(const unsigned char sha1[20], void *unused)
 147 {
 148         add_extra_ref(".have", sha1, 0);
 149 }
 150
 151 static void collect_one_alternate_ref(const struct ref *ref, void *data)
 152 {
 153         struct sha1_array *sa = data;
 154         sha1_array_append(sa, ref->old_sha1);
 155 }
 156
 157 static void write_head_info(void)
 158 {
 159         struct sha1_array sa = SHA1_ARRAY_INIT;
 160         for_each_alternate_ref(collect_one_alternate_ref, &sa);
 161         sha1_array_for_each_unique(&sa, add_one_alternate_sha1, NULL);
 162         sha1_array_clear(&sa);
 163         for_each_ref(show_ref_cb, NULL);
 164         if (!sent_capabilities)
 165                 show_ref("capabilities^{}", null_sha1, 0, NULL);
 166         clear_extra_refs();
 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(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((char *)head_name);
 717         head_name = resolve_ref("HEAD", sha1, 0, NULL);
 718         if (head_name)
 719                 head_name = xstrdup(head_name);
 720
 721         for (cmd = commands; cmd; cmd = cmd->next)
 722                 if (!cmd->skip_update)
 723                         cmd->error_string = update(cmd);
 724 }
 725
 726 static struct command *read_head_info(void)
 727 {
 728         struct command *commands = NULL;
 729         struct command **p = &commands;
 730         for (;;) {
 731                 static char line[1000];
 732                 unsigned char old_sha1[20], new_sha1[20];
 733                 struct command *cmd;
 734                 char *refname;
 735                 int len, reflen;
 736
 737                 len = packet_read_line(0, line, sizeof(line));
 738                 if (!len)
 739                         break;
 740                 if (line[len-1] == '\n')
 741                         line[--len] = 0;
 742                 if (len < 83 ||
 743                     line[40] != ' ' ||
 744                     line[81] != ' ' ||
 745                     get_sha1_hex(line, old_sha1) ||
 746                     get_sha1_hex(line + 41, new_sha1))
 747                         die("protocol error: expected old/new/ref, got '%s'",
 748                             line);
 749
 750                 refname = line + 82;
 751                 reflen = strlen(refname);
 752                 if (reflen + 82 < len) {
 753                         if (strstr(refname + reflen + 1, "report-status"))
 754                                 report_status = 1;
 755                         if (strstr(refname + reflen + 1, "side-band-64k"))
 756                                 use_sideband = LARGE_PACKET_MAX;
 757                 }
 758                 cmd = xcalloc(1, sizeof(struct command) + len - 80);
 759                 hashcpy(cmd->old_sha1, old_sha1);
 760                 hashcpy(cmd->new_sha1, new_sha1);
 761                 memcpy(cmd->ref_name, line + 82, len - 81);
 762                 *p = cmd;
 763                 p = &cmd->next;
 764         }
 765         return commands;
 766 }
 767
 768 static const char *parse_pack_header(struct pack_header *hdr)
 769 {
 770         switch (read_pack_header(0, hdr)) {
 771         case PH_ERROR_EOF:
 772                 return "eof before pack header was fully read";
 773
 774         case PH_ERROR_PACK_SIGNATURE:
 775                 return "protocol error (pack signature mismatch detected)";
 776
 777         case PH_ERROR_PROTOCOL:
 778                 return "protocol error (pack version unsupported)";
 779
 780         default:
 781                 return "unknown error in parse_pack_header";
 782
 783         case 0:
 784                 return NULL;
 785         }
 786 }
 787
 788 static const char *pack_lockfile;
 789
 790 static const char *unpack(void)
 791 {
 792         struct pack_header hdr;
 793         const char *hdr_err;
 794         char hdr_arg[38];
 795         int fsck_objects = (receive_fsck_objects >= 0
 796                             ? receive_fsck_objects
 797                             : transfer_fsck_objects >= 0
 798                             ? transfer_fsck_objects
 799                             : 0);
 800
 801         hdr_err = parse_pack_header(&hdr);
 802         if (hdr_err)
 803                 return hdr_err;
 804         snprintf(hdr_arg, sizeof(hdr_arg),
 805                         "--pack_header=%"PRIu32",%"PRIu32,
 806                         ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
 807
 808         if (ntohl(hdr.hdr_entries) < unpack_limit) {
 809                 int code, i = 0;
 810                 const char *unpacker[4];
 811                 unpacker[i++] = "unpack-objects";
 812                 if (fsck_objects)
 813                         unpacker[i++] = "--strict";
 814                 unpacker[i++] = hdr_arg;
 815                 unpacker[i++] = NULL;
 816                 code = run_command_v_opt(unpacker, RUN_GIT_CMD);
 817                 if (!code)
 818                         return NULL;
 819                 return "unpack-objects abnormal exit";
 820         } else {
 821                 const char *keeper[7];
 822                 int s, status, i = 0;
 823                 char keep_arg[256];
 824                 struct child_process ip;
 825
 826                 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
 827                 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 828                         strcpy(keep_arg + s, "localhost");
 829
 830                 keeper[i++] = "index-pack";
 831                 keeper[i++] = "--stdin";
 832                 if (fsck_objects)
 833                         keeper[i++] = "--strict";
 834                 keeper[i++] = "--fix-thin";
 835                 keeper[i++] = hdr_arg;
 836                 keeper[i++] = keep_arg;
 837                 keeper[i++] = NULL;
 838                 memset(&ip, 0, sizeof(ip));
 839                 ip.argv = keeper;
 840                 ip.out = -1;
 841                 ip.git_cmd = 1;
 842                 status = start_command(&ip);
 843                 if (status) {
 844                         return "index-pack fork failed";
 845                 }
 846                 pack_lockfile = index_pack_lockfile(ip.out);
 847                 close(ip.out);
 848                 status = finish_command(&ip);
 849                 if (!status) {
 850                         reprepare_packed_git();
 851                         return NULL;
 852                 }
 853                 return "index-pack abnormal exit";
 854         }
 855 }
 856
 857 static void report(struct command *commands, const char *unpack_status)
 858 {
 859         struct command *cmd;
 860         struct strbuf buf = STRBUF_INIT;
 861
 862         packet_buf_write(&buf, "unpack %s\n",
 863                          unpack_status ? unpack_status : "ok");
 864         for (cmd = commands; cmd; cmd = cmd->next) {
 865                 if (!cmd->error_string)
 866                         packet_buf_write(&buf, "ok %s\n",
 867                                          cmd->ref_name);
 868                 else
 869                         packet_buf_write(&buf, "ng %s %s\n",
 870                                          cmd->ref_name, cmd->error_string);
 871         }
 872         packet_buf_flush(&buf);
 873
 874         if (use_sideband)
 875                 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
 876         else
 877                 safe_write(1, buf.buf, buf.len);
 878         strbuf_release(&buf);
 879 }
 880
 881 static int delete_only(struct command *commands)
 882 {
 883         struct command *cmd;
 884         for (cmd = commands; cmd; cmd = cmd->next) {
 885                 if (!is_null_sha1(cmd->new_sha1))
 886                         return 0;
 887         }
 888         return 1;
 889 }
 890
 891 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
 892 {
 893         int advertise_refs = 0;
 894         int stateless_rpc = 0;
 895         int i;
 896         char *dir = NULL;
 897         struct command *commands;
 898
 899         packet_trace_identity("receive-pack");
 900
 901         argv++;
 902         for (i = 1; i < argc; i++) {
 903                 const char *arg = *argv++;
 904
 905                 if (*arg == '-') {
 906                         if (!strcmp(arg, "--advertise-refs")) {
 907                                 advertise_refs = 1;
 908                                 continue;
 909                         }
 910                         if (!strcmp(arg, "--stateless-rpc")) {
 911                                 stateless_rpc = 1;
 912                                 continue;
 913                         }
 914
 915                         usage(receive_pack_usage);
 916                 }
 917                 if (dir)
 918                         usage(receive_pack_usage);
 919                 dir = xstrdup(arg);
 920         }
 921         if (!dir)
 922                 usage(receive_pack_usage);
 923
 924         setup_path();
 925
 926         if (!enter_repo(dir, 0))
 927                 die("'%s' does not appear to be a git repository", dir);
 928
 929         if (is_repository_shallow())
 930                 die("attempt to push into a shallow repository");
 931
 932         git_config(receive_pack_config, NULL);
 933
 934         if (0 <= transfer_unpack_limit)
 935                 unpack_limit = transfer_unpack_limit;
 936         else if (0 <= receive_unpack_limit)
 937                 unpack_limit = receive_unpack_limit;
 938
 939         if (advertise_refs || !stateless_rpc) {
 940                 write_head_info();
 941         }
 942         if (advertise_refs)
 943                 return 0;
 944
 945         if ((commands = read_head_info()) != NULL) {
 946                 const char *unpack_status = NULL;
 947
 948                 if (!delete_only(commands))
 949                         unpack_status = unpack();
 950                 execute_commands(commands, unpack_status);
 951                 if (pack_lockfile)
 952                         unlink_or_warn(pack_lockfile);
 953                 if (report_status)
 954                         report(commands, unpack_status);
 955                 run_receive_hook(commands, post_receive_hook, 1);
 956                 run_update_post_hook(commands);
 957                 if (auto_gc) {
 958                         const char *argv_gc_auto[] = {
 959                                 "gc", "--auto", "--quiet", NULL,
 960                         };
 961                         run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
 962                 }
 963                 if (auto_update_server_info)
 964                         update_server_info(0);
 965         }
 966         if (use_sideband)
 967                 packet_flush(1);
 968         return 0;
 969 }