builtin/receive-pack.c

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