Give up on uncrustify; switch to clang-format.

26 files changed, 537 insertions, 746 deletions

diff --git a/src/platform/posix/posix_aio.h b/src/platform/posix/posix_aio.h
index 13559c08..60594152 100644
--- a/src/platform/posix/posix_aio.h
+++ b/src/platform/posix/posix_aio.h
@@ -18,26 +18,25 @@
 
 #include "core/nng_impl.h"
 
-typedef struct nni_posix_pollq		nni_posix_pollq;
+typedef struct nni_posix_pollq nni_posix_pollq;
 
+typedef struct nni_posix_pipedesc nni_posix_pipedesc;
+typedef struct nni_posix_epdesc   nni_posix_epdesc;
 
-typedef struct nni_posix_pipedesc	nni_posix_pipedesc;
-typedef struct nni_posix_epdesc		nni_posix_epdesc;
-
-extern int nni_posix_pipedesc_init(nni_posix_pipedesc **, int);
+extern int  nni_posix_pipedesc_init(nni_posix_pipedesc **, int);
 extern void nni_posix_pipedesc_fini(nni_posix_pipedesc *);
 extern void nni_posix_pipedesc_recv(nni_posix_pipedesc *, nni_aio *);
 extern void nni_posix_pipedesc_send(nni_posix_pipedesc *, nni_aio *);
 extern void nni_posix_pipedesc_close(nni_posix_pipedesc *);
 
-extern int nni_posix_epdesc_init(nni_posix_epdesc **, const char *);
+extern int         nni_posix_epdesc_init(nni_posix_epdesc **, const char *);
 extern const char *nni_posix_epdesc_url(nni_posix_epdesc *);
-extern void nni_posix_epdesc_set_local(nni_posix_epdesc *, void *, int);
+extern void        nni_posix_epdesc_set_local(nni_posix_epdesc *, void *, int);
 extern void nni_posix_epdesc_set_remote(nni_posix_epdesc *, void *, int);
 extern void nni_posix_epdesc_fini(nni_posix_epdesc *);
 extern void nni_posix_epdesc_close(nni_posix_epdesc *);
 extern void nni_posix_epdesc_connect(nni_posix_epdesc *, nni_aio *);
-extern int nni_posix_epdesc_listen(nni_posix_epdesc *);
+extern int  nni_posix_epdesc_listen(nni_posix_epdesc *);
 extern void nni_posix_epdesc_accept(nni_posix_epdesc *, nni_aio *);
 
 #endif // PLATFORM_POSIX_AIO_H
diff --git a/src/platform/posix/posix_alloc.c b/src/platform/posix/posix_alloc.c
index aef5bbfc..a3cd29b9 100644
--- a/src/platform/posix/posix_alloc.c
+++ b/src/platform/posix/posix_alloc.c
@@ -20,7 +20,6 @@ nni_alloc(size_t sz)
 	return (calloc(1, sz));
 }
 
-
 void
 nni_free(void *ptr, size_t size)
 {
@@ -28,7 +27,6 @@ nni_free(void *ptr, size_t size)
 	free(ptr);
 }
 
-
 #else
 
 // Suppress empty symbols warnings in ranlib.
diff --git a/src/platform/posix/posix_clock.c b/src/platform/posix/posix_clock.c
index c87fb890..93e0978c 100644
--- a/src/platform/posix/posix_clock.c
+++ b/src/platform/posix/posix_clock.c
@@ -12,9 +12,9 @@
 
 #ifdef PLATFORM_POSIX_CLOCK
 
-#include <time.h>
 #include <errno.h>
 #include <string.h>
+#include <time.h>
 
 #ifndef NNG_USE_GETTIMEOFDAY
 
@@ -23,7 +23,7 @@ nni_time
 nni_plat_clock(void)
 {
 	struct timespec ts;
-	nni_time usec;
+	nni_time        usec;
 
 	if (clock_gettime(NNG_USE_CLOCKID, &ts) != 0) {
 		/* This should never ever occur. */
@@ -36,13 +36,12 @@ nni_plat_clock(void)
 	return (usec);
 }
 
-
 void
 nni_plat_usleep(nni_duration usec)
 {
 	struct timespec ts;
 
-	ts.tv_sec = usec / 1000000;
+	ts.tv_sec  = usec / 1000000;
 	ts.tv_nsec = (usec % 1000000) * 1000;
 
 	/* Do this in a loop, so that interrupts don't actually wake us. */
@@ -53,8 +52,7 @@ nni_plat_usleep(nni_duration usec)
 	}
 }
 
-
-#else   // NNG_USE_GETTIMEOFDAY
+#else // NNG_USE_GETTIMEOFDAY
 
 // If you're here, its because you don't have a modern clock_gettime with
 // monotonic clocks, or the necessary pthread_condattr_settclock().  In
@@ -65,9 +63,9 @@ nni_plat_usleep(nni_duration usec)
 // but if you change the clock by a large amount you might wonder what the
 // heck is happening until it does.)
 
+#include <poll.h>
 #include <pthread.h>
 #include <sys/time.h>
-#include <poll.h>
 
 nni_time
 nni_plat_clock(void)
@@ -86,7 +84,6 @@ nni_plat_clock(void)
 	return (usec);
 }
 
-
 void
 nni_plat_usleep(nni_duration usec)
 {
@@ -99,16 +96,16 @@ nni_plat_usleep(nni_duration usec)
 	// So we can use poll() instead, which is rather coarse, but
 	// pretty much guaranteed to work.
 	struct pollfd pfd;
-	nni_time now;
-	nni_time expire;
+	nni_time      now;
+	nni_time      expire;
 
 	// Possibly we could pass NULL instead of pfd, but passing a valid
 	// pointer ensures that if the system dereferences the pointer it
 	// won't come back with EFAULT.
-	pfd.fd = -1;
+	pfd.fd     = -1;
 	pfd.events = 0;
 
-	now = nni_clock();
+	now    = nni_clock();
 	expire = now + usec;
 
 	while (now < expire) {
@@ -122,12 +119,11 @@ nni_plat_usleep(nni_duration usec)
 	}
 }
 
-
-#endif  // NNG_USE_GETTIMEOFDAY
+#endif // NNG_USE_GETTIMEOFDAY
 
 #else
 
 // Suppress empty symbols warnings in ranlib.
 int nni_posix_clock_not_used = 0;
 
-#endif  // PLATFORM_POSIX_CLOCK
+#endif // PLATFORM_POSIX_CLOCK
diff --git a/src/platform/posix/posix_config.h b/src/platform/posix/posix_config.h
index 7e82a050..8ed6387c 100644
--- a/src/platform/posix/posix_config.h
+++ b/src/platform/posix/posix_config.h
@@ -49,18 +49,18 @@
 // exists but has somehow very very different semantics.  We don't know
 // of any such concerns.)  This won't be used if any of the other options
 // are defined and work.
-#define NNG_USE_DEVURANDOM	1
+#define NNG_USE_DEVURANDOM 1
 
-#define NNG_USE_CLOCKID		CLOCK_REALTIME
+#define NNG_USE_CLOCKID CLOCK_REALTIME
 #ifndef CLOCK_REALTIME
 #define NNG_USE_GETTIMEOFDAY
 #elif !defined(NNG_USE_CLOCKID)
-#define NNG_USE_CLOCKID			CLOCK_MONOTONIC
+#define NNG_USE_CLOCKID CLOCK_MONOTONIC
 #else
-#define NNG_USE_CLOCKID			CLOCK_REALTIME
-#endif  // CLOCK_REALTIME
+#define NNG_USE_CLOCKID CLOCK_REALTIME
+#endif // CLOCK_REALTIME
 
-#define NNG_USE_POSIX_POLLQ_POLL	1
-#define NNG_USE_POSIX_RESOLV_GAI	1
+#define NNG_USE_POSIX_POLLQ_POLL 1
+#define NNG_USE_POSIX_RESOLV_GAI 1
 
 #endif // PLATFORM_POSIX
diff --git a/src/platform/posix/posix_debug.c b/src/platform/posix/posix_debug.c
index b9321ea5..647d93ff 100644
--- a/src/platform/posix/posix_debug.c
+++ b/src/platform/posix/posix_debug.c
@@ -12,8 +12,8 @@
 #ifdef PLATFORM_POSIX_DEBUG
 
 #include <errno.h>
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
 void
@@ -22,7 +22,6 @@ nni_plat_abort(void)
 	abort();
 }
 
-
 void
 nni_plat_println(const char *message)
 {
@@ -30,7 +29,6 @@ nni_plat_println(const char *message)
 	fputc('\n', stderr);
 }
 
-
 const char *
 nni_plat_strerror(int errnum)
 {
@@ -40,7 +38,6 @@ nni_plat_strerror(int errnum)
 	return (strerror(errnum));
 }
 
-
 // There are of course other errors than these, but these are the ones
 // that we might reasonably expect and want to handle "cleanly".  Most of
 // the others should be handled by the system error code.  Note that EFAULT
@@ -50,10 +47,10 @@ nni_plat_strerror(int errnum)
 // error codes should exist, and be distinct positive numbers. (EWOULDBLOCK
 // and EAGAIN are permitted to have the same value.)
 static struct {
-	int	posix_err;
-	int	nng_err;
-}
-nni_plat_errnos[] = {
+	int posix_err;
+	int nng_err;
+} nni_plat_errnos[] = {
+	// clang-format off
 	{ EINTR,	   NNG_EINTR	    },
 	{ EINVAL,	   NNG_EINVAL	    },
 	{ ENOMEM,	   NNG_ENOMEM	    },
@@ -86,6 +83,7 @@ nni_plat_errnos[] = {
 	{ EWOULDBLOCK,	   NNG_EAGAIN	    },
 	// must be last
 	{		0,		  0 },
+	// clang-format on
 };
 
 int
@@ -108,7 +106,6 @@ nni_plat_errno(int errnum)
 	return (NNG_ESYSERR + errnum);
 }
 
-
 #else
 
 // Suppress empty symbols warnings in ranlib.
diff --git a/src/platform/posix/posix_epdesc.c b/src/platform/posix/posix_epdesc.c
index 77662ddd..a6de29e1 100644
--- a/src/platform/posix/posix_epdesc.c
+++ b/src/platform/posix/posix_epdesc.c
@@ -14,38 +14,37 @@
 #include "platform/posix/posix_pollq.h"
 
 #include <errno.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <poll.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/types.h>
 #include <sys/socket.h>
+#include <sys/types.h>
 #include <sys/uio.h>
 #include <sys/un.h>
-#include <fcntl.h>
 #include <unistd.h>
-#include <poll.h>
-#include <netdb.h>
 
-#ifdef  SOCK_CLOEXEC
-#define NNI_STREAM_SOCKTYPE	(SOCK_STREAM | SOCK_CLOEXEC)
+#ifdef SOCK_CLOEXEC
+#define NNI_STREAM_SOCKTYPE (SOCK_STREAM | SOCK_CLOEXEC)
 #else
-#define NNI_STREAM_SOCKTYPE	SOCK_STREAM
+#define NNI_STREAM_SOCKTYPE SOCK_STREAM
 #endif
 
 struct nni_posix_epdesc {
-	int			fd;
-	nni_list		connectq;
-	nni_list		acceptq;
-	nni_posix_pollq_node	node;
-	nni_posix_pollq *	pq;
+	int                     fd;
+	nni_list                connectq;
+	nni_list                acceptq;
+	nni_posix_pollq_node    node;
+	nni_posix_pollq *       pq;
 	struct sockaddr_storage locaddr;
 	struct sockaddr_storage remaddr;
-	socklen_t		loclen;
-	socklen_t		remlen;
-	const char *		url;
-	nni_mtx			mtx;
+	socklen_t               loclen;
+	socklen_t               remlen;
+	const char *            url;
+	nni_mtx                 mtx;
 };
 
-
 static void
 nni_posix_epdesc_cancel(nni_aio *aio)
 {
@@ -56,11 +55,10 @@ nni_posix_epdesc_cancel(nni_aio *aio)
 	nni_mtx_unlock(&ed->mtx);
 }
 
-
 static void
 nni_posix_epdesc_finish(nni_aio *aio, int rv, int newfd)
 {
-	nni_posix_epdesc *ed = aio->a_prov_data;
+	nni_posix_epdesc *  ed = aio->a_prov_data;
 	nni_posix_pipedesc *pd;
 
 	// acceptq or connectq.
@@ -78,13 +76,12 @@ nni_posix_epdesc_finish(nni_aio *aio, int rv, int newfd)
 	nni_aio_finish(aio, rv, 0);
 }
 
-
 static void
 nni_posix_epdesc_doconnect(nni_posix_epdesc *ed)
 {
-	nni_aio *aio;
+	nni_aio * aio;
 	socklen_t sz;
-	int rv;
+	int       rv;
 
 	// Note that normally there will only be a single connect AIO...
 	// A socket that is here will have *initiated* with a connect()
@@ -94,7 +91,7 @@ nni_posix_epdesc_doconnect(nni_posix_epdesc *ed)
 	// status of the connection attempt...
 	while ((aio = nni_list_first(&ed->connectq)) != NULL) {
 		rv = -1;
-		sz = sizeof (rv);
+		sz = sizeof(rv);
 		if (getsockopt(ed->fd, SOL_SOCKET, SO_ERROR, &rv, &sz) < 0) {
 			rv = errno;
 		}
@@ -121,24 +118,22 @@ nni_posix_epdesc_doconnect(nni_posix_epdesc *ed)
 	}
 }
 
