Commit Diff


commit - f62f088a360047e04fe68b45a49f197be74f18c2
commit + c8c36d05ae302e32016bc0f766333f02800a15eb
blob - 26e70062578727e59ff8485a44299160f1384e3b
blob + 18a8f5cc7ae4a5d0a1371eb62a70e606b9dfa0b3
--- thingsd/Makefile	
+++ thingsd/Makefile	
@@ -11,7 +11,7 @@ MANDIR?=	${PREFIX}/man/man
 
 LDADD =		-levent -ltls -lssl -lcrypto -lutil
 DPADD =		${LIBEVENT} ${LIBTLS} ${LIBSSL} ${LIBCRYPTO} ${LIBUTIL}
-#DEBUG=		-g -DDEBUG=0 -O0
+# DEBUG=		-g -O0 -DDEBUG=0
 CFLAGS +=	-Wall -I${.CURDIR}
 CFLAGS +=	-Wstrict-prototypes -Wmissing-prototypes
 CFLAGS +=	-Wmissing-declarations
blob - a1ea3ecef65fb0f17c25e9e9007a8e1897a4886b
blob + f62feecd9602215ff84c048994a6f14d472d75ee
--- thingsd/config.c	
+++ thingsd/config.c	
@@ -42,6 +42,15 @@
 
 extern enum privsep_procid privsep_process;
 
