6 #include "run-command.h"
12 #include "transport.h"
13 #include "string-list.h"
14 #include "sha1-array.h"
15 #include "connected.h"
16 #include "argv-array.h"
19 static const char receive_pack_usage[] = "git receive-pack <git-dir>";
28 static int deny_deletes;
29 static int deny_non_fast_forwards;
30 static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
31 static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
32 static int receive_fsck_objects = -1;
33 static int transfer_fsck_objects = -1;
34 static int receive_unpack_limit = -1;
35 static int transfer_unpack_limit = -1;
36 static int unpack_limit = 100;
37 static int report_status;
38 static int use_sideband;
40 static int prefer_ofs_delta = 1;
41 static int auto_update_server_info;
42 static int auto_gc = 1;
43 static int fix_thin = 1;
44 static const char *head_name;
45 static void *head_name_to_free;
46 static int sent_capabilities;
47 static int shallow_update;
48 static const char *alt_shallow_file;
50 static enum deny_action parse_deny_action(const char *var, const char *value)
53 if (!strcasecmp(value, "ignore"))
55 if (!strcasecmp(value, "warn"))
57 if (!strcasecmp(value, "refuse"))
60 if (git_config_bool(var, value))
65 static int receive_pack_config(const char *var, const char *value, void *cb)
67 int status = parse_hide_refs_config(var, value, "receive");
72 if (strcmp(var, "receive.denydeletes") == 0) {
73 deny_deletes = git_config_bool(var, value);
77 if (strcmp(var, "receive.denynonfastforwards") == 0) {
78 deny_non_fast_forwards = git_config_bool(var, value);
82 if (strcmp(var, "receive.unpacklimit") == 0) {
83 receive_unpack_limit = git_config_int(var, value);
87 if (strcmp(var, "transfer.unpacklimit") == 0) {
88 transfer_unpack_limit = git_config_int(var, value);
92 if (strcmp(var, "receive.fsckobjects") == 0) {
93 receive_fsck_objects = git_config_bool(var, value);
97 if (strcmp(var, "transfer.fsckobjects") == 0) {
98 transfer_fsck_objects = git_config_bool(var, value);
102 if (!strcmp(var, "receive.denycurrentbranch")) {
103 deny_current_branch = parse_deny_action(var, value);
107 if (strcmp(var, "receive.denydeletecurrent") == 0) {
108 deny_delete_current = parse_deny_action(var, value);
112 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
113 prefer_ofs_delta = git_config_bool(var, value);
117 if (strcmp(var, "receive.updateserverinfo") == 0) {
118 auto_update_server_info = git_config_bool(var, value);
122 if (strcmp(var, "receive.autogc") == 0) {
123 auto_gc = git_config_bool(var, value);
127 if (strcmp(var, "receive.shallowupdate") == 0) {
128 shallow_update = git_config_bool(var, value);
132 return git_default_config(var, value, cb);
135 static void show_ref(const char *path, const unsigned char *sha1)
137 if (ref_is_hidden(path))
140 if (sent_capabilities)
141 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
143 packet_write(1, "%s %s%c%s%s agent=%s\n",
144 sha1_to_hex(sha1), path, 0,
145 " report-status delete-refs side-band-64k quiet",
146 prefer_ofs_delta ? " ofs-delta" : "",
147 git_user_agent_sanitized());
148 sent_capabilities = 1;
151 static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
153 path = strip_namespace(path);
155 * Advertise refs outside our current namespace as ".have"
156 * refs, so that the client can use them to minimize data
157 * transfer but will otherwise ignore them. This happens to
158 * cover ".have" that are thrown in by add_one_alternate_ref()
159 * to mark histories that are complete in our alternates as
164 show_ref(path, sha1);
168 static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
170 show_ref(".have", sha1);
173 static void collect_one_alternate_ref(const struct ref *ref, void *data)
175 struct sha1_array *sa = data;
176 sha1_array_append(sa, ref->old_sha1);
179 static void write_head_info(void)
181 struct sha1_array sa = SHA1_ARRAY_INIT;
182 for_each_alternate_ref(collect_one_alternate_ref, &sa);
183 sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
184 sha1_array_clear(&sa);
185 for_each_ref(show_ref_cb, NULL);
186 if (!sent_capabilities)
187 show_ref("capabilities^{}", null_sha1);
189 advertise_shallow_grafts(1);
196 struct command *next;
197 const char *error_string;
198 unsigned int skip_update:1,
201 unsigned char old_sha1[20];
202 unsigned char new_sha1[20];
203 char ref_name[FLEX_ARRAY]; /* more */
206 static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
207 static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
209 static void report_message(const char *prefix, const char *err, va_list params)
211 int sz = strlen(prefix);
214 strncpy(msg, prefix, sz);
215 sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
216 if (sz > (sizeof(msg) - 1))
217 sz = sizeof(msg) - 1;
221 send_sideband(1, 2, msg, sz, use_sideband);
226 static void rp_warning(const char *err, ...)
229 va_start(params, err);
230 report_message("warning: ", err, params);
234 static void rp_error(const char *err, ...)
237 va_start(params, err);
238 report_message("error: ", err, params);
242 static int copy_to_sideband(int in, int out, void *arg)
246 ssize_t sz = xread(in, data, sizeof(data));
249 send_sideband(1, 2, data, sz, use_sideband);
255 typedef int (*feed_fn)(void *, const char **, size_t *);
256 static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
258 struct child_process proc;
263 argv[0] = find_hook(hook_name);
269 memset(&proc, 0, sizeof(proc));
272 proc.stdout_to_stderr = 1;
275 memset(&muxer, 0, sizeof(muxer));
276 muxer.proc = copy_to_sideband;
278 code = start_async(&muxer);
284 code = start_command(&proc);
287 finish_async(&muxer);
294 if (feed(feed_state, &buf, &n))
296 if (write_in_full(proc.in, buf, n) != n)
301 finish_async(&muxer);
302 return finish_command(&proc);
305 struct receive_hook_feed_state {
311 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
313 struct receive_hook_feed_state *state = state_;
314 struct command *cmd = state->cmd;
317 state->skip_broken && (cmd->error_string || cmd->did_not_exist))
321 strbuf_reset(&state->buf);
322 strbuf_addf(&state->buf, "%s %s %s\n",
323 sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
325 state->cmd = cmd->next;
327 *bufp = state->buf.buf;
328 *sizep = state->buf.len;
333 static int run_receive_hook(struct command *commands, const char *hook_name,
336 struct receive_hook_feed_state state;
339 strbuf_init(&state.buf, 0);
340 state.cmd = commands;
341 state.skip_broken = skip_broken;
342 if (feed_receive_hook(&state, NULL, NULL))
344 state.cmd = commands;
345 status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
346 strbuf_release(&state.buf);
350 static int run_update_hook(struct command *cmd)
353 struct child_process proc;
356 argv[0] = find_hook("update");
360 argv[1] = cmd->ref_name;
361 argv[2] = sha1_to_hex(cmd->old_sha1);
362 argv[3] = sha1_to_hex(cmd->new_sha1);
365 memset(&proc, 0, sizeof(proc));
367 proc.stdout_to_stderr = 1;
368 proc.err = use_sideband ? -1 : 0;
371 code = start_command(&proc);
375 copy_to_sideband(proc.err, -1, NULL);
376 return finish_command(&proc);
379 static int is_ref_checked_out(const char *ref)
381 if (is_bare_repository())
386 return !strcmp(head_name, ref);
389 static char *refuse_unconfigured_deny_msg[] = {
390 "By default, updating the current branch in a non-bare repository",
391 "is denied, because it will make the index and work tree inconsistent",
392 "with what you pushed, and will require 'git reset --hard' to match",
393 "the work tree to HEAD.",
395 "You can set 'receive.denyCurrentBranch' configuration variable to",
396 "'ignore' or 'warn' in the remote repository to allow pushing into",
397 "its current branch; however, this is not recommended unless you",
398 "arranged to update its work tree to match what you pushed in some",
401 "To squelch this message and still keep the default behaviour, set",
402 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
405 static void refuse_unconfigured_deny(void)
408 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
409 rp_error("%s", refuse_unconfigured_deny_msg[i]);
412 static char *refuse_unconfigured_deny_delete_current_msg[] = {
413 "By default, deleting the current branch is denied, because the next",
414 "'git clone' won't result in any file checked out, causing confusion.",
416 "You can set 'receive.denyDeleteCurrent' configuration variable to",
417 "'warn' or 'ignore' in the remote repository to allow deleting the",
418 "current branch, with or without a warning message.",
420 "To squelch this message, you can set it to 'refuse'."
423 static void refuse_unconfigured_deny_delete_current(void)
427 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
429 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
432 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20]);
433 static int update_shallow_ref(struct command *cmd, struct shallow_info *si)
435 static struct lock_file shallow_lock;
436 struct sha1_array extra = SHA1_ARRAY_INIT;
437 const char *alt_file;
438 uint32_t mask = 1 << (cmd->index % 32);
441 trace_printf_key("GIT_TRACE_SHALLOW",
442 "shallow: update_shallow_ref %s\n", cmd->ref_name);
443 for (i = 0; i < si->shallow->nr; i++)
444 if (si->used_shallow[i] &&
445 (si->used_shallow[i][cmd->index / 32] & mask) &&
446 !delayed_reachability_test(si, i))
447 sha1_array_append(&extra, si->shallow->sha1[i]);
449 setup_alternate_shallow(&shallow_lock, &alt_file, &extra);
450 if (check_shallow_connected(command_singleton_iterator,
452 rollback_lock_file(&shallow_lock);
453 sha1_array_clear(&extra);
457 commit_lock_file(&shallow_lock);
460 * Make sure setup_alternate_shallow() for the next ref does
461 * not lose these new roots..
463 for (i = 0; i < extra.nr; i++)
464 register_shallow(extra.sha1[i]);
466 si->shallow_ref[cmd->index] = 0;
467 sha1_array_clear(&extra);
471 static const char *update(struct command *cmd, struct shallow_info *si)
473 const char *name = cmd->ref_name;
474 struct strbuf namespaced_name_buf = STRBUF_INIT;
475 const char *namespaced_name;
476 unsigned char *old_sha1 = cmd->old_sha1;
477 unsigned char *new_sha1 = cmd->new_sha1;
478 struct ref_lock *lock;
480 /* only refs/... are allowed */
481 if (!starts_with(name, "refs/") || check_refname_format(name + 5, 0)) {
482 rp_error("refusing to create funny ref '%s' remotely", name);
483 return "funny refname";
486 strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
487 namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
489 if (is_ref_checked_out(namespaced_name)) {
490 switch (deny_current_branch) {
494 rp_warning("updating the current branch");
497 case DENY_UNCONFIGURED:
498 rp_error("refusing to update checked out branch: %s", name);
499 if (deny_current_branch == DENY_UNCONFIGURED)
500 refuse_unconfigured_deny();
501 return "branch is currently checked out";
505 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
506 error("unpack should have generated %s, "
507 "but I can't find it!", sha1_to_hex(new_sha1));
511 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
512 if (deny_deletes && starts_with(name, "refs/heads/")) {
513 rp_error("denying ref deletion for %s", name);
514 return "deletion prohibited";
517 if (!strcmp(namespaced_name, head_name)) {
518 switch (deny_delete_current) {
522 rp_warning("deleting the current branch");
525 case DENY_UNCONFIGURED:
526 if (deny_delete_current == DENY_UNCONFIGURED)
527 refuse_unconfigured_deny_delete_current();
528 rp_error("refusing to delete the current branch: %s", name);
529 return "deletion of the current branch prohibited";
534 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
535 !is_null_sha1(old_sha1) &&
536 starts_with(name, "refs/heads/")) {
537 struct object *old_object, *new_object;
538 struct commit *old_commit, *new_commit;
540 old_object = parse_object(old_sha1);
541 new_object = parse_object(new_sha1);
543 if (!old_object || !new_object ||
544 old_object->type != OBJ_COMMIT ||
545 new_object->type != OBJ_COMMIT) {
546 error("bad sha1 objects for %s", name);
549 old_commit = (struct commit *)old_object;
550 new_commit = (struct commit *)new_object;
551 if (!in_merge_bases(old_commit, new_commit)) {
552 rp_error("denying non-fast-forward %s"
553 " (you should pull first)", name);
554 return "non-fast-forward";
557 if (run_update_hook(cmd)) {
558 rp_error("hook declined to update %s", name);
559 return "hook declined";
562 if (is_null_sha1(new_sha1)) {
563 if (!parse_object(old_sha1)) {
565 if (ref_exists(name)) {
566 rp_warning("Allowing deletion of corrupt ref.");
568 rp_warning("Deleting a non-existent ref.");
569 cmd->did_not_exist = 1;
572 if (delete_ref(namespaced_name, old_sha1, 0)) {
573 rp_error("failed to delete %s", name);
574 return "failed to delete";
576 return NULL; /* good */
579 if (shallow_update && si->shallow_ref[cmd->index] &&
580 update_shallow_ref(cmd, si))
581 return "shallow error";
583 lock = lock_any_ref_for_update(namespaced_name, old_sha1,
586 rp_error("failed to lock %s", name);
587 return "failed to lock";
589 if (write_ref_sha1(lock, new_sha1, "push")) {
590 return "failed to write"; /* error() already called */
592 return NULL; /* good */
596 static void run_update_post_hook(struct command *commands)
601 struct child_process proc;
604 hook = find_hook("post-update");
605 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
606 if (cmd->error_string || cmd->did_not_exist)
613 argv = xmalloc(sizeof(*argv) * (2 + argc));
616 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
618 if (cmd->error_string || cmd->did_not_exist)
620 p = xmalloc(strlen(cmd->ref_name) + 1);
621 strcpy(p, cmd->ref_name);
627 memset(&proc, 0, sizeof(proc));
629 proc.stdout_to_stderr = 1;
630 proc.err = use_sideband ? -1 : 0;
633 if (!start_command(&proc)) {
635 copy_to_sideband(proc.err, -1, NULL);
636 finish_command(&proc);
640 static void check_aliased_update(struct command *cmd, struct string_list *list)
642 struct strbuf buf = STRBUF_INIT;
643 const char *dst_name;
644 struct string_list_item *item;
645 struct command *dst_cmd;
646 unsigned char sha1[20];
647 char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
650 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
651 dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
652 strbuf_release(&buf);
654 if (!(flag & REF_ISSYMREF))
657 dst_name = strip_namespace(dst_name);
659 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
660 cmd->skip_update = 1;
661 cmd->error_string = "broken symref";
665 if ((item = string_list_lookup(list, dst_name)) == NULL)
668 cmd->skip_update = 1;
670 dst_cmd = (struct command *) item->util;
672 if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
673 !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
676 dst_cmd->skip_update = 1;
678 strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
679 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
680 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
681 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
682 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
683 " its target '%s' (%s..%s)",
684 cmd->ref_name, cmd_oldh, cmd_newh,
685 dst_cmd->ref_name, dst_oldh, dst_newh);
687 cmd->error_string = dst_cmd->error_string =
688 "inconsistent aliased update";
691 static void check_aliased_updates(struct command *commands)
694 struct string_list ref_list = STRING_LIST_INIT_NODUP;
696 for (cmd = commands; cmd; cmd = cmd->next) {
697 struct string_list_item *item =
698 string_list_append(&ref_list, cmd->ref_name);
699 item->util = (void *)cmd;
701 sort_string_list(&ref_list);
703 for (cmd = commands; cmd; cmd = cmd->next) {
704 if (!cmd->error_string)
705 check_aliased_update(cmd, &ref_list);
708 string_list_clear(&ref_list, 0);
711 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
713 struct command **cmd_list = cb_data;
714 struct command *cmd = *cmd_list;
716 if (!cmd || is_null_sha1(cmd->new_sha1))
717 return -1; /* end of list */
718 *cmd_list = NULL; /* this returns only one */
719 hashcpy(sha1, cmd->new_sha1);
723 static void set_connectivity_errors(struct command *commands,
724 struct shallow_info *si)
728 for (cmd = commands; cmd; cmd = cmd->next) {
729 struct command *singleton = cmd;
730 if (shallow_update && si->shallow_ref[cmd->index])
731 /* to be checked in update_shallow_ref() */
733 if (!check_everything_connected(command_singleton_iterator,
736 cmd->error_string = "missing necessary objects";
740 struct iterate_data {
741 struct command *cmds;
742 struct shallow_info *si;
745 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
747 struct iterate_data *data = cb_data;
748 struct command **cmd_list = &data->cmds;
749 struct command *cmd = *cmd_list;
751 for (; cmd; cmd = cmd->next) {
752 if (shallow_update && data->si->shallow_ref[cmd->index])
753 /* to be checked in update_shallow_ref() */
755 if (!is_null_sha1(cmd->new_sha1) && !cmd->skip_update) {
756 hashcpy(sha1, cmd->new_sha1);
757 *cmd_list = cmd->next;
762 return -1; /* end of list */
765 static void reject_updates_to_hidden(struct command *commands)
769 for (cmd = commands; cmd; cmd = cmd->next) {
770 if (cmd->error_string || !ref_is_hidden(cmd->ref_name))
772 if (is_null_sha1(cmd->new_sha1))
773 cmd->error_string = "deny deleting a hidden ref";
775 cmd->error_string = "deny updating a hidden ref";
779 static void execute_commands(struct command *commands,
780 const char *unpacker_error,
781 struct shallow_info *si)
783 int checked_connectivity;
785 unsigned char sha1[20];
786 struct iterate_data data;
788 if (unpacker_error) {
789 for (cmd = commands; cmd; cmd = cmd->next)
790 cmd->error_string = "unpacker error";
794 data.cmds = commands;
796 if (check_everything_connected(iterate_receive_command_list, 0, &data))
797 set_connectivity_errors(commands, si);
799 reject_updates_to_hidden(commands);
801 if (run_receive_hook(commands, "pre-receive", 0)) {
802 for (cmd = commands; cmd; cmd = cmd->next) {
803 if (!cmd->error_string)
804 cmd->error_string = "pre-receive hook declined";
809 check_aliased_updates(commands);
811 free(head_name_to_free);
812 head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
814 checked_connectivity = 1;
815 for (cmd = commands; cmd; cmd = cmd->next) {
816 if (cmd->error_string)
819 if (cmd->skip_update)
822 cmd->error_string = update(cmd, si);
823 if (shallow_update && !cmd->error_string &&
824 si->shallow_ref[cmd->index]) {
825 error("BUG: connectivity check has not been run on ref %s",
827 checked_connectivity = 0;
831 if (shallow_update && !checked_connectivity)
832 error("BUG: run 'git fsck' for safety.\n"
833 "If there are errors, try to remove "
834 "the reported refs above");
837 static struct command *read_head_info(struct sha1_array *shallow)
839 struct command *commands = NULL;
840 struct command **p = &commands;
843 unsigned char old_sha1[20], new_sha1[20];
848 line = packet_read_line(0, &len);
852 if (len == 48 && starts_with(line, "shallow ")) {
853 if (get_sha1_hex(line + 8, old_sha1))
854 die("protocol error: expected shallow sha, got '%s'", line + 8);
855 sha1_array_append(shallow, old_sha1);
862 get_sha1_hex(line, old_sha1) ||
863 get_sha1_hex(line + 41, new_sha1))
864 die("protocol error: expected old/new/ref, got '%s'",
868 reflen = strlen(refname);
869 if (reflen + 82 < len) {
870 const char *feature_list = refname + reflen + 1;
871 if (parse_feature_request(feature_list, "report-status"))
873 if (parse_feature_request(feature_list, "side-band-64k"))
874 use_sideband = LARGE_PACKET_MAX;
875 if (parse_feature_request(feature_list, "quiet"))
878 cmd = xcalloc(1, sizeof(struct command) + len - 80);
879 hashcpy(cmd->old_sha1, old_sha1);
880 hashcpy(cmd->new_sha1, new_sha1);
881 memcpy(cmd->ref_name, line + 82, len - 81);
888 static const char *parse_pack_header(struct pack_header *hdr)
890 switch (read_pack_header(0, hdr)) {
892 return "eof before pack header was fully read";
894 case PH_ERROR_PACK_SIGNATURE:
895 return "protocol error (pack signature mismatch detected)";
897 case PH_ERROR_PROTOCOL:
898 return "protocol error (pack version unsupported)";
901 return "unknown error in parse_pack_header";
908 static const char *pack_lockfile;
910 static const char *unpack(int err_fd, struct shallow_info *si)
912 struct pack_header hdr;
916 struct child_process child;
917 int fsck_objects = (receive_fsck_objects >= 0
918 ? receive_fsck_objects
919 : transfer_fsck_objects >= 0
920 ? transfer_fsck_objects
923 hdr_err = parse_pack_header(&hdr);
929 snprintf(hdr_arg, sizeof(hdr_arg),
930 "--pack_header=%"PRIu32",%"PRIu32,
931 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
933 if (si->nr_ours || si->nr_theirs) {
934 alt_shallow_file = setup_temporary_shallow(si->shallow);
935 argv_array_push(&child.args, "--shallow-file");
936 argv_array_push(&child.args, alt_shallow_file);
939 memset(&child, 0, sizeof(child));
940 if (ntohl(hdr.hdr_entries) < unpack_limit) {
941 argv_array_pushl(&child.args, "unpack-objects", hdr_arg, NULL);
943 argv_array_push(&child.args, "-q");
945 argv_array_push(&child.args, "--strict");
949 status = run_command(&child);
951 return "unpack-objects abnormal exit";
956 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
957 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
958 strcpy(keep_arg + s, "localhost");
960 argv_array_pushl(&child.args, "index-pack",
961 "--stdin", hdr_arg, keep_arg, NULL);
963 argv_array_push(&child.args, "--strict");
965 argv_array_push(&child.args, "--fix-thin");
969 status = start_command(&child);
971 return "index-pack fork failed";
972 pack_lockfile = index_pack_lockfile(child.out);
974 status = finish_command(&child);
976 return "index-pack abnormal exit";
977 reprepare_packed_git();
982 static const char *unpack_with_sideband(struct shallow_info *si)
988 return unpack(0, si);
990 memset(&muxer, 0, sizeof(muxer));
991 muxer.proc = copy_to_sideband;
993 if (start_async(&muxer))
996 ret = unpack(muxer.in, si);
998 finish_async(&muxer);
1002 static void prepare_shallow_update(struct command *commands,
1003 struct shallow_info *si)
1005 int i, j, k, bitmap_size = (si->ref->nr + 31) / 32;
1007 si->used_shallow = xmalloc(sizeof(*si->used_shallow) *
1009 assign_shallow_commits_to_refs(si, si->used_shallow, NULL);
1011 si->need_reachability_test =
1012 xcalloc(si->shallow->nr, sizeof(*si->need_reachability_test));
1014 xcalloc(si->shallow->nr, sizeof(*si->reachable));
1015 si->shallow_ref = xcalloc(si->ref->nr, sizeof(*si->shallow_ref));
1017 for (i = 0; i < si->nr_ours; i++)
1018 si->need_reachability_test[si->ours[i]] = 1;
1020 for (i = 0; i < si->shallow->nr; i++) {
1021 if (!si->used_shallow[i])
1023 for (j = 0; j < bitmap_size; j++) {
1024 if (!si->used_shallow[i][j])
1026 si->need_reachability_test[i]++;
1027 for (k = 0; k < 32; k++)
1028 if (si->used_shallow[i][j] & (1 << k))
1029 si->shallow_ref[j * 32 + k]++;
1033 * true for those associated with some refs and belong
1034 * in "ours" list aka "step 7 not done yet"
1036 si->need_reachability_test[i] =
1037 si->need_reachability_test[i] > 1;
1041 * keep hooks happy by forcing a temporary shallow file via
1042 * env variable because we can't add --shallow-file to every
1043 * command. check_everything_connected() will be done with
1044 * true .git/shallow though.
1046 setenv(GIT_SHALLOW_FILE_ENVIRONMENT, alt_shallow_file, 1);
1049 static void update_shallow_info(struct command *commands,
1050 struct shallow_info *si,
1051 struct sha1_array *ref)
1053 struct command *cmd;
1055 remove_nonexistent_theirs_shallow(si);
1056 if (!si->nr_ours && !si->nr_theirs) {
1061 for (cmd = commands; cmd; cmd = cmd->next) {
1062 if (is_null_sha1(cmd->new_sha1))
1064 sha1_array_append(ref, cmd->new_sha1);
1065 cmd->index = ref->nr - 1;
1069 if (shallow_update) {
1070 prepare_shallow_update(commands, si);
1074 ref_status = xmalloc(sizeof(*ref_status) * ref->nr);
1075 assign_shallow_commits_to_refs(si, NULL, ref_status);
1076 for (cmd = commands; cmd; cmd = cmd->next) {
1077 if (is_null_sha1(cmd->new_sha1))
1079 if (ref_status[cmd->index]) {
1080 cmd->error_string = "shallow update not allowed";
1081 cmd->skip_update = 1;
1087 static void report(struct command *commands, const char *unpack_status)
1089 struct command *cmd;
1090 struct strbuf buf = STRBUF_INIT;
1092 packet_buf_write(&buf, "unpack %s\n",
1093 unpack_status ? unpack_status : "ok");
1094 for (cmd = commands; cmd; cmd = cmd->next) {
1095 if (!cmd->error_string)
1096 packet_buf_write(&buf, "ok %s\n",
1099 packet_buf_write(&buf, "ng %s %s\n",
1100 cmd->ref_name, cmd->error_string);
1102 packet_buf_flush(&buf);
1105 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
1107 write_or_die(1, buf.buf, buf.len);
1108 strbuf_release(&buf);
1111 static int delete_only(struct command *commands)
1113 struct command *cmd;
1114 for (cmd = commands; cmd; cmd = cmd->next) {
1115 if (!is_null_sha1(cmd->new_sha1))
1121 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
1123 int advertise_refs = 0;
1124 int stateless_rpc = 0;
1127 struct command *commands;
1128 struct sha1_array shallow = SHA1_ARRAY_INIT;
1129 struct sha1_array ref = SHA1_ARRAY_INIT;
1130 struct shallow_info si;
1132 packet_trace_identity("receive-pack");
1135 for (i = 1; i < argc; i++) {
1136 const char *arg = *argv++;
1139 if (!strcmp(arg, "--quiet")) {
1144 if (!strcmp(arg, "--advertise-refs")) {
1148 if (!strcmp(arg, "--stateless-rpc")) {
1152 if (!strcmp(arg, "--reject-thin-pack-for-testing")) {
1157 usage(receive_pack_usage);
1160 usage(receive_pack_usage);
1164 usage(receive_pack_usage);
1168 if (!enter_repo(dir, 0))
1169 die("'%s' does not appear to be a git repository", dir);
1171 git_config(receive_pack_config, NULL);
1173 if (0 <= transfer_unpack_limit)
1174 unpack_limit = transfer_unpack_limit;
1175 else if (0 <= receive_unpack_limit)
1176 unpack_limit = receive_unpack_limit;
1178 if (advertise_refs || !stateless_rpc) {
1184 if ((commands = read_head_info(&shallow)) != NULL) {
1185 const char *unpack_status = NULL;
1187 prepare_shallow_info(&si, &shallow);
1188 if (!si.nr_ours && !si.nr_theirs)
1190 if (!delete_only(commands)) {
1191 unpack_status = unpack_with_sideband(&si);
1192 update_shallow_info(commands, &si, &ref);
1194 execute_commands(commands, unpack_status, &si);
1196 unlink_or_warn(pack_lockfile);
1198 report(commands, unpack_status);
1199 run_receive_hook(commands, "post-receive", 1);
1200 run_update_post_hook(commands);
1202 const char *argv_gc_auto[] = {
1203 "gc", "--auto", "--quiet", NULL,
1205 int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1206 run_command_v_opt(argv_gc_auto, opt);
1208 if (auto_update_server_info)
1209 update_server_info(0);
1210 clear_shallow_info(&si);
1214 sha1_array_clear(&shallow);
1215 sha1_array_clear(&ref);