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