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