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
}
// 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)

46
listen.go
View File

@ -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()
}