op public repos

Blob

Date:: Mon Jan 10 08:59:39 2022 UTC
Message:: Merge branch 'portable' Trying to maintain two branches was impossible at this stage for me alone, so I'll recognize my stupidity and merge the portable branch into the main one. The repository will build using autotools.
Actions:: History | Blame | Raw File
1 /*
2  * Copyright (c) 2021 Omar Polo <op@omarpolo.com>
3  * Copyright (c) 2018 Florian Obser <florian@openbsd.org>
4  * Copyright (c) 2005 Claudio Jeker <claudio@openbsd.org>
5  * Copyright (c) 2004 Esben Norby <norby@openbsd.org>
6  * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
7  *
8  * Permission to use, copy, modify, and distribute this software for any
9  * purpose with or without fee is hereby granted, provided that the above
10  * copyright notice and this permission notice appear in all copies.
11  *
12  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
13  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
14  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
15  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
16  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19  */
20 
21 #include "compat.h"
22 
23 #include <sys/socket.h>
24 #include <sys/types.h>
25 #include <sys/uio.h>
26 #include <sys/wait.h>
27 
28 #include <arpa/inet.h>
29 #include <netinet/in.h>
30 
31 #include <errno.h>
32 #include <fcntl.h>
33 #include <pwd.h>
34 #include <signal.h>
35 #include <stdint.h>
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <syslog.h>
40 #include <unistd.h>
41 
42 #include "client.h"
43 #include "control.h"
44 #include "kamid.h"
45 #include "listener.h"
46 #include "log.h"
47 #include "sandbox.h"
48 #include "table.h"
49 #include "utils.h"
50 
51 enum kd_process {
52 	PROC_MAIN,
53 	PROC_LISTENER,
54 	PROC_CLIENTCONN,
55 };
56 
57 const char	*saved_argv0;
58 static int	 debug, nflag;
59 int		 verbose;
60 
61 __dead void	usage(void);
62 
63 void		main_sig_handler(int, short, void *);
64 void		main_dispatch_listener(int, short, void *);
65 int		main_reload(void);
66 int		main_imsg_send_config(struct kd_conf *);
67 void		main_dispatch_listener(int, short, void *);
68 __dead void	main_shutdown(void);
69 
70 static pid_t	start_child(enum kd_process, int, int, int);
71 
72 struct kd_conf		*main_conf;
73 static struct imsgev	*iev_listener;
74 const char		*conffile;
75 pid_t			 listener_pid;
76 uint32_t		 cmd_opts;
77 
78 __dead void
79 usage(void)
80 {
81 	fprintf(stderr, "usage: %s [-dnv] [-f file] [-s socket]\n",
82 	    getprogname());
83 	exit(1);
84 }
85 
86 int
87 main(int argc, char **argv)
88 {
89 	struct event	 ev_sigint, ev_sigterm, ev_sighup;
90 	int		 ch;
91 	int		 listener_flag = 0, client_flag = 0;
92 	int		 pipe_main2listener[2];
93 	int		 control_fd;
94 	const char	*csock;
95 
96 	conffile = KD_CONF_FILE;
97 	csock = KD_SOCKET;
98 
99 	log_init(1, LOG_DAEMON);	/* Log to stderr until deamonized. */
100 	log_setverbose(1);
101 
102 	saved_argv0 = argv[0];
103 	if (saved_argv0 == NULL)
104 		saved_argv0 = "kamid";
105 
106 	while ((ch = getopt(argc, argv, "D:df:nsT:v")) != -1) {
107 		switch (ch) {
108 		case 'D':
109 			if (cmdline_symset(optarg) == -1)
110                                 log_warnx("could not parse macro definition %s",
111 					optarg);
112 			break;
113 		case 'd':
114 			debug = 1;
115 			break;
116 		case 'f':
117 			conffile = optarg;
118 			break;
119 		case 'n':
120 			nflag = 1;
121 			break;
122 		case 's':
123 			csock = optarg;
124 			break;
125 		case 'T':
126 			switch (*optarg) {
127 			case 'c':
128 				client_flag = 1;
129 				break;
130 			case 'l':
131 				listener_flag = 1;
132 				break;
133 			default:
134 				fatalx("invalid process spec %c", *optarg);
135 			}
136 			break;
137 		case 'v':
138 			verbose = 1;
139 			break;
140 		default:
141 			usage();
142 		}
143 	}
144 
145 	argc -= optind;
146 	argv += optind;
147 	if (argc > 0 || (listener_flag && client_flag))
148 		usage();
149 
150 	if (client_flag)
151 		client(debug, verbose);
152 	else if (listener_flag)
153 		listener(debug, verbose);
154 
155 	if ((main_conf = parse_config(conffile)) == NULL)
156 		exit(1);
157 
158 	if (nflag) {
159 		fprintf(stderr, "configuration OK\n");
160 		exit(0);
161 	}
162 
163 	/* Check for root privileges. */
164         if (geteuid())
165                 fatalx("need root privileges");
166 
167 	/* Check for assigned daemon user. */
168 	if (getpwnam(KD_USER) == NULL)
169 		fatalx("unknown user %s", KD_USER);
170 
171 	log_init(debug, LOG_DAEMON);
172 	log_setverbose(verbose);
173 
174 	if (!debug)
175 		daemon(1, 0);
176 
177 	log_info("startup");
178 
179 	if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
180 	    PF_UNSPEC, pipe_main2listener) == -1)
181 		fatal("main2listener socketpair");
182 
183 	/* Start children. */
184 	listener_pid = start_child(PROC_LISTENER, pipe_main2listener[1],
185 	    debug, verbose);
186 
187 	log_procinit("main");
188 
189 	event_init();
190 
191 	/* Setup signal handler */
192 	signal_set(&ev_sigint, SIGINT, main_sig_handler, NULL);
193 	signal_set(&ev_sigterm, SIGTERM, main_sig_handler, NULL);
194 	signal_set(&ev_sighup, SIGHUP, main_sig_handler, NULL);
195 
196 	signal_add(&ev_sigint, NULL);
197 	signal_add(&ev_sigterm, NULL);
198 	signal_add(&ev_sighup, NULL);
199 
200 	signal(SIGCHLD, SIG_IGN);
201 	signal(SIGPIPE, SIG_IGN);
202 
203 	if ((iev_listener = malloc(sizeof(*iev_listener))) == NULL)
204 		fatal(NULL);
205 	imsg_init(&iev_listener->ibuf, pipe_main2listener[0]);
206 	iev_listener->handler = main_dispatch_listener;
207 
208 	/* Setup event handlers for pipes to listener. */
209 	iev_listener->events = EV_READ;
210 	event_set(&iev_listener->ev, iev_listener->ibuf.fd,
211 	    iev_listener->events, iev_listener->handler, iev_listener);
212 	event_add(&iev_listener->ev, NULL);
213 
214 	if ((control_fd = control_init(csock)) == -1)
215 		fatalx("control socket setup failed");
216 
217 	main_imsg_compose_listener(IMSG_CONTROLFD, control_fd, 0,
218 	    NULL, 0);
219 	main_imsg_send_config(main_conf);
220 
221 	sandbox_main();
222 
223 	event_dispatch();
224 
225 	main_shutdown();
226 	return 0;
227 }
228 
229 void
230 main_sig_handler(int sig, short event, void *arg)
231 {
232 	/*
233 	 * Normal signal handler rules don't apply because libevent
234 	 * decouples for us.
235 	 */
236 
237 	switch (sig) {
238 	case SIGTERM:
239 	case SIGINT:
240 		main_shutdown();
241 		break;
242 	case SIGHUP:
243 		if (main_reload() == -1)
244 			log_warnx("configuration reload failed");
245 		else
246 			log_debug("configuration reloaded");
247 		break;
248 	default:
249 		fatalx("unexpected signal %d", sig);
250 	}
251 }
252 
253 static inline struct table *
254 auth_table_by_id(uint32_t id)
255 {
256 	struct kd_listen_conf *listen;
257 
258 	STAILQ_FOREACH(listen, &main_conf->listen_head, entry) {
259 		if (listen->id == id)
260 			return listen->auth_table;
261 	}
262 
263 	return NULL;
264 }
265 
266 static inline struct table *
267 virtual_table_by_id(uint32_t id)
268 {
269 	struct kd_listen_conf *listen;
270 
271 	STAILQ_FOREACH(listen, &main_conf->listen_head, entry) {
272 		if (listen->id == id)
273 			return listen->virtual_table;
274 	}
275 
276 	return NULL;
277 }
278 
279 static inline struct table *
280 userdata_table_by_id(uint32_t id)
281 {
282 	struct kd_listen_conf *listen;
283 
284 	STAILQ_FOREACH(listen, &main_conf->listen_head, entry) {
285 		if (listen->id == id)
286 			return listen->userdata_table;
287 	}
288 
289 	return NULL;
290 }
291 
292 static inline void
293 do_auth_tls(struct imsg *imsg)
294 {
295 	char *username = NULL, *user = NULL, *home = NULL, *local_user;
296 	struct passwd *pw;
297 	struct table *auth, *virt, *userdata;
298 	struct kd_auth_req kauth;
299 	int p[2], free_home = 1;
300 
301 	if (sizeof(kauth) != IMSG_DATA_SIZE(*imsg))
302 		fatal("wrong size for IMSG_AUTH_TLS: "
303 		    "got %lu; want %lu", IMSG_DATA_SIZE(*imsg),
304 		    sizeof(kauth));
305 	memcpy(&kauth, imsg->data, sizeof(kauth));
306 
307 	if (memmem(kauth.hash, sizeof(kauth.hash), "", 1) == NULL)
308                 fatal("non NUL-terminated hash received");
309 
310 	log_debug("tls id=%u hash=%s", kauth.listen_id, kauth.hash);
311 
312 	if ((auth = auth_table_by_id(kauth.listen_id)) == NULL)
313 		fatal("request for invalid listener id %d", imsg->hdr.pid);
314 
315 	virt = virtual_table_by_id(kauth.listen_id);
316 	userdata = userdata_table_by_id(kauth.listen_id);
317 
318 	if (table_lookup(auth, kauth.hash, &username) == -1) {
319 		log_warnx("login failed for hash %s", kauth.hash);
320 		goto err;
321 	}
322 
323 	if (virt != NULL && table_lookup(virt, username, &user) == -1) {
324 		log_warnx("virtual lookup failed for user %s", username);
325 		goto err;
326 	}
327 
328 	/* the local user */
329 	local_user = user != NULL ? user : username;
330 
331 	if (user != NULL)
332 		log_debug("virtual user %s matched local user %s",
333 		    username, user);
334 	else
335 		log_debug("matched local user %s", username);
336 
337 	if (userdata != NULL && table_lookup(userdata, username, &home)
338 	    == -1) {
339 		log_warnx("userdata lookup failed for user %s", username);
340 		goto err;
341 	} else if (userdata == NULL) {
342 		if ((pw = getpwnam(local_user)) == NULL) {
343 			log_warnx("getpwnam(%s) failed", local_user);
344 			goto err;
345 		}
346 
347 		free_home = 0;
348 		home = pw->pw_dir;
349 	}
350 
351 	if (user != NULL)
352 		log_debug("matched home %s for virtual user %s",
353 		    home, username);
354 	else
355 		log_debug("matched home %s for local user %s",
356 		    home, username);
357 
358 	if (socketpair(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK,
359 	    PF_UNSPEC, p) == -1)
360 		fatal("socketpair");
361 
362 	start_child(PROC_CLIENTCONN, p[1], debug, verbose);
363 
364 	main_imsg_compose_listener(IMSG_AUTH, p[0], imsg->hdr.peerid,
365 	    local_user, strlen(local_user)+1);
366 	main_imsg_compose_listener(IMSG_AUTH_DIR, -1, imsg->hdr.peerid,
367 	    home, strlen(home)+1);
368 
369 	free(username);
370 	free(user);
371 	if (free_home)
372 		free(home);
373 	return;
374 
375 err:
376 	free(username);
377 	free(user);
378 	if (free_home)
379 		free(home);
380 	main_imsg_compose_listener(IMSG_AUTH, -1, imsg->hdr.peerid,
381 	    NULL, 0);
382 }
383 
384 void
385 main_dispatch_listener(int fd, short event, void *d)
386 {
387 	struct imsgev	*iev = d;
388 	struct imsgbuf	*ibuf;
389 	struct imsg	 imsg;
390 	ssize_t		 n;
391 	int		 shut = 0;
392 
393 	ibuf = &iev->ibuf;
394 
395 	if (event & EV_READ) {
396 		if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
397 			fatal("imsg_read error");
398 		if (n == 0)	/* Connection closed. */
399 			shut = 1;
400 	}
401 	if (event & EV_WRITE) {
402 		if ((n = msgbuf_write(&ibuf->w)) == -1 && errno != EAGAIN)
403 			fatal("msgbuf_write");
404 		if (n == 0)	/* Connection closed. */
405 			shut = 1;
406 	}
407 
408 	for (;;) {
409 		if ((n = imsg_get(ibuf, &imsg)) == -1)
410 			fatal("imsg_get");
411 		if (n == 0)	/* No more messages. */
412 			break;
413 
414 		switch (imsg.hdr.type) {
415 		case IMSG_AUTH_TLS:
416 			do_auth_tls(&imsg);
417 			break;
418 		default:
419 			log_debug("%s: error handling imsg %d", __func__,
420 				imsg.hdr.type);
421 			break;
422 		}
423 		imsg_free(&imsg);
424 	}
425 	if (!shut)
426 		imsg_event_add(iev);
427 	else {
428 		/* This pipe is dead.  Remove its event handler. */
429 		event_del(&iev->ev);
430 		event_loopexit(NULL);
431 	}
432 }
433 
434 int
435 main_reload(void)
436 {
437 	struct kd_conf *xconf;
438 
439 	if ((xconf = parse_config(conffile)) == NULL)
440 		return -1;
441 
442 	if (main_imsg_send_config(xconf) == -1)
443 		return -1;
444 
445 	merge_config(main_conf, xconf);
446 
447 	return 0;
448 }
449 
450 static inline int
451 make_socket_for(struct kd_listen_conf *l)
452 {
453 	struct sockaddr_in	addr4;
454 	size_t			len;
455 	int			fd, v;
456 
457 	memset(&addr4, 0, sizeof(addr4));
458 	addr4.sin_family = AF_INET;
459 	addr4.sin_port = htons(l->port);
460 	addr4.sin_addr.s_addr = INADDR_ANY;
461 
462 	if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
463 		fatal("socket");
464 
465 	v = 1;
466 	if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &v, sizeof(v)) == -1)
467 		fatal("setsockopt(SO_REUSEADDR)");
468 
469 	v = 1;
470 	if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &v, sizeof(v)) == -1)
471 		fatal("setsockopt(SO_REUSEPORT)");
472 
473 	len = sizeof(addr4);
474 	if (bind(fd, (struct sockaddr *)&addr4, len) == -1)
475 		fatal("bind(%s, %d)", l->iface, l->port);
476 
477 	if (listen(fd, 16) == -1)
478 		fatal("l(%s, %d)", l->iface, l->port);
479 
480 	return fd;
481 }
482 
483 int
484 main_imsg_send_config(struct kd_conf *xconf)
485 {
486 	struct kd_pki_conf *pki;
487 	struct kd_listen_conf *listen;
488 
489 #define SEND(type, fd, data, len) do {					\
490 		if (main_imsg_compose_listener(type, fd, 0, data, len)	\
491 		    == -1)						\
492 			return -1;					\
493 	} while (0)
494 
495 	/* Send fixed part of config to children. */
496 	SEND(IMSG_RECONF_CONF, -1, xconf, sizeof(*xconf));
497 
498 	STAILQ_FOREACH(pki, &xconf->pki_head, entry) {
499 		log_debug("sending pki %s", pki->name);
500 		SEND(IMSG_RECONF_PKI, -1, pki->name, sizeof(pki->name));
501 		SEND(IMSG_RECONF_PKI_CERT, -1, pki->cert, pki->certlen);
502 		SEND(IMSG_RECONF_PKI_KEY, -1, pki->key, pki->keylen);
503 	}
504 
505 	STAILQ_FOREACH(listen, &xconf->listen_head, entry) {
506 		log_debug("sending listen on port %d", listen->port);
507 		SEND(IMSG_RECONF_LISTEN, make_socket_for(listen), listen,
508 		    sizeof(*listen));
509 	}
510 
511 	SEND(IMSG_RECONF_END, -1, NULL, 0);
512 	return 0;
513 
514 #undef SEND
515 }
516 
517 void
518 merge_config(struct kd_conf *conf, struct kd_conf *xconf)
519 {
520 	/* do stuff... */
521 
522 	free(xconf);
523 }
524 
525 struct kd_conf *
526 config_new_empty(void)
527 {
528 	struct kd_conf *xconf;
529 
530 	if ((xconf = calloc(1, sizeof(*xconf))) == NULL)
531 		fatal(NULL);
532 
533 	/* set default values */
534 
535 	return xconf;
536 }
537 
538 void
539 config_clear(struct kd_conf *conf)
540 {
541 	struct kd_conf *xconf;
542 
543 	/* Merge current config with an empty one. */
544 	xconf = config_new_empty();
545 	merge_config(conf, xconf);
546 
547 	free(conf);
548 }
549 
550 __dead void
551 main_shutdown(void)
552 {
553 	pid_t	pid;
554 	int	status;
555 
556 	/* close pipes. */
557         config_clear(main_conf);
558 
559 	log_debug("waiting for children to terminate");
560 	do {
561 		pid = wait(&status);
562 		if (pid == -1) {
563 			if (errno != EINTR && errno != ECHILD)
564 				fatal("wait");
565 		} else if (WIFSIGNALED(status))
566 			log_warnx("%s terminated; signal %d",
567 			    (pid == listener_pid) ? "logger" : "clientconn",
568 			    WTERMSIG(status));
569 	} while (pid != -1 || (pid == -1 && errno == EINTR));
570 
571 	free(iev_listener);
572 
573 	log_info("terminating");
574 	exit(0);
575 }
576 
577 static pid_t
578 start_child(enum kd_process p, int fd, int debug, int verbose)
579 {
580 	const char	*argv[5];
581 	int		 argc = 0;
582 	pid_t		 pid;
583 
584 	switch (pid = fork()) {
585 	case -1:
586 		fatal("cannot fork");
587 	case 0:
588 		break;
589 	default:
590 		close(fd);
591 		return pid;
592 	}
593 
594 	if (fd != 3) {
595 		if (dup2(fd, 3) == -1)
596 			fatal("cannot setup imsg fd");
597 	} else if (fcntl(F_SETFD, 0) == -1)
598 		fatal("cannot setup imsg fd");
599 
600 	argv[argc++] = saved_argv0;
601 	switch (p) {
602 	case PROC_MAIN:
603 		fatalx("Can not start main process");
604 	case PROC_LISTENER:
605 		argv[argc++] = "-Tl";
606 		break;
607 	case PROC_CLIENTCONN:
608 		argv[argc++] = "-Tc";
609 		break;
610 	}
611 	if (debug)
612 		argv[argc++] = "-d";
613 	if (verbose)
614 		argv[argc++] = "-v";
615 	argv[argc++] = NULL;
616 
617 	/* really? */
618 	execvp(saved_argv0, (char *const *)argv);
619 	fatal("execvp");
620 }
621 
622 int
623 main_imsg_compose_listener(int type, int fd, uint32_t peerid,
624     const void *data, uint16_t datalen)
625 {
626 	if (iev_listener)
627 		return imsg_compose_event(iev_listener, type, peerid, 0,
628 		    fd, data, datalen);
629 	else
630 		return -1;
631 }