mirror of
https://github.com/v2rayA/v2rayA.git
synced 2026-11-20 23:02:25 +03:00
190 lines
4.9 KiB
Go
190 lines
4.9 KiB
Go
package plugin
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net"
|
|
"net/url"
|
|
"runtime"
|
|
"strings"
|
|
"syscall"
|
|
|
|
"github.com/daeuniverse/outbound/netproxy"
|
|
"github.com/v2rayA/v2rayA/conf"
|
|
"github.com/v2rayA/v2rayA/pkg/util/log"
|
|
)
|
|
|
|
type FakeNetPacketConn interface {
|
|
net.PacketConn
|
|
}
|
|
|
|
type fakeNetPacketConn struct {
|
|
netproxy.PacketConn
|
|
}
|
|
|
|
type fakeNetConn struct {
|
|
netproxy.Conn
|
|
}
|
|
|
|
func (f *fakeNetConn) LocalAddr() net.Addr {
|
|
return &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 30000}
|
|
}
|
|
|
|
func (f *fakeNetConn) RemoteAddr() net.Addr {
|
|
return &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 80}
|
|
}
|
|
|
|
func (f *fakeNetConn) Read(b []byte) (n int, err error) {
|
|
n, err = f.Conn.Read(b)
|
|
if n > 0 {
|
|
log.Trace("[conn] read %d bytes from %v", n, f.RemoteAddr())
|
|
}
|
|
return
|
|
}
|
|
|
|
func (f *fakeNetConn) Write(b []byte) (n int, err error) {
|
|
n, err = f.Conn.Write(b)
|
|
if n > 0 {
|
|
log.Trace("[conn] write %d bytes to %v", n, f.RemoteAddr())
|
|
}
|
|
return
|
|
}
|
|
|
|
func (f *fakeNetConn) SyscallConn() (syscall.RawConn, error) {
|
|
if sc, ok := f.Conn.(syscall.Conn); ok {
|
|
return sc.SyscallConn()
|
|
}
|
|
return nil, fmt.Errorf("connection doesn't allow to get Syscall.RawConn")
|
|
}
|
|
|
|
func NewFakeNetConn(c netproxy.Conn) net.Conn {
|
|
if c == nil {
|
|
return nil
|
|
}
|
|
return &fakeNetConn{Conn: c}
|
|
}
|
|
|
|
func (f *fakeNetPacketConn) LocalAddr() net.Addr {
|
|
return &net.UDPAddr{}
|
|
}
|
|
|
|
func (f *fakeNetPacketConn) RemoteAddr() net.Addr {
|
|
return &net.UDPAddr{}
|
|
}
|
|
|
|
func (f *fakeNetPacketConn) ReadFrom(p []byte) (n int, addr net.Addr, err error) {
|
|
n, ap, err := f.PacketConn.ReadFrom(p)
|
|
if err != nil {
|
|
return 0, nil, err
|
|
}
|
|
return n, net.UDPAddrFromAddrPort(ap), nil
|
|
}
|
|
|
|
func (f *fakeNetPacketConn) WriteTo(p []byte, addr net.Addr) (n int, err error) {
|
|
return f.PacketConn.WriteTo(p, addr.String())
|
|
}
|
|
|
|
func (f *fakeNetPacketConn) WriteMsgUDP(b []byte, oob []byte, addr *net.UDPAddr) (n int, oobn int, err error) {
|
|
if pc, ok := f.PacketConn.(interface {
|
|
WriteMsgUDP(b []byte, oob []byte, addr *net.UDPAddr) (n int, oobn int, err error)
|
|
}); ok {
|
|
return pc.WriteMsgUDP(b, oob, addr)
|
|
}
|
|
return 0, 0, fmt.Errorf("WriteMsgUDP not supported by underlying PacketConn: %T", f.PacketConn)
|
|
}
|
|
|
|
func (f *fakeNetPacketConn) SyscallConn() (syscall.RawConn, error) {
|
|
if sc, ok := f.PacketConn.(syscall.Conn); ok {
|
|
return sc.SyscallConn()
|
|
}
|
|
return nil, fmt.Errorf("connection doesn't allow to get Syscall.RawConn")
|
|
}
|
|
|
|
func NewFakeNetPacketConn(pc netproxy.PacketConn) FakeNetPacketConn {
|
|
return &fakeNetPacketConn{PacketConn: pc}
|
|
}
|
|
|
|
// Dialer is used to create connection.
|
|
type Dialer interface {
|
|
// Addr is the dialer's addr
|
|
Addr() string
|
|
|
|
// Dial connects to the given address
|
|
Dial(network, addr string) (c net.Conn, err error)
|
|
|
|
DialContext(ctx context.Context, network, addr string) (c net.Conn, err error)
|
|
|
|
// DialUDP connects to the given address
|
|
DialUDP(network string) (pc FakeNetPacketConn, err error)
|
|
}
|
|
|
|
// DialerCreator is a function to create dialers.
|
|
type DialerCreator func(s string, dialer Dialer) (Dialer, error)
|
|
|
|
var (
|
|
dialerMap = make(map[string]DialerCreator)
|
|
)
|
|
|
|
// RegisterDialer is used to register a dialer.
|
|
func RegisterDialer(name string, c DialerCreator) {
|
|
dialerMap[name] = c
|
|
}
|
|
|
|
// getAvailableSchemes returns a list of registered dialer schemes
|
|
func getAvailableSchemes() []string {
|
|
schemes := make([]string, 0, len(dialerMap))
|
|
for k := range dialerMap {
|
|
schemes = append(schemes, k)
|
|
}
|
|
return schemes
|
|
}
|
|
|
|
// DialerFromURL calls the registered creator to create dialers.
|
|
// dialer is the default upstream dialer so cannot be nil, we can use Default when calling this function.
|
|
func DialerFromURL(s string, dialer Dialer) (Dialer, error) {
|
|
if dialer == nil {
|
|
return nil, fmt.Errorf("DialerFromURL: dialer cannot be nil")
|
|
}
|
|
|
|
u, err := url.Parse(s)
|
|
if err != nil {
|
|
log.Warn("[plugin] parse URL '%s' failed: %v", s, err)
|
|
return nil, fmt.Errorf("parse URL: %w", err)
|
|
}
|
|
|
|
scheme := strings.ToLower(u.Scheme)
|
|
c, ok := dialerMap[scheme]
|
|
if !ok {
|
|
log.Warn("[plugin] unknown scheme '%s' in URL: %s. Available schemes: %v", u.Scheme, s, getAvailableSchemes())
|
|
return nil, fmt.Errorf("unknown scheme '%s'", u.Scheme)
|
|
}
|
|
|
|
log.Trace("[plugin] creating dialer for scheme '%s' from URL: %s", scheme, s)
|
|
result, err := c(s, dialer)
|
|
if err != nil {
|
|
log.Warn("[plugin] failed to create dialer for scheme '%s': %v", scheme, err)
|
|
return nil, fmt.Errorf("create %s dialer: %w", scheme, err)
|
|
}
|
|
|
|
log.Trace("[plugin] successfully created dialer for scheme '%s'", scheme)
|
|
return result, nil
|
|
}
|
|
|
|
// ShouldSetMark determines if SO_MARK should be set on sockets.
|
|
// SO_MARK should only be set on Linux with root privileges.
|
|
// Returns 0x80 if mark should be set, 0 otherwise.
|
|
func ShouldSetMark() uint32 {
|
|
// Don't set mark on Windows or macOS (they don't support redirect/tproxy)
|
|
if runtime.GOOS == "windows" || runtime.GOOS == "darwin" {
|
|
return 0
|
|
}
|
|
|
|
// Don't set mark in lite mode (no root privileges)
|
|
if conf.GetEnvironmentConfig().Lite {
|
|
return 0
|
|
}
|
|
|
|
// Set mark on Linux with root privileges
|
|
return 0x80
|
|
}
|