builtin-receive-pack.c

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