feat(wip): PluggableOutbound framework

extras/outbounds/interface.go

@@ -0,0 +1,116 @@
+package outbounds
+
+import (
+	"net"
+	"strconv"
+
+	"github.com/apernet/hysteria/core/server"
+)
+
+// The PluggableOutbound system is designed to function in a chain-like manner.
+// Not every outbound is an actual outbound; some are just wrappers around other
+// outbounds, such as custom resolvers, ACL engine, etc. It is a pipeline where
+// each stage can check (and optionally modify) the request before passing it
+// on to the next stage. The last stage in the pipeline is always a real outbound
+// that actually implements the logic of connecting to the remote server.
+// There can also be instances of branching, where requests can be sent to
+// different outbound sub-pipelines based on some criteria.
+
+// PluggableOutbound differs from the built-in Outbound interface from Hysteria core
+// in that it uses an AddrEx struct for addresses instead of a string. Because of this
+// difference, we need a special PluggableOutboundAdapter to convert between the two
+// for use in Hysteria core config.
+type PluggableOutbound interface {
+	DialTCP(reqAddr *AddrEx) (net.Conn, error)
+	ListenUDP() (UDPConn, error)
+}
+
+type UDPConn interface {
+	ReadFrom(b []byte) (int, *AddrEx, error)
+	WriteTo(b []byte, addr *AddrEx) (int, error)
+	Close() error
+}
+
+// AddrEx keeps both the original string representation of the address and
+// the resolved IP addresses from the resolver, if any.
+// The actual outbound implementations can choose to use either the string
+// representation or the resolved IP addresses, depending on their capabilities.
+// A SOCKS5 outbound, for example, should prefer the string representation
+// because SOCKS5 protocol supports sending the hostname to the proxy server
+// and let the proxy server do the DNS resolution.
+type AddrEx struct {
+	Host        string // String representation of the host, can be an IP or a domain name
+	Port        uint16
+	ResolveInfo *ResolveInfo // Only set if there's a resolver in the pipeline
+}
+
+func (a *AddrEx) String() string {
+	return net.JoinHostPort(a.Host, strconv.Itoa(int(a.Port)))
+}
+
+type ResolveInfo struct {
+	IPv4 net.IP
+	IPv6 net.IP
+	Err  error
+}
+
+var _ server.Outbound = (*PluggableOutboundAdapter)(nil)
+
+type PluggableOutboundAdapter struct {
+	PluggableOutbound
+}
+
+func (a *PluggableOutboundAdapter) DialTCP(reqAddr string) (net.Conn, error) {
+	host, port, err := net.SplitHostPort(reqAddr)
+	if err != nil {
+		return nil, err
+	}
+	portInt, err := strconv.Atoi(port)
+	if err != nil {
+		return nil, err
+	}
+	return a.PluggableOutbound.DialTCP(&AddrEx{
+		Host: host,
+		Port: uint16(portInt),
+	})
+}
+
+func (a *PluggableOutboundAdapter) ListenUDP() (server.UDPConn, error) {
+	conn, err := a.PluggableOutbound.ListenUDP()
+	if err != nil {
+		return nil, err
+	}
+	return &udpConnAdapter{conn}, nil
+}
+
+type udpConnAdapter struct {
+	UDPConn
+}
+
+func (u *udpConnAdapter) ReadFrom(b []byte) (int, string, error) {
+	n, addr, err := u.UDPConn.ReadFrom(b)
+	if addr != nil {
+		return n, addr.String(), err
+	} else {
+		return n, "", err
+	}
+}
+
+func (u *udpConnAdapter) WriteTo(b []byte, addr string) (int, error) {
+	host, port, err := net.SplitHostPort(addr)
+	if err != nil {
+		return 0, err
+	}
+	portInt, err := strconv.Atoi(port)
+	if err != nil {
+		return 0, err
+	}
+	return u.UDPConn.WriteTo(b, &AddrEx{
+		Host: host,
+		Port: uint16(portInt),
+	})
+}
+
+func (u *udpConnAdapter) Close() error {
+	return u.UDPConn.Close()
+}

extras/outbounds/interface_test.go

@@ -0,0 +1,103 @@
+package outbounds
+
+import (
+	"errors"
+	"net"
+	"reflect"
+	"testing"
+)
+
+var errWrongAddr = errors.New("wrong addr")
+
+type mockPluggableOutbound struct{}
+
+func (m *mockPluggableOutbound) DialTCP(reqAddr *AddrEx) (net.Conn, error) {
+	if !reflect.DeepEqual(reqAddr, &AddrEx{
+		Host:        "correct_host_1",
+		Port:        34567,
+		ResolveInfo: nil,
+	}) {
+		return nil, errWrongAddr
+	}
+	return nil, nil
+}
+
+func (m *mockPluggableOutbound) ListenUDP() (UDPConn, error) {
+	return &mockUDPConn{}, nil
+}
+
+type mockUDPConn struct{}
+
+func (u *mockUDPConn) ReadFrom(b []byte) (int, *AddrEx, error) {
+	for i := range b {
+		b[i] = 1
+	}
+	return len(b), &AddrEx{
+		Host:        "correct_host_2",
+		Port:        54321,
+		ResolveInfo: nil,
+	}, nil
+}
+
+func (u *mockUDPConn) WriteTo(b []byte, addr *AddrEx) (int, error) {
+	if !reflect.DeepEqual(addr, &AddrEx{
+		Host:        "correct_host_3",
+		Port:        22334,
+		ResolveInfo: nil,
+	}) {
+		return 0, errWrongAddr
+	}
+	return len(b), nil
+}
+
+func (u *mockUDPConn) Close() error {
+	return nil
+}
+
+func TestPluggableOutboundAdapter(t *testing.T) {
+	adapter := &PluggableOutboundAdapter{
+		PluggableOutbound: &mockPluggableOutbound{},
+	}
+	// DialTCP with correct addr
+	_, err := adapter.DialTCP("correct_host_1:34567")
+	if err != nil {
+		t.Fatal("DialTCP with correct addr failed", err)
+	}
+	// DialTCP with wrong addr
+	_, err = adapter.DialTCP("wrong_host_1:34567")
+	if err != errWrongAddr {
+		t.Fatal("DialTCP with wrong addr should fail, got", err)
+	}
+	// ListenUDP
+	uConn, err := adapter.ListenUDP()
+	if err != nil {
+		t.Fatal("ListenUDP failed", err)
+	}
+	// ReadFrom
+	b := make([]byte, 10)
+	n, addr, err := uConn.ReadFrom(b)
+	if err != nil {
+		t.Fatal("ReadFrom failed", err)
+	}
+	if n != 10 || addr != "correct_host_2:54321" {
+		t.Fatalf("ReadFrom got wrong result, n: %d, addr: %s", n, addr)
+	}
+	// WriteTo with correct addr
+	n, err = uConn.WriteTo(b, "correct_host_3:22334")
+	if err != nil {
+		t.Fatal("WriteTo with correct addr failed", err)
+	}
+	if n != 10 {
+		t.Fatalf("WriteTo with correct addr got wrong result, n: %d", n)
+	}
+	// WriteTo with wrong addr
+	n, err = uConn.WriteTo(b, "wrong_host_3:22334")
+	if err != errWrongAddr {
+		t.Fatal("WriteTo with wrong addr should fail, got", err)
+	}
+	// Close
+	err = uConn.Close()
+	if err != nil {
+		t.Fatal("Close failed", err)
+	}
+}