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