op public repos

Blob

Date:: Mon Jan 10 19:16:27 2022 UTC
Message:: simplify client proc bootstrap Drop the IMSG_AUTH_DIR imsg type and stuff everything in a struct kd_auth_proc that gets sent via IMSG_AUTH. Tweak the necessary bits to compile. While here also start documenting what data we send over which imsg. As an added benefit, now we're sending fixed-size messages instead of variable length strings.
Actions:: History | Blame | Raw File
1 /*
2  * Copyright (c) 2021, 2022 Omar Polo <op@omarpolo.com>
3  * Copyright (c) 2018 Florian Obser <florian@openbsd.org>
4  * Copyright (c) 2004, 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 
27 #include <endian.h>
28 #include <errno.h>
29 #include <inttypes.h>
30 #include <pwd.h>
31 #include <signal.h>
32 #include <stdint.h>
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <syslog.h>
37 #include <unistd.h>
38 
39 #include "control.h"
40 #include "kami.h"
41 #include "kamid.h"
42 #include "listener.h"
43 #include "log.h"
44 #include "sandbox.h"
45 #include "utils.h"
46 
47 static struct kd_conf	*listener_conf;
48 static struct imsgev	*iev_main;
49 
50 static void	listener_sig_handler(int, short, void *);
51 __dead void	listener_shutdown(void);
52 
53 SPLAY_HEAD(clients_tree_id, client) clients;
54 
55 struct client {
56 	uint32_t		 id;
57 	uint32_t		 lid;
58 	uint32_t		 msize;
59 	int			 fd;
60 	int			 done;
61 	struct tls		*ctx;
62 	struct event		 event;
63 	struct imsgev		 iev;
64 	struct bufferevent	*bev;
65 	SPLAY_ENTRY(client)	 sp_entry;
66 };
67 
68 static void	listener_imsg_event_add(struct imsgev *, void *);
69 static void	listener_dispatch_client(int, short, void *);
70 static int	listener_imsg_compose_client(struct client *, int,
71     uint32_t, const void *, uint16_t);
72 
73 static void	apply_config(struct kd_conf *);
74 static void	handle_accept(int, short, void *);
75 
76 static void	handle_handshake(int, short, void *);
77 static void	client_read(struct bufferevent *, void *);
78 static void	client_write(struct bufferevent *, void *);
79 static void	client_error(struct bufferevent *, short, void *);
80 static void	client_tls_readcb(int, short, void *);
81 static void	client_tls_writecb(int, short, void *);
82 static void	close_conn(struct client *);
83 static void	handle_close(int, short, void *);
84 
85 static inline int
86 clients_tree_cmp(struct client *a, struct client *b)
87 {
88 	if (a->id == b->id)
89 		return 0;
90 	else if (a->id < b->id)
91 		return -1;
92 	else
93 		return +1;
94 }
95 
96 SPLAY_PROTOTYPE(clients_tree_id, client, sp_entry, clients_tree_cmp);
97 SPLAY_GENERATE(clients_tree_id, client, sp_entry, clients_tree_cmp)
98 
99 static void
100 listener_sig_handler(int sig, short event, void *d)
101 {
102 	/*
103 	 * Normal signal handler rules don't apply because libevent
104 	 * decouples for us.
105 	 */
106 
107 	switch (sig) {
108 	case SIGINT:
109 	case SIGTERM:
110 		listener_shutdown();
111 	default:
112 		fatalx("unexpected signal %d", sig);
113 	}
114 }
115 
116 void
117 listener(int debug, int verbose)
118 {
119 	struct event		 ev_sigint, ev_sigterm;
120 	struct passwd		*pw;
121 
122 	/* listener_conf = config_new_empty(); */
123 
124 	log_init(debug, LOG_DAEMON);
125 	log_setverbose(verbose);
126 
127 	if ((pw = getpwnam(KD_USER)) == NULL)
128 		fatal("getpwnam");
129 
130 	if (chroot(pw->pw_dir) == -1)
131 		fatal("chroot");
132 	if (chdir("/") == -1)
133 		fatal("chdir(\"/\")");
134 
135 	setproctitle("listener");
136 	log_procinit("listener");
137 
138 	if (setgroups(1, &pw->pw_gid) ||
139 	    setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) ||
140 	    setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid))
141 		fatal("can't drop privileges");
142 
143 	event_init();
144 
145 	/* Setup signal handlers(s). */
146 	signal_set(&ev_sigint, SIGINT, listener_sig_handler, NULL);
147 	signal_set(&ev_sigterm, SIGTERM, listener_sig_handler, NULL);
148 
149 	signal_add(&ev_sigint, NULL);
150 	signal_add(&ev_sigterm, NULL);
151 
152 	signal(SIGPIPE, SIG_IGN);
153 	signal(SIGHUP, SIG_IGN);
154 
155 	/* Setup pipe and event handler to the main process. */
156 	if ((iev_main = malloc(sizeof(*iev_main))) == NULL)
157 		fatal(NULL);
158 
159 	imsg_init(&iev_main->ibuf, 3);
160 	iev_main->handler = listener_dispatch_main;
161 
162 	/* Setup event handlers. */
163 	iev_main->events = EV_READ;
164 	event_set(&iev_main->ev, iev_main->ibuf.fd, iev_main->events,
165 	    iev_main->handler, iev_main);
166 	event_add(&iev_main->ev, NULL);
167 
168 	sandbox_listener();
169 	event_dispatch();
170 	listener_shutdown();
171 }
172 
173 __dead void
174 listener_shutdown(void)
175 {
176 	msgbuf_clear(&iev_main->ibuf.w);
177 	close(iev_main->ibuf.fd);
178 
179 	config_clear(listener_conf);
180 
181 	free(iev_main);
182 
183 	log_info("listener exiting");
184 	exit(0);
185 }
186 
187 static void
188 listener_receive_config(struct imsg *imsg, struct kd_conf **nconf,
189     struct kd_pki_conf **pki)
190 {
191 	struct kd_listen_conf *listen;
192 	char *t;
193 
194 	switch (imsg->hdr.type) {
195 	case IMSG_RECONF_CONF:
196 		if (*nconf != NULL)
197 			fatalx("%s: IMSG_RECONF_CONF already in "
198 			    "progress", __func__);
199 
200 		if (listener_conf != NULL)
201 			fatalx("%s: don't know how reload the "
202 			    "configuration yet", __func__);
203 
204 		if (IMSG_DATA_SIZE(*imsg) != sizeof(struct kd_conf))
205 			fatalx("%s: IMSG_RECONF_CONF wrong length: %lu",
206 			    __func__, IMSG_DATA_SIZE(*imsg));
207 		if ((*nconf = malloc(sizeof(**nconf))) == NULL)
208 			fatal(NULL);
209 		memcpy(*nconf, imsg->data, sizeof(**nconf));
210 		memset(&(*nconf)->pki_head, 0, sizeof((*nconf)->pki_head));
211 		memset(&(*nconf)->table_head, 0, sizeof((*nconf)->table_head));
212 		memset(&(*nconf)->listen_head, 0, sizeof((*nconf)->listen_head));
213 		break;
214 	case IMSG_RECONF_PKI:
215 		if (*nconf == NULL)
216 			fatalx("%s: IMSG_RECONF_PKI without "
217 			    "IMSG_RECONF_CONF", __func__);
218 		*pki = xcalloc(1, sizeof(**pki));
219 		t = imsg->data;
220 		t[IMSG_DATA_SIZE(*imsg)-1] = '\0';
221 		strlcpy((*pki)->name, t, sizeof((*pki)->name));
222 		break;
223 	case IMSG_RECONF_PKI_CERT:
224 		if (*pki == NULL)
225 			fatalx("%s: IMSG_RECONF_PKI_CERT without "
226 			    "IMSG_RECONF_PKI", __func__);
227 		(*pki)->certlen = IMSG_DATA_SIZE(*imsg);
228 		(*pki)->cert = xmemdup(imsg->data, (*pki)->certlen);
229 		break;
230 	case IMSG_RECONF_PKI_KEY:
231 		if (*pki == NULL)
232 			fatalx("%s: IMSG_RECONF_PKI_KEY without "
233 			    "IMSG_RECONF_PKI", __func__);
234 		(*pki)->keylen = IMSG_DATA_SIZE(*imsg);
235 		(*pki)->key = xmemdup(imsg->data, (*pki)->keylen);
236 		STAILQ_INSERT_HEAD(&(*nconf)->pki_head, *pki, entry);
237 		pki = NULL;
238 		break;
239 	case IMSG_RECONF_LISTEN:
240 		if (*nconf == NULL)
241 			fatalx("%s: IMSG_RECONF_LISTEN without "
242 			    "IMSG_RECONF_CONF", __func__);
243 		if (IMSG_DATA_SIZE(*imsg) != sizeof(*listen))
244 			fatalx("%s: IMSG_RECONF_LISTEN wrong length: %lu",
245 			    __func__, IMSG_DATA_SIZE(*imsg));
246 		listen = xcalloc(1, sizeof(*listen));
247 		memcpy(listen, imsg->data, sizeof(*listen));
248 		memset(&listen->entry, 0, sizeof(listen->entry));
249 		if ((listen->fd = imsg->fd) == -1)
250 			fatalx("%s: IMSG_RECONF_LISTEN no fd",
251 			    __func__);
252 		listen->auth_table = NULL;
253 		memset(&listen->ev, 0, sizeof(listen->ev));
254 		STAILQ_INSERT_HEAD(&(*nconf)->listen_head, listen, entry);
255 		break;
256 	case IMSG_RECONF_END:
257 		if (*nconf == NULL)
258 			fatalx("%s: IMSG_RECONF_END without "
259 			    "IMSG_RECONF_CONF", __func__);
260 		/* merge_config(listener_conf, nconf); */
261 		apply_config(*nconf);
262 		*nconf = NULL;
263 		break;
264 	}
265 }
266 
267 static inline struct kd_listen_conf *
268 listen_by_id(uint32_t id)
269 {
270 	struct kd_listen_conf *l;
271 
272 	STAILQ_FOREACH(l, &listener_conf->listen_head, entry) {
273 		if (l->id == id)
274 			return l;
275 	}
276 	return NULL;
277 }
278 
279 void
280 listener_dispatch_main(int fd, short event, void *d)
281 {
282 	static struct kd_conf		*nconf;
283 	static struct kd_pki_conf	*pki;
284 	struct kd_listen_conf		*listen;
285 	struct client			*client, find;
286 	struct imsg			 imsg;
287 	struct imsgev			*iev = d;
288 	struct imsgbuf			*ibuf;
289 	ssize_t				 n;
290 	int				 shut = 0;
291 
292 	ibuf = &iev->ibuf;
293 
294 	if (event & EV_READ) {
295 		if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
296 			fatal("imsg_read error");
297 		if (n == 0)	/* Connection closed. */
298 			shut = 1;
299 	}
300 	if (event & EV_WRITE) {
301 		if ((n = msgbuf_write(&ibuf->w)) == -1 && errno != EAGAIN)
302 			fatal("msgbuf_write");
303 		if (n == 0)	/* Connection closed. */
304 			shut = 1;
305 	}
306 
307 	for (;;) {
308 		if ((n = imsg_get(ibuf, &imsg)) == -1)
309 			fatal("%s: imsg_get error", __func__);
310 		if (n == 0)	/* No more messages. */
311 			break;
312 
313 		switch (imsg.hdr.type) {
314 		case IMSG_CONTROLFD:
315 			if ((fd = imsg.fd) == -1)
316 				fatalx("%s: expected to receive imsg "
317 				    "control fd but didn't receive any",
318 				    __func__);
319 			/* Listen on control socket. */
320 			control_listen(fd);
321 			break;
322 		case IMSG_RECONF_CONF:
323 		case IMSG_RECONF_PKI:
324 		case IMSG_RECONF_PKI_CERT:
325 		case IMSG_RECONF_PKI_KEY:
326 		case IMSG_RECONF_LISTEN:
327 		case IMSG_RECONF_END:
328 			listener_receive_config(&imsg, &nconf, &pki);
329 			break;
330 		case IMSG_AUTH:
331 			if (IMSG_DATA_SIZE(imsg) != sizeof(struct kd_auth_proc))
332 				fatalx("mismatching size for IMSG_AUTH");
333 
334 			find.id = imsg.hdr.peerid;
335 			client = SPLAY_FIND(clients_tree_id, &clients, &find);
336 			if (client == NULL) {
337 				if (imsg.fd != -1)
338 					close(imsg.fd);
339 				break;
340 			}
341 			if (imsg.fd == -1) {
342 				log_info("got fd = -1, auth failed?");
343 				close_conn(client);
344 				break;
345 			}
346 			imsg_init(&client->iev.ibuf, imsg.fd);
347 			client->iev.events = EV_READ;
348 			client->iev.handler = listener_dispatch_client;
349 			event_set(&client->iev.ev, client->iev.ibuf.fd,
350 			    client->iev.events, client->iev.handler, client);
351 			listener_imsg_compose_client(client, IMSG_AUTH,
352 			    client->id, imsg.data, IMSG_DATA_SIZE(imsg));
353 
354 			client->bev = bufferevent_new(client->fd,
355 			    client_read, client_write, client_error,
356 			    client);
357 			if (client->bev == NULL) {
358 				log_info("failed to allocate client buffer");
359 				close_conn(client);
360 				return;
361 			}
362 
363 #if HAVE_EVENT2
364 			evbuffer_unfreeze(client->bev->input, 0);
365 			evbuffer_unfreeze(client->bev->output, 1);
366 #endif
367 
368 			listen = listen_by_id(client->lid);
369 			if (listen->flags & L_TLS) {
370 				event_set(&client->bev->ev_read, client->fd,
371 				    EV_READ, client_tls_readcb, client->bev);
372 				event_set(&client->bev->ev_write, client->fd,
373 				    EV_WRITE, client_tls_writecb, client->bev);
374 			}
375 
376 			/*
377 			 * Read or write at least a header before
378 			 * firing the callbacks.  High watermark of 0
379 			 * to never stop reading/writing; probably to
380 			 * be revisited.
381 			 */
382 			/* bufferevent_setwatermark(client->bev, EV_READ|EV_WRITE, */
383 			    /* sizeof(struct np_msg_header), 0); */
384 			bufferevent_enable(client->bev, EV_READ|EV_WRITE);
385 			break;
386 
387 		default:
388 			log_debug("%s: unexpected imsg %d", __func__,
389 			    imsg.hdr.type);
390 			break;
391 		}
392 		imsg_free(&imsg);
393 	}
394 
395 	if (!shut)
396 		listener_imsg_event_add(iev, d);
397 	else {
398 		/* This pipe is dead.  Remove its event handler. */
399 		event_del(&iev->ev);
400 		log_warnx("pipe closed, shutting down...");
401 		event_loopexit(NULL);
402 	}
403 }
404 
405 int
406 listener_imsg_compose_main(int type, uint32_t peerid, const void *data,
407     uint16_t datalen)
408 {
409 	return imsg_compose_event(iev_main, type, peerid, 0, -1, data,
410 	    datalen);
411 }
412 
413 static void
414 listener_imsg_event_add(struct imsgev *iev, void *d)
415 {
416 	iev->events = EV_READ;
417 	if (iev->ibuf.w.queued)
418 		iev->events |= EV_WRITE;
419 
420 	event_del(&iev->ev);
421 	event_set(&iev->ev, iev->ibuf.fd, iev->events, iev->handler, d);
422 	event_add(&iev->ev, NULL);
423 }
424 
425 static void
426 listener_dispatch_client(int fd, short event, void *d)
427 {
428         struct client	 find, *client = d;
429 	struct imsg	 imsg;
430 	struct imsgev	*iev;
431 	struct imsgbuf	*ibuf;
432 	ssize_t		 n;
433 	int		 r, shut = 0;
434 
435 	iev = &client->iev;
436 	ibuf = &iev->ibuf;
437 
438 	if (event & EV_READ) {
439 		if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
440 			fatal("imsg_read error");
441 		if (n == 0)	/* Connection closed */
442 			shut = 1;
443 	}
444 
445 	if (event & EV_WRITE) {
446 		if ((n = msgbuf_write(&ibuf->w)) == -1 && errno != EAGAIN)
447 			fatal("msgbuf_write");
448 		if (n == 0)	/* Connection closed. */
449 			shut = 1;
450 	}
451 
452 	for (;;) {
453 		if ((n = imsg_get(ibuf, &imsg)) == -1)
454 			fatal("%s: imsg_get error", __func__);
455 		if (n == 0)	/* No more messages. */
456 			break;
457 
458 		switch (imsg.hdr.type) {
459 		case IMSG_BUF:
460 			find.id = imsg.hdr.peerid;
461 			client = SPLAY_FIND(clients_tree_id, &clients, &find);
462 			if (client == NULL) {
463 				log_info("got IMSG_BUF but client (%d) gone",
464 				    imsg.hdr.peerid);
465 				break;
466 			}
467 			r = bufferevent_write(client->bev, imsg.data,
468 			    IMSG_DATA_SIZE(imsg));
469 			if (r == -1) {
470 				log_warn("%s: bufferevent_write failed",
471 				    __func__);
472 				close_conn(client);
473 				break;
474 			}
475 			break;
476 
477 		case IMSG_MSIZE:
478 			if (IMSG_DATA_SIZE(imsg) != sizeof(client->msize))
479 				fatal("IMSG_MSIZE size mismatch: "
480 				    "got %zu want %zu", IMSG_DATA_SIZE(imsg),
481 				    sizeof(client->msize));
482 
483 			memcpy(&client->msize, imsg.data,
484 			    sizeof(client->msize));
485 
486 			if (client->msize == 0)
487 				fatal("IMSG_MSIZE got msize = 0");
488 
489 			break;
490 
491 		case IMSG_CLOSE:
492 			/*
493 			 * Both EVBUFFER_READ or EVBUFFER_WRITE should
494 			 * be fine.
495 			 */
496 			client_error(client->bev, EVBUFFER_READ, client);
497 			break;
498 
499 		default:
500 			log_debug("%s: unexpected imsg %d", __func__,
501 			    imsg.hdr.type);
502 			break;
503 		}
504 		imsg_free(&imsg);
505 	}
506 
507 	if (!shut)
508 		listener_imsg_event_add(iev, d);
509 	else {
510 		/* This pipe is dead.  Remove its handler */
511 		log_debug("client proc vanished");
512                 close_conn(client);
513 	}
514 }
515 
516 static int
517 listener_imsg_compose_client(struct client *client, int type,
518     uint32_t peerid, const void *data, uint16_t len)
519 {
520 	int ret;
521 
522 	if ((ret = imsg_compose(&client->iev.ibuf, type, peerid, 0, -1,
523 	    data, len)) != -1)
524 		listener_imsg_event_add(&client->iev, client);
525 
526 	return ret;
527 }
528 
529 static inline struct kd_pki_conf *
530 pki_by_name(const char *name)
531 {
532         struct kd_pki_conf *pki;
533 
534 	STAILQ_FOREACH(pki, &listener_conf->pki_head, entry) {
535 		if (!strcmp(name, pki->name))
536 			return pki;
537 	}
538 
539 	return NULL;
540 }
541 
542 static void
543 apply_config(struct kd_conf *conf)
544 {
545 	struct kd_pki_conf *pki;
546 	struct kd_listen_conf *listen;
547 
548 	listener_conf = conf;
549 
550 	/* prepare the various tls_config */
551 	STAILQ_FOREACH(pki, &listener_conf->pki_head, entry) {
552 		if ((pki->tlsconf = tls_config_new()) == NULL)
553 			fatal("tls_config_new");
554 		tls_config_verify_client_optional(pki->tlsconf);
555 		tls_config_insecure_noverifycert(pki->tlsconf);
556 		if (tls_config_set_keypair_mem(pki->tlsconf,
557 		    pki->cert, pki->certlen,
558 		    pki->key, pki->keylen) == -1)
559 			fatalx("tls_config_set_keypair_mem: %s",
560 			    tls_config_error(pki->tlsconf));
561 	}
562 
563 	/* prepare and kickoff the listeners */
564 	STAILQ_FOREACH(listen, &listener_conf->listen_head, entry) {
565 		if ((listen->ctx = tls_server()) == NULL)
566 			fatal("tls_server");
567 
568 		pki = pki_by_name(listen->pki);
569 		if (tls_configure(listen->ctx, pki->tlsconf) == -1)
570 			fatalx("tls_configure: %s",
571 			    tls_config_error(pki->tlsconf));
572 
573 		event_set(&listen->ev, listen->fd, EV_READ|EV_PERSIST,
574 		    handle_accept, listen);
575 		event_add(&listen->ev, NULL);
576 	}
577 }
578 
579 static inline void
580 yield_r(struct client *c, void (*fn)(int, short, void *))
581 {
582 	if (event_pending(&c->event, EV_WRITE|EV_READ, NULL))
583 		event_del(&c->event);
584 	event_set(&c->event, c->fd, EV_READ, fn, c);
585 	event_add(&c->event, NULL);
586 }
587 
588 static inline void
589 yield_w(struct client *c, void (*fn)(int, short, void *))
590 {
591 	if (event_pending(&c->event, EV_WRITE|EV_READ, NULL))
592 		event_del(&c->event);
593 	event_set(&c->event, c->fd, EV_WRITE, fn, c);
594 	event_add(&c->event, NULL);
595 }
596 
597 static inline uint32_t
598 random_id(void)
599 {
600 #if HAVE_ARC4RANDOM
601 # define RANDID() arc4random()
602 #else
603 	/* not as pretty as a random id */
604 	static uint32_t counter = 0;
605 # define RANDID() counter++
606 #endif
607 
608 	struct client find, *res;
609 
610 	for (;;) {
611 		find.id = RANDID();
612 		res = SPLAY_FIND(clients_tree_id, &clients, &find);
613 		if (res == NULL)
614 			return find.id;
615 	}
616 
617 #undef RANDID
618 }
619 
620 static void
621 handle_accept(int fd, short ev, void *data)
622 {
623 	struct kd_listen_conf *listen = data;
624 	struct client *c;
625 	int s;
626 
627 	if ((s = accept(fd, NULL, NULL)) == -1) {
628 		log_warn("accept");
629 		return;
630 	}
631 
632 	c = xcalloc(1, sizeof(*c));
633 	c->msize = MSIZE9P;
634 	c->lid = listen->id;
635 	c->iev.ibuf.fd = -1;
636 
637 	if (tls_accept_socket(listen->ctx, &c->ctx, s) == -1) {
638 		log_warnx("tls_accept_socket: %s",
639 		    tls_error(listen->ctx));
640 		free(c);
641 		close(s);
642 		return;
643 	}
644 
645 	c->fd = s;
646 	c->id = random_id();
647 
648 	SPLAY_INSERT(clients_tree_id, &clients, c);
649 
650 	/* initialize the event */
651 	event_set(&c->event, c->fd, EV_READ, NULL, NULL);
652 
653 	yield_r(c, handle_handshake);
654 }
655 
656 static void
657 handle_handshake(int fd, short ev, void *data)
658 {
659 	struct client *c = data;
660 	struct kd_auth_req auth;
661 	ssize_t r;
662 	const char *hash;
663 
664 	switch (r = tls_handshake(c->ctx)) {
665 	case TLS_WANT_POLLIN:
666 		yield_r(c, handle_handshake);
667 		return;
668 	case TLS_WANT_POLLOUT:
669 		yield_w(c, handle_handshake);
670 		return;
671 	case -1:
672 		log_debug("handhsake failed: %s", tls_error(c->ctx));
673 		close_conn(c);
674 		return;
675 	}
676 
677 	if ((hash = tls_peer_cert_hash(c->ctx)) == NULL) {
678 		log_warnx("client didn't provide certificate");
679 		close_conn(c);
680 		return;
681 	}
682 
683 	memset(&auth, 0, sizeof(auth));
684 	auth.listen_id = c->lid;
685 	strlcpy(auth.hash, hash, sizeof(auth.hash));
686 	log_debug("sending hash %s", auth.hash);
687 
688 	listener_imsg_compose_main(IMSG_AUTH_TLS, c->id,
689 	    &auth, sizeof(auth));
690 }
691 
692 static void
693 client_read(struct bufferevent *bev, void *d)
694 {
695 	struct client	*client = d;
696 	struct evbuffer	*src = EVBUFFER_INPUT(bev);
697 	uint32_t	 len;
698 
699 	for (;;) {
700 		if (EVBUFFER_LENGTH(src) < 4)
701 			return;
702 
703 		memcpy(&len, EVBUFFER_DATA(src), sizeof(len));
704 		len = le32toh(len);
705 		log_debug("expecting a message %"PRIu32" bytes long "
706 		    "(of wich %zu already read)",
707 		    len, EVBUFFER_LENGTH(src));
708 
709 		if (len < HEADERSIZE) {
710 			log_warnx("invalid message size %d (too low)", len);
711 			client_error(bev, EVBUFFER_READ, client);
712 			return;
713 		}
714 
715 		if (len > client->msize) {
716 			log_warnx("incoming message bigger than msize "
717 			    "(%"PRIu32" vs %"PRIu32")", len, client->msize);
718 			client_error(bev, EVBUFFER_READ, client);
719 			return;
720 		}
721 
722 		if (len > EVBUFFER_LENGTH(src))
723 			return;
724 
725 		listener_imsg_compose_client(client, IMSG_BUF, client->id,
726 		    EVBUFFER_DATA(src), len);
727 		evbuffer_drain(src, len);
728 	}
729 }
730 
731 static void
732 client_write(struct bufferevent *bev, void *d)
733 {
734 	/*
735 	 * here we can do some fancy logic like deciding when to call
736 	 *
737 	 *	(*bev->errorcb)(bev, EVBUFFER_WRITE, bev->cbarg)
738 	 *
739 	 * to signal the end of the transaction.
740 	 */
741 
742 	return;
743 }
744 
745 static void
746 client_error(struct bufferevent *bev, short err, void *d)
747 {
748 	struct client	*client = d;
749 	struct evbuffer	*buf;
750 
751         if (err & EVBUFFER_ERROR) {
752 		if (errno == EFBIG) {
753 			bufferevent_enable(bev, EV_READ);
754 			return;
755 		}
756 		log_debug("buffer event error");
757                 close_conn(client);
758 		return;
759 	}
760 
761 	if (err & EVBUFFER_EOF) {
762                 close_conn(client);
763 		return;
764 	}
765 
766 	if (err & (EVBUFFER_READ|EVBUFFER_WRITE)) {
767 		bufferevent_disable(bev, EV_READ|EV_WRITE);
768 		client->done = 1;
769 
770 		buf = EVBUFFER_OUTPUT(client->bev);
771 		if (EVBUFFER_LENGTH(buf) != 0) {
772 			/* finish writing all the data first */
773 			bufferevent_enable(client->bev, EV_WRITE);
774 			return;
775 		}
776 
777 		close_conn(client);
778 		return;
779 	}
780 
781 	log_warnx("unknown event error, closing client connection");
782 	close_conn(client);
783 }
784 
785 static void
786 client_tls_readcb(int fd, short event, void *d)
787 {
788 	struct bufferevent	*bufev = d;
789 	struct client		*client = bufev->cbarg;
790 	char			 buf[IBUF_READ_SIZE];
791 	int			 what = EVBUFFER_READ;
792 	int			 howmuch = IBUF_READ_SIZE;
793 	ssize_t			 ret;
794 	size_t			 len;
795 
796 	if (event == EV_TIMEOUT) {
797 		what |= EVBUFFER_TIMEOUT;
798 		goto err;
799 	}
800 
801 	if (bufev->wm_read.high != 0)
802 		howmuch = MIN(sizeof(buf), bufev->wm_read.high);
803 
804         switch (ret = tls_read(client->ctx, buf, howmuch)) {
805 	case TLS_WANT_POLLIN:
806 	case TLS_WANT_POLLOUT:
807 		goto retry;
808 	case -1:
809 		what |= EVBUFFER_ERROR;
810 		goto err;
811 	}
812 	len = ret;
813 
814 	if (len == 0) {
815 		what |= EVBUFFER_EOF;
816 		goto err;
817 	}
818 
819 	if (evbuffer_add(bufev->input, buf, len) == -1) {
820 		what |= EVBUFFER_ERROR;
821 		goto err;
822 	}
823 
824 	event_add(&bufev->ev_read, NULL);
825 
826 	len = EVBUFFER_LENGTH(bufev->input);
827 	if (bufev->wm_read.low != 0 && len < bufev->wm_read.low)
828 		return;
829 	if (bufev->wm_read.high != 0 && len > bufev->wm_read.high) {
830 		/*
831 		 * here we could implement some read pressure
832 		 * mechanism.
833 		 */
834 	}
835 
836 	if (bufev->readcb != NULL)
837 		(*bufev->readcb)(bufev, bufev->cbarg);
838 
839 	return;
840 
841 retry:
842 	event_add(&bufev->ev_read, NULL);
843 	return;
844 
845 err:
846 	(*bufev->errorcb)(bufev, what, bufev->cbarg);
847 }
848 
849 static void
850 client_tls_writecb(int fd, short event, void *d)
851 {
852 	struct bufferevent	*bufev = d;
853 	struct client		*client = bufev->cbarg;
854 	ssize_t			 ret;
855 	size_t			 len;
856 	short			 what = EVBUFFER_WRITE;
857 
858 	if (event == EV_TIMEOUT) {
859 		what |= EVBUFFER_TIMEOUT;
860 		goto err;
861 	}
862 
863 	if (EVBUFFER_LENGTH(bufev->output) != 0) {
864 		ret = tls_write(client->ctx,
865 		    EVBUFFER_DATA(bufev->output),
866 		    EVBUFFER_LENGTH(bufev->output));
867 		switch (ret) {
868 		case TLS_WANT_POLLIN:
869 		case TLS_WANT_POLLOUT:
870 			goto retry;
871 		case -1:
872 			what |= EVBUFFER_ERROR;
873 			goto err;
874 		}
875 		len = ret;
876 		evbuffer_drain(bufev->output, len);
877 	}
878 
879 	if (EVBUFFER_LENGTH(bufev->output) != 0)
880 		event_add(&bufev->ev_write, NULL);
881 
882 	if (bufev->writecb != NULL &&
883 	    EVBUFFER_LENGTH(bufev->output) <= bufev->wm_write.low)
884 		(*bufev->writecb)(bufev, bufev->cbarg);
885 	return;
886 
887 retry:
888 	event_add(&bufev->ev_write, NULL);
889 	return;
890 
891 err:
892 	(*bufev->errorcb)(bufev, what, bufev->cbarg);
893 }
894 
895 static void
896 close_conn(struct client *c)
897 {
898 	log_debug("closing connection");
899 
900 	if (c->iev.ibuf.fd != -1) {
901 		listener_imsg_compose_client(c, IMSG_CONN_GONE, 0, NULL, 0);
902 		imsg_flush(&c->iev.ibuf);
903 		msgbuf_clear(&c->iev.ibuf.w);
904 		event_del(&c->iev.ev);
905 		close(c->iev.ibuf.fd);
906 	}
907 
908 	handle_close(c->fd, 0, c);
909 }
910 
911 static void
912 handle_close(int fd, short ev, void *d)
913 {
914 	struct client *c = d;
915 
916 	switch (tls_close(c->ctx)) {
917 	case TLS_WANT_POLLIN:
918 		yield_r(c, handle_close);
919 		return;
920 	case TLS_WANT_POLLOUT:
921 		yield_w(c, handle_close);
922 		return;
923 	}
924 
925 	event_del(&c->event);
926 	tls_free(c->ctx);
927 	close(c->fd);
928 	free(c);
929 }