fixes #595 mutex leak and other minor errors in TCP

fixes #596 POSIX IPC should move away from pipedesc/epdesc
fixes #598 TLS and TCP listeners could support NNG_OPT_LOCADDR
fixes #594 Windows IPC should use "new style" win_io code.
fixes #597 macOS could support PEER PID

This large change set cleans up the IPC support on Windows and
POSIX.  This has the beneficial impact of significantly reducing
the complexity of the code, reducing locking, increasing
concurrency (multiple dial and accepts can be outstanding now),
reducing context switches (we complete thins synchronously now).

While here we have added some missing option support, and fixed a
few more bugs that we found in the TCP code changes from last week.

1 files changed, 581 insertions, 429 deletions

diff --git a/src/transport/ipc/ipc.c b/src/transport/ipc/ipc.c
index 7d99e507..ee72d6d8 100644
--- a/src/transport/ipc/ipc.c
+++ b/src/transport/ipc/ipc.c
@@ -20,16 +20,17 @@
 // Windows named pipes.  Other platforms could use other mechanisms,
 // but all implementations on the platform must use the same mechanism.
 
-typedef struct ipc_pipe ipc_pipe;
-typedef struct ipc_ep   ipc_ep;
+typedef struct ipctran_pipe     ipctran_pipe;
+typedef struct ipctran_dialer   ipctran_dialer;
+typedef struct ipctran_listener ipctran_listener;
 
 // ipc_pipe is one end of an IPC connection.
