sashakoshka/hopp
1
0
Fork 0
Code Issues 8 Pull Requests Actions Packages Projects Releases Wiki Activity

Simplify how dialing and listening works

Browse Source 
Also add support for bare TCP
This commit is contained in:
Sasha Koshka
2025-10-20 16:44:07 -04:00
parent da01a0d119
commit 09b2259a8c
3 changed files with 61 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
dial.go
View File

@@ -5,53 +5,57 @@ import "errors"
import "context"
import "crypto/tls"
// Dial opens a connection to a server. The network must be one of "quic",
// "quic4", (IPv4-only) "quic6" (IPv6-only), or "unix". For now, "quic4" and
// "quic6" don't do anything as the quic-go package doesn't seem to support this
// behavior.
func Dial(ctx context.Context, network, address string) (Conn, error) {
return (Dialer { }).Dial(ctx, network, address)
}
// Dialer allows for further configuration of the dialing process.
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)
// - "tls"
// - "tls4" (IPv4-only)
// - "tls6" (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) {
func Dial(ctx context.Context, network, address string, tlsConf *tls.Config) (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)
case "quic", "quic4", "quic6": return DialQUIC(ctx, network, address, tlsConf)
case "tls", "tls4", "tls6": return DialTLS(ctx, network, address, tlsConf)
case "tcp", "tcp4", "tcp6":
addr, err := net.ResolveTCPAddr(network, address)
if err != nil { return nil, err }
return DialTCP(ctx, network, nil, addr)
case "unix":
addr, err := net.ResolveUnixAddr(network, address)
if err != nil { return nil, err }
return DialUnix(ctx, network, addr)
default: return nil, ErrUnknownNetwork
}
}
func (diale Dialer) dialQUIC(ctx context.Context, network, address string) (Conn, error) {
// DialQUIC opens a connection to a server over QUIC.
func DialQUIC(ctx context.Context, network, address string, tlsConf *tls.Config) (Conn, error) {
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, address, diale.TLSConfig)
// DialTLS opens a connection to a server over TLS.
func DialTLS(ctx context.Context, network, address string, tlsConf *tls.Config) (Conn, error) {
conn, err := tls.Dial(network, address, tlsConf)
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)
// DialTCP opens a connection to a server over TCP.
func DialTCP(ctx context.Context, network string, laddr, raddr *net.TCPAddr) (Conn, error) {
conn, err := net.DialTCP(network, laddr, raddr)
if err != nil { return nil, err }
return AdaptA(conn, ClientSide), nil
}
// DialUnix opens a connection to a server over a Unix domain socket.
func DialUnix(ctx context.Context, network string, addr *net.UnixAddr) (Conn, error) {
conn, err := net.DialUnix(network, nil, addr)
if err != nil { return nil, err }
return AdaptA(conn, ClientSide), nil