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                         if (strstr(refname + reflen + 1, "report-status"))
 735                                 report_status = 1;
 736                         if (strstr(refname + reflen + 1, "side-band-64k"))
 737                                 use_sideband = LARGE_PACKET_MAX;
 738                 }
 739                 cmd = xcalloc(1, sizeof(struct command) + len - 80);
 740                 hashcpy(cmd->old_sha1, old_sha1);
 741                 hashcpy(cmd->new_sha1, new_sha1);
 742                 memcpy(cmd->ref_name, line + 82, len - 81);
 743                 *p = cmd;
 744                 p = &cmd->next;
 745         }
 746         return commands;
 747 }
 748
 749 static const char *parse_pack_header(struct pack_header *hdr)
 750 {
 751         switch (read_pack_header(0, hdr)) {
 752         case PH_ERROR_EOF:
 753                 return "eof before pack header was fully read";
 754
 755         case PH_ERROR_PACK_SIGNATURE:
 756                 return "protocol error (pack signature mismatch detected)";
 757
 758         case PH_ERROR_PROTOCOL:
 759                 return "protocol error (pack version unsupported)";
 760
 761         default:
 762                 return "unknown error in parse_pack_header";
 763
 764         case 0:
 765                 return NULL;
 766         }
 767 }
 768
 769 static const char *pack_lockfile;
 770
 771 static const char *unpack(void)
 772 {
 773         struct pack_header hdr;
 774         const char *hdr_err;
 775         char hdr_arg[38];
 776         int fsck_objects = (receive_fsck_objects >= 0
 777                             ? receive_fsck_objects
 778                             : transfer_fsck_objects >= 0
 779                             ? transfer_fsck_objects
 780                             : 0);
 781
 782         hdr_err = parse_pack_header(&hdr);
 783         if (hdr_err)
 784                 return hdr_err;
 785         snprintf(hdr_arg, sizeof(hdr_arg),
 786                         "--pack_header=%"PRIu32",%"PRIu32,
 787                         ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
 788
 789         if (ntohl(hdr.hdr_entries) < unpack_limit) {
 790                 int code, i = 0;
 791                 const char *unpacker[4];
 792                 unpacker[i++] = "unpack-objects";
 793                 if (fsck_objects)
 794                         unpacker[i++] = "--strict";
 795                 unpacker[i++] = hdr_arg;
 796                 unpacker[i++] = NULL;
 797                 code = run_command_v_opt(unpacker, RUN_GIT_CMD);
 798                 if (!code)
 799                         return NULL;
 800                 return "unpack-objects abnormal exit";
 801         } else {
 802                 const char *keeper[7];
 803                 int s, status, i = 0;
 804                 char keep_arg[256];
 805                 struct child_process ip;
 806
 807                 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
 808                 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 809                         strcpy(keep_arg + s, "localhost");
 810
 811                 keeper[i++] = "index-pack";
 812                 keeper[i++] = "--stdin";
 813                 if (fsck_objects)
 814                         keeper[i++] = "--strict";
 815                 keeper[i++] = "--fix-thin";
 816                 keeper[i++] = hdr_arg;
 817                 keeper[i++] = keep_arg;
 818                 keeper[i++] = NULL;
 819                 memset(&ip, 0, sizeof(ip));
 820                 ip.argv = keeper;
 821                 ip.out = -1;
 822                 ip.git_cmd = 1;
 823                 status = start_command(&ip);
 824                 if (status) {
 825                         return "index-pack fork failed";
 826                 }
 827                 pack_lockfile = index_pack_lockfile(ip.out);
 828                 close(ip.out);
 829                 status = finish_command(&ip);
 830                 if (!status) {
 831                         reprepare_packed_git();
 832                         return NULL;
 833                 }
 834                 return "index-pack abnormal exit";
 835         }
 836 }
 837
 838 static void report(struct command *commands, const char *unpack_status)
 839 {
 840         struct command *cmd;
 841         struct strbuf buf = STRBUF_INIT;
 842
 843         packet_buf_write(&buf, "unpack %s\n",
 844                          unpack_status ? unpack_status : "ok");
 845         for (cmd = commands; cmd; cmd = cmd->next) {
 846                 if (!cmd->error_string)
 847                         packet_buf_write(&buf, "ok %s\n",
 848                                          cmd->ref_name);
 849                 else
 850                         packet_buf_write(&buf, "ng %s %s\n",
 851                                          cmd->ref_name, cmd->error_string);
 852         }
 853         packet_buf_flush(&buf);
 854
 855         if (use_sideband)
 856                 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
 857         else
 858                 safe_write(1, buf.buf, buf.len);
 859         strbuf_release(&buf);
 860 }
 861
 862 static int delete_only(struct command *commands)
 863 {
 864         struct command *cmd;
 865         for (cmd = commands; cmd; cmd = cmd->next) {
 866                 if (!is_null_sha1(cmd->new_sha1))
 867                         return 0;
 868         }
 869         return 1;
 870 }
 871
 872 static void add_one_alternate_sha1(const unsigned char sha1[20], void *unused)
 873 {
 874         add_extra_ref(".have", sha1, 0);
 875 }
 876
 877 static void collect_one_alternate_ref(const struct ref *ref, void *data)
 878 {
 879         struct sha1_array *sa = data;
 880         sha1_array_append(sa, ref->old_sha1);
 881 }
 882
 883 static void add_alternate_refs(void)
 884 {
 885         struct sha1_array sa = SHA1_ARRAY_INIT;
 886         for_each_alternate_ref(collect_one_alternate_ref, &sa);
 887         sha1_array_for_each_unique(&sa, add_one_alternate_sha1, NULL);
 888         sha1_array_clear(&sa);
 889 }
 890
 891 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
 892 {
 893         int advertise_refs = 0;
 894         int stateless_rpc = 0;
 895         int i;
 896         char *dir = NULL;
 897         struct command *commands;
 898
 899         packet_trace_identity("receive-pack");
 900
 901         argv++;
 902         for (i = 1; i < argc; i++) {
 903                 const char *arg = *argv++;
 904
 905                 if (*arg == '-') {
 906                         if (!strcmp(arg, "--advertise-refs")) {
 907                                 advertise_refs = 1;
 908                                 continue;
 909                         }
 910                         if (!strcmp(arg, "--stateless-rpc")) {
 911                                 stateless_rpc = 1;
 912                                 continue;
 913                         }
 914
 915                         usage(receive_pack_usage);
 916                 }
 917                 if (dir)
 918                         usage(receive_pack_usage);
 919                 dir = xstrdup(arg);
 920         }
 921         if (!dir)
 922                 usage(receive_pack_usage);
 923
 924         setup_path();
 925
 926         if (!enter_repo(dir, 0))
 927                 die("'%s' does not appear to be a git repository", dir);
 928
 929         if (is_repository_shallow())
 930                 die("attempt to push into a shallow repository");
 931
 932         git_config(receive_pack_config, NULL);
 933
 934         if (0 <= transfer_unpack_limit)
 935                 unpack_limit = transfer_unpack_limit;
 936         else if (0 <= receive_unpack_limit)
 937                 unpack_limit = receive_unpack_limit;
 938
 939         if (advertise_refs || !stateless_rpc) {
 940                 add_alternate_refs();
 941                 write_head_info();
 942                 clear_extra_refs();
 943
 944                 /* EOF */
 945                 packet_flush(1);
 946         }
 947         if (advertise_refs)
 948                 return 0;
 949
 950         if ((commands = read_head_info()) != NULL) {
 951                 const char *unpack_status = NULL;
 952
 953                 if (!delete_only(commands))
 954                         unpack_status = unpack();
 955                 execute_commands(commands, unpack_status);
 956                 if (pack_lockfile)
 957                         unlink_or_warn(pack_lockfile);
 958                 if (report_status)
 959                         report(commands, unpack_status);
 960                 run_receive_hook(commands, post_receive_hook, 1);
 961                 run_update_post_hook(commands);
 962                 if (auto_gc) {
 963                         const char *argv_gc_auto[] = {
 964                                 "gc", "--auto", "--quiet", NULL,
 965                         };
 966                         run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
 967                 }
 968                 if (auto_update_server_info)
 969                         update_server_info(0);
 970         }
 971         if (use_sideband)
 972                 packet_flush(1);
 973         return 0;
 974 }