6 #include "run-command.h"
11 #include "transport.h"
12 #include "string-list.h"
13 #include "sha1-array.h"
14 #include "connected.h"
16 static const char receive_pack_usage[] = "git receive-pack <git-dir>";
25 static int deny_deletes;
26 static int deny_non_fast_forwards;
27 static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
28 static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
29 static int receive_fsck_objects = -1;
30 static int transfer_fsck_objects = -1;
31 static int receive_unpack_limit = -1;
32 static int transfer_unpack_limit = -1;
33 static int unpack_limit = 100;
34 static int report_status;
35 static int use_sideband;
36 static int prefer_ofs_delta = 1;
37 static int auto_update_server_info;
38 static int auto_gc = 1;
39 static const char *head_name;
40 static int sent_capabilities;
42 static enum deny_action parse_deny_action(const char *var, const char *value)
45 if (!strcasecmp(value, "ignore"))
47 if (!strcasecmp(value, "warn"))
49 if (!strcasecmp(value, "refuse"))
52 if (git_config_bool(var, value))
57 static int receive_pack_config(const char *var, const char *value, void *cb)
59 if (strcmp(var, "receive.denydeletes") == 0) {
60 deny_deletes = git_config_bool(var, value);
64 if (strcmp(var, "receive.denynonfastforwards") == 0) {
65 deny_non_fast_forwards = git_config_bool(var, value);
69 if (strcmp(var, "receive.unpacklimit") == 0) {
70 receive_unpack_limit = git_config_int(var, value);
74 if (strcmp(var, "transfer.unpacklimit") == 0) {
75 transfer_unpack_limit = git_config_int(var, value);
79 if (strcmp(var, "receive.fsckobjects") == 0) {
80 receive_fsck_objects = git_config_bool(var, value);
84 if (strcmp(var, "transfer.fsckobjects") == 0) {
85 transfer_fsck_objects = git_config_bool(var, value);
89 if (!strcmp(var, "receive.denycurrentbranch")) {
90 deny_current_branch = parse_deny_action(var, value);
94 if (strcmp(var, "receive.denydeletecurrent") == 0) {
95 deny_delete_current = parse_deny_action(var, value);
99 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
100 prefer_ofs_delta = git_config_bool(var, value);
104 if (strcmp(var, "receive.updateserverinfo") == 0) {
105 auto_update_server_info = git_config_bool(var, value);
109 if (strcmp(var, "receive.autogc") == 0) {
110 auto_gc = git_config_bool(var, value);
114 return git_default_config(var, value, cb);
117 static int show_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
119 if (sent_capabilities)
120 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
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;
130 static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *cb_data)
132 path = strip_namespace(path);
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
143 return show_ref(path, sha1, flag, cb_data);
146 static void add_one_alternate_sha1(const unsigned char sha1[20], void *unused)
148 add_extra_ref(".have", sha1, 0);
151 static void collect_one_alternate_ref(const struct ref *ref, void *data)
153 struct sha1_array *sa = data;
154 sha1_array_append(sa, ref->old_sha1);
157 static void write_head_info(void)
159 struct sha1_array sa = SHA1_ARRAY_INIT;
160 for_each_alternate_ref(collect_one_alternate_ref, &sa);
161 sha1_array_for_each_unique(&sa, add_one_alternate_sha1, NULL);
162 sha1_array_clear(&sa);
163 for_each_ref(show_ref_cb, NULL);
164 if (!sent_capabilities)
165 show_ref("capabilities^{}", null_sha1, 0, NULL);
173 struct command *next;
174 const char *error_string;
175 unsigned int skip_update:1,
177 unsigned char old_sha1[20];
178 unsigned char new_sha1[20];
179 char ref_name[FLEX_ARRAY]; /* more */
182 static const char pre_receive_hook[] = "hooks/pre-receive";
183 static const char post_receive_hook[] = "hooks/post-receive";
185 static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
186 static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
188 static void report_message(const char *prefix, const char *err, va_list params)
190 int sz = strlen(prefix);
193 strncpy(msg, prefix, sz);
194 sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
195 if (sz > (sizeof(msg) - 1))
196 sz = sizeof(msg) - 1;
200 send_sideband(1, 2, msg, sz, use_sideband);
205 static void rp_warning(const char *err, ...)
208 va_start(params, err);
209 report_message("warning: ", err, params);
213 static void rp_error(const char *err, ...)
216 va_start(params, err);
217 report_message("error: ", err, params);
221 static int copy_to_sideband(int in, int out, void *arg)
225 ssize_t sz = xread(in, data, sizeof(data));
228 send_sideband(1, 2, data, sz, use_sideband);
234 typedef int (*feed_fn)(void *, const char **, size_t *);
235 static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
237 struct child_process proc;
242 if (access(hook_name, X_OK) < 0)
248 memset(&proc, 0, sizeof(proc));
251 proc.stdout_to_stderr = 1;
254 memset(&muxer, 0, sizeof(muxer));
255 muxer.proc = copy_to_sideband;
257 code = start_async(&muxer);
263 code = start_command(&proc);
266 finish_async(&muxer);
273 if (feed(feed_state, &buf, &n))
275 if (write_in_full(proc.in, buf, n) != n)
280 finish_async(&muxer);
281 return finish_command(&proc);
284 struct receive_hook_feed_state {
290 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
292 struct receive_hook_feed_state *state = state_;
293 struct command *cmd = state->cmd;
296 state->skip_broken && (cmd->error_string || cmd->did_not_exist))
300 strbuf_reset(&state->buf);
301 strbuf_addf(&state->buf, "%s %s %s\n",
302 sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
304 state->cmd = cmd->next;
306 *bufp = state->buf.buf;
307 *sizep = state->buf.len;
312 static int run_receive_hook(struct command *commands, const char *hook_name,
315 struct receive_hook_feed_state state;
318 strbuf_init(&state.buf, 0);
319 state.cmd = commands;
320 state.skip_broken = skip_broken;
321 if (feed_receive_hook(&state, NULL, NULL))
323 state.cmd = commands;
324 status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
325 strbuf_release(&state.buf);
329 static int run_update_hook(struct command *cmd)
331 static const char update_hook[] = "hooks/update";
333 struct child_process proc;
336 if (access(update_hook, X_OK) < 0)
339 argv[0] = update_hook;
340 argv[1] = cmd->ref_name;
341 argv[2] = sha1_to_hex(cmd->old_sha1);
342 argv[3] = sha1_to_hex(cmd->new_sha1);
345 memset(&proc, 0, sizeof(proc));
347 proc.stdout_to_stderr = 1;
348 proc.err = use_sideband ? -1 : 0;
351 code = start_command(&proc);
355 copy_to_sideband(proc.err, -1, NULL);
356 return finish_command(&proc);
359 static int is_ref_checked_out(const char *ref)
361 if (is_bare_repository())
366 return !strcmp(head_name, ref);
369 static char *refuse_unconfigured_deny_msg[] = {
370 "By default, updating the current branch in a non-bare repository",
371 "is denied, because it will make the index and work tree inconsistent",
372 "with what you pushed, and will require 'git reset --hard' to match",
373 "the work tree to HEAD.",
375 "You can set 'receive.denyCurrentBranch' configuration variable to",
376 "'ignore' or 'warn' in the remote repository to allow pushing into",
377 "its current branch; however, this is not recommended unless you",
378 "arranged to update its work tree to match what you pushed in some",
381 "To squelch this message and still keep the default behaviour, set",
382 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
385 static void refuse_unconfigured_deny(void)
388 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
389 rp_error("%s", refuse_unconfigured_deny_msg[i]);
392 static char *refuse_unconfigured_deny_delete_current_msg[] = {
393 "By default, deleting the current branch is denied, because the next",
394 "'git clone' won't result in any file checked out, causing confusion.",
396 "You can set 'receive.denyDeleteCurrent' configuration variable to",
397 "'warn' or 'ignore' in the remote repository to allow deleting the",
398 "current branch, with or without a warning message.",
400 "To squelch this message, you can set it to 'refuse'."
403 static void refuse_unconfigured_deny_delete_current(void)
407 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
409 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
412 static const char *update(struct command *cmd)
414 const char *name = cmd->ref_name;
415 struct strbuf namespaced_name_buf = STRBUF_INIT;
416 const char *namespaced_name;
417 unsigned char *old_sha1 = cmd->old_sha1;
418 unsigned char *new_sha1 = cmd->new_sha1;
419 struct ref_lock *lock;
421 /* only refs/... are allowed */
422 if (prefixcmp(name, "refs/") || check_refname_format(name + 5, 0)) {
423 rp_error("refusing to create funny ref '%s' remotely", name);
424 return "funny refname";
427 strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
428 namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
430 if (is_ref_checked_out(namespaced_name)) {
431 switch (deny_current_branch) {
435 rp_warning("updating the current branch");
438 case DENY_UNCONFIGURED:
439 rp_error("refusing to update checked out branch: %s", name);
440 if (deny_current_branch == DENY_UNCONFIGURED)
441 refuse_unconfigured_deny();
442 return "branch is currently checked out";
446 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
447 error("unpack should have generated %s, "
448 "but I can't find it!", sha1_to_hex(new_sha1));
452 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
453 if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
454 rp_error("denying ref deletion for %s", name);
455 return "deletion prohibited";
458 if (!strcmp(namespaced_name, head_name)) {
459 switch (deny_delete_current) {
463 rp_warning("deleting the current branch");
466 case DENY_UNCONFIGURED:
467 if (deny_delete_current == DENY_UNCONFIGURED)
468 refuse_unconfigured_deny_delete_current();
469 rp_error("refusing to delete the current branch: %s", name);
470 return "deletion of the current branch prohibited";
475 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
476 !is_null_sha1(old_sha1) &&
477 !prefixcmp(name, "refs/heads/")) {
478 struct object *old_object, *new_object;
479 struct commit *old_commit, *new_commit;
480 struct commit_list *bases, *ent;
482 old_object = parse_object(old_sha1);
483 new_object = parse_object(new_sha1);
485 if (!old_object || !new_object ||
486 old_object->type != OBJ_COMMIT ||
487 new_object->type != OBJ_COMMIT) {
488 error("bad sha1 objects for %s", name);
491 old_commit = (struct commit *)old_object;
492 new_commit = (struct commit *)new_object;
493 bases = get_merge_bases(old_commit, new_commit, 1);
494 for (ent = bases; ent; ent = ent->next)
495 if (!hashcmp(old_sha1, ent->item->object.sha1))
497 free_commit_list(bases);
499 rp_error("denying non-fast-forward %s"
500 " (you should pull first)", name);
501 return "non-fast-forward";
504 if (run_update_hook(cmd)) {
505 rp_error("hook declined to update %s", name);
506 return "hook declined";
509 if (is_null_sha1(new_sha1)) {
510 if (!parse_object(old_sha1)) {
512 if (ref_exists(name)) {
513 rp_warning("Allowing deletion of corrupt ref.");
515 rp_warning("Deleting a non-existent ref.");
516 cmd->did_not_exist = 1;
519 if (delete_ref(namespaced_name, old_sha1, 0)) {
520 rp_error("failed to delete %s", name);
521 return "failed to delete";
523 return NULL; /* good */
526 lock = lock_any_ref_for_update(namespaced_name, old_sha1, 0);
528 rp_error("failed to lock %s", name);
529 return "failed to lock";
531 if (write_ref_sha1(lock, new_sha1, "push")) {
532 return "failed to write"; /* error() already called */
534 return NULL; /* good */
538 static char update_post_hook[] = "hooks/post-update";
540 static void run_update_post_hook(struct command *commands)
545 struct child_process proc;
547 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
548 if (cmd->error_string || cmd->did_not_exist)
552 if (!argc || access(update_post_hook, X_OK) < 0)
554 argv = xmalloc(sizeof(*argv) * (2 + argc));
555 argv[0] = update_post_hook;
557 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
559 if (cmd->error_string || cmd->did_not_exist)
561 p = xmalloc(strlen(cmd->ref_name) + 1);
562 strcpy(p, cmd->ref_name);
568 memset(&proc, 0, sizeof(proc));
570 proc.stdout_to_stderr = 1;
571 proc.err = use_sideband ? -1 : 0;
574 if (!start_command(&proc)) {
576 copy_to_sideband(proc.err, -1, NULL);
577 finish_command(&proc);
581 static void check_aliased_update(struct command *cmd, struct string_list *list)
583 struct strbuf buf = STRBUF_INIT;
584 const char *dst_name;
585 struct string_list_item *item;
586 struct command *dst_cmd;
587 unsigned char sha1[20];
588 char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
591 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
592 dst_name = resolve_ref(buf.buf, sha1, 0, &flag);
593 strbuf_release(&buf);
595 if (!(flag & REF_ISSYMREF))
598 dst_name = strip_namespace(dst_name);
600 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
601 cmd->skip_update = 1;
602 cmd->error_string = "broken symref";
606 if ((item = string_list_lookup(list, dst_name)) == NULL)
609 cmd->skip_update = 1;
611 dst_cmd = (struct command *) item->util;
613 if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
614 !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
617 dst_cmd->skip_update = 1;
619 strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
620 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
621 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
622 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
623 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
624 " its target '%s' (%s..%s)",
625 cmd->ref_name, cmd_oldh, cmd_newh,
626 dst_cmd->ref_name, dst_oldh, dst_newh);
628 cmd->error_string = dst_cmd->error_string =
629 "inconsistent aliased update";
632 static void check_aliased_updates(struct command *commands)
635 struct string_list ref_list = STRING_LIST_INIT_NODUP;
637 for (cmd = commands; cmd; cmd = cmd->next) {
638 struct string_list_item *item =
639 string_list_append(&ref_list, cmd->ref_name);
640 item->util = (void *)cmd;
642 sort_string_list(&ref_list);
644 for (cmd = commands; cmd; cmd = cmd->next)
645 check_aliased_update(cmd, &ref_list);
647 string_list_clear(&ref_list, 0);
650 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
652 struct command **cmd_list = cb_data;
653 struct command *cmd = *cmd_list;
655 if (!cmd || is_null_sha1(cmd->new_sha1))
656 return -1; /* end of list */
657 *cmd_list = NULL; /* this returns only one */
658 hashcpy(sha1, cmd->new_sha1);
662 static void set_connectivity_errors(struct command *commands)
666 for (cmd = commands; cmd; cmd = cmd->next) {
667 struct command *singleton = cmd;
668 if (!check_everything_connected(command_singleton_iterator,
671 cmd->error_string = "missing necessary objects";
675 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
677 struct command **cmd_list = cb_data;
678 struct command *cmd = *cmd_list;
681 if (!is_null_sha1(cmd->new_sha1)) {
682 hashcpy(sha1, cmd->new_sha1);
683 *cmd_list = cmd->next;
689 return -1; /* end of list */
692 static void execute_commands(struct command *commands, const char *unpacker_error)
695 unsigned char sha1[20];
697 if (unpacker_error) {
698 for (cmd = commands; cmd; cmd = cmd->next)
699 cmd->error_string = "n/a (unpacker error)";
704 if (check_everything_connected(iterate_receive_command_list,
706 set_connectivity_errors(commands);
708 if (run_receive_hook(commands, pre_receive_hook, 0)) {
709 for (cmd = commands; cmd; cmd = cmd->next)
710 cmd->error_string = "pre-receive hook declined";
714 check_aliased_updates(commands);
716 free((char *)head_name);
717 head_name = resolve_ref("HEAD", sha1, 0, NULL);
719 head_name = xstrdup(head_name);
721 for (cmd = commands; cmd; cmd = cmd->next)
722 if (!cmd->skip_update)
723 cmd->error_string = update(cmd);
726 static struct command *read_head_info(void)
728 struct command *commands = NULL;
729 struct command **p = &commands;
731 static char line[1000];
732 unsigned char old_sha1[20], new_sha1[20];
737 len = packet_read_line(0, line, sizeof(line));
740 if (line[len-1] == '\n')
745 get_sha1_hex(line, old_sha1) ||
746 get_sha1_hex(line + 41, new_sha1))
747 die("protocol error: expected old/new/ref, got '%s'",
751 reflen = strlen(refname);
752 if (reflen + 82 < len) {
753 if (strstr(refname + reflen + 1, "report-status"))
755 if (strstr(refname + reflen + 1, "side-band-64k"))
756 use_sideband = LARGE_PACKET_MAX;
758 cmd = xcalloc(1, sizeof(struct command) + len - 80);
759 hashcpy(cmd->old_sha1, old_sha1);
760 hashcpy(cmd->new_sha1, new_sha1);
761 memcpy(cmd->ref_name, line + 82, len - 81);
768 static const char *parse_pack_header(struct pack_header *hdr)
770 switch (read_pack_header(0, hdr)) {
772 return "eof before pack header was fully read";
774 case PH_ERROR_PACK_SIGNATURE:
775 return "protocol error (pack signature mismatch detected)";
777 case PH_ERROR_PROTOCOL:
778 return "protocol error (pack version unsupported)";
781 return "unknown error in parse_pack_header";
788 static const char *pack_lockfile;
790 static const char *unpack(void)
792 struct pack_header hdr;
795 int fsck_objects = (receive_fsck_objects >= 0
796 ? receive_fsck_objects
797 : transfer_fsck_objects >= 0
798 ? transfer_fsck_objects
801 hdr_err = parse_pack_header(&hdr);
804 snprintf(hdr_arg, sizeof(hdr_arg),
805 "--pack_header=%"PRIu32",%"PRIu32,
806 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
808 if (ntohl(hdr.hdr_entries) < unpack_limit) {
810 const char *unpacker[4];
811 unpacker[i++] = "unpack-objects";
813 unpacker[i++] = "--strict";
814 unpacker[i++] = hdr_arg;
815 unpacker[i++] = NULL;
816 code = run_command_v_opt(unpacker, RUN_GIT_CMD);
819 return "unpack-objects abnormal exit";
821 const char *keeper[7];
822 int s, status, i = 0;
824 struct child_process ip;
826 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
827 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
828 strcpy(keep_arg + s, "localhost");
830 keeper[i++] = "index-pack";
831 keeper[i++] = "--stdin";
833 keeper[i++] = "--strict";
834 keeper[i++] = "--fix-thin";
835 keeper[i++] = hdr_arg;
836 keeper[i++] = keep_arg;
838 memset(&ip, 0, sizeof(ip));
842 status = start_command(&ip);
844 return "index-pack fork failed";
846 pack_lockfile = index_pack_lockfile(ip.out);
848 status = finish_command(&ip);
850 reprepare_packed_git();
853 return "index-pack abnormal exit";
857 static void report(struct command *commands, const char *unpack_status)
860 struct strbuf buf = STRBUF_INIT;
862 packet_buf_write(&buf, "unpack %s\n",
863 unpack_status ? unpack_status : "ok");
864 for (cmd = commands; cmd; cmd = cmd->next) {
865 if (!cmd->error_string)
866 packet_buf_write(&buf, "ok %s\n",
869 packet_buf_write(&buf, "ng %s %s\n",
870 cmd->ref_name, cmd->error_string);
872 packet_buf_flush(&buf);
875 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
877 safe_write(1, buf.buf, buf.len);
878 strbuf_release(&buf);
881 static int delete_only(struct command *commands)
884 for (cmd = commands; cmd; cmd = cmd->next) {
885 if (!is_null_sha1(cmd->new_sha1))
891 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
893 int advertise_refs = 0;
894 int stateless_rpc = 0;
897 struct command *commands;
899 packet_trace_identity("receive-pack");
902 for (i = 1; i < argc; i++) {
903 const char *arg = *argv++;
906 if (!strcmp(arg, "--advertise-refs")) {
910 if (!strcmp(arg, "--stateless-rpc")) {
915 usage(receive_pack_usage);
918 usage(receive_pack_usage);
922 usage(receive_pack_usage);
926 if (!enter_repo(dir, 0))
927 die("'%s' does not appear to be a git repository", dir);
929 if (is_repository_shallow())
930 die("attempt to push into a shallow repository");
932 git_config(receive_pack_config, NULL);
934 if (0 <= transfer_unpack_limit)
935 unpack_limit = transfer_unpack_limit;
936 else if (0 <= receive_unpack_limit)
937 unpack_limit = receive_unpack_limit;
939 if (advertise_refs || !stateless_rpc) {
945 if ((commands = read_head_info()) != NULL) {
946 const char *unpack_status = NULL;
948 if (!delete_only(commands))
949 unpack_status = unpack();
950 execute_commands(commands, unpack_status);
952 unlink_or_warn(pack_lockfile);
954 report(commands, unpack_status);
955 run_receive_hook(commands, post_receive_hook, 1);
956 run_update_post_hook(commands);
958 const char *argv_gc_auto[] = {
959 "gc", "--auto", "--quiet", NULL,
961 run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
963 if (auto_update_server_info)
964 update_server_info(0);