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;
37 static int prefer_ofs_delta = 1;
38 static int auto_update_server_info;
39 static int auto_gc = 1;
40 static const char *head_name;
41 static void *head_name_to_free;
42 static int sent_capabilities;
44 static enum deny_action parse_deny_action(const char *var, const char *value)
47 if (!strcasecmp(value, "ignore"))
49 if (!strcasecmp(value, "warn"))
51 if (!strcasecmp(value, "refuse"))
54 if (git_config_bool(var, value))
59 static int receive_pack_config(const char *var, const char *value, void *cb)
61 if (strcmp(var, "receive.denydeletes") == 0) {
62 deny_deletes = git_config_bool(var, value);
66 if (strcmp(var, "receive.denynonfastforwards") == 0) {
67 deny_non_fast_forwards = git_config_bool(var, value);
71 if (strcmp(var, "receive.unpacklimit") == 0) {
72 receive_unpack_limit = git_config_int(var, value);
76 if (strcmp(var, "transfer.unpacklimit") == 0) {
77 transfer_unpack_limit = git_config_int(var, value);
81 if (strcmp(var, "receive.fsckobjects") == 0) {
82 receive_fsck_objects = git_config_bool(var, value);
86 if (strcmp(var, "transfer.fsckobjects") == 0) {
87 transfer_fsck_objects = git_config_bool(var, value);
91 if (!strcmp(var, "receive.denycurrentbranch")) {
92 deny_current_branch = parse_deny_action(var, value);
96 if (strcmp(var, "receive.denydeletecurrent") == 0) {
97 deny_delete_current = parse_deny_action(var, value);
101 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
102 prefer_ofs_delta = git_config_bool(var, value);
106 if (strcmp(var, "receive.updateserverinfo") == 0) {
107 auto_update_server_info = git_config_bool(var, value);
111 if (strcmp(var, "receive.autogc") == 0) {
112 auto_gc = git_config_bool(var, value);
116 return git_default_config(var, value, cb);
119 static int show_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
121 if (sent_capabilities)
122 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
124 packet_write(1, "%s %s%c%s%s\n",
125 sha1_to_hex(sha1), path, 0,
126 " report-status delete-refs side-band-64k quiet",
127 prefer_ofs_delta ? " ofs-delta" : "");
128 sent_capabilities = 1;
132 static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *cb_data)
134 path = strip_namespace(path);
136 * Advertise refs outside our current namespace as ".have"
137 * refs, so that the client can use them to minimize data
138 * transfer but will otherwise ignore them. This happens to
139 * cover ".have" that are thrown in by add_one_alternate_ref()
140 * to mark histories that are complete in our alternates as
145 return show_ref(path, sha1, flag, cb_data);
148 static void write_head_info(void)
150 for_each_ref(show_ref_cb, NULL);
151 if (!sent_capabilities)
152 show_ref("capabilities^{}", null_sha1, 0, NULL);
157 struct command *next;
158 const char *error_string;
159 unsigned int skip_update:1,
161 unsigned char old_sha1[20];
162 unsigned char new_sha1[20];
163 char ref_name[FLEX_ARRAY]; /* more */
166 static const char pre_receive_hook[] = "hooks/pre-receive";
167 static const char post_receive_hook[] = "hooks/post-receive";
169 static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
170 static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
172 static void report_message(const char *prefix, const char *err, va_list params)
174 int sz = strlen(prefix);
177 strncpy(msg, prefix, sz);
178 sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
179 if (sz > (sizeof(msg) - 1))
180 sz = sizeof(msg) - 1;
184 send_sideband(1, 2, msg, sz, use_sideband);
189 static void rp_warning(const char *err, ...)
192 va_start(params, err);
193 report_message("warning: ", err, params);
197 static void rp_error(const char *err, ...)
200 va_start(params, err);
201 report_message("error: ", err, params);
205 static int copy_to_sideband(int in, int out, void *arg)
209 ssize_t sz = xread(in, data, sizeof(data));
212 send_sideband(1, 2, data, sz, use_sideband);
218 typedef int (*feed_fn)(void *, const char **, size_t *);
219 static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
221 struct child_process proc;
226 if (access(hook_name, X_OK) < 0)
232 memset(&proc, 0, sizeof(proc));
235 proc.stdout_to_stderr = 1;
238 memset(&muxer, 0, sizeof(muxer));
239 muxer.proc = copy_to_sideband;
241 code = start_async(&muxer);
247 code = start_command(&proc);
250 finish_async(&muxer);
257 if (feed(feed_state, &buf, &n))
259 if (write_in_full(proc.in, buf, n) != n)
264 finish_async(&muxer);
265 return finish_command(&proc);
268 struct receive_hook_feed_state {
274 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
276 struct receive_hook_feed_state *state = state_;
277 struct command *cmd = state->cmd;
280 state->skip_broken && (cmd->error_string || cmd->did_not_exist))
284 strbuf_reset(&state->buf);
285 strbuf_addf(&state->buf, "%s %s %s\n",
286 sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
288 state->cmd = cmd->next;
290 *bufp = state->buf.buf;
291 *sizep = state->buf.len;
296 static int run_receive_hook(struct command *commands, const char *hook_name,
299 struct receive_hook_feed_state state;
302 strbuf_init(&state.buf, 0);
303 state.cmd = commands;
304 state.skip_broken = skip_broken;
305 if (feed_receive_hook(&state, NULL, NULL))
307 state.cmd = commands;
308 status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
309 strbuf_release(&state.buf);
313 static int run_update_hook(struct command *cmd)
315 static const char update_hook[] = "hooks/update";
317 struct child_process proc;
320 if (access(update_hook, X_OK) < 0)
323 argv[0] = update_hook;
324 argv[1] = cmd->ref_name;
325 argv[2] = sha1_to_hex(cmd->old_sha1);
326 argv[3] = sha1_to_hex(cmd->new_sha1);
329 memset(&proc, 0, sizeof(proc));
331 proc.stdout_to_stderr = 1;
332 proc.err = use_sideband ? -1 : 0;
335 code = start_command(&proc);
339 copy_to_sideband(proc.err, -1, NULL);
340 return finish_command(&proc);
343 static int is_ref_checked_out(const char *ref)
345 if (is_bare_repository())
350 return !strcmp(head_name, ref);
353 static char *refuse_unconfigured_deny_msg[] = {
354 "By default, updating the current branch in a non-bare repository",
355 "is denied, because it will make the index and work tree inconsistent",
356 "with what you pushed, and will require 'git reset --hard' to match",
357 "the work tree to HEAD.",
359 "You can set 'receive.denyCurrentBranch' configuration variable to",
360 "'ignore' or 'warn' in the remote repository to allow pushing into",
361 "its current branch; however, this is not recommended unless you",
362 "arranged to update its work tree to match what you pushed in some",
365 "To squelch this message and still keep the default behaviour, set",
366 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
369 static void refuse_unconfigured_deny(void)
372 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
373 rp_error("%s", refuse_unconfigured_deny_msg[i]);
376 static char *refuse_unconfigured_deny_delete_current_msg[] = {
377 "By default, deleting the current branch is denied, because the next",
378 "'git clone' won't result in any file checked out, causing confusion.",
380 "You can set 'receive.denyDeleteCurrent' configuration variable to",
381 "'warn' or 'ignore' in the remote repository to allow deleting the",
382 "current branch, with or without a warning message.",
384 "To squelch this message, you can set it to 'refuse'."
387 static void refuse_unconfigured_deny_delete_current(void)
391 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
393 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
396 static const char *update(struct command *cmd)
398 const char *name = cmd->ref_name;
399 struct strbuf namespaced_name_buf = STRBUF_INIT;
400 const char *namespaced_name;
401 unsigned char *old_sha1 = cmd->old_sha1;
402 unsigned char *new_sha1 = cmd->new_sha1;
403 struct ref_lock *lock;
405 /* only refs/... are allowed */
406 if (prefixcmp(name, "refs/") || check_refname_format(name + 5, 0)) {
407 rp_error("refusing to create funny ref '%s' remotely", name);
408 return "funny refname";
411 strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
412 namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
414 if (is_ref_checked_out(namespaced_name)) {
415 switch (deny_current_branch) {
419 rp_warning("updating the current branch");
422 case DENY_UNCONFIGURED:
423 rp_error("refusing to update checked out branch: %s", name);
424 if (deny_current_branch == DENY_UNCONFIGURED)
425 refuse_unconfigured_deny();
426 return "branch is currently checked out";
430 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
431 error("unpack should have generated %s, "
432 "but I can't find it!", sha1_to_hex(new_sha1));
436 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
437 if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
438 rp_error("denying ref deletion for %s", name);
439 return "deletion prohibited";
442 if (!strcmp(namespaced_name, head_name)) {
443 switch (deny_delete_current) {
447 rp_warning("deleting the current branch");
450 case DENY_UNCONFIGURED:
451 if (deny_delete_current == DENY_UNCONFIGURED)
452 refuse_unconfigured_deny_delete_current();
453 rp_error("refusing to delete the current branch: %s", name);
454 return "deletion of the current branch prohibited";
459 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
460 !is_null_sha1(old_sha1) &&
461 !prefixcmp(name, "refs/heads/")) {
462 struct object *old_object, *new_object;
463 struct commit *old_commit, *new_commit;
464 struct commit_list *bases, *ent;
466 old_object = parse_object(old_sha1);
467 new_object = parse_object(new_sha1);
469 if (!old_object || !new_object ||
470 old_object->type != OBJ_COMMIT ||
471 new_object->type != OBJ_COMMIT) {
472 error("bad sha1 objects for %s", name);
475 old_commit = (struct commit *)old_object;
476 new_commit = (struct commit *)new_object;
477 bases = get_merge_bases(old_commit, new_commit, 1);
478 for (ent = bases; ent; ent = ent->next)
479 if (!hashcmp(old_sha1, ent->item->object.sha1))
481 free_commit_list(bases);
483 rp_error("denying non-fast-forward %s"
484 " (you should pull first)", name);
485 return "non-fast-forward";
488 if (run_update_hook(cmd)) {
489 rp_error("hook declined to update %s", name);
490 return "hook declined";
493 if (is_null_sha1(new_sha1)) {
494 if (!parse_object(old_sha1)) {
496 if (ref_exists(name)) {
497 rp_warning("Allowing deletion of corrupt ref.");
499 rp_warning("Deleting a non-existent ref.");
500 cmd->did_not_exist = 1;
503 if (delete_ref(namespaced_name, old_sha1, 0)) {
504 rp_error("failed to delete %s", name);
505 return "failed to delete";
507 return NULL; /* good */
510 lock = lock_any_ref_for_update(namespaced_name, old_sha1, 0);
512 rp_error("failed to lock %s", name);
513 return "failed to lock";
515 if (write_ref_sha1(lock, new_sha1, "push")) {
516 return "failed to write"; /* error() already called */
518 return NULL; /* good */
522 static char update_post_hook[] = "hooks/post-update";
524 static void run_update_post_hook(struct command *commands)
529 struct child_process proc;
531 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
532 if (cmd->error_string || cmd->did_not_exist)
536 if (!argc || access(update_post_hook, X_OK) < 0)
538 argv = xmalloc(sizeof(*argv) * (2 + argc));
539 argv[0] = update_post_hook;
541 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
543 if (cmd->error_string || cmd->did_not_exist)
545 p = xmalloc(strlen(cmd->ref_name) + 1);
546 strcpy(p, cmd->ref_name);
552 memset(&proc, 0, sizeof(proc));
554 proc.stdout_to_stderr = 1;
555 proc.err = use_sideband ? -1 : 0;
558 if (!start_command(&proc)) {
560 copy_to_sideband(proc.err, -1, NULL);
561 finish_command(&proc);
565 static void check_aliased_update(struct command *cmd, struct string_list *list)
567 struct strbuf buf = STRBUF_INIT;
568 const char *dst_name;
569 struct string_list_item *item;
570 struct command *dst_cmd;
571 unsigned char sha1[20];
572 char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
575 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
576 dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
577 strbuf_release(&buf);
579 if (!(flag & REF_ISSYMREF))
582 dst_name = strip_namespace(dst_name);
584 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
585 cmd->skip_update = 1;
586 cmd->error_string = "broken symref";
590 if ((item = string_list_lookup(list, dst_name)) == NULL)
593 cmd->skip_update = 1;
595 dst_cmd = (struct command *) item->util;
597 if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
598 !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
601 dst_cmd->skip_update = 1;
603 strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
604 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
605 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
606 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
607 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
608 " its target '%s' (%s..%s)",
609 cmd->ref_name, cmd_oldh, cmd_newh,
610 dst_cmd->ref_name, dst_oldh, dst_newh);
612 cmd->error_string = dst_cmd->error_string =
613 "inconsistent aliased update";
616 static void check_aliased_updates(struct command *commands)
619 struct string_list ref_list = STRING_LIST_INIT_NODUP;
621 for (cmd = commands; cmd; cmd = cmd->next) {
622 struct string_list_item *item =
623 string_list_append(&ref_list, cmd->ref_name);
624 item->util = (void *)cmd;
626 sort_string_list(&ref_list);
628 for (cmd = commands; cmd; cmd = cmd->next)
629 check_aliased_update(cmd, &ref_list);
631 string_list_clear(&ref_list, 0);
634 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
636 struct command **cmd_list = cb_data;
637 struct command *cmd = *cmd_list;
639 if (!cmd || is_null_sha1(cmd->new_sha1))
640 return -1; /* end of list */
641 *cmd_list = NULL; /* this returns only one */
642 hashcpy(sha1, cmd->new_sha1);
646 static void set_connectivity_errors(struct command *commands)
650 for (cmd = commands; cmd; cmd = cmd->next) {
651 struct command *singleton = cmd;
652 if (!check_everything_connected(command_singleton_iterator,
655 cmd->error_string = "missing necessary objects";
659 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
661 struct command **cmd_list = cb_data;
662 struct command *cmd = *cmd_list;
665 if (!is_null_sha1(cmd->new_sha1)) {
666 hashcpy(sha1, cmd->new_sha1);
667 *cmd_list = cmd->next;
673 return -1; /* end of list */
676 static void execute_commands(struct command *commands, const char *unpacker_error)
679 unsigned char sha1[20];
681 if (unpacker_error) {
682 for (cmd = commands; cmd; cmd = cmd->next)
683 cmd->error_string = "n/a (unpacker error)";
688 if (check_everything_connected(iterate_receive_command_list,
690 set_connectivity_errors(commands);
692 if (run_receive_hook(commands, pre_receive_hook, 0)) {
693 for (cmd = commands; cmd; cmd = cmd->next)
694 cmd->error_string = "pre-receive hook declined";
698 check_aliased_updates(commands);
700 free(head_name_to_free);
701 head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
703 for (cmd = commands; cmd; cmd = cmd->next)
704 if (!cmd->skip_update)
705 cmd->error_string = update(cmd);
708 static struct command *read_head_info(void)
710 struct command *commands = NULL;
711 struct command **p = &commands;
713 static char line[1000];
714 unsigned char old_sha1[20], new_sha1[20];
719 len = packet_read_line(0, line, sizeof(line));
722 if (line[len-1] == '\n')
727 get_sha1_hex(line, old_sha1) ||
728 get_sha1_hex(line + 41, new_sha1))
729 die("protocol error: expected old/new/ref, got '%s'",
733 reflen = strlen(refname);
734 if (reflen + 82 < len) {
735 const char *feature_list = refname + reflen + 1;
736 if (parse_feature_request(feature_list, "report-status"))
738 if (parse_feature_request(feature_list, "side-band-64k"))
739 use_sideband = LARGE_PACKET_MAX;
740 if (parse_feature_request(feature_list, "quiet"))
743 cmd = xcalloc(1, sizeof(struct command) + len - 80);
744 hashcpy(cmd->old_sha1, old_sha1);
745 hashcpy(cmd->new_sha1, new_sha1);
746 memcpy(cmd->ref_name, line + 82, len - 81);
753 static const char *parse_pack_header(struct pack_header *hdr)
755 switch (read_pack_header(0, hdr)) {
757 return "eof before pack header was fully read";
759 case PH_ERROR_PACK_SIGNATURE:
760 return "protocol error (pack signature mismatch detected)";
762 case PH_ERROR_PROTOCOL:
763 return "protocol error (pack version unsupported)";
766 return "unknown error in parse_pack_header";
773 static const char *pack_lockfile;
775 static const char *unpack(void)
777 struct pack_header hdr;
780 int fsck_objects = (receive_fsck_objects >= 0
781 ? receive_fsck_objects
782 : transfer_fsck_objects >= 0
783 ? transfer_fsck_objects
786 hdr_err = parse_pack_header(&hdr);
789 snprintf(hdr_arg, sizeof(hdr_arg),
790 "--pack_header=%"PRIu32",%"PRIu32,
791 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
793 if (ntohl(hdr.hdr_entries) < unpack_limit) {
795 const char *unpacker[5];
796 unpacker[i++] = "unpack-objects";
798 unpacker[i++] = "-q";
800 unpacker[i++] = "--strict";
801 unpacker[i++] = hdr_arg;
802 unpacker[i++] = NULL;
803 code = run_command_v_opt(unpacker, RUN_GIT_CMD);
806 return "unpack-objects abnormal exit";
808 const char *keeper[7];
809 int s, status, i = 0;
811 struct child_process ip;
813 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
814 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
815 strcpy(keep_arg + s, "localhost");
817 keeper[i++] = "index-pack";
818 keeper[i++] = "--stdin";
820 keeper[i++] = "--strict";
821 keeper[i++] = "--fix-thin";
822 keeper[i++] = hdr_arg;
823 keeper[i++] = keep_arg;
825 memset(&ip, 0, sizeof(ip));
829 status = start_command(&ip);
831 return "index-pack fork failed";
833 pack_lockfile = index_pack_lockfile(ip.out);
835 status = finish_command(&ip);
837 reprepare_packed_git();
840 return "index-pack abnormal exit";
844 static void report(struct command *commands, const char *unpack_status)
847 struct strbuf buf = STRBUF_INIT;
849 packet_buf_write(&buf, "unpack %s\n",
850 unpack_status ? unpack_status : "ok");
851 for (cmd = commands; cmd; cmd = cmd->next) {
852 if (!cmd->error_string)
853 packet_buf_write(&buf, "ok %s\n",
856 packet_buf_write(&buf, "ng %s %s\n",
857 cmd->ref_name, cmd->error_string);
859 packet_buf_flush(&buf);
862 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
864 safe_write(1, buf.buf, buf.len);
865 strbuf_release(&buf);
868 static int delete_only(struct command *commands)
871 for (cmd = commands; cmd; cmd = cmd->next) {
872 if (!is_null_sha1(cmd->new_sha1))
878 static void add_one_alternate_sha1(const unsigned char sha1[20], void *unused)
880 add_extra_ref(".have", sha1, 0);
883 static void collect_one_alternate_ref(const struct ref *ref, void *data)
885 struct sha1_array *sa = data;
886 sha1_array_append(sa, ref->old_sha1);
889 static void add_alternate_refs(void)
891 struct sha1_array sa = SHA1_ARRAY_INIT;
892 for_each_alternate_ref(collect_one_alternate_ref, &sa);
893 sha1_array_for_each_unique(&sa, add_one_alternate_sha1, NULL);
894 sha1_array_clear(&sa);
897 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
899 int advertise_refs = 0;
900 int stateless_rpc = 0;
903 struct command *commands;
905 packet_trace_identity("receive-pack");
908 for (i = 1; i < argc; i++) {
909 const char *arg = *argv++;
912 if (!strcmp(arg, "--quiet")) {
917 if (!strcmp(arg, "--advertise-refs")) {
921 if (!strcmp(arg, "--stateless-rpc")) {
926 usage(receive_pack_usage);
929 usage(receive_pack_usage);
933 usage(receive_pack_usage);
937 if (!enter_repo(dir, 0))
938 die("'%s' does not appear to be a git repository", dir);
940 if (is_repository_shallow())
941 die("attempt to push into a shallow repository");
943 git_config(receive_pack_config, NULL);
945 if (0 <= transfer_unpack_limit)
946 unpack_limit = transfer_unpack_limit;
947 else if (0 <= receive_unpack_limit)
948 unpack_limit = receive_unpack_limit;
950 if (advertise_refs || !stateless_rpc) {
951 add_alternate_refs();
961 if ((commands = read_head_info()) != NULL) {
962 const char *unpack_status = NULL;
964 if (!delete_only(commands))
965 unpack_status = unpack();
966 execute_commands(commands, unpack_status);
968 unlink_or_warn(pack_lockfile);
970 report(commands, unpack_status);
971 run_receive_hook(commands, post_receive_hook, 1);
972 run_update_post_hook(commands);
974 const char *argv_gc_auto[] = {
975 "gc", "--auto", "--quiet", NULL,
977 run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
979 if (auto_update_server_info)
980 update_server_info(0);