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