diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index aaeb9a4..3e148b4 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -38,7 +38,6 @@
 
     core/ep.h
     core/ep.c
-    core/epbase.c
     core/global.h
     core/global.c
     core/pipe.c
diff --git a/src/core/ep.c b/src/core/ep.c
index 94b5f5e..a39f01a 100644
--- a/src/core/ep.c
+++ b/src/core/ep.c
@@ -1,6 +1,7 @@
 /*
     Copyright (c) 2012 Martin Sustrik  All rights reserved.
     Copyright (c) 2013 GoPivotal, Inc.  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -54,7 +55,6 @@
         src, self, &sock->fsm);
     self->state = NN_EP_STATE_IDLE;
 
-    self->epbase = NULL;
     self->sock = sock;
     self->eid = eid;
     self->last_errno = 0;
@@ -67,9 +67,9 @@
 
     /*  Create transport-specific part of the endpoint. */
     if (bind)
-        rc = transport->bind ((void*) self, &self->epbase);
+        rc = transport->bind (self);
     else
-        rc = transport->connect ((void*) self, &self->epbase);
+        rc = transport->connect (self);
 
     /*  Endpoint creation failed. */
     if (rc < 0) {
@@ -85,7 +85,7 @@
 {
     nn_assert_state (self, NN_EP_STATE_IDLE);
 
-    self->epbase->vfptr->destroy (self->epbase);
+    self->vfptr->destroy (self);
     nn_list_item_term (&self->item);
     nn_fsm_term (&self->fsm);
 }
@@ -143,7 +143,7 @@
     ep = nn_cont (self, struct nn_ep, fsm);
 
     if (nn_slow (src == NN_FSM_ACTION && type == NN_FSM_STOP)) {
-        ep->epbase->vfptr->stop (ep->epbase);
+        ep->vfptr->stop (ep);
         ep->state = NN_EP_STATE_STOPPING;
         return;
     }
@@ -228,3 +228,24 @@
 {
     nn_sock_stat_increment (self->sock, name, increment);
 }
+
+/*  Get transport private state object. */
+void *nn_ep_tran_private (struct nn_ep *self)
+{
+    return self->tran_private;
+}
+
+int nn_ep_ispeer_ep (struct nn_ep *self, struct nn_ep *other)
+{
+    return nn_ep_ispeer (self, other->sock->socktype->protocol);
+}
+
+/*  Set up an ep for use by a transport.  Note that the core will already have
+    done most of the initialization steps.  The associated data can be retrieved
+    later with nn_ep_tran_private(). */
+void nn_ep_tran_setup (struct nn_ep *ep, const struct nn_ep_vfptr *vfptr,
+    void *data)
+{
+    ep->vfptr = vfptr;
+    ep->tran_private = data;
+}
diff --git a/src/core/ep.h b/src/core/ep.h
index d32c23b..1e44930 100644
--- a/src/core/ep.h
+++ b/src/core/ep.h
@@ -35,15 +35,21 @@
 struct nn_ep {
     struct nn_fsm fsm;
     int state;
-    struct nn_epbase *epbase;
     struct nn_sock *sock;
     struct nn_ep_options options;
     int eid;
     struct nn_list_item item;
     char addr [NN_SOCKADDR_MAX + 1];
+    int protocol;
 
     /*  Error state for endpoint */
     int last_errno;
+
+    /*  Transport private state structure */
+    void *tran_private;
+
+    /*  Transport specific operations */
+    const struct nn_ep_vfptr *vfptr;
 };
 
 int nn_ep_init (struct nn_ep *self, int src, struct nn_sock *sock, int eid,
diff --git a/src/core/epbase.c b/src/core/epbase.c
deleted file mode 100644
index 28e0905..0000000
--- a/src/core/epbase.c
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
-    Copyright (c) 2013 Martin Sustrik  All rights reserved.
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"),
-    to deal in the Software without restriction, including without limitation
-    the rights to use, copy, modify, merge, publish, distribute, sublicense,
-    and/or sell copies of the Software, and to permit persons to whom
-    the Software is furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included
-    in all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-    IN THE SOFTWARE.
-*/
-
-#include "../transport.h"
-
-#include "ep.h"
-#include "sock.h"
-#include "../utils/attr.h"
-
-void nn_epbase_init (struct nn_epbase *self,
-    const struct nn_epbase_vfptr *vfptr, void *hint)
-{
-    self->vfptr = vfptr;
-    self->ep = (struct nn_ep*) hint;
-}
-
-void nn_epbase_term (NN_UNUSED struct nn_epbase *self)
-{
-}
-
-void nn_epbase_stopped (struct nn_epbase *self)
-{
-    nn_ep_stopped (self->ep);
-}
-
-struct nn_ctx *nn_epbase_getctx (struct nn_epbase *self)
-{
-    return nn_ep_getctx (self->ep);
-}
-
-const char *nn_epbase_getaddr (struct nn_epbase *self)
-{
-    return nn_ep_getaddr (self->ep);
-}
-
-void nn_epbase_getopt (struct nn_epbase *self, int level, int option,
-    void *optval, size_t *optvallen)
-{
-    nn_ep_getopt (self->ep, level, option, optval, optvallen);
-}
-
-int nn_epbase_ispeer (struct nn_epbase *self, int socktype)
-{
-    return nn_ep_ispeer (self->ep, socktype);
-}
-
-void nn_epbase_set_error (struct nn_epbase *self, int errnum)
-{
-    nn_ep_set_error (self->ep, errnum);
-}
-
-void nn_epbase_clear_error (struct nn_epbase *self)
-{
-    nn_ep_clear_error (self->ep);
-}
-
-void nn_epbase_stat_increment(struct nn_epbase *self, int name, int increment) {
-    nn_ep_stat_increment(self->ep, name, increment);
-}
diff --git a/src/core/pipe.c b/src/core/pipe.c
index 5308c3a..e495b80 100644
--- a/src/core/pipe.c
+++ b/src/core/pipe.c
@@ -48,18 +48,17 @@
 #define NN_PIPEBASE_OUTSTATE_ASYNC 4
 
 void nn_pipebase_init (struct nn_pipebase *self,
-    const struct nn_pipebase_vfptr *vfptr, struct nn_epbase *epbase)
+    const struct nn_pipebase_vfptr *vfptr, struct nn_ep *ep)
 {
-    nn_assert (epbase->ep->sock);
+    nn_assert (ep->sock);
 
-    nn_fsm_init (&self->fsm, NULL, NULL, 0, self, &epbase->ep->sock->fsm);
+    nn_fsm_init (&self->fsm, NULL, NULL, 0, self, &ep->sock->fsm);
     self->vfptr = vfptr;
     self->state = NN_PIPEBASE_STATE_IDLE;
     self->instate = NN_PIPEBASE_INSTATE_DEACTIVATED;
     self->outstate = NN_PIPEBASE_OUTSTATE_DEACTIVATED;
-    self->sock = epbase->ep->sock;
-    memcpy (&self->options, &epbase->ep->options,
-        sizeof (struct nn_ep_options));
+    self->sock = ep->sock;
+    memcpy (&self->options, &ep->options, sizeof (struct nn_ep_options));
     nn_fsm_event_init (&self->in);
     nn_fsm_event_init (&self->out);
 }
@@ -223,4 +222,3 @@
     pipebase = (struct nn_pipebase*) self;
     nn_pipebase_getopt (pipebase, level, option, optval, optvallen);
 }
-
diff --git a/src/transport.h b/src/transport.h
index d56a77a..86fb817 100644
--- a/src/transport.h
+++ b/src/transport.h
@@ -1,6 +1,7 @@
 /*
     Copyright (c) 2012-2014 Martin Sustrik  All rights reserved.
     Copyright (c) 2013 GoPivotal, Inc.  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -64,57 +65,54 @@
     by each nn_bind() or nn_connect() call. Each endpoint is associated with
     exactly one address string (e.g. "tcp://127.0.0.1:5555"). */
 
-struct nn_epbase;
+struct nn_ep;
 
