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 write_head_info(void)
148 for_each_ref(show_ref_cb, NULL);
149 if (!sent_capabilities)
150 show_ref("capabilities^{}", null_sha1, 0, NULL);
155 struct command *next;
156 const char *error_string;
157 unsigned int skip_update:1,
159 unsigned char old_sha1[20];
160 unsigned char new_sha1[20];
161 char ref_name[FLEX_ARRAY]; /* more */
164 static const char pre_receive_hook[] = "hooks/pre-receive";
165 static const char post_receive_hook[] = "hooks/post-receive";
167 static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
168 static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
170 static void report_message(const char *prefix, const char *err, va_list params)
172 int sz = strlen(prefix);
175 strncpy(msg, prefix, sz);
176 sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
177 if (sz > (sizeof(msg) - 1))
178 sz = sizeof(msg) - 1;
182 send_sideband(1, 2, msg, sz, use_sideband);
187 static void rp_warning(const char *err, ...)
190 va_start(params, err);
191 report_message("warning: ", err, params);
195 static void rp_error(const char *err, ...)
198 va_start(params, err);
199 report_message("error: ", err, params);
203 static int copy_to_sideband(int in, int out, void *arg)
207 ssize_t sz = xread(in, data, sizeof(data));
210 send_sideband(1, 2, data, sz, use_sideband);
216 typedef int (*feed_fn)(void *, const char **, size_t *);
217 static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
219 struct child_process proc;
224 if (access(hook_name, X_OK) < 0)
230 memset(&proc, 0, sizeof(proc));
233 proc.stdout_to_stderr = 1;
236 memset(&muxer, 0, sizeof(muxer));
237 muxer.proc = copy_to_sideband;
239 code = start_async(&muxer);
245 code = start_command(&proc);
248 finish_async(&muxer);
255 if (feed(feed_state, &buf, &n))
257 if (write_in_full(proc.in, buf, n) != n)
262 finish_async(&muxer);
263 return finish_command(&proc);
266 struct receive_hook_feed_state {
272 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
274 struct receive_hook_feed_state *state = state_;
275 struct command *cmd = state->cmd;
278 state->skip_broken && (cmd->error_string || cmd->did_not_exist))
282 strbuf_reset(&state->buf);
283 strbuf_addf(&state->buf, "%s %s %s\n",
284 sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
286 state->cmd = cmd->next;
288 *bufp = state->buf.buf;
289 *sizep = state->buf.len;
294 static int run_receive_hook(struct command *commands, const char *hook_name,
297 struct receive_hook_feed_state state;
300 strbuf_init(&state.buf, 0);
301 state.cmd = commands;
302 state.skip_broken = skip_broken;
303 if (feed_receive_hook(&state, NULL, NULL))
305 state.cmd = commands;
306 status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
307 strbuf_release(&state.buf);
311 static int run_update_hook(struct command *cmd)
313 static const char update_hook[] = "hooks/update";
315 struct child_process proc;
318 if (access(update_hook, X_OK) < 0)
321 argv[0] = update_hook;
322 argv[1] = cmd->ref_name;
323 argv[2] = sha1_to_hex(cmd->old_sha1);
324 argv[3] = sha1_to_hex(cmd->new_sha1);
327 memset(&proc, 0, sizeof(proc));
329 proc.stdout_to_stderr = 1;
330 proc.err = use_sideband ? -1 : 0;
333 code = start_command(&proc);
337 copy_to_sideband(proc.err, -1, NULL);
338 return finish_command(&proc);
341 static int is_ref_checked_out(const char *ref)
343 if (is_bare_repository())
348 return !strcmp(head_name, ref);
351 static char *refuse_unconfigured_deny_msg[] = {
352 "By default, updating the current branch in a non-bare repository",
353 "is denied, because it will make the index and work tree inconsistent",
354 "with what you pushed, and will require 'git reset --hard' to match",
355 "the work tree to HEAD.",
357 "You can set 'receive.denyCurrentBranch' configuration variable to",
358 "'ignore' or 'warn' in the remote repository to allow pushing into",
359 "its current branch; however, this is not recommended unless you",
360 "arranged to update its work tree to match what you pushed in some",
363 "To squelch this message and still keep the default behaviour, set",
364 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
367 static void refuse_unconfigured_deny(void)
370 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
371 rp_error("%s", refuse_unconfigured_deny_msg[i]);
374 static char *refuse_unconfigured_deny_delete_current_msg[] = {
375 "By default, deleting the current branch is denied, because the next",
376 "'git clone' won't result in any file checked out, causing confusion.",
378 "You can set 'receive.denyDeleteCurrent' configuration variable to",
379 "'warn' or 'ignore' in the remote repository to allow deleting the",
380 "current branch, with or without a warning message.",
382 "To squelch this message, you can set it to 'refuse'."
385 static void refuse_unconfigured_deny_delete_current(void)
389 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
391 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
394 static const char *update(struct command *cmd)
396 const char *name = cmd->ref_name;
397 struct strbuf namespaced_name_buf = STRBUF_INIT;
398 const char *namespaced_name;
399 unsigned char *old_sha1 = cmd->old_sha1;
400 unsigned char *new_sha1 = cmd->new_sha1;
401 struct ref_lock *lock;
403 /* only refs/... are allowed */
404 if (prefixcmp(name, "refs/") || check_refname_format(name + 5, 0)) {
405 rp_error("refusing to create funny ref '%s' remotely", name);
406 return "funny refname";
409 strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
410 namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
412 if (is_ref_checked_out(namespaced_name)) {
413 switch (deny_current_branch) {
417 rp_warning("updating the current branch");
420 case DENY_UNCONFIGURED:
421 rp_error("refusing to update checked out branch: %s", name);
422 if (deny_current_branch == DENY_UNCONFIGURED)
423 refuse_unconfigured_deny();
424 return "branch is currently checked out";
428 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
429 error("unpack should have generated %s, "
430 "but I can't find it!", sha1_to_hex(new_sha1));
434 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
435 if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
436 rp_error("denying ref deletion for %s", name);
437 return "deletion prohibited";
440 if (!strcmp(namespaced_name, head_name)) {
441 switch (deny_delete_current) {
445 rp_warning("deleting the current branch");
448 case DENY_UNCONFIGURED:
449 if (deny_delete_current == DENY_UNCONFIGURED)
450 refuse_unconfigured_deny_delete_current();
451 rp_error("refusing to delete the current branch: %s", name);
452 return "deletion of the current branch prohibited";
457 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
458 !is_null_sha1(old_sha1) &&
459 !prefixcmp(name, "refs/heads/")) {
460 struct object *old_object, *new_object;
461 struct commit *old_commit, *new_commit;
462 struct commit_list *bases, *ent;
464 old_object = parse_object(old_sha1);
465 new_object = parse_object(new_sha1);
467 if (!old_object || !new_object ||
468 old_object->type != OBJ_COMMIT ||
469 new_object->type != OBJ_COMMIT) {
470 error("bad sha1 objects for %s", name);
473 old_commit = (struct commit *)old_object;
474 new_commit = (struct commit *)new_object;
475 bases = get_merge_bases(old_commit, new_commit, 1);
476 for (ent = bases; ent; ent = ent->next)
477 if (!hashcmp(old_sha1, ent->item->object.sha1))
479 free_commit_list(bases);
481 rp_error("denying non-fast-forward %s"
482 " (you should pull first)", name);
483 return "non-fast-forward";
486 if (run_update_hook(cmd)) {
487 rp_error("hook declined to update %s", name);
488 return "hook declined";
491 if (is_null_sha1(new_sha1)) {
492 if (!parse_object(old_sha1)) {
494 if (ref_exists(name)) {
495 rp_warning("Allowing deletion of corrupt ref.");
497 rp_warning("Deleting a non-existent ref.");
498 cmd->did_not_exist = 1;
501 if (delete_ref(namespaced_name, old_sha1, 0)) {
502 rp_error("failed to delete %s", name);
503 return "failed to delete";
505 return NULL; /* good */
508 lock = lock_any_ref_for_update(namespaced_name, old_sha1, 0);
510 rp_error("failed to lock %s", name);
511 return "failed to lock";
513 if (write_ref_sha1(lock, new_sha1, "push")) {
514 return "failed to write"; /* error() already called */
516 return NULL; /* good */
520 static char update_post_hook[] = "hooks/post-update";
522 static void run_update_post_hook(struct command *commands)
527 struct child_process proc;
529 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
530 if (cmd->error_string || cmd->did_not_exist)
534 if (!argc || access(update_post_hook, X_OK) < 0)
536 argv = xmalloc(sizeof(*argv) * (2 + argc));
537 argv[0] = update_post_hook;
539 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
541 if (cmd->error_string || cmd->did_not_exist)
543 p = xmalloc(strlen(cmd->ref_name) + 1);
544 strcpy(p, cmd->ref_name);
550 memset(&proc, 0, sizeof(proc));
552 proc.stdout_to_stderr = 1;
553 proc.err = use_sideband ? -1 : 0;
556 if (!start_command(&proc)) {
558 copy_to_sideband(proc.err, -1, NULL);
559 finish_command(&proc);
563 static void check_aliased_update(struct command *cmd, struct string_list *list)
565 struct strbuf buf = STRBUF_INIT;
566 const char *dst_name;
567 struct string_list_item *item;
568 struct command *dst_cmd;
569 unsigned char sha1[20];
570 char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
573 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
574 dst_name = resolve_ref(buf.buf, sha1, 0, &flag);
575 strbuf_release(&buf);
577 if (!(flag & REF_ISSYMREF))
580 dst_name = strip_namespace(dst_name);
582 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
583 cmd->skip_update = 1;
584 cmd->error_string = "broken symref";
588 if ((item = string_list_lookup(list, dst_name)) == NULL)
591 cmd->skip_update = 1;
593 dst_cmd = (struct command *) item->util;
595 if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
596 !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
599 dst_cmd->skip_update = 1;
601 strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
602 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
603 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
604 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
605 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
606 " its target '%s' (%s..%s)",
607 cmd->ref_name, cmd_oldh, cmd_newh,
608 dst_cmd->ref_name, dst_oldh, dst_newh);
610 cmd->error_string = dst_cmd->error_string =
611 "inconsistent aliased update";
614 static void check_aliased_updates(struct command *commands)
617 struct string_list ref_list = STRING_LIST_INIT_NODUP;
619 for (cmd = commands; cmd; cmd = cmd->next) {
620 struct string_list_item *item =
621 string_list_append(&ref_list, cmd->ref_name);
622 item->util = (void *)cmd;
624 sort_string_list(&ref_list);
626 for (cmd = commands; cmd; cmd = cmd->next)
627 check_aliased_update(cmd, &ref_list);
629 string_list_clear(&ref_list, 0);
632 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
634 struct command **cmd_list = cb_data;
635 struct command *cmd = *cmd_list;
638 return -1; /* end of list */
639 *cmd_list = NULL; /* this returns only one */
640 hashcpy(sha1, cmd->new_sha1);
644 static void set_connectivity_errors(struct command *commands)
648 for (cmd = commands; cmd; cmd = cmd->next) {
649 struct command *singleton = cmd;
650 if (!check_everything_connected(command_singleton_iterator,
653 cmd->error_string = "missing necessary objects";
657 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
659 struct command **cmd_list = cb_data;
660 struct command *cmd = *cmd_list;
663 return -1; /* end of list */
664 *cmd_list = cmd->next;
665 hashcpy(sha1, cmd->new_sha1);
669 static void execute_commands(struct command *commands, const char *unpacker_error)
672 unsigned char sha1[20];
674 if (unpacker_error) {
675 for (cmd = commands; cmd; cmd = cmd->next)
676 cmd->error_string = "n/a (unpacker error)";
681 if (check_everything_connected(iterate_receive_command_list,
683 set_connectivity_errors(commands);
685 if (run_receive_hook(commands, pre_receive_hook, 0)) {
686 for (cmd = commands; cmd; cmd = cmd->next)
687 cmd->error_string = "pre-receive hook declined";
691 check_aliased_updates(commands);
693 head_name = resolve_ref("HEAD", sha1, 0, NULL);
695 for (cmd = commands; cmd; cmd = cmd->next)
696 if (!cmd->skip_update)
697 cmd->error_string = update(cmd);
700 static struct command *read_head_info(void)
702 struct command *commands = NULL;
703 struct command **p = &commands;
705 static char line[1000];
706 unsigned char old_sha1[20], new_sha1[20];
711 len = packet_read_line(0, line, sizeof(line));
714 if (line[len-1] == '\n')
719 get_sha1_hex(line, old_sha1) ||
720 get_sha1_hex(line + 41, new_sha1))
721 die("protocol error: expected old/new/ref, got '%s'",
725 reflen = strlen(refname);
726 if (reflen + 82 < len) {
727 if (strstr(refname + reflen + 1, "report-status"))
729 if (strstr(refname + reflen + 1, "side-band-64k"))
730 use_sideband = LARGE_PACKET_MAX;
732 cmd = xcalloc(1, sizeof(struct command) + len - 80);
733 hashcpy(cmd->old_sha1, old_sha1);
734 hashcpy(cmd->new_sha1, new_sha1);
735 memcpy(cmd->ref_name, line + 82, len - 81);
742 static const char *parse_pack_header(struct pack_header *hdr)
744 switch (read_pack_header(0, hdr)) {
746 return "eof before pack header was fully read";
748 case PH_ERROR_PACK_SIGNATURE:
749 return "protocol error (pack signature mismatch detected)";
751 case PH_ERROR_PROTOCOL:
752 return "protocol error (pack version unsupported)";
755 return "unknown error in parse_pack_header";
762 static const char *pack_lockfile;
764 static const char *unpack(void)
766 struct pack_header hdr;
769 int fsck_objects = (receive_fsck_objects >= 0
770 ? receive_fsck_objects
771 : transfer_fsck_objects >= 0
772 ? transfer_fsck_objects
775 hdr_err = parse_pack_header(&hdr);
778 snprintf(hdr_arg, sizeof(hdr_arg),
779 "--pack_header=%"PRIu32",%"PRIu32,
780 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
782 if (ntohl(hdr.hdr_entries) < unpack_limit) {
784 const char *unpacker[4];
785 unpacker[i++] = "unpack-objects";
787 unpacker[i++] = "--strict";
788 unpacker[i++] = hdr_arg;
789 unpacker[i++] = NULL;
790 code = run_command_v_opt(unpacker, RUN_GIT_CMD);
793 return "unpack-objects abnormal exit";
795 const char *keeper[7];
796 int s, status, i = 0;
798 struct child_process ip;
800 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
801 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
802 strcpy(keep_arg + s, "localhost");
804 keeper[i++] = "index-pack";
805 keeper[i++] = "--stdin";
807 keeper[i++] = "--strict";
808 keeper[i++] = "--fix-thin";
809 keeper[i++] = hdr_arg;
810 keeper[i++] = keep_arg;
812 memset(&ip, 0, sizeof(ip));
816 status = start_command(&ip);
818 return "index-pack fork failed";
820 pack_lockfile = index_pack_lockfile(ip.out);
822 status = finish_command(&ip);
824 reprepare_packed_git();
827 return "index-pack abnormal exit";
831 static void report(struct command *commands, const char *unpack_status)
834 struct strbuf buf = STRBUF_INIT;
836 packet_buf_write(&buf, "unpack %s\n",
837 unpack_status ? unpack_status : "ok");
838 for (cmd = commands; cmd; cmd = cmd->next) {
839 if (!cmd->error_string)
840 packet_buf_write(&buf, "ok %s\n",
843 packet_buf_write(&buf, "ng %s %s\n",
844 cmd->ref_name, cmd->error_string);
846 packet_buf_flush(&buf);
849 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
851 safe_write(1, buf.buf, buf.len);
852 strbuf_release(&buf);
855 static int delete_only(struct command *commands)
858 for (cmd = commands; cmd; cmd = cmd->next) {
859 if (!is_null_sha1(cmd->new_sha1))
865 static void add_one_alternate_sha1(const unsigned char sha1[20], void *unused)
867 add_extra_ref(".have", sha1, 0);
870 static void collect_one_alternate_ref(const struct ref *ref, void *data)
872 struct sha1_array *sa = data;
873 sha1_array_append(sa, ref->old_sha1);
876 static void add_alternate_refs(void)
878 struct sha1_array sa = SHA1_ARRAY_INIT;
879 for_each_alternate_ref(collect_one_alternate_ref, &sa);
880 sha1_array_for_each_unique(&sa, add_one_alternate_sha1, NULL);
881 sha1_array_clear(&sa);
884 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
886 int advertise_refs = 0;
887 int stateless_rpc = 0;
890 struct command *commands;
892 packet_trace_identity("receive-pack");
895 for (i = 1; i < argc; i++) {
896 const char *arg = *argv++;
899 if (!strcmp(arg, "--advertise-refs")) {
903 if (!strcmp(arg, "--stateless-rpc")) {
908 usage(receive_pack_usage);
911 usage(receive_pack_usage);
915 usage(receive_pack_usage);
919 if (!enter_repo(dir, 0))
920 die("'%s' does not appear to be a git repository", dir);
922 if (is_repository_shallow())
923 die("attempt to push into a shallow repository");
925 git_config(receive_pack_config, NULL);
927 if (0 <= transfer_unpack_limit)
928 unpack_limit = transfer_unpack_limit;
929 else if (0 <= receive_unpack_limit)
930 unpack_limit = receive_unpack_limit;
932 if (advertise_refs || !stateless_rpc) {
933 add_alternate_refs();
943 if ((commands = read_head_info()) != NULL) {
944 const char *unpack_status = NULL;
946 if (!delete_only(commands))
947 unpack_status = unpack();
948 execute_commands(commands, unpack_status);
950 unlink_or_warn(pack_lockfile);
952 report(commands, unpack_status);
953 run_receive_hook(commands, post_receive_hook, 1);
954 run_update_post_hook(commands);
956 const char *argv_gc_auto[] = {
957 "gc", "--auto", "--quiet", NULL,
959 run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
961 if (auto_update_server_info)
962 update_server_info(0);