Allocate AIOs dynamically.

We allocate AIO structures dynamically, so that we can use them
abstractly in more places without inlining them.  This will be used
for the ZeroTier transport to allow us to create operations consisting
of just the AIO.  Furthermore, we provide accessors for some of the
aio members, in the hopes that we will be able to wrap these for
"safe" version of the AIO capability to export to applications, and
to protocol and transport implementors.

While here we cleaned up the protocol details to use consistently
shorter names (no nni_ prefix for static symbols needed), and we
also fixed a bug in the surveyor code.

1 files changed, 221 insertions, 224 deletions

diff --git a/src/protocol/survey/respond.c b/src/protocol/survey/respond.c
index e695a987..c3a9dd81 100644
--- a/src/protocol/survey/respond.c
+++ b/src/protocol/survey/respond.c
@@ -17,18 +17,18 @@
 // the surveyor pattern.  This is useful for building service discovery, or
 // voting algorithsm, for example.
 
-typedef struct nni_resp_pipe nni_resp_pipe;
-typedef struct nni_resp_sock nni_resp_sock;
-
-static void nni_resp_recv_cb(void *);
-static void nni_resp_putq_cb(void *);
-static void nni_resp_getq_cb(void *);
-static void nni_resp_send_cb(void *);
-static void nni_resp_sock_getq_cb(void *);
-static void nni_resp_pipe_fini(void *);
-
-// An nni_resp_sock is our per-socket protocol private structure.
-struct nni_resp_sock {
+typedef struct resp_pipe resp_pipe;
+typedef struct resp_sock resp_sock;
+
+static void resp_recv_cb(void *);
+static void resp_putq_cb(void *);
+static void resp_getq_cb(void *);
+static void resp_send_cb(void *);
+static void resp_sock_getq_cb(void *);
+static void resp_pipe_fini(void *);
+
+// A resp_sock is our per-socket protocol private structure.
+struct resp_sock {
 	nni_sock *  nsock;
 	nni_msgq *  urq;
 	nni_msgq *  uwq;
@@ -37,259 +37,257 @@ struct nni_resp_sock {
 	nni_idhash *pipes;
 	char *      btrace;
 	size_t      btrace_len;
-	nni_aio     aio_getq;
+	nni_aio *   aio_getq;
 	nni_mtx     mtx;
 };
 
-// An nni_resp_pipe is our per-pipe protocol private structure.
-struct nni_resp_pipe {
-	nni_pipe *     npipe;
-	nni_resp_sock *psock;
-	uint32_t       id;
-	nni_msgq *     sendq;
-	nni_aio        aio_getq;
-	nni_aio        aio_putq;
-	nni_aio        aio_send;
-	nni_aio        aio_recv;
+// A resp_pipe is our per-pipe protocol private structure.
+struct resp_pipe {
+	nni_pipe * npipe;
+	resp_sock *psock;
+	uint32_t   id;
+	nni_msgq * sendq;
+	nni_aio *  aio_getq;
+	nni_aio *  aio_putq;
+	nni_aio *  aio_send;
+	nni_aio *  aio_recv;
 };
 
 static void
-nni_resp_sock_fini(void *arg)
+resp_sock_fini(void *arg)
 {
-	nni_resp_sock *psock = arg;
+	resp_sock *s = arg;
 
-	nni_aio_stop(&psock->aio_getq);
-	nni_aio_fini(&psock->aio_getq);
-	nni_idhash_fini(psock->pipes);
-	if (psock->btrace != NULL) {
-		nni_free(psock->btrace, psock->btrace_len);
+	nni_aio_stop(s->aio_getq);
+	nni_aio_fini(s->aio_getq);
+	nni_idhash_fini(s->pipes);
+	if (s->btrace != NULL) {
+		nni_free(s->btrace, s->btrace_len);
 	}
-	nni_mtx_fini(&psock->mtx);
-	NNI_FREE_STRUCT(psock);
+	nni_mtx_fini(&s->mtx);
+	NNI_FREE_STRUCT(s);
 }
 
 static int
-nni_resp_sock_init(void **pp, nni_sock *nsock)
+resp_sock_init(void **sp, nni_sock *nsock)
 {
-	nni_resp_sock *psock;
-	int            rv;
+	resp_sock *s;
+	int        rv;
 
-	if ((psock = NNI_ALLOC_STRUCT(psock)) == NULL) {
+	if ((s = NNI_ALLOC_STRUCT(s)) == NULL) {
 		return (NNG_ENOMEM);
 	}
-	if ((rv = nni_idhash_init(&psock->pipes)) != 0) {
-		NNI_FREE_STRUCT(psock);
+	if (((rv = nni_idhash_init(&s->pipes)) != 0) ||
+	    ((rv = nni_aio_init(&s->aio_getq, resp_sock_getq_cb, s)) != 0)) {
+		resp_sock_fini(s);
 		return (rv);
 	}
 
-	psock->ttl        = 8; // Per RFC
-	psock->nsock      = nsock;
-	psock->raw        = 0;
-	psock->btrace     = NULL;
-	psock->btrace_len = 0;
-	psock->urq        = nni_sock_recvq(nsock);
-	psock->uwq        = nni_sock_sendq(nsock);
+	s->ttl        = 8; // Per RFC
+	s->nsock      = nsock;
+	s->raw        = 0;
+	s->btrace     = NULL;
+	s->btrace_len = 0;
+	s->urq        = nni_sock_recvq(nsock);
+	s->uwq        = nni_sock_sendq(nsock);
 
-	nni_mtx_init(&psock->mtx);
-	nni_aio_init(&psock->aio_getq, nni_resp_sock_getq_cb, psock);
+	nni_mtx_init(&s->mtx);
 
-	*pp = psock;
+	*sp = s;
 	nni_sock_senderr(nsock, NNG_ESTATE);
 	return (0);
 }
 
 static void
-nni_resp_sock_open(void *arg)
+resp_sock_open(void *arg)
 {
-	nni_resp_sock *psock = arg;
+	resp_sock *s = arg;
 
-	nni_msgq_aio_get(psock->uwq, &psock->aio_getq);
+	nni_msgq_aio_get(s->uwq, s->aio_getq);
 }
 
 static void
-nni_resp_sock_close(void *arg)
+resp_sock_close(void *arg)
 {
-	nni_resp_sock *psock = arg;
+	resp_sock *s = arg;
 
-	nni_aio_cancel(&psock->aio_getq, NNG_ECLOSED);
+	nni_aio_cancel(s->aio_getq, NNG_ECLOSED);
+}
+
+static void
+resp_pipe_fini(void *arg)
+{
+	resp_pipe *p = arg;
+
+	nni_aio_fini(p->aio_putq);
+	nni_aio_fini(p->aio_getq);
+	nni_aio_fini(p->aio_send);
+	nni_aio_fini(p->aio_recv);
+	nni_msgq_fini(p->sendq);
+	NNI_FREE_STRUCT(p);
 }
 
 static int
-nni_resp_pipe_init(void **pp, nni_pipe *npipe, void *psock)
+resp_pipe_init(void **pp, nni_pipe *npipe, void *s)
 {
-	nni_resp_pipe *ppipe;
-	int            rv;
+	resp_pipe *p;
+	int        rv;
 
-	if ((ppipe = NNI_ALLOC_STRUCT(ppipe)) == NULL) {
+	if ((p = NNI_ALLOC_STRUCT(p)) == NULL) {
 		return (NNG_ENOMEM);
 	}
-	if ((rv = nni_msgq_init(&ppipe->sendq, 2)) != 0) {
-		NNI_FREE_STRUCT(ppipe);
+	if (((rv = nni_msgq_init(&p->sendq, 2)) != 0) ||
+	    ((rv = nni_aio_init(&p->aio_putq, resp_putq_cb, p)) != 0) ||
+	    ((rv = nni_aio_init(&p->aio_recv, resp_recv_cb, p)) != 0) ||
+	    ((rv = nni_aio_init(&p->aio_getq, resp_getq_cb, p)) != 0) ||
+	    ((rv = nni_aio_init(&p->aio_send, resp_send_cb, p)) != 0)) {
+		resp_pipe_fini(p);
 		return (rv);
 	}
-	nni_aio_init(&ppipe->aio_putq, nni_resp_putq_cb, ppipe);
-	nni_aio_init(&ppipe->aio_recv, nni_resp_recv_cb, ppipe);
-	nni_aio_init(&ppipe->aio_getq, nni_resp_getq_cb, ppipe);
-	nni_aio_init(&ppipe->aio_send, nni_resp_send_cb, ppipe);
-
-	ppipe->npipe = npipe;
-	ppipe->psock = psock;
-	*pp          = ppipe;
-	return (0);
-}
 
-static void
-nni_resp_pipe_fini(void *arg)
-{
-	nni_resp_pipe *ppipe = arg;
-
-	nni_aio_fini(&ppipe->aio_putq);
-	nni_aio_fini(&ppipe->aio_getq);
-	nni_aio_fini(&ppipe->aio_send);
-	nni_aio_fini(&ppipe->aio_recv);
-	nni_msgq_fini(ppipe->sendq);
-	NNI_FREE_STRUCT(ppipe);
+	p->npipe = npipe;
+	p->psock = s;
+	*pp      = p;
+	return (0);
 }
 
 static int
-nni_resp_pipe_start(void *arg)
+resp_pipe_start(void *arg)
 {
-	nni_resp_pipe *ppipe = arg;
-	nni_resp_sock *psock = ppipe->psock;
-	int            rv;
+	resp_pipe *p = arg;
+	resp_sock *s = p->psock;
+	int        rv;
 
-	ppipe->id = nni_pipe_id(ppipe->npipe);
+	p->id = nni_pipe_id(p->npipe);
 
-	nni_mtx_lock(&psock->mtx);
-	rv = nni_idhash_insert(psock->pipes, ppipe->id, ppipe);
-	nni_mtx_unlock(&psock->mtx);
+	nni_mtx_lock(&s->mtx);
+	rv = nni_idhash_insert(s->pipes, p->id, p);
+	nni_mtx_unlock(&s->mtx);
 	if (rv != 0) {
 		return (rv);
 	}
 
-	nni_pipe_recv(ppipe->npipe, &ppipe->aio_recv);
-	nni_msgq_aio_get(ppipe->sendq, &ppipe->aio_getq);
+	nni_pipe_recv(p->npipe, p->aio_recv);
+	nni_msgq_aio_get(p->sendq, p->aio_getq);
 
 	return (rv);
 }
 
 static void
-nni_resp_pipe_stop(void *arg)
+resp_pipe_stop(void *arg)
 {
-	nni_resp_pipe *ppipe = arg;
-	nni_resp_sock *psock = ppipe->psock;
-
-	nni_msgq_close(ppipe->sendq);
-	nni_aio_stop(&ppipe->aio_putq);
-	nni_aio_stop(&ppipe->aio_getq);
-	nni_aio_stop(&ppipe->aio_send);
-	nni_aio_stop(&ppipe->aio_recv);
-
-	if (ppipe->id != 0) {
-		nni_mtx_lock(&psock->mtx);
-		nni_idhash_remove(psock->pipes, ppipe->id);
-		nni_mtx_unlock(&psock->mtx);
-		ppipe->id = 0;
+	resp_pipe *p = arg;
+	resp_sock *s = p->psock;
+
+	nni_msgq_close(p->sendq);
+	nni_aio_stop(p->aio_putq);
+	nni_aio_stop(p->aio_getq);
+	nni_aio_stop(p->aio_send);
+	nni_aio_stop(p->aio_recv);
+
+	if (p->id != 0) {
+		nni_mtx_lock(&s->mtx);
+		nni_idhash_remove(s->pipes, p->id);
+		nni_mtx_unlock(&s->mtx);
+		p->id = 0;
 	}
 }
 
-// nni_resp_sock_send watches for messages from the upper write queue,
+// resp_sock_send watches for messages from the upper write queue,
 // extracts the destination pipe, and forwards it to the appropriate
 // destination pipe via a separate queue.  This prevents a single bad
 // or slow pipe from gumming up the works for the entire socket.s
 
 void
-nni_resp_sock_getq_cb(void *arg)
+resp_sock_getq_cb(void *arg)
 {
-	nni_resp_sock *psock = arg;
-	nni_msg *      msg;
-	uint32_t       id;
-	nni_resp_pipe *ppipe;
-	int            rv;
+	resp_sock *s = arg;
+	nni_msg *  msg;
+	uint32_t   id;
+	resp_pipe *p;
+	int        rv;
 
-	if (nni_aio_result(&psock->aio_getq) != 0) {
+	if (nni_aio_result(s->aio_getq) != 0) {
 		return;
 	}
-	msg                   = psock->aio_getq.a_msg;
-	psock->aio_getq.a_msg = NULL;
+	msg = nni_aio_get_msg(s->aio_getq);
+	nni_aio_set_msg(s->aio_getq, NULL);
 
 	// We yank the outgoing pipe id from the header
 	if (nni_msg_header_len(msg) < 4) {
 		nni_msg_free(msg);
-		// We can't really close down the socket, so just
-		// keep going.
-		nni_msgq_aio_get(psock->uwq, &psock->aio_getq);
+		// We can't really close down the socket, so just keep going.
+		nni_msgq_aio_get(s->uwq, s->aio_getq);
 		return;
 	}
 	id = nni_msg_header_trim_u32(msg);
 
-	nni_mtx_lock(&psock->mtx);
-	rv = nni_idhash_find(psock->pipes, id, (void **) &ppipe);
-
-	if (rv != 0) {
+	nni_mtx_lock(&s->mtx);
+	if ((rv = nni_idhash_find(s->pipes, id, (void **) &p)) != 0) {
+		// Destination pipe not present.
 		nni_msg_free(msg);
-		nni_msgq_aio_get(psock->uwq, &psock->aio_getq);
 	} else {
 		// Non-blocking put.
-		if (nni_msgq_tryput(ppipe->sendq, msg) != 0) {
+		if (nni_msgq_tryput(p->sendq, msg) != 0) {
 			nni_msg_free(msg);
 		}
 	}
-	nni_mtx_unlock(&psock->mtx);
+	nni_msgq_aio_get(s->uwq, s->aio_getq);
+	nni_mtx_unlock(&s->mtx);
 }
 
 void
-nni_resp_getq_cb(void *arg)
+resp_getq_cb(void *arg)
 {
-	nni_resp_pipe *ppipe = arg;
+	resp_pipe *p = arg;
 
-	if (nni_aio_result(&ppipe->aio_getq) != 0) {
-		nni_pipe_stop(ppipe->npipe);
+	if (nni_aio_result(p->aio_getq) != 0) {
+		nni_pipe_stop(p->npipe);
 		return;
 	}
 
-	ppipe->aio_send.a_msg = ppipe->aio_getq.a_msg;
-	ppipe->aio_getq.a_msg = NULL;
+	nni_aio_set_msg(p->aio_send, nni_aio_get_msg(p->aio_getq));
+	nni_aio_set_msg(p->aio_getq, NULL);
 
-	nni_pipe_send(ppipe->npipe, &ppipe->aio_send);
+	nni_pipe_send(p->npipe, p->aio_send);
 }
 
 void
-nni_resp_send_cb(void *arg)
+resp_send_cb(void *arg)
 {
-	nni_resp_pipe *ppipe = arg;
+	resp_pipe *p = arg;
 
-	if (nni_aio_result(&ppipe->aio_send) != 0) {
-		nni_msg_free(ppipe->aio_send.a_msg);
-		ppipe->aio_send.a_msg = NULL;
-		nni_pipe_stop(ppipe->npipe);
+	if (nni_aio_result(p->aio_send) != 0) {
+		nni_msg_free(nni_aio_get_msg(p->aio_send));
+		nni_aio_set_msg(p->aio_send, NULL);
+		nni_pipe_stop(p->npipe);
 		return;
 	}
 
-	nni_msgq_aio_get(ppipe->sendq, &ppipe->aio_getq);
+	nni_msgq_aio_get(p->sendq, p->aio_getq);
 }
 
 static void
-nni_resp_recv_cb(void *arg)
+resp_recv_cb(void *arg)
 {
-	nni_resp_pipe *ppipe = arg;
-	nni_resp_sock *psock = ppipe->psock;
-	nni_msgq *     urq;
-	nni_msg *      msg;
-	int            hops;
-	int            rv;
-
-	if (nni_aio_result(&ppipe->aio_recv) != 0) {
+	resp_pipe *p = arg;
+	resp_sock *s = p->psock;
+	nni_msgq * urq;
+	nni_msg *  msg;
+	int        hops;
+	int        rv;
+
+	if (nni_aio_result(p->aio_recv) != 0) {
 		goto error;
 	}
 
-	urq = nni_sock_recvq(psock->nsock);
+	urq = nni_sock_recvq(s->nsock);
 
-	msg                   = ppipe->aio_recv.a_msg;
-	ppipe->aio_recv.a_msg = NULL;
+	msg = nni_aio_get_msg(p->aio_recv);
+	nni_aio_set_msg(p->aio_recv, NULL);
 
 	// Store the pipe id in the header, first thing.
-	if (nni_msg_header_append_u32(msg, ppipe->id) != 0) {
+	if (nni_msg_header_append_u32(msg, p->id) != 0) {
 		nni_msg_free(msg);
 		goto error;
 	}
@@ -300,7 +298,7 @@ nni_resp_recv_cb(void *arg)
 		int      end = 0;
 		uint8_t *body;
 
-		if (hops >= psock->ttl) {
+		if (hops >= s->ttl) {
 			nni_msg_free(msg);
 			goto error;
 		}
@@ -322,46 +320,46 @@ nni_resp_recv_cb(void *arg)
 	}
 
 	// Now send it up.
-	ppipe->aio_putq.a_msg = msg;
-	nni_msgq_aio_put(urq, &ppipe->aio_putq);
+	nni_aio_set_msg(p->aio_putq, msg);
+	nni_msgq_aio_put(urq, p->aio_putq);
 	return;
 
 error:
-	nni_pipe_stop(ppipe->npipe);
+	nni_pipe_stop(p->npipe);
 }
 
 static void
-nni_resp_putq_cb(void *arg)
+resp_putq_cb(void *arg)
 {
-	nni_resp_pipe *ppipe = arg;
+	resp_pipe *p = arg;
 
-	if (nni_aio_result(&ppipe->aio_putq) != 0) {
-		nni_msg_free(ppipe->aio_putq.a_msg);
-		ppipe->aio_putq.a_msg = NULL;
-		nni_pipe_stop(ppipe->npipe);
+	if (nni_aio_result(p->aio_putq) != 0) {
+		nni_msg_free(nni_aio_get_msg(p->aio_putq));
+		nni_aio_set_msg(p->aio_putq, NULL);
+		nni_pipe_stop(p->npipe);
 	}
 
-	nni_pipe_recv(ppipe->npipe, &ppipe->aio_recv);
+	nni_pipe_recv(p->npipe, p->aio_recv);
 }
 
 static int
-nni_resp_sock_setopt(void *arg, int opt, const void *buf, size_t sz)
+resp_sock_setopt(void *arg, int opt, const void *buf, size_t sz)
 {
-	nni_resp_sock *psock = arg;
-	int            rv    = NNG_ENOTSUP;
-	int            oldraw;
+	resp_sock *s  = arg;
+	int        rv = NNG_ENOTSUP;
+	int        oldraw;
 
 	if (opt == nng_optid_maxttl) {
-		rv = nni_setopt_int(&psock->ttl, buf, sz, 1, 255);
+		rv = nni_setopt_int(&s->ttl, buf, sz, 1, 255);
 
 	} else if (opt == nng_optid_raw) {
-		oldraw = psock->raw;
-		rv     = nni_setopt_int(&psock->raw, buf, sz, 0, 1);
-		if (oldraw != psock->raw) {
-			if (!psock->raw) {
-				nni_sock_senderr(psock->nsock, 0);
+		oldraw = s->raw;
+		rv     = nni_setopt_int(&s->raw, buf, sz, 0, 1);
+		if (oldraw != s->raw) {
+			if (!s->raw) {
+				nni_sock_senderr(s->nsock, 0);
 			} else {
-				nni_sock_senderr(psock->nsock, NNG_ESTATE);
+				nni_sock_senderr(s->nsock, NNG_ESTATE);
 			}
 		}
 	}
@@ -370,34 +368,34 @@ nni_resp_sock_setopt(void *arg, int opt, const void *buf, size_t sz)
 }
 
 static int
-nni_resp_sock_getopt(void *arg, int opt, void *buf, size_t *szp)
+resp_sock_getopt(void *arg, int opt, void *buf, size_t *szp)
 {
-	nni_resp_sock *psock = arg;
-	int            rv    = NNG_ENOTSUP;
+	resp_sock *s  = arg;
+	int        rv = NNG_ENOTSUP;
 
 	if (opt == nng_optid_maxttl) {
-		rv = nni_getopt_int(&psock->ttl, buf, szp);
+		rv = nni_getopt_int(&s->ttl, buf, szp);
 	} else if (opt == nng_optid_raw) {
-		rv = nni_getopt_int(&psock->raw, buf, szp);
+		rv = nni_getopt_int(&s->raw, buf, szp);
 	}
 	return (rv);
 }
 
 static nni_msg *
-nni_resp_sock_sfilter(void *arg, nni_msg *msg)
+resp_sock_sfilter(void *arg, nni_msg *msg)
 {
-	nni_resp_sock *psock = arg;
+	resp_sock *s = arg;
 
-	if (psock->raw) {
+	if (s->raw) {
 		return (msg);
 	}
 
 	// Cannot send again until a receive is done...
-	nni_sock_senderr(psock->nsock, NNG_ESTATE);
+	nni_sock_senderr(s->nsock, NNG_ESTATE);
 
 	// If we have a stored backtrace, append it to the header...
 	// if we don't have a backtrace, discard the message.
-	if (psock->btrace == NULL) {
+	if (s->btrace == NULL) {
 		nni_msg_free(msg);
 		return (NULL);
 	}
@@ -405,79 +403,78 @@ nni_resp_sock_sfilter(void *arg, nni_msg *msg)
 	// drop anything else in the header...
 	nni_msg_header_clear(msg);
 
-	if (nni_msg_header_append(msg, psock->btrace, psock->btrace_len) !=
-	    0) {
-		nni_free(psock->btrace, psock->btrace_len);
-		psock->btrace     = NULL;
-		psock->btrace_len = 0;
+	if (nni_msg_header_append(msg, s->btrace, s->btrace_len) != 0) {
+		nni_free(s->btrace, s->btrace_len);
+		s->btrace     = NULL;
+		s->btrace_len = 0;
 		nni_msg_free(msg);
 		return (NULL);
 	}
 
-	nni_free(psock->btrace, psock->btrace_len);
-	psock->btrace     = NULL;
-	psock->btrace_len = 0;
+	nni_free(s->btrace, s->btrace_len);
+	s->btrace     = NULL;
+	s->btrace_len = 0;
 	return (msg);
 }
 
 static nni_msg *
-nni_resp_sock_rfilter(void *arg, nni_msg *msg)
+resp_sock_rfilter(void *arg, nni_msg *msg)
 {
-	nni_resp_sock *psock = arg;
-	char *         header;
-	size_t         len;
+	resp_sock *s = arg;
+	char *     header;
+	size_t     len;
 
-	if (psock->raw) {
+	if (s->raw) {
 		return (msg);
 	}
 
-	nni_sock_senderr(psock->nsock, 0);
+	nni_sock_senderr(s->nsock, 0);
 	len    = nni_msg_header_len(msg);
 	header = nni_msg_header(msg);
-	if (psock->btrace != NULL) {
-		nni_free(psock->btrace, psock->btrace_len);
-		psock->btrace     = NULL;
-		psock->btrace_len = 0;
+	if (s->btrace != NULL) {
+		nni_free(s->btrace, s->btrace_len);
+		s->btrace     = NULL;
+		s->btrace_len = 0;
 	}
-	if ((psock->btrace = nni_alloc(len)) == NULL) {
+	if ((s->btrace = nni_alloc(len)) == NULL) {
 		nni_msg_free(msg);
 		return (NULL);
 	}
-	psock->btrace_len = len;
-	memcpy(psock->btrace, header, len);
+	s->btrace_len = len;
+	memcpy(s->btrace, header, len);
 	nni_msg_header_clear(msg);
 	return (msg);
 }
 
-static nni_proto_pipe_ops nni_resp_pipe_ops = {
-	.pipe_init  = nni_resp_pipe_init,
-	.pipe_fini  = nni_resp_pipe_fini,
-	.pipe_start = nni_resp_pipe_start,
-	.pipe_stop  = nni_resp_pipe_stop,
+static nni_proto_pipe_ops resp_pipe_ops = {
+	.pipe_init  = resp_pipe_init,
+	.pipe_fini  = resp_pipe_fini,
+	.pipe_start = resp_pipe_start,
+	.pipe_stop  = resp_pipe_stop,
 };
 
-static nni_proto_sock_ops nni_resp_sock_ops = {
-	.sock_init    = nni_resp_sock_init,
-	.sock_fini    = nni_resp_sock_fini,
-	.sock_open    = nni_resp_sock_open,
-	.sock_close   = nni_resp_sock_close,
-	.sock_setopt  = nni_resp_sock_setopt,
-	.sock_getopt  = nni_resp_sock_getopt,
-	.sock_rfilter = nni_resp_sock_rfilter,
-	.sock_sfilter = nni_resp_sock_sfilter,
+static nni_proto_sock_ops resp_sock_ops = {
+	.sock_init    = resp_sock_init,
+	.sock_fini    = resp_sock_fini,
+	.sock_open    = resp_sock_open,
+	.sock_close   = resp_sock_close,
+	.sock_setopt  = resp_sock_setopt,
+	.sock_getopt  = resp_sock_getopt,
+	.sock_rfilter = resp_sock_rfilter,
+	.sock_sfilter = resp_sock_sfilter,
 };
 
-nni_proto nni_respondent_proto = {
+static nni_proto resp_proto = {
 	.proto_version  = NNI_PROTOCOL_VERSION,
 	.proto_self     = { NNG_PROTO_RESPONDENT_V0, "respondent" },
 	.proto_peer     = { NNG_PROTO_SURVEYOR_V0, "surveyor" },
 	.proto_flags    = NNI_PROTO_FLAG_SNDRCV,
-	.proto_sock_ops = &nni_resp_sock_ops,
-	.proto_pipe_ops = &nni_resp_pipe_ops,
+	.proto_sock_ops = &resp_sock_ops,
+	.proto_pipe_ops = &resp_pipe_ops,
 };
 
 int
 nng_respondent0_open(nng_socket *sidp)
 {
-	return (nni_proto_open(sidp, &nni_respondent_proto));
+	return (nni_proto_open(sidp, &resp_proto));
 }