-
 static void
 nni_posix_epdesc_doaccept(nni_posix_epdesc *ed)
 {
-	nni_aio *aio;
-	int newfd;
+	nni_aio *               aio;
+	int                     newfd;
 	struct sockaddr_storage ss;
-	socklen_t slen;
+	socklen_t               slen;
 
 	while ((aio = nni_list_first(&ed->acceptq)) != NULL) {
-		// We could argue that knowing the remote peer address would
-		// be nice.  But frankly if someone wants it, they can just
-		// do getpeername().
+// We could argue that knowing the remote peer address would
+// be nice.  But frankly if someone wants it, they can just
+// do getpeername().
 
 #ifdef NNG_USE_ACCEPT4
 		newfd = accept4(ed->fd, NULL, NULL, SOCK_CLOEXEC);
-		if ((newfd < 0) &&
-		    ((errno == ENOSYS) || (errno == ENOTSUP))) {
+		if ((newfd < 0) && ((errno == ENOSYS) || (errno == ENOTSUP))) {
 			newfd = accept(ed->fd, NULL, NULL);
 		}
 #else
@@ -172,13 +167,12 @@ nni_posix_epdesc_doaccept(nni_posix_epdesc *ed)
 	}
 }
 
-
 static void
 nni_posix_epdesc_doerror(nni_posix_epdesc *ed)
 {
-	nni_aio *aio;
-	int rv = 1;
-	socklen_t sz = sizeof (rv);
+	nni_aio * aio;
+	int       rv = 1;
+	socklen_t sz = sizeof(rv);
 
 	if (getsockopt(ed->fd, SOL_SOCKET, SO_ERROR, &rv, &sz) < 0) {
 		rv = errno;
@@ -196,11 +190,10 @@ nni_posix_epdesc_doerror(nni_posix_epdesc *ed)
 	}
 }
 
-
 static void
 nni_posix_epdesc_doclose(nni_posix_epdesc *ed)
 {
-	nni_aio *aio;
+	nni_aio *           aio;
 	struct sockaddr_un *sun;
 
 	if (ed->fd != -1) {
@@ -220,7 +213,6 @@ nni_posix_epdesc_doclose(nni_posix_epdesc *ed)
 	}
 }
 
-
 static void
 nni_posix_epdesc_cb(void *arg)
 {
@@ -234,14 +226,14 @@ nni_posix_epdesc_cb(void *arg)
 	if (ed->node.revents & POLLOUT) {
 		nni_posix_epdesc_doconnect(ed);
 	}
-	if (ed->node.revents & (POLLERR|POLLHUP)) {
+	if (ed->node.revents & (POLLERR | POLLHUP)) {
 		nni_posix_epdesc_doerror(ed);
 	}
 	if (ed->node.revents & POLLNVAL) {
 		nni_posix_epdesc_doclose(ed);
 	}
 	ed->node.revents = 0;
-	ed->node.events = 0;
+	ed->node.events  = 0;
 
 	if (!nni_list_empty(&ed->connectq)) {
 		ed->node.events |= POLLOUT;
@@ -252,7 +244,6 @@ nni_posix_epdesc_cb(void *arg)
 	nni_mtx_unlock(&ed->mtx);
 }
 
-
 void
 nni_posix_epdesc_close(nni_posix_epdesc *ed)
 {
@@ -263,16 +254,15 @@ nni_posix_epdesc_close(nni_posix_epdesc *ed)
 	nni_mtx_unlock(&ed->mtx);
 }
 
-
 static int
 nni_posix_epdesc_parseaddr(char *pair, char **hostp, uint16_t *portp)
 {
 	char *host, *port, *end;
-	char c;
-	int val;
+	char  c;
+	int   val;
 
 	if (pair[0] == '[') {
-		host = pair+1;
+		host = pair + 1;
 		// IP address enclosed ... for IPv6 usually.
 		if ((end = strchr(host, ']')) == NULL) {
 			return (NNG_EADDRINVAL);
@@ -315,18 +305,17 @@ nni_posix_epdesc_parseaddr(char *pair, char **hostp, uint16_t *portp)
 	return (0);
 }
 
-
 int
 nni_posix_epdesc_listen(nni_posix_epdesc *ed)
 {
-	int len;
+	int                      len;
 	struct sockaddr_storage *ss;
-	int rv;
-	int fd;
+	int                      rv;
+	int                      fd;
 
 	nni_mtx_lock(&ed->mtx);
 
-	ss = &ed->locaddr;
+	ss  = &ed->locaddr;
 	len = ed->loclen;
 
 	if ((fd = socket(ss->ss_family, NNI_STREAM_SOCKTYPE, 0)) < 0) {
@@ -352,13 +341,12 @@ nni_posix_epdesc_listen(nni_posix_epdesc *ed)
 
 	(void) fcntl(fd, F_SETFL, O_NONBLOCK);
 
-	ed->fd = fd;
+	ed->fd      = fd;
 	ed->node.fd = fd;
 	nni_mtx_unlock(&ed->mtx);
 	return (0);
 }
 
-
 void
 nni_posix_epdesc_accept(nni_posix_epdesc *ed, nni_aio *aio)
 {
@@ -394,7 +382,6 @@ nni_posix_epdesc_accept(nni_posix_epdesc *ed, nni_aio *aio)
 	nni_mtx_unlock(&ed->mtx);
 }
 
-
 void
 nni_posix_epdesc_connect(nni_posix_epdesc *ed, nni_aio *aio)
 {
@@ -469,12 +456,11 @@ nni_posix_epdesc_connect(nni_posix_epdesc *ed, nni_aio *aio)
 	nni_mtx_unlock(&ed->mtx);
 }
 
-
 int
 nni_posix_epdesc_init(nni_posix_epdesc **edp, const char *url)
 {
 	nni_posix_epdesc *ed;
-	int rv;
+	int               rv;
 
 	if ((ed = NNI_ALLOC_STRUCT(ed)) == NULL) {
 		return (NNG_ENOMEM);
@@ -490,12 +476,12 @@ nni_posix_epdesc_init(nni_posix_epdesc **edp, const char *url)
 	// one.  For now we just have a global pollq.  Note that by tying
 	// the ed to a single pollq we may get some kind of cache warmth.
 
-	ed->pq = nni_posix_pollq_get((int) nni_random());
-	ed->fd = -1;
+	ed->pq         = nni_posix_pollq_get((int) nni_random());
+	ed->fd         = -1;
 	ed->node.index = 0;
-	ed->node.cb = nni_posix_epdesc_cb;
-	ed->node.data = ed;
-	ed->url = url;
+	ed->node.cb    = nni_posix_epdesc_cb;
+	ed->node.data  = ed;
+	ed->url        = url;
 
 	nni_aio_list_init(&ed->connectq);
 	nni_aio_list_init(&ed->acceptq);
@@ -504,18 +490,16 @@ nni_posix_epdesc_init(nni_posix_epdesc **edp, const char *url)
 	return (0);
 }
 
-
 const char *
 nni_posix_epdesc_url(nni_posix_epdesc *ed)
 {
 	return (ed->url);
 }
 
-
 void
 nni_posix_epdesc_set_local(nni_posix_epdesc *ed, void *sa, int len)
 {
-	if ((len < 0) || (len > sizeof (struct sockaddr_storage))) {
+	if ((len < 0) || (len > sizeof(struct sockaddr_storage))) {
 		return;
 	}
 	nni_mtx_lock(&ed->mtx);
@@ -524,11 +508,10 @@ nni_posix_epdesc_set_local(nni_posix_epdesc *ed, void *sa, int len)
 	nni_mtx_unlock(&ed->mtx);
 }
 
-
 void
 nni_posix_epdesc_set_remote(nni_posix_epdesc *ed, void *sa, int len)
 {
-	if ((len < 0) || (len > sizeof (struct sockaddr_storage))) {
+	if ((len < 0) || (len > sizeof(struct sockaddr_storage))) {
 		return;
 	}
 	nni_mtx_lock(&ed->mtx);
@@ -537,7 +520,6 @@ nni_posix_epdesc_set_remote(nni_posix_epdesc *ed, void *sa, int len)
 	nni_mtx_unlock(&ed->mtx);
 }
 
-
 void
 nni_posix_epdesc_fini(nni_posix_epdesc *ed)
 {
@@ -548,7 +530,6 @@ nni_posix_epdesc_fini(nni_posix_epdesc *ed)
 	NNI_FREE_STRUCT(ed);
 }
 
-
 #else
 
 // Suppress empty symbols warnings in ranlib.
diff --git a/src/platform/posix/posix_impl.h b/src/platform/posix/posix_impl.h
index 407adf74..72842076 100644
--- a/src/platform/posix/posix_impl.h
+++ b/src/platform/posix/posix_impl.h
@@ -16,7 +16,7 @@
 // when using PLATFORM_POSIX_CLOCK, your condition variable timeouts need
 // to use the same base clock values.  Normally these should be used
 // together.  Almost everything depends on PLATFORM_POSIX_DEBUG.
-#ifdef  PLATFORM_POSIX
+#ifdef PLATFORM_POSIX
 #define PLATFORM_POSIX_ALLOC
 #define PLATFORM_POSIX_DEBUG
 #define PLATFORM_POSIX_CLOCK
@@ -40,7 +40,7 @@ extern int nni_plat_errno(int);
 // Define types that this platform uses.
 #ifdef PLATFORM_POSIX_THREAD
 
-extern int nni_plat_devnull;    // open descriptor on /dev/null
+extern int nni_plat_devnull; // open descriptor on /dev/null
 
 #include <pthread.h>
 
@@ -48,28 +48,27 @@ extern int nni_plat_devnull;    // open descriptor on /dev/null
 // elsewhere.
 
 struct nni_plat_mtx {
-	int		init;
-	pthread_t	owner;
+	int             init;
+	pthread_t       owner;
 	pthread_mutex_t mtx;
 };
 
 struct nni_plat_thr {
-	pthread_t	tid;
-	void		(*func)(void *);
-	void *		arg;
+	pthread_t tid;
+	void (*func)(void *);
+	void *arg;
 };
 
 struct nni_plat_cv {
-	pthread_cond_t	cv;
-	nni_plat_mtx *	mtx;
+	pthread_cond_t cv;
+	nni_plat_mtx * mtx;
 };
 
 #endif
 
-
-extern int nni_posix_pollq_sysinit(void);
+extern int  nni_posix_pollq_sysinit(void);
 extern void nni_posix_pollq_sysfini(void);
-extern int nni_posix_resolv_sysinit(void);
+extern int  nni_posix_resolv_sysinit(void);
 extern void nni_posix_resolv_sysfini(void);
 
 #endif // PLATFORM_POSIX_IMPL_H
diff --git a/src/platform/posix/posix_ipc.c b/src/platform/posix/posix_ipc.c
index 706ef15f..a362de6d 100644
--- a/src/platform/posix/posix_ipc.c
+++ b/src/platform/posix/posix_ipc.c
@@ -13,24 +13,23 @@
 #include "platform/posix/posix_aio.h"
 
 #include <errno.h>
-#include <stdlib.h>
+#include <fcntl.h>
+#include <netdb.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
-#include <sys/types.h>
 #include <sys/socket.h>
+#include <sys/types.h>
 #include <sys/uio.h>
 #include <sys/un.h>
-#include <fcntl.h>
 #include <unistd.h>
-#include <netdb.h>
 
-#ifdef  SOCK_CLOEXEC
-#define NNI_STREAM_SOCKTYPE	(SOCK_STREAM | SOCK_CLOEXEC)
+#ifdef SOCK_CLOEXEC
+#define NNI_STREAM_SOCKTYPE (SOCK_STREAM | SOCK_CLOEXEC)
 #else
-#define NNI_STREAM_SOCKTYPE	SOCK_STREAM
+#define NNI_STREAM_SOCKTYPE SOCK_STREAM
 #endif
 
-
 // Solaris/SunOS systems define this, which collides with our symbol
 // names.  Just undefine it now.
 #ifdef sun
@@ -43,32 +42,32 @@
 int
 nni_plat_ipc_ep_init(nni_plat_ipc_ep **epp, const char *url, int mode)
 {
-	nni_posix_epdesc *ed;
-	int rv;
+	nni_posix_epdesc * ed;
+	int                rv;
 	struct sockaddr_un sun;
-	const char *path;
+	const char *       path;
 
 	if (strncmp(url, "ipc://", strlen("ipc://")) != 0) {
 		return (NNG_EADDRINVAL);
 	}
-	path = url + strlen("ipc://");        // skip the prefix.
+	path = url + strlen("ipc://"); // skip the prefix.
 
 	// prepare the sockaddr_un
 	sun.sun_family = AF_UNIX;
-	if (strlen(url) >= sizeof (sun.sun_path)) {
+	if (strlen(url) >= sizeof(sun.sun_path)) {
 		return (NNG_EADDRINVAL);
 	}
-	snprintf(sun.sun_path, sizeof (sun.sun_path), "%s", path);
+	snprintf(sun.sun_path, sizeof(sun.sun_path), "%s", path);
 
 	if ((rv = nni_posix_epdesc_init(&ed, url)) != 0) {
 		return (rv);
 	}
 	switch (mode) {
 	case NNI_EP_MODE_DIAL:
-		nni_posix_epdesc_set_remote(ed, &sun, sizeof (sun));
+		nni_posix_epdesc_set_remote(ed, &sun, sizeof(sun));
 		break;
 	case NNI_EP_MODE_LISTEN:
-		nni_posix_epdesc_set_local(ed, &sun, sizeof (sun));
+		nni_posix_epdesc_set_local(ed, &sun, sizeof(sun));
 		break;
 	default:
 		nni_posix_epdesc_fini(ed);
@@ -79,21 +78,18 @@ nni_plat_ipc_ep_init(nni_plat_ipc_ep **epp, const char *url, int mode)
 	return (0);
 }
 
-
 void
 nni_plat_ipc_ep_fini(nni_plat_ipc_ep *ep)
 {
 	nni_posix_epdesc_fini((void *) ep);
 }
 
-
 void
 nni_plat_ipc_ep_close(nni_plat_ipc_ep *ep)
 {
 	nni_posix_epdesc_close((void *) ep);
 }
 
-
 // UNIX DOMAIN SOCKETS -- these have names in the file namespace.
 // We are going to check to see if there was a name already there.
 // If there was, and nothing is listening (ECONNREFUSED), then we
@@ -102,12 +98,12 @@ nni_plat_ipc_ep_close(nni_plat_ipc_ep *ep)
 static int
 nni_plat_ipc_remove_stale(const char *path)
 {
-	int fd;
-	int rv;
+	int                fd;
+	int                rv;
 	struct sockaddr_un sun;
 
 	sun.sun_family = AF_UNIX;
-	snprintf(sun.sun_path, sizeof (sun.sun_path), "%s", path);
+	snprintf(sun.sun_path, sizeof(sun.sun_path), "%s", path);
 
 	if ((fd = socket(AF_UNIX, NNI_STREAM_SOCKTYPE, 0)) < 0) {
 		return (nni_plat_errno(errno));
@@ -119,7 +115,7 @@ nni_plat_ipc_remove_stale(const char *path)
 	// then the cleanup will fail.  As this is supposed to be an
 	// exceptional case, don't worry.
 	(void) fcntl(fd, F_SETFL, O_NONBLOCK);
-	if (connect(fd, (void *) &sun, sizeof (sun)) < 0) {
+	if (connect(fd, (void *) &sun, sizeof(sun)) < 0) {
 		if (errno == ECONNREFUSED) {
 			(void) unlink(path);
 		}
@@ -128,14 +124,13 @@ nni_plat_ipc_remove_stale(const char *path)
 	return (0);
 }
 
-
 int
 nni_plat_ipc_ep_listen(nni_plat_ipc_ep *ep)
 {
-	const char *path;
-	nni_posix_epdesc *ed = (void *) ep;
+	const char *       path;
+	nni_posix_epdesc * ed = (void *) ep;
 	struct sockaddr_un sun;
-	int rv;
+	int                rv;
 
 	path = nni_posix_epdesc_url(ed);
 	path += strlen("ipc://");
@@ -146,49 +141,42 @@ nni_plat_ipc_ep_listen(nni_plat_ipc_ep *ep)
 	return (nni_posix_epdesc_listen(ed));
 }
 
-
 void
 nni_plat_ipc_ep_connect(nni_plat_ipc_ep *ep, nni_aio *aio)
 {
 	nni_posix_epdesc_connect((void *) ep, aio);
 }
 
-
 void
 nni_plat_ipc_ep_accept(nni_plat_ipc_ep *ep, nni_aio *aio)
 {
 	nni_posix_epdesc_accept((void *) ep, aio);
 }
 
-
 void
 nni_plat_ipc_pipe_fini(nni_plat_ipc_pipe *p)
 {
 	nni_posix_pipedesc_fini((void *) p);
 }
 
-
 void
 nni_plat_ipc_pipe_close(nni_plat_ipc_pipe *p)
 {
 	nni_posix_pipedesc_close((void *) p);
 }
 
-
 void
 nni_plat_ipc_pipe_send(nni_plat_ipc_pipe *p, nni_aio *aio)
 {
 	nni_posix_pipedesc_send((void *) p, aio);
 }
 
-
 void
 nni_plat_ipc_pipe_recv(nni_plat_ipc_pipe *p, nni_aio *aio)
 {
 	nni_posix_pipedesc_recv((void *) p, aio);
 }
 
-
 #else
 
 // Suppress empty symbols warnings in ranlib.
diff --git a/src/platform/posix/posix_net.c b/src/platform/posix/posix_net.c
index 26ec3632..78e1e6ee 100644
--- a/src/platform/posix/posix_net.c
+++ b/src/platform/posix/posix_net.c
@@ -12,72 +12,70 @@
 #ifdef PLATFORM_POSIX_NET
 #include "platform/posix/posix_aio.h"
 
+#include <arpa/inet.h>
 #include <errno.h>
+#include <fcntl.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/types.h>
 #include <sys/socket.h>
+#include <sys/types.h>
 #include <sys/uio.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <arpa/inet.h>
-#include <fcntl.h>
 #include <unistd.h>
 
 static int
 nni_posix_tcp_addr(struct sockaddr_storage *ss, const nni_sockaddr *sa)
 {
-	struct sockaddr_in *sin;
+	struct sockaddr_in * sin;
 	struct sockaddr_in6 *sin6;
 
 	switch (sa->s_un.s_family) {
 	case NNG_AF_INET:
 		sin = (void *) ss;
-		memset(sin, 0, sizeof (*sin));
-		sin->sin_family = PF_INET;
-		sin->sin_port = sa->s_un.s_in.sa_port;
+		memset(sin, 0, sizeof(*sin));
+		sin->sin_family      = PF_INET;
+		sin->sin_port        = sa->s_un.s_in.sa_port;
 		sin->sin_addr.s_addr = sa->s_un.s_in.sa_addr;
-		return (sizeof (*sin));
-
+		return (sizeof(*sin));
 
 	case NNG_AF_INET6:
 		sin6 = (void *) ss;
-		memset(sin6, 0, sizeof (*sin6));
-#ifdef  SIN6_LEN
-		sin6->sin6_len = sizeof (*sin6);
+		memset(sin6, 0, sizeof(*sin6));
+#ifdef SIN6_LEN
+		sin6->sin6_len = sizeof(*sin6);
 #endif
 		sin6->sin6_family = PF_INET6;
-		sin6->sin6_port = sa->s_un.s_in6.sa_port;
+		sin6->sin6_port   = sa->s_un.s_in6.sa_port;
 		memcpy(sin6->sin6_addr.s6_addr, sa->s_un.s_in6.sa_addr, 16);
-		return (sizeof (*sin6));
+		return (sizeof(*sin6));
 	}
 	return (-1);
 }
 
-
 extern int nni_tcp_parse_url(char *, char **, char **, char **, char **);
 
 int
 nni_plat_tcp_ep_init(nni_plat_tcp_ep **epp, const char *url, int mode)
 {
-	nni_posix_epdesc *ed;
-	char buf[NNG_MAXADDRLEN];
-	int rv;
-	char *lhost, *rhost;
-	char *lserv, *rserv;
-	char *sep;
+	nni_posix_epdesc *      ed;
+	char                    buf[NNG_MAXADDRLEN];
+	int                     rv;
+	char *                  lhost, *rhost;
+	char *                  lserv, *rserv;
+	char *                  sep;
 	struct sockaddr_storage ss;
-	int len;
-	int passive;
-	nni_aio aio;
+	int                     len;
+	int                     passive;
+	nni_aio                 aio;
 
 	if ((rv = nni_posix_epdesc_init(&ed, url)) != 0) {
 		return (rv);
 	}
 
 	// Make a local copy.
-	snprintf(buf, sizeof (buf), "%s", url);
+	snprintf(buf, sizeof(buf), "%s", url);
 	nni_aio_init(&aio, NULL, NULL);
 
 	if (mode == NNI_EP_MODE_DIAL) {
@@ -138,70 +136,60 @@ done:
 	return (rv);
 }
 
-
 void
 nni_plat_tcp_ep_fini(nni_plat_tcp_ep *ep)
 {
 	nni_posix_epdesc_fini((void *) ep);
 }
 
-
 void
 nni_plat_tcp_ep_close(nni_plat_tcp_ep *ep)
 {
 	nni_posix_epdesc_close((void *) ep);
 }
 
-
 int
 nni_plat_tcp_ep_listen(nni_plat_tcp_ep *ep)
 {
 	return (nni_posix_epdesc_listen((void *) ep));
 }
 
-
 void
 nni_plat_tcp_ep_connect(nni_plat_tcp_ep *ep, nni_aio *aio)
 {
 	return (nni_posix_epdesc_connect((void *) ep, aio));
 }
 
-
 void
 nni_plat_tcp_ep_accept(nni_plat_tcp_ep *ep, nni_aio *aio)
 {
 	return (nni_posix_epdesc_accept((void *) ep, aio));
 }
 
-
 void
 nni_plat_tcp_pipe_fini(nni_plat_tcp_pipe *p)
 {
 	nni_posix_pipedesc_fini((void *) p);
 }
 
-
 void
 nni_plat_tcp_pipe_close(nni_plat_tcp_pipe *p)
 {
 	nni_posix_pipedesc_close((void *) p);
 }
 
-
 void
 nni_plat_tcp_pipe_send(nni_plat_tcp_pipe *p, nni_aio *aio)
 {
 	nni_posix_pipedesc_send((void *) p, aio);
 }
 
-
 void
 nni_plat_tcp_pipe_recv(nni_plat_tcp_pipe *p, nni_aio *aio)
 {
 	nni_posix_pipedesc_recv((void *) p, aio);
 }
 
-
 #else
 
 // Suppress empty symbols warnings in ranlib.
diff --git a/src/platform/posix/posix_pipe.c b/src/platform/posix/posix_pipe.c
index c86022ef..78415d26 100644
--- a/src/platform/posix/posix_pipe.c
+++ b/src/platform/posix/posix_pipe.c
@@ -21,14 +21,14 @@
 
 // Linux eventfd.  This is lighter weight than pipes, and has better semantics
 // to boot.  This is far better than say epoll().
-#include <sys/eventfd.h>
 #include <fcntl.h>
+#include <sys/eventfd.h>
 #include <unistd.h>
 
 #ifdef EFD_CLOEXEC
-#define NNI_EVENTFD_FLAGS	EFD_CLOEXEC
+#define NNI_EVENTFD_FLAGS EFD_CLOEXEC
 #else
-#define NNI_EVENTFD_FLAGS	0
+#define NNI_EVENTFD_FLAGS 0
 #endif
 
 int
@@ -46,25 +46,22 @@ nni_plat_pipe_open(int *wfd, int *rfd)
 	return (0);
 }
 
-
 void
 nni_plat_pipe_raise(int wfd)
 {
 	uint64_t one = 1;
 
-	(void) write(wfd, &one, sizeof (one));
+	(void) write(wfd, &one, sizeof(one));
 }
 
-
 void
 nni_plat_pipe_clear(int rfd)
 {
 	uint64_t val;
 
-	(void) read(rfd, &val, sizeof (val));
+	(void) read(rfd, &val, sizeof(val));
 }
 
-
 void
 nni_plat_pipe_close(int wfd, int rfd)
 {
@@ -72,11 +69,10 @@ nni_plat_pipe_close(int wfd, int rfd)
 	(void) close(wfd);
 }
 
-
 #else // NNG_USE_EVENTFD
 
-#include <unistd.h>
 #include <fcntl.h>
+#include <unistd.h>
 
 int
 nni_plat_pipe_open(int *wfd, int *rfd)
@@ -97,7 +93,6 @@ nni_plat_pipe_open(int *wfd, int *rfd)
 	return (0);
 }
 
-
 void
 nni_plat_pipe_raise(int wfd)
 {
@@ -106,23 +101,21 @@ nni_plat_pipe_raise(int wfd)
 	(void) write(wfd, &c, 1);
 }
 
-
 void
 nni_plat_pipe_clear(int rfd)
 {
 	char buf[32];
-	int rv;
+	int  rv;
 
 	for (;;) {
 		// Completely drain the pipe, but don't wait.  This coalesces
 		// events somewhat.
-		if (read(rfd, buf, sizeof (buf)) <= 0) {
+		if (read(rfd, buf, sizeof(buf)) <= 0) {
 			return;
 		}
 	}
 }
 
-
 void
 nni_plat_pipe_close(int wfd, int rfd)
 {
@@ -130,7 +123,6 @@ nni_plat_pipe_close(int wfd, int rfd)
 	close(rfd);
 }
 
-
 #endif // NNG_USE_EVENTFD
 
 #else
diff --git a/src/platform/posix/posix_pipedesc.c b/src/platform/posix/posix_pipedesc.c
index c509643e..faab91ad 100644
--- a/src/platform/posix/posix_pipedesc.c
+++ b/src/platform/posix/posix_pipedesc.c
@@ -14,29 +14,27 @@
 #include "platform/posix/posix_pollq.h"
 
 #include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/types.h>
 #include <sys/socket.h>
+#include <sys/types.h>
 #include <sys/uio.h>
-#include <fcntl.h>
 #include <unistd.h>
-#include <poll.h>
-
 
 // nni_posix_pipedesc is a descriptor kept one per transport pipe (i.e. open
 // file descriptor for TCP socket, etc.)  This contains the list of pending
 // aios for that underlying socket, as well as the socket itself.
 struct nni_posix_pipedesc {
-	nni_posix_pollq *	pq;
-	int			fd;
-	nni_list		readq;
-	nni_list		writeq;
-	nni_posix_pollq_node	node;
-	nni_mtx			mtx;
+	nni_posix_pollq *    pq;
+	int                  fd;
+	nni_list             readq;
+	nni_list             writeq;
+	nni_posix_pollq_node node;
+	nni_mtx              mtx;
 };
 
-
 static void
 nni_posix_pipedesc_finish(nni_aio *aio, int rv)
 {
@@ -44,24 +42,23 @@ nni_posix_pipedesc_finish(nni_aio *aio, int rv)
 	nni_aio_finish(aio, rv, aio->a_count);
 }
 
-
 static void
 nni_posix_pipedesc_dowrite(nni_posix_pipedesc *pd)
 {
-	int n;
-	int rv;
-	int i;
-	struct iovec iovec[4];
+	int           n;
+	int           rv;
+	int           i;
+	struct iovec  iovec[4];
 	struct iovec *iovp;
-	nni_aio *aio;
+	nni_aio *     aio;
 
 	while ((aio = nni_list_first(&pd->writeq)) != NULL) {
 		for (i = 0; i < aio->a_niov; i++) {
-			iovec[i].iov_len = aio->a_iov[i].iov_len;
+			iovec[i].iov_len  = aio->a_iov[i].iov_len;
 			iovec[i].iov_base = aio->a_iov[i].iov_buf;
 		}
 		iovp = &iovec[0];
-		rv = 0;
+		rv   = 0;
 
 		n = writev(pd->fd, iovp, aio->a_niov);
 		if (n < 0) {
@@ -92,7 +89,7 @@ nni_posix_pipedesc_dowrite(nni_posix_pipedesc *pd)
 			// remaininng ones up, and decrement count handled.
 			n -= aio->a_iov[0].iov_len;
 			for (i = 1; i < aio->a_niov; i++) {
-				aio->a_iov[i-1] = aio->a_iov[i];
+				aio->a_iov[i - 1] = aio->a_iov[i];
 			}
 			NNI_ASSERT(aio->a_niov > 0);
 			aio->a_niov--;
@@ -106,24 +103,23 @@ nni_posix_pipedesc_dowrite(nni_posix_pipedesc *pd)
 	}
 }
 
-
 static void
 nni_posix_pipedesc_doread(nni_posix_pipedesc *pd)
 {
-	int n;
-	int rv;
-	int i;
-	struct iovec iovec[4];
+	int           n;
+	int           rv;
+	int           i;
+	struct iovec  iovec[4];
 	struct iovec *iovp;
-	nni_aio *aio;
+	nni_aio *     aio;
 
 	while ((aio = nni_list_first(&pd->readq)) != NULL) {
 		for (i = 0; i < aio->a_niov; i++) {
-			iovec[i].iov_len = aio->a_iov[i].iov_len;
+			iovec[i].iov_len  = aio->a_iov[i].iov_len;
 			iovec[i].iov_base = aio->a_iov[i].iov_buf;
 		}
 		iovp = &iovec[0];
-		rv = 0;
+		rv   = 0;
 
 		n = readv(pd->fd, iovp, aio->a_niov);
 		if (n < 0) {
@@ -160,7 +156,7 @@ nni_posix_pipedesc_doread(nni_posix_pipedesc *pd)
 			// remaininng ones up, and decrement count handled.
 			n -= aio->a_iov[0].iov_len;
 			for (i = 1; i < aio->a_niov; i++) {
-				aio->a_iov[i-1] = aio->a_iov[i];
+				aio->a_iov[i - 1] = aio->a_iov[i];
 			}
 			NNI_ASSERT(aio->a_niov > 0);
 			aio->a_niov--;
@@ -174,7 +170,6 @@ nni_posix_pipedesc_doread(nni_posix_pipedesc *pd)
 	}
 }
 
-
 static void
 nni_posix_pipedesc_doclose(nni_posix_pipedesc *pd)
 {
@@ -194,7 +189,6 @@ nni_posix_pipedesc_doclose(nni_posix_pipedesc *pd)
 	}
 }
 
-
 static void
 nni_posix_pipedesc_cb(void *arg)
 {
@@ -207,12 +201,12 @@ nni_posix_pipedesc_cb(void *arg)
 	if (pd->node.revents & POLLOUT) {
 		nni_posix_pipedesc_dowrite(pd);
 	}
-	if (pd->node.revents & (POLLHUP|POLLERR|POLLNVAL)) {
+	if (pd->node.revents & (POLLHUP | POLLERR | POLLNVAL)) {
 		nni_posix_pipedesc_doclose(pd);
 	}
 
 	pd->node.revents = 0;
-	pd->node.events = 0;
+	pd->node.events  = 0;
 
 	if (!nni_list_empty(&pd->writeq)) {
 		pd->node.events |= POLLOUT;
@@ -228,7 +222,6 @@ nni_posix_pipedesc_cb(void *arg)
 	nni_mtx_unlock(&pd->mtx);
 }
 
-
 void
 nni_posix_pipedesc_close(nni_posix_pipedesc *pd)
 {
@@ -239,7 +232,6 @@ nni_posix_pipedesc_close(nni_posix_pipedesc *pd)
 	nni_mtx_unlock(&pd->mtx);
 }
 
-
 static void
 nni_posix_pipedesc_cancel(nni_aio *aio)
 {
@@ -250,7 +242,6 @@ nni_posix_pipedesc_cancel(nni_aio *aio)
 	nni_mtx_unlock(&pd->mtx);
 }
 
-
 void
 nni_posix_pipedesc_recv(nni_posix_pipedesc *pd, nni_aio *aio)
 {
@@ -280,7 +271,6 @@ nni_posix_pipedesc_recv(nni_posix_pipedesc *pd, nni_aio *aio)
 	nni_mtx_unlock(&pd->mtx);
 }
 
-
 void
 nni_posix_pipedesc_send(nni_posix_pipedesc *pd, nni_aio *aio)
 {
@@ -310,17 +300,16 @@ nni_posix_pipedesc_send(nni_posix_pipedesc *pd, nni_aio *aio)
 	nni_mtx_unlock(&pd->mtx);
 }
 
-
 int
 nni_posix_pipedesc_init(nni_posix_pipedesc **pdp, int fd)
 {
 	nni_posix_pipedesc *pd;
-	int rv;
+	int                 rv;
 
 	if ((pd = NNI_ALLOC_STRUCT(pd)) == NULL) {
 		return (NNG_ENOMEM);
 	}
-	memset(pd, 0, sizeof (*pd));
+	memset(pd, 0, sizeof(*pd));
 
 	// We could randomly choose a different pollq, or for efficiencies
 	// sake we could take a modulo of the file desc number to choose
@@ -331,10 +320,10 @@ nni_posix_pipedesc_init(nni_posix_pipedesc **pdp, int fd)
 		NNI_FREE_STRUCT(pd);
 		return (rv);
 	}
-	pd->pq = nni_posix_pollq_get(fd);
-	pd->fd = fd;
-	pd->node.fd = fd;
-	pd->node.cb = nni_posix_pipedesc_cb;
+	pd->pq        = nni_posix_pollq_get(fd);
+	pd->fd        = fd;
+	pd->node.fd   = fd;
+	pd->node.cb   = nni_posix_pipedesc_cb;
 	pd->node.data = pd;
 
 	(void) fcntl(pd->fd, F_SETFL, O_NONBLOCK);
@@ -346,7 +335,6 @@ nni_posix_pipedesc_init(nni_posix_pipedesc **pdp, int fd)
 	return (0);
 }
 
-
 void
 nni_posix_pipedesc_fini(nni_posix_pipedesc *pd)
 {
@@ -358,7 +346,6 @@ nni_posix_pipedesc_fini(nni_posix_pipedesc *pd)
 	NNI_FREE_STRUCT(pd);
 }
 
-
 #else
 
 // Suppress empty symbols warnings in ranlib.
diff --git a/src/platform/posix/posix_pollq.h b/src/platform/posix/posix_pollq.h
index 224bf765..e42b120d 100644
--- a/src/platform/posix/posix_pollq.h
+++ b/src/platform/posix/posix_pollq.h
@@ -21,27 +21,27 @@
 #include "core/nng_impl.h"
 #include <poll.h>
 
-typedef struct nni_posix_pollq_node	nni_posix_pollq_node;
-typedef struct nni_posix_pollq		nni_posix_pollq;
+typedef struct nni_posix_pollq_node nni_posix_pollq_node;
+typedef struct nni_posix_pollq      nni_posix_pollq;
 
 struct nni_posix_pollq_node {
-	nni_posix_pollq *	pq;             // associated pollq
-	nni_list_node		node;           // linkage into the pollq list
-	int			index;          // used by the poller impl
-	int			armed;          // used by the poller impl
-	int			fd;             // file descriptor to poll
-	int			events;         // events to watch for
-	int			revents;        // events received
-	void *			data;           // user data
-	nni_cb			cb;             // user callback on event
+	nni_posix_pollq *pq;      // associated pollq
+	nni_list_node    node;    // linkage into the pollq list
+	int              index;   // used by the poller impl
+	int              armed;   // used by the poller impl
+	int              fd;      // file descriptor to poll
+	int              events;  // events to watch for
+	int              revents; // events received
+	void *           data;    // user data
+	nni_cb           cb;      // user callback on event
 };
 
 extern nni_posix_pollq *nni_posix_pollq_get(int);
-extern int nni_posix_pollq_submit(nni_posix_pollq *, nni_posix_pollq_node *);
+extern int  nni_posix_pollq_submit(nni_posix_pollq *, nni_posix_pollq_node *);
 extern void nni_posix_pollq_cancel(nni_posix_pollq *, nni_posix_pollq_node *);
-extern int nni_posix_pollq_sysinit(void);
+extern int  nni_posix_pollq_sysinit(void);
 extern void nni_posix_pollq_sysfini(void);
 
-#endif  // PLATFORM_POSIX
+#endif // PLATFORM_POSIX
 
-#endif  // PLATFORM_POSIX_POLLQ_H
+#endif // PLATFORM_POSIX_POLLQ_H
diff --git a/src/platform/posix/posix_pollq_poll.c b/src/platform/posix/posix_pollq_poll.c
index cd2eea7b..fe1359ec 100644
--- a/src/platform/posix/posix_pollq_poll.c
+++ b/src/platform/posix/posix_pollq_poll.c
@@ -13,15 +13,14 @@
 #ifdef NNG_USE_POSIX_POLLQ_POLL
 
 #include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/types.h>
 #include <sys/socket.h>
+#include <sys/types.h>
 #include <sys/uio.h>
-#include <fcntl.h>
 #include <unistd.h>
-#include <poll.h>
-
 
 // POSIX AIO using poll().  We use a single poll thread to perform
 // I/O operations for the entire system.  This isn't entirely scalable,
@@ -33,33 +32,31 @@
 // nni_posix_pollq is a work structure used by the poller thread, that keeps
 // track of all the underlying pipe handles and so forth being used by poll().
 struct nni_posix_pollq {
-	nni_mtx			mtx;
-	nni_cv			cv;
-	struct pollfd *		fds;
-	struct pollfd *		newfds;
-	int			nfds;
-	int			nnewfds;
-	int			wakewfd;        // write side of waker pipe
-	int			wakerfd;        // read side of waker pipe
-	int			close;          // request for worker to exit
-	int			started;
-	nni_thr			thr;            // worker thread
-	nni_list		nodes;          // poll list
-	nni_list		notify;         // notify list
-	int			nnodes;         // num of nodes in nodes list
-	int			cancel;         // waiters for cancellation
-	int			inpoll;         // poller asleep in poll
-
-	nni_posix_pollq_node *	active;         // active node (in callback)
+	nni_mtx        mtx;
+	nni_cv         cv;
+	struct pollfd *fds;
+	struct pollfd *newfds;
+	int            nfds;
+	int            nnewfds;
+	int            wakewfd; // write side of waker pipe
+	int            wakerfd; // read side of waker pipe
+	int            close;   // request for worker to exit
+	int            started;
+	nni_thr        thr;    // worker thread
+	nni_list       nodes;  // poll list
+	nni_list       notify; // notify list
+	int            nnodes; // num of nodes in nodes list
+	int            cancel; // waiters for cancellation
+	int            inpoll; // poller asleep in poll
+
+	nni_posix_pollq_node *active; // active node (in callback)
 };
 
-
-
 static int
 nni_posix_pollq_poll_grow(nni_posix_pollq *pq)
 {
-	int grow = pq->nnodes + 2; // one for us, one for waker
-	int noldfds;
+	int            grow = pq->nnodes + 2; // one for us, one for waker
+	int            noldfds;
 	struct pollfd *oldfds;
 	struct pollfd *newfds;
 
@@ -72,34 +69,32 @@ nni_posix_pollq_poll_grow(nni_posix_pollq *pq)
 	// Maybe we are adding a *lot* of pipes at once, and have to grow
 	// multiple times before the poller gets scheduled.  In that case
 	// toss the old array before we finish.
-	oldfds = pq->newfds;
+	oldfds  = pq->newfds;
 	noldfds = pq->nnewfds;
 
-	if ((newfds = nni_alloc(grow * sizeof (struct pollfd))) == NULL) {
+	if ((newfds = nni_alloc(grow * sizeof(struct pollfd))) == NULL) {
 		return (NNG_ENOMEM);
 	}
 
-
-	pq->newfds = newfds;
+	pq->newfds  = newfds;
 	pq->nnewfds = grow;
 
 	if (noldfds != 0) {
-		nni_free(oldfds, noldfds * sizeof (struct pollfd));
+		nni_free(oldfds, noldfds * sizeof(struct pollfd));
 	}
 	return (0);
 }
 
-
 static void
 nni_posix_poll_thr(void *arg)
 {
-	nni_posix_pollq *pollq = arg;
+	nni_posix_pollq *     pollq = arg;
 	nni_posix_pollq_node *node, *nextnode;
 
 	nni_mtx_lock(&pollq->mtx);
 	for (;;) {
-		int rv;
-		int nfds;
+		int            rv;
+		int            nfds;
 		struct pollfd *fds;
 
 		if (pollq->close) {
@@ -109,28 +104,28 @@ nni_posix_poll_thr(void *arg)
 		if (pollq->newfds != NULL) {
 			// We have "grown" by the caller.  Free up the old
 			// space, and start using the new.
-			nni_free(pollq->fds,
-			    pollq->nfds * sizeof (struct pollfd));
-			pollq->fds = pollq->newfds;
-			pollq->nfds = pollq->nnewfds;
+			nni_free(
+			    pollq->fds, pollq->nfds * sizeof(struct pollfd));
+			pollq->fds    = pollq->newfds;
+			pollq->nfds   = pollq->nnewfds;
 			pollq->newfds = NULL;
 		}
-		fds = pollq->fds;
+		fds  = pollq->fds;
 		nfds = 0;
 
 		// The waker pipe is set up so that we will be woken
 		// when it is written (this allows us to be signaled).
-		fds[nfds].fd = pollq->wakerfd;
-		fds[nfds].events = POLLIN;
+		fds[nfds].fd      = pollq->wakerfd;
+		fds[nfds].events  = POLLIN;
 		fds[nfds].revents = 0;
 		nfds++;
 
 		// Set up the poll list.
 		NNI_LIST_FOREACH (&pollq->nodes, node) {
-			fds[nfds].fd = node->fd;
-			fds[nfds].events = node->armed;
+			fds[nfds].fd      = node->fd;
+			fds[nfds].events  = node->armed;
 			fds[nfds].revents = 0;
-			node->index = nfds;
+			node->index       = nfds;
 			nfds++;
 		}
 
@@ -150,7 +145,6 @@ nni_posix_poll_thr(void *arg)
 			continue;
 		}
 
-
 		// If the waker pipe was signaled, read from it.
 		if (fds[0].revents & POLLIN) {
 			NNI_ASSERT(fds[0].fd == pollq->wakerfd);
@@ -183,7 +177,7 @@ nni_posix_poll_thr(void *arg)
 			}
 
 			// Clear the index for the next time around.
-			node->index = 0;
+			node->index   = 0;
 			node->revents = fds[index].revents;
 
 			// Now we move this node to the callback list.
@@ -216,7 +210,6 @@ nni_posix_poll_thr(void *arg)
 	nni_mtx_unlock(&pollq->mtx);
 }
 
-
 void
 nni_posix_pollq_cancel(nni_posix_pollq *pq, nni_posix_pollq_node *node)
 {
@@ -238,7 +231,6 @@ nni_posix_pollq_cancel(nni_posix_pollq *pq, nni_posix_pollq_node *node)
 	nni_mtx_unlock(&pq->mtx);
 }
 
-
 int
 nni_posix_pollq_submit(nni_posix_pollq *pq, nni_posix_pollq_node *node)
 {
@@ -278,13 +270,12 @@ nni_posix_pollq_submit(nni_posix_pollq *pq, nni_posix_pollq_node *node)
 	return (0);
 }
 
-
 static void
 nni_posix_pollq_fini(nni_posix_pollq *pq)
 {
 	if (pq->started) {
 		nni_mtx_lock(&pq->mtx);
-		pq->close = 1;
+		pq->close   = 1;
 		pq->started = 0;
 		nni_plat_pipe_raise(pq->wakewfd);
 
@@ -298,12 +289,11 @@ nni_posix_pollq_fini(nni_posix_pollq *pq)
 		nni_plat_pipe_close(pq->wakewfd, pq->wakerfd);
 		pq->wakewfd = pq->wakerfd = -1;
 	}
-	nni_free(pq->newfds, pq->nnewfds * sizeof (struct pollfd));
-	nni_free(pq->fds, pq->nfds * sizeof (struct pollfd));
+	nni_free(pq->newfds, pq->nnewfds * sizeof(struct pollfd));
+	nni_free(pq->fds, pq->nfds * sizeof(struct pollfd));
 	nni_mtx_fini(&pq->mtx);
 }
 
-
 static int
 nni_posix_pollq_init(nni_posix_pollq *pq)
 {
@@ -313,7 +303,7 @@ nni_posix_pollq_init(nni_posix_pollq *pq)
 	NNI_LIST_INIT(&pq->notify, nni_posix_pollq_node, node);
 	pq->wakewfd = -1;
 	pq->wakerfd = -1;
-	pq->close = 0;
+	pq->close   = 0;
 
 	if (((rv = nni_mtx_init(&pq->mtx)) != 0) ||
 	    ((rv = nni_cv_init(&pq->cv, &pq->mtx)) != 0) ||
@@ -328,7 +318,6 @@ nni_posix_pollq_init(nni_posix_pollq *pq)
 	return (0);
 }
 
-
 // We use a single pollq for the entire system, which means only a single
 // thread is polling.  This may be somewhat less than optimally efficient,
 // and it may be worth investigating having multiple threads to improve
@@ -344,7 +333,6 @@ nni_posix_pollq_get(int fd)
 	return (&nni_posix_global_pollq);
 }
 
-
 int
 nni_posix_pollq_sysinit(void)
 {
@@ -354,14 +342,12 @@ nni_posix_pollq_sysinit(void)
 	return (rv);
 }
 
-
 void
 nni_posix_pollq_sysfini(void)
 {
 	nni_posix_pollq_fini(&nni_posix_global_pollq);
 }
 
-
 #else
 
 // Suppress empty symbols warnings in ranlib.
diff --git a/src/platform/posix/posix_rand.c b/src/platform/posix/posix_rand.c
index 11d166bd..4322e491 100644
--- a/src/platform/posix/posix_rand.c
+++ b/src/platform/posix/posix_rand.c
@@ -12,14 +12,14 @@
 
 #ifdef PLATFORM_POSIX_RANDOM
 
-#include <time.h>
 #include <errno.h>
+#include <fcntl.h>
 #include <stdlib.h>
+#include <string.h>
 #include <sys/types.h>
-#include <unistd.h>
 #include <sys/utsname.h>
-#include <fcntl.h>
-#include <string.h>
+#include <time.h>
+#include <unistd.h>
 
 #ifdef NNG_USE_GETRANDOM
 #include <linux/random.h>
@@ -34,17 +34,17 @@
 // really really you want to have more data than this available, especially
 // for cryptographic applications.
 struct nni_plat_prng_x {
-	nni_time	now;
-	pid_t		pid;
-	uid_t		uid;
-	struct utsname	uts;
+	nni_time       now;
+	pid_t          pid;
+	uid_t          uid;
+	struct utsname uts;
 };
 
 void
 nni_plat_seed_prng(void *buf, size_t bufsz)
 {
 	struct nni_plat_prng_x x;
-	int i;
+	int                    i;
 
 	memset(buf, 0, bufsz);
 
@@ -75,21 +75,20 @@ nni_plat_seed_prng(void *buf, size_t bufsz)
 	// limited of systems, we have at least *some* level of randomness.
 	// The mixing is done in a way to avoid diminishing entropy we may
 	// have already collected.
-	memset(&x, 0, sizeof (x)); // satisfy valgrind
+	memset(&x, 0, sizeof(x)); // satisfy valgrind
 	x.now = nni_clock();
 	x.pid = getpid();
 	x.uid = getuid();
 	uname(&x.uts);
 
-	for (i = 0; (i < bufsz) && (i < sizeof (x)); i++) {
+	for (i = 0; (i < bufsz) && (i < sizeof(x)); i++) {
 		((uint8_t *) buf)[i] ^= ((uint8_t *) &x)[i];
 	}
 }
 
-
 #else
 
 // Suppress empty symbols warnings in ranlib.
 int nni_posix_rand_not_used = 0;
 
-#endif  // PLATFORM_POSIX_RANDOM
+#endif // PLATFORM_POSIX_RANDOM
diff --git a/src/platform/posix/posix_resolv_gai.c b/src/platform/posix/posix_resolv_gai.c
index 4283e9f6..cc27b213 100644
--- a/src/platform/posix/posix_resolv_gai.c
+++ b/src/platform/posix/posix_resolv_gai.c
@@ -7,24 +7,22 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-
 #include "core/nng_impl.h"
 
 #ifdef NNG_USE_POSIX_RESOLV_GAI
 #include "platform/posix/posix_aio.h"
 
 #include <errno.h>
+#include <netdb.h>
+#include <netinet/in.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/types.h>
 #include <sys/socket.h>
+#include <sys/types.h>
 #include <sys/uio.h>
 #include <sys/un.h>
 #include <unistd.h>
-#include <netdb.h>
-#include <netinet/in.h>
-
 
 // We use a single resolver taskq - but we allocate a few threads
 // for it to ensure that names can be looked up concurrently.  This isn't
@@ -35,25 +33,23 @@
 // thread-safe getaddrinfo().  In that case they should set this to 1.
 
 #ifndef NNG_POSIX_RESOLV_CONCURRENCY
-#define NNG_POSIX_RESOLV_CONCURRENCY    4
+#define NNG_POSIX_RESOLV_CONCURRENCY 4
 #endif
 
-
 static nni_taskq *nni_posix_resolv_tq = NULL;
-static nni_mtx nni_posix_resolv_mtx;
+static nni_mtx    nni_posix_resolv_mtx;
 
-typedef struct nni_posix_resolv_item   nni_posix_resolv_item;
+typedef struct nni_posix_resolv_item nni_posix_resolv_item;
 struct nni_posix_resolv_item {
-	int		family;
-	int		passive;
-	const char *	name;
-	const char *	serv;
-	int		proto;
-	nni_aio *	aio;
-	nni_taskq_ent	tqe;
+	int           family;
+	int           passive;
+	const char *  name;
+	const char *  serv;
+	int           proto;
+	nni_aio *     aio;
+	nni_taskq_ent tqe;
 };
 
-
 static void
 nni_posix_resolv_finish(nni_posix_resolv_item *item, int rv)
 {
@@ -64,7 +60,6 @@ nni_posix_resolv_finish(nni_posix_resolv_item *item, int rv)
 	NNI_FREE_STRUCT(item);
 }
 
-
 static void
 nni_posix_resolv_cancel(nni_aio *aio)
 {
@@ -81,7 +76,6 @@ nni_posix_resolv_cancel(nni_aio *aio)
 	NNI_FREE_STRUCT(item);
 }
 
-
 static int
 nni_posix_gai_errno(int rv)
 {
@@ -110,16 +104,15 @@ nni_posix_gai_errno(int rv)
 	}
 }
 
-
 static void
 nni_posix_resolv_task(void *arg)
 {
 	nni_posix_resolv_item *item = arg;
-	nni_aio *aio = item->aio;
-	struct addrinfo hints;
-	struct addrinfo *results;
-	struct addrinfo *probe;
-	int i, rv;
+	nni_aio *              aio  = item->aio;
+	struct addrinfo        hints;
+	struct addrinfo *      results;
+	struct addrinfo *      probe;
+	int                    i, rv;
 
 	results = NULL;
 
@@ -129,7 +122,7 @@ nni_posix_resolv_task(void *arg)
 	case AF_UNSPEC:
 		// We treat these all as IP addresses.  The service and the
 		// host part are split.
-		memset(&hints, 0, sizeof (hints));
+		memset(&hints, 0, sizeof(hints));
 		if (item->passive) {
 			hints.ai_flags |= AI_PASSIVE;
 		}
@@ -137,11 +130,11 @@ nni_posix_resolv_task(void *arg)
 		hints.ai_flags |= AI_ADDRCONFIG;
 #endif
 		hints.ai_protocol = item->proto;
-		hints.ai_family = item->family;
+		hints.ai_family   = item->family;
 		if (item->family == AF_INET6) {
-			// We prefer to have v4mapped addresses if a remote
-			// v4 address isn't avaiable.  And we prefer to only
-			// do this if we actually support v6.
+// We prefer to have v4mapped addresses if a remote
+// v4 address isn't avaiable.  And we prefer to only
+// do this if we actually support v6.
 #if defined(AI_V4MAPPED_CFG)
 			hints.ai_flags |= AI_V4MAPPED_CFG;
 #elif defined(AI_V4MAPPED)
@@ -174,27 +167,27 @@ nni_posix_resolv_task(void *arg)
 		aio->a_addrs = NNI_ALLOC_STRUCTS(aio->a_addrs, aio->a_naddrs);
 		if (aio->a_addrs == NULL) {
 			aio->a_naddrs = 0;
-			rv = NNG_ENOMEM;
+			rv            = NNG_ENOMEM;
 			break;
 		}
 		i = 0;
 		for (probe = results; probe != NULL; probe = probe->ai_next) {
-			struct sockaddr_in *sin;
+			struct sockaddr_in * sin;
 			struct sockaddr_in6 *sin6;
-			nng_sockaddr *sa = &aio->a_addrs[i];
+			nng_sockaddr *       sa = &aio->a_addrs[i];
 
 			switch (probe->ai_addr->sa_family) {
 			case AF_INET:
 				sin = (void *) probe->ai_addr;
 				sa->s_un.s_in.sa_family = NNG_AF_INET;
-				sa->s_un.s_in.sa_port = sin->sin_port;
-				sa->s_un.s_in.sa_addr = sin->sin_addr.s_addr;
+				sa->s_un.s_in.sa_port   = sin->sin_port;
+				sa->s_un.s_in.sa_addr   = sin->sin_addr.s_addr;
 				i++;
 				break;
 			case AF_INET6:
 				sin6 = (void *) probe->ai_addr;
 				sa->s_un.s_in6.sa_family = NNG_AF_INET6;
-				sa->s_un.s_in6.sa_port = sin6->sin6_port;
+				sa->s_un.s_in6.sa_port   = sin6->sin6_port;
 				memcpy(sa->s_un.s_in6.sa_addr,
 				    sin6->sin6_addr.s6_addr, 16);
 				i++;
@@ -222,13 +215,12 @@ nni_posix_resolv_task(void *arg)
 	nni_mtx_unlock(&nni_posix_resolv_mtx);
 }
 
-
 static void
 nni_posix_resolv_ip(const char *host, const char *serv, int passive,
     int family, int proto, nni_aio *aio)
 {
 	nni_posix_resolv_item *item;
-	int rv;
+	int                    rv;
 
 	if ((aio->a_naddrs != 0) && (aio->a_addrs != NULL)) {
 		NNI_FREE_STRUCTS(aio->a_addrs, aio->a_naddrs);
@@ -253,10 +245,10 @@ nni_posix_resolv_ip(const char *host, const char *serv, int passive,
 	}
 	// NB: host and serv must remain valid until this is completed.
 	item->passive = passive;
-	item->name = host;
-	item->serv = serv;
-	item->proto = proto;
-	item->aio = aio;
+	item->name    = host;
+	item->serv    = serv;
+	item->proto   = proto;
+	item->aio     = aio;
 
 	nni_mtx_lock(&nni_posix_resolv_mtx);
 	// If we were stopped, we're done...
@@ -273,15 +265,13 @@ nni_posix_resolv_ip(const char *host, const char *serv, int passive,
 	nni_mtx_unlock(&nni_posix_resolv_mtx);
 }
 
-
 void
-nni_plat_tcp_resolv(const char *host, const char *serv, int family,
-    int passive, nni_aio *aio)
+nni_plat_tcp_resolv(
+    const char *host, const char *serv, int family, int passive, nni_aio *aio)
 {
 	nni_posix_resolv_ip(host, serv, passive, family, IPPROTO_TCP, aio);
 }
 
-
 int
 nni_posix_resolv_sysinit(void)
 {
@@ -297,7 +287,6 @@ nni_posix_resolv_sysinit(void)
 	return (0);
 }
 
-
 void
 nni_posix_resolv_sysfini(void)
 {
@@ -308,7 +297,6 @@ nni_posix_resolv_sysfini(void)
 	nni_mtx_fini(&nni_posix_resolv_mtx);
 }
 
-
 #else
 
 // Suppress empty symbols warnings in ranlib.
diff --git a/src/platform/posix/posix_thread.c b/src/platform/posix/posix_thread.c
index a2f24f8a..45bbfcd3 100644
--- a/src/platform/posix/posix_thread.c
+++ b/src/platform/posix/posix_thread.c
@@ -14,21 +14,21 @@
 #ifdef PLATFORM_POSIX_THREAD
 
 #include <errno.h>
+#include <fcntl.h>
 #include <pthread.h>
-#include <time.h>
-#include <string.h>
+#include <signal.h>
 #include <stdlib.h>
+#include <string.h>
 #include <sys/types.h>
+#include <time.h>
 #include <unistd.h>
-#include <fcntl.h>
-#include <signal.h>
 
-static pthread_mutex_t nni_plat_lock = PTHREAD_MUTEX_INITIALIZER;
-static int nni_plat_inited = 0;
-static int nni_plat_forked = 0;
+static pthread_mutex_t nni_plat_lock   = PTHREAD_MUTEX_INITIALIZER;
+static int             nni_plat_inited = 0;
+static int             nni_plat_forked = 0;
 
-pthread_condattr_t nni_cvattr;
-pthread_mutexattr_t nni_mxattr;
+pthread_condattr_t    nni_cvattr;
+pthread_mutexattr_t   nni_mxattr;
 static pthread_attr_t nni_pthread_attr;
 
 // We open a /dev/null file descriptor so that we can dup2() it to
@@ -55,7 +55,6 @@ nni_plat_mtx_init(nni_plat_mtx *mtx)
 	return (0);
 }
 
-
 void
 nni_plat_mtx_fini(nni_plat_mtx *mtx)
 {
@@ -72,7 +71,6 @@ nni_plat_mtx_fini(nni_plat_mtx *mtx)
 	mtx->init = 0;
 }
 
-
 void
 nni_plat_mtx_lock(nni_plat_mtx *mtx)
 {
@@ -84,7 +82,6 @@ nni_plat_mtx_lock(nni_plat_mtx *mtx)
 	mtx->owner = pthread_self();
 }
 
-
 void
 nni_plat_mtx_unlock(nni_plat_mtx *mtx)
 {
@@ -97,7 +94,6 @@ nni_plat_mtx_unlock(nni_plat_mtx *mtx)
 	}
 }
 
-
 int
 nni_plat_cv_init(nni_plat_cv *cv, nni_plat_mtx *mtx)
 {
@@ -117,7 +113,6 @@ nni_plat_cv_init(nni_plat_cv *cv, nni_plat_mtx *mtx)
 	return (0);
 }
 
-
 void
 nni_plat_cv_wake(nni_plat_cv *cv)
 {
@@ -128,7 +123,6 @@ nni_plat_cv_wake(nni_plat_cv *cv)
 	}
 }
 
-
 void
 nni_plat_cv_wait(nni_plat_cv *cv)
 {
@@ -141,20 +135,19 @@ nni_plat_cv_wait(nni_plat_cv *cv)
 	cv->mtx->owner = pthread_self();
 }
 
-
 int
 nni_plat_cv_until(nni_plat_cv *cv, nni_time until)
 {
 	struct timespec ts;
-	int rv;
+	int             rv;
 
 	NNI_ASSERT(cv->mtx->owner == pthread_self());
 
 	// Our caller has already guaranteed a sane value for until.
-	ts.tv_sec = until / 1000000;
+	ts.tv_sec  = until / 1000000;
 	ts.tv_nsec = (until % 1000000) * 1000;
 
-	rv = pthread_cond_timedwait(&cv->cv, &cv->mtx->mtx, &ts);
+	rv             = pthread_cond_timedwait(&cv->cv, &cv->mtx->mtx, &ts);
 	cv->mtx->owner = pthread_self();
 	if (rv == ETIMEDOUT) {
 		return (NNG_ETIMEDOUT);
@@ -164,7 +157,6 @@ nni_plat_cv_until(nni_plat_cv *cv, nni_time until)
 	return (0);
 }
 
-
 void
 nni_plat_cv_fini(nni_plat_cv *cv)
 {
@@ -179,12 +171,11 @@ nni_plat_cv_fini(nni_plat_cv *cv)
 	cv->mtx = NULL;
 }
 
-
 static void *
 nni_plat_thr_main(void *arg)
 {
 	nni_plat_thr *thr = arg;
-	sigset_t set;
+	sigset_t      set;
 
 	// Suppress (block) SIGPIPE for this thread.
 	sigemptyset(&set);
@@ -195,26 +186,24 @@ nni_plat_thr_main(void *arg)
 	return (NULL);
 }
 
-
 int
 nni_plat_thr_init(nni_plat_thr *thr, void (*fn)(void *), void *arg)
 {
 	int rv;
 
 	thr->func = fn;
-	thr->arg = arg;
+	thr->arg  = arg;
 
 	// POSIX wants functions to return a void *, but we don't care.
-	rv = pthread_create(&thr->tid, &nni_pthread_attr,
-		nni_plat_thr_main, thr);
+	rv = pthread_create(
+	    &thr->tid, &nni_pthread_attr, nni_plat_thr_main, thr);
 	if (rv != 0) {
-		//nni_printf("pthread_create: %s", strerror(rv));
+		// nni_printf("pthread_create: %s", strerror(rv));
 		return (NNG_ENOMEM);
 	}
 	return (0);
 }
 
-
 void
 nni_plat_thr_fini(nni_plat_thr *thr)
 {
@@ -225,14 +214,12 @@ nni_plat_thr_fini(nni_plat_thr *thr)
 	}
 }
 
-
 void
 nni_atfork_child(void)
 {
 	nni_plat_forked = 1;
 }
 
-
 int
 nni_plat_init(int (*helper)(void))
 {
@@ -243,14 +230,14 @@ nni_plat_init(int (*helper)(void))
 		nni_panic("nng is not fork-reentrant safe");
 	}
 	if (nni_plat_inited) {
-		return (0);     // fast path
+		return (0); // fast path
 	}
 	if ((devnull = open("/dev/null", O_RDONLY)) < 0) {
 		return (nni_plat_errno(errno));
 	}
 
 	pthread_mutex_lock(&nni_plat_lock);
-	if (nni_plat_inited) {        // check again under the lock to be sure
+	if (nni_plat_inited) { // check again under the lock to be sure
 		pthread_mutex_unlock(&nni_plat_lock);
 		close(devnull);
 		return (0);
@@ -337,7 +324,6 @@ nni_plat_init(int (*helper)(void))
 	return (rv);
 }
 
-
 void
 nni_plat_fini(void)
 {
@@ -349,12 +335,11 @@ nni_plat_fini(void)
 		pthread_attr_destroy(&nni_pthread_attr);
 		(void) close(nni_plat_devnull);
 		nni_plat_devnull = -1;
-		nni_plat_inited = 0;
+		nni_plat_inited  = 0;
 	}
 	pthread_mutex_unlock(&nni_plat_lock);
 }
 
-
 #else
 
 // Suppress empty symbols warnings in ranlib.
diff --git a/src/platform/windows/win_clock.c b/src/platform/windows/win_clock.c
index 9064b5e2..5a874a71 100644
--- a/src/platform/windows/win_clock.c
+++ b/src/platform/windows/win_clock.c
@@ -15,16 +15,14 @@ nni_time
 nni_plat_clock(void)
 {
 	// We are limited by the system clock, but that is ok.
-	return (GetTickCount64()*1000);
+	return (GetTickCount64() * 1000);
 }
 
-
 void
 nni_plat_usleep(nni_duration dur)
 {
 	uint64_t exp;
 
-
 	// Convert duration to msec, rounding up.
 	dur += 999;
 	dur /= 1000;
@@ -43,10 +41,9 @@ nni_plat_usleep(nni_duration dur)
 	}
 }
 
-
 #else
 
 // Suppress empty symbols warnings in ranlib.
 int nni_win_clock_not_used = 0;
 
-#endif  // PLATFORM_WINDOWS
+#endif // PLATFORM_WINDOWS
diff --git a/src/platform/windows/win_debug.c b/src/platform/windows/win_debug.c
index 43db0505..bc3d5bfa 100644
--- a/src/platform/windows/win_debug.c
+++ b/src/platform/windows/win_debug.c
@@ -12,8 +12,8 @@
 #ifdef PLATFORM_WINDOWS
 
 #include <errno.h>
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
 void
@@ -22,14 +22,12 @@ nni_plat_abort(void)
 	abort();
 }
 
-
 void
 nni_plat_println(const char *message)
 {
 	(void) fprintf(stderr, "%s\n", message);
 }
 
-
 const char *
 nni_plat_strerror(int errnum)
 {
@@ -39,25 +37,16 @@ nni_plat_strerror(int errnum)
 	return (strerror(errnum));
 }
 
-
 // Win32 has its own error codes, but these ones it shares with POSIX.
 static struct {
-	int	sys_err;
-	int	nng_err;
-}
-nni_plat_errnos[] = {
-	{ ENOENT,	NNG_ENOENT  },
-	{ EINTR,	NNG_EINTR   },
-	{ EINVAL,	NNG_EINVAL  },
-	{ ENOMEM,	NNG_ENOMEM  },
-	{ EACCES,	NNG_EPERM   },
-	{ EAGAIN,	NNG_EAGAIN  },
-	{ EBADF,	NNG_ECLOSED },
-	{ EBUSY,	NNG_EBUSY   },
-	{ ENAMETOOLONG, NNG_EINVAL  },
-	{ EPERM,	NNG_EPERM   },
-	{ EPIPE,	NNG_ECLOSED },
-	{	     0,		  0 } // must be last
+	int sys_err;
+	int nng_err;
+} nni_plat_errnos[] = {
+	{ ENOENT, NNG_ENOENT }, { EINTR, NNG_EINTR }, { EINVAL, NNG_EINVAL },
+	{ ENOMEM, NNG_ENOMEM }, { EACCES, NNG_EPERM }, { EAGAIN, NNG_EAGAIN },
+	{ EBADF, NNG_ECLOSED }, { EBUSY, NNG_EBUSY },
+	{ ENAMETOOLONG, NNG_EINVAL }, { EPERM, NNG_EPERM },
+	{ EPIPE, NNG_ECLOSED }, { 0, 0 } // must be last
 };
 
 int
@@ -77,15 +66,14 @@ nni_plat_errno(int errnum)
 	return (NNG_ESYSERR + errnum);
 }
 
-
 // Windows has infinite numbers of error codes it seems.  We only bother
 // with the ones that are relevant to us (we think).  Note that there is
 // no overlap between errnos and GetLastError values.
 static struct {
-	int	win_err;
-	int	nng_err;
-}
-nni_win_errnos[] = {
+	int win_err;
+	int nng_err;
+} nni_win_errnos[] = {
+	// clang-format off
 	{ ERROR_FILE_NOT_FOUND,	    NNG_ENOENT	     },
 	{ ERROR_ACCESS_DENIED,	    NNG_EPERM	     },
 	{ ERROR_INVALID_HANDLE,	    NNG_ECLOSED	     },
@@ -106,6 +94,7 @@ nni_win_errnos[] = {
 	{ WAIT_TIMEOUT,		    NNG_ETIMEDOUT    },
 	// Must be Last!!
 	{			 0,		   0 },
+	// clang-format on
 };
 
 // This converts a Windows API error (from GetLastError()) to an
@@ -127,7 +116,6 @@ nni_win_error(int errnum)
 	return (NNG_ESYSERR + errnum);
 }
 
-
 #else
 
 // Suppress empty symbols warnings in ranlib.
diff --git a/src/platform/windows/win_impl.h b/src/platform/windows/win_impl.h
index 6ce38250..234acc35 100644
--- a/src/platform/windows/win_impl.h
+++ b/src/platform/windows/win_impl.h
@@ -16,10 +16,10 @@
 #define WIN32_LEAN_AND_MEAN
 #endif
 
-#include <windows.h>
-#include <winsock2.h>
 #include <mswsock.h>
 #include <process.h>
+#include <windows.h>
+#include <winsock2.h>
 #include <ws2tcpip.h>
 
 #include "core/list.h"
@@ -27,7 +27,7 @@
 // These types are provided for here, to permit them to be directly inlined
 // elsewhere.
 
-typedef struct nni_win_event   nni_win_event;
+typedef struct nni_win_event nni_win_event;
 
 // nni_win_event is used with io completion ports.  This allows us to get
 // to a specific completion callback without requiring the poller (in the
@@ -35,50 +35,50 @@ typedef struct nni_win_event   nni_win_event;
 // this to pass back status and counts to the routine, which may not be
 // conveyed in the OVERLAPPED directly.
 struct nni_win_event {
-	OVERLAPPED	olpd;
-	HANDLE		h;
-	void *		ptr;
-	nni_cb		cb;
-	nni_list	aios;
+	OVERLAPPED olpd;
+	HANDLE     h;
+	void *     ptr;
+	nni_cb     cb;
+	nni_list   aios;
 };
 
 struct nni_plat_thr {
-	void	(*func)(void *);
-	void *	arg;
-	HANDLE	handle;
+	void (*func)(void *);
+	void * arg;
+	HANDLE handle;
 };
 
 struct nni_plat_mtx {
 	SRWLOCK srl;
-	DWORD	owner;
-	int	init;
+	DWORD   owner;
+	int     init;
 };
 
 struct nni_plat_cv {
-	CONDITION_VARIABLE	cv;
-	PSRWLOCK		srl;
+	CONDITION_VARIABLE cv;
+	PSRWLOCK           srl;
 };
 
 extern int nni_win_error(int);
 extern int nni_winsock_error(int);
 
-extern int nni_win_event_init(nni_win_event *, nni_cb, void *, HANDLE);
-extern void nni_win_event_fini(nni_win_event *);
-extern int nni_win_event_reset(nni_win_event *);
+extern int         nni_win_event_init(nni_win_event *, nni_cb, void *, HANDLE);
+extern void        nni_win_event_fini(nni_win_event *);
+extern int         nni_win_event_reset(nni_win_event *);
 extern OVERLAPPED *nni_win_event_overlapped(nni_win_event *);
-extern void nni_win_event_cancel(nni_win_event *);
+extern void        nni_win_event_cancel(nni_win_event *);
 
 extern int nni_win_iocp_register(HANDLE);
 
-extern int nni_win_iocp_sysinit(void);
+extern int  nni_win_iocp_sysinit(void);
 extern void nni_win_iocp_sysfini(void);
 
-extern int nni_win_ipc_sysinit(void);
+extern int  nni_win_ipc_sysinit(void);
 extern void nni_win_ipc_sysfini(void);
 
-extern int nni_win_resolv_sysinit(void);
+extern int  nni_win_resolv_sysinit(void);
 extern void nni_win_resolv_sysfini(void);
 
-#endif  // PLATFORM_WINDOWS
+#endif // PLATFORM_WINDOWS
 
-#endif  // PLATFORM_WIN_IMPL_H
+#endif // PLATFORM_WIN_IMPL_H
diff --git a/src/platform/windows/win_iocp.c b/src/platform/windows/win_iocp.c
index 381da64f..7244b360 100644
--- a/src/platform/windows/win_iocp.c
+++ b/src/platform/windows/win_iocp.c
@@ -11,7 +11,7 @@
 
 #ifdef PLATFORM_WINDOWS
 
-#define NNI_WIN_IOCP_NTHREADS    4
+#define NNI_WIN_IOCP_NTHREADS 4
 #include <stdio.h>
 
 // Windows IO Completion Port support.  We basically creaet a single
@@ -19,33 +19,33 @@
 // to the port on an as needed basis.  We use a single IO completion
 // port for pretty much everything.
 
-static HANDLE nni_win_global_iocp = NULL;
+static HANDLE  nni_win_global_iocp = NULL;
 static nni_thr nni_win_iocp_thrs[NNI_WIN_IOCP_NTHREADS];
 static nni_mtx nni_win_iocp_mtx;
 
 static void
 nni_win_iocp_handler(void *arg)
 {
-	HANDLE iocp;
-	DWORD cnt;
-	ULONG_PTR key;
-	OVERLAPPED *olpd;
+	HANDLE         iocp;
+	DWORD          cnt;
+	ULONG_PTR      key;
+	OVERLAPPED *   olpd;
 	nni_win_event *evt;
-	int status;
-	BOOL rv;
+	int            status;
+	BOOL           rv;
 
 	NNI_ARG_UNUSED(arg);
 
 	iocp = nni_win_global_iocp;
 
 	for (;;) {
-		key = 0;
-		olpd = NULL;
+		key    = 0;
+		olpd   = NULL;
 		status = 0;
-		cnt = 0;
+		cnt    = 0;
 
-		rv = GetQueuedCompletionStatus(iocp, &cnt, &key, &olpd,
-			INFINITE);
+		rv = GetQueuedCompletionStatus(
+		    iocp, &cnt, &key, &olpd, INFINITE);
 
 		if (rv == FALSE) {
 			if (olpd == NULL) {
@@ -62,7 +62,6 @@ nni_win_iocp_handler(void *arg)
 	}
 }
 
-
 int
 nni_win_iocp_register(HANDLE h)
 {
@@ -72,23 +71,21 @@ nni_win_iocp_register(HANDLE h)
 	return (0);
 }
 
-
 int
 nni_win_event_init(nni_win_event *evt, nni_cb cb, void *ptr, HANDLE h)
 {
-	ZeroMemory(&evt->olpd, sizeof (evt->olpd));
+	ZeroMemory(&evt->olpd, sizeof(evt->olpd));
 	evt->olpd.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 	if (evt->olpd.hEvent == NULL) {
 		return (nni_win_error(GetLastError()));
 	}
 	nni_aio_list_init(&evt->aios);
 	evt->ptr = ptr;
-	evt->cb = cb;
-	evt->h = h;
+	evt->cb  = cb;
+	evt->h   = h;
 	return (0);
 }
 
-
 void
 nni_win_event_fini(nni_win_event *evt)
 {
@@ -98,7 +95,6 @@ nni_win_event_fini(nni_win_event *evt)
 	}
 }
 
-
 int
 nni_win_event_reset(nni_win_event *evt)
 {
@@ -108,18 +104,16 @@ nni_win_event_reset(nni_win_event *evt)
 	return (0);
 }
 
-
 OVERLAPPED *
 nni_win_event_overlapped(nni_win_event *evt)
 {
 	return (&evt->olpd);
 }
 
-
 void
 nni_win_event_cancel(nni_win_event *evt)
 {
-	int rv;
+	int   rv;
 	DWORD cnt;
 
 	// Try to cancel the event...
@@ -146,23 +140,22 @@ nni_win_event_cancel(nni_win_event *evt)
 	GetOverlappedResult(evt->h, &evt->olpd, &cnt, TRUE);
 }
 
-
 int
 nni_win_iocp_sysinit(void)
 {
 	HANDLE h;
-	int i;
-	int rv;
+	int    i;
+	int    rv;
 
-	h = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0,
-		NNI_WIN_IOCP_NTHREADS);
+	h = CreateIoCompletionPort(
+	    INVALID_HANDLE_VALUE, NULL, 0, NNI_WIN_IOCP_NTHREADS);
 	if (h == NULL) {
 		return (nni_win_error(GetLastError()));
 	}
 	nni_win_global_iocp = h;
 	for (i = 0; i < NNI_WIN_IOCP_NTHREADS; i++) {
-		rv = nni_thr_init(&nni_win_iocp_thrs[i], nni_win_iocp_handler,
-			NULL);
+		rv = nni_thr_init(
+		    &nni_win_iocp_thrs[i], nni_win_iocp_handler, NULL);
 		if (rv != 0) {
 			goto fail;
 		}
@@ -186,11 +179,10 @@ fail:
 	return (rv);
 }
 
-
 void
 nni_win_iocp_sysfini(void)
 {
-	int i;
+	int    i;
 	HANDLE h;
 
 	if ((h = nni_win_global_iocp) != NULL) {
@@ -203,7 +195,6 @@ nni_win_iocp_sysfini(void)
 	nni_mtx_fini(&nni_win_iocp_mtx);
 }
 
-
 #else
 
 // Suppress empty symbols warnings in ranlib.
diff --git a/src/platform/windows/win_ipc.c b/src/platform/windows/win_ipc.c
index f6601f93..237ded78 100644
--- a/src/platform/windows/win_ipc.c
+++ b/src/platform/windows/win_ipc.c
@@ -20,31 +20,30 @@ static void nni_win_ipc_send_start(nni_plat_ipc_pipe *);
 static void nni_win_ipc_recv_start(nni_plat_ipc_pipe *);
 
 struct nni_plat_ipc_pipe {
-	HANDLE		p;
-	nni_win_event	recv_evt;
-	nni_win_event	send_evt;
-	nni_mtx		mtx;
-	nni_list	readq;
-	nni_list	writeq;
+	HANDLE        p;
+	nni_win_event recv_evt;
+	nni_win_event send_evt;
+	nni_mtx       mtx;
+	nni_list      readq;
+	nni_list      writeq;
 };
 
 struct nni_plat_ipc_ep {
-	char		path[256];
-	int		mode;
-	int		started;
-	nni_list	aios;
-	HANDLE		p;              // accept side only
-	nni_win_event	acc_evt;        // accept side only
-	nni_mtx		mtx;            // accept side only
-	nni_list_node	node;           // conn side uses this
+	char          path[256];
+	int           mode;
+	int           started;
+	nni_list      aios;
+	HANDLE        p;       // accept side only
+	nni_win_event acc_evt; // accept side only
+	nni_mtx       mtx;     // accept side only
+	nni_list_node node;    // conn side uses this
 };
 
-
 static int
 nni_win_ipc_pipe_init(nni_plat_ipc_pipe **pipep, HANDLE p)
 {
 	nni_plat_ipc_pipe *pipe;
-	int rv;
+	int                rv;
 
 	if ((pipe = NNI_ALLOC_STRUCT(pipe)) == NULL) {
 		return (NNG_ENOMEM);
@@ -71,7 +70,6 @@ nni_win_ipc_pipe_init(nni_plat_ipc_pipe **pipep, HANDLE p)
 	return (0);
 }
 
-
 static void
 nni_win_ipc_send_cancel(nni_aio *aio)
 {
@@ -83,15 +81,14 @@ nni_win_ipc_send_cancel(nni_aio *aio)
 	nni_mtx_unlock(&pipe->mtx);
 }
 
-
 static void
 nni_win_ipc_send_finish(nni_plat_ipc_pipe *pipe)
 {
-	nni_win_event *evt = &pipe->send_evt;
-	OVERLAPPED *olpd = nni_win_event_overlapped(evt);
-	int rv = 0;
-	nni_aio *aio;
-	DWORD cnt;
+	nni_win_event *evt  = &pipe->send_evt;
+	OVERLAPPED *   olpd = nni_win_event_overlapped(evt);
+	int            rv   = 0;
+	nni_aio *      aio;
+	DWORD          cnt;
 
 	if (GetOverlappedResult(pipe->p, olpd, &cnt, TRUE) == FALSE) {
 		rv = nni_win_error(GetLastError());
@@ -110,7 +107,7 @@ nni_win_ipc_send_finish(nni_plat_ipc_pipe *pipe)
 		if (aio->a_iov[0].iov_len == 0) {
 			int i;
 			for (i = 1; i < aio->a_niov; i++) {
-				aio->a_iov[i-1] = aio->a_iov[i];
+				aio->a_iov[i - 1] = aio->a_iov[i];
 			}
 			aio->a_niov--;
 		}
@@ -127,16 +124,15 @@ nni_win_ipc_send_finish(nni_plat_ipc_pipe *pipe)
 	nni_aio_finish(aio, rv, aio->a_count);
 }
 
-
 static void
 nni_win_ipc_send_start(nni_plat_ipc_pipe *pipe)
 {
-	void *buf;
-	DWORD len;
-	int rv;
-	nni_win_event *evt = &pipe->send_evt;
-	OVERLAPPED *olpd = nni_win_event_overlapped(evt);
-	nni_aio *aio = nni_list_first(&pipe->writeq);
+	void *         buf;
+	DWORD          len;
+	int            rv;
+	nni_win_event *evt  = &pipe->send_evt;
+	OVERLAPPED *   olpd = nni_win_event_overlapped(evt);
+	nni_aio *      aio  = nni_list_first(&pipe->writeq);
 
 	NNI_ASSERT(aio != NULL);
 	NNI_ASSERT(aio->a_niov > 0);
@@ -157,8 +153,8 @@ nni_win_ipc_send_start(nni_plat_ipc_pipe *pipe)
 	// scrambling the data anyway.  Note that Windows named pipes do
 	// not appear to support scatter/gather, so we have to process
 	// each element in turn.
-	buf = aio->a_iov[0].iov_buf;
-	len = (DWORD) aio->a_iov[0].iov_len;
+	buf  = aio->a_iov[0].iov_buf;
+	len  = (DWORD) aio->a_iov[0].iov_len;
 	olpd = nni_win_event_overlapped(evt);
 
 	// We limit ourselves to writing 16MB at a time.  Named Pipes
@@ -190,7 +186,6 @@ fail:
 	nni_aio_finish(aio, rv, aio->a_count);
 }
 
-
 static void
 nni_win_ipc_send_cb(void *arg)
 {
@@ -201,12 +196,11 @@ nni_win_ipc_send_cb(void *arg)
 	nni_mtx_unlock(&pipe->mtx);
 }
 
-
 void
 nni_plat_ipc_pipe_send(nni_plat_ipc_pipe *pipe, nni_aio *aio)
 {
 	nni_win_event *evt = &pipe->send_evt;
-	int rv;
+	int            rv;
 
 	nni_mtx_lock(&pipe->mtx);
 	if ((rv = nni_aio_start(aio, nni_win_ipc_send_cancel, pipe)) != 0) {
@@ -229,7 +223,6 @@ nni_plat_ipc_pipe_send(nni_plat_ipc_pipe *pipe, nni_aio *aio)
 	nni_mtx_unlock(&pipe->mtx);
 }
 
-
 static void
 nni_win_ipc_recv_cancel(nni_aio *aio)
 {
@@ -241,15 +234,14 @@ nni_win_ipc_recv_cancel(nni_aio *aio)
 	nni_mtx_unlock(&pipe->mtx);
 }
 
-
 static void
 nni_win_ipc_recv_finish(nni_plat_ipc_pipe *pipe)
 {
-	nni_win_event *evt = &pipe->recv_evt;
-	OVERLAPPED *olpd = nni_win_event_overlapped(evt);
-	int rv = 0;
-	nni_aio *aio;
-	DWORD cnt;
+	nni_win_event *evt  = &pipe->recv_evt;
+	OVERLAPPED *   olpd = nni_win_event_overlapped(evt);
+	int            rv   = 0;
+	nni_aio *      aio;
+	DWORD          cnt;
 
 	if (GetOverlappedResult(pipe->p, olpd, &cnt, TRUE) == FALSE) {
 		rv = nni_win_error(GetLastError());
@@ -268,7 +260,7 @@ nni_win_ipc_recv_finish(nni_plat_ipc_pipe *pipe)
 		if (aio->a_iov[0].iov_len == 0) {
 			int i;
 			for (i = 1; i < aio->a_niov; i++) {
-				aio->a_iov[i-1] = aio->a_iov[i];
+				aio->a_iov[i - 1] = aio->a_iov[i];
 			}
 			aio->a_niov--;
 		}
@@ -285,16 +277,15 @@ nni_win_ipc_recv_finish(nni_plat_ipc_pipe *pipe)
 	nni_aio_finish(aio, rv, aio->a_count);
 }
 
-
 static void
 nni_win_ipc_recv_start(nni_plat_ipc_pipe *pipe)
 {
-	void *buf;
-	DWORD len;
-	int rv;
-	nni_win_event *evt = &pipe->recv_evt;
-	OVERLAPPED *olpd = nni_win_event_overlapped(evt);
-	nni_aio *aio = nni_list_first(&pipe->readq);
+	void *         buf;
+	DWORD          len;
+	int            rv;
+	nni_win_event *evt  = &pipe->recv_evt;
+	OVERLAPPED *   olpd = nni_win_event_overlapped(evt);
+	nni_aio *      aio  = nni_list_first(&pipe->readq);
 
 	NNI_ASSERT(aio != NULL);
 	NNI_ASSERT(aio->a_niov > 0);
@@ -315,8 +306,8 @@ nni_win_ipc_recv_start(nni_plat_ipc_pipe *pipe)
 	// scrambling the data anyway.  Note that Windows named pipes do
 	// not appear to support scatter/gather, so we have to process
 	// each element in turn.
-	buf = aio->a_iov[0].iov_buf;
-	len = (DWORD) aio->a_iov[0].iov_len;
+	buf  = aio->a_iov[0].iov_buf;
+	len  = (DWORD) aio->a_iov[0].iov_len;
 	olpd = nni_win_event_overlapped(evt);
 
 	// We limit ourselves to writing 16MB at a time.  Named Pipes
@@ -348,7 +339,6 @@ fail:
 	nni_aio_finish(aio, rv, 0);
 }
 
-
 static void
 nni_win_ipc_recv_cb(void *arg)
 {
@@ -359,12 +349,11 @@ nni_win_ipc_recv_cb(void *arg)
 	nni_mtx_unlock(&pipe->mtx);
 }
 
-
 void
 nni_plat_ipc_pipe_recv(nni_plat_ipc_pipe *pipe, nni_aio *aio)
 {
 	nni_win_event *evt = &pipe->send_evt;
-	int rv;
+	int            rv;
 
 	nni_mtx_lock(&pipe->mtx);
 	if ((rv = nni_aio_start(aio, nni_win_ipc_recv_cancel, pipe)) != 0) {
@@ -386,7 +375,6 @@ nni_plat_ipc_pipe_recv(nni_plat_ipc_pipe *pipe, nni_aio *aio)
 	nni_win_ipc_recv_start(pipe);
 }
 
-
 void
 nni_plat_ipc_pipe_close(nni_plat_ipc_pipe *pipe)
 {
@@ -400,7 +388,6 @@ nni_plat_ipc_pipe_close(nni_plat_ipc_pipe *pipe)
 	nni_mtx_unlock(&pipe->mtx);
 }
 
-
 void
 nni_plat_ipc_pipe_fini(nni_plat_ipc_pipe *pipe)
 {
@@ -412,13 +399,12 @@ nni_plat_ipc_pipe_fini(nni_plat_ipc_pipe *pipe)
 	NNI_FREE_STRUCT(pipe);
 }
 
-
 int
 nni_plat_ipc_ep_init(nni_plat_ipc_ep **epp, const char *url, int mode)
 {
-	const char *path;
+	const char *     path;
 	nni_plat_ipc_ep *ep;
-	int rv;
+	int              rv;
 
 	if (strncmp(url, "ipc://", strlen("ipc://")) != 0) {
 		return (NNG_EADDRINVAL);
@@ -427,7 +413,7 @@ nni_plat_ipc_ep_init(nni_plat_ipc_ep **epp, const char *url, int mode)
 	if ((ep = NNI_ALLOC_STRUCT(ep)) == NULL) {
 		return (NNG_ENOMEM);
 	}
-	ZeroMemory(ep, sizeof (ep));
+	ZeroMemory(ep, sizeof(ep));
 	if ((rv = nni_mtx_init(&ep->mtx)) != 0) {
 		NNI_FREE_STRUCT(ep);
 		return (rv);
@@ -437,17 +423,16 @@ nni_plat_ipc_ep_init(nni_plat_ipc_ep **epp, const char *url, int mode)
 	NNI_LIST_NODE_INIT(&ep->node);
 	nni_aio_list_init(&ep->aios);
 
-	(void) snprintf(ep->path, sizeof (ep->path), "\\\\.\\pipe\\%s", path);
+	(void) snprintf(ep->path, sizeof(ep->path), "\\\\.\\pipe\\%s", path);
 
 	*epp = ep;
 	return (0);
 }
 
-
 int
 nni_plat_ipc_ep_listen(nni_plat_ipc_ep *ep)
 {
-	int rv;
+	int    rv;
 	HANDLE p;
 
 	nni_mtx_lock(&ep->mtx);
@@ -463,12 +448,11 @@ nni_plat_ipc_ep_listen(nni_plat_ipc_ep *ep)
 	// We create the first named pipe, and we make sure that it is
 	// properly ours.
 	p = CreateNamedPipeA(ep->path,
-		PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED |
-		FILE_FLAG_FIRST_PIPE_INSTANCE,
-		PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT |
-		PIPE_REJECT_REMOTE_CLIENTS,
-		PIPE_UNLIMITED_INSTANCES,
-		4096, 4096, 0, NULL);
+	    PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED |
+	        FILE_FLAG_FIRST_PIPE_INSTANCE,
+	    PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT |
+	        PIPE_REJECT_REMOTE_CLIENTS,
+	    PIPE_UNLIMITED_INSTANCES, 4096, 4096, 0, NULL);
 	if (p == INVALID_HANDLE_VALUE) {
 		if ((rv = GetLastError()) == ERROR_ACCESS_DENIED) {
 			rv = NNG_EADDRINUSE;
@@ -486,7 +470,7 @@ nni_plat_ipc_ep_listen(nni_plat_ipc_ep *ep)
 		goto failed;
 	}
 
-	ep->p = p;
+	ep->p       = p;
 	ep->started = 1;
 	nni_mtx_unlock(&ep->mtx);
 	return (0);
@@ -501,16 +485,15 @@ failed:
 	return (rv);
 }
 
-
 static void
 nni_win_ipc_acc_finish(nni_plat_ipc_ep *ep)
 {
-	nni_win_event *evt = &ep->acc_evt;
-	DWORD nbytes;
-	int rv;
+	nni_win_event *    evt = &ep->acc_evt;
+	DWORD              nbytes;
+	int                rv;
 	nni_plat_ipc_pipe *pipe;
-	nni_aio *aio;
-	HANDLE newp, oldp;
+	nni_aio *          aio;
+	HANDLE             newp, oldp;
 
 	// Note: This should be called with the ep lock held, and only when
 	// the ConnectNamedPipe has finished.
@@ -541,17 +524,16 @@ nni_win_ipc_acc_finish(nni_plat_ipc_ep *ep)
 	}
 
 	newp = CreateNamedPipeA(ep->path,
-		PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
-		PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT |
-		PIPE_REJECT_REMOTE_CLIENTS,
-		PIPE_UNLIMITED_INSTANCES,
-		4096, 4096, 0, NULL);
+	    PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
+	    PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT |
+	        PIPE_REJECT_REMOTE_CLIENTS,
+	    PIPE_UNLIMITED_INSTANCES, 4096, 4096, 0, NULL);
 	if (newp == INVALID_HANDLE_VALUE) {
 		rv = nni_win_error(GetLastError());
 		DisconnectNamedPipe(ep->p);
 		return;
 	}
-	oldp = ep->p;
+	oldp  = ep->p;
 	ep->p = newp;
 
 	if ((rv = nni_win_ipc_pipe_init(&pipe, oldp)) != 0) {
@@ -564,7 +546,6 @@ nni_win_ipc_acc_finish(nni_plat_ipc_ep *ep)
 	nni_aio_finish(aio, 0, 0);
 }
 
-
 static void
 nni_win_ipc_acc_cb(void *arg)
 {
@@ -575,7 +556,6 @@ nni_win_ipc_acc_cb(void *arg)
 	nni_mtx_unlock(&ep->mtx);
 }
 
-
 static void
 nni_win_ipc_acc_cancel(nni_aio *aio)
 {
@@ -587,11 +567,10 @@ nni_win_ipc_acc_cancel(nni_aio *aio)
 	nni_mtx_unlock(&ep->mtx);
 }
 
-
 void
 nni_plat_ipc_ep_accept(nni_plat_ipc_ep *ep, nni_aio *aio)
 {
-	int rv;
+	int            rv;
 	nni_win_event *evt = &ep->acc_evt;
 
 	nni_mtx_lock(&ep->mtx);
@@ -628,34 +607,32 @@ nni_plat_ipc_ep_accept(nni_plat_ipc_ep *ep, nni_aio *aio)
 	nni_mtx_unlock(&ep->mtx);
 }
 
-
 // So Windows IPC is a bit different on the client side.  There is no
 // support for asynchronous connection, but we can fake it with a single
 // thread that runs to establish the connection.  That thread will run
 // keep looping, sleeping for 10 ms between attempts.  It performs non-blocking
 // attempts to connect.
-typedef struct nni_win_ipc_conn_work   nni_win_ipc_conn_work;
+typedef struct nni_win_ipc_conn_work nni_win_ipc_conn_work;
 struct nni_win_ipc_conn_work {
-	nni_list	waiters;
-	nni_list	workers;
-	nni_mtx		mtx;
-	nni_cv		cv;
-	nni_thr		thr;
-	int		exit;
+	nni_list waiters;
+	nni_list workers;
+	nni_mtx  mtx;
+	nni_cv   cv;
+	nni_thr  thr;
+	int      exit;
 };
 
 static nni_win_ipc_conn_work nni_win_ipc_connecter;
 
-
 static void
 nni_win_ipc_conn_thr(void *arg)
 {
 	nni_win_ipc_conn_work *w = arg;
-	nni_plat_ipc_ep *ep;
-	nni_plat_ipc_pipe *pipe;
-	nni_aio *aio;
-	HANDLE p;
-	int rv;
+	nni_plat_ipc_ep *      ep;
+	nni_plat_ipc_pipe *    pipe;
+	nni_aio *              aio;
+	HANDLE                 p;
+	int                    rv;
 
 	nni_mtx_lock(&w->mtx);
 	for (;;) {
@@ -674,10 +651,9 @@ nni_win_ipc_conn_thr(void *arg)
 				continue;
 			}
 			nni_list_remove(&ep->aios, aio);
-			p = CreateFileA(ep->path,
-				GENERIC_READ | GENERIC_WRITE,
-				0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED,
-				NULL);
+			p = CreateFileA(ep->path, GENERIC_READ | GENERIC_WRITE,
+			    0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED,
+			    NULL);
 
 			if (p == INVALID_HANDLE_VALUE) {
 				switch ((rv = GetLastError())) {
@@ -686,12 +662,12 @@ nni_win_ipc_conn_thr(void *arg)
 					nni_list_prepend(&ep->aios, aio);
 					break;
 				case ERROR_FILE_NOT_FOUND:
-					nni_aio_finish(aio, NNG_ECONNREFUSED,
-					    0);
+					nni_aio_finish(
+					    aio, NNG_ECONNREFUSED, 0);
 					break;
 				default:
-					nni_aio_finish(aio, nni_win_error(rv),
-					    0);
+					nni_aio_finish(
+					    aio, nni_win_error(rv), 0);
 					break;
 				}
 			} else {
@@ -723,12 +699,11 @@ nni_win_ipc_conn_thr(void *arg)
 	nni_mtx_unlock(&w->mtx);
 }
 
-
 static void
 nni_win_ipc_conn_cancel(nni_aio *aio)
 {
-	nni_win_ipc_conn_work *w = &nni_win_ipc_connecter;
-	nni_plat_ipc_ep *ep = aio->a_prov_data;
+	nni_win_ipc_conn_work *w  = &nni_win_ipc_connecter;
+	nni_plat_ipc_ep *      ep = aio->a_prov_data;
 
 	nni_mtx_lock(&w->mtx);
 	nni_aio_list_remove(aio);
@@ -738,7 +713,6 @@ nni_win_ipc_conn_cancel(nni_aio *aio)
 	nni_mtx_unlock(&w->mtx);
 }
 
-
 void
 nni_plat_ipc_ep_connect(nni_plat_ipc_ep *ep, nni_aio *aio)
 {
@@ -762,7 +736,6 @@ nni_plat_ipc_ep_connect(nni_plat_ipc_ep *ep, nni_aio *aio)
 	nni_mtx_unlock(&w->mtx);
 }
 
-
 void
 nni_plat_ipc_ep_fini(nni_plat_ipc_ep *ep)
 {
@@ -776,12 +749,11 @@ nni_plat_ipc_ep_fini(nni_plat_ipc_ep *ep)
 	NNI_FREE_STRUCT(ep);
 }
 
-
 void
 nni_plat_ipc_ep_close(nni_plat_ipc_ep *ep)
 {
 	nni_win_ipc_conn_work *w = &nni_win_ipc_connecter;
-	nni_aio *aio;
+	nni_aio *              aio;
 
 	switch (ep->mode) {
 	case NNI_EP_MODE_DIAL:
@@ -811,11 +783,10 @@ nni_plat_ipc_ep_close(nni_plat_ipc_ep *ep)
 	}
 }
 
-
 int
 nni_win_ipc_sysinit(void)
 {
-	int rv;
+	int                    rv;
 	nni_win_ipc_conn_work *worker = &nni_win_ipc_connecter;
 
 	NNI_LIST_INIT(&worker->workers, nni_plat_ipc_ep, node);
@@ -835,7 +806,6 @@ nni_win_ipc_sysinit(void)
 	return (0);
 }
 
-
 void
 nni_win_ipc_sysfini(void)
 {
@@ -850,7 +820,6 @@ nni_win_ipc_sysfini(void)
 	nni_mtx_fini(&worker->mtx);
 }
 
-
 #else
 
 // Suppress empty symbols warnings in ranlib.
diff --git a/src/platform/windows/win_net.c b/src/platform/windows/win_net.c
index 2a77d97f..19491d02 100644
--- a/src/platform/windows/win_net.c
+++ b/src/platform/windows/win_net.c
@@ -14,36 +14,33 @@
 #include <stdio.h>
 
 static LPFN_CONNECTEX nni_win_connectex;
-static LPFN_ACCEPTEX nni_win_acceptex;
-
+static LPFN_ACCEPTEX  nni_win_acceptex;
 
 struct nni_plat_tcp_pipe {
-	SOCKET		s;
-	nni_win_event	recv_evt;
-	nni_win_event	send_evt;
-	WSAOVERLAPPED	recv_olpd;
-	WSAOVERLAPPED	send_olpd;
+	SOCKET        s;
+	nni_win_event recv_evt;
+	nni_win_event send_evt;
+	WSAOVERLAPPED recv_olpd;
+	WSAOVERLAPPED send_olpd;
 };
 
-
 struct nni_plat_tcp_ep {
-	SOCKET		s;
-	nni_win_event	evt;
-	WSAOVERLAPPED	olpd;
+	SOCKET        s;
+	nni_win_event evt;
+	WSAOVERLAPPED olpd;
 
 	// We have to lookup some function pointers using ioctls.  Winsock,
 	// gotta love it.
-	LPFN_CONNECTEX	connectex;
-	LPFN_ACCEPTEX	acceptex;
+	LPFN_CONNECTEX connectex;
+	LPFN_ACCEPTEX  acceptex;
 };
 
-
 // Windows has infinite numbers of error codes it seems.
 static struct {
-	int	wsa_err;
-	int	nng_err;
-}
-nni_plat_wsa_errnos[] = {
+	int wsa_err;
+	int nng_err;
+} nni_plat_wsa_errnos[] = {
+	// clang-format off
 	{ WSA_INVALID_HANDLE,	  NNG_ECLOSED			       },
 	{ WSA_NOT_ENOUGH_MEMORY,  NNG_ENOMEM			       },
 	{ WSA_INVALID_PARAMETER,  NNG_EINVAL			       },
@@ -106,6 +103,7 @@ nni_plat_wsa_errnos[] = {
 	// Eliding all the QoS related errors.
 	// Must be Last!!
 	{		       0,				     0 },
+	// clang-format on	
 };
 
 
diff --git a/src/platform/windows/win_pipe.c b/src/platform/windows/win_pipe.c
index 22886faa..ed6149c0 100644
--- a/src/platform/windows/win_pipe.c
+++ b/src/platform/windows/win_pipe.c
@@ -24,17 +24,17 @@ nni_plat_pipe_open(int *wfdp, int *rfdp)
 	SOCKET wfd = INVALID_SOCKET;
 
 	struct sockaddr_in addr;
-	socklen_t alen;
-	int one;
-	ULONG yes;
-	int rv;
+	socklen_t          alen;
+	int                one;
+	ULONG              yes;
+	int                rv;
 
-	ZeroMemory(&addr, sizeof (addr));
+	ZeroMemory(&addr, sizeof(addr));
 
 	// Restrict our bind to the loopback address.  We bind to an
 	// ephemeral port.
-	addr.sin_family = AF_INET;
-	addr.sin_port = 0;
+	addr.sin_family      = AF_INET;
+	addr.sin_port        = 0;
 	addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 
 	afd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
@@ -42,15 +42,14 @@ nni_plat_pipe_open(int *wfdp, int *rfdp)
 		goto fail;
 	}
 
-
 	// Make sure we have exclusive address use...
 	one = 1;
-	if (setsockopt(afd, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
-	    (char *) (&one), sizeof (one)) != 0) {
+	if (setsockopt(afd, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char *) (&one),
+	        sizeof(one)) != 0) {
 		goto fail;
 	}
 
-	alen = sizeof (addr);
+	alen = sizeof(addr);
 	if (bind(afd, (struct sockaddr *) &addr, alen) != 0) {
 		goto fail;
 	}
@@ -110,7 +109,6 @@ fail:
 	return (rv);
 }
 
-
 void
 nni_plat_pipe_raise(int wfd)
 {
@@ -119,7 +117,6 @@ nni_plat_pipe_raise(int wfd)
 	send((SOCKET) wfd, &c, 1, 0);
 }
 
-
 void
 nni_plat_pipe_clear(int rfd)
 {
@@ -128,13 +125,12 @@ nni_plat_pipe_clear(int rfd)
 	for (;;) {
 		// Completely drain the pipe, but don't wait.  This coalesces
 		// events somewhat.
-		if (recv((SOCKET) rfd, buf, sizeof (buf), 0) <= 0) {
+		if (recv((SOCKET) rfd, buf, sizeof(buf), 0) <= 0) {
 			return;
 		}
 	}
 }
 
-
 void
 nni_plat_pipe_close(int wfd, int rfd)
 {
@@ -142,7 +138,6 @@ nni_plat_pipe_close(int wfd, int rfd)
 	closesocket((SOCKET) rfd);
 }
 
-
 #else
 
 // Suppress empty symbols warnings in ranlib.
diff --git a/src/platform/windows/win_rand.c b/src/platform/windows/win_rand.c
index a1e381d8..38c86572 100644
--- a/src/platform/windows/win_rand.c
+++ b/src/platform/windows/win_rand.c
@@ -21,18 +21,17 @@ nni_plat_seed_prng(void *buf, size_t bufsz)
 	// The rand_s routine uses RtlGenRandom to get high quality
 	// pseudo random numbers (i.e. numbers that should be good enough
 	// for use with crypto keying.)
-	while (bufsz > sizeof (val)) {
+	while (bufsz > sizeof(val)) {
 		rand_s(&val);
-		memcpy(buf, &val, sizeof (val));
-		buf = (((char *) buf) + sizeof (val));
-		bufsz -= sizeof (val);
+		memcpy(buf, &val, sizeof(val));
+		buf = (((char *) buf) + sizeof(val));
+		bufsz -= sizeof(val);
 	}
 }
 
-
 #else
 
 // Suppress empty symbols warnings in ranlib.
 int nni_win_rand_not_used = 0;
 
-#endif  // PLATFORM_WINDOWS
+#endif // PLATFORM_WINDOWS
diff --git a/src/platform/windows/win_resolv.c b/src/platform/windows/win_resolv.c
index 3d37d546..44d00c34 100644
--- a/src/platform/windows/win_resolv.c
+++ b/src/platform/windows/win_resolv.c
@@ -7,7 +7,6 @@
 // found online at https://opensource.org/licenses/MIT.
 //
 
-
 #include "core/nng_impl.h"
 
 #ifdef PLATFORM_WINDOWS
@@ -23,25 +22,23 @@
 // changed with this define.
 
 #ifndef NNG_WIN_RESOLV_CONCURRENCY
-#define NNG_WIN_RESOLV_CONCURRENCY    4
+#define NNG_WIN_RESOLV_CONCURRENCY 4
 #endif
 
-
 static nni_taskq *nni_win_resolv_tq = NULL;
-static nni_mtx nni_win_resolv_mtx;
+static nni_mtx    nni_win_resolv_mtx;
 
-typedef struct nni_win_resolv_item   nni_win_resolv_item;
+typedef struct nni_win_resolv_item nni_win_resolv_item;
 struct nni_win_resolv_item {
-	int		family;
-	int		passive;
-	const char *	name;
-	const char *	serv;
-	int		proto;
-	nni_aio *	aio;
-	nni_taskq_ent	tqe;
+	int           family;
+	int           passive;
+	const char *  name;
+	const char *  serv;
+	int           proto;
+	nni_aio *     aio;
+	nni_taskq_ent tqe;
 };
 
-
 static void
 nni_win_resolv_finish(nni_win_resolv_item *item, int rv)
 {
@@ -52,7 +49,6 @@ nni_win_resolv_finish(nni_win_resolv_item *item, int rv)
 	NNI_FREE_STRUCT(item);
 }
 
-
 static void
 nni_win_resolv_cancel(nni_aio *aio)
 {
@@ -69,7 +65,6 @@ nni_win_resolv_cancel(nni_aio *aio)
 	NNI_FREE_STRUCT(item);
 }
 
-
 static int
 nni_win_gai_errno(int rv)
 {
@@ -97,16 +92,15 @@ nni_win_gai_errno(int rv)
 	}
 }
 
-
 static void
 nni_win_resolv_task(void *arg)
 {
 	nni_win_resolv_item *item = arg;
-	nni_aio *aio = item->aio;
-	struct addrinfo hints;
-	struct addrinfo *results;
-	struct addrinfo *probe;
-	int i, rv;
+	nni_aio *            aio  = item->aio;
+	struct addrinfo      hints;
+	struct addrinfo *    results;
+	struct addrinfo *    probe;
+	int                  i, rv;
 
 	results = NULL;
 
@@ -116,13 +110,13 @@ nni_win_resolv_task(void *arg)
 	case AF_UNSPEC:
 		// We treat these all as IP addresses.  The service and the
 		// host part are split.
-		memset(&hints, 0, sizeof (hints));
+		memset(&hints, 0, sizeof(hints));
 		if (item->passive) {
 			hints.ai_flags |= AI_PASSIVE;
 		}
 		hints.ai_flags |= AI_ADDRCONFIG;
 		hints.ai_protocol = item->proto;
-		hints.ai_family = item->family;
+		hints.ai_family   = item->family;
 		if (item->family == AF_INET6) {
 			hints.ai_flags |= AI_V4MAPPED;
 		}
@@ -152,27 +146,27 @@ nni_win_resolv_task(void *arg)
 		aio->a_addrs = NNI_ALLOC_STRUCTS(aio->a_addrs, aio->a_naddrs);
 		if (aio->a_addrs == NULL) {
 			aio->a_naddrs = 0;
-			rv = NNG_ENOMEM;
+			rv            = NNG_ENOMEM;
 			break;
 		}
 		i = 0;
 		for (probe = results; probe != NULL; probe = probe->ai_next) {
-			struct sockaddr_in *sin;
+			struct sockaddr_in * sin;
 			struct sockaddr_in6 *sin6;
-			nng_sockaddr *sa = &aio->a_addrs[i];
+			nng_sockaddr *       sa = &aio->a_addrs[i];
 
 			switch (probe->ai_addr->sa_family) {
 			case AF_INET:
 				sin = (void *) probe->ai_addr;
 				sa->s_un.s_in.sa_family = NNG_AF_INET;
-				sa->s_un.s_in.sa_port = sin->sin_port;
-				sa->s_un.s_in.sa_addr = sin->sin_addr.s_addr;
+				sa->s_un.s_in.sa_port   = sin->sin_port;
+				sa->s_un.s_in.sa_addr   = sin->sin_addr.s_addr;
 				i++;
 				break;
 			case AF_INET6:
 				sin6 = (void *) probe->ai_addr;
 				sa->s_un.s_in6.sa_family = NNG_AF_INET6;
-				sa->s_un.s_in6.sa_port = sin6->sin6_port;
+				sa->s_un.s_in6.sa_port   = sin6->sin6_port;
 				memcpy(sa->s_un.s_in6.sa_addr,
 				    sin6->sin6_addr.s6_addr, 16);
 				i++;
@@ -200,13 +194,12 @@ nni_win_resolv_task(void *arg)
 	nni_mtx_unlock(&nni_win_resolv_mtx);
 }
 
-
 static void
-nni_win_resolv_ip(const char *host, const char *serv, int passive,
-    int family, int proto, nni_aio *aio)
+nni_win_resolv_ip(const char *host, const char *serv, int passive, int family,
+    int proto, nni_aio *aio)
 {
 	nni_win_resolv_item *item;
-	int rv;
+	int                  rv;
 
 	if ((aio->a_naddrs != 0) && (aio->a_addrs != NULL)) {
 		NNI_FREE_STRUCTS(aio->a_addrs, aio->a_naddrs);
@@ -231,10 +224,10 @@ nni_win_resolv_ip(const char *host, const char *serv, int passive,
 	}
 	// NB: host and serv must remain valid until this is completed.
 	item->passive = passive;
-	item->name = host;
-	item->serv = serv;
-	item->proto = proto;
-	item->aio = aio;
+	item->name    = host;
+	item->serv    = serv;
+	item->proto   = proto;
+	item->aio     = aio;
 
 	nni_mtx_lock(&nni_win_resolv_mtx);
 	// If we were stopped, we're done...
@@ -251,15 +244,13 @@ nni_win_resolv_ip(const char *host, const char *serv, int passive,
 	nni_mtx_unlock(&nni_win_resolv_mtx);
 }
 
-
 void
-nni_plat_tcp_resolv(const char *host, const char *serv, int family,
-    int passive, nni_aio *aio)
+nni_plat_tcp_resolv(
+    const char *host, const char *serv, int family, int passive, nni_aio *aio)
 {
 	nni_win_resolv_ip(host, serv, passive, family, IPPROTO_TCP, aio);
 }
 
-
 int
 nni_win_resolv_sysinit(void)
 {
@@ -275,7 +266,6 @@ nni_win_resolv_sysinit(void)
 	return (0);
 }
 
-
 void
 nni_win_resolv_sysfini(void)
 {
@@ -286,7 +276,6 @@ nni_win_resolv_sysfini(void)
 	nni_mtx_fini(&nni_win_resolv_mtx);
 }
 
-
 #else
 
 // Suppress empty symbols warnings in ranlib.
diff --git a/src/platform/windows/win_thread.c b/src/platform/windows/win_thread.c
index bc2d7a0c..693516bd 100644
--- a/src/platform/windows/win_thread.c
+++ b/src/platform/windows/win_thread.c
@@ -22,7 +22,6 @@ nni_alloc(size_t sz)
 	return (v);
 }
 
-
 void
 nni_free(void *b, size_t z)
 {
@@ -30,7 +29,6 @@ nni_free(void *b, size_t z)
 	HeapFree(GetProcessHeap(), 0, b);
 }
 
-
 int
 nni_plat_mtx_init(nni_plat_mtx *mtx)
 {
@@ -39,28 +37,24 @@ nni_plat_mtx_init(nni_plat_mtx *mtx)
 	return (0);
 }
 
-
 void
 nni_plat_mtx_fini(nni_plat_mtx *mtx)
 {
 	mtx->init = 0;
 }
 
-
 void
 nni_plat_mtx_lock(nni_plat_mtx *mtx)
 {
 	AcquireSRWLockExclusive(&mtx->srl);
 }
 
-
 void
 nni_plat_mtx_unlock(nni_plat_mtx *mtx)
 {
 	ReleaseSRWLockExclusive(&mtx->srl);
 }
 
-
 int
 nni_plat_cv_init(nni_plat_cv *cv, nni_plat_mtx *mtx)
 {
@@ -69,49 +63,43 @@ nni_plat_cv_init(nni_plat_cv *cv, nni_plat_mtx *mtx)
 	return (0);
 }
 
-
 void
 nni_plat_cv_wake(nni_plat_cv *cv)
 {
 	WakeAllConditionVariable(&cv->cv);
 }
 
-
 void
 nni_plat_cv_wait(nni_plat_cv *cv)
 {
 	(void) SleepConditionVariableSRW(&cv->cv, cv->srl, INFINITE, 0);
 }
 
-
 int
 nni_plat_cv_until(nni_plat_cv *cv, nni_time until)
 {
 	nni_time now;
-	DWORD msec;
-	BOOL ok;
+	DWORD    msec;
+	BOOL     ok;
 
 	now = nni_plat_clock();
 	if (now > until) {
 		msec = 0;
 	} else {
 		// times are in usec, but win32 wants millis
-		msec = (DWORD) (((until - now) + 999)/1000);
+		msec = (DWORD)(((until - now) + 999) / 1000);
 	}
 
 	ok = SleepConditionVariableSRW(&cv->cv, cv->srl, msec, 0);
 	return (ok ? 0 : NNG_ETIMEDOUT);
 }
 
-
 void
 nni_plat_cv_fini(nni_plat_cv *cv)
 {
 }
 
-
-static unsigned int __stdcall
-nni_plat_thr_main(void *arg)
+static unsigned int __stdcall nni_plat_thr_main(void *arg)
 {
 	nni_plat_thr *thr = arg;
 
@@ -119,25 +107,22 @@ nni_plat_thr_main(void *arg)
 	return (0);
 }
 
-
 int
 nni_plat_thr_init(nni_plat_thr *thr, void (*fn)(void *), void *arg)
 {
 	thr->func = fn;
-	thr->arg = arg;
+	thr->arg  = arg;
 
 	// We could probably even go down to 8k... but crypto for some
 	// protocols might get bigger than this.  1MB is waaay too big.
-	thr->handle = (HANDLE) _beginthreadex(NULL, 16384,
-		nni_plat_thr_main, thr, STACK_SIZE_PARAM_IS_A_RESERVATION,
-		NULL);
+	thr->handle = (HANDLE) _beginthreadex(NULL, 16384, nni_plat_thr_main,
+	    thr, STACK_SIZE_PARAM_IS_A_RESERVATION, NULL);
 	if (thr->handle == NULL) {
-		return (NNG_ENOMEM);    // Best guess...
+		return (NNG_ENOMEM); // Best guess...
 	}
 	return (0);
 }
 
-
 void
 nni_plat_thr_fini(nni_plat_thr *thr)
 {
@@ -149,23 +134,22 @@ nni_plat_thr_fini(nni_plat_thr *thr)
 	}
 }
 
-
 int
 nni_plat_init(int (*helper)(void))
 {
-	static LONG inited = 0;
-	int rv;
+	static LONG    inited = 0;
+	int            rv;
 	static SRWLOCK lock = SRWLOCK_INIT;
 
 	if (inited) {
-		return (0);     // fast path
+		return (0); // fast path
 	}
 
 	AcquireSRWLockExclusive(&lock);
 
 	if (!inited) {
 		WSADATA data;
-		WORD ver;
+		WORD    ver;
 		ver = MAKEWORD(2, 2);
 		if (WSAStartup(MAKEWORD(2, 2), &data) != 0) {
 			if ((LOBYTE(data.wVersion) != 2) ||
@@ -195,7 +179,6 @@ out:
 	return (rv);
 }
 
-
 void
 nni_plat_fini(void)
 {
@@ -205,7 +188,6 @@ nni_plat_fini(void)
 	WSACleanup();
 }
 
-
 #else
 
 // Suppress empty symbols warnings in ranlib.