Make mingw_offset_1st_component() behave consistently for all paths.
[git/dscho.git] / builtin / receive-pack.c
blob1b2bf5fe667db1c6ba67a2cada41d4481fe91fd9
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"
16 static const char receive_pack_usage[] = "git receive-pack <git-dir>";
18 enum deny_action {
19 DENY_UNCONFIGURED,
20 DENY_IGNORE,
21 DENY_WARN,
22 DENY_REFUSE,
23 DENY_UPDATE_INSTEAD,
24 DENY_DETACH_INSTEAD,
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 const char *head_name;
43 static void *head_name_to_free;
44 static int sent_capabilities;
46 static enum deny_action parse_deny_action(const char *var, const char *value)
48 if (value) {
49 if (!strcasecmp(value, "ignore"))
50 return DENY_IGNORE;
51 if (!strcasecmp(value, "warn"))
52 return DENY_WARN;
53 if (!strcasecmp(value, "refuse"))
54 return DENY_REFUSE;
56 if (git_config_bool(var, value))
57 return DENY_REFUSE;
58 return DENY_IGNORE;
61 static int receive_pack_config(const char *var, const char *value, void *cb)
63 if (strcmp(var, "receive.denydeletes") == 0) {
64 deny_deletes = git_config_bool(var, value);
65 return 0;
68 if (strcmp(var, "receive.denynonfastforwards") == 0) {
69 deny_non_fast_forwards = git_config_bool(var, value);
70 return 0;
73 if (strcmp(var, "receive.unpacklimit") == 0) {
74 receive_unpack_limit = git_config_int(var, value);
75 return 0;
78 if (strcmp(var, "transfer.unpacklimit") == 0) {
79 transfer_unpack_limit = git_config_int(var, value);
80 return 0;
83 if (strcmp(var, "receive.fsckobjects") == 0) {
84 receive_fsck_objects = git_config_bool(var, value);
85 return 0;
88 if (strcmp(var, "transfer.fsckobjects") == 0) {
89 transfer_fsck_objects = git_config_bool(var, value);
90 return 0;
93 if (!strcmp(var, "receive.denycurrentbranch")) {
94 if (value && !strcasecmp(value, "updateinstead"))
95 deny_current_branch = DENY_UPDATE_INSTEAD;
96 else if (value && !strcasecmp(value, "detachinstead"))
97 deny_current_branch = DENY_DETACH_INSTEAD;
98 else
99 deny_current_branch = parse_deny_action(var, value);
100 return 0;
103 if (strcmp(var, "receive.denydeletecurrent") == 0) {
104 deny_delete_current = parse_deny_action(var, value);
105 return 0;
108 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
109 prefer_ofs_delta = git_config_bool(var, value);
110 return 0;
113 if (strcmp(var, "receive.updateserverinfo") == 0) {
114 auto_update_server_info = git_config_bool(var, value);
115 return 0;
118 if (strcmp(var, "receive.autogc") == 0) {
119 auto_gc = git_config_bool(var, value);
120 return 0;
123 return git_default_config(var, value, cb);
126 static void show_ref(const char *path, const unsigned char *sha1)
128 if (sent_capabilities)
129 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
130 else
131 packet_write(1, "%s %s%c%s%s\n",
132 sha1_to_hex(sha1), path, 0,
133 " report-status delete-refs side-band-64k quiet",
134 prefer_ofs_delta ? " ofs-delta" : "");
135 sent_capabilities = 1;
138 static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
140 path = strip_namespace(path);
142 * Advertise refs outside our current namespace as ".have"
143 * refs, so that the client can use them to minimize data
144 * transfer but will otherwise ignore them. This happens to
145 * cover ".have" that are thrown in by add_one_alternate_ref()
146 * to mark histories that are complete in our alternates as
147 * well.
149 if (!path)
150 path = ".have";
151 show_ref(path, sha1);
152 return 0;
155 static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
157 show_ref(".have", sha1);
160 static void collect_one_alternate_ref(const struct ref *ref, void *data)
162 struct sha1_array *sa = data;
163 sha1_array_append(sa, ref->old_sha1);
166 static void write_head_info(void)
168 struct sha1_array sa = SHA1_ARRAY_INIT;
169 for_each_alternate_ref(collect_one_alternate_ref, &sa);
170 sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
171 sha1_array_clear(&sa);
172 for_each_ref(show_ref_cb, NULL);
173 if (!sent_capabilities)
174 show_ref("capabilities^{}", null_sha1);
176 /* EOF */
177 packet_flush(1);
180 struct command {
181 struct command *next;
182 const char *error_string;
183 unsigned int skip_update:1,
184 did_not_exist:1;
185 unsigned char old_sha1[20];
186 unsigned char new_sha1[20];
187 char ref_name[FLEX_ARRAY]; /* more */
190 static const char pre_receive_hook[] = "hooks/pre-receive";
191 static const char post_receive_hook[] = "hooks/post-receive";
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 if (access(hook_name, X_OK) < 0)
251 return 0;
253 argv[0] = hook_name;
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 static const char update_hook[] = "hooks/update";
340 const char *argv[5];
341 struct child_process proc;
342 int code;
344 if (access(update_hook, X_OK) < 0)
345 return 0;
347 argv[0] = update_hook;
348 argv[1] = cmd->ref_name;
349 argv[2] = sha1_to_hex(cmd->old_sha1);
350 argv[3] = sha1_to_hex(cmd->new_sha1);
351 argv[4] = NULL;
353 memset(&proc, 0, sizeof(proc));
354 proc.no_stdin = 1;
355 proc.stdout_to_stderr = 1;
356 proc.err = use_sideband ? -1 : 0;
357 proc.argv = argv;
359 code = start_command(&proc);
360 if (code)
361 return code;
362 if (use_sideband)
363 copy_to_sideband(proc.err, -1, NULL);
364 return finish_command(&proc);
367 static int is_ref_checked_out(const char *ref)
369 if (is_bare_repository())
370 return 0;
372 if (!head_name)
373 return 0;
374 return !strcmp(head_name, ref);
377 static char *refuse_unconfigured_deny_msg[] = {
378 "By default, updating the current branch in a non-bare repository",
379 "is denied, because it will make the index and work tree inconsistent",
380 "with what you pushed, and will require 'git reset --hard' to match",
381 "the work tree to HEAD.",
383 "You can set 'receive.denyCurrentBranch' configuration variable to",
384 "'ignore' or 'warn' in the remote repository to allow pushing into",
385 "its current branch; however, this is not recommended unless you",
386 "arranged to update its work tree to match what you pushed in some",
387 "other way.",
389 "To squelch this message and still keep the default behaviour, set",
390 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
393 static void refuse_unconfigured_deny(void)
395 int i;
396 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
397 rp_error("%s", refuse_unconfigured_deny_msg[i]);
400 static char *refuse_unconfigured_deny_delete_current_msg[] = {
401 "By default, deleting the current branch is denied, because the next",
402 "'git clone' won't result in any file checked out, causing confusion.",
404 "You can set 'receive.denyDeleteCurrent' configuration variable to",
405 "'warn' or 'ignore' in the remote repository to allow deleting the",
406 "current branch, with or without a warning message.",
408 "To squelch this message, you can set it to 'refuse'."
411 static void refuse_unconfigured_deny_delete_current(void)
413 int i;
414 for (i = 0;
415 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
416 i++)
417 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
420 static void merge_worktree(unsigned char *sha1)
422 const char *update_refresh[] = {
423 "update-index", "--refresh", NULL
425 const char *read_tree[] = {
426 "read-tree", "-u", "-m", sha1_to_hex(sha1), NULL
428 struct child_process child;
429 struct strbuf git_env = STRBUF_INIT;
430 const char *env[2];
432 if (is_bare_repository())
433 die ("denyCurrentBranch = updateInstead needs a worktree");
435 strbuf_addf(&git_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
436 env[0] = git_env.buf;
437 env[1] = NULL;
439 memset(&child, 0, sizeof(child));
440 child.argv = update_refresh;
441 child.env = env;
442 child.dir = git_work_tree_cfg ? git_work_tree_cfg : "..";
443 child.stdout_to_stderr = 1;
444 child.git_cmd = 1;
445 if (run_command(&child))
446 die ("Could not refresh the index");
448 child.argv = read_tree;
449 child.no_stdin = 1;
450 child.no_stdout = 1;
451 child.stdout_to_stderr = 0;
452 if (run_command(&child))
453 die ("Could not merge working tree with new HEAD. Good luck.");
455 strbuf_release(&git_env);
458 static const char *update(struct command *cmd)
460 const char *name = cmd->ref_name;
461 struct strbuf namespaced_name_buf = STRBUF_INIT;
462 const char *namespaced_name;
463 unsigned char *old_sha1 = cmd->old_sha1;
464 unsigned char *new_sha1 = cmd->new_sha1;
465 struct ref_lock *lock;
467 /* only refs/... are allowed */
468 if (prefixcmp(name, "refs/") || check_refname_format(name + 5, 0)) {
469 rp_error("refusing to create funny ref '%s' remotely", name);
470 return "funny refname";
473 strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
474 namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
476 if (is_ref_checked_out(namespaced_name)) {
477 switch (deny_current_branch) {
478 case DENY_IGNORE:
479 break;
480 case DENY_WARN:
481 rp_warning("updating the current branch");
482 break;
483 case DENY_REFUSE:
484 case DENY_UNCONFIGURED:
485 rp_error("refusing to update checked out branch: %s", name);
486 if (deny_current_branch == DENY_UNCONFIGURED)
487 refuse_unconfigured_deny();
488 return "branch is currently checked out";
489 case DENY_UPDATE_INSTEAD:
490 merge_worktree(new_sha1);
491 break;
492 case DENY_DETACH_INSTEAD:
493 update_ref("push into current branch (detach)", "HEAD",
494 old_sha1, NULL, REF_NODEREF, DIE_ON_ERR);
495 break;
499 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
500 error("unpack should have generated %s, "
501 "but I can't find it!", sha1_to_hex(new_sha1));
502 return "bad pack";
505 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
506 if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
507 rp_error("denying ref deletion for %s", name);
508 return "deletion prohibited";
511 if (!strcmp(namespaced_name, head_name)) {
512 switch (deny_delete_current) {
513 case DENY_IGNORE:
514 break;
515 case DENY_WARN:
516 rp_warning("deleting the current branch");
517 break;
518 case DENY_REFUSE:
519 case DENY_UNCONFIGURED:
520 if (deny_delete_current == DENY_UNCONFIGURED)
521 refuse_unconfigured_deny_delete_current();
522 rp_error("refusing to delete the current branch: %s", name);
523 return "deletion of the current branch prohibited";
524 default:
525 die ("Invalid denyDeleteCurrent setting");
530 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
531 !is_null_sha1(old_sha1) &&
532 !prefixcmp(name, "refs/heads/")) {
533 struct object *old_object, *new_object;
534 struct commit *old_commit, *new_commit;
535 struct commit_list *bases, *ent;
537 old_object = parse_object(old_sha1);
538 new_object = parse_object(new_sha1);
540 if (!old_object || !new_object ||
541 old_object->type != OBJ_COMMIT ||
542 new_object->type != OBJ_COMMIT) {
543 error("bad sha1 objects for %s", name);
544 return "bad ref";
546 old_commit = (struct commit *)old_object;
547 new_commit = (struct commit *)new_object;
548 bases = get_merge_bases(old_commit, new_commit, 1);
549 for (ent = bases; ent; ent = ent->next)
550 if (!hashcmp(old_sha1, ent->item->object.sha1))
551 break;
552 free_commit_list(bases);
553 if (!ent) {
554 rp_error("denying non-fast-forward %s"
555 " (you should pull first)", name);
556 return "non-fast-forward";
559 if (run_update_hook(cmd)) {
560 rp_error("hook declined to update %s", name);
561 return "hook declined";
564 if (is_null_sha1(new_sha1)) {
565 if (!parse_object(old_sha1)) {
566 old_sha1 = NULL;
567 if (ref_exists(name)) {
568 rp_warning("Allowing deletion of corrupt ref.");
569 } else {
570 rp_warning("Deleting a non-existent ref.");
571 cmd->did_not_exist = 1;
574 if (delete_ref(namespaced_name, old_sha1, 0)) {
575 rp_error("failed to delete %s", name);
576 return "failed to delete";
578 return NULL; /* good */
580 else {
581 lock = lock_any_ref_for_update(namespaced_name, old_sha1, 0);
582 if (!lock) {
583 rp_error("failed to lock %s", name);
584 return "failed to lock";
586 if (write_ref_sha1(lock, new_sha1, "push")) {
587 return "failed to write"; /* error() already called */
589 return NULL; /* good */
593 static char update_post_hook[] = "hooks/post-update";
595 static void run_update_post_hook(struct command *commands)
597 struct command *cmd;
598 int argc;
599 const char **argv;
600 struct child_process proc;
602 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
603 if (cmd->error_string || cmd->did_not_exist)
604 continue;
605 argc++;
607 if (!argc || access(update_post_hook, X_OK) < 0)
608 return;
609 argv = xmalloc(sizeof(*argv) * (2 + argc));
610 argv[0] = update_post_hook;
612 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
613 char *p;
614 if (cmd->error_string || cmd->did_not_exist)
615 continue;
616 p = xmalloc(strlen(cmd->ref_name) + 1);
617 strcpy(p, cmd->ref_name);
618 argv[argc] = p;
619 argc++;
621 argv[argc] = NULL;
623 memset(&proc, 0, sizeof(proc));
624 proc.no_stdin = 1;
625 proc.stdout_to_stderr = 1;
626 proc.err = use_sideband ? -1 : 0;
627 proc.argv = argv;
629 if (!start_command(&proc)) {
630 if (use_sideband)
631 copy_to_sideband(proc.err, -1, NULL);
632 finish_command(&proc);
636 static void check_aliased_update(struct command *cmd, struct string_list *list)
638 struct strbuf buf = STRBUF_INIT;
639 const char *dst_name;
640 struct string_list_item *item;
641 struct command *dst_cmd;
642 unsigned char sha1[20];
643 char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
644 int flag;
646 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
647 dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
648 strbuf_release(&buf);
650 if (!(flag & REF_ISSYMREF))
651 return;
653 dst_name = strip_namespace(dst_name);
654 if (!dst_name) {
655 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
656 cmd->skip_update = 1;
657 cmd->error_string = "broken symref";
658 return;
661 if ((item = string_list_lookup(list, dst_name)) == NULL)
662 return;
664 cmd->skip_update = 1;
666 dst_cmd = (struct command *) item->util;
668 if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
669 !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
670 return;
672 dst_cmd->skip_update = 1;
674 strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
675 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
676 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
677 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
678 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
679 " its target '%s' (%s..%s)",
680 cmd->ref_name, cmd_oldh, cmd_newh,
681 dst_cmd->ref_name, dst_oldh, dst_newh);
683 cmd->error_string = dst_cmd->error_string =
684 "inconsistent aliased update";
687 static void check_aliased_updates(struct command *commands)
689 struct command *cmd;
690 struct string_list ref_list = STRING_LIST_INIT_NODUP;
692 for (cmd = commands; cmd; cmd = cmd->next) {
693 struct string_list_item *item =
694 string_list_append(&ref_list, cmd->ref_name);
695 item->util = (void *)cmd;
697 sort_string_list(&ref_list);
699 for (cmd = commands; cmd; cmd = cmd->next) {
700 if (!cmd->error_string)
701 check_aliased_update(cmd, &ref_list);
704 string_list_clear(&ref_list, 0);
707 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
709 struct command **cmd_list = cb_data;
710 struct command *cmd = *cmd_list;
712 if (!cmd || is_null_sha1(cmd->new_sha1))
713 return -1; /* end of list */
714 *cmd_list = NULL; /* this returns only one */
715 hashcpy(sha1, cmd->new_sha1);
716 return 0;
719 static void set_connectivity_errors(struct command *commands)
721 struct command *cmd;
723 for (cmd = commands; cmd; cmd = cmd->next) {
724 struct command *singleton = cmd;
725 if (!check_everything_connected(command_singleton_iterator,
726 0, &singleton))
727 continue;
728 cmd->error_string = "missing necessary objects";
732 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
734 struct command **cmd_list = cb_data;
735 struct command *cmd = *cmd_list;
737 while (cmd) {
738 if (!is_null_sha1(cmd->new_sha1)) {
739 hashcpy(sha1, cmd->new_sha1);
740 *cmd_list = cmd->next;
741 return 0;
743 cmd = cmd->next;
745 *cmd_list = NULL;
746 return -1; /* end of list */
749 static void execute_commands(struct command *commands, const char *unpacker_error)
751 struct command *cmd;
752 unsigned char sha1[20];
754 if (unpacker_error) {
755 for (cmd = commands; cmd; cmd = cmd->next)
756 cmd->error_string = "n/a (unpacker error)";
757 return;
760 cmd = commands;
761 if (check_everything_connected(iterate_receive_command_list,
762 0, &cmd))
763 set_connectivity_errors(commands);
765 if (run_receive_hook(commands, pre_receive_hook, 0)) {
766 for (cmd = commands; cmd; cmd = cmd->next) {
767 if (!cmd->error_string)
768 cmd->error_string = "pre-receive hook declined";
770 return;
773 check_aliased_updates(commands);
775 free(head_name_to_free);
776 head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
778 for (cmd = commands; cmd; cmd = cmd->next) {
779 if (cmd->error_string)
780 continue;
782 if (cmd->skip_update)
783 continue;
785 cmd->error_string = update(cmd);
789 static struct command *read_head_info(void)
791 struct command *commands = NULL;
792 struct command **p = &commands;
793 for (;;) {
794 static char line[1000];
795 unsigned char old_sha1[20], new_sha1[20];
796 struct command *cmd;
797 char *refname;
798 int len, reflen;
800 len = packet_read_line(0, line, sizeof(line));
801 if (!len)
802 break;
803 if (line[len-1] == '\n')
804 line[--len] = 0;
805 if (len < 83 ||
806 line[40] != ' ' ||
807 line[81] != ' ' ||
808 get_sha1_hex(line, old_sha1) ||
809 get_sha1_hex(line + 41, new_sha1))
810 die("protocol error: expected old/new/ref, got '%s'",
811 line);
813 refname = line + 82;
814 reflen = strlen(refname);
815 if (reflen + 82 < len) {
816 const char *feature_list = refname + reflen + 1;
817 if (parse_feature_request(feature_list, "report-status"))
818 report_status = 1;
819 if (parse_feature_request(feature_list, "side-band-64k"))
820 use_sideband = LARGE_PACKET_MAX;
821 if (parse_feature_request(feature_list, "quiet"))
822 quiet = 1;
824 cmd = xcalloc(1, sizeof(struct command) + len - 80);
825 hashcpy(cmd->old_sha1, old_sha1);
826 hashcpy(cmd->new_sha1, new_sha1);
827 memcpy(cmd->ref_name, line + 82, len - 81);
828 *p = cmd;
829 p = &cmd->next;
831 return commands;
834 static const char *parse_pack_header(struct pack_header *hdr)
836 switch (read_pack_header(0, hdr)) {
837 case PH_ERROR_EOF:
838 return "eof before pack header was fully read";
840 case PH_ERROR_PACK_SIGNATURE:
841 return "protocol error (pack signature mismatch detected)";
843 case PH_ERROR_PROTOCOL:
844 return "protocol error (pack version unsupported)";
846 default:
847 return "unknown error in parse_pack_header";
849 case 0:
850 return NULL;
854 static const char *pack_lockfile;
856 static const char *unpack(void)
858 struct pack_header hdr;
859 const char *hdr_err;
860 char hdr_arg[38];
861 int fsck_objects = (receive_fsck_objects >= 0
862 ? receive_fsck_objects
863 : transfer_fsck_objects >= 0
864 ? transfer_fsck_objects
865 : 0);
867 hdr_err = parse_pack_header(&hdr);
868 if (hdr_err)
869 return hdr_err;
870 snprintf(hdr_arg, sizeof(hdr_arg),
871 "--pack_header=%"PRIu32",%"PRIu32,
872 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
874 if (ntohl(hdr.hdr_entries) < unpack_limit) {
875 int code, i = 0;
876 const char *unpacker[5];
877 unpacker[i++] = "unpack-objects";
878 if (quiet)
879 unpacker[i++] = "-q";
880 if (fsck_objects)
881 unpacker[i++] = "--strict";
882 unpacker[i++] = hdr_arg;
883 unpacker[i++] = NULL;
884 code = run_command_v_opt(unpacker, RUN_GIT_CMD);
885 if (!code)
886 return NULL;
887 return "unpack-objects abnormal exit";
888 } else {
889 const char *keeper[7];
890 int s, status, i = 0;
891 char keep_arg[256];
892 struct child_process ip;
894 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
895 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
896 strcpy(keep_arg + s, "localhost");
898 keeper[i++] = "index-pack";
899 keeper[i++] = "--stdin";
900 if (fsck_objects)
901 keeper[i++] = "--strict";
902 keeper[i++] = "--fix-thin";
903 keeper[i++] = hdr_arg;
904 keeper[i++] = keep_arg;
905 keeper[i++] = NULL;
906 memset(&ip, 0, sizeof(ip));
907 ip.argv = keeper;
908 ip.out = -1;
909 ip.git_cmd = 1;
910 status = start_command(&ip);
911 if (status) {
912 return "index-pack fork failed";
914 pack_lockfile = index_pack_lockfile(ip.out);
915 close(ip.out);
916 status = finish_command(&ip);
917 if (!status) {
918 reprepare_packed_git();
919 return NULL;
921 return "index-pack abnormal exit";
925 static void report(struct command *commands, const char *unpack_status)
927 struct command *cmd;
928 struct strbuf buf = STRBUF_INIT;
930 packet_buf_write(&buf, "unpack %s\n",
931 unpack_status ? unpack_status : "ok");
932 for (cmd = commands; cmd; cmd = cmd->next) {
933 if (!cmd->error_string)
934 packet_buf_write(&buf, "ok %s\n",
935 cmd->ref_name);
936 else
937 packet_buf_write(&buf, "ng %s %s\n",
938 cmd->ref_name, cmd->error_string);
940 packet_buf_flush(&buf);
942 if (use_sideband)
943 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
944 else
945 safe_write(1, buf.buf, buf.len);
946 strbuf_release(&buf);
949 static int delete_only(struct command *commands)
951 struct command *cmd;
952 for (cmd = commands; cmd; cmd = cmd->next) {
953 if (!is_null_sha1(cmd->new_sha1))
954 return 0;
956 return 1;
959 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
961 int advertise_refs = 0;
962 int stateless_rpc = 0;
963 int i;
964 char *dir = NULL;
965 struct command *commands;
967 packet_trace_identity("receive-pack");
969 argv++;
970 for (i = 1; i < argc; i++) {
971 const char *arg = *argv++;
973 if (*arg == '-') {
974 if (!strcmp(arg, "--quiet")) {
975 quiet = 1;
976 continue;
979 if (!strcmp(arg, "--advertise-refs")) {
980 advertise_refs = 1;
981 continue;
983 if (!strcmp(arg, "--stateless-rpc")) {
984 stateless_rpc = 1;
985 continue;
988 usage(receive_pack_usage);
990 if (dir)
991 usage(receive_pack_usage);
992 dir = xstrdup(arg);
994 if (!dir)
995 usage(receive_pack_usage);
997 setup_path();
999 if (!enter_repo(dir, 0))
1000 die("'%s' does not appear to be a git repository", dir);
1002 if (is_repository_shallow())
1003 die("attempt to push into a shallow repository");
1005 git_config(receive_pack_config, NULL);
1007 if (0 <= transfer_unpack_limit)
1008 unpack_limit = transfer_unpack_limit;
1009 else if (0 <= receive_unpack_limit)
1010 unpack_limit = receive_unpack_limit;
1012 if (advertise_refs || !stateless_rpc) {
1013 write_head_info();
1015 if (advertise_refs)
1016 return 0;
1018 if ((commands = read_head_info()) != NULL) {
1019 const char *unpack_status = NULL;
1021 if (!delete_only(commands))
1022 unpack_status = unpack();
1023 execute_commands(commands, unpack_status);
1024 if (pack_lockfile)
1025 unlink_or_warn(pack_lockfile);
1026 if (report_status)
1027 report(commands, unpack_status);
1028 run_receive_hook(commands, post_receive_hook, 1);
1029 run_update_post_hook(commands);
1030 if (auto_gc) {
1031 const char *argv_gc_auto[] = {
1032 "gc", "--auto", "--quiet", NULL,
1034 run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
1036 if (auto_update_server_info)
1037 update_server_info(0);
1039 if (use_sideband)
1040 packet_flush(1);
1041 return 0;