v1.0.0

transport/internet/system_dialer.go

@@ -0,0 +1,185 @@
+package internet
+
+import (
+	"context"
+	"syscall"
+	"time"
+
+	"github.com/xtls/xray-core/v1/common/net"
+	"github.com/xtls/xray-core/v1/common/session"
+)
+
+var (
+	effectiveSystemDialer SystemDialer = &DefaultSystemDialer{}
+)
+
+type SystemDialer interface {
+	Dial(ctx context.Context, source net.Address, destination net.Destination, sockopt *SocketConfig) (net.Conn, error)
+}
+
+type DefaultSystemDialer struct {
+	controllers []controller
+}
+
+func resolveSrcAddr(network net.Network, src net.Address) net.Addr {
+	if src == nil || src == net.AnyIP {
+		return nil
+	}
+
+	if network == net.Network_TCP {
+		return &net.TCPAddr{
+			IP:   src.IP(),
+			Port: 0,
+		}
+	}
+
+	return &net.UDPAddr{
+		IP:   src.IP(),
+		Port: 0,
+	}
+}
+
+func hasBindAddr(sockopt *SocketConfig) bool {
+	return sockopt != nil && len(sockopt.BindAddress) > 0 && sockopt.BindPort > 0
+}
+
+func (d *DefaultSystemDialer) Dial(ctx context.Context, src net.Address, dest net.Destination, sockopt *SocketConfig) (net.Conn, error) {
+	if dest.Network == net.Network_UDP && !hasBindAddr(sockopt) {
+		srcAddr := resolveSrcAddr(net.Network_UDP, src)
+		if srcAddr == nil {
+			srcAddr = &net.UDPAddr{
+				IP:   []byte{0, 0, 0, 0},
+				Port: 0,
+			}
+		}
+		packetConn, err := ListenSystemPacket(ctx, srcAddr, sockopt)
+		if err != nil {
+			return nil, err
+		}
+		destAddr, err := net.ResolveUDPAddr("udp", dest.NetAddr())
+		if err != nil {
+			return nil, err
+		}
+		return &packetConnWrapper{
+			conn: packetConn,
+			dest: destAddr,
+		}, nil
+	}
+
+	dialer := &net.Dialer{
+		Timeout:   time.Second * 16,
+		DualStack: true,
+		LocalAddr: resolveSrcAddr(dest.Network, src),
+	}
+
+	if sockopt != nil || len(d.controllers) > 0 {
+		dialer.Control = func(network, address string, c syscall.RawConn) error {
+			return c.Control(func(fd uintptr) {
+				if sockopt != nil {
+					if err := applyOutboundSocketOptions(network, address, fd, sockopt); err != nil {
+						newError("failed to apply socket options").Base(err).WriteToLog(session.ExportIDToError(ctx))
+					}
+					if dest.Network == net.Network_UDP && hasBindAddr(sockopt) {
+						if err := bindAddr(fd, sockopt.BindAddress, sockopt.BindPort); err != nil {
+							newError("failed to bind source address to ", sockopt.BindAddress).Base(err).WriteToLog(session.ExportIDToError(ctx))
+						}
+					}
+				}
+
+				for _, ctl := range d.controllers {
+					if err := ctl(network, address, fd); err != nil {
+						newError("failed to apply external controller").Base(err).WriteToLog(session.ExportIDToError(ctx))
+					}
+				}
+			})
+		}
+	}
+
+	return dialer.DialContext(ctx, dest.Network.SystemString(), dest.NetAddr())
+}
+
+type packetConnWrapper struct {
+	conn net.PacketConn
+	dest net.Addr
+}
+
+func (c *packetConnWrapper) Close() error {
+	return c.conn.Close()
+}
+
+func (c *packetConnWrapper) LocalAddr() net.Addr {
+	return c.conn.LocalAddr()
+}
+
+func (c *packetConnWrapper) RemoteAddr() net.Addr {
+	return c.dest
+}
+
+func (c *packetConnWrapper) Write(p []byte) (int, error) {
+	return c.conn.WriteTo(p, c.dest)
+}
+
+func (c *packetConnWrapper) Read(p []byte) (int, error) {
+	n, _, err := c.conn.ReadFrom(p)
+	return n, err
+}
+
+func (c *packetConnWrapper) SetDeadline(t time.Time) error {
+	return c.conn.SetDeadline(t)
+}
+
+func (c *packetConnWrapper) SetReadDeadline(t time.Time) error {
+	return c.conn.SetReadDeadline(t)
+}
+
+func (c *packetConnWrapper) SetWriteDeadline(t time.Time) error {
+	return c.conn.SetWriteDeadline(t)
+}
+
+type SystemDialerAdapter interface {
+	Dial(network string, address string) (net.Conn, error)
+}
+
+type SimpleSystemDialer struct {
+	adapter SystemDialerAdapter
+}
+
+func WithAdapter(dialer SystemDialerAdapter) SystemDialer {
+	return &SimpleSystemDialer{
+		adapter: dialer,
+	}
+}
+
+func (v *SimpleSystemDialer) Dial(ctx context.Context, src net.Address, dest net.Destination, sockopt *SocketConfig) (net.Conn, error) {
+	return v.adapter.Dial(dest.Network.SystemString(), dest.NetAddr())
+}
+
+// UseAlternativeSystemDialer replaces the current system dialer with a given one.
+// Caller must ensure there is no race condition.
+//
+// xray:api:stable
+func UseAlternativeSystemDialer(dialer SystemDialer) {
+	if dialer == nil {
+		effectiveSystemDialer = &DefaultSystemDialer{}
+	}
+	effectiveSystemDialer = dialer
+}
+
+// RegisterDialerController adds a controller to the effective system dialer.
+// The controller can be used to operate on file descriptors before they are put into use.
+// It only works when effective dialer is the default dialer.
+//
+// xray:api:beta
+func RegisterDialerController(ctl func(network, address string, fd uintptr) error) error {
+	if ctl == nil {
+		return newError("nil listener controller")
+	}
+
+	dialer, ok := effectiveSystemDialer.(*DefaultSystemDialer)
+	if !ok {
+		return newError("RegisterListenerController not supported in custom dialer")
+	}
+
+	dialer.controllers = append(dialer.controllers, ctl)
+	return nil
+}