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