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