1 /*
2  * Copyright (c) 2020 Stefan Sperling <stsp@openbsd.org>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 #include "got_compat.h"
18 
19 #include <sys/types.h>
20 #include <sys/queue.h>
21 #include <sys/uio.h>
22 #include <sys/time.h>
23 
24 #include <stdint.h>
25 #include <limits.h>
26 #include <signal.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <unistd.h>
31 #include <zlib.h>
32 
33 #include "got_error.h"
34 #include "got_object.h"
35 #include "got_path.h"
36 #include "got_repository.h"
37 
38 #include "got_lib_delta.h"
39 #include "got_lib_object.h"
40 #include "got_lib_privsep.h"
41 
42 #include "gotconfig.h"
43 
44 /* parse.y */
45 static volatile sig_atomic_t sigint_received;
46 
47 static void
48 catch_sigint(int signo)
49 {
50 	sigint_received = 1;
51 }
52 
53 static const struct got_error *
54 make_fetch_url(char **url, struct gotconfig_remote_repo *repo)
55 {
56 	const struct got_error *err = NULL;
57 	char *s = NULL, *p = NULL;
58 	const char *protocol, *server, *repo_path;
59 	int port;
60 
61 	*url = NULL;
62 
63 	if (repo->fetch_config && repo->fetch_config->protocol)
64 		protocol = repo->fetch_config->protocol;
65 	else
66 		protocol = repo->protocol;
67 	if (protocol == NULL)
68 		return got_error_fmt(GOT_ERR_PARSE_CONFIG,
69 		    "fetch protocol required for remote repository \"%s\"",
70 		    repo->name);
71 	if (asprintf(&s, "%s://", protocol) == -1)
72 		return got_error_from_errno("asprintf");
73 
74 	if (repo->fetch_config && repo->fetch_config->server)
75 		server = repo->fetch_config->server;
76 	else
77 		server = repo->server;
78 	if (server == NULL)
79 		return got_error_fmt(GOT_ERR_PARSE_CONFIG,
80 		    "fetch server required for remote repository \"%s\"",
81 		    repo->name);
82 	p = s;
83 	s = NULL;
84 	if (asprintf(&s, "%s%s", p, server) == -1) {
85 		err = got_error_from_errno("asprintf");
86 		goto done;
87 	}
88 	free(p);
89 	p = NULL;
90 
91 	if (repo->fetch_config && repo->fetch_config->server)
92 		port = repo->fetch_config->port;
93 	else
94 		port = repo->port;
95 	if (port) {
96 		p = s;
97 		s = NULL;
98 		if (asprintf(&s, "%s:%d", p, repo->port) == -1) {
99 			err = got_error_from_errno("asprintf");
100 			goto done;
101 		}
102 		free(p);
103 		p = NULL;
104 	}
105 
106 	if (repo->fetch_config && repo->fetch_config->repository)
107 		repo_path = repo->fetch_config->repository;
108 	else
109 		repo_path = repo->repository;
110 	if (repo_path == NULL)
111 		return got_error_fmt(GOT_ERR_PARSE_CONFIG,
112 		    "fetch repository path required for remote "
113 		    "repository \"%s\"", repo->name);
114 
115 	while (repo_path[0] == '/')
116 		repo_path++;
117 	p = s;
118 	s = NULL;
119 	if (asprintf(&s, "%s/%s", p, repo_path) == -1) {
120 		err = got_error_from_errno("asprintf");
121 		goto done;
122 	}
123 	free(p);
124 	p = NULL;
125 
126 	got_path_strip_trailing_slashes(s);
127 done:
128 	if (err) {
129 		free(s);
130 		free(p);
131 	} else
132 		*url = s;
133 	return err;
134 }
135 
136 static const struct got_error *
137 make_send_url(char **url, struct gotconfig_remote_repo *repo)
138 {
139 	const struct got_error *err = NULL;
140 	char *s = NULL, *p = NULL;
141 	const char *protocol, *server, *repo_path;
142 	int port;
143 
144 	*url = NULL;
145 
146 	if (repo->send_config && repo->send_config->protocol)
147 		protocol = repo->send_config->protocol;
148 	else
149 		protocol = repo->protocol;
150 	if (protocol == NULL)
151 		return got_error_fmt(GOT_ERR_PARSE_CONFIG,
152 		    "send protocol required for remote repository \"%s\"",
153 		    repo->name);
154 	if (asprintf(&s, "%s://", protocol) == -1)
155 		return got_error_from_errno("asprintf");
156 
157 	if (repo->send_config && repo->send_config->server)
158 		server = repo->send_config->server;
159 	else
160 		server = repo->server;
161 	if (server == NULL)
162 		return got_error_fmt(GOT_ERR_PARSE_CONFIG,
163 		    "send server required for remote repository \"%s\"",
164 		    repo->name);
165 	p = s;
166 	s = NULL;
167 	if (asprintf(&s, "%s%s", p, server) == -1) {
168 		err = got_error_from_errno("asprintf");
169 		goto done;
170 	}
171 	free(p);
172 	p = NULL;
173 
174 	if (repo->send_config && repo->send_config->server)
175 		port = repo->send_config->port;
176 	else
177 		port = repo->port;
178 	if (port) {
179 		p = s;
180 		s = NULL;
181 		if (asprintf(&s, "%s:%d", p, repo->port) == -1) {
182 			err = got_error_from_errno("asprintf");
183 			goto done;
184 		}
185 		free(p);
186 		p = NULL;
187 	}
188 
189 	if (repo->send_config && repo->send_config->repository)
190 		repo_path = repo->send_config->repository;
191 	else
192 		repo_path = repo->repository;
193 	if (repo_path == NULL)
194 		return got_error_fmt(GOT_ERR_PARSE_CONFIG,
195 		    "send repository path required for remote "
196 		    "repository \"%s\"", repo->name);
197 
198 	while (repo_path[0] == '/')
199 		repo_path++;
200 	p = s;
201 	s = NULL;
202 	if (asprintf(&s, "%s/%s", p, repo_path) == -1) {
203 		err = got_error_from_errno("asprintf");
204 		goto done;
205 	}
206 	free(p);
207 	p = NULL;
208 
209 	got_path_strip_trailing_slashes(s);
210 done:
211 	if (err) {
212 		free(s);
213 		free(p);
214 	} else
215 		*url = s;
216 	return err;
217 }
218 
219 static const struct got_error *
220 send_gotconfig_str(struct imsgbuf *ibuf, const char *value)
221 {
222 	size_t len = value ? strlen(value) : 0;
223 
224 	if (imsg_compose(ibuf, GOT_IMSG_GOTCONFIG_STR_VAL, 0, 0, -1,
225 	    value, len) == -1)
226 		return got_error_from_errno("imsg_compose GOTCONFIG_STR_VAL");
227 
228 	return got_privsep_flush_imsg(ibuf);
229 }
230 
231 static const struct got_error *
232 send_gotconfig_remotes(struct imsgbuf *ibuf,
233     struct gotconfig_remote_repo_list *remotes, int nremotes)
234 {
235 	const struct got_error *err = NULL;
236 	struct got_imsg_remotes iremotes;
237 	struct gotconfig_remote_repo *repo;
238 	char *fetch_url = NULL, *send_url = NULL;
239 
240 	iremotes.nremotes = nremotes;
241 	if (imsg_compose(ibuf, GOT_IMSG_GOTCONFIG_REMOTES, 0, 0, -1,
242 	    &iremotes, sizeof(iremotes)) == -1)
243 		return got_error_from_errno("imsg_compose GOTCONFIG_REMOTES");
244 
245 	err = got_privsep_flush_imsg(ibuf);
246 	imsg_clear(ibuf);
247 	if (err)
248 		return err;
249 
250 	TAILQ_FOREACH(repo, remotes, entry) {
251 		struct got_imsg_remote iremote;
252 		size_t len = sizeof(iremote);
253 		struct ibuf *wbuf;
254 		struct node_branch *branch;
255 		struct node_ref *ref;
256 		int nfetch_branches = 0, nsend_branches = 0, nfetch_refs = 0;
257 
258 		if (repo->fetch_config && repo->fetch_config->branch)
259 			branch = repo->fetch_config->branch;
260 		else
261 			branch = repo->branch;
262 		while (branch) {
263 			branch = branch->next;
264 			nfetch_branches++;
265 		}
266 
267 		if (repo->send_config && repo->send_config->branch)
268 			branch = repo->send_config->branch;
269 		else
270 			branch = repo->branch;
271 		while (branch) {
272 			branch = branch->next;
273 			nsend_branches++;
274 		}
275 
276 		ref = repo->fetch_ref;
277 		while (ref) {
278 			ref = ref->next;
279 			nfetch_refs++;
280 		}
281 
282 		iremote.nfetch_branches = nfetch_branches;
283 		iremote.nsend_branches = nsend_branches;
284 		iremote.nfetch_refs = nfetch_refs;
285 		iremote.mirror_references = repo->mirror_references;
286 		iremote.fetch_all_branches = repo->fetch_all_branches;
287 
288 		iremote.name_len = strlen(repo->name);
289 		len += iremote.name_len;
290 
291 		err = make_fetch_url(&fetch_url, repo);
292 		if (err)
293 			break;
294 		iremote.fetch_url_len = strlen(fetch_url);
295 		len += iremote.fetch_url_len;
296 
297 		err = make_send_url(&send_url, repo);
298 		if (err)
299 			break;
300 		iremote.send_url_len = strlen(send_url);
301 		len += iremote.send_url_len;
302 
303 		wbuf = imsg_create(ibuf, GOT_IMSG_GOTCONFIG_REMOTE, 0, 0, len);
304 		if (wbuf == NULL) {
305 			err = got_error_from_errno(
306 			    "imsg_create GOTCONFIG_REMOTE");
307 			break;
308 		}
309 
310 		if (imsg_add(wbuf, &iremote, sizeof(iremote)) == -1) {
311 			err = got_error_from_errno(
312 			    "imsg_add GOTCONFIG_REMOTE");
313 			break;
314 		}
315 
316 		if (imsg_add(wbuf, repo->name, iremote.name_len) == -1) {
317 			err = got_error_from_errno(
318 			    "imsg_add GOTCONFIG_REMOTE");
319 			break;
320 		}
321 		if (imsg_add(wbuf, fetch_url, iremote.fetch_url_len) == -1) {
322 			err = got_error_from_errno(
323 			    "imsg_add GOTCONFIG_REMOTE");
324 			break;
325 		}
326 		if (imsg_add(wbuf, send_url, iremote.send_url_len) == -1) {
327 			err = got_error_from_errno(
328 			    "imsg_add GOTCONFIG_REMOTE");
329 			break;
330 		}
331 
332 		imsg_close(ibuf, wbuf);
333 		err = got_privsep_flush_imsg(ibuf);
334 		if (err)
335 			break;
336 
337 		free(fetch_url);
338 		fetch_url = NULL;
339 		free(send_url);
340 		send_url = NULL;
341 
342 		if (repo->fetch_config && repo->fetch_config->branch)
343 			branch = repo->fetch_config->branch;
344 		else
345 			branch = repo->branch;
346 		while (branch) {
347 			err = send_gotconfig_str(ibuf, branch->branch_name);
348 			if (err)
349 				break;
350 			branch = branch->next;
351 		}
352 
353 		if (repo->send_config && repo->send_config->branch)
354 			branch = repo->send_config->branch;
355 		else
356 			branch = repo->branch;
357 		while (branch) {
358 			err = send_gotconfig_str(ibuf, branch->branch_name);
359 			if (err)
360 				break;
361 			branch = branch->next;
362 		}
363 
364 		ref = repo->fetch_ref;
365 		while (ref) {
366 			err = send_gotconfig_str(ibuf, ref->ref_name);
367 			if (err)
368 				break;
369 			ref = ref->next;
370 		}
371 	}
372 
373 	free(fetch_url);
374 	free(send_url);
375 	return err;
376 }
377 
378 static const struct got_error *
379 validate_protocol(const char *protocol, const char *repo_name)
380 {
381 	static char msg[512];
382 
383 	if (strcmp(protocol, "ssh") != 0 &&
384 	    strcmp(protocol, "git+ssh") != 0 &&
385 	    strcmp(protocol, "git") != 0) {
386 		snprintf(msg, sizeof(msg),"unknown protocol \"%s\" "
387 		    "for remote repository \"%s\"", protocol, repo_name);
388 		return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
389 	}
390 
391 	return NULL;
392 }
393 
394 static const struct got_error *
395 validate_config(struct gotconfig *gotconfig)
396 {
397 	const struct got_error *err;
398 	struct gotconfig_remote_repo *repo, *repo2;
399 	static char msg[512];
400 
401 	TAILQ_FOREACH(repo, &gotconfig->remotes, entry) {
402 		if (repo->name == NULL) {
403 			return got_error_msg(GOT_ERR_PARSE_CONFIG,
404 			    "name required for remote repository");
405 		}
406 
407 		TAILQ_FOREACH(repo2, &gotconfig->remotes, entry) {
408 			if (repo == repo2 ||
409 			    strcmp(repo->name, repo2->name) != 0)
410 				continue;
411 			snprintf(msg, sizeof(msg),
412 			    "duplicate remote repository name '%s'",
413 			    repo->name);
414 			return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
415 		}
416 
417 		if (repo->server == NULL &&
418 		    (repo->fetch_config == NULL ||
419 		    repo->fetch_config->server == NULL) &&
420 		    (repo->send_config == NULL ||
421 		    repo->send_config->server == NULL)) {
422 			snprintf(msg, sizeof(msg),
423 			    "server required for remote repository \"%s\"",
424 			    repo->name);
425 			return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
426 		}
427 
428 		if (repo->protocol == NULL &&
429 		    (repo->fetch_config == NULL ||
430 		    repo->fetch_config->protocol == NULL) &&
431 		    (repo->send_config == NULL ||
432 		    repo->send_config->protocol == NULL)) {
433 			snprintf(msg, sizeof(msg),
434 			    "protocol required for remote repository \"%s\"",
435 			    repo->name);
436 			return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
437 		}
438 
439 		if (repo->protocol) {
440 			err = validate_protocol(repo->protocol, repo->name);
441 			if (err)
442 				return err;
443 		}
444 		if (repo->fetch_config && repo->fetch_config->protocol) {
445 			err = validate_protocol(repo->fetch_config->protocol,
446 			    repo->name);
447 			if (err)
448 				return err;
449 		}
450 		if (repo->send_config && repo->send_config->protocol) {
451 			err = validate_protocol(repo->send_config->protocol,
452 			    repo->name);
453 			if (err)
454 				return err;
455 		}
456 
457 		if (repo->repository == NULL &&
458 		    (repo->fetch_config == NULL ||
459 		    repo->fetch_config->repository == NULL) &&
460 		    (repo->send_config == NULL ||
461 		    repo->send_config->repository == NULL)) {
462 			snprintf(msg, sizeof(msg),
463 			    "repository path required for remote "
464 			    "repository \"%s\"", repo->name);
465 			return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
466 		}
467 	}
468 
469 	return NULL;
470 }
471 
472 int
473 main(int argc, char *argv[])
474 {
475 	const struct got_error *err = NULL;
476 	struct imsgbuf ibuf;
477 	struct gotconfig *gotconfig = NULL;
478 	size_t datalen;
479 	const char *filename = "got.conf";
480 #if 0
481 	static int attached;
482 
483 	while (!attached)
484 		sleep(1);
485 #endif
486 	signal(SIGINT, catch_sigint);
487 
488 	imsg_init(&ibuf, GOT_IMSG_FD_CHILD);
489 
490 #ifndef PROFILE
491 	/* revoke access to most system calls */
492 	if (pledge("stdio recvfd", NULL) == -1) {
493 		err = got_error_from_errno("pledge");
494 		got_privsep_send_error(&ibuf, err);
495 		return 1;
496 	}
497 
498 	/* revoke fs access */
499 	if (landlock_no_fs() == -1) {
500 		err = got_error_from_errno("landlock_no_fs");
501 		got_privsep_send_error(&ibuf, err);
502 		return 1;
503 	}
504 	if (cap_enter() == -1) {
505 		err = got_error_from_errno("cap_enter");
506 		got_privsep_send_error(&ibuf, err);
507 		return 1;
508 	}
509 #endif
510 
511 	if (argc > 1)
512 		filename = argv[1];
513 
514 	for (;;) {
515 		struct imsg imsg;
516 		int fd = -1;
517 
518 		memset(&imsg, 0, sizeof(imsg));
519 
520 		if (sigint_received) {
521 			err = got_error(GOT_ERR_CANCELLED);
522 			break;
523 		}
524 
525 		err = got_privsep_recv_imsg(&imsg, &ibuf, 0);
526 		if (err) {
527 			if (err->code == GOT_ERR_PRIVSEP_PIPE)
528 				err = NULL;
529 			break;
530 		}
531 
532 		if (imsg.hdr.type == GOT_IMSG_STOP)
533 			break;
534 
535 		switch (imsg.hdr.type) {
536 		case GOT_IMSG_GOTCONFIG_PARSE_REQUEST:
537 			datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
538 			if (datalen != 0) {
539 				err = got_error(GOT_ERR_PRIVSEP_LEN);
540 				break;
541 			}
542 			fd = imsg_get_fd(&imsg);
543 			if (fd == -1){
544 				err = got_error(GOT_ERR_PRIVSEP_NO_FD);
545 				break;
546 			}
547 
548 			if (gotconfig)
549 				gotconfig_free(gotconfig);
550 			err = gotconfig_parse(&gotconfig, filename, &fd);
551 			if (err)
552 				break;
553 			err = validate_config(gotconfig);
554 			break;
555 		case GOT_IMSG_GOTCONFIG_AUTHOR_REQUEST:
556 			if (gotconfig == NULL) {
557 				err = got_error(GOT_ERR_PRIVSEP_MSG);
558 				break;
559 			}
560 			err = send_gotconfig_str(&ibuf,
561 			    gotconfig->author ?  gotconfig->author : "");
562 			break;
563 		case GOT_IMSG_GOTCONFIG_ALLOWEDSIGNERS_REQUEST:
564 			if (gotconfig == NULL) {
565 				err = got_error(GOT_ERR_PRIVSEP_MSG);
566 				break;
567 			}
568 			err = send_gotconfig_str(&ibuf,
569 			    gotconfig->allowed_signers_file ?
570 			        gotconfig->allowed_signers_file : "");
571 			break;
572 		case GOT_IMSG_GOTCONFIG_REVOKEDSIGNERS_REQUEST:
573 			if (gotconfig == NULL) {
574 				err = got_error(GOT_ERR_PRIVSEP_MSG);
575 				break;
576 			}
577 			err = send_gotconfig_str(&ibuf,
578 			    gotconfig->revoked_signers_file ?
579 			        gotconfig->revoked_signers_file : "");
580 			break;
581 		case GOT_IMSG_GOTCONFIG_SIGNERID_REQUEST:
582 			if (gotconfig == NULL) {
583 				err = got_error(GOT_ERR_PRIVSEP_MSG);
584 				break;
585 			}
586 			err = send_gotconfig_str(&ibuf,
587 			    gotconfig->signer_id ? gotconfig->signer_id : "");
588 			break;
589 		case GOT_IMSG_GOTCONFIG_REMOTES_REQUEST:
590 			if (gotconfig == NULL) {
591 				err = got_error(GOT_ERR_PRIVSEP_MSG);
592 				break;
593 			}
594 			err = send_gotconfig_remotes(&ibuf,
595 			    &gotconfig->remotes, gotconfig->nremotes);
596 			break;
597 		default:
598 			err = got_error(GOT_ERR_PRIVSEP_MSG);
599 			break;
600 		}
601 
602 		if (fd != -1) {
603 			if (close(fd) == -1 && err == NULL)
604 				err = got_error_from_errno("close");
605 		}
606 
607 		imsg_free(&imsg);
608 		if (err)
609 			break;
610 	}
611 
612 	imsg_clear(&ibuf);
613 	if (err) {
614 		if (!sigint_received && err->code != GOT_ERR_PRIVSEP_PIPE) {
615 			fprintf(stderr, "%s: %s\n", getprogname(), err->msg);
616 			got_privsep_send_error(&ibuf, err);
617 		}
618 	}
619 	if (close(GOT_IMSG_FD_CHILD) == -1 && err == NULL)
620 		err = got_error_from_errno("close");
621 	return err ? 1 : 0;
622 }