upload/receive-pack: allow hiding ref hierarchies
[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 "transport.h"
12 #include "string-list.h"
13 #include "sha1-array.h"
14 #include "connected.h"
15 #include "version.h"
16
17 static const char receive_pack_usage[] = "git receive-pack <git-dir>";
18
19 enum deny_action {
20 DENY_UNCONFIGURED,
21 DENY_IGNORE,
22 DENY_WARN,
23 DENY_REFUSE
24 };
25
26 static int deny_deletes;
27 static int deny_non_fast_forwards;
28 static enum deny_action deny_current_branch = DENY_UNCONFIGURED;
29 static enum deny_action deny_delete_current = DENY_UNCONFIGURED;
30 static int receive_fsck_objects = -1;
31 static int transfer_fsck_objects = -1;
32 static int receive_unpack_limit = -1;
33 static int transfer_unpack_limit = -1;
34 static int unpack_limit = 100;
35 static int report_status;
36 static int use_sideband;
37 static int quiet;
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 void *head_name_to_free;
43 static int sent_capabilities;
44
45 static enum deny_action parse_deny_action(const char *var, const char *value)
46 {
47 if (value) {
48 if (!strcasecmp(value, "ignore"))
49 return DENY_IGNORE;
50 if (!strcasecmp(value, "warn"))
51 return DENY_WARN;
52 if (!strcasecmp(value, "refuse"))
53 return DENY_REFUSE;
54 }
55 if (git_config_bool(var, value))
56 return DENY_REFUSE;
57 return DENY_IGNORE;
58 }
59
60 static int receive_pack_config(const char *var, const char *value, void *cb)
61 {
62 int status = parse_hide_refs_config(var, value, "receive");
63
64 if (status)
65 return status;
66
67 if (strcmp(var, "receive.denydeletes") == 0) {
68 deny_deletes = git_config_bool(var, value);
69 return 0;
70 }
71
72 if (strcmp(var, "receive.denynonfastforwards") == 0) {
73 deny_non_fast_forwards = git_config_bool(var, value);
74 return 0;
75 }
76
77 if (strcmp(var, "receive.unpacklimit") == 0) {
78 receive_unpack_limit = git_config_int(var, value);
79 return 0;
80 }
81
82 if (strcmp(var, "transfer.unpacklimit") == 0) {
83 transfer_unpack_limit = git_config_int(var, value);
84 return 0;
85 }
86
87 if (strcmp(var, "receive.fsckobjects") == 0) {
88 receive_fsck_objects = git_config_bool(var, value);
89 return 0;
90 }
91
92 if (strcmp(var, "transfer.fsckobjects") == 0) {
93 transfer_fsck_objects = git_config_bool(var, value);
94 return 0;
95 }
96
97 if (!strcmp(var, "receive.denycurrentbranch")) {
98 deny_current_branch = parse_deny_action(var, value);
99 return 0;
100 }
101
102 if (strcmp(var, "receive.denydeletecurrent") == 0) {
103 deny_delete_current = parse_deny_action(var, value);
104 return 0;
105 }
106
107 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
108 prefer_ofs_delta = git_config_bool(var, value);
109 return 0;
110 }
111
112 if (strcmp(var, "receive.updateserverinfo") == 0) {
113 auto_update_server_info = git_config_bool(var, value);
114 return 0;
115 }
116
117 if (strcmp(var, "receive.autogc") == 0) {
118 auto_gc = git_config_bool(var, value);
119 return 0;
120 }
121
122 return git_default_config(var, value, cb);
123 }
124
125 static void show_ref(const char *path, const unsigned char *sha1)
126 {
127 if (ref_is_hidden(path))
128 return;
129
130 if (sent_capabilities)
131 packet_write(1, "%s %s\n", sha1_to_hex(sha1), path);
132 else
133 packet_write(1, "%s %s%c%s%s agent=%s\n",
134 sha1_to_hex(sha1), path, 0,
135 " report-status delete-refs side-band-64k quiet",
136 prefer_ofs_delta ? " ofs-delta" : "",
137 git_user_agent_sanitized());
138 sent_capabilities = 1;
139 }
140
141 static int show_ref_cb(const char *path, const unsigned char *sha1, int flag, void *unused)
142 {
143 path = strip_namespace(path);
144 /*
145 * Advertise refs outside our current namespace as ".have"
146 * refs, so that the client can use them to minimize data
147 * transfer but will otherwise ignore them. This happens to
148 * cover ".have" that are thrown in by add_one_alternate_ref()
149 * to mark histories that are complete in our alternates as
150 * well.
151 */
152 if (!path)
153 path = ".have";
154 show_ref(path, sha1);
155 return 0;
156 }
157
158 static void show_one_alternate_sha1(const unsigned char sha1[20], void *unused)
159 {
160 show_ref(".have", sha1);
161 }
162
163 static void collect_one_alternate_ref(const struct ref *ref, void *data)
164 {
165 struct sha1_array *sa = data;
166 sha1_array_append(sa, ref->old_sha1);
167 }
168
169 static void write_head_info(void)
170 {
171 struct sha1_array sa = SHA1_ARRAY_INIT;
172 for_each_alternate_ref(collect_one_alternate_ref, &sa);
173 sha1_array_for_each_unique(&sa, show_one_alternate_sha1, NULL);
174 sha1_array_clear(&sa);
175 for_each_ref(show_ref_cb, NULL);
176 if (!sent_capabilities)
177 show_ref("capabilities^{}", null_sha1);
178
179 /* EOF */
180 packet_flush(1);
181 }
182
183 struct command {
184 struct command *next;
185 const char *error_string;
186 unsigned int skip_update:1,
187 did_not_exist:1;
188 unsigned char old_sha1[20];
189 unsigned char new_sha1[20];
190 char ref_name[FLEX_ARRAY]; /* more */
191 };
192
193 static const char pre_receive_hook[] = "hooks/pre-receive";
194 static const char post_receive_hook[] = "hooks/post-receive";
195
196 static void rp_error(const char *err, ...) __attribute__((format (printf, 1, 2)));
197 static void rp_warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
198
199 static void report_message(const char *prefix, const char *err, va_list params)
200 {
201 int sz = strlen(prefix);
202 char msg[4096];
203
204 strncpy(msg, prefix, sz);
205 sz += vsnprintf(msg + sz, sizeof(msg) - sz, err, params);
206 if (sz > (sizeof(msg) - 1))
207 sz = sizeof(msg) - 1;
208 msg[sz++] = '\n';
209
210 if (use_sideband)
211 send_sideband(1, 2, msg, sz, use_sideband);
212 else
213 xwrite(2, msg, sz);
214 }
215
216 static void rp_warning(const char *err, ...)
217 {
218 va_list params;
219 va_start(params, err);
220 report_message("warning: ", err, params);
221 va_end(params);
222 }
223
224 static void rp_error(const char *err, ...)
225 {
226 va_list params;
227 va_start(params, err);
228 report_message("error: ", err, params);
229 va_end(params);
230 }
231
232 static int copy_to_sideband(int in, int out, void *arg)
233 {
234 char data[128];
235 while (1) {
236 ssize_t sz = xread(in, data, sizeof(data));
237 if (sz <= 0)
238 break;
239 send_sideband(1, 2, data, sz, use_sideband);
240 }
241 close(in);
242 return 0;
243 }
244
245 typedef int (*feed_fn)(void *, const char **, size_t *);
246 static int run_and_feed_hook(const char *hook_name, feed_fn feed, void *feed_state)
247 {
248 struct child_process proc;
249 struct async muxer;
250 const char *argv[2];
251 int code;
252
253 if (access(hook_name, X_OK) < 0)
254 return 0;
255
256 argv[0] = hook_name;
257 argv[1] = NULL;
258
259 memset(&proc, 0, sizeof(proc));
260 proc.argv = argv;
261 proc.in = -1;
262 proc.stdout_to_stderr = 1;
263
264 if (use_sideband) {
265 memset(&muxer, 0, sizeof(muxer));
266 muxer.proc = copy_to_sideband;
267 muxer.in = -1;
268 code = start_async(&muxer);
269 if (code)
270 return code;
271 proc.err = muxer.in;
272 }
273
274 code = start_command(&proc);
275 if (code) {
276 if (use_sideband)
277 finish_async(&muxer);
278 return code;
279 }
280
281 while (1) {
282 const char *buf;
283 size_t n;
284 if (feed(feed_state, &buf, &n))
285 break;
286 if (write_in_full(proc.in, buf, n) != n)
287 break;
288 }
289 close(proc.in);
290 if (use_sideband)
291 finish_async(&muxer);
292 return finish_command(&proc);
293 }
294
295 struct receive_hook_feed_state {
296 struct command *cmd;
297 int skip_broken;
298 struct strbuf buf;
299 };
300
301 static int feed_receive_hook(void *state_, const char **bufp, size_t *sizep)
302 {
303 struct receive_hook_feed_state *state = state_;
304 struct command *cmd = state->cmd;
305
306 while (cmd &&
307 state->skip_broken && (cmd->error_string || cmd->did_not_exist))
308 cmd = cmd->next;
309 if (!cmd)
310 return -1; /* EOF */
311 strbuf_reset(&state->buf);
312 strbuf_addf(&state->buf, "%s %s %s\n",
313 sha1_to_hex(cmd->old_sha1), sha1_to_hex(cmd->new_sha1),
314 cmd->ref_name);
315 state->cmd = cmd->next;
316 if (bufp) {
317 *bufp = state->buf.buf;
318 *sizep = state->buf.len;
319 }
320 return 0;
321 }
322
323 static int run_receive_hook(struct command *commands, const char *hook_name,
324 int skip_broken)
325 {
326 struct receive_hook_feed_state state;
327 int status;
328
329 strbuf_init(&state.buf, 0);
330 state.cmd = commands;
331 state.skip_broken = skip_broken;
332 if (feed_receive_hook(&state, NULL, NULL))
333 return 0;
334 state.cmd = commands;
335 status = run_and_feed_hook(hook_name, feed_receive_hook, &state);
336 strbuf_release(&state.buf);
337 return status;
338 }
339
340 static int run_update_hook(struct command *cmd)
341 {
342 static const char update_hook[] = "hooks/update";
343 const char *argv[5];
344 struct child_process proc;
345 int code;
346
347 if (access(update_hook, X_OK) < 0)
348 return 0;
349
350 argv[0] = update_hook;
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, 0);
532 if (!lock) {
533 rp_error("failed to lock %s", name);
534 return "failed to lock";
535 }
536 if (write_ref_sha1(lock, new_sha1, "push")) {
537 return "failed to write"; /* error() already called */
538 }
539 return NULL; /* good */
540 }
541 }
542
543 static char update_post_hook[] = "hooks/post-update";
544
545 static void run_update_post_hook(struct command *commands)
546 {
547 struct command *cmd;
548 int argc;
549 const char **argv;
550 struct child_process proc;
551
552 for (argc = 0, cmd = commands; cmd; cmd = cmd->next) {
553 if (cmd->error_string || cmd->did_not_exist)
554 continue;
555 argc++;
556 }
557 if (!argc || access(update_post_hook, X_OK) < 0)
558 return;
559 argv = xmalloc(sizeof(*argv) * (2 + argc));
560 argv[0] = update_post_hook;
561
562 for (argc = 1, cmd = commands; cmd; cmd = cmd->next) {
563 char *p;
564 if (cmd->error_string || cmd->did_not_exist)
565 continue;
566 p = xmalloc(strlen(cmd->ref_name) + 1);
567 strcpy(p, cmd->ref_name);
568 argv[argc] = p;
569 argc++;
570 }
571 argv[argc] = NULL;
572
573 memset(&proc, 0, sizeof(proc));
574 proc.no_stdin = 1;
575 proc.stdout_to_stderr = 1;
576 proc.err = use_sideband ? -1 : 0;
577 proc.argv = argv;
578
579 if (!start_command(&proc)) {
580 if (use_sideband)
581 copy_to_sideband(proc.err, -1, NULL);
582 finish_command(&proc);
583 }
584 }
585
586 static void check_aliased_update(struct command *cmd, struct string_list *list)
587 {
588 struct strbuf buf = STRBUF_INIT;
589 const char *dst_name;
590 struct string_list_item *item;
591 struct command *dst_cmd;
592 unsigned char sha1[20];
593 char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41];
594 int flag;
595
596 strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name);
597 dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag);
598 strbuf_release(&buf);
599
600 if (!(flag & REF_ISSYMREF))
601 return;
602
603 dst_name = strip_namespace(dst_name);
604 if (!dst_name) {
605 rp_error("refusing update to broken symref '%s'", cmd->ref_name);
606 cmd->skip_update = 1;
607 cmd->error_string = "broken symref";
608 return;
609 }
610
611 if ((item = string_list_lookup(list, dst_name)) == NULL)
612 return;
613
614 cmd->skip_update = 1;
615
616 dst_cmd = (struct command *) item->util;
617
618 if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) &&
619 !hashcmp(cmd->new_sha1, dst_cmd->new_sha1))
620 return;
621
622 dst_cmd->skip_update = 1;
623
624 strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV));
625 strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV));
626 strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV));
627 strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV));
628 rp_error("refusing inconsistent update between symref '%s' (%s..%s) and"
629 " its target '%s' (%s..%s)",
630 cmd->ref_name, cmd_oldh, cmd_newh,
631 dst_cmd->ref_name, dst_oldh, dst_newh);
632
633 cmd->error_string = dst_cmd->error_string =
634 "inconsistent aliased update";
635 }
636
637 static void check_aliased_updates(struct command *commands)
638 {
639 struct command *cmd;
640 struct string_list ref_list = STRING_LIST_INIT_NODUP;
641
642 for (cmd = commands; cmd; cmd = cmd->next) {
643 struct string_list_item *item =
644 string_list_append(&ref_list, cmd->ref_name);
645 item->util = (void *)cmd;
646 }
647 sort_string_list(&ref_list);
648
649 for (cmd = commands; cmd; cmd = cmd->next) {
650 if (!cmd->error_string)
651 check_aliased_update(cmd, &ref_list);
652 }
653
654 string_list_clear(&ref_list, 0);
655 }
656
657 static int command_singleton_iterator(void *cb_data, unsigned char sha1[20])
658 {
659 struct command **cmd_list = cb_data;
660 struct command *cmd = *cmd_list;
661
662 if (!cmd || is_null_sha1(cmd->new_sha1))
663 return -1; /* end of list */
664 *cmd_list = NULL; /* this returns only one */
665 hashcpy(sha1, cmd->new_sha1);
666 return 0;
667 }
668
669 static void set_connectivity_errors(struct command *commands)
670 {
671 struct command *cmd;
672
673 for (cmd = commands; cmd; cmd = cmd->next) {
674 struct command *singleton = cmd;
675 if (!check_everything_connected(command_singleton_iterator,
676 0, &singleton))
677 continue;
678 cmd->error_string = "missing necessary objects";
679 }
680 }
681
682 static int iterate_receive_command_list(void *cb_data, unsigned char sha1[20])
683 {
684 struct command **cmd_list = cb_data;
685 struct command *cmd = *cmd_list;
686
687 while (cmd) {
688 if (!is_null_sha1(cmd->new_sha1)) {
689 hashcpy(sha1, cmd->new_sha1);
690 *cmd_list = cmd->next;
691 return 0;
692 }
693 cmd = cmd->next;
694 }
695 *cmd_list = NULL;
696 return -1; /* end of list */
697 }
698
699 static void reject_updates_to_hidden(struct command *commands)
700 {
701 struct command *cmd;
702
703 for (cmd = commands; cmd; cmd = cmd->next) {
704 if (cmd->error_string || !ref_is_hidden(cmd->ref_name))
705 continue;
706 if (is_null_sha1(cmd->new_sha1))
707 cmd->error_string = "deny deleting a hidden ref";
708 else
709 cmd->error_string = "deny updating a hidden ref";
710 }
711 }
712
713 static void execute_commands(struct command *commands, const char *unpacker_error)
714 {
715 struct command *cmd;
716 unsigned char sha1[20];
717
718 if (unpacker_error) {
719 for (cmd = commands; cmd; cmd = cmd->next)
720 cmd->error_string = "unpacker error";
721 return;
722 }
723
724 cmd = commands;
725 if (check_everything_connected(iterate_receive_command_list,
726 0, &cmd))
727 set_connectivity_errors(commands);
728
729 reject_updates_to_hidden(commands);
730
731 if (run_receive_hook(commands, pre_receive_hook, 0)) {
732 for (cmd = commands; cmd; cmd = cmd->next) {
733 if (!cmd->error_string)
734 cmd->error_string = "pre-receive hook declined";
735 }
736 return;
737 }
738
739 check_aliased_updates(commands);
740
741 free(head_name_to_free);
742 head_name = head_name_to_free = resolve_refdup("HEAD", sha1, 0, NULL);
743
744 for (cmd = commands; cmd; cmd = cmd->next) {
745 if (cmd->error_string)
746 continue;
747
748 if (cmd->skip_update)
749 continue;
750
751 cmd->error_string = update(cmd);
752 }
753 }
754
755 static struct command *read_head_info(void)
756 {
757 struct command *commands = NULL;
758 struct command **p = &commands;
759 for (;;) {
760 static char line[1000];
761 unsigned char old_sha1[20], new_sha1[20];
762 struct command *cmd;
763 char *refname;
764 int len, reflen;
765
766 len = packet_read_line(0, line, sizeof(line));
767 if (!len)
768 break;
769 if (line[len-1] == '\n')
770 line[--len] = 0;
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 return hdr_err;
836 snprintf(hdr_arg, sizeof(hdr_arg),
837 "--pack_header=%"PRIu32",%"PRIu32,
838 ntohl(hdr.hdr_version), ntohl(hdr.hdr_entries));
839
840 if (ntohl(hdr.hdr_entries) < unpack_limit) {
841 int code, i = 0;
842 struct child_process child;
843 const char *unpacker[5];
844 unpacker[i++] = "unpack-objects";
845 if (quiet)
846 unpacker[i++] = "-q";
847 if (fsck_objects)
848 unpacker[i++] = "--strict";
849 unpacker[i++] = hdr_arg;
850 unpacker[i++] = NULL;
851 memset(&child, 0, sizeof(child));
852 child.argv = unpacker;
853 child.no_stdout = 1;
854 child.err = err_fd;
855 child.git_cmd = 1;
856 code = run_command(&child);
857 if (!code)
858 return NULL;
859 return "unpack-objects abnormal exit";
860 } else {
861 const char *keeper[7];
862 int s, status, i = 0;
863 char keep_arg[256];
864 struct child_process ip;
865
866 s = sprintf(keep_arg, "--keep=receive-pack %"PRIuMAX" on ", (uintmax_t) getpid());
867 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
868 strcpy(keep_arg + s, "localhost");
869
870 keeper[i++] = "index-pack";
871 keeper[i++] = "--stdin";
872 if (fsck_objects)
873 keeper[i++] = "--strict";
874 keeper[i++] = "--fix-thin";
875 keeper[i++] = hdr_arg;
876 keeper[i++] = keep_arg;
877 keeper[i++] = NULL;
878 memset(&ip, 0, sizeof(ip));
879 ip.argv = keeper;
880 ip.out = -1;
881 ip.err = err_fd;
882 ip.git_cmd = 1;
883 status = start_command(&ip);
884 if (status) {
885 return "index-pack fork failed";
886 }
887 pack_lockfile = index_pack_lockfile(ip.out);
888 close(ip.out);
889 status = finish_command(&ip);
890 if (!status) {
891 reprepare_packed_git();
892 return NULL;
893 }
894 return "index-pack abnormal exit";
895 }
896 }
897
898 static const char *unpack_with_sideband(void)
899 {
900 struct async muxer;
901 const char *ret;
902
903 if (!use_sideband)
904 return unpack(0);
905
906 memset(&muxer, 0, sizeof(muxer));
907 muxer.proc = copy_to_sideband;
908 muxer.in = -1;
909 if (start_async(&muxer))
910 return NULL;
911
912 ret = unpack(muxer.in);
913
914 finish_async(&muxer);
915 return ret;
916 }
917
918 static void report(struct command *commands, const char *unpack_status)
919 {
920 struct command *cmd;
921 struct strbuf buf = STRBUF_INIT;
922
923 packet_buf_write(&buf, "unpack %s\n",
924 unpack_status ? unpack_status : "ok");
925 for (cmd = commands; cmd; cmd = cmd->next) {
926 if (!cmd->error_string)
927 packet_buf_write(&buf, "ok %s\n",
928 cmd->ref_name);
929 else
930 packet_buf_write(&buf, "ng %s %s\n",
931 cmd->ref_name, cmd->error_string);
932 }
933 packet_buf_flush(&buf);
934
935 if (use_sideband)
936 send_sideband(1, 1, buf.buf, buf.len, use_sideband);
937 else
938 safe_write(1, buf.buf, buf.len);
939 strbuf_release(&buf);
940 }
941
942 static int delete_only(struct command *commands)
943 {
944 struct command *cmd;
945 for (cmd = commands; cmd; cmd = cmd->next) {
946 if (!is_null_sha1(cmd->new_sha1))
947 return 0;
948 }
949 return 1;
950 }
951
952 int cmd_receive_pack(int argc, const char **argv, const char *prefix)
953 {
954 int advertise_refs = 0;
955 int stateless_rpc = 0;
956 int i;
957 char *dir = NULL;
958 struct command *commands;
959
960 packet_trace_identity("receive-pack");
961
962 argv++;
963 for (i = 1; i < argc; i++) {
964 const char *arg = *argv++;
965
966 if (*arg == '-') {
967 if (!strcmp(arg, "--quiet")) {
968 quiet = 1;
969 continue;
970 }
971
972 if (!strcmp(arg, "--advertise-refs")) {
973 advertise_refs = 1;
974 continue;
975 }
976 if (!strcmp(arg, "--stateless-rpc")) {
977 stateless_rpc = 1;
978 continue;
979 }
980
981 usage(receive_pack_usage);
982 }
983 if (dir)
984 usage(receive_pack_usage);
985 dir = xstrdup(arg);
986 }
987 if (!dir)
988 usage(receive_pack_usage);
989
990 setup_path();
991
992 if (!enter_repo(dir, 0))
993 die("'%s' does not appear to be a git repository", dir);
994
995 if (is_repository_shallow())
996 die("attempt to push into a shallow repository");
997
998 git_config(receive_pack_config, NULL);
999
1000 if (0 <= transfer_unpack_limit)
1001 unpack_limit = transfer_unpack_limit;
1002 else if (0 <= receive_unpack_limit)
1003 unpack_limit = receive_unpack_limit;
1004
1005 if (advertise_refs || !stateless_rpc) {
1006 write_head_info();
1007 }
1008 if (advertise_refs)
1009 return 0;
1010
1011 if ((commands = read_head_info()) != NULL) {
1012 const char *unpack_status = NULL;
1013
1014 if (!delete_only(commands))
1015 unpack_status = unpack_with_sideband();
1016 execute_commands(commands, unpack_status);
1017 if (pack_lockfile)
1018 unlink_or_warn(pack_lockfile);
1019 if (report_status)
1020 report(commands, unpack_status);
1021 run_receive_hook(commands, post_receive_hook, 1);
1022 run_update_post_hook(commands);
1023 if (auto_gc) {
1024 const char *argv_gc_auto[] = {
1025 "gc", "--auto", "--quiet", NULL,
1026 };
1027 int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
1028 run_command_v_opt(argv_gc_auto, opt);
1029 }
1030 if (auto_update_server_info)
1031 update_server_info(0);
1032 }
1033 if (use_sideband)
1034 packet_flush(1);
1035 return 0;
1036 }