submodule: Use cat instead of echo to avoid DOS line-endings
[git/dscho.git] / builtin / receive-pack.c
blob45289d98e95dccb686373f2c0b3d6294c2d8a403
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 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 int sent_capabilities;
44 static enum deny_action parse_deny_action(const char *var, const char *value)
46 if (value) {
47 if (!strcasecmp(value, "ignore"))
48 return DENY_IGNORE;
49 if (!strcasecmp(value, "warn"))
50 return DENY_WARN;
51 if (!strcasecmp(value, "refuse"))
52 return DENY_REFUSE;
54 if (git_config_bool(var, value))
55 return DENY_REFUSE;
56 return DENY_IGNORE;
59 static int receive_pack_config(const char *var, const char *value, void *cb)
61 if (strcmp(var, "receive.denydeletes") == 0) {
62 deny_deletes = git_config_bool(var, value);
63 return 0;
66 if (strcmp(var, "receive.denynonfastforwards") == 0) {
67 deny_non_fast_forwards = git_config_bool(var, value);
68 return 0;
71 if (strcmp(var, "receive.unpacklimit") == 0) {
72 receive_unpack_limit = git_config_int(var, value);
73 return 0;
76 if (strcmp(var, "transfer.unpacklimit") == 0) {
77 transfer_unpack_limit = git_config_int(var, value);
78 return 0;
81 if (strcmp(var, "receive.fsckobjects") == 0) {
82 receive_fsck_objects = git_config_bool(var, value);
83 return 0;
86 if (strcmp(var, "transfer.fsckobjects") == 0) {
87 transfer_fsck_objects = git_config_bool(var, value);
88 return 0;
91 if (!strcmp(var, "receive.denycurrentbranch")) {
92 if (value && !strcasecmp(value, "updateinstead"))
93 deny_current_branch = DENY_UPDATE_INSTEAD;
94 else if (value && !strcasecmp(value, "detachinstead"))
95 deny_current_branch = DENY_DETACH_INSTEAD;
96 else
97 deny_current_branch = parse_deny_action(var, value);
98 return 0;
101 if (strcmp(var, "receive.denydeletecurrent") == 0) {
102 deny_delete_current = parse_deny_action(var, value);
103 return 0;
106 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
107 prefer_ofs_delta = git_config_bool(var, value);
108 return 0;
111 if (strcmp(var, "receive.updateserverinfo") == 0) {
112 auto_update_server_info = git_config_bool(var, value);
113 return 0;
116 if (strcmp(var, "receive.autogc") == 0) {
117 auto_gc = git_config_bool(var, value);
118 return 0;
121 return git_default_config(var, value, cb);
124 static int show_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
126 if (sent_capabilities)
127 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
128 else
129 packet_write(1, "%s %s%c%s%s\n",
130 sha1_to_hex(sha1), path, 0,
131 " report-status delete-refs side-band-64k",
132 prefer_ofs_delta ? " ofs-delta" : "");
133 sent_capabilities = 1;
134 return 0;
137 static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *cb_data)
139 path = strip_namespace(path);
141 * Advertise refs outside our current namespace as ".have"
142 * refs, so that the client can use them to minimize data
143 * transfer but will otherwise ignore them. This happens to
144 * cover ".have" that are thrown in by add_one_alternate_ref()
145 * to mark histories that are complete in our alternates as
146 * well.
148 if (!path)
149 path = ".have";
150 return show_ref(path, sha1, flag, cb_data);
153 static void write_head_info(void)
155 for_each_ref(show_ref_cb, NULL);
156 if (!sent_capabilities)
157 show_ref("capabilities^{}", null_sha1, 0, NULL);
161 struct command {
162 struct command *next;
163 const char *error_string;
164 unsigned int skip_update:1,
165 did_not_exist:1;
166 unsigned char old_sha1[20];
167 unsigned char new_sha1[20];
168 char ref_name[FLEX_ARRAY]; /* more */
171 static const char pre_receive_hook[] = "hooks/pre-receive";
172 static const char post_receive_hook[] = "hooks/post-receive";
174 static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
175 static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
177 static void report_message(const char *prefix, const char *err, va_list params)
179 int sz = strlen(prefix);
180 char msg[4096];
182 strncpy(msg, prefix, sz);
183 sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
184 if (sz > (sizeof(msg) - 1))
185 sz = sizeof(msg) - 1;
186 msg[sz++] = '\n';
188 if (use_sideband)
189 send_sideband(1, 2, msg, sz, use_sideband);
190 else
191 xwrite(2, msg, sz);
194 static void rp_warning(const char *err, ...)
196 va_list params;
197 va_start(params, err);
198 report_message("warning: ", err, params);
199 va_end(params);
202 static void rp_error(const char *err, ...)
204 va_list params;
205 va_start(params, err);
206 report_message("error: ", err, params);
207 va_end(params);
210 static int copy_to_sideband(int in, int out, void *arg)
212 char data[128];
213 while (1) {
214 ssize_t sz = xread(in, data, sizeof(data));
215 if (sz <= 0)
216 break;
217 send_sideband(1, 2, data, sz, use_sideband);
219 close(in);
220 return 0;
223 typedef int (*feed_fn)(void *, const char **, size_t *);
224 static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
226 struct child_process proc;
227 struct async muxer;
228 const char *argv[2];
229 int code;
231 if (access(hook_name, X_OK) < 0)
232 return 0;
234 argv[0] = hook_name;
235 argv[1] = NULL;
237 memset(&proc, 0, sizeof(proc));
238 proc.argv = argv;
239 proc.in = -1;
240 proc.stdout_to_stderr = 1;
242 if (use_sideband) {
243 memset(&muxer, 0, sizeof(muxer));
244 muxer.proc = copy_to_sideband;
245 muxer.in = -1;
246 code = start_async(&muxer);
247 if (code)
248 return code;
249 proc.err = muxer.in;
252 code = start_command(&proc);
253 if (code) {
254 if (use_sideband)
255 finish_async(&muxer);
256 return code;
259 while (1) {
260 const char *buf;
261 size_t n;
262 if (feed(feed_state, &buf, &n))
263 break;
264 if (write_in_full(proc.in, buf, n) != n)
265 break;
267 close(proc.in);
268 if (use_sideband)
269 finish_async(&muxer);
270 return finish_command(&proc);
273 struct receive_hook_feed_state {
274 struct command *cmd;
275 int skip_broken;
276 struct strbuf buf;
279 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
281 struct receive_hook_feed_state *state = state_;
282 struct command *cmd = state->cmd;
284 while (cmd &&
285 state->skip_broken && (cmd->error_string || cmd->did_not_exist))
286 cmd = cmd->next;
287 if (!cmd)
288 return -1; /* EOF */
289 strbuf_reset(&state->buf);
290 strbuf_addf(&state->buf, "%s %s %s\n",
291 sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
292 cmd->ref_name);
293 state->cmd = cmd->next;
294 if (bufp) {
295 *bufp = state->buf.buf;
296 *sizep = state->buf.len;
298 return 0;
301 static int run_receive_hook(struct command *commands, const char *hook_name,
302 int skip_broken)
304 struct receive_hook_feed_state state;
305 int status;
307 strbuf_init(&state.buf, 0);
308 state.cmd = commands;
309 state.skip_broken = skip_broken;
310 if (feed_receive_hook(&state, NULL, NULL))
311 return 0;
312 state.cmd = commands;
313 status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
314 strbuf_release(&state.buf);
315 return status;
318 static int run_update_hook(struct command *cmd)
320 static const char update_hook[] = "hooks/update";
321 const char *argv[5];
322 struct child_process proc;
323 int code;
325 if (access(update_hook, X_OK) < 0)
326 return 0;
328 argv[0] = update_hook;
329 argv[1] = cmd->ref_name;
330 argv[2] = sha1_to_hex(cmd->old_sha1);
331 argv[3] = sha1_to_hex(cmd->new_sha1);
332 argv[4] = NULL;
334 memset(&proc, 0, sizeof(proc));
335 proc.no_stdin = 1;
336 proc.stdout_to_stderr = 1;
337 proc.err = use_sideband ? -1 : 0;
338 proc.argv = argv;
340 code = start_command(&proc);
341 if (code)
342 return code;
343 if (use_sideband)
344 copy_to_sideband(proc.err, -1, NULL);
345 return finish_command(&proc);
348 static int is_ref_checked_out(const char *ref)
350 if (is_bare_repository())
351 return 0;
353 if (!head_name)
354 return 0;
355 return !strcmp(head_name, ref);
358 static char *refuse_unconfigured_deny_msg[] = {
359 "By default, updating the current branch in a non-bare repository",
360 "is denied, because it will make the index and work tree inconsistent",
361 "with what you pushed, and will require 'git reset --hard' to match",
362 "the work tree to HEAD.",
364 "You can set 'receive.denyCurrentBranch' configuration variable to",
365 "'ignore' or 'warn' in the remote repository to allow pushing into",
366 "its current branch; however, this is not recommended unless you",
367 "arranged to update its work tree to match what you pushed in some",
368 "other way.",
370 "To squelch this message and still keep the default behaviour, set",
371 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
374 static void refuse_unconfigured_deny(void)
376 int i;
377 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
378 rp_error("%s", refuse_unconfigured_deny_msg[i]);
381 static char *refuse_unconfigured_deny_delete_current_msg[] = {
382 "By default, deleting the current branch is denied, because the next",
383 "'git clone' won't result in any file checked out, causing confusion.",
385 "You can set 'receive.denyDeleteCurrent' configuration variable to",
386 "'warn' or 'ignore' in the remote repository to allow deleting the",
387 "current branch, with or without a warning message.",
389 "To squelch this message, you can set it to 'refuse'."
392 static void refuse_unconfigured_deny_delete_current(void)
394 int i;
395 for (i = 0;
396 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
397 i++)
398 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
401 static void merge_worktree(unsigned char *sha1)
403 const char *update_refresh[] = {
404 "update-index", "--ignore-submodules", "--refresh", NULL
406 const char *read_tree[] = {
407 "read-tree", "-u", "-m", sha1_to_hex(sha1), NULL
409 struct child_process child;
410 struct strbuf git_env = STRBUF_INIT;
411 const char *env[2];
413 if (is_bare_repository())
414 die ("denyCurrentBranch = updateInstead needs a worktree");
416 strbuf_addf(&git_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
417 env[0] = git_env.buf;
418 env[1] = NULL;
420 memset(&child, 0, sizeof(child));
421 child.argv = update_refresh;
422 child.env = env;
423 child.dir = git_work_tree_cfg ? git_work_tree_cfg : "..";
424 child.stdout_to_stderr = 1;
425 child.git_cmd = 1;
426 if (run_command(&child))
427 die ("Could not refresh the index");
429 child.argv = read_tree;
430 child.no_stdin = 1;
431 child.no_stdout = 1;
432 child.stdout_to_stderr = 0;
433 if (run_command(&child))
434 die ("Could not merge working tree with new HEAD. Good luck.");
436 strbuf_release(&git_env);
439 static const char *update(struct command *cmd)
441 const char *name = cmd->ref_name;
442 struct strbuf namespaced_name_buf = STRBUF_INIT;
443 const char *namespaced_name;
444 unsigned char *old_sha1 = cmd->old_sha1;
445 unsigned char *new_sha1 = cmd->new_sha1;
446 struct ref_lock *lock;
448 /* only refs/... are allowed */
449 if (prefixcmp(name, "refs/") || check_refname_format(name + 5, 0)) {
450 rp_error("refusing to create funny ref '%s' remotely", name);
451 return "funny refname";
454 strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
455 namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
457 if (is_ref_checked_out(namespaced_name)) {
458 switch (deny_current_branch) {
459 case DENY_IGNORE:
460 break;
461 case DENY_WARN:
462 rp_warning("updating the current branch");
463 break;
464 case DENY_REFUSE:
465 case DENY_UNCONFIGURED:
466 rp_error("refusing to update checked out branch: %s", name);
467 if (deny_current_branch == DENY_UNCONFIGURED)
468 refuse_unconfigured_deny();
469 return "branch is currently checked out";
470 case DENY_UPDATE_INSTEAD:
471 merge_worktree(new_sha1);
472 break;
473 case DENY_DETACH_INSTEAD:
474 update_ref("push into current branch (detach)", "HEAD",
475 old_sha1, NULL, REF_NODEREF, DIE_ON_ERR);
476 break;
480 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
481 error("unpack should have generated %s, "
482 "but I can't find it!", sha1_to_hex(new_sha1));
483 return "bad pack";
486 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
487 if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
488 rp_error("denying ref deletion for %s", name);
489 return "deletion prohibited";
492 if (!strcmp(namespaced_name, head_name)) {
493 switch (deny_delete_current) {
494 case DENY_IGNORE:
495 break;
496 case DENY_WARN:
497 rp_warning("deleting the current branch");
498 break;
499 case DENY_REFUSE:
500 case DENY_UNCONFIGURED:
501 if (deny_delete_current == DENY_UNCONFIGURED)
502 refuse_unconfigured_deny_delete_current();
503 rp_error("refusing to delete the current branch: %s", name);
504 return "deletion of the current branch prohibited";
505 default:
506 die ("Invalid denyDeleteCurrent setting");
511 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
512 !is_null_sha1(old_sha1) &&
513 !prefixcmp(name, "refs/heads/")) {
514 struct object *old_object, *new_object;
515 struct commit *old_commit, *new_commit;
516 struct commit_list *bases, *ent;
518 old_object = parse_object(old_sha1);
519 new_object = parse_object(new_sha1);
521 if (!old_object || !new_object ||
522 old_object->type != OBJ_COMMIT ||
523 new_object->type != OBJ_COMMIT) {
524 error("bad sha1 objects for %s", name);
525 return "bad ref";
527 old_commit = (struct commit *)old_object;
528 new_commit = (struct commit *)new_object;
529 bases = get_merge_bases(old_commit, new_commit, 1);
530 for (ent = bases; ent; ent = ent->next)
531 if (!hashcmp(old_sha1, ent->item->object.sha1))
532 break;
533 free_commit_list(bases);
534 if (!ent) {
535 rp_error("denying non-fast-forward %s"
536 " (you should pull first)", name);
537 return "non-fast-forward";
540 if (run_update_hook(cmd)) {
541 rp_error("hook declined to update %s", name);
542 return "hook declined";
545 if (is_null_sha1(new_sha1)) {
546 if (!parse_object(old_sha1)) {
547 old_sha1 = NULL;
548 if (ref_exists(name)) {
549 rp_warning("Allowing deletion of corrupt ref.");
550 } else {
551 rp_warning("Deleting a non-existent ref.");
552 cmd->did_not_exist = 1;
555 if (delete_ref(namespaced_name, old_sha1, 0)) {
556 rp_error("failed to delete %s", name);
557 return "failed to delete";
559 return NULL; /* good */
561 else {
562 lock = lock_any_ref_for_update(namespaced_name, old_sha1, 0);
563 if (!lock) {
564 rp_error("failed to lock %s", name);
565 return "failed to lock";
567 if (write_ref_sha1(lock, new_sha1, "push")) {
568 return "failed to write"; /* error() already called */
570 return NULL; /* good */
574 static char update_post_hook[] = "hooks/post-update";
576 static void run_update_post_hook(struct command *commands)
578 struct command *cmd;
579 int argc;
580 const char **argv;
581 struct child_process proc;
583 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
584 if (cmd->error_string || cmd->did_not_exist)
585 continue;
586 argc++;
588 if (!argc || access(update_post_hook, X_OK) < 0)
589 return;
590 argv = xmalloc(sizeof(*argv) * (2 + argc));
591 argv[0] = update_post_hook;
593 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
594 char *p;
595 if (cmd->error_string || cmd->did_not_exist)
596 continue;
597 p = xmalloc(strlen(cmd->ref_name) + 1);
598 strcpy(p, cmd->ref_name);
599 argv[argc] = p;
600 argc++;
602 argv[argc] = NULL;
604 memset(&proc, 0, sizeof(proc));
605 proc.no_stdin = 1;
606 proc.stdout_to_stderr = 1;
607 proc.err = use_sideband ? -1 : 0;
608 proc.argv = argv;
610 if (!start_command(&proc)) {
611 if (use_sideband)
612 copy_to_sideband(proc.err, -1, NULL);
613 finish_command(&proc);
617 static void check_aliased_update(struct command *cmd, struct string_list *list)
619 struct strbuf buf = STRBUF_INIT;
620 const char *dst_name;
621 struct string_list_item *item;
622 struct command *dst_cmd;
623 unsigned char sha1[20];
624 char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
625 int flag;
627 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
628 dst_name = resolve_ref(buf.buf, sha1, 0, &flag);
629 strbuf_release(&buf);
631 if (!(flag & REF_ISSYMREF))
632 return;
634 dst_name = strip_namespace(dst_name);
635 if (!dst_name) {
636 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
637 cmd->skip_update = 1;
638 cmd->error_string = "broken symref";
639 return;
642 if ((item = string_list_lookup(list, dst_name)) == NULL)
643 return;
645 cmd->skip_update = 1;
647 dst_cmd = (struct command *) item->util;
649 if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
650 !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
651 return;
653 dst_cmd->skip_update = 1;
655 strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
656 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
657 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
658 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
659 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
660 " its target '%s' (%s..%s)",
661 cmd->ref_name, cmd_oldh, cmd_newh,
662 dst_cmd->ref_name, dst_oldh, dst_newh);
664 cmd->error_string = dst_cmd->error_string =
665 "inconsistent aliased update";
668 static void check_aliased_updates(struct command *commands)
670 struct command *cmd;
671 struct string_list ref_list = STRING_LIST_INIT_NODUP;
673 for (cmd = commands; cmd; cmd = cmd->next) {
674 struct string_list_item *item =
675 string_list_append(&ref_list, cmd->ref_name);
676 item->util = (void *)cmd;
678 sort_string_list(&ref_list);
680 for (cmd = commands; cmd; cmd = cmd->next)
681 check_aliased_update(cmd, &ref_list);
683 string_list_clear(&ref_list, 0);
686 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
688 struct command **cmd_list = cb_data;
689 struct command *cmd = *cmd_list;
691 if (!cmd || is_null_sha1(cmd->new_sha1))
692 return -1; /* end of list */
693 *cmd_list = NULL; /* this returns only one */
694 hashcpy(sha1, cmd->new_sha1);
695 return 0;
698 static void set_connectivity_errors(struct command *commands)
700 struct command *cmd;
702 for (cmd = commands; cmd; cmd = cmd->next) {
703 struct command *singleton = cmd;
704 if (!check_everything_connected(command_singleton_iterator,
705 0, &singleton))
706 continue;
707 cmd->error_string = "missing necessary objects";
711 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
713 struct command **cmd_list = cb_data;
714 struct command *cmd = *cmd_list;
716 while (cmd) {
717 if (!is_null_sha1(cmd->new_sha1)) {
718 hashcpy(sha1, cmd->new_sha1);
719 *cmd_list = cmd->next;
720 return 0;
722 cmd = cmd->next;
724 *cmd_list = NULL;
725 return -1; /* end of list */
728 static void execute_commands(struct command *commands, const char *unpacker_error)
730 struct command *cmd;
731 unsigned char sha1[20];
733 if (unpacker_error) {
734 for (cmd = commands; cmd; cmd = cmd->next)
735 cmd->error_string = "n/a (unpacker error)";
736 return;
739 cmd = commands;
740 if (check_everything_connected(iterate_receive_command_list,
741 0, &cmd))
742 set_connectivity_errors(commands);
744 if (run_receive_hook(commands, pre_receive_hook, 0)) {
745 for (cmd = commands; cmd; cmd = cmd->next)
746 cmd->error_string = "pre-receive hook declined";
747 return;
750 check_aliased_updates(commands);
752 free((char*)head_name);
753 head_name = resolve_ref("HEAD", sha1, 0, NULL);
754 if (head_name)
755 head_name = xstrdup(head_name);
757 for (cmd = commands; cmd; cmd = cmd->next)
758 if (!cmd->skip_update)
759 cmd->error_string = update(cmd);
762 static struct command *read_head_info(void)
764 struct command *commands = NULL;
765 struct command **p = &commands;
766 for (;;) {
767 static char line[1000];
768 unsigned char old_sha1[20], new_sha1[20];
769 struct command *cmd;
770 char *refname;
771 int len, reflen;
773 len = packet_read_line(0, line, sizeof(line));
774 if (!len)
775 break;
776 if (line[len-1] == '\n')
777 line[--len] = 0;
778 if (len < 83 ||
779 line[40] != ' ' ||
780 line[81] != ' ' ||
781 get_sha1_hex(line, old_sha1) ||
782 get_sha1_hex(line + 41, new_sha1))
783 die("protocol error: expected old/new/ref, got '%s'",
784 line);
786 refname = line + 82;
787 reflen = strlen(refname);
788 if (reflen + 82 < len) {
789 if (strstr(refname + reflen + 1, "report-status"))
790 report_status = 1;
791 if (strstr(refname + reflen + 1, "side-band-64k"))
792 use_sideband = LARGE_PACKET_MAX;
794 cmd = xcalloc(1, sizeof(struct command) + len - 80);
795 hashcpy(cmd->old_sha1, old_sha1);
796 hashcpy(cmd->new_sha1, new_sha1);
797 memcpy(cmd->ref_name, line + 82, len - 81);
798 *p = cmd;
799 p = &cmd->next;
801 return commands;
804 static const char *parse_pack_header(struct pack_header *hdr)
806 switch (read_pack_header(0, hdr)) {
807 case PH_ERROR_EOF:
808 return "eof before pack header was fully read";
810 case PH_ERROR_PACK_SIGNATURE:
811 return "protocol error (pack signature mismatch detected)";
813 case PH_ERROR_PROTOCOL:
814 return "protocol error (pack version unsupported)";
816 default:
817 return "unknown error in parse_pack_header";
819 case 0:
820 return NULL;
824 static const char *pack_lockfile;
826 static const char *unpack(void)
828 struct pack_header hdr;
829 const char *hdr_err;
830 char hdr_arg[38];
831 int fsck_objects = (receive_fsck_objects >= 0
832 ? receive_fsck_objects
833 : transfer_fsck_objects >= 0
834 ? transfer_fsck_objects
835 : 0);
837 hdr_err = parse_pack_header(&hdr);
838 if (hdr_err)
839 return hdr_err;
840 snprintf(hdr_arg, sizeof(hdr_arg),
841 "--pack_header=%"PRIu32",%"PRIu32,
842 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
844 if (ntohl(hdr.hdr_entries) < unpack_limit) {
845 int code, i = 0;
846 const char *unpacker[4];
847 unpacker[i++] = "unpack-objects";
848 if (fsck_objects)
849 unpacker[i++] = "--strict";
850 unpacker[i++] = hdr_arg;
851 unpacker[i++] = NULL;
852 code = run_command_v_opt(unpacker, RUN_GIT_CMD);
853 if (!code)
854 return NULL;
855 return "unpack-objects abnormal exit";
856 } else {
857 const char *keeper[7];
858 int s, status, i = 0;
859 char keep_arg[256];
860 struct child_process ip;
862 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
863 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
864 strcpy(keep_arg + s, "localhost");
866 keeper[i++] = "index-pack";
867 keeper[i++] = "--stdin";
868 if (fsck_objects)
869 keeper[i++] = "--strict";
870 keeper[i++] = "--fix-thin";
871 keeper[i++] = hdr_arg;
872 keeper[i++] = keep_arg;
873 keeper[i++] = NULL;
874 memset(&ip, 0, sizeof(ip));
875 ip.argv = keeper;
876 ip.out = -1;
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 void report(struct command *commands, const char *unpack_status)
895 struct command *cmd;
896 struct strbuf buf = STRBUF_INIT;
898 packet_buf_write(&buf, "unpack %s\n",
899 unpack_status ? unpack_status : "ok");
900 for (cmd = commands; cmd; cmd = cmd->next) {
901 if (!cmd->error_string)
902 packet_buf_write(&buf, "ok %s\n",
903 cmd->ref_name);
904 else
905 packet_buf_write(&buf, "ng %s %s\n",
906 cmd->ref_name, cmd->error_string);
908 packet_buf_flush(&buf);
910 if (use_sideband)
911 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
912 else
913 safe_write(1, buf.buf, buf.len);
914 strbuf_release(&buf);
917 static int delete_only(struct command *commands)
919 struct command *cmd;
920 for (cmd = commands; cmd; cmd = cmd->next) {
921 if (!is_null_sha1(cmd->new_sha1))
922 return 0;
924 return 1;
927 static void add_one_alternate_sha1(const unsigned char sha1[20], void *unused)
929 add_extra_ref(".have", sha1, 0);
932 static void collect_one_alternate_ref(const struct ref *ref, void *data)
934 struct sha1_array *sa = data;
935 sha1_array_append(sa, ref->old_sha1);
938 static void add_alternate_refs(void)
940 struct sha1_array sa = SHA1_ARRAY_INIT;
941 for_each_alternate_ref(collect_one_alternate_ref, &sa);
942 sha1_array_for_each_unique(&sa, add_one_alternate_sha1, NULL);
943 sha1_array_clear(&sa);
946 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
948 int advertise_refs = 0;
949 int stateless_rpc = 0;
950 int i;
951 char *dir = NULL;
952 struct command *commands;
954 packet_trace_identity("receive-pack");
956 argv++;
957 for (i = 1; i < argc; i++) {
958 const char *arg = *argv++;
960 if (*arg == '-') {
961 if (!strcmp(arg, "--advertise-refs")) {
962 advertise_refs = 1;
963 continue;
965 if (!strcmp(arg, "--stateless-rpc")) {
966 stateless_rpc = 1;
967 continue;
970 usage(receive_pack_usage);
972 if (dir)
973 usage(receive_pack_usage);
974 dir = xstrdup(arg);
976 if (!dir)
977 usage(receive_pack_usage);
979 setup_path();
981 if (!enter_repo(dir, 0))
982 die("'%s' does not appear to be a git repository", dir);
984 if (is_repository_shallow())
985 die("attempt to push into a shallow repository");
987 git_config(receive_pack_config, NULL);
989 if (0 <= transfer_unpack_limit)
990 unpack_limit = transfer_unpack_limit;
991 else if (0 <= receive_unpack_limit)
992 unpack_limit = receive_unpack_limit;
994 if (advertise_refs || !stateless_rpc) {
995 add_alternate_refs();
996 write_head_info();
997 clear_extra_refs();
999 /* EOF */
1000 packet_flush(1);
1002 if (advertise_refs)
1003 return 0;
1005 if ((commands = read_head_info()) != NULL) {
1006 const char *unpack_status = NULL;
1008 if (!delete_only(commands))
1009 unpack_status = unpack();
1010 execute_commands(commands, unpack_status);
1011 if (pack_lockfile)
1012 unlink_or_warn(pack_lockfile);
1013 if (report_status)
1014 report(commands, unpack_status);
1015 run_receive_hook(commands, post_receive_hook, 1);
1016 run_update_post_hook(commands);
1017 if (auto_gc) {
1018 const char *argv_gc_auto[] = {
1019 "gc", "--auto", "--quiet", NULL,
1021 run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
1023 if (auto_update_server_info)
1024 update_server_info(0);
1026 if (use_sideband)
1027 packet_flush(1);
1028 return 0;