op public repos

Blob

Date:: Sun Jan 23 12:58:01 2022 UTC
Message:: listener: handle IMSG_CTL_LOG_VERBOSE adjust the logging level and forward it to every client process so they can do so too.
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_CTL_LOG_VERBOSE:
315 			if (IMSG_DATA_SIZE(imsg) != sizeof(verbose))
316 				fatalx("wrong size for IMSG_CTL_LOG_VERBOSE");
317 			memcpy(&verbose, imsg.data, sizeof(verbose));
318 			log_setverbose(verbose);
319 			SPLAY_FOREACH(client, clients_tree_id, &clients)
320 				listener_imsg_compose_client(client,
321 				    imsg.hdr.type, 0,
322 				    &verbose, sizeof(verbose));
323 			break;
324 		case IMSG_RECONF_CONF:
325 		case IMSG_RECONF_PKI:
326 		case IMSG_RECONF_PKI_CERT:
327 		case IMSG_RECONF_PKI_KEY:
328 		case IMSG_RECONF_LISTEN:
329 		case IMSG_RECONF_END:
330 			listener_receive_config(&imsg, &nconf, &pki);
331 			break;
332 		case IMSG_AUTH:
333 			if (IMSG_DATA_SIZE(imsg) != sizeof(struct kd_auth_proc))
334 				fatalx("mismatching size for IMSG_AUTH");
335 
336 			find.id = imsg.hdr.peerid;
337 			client = SPLAY_FIND(clients_tree_id, &clients, &find);
338 			if (client == NULL) {
339 				if (imsg.fd != -1)
340 					close(imsg.fd);
341 				break;
342 			}
343 			if (imsg.fd == -1) {
344 				log_info("got fd = -1, auth failed?");
345 				close_conn(client);
346 				break;
347 			}
348 			imsg_init(&client->iev.ibuf, imsg.fd);
349 			client->iev.events = EV_READ;
350 			client->iev.handler = listener_dispatch_client;
351 			event_set(&client->iev.ev, client->iev.ibuf.fd,
352 			    client->iev.events, client->iev.handler, client);
353 			listener_imsg_compose_client(client, IMSG_AUTH,
354 			    client->id, imsg.data, IMSG_DATA_SIZE(imsg));
355 
356 			client->bev = bufferevent_new(client->fd,
357 			    client_read, client_write, client_error,
358 			    client);
359 			if (client->bev == NULL) {
360 				log_info("failed to allocate client buffer");
361 				close_conn(client);
362 				return;
363 			}
364 
365 #if HAVE_EVENT2
366 			evbuffer_unfreeze(client->bev->input, 0);
367 			evbuffer_unfreeze(client->bev->output, 1);
368 #endif
369 
370 			listen = listen_by_id(client->lid);
371 			if (listen->flags & L_TLS) {
372 				event_set(&client->bev->ev_read, client->fd,
373 				    EV_READ, client_tls_readcb, client->bev);
374 				event_set(&client->bev->ev_write, client->fd,
375 				    EV_WRITE, client_tls_writecb, client->bev);
376 			}
377 
378 			/*
379 			 * Read or write at least a header before
380 			 * firing the callbacks.  High watermark of 0
381 			 * to never stop reading/writing; probably to
382 			 * be revisited.
383 			 */
384 			/* bufferevent_setwatermark(client->bev, EV_READ|EV_WRITE, */
385 			    /* sizeof(struct np_msg_header), 0); */
386 			bufferevent_enable(client->bev, EV_READ|EV_WRITE);
387 			break;
388 
389 		default:
390 			log_debug("%s: unexpected imsg %d", __func__,
391 			    imsg.hdr.type);
392 			break;
393 		}
394 		imsg_free(&imsg);
395 	}
396 
397 	if (!shut)
398 		listener_imsg_event_add(iev, d);
399 	else {
400 		/* This pipe is dead.  Remove its event handler. */
401 		event_del(&iev->ev);
402 		log_warnx("pipe closed, shutting down...");
403 		event_loopexit(NULL);
404 	}
405 }
406 
407 int
408 listener_imsg_compose_main(int type, uint32_t peerid, const void *data,
409     uint16_t datalen)
410 {
411 	return imsg_compose_event(iev_main, type, peerid, 0, -1, data,
412 	    datalen);
413 }
414 
415 static void
416 listener_imsg_event_add(struct imsgev *iev, void *d)
417 {
418 	iev->events = EV_READ;
419 	if (iev->ibuf.w.queued)
420 		iev->events |= EV_WRITE;
421 
422 	event_del(&iev->ev);
423 	event_set(&iev->ev, iev->ibuf.fd, iev->events, iev->handler, d);
424 	event_add(&iev->ev, NULL);
425 }
426 
427 static void
428 listener_dispatch_client(int fd, short event, void *d)
429 {
430         struct client	 find, *client = d;
431 	struct imsg	 imsg;
432 	struct imsgev	*iev;
433 	struct imsgbuf	*ibuf;
434 	ssize_t		 n;
435 	int		 r, shut = 0;
436 
437 	iev = &client->iev;
438 	ibuf = &iev->ibuf;
439 
440 	if (event & EV_READ) {
441 		if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
442 			fatal("imsg_read error");
443 		if (n == 0)	/* Connection closed */
444 			shut = 1;
445 	}
446 
447 	if (event & EV_WRITE) {
448 		if ((n = msgbuf_write(&ibuf->w)) == -1 && errno != EAGAIN)
449 			fatal("msgbuf_write");
450 		if (n == 0)	/* Connection closed. */
451 			shut = 1;
452 	}
453 
454 	for (;;) {
455 		if ((n = imsg_get(ibuf, &imsg)) == -1)
456 			fatal("%s: imsg_get error", __func__);
457 		if (n == 0)	/* No more messages. */
458 			break;
459 
460 		switch (imsg.hdr.type) {
461 		case IMSG_BUF:
462 			find.id = imsg.hdr.peerid;
463 			client = SPLAY_FIND(clients_tree_id, &clients, &find);
464 			if (client == NULL) {
465 				log_info("got IMSG_BUF but client (%d) gone",
466 				    imsg.hdr.peerid);
467 				break;
468 			}
469 			r = bufferevent_write(client->bev, imsg.data,
470 			    IMSG_DATA_SIZE(imsg));
471 			if (r == -1) {
472 				log_warn("%s: bufferevent_write failed",
473 				    __func__);
474 				close_conn(client);
475 				break;
476 			}
477 			break;
478 
479 		case IMSG_MSIZE:
480 			if (IMSG_DATA_SIZE(imsg) != sizeof(client->msize))
481 				fatal("IMSG_MSIZE size mismatch: "
482 				    "got %zu want %zu", IMSG_DATA_SIZE(imsg),
483 				    sizeof(client->msize));
484 
485 			memcpy(&client->msize, imsg.data,
486 			    sizeof(client->msize));
487 
488 			if (client->msize == 0)
489 				fatal("IMSG_MSIZE got msize = 0");
490 
491 			break;
492 
493 		case IMSG_CLOSE:
494 			/*
495 			 * Both EVBUFFER_READ or EVBUFFER_WRITE should
496 			 * be fine.
497 			 */
498 			client_error(client->bev, EVBUFFER_READ, client);
499 			break;
500 
501 		default:
502 			log_debug("%s: unexpected imsg %d", __func__,
503 			    imsg.hdr.type);
504 			break;
505 		}
506 		imsg_free(&imsg);
507 	}
508 
509 	if (!shut)
510 		listener_imsg_event_add(iev, d);
511 	else {
512 		/* This pipe is dead.  Remove its handler */
513 		log_debug("client proc vanished");
514                 close_conn(client);
515 	}
516 }
517 
518 static int
519 listener_imsg_compose_client(struct client *client, int type,
520     uint32_t peerid, const void *data, uint16_t len)
521 {
522 	int ret;
523 
524 	if ((ret = imsg_compose(&client->iev.ibuf, type, peerid, 0, -1,
525 	    data, len)) != -1)
526 		listener_imsg_event_add(&client->iev, client);
527 
528 	return ret;
529 }
530 
531 static inline struct kd_pki_conf *
532 pki_by_name(const char *name)
533 {
534         struct kd_pki_conf *pki;
535 
536 	STAILQ_FOREACH(pki, &listener_conf->pki_head, entry) {
537 		if (!strcmp(name, pki->name))
538 			return pki;
539 	}
540 
541 	return NULL;
542 }
543 
544 static void
545 apply_config(struct kd_conf *conf)
546 {
547 	struct kd_pki_conf *pki;
548 	struct kd_listen_conf *listen;
549 
550 	listener_conf = conf;
551 
552 	/* prepare the various tls_config */
553 	STAILQ_FOREACH(pki, &listener_conf->pki_head, entry) {
554 		if ((pki->tlsconf = tls_config_new()) == NULL)
555 			fatal("tls_config_new");
556 		tls_config_verify_client_optional(pki->tlsconf);
557 		tls_config_insecure_noverifycert(pki->tlsconf);
558 		if (tls_config_set_keypair_mem(pki->tlsconf,
559 		    pki->cert, pki->certlen,
560 		    pki->key, pki->keylen) == -1)
561 			fatalx("tls_config_set_keypair_mem: %s",
562 			    tls_config_error(pki->tlsconf));
563 	}
564 
565 	/* prepare and kickoff the listeners */
566 	STAILQ_FOREACH(listen, &listener_conf->listen_head, entry) {
567 		if ((listen->ctx = tls_server()) == NULL)
568 			fatal("tls_server");
569 
570 		pki = pki_by_name(listen->pki);
571 		if (tls_configure(listen->ctx, pki->tlsconf) == -1)
572 			fatalx("tls_configure: %s",
573 			    tls_config_error(pki->tlsconf));
574 
575 		event_set(&listen->ev, listen->fd, EV_READ|EV_PERSIST,
576 		    handle_accept, listen);
577 		event_add(&listen->ev, NULL);
578 	}
579 }
580 
581 static inline void
582 yield_r(struct client *c, void (*fn)(int, short, void *))
583 {
584 	if (event_pending(&c->event, EV_WRITE|EV_READ, NULL))
585 		event_del(&c->event);
586 	event_set(&c->event, c->fd, EV_READ, fn, c);
587 	event_add(&c->event, NULL);
588 }
589 
590 static inline void
591 yield_w(struct client *c, void (*fn)(int, short, void *))
592 {
593 	if (event_pending(&c->event, EV_WRITE|EV_READ, NULL))
594 		event_del(&c->event);
595 	event_set(&c->event, c->fd, EV_WRITE, fn, c);
596 	event_add(&c->event, NULL);
597 }
598 
599 static inline uint32_t
600 random_id(void)
601 {
602 #if HAVE_ARC4RANDOM
603 # define RANDID() arc4random()
604 #else
605 	/* not as pretty as a random id */
606 	static uint32_t counter = 0;
607 # define RANDID() counter++
608 #endif
609 
610 	struct client find, *res;
611 
612 	for (;;) {
613 		find.id = RANDID();
614 		res = SPLAY_FIND(clients_tree_id, &clients, &find);
615 		if (res == NULL)
616 			return find.id;
617 	}
618 
619 #undef RANDID
620 }
621 
622 static void
623 handle_accept(int fd, short ev, void *data)
624 {
625 	struct kd_listen_conf *listen = data;
626 	struct client *c;
627 	int s;
628 
629 	if ((s = accept(fd, NULL, NULL)) == -1) {
630 		log_warn("accept");
631 		return;
632 	}
633 
634 	c = xcalloc(1, sizeof(*c));
635 	c->msize = MSIZE9P;
636 	c->lid = listen->id;
637 	c->iev.ibuf.fd = -1;
638 
639 	if (tls_accept_socket(listen->ctx, &c->ctx, s) == -1) {
640 		log_warnx("tls_accept_socket: %s",
641 		    tls_error(listen->ctx));
642 		free(c);
643 		close(s);
644 		return;
645 	}
646 
647 	c->fd = s;
648 	c->id = random_id();
649 
650 	SPLAY_INSERT(clients_tree_id, &clients, c);
651 
652 	/* initialize the event */
653 	event_set(&c->event, c->fd, EV_READ, NULL, NULL);
654 
655 	yield_r(c, handle_handshake);
656 }
657 
658 static void
659 handle_handshake(int fd, short ev, void *data)
660 {
661 	struct client *c = data;
662 	struct kd_auth_req auth;
663 	ssize_t r;
664 	const char *hash;
665 
666 	switch (r = tls_handshake(c->ctx)) {
667 	case TLS_WANT_POLLIN:
668 		yield_r(c, handle_handshake);
669 		return;
670 	case TLS_WANT_POLLOUT:
671 		yield_w(c, handle_handshake);
672 		return;
673 	case -1:
674 		log_debug("handhsake failed: %s", tls_error(c->ctx));
675 		close_conn(c);
676 		return;
677 	}
678 
679 	if ((hash = tls_peer_cert_hash(c->ctx)) == NULL) {
680 		log_warnx("client didn't provide certificate");
681 		close_conn(c);
682 		return;
683 	}
684 
685 	memset(&auth, 0, sizeof(auth));
686 	auth.listen_id = c->lid;
687 	strlcpy(auth.hash, hash, sizeof(auth.hash));
688 	log_debug("sending hash %s", auth.hash);
689 
690 	listener_imsg_compose_main(IMSG_AUTH_TLS, c->id,
691 	    &auth, sizeof(auth));
692 }
693 
694 static void
695 client_read(struct bufferevent *bev, void *d)
696 {
697 	struct client	*client = d;
698 	struct evbuffer	*src = EVBUFFER_INPUT(bev);
699 	uint32_t	 len;
700 
701 	for (;;) {
702 		if (EVBUFFER_LENGTH(src) < 4)
703 			return;
704 
705 		memcpy(&len, EVBUFFER_DATA(src), sizeof(len));
706 		len = le32toh(len);
707 		log_debug("expecting a message %"PRIu32" bytes long "
708 		    "(of wich %zu already read)",
709 		    len, EVBUFFER_LENGTH(src));
710 
711 		if (len < HEADERSIZE) {
712 			log_warnx("invalid message size %d (too low)", len);
713 			client_error(bev, EVBUFFER_READ, client);
714 			return;
715 		}
716 
717 		if (len > client->msize) {
718 			log_warnx("incoming message bigger than msize "
719 			    "(%"PRIu32" vs %"PRIu32")", len, client->msize);
720 			client_error(bev, EVBUFFER_READ, client);
721 			return;
722 		}
723 
724 		if (len > EVBUFFER_LENGTH(src))
725 			return;
726 
727 		listener_imsg_compose_client(client, IMSG_BUF, client->id,
728 		    EVBUFFER_DATA(src), len);
729 		evbuffer_drain(src, len);
730 	}
731 }
732 
733 static void
734 client_write(struct bufferevent *bev, void *d)
735 {
736 	/*
737 	 * here we can do some fancy logic like deciding when to call
738 	 *
739 	 *	(*bev->errorcb)(bev, EVBUFFER_WRITE, bev->cbarg)
740 	 *
741 	 * to signal the end of the transaction.
742 	 */
743 
744 	return;
745 }
746 
747 static void
748 client_error(struct bufferevent *bev, short err, void *d)
749 {
750 	struct client	*client = d;
751 	struct evbuffer	*buf;
752 
753         if (err & EVBUFFER_ERROR) {
754 		if (errno == EFBIG) {
755 			bufferevent_enable(bev, EV_READ);
756 			return;
757 		}
758 		log_debug("buffer event error");
759                 close_conn(client);
760 		return;
761 	}
762 
763 	if (err & EVBUFFER_EOF) {
764                 close_conn(client);
765 		return;
766 	}
767 
768 	if (err & (EVBUFFER_READ|EVBUFFER_WRITE)) {
769 		bufferevent_disable(bev, EV_READ|EV_WRITE);
770 		client->done = 1;
771 
772 		buf = EVBUFFER_OUTPUT(client->bev);
773 		if (EVBUFFER_LENGTH(buf) != 0) {
774 			/* finish writing all the data first */
775 			bufferevent_enable(client->bev, EV_WRITE);
776 			return;
777 		}
778 
779 		close_conn(client);
780 		return;
781 	}
782 
783 	log_warnx("unknown event error, closing client connection");
784 	close_conn(client);
785 }
786 
787 static void
788 client_tls_readcb(int fd, short event, void *d)
789 {
790 	struct bufferevent	*bufev = d;
791 	struct client		*client = bufev->cbarg;
792 	char			 buf[IBUF_READ_SIZE];
793 	int			 what = EVBUFFER_READ;
794 	int			 howmuch = IBUF_READ_SIZE;
795 	ssize_t			 ret;
796 	size_t			 len;
797 
798 	if (event == EV_TIMEOUT) {
799 		what |= EVBUFFER_TIMEOUT;
800 		goto err;
801 	}
802 
803 	if (bufev->wm_read.high != 0)
804 		howmuch = MIN(sizeof(buf), bufev->wm_read.high);
805 
806         switch (ret = tls_read(client->ctx, buf, howmuch)) {
807 	case TLS_WANT_POLLIN:
808 	case TLS_WANT_POLLOUT:
809 		goto retry;
810 	case -1:
811 		what |= EVBUFFER_ERROR;
812 		goto err;
813 	}
814 	len = ret;
815 
816 	if (len == 0) {
817 		what |= EVBUFFER_EOF;
818 		goto err;
819 	}
820 
821 	if (evbuffer_add(bufev->input, buf, len) == -1) {
822 		what |= EVBUFFER_ERROR;
823 		goto err;
824 	}
825 
826 	event_add(&bufev->ev_read, NULL);
827 
828 	len = EVBUFFER_LENGTH(bufev->input);
829 	if (bufev->wm_read.low != 0 && len < bufev->wm_read.low)
830 		return;
831 	if (bufev->wm_read.high != 0 && len > bufev->wm_read.high) {
832 		/*
833 		 * here we could implement some read pressure
834 		 * mechanism.
835 		 */
836 	}
837 
838 	if (bufev->readcb != NULL)
839 		(*bufev->readcb)(bufev, bufev->cbarg);
840 
841 	return;
842 
843 retry:
844 	event_add(&bufev->ev_read, NULL);
845 	return;
846 
847 err:
848 	(*bufev->errorcb)(bufev, what, bufev->cbarg);
849 }
850 
851 static void
852 client_tls_writecb(int fd, short event, void *d)
853 {
854 	struct bufferevent	*bufev = d;
855 	struct client		*client = bufev->cbarg;
856 	ssize_t			 ret;
857 	size_t			 len;
858 	short			 what = EVBUFFER_WRITE;
859 
860 	if (event == EV_TIMEOUT) {
861 		what |= EVBUFFER_TIMEOUT;
862 		goto err;
863 	}
864 
865 	if (EVBUFFER_LENGTH(bufev->output) != 0) {
866 		ret = tls_write(client->ctx,
867 		    EVBUFFER_DATA(bufev->output),
868 		    EVBUFFER_LENGTH(bufev->output));
869 		switch (ret) {
870 		case TLS_WANT_POLLIN:
871 		case TLS_WANT_POLLOUT:
872 			goto retry;
873 		case -1:
874 			what |= EVBUFFER_ERROR;
875 			goto err;
876 		}
877 		len = ret;
878 		evbuffer_drain(bufev->output, len);
879 	}
880 
881 	if (EVBUFFER_LENGTH(bufev->output) != 0)
882 		event_add(&bufev->ev_write, NULL);
883 
884 	if (bufev->writecb != NULL &&
885 	    EVBUFFER_LENGTH(bufev->output) <= bufev->wm_write.low)
886 		(*bufev->writecb)(bufev, bufev->cbarg);
887 	return;
888 
889 retry:
890 	event_add(&bufev->ev_write, NULL);
891 	return;
892 
893 err:
894 	(*bufev->errorcb)(bufev, what, bufev->cbarg);
895 }
896 
897 static void
898 close_conn(struct client *c)
899 {
900 	log_debug("closing connection");
901 
902 	if (c->iev.ibuf.fd != -1) {
903 		listener_imsg_compose_client(c, IMSG_CONN_GONE, 0, NULL, 0);
904 		imsg_flush(&c->iev.ibuf);
905 		msgbuf_clear(&c->iev.ibuf.w);
906 		event_del(&c->iev.ev);
907 		close(c->iev.ibuf.fd);
908 	}
909 
910 	handle_close(c->fd, 0, c);
911 }
912 
913 static void
914 handle_close(int fd, short ev, void *d)
915 {
916 	struct client *c = d;
917 
918 	switch (tls_close(c->ctx)) {
919 	case TLS_WANT_POLLIN:
920 		yield_r(c, handle_close);
921 		return;
922 	case TLS_WANT_POLLOUT:
923 		yield_w(c, handle_close);
924 		return;
925 	}
926 
927 	event_del(&c->event);
928 	tls_free(c->ctx);
929 	close(c->fd);
930 	free(c);
931 }