Xray-core/transport/internet/system_dialer.go

295 lines
8 KiB
Go
Raw Normal View History

2020-11-25 11:01:53 +00:00
package internet
import (
"context"
"syscall"
"time"
2021-03-06 16:29:17 +00:00
"github.com/xtls/xray-core/common"
"github.com/xtls/xray-core/common/dice"
2020-12-04 01:36:16 +00:00
"github.com/xtls/xray-core/common/net"
2021-03-06 16:29:17 +00:00
"github.com/xtls/xray-core/common/net/cnc"
2020-12-04 01:36:16 +00:00
"github.com/xtls/xray-core/common/session"
2021-03-06 16:29:17 +00:00
"github.com/xtls/xray-core/features/dns"
"github.com/xtls/xray-core/features/outbound"
"github.com/xtls/xray-core/transport"
"github.com/xtls/xray-core/transport/pipe"
2020-11-25 11:01:53 +00:00
)
var (
effectiveSystemDialer SystemDialer = &DefaultSystemDialer{}
)
2021-03-06 16:29:17 +00:00
// InitSystemDialer: It's private method and you are NOT supposed to use this function.
func InitSystemDialer(dc dns.Client, om outbound.Manager) {
effectiveSystemDialer.Init(dc, om)
2021-03-06 16:29:17 +00:00
}
2020-11-25 11:01:53 +00:00
type SystemDialer interface {
Dial(ctx context.Context, source net.Address, destination net.Destination, sockopt *SocketConfig) (net.Conn, error)
Init(dc dns.Client, om outbound.Manager)
2020-11-25 11:01:53 +00:00
}
type DefaultSystemDialer struct {
controllers []controller
2021-03-06 16:29:17 +00:00
dns dns.Client
obm outbound.Manager
2020-11-25 11:01:53 +00:00
}
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
}
2021-03-06 16:29:17 +00:00
func (d *DefaultSystemDialer) lookupIP(domain string, strategy DomainStrategy, localAddr net.Address) ([]net.IP, error) {
if d.dns == nil {
return nil, nil
}
var option = dns.IPOption{
IPv4Enable: true,
IPv6Enable: true,
FakeEnable: false,
}
2021-03-06 16:29:17 +00:00
switch {
case strategy == DomainStrategy_USE_IP4 || (localAddr != nil && localAddr.Family().IsIPv4()):
option = dns.IPOption{
IPv4Enable: true,
IPv6Enable: false,
FakeEnable: false,
2021-03-06 16:29:17 +00:00
}
case strategy == DomainStrategy_USE_IP6 || (localAddr != nil && localAddr.Family().IsIPv6()):
option = dns.IPOption{
IPv4Enable: false,
IPv6Enable: true,
FakeEnable: false,
2021-03-06 16:29:17 +00:00
}
case strategy == DomainStrategy_AS_IS:
return nil, nil
}
return d.dns.LookupIP(domain, option)
2021-03-06 16:29:17 +00:00
}
func (d *DefaultSystemDialer) canLookupIP(ctx context.Context, dst net.Destination, sockopt *SocketConfig) bool {
if sockopt == nil || dst.Address.Family().IsIP() || d.dns == nil {
return false
}
if dst.Address.Domain() == LookupDomainFromContext(ctx) {
newError("infinite loop detected").AtError().WriteToLog(session.ExportIDToError(ctx))
return false
}
return sockopt.DomainStrategy != DomainStrategy_AS_IS
}
func (d *DefaultSystemDialer) redirect(ctx context.Context, dst net.Destination, obt string) net.Conn {
newError("redirecting request " + dst.String() + " to " + obt).WriteToLog(session.ExportIDToError(ctx))
h := d.obm.GetHandler(obt)
ctx = session.ContextWithOutbound(ctx, &session.Outbound{dst, nil})
if h != nil {
ur, uw := pipe.New(pipe.OptionsFromContext(ctx)...)
dr, dw := pipe.New(pipe.OptionsFromContext(ctx)...)
go h.Dispatch(ctx, &transport.Link{ur, dw})
nc := cnc.NewConnection(
cnc.ConnectionInputMulti(uw),
cnc.ConnectionOutputMulti(dr),
cnc.ConnectionOnClose(common.ChainedClosable{uw, dw}),
)
return nc
}
return nil
}
2020-11-25 11:01:53 +00:00
func (d *DefaultSystemDialer) Dial(ctx context.Context, src net.Address, dest net.Destination, sockopt *SocketConfig) (net.Conn, error) {
2021-03-06 16:29:17 +00:00
newError("dialing to " + dest.String()).AtDebug().WriteToLog()
if d.obm != nil && sockopt != nil && len(sockopt.DialerProxy) > 0 {
nc := d.redirect(ctx, dest, sockopt.DialerProxy)
if nc != nil {
return nc, nil
}
}
if d.canLookupIP(ctx, dest, sockopt) {
ips, err := d.lookupIP(dest.Address.String(), sockopt.DomainStrategy, src)
if err == nil && len(ips) > 0 {
dest.Address = net.IPAddress(ips[dice.Roll(len(ips))])
newError("replace destination with " + dest.String()).AtInfo().WriteToLog()
} else if err != nil {
newError("failed to resolve ip").Base(err).AtWarning().WriteToLog()
}
}
2020-11-25 11:01:53 +00:00
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{
2020-11-25 11:01:53 +00:00
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())
}
func (d *DefaultSystemDialer) Init(dc dns.Client, om outbound.Manager) {
2021-03-06 16:29:17 +00:00
d.dns = dc
d.obm = om
}
type PacketConnWrapper struct {
2020-11-25 11:01:53 +00:00
conn net.PacketConn
dest net.Addr
}
func (c *PacketConnWrapper) Close() error {
2020-11-25 11:01:53 +00:00
return c.conn.Close()
}
func (c *PacketConnWrapper) LocalAddr() net.Addr {
2020-11-25 11:01:53 +00:00
return c.conn.LocalAddr()
}
func (c *PacketConnWrapper) RemoteAddr() net.Addr {
2020-11-25 11:01:53 +00:00
return c.dest
}
func (c *PacketConnWrapper) Write(p []byte) (int, error) {
2020-11-25 11:01:53 +00:00
return c.conn.WriteTo(p, c.dest)
}
func (c *PacketConnWrapper) Read(p []byte) (int, error) {
2020-11-25 11:01:53 +00:00
n, _, err := c.conn.ReadFrom(p)
return n, err
}
func (c *PacketConnWrapper) WriteTo(p []byte, d net.Addr) (int, error) {
return c.conn.WriteTo(p, d)
}
func (c *PacketConnWrapper) ReadFrom(p []byte) (int, net.Addr, error) {
return c.conn.ReadFrom(p)
}
func (c *PacketConnWrapper) SetDeadline(t time.Time) error {
2020-11-25 11:01:53 +00:00
return c.conn.SetDeadline(t)
}
func (c *PacketConnWrapper) SetReadDeadline(t time.Time) error {
2020-11-25 11:01:53 +00:00
return c.conn.SetReadDeadline(t)
}
func (c *PacketConnWrapper) SetWriteDeadline(t time.Time) error {
2020-11-25 11:01:53 +00:00
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) Init(_ dns.Client, _ outbound.Manager) {}
2021-03-06 16:29:17 +00:00
2020-11-25 11:01:53 +00:00
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
}