-struct nn_epbase_vfptr {
+struct nn_ep_vfptr {
 
     /*  Ask the endpoint to stop itself. The endpoint is allowed to linger
         to send the pending outbound data. When done, it reports the fact by
-        invoking nn_epbase_stopped() function. */
-    void (*stop) (struct nn_epbase *self);
+        invoking nn_ep_stopped() function. */
+    void (*stop) (struct nn_ep *);
 
     /*  Deallocate the endpoint object. */
-    void (*destroy) (struct nn_epbase *self);
+    void (*destroy) (struct nn_ep *);
 };
 
-struct nn_epbase {
-    const struct nn_epbase_vfptr *vfptr;
-    struct nn_ep *ep;
-};
+/*  Gets the opaque value stored by a transport at setup time. */
+void *nn_ep_tran_private (struct nn_ep *);
 
-/*  Creates a new endpoint. 'hint' parameter is an opaque value that
-    was passed to transport's bind or connect function. */
-void nn_epbase_init (struct nn_epbase *self,
-    const struct nn_epbase_vfptr *vfptr, void *hint);
+/*  Set up an ep for use by a transport.  The final opaque argument can be
+    accessed later by calling nn_ep_tran_private(). */
+void nn_ep_tran_setup (struct nn_ep *, const struct nn_ep_vfptr *, void *);
 
 /*  Notify the user that stopping is done. */
-void nn_epbase_stopped (struct nn_epbase *self);
-
-/*  Terminate the epbase object. */
-void nn_epbase_term (struct nn_epbase *self);
+void nn_ep_stopped (struct nn_ep *);
 
 /*  Returns the AIO context associated with the endpoint. */
-struct nn_ctx *nn_epbase_getctx (struct nn_epbase *self);
+struct nn_ctx *nn_ep_getctx (struct nn_ep *);
 
 /*  Returns the address string associated with this endpoint. */
-const char *nn_epbase_getaddr (struct nn_epbase *self);
+const char *nn_ep_getaddr (struct nn_ep *self);
 
 /*  Retrieve value of a socket option. */
-void nn_epbase_getopt (struct nn_epbase *self, int level, int option,
+void nn_ep_getopt (struct nn_ep *, int level, int option,
     void *optval, size_t *optvallen);
 
-/*  Returns 1 is the specified socket type is a valid peer for this socket,
+/*  Returns 1 if the specified socket type is a valid peer for this socket,
     or 0 otherwise. */
-int nn_epbase_ispeer (struct nn_epbase *self, int socktype);
+int nn_ep_ispeer (struct nn_ep *, int socktype);
+
+/*  Returns 1 if the ep's are valid peers for each other, 0 otherwise. */
+int nn_ep_ispeer_ep (struct nn_ep *, struct nn_ep *);
 
 /*  Notifies a monitoring system the error on this endpoint  */
-void nn_epbase_set_error(struct nn_epbase *self, int errnum);
+void nn_ep_set_error(struct nn_ep*, int errnum);
 
 /*  Notifies a monitoring system that error is gone  */
-void nn_epbase_clear_error(struct nn_epbase *self);
+void nn_ep_clear_error(struct nn_ep *);
 
 /*  Increments statistics counters in the socket structure  */
-void nn_epbase_stat_increment(struct nn_epbase *self, int name, int increment);
+void nn_ep_stat_increment(struct nn_ep *, int name, int increment);
 
 
 /******************************************************************************/
@@ -176,7 +174,7 @@
 
 /*  Initialise the pipe.  */
 void nn_pipebase_init (struct nn_pipebase *self,
-    const struct nn_pipebase_vfptr *vfptr, struct nn_epbase *epbase);
+    const struct nn_pipebase_vfptr *vfptr, struct nn_ep *ep);
 
 /*  Terminate the pipe. */
 void nn_pipebase_term (struct nn_pipebase *self);
@@ -222,14 +220,13 @@
     void (*init) (void);
     void (*term) (void);
 
-    /*  Each of these functions creates an endpoint and returns the newly
-        created endpoint in 'epbase' parameter. 'hint' is in opaque pointer
-        to be passed to nn_epbase_init(). The epbase object can then be used
-        to retrieve the address to bind/connect to. These functions are guarded
-        by a socket-wide critical section. Two of these function will never be
-        invoked in parallel on the same socket. */
-    int (*bind) (void *hint, struct nn_epbase **epbase);
-    int (*connect) (void *hint, struct nn_epbase **epbase);
+    /*  Each of these functions creates an endpoint and sets up the newly
+        established endpoint in 'ep' parameter using nn_ep_tran_setup ().
+        These functions are guarded by a socket-wide critical section.
+        Two of these function will never be invoked in parallel on the same
+        socket. */
+    int (*bind) (struct nn_ep *);
+    int (*connect) (struct nn_ep *);
 
     /*  Create an object to hold transport-specific socket options.
         Set this member to NULL in case there are no transport-specific
diff --git a/src/transports/inproc/binproc.c b/src/transports/inproc/binproc.c
index af96045..d7fc7d6 100644
--- a/src/transports/inproc/binproc.c
+++ b/src/transports/inproc/binproc.c
@@ -1,6 +1,7 @@
 /*
     Copyright (c) 2012-2013 Martin Sustrik  All rights reserved.
     Copyright (c) 2013 GoPivotal, Inc.  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -37,10 +38,10 @@
 
 #define NN_BINPROC_SRC_SINPROC 1
 
-/*  Implementation of nn_epbase interface. */
-static void nn_binproc_stop (struct nn_epbase *self);
-static void nn_binproc_destroy (struct nn_epbase *self);
-static const struct nn_epbase_vfptr nn_binproc_vfptr = {
+/*  Implementation of nn_ep interface. */
+static void nn_binproc_stop (struct nn_ep *);
+static void nn_binproc_destroy (struct nn_ep *);
+static const struct nn_ep_vfptr nn_binproc_vfptr = {
     nn_binproc_stop,
     nn_binproc_destroy
 };
@@ -54,7 +55,7 @@
     struct nn_ins_item *peer);
 
 
-int nn_binproc_create (void *hint, struct nn_epbase **epbase)
+int nn_binproc_create (struct nn_ep *ep)
 {
     int rc;
     struct nn_binproc *self;
@@ -62,9 +63,9 @@
     self = nn_alloc (sizeof (struct nn_binproc), "binproc");
     alloc_assert (self);
 
-    nn_ins_item_init (&self->item, &nn_binproc_vfptr, hint);
+    nn_ins_item_init (&self->item, ep);
     nn_fsm_init_root (&self->fsm, nn_binproc_handler, nn_binproc_shutdown,
-        nn_epbase_getctx (&self->item.epbase));
+        nn_ep_getctx (ep));
     self->state = NN_BINPROC_STATE_IDLE;
     nn_list_init (&self->sinprocs);
 
@@ -73,7 +74,7 @@
 
     /*  Register the inproc endpoint into a global repository. */
     rc = nn_ins_bind (&self->item, nn_binproc_connect);
-    if (nn_slow (rc < 0)) {
+    if (rc < 0) {
         nn_list_term (&self->sinprocs);
 
         /*  TODO: Now, this is ugly! We are getting the state machine into
@@ -86,24 +87,24 @@
         return rc;
     }
 
-    *epbase = &self->item.epbase;
+    nn_ep_tran_setup (ep, &nn_binproc_vfptr, self);
     return 0;
 }
 
-static void nn_binproc_stop (struct nn_epbase *self)
+static void nn_binproc_stop (struct nn_ep *ep)
 {
     struct nn_binproc *binproc;
 
-    binproc = nn_cont (self, struct nn_binproc, item.epbase);
+    binproc = nn_ep_tran_private (ep);
 
     nn_fsm_stop (&binproc->fsm);
 }
 
-static void nn_binproc_destroy (struct nn_epbase *self)
+static void nn_binproc_destroy (struct nn_ep *ep)
 {
     struct nn_binproc *binproc;
 
-    binproc = nn_cont (self, struct nn_binproc, item.epbase);
+    binproc = nn_ep_tran_private (ep);
 
     nn_list_term (&binproc->sinprocs);
     nn_fsm_term (&binproc->fsm);
@@ -127,13 +128,12 @@
     sinproc = nn_alloc (sizeof (struct nn_sinproc), "sinproc");
     alloc_assert (sinproc);
     nn_sinproc_init (sinproc, NN_BINPROC_SRC_SINPROC,
-        &binproc->item.epbase, &binproc->fsm);
+        binproc->item.ep, &binproc->fsm);
     nn_list_insert (&binproc->sinprocs, &sinproc->item,
         nn_list_end (&binproc->sinprocs));
     nn_sinproc_connect (sinproc, &cinproc->fsm);
 
-    nn_epbase_stat_increment (&binproc->item.epbase,
-        NN_STAT_ACCEPTED_CONNECTIONS, 1);
+    nn_ep_stat_increment (binproc->item.ep, NN_STAT_ACCEPTED_CONNECTIONS, 1);
 }
 
 static void nn_binproc_shutdown (struct nn_fsm *self, int src, int type,
@@ -162,7 +162,7 @@
         binproc->state = NN_BINPROC_STATE_STOPPING;
         goto finish;
     }
-    if (nn_slow (binproc->state == NN_BINPROC_STATE_STOPPING)) {
+    if (binproc->state == NN_BINPROC_STATE_STOPPING) {
         nn_assert (src == NN_BINPROC_SRC_SINPROC && type == NN_SINPROC_STOPPED);
         sinproc = (struct nn_sinproc*) srcptr;
         nn_list_erase (&binproc->sinprocs, &sinproc->item);
@@ -173,7 +173,7 @@
             return;
         binproc->state = NN_BINPROC_STATE_IDLE;
         nn_fsm_stopped_noevent (&binproc->fsm);
-        nn_epbase_stopped (&binproc->item.epbase);
+        nn_ep_stopped (binproc->item.ep);
         return;
     }
 
@@ -223,7 +223,7 @@
                 sinproc = nn_alloc (sizeof (struct nn_sinproc), "sinproc");
                 alloc_assert (sinproc);
                 nn_sinproc_init (sinproc, NN_BINPROC_SRC_SINPROC,
-                    &binproc->item.epbase, &binproc->fsm);
+                    binproc->item.ep, &binproc->fsm);
                 nn_list_insert (&binproc->sinprocs, &sinproc->item,
                     nn_list_end (&binproc->sinprocs));
                 nn_sinproc_accept (sinproc, peer);
@@ -246,4 +246,3 @@
         nn_fsm_bad_state (binproc->state, src, type);
     }
 }
-
diff --git a/src/transports/inproc/binproc.h b/src/transports/inproc/binproc.h
index 4516bfa..0320673 100644
--- a/src/transports/inproc/binproc.h
+++ b/src/transports/inproc/binproc.h
@@ -1,5 +1,6 @@
 /*
     Copyright (c) 2012-2013 Martin Sustrik  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -46,6 +47,6 @@
     struct nn_list sinprocs;
 };
 
-int nn_binproc_create (void *hint, struct nn_epbase **epbase);
+int nn_binproc_create (struct nn_ep *);
 
 #endif
diff --git a/src/transports/inproc/cinproc.c b/src/transports/inproc/cinproc.c
index 00c1bb7..06d9466 100644
--- a/src/transports/inproc/cinproc.c
+++ b/src/transports/inproc/cinproc.c
@@ -1,6 +1,7 @@
  /*
     Copyright (c) 2012-2013 Martin Sustrik  All rights reserved.
     Copyright (c) 2013 GoPivotal, Inc.  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -40,10 +41,10 @@
 
 #define NN_CINPROC_SRC_SINPROC 1
 
-/*  Implementation of nn_epbase callback interface. */
-static void nn_cinproc_stop (struct nn_epbase *self);
-static void nn_cinproc_destroy (struct nn_epbase *self);
-static const struct nn_epbase_vfptr nn_cinproc_vfptr = {
+/*  Implementation of nn_ep callback interface. */
+static void nn_cinproc_stop (struct nn_ep *);
+static void nn_cinproc_destroy (struct nn_ep *);
+static const struct nn_ep_vfptr nn_cinproc_vfptr = {
     nn_cinproc_stop,
     nn_cinproc_destroy
 };
@@ -56,21 +57,22 @@
 static void nn_cinproc_connect (struct nn_ins_item *self,
     struct nn_ins_item *peer);
 
-int nn_cinproc_create (void *hint, struct nn_epbase **epbase)
+int nn_cinproc_create (struct nn_ep *ep)
 {
     struct nn_cinproc *self;
 
     self = nn_alloc (sizeof (struct nn_cinproc), "cinproc");
     alloc_assert (self);
 
-    nn_ins_item_init (&self->item, &nn_cinproc_vfptr, hint);
+    nn_ep_tran_setup (ep, &nn_cinproc_vfptr, self);
+
+    nn_ins_item_init (&self->item, ep);
     nn_fsm_init_root (&self->fsm, nn_cinproc_handler, nn_cinproc_shutdown,
-        nn_epbase_getctx (&self->item.epbase));
+        nn_ep_getctx (ep));
     self->state = NN_CINPROC_STATE_IDLE;
     nn_list_init (&self->sinprocs);
 
-    nn_epbase_stat_increment (&self->item.epbase,
-        NN_STAT_INPROGRESS_CONNECTIONS, 1);
+    nn_ep_stat_increment (ep, NN_STAT_INPROGRESS_CONNECTIONS, 1);
 
     /*  Start the state machine. */
     nn_fsm_start (&self->fsm);
@@ -78,24 +80,23 @@
     /*  Register the inproc endpoint into a global repository. */
     nn_ins_connect (&self->item, nn_cinproc_connect);
 
-    *epbase = &self->item.epbase;
     return 0;
 }
 
-static void nn_cinproc_stop (struct nn_epbase *self)
+static void nn_cinproc_stop (struct nn_ep *ep)
 {
     struct nn_cinproc *cinproc;
 
-    cinproc = nn_cont (self, struct nn_cinproc, item.epbase);
+    cinproc = nn_ep_tran_private (ep);
 
     nn_fsm_stop (&cinproc->fsm);
 }
 
-static void nn_cinproc_destroy (struct nn_epbase *self)
+static void nn_cinproc_destroy (struct nn_ep *ep)
 {
     struct nn_cinproc *cinproc;
 
-    cinproc = nn_cont (self, struct nn_cinproc, item.epbase);
+    cinproc = nn_ep_tran_private (ep);
 
     nn_list_term (&cinproc->sinprocs);
     nn_fsm_term (&cinproc->fsm);
@@ -119,17 +120,15 @@
     sinproc = nn_alloc (sizeof (struct nn_sinproc), "sinproc");
     alloc_assert (sinproc);
     nn_sinproc_init (sinproc, NN_CINPROC_SRC_SINPROC,
-        &cinproc->item.epbase, &cinproc->fsm);
+        cinproc->item.ep, &cinproc->fsm);
 
     nn_list_insert (&cinproc->sinprocs, &sinproc->item,
         nn_list_end (&cinproc->sinprocs));
 
     nn_sinproc_connect (sinproc, &binproc->fsm);
 
-    nn_epbase_stat_increment (&cinproc->item.epbase,
-        NN_STAT_INPROGRESS_CONNECTIONS, -1);
-    nn_epbase_stat_increment (&cinproc->item.epbase,
-        NN_STAT_ESTABLISHED_CONNECTIONS, 1);
+    nn_ep_stat_increment (cinproc->item.ep, NN_STAT_INPROGRESS_CONNECTIONS, -1);
+    nn_ep_stat_increment (cinproc->item.ep, NN_STAT_ESTABLISHED_CONNECTIONS, 1);
 }
 
 static void nn_cinproc_shutdown (struct nn_fsm *self, int src, int type,
@@ -141,7 +140,7 @@
 
     cinproc = nn_cont (self, struct nn_cinproc, fsm);
 
-    if (nn_slow (src == NN_FSM_ACTION && type == NN_FSM_STOP)) {
+    if (src == NN_FSM_ACTION && type == NN_FSM_STOP) {
 
         /*  First, unregister the endpoint from the global repository of inproc
             endpoints. This way, new connections cannot be created anymore. */
@@ -157,7 +156,7 @@
         cinproc->state = NN_CINPROC_STATE_STOPPING;
         goto finish;
     }
-    if (nn_slow (cinproc->state == NN_CINPROC_STATE_STOPPING)) {
+    if (cinproc->state == NN_CINPROC_STATE_STOPPING) {
         sinproc = (struct nn_sinproc *) srcptr;
         nn_list_erase (&cinproc->sinprocs, &sinproc->item);
         nn_sinproc_term (sinproc);
@@ -168,7 +167,7 @@
             return;
         cinproc->state = NN_CINPROC_STATE_IDLE;
         nn_fsm_stopped_noevent (&cinproc->fsm);
-        nn_epbase_stopped (&cinproc->item.epbase);
+        nn_ep_stopped (cinproc->item.ep);
         return;
     }
 
@@ -219,13 +218,13 @@
                 sinproc = nn_alloc (sizeof (struct nn_sinproc), "sinproc");
                 alloc_assert (sinproc);
                 nn_sinproc_init (sinproc, NN_CINPROC_SRC_SINPROC,
-                    &cinproc->item.epbase, &cinproc->fsm);
+                    cinproc->item.ep, &cinproc->fsm);
                 nn_list_insert (&cinproc->sinprocs, &sinproc->item,
                     nn_list_end (&cinproc->sinprocs));
                 nn_sinproc_accept (sinproc, peer);
-                nn_epbase_stat_increment (&cinproc->item.epbase,
+                nn_ep_stat_increment (cinproc->item.ep,
                     NN_STAT_INPROGRESS_CONNECTIONS, -1);
-                nn_epbase_stat_increment (&cinproc->item.epbase,
+                nn_ep_stat_increment (cinproc->item.ep,
                     NN_STAT_ESTABLISHED_CONNECTIONS, 1);
                 return;
             default:
@@ -235,7 +234,7 @@
         case NN_CINPROC_SRC_SINPROC:
             switch (type) {
             case NN_SINPROC_DISCONNECT:
-                nn_epbase_stat_increment (&cinproc->item.epbase,
+                nn_ep_stat_increment (cinproc->item.ep,
                     NN_STAT_INPROGRESS_CONNECTIONS, 1);
                 return;
             }
@@ -252,4 +251,3 @@
         nn_fsm_bad_state (cinproc->state, src, type);
     }
 }
-
diff --git a/src/transports/inproc/cinproc.h b/src/transports/inproc/cinproc.h
index 8a6355e..c5d7c0b 100644
--- a/src/transports/inproc/cinproc.h
+++ b/src/transports/inproc/cinproc.h
@@ -46,7 +46,7 @@
     struct nn_list sinprocs;
 };
 
-int nn_cinproc_create (void *hint, struct nn_epbase **epbase);
+int nn_cinproc_create (struct nn_ep *);
 
 #endif
 
diff --git a/src/transports/inproc/inproc.c b/src/transports/inproc/inproc.c
index 9f994f5..a77f8fa 100644
--- a/src/transports/inproc/inproc.c
+++ b/src/transports/inproc/inproc.c
@@ -33,8 +33,8 @@
 /*  nn_transport interface. */
 static void nn_inproc_init (void);
 static void nn_inproc_term (void);
-static int nn_inproc_bind (void *hint, struct nn_epbase **epbase);
-static int nn_inproc_connect (void *hint, struct nn_epbase **epbase);
+static int nn_inproc_bind (struct nn_ep *);
+static int nn_inproc_connect (struct nn_ep *);
 
 static struct nn_transport nn_inproc_vfptr = {
     "inproc",
@@ -59,13 +59,13 @@
     nn_ins_term ();
 }
 
-static int nn_inproc_bind (void *hint, struct nn_epbase **epbase)
+static int nn_inproc_bind (struct nn_ep *ep)
 {
-    return nn_binproc_create (hint, epbase);
+    return nn_binproc_create (ep);
 }
 
-static int nn_inproc_connect (void *hint, struct nn_epbase **epbase)
+static int nn_inproc_connect (struct nn_ep *ep)
 {
-    return nn_cinproc_create (hint, epbase);
+    return nn_cinproc_create (ep);
 }
 
diff --git a/src/transports/inproc/ins.c b/src/transports/inproc/ins.c
index b8e08eb..2bd39fe 100644
--- a/src/transports/inproc/ins.c
+++ b/src/transports/inproc/ins.c
@@ -48,23 +48,15 @@
     inproc endpoints in the current process. */
 static struct nn_ins self;
 
-void nn_ins_item_init (struct nn_ins_item *self,
-    const struct nn_epbase_vfptr *vfptr, void *hint)
+void nn_ins_item_init (struct nn_ins_item *self, struct nn_ep *ep)
 {
-    size_t sz;
-
-    nn_epbase_init (&self->epbase, vfptr, hint);
+    self->ep = ep;
     nn_list_item_init (&self->item);
-    sz = sizeof (self->protocol);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_PROTOCOL,
-        &self->protocol, &sz);
-    nn_assert (sz == sizeof (self->protocol));
 }
 
 void nn_ins_item_term (struct nn_ins_item *self)
 {
     nn_list_item_term (&self->item);
-    nn_epbase_term (&self->epbase);
 }
 
 void nn_ins_init (void)
@@ -93,8 +85,10 @@
     for (it = nn_list_begin (&self.bound); it != nn_list_end (&self.bound);
           it = nn_list_next (&self.bound, it)) {
         bitem = nn_cont (it, struct nn_ins_item, item);
-        if (strncmp (nn_epbase_getaddr (&item->epbase),
-              nn_epbase_getaddr (&bitem->epbase), NN_SOCKADDR_MAX) == 0) {
+
+        if (strncmp (nn_ep_getaddr(bitem->ep), nn_ep_getaddr(item->ep),
+            NN_SOCKADDR_MAX) == 0) {
+
             nn_mutex_unlock (&self.sync);
             return -EADDRINUSE;
         }
@@ -109,11 +103,11 @@
           it != nn_list_end (&self.connected);
           it = nn_list_next (&self.connected, it)) {
         citem = nn_cont (it, struct nn_ins_item, item);
-        if (strncmp (nn_epbase_getaddr (&item->epbase),
-              nn_epbase_getaddr (&citem->epbase), NN_SOCKADDR_MAX) == 0) {
+        if (strncmp (nn_ep_getaddr(item->ep), nn_ep_getaddr(citem->ep),
+            NN_SOCKADDR_MAX) == 0) {
 
             /*  Check whether the two sockets are compatible. */
-            if (!nn_epbase_ispeer (&item->epbase, citem->protocol))
+            if (!nn_ep_ispeer_ep (item->ep, citem->ep))
                 continue;
 
             fn (item, citem);
@@ -141,11 +135,12 @@
           it != nn_list_end (&self.bound);
           it = nn_list_next (&self.bound, it)) {
         bitem = nn_cont (it, struct nn_ins_item, item);
-        if (strncmp (nn_epbase_getaddr (&item->epbase),
-              nn_epbase_getaddr (&bitem->epbase), NN_SOCKADDR_MAX) == 0) {
+
+        if (strncmp (nn_ep_getaddr(item->ep), nn_ep_getaddr(bitem->ep),
+            NN_SOCKADDR_MAX) == 0) {
 
             /*  Check whether the two sockets are compatible. */
-            if (!nn_epbase_ispeer (&item->epbase, bitem->protocol))
+            if (!nn_ep_ispeer_ep (item->ep, bitem->ep))
                 break;
 
             /*  Call back to cinproc to create actual connection. */
diff --git a/src/transports/inproc/ins.h b/src/transports/inproc/ins.h
index 04034fb..99b76fd 100644
--- a/src/transports/inproc/ins.h
+++ b/src/transports/inproc/ins.h
@@ -31,19 +31,17 @@
 
 struct nn_ins_item {
 
-    /*  Every ins_item is an endpoint. */
-    struct nn_epbase epbase;
-
     /*  Every ins_item is either in the list of bound or connected endpoints. */
     struct nn_list_item item;
 
+    struct nn_ep *ep;
+
     /*  This is the local cache of the endpoint's protocol ID. This way we can
         check the value without actually locking the object. */
     int protocol;
 };
 
-void nn_ins_item_init (struct nn_ins_item *self,
-    const struct nn_epbase_vfptr *vfptr, void *hint);
+void nn_ins_item_init (struct nn_ins_item *self, struct nn_ep *ep);
 void nn_ins_item_term (struct nn_ins_item *self);
 
 void nn_ins_init (void);
diff --git a/src/transports/inproc/sinproc.c b/src/transports/inproc/sinproc.c
index 546e299..314d827 100644
--- a/src/transports/inproc/sinproc.c
+++ b/src/transports/inproc/sinproc.c
@@ -63,7 +63,7 @@
 };
 
 void nn_sinproc_init (struct nn_sinproc *self, int src,
-    struct nn_epbase *epbase, struct nn_fsm *owner)
+    struct nn_ep *ep, struct nn_fsm *owner)
 {
     int rcvbuf;
     size_t sz;
@@ -73,9 +73,9 @@
     self->state = NN_SINPROC_STATE_IDLE;
     self->flags = 0;
     self->peer = NULL;
-    nn_pipebase_init (&self->pipebase, &nn_sinproc_pipebase_vfptr, epbase);
+    nn_pipebase_init (&self->pipebase, &nn_sinproc_pipebase_vfptr, ep);
     sz = sizeof (rcvbuf);
-    nn_epbase_getopt (epbase, NN_SOL_SOCKET, NN_RCVBUF, &rcvbuf, &sz);
+    nn_ep_getopt (ep, NN_SOL_SOCKET, NN_RCVBUF, &rcvbuf, &sz);
     nn_assert (sz == sizeof (rcvbuf));
     nn_msgqueue_init (&self->msgqueue, rcvbuf);
     nn_msg_init (&self->msg, 0);
diff --git a/src/transports/inproc/sinproc.h b/src/transports/inproc/sinproc.h
index 07b51ad..ed6367f 100644
--- a/src/transports/inproc/sinproc.h
+++ b/src/transports/inproc/sinproc.h
@@ -1,5 +1,6 @@
 /*
     Copyright (c) 2013 Martin Sustrik  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -82,7 +83,7 @@
 };
 
 void nn_sinproc_init (struct nn_sinproc *self, int src,
-    struct nn_epbase *epbase, struct nn_fsm *owner);
+    struct nn_ep *ep, struct nn_fsm *owner);
 void nn_sinproc_term (struct nn_sinproc *self);
 int nn_sinproc_isidle (struct nn_sinproc *self);
 
diff --git a/src/transports/ipc/aipc.c b/src/transports/ipc/aipc.c
index bc64a4e..8889af2 100644
--- a/src/transports/ipc/aipc.c
+++ b/src/transports/ipc/aipc.c
@@ -1,5 +1,6 @@
 /*
     Copyright (c) 2012-2013 Martin Sustrik  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -46,17 +47,17 @@
    void *srcptr);
 
 void nn_aipc_init (struct nn_aipc *self, int src,
-    struct nn_epbase *epbase, struct nn_fsm *owner)
+    struct nn_ep *ep, struct nn_fsm *owner)
 {
     nn_fsm_init (&self->fsm, nn_aipc_handler, nn_aipc_shutdown,
         src, self, owner);
     self->state = NN_AIPC_STATE_IDLE;
-    self->epbase = epbase;
+    self->ep = ep;
     nn_usock_init (&self->usock, NN_AIPC_SRC_USOCK, &self->fsm);
     self->listener = NULL;
     self->listener_owner.src = -1;
     self->listener_owner.fsm = NULL;
-    nn_sipc_init (&self->sipc, NN_AIPC_SRC_SIPC, epbase, &self->fsm);
+    nn_sipc_init (&self->sipc, NN_AIPC_SRC_SIPC, ep, &self->fsm);
     nn_fsm_event_init (&self->accepted);
     nn_fsm_event_init (&self->done);
     nn_list_item_init (&self->item);
@@ -94,9 +95,9 @@
 
 #if defined NN_HAVE_WINDOWS
     /* Get/Set security attribute pointer*/
-    nn_epbase_getopt (self->epbase, NN_IPC, NN_IPC_SEC_ATTR, &self->usock.sec_attr, &sz);
-    nn_epbase_getopt (self->epbase, NN_IPC, NN_IPC_OUTBUFSZ, &self->usock.outbuffersz, &sz);
-    nn_epbase_getopt (self->epbase, NN_IPC, NN_IPC_INBUFSZ, &self->usock.inbuffersz, &sz);
+    nn_ep_getopt (self->ep, NN_IPC, NN_IPC_SEC_ATTR, &self->usock.sec_attr, &sz);
+    nn_ep_getopt (self->ep, NN_IPC, NN_IPC_OUTBUFSZ, &self->usock.outbuffersz, &sz);
+    nn_ep_getopt (self->ep, NN_IPC, NN_IPC_INBUFSZ, &self->usock.inbuffersz, &sz);
 #endif
 
     /*  Start the state machine. */
@@ -117,8 +118,7 @@
 
     if (nn_slow (src == NN_FSM_ACTION && type == NN_FSM_STOP)) {
         if (!nn_sipc_isidle (&aipc->sipc)) {
-            nn_epbase_stat_increment (aipc->epbase,
-                NN_STAT_DROPPED_CONNECTIONS, 1);
+            nn_ep_stat_increment (aipc->ep, NN_STAT_DROPPED_CONNECTIONS, 1);
             nn_sipc_stop (&aipc->sipc);
         }
         aipc->state = NN_AIPC_STATE_STOPPING_SIPC_FINAL;
@@ -189,18 +189,16 @@
         case NN_AIPC_SRC_USOCK:
             switch (type) {
             case NN_USOCK_ACCEPTED:
-                nn_epbase_clear_error (aipc->epbase);
+                nn_ep_clear_error (aipc->ep);
 
                 /*  Set the relevant socket options. */
                 sz = sizeof (val);
-                nn_epbase_getopt (aipc->epbase, NN_SOL_SOCKET, NN_SNDBUF,
-                    &val, &sz);
+                nn_ep_getopt (aipc->ep, NN_SOL_SOCKET, NN_SNDBUF, &val, &sz);
                 nn_assert (sz == sizeof (val));
                 nn_usock_setsockopt (&aipc->usock, SOL_SOCKET, SO_SNDBUF,
                     &val, sizeof (val));
                 sz = sizeof (val);
-                nn_epbase_getopt (aipc->epbase, NN_SOL_SOCKET, NN_RCVBUF,
-                    &val, &sz);
+                nn_ep_getopt (aipc->ep, NN_SOL_SOCKET, NN_RCVBUF, &val, &sz);
                 nn_assert (sz == sizeof (val));
                 nn_usock_setsockopt (&aipc->usock, SOL_SOCKET, SO_RCVBUF,
                     &val, sizeof (val));
@@ -217,7 +215,7 @@
                 nn_sipc_start (&aipc->sipc, &aipc->usock);
                 aipc->state = NN_AIPC_STATE_ACTIVE;
 
-                nn_epbase_stat_increment (aipc->epbase,
+                nn_ep_stat_increment (aipc->ep,
                     NN_STAT_ACCEPTED_CONNECTIONS, 1);
 
                 return;
@@ -229,10 +227,8 @@
         case NN_AIPC_SRC_LISTENER:
             switch (type) {
             case NN_USOCK_ACCEPT_ERROR:
-                nn_epbase_set_error (aipc->epbase,
-                    nn_usock_geterrno (aipc->listener));
-                nn_epbase_stat_increment (aipc->epbase,
-                    NN_STAT_ACCEPT_ERRORS, 1);
+                nn_ep_set_error (aipc->ep, nn_usock_geterrno (aipc->listener));
+                nn_ep_stat_increment (aipc->ep, NN_STAT_ACCEPT_ERRORS, 1);
                 nn_usock_accept (&aipc->usock, aipc->listener);
 
                 return;
@@ -256,8 +252,7 @@
             case NN_SIPC_ERROR:
                 nn_sipc_stop (&aipc->sipc);
                 aipc->state = NN_AIPC_STATE_STOPPING_SIPC;
-                nn_epbase_stat_increment (aipc->epbase,
-                    NN_STAT_BROKEN_CONNECTIONS, 1);
+                nn_ep_stat_increment (aipc->ep, NN_STAT_BROKEN_CONNECTIONS, 1);
                 return;
             default:
                 nn_fsm_bad_action (aipc->state, src, type);
diff --git a/src/transports/ipc/aipc.h b/src/transports/ipc/aipc.h
index 2c95a7f..e9d7c72 100644
--- a/src/transports/ipc/aipc.h
+++ b/src/transports/ipc/aipc.h
@@ -1,5 +1,6 @@
 /*
     Copyright (c) 2013 Martin Sustrik  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -49,7 +50,7 @@
     int state;
 
     /*  Pointer to the associated endpoint. */
-    struct nn_epbase *epbase;
+    struct nn_ep *ep;
 
     /*  Underlying socket. */
     struct nn_usock usock;
@@ -70,7 +71,7 @@
 };
 
 void nn_aipc_init (struct nn_aipc *self, int src,
-    struct nn_epbase *epbase, struct nn_fsm *owner);
+    struct nn_ep *ep, struct nn_fsm *owner);
 void nn_aipc_term (struct nn_aipc *self);
 
 int nn_aipc_isidle (struct nn_aipc *self);
@@ -78,4 +79,3 @@
 void nn_aipc_stop (struct nn_aipc *self);
 
 #endif
-
diff --git a/src/transports/ipc/bipc.c b/src/transports/ipc/bipc.c
index f1b3a2a..4b729ab 100644
--- a/src/transports/ipc/bipc.c
+++ b/src/transports/ipc/bipc.c
@@ -60,9 +60,7 @@
     struct nn_fsm fsm;
     int state;
 
-    /*  This object is a specific type of endpoint.
-        Thus it is derived from epbase. */
-    struct nn_epbase epbase;
+    struct nn_ep *ep;
 
     /*  The underlying listening IPC socket. */
     struct nn_usock usock;
@@ -74,10 +72,10 @@
     struct nn_list aipcs;
 };
 
-/*  nn_epbase virtual interface implementation. */
-static void nn_bipc_stop (struct nn_epbase *self);
-static void nn_bipc_destroy (struct nn_epbase *self);
-const struct nn_epbase_vfptr nn_bipc_epbase_vfptr = {
+/*  nn_ep virtual interface implementation. */
+static void nn_bipc_stop (struct nn_ep *self);
+static void nn_bipc_destroy (struct nn_ep *self);
+const struct nn_ep_vfptr nn_bipc_ep_vfptr = {
     nn_bipc_stop,
     nn_bipc_destroy
 };
@@ -90,7 +88,7 @@
 static int nn_bipc_listen (struct nn_bipc *self);
 static void nn_bipc_start_accepting (struct nn_bipc *self);
 
-int nn_bipc_create (void *hint, struct nn_epbase **epbase)
+int nn_bipc_create (struct nn_ep *ep)
 {
     struct nn_bipc *self;
     int rc;
@@ -101,9 +99,10 @@
 
 
     /*  Initialise the structure. */
-    nn_epbase_init (&self->epbase, &nn_bipc_epbase_vfptr, hint);
+    nn_ep_tran_setup (ep, &nn_bipc_ep_vfptr, self);
+    self->ep = ep;
     nn_fsm_init_root (&self->fsm, nn_bipc_handler, nn_bipc_shutdown,
-        nn_epbase_getctx (&self->epbase));
+        nn_ep_getctx (ep));
     self->state = NN_BIPC_STATE_IDLE;
     self->aipc = NULL;
     nn_list_init (&self->aipcs);
@@ -115,36 +114,31 @@
 
     rc = nn_bipc_listen (self);
     if (rc != 0) {
-        nn_epbase_term (&self->epbase);
         return rc;
     }
 
-    /*  Return the base class as an out parameter. */
-    *epbase = &self->epbase;
-
     return 0;
 }
 
-static void nn_bipc_stop (struct nn_epbase *self)
+static void nn_bipc_stop (struct nn_ep *ep)
 {
     struct nn_bipc *bipc;
 
-    bipc = nn_cont (self, struct nn_bipc, epbase);
+    bipc = nn_ep_tran_private (ep);
 
     nn_fsm_stop (&bipc->fsm);
 }
 
-static void nn_bipc_destroy (struct nn_epbase *self)
+static void nn_bipc_destroy (struct nn_ep *ep)
 {
     struct nn_bipc *bipc;
 
-    bipc = nn_cont (self, struct nn_bipc, epbase);
+    bipc = nn_ep_tran_private (ep);
 
     nn_assert_state (bipc, NN_BIPC_STATE_IDLE);
     nn_list_term (&bipc->aipcs);
     nn_assert (bipc->aipc == NULL);
     nn_usock_term (&bipc->usock);
-    nn_epbase_term (&bipc->epbase);
     nn_fsm_term (&bipc->fsm);
 
     nn_free (bipc);
@@ -182,7 +176,7 @@
 
         /* On *nixes, unlink the domain socket file */
 #if defined NN_HAVE_UNIX_SOCKETS
-        addr = nn_epbase_getaddr (&bipc->epbase);
+        addr = nn_ep_getaddr (bipc->ep);
         rc = unlink(addr);
         errno_assert (rc == 0 || errno == ENOENT);
 #endif
@@ -215,7 +209,7 @@
         if (nn_list_empty (&bipc->aipcs)) {
             bipc->state = NN_BIPC_STATE_IDLE;
             nn_fsm_stopped_noevent (&bipc->fsm);
-            nn_epbase_stopped (&bipc->epbase);
+            nn_ep_stopped (bipc->ep);
             return;
         }
 
@@ -296,7 +290,7 @@
 #endif
 
     /*  First, create the AF_UNIX address. */
-    addr = nn_epbase_getaddr (&self->epbase);
+    addr = nn_ep_getaddr (self->ep);
     memset (&ss, 0, sizeof (ss));
     un = (struct sockaddr_un*) &ss;
     nn_assert (strlen (addr) < sizeof (un->sun_path));
@@ -357,7 +351,7 @@
     /*  Allocate new aipc state machine. */
     self->aipc = nn_alloc (sizeof (struct nn_aipc), "aipc");
     alloc_assert (self->aipc);
-    nn_aipc_init (self->aipc, NN_BIPC_SRC_AIPC, &self->epbase, &self->fsm);
+    nn_aipc_init (self->aipc, NN_BIPC_SRC_AIPC, self->ep, &self->fsm);
 
     /*  Start waiting for a new incoming connection. */
     nn_aipc_start (self->aipc, &self->usock);
diff --git a/src/transports/ipc/bipc.h b/src/transports/ipc/bipc.h
index ca43bd5..b7c3f69 100644
--- a/src/transports/ipc/bipc.h
+++ b/src/transports/ipc/bipc.h
@@ -1,5 +1,6 @@
 /*
     Copyright (c) 2013 Martin Sustrik  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -27,6 +28,6 @@
 
 /*  State machine managing bound IPC socket. */
 
-int nn_bipc_create (void *hint, struct nn_epbase **epbase);
+int nn_bipc_create (struct nn_ep *);
 
 #endif
diff --git a/src/transports/ipc/cipc.c b/src/transports/ipc/cipc.c
index 1f6adad..844cf94 100644
--- a/src/transports/ipc/cipc.c
+++ b/src/transports/ipc/cipc.c
@@ -1,5 +1,6 @@
 /*
     Copyright (c) 2012-2013 Martin Sustrik  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -62,9 +63,7 @@
     struct nn_fsm fsm;
     int state;
 
-    /*  This object is a specific type of endpoint.
-        Thus it is derived from epbase. */
-    struct nn_epbase epbase;
+    struct nn_ep *ep;
 
     /*  The underlying IPC socket. */
     struct nn_usock usock;
@@ -77,10 +76,10 @@
     struct nn_sipc sipc;
 };
 
-/*  nn_epbase virtual interface implementation. */
-static void nn_cipc_stop (struct nn_epbase *self);
-static void nn_cipc_destroy (struct nn_epbase *self);
-const struct nn_epbase_vfptr nn_cipc_epbase_vfptr = {
+/*  nn_ep virtual interface implementation. */
+static void nn_cipc_stop (struct nn_ep *ep);
+static void nn_cipc_destroy (struct nn_ep *ep);
+const struct nn_ep_vfptr nn_cipc_ep_vfptr = {
     nn_cipc_stop,
     nn_cipc_destroy
 };
@@ -92,7 +91,7 @@
     void *srcptr);
 static void nn_cipc_start_connecting (struct nn_cipc *self);
 
-int nn_cipc_create (void *hint, struct nn_epbase **epbase)
+int nn_cipc_create (struct nn_ep *ep)
 {
     struct nn_cipc *self;
     int reconnect_ivl;
@@ -104,54 +103,50 @@
     alloc_assert (self);
 
     /*  Initialise the structure. */
-    nn_epbase_init (&self->epbase, &nn_cipc_epbase_vfptr, hint);
+    self->ep = ep;
+    nn_ep_tran_setup (ep, &nn_cipc_ep_vfptr, self);
     nn_fsm_init_root (&self->fsm, nn_cipc_handler, nn_cipc_shutdown,
-        nn_epbase_getctx (&self->epbase));
+        nn_ep_getctx (ep));
     self->state = NN_CIPC_STATE_IDLE;
     nn_usock_init (&self->usock, NN_CIPC_SRC_USOCK, &self->fsm);
     sz = sizeof (reconnect_ivl);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_RECONNECT_IVL,
-        &reconnect_ivl, &sz);
+    nn_ep_getopt (ep, NN_SOL_SOCKET, NN_RECONNECT_IVL, &reconnect_ivl, &sz);
     nn_assert (sz == sizeof (reconnect_ivl));
     sz = sizeof (reconnect_ivl_max);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_RECONNECT_IVL_MAX,
+    nn_ep_getopt (ep, NN_SOL_SOCKET, NN_RECONNECT_IVL_MAX,
         &reconnect_ivl_max, &sz);
     nn_assert (sz == sizeof (reconnect_ivl_max));
     if (reconnect_ivl_max == 0)
         reconnect_ivl_max = reconnect_ivl;
     nn_backoff_init (&self->retry, NN_CIPC_SRC_RECONNECT_TIMER,
         reconnect_ivl, reconnect_ivl_max, &self->fsm);
-    nn_sipc_init (&self->sipc, NN_CIPC_SRC_SIPC, &self->epbase, &self->fsm);
+    nn_sipc_init (&self->sipc, NN_CIPC_SRC_SIPC, ep, &self->fsm);
 
     /*  Start the state machine. */
     nn_fsm_start (&self->fsm);
 
-    /*  Return the base class as an out parameter. */
-    *epbase = &self->epbase;
-
     return 0;
 }
 
-static void nn_cipc_stop (struct nn_epbase *self)
+static void nn_cipc_stop (struct nn_ep *ep)
 {
     struct nn_cipc *cipc;
 
-    cipc = nn_cont (self, struct nn_cipc, epbase);
+    cipc = nn_ep_tran_private (ep);
 
     nn_fsm_stop (&cipc->fsm);
 }
 
-static void nn_cipc_destroy (struct nn_epbase *self)
+static void nn_cipc_destroy (struct nn_ep *ep)
 {
     struct nn_cipc *cipc;
 
-    cipc = nn_cont (self, struct nn_cipc, epbase);
+    cipc = nn_ep_tran_private (ep);
 
     nn_sipc_term (&cipc->sipc);
     nn_backoff_term (&cipc->retry);
     nn_usock_term (&cipc->usock);
     nn_fsm_term (&cipc->fsm);
-    nn_epbase_term (&cipc->epbase);
 
     nn_free (cipc);
 }
@@ -165,8 +160,7 @@
 
     if (nn_slow (src == NN_FSM_ACTION && type == NN_FSM_STOP)) {
         if (!nn_sipc_isidle (&cipc->sipc)) {
-            nn_epbase_stat_increment (&cipc->epbase,
-                NN_STAT_DROPPED_CONNECTIONS, 1);
+            nn_ep_stat_increment (cipc->ep, NN_STAT_DROPPED_CONNECTIONS, 1);
             nn_sipc_stop (&cipc->sipc);
         }
         cipc->state = NN_CIPC_STATE_STOPPING_SIPC_FINAL;
@@ -184,7 +178,7 @@
             return;
         cipc->state = NN_CIPC_STATE_IDLE;
         nn_fsm_stopped_noevent (&cipc->fsm);
-        nn_epbase_stopped (&cipc->epbase);
+        nn_ep_stopped (cipc->ep);
         return;
     }
 
@@ -232,21 +226,19 @@
             case NN_USOCK_CONNECTED:
                 nn_sipc_start (&cipc->sipc, &cipc->usock);
                 cipc->state = NN_CIPC_STATE_ACTIVE;
-                nn_epbase_stat_increment (&cipc->epbase,
+                nn_ep_stat_increment (cipc->ep,
                     NN_STAT_INPROGRESS_CONNECTIONS, -1);
-                nn_epbase_stat_increment (&cipc->epbase,
+                nn_ep_stat_increment (cipc->ep,
                     NN_STAT_ESTABLISHED_CONNECTIONS, 1);
-                nn_epbase_clear_error (&cipc->epbase);
+                nn_ep_clear_error (cipc->ep);
                 return;
             case NN_USOCK_ERROR:
-                nn_epbase_set_error (&cipc->epbase,
-                    nn_usock_geterrno (&cipc->usock));
+                nn_ep_set_error (cipc->ep, nn_usock_geterrno (&cipc->usock));
                 nn_usock_stop (&cipc->usock);
                 cipc->state = NN_CIPC_STATE_STOPPING_USOCK;
-                nn_epbase_stat_increment (&cipc->epbase,
+                nn_ep_stat_increment (cipc->ep,
                     NN_STAT_INPROGRESS_CONNECTIONS, -1);
-                nn_epbase_stat_increment (&cipc->epbase,
-                    NN_STAT_CONNECT_ERRORS, 1);
+                nn_ep_stat_increment (cipc->ep, NN_STAT_CONNECT_ERRORS, 1);
                 return;
             default:
                 nn_fsm_bad_action (cipc->state, src, type);
@@ -268,8 +260,7 @@
             case NN_SIPC_ERROR:
                 nn_sipc_stop (&cipc->sipc);
                 cipc->state = NN_CIPC_STATE_STOPPING_SIPC;
-                nn_epbase_stat_increment (&cipc->epbase,
-                    NN_STAT_BROKEN_CONNECTIONS, 1);
+                nn_ep_stat_increment (cipc->ep, NN_STAT_BROKEN_CONNECTIONS, 1);
                 return;
             default:
                nn_fsm_bad_action (cipc->state, src, type);
@@ -398,18 +389,18 @@
 
     /*  Set the relevant socket options. */
     sz = sizeof (val);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_SNDBUF, &val, &sz);
+    nn_ep_getopt (self->ep, NN_SOL_SOCKET, NN_SNDBUF, &val, &sz);
     nn_assert (sz == sizeof (val));
     nn_usock_setsockopt (&self->usock, SOL_SOCKET, SO_SNDBUF,
         &val, sizeof (val));
     sz = sizeof (val);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_RCVBUF, &val, &sz);
+    nn_ep_getopt (self->ep, NN_SOL_SOCKET, NN_RCVBUF, &val, &sz);
     nn_assert (sz == sizeof (val));
     nn_usock_setsockopt (&self->usock, SOL_SOCKET, SO_RCVBUF,
         &val, sizeof (val));
 
     /*  Create the IPC address from the address string. */
-    addr = nn_epbase_getaddr (&self->epbase);
+    addr = nn_ep_getaddr (self->ep);
     memset (&ss, 0, sizeof (ss));
     un = (struct sockaddr_un*) &ss;
     nn_assert (strlen (addr) < sizeof (un->sun_path));
@@ -418,10 +409,10 @@
 
 #if defined NN_HAVE_WINDOWS
     /* Get/Set security attribute pointer*/
-    nn_epbase_getopt (&self->epbase, NN_IPC, NN_IPC_SEC_ATTR, &self->usock.sec_attr, &sz);
+    nn_ep_getopt (self->ep, NN_IPC, NN_IPC_SEC_ATTR, &self->usock.sec_attr, &sz);
 
-    nn_epbase_getopt (&self->epbase, NN_IPC, NN_IPC_OUTBUFSZ, &self->usock.outbuffersz, &sz);
-    nn_epbase_getopt (&self->epbase, NN_IPC, NN_IPC_INBUFSZ, &self->usock.inbuffersz, &sz);
+    nn_ep_getopt (self->ep, NN_IPC, NN_IPC_OUTBUFSZ, &self->usock.outbuffersz, &sz);
+    nn_ep_getopt (self->ep, NN_IPC, NN_IPC_INBUFSZ, &self->usock.inbuffersz, &sz);
 #endif
 
     /*  Start connecting. */
@@ -429,7 +420,5 @@
         sizeof (struct sockaddr_un));
     self->state  = NN_CIPC_STATE_CONNECTING;
 
-    nn_epbase_stat_increment (&self->epbase,
-        NN_STAT_INPROGRESS_CONNECTIONS, 1);
+    nn_ep_stat_increment (self->ep, NN_STAT_INPROGRESS_CONNECTIONS, 1);
 }
-
diff --git a/src/transports/ipc/cipc.h b/src/transports/ipc/cipc.h
index 4036bba..c66db06 100644
--- a/src/transports/ipc/cipc.h
+++ b/src/transports/ipc/cipc.h
@@ -28,6 +28,6 @@
 
 /*  State machine managing connected IPC socket. */
 
-int nn_cipc_create (void *hint, struct nn_epbase **epbase);
+int nn_cipc_create (struct nn_ep *ep);
 
 #endif
diff --git a/src/transports/ipc/ipc.c b/src/transports/ipc/ipc.c
index c4fe740..5f23722 100644
--- a/src/transports/ipc/ipc.c
+++ b/src/transports/ipc/ipc.c
@@ -1,6 +1,7 @@
 /*
     Copyright (c) 2012-2013 Martin Sustrik  All rights reserved.
     Copyright (c) 2013 GoPivotal, Inc.  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -65,8 +66,8 @@
 };
 
 /*  nn_transport interface. */
-static int nn_ipc_bind (void *hint, struct nn_epbase **epbase);
-static int nn_ipc_connect (void *hint, struct nn_epbase **epbase);
+static int nn_ipc_bind (struct nn_ep *ep);
+static int nn_ipc_connect (struct nn_ep *ep);
 static struct nn_optset *nn_ipc_optset (void);
 
 static struct nn_transport nn_ipc_vfptr = {
@@ -82,14 +83,14 @@
 
 struct nn_transport *nn_ipc = &nn_ipc_vfptr;
 
-static int nn_ipc_bind (void *hint, struct nn_epbase **epbase)
+static int nn_ipc_bind (struct nn_ep *ep)
 {
-    return nn_bipc_create (hint, epbase);
+    return nn_bipc_create (ep);
 }
 
-static int nn_ipc_connect (void *hint, struct nn_epbase **epbase)
+static int nn_ipc_connect (struct nn_ep *ep)
 {
-    return nn_cipc_create (hint, epbase);
+    return nn_cipc_create (ep);
 }
 
 static struct nn_optset *nn_ipc_optset ()
diff --git a/src/transports/ipc/sipc.c b/src/transports/ipc/sipc.c
index 8375d49..204dc7a 100644
--- a/src/transports/ipc/sipc.c
+++ b/src/transports/ipc/sipc.c
@@ -1,5 +1,6 @@
 /*
     Copyright (c) 2013 Martin Sustrik  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -69,7 +70,7 @@
     void *srcptr);
 
 void nn_sipc_init (struct nn_sipc *self, int src,
-    struct nn_epbase *epbase, struct nn_fsm *owner)
+    struct nn_ep *ep, struct nn_fsm *owner)
 {
     nn_fsm_init (&self->fsm, nn_sipc_handler, nn_sipc_shutdown,
         src, self, owner);
@@ -78,7 +79,7 @@
     self->usock = NULL;
     self->usock_owner.src = -1;
     self->usock_owner.fsm = NULL;
-    nn_pipebase_init (&self->pipebase, &nn_sipc_pipebase_vfptr, epbase);
+    nn_pipebase_init (&self->pipebase, &nn_sipc_pipebase_vfptr, ep);
     self->instate = -1;
     nn_msg_init (&self->inmsg, 0);
     self->outstate = -1;
diff --git a/src/transports/ipc/sipc.h b/src/transports/ipc/sipc.h
index eaf1e2b..7102c89 100644
--- a/src/transports/ipc/sipc.h
+++ b/src/transports/ipc/sipc.h
@@ -1,5 +1,6 @@
 /*
     Copyright (c) 2013 Martin Sustrik  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -79,7 +80,7 @@
 };
 
 void nn_sipc_init (struct nn_sipc *self, int src,
-    struct nn_epbase *epbase, struct nn_fsm *owner);
+    struct nn_ep *ep, struct nn_fsm *owner);
 void nn_sipc_term (struct nn_sipc *self);
 
 int nn_sipc_isidle (struct nn_sipc *self);
diff --git a/src/transports/tcp/atcp.c b/src/transports/tcp/atcp.c
index e94be8f..60d75ef 100644
--- a/src/transports/tcp/atcp.c
+++ b/src/transports/tcp/atcp.c
@@ -1,5 +1,6 @@
 /*
     Copyright (c) 2012-2013 Martin Sustrik  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -46,17 +47,17 @@
     void *srcptr);
 
 void nn_atcp_init (struct nn_atcp *self, int src,
-    struct nn_epbase *epbase, struct nn_fsm *owner)
+    struct nn_ep *ep, struct nn_fsm *owner)
 {
     nn_fsm_init (&self->fsm, nn_atcp_handler, nn_atcp_shutdown,
         src, self, owner);
     self->state = NN_ATCP_STATE_IDLE;
-    self->epbase = epbase;
+    self->ep = ep;
     nn_usock_init (&self->usock, NN_ATCP_SRC_USOCK, &self->fsm);
     self->listener = NULL;
     self->listener_owner.src = -1;
     self->listener_owner.fsm = NULL;
-    nn_stcp_init (&self->stcp, NN_ATCP_SRC_STCP, epbase, &self->fsm);
+    nn_stcp_init (&self->stcp, NN_ATCP_SRC_STCP, ep, &self->fsm);
     nn_fsm_event_init (&self->accepted);
     nn_fsm_event_init (&self->done);
     nn_list_item_init (&self->item);
@@ -107,8 +108,7 @@
 
     if (nn_slow (src == NN_FSM_ACTION && type == NN_FSM_STOP)) {
         if (!nn_stcp_isidle (&atcp->stcp)) {
-            nn_epbase_stat_increment (atcp->epbase,
-                NN_STAT_DROPPED_CONNECTIONS, 1);
+            nn_ep_stat_increment (atcp->ep, NN_STAT_DROPPED_CONNECTIONS, 1);
             nn_stcp_stop (&atcp->stcp);
         }
         atcp->state = NN_ATCP_STATE_STOPPING_STCP_FINAL;
@@ -179,18 +179,16 @@
         case NN_ATCP_SRC_USOCK:
             switch (type) {
             case NN_USOCK_ACCEPTED:
-                nn_epbase_clear_error (atcp->epbase);
+                nn_ep_clear_error (atcp->ep);
 
                 /*  Set the relevant socket options. */
                 sz = sizeof (val);
-                nn_epbase_getopt (atcp->epbase, NN_SOL_SOCKET, NN_SNDBUF,
-                    &val, &sz);
+                nn_ep_getopt (atcp->ep, NN_SOL_SOCKET, NN_SNDBUF, &val, &sz);
                 nn_assert (sz == sizeof (val));
                 nn_usock_setsockopt (&atcp->usock, SOL_SOCKET, SO_SNDBUF,
                     &val, sizeof (val));
                 sz = sizeof (val);
-                nn_epbase_getopt (atcp->epbase, NN_SOL_SOCKET, NN_RCVBUF,
-                    &val, &sz);
+                nn_ep_getopt (atcp->ep, NN_SOL_SOCKET, NN_RCVBUF, &val, &sz);
                 nn_assert (sz == sizeof (val));
                 nn_usock_setsockopt (&atcp->usock, SOL_SOCKET, SO_RCVBUF,
                     &val, sizeof (val));
@@ -207,7 +205,7 @@
                 nn_stcp_start (&atcp->stcp, &atcp->usock);
                 atcp->state = NN_ATCP_STATE_ACTIVE;
 
-                nn_epbase_stat_increment (atcp->epbase,
+                nn_ep_stat_increment (atcp->ep,
                     NN_STAT_ACCEPTED_CONNECTIONS, 1);
 
                 return;
@@ -220,10 +218,8 @@
             switch (type) {
 
             case NN_USOCK_ACCEPT_ERROR:
-                nn_epbase_set_error (atcp->epbase,
-                    nn_usock_geterrno(atcp->listener));
-                nn_epbase_stat_increment (atcp->epbase,
-                    NN_STAT_ACCEPT_ERRORS, 1);
+                nn_ep_set_error (atcp->ep, nn_usock_geterrno(atcp->listener));
+                nn_ep_stat_increment (atcp->ep, NN_STAT_ACCEPT_ERRORS, 1);
                 nn_usock_accept (&atcp->usock, atcp->listener);
                 return;
 
@@ -246,8 +242,7 @@
             case NN_STCP_ERROR:
                 nn_stcp_stop (&atcp->stcp);
                 atcp->state = NN_ATCP_STATE_STOPPING_STCP;
-                nn_epbase_stat_increment (atcp->epbase,
-                    NN_STAT_BROKEN_CONNECTIONS, 1);
+                nn_ep_stat_increment (atcp->ep, NN_STAT_BROKEN_CONNECTIONS, 1);
                 return;
             default:
                 nn_fsm_bad_action (atcp->state, src, type);
diff --git a/src/transports/tcp/atcp.h b/src/transports/tcp/atcp.h
index 435d2a8..ee9cf45 100644
--- a/src/transports/tcp/atcp.h
+++ b/src/transports/tcp/atcp.h
@@ -1,5 +1,6 @@
 /*
     Copyright (c) 2013 Martin Sustrik  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -48,7 +49,7 @@
     int state;
 
     /*  Pointer to the associated endpoint. */
-    struct nn_epbase *epbase;
+    struct nn_ep *ep;
 
     /*  Underlying socket. */
     struct nn_usock usock;
@@ -69,7 +70,7 @@
 };
 
 void nn_atcp_init (struct nn_atcp *self, int src,
-    struct nn_epbase *epbase, struct nn_fsm *owner);
+    struct nn_ep *ep, struct nn_fsm *owner);
 void nn_atcp_term (struct nn_atcp *self);
 
 int nn_atcp_isidle (struct nn_atcp *self);
diff --git a/src/transports/tcp/btcp.c b/src/transports/tcp/btcp.c
index 1b012c8..a22b60c 100644
--- a/src/transports/tcp/btcp.c
+++ b/src/transports/tcp/btcp.c
@@ -66,9 +66,7 @@
     struct nn_fsm fsm;
     int state;
 
-    /*  This object is a specific type of endpoint.
-        Thus it is derived from epbase. */
-    struct nn_epbase epbase;
+    struct nn_ep *ep;
 
     /*  The underlying listening TCP socket. */
     struct nn_usock usock;
@@ -80,10 +78,10 @@
     struct nn_list atcps;
 };
 
-/*  nn_epbase virtual interface implementation. */
-static void nn_btcp_stop (struct nn_epbase *self);
-static void nn_btcp_destroy (struct nn_epbase *self);
-const struct nn_epbase_vfptr nn_btcp_epbase_vfptr = {
+/*  nn_ep virtual interface implementation. */
+static void nn_btcp_stop (struct nn_ep *);
+static void nn_btcp_destroy (struct nn_ep *);
+const struct nn_ep_vfptr nn_btcp_ep_vfptr = {
     nn_btcp_stop,
     nn_btcp_destroy
 };
@@ -96,7 +94,7 @@
 static int nn_btcp_listen (struct nn_btcp *self);
 static void nn_btcp_start_accepting (struct nn_btcp *self);
 
-int nn_btcp_create (void *hint, struct nn_epbase **epbase)
+int nn_btcp_create (struct nn_ep *ep)
 {
     int rc;
     struct nn_btcp *self;
@@ -110,42 +108,38 @@
 
     /*  Allocate the new endpoint object. */
     self = nn_alloc (sizeof (struct nn_btcp), "btcp");
+    self->ep = ep;
     alloc_assert (self);
 
-    /*  Initalise the epbase. */
-    nn_epbase_init (&self->epbase, &nn_btcp_epbase_vfptr, hint);
-    addr = nn_epbase_getaddr (&self->epbase);
+    nn_ep_tran_setup (ep, &nn_btcp_ep_vfptr, self);
+    addr = nn_ep_getaddr (ep);
 
     /*  Parse the port. */
     end = addr + strlen (addr);
     pos = strrchr (addr, ':');
-    if (nn_slow (!pos)) {
-        nn_epbase_term (&self->epbase);
+    if (pos == NULL) {
         return -EINVAL;
     }
     ++pos;
     rc = nn_port_resolve (pos, end - pos);
-    if (nn_slow (rc < 0)) {
-        nn_epbase_term (&self->epbase);
+    if (rc < 0) {
         return -EINVAL;
     }
 
     /*  Check whether IPv6 is to be used. */
     ipv4onlylen = sizeof (ipv4only);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_IPV4ONLY,
-        &ipv4only, &ipv4onlylen);
+    nn_ep_getopt (ep, NN_SOL_SOCKET, NN_IPV4ONLY, &ipv4only, &ipv4onlylen);
     nn_assert (ipv4onlylen == sizeof (ipv4only));
 
     /*  Parse the address. */
     rc = nn_iface_resolve (addr, pos - addr - 1, ipv4only, &ss, &sslen);
     if (nn_slow (rc < 0)) {
-        nn_epbase_term (&self->epbase);
         return -ENODEV;
     }
 
     /*  Initialise the structure. */
     nn_fsm_init_root (&self->fsm, nn_btcp_handler, nn_btcp_shutdown,
-        nn_epbase_getctx (&self->epbase));
+        nn_ep_getctx (ep));
     self->state = NN_BTCP_STATE_IDLE;
     self->atcp = NULL;
     nn_list_init (&self->atcps);
@@ -157,36 +151,31 @@
 
     rc = nn_btcp_listen (self);
     if (rc != 0) {
-        nn_epbase_term (&self->epbase);
         return rc;
     }
 
-    /*  Return the base class as an out parameter. */
-    *epbase = &self->epbase;
-
     return 0;
 }
 
-static void nn_btcp_stop (struct nn_epbase *self)
+static void nn_btcp_stop (struct nn_ep *ep)
 {
     struct nn_btcp *btcp;
 
-    btcp = nn_cont (self, struct nn_btcp, epbase);
+    btcp = nn_ep_tran_private (ep);
 
     nn_fsm_stop (&btcp->fsm);
 }
 
-static void nn_btcp_destroy (struct nn_epbase *self)
+static void nn_btcp_destroy (struct nn_ep *ep)
 {
     struct nn_btcp *btcp;
 
-    btcp = nn_cont (self, struct nn_btcp, epbase);
+    btcp = nn_ep_tran_private (ep);
 
     nn_assert_state (btcp, NN_BTCP_STATE_IDLE);
     nn_list_term (&btcp->atcps);
     nn_assert (btcp->atcp == NULL);
     nn_usock_term (&btcp->usock);
-    nn_epbase_term (&btcp->epbase);
     nn_fsm_term (&btcp->fsm);
 
     nn_free (btcp);
@@ -244,7 +233,7 @@
         if (nn_list_empty (&btcp->atcps)) {
             btcp->state = NN_BTCP_STATE_IDLE;
             nn_fsm_stopped_noevent (&btcp->fsm);
-            nn_epbase_stopped (&btcp->epbase);
+            nn_ep_stopped (btcp->ep);
             return;
         }
 
@@ -328,7 +317,7 @@
     uint16_t port;
 
     /*  First, resolve the IP address. */
-    addr = nn_epbase_getaddr (&self->epbase);
+    addr = nn_ep_getaddr (self->ep);
     memset (&ss, 0, sizeof (ss));
 
     /*  Parse the port. */
@@ -345,7 +334,7 @@
 
     /*  Parse the address. */
     ipv4onlylen = sizeof (ipv4only);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_IPV4ONLY,
+    nn_ep_getopt (self->ep, NN_SOL_SOCKET, NN_IPV4ONLY,
         &ipv4only, &ipv4onlylen);
     nn_assert (ipv4onlylen == sizeof (ipv4only));
     rc = nn_iface_resolve (addr, pos - addr - 1, ipv4only, &ss, &sslen);
@@ -400,7 +389,7 @@
     /*  Allocate new atcp state machine. */
     self->atcp = nn_alloc (sizeof (struct nn_atcp), "atcp");
     alloc_assert (self->atcp);
-    nn_atcp_init (self->atcp, NN_BTCP_SRC_ATCP, &self->epbase, &self->fsm);
+    nn_atcp_init (self->atcp, NN_BTCP_SRC_ATCP, self->ep, &self->fsm);
 
     /*  Start waiting for a new incoming connection. */
     nn_atcp_start (self->atcp, &self->usock);
diff --git a/src/transports/tcp/btcp.h b/src/transports/tcp/btcp.h
index 30aca24..633af88 100644
--- a/src/transports/tcp/btcp.h
+++ b/src/transports/tcp/btcp.h
@@ -1,5 +1,6 @@
 /*
     Copyright (c) 2013 Martin Sustrik  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -27,7 +28,7 @@
 
 /*  State machine managing bound TCP socket. */
 
-int nn_btcp_create (void *hint, struct nn_epbase **epbase);
+int nn_btcp_create (struct nn_ep *);
 
 #endif
 
diff --git a/src/transports/tcp/ctcp.c b/src/transports/tcp/ctcp.c
index d46ddf7..fb1fc73 100644
--- a/src/transports/tcp/ctcp.c
+++ b/src/transports/tcp/ctcp.c
@@ -1,5 +1,6 @@
 /*
     Copyright (c) 2012-2013 Martin Sustrik  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -73,9 +74,7 @@
     struct nn_fsm fsm;
     int state;
 
-    /*  This object is a specific type of endpoint.
-        Thus it is derived from epbase. */
-    struct nn_epbase epbase;
+    struct nn_ep *ep;
 
     /*  The underlying TCP socket. */
     struct nn_usock usock;
@@ -93,10 +92,10 @@
     struct nn_dns_result dns_result;
 };
 
-/*  nn_epbase virtual interface implementation. */
-static void nn_ctcp_stop (struct nn_epbase *self);
-static void nn_ctcp_destroy (struct nn_epbase *self);
-const struct nn_epbase_vfptr nn_ctcp_epbase_vfptr = {
+/*  nn_ep virtual interface implementation. */
+static void nn_ctcp_stop (struct nn_ep *ep);
+static void nn_ctcp_destroy (struct nn_ep *ep);
+const struct nn_ep_vfptr nn_ctcp_ep_vfptr = {
     nn_ctcp_stop,
     nn_ctcp_destroy
 };
@@ -110,7 +109,7 @@
 static void nn_ctcp_start_connecting (struct nn_ctcp *self,
     struct sockaddr_storage *ss, size_t sslen);
 
-int nn_ctcp_create (void *hint, struct nn_epbase **epbase)
+int nn_ctcp_create (struct nn_ep *ep)
 {
     int rc;
     const char *addr;
@@ -133,16 +132,16 @@
     alloc_assert (self);
 
     /*  Initalise the endpoint. */
-    nn_epbase_init (&self->epbase, &nn_ctcp_epbase_vfptr, hint);
+    self->ep = ep;
+    nn_ep_tran_setup (ep, &nn_ctcp_ep_vfptr, self);
 
     /*  Check whether IPv6 is to be used. */
     ipv4onlylen = sizeof (ipv4only);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_IPV4ONLY,
-        &ipv4only, &ipv4onlylen);
+    nn_ep_getopt (ep, NN_SOL_SOCKET, NN_IPV4ONLY, &ipv4only, &ipv4onlylen);
     nn_assert (ipv4onlylen == sizeof (ipv4only));
 
     /*  Start parsing the address. */
-    addr = nn_epbase_getaddr (&self->epbase);
+    addr = nn_ep_getaddr (ep);
     addrlen = strlen (addr);
     semicolon = strchr (addr, ';');
     hostname = semicolon ? semicolon + 1 : addr;
@@ -150,13 +149,11 @@
     end = addr + addrlen;
 
     /*  Parse the port. */
-    if (nn_slow (!colon)) {
-        nn_epbase_term (&self->epbase);
+    if (!colon) {
         return -EINVAL;
     }
     rc = nn_port_resolve (colon + 1, end - colon - 1);
-    if (nn_slow (rc < 0)) {
-        nn_epbase_term (&self->epbase);
+    if (rc < 0) {
         return -EINVAL;
     }
 
@@ -165,7 +162,6 @@
     if (nn_dns_check_hostname (hostname, colon - hostname) < 0 &&
           nn_literal_resolve (hostname, colon - hostname, ipv4only,
           &ss, &sslen) < 0) {
-        nn_epbase_term (&self->epbase);
         return -EINVAL;
     }
 
@@ -173,61 +169,55 @@
     if (semicolon) {
         rc = nn_iface_resolve (addr, semicolon - addr, ipv4only, &ss, &sslen);
         if (rc < 0) {
-            nn_epbase_term (&self->epbase);
             return -ENODEV;
         }
     }
 
     /*  Initialise the structure. */
     nn_fsm_init_root (&self->fsm, nn_ctcp_handler, nn_ctcp_shutdown,
-        nn_epbase_getctx (&self->epbase));
+        nn_ep_getctx (ep));
     self->state = NN_CTCP_STATE_IDLE;
     nn_usock_init (&self->usock, NN_CTCP_SRC_USOCK, &self->fsm);
     sz = sizeof (reconnect_ivl);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_RECONNECT_IVL,
-        &reconnect_ivl, &sz);
+    nn_ep_getopt (ep, NN_SOL_SOCKET, NN_RECONNECT_IVL, &reconnect_ivl, &sz);
     nn_assert (sz == sizeof (reconnect_ivl));
     sz = sizeof (reconnect_ivl_max);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_RECONNECT_IVL_MAX,
+    nn_ep_getopt (ep, NN_SOL_SOCKET, NN_RECONNECT_IVL_MAX,
         &reconnect_ivl_max, &sz);
     nn_assert (sz == sizeof (reconnect_ivl_max));
     if (reconnect_ivl_max == 0)
         reconnect_ivl_max = reconnect_ivl;
     nn_backoff_init (&self->retry, NN_CTCP_SRC_RECONNECT_TIMER,
         reconnect_ivl, reconnect_ivl_max, &self->fsm);
-    nn_stcp_init (&self->stcp, NN_CTCP_SRC_STCP, &self->epbase, &self->fsm);
+    nn_stcp_init (&self->stcp, NN_CTCP_SRC_STCP, ep, &self->fsm);
     nn_dns_init (&self->dns, NN_CTCP_SRC_DNS, &self->fsm);
 
     /*  Start the state machine. */
     nn_fsm_start (&self->fsm);
 
-    /*  Return the base class as an out parameter. */
-    *epbase = &self->epbase;
-
     return 0;
 }
 
-static void nn_ctcp_stop (struct nn_epbase *self)
+static void nn_ctcp_stop (struct nn_ep *ep)
 {
     struct nn_ctcp *ctcp;
 
-    ctcp = nn_cont (self, struct nn_ctcp, epbase);
+    ctcp = nn_ep_tran_private (ep);
 
     nn_fsm_stop (&ctcp->fsm);
 }
 
-static void nn_ctcp_destroy (struct nn_epbase *self)
+static void nn_ctcp_destroy (struct nn_ep *ep)
 {
     struct nn_ctcp *ctcp;
 
-    ctcp = nn_cont (self, struct nn_ctcp, epbase);
+    ctcp = nn_ep_tran_private (ep);
 
     nn_dns_term (&ctcp->dns);
     nn_stcp_term (&ctcp->stcp);
     nn_backoff_term (&ctcp->retry);
     nn_usock_term (&ctcp->usock);
     nn_fsm_term (&ctcp->fsm);
-    nn_epbase_term (&ctcp->epbase);
 
     nn_free (ctcp);
 }
@@ -239,15 +229,14 @@
 
     ctcp = nn_cont (self, struct nn_ctcp, fsm);
 
-    if (nn_slow (src == NN_FSM_ACTION && type == NN_FSM_STOP)) {
+    if (src == NN_FSM_ACTION && type == NN_FSM_STOP) {
         if (!nn_stcp_isidle (&ctcp->stcp)) {
-            nn_epbase_stat_increment (&ctcp->epbase,
-                NN_STAT_DROPPED_CONNECTIONS, 1);
+            nn_ep_stat_increment (ctcp->ep, NN_STAT_DROPPED_CONNECTIONS, 1);
             nn_stcp_stop (&ctcp->stcp);
         }
         ctcp->state = NN_CTCP_STATE_STOPPING_STCP_FINAL;
     }
-    if (nn_slow (ctcp->state == NN_CTCP_STATE_STOPPING_STCP_FINAL)) {
+    if (ctcp->state == NN_CTCP_STATE_STOPPING_STCP_FINAL) {
         if (!nn_stcp_isidle (&ctcp->stcp))
             return;
         nn_backoff_stop (&ctcp->retry);
@@ -262,7 +251,7 @@
             return;
         ctcp->state = NN_CTCP_STATE_IDLE;
         nn_fsm_stopped_noevent (&ctcp->fsm);
-        nn_epbase_stopped (&ctcp->epbase);
+        nn_ep_stopped (ctcp->ep);
         return;
     }
 
@@ -357,21 +346,19 @@
             case NN_USOCK_CONNECTED:
                 nn_stcp_start (&ctcp->stcp, &ctcp->usock);
                 ctcp->state = NN_CTCP_STATE_ACTIVE;
-                nn_epbase_stat_increment (&ctcp->epbase,
+                nn_ep_stat_increment (ctcp->ep,
                     NN_STAT_INPROGRESS_CONNECTIONS, -1);
-                nn_epbase_stat_increment (&ctcp->epbase,
+                nn_ep_stat_increment (ctcp->ep,
                     NN_STAT_ESTABLISHED_CONNECTIONS, 1);
-                nn_epbase_clear_error (&ctcp->epbase);
+                nn_ep_clear_error (ctcp->ep);
                 return;
             case NN_USOCK_ERROR:
-                nn_epbase_set_error (&ctcp->epbase,
-                    nn_usock_geterrno (&ctcp->usock));
+                nn_ep_set_error (ctcp->ep, nn_usock_geterrno (&ctcp->usock));
                 nn_usock_stop (&ctcp->usock);
                 ctcp->state = NN_CTCP_STATE_STOPPING_USOCK;
-                nn_epbase_stat_increment (&ctcp->epbase,
+                nn_ep_stat_increment (ctcp->ep,
                     NN_STAT_INPROGRESS_CONNECTIONS, -1);
-                nn_epbase_stat_increment (&ctcp->epbase,
-                    NN_STAT_CONNECT_ERRORS, 1);
+                nn_ep_stat_increment (ctcp->ep, NN_STAT_CONNECT_ERRORS, 1);
                 return;
             default:
                 nn_fsm_bad_action (ctcp->state, src, type);
@@ -393,8 +380,7 @@
             case NN_STCP_ERROR:
                 nn_stcp_stop (&ctcp->stcp);
                 ctcp->state = NN_CTCP_STATE_STOPPING_STCP;
-                nn_epbase_stat_increment (&ctcp->epbase,
-                    NN_STAT_BROKEN_CONNECTIONS, 1);
+                nn_ep_stat_increment (ctcp->ep, NN_STAT_BROKEN_CONNECTIONS, 1);
                 return;
             default:
                 nn_fsm_bad_action (ctcp->state, src, type);
@@ -513,7 +499,7 @@
     size_t ipv4onlylen;
 
     /*  Extract the hostname part from address string. */
-    addr = nn_epbase_getaddr (&self->epbase);
+    addr = nn_ep_getaddr (self->ep);
     begin = strchr (addr, ';');
     if (!begin)
         begin = addr;
@@ -524,7 +510,7 @@
 
     /*  Check whether IPv6 is to be used. */
     ipv4onlylen = sizeof (ipv4only);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_IPV4ONLY,
+    nn_ep_getopt (self->ep, NN_SOL_SOCKET, NN_IPV4ONLY,
         &ipv4only, &ipv4onlylen);
     nn_assert (ipv4onlylen == sizeof (ipv4only));
 
@@ -553,7 +539,7 @@
     size_t sz;
 
     /*  Create IP address from the address string. */
-    addr = nn_epbase_getaddr (&self->epbase);
+    addr = nn_ep_getaddr (self->ep);
     memset (&remote, 0, sizeof (remote));
 
     /*  Parse the port. */
@@ -565,7 +551,7 @@
 
     /*  Check whether IPv6 is to be used. */
     ipv4onlylen = sizeof (ipv4only);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_IPV4ONLY,
+    nn_ep_getopt (self->ep, NN_SOL_SOCKET, NN_IPV4ONLY,
         &ipv4only, &ipv4onlylen);
     nn_assert (ipv4onlylen == sizeof (ipv4only));
 
@@ -603,12 +589,12 @@
 
     /*  Set the relevant socket options. */
     sz = sizeof (val);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_SNDBUF, &val, &sz);
+    nn_ep_getopt (self->ep, NN_SOL_SOCKET, NN_SNDBUF, &val, &sz);
     nn_assert (sz == sizeof (val));
     nn_usock_setsockopt (&self->usock, SOL_SOCKET, SO_SNDBUF,
         &val, sizeof (val));
     sz = sizeof (val);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_RCVBUF, &val, &sz);
+    nn_ep_getopt (self->ep, NN_SOL_SOCKET, NN_RCVBUF, &val, &sz);
     nn_assert (sz == sizeof (val));
     nn_usock_setsockopt (&self->usock, SOL_SOCKET, SO_RCVBUF,
         &val, sizeof (val));
@@ -624,7 +610,5 @@
     /*  Start connecting. */
     nn_usock_connect (&self->usock, (struct sockaddr*) &remote, remotelen);
     self->state = NN_CTCP_STATE_CONNECTING;
-    nn_epbase_stat_increment (&self->epbase,
-        NN_STAT_INPROGRESS_CONNECTIONS, 1);
+    nn_ep_stat_increment (self->ep, NN_STAT_INPROGRESS_CONNECTIONS, 1);
 }
-
diff --git a/src/transports/tcp/ctcp.h b/src/transports/tcp/ctcp.h
index 92b1694..11db1ca 100644
--- a/src/transports/tcp/ctcp.h
+++ b/src/transports/tcp/ctcp.h
@@ -1,5 +1,6 @@
 /*
     Copyright (c) 2013 Martin Sustrik  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -27,7 +28,7 @@
 
 /*  State machine managing connected TCP socket. */
 
-int nn_ctcp_create (void *hint, struct nn_epbase **epbase);
+int nn_ctcp_create (struct nn_ep *);
 
 #endif
 
diff --git a/src/transports/tcp/stcp.c b/src/transports/tcp/stcp.c
index 5abe536..61be273 100644
--- a/src/transports/tcp/stcp.c
+++ b/src/transports/tcp/stcp.c
@@ -1,5 +1,6 @@
 /*
     Copyright (c) 2013 Martin Sustrik  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -65,7 +66,7 @@
     void *srcptr);
 
 void nn_stcp_init (struct nn_stcp *self, int src,
-    struct nn_epbase *epbase, struct nn_fsm *owner)
+    struct nn_ep *ep, struct nn_fsm *owner)
 {
     nn_fsm_init (&self->fsm, nn_stcp_handler, nn_stcp_shutdown,
         src, self, owner);
@@ -74,7 +75,7 @@
     self->usock = NULL;
     self->usock_owner.src = -1;
     self->usock_owner.fsm = NULL;
-    nn_pipebase_init (&self->pipebase, &nn_stcp_pipebase_vfptr, epbase);
+    nn_pipebase_init (&self->pipebase, &nn_stcp_pipebase_vfptr, ep);
     self->instate = -1;
     nn_msg_init (&self->inmsg, 0);
     self->outstate = -1;
diff --git a/src/transports/tcp/stcp.h b/src/transports/tcp/stcp.h
index d817807..0a53717 100644
--- a/src/transports/tcp/stcp.h
+++ b/src/transports/tcp/stcp.h
@@ -1,5 +1,6 @@
 /*
     Copyright (c) 2013 Martin Sustrik  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -79,7 +80,7 @@
 };
 
 void nn_stcp_init (struct nn_stcp *self, int src,
-    struct nn_epbase *epbase, struct nn_fsm *owner);
+    struct nn_ep *ep, struct nn_fsm *owner);
 void nn_stcp_term (struct nn_stcp *self);
 
 int nn_stcp_isidle (struct nn_stcp *self);
diff --git a/src/transports/tcp/tcp.c b/src/transports/tcp/tcp.c
index 3039e21..32e5c60 100644
--- a/src/transports/tcp/tcp.c
+++ b/src/transports/tcp/tcp.c
@@ -1,6 +1,7 @@
 /*
     Copyright (c) 2012-2013 Martin Sustrik  All rights reserved.
     Copyright (c) 2013 GoPivotal, Inc.  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -63,8 +64,8 @@
 };
 
 /*  nn_transport interface. */
-static int nn_tcp_bind (void *hint, struct nn_epbase **epbase);
-static int nn_tcp_connect (void *hint, struct nn_epbase **epbase);
+static int nn_tcp_bind (struct nn_ep *ep);
+static int nn_tcp_connect (struct nn_ep *ep);
 static struct nn_optset *nn_tcp_optset (void);
 
 static struct nn_transport nn_tcp_vfptr = {
@@ -80,14 +81,14 @@
 
 struct nn_transport *nn_tcp = &nn_tcp_vfptr;
 
-static int nn_tcp_bind (void *hint, struct nn_epbase **epbase)
+static int nn_tcp_bind (struct nn_ep *ep)
 {
-    return nn_btcp_create (hint, epbase);
+    return nn_btcp_create (ep);
 }
 
-static int nn_tcp_connect (void *hint, struct nn_epbase **epbase)
+static int nn_tcp_connect (struct nn_ep *ep)
 {
-    return nn_ctcp_create (hint, epbase);
+    return nn_ctcp_create (ep);
 }
 
 static struct nn_optset *nn_tcp_optset ()
diff --git a/src/transports/ws/aws.c b/src/transports/ws/aws.c
index bb025e4..d60a1fd 100644
--- a/src/transports/ws/aws.c
+++ b/src/transports/ws/aws.c
@@ -1,7 +1,7 @@
 /*
     Copyright (c) 2012-2013 250bpm s.r.o.  All rights reserved.
     Copyright (c) 2014-2016 Jack R. Dunaway. All rights reserved.
-    Copyright 2015 Garrett D'Amore <garrett@damore.org>
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -49,17 +49,17 @@
     void *srcptr);
 
 void nn_aws_init (struct nn_aws *self, int src,
-    struct nn_epbase *epbase, struct nn_fsm *owner)
+    struct nn_ep *ep, struct nn_fsm *owner)
 {
     nn_fsm_init (&self->fsm, nn_aws_handler, nn_aws_shutdown,
         src, self, owner);
     self->state = NN_AWS_STATE_IDLE;
-    self->epbase = epbase;
+    self->ep = ep;
     nn_usock_init (&self->usock, NN_AWS_SRC_USOCK, &self->fsm);
     self->listener = NULL;
     self->listener_owner.src = -1;
     self->listener_owner.fsm = NULL;
-    nn_sws_init (&self->sws, NN_AWS_SRC_SWS, epbase, &self->fsm);
+    nn_sws_init (&self->sws, NN_AWS_SRC_SWS, ep, &self->fsm);
     nn_fsm_event_init (&self->accepted);
     nn_fsm_event_init (&self->done);
     nn_list_item_init (&self->item);
@@ -110,8 +110,7 @@
 
     if (nn_slow (src == NN_FSM_ACTION && type == NN_FSM_STOP)) {
         if (!nn_sws_isidle (&aws->sws)) {
-            nn_epbase_stat_increment (aws->epbase,
-                NN_STAT_DROPPED_CONNECTIONS, 1);
+            nn_ep_stat_increment (aws->ep, NN_STAT_DROPPED_CONNECTIONS, 1);
             nn_sws_stop (&aws->sws);
         }
         aws->state = NN_AWS_STATE_STOPPING_SWS_FINAL;
@@ -183,24 +182,21 @@
         case NN_AWS_SRC_USOCK:
             switch (type) {
             case NN_USOCK_ACCEPTED:
-                nn_epbase_clear_error (aws->epbase);
+                nn_ep_clear_error (aws->ep);
 
                 /*  Set the relevant socket options. */
                 sz = sizeof (val);
-                nn_epbase_getopt (aws->epbase, NN_SOL_SOCKET, NN_SNDBUF,
-                    &val, &sz);
+                nn_ep_getopt (aws->ep, NN_SOL_SOCKET, NN_SNDBUF, &val, &sz);
                 nn_assert (sz == sizeof (val));
                 nn_usock_setsockopt (&aws->usock, SOL_SOCKET, SO_SNDBUF,
                     &val, sizeof (val));
                 sz = sizeof (val);
-                nn_epbase_getopt (aws->epbase, NN_SOL_SOCKET, NN_RCVBUF,
-                    &val, &sz);
+                nn_ep_getopt (aws->ep, NN_SOL_SOCKET, NN_RCVBUF, &val, &sz);
                 nn_assert (sz == sizeof (val));
                 nn_usock_setsockopt (&aws->usock, SOL_SOCKET, SO_RCVBUF,
                     &val, sizeof (val));
                 sz = sizeof (val);
-                nn_epbase_getopt (aws->epbase, NN_WS, NN_WS_MSG_TYPE,
-                    &val, &sz);
+                nn_ep_getopt (aws->ep, NN_WS, NN_WS_MSG_TYPE, &val, &sz);
                 msg_type = (uint8_t)val;
 
                 /*   Since the WebSocket handshake must poll, the receive
@@ -224,8 +220,7 @@
                     NULL, NULL, msg_type);
                 aws->state = NN_AWS_STATE_ACTIVE;
 
-                nn_epbase_stat_increment (aws->epbase,
-                    NN_STAT_ACCEPTED_CONNECTIONS, 1);
+                nn_ep_stat_increment (aws->ep, NN_STAT_ACCEPTED_CONNECTIONS, 1);
 
                 return;
 
@@ -237,10 +232,8 @@
             switch (type) {
 
             case NN_USOCK_ACCEPT_ERROR:
-                nn_epbase_set_error (aws->epbase,
-                    nn_usock_geterrno (aws->listener));
-                nn_epbase_stat_increment (aws->epbase,
-                    NN_STAT_ACCEPT_ERRORS, 1);
+                nn_ep_set_error (aws->ep, nn_usock_geterrno (aws->listener));
+                nn_ep_stat_increment (aws->ep, NN_STAT_ACCEPT_ERRORS, 1);
                 nn_usock_accept (&aws->usock, aws->listener);
                 return;
 
@@ -269,8 +262,7 @@
             case NN_SWS_RETURN_ERROR:
                 nn_sws_stop (&aws->sws);
                 aws->state = NN_AWS_STATE_STOPPING_SWS;
-                nn_epbase_stat_increment (aws->epbase,
-                    NN_STAT_BROKEN_CONNECTIONS, 1);
+                nn_ep_stat_increment (aws->ep, NN_STAT_BROKEN_CONNECTIONS, 1);
                 return;
             default:
                 nn_fsm_bad_action (aws->state, src, type);
diff --git a/src/transports/ws/aws.h b/src/transports/ws/aws.h
index ae271be..8a03255 100644
--- a/src/transports/ws/aws.h
+++ b/src/transports/ws/aws.h
@@ -1,6 +1,7 @@
 /*
     Copyright (c) 2013 250bpm s.r.o.  All rights reserved.
     Copyright (c) 2014 Wirebird Labs LLC.  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -49,7 +50,7 @@
     int state;
 
     /*  Pointer to the associated endpoint. */
-    struct nn_epbase *epbase;
+    struct nn_ep *ep;
 
     /*  Underlying socket. */
     struct nn_usock usock;
@@ -70,7 +71,7 @@
 };
 
 void nn_aws_init (struct nn_aws *self, int src,
-    struct nn_epbase *epbase, struct nn_fsm *owner);
+    struct nn_ep *ep, struct nn_fsm *owner);
 void nn_aws_term (struct nn_aws *self);
 
 int nn_aws_isidle (struct nn_aws *self);
diff --git a/src/transports/ws/bws.c b/src/transports/ws/bws.c
index da3a53f..98c5448 100644
--- a/src/transports/ws/bws.c
+++ b/src/transports/ws/bws.c
@@ -65,9 +65,7 @@
     struct nn_fsm fsm;
     int state;
 
-    /*  This object is a specific type of endpoint.
-        Thus it is derived from epbase. */
-    struct nn_epbase epbase;
+    struct nn_ep *ep;
 
     /*  The underlying listening WS socket. */
     struct nn_usock usock;
@@ -79,10 +77,10 @@
     struct nn_list awss;
 };
 
-/*  nn_epbase virtual interface implementation. */
-static void nn_bws_stop (struct nn_epbase *self);
-static void nn_bws_destroy (struct nn_epbase *self);
-const struct nn_epbase_vfptr nn_bws_epbase_vfptr = {
+/*  nn_ep virtual interface implementation. */
+static void nn_bws_stop (struct nn_ep *);
+static void nn_bws_destroy (struct nn_ep *);
+const struct nn_ep_vfptr nn_bws_ep_vfptr = {
     nn_bws_stop,
     nn_bws_destroy
 };
@@ -95,7 +93,7 @@
 static int nn_bws_listen (struct nn_bws *self);
 static void nn_bws_start_accepting (struct nn_bws *self);
 
-int nn_bws_create (void *hint, struct nn_epbase **epbase)
+int nn_bws_create (struct nn_ep *ep)
 {
     int rc;
     struct nn_bws *self;
@@ -110,41 +108,37 @@
     /*  Allocate the new endpoint object. */
     self = nn_alloc (sizeof (struct nn_bws), "bws");
     alloc_assert (self);
+    self->ep = ep;
 
-    /*  Initalise the epbase. */
-    nn_epbase_init (&self->epbase, &nn_bws_epbase_vfptr, hint);
-    addr = nn_epbase_getaddr (&self->epbase);
+    nn_ep_tran_setup (ep, &nn_bws_ep_vfptr, self);
+    addr = nn_ep_getaddr (ep);
 
     /*  Parse the port. */
     end = addr + strlen (addr);
     pos = strrchr (addr, ':');
-    if (nn_slow (!pos)) {
-        nn_epbase_term (&self->epbase);
+    if (!pos) {
         return -EINVAL;
     }
     ++pos;
     rc = nn_port_resolve (pos, end - pos);
-    if (nn_slow (rc < 0)) {
-        nn_epbase_term (&self->epbase);
+    if (rc < 0) {
         return -EINVAL;
     }
 
     /*  Check whether IPv6 is to be used. */
     ipv4onlylen = sizeof (ipv4only);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_IPV4ONLY,
-        &ipv4only, &ipv4onlylen);
+    nn_ep_getopt (ep, NN_SOL_SOCKET, NN_IPV4ONLY, &ipv4only, &ipv4onlylen);
     nn_assert (ipv4onlylen == sizeof (ipv4only));
 
     /*  Parse the address. */
     rc = nn_iface_resolve (addr, pos - addr - 1, ipv4only, &ss, &sslen);
-    if (nn_slow (rc < 0)) {
-        nn_epbase_term (&self->epbase);
+    if (rc < 0) {
         return -ENODEV;
     }
 
     /*  Initialise the structure. */
     nn_fsm_init_root (&self->fsm, nn_bws_handler, nn_bws_shutdown,
-        nn_epbase_getctx (&self->epbase));
+        nn_ep_getctx (ep));
     self->state = NN_BWS_STATE_IDLE;
     self->aws = NULL;
     nn_list_init (&self->awss);
@@ -156,36 +150,31 @@
 
     rc = nn_bws_listen (self);
     if (rc != 0) {
-        nn_epbase_term (&self->epbase);
         return rc;
     }
 
-    /*  Return the base class as an out parameter. */
-    *epbase = &self->epbase;
-
     return 0;
 }
 
-static void nn_bws_stop (struct nn_epbase *self)
+static void nn_bws_stop (struct nn_ep *ep)
 {
     struct nn_bws *bws;
 
-    bws = nn_cont (self, struct nn_bws, epbase);
+    bws = nn_ep_tran_private (ep);
 
     nn_fsm_stop (&bws->fsm);
 }
 
-static void nn_bws_destroy (struct nn_epbase *self)
+static void nn_bws_destroy (struct nn_ep *ep)
 {
     struct nn_bws *bws;
 
-    bws = nn_cont (self, struct nn_bws, epbase);
+    bws = nn_ep_tran_private (ep);
 
     nn_assert_state (bws, NN_BWS_STATE_IDLE);
     nn_list_term (&bws->awss);
     nn_assert (bws->aws == NULL);
     nn_usock_term (&bws->usock);
-    nn_epbase_term (&bws->epbase);
     nn_fsm_term (&bws->fsm);
 
     nn_free (bws);
@@ -200,7 +189,7 @@
 
     bws = nn_cont (self, struct nn_bws, fsm);
 
-    if (nn_slow (src == NN_FSM_ACTION && type == NN_FSM_STOP)) {
+    if (src == NN_FSM_ACTION && type == NN_FSM_STOP) {
         if (bws->aws) {
             nn_aws_stop (bws->aws);
             bws->state = NN_BWS_STATE_STOPPING_AWS;
@@ -209,7 +198,7 @@
             bws->state = NN_BWS_STATE_STOPPING_USOCK;
         }
     }
-    if (nn_slow (bws->state == NN_BWS_STATE_STOPPING_AWS)) {
+    if (bws->state == NN_BWS_STATE_STOPPING_AWS) {
         if (!nn_aws_isidle (bws->aws))
             return;
         nn_aws_term (bws->aws);
@@ -218,7 +207,7 @@
         nn_usock_stop (&bws->usock);
         bws->state = NN_BWS_STATE_STOPPING_USOCK;
     }
-    if (nn_slow (bws->state == NN_BWS_STATE_STOPPING_USOCK)) {
+    if (bws->state == NN_BWS_STATE_STOPPING_USOCK) {
        if (!nn_usock_isidle (&bws->usock))
             return;
         for (it = nn_list_begin (&bws->awss);
@@ -230,7 +219,7 @@
         bws->state = NN_BWS_STATE_STOPPING_AWSS;
         goto awss_stopping;
     }
-    if (nn_slow (bws->state == NN_BWS_STATE_STOPPING_AWSS)) {
+    if (bws->state == NN_BWS_STATE_STOPPING_AWSS) {
         nn_assert (src == NN_BWS_SRC_AWS && type == NN_AWS_STOPPED);
         aws = (struct nn_aws *) srcptr;
         nn_list_erase (&bws->awss, &aws->item);
@@ -243,7 +232,7 @@
         if (nn_list_empty (&bws->awss)) {
             bws->state = NN_BWS_STATE_IDLE;
             nn_fsm_stopped_noevent (&bws->fsm);
-            nn_epbase_stopped (&bws->epbase);
+            nn_ep_stopped (bws->ep);
             return;
         }
 
@@ -332,7 +321,7 @@
     uint16_t port;
 
     /*  First, resolve the IP address. */
-    addr = nn_epbase_getaddr (&self->epbase);
+    addr = nn_ep_getaddr (self->ep);
     memset (&ss, 0, sizeof (ss));
 
     /*  Parse the port. */
@@ -348,7 +337,7 @@
 
     /*  Parse the address. */
     ipv4onlylen = sizeof (ipv4only);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_IPV4ONLY,
+    nn_ep_getopt (self->ep, NN_SOL_SOCKET, NN_IPV4ONLY,
         &ipv4only, &ipv4onlylen);
     nn_assert (ipv4onlylen == sizeof (ipv4only));
     rc = nn_iface_resolve (addr, pos - addr - 1, ipv4only, &ss, &sslen);
@@ -401,7 +390,7 @@
     /*  Allocate new aws state machine. */
     self->aws = nn_alloc (sizeof (struct nn_aws), "aws");
     alloc_assert (self->aws);
-    nn_aws_init (self->aws, NN_BWS_SRC_AWS, &self->epbase, &self->fsm);
+    nn_aws_init (self->aws, NN_BWS_SRC_AWS, self->ep, &self->fsm);
 
     /*  Start waiting for a new incoming connection. */
     nn_aws_start (self->aws, &self->usock);
diff --git a/src/transports/ws/bws.h b/src/transports/ws/bws.h
index 9203b2e..7e9f3f3 100644
--- a/src/transports/ws/bws.h
+++ b/src/transports/ws/bws.h
@@ -1,6 +1,7 @@
 /*
     Copyright (c) 2013 250bpm s.r.o.  All rights reserved.
     Copyright (c) 2014 Wirebird Labs LLC.  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -28,7 +29,6 @@
 
 /*  State machine managing bound WS socket. */
 
-int nn_bws_create (void *hint, struct nn_epbase **epbase);
+int nn_bws_create (struct nn_ep *ep);
 
 #endif
-
diff --git a/src/transports/ws/cws.c b/src/transports/ws/cws.c
index 627d1ec..546430f 100644
--- a/src/transports/ws/cws.c
+++ b/src/transports/ws/cws.c
@@ -1,7 +1,7 @@
 /*
     Copyright (c) 2012-2013 250bpm s.r.o.  All rights reserved.
     Copyright (c) 2014-2016 Jack R. Dunaway. All rights reserved.
-    Copyright 2015 Garrett D'Amore <garrett@damore.org>
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -75,9 +75,7 @@
     struct nn_fsm fsm;
     int state;
 
-    /*  This object is a specific type of endpoint.
-        Thus it is derived from epbase. */
-    struct nn_epbase epbase;
+    struct nn_ep *ep;
 
     /*  The underlying WS socket. */
     struct nn_usock usock;
@@ -109,10 +107,10 @@
     struct nn_dns_result dns_result;
 };
 
-/*  nn_epbase virtual interface implementation. */
-static void nn_cws_stop (struct nn_epbase *self);
-static void nn_cws_destroy (struct nn_epbase *self);
-const struct nn_epbase_vfptr nn_cws_epbase_vfptr = {
+/*  nn_ep virtual interface implementation. */
+static void nn_cws_stop (struct nn_ep *ep);
+static void nn_cws_destroy (struct nn_ep *ep);
+const struct nn_ep_vfptr nn_cws_ep_vfptr = {
     nn_cws_stop,
     nn_cws_destroy
 };
@@ -126,7 +124,7 @@
 static void nn_cws_start_connecting (struct nn_cws *self,
     struct sockaddr_storage *ss, size_t sslen);
 
-int nn_cws_create (void *hint, struct nn_epbase **epbase)
+int nn_cws_create (struct nn_ep *ep)
 {
     int rc;
     const char *addr;
@@ -151,18 +149,18 @@
     /*  Allocate the new endpoint object. */
     self = nn_alloc (sizeof (struct nn_cws), "cws");
     alloc_assert (self);
+    self->ep = ep;
 
     /*  Initalise the endpoint. */
-    nn_epbase_init (&self->epbase, &nn_cws_epbase_vfptr, hint);
+    nn_ep_tran_setup (ep, &nn_cws_ep_vfptr, self);
 
     /*  Check whether IPv6 is to be used. */
     ipv4onlylen = sizeof (ipv4only);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_IPV4ONLY,
-        &ipv4only, &ipv4onlylen);
+    nn_ep_getopt (ep, NN_SOL_SOCKET, NN_IPV4ONLY, &ipv4only, &ipv4onlylen);
     nn_assert (ipv4onlylen == sizeof (ipv4only));
 
     /*  Start parsing the address. */
-    addr = nn_epbase_getaddr (&self->epbase);
+    addr = nn_ep_getaddr (ep);
     addrlen = strlen (addr);
     semicolon = strchr (addr, ';');
     hostname = semicolon ? semicolon + 1 : addr;
@@ -175,10 +173,9 @@
     hostlen = resource - hostname;
 
     /*  Parse the port; assume port 80 if not explicitly declared. */
-    if (nn_slow (colon != NULL)) {
+    if (colon != NULL) {
         rc = nn_port_resolve (colon + 1, resource - colon - 1);
-        if (nn_slow (rc < 0)) {
-            nn_epbase_term (&self->epbase);
+        if (rc < 0) {
             return -EINVAL;
         }
         self->remote_port = rc;
@@ -192,7 +189,6 @@
     if (nn_dns_check_hostname (hostname, self->remote_hostname_len) < 0 &&
           nn_literal_resolve (hostname, self->remote_hostname_len, ipv4only,
           &ss, &sslen) < 0) {
-        nn_epbase_term (&self->epbase);
         return -EINVAL;
     }
 
@@ -200,7 +196,6 @@
     if (semicolon) {
         rc = nn_iface_resolve (addr, semicolon - addr, ipv4only, &ss, &sslen);
         if (rc < 0) {
-            nn_epbase_term (&self->epbase);
             return -ENODEV;
         }
     }
@@ -235,22 +230,20 @@
 
     /*  Initialise the structure. */
     nn_fsm_init_root (&self->fsm, nn_cws_handler, nn_cws_shutdown,
-        nn_epbase_getctx (&self->epbase));
+        nn_ep_getctx (ep));
     self->state = NN_CWS_STATE_IDLE;
     nn_usock_init (&self->usock, NN_CWS_SRC_USOCK, &self->fsm);
 
     sz = sizeof (msg_type);
-    nn_epbase_getopt (&self->epbase, NN_WS, NN_WS_MSG_TYPE,
-        &msg_type, &sz);
+    nn_ep_getopt (ep, NN_WS, NN_WS_MSG_TYPE, &msg_type, &sz);
     nn_assert (sz == sizeof (msg_type));
     self->msg_type = (uint8_t) msg_type;
 
     sz = sizeof (reconnect_ivl);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_RECONNECT_IVL,
-        &reconnect_ivl, &sz);
+    nn_ep_getopt (ep, NN_SOL_SOCKET, NN_RECONNECT_IVL, &reconnect_ivl, &sz);
     nn_assert (sz == sizeof (reconnect_ivl));
     sz = sizeof (reconnect_ivl_max);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_RECONNECT_IVL_MAX,
+    nn_ep_getopt (ep, NN_SOL_SOCKET, NN_RECONNECT_IVL_MAX,
         &reconnect_ivl_max, &sz);
     nn_assert (sz == sizeof (reconnect_ivl_max));
     if (reconnect_ivl_max == 0)
@@ -258,32 +251,29 @@
     nn_backoff_init (&self->retry, NN_CWS_SRC_RECONNECT_TIMER,
         reconnect_ivl, reconnect_ivl_max, &self->fsm);
 
-    nn_sws_init (&self->sws, NN_CWS_SRC_SWS, &self->epbase, &self->fsm);
+    nn_sws_init (&self->sws, NN_CWS_SRC_SWS, ep, &self->fsm);
     nn_dns_init (&self->dns, NN_CWS_SRC_DNS, &self->fsm);
 
     /*  Start the state machine. */
     nn_fsm_start (&self->fsm);
 
-    /*  Return the base class as an out parameter. */
-    *epbase = &self->epbase;
-
     return 0;
 }
 
-static void nn_cws_stop (struct nn_epbase *self)
+static void nn_cws_stop (struct nn_ep *ep)
 {
     struct nn_cws *cws;
 
-    cws = nn_cont (self, struct nn_cws, epbase);
+    cws = nn_ep_tran_private (ep);
 
     nn_fsm_stop (&cws->fsm);
 }
 
-static void nn_cws_destroy (struct nn_epbase *self)
+static void nn_cws_destroy (struct nn_ep *ep)
 {
     struct nn_cws *cws;
 
-    cws = nn_cont (self, struct nn_cws, epbase);
+    cws = nn_ep_tran_private (ep);
 
     nn_chunkref_term (&cws->resource);
     nn_chunkref_term (&cws->remote_host);
@@ -293,7 +283,6 @@
     nn_backoff_term (&cws->retry);
     nn_usock_term (&cws->usock);
     nn_fsm_term (&cws->fsm);
-    nn_epbase_term (&cws->epbase);
 
     nn_free (cws);
 }
@@ -307,8 +296,7 @@
 
     if (nn_slow (src == NN_FSM_ACTION && type == NN_FSM_STOP)) {
         if (!nn_sws_isidle (&cws->sws)) {
-            nn_epbase_stat_increment (&cws->epbase,
-                NN_STAT_DROPPED_CONNECTIONS, 1);
+            nn_ep_stat_increment (cws->ep, NN_STAT_DROPPED_CONNECTIONS, 1);
             nn_sws_stop (&cws->sws);
         }
         cws->state = NN_CWS_STATE_STOPPING_SWS_FINAL;
@@ -328,7 +316,7 @@
             return;
         cws->state = NN_CWS_STATE_IDLE;
         nn_fsm_stopped_noevent (&cws->fsm);
-        nn_epbase_stopped (&cws->epbase);
+        nn_ep_stopped (cws->ep);
         return;
     }
 
@@ -426,21 +414,19 @@
                     nn_chunkref_data (&cws->remote_host), cws->msg_type);
                 cws->state = NN_CWS_STATE_ACTIVE;
                 cws->peer_gone = 0;
-                nn_epbase_stat_increment (&cws->epbase,
+                nn_ep_stat_increment (cws->ep,
                     NN_STAT_INPROGRESS_CONNECTIONS, -1);
-                nn_epbase_stat_increment (&cws->epbase,
+                nn_ep_stat_increment (cws->ep,
                     NN_STAT_ESTABLISHED_CONNECTIONS, 1);
-                nn_epbase_clear_error (&cws->epbase);
+                nn_ep_clear_error (cws->ep);
                 return;
             case NN_USOCK_ERROR:
-                nn_epbase_set_error (&cws->epbase,
-                    nn_usock_geterrno (&cws->usock));
+                nn_ep_set_error (cws->ep, nn_usock_geterrno (&cws->usock));
                 nn_usock_stop (&cws->usock);
                 cws->state = NN_CWS_STATE_STOPPING_USOCK;
-                nn_epbase_stat_increment (&cws->epbase,
+                nn_ep_stat_increment (cws->ep,
                     NN_STAT_INPROGRESS_CONNECTIONS, -1);
-                nn_epbase_stat_increment (&cws->epbase,
-                    NN_STAT_CONNECT_ERRORS, 1);
+                nn_ep_stat_increment (cws->ep, NN_STAT_CONNECT_ERRORS, 1);
                 return;
             default:
                 nn_fsm_bad_action (cws->state, src, type);
@@ -469,8 +455,7 @@
             case NN_SWS_RETURN_ERROR:
                 nn_sws_stop (&cws->sws);
                 cws->state = NN_CWS_STATE_STOPPING_SWS;
-                nn_epbase_stat_increment (&cws->epbase,
-                    NN_STAT_BROKEN_CONNECTIONS, 1);
+                nn_ep_stat_increment (cws->ep, NN_STAT_BROKEN_CONNECTIONS, 1);
                 return;
             default:
                 nn_fsm_bad_action (cws->state, src, type);
@@ -593,7 +578,7 @@
 
     /*  Check whether IPv6 is to be used. */
     ipv4onlylen = sizeof (ipv4only);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_IPV4ONLY,
+    nn_ep_getopt (self->ep, NN_SOL_SOCKET, NN_IPV4ONLY,
         &ipv4only, &ipv4onlylen);
     nn_assert (ipv4onlylen == sizeof (ipv4only));
 
@@ -615,7 +600,6 @@
     struct sockaddr_storage local;
     size_t locallen;
     int ipv4only;
-    size_t ipv4onlylen;
     int val;
     size_t sz;
 
@@ -623,10 +607,9 @@
     memset (&local, 0, sizeof (local));
 
     /*  Check whether IPv6 is to be used. */
-    ipv4onlylen = sizeof (ipv4only);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_IPV4ONLY,
-        &ipv4only, &ipv4onlylen);
-    nn_assert (ipv4onlylen == sizeof (ipv4only));
+    sz = sizeof (ipv4only);
+    nn_ep_getopt (self->ep, NN_SOL_SOCKET, NN_IPV4ONLY, &ipv4only, &sz);
+    nn_assert (sz == sizeof (ipv4only));
 
     rc = nn_iface_resolve (nn_chunkref_data (&self->nic),
     nn_chunkref_size (&self->nic), ipv4only, &local, &locallen);
@@ -657,12 +640,12 @@
 
     /*  Set the relevant socket options. */
     sz = sizeof (val);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_SNDBUF, &val, &sz);
+    nn_ep_getopt (self->ep, NN_SOL_SOCKET, NN_SNDBUF, &val, &sz);
     nn_assert (sz == sizeof (val));
     nn_usock_setsockopt (&self->usock, SOL_SOCKET, SO_SNDBUF,
         &val, sizeof (val));
     sz = sizeof (val);
-    nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_RCVBUF, &val, &sz);
+    nn_ep_getopt (self->ep, NN_SOL_SOCKET, NN_RCVBUF, &val, &sz);
     nn_assert (sz == sizeof (val));
     nn_usock_setsockopt (&self->usock, SOL_SOCKET, SO_RCVBUF,
         &val, sizeof (val));
@@ -678,6 +661,5 @@
     /*  Start connecting. */
     nn_usock_connect (&self->usock, (struct sockaddr*) &remote, remotelen);
     self->state = NN_CWS_STATE_CONNECTING;
-    nn_epbase_stat_increment (&self->epbase,
-        NN_STAT_INPROGRESS_CONNECTIONS, 1);
+    nn_ep_stat_increment (self->ep, NN_STAT_INPROGRESS_CONNECTIONS, 1);
 }
diff --git a/src/transports/ws/cws.h b/src/transports/ws/cws.h
index 6c25b38..5314018 100644
--- a/src/transports/ws/cws.h
+++ b/src/transports/ws/cws.h
@@ -1,6 +1,7 @@
 /*
     Copyright (c) 2013 250bpm s.r.o.  All rights reserved.
     Copyright (c) 2014 Wirebird Labs LLC.  All rights reserved.
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -28,7 +29,7 @@
 
 /*  State machine managing connected WS socket. */
 
-int nn_cws_create (void *hint, struct nn_epbase **epbase);
+int nn_cws_create (struct nn_ep *);
 
 #endif
 
diff --git a/src/transports/ws/sws.c b/src/transports/ws/sws.c
index 7029131..b2590d4 100644
--- a/src/transports/ws/sws.c
+++ b/src/transports/ws/sws.c
@@ -1,7 +1,7 @@
 /*
     Copyright (c) 2013 250bpm s.r.o.  All rights reserved.
     Copyright (c) 2014-2016 Jack R. Dunaway. All rights reserved.
-    Copyright 2015 Garrett D'Amore <garrett@damore.org>
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -132,18 +132,17 @@
 static void nn_sws_acknowledge_close_handshake (struct nn_sws *self);
 
 void nn_sws_init (struct nn_sws *self, int src,
-    struct nn_epbase *epbase, struct nn_fsm *owner)
+    struct nn_ep *ep, struct nn_fsm *owner)
 {
     nn_fsm_init (&self->fsm, nn_sws_handler, nn_sws_shutdown,
         src, self, owner);
     self->state = NN_SWS_STATE_IDLE;
-    self->epbase = epbase;
     nn_ws_handshake_init (&self->handshaker,
         NN_SWS_SRC_HANDSHAKE, &self->fsm);
     self->usock = NULL;
     self->usock_owner.src = -1;
     self->usock_owner.fsm = NULL;
-    nn_pipebase_init (&self->pipebase, &nn_sws_pipebase_vfptr, epbase);
+    nn_pipebase_init (&self->pipebase, &nn_sws_pipebase_vfptr, ep);
     self->instate = -1;
     nn_list_init (&self->inmsg_array);
     self->outstate = -1;
diff --git a/src/transports/ws/sws.h b/src/transports/ws/sws.h
index 9ab02e6..7f2659d 100644
--- a/src/transports/ws/sws.h
+++ b/src/transports/ws/sws.h
@@ -1,7 +1,7 @@
 /*
     Copyright (c) 2013 250bpm s.r.o.  All rights reserved.
     Copyright (c) 2014 Wirebird Labs LLC.  All rights reserved.
-    Copyright 2015 Garrett D'Amore <garrett@damore.org>
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -83,9 +83,6 @@
     struct nn_fsm fsm;
     int state;
 
-    /*  Endpoint base. */
-    struct nn_epbase *epbase;
-
     /*  Default message type set on outbound frames. */
     uint8_t msg_type;
 
@@ -193,7 +190,7 @@
 void nn_msg_array_term (struct nn_list *msg_array);
 
 void nn_sws_init (struct nn_sws *self, int src,
-    struct nn_epbase *epbase, struct nn_fsm *owner);
+    struct nn_ep *ep, struct nn_fsm *owner);
 void nn_sws_term (struct nn_sws *self);
 
 int nn_sws_isidle (struct nn_sws *self);
diff --git a/src/transports/ws/ws.c b/src/transports/ws/ws.c
index af5bf8b..4e6d805 100644
--- a/src/transports/ws/ws.c
+++ b/src/transports/ws/ws.c
@@ -2,7 +2,7 @@
     Copyright (c) 2012-2013 250bpm s.r.o.  All rights reserved.
     Copyright (c) 2013 GoPivotal, Inc.  All rights reserved.
     Copyright (c) 2014 Wirebird Labs LLC.  All rights reserved.
-    Copyright 2015 Garrett D'Amore <garrett@damore.org>
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"),
@@ -65,8 +65,8 @@
 };
 
 /*  nn_transport interface. */
-static int nn_ws_bind (void *hint, struct nn_epbase **epbase);
-static int nn_ws_connect (void *hint, struct nn_epbase **epbase);
+static int nn_ws_bind (struct nn_ep *);
+static int nn_ws_connect (struct nn_ep *);
 static struct nn_optset *nn_ws_optset (void);
 
 static struct nn_transport nn_ws_vfptr = {
@@ -82,14 +82,14 @@
 
 struct nn_transport *nn_ws = &nn_ws_vfptr;
 
-static int nn_ws_bind (void *hint, struct nn_epbase **epbase)
+static int nn_ws_bind (struct nn_ep *ep)
 {
-    return nn_bws_create (hint, epbase);
+    return nn_bws_create (ep);
 }
 
-static int nn_ws_connect (void *hint, struct nn_epbase **epbase)
+static int nn_ws_connect (struct nn_ep *ep)
 {
-    return nn_cws_create (hint, epbase); 
+    return nn_cws_create (ep);
 }
 
 static struct nn_optset *nn_ws_optset ()
diff --git a/src/transports/ws/ws_handshake.c b/src/transports/ws/ws_handshake.c
index 26b7367..ddf5f25 100644
--- a/src/transports/ws/ws_handshake.c
+++ b/src/transports/ws/ws_handshake.c
@@ -916,7 +916,6 @@
     {
         const char *conn = NULL;
         size_t conn_len = 0;
-fprintf(stderr, "POS is %s\n", pos);
         if (nn_ws_match_token ("Host:", &pos, 1, 0)) {
             rc = nn_ws_match_value (CRLF, &pos, 1, 1,
                 &self->host, &self->host_len);