chore: add test case

adjust buff size,same as sing

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,82 +0,0 @@
-name: Bug report
-description: Create a report to help us improve
-title: "[Bug] "
-body:
-  - type: checkboxes
-    id: ensure
-    attributes:
-      label: Verify steps
-      description: "
-在提交之前，请确认
-Please verify that you've followed these steps
-"
-      options:
-        - label: "
-确保你使用的是**本仓库**最新的的 clash 或 clash Alpha 版本
-Ensure you are using the latest version of Clash or Clash Premium from **this repository**.
-"
-          required: true
-        - label: "
-如果你可以自己 debug 并解决的话，提交 PR 吧
-Is this something you can **debug and fix**? Send a pull request! Bug fixes and documentation fixes are welcome.
-"
-          required: false
-        - label: "
-我已经在 [Issue Tracker](……/) 中找过我要提出的问题
-I have searched on the [issue tracker](……/) for a related issue.
-"
-          required: true
-        - label: "
-我已经使用 Alpha 分支版本测试过，问题依旧存在
-I have tested using the dev branch, and the issue still exists.
-"
-          required: true
-        - label: "
-我已经仔细看过 [Documentation](https://wiki.metacubex.one/) 并无法自行解决问题
-I have read the [documentation](https://wiki.metacubex.one/) and was unable to solve the issue.
-"
-          required: true
-        - label: "
-这是 Clash 核心的问题，并非我所使用的 Clash 衍生版本（如 OpenClash、KoolClash 等）的特定问题
-This is an issue of the Clash core *per se*, not to the derivatives of Clash, like OpenClash or KoolClash.
-"
-          required: true
-  - type: input
-    attributes:
-      label: Clash version
-      description: "use `clash -v`"
-    validations:
-      required: true
-  - type: dropdown
-    id: os
-    attributes:
-      label: What OS are you seeing the problem on?
-      multiple: true
-      options:
-        - macOS
-        - Windows
-        - Linux
-        - OpenBSD/FreeBSD
-  - type: textarea
-    attributes:
-      render: yaml
-      label: "Clash config"
-      description: "
-在下方附上 Clash core 配置文件，请确保配置文件中没有敏感信息（比如：服务器地址，密码，端口等）
-Paste the Clash core configuration file below, please make sure that there is no sensitive information in the configuration file (e.g., server address/url, password, port)
-"
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      render: shell
-      label: Clash log
-      description: "
-在下方附上 Clash Core 的日志，log level 使用 DEBUG
-Paste the Clash core log below with the log level set to `DEBUG`.
-"
-  - type: textarea
-    attributes:
-      label: Description
-    validations:
-      required: true

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,36 +0,0 @@
-name: Feature request
-description: Suggest an idea for this project
-title: "[Feature] "
-body:
-  - type: checkboxes
-    id: ensure
-    attributes:
-      label: Verify steps
-      description: "
-在提交之前，请确认
-Please verify that you've followed these steps
-"
-      options:
-        - label: "
-我已经在 [Issue Tracker](……/) 中找过我要提出的请求
-I have searched on the [issue tracker](……/) for a related feature request.
-"
-          required: true
-        - label: "
-我已经仔细看过 [Documentation](https://wiki.metacubex.one/) 并无法找到这个功能
-I have read the [documentation](https://wiki.metacubex.one/) and was unable to solve the issue.
-"
-          required: true
-  - type: textarea
-    attributes:
-      label: Description
-      description: 请详细、清晰地表达你要提出的论述，例如这个问题如何影响到你？你想实现什么功能？目前 Clash Core 的行为是什麽？
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: Possible Solution
-      description: "
-此项非必须，但是如果你有想法的话欢迎提出。
-Not obligatory, but suggest a fix/reason for the bug, or ideas how to implement the addition or change
-"

.github/genReleaseNote.sh

@@ -1 +0,0 @@
-git log --pretty=format:"* %s by @%an" v1.14.x..v1.14.y | sort -f | uniq > release.md

.github/workflows/build.yml

@@ -5,14 +5,17 @@ on:
     paths-ignore:
       - "docs/**"
       - "README.md"
-      - ".github/ISSUE_TEMPLATE/**"
     branches:
       - Alpha
+      - Beta
+      - Meta
     tags:
       - "v*"
   pull_request_target:
     branches:
       - Alpha
+      - Beta
+      - Meta
       
 concurrency:
   group: ${{ github.ref }}-${{ github.workflow }}
@@ -126,7 +129,7 @@ jobs:
         shell: bash
 
       - name: Setup Go
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@v3
         with:
           go-version: "1.20"
           check-latest: true
@@ -223,7 +226,7 @@ jobs:
         working-directory: bin
 
       - name: Delete current release assets
-        uses: 8Mi-Tech/delete-release-assets-action@main
+        uses: andreaswilli/delete-release-assets-action@v2.0.0
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           tag: Prerelease-${{ github.ref_name }}
@@ -246,14 +249,18 @@ jobs:
           Release created at  ${{ env.BUILDTIME }}
           Synchronize ${{ github.ref_name }} branch code updates, keeping only the latest version
           <br>
-          [我应该下载哪个文件? / Which file should I download?](https://github.com/MetaCubeX/Clash.Meta/wiki/FAQ)
-          [查看文档 / Docs](https://metacubex.github.io/Meta-Docs/)
+          ### release version
+          `default(not specified in file name)`: compiled with GOAMD64=v3
+          `cgo`: support lwip tun stack, compiled with GOAMD64=v1
+          `compatible`: compiled with GOAMD64=v1
+          Check details between different architectural levels [here](https://github.com/golang/go/wiki/MinimumRequirements#amd64).
           EOF
 
       - name: Upload Prerelease
         uses: softprops/action-gh-release@v1
         if: ${{  success() }}
         with:
+          tag: ${{ github.ref_name }}
           tag_name: Prerelease-${{ github.ref_name }}
           files: |
             bin/*
@@ -261,6 +268,18 @@ jobs:
           generate_release_notes: true
           body_path: release.txt
 
+      - name: Git push assets to "release" branch
+        run: |
+          cd bin || exit 1
+          git init
+          git config --local user.name "github-actions[bot]"
+          git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git checkout -b release
+          git add .
+          git commit -m "${{ env.BUILDTIME }}"
+          git remote add origin "https://${{ github.actor }}:${{ secrets.GITHUB_TOKEN }}@github.com/${{ github.repository }}"
+          git push -f -u origin release
+
   Upload-Release:
     permissions: write-all
     if: ${{ github.ref_type=='tag' }}
@@ -280,6 +299,7 @@ jobs:
         uses: softprops/action-gh-release@v1
         if: ${{  success() }}
         with:
+          tag: ${{ github.ref_name }}
           tag_name: ${{ github.ref_name }}
           files: bin/*
           generate_release_notes: true
@@ -304,10 +324,10 @@ jobs:
         working-directory: bin
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
+        uses: docker/setup-qemu-action@v1
 
       - name: Setup Docker buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v1
         with:
           version: latest
 
@@ -315,7 +335,7 @@ jobs:
       # https://github.com/docker/metadata-action
       - name: Extract Docker metadata
         id: meta
-        uses: docker/metadata-action@v4
+        uses: docker/metadata-action@v3
         with:
           images: ${{ env.REGISTRY }}/${{ secrets.DOCKERHUB_ACCOUNT }}/${{secrets.DOCKERHUB_REPO}}
       - name: Show files
@@ -324,7 +344,7 @@ jobs:
           ls bin/
       - name: Log into registry
         if: github.event_name != 'pull_request'
-        uses: docker/login-action@v2
+        uses: docker/login-action@v1
         with:
           registry: ${{ env.REGISTRY }}
           username: ${{ secrets.DOCKER_HUB_USER }}
@@ -334,7 +354,7 @@ jobs:
       # https://github.com/docker/build-push-action
       - name: Build and push Docker image
         id: build-and-push
-        uses: docker/build-push-action@v4
+        uses: docker/build-push-action@v2
         with:
           context: .
           file: ./Dockerfile

.github/workflows/delete.yml

@@ -1,15 +0,0 @@
-name: Delete old workflow runs
-on:
-  schedule:
-    - cron: "0 0 * * SUN"
-
-jobs:
-  del_runs:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Delete workflow runs
-        uses: GitRML/delete-workflow-runs@main
-        with:
-          token: ${{ secrets.AUTH_PAT }}
-          repository: ${{ github.repository }}
-          retain_days: 30

README.md

@@ -30,7 +30,8 @@
 - Comprehensive HTTP RESTful API controller
 
 ## Wiki
-Configuration examples can be found at [/docs/config.yaml](https://github.com/MetaCubeX/Clash.Meta/blob/Alpha/docs/config.yaml), while documentation can be found [Clash.Meta Wiki](https://clash-meta.wiki).
+
+Documentation and configuring examples are available on [Clash.Meta Wiki](https://clash-meta.wiki).
 
 ## Build
 

adapter/adapter.go

@@ -4,16 +4,16 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"github.com/Dreamacro/clash/common/queue"
+	"github.com/Dreamacro/clash/component/dialer"
+	C "github.com/Dreamacro/clash/constant"
 	"net"
 	"net/http"
 	"net/netip"
 	"net/url"
 	"time"
 
-	"github.com/Dreamacro/clash/common/atomic"
-	"github.com/Dreamacro/clash/common/queue"
-	"github.com/Dreamacro/clash/component/dialer"
-	C "github.com/Dreamacro/clash/constant"
+	"go.uber.org/atomic"
 )
 
 var UnifiedDelay = atomic.NewBool(false)

adapter/inbound/addition.go

@@ -16,12 +16,6 @@ func WithInName(name string) Addition {
 	}
 }
 
-func WithInUser(user string) Addition {
-	return func(metadata *C.Metadata) {
-		metadata.InUser = user
-	}
-}
-
 func WithSpecialRules(specialRules string) Addition {
 	return func(metadata *C.Metadata) {
 		metadata.SpecialRules = specialRules

adapter/inbound/socket.go

@@ -30,18 +30,19 @@ func NewSocket(target socks5.Addr, conn net.Conn, source C.Type, additions ...Ad
 	return context.NewConnContext(conn, metadata)
 }
 
-func NewInner(conn net.Conn, address string) *context.ConnContext {
+func NewInner(conn net.Conn, dst string, host string) *context.ConnContext {
 	metadata := &C.Metadata{}
 	metadata.NetWork = C.TCP
 	metadata.Type = C.INNER
 	metadata.DNSMode = C.DNSNormal
+	metadata.Host = host
 	metadata.Process = C.ClashName
-	if h, port, err := net.SplitHostPort(address); err == nil {
+	if h, port, err := net.SplitHostPort(dst); err == nil {
 		metadata.DstPort = port
+		if host == "" {
 			if ip, err := netip.ParseAddr(h); err == nil {
 				metadata.DstIP = ip
-		} else {
-			metadata.Host = h
+			}
 		}
 	}
 

adapter/outbound/base.go

@@ -3,9 +3,9 @@ package outbound
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"net"
 	"strings"
-	"syscall"
 
 	N "github.com/Dreamacro/clash/common/net"
 	"github.com/Dreamacro/clash/common/utils"
@@ -45,33 +45,33 @@ func (b *Base) Type() C.AdapterType {
 	return b.tp
 }
 
-// StreamConnContext implements C.ProxyAdapter
-func (b *Base) StreamConnContext(ctx context.Context, c net.Conn, metadata *C.Metadata) (net.Conn, error) {
-	return c, C.ErrNotSupport
+// StreamConn implements C.ProxyAdapter
+func (b *Base) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
+	return c, errors.New("no support")
 }
 
 func (b *Base) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.Conn, error) {
-	return nil, C.ErrNotSupport
+	return nil, errors.New("no support")
 }
 
 // DialContextWithDialer implements C.ProxyAdapter
 func (b *Base) DialContextWithDialer(ctx context.Context, dialer C.Dialer, metadata *C.Metadata) (_ C.Conn, err error) {
-	return nil, C.ErrNotSupport
+	return nil, errors.New("no support")
 }
 
 // ListenPacketContext implements C.ProxyAdapter
 func (b *Base) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.PacketConn, error) {
-	return nil, C.ErrNotSupport
+	return nil, errors.New("no support")
 }
 
 // ListenPacketWithDialer implements C.ProxyAdapter
 func (b *Base) ListenPacketWithDialer(ctx context.Context, dialer C.Dialer, metadata *C.Metadata) (_ C.PacketConn, err error) {
-	return nil, C.ErrNotSupport
+	return nil, errors.New("no support")
 }
 
 // SupportWithDialer implements C.ProxyAdapter
-func (b *Base) SupportWithDialer() C.NetWork {
-	return C.InvalidNet
+func (b *Base) SupportWithDialer() bool {
+	return false
 }
 
 // SupportUOT implements C.ProxyAdapter
@@ -94,11 +94,6 @@ func (b *Base) SupportTFO() bool {
 	return b.tfo
 }
 
-// IsL3Protocol implements C.ProxyAdapter
-func (b *Base) IsL3Protocol(metadata *C.Metadata) bool {
-	return false
-}
-
 // MarshalJSON implements C.ProxyAdapter
 func (b *Base) MarshalJSON() ([]byte, error) {
 	return json.Marshal(map[string]string{
@@ -151,7 +146,6 @@ 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 {
@@ -204,23 +198,12 @@ func (c *conn) Upstream() any {
 	return c.ExtendedConn
 }
 
-func (c *conn) WriterReplaceable() bool {
-	return true
-}
-
-func (c *conn) ReaderReplaceable() bool {
-	return true
-}
-
 func NewConn(c net.Conn, a C.ProxyAdapter) C.Conn {
-	if _, ok := c.(syscall.Conn); !ok { // exclusion system conn like *net.TCPConn
-		c = N.NewDeadlineConn(c) // most conn from outbound can't handle readDeadline correctly
-	}
 	return &conn{N.NewExtendedConn(c), []string{a.Name()}, parseRemoteDestination(a.Addr())}
 }
 
 type packetConn struct {
-	N.EnhancePacketConn
+	net.PacketConn
 	chain                   C.Chain
 	adapterName             string
 	connID                  string
@@ -242,28 +225,12 @@ func (c *packetConn) AppendToChains(a C.ProxyAdapter) {
 }
 
 func (c *packetConn) LocalAddr() net.Addr {
-	lAddr := c.EnhancePacketConn.LocalAddr()
+	lAddr := c.PacketConn.LocalAddr()
 	return N.NewCustomAddr(c.adapterName, c.connID, lAddr) // make quic-go's connMultiplexer happy
 }
 
-func (c *packetConn) Upstream() any {
-	return c.EnhancePacketConn
-}
-
-func (c *packetConn) WriterReplaceable() bool {
-	return true
-}
-
-func (c *packetConn) ReaderReplaceable() bool {
-	return true
-}
-
 func newPacketConn(pc net.PacketConn, a C.ProxyAdapter) C.PacketConn {
-	epc := N.NewEnhancePacketConn(pc)
-	if _, ok := pc.(syscall.Conn); !ok { // exclusion system conn like *net.UDPConn
-		epc = N.NewDeadlineEnhancePacketConn(epc) // most conn from outbound can't handle readDeadline correctly
-	}
-	return &packetConn{epc, []string{a.Name()}, a.Name(), utils.NewUUIDV4().String(), parseRemoteDestination(a.Addr())}
+	return &packetConn{pc, []string{a.Name()}, a.Name(), utils.NewUUIDV4().String(), parseRemoteDestination(a.Addr())}
 }
 
 func parseRemoteDestination(addr string) string {

adapter/outbound/direct.go

@@ -2,7 +2,8 @@ package outbound
 
 import (
 	"context"
-	"errors"
+	"net"
+
 	"github.com/Dreamacro/clash/component/dialer"
 	"github.com/Dreamacro/clash/component/resolver"
 	C "github.com/Dreamacro/clash/constant"
@@ -25,19 +26,16 @@ func (d *Direct) DialContext(ctx context.Context, metadata *C.Metadata, opts ...
 
 // ListenPacketContext implements C.ProxyAdapter
 func (d *Direct) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.PacketConn, error) {
-	// net.UDPConn.WriteTo only working with *net.UDPAddr, so we need a net.UDPAddr
-	if !metadata.Resolved() {
-		ip, err := resolver.ResolveIPWithResolver(ctx, metadata.Host, resolver.DefaultResolver)
-		if err != nil {
-			return nil, errors.New("can't resolve ip")
-		}
-		metadata.DstIP = ip
-	}
+	opts = append(opts, dialer.WithResolver(resolver.DefaultResolver))
 	pc, err := dialer.ListenPacket(ctx, dialer.ParseNetwork("udp", metadata.DstIP), "", d.Base.DialOptions(opts...)...)
 	if err != nil {
 		return nil, err
 	}
-	return newPacketConn(pc, d), nil
+	return newPacketConn(&directPacketConn{pc}, d), nil
+}
+
+type directPacketConn struct {
+	net.PacketConn
 }
 
 func NewDirect() *Direct {

adapter/outbound/http.go

@@ -10,10 +10,10 @@ import (
 	"io"
 	"net"
 	"net/http"
+	"net/url"
 	"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"
 )
@@ -40,10 +40,12 @@ type HttpOption struct {
 	Headers        map[string]string `proxy:"headers,omitempty"`
 }
 
-// StreamConnContext implements C.ProxyAdapter
-func (h *Http) StreamConnContext(ctx context.Context, c net.Conn, metadata *C.Metadata) (net.Conn, error) {
+// StreamConn implements C.ProxyAdapter
+func (h *Http) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
 	if h.tlsConfig != nil {
 		cc := tls.Client(c, h.tlsConfig)
+		ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
+		defer cancel()
 		err := cc.HandshakeContext(ctx)
 		c = cc
 		if err != nil {
@@ -64,12 +66,6 @@ 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)
@@ -80,7 +76,7 @@ func (h *Http) DialContextWithDialer(ctx context.Context, dialer C.Dialer, metad
 		safeConnClose(c, err)
 	}(c)
 
-	c, err = h.StreamConnContext(ctx, c, metadata)
+	c, err = h.StreamConn(c, metadata)
 	if err != nil {
 		return nil, err
 	}
@@ -89,42 +85,40 @@ func (h *Http) DialContextWithDialer(ctx context.Context, dialer C.Dialer, metad
 }
 
 // SupportWithDialer implements C.ProxyAdapter
-func (h *Http) SupportWithDialer() C.NetWork {
-	return C.TCP
+func (h *Http) SupportWithDialer() bool {
+	return true
 }
 
 func (h *Http) shakeHand(metadata *C.Metadata, rw io.ReadWriter) error {
 	addr := metadata.RemoteAddress()
-	HeaderString := "CONNECT " + addr + " HTTP/1.1\r\n"
-	tempHeaders := map[string]string{
-		"Host":             addr,
-		"User-Agent":       "Go-http-client/1.1",
-		"Proxy-Connection": "Keep-Alive",
+	req := &http.Request{
+		Method: http.MethodConnect,
+		URL: &url.URL{
+			Host: addr,
+		},
+		Host: addr,
+		Header: http.Header{
+			"Proxy-Connection": []string{"Keep-Alive"},
+		},
 	}
 
+	//增加headers
+	if len(h.option.Headers) != 0 {
 		for key, value := range h.option.Headers {
-		tempHeaders[key] = value
+			req.Header.Add(key, value)
+		}
 	}
 
 	if h.user != "" && h.pass != "" {
 		auth := h.user + ":" + h.pass
-		tempHeaders["Proxy-Authorization"] = "Basic " + base64.StdEncoding.EncodeToString([]byte(auth))
+		req.Header.Add("Proxy-Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(auth)))
 	}
 
-	for key, value := range tempHeaders {
-		HeaderString += key + ": " + value + "\r\n"
-	}
-
-	HeaderString += "\r\n"
-
-	_, err := rw.Write([]byte(HeaderString))
-
-	if err != nil {
+	if err := req.Write(rw); err != nil {
 		return err
 	}
 
-	resp, err := http.ReadResponse(bufio.NewReader(rw), nil)
-
+	resp, err := http.ReadResponse(bufio.NewReader(rw), req)
 	if err != nil {
 		return err
 	}

adapter/outbound/hysteria.go

@@ -20,7 +20,6 @@ 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"
@@ -29,7 +28,6 @@ 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 (
@@ -48,12 +46,21 @@ 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) {
-	tcpConn, err := h.client.DialTCP(metadata.RemoteAddress(), h.genHdc(ctx, opts...))
+	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)
 	if err != nil {
 		return nil, err
 	}
@@ -62,32 +69,20 @@ 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) {
-	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{
+	hdc := hyDialerWithContext{
 		ctx: context.Background(),
 		hyDialer: func(network string) (net.PacketConn, error) {
-			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)
+			return dialer.ListenPacket(ctx, network, "", h.Base.DialOptions(opts...)...)
 		},
 		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 {
@@ -263,7 +258,6 @@ func NewHysteria(option HysteriaOption) (*Hysteria, error) {
 			rmark:  option.RoutingMark,
 			prefer: C.NewDNSPrefer(option.IPVersion),
 		},
-		option: &option,
 		client: client,
 	}, nil
 }
@@ -318,16 +312,6 @@ func (c *hyPacketConn) ReadFrom(p []byte) (n int, addr net.Addr, err error) {
 	return
 }
 
-func (c *hyPacketConn) WaitReadFrom() (data []byte, put func(), addr net.Addr, err error) {
-	b, addrStr, err := c.UDPConn.ReadFrom()
-	if err != nil {
-		return
-	}
-	data = b
-	addr = M.ParseSocksaddr(addrStr).UDPAddr()
-	return
-}
-
 func (c *hyPacketConn) WriteTo(p []byte, addr net.Addr) (n int, err error) {
 	err = c.UDPConn.WriteTo(p, M.SocksaddrFromNet(addr).String())
 	if err != nil {

adapter/outbound/reject.go

@@ -78,9 +78,6 @@ type nopPacketConn struct{}
 
 func (npc nopPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) { return len(b), nil }
 func (npc nopPacketConn) ReadFrom(b []byte) (int, net.Addr, error)           { return 0, nil, io.EOF }
-func (npc nopPacketConn) WaitReadFrom() ([]byte, func(), net.Addr, error) {
-	return nil, nil, nil, io.EOF
-}
 func (npc nopPacketConn) Close() error                                       { return nil }
 func (npc nopPacketConn) LocalAddr() net.Addr                                { return udpAddrIPv4Unspecified }
 func (npc nopPacketConn) SetDeadline(time.Time) error                        { return nil }

adapter/outbound/shadowsocks.go

@@ -6,20 +6,22 @@ import (
 	"fmt"
 	"net"
 	"strconv"
+	"time"
 
 	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"
-	"github.com/Dreamacro/clash/component/resolver"
 	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/transport/restls"
 	obfs "github.com/Dreamacro/clash/transport/simple-obfs"
 	shadowtls "github.com/Dreamacro/clash/transport/sing-shadowtls"
+	"github.com/Dreamacro/clash/transport/socks5"
 	v2rayObfs "github.com/Dreamacro/clash/transport/v2ray-plugin"
 
 	restlsC "github.com/3andne/restls-client-go"
-	"github.com/metacubex/sing-shadowsocks2"
+	shadowsocks "github.com/metacubex/sing-shadowsocks"
+	"github.com/metacubex/sing-shadowsocks/shadowimpl"
+	"github.com/sagernet/sing/common/bufio"
 	M "github.com/sagernet/sing/common/metadata"
 	"github.com/sagernet/sing/common/uot"
 )
@@ -83,7 +85,14 @@ type restlsOption struct {
 	RestlsScript string `obfs:"restls-script,omitempty"`
 }
 
-// StreamConnContext implements C.ProxyAdapter
+// StreamConn implements C.ProxyAdapter
+func (ss *ShadowSocks) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
+	// fix tls handshake not timeout
+	ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
+	defer cancel()
+	return ss.StreamConnContext(ctx, c, metadata)
+}
+
 func (ss *ShadowSocks) StreamConnContext(ctx context.Context, c net.Conn, metadata *C.Metadata) (net.Conn, error) {
 	useEarly := false
 	switch ss.obfsMode {
@@ -94,7 +103,7 @@ func (ss *ShadowSocks) StreamConnContext(ctx context.Context, c net.Conn, metada
 		c = obfs.NewHTTPObfs(c, ss.obfsOption.Host, port)
 	case "websocket":
 		var err error
-		c, err = v2rayObfs.NewV2rayObfs(ctx, c, ss.v2rayOption)
+		c, err = v2rayObfs.NewV2rayObfs(c, ss.v2rayOption)
 		if err != nil {
 			return nil, fmt.Errorf("%s connect error: %w", ss.addr, err)
 		}
@@ -136,12 +145,6 @@ 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)
@@ -163,18 +166,17 @@ 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 {
 			return nil, err
 		}
-		return ss.ListenPacketOnStreamConn(ctx, tcpConn, metadata)
+		destination := M.ParseSocksaddr(metadata.RemoteAddress())
+		if ss.option.UDPOverTCPVersion == 1 {
+			return newPacketConn(uot.NewConn(tcpConn, uot.Request{Destination: destination}), ss), nil
+		} else {
+			return newPacketConn(uot.NewLazyConn(tcpConn, uot.Request{Destination: destination}), ss), nil
+		}
 	}
 	addr, err := resolveUDPAddrWithPrefer(ctx, "udp", ss.addr, ss.prefer)
 	if err != nil {
@@ -185,35 +187,26 @@ func (ss *ShadowSocks) ListenPacketWithDialer(ctx context.Context, dialer C.Dial
 	if err != nil {
 		return nil, err
 	}
-	pc = ss.method.DialPacketConn(N.NewBindPacketConn(pc, addr))
+	pc = ss.method.DialPacketConn(&bufio.BindPacketConn{PacketConn: pc, Addr: addr})
 	return newPacketConn(pc, ss), nil
 }
 
 // SupportWithDialer implements C.ProxyAdapter
-func (ss *ShadowSocks) SupportWithDialer() C.NetWork {
-	return C.ALLNet
+func (ss *ShadowSocks) SupportWithDialer() bool {
+	return true
 }
 
 // ListenPacketOnStreamConn implements C.ProxyAdapter
-func (ss *ShadowSocks) ListenPacketOnStreamConn(ctx context.Context, c net.Conn, metadata *C.Metadata) (_ C.PacketConn, err error) {
+func (ss *ShadowSocks) ListenPacketOnStreamConn(c net.Conn, metadata *C.Metadata) (_ C.PacketConn, err error) {
 	if ss.option.UDPOverTCP {
-		// ss uot use stream-oriented udp with a special address, so we need a net.UDPAddr
-		if !metadata.Resolved() {
-			ip, err := resolver.ResolveIP(ctx, metadata.Host)
-			if err != nil {
-				return nil, errors.New("can't resolve ip")
-			}
-			metadata.DstIP = ip
-		}
-
-		destination := M.SocksaddrFromNet(metadata.UDPAddr())
+		destination := M.ParseSocksaddr(metadata.RemoteAddress())
 		if ss.option.UDPOverTCPVersion == uot.LegacyVersion {
 			return newPacketConn(uot.NewConn(c, uot.Request{Destination: destination}), ss), nil
 		} else {
 			return newPacketConn(uot.NewLazyConn(c, uot.Request{Destination: destination}), ss), nil
 		}
 	}
-	return nil, C.ErrNotSupport
+	return nil, errors.New("no support")
 }
 
 // SupportUOT implements C.ProxyAdapter
@@ -223,9 +216,7 @@ func (ss *ShadowSocks) SupportUOT() bool {
 
 func NewShadowSocks(option ShadowSocksOption) (*ShadowSocks, error) {
 	addr := net.JoinHostPort(option.Server, strconv.Itoa(option.Port))
-	method, err := shadowsocks.CreateMethod(context.Background(), option.Cipher, shadowsocks.MethodOptions{
-		Password: option.Password,
-	})
+	method, err := shadowimpl.FetchMethod(option.Cipher, option.Password, time.Now)
 	if err != nil {
 		return nil, fmt.Errorf("ss %s initialize error: %w", addr, err)
 	}
@@ -303,7 +294,7 @@ func NewShadowSocks(option ShadowSocksOption) (*ShadowSocks, error) {
 	switch option.UDPOverTCPVersion {
 	case uot.Version, uot.LegacyVersion:
 	case 0:
-		option.UDPOverTCPVersion = uot.LegacyVersion
+		option.UDPOverTCPVersion = uot.Version
 	default:
 		return nil, fmt.Errorf("ss %s unknown udp over tcp protocol version: %d", addr, option.UDPOverTCPVersion)
 	}
@@ -329,3 +320,36 @@ func NewShadowSocks(option ShadowSocksOption) (*ShadowSocks, error) {
 		restlsConfig:    restlsConfig,
 	}, nil
 }
+
+type ssPacketConn struct {
+	net.PacketConn
+	rAddr net.Addr
+}
+
+func (spc *ssPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
+	packet, err := socks5.EncodeUDPPacket(socks5.ParseAddrToSocksAddr(addr), b)
+	if err != nil {
+		return
+	}
+	return spc.PacketConn.WriteTo(packet[3:], spc.rAddr)
+}
+
+func (spc *ssPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
+	n, _, e := spc.PacketConn.ReadFrom(b)
+	if e != nil {
+		return 0, nil, e
+	}
+
+	addr := socks5.SplitAddr(b[:n])
+	if addr == nil {
+		return 0, nil, errors.New("parse addr error")
+	}
+
+	udpAddr := addr.UDPAddr()
+	if udpAddr == nil {
+		return 0, nil, errors.New("parse addr error")
+	}
+
+	copy(b, b[len(addr):])
+	return n - len(addr), udpAddr, e
+}

adapter/outbound/shadowsocksr.go

@@ -2,26 +2,21 @@ package outbound
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"net"
 	"strconv"
 
-	N "github.com/Dreamacro/clash/common/net"
 	"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"
 	"github.com/Dreamacro/clash/transport/shadowsocks/shadowstream"
-	"github.com/Dreamacro/clash/transport/socks5"
 	"github.com/Dreamacro/clash/transport/ssr/obfs"
 	"github.com/Dreamacro/clash/transport/ssr/protocol"
 )
 
 type ShadowSocksR struct {
 	*Base
-	option   *ShadowSocksROption
 	cipher   core.Cipher
 	obfs     obfs.Obfs
 	protocol protocol.Protocol
@@ -41,8 +36,8 @@ type ShadowSocksROption struct {
 	UDP           bool   `proxy:"udp,omitempty"`
 }
 
-// StreamConnContext implements C.ProxyAdapter
-func (ssr *ShadowSocksR) StreamConnContext(ctx context.Context, c net.Conn, metadata *C.Metadata) (net.Conn, error) {
+// StreamConn implements C.ProxyAdapter
+func (ssr *ShadowSocksR) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
 	c = ssr.obfs.StreamConn(c)
 	c = ssr.cipher.StreamConn(c)
 	var (
@@ -70,12 +65,6 @@ 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,7 +75,7 @@ func (ssr *ShadowSocksR) DialContextWithDialer(ctx context.Context, dialer C.Dia
 		safeConnClose(c, err)
 	}(c)
 
-	c, err = ssr.StreamConnContext(ctx, c, metadata)
+	c, err = ssr.StreamConn(c, metadata)
 	return NewConn(c, ssr), err
 }
 
@@ -97,12 +86,6 @@ 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
@@ -113,14 +96,14 @@ func (ssr *ShadowSocksR) ListenPacketWithDialer(ctx context.Context, dialer C.Di
 		return nil, err
 	}
 
-	epc := ssr.cipher.PacketConn(N.NewEnhancePacketConn(pc))
-	epc = ssr.protocol.PacketConn(epc)
-	return newPacketConn(&ssrPacketConn{EnhancePacketConn: epc, rAddr: addr}, ssr), nil
+	pc = ssr.cipher.PacketConn(pc)
+	pc = ssr.protocol.PacketConn(pc)
+	return newPacketConn(&ssPacketConn{PacketConn: pc, rAddr: addr}, ssr), nil
 }
 
 // SupportWithDialer implements C.ProxyAdapter
-func (ssr *ShadowSocksR) SupportWithDialer() C.NetWork {
-	return C.ALLNet
+func (ssr *ShadowSocksR) SupportWithDialer() bool {
+	return true
 }
 
 func NewShadowSocksR(option ShadowSocksROption) (*ShadowSocksR, error) {
@@ -185,68 +168,8 @@ func NewShadowSocksR(option ShadowSocksROption) (*ShadowSocksR, error) {
 			rmark:  option.RoutingMark,
 			prefer: C.NewDNSPrefer(option.IPVersion),
 		},
-		option:   &option,
 		cipher:   coreCiph,
 		obfs:     obfs,
 		protocol: protocol,
 	}, nil
 }
-
-type ssrPacketConn struct {
-	N.EnhancePacketConn
-	rAddr net.Addr
-}
-
-func (spc *ssrPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
-	packet, err := socks5.EncodeUDPPacket(socks5.ParseAddrToSocksAddr(addr), b)
-	if err != nil {
-		return
-	}
-	return spc.EnhancePacketConn.WriteTo(packet[3:], spc.rAddr)
-}
-
-func (spc *ssrPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
-	n, _, e := spc.EnhancePacketConn.ReadFrom(b)
-	if e != nil {
-		return 0, nil, e
-	}
-
-	addr := socks5.SplitAddr(b[:n])
-	if addr == nil {
-		return 0, nil, errors.New("parse addr error")
-	}
-
-	udpAddr := addr.UDPAddr()
-	if udpAddr == nil {
-		return 0, nil, errors.New("parse addr error")
-	}
-
-	copy(b, b[len(addr):])
-	return n - len(addr), udpAddr, e
-}
-
-func (spc *ssrPacketConn) WaitReadFrom() (data []byte, put func(), addr net.Addr, err error) {
-	data, put, _, err = spc.EnhancePacketConn.WaitReadFrom()
-	if err != nil {
-		return nil, nil, nil, err
-	}
-
-	_addr := socks5.SplitAddr(data)
-	if _addr == nil {
-		if put != nil {
-			put()
-		}
-		return nil, nil, nil, errors.New("parse addr error")
-	}
-
-	addr = _addr.UDPAddr()
-	if addr == nil {
-		if put != nil {
-			put()
-		}
-		return nil, nil, nil, errors.New("parse addr error")
-	}
-
-	data = data[len(_addr):]
-	return
-}

adapter/outbound/singmux.go

@@ -1,138 +0,0 @@
-package outbound
-
-import (
-	"context"
-	"errors"
-	"net"
-	"runtime"
-
-	CN "github.com/Dreamacro/clash/common/net"
-	"github.com/Dreamacro/clash/component/dialer"
-	"github.com/Dreamacro/clash/component/proxydialer"
-	"github.com/Dreamacro/clash/component/resolver"
-	C "github.com/Dreamacro/clash/constant"
-
-	mux "github.com/sagernet/sing-mux"
-	E "github.com/sagernet/sing/common/exceptions"
-	M "github.com/sagernet/sing/common/metadata"
-	N "github.com/sagernet/sing/common/network"
-)
-
-type SingMux struct {
-	C.ProxyAdapter
-	base    ProxyBase
-	client  *mux.Client
-	dialer  *muxSingDialer
-	onlyTcp bool
-}
-
-type SingMuxOption struct {
-	Enabled        bool   `proxy:"enabled,omitempty"`
-	Protocol       string `proxy:"protocol,omitempty"`
-	MaxConnections int    `proxy:"max-connections,omitempty"`
-	MinStreams     int    `proxy:"min-streams,omitempty"`
-	MaxStreams     int    `proxy:"max-streams,omitempty"`
-	Padding        bool   `proxy:"padding,omitempty"`
-	Statistic      bool   `proxy:"statistic,omitempty"`
-	OnlyTcp        bool   `proxy:"only-tcp,omitempty"`
-}
-
-type ProxyBase interface {
-	DialOptions(opts ...dialer.Option) []dialer.Option
-}
-
-type muxSingDialer struct {
-	dialer    dialer.Dialer
-	proxy     C.ProxyAdapter
-	statistic bool
-}
-
-var _ N.Dialer = (*muxSingDialer)(nil)
-
-func (d *muxSingDialer) DialContext(ctx context.Context, network string, destination M.Socksaddr) (net.Conn, error) {
-	var cDialer C.Dialer = proxydialer.New(d.proxy, d.dialer, d.statistic)
-	return cDialer.DialContext(ctx, network, destination.String())
-}
-
-func (d *muxSingDialer) ListenPacket(ctx context.Context, destination M.Socksaddr) (net.PacketConn, error) {
-	var cDialer C.Dialer = proxydialer.New(d.proxy, d.dialer, d.statistic)
-	return cDialer.ListenPacket(ctx, "udp", "", destination.AddrPort())
-}
-
-func (s *SingMux) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (_ C.Conn, err error) {
-	options := s.base.DialOptions(opts...)
-	s.dialer.dialer = dialer.NewDialer(options...)
-	c, err := s.client.DialContext(ctx, "tcp", M.ParseSocksaddr(metadata.RemoteAddress()))
-	if err != nil {
-		return nil, err
-	}
-	return NewConn(CN.NewRefConn(c, s), s.ProxyAdapter), err
-}
-
-func (s *SingMux) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (_ C.PacketConn, err error) {
-	if s.onlyTcp {
-		return s.ProxyAdapter.ListenPacketContext(ctx, metadata, opts...)
-	}
-	options := s.base.DialOptions(opts...)
-	s.dialer.dialer = dialer.NewDialer(options...)
-
-	// sing-mux use stream-oriented udp with a special address, so we need a net.UDPAddr
-	if !metadata.Resolved() {
-		ip, err := resolver.ResolveIP(ctx, metadata.Host)
-		if err != nil {
-			return nil, errors.New("can't resolve ip")
-		}
-		metadata.DstIP = ip
-	}
-
-	pc, err := s.client.ListenPacket(ctx, M.SocksaddrFromNet(metadata.UDPAddr()))
-	if err != nil {
-		return nil, err
-	}
-	if pc == nil {
-		return nil, E.New("packetConn is nil")
-	}
-	return newPacketConn(CN.NewRefPacketConn(CN.NewThreadSafePacketConn(pc), s), s.ProxyAdapter), nil
-}
-
-func (s *SingMux) SupportUDP() bool {
-	if s.onlyTcp {
-		return s.ProxyAdapter.SupportUOT()
-	}
-	return true
-}
-
-func (s *SingMux) SupportUOT() bool {
-	if s.onlyTcp {
-		return s.ProxyAdapter.SupportUOT()
-	}
-	return true
-}
-
-func closeSingMux(s *SingMux) {
-	_ = s.client.Close()
-}
-
-func NewSingMux(option SingMuxOption, proxy C.ProxyAdapter, base ProxyBase) (C.ProxyAdapter, error) {
-	singDialer := &muxSingDialer{dialer: dialer.NewDialer(), proxy: proxy, statistic: option.Statistic}
-	client, err := mux.NewClient(mux.Options{
-		Dialer:         singDialer,
-		Protocol:       option.Protocol,
-		MaxConnections: option.MaxConnections,
-		MinStreams:     option.MinStreams,
-		MaxStreams:     option.MaxStreams,
-		Padding:        option.Padding,
-	})
-	if err != nil {
-		return nil, err
-	}
-	outbound := &SingMux{
-		ProxyAdapter: proxy,
-		base:         base,
-		client:       client,
-		dialer:       singDialer,
-		onlyTcp:      option.OnlyTcp,
-	}
-	runtime.SetFinalizer(outbound, closeSingMux)
-	return outbound, nil
-}

adapter/outbound/snell.go

@@ -8,7 +8,6 @@ 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"
@@ -16,7 +15,6 @@ import (
 
 type Snell struct {
 	*Base
-	option     *SnellOption
 	psk        []byte
 	pool       *snell.Pool
 	obfsOption *simpleObfsOption
@@ -52,8 +50,8 @@ func streamConn(c net.Conn, option streamOption) *snell.Snell {
 	return snell.StreamConn(c, option.psk, option.version)
 }
 
-// StreamConnContext implements C.ProxyAdapter
-func (s *Snell) StreamConnContext(ctx context.Context, c net.Conn, metadata *C.Metadata) (net.Conn, error) {
+// StreamConn implements C.ProxyAdapter
+func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
 	c = streamConn(c, streamOption{s.psk, s.version, s.addr, s.obfsOption})
 	if metadata.NetWork == C.UDP {
 		err := snell.WriteUDPHeader(c, s.version)
@@ -85,12 +83,6 @@ 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)
@@ -101,7 +93,7 @@ func (s *Snell) DialContextWithDialer(ctx context.Context, dialer C.Dialer, meta
 		safeConnClose(c, err)
 	}(c)
 
-	c, err = s.StreamConnContext(ctx, c, metadata)
+	c, err = s.StreamConn(c, metadata)
 	return NewConn(c, s), err
 }
 
@@ -112,13 +104,6 @@ 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
@@ -136,8 +121,8 @@ func (s *Snell) ListenPacketWithDialer(ctx context.Context, dialer C.Dialer, met
 }
 
 // SupportWithDialer implements C.ProxyAdapter
-func (s *Snell) SupportWithDialer() C.NetWork {
-	return C.ALLNet
+func (s *Snell) SupportWithDialer() bool {
+	return true
 }
 
 // SupportUOT implements C.ProxyAdapter
@@ -187,7 +172,6 @@ func NewSnell(option SnellOption) (*Snell, error) {
 			rmark:  option.RoutingMark,
 			prefer: C.NewDNSPrefer(option.IPVersion),
 		},
-		option:     &option,
 		psk:        psk,
 		obfsOption: obfsOption,
 		version:    option.Version,
@@ -195,15 +179,7 @@ func NewSnell(option SnellOption) (*Snell, error) {
 
 	if option.Version == snell.Version2 {
 		s.pool = snell.NewPool(func(ctx context.Context) (*snell.Snell, error) {
-			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)
+			c, err := dialer.DialContext(ctx, "tcp", addr, s.Base.DialOptions()...)
 			if err != nil {
 				return nil, err
 			}

adapter/outbound/socks5.go

@@ -10,7 +10,6 @@ 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"
@@ -18,7 +17,6 @@ import (
 
 type Socks5 struct {
 	*Base
-	option         *Socks5Option
 	user           string
 	pass           string
 	tls            bool
@@ -39,10 +37,12 @@ type Socks5Option struct {
 	Fingerprint    string `proxy:"fingerprint,omitempty"`
 }
 
-// StreamConnContext implements C.ProxyAdapter
-func (ss *Socks5) StreamConnContext(ctx context.Context, c net.Conn, metadata *C.Metadata) (net.Conn, error) {
+// StreamConn implements C.ProxyAdapter
+func (ss *Socks5) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
 	if ss.tls {
 		cc := tls.Client(c, ss.tlsConfig)
+		ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
+		defer cancel()
 		err := cc.HandshakeContext(ctx)
 		c = cc
 		if err != nil {
@@ -70,12 +70,6 @@ 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)
@@ -86,7 +80,7 @@ func (ss *Socks5) DialContextWithDialer(ctx context.Context, dialer C.Dialer, me
 		safeConnClose(c, err)
 	}(c)
 
-	c, err = ss.StreamConnContext(ctx, c, metadata)
+	c, err = ss.StreamConn(c, metadata)
 	if err != nil {
 		return nil, err
 	}
@@ -95,20 +89,13 @@ func (ss *Socks5) DialContextWithDialer(ctx context.Context, dialer C.Dialer, me
 }
 
 // SupportWithDialer implements C.ProxyAdapter
-func (ss *Socks5) SupportWithDialer() C.NetWork {
-	return C.TCP
+func (ss *Socks5) SupportWithDialer() bool {
+	return true
 }
 
 // ListenPacketContext implements C.ProxyAdapter
 func (ss *Socks5) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (_ C.PacketConn, err error) {
-	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)
+	c, err := dialer.DialContext(ctx, "tcp", ss.addr, ss.Base.DialOptions(opts...)...)
 	if err != nil {
 		err = fmt.Errorf("%s connect error: %w", ss.addr, err)
 		return
@@ -200,7 +187,6 @@ 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,

adapter/outbound/trojan.go

@@ -8,8 +8,8 @@ import (
 	"net/http"
 	"strconv"
 
+	N "github.com/Dreamacro/clash/common/net"
 	"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"
@@ -50,7 +50,7 @@ type TrojanOption struct {
 	ClientFingerprint string         `proxy:"client-fingerprint,omitempty"`
 }
 
-func (t *Trojan) plainStream(ctx context.Context, c net.Conn) (net.Conn, error) {
+func (t *Trojan) plainStream(c net.Conn) (net.Conn, error) {
 	if t.option.Network == "ws" {
 		host, port, _ := net.SplitHostPort(t.addr)
 		wsOpts := &trojan.WebsocketOption{
@@ -71,14 +71,14 @@ func (t *Trojan) plainStream(ctx context.Context, c net.Conn) (net.Conn, error)
 			wsOpts.Headers = header
 		}
 
-		return t.instance.StreamWebsocketConn(ctx, c, wsOpts)
+		return t.instance.StreamWebsocketConn(c, wsOpts)
 	}
 
-	return t.instance.StreamConn(ctx, c)
+	return t.instance.StreamConn(c)
 }
 
-// StreamConnContext implements C.ProxyAdapter
-func (t *Trojan) StreamConnContext(ctx context.Context, c net.Conn, metadata *C.Metadata) (net.Conn, error) {
+// StreamConn implements C.ProxyAdapter
+func (t *Trojan) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
 	var err error
 
 	if tlsC.HaveGlobalFingerprint() && len(t.option.ClientFingerprint) == 0 {
@@ -88,7 +88,7 @@ func (t *Trojan) StreamConnContext(ctx context.Context, c net.Conn, metadata *C.
 	if t.transport != nil {
 		c, err = gun.StreamGunWithConn(c, t.gunTLSConfig, t.gunConfig, t.realityConfig)
 	} else {
-		c, err = t.plainStream(ctx, c)
+		c, err = t.plainStream(c)
 	}
 
 	if err != nil {
@@ -105,7 +105,7 @@ func (t *Trojan) StreamConnContext(ctx context.Context, c net.Conn, metadata *C.
 		return c, err
 	}
 	err = t.instance.WriteHeader(c, trojan.CommandTCP, serializesSocksAddr(metadata))
-	return c, err
+	return N.NewExtendedConn(c), err
 }
 
 // DialContext implements C.ProxyAdapter
@@ -135,12 +135,6 @@ 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)
@@ -151,7 +145,7 @@ func (t *Trojan) DialContextWithDialer(ctx context.Context, dialer C.Dialer, met
 		safeConnClose(c, err)
 	}(c)
 
-	c, err = t.StreamConnContext(ctx, c, metadata)
+	c, err = t.StreamConn(c, metadata)
 	if err != nil {
 		return nil, err
 	}
@@ -185,12 +179,6 @@ 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)
@@ -199,7 +187,7 @@ func (t *Trojan) ListenPacketWithDialer(ctx context.Context, dialer C.Dialer, me
 		safeConnClose(c, err)
 	}(c)
 	tcpKeepAlive(c)
-	c, err = t.plainStream(ctx, c)
+	c, err = t.plainStream(c)
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error: %w", t.addr, err)
 	}
@@ -214,8 +202,8 @@ func (t *Trojan) ListenPacketWithDialer(ctx context.Context, dialer C.Dialer, me
 }
 
 // SupportWithDialer implements C.ProxyAdapter
-func (t *Trojan) SupportWithDialer() C.NetWork {
-	return C.ALLNet
+func (t *Trojan) SupportWithDialer() bool {
+	return true
 }
 
 // ListenPacketOnStreamConn implements C.ProxyAdapter
@@ -283,15 +271,7 @@ func NewTrojan(option TrojanOption) (*Trojan, error) {
 
 	if option.Network == "grpc" {
 		dialFn := func(network, addr string) (net.Conn, error) {
-			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)
+			c, err := dialer.DialContext(context.Background(), "tcp", t.addr, t.Base.DialOptions()...)
 			if err != nil {
 				return nil, fmt.Errorf("%s connect error: %s", t.addr, err.Error())
 			}

adapter/outbound/tuic.go

@@ -16,7 +16,6 @@ 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"
@@ -24,7 +23,6 @@ import (
 
 type Tuic struct {
 	*Base
-	option *TuicOption
 	client *tuic.PoolClient
 }
 
@@ -86,8 +84,8 @@ func (t *Tuic) ListenPacketWithDialer(ctx context.Context, dialer C.Dialer, meta
 }
 
 // SupportWithDialer implements C.ProxyAdapter
-func (t *Tuic) SupportWithDialer() C.NetWork {
-	return C.ALLNet
+func (t *Tuic) SupportWithDialer() bool {
+	return true
 }
 
 func (t *Tuic) dial(ctx context.Context, opts ...dialer.Option) (pc net.PacketConn, addr net.Addr, err error) {
@@ -95,12 +93,6 @@ 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
@@ -238,7 +230,6 @@ func NewTuic(option TuicOption) (*Tuic, error) {
 			rmark:  option.RoutingMark,
 			prefer: C.NewDNSPrefer(option.IPVersion),
 		},
-		option: &option,
 	}
 
 	clientMaxOpenStreams := int64(option.MaxOpenStreams)

adapter/outbound/vless.go

@@ -13,9 +13,7 @@ import (
 	"sync"
 
 	"github.com/Dreamacro/clash/common/convert"
-	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"
@@ -75,7 +73,7 @@ type VlessOption struct {
 	ClientFingerprint string            `proxy:"client-fingerprint,omitempty"`
 }
 
-func (v *Vless) StreamConnContext(ctx context.Context, c net.Conn, metadata *C.Metadata) (net.Conn, error) {
+func (v *Vless) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
 	var err error
 
 	if tlsC.HaveGlobalFingerprint() && len(v.option.ClientFingerprint) == 0 {
@@ -129,10 +127,10 @@ func (v *Vless) StreamConnContext(ctx context.Context, c net.Conn, metadata *C.M
 				convert.SetUserAgent(wsOpts.Headers)
 			}
 		}
-		c, err = vmess.StreamWebsocketConn(ctx, c, wsOpts)
+		c, err = vmess.StreamWebsocketConn(c, wsOpts)
 	case "http":
 		// readability first, so just copy default TLS logic
-		c, err = v.streamTLSOrXTLSConn(ctx, c, false)
+		c, err = v.streamTLSOrXTLSConn(c, false)
 		if err != nil {
 			return nil, err
 		}
@@ -147,7 +145,7 @@ func (v *Vless) StreamConnContext(ctx context.Context, c net.Conn, metadata *C.M
 
 		c = vmess.StreamHTTPConn(c, httpOpts)
 	case "h2":
-		c, err = v.streamTLSOrXTLSConn(ctx, c, true)
+		c, err = v.streamTLSOrXTLSConn(c, true)
 		if err != nil {
 			return nil, err
 		}
@@ -163,45 +161,17 @@ func (v *Vless) StreamConnContext(ctx context.Context, c net.Conn, metadata *C.M
 	default:
 		// default tcp network
 		// handle TLS And XTLS
-		c, err = v.streamTLSOrXTLSConn(ctx, c, false)
+		c, err = v.streamTLSOrXTLSConn(c, false)
 	}
 
 	if err != nil {
 		return nil, err
 	}
 
-	return v.streamConn(c, metadata)
+	return v.client.StreamConn(c, parseVlessAddr(metadata, v.option.XUDP))
 }
 
-func (v *Vless) streamConn(c net.Conn, metadata *C.Metadata) (conn net.Conn, err error) {
-	if metadata.NetWork == C.UDP {
-		if v.option.PacketAddr {
-			metadata = &C.Metadata{
-				NetWork: C.UDP,
-				Host:    packetaddr.SeqPacketMagicAddress,
-				DstPort: "443",
-			}
-		} else {
-			metadata = &C.Metadata{ // a clear metadata only contains ip
-				NetWork: C.UDP,
-				DstIP:   metadata.DstIP,
-				DstPort: metadata.DstPort,
-			}
-		}
-		conn, err = v.client.StreamConn(c, parseVlessAddr(metadata, v.option.XUDP))
-		if v.option.PacketAddr {
-			conn = packetaddr.NewBindConn(conn)
-		}
-	} else {
-		conn, err = v.client.StreamConn(c, parseVlessAddr(metadata, false))
-	}
-	if err != nil {
-		conn = nil
-	}
-	return
-}
-
-func (v *Vless) streamTLSOrXTLSConn(ctx context.Context, conn net.Conn, isH2 bool) (net.Conn, error) {
+func (v *Vless) streamTLSOrXTLSConn(conn net.Conn, isH2 bool) (net.Conn, error) {
 	host, _, _ := net.SplitHostPort(v.addr)
 
 	if v.isLegacyXTLSEnabled() && !isH2 {
@@ -215,7 +185,7 @@ func (v *Vless) streamTLSOrXTLSConn(ctx context.Context, conn net.Conn, isH2 boo
 			xtlsOpts.Host = v.option.ServerName
 		}
 
-		return vless.StreamXTLSConn(ctx, conn, &xtlsOpts)
+		return vless.StreamXTLSConn(conn, &xtlsOpts)
 
 	} else if v.option.TLS {
 		tlsOpts := vmess.TLSConfig{
@@ -234,7 +204,7 @@ func (v *Vless) streamTLSOrXTLSConn(ctx context.Context, conn net.Conn, isH2 boo
 			tlsOpts.Host = v.option.ServerName
 		}
 
-		return vmess.StreamTLSConn(ctx, conn, &tlsOpts)
+		return vmess.StreamTLSConn(conn, &tlsOpts)
 	}
 
 	return conn, nil
@@ -268,12 +238,6 @@ 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())
@@ -283,7 +247,7 @@ func (v *Vless) DialContextWithDialer(ctx context.Context, dialer C.Dialer, meta
 		safeConnClose(c, err)
 	}(c)
 
-	c, err = v.StreamConnContext(ctx, c, metadata)
+	c, err = v.StreamConn(c, metadata)
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
 	}
@@ -300,6 +264,7 @@ func (v *Vless) ListenPacketContext(ctx context.Context, metadata *C.Metadata, o
 		}
 		metadata.DstIP = ip
 	}
+
 	var c net.Conn
 	// gun transport
 	if v.transport != nil && len(opts) == 0 {
@@ -311,25 +276,27 @@ func (v *Vless) ListenPacketContext(ctx context.Context, metadata *C.Metadata, o
 			safeConnClose(c, err)
 		}(c)
 
-		c, err = v.streamConn(c, metadata)
+		if v.option.PacketAddr {
+			packetAddrMetadata := *metadata // make a copy
+			packetAddrMetadata.Host = packetaddr.SeqPacketMagicAddress
+			packetAddrMetadata.DstPort = "443"
+
+			c, err = v.client.StreamConn(c, parseVlessAddr(&packetAddrMetadata, false))
+		} else {
+			c, err = v.client.StreamConn(c, parseVlessAddr(metadata, v.option.XUDP))
+		}
+
 		if err != nil {
 			return nil, fmt.Errorf("new vless client error: %v", err)
 		}
 
-		return v.ListenPacketOnStreamConn(ctx, c, metadata)
+		return v.ListenPacketOnStreamConn(c, metadata)
 	}
 	return v.ListenPacketWithDialer(ctx, dialer.NewDialer(v.Base.DialOptions(opts...)...), metadata)
 }
 
 // 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)
@@ -338,7 +305,6 @@ func (v *Vless) ListenPacketWithDialer(ctx context.Context, dialer C.Dialer, met
 		}
 		metadata.DstIP = ip
 	}
-
 	c, err := dialer.DialContext(ctx, "tcp", v.addr)
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
@@ -348,40 +314,40 @@ func (v *Vless) ListenPacketWithDialer(ctx context.Context, dialer C.Dialer, met
 		safeConnClose(c, err)
 	}(c)
 
-	c, err = v.StreamConnContext(ctx, c, metadata)
+	if v.option.PacketAddr {
+		packetAddrMetadata := *metadata // make a copy
+		packetAddrMetadata.Host = packetaddr.SeqPacketMagicAddress
+		packetAddrMetadata.DstPort = "443"
+
+		c, err = v.StreamConn(c, &packetAddrMetadata)
+	} else {
+		c, err = v.StreamConn(c, metadata)
+	}
+
 	if err != nil {
 		return nil, fmt.Errorf("new vless client error: %v", err)
 	}
 
-	return v.ListenPacketOnStreamConn(ctx, c, metadata)
+	return v.ListenPacketOnStreamConn(c, metadata)
 }
 
 // SupportWithDialer implements C.ProxyAdapter
-func (v *Vless) SupportWithDialer() C.NetWork {
-	return C.ALLNet
+func (v *Vless) SupportWithDialer() bool {
+	return true
 }
 
 // ListenPacketOnStreamConn implements C.ProxyAdapter
-func (v *Vless) ListenPacketOnStreamConn(ctx context.Context, c net.Conn, metadata *C.Metadata) (_ C.PacketConn, err error) {
-	// 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)
-		if err != nil {
-			return nil, errors.New("can't resolve ip")
-		}
-		metadata.DstIP = ip
-	}
-
+func (v *Vless) ListenPacketOnStreamConn(c net.Conn, metadata *C.Metadata) (_ C.PacketConn, err error) {
 	if v.option.XUDP {
-		return newPacketConn(N.NewThreadSafePacketConn(
-			vmessSing.NewXUDPConn(c, M.SocksaddrFromNet(metadata.UDPAddr())),
-		), v), nil
+		return newPacketConn(&threadSafePacketConn{
+			PacketConn: vmessSing.NewXUDPConn(c, M.ParseSocksaddr(metadata.RemoteAddress())),
+		}, v), nil
 	} else if v.option.PacketAddr {
-		return newPacketConn(N.NewThreadSafePacketConn(
-			packetaddr.NewConn(&vlessPacketConn{
+		return newPacketConn(&threadSafePacketConn{
+			PacketConn: packetaddr.NewConn(&vlessPacketConn{
 				Conn: c, rAddr: metadata.UDPAddr(),
-			}, M.SocksaddrFromNet(metadata.UDPAddr())),
-		), v), nil
+			}, M.ParseSocksaddr(metadata.RemoteAddress())),
+		}, v), nil
 	}
 	return newPacketConn(&vlessPacketConn{Conn: c, rAddr: metadata.UDPAddr()}, v), nil
 }
@@ -538,9 +504,6 @@ func NewVless(option VlessOption) (*Vless, error) {
 			option.XUDP = true
 		}
 	}
-	if option.XUDP {
-		option.PacketAddr = false
-	}
 
 	client, err := vless.NewClient(option.UUID, addons, option.FlowShow)
 	if err != nil {
@@ -575,15 +538,7 @@ func NewVless(option VlessOption) (*Vless, error) {
 		}
 	case "grpc":
 		dialFn := func(network, addr string) (net.Conn, error) {
-			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)
+			c, err := dialer.DialContext(context.Background(), "tcp", v.addr, v.Base.DialOptions()...)
 			if err != nil {
 				return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
 			}
@@ -596,19 +551,15 @@ func NewVless(option VlessOption) (*Vless, error) {
 			Host:              v.option.ServerName,
 			ClientFingerprint: v.option.ClientFingerprint,
 		}
-		if option.ServerName == "" {
-			gunConfig.Host = v.addr
-		}
-		var tlsConfig *tls.Config
-		if option.TLS {
-			tlsConfig = tlsC.GetGlobalTLSConfig(&tls.Config{
+		tlsConfig := tlsC.GetGlobalTLSConfig(&tls.Config{
 			InsecureSkipVerify: v.option.SkipCertVerify,
 			ServerName:         v.option.ServerName,
 		})
-			if option.ServerName == "" {
+
+		if v.option.ServerName == "" {
 			host, _, _ := net.SplitHostPort(v.addr)
 			tlsConfig.ServerName = host
-			}
+			gunConfig.Host = host
 		}
 
 		v.gunTLSConfig = tlsConfig

adapter/outbound/vmess.go

@@ -13,7 +13,6 @@ 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"
@@ -89,8 +88,8 @@ type WSOptions struct {
 	EarlyDataHeaderName string            `proxy:"early-data-header-name,omitempty"`
 }
 
-// StreamConnContext implements C.ProxyAdapter
-func (v *Vmess) StreamConnContext(ctx context.Context, c net.Conn, metadata *C.Metadata) (net.Conn, error) {
+// StreamConn implements C.ProxyAdapter
+func (v *Vmess) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
 	var err error
 
 	if tlsC.HaveGlobalFingerprint() && (len(v.option.ClientFingerprint) == 0) {
@@ -138,7 +137,7 @@ func (v *Vmess) StreamConnContext(ctx context.Context, c net.Conn, metadata *C.M
 				wsOpts.TLSConfig.ServerName = host
 			}
 		}
-		c, err = clashVMess.StreamWebsocketConn(ctx, c, wsOpts)
+		c, err = clashVMess.StreamWebsocketConn(c, wsOpts)
 	case "http":
 		// readability first, so just copy default TLS logic
 		if v.option.TLS {
@@ -153,7 +152,7 @@ func (v *Vmess) StreamConnContext(ctx context.Context, c net.Conn, metadata *C.M
 			if v.option.ServerName != "" {
 				tlsOpts.Host = v.option.ServerName
 			}
-			c, err = clashVMess.StreamTLSConn(ctx, c, tlsOpts)
+			c, err = clashVMess.StreamTLSConn(c, tlsOpts)
 			if err != nil {
 				return nil, err
 			}
@@ -182,7 +181,7 @@ func (v *Vmess) StreamConnContext(ctx context.Context, c net.Conn, metadata *C.M
 			tlsOpts.Host = v.option.ServerName
 		}
 
-		c, err = clashVMess.StreamTLSConn(ctx, c, &tlsOpts)
+		c, err = clashVMess.StreamTLSConn(c, &tlsOpts)
 		if err != nil {
 			return nil, err
 		}
@@ -210,49 +209,34 @@ func (v *Vmess) StreamConnContext(ctx context.Context, c net.Conn, metadata *C.M
 				tlsOpts.Host = v.option.ServerName
 			}
 
-			c, err = clashVMess.StreamTLSConn(ctx, c, tlsOpts)
+			c, err = clashVMess.StreamTLSConn(c, tlsOpts)
 		}
 	}
 
 	if err != nil {
 		return nil, err
 	}
-	return v.streamConn(c, metadata)
-}
-
-func (v *Vmess) streamConn(c net.Conn, metadata *C.Metadata) (conn net.Conn, err error) {
 	if metadata.NetWork == C.UDP {
 		if v.option.XUDP {
 			if N.NeedHandshake(c) {
-				conn = v.client.DialEarlyXUDPPacketConn(c, M.SocksaddrFromNet(metadata.UDPAddr()))
+				return v.client.DialEarlyXUDPPacketConn(c, M.ParseSocksaddr(metadata.RemoteAddress())), nil
 			} else {
-				conn, err = v.client.DialXUDPPacketConn(c, M.SocksaddrFromNet(metadata.UDPAddr()))
+				return v.client.DialXUDPPacketConn(c, M.ParseSocksaddr(metadata.RemoteAddress()))
 			}
-		} else if v.option.PacketAddr {
-			if N.NeedHandshake(c) {
-				conn = v.client.DialEarlyPacketConn(c, M.ParseSocksaddrHostPort(packetaddr.SeqPacketMagicAddress, 443))
-			} else {
-				conn, err = v.client.DialPacketConn(c, M.ParseSocksaddrHostPort(packetaddr.SeqPacketMagicAddress, 443))
-			}
-			conn = packetaddr.NewBindConn(conn)
 		} else {
 			if N.NeedHandshake(c) {
-				conn = v.client.DialEarlyPacketConn(c, M.SocksaddrFromNet(metadata.UDPAddr()))
+				return v.client.DialEarlyPacketConn(c, M.ParseSocksaddr(metadata.RemoteAddress())), nil
 			} else {
-				conn, err = v.client.DialPacketConn(c, M.SocksaddrFromNet(metadata.UDPAddr()))
+				return v.client.DialPacketConn(c, M.ParseSocksaddr(metadata.RemoteAddress()))
 			}
 		}
 	} else {
 		if N.NeedHandshake(c) {
-			conn = v.client.DialEarlyConn(c, M.ParseSocksaddr(metadata.RemoteAddress()))
+			return v.client.DialEarlyConn(c, M.ParseSocksaddr(metadata.RemoteAddress())), nil
 		} else {
-			conn, err = v.client.DialConn(c, M.ParseSocksaddr(metadata.RemoteAddress()))
+			return v.client.DialConn(c, M.ParseSocksaddr(metadata.RemoteAddress()))
 		}
 	}
-	if err != nil {
-		conn = nil
-	}
-	return
 }
 
 // DialContext implements C.ProxyAdapter
@@ -279,12 +263,6 @@ 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())
@@ -294,7 +272,7 @@ func (v *Vmess) DialContextWithDialer(ctx context.Context, dialer C.Dialer, meta
 		safeConnClose(c, err)
 	}(c)
 
-	c, err = v.StreamConnContext(ctx, c, metadata)
+	c, err = v.StreamConn(c, metadata)
 	return NewConn(c, v), err
 }
 
@@ -308,6 +286,14 @@ func (v *Vmess) ListenPacketContext(ctx context.Context, metadata *C.Metadata, o
 		}
 		metadata.DstIP = ip
 	}
+
+	if v.option.PacketAddr {
+		_metadata := *metadata // make a copy
+		metadata = &_metadata
+		metadata.Host = packetaddr.SeqPacketMagicAddress
+		metadata.DstPort = "443"
+	}
+
 	var c net.Conn
 	// gun transport
 	if v.transport != nil && len(opts) == 0 {
@@ -319,24 +305,30 @@ func (v *Vmess) ListenPacketContext(ctx context.Context, metadata *C.Metadata, o
 			safeConnClose(c, err)
 		}(c)
 
-		c, err = v.streamConn(c, metadata)
+		if v.option.XUDP {
+			if N.NeedHandshake(c) {
+				c = v.client.DialEarlyXUDPPacketConn(c, M.ParseSocksaddr(metadata.RemoteAddress()))
+			} else {
+				c, err = v.client.DialXUDPPacketConn(c, M.ParseSocksaddr(metadata.RemoteAddress()))
+			}
+		} else {
+			if N.NeedHandshake(c) {
+				c = v.client.DialEarlyPacketConn(c, M.ParseSocksaddr(metadata.RemoteAddress()))
+			} else {
+				c, err = v.client.DialPacketConn(c, M.ParseSocksaddr(metadata.RemoteAddress()))
+			}
+		}
+
 		if err != nil {
 			return nil, fmt.Errorf("new vmess client error: %v", err)
 		}
-		return v.ListenPacketOnStreamConn(ctx, c, metadata)
+		return v.ListenPacketOnStreamConn(c, metadata)
 	}
 	return v.ListenPacketWithDialer(ctx, dialer.NewDialer(v.Base.DialOptions(opts...)...), metadata)
 }
 
 // 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)
@@ -355,31 +347,24 @@ func (v *Vmess) ListenPacketWithDialer(ctx context.Context, dialer C.Dialer, met
 		safeConnClose(c, err)
 	}(c)
 
-	c, err = v.StreamConnContext(ctx, c, metadata)
+	c, err = v.StreamConn(c, metadata)
 	if err != nil {
 		return nil, fmt.Errorf("new vmess client error: %v", err)
 	}
-	return v.ListenPacketOnStreamConn(ctx, c, metadata)
+	return v.ListenPacketOnStreamConn(c, metadata)
 }
 
 // SupportWithDialer implements C.ProxyAdapter
-func (v *Vmess) SupportWithDialer() C.NetWork {
-	return C.ALLNet
+func (v *Vmess) SupportWithDialer() bool {
+	return true
 }
 
 // ListenPacketOnStreamConn implements C.ProxyAdapter
-func (v *Vmess) ListenPacketOnStreamConn(ctx context.Context, c net.Conn, metadata *C.Metadata) (_ C.PacketConn, err error) {
-	// 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)
-		if err != nil {
-			return nil, errors.New("can't resolve ip")
-		}
-		metadata.DstIP = ip
-	}
-
-	if pc, ok := c.(net.PacketConn); ok {
-		return newPacketConn(N.NewThreadSafePacketConn(pc), v), nil
+func (v *Vmess) ListenPacketOnStreamConn(c net.Conn, metadata *C.Metadata) (_ C.PacketConn, err error) {
+	if v.option.PacketAddr {
+		return newPacketConn(&threadSafePacketConn{PacketConn: packetaddr.NewBindConn(c)}, v), nil
+	} else if pc, ok := c.(net.PacketConn); ok {
+		return newPacketConn(&threadSafePacketConn{PacketConn: pc}, v), nil
 	}
 	return newPacketConn(&vmessPacketConn{Conn: c, rAddr: metadata.UDPAddr()}, v), nil
 }
@@ -413,6 +398,13 @@ func NewVmess(option VmessOption) (*Vmess, error) {
 		option.PacketAddr = false
 	}
 
+	switch option.Network {
+	case "h2", "grpc":
+		if !option.TLS {
+			option.TLS = true
+		}
+	}
+
 	v := &Vmess{
 		Base: &Base{
 			name:   option.Name,
@@ -436,15 +428,7 @@ func NewVmess(option VmessOption) (*Vmess, error) {
 		}
 	case "grpc":
 		dialFn := func(network, addr string) (net.Conn, error) {
-			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)
+			c, err := dialer.DialContext(context.Background(), "tcp", v.addr, v.Base.DialOptions()...)
 			if err != nil {
 				return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
 			}
@@ -457,19 +441,15 @@ func NewVmess(option VmessOption) (*Vmess, error) {
 			Host:              v.option.ServerName,
 			ClientFingerprint: v.option.ClientFingerprint,
 		}
-		if option.ServerName == "" {
-			gunConfig.Host = v.addr
-		}
-		var tlsConfig *tls.Config
-		if option.TLS {
-			tlsConfig = tlsC.GetGlobalTLSConfig(&tls.Config{
+		tlsConfig := &tls.Config{
 			InsecureSkipVerify: v.option.SkipCertVerify,
 			ServerName:         v.option.ServerName,
-			})
-			if option.ServerName == "" {
+		}
+
+		if v.option.ServerName == "" {
 			host, _, _ := net.SplitHostPort(v.addr)
 			tlsConfig.ServerName = host
-			}
+			gunConfig.Host = host
 		}
 
 		v.gunTLSConfig = tlsConfig
@@ -486,6 +466,17 @@ func NewVmess(option VmessOption) (*Vmess, error) {
 	return v, nil
 }
 
+type threadSafePacketConn struct {
+	net.PacketConn
+	access sync.Mutex
+}
+
+func (c *threadSafePacketConn) WriteTo(b []byte, addr net.Addr) (int, error) {
+	c.access.Lock()
+	defer c.access.Unlock()
+	return c.PacketConn.WriteTo(b, addr)
+}
+
 type vmessPacketConn struct {
 	net.Conn
 	rAddr  net.Addr
@@ -495,9 +486,9 @@ type vmessPacketConn struct {
 // WriteTo implments C.PacketConn.WriteTo
 // Since VMess doesn't support full cone NAT by design, we verify if addr matches uc.rAddr, and drop the packet if not.
 func (uc *vmessPacketConn) WriteTo(b []byte, addr net.Addr) (int, error) {
-	allowedAddr := uc.rAddr
-	destAddr := addr
-	if allowedAddr.String() != destAddr.String() {
+	allowedAddr := uc.rAddr.(*net.UDPAddr)
+	destAddr := addr.(*net.UDPAddr)
+	if !(allowedAddr.IP.Equal(destAddr.IP) && allowedAddr.Port == destAddr.Port) {
 		return 0, ErrUDPRemoteAddrMismatch
 	}
 	uc.access.Lock()

adapter/outbound/wireguard.go

@@ -15,10 +15,8 @@ import (
 
 	CN "github.com/Dreamacro/clash/common/net"
 	"github.com/Dreamacro/clash/component/dialer"
-	"github.com/Dreamacro/clash/component/proxydialer"
 	"github.com/Dreamacro/clash/component/resolver"
 	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/dns"
 	"github.com/Dreamacro/clash/log"
 
 	wireguard "github.com/metacubex/sing-wireguard"
@@ -39,97 +37,75 @@ type WireGuard struct {
 	dialer    *wgSingDialer
 	startOnce sync.Once
 	startErr  error
-	resolver  *dns.Resolver
-	refP      *refProxyAdapter
 }
 
 type WireGuardOption struct {
 	BasicOption
-	WireGuardPeerOption
 	Name                string  `proxy:"name"`
-	PrivateKey          string `proxy:"private-key"`
-	Workers             int    `proxy:"workers,omitempty"`
-	MTU                 int    `proxy:"mtu,omitempty"`
-	UDP                 bool   `proxy:"udp,omitempty"`
-	PersistentKeepalive int    `proxy:"persistent-keepalive,omitempty"`
-
-	Peers []WireGuardPeerOption `proxy:"peers,omitempty"`
-
-	RemoteDnsResolve bool     `proxy:"remote-dns-resolve,omitempty"`
-	Dns              []string `proxy:"dns,omitempty"`
-}
-
-type WireGuardPeerOption struct {
 	Server              string  `proxy:"server"`
 	Port                int     `proxy:"port"`
 	Ip                  string  `proxy:"ip,omitempty"`
 	Ipv6                string  `proxy:"ipv6,omitempty"`
-	PublicKey    string   `proxy:"public-key,omitempty"`
+	PrivateKey          string  `proxy:"private-key"`
+	PublicKey           string  `proxy:"public-key"`
 	PreSharedKey        string  `proxy:"pre-shared-key,omitempty"`
 	Reserved            []uint8 `proxy:"reserved,omitempty"`
-	AllowedIPs   []string `proxy:"allowed-ips,omitempty"`
+	Workers             int     `proxy:"workers,omitempty"`
+	MTU                 int     `proxy:"mtu,omitempty"`
+	UDP                 bool    `proxy:"udp,omitempty"`
+	PersistentKeepalive int     `proxy:"persistent-keepalive,omitempty"`
 }
 
 type wgSingDialer struct {
 	dialer dialer.Dialer
-	proxyName string
 }
 
-var _ N.Dialer = (*wgSingDialer)(nil)
+var _ N.Dialer = &wgSingDialer{}
 
 func (d *wgSingDialer) DialContext(ctx context.Context, network string, destination M.Socksaddr) (net.Conn, error) {
-	var cDialer C.Dialer = d.dialer
-	if len(d.proxyName) > 0 {
-		pd, err := proxydialer.NewByName(d.proxyName, d.dialer)
-		if err != nil {
-			return nil, err
-		}
-		cDialer = pd
-	}
-	return cDialer.DialContext(ctx, network, destination.String())
+	return d.dialer.DialContext(ctx, network, destination.String())
 }
 
 func (d *wgSingDialer) ListenPacket(ctx context.Context, destination M.Socksaddr) (net.PacketConn, error) {
-	var cDialer C.Dialer = d.dialer
-	if len(d.proxyName) > 0 {
-		pd, err := proxydialer.NewByName(d.proxyName, d.dialer)
-		if err != nil {
-			return nil, err
-		}
-		cDialer = pd
-	}
-	return cDialer.ListenPacket(ctx, "udp", "", destination.AddrPort())
-}
-
-type wgSingErrorHandler struct {
-	name string
-}
-
-var _ E.Handler = (*wgSingErrorHandler)(nil)
-
-func (w wgSingErrorHandler) NewError(ctx context.Context, err error) {
-	if E.IsClosedOrCanceled(err) {
-		log.SingLogger.Debug(fmt.Sprintf("[WG](%s) connection closed: %s", w.name, err))
-		return
-	}
-	log.SingLogger.Error(fmt.Sprintf("[WG](%s) %s", w.name, err))
+	return d.dialer.ListenPacket(ctx, "udp", "", destination.AddrPort())
 }
 
 type wgNetDialer struct {
 	tunDevice wireguard.Device
 }
 
-var _ dialer.NetDialer = (*wgNetDialer)(nil)
+var _ dialer.NetDialer = &wgNetDialer{}
 
 func (d wgNetDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
 	return d.tunDevice.DialContext(ctx, network, M.ParseSocksaddr(address).Unwrap())
 }
 
-func (option WireGuardPeerOption) Addr() M.Socksaddr {
-	return M.ParseSocksaddrHostPort(option.Server, uint16(option.Port))
-}
+func NewWireGuard(option WireGuardOption) (*WireGuard, error) {
+	outbound := &WireGuard{
+		Base: &Base{
+			name:   option.Name,
+			addr:   net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
+			tp:     C.WireGuard,
+			udp:    option.UDP,
+			iface:  option.Interface,
+			rmark:  option.RoutingMark,
+			prefer: C.NewDNSPrefer(option.IPVersion),
+		},
+		dialer: &wgSingDialer{dialer: dialer.NewDialer()},
+	}
+	runtime.SetFinalizer(outbound, closeWireGuard)
 
-func (option WireGuardPeerOption) Prefixes() ([]netip.Prefix, error) {
+	var reserved [3]uint8
+	if len(option.Reserved) > 0 {
+		if len(option.Reserved) != 3 {
+			return nil, E.New("invalid reserved value, required 3 bytes, got ", len(option.Reserved))
+		}
+		reserved[0] = uint8(option.Reserved[0])
+		reserved[1] = uint8(option.Reserved[1])
+		reserved[2] = uint8(option.Reserved[2])
+	}
+	peerAddr := M.ParseSocksaddrHostPort(option.Server, uint16(option.Port))
+	outbound.bind = wireguard.NewClientBind(context.Background(), outbound.dialer, peerAddr, reserved)
 	localPrefixes := make([]netip.Prefix, 0, 2)
 	if len(option.Ip) > 0 {
 		if !strings.Contains(option.Ip, "/") {
@@ -154,46 +130,7 @@ func (option WireGuardPeerOption) Prefixes() ([]netip.Prefix, error) {
 	if len(localPrefixes) == 0 {
 		return nil, E.New("missing local address")
 	}
-	return localPrefixes, nil
-}
-
-func NewWireGuard(option WireGuardOption) (*WireGuard, error) {
-	outbound := &WireGuard{
-		Base: &Base{
-			name:   option.Name,
-			addr:   net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
-			tp:     C.WireGuard,
-			udp:    option.UDP,
-			iface:  option.Interface,
-			rmark:  option.RoutingMark,
-			prefer: C.NewDNSPrefer(option.IPVersion),
-		},
-		dialer: &wgSingDialer{dialer: dialer.NewDialer(), proxyName: option.DialerProxy},
-	}
-	runtime.SetFinalizer(outbound, closeWireGuard)
-
-	var reserved [3]uint8
-	if len(option.Reserved) > 0 {
-		if len(option.Reserved) != 3 {
-			return nil, E.New("invalid reserved value, required 3 bytes, got ", len(option.Reserved))
-		}
-		copy(reserved[:], option.Reserved)
-	}
-	var isConnect bool
-	var connectAddr M.Socksaddr
-	if len(option.Peers) < 2 {
-		isConnect = true
-		if len(option.Peers) == 1 {
-			connectAddr = option.Peers[0].Addr()
-		} else {
-			connectAddr = option.Addr()
-		}
-	}
-	outbound.bind = wireguard.NewClientBind(context.Background(), wgSingErrorHandler{outbound.Name()}, outbound.dialer, isConnect, connectAddr, reserved)
-
-	var localPrefixes []netip.Prefix
-
-	var privateKey string
+	var privateKey, peerPublicKey, preSharedKey string
 	{
 		bytes, err := base64.StdEncoding.DecodeString(option.PrivateKey)
 		if err != nil {
@@ -201,52 +138,6 @@ func NewWireGuard(option WireGuardOption) (*WireGuard, error) {
 		}
 		privateKey = hex.EncodeToString(bytes)
 	}
-	ipcConf := "private_key=" + privateKey
-	if peersLen := len(option.Peers); peersLen > 0 {
-		localPrefixes = make([]netip.Prefix, 0, peersLen*2)
-		for i, peer := range option.Peers {
-			var peerPublicKey, preSharedKey string
-			{
-				bytes, err := base64.StdEncoding.DecodeString(peer.PublicKey)
-				if err != nil {
-					return nil, E.Cause(err, "decode public key for peer ", i)
-				}
-				peerPublicKey = hex.EncodeToString(bytes)
-			}
-			if peer.PreSharedKey != "" {
-				bytes, err := base64.StdEncoding.DecodeString(peer.PreSharedKey)
-				if err != nil {
-					return nil, E.Cause(err, "decode pre shared key for peer ", i)
-				}
-				preSharedKey = hex.EncodeToString(bytes)
-			}
-			destination := peer.Addr()
-			ipcConf += "\npublic_key=" + peerPublicKey
-			ipcConf += "\nendpoint=" + destination.String()
-			if preSharedKey != "" {
-				ipcConf += "\npreshared_key=" + preSharedKey
-			}
-			if len(peer.AllowedIPs) == 0 {
-				return nil, E.New("missing allowed_ips for peer ", i)
-			}
-			for _, allowedIP := range peer.AllowedIPs {
-				ipcConf += "\nallowed_ip=" + allowedIP
-			}
-			if len(peer.Reserved) > 0 {
-				if len(peer.Reserved) != 3 {
-					return nil, E.New("invalid reserved value for peer ", i, ", required 3 bytes, got ", len(peer.Reserved))
-				}
-				copy(reserved[:], option.Reserved)
-				outbound.bind.SetReservedForEndpoint(destination, reserved)
-			}
-			prefixes, err := peer.Prefixes()
-			if err != nil {
-				return nil, err
-			}
-			localPrefixes = append(localPrefixes, prefixes...)
-		}
-	} else {
-		var peerPublicKey, preSharedKey string
 	{
 		bytes, err := base64.StdEncoding.DecodeString(option.PublicKey)
 		if err != nil {
@@ -261,16 +152,12 @@ func NewWireGuard(option WireGuardOption) (*WireGuard, error) {
 		}
 		preSharedKey = hex.EncodeToString(bytes)
 	}
+	ipcConf := "private_key=" + privateKey
 	ipcConf += "\npublic_key=" + peerPublicKey
-		ipcConf += "\nendpoint=" + connectAddr.String()
+	ipcConf += "\nendpoint=" + peerAddr.String()
 	if preSharedKey != "" {
 		ipcConf += "\npreshared_key=" + preSharedKey
 	}
-		var err error
-		localPrefixes, err = option.Prefixes()
-		if err != nil {
-			return nil, err
-		}
 	var has4, has6 bool
 	for _, address := range localPrefixes {
 		if address.Addr().Is4() {
@@ -285,8 +172,6 @@ func NewWireGuard(option WireGuardOption) (*WireGuard, error) {
 	if has6 {
 		ipcConf += "\nallowed_ip=::/0"
 	}
-	}
-
 	if option.PersistentKeepalive != 0 {
 		ipcConf += fmt.Sprintf("\npersistent_keepalive_interval=%d", option.PersistentKeepalive)
 	}
@@ -294,9 +179,6 @@ func NewWireGuard(option WireGuardOption) (*WireGuard, error) {
 	if mtu == 0 {
 		mtu = 1408
 	}
-	if len(localPrefixes) == 0 {
-		return nil, E.New("missing local address")
-	}
 	var err error
 	outbound.tunDevice, err = wireguard.NewStackDevice(localPrefixes, uint32(mtu))
 	if err != nil {
@@ -304,45 +186,20 @@ func NewWireGuard(option WireGuardOption) (*WireGuard, error) {
 	}
 	outbound.device = device.NewDevice(outbound.tunDevice, outbound.bind, &device.Logger{
 		Verbosef: func(format string, args ...interface{}) {
-			log.SingLogger.Debug(fmt.Sprintf("[WG](%s) %s", option.Name, fmt.Sprintf(format, args...)))
+			log.SingLogger.Debug(fmt.Sprintf(strings.ToLower(format), args...))
 		},
 		Errorf: func(format string, args ...interface{}) {
-			log.SingLogger.Error(fmt.Sprintf("[WG](%s) %s", option.Name, fmt.Sprintf(format, args...)))
+			log.SingLogger.Error(fmt.Sprintf(strings.ToLower(format), args...))
 		},
 	}, option.Workers)
 	if debug.Enabled {
-		log.SingLogger.Trace(fmt.Sprintf("[WG](%s) created wireguard ipc conf: \n %s", option.Name, ipcConf))
+		log.SingLogger.Trace("created wireguard ipc conf: \n", ipcConf)
 	}
 	err = outbound.device.IpcSet(ipcConf)
 	if err != nil {
 		return nil, E.Cause(err, "setup wireguard")
 	}
 	//err = outbound.tunDevice.Start()
-
-	var has6 bool
-	for _, address := range localPrefixes {
-		if !address.Addr().Unmap().Is4() {
-			has6 = true
-			break
-		}
-	}
-
-	refP := &refProxyAdapter{}
-	outbound.refP = refP
-	if option.RemoteDnsResolve && len(option.Dns) > 0 {
-		nss, err := dns.ParseNameServer(option.Dns)
-		if err != nil {
-			return nil, err
-		}
-		for i := range nss {
-			nss[i].ProxyAdapter = refP
-		}
-		outbound.resolver = dns.NewResolver(dns.Config{
-			Main: nss,
-			IPv6: has6,
-		})
-	}
-
 	return outbound, nil
 }
 
@@ -363,14 +220,8 @@ func (w *WireGuard) DialContext(ctx context.Context, metadata *C.Metadata, opts
 	if w.startErr != nil {
 		return nil, w.startErr
 	}
-	if !metadata.Resolved() || w.resolver != nil {
-		r := resolver.DefaultResolver
-		if w.resolver != nil {
-			w.refP.SetProxyAdapter(w)
-			defer w.refP.ClearProxyAdapter()
-			r = w.resolver
-		}
-		options = append(options, dialer.WithResolver(r))
+	if !metadata.Resolved() {
+		options = append(options, dialer.WithResolver(resolver.DefaultResolver))
 		options = append(options, dialer.WithNetDialer(wgNetDialer{tunDevice: w.tunDevice}))
 		conn, err = dialer.NewDialer(options...).DialContext(ctx, "tcp", metadata.RemoteAddress())
 	} else {
@@ -399,14 +250,8 @@ func (w *WireGuard) ListenPacketContext(ctx context.Context, metadata *C.Metadat
 	if err != nil {
 		return nil, err
 	}
-	if (!metadata.Resolved() || w.resolver != nil) && metadata.Host != "" {
-		r := resolver.DefaultResolver
-		if w.resolver != nil {
-			w.refP.SetProxyAdapter(w)
-			defer w.refP.ClearProxyAdapter()
-			r = w.resolver
-		}
-		ip, err := resolver.ResolveIPWithResolver(ctx, metadata.Host, r)
+	if !metadata.Resolved() {
+		ip, err := resolver.ResolveIP(ctx, metadata.Host)
 		if err != nil {
 			return nil, errors.New("can't resolve ip")
 		}
@@ -422,144 +267,3 @@ func (w *WireGuard) ListenPacketContext(ctx context.Context, metadata *C.Metadat
 	}
 	return newPacketConn(CN.NewRefPacketConn(pc, w), w), nil
 }
-
-// IsL3Protocol implements C.ProxyAdapter
-func (w *WireGuard) IsL3Protocol(metadata *C.Metadata) bool {
-	return true
-}
-
-type refProxyAdapter struct {
-	proxyAdapter C.ProxyAdapter
-	count        int
-	mutex        sync.Mutex
-}
-
-func (r *refProxyAdapter) SetProxyAdapter(proxyAdapter C.ProxyAdapter) {
-	r.mutex.Lock()
-	defer r.mutex.Unlock()
-	r.proxyAdapter = proxyAdapter
-	r.count++
-}
-
-func (r *refProxyAdapter) ClearProxyAdapter() {
-	r.mutex.Lock()
-	defer r.mutex.Unlock()
-	r.count--
-	if r.count == 0 {
-		r.proxyAdapter = nil
-	}
-}
-
-func (r *refProxyAdapter) Name() string {
-	if r.proxyAdapter != nil {
-		return r.proxyAdapter.Name()
-	}
-	return ""
-}
-
-func (r *refProxyAdapter) Type() C.AdapterType {
-	if r.proxyAdapter != nil {
-		return r.proxyAdapter.Type()
-	}
-	return C.AdapterType(0)
-}
-
-func (r *refProxyAdapter) Addr() string {
-	if r.proxyAdapter != nil {
-		return r.proxyAdapter.Addr()
-	}
-	return ""
-}
-
-func (r *refProxyAdapter) SupportUDP() bool {
-	if r.proxyAdapter != nil {
-		return r.proxyAdapter.SupportUDP()
-	}
-	return false
-}
-
-func (r *refProxyAdapter) SupportXUDP() bool {
-	if r.proxyAdapter != nil {
-		return r.proxyAdapter.SupportXUDP()
-	}
-	return false
-}
-
-func (r *refProxyAdapter) SupportTFO() bool {
-	if r.proxyAdapter != nil {
-		return r.proxyAdapter.SupportTFO()
-	}
-	return false
-}
-
-func (r *refProxyAdapter) MarshalJSON() ([]byte, error) {
-	if r.proxyAdapter != nil {
-		return r.proxyAdapter.MarshalJSON()
-	}
-	return nil, C.ErrNotSupport
-}
-
-func (r *refProxyAdapter) StreamConnContext(ctx context.Context, c net.Conn, metadata *C.Metadata) (net.Conn, error) {
-	if r.proxyAdapter != nil {
-		return r.proxyAdapter.StreamConnContext(ctx, c, metadata)
-	}
-	return nil, C.ErrNotSupport
-}
-
-func (r *refProxyAdapter) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.Conn, error) {
-	if r.proxyAdapter != nil {
-		return r.proxyAdapter.DialContext(ctx, metadata, opts...)
-	}
-	return nil, C.ErrNotSupport
-}
-
-func (r *refProxyAdapter) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.PacketConn, error) {
-	if r.proxyAdapter != nil {
-		return r.proxyAdapter.ListenPacketContext(ctx, metadata, opts...)
-	}
-	return nil, C.ErrNotSupport
-}
-
-func (r *refProxyAdapter) SupportUOT() bool {
-	if r.proxyAdapter != nil {
-		return r.proxyAdapter.SupportUOT()
-	}
-	return false
-}
-
-func (r *refProxyAdapter) SupportWithDialer() C.NetWork {
-	if r.proxyAdapter != nil {
-		return r.proxyAdapter.SupportWithDialer()
-	}
-	return C.InvalidNet
-}
-
-func (r *refProxyAdapter) DialContextWithDialer(ctx context.Context, dialer C.Dialer, metadata *C.Metadata) (C.Conn, error) {
-	if r.proxyAdapter != nil {
-		return r.proxyAdapter.DialContextWithDialer(ctx, dialer, metadata)
-	}
-	return nil, C.ErrNotSupport
-}
-
-func (r *refProxyAdapter) ListenPacketWithDialer(ctx context.Context, dialer C.Dialer, metadata *C.Metadata) (C.PacketConn, error) {
-	if r.proxyAdapter != nil {
-		return r.proxyAdapter.ListenPacketWithDialer(ctx, dialer, metadata)
-	}
-	return nil, C.ErrNotSupport
-}
-
-func (r *refProxyAdapter) IsL3Protocol(metadata *C.Metadata) bool {
-	if r.proxyAdapter != nil {
-		return r.proxyAdapter.IsL3Protocol(metadata)
-	}
-	return false
-}
-
-func (r *refProxyAdapter) Unwrap(metadata *C.Metadata, touch bool) C.Proxy {
-	if r.proxyAdapter != nil {
-		return r.proxyAdapter.Unwrap(metadata, touch)
-	}
-	return nil
-}
-
-var _ C.ProxyAdapter = (*refProxyAdapter)(nil)

adapter/outboundgroup/fallback.go

@@ -37,13 +37,16 @@ func (f *Fallback) DialContext(ctx context.Context, metadata *C.Metadata, opts .
 	}
 
 	if N.NeedHandshake(c) {
-		c = callback.NewFirstWriteCallBackConn(c, func(err error) {
+		c = &callback.FirstWriteCallBackConn{
+			Conn: c,
+			Callback: func(err error) {
 				if err == nil {
 					f.onDialSuccess()
 				} else {
 					f.onDialFailed(proxy.Type(), err)
 				}
-		})
+			},
+		}
 	}
 
 	return c, err
@@ -70,11 +73,6 @@ func (f *Fallback) SupportUDP() bool {
 	return proxy.SupportUDP()
 }
 
-// IsL3Protocol implements C.ProxyAdapter
-func (f *Fallback) IsL3Protocol(metadata *C.Metadata) bool {
-	return f.findAliveProxy(false).IsL3Protocol(metadata)
-}
-
 // MarshalJSON implements C.ProxyAdapter
 func (f *Fallback) MarshalJSON() ([]byte, error) {
 	all := []string{}
@@ -138,10 +136,6 @@ func (f *Fallback) Set(name string) error {
 	return nil
 }
 
-func (f *Fallback) ForceSet(name string) {
-	f.selected = name
-}
-
 func NewFallback(option *GroupCommonOption, providers []provider.ProxyProvider) *Fallback {
 	return &Fallback{
 		GroupBase: NewGroupBase(GroupBaseOption{

adapter/outboundgroup/groupbase.go

@@ -8,7 +8,6 @@ import (
 	"time"
 
 	"github.com/Dreamacro/clash/adapter/outbound"
-	"github.com/Dreamacro/clash/common/atomic"
 	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/constant/provider"
 	types "github.com/Dreamacro/clash/constant/provider"
@@ -16,6 +15,7 @@ import (
 	"github.com/Dreamacro/clash/tunnel"
 
 	"github.com/dlclark/regexp2"
+	"go.uber.org/atomic"
 )
 
 type GroupBase struct {
@@ -130,6 +130,10 @@ func (gb *GroupBase) GetProxies(touch bool) []C.Proxy {
 		}
 	}
 
+	if len(proxies) == 0 {
+		return append(proxies, tunnel.Proxies()["COMPATIBLE"])
+	}
+
 	if len(gb.providers) > 1 && len(gb.filterRegs) > 1 {
 		var newProxies []C.Proxy
 		proxiesSet := map[string]struct{}{}
@@ -185,10 +189,6 @@ func (gb *GroupBase) GetProxies(touch bool) []C.Proxy {
 		proxies = newProxies
 	}
 
-	if len(proxies) == 0 {
-		return append(proxies, tunnel.Proxies()["COMPATIBLE"])
-	}
-
 	return proxies
 }
 

adapter/outboundgroup/loadbalance.go

@@ -95,13 +95,16 @@ func (lb *LoadBalance) DialContext(ctx context.Context, metadata *C.Metadata, op
 	}
 
 	if N.NeedHandshake(c) {
-		c = callback.NewFirstWriteCallBackConn(c, func(err error) {
+		c = &callback.FirstWriteCallBackConn{
+			Conn: c,
+			Callback: func(err error) {
 				if err == nil {
 					lb.onDialSuccess()
 				} else {
 					lb.onDialFailed(proxy.Type(), err)
 				}
-		})
+			},
+		}
 	}
 
 	return
@@ -124,11 +127,6 @@ func (lb *LoadBalance) SupportUDP() bool {
 	return !lb.disableUDP
 }
 
-// IsL3Protocol implements C.ProxyAdapter
-func (lb *LoadBalance) IsL3Protocol(metadata *C.Metadata) bool {
-	return lb.Unwrap(metadata, false).IsL3Protocol(metadata)
-}
-
 func strategyRoundRobin() strategyFn {
 	idx := 0
 	idxMutex := sync.Mutex{}

adapter/outboundgroup/relay.go

@@ -3,9 +3,13 @@ package outboundgroup
 import (
 	"context"
 	"encoding/json"
+	"net"
+	"net/netip"
+	"strings"
+
 	"github.com/Dreamacro/clash/adapter/outbound"
+	N "github.com/Dreamacro/clash/common/net"
 	"github.com/Dreamacro/clash/component/dialer"
-	"github.com/Dreamacro/clash/component/proxydialer"
 	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/constant/provider"
 )
@@ -14,6 +18,36 @@ type Relay struct {
 	*GroupBase
 }
 
+type proxyDialer struct {
+	proxy  C.Proxy
+	dialer C.Dialer
+}
+
+func (p proxyDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
+	currentMeta, err := addrToMetadata(address)
+	if err != nil {
+		return nil, err
+	}
+	if strings.Contains(network, "udp") { // should not support this operation
+		currentMeta.NetWork = C.UDP
+		pc, err := p.proxy.ListenPacketWithDialer(ctx, p.dialer, currentMeta)
+		if err != nil {
+			return nil, err
+		}
+		return N.NewBindPacketConn(pc, currentMeta.UDPAddr()), nil
+	}
+	return p.proxy.DialContextWithDialer(ctx, p.dialer, currentMeta)
+}
+
+func (p proxyDialer) ListenPacket(ctx context.Context, network, address string, rAddrPort netip.AddrPort) (net.PacketConn, error) {
+	currentMeta, err := addrToMetadata(rAddrPort.String())
+	if err != nil {
+		return nil, err
+	}
+	currentMeta.NetWork = C.UDP
+	return p.proxy.ListenPacketWithDialer(ctx, p.dialer, currentMeta)
+}
+
 // DialContext implements C.ProxyAdapter
 func (r *Relay) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.Conn, error) {
 	proxies, chainProxies := r.proxies(metadata, true)
@@ -27,7 +61,10 @@ func (r *Relay) DialContext(ctx context.Context, metadata *C.Metadata, opts ...d
 	var d C.Dialer
 	d = dialer.NewDialer(r.Base.DialOptions(opts...)...)
 	for _, proxy := range proxies[:len(proxies)-1] {
-		d = proxydialer.New(proxy, d, false)
+		d = proxyDialer{
+			proxy:  proxy,
+			dialer: d,
+		}
 	}
 	last := proxies[len(proxies)-1]
 	conn, err := last.DialContextWithDialer(ctx, d, metadata)
@@ -58,7 +95,10 @@ func (r *Relay) ListenPacketContext(ctx context.Context, metadata *C.Metadata, o
 	var d C.Dialer
 	d = dialer.NewDialer(r.Base.DialOptions(opts...)...)
 	for _, proxy := range proxies[:len(proxies)-1] {
-		d = proxydialer.New(proxy, d, false)
+		d = proxyDialer{
+			proxy:  proxy,
+			dialer: d,
+		}
 	}
 	last := proxies[len(proxies)-1]
 	pc, err := last.ListenPacketWithDialer(ctx, d, metadata)
@@ -89,10 +129,7 @@ func (r *Relay) SupportUDP() bool {
 		if proxy.SupportUOT() {
 			return true
 		}
-		switch proxy.SupportWithDialer() {
-		case C.ALLNet:
-		case C.UDP:
-		default: // C.TCP and C.InvalidNet
+		if !proxy.SupportWithDialer() {
 			return false
 		}
 	}

adapter/outboundgroup/selector.go

@@ -44,11 +44,6 @@ func (s *Selector) SupportUDP() bool {
 	return s.selectedProxy(false).SupportUDP()
 }
 
-// IsL3Protocol implements C.ProxyAdapter
-func (s *Selector) IsL3Protocol(metadata *C.Metadata) bool {
-	return s.selectedProxy(false).IsL3Protocol(metadata)
-}
-
 // MarshalJSON implements C.ProxyAdapter
 func (s *Selector) MarshalJSON() ([]byte, error) {
 	all := []string{}
@@ -78,10 +73,6 @@ func (s *Selector) Set(name string) error {
 	return errors.New("proxy not exist")
 }
 
-func (s *Selector) ForceSet(name string) {
-	s.selected = name
-}
-
 // Unwrap implements C.ProxyAdapter
 func (s *Selector) Unwrap(metadata *C.Metadata, touch bool) C.Proxy {
 	return s.selectedProxy(touch)

adapter/outboundgroup/urltest.go

@@ -3,7 +3,6 @@ package outboundgroup
 import (
 	"context"
 	"encoding/json"
-	"errors"
 	"time"
 
 	"github.com/Dreamacro/clash/adapter/outbound"
@@ -25,8 +24,6 @@ func urlTestWithTolerance(tolerance uint16) urlTestOption {
 
 type URLTest struct {
 	*GroupBase
-	selected   string
-	testUrl    string
 	tolerance  uint16
 	disableUDP bool
 	fastNode   C.Proxy
@@ -37,26 +34,6 @@ func (u *URLTest) Now() string {
 	return u.fast(false).Name()
 }
 
-func (u *URLTest) Set(name string) error {
-	var p C.Proxy
-	for _, proxy := range u.GetProxies(false) {
-		if proxy.Name() == name {
-			p = proxy
-			break
-		}
-	}
-	if p == nil {
-		return errors.New("proxy not exist")
-	}
-	u.selected = name
-	u.fast(false)
-	return nil
-}
-
-func (u *URLTest) ForceSet(name string) {
-	u.selected = name
-}
-
 // DialContext implements C.ProxyAdapter
 func (u *URLTest) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (c C.Conn, err error) {
 	proxy := u.fast(true)
@@ -68,13 +45,16 @@ func (u *URLTest) DialContext(ctx context.Context, metadata *C.Metadata, opts ..
 	}
 
 	if N.NeedHandshake(c) {
-		c = callback.NewFirstWriteCallBackConn(c, func(err error) {
+		c = &callback.FirstWriteCallBackConn{
+			Conn: c,
+			Callback: func(err error) {
 				if err == nil {
 					u.onDialSuccess()
 				} else {
 					u.onDialFailed(proxy.Type(), err)
 				}
-		})
+			},
+		}
 	}
 
 	return c, err
@@ -96,21 +76,8 @@ func (u *URLTest) Unwrap(metadata *C.Metadata, touch bool) C.Proxy {
 }
 
 func (u *URLTest) fast(touch bool) C.Proxy {
-
-	proxies := u.GetProxies(touch)
-	if u.selected != "" {
-		for _, proxy := range proxies {
-			if !proxy.Alive() {
-				continue
-			}
-			if proxy.Name() == u.selected {
-				u.fastNode = proxy
-				return proxy
-			}
-		}
-	}
-
 	elm, _, shared := u.fastSingle.Do(func() (C.Proxy, error) {
+		proxies := u.GetProxies(touch)
 		fast := proxies[0]
 		min := fast.LastDelay()
 		fastNotExist := true
@@ -129,12 +96,13 @@ func (u *URLTest) fast(touch bool) C.Proxy {
 				fast = proxy
 				min = delay
 			}
-
 		}
+
 		// tolerance
 		if u.fastNode == nil || fastNotExist || !u.fastNode.Alive() || u.fastNode.LastDelay() > fast.LastDelay()+u.tolerance {
 			u.fastNode = fast
 		}
+
 		return u.fastNode, nil
 	})
 	if shared && touch { // a shared fastSingle.Do() may cause providers untouched, so we touch them again
@@ -149,12 +117,8 @@ func (u *URLTest) SupportUDP() bool {
 	if u.disableUDP {
 		return false
 	}
-	return u.fast(false).SupportUDP()
-}
 
-// IsL3Protocol implements C.ProxyAdapter
-func (u *URLTest) IsL3Protocol(metadata *C.Metadata) bool {
-	return u.fast(false).IsL3Protocol(metadata)
+	return u.fast(false).SupportUDP()
 }
 
 // MarshalJSON implements C.ProxyAdapter
@@ -200,7 +164,6 @@ func NewURLTest(option *GroupCommonOption, providers []provider.ProxyProvider, o
 		}),
 		fastSingle: singledo.NewSingle[C.Proxy](time.Second * 10),
 		disableUDP: option.DisableUDP,
-		testUrl:    option.URL,
 	}
 
 	for _, option := range options {

adapter/outboundgroup/util.go

@@ -1,10 +1,37 @@
 package outboundgroup
 
 import (
+	"fmt"
 	"net"
+	"net/netip"
 	"time"
+
+	C "github.com/Dreamacro/clash/constant"
 )
 
+func addrToMetadata(rawAddress string) (addr *C.Metadata, err error) {
+	host, port, err := net.SplitHostPort(rawAddress)
+	if err != nil {
+		err = fmt.Errorf("addrToMetadata failed: %w", err)
+		return
+	}
+
+	if ip, err := netip.ParseAddr(host); err != nil {
+		addr = &C.Metadata{
+			Host:    host,
+			DstPort: port,
+		}
+	} else {
+		addr = &C.Metadata{
+			Host:    "",
+			DstIP:   ip.Unmap(),
+			DstPort: port,
+		}
+	}
+
+	return
+}
+
 func tcpKeepAlive(c net.Conn) {
 	if tcp, ok := c.(*net.TCPConn); ok {
 		_ = tcp.SetKeepAlive(true)
@@ -14,5 +41,4 @@ func tcpKeepAlive(c net.Conn) {
 
 type SelectAble interface {
 	Set(string) error
-	ForceSet(name string)
 }

adapter/parser.go

@@ -114,19 +114,5 @@ func ParseProxy(mapping map[string]any) (C.Proxy, error) {
 		return nil, err
 	}
 
-	if muxMapping, muxExist := mapping["smux"].(map[string]any); muxExist {
-		muxOption := &outbound.SingMuxOption{}
-		err = decoder.Decode(muxMapping, muxOption)
-		if err != nil {
-			return nil, err
-		}
-		if muxOption.Enabled {
-			proxy, err = outbound.NewSingMux(*muxOption, proxy, proxy.(outbound.ProxyBase))
-			if err != nil {
-				return nil, err
-			}
-		}
-	}
-
 	return NewProxy(proxy), nil
 }

adapter/provider/healthcheck.go

@@ -4,12 +4,13 @@ import (
 	"context"
 	"time"
 
-	"github.com/Dreamacro/clash/common/atomic"
 	"github.com/Dreamacro/clash/common/batch"
 	"github.com/Dreamacro/clash/common/singledo"
 	"github.com/Dreamacro/clash/common/utils"
 	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/log"
+
+	"go.uber.org/atomic"
 )
 
 const (

adapter/provider/parser.go

@@ -28,7 +28,6 @@ type proxyProviderSchema struct {
 	Filter        string            `provider:"filter,omitempty"`
 	ExcludeFilter string            `provider:"exclude-filter,omitempty"`
 	ExcludeType   string            `provider:"exclude-type,omitempty"`
-	DialerProxy   string            `provider:"dialer-proxy,omitempty"`
 	HealthCheck   healthCheckSchema `provider:"health-check,omitempty"`
 }
 
@@ -66,7 +65,6 @@ func ParseProxyProvider(name string, mapping map[string]any) (types.ProxyProvide
 	filter := schema.Filter
 	excludeFilter := schema.ExcludeFilter
 	excludeType := schema.ExcludeType
-	dialerProxy := schema.DialerProxy
 
-	return NewProxySetProvider(name, interval, filter, excludeFilter, excludeType, dialerProxy, vehicle, hc)
+	return NewProxySetProvider(name, interval, filter, excludeFilter, excludeType, vehicle, hc)
 }

adapter/provider/provider.go

@@ -17,7 +17,6 @@ import (
 	C "github.com/Dreamacro/clash/constant"
 	types "github.com/Dreamacro/clash/constant/provider"
 	"github.com/Dreamacro/clash/log"
-	"github.com/Dreamacro/clash/tunnel/statistic"
 
 	"github.com/dlclark/regexp2"
 	"gopkg.in/yaml.v3"
@@ -82,7 +81,6 @@ func (pp *proxySetProvider) Initial() error {
 	}
 	pp.OnUpdate(elm)
 	pp.getSubscriptionInfo()
-	pp.closeAllConnections()
 	return nil
 }
 
@@ -140,24 +138,12 @@ func (pp *proxySetProvider) getSubscriptionInfo() {
 	}()
 }
 
-func (pp *proxySetProvider) closeAllConnections() {
-	snapshot := statistic.DefaultManager.Snapshot()
-	for _, c := range snapshot.Connections {
-		for _, chain := range c.Chains() {
-			if chain == pp.Name() {
-				_ = c.Close()
-				break
-			}
-		}
-	}
-}
-
 func stopProxyProvider(pd *ProxySetProvider) {
 	pd.healthCheck.close()
 	_ = pd.Fetcher.Destroy()
 }
 
-func NewProxySetProvider(name string, interval time.Duration, filter string, excludeFilter string, excludeType string, dialerProxy string, vehicle types.Vehicle, hc *HealthCheck) (*ProxySetProvider, error) {
+func NewProxySetProvider(name string, interval time.Duration, filter string, excludeFilter string, excludeType string, vehicle types.Vehicle, hc *HealthCheck) (*ProxySetProvider, error) {
 	excludeFilterReg, err := regexp2.Compile(excludeFilter, 0)
 	if err != nil {
 		return nil, fmt.Errorf("invalid excludeFilter regex: %w", err)
@@ -185,7 +171,7 @@ func NewProxySetProvider(name string, interval time.Duration, filter string, exc
 		healthCheck: hc,
 	}
 
-	fetcher := resource.NewFetcher[[]C.Proxy](name, interval, vehicle, proxiesParseAndFilter(filter, excludeFilter, excludeTypeArray, filterRegs, excludeFilterReg, dialerProxy), proxiesOnUpdate(pd))
+	fetcher := resource.NewFetcher[[]C.Proxy](name, interval, vehicle, proxiesParseAndFilter(filter, excludeFilter, excludeTypeArray, filterRegs, excludeFilterReg), proxiesOnUpdate(pd))
 	pd.Fetcher = fetcher
 	wrapper := &ProxySetProvider{pd}
 	runtime.SetFinalizer(wrapper, stopProxyProvider)
@@ -281,7 +267,7 @@ func proxiesOnUpdate(pd *proxySetProvider) func([]C.Proxy) {
 	}
 }
 
-func proxiesParseAndFilter(filter string, excludeFilter string, excludeTypeArray []string, filterRegs []*regexp2.Regexp, excludeFilterReg *regexp2.Regexp, dialerProxy string) resource.Parser[[]C.Proxy] {
+func proxiesParseAndFilter(filter string, excludeFilter string, excludeTypeArray []string, filterRegs []*regexp2.Regexp, excludeFilterReg *regexp2.Regexp) resource.Parser[[]C.Proxy] {
 	return func(buf []byte) ([]C.Proxy, error) {
 		schema := &ProxySchema{}
 
@@ -344,9 +330,6 @@ func proxiesParseAndFilter(filter string, excludeFilter string, excludeTypeArray
 				if _, ok := proxiesSet[name]; ok {
 					continue
 				}
-				if len(dialerProxy) > 0 {
-					mapping["dialer-proxy"] = dialerProxy
-				}
 				proxy, err := adapter.ParseProxy(mapping)
 				if err != nil {
 					return nil, fmt.Errorf("proxy %d error: %w", idx, err)

common/atomic/type.go

@@ -1,205 +0,0 @@
-package atomic
-
-import (
-	"encoding/json"
-	"fmt"
-	"strconv"
-	"sync/atomic"
-)
-
-type Bool struct {
-	atomic.Bool
-}
-
-func NewBool(val bool) *Bool {
-	i := &Bool{}
-	i.Store(val)
-	return i
-}
-
-func (i *Bool) MarshalJSON() ([]byte, error) {
-	return json.Marshal(i.Load())
-}
-
-func (i *Bool) UnmarshalJSON(b []byte) error {
-	var v bool
-	if err := json.Unmarshal(b, &v); err != nil {
-		return err
-	}
-	i.Store(v)
-	return nil
-}
-
-func (i *Bool) String() string {
-	v := i.Load()
-	return strconv.FormatBool(v)
-}
-
-type Pointer[T any] struct {
-	atomic.Pointer[T]
-}
-
-func NewPointer[T any](v *T) *Pointer[T] {
-	var p Pointer[T]
-	if v != nil {
-		p.Store(v)
-	}
-	return &p
-}
-
-func (p *Pointer[T]) MarshalJSON() ([]byte, error) {
-	return json.Marshal(p.Load())
-}
-
-func (p *Pointer[T]) UnmarshalJSON(b []byte) error {
-	var v *T
-	if err := json.Unmarshal(b, &v); err != nil {
-		return err
-	}
-	p.Store(v)
-	return nil
-}
-
-func (p *Pointer[T]) String() string {
-	return fmt.Sprint(p.Load())
-}
-
-type Int32 struct {
-	atomic.Int32
-}
-
-func NewInt32(val int32) *Int32 {
-	i := &Int32{}
-	i.Store(val)
-	return i
-}
-
-func (i *Int32) MarshalJSON() ([]byte, error) {
-	return json.Marshal(i.Load())
-}
-
-func (i *Int32) UnmarshalJSON(b []byte) error {
-	var v int32
-	if err := json.Unmarshal(b, &v); err != nil {
-		return err
-	}
-	i.Store(v)
-	return nil
-}
-
-func (i *Int32) String() string {
-	v := i.Load()
-	return strconv.FormatInt(int64(v), 10)
-}
-
-type Int64 struct {
-	atomic.Int64
-}
-
-func NewInt64(val int64) *Int64 {
-	i := &Int64{}
-	i.Store(val)
-	return i
-}
-
-func (i *Int64) MarshalJSON() ([]byte, error) {
-	return json.Marshal(i.Load())
-}
-
-func (i *Int64) UnmarshalJSON(b []byte) error {
-	var v int64
-	if err := json.Unmarshal(b, &v); err != nil {
-		return err
-	}
-	i.Store(v)
-	return nil
-}
-
-func (i *Int64) String() string {
-	v := i.Load()
-	return strconv.FormatInt(int64(v), 10)
-}
-
-type Uint32 struct {
-	atomic.Uint32
-}
-
-func NewUint32(val uint32) *Uint32 {
-	i := &Uint32{}
-	i.Store(val)
-	return i
-}
-
-func (i *Uint32) MarshalJSON() ([]byte, error) {
-	return json.Marshal(i.Load())
-}
-
-func (i *Uint32) UnmarshalJSON(b []byte) error {
-	var v uint32
-	if err := json.Unmarshal(b, &v); err != nil {
-		return err
-	}
-	i.Store(v)
-	return nil
-}
-
-func (i *Uint32) String() string {
-	v := i.Load()
-	return strconv.FormatUint(uint64(v), 10)
-}
-
-type Uint64 struct {
-	atomic.Uint64
-}
-
-func NewUint64(val uint64) *Uint64 {
-	i := &Uint64{}
-	i.Store(val)
-	return i
-}
-
-func (i *Uint64) MarshalJSON() ([]byte, error) {
-	return json.Marshal(i.Load())
-}
-
-func (i *Uint64) UnmarshalJSON(b []byte) error {
-	var v uint64
-	if err := json.Unmarshal(b, &v); err != nil {
-		return err
-	}
-	i.Store(v)
-	return nil
-}
-
-func (i *Uint64) String() string {
-	v := i.Load()
-	return strconv.FormatUint(uint64(v), 10)
-}
-
-type Uintptr struct {
-	atomic.Uintptr
-}
-
-func NewUintptr(val uintptr) *Uintptr {
-	i := &Uintptr{}
-	i.Store(val)
-	return i
-}
-
-func (i *Uintptr) MarshalJSON() ([]byte, error) {
-	return json.Marshal(i.Load())
-}
-
-func (i *Uintptr) UnmarshalJSON(b []byte) error {
-	var v uintptr
-	if err := json.Unmarshal(b, &v); err != nil {
-		return err
-	}
-	i.Store(v)
-	return nil
-}
-
-func (i *Uintptr) String() string {
-	v := i.Load()
-	return strconv.FormatUint(uint64(v), 10)
-}

common/atomic/value.go

@@ -1,58 +0,0 @@
-package atomic
-
-import (
-	"encoding/json"
-	"sync/atomic"
-)
-
-func DefaultValue[T any]() T {
-	var defaultValue T
-	return defaultValue
-}
-
-type TypedValue[T any] struct {
-	value atomic.Value
-}
-
-func (t *TypedValue[T]) Load() T {
-	value := t.value.Load()
-	if value == nil {
-		return DefaultValue[T]()
-	}
-	return value.(T)
-}
-
-func (t *TypedValue[T]) Store(value T) {
-	t.value.Store(value)
-}
-
-func (t *TypedValue[T]) Swap(new T) T {
-	old := t.value.Swap(new)
-	if old == nil {
-		return DefaultValue[T]()
-	}
-	return old.(T)
-}
-
-func (t *TypedValue[T]) CompareAndSwap(old, new T) bool {
-	return t.value.CompareAndSwap(old, new)
-}
-
-func (t *TypedValue[T]) MarshalJSON() ([]byte, error) {
-	return json.Marshal(t.Load())
-}
-
-func (t *TypedValue[T]) UnmarshalJSON(b []byte) error {
-	var v T
-	if err := json.Unmarshal(b, &v); err != nil {
-		return err
-	}
-	t.Store(v)
-	return nil
-}
-
-func NewTypedValue[T any](t T) *TypedValue[T] {
-	v := &TypedValue[T]{}
-	v.Store(t)
-	return v
-}

common/buf/sing.go

@@ -10,11 +10,9 @@ const BufferSize = buf.BufferSize
 type Buffer = buf.Buffer
 
 var New = buf.New
-var NewSize = buf.NewSize
 var StackNew = buf.StackNew
 var StackNewSize = buf.StackNewSize
 var With = buf.With
-var As = buf.As
 
 var KeepAlive = common.KeepAlive
 
@@ -23,7 +21,5 @@ func Dup[T any](obj T) T {
 	return common.Dup(obj)
 }
 
-var (
-	Must  = common.Must
-	Error = common.Error
-)
+var Must = common.Must
+var Error = common.Error

common/callback/callback.go

@@ -1,55 +1,25 @@
 package callback
 
 import (
-	"github.com/Dreamacro/clash/common/buf"
-	N "github.com/Dreamacro/clash/common/net"
 	C "github.com/Dreamacro/clash/constant"
 )
 
-type firstWriteCallBackConn struct {
+type FirstWriteCallBackConn struct {
 	C.Conn
-	callback func(error)
+	Callback func(error)
 	written  bool
 }
 
-func (c *firstWriteCallBackConn) Write(b []byte) (n int, err error) {
+func (c *FirstWriteCallBackConn) Write(b []byte) (n int, err error) {
 	defer func() {
 		if !c.written {
 			c.written = true
-			c.callback(err)
+			c.Callback(err)
 		}
 	}()
 	return c.Conn.Write(b)
 }
 
-func (c *firstWriteCallBackConn) WriteBuffer(buffer *buf.Buffer) (err error) {
-	defer func() {
-		if !c.written {
-			c.written = true
-			c.callback(err)
-		}
-	}()
-	return c.Conn.WriteBuffer(buffer)
-}
-
-func (c *firstWriteCallBackConn) Upstream() any {
+func (c *FirstWriteCallBackConn) Upstream() any {
 	return c.Conn
 }
-
-func (c *firstWriteCallBackConn) WriterReplaceable() bool {
-	return c.written
-}
-
-func (c *firstWriteCallBackConn) ReaderReplaceable() bool {
-	return true
-}
-
-var _ N.ExtendedConn = (*firstWriteCallBackConn)(nil)
-
-func NewFirstWriteCallBackConn(c C.Conn, callback func(error)) C.Conn {
-	return &firstWriteCallBackConn{
-		Conn:     c,
-		callback: callback,
-		written:  false,
-	}
-}

common/convert/converter.go

@@ -5,11 +5,10 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
+	"github.com/Dreamacro/clash/log"
 	"net/url"
 	"strconv"
 	"strings"
-
-	"github.com/Dreamacro/clash/log"
 )
 
 // ConvertsV2Ray convert V2Ray subscribe proxies data to clash proxies config
@@ -202,8 +201,7 @@ func ConvertsV2Ray(buf []byte) ([]map[string]any, error) {
 				vmess["servername"] = sni
 			}
 
-			network, _ := values["net"].(string)
-			network = strings.ToLower(network)
+			network := strings.ToLower(values["net"].(string))
 			if values["type"] == "http" {
 				network = "http"
 			} else if network == "http" {
@@ -211,13 +209,10 @@ func ConvertsV2Ray(buf []byte) ([]map[string]any, error) {
 			}
 			vmess["network"] = network
 
-			tls, ok := values["tls"].(string)
-			if ok {
-				tls = strings.ToLower(tls)
+			tls := strings.ToLower(values["tls"].(string))
 			if strings.HasSuffix(tls, "tls") {
 				vmess["tls"] = true
 			}
-			}
 
 			switch network {
 			case "http":

common/net/bind.go

@@ -3,43 +3,34 @@ package net
 import "net"
 
 type bindPacketConn struct {
-	EnhancePacketConn
+	net.PacketConn
 	rAddr net.Addr
 }
 
-func (c *bindPacketConn) Read(b []byte) (n int, err error) {
-	n, _, err = c.EnhancePacketConn.ReadFrom(b)
+func (wpc *bindPacketConn) Read(b []byte) (n int, err error) {
+	n, _, err = wpc.PacketConn.ReadFrom(b)
 	return n, err
 }
 
-func (c *bindPacketConn) WaitRead() (data []byte, put func(), err error) {
-	data, put, _, err = c.EnhancePacketConn.WaitReadFrom()
-	return
+func (wpc *bindPacketConn) Write(b []byte) (n int, err error) {
+	return wpc.PacketConn.WriteTo(b, wpc.rAddr)
 }
 
-func (c *bindPacketConn) Write(b []byte) (n int, err error) {
-	return c.EnhancePacketConn.WriteTo(b, c.rAddr)
+func (wpc *bindPacketConn) RemoteAddr() net.Addr {
+	return wpc.rAddr
 }
 
-func (c *bindPacketConn) RemoteAddr() net.Addr {
-	return c.rAddr
-}
-
-func (c *bindPacketConn) LocalAddr() net.Addr {
-	if c.EnhancePacketConn.LocalAddr() == nil {
+func (wpc *bindPacketConn) LocalAddr() net.Addr {
+	if wpc.PacketConn.LocalAddr() == nil {
 		return &net.UDPAddr{IP: net.IPv4zero, Port: 0}
 	} else {
-		return c.EnhancePacketConn.LocalAddr()
+		return wpc.PacketConn.LocalAddr()
 	}
 }
 
-func (c *bindPacketConn) Upstream() any {
-	return c.EnhancePacketConn
-}
-
 func NewBindPacketConn(pc net.PacketConn, rAddr net.Addr) net.Conn {
 	return &bindPacketConn{
-		EnhancePacketConn: NewEnhancePacketConn(pc),
+		PacketConn: pc,
 		rAddr:      rAddr,
 	}
 }

common/net/bufconn.go

@@ -62,35 +62,20 @@ func (c *BufferedConn) Buffered() int {
 }
 
 func (c *BufferedConn) ReadBuffer(buffer *buf.Buffer) (err error) {
-	if c.r != nil && c.r.Buffered() > 0 {
+	if c.r.Buffered() > 0 {
 		_, err = buffer.ReadOnceFrom(c.r)
 		return
 	}
 	return c.ExtendedConn.ReadBuffer(buffer)
 }
 
-func (c *BufferedConn) ReadCached() *buf.Buffer { // call in sing/common/bufio.Copy
-	if c.r != nil && c.r.Buffered() > 0 {
-		length := c.r.Buffered()
-		b, _ := c.r.Peek(length)
-		_, _ = c.r.Discard(length)
-		c.r = nil // drop bufio.Reader to let gc can clean up its internal buf
-		return buf.As(b)
-	}
-	return nil
-}
-
 func (c *BufferedConn) Upstream() any {
 	return c.ExtendedConn
 }
 
 func (c *BufferedConn) ReaderReplaceable() bool {
-	if c.r != nil && c.r.Buffered() > 0 {
+	if c.r.Buffered() > 0 {
 		return false
 	}
 	return true
 }
-
-func (c *BufferedConn) WriterReplaceable() bool {
-	return true
-}

common/net/deadline/packet.go

@@ -1,154 +0,0 @@
-package deadline
-
-import (
-	"net"
-	"os"
-	"runtime"
-	"time"
-
-	"github.com/Dreamacro/clash/common/atomic"
-	"github.com/Dreamacro/clash/common/net/packet"
-)
-
-type readResult struct {
-	data []byte
-	addr net.Addr
-	err  error
-}
-
-type NetPacketConn struct {
-	net.PacketConn
-	deadline     atomic.TypedValue[time.Time]
-	pipeDeadline pipeDeadline
-	disablePipe  atomic.Bool
-	inRead       atomic.Bool
-	resultCh     chan any
-}
-
-func NewNetPacketConn(pc net.PacketConn) net.PacketConn {
-	npc := &NetPacketConn{
-		PacketConn:   pc,
-		pipeDeadline: makePipeDeadline(),
-		resultCh:     make(chan any, 1),
-	}
-	npc.resultCh <- nil
-	if enhancePC, isEnhance := pc.(packet.EnhancePacketConn); isEnhance {
-		epc := &EnhancePacketConn{
-			NetPacketConn: npc,
-			enhancePacketConn: enhancePacketConn{
-				netPacketConn:     npc,
-				enhancePacketConn: enhancePC,
-			},
-		}
-		if singPC, isSingPC := pc.(packet.SingPacketConn); isSingPC {
-			return &EnhanceSingPacketConn{
-				EnhancePacketConn: epc,
-				singPacketConn: singPacketConn{
-					netPacketConn:  npc,
-					singPacketConn: singPC,
-				},
-			}
-		}
-		return epc
-	}
-	if singPC, isSingPC := pc.(packet.SingPacketConn); isSingPC {
-		return &SingPacketConn{
-			NetPacketConn: npc,
-			singPacketConn: singPacketConn{
-				netPacketConn:  npc,
-				singPacketConn: singPC,
-			},
-		}
-	}
-	return npc
-}
-
-func (c *NetPacketConn) ReadFrom(p []byte) (n int, addr net.Addr, err error) {
-FOR:
-	for {
-		select {
-		case result := <-c.resultCh:
-			if result != nil {
-				if result, ok := result.(*readResult); ok {
-					n = copy(p, result.data)
-					addr = result.addr
-					err = result.err
-					c.resultCh <- nil // finish cache read
-					return
-				}
-				c.resultCh <- result // another type of read
-				runtime.Gosched()    // allowing other goroutines to run
-				continue FOR
-			} else {
-				c.resultCh <- nil
-				break FOR
-			}
-		case <-c.pipeDeadline.wait():
-			return 0, nil, os.ErrDeadlineExceeded
-		}
-	}
-
-	if c.disablePipe.Load() {
-		return c.PacketConn.ReadFrom(p)
-	} else if c.deadline.Load().IsZero() {
-		c.inRead.Store(true)
-		defer c.inRead.Store(false)
-		n, addr, err = c.PacketConn.ReadFrom(p)
-		return
-	}
-
-	<-c.resultCh
-	go c.pipeReadFrom(len(p))
-
-	return c.ReadFrom(p)
-}
-
-func (c *NetPacketConn) pipeReadFrom(size int) {
-	buffer := make([]byte, size)
-	n, addr, err := c.PacketConn.ReadFrom(buffer)
-	buffer = buffer[:n]
-	result := &readResult{}
-	result.data = buffer
-	result.addr = addr
-	result.err = err
-	c.resultCh <- result
-}
-
-func (c *NetPacketConn) SetReadDeadline(t time.Time) error {
-	if c.disablePipe.Load() {
-		return c.PacketConn.SetReadDeadline(t)
-	} else if c.inRead.Load() {
-		c.disablePipe.Store(true)
-		return c.PacketConn.SetReadDeadline(t)
-	}
-	c.deadline.Store(t)
-	c.pipeDeadline.set(t)
-	return nil
-}
-
-func (c *NetPacketConn) ReaderReplaceable() bool {
-	select {
-	case result := <-c.resultCh:
-		c.resultCh <- result
-		if result != nil {
-			return false // cache reading
-		} else {
-			break
-		}
-	default:
-		return false // pipe reading
-	}
-	return c.disablePipe.Load() || c.deadline.Load().IsZero()
-}
-
-func (c *NetPacketConn) WriterReplaceable() bool {
-	return true
-}
-
-func (c *NetPacketConn) Upstream() any {
-	return c.PacketConn
-}
-
-func (c *NetPacketConn) NeedAdditionalReadDeadline() bool {
-	return false
-}

common/net/deadline/packet_enhance.go

@@ -1,83 +0,0 @@
-package deadline
-
-import (
-	"net"
-	"os"
-	"runtime"
-
-	"github.com/Dreamacro/clash/common/net/packet"
-)
-
-type EnhancePacketConn struct {
-	*NetPacketConn
-	enhancePacketConn
-}
-
-var _ packet.EnhancePacketConn = (*EnhancePacketConn)(nil)
-
-func NewEnhancePacketConn(pc packet.EnhancePacketConn) packet.EnhancePacketConn {
-	return NewNetPacketConn(pc).(packet.EnhancePacketConn)
-}
-
-type enhanceReadResult struct {
-	data []byte
-	put  func()
-	addr net.Addr
-	err  error
-}
-
-type enhancePacketConn struct {
-	netPacketConn     *NetPacketConn
-	enhancePacketConn packet.EnhancePacketConn
-}
-
-func (c *enhancePacketConn) WaitReadFrom() (data []byte, put func(), addr net.Addr, err error) {
-FOR:
-	for {
-		select {
-		case result := <-c.netPacketConn.resultCh:
-			if result != nil {
-				if result, ok := result.(*enhanceReadResult); ok {
-					data = result.data
-					put = result.put
-					addr = result.addr
-					err = result.err
-					c.netPacketConn.resultCh <- nil // finish cache read
-					return
-				}
-				c.netPacketConn.resultCh <- result // another type of read
-				runtime.Gosched()                  // allowing other goroutines to run
-				continue FOR
-			} else {
-				c.netPacketConn.resultCh <- nil
-				break FOR
-			}
-		case <-c.netPacketConn.pipeDeadline.wait():
-			return nil, nil, nil, os.ErrDeadlineExceeded
-		}
-	}
-
-	if c.netPacketConn.disablePipe.Load() {
-		return c.enhancePacketConn.WaitReadFrom()
-	} else if c.netPacketConn.deadline.Load().IsZero() {
-		c.netPacketConn.inRead.Store(true)
-		defer c.netPacketConn.inRead.Store(false)
-		data, put, addr, err = c.enhancePacketConn.WaitReadFrom()
-		return
-	}
-
-	<-c.netPacketConn.resultCh
-	go c.pipeWaitReadFrom()
-
-	return c.WaitReadFrom()
-}
-
-func (c *enhancePacketConn) pipeWaitReadFrom() {
-	data, put, addr, err := c.enhancePacketConn.WaitReadFrom()
-	result := &enhanceReadResult{}
-	result.data = data
-	result.put = put
-	result.addr = addr
-	result.err = err
-	c.netPacketConn.resultCh <- result
-}

common/net/deadline/packet_sing.go

@@ -1,177 +0,0 @@
-package deadline
-
-import (
-	"os"
-	"runtime"
-
-	"github.com/Dreamacro/clash/common/net/packet"
-	"github.com/sagernet/sing/common/buf"
-	"github.com/sagernet/sing/common/bufio"
-	M "github.com/sagernet/sing/common/metadata"
-	N "github.com/sagernet/sing/common/network"
-)
-
-type SingPacketConn struct {
-	*NetPacketConn
-	singPacketConn
-}
-
-var _ packet.SingPacketConn = (*SingPacketConn)(nil)
-
-func NewSingPacketConn(pc packet.SingPacketConn) packet.SingPacketConn {
-	return NewNetPacketConn(pc).(packet.SingPacketConn)
-}
-
-type EnhanceSingPacketConn struct {
-	*EnhancePacketConn
-	singPacketConn
-}
-
-func NewEnhanceSingPacketConn(pc packet.EnhanceSingPacketConn) packet.EnhanceSingPacketConn {
-	return NewNetPacketConn(pc).(packet.EnhanceSingPacketConn)
-}
-
-var _ packet.EnhanceSingPacketConn = (*EnhanceSingPacketConn)(nil)
-
-type singReadResult struct {
-	buffer      *buf.Buffer
-	destination M.Socksaddr
-	err         error
-}
-
-type singPacketConn struct {
-	netPacketConn  *NetPacketConn
-	singPacketConn packet.SingPacketConn
-}
-
-func (c *singPacketConn) ReadPacket(buffer *buf.Buffer) (destination M.Socksaddr, err error) {
-FOR:
-	for {
-		select {
-		case result := <-c.netPacketConn.resultCh:
-			if result != nil {
-				if result, ok := result.(*singReadResult); ok {
-					destination = result.destination
-					err = result.err
-					n, _ := buffer.Write(result.buffer.Bytes())
-					result.buffer.Advance(n)
-					if result.buffer.IsEmpty() {
-						result.buffer.Release()
-					}
-					c.netPacketConn.resultCh <- nil // finish cache read
-					return
-				}
-				c.netPacketConn.resultCh <- result // another type of read
-				runtime.Gosched()                  // allowing other goroutines to run
-				continue FOR
-			} else {
-				c.netPacketConn.resultCh <- nil
-				break FOR
-			}
-		case <-c.netPacketConn.pipeDeadline.wait():
-			return M.Socksaddr{}, os.ErrDeadlineExceeded
-		}
-	}
-
-	if c.netPacketConn.disablePipe.Load() {
-		return c.singPacketConn.ReadPacket(buffer)
-	} else if c.netPacketConn.deadline.Load().IsZero() {
-		c.netPacketConn.inRead.Store(true)
-		defer c.netPacketConn.inRead.Store(false)
-		destination, err = c.singPacketConn.ReadPacket(buffer)
-		return
-	}
-
-	<-c.netPacketConn.resultCh
-	go c.pipeReadPacket(buffer.FreeLen())
-
-	return c.ReadPacket(buffer)
-}
-
-func (c *singPacketConn) pipeReadPacket(pLen int) {
-	buffer := buf.NewSize(pLen)
-	destination, err := c.singPacketConn.ReadPacket(buffer)
-	result := &singReadResult{}
-	result.destination = destination
-	result.err = err
-	c.netPacketConn.resultCh <- result
-}
-
-func (c *singPacketConn) WritePacket(buffer *buf.Buffer, destination M.Socksaddr) error {
-	return c.singPacketConn.WritePacket(buffer, destination)
-}
-
-func (c *singPacketConn) CreateReadWaiter() (N.PacketReadWaiter, bool) {
-	prw, isReadWaiter := bufio.CreatePacketReadWaiter(c.singPacketConn)
-	if isReadWaiter {
-		return &singPacketReadWaiter{
-			netPacketConn:    c.netPacketConn,
-			packetReadWaiter: prw,
-		}, true
-	}
-	return nil, false
-}
-
-var _ N.PacketReadWaiter = (*singPacketReadWaiter)(nil)
-
-type singPacketReadWaiter struct {
-	netPacketConn    *NetPacketConn
-	packetReadWaiter N.PacketReadWaiter
-}
-
-type singWaitReadResult singReadResult
-
-func (c *singPacketReadWaiter) InitializeReadWaiter(newBuffer func() *buf.Buffer) {
-	c.packetReadWaiter.InitializeReadWaiter(newBuffer)
-}
-
-func (c *singPacketReadWaiter) WaitReadPacket() (destination M.Socksaddr, err error) {
-FOR:
-	for {
-		select {
-		case result := <-c.netPacketConn.resultCh:
-			if result != nil {
-				if result, ok := result.(*singWaitReadResult); ok {
-					destination = result.destination
-					err = result.err
-					c.netPacketConn.resultCh <- nil // finish cache read
-					return
-				}
-				c.netPacketConn.resultCh <- result // another type of read
-				runtime.Gosched()                  // allowing other goroutines to run
-				continue FOR
-			} else {
-				c.netPacketConn.resultCh <- nil
-				break FOR
-			}
-		case <-c.netPacketConn.pipeDeadline.wait():
-			return M.Socksaddr{}, os.ErrDeadlineExceeded
-		}
-	}
-
-	if c.netPacketConn.disablePipe.Load() {
-		return c.packetReadWaiter.WaitReadPacket()
-	} else if c.netPacketConn.deadline.Load().IsZero() {
-		c.netPacketConn.inRead.Store(true)
-		defer c.netPacketConn.inRead.Store(false)
-		destination, err = c.packetReadWaiter.WaitReadPacket()
-		return
-	}
-
-	<-c.netPacketConn.resultCh
-	go c.pipeWaitReadPacket()
-
-	return c.WaitReadPacket()
-}
-
-func (c *singPacketReadWaiter) pipeWaitReadPacket() {
-	destination, err := c.packetReadWaiter.WaitReadPacket()
-	result := &singWaitReadResult{}
-	result.destination = destination
-	result.err = err
-	c.netPacketConn.resultCh <- result
-}
-
-func (c *singPacketReadWaiter) Upstream() any {
-	return c.packetReadWaiter
-}

common/net/deadline/pipe.go

@@ -1,84 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package deadline
-
-import (
-	"sync"
-	"time"
-)
-
-// pipeDeadline is an abstraction for handling timeouts.
-type pipeDeadline struct {
-	mu     sync.Mutex // Guards timer and cancel
-	timer  *time.Timer
-	cancel chan struct{} // Must be non-nil
-}
-
-func makePipeDeadline() pipeDeadline {
-	return pipeDeadline{cancel: make(chan struct{})}
-}
-
-// set sets the point in time when the deadline will time out.
-// A timeout event is signaled by closing the channel returned by waiter.
-// Once a timeout has occurred, the deadline can be refreshed by specifying a
-// t value in the future.
-//
-// A zero value for t prevents timeout.
-func (d *pipeDeadline) set(t time.Time) {
-	d.mu.Lock()
-	defer d.mu.Unlock()
-
-	if d.timer != nil && !d.timer.Stop() {
-		<-d.cancel // Wait for the timer callback to finish and close cancel
-	}
-	d.timer = nil
-
-	// Time is zero, then there is no deadline.
-	closed := isClosedChan(d.cancel)
-	if t.IsZero() {
-		if closed {
-			d.cancel = make(chan struct{})
-		}
-		return
-	}
-
-	// Time in the future, setup a timer to cancel in the future.
-	if dur := time.Until(t); dur > 0 {
-		if closed {
-			d.cancel = make(chan struct{})
-		}
-		d.timer = time.AfterFunc(dur, func() {
-			close(d.cancel)
-		})
-		return
-	}
-
-	// Time in the past, so close immediately.
-	if !closed {
-		close(d.cancel)
-	}
-}
-
-// wait returns a channel that is closed when the deadline is exceeded.
-func (d *pipeDeadline) wait() chan struct{} {
-	d.mu.Lock()
-	defer d.mu.Unlock()
-	return d.cancel
-}
-
-func isClosedChan(c <-chan struct{}) bool {
-	select {
-	case <-c:
-		return true
-	default:
-		return false
-	}
-}
-
-func makeFilledChan() chan struct{} {
-	ch := make(chan struct{}, 1)
-	ch <- struct{}{}
-	return ch
-}

common/net/packet.go

@@ -1,18 +0,0 @@
-package net
-
-import (
-	"github.com/Dreamacro/clash/common/net/deadline"
-	"github.com/Dreamacro/clash/common/net/packet"
-)
-
-type EnhancePacketConn = packet.EnhancePacketConn
-type WaitReadFrom = packet.WaitReadFrom
-
-var NewEnhancePacketConn = packet.NewEnhancePacketConn
-var NewThreadSafePacketConn = packet.NewThreadSafePacketConn
-var NewRefPacketConn = packet.NewRefPacketConn
-
-var NewDeadlineNetPacketConn = deadline.NewNetPacketConn
-var NewDeadlineEnhancePacketConn = deadline.NewEnhancePacketConn
-var NewDeadlineSingPacketConn = deadline.NewSingPacketConn
-var NewDeadlineEnhanceSingPacketConn = deadline.NewEnhanceSingPacketConn

common/net/packet/packet.go

@@ -1,77 +0,0 @@
-package packet
-
-import (
-	"net"
-
-	"github.com/Dreamacro/clash/common/pool"
-)
-
-type WaitReadFrom interface {
-	WaitReadFrom() (data []byte, put func(), addr net.Addr, err error)
-}
-
-type EnhancePacketConn interface {
-	net.PacketConn
-	WaitReadFrom
-}
-
-func NewEnhancePacketConn(pc net.PacketConn) EnhancePacketConn {
-	if udpConn, isUDPConn := pc.(*net.UDPConn); isUDPConn {
-		return &enhanceUDPConn{UDPConn: udpConn}
-	}
-	if enhancePC, isEnhancePC := pc.(EnhancePacketConn); isEnhancePC {
-		return enhancePC
-	}
-	if singPC, isSingPC := pc.(SingPacketConn); isSingPC {
-		return newEnhanceSingPacketConn(singPC)
-	}
-	return &enhancePacketConn{PacketConn: pc}
-}
-
-type enhancePacketConn struct {
-	net.PacketConn
-}
-
-func (c *enhancePacketConn) WaitReadFrom() (data []byte, put func(), addr net.Addr, err error) {
-	return waitReadFrom(c.PacketConn)
-}
-
-func (c *enhancePacketConn) Upstream() any {
-	return c.PacketConn
-}
-
-func (c *enhancePacketConn) WriterReplaceable() bool {
-	return true
-}
-
-func (c *enhancePacketConn) ReaderReplaceable() bool {
-	return true
-}
-
-func (c *enhanceUDPConn) Upstream() any {
-	return c.UDPConn
-}
-
-func (c *enhanceUDPConn) WriterReplaceable() bool {
-	return true
-}
-
-func (c *enhanceUDPConn) ReaderReplaceable() bool {
-	return true
-}
-
-func waitReadFrom(pc net.PacketConn) (data []byte, put func(), addr net.Addr, err error) {
-	readBuf := pool.Get(pool.UDPBufferSize)
-	put = func() {
-		_ = pool.Put(readBuf)
-	}
-	var readN int
-	readN, addr, err = pc.ReadFrom(readBuf)
-	if readN > 0 {
-		data = readBuf[:readN]
-	} else {
-		put()
-		put = nil
-	}
-	return
-}

common/net/packet/packet_posix.go

@@ -1,65 +0,0 @@
-//go:build !windows
-
-package packet
-
-import (
-	"net"
-	"strconv"
-	"syscall"
-
-	"github.com/Dreamacro/clash/common/pool"
-)
-
-type enhanceUDPConn struct {
-	*net.UDPConn
-	rawConn syscall.RawConn
-}
-
-func (c *enhanceUDPConn) WaitReadFrom() (data []byte, put func(), addr net.Addr, err error) {
-	if c.rawConn == nil {
-		c.rawConn, _ = c.UDPConn.SyscallConn()
-	}
-	var readErr error
-	err = c.rawConn.Read(func(fd uintptr) (done bool) {
-		readBuf := pool.Get(pool.UDPBufferSize)
-		put = func() {
-			_ = pool.Put(readBuf)
-		}
-		var readFrom syscall.Sockaddr
-		var readN int
-		readN, _, _, readFrom, readErr = syscall.Recvmsg(int(fd), readBuf, nil, 0)
-		if readN > 0 {
-			data = readBuf[:readN]
-		} else {
-			put()
-			put = nil
-			data = nil
-		}
-		if readErr == syscall.EAGAIN {
-			return false
-		}
-		if readFrom != nil {
-			switch from := readFrom.(type) {
-			case *syscall.SockaddrInet4:
-				ip := from.Addr // copy from.Addr; ip escapes, so this line allocates 4 bytes
-				addr = &net.UDPAddr{IP: ip[:], Port: from.Port}
-			case *syscall.SockaddrInet6:
-				ip := from.Addr // copy from.Addr; ip escapes, so this line allocates 16 bytes
-				addr = &net.UDPAddr{IP: ip[:], Port: from.Port, Zone: strconv.FormatInt(int64(from.ZoneId), 10)}
-			}
-		}
-		// udp should not convert readN == 0 to io.EOF
-		//if readN == 0 {
-		//	readErr = io.EOF
-		//}
-		return true
-	})
-	if err != nil {
-		return
-	}
-	if readErr != nil {
-		err = readErr
-		return
-	}
-	return
-}

common/net/packet/packet_sing.go

@@ -1,79 +0,0 @@
-package packet
-
-import (
-	"net"
-
-	"github.com/sagernet/sing/common/buf"
-	"github.com/sagernet/sing/common/bufio"
-	M "github.com/sagernet/sing/common/metadata"
-	N "github.com/sagernet/sing/common/network"
-)
-
-type SingPacketConn = N.NetPacketConn
-
-type EnhanceSingPacketConn interface {
-	SingPacketConn
-	EnhancePacketConn
-}
-
-type enhanceSingPacketConn struct {
-	SingPacketConn
-	packetReadWaiter N.PacketReadWaiter
-}
-
-func (c *enhanceSingPacketConn) WaitReadFrom() (data []byte, put func(), addr net.Addr, err error) {
-	var buff *buf.Buffer
-	var dest M.Socksaddr
-	newBuffer := func() *buf.Buffer {
-		buff = buf.NewPacket() // do not use stack buffer
-		return buff
-	}
-	if c.packetReadWaiter != nil {
-		c.packetReadWaiter.InitializeReadWaiter(newBuffer)
-		defer c.packetReadWaiter.InitializeReadWaiter(nil)
-		dest, err = c.packetReadWaiter.WaitReadPacket()
-	} else {
-		dest, err = c.SingPacketConn.ReadPacket(newBuffer())
-	}
-	if dest.IsFqdn() {
-		addr = dest
-	} else {
-		addr = dest.UDPAddr()
-	}
-	if err != nil {
-		if buff != nil {
-			buff.Release()
-		}
-		return
-	}
-	if buff == nil {
-		return
-	}
-	if buff.IsEmpty() {
-		buff.Release()
-		return
-	}
-	data = buff.Bytes()
-	put = buff.Release
-	return
-}
-
-func (c *enhanceSingPacketConn) Upstream() any {
-	return c.SingPacketConn
-}
-
-func (c *enhanceSingPacketConn) WriterReplaceable() bool {
-	return true
-}
-
-func (c *enhanceSingPacketConn) ReaderReplaceable() bool {
-	return true
-}
-
-func newEnhanceSingPacketConn(conn SingPacketConn) *enhanceSingPacketConn {
-	epc := &enhanceSingPacketConn{SingPacketConn: conn}
-	if readWaiter, isReadWaiter := bufio.CreatePacketReadWaiter(conn); isReadWaiter {
-		epc.packetReadWaiter = readWaiter
-	}
-	return epc
-}

common/net/packet/packet_windows.go

@@ -1,15 +0,0 @@
-//go:build windows
-
-package packet
-
-import (
-	"net"
-)
-
-type enhanceUDPConn struct {
-	*net.UDPConn
-}
-
-func (c *enhanceUDPConn) WaitReadFrom() (data []byte, put func(), addr net.Addr, err error) {
-	return waitReadFrom(c.UDPConn)
-}

common/net/packet/ref.go

@@ -1,75 +0,0 @@
-package packet
-
-import (
-	"net"
-	"runtime"
-	"time"
-)
-
-type refPacketConn struct {
-	pc  EnhancePacketConn
-	ref any
-}
-
-func (c *refPacketConn) WaitReadFrom() (data []byte, put func(), addr net.Addr, err error) {
-	defer runtime.KeepAlive(c.ref)
-	return c.pc.WaitReadFrom()
-}
-
-func (c *refPacketConn) ReadFrom(p []byte) (n int, addr net.Addr, err error) {
-	defer runtime.KeepAlive(c.ref)
-	return c.pc.ReadFrom(p)
-}
-
-func (c *refPacketConn) WriteTo(p []byte, addr net.Addr) (n int, err error) {
-	defer runtime.KeepAlive(c.ref)
-	return c.pc.WriteTo(p, addr)
-}
-
-func (c *refPacketConn) Close() error {
-	defer runtime.KeepAlive(c.ref)
-	return c.pc.Close()
-}
-
-func (c *refPacketConn) LocalAddr() net.Addr {
-	defer runtime.KeepAlive(c.ref)
-	return c.pc.LocalAddr()
-}
-
-func (c *refPacketConn) SetDeadline(t time.Time) error {
-	defer runtime.KeepAlive(c.ref)
-	return c.pc.SetDeadline(t)
-}
-
-func (c *refPacketConn) SetReadDeadline(t time.Time) error {
-	defer runtime.KeepAlive(c.ref)
-	return c.pc.SetReadDeadline(t)
-}
-
-func (c *refPacketConn) SetWriteDeadline(t time.Time) error {
-	defer runtime.KeepAlive(c.ref)
-	return c.pc.SetWriteDeadline(t)
-}
-
-func (c *refPacketConn) Upstream() any {
-	return c.pc
-}
-
-func (c *refPacketConn) ReaderReplaceable() bool { // Relay() will handle reference
-	return true
-}
-
-func (c *refPacketConn) WriterReplaceable() bool { // Relay() will handle reference
-	return true
-}
-
-func NewRefPacketConn(pc net.PacketConn, ref any) EnhancePacketConn {
-	rPC := &refPacketConn{pc: NewEnhancePacketConn(pc), ref: ref}
-	if singPC, isSingPC := pc.(SingPacketConn); isSingPC {
-		return &refSingPacketConn{
-			refPacketConn:  rPC,
-			singPacketConn: singPC,
-		}
-	}
-	return rPC
-}

common/net/packet/ref_sing.go

@@ -1,26 +0,0 @@
-package packet
-
-import (
-	"runtime"
-
-	"github.com/sagernet/sing/common/buf"
-	M "github.com/sagernet/sing/common/metadata"
-	N "github.com/sagernet/sing/common/network"
-)
-
-type refSingPacketConn struct {
-	*refPacketConn
-	singPacketConn SingPacketConn
-}
-
-var _ N.NetPacketConn = (*refSingPacketConn)(nil)
-
-func (c *refSingPacketConn) WritePacket(buffer *buf.Buffer, destination M.Socksaddr) error {
-	defer runtime.KeepAlive(c.ref)
-	return c.singPacketConn.WritePacket(buffer, destination)
-}
-
-func (c *refSingPacketConn) ReadPacket(buffer *buf.Buffer) (destination M.Socksaddr, err error) {
-	defer runtime.KeepAlive(c.ref)
-	return c.singPacketConn.ReadPacket(buffer)
-}

common/net/packet/thread.go

@@ -1,36 +0,0 @@
-package packet
-
-import (
-	"net"
-	"sync"
-)
-
-type threadSafePacketConn struct {
-	EnhancePacketConn
-	access sync.Mutex
-}
-
-func (c *threadSafePacketConn) WriteTo(b []byte, addr net.Addr) (int, error) {
-	c.access.Lock()
-	defer c.access.Unlock()
-	return c.EnhancePacketConn.WriteTo(b, addr)
-}
-
-func (c *threadSafePacketConn) Upstream() any {
-	return c.EnhancePacketConn
-}
-
-func (c *threadSafePacketConn) ReaderReplaceable() bool {
-	return true
-}
-
-func NewThreadSafePacketConn(pc net.PacketConn) EnhancePacketConn {
-	tsPC := &threadSafePacketConn{EnhancePacketConn: NewEnhancePacketConn(pc)}
-	if singPC, isSingPC := pc.(SingPacketConn); isSingPC {
-		return &threadSafeSingPacketConn{
-			threadSafePacketConn: tsPC,
-			singPacketConn:       singPC,
-		}
-	}
-	return tsPC
-}

common/net/packet/thread_sing.go

@@ -1,24 +0,0 @@
-package packet
-
-import (
-	"github.com/sagernet/sing/common/buf"
-	M "github.com/sagernet/sing/common/metadata"
-	N "github.com/sagernet/sing/common/network"
-)
-
-type threadSafeSingPacketConn struct {
-	*threadSafePacketConn
-	singPacketConn SingPacketConn
-}
-
-var _ N.NetPacketConn = (*threadSafeSingPacketConn)(nil)
-
-func (c *threadSafeSingPacketConn) WritePacket(buffer *buf.Buffer, destination M.Socksaddr) error {
-	c.access.Lock()
-	defer c.access.Unlock()
-	return c.singPacketConn.WritePacket(buffer, destination)
-}
-
-func (c *threadSafeSingPacketConn) ReadPacket(buffer *buf.Buffer) (destination M.Socksaddr, err error) {
-	return c.singPacketConn.ReadPacket(buffer)
-}

common/net/refconn.go

@@ -4,12 +4,10 @@ import (
 	"net"
 	"runtime"
 	"time"
-
-	"github.com/Dreamacro/clash/common/buf"
 )
 
 type refConn struct {
-	conn ExtendedConn
+	conn net.Conn
 	ref  any
 }
 
@@ -57,26 +55,50 @@ func (c *refConn) Upstream() any {
 	return c.conn
 }
 
-func (c *refConn) ReadBuffer(buffer *buf.Buffer) error {
-	defer runtime.KeepAlive(c.ref)
-	return c.conn.ReadBuffer(buffer)
-}
-
-func (c *refConn) WriteBuffer(buffer *buf.Buffer) error {
-	defer runtime.KeepAlive(c.ref)
-	return c.conn.WriteBuffer(buffer)
-}
-
-func (c *refConn) ReaderReplaceable() bool { // Relay() will handle reference
-	return true
-}
-
-func (c *refConn) WriterReplaceable() bool { // Relay() will handle reference
-	return true
-}
-
-var _ ExtendedConn = (*refConn)(nil)
-
 func NewRefConn(conn net.Conn, ref any) net.Conn {
-	return &refConn{conn: NewExtendedConn(conn), ref: ref}
+	return &refConn{conn: conn, ref: ref}
+}
+
+type refPacketConn struct {
+	pc  net.PacketConn
+	ref any
+}
+
+func (pc *refPacketConn) ReadFrom(p []byte) (n int, addr net.Addr, err error) {
+	defer runtime.KeepAlive(pc.ref)
+	return pc.pc.ReadFrom(p)
+}
+
+func (pc *refPacketConn) WriteTo(p []byte, addr net.Addr) (n int, err error) {
+	defer runtime.KeepAlive(pc.ref)
+	return pc.pc.WriteTo(p, addr)
+}
+
+func (pc *refPacketConn) Close() error {
+	defer runtime.KeepAlive(pc.ref)
+	return pc.pc.Close()
+}
+
+func (pc *refPacketConn) LocalAddr() net.Addr {
+	defer runtime.KeepAlive(pc.ref)
+	return pc.pc.LocalAddr()
+}
+
+func (pc *refPacketConn) SetDeadline(t time.Time) error {
+	defer runtime.KeepAlive(pc.ref)
+	return pc.pc.SetDeadline(t)
+}
+
+func (pc *refPacketConn) SetReadDeadline(t time.Time) error {
+	defer runtime.KeepAlive(pc.ref)
+	return pc.pc.SetReadDeadline(t)
+}
+
+func (pc *refPacketConn) SetWriteDeadline(t time.Time) error {
+	defer runtime.KeepAlive(pc.ref)
+	return pc.pc.SetWriteDeadline(t)
+}
+
+func NewRefPacketConn(pc net.PacketConn, ref any) net.PacketConn {
+	return &refPacketConn{pc: pc, ref: ref}
 }

common/net/sing.go

@@ -3,11 +3,9 @@ package net
 import (
 	"context"
 	"net"
-	"runtime"
 
 	"github.com/sagernet/sing/common"
 	"github.com/sagernet/sing/common/bufio"
-	"github.com/sagernet/sing/common/bufio/deadline"
 	"github.com/sagernet/sing/common/network"
 )
 
@@ -19,10 +17,6 @@ type ExtendedConn = network.ExtendedConn
 type ExtendedWriter = network.ExtendedWriter
 type ExtendedReader = network.ExtendedReader
 
-func NewDeadlineConn(conn net.Conn) ExtendedConn {
-	return deadline.NewFallbackConn(conn)
-}
-
 func NeedHandshake(conn any) bool {
 	if earlyConn, isEarlyConn := common.Cast[network.EarlyConn](conn); isEarlyConn && earlyConn.NeedHandshake() {
 		return true
@@ -30,11 +24,7 @@ func NeedHandshake(conn any) bool {
 	return false
 }
 
-type CountFunc = network.CountFunc
-
 // Relay copies between left and right bidirectionally.
 func Relay(leftConn, rightConn net.Conn) {
-	defer runtime.KeepAlive(leftConn)
-	defer runtime.KeepAlive(rightConn)
 	_ = bufio.CopyConn(context.TODO(), leftConn, rightConn)
 }

common/net/tls.go

@@ -11,7 +11,7 @@ import (
 )
 
 func ParseCert(certificate, privateKey string) (tls.Certificate, error) {
-	if certificate == "" && privateKey == "" {
+	if certificate == "" || privateKey == "" {
 		return newRandomTLSKeyPair()
 	}
 	cert, painTextErr := tls.X509KeyPair([]byte(certificate), []byte(privateKey))

common/observable/observable_test.go

@@ -5,9 +5,8 @@ import (
 	"testing"
 	"time"
 
-	"github.com/Dreamacro/clash/common/atomic"
-
 	"github.com/stretchr/testify/assert"
+	"go.uber.org/atomic"
 )
 
 func iterator[T any](item []T) chan T {
@@ -45,7 +44,7 @@ func TestObservable_MultiSubscribe(t *testing.T) {
 	wg.Add(2)
 	waitCh := func(ch <-chan int) {
 		for range ch {
-			count.Add(1)
+			count.Inc()
 		}
 		wg.Done()
 	}

common/singledo/singledo_test.go

@@ -5,9 +5,8 @@ import (
 	"testing"
 	"time"
 
-	"github.com/Dreamacro/clash/common/atomic"
-
 	"github.com/stretchr/testify/assert"
+	"go.uber.org/atomic"
 )
 
 func TestBasic(t *testing.T) {
@@ -27,7 +26,7 @@ func TestBasic(t *testing.T) {
 		go func() {
 			_, _, shard := single.Do(call)
 			if shard {
-				shardCount.Add(1)
+				shardCount.Inc()
 			}
 			wg.Done()
 		}()

common/utils/uuid.go

@@ -1,7 +1,7 @@
 package utils
 
 import (
-	"github.com/gofrs/uuid/v5"
+	"github.com/gofrs/uuid"
 	"github.com/zhangyunhao116/fastrand"
 )
 

common/utils/uuid_test.go

@@ -1,7 +1,7 @@
 package utils
 
 import (
-	"github.com/gofrs/uuid/v5"
+	"github.com/gofrs/uuid"
 	"reflect"
 	"testing"
 )

component/dialer/bind_windows.go

@@ -3,7 +3,6 @@ package dialer
 import (
 	"context"
 	"encoding/binary"
-	"fmt"
 	"net"
 	"net/netip"
 	"syscall"
@@ -21,19 +20,11 @@ func bind4(handle syscall.Handle, ifaceIdx int) error {
 	var bytes [4]byte
 	binary.BigEndian.PutUint32(bytes[:], uint32(ifaceIdx))
 	idx := *(*uint32)(unsafe.Pointer(&bytes[0]))
-	err := syscall.SetsockoptInt(handle, syscall.IPPROTO_IP, IP_UNICAST_IF, int(idx))
-	if err != nil {
-		err = fmt.Errorf("bind4: %w", err)
-	}
-	return err
+	return syscall.SetsockoptInt(handle, syscall.IPPROTO_IP, IP_UNICAST_IF, int(idx))
 }
 
 func bind6(handle syscall.Handle, ifaceIdx int) error {
-	err := syscall.SetsockoptInt(handle, syscall.IPPROTO_IPV6, IPV6_UNICAST_IF, ifaceIdx)
-	if err != nil {
-		err = fmt.Errorf("bind6: %w", err)
-	}
-	return err
+	return syscall.SetsockoptInt(handle, syscall.IPPROTO_IPV6, IPV6_UNICAST_IF, ifaceIdx)
 }
 
 func bindControl(ifaceIdx int) controlFn {
@@ -58,9 +49,9 @@ func bindControl(ifaceIdx int) controlFn {
 				if (!addrPort.Addr().IsValid() || addrPort.Addr().IsUnspecified()) && bind6err != nil {
 					// try bind ipv6, if failed, ignore. it's a workaround for windows disable interface ipv6
 					if bind4err != nil {
-						innerErr = fmt.Errorf("%w (%s)", bind6err, bind4err)
+						innerErr = bind6err
 					} else {
-						innerErr = nil
+						innerErr = bind4err
 					}
 				} else {
 					innerErr = bind6err

component/dialer/dialer.go

@@ -157,7 +157,7 @@ func concurrentDualStackDialContext(ctx context.Context, network string, ips []n
 }
 
 func dualStackDialContext(ctx context.Context, dialFn dialFunc, network string, ips []netip.Addr, port string, opt *option) (net.Conn, error) {
-	ipv4s, ipv6s := resolver.SortationAddr(ips)
+	ipv4s, ipv6s := sortationAddr(ips)
 	preferIPVersion := opt.prefer
 
 	fallbackTicker := time.NewTicker(fallbackTimeout)
@@ -309,16 +309,27 @@ func parseAddr(ctx context.Context, network, address string, preferResolver reso
 	return ips, port, nil
 }
 
+func sortationAddr(ips []netip.Addr) (ipv4s, ipv6s []netip.Addr) {
+	for _, v := range ips {
+		if v.Is4() { // 4in6 parse was in parseAddr
+			ipv4s = append(ipv4s, v)
+		} else {
+			ipv6s = append(ipv6s, v)
+		}
+	}
+	return
+}
+
 type Dialer struct {
-	Opt option
+	opt option
 }
 
 func (d Dialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
-	return DialContext(ctx, network, address, WithOption(d.Opt))
+	return DialContext(ctx, network, address, WithOption(d.opt))
 }
 
 func (d Dialer) ListenPacket(ctx context.Context, network, address string, rAddrPort netip.AddrPort) (net.PacketConn, error) {
-	opt := WithOption(d.Opt)
+	opt := WithOption(d.opt)
 	if rAddrPort.Addr().Unmap().IsLoopback() {
 		// avoid "The requested address is not valid in its context."
 		opt = WithInterface("")
@@ -328,5 +339,5 @@ func (d Dialer) ListenPacket(ctx context.Context, network, address string, rAddr
 
 func NewDialer(options ...Option) Dialer {
 	opt := applyOptions(options...)
-	return Dialer{Opt: *opt}
+	return Dialer{opt: *opt}
 }

component/dialer/options.go

@@ -4,13 +4,14 @@ import (
 	"context"
 	"net"
 
-	"github.com/Dreamacro/clash/common/atomic"
 	"github.com/Dreamacro/clash/component/resolver"
+
+	"go.uber.org/atomic"
 )
 
 var (
 	DefaultOptions     []Option
-	DefaultInterface   = atomic.NewTypedValue[string]("")
+	DefaultInterface   = atomic.NewString("")
 	DefaultRoutingMark = atomic.NewInt32(0)
 )
 

component/dialer/tfo.go

@@ -18,11 +18,10 @@ type tfoConn struct {
 }
 
 func (c *tfoConn) Dial(earlyData []byte) (err error) {
-	conn, err := c.dialFn(c.ctx, earlyData)
+	c.Conn, err = c.dialFn(c.ctx, earlyData)
 	if err != nil {
 		return
 	}
-	c.Conn = conn
 	c.dialed <- true
 	return err
 }
@@ -106,22 +105,10 @@ func (c *tfoConn) Upstream() any {
 	return c.Conn
 }
 
-func (c *tfoConn) NeedAdditionalReadDeadline() bool {
-	return c.Conn == nil
-}
-
 func (c *tfoConn) NeedHandshake() bool {
 	return c.Conn == nil
 }
 
-func (c *tfoConn) ReaderReplaceable() bool {
-	return c.Conn != nil
-}
-
-func (c *tfoConn) WriterReplaceable() bool {
-	return c.Conn != nil
-}
-
 func dialTFO(ctx context.Context, netDialer net.Dialer, network, address string) (net.Conn, error) {
 	ctx, cancel := context.WithCancel(ctx)
 	dialer := tfo.Dialer{Dialer: netDialer, DisableTFO: false}

component/geodata/init.go

@@ -1,17 +1,13 @@
 package geodata
 
 import (
-	"context"
 	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"time"
-
-	clashHttp "github.com/Dreamacro/clash/component/http"
 	"github.com/Dreamacro/clash/component/mmdb"
 	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/log"
+	"io"
+	"net/http"
+	"os"
 )
 
 var initGeoSite bool
@@ -42,9 +38,7 @@ func InitGeoSite() error {
 }
 
 func downloadGeoSite(path string) (err error) {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second*90)
-	defer cancel()
-	resp, err := clashHttp.HttpRequest(ctx, C.GeoSiteUrl, http.MethodGet, http.Header{"User-Agent": {"clash"}}, nil)
+	resp, err := http.Get(C.GeoSiteUrl)
 	if err != nil {
 		return
 	}
@@ -61,9 +55,7 @@ func downloadGeoSite(path string) (err error) {
 }
 
 func downloadGeoIP(path string) (err error) {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second*90)
-	defer cancel()
-	resp, err := clashHttp.HttpRequest(ctx, C.GeoIpUrl, http.MethodGet, http.Header{"User-Agent": {"clash"}}, nil)
+	resp, err := http.Get(C.GeoIpUrl)
 	if err != nil {
 		return
 	}

component/geodata/strmatcher/mph_matcher.go

@@ -234,26 +234,26 @@ tail:
 	case s == 0:
 	case s < 4:
 		h ^= uint64(*(*byte)(p))
-		h ^= uint64(*(*byte)(unsafe.Add(p, s>>1))) << 8
-		h ^= uint64(*(*byte)(unsafe.Add(p, s-1))) << 16
+		h ^= uint64(*(*byte)(add(p, s>>1))) << 8
+		h ^= uint64(*(*byte)(add(p, s-1))) << 16
 		h = rotl31(h*m1) * m2
 	case s <= 8:
 		h ^= uint64(readUnaligned32(p))
-		h ^= uint64(readUnaligned32(unsafe.Add(p, s-4))) << 32
+		h ^= uint64(readUnaligned32(add(p, s-4))) << 32
 		h = rotl31(h*m1) * m2
 	case s <= 16:
 		h ^= readUnaligned64(p)
 		h = rotl31(h*m1) * m2
-		h ^= readUnaligned64(unsafe.Add(p, s-8))
+		h ^= readUnaligned64(add(p, s-8))
 		h = rotl31(h*m1) * m2
 	case s <= 32:
 		h ^= readUnaligned64(p)
 		h = rotl31(h*m1) * m2
-		h ^= readUnaligned64(unsafe.Add(p, 8))
+		h ^= readUnaligned64(add(p, 8))
 		h = rotl31(h*m1) * m2
-		h ^= readUnaligned64(unsafe.Add(p, s-16))
+		h ^= readUnaligned64(add(p, s-16))
 		h = rotl31(h*m1) * m2
-		h ^= readUnaligned64(unsafe.Add(p, s-8))
+		h ^= readUnaligned64(add(p, s-8))
 		h = rotl31(h*m1) * m2
 	default:
 		v1 := h
@@ -263,16 +263,16 @@ tail:
 		for s >= 32 {
 			v1 ^= readUnaligned64(p)
 			v1 = rotl31(v1*m1) * m2
-			p = unsafe.Add(p, 8)
+			p = add(p, 8)
 			v2 ^= readUnaligned64(p)
 			v2 = rotl31(v2*m2) * m3
-			p = unsafe.Add(p, 8)
+			p = add(p, 8)
 			v3 ^= readUnaligned64(p)
 			v3 = rotl31(v3*m3) * m4
-			p = unsafe.Add(p, 8)
+			p = add(p, 8)
 			v4 ^= readUnaligned64(p)
 			v4 = rotl31(v4*m4) * m1
-			p = unsafe.Add(p, 8)
+			p = add(p, 8)
 			s -= 32
 		}
 		h = v1 ^ v2 ^ v3 ^ v4
@@ -285,6 +285,10 @@ tail:
 	return uintptr(h)
 }
 
+func add(p unsafe.Pointer, x uintptr) unsafe.Pointer {
+	return unsafe.Pointer(uintptr(p) + x)
+}
+
 func readUnaligned32(p unsafe.Pointer) uint32 {
 	q := (*[4]byte)(p)
 	return uint32(q[0]) | uint32(q[1])<<8 | uint32(q[2])<<16 | uint32(q[3])<<24

component/http/http.go

@@ -53,12 +53,8 @@ func HttpRequest(ctx context.Context, url, method string, header map[string][]st
 		TLSHandshakeTimeout:   10 * time.Second,
 		ExpectContinueTimeout: 1 * time.Second,
 		DialContext: func(ctx context.Context, network, address string) (net.Conn, error) {
-			if conn, err := inner.HandleTcp(address); err == nil {
+			conn := inner.HandleTcp(address, urlRes.Hostname())
 			return conn, nil
-			} else {
-				d := net.Dialer{}
-				return d.DialContext(ctx, network, address)
-			}
 		},
 		TLSClientConfig: tls.GetDefaultTLSConfig(),
 	}

component/mmdb/mmdb.go

@@ -1,18 +1,14 @@
 package mmdb
 
 import (
-	"context"
+	"github.com/oschwald/geoip2-golang"
 	"io"
 	"net/http"
 	"os"
 	"sync"
-	"time"
 
-	clashHttp "github.com/Dreamacro/clash/component/http"
 	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/log"
-
-	"github.com/oschwald/geoip2-golang"
 )
 
 var (
@@ -51,9 +47,7 @@ func Instance() *geoip2.Reader {
 }
 
 func DownloadMMDB(path string) (err error) {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second*90)
-	defer cancel()
-	resp, err := clashHttp.HttpRequest(ctx, C.MmdbUrl, http.MethodGet, http.Header{"User-Agent": {"clash"}}, nil)
+	resp, err := http.Get(C.MmdbUrl)
 	if err != nil {
 		return
 	}

component/profile/profile.go

@@ -1,7 +1,7 @@
 package profile
 
 import (
-	"github.com/Dreamacro/clash/common/atomic"
+	"go.uber.org/atomic"
 )
 
 // StoreSelected is a global switch for storing selected proxy to cache

component/proxydialer/proxydialer.go

@@ -1,96 +0,0 @@
-package proxydialer
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net"
-	"net/netip"
-	"strings"
-
-	N "github.com/Dreamacro/clash/common/net"
-	"github.com/Dreamacro/clash/component/dialer"
-	"github.com/Dreamacro/clash/component/resolver"
-	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/tunnel"
-	"github.com/Dreamacro/clash/tunnel/statistic"
-)
-
-type proxyDialer struct {
-	proxy     C.ProxyAdapter
-	dialer    C.Dialer
-	statistic bool
-}
-
-func New(proxy C.ProxyAdapter, dialer C.Dialer, statistic bool) C.Dialer {
-	return proxyDialer{proxy: proxy, dialer: dialer, statistic: statistic}
-}
-
-func NewByName(proxyName string, dialer C.Dialer) (C.Dialer, error) {
-	proxies := tunnel.Proxies()
-	if proxy, ok := proxies[proxyName]; ok {
-		return New(proxy, dialer, true), nil
-	}
-	return nil, fmt.Errorf("proxyName[%s] not found", proxyName)
-}
-
-func (p proxyDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
-	currentMeta := &C.Metadata{Type: C.INNER}
-	if err := currentMeta.SetRemoteAddress(address); err != nil {
-		return nil, err
-	}
-	if strings.Contains(network, "udp") { // using in wireguard outbound
-		if !currentMeta.Resolved() {
-			ip, err := resolver.ResolveIP(ctx, currentMeta.Host)
-			if err != nil {
-				return nil, errors.New("can't resolve ip")
-			}
-			currentMeta.DstIP = ip
-		}
-		pc, err := p.listenPacket(ctx, currentMeta)
-		if err != nil {
-			return nil, err
-		}
-		return N.NewBindPacketConn(pc, currentMeta.UDPAddr()), nil
-	}
-	var conn C.Conn
-	var err error
-	if d, ok := p.dialer.(dialer.Dialer); ok { // first using old function to let mux work
-		conn, err = p.proxy.DialContext(ctx, currentMeta, dialer.WithOption(d.Opt))
-	} else {
-		conn, err = p.proxy.DialContextWithDialer(ctx, p.dialer, currentMeta)
-	}
-	if err != nil {
-		return nil, err
-	}
-	if p.statistic {
-		conn = statistic.NewTCPTracker(conn, statistic.DefaultManager, currentMeta, nil, 0, 0, false)
-	}
-	return conn, err
-}
-
-func (p proxyDialer) ListenPacket(ctx context.Context, network, address string, rAddrPort netip.AddrPort) (net.PacketConn, error) {
-	currentMeta := &C.Metadata{Type: C.INNER}
-	if err := currentMeta.SetRemoteAddress(rAddrPort.String()); err != nil {
-		return nil, err
-	}
-	return p.listenPacket(ctx, currentMeta)
-}
-
-func (p proxyDialer) listenPacket(ctx context.Context, currentMeta *C.Metadata) (C.PacketConn, error) {
-	var pc C.PacketConn
-	var err error
-	currentMeta.NetWork = C.UDP
-	if d, ok := p.dialer.(dialer.Dialer); ok { // first using old function to let mux work
-		pc, err = p.proxy.ListenPacketContext(ctx, currentMeta, dialer.WithOption(d.Opt))
-	} else {
-		pc, err = p.proxy.ListenPacketWithDialer(ctx, p.dialer, currentMeta)
-	}
-	if err != nil {
-		return nil, err
-	}
-	if p.statistic {
-		pc = statistic.NewUDPTracker(pc, statistic.DefaultManager, currentMeta, nil, 0, 0, false)
-	}
-	return pc, nil
-}

component/resolver/resolver.go

@@ -44,8 +44,10 @@ type Resolver interface {
 	LookupIP(ctx context.Context, host string) (ips []netip.Addr, err error)
 	LookupIPv4(ctx context.Context, host string) (ips []netip.Addr, err error)
 	LookupIPv6(ctx context.Context, host string) (ips []netip.Addr, err error)
+	ResolveIP(ctx context.Context, host string) (ip netip.Addr, err error)
+	ResolveIPv4(ctx context.Context, host string) (ip netip.Addr, err error)
+	ResolveIPv6(ctx context.Context, host string) (ip netip.Addr, err error)
 	ExchangeContext(ctx context.Context, m *dns.Msg) (msg *dns.Msg, err error)
-	Invalid() bool
 }
 
 // LookupIPv4WithResolver same as LookupIPv4, but with a resolver
@@ -66,7 +68,7 @@ func LookupIPv4WithResolver(ctx context.Context, host string, r Resolver) ([]net
 		return []netip.Addr{}, ErrIPVersion
 	}
 
-	if r != nil && r.Invalid() {
+	if r != nil {
 		return r.LookupIPv4(ctx, host)
 	}
 
@@ -122,7 +124,7 @@ func LookupIPv6WithResolver(ctx context.Context, host string, r Resolver) ([]net
 		return nil, ErrIPVersion
 	}
 
-	if r != nil && r.Invalid() {
+	if r != nil {
 		return r.LookupIPv6(ctx, host)
 	}
 
@@ -162,7 +164,7 @@ func LookupIPWithResolver(ctx context.Context, host string, r Resolver) ([]netip
 		return node.IPs, nil
 	}
 
-	if r != nil && r.Invalid() {
+	if r != nil {
 		if DisableIPv6 {
 			return r.LookupIPv4(ctx, host)
 		}
@@ -198,14 +200,10 @@ func ResolveIPWithResolver(ctx context.Context, host string, r Resolver) (netip.
 	} else if len(ips) == 0 {
 		return netip.Addr{}, fmt.Errorf("%w: %s", ErrIPNotFound, host)
 	}
-	ipv4s, ipv6s := SortationAddr(ips)
-	if len(ipv4s) > 0 {
-		return ipv4s[fastrand.Intn(len(ipv4s))], nil
-	}
-	return ipv6s[fastrand.Intn(len(ipv6s))], nil
+	return ips[fastrand.Intn(len(ips))], nil
 }
 
-// ResolveIP with a host, return ip and priority return TypeA
+// ResolveIP with a host, return ip
 func ResolveIP(ctx context.Context, host string) (netip.Addr, error) {
 	return ResolveIPWithResolver(ctx, host, DefaultResolver)
 }
@@ -266,14 +264,3 @@ func LookupIPProxyServerHost(ctx context.Context, host string) ([]netip.Addr, er
 	}
 	return LookupIP(ctx, host)
 }
-
-func SortationAddr(ips []netip.Addr) (ipv4s, ipv6s []netip.Addr) {
-	for _, v := range ips {
-		if v.Unmap().Is4() {
-			ipv4s = append(ipv4s, v)
-		} else {
-			ipv6s = append(ipv6s, v)
-		}
-	}
-	return
-}

component/tls/config.go

@@ -33,22 +33,10 @@ func AddCertificate(certificate string) error {
 	}
 }
 
-func initializeCertPool() {
-	var err error
-	certPool, err = x509.SystemCertPool()
-	if err != nil {
-		certPool = x509.NewCertPool()
-	}
-	for _, cert := range trustCerts {
-		certPool.AddCert(cert)
-	}
-}
-
 func ResetCertificate() {
 	mutex.Lock()
 	defer mutex.Unlock()
 	trustCerts = nil
-	initializeCertPool()
 }
 
 func getCertPool() *x509.CertPool {
@@ -61,7 +49,12 @@ func getCertPool() *x509.CertPool {
 		if certPool != nil {
 			return certPool
 		}
-		initializeCertPool()
+		certPool, err := x509.SystemCertPool()
+		if err == nil {
+			for _, cert := range trustCerts {
+				certPool.AddCert(cert)
+			}
+		}
 	}
 	return certPool
 }

component/tls/reality.go

@@ -141,7 +141,7 @@ var pOffset = utils.MustOK(reflect.TypeOf((*utls.UConn)(nil)).Elem().FieldByName
 
 func (c *realityVerifier) VerifyPeerCertificate(rawCerts [][]byte, verifiedChains [][]*x509.Certificate) error {
 	//p, _ := reflect.TypeOf(c.Conn).Elem().FieldByName("peerCertificates")
-	certs := *(*[]*x509.Certificate)(unsafe.Add(unsafe.Pointer(c.Conn), pOffset))
+	certs := *(*[]*x509.Certificate)(unsafe.Pointer(uintptr(unsafe.Pointer(c.Conn)) + pOffset))
 	if pub, ok := certs[0].PublicKey.(ed25519.PublicKey); ok {
 		h := hmac.New(sha512.New, c.authKey)
 		h.Write(pub)

component/trie/domain.go

@@ -25,7 +25,7 @@ func ValidAndSplitDomain(domain string) ([]string, bool) {
 	if domain != "" && domain[len(domain)-1] == '.' {
 		return nil, false
 	}
-	domain = strings.ToLower(domain)
+	domain=strings.ToLower(domain)
 	parts := strings.Split(domain, domainStep)
 	if len(parts) == 1 {
 		if parts[0] == "" {
@@ -126,9 +126,6 @@ func (t *DomainTrie[T]) Optimize() {
 func (t *DomainTrie[T]) Foreach(print func(domain string, data T)) {
 	for key, data := range t.root.getChildren() {
 		recursion([]string{key}, data, print)
-		if data != nil && data.inited {
-			print(joinDomain([]string{key}), data.data)
-		}
 	}
 }
 

component/trie/domain_test.go

@@ -1,17 +1,16 @@
-package trie_test
+package trie
 
 import (
 	"net/netip"
 	"testing"
 
-	"github.com/Dreamacro/clash/component/trie"
 	"github.com/stretchr/testify/assert"
 )
 
 var localIP = netip.AddrFrom4([4]byte{127, 0, 0, 1})
 
 func TestTrie_Basic(t *testing.T) {
-	tree := trie.New[netip.Addr]()
+	tree := New[netip.Addr]()
 	domains := []string{
 		"example.com",
 		"google.com",
@@ -19,7 +18,7 @@ func TestTrie_Basic(t *testing.T) {
 	}
 
 	for _, domain := range domains {
-		assert.NoError(t, tree.Insert(domain, localIP))
+		tree.Insert(domain, localIP)
 	}
 
 	node := tree.Search("example.com")
@@ -32,7 +31,7 @@ func TestTrie_Basic(t *testing.T) {
 }
 
 func TestTrie_Wildcard(t *testing.T) {
-	tree := trie.New[netip.Addr]()
+	tree := New[netip.Addr]()
 	domains := []string{
 		"*.example.com",
 		"sub.*.example.com",
@@ -48,7 +47,7 @@ func TestTrie_Wildcard(t *testing.T) {
 	}
 
 	for _, domain := range domains {
-		assert.NoError(t, tree.Insert(domain, localIP))
+		tree.Insert(domain, localIP)
 	}
 
 	assert.NotNil(t, tree.Search("sub.example.com"))
@@ -65,7 +64,7 @@ func TestTrie_Wildcard(t *testing.T) {
 }
 
 func TestTrie_Priority(t *testing.T) {
-	tree := trie.New[int]()
+	tree := New[int]()
 	domains := []string{
 		".dev",
 		"example.dev",
@@ -80,7 +79,7 @@ func TestTrie_Priority(t *testing.T) {
 	}
 
 	for idx, domain := range domains {
-		assert.NoError(t, tree.Insert(domain, idx+1))
+		tree.Insert(domain, idx+1)
 	}
 
 	assertFn("test.dev", 1)
@@ -91,8 +90,8 @@ func TestTrie_Priority(t *testing.T) {
 }
 
 func TestTrie_Boundary(t *testing.T) {
-	tree := trie.New[netip.Addr]()
-	assert.NoError(t, tree.Insert("*.dev", localIP))
+	tree := New[netip.Addr]()
+	tree.Insert("*.dev", localIP)
 
 	assert.NotNil(t, tree.Insert(".", localIP))
 	assert.NotNil(t, tree.Insert("..dev", localIP))
@@ -100,15 +99,15 @@ func TestTrie_Boundary(t *testing.T) {
 }
 
 func TestTrie_WildcardBoundary(t *testing.T) {
-	tree := trie.New[netip.Addr]()
-	assert.NoError(t, tree.Insert("+.*", localIP))
-	assert.NoError(t, tree.Insert("stun.*.*.*", localIP))
+	tree := New[netip.Addr]()
+	tree.Insert("+.*", localIP)
+	tree.Insert("stun.*.*.*", localIP)
 
 	assert.NotNil(t, tree.Search("example.com"))
 }
 
 func TestTrie_Foreach(t *testing.T) {
-	tree := trie.New[netip.Addr]()
+	tree := New[netip.Addr]()
 	domainList := []string{
 		"google.com",
 		"stun.*.*.*",
@@ -118,7 +117,7 @@ func TestTrie_Foreach(t *testing.T) {
 		"*.*.baidu.com",
 	}
 	for _, domain := range domainList {
-		assert.NoError(t, tree.Insert(domain, localIP))
+		tree.Insert(domain, localIP)
 	}
 	count := 0
 	tree.Foreach(func(domain string, data netip.Addr) {

component/trie/set_test.go

@@ -7,36 +7,22 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestDomainSet(t *testing.T) {
-	tree := trie.New[struct{}]()
+func TestDomain(t *testing.T) {
 	domainSet := []string{
 		"baidu.com",
 		"google.com",
 		"www.google.com",
 		"test.a.net",
 		"test.a.oc",
-		"Mijia Cloud",
-		".qq.com",
-		"+.cn",
 	}
-
-	for _, domain := range domainSet {
-		assert.NoError(t, tree.Insert(domain, struct{}{}))
-	}
-	set := tree.NewDomainSet()
+	set := trie.NewDomainSet(domainSet)
 	assert.NotNil(t, set)
-	assert.True(t, set.Has("test.cn"))
-	assert.True(t, set.Has("cn"))
-	assert.True(t, set.Has("Mijia Cloud"))
 	assert.True(t, set.Has("test.a.net"))
-	assert.True(t, set.Has("www.qq.com"))
 	assert.True(t, set.Has("google.com"))
-	assert.False(t, set.Has("qq.com"))
 	assert.False(t, set.Has("www.baidu.com"))
 }
 
-func TestDomainSetComplexWildcard(t *testing.T) {
-	tree := trie.New[struct{}]()
+func TestDomainComplexWildcard(t *testing.T) {
 	domainSet := []string{
 		"+.baidu.com",
 		"+.a.baidu.com",
@@ -46,40 +32,29 @@ func TestDomainSetComplexWildcard(t *testing.T) {
 		"test.a.oc",
 		"www.qq.com",
 	}
-
-	for _, domain := range domainSet {
-		assert.NoError(t, tree.Insert(domain, struct{}{}))
-	}
-	set := tree.NewDomainSet()
+	set := trie.NewDomainSet(domainSet)
 	assert.NotNil(t, set)
 	assert.False(t, set.Has("google.com"))
 	assert.True(t, set.Has("www.baidu.com"))
 	assert.True(t, set.Has("test.test.baidu.com"))
 }
 
-func TestDomainSetWildcard(t *testing.T) {
-	tree := trie.New[struct{}]()
+func TestDomainWildcard(t *testing.T) {
 	domainSet := []string{
 		"*.*.*.baidu.com",
 		"www.baidu.*",
 		"stun.*.*",
 		"*.*.qq.com",
 		"test.*.baidu.com",
-		"*.apple.com",
 	}
-
-	for _, domain := range domainSet {
-		assert.NoError(t, tree.Insert(domain, struct{}{}))
-	}
-	set := tree.NewDomainSet()
+	set := trie.NewDomainSet(domainSet)
 	assert.NotNil(t, set)
 	assert.True(t, set.Has("www.baidu.com"))
 	assert.True(t, set.Has("test.test.baidu.com"))
 	assert.True(t, set.Has("test.test.qq.com"))
-	assert.True(t, set.Has("stun.ab.cd"))
+	assert.True(t,set.Has("stun.ab.cd"))
 	assert.False(t, set.Has("test.baidu.com"))
-	assert.False(t, set.Has("www.google.com"))
-	assert.False(t, set.Has("a.www.google.com"))
+	assert.False(t,set.Has("www.google.com"))
 	assert.False(t, set.Has("test.qq.com"))
 	assert.False(t, set.Has("test.test.test.qq.com"))
 }

component/trie/sskv.go

@@ -23,16 +23,20 @@ type DomainSet struct {
 	ranks, selects      []int32
 }
 
-// NewDomainSet creates a new *DomainSet struct, from a DomainTrie.
-func (t *DomainTrie[T]) NewDomainSet() *DomainSet {
-	reserveDomains := make([]string, 0)
-	t.Foreach(func(domain string, data T) {
+// NewDomainSet creates a new *DomainSet struct, from a slice of sorted strings.
+func NewDomainSet(keys []string) *DomainSet {
+	domainTrie := New[struct{}]()
+	for _, domain := range keys {
+		domainTrie.Insert(domain, struct{}{})
+	}
+	reserveDomains := make([]string, 0, len(keys))
+	domainTrie.Foreach(func(domain string, data struct{}) {
 		reserveDomains = append(reserveDomains, utils.Reverse(domain))
 	})
 	// ensure that the same prefix is continuous
 	// and according to the ascending sequence of length
 	sort.Strings(reserveDomains)
-	keys := reserveDomains
+	keys = reserveDomains
 	if len(keys) == 0 {
 		return nil
 	}
@@ -100,11 +104,11 @@ func (ss *DomainSet) Has(key string) bool {
 					if j == len(key) {
 						if getBit(ss.leaves, nextNodeId) != 0 {
 							return true
-						} else {
+						}else {
 							goto RESTART
 						}
 					}
-					for ; nextBmIdx-nextNodeId < len(ss.labels); nextBmIdx++ {
+					for ; ; nextBmIdx++ {
 						if ss.labels[nextBmIdx-nextNodeId] == domainStepByte {
 							bmIdx = nextBmIdx
 							nodeId = nextNodeId

config/config.go

@@ -841,7 +841,7 @@ func parseHosts(cfg *RawConfig) (*trie.DomainTrie[resolver.HostValue], error) {
 				} else {
 					ips := make([]netip.Addr, 0)
 					for _, addr := range addrs {
-						if ipnet, ok := addr.(*net.IPNet); ok && !ipnet.IP.IsLoopback() && !ipnet.IP.IsLinkLocalUnicast() {
+						if ipnet, ok := addr.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
 							if ip, err := netip.ParseAddr(ipnet.IP.String()); err == nil {
 								ips = append(ips, ip)
 							}
@@ -896,7 +896,7 @@ func parseNameServer(servers []string, preferH3 bool) ([]dns.NameServer, error)
 			return nil, fmt.Errorf("DNS NameServer[%d] format error: %s", idx, err.Error())
 		}
 
-		proxyName := u.Fragment
+		proxyAdapter := u.Fragment
 
 		var addr, dnsNetType string
 		params := map[string]string{}
@@ -913,7 +913,7 @@ func parseNameServer(servers []string, preferH3 bool) ([]dns.NameServer, error)
 		case "https":
 			addr, err = hostWithDefaultPort(u.Host, "443")
 			if err == nil {
-				proxyName = ""
+				proxyAdapter = ""
 				clearURL := url.URL{Scheme: "https", Host: addr, Path: u.Path}
 				addr = clearURL.String()
 				dnsNetType = "https" // DNS over HTTPS
@@ -923,7 +923,7 @@ func parseNameServer(servers []string, preferH3 bool) ([]dns.NameServer, error)
 						if len(arr) == 0 {
 							continue
 						} else if len(arr) == 1 {
-							proxyName = arr[0]
+							proxyAdapter = arr[0]
 						} else if len(arr) == 2 {
 							params[arr[0]] = arr[1]
 						} else {
@@ -938,8 +938,6 @@ func parseNameServer(servers []string, preferH3 bool) ([]dns.NameServer, error)
 		case "quic":
 			addr, err = hostWithDefaultPort(u.Host, "853")
 			dnsNetType = "quic" // DNS over QUIC
-		case "system":
-			dnsNetType = "system" // System DNS
 		default:
 			return nil, fmt.Errorf("DNS NameServer[%d] unsupport scheme: %s", idx, u.Scheme)
 		}
@@ -953,7 +951,7 @@ func parseNameServer(servers []string, preferH3 bool) ([]dns.NameServer, error)
 			dns.NameServer{
 				Net:          dnsNetType,
 				Addr:         addr,
-				ProxyName: proxyName,
+				ProxyAdapter: proxyAdapter,
 				Interface:    dialer.DefaultInterface,
 				Params:       params,
 				PreferH3:     preferH3,
@@ -963,21 +961,11 @@ func parseNameServer(servers []string, preferH3 bool) ([]dns.NameServer, error)
 	return nameservers, nil
 }
 
-func init() {
-	dns.ParseNameServer = func(servers []string) ([]dns.NameServer, error) { // using by wireguard
-		return parseNameServer(servers, false)
-	}
-}
-
 func parsePureDNSServer(server string) string {
 	addPre := func(server string) string {
 		return "udp://" + server
 	}
 
-	if server == "system" {
-		return "system://"
-	}
-
 	if ip, err := netip.ParseAddr(server); err != nil {
 		if strings.Contains(server, "://") {
 			return server
@@ -1148,9 +1136,6 @@ func parseDNS(rawCfg *RawConfig, hosts *trie.DomainTrie[resolver.HostValue], rul
 	}
 	// check default nameserver is pure ip addr
 	for _, ns := range dnsCfg.DefaultNameserver {
-		if ns.Net == "system" {
-			continue
-		}
 		host, _, err := net.SplitHostPort(ns.Addr)
 		if err != nil || net.ParseIP(host) == nil {
 			u, err := url.Parse(ns.Addr)
@@ -1355,25 +1340,8 @@ func parseSniffer(snifferRaw RawSniffer) (*Sniffer, error) {
 	}
 
 	sniffer.Sniffers = loadSniffer
-
-	forceDomainTrie := trie.New[struct{}]()
-	for _, domain := range snifferRaw.ForceDomain {
-		err := forceDomainTrie.Insert(domain, struct{}{})
-		if err != nil {
-			return nil, fmt.Errorf("error domian[%s] in force-domain, error:%v", domain, err)
-		}
-	}
-	sniffer.ForceDomain = forceDomainTrie.NewDomainSet()
-
-	skipDomainTrie := trie.New[struct{}]()
-	for _, domain := range snifferRaw.SkipDomain {
-		err := skipDomainTrie.Insert(domain, struct{}{})
-		if err != nil {
-			return nil, fmt.Errorf("error domian[%s] in force-domain, error:%v", domain, err)
-		}
-	}
-	sniffer.SkipDomain = skipDomainTrie.NewDomainSet()
-
+	sniffer.ForceDomain = trie.NewDomainSet(snifferRaw.ForceDomain)
+	sniffer.SkipDomain = trie.NewDomainSet(snifferRaw.SkipDomain)
 	return sniffer, nil
 }
 

config/updateGeo.go

@@ -1,20 +1,15 @@
 package config
 
 import (
-	"context"
 	"fmt"
+	"github.com/Dreamacro/clash/component/geodata"
+	_ "github.com/Dreamacro/clash/component/geodata/standard"
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/oschwald/geoip2-golang"
 	"io"
 	"net/http"
 	"os"
 	"runtime"
-	"time"
-
-	"github.com/Dreamacro/clash/component/geodata"
-	_ "github.com/Dreamacro/clash/component/geodata/standard"
-	clashHttp "github.com/Dreamacro/clash/component/http"
-	C "github.com/Dreamacro/clash/constant"
-
-	"github.com/oschwald/geoip2-golang"
 )
 
 func UpdateGeoDatabases() error {
@@ -74,9 +69,7 @@ func UpdateGeoDatabases() error {
 }
 
 func downloadForBytes(url string) ([]byte, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second*90)
-	defer cancel()
-	resp, err := clashHttp.HttpRequest(ctx, url, http.MethodGet, http.Header{"User-Agent": {"clash"}}, nil)
+	resp, err := http.Get(url)
 	if err != nil {
 		return nil, err
 	}

config/utils.go

@@ -3,7 +3,6 @@ package config
 import (
 	"fmt"
 	"net"
-	"net/netip"
 	"strings"
 
 	"github.com/Dreamacro/clash/adapter/outboundgroup"
@@ -150,14 +149,23 @@ func proxyGroupsDagSort(groupsConfig []map[string]any) error {
 }
 
 func verifyIP6() bool {
-	if iAddrs, err := net.InterfaceAddrs(); err == nil {
-		for _, addr := range iAddrs {
-			if prefix, err := netip.ParsePrefix(addr.String()); err == nil {
-				if addr := prefix.Addr().Unmap(); addr.Is6() && addr.IsGlobalUnicast() {
+	addrs, err := net.InterfaceAddrs()
+	if err != nil {
+		return false
+	}
+	for _, addr := range addrs {
+		ipNet, isIpNet := addr.(*net.IPNet)
+		if isIpNet && !ipNet.IP.IsLoopback() {
+			if ipNet.IP.To16() != nil {
+				s := ipNet.IP.String()
+				for i := 0; i < len(s); i++ {
+					switch s[i] {
+					case ':':
 						return true
 					}
 				}
 			}
 		}
+	}
 	return false
 }

constant/adapters.go

@@ -2,14 +2,12 @@ package constant
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"net"
 	"net/netip"
 	"sync"
 	"time"
 
-	N "github.com/Dreamacro/clash/common/net"
 	"github.com/Dreamacro/clash/component/dialer"
 )
 
@@ -45,8 +43,6 @@ const (
 	DefaultTLSTimeout = DefaultTCPTimeout
 )
 
-var ErrNotSupport = errors.New("no support")
-
 type Connection interface {
 	Chains() Chain
 	AppendToChains(adapter ProxyAdapter)
@@ -76,12 +72,12 @@ func (c Chain) Last() string {
 }
 
 type Conn interface {
-	N.ExtendedConn
+	net.Conn
 	Connection
 }
 
 type PacketConn interface {
-	N.EnhancePacketConn
+	net.PacketConn
 	Connection
 	// Deprecate WriteWithMetadata because of remote resolve DNS cause TURN failed
 	// WriteWithMetadata(p []byte, metadata *Metadata) (n int, err error)
@@ -106,11 +102,11 @@ type ProxyAdapter interface {
 	//
 	// Examples:
 	//	conn, _ := net.DialContext(context.Background(), "tcp", "host:port")
-	//	conn, _ = adapter.StreamConnContext(context.Background(), conn, metadata)
+	//	conn, _ = adapter.StreamConn(conn, metadata)
 	//
 	// It returns a C.Conn with protocol which start with
 	// a new session (if any)
-	StreamConnContext(ctx context.Context, c net.Conn, metadata *Metadata) (net.Conn, error)
+	StreamConn(c net.Conn, metadata *Metadata) (net.Conn, error)
 
 	// DialContext return a C.Conn with protocol which
 	// contains multiplexing-related reuse logic (if any)
@@ -120,13 +116,10 @@ type ProxyAdapter interface {
 	// SupportUOT return UDP over TCP support
 	SupportUOT() bool
 
-	SupportWithDialer() NetWork
+	SupportWithDialer() bool
 	DialContextWithDialer(ctx context.Context, dialer Dialer, metadata *Metadata) (Conn, error)
 	ListenPacketWithDialer(ctx context.Context, dialer Dialer, metadata *Metadata) (PacketConn, error)
 
-	// IsL3Protocol return ProxyAdapter working in L3 (tell dns module not pass the domain to avoid loopback)
-	IsL3Protocol(metadata *Metadata) bool
-
 	// Unwrap extracts the proxy from a proxy-group. It returns nil when nothing to extract.
 	Unwrap(metadata *Metadata, touch bool) Proxy
 }

constant/context.go

@@ -5,7 +5,7 @@ import (
 
 	N "github.com/Dreamacro/clash/common/net"
 
-	"github.com/gofrs/uuid/v5"
+	"github.com/gofrs/uuid"
 )
 
 type PlainContext interface {

constant/features/low_memory.go

@@ -1,4 +1,3 @@
-//go:build with_low_memory
 package features
 
 func init() {

constant/metadata.go

@@ -15,10 +15,7 @@ const (
 	TCP NetWork = iota
 	UDP
 	ALLNet
-	InvalidNet = 0xff
-)
 
-const (
 	HTTP Type = iota
 	HTTPS
 	SOCKS4
@@ -36,16 +33,12 @@ const (
 type NetWork int
 
 func (n NetWork) String() string {
-	switch n {
-	case TCP:
+	if n == TCP {
 		return "tcp"
-	case UDP:
+	} else if n == UDP {
 		return "udp"
-	case ALLNet:
-		return "all"
-	default:
-		return "invalid"
 	}
+	return "all"
 }
 
 func (n NetWork) MarshalJSON() ([]byte, error) {
@@ -133,7 +126,6 @@ type Metadata struct {
 	InIP         netip.Addr `json:"inboundIP"`
 	InPort       string     `json:"inboundPort"`
 	InName       string     `json:"inboundName"`
-	InUser       string     `json:"inboundUser"`
 	Host         string     `json:"host"`
 	DNSMode      DNSMode    `json:"dnsMode"`
 	Uid          uint32     `json:"uid"`
@@ -206,16 +198,15 @@ func (m *Metadata) Pure() *Metadata {
 	return m
 }
 
-func (m *Metadata) AddrPort() netip.AddrPort {
-	port, _ := strconv.ParseUint(m.DstPort, 10, 16)
-	return netip.AddrPortFrom(m.DstIP.Unmap(), uint16(port))
-}
-
 func (m *Metadata) UDPAddr() *net.UDPAddr {
 	if m.NetWork != UDP || !m.DstIP.IsValid() {
 		return nil
 	}
-	return net.UDPAddrFromAddrPort(m.AddrPort())
+	port, _ := strconv.ParseUint(m.DstPort, 10, 16)
+	return &net.UDPAddr{
+		IP:   m.DstIP.AsSlice(),
+		Port: int(port),
+	}
 }
 
 func (m *Metadata) String() string {
@@ -231,21 +222,3 @@ func (m *Metadata) String() string {
 func (m *Metadata) Valid() bool {
 	return m.Host != "" || m.DstIP.IsValid()
 }
-
-func (m *Metadata) SetRemoteAddress(rawAddress string) error {
-	host, port, err := net.SplitHostPort(rawAddress)
-	if err != nil {
-		return err
-	}
-
-	if ip, err := netip.ParseAddr(host); err != nil {
-		m.Host = host
-		m.DstIP = netip.Addr{}
-	} else {
-		m.Host = ""
-		m.DstIP = ip.Unmap()
-	}
-	m.DstPort = port
-
-	return nil
-}

constant/path.go

@@ -66,7 +66,7 @@ func (p *path) MMDB() string {
 			// 目录则直接跳过
 			continue
 		} else {
-			if strings.EqualFold(fi.Name(), "Country.mmdb") {
+			if strings.EqualFold(strings.ToLower(fi.Name()), "country.mmdb") {
 				GeoipName = fi.Name()
 				return P.Join(p.homeDir, fi.Name())
 			}
@@ -93,7 +93,7 @@ func (p *path) GeoIP() string {
 			// 目录则直接跳过
 			continue
 		} else {
-			if strings.EqualFold(fi.Name(), "GeoIP.dat") {
+			if strings.EqualFold(strings.ToLower(fi.Name()), "geoip.dat") {
 				GeoipName = fi.Name()
 				return P.Join(p.homeDir, fi.Name())
 			}
@@ -112,7 +112,7 @@ func (p *path) GeoSite() string {
 			// 目录则直接跳过
 			continue
 		} else {
-			if strings.EqualFold(fi.Name(), "GeoSite.dat") {
+			if strings.EqualFold(strings.ToLower(fi.Name()), "geosite.dat") {
 				GeositeName = fi.Name()
 				return P.Join(p.homeDir, fi.Name())
 			}

constant/provider/interface.go

@@ -73,27 +73,17 @@ type ProxyProvider interface {
 	Version() uint32
 }
 
-// RuleProvider interface
-type RuleProvider interface {
-	Provider
-	Behavior() RuleBehavior
-	Match(*constant.Metadata) bool
-	ShouldResolveIP() bool
-	ShouldFindProcess() bool
-	AsRule(adaptor string) constant.Rule
-}
-
-// Rule Behavior
+// Rule Type
 const (
-	Domain RuleBehavior = iota
+	Domain RuleType = iota
 	IPCIDR
 	Classical
 )
 
-// RuleBehavior defined
-type RuleBehavior int
+// RuleType defined
+type RuleType int
 
-func (rt RuleBehavior) String() string {
+func (rt RuleType) String() string {
 	switch rt {
 	case Domain:
 		return "Domain"
@@ -106,20 +96,12 @@ func (rt RuleBehavior) String() string {
 	}
 }
 
-const (
-	YamlRule RuleFormat = iota
-	TextRule
-)
-
-type RuleFormat int
-
-func (rf RuleFormat) String() string {
-	switch rf {
-	case YamlRule:
-		return "YamlRule"
-	case TextRule:
-		return "TextRule"
-	default:
-		return "Unknown"
-	}
+// RuleProvider interface
+type RuleProvider interface {
+	Provider
+	Behavior() RuleType
+	Match(*constant.Metadata) bool
+	ShouldResolveIP() bool
+	ShouldFindProcess() bool
+	AsRule(adaptor string) constant.Rule
 }

constant/rule.go

@@ -14,14 +14,12 @@ const (
 	SrcPort
 	DstPort
 	InPort
-	InUser
-	InName
-	InType
 	Process
 	ProcessPath
 	RuleSet
 	Network
 	Uid
+	INTYPE
 	SubRules
 	MATCH
 	AND
@@ -57,12 +55,6 @@ func (rt RuleType) String() string {
 		return "DstPort"
 	case InPort:
 		return "InPort"
-	case InUser:
-		return "InUser"
-	case InName:
-		return "InName"
-	case InType:
-		return "InType"
 	case Process:
 		return "Process"
 	case ProcessPath:
@@ -75,6 +67,8 @@ func (rt RuleType) String() string {
 		return "Network"
 	case Uid:
 		return "Uid"
+	case INTYPE:
+		return "InType"
 	case SubRules:
 		return "SubRules"
 	case AND:

context/conn.go

@@ -7,7 +7,7 @@ import (
 	N "github.com/Dreamacro/clash/common/net"
 	C "github.com/Dreamacro/clash/constant"
 
-	"github.com/gofrs/uuid/v5"
+	"github.com/gofrs/uuid"
 )
 
 type ConnContext struct {

context/dns.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"github.com/Dreamacro/clash/common/utils"
 
-	"github.com/gofrs/uuid/v5"
+	"github.com/gofrs/uuid"
 	"github.com/miekg/dns"
 )
 

context/packetconn.go

@@ -6,7 +6,7 @@ import (
 	"github.com/Dreamacro/clash/common/utils"
 	C "github.com/Dreamacro/clash/constant"
 
-	"github.com/gofrs/uuid/v5"
+	"github.com/gofrs/uuid"
 )
 
 type PacketConnContext struct {

dns/client.go

@@ -8,11 +8,11 @@ import (
 	"net/netip"
 	"strings"
 
-	"github.com/Dreamacro/clash/common/atomic"
+	tlsC "github.com/Dreamacro/clash/component/tls"
+	"go.uber.org/atomic"
+
 	"github.com/Dreamacro/clash/component/dialer"
 	"github.com/Dreamacro/clash/component/resolver"
-	tlsC "github.com/Dreamacro/clash/component/tls"
-	C "github.com/Dreamacro/clash/constant"
 
 	D "github.com/miekg/dns"
 	"github.com/zhangyunhao116/fastrand"
@@ -23,9 +23,8 @@ type client struct {
 	r            *Resolver
 	port         string
 	host         string
-	iface        *atomic.TypedValue[string]
-	proxyAdapter C.ProxyAdapter
-	proxyName    string
+	iface        *atomic.String
+	proxyAdapter string
 	addr         string
 }
 
@@ -82,7 +81,7 @@ func (c *client) ExchangeContext(ctx context.Context, m *D.Msg) (*D.Msg, error)
 		options = append(options, dialer.WithInterface(c.iface.Load()))
 	}
 
-	conn, err := getDialHandler(c.r, c.proxyAdapter, c.proxyName, options...)(ctx, network, net.JoinHostPort(ip.String(), c.port))
+	conn, err := getDialHandler(c.r, c.proxyAdapter, options...)(ctx, network, net.JoinHostPort(ip.String(), c.port))
 	if err != nil {
 		return nil, err
 	}

dns/dhcp.go

@@ -8,7 +8,8 @@ import (
 	"sync"
 	"time"
 
-	"github.com/Dreamacro/clash/common/atomic"
+	"go.uber.org/atomic"
+
 	"github.com/Dreamacro/clash/component/dhcp"
 	"github.com/Dreamacro/clash/component/iface"
 	"github.com/Dreamacro/clash/component/resolver"
@@ -85,7 +86,7 @@ func (d *dhcpClient) resolve(ctx context.Context) ([]dnsClient, error) {
 				for _, item := range dns {
 					nameserver = append(nameserver, NameServer{
 						Addr:      net.JoinHostPort(item.String(), "53"),
-						Interface: atomic.NewTypedValue(d.ifaceName),
+						Interface: atomic.NewString(d.ifaceName),
 					})
 				}
 

dns/doh.go

@@ -21,7 +21,6 @@ import (
 	"github.com/metacubex/quic-go"
 	"github.com/metacubex/quic-go/http3"
 	D "github.com/miekg/dns"
-	"golang.org/x/exp/slices"
 	"golang.org/x/net/http2"
 )
 
@@ -64,8 +63,7 @@ type dnsOverHTTPS struct {
 	url             *url.URL
 	r               *Resolver
 	httpVersions    []C.HTTPVersion
-	proxyAdapter    C.ProxyAdapter
-	proxyName       string
+	proxyAdapter    string
 	addr            string
 }
 
@@ -73,7 +71,7 @@ type dnsOverHTTPS struct {
 var _ dnsClient = (*dnsOverHTTPS)(nil)
 
 // newDoH returns the DNS-over-HTTPS Upstream.
-func newDoHClient(urlString string, r *Resolver, preferH3 bool, params map[string]string, proxyAdapter C.ProxyAdapter, proxyName string) dnsClient {
+func newDoHClient(urlString string, r *Resolver, preferH3 bool, params map[string]string, proxyAdapter string) dnsClient {
 	u, _ := url.Parse(urlString)
 	httpVersions := DefaultHTTPVersions
 	if preferH3 {
@@ -89,7 +87,6 @@ func newDoHClient(urlString string, r *Resolver, preferH3 bool, params map[strin
 		addr:         u.String(),
 		r:            r,
 		proxyAdapter: proxyAdapter,
-		proxyName:    proxyName,
 		quicConfig: &quic.Config{
 			KeepAlivePeriod: QUICKeepAlivePeriod,
 			TokenStore:      newQUICTokenStore(),
@@ -393,9 +390,7 @@ func (doh *dnsOverHTTPS) createTransport(ctx context.Context) (t http.RoundTripp
 		nextProtos = append(nextProtos, string(v))
 	}
 	tlsConfig.NextProtos = nextProtos
-	dialContext := getDialHandler(doh.r, doh.proxyAdapter, doh.proxyName)
-
-	if slices.Contains(doh.httpVersions, C.HTTPVersion3) {
+	dialContext := getDialHandler(doh.r, doh.proxyAdapter)
 	// First, we attempt to create an HTTP3 transport.  If the probe QUIC
 	// connection is established successfully, we'll be using HTTP3 for this
 	// upstream.
@@ -404,7 +399,6 @@ func (doh *dnsOverHTTPS) createTransport(ctx context.Context) (t http.RoundTripp
 		log.Debugln("[%s] using HTTP/3 for this upstream: QUIC was faster", doh.url.String())
 		return transportH3, nil
 	}
-	}
 
 	log.Debugln("[%s] using HTTP/2 for this upstream: %v", doh.url.String(), err)
 
@@ -539,7 +533,7 @@ func (doh *dnsOverHTTPS) dialQuic(ctx context.Context, addr string, tlsCfg *tls.
 		IP:   net.ParseIP(ip),
 		Port: portInt,
 	}
-	conn, err := listenPacket(ctx, doh.proxyAdapter, doh.proxyName, "udp", addr, doh.r)
+	conn, err := listenPacket(ctx, doh.proxyAdapter, "udp", addr, doh.r)
 	if err != nil {
 		return nil, err
 	}

dns/doq.go

@@ -13,10 +13,9 @@ import (
 	"time"
 
 	tlsC "github.com/Dreamacro/clash/component/tls"
-	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/log"
 	"github.com/metacubex/quic-go"
 
+	"github.com/Dreamacro/clash/log"
 	D "github.com/miekg/dns"
 )
 
@@ -61,8 +60,7 @@ type dnsOverQUIC struct {
 	bytesPoolGuard sync.Mutex
 
 	addr         string
-	proxyAdapter C.ProxyAdapter
-	proxyName    string
+	proxyAdapter string
 	r            *Resolver
 }
 
@@ -70,11 +68,10 @@ type dnsOverQUIC struct {
 var _ dnsClient = (*dnsOverQUIC)(nil)
 
 // newDoQ returns the DNS-over-QUIC Upstream.
-func newDoQ(resolver *Resolver, addr string, proxyAdapter C.ProxyAdapter, proxyName string) (dnsClient, error) {
+func newDoQ(resolver *Resolver, addr string, adapter string) (dnsClient, error) {
 	doq := &dnsOverQUIC{
 		addr:         addr,
-		proxyAdapter: proxyAdapter,
-		proxyName:    proxyName,
+		proxyAdapter: adapter,
 		r:            resolver,
 		quicConfig: &quic.Config{
 			KeepAlivePeriod: QUICKeepAlivePeriod,
@@ -313,7 +310,7 @@ func (doq *dnsOverQUIC) openConnection(ctx context.Context) (conn quic.Connectio
 	// we're using bootstrapped address instead of what's passed to the function
 	// it does not create an actual connection, but it helps us determine
 	// what IP is actually reachable (when there're v4/v6 addresses).
-	rawConn, err := getDialHandler(doq.r, doq.proxyAdapter, doq.proxyName)(ctx, "udp", doq.addr)
+	rawConn, err := getDialHandler(doq.r, doq.proxyAdapter)(ctx, "udp", doq.addr)
 	if err != nil {
 		return nil, fmt.Errorf("failed to open a QUIC connection: %w", err)
 	}
@@ -328,7 +325,7 @@ func (doq *dnsOverQUIC) openConnection(ctx context.Context) (conn quic.Connectio
 
 	p, err := strconv.Atoi(port)
 	udpAddr := net.UDPAddr{IP: net.ParseIP(ip), Port: p}
-	udp, err := listenPacket(ctx, doq.proxyAdapter, doq.proxyName, "udp", addr, doq.r)
+	udp, err := listenPacket(ctx, doq.proxyAdapter, "udp", addr, doq.r)
 	if err != nil {
 		return nil, err
 	}

dns/resolver.go

@@ -3,11 +3,13 @@ package dns
 import (
 	"context"
 	"errors"
+	"fmt"
 	"net/netip"
 	"strings"
 	"time"
 
-	"github.com/Dreamacro/clash/common/atomic"
+	"go.uber.org/atomic"
+
 	"github.com/Dreamacro/clash/common/cache"
 	"github.com/Dreamacro/clash/component/fakeip"
 	"github.com/Dreamacro/clash/component/geodata/router"
@@ -18,6 +20,7 @@ import (
 	"github.com/Dreamacro/clash/log"
 
 	D "github.com/miekg/dns"
+	"github.com/zhangyunhao116/fastrand"
 	"golang.org/x/sync/singleflight"
 )
 
@@ -97,7 +100,7 @@ func (r *Resolver) LookupIP(ctx context.Context, host string) (ips []netip.Addr,
 
 	ips, err = r.lookupIP(ctx, host, D.TypeA)
 	var waitIPv6 *time.Timer
-	if r != nil && r.ipv6Timeout > 0 {
+	if r != nil {
 		waitIPv6 = time.NewTimer(r.ipv6Timeout)
 	} else {
 		waitIPv6 = time.NewTimer(100 * time.Millisecond)
@@ -116,16 +119,49 @@ func (r *Resolver) LookupIP(ctx context.Context, host string) (ips []netip.Addr,
 	return ips, nil
 }
 
+// ResolveIP request with TypeA and TypeAAAA, priority return TypeA
+func (r *Resolver) ResolveIP(ctx context.Context, host string) (ip netip.Addr, err error) {
+	ips, err := r.LookupIPPrimaryIPv4(ctx, host)
+	if err != nil {
+		return netip.Addr{}, err
+	} else if len(ips) == 0 {
+		return netip.Addr{}, fmt.Errorf("%w: %s", resolver.ErrIPNotFound, host)
+	}
+	return ips[fastrand.Intn(len(ips))], nil
+}
+
 // LookupIPv4 request with TypeA
 func (r *Resolver) LookupIPv4(ctx context.Context, host string) ([]netip.Addr, error) {
 	return r.lookupIP(ctx, host, D.TypeA)
 }
 
+// ResolveIPv4 request with TypeA
+func (r *Resolver) ResolveIPv4(ctx context.Context, host string) (ip netip.Addr, err error) {
+	ips, err := r.lookupIP(ctx, host, D.TypeA)
+	if err != nil {
+		return netip.Addr{}, err
+	} else if len(ips) == 0 {
+		return netip.Addr{}, fmt.Errorf("%w: %s", resolver.ErrIPNotFound, host)
+	}
+	return ips[fastrand.Intn(len(ips))], nil
+}
+
 // LookupIPv6 request with TypeAAAA
 func (r *Resolver) LookupIPv6(ctx context.Context, host string) ([]netip.Addr, error) {
 	return r.lookupIP(ctx, host, D.TypeAAAA)
 }
 
+// ResolveIPv6 request with TypeAAAA
+func (r *Resolver) ResolveIPv6(ctx context.Context, host string) (ip netip.Addr, err error) {
+	ips, err := r.lookupIP(ctx, host, D.TypeAAAA)
+	if err != nil {
+		return netip.Addr{}, err
+	} else if len(ips) == 0 {
+		return netip.Addr{}, fmt.Errorf("%w: %s", resolver.ErrIPNotFound, host)
+	}
+	return ips[fastrand.Intn(len(ips))], nil
+}
+
 func (r *Resolver) shouldIPFallback(ip netip.Addr) bool {
 	for _, filter := range r.fallbackIPFilters {
 		if filter.Match(ip) {
@@ -376,20 +412,16 @@ func (r *Resolver) asyncExchange(ctx context.Context, client []dnsClient, msg *D
 	return ch
 }
 
-// Invalid return this resolver can or can't be used
-func (r *Resolver) Invalid() bool {
-	if r == nil {
-		return false
-	}
+// HasProxyServer has proxy server dns client
+func (r *Resolver) HasProxyServer() bool {
 	return len(r.main) > 0
 }
 
 type NameServer struct {
 	Net          string
 	Addr         string
-	Interface    *atomic.TypedValue[string]
-	ProxyAdapter C.ProxyAdapter
-	ProxyName    string
+	Interface    *atomic.String
+	ProxyAdapter string
 	Params       map[string]string
 	PreferH3     bool
 }
@@ -512,5 +544,3 @@ func NewProxyServerHostResolver(old *Resolver) *Resolver {
 	}
 	return r
 }
-
-var ParseNameServer func(servers []string) ([]NameServer, error) // define in config/config.go

dns/system.go

@@ -1,23 +0,0 @@
-package dns
-
-import (
-	"net"
-)
-
-func loadSystemResolver() (clients []dnsClient, err error) {
-	nameservers, err := dnsReadConfig()
-	if err != nil {
-		return
-	}
-	if len(nameservers) == 0 {
-		return
-	}
-	servers := make([]NameServer, 0, len(nameservers))
-	for _, addr := range nameservers {
-		servers = append(servers, NameServer{
-			Addr: net.JoinHostPort(addr, "53"),
-			Net:  "udp",
-		})
-	}
-	return transform(servers, nil), nil
-}

dns/system_posix.go

@@ -1,27 +0,0 @@
-//go:build !windows
-
-package dns
-
-import (
-	"fmt"
-	"os"
-	"regexp"
-)
-
-var (
-	// nameserver xxx.xxx.xxx.xxx
-	nameserverPattern = regexp.MustCompile(`nameserver\s+(?P<ip>\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})`)
-)
-
-func dnsReadConfig() (servers []string, err error) {
-	content, err := os.ReadFile("/etc/resolv.conf")
-	if err != nil {
-		err = fmt.Errorf("failed to read /etc/resolv.conf: %w", err)
-		return
-	}
-	for _, line := range nameserverPattern.FindAllStringSubmatch(string(content), -1) {
-		addr := line[1]
-		servers = append(servers, addr)
-	}
-	return
-}

dns/system_windows.go

@@ -1,77 +0,0 @@
-//go:build windows
-
-package dns
-
-import (
-	"net"
-	"os"
-	"syscall"
-	"unsafe"
-
-	"golang.org/x/sys/windows"
-)
-
-func dnsReadConfig() (servers []string, err error) {
-	aas, err := adapterAddresses()
-	if err != nil {
-		return
-	}
-	for _, aa := range aas {
-		for dns := aa.FirstDnsServerAddress; dns != nil; dns = dns.Next {
-			sa, err := dns.Address.Sockaddr.Sockaddr()
-			if err != nil {
-				continue
-			}
-			var ip net.IP
-			switch sa := sa.(type) {
-			case *syscall.SockaddrInet4:
-				ip = net.IPv4(sa.Addr[0], sa.Addr[1], sa.Addr[2], sa.Addr[3])
-			case *syscall.SockaddrInet6:
-				ip = make(net.IP, net.IPv6len)
-				copy(ip, sa.Addr[:])
-				if ip[0] == 0xfe && ip[1] == 0xc0 {
-					// Ignore these fec0/10 ones. Windows seems to
-					// populate them as defaults on its misc rando
-					// interfaces.
-					continue
-				}
-				//continue
-			default:
-				// Unexpected type.
-				continue
-			}
-			servers = append(servers, ip.String())
-		}
-	}
-	return
-}
-
-// adapterAddresses returns a list of IP adapter and address
-// structures. The structure contains an IP adapter and flattened
-// multiple IP addresses including unicast, anycast and multicast
-// addresses.
-func adapterAddresses() ([]*windows.IpAdapterAddresses, error) {
-	var b []byte
-	l := uint32(15000) // recommended initial size
-	for {
-		b = make([]byte, l)
-		err := windows.GetAdaptersAddresses(syscall.AF_UNSPEC, windows.GAA_FLAG_INCLUDE_PREFIX, 0, (*windows.IpAdapterAddresses)(unsafe.Pointer(&b[0])), &l)
-		if err == nil {
-			if l == 0 {
-				return nil, nil
-			}
-			break
-		}
-		if err.(syscall.Errno) != syscall.ERROR_BUFFER_OVERFLOW {
-			return nil, os.NewSyscallError("getadaptersaddresses", err)
-		}
-		if l <= uint32(len(b)) {
-			return nil, os.NewSyscallError("getadaptersaddresses", err)
-		}
-	}
-	var aas []*windows.IpAdapterAddresses
-	for aa := (*windows.IpAdapterAddresses)(unsafe.Pointer(&b[0])); aa != nil; aa = aa.Next {
-		aas = append(aas, aa)
-	}
-	return aas, nil
-}