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         DENY_UPDATE_INSTEAD,
  23         DENY_DETACH_INSTEAD,
  24 };
  25
  26 static int deny_deletes;
  27 static int deny_non_fast_forwards;
  28 static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
  29 static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
  30 static int receive_fsck_objects;
  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, "receive.denycurrentbranch")) {
  85                 if (value && !strcasecmp(value, "updateinstead"))
  86                         deny_current_branch = DENY_UPDATE_INSTEAD;
  87                 else if (value && !strcasecmp(value, "detachinstead"))
  88                         deny_current_branch = DENY_DETACH_INSTEAD;
  89                 else
  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 void merge_worktree(unsigned char *sha1)
 357 {
 358         const char *update_refresh[] = {
 359                 "update-index", "--ignore-submodules", "--refresh", NULL
 360         };
 361         const char *read_tree[] = {
 362                 "read-tree", "-u", "-m", sha1_to_hex(sha1), NULL
 363         };
 364         struct child_process child;
 365         struct strbuf git_env = STRBUF_INIT;
 366         const char *env[2];
 367
 368         if (is_bare_repository())
 369                 die ("denyCurrentBranch = updateInstead needs a worktree");
 370
 371         strbuf_addf(&git_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
 372         env[0] = git_env.buf;
 373         env[1] = NULL;
 374
 375         memset(&child, 0, sizeof(child));
 376         child.argv = update_refresh;
 377         child.env = env;
 378         child.dir = git_work_tree_cfg ? git_work_tree_cfg : "..";
 379         child.stdout_to_stderr = 1;
 380         child.git_cmd = 1;
 381         if (run_command(&child))
 382                 die ("Could not refresh the index");
 383
 384         child.argv = read_tree;
 385         child.no_stdin = 1;
 386         child.no_stdout = 1;
 387         child.stdout_to_stderr = 0;
 388         if (run_command(&child))
 389                 die ("Could not merge working tree with new HEAD.  Good luck.");
 390
 391         strbuf_release(&git_env);
 392 }
 393
 394 static const char *update(struct command *cmd)
 395 {
 396         const char *name = cmd->ref_name;
 397         struct strbuf namespaced_name_buf = STRBUF_INIT;
 398         const char *namespaced_name;
 399         unsigned char *old_sha1 = cmd->old_sha1;
 400         unsigned char *new_sha1 = cmd->new_sha1;
 401         struct ref_lock *lock;
 402
 403         /* only refs/... are allowed */
 404         if (prefixcmp(name, "refs/") || check_ref_format(name + 5)) {
 405                 rp_error("refusing to create funny ref '%s' remotely", name);
 406                 return "funny refname";
 407         }
 408
 409         strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
 410         namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
 411
 412         if (is_ref_checked_out(namespaced_name)) {
 413                 switch (deny_current_branch) {
 414                 case DENY_IGNORE:
 415                         break;
 416                 case DENY_WARN:
 417                         rp_warning("updating the current branch");
 418                         break;
 419                 case DENY_REFUSE:
 420                 case DENY_UNCONFIGURED:
 421                         rp_error("refusing to update checked out branch: %s", name);
 422                         if (deny_current_branch == DENY_UNCONFIGURED)
 423                                 refuse_unconfigured_deny();
 424                         return "branch is currently checked out";
 425                 case DENY_UPDATE_INSTEAD:
 426                         merge_worktree(new_sha1);
 427                         break;
 428                 case DENY_DETACH_INSTEAD:
 429                         update_ref("push into current branch (detach)", "HEAD",
 430                                 old_sha1, NULL, REF_NODEREF, DIE_ON_ERR);
 431                         break;
 432                 }
 433         }
 434
 435         if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
 436                 error("unpack should have generated %s, "
 437                       "but I can't find it!", sha1_to_hex(new_sha1));
 438                 return "bad pack";
 439         }
 440
 441         if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
 442                 if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
 443                         rp_error("denying ref deletion for %s", name);
 444                         return "deletion prohibited";
 445                 }
 446
 447                 if (!strcmp(namespaced_name, head_name)) {
 448                         switch (deny_delete_current) {
 449                         case DENY_IGNORE:
 450                                 break;
 451                         case DENY_WARN:
 452                                 rp_warning("deleting the current branch");
 453                                 break;
 454                         case DENY_REFUSE:
 455                         case DENY_UNCONFIGURED:
 456                                 if (deny_delete_current == DENY_UNCONFIGURED)
 457                                         refuse_unconfigured_deny_delete_current();
 458                                 rp_error("refusing to delete the current branch: %s", name);
 459                                 return "deletion of the current branch prohibited";
 460                         default:
 461                                 die ("Invalid denyDeleteCurrent setting");
 462                         }
 463                 }
 464         }
 465
 466         if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
 467             !is_null_sha1(old_sha1) &&
 468             !prefixcmp(name, "refs/heads/")) {
 469                 struct object *old_object, *new_object;
 470                 struct commit *old_commit, *new_commit;
 471                 struct commit_list *bases, *ent;
 472
 473                 old_object = parse_object(old_sha1);
 474                 new_object = parse_object(new_sha1);
 475
 476                 if (!old_object || !new_object ||
 477                     old_object->type != OBJ_COMMIT ||
 478                     new_object->type != OBJ_COMMIT) {
 479                         error("bad sha1 objects for %s", name);
 480                         return "bad ref";
 481                 }
 482                 old_commit = (struct commit *)old_object;
 483                 new_commit = (struct commit *)new_object;
 484                 bases = get_merge_bases(old_commit, new_commit, 1);
 485                 for (ent = bases; ent; ent = ent->next)
 486                         if (!hashcmp(old_sha1, ent->item->object.sha1))
 487                                 break;
 488                 free_commit_list(bases);
 489                 if (!ent) {
 490                         rp_error("denying non-fast-forward %s"
 491                                  " (you should pull first)", name);
 492                         return "non-fast-forward";
 493                 }
 494         }
 495         if (run_update_hook(cmd)) {
 496                 rp_error("hook declined to update %s", name);
 497                 return "hook declined";
 498         }
 499
 500         if (is_null_sha1(new_sha1)) {
 501                 if (!parse_object(old_sha1)) {
 502                         rp_warning("Allowing deletion of corrupt ref.");
 503                         old_sha1 = NULL;
 504                 }
 505                 if (delete_ref(namespaced_name, old_sha1, 0)) {
 506                         rp_error("failed to delete %s", name);
 507                         return "failed to delete";
 508                 }
 509                 return NULL; /* good */
 510         }
 511         else {
 512                 lock = lock_any_ref_for_update(namespaced_name, old_sha1, 0);
 513                 if (!lock) {
 514                         rp_error("failed to lock %s", name);
 515                         return "failed to lock";
 516                 }
 517                 if (write_ref_sha1(lock, new_sha1, "push")) {
 518                         return "failed to write"; /* error() already called */
 519                 }
 520                 return NULL; /* good */
 521         }
 522 }
 523
 524 static char update_post_hook[] = "hooks/post-update";
 525
 526 static void run_update_post_hook(struct command *commands)
 527 {
 528         struct command *cmd;
 529         int argc;
 530         const char **argv;
 531         struct child_process proc;
 532
 533         for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
 534                 if (cmd->error_string)
 535                         continue;
 536                 argc++;
 537         }
 538         if (!argc || access(update_post_hook, X_OK) < 0)
 539                 return;
 540         argv = xmalloc(sizeof(*argv) * (2 + argc));
 541         argv[0] = update_post_hook;
 542
 543         for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
 544                 char *p;
 545                 if (cmd->error_string)
 546                         continue;
 547                 p = xmalloc(strlen(cmd->ref_name) + 1);
 548                 strcpy(p, cmd->ref_name);
 549                 argv[argc] = p;
 550                 argc++;
 551         }
 552         argv[argc] = NULL;
 553
 554         memset(&proc, 0, sizeof(proc));
 555         proc.no_stdin = 1;
 556         proc.stdout_to_stderr = 1;
 557         proc.err = use_sideband ? -1 : 0;
 558         proc.argv = argv;
 559
 560         if (!start_command(&proc)) {
 561                 if (use_sideband)
 562                         copy_to_sideband(proc.err, -1, NULL);
 563                 finish_command(&proc);
 564         }
 565 }
 566
 567 static void check_aliased_update(struct command *cmd, struct string_list *list)
 568 {
 569         struct strbuf buf = STRBUF_INIT;
 570         const char *dst_name;
 571         struct string_list_item *item;
 572         struct command *dst_cmd;
 573         unsigned char sha1[20];
 574         char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
 575         int flag;
 576
 577         strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
 578         dst_name = resolve_ref(buf.buf, sha1, 0, &flag);
 579         strbuf_release(&buf);
 580
 581         if (!(flag & REF_ISSYMREF))
 582                 return;
 583
 584         dst_name = strip_namespace(dst_name);
 585         if (!dst_name) {
 586                 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
 587                 cmd->skip_update = 1;
 588                 cmd->error_string = "broken symref";
 589                 return;
 590         }
 591
 592         if ((item = string_list_lookup(list, dst_name)) == NULL)
 593                 return;
 594
 595         cmd->skip_update = 1;
 596
 597         dst_cmd = (struct command *) item->util;
 598
 599         if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
 600             !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
 601                 return;
 602
 603         dst_cmd->skip_update = 1;
 604
 605         strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
 606         strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
 607         strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
 608         strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
 609         rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
 610                  " its target '%s' (%s..%s)",
 611                  cmd->ref_name, cmd_oldh, cmd_newh,
 612                  dst_cmd->ref_name, dst_oldh, dst_newh);
 613
 614         cmd->error_string = dst_cmd->error_string =
 615                 "inconsistent aliased update";
 616 }
 617
 618 static void check_aliased_updates(struct command *commands)
 619 {
 620         struct command *cmd;
 621         struct string_list ref_list = STRING_LIST_INIT_NODUP;
 622
 623         for (cmd = commands; cmd; cmd = cmd->next) {
 624                 struct string_list_item *item =
 625                         string_list_append(&ref_list, cmd->ref_name);
 626                 item->util = (void *)cmd;
 627         }
 628         sort_string_list(&ref_list);
 629
 630         for (cmd = commands; cmd; cmd = cmd->next)
 631                 check_aliased_update(cmd, &ref_list);
 632
 633         string_list_clear(&ref_list, 0);
 634 }
 635
 636 static void execute_commands(struct command *commands, const char *unpacker_error)
 637 {
 638         struct command *cmd;
 639         unsigned char sha1[20];
 640
 641         if (unpacker_error) {
 642                 for (cmd = commands; cmd; cmd = cmd->next)
 643                         cmd->error_string = "n/a (unpacker error)";
 644                 return;
 645         }
 646
 647         if (run_receive_hook(commands, pre_receive_hook)) {
 648                 for (cmd = commands; cmd; cmd = cmd->next)
 649                         cmd->error_string = "pre-receive hook declined";
 650                 return;
 651         }
 652
 653         check_aliased_updates(commands);
 654
 655         head_name = resolve_ref("HEAD", sha1, 0, NULL);
 656
 657         for (cmd = commands; cmd; cmd = cmd->next)
 658                 if (!cmd->skip_update)
 659                         cmd->error_string = update(cmd);
 660 }
 661
 662 static struct command *read_head_info(void)
 663 {
 664         struct command *commands = NULL;
 665         struct command **p = &commands;
 666         for (;;) {
 667                 static char line[1000];
 668                 unsigned char old_sha1[20], new_sha1[20];
 669                 struct command *cmd;
 670                 char *refname;
 671                 int len, reflen;
 672
 673                 len = packet_read_line(0, line, sizeof(line));
 674                 if (!len)
 675                         break;
 676                 if (line[len-1] == '\n')
 677                         line[--len] = 0;
 678                 if (len < 83 ||
 679                     line[40] != ' ' ||
 680                     line[81] != ' ' ||
 681                     get_sha1_hex(line, old_sha1) ||
 682                     get_sha1_hex(line + 41, new_sha1))
 683                         die("protocol error: expected old/new/ref, got '%s'",
 684                             line);
 685
 686                 refname = line + 82;
 687                 reflen = strlen(refname);
 688                 if (reflen + 82 < len) {
 689                         if (strstr(refname + reflen + 1, "report-status"))
 690                                 report_status = 1;
 691                         if (strstr(refname + reflen + 1, "side-band-64k"))
 692                                 use_sideband = LARGE_PACKET_MAX;
 693                 }
 694                 cmd = xcalloc(1, sizeof(struct command) + len - 80);
 695                 hashcpy(cmd->old_sha1, old_sha1);
 696                 hashcpy(cmd->new_sha1, new_sha1);
 697                 memcpy(cmd->ref_name, line + 82, len - 81);
 698                 *p = cmd;
 699                 p = &cmd->next;
 700         }
 701         return commands;
 702 }
 703
 704 static const char *parse_pack_header(struct pack_header *hdr)
 705 {
 706         switch (read_pack_header(0, hdr)) {
 707         case PH_ERROR_EOF:
 708                 return "eof before pack header was fully read";
 709
 710         case PH_ERROR_PACK_SIGNATURE:
 711                 return "protocol error (pack signature mismatch detected)";
 712
 713         case PH_ERROR_PROTOCOL:
 714                 return "protocol error (pack version unsupported)";
 715
 716         default:
 717                 return "unknown error in parse_pack_header";
 718
 719         case 0:
 720                 return NULL;
 721         }
 722 }
 723
 724 static const char *pack_lockfile;
 725
 726 static const char *unpack(int quiet)
 727 {
 728         struct pack_header hdr;
 729         const char *hdr_err;
 730         char hdr_arg[38];
 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 (quiet)
 744                         unpacker[i++] = "-q";
 745                 if (receive_fsck_objects)
 746                         unpacker[i++] = "--strict";
 747                 unpacker[i++] = hdr_arg;
 748                 unpacker[i++] = NULL;
 749                 code = run_command_v_opt(unpacker, RUN_GIT_CMD);
 750                 if (!code)
 751                         return NULL;
 752                 return "unpack-objects abnormal exit";
 753         } else {
 754                 const char *keeper[7];
 755                 int s, status, i = 0;
 756                 char keep_arg[256];
 757                 struct child_process ip;
 758
 759                 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
 760                 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 761                         strcpy(keep_arg + s, "localhost");
 762
 763                 keeper[i++] = "index-pack";
 764                 keeper[i++] = "--stdin";
 765                 if (receive_fsck_objects)
 766                         keeper[i++] = "--strict";
 767                 keeper[i++] = "--fix-thin";
 768                 keeper[i++] = hdr_arg;
 769                 keeper[i++] = keep_arg;
 770                 keeper[i++] = NULL;
 771                 memset(&ip, 0, sizeof(ip));
 772                 ip.argv = keeper;
 773                 ip.out = -1;
 774                 ip.git_cmd = 1;
 775                 status = start_command(&ip);
 776                 if (status) {
 777                         return "index-pack fork failed";
 778                 }
 779                 pack_lockfile = index_pack_lockfile(ip.out);
 780                 close(ip.out);
 781                 status = finish_command(&ip);
 782                 if (!status) {
 783                         reprepare_packed_git();
 784                         return NULL;
 785                 }
 786                 return "index-pack abnormal exit";
 787         }
 788 }
 789
 790 static void report(struct command *commands, const char *unpack_status)
 791 {
 792         struct command *cmd;
 793         struct strbuf buf = STRBUF_INIT;
 794
 795         packet_buf_write(&buf, "unpack %s\n",
 796                          unpack_status ? unpack_status : "ok");
 797         for (cmd = commands; cmd; cmd = cmd->next) {
 798                 if (!cmd->error_string)
 799                         packet_buf_write(&buf, "ok %s\n",
 800                                          cmd->ref_name);
 801                 else
 802                         packet_buf_write(&buf, "ng %s %s\n",
 803                                          cmd->ref_name, cmd->error_string);
 804         }
 805         packet_buf_flush(&buf);
 806
 807         if (use_sideband)
 808                 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
 809         else
 810                 safe_write(1, buf.buf, buf.len);
 811         strbuf_release(&buf);
 812 }
 813
 814 static int delete_only(struct command *commands)
 815 {
 816         struct command *cmd;
 817         for (cmd = commands; cmd; cmd = cmd->next) {
 818                 if (!is_null_sha1(cmd->new_sha1))
 819                         return 0;
 820         }
 821         return 1;
 822 }
 823
 824 static void add_one_alternate_sha1(const unsigned char sha1[20], void *unused)
 825 {
 826         add_extra_ref(".have", sha1, 0);
 827 }
 828
 829 static void collect_one_alternate_ref(const struct ref *ref, void *data)
 830 {
 831         struct sha1_array *sa = data;
 832         sha1_array_append(sa, ref->old_sha1);
 833 }
 834
 835 static void add_alternate_refs(void)
 836 {
 837         struct sha1_array sa = SHA1_ARRAY_INIT;
 838         for_each_alternate_ref(collect_one_alternate_ref, &sa);
 839         sha1_array_for_each_unique(&sa, add_one_alternate_sha1, NULL);
 840         sha1_array_clear(&sa);
 841 }
 842
 843 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
 844 {
 845         int quiet = 0;
 846         int advertise_refs = 0;
 847         int stateless_rpc = 0;
 848         int i;
 849         char *dir = NULL;
 850         struct command *commands;
 851
 852         packet_trace_identity("receive-pack");
 853
 854         argv++;
 855         for (i = 1; i < argc; i++) {
 856                 const char *arg = *argv++;
 857
 858                 if (*arg == '-') {
 859                         if (!strcmp(arg, "--quiet")) {
 860                                 quiet = 1;
 861                                 continue;
 862                         }
 863
 864                         if (!strcmp(arg, "--advertise-refs")) {
 865                                 advertise_refs = 1;
 866                                 continue;
 867                         }
 868                         if (!strcmp(arg, "--stateless-rpc")) {
 869                                 stateless_rpc = 1;
 870                                 continue;
 871                         }
 872
 873                         usage(receive_pack_usage);
 874                 }
 875                 if (dir)
 876                         usage(receive_pack_usage);
 877                 dir = xstrdup(arg);
 878         }
 879         if (!dir)
 880                 usage(receive_pack_usage);
 881
 882         setup_path();
 883
 884         if (!enter_repo(dir, 0))
 885                 die("'%s' does not appear to be a git repository", dir);
 886
 887         if (is_repository_shallow())
 888                 die("attempt to push into a shallow repository");
 889
 890         git_config(receive_pack_config, NULL);
 891
 892         if (0 <= transfer_unpack_limit)
 893                 unpack_limit = transfer_unpack_limit;
 894         else if (0 <= receive_unpack_limit)
 895                 unpack_limit = receive_unpack_limit;
 896
 897         if (advertise_refs || !stateless_rpc) {
 898                 add_alternate_refs();
 899                 write_head_info();
 900                 clear_extra_refs();
 901
 902                 /* EOF */
 903                 packet_flush(1);
 904         }
 905         if (advertise_refs)
 906                 return 0;
 907
 908         if ((commands = read_head_info()) != NULL) {
 909                 const char *unpack_status = NULL;
 910
 911                 if (!delete_only(commands))
 912                         unpack_status = unpack(quiet);
 913                 execute_commands(commands, unpack_status);
 914                 if (pack_lockfile)
 915                         unlink_or_warn(pack_lockfile);
 916                 if (report_status)
 917                         report(commands, unpack_status);
 918                 run_receive_hook(commands, post_receive_hook);
 919                 run_update_post_hook(commands);
 920                 if (auto_gc) {
 921                         const char *argv_gc_auto[] = {
 922                                 "gc", "--auto", "--quiet", NULL,
 923                         };
 924                         run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
 925                 }
 926                 if (auto_update_server_info)
 927                         update_server_info(0);
 928         }
 929         if (use_sideband)
 930                 packet_flush(1);
 931         return 0;
 932 }