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

Add support for TLS/TCP

Browse Source
This commit is contained in:
Sasha Koshka 2025-10-17 21:46:17 -04:00
parent 476833709e
commit b3dc633abe
2 changed files with 51 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
dial.go
View File

@ -18,12 +18,21 @@ type Dialer struct {
TLSConfig *tls.Config TLSConfig *tls.Config
} }
// Dial opens a connection to a server. The network must be one of "quic", // Dial opens a connection to a server. The network must be one of:
// "quic4", (IPv4-only) "quic6" (IPv6-only), or "unix". For now, quic is not //
// supported. // - "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) { func (diale Dialer) Dial(ctx context.Context, network, address string) (Conn, error) {
switch network { switch network {
case "quic", "quic4", "quic6": return diale.dialQUIC(ctx, network, address) 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 "unix": return diale.dialUnix(ctx, network, address)
default: return nil, ErrUnknownNetwork 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") 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) { func (diale Dialer) dialUnix(ctx context.Context, network, address string) (Conn, error) {
if network != "unix" { return nil, ErrUnknownNetwork } if network != "unix" { return nil, ErrUnknownNetwork }
addr, err := net.ResolveUnixAddr(network, address) addr, err := net.ResolveUnixAddr(network, address)

46
listen.go
View File

@ -15,12 +15,21 @@ type Listener interface {
Addr() net.Addr Addr() net.Addr
} }
// Listen listens for incoming HOPP connections. The network must be one of // 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. // - "quic"
func Listen(network, address string) (Listener, error) { // - "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 { 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) case "unix": return ListenUnix(network, address)
default: return nil, ErrUnknownNetwork 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") 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 // ListenUnix listens for incoming HOPP connections using a Unix domain socket
// as a transport. The network must be "unix". // as a transport. The network must be "unix".
func ListenUnix(network, address string) (Listener, error) { func ListenUnix(network, address string) (Listener, error) {
if network != "unix" { return nil, ErrUnknownNetwork } if network != "unix" { return nil, ErrUnknownNetwork }
addr, err := net.ResolveUnixAddr(network, address) addr, err := net.ResolveUnixAddr(network, address)
if err != nil { return nil, err } if err != nil { return nil, err }
unixListener, err := net.ListenUnix(network, addr) listener, err := net.ListenUnix(network, addr)
if err != nil { return nil, err } if err != nil { return nil, err }
return &listenerUnix { return &netListenerWrapper {
underlying: unixListener, underlying: listener,
}, nil }, nil
} }
type listenerUnix struct { type netListenerWrapper struct {
underlying *net.UnixListener underlying net.Listener
} }
func (this *listenerUnix) Accept() (Conn, error) { func (this *netListenerWrapper) Accept() (Conn, error) {
conn, err := this.underlying.Accept() conn, err := this.underlying.Accept()
if err != nil { return nil, err } if err != nil { return nil, err }
return AdaptA(conn, ServerSide), nil return AdaptA(conn, ServerSide), nil
} }
func (this *listenerUnix) Close() error { func (this *netListenerWrapper) Close() error {
return this.underlying.Close() return this.underlying.Close()
} }
func (this *listenerUnix) Addr() net.Addr { func (this *netListenerWrapper) Addr() net.Addr {
return this.underlying.Addr() return this.underlying.Addr()
} }