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