yanistyle/sing-box-extended
1
0
Fork 0
mirror of https://github.com/shtorm-7/sing-box-extended.git synced 2026-05-30 16:04:23 +03:00
Code Issues Packages Projects Releases Wiki Activity

Add resolver for outbound dialer

Browse Source
This commit is contained in:
世界
2022-07-07 21:47:21 +08:00
parent ecac383477
commit 538a1f5909
32 changed files with 1058 additions and 222 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
outbound/dialer/default.go
View File

@@ -1,53 +0,0 @@
package dialer
import (
"context"
"net"
"time"
"github.com/sagernet/sing/common/control"
M "github.com/sagernet/sing/common/metadata"
N "github.com/sagernet/sing/common/network"
C "github.com/sagernet/sing-box/constant"
"github.com/sagernet/sing-box/option"
"github.com/database64128/tfo-go"
)
type defaultDialer struct {
tfo.Dialer
net.ListenConfig
}
func NewDefault(options option.DialerOptions) N.Dialer {
var dialer net.Dialer
var listener net.ListenConfig
if options.BindInterface != "" {
dialer.Control = control.Append(dialer.Control, control.BindToInterface(options.BindInterface))
listener.Control = control.Append(listener.Control, control.BindToInterface(options.BindInterface))
}
if options.RoutingMark != 0 {
dialer.Control = control.Append(dialer.Control, control.RoutingMark(options.RoutingMark))
listener.Control = control.Append(listener.Control, control.RoutingMark(options.RoutingMark))
}
if options.ReuseAddr {
listener.Control = control.Append(listener.Control, control.ReuseAddr())
}
if options.ProtectPath != "" {
dialer.Control = control.Append(dialer.Control, ProtectPath(options.ProtectPath))
listener.Control = control.Append(listener.Control, ProtectPath(options.ProtectPath))
}
if options.ConnectTimeout != 0 {
dialer.Timeout = time.Duration(options.ConnectTimeout) * time.Second
}
return &defaultDialer{tfo.Dialer{Dialer: dialer, DisableTFO: !options.TCPFastOpen}, listener}
}
func (d *defaultDialer) DialContext(ctx context.Context, network string, address M.Socksaddr) (net.Conn, error) {
return d.Dialer.DialContext(ctx, network, address.String())
}
func (d *defaultDialer) ListenPacket(ctx context.Context, destination M.Socksaddr) (net.PacketConn, error) {
return d.ListenConfig.ListenPacket(ctx, C.NetworkUDP, "")
}

57
outbound/dialer/detour.go
View File

@@ -1,57 +0,0 @@
package dialer
import (
"context"
"net"
"sync"
E "github.com/sagernet/sing/common/exceptions"
M "github.com/sagernet/sing/common/metadata"
N "github.com/sagernet/sing/common/network"
"github.com/sagernet/sing-box/adapter"
)
type detourDialer struct {
router adapter.Router
detour string
dialer N.Dialer
initOnce sync.Once
initErr error
}
func NewDetour(router adapter.Router, detour string) N.Dialer {
return &detourDialer{router: router, detour: detour}
}
func (d *detourDialer) Start() error {
_, err := d.Dialer()
return err
}
func (d *detourDialer) Dialer() (N.Dialer, error) {
d.initOnce.Do(func() {
var loaded bool
d.dialer, loaded = d.router.Outbound(d.detour)
if !loaded {
d.initErr = E.New("outbound detour not found: ", d.detour)
}
})
return d.dialer, d.initErr
}
func (d *detourDialer) DialContext(ctx context.Context, network string, destination M.Socksaddr) (net.Conn, error) {
dialer, err := d.Dialer()
if err != nil {
return nil, err
}
return dialer.DialContext(ctx, network, destination)
}
func (d *detourDialer) ListenPacket(ctx context.Context, destination M.Socksaddr) (net.PacketConn, error) {
dialer, err := d.Dialer()
if err != nil {
return nil, err
}
return dialer.ListenPacket(ctx, destination)
}

22
outbound/dialer/dialer.go
View File

