Simplify how dialing and listening works

Also add support for bare TCP

listen.go

@@ -20,6 +20,9 @@ type Listener interface {
 // - "quic"
 // - "quic4" (IPv4-only)
 // - "quic6" (IPv6-only)
+// - "tls"
+// - "tls4" (IPv4-only)
+// - "tls6" (IPv6-only)
 // - "tcp"
 // - "tcp4" (IPv4-only)
 // - "tcp6" (IPv6-only)
@@ -29,9 +32,17 @@ type Listener interface {
 func Listen(network, address string, tlsConf *tls.Config) (Listener, error) {
 	switch network {
 	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
+	case "tls", "tls4", "tls6":    return ListenTLS(network, address, tlsConf)
+	case "tcp", "tcp4", "tcp6":
+		addr, err := net.ResolveTCPAddr(network, address)
+		if err != nil { return nil, err }
+		return ListenTCP(network, addr)
+	case "unix":
+		addr, err := net.ResolveUnixAddr(network, address)
+		if err != nil { return nil, err }
+		return ListenUnix(network, addr)
+	default:
+		return nil, ErrUnknownNetwork
 	}
 }
 
@@ -46,7 +57,6 @@ func ListenQUIC(network, address string, tlsConf *tls.Config) (Listener, error)
 // 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 {
@@ -54,12 +64,19 @@ func ListenTLS(network, address string, tlsConf *tls.Config) (Listener, error) {
 	}, nil
 }
 
+// ListenTCP listens for incoming HOPP connections using a TCP socket as a
+// transport. The network must be "tcp".
+func ListenTCP(network string, laddr *net.TCPAddr) (Listener, error) {
+	listener, err := net.ListenTCP(network, laddr)
+	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 }
+func ListenUnix(network string, addr *net.UnixAddr) (Listener, error) {
 	listener, err := net.ListenUnix(network, addr)
 	if err != nil { return nil, err }
 	return &netListenerWrapper {