-struct ipc_pipe {
-	nni_plat_ipc_pipe *ipp;
-	uint16_t           peer;
-	uint16_t           proto;
-	size_t             rcvmax;
-	nni_sockaddr       sa;
+struct ipctran_pipe {
+	nni_ipc_conn *conn;
+	uint16_t      peer;
+	uint16_t      proto;
+	size_t        rcvmax;
+	nni_sockaddr  sa;
 
 	uint8_t txhead[1 + sizeof(uint64_t)];
 	uint8_t rxhead[1 + sizeof(uint64_t)];
@@ -48,189 +49,201 @@ struct ipc_pipe {
 	nni_mtx  mtx;
 };
 
-struct ipc_ep {
-	nni_sockaddr     sa;
-	nni_plat_ipc_ep *iep;
-	uint16_t         proto;
-	size_t           rcvmax;
-	nni_aio *        aio;
-	nni_aio *        user_aio;
-	nni_mtx          mtx;
+struct ipctran_dialer {
+	nni_sockaddr    sa;
+	nni_ipc_dialer *dialer;
+	uint16_t        proto;
+	size_t          rcvmax;
+	nni_aio *       aio;
+	nni_aio *       user_aio;
+	nni_mtx         mtx;
 };
 
-static void ipc_pipe_dosend(ipc_pipe *, nni_aio *);
-static void ipc_pipe_dorecv(ipc_pipe *);
-static void ipc_pipe_send_cb(void *);
-static void ipc_pipe_recv_cb(void *);
-static void ipc_pipe_nego_cb(void *);
-static void ipc_ep_cb(void *);
+struct ipctran_listener {
+	nni_sockaddr      sa;
+	nni_ipc_listener *listener;
+	uint16_t          proto;
+	size_t            rcvmax;
+	nni_aio *         aio;
+	nni_aio *         user_aio;
+	nni_mtx           mtx;
+};
+
+static void ipctran_pipe_send_start(ipctran_pipe *);
+static void ipctran_pipe_recv_start(ipctran_pipe *);
+static void ipctran_pipe_send_cb(void *);
+static void ipctran_pipe_recv_cb(void *);
+static void ipctran_pipe_nego_cb(void *);
+static void ipctran_dialer_cb(void *);
+static void ipctran_listener_cb(void *);
 
 static int
-ipc_tran_init(void)
+ipctran_init(void)
 {
 	return (0);
 }
 
 static void
-ipc_tran_fini(void)
+ipctran_fini(void)
 {
 }
 
 static void
-ipc_pipe_close(void *arg)
+ipctran_pipe_close(void *arg)
 {
-	ipc_pipe *pipe = arg;
+	ipctran_pipe *p = arg;
 
-	nni_aio_close(pipe->rxaio);
-	nni_aio_close(pipe->txaio);
-	nni_aio_close(pipe->negaio);
+	nni_aio_close(p->rxaio);
+	nni_aio_close(p->txaio);
+	nni_aio_close(p->negaio);
 
-	nni_plat_ipc_pipe_close(pipe->ipp);
+	nni_ipc_conn_close(p->conn);
 }
 
 static void
-ipc_pipe_stop(void *arg)
+ipctran_pipe_stop(void *arg)
 {
-	ipc_pipe *pipe = arg;
+	ipctran_pipe *p = arg;
 
-	nni_aio_stop(pipe->rxaio);
-	nni_aio_stop(pipe->txaio);
-	nni_aio_stop(pipe->negaio);
+	nni_aio_stop(p->rxaio);
+	nni_aio_stop(p->txaio);
+	nni_aio_stop(p->negaio);
 }
 
 static void
-ipc_pipe_fini(void *arg)
+ipctran_pipe_fini(void *arg)
 {
-	ipc_pipe *pipe = arg;
+	ipctran_pipe *p = arg;
 
-	nni_aio_fini(pipe->rxaio);
-	nni_aio_fini(pipe->txaio);
-	nni_aio_fini(pipe->negaio);
-	if (pipe->ipp != NULL) {
-		nni_plat_ipc_pipe_fini(pipe->ipp);
+	nni_aio_fini(p->rxaio);
+	nni_aio_fini(p->txaio);
+	nni_aio_fini(p->negaio);
+	if (p->conn != NULL) {
+		nni_ipc_conn_fini(p->conn);
 	}
-	if (pipe->rxmsg) {
-		nni_msg_free(pipe->rxmsg);
+	if (p->rxmsg) {
+		nni_msg_free(p->rxmsg);
 	}
-	nni_mtx_fini(&pipe->mtx);
-	NNI_FREE_STRUCT(pipe);
+	nni_mtx_fini(&p->mtx);
+	NNI_FREE_STRUCT(p);
 }
 
 static int
-ipc_pipe_init(ipc_pipe **pipep, ipc_ep *ep, void *ipp)
+ipctran_pipe_init(ipctran_pipe **pipep, void *conn)
 {
-	ipc_pipe *p;
-	int       rv;
+	ipctran_pipe *p;
+	int           rv;
 
 	if ((p = NNI_ALLOC_STRUCT(p)) == NULL) {
 		return (NNG_ENOMEM);
 	}
 	nni_mtx_init(&p->mtx);
-	if (((rv = nni_aio_init(&p->txaio, ipc_pipe_send_cb, p)) != 0) ||
-	    ((rv = nni_aio_init(&p->rxaio, ipc_pipe_recv_cb, p)) != 0) ||
-	    ((rv = nni_aio_init(&p->negaio, ipc_pipe_nego_cb, p)) != 0)) {
-		ipc_pipe_fini(p);
+	if (((rv = nni_aio_init(&p->txaio, ipctran_pipe_send_cb, p)) != 0) ||
+	    ((rv = nni_aio_init(&p->rxaio, ipctran_pipe_recv_cb, p)) != 0) ||
+	    ((rv = nni_aio_init(&p->negaio, ipctran_pipe_nego_cb, p)) != 0)) {
+		ipctran_pipe_fini(p);
 		return (rv);
 	}
 	nni_aio_list_init(&p->sendq);
 	nni_aio_list_init(&p->recvq);
 
+	p->conn = conn;
+#if 0
 	p->proto              = ep->proto;
 	p->rcvmax             = ep->rcvmax;
-	p->ipp                = ipp;
 	p->sa.s_ipc.sa_family = NNG_AF_IPC;
 	p->sa                 = ep->sa;
-
+#endif
 	*pipep = p;
 	return (0);
 }
 
 static void
-ipc_cancel_start(nni_aio *aio, int rv)
+ipctran_pipe_nego_cancel(nni_aio *aio, int rv)
 {
-	ipc_pipe *pipe = nni_aio_get_prov_data(aio);
+	ipctran_pipe *p = nni_aio_get_prov_data(aio);
 
-	nni_mtx_lock(&pipe->mtx);
-	if (pipe->user_negaio != aio) {
-		nni_mtx_unlock(&pipe->mtx);
+	nni_mtx_lock(&p->mtx);
+	if (p->user_negaio != aio) {
+		nni_mtx_unlock(&p->mtx);
 		return;
 	}
-	pipe->user_negaio = NULL;
-	nni_mtx_unlock(&pipe->mtx);
+	p->user_negaio = NULL;
+	nni_mtx_unlock(&p->mtx);
 
-	nni_aio_abort(pipe->negaio, rv);
+	nni_aio_abort(p->negaio, rv);
 	nni_aio_finish_error(aio, rv);
 }
 
 static void
-ipc_pipe_nego_cb(void *arg)
+ipctran_pipe_nego_cb(void *arg)
 {
-	ipc_pipe *pipe = arg;
-	nni_aio * aio  = pipe->negaio;
-	int       rv;
+	ipctran_pipe *p   = arg;
+	nni_aio *     aio = p->negaio;
+	int           rv;
 
-	nni_mtx_lock(&pipe->mtx);
+	nni_mtx_lock(&p->mtx);
 	if ((rv = nni_aio_result(aio)) != 0) {
 		goto done;
 	}
 
 	// We start transmitting before we receive.
-	if (pipe->gottxhead < pipe->wanttxhead) {
-		pipe->gottxhead += nni_aio_count(aio);
-	} else if (pipe->gotrxhead < pipe->wantrxhead) {
-		pipe->gotrxhead += nni_aio_count(aio);
+	if (p->gottxhead < p->wanttxhead) {
+		p->gottxhead += nni_aio_count(aio);
+	} else if (p->gotrxhead < p->wantrxhead) {
+		p->gotrxhead += nni_aio_count(aio);
 	}
 
-	if (pipe->gottxhead < pipe->wanttxhead) {
+	if (p->gottxhead < p->wanttxhead) {
 		nni_iov iov;
-		iov.iov_len = pipe->wanttxhead - pipe->gottxhead;
-		iov.iov_buf = &pipe->txhead[pipe->gottxhead];
+		iov.iov_len = p->wanttxhead - p->gottxhead;
+		iov.iov_buf = &p->txhead[p->gottxhead];
 		nni_aio_set_iov(aio, 1, &iov);
 		// send it down...
-		nni_plat_ipc_pipe_send(pipe->ipp, aio);
-		nni_mtx_unlock(&pipe->mtx);
+		nni_ipc_conn_send(p->conn, aio);
+		nni_mtx_unlock(&p->mtx);
 		return;
 	}
-	if (pipe->gotrxhead < pipe->wantrxhead) {
+	if (p->gotrxhead < p->wantrxhead) {
 		nni_iov iov;
-		iov.iov_len = pipe->wantrxhead - pipe->gotrxhead;
-		iov.iov_buf = &pipe->rxhead[pipe->gotrxhead];
+		iov.iov_len = p->wantrxhead - p->gotrxhead;
+		iov.iov_buf = &p->rxhead[p->gotrxhead];
 		nni_aio_set_iov(aio, 1, &iov);
-		nni_plat_ipc_pipe_recv(pipe->ipp, aio);
-		nni_mtx_unlock(&pipe->mtx);
+		nni_ipc_conn_recv(p->conn, aio);
+		nni_mtx_unlock(&p->mtx);
 		return;
 	}
 	// We have both sent and received the headers.  Lets check the
 	// receive side header.
-	if ((pipe->rxhead[0] != 0) || (pipe->rxhead[1] != 'S') ||
-	    (pipe->rxhead[2] != 'P') || (pipe->rxhead[3] != 0) ||
-	    (pipe->rxhead[6] != 0) || (pipe->rxhead[7] != 0)) {
+	if ((p->rxhead[0] != 0) || (p->rxhead[1] != 'S') ||
+	    (p->rxhead[2] != 'P') || (p->rxhead[3] != 0) ||
+	    (p->rxhead[6] != 0) || (p->rxhead[7] != 0)) {
 		rv = NNG_EPROTO;
 		goto done;
 	}
 
-	NNI_GET16(&pipe->rxhead[4], pipe->peer);
+	NNI_GET16(&p->rxhead[4], p->peer);
 
 done:
-	if ((aio = pipe->user_negaio) != NULL) {
-		pipe->user_negaio = NULL;
+	if ((aio = p->user_negaio) != NULL) {
+		p->user_negaio = NULL;
 		nni_aio_finish(aio, rv, 0);
 	}
-	nni_mtx_unlock(&pipe->mtx);
+	nni_mtx_unlock(&p->mtx);
 }
 
 static void
-ipc_pipe_send_cb(void *arg)
+ipctran_pipe_send_cb(void *arg)
 {
-	ipc_pipe *pipe = arg;
-	nni_aio * aio;
-	nni_aio * txaio = pipe->txaio;
-	nni_msg * msg;
-	int       rv;
-	size_t    n;
+	ipctran_pipe *p = arg;
+	int           rv;
+	nni_aio *     aio;
+	size_t        n;
+	nni_msg *     msg;
+	nni_aio *     txaio = p->txaio;
 
-	nni_mtx_lock(&pipe->mtx);
-	aio = nni_list_first(&pipe->sendq);
+	nni_mtx_lock(&p->mtx);
+	aio = nni_list_first(&p->sendq);
 
 	if ((rv = nni_aio_result(txaio)) != 0) {
 		// Intentionally we do not queue up another transfer.
@@ -239,7 +252,7 @@ ipc_pipe_send_cb(void *arg)
 		// The protocol should see this error, and close the
 		// pipe itself, we hope.
 		nni_aio_list_remove(aio);
-		nni_mtx_unlock(&pipe->mtx);
+		nni_mtx_unlock(&p->mtx);
 		nni_aio_finish_error(aio, rv);
 		return;
 	}
@@ -247,17 +260,15 @@ ipc_pipe_send_cb(void *arg)
 	n = nni_aio_count(txaio);
 	nni_aio_iov_advance(txaio, n);
 	if (nni_aio_iov_count(txaio) != 0) {
-		nni_plat_ipc_pipe_send(pipe->ipp, txaio);
-		nni_mtx_unlock(&pipe->mtx);
+		nni_ipc_conn_send(p->conn, txaio);
+		nni_mtx_unlock(&p->mtx);
 		return;
 	}
 
 	nni_aio_list_remove(aio);
-	if (!nni_list_empty(&pipe->sendq)) {
-		// schedule next send
-		ipc_pipe_dosend(pipe, nni_list_first(&pipe->sendq));
-	}
-	nni_mtx_unlock(&pipe->mtx);
+	ipctran_pipe_send_start(p);
+
+	nni_mtx_unlock(&p->mtx);
 
 	msg = nni_aio_get_msg(aio);
 	n   = nni_msg_len(msg);
@@ -267,17 +278,17 @@ ipc_pipe_send_cb(void *arg)
 }
 
 static void
-ipc_pipe_recv_cb(void *arg)
+ipctran_pipe_recv_cb(void *arg)
 {
-	ipc_pipe *pipe = arg;
-	nni_aio * aio;
-	int       rv;
-	size_t    n;
-	nni_msg * msg;
-	nni_aio * rxaio = pipe->rxaio;
+	ipctran_pipe *p = arg;
+	nni_aio *     aio;
+	int           rv;
+	size_t        n;
+	nni_msg *     msg;
+	nni_aio *     rxaio = p->rxaio;
 
-	nni_mtx_lock(&pipe->mtx);
-	aio = nni_list_first(&pipe->recvq);
+	nni_mtx_lock(&p->mtx);
+	aio = nni_list_first(&p->recvq);
 
 	if ((rv = nni_aio_result(rxaio)) != 0) {
 		// Error on receive.  This has to cause an error back
@@ -290,29 +301,29 @@ ipc_pipe_recv_cb(void *arg)
 	nni_aio_iov_advance(rxaio, n);
 	if (nni_aio_iov_count(rxaio) != 0) {
 		// Was this a partial read?  If so then resubmit for the rest.
-		nni_plat_ipc_pipe_recv(pipe->ipp, rxaio);
-		nni_mtx_unlock(&pipe->mtx);
+		nni_ipc_conn_recv(p->conn, rxaio);
+		nni_mtx_unlock(&p->mtx);
 		return;
 	}
 
 	// If we don't have a message yet, we were reading the message
 	// header, which is just the length.  This tells us the size of the
 	// message to allocate and how much more to expect.
-	if (pipe->rxmsg == NULL) {
+	if (p->rxmsg == NULL) {
 		uint64_t len;
 
 		// Check to make sure we got msg type 1.
-		if (pipe->rxhead[0] != 1) {
+		if (p->rxhead[0] != 1) {
 			rv = NNG_EPROTO;
 			goto recv_error;
 		}
 
 		// We should have gotten a message header.
-		NNI_GET64(pipe->rxhead + 1, len);
+		NNI_GET64(p->rxhead + 1, len);
 
 		// Make sure the message payload is not too big.  If it is
 		// the caller will shut down the pipe.
-		if ((len > pipe->rcvmax) && (pipe->rcvmax > 0)) {
+		if ((len > p->rcvmax) && (p->rcvmax > 0)) {
 			rv = NNG_EMSGSIZE;
 			goto recv_error;
 		}
@@ -322,7 +333,7 @@ ipc_pipe_recv_cb(void *arg)
 		// lock for the read side in the future, so that we allow
 		// transmits to proceed normally.  In practice this is
 		// unlikely to be much of an issue though.
-		if ((rv = nni_msg_alloc(&pipe->rxmsg, (size_t) len)) != 0) {
+		if ((rv = nni_msg_alloc(&p->rxmsg, (size_t) len)) != 0) {
 			goto recv_error;
 		}
 
@@ -330,11 +341,12 @@ ipc_pipe_recv_cb(void *arg)
 			nni_iov iov;
 			// Submit the rest of the data for a read -- we want to
 			// read the entire message now.
-			iov.iov_buf = nni_msg_body(pipe->rxmsg);
+			iov.iov_buf = nni_msg_body(p->rxmsg);
 			iov.iov_len = (size_t) len;
+
 			nni_aio_set_iov(rxaio, 1, &iov);
-			nni_plat_ipc_pipe_recv(pipe->ipp, rxaio);
-			nni_mtx_unlock(&pipe->mtx);
+			nni_ipc_conn_recv(p->conn, rxaio);
+			nni_mtx_unlock(&p->mtx);
 			return;
 		}
 	}
@@ -343,12 +355,12 @@ ipc_pipe_recv_cb(void *arg)
 	// good news.
 
 	nni_aio_list_remove(aio);
-	msg         = pipe->rxmsg;
-	pipe->rxmsg = NULL;
-	if (!nni_list_empty(&pipe->recvq)) {
-		ipc_pipe_dorecv(pipe);
+	msg      = p->rxmsg;
+	p->rxmsg = NULL;
+	if (!nni_list_empty(&p->recvq)) {
+		ipctran_pipe_recv_start(p);
 	}
-	nni_mtx_unlock(&pipe->mtx);
+	nni_mtx_unlock(&p->mtx);
 
 	nni_aio_set_msg(aio, msg);
 	nni_aio_finish_synch(aio, 0, nni_msg_len(msg));
@@ -356,59 +368,65 @@ ipc_pipe_recv_cb(void *arg)
 
 recv_error:
 	nni_aio_list_remove(aio);
-	msg         = pipe->rxmsg;
-	pipe->rxmsg = NULL;
+	msg      = p->rxmsg;
+	p->rxmsg = NULL;
 	// Intentionally, we do not queue up another receive.
 	// The protocol should notice this error and close the pipe.
-	nni_mtx_unlock(&pipe->mtx);
+	nni_mtx_unlock(&p->mtx);
 
 	nni_msg_free(msg);
 	nni_aio_finish_error(aio, rv);
 }
 
 static void
-ipc_cancel_tx(nni_aio *aio, int rv)
+ipctran_pipe_send_cancel(nni_aio *aio, int rv)
 {
-	ipc_pipe *pipe = nni_aio_get_prov_data(aio);
+	ipctran_pipe *p = nni_aio_get_prov_data(aio);
 
-	nni_mtx_lock(&pipe->mtx);
+	nni_mtx_lock(&p->mtx);
 	if (!nni_aio_list_active(aio)) {
-		nni_mtx_unlock(&pipe->mtx);
+		nni_mtx_unlock(&p->mtx);
 		return;
 	}
 	// If this is being sent, then cancel the pending transfer.
 	// The callback on the txaio will cause the user aio to
 	// be canceled too.
-	if (nni_list_first(&pipe->sendq) == aio) {
-		nni_aio_abort(pipe->txaio, rv);
-		nni_mtx_unlock(&pipe->mtx);
+	if (nni_list_first(&p->sendq) == aio) {
+		nni_aio_abort(p->txaio, rv);
+		nni_mtx_unlock(&p->mtx);
 		return;
 	}
 	nni_aio_list_remove(aio);
-	nni_mtx_unlock(&pipe->mtx);
+	nni_mtx_unlock(&p->mtx);
+
 	nni_aio_finish_error(aio, rv);
 }
 
 static void
-ipc_pipe_dosend(ipc_pipe *pipe, nni_aio *aio)
+ipctran_pipe_send_start(ipctran_pipe *p)
 {
+	nni_aio *aio;
 	nni_aio *txaio;
 	nni_msg *msg;
 	int      niov;
 	nni_iov  iov[3];
 	uint64_t len;
 
+	if ((aio = nni_list_first(&p->sendq)) == NULL) {
+		return;
+	}
+
 	// This runs to send the message.
 	msg = nni_aio_get_msg(aio);
 	len = nni_msg_len(msg) + nni_msg_header_len(msg);
 
-	pipe->txhead[0] = 1; // message type, 1.
-	NNI_PUT64(pipe->txhead + 1, len);
+	p->txhead[0] = 1; // message type, 1.
+	NNI_PUT64(p->txhead + 1, len);
 
-	txaio          = pipe->txaio;
+	txaio          = p->txaio;
 	niov           = 0;
-	iov[0].iov_buf = pipe->txhead;
-	iov[0].iov_len = sizeof(pipe->txhead);
+	iov[0].iov_buf = p->txhead;
+	iov[0].iov_len = sizeof(p->txhead);
 	niov++;
 	if (nni_msg_header_len(msg) > 0) {
 		iov[niov].iov_buf = nni_msg_header(msg);
@@ -421,504 +439,643 @@ ipc_pipe_dosend(ipc_pipe *pipe, nni_aio *aio)
 		niov++;
 	}
 	nni_aio_set_iov(txaio, niov, iov);
-	nni_plat_ipc_pipe_send(pipe->ipp, txaio);
+	nni_ipc_conn_send(p->conn, txaio);
 }
 
 static void
-ipc_pipe_send(void *arg, nni_aio *aio)
+ipctran_pipe_send(void *arg, nni_aio *aio)
 {
-	ipc_pipe *pipe = arg;
-	int       rv;
+	ipctran_pipe *p = arg;
+	int           rv;
 
 	if (nni_aio_begin(aio) != 0) {
 		return;
 	}
-	nni_mtx_lock(&pipe->mtx);
-	if ((rv = nni_aio_schedule(aio, ipc_cancel_tx, pipe)) != 0) {
-		nni_mtx_unlock(&pipe->mtx);
+	nni_mtx_lock(&p->mtx);
+	if ((rv = nni_aio_schedule(aio, ipctran_pipe_send_cancel, p)) != 0) {
+		nni_mtx_unlock(&p->mtx);
 		nni_aio_finish_error(aio, rv);
 		return;
 	}
-	nni_list_append(&pipe->sendq, aio);
-	if (nni_list_first(&pipe->sendq) == aio) {
-		ipc_pipe_dosend(pipe, aio);
+	nni_list_append(&p->sendq, aio);
+	if (nni_list_first(&p->sendq) == aio) {
+		ipctran_pipe_send_start(p);
 	}
-	nni_mtx_unlock(&pipe->mtx);
+	nni_mtx_unlock(&p->mtx);
 }
 
 static void
-ipc_cancel_rx(nni_aio *aio, int rv)
+ipctran_pipe_recv_cancel(nni_aio *aio, int rv)
 {
-	ipc_pipe *pipe = nni_aio_get_prov_data(aio);
+	ipctran_pipe *p = nni_aio_get_prov_data(aio);
 
-	nni_mtx_lock(&pipe->mtx);
+	nni_mtx_lock(&p->mtx);
 	if (!nni_aio_list_active(aio)) {
-		nni_mtx_unlock(&pipe->mtx);
+		nni_mtx_unlock(&p->mtx);
 		return;
 	}
 	// If receive in progress, then cancel the pending transfer.
 	// The callback on the rxaio will cause the user aio to
 	// be canceled too.
-	if (nni_list_first(&pipe->recvq) == aio) {
-		nni_aio_abort(pipe->rxaio, rv);
-		nni_mtx_unlock(&pipe->mtx);
+	if (nni_list_first(&p->recvq) == aio) {
+		nni_aio_abort(p->rxaio, rv);
+		nni_mtx_unlock(&p->mtx);
 		return;
 	}
 	nni_aio_list_remove(aio);
-	nni_mtx_unlock(&pipe->mtx);
+	nni_mtx_unlock(&p->mtx);
 	nni_aio_finish_error(aio, rv);
 }
 
 static void
-ipc_pipe_dorecv(ipc_pipe *pipe)
+ipctran_pipe_recv_start(ipctran_pipe *p)
 {
 	nni_aio *rxaio;
 	nni_iov  iov;
-	NNI_ASSERT(pipe->rxmsg == NULL);
+	NNI_ASSERT(p->rxmsg == NULL);
 
 	// Schedule a read of the IPC header.
-	rxaio       = pipe->rxaio;
-	iov.iov_buf = pipe->rxhead;
-	iov.iov_len = sizeof(pipe->rxhead);
+	rxaio       = p->rxaio;
+	iov.iov_buf = p->rxhead;
+	iov.iov_len = sizeof(p->rxhead);
 	nni_aio_set_iov(rxaio, 1, &iov);
 
-	nni_plat_ipc_pipe_recv(pipe->ipp, rxaio);
+	nni_ipc_conn_recv(p->conn, rxaio);
 }
 
 static void
-ipc_pipe_recv(void *arg, nni_aio *aio)
+ipctran_pipe_recv(void *arg, nni_aio *aio)
 {
-	ipc_pipe *pipe = arg;
-	int       rv;
+	ipctran_pipe *p = arg;
+	int           rv;
 
 	if (nni_aio_begin(aio) != 0) {
 		return;
 	}
-	nni_mtx_lock(&pipe->mtx);
+	nni_mtx_lock(&p->mtx);
 
-	if ((rv = nni_aio_schedule(aio, ipc_cancel_rx, pipe)) != 0) {
-		nni_mtx_unlock(&pipe->mtx);
+	if ((rv = nni_aio_schedule(aio, ipctran_pipe_recv_cancel, p)) != 0) {
+		nni_mtx_unlock(&p->mtx);
 		nni_aio_finish_error(aio, rv);
 		return;
 	}
 
-	nni_list_append(&pipe->recvq, aio);
-	if (nni_list_first(&pipe->recvq) == aio) {
-		ipc_pipe_dorecv(pipe);
+	nni_list_append(&p->recvq, aio);
+	if (nni_list_first(&p->recvq) == aio) {
+		ipctran_pipe_recv_start(p);
 	}
-	nni_mtx_unlock(&pipe->mtx);
+	nni_mtx_unlock(&p->mtx);
 }
 
 static void
-ipc_pipe_start(void *arg, nni_aio *aio)
+ipctran_pipe_start(void *arg, nni_aio *aio)
 {
-	ipc_pipe *pipe = arg;
-	nni_aio * negaio;
-	nni_iov   iov;
-	int       rv;
+	ipctran_pipe *p = arg;
+	nni_aio *     negaio;
+	nni_iov       iov;
+	int           rv;
 
 	if (nni_aio_begin(aio) != 0) {
 		return;
 	}
-	nni_mtx_lock(&pipe->mtx);
-	if ((rv = nni_aio_schedule(aio, ipc_cancel_start, pipe)) != 0) {
-		nni_mtx_unlock(&pipe->mtx);
+	nni_mtx_lock(&p->mtx);
+	if ((rv = nni_aio_schedule(aio, ipctran_pipe_nego_cancel, p)) != 0) {
+		nni_mtx_unlock(&p->mtx);
 		nni_aio_finish_error(aio, rv);
 		return;
 	}
-	pipe->txhead[0] = 0;
-	pipe->txhead[1] = 'S';
-	pipe->txhead[2] = 'P';
-	pipe->txhead[3] = 0;
-	NNI_PUT16(&pipe->txhead[4], pipe->proto);
-	NNI_PUT16(&pipe->txhead[6], 0);
-
-	pipe->user_negaio = aio;
-	pipe->gotrxhead   = 0;
-	pipe->gottxhead   = 0;
-	pipe->wantrxhead  = 8;
-	pipe->wanttxhead  = 8;
-	negaio            = pipe->negaio;
-	iov.iov_len       = 8;
-	iov.iov_buf       = &pipe->txhead[0];
+	p->txhead[0] = 0;
+	p->txhead[1] = 'S';
+	p->txhead[2] = 'P';
+	p->txhead[3] = 0;
+	NNI_PUT16(&p->txhead[4], p->proto);
+	NNI_PUT16(&p->txhead[6], 0);
+
+	p->user_negaio = aio;
+	p->gotrxhead   = 0;
+	p->gottxhead   = 0;
+	p->wantrxhead  = 8;
+	p->wanttxhead  = 8;
+	negaio         = p->negaio;
+	iov.iov_len    = 8;
+	iov.iov_buf    = &p->txhead[0];
 	nni_aio_set_iov(negaio, 1, &iov);
-	nni_plat_ipc_pipe_send(pipe->ipp, negaio);
-	nni_mtx_unlock(&pipe->mtx);
+	nni_ipc_conn_send(p->conn, negaio);
+	nni_mtx_unlock(&p->mtx);
 }
 
 static uint16_t
-ipc_pipe_peer(void *arg)
+ipctran_pipe_peer(void *arg)
 {
-	ipc_pipe *pipe = arg;
+	ipctran_pipe *p = arg;
 
-	return (pipe->peer);
+	return (p->peer);
 }
 
 static int
-ipc_pipe_get_addr(void *arg, void *buf, size_t *szp, nni_opt_type t)
+ipctran_pipe_get_addr(void *arg, void *buf, size_t *szp, nni_opt_type t)
 {
-	ipc_pipe *p = arg;
+	ipctran_pipe *p = arg;
 	return (nni_copyout_sockaddr(&p->sa, buf, szp, t));
 }
 
 static int
-ipc_pipe_get_peer_uid(void *arg, void *buf, size_t *szp, nni_opt_type t)
+ipctran_pipe_get_peer_uid(void *arg, void *buf, size_t *szp, nni_opt_type t)
 {
-	ipc_pipe *p = arg;
-	uint64_t  id;
-	int       rv;
-	if ((rv = nni_plat_ipc_pipe_get_peer_uid(p->ipp, &id)) != 0) {
+	ipctran_pipe *p = arg;
+	uint64_t      id;
+	int           rv;
+	if ((rv = nni_ipc_conn_get_peer_uid(p->conn, &id)) != 0) {
 		return (rv);
 	}
 	return (nni_copyout_u64(id, buf, szp, t));
 }
 
 static int
-ipc_pipe_get_peer_gid(void *arg, void *buf, size_t *szp, nni_opt_type t)
+ipctran_pipe_get_peer_gid(void *arg, void *buf, size_t *szp, nni_opt_type t)
 {
-	ipc_pipe *p = arg;
-	uint64_t  id;
-	int       rv;
-	if ((rv = nni_plat_ipc_pipe_get_peer_gid(p->ipp, &id)) != 0) {
+	ipctran_pipe *p = arg;
+	uint64_t      id;
+	int           rv;
+	if ((rv = nni_ipc_conn_get_peer_gid(p->conn, &id)) != 0) {
 		return (rv);
 	}
 	return (nni_copyout_u64(id, buf, szp, t));
 }
 
 static int
-ipc_pipe_get_peer_pid(void *arg, void *buf, size_t *szp, nni_opt_type t)
+ipctran_pipe_get_peer_pid(void *arg, void *buf, size_t *szp, nni_opt_type t)
 {
-	ipc_pipe *p = arg;
-	uint64_t  id;
-	int       rv;
-	if ((rv = nni_plat_ipc_pipe_get_peer_pid(p->ipp, &id)) != 0) {
+	ipctran_pipe *p = arg;
+	uint64_t      id;
+	int           rv;
+	if ((rv = nni_ipc_conn_get_peer_pid(p->conn, &id)) != 0) {
 		return (rv);
 	}
 	return (nni_copyout_u64(id, buf, szp, t));
 }
 
 static int
-ipc_pipe_get_peer_zoneid(void *arg, void *buf, size_t *szp, nni_opt_type t)
+ipctran_pipe_get_peer_zoneid(void *arg, void *buf, size_t *szp, nni_opt_type t)
 {
-	ipc_pipe *p = arg;
-	uint64_t  id;
-	int       rv;
-	if ((rv = nni_plat_ipc_pipe_get_peer_zoneid(p->ipp, &id)) != 0) {
+	ipctran_pipe *p = arg;
+	uint64_t      id;
+	int           rv;
+	if ((rv = nni_ipc_conn_get_peer_zoneid(p->conn, &id)) != 0) {
 		return (rv);
 	}
 	return (nni_copyout_u64(id, buf, szp, t));
 }
 
 static void
-ipc_ep_fini(void *arg)
+ipctran_dialer_fini(void *arg)
 {
-	ipc_ep *ep = arg;
+	ipctran_dialer *d = arg;
 
-	nni_aio_stop(ep->aio);
-	nni_plat_ipc_ep_fini(ep->iep);
-	nni_aio_fini(ep->aio);
-	nni_mtx_fini(&ep->mtx);
-	NNI_FREE_STRUCT(ep);
+	nni_aio_stop(d->aio);
+	if (d->dialer != NULL) {
+		nni_ipc_dialer_fini(d->dialer);
+	}
+	nni_aio_fini(d->aio);
+	nni_mtx_fini(&d->mtx);
+	NNI_FREE_STRUCT(d);
+}
+
+static void
+ipctran_dialer_close(void *arg)
+{
+	ipctran_dialer *d = arg;
+
+	nni_aio_close(d->aio);
+	nni_ipc_dialer_close(d->dialer);
 }
 
 static int
-ipc_ep_init(void **epp, nni_url *url, nni_sock *sock, int mode)
+ipctran_dialer_init(void **dp, nni_url *url, nni_sock *sock)
 {
-	ipc_ep *ep;
-	int     rv;
-	size_t  sz;
+	ipctran_dialer *d;
+	int             rv;
+	size_t          sz;
 
-	if ((ep = NNI_ALLOC_STRUCT(ep)) == NULL) {
+	if ((d = NNI_ALLOC_STRUCT(d)) == NULL) {
 		return (NNG_ENOMEM);
 	}
-	nni_mtx_init(&ep->mtx);
+	nni_mtx_init(&d->mtx);
 
-	sz                     = sizeof(ep->sa.s_ipc.sa_path);
-	ep->sa.s_ipc.sa_family = NNG_AF_IPC;
+	sz                    = sizeof(d->sa.s_ipc.sa_path);
+	d->sa.s_ipc.sa_family = NNG_AF_IPC;
 
-	if (nni_strlcpy(ep->sa.s_ipc.sa_path, url->u_path, sz) >= sz) {
-		ipc_ep_fini(ep);
+	if (nni_strlcpy(d->sa.s_ipc.sa_path, url->u_path, sz) >= sz) {
+		ipctran_dialer_fini(d);
 		return (NNG_EADDRINVAL);
 	}
 
-	if ((rv = nni_plat_ipc_ep_init(&ep->iep, &ep->sa, mode)) != 0) {
-		ipc_ep_fini(ep);
+	if (((rv = nni_ipc_dialer_init(&d->dialer)) != 0) ||
+	    ((rv = nni_aio_init(&d->aio, ipctran_dialer_cb, d)) != 0)) {
+		ipctran_dialer_fini(d);
 		return (rv);
 	}
 
-	if ((rv = nni_aio_init(&ep->aio, ipc_ep_cb, ep)) != 0) {
-		ipc_ep_fini(ep);
-		return (rv);
-	}
-	ep->proto = nni_sock_proto_id(sock);
+	d->proto = nni_sock_proto_id(sock);
 
-	*epp = ep;
+	*dp = d;
 	return (0);
 }
 
-static int
-ipc_dialer_init(void **epp, nni_url *url, nni_sock *sock)
+static void
+ipctran_dialer_cb(void *arg)
 {
-	return (ipc_ep_init(epp, url, sock, NNI_EP_MODE_DIAL));
+	ipctran_dialer *d = arg;
+	ipctran_pipe *  p;
+	nni_ipc_conn *  conn;
+	nni_aio *       aio;
+	int             rv;
+
+	nni_mtx_lock(&d->mtx);
+	aio = d->user_aio;
+	rv  = nni_aio_result(d->aio);
+
+	if (aio == NULL) {
+		nni_mtx_unlock(&d->mtx);
+		if (rv == 0) {
+			conn = nni_aio_get_output(d->aio, 0);
+			nni_ipc_conn_fini(conn);
+		}
+		return;
+	}
+
+	if (rv != 0) {
+		d->user_aio = NULL;
+		nni_mtx_unlock(&d->mtx);
+		nni_aio_finish_error(aio, rv);
+		return;
+	}
+
+	d->user_aio = NULL;
+	conn        = nni_aio_get_output(d->aio, 0);
+	NNI_ASSERT(conn != NULL);
+	if ((rv = ipctran_pipe_init(&p, conn)) != 0) {
+		nni_mtx_unlock(&d->mtx);
+		nni_ipc_conn_fini(conn);
+		nni_aio_finish_error(aio, rv);
+		return;
+	}
+
+	p->proto  = d->proto;
+	p->rcvmax = d->rcvmax;
+	p->sa     = d->sa;
+	nni_mtx_unlock(&d->mtx);
+
+	nni_aio_set_output(aio, 0, p);
+	nni_aio_finish(aio, 0, 0);
 }
 
-static int
-ipc_listener_init(void **epp, nni_url *url, nni_sock *sock)
+static void
+ipctran_dialer_cancel(nni_aio *aio, int rv)
 {
-	return (ipc_ep_init(epp, url, sock, NNI_EP_MODE_LISTEN));
+	ipctran_dialer *d = nni_aio_get_prov_data(aio);
+
+	nni_mtx_lock(&d->mtx);
+	if (d->user_aio != aio) {
+		nni_mtx_unlock(&d->mtx);
+		return;
+	}
+	d->user_aio = NULL;
+	nni_mtx_unlock(&d->mtx);
+
+	nni_aio_abort(d->aio, rv);
+	nni_aio_finish_error(aio, rv);
 }
 
 static void
-ipc_ep_close(void *arg)
+ipctran_dialer_connect(void *arg, nni_aio *aio)
 {
-	ipc_ep *ep = arg;
+	ipctran_dialer *d = arg;
+	int             rv;
 
-	nni_aio_close(ep->aio);
+	if (nni_aio_begin(aio) != 0) {
+		return;
+	}
+	nni_mtx_lock(&d->mtx);
+	NNI_ASSERT(d->user_aio == NULL);
+
+	if ((rv = nni_aio_schedule(aio, ipctran_dialer_cancel, d)) != 0) {
+		nni_mtx_unlock(&d->mtx);
+		nni_aio_finish_error(aio, rv);
+		return;
+	}
+	d->user_aio = aio;
 
-	nni_mtx_lock(&ep->mtx);
-	nni_plat_ipc_ep_close(ep->iep);
-	nni_mtx_unlock(&ep->mtx);
+	nni_ipc_dialer_dial(d->dialer, &d->sa, d->aio);
+	nni_mtx_unlock(&d->mtx);
 }
 
 static int
-ipc_ep_bind(void *arg)
+ipctran_dialer_get_recvmaxsz(void *arg, void *v, size_t *szp, nni_opt_type t)
 {
-	ipc_ep *ep = arg;
-	int     rv;
+	ipctran_dialer *d = arg;
+	int             rv;
+	nni_mtx_lock(&d->mtx);
+	rv = nni_copyout_size(d->rcvmax, v, szp, t);
+	nni_mtx_unlock(&d->mtx);
+	return (rv);
+}
 
-	nni_mtx_lock(&ep->mtx);
-	rv = nni_plat_ipc_ep_listen(ep->iep);
-	nni_mtx_unlock(&ep->mtx);
+static int
+ipctran_dialer_set_recvmaxsz(
+    void *arg, const void *v, size_t sz, nni_opt_type t)
+{
+	ipctran_dialer *d = arg;
+	size_t          val;
+	int             rv;
+	if ((rv = nni_copyin_size(&val, v, sz, 0, NNI_MAXSZ, t)) == 0) {
+		nni_mtx_lock(&d->mtx);
+		d->rcvmax = val;
+		nni_mtx_unlock(&d->mtx);
+	}
 	return (rv);
 }
 
 static void
-ipc_ep_finish(ipc_ep *ep)
+ipctran_listener_fini(void *arg)
 {
-	nni_aio * aio;
-	int       rv;
-	ipc_pipe *pipe = NULL;
+	ipctran_listener *l = arg;
 
-	if ((rv = nni_aio_result(ep->aio)) != 0) {
-		goto done;
+	nni_aio_stop(l->aio);
+	if (l->listener != NULL) {
+		nni_ipc_listener_fini(l->listener);
 	}
-	NNI_ASSERT(nni_aio_get_output(ep->aio, 0) != NULL);
-
-	// Attempt to allocate the parent pipe.  If this fails we'll
-	// drop the connection (ENOMEM probably).
-	rv = ipc_pipe_init(&pipe, ep, nni_aio_get_output(ep->aio, 0));
+	nni_aio_fini(l->aio);
+	nni_mtx_fini(&l->mtx);
+	NNI_FREE_STRUCT(l);
+}
 
-done:
-	aio          = ep->user_aio;
-	ep->user_aio = NULL;
+static int
+ipctran_listener_init(void **lp, nni_url *url, nni_sock *sock)
+{
+	ipctran_listener *l;
+	int               rv;
+	size_t            sz;
 
-	if ((aio != NULL) && (rv == 0)) {
-		NNI_ASSERT(pipe != NULL);
-		nni_aio_set_output(aio, 0, pipe);
-		nni_aio_finish(aio, 0, 0);
-		return;
+	if ((l = NNI_ALLOC_STRUCT(l)) == NULL) {
+		return (NNG_ENOMEM);
 	}
+	nni_mtx_init(&l->mtx);
+
+	sz                    = sizeof(l->sa.s_ipc.sa_path);
+	l->sa.s_ipc.sa_family = NNG_AF_IPC;
 
-	if (pipe != NULL) {
-		ipc_pipe_fini(pipe);
+	if (nni_strlcpy(l->sa.s_ipc.sa_path, url->u_path, sz) >= sz) {
+		ipctran_listener_fini(l);
+		return (NNG_EADDRINVAL);
 	}
-	if (aio != NULL) {
-		NNI_ASSERT(rv != 0);
-		nni_aio_finish_error(aio, rv);
+
+	if (((rv = nni_ipc_listener_init(&l->listener)) != 0) ||
+	    ((rv = nni_aio_init(&l->aio, ipctran_listener_cb, l)) != 0)) {
+		ipctran_listener_fini(l);
+		return (rv);
 	}
+
+	l->proto = nni_sock_proto_id(sock);
+
+	*lp = l;
+	return (0);
 }
 
 static void
-ipc_ep_cb(void *arg)
+ipctran_listener_close(void *arg)
 {
-	ipc_ep *ep = arg;
+	ipctran_listener *l = arg;
 
-	nni_mtx_lock(&ep->mtx);
-	ipc_ep_finish(ep);
-	nni_mtx_unlock(&ep->mtx);
+	nni_aio_close(l->aio);
+	nni_ipc_listener_close(l->listener);
 }
 
-static void
-ipc_cancel_ep(nni_aio *aio, int rv)
+static int
+ipctran_listener_bind(void *arg)
 {
-	ipc_ep *ep = nni_aio_get_prov_data(aio);
+	ipctran_listener *l = arg;
+	int               rv;
 
-	NNI_ASSERT(rv != 0);
-	nni_mtx_lock(&ep->mtx);
-	if (ep->user_aio != aio) {
-		nni_mtx_unlock(&ep->mtx);
-		return;
-	}
-	ep->user_aio = NULL;
-	nni_mtx_unlock(&ep->mtx);
-
-	nni_aio_abort(ep->aio, rv);
-	nni_aio_finish_error(aio, rv);
+	nni_mtx_lock(&l->mtx);
+	rv = nni_ipc_listener_listen(l->listener, &l->sa);
+	nni_mtx_unlock(&l->mtx);
+	return (rv);
 }
 
 static void
-ipc_ep_accept(void *arg, nni_aio *aio)
+ipctran_listener_cb(void *arg)
 {
-	ipc_ep *ep = arg;
-	int     rv;
+	ipctran_listener *l = arg;
+	nni_aio *         aio;
+	int               rv;
+	ipctran_pipe *    p = NULL;
+	nni_ipc_conn *    conn;
+
+	nni_mtx_lock(&l->mtx);
+	rv          = nni_aio_result(l->aio);
+	aio         = l->user_aio;
+	l->user_aio = NULL;
+
+	if (aio == NULL) {
+		nni_mtx_unlock(&l->mtx);
+		if (rv == 0) {
+			conn = nni_aio_get_output(l->aio, 0);
+			nni_ipc_conn_fini(conn);
+		}
+		return;
+	}
 
-	if (nni_aio_begin(aio) != 0) {
+	if (rv != 0) {
+		nni_mtx_unlock(&l->mtx);
+		nni_aio_finish_error(aio, rv);
 		return;
 	}
-	nni_mtx_lock(&ep->mtx);
-	NNI_ASSERT(ep->user_aio == NULL);
 
-	if ((rv = nni_aio_schedule(aio, ipc_cancel_ep, ep)) != 0) {
-		nni_mtx_unlock(&ep->mtx);
+	conn = nni_aio_get_output(l->aio, 0);
+	NNI_ASSERT(conn != NULL);
+
+	// Attempt to allocate the parent pipe.  If this fails we'll
+	// drop the connection (ENOMEM probably).
+	if ((rv = ipctran_pipe_init(&p, conn)) != 0) {
+		nni_mtx_unlock(&l->mtx);
+		nni_ipc_conn_fini(conn);
 		nni_aio_finish_error(aio, rv);
 		return;
 	}
-	ep->user_aio = aio;
+	p->proto  = l->proto;
+	p->rcvmax = l->rcvmax;
+	p->sa     = l->sa;
+	nni_mtx_unlock(&l->mtx);
+
+	nni_aio_set_output(aio, 0, p);
+	nni_aio_finish(aio, 0, 0);
+}
+
+static void
+ipctran_listener_cancel(nni_aio *aio, int rv)
+{
+	ipctran_listener *l = nni_aio_get_prov_data(aio);
+
+	NNI_ASSERT(rv != 0);
+	nni_mtx_lock(&l->mtx);
+	if (l->user_aio != aio) {
+		nni_mtx_unlock(&l->mtx);
+		return;
+	}
+	l->user_aio = NULL;
+	nni_mtx_unlock(&l->mtx);
 
-	nni_plat_ipc_ep_accept(ep->iep, ep->aio);
-	nni_mtx_unlock(&ep->mtx);
+	nni_aio_abort(l->aio, rv);
+	nni_aio_finish_error(aio, rv);
 }
 
 static void
-ipc_ep_connect(void *arg, nni_aio *aio)
+ipctran_listener_accept(void *arg, nni_aio *aio)
 {
-	ipc_ep *ep = arg;
-	int     rv;
+	ipctran_listener *l = arg;
+	int               rv;
 
 	if (nni_aio_begin(aio) != 0) {
 		return;
 	}
-	nni_mtx_lock(&ep->mtx);
-	NNI_ASSERT(ep->user_aio == NULL);
+	nni_mtx_lock(&l->mtx);
+	NNI_ASSERT(l->user_aio == NULL);
 
-	if ((rv = nni_aio_schedule(aio, ipc_cancel_ep, ep)) != 0) {
-		nni_mtx_unlock(&ep->mtx);
+	if ((rv = nni_aio_schedule(aio, ipctran_listener_cancel, l)) != 0) {
+		nni_mtx_unlock(&l->mtx);
 		nni_aio_finish_error(aio, rv);
 		return;
 	}
-	ep->user_aio = aio;
+	l->user_aio = aio;
 
-	nni_plat_ipc_ep_connect(ep->iep, ep->aio);
-	nni_mtx_unlock(&ep->mtx);
+	nni_ipc_listener_accept(l->listener, l->aio);
+	nni_mtx_unlock(&l->mtx);
 }
 
 static int
-ipc_ep_set_recvmaxsz(void *arg, const void *data, size_t sz, nni_opt_type t)
+ipctran_listener_set_recvmaxsz(
+    void *arg, const void *data, size_t sz, nni_opt_type t)
 {
-	ipc_ep *ep = arg;
-	size_t  val;
-	int     rv;
+	ipctran_listener *l = arg;
+	size_t            val;
+	int               rv;
 
 	if ((rv = nni_copyin_size(&val, data, sz, 0, NNI_MAXSZ, t)) == 0) {
-		nni_mtx_lock(&ep->mtx);
-		ep->rcvmax = val;
-		nni_mtx_unlock(&ep->mtx);
+		nni_mtx_lock(&l->mtx);
+		l->rcvmax = val;
+		nni_mtx_unlock(&l->mtx);
 	}
 	return (rv);
 }
 
 static int
-ipc_ep_chk_recvmaxsz(const void *data, size_t sz, nni_opt_type t)
+ipctran_listener_get_recvmaxsz(
+    void *arg, void *data, size_t *szp, nni_opt_type t)
 {
-	return (nni_copyin_size(NULL, data, sz, 0, NNI_MAXSZ, t));
+	ipctran_listener *l = arg;
+	int               rv;
+	nni_mtx_lock(&l->mtx);
+	rv = nni_copyout_size(l->rcvmax, data, szp, t);
+	nni_mtx_unlock(&l->mtx);
+	return (rv);
 }
 
 static int
-ipc_ep_get_recvmaxsz(void *arg, void *data, size_t *szp, nni_opt_type t)
+ipctran_listener_get_locaddr(void *arg, void *buf, size_t *szp, nni_opt_type t)
 {
-	ipc_ep *ep = arg;
-	int     rv;
-	nni_mtx_lock(&ep->mtx);
-	rv = nni_copyout_size(ep->rcvmax, data, szp, t);
-	nni_mtx_unlock(&ep->mtx);
+	ipctran_listener *l = arg;
+	int               rv;
+
+	nni_mtx_lock(&l->mtx);
+	rv = nni_copyout_sockaddr(&l->sa, buf, szp, t);
+	nni_mtx_unlock(&l->mtx);
 	return (rv);
 }
 
 static int
-ipc_ep_get_addr(void *arg, void *data, size_t *szp, nni_opt_type t)
+ipctran_check_recvmaxsz(const void *data, size_t sz, nni_opt_type t)
 {
-	ipc_ep *ep = arg;
-	int     rv;
-	nni_mtx_lock(&ep->mtx);
-	rv = nni_copyout_sockaddr(&ep->sa, data, szp, t);
-	nni_mtx_unlock(&ep->mtx);
-	return (rv);
+	return (nni_copyin_size(NULL, data, sz, 0, NNI_MAXSZ, t));
 }
 
 static int
-ipc_ep_set_perms(void *arg, const void *data, size_t sz, nni_opt_type t)
+ipctran_listener_set_perms(
+    void *arg, const void *data, size_t sz, nni_opt_type t)
 {
-	ipc_ep *ep = arg;
-	int     val;
-	int     rv;
+	ipctran_listener *l = arg;
+	int               val;
+	int               rv;
 
 	// Probably we could further limit this -- most systems don't have
 	// meaningful chmod beyond the lower 9 bits.
 	if ((rv = nni_copyin_int(&val, data, sz, 0, 0x7FFFFFFF, t)) == 0) {
-		nni_mtx_lock(&ep->mtx);
-		rv = nni_plat_ipc_ep_set_permissions(ep->iep, val);
-		nni_mtx_unlock(&ep->mtx);
+		nni_mtx_lock(&l->mtx);
+		rv = nni_ipc_listener_set_permissions(l->listener, val);
+		nni_mtx_unlock(&l->mtx);
 	}
 	return (rv);
 }
 
 static int
-ipc_ep_chk_perms(const void *data, size_t sz, nni_opt_type t)
+ipctran_check_perms(const void *data, size_t sz, nni_opt_type t)
 {
 	return (nni_copyin_int(NULL, data, sz, 0, 0x7FFFFFFF, t));
 }
 
 static int
-ipc_ep_set_sec_desc(void *arg, const void *data, size_t sz, nni_opt_type t)
+ipctran_listener_set_sec_desc(
+    void *arg, const void *data, size_t sz, nni_opt_type t)
 {
-	ipc_ep *ep = arg;
-	void *  ptr;
-	int     rv;
+	ipctran_listener *l = arg;
+	void *            ptr;
+	int               rv;
 
 	if ((rv = nni_copyin_ptr(&ptr, data, sz, t)) == 0) {
-		nni_mtx_lock(&ep->mtx);
-		rv = nni_plat_ipc_ep_set_security_descriptor(ep->iep, ptr);
-		nni_mtx_unlock(&ep->mtx);
+		nni_mtx_lock(&l->mtx);
+		rv =
+		    nni_ipc_listener_set_security_descriptor(l->listener, ptr);
+		nni_mtx_unlock(&l->mtx);
 	}
 	return (rv);
 }
 
 static int
-ipc_ep_chk_sec_desc(const void *data, size_t sz, nni_opt_type t)
+ipctran_check_sec_desc(const void *data, size_t sz, nni_opt_type t)
 {
 	return (nni_copyin_ptr(NULL, data, sz, t));
 }
 
-static nni_tran_option ipc_pipe_options[] = {
+static nni_tran_option ipctran_pipe_options[] = {
 	{
 	    .o_name = NNG_OPT_REMADDR,
 	    .o_type = NNI_TYPE_SOCKADDR,
-	    .o_get  = ipc_pipe_get_addr,
+	    .o_get  = ipctran_pipe_get_addr,
 	},
 	{
 	    .o_name = NNG_OPT_LOCADDR,
 	    .o_type = NNI_TYPE_SOCKADDR,
-	    .o_get  = ipc_pipe_get_addr,
+	    .o_get  = ipctran_pipe_get_addr,
 	},
 	{
 	    .o_name = NNG_OPT_IPC_PEER_UID,
 	    .o_type = NNI_TYPE_UINT64,
-	    .o_get  = ipc_pipe_get_peer_uid,
+	    .o_get  = ipctran_pipe_get_peer_uid,
 	},
 	{
 	    .o_name = NNG_OPT_IPC_PEER_GID,
 	    .o_type = NNI_TYPE_UINT64,
-	    .o_get  = ipc_pipe_get_peer_gid,
+	    .o_get  = ipctran_pipe_get_peer_gid,
 	},
 	{
 	    .o_name = NNG_OPT_IPC_PEER_PID,
 	    .o_type = NNI_TYPE_UINT64,
-	    .o_get  = ipc_pipe_get_peer_pid,
+	    .o_get  = ipctran_pipe_get_peer_pid,
 	},
 	{
 	    .o_name = NNG_OPT_IPC_PEER_ZONEID,
 	    .o_type = NNI_TYPE_UINT64,
-	    .o_get  = ipc_pipe_get_peer_zoneid,
+	    .o_get  = ipctran_pipe_get_peer_zoneid,
 	},
 	// terminate list
 	{
@@ -926,29 +1083,24 @@ static nni_tran_option ipc_pipe_options[] = {
 	},
 };
 
-static nni_tran_pipe_ops ipc_pipe_ops = {
-	.p_fini    = ipc_pipe_fini,
-	.p_start   = ipc_pipe_start,
-	.p_stop    = ipc_pipe_stop,
-	.p_send    = ipc_pipe_send,
-	.p_recv    = ipc_pipe_recv,
-	.p_close   = ipc_pipe_close,
-	.p_peer    = ipc_pipe_peer,
-	.p_options = ipc_pipe_options,
+static nni_tran_pipe_ops ipctran_pipe_ops = {
+	.p_fini    = ipctran_pipe_fini,
+	.p_start   = ipctran_pipe_start,
+	.p_stop    = ipctran_pipe_stop,
+	.p_send    = ipctran_pipe_send,
+	.p_recv    = ipctran_pipe_recv,
+	.p_close   = ipctran_pipe_close,
+	.p_peer    = ipctran_pipe_peer,
+	.p_options = ipctran_pipe_options,
 };
 
-static nni_tran_option ipc_dialer_options[] = {
+static nni_tran_option ipctran_dialer_options[] = {
 	{
 	    .o_name = NNG_OPT_RECVMAXSZ,
 	    .o_type = NNI_TYPE_SIZE,
-	    .o_get  = ipc_ep_get_recvmaxsz,
-	    .o_set  = ipc_ep_set_recvmaxsz,
-	    .o_chk  = ipc_ep_chk_recvmaxsz,
-	},
-	{
-	    .o_name = NNG_OPT_LOCADDR,
-	    .o_type = NNI_TYPE_SOCKADDR,
-	    .o_get  = ipc_ep_get_addr,
+	    .o_get  = ipctran_dialer_get_recvmaxsz,
+	    .o_set  = ipctran_dialer_set_recvmaxsz,
+	    .o_chk  = ipctran_check_recvmaxsz,
 	},
 	// terminate list
 	{
@@ -956,32 +1108,32 @@ static nni_tran_option ipc_dialer_options[] = {
 	},
 };
 
-static nni_tran_option ipc_listener_options[] = {
+static nni_tran_option ipctran_listener_options[] = {
 	{
 	    .o_name = NNG_OPT_RECVMAXSZ,
 	    .o_type = NNI_TYPE_SIZE,
-	    .o_get  = ipc_ep_get_recvmaxsz,
-	    .o_set  = ipc_ep_set_recvmaxsz,
-	    .o_chk  = ipc_ep_chk_recvmaxsz,
+	    .o_get  = ipctran_listener_get_recvmaxsz,
+	    .o_set  = ipctran_listener_set_recvmaxsz,
+	    .o_chk  = ipctran_check_recvmaxsz,
 	},
 	{
 	    .o_name = NNG_OPT_LOCADDR,
 	    .o_type = NNI_TYPE_SOCKADDR,
-	    .o_get  = ipc_ep_get_addr,
+	    .o_get  = ipctran_listener_get_locaddr,
 	},
 	{
 	    .o_name = NNG_OPT_IPC_SECURITY_DESCRIPTOR,
 	    .o_type = NNI_TYPE_POINTER,
 	    .o_get  = NULL,
-	    .o_set  = ipc_ep_set_sec_desc,
-	    .o_chk  = ipc_ep_chk_sec_desc,
+	    .o_set  = ipctran_listener_set_sec_desc,
+	    .o_chk  = ipctran_check_sec_desc,
 	},
 	{
 	    .o_name = NNG_OPT_IPC_PERMISSIONS,
 	    .o_type = NNI_TYPE_INT32,
 	    .o_get  = NULL,
-	    .o_set  = ipc_ep_set_perms,
-	    .o_chk  = ipc_ep_chk_perms,
+	    .o_set  = ipctran_listener_set_perms,
+	    .o_chk  = ipctran_check_perms,
 	},
 	// terminate list
 	{
@@ -989,31 +1141,31 @@ static nni_tran_option ipc_listener_options[] = {
 	},
 };
 
-static nni_tran_dialer_ops ipc_dialer_ops = {
-	.d_init    = ipc_dialer_init,
-	.d_fini    = ipc_ep_fini,
-	.d_connect = ipc_ep_connect,
-	.d_close   = ipc_ep_close,
-	.d_options = ipc_dialer_options,
+static nni_tran_dialer_ops ipctran_dialer_ops = {
+	.d_init    = ipctran_dialer_init,
+	.d_fini    = ipctran_dialer_fini,
+	.d_connect = ipctran_dialer_connect,
+	.d_close   = ipctran_dialer_close,
+	.d_options = ipctran_dialer_options,
 };
 
-static nni_tran_listener_ops ipc_listener_ops = {
-	.l_init    = ipc_listener_init,
-	.l_fini    = ipc_ep_fini,
-	.l_bind    = ipc_ep_bind,
-	.l_accept  = ipc_ep_accept,
-	.l_close   = ipc_ep_close,
-	.l_options = ipc_listener_options,
+static nni_tran_listener_ops ipctran_listener_ops = {
+	.l_init    = ipctran_listener_init,
+	.l_fini    = ipctran_listener_fini,
+	.l_bind    = ipctran_listener_bind,
+	.l_accept  = ipctran_listener_accept,
+	.l_close   = ipctran_listener_close,
+	.l_options = ipctran_listener_options,
 };
 
 static nni_tran ipc_tran = {
 	.tran_version  = NNI_TRANSPORT_VERSION,
 	.tran_scheme   = "ipc",
-	.tran_dialer   = &ipc_dialer_ops,
-	.tran_listener = &ipc_listener_ops,
-	.tran_pipe     = &ipc_pipe_ops,
-	.tran_init     = ipc_tran_init,
-	.tran_fini     = ipc_tran_fini,
+	.tran_dialer   = &ipctran_dialer_ops,
+	.tran_listener = &ipctran_listener_ops,
+	.tran_pipe     = &ipctran_pipe_ops,
+	.tran_init     = ipctran_init,
+	.tran_fini     = ipctran_fini,
 };
 
 int