French translation: copy -> copie.
[git/dscho.git] / builtin / receive-pack.c
blob1188a7734f4f55a1d91881c7dfad9c24c630642b
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,
24 DENY_UPDATE_INSTEAD,
25 DENY_DETACH_INSTEAD,
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;
39 static int quiet;
40 static int prefer_ofs_delta = 1;
41 static int auto_update_server_info;
42 static int auto_gc = 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 if (strcmp(var, "receive.denydeletes") == 0) {
65 deny_deletes = git_config_bool(var, value);
66 return 0;
69 if (strcmp(var, "receive.denynonfastforwards") == 0) {
70 deny_non_fast_forwards = git_config_bool(var, value);
71 return 0;
74 if (strcmp(var, "receive.unpacklimit") == 0) {
75 receive_unpack_limit = git_config_int(var, value);
76 return 0;
79 if (strcmp(var, "transfer.unpacklimit") == 0) {
80 transfer_unpack_limit = git_config_int(var, value);
81 return 0;
84 if (strcmp(var, "receive.fsckobjects") == 0) {
85 receive_fsck_objects = git_config_bool(var, value);
86 return 0;
89 if (strcmp(var, "transfer.fsckobjects") == 0) {
90 transfer_fsck_objects = git_config_bool(var, value);
91 return 0;
94 if (!strcmp(var, "receive.denycurrentbranch")) {
95 if (value && !strcasecmp(value, "updateinstead"))
96 deny_current_branch = DENY_UPDATE_INSTEAD;
97 else if (value && !strcasecmp(value, "detachinstead"))
98 deny_current_branch = DENY_DETACH_INSTEAD;
99 else
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 (sent_capabilities)
130 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
131 else
132 packet_write(1, "%s %s%c%s%s agent=%s\n",
133 sha1_to_hex(sha1), path, 0,
134 " report-status delete-refs side-band-64k quiet",
135 prefer_ofs_delta ? " ofs-delta" : "",
136 git_user_agent_sanitized());
137 sent_capabilities = 1;
140 static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
142 path = strip_namespace(path);
144 * Advertise refs outside our current namespace as ".have"
145 * refs, so that the client can use them to minimize data
146 * transfer but will otherwise ignore them. This happens to
147 * cover ".have" that are thrown in by add_one_alternate_ref()
148 * to mark histories that are complete in our alternates as
149 * well.
151 if (!path)
152 path = ".have";
153 show_ref(path, sha1);
154 return 0;
157 static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
159 show_ref(".have", sha1);
162 static void collect_one_alternate_ref(const struct ref *ref, void *data)
164 struct sha1_array *sa = data;
165 sha1_array_append(sa, ref->old_sha1);
168 static void write_head_info(void)
170 struct sha1_array sa = SHA1_ARRAY_INIT;
171 for_each_alternate_ref(collect_one_alternate_ref, &sa);
172 sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
173 sha1_array_clear(&sa);
174 for_each_ref(show_ref_cb, NULL);
175 if (!sent_capabilities)
176 show_ref("capabilities^{}", null_sha1);
178 /* EOF */
179 packet_flush(1);
182 struct command {
183 struct command *next;
184 const char *error_string;
185 unsigned int skip_update:1,
186 did_not_exist:1;
187 unsigned char old_sha1[20];
188 unsigned char new_sha1[20];
189 char ref_name[FLEX_ARRAY]; /* more */
192 static const char pre_receive_hook[] = "hooks/pre-receive";
193 static const char post_receive_hook[] = "hooks/post-receive";
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 if (access(hook_name, X_OK) < 0)
253 return 0;
255 argv[0] = hook_name;
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 static const char update_hook[] = "hooks/update";
342 const char *argv[5];
343 struct child_process proc;
344 int code;
346 if (access(update_hook, X_OK) < 0)
347 return 0;
349 argv[0] = update_hook;
350 argv[1] = cmd->ref_name;
351 argv[2] = sha1_to_hex(cmd->old_sha1);
352 argv[3] = sha1_to_hex(cmd->new_sha1);
353 argv[4] = NULL;
355 memset(&proc, 0, sizeof(proc));
356 proc.no_stdin = 1;
357 proc.stdout_to_stderr = 1;
358 proc.err = use_sideband ? -1 : 0;
359 proc.argv = argv;
361 code = start_command(&proc);
362 if (code)
363 return code;
364 if (use_sideband)
365 copy_to_sideband(proc.err, -1, NULL);
366 return finish_command(&proc);
369 static int is_ref_checked_out(const char *ref)
371 if (is_bare_repository())
372 return 0;
374 if (!head_name)
375 return 0;
376 return !strcmp(head_name, ref);
379 static char *refuse_unconfigured_deny_msg[] = {
380 "By default, updating the current branch in a non-bare repository",
381 "is denied, because it will make the index and work tree inconsistent",
382 "with what you pushed, and will require 'git reset --hard' to match",
383 "the work tree to HEAD.",
385 "You can set 'receive.denyCurrentBranch' configuration variable to",
386 "'ignore' or 'warn' in the remote repository to allow pushing into",
387 "its current branch; however, this is not recommended unless you",
388 "arranged to update its work tree to match what you pushed in some",
389 "other way.",
391 "To squelch this message and still keep the default behaviour, set",
392 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
395 static void refuse_unconfigured_deny(void)
397 int i;
398 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
399 rp_error("%s", refuse_unconfigured_deny_msg[i]);
402 static char *refuse_unconfigured_deny_delete_current_msg[] = {
403 "By default, deleting the current branch is denied, because the next",
404 "'git clone' won't result in any file checked out, causing confusion.",
406 "You can set 'receive.denyDeleteCurrent' configuration variable to",
407 "'warn' or 'ignore' in the remote repository to allow deleting the",
408 "current branch, with or without a warning message.",
410 "To squelch this message, you can set it to 'refuse'."
413 static void refuse_unconfigured_deny_delete_current(void)
415 int i;
416 for (i = 0;
417 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
418 i++)
419 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
422 static void merge_worktree(unsigned char *sha1)
424 const char *update_refresh[] = {
425 "update-index", "--ignore-submodules", "--refresh", NULL
427 const char *read_tree[] = {
428 "read-tree", "-u", "-m", sha1_to_hex(sha1), NULL
430 struct child_process child;
431 struct strbuf git_env = STRBUF_INIT;
432 const char *env[2];
434 if (is_bare_repository())
435 die ("denyCurrentBranch = updateInstead needs a worktree");
437 strbuf_addf(&git_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
438 env[0] = git_env.buf;
439 env[1] = NULL;
441 memset(&child, 0, sizeof(child));
442 child.argv = update_refresh;
443 child.env = env;
444 child.dir = git_work_tree_cfg ? git_work_tree_cfg : "..";
445 child.stdout_to_stderr = 1;
446 child.git_cmd = 1;
447 if (run_command(&child))
448 die ("Could not refresh the index");
450 child.argv = read_tree;
451 child.no_stdin = 1;
452 child.no_stdout = 1;
453 child.stdout_to_stderr = 0;
454 if (run_command(&child))
455 die ("Could not merge working tree with new HEAD. Good luck.");
457 strbuf_release(&git_env);
460 static const char *update(struct command *cmd)
462 const char *name = cmd->ref_name;
463 struct strbuf namespaced_name_buf = STRBUF_INIT;
464 const char *namespaced_name;
465 unsigned char *old_sha1 = cmd->old_sha1;
466 unsigned char *new_sha1 = cmd->new_sha1;
467 struct ref_lock *lock;
469 /* only refs/... are allowed */
470 if (prefixcmp(name, "refs/") || check_refname_format(name + 5, 0)) {
471 rp_error("refusing to create funny ref '%s' remotely", name);
472 return "funny refname";
475 strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
476 namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
478 if (is_ref_checked_out(namespaced_name)) {
479 switch (deny_current_branch) {
480 case DENY_IGNORE:
481 break;
482 case DENY_WARN:
483 rp_warning("updating the current branch");
484 break;
485 case DENY_REFUSE:
486 case DENY_UNCONFIGURED:
487 rp_error("refusing to update checked out branch: %s", name);
488 if (deny_current_branch == DENY_UNCONFIGURED)
489 refuse_unconfigured_deny();
490 return "branch is currently checked out";
491 case DENY_UPDATE_INSTEAD:
492 merge_worktree(new_sha1);
493 break;
494 case DENY_DETACH_INSTEAD:
495 update_ref("push into current branch (detach)", "HEAD",
496 old_sha1, NULL, REF_NODEREF, DIE_ON_ERR);
497 break;
501 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
502 error("unpack should have generated %s, "
503 "but I can't find it!", sha1_to_hex(new_sha1));
504 return "bad pack";
507 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
508 if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
509 rp_error("denying ref deletion for %s", name);
510 return "deletion prohibited";
513 if (!strcmp(namespaced_name, head_name)) {
514 switch (deny_delete_current) {
515 case DENY_IGNORE:
516 break;
517 case DENY_WARN:
518 rp_warning("deleting the current branch");
519 break;
520 case DENY_REFUSE:
521 case DENY_UNCONFIGURED:
522 if (deny_delete_current == DENY_UNCONFIGURED)
523 refuse_unconfigured_deny_delete_current();
524 rp_error("refusing to delete the current branch: %s", name);
525 return "deletion of the current branch prohibited";
526 default:
527 die ("Invalid denyDeleteCurrent setting");
532 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
533 !is_null_sha1(old_sha1) &&
534 !prefixcmp(name, "refs/heads/")) {
535 struct object *old_object, *new_object;
536 struct commit *old_commit, *new_commit;
538 old_object = parse_object(old_sha1);
539 new_object = parse_object(new_sha1);
541 if (!old_object || !new_object ||
542 old_object->type != OBJ_COMMIT ||
543 new_object->type != OBJ_COMMIT) {
544 error("bad sha1 objects for %s", name);
545 return "bad ref";
547 old_commit = (struct commit *)old_object;
548 new_commit = (struct commit *)new_object;
549 if (!in_merge_bases(old_commit, new_commit)) {
550 rp_error("denying non-fast-forward %s"
551 " (you should pull first)", name);
552 return "non-fast-forward";
555 if (run_update_hook(cmd)) {
556 rp_error("hook declined to update %s", name);
557 return "hook declined";
560 if (is_null_sha1(new_sha1)) {
561 if (!parse_object(old_sha1)) {
562 old_sha1 = NULL;
563 if (ref_exists(name)) {
564 rp_warning("Allowing deletion of corrupt ref.");
565 } else {
566 rp_warning("Deleting a non-existent ref.");
567 cmd->did_not_exist = 1;
570 if (delete_ref(namespaced_name, old_sha1, 0)) {
571 rp_error("failed to delete %s", name);
572 return "failed to delete";
574 return NULL; /* good */
576 else {
577 lock = lock_any_ref_for_update(namespaced_name, old_sha1, 0);
578 if (!lock) {
579 rp_error("failed to lock %s", name);
580 return "failed to lock";
582 if (write_ref_sha1(lock, new_sha1, "push")) {
583 return "failed to write"; /* error() already called */
585 return NULL; /* good */
589 static char update_post_hook[] = "hooks/post-update";
591 static void run_update_post_hook(struct command *commands)
593 struct command *cmd;
594 int argc;
595 const char **argv;
596 struct child_process proc;
598 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
599 if (cmd->error_string || cmd->did_not_exist)
600 continue;
601 argc++;
603 if (!argc || access(update_post_hook, X_OK) < 0)
604 return;
605 argv = xmalloc(sizeof(*argv) * (2 + argc));
606 argv[0] = update_post_hook;
608 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
609 char *p;
610 if (cmd->error_string || cmd->did_not_exist)
611 continue;
612 p = xmalloc(strlen(cmd->ref_name) + 1);
613 strcpy(p, cmd->ref_name);
614 argv[argc] = p;
615 argc++;
617 argv[argc] = NULL;
619 memset(&proc, 0, sizeof(proc));
620 proc.no_stdin = 1;
621 proc.stdout_to_stderr = 1;
622 proc.err = use_sideband ? -1 : 0;
623 proc.argv = argv;
625 if (!start_command(&proc)) {
626 if (use_sideband)
627 copy_to_sideband(proc.err, -1, NULL);
628 finish_command(&proc);
632 static void check_aliased_update(struct command *cmd, struct string_list *list)
634 struct strbuf buf = STRBUF_INIT;
635 const char *dst_name;
636 struct string_list_item *item;
637 struct command *dst_cmd;
638 unsigned char sha1[20];
639 char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
640 int flag;
642 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
643 dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
644 strbuf_release(&buf);
646 if (!(flag & REF_ISSYMREF))
647 return;
649 dst_name = strip_namespace(dst_name);
650 if (!dst_name) {
651 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
652 cmd->skip_update = 1;
653 cmd->error_string = "broken symref";
654 return;
657 if ((item = string_list_lookup(list, dst_name)) == NULL)
658 return;
660 cmd->skip_update = 1;
662 dst_cmd = (struct command *) item->util;
664 if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
665 !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
666 return;
668 dst_cmd->skip_update = 1;
670 strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
671 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
672 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
673 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
674 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
675 " its target '%s' (%s..%s)",
676 cmd->ref_name, cmd_oldh, cmd_newh,
677 dst_cmd->ref_name, dst_oldh, dst_newh);
679 cmd->error_string = dst_cmd->error_string =
680 "inconsistent aliased update";
683 static void check_aliased_updates(struct command *commands)
685 struct command *cmd;
686 struct string_list ref_list = STRING_LIST_INIT_NODUP;
688 for (cmd = commands; cmd; cmd = cmd->next) {
689 struct string_list_item *item =
690 string_list_append(&ref_list, cmd->ref_name);
691 item->util = (void *)cmd;
693 sort_string_list(&ref_list);
695 for (cmd = commands; cmd; cmd = cmd->next) {
696 if (!cmd->error_string)
697 check_aliased_update(cmd, &ref_list);
700 string_list_clear(&ref_list, 0);
703 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
705 struct command **cmd_list = cb_data;
706 struct command *cmd = *cmd_list;
708 if (!cmd || is_null_sha1(cmd->new_sha1))
709 return -1; /* end of list */
710 *cmd_list = NULL; /* this returns only one */
711 hashcpy(sha1, cmd->new_sha1);
712 return 0;
715 static void set_connectivity_errors(struct command *commands)
717 struct command *cmd;
719 for (cmd = commands; cmd; cmd = cmd->next) {
720 struct command *singleton = cmd;
721 if (!check_everything_connected(command_singleton_iterator,
722 0, &singleton))
723 continue;
724 cmd->error_string = "missing necessary objects";
728 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
730 struct command **cmd_list = cb_data;
731 struct command *cmd = *cmd_list;
733 while (cmd) {
734 if (!is_null_sha1(cmd->new_sha1)) {
735 hashcpy(sha1, cmd->new_sha1);
736 *cmd_list = cmd->next;
737 return 0;
739 cmd = cmd->next;
741 *cmd_list = NULL;
742 return -1; /* end of list */
745 static void execute_commands(struct command *commands, const char *unpacker_error)
747 struct command *cmd;
748 unsigned char sha1[20];
750 if (unpacker_error) {
751 for (cmd = commands; cmd; cmd = cmd->next)
752 cmd->error_string = "unpacker error";
753 return;
756 cmd = commands;
757 if (check_everything_connected(iterate_receive_command_list,
758 0, &cmd))
759 set_connectivity_errors(commands);
761 if (run_receive_hook(commands, pre_receive_hook, 0)) {
762 for (cmd = commands; cmd; cmd = cmd->next) {
763 if (!cmd->error_string)
764 cmd->error_string = "pre-receive hook declined";
766 return;
769 check_aliased_updates(commands);
771 free(head_name_to_free);
772 head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
774 for (cmd = commands; cmd; cmd = cmd->next) {
775 if (cmd->error_string)
776 continue;
778 if (cmd->skip_update)
779 continue;
781 cmd->error_string = update(cmd);
785 static struct command *read_head_info(void)
787 struct command *commands = NULL;
788 struct command **p = &commands;
789 for (;;) {
790 static char line[1000];
791 unsigned char old_sha1[20], new_sha1[20];
792 struct command *cmd;
793 char *refname;
794 int len, reflen;
796 len = packet_read_line(0, line, sizeof(line));
797 if (!len)
798 break;
799 if (line[len-1] == '\n')
800 line[--len] = 0;
801 if (len < 83 ||
802 line[40] != ' ' ||
803 line[81] != ' ' ||
804 get_sha1_hex(line, old_sha1) ||
805 get_sha1_hex(line + 41, new_sha1))
806 die("protocol error: expected old/new/ref, got '%s'",
807 line);
809 refname = line + 82;
810 reflen = strlen(refname);
811 if (reflen + 82 < len) {
812 const char *feature_list = refname + reflen + 1;
813 if (parse_feature_request(feature_list, "report-status"))
814 report_status = 1;
815 if (parse_feature_request(feature_list, "side-band-64k"))
816 use_sideband = LARGE_PACKET_MAX;
817 if (parse_feature_request(feature_list, "quiet"))
818 quiet = 1;
820 cmd = xcalloc(1, sizeof(struct command) + len - 80);
821 hashcpy(cmd->old_sha1, old_sha1);
822 hashcpy(cmd->new_sha1, new_sha1);
823 memcpy(cmd->ref_name, line + 82, len - 81);
824 *p = cmd;
825 p = &cmd->next;
827 return commands;
830 static const char *parse_pack_header(struct pack_header *hdr)
832 switch (read_pack_header(0, hdr)) {
833 case PH_ERROR_EOF:
834 return "eof before pack header was fully read";
836 case PH_ERROR_PACK_SIGNATURE:
837 return "protocol error (pack signature mismatch detected)";
839 case PH_ERROR_PROTOCOL:
840 return "protocol error (pack version unsupported)";
842 default:
843 return "unknown error in parse_pack_header";
845 case 0:
846 return NULL;
850 static const char *pack_lockfile;
852 static const char *unpack(int err_fd)
854 struct pack_header hdr;
855 const char *hdr_err;
856 char hdr_arg[38];
857 int fsck_objects = (receive_fsck_objects >= 0
858 ? receive_fsck_objects
859 : transfer_fsck_objects >= 0
860 ? transfer_fsck_objects
861 : 0);
863 hdr_err = parse_pack_header(&hdr);
864 if (hdr_err)
865 return hdr_err;
866 snprintf(hdr_arg, sizeof(hdr_arg),
867 "--pack_header=%"PRIu32",%"PRIu32,
868 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
870 if (ntohl(hdr.hdr_entries) < unpack_limit) {
871 int code, i = 0;
872 struct child_process child;
873 const char *unpacker[5];
874 unpacker[i++] = "unpack-objects";
875 if (quiet)
876 unpacker[i++] = "-q";
877 if (fsck_objects)
878 unpacker[i++] = "--strict";
879 unpacker[i++] = hdr_arg;
880 unpacker[i++] = NULL;
881 memset(&child, 0, sizeof(child));
882 child.argv = unpacker;
883 child.no_stdout = 1;
884 child.err = err_fd;
885 child.git_cmd = 1;
886 code = run_command(&child);
887 if (!code)
888 return NULL;
889 return "unpack-objects abnormal exit";
890 } else {
891 const char *keeper[7];
892 int s, status, i = 0;
893 char keep_arg[256];
894 struct child_process ip;
896 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
897 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
898 strcpy(keep_arg + s, "localhost");
900 keeper[i++] = "index-pack";
901 keeper[i++] = "--stdin";
902 if (fsck_objects)
903 keeper[i++] = "--strict";
904 keeper[i++] = "--fix-thin";
905 keeper[i++] = hdr_arg;
906 keeper[i++] = keep_arg;
907 keeper[i++] = NULL;
908 memset(&ip, 0, sizeof(ip));
909 ip.argv = keeper;
910 ip.out = -1;
911 ip.err = err_fd;
912 ip.git_cmd = 1;
913 status = start_command(&ip);
914 if (status) {
915 return "index-pack fork failed";
917 pack_lockfile = index_pack_lockfile(ip.out);
918 close(ip.out);
919 status = finish_command(&ip);
920 if (!status) {
921 reprepare_packed_git();
922 return NULL;
924 return "index-pack abnormal exit";
928 static const char *unpack_with_sideband(void)
930 struct async muxer;
931 const char *ret;
933 if (!use_sideband)
934 return unpack(0);
936 memset(&muxer, 0, sizeof(muxer));
937 muxer.proc = copy_to_sideband;
938 muxer.in = -1;
939 if (start_async(&muxer))
940 return NULL;
942 ret = unpack(muxer.in);
944 finish_async(&muxer);
945 return ret;
948 static void report(struct command *commands, const char *unpack_status)
950 struct command *cmd;
951 struct strbuf buf = STRBUF_INIT;
953 packet_buf_write(&buf, "unpack %s\n",
954 unpack_status ? unpack_status : "ok");
955 for (cmd = commands; cmd; cmd = cmd->next) {
956 if (!cmd->error_string)
957 packet_buf_write(&buf, "ok %s\n",
958 cmd->ref_name);
959 else
960 packet_buf_write(&buf, "ng %s %s\n",
961 cmd->ref_name, cmd->error_string);
963 packet_buf_flush(&buf);
965 if (use_sideband)
966 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
967 else
968 safe_write(1, buf.buf, buf.len);
969 strbuf_release(&buf);
972 static int delete_only(struct command *commands)
974 struct command *cmd;
975 for (cmd = commands; cmd; cmd = cmd->next) {
976 if (!is_null_sha1(cmd->new_sha1))
977 return 0;
979 return 1;
982 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
984 int advertise_refs = 0;
985 int stateless_rpc = 0;
986 int i;
987 char *dir = NULL;
988 struct command *commands;
990 packet_trace_identity("receive-pack");
992 argv++;
993 for (i = 1; i < argc; i++) {
994 const char *arg = *argv++;
996 if (*arg == '-') {
997 if (!strcmp(arg, "--quiet")) {
998 quiet = 1;
999 continue;
1002 if (!strcmp(arg, "--advertise-refs")) {
1003 advertise_refs = 1;
1004 continue;
1006 if (!strcmp(arg, "--stateless-rpc")) {
1007 stateless_rpc = 1;
1008 continue;
1011 usage(receive_pack_usage);
1013 if (dir)
1014 usage(receive_pack_usage);
1015 dir = xstrdup(arg);
1017 if (!dir)
1018 usage(receive_pack_usage);
1020 setup_path();
1022 if (!enter_repo(dir, 0))
1023 die("'%s' does not appear to be a git repository", dir);
1025 if (is_repository_shallow())
1026 die("attempt to push into a shallow repository");
1028 git_config(receive_pack_config, NULL);
1030 if (0 <= transfer_unpack_limit)
1031 unpack_limit = transfer_unpack_limit;
1032 else if (0 <= receive_unpack_limit)
1033 unpack_limit = receive_unpack_limit;
1035 if (advertise_refs || !stateless_rpc) {
1036 write_head_info();
1038 if (advertise_refs)
1039 return 0;
1041 if ((commands = read_head_info()) != NULL) {
1042 const char *unpack_status = NULL;
1044 if (!delete_only(commands))
1045 unpack_status = unpack_with_sideband();
1046 execute_commands(commands, unpack_status);
1047 if (pack_lockfile)
1048 unlink_or_warn(pack_lockfile);
1049 if (report_status)
1050 report(commands, unpack_status);
1051 run_receive_hook(commands, post_receive_hook, 1);
1052 run_update_post_hook(commands);
1053 if (auto_gc) {
1054 const char *argv_gc_auto[] = {
1055 "gc", "--auto", "--quiet", NULL,
1057 int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1058 run_command_v_opt(argv_gc_auto, opt);
1060 if (auto_update_server_info)
1061 update_server_info(0);
1063 if (use_sideband)
1064 packet_flush(1);
1065 return 0;