2016-07-26 11:11:58 -04:00
|
|
|
package internet
|
|
|
|
|
|
|
|
import (
|
2017-02-26 08:38:41 -05:00
|
|
|
"context"
|
2018-09-06 04:06:57 -04:00
|
|
|
"syscall"
|
2016-07-26 11:11:58 -04:00
|
|
|
"time"
|
|
|
|
|
2021-02-16 15:31:50 -05:00
|
|
|
"github.com/v2fly/v2ray-core/v4/common/net"
|
|
|
|
"github.com/v2fly/v2ray-core/v4/common/session"
|
2016-07-26 11:11:58 -04:00
|
|
|
)
|
|
|
|
|
2021-05-19 17:28:52 -04:00
|
|
|
var effectiveSystemDialer SystemDialer = &DefaultSystemDialer{}
|
2016-07-26 11:11:58 -04:00
|
|
|
|
|
|
|
type SystemDialer interface {
|
2018-11-21 08:54:40 -05:00
|
|
|
Dial(ctx context.Context, source net.Address, destination net.Destination, sockopt *SocketConfig) (net.Conn, error)
|
2016-07-26 11:11:58 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
type DefaultSystemDialer struct {
|
2018-12-06 15:09:41 -05:00
|
|
|
controllers []controller
|
2016-07-26 11:11:58 -04:00
|
|
|
}
|
|
|
|
|
2019-01-06 03:39:37 -05: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,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-12 03:12:48 -05:00
|
|
|
func hasBindAddr(sockopt *SocketConfig) bool {
|
2019-01-12 03:44:51 -05:00
|
|
|
return sockopt != nil && len(sockopt.BindAddress) > 0 && sockopt.BindPort > 0
|
2019-01-12 03:12:48 -05:00
|
|
|
}
|
|
|
|
|
2018-12-06 15:09:41 -05:00
|
|
|
func (d *DefaultSystemDialer) Dial(ctx context.Context, src net.Address, dest net.Destination, sockopt *SocketConfig) (net.Conn, error) {
|
2019-01-12 03:12:48 -05:00
|
|
|
if dest.Network == net.Network_UDP && !hasBindAddr(sockopt) {
|
2019-01-06 03:39:37 -05:00
|
|
|
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
|
|
|
|
}
|
2021-11-13 16:31:49 -05:00
|
|
|
goStdKeepAlive := time.Duration(0)
|
2021-11-13 17:32:23 -05:00
|
|
|
if sockopt != nil && sockopt.TcpKeepAliveIdle != 0 {
|
2021-11-13 16:31:49 -05:00
|
|
|
goStdKeepAlive = time.Duration(-1)
|
|
|
|
}
|
2016-07-26 11:11:58 -04:00
|
|
|
dialer := &net.Dialer{
|
2019-01-12 03:44:51 -05:00
|
|
|
Timeout: time.Second * 16,
|
2019-01-06 03:39:37 -05:00
|
|
|
LocalAddr: resolveSrcAddr(dest.Network, src),
|
2021-11-13 16:31:49 -05:00
|
|
|
KeepAlive: goStdKeepAlive,
|
2016-07-26 11:11:58 -04:00
|
|
|
}
|
2018-09-06 04:06:57 -04:00
|
|
|
|
2018-12-06 15:09:41 -05:00
|
|
|
if sockopt != nil || len(d.controllers) > 0 {
|
2018-09-06 04:06:57 -04:00
|
|
|
dialer.Control = func(network, address string, c syscall.RawConn) error {
|
|
|
|
return c.Control(func(fd uintptr) {
|
2018-12-06 15:09:41 -05:00
|
|
|
if sockopt != nil {
|
|
|
|
if err := applyOutboundSocketOptions(network, address, fd, sockopt); err != nil {
|
|
|
|
newError("failed to apply socket options").Base(err).WriteToLog(session.ExportIDToError(ctx))
|
|
|
|
}
|
2019-01-12 03:12:48 -05:00
|
|
|
if dest.Network == net.Network_UDP && hasBindAddr(sockopt) {
|
2018-12-06 15:09:41 -05:00
|
|
|
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))
|
|
|
|
}
|
|
|
|
}
|
2018-09-06 04:06:57 -04:00
|
|
|
}
|
2018-12-06 15:09:41 -05:00
|
|
|
|
|
|
|
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))
|
2018-09-17 09:12:58 -04:00
|
|
|
}
|
|
|
|
}
|
2018-09-06 04:06:57 -04:00
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-23 17:48:47 -05:00
|
|
|
return dialer.DialContext(ctx, dest.Network.SystemString(), dest.NetAddr())
|
2016-07-26 11:11:58 -04:00
|
|
|
}
|
|
|
|
|
2019-01-06 03:39:37 -05:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
|
2016-07-26 11:11:58 -04:00
|
|
|
type SystemDialerAdapter interface {
|
|
|
|
Dial(network string, address string) (net.Conn, error)
|
|
|
|
}
|
|
|
|
|
|
|
|
type SimpleSystemDialer struct {
|
|
|
|
adapter SystemDialerAdapter
|
|
|
|
}
|
|
|
|
|
2016-07-26 11:25:13 -04:00
|
|
|
func WithAdapter(dialer SystemDialerAdapter) SystemDialer {
|
|
|
|
return &SimpleSystemDialer{
|
|
|
|
adapter: dialer,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-21 08:54:40 -05:00
|
|
|
func (v *SimpleSystemDialer) Dial(ctx context.Context, src net.Address, dest net.Destination, sockopt *SocketConfig) (net.Conn, error) {
|
2016-11-27 15:39:09 -05:00
|
|
|
return v.adapter.Dial(dest.Network.SystemString(), dest.NetAddr())
|
2016-07-26 11:11:58 -04:00
|
|
|
}
|
|
|
|
|
2016-07-26 11:25:13 -04:00
|
|
|
// UseAlternativeSystemDialer replaces the current system dialer with a given one.
|
|
|
|
// Caller must ensure there is no race condition.
|
2018-12-03 16:44:42 -05:00
|
|
|
//
|
|
|
|
// v2ray:api:stable
|
2016-07-26 11:11:58 -04:00
|
|
|
func UseAlternativeSystemDialer(dialer SystemDialer) {
|
2017-04-30 17:37:30 -04:00
|
|
|
if dialer == nil {
|
2021-05-02 10:28:33 -04:00
|
|
|
dialer = &DefaultSystemDialer{}
|
2017-04-30 17:37:30 -04:00
|
|
|
}
|
2016-07-26 11:11:58 -04:00
|
|
|
effectiveSystemDialer = dialer
|
|
|
|
}
|
2018-12-06 15:09:41 -05:00
|
|
|
|
|
|
|
// 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.
|
|
|
|
//
|
|
|
|
// v2ray: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
|
|
|
|
}
|