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