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