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                 if (!cmd->error_string)
 647                         check_aliased_update(cmd, &ref_list);
 648         }
 649
 650         string_list_clear(&ref_list, 0);
 651 }
 652
 653 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
 654 {
 655         struct command **cmd_list = cb_data;
 656         struct command *cmd = *cmd_list;
 657
 658         if (!cmd || is_null_sha1(cmd->new_sha1))
 659                 return -1; /* end of list */
 660         *cmd_list = NULL; /* this returns only one */
 661         hashcpy(sha1, cmd->new_sha1);
 662         return 0;
 663 }
 664
 665 static void set_connectivity_errors(struct command *commands)
 666 {
 667         struct command *cmd;
 668
 669         for (cmd = commands; cmd; cmd = cmd->next) {
 670                 struct command *singleton = cmd;
 671                 if (!check_everything_connected(command_singleton_iterator,
 672                                                 0, &singleton))
 673                         continue;
 674                 cmd->error_string = "missing necessary objects";
 675         }
 676 }
 677
 678 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
 679 {
 680         struct command **cmd_list = cb_data;
 681         struct command *cmd = *cmd_list;
 682
 683         while (cmd) {
 684                 if (!is_null_sha1(cmd->new_sha1)) {
 685                         hashcpy(sha1, cmd->new_sha1);
 686                         *cmd_list = cmd->next;
 687                         return 0;
 688                 }
 689                 cmd = cmd->next;
 690         }
 691         *cmd_list = NULL;
 692         return -1; /* end of list */
 693 }
 694
 695 static void execute_commands(struct command *commands, const char *unpacker_error)
 696 {
 697         struct command *cmd;
 698         unsigned char sha1[20];
 699
 700         if (unpacker_error) {
 701                 for (cmd = commands; cmd; cmd = cmd->next)
 702                         cmd->error_string = "n/a (unpacker error)";
 703                 return;
 704         }
 705
 706         cmd = commands;
 707         if (check_everything_connected(iterate_receive_command_list,
 708                                        0, &cmd))
 709                 set_connectivity_errors(commands);
 710
 711         if (run_receive_hook(commands, pre_receive_hook, 0)) {
 712                 for (cmd = commands; cmd; cmd = cmd->next) {
 713                         if (!cmd->error_string)
 714                                 cmd->error_string = "pre-receive hook declined";
 715                 }
 716                 return;
 717         }
 718
 719         check_aliased_updates(commands);
 720
 721         free(head_name_to_free);
 722         head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
 723
 724         for (cmd = commands; cmd; cmd = cmd->next) {
 725                 if (cmd->error_string)
 726                         continue;
 727
 728                 if (cmd->skip_update)
 729                         continue;
 730
 731                 cmd->error_string = update(cmd);
 732         }
 733 }
 734
 735 static struct command *read_head_info(void)
 736 {
 737         struct command *commands = NULL;
 738         struct command **p = &commands;
 739         for (;;) {
 740                 static char line[1000];
 741                 unsigned char old_sha1[20], new_sha1[20];
 742                 struct command *cmd;
 743                 char *refname;
 744                 int len, reflen;
 745
 746                 len = packet_read_line(0, line, sizeof(line));
 747                 if (!len)
 748                         break;
 749                 if (line[len-1] == '\n')
 750                         line[--len] = 0;
 751                 if (len < 83 ||
 752                     line[40] != ' ' ||
 753                     line[81] != ' ' ||
 754                     get_sha1_hex(line, old_sha1) ||
 755                     get_sha1_hex(line + 41, new_sha1))
 756                         die("protocol error: expected old/new/ref, got '%s'",
 757                             line);
 758
 759                 refname = line + 82;
 760                 reflen = strlen(refname);
 761                 if (reflen + 82 < len) {
 762                         const char *feature_list = refname + reflen + 1;
 763                         if (parse_feature_request(feature_list, "report-status"))
 764                                 report_status = 1;
 765                         if (parse_feature_request(feature_list, "side-band-64k"))
 766                                 use_sideband = LARGE_PACKET_MAX;
 767                         if (parse_feature_request(feature_list, "quiet"))
 768                                 quiet = 1;
 769                 }
 770                 cmd = xcalloc(1, sizeof(struct command) + len - 80);
 771                 hashcpy(cmd->old_sha1, old_sha1);
 772                 hashcpy(cmd->new_sha1, new_sha1);
 773                 memcpy(cmd->ref_name, line + 82, len - 81);
 774                 *p = cmd;
 775                 p = &cmd->next;
 776         }
 777         return commands;
 778 }
 779
 780 static const char *parse_pack_header(struct pack_header *hdr)
 781 {
 782         switch (read_pack_header(0, hdr)) {
 783         case PH_ERROR_EOF:
 784                 return "eof before pack header was fully read";
 785
 786         case PH_ERROR_PACK_SIGNATURE:
 787                 return "protocol error (pack signature mismatch detected)";
 788
 789         case PH_ERROR_PROTOCOL:
 790                 return "protocol error (pack version unsupported)";
 791
 792         default:
 793                 return "unknown error in parse_pack_header";
 794
 795         case 0:
 796                 return NULL;
 797         }
 798 }
 799
 800 static const char *pack_lockfile;
 801
 802 static const char *unpack(void)
 803 {
 804         struct pack_header hdr;
 805         const char *hdr_err;
 806         char hdr_arg[38];
 807         int fsck_objects = (receive_fsck_objects >= 0
 808                             ? receive_fsck_objects
 809                             : transfer_fsck_objects >= 0
 810                             ? transfer_fsck_objects
 811                             : 0);
 812
 813         hdr_err = parse_pack_header(&hdr);
 814         if (hdr_err)
 815                 return hdr_err;
 816         snprintf(hdr_arg, sizeof(hdr_arg),
 817                         "--pack_header=%"PRIu32",%"PRIu32,
 818                         ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
 819
 820         if (ntohl(hdr.hdr_entries) < unpack_limit) {
 821                 int code, i = 0;
 822                 const char *unpacker[5];
 823                 unpacker[i++] = "unpack-objects";
 824                 if (quiet)
 825                         unpacker[i++] = "-q";
 826                 if (fsck_objects)
 827                         unpacker[i++] = "--strict";
 828                 unpacker[i++] = hdr_arg;
 829                 unpacker[i++] = NULL;
 830                 code = run_command_v_opt(unpacker, RUN_GIT_CMD);
 831                 if (!code)
 832                         return NULL;
 833                 return "unpack-objects abnormal exit";
 834         } else {
 835                 const char *keeper[7];
 836                 int s, status, i = 0;
 837                 char keep_arg[256];
 838                 struct child_process ip;
 839
 840                 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
 841                 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 842                         strcpy(keep_arg + s, "localhost");
 843
 844                 keeper[i++] = "index-pack";
 845                 keeper[i++] = "--stdin";
 846                 if (fsck_objects)
 847                         keeper[i++] = "--strict";
 848                 keeper[i++] = "--fix-thin";
 849                 keeper[i++] = hdr_arg;
 850                 keeper[i++] = keep_arg;
 851                 keeper[i++] = NULL;
 852                 memset(&ip, 0, sizeof(ip));
 853                 ip.argv = keeper;
 854                 ip.out = -1;
 855                 ip.git_cmd = 1;
 856                 status = start_command(&ip);
 857                 if (status) {
 858                         return "index-pack fork failed";
 859                 }
 860                 pack_lockfile = index_pack_lockfile(ip.out);
 861                 close(ip.out);
 862                 status = finish_command(&ip);
 863                 if (!status) {
 864                         reprepare_packed_git();
 865                         return NULL;
 866                 }
 867                 return "index-pack abnormal exit";
 868         }
 869 }
 870
 871 static void report(struct command *commands, const char *unpack_status)
 872 {
 873         struct command *cmd;
 874         struct strbuf buf = STRBUF_INIT;
 875
 876         packet_buf_write(&buf, "unpack %s\n",
 877                          unpack_status ? unpack_status : "ok");
 878         for (cmd = commands; cmd; cmd = cmd->next) {
 879                 if (!cmd->error_string)
 880                         packet_buf_write(&buf, "ok %s\n",
 881                                          cmd->ref_name);
 882                 else
 883                         packet_buf_write(&buf, "ng %s %s\n",
 884                                          cmd->ref_name, cmd->error_string);
 885         }
 886         packet_buf_flush(&buf);
 887
 888         if (use_sideband)
 889                 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
 890         else
 891                 safe_write(1, buf.buf, buf.len);
 892         strbuf_release(&buf);
 893 }
 894
 895 static int delete_only(struct command *commands)
 896 {
 897         struct command *cmd;
 898         for (cmd = commands; cmd; cmd = cmd->next) {
 899                 if (!is_null_sha1(cmd->new_sha1))
 900                         return 0;
 901         }
 902         return 1;
 903 }
 904
 905 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
 906 {
 907         int advertise_refs = 0;
 908         int stateless_rpc = 0;
 909         int i;
 910         char *dir = NULL;
 911         struct command *commands;
 912
 913         packet_trace_identity("receive-pack");
 914
 915         argv++;
 916         for (i = 1; i < argc; i++) {
 917                 const char *arg = *argv++;
 918
 919                 if (*arg == '-') {
 920                         if (!strcmp(arg, "--quiet")) {
 921                                 quiet = 1;
 922                                 continue;
 923                         }
 924
 925                         if (!strcmp(arg, "--advertise-refs")) {
 926                                 advertise_refs = 1;
 927                                 continue;
 928                         }
 929                         if (!strcmp(arg, "--stateless-rpc")) {
 930                                 stateless_rpc = 1;
 931                                 continue;
 932                         }
 933
 934                         usage(receive_pack_usage);
 935                 }
 936                 if (dir)
 937                         usage(receive_pack_usage);
 938                 dir = xstrdup(arg);
 939         }
 940         if (!dir)
 941                 usage(receive_pack_usage);
 942
 943         setup_path();
 944
 945         if (!enter_repo(dir, 0))
 946                 die("'%s' does not appear to be a git repository", dir);
 947
 948         if (is_repository_shallow())
 949                 die("attempt to push into a shallow repository");
 950
 951         git_config(receive_pack_config, NULL);
 952
 953         if (0 <= transfer_unpack_limit)
 954                 unpack_limit = transfer_unpack_limit;
 955         else if (0 <= receive_unpack_limit)
 956                 unpack_limit = receive_unpack_limit;
 957
 958         if (advertise_refs || !stateless_rpc) {
 959                 write_head_info();
 960         }
 961         if (advertise_refs)
 962                 return 0;
 963
 964         if ((commands = read_head_info()) != NULL) {
 965                 const char *unpack_status = NULL;
 966
 967                 if (!delete_only(commands))
 968                         unpack_status = unpack();
 969                 execute_commands(commands, unpack_status);
 970                 if (pack_lockfile)
 971                         unlink_or_warn(pack_lockfile);
 972                 if (report_status)
 973                         report(commands, unpack_status);
 974                 run_receive_hook(commands, post_receive_hook, 1);
 975                 run_update_post_hook(commands);
 976                 if (auto_gc) {
 977                         const char *argv_gc_auto[] = {
 978                                 "gc", "--auto", "--quiet", NULL,
 979                         };
 980                         run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
 981                 }
 982                 if (auto_update_server_info)
 983                         update_server_info(0);
 984         }
 985         if (use_sideband)
 986                 packet_flush(1);
 987         return 0;
 988 }