diff --git a/adapter/outbound/base.go b/adapter/outbound/base.go index f356ae2d..76f9bd39 100644 --- a/adapter/outbound/base.go +++ b/adapter/outbound/base.go @@ -146,6 +146,7 @@ type BasicOption struct { Interface string `proxy:"interface-name,omitempty" group:"interface-name,omitempty"` RoutingMark int `proxy:"routing-mark,omitempty" group:"routing-mark,omitempty"` IPVersion string `proxy:"ip-version,omitempty" group:"ip-version,omitempty"` + DialerProxy string `proxy:"dialer-proxy,omitempty"` // don't apply this option into groups, but can set a group name in a proxy } type BaseOption struct { diff --git a/adapter/outbound/http.go b/adapter/outbound/http.go index 6a668ebb..645177a4 100644 --- a/adapter/outbound/http.go +++ b/adapter/outbound/http.go @@ -14,6 +14,7 @@ import ( "strconv" "github.com/Dreamacro/clash/component/dialer" + "github.com/Dreamacro/clash/component/proxydialer" tlsC "github.com/Dreamacro/clash/component/tls" C "github.com/Dreamacro/clash/constant" ) @@ -66,6 +67,12 @@ func (h *Http) DialContext(ctx context.Context, metadata *C.Metadata, opts ...di // DialContextWithDialer implements C.ProxyAdapter func (h *Http) DialContextWithDialer(ctx context.Context, dialer C.Dialer, metadata *C.Metadata) (_ C.Conn, err error) { + if len(h.option.DialerProxy) > 0 { + dialer, err = proxydialer.NewByName(h.option.DialerProxy, dialer) + if err != nil { + return nil, err + } + } c, err := dialer.DialContext(ctx, "tcp", h.addr) if err != nil { return nil, fmt.Errorf("%s connect error: %w", h.addr, err) diff --git a/adapter/outbound/hysteria.go b/adapter/outbound/hysteria.go index bd75cc3c..6024ea10 100644 --- a/adapter/outbound/hysteria.go +++ b/adapter/outbound/hysteria.go @@ -20,6 +20,7 @@ import ( M "github.com/sagernet/sing/common/metadata" "github.com/Dreamacro/clash/component/dialer" + "github.com/Dreamacro/clash/component/proxydialer" tlsC "github.com/Dreamacro/clash/component/tls" C "github.com/Dreamacro/clash/constant" "github.com/Dreamacro/clash/log" @@ -28,6 +29,7 @@ import ( "github.com/Dreamacro/clash/transport/hysteria/obfs" "github.com/Dreamacro/clash/transport/hysteria/pmtud_fix" "github.com/Dreamacro/clash/transport/hysteria/transport" + "github.com/Dreamacro/clash/transport/hysteria/utils" ) const ( @@ -46,21 +48,12 @@ var rateStringRegexp = regexp.MustCompile(`^(\d+)\s*([KMGT]?)([Bb])ps$`) type Hysteria struct { *Base + option *HysteriaOption client *core.Client } func (h *Hysteria) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.Conn, error) { - hdc := hyDialerWithContext{ - ctx: context.Background(), - hyDialer: func(network string) (net.PacketConn, error) { - return dialer.ListenPacket(ctx, network, "", h.Base.DialOptions(opts...)...) - }, - remoteAddr: func(addr string) (net.Addr, error) { - return resolveUDPAddrWithPrefer(ctx, "udp", addr, h.prefer) - }, - } - - tcpConn, err := h.client.DialTCP(metadata.RemoteAddress(), &hdc) + tcpConn, err := h.client.DialTCP(metadata.RemoteAddress(), h.genHdc(ctx, opts...)) if err != nil { return nil, err } @@ -69,20 +62,32 @@ func (h *Hysteria) DialContext(ctx context.Context, metadata *C.Metadata, opts . } func (h *Hysteria) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.PacketConn, error) { - hdc := hyDialerWithContext{ + udpConn, err := h.client.DialUDP(h.genHdc(ctx, opts...)) + if err != nil { + return nil, err + } + return newPacketConn(&hyPacketConn{udpConn}, h), nil +} + +func (h *Hysteria) genHdc(ctx context.Context, opts ...dialer.Option) utils.PacketDialer { + return &hyDialerWithContext{ ctx: context.Background(), hyDialer: func(network string) (net.PacketConn, error) { - return dialer.ListenPacket(ctx, network, "", h.Base.DialOptions(opts...)...) + var err error + var cDialer C.Dialer = dialer.NewDialer(h.Base.DialOptions(opts...)...) + if len(h.option.DialerProxy) > 0 { + cDialer, err = proxydialer.NewByName(h.option.DialerProxy, cDialer) + if err != nil { + return nil, err + } + } + rAddrPort, _ := netip.ParseAddrPort(h.Addr()) + return cDialer.ListenPacket(ctx, network, "", rAddrPort) }, remoteAddr: func(addr string) (net.Addr, error) { return resolveUDPAddrWithPrefer(ctx, "udp", addr, h.prefer) }, } - udpConn, err := h.client.DialUDP(&hdc) - if err != nil { - return nil, err - } - return newPacketConn(&hyPacketConn{udpConn}, h), nil } type HysteriaOption struct { @@ -258,6 +263,7 @@ func NewHysteria(option HysteriaOption) (*Hysteria, error) { rmark: option.RoutingMark, prefer: C.NewDNSPrefer(option.IPVersion), }, + option: &option, client: client, }, nil } diff --git a/adapter/outbound/shadowsocks.go b/adapter/outbound/shadowsocks.go index ae4037dc..ac4cc31e 100644 --- a/adapter/outbound/shadowsocks.go +++ b/adapter/outbound/shadowsocks.go @@ -11,6 +11,7 @@ import ( N "github.com/Dreamacro/clash/common/net" "github.com/Dreamacro/clash/common/structure" "github.com/Dreamacro/clash/component/dialer" + "github.com/Dreamacro/clash/component/proxydialer" C "github.com/Dreamacro/clash/constant" "github.com/Dreamacro/clash/transport/restls" obfs "github.com/Dreamacro/clash/transport/simple-obfs" @@ -145,6 +146,12 @@ func (ss *ShadowSocks) DialContext(ctx context.Context, metadata *C.Metadata, op // DialContextWithDialer implements C.ProxyAdapter func (ss *ShadowSocks) DialContextWithDialer(ctx context.Context, dialer C.Dialer, metadata *C.Metadata) (_ C.Conn, err error) { + if len(ss.option.DialerProxy) > 0 { + dialer, err = proxydialer.NewByName(ss.option.DialerProxy, dialer) + if err != nil { + return nil, err + } + } c, err := dialer.DialContext(ctx, "tcp", ss.addr) if err != nil { return nil, fmt.Errorf("%s connect error: %w", ss.addr, err) @@ -166,6 +173,12 @@ func (ss *ShadowSocks) ListenPacketContext(ctx context.Context, metadata *C.Meta // ListenPacketWithDialer implements C.ProxyAdapter func (ss *ShadowSocks) ListenPacketWithDialer(ctx context.Context, dialer C.Dialer, metadata *C.Metadata) (_ C.PacketConn, err error) { + if len(ss.option.DialerProxy) > 0 { + dialer, err = proxydialer.NewByName(ss.option.DialerProxy, dialer) + if err != nil { + return nil, err + } + } if ss.option.UDPOverTCP { tcpConn, err := ss.DialContextWithDialer(ctx, dialer, metadata) if err != nil { diff --git a/adapter/outbound/shadowsocksr.go b/adapter/outbound/shadowsocksr.go index 135e7132..e96116d4 100644 --- a/adapter/outbound/shadowsocksr.go +++ b/adapter/outbound/shadowsocksr.go @@ -7,6 +7,7 @@ import ( "strconv" "github.com/Dreamacro/clash/component/dialer" + "github.com/Dreamacro/clash/component/proxydialer" C "github.com/Dreamacro/clash/constant" "github.com/Dreamacro/clash/transport/shadowsocks/core" "github.com/Dreamacro/clash/transport/shadowsocks/shadowaead" @@ -17,6 +18,7 @@ import ( type ShadowSocksR struct { *Base + option *ShadowSocksROption cipher core.Cipher obfs obfs.Obfs protocol protocol.Protocol @@ -65,6 +67,12 @@ func (ssr *ShadowSocksR) DialContext(ctx context.Context, metadata *C.Metadata, // DialContextWithDialer implements C.ProxyAdapter func (ssr *ShadowSocksR) DialContextWithDialer(ctx context.Context, dialer C.Dialer, metadata *C.Metadata) (_ C.Conn, err error) { + if len(ssr.option.DialerProxy) > 0 { + dialer, err = proxydialer.NewByName(ssr.option.DialerProxy, dialer) + if err != nil { + return nil, err + } + } c, err := dialer.DialContext(ctx, "tcp", ssr.addr) if err != nil { return nil, fmt.Errorf("%s connect error: %w", ssr.addr, err) @@ -86,6 +94,12 @@ func (ssr *ShadowSocksR) ListenPacketContext(ctx context.Context, metadata *C.Me // ListenPacketWithDialer implements C.ProxyAdapter func (ssr *ShadowSocksR) ListenPacketWithDialer(ctx context.Context, dialer C.Dialer, metadata *C.Metadata) (_ C.PacketConn, err error) { + if len(ssr.option.DialerProxy) > 0 { + dialer, err = proxydialer.NewByName(ssr.option.DialerProxy, dialer) + if err != nil { + return nil, err + } + } addr, err := resolveUDPAddrWithPrefer(ctx, "udp", ssr.addr, ssr.prefer) if err != nil { return nil, err @@ -168,6 +182,7 @@ func NewShadowSocksR(option ShadowSocksROption) (*ShadowSocksR, error) { rmark: option.RoutingMark, prefer: C.NewDNSPrefer(option.IPVersion), }, + option: &option, cipher: coreCiph, obfs: obfs, protocol: protocol, diff --git a/adapter/outbound/snell.go b/adapter/outbound/snell.go index d6f1efee..d6d0436d 100644 --- a/adapter/outbound/snell.go +++ b/adapter/outbound/snell.go @@ -8,6 +8,7 @@ import ( "github.com/Dreamacro/clash/common/structure" "github.com/Dreamacro/clash/component/dialer" + "github.com/Dreamacro/clash/component/proxydialer" C "github.com/Dreamacro/clash/constant" obfs "github.com/Dreamacro/clash/transport/simple-obfs" "github.com/Dreamacro/clash/transport/snell" @@ -15,6 +16,7 @@ import ( type Snell struct { *Base + option *SnellOption psk []byte pool *snell.Pool obfsOption *simpleObfsOption @@ -83,6 +85,12 @@ func (s *Snell) DialContext(ctx context.Context, metadata *C.Metadata, opts ...d // DialContextWithDialer implements C.ProxyAdapter func (s *Snell) DialContextWithDialer(ctx context.Context, dialer C.Dialer, metadata *C.Metadata) (_ C.Conn, err error) { + if len(s.option.DialerProxy) > 0 { + dialer, err = proxydialer.NewByName(s.option.DialerProxy, dialer) + if err != nil { + return nil, err + } + } c, err := dialer.DialContext(ctx, "tcp", s.addr) if err != nil { return nil, fmt.Errorf("%s connect error: %w", s.addr, err) @@ -104,6 +112,13 @@ func (s *Snell) ListenPacketContext(ctx context.Context, metadata *C.Metadata, o // ListenPacketWithDialer implements C.ProxyAdapter func (s *Snell) ListenPacketWithDialer(ctx context.Context, dialer C.Dialer, metadata *C.Metadata) (C.PacketConn, error) { + var err error + if len(s.option.DialerProxy) > 0 { + dialer, err = proxydialer.NewByName(s.option.DialerProxy, dialer) + if err != nil { + return nil, err + } + } c, err := dialer.DialContext(ctx, "tcp", s.addr) if err != nil { return nil, err @@ -172,6 +187,7 @@ func NewSnell(option SnellOption) (*Snell, error) { rmark: option.RoutingMark, prefer: C.NewDNSPrefer(option.IPVersion), }, + option: &option, psk: psk, obfsOption: obfsOption, version: option.Version, @@ -179,7 +195,15 @@ func NewSnell(option SnellOption) (*Snell, error) { if option.Version == snell.Version2 { s.pool = snell.NewPool(func(ctx context.Context) (*snell.Snell, error) { - c, err := dialer.DialContext(ctx, "tcp", addr, s.Base.DialOptions()...) + var err error + var cDialer C.Dialer = dialer.NewDialer(s.Base.DialOptions()...) + if len(s.option.DialerProxy) > 0 { + cDialer, err = proxydialer.NewByName(s.option.DialerProxy, cDialer) + if err != nil { + return nil, err + } + } + c, err := cDialer.DialContext(ctx, "tcp", addr) if err != nil { return nil, err } diff --git a/adapter/outbound/socks5.go b/adapter/outbound/socks5.go index cdb89cc2..b328b634 100644 --- a/adapter/outbound/socks5.go +++ b/adapter/outbound/socks5.go @@ -10,6 +10,7 @@ import ( "strconv" "github.com/Dreamacro/clash/component/dialer" + "github.com/Dreamacro/clash/component/proxydialer" tlsC "github.com/Dreamacro/clash/component/tls" C "github.com/Dreamacro/clash/constant" "github.com/Dreamacro/clash/transport/socks5" @@ -17,6 +18,7 @@ import ( type Socks5 struct { *Base + option *Socks5Option user string pass string tls bool @@ -70,6 +72,12 @@ func (ss *Socks5) DialContext(ctx context.Context, metadata *C.Metadata, opts .. // DialContextWithDialer implements C.ProxyAdapter func (ss *Socks5) DialContextWithDialer(ctx context.Context, dialer C.Dialer, metadata *C.Metadata) (_ C.Conn, err error) { + if len(ss.option.DialerProxy) > 0 { + dialer, err = proxydialer.NewByName(ss.option.DialerProxy, dialer) + if err != nil { + return nil, err + } + } c, err := dialer.DialContext(ctx, "tcp", ss.addr) if err != nil { return nil, fmt.Errorf("%s connect error: %w", ss.addr, err) @@ -95,7 +103,14 @@ func (ss *Socks5) SupportWithDialer() bool { // ListenPacketContext implements C.ProxyAdapter func (ss *Socks5) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (_ C.PacketConn, err error) { - c, err := dialer.DialContext(ctx, "tcp", ss.addr, ss.Base.DialOptions(opts...)...) + var cDialer C.Dialer = dialer.NewDialer(ss.Base.DialOptions(opts...)...) + if len(ss.option.DialerProxy) > 0 { + cDialer, err = proxydialer.NewByName(ss.option.DialerProxy, cDialer) + if err != nil { + return nil, err + } + } + c, err := cDialer.DialContext(ctx, "tcp", ss.addr) if err != nil { err = fmt.Errorf("%s connect error: %w", ss.addr, err) return @@ -187,6 +202,7 @@ func NewSocks5(option Socks5Option) (*Socks5, error) { rmark: option.RoutingMark, prefer: C.NewDNSPrefer(option.IPVersion), }, + option: &option, user: option.UserName, pass: option.Password, tls: option.TLS, diff --git a/adapter/outbound/trojan.go b/adapter/outbound/trojan.go index 4a31538b..013164c4 100644 --- a/adapter/outbound/trojan.go +++ b/adapter/outbound/trojan.go @@ -9,6 +9,7 @@ import ( "strconv" "github.com/Dreamacro/clash/component/dialer" + "github.com/Dreamacro/clash/component/proxydialer" tlsC "github.com/Dreamacro/clash/component/tls" C "github.com/Dreamacro/clash/constant" "github.com/Dreamacro/clash/transport/gun" @@ -134,6 +135,12 @@ func (t *Trojan) DialContext(ctx context.Context, metadata *C.Metadata, opts ... // DialContextWithDialer implements C.ProxyAdapter func (t *Trojan) DialContextWithDialer(ctx context.Context, dialer C.Dialer, metadata *C.Metadata) (_ C.Conn, err error) { + if len(t.option.DialerProxy) > 0 { + dialer, err = proxydialer.NewByName(t.option.DialerProxy, dialer) + if err != nil { + return nil, err + } + } c, err := dialer.DialContext(ctx, "tcp", t.addr) if err != nil { return nil, fmt.Errorf("%s connect error: %w", t.addr, err) @@ -178,6 +185,12 @@ func (t *Trojan) ListenPacketContext(ctx context.Context, metadata *C.Metadata, // ListenPacketWithDialer implements C.ProxyAdapter func (t *Trojan) ListenPacketWithDialer(ctx context.Context, dialer C.Dialer, metadata *C.Metadata) (_ C.PacketConn, err error) { + if len(t.option.DialerProxy) > 0 { + dialer, err = proxydialer.NewByName(t.option.DialerProxy, dialer) + if err != nil { + return nil, err + } + } c, err := dialer.DialContext(ctx, "tcp", t.addr) if err != nil { return nil, fmt.Errorf("%s connect error: %w", t.addr, err) @@ -270,7 +283,15 @@ func NewTrojan(option TrojanOption) (*Trojan, error) { if option.Network == "grpc" { dialFn := func(network, addr string) (net.Conn, error) { - c, err := dialer.DialContext(context.Background(), "tcp", t.addr, t.Base.DialOptions()...) + var err error + var cDialer C.Dialer = dialer.NewDialer(t.Base.DialOptions()...) + if len(t.option.DialerProxy) > 0 { + cDialer, err = proxydialer.NewByName(t.option.DialerProxy, cDialer) + if err != nil { + return nil, err + } + } + c, err := cDialer.DialContext(context.Background(), "tcp", t.addr) if err != nil { return nil, fmt.Errorf("%s connect error: %s", t.addr, err.Error()) } diff --git a/adapter/outbound/tuic.go b/adapter/outbound/tuic.go index d2f2b5e9..6640c46a 100644 --- a/adapter/outbound/tuic.go +++ b/adapter/outbound/tuic.go @@ -16,6 +16,7 @@ import ( "github.com/metacubex/quic-go" "github.com/Dreamacro/clash/component/dialer" + "github.com/Dreamacro/clash/component/proxydialer" tlsC "github.com/Dreamacro/clash/component/tls" C "github.com/Dreamacro/clash/constant" "github.com/Dreamacro/clash/transport/tuic" @@ -23,6 +24,7 @@ import ( type Tuic struct { *Base + option *TuicOption client *tuic.PoolClient } @@ -93,6 +95,12 @@ func (t *Tuic) dial(ctx context.Context, opts ...dialer.Option) (pc net.PacketCo } func (t *Tuic) dialWithDialer(ctx context.Context, dialer C.Dialer) (pc net.PacketConn, addr net.Addr, err error) { + if len(t.option.DialerProxy) > 0 { + dialer, err = proxydialer.NewByName(t.option.DialerProxy, dialer) + if err != nil { + return nil, nil, err + } + } udpAddr, err := resolveUDPAddrWithPrefer(ctx, "udp", t.addr, t.prefer) if err != nil { return nil, nil, err @@ -230,6 +238,7 @@ func NewTuic(option TuicOption) (*Tuic, error) { rmark: option.RoutingMark, prefer: C.NewDNSPrefer(option.IPVersion), }, + option: &option, } clientMaxOpenStreams := int64(option.MaxOpenStreams) diff --git a/adapter/outbound/vless.go b/adapter/outbound/vless.go index 757661cc..b5ae66e1 100644 --- a/adapter/outbound/vless.go +++ b/adapter/outbound/vless.go @@ -14,6 +14,7 @@ import ( "github.com/Dreamacro/clash/common/convert" "github.com/Dreamacro/clash/component/dialer" + "github.com/Dreamacro/clash/component/proxydialer" "github.com/Dreamacro/clash/component/resolver" tlsC "github.com/Dreamacro/clash/component/tls" C "github.com/Dreamacro/clash/constant" @@ -238,6 +239,12 @@ func (v *Vless) DialContext(ctx context.Context, metadata *C.Metadata, opts ...d // DialContextWithDialer implements C.ProxyAdapter func (v *Vless) DialContextWithDialer(ctx context.Context, dialer C.Dialer, metadata *C.Metadata) (_ C.Conn, err error) { + if len(v.option.DialerProxy) > 0 { + dialer, err = proxydialer.NewByName(v.option.DialerProxy, dialer) + if err != nil { + return nil, err + } + } c, err := dialer.DialContext(ctx, "tcp", v.addr) if err != nil { return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error()) @@ -297,6 +304,12 @@ func (v *Vless) ListenPacketContext(ctx context.Context, metadata *C.Metadata, o // ListenPacketWithDialer implements C.ProxyAdapter func (v *Vless) ListenPacketWithDialer(ctx context.Context, dialer C.Dialer, metadata *C.Metadata) (_ C.PacketConn, err error) { + if len(v.option.DialerProxy) > 0 { + dialer, err = proxydialer.NewByName(v.option.DialerProxy, dialer) + if err != nil { + return nil, err + } + } // vless use stream-oriented udp with a special address, so we need a net.UDPAddr if !metadata.Resolved() { ip, err := resolver.ResolveIP(ctx, metadata.Host) @@ -538,7 +551,15 @@ func NewVless(option VlessOption) (*Vless, error) { } case "grpc": dialFn := func(network, addr string) (net.Conn, error) { - c, err := dialer.DialContext(context.Background(), "tcp", v.addr, v.Base.DialOptions()...) + var err error + var cDialer C.Dialer = dialer.NewDialer(v.Base.DialOptions()...) + if len(v.option.DialerProxy) > 0 { + cDialer, err = proxydialer.NewByName(v.option.DialerProxy, cDialer) + if err != nil { + return nil, err + } + } + c, err := cDialer.DialContext(context.Background(), "tcp", v.addr) if err != nil { return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error()) } diff --git a/adapter/outbound/vmess.go b/adapter/outbound/vmess.go index 5bb46dad..048b381c 100644 --- a/adapter/outbound/vmess.go +++ b/adapter/outbound/vmess.go @@ -13,6 +13,7 @@ import ( N "github.com/Dreamacro/clash/common/net" "github.com/Dreamacro/clash/component/dialer" + "github.com/Dreamacro/clash/component/proxydialer" "github.com/Dreamacro/clash/component/resolver" tlsC "github.com/Dreamacro/clash/component/tls" C "github.com/Dreamacro/clash/constant" @@ -263,6 +264,12 @@ func (v *Vmess) DialContext(ctx context.Context, metadata *C.Metadata, opts ...d // DialContextWithDialer implements C.ProxyAdapter func (v *Vmess) DialContextWithDialer(ctx context.Context, dialer C.Dialer, metadata *C.Metadata) (_ C.Conn, err error) { + if len(v.option.DialerProxy) > 0 { + dialer, err = proxydialer.NewByName(v.option.DialerProxy, dialer) + if err != nil { + return nil, err + } + } c, err := dialer.DialContext(ctx, "tcp", v.addr) if err != nil { return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error()) @@ -329,6 +336,12 @@ func (v *Vmess) ListenPacketContext(ctx context.Context, metadata *C.Metadata, o // ListenPacketWithDialer implements C.ProxyAdapter func (v *Vmess) ListenPacketWithDialer(ctx context.Context, dialer C.Dialer, metadata *C.Metadata) (_ C.PacketConn, err error) { + if len(v.option.DialerProxy) > 0 { + dialer, err = proxydialer.NewByName(v.option.DialerProxy, dialer) + if err != nil { + return nil, err + } + } // vmess use stream-oriented udp with a special address, so we need a net.UDPAddr if !metadata.Resolved() { ip, err := resolver.ResolveIP(ctx, metadata.Host) @@ -428,7 +441,15 @@ func NewVmess(option VmessOption) (*Vmess, error) { } case "grpc": dialFn := func(network, addr string) (net.Conn, error) { - c, err := dialer.DialContext(context.Background(), "tcp", v.addr, v.Base.DialOptions()...) + var err error + var cDialer C.Dialer = dialer.NewDialer(v.Base.DialOptions()...) + if len(v.option.DialerProxy) > 0 { + cDialer, err = proxydialer.NewByName(v.option.DialerProxy, cDialer) + if err != nil { + return nil, err + } + } + c, err := cDialer.DialContext(context.Background(), "tcp", v.addr) if err != nil { return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error()) } diff --git a/adapter/outbound/wireguard.go b/adapter/outbound/wireguard.go index 2eb56210..9a302de5 100644 --- a/adapter/outbound/wireguard.go +++ b/adapter/outbound/wireguard.go @@ -49,7 +49,6 @@ type WireGuardOption struct { MTU int `proxy:"mtu,omitempty"` UDP bool `proxy:"udp,omitempty"` PersistentKeepalive int `proxy:"persistent-keepalive,omitempty"` - DialerProxy string `proxy:"dialer-proxy,omitempty"` Peers []WireGuardPeerOption `proxy:"peers,omitempty"` }