op public repos

Blob

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