glossary-content.txt: rephrase magic signature part
[git.git] / builtin / receive-pack.c
blob67ce1ef105d1494e7905e66750b14676e082e11c
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 "connect.h"
12 #include "transport.h"
13 #include "string-list.h"
14 #include "sha1-array.h"
15 #include "connected.h"
16 #include "version.h"
18 static const char receive_pack_usage[] = "git receive-pack <git-dir>";
20 enum deny_action {
21 DENY_UNCONFIGURED,
22 DENY_IGNORE,
23 DENY_WARN,
24 DENY_REFUSE
27 static int deny_deletes;
28 static int deny_non_fast_forwards;
29 static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
30 static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
31 static int receive_fsck_objects = -1;
32 static int transfer_fsck_objects = -1;
33 static int receive_unpack_limit = -1;
34 static int transfer_unpack_limit = -1;
35 static int unpack_limit = 100;
36 static int report_status;
37 static int use_sideband;
38 static int quiet;
39 static int prefer_ofs_delta = 1;
40 static int auto_update_server_info;
41 static int auto_gc = 1;
42 static int fix_thin = 1;
43 static const char *head_name;
44 static void *head_name_to_free;
45 static int sent_capabilities;
47 static enum deny_action parse_deny_action(const char *var, const char *value)
49 if (value) {
50 if (!strcasecmp(value, "ignore"))
51 return DENY_IGNORE;
52 if (!strcasecmp(value, "warn"))
53 return DENY_WARN;
54 if (!strcasecmp(value, "refuse"))
55 return DENY_REFUSE;
57 if (git_config_bool(var, value))
58 return DENY_REFUSE;
59 return DENY_IGNORE;
62 static int receive_pack_config(const char *var, const char *value, void *cb)
64 int status = parse_hide_refs_config(var, value, "receive");
66 if (status)
67 return status;
69 if (strcmp(var, "receive.denydeletes") == 0) {
70 deny_deletes = git_config_bool(var, value);
71 return 0;
74 if (strcmp(var, "receive.denynonfastforwards") == 0) {
75 deny_non_fast_forwards = git_config_bool(var, value);
76 return 0;
79 if (strcmp(var, "receive.unpacklimit") == 0) {
80 receive_unpack_limit = git_config_int(var, value);
81 return 0;
84 if (strcmp(var, "transfer.unpacklimit") == 0) {
85 transfer_unpack_limit = git_config_int(var, value);
86 return 0;
89 if (strcmp(var, "receive.fsckobjects") == 0) {
90 receive_fsck_objects = git_config_bool(var, value);
91 return 0;
94 if (strcmp(var, "transfer.fsckobjects") == 0) {
95 transfer_fsck_objects = git_config_bool(var, value);
96 return 0;
99 if (!strcmp(var, "receive.denycurrentbranch")) {
100 deny_current_branch = parse_deny_action(var, value);
101 return 0;
104 if (strcmp(var, "receive.denydeletecurrent") == 0) {
105 deny_delete_current = parse_deny_action(var, value);
106 return 0;
109 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
110 prefer_ofs_delta = git_config_bool(var, value);
111 return 0;
114 if (strcmp(var, "receive.updateserverinfo") == 0) {
115 auto_update_server_info = git_config_bool(var, value);
116 return 0;
119 if (strcmp(var, "receive.autogc") == 0) {
120 auto_gc = git_config_bool(var, value);
121 return 0;
124 return git_default_config(var, value, cb);
127 static void show_ref(const char *path, const unsigned char *sha1)
129 if (ref_is_hidden(path))
130 return;
132 if (sent_capabilities)
133 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
134 else
135 packet_write(1, "%s %s%c%s%s agent=%s\n",
136 sha1_to_hex(sha1), path, 0,
137 " report-status delete-refs side-band-64k quiet",
138 prefer_ofs_delta ? " ofs-delta" : "",
139 git_user_agent_sanitized());
140 sent_capabilities = 1;
143 static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
145 path = strip_namespace(path);
147 * Advertise refs outside our current namespace as ".have"
148 * refs, so that the client can use them to minimize data
149 * transfer but will otherwise ignore them. This happens to
150 * cover ".have" that are thrown in by add_one_alternate_ref()
151 * to mark histories that are complete in our alternates as
152 * well.
154 if (!path)
155 path = ".have";
156 show_ref(path, sha1);
157 return 0;
160 static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
162 show_ref(".have", sha1);
165 static void collect_one_alternate_ref(const struct ref *ref, void *data)
167 struct sha1_array *sa = data;
168 sha1_array_append(sa, ref->old_sha1);
171 static void write_head_info(void)
173 struct sha1_array sa = SHA1_ARRAY_INIT;
174 for_each_alternate_ref(collect_one_alternate_ref, &sa);
175 sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
176 sha1_array_clear(&sa);
177 for_each_ref(show_ref_cb, NULL);
178 if (!sent_capabilities)
179 show_ref("capabilities^{}", null_sha1);
181 /* EOF */
182 packet_flush(1);
185 struct command {
186 struct command *next;
187 const char *error_string;
188 unsigned int skip_update:1,
189 did_not_exist:1;
190 unsigned char old_sha1[20];
191 unsigned char new_sha1[20];
192 char ref_name[FLEX_ARRAY]; /* more */
195 static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
196 static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
198 static void report_message(const char *prefix, const char *err, va_list params)
200 int sz = strlen(prefix);
201 char msg[4096];
203 strncpy(msg, prefix, sz);
204 sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
205 if (sz > (sizeof(msg) - 1))
206 sz = sizeof(msg) - 1;
207 msg[sz++] = '\n';
209 if (use_sideband)
210 send_sideband(1, 2, msg, sz, use_sideband);
211 else
212 xwrite(2, msg, sz);
215 static void rp_warning(const char *err, ...)
217 va_list params;
218 va_start(params, err);
219 report_message("warning: ", err, params);
220 va_end(params);
223 static void rp_error(const char *err, ...)
225 va_list params;
226 va_start(params, err);
227 report_message("error: ", err, params);
228 va_end(params);
231 static int copy_to_sideband(int in, int out, void *arg)
233 char data[128];
234 while (1) {
235 ssize_t sz = xread(in, data, sizeof(data));
236 if (sz <= 0)
237 break;
238 send_sideband(1, 2, data, sz, use_sideband);
240 close(in);
241 return 0;
244 typedef int (*feed_fn)(void *, const char **, size_t *);
245 static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
247 struct child_process proc;
248 struct async muxer;
249 const char *argv[2];
250 int code;
252 argv[0] = find_hook(hook_name);
253 if (!argv[0])
254 return 0;
256 argv[1] = NULL;
258 memset(&proc, 0, sizeof(proc));
259 proc.argv = argv;
260 proc.in = -1;
261 proc.stdout_to_stderr = 1;
263 if (use_sideband) {
264 memset(&muxer, 0, sizeof(muxer));
265 muxer.proc = copy_to_sideband;
266 muxer.in = -1;
267 code = start_async(&muxer);
268 if (code)
269 return code;
270 proc.err = muxer.in;
273 code = start_command(&proc);
274 if (code) {
275 if (use_sideband)
276 finish_async(&muxer);
277 return code;
280 while (1) {
281 const char *buf;
282 size_t n;
283 if (feed(feed_state, &buf, &n))
284 break;
285 if (write_in_full(proc.in, buf, n) != n)
286 break;
288 close(proc.in);
289 if (use_sideband)
290 finish_async(&muxer);
291 return finish_command(&proc);
294 struct receive_hook_feed_state {
295 struct command *cmd;
296 int skip_broken;
297 struct strbuf buf;
300 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
302 struct receive_hook_feed_state *state = state_;
303 struct command *cmd = state->cmd;
305 while (cmd &&
306 state->skip_broken && (cmd->error_string || cmd->did_not_exist))
307 cmd = cmd->next;
308 if (!cmd)
309 return -1; /* EOF */
310 strbuf_reset(&state->buf);
311 strbuf_addf(&state->buf, "%s %s %s\n",
312 sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
313 cmd->ref_name);
314 state->cmd = cmd->next;
315 if (bufp) {
316 *bufp = state->buf.buf;
317 *sizep = state->buf.len;
319 return 0;
322 static int run_receive_hook(struct command *commands, const char *hook_name,
323 int skip_broken)
325 struct receive_hook_feed_state state;
326 int status;
328 strbuf_init(&state.buf, 0);
329 state.cmd = commands;
330 state.skip_broken = skip_broken;
331 if (feed_receive_hook(&state, NULL, NULL))
332 return 0;
333 state.cmd = commands;
334 status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
335 strbuf_release(&state.buf);
336 return status;
339 static int run_update_hook(struct command *cmd)
341 const char *argv[5];
342 struct child_process proc;
343 int code;
345 argv[0] = find_hook("update");
346 if (!argv[0])
347 return 0;
349 argv[1] = cmd->ref_name;
350 argv[2] = sha1_to_hex(cmd->old_sha1);
351 argv[3] = sha1_to_hex(cmd->new_sha1);
352 argv[4] = NULL;
354 memset(&proc, 0, sizeof(proc));
355 proc.no_stdin = 1;
356 proc.stdout_to_stderr = 1;
357 proc.err = use_sideband ? -1 : 0;
358 proc.argv = argv;
360 code = start_command(&proc);
361 if (code)
362 return code;
363 if (use_sideband)
364 copy_to_sideband(proc.err, -1, NULL);
365 return finish_command(&proc);
368 static int is_ref_checked_out(const char *ref)
370 if (is_bare_repository())
371 return 0;
373 if (!head_name)
374 return 0;
375 return !strcmp(head_name, ref);
378 static char *refuse_unconfigured_deny_msg[] = {
379 "By default, updating the current branch in a non-bare repository",
380 "is denied, because it will make the index and work tree inconsistent",
381 "with what you pushed, and will require 'git reset --hard' to match",
382 "the work tree to HEAD.",
384 "You can set 'receive.denyCurrentBranch' configuration variable to",
385 "'ignore' or 'warn' in the remote repository to allow pushing into",
386 "its current branch; however, this is not recommended unless you",
387 "arranged to update its work tree to match what you pushed in some",
388 "other way.",
390 "To squelch this message and still keep the default behaviour, set",
391 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
394 static void refuse_unconfigured_deny(void)
396 int i;
397 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
398 rp_error("%s", refuse_unconfigured_deny_msg[i]);
401 static char *refuse_unconfigured_deny_delete_current_msg[] = {
402 "By default, deleting the current branch is denied, because the next",
403 "'git clone' won't result in any file checked out, causing confusion.",
405 "You can set 'receive.denyDeleteCurrent' configuration variable to",
406 "'warn' or 'ignore' in the remote repository to allow deleting the",
407 "current branch, with or without a warning message.",
409 "To squelch this message, you can set it to 'refuse'."
412 static void refuse_unconfigured_deny_delete_current(void)
414 int i;
415 for (i = 0;
416 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
417 i++)
418 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
421 static const char *update(struct command *cmd)
423 const char *name = cmd->ref_name;
424 struct strbuf namespaced_name_buf = STRBUF_INIT;
425 const char *namespaced_name;
426 unsigned char *old_sha1 = cmd->old_sha1;
427 unsigned char *new_sha1 = cmd->new_sha1;
428 struct ref_lock *lock;
430 /* only refs/... are allowed */
431 if (prefixcmp(name, "refs/") || check_refname_format(name + 5, 0)) {
432 rp_error("refusing to create funny ref '%s' remotely", name);
433 return "funny refname";
436 strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
437 namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
439 if (is_ref_checked_out(namespaced_name)) {
440 switch (deny_current_branch) {
441 case DENY_IGNORE:
442 break;
443 case DENY_WARN:
444 rp_warning("updating the current branch");
445 break;
446 case DENY_REFUSE:
447 case DENY_UNCONFIGURED:
448 rp_error("refusing to update checked out branch: %s", name);
449 if (deny_current_branch == DENY_UNCONFIGURED)
450 refuse_unconfigured_deny();
451 return "branch is currently checked out";
455 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
456 error("unpack should have generated %s, "
457 "but I can't find it!", sha1_to_hex(new_sha1));
458 return "bad pack";
461 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
462 if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
463 rp_error("denying ref deletion for %s", name);
464 return "deletion prohibited";
467 if (!strcmp(namespaced_name, head_name)) {
468 switch (deny_delete_current) {
469 case DENY_IGNORE:
470 break;
471 case DENY_WARN:
472 rp_warning("deleting the current branch");
473 break;
474 case DENY_REFUSE:
475 case DENY_UNCONFIGURED:
476 if (deny_delete_current == DENY_UNCONFIGURED)
477 refuse_unconfigured_deny_delete_current();
478 rp_error("refusing to delete the current branch: %s", name);
479 return "deletion of the current branch prohibited";
484 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
485 !is_null_sha1(old_sha1) &&
486 !prefixcmp(name, "refs/heads/")) {
487 struct object *old_object, *new_object;
488 struct commit *old_commit, *new_commit;
490 old_object = parse_object(old_sha1);
491 new_object = parse_object(new_sha1);
493 if (!old_object || !new_object ||
494 old_object->type != OBJ_COMMIT ||
495 new_object->type != OBJ_COMMIT) {
496 error("bad sha1 objects for %s", name);
497 return "bad ref";
499 old_commit = (struct commit *)old_object;
500 new_commit = (struct commit *)new_object;
501 if (!in_merge_bases(old_commit, new_commit)) {
502 rp_error("denying non-fast-forward %s"
503 " (you should pull first)", name);
504 return "non-fast-forward";
507 if (run_update_hook(cmd)) {
508 rp_error("hook declined to update %s", name);
509 return "hook declined";
512 if (is_null_sha1(new_sha1)) {
513 if (!parse_object(old_sha1)) {
514 old_sha1 = NULL;
515 if (ref_exists(name)) {
516 rp_warning("Allowing deletion of corrupt ref.");
517 } else {
518 rp_warning("Deleting a non-existent ref.");
519 cmd->did_not_exist = 1;
522 if (delete_ref(namespaced_name, old_sha1, 0)) {
523 rp_error("failed to delete %s", name);
524 return "failed to delete";
526 return NULL; /* good */
528 else {
529 lock = lock_any_ref_for_update(namespaced_name, old_sha1,
530 0, NULL);
531 if (!lock) {
532 rp_error("failed to lock %s", name);
533 return "failed to lock";
535 if (write_ref_sha1(lock, new_sha1, "push")) {
536 return "failed to write"; /* error() already called */
538 return NULL; /* good */
542 static void run_update_post_hook(struct command *commands)
544 struct command *cmd;
545 int argc;
546 const char **argv;
547 struct child_process proc;
548 char *hook;
550 hook = find_hook("post-update");
551 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
552 if (cmd->error_string || cmd->did_not_exist)
553 continue;
554 argc++;
556 if (!argc || !hook)
557 return;
559 argv = xmalloc(sizeof(*argv) * (2 + argc));
560 argv[0] = hook;
562 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
563 char *p;
564 if (cmd->error_string || cmd->did_not_exist)
565 continue;
566 p = xmalloc(strlen(cmd->ref_name) + 1);
567 strcpy(p, cmd->ref_name);
568 argv[argc] = p;
569 argc++;
571 argv[argc] = NULL;
573 memset(&proc, 0, sizeof(proc));
574 proc.no_stdin = 1;
575 proc.stdout_to_stderr = 1;
576 proc.err = use_sideband ? -1 : 0;
577 proc.argv = argv;
579 if (!start_command(&proc)) {
580 if (use_sideband)
581 copy_to_sideband(proc.err, -1, NULL);
582 finish_command(&proc);
586 static void check_aliased_update(struct command *cmd, struct string_list *list)
588 struct strbuf buf = STRBUF_INIT;
589 const char *dst_name;
590 struct string_list_item *item;
591 struct command *dst_cmd;
592 unsigned char sha1[20];
593 char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
594 int flag;
596 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
597 dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
598 strbuf_release(&buf);
600 if (!(flag & REF_ISSYMREF))
601 return;
603 dst_name = strip_namespace(dst_name);
604 if (!dst_name) {
605 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
606 cmd->skip_update = 1;
607 cmd->error_string = "broken symref";
608 return;
611 if ((item = string_list_lookup(list, dst_name)) == NULL)
612 return;
614 cmd->skip_update = 1;
616 dst_cmd = (struct command *) item->util;
618 if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
619 !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
620 return;
622 dst_cmd->skip_update = 1;
624 strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
625 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
626 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
627 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
628 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
629 " its target '%s' (%s..%s)",
630 cmd->ref_name, cmd_oldh, cmd_newh,
631 dst_cmd->ref_name, dst_oldh, dst_newh);
633 cmd->error_string = dst_cmd->error_string =
634 "inconsistent aliased update";
637 static void check_aliased_updates(struct command *commands)
639 struct command *cmd;
640 struct string_list ref_list = STRING_LIST_INIT_NODUP;
642 for (cmd = commands; cmd; cmd = cmd->next) {
643 struct string_list_item *item =
644 string_list_append(&ref_list, cmd->ref_name);
645 item->util = (void *)cmd;
647 sort_string_list(&ref_list);
649 for (cmd = commands; cmd; cmd = cmd->next) {
650 if (!cmd->error_string)
651 check_aliased_update(cmd, &ref_list);
654 string_list_clear(&ref_list, 0);
657 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
659 struct command **cmd_list = cb_data;
660 struct command *cmd = *cmd_list;
662 if (!cmd || is_null_sha1(cmd->new_sha1))
663 return -1; /* end of list */
664 *cmd_list = NULL; /* this returns only one */
665 hashcpy(sha1, cmd->new_sha1);
666 return 0;
669 static void set_connectivity_errors(struct command *commands)
671 struct command *cmd;
673 for (cmd = commands; cmd; cmd = cmd->next) {
674 struct command *singleton = cmd;
675 if (!check_everything_connected(command_singleton_iterator,
676 0, &singleton))
677 continue;
678 cmd->error_string = "missing necessary objects";
682 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
684 struct command **cmd_list = cb_data;
685 struct command *cmd = *cmd_list;
687 while (cmd) {
688 if (!is_null_sha1(cmd->new_sha1)) {
689 hashcpy(sha1, cmd->new_sha1);
690 *cmd_list = cmd->next;
691 return 0;
693 cmd = cmd->next;
695 *cmd_list = NULL;
696 return -1; /* end of list */
699 static void reject_updates_to_hidden(struct command *commands)
701 struct command *cmd;
703 for (cmd = commands; cmd; cmd = cmd->next) {
704 if (cmd->error_string || !ref_is_hidden(cmd->ref_name))
705 continue;
706 if (is_null_sha1(cmd->new_sha1))
707 cmd->error_string = "deny deleting a hidden ref";
708 else
709 cmd->error_string = "deny updating a hidden ref";
713 static void execute_commands(struct command *commands, const char *unpacker_error)
715 struct command *cmd;
716 unsigned char sha1[20];
718 if (unpacker_error) {
719 for (cmd = commands; cmd; cmd = cmd->next)
720 cmd->error_string = "unpacker error";
721 return;
724 cmd = commands;
725 if (check_everything_connected(iterate_receive_command_list,
726 0, &cmd))
727 set_connectivity_errors(commands);
729 reject_updates_to_hidden(commands);
731 if (run_receive_hook(commands, "pre-receive", 0)) {
732 for (cmd = commands; cmd; cmd = cmd->next) {
733 if (!cmd->error_string)
734 cmd->error_string = "pre-receive hook declined";
736 return;
739 check_aliased_updates(commands);
741 free(head_name_to_free);
742 head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
744 for (cmd = commands; cmd; cmd = cmd->next) {
745 if (cmd->error_string)
746 continue;
748 if (cmd->skip_update)
749 continue;
751 cmd->error_string = update(cmd);
755 static struct command *read_head_info(void)
757 struct command *commands = NULL;
758 struct command **p = &commands;
759 for (;;) {
760 char *line;
761 unsigned char old_sha1[20], new_sha1[20];
762 struct command *cmd;
763 char *refname;
764 int len, reflen;
766 line = packet_read_line(0, &len);
767 if (!line)
768 break;
769 if (len < 83 ||
770 line[40] != ' ' ||
771 line[81] != ' ' ||
772 get_sha1_hex(line, old_sha1) ||
773 get_sha1_hex(line + 41, new_sha1))
774 die("protocol error: expected old/new/ref, got '%s'",
775 line);
777 refname = line + 82;
778 reflen = strlen(refname);
779 if (reflen + 82 < len) {
780 const char *feature_list = refname + reflen + 1;
781 if (parse_feature_request(feature_list, "report-status"))
782 report_status = 1;
783 if (parse_feature_request(feature_list, "side-band-64k"))
784 use_sideband = LARGE_PACKET_MAX;
785 if (parse_feature_request(feature_list, "quiet"))
786 quiet = 1;
788 cmd = xcalloc(1, sizeof(struct command) + len - 80);
789 hashcpy(cmd->old_sha1, old_sha1);
790 hashcpy(cmd->new_sha1, new_sha1);
791 memcpy(cmd->ref_name, line + 82, len - 81);
792 *p = cmd;
793 p = &cmd->next;
795 return commands;
798 static const char *parse_pack_header(struct pack_header *hdr)
800 switch (read_pack_header(0, hdr)) {
801 case PH_ERROR_EOF:
802 return "eof before pack header was fully read";
804 case PH_ERROR_PACK_SIGNATURE:
805 return "protocol error (pack signature mismatch detected)";
807 case PH_ERROR_PROTOCOL:
808 return "protocol error (pack version unsupported)";
810 default:
811 return "unknown error in parse_pack_header";
813 case 0:
814 return NULL;
818 static const char *pack_lockfile;
820 static const char *unpack(int err_fd)
822 struct pack_header hdr;
823 const char *hdr_err;
824 char hdr_arg[38];
825 int fsck_objects = (receive_fsck_objects >= 0
826 ? receive_fsck_objects
827 : transfer_fsck_objects >= 0
828 ? transfer_fsck_objects
829 : 0);
831 hdr_err = parse_pack_header(&hdr);
832 if (hdr_err) {
833 if (err_fd > 0)
834 close(err_fd);
835 return hdr_err;
837 snprintf(hdr_arg, sizeof(hdr_arg),
838 "--pack_header=%"PRIu32",%"PRIu32,
839 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
841 if (ntohl(hdr.hdr_entries) < unpack_limit) {
842 int code, i = 0;
843 struct child_process child;
844 const char *unpacker[5];
845 unpacker[i++] = "unpack-objects";
846 if (quiet)
847 unpacker[i++] = "-q";
848 if (fsck_objects)
849 unpacker[i++] = "--strict";
850 unpacker[i++] = hdr_arg;
851 unpacker[i++] = NULL;
852 memset(&child, 0, sizeof(child));
853 child.argv = unpacker;
854 child.no_stdout = 1;
855 child.err = err_fd;
856 child.git_cmd = 1;
857 code = run_command(&child);
858 if (!code)
859 return NULL;
860 return "unpack-objects abnormal exit";
861 } else {
862 const char *keeper[7];
863 int s, status, i = 0;
864 char keep_arg[256];
865 struct child_process ip;
867 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
868 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
869 strcpy(keep_arg + s, "localhost");
871 keeper[i++] = "index-pack";
872 keeper[i++] = "--stdin";
873 if (fsck_objects)
874 keeper[i++] = "--strict";
875 if (fix_thin)
876 keeper[i++] = "--fix-thin";
877 keeper[i++] = hdr_arg;
878 keeper[i++] = keep_arg;
879 keeper[i++] = NULL;
880 memset(&ip, 0, sizeof(ip));
881 ip.argv = keeper;
882 ip.out = -1;
883 ip.err = err_fd;
884 ip.git_cmd = 1;
885 status = start_command(&ip);
886 if (status) {
887 return "index-pack fork failed";
889 pack_lockfile = index_pack_lockfile(ip.out);
890 close(ip.out);
891 status = finish_command(&ip);
892 if (!status) {
893 reprepare_packed_git();
894 return NULL;
896 return "index-pack abnormal exit";
900 static const char *unpack_with_sideband(void)
902 struct async muxer;
903 const char *ret;
905 if (!use_sideband)
906 return unpack(0);
908 memset(&muxer, 0, sizeof(muxer));
909 muxer.proc = copy_to_sideband;
910 muxer.in = -1;
911 if (start_async(&muxer))
912 return NULL;
914 ret = unpack(muxer.in);
916 finish_async(&muxer);
917 return ret;
920 static void report(struct command *commands, const char *unpack_status)
922 struct command *cmd;
923 struct strbuf buf = STRBUF_INIT;
925 packet_buf_write(&buf, "unpack %s\n",
926 unpack_status ? unpack_status : "ok");
927 for (cmd = commands; cmd; cmd = cmd->next) {
928 if (!cmd->error_string)
929 packet_buf_write(&buf, "ok %s\n",
930 cmd->ref_name);
931 else
932 packet_buf_write(&buf, "ng %s %s\n",
933 cmd->ref_name, cmd->error_string);
935 packet_buf_flush(&buf);
937 if (use_sideband)
938 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
939 else
940 write_or_die(1, buf.buf, buf.len);
941 strbuf_release(&buf);
944 static int delete_only(struct command *commands)
946 struct command *cmd;
947 for (cmd = commands; cmd; cmd = cmd->next) {
948 if (!is_null_sha1(cmd->new_sha1))
949 return 0;
951 return 1;
954 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
956 int advertise_refs = 0;
957 int stateless_rpc = 0;
958 int i;
959 char *dir = NULL;
960 struct command *commands;
962 packet_trace_identity("receive-pack");
964 argv++;
965 for (i = 1; i < argc; i++) {
966 const char *arg = *argv++;
968 if (*arg == '-') {
969 if (!strcmp(arg, "--quiet")) {
970 quiet = 1;
971 continue;
974 if (!strcmp(arg, "--advertise-refs")) {
975 advertise_refs = 1;
976 continue;
978 if (!strcmp(arg, "--stateless-rpc")) {
979 stateless_rpc = 1;
980 continue;
982 if (!strcmp(arg, "--reject-thin-pack-for-testing")) {
983 fix_thin = 0;
984 continue;
987 usage(receive_pack_usage);
989 if (dir)
990 usage(receive_pack_usage);
991 dir = xstrdup(arg);
993 if (!dir)
994 usage(receive_pack_usage);
996 setup_path();
998 if (!enter_repo(dir, 0))
999 die("'%s' does not appear to be a git repository", dir);
1001 if (is_repository_shallow())
1002 die("attempt to push into a shallow repository");
1004 git_config(receive_pack_config, NULL);
1006 if (0 <= transfer_unpack_limit)
1007 unpack_limit = transfer_unpack_limit;
1008 else if (0 <= receive_unpack_limit)
1009 unpack_limit = receive_unpack_limit;
1011 if (advertise_refs || !stateless_rpc) {
1012 write_head_info();
1014 if (advertise_refs)
1015 return 0;
1017 if ((commands = read_head_info()) != NULL) {
1018 const char *unpack_status = NULL;
1020 if (!delete_only(commands))
1021 unpack_status = unpack_with_sideband();
1022 execute_commands(commands, unpack_status);
1023 if (pack_lockfile)
1024 unlink_or_warn(pack_lockfile);
1025 if (report_status)
1026 report(commands, unpack_status);
1027 run_receive_hook(commands, "post-receive", 1);
1028 run_update_post_hook(commands);
1029 if (auto_gc) {
1030 const char *argv_gc_auto[] = {
1031 "gc", "--auto", "--quiet", NULL,
1033 int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1034 run_command_v_opt(argv_gc_auto, opt);
1036 if (auto_update_server_info)
1037 update_server_info(0);
1039 if (use_sideband)
1040 packet_flush(1);
1041 return 0;