diff --git a/dial.go b/dial.go
index 9b9d3d8..15b6aeb 100644
--- a/dial.go
+++ b/dial.go
@@ -18,12 +18,21 @@ type Dialer struct {
 	TLSConfig *tls.Config
 }
 
-// Dial opens a connection to a server. The network must be one of "quic",
-// "quic4", (IPv4-only) "quic6" (IPv6-only), or "unix". For now, quic is not
-// supported.
+// Dial opens a connection to a server. The network must be one of:
+// 
+// - "quic"
+// - "quic4" (IPv4-only)
+// - "quic6" (IPv6-only)
+// - "tcp"
+// - "tcp4" (IPv4-only)
+// - "tcp6" (IPv6-only)
+// - "unix"
+//
+// For now, QUIC is unsupported.
 func (diale Dialer) Dial(ctx context.Context, network, address string) (Conn, error) {
 	switch network {
 	case "quic", "quic4", "quic6": return diale.dialQUIC(ctx, network, address)
+	case "tcp", "tcp4", "tcp6":    return diale.dialTLS(ctx, network, address)
 	case "unix":                   return diale.dialUnix(ctx, network, address)
 	default:                       return nil, ErrUnknownNetwork
 	}
@@ -33,6 +42,12 @@ func (diale Dialer) dialQUIC(ctx context.Context, network, address string) (Conn
 	return nil, errors.New("quic is not yet implemented")
 }
 
+func (diale Dialer) dialTLS(ctx context.Context, network, address string) (Conn, error) {
+	conn, err := tls.Dial(network, nil, addr, diale.TLSConfig)
+	if err != nil { return nil, err }
+	return AdaptA(conn, ClientSide), nil
+}
+
 func (diale Dialer) dialUnix(ctx context.Context, network, address string) (Conn, error) {
 	if network != "unix" { return nil, ErrUnknownNetwork }
 	addr, err := net.ResolveUnixAddr(network, address)
diff --git a/listen.go b/listen.go
index 4c0681c..51d355f 100644
--- a/listen.go
+++ b/listen.go
@@ -15,12 +15,21 @@ type Listener interface {
 	Addr() net.Addr
 }
 
-// Listen listens for incoming HOPP connections. The network must be one of
-// "quic", "quic4", (IPv4-only) "quic6" (IPv6-only), or "unix". For now, quic is
-// not supported.
-func Listen(network, address string) (Listener, error) {
+// Listen listens for incoming HOPP connections. The network must be one of:
+// 
+// - "quic"
+// - "quic4" (IPv4-only)
+// - "quic6" (IPv6-only)
+// - "tcp"
+// - "tcp4" (IPv4-only)
+// - "tcp6" (IPv6-only)
+// - "unix"
+//
+// For now, QUIC is unsupported.
+func Listen(network, address string, tlsConf *tls.Config) (Listener, error) {
 	switch network {
-	case "quic", "quic4", "quic6": return ListenQUIC(network, address, nil)
+	case "quic", "quic4", "quic6": return ListenQUIC(network, address, tlsConf)
+	case "tcp", "tcp4", "tcp6":    return ListenTLS(network, address, tlsConf)
 	case "unix":                   return ListenUnix(network, address)
 	default:                       return nil, ErrUnknownNetwork
 	}
@@ -34,33 +43,44 @@ func ListenQUIC(network, address string, tlsConf *tls.Config) (Listener, error)
 	return nil, errors.New("quic is not yet implemented")
 }
 
+// ListenTLS listens for incoming HOPP connections using a TLS socket as a
+// transport. The network must be "tcp".
+func ListenTLS(network, address string, tlsConf *tls.Config) (Listener, error) {
+	if network != "tcp" { return nil, ErrUnknownNetwork }
+	listener, err := tls.Listen(network, address, tlsConf)
+	if err != nil { return nil, err }
+	return &netListenerWrapper {
+		underlying: listener,
+	}, nil
+}
+
 // ListenUnix listens for incoming HOPP connections using a Unix domain socket
 // as a transport. The network must be "unix".
 func ListenUnix(network, address string) (Listener, error) {
 	if network != "unix" { return nil, ErrUnknownNetwork }
 	addr, err := net.ResolveUnixAddr(network, address)
 	if err != nil { return nil, err }
-	unixListener, err := net.ListenUnix(network, addr)
+	listener, err := net.ListenUnix(network, addr)
 	if err != nil { return nil, err }
-	return &listenerUnix {
-		underlying: unixListener,
+	return &netListenerWrapper {
+		underlying: listener,
 	}, nil
 }
 
-type listenerUnix struct {
-	underlying *net.UnixListener
+type netListenerWrapper struct {
+	underlying net.Listener
 }
 
-func (this *listenerUnix) Accept() (Conn, error) {
+func (this *netListenerWrapper) Accept() (Conn, error) {
 	conn, err := this.underlying.Accept()
 	if err != nil { return nil, err }
 	return AdaptA(conn, ServerSide), nil
 }
 
-func (this *listenerUnix) Close() error {
+func (this *netListenerWrapper) Close() error {
 	return this.underlying.Close()
 }
 
-func (this *listenerUnix) Addr() net.Addr {
+func (this *netListenerWrapper) Addr() net.Addr {
 	return this.underlying.Addr()
 }