@@ -1,22 +0,0 @@
package dialer
import (
"github.com/sagernet/sing/common"
N "github.com/sagernet/sing/common/network"
"github.com/sagernet/sing-box/adapter"
"github.com/sagernet/sing-box/option"
)
func New(router adapter.Router, options option.DialerOptions) N.Dialer {
var dialer N.Dialer
if options.Detour == "" {
dialer = NewDefault(options)
} else {
dialer = NewDetour(router, options.Detour)
}
if options.OverrideOptions.IsValid() {
dialer = NewOverride(dialer, common.PtrValueOrDefault(options.OverrideOptions))
}
return dialer
}

66
outbound/dialer/override.go
View File

@@ -1,66 +0,0 @@
package dialer
import (
"context"
"crypto/tls"
"net"
M "github.com/sagernet/sing/common/metadata"
N "github.com/sagernet/sing/common/network"
"github.com/sagernet/sing/common/uot"
C "github.com/sagernet/sing-box/constant"
"github.com/sagernet/sing-box/option"
)
var _ N.Dialer = (*overrideDialer)(nil)
type overrideDialer struct {
upstream N.Dialer
tlsEnabled bool
tlsConfig tls.Config
uotEnabled bool
}
func NewOverride(upstream N.Dialer, options option.OverrideStreamOptions) N.Dialer {
return &overrideDialer{
upstream,
options.TLS,
tls.Config{
ServerName: options.TLSServerName,
InsecureSkipVerify: options.TLSInsecure,
},
options.UDPOverTCP,
}
}
func (d *overrideDialer) DialContext(ctx context.Context, network string, destination M.Socksaddr) (net.Conn, error) {
switch network {
case C.NetworkTCP:
conn, err := d.upstream.DialContext(ctx, C.NetworkTCP, destination)
if err != nil {
return nil, err
}
return tls.Client(conn, &d.tlsConfig), nil
case C.NetworkUDP:
if d.uotEnabled {
tcpConn, err := d.upstream.DialContext(ctx, C.NetworkTCP, destination)
if err != nil {
return nil, err
}
return uot.NewClientConn(tcpConn), nil
}
}
return d.upstream.DialContext(ctx, network, destination)
}
func (d *overrideDialer) ListenPacket(ctx context.Context, destination M.Socksaddr) (net.PacketConn, error) {
if d.uotEnabled {
tcpConn, err := d.upstream.DialContext(ctx, C.NetworkTCP, destination)
if err != nil {
return nil, err
}
return uot.NewClientConn(tcpConn), nil
}
return d.upstream.ListenPacket(ctx, destination)
}

46
outbound/dialer/protect.go
View File

@@ -1,46 +0,0 @@
//go:build android || with_protect
package dialer
import (
"syscall"
"github.com/sagernet/sing/common/control"
E "github.com/sagernet/sing/common/exceptions"
)
func sendAncillaryFileDescriptors(protectPath string, fileDescriptors []int) error {
socket, err := syscall.Socket(syscall.AF_UNIX, syscall.SOCK_STREAM, 0)
if err != nil {
return E.Cause(err, "open protect socket")
}
defer syscall.Close(socket)
err = syscall.Connect(socket, &syscall.SockaddrUnix{Name: protectPath})
if err != nil {
return E.Cause(err, "connect protect path")
}
oob := syscall.UnixRights(fileDescriptors...)
dummy := []byte{1}
err = syscall.Sendmsg(socket, dummy, oob, nil, 0)
if err != nil {
return err
}
n, err := syscall.Read(socket, dummy)
if err != nil {
return err
}
if n != 1 {
return E.New("failed to protect fd")
}
return nil
}
func ProtectPath(protectPath string) control.Func {
return func(network, address string, conn syscall.RawConn) error {
var innerErr error
err := conn.Control(func(fd uintptr) {
innerErr = sendAncillaryFileDescriptors(protectPath, []int{int(fd)})
})
return E.Errors(innerErr, err)
}
}

9
outbound/dialer/protect_stub.go
View File

