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 };
25 static int deny_deletes;
26 static int deny_non_fast_forwards;
27 static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
28 static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
29 static int receive_fsck_objects = -1;
30 static int transfer_fsck_objects = -1;
31 static int receive_unpack_limit = -1;
32 static int transfer_unpack_limit = -1;
33 static int unpack_limit = 100;
34 static int report_status;
35 static int use_sideband;
36 static int prefer_ofs_delta = 1;
37 static int auto_update_server_info;
38 static int auto_gc = 1;
39 static const char *head_name;
40 static int sent_capabilities;
42 static enum deny_action parse_deny_action(const char *var, const char *value)
43 {
44 if (value) {
45 if (!strcasecmp(value, "ignore"))
46 return DENY_IGNORE;
47 if (!strcasecmp(value, "warn"))
48 return DENY_WARN;
49 if (!strcasecmp(value, "refuse"))
50 return DENY_REFUSE;
51 }
52 if (git_config_bool(var, value))
53 return DENY_REFUSE;
54 return DENY_IGNORE;
55 }
57 static int receive_pack_config(const char *var, const char *value, void *cb)
58 {
59 if (strcmp(var, "receive.denydeletes") == 0) {
60 deny_deletes = git_config_bool(var, value);
61 return 0;
62 }
64 if (strcmp(var, "receive.denynonfastforwards") == 0) {
65 deny_non_fast_forwards = git_config_bool(var, value);
66 return 0;
67 }
69 if (strcmp(var, "receive.unpacklimit") == 0) {
70 receive_unpack_limit = git_config_int(var, value);
71 return 0;
72 }
74 if (strcmp(var, "transfer.unpacklimit") == 0) {
75 transfer_unpack_limit = git_config_int(var, value);
76 return 0;
77 }
79 if (strcmp(var, "receive.fsckobjects") == 0) {
80 receive_fsck_objects = git_config_bool(var, value);
81 return 0;
82 }
84 if (strcmp(var, "transfer.fsckobjects") == 0) {
85 transfer_fsck_objects = git_config_bool(var, value);
86 return 0;
87 }
89 if (!strcmp(var, "receive.denycurrentbranch")) {
90 deny_current_branch = parse_deny_action(var, value);
91 return 0;
92 }
94 if (strcmp(var, "receive.denydeletecurrent") == 0) {
95 deny_delete_current = parse_deny_action(var, value);
96 return 0;
97 }
99 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
100 prefer_ofs_delta = git_config_bool(var, value);
101 return 0;
102 }
104 if (strcmp(var, "receive.updateserverinfo") == 0) {
105 auto_update_server_info = git_config_bool(var, value);
106 return 0;
107 }
109 if (strcmp(var, "receive.autogc") == 0) {
110 auto_gc = git_config_bool(var, value);
111 return 0;
112 }
114 return git_default_config(var, value, cb);
115 }
117 static int show_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
118 {
119 if (sent_capabilities)
120 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
121 else
122 packet_write(1, "%s %s%c%s%s\n",
123 sha1_to_hex(sha1), path, 0,
124 " report-status delete-refs side-band-64k",
125 prefer_ofs_delta ? " ofs-delta" : "");
126 sent_capabilities = 1;
127 return 0;
128 }
130 static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *cb_data)
131 {
132 path = strip_namespace(path);
133 /*
134 * Advertise refs outside our current namespace as ".have"
135 * refs, so that the client can use them to minimize data
136 * transfer but will otherwise ignore them. This happens to
137 * cover ".have" that are thrown in by add_one_alternate_ref()
138 * to mark histories that are complete in our alternates as
139 * well.
140 */
141 if (!path)
142 path = ".have";
143 return show_ref(path, sha1, flag, cb_data);
144 }
146 static void write_head_info(void)
147 {
148 for_each_ref(show_ref_cb, NULL);
149 if (!sent_capabilities)
150 show_ref("capabilities^{}", null_sha1, 0, NULL);
152 }
154 struct command {
155 struct command *next;
156 const char *error_string;
157 unsigned int skip_update:1,
158 did_not_exist:1;
159 unsigned char old_sha1[20];
160 unsigned char new_sha1[20];
161 char ref_name[FLEX_ARRAY]; /* more */
162 };
164 static const char pre_receive_hook[] = "hooks/pre-receive";
165 static const char post_receive_hook[] = "hooks/post-receive";
167 static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
168 static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
170 static void report_message(const char *prefix, const char *err, va_list params)
171 {
172 int sz = strlen(prefix);
173 char msg[4096];
175 strncpy(msg, prefix, sz);
176 sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
177 if (sz > (sizeof(msg) - 1))
178 sz = sizeof(msg) - 1;
179 msg[sz++] = '\n';
181 if (use_sideband)
182 send_sideband(1, 2, msg, sz, use_sideband);
183 else
184 xwrite(2, msg, sz);
185 }
187 static void rp_warning(const char *err, ...)
188 {
189 va_list params;
190 va_start(params, err);
191 report_message("warning: ", err, params);
192 va_end(params);
193 }
195 static void rp_error(const char *err, ...)
196 {
197 va_list params;
198 va_start(params, err);
199 report_message("error: ", err, params);
200 va_end(params);
201 }
203 static int copy_to_sideband(int in, int out, void *arg)
204 {
205 char data[128];
206 while (1) {
207 ssize_t sz = xread(in, data, sizeof(data));
208 if (sz <= 0)
209 break;
210 send_sideband(1, 2, data, sz, use_sideband);
211 }
212 close(in);
213 return 0;
214 }
216 typedef int (*feed_fn)(void *, const char **, size_t *);
217 static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
218 {
219 struct child_process proc;
220 struct async muxer;
221 const char *argv[2];
222 int code;
224 if (access(hook_name, X_OK) < 0)
225 return 0;
227 argv[0] = hook_name;
228 argv[1] = NULL;
230 memset(&proc, 0, sizeof(proc));
231 proc.argv = argv;
232 proc.in = -1;
233 proc.stdout_to_stderr = 1;
235 if (use_sideband) {
236 memset(&muxer, 0, sizeof(muxer));
237 muxer.proc = copy_to_sideband;
238 muxer.in = -1;
239 code = start_async(&muxer);
240 if (code)
241 return code;
242 proc.err = muxer.in;
243 }
245 code = start_command(&proc);
246 if (code) {
247 if (use_sideband)
248 finish_async(&muxer);
249 return code;
250 }
252 while (1) {
253 const char *buf;
254 size_t n;
255 if (feed(feed_state, &buf, &n))
256 break;
257 if (write_in_full(proc.in, buf, n) != n)
258 break;
259 }
260 close(proc.in);
261 if (use_sideband)
262 finish_async(&muxer);
263 return finish_command(&proc);
264 }
266 struct receive_hook_feed_state {
267 struct command *cmd;
268 int skip_broken;
269 struct strbuf buf;
270 };
272 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
273 {
274 struct receive_hook_feed_state *state = state_;
275 struct command *cmd = state->cmd;
277 while (cmd &&
278 state->skip_broken && (cmd->error_string || cmd->did_not_exist))
279 cmd = cmd->next;
280 if (!cmd)
281 return -1; /* EOF */
282 strbuf_reset(&state->buf);
283 strbuf_addf(&state->buf, "%s %s %s\n",
284 sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
285 cmd->ref_name);
286 state->cmd = cmd->next;
287 if (bufp) {
288 *bufp = state->buf.buf;
289 *sizep = state->buf.len;
290 }
291 return 0;
292 }
294 static int run_receive_hook(struct command *commands, const char *hook_name,
295 int skip_broken)
296 {
297 struct receive_hook_feed_state state;
298 int status;
300 strbuf_init(&state.buf, 0);
301 state.cmd = commands;
302 state.skip_broken = skip_broken;
303 if (feed_receive_hook(&state, NULL, NULL))
304 return 0;
305 state.cmd = commands;
306 status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
307 strbuf_release(&state.buf);
308 return status;
309 }
311 static int run_update_hook(struct command *cmd)
312 {
313 static const char update_hook[] = "hooks/update";
314 const char *argv[5];
315 struct child_process proc;
316 int code;
318 if (access(update_hook, X_OK) < 0)
319 return 0;
321 argv[0] = update_hook;
322 argv[1] = cmd->ref_name;
323 argv[2] = sha1_to_hex(cmd->old_sha1);
324 argv[3] = sha1_to_hex(cmd->new_sha1);
325 argv[4] = NULL;
327 memset(&proc, 0, sizeof(proc));
328 proc.no_stdin = 1;
329 proc.stdout_to_stderr = 1;
330 proc.err = use_sideband ? -1 : 0;
331 proc.argv = argv;
333 code = start_command(&proc);
334 if (code)
335 return code;
336 if (use_sideband)
337 copy_to_sideband(proc.err, -1, NULL);
338 return finish_command(&proc);
339 }
341 static int is_ref_checked_out(const char *ref)
342 {
343 if (is_bare_repository())
344 return 0;
346 if (!head_name)
347 return 0;
348 return !strcmp(head_name, ref);
349 }
351 static char *refuse_unconfigured_deny_msg[] = {
352 "By default, updating the current branch in a non-bare repository",
353 "is denied, because it will make the index and work tree inconsistent",
354 "with what you pushed, and will require 'git reset --hard' to match",
355 "the work tree to HEAD.",
356 "",
357 "You can set 'receive.denyCurrentBranch' configuration variable to",
358 "'ignore' or 'warn' in the remote repository to allow pushing into",
359 "its current branch; however, this is not recommended unless you",
360 "arranged to update its work tree to match what you pushed in some",
361 "other way.",
362 "",
363 "To squelch this message and still keep the default behaviour, set",
364 "'receive.denyCurrentBranch' configuration variable to 'refuse'."
365 };
367 static void refuse_unconfigured_deny(void)
368 {
369 int i;
370 for (i = 0; i < ARRAY_SIZE(refuse_unconfigured_deny_msg); i++)
371 rp_error("%s", refuse_unconfigured_deny_msg[i]);
372 }
374 static char *refuse_unconfigured_deny_delete_current_msg[] = {
375 "By default, deleting the current branch is denied, because the next",
376 "'git clone' won't result in any file checked out, causing confusion.",
377 "",
378 "You can set 'receive.denyDeleteCurrent' configuration variable to",
379 "'warn' or 'ignore' in the remote repository to allow deleting the",
380 "current branch, with or without a warning message.",
381 "",
382 "To squelch this message, you can set it to 'refuse'."
383 };
385 static void refuse_unconfigured_deny_delete_current(void)
386 {
387 int i;
388 for (i = 0;
389 i < ARRAY_SIZE(refuse_unconfigured_deny_delete_current_msg);
390 i++)
391 rp_error("%s", refuse_unconfigured_deny_delete_current_msg[i]);
392 }
394 static const char *update(struct command *cmd)
395 {
396 const char *name = cmd->ref_name;
397 struct strbuf namespaced_name_buf = STRBUF_INIT;
398 const char *namespaced_name;
399 unsigned char *old_sha1 = cmd->old_sha1;
400 unsigned char *new_sha1 = cmd->new_sha1;
401 struct ref_lock *lock;
403 /* only refs/... are allowed */
404 if (prefixcmp(name, "refs/") || check_refname_format(name + 5, 0)) {
405 rp_error("refusing to create funny ref '%s' remotely", name);
406 return "funny refname";
407 }
409 strbuf_addf(&namespaced_name_buf, "%s%s", get_git_namespace(), name);
410 namespaced_name = strbuf_detach(&namespaced_name_buf, NULL);
412 if (is_ref_checked_out(namespaced_name)) {
413 switch (deny_current_branch) {
414 case DENY_IGNORE:
415 break;
416 case DENY_WARN:
417 rp_warning("updating the current branch");
418 break;
419 case DENY_REFUSE:
420 case DENY_UNCONFIGURED:
421 rp_error("refusing to update checked out branch: %s", name);
422 if (deny_current_branch == DENY_UNCONFIGURED)
423 refuse_unconfigured_deny();
424 return "branch is currently checked out";
425 }
426 }
428 if (!is_null_sha1(new_sha1) && !has_sha1_file(new_sha1)) {
429 error("unpack should have generated %s, "
430 "but I can't find it!", sha1_to_hex(new_sha1));
431 return "bad pack";
432 }
434 if (!is_null_sha1(old_sha1) && is_null_sha1(new_sha1)) {
435 if (deny_deletes && !prefixcmp(name, "refs/heads/")) {
436 rp_error("denying ref deletion for %s", name);
437 return "deletion prohibited";
438 }
440 if (!strcmp(namespaced_name, head_name)) {
441 switch (deny_delete_current) {
442 case DENY_IGNORE:
443 break;
444 case DENY_WARN:
445 rp_warning("deleting the current branch");
446 break;
447 case DENY_REFUSE:
448 case DENY_UNCONFIGURED:
449 if (deny_delete_current == DENY_UNCONFIGURED)
450 refuse_unconfigured_deny_delete_current();
451 rp_error("refusing to delete the current branch: %s", name);
452 return "deletion of the current branch prohibited";
453 }
454 }
455 }
457 if (deny_non_fast_forwards && !is_null_sha1(new_sha1) &&
458 !is_null_sha1(old_sha1) &&
459 !prefixcmp(name, "refs/heads/")) {
460 struct object *old_object, *new_object;
461 struct commit *old_commit, *new_commit;
462 struct commit_list *bases, *ent;
464 old_object = parse_object(old_sha1);
465 new_object = parse_object(new_sha1);
467 if (!old_object || !new_object ||
468 old_object->type != OBJ_COMMIT ||
469 new_object->type != OBJ_COMMIT) {
470 error("bad sha1 objects for %s", name);
471 return "bad ref";
472 }
473 old_commit = (struct commit *)old_object;
474 new_commit = (struct commit *)new_object;
475 bases = get_merge_bases(old_commit, new_commit, 1);
476 for (ent = bases; ent; ent = ent->next)
477 if (!hashcmp(old_sha1, ent->item->object.sha1))
478 break;
479 free_commit_list(bases);
480 if (!ent) {
481 rp_error("denying non-fast-forward %s"
482 " (you should pull first)", name);
483 return "non-fast-forward";
484 }
485 }
486 if (run_update_hook(cmd)) {
487 rp_error("hook declined to update %s", name);
488 return "hook declined";
489 }
491 if (is_null_sha1(new_sha1)) {
492 if (!parse_object(old_sha1)) {
493 old_sha1 = NULL;
494 if (ref_exists(name)) {
495 rp_warning("Allowing deletion of corrupt ref.");
496 } else {
497 rp_warning("Deleting a non-existent ref.");
498 cmd->did_not_exist = 1;
499 }
500 }
501 if (delete_ref(namespaced_name, old_sha1, 0)) {
502 rp_error("failed to delete %s", name);
503 return "failed to delete";
504 }
505 return NULL; /* good */
506 }
507 else {
508 lock = lock_any_ref_for_update(namespaced_name, old_sha1, 0);
509 if (!lock) {
510 rp_error("failed to lock %s", name);
511 return "failed to lock";
512 }
513 if (write_ref_sha1(lock, new_sha1, "push")) {
514 return "failed to write"; /* error() already called */
515 }
516 return NULL; /* good */
517 }
518 }
520 static char update_post_hook[] = "hooks/post-update";
522 static void run_update_post_hook(struct command *commands)
523 {
524 struct command *cmd;
525 int argc;
526 const char **argv;
527 struct child_process proc;
529 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
530 if (cmd->error_string || cmd->did_not_exist)
531 continue;
532 argc++;
533 }
534 if (!argc || access(update_post_hook, X_OK) < 0)
535 return;
536 argv = xmalloc(sizeof(*argv) * (2 + argc));
537 argv[0] = update_post_hook;
539 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
540 char *p;
541 if (cmd->error_string || cmd->did_not_exist)
542 continue;
543 p = xmalloc(strlen(cmd->ref_name) + 1);
544 strcpy(p, cmd->ref_name);
545 argv[argc] = p;
546 argc++;
547 }
548 argv[argc] = NULL;
550 memset(&proc, 0, sizeof(proc));
551 proc.no_stdin = 1;
552 proc.stdout_to_stderr = 1;
553 proc.err = use_sideband ? -1 : 0;
554 proc.argv = argv;
556 if (!start_command(&proc)) {
557 if (use_sideband)
558 copy_to_sideband(proc.err, -1, NULL);
559 finish_command(&proc);
560 }
561 }
563 static void check_aliased_update(struct command *cmd, struct string_list *list)
564 {
565 struct strbuf buf = STRBUF_INIT;
566 const char *dst_name;
567 struct string_list_item *item;
568 struct command *dst_cmd;
569 unsigned char sha1[20];
570 char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
571 int flag;
573 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
574 dst_name = resolve_ref(buf.buf, sha1, 0, &flag);
575 strbuf_release(&buf);
577 if (!(flag & REF_ISSYMREF))
578 return;
580 dst_name = strip_namespace(dst_name);
581 if (!dst_name) {
582 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
583 cmd->skip_update = 1;
584 cmd->error_string = "broken symref";
585 return;
586 }
588 if ((item = string_list_lookup(list, dst_name)) == NULL)
589 return;
591 cmd->skip_update = 1;
593 dst_cmd = (struct command *) item->util;
595 if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
596 !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
597 return;
599 dst_cmd->skip_update = 1;
601 strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
602 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
603 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
604 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
605 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
606 " its target '%s' (%s..%s)",
607 cmd->ref_name, cmd_oldh, cmd_newh,
608 dst_cmd->ref_name, dst_oldh, dst_newh);
610 cmd->error_string = dst_cmd->error_string =
611 "inconsistent aliased update";
612 }
614 static void check_aliased_updates(struct command *commands)
615 {
616 struct command *cmd;
617 struct string_list ref_list = STRING_LIST_INIT_NODUP;
619 for (cmd = commands; cmd; cmd = cmd->next) {
620 struct string_list_item *item =
621 string_list_append(&ref_list, cmd->ref_name);
622 item->util = (void *)cmd;
623 }
624 sort_string_list(&ref_list);
626 for (cmd = commands; cmd; cmd = cmd->next) {
627 if (!cmd->error_string)
628 check_aliased_update(cmd, &ref_list);
629 }
631 string_list_clear(&ref_list, 0);
632 }
634 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
635 {
636 struct command **cmd_list = cb_data;
637 struct command *cmd = *cmd_list;
639 if (!cmd || is_null_sha1(cmd->new_sha1))
640 return -1; /* end of list */
641 *cmd_list = NULL; /* this returns only one */
642 hashcpy(sha1, cmd->new_sha1);
643 return 0;
644 }
646 static void set_connectivity_errors(struct command *commands)
647 {
648 struct command *cmd;
650 for (cmd = commands; cmd; cmd = cmd->next) {
651 struct command *singleton = cmd;
652 if (!check_everything_connected(command_singleton_iterator,
653 0, &singleton))
654 continue;
655 cmd->error_string = "missing necessary objects";
656 }
657 }
659 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
660 {
661 struct command **cmd_list = cb_data;
662 struct command *cmd = *cmd_list;
664 while (cmd) {
665 if (!is_null_sha1(cmd->new_sha1)) {
666 hashcpy(sha1, cmd->new_sha1);
667 *cmd_list = cmd->next;
668 return 0;
669 }
670 cmd = cmd->next;
671 }
672 *cmd_list = NULL;
673 return -1; /* end of list */
674 }
676 static void execute_commands(struct command *commands, const char *unpacker_error)
677 {
678 struct command *cmd;
679 unsigned char sha1[20];
681 if (unpacker_error) {
682 for (cmd = commands; cmd; cmd = cmd->next)
683 cmd->error_string = "n/a (unpacker error)";
684 return;
685 }
687 cmd = commands;
688 if (check_everything_connected(iterate_receive_command_list,
689 0, &cmd))
690 set_connectivity_errors(commands);
692 if (run_receive_hook(commands, pre_receive_hook, 0)) {
693 for (cmd = commands; cmd; cmd = cmd->next) {
694 if (!cmd->error_string)
695 cmd->error_string = "pre-receive hook declined";
696 }
697 return;
698 }
700 check_aliased_updates(commands);
702 head_name = resolve_ref("HEAD", sha1, 0, NULL);
704 for (cmd = commands; cmd; cmd = cmd->next) {
705 if (cmd->error_string)
706 continue;
708 if (cmd->skip_update)
709 continue;
711 cmd->error_string = update(cmd);
712 }
713 }
715 static struct command *read_head_info(void)
716 {
717 struct command *commands = NULL;
718 struct command **p = &commands;
719 for (;;) {
720 static char line[1000];
721 unsigned char old_sha1[20], new_sha1[20];
722 struct command *cmd;
723 char *refname;
724 int len, reflen;
726 len = packet_read_line(0, line, sizeof(line));
727 if (!len)
728 break;
729 if (line[len-1] == '\n')
730 line[--len] = 0;
731 if (len < 83 ||
732 line[40] != ' ' ||
733 line[81] != ' ' ||
734 get_sha1_hex(line, old_sha1) ||
735 get_sha1_hex(line + 41, new_sha1))
736 die("protocol error: expected old/new/ref, got '%s'",
737 line);
739 refname = line + 82;
740 reflen = strlen(refname);
741 if (reflen + 82 < len) {
742 if (strstr(refname + reflen + 1, "report-status"))
743 report_status = 1;
744 if (strstr(refname + reflen + 1, "side-band-64k"))
745 use_sideband = LARGE_PACKET_MAX;
746 }
747 cmd = xcalloc(1, sizeof(struct command) + len - 80);
748 hashcpy(cmd->old_sha1, old_sha1);
749 hashcpy(cmd->new_sha1, new_sha1);
750 memcpy(cmd->ref_name, line + 82, len - 81);
751 *p = cmd;
752 p = &cmd->next;
753 }
754 return commands;
755 }
757 static const char *parse_pack_header(struct pack_header *hdr)
758 {
759 switch (read_pack_header(0, hdr)) {
760 case PH_ERROR_EOF:
761 return "eof before pack header was fully read";
763 case PH_ERROR_PACK_SIGNATURE:
764 return "protocol error (pack signature mismatch detected)";
766 case PH_ERROR_PROTOCOL:
767 return "protocol error (pack version unsupported)";
769 default:
770 return "unknown error in parse_pack_header";
772 case 0:
773 return NULL;
774 }
775 }
777 static const char *pack_lockfile;
779 static const char *unpack(void)
780 {
781 struct pack_header hdr;
782 const char *hdr_err;
783 char hdr_arg[38];
784 int fsck_objects = (receive_fsck_objects >= 0
785 ? receive_fsck_objects
786 : transfer_fsck_objects >= 0
787 ? transfer_fsck_objects
788 : 0);
790 hdr_err = parse_pack_header(&hdr);
791 if (hdr_err)
792 return hdr_err;
793 snprintf(hdr_arg, sizeof(hdr_arg),
794 "--pack_header=%"PRIu32",%"PRIu32,
795 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
797 if (ntohl(hdr.hdr_entries) < unpack_limit) {
798 int code, i = 0;
799 const char *unpacker[4];
800 unpacker[i++] = "unpack-objects";
801 if (fsck_objects)
802 unpacker[i++] = "--strict";
803 unpacker[i++] = hdr_arg;
804 unpacker[i++] = NULL;
805 code = run_command_v_opt(unpacker, RUN_GIT_CMD);
806 if (!code)
807 return NULL;
808 return "unpack-objects abnormal exit";
809 } else {
810 const char *keeper[7];
811 int s, status, i = 0;
812 char keep_arg[256];
813 struct child_process ip;
815 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
816 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
817 strcpy(keep_arg + s, "localhost");
819 keeper[i++] = "index-pack";
820 keeper[i++] = "--stdin";
821 if (fsck_objects)
822 keeper[i++] = "--strict";
823 keeper[i++] = "--fix-thin";
824 keeper[i++] = hdr_arg;
825 keeper[i++] = keep_arg;
826 keeper[i++] = NULL;
827 memset(&ip, 0, sizeof(ip));
828 ip.argv = keeper;
829 ip.out = -1;
830 ip.git_cmd = 1;
831 status = start_command(&ip);
832 if (status) {
833 return "index-pack fork failed";
834 }
835 pack_lockfile = index_pack_lockfile(ip.out);
836 close(ip.out);
837 status = finish_command(&ip);
838 if (!status) {
839 reprepare_packed_git();
840 return NULL;
841 }
842 return "index-pack abnormal exit";
843 }
844 }
846 static void report(struct command *commands, const char *unpack_status)
847 {
848 struct command *cmd;
849 struct strbuf buf = STRBUF_INIT;
851 packet_buf_write(&buf, "unpack %s\n",
852 unpack_status ? unpack_status : "ok");
853 for (cmd = commands; cmd; cmd = cmd->next) {
854 if (!cmd->error_string)
855 packet_buf_write(&buf, "ok %s\n",
856 cmd->ref_name);
857 else
858 packet_buf_write(&buf, "ng %s %s\n",
859 cmd->ref_name, cmd->error_string);
860 }
861 packet_buf_flush(&buf);
863 if (use_sideband)
864 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
865 else
866 safe_write(1, buf.buf, buf.len);
867 strbuf_release(&buf);
868 }
870 static int delete_only(struct command *commands)
871 {
872 struct command *cmd;
873 for (cmd = commands; cmd; cmd = cmd->next) {
874 if (!is_null_sha1(cmd->new_sha1))
875 return 0;
876 }
877 return 1;
878 }
880 static void add_one_alternate_sha1(const unsigned char sha1[20], void *unused)
881 {
882 add_extra_ref(".have", sha1, 0);
883 }
885 static void collect_one_alternate_ref(const struct ref *ref, void *data)
886 {
887 struct sha1_array *sa = data;
888 sha1_array_append(sa, ref->old_sha1);
889 }
891 static void add_alternate_refs(void)
892 {
893 struct sha1_array sa = SHA1_ARRAY_INIT;
894 for_each_alternate_ref(collect_one_alternate_ref, &sa);
895 sha1_array_for_each_unique(&sa, add_one_alternate_sha1, NULL);
896 sha1_array_clear(&sa);
897 }
899 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
900 {
901 int advertise_refs = 0;
902 int stateless_rpc = 0;
903 int i;
904 char *dir = NULL;
905 struct command *commands;
907 packet_trace_identity("receive-pack");
909 argv++;
910 for (i = 1; i < argc; i++) {
911 const char *arg = *argv++;
913 if (*arg == '-') {
914 if (!strcmp(arg, "--advertise-refs")) {
915 advertise_refs = 1;
916 continue;
917 }
918 if (!strcmp(arg, "--stateless-rpc")) {
919 stateless_rpc = 1;
920 continue;
921 }
923 usage(receive_pack_usage);
924 }
925 if (dir)
926 usage(receive_pack_usage);
927 dir = xstrdup(arg);
928 }
929 if (!dir)
930 usage(receive_pack_usage);
932 setup_path();
934 if (!enter_repo(dir, 0))
935 die("'%s' does not appear to be a git repository", dir);
937 if (is_repository_shallow())
938 die("attempt to push into a shallow repository");
940 git_config(receive_pack_config, NULL);
942 if (0 <= transfer_unpack_limit)
943 unpack_limit = transfer_unpack_limit;
944 else if (0 <= receive_unpack_limit)
945 unpack_limit = receive_unpack_limit;
947 if (advertise_refs || !stateless_rpc) {
948 add_alternate_refs();
949 write_head_info();
950 clear_extra_refs();
952 /* EOF */
953 packet_flush(1);
954 }
955 if (advertise_refs)
956 return 0;
958 if ((commands = read_head_info()) != NULL) {
959 const char *unpack_status = NULL;
961 if (!delete_only(commands))
962 unpack_status = unpack();
963 execute_commands(commands, unpack_status);
964 if (pack_lockfile)
965 unlink_or_warn(pack_lockfile);
966 if (report_status)
967 report(commands, unpack_status);
968 run_receive_hook(commands, post_receive_hook, 1);
969 run_update_post_hook(commands);
970 if (auto_gc) {
971 const char *argv_gc_auto[] = {
972 "gc", "--auto", "--quiet", NULL,
973 };
974 run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
975 }
976 if (auto_update_server_info)
977 update_server_info(0);
978 }
979 if (use_sideband)
980 packet_flush(1);
981 return 0;
982 }