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