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