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