@@ -1,9 +0,0 @@
//go:build !android && !with_protect
package dialer
import "github.com/sagernet/sing/common/control"
func ProtectPath(protectPath string) control.Func {
return nil
}

36
outbound/direct.go
View File

@@ -9,10 +9,10 @@ import (
N "github.com/sagernet/sing/common/network"
"github.com/sagernet/sing-box/adapter"
"github.com/sagernet/sing-box/common/dialer"
C "github.com/sagernet/sing-box/constant"
"github.com/sagernet/sing-box/log"
"github.com/sagernet/sing-box/option"
"github.com/sagernet/sing-box/outbound/dialer"
)
var _ adapter.Outbound = (*Direct)(nil)
@@ -47,41 +47,45 @@ func NewDirect(router adapter.Router, logger log.Logger, tag string, options opt
return outbound
}
func (d *Direct) DialContext(ctx context.Context, network string, destination M.Socksaddr) (net.Conn, error) {
switch d.overrideOption {
func (h *Direct) DialContext(ctx context.Context, network string, destination M.Socksaddr) (net.Conn, error) {
ctx, metadata := adapter.AppendContext(ctx)
metadata.Outbound = h.tag
switch h.overrideOption {
case 1:
destination = d.overrideDestination
destination = h.overrideDestination
case 2:
newDestination := d.overrideDestination
newDestination := h.overrideDestination
newDestination.Port = destination.Port
destination = newDestination
case 3:
destination.Port = d.overrideDestination.Port
destination.Port = h.overrideDestination.Port
}
switch network {
case C.NetworkTCP:
d.logger.WithContext(ctx).Info("outbound connection to ", destination)
h.logger.WithContext(ctx).Info("outbound connection to ", destination)
case C.NetworkUDP:
d.logger.WithContext(ctx).Info("outbound packet connection to ", destination)
h.logger.WithContext(ctx).Info("outbound packet connection to ", destination)
}
return d.dialer.DialContext(ctx, network, destination)
return h.dialer.DialContext(ctx, network, destination)
}
func (d *Direct) ListenPacket(ctx context.Context, destination M.Socksaddr) (net.PacketConn, error) {
d.logger.WithContext(ctx).Info("outbound packet connection")
return d.dialer.ListenPacket(ctx, destination)
func (h *Direct) ListenPacket(ctx context.Context, destination M.Socksaddr) (net.PacketConn, error) {
ctx, metadata := adapter.AppendContext(ctx)
metadata.Outbound = h.tag
h.logger.WithContext(ctx).Info("outbound packet connection")
return h.dialer.ListenPacket(ctx, destination)
}
func (d *Direct) NewConnection(ctx context.Context, conn net.Conn, destination M.Socksaddr) error {
outConn, err := d.DialContext(ctx, C.NetworkTCP, destination)
func (h *Direct) NewConnection(ctx context.Context, conn net.Conn, destination M.Socksaddr) error {
outConn, err := h.DialContext(ctx, C.NetworkTCP, destination)
if err != nil {
return err
}
return bufio.CopyConn(ctx, conn, outConn)
}
func (d *Direct) NewPacketConnection(ctx context.Context, conn N.PacketConn, destination M.Socksaddr) error {
outConn, err := d.ListenPacket(ctx, destination)
func (h *Direct) NewPacketConnection(ctx context.Context, conn N.PacketConn, destination M.Socksaddr) error {
outConn, err := h.ListenPacket(ctx, destination)
if err != nil {
return err
}

8
outbound/http.go
View File

@@ -11,10 +11,10 @@ import (
"github.com/sagernet/sing/protocol/http"
"github.com/sagernet/sing-box/adapter"
"github.com/sagernet/sing-box/common/dialer"
C "github.com/sagernet/sing-box/constant"
"github.com/sagernet/sing-box/log"
"github.com/sagernet/sing-box/option"
"github.com/sagernet/sing-box/outbound/dialer"
)
var _ adapter.Outbound = (*HTTP)(nil)
@@ -32,16 +32,20 @@ func NewHTTP(router adapter.Router, logger log.Logger, tag string, options optio
tag: tag,
network: []string{C.NetworkTCP},
},
http.NewClient(dialer.New(router, options.DialerOptions), M.ParseSocksaddrHostPort(options.Server, options.ServerPort), options.Username, options.Password),
http.NewClient(dialer.New(router, options.DialerOptions), options.ServerOptions.Build(), options.Username, options.Password),
}
}
func (h *HTTP) DialContext(ctx context.Context, network string, destination M.Socksaddr) (net.Conn, error) {
ctx, metadata := adapter.AppendContext(ctx)
metadata.Outbound = h.tag
h.logger.WithContext(ctx).Info("outbound connection to ", destination)
return h.client.DialContext(ctx, network, destination)
}
func (h *HTTP) ListenPacket(ctx context.Context, destination M.Socksaddr) (net.PacketConn, error) {
ctx, metadata := adapter.AppendContext(ctx)
metadata.Outbound = h.tag
return nil, os.ErrInvalid
}

63
outbound/shadowsocks.go
View File

@@ -5,7 +5,6 @@ import (
"net"
"github.com/sagernet/sing/common/bufio"
E "github.com/sagernet/sing/common/exceptions"
M "github.com/sagernet/sing/common/metadata"
N "github.com/sagernet/sing/common/network"
@@ -13,10 +12,10 @@ import (
"github.com/sagernet/sing-shadowsocks/shadowimpl"
"github.com/sagernet/sing-box/adapter"
"github.com/sagernet/sing-box/common/dialer"
C "github.com/sagernet/sing-box/constant"
"github.com/sagernet/sing-box/log"
"github.com/sagernet/sing-box/option"
"github.com/sagernet/sing-box/outbound/dialer"
)
var _ adapter.Outbound = (*Shadowsocks)(nil)
@@ -29,69 +28,67 @@ type Shadowsocks struct {
}
func NewShadowsocks(router adapter.Router, logger log.Logger, tag string, options option.ShadowsocksOutboundOptions) (*Shadowsocks, error) {
outbound := &Shadowsocks{
myOutboundAdapter: myOutboundAdapter{
method, err := shadowimpl.FetchMethod(options.Method, options.Password)
if err != nil {
return nil, err
}
return &Shadowsocks{
myOutboundAdapter{
protocol: C.TypeDirect,
logger: logger,
tag: tag,
network: options.Network.Build(),
},
dialer: dialer.New(router, options.DialerOptions),
}
var err error
outbound.method, err = shadowimpl.FetchMethod(options.Method, options.Password)
if err != nil {
return nil, err
}
if options.Server == "" {
return nil, E.New("missing server address")
} else if options.ServerPort == 0 {
return nil, E.New("missing server port")
}
outbound.serverAddr = M.ParseSocksaddrHostPort(options.Server, options.ServerPort)
return outbound, nil
dialer.New(router, options.DialerOptions),
method,
options.ServerOptions.Build(),
}, nil
}
func (o *Shadowsocks) DialContext(ctx context.Context, network string, destination M.Socksaddr) (net.Conn, error) {
func (h *Shadowsocks) DialContext(ctx context.Context, network string, destination M.Socksaddr) (net.Conn, error) {
ctx, metadata := adapter.AppendContext(ctx)
metadata.Outbound = h.tag
switch network {
case C.NetworkTCP:
o.logger.WithContext(ctx).Info("outbound connection to ", destination)
outConn, err := o.dialer.DialContext(ctx, C.NetworkTCP, o.serverAddr)
h.logger.WithContext(ctx).Info("outbound connection to ", destination)
outConn, err := h.dialer.DialContext(ctx, C.NetworkTCP, h.serverAddr)
if err != nil {
return nil, err
}
return o.method.DialEarlyConn(outConn, destination), nil
return h.method.DialEarlyConn(outConn, destination), nil
case C.NetworkUDP:
o.logger.WithContext(ctx).Info("outbound packet connection to ", destination)
outConn, err := o.dialer.DialContext(ctx, C.NetworkUDP, o.serverAddr)
h.logger.WithContext(ctx).Info("outbound packet connection to ", destination)
outConn, err := h.dialer.DialContext(ctx, C.NetworkUDP, h.serverAddr)
if err != nil {
return nil, err
}
return &bufio.BindPacketConn{PacketConn: o.method.DialPacketConn(outConn), Addr: destination}, nil
return &bufio.BindPacketConn{PacketConn: h.method.DialPacketConn(outConn), Addr: destination}, nil
default:
panic("unknown network " + network)
}
}
func (o *Shadowsocks) ListenPacket(ctx context.Context, destination M.Socksaddr) (net.PacketConn, error) {
o.logger.WithContext(ctx).Info("outbound packet connection to ", o.serverAddr)
outConn, err := o.dialer.ListenPacket(ctx, destination)
func (h *Shadowsocks) ListenPacket(ctx context.Context, destination M.Socksaddr) (net.PacketConn, error) {
ctx, metadata := adapter.AppendContext(ctx)
metadata.Outbound = h.tag
h.logger.WithContext(ctx).Info("outbound packet connection to ", h.serverAddr)
outConn, err := h.dialer.ListenPacket(ctx, destination)
if err != nil {
return nil, err
}
return o.method.DialPacketConn(&bufio.BindPacketConn{PacketConn: outConn, Addr: o.serverAddr.UDPAddr()}), nil
return h.method.DialPacketConn(&bufio.BindPacketConn{PacketConn: outConn, Addr: h.serverAddr.UDPAddr()}), nil
}
func (o *Shadowsocks) NewConnection(ctx context.Context, conn net.Conn, destination M.Socksaddr) error {
serverConn, err := o.DialContext(ctx, C.NetworkTCP, destination)
func (h *Shadowsocks) NewConnection(ctx context.Context, conn net.Conn, destination M.Socksaddr) error {
serverConn, err := h.DialContext(ctx, C.NetworkTCP, destination)
if err != nil {
return err
}
return CopyEarlyConn(ctx, conn, serverConn)
}
func (o *Shadowsocks) NewPacketConnection(ctx context.Context, conn N.PacketConn, destination M.Socksaddr) error {
serverConn, err := o.ListenPacket(ctx, destination)
func (h *Shadowsocks) NewPacketConnection(ctx context.Context, conn N.PacketConn, destination M.Socksaddr) error {
serverConn, err := h.ListenPacket(ctx, destination)
if err != nil {
return err
}

8
outbound/socks.go
View File

@@ -10,10 +10,10 @@ import (
"github.com/sagernet/sing/protocol/socks"
"github.com/sagernet/sing-box/adapter"
"github.com/sagernet/sing-box/common/dialer"
C "github.com/sagernet/sing-box/constant"
"github.com/sagernet/sing-box/log"
"github.com/sagernet/sing-box/option"
"github.com/sagernet/sing-box/outbound/dialer"
)
var _ adapter.Outbound = (*Socks)(nil)
@@ -42,11 +42,13 @@ func NewSocks(router adapter.Router, logger log.Logger, tag string, options opti
tag: tag,
network: options.Network.Build(),
},
socks.NewClient(detour, M.ParseSocksaddrHostPort(options.Server, options.ServerPort), version, options.Username, options.Password),
socks.NewClient(detour, options.ServerOptions.Build(), version, options.Username, options.Password),
}, nil
}
func (h *Socks) DialContext(ctx context.Context, network string, destination M.Socksaddr) (net.Conn, error) {
ctx, metadata := adapter.AppendContext(ctx)
metadata.Outbound = h.tag
switch network {
case C.NetworkTCP:
h.logger.WithContext(ctx).Info("outbound connection to ", destination)
@@ -59,6 +61,8 @@ func (h *Socks) DialContext(ctx context.Context, network string, destination M.S
}
func (h *Socks) ListenPacket(ctx context.Context, destination M.Socksaddr) (net.PacketConn, error) {
ctx, metadata := adapter.AppendContext(ctx)
metadata.Outbound = h.tag
h.logger.WithContext(ctx).Info("outbound packet connection to ", destination)
return h.client.ListenPacket(ctx, destination)
}