+int	 config_setsocks_tls(struct thingsd *, struct socket *);
+static int
+	config_settls(struct thingsd *, struct socket *,
+	    enum tls_config_type, const char *, uint8_t *, size_t);
+static int
+	config_gettls(struct thingsd *, struct socket_config *,
+	    struct tls_config *, const char *, uint8_t *, size_t,
+	    uint8_t **, size_t *);
+
 int
 config_init(struct thingsd *env)
 {
@@ -121,7 +130,7 @@ config_getsocks(struct thingsd *env, struct imsg *imsg
 }
 
 int
-config_setsocks(struct thingsd *env, struct socket *ts)
+config_setsocks(struct thingsd *env, struct socket *sock)
 {
 	struct privsep		*ps = env->thingsd_ps;
 	struct socket_config	 u;
@@ -131,7 +140,7 @@ config_setsocks(struct thingsd *env, struct socket *ts
 	unsigned int		 id, what;
 
 	/* setup socket in priv process */
-	if (sockets_privinit(ts) == -1)
+	if (sockets_privinit(sock) == -1)
 		return (-1);
 
 	for (id = 0; id < PROC_MAX; id++) {
@@ -140,7 +149,7 @@ config_setsocks(struct thingsd *env, struct socket *ts
 		if ((what & CONFIG_SOCKS) == 0 || id == privsep_process)
 			continue;
 
-		memcpy(&u, &ts->conf, sizeof(u));
+		memcpy(&u, &sock->conf, sizeof(u));
 
 		c = 0;
 		iov[c].iov_base = &u;
@@ -151,9 +160,9 @@ config_setsocks(struct thingsd *env, struct socket *ts
 			proc_range(ps, id, &n, &m);
 			for (n = 0; n < m; n++) {
 				/* send thing fd */
-				if (ts->fd == -1)
+				if (sock->fd == -1)
 					fd = -1;
-				else if ((fd = dup(ts->fd)) == -1)
+				else if ((fd = dup(sock->fd)) == -1)
 					return (-1);
 				if (proc_composev_imsg(ps, id, n,
 				    IMSG_CFG_SOCKS, -1, fd, iov,
@@ -170,17 +179,218 @@ config_setsocks(struct thingsd *env, struct socket *ts
 					return (-1);
 				}
 			}
+			/* Configure TLS if necessary. */
+			config_setsocks_tls(env, sock);
 		}
 	}
 
 	/* Close thing socket early to prevent fd exhaustion in thingsd. */
-	if (ts->fd != -1) {
-		close(ts->fd);
-		ts->fd = -1;
+	if (sock->fd != -1) {
+		close(sock->fd);
+		sock->fd = -1;
 	}
 	return (0);
 }
 
+static int
+config_settls(struct thingsd *env, struct socket *sock,
+    enum tls_config_type type, const char *label, uint8_t *data, size_t len)
+{
+	struct privsep		*ps = env->thingsd_ps;
+	struct socket_config	*sock_conf = &sock->conf;
+	struct tls_config	 tls;
+	struct iovec		 iov[2];
+	size_t			 c;
+
+	if (data == NULL || len == 0)
+		return (0);
+
+	DPRINTF("%s: sending tls %s for \"%s[%u]\" to %s fd %d", __func__,
+	    label, sock_conf->name, sock_conf->id, ps->ps_title[PROC_SOCKS],
+	    sock->fd);
+
+	memset(&tls, 0, sizeof(tls));
+	tls.id = sock_conf->id;
+	tls.tls_type = type;
+	tls.tls_len = len;
+	tls.tls_chunk_offset = 0;
+
+	while (len > 0) {
+		tls.tls_chunk_len = len;
+		if (tls.tls_chunk_len > (MAX_IMSG_DATA_SIZE - sizeof(tls)))
+			tls.tls_chunk_len = MAX_IMSG_DATA_SIZE - sizeof(tls);
+
+		c = 0;
+		iov[c].iov_base = &tls;
+		iov[c++].iov_len = sizeof(tls);
+		iov[c].iov_base = data;
+		iov[c++].iov_len = tls.tls_chunk_len;
+
+		if (proc_composev(ps, PROC_SOCKS, IMSG_CFG_TLS, iov, c) != 0) {
+			log_warn("%s: failed to compose IMSG_CFG_TLS imsg for "
+			    "`%s'", __func__, sock_conf->name);
+			return (-1);
+		}
+
+		tls.tls_chunk_offset += tls.tls_chunk_len;
+		data += tls.tls_chunk_len;
+		len -= tls.tls_chunk_len;
+	}
+
+	return (0);
+}
+
+int
+config_setsocks_tls(struct thingsd *env, struct socket *sock)
+{
+	struct socket_config	*sock_conf = &sock->conf;
+
+	if (sock_conf->tls == 0)
+		return (0);
+
+	log_debug("%s: configuring tls for %s", __func__, sock_conf->name);
+
+	if (config_settls(env, sock, TLS_CFG_CA, "ca", sock_conf->tls_ca,
+	    sock_conf->tls_ca_len) != 0)
+		return (-1);
+
+	if (config_settls(env, sock, TLS_CFG_CERT, "cert", sock_conf->tls_cert,
+	    sock_conf->tls_cert_len) != 0)
+		return (-1);
+
+	if (config_settls(env, sock, TLS_CFG_CRL, "crl", sock_conf->tls_crl,
+	    sock_conf->tls_crl_len) != 0)
+		return (-1);
+
+	if (config_settls(env, sock, TLS_CFG_KEY, "key", sock_conf->tls_key,
+	    sock_conf->tls_key_len) != 0)
+		return (-1);
+
+	if (config_settls(env, sock, TLS_CFG_OCSP_STAPLE, "ocsp staple",
+	    sock_conf->tls_ocsp_staple, sock_conf->tls_ocsp_staple_len) != 0)
+		return (-1);
+
+	return (0);
+}
+
+static int
+config_gettls(struct thingsd *env, struct socket_config *sock_conf,
+    struct tls_config *tls_conf, const char *label, uint8_t *data, size_t len,
+    uint8_t **outdata, size_t *outlen)
+{
+#ifdef DEBUG
+	struct privsep		*ps = env->thingsd_ps;
+#endif
+
+	DPRINTF("%s: %s %d getting tls %s (%zu:%zu@%zu) for \"%s[%u]\"",
+	    __func__, ps->ps_title[privsep_process], ps->ps_instance, label,
+	    tls_conf->tls_len, len, tls_conf->tls_chunk_offset, sock_conf->name,
+	    sock_conf->id);
+
+	if (tls_conf->tls_chunk_offset == 0) {
+		*outdata = NULL;
+		free(*outdata);
+		*outlen = 0;
+		if ((*outdata = calloc(1, tls_conf->tls_len)) == NULL)
+			goto fail;
+		*outlen = tls_conf->tls_len;
+	}
+
+	if (*outdata == NULL) {
+		log_debug("%s: tls config invalid chunk sequence", __func__);
+		goto fail;
+	}
+
+	if (*outlen != tls_conf->tls_len) {
+		log_debug("%s: tls config length mismatch (%zu != %zu)",
+		    __func__, *outlen, tls_conf->tls_len);
+		goto fail;
+	}
+
+	if (len > (tls_conf->tls_len - tls_conf->tls_chunk_offset)) {
+		log_debug("%s: tls config invalid chunk length", __func__);
+		goto fail;
+	}
+
+	memcpy(*outdata + tls_conf->tls_chunk_offset, data, len);
+
+	return (0);
+
+ fail:
+	return (-1);
+}
+
+int
+config_getsocks_tls(struct thingsd *env, struct imsg *imsg)
+{
+	struct socket		*sock = NULL;
+	struct socket_config	*sock_conf;
+	struct tls_config	 tls_conf;
+	uint8_t			*p = imsg->data;
+	size_t			 len;
+
+	IMSG_SIZE_CHECK(imsg, &tls_conf);
+	memcpy(&tls_conf, p, sizeof(tls_conf));
+
+	len = tls_conf.tls_chunk_len;
+
+	if ((IMSG_DATA_SIZE(imsg) - sizeof(tls_conf)) < len) {
+		log_debug("%s: invalid message length", __func__);
+		goto fail;
+	}
+
+	p += sizeof(tls_conf);
+
+	sock = sockets_get_socket_byid(env, tls_conf.id);
+	if (sock == NULL)
+		return (0);
+
+	sock_conf = &sock->conf;
+
+	switch (tls_conf.tls_type) {
+	case TLS_CFG_CA:
+		if (config_gettls(env, sock_conf, &tls_conf, "ca", p, len,
+		    &sock_conf->tls_ca, &sock_conf->tls_ca_len) != 0)
+			goto fail;
+		break;
+
+	case TLS_CFG_CERT:
+		if (config_gettls(env, sock_conf, &tls_conf, "cert", p, len,
+		    &sock_conf->tls_cert, &sock_conf->tls_cert_len) != 0)
+			goto fail;
+		break;
+
+	case TLS_CFG_CRL:
+		if (config_gettls(env, sock_conf, &tls_conf, "crl", p, len,
+		    &sock_conf->tls_crl, &sock_conf->tls_crl_len) != 0)
+			goto fail;
+		break;
+
+	case TLS_CFG_KEY:
+		if (config_gettls(env, sock_conf, &tls_conf, "key", p, len,
+		    &sock_conf->tls_key, &sock_conf->tls_key_len) != 0)
+			goto fail;
+		break;
+
+	case TLS_CFG_OCSP_STAPLE:
+		if (config_gettls(env, sock_conf, &tls_conf, "ocsp staple",
+		    p, len, &sock_conf->tls_ocsp_staple,
+		    &sock_conf->tls_ocsp_staple_len) != 0)
+			goto fail;
+		break;
+
+	default:
+		log_debug("%s: unknown tls config type %i\n",
+		     __func__, tls_conf.tls_type);
+		goto fail;
+	}
+
+	return (0);
+
+ fail:
+	return (-1);
+}
+
 void
 config_purge(struct thingsd *env, unsigned int reset)
 {
blob - 85c6c39ab1e6d1004dca46029c5c57a37ded528a
blob + 6d673260c2f6e9676ee0e8c5410ce40a64ca4119
--- thingsd/sockets.c	
+++ thingsd/sockets.c	
@@ -34,6 +34,7 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include <tls.h>
 #include <unistd.h>
 
 #include "proc.h"
@@ -107,7 +108,7 @@ sockets_launch(void)
 		log_debug("%s: configuring thing listener %d (%d)", __func__,
 		    sock->conf.id, sock->fd);
 
-		/* socket_tls_init(sock); */
+		socket_tls_init(sock);
 
 		if ((sock->clients = calloc(1, sizeof(*sock->clients))) == NULL)
 			fatalx("%s: calloc", __func__);
@@ -277,6 +278,8 @@ sockets_dup_new_socket(struct socket *p_sock, struct s
 	    sizeof(sock->conf.tls_ecdhe_curves)) >=
 	    sizeof(sock->conf.tls_ecdhe_curves))
 		fatalx("%s: strlcpy", __func__);
+
+	socket_tls_load(sock);
 }
 
 struct socket *
@@ -712,6 +715,9 @@ sockets_dispatch_thingsd(int fd, struct privsep_proc *
 
 		config_getreset(thingsd_env, imsg);
 		break;
+	case IMSG_CFG_TLS:
+		config_getsocks_tls(thingsd_env, imsg);
+		break;
 	case IMSG_CTL_VERBOSE:
 		IMSG_SIZE_CHECK(imsg, &verbose);
 		memcpy(&verbose, imsg->data, sizeof(verbose));
@@ -757,31 +763,32 @@ sockets_shutdown(void)
 {
 	struct socket		*sock = NULL, *tsock;
 	struct client		*client, *tclient;
-	/* struct subscription	*sub, *tsub; */
 
-
 	/* clean up sockets */
 	TAILQ_FOREACH_SAFE(sock, thingsd_env->sockets, entry, tsock) {
 		/* clean up clients */
 		TAILQ_FOREACH_SAFE(client, sock->clients, entry, tclient) {
-			if (client->bev != NULL)
-				bufferevent_disable(client->bev,
-				    EV_READ | EV_WRITE);
-			if (client->bev != NULL)
-				bufferevent_free(client->bev);
-
+			if (client->tls) {
+				if (event_initialized(&client->ev))
+					event_del(&client->ev);
+				tls_free(client->tls_ctx);
+			} else {
+				if (client->bev != NULL)
+					bufferevent_disable(client->bev,
+					    EV_READ | EV_WRITE);
+				if (client->bev != NULL)
+					bufferevent_free(client->bev);
+			}
 			close(client->fd);
 			TAILQ_REMOVE(sock->clients, client, entry);
 			free(client);
 		}
 
 		if (sock->conf.tls) {
-			/* tls_config_free(sock->tls_config); */
-			/* tls_free(sock->tls_ctx); */
-			/* free(sock->conf.tls_cert); */
-			/* free(sock->conf.tls_cert_file); */
-			/* free(sock->conf.tls_key); */
-			/* free(sock->conf.tls_key_file); */
+			tls_config_free(sock->tls_config);
+			tls_free(sock->tls_ctx);
+			free(sock->conf.tls_cert);
+			free(sock->conf.tls_key);
 			free(sock->conf.tls_ca);
 			free(sock->conf.tls_ca_file);
 			free(sock->conf.tls_crl);
@@ -789,7 +796,8 @@ sockets_shutdown(void)
 			free(sock->conf.tls_ocsp_staple);
 			free(sock->conf.tls_ocsp_staple_file);
 		}
-		event_del(&sock->ev);
+		if (event_initialized(&sock->ev))
+			event_del(&sock->ev);
 		evtimer_del(&sock->pause);
 		close(sock->fd);
 		TAILQ_REMOVE(thingsd_env->sockets, sock, entry);
@@ -898,14 +906,14 @@ sockets_socket_conn(int fd, short event, void *arg)
 	memset(&client->timeout, 0, sizeof(struct event));
 	evtimer_set(&client->timeout, sockets_client_sub_timeout, client);
 
-	/* if (sock->conf.tls) { */
-	/* 	if (tls_accept_socket(sock->tls_ctx, &client->tls_ctx, */
-	/* 	    client_fd) == -1) { */
-	/* 		log_warnx("tls accept failed: %s", */
-	/* 		    tls_error(sock->tls_ctx)); */
-	/* 		goto err; */
-	/* 	} */
-	/* } */
+	if (sock->conf.tls) {
+		if (tls_accept_socket(sock->tls_ctx, &client->tls_ctx,
+		    client_fd) == -1) {
+			log_warnx("tls accept failed: %s",
+			    tls_error(sock->tls_ctx));
+			goto err;
+		}
+	}
 
 	client->packages = calloc(1, sizeof(*client->packages));
 	if (client->packages == NULL)
@@ -913,8 +921,6 @@ sockets_socket_conn(int fd, short event, void *arg)
 
 	TAILQ_INIT(client->packages);
 
-	/* sock->client_cnt++; */
-
 	if (sock->conf.max_clients > 0)
 		if (sock->client_cnt > sock->conf.max_clients) {
 			log_debug("%s: listener %d max clients reached",
@@ -939,14 +945,14 @@ sockets_socket_conn(int fd, short event, void *arg)
 	client->fd = client_fd;
 	client->join_time = time(NULL);
 
-	/* if (sock->conf.tls) { */
-	/* 	client->tls = 1; */
-	/* 	event_del(&client->ev); */
-	/* 	event_set(&client->ev, client->fd, EV_READ | EV_PERSIST, */
-	/* 	    socket_tls_handshake, env); */
-	/* 	event_add(&client->ev, NULL); */
-	/* 	return; */
-	/* } */
+	if (sock->conf.tls) {
+		client->tls = 1;
+		event_del(&client->ev);
+		event_set(&client->ev, client->fd, EV_READ | EV_PERSIST,
+		    socket_tls_handshake, client);
+		event_add(&client->ev, NULL);
+		goto done;
+	}
 
 	client->bev = bufferevent_new(client->fd, clientrd, clientwr,
 	    client_err, client);
@@ -964,7 +970,7 @@ sockets_socket_conn(int fd, short event, void *arg)
 	bufferevent_setwatermark(client->bev, EV_READ, 0, PKT_BUFF);
 	bufferevent_enable(client->bev, EV_READ|EV_WRITE);
 	TAILQ_INSERT_TAIL(sock->clients, client, entry);
-
+done:
 	log_debug("%s: client connected (%d)", __func__, client->fd);
 	return;
 err:
@@ -975,8 +981,8 @@ err2:
 	if (client_fd != -1)
 		close(client_fd);
 	if (client != NULL) {
-		/* if (sock->conf.tls) */
-		/* 	tls_free(client->tls_ctx); */
+		if (sock->conf.tls)
+			tls_free(client->tls_ctx);
 		free(client);
 	}
 }
blob - 80d2d2ca61cda90faec7101093c25fc2d09345e7
blob + cb467c736b20c390bdde15a8d171302e89742419
--- thingsd/thingsd.h	
+++ thingsd/thingsd.h	
@@ -60,6 +60,8 @@
 
 #define PKT_BUFF		 2048
 
+#define MAX_IMSG_DATA_SIZE	(MAX_IMSGSIZE - IMSG_HEADER_SIZE)
+
 enum imsg_type {
 	IMSG_GET_INFO_THINGSD_REQUEST = IMSG_PROC_MAX,
 	IMSG_GET_INFO_THINGSD_DATA,
@@ -93,6 +95,7 @@ enum imsg_type {
 	IMSG_CFG_DONE,
 
 	IMSG_CFG_SOCKS,
+	IMSG_CFG_TLS,
 	IMSG_DIST_THING_PACKAGE,
 	IMSG_DIST_CLIENT_PACKAGE,
 };
@@ -222,6 +225,23 @@ struct socket_config {
 	uint32_t		 tls_protocols;
 };
 
+enum tls_config_type {
+	TLS_CFG_CA,
+	TLS_CFG_CERT,
+	TLS_CFG_CRL,
+	TLS_CFG_KEY,
+	TLS_CFG_OCSP_STAPLE,
+};
+
+struct tls_config {
+	uint32_t		 id;
+
+	enum tls_config_type	 tls_type;
+	size_t			 tls_len;
+	size_t			 tls_chunk_len;
+	size_t			 tls_chunk_offset;
+};
+
 struct socket {
 	TAILQ_ENTRY(socket)	 entry;
 	struct clientlist	*clients;
@@ -419,6 +439,7 @@ int	 config_getreset(struct thingsd *, struct imsg *);
 int	 config_setsocks(struct thingsd *, struct socket *);
 int	 config_getsocks(struct thingsd *, struct imsg *);
 int	 config_getcfg(struct thingsd *, struct imsg *);
+int	 config_getsocks_tls(struct thingsd *, struct imsg *);
 
 /* parse.y */
 int	 parse_config(const char *, struct thingsd *);
blob - 0260b0e56c5d835ba95fb7a3de1805d693e00a11
blob + 9363c450d62ab00679b8c5fa4dfc7cf49846a4bb
--- thingsd/tls.c	
+++ thingsd/tls.c	
@@ -43,20 +43,16 @@ tls_load_keypair(struct socket *sock)
 	if (sock->conf.tls == 0)
 		return (0);
 
-	sock->conf.tls_cert = tls_load_file(sock->conf.tls_cert_file,
-	    &sock->conf.tls_cert_len, NULL);
-	if (sock->conf.tls_cert == NULL)
+	if ((sock->conf.tls_cert = tls_load_file(sock->conf.tls_cert_file,
+	    &sock->conf.tls_cert_len, NULL)) == NULL)
 		return (-1);
-
 	log_debug("%s: using certificate %s", __func__,
 	    sock->conf.tls_cert_file);
 
 	/* XXX allow to specify password for encrypted key */
-	sock->conf.tls_key = tls_load_file(sock->conf.tls_key_file,
-	    &sock->conf.tls_key_len, NULL);
-	if (sock->conf.tls_key == NULL)
+	if ((sock->conf.tls_key = tls_load_file(sock->conf.tls_key_file,
+	    &sock->conf.tls_key_len, NULL)) == NULL)
 		return (-1);
-
 	log_debug("%s: using private key %s", __func__,
 	    sock->conf.tls_key_file);
 
@@ -70,11 +66,10 @@ tls_load_ca(struct socket *sock)
 	    sock->conf.tls_ca_file == NULL)
 		return (0);
 
-	sock->conf.tls_ca = tls_load_file(sock->conf.tls_ca_file,
-	    &sock->conf.tls_ca_len, NULL);
-	if (sock->conf.tls_ca == NULL)
+	if ((sock->conf.tls_ca = tls_load_file(
+	    sock->conf.tls_ca_file,
+	    &sock->conf.tls_ca_len, NULL)) == NULL)
 		return (-1);
-
 	log_debug("%s: using ca cert(s) from %s", __func__,
 	    sock->conf.tls_ca_file);
 
@@ -90,10 +85,9 @@ tls_load_ocsp(struct socket *sock)
 	if (sock->conf.tls_ocsp_staple_file == NULL)
 		return (0);
 
-	sock->conf.tls_ocsp_staple = tls_load_file(
+	if ((sock->conf.tls_ocsp_staple = tls_load_file(
 	    sock->conf.tls_ocsp_staple_file,
-	    &sock->conf.tls_ocsp_staple_len, NULL);
-	if (sock->conf.tls_ocsp_staple == NULL) {
+	    &sock->conf.tls_ocsp_staple_len, NULL)) == NULL) {
 		log_warnx("%s: Failed to load ocsp staple from %s", __func__,
 		    sock->conf.tls_ocsp_staple_file);
 		return (-1);
@@ -118,11 +112,10 @@ tls_load_crl(struct socket *sock)
 	    sock->conf.tls_crl_file == NULL)
 		return (0);
 
-	sock->conf.tls_crl = tls_load_file(sock->conf.tls_crl_file,
-	    &sock->conf.tls_crl_len, NULL);
-	if (sock->conf.tls_crl == NULL)
+	if ((sock->conf.tls_crl = tls_load_file(
+	    sock->conf.tls_crl_file,
+	    &sock->conf.tls_crl_len, NULL)) == NULL)
 		return (-1);
-
 	log_debug("%s: using crl(s) from %s", __func__,
 	    sock->conf.tls_crl_file);
 
@@ -142,50 +135,44 @@ socket_tls_init(struct socket *sock)
 		 */
 		return (-1);
 
-	log_debug("%s: initializing tls for %d", __func__, sock->conf.id);
+	log_debug("%s: initializing tls for listener %d", __func__,
+	    sock->conf.id);
 
 	if (tls_init() != 0) {
 		log_warnx("%s: failed to initialise tls", __func__);
 		return (-1);
 	}
-
-	sock->tls_config = tls_config_new();
-	if (sock->tls_config == NULL) {
+	if ((sock->tls_config = tls_config_new()) == NULL) {
 		log_warnx("%s: failed to get tls config", __func__);
 		return (-1);
 	}
-
-	sock->tls_ctx = tls_server();
-	if (sock->tls_ctx == NULL) {
+	if ((sock->tls_ctx = tls_server()) == NULL) {
 		log_warnx("%s: failed to get tls server", __func__);
 		return (-1);
 	}
 
 	if (tls_config_set_protocols(sock->tls_config,
 	    sock->conf.tls_protocols) != 0) {
-		log_warnx("%s: failed to set tls protocols: %s", __func__,
-		    tls_config_error(sock->tls_config));
+		log_warnx("%s: failed to set tls protocols: %s",
+		    __func__, tls_config_error(sock->tls_config));
 		return (-1);
 	}
-
 	if (tls_config_set_ciphers(sock->tls_config,
 	    sock->conf.tls_ciphers) != 0) {
-		log_warnx("%s: failed to set tls ciphers: %s", __func__,
-		    tls_config_error(sock->tls_config));
+		log_warnx("%s: failed to set tls ciphers: %s",
+		    __func__, tls_config_error(sock->tls_config));
 		return (-1);
 	}
-
 	if (tls_config_set_dheparams(sock->tls_config,
 	    sock->conf.tls_dhe_params) != 0) {
-		log_warnx("%s: failed to set tls dhe params: %s", __func__,
-		    tls_config_error(sock->tls_config));
+		log_warnx("%s: failed to set tls dhe params: %s",
+		    __func__, tls_config_error(sock->tls_config));
 		return (-1);
 	}
-
 	if (tls_config_set_ecdhecurves(sock->tls_config,
 	    sock->conf.tls_ecdhe_curves) != 0) {
-		log_warnx("%s: failed to set tls ecdhe curves: %s", __func__,
-		    tls_config_error(sock->tls_config));
+		log_warnx("%s: failed to set tls ecdhe curves: %s",
+		    __func__, tls_config_error(sock->tls_config));
 		return (-1);
 	}
 
@@ -194,32 +181,30 @@ socket_tls_init(struct socket *sock)
 	    sock->conf.tls_key, sock->conf.tls_key_len,
 	    sock->conf.tls_ocsp_staple,
 	    sock->conf.tls_ocsp_staple_len) != 0) {
-		log_warnx("%s: failed to set tls certificate/key: %s", __func__,
-		    tls_config_error(sock->tls_config));
+		log_warnx("%s: failed to set tls certificate/key: %s",
+		    __func__, tls_config_error(sock->tls_config));
 		return (-1);
 	}
 
 	if (sock->conf.tls_ca != NULL) {
-		if (tls_config_set_ca_mem(sock->tls_config, sock->conf.tls_ca,
-			sock->conf.tls_ca_len) != 0) {
+		if (tls_config_set_ca_mem(sock->tls_config,
+		    sock->conf.tls_ca, sock->conf.tls_ca_len) != 0) {
 			log_warnx("%s: failed to add ca cert(s)", __func__);
 			return (-1);
 		}
-
 		if (tls_config_set_crl_mem(sock->tls_config,
 		    sock->conf.tls_crl, sock->conf.tls_crl_len) != 0) {
 			log_warnx("%s: failed to add crl(s)", __func__);
 			return (-1);
 		}
-
 		if (sock->conf.tls_flags & TLSFLAG_OPTIONAL)
 			tls_config_verify_client_optional(sock->tls_config);
 		else
 			tls_config_verify_client(sock->tls_config);
 	}
 
-	/* log_debug("%s: adding keypair for server %s", __func__, */
-	/*     sock->conf.name); */
+	log_debug("%s: adding keypair for listener %s", __func__,
+	    sock->conf.name);
 
 	if (tls_config_add_keypair_ocsp_mem(sock->tls_config,
 	    sock->conf.tls_cert, sock->conf.tls_cert_len,
@@ -254,49 +239,40 @@ socket_tls_init(struct socket *sock)
 	sock->conf.tls_crl_len = 0;
 	sock->conf.tls_key_len = 0;
 
-	return 0;
+	return (0);
 }
 
 void
 socket_tls_handshake(int fd, short event, void *arg)
 {
-	/* struct thingsd		*thingsd = (struct thingsd *)arg; */
-	/* struct client		*client = NULL, *tclient; */
-	/* ssize_t			 ret = 0; */
+	struct client		*client = (struct client *)arg;
+	ssize_t			 ret = 0;
 
-	/* TAILQ_FOREACH(tclient, thingsd->clients, entry) { */
-	/* 	if (tclient->fd == fd) { */
-	/* 		client = tclient; */
-	/* 		break; */
-	/* 	} */
-	/* } */
+	if (client == NULL)
+		return;
 
-	/* if (client == NULL) */
-	/* 	return; */
+	ret = tls_handshake(client->tls_ctx);
 
-	/* ret = tls_handshake(client->tls_ctx); */
-
-	/* if (ret == 0) { */
-	/* 	event_del(client->ev); */
-	/* 	log_debug("%s: tls handshake success", __func__); */
-	/* 	/1* client_add(thingsd, client); *1/ */
-	/* } else if (ret == TLS_WANT_POLLIN) { */
-	/* 	event_del(client->ev); */
-	/* 	event_set(client->ev, client->fd, EV_READ|EV_PERSIST, */
-	/* 		    socket_tls_handshake, thingsd); */
-	/* 	if (event_add(client->ev, NULL)) */
-	/* 		log_debug("%s: event add client", __func__); */
-	/* } else if (ret == TLS_WANT_POLLOUT) { */
-	/* 	event_del(client->ev); */
-	/* 	event_set(client->ev, client->fd, EV_WRITE|EV_PERSIST, */
-	/* 		    socket_tls_handshake, thingsd); */
-	/* 	if (event_add(client->ev, NULL)) */
-	/* 		log_debug("%s: event add client", __func__); */
-	/* } else { */
-	/* 	event_del(client->ev); */
-	/* 	log_debug("%s: tls handshake failed - %s", __func__, */
-	/* 	    tls_error(client->tls_ctx)); */
-	/* } */
+	if (ret == 0) {
+		event_del(&client->ev);
+		log_debug("%s: tls handshake success", __func__);
+	} else if (ret == TLS_WANT_POLLIN) {
+		event_del(&client->ev);
+		event_set(&client->ev, client->fd, EV_READ|EV_PERSIST,
+			    socket_tls_handshake, client);
+		if (event_add(&client->ev, NULL))
+			log_debug("%s: event add client", __func__);
+	} else if (ret == TLS_WANT_POLLOUT) {
+		event_del(&client->ev);
+		event_set(&client->ev, client->fd, EV_WRITE|EV_PERSIST,
+			    socket_tls_handshake, client);
+		if (event_add(&client->ev, NULL))
+			log_debug("%s: event add client", __func__);
+	} else {
+		event_del(&client->ev);
+		log_debug("%s: tls handshake failed - %s", __func__,
+		    tls_error(client->tls_ctx));
+	}
 }
 
 void