remote.c: introduce a way to have different remotes for fetch/push
[alt-git.git] / builtin / receive-pack.c
blobccebd74f166f5d02e8e6a0bb6033d741f8580f7b
1 #include "builtin.h"
2 #include "pack.h"
3 #include "refs.h"
4 #include "pkt-line.h"
5 #include "sideband.h"
6 #include "run-command.h"
7 #include "exec_cmd.h"
8 #include "commit.h"
9 #include "object.h"
10 #include "remote.h"
11 #include "transport.h"
12 #include "string-list.h"
13 #include "sha1-array.h"
14 #include "connected.h"
15 #include "version.h"
17 static const char receive_pack_usage[] = "git receive-pack <git-dir>";
19 enum deny_action {
20 DENY_UNCONFIGURED,
21 DENY_IGNORE,
22 DENY_WARN,
23 DENY_REFUSE
26 static int deny_deletes;
27 static int deny_non_fast_forwards;
28 static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
29 static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
30 static int receive_fsck_objects = -1;
31 static int transfer_fsck_objects = -1;
32 static int receive_unpack_limit = -1;
33 static int transfer_unpack_limit = -1;
34 static int unpack_limit = 100;
35 static int report_status;
36 static int use_sideband;
37 static int quiet;
38 static int prefer_ofs_delta = 1;
39 static int auto_update_server_info;
40 static int auto_gc = 1;
41 static const char *head_name;
42 static void *head_name_to_free;
43 static int sent_capabilities;
45 static enum deny_action parse_deny_action(const char *var, const char *value)
47 if (value) {
48 if (!strcasecmp(value, "ignore"))
49 return DENY_IGNORE;
50 if (!strcasecmp(value, "warn"))
51 return DENY_WARN;
52 if (!strcasecmp(value, "refuse"))
53 return DENY_REFUSE;
55 if (git_config_bool(var, value))
56 return DENY_REFUSE;
57 return DENY_IGNORE;
60 static int receive_pack_config(const char *var, const char *value, void *cb)
62 int status = parse_hide_refs_config(var, value, "receive");
64 if (status)
65 return status;
67 if (strcmp(var, "receive.denydeletes") == 0) {
68 deny_deletes = git_config_bool(var, value);
69 return 0;
72 if (strcmp(var, "receive.denynonfastforwards") == 0) {
73 deny_non_fast_forwards = git_config_bool(var, value);
74 return 0;
77 if (strcmp(var, "receive.unpacklimit") == 0) {
78 receive_unpack_limit = git_config_int(var, value);
79 return 0;
82 if (strcmp(var, "transfer.unpacklimit") == 0) {
83 transfer_unpack_limit = git_config_int(var, value);
84 return 0;
87 if (strcmp(var, "receive.fsckobjects") == 0) {
88 receive_fsck_objects = git_config_bool(var, value);
89 return 0;
92 if (strcmp(var, "transfer.fsckobjects") == 0) {
93 transfer_fsck_objects = git_config_bool(var, value);
94 return 0;
97 if (!strcmp(var, "receive.denycurrentbranch")) {
98 deny_current_branch = parse_deny_action(var, value);
99 return 0;
102 if (strcmp(var, "receive.denydeletecurrent") == 0) {
103 deny_delete_current = parse_deny_action(var, value);
104 return 0;
107 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
108 prefer_ofs_delta = git_config_bool(var, value);
109 return 0;
112 if (strcmp(var, "receive.updateserverinfo") == 0) {
113 auto_update_server_info = git_config_bool(var, value);
114 return 0;
117 if (strcmp(var, "receive.autogc") == 0) {
118 auto_gc = git_config_bool(var, value);
119 return 0;
122 return git_default_config(var, value, cb);
125 static void show_ref(const char *path, const unsigned char *sha1)
127 if (ref_is_hidden(path))
128 return;
130 if (sent_capabilities)
131 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
132 else
133 packet_write(1, "%s %s%c%s%s agent=%s\n",
134 sha1_to_hex(sha1), path, 0,
135 " report-status delete-refs side-band-64k quiet",
136 prefer_ofs_delta ? " ofs-delta" : "",
137 git_user_agent_sanitized());
138 sent_capabilities = 1;
141 static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
143 path = strip_namespace(path);
145 * Advertise refs outside our current namespace as ".have"
146 * refs, so that the client can use them to minimize data
147 * transfer but will otherwise ignore them. This happens to
148 * cover ".have" that are thrown in by add_one_alternate_ref()
149 * to mark histories that are complete in our alternates as
150 * well.
152 if (!path)
153 path = ".have";
154 show_ref(path, sha1);
155 return 0;
158 static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
160 show_ref(".have", sha1);
163 static void collect_one_alternate_ref(const struct ref *ref, void *data)
165 struct sha1_array *sa = data;
166 sha1_array_append(sa, ref->old_sha1);
169 static void write_head_info(void)
171 struct sha1_array sa = SHA1_ARRAY_INIT;
172 for_each_alternate_ref(collect_one_alternate_ref, &sa);
173 sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
174 sha1_array_clear(&sa);
175 for_each_ref(show_ref_cb, NULL);
176 if (!sent_capabilities)
177 show_ref("capabilities^{}", null_sha1);
179 /* EOF */
180 packet_flush(1);
183 struct command {
184 struct command *next;
185 const char *error_string;
186 unsigned int skip_update:1,
187 did_not_exist:1;
188 unsigned char old_sha1[20];
189 unsigned char new_sha1[20];
190 char ref_name[FLEX_ARRAY]; /* more */
193 static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
194 static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
196 static void report_message(const char *prefix, const char *err, va_list params)
198 int sz = strlen(prefix);
199 char msg[4096];
201 strncpy(msg, prefix, sz);
202 sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
203 if (sz > (sizeof(msg) - 1))
204 sz = sizeof(msg) - 1;
205 msg[sz++] = '\n';
207 if (use_sideband)
208 send_sideband(1, 2, msg, sz, use_sideband);
209 else
210 xwrite(2, msg, sz);
213 static void rp_warning(const char *err, ...)
215 va_list params;
216 va_start(params, err);
217 report_message("warning: ", err, params);
218 va_end(params);
221 static void rp_error(const char *err, ...)
223 va_list params;
224 va_start(params, err);
225 report_message("error: ", err, params);
226 va_end(params);
229 static int copy_to_sideband(int in, int out, void *arg)
231 char data[128];
232 while (1) {
233 ssize_t sz = xread(in, data, sizeof(data));
234 if (sz <= 0)
235 break;
236 send_sideband(1, 2, data, sz, use_sideband);
238 close(in);
239 return 0;
242 typedef int (*feed_fn)(void *, const char **, size_t *);
243 static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
245 struct child_process proc;
246 struct async muxer;
247 const char *argv[2];
248 int code;
250 argv[0] = find_hook(hook_name);
251 if (!argv[0])
252 return 0;
254 argv[1] = NULL;
256 memset(&proc, 0, sizeof(proc));
257 proc.argv = argv;
258 proc.in = -1;
259 proc.stdout_to_stderr = 1;
261 if (use_sideband) {
262 memset(&muxer, 0, sizeof(muxer));
263 muxer.proc = copy_to_sideband;
264 muxer.in = -1;
265 code = start_async(&muxer);
266 if (code)
267 return code;
268 proc.err = muxer.in;
271 code = start_command(&proc);
272 if (code) {
273 if (use_sideband)
274 finish_async(&muxer);
275 return code;
278 while (1) {
279 const char *buf;
280 size_t n;
281 if (feed(feed_state, &buf, &n))
282 break;
283 if (write_in_full(proc.in, buf, n) != n)
284 break;
286 close(proc.in);
287 if (use_sideband)
288 finish_async(&muxer);
289 return finish_command(&proc);
292 struct receive_hook_feed_state {
293 struct command *cmd;
294 int skip_broken;
295 struct strbuf buf;
298 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
300 struct receive_hook_feed_state *state = state_;
301 struct command *cmd = state->cmd;
303 while (cmd &&
304 state->skip_broken && (cmd->error_string || cmd->did_not_exist))
305 cmd = cmd->next;
306 if (!cmd)
307 return -1; /* EOF */
308 strbuf_reset(&state->buf);
309 strbuf_addf(&state->buf, "%s %s %s\n",
310 sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
311 cmd->ref_name);
312 state->cmd = cmd->next;
313 if (bufp) {
314 *bufp = state->buf.buf;
315 *sizep = state->buf.len;
317 return 0;
320 static int run_receive_hook(struct command *commands, const char *hook_name,
321 int skip_broken)
323 struct receive_hook_feed_state state;
324 int status;
326 strbuf_init(&state.buf, 0);
327 state.cmd = commands;
328 state.skip_broken = skip_broken;
329 if (feed_receive_hook(&state, NULL, NULL))
330 return 0;
331 state.cmd = commands;
332 status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
333 strbuf_release(&state.buf);
334 return status;
337 static int run_update_hook(struct command *cmd)
339 const char *argv[5];
340 struct child_process proc;
341 int code;
343 argv[0] = find_hook("update");
344 if (!argv[0])
345 return 0;
347 argv[1] = cmd->ref_name;
348 argv[2] = sha1_to_hex(cmd->old_sha1);
349 argv[3] = sha1_to_hex(cmd->new_sha1);
350 argv[4] = NULL;
352 memset(&proc, 0, sizeof(proc));
353 proc.no_stdin = 1;
354 proc.stdout_to_stderr = 1;
355 proc.err = use_sideband ? -1 : 0;
356 proc.argv = argv;
358 code = start_command(&proc);
359 if (code)
360 return code;
361 if (use_sideband)
362 copy_to_sideband(proc.err, -1, NULL);
363 return finish_command(&proc);
366 static int is_ref_checked_out(const char *ref)
368 if (is_bare_repository())
369 return 0;
371 if (!head_name)
372 return 0;
373 return !strcmp(head_name, ref);
376 static char *refuse_unconfigured_deny_msg[] = {
377 "By default, updating the current branch in a non-bare repository",
378 "is denied, because it will make the index and work tree inconsistent",
379 "with what you pushed, and will require 'git reset --hard' to match",
380 "the work tree to HEAD.",
382 "You can set 'receive.denyCurrentBranch' configuration variable to",
383 "'ignore' or 'warn' in the remote repository to allow pushing into",
384 "its current branch; however, this is not recommended unless you",
385 "arranged to update its work tree to match what you pushed in some",
386 "other way.",
388 "To squelch this message and still keep the default behaviour, set",
389 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
392 static void refuse_unconfigured_deny(void)
394 int i;
395 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
396 rp_error("%s", refuse_unconfigured_deny_msg[i]);
399 static char *refuse_unconfigured_deny_delete_current_msg[] = {
400 "By default, deleting the current branch is denied, because the next",
401 "'git clone' won't result in any file checked out, causing confusion.",
403 "You can set 'receive.denyDeleteCurrent' configuration variable to",
404 "'warn' or 'ignore' in the remote repository to allow deleting the",
405 "current branch, with or without a warning message.",
407 "To squelch this message, you can set it to 'refuse'."
410 static void refuse_unconfigured_deny_delete_current(void)
412 int i;
413 for (i = 0;
414 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
415 i++)
416 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
419 static const char *update(struct command *cmd)
421 const char *name = cmd->ref_name;
422 struct strbuf namespaced_name_buf = STRBUF_INIT;
423 const char *namespaced_name;
424 unsigned char *old_sha1 = cmd->old_sha1;
425 unsigned char *new_sha1 = cmd->new_sha1;
426 struct ref_lock *lock;
428 /* only refs/... are allowed */
429 if (prefixcmp(name, "refs/") || check_refname_format(name + 5, 0)) {
430 rp_error("refusing to create funny ref '%s' remotely", name);
431 return "funny refname";
434 strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
435 namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
437 if (is_ref_checked_out(namespaced_name)) {
438 switch (deny_current_branch) {
439 case DENY_IGNORE:
440 break;
441 case DENY_WARN:
442 rp_warning("updating the current branch");
443 break;
444 case DENY_REFUSE:
445 case DENY_UNCONFIGURED:
446 rp_error("refusing to update checked out branch: %s", name);
447 if (deny_current_branch == DENY_UNCONFIGURED)
448 refuse_unconfigured_deny();
449 return "branch is currently checked out";
453 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
454 error("unpack should have generated %s, "
455 "but I can't find it!", sha1_to_hex(new_sha1));
456 return "bad pack";
459 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
460 if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
461 rp_error("denying ref deletion for %s", name);
462 return "deletion prohibited";
465 if (!strcmp(namespaced_name, head_name)) {
466 switch (deny_delete_current) {
467 case DENY_IGNORE:
468 break;
469 case DENY_WARN:
470 rp_warning("deleting the current branch");
471 break;
472 case DENY_REFUSE:
473 case DENY_UNCONFIGURED:
474 if (deny_delete_current == DENY_UNCONFIGURED)
475 refuse_unconfigured_deny_delete_current();
476 rp_error("refusing to delete the current branch: %s", name);
477 return "deletion of the current branch prohibited";
482 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
483 !is_null_sha1(old_sha1) &&
484 !prefixcmp(name, "refs/heads/")) {
485 struct object *old_object, *new_object;
486 struct commit *old_commit, *new_commit;
488 old_object = parse_object(old_sha1);
489 new_object = parse_object(new_sha1);
491 if (!old_object || !new_object ||
492 old_object->type != OBJ_COMMIT ||
493 new_object->type != OBJ_COMMIT) {
494 error("bad sha1 objects for %s", name);
495 return "bad ref";
497 old_commit = (struct commit *)old_object;
498 new_commit = (struct commit *)new_object;
499 if (!in_merge_bases(old_commit, new_commit)) {
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)) {
512 old_sha1 = NULL;
513 if (ref_exists(name)) {
514 rp_warning("Allowing deletion of corrupt ref.");
515 } else {
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 */
526 else {
527 lock = lock_any_ref_for_update(namespaced_name, old_sha1, 0);
528 if (!lock) {
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 void run_update_post_hook(struct command *commands)
541 struct command *cmd;
542 int argc;
543 const char **argv;
544 struct child_process proc;
545 char *hook;
547 hook = find_hook("post-update");
548 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
549 if (cmd->error_string || cmd->did_not_exist)
550 continue;
551 argc++;
553 if (!argc || !hook)
554 return;
556 argv = xmalloc(sizeof(*argv) * (2 + argc));
557 argv[0] = hook;
559 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
560 char *p;
561 if (cmd->error_string || cmd->did_not_exist)
562 continue;
563 p = xmalloc(strlen(cmd->ref_name) + 1);
564 strcpy(p, cmd->ref_name);
565 argv[argc] = p;
566 argc++;
568 argv[argc] = NULL;
570 memset(&proc, 0, sizeof(proc));
571 proc.no_stdin = 1;
572 proc.stdout_to_stderr = 1;
573 proc.err = use_sideband ? -1 : 0;
574 proc.argv = argv;
576 if (!start_command(&proc)) {
577 if (use_sideband)
578 copy_to_sideband(proc.err, -1, NULL);
579 finish_command(&proc);
583 static void check_aliased_update(struct command *cmd, struct string_list *list)
585 struct strbuf buf = STRBUF_INIT;
586 const char *dst_name;
587 struct string_list_item *item;
588 struct command *dst_cmd;
589 unsigned char sha1[20];
590 char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
591 int flag;
593 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
594 dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
595 strbuf_release(&buf);
597 if (!(flag & REF_ISSYMREF))
598 return;
600 dst_name = strip_namespace(dst_name);
601 if (!dst_name) {
602 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
603 cmd->skip_update = 1;
604 cmd->error_string = "broken symref";
605 return;
608 if ((item = string_list_lookup(list, dst_name)) == NULL)
609 return;
611 cmd->skip_update = 1;
613 dst_cmd = (struct command *) item->util;
615 if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
616 !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
617 return;
619 dst_cmd->skip_update = 1;
621 strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
622 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
623 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
624 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
625 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
626 " its target '%s' (%s..%s)",
627 cmd->ref_name, cmd_oldh, cmd_newh,
628 dst_cmd->ref_name, dst_oldh, dst_newh);
630 cmd->error_string = dst_cmd->error_string =
631 "inconsistent aliased update";
634 static void check_aliased_updates(struct command *commands)
636 struct command *cmd;
637 struct string_list ref_list = STRING_LIST_INIT_NODUP;
639 for (cmd = commands; cmd; cmd = cmd->next) {
640 struct string_list_item *item =
641 string_list_append(&ref_list, cmd->ref_name);
642 item->util = (void *)cmd;
644 sort_string_list(&ref_list);
646 for (cmd = commands; cmd; cmd = cmd->next) {
647 if (!cmd->error_string)
648 check_aliased_update(cmd, &ref_list);
651 string_list_clear(&ref_list, 0);
654 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
656 struct command **cmd_list = cb_data;
657 struct command *cmd = *cmd_list;
659 if (!cmd || is_null_sha1(cmd->new_sha1))
660 return -1; /* end of list */
661 *cmd_list = NULL; /* this returns only one */
662 hashcpy(sha1, cmd->new_sha1);
663 return 0;
666 static void set_connectivity_errors(struct command *commands)
668 struct command *cmd;
670 for (cmd = commands; cmd; cmd = cmd->next) {
671 struct command *singleton = cmd;
672 if (!check_everything_connected(command_singleton_iterator,
673 0, &singleton))
674 continue;
675 cmd->error_string = "missing necessary objects";
679 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
681 struct command **cmd_list = cb_data;
682 struct command *cmd = *cmd_list;
684 while (cmd) {
685 if (!is_null_sha1(cmd->new_sha1)) {
686 hashcpy(sha1, cmd->new_sha1);
687 *cmd_list = cmd->next;
688 return 0;
690 cmd = cmd->next;
692 *cmd_list = NULL;
693 return -1; /* end of list */
696 static void reject_updates_to_hidden(struct command *commands)
698 struct command *cmd;
700 for (cmd = commands; cmd; cmd = cmd->next) {
701 if (cmd->error_string || !ref_is_hidden(cmd->ref_name))
702 continue;
703 if (is_null_sha1(cmd->new_sha1))
704 cmd->error_string = "deny deleting a hidden ref";
705 else
706 cmd->error_string = "deny updating a hidden ref";
710 static void execute_commands(struct command *commands, const char *unpacker_error)
712 struct command *cmd;
713 unsigned char sha1[20];
715 if (unpacker_error) {
716 for (cmd = commands; cmd; cmd = cmd->next)
717 cmd->error_string = "unpacker error";
718 return;
721 cmd = commands;
722 if (check_everything_connected(iterate_receive_command_list,
723 0, &cmd))
724 set_connectivity_errors(commands);
726 reject_updates_to_hidden(commands);
728 if (run_receive_hook(commands, "pre-receive", 0)) {
729 for (cmd = commands; cmd; cmd = cmd->next) {
730 if (!cmd->error_string)
731 cmd->error_string = "pre-receive hook declined";
733 return;
736 check_aliased_updates(commands);
738 free(head_name_to_free);
739 head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
741 for (cmd = commands; cmd; cmd = cmd->next) {
742 if (cmd->error_string)
743 continue;
745 if (cmd->skip_update)
746 continue;
748 cmd->error_string = update(cmd);
752 static struct command *read_head_info(void)
754 struct command *commands = NULL;
755 struct command **p = &commands;
756 for (;;) {
757 char *line;
758 unsigned char old_sha1[20], new_sha1[20];
759 struct command *cmd;
760 char *refname;
761 int len, reflen;
763 line = packet_read_line(0, &len);
764 if (!line)
765 break;
766 if (len < 83 ||
767 line[40] != ' ' ||
768 line[81] != ' ' ||
769 get_sha1_hex(line, old_sha1) ||
770 get_sha1_hex(line + 41, new_sha1))
771 die("protocol error: expected old/new/ref, got '%s'",
772 line);
774 refname = line + 82;
775 reflen = strlen(refname);
776 if (reflen + 82 < len) {
777 const char *feature_list = refname + reflen + 1;
778 if (parse_feature_request(feature_list, "report-status"))
779 report_status = 1;
780 if (parse_feature_request(feature_list, "side-band-64k"))
781 use_sideband = LARGE_PACKET_MAX;
782 if (parse_feature_request(feature_list, "quiet"))
783 quiet = 1;
785 cmd = xcalloc(1, sizeof(struct command) + len - 80);
786 hashcpy(cmd->old_sha1, old_sha1);
787 hashcpy(cmd->new_sha1, new_sha1);
788 memcpy(cmd->ref_name, line + 82, len - 81);
789 *p = cmd;
790 p = &cmd->next;
792 return commands;
795 static const char *parse_pack_header(struct pack_header *hdr)
797 switch (read_pack_header(0, hdr)) {
798 case PH_ERROR_EOF:
799 return "eof before pack header was fully read";
801 case PH_ERROR_PACK_SIGNATURE:
802 return "protocol error (pack signature mismatch detected)";
804 case PH_ERROR_PROTOCOL:
805 return "protocol error (pack version unsupported)";
807 default:
808 return "unknown error in parse_pack_header";
810 case 0:
811 return NULL;
815 static const char *pack_lockfile;
817 static const char *unpack(int err_fd)
819 struct pack_header hdr;
820 const char *hdr_err;
821 char hdr_arg[38];
822 int fsck_objects = (receive_fsck_objects >= 0
823 ? receive_fsck_objects
824 : transfer_fsck_objects >= 0
825 ? transfer_fsck_objects
826 : 0);
828 hdr_err = parse_pack_header(&hdr);
829 if (hdr_err)
830 return hdr_err;
831 snprintf(hdr_arg, sizeof(hdr_arg),
832 "--pack_header=%"PRIu32",%"PRIu32,
833 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
835 if (ntohl(hdr.hdr_entries) < unpack_limit) {
836 int code, i = 0;
837 struct child_process child;
838 const char *unpacker[5];
839 unpacker[i++] = "unpack-objects";
840 if (quiet)
841 unpacker[i++] = "-q";
842 if (fsck_objects)
843 unpacker[i++] = "--strict";
844 unpacker[i++] = hdr_arg;
845 unpacker[i++] = NULL;
846 memset(&child, 0, sizeof(child));
847 child.argv = unpacker;
848 child.no_stdout = 1;
849 child.err = err_fd;
850 child.git_cmd = 1;
851 code = run_command(&child);
852 if (!code)
853 return NULL;
854 return "unpack-objects abnormal exit";
855 } else {
856 const char *keeper[7];
857 int s, status, i = 0;
858 char keep_arg[256];
859 struct child_process ip;
861 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
862 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
863 strcpy(keep_arg + s, "localhost");
865 keeper[i++] = "index-pack";
866 keeper[i++] = "--stdin";
867 if (fsck_objects)
868 keeper[i++] = "--strict";
869 keeper[i++] = "--fix-thin";
870 keeper[i++] = hdr_arg;
871 keeper[i++] = keep_arg;
872 keeper[i++] = NULL;
873 memset(&ip, 0, sizeof(ip));
874 ip.argv = keeper;
875 ip.out = -1;
876 ip.err = err_fd;
877 ip.git_cmd = 1;
878 status = start_command(&ip);
879 if (status) {
880 return "index-pack fork failed";
882 pack_lockfile = index_pack_lockfile(ip.out);
883 close(ip.out);
884 status = finish_command(&ip);
885 if (!status) {
886 reprepare_packed_git();
887 return NULL;
889 return "index-pack abnormal exit";
893 static const char *unpack_with_sideband(void)
895 struct async muxer;
896 const char *ret;
898 if (!use_sideband)
899 return unpack(0);
901 memset(&muxer, 0, sizeof(muxer));
902 muxer.proc = copy_to_sideband;
903 muxer.in = -1;
904 if (start_async(&muxer))
905 return NULL;
907 ret = unpack(muxer.in);
909 finish_async(&muxer);
910 return ret;
913 static void report(struct command *commands, const char *unpack_status)
915 struct command *cmd;
916 struct strbuf buf = STRBUF_INIT;
918 packet_buf_write(&buf, "unpack %s\n",
919 unpack_status ? unpack_status : "ok");
920 for (cmd = commands; cmd; cmd = cmd->next) {
921 if (!cmd->error_string)
922 packet_buf_write(&buf, "ok %s\n",
923 cmd->ref_name);
924 else
925 packet_buf_write(&buf, "ng %s %s\n",
926 cmd->ref_name, cmd->error_string);
928 packet_buf_flush(&buf);
930 if (use_sideband)
931 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
932 else
933 write_or_die(1, buf.buf, buf.len);
934 strbuf_release(&buf);
937 static int delete_only(struct command *commands)
939 struct command *cmd;
940 for (cmd = commands; cmd; cmd = cmd->next) {
941 if (!is_null_sha1(cmd->new_sha1))
942 return 0;
944 return 1;
947 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
949 int advertise_refs = 0;
950 int stateless_rpc = 0;
951 int i;
952 char *dir = NULL;
953 struct command *commands;
955 packet_trace_identity("receive-pack");
957 argv++;
958 for (i = 1; i < argc; i++) {
959 const char *arg = *argv++;
961 if (*arg == '-') {
962 if (!strcmp(arg, "--quiet")) {
963 quiet = 1;
964 continue;
967 if (!strcmp(arg, "--advertise-refs")) {
968 advertise_refs = 1;
969 continue;
971 if (!strcmp(arg, "--stateless-rpc")) {
972 stateless_rpc = 1;
973 continue;
976 usage(receive_pack_usage);
978 if (dir)
979 usage(receive_pack_usage);
980 dir = xstrdup(arg);
982 if (!dir)
983 usage(receive_pack_usage);
985 setup_path();
987 if (!enter_repo(dir, 0))
988 die("'%s' does not appear to be a git repository", dir);
990 if (is_repository_shallow())
991 die("attempt to push into a shallow repository");
993 git_config(receive_pack_config, NULL);
995 if (0 <= transfer_unpack_limit)
996 unpack_limit = transfer_unpack_limit;
997 else if (0 <= receive_unpack_limit)
998 unpack_limit = receive_unpack_limit;
1000 if (advertise_refs || !stateless_rpc) {
1001 write_head_info();
1003 if (advertise_refs)
1004 return 0;
1006 if ((commands = read_head_info()) != NULL) {
1007 const char *unpack_status = NULL;
1009 if (!delete_only(commands))
1010 unpack_status = unpack_with_sideband();
1011 execute_commands(commands, unpack_status);
1012 if (pack_lockfile)
1013 unlink_or_warn(pack_lockfile);
1014 if (report_status)
1015 report(commands, unpack_status);
1016 run_receive_hook(commands, "post-receive", 1);
1017 run_update_post_hook(commands);
1018 if (auto_gc) {
1019 const char *argv_gc_auto[] = {
1020 "gc", "--auto", "--quiet", NULL,
1022 int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1023 run_command_v_opt(argv_gc_auto, opt);
1025 if (auto_update_server_info)
1026 update_server_info(0);
1028 if (use_sideband)
1029 packet_flush(1);
1030 return 0;