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 void show_ref(const char *path, const unsigned char *sha1)
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;
131 static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
133 path = strip_namespace(path);
135 * Advertise refs outside our current namespace as ".have"
136 * refs, so that the client can use them to minimize data
137 * transfer but will otherwise ignore them. This happens to
138 * cover ".have" that are thrown in by add_one_alternate_ref()
139 * to mark histories that are complete in our alternates as
144 show_ref(path, sha1);
148 static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
150 show_ref(".have", sha1);
153 static void collect_one_alternate_ref(const struct ref *ref, void *data)
155 struct sha1_array *sa = data;
156 sha1_array_append(sa, ref->old_sha1);
159 static void write_head_info(void)
161 struct sha1_array sa = SHA1_ARRAY_INIT;
162 for_each_alternate_ref(collect_one_alternate_ref, &sa);
163 sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
164 sha1_array_clear(&sa);
165 for_each_ref(show_ref_cb, NULL);
166 if (!sent_capabilities)
167 show_ref("capabilities^{}", null_sha1);
174 struct command *next;
175 const char *error_string;
176 unsigned int skip_update:1,
178 unsigned char old_sha1[20];
179 unsigned char new_sha1[20];
180 char ref_name[FLEX_ARRAY]; /* more */
183 static const char pre_receive_hook[] = "hooks/pre-receive";
184 static const char post_receive_hook[] = "hooks/post-receive";
186 static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
187 static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
189 static void report_message(const char *prefix, const char *err, va_list params)
191 int sz = strlen(prefix);
194 strncpy(msg, prefix, sz);
195 sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
196 if (sz > (sizeof(msg) - 1))
197 sz = sizeof(msg) - 1;
201 send_sideband(1, 2, msg, sz, use_sideband);
206 static void rp_warning(const char *err, ...)
209 va_start(params, err);
210 report_message("warning: ", err, params);
214 static void rp_error(const char *err, ...)
217 va_start(params, err);
218 report_message("error: ", err, params);
222 static int copy_to_sideband(int in, int out, void *arg)
226 ssize_t sz = xread(in, data, sizeof(data));
229 send_sideband(1, 2, data, sz, use_sideband);
235 typedef int (*feed_fn)(void *, const char **, size_t *);
236 static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
238 struct child_process proc;
243 if (access(hook_name, X_OK) < 0)
249 memset(&proc, 0, sizeof(proc));
252 proc.stdout_to_stderr = 1;
255 memset(&muxer, 0, sizeof(muxer));
256 muxer.proc = copy_to_sideband;
258 code = start_async(&muxer);
264 code = start_command(&proc);
267 finish_async(&muxer);
274 if (feed(feed_state, &buf, &n))
276 if (write_in_full(proc.in, buf, n) != n)
281 finish_async(&muxer);
282 return finish_command(&proc);
285 struct receive_hook_feed_state {
291 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
293 struct receive_hook_feed_state *state = state_;
294 struct command *cmd = state->cmd;
297 state->skip_broken && (cmd->error_string || cmd->did_not_exist))
301 strbuf_reset(&state->buf);
302 strbuf_addf(&state->buf, "%s %s %s\n",
303 sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
305 state->cmd = cmd->next;
307 *bufp = state->buf.buf;
308 *sizep = state->buf.len;
313 static int run_receive_hook(struct command *commands, const char *hook_name,
316 struct receive_hook_feed_state state;
319 strbuf_init(&state.buf, 0);
320 state.cmd = commands;
321 state.skip_broken = skip_broken;
322 if (feed_receive_hook(&state, NULL, NULL))
324 state.cmd = commands;
325 status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
326 strbuf_release(&state.buf);
330 static int run_update_hook(struct command *cmd)
332 static const char update_hook[] = "hooks/update";
334 struct child_process proc;
337 if (access(update_hook, X_OK) < 0)
340 argv[0] = update_hook;
341 argv[1] = cmd->ref_name;
342 argv[2] = sha1_to_hex(cmd->old_sha1);
343 argv[3] = sha1_to_hex(cmd->new_sha1);
346 memset(&proc, 0, sizeof(proc));
348 proc.stdout_to_stderr = 1;
349 proc.err = use_sideband ? -1 : 0;
352 code = start_command(&proc);
356 copy_to_sideband(proc.err, -1, NULL);
357 return finish_command(&proc);
360 static int is_ref_checked_out(const char *ref)
362 if (is_bare_repository())
367 return !strcmp(head_name, ref);
370 static char *refuse_unconfigured_deny_msg[] = {
371 "By default, updating the current branch in a non-bare repository",
372 "is denied, because it will make the index and work tree inconsistent",
373 "with what you pushed, and will require 'git reset --hard' to match",
374 "the work tree to HEAD.",
376 "You can set 'receive.denyCurrentBranch' configuration variable to",
377 "'ignore' or 'warn' in the remote repository to allow pushing into",
378 "its current branch; however, this is not recommended unless you",
379 "arranged to update its work tree to match what you pushed in some",
382 "To squelch this message and still keep the default behaviour, set",
383 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
386 static void refuse_unconfigured_deny(void)
389 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
390 rp_error("%s", refuse_unconfigured_deny_msg[i]);
393 static char *refuse_unconfigured_deny_delete_current_msg[] = {
394 "By default, deleting the current branch is denied, because the next",
395 "'git clone' won't result in any file checked out, causing confusion.",
397 "You can set 'receive.denyDeleteCurrent' configuration variable to",
398 "'warn' or 'ignore' in the remote repository to allow deleting the",
399 "current branch, with or without a warning message.",
401 "To squelch this message, you can set it to 'refuse'."
404 static void refuse_unconfigured_deny_delete_current(void)
408 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
410 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
413 static const char *update(struct command *cmd)
415 const char *name = cmd->ref_name;
416 struct strbuf namespaced_name_buf = STRBUF_INIT;
417 const char *namespaced_name;
418 unsigned char *old_sha1 = cmd->old_sha1;
419 unsigned char *new_sha1 = cmd->new_sha1;
420 struct ref_lock *lock;
422 /* only refs/... are allowed */
423 if (prefixcmp(name, "refs/") || check_refname_format(name + 5, 0)) {
424 rp_error("refusing to create funny ref '%s' remotely", name);
425 return "funny refname";
428 strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
429 namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
431 if (is_ref_checked_out(namespaced_name)) {
432 switch (deny_current_branch) {
436 rp_warning("updating the current branch");
439 case DENY_UNCONFIGURED:
440 rp_error("refusing to update checked out branch: %s", name);
441 if (deny_current_branch == DENY_UNCONFIGURED)
442 refuse_unconfigured_deny();
443 return "branch is currently checked out";
447 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
448 error("unpack should have generated %s, "
449 "but I can't find it!", sha1_to_hex(new_sha1));
453 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
454 if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
455 rp_error("denying ref deletion for %s", name);
456 return "deletion prohibited";
459 if (!strcmp(namespaced_name, head_name)) {
460 switch (deny_delete_current) {
464 rp_warning("deleting the current branch");
467 case DENY_UNCONFIGURED:
468 if (deny_delete_current == DENY_UNCONFIGURED)
469 refuse_unconfigured_deny_delete_current();
470 rp_error("refusing to delete the current branch: %s", name);
471 return "deletion of the current branch prohibited";
476 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
477 !is_null_sha1(old_sha1) &&
478 !prefixcmp(name, "refs/heads/")) {
479 struct object *old_object, *new_object;
480 struct commit *old_commit, *new_commit;
481 struct commit_list *bases, *ent;
483 old_object = parse_object(old_sha1);
484 new_object = parse_object(new_sha1);
486 if (!old_object || !new_object ||
487 old_object->type != OBJ_COMMIT ||
488 new_object->type != OBJ_COMMIT) {
489 error("bad sha1 objects for %s", name);
492 old_commit = (struct commit *)old_object;
493 new_commit = (struct commit *)new_object;
494 bases = get_merge_bases(old_commit, new_commit, 1);
495 for (ent = bases; ent; ent = ent->next)
496 if (!hashcmp(old_sha1, ent->item->object.sha1))
498 free_commit_list(bases);
500 rp_error("denying non-fast-forward %s"
501 " (you should pull first)", name);
502 return "non-fast-forward";
505 if (run_update_hook(cmd)) {
506 rp_error("hook declined to update %s", name);
507 return "hook declined";
510 if (is_null_sha1(new_sha1)) {
511 if (!parse_object(old_sha1)) {
513 if (ref_exists(name)) {
514 rp_warning("Allowing deletion of corrupt ref.");
516 rp_warning("Deleting a non-existent ref.");
517 cmd->did_not_exist = 1;
520 if (delete_ref(namespaced_name, old_sha1, 0)) {
521 rp_error("failed to delete %s", name);
522 return "failed to delete";
524 return NULL; /* good */
527 lock = lock_any_ref_for_update(namespaced_name, old_sha1, 0);
529 rp_error("failed to lock %s", name);
530 return "failed to lock";
532 if (write_ref_sha1(lock, new_sha1, "push")) {
533 return "failed to write"; /* error() already called */
535 return NULL; /* good */
539 static char update_post_hook[] = "hooks/post-update";
541 static void run_update_post_hook(struct command *commands)
546 struct child_process proc;
548 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
549 if (cmd->error_string || cmd->did_not_exist)
553 if (!argc || access(update_post_hook, X_OK) < 0)
555 argv = xmalloc(sizeof(*argv) * (2 + argc));
556 argv[0] = update_post_hook;
558 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
560 if (cmd->error_string || cmd->did_not_exist)
562 p = xmalloc(strlen(cmd->ref_name) + 1);
563 strcpy(p, cmd->ref_name);
569 memset(&proc, 0, sizeof(proc));
571 proc.stdout_to_stderr = 1;
572 proc.err = use_sideband ? -1 : 0;
575 if (!start_command(&proc)) {
577 copy_to_sideband(proc.err, -1, NULL);
578 finish_command(&proc);
582 static void check_aliased_update(struct command *cmd, struct string_list *list)
584 struct strbuf buf = STRBUF_INIT;
585 const char *dst_name;
586 struct string_list_item *item;
587 struct command *dst_cmd;
588 unsigned char sha1[20];
589 char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
592 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
593 dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
594 strbuf_release(&buf);
596 if (!(flag & REF_ISSYMREF))
599 dst_name = strip_namespace(dst_name);
601 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
602 cmd->skip_update = 1;
603 cmd->error_string = "broken symref";
607 if ((item = string_list_lookup(list, dst_name)) == NULL)
610 cmd->skip_update = 1;
612 dst_cmd = (struct command *) item->util;
614 if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
615 !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
618 dst_cmd->skip_update = 1;
620 strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
621 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
622 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
623 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
624 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
625 " its target '%s' (%s..%s)",
626 cmd->ref_name, cmd_oldh, cmd_newh,
627 dst_cmd->ref_name, dst_oldh, dst_newh);
629 cmd->error_string = dst_cmd->error_string =
630 "inconsistent aliased update";
633 static void check_aliased_updates(struct command *commands)
636 struct string_list ref_list = STRING_LIST_INIT_NODUP;
638 for (cmd = commands; cmd; cmd = cmd->next) {
639 struct string_list_item *item =
640 string_list_append(&ref_list, cmd->ref_name);
641 item->util = (void *)cmd;
643 sort_string_list(&ref_list);
645 for (cmd = commands; cmd; cmd = cmd->next)
646 check_aliased_update(cmd, &ref_list);
648 string_list_clear(&ref_list, 0);
651 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
653 struct command **cmd_list = cb_data;
654 struct command *cmd = *cmd_list;
656 if (!cmd || is_null_sha1(cmd->new_sha1))
657 return -1; /* end of list */
658 *cmd_list = NULL; /* this returns only one */
659 hashcpy(sha1, cmd->new_sha1);
663 static void set_connectivity_errors(struct command *commands)
667 for (cmd = commands; cmd; cmd = cmd->next) {
668 struct command *singleton = cmd;
669 if (!check_everything_connected(command_singleton_iterator,
672 cmd->error_string = "missing necessary objects";
676 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
678 struct command **cmd_list = cb_data;
679 struct command *cmd = *cmd_list;
682 if (!is_null_sha1(cmd->new_sha1)) {
683 hashcpy(sha1, cmd->new_sha1);
684 *cmd_list = cmd->next;
690 return -1; /* end of list */
693 static void execute_commands(struct command *commands, const char *unpacker_error)
696 unsigned char sha1[20];
698 if (unpacker_error) {
699 for (cmd = commands; cmd; cmd = cmd->next)
700 cmd->error_string = "n/a (unpacker error)";
705 if (check_everything_connected(iterate_receive_command_list,
707 set_connectivity_errors(commands);
709 if (run_receive_hook(commands, pre_receive_hook, 0)) {
710 for (cmd = commands; cmd; cmd = cmd->next)
711 cmd->error_string = "pre-receive hook declined";
715 check_aliased_updates(commands);
717 free(head_name_to_free);
718 head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
720 for (cmd = commands; cmd; cmd = cmd->next)
721 if (!cmd->skip_update)
722 cmd->error_string = update(cmd);
725 static struct command *read_head_info(void)
727 struct command *commands = NULL;
728 struct command **p = &commands;
730 static char line[1000];
731 unsigned char old_sha1[20], new_sha1[20];
736 len = packet_read_line(0, line, sizeof(line));
739 if (line[len-1] == '\n')
744 get_sha1_hex(line, old_sha1) ||
745 get_sha1_hex(line + 41, new_sha1))
746 die("protocol error: expected old/new/ref, got '%s'",
750 reflen = strlen(refname);
751 if (reflen + 82 < len) {
752 const char *feature_list = refname + reflen + 1;
753 if (parse_feature_request(feature_list, "report-status"))
755 if (parse_feature_request(feature_list, "side-band-64k"))
756 use_sideband = LARGE_PACKET_MAX;
757 if (parse_feature_request(feature_list, "quiet"))
760 cmd = xcalloc(1, sizeof(struct command) + len - 80);
761 hashcpy(cmd->old_sha1, old_sha1);
762 hashcpy(cmd->new_sha1, new_sha1);
763 memcpy(cmd->ref_name, line + 82, len - 81);
770 static const char *parse_pack_header(struct pack_header *hdr)
772 switch (read_pack_header(0, hdr)) {
774 return "eof before pack header was fully read";
776 case PH_ERROR_PACK_SIGNATURE:
777 return "protocol error (pack signature mismatch detected)";
779 case PH_ERROR_PROTOCOL:
780 return "protocol error (pack version unsupported)";
783 return "unknown error in parse_pack_header";
790 static const char *pack_lockfile;
792 static const char *unpack(void)
794 struct pack_header hdr;
797 int fsck_objects = (receive_fsck_objects >= 0
798 ? receive_fsck_objects
799 : transfer_fsck_objects >= 0
800 ? transfer_fsck_objects
803 hdr_err = parse_pack_header(&hdr);
806 snprintf(hdr_arg, sizeof(hdr_arg),
807 "--pack_header=%"PRIu32",%"PRIu32,
808 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
810 if (ntohl(hdr.hdr_entries) < unpack_limit) {
812 const char *unpacker[5];
813 unpacker[i++] = "unpack-objects";
815 unpacker[i++] = "-q";
817 unpacker[i++] = "--strict";
818 unpacker[i++] = hdr_arg;
819 unpacker[i++] = NULL;
820 code = run_command_v_opt(unpacker, RUN_GIT_CMD);
823 return "unpack-objects abnormal exit";
825 const char *keeper[7];
826 int s, status, i = 0;
828 struct child_process ip;
830 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
831 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
832 strcpy(keep_arg + s, "localhost");
834 keeper[i++] = "index-pack";
835 keeper[i++] = "--stdin";
837 keeper[i++] = "--strict";
838 keeper[i++] = "--fix-thin";
839 keeper[i++] = hdr_arg;
840 keeper[i++] = keep_arg;
842 memset(&ip, 0, sizeof(ip));
846 status = start_command(&ip);
848 return "index-pack fork failed";
850 pack_lockfile = index_pack_lockfile(ip.out);
852 status = finish_command(&ip);
854 reprepare_packed_git();
857 return "index-pack abnormal exit";
861 static void report(struct command *commands, const char *unpack_status)
864 struct strbuf buf = STRBUF_INIT;
866 packet_buf_write(&buf, "unpack %s\n",
867 unpack_status ? unpack_status : "ok");
868 for (cmd = commands; cmd; cmd = cmd->next) {
869 if (!cmd->error_string)
870 packet_buf_write(&buf, "ok %s\n",
873 packet_buf_write(&buf, "ng %s %s\n",
874 cmd->ref_name, cmd->error_string);
876 packet_buf_flush(&buf);
879 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
881 safe_write(1, buf.buf, buf.len);
882 strbuf_release(&buf);
885 static int delete_only(struct command *commands)
888 for (cmd = commands; cmd; cmd = cmd->next) {
889 if (!is_null_sha1(cmd->new_sha1))
895 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
897 int advertise_refs = 0;
898 int stateless_rpc = 0;
901 struct command *commands;
903 packet_trace_identity("receive-pack");
906 for (i = 1; i < argc; i++) {
907 const char *arg = *argv++;
910 if (!strcmp(arg, "--quiet")) {
915 if (!strcmp(arg, "--advertise-refs")) {
919 if (!strcmp(arg, "--stateless-rpc")) {
924 usage(receive_pack_usage);
927 usage(receive_pack_usage);
931 usage(receive_pack_usage);
935 if (!enter_repo(dir, 0))
936 die("'%s' does not appear to be a git repository", dir);
938 if (is_repository_shallow())
939 die("attempt to push into a shallow repository");
941 git_config(receive_pack_config, NULL);
943 if (0 <= transfer_unpack_limit)
944 unpack_limit = transfer_unpack_limit;
945 else if (0 <= receive_unpack_limit)
946 unpack_limit = receive_unpack_limit;
948 if (advertise_refs || !stateless_rpc) {
954 if ((commands = read_head_info()) != NULL) {
955 const char *unpack_status = NULL;
957 if (!delete_only(commands))
958 unpack_status = unpack();
959 execute_commands(commands, unpack_status);
961 unlink_or_warn(pack_lockfile);
963 report(commands, unpack_status);
964 run_receive_hook(commands, post_receive_hook, 1);
965 run_update_post_hook(commands);
967 const char *argv_gc_auto[] = {
968 "gc", "--auto", "--quiet", NULL,
970 run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
972 if (auto_update_server_info)
973 update_server_info(0);