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 <sys/types.h>
18 #include <sys/queue.h>
19 #include <sys/uio.h>
20 #include <sys/time.h>
21 
22 #include <stdint.h>
23 #include <imsg.h>
24 #include <limits.h>
25 #include <signal.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <sha1.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 			while (branch) {
261 				branch = branch->next;
262 				nfetch_branches++;
263 			}
264 		} else {
265 			branch = repo->branch;
266 			while (branch) {
267 				branch = branch->next;
268 				nfetch_branches++;
269 			}
270 		}
271 
272 		if (repo->send_config && repo->send_config->branch) {
273 			branch = repo->send_config->branch;
274 			while (branch) {
275 				branch = branch->next;
276 				nsend_branches++;
277 			}
278 		} else {
279 			branch = repo->branch;
280 			while (branch) {
281 				branch = branch->next;
282 				nsend_branches++;
283 			}
284 		}
285 
286 		ref = repo->fetch_ref;
287 		while (ref) {
288 			ref = ref->next;
289 			nfetch_refs++;
290 		}
291 
292 		iremote.nfetch_branches = nfetch_branches;
293 		iremote.nsend_branches = nsend_branches;
294 		iremote.nfetch_refs = nfetch_refs;
295 		iremote.mirror_references = repo->mirror_references;
296 		iremote.fetch_all_branches = repo->fetch_all_branches;
297 
298 		iremote.name_len = strlen(repo->name);
299 		len += iremote.name_len;
300 
301 		err = make_fetch_url(&fetch_url, repo);
302 		if (err)
303 			break;
304 		iremote.fetch_url_len = strlen(fetch_url);
305 		len += iremote.fetch_url_len;
306 
307 		err = make_send_url(&send_url, repo);
308 		if (err)
309 			break;
310 		iremote.send_url_len = strlen(send_url);
311 		len += iremote.send_url_len;
312 
313 		wbuf = imsg_create(ibuf, GOT_IMSG_GOTCONFIG_REMOTE, 0, 0, len);
314 		if (wbuf == NULL) {
315 			err = got_error_from_errno(
316 			    "imsg_create GOTCONFIG_REMOTE");
317 			break;
318 		}
319 
320 		if (imsg_add(wbuf, &iremote, sizeof(iremote)) == -1) {
321 			err = got_error_from_errno(
322 			    "imsg_add GOTCONFIG_REMOTE");
323 			ibuf_free(wbuf);
324 			break;
325 		}
326 
327 		if (imsg_add(wbuf, repo->name, iremote.name_len) == -1) {
328 			err = got_error_from_errno(
329 			    "imsg_add GOTCONFIG_REMOTE");
330 			ibuf_free(wbuf);
331 			break;
332 		}
333 		if (imsg_add(wbuf, fetch_url, iremote.fetch_url_len) == -1) {
334 			err = got_error_from_errno(
335 			    "imsg_add GOTCONFIG_REMOTE");
336 			ibuf_free(wbuf);
337 			break;
338 		}
339 		if (imsg_add(wbuf, send_url, iremote.send_url_len) == -1) {
340 			err = got_error_from_errno(
341 			    "imsg_add GOTCONFIG_REMOTE");
342 			ibuf_free(wbuf);
343 			break;
344 		}
345 
346 		wbuf->fd = -1;
347 		imsg_close(ibuf, wbuf);
348 		err = got_privsep_flush_imsg(ibuf);
349 		if (err)
350 			break;
351 
352 		free(fetch_url);
353 		fetch_url = NULL;
354 		free(send_url);
355 		send_url = NULL;
356 
357 		if (repo->fetch_config && repo->fetch_config->branch) {
358 			branch = repo->fetch_config->branch;
359 			while (branch) {
360 				err = send_gotconfig_str(ibuf,
361 				    branch->branch_name);
362 				if (err)
363 					break;
364 				branch = branch->next;
365 			}
366 		} else {
367 			branch = repo->branch;
368 			while (branch) {
369 				err = send_gotconfig_str(ibuf,
370 				    branch->branch_name);
371 				if (err)
372 					break;
373 				branch = branch->next;
374 			}
375 		}
376 
377 		if (repo->send_config && repo->send_config->branch) {
378 			branch = repo->send_config->branch;
379 			while (branch) {
380 				err = send_gotconfig_str(ibuf,
381 				    branch->branch_name);
382 				if (err)
383 					break;
384 				branch = branch->next;
385 			}
386 		} else {
387 			branch = repo->branch;
388 			while (branch) {
389 				err = send_gotconfig_str(ibuf,
390 				    branch->branch_name);
391 				if (err)
392 					break;
393 				branch = branch->next;
394 			}
395 		}
396 
397 		ref = repo->fetch_ref;
398 		while (ref) {
399 			err = send_gotconfig_str(ibuf, ref->ref_name);
400 			if (err)
401 				break;
402 			ref = ref->next;
403 		}
404 	}
405 
406 	free(fetch_url);
407 	free(send_url);
408 	return err;
409 }
410 
411 static const struct got_error *
412 validate_protocol(const char *protocol, const char *repo_name)
413 {
414 	static char msg[512];
415 
416 	if (strcmp(protocol, "ssh") != 0 &&
417 	    strcmp(protocol, "git+ssh") != 0 &&
418 	    strcmp(protocol, "git") != 0) {
419 		snprintf(msg, sizeof(msg),"unknown protocol \"%s\" "
420 		    "for remote repository \"%s\"", protocol, repo_name);
421 		return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
422 	}
423 
424 	return NULL;
425 }
426 
427 static const struct got_error *
428 validate_config(struct gotconfig *gotconfig)
429 {
430 	const struct got_error *err;
431 	struct gotconfig_remote_repo *repo, *repo2;
432 	static char msg[512];
433 
434 	TAILQ_FOREACH(repo, &gotconfig->remotes, entry) {
435 		if (repo->name == NULL) {
436 			return got_error_msg(GOT_ERR_PARSE_CONFIG,
437 			    "name required for remote repository");
438 		}
439 
440 		TAILQ_FOREACH(repo2, &gotconfig->remotes, entry) {
441 			if (repo == repo2 ||
442 			    strcmp(repo->name, repo2->name) != 0)
443 				continue;
444 			snprintf(msg, sizeof(msg),
445 			    "duplicate remote repository name '%s'",
446 			    repo->name);
447 			return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
448 		}
449 
450 		if (repo->server == NULL &&
451 		    (repo->fetch_config == NULL ||
452 		    repo->fetch_config->server == NULL) &&
453 		    (repo->send_config == NULL ||
454 		    repo->send_config->server == NULL)) {
455 			snprintf(msg, sizeof(msg),
456 			    "server required for remote repository \"%s\"",
457 			    repo->name);
458 			return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
459 		}
460 
461 		if (repo->protocol == NULL &&
462 		    (repo->fetch_config == NULL ||
463 		    repo->fetch_config->protocol == NULL) &&
464 		    (repo->send_config == NULL ||
465 		    repo->send_config->protocol == NULL)) {
466 			snprintf(msg, sizeof(msg),
467 			    "protocol required for remote repository \"%s\"",
468 			    repo->name);
469 			return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
470 		}
471 
472 		if (repo->protocol) {
473 			err = validate_protocol(repo->protocol, repo->name);
474 			if (err)
475 				return err;
476 		}
477 		if (repo->fetch_config && repo->fetch_config->protocol) {
478 			err = validate_protocol(repo->fetch_config->protocol,
479 			    repo->name);
480 			if (err)
481 				return err;
482 		}
483 		if (repo->send_config && repo->send_config->protocol) {
484 			err = validate_protocol(repo->send_config->protocol,
485 			    repo->name);
486 			if (err)
487 				return err;
488 		}
489 
490 		if (repo->repository == NULL &&
491 		    (repo->fetch_config == NULL ||
492 		    repo->fetch_config->repository == NULL) &&
493 		    (repo->send_config == NULL ||
494 		    repo->send_config->repository == NULL)) {
495 			snprintf(msg, sizeof(msg),
496 			    "repository path required for remote "
497 			    "repository \"%s\"", repo->name);
498 			return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
499 		}
500 	}
501 
502 	return NULL;
503 }
504 
505 int
506 main(int argc, char *argv[])
507 {
508 	const struct got_error *err = NULL;
509 	struct imsgbuf ibuf;
510 	struct gotconfig *gotconfig = NULL;
511 	size_t datalen;
512 	const char *filename = "got.conf";
513 #if 0
514 	static int attached;
515 
516 	while (!attached)
517 		sleep(1);
518 #endif
519 	signal(SIGINT, catch_sigint);
520 
521 	imsg_init(&ibuf, GOT_IMSG_FD_CHILD);
522 
523 #ifndef PROFILE
524 	/* revoke access to most system calls */
525 	if (pledge("stdio recvfd", NULL) == -1) {
526 		err = got_error_from_errno("pledge");
527 		got_privsep_send_error(&ibuf, err);
528 		return 1;
529 	}
530 #endif
531 
532 	if (argc > 1)
533 		filename = argv[1];
534 
535 	for (;;) {
536 		struct imsg imsg;
537 
538 		memset(&imsg, 0, sizeof(imsg));
539 		imsg.fd = -1;
540 
541 		if (sigint_received) {
542 			err = got_error(GOT_ERR_CANCELLED);
543 			break;
544 		}
545 
546 		err = got_privsep_recv_imsg(&imsg, &ibuf, 0);
547 		if (err) {
548 			if (err->code == GOT_ERR_PRIVSEP_PIPE)
549 				err = NULL;
550 			break;
551 		}
552 
553 		if (imsg.hdr.type == GOT_IMSG_STOP)
554 			break;
555 
556 		switch (imsg.hdr.type) {
557 		case GOT_IMSG_GOTCONFIG_PARSE_REQUEST:
558 			datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
559 			if (datalen != 0) {
560 				err = got_error(GOT_ERR_PRIVSEP_LEN);
561 				break;
562 			}
563 			if (imsg.fd == -1){
564 				err = got_error(GOT_ERR_PRIVSEP_NO_FD);
565 				break;
566 			}
567 
568 			if (gotconfig)
569 				gotconfig_free(gotconfig);
570 			err = gotconfig_parse(&gotconfig, filename, &imsg.fd);
571 			if (err)
572 				break;
573 			err = validate_config(gotconfig);
574 			break;
575 		case GOT_IMSG_GOTCONFIG_AUTHOR_REQUEST:
576 			if (gotconfig == NULL) {
577 				err = got_error(GOT_ERR_PRIVSEP_MSG);
578 				break;
579 			}
580 			err = send_gotconfig_str(&ibuf,
581 			    gotconfig->author ?  gotconfig->author : "");
582 			break;
583 		case GOT_IMSG_GOTCONFIG_REMOTES_REQUEST:
584 			if (gotconfig == NULL) {
585 				err = got_error(GOT_ERR_PRIVSEP_MSG);
586 				break;
587 			}
588 			err = send_gotconfig_remotes(&ibuf,
589 			    &gotconfig->remotes, gotconfig->nremotes);
590 			break;
591 		default:
592 			err = got_error(GOT_ERR_PRIVSEP_MSG);
593 			break;
594 		}
595 
596 		if (imsg.fd != -1) {
597 			if (close(imsg.fd) == -1 && err == NULL)
598 				err = got_error_from_errno("close");
599 		}
600 
601 		imsg_free(&imsg);
602 		if (err)
603 			break;
604 	}
605 
606 	imsg_clear(&ibuf);
607 	if (err) {
608 		if (!sigint_received && err->code != GOT_ERR_PRIVSEP_PIPE) {
609 			fprintf(stderr, "%s: %s\n", getprogname(), err->msg);
610 			got_privsep_send_error(&ibuf, err);
611 		}
612 	}
613 	if (close(GOT_IMSG_FD_CHILD) == -1 && err == NULL)
614 		err = got_error_from_errno("close");
615 	return err ? 1 : 0;
616 }