builtin/receive-pack.c

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