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