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 		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 			ibuf_free(wbuf);
314 			break;
315 		}
316 
317 		if (imsg_add(wbuf, repo->name, iremote.name_len) == -1) {
318 			err = got_error_from_errno(
319 			    "imsg_add GOTCONFIG_REMOTE");
320 			ibuf_free(wbuf);
321 			break;
322 		}
323 		if (imsg_add(wbuf, fetch_url, iremote.fetch_url_len) == -1) {
324 			err = got_error_from_errno(
325 			    "imsg_add GOTCONFIG_REMOTE");
326 			ibuf_free(wbuf);
327 			break;
328 		}
329 		if (imsg_add(wbuf, send_url, iremote.send_url_len) == -1) {
330 			err = got_error_from_errno(
331 			    "imsg_add GOTCONFIG_REMOTE");
332 			ibuf_free(wbuf);
333 			break;
334 		}
335 
336 		wbuf->fd = -1;
337 		imsg_close(ibuf, wbuf);
338 		err = got_privsep_flush_imsg(ibuf);
339 		if (err)
340 			break;
341 
342 		free(fetch_url);
343 		fetch_url = NULL;
344 		free(send_url);
345 		send_url = NULL;
346 
347 		if (repo->fetch_config && repo->fetch_config->branch)
348 			branch = repo->fetch_config->branch;
349 		else
350 			branch = repo->branch;
351 		while (branch) {
352 			err = send_gotconfig_str(ibuf, branch->branch_name);
353 			if (err)
354 				break;
355 			branch = branch->next;
356 		}
357 
358 		if (repo->send_config && repo->send_config->branch)
359 			branch = repo->send_config->branch;
360 		else
361 			branch = repo->branch;
362 		while (branch) {
363 			err = send_gotconfig_str(ibuf, branch->branch_name);
364 			if (err)
365 				break;
366 			branch = branch->next;
367 		}
368 
369 		ref = repo->fetch_ref;
370 		while (ref) {
371 			err = send_gotconfig_str(ibuf, ref->ref_name);
372 			if (err)
373 				break;
374 			ref = ref->next;
375 		}
376 	}
377 
378 	free(fetch_url);
379 	free(send_url);
380 	return err;
381 }
382 
383 static const struct got_error *
384 validate_protocol(const char *protocol, const char *repo_name)
385 {
386 	static char msg[512];
387 
388 	if (strcmp(protocol, "ssh") != 0 &&
389 	    strcmp(protocol, "git+ssh") != 0 &&
390 	    strcmp(protocol, "git") != 0) {
391 		snprintf(msg, sizeof(msg),"unknown protocol \"%s\" "
392 		    "for remote repository \"%s\"", protocol, repo_name);
393 		return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
394 	}
395 
396 	return NULL;
397 }
398 
399 static const struct got_error *
400 validate_config(struct gotconfig *gotconfig)
401 {
402 	const struct got_error *err;
403 	struct gotconfig_remote_repo *repo, *repo2;
404 	static char msg[512];
405 
406 	TAILQ_FOREACH(repo, &gotconfig->remotes, entry) {
407 		if (repo->name == NULL) {
408 			return got_error_msg(GOT_ERR_PARSE_CONFIG,
409 			    "name required for remote repository");
410 		}
411 
412 		TAILQ_FOREACH(repo2, &gotconfig->remotes, entry) {
413 			if (repo == repo2 ||
414 			    strcmp(repo->name, repo2->name) != 0)
415 				continue;
416 			snprintf(msg, sizeof(msg),
417 			    "duplicate remote repository name '%s'",
418 			    repo->name);
419 			return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
420 		}
421 
422 		if (repo->server == NULL &&
423 		    (repo->fetch_config == NULL ||
424 		    repo->fetch_config->server == NULL) &&
425 		    (repo->send_config == NULL ||
426 		    repo->send_config->server == NULL)) {
427 			snprintf(msg, sizeof(msg),
428 			    "server required for remote repository \"%s\"",
429 			    repo->name);
430 			return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
431 		}
432 
433 		if (repo->protocol == NULL &&
434 		    (repo->fetch_config == NULL ||
435 		    repo->fetch_config->protocol == NULL) &&
436 		    (repo->send_config == NULL ||
437 		    repo->send_config->protocol == NULL)) {
438 			snprintf(msg, sizeof(msg),
439 			    "protocol required for remote repository \"%s\"",
440 			    repo->name);
441 			return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
442 		}
443 
444 		if (repo->protocol) {
445 			err = validate_protocol(repo->protocol, repo->name);
446 			if (err)
447 				return err;
448 		}
449 		if (repo->fetch_config && repo->fetch_config->protocol) {
450 			err = validate_protocol(repo->fetch_config->protocol,
451 			    repo->name);
452 			if (err)
453 				return err;
454 		}
455 		if (repo->send_config && repo->send_config->protocol) {
456 			err = validate_protocol(repo->send_config->protocol,
457 			    repo->name);
458 			if (err)
459 				return err;
460 		}
461 
462 		if (repo->repository == NULL &&
463 		    (repo->fetch_config == NULL ||
464 		    repo->fetch_config->repository == NULL) &&
465 		    (repo->send_config == NULL ||
466 		    repo->send_config->repository == NULL)) {
467 			snprintf(msg, sizeof(msg),
468 			    "repository path required for remote "
469 			    "repository \"%s\"", repo->name);
470 			return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
471 		}
472 	}
473 
474 	return NULL;
475 }
476 
477 int
478 main(int argc, char *argv[])
479 {
480 	const struct got_error *err = NULL;
481 	struct imsgbuf ibuf;
482 	struct gotconfig *gotconfig = NULL;
483 	size_t datalen;
484 	const char *filename = "got.conf";
485 #if 0
486 	static int attached;
487 
488 	while (!attached)
489 		sleep(1);
490 #endif
491 	signal(SIGINT, catch_sigint);
492 
493 	imsg_init(&ibuf, GOT_IMSG_FD_CHILD);
494 
495 #ifndef PROFILE
496 	/* revoke access to most system calls */
497 	if (pledge("stdio recvfd", NULL) == -1) {
498 		err = got_error_from_errno("pledge");
499 		got_privsep_send_error(&ibuf, err);
500 		return 1;
501 	}
502 #endif
503 
504 	if (argc > 1)
505 		filename = argv[1];
506 
507 	for (;;) {
508 		struct imsg imsg;
509 
510 		memset(&imsg, 0, sizeof(imsg));
511 		imsg.fd = -1;
512 
513 		if (sigint_received) {
514 			err = got_error(GOT_ERR_CANCELLED);
515 			break;
516 		}
517 
518 		err = got_privsep_recv_imsg(&imsg, &ibuf, 0);
519 		if (err) {
520 			if (err->code == GOT_ERR_PRIVSEP_PIPE)
521 				err = NULL;
522 			break;
523 		}
524 
525 		if (imsg.hdr.type == GOT_IMSG_STOP)
526 			break;
527 
528 		switch (imsg.hdr.type) {
529 		case GOT_IMSG_GOTCONFIG_PARSE_REQUEST:
530 			datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
531 			if (datalen != 0) {
532 				err = got_error(GOT_ERR_PRIVSEP_LEN);
533 				break;
534 			}
535 			if (imsg.fd == -1){
536 				err = got_error(GOT_ERR_PRIVSEP_NO_FD);
537 				break;
538 			}
539 
540 			if (gotconfig)
541 				gotconfig_free(gotconfig);
542 			err = gotconfig_parse(&gotconfig, filename, &imsg.fd);
543 			if (err)
544 				break;
545 			err = validate_config(gotconfig);
546 			break;
547 		case GOT_IMSG_GOTCONFIG_AUTHOR_REQUEST:
548 			if (gotconfig == NULL) {
549 				err = got_error(GOT_ERR_PRIVSEP_MSG);
550 				break;
551 			}
552 			err = send_gotconfig_str(&ibuf,
553 			    gotconfig->author ?  gotconfig->author : "");
554 			break;
555 		case GOT_IMSG_GOTCONFIG_REMOTES_REQUEST:
556 			if (gotconfig == NULL) {
557 				err = got_error(GOT_ERR_PRIVSEP_MSG);
558 				break;
559 			}
560 			err = send_gotconfig_remotes(&ibuf,
561 			    &gotconfig->remotes, gotconfig->nremotes);
562 			break;
563 		default:
564 			err = got_error(GOT_ERR_PRIVSEP_MSG);
565 			break;
566 		}
567 
568 		if (imsg.fd != -1) {
569 			if (close(imsg.fd) == -1 && err == NULL)
570 				err = got_error_from_errno("close");
571 		}
572 
573 		imsg_free(&imsg);
574 		if (err)
575 			break;
576 	}
577 
578 	imsg_clear(&ibuf);
579 	if (err) {
580 		if (!sigint_received && err->code != GOT_ERR_PRIVSEP_PIPE) {
581 			fprintf(stderr, "%s: %s\n", getprogname(), err->msg);
582 			got_privsep_send_error(&ibuf, err);
583 		}
584 	}
585 	if (close(GOT_IMSG_FD_CHILD) == -1 && err == NULL)
586 		err = got_error_from_errno("close");
587 	return err ? 1 : 0;
588 }