Update prerelease.yml

.github/workflows/docker.yaml

@@ -1,13 +1,11 @@
 name: Docker
 
-on:
-  push:
-    branches:
-      - Beta
-    tags:
-      - "v*"
+on: [push]
+
 env:
   REGISTRY: docker.io
+  IMAGE_NAME: '{{ env.DOCKERHUB_ACCOUNT }}/{{ env.DOCKERHUB_REPO }}'
+
 jobs:
   build:
     runs-on: ubuntu-latest
@@ -25,8 +23,6 @@ jobs:
 
       - name: Setup Docker buildx
         uses: docker/setup-buildx-action@v1
-        with:
-          version: latest
 
       # Extract metadata (tags, labels) for Docker
       # https://github.com/docker/metadata-action
@@ -34,15 +30,15 @@ jobs:
         id: meta
         uses: docker/metadata-action@v3
         with:
-          images: ${{ env.REGISTRY }}/${{ secrets.DOCKERHUB_ACCOUNT }}/${{secrets.DOCKERHUB_REPO}}
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
 
-      - name: Log into registry
+      - name: Log into registry ${{ env.REGISTRY }}
         if: github.event_name != 'pull_request'
         uses: docker/login-action@v1
         with:
           registry: ${{ env.REGISTRY }}
-          username: ${{ secrets.DOCKER_HUB_USER }}
-          password: ${{ secrets.DOCKER_HUB_TOKEN }}
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       # Build and push Docker image with Buildx (don't push on PR)
       # https://github.com/docker/build-push-action
@@ -51,7 +47,6 @@ jobs:
         uses: docker/build-push-action@v2
         with:
           context: .
-          file: ./Dockerfile
           push: ${{ github.event_name != 'pull_request' }}
           platforms: |
             linux/386

.github/workflows/prerelease.yml

@@ -1,4 +1,4 @@
-name: Prerelease
+name: prerelease
 on:
   push:
     branches:
@@ -31,31 +31,28 @@ jobs:
           key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
           restore-keys: |
             ${{ runner.os }}-go-
-
-
       - name: Test
-        if: ${{github.ref_name=='Beta'}}
+        if: ${{env.GITHUB_REF_NAME=='Beta'}}
         run: |
           go test ./...
-
       - name: Build
         if: success()
         env:
           NAME: Clash.Meta
           BINDIR: bin
-        run: make -j$(($(nproc) + 1)) releases
+        run: make -j releases
 
       - name: Delete current release assets
         uses: andreaswilli/delete-release-assets-action@v2.0.0
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
-          tag: Prerelease-${{ github.ref_name }}
+          tag: ${{ env.GITHUB_REF_NAME }}
           deleteOnlyFromDrafts: false
 
       - name: Tag Repo
         uses: richardsimko/update-tag@v1
         with:
-          tag_name: Prerelease-${{ github.ref_name }}
+          tag_name: ${{env.GITHUB_REF_NAME}}
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
@@ -63,8 +60,8 @@ jobs:
         uses: softprops/action-gh-release@v1
         if: ${{  success() }}
         with:
-          tag: ${{ github.ref_name }}
-          tag_name: Prerelease-${{ github.ref_name }}
+          tag: ${{env.GITHUB_REF_NAME}}
+          tag_name: ${{env.GITHUB_REF_NAME}}
           files: bin/*
           prerelease: true
           generate_release_notes: true

.github/workflows/product.yaml

@@ -1,64 +0,0 @@
-name: Build
-on:
-  push:
-    branches:
-      - release
-  workflow_dispatch:
-
-jobs:
-  Build:
-    runs-on: self-hosted
-    steps:
-      - name: Get latest go version
-        id: version
-        run: |
-          echo ::set-output name=go_version::$(curl -s https://raw.githubusercontent.com/actions/go-versions/main/versions-manifest.json | grep -oE '"version": "[0-9]{1}.[0-9]{1,}(.[0-9]{1,})?"' | head -1 | cut -d':' -f2 | sed 's/ //g; s/"//g')
-      - name: Setup Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: ${{ steps.version.outputs.go_version }}
-
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v3
-
-      - name: Cache go module
-        uses: actions/cache@v2
-        with:
-          path: ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
-      - name: Test
-        run: |
-          go test ./...
-
-      - name: Build
-        if: success()
-        env:
-          NAME: Clash.Meta
-          BINDIR: bin
-        run: make -j$(($(nproc) + 1)) linux-amd64v2 windows-amd64v2 darwin-arm64 linux-amd64v3 windows-amd64v3 linux-arm64
-
-      - name: Delete current release assets
-        uses: andreaswilli/delete-release-assets-action@v2.0.0
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          tag: test
-          deleteOnlyFromDrafts: false
-
-      - name: Tag Repo
-        uses: richardsimko/update-tag@v1
-        with:
-          tag_name: test
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Upload Alpha
-        uses: softprops/action-gh-release@v1
-        if: ${{  success() }}
-        with:
-          tag: test
-          tag_name: test
-          files: bin/*
-          prerelease: true
-          generate_release_notes: true

.github/workflows/release.yaml

@@ -1,4 +1,4 @@
-name: Release
+name: release-test
 on:
   push:
     tags:
@@ -33,9 +33,23 @@ jobs:
         env:
           NAME: Clash.Meta
           BINDIR: bin
-        run: make -j$(($(nproc) + 1)) releases
+        run: make -j releases
 
-      - name: Upload Release
+      - name: Delete current release assets
+        uses: andreaswilli/delete-release-assets-action@v2.0.0
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          tag: beta
+          deleteOnlyFromDrafts: false
+
+      - name: Tag Repo
+        uses: richardsimko/update-tag@v1
+        with:
+          tag_name: beta
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Upload Alpha
         uses: softprops/action-gh-release@v1
         if: ${{ success() && startsWith(github.ref, 'refs/tags/')}}
         with:

Dockerfile

@@ -1,26 +1,41 @@
 FROM golang:alpine as builder
 
+ARG TARGETOS
+ARG TARGETARCH
+
 RUN apk add --no-cache make git && \
     mkdir /clash-config && \
     wget -O /clash-config/Country.mmdb https://raw.githubusercontent.com/Loyalsoldier/geoip/release/Country.mmdb && \
     wget -O /clash-config/geosite.dat https://github.com/Loyalsoldier/v2ray-rules-dat/releases/latest/download/geosite.dat && \
     wget -O /clash-config/geoip.dat https://github.com/Loyalsoldier/v2ray-rules-dat/releases/latest/download/geoip.dat
 
-
-COPY . /clash-src
 WORKDIR /clash-src
-RUN go mod download &&\
-    make docker &&\
-    mv ./bin/Clash.Meta-docker /clash
-
+COPY . /clash-src
+RUN go mod download
+RUN /bin/ash -c 'set -ex && \
+    if [ "$TARGETARCH" == "amd64" ]; then \
+       GOOS=$TARGETOS GOARCH=$TARGETARCH GOAMD64=v1 make docker && \
+       mv ./bin/Clash.Meta-docker ./bin/clash-amd64v1 && \
+       GOOS=$TARGETOS GOARCH=$TARGETARCH GOAMD64=v2 make docker && \
+       mv ./bin/Clash.Meta-docker ./bin/clash-amd64v2 && \
+       GOOS=$TARGETOS GOARCH=$TARGETARCH GOAMD64=v3 make docker && \
+       mv ./bin/Clash.Meta-docker ./bin/clash-amd64v3 && \
+       ln -s clash-amd64v3 ./bin/clash-amd64v4 && \
+       mv check_amd64.sh ./bin/ && \
+       printf "#!/bin/sh\\nsh ./check_amd64.sh\\nexec ./clash-amd64v\$? \$@" > ./bin/clash && \
+       chmod +x ./bin/check_amd64.sh ./bin/clash; \
+    else \
+       GOOS=$TARGETOS GOARCH=$TARGETARCH make docker && \
+       mv ./bin/Clash.Meta-docker ./bin/clash; \
+    fi'
 FROM alpine:latest
 LABEL org.opencontainers.image.source="https://github.com/MetaCubeX/Clash.Meta"
 
 RUN apk add --no-cache ca-certificates tzdata
 
 VOLUME ["/root/.config/clash/"]
+EXPOSE 7890/tcp
 
 COPY --from=builder /clash-config/ /root/.config/clash/
-COPY --from=builder /clash /clash
-RUN chmod +x /clash
+COPY --from=builder /clash-src/bin/ /
 ENTRYPOINT [ "/clash" ]

Makefile

@@ -1,16 +1,7 @@
 NAME=Clash.Meta
 BINDIR=bin
-BRANCH=$(shell git branch --show-current)
-ifeq ($(BRANCH),Alpha)
+BRANCH=$(shell git rev-parse --abbrev-ref HEAD)
 VERSION=alpha-$(shell git rev-parse --short HEAD)
-else ifeq ($(BRANCH),Beta)
-VERSION=beta-$(shell git rev-parse --short HEAD)
-else ifeq ($(BRANCH),)
-VERSION=$(shell git describe --tags)
-else
-VERSION=unknown
-endif
-
 BUILDTIME=$(shell date -u)
 GOBUILD=CGO_ENABLED=0 go build -trimpath -ldflags '-X "github.com/Dreamacro/clash/constant.Version=$(VERSION)" \
 		-X "github.com/Dreamacro/clash/constant.BuildTime=$(BUILDTIME)" \
@@ -47,12 +38,12 @@ WINDOWS_ARCH_LIST = \
 	windows-arm64 \
     windows-arm32v7
 
-all:linux-amd64v3 linux-arm64\
-	darwin-amd64v3 darwin-arm64\
- 	windows-amd64v3 windows-arm64\
+all:linux-amd64 linux-arm64\
+	darwin-amd64 darwin-arm64\
+ 	windows-amd64 windows-arm64\
 
 docker:
-	GOAMD64=v3 $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
+	$(GOBUILD) -o $(BINDIR)/$(NAME)-$@
 
 darwin-amd64v3:
 	GOARCH=amd64 GOOS=darwin GOAMD64=v3 $(GOBUILD) -o $(BINDIR)/$(NAME)-$@

adapter/adapter.go

@@ -4,9 +4,6 @@ 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"
@@ -14,6 +11,10 @@ import (
 	"strings"
 	"time"
 
+	"github.com/Dreamacro/clash/common/queue"
+	"github.com/Dreamacro/clash/component/dialer"
+	C "github.com/Dreamacro/clash/constant"
+
 	"go.uber.org/atomic"
 )
 

adapter/inbound/https.go

@@ -11,7 +11,7 @@ import (
 // NewHTTPS receive CONNECT request and return ConnContext
 func NewHTTPS(request *http.Request, conn net.Conn) *context.ConnContext {
 	metadata := parseHTTPAddr(request)
-	metadata.Type = C.HTTPS
+	metadata.Type = C.HTTPCONNECT
 	if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
 		metadata.SrcIP = ip
 		metadata.SrcPort = port

adapter/outbound/base.go

@@ -2,11 +2,12 @@ package outbound
 
 import (
 	"context"
+	"crypto/sha1"
+	"encoding/hex"
 	"encoding/json"
 	"errors"
-	"github.com/gofrs/uuid"
 	"net"
-	"strings"
+	"regexp"
 
 	"github.com/Dreamacro/clash/component/dialer"
 	C "github.com/Dreamacro/clash/constant"
@@ -19,7 +20,6 @@ type Base struct {
 	tp    C.AdapterType
 	udp   bool
 	rmark int
-	id    string
 }
 
 // Name implements C.ProxyAdapter
@@ -27,20 +27,6 @@ func (b *Base) Name() string {
 	return b.name
 }
 
-// Id implements C.ProxyAdapter
-func (b *Base) Id() string {
-	if b.id == "" {
-		id, err := uuid.NewV6()
-		if err != nil {
-			b.id = b.name
-		} else {
-			b.id = id.String()
-		}
-	}
-
-	return b.id
-}
-
 // Type implements C.ProxyAdapter
 func (b *Base) Type() C.AdapterType {
 	return b.tp
@@ -51,10 +37,6 @@ 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, 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, errors.New("no support")
@@ -79,7 +61,6 @@ func (b *Base) SupportUDP() bool {
 func (b *Base) MarshalJSON() ([]byte, error) {
 	return json.Marshal(map[string]string{
 		"type": b.Type().String(),
-		"id":   b.Id(),
 	})
 }
 
@@ -133,12 +114,7 @@ func NewBase(opt BaseOption) *Base {
 
 type conn struct {
 	net.Conn
-	chain                   C.Chain
-	actualRemoteDestination string
-}
-
-func (c *conn) RemoteDestination() string {
-	return c.actualRemoteDestination
+	chain C.Chain
 }
 
 // Chains implements C.Connection
@@ -152,17 +128,12 @@ func (c *conn) AppendToChains(a C.ProxyAdapter) {
 }
 
 func NewConn(c net.Conn, a C.ProxyAdapter) C.Conn {
-	return &conn{c, []string{a.Name()}, parseRemoteDestination(a.Addr())}
+	return &conn{c, []string{a.Name()}}
 }
 
 type packetConn struct {
 	net.PacketConn
-	chain                   C.Chain
-	actualRemoteDestination string
-}
-
-func (c *packetConn) RemoteDestination() string {
-	return c.actualRemoteDestination
+	chain C.Chain
 }
 
 // Chains implements C.Connection
@@ -176,17 +147,30 @@ func (c *packetConn) AppendToChains(a C.ProxyAdapter) {
 }
 
 func newPacketConn(pc net.PacketConn, a C.ProxyAdapter) C.PacketConn {
-	return &packetConn{pc, []string{a.Name()}, parseRemoteDestination(a.Addr())}
+	return &packetConn{pc, []string{a.Name()}}
 }
 
-func parseRemoteDestination(addr string) string {
-	if dst, _, err := net.SplitHostPort(addr); err == nil {
-		return dst
-	} else {
-		if addrError, ok := err.(*net.AddrError); ok && strings.Contains(addrError.Err, "missing port") {
-			return dst
-		} else {
-			return ""
-		}
+func uuidMap(str string) string {
+	match, _ := regexp.MatchString(`[\da-f]{8}(-[\da-f]{4}){3}-[\da-f]{12}$`, str)
+	if !match {
+		var Nil [16]byte
+		h := sha1.New()
+		h.Write(Nil[:])
+		h.Write([]byte(str))
+		u := h.Sum(nil)[:16]
+		u[6] = (u[6] & 0x0f) | (5 << 4)
+		u[8] = u[8]&(0xff>>2) | (0x02 << 6)
+		buf := make([]byte, 36)
+		hex.Encode(buf[0:8], u[0:4])
+		buf[8] = '-'
+		hex.Encode(buf[9:13], u[4:6])
+		buf[13] = '-'
+		hex.Encode(buf[14:18], u[6:8])
+		buf[18] = '-'
+		hex.Encode(buf[19:23], u[8:10])
+		buf[23] = '-'
+		hex.Encode(buf[24:], u[10:])
+		return string(buf)
 	}
+	return str
 }

adapter/outbound/direct.go

@@ -56,3 +56,13 @@ func NewCompatible() *Direct {
 		},
 	}
 }
+
+func NewPass() *Direct {
+	return &Direct{
+		Base: &Base{
+			name: "PASS",
+			tp:   C.Pass,
+			udp:  true,
+		},
+	}
+}

adapter/outbound/reject.go

@@ -34,16 +34,6 @@ func NewReject() *Reject {
 	}
 }
 
-func NewPass() *Reject {
-	return &Reject{
-		Base: &Base{
-			name: "PASS",
-			tp:   C.Pass,
-			udp:  true,
-		},
-	}
-}
-
 type nopConn struct{}
 
 func (rw *nopConn) Read(b []byte) (int, error) {

adapter/outbound/snell.go

@@ -99,13 +99,7 @@ func (s *Snell) ListenPacketContext(ctx context.Context, metadata *C.Metadata, o
 	tcpKeepAlive(c)
 	c = streamConn(c, streamOption{s.psk, s.version, s.addr, s.obfsOption})
 
-	err = snell.WriteUDPHeader(c, s.version)
-	if err != nil {
-		return nil, err
-	}
-
-	pc := snell.PacketConn(c)
-	return newPacketConn(pc, s), nil
+	return s.ListenPacketOnStreamConn(c, metadata)
 }
 
 // ListenPacketOnStreamConn implements C.ProxyAdapter

adapter/outbound/trojan.go

@@ -13,6 +13,8 @@ import (
 	"github.com/Dreamacro/clash/transport/gun"
 	"github.com/Dreamacro/clash/transport/trojan"
 	"github.com/Dreamacro/clash/transport/vless"
+
+	"golang.org/x/net/http2"
 )
 
 type Trojan struct {
@@ -23,7 +25,7 @@ type Trojan struct {
 	// for gun mux
 	gunTLSConfig *tls.Config
 	gunConfig    *gun.Config
-	transport    *gun.TransportWrap
+	transport    *http2.Transport
 }
 
 type TrojanOption struct {
@@ -159,13 +161,7 @@ func (t *Trojan) ListenPacketContext(ctx context.Context, metadata *C.Metadata,
 		}
 	}
 
-	err = t.instance.WriteHeader(c, trojan.CommandUDP, serializesSocksAddr(metadata))
-	if err != nil {
-		return nil, err
-	}
-
-	pc := t.instance.PacketConn(c)
-	return newPacketConn(pc, t), err
+	return t.ListenPacketOnStreamConn(c, metadata)
 }
 
 // ListenPacketOnStreamConn implements C.ProxyAdapter

adapter/outbound/vless.go

@@ -18,6 +18,8 @@ import (
 	"github.com/Dreamacro/clash/transport/gun"
 	"github.com/Dreamacro/clash/transport/vless"
 	"github.com/Dreamacro/clash/transport/vmess"
+
+	"golang.org/x/net/http2"
 )
 
 const (
@@ -33,7 +35,7 @@ type Vless struct {
 	// for gun mux
 	gunTLSConfig *tls.Config
 	gunConfig    *gun.Config
-	transport    *gun.TransportWrap
+	transport    *http2.Transport
 }
 
 type VlessOption struct {
@@ -394,7 +396,7 @@ func NewVless(option VlessOption) (*Vless, error) {
 		}
 	}
 
-	client, err := vless.NewClient(option.UUID, addons, option.FlowShow)
+	client, err := vless.NewClient(uuidMap(option.UUID), addons, option.FlowShow)
 	if err != nil {
 		return nil, err
 	}

adapter/outbound/vmess.go

@@ -15,6 +15,8 @@ import (
 	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/transport/gun"
 	"github.com/Dreamacro/clash/transport/vmess"
+
+	"golang.org/x/net/http2"
 )
 
 type Vmess struct {
@@ -25,7 +27,7 @@ type Vmess struct {
 	// for gun mux
 	gunTLSConfig *tls.Config
 	gunConfig    *gun.Config
-	transport    *gun.TransportWrap
+	transport    *http2.Transport
 }
 
 type VmessOption struct {
@@ -274,7 +276,7 @@ func (v *Vmess) SupportUOT() bool {
 func NewVmess(option VmessOption) (*Vmess, error) {
 	security := strings.ToLower(option.Cipher)
 	client, err := vmess.NewClient(vmess.Config{
-		UUID:     option.UUID,
+		UUID:     uuidMap(option.UUID),
 		AlterID:  uint16(option.AlterID),
 		Security: security,
 		HostName: option.Server,

adapter/outboundgroup/fallback.go

@@ -3,19 +3,21 @@ package outboundgroup
 import (
 	"context"
 	"encoding/json"
-	"errors"
+	"github.com/Dreamacro/clash/log"
+	"go.uber.org/atomic"
+	"time"
+
 	"github.com/Dreamacro/clash/adapter/outbound"
 	"github.com/Dreamacro/clash/component/dialer"
 	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/constant/provider"
-	"time"
 )
 
 type Fallback struct {
 	*GroupBase
-	disableUDP bool
-	testUrl    string
-	selected   string
+	disableUDP  bool
+	failedTimes *atomic.Int32
+	failedTime  *atomic.Int64
 }
 
 func (f *Fallback) Now() string {
@@ -29,7 +31,8 @@ func (f *Fallback) DialContext(ctx context.Context, metadata *C.Metadata, opts .
 	c, err := proxy.DialContext(ctx, metadata, f.Base.DialOptions(opts...)...)
 	if err == nil {
 		c.AppendToChains(f)
-		f.onDialSuccess()
+		f.failedTimes.Store(-1)
+		f.failedTime.Store(-1)
 	} else {
 		f.onDialFailed()
 	}
@@ -43,11 +46,41 @@ func (f *Fallback) ListenPacketContext(ctx context.Context, metadata *C.Metadata
 	pc, err := proxy.ListenPacketContext(ctx, metadata, f.Base.DialOptions(opts...)...)
 	if err == nil {
 		pc.AppendToChains(f)
+		f.failedTimes.Store(-1)
+		f.failedTime.Store(-1)
+	} else {
+		f.onDialFailed()
 	}
 
 	return pc, err
 }
 
+func (f *Fallback) onDialFailed() {
+	if f.failedTime.Load() == -1 {
+		log.Warnln("%s first failed", f.Name())
+		now := time.Now().UnixMilli()
+		f.failedTime.Store(now)
+		f.failedTimes.Store(1)
+	} else {
+		if f.failedTime.Load()-time.Now().UnixMilli() > 5*time.Second.Milliseconds() {
+			f.failedTimes.Store(-1)
+			f.failedTime.Store(-1)
+		} else {
+			failedCount := f.failedTimes.Inc()
+			log.Warnln("%s failed count: %d", f.Name(), failedCount)
+			if failedCount >= 5 {
+				log.Warnln("because %s failed multiple times, active health check", f.Name())
+				for _, proxyProvider := range f.providers {
+					go proxyProvider.HealthCheck()
+				}
+
+				f.failedTimes.Store(-1)
+				f.failedTime.Store(-1)
+			}
+		}
+	}
+}
+
 // SupportUDP implements C.ProxyAdapter
 func (f *Fallback) SupportUDP() bool {
 	if f.disableUDP {
@@ -79,40 +112,13 @@ func (f *Fallback) Unwrap(metadata *C.Metadata) C.Proxy {
 
 func (f *Fallback) findAliveProxy(touch bool) C.Proxy {
 	proxies := f.GetProxies(touch)
-	al := proxies[0]
-	for i := len(proxies) - 1; i > -1; i-- {
-		proxy := proxies[i]
-		if proxy.Name() == f.selected && proxy.Alive() {
+	for _, proxy := range proxies {
+		if proxy.Alive() {
 			return proxy
 		}
-		if proxy.Alive() {
-			al = proxy
-		}
-	}
-	return al
-}
-
-func (f *Fallback) Set(name string) error {
-	var p C.Proxy
-	for _, proxy := range f.GetProxies(false) {
-		if proxy.Name() == name {
-			p = proxy
-			break
-		}
 	}
 
-	if p == nil {
-		return errors.New("proxy not exist")
-	}
-
-	f.selected = name
-	if !p.Alive() {
-		ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*time.Duration(5000))
-		defer cancel()
-		_, _ = p.URLTest(ctx, f.testUrl)
-	}
-
-	return nil
+	return proxies[0]
 }
 
 func NewFallback(option *GroupCommonOption, providers []provider.ProxyProvider) *Fallback {
@@ -127,7 +133,8 @@ func NewFallback(option *GroupCommonOption, providers []provider.ProxyProvider)
 			option.Filter,
 			providers,
 		}),
-		disableUDP: option.DisableUDP,
-		testUrl:    option.URL,
+		disableUDP:  option.DisableUDP,
+		failedTimes: atomic.NewInt32(-1),
+		failedTime:  atomic.NewInt64(-1),
 	}
 }

adapter/outboundgroup/groupbase.go

@@ -1,30 +1,21 @@
 package outboundgroup
 
 import (
-	"context"
-	"fmt"
 	"github.com/Dreamacro/clash/adapter/outbound"
 	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/constant/provider"
 	types "github.com/Dreamacro/clash/constant/provider"
-	"github.com/Dreamacro/clash/log"
 	"github.com/Dreamacro/clash/tunnel"
 	"github.com/dlclark/regexp2"
-	"go.uber.org/atomic"
 	"sync"
-	"time"
 )
 
 type GroupBase struct {
 	*outbound.Base
-	filter        *regexp2.Regexp
-	providers     []provider.ProxyProvider
-	versions      sync.Map // map[string]uint
-	proxies       sync.Map // map[string][]C.Proxy
-	failedTestMux sync.Mutex
-	failedTimes   int
-	failedTime    time.Time
-	failedTesting *atomic.Bool
+	filter    *regexp2.Regexp
+	providers []provider.ProxyProvider
+	versions  sync.Map // map[string]uint
+	proxies   sync.Map // map[string][]C.Proxy
 }
 
 type GroupBaseOption struct {
@@ -39,10 +30,9 @@ func NewGroupBase(opt GroupBaseOption) *GroupBase {
 		filter = regexp2.MustCompile(opt.filter, 0)
 	}
 	return &GroupBase{
-		Base:          outbound.NewBase(opt.BaseOption),
-		filter:        filter,
-		providers:     opt.providers,
-		failedTesting: atomic.NewBool(false),
+		Base:      outbound.NewBase(opt.BaseOption),
+		filter:    filter,
+		providers: opt.providers,
 	}
 }
 
@@ -61,7 +51,7 @@ func (gb *GroupBase) GetProxies(touch bool) []C.Proxy {
 		}
 		return proxies
 	}
-
+	//TODO("Touch Version 没变的")
 	for _, pd := range gb.providers {
 		if pd.VehicleType() == types.Compatible {
 			if touch {
@@ -106,89 +96,3 @@ func (gb *GroupBase) GetProxies(touch bool) []C.Proxy {
 	}
 	return proxies
 }
-
-func (gb *GroupBase) URLTest(ctx context.Context, url string) (map[string]uint16, error) {
-	var wg sync.WaitGroup
-	var lock sync.Mutex
-	mp := map[string]uint16{}
-	proxies := gb.GetProxies(false)
-	for _, proxy := range proxies {
-		proxy := proxy
-		wg.Add(1)
-		go func() {
-			delay, err := proxy.URLTest(ctx, url)
-			lock.Lock()
-			if err == nil {
-				mp[proxy.Name()] = delay
-			}
-			lock.Unlock()
-
-			wg.Done()
-		}()
-	}
-	wg.Wait()
-
-	if len(mp) == 0 {
-		return mp, fmt.Errorf("get delay: all proxies timeout")
-	} else {
-		return mp, nil
-	}
-}
-
-func (gb *GroupBase) onDialFailed() {
-	if gb.failedTesting.Load() {
-		return
-	}
-
-	go func() {
-		gb.failedTestMux.Lock()
-		defer gb.failedTestMux.Unlock()
-
-		gb.failedTimes++
-		if gb.failedTimes == 1 {
-			log.Debugln("ProxyGroup: %s first failed", gb.Name())
-			gb.failedTime = time.Now()
-		} else {
-			if time.Since(gb.failedTime) > gb.failedTimeoutInterval() {
-				return
-			}
-
-			log.Debugln("ProxyGroup: %s failed count: %d", gb.Name(), gb.failedTimes)
-			if gb.failedTimes >= gb.maxFailedTimes() {
-				gb.failedTesting.Store(true)
-				log.Warnln("because %s failed multiple times, active health check", gb.Name())
-				wg := sync.WaitGroup{}
-				for _, proxyProvider := range gb.providers {
-					wg.Add(1)
-					proxyProvider := proxyProvider
-					go func() {
-						defer wg.Done()
-						proxyProvider.HealthCheck()
-					}()
-				}
-
-				wg.Wait()
-				gb.failedTesting.Store(false)
-				gb.failedTimes = 0
-			}
-		}
-	}()
-}
-
-func (gb *GroupBase) failedIntervalTime() int64 {
-	return 5 * time.Second.Milliseconds()
-}
-
-func (gb *GroupBase) onDialSuccess() {
-	if !gb.failedTesting.Load() {
-		gb.failedTimes = 0
-	}
-}
-
-func (gb *GroupBase) maxFailedTimes() int {
-	return 5
-}
-
-func (gb *GroupBase) failedTimeoutInterval() time.Duration {
-	return 5 * time.Second
-}

adapter/outboundgroup/loadbalance.go

@@ -5,9 +5,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/Dreamacro/clash/common/cache"
 	"net"
-	"time"
 
 	"github.com/Dreamacro/clash/adapter/outbound"
 	"github.com/Dreamacro/clash/common/murmur3"
@@ -38,10 +36,6 @@ func parseStrategy(config map[string]any) string {
 }
 
 func getKey(metadata *C.Metadata) string {
-	if metadata == nil {
-		return ""
-	}
-
 	if metadata.Host != "" {
 		// ip host
 		if ip := net.ParseIP(metadata.Host); ip != nil {
@@ -60,16 +54,6 @@ func getKey(metadata *C.Metadata) string {
 	return metadata.DstIP.String()
 }
 
-func getKeyWithSrcAndDst(metadata *C.Metadata) string {
-	dst := getKey(metadata)
-	src := ""
-	if metadata != nil {
-		src = metadata.SrcIP.String()
-	}
-
-	return fmt.Sprintf("%s%s", src, dst)
-}
-
 func jumpHash(key uint64, buckets int32) int32 {
 	var b, j int64
 
@@ -87,9 +71,6 @@ func (lb *LoadBalance) DialContext(ctx context.Context, metadata *C.Metadata, op
 	defer func() {
 		if err == nil {
 			c.AppendToChains(lb)
-			lb.onDialSuccess()
-		} else {
-			lb.onDialFailed()
 		}
 	}()
 
@@ -149,41 +130,6 @@ func strategyConsistentHashing() strategyFn {
 	}
 }
 
-func strategyStickySessions() strategyFn {
-	ttl := time.Minute * 10
-	maxRetry := 5
-	lruCache := cache.NewLRUCache[uint64, int](
-		cache.WithAge[uint64, int](int64(ttl.Seconds())),
-		cache.WithSize[uint64, int](1000))
-	return func(proxies []C.Proxy, metadata *C.Metadata) C.Proxy {
-		key := uint64(murmur3.Sum32([]byte(getKeyWithSrcAndDst(metadata))))
-		length := len(proxies)
-		idx, has := lruCache.Get(key)
-		if !has {
-			idx = int(jumpHash(key+uint64(time.Now().UnixNano()), int32(length)))
-		}
-
-		nowIdx := idx
-		for i := 1; i < maxRetry; i++ {
-			proxy := proxies[nowIdx]
-			if proxy.Alive() {
-				if nowIdx != idx {
-					lruCache.Delete(key)
-					lruCache.Set(key, nowIdx)
-				}
-
-				return proxy
-			} else {
-				nowIdx = int(jumpHash(key+uint64(time.Now().UnixNano()), int32(length)))
-			}
-		}
-
-		lruCache.Delete(key)
-		lruCache.Set(key, 0)
-		return proxies[0]
-	}
-}
-
 // Unwrap implements C.ProxyAdapter
 func (lb *LoadBalance) Unwrap(metadata *C.Metadata) C.Proxy {
 	proxies := lb.GetProxies(true)
@@ -192,7 +138,7 @@ func (lb *LoadBalance) Unwrap(metadata *C.Metadata) C.Proxy {
 
 // MarshalJSON implements C.ProxyAdapter
 func (lb *LoadBalance) MarshalJSON() ([]byte, error) {
-	var all []string
+	all := []string{}
 	for _, proxy := range lb.GetProxies(false) {
 		all = append(all, proxy.Name())
 	}
@@ -209,8 +155,6 @@ func NewLoadBalance(option *GroupCommonOption, providers []provider.ProxyProvide
 		strategyFn = strategyConsistentHashing()
 	case "round-robin":
 		strategyFn = strategyRoundRobin()
-	case "sticky-sessions":
-		strategyFn = strategyStickySessions()
 	default:
 		return nil, fmt.Errorf("%w: %s", errStrategy, strategy)
 	}

adapter/outboundgroup/parser.go

@@ -76,9 +76,7 @@ func ParseProxyGroup(config map[string]any, proxyMap map[string]C.Proxy, provide
 			providersMap[groupName] = pd
 		} else {
 			if groupOption.URL == "" || groupOption.Interval == 0 {
-				//return nil, errMissHealthCheck
-				groupOption.URL = "http://www.gstatic.com/generate_204"
-				groupOption.Interval = 300
+				return nil, errMissHealthCheck
 			}
 
 			hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval), groupOption.Lazy)

adapter/outboundgroup/relay.go

@@ -170,11 +170,6 @@ func (r *Relay) proxies(metadata *C.Metadata, touch bool) ([]C.Proxy, []C.Proxy)
 	return targetProxies, chainProxies
 }
 
-func (r *Relay) Addr() string {
-	proxies, _ := r.proxies(nil, true)
-	return proxies[len(proxies)-1].Addr()
-}
-
 func NewRelay(option *GroupCommonOption, providers []provider.ProxyProvider) *Relay {
 	return &Relay{
 		GroupBase: NewGroupBase(GroupBaseOption{

adapter/outboundgroup/urltest.go

@@ -3,6 +3,8 @@ package outboundgroup
 import (
 	"context"
 	"encoding/json"
+	"github.com/Dreamacro/clash/log"
+	"go.uber.org/atomic"
 	"time"
 
 	"github.com/Dreamacro/clash/adapter/outbound"
@@ -22,10 +24,12 @@ func urlTestWithTolerance(tolerance uint16) urlTestOption {
 
 type URLTest struct {
 	*GroupBase
-	tolerance  uint16
-	disableUDP bool
-	fastNode   C.Proxy
-	fastSingle *singledo.Single[C.Proxy]
+	tolerance   uint16
+	disableUDP  bool
+	fastNode    C.Proxy
+	fastSingle  *singledo.Single[C.Proxy]
+	failedTimes *atomic.Int32
+	failedTime  *atomic.Int64
 }
 
 func (u *URLTest) Now() string {
@@ -37,7 +41,8 @@ func (u *URLTest) DialContext(ctx context.Context, metadata *C.Metadata, opts ..
 	c, err = u.fast(true).DialContext(ctx, metadata, u.Base.DialOptions(opts...)...)
 	if err == nil {
 		c.AppendToChains(u)
-		u.onDialSuccess()
+		u.failedTimes.Store(-1)
+		u.failedTime.Store(-1)
 	} else {
 		u.onDialFailed()
 	}
@@ -49,8 +54,11 @@ func (u *URLTest) ListenPacketContext(ctx context.Context, metadata *C.Metadata,
 	pc, err := u.fast(true).ListenPacketContext(ctx, metadata, u.Base.DialOptions(opts...)...)
 	if err == nil {
 		pc.AppendToChains(u)
+		u.failedTimes.Store(-1)
+		u.failedTime.Store(-1)
+	} else {
+		u.onDialFailed()
 	}
-
 	return pc, err
 }
 
@@ -115,6 +123,32 @@ func (u *URLTest) MarshalJSON() ([]byte, error) {
 	})
 }
 
+func (u *URLTest) onDialFailed() {
+	if u.failedTime.Load() == -1 {
+		log.Warnln("%s first failed", u.Name())
+		now := time.Now().UnixMilli()
+		u.failedTime.Store(now)
+		u.failedTimes.Store(1)
+	} else {
+		if u.failedTime.Load()-time.Now().UnixMilli() > 5*1000 {
+			u.failedTimes.Store(-1)
+			u.failedTime.Store(-1)
+		} else {
+			failedCount := u.failedTimes.Inc()
+			log.Warnln("%s failed count: %d", u.Name(), failedCount)
+			if failedCount >= 5 {
+				log.Warnln("because %s failed multiple times, active health check", u.Name())
+				for _, proxyProvider := range u.providers {
+					go proxyProvider.HealthCheck()
+				}
+
+				u.failedTimes.Store(-1)
+				u.failedTime.Store(-1)
+			}
+		}
+	}
+}
+
 func parseURLTestOption(config map[string]any) []urlTestOption {
 	opts := []urlTestOption{}
 
@@ -137,12 +171,13 @@ func NewURLTest(option *GroupCommonOption, providers []provider.ProxyProvider, o
 				Interface:   option.Interface,
 				RoutingMark: option.RoutingMark,
 			},
-
 			option.Filter,
 			providers,
 		}),
-		fastSingle: singledo.NewSingle[C.Proxy](time.Second * 10),
-		disableUDP: option.DisableUDP,
+		fastSingle:  singledo.NewSingle[C.Proxy](time.Second * 10),
+		disableUDP:  option.DisableUDP,
+		failedTimes: atomic.NewInt32(-1),
+		failedTime:  atomic.NewInt64(-1),
 	}
 
 	for _, option := range options {

adapter/outboundgroup/util.go

@@ -51,7 +51,3 @@ func tcpKeepAlive(c net.Conn) {
 		_ = tcp.SetKeepAlivePeriod(30 * time.Second)
 	}
 }
-
-type SelectAble interface {
-	Set(string) error
-}

adapter/provider/fetcher.go

@@ -26,7 +26,6 @@ type fetcher struct {
 	done      chan struct{}
 	hash      [16]byte
 	parser    parser
-	interval  time.Duration
 	onUpdate  func(any)
 }
 
@@ -44,25 +43,11 @@ func (f *fetcher) Initial() (any, error) {
 		err     error
 		isLocal bool
 	)
-
-	defer func() {
-		// pull proxies automatically
-		if f.ticker != nil {
-			go f.pullLoop()
-		}
-	}()
-
 	if stat, fErr := os.Stat(f.vehicle.Path()); fErr == nil {
 		buf, err = os.ReadFile(f.vehicle.Path())
 		modTime := stat.ModTime()
 		f.updatedAt = &modTime
 		isLocal = true
-		if f.interval != 0 && modTime.Add(f.interval).Before(time.Now()) {
-			defer func() {
-				log.Infoln("[Provider] %s's proxies not updated for a long time, force refresh", f.Name())
-				go f.update()
-			}()
-		}
 	} else {
 		buf, err = f.vehicle.Read()
 	}
@@ -99,6 +84,11 @@ func (f *fetcher) Initial() (any, error) {
 
 	f.hash = md5.Sum(buf)
 
+	// pull proxies automatically
+	if f.ticker != nil {
+		go f.pullLoop()
+	}
+
 	return proxies, nil
 }
 
@@ -144,11 +134,21 @@ func (f *fetcher) pullLoop() {
 	for {
 		select {
 		case <-f.ticker.C:
-			same, err := f.update()
-			if same || err != nil {
+			elm, same, err := f.Update()
+			if err != nil {
+				log.Warnln("[Provider] %s pull error: %s", f.Name(), err.Error())
 				continue
 			}
 
+			if same {
+				log.Debugln("[Provider] %s's proxies doesn't change", f.Name())
+				continue
+			}
+
+			log.Infoln("[Provider] %s's proxies update", f.Name())
+			if f.onUpdate != nil {
+				f.onUpdate(elm)
+			}
 		case <-f.done:
 			f.ticker.Stop()
 			return
@@ -156,26 +156,6 @@ func (f *fetcher) pullLoop() {
 	}
 }
 
-func (f *fetcher) update() (same bool, err error) {
-	elm, same, err := f.Update()
-	if err != nil {
-		log.Warnln("[Provider] %s pull error: %s", f.Name(), err.Error())
-		return
-	}
-
-	if same {
-		log.Debugln("[Provider] %s's proxies doesn't change", f.Name())
-		return
-	}
-
-	if f.onUpdate != nil {
-		f.onUpdate(elm)
-	}
-
-	log.Infoln("[Provider] %s's proxies update", f.Name())
-	return
-}
-
 func safeWrite(path string, buf []byte) error {
 	dir := filepath.Dir(path)
 
@@ -201,6 +181,5 @@ func newFetcher(name string, interval time.Duration, vehicle types.Vehicle, pars
 		parser:   parser,
 		done:     make(chan struct{}, 1),
 		onUpdate: onUpdate,
-		interval: interval,
 	}
 }

adapter/provider/provider.go

@@ -75,7 +75,7 @@ func (pp *proxySetProvider) Initial() error {
 
 	pp.onUpdate(elm)
 	if pp.healthCheck.auto() {
-		defer func() { go pp.healthCheck.process() }()
+		go pp.healthCheck.process()
 	}
 
 	return nil

adapter/provider/vehicle.go

@@ -2,12 +2,16 @@ package provider
 
 import (
 	"context"
-	netHttp "github.com/Dreamacro/clash/component/http"
-	types "github.com/Dreamacro/clash/constant/provider"
+	"github.com/Dreamacro/clash/listener/inner"
 	"io"
+	"net"
 	"net/http"
+	"net/url"
 	"os"
 	"time"
+
+	netHttp "github.com/Dreamacro/clash/common/net"
+	types "github.com/Dreamacro/clash/constant/provider"
 )
 
 type FileVehicle struct {
@@ -46,16 +50,52 @@ func (h *HTTPVehicle) Path() string {
 func (h *HTTPVehicle) Read() ([]byte, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*20)
 	defer cancel()
-	resp, err := netHttp.HttpRequest(ctx, h.url, http.MethodGet, nil, nil)
+
+	uri, err := url.Parse(h.url)
 	if err != nil {
 		return nil, err
 	}
 
+	req, err := http.NewRequest(http.MethodGet, uri.String(), nil)
+	req.Header.Set("User-Agent", netHttp.UA)
+
+	if err != nil {
+		return nil, err
+	}
+
+	if user := uri.User; user != nil {
+		password, _ := user.Password()
+		req.SetBasicAuth(user.Username(), password)
+	}
+
+	req = req.WithContext(ctx)
+
+	transport := &http.Transport{
+		// from http.DefaultTransport
+		MaxIdleConns:          100,
+		IdleConnTimeout:       90 * time.Second,
+		TLSHandshakeTimeout:   10 * time.Second,
+		ExpectContinueTimeout: 1 * time.Second,
+		DialContext: func(ctx context.Context, network, address string) (net.Conn, error) {
+			conn := inner.HandleTcp(address, uri.Hostname())
+			return conn, nil
+		},
+	}
+
+	client := http.Client{Transport: transport}
+	resp, err := client.Do(req)
+	if err != nil {
+		if err != nil {
+			return nil, err
+		}
+	}
 	defer resp.Body.Close()
+
 	buf, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return nil, err
 	}
+
 	return buf, nil
 }
 

common/net/http.go

@@ -0,0 +1,5 @@
+package net
+
+const (
+	UA = "Clash"
+)

common/structure/structure.go

@@ -159,19 +159,9 @@ func (d *Decoder) decodeSlice(name string, data any, val reflect.Value) error {
 		for valSlice.Len() <= i {
 			valSlice = reflect.Append(valSlice, reflect.Zero(valElemType))
 		}
-		fieldName := fmt.Sprintf("%s[%d]", name, i)
-		if currentData == nil {
-			// in weakly type mode, null will convert to zero value
-			if d.option.WeaklyTypedInput {
-				continue
-			}
-			// in non-weakly type mode, null will convert to nil if element's zero value is nil, otherwise return an error
-			if elemKind := valElemType.Kind(); elemKind == reflect.Map || elemKind == reflect.Slice {
-				continue
-			}
-			return fmt.Errorf("'%s' can not be null", fieldName)
-		}
 		currentField := valSlice.Index(i)
+
+		fieldName := fmt.Sprintf("%s[%d]", name, i)
 		if err := d.decode(fieldName, currentData, currentField); err != nil {
 			return err
 		}

common/utils/uuid.go

@@ -1,16 +0,0 @@
-package utils
-
-import (
-	"github.com/gofrs/uuid"
-)
-
-var uuidNamespace, _ = uuid.FromString("00000000-0000-0000-0000-000000000000")
-
-// UUIDMap https://github.com/XTLS/Xray-core/issues/158#issue-783294090
-func UUIDMap(str string) (uuid.UUID, error) {
-	u, err := uuid.FromString(str)
-	if err != nil {
-		return uuid.NewV5(uuidNamespace, str), nil
-	}
-	return u, nil
-}

common/utils/uuid_test.go

@@ -1,74 +0,0 @@
-package utils
-
-import (
-	"github.com/gofrs/uuid"
-	"reflect"
-	"testing"
-)
-
-func TestUUIDMap(t *testing.T) {
-	type args struct {
-		str string
-	}
-
-	tests := []struct {
-		name    string
-		args    args
-		want    uuid.UUID
-		wantErr bool
-	}{
-		{
-			name: "uuid-test-1",
-			args: args{
-				str: "82410302-039e-41b6-98b0-d964084b4170",
-			},
-			want:    uuid.FromStringOrNil("82410302-039e-41b6-98b0-d964084b4170"),
-			wantErr: false,
-		},
-		{
-			name: "uuid-test-2",
-			args: args{
-				str: "88c502e6-d7eb-4c8e-8259-94cb13d83c77",
-			},
-			want:    uuid.FromStringOrNil("88c502e6-d7eb-4c8e-8259-94cb13d83c77"),
-			wantErr: false,
-		},
-		{
-			name: "uuid-map-1",
-			args: args{
-				str: "123456",
-			},
-			want:    uuid.FromStringOrNil("f8598425-92f2-5508-a071-4fc67f9040ac"),
-			wantErr: false,
-		},
-		// GENERATED BY 'xray uuid -i'
-		{
-			name: "uuid-map-2",
-			args: args{
-				str: "a9dk23bz0",
-			},
-			want:    uuid.FromStringOrNil("c91481b6-fc0f-5d9e-b166-5ddf07b9c3c5"),
-			wantErr: false,
-		},
-		{
-			name: "uuid-map-2",
-			args: args{
-				str: "中文123",
-			},
-			want:    uuid.FromStringOrNil("145c544c-2229-59e5-8dbb-3f33b7610d26"),
-			wantErr: false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := UUIDMap(tt.args.str)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("UUIDMap() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("UUIDMap() got = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}

component/dialer/dialer.go

@@ -15,7 +15,6 @@ var (
 	dialMux                    sync.Mutex
 	actualSingleDialContext    = singleDialContext
 	actualDualStackDialContext = dualStackDialContext
-	tcpConcurrent              = false
 	DisableIPv6                = false
 )
 
@@ -77,22 +76,17 @@ func ListenPacket(ctx context.Context, network, address string, options ...Optio
 
 func SetDial(concurrent bool) {
 	dialMux.Lock()
-	tcpConcurrent = concurrent
 	if concurrent {
 		actualSingleDialContext = concurrentSingleDialContext
 		actualDualStackDialContext = concurrentDualStackDialContext
 	} else {
 		actualSingleDialContext = singleDialContext
-		actualDualStackDialContext = dualStackDialContext
+		actualDualStackDialContext = concurrentDualStackDialContext
 	}
 
 	dialMux.Unlock()
 }
 
-func GetDial() bool {
-	return tcpConcurrent
-}
-
 func dialContext(ctx context.Context, network string, destination netip.Addr, port string, opt *option) (net.Conn, error) {
 	dialer := &net.Dialer{}
 	if opt.interfaceName != "" {
@@ -259,7 +253,7 @@ func concurrentDialContext(ctx context.Context, network string, ips []netip.Addr
 		}
 	}
 
-	return nil, fmt.Errorf("all ips %v tcp shake hands failed", ips)
+	return nil, errors.New("all ip tcp shake hands failed")
 }
 
 func singleDialContext(ctx context.Context, network string, address string, opt *option) (net.Conn, error) {

component/geodata/geodata.go

@@ -30,7 +30,7 @@ func (l *loader) LoadGeoSiteWithAttr(file string, siteWithAttr string) ([]*route
 		return nil, fmt.Errorf("empty listname in rule: %s", siteWithAttr)
 	}
 
-	domains, err := l.LoadSiteByPath(file, list)
+	domains, err := l.LoadSite(file, list)
 	if err != nil {
 		return nil, err
 	}
@@ -59,7 +59,7 @@ func (l *loader) LoadGeoSiteWithAttr(file string, siteWithAttr string) ([]*route
 }
 
 func (l *loader) LoadGeoIP(country string) ([]*router.CIDR, error) {
-	return l.LoadIPByPath(C.GeoipName, country)
+	return l.LoadIP(C.GeoipName, country)
 }
 
 var loaders map[string]func() LoaderImplementation

component/geodata/geodataproto.go

@@ -5,10 +5,8 @@ import (
 )
 
 type LoaderImplementation interface {
-	LoadSiteByPath(filename, list string) ([]*router.Domain, error)
-	LoadSiteByBytes(geositeBytes []byte, list string) ([]*router.Domain, error)
-	LoadIPByPath(filename, country string) ([]*router.CIDR, error)
-	LoadIPByBytes(geoipBytes []byte, country string) ([]*router.CIDR, error)
+	LoadSite(filename, list string) ([]*router.Domain, error)
+	LoadIP(filename, country string) ([]*router.CIDR, error)
 }
 
 type Loader interface {

component/geodata/memconservative/memc.go

@@ -1,7 +1,6 @@
 package memconservative
 
 import (
-	"errors"
 	"fmt"
 	"runtime"
 
@@ -14,7 +13,7 @@ type memConservativeLoader struct {
 	geositecache GeoSiteCache
 }
 
-func (m *memConservativeLoader) LoadIPByPath(filename, country string) ([]*router.CIDR, error) {
+func (m *memConservativeLoader) LoadIP(filename, country string) ([]*router.CIDR, error) {
 	defer runtime.GC()
 	geoip, err := m.geoipcache.Unmarshal(filename, country)
 	if err != nil {
@@ -23,11 +22,7 @@ func (m *memConservativeLoader) LoadIPByPath(filename, country string) ([]*route
 	return geoip.Cidr, nil
 }
 
-func (m *memConservativeLoader) LoadIPByBytes(geoipBytes []byte, country string) ([]*router.CIDR, error) {
-	return nil, errors.New("memConservative do not support LoadIPByBytes")
-}
-
-func (m *memConservativeLoader) LoadSiteByPath(filename, list string) ([]*router.Domain, error) {
+func (m *memConservativeLoader) LoadSite(filename, list string) ([]*router.Domain, error) {
 	defer runtime.GC()
 	geosite, err := m.geositecache.Unmarshal(filename, list)
 	if err != nil {
@@ -36,10 +31,6 @@ func (m *memConservativeLoader) LoadSiteByPath(filename, list string) ([]*router
 	return geosite.Domain, nil
 }
 
-func (m *memConservativeLoader) LoadSiteByBytes(geositeBytes []byte, list string) ([]*router.Domain, error) {
-	return nil, errors.New("memConservative do not support LoadSiteByBytes")
-}
-
 func newMemConservativeLoader() geodata.LoaderImplementation {
 	return &memConservativeLoader{make(map[string]*router.GeoIP), make(map[string]*router.GeoSite)}
 }

component/geodata/router/condition.go

@@ -33,10 +33,9 @@ func domainToMatcher(domain *Domain) (strmatcher.Matcher, error) {
 
 type DomainMatcher struct {
 	matchers strmatcher.IndexMatcher
-	not      bool
 }
 
-func NewMphMatcherGroup(domains []*Domain, not bool) (*DomainMatcher, error) {
+func NewMphMatcherGroup(domains []*Domain) (*DomainMatcher, error) {
 	g := strmatcher.NewMphMatcherGroup()
 	for _, d := range domains {
 		matcherType, f := matcherTypeMap[d.Type]
@@ -51,12 +50,11 @@ func NewMphMatcherGroup(domains []*Domain, not bool) (*DomainMatcher, error) {
 	g.Build()
 	return &DomainMatcher{
 		matchers: g,
-		not:      not,
 	}, nil
 }
 
 // NewDomainMatcher new domain matcher.
-func NewDomainMatcher(domains []*Domain, not bool) (*DomainMatcher, error) {
+func NewDomainMatcher(domains []*Domain) (*DomainMatcher, error) {
 	g := new(strmatcher.MatcherGroup)
 	for _, d := range domains {
 		m, err := domainToMatcher(d)
@@ -68,16 +66,11 @@ func NewDomainMatcher(domains []*Domain, not bool) (*DomainMatcher, error) {
 
 	return &DomainMatcher{
 		matchers: g,
-		not:      not,
 	}, nil
 }
 
 func (m *DomainMatcher) ApplyDomain(domain string) bool {
-	isMatched := len(m.matchers.Match(strings.ToLower(domain))) > 0
-	if m.not {
-		isMatched = !isMatched
-	}
-	return isMatched
+	return len(m.matchers.Match(strings.ToLower(domain))) > 0
 }
 
 // CIDRList is an alias of []*CIDR to provide sort.Interface.

component/geodata/standard/standard.go

@@ -29,7 +29,11 @@ func ReadAsset(file string) ([]byte, error) {
 	return ReadFile(C.Path.GetAssetLocation(file))
 }
 
-func loadIP(geoipBytes []byte, country string) ([]*router.CIDR, error) {
+func loadIP(filename, country string) ([]*router.CIDR, error) {
+	geoipBytes, err := ReadAsset(filename)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open file: %s, base error: %s", filename, err.Error())
+	}
 	var geoipList router.GeoIPList
 	if err := proto.Unmarshal(geoipBytes, &geoipList); err != nil {
 		return nil, err
@@ -41,10 +45,14 @@ func loadIP(geoipBytes []byte, country string) ([]*router.CIDR, error) {
 		}
 	}
 
-	return nil, fmt.Errorf("country %s not found", country)
+	return nil, fmt.Errorf("country not found in %s%s%s", filename, ": ", country)
 }
 
-func loadSite(geositeBytes []byte, list string) ([]*router.Domain, error) {
+func loadSite(filename, list string) ([]*router.Domain, error) {
+	geositeBytes, err := ReadAsset(filename)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open file: %s, base error: %s", filename, err.Error())
+	}
 	var geositeList router.GeoSiteList
 	if err := proto.Unmarshal(geositeBytes, &geositeList); err != nil {
 		return nil, err
@@ -56,33 +64,17 @@ func loadSite(geositeBytes []byte, list string) ([]*router.Domain, error) {
 		}
 	}
 
-	return nil, fmt.Errorf("list %s not found", list)
+	return nil, fmt.Errorf("list not found in %s%s%s", filename, ": ", list)
 }
 
 type standardLoader struct{}
 
-func (d standardLoader) LoadSiteByPath(filename, list string) ([]*router.Domain, error) {
-	geositeBytes, err := ReadAsset(filename)
-	if err != nil {
-		return nil, fmt.Errorf("failed to open file: %s, base error: %s", filename, err.Error())
-	}
-	return loadSite(geositeBytes, list)
+func (d standardLoader) LoadSite(filename, list string) ([]*router.Domain, error) {
+	return loadSite(filename, list)
 }
 
-func (d standardLoader) LoadSiteByBytes(geositeBytes []byte, list string) ([]*router.Domain, error) {
-	return loadSite(geositeBytes, list)
-}
-
-func (d standardLoader) LoadIPByPath(filename, country string) ([]*router.CIDR, error) {
-	geoipBytes, err := ReadAsset(filename)
-	if err != nil {
-		return nil, fmt.Errorf("failed to open file: %s, base error: %s", filename, err.Error())
-	}
-	return loadIP(geoipBytes, country)
-}
-
-func (d standardLoader) LoadIPByBytes(geoipBytes []byte, country string) ([]*router.CIDR, error) {
-	return loadIP(geoipBytes, country)
+func (d standardLoader) LoadIP(filename, country string) ([]*router.CIDR, error) {
+	return loadIP(filename, country)
 }
 
 func init() {

component/geodata/utils.go

@@ -1,9 +1,9 @@
 package geodata
 
 import (
-	"fmt"
 	"github.com/Dreamacro/clash/component/geodata/router"
 	C "github.com/Dreamacro/clash/constant"
+	"strings"
 )
 
 var geoLoaderName = "memconservative"
@@ -21,30 +21,20 @@ func SetLoader(newLoader string) {
 	geoLoaderName = newLoader
 }
 
-func Verify(name string) error {
+func Verify(name string) bool {
 	switch name {
 	case C.GeositeName:
 		_, _, err := LoadGeoSiteMatcher("CN")
-		return err
+		return err == nil
 	case C.GeoipName:
 		_, _, err := LoadGeoIPMatcher("CN")
-		return err
+		return err == nil
 	default:
-		return fmt.Errorf("not support name")
+		return false
 	}
 }
 
 func LoadGeoSiteMatcher(countryCode string) (*router.DomainMatcher, int, error) {
-	if len(countryCode) == 0 {
-		return nil, 0, fmt.Errorf("country code could not be empty")
-	}
-
-	not := false
-	if countryCode[0] == '!' {
-		not = true
-		countryCode = countryCode[1:]
-	}
-
 	geoLoader, err := GetGeoDataLoader(geoLoaderName)
 	if err != nil {
 		return nil, 0, err
@@ -60,7 +50,7 @@ func LoadGeoSiteMatcher(countryCode string) (*router.DomainMatcher, int, error)
 	matcher, err := router.NewDomainMatcher(domains)
 	mph：minimal perfect hash algorithm
 	*/
-	matcher, err := router.NewMphMatcherGroup(domains, not)
+	matcher, err := router.NewMphMatcherGroup(domains)
 	if err != nil {
 		return nil, 0, err
 	}
@@ -69,21 +59,12 @@ func LoadGeoSiteMatcher(countryCode string) (*router.DomainMatcher, int, error)
 }
 
 func LoadGeoIPMatcher(country string) (*router.GeoIPMatcher, int, error) {
-	if len(country) == 0 {
-		return nil, 0, fmt.Errorf("country code could not be empty")
-	}
 	geoLoader, err := GetGeoDataLoader(geoLoaderName)
 	if err != nil {
 		return nil, 0, err
 	}
 
-	not := false
-	if country[0] == '!' {
-		not = true
-		country = country[1:]
-	}
-
-	records, err := geoLoader.LoadGeoIP(country)
+	records, err := geoLoader.LoadGeoIP(strings.ReplaceAll(country, "!", ""))
 	if err != nil {
 		return nil, 0, err
 	}
@@ -91,7 +72,7 @@ func LoadGeoIPMatcher(country string) (*router.GeoIPMatcher, int, error) {
 	geoIP := &router.GeoIP{
 		CountryCode:  country,
 		Cidr:         records,
-		ReverseMatch: not,
+		ReverseMatch: strings.Contains(country, "!"),
 	}
 
 	matcher, err := router.NewGeoIPMatcher(geoIP)

component/http/http.go

@@ -1,64 +0,0 @@
-package http
-
-import (
-	"context"
-	"github.com/Dreamacro/clash/listener/inner"
-	"github.com/Dreamacro/clash/log"
-	"io"
-	"net"
-	"net/http"
-	URL "net/url"
-	"strings"
-	"time"
-)
-
-const (
-	UA = "Clash"
-)
-
-func HttpRequest(ctx context.Context, url, method string, header map[string][]string, body io.Reader) (*http.Response, error) {
-	method = strings.ToUpper(method)
-	urlRes, err := URL.Parse(url)
-	if err != nil {
-		return nil, err
-	}
-
-	req, err := http.NewRequest(method, urlRes.String(), body)
-	for k, v := range header {
-		for _, v := range v {
-			req.Header.Add(k, v)
-		}
-	}
-
-	if _, ok := header["User-Agent"]; !ok {
-		req.Header.Set("User-Agent", UA)
-	}
-
-	if err != nil {
-		return nil, err
-	}
-
-	if user := urlRes.User; user != nil {
-		password, _ := user.Password()
-		req.SetBasicAuth(user.Username(), password)
-	}
-
-	req = req.WithContext(ctx)
-
-	transport := &http.Transport{
-		// from http.DefaultTransport
-		MaxIdleConns:          100,
-		IdleConnTimeout:       30 * time.Second,
-		TLSHandshakeTimeout:   10 * time.Second,
-		ExpectContinueTimeout: 1 * time.Second,
-		DialContext: func(ctx context.Context, network, address string) (net.Conn, error) {
-			log.Infoln(urlRes.String())
-			conn := inner.HandleTcp(address, urlRes.Hostname())
-			return conn, nil
-		},
-	}
-
-	client := http.Client{Transport: transport}
-	return client.Do(req)
-
-}

component/js/function.go

@@ -1,69 +0,0 @@
-//go:build !no_script
-
-package js
-
-import (
-	"github.com/Dreamacro/clash/component/resolver"
-	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/log"
-	"github.com/dop251/goja"
-	"github.com/dop251/goja_nodejs/require"
-	"net/netip"
-)
-
-type Context struct {
-	runtime *goja.Runtime
-}
-
-func (c *Context) Resolve(host string, dnsType C.DnsType) []string {
-	var ips []string
-	var ipAddrs []netip.Addr
-	var err error
-	switch dnsType {
-	case C.IPv4:
-		ipAddrs, err = resolver.ResolveAllIPv4(host)
-	case C.IPv6:
-		ipAddrs, err = resolver.ResolveAllIPv6(host)
-	case C.All:
-		ipAddrs, err = resolver.ResolveAllIP(host)
-	}
-
-	if err != nil {
-		log.Errorln("Script resolve %s failed, error: %v", host, err)
-		return ips
-	}
-
-	for _, addr := range ipAddrs {
-		ips = append(ips, addr.String())
-	}
-
-	return ips
-}
-
-func newContext() require.ModuleLoader {
-	return func(runtime *goja.Runtime, object *goja.Object) {
-		ctx := Context{
-			runtime: runtime,
-		}
-
-		o := object.Get("exports").(*goja.Object)
-		o.Set("resolve", func(call goja.FunctionCall) goja.Value {
-			if len(call.Arguments) < 1 {
-				return runtime.ToValue([]string{})
-			}
-
-			host := call.Argument(0).String()
-			dnsType := C.IPv4
-			if len(call.Arguments) == 2 {
-				dnsType = int(call.Argument(1).ToInteger())
-			}
-
-			ips := ctx.Resolve(host, C.DnsType(dnsType))
-			return runtime.ToValue(ips)
-		})
-	}
-}
-
-func enable(rt *goja.Runtime) {
-	rt.Set("context", require.Require(rt, "context"))
-}

component/js/js.go

@@ -1,60 +0,0 @@
-//go:build !no_script
-
-package js
-
-import (
-	"github.com/Dreamacro/clash/log"
-	"github.com/dop251/goja"
-	"github.com/dop251/goja_nodejs/console"
-	"github.com/dop251/goja_nodejs/eventloop"
-	"github.com/dop251/goja_nodejs/require"
-)
-
-func init() {
-	logPrinter := console.RequireWithPrinter(&JsLog{})
-	require.RegisterNativeModule("console", logPrinter)
-	contextFuncLoader := newContext()
-	require.RegisterNativeModule("context", contextFuncLoader)
-}
-
-func preSetting(rt *goja.Runtime) {
-	registry := new(require.Registry)
-	registry.Enable(rt)
-
-	console.Enable(rt)
-	enable(rt)
-	eventloop.EnableConsole(true)
-}
-
-func getLoop() *eventloop.EventLoop {
-	loop := eventloop.NewEventLoop(func(loop *eventloop.EventLoop) {
-		loop.Run(func(runtime *goja.Runtime) {
-			preSetting(runtime)
-		})
-	})
-
-	return loop
-}
-
-func compiler(name, code string) (*goja.Program, error) {
-	return goja.Compile(name, code, false)
-}
-
-func run(loop *eventloop.EventLoop, program *goja.Program, args map[string]any, callback func(any, error)) {
-	loop.Run(func(runtime *goja.Runtime) {
-		for k, v := range args {
-			runtime.SetFieldNameMapper(goja.TagFieldNameMapper("json", true))
-			err := runtime.Set(k, v)
-			if err != nil {
-				log.Errorln("Args to script failed, %s", err.Error())
-			}
-		}
-
-		v, err := runtime.RunProgram(program)
-		if v == nil {
-			callback(nil, err)
-		} else {
-			callback(v.Export(), err)
-		}
-	})
-}

component/js/log.go

@@ -1,20 +0,0 @@
-//go:build !no_script
-
-package js
-
-import "github.com/Dreamacro/clash/log"
-
-type JsLog struct {
-}
-
-func (j JsLog) Log(s string) {
-	log.Infoln("[JS] %s", s)
-}
-
-func (j JsLog) Warn(s string) {
-	log.Warnln("[JS] %s", s)
-}
-
-func (j JsLog) Error(s string) {
-	log.Errorln("[JS] %s", s)
-}

component/js/script.go

@@ -1,34 +0,0 @@
-//go:build !no_script
-
-package js
-
-import (
-	"github.com/dop251/goja"
-	"sync"
-)
-
-var JS sync.Map
-var mux sync.Mutex
-
-func NewJS(name, code string) error {
-	program, err := compiler(name, code)
-	if err != nil {
-		return err
-	}
-
-	if _, ok := JS.Load(name); !ok {
-		mux.Lock()
-		defer mux.Unlock()
-		if _, ok := JS.Load(name); !ok {
-			JS.Store(name, program)
-		}
-	}
-
-	return nil
-}
-
-func Run(name string, args map[string]any, callback func(any, error)) {
-	if value, ok := JS.Load(name); ok {
-		run(getLoop(), value.(*goja.Program), args, callback)
-	}
-}

component/js/script_no_script.go

@@ -1,12 +0,0 @@
-//go:build no_script
-
-package js
-
-import "fmt"
-
-func NewJS(name, code string) error {
-	fmt.Errorf("unsupported script on the build")
-}
-
-func Run(name string, args map[string]any, callback func(any, error)) {
-}

component/process/process.go

@@ -6,14 +6,13 @@ import (
 	C "github.com/Dreamacro/clash/constant"
 	"net"
 	"net/netip"
+	"runtime"
 )
 
 var (
 	ErrInvalidNetwork     = errors.New("invalid network")
 	ErrPlatformNotSupport = errors.New("not support on this platform")
 	ErrNotFound           = errors.New("process not found")
-
-	enableFindProcess = true
 )
 
 const (
@@ -21,11 +20,7 @@ const (
 	UDP = "udp"
 )
 
-func EnableFindProcess(e bool) {
-	enableFindProcess = e
-}
-
-func FindProcessName(network string, srcIP netip.Addr, srcPort int) (int32, string, error) {
+func FindProcessName(network string, srcIP netip.Addr, srcPort int) (string, error) {
 	return findProcessName(network, srcIP, srcPort)
 }
 
@@ -38,9 +33,10 @@ func FindUid(network string, srcIP netip.Addr, srcPort int) (int32, error) {
 }
 
 func ShouldFindProcess(metadata *C.Metadata) bool {
-	if !enableFindProcess ||
-		metadata.Process != "" ||
-		metadata.ProcessPath != "" {
+	if runtime.GOOS == "android" {
+		return false
+	}
+	if metadata.Process != "" || metadata.ProcessPath != "" {
 		return false
 	}
 	for _, ip := range localIPs {

component/process/process_darwin.go

@@ -21,7 +21,7 @@ func resolveSocketByNetlink(network string, ip netip.Addr, srcPort int) (int32,
 	return 0, 0, ErrPlatformNotSupport
 }
 
-func findProcessName(network string, ip netip.Addr, port int) (int32, string, error) {
+func findProcessName(network string, ip netip.Addr, port int) (string, error) {
 	var spath string
 	switch network {
 	case TCP:
@@ -29,14 +29,14 @@ func findProcessName(network string, ip netip.Addr, port int) (int32, string, er
 	case UDP:
 		spath = "net.inet.udp.pcblist_n"
 	default:
-		return -1, "", ErrInvalidNetwork
+		return "", ErrInvalidNetwork
 	}
 
 	isIPv4 := ip.Is4()
 
 	value, err := syscall.Sysctl(spath)
 	if err != nil {
-		return -1, "", err
+		return "", err
 	}
 
 	buf := []byte(value)
@@ -81,11 +81,10 @@ func findProcessName(network string, ip netip.Addr, port int) (int32, string, er
 
 		// xsocket_n.so_last_pid
 		pid := readNativeUint32(buf[so+68 : so+72])
-		pp, err := getExecPathFromPID(pid)
-		return -1, pp, err
+		return getExecPathFromPID(pid)
 	}
 
-	return -1, "", ErrNotFound
+	return "", ErrNotFound
 }
 
 func getExecPathFromPID(pid uint32) (string, error) {

component/process/process_freebsd_amd64.go

@@ -25,7 +25,7 @@ func resolveSocketByNetlink(network string, ip netip.Addr, srcPort int) (int32,
 	return 0, 0, ErrPlatformNotSupport
 }
 
-func findProcessName(network string, ip netip.Addr, srcPort int) (int32, string, error) {
+func findProcessName(network string, ip netip.Addr, srcPort int) (string, error) {
 	once.Do(func() {
 		if err := initSearcher(); err != nil {
 			log.Errorln("Initialize PROCESS-NAME failed: %s", err.Error())
@@ -35,7 +35,7 @@ func findProcessName(network string, ip netip.Addr, srcPort int) (int32, string,
 	})
 
 	if defaultSearcher == nil {
-		return -1, "", ErrPlatformNotSupport
+		return "", ErrPlatformNotSupport
 	}
 
 	var spath string
@@ -46,22 +46,21 @@ func findProcessName(network string, ip netip.Addr, srcPort int) (int32, string,
 	case UDP:
 		spath = "net.inet.udp.pcblist"
 	default:
-		return -1, "", ErrInvalidNetwork
+		return "", ErrInvalidNetwork
 	}
 
 	value, err := syscall.Sysctl(spath)
 	if err != nil {
-		return -1, "", err
+		return "", err
 	}
 
 	buf := []byte(value)
 	pid, err := defaultSearcher.Search(buf, ip, uint16(srcPort), isTCP)
 	if err != nil {
-		return -1, "", err
+		return "", err
 	}
 
-	pp, err := getExecPathFromPID(pid)
-	return -1, pp, err
+	return getExecPathFromPID(pid)
 }
 
 func getExecPathFromPID(pid uint32) (string, error) {

component/process/process_linux.go

@@ -8,8 +8,6 @@ import (
 	"net/netip"
 	"os"
 	"path"
-	"path/filepath"
-	"runtime"
 	"strings"
 	"syscall"
 	"unicode"
@@ -34,13 +32,12 @@ const (
 	pathProc                = "/proc"
 )
 
-func findProcessName(network string, ip netip.Addr, srcPort int) (int32, string, error) {
+func findProcessName(network string, ip netip.Addr, srcPort int) (string, error) {
 	inode, uid, err := resolveSocketByNetlink(network, ip, srcPort)
 	if err != nil {
-		return -1, "", err
+		return "", err
 	}
-	pp, err := resolveProcessNameByProcSearch(inode, uid)
-	return uid, pp, err
+	return resolveProcessNameByProcSearch(inode, uid)
 }
 
 func resolveSocketByNetlink(network string, ip netip.Addr, srcPort int) (int32, int32, error) {
@@ -198,19 +195,8 @@ func resolveProcessNameByProcSearch(inode, uid int32) (string, error) {
 				continue
 			}
 
-			if runtime.GOOS == "android" {
-				if bytes.Equal(buffer[:n], socket) {
-					cmdline, err := os.ReadFile(path.Join(processPath, "cmdline"))
-					if err != nil {
-						return "", err
-					}
-
-					return splitCmdline(cmdline), nil
-				}
-			} else {
-				if bytes.Equal(buffer[:n], socket) {
-					return os.Readlink(path.Join(processPath, "exe"))
-				}
+			if bytes.Equal(buffer[:n], socket) {
+				return os.Readlink(path.Join(processPath, "exe"))
 			}
 		}
 	}
@@ -218,19 +204,6 @@ func resolveProcessNameByProcSearch(inode, uid int32) (string, error) {
 	return "", fmt.Errorf("process of uid(%d),inode(%d) not found", uid, inode)
 }
 
-func splitCmdline(cmdline []byte) string {
-	cmdline = bytes.Trim(cmdline, " ")
-
-	idx := bytes.IndexFunc(cmdline, func(r rune) bool {
-		return unicode.IsControl(r) || unicode.IsSpace(r)
-	})
-
-	if idx == -1 {
-		return filepath.Base(string(cmdline))
-	}
-	return filepath.Base(string(cmdline[:idx]))
-}
-
 func isPid(s string) bool {
 	return strings.IndexFunc(s, func(r rune) bool {
 		return !unicode.IsDigit(r)

component/process/process_other.go

@@ -4,8 +4,8 @@ package process
 
 import "net/netip"
 
-func findProcessName(network string, ip netip.Addr, srcPort int) (int32, string, error) {
-	return -1, "", ErrPlatformNotSupport
+func findProcessName(network string, ip netip.Addr, srcPort int) (string, error) {
+	return "", ErrPlatformNotSupport
 }
 
 func resolveSocketByNetlink(network string, ip netip.Addr, srcPort int) (int32, int32, error) {

component/process/process_windows.go

@@ -62,7 +62,7 @@ func initWin32API() error {
 	return nil
 }
 
-func findProcessName(network string, ip netip.Addr, srcPort int) (int32, string, error) {
+func findProcessName(network string, ip netip.Addr, srcPort int) (string, error) {
 	once.Do(func() {
 		err := initWin32API()
 		if err != nil {
@@ -86,22 +86,21 @@ func findProcessName(network string, ip netip.Addr, srcPort int) (int32, string,
 		fn = getExUDPTable
 		class = udpTablePid
 	default:
-		return -1, "", ErrInvalidNetwork
+		return "", ErrInvalidNetwork
 	}
 
 	buf, err := getTransportTable(fn, family, class)
 	if err != nil {
-		return -1, "", err
+		return "", err
 	}
 
 	s := newSearcher(family == windows.AF_INET, network == TCP)
 
 	pid, err := s.Search(buf, ip, uint16(srcPort))
 	if err != nil {
-		return -1, "", err
+		return "", err
 	}
-	pp, err := getExecPathFromPID(pid)
-	return -1, pp, err
+	return getExecPathFromPID(pid)
 }
 
 type searcher struct {

component/resolver/resolver.go

@@ -89,39 +89,24 @@ func ResolveIP(host string) (netip.Addr, error) {
 // ResolveIPv4ProxyServerHost proxies server host only
 func ResolveIPv4ProxyServerHost(host string) (netip.Addr, error) {
 	if ProxyServerHostResolver != nil {
-		if ip, err := ResolveIPv4WithResolver(host, ProxyServerHostResolver); err != nil {
-			return ResolveIPv4(host)
-		} else {
-			return ip, nil
-		}
+		return ResolveIPv4WithResolver(host, ProxyServerHostResolver)
 	}
-
 	return ResolveIPv4(host)
 }
 
 // ResolveIPv6ProxyServerHost proxies server host only
 func ResolveIPv6ProxyServerHost(host string) (netip.Addr, error) {
 	if ProxyServerHostResolver != nil {
-		if ip, err := ResolveIPv6WithResolver(host, ProxyServerHostResolver); err != nil {
-			return ResolveIPv6(host)
-		} else {
-			return ip, nil
-		}
+		return ResolveIPv6WithResolver(host, ProxyServerHostResolver)
 	}
-
 	return ResolveIPv6(host)
 }
 
 // ResolveProxyServerHost proxies server host only
 func ResolveProxyServerHost(host string) (netip.Addr, error) {
 	if ProxyServerHostResolver != nil {
-		if ip, err := ResolveIPWithResolver(host, ProxyServerHostResolver); err != nil {
-			return ResolveIP(host)
-		} else {
-			return ip, err
-		}
+		return ResolveIPWithResolver(host, ProxyServerHostResolver)
 	}
-
 	return ResolveIP(host)
 }
 

component/sniffer/dispatcher.go

@@ -2,7 +2,6 @@ package sniffer
 
 import (
 	"errors"
-	"github.com/Dreamacro/clash/constant/sniffer"
 	"net"
 	"net/netip"
 	"strconv"
@@ -20,7 +19,6 @@ import (
 var (
 	ErrorUnsupportedSniffer = errors.New("unsupported sniffer")
 	ErrorSniffFailed        = errors.New("all sniffer failed")
-	ErrNoClue               = errors.New("not enough information for making a decision")
 )
 
 var Dispatcher SnifferDispatcher
@@ -29,7 +27,7 @@ type (
 	SnifferDispatcher struct {
 		enable bool
 
-		sniffers []sniffer.Sniffer
+		sniffers []C.Sniffer
 
 		foreDomain *trie.DomainTrie[bool]
 		skipSNI    *trie.DomainTrie[bool]
@@ -86,6 +84,7 @@ func (sd *SnifferDispatcher) replaceDomain(metadata *C.Metadata, host string) {
 	metadata.Host = host
 	metadata.DNSMode = C.DNSMapping
 	resolver.InsertHostByIP(metadata.DstIP, host)
+	metadata.DstIP = netip.Addr{}
 }
 
 func (sd *SnifferDispatcher) Enable() bool {
@@ -95,16 +94,16 @@ func (sd *SnifferDispatcher) Enable() bool {
 func (sd *SnifferDispatcher) sniffDomain(conn *CN.BufferedConn, metadata *C.Metadata) (string, error) {
 	for _, sniffer := range sd.sniffers {
 		if sniffer.SupportNetwork() == C.TCP {
-			_ = conn.SetReadDeadline(time.Now().Add(3 * time.Second))
+			conn.SetReadDeadline(time.Now().Add(3 * time.Second))
 			_, err := conn.Peek(1)
-			_ = conn.SetReadDeadline(time.Time{})
+			conn.SetReadDeadline(time.Time{})
 			if err != nil {
 				_, ok := err.(*net.OpError)
 				if ok {
-					log.Errorln("[Sniffer] [%s] may not have any sent data, Consider adding skip", metadata.DstIP.String())
-					_ = conn.Close()
+					log.Errorln("[Sniffer] [%s] Maybe read timeout, Consider adding skip", metadata.DstIP.String())
+					conn.Close()
 				}
-
+				log.Errorln("[Sniffer] %v", err)
 				return "", err
 			}
 
@@ -117,13 +116,7 @@ func (sd *SnifferDispatcher) sniffDomain(conn *CN.BufferedConn, metadata *C.Meta
 
 			host, err := sniffer.SniffTCP(bytes)
 			if err != nil {
-				//log.Debugln("[Sniffer] [%s] Sniff data failed %s", sniffer.Protocol(), metadata.DstIP)
-				continue
-			}
-
-			_, err = netip.ParseAddr(host)
-			if err == nil {
-				//log.Debugln("[Sniffer] [%s] Sniff data failed %s", sniffer.Protocol(), metadata.DstIP)
+				log.Debugln("[Sniffer] [%s] Sniff data failed %s", sniffer.Protocol(), metadata.DstIP)
 				continue
 			}
 
@@ -142,7 +135,7 @@ func NewCloseSnifferDispatcher() (*SnifferDispatcher, error) {
 	return &dispatcher, nil
 }
 
-func NewSnifferDispatcher(needSniffer []sniffer.Type, forceDomain *trie.DomainTrie[bool],
+func NewSnifferDispatcher(needSniffer []C.SnifferType, forceDomain *trie.DomainTrie[bool],
 	skipSNI *trie.DomainTrie[bool], ports *[]utils.Range[uint16]) (*SnifferDispatcher, error) {
 	dispatcher := SnifferDispatcher{
 		enable:     true,
@@ -164,12 +157,10 @@ func NewSnifferDispatcher(needSniffer []sniffer.Type, forceDomain *trie.DomainTr
 	return &dispatcher, nil
 }
 
-func NewSniffer(name sniffer.Type) (sniffer.Sniffer, error) {
+func NewSniffer(name C.SnifferType) (C.Sniffer, error) {
 	switch name {
-	case sniffer.TLS:
+	case C.TLS:
 		return &TLSSniffer{}, nil
-	case sniffer.HTTP:
-		return &HTTPSniffer{}, nil
 	default:
 		return nil, ErrorUnsupportedSniffer
 	}

component/sniffer/http_sniffer.go

@@ -1,100 +0,0 @@
-package sniffer
-
-import (
-	"bytes"
-	"errors"
-	C "github.com/Dreamacro/clash/constant"
-	"net"
-	"strings"
-)
-
-var (
-	// refer to https://pkg.go.dev/net/http@master#pkg-constants
-	methods          = [...]string{"get", "post", "head", "put", "delete", "options", "connect", "patch", "trace"}
-	errNotHTTPMethod = errors.New("not an HTTP method")
-)
-
-type version byte
-
-const (
-	HTTP1 version = iota
-	HTTP2
-)
-
-type HTTPSniffer struct {
-	version version
-	host    string
-}
-
-func (http *HTTPSniffer) Protocol() string {
-	switch http.version {
-	case HTTP1:
-		return "http1"
-	case HTTP2:
-		return "http2"
-	default:
-		return "unknown"
-	}
-}
-
-func (http *HTTPSniffer) SupportNetwork() C.NetWork {
-	return C.TCP
-}
-
-func (http *HTTPSniffer) SniffTCP(bytes []byte) (string, error) {
-	domain, err := SniffHTTP(bytes)
-	if err == nil {
-		return *domain, nil
-	} else {
-		return "", err
-	}
-}
-
-func beginWithHTTPMethod(b []byte) error {
-	for _, m := range &methods {
-		if len(b) >= len(m) && strings.EqualFold(string(b[:len(m)]), m) {
-			return nil
-		}
-
-		if len(b) < len(m) {
-			return ErrNoClue
-		}
-	}
-	return errNotHTTPMethod
-}
-
-func SniffHTTP(b []byte) (*string, error) {
-	if err := beginWithHTTPMethod(b); err != nil {
-		return nil, err
-	}
-
-	_ = &HTTPSniffer{
-		version: HTTP1,
-	}
-
-	headers := bytes.Split(b, []byte{'\n'})
-	for i := 1; i < len(headers); i++ {
-		header := headers[i]
-		if len(header) == 0 {
-			break
-		}
-		parts := bytes.SplitN(header, []byte{':'}, 2)
-		if len(parts) != 2 {
-			continue
-		}
-		key := strings.ToLower(string(parts[0]))
-		if key == "host" {
-			rawHost := strings.ToLower(string(bytes.TrimSpace(parts[1])))
-			host, _, err := net.SplitHostPort(rawHost)
-			if err != nil {
-				if addrError, ok := err.(*net.AddrError); ok && strings.Contains(addrError.Err, "missing port") {
-					host = rawHost
-				} else {
-					return nil, err
-				}
-			}
-			return &host, nil
-		}
-	}
-	return nil, ErrNoClue
-}

component/sniffer/quic_sniffer.go

@@ -1,3 +0,0 @@
-package sniffer
-
-//TODO

component/sniffer/tls_sniffer.go

@@ -11,6 +11,7 @@ import (
 var (
 	errNotTLS         = errors.New("not TLS header")
 	errNotClientHello = errors.New("not client hello")
+	ErrNoClue         = errors.New("not enough information for making a decision")
 )
 
 type TLSSniffer struct {

config/config.go

@@ -4,7 +4,6 @@ import (
 	"container/list"
 	"errors"
 	"fmt"
-	"github.com/Dreamacro/clash/constant/sniffer"
 	"github.com/Dreamacro/clash/listener/tun/ipstack/commons"
 	"net"
 	"net/netip"
@@ -31,7 +30,6 @@ import (
 	"github.com/Dreamacro/clash/component/trie"
 	C "github.com/Dreamacro/clash/constant"
 	providerTypes "github.com/Dreamacro/clash/constant/provider"
-	snifferTypes "github.com/Dreamacro/clash/constant/sniffer"
 	"github.com/Dreamacro/clash/dns"
 	"github.com/Dreamacro/clash/log"
 	T "github.com/Dreamacro/clash/tunnel"
@@ -47,14 +45,11 @@ type General struct {
 	UnifiedDelay  bool
 	LogLevel      log.LogLevel `json:"log-level"`
 	IPv6          bool         `json:"ipv6"`
-	Interface     string       `json:"interface-name"`
+	Interface     string       `json:"-"`
 	RoutingMark   int          `json:"-"`
 	GeodataMode   bool         `json:"geodata-mode"`
 	GeodataLoader string       `json:"geodata-loader"`
 	TCPConcurrent bool         `json:"tcp-concurrent"`
-	EnableProcess bool         `json:"enable-process"`
-	Tun           Tun          `json:"tun"`
-	Sniffing      bool         `json:"sniffing"`
 }
 
 // Inbound config
@@ -101,6 +96,12 @@ type FallbackFilter struct {
 	GeoSite   []*router.DomainMatcher `yaml:"geosite"`
 }
 
+var (
+	GroupsList             = list.New()
+	ProxiesList            = list.New()
+	ParsingProxiesCallback func(groupsList *list.List, proxiesList *list.List)
+)
+
 // Profile config
 type Profile struct {
 	StoreSelected bool `yaml:"store-selected"`
@@ -115,7 +116,6 @@ type Tun struct {
 	DNSHijack           []netip.AddrPort `yaml:"dns-hijack" json:"dns-hijack"`
 	AutoRoute           bool             `yaml:"auto-route" json:"auto-route"`
 	AutoDetectInterface bool             `yaml:"auto-detect-interface" json:"auto-detect-interface"`
-	TunAddressPrefix    netip.Prefix     `yaml:"-" json:"-"`
 }
 
 // IPTables config
@@ -127,10 +127,11 @@ type IPTables struct {
 
 type Sniffer struct {
 	Enable      bool
-	Sniffers    []sniffer.Type
+	Force       bool
+	Sniffers    []C.SnifferType
 	Reverses    *trie.DomainTrie[bool]
 	ForceDomain *trie.DomainTrie[bool]
-	SkipDomain  *trie.DomainTrie[bool]
+	SkipSNI     *trie.DomainTrie[bool]
 	Ports       *[]utils.Range[uint16]
 }
 
@@ -208,9 +209,8 @@ type RawConfig struct {
 	GeodataMode        bool         `yaml:"geodata-mode"`
 	GeodataLoader      string       `yaml:"geodata-loader"`
 	TCPConcurrent      bool         `yaml:"tcp-concurrent" json:"tcp-concurrent"`
-	EnableProcess      bool         `yaml:"enable-process" json:"enable-process"`
 
-	Sniffer       RawSniffer                `yaml:"sniffer"`
+	Sniffer       SnifferRaw                `yaml:"sniffer"`
 	ProxyProvider map[string]map[string]any `yaml:"proxy-providers"`
 	RuleProvider  map[string]map[string]any `yaml:"rule-providers"`
 	Hosts         map[string]string         `yaml:"hosts"`
@@ -219,23 +219,18 @@ type RawConfig struct {
 	IPTables      IPTables                  `yaml:"iptables"`
 	Experimental  Experimental              `yaml:"experimental"`
 	Profile       Profile                   `yaml:"profile"`
-	GeoXUrl       RawGeoXUrl                `yaml:"geox-url"`
 	Proxy         []map[string]any          `yaml:"proxies"`
 	ProxyGroup    []map[string]any          `yaml:"proxy-groups"`
 	Rule          []string                  `yaml:"rules"`
 }
 
-type RawGeoXUrl struct {
-	GeoIp   string `yaml:"geoip" json:"geoip"`
-	Mmdb    string `yaml:"mmdb" json:"mmdb"`
-	GeoSite string `yaml:"geosite" json:"geosite"`
-}
-
-type RawSniffer struct {
+type SnifferRaw struct {
 	Enable      bool     `yaml:"enable" json:"enable"`
 	Sniffing    []string `yaml:"sniffing" json:"sniffing"`
+	Force       bool     `yaml:"force" json:"force"`
+	Reverse     []string `yaml:"reverses" json:"reverses"`
 	ForceDomain []string `yaml:"force-domain" json:"force-domain"`
-	SkipDomain  []string `yaml:"skip-domain" json:"skip-domain"`
+	SkipSNI     []string `yaml:"skip-sni" json:"skip-sni"`
 	Ports       []string `yaml:"port-whitelist" json:"port-whitelist"`
 }
 
@@ -265,14 +260,13 @@ func UnmarshalRawConfig(buf []byte) (*RawConfig, error) {
 		Proxy:          []map[string]any{},
 		ProxyGroup:     []map[string]any{},
 		TCPConcurrent:  false,
-		EnableProcess:  true,
 		Tun: RawTun{
 			Enable:              false,
 			Device:              "",
+			AutoDetectInterface: true,
 			Stack:               C.TunGvisor,
 			DNSHijack:           []string{"0.0.0.0:53"}, // default hijack all dns query
-			AutoRoute:           false,
-			AutoDetectInterface: false,
+			AutoRoute:           true,
 		},
 		IPTables: IPTables{
 			Enable:           false,
@@ -306,21 +300,18 @@ func UnmarshalRawConfig(buf []byte) (*RawConfig, error) {
 				"www.msftconnecttest.com",
 			},
 		},
-		Sniffer: RawSniffer{
+		Sniffer: SnifferRaw{
 			Enable:      false,
+			Force:       false,
 			Sniffing:    []string{},
+			Reverse:     []string{},
 			ForceDomain: []string{},
-			SkipDomain:  []string{},
+			SkipSNI:     []string{},
 			Ports:       []string{},
 		},
 		Profile: Profile{
 			StoreSelected: true,
 		},
-		GeoXUrl: RawGeoXUrl{
-			GeoIp:   "https://ghproxy.com/https://raw.githubusercontent.com/Loyalsoldier/v2ray-rules-dat/release/geoip.dat",
-			Mmdb:    "https://ghproxy.com/https://raw.githubusercontent.com/Loyalsoldier/geoip/release/Country.mmdb",
-			GeoSite: "https://ghproxy.com/https://raw.githubusercontent.com/Loyalsoldier/v2ray-rules-dat/release/geosite.dat",
-		},
 	}
 
 	if err := yaml.Unmarshal(buf, rawCfg); err != nil {
@@ -344,6 +335,12 @@ func ParseRawConfig(rawCfg *RawConfig) (*Config, error) {
 	}
 	config.General = general
 
+	tunCfg, err := parseTun(rawCfg.Tun, config.General)
+	if err != nil {
+		return nil, err
+	}
+	config.Tun = tunCfg
+
 	dialer.DefaultInterface.Store(config.General.Interface)
 
 	proxies, providers, err := parseProxies(rawCfg)
@@ -372,12 +369,6 @@ func ParseRawConfig(rawCfg *RawConfig) (*Config, error) {
 	}
 	config.DNS = dnsCfg
 
-	tunCfg, err := parseTun(rawCfg.Tun, config.General, dnsCfg)
-	if err != nil {
-		return nil, err
-	}
-	config.Tun = tunCfg
-
 	config.Users = parseAuthentication(rawCfg.Authentication)
 
 	config.Sniffer, err = parseSniffer(rawCfg.Sniffer)
@@ -426,7 +417,6 @@ func parseGeneral(cfg *RawConfig) (*General, error) {
 		GeodataMode:   cfg.GeodataMode,
 		GeodataLoader: cfg.GeodataLoader,
 		TCPConcurrent: cfg.TCPConcurrent,
-		EnableProcess: cfg.EnableProcess,
 	}, nil
 }
 
@@ -438,8 +428,8 @@ func parseProxies(cfg *RawConfig) (proxies map[string]C.Proxy, providersMap map[
 	providersConfig := cfg.ProxyProvider
 
 	var proxyList []string
-	proxiesList := list.New()
-	groupsList := list.New()
+	_proxiesList := list.New()
+	_groupsList := list.New()
 
 	proxies["DIRECT"] = adapter.NewProxy(outbound.NewDirect())
 	proxies["REJECT"] = adapter.NewProxy(outbound.NewReject())
@@ -459,7 +449,7 @@ func parseProxies(cfg *RawConfig) (proxies map[string]C.Proxy, providersMap map[
 		}
 		proxies[proxy.Name()] = proxy
 		proxyList = append(proxyList, proxy.Name())
-		proxiesList.PushBack(mapping)
+		_proxiesList.PushBack(mapping)
 	}
 
 	// keep the original order of ProxyGroups in config file
@@ -469,7 +459,7 @@ func parseProxies(cfg *RawConfig) (proxies map[string]C.Proxy, providersMap map[
 			return nil, nil, fmt.Errorf("proxy group %d: missing name", idx)
 		}
 		proxyList = append(proxyList, groupName)
-		groupsList.PushBack(mapping)
+		_groupsList.PushBack(mapping)
 	}
 
 	// check if any loop exists and sort the ProxyGroups
@@ -524,7 +514,12 @@ func parseProxies(cfg *RawConfig) (proxies map[string]C.Proxy, providersMap map[
 		[]providerTypes.ProxyProvider{pd},
 	)
 	proxies["GLOBAL"] = adapter.NewProxy(global)
-
+	ProxiesList = _proxiesList
+	GroupsList = _groupsList
+	if ParsingProxiesCallback != nil {
+		// refresh tray menu
+		go ParsingProxiesCallback(GroupsList, ProxiesList)
+	}
 	return proxies, providersMap, nil
 }
 
@@ -544,6 +539,7 @@ func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, map[strin
 
 	var rules []C.Rule
 	rulesConfig := cfg.Rule
+	mode := cfg.Mode
 
 	// parse rules
 	for idx, line := range rulesConfig {
@@ -555,6 +551,10 @@ func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, map[strin
 			ruleName = strings.ToUpper(rule[0])
 		)
 
+		if mode == T.Script && ruleName != "GEOSITE" {
+			continue
+		}
+
 		l := len(rule)
 
 		if ruleName == "NOT" || ruleName == "OR" || ruleName == "AND" {
@@ -883,7 +883,7 @@ func parseAuthentication(rawRecords []string) []auth.AuthUser {
 	return users
 }
 
-func parseTun(rawTun RawTun, general *General, dnsCfg *DNS) (*Tun, error) {
+func parseTun(rawTun RawTun, general *General) (*Tun, error) {
 	if rawTun.Enable && rawTun.AutoDetectInterface {
 		autoDetectInterfaceName, err := commons.GetAutoDetectInterface()
 		if err != nil {
@@ -910,13 +910,6 @@ func parseTun(rawTun RawTun, general *General, dnsCfg *DNS) (*Tun, error) {
 		dnsHijack = append(dnsHijack, addrPort)
 	}
 
-	var tunAddressPrefix netip.Prefix
-	if dnsCfg.FakeIPRange != nil {
-		tunAddressPrefix = *dnsCfg.FakeIPRange.IPNet()
-	} else {
-		tunAddressPrefix = netip.MustParsePrefix("198.18.0.1/16")
-	}
-
 	return &Tun{
 		Enable:              rawTun.Enable,
 		Device:              rawTun.Device,
@@ -924,13 +917,13 @@ func parseTun(rawTun RawTun, general *General, dnsCfg *DNS) (*Tun, error) {
 		DNSHijack:           dnsHijack,
 		AutoRoute:           rawTun.AutoRoute,
 		AutoDetectInterface: rawTun.AutoDetectInterface,
-		TunAddressPrefix:    tunAddressPrefix,
 	}, nil
 }
 
-func parseSniffer(snifferRaw RawSniffer) (*Sniffer, error) {
+func parseSniffer(snifferRaw SnifferRaw) (*Sniffer, error) {
 	sniffer := &Sniffer{
 		Enable: snifferRaw.Enable,
+		Force:  snifferRaw.Force,
 	}
 
 	var ports []utils.Range[uint16]
@@ -961,11 +954,11 @@ func parseSniffer(snifferRaw RawSniffer) (*Sniffer, error) {
 
 	sniffer.Ports = &ports
 
-	loadSniffer := make(map[snifferTypes.Type]struct{})
+	loadSniffer := make(map[C.SnifferType]struct{})
 
 	for _, snifferName := range snifferRaw.Sniffing {
 		find := false
-		for _, snifferType := range snifferTypes.List {
+		for _, snifferType := range C.SnifferList {
 			if snifferType.String() == strings.ToUpper(snifferName) {
 				find = true
 				loadSniffer[snifferType] = struct{}{}
@@ -980,6 +973,7 @@ func parseSniffer(snifferRaw RawSniffer) (*Sniffer, error) {
 	for st := range loadSniffer {
 		sniffer.Sniffers = append(sniffer.Sniffers, st)
 	}
+
 	sniffer.ForceDomain = trie.New[bool]()
 	for _, domain := range snifferRaw.ForceDomain {
 		err := sniffer.ForceDomain.Insert(domain, true)
@@ -988,13 +982,35 @@ func parseSniffer(snifferRaw RawSniffer) (*Sniffer, error) {
 		}
 	}
 
-	sniffer.SkipDomain = trie.New[bool]()
-	for _, domain := range snifferRaw.SkipDomain {
-		err := sniffer.SkipDomain.Insert(domain, true)
+	sniffer.SkipSNI = trie.New[bool]()
+	for _, domain := range snifferRaw.SkipSNI {
+		err := sniffer.SkipSNI.Insert(domain, true)
 		if err != nil {
 			return nil, fmt.Errorf("error domian[%s] in force-domain, error:%v", domain, err)
 		}
 	}
 
+	// Compatibility, remove it when release
+	if strings.Contains(C.Version, "alpha") || strings.Contains(C.Version, "develop") || strings.Contains(C.Version, "1.10.0") {
+		log.Warnln("Sniffer param force and reverses deprecated, will be removed in the release version, see https://github.com/MetaCubeX/Clash.Meta/commit/48a01adb7a4f38974b9d9639f931d0d245aebf28")
+		if snifferRaw.Force {
+			// match all domain
+			sniffer.ForceDomain.Insert("+", true)
+			for _, domain := range snifferRaw.Reverse {
+				err := sniffer.SkipSNI.Insert(domain, true)
+				if err != nil {
+					return nil, fmt.Errorf("error domian[%s], error:%v", domain, err)
+				}
+			}
+		} else {
+			for _, domain := range snifferRaw.Reverse {
+				err := sniffer.ForceDomain.Insert(domain, true)
+				if err != nil {
+					return nil, fmt.Errorf("error domian[%s], error:%v", domain, err)
+				}
+			}
+		}
+	}
+
 	return sniffer, nil
 }

config/initial.go

@@ -15,7 +15,7 @@ import (
 var initMode = true
 
 func downloadMMDB(path string) (err error) {
-	resp, err := http.Get(C.MmdbUrl)
+	resp, err := http.Get("https://raw.githubusercontents.com/Loyalsoldier/geoip/release/Country.mmdb")
 	if err != nil {
 		return
 	}
@@ -32,7 +32,7 @@ func downloadMMDB(path string) (err error) {
 }
 
 func downloadGeoIP(path string) (err error) {
-	resp, err := http.Get(C.GeoIpUrl)
+	resp, err := http.Get("https://raw.githubusercontents.com/Loyalsoldier/v2ray-rules-dat/release/geoip.dat")
 	if err != nil {
 		return
 	}
@@ -49,7 +49,7 @@ func downloadGeoIP(path string) (err error) {
 }
 
 func downloadGeoSite(path string) (err error) {
-	resp, err := http.Get(C.GeoSiteUrl)
+	resp, err := http.Get("https://raw.githubusercontents.com/Loyalsoldier/v2ray-rules-dat/release/geosite.dat")
 	if err != nil {
 		return
 	}
@@ -74,8 +74,8 @@ func initGeoSite() error {
 		log.Infoln("Download GeoSite.dat finish")
 	}
 	if initMode {
-		if err := geodata.Verify(C.GeositeName); err != nil {
-			log.Warnln("GeoSite.dat invalid, remove and download: %s", err)
+		if !geodata.Verify(C.GeositeName) {
+			log.Warnln("GeoSite.dat invalid, remove and download")
 			if err := os.Remove(C.Path.GeoSite()); err != nil {
 				return fmt.Errorf("can't remove invalid GeoSite.dat: %s", err.Error())
 			}
@@ -97,8 +97,8 @@ func initGeoIP() error {
 			log.Infoln("Download GeoIP.dat finish")
 		}
 
-		if err := geodata.Verify(C.GeoipName); err != nil {
-			log.Warnln("GeoIP.dat invalid, remove and download: %s", err)
+		if !geodata.Verify(C.GeoipName) {
+			log.Warnln("GeoIP.dat invalid, remove and download")
 			if err := os.Remove(C.Path.GeoIP()); err != nil {
 				return fmt.Errorf("can't remove invalid GeoIP.dat: %s", err.Error())
 			}
@@ -159,9 +159,6 @@ func Init(dir string) error {
 	if !C.GeodataMode {
 		C.GeodataMode = rawCfg.GeodataMode
 	}
-	C.GeoIpUrl = rawCfg.GeoXUrl.GeoIp
-	C.GeoSiteUrl = rawCfg.GeoXUrl.GeoSite
-	C.MmdbUrl = rawCfg.GeoXUrl.Mmdb
 	// initial GeoIP
 	if err := initGeoIP(); err != nil {
 		return fmt.Errorf("can't initial GeoIP: %w", err)

config/updateGeo.go

@@ -1,80 +0,0 @@
-package config
-
-import (
-	"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/ioutil"
-	"net/http"
-	"runtime"
-)
-
-func UpdateGeoDatabases() error {
-	defer runtime.GC()
-	geoLoader, err := geodata.GetGeoDataLoader("standard")
-	if err != nil {
-		return err
-	}
-
-	if C.GeodataMode {
-		data, err := downloadForBytes(C.GeoIpUrl)
-		if err != nil {
-			return fmt.Errorf("can't download GeoIP database file: %w", err)
-		}
-
-		if _, err = geoLoader.LoadIPByBytes(data, "cn"); err != nil {
-			return fmt.Errorf("invalid GeoIP database file: %s", err)
-		}
-
-		if saveFile(data, C.Path.GeoIP()) != nil {
-			return fmt.Errorf("can't save GeoIP database file: %w", err)
-		}
-
-	} else {
-		data, err := downloadForBytes(C.MmdbUrl)
-		if err != nil {
-			return fmt.Errorf("can't download MMDB database file: %w", err)
-		}
-
-		instance, err := geoip2.FromBytes(data)
-		if err != nil {
-			return fmt.Errorf("invalid MMDB database file: %s", err)
-		}
-		_ = instance.Close()
-
-		if saveFile(data, C.Path.MMDB()) != nil {
-			return fmt.Errorf("can't save MMDB database file: %w", err)
-		}
-	}
-
-	data, err := downloadForBytes(C.GeoSiteUrl)
-	if err != nil {
-		return fmt.Errorf("can't download GeoSite database file: %w", err)
-	}
-
-	if _, err = geoLoader.LoadSiteByBytes(data, "cn"); err != nil {
-		return fmt.Errorf("invalid GeoSite database file: %s", err)
-	}
-
-	if saveFile(data, C.Path.GeoSite()) != nil {
-		return fmt.Errorf("can't save GeoSite database file: %w", err)
-	}
-
-	return nil
-}
-
-func downloadForBytes(url string) ([]byte, error) {
-	resp, err := http.Get(url)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	return ioutil.ReadAll(resp.Body)
-}
-
-func saveFile(bytes []byte, path string) error {
-	return ioutil.WriteFile(path, bytes, 0o644)
-}

constant/adapters.go

@@ -41,7 +41,6 @@ const (
 type Connection interface {
 	Chains() Chain
 	AppendToChains(adapter ProxyAdapter)
-	RemoteDestination() string
 }
 
 type Chain []string
@@ -108,11 +107,6 @@ type ProxyAdapter interface {
 	Unwrap(metadata *Metadata) Proxy
 }
 
-type Group interface {
-	URLTest(ctx context.Context, url string) (mp map[string]uint16, err error)
-	GetProxies(touch bool) []Proxy
-}
-
 type DelayHistory struct {
 	Time  time.Time `json:"time"`
 	Delay uint16    `json:"delay"`

constant/features/no_doq.go

@@ -1,7 +0,0 @@
-//go:build no_doq
-
-package features
-
-func init() {
-	TAGS = append(TAGS, "no_doq")
-}

constant/features/no_gvisor.go

@@ -1,7 +0,0 @@
-//go:build no_gvisor
-
-package features
-
-func init() {
-	TAGS = append(TAGS, "no_gvisor")
-}

constant/features/tags.go

@@ -1,3 +0,0 @@
-package features
-
-var TAGS = make([]string, 0, 0)

constant/geodata.go

@@ -1,8 +1,3 @@
 package constant
 
-var (
-	GeodataMode bool
-	GeoIpUrl    string
-	MmdbUrl     string
-	GeoSiteUrl  string
-)
+var GeodataMode bool

constant/metadata.go

@@ -19,7 +19,7 @@ const (
 	ALLNet
 
 	HTTP Type = iota
-	HTTPS
+	HTTPCONNECT
 	SOCKS4
 	SOCKS5
 	REDIR
@@ -49,8 +49,8 @@ func (t Type) String() string {
 	switch t {
 	case HTTP:
 		return "HTTP"
-	case HTTPS:
-		return "HTTPS"
+	case HTTPCONNECT:
+		return "HTTP Connect"
 	case SOCKS4:
 		return "Socks4"
 	case SOCKS5:
@@ -68,31 +68,6 @@ func (t Type) String() string {
 	}
 }
 
-func ParseType(t string) (*Type, error) {
-	var res Type
-	switch t {
-	case "HTTP":
-		res = HTTP
-	case "HTTPS":
-		res = HTTPS
-	case "SOCKS4":
-		res = SOCKS4
-	case "SOCKS5":
-		res = SOCKS5
-	case "REDIR":
-		res = REDIR
-	case "TPROXY":
-		res = TPROXY
-	case "TUN":
-		res = TUN
-	case "INNER":
-		res = INNER
-	default:
-		return nil, fmt.Errorf("unknown type: %s", t)
-	}
-	return &res, nil
-}
-
 func (t Type) MarshalJSON() ([]byte, error) {
 	return json.Marshal(t.String())
 }
@@ -111,7 +86,6 @@ type Metadata struct {
 	Uid         *int32     `json:"uid"`
 	Process     string     `json:"process"`
 	ProcessPath string     `json:"processPath"`
-	RemoteDst   string     `json:"remoteDestination"`
 }
 
 func (m *Metadata) RemoteAddress() string {
@@ -130,7 +104,7 @@ func (m *Metadata) SourceDetail() string {
 	if m.Process != "" && m.Uid != nil {
 		return fmt.Sprintf("%s(%s, uid=%d)", m.SourceAddress(), m.Process, *m.Uid)
 	} else if m.Uid != nil {
-		return fmt.Sprintf("%s(uid=%d)", m.SourceAddress(), *m.Uid)
+		return fmt.Sprintf("%s(%d)", m.SourceAddress(), *m.Uid)
 	} else if m.Process != "" {
 		return fmt.Sprintf("%s(%s)", m.SourceAddress(), m.Process)
 	} else {

constant/path.go

@@ -29,6 +29,7 @@ var Path = func() *path {
 type path struct {
 	homeDir    string
 	configFile string
+	scriptDir  string
 }
 
 // SetHomeDir is used to set the configuration path
@@ -122,6 +123,23 @@ func (p *path) GeoSite() string {
 	return P.Join(p.homeDir, "GeoSite.dat")
 }
 
+func (p *path) ScriptDir() string {
+	if len(p.scriptDir) != 0 {
+		return p.scriptDir
+	}
+	if dir, err := os.MkdirTemp("", Name+"-"); err == nil {
+		p.scriptDir = dir
+	} else {
+		p.scriptDir = P.Join(os.TempDir(), Name)
+		_ = os.MkdirAll(p.scriptDir, 0o644)
+	}
+	return p.scriptDir
+}
+
+func (p *path) Script() string {
+	return P.Join(p.ScriptDir(), "clash_script.py")
+}
+
 func (p *path) GetAssetLocation(file string) string {
 	return P.Join(p.homeDir, file)
 }

constant/provider/interface.go

@@ -1,7 +1,7 @@
 package provider
 
 import (
-	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/constant"
 )
 
 // Vehicle Type
@@ -65,10 +65,10 @@ type Provider interface {
 // ProxyProvider interface
 type ProxyProvider interface {
 	Provider
-	Proxies() []C.Proxy
+	Proxies() []constant.Proxy
 	// ProxiesWithTouch is used to inform the provider that the proxy is actually being used while getting the list of proxies.
 	// Commonly used in DialContext and DialPacketConn
-	ProxiesWithTouch() []C.Proxy
+	ProxiesWithTouch() []constant.Proxy
 	HealthCheck()
 	Version() uint
 }
@@ -100,7 +100,7 @@ func (rt RuleType) String() string {
 type RuleProvider interface {
 	Provider
 	Behavior() RuleType
-	Match(*C.Metadata) bool
+	Match(*constant.Metadata) bool
 	ShouldResolveIP() bool
-	AsRule(adaptor string) C.Rule
+	AsRule(adaptor string) constant.Rule
 }

constant/rule.go

@@ -9,17 +9,14 @@ const (
 	GEOIP
 	IPCIDR
 	SrcIPCIDR
-	IPSuffix
-	SrcIPSuffix
 	SrcPort
 	DstPort
 	Process
-	Script
 	ProcessPath
+	Script
 	RuleSet
 	Network
 	Uid
-	INTYPE
 	MATCH
 	AND
 	OR
@@ -44,10 +41,6 @@ func (rt RuleType) String() string {
 		return "IPCIDR"
 	case SrcIPCIDR:
 		return "SrcIPCIDR"
-	case IPSuffix:
-		return "IPSuffix"
-	case SrcIPSuffix:
-		return "SrcIPSuffix"
 	case SrcPort:
 		return "SrcPort"
 	case DstPort:
@@ -56,18 +49,16 @@ func (rt RuleType) String() string {
 		return "Process"
 	case ProcessPath:
 		return "ProcessPath"
+	case Script:
+		return "Script"
 	case MATCH:
 		return "Match"
 	case RuleSet:
 		return "RuleSet"
 	case Network:
 		return "Network"
-	case Script:
-		return "Script"
 	case Uid:
 		return "Uid"
-	case INTYPE:
-		return "InType"
 	case AND:
 		return "AND"
 	case OR:

constant/rule_extra.go

@@ -46,11 +46,3 @@ func (re *RuleExtra) NotMatchProcessName(processName string) bool {
 type RuleGeoSite interface {
 	GetDomainMatcher() *router.DomainMatcher
 }
-
-type RuleGeoIP interface {
-	GetIPMatcher() *router.GeoIPMatcher
-}
-
-type RuleGroup interface {
-	GetRecodeSize() int
-}

constant/script.go

@@ -1,27 +0,0 @@
-package constant
-
-type JSRuleMetadata struct {
-	Type        string `json:"type"`
-	Network     string `json:"network"`
-	Host        string `json:"host"`
-	SrcIP       string `json:"srcIP"`
-	DstIP       string `json:"dstIP"`
-	SrcPort     string `json:"srcPort"`
-	DstPort     string `json:"dstPort"`
-	Uid         *int32 `json:"uid"`
-	Process     string `json:"process"`
-	ProcessPath string `json:"processPath"`
-}
-
-type DnsType int
-
-const (
-	IPv4 = 1 << iota
-	IPv6
-	All
-)
-
-type JSFunction interface {
-	//Resolve host to ip  by Clash DNS
-	Resolve(host string, resolveType DnsType) []string
-}

constant/sniffer.go

@@ -0,0 +1,26 @@
+package constant
+
+type Sniffer interface {
+	SupportNetwork() NetWork
+	SniffTCP(bytes []byte) (string, error)
+	Protocol() string
+}
+
+const (
+	TLS SnifferType = iota
+)
+
+var (
+	SnifferList = []SnifferType{TLS}
+)
+
+type SnifferType int
+
+func (rt SnifferType) String() string {
+	switch rt {
+	case TLS:
+		return "TLS"
+	default:
+		return "Unknown"
+	}
+}

constant/sniffer/sniffer.go

@@ -1,31 +0,0 @@
-package sniffer
-
-import "github.com/Dreamacro/clash/constant"
-
-type Sniffer interface {
-	SupportNetwork() constant.NetWork
-	SniffTCP(bytes []byte) (string, error)
-	Protocol() string
-}
-
-const (
-	TLS Type = iota
-	HTTP
-)
-
-var (
-	List = []Type{TLS, HTTP}
-)
-
-type Type int
-
-func (rt Type) String() string {
-	switch rt {
-	case TLS:
-		return "TLS"
-	case HTTP:
-		return "HTTP"
-	default:
-		return "Unknown"
-	}
-}

dns/doq.go

@@ -138,8 +138,6 @@ func (dc *quicClient) openSession() (quic.Connection, error) {
 	quicConfig := &quic.Config{
 		ConnectionIDLength:   12,
 		HandshakeIdleTimeout: time.Second * 8,
-		MaxIncomingStreams:   4,
-		MaxIdleTimeout:       time.Second * 45,
 	}
 
 	log.Debugln("opening session to %s", dc.addr)
@@ -177,7 +175,7 @@ func (dc *quicClient) openSession() (quic.Connection, error) {
 			return nil, fmt.Errorf("quio create packet failed")
 		}
 
-		udp = wrapConn
+		udp = wrapConn.PacketConn
 	}
 
 	session, err := quic.Dial(udp, &udpAddr, host, tlsConfig, quicConfig)

dns/middleware.go

@@ -164,7 +164,6 @@ func withResolver(resolver *Resolver) handler {
 		msg.SetRcode(r, msg.Rcode)
 		msg.Authoritative = true
 
-		log.Debugln("[DNS] %s --> %s", msgToDomain(r), msgToIP(msg))
 		return msg, nil
 	}
 }

dns/patch.go

@@ -1,16 +0,0 @@
-package dns
-
-import D "github.com/miekg/dns"
-
-type LocalServer struct {
-	handler handler
-}
-
-// ServeMsg implement resolver.LocalServer ResolveMsg
-func (s *LocalServer) ServeMsg(msg *D.Msg) (*D.Msg, error) {
-	return handlerWithContext(s.handler, msg)
-}
-
-func NewLocalServer(resolver *Resolver, mapper *ResolverEnhancer) *LocalServer {
-	return &LocalServer{handler: NewHandler(resolver, mapper)}
-}

dns/resolver.go

@@ -7,6 +7,7 @@ import (
 	"go.uber.org/atomic"
 	"math/rand"
 	"net/netip"
+	"strings"
 	"time"
 
 	"github.com/Dreamacro/clash/common/cache"
@@ -82,16 +83,12 @@ func (r *Resolver) ResolveAllIP(host string) (ips []netip.Addr, err error) {
 
 	ips, err = r.resolveIP(host, D.TypeA)
 
-	select {
-	case ipv6s, open := <-ch:
-		if !open && err != nil {
-			return nil, resolver.ErrIPNotFound
-		}
-		ips = append(ips, ipv6s...)
-	case <-time.After(1 * time.Millisecond):
-		// wait ipv6 result
+	ipv6s, open := <-ch
+	if !open && err != nil {
+		return nil, resolver.ErrIPNotFound
 	}
 
+	ips = append(ips, ipv6s...)
 	return ips, nil
 }
 
@@ -235,7 +232,7 @@ func (r *Resolver) matchPolicy(m *D.Msg) []dnsClient {
 		return nil
 	}
 
-	domain := msgToDomain(m)
+	domain := r.msgToDomain(m)
 	if domain == "" {
 		return nil
 	}
@@ -254,7 +251,7 @@ func (r *Resolver) shouldOnlyQueryFallback(m *D.Msg) bool {
 		return false
 	}
 
-	domain := msgToDomain(m)
+	domain := r.msgToDomain(m)
 
 	if domain == "" {
 		return false
@@ -335,6 +332,14 @@ func (r *Resolver) resolveIP(host string, dnsType uint16) (ips []netip.Addr, err
 	return
 }
 
+func (r *Resolver) msgToDomain(msg *D.Msg) string {
+	if len(msg.Question) > 0 {
+		return strings.TrimRight(msg.Question[0].Name, ".")
+	}
+
+	return ""
+}
+
 func (r *Resolver) asyncExchange(ctx context.Context, client []dnsClient, msg *D.Msg) <-chan *result {
 	ch := make(chan *result, 1)
 	go func() {

dns/util.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"net"
 	"net/netip"
-	"strings"
 	"time"
 
 	"github.com/Dreamacro/clash/common/cache"
@@ -117,14 +116,6 @@ func msgToIP(msg *D.Msg) []netip.Addr {
 	return ips
 }
 
-func msgToDomain(msg *D.Msg) string {
-	if len(msg.Question) > 0 {
-		return strings.TrimRight(msg.Question[0].Name, ".")
-	}
-
-	return ""
-}
-
 type wrapPacketConn struct {
 	net.PacketConn
 	rAddr net.Addr

go.mod

@@ -4,45 +4,42 @@ go 1.18
 
 require (
 	github.com/Dreamacro/go-shadowsocks2 v0.1.8
-	github.com/dlclark/regexp2 v1.4.1-0.20201116162257-a2a8dda75c91
-	github.com/dop251/goja v0.0.0-20220516123900-4418d4575a41
-	github.com/dop251/goja_nodejs v0.0.0-20211022123610-8dd9abb0616d
+	github.com/dlclark/regexp2 v1.4.0
 	github.com/go-chi/chi/v5 v5.0.7
 	github.com/go-chi/cors v1.2.1
 	github.com/go-chi/render v1.0.1
 	github.com/gofrs/uuid v4.2.0+incompatible
 	github.com/gorilla/websocket v1.5.0
-	github.com/insomniacslk/dhcp v0.0.0-20220504074936-1ca156eafb9f
+	github.com/insomniacslk/dhcp v0.0.0-20220405050111-12fbdcb11b41
 	github.com/lucas-clemente/quic-go v0.27.0
 	github.com/miekg/dns v1.1.48
 	github.com/oschwald/geoip2-golang v1.7.0
 	github.com/sirupsen/logrus v1.8.1
 	github.com/stretchr/testify v1.7.1
-	github.com/vishvananda/netlink v1.2.0-beta.0.20220404152918-5e915e014938
 	github.com/xtls/go v0.0.0-20210920065950-d4af136d3672
 	go.etcd.io/bbolt v1.3.6
 	go.uber.org/atomic v1.9.0
 	go.uber.org/automaxprocs v1.5.1
-	golang.org/x/crypto v0.0.0-20220507011949-2cf3adece122
-	golang.org/x/exp v0.0.0-20220428152302-39d4317da171
-	golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4
+	golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4
+	golang.org/x/exp v0.0.0-20220414153411-bcd21879b8fd
+	golang.org/x/net v0.0.0-20220421235706-1d1ef9303861
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
-	golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6
+	golang.org/x/sys v0.0.0-20220422013727-9388b58f7150
 	golang.org/x/time v0.0.0-20220411224347-583f2d630306
 	golang.zx2c4.com/wireguard v0.0.0-20220407013110-ef5c587f782d
 	golang.zx2c4.com/wireguard/windows v0.5.4-0.20220317000008-6432784c2469
 	google.golang.org/protobuf v1.28.0
 	gopkg.in/yaml.v2 v2.4.0
-	gvisor.dev/gvisor v0.0.0-20220506231117-8ef340c14150
+	gvisor.dev/gvisor v0.0.0-20220422224113-2cca6b79d9f4
 )
 
 require (
 	github.com/cheekybits/genny v1.0.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/fsnotify/fsnotify v1.5.4 // indirect
-	github.com/go-sourcemap/sourcemap v2.1.3+incompatible // indirect
+	github.com/fsnotify/fsnotify v1.5.1 // indirect
 	github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0 // indirect
 	github.com/google/btree v1.0.1 // indirect
+	github.com/kr/pretty v0.2.1 // indirect
 	github.com/marten-seemann/qtls-go1-16 v0.1.5 // indirect
 	github.com/marten-seemann/qtls-go1-17 v0.1.1 // indirect
 	github.com/marten-seemann/qtls-go1-18 v0.1.1 // indirect
@@ -51,7 +48,6 @@ require (
 	github.com/oschwald/maxminddb-golang v1.9.0 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/u-root/uio v0.0.0-20220204230159-dac05f7d2cb4 // indirect
-	github.com/vishvananda/netns v0.0.0-20211101163701-50045581ed74 // indirect
 	golang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3 // indirect
 	golang.org/x/text v0.3.8-0.20220124021120-d1c84af989ab // indirect
 	golang.org/x/tools v0.1.10 // indirect
@@ -61,4 +57,4 @@ require (
 	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect
 )
 
-replace github.com/vishvananda/netlink v1.2.0-beta.0.20220404152918-5e915e014938 => github.com/MetaCubeX/netlink v1.2.0-beta.0.20220529072258-d6853f887820
+replace golang.zx2c4.com/wintun v0.0.0-20211104114900-415007cec224 => github.com/MetaCubeX/wintun-go v0.0.0-20220319102620-bbc5e6b2015e

go.sum

@@ -10,8 +10,8 @@ git.apache.org/thrift.git v0.0.0-20180902110319-2566ecd5d999/go.mod h1:fPE2ZNJGy
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/Dreamacro/go-shadowsocks2 v0.1.8 h1:Ixejp5JscEc866gAvm/l6TFd7BOBvDviKgwb1quWw3g=
 github.com/Dreamacro/go-shadowsocks2 v0.1.8/go.mod h1:51y4Q6tJoCE7e8TmYXcQRqfoxPfE9Cvn79V6pB6Df7Y=
-github.com/MetaCubeX/netlink v1.2.0-beta.0.20220529072258-d6853f887820 h1:fGKWZ25VApYnuPZoNeqdH/nZtHa2XMajwH6Yj/OgoVc=
-github.com/MetaCubeX/netlink v1.2.0-beta.0.20220529072258-d6853f887820/go.mod h1:twkDnbuQxJYemMlGd4JFIcuhgX83tXhKS2B/PRMpOho=
+github.com/MetaCubeX/wintun-go v0.0.0-20220319102620-bbc5e6b2015e h1:GRfT5Lf8HP7RNczKIwTYLoCh1PPuIs/sY9hj+W+3deg=
+github.com/MetaCubeX/wintun-go v0.0.0-20220319102620-bbc5e6b2015e/go.mod h1:ARUuShAtcziEJ/vnZ2hgoP+zc0J7Ukcca2S/NPDoQCc=
 github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/bradfitz/go-smtpd v0.0.0-20170404230938-deb6d6237625/go.mod h1:HYsPBTaaSFSlLx/70C2HPIMNZpVV8+vt/A+FMnYP11g=
@@ -20,26 +20,19 @@ github.com/cheekybits/genny v1.0.0 h1:uGGa4nei+j20rOSeDeP5Of12XVm7TGUd4dJA9RDitf
 github.com/cheekybits/genny v1.0.0/go.mod h1:+tQajlRqAUrPI7DOSpB0XAqZYtQakVtB7wXkRAgjxjQ=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/coreos/go-systemd v0.0.0-20181012123002-c6f51f82210d/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
-github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dlclark/regexp2 v1.4.1-0.20201116162257-a2a8dda75c91 h1:Izz0+t1Z5nI16/II7vuEo/nHjodOg0p7+OiDpjX5t1E=
-github.com/dlclark/regexp2 v1.4.1-0.20201116162257-a2a8dda75c91/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
-github.com/dop251/goja v0.0.0-20211022113120-dc8c55024d06/go.mod h1:R9ET47fwRVRPZnOGvHxxhuZcbrMCuiqOz3Rlrh4KSnk=
-github.com/dop251/goja v0.0.0-20220516123900-4418d4575a41 h1:yRPjAkkuR/E/tsVG7QmhzEeEtD3P2yllxsT1/ftURb0=
-github.com/dop251/goja v0.0.0-20220516123900-4418d4575a41/go.mod h1:TQJQ+ZNyFVvUtUEtCZxBhfWiH7RJqR3EivNmvD6Waik=
-github.com/dop251/goja_nodejs v0.0.0-20210225215109-d91c329300e7/go.mod h1:hn7BA7c8pLvoGndExHudxTDKZ84Pyvv+90pbBjbTz0Y=
-github.com/dop251/goja_nodejs v0.0.0-20211022123610-8dd9abb0616d h1:W1n4DvpzZGOISgp7wWNtraLcHtnmnTwBlJidqtMIuwQ=
-github.com/dop251/goja_nodejs v0.0.0-20211022123610-8dd9abb0616d/go.mod h1:DngW8aVqWbuLRMHItjPUyqdj+HWPvnQe8V8y1nDpIbM=
+github.com/dlclark/regexp2 v1.4.0 h1:F1rxgk7p4uKjwIQxBs9oAXe5CqrXlCduYEJvrF4u93E=
+github.com/dlclark/regexp2 v1.4.0/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/fanliao/go-promise v0.0.0-20141029170127-1890db352a72/go.mod h1:PjfxuH4FZdUyfMdtBio2lsRr1AKEaVPwelzuHuh8Lqc=
 github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
 github.com/francoispqt/gojay v1.2.13/go.mod h1:ehT5mTG4ua4581f1++1WLG0vPdaA9HaiDsoyrBGkyDY=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
-github.com/fsnotify/fsnotify v1.5.4 h1:jRbGcIw6P2Meqdwuo0H1p6JVLbL5DHKAKlYndzMwVZI=
-github.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU=
+github.com/fsnotify/fsnotify v1.5.1 h1:mZcQUHVQUQWoPXXtuf9yuEXKudkV2sx1E06UadKWpgI=
+github.com/fsnotify/fsnotify v1.5.1/go.mod h1:T3375wBYaZdLLcVNkcVbzGHY7f1l/uK5T5Ai1i3InKU=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
 github.com/gliderlabs/ssh v0.1.1/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0=
 github.com/go-chi/chi/v5 v5.0.7 h1:rDTPXLDHGATaeHvVlLcR4Qe0zftYethFucbjVQ1PxU8=
@@ -49,8 +42,6 @@ github.com/go-chi/cors v1.2.1/go.mod h1:sSbTewc+6wYHBBCW7ytsFSn836hqM7JxpglAy2Vz
 github.com/go-chi/render v1.0.1 h1:4/5tis2cKaNdnv9zFLfXzcquC9HbeZgCnxGnKrltBS8=
 github.com/go-chi/render v1.0.1/go.mod h1:pq4Rr7HbnsdaeHagklXub+p6Wd16Af5l9koip1OvJns=
 github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q=
-github.com/go-sourcemap/sourcemap v2.1.3+incompatible h1:W1iEw64niKVGogNgBN3ePyLFfuisuzeidWPMPWmECqU=
-github.com/go-sourcemap/sourcemap v2.1.3+incompatible/go.mod h1:F8jJfvm2KbVjc5NqelyYJmf/v5J0dwNLS2mL4sNA1Jg=
 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0 h1:p104kn46Q8WdvHunIJ9dAyjPVtrBPhSr3KT2yUst43I=
 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
 github.com/gofrs/uuid v4.2.0+incompatible h1:yyYWMnhkhrKwwr8gAOcOCYxOOscHgDS9yZgBrnJfGa0=
@@ -97,8 +88,8 @@ github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:Fecb
 github.com/grpc-ecosystem/grpc-gateway v1.5.0/go.mod h1:RSKVYQBd5MCa4OVpNdGskqpgL2+G+NZTnrVHpWWfpdw=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/hugelgupf/socketpair v0.0.0-20190730060125-05d35a94e714/go.mod h1:2Goc3h8EklBH5mspfHFxBnEoURQCGzQQH1ga9Myjvis=
-github.com/insomniacslk/dhcp v0.0.0-20220504074936-1ca156eafb9f h1:l1QCwn715k8nYkj4Ql50rzEog3WnMdrd4YYMMwemxEo=
-github.com/insomniacslk/dhcp v0.0.0-20220504074936-1ca156eafb9f/go.mod h1:h+MxyHxRg9NH3terB1nfRIUaQEcI0XOVkdR9LNBlp8E=
+github.com/insomniacslk/dhcp v0.0.0-20220405050111-12fbdcb11b41 h1:Yg3n3AI7GoHnWt7dyjsLPU+TEuZfPAg0OdiA3MJUV6I=
+github.com/insomniacslk/dhcp v0.0.0-20220405050111-12fbdcb11b41/go.mod h1:h+MxyHxRg9NH3terB1nfRIUaQEcI0XOVkdR9LNBlp8E=
 github.com/jellevandenhooff/dkim v0.0.0-20150330215556-f50fe3d243e1/go.mod h1:E0B/fFc00Y+Rasa88328GlI/XbtyysCtTHZS8h7IrBU=
 github.com/jsimonetti/rtnetlink v0.0.0-20190606172950-9527aa82566a/go.mod h1:Oz+70psSo5OFh8DBl0Zv2ACw7Esh6pPUphlvZG9x7uw=
 github.com/jsimonetti/rtnetlink v0.0.0-20200117123717-f846d4f6c1f4/go.mod h1:WGuG/smIU4J/54PblvSbh+xvCZmpJnFgr3ds6Z55XMQ=
@@ -109,14 +100,12 @@ github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=
 github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
-github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
-github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/pty v1.1.3/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/lucas-clemente/quic-go v0.27.0 h1:v6WY87q9zD4dKASbG8hy/LpzAVNzEQzw8sEIeloJsc4=
 github.com/lucas-clemente/quic-go v0.27.0/go.mod h1:AzgQoPda7N+3IqMMMkywBKggIFo2KT6pfnlrQ2QieeI=
 github.com/lunixbochs/vtclean v1.0.0/go.mod h1:pHhQNgMf3btfWnGBVipUOjRYhoOsdGqdm/+2c2E2WMI=
@@ -170,8 +159,6 @@ github.com/prometheus/client_golang v0.8.0/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXP
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/common v0.0.0-20180801064454-c7de2306084e/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
 github.com/prometheus/procfs v0.0.0-20180725123919-05ee40e3a273/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
-github.com/rogpeppe/go-internal v1.6.1 h1:/FiVV8dS/e+YqF2JvO3yXRFbBLTIuSDkuC7aBOAvL+k=
-github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
 github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
 github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
 github.com/shurcooL/component v0.0.0-20170202220835-f88ec8f54cc4/go.mod h1:XhFIlyj5a1fBNx5aJTbKoIq0mNaPvOagO+HjB3EtxrY=
@@ -215,9 +202,6 @@ github.com/u-root/uio v0.0.0-20220204230159-dac05f7d2cb4 h1:hl6sK6aFgTLISijk6xIz
 github.com/u-root/uio v0.0.0-20220204230159-dac05f7d2cb4/go.mod h1:LpEX5FO/cB+WF4TYGY1V5qktpaZLkKkSegbr0V4eYXA=
 github.com/viant/assertly v0.4.8/go.mod h1:aGifi++jvCrUaklKEKT0BU95igDNaqkvz+49uaYMPRU=
 github.com/viant/toolbox v0.24.0/go.mod h1:OxMCG57V0PXuIP2HNQrtJf2CjqdmbrOx5EkMILuUhzM=
-github.com/vishvananda/netns v0.0.0-20200728191858-db3c7e526aae/go.mod h1:DD4vA1DwXk04H54A1oHXtwZmA0grkVMdPxx/VGLCah0=
-github.com/vishvananda/netns v0.0.0-20211101163701-50045581ed74 h1:gga7acRE695APm9hlsSMoOoE65U4/TcqNj90mc69Rlg=
-github.com/vishvananda/netns v0.0.0-20211101163701-50045581ed74/go.mod h1:DD4vA1DwXk04H54A1oHXtwZmA0grkVMdPxx/VGLCah0=
 github.com/xtls/go v0.0.0-20210920065950-d4af136d3672 h1:4mkzGhKqt3JO1BWYjtD3iRFyAx4ow67hmSqOcGjuxqQ=
 github.com/xtls/go v0.0.0-20210920065950-d4af136d3672/go.mod h1:YGGVbz9cOxyKFUmhW7LGaLZaMA0cPlHJinvAmVxEMSU=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
@@ -237,11 +221,11 @@ golang.org/x/crypto v0.0.0-20190313024323-a1f597ede03a/go.mod h1:djNgcEr1/C05ACk
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200221231518-2aa609cf4a9d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20220507011949-2cf3adece122 h1:NvGWuYG8dkDHFSKksI1P9faiVJ9rayE6l0+ouWVIDs8=
-golang.org/x/crypto v0.0.0-20220507011949-2cf3adece122/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4 h1:kUhD7nTDoI3fVd9G4ORWrbV5NY0liEs/Jg2pv5f+bBA=
+golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20220428152302-39d4317da171 h1:TfdoLivD44QwvssI9Sv1xwa5DcL5XQr4au4sZ2F2NV4=
-golang.org/x/exp v0.0.0-20220428152302-39d4317da171/go.mod h1:lgLbSvA5ygNOMpwM/9anMpWVlVJ7Z+cHWq/eFuinpGE=
+golang.org/x/exp v0.0.0-20220414153411-bcd21879b8fd h1:zVFyTKZN/Q7mNRWSs1GOYnHM9NiFSJ54YVRsD0rNWT4=
+golang.org/x/exp v0.0.0-20220414153411-bcd21879b8fd/go.mod h1:lgLbSvA5ygNOMpwM/9anMpWVlVJ7Z+cHWq/eFuinpGE=
 golang.org/x/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
@@ -273,8 +257,8 @@ golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwY
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
 golang.org/x/net v0.0.0-20210726213435-c6fcb2dbf985/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4 h1:HVyaeDAYux4pnY+D/SiwmLOR36ewZ4iGQIIrtnuCjFA=
-golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
+golang.org/x/net v0.0.0-20220421235706-1d1ef9303861 h1:yssD99+7tqHWO5Gwh81phT+67hg+KttniBr6UnEXOY8=
+golang.org/x/net v0.0.0-20220421235706-1d1ef9303861/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20181017192945-9dcd33a902f4/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
@@ -305,11 +289,9 @@ golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200217220822-9197077df867/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200728102440-3e129f6d46b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200923182605-d9f96fdee20d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201009025420-dfb3f7c4e634/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -322,16 +304,14 @@ golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20210525143221-35b2ab0089ea/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6 h1:nonptSpoQ4vQjyraW20DXPAglgQfVnM9ZC6MmNLMR60=
-golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220422013727-9388b58f7150 h1:xHms4gcpe1YE7A3yIllJXP16CMAGuqwO2lX1mTyyRRc=
+golang.org/x/sys v0.0.0-20220422013727-9388b58f7150/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.3.8-0.20220124021120-d1c84af989ab h1:eHo2TTVBaAPw9lDGK2Gb9GyPMXT6g7O63W6sx3ylbzU=
 golang.org/x/text v0.3.8-0.20220124021120-d1c84af989ab/go.mod h1:EFNZuWvGYxIRUEX+K8UmCFwYmZjqcrnq15ZuVldZkZ0=
 golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
@@ -357,8 +337,6 @@ golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8T
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20220411194840-2f41105eb62f h1:GGU+dLjvlC3qDwqYgL6UgRmHXhOOgns0bZu2Ty5mm6U=
 golang.org/x/xerrors v0.0.0-20220411194840-2f41105eb62f/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.zx2c4.com/wintun v0.0.0-20211104114900-415007cec224 h1:Ug9qvr1myri/zFN6xL17LSCBGFDnphBBhzmILHsM5TY=
-golang.zx2c4.com/wintun v0.0.0-20211104114900-415007cec224/go.mod h1:deeaetjYA+DHMHg+sMSMI58GrEteJUUzzw7en6TJQcI=
 golang.zx2c4.com/wireguard v0.0.0-20220407013110-ef5c587f782d h1:q4JksJ2n0fmbXC0Aj0eOs6E0AcPqnKglxWXWFqGD6x0=
 golang.zx2c4.com/wireguard v0.0.0-20220407013110-ef5c587f782d/go.mod h1:bVQfyl2sCM/QIIGHpWbFGfHPuDvqnCNkT6MQLTCjO/U=
 golang.zx2c4.com/wireguard/windows v0.5.4-0.20220317000008-6432784c2469 h1:SEYkJAIuYAsSAPkCffOiYLtq5brBDSI+L0mRjSsvSTY=
@@ -390,10 +368,8 @@ google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQ
 google.golang.org/protobuf v1.28.0 h1:w43yiav+6bVFTBQFZX0r7ipe9JQ1QsbMgHwbBziscLw=
 google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
-gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
 gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
@@ -408,8 +384,8 @@ gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 grpc.go4.org v0.0.0-20170609214715-11d0a25b4919/go.mod h1:77eQGdRu53HpSqPFJFmuJdjuHRquDANNeA4x7B8WQ9o=
-gvisor.dev/gvisor v0.0.0-20220506231117-8ef340c14150 h1:bspdBY1iCLtW6JXold8yhXHkAiE9UoWfmHShNkTc9JA=
-gvisor.dev/gvisor v0.0.0-20220506231117-8ef340c14150/go.mod h1:tWwEcFvJavs154OdjFCw78axNrsDlz4Zh8jvPqwcpGI=
+gvisor.dev/gvisor v0.0.0-20220422224113-2cca6b79d9f4 h1:CSkd548jw5hmVwdJ+JuUhMtRV56oQBER7sbkIOePP2Y=
+gvisor.dev/gvisor v0.0.0-20220422224113-2cca6b79d9f4/go.mod h1:tWwEcFvJavs154OdjFCw78axNrsDlz4Zh8jvPqwcpGI=
 honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

hub/executor/concurrent_load_limit.go

@@ -1,5 +0,0 @@
-//go:build !386 && !amd64 && !arm64 && !arm64be && !mipsle && !mips
-
-package executor
-
-const concurrentCount = 5

hub/executor/concurrent_load_single.go

@@ -1,5 +0,0 @@
-//go:build mips || mipsle
-
-package executor
-
-const concurrentCount = 1

hub/executor/concurrent_load_unlimit.go

@@ -1,7 +0,0 @@
-//go:build 386 || amd64 || arm64 || arm64be
-
-package executor
-
-import "math"
-
-const concurrentCount = math.MaxInt

hub/executor/executor.go

@@ -2,8 +2,6 @@ package executor
 
 import (
 	"fmt"
-	"github.com/Dreamacro/clash/component/process"
-	"github.com/Dreamacro/clash/listener/inner"
 	"net/netip"
 	"os"
 	"runtime"
@@ -78,24 +76,19 @@ func ApplyConfig(cfg *config.Config, force bool) {
 	updateProxies(cfg.Proxies, cfg.Providers)
 	updateRules(cfg.Rules, cfg.RuleProviders)
 	updateSniffer(cfg.Sniffer)
+	updateDNS(cfg.DNS)
+	updateGeneral(cfg.General, force)
+	updateIPTables(cfg)
+	updateTun(cfg.Tun, cfg.DNS)
+	updateExperimental(cfg)
 	updateHosts(cfg.Hosts)
-	initInnerTcp()
-	updateDNS(cfg.DNS, cfg.General.IPv6)
 	loadProxyProvider(cfg.Providers)
 	updateProfile(cfg)
 	loadRuleProvider(cfg.RuleProviders)
-	updateGeneral(cfg.General, force)
-	updateIPTables(cfg)
-	updateTun(cfg.Tun)
-	updateExperimental(cfg)
 
 	log.SetLevel(cfg.General.LogLevel)
 }
 
-func initInnerTcp() {
-	inner.New(tunnel.TCPIn())
-}
-
 func GetGeneral() *config.General {
 	ports := P.GetPorts()
 	var authenticator []string
@@ -118,10 +111,6 @@ func GetGeneral() *config.General {
 		LogLevel:      log.Level(),
 		IPv6:          !resolver.DisableIPv6,
 		GeodataLoader: G.LoaderName(),
-		Tun:           P.GetTunConf(),
-		Interface:     dialer.DefaultInterface.Load(),
-		Sniffing:      tunnel.IsSniffing(),
-		TCPConcurrent: dialer.GetDial(),
 	}
 
 	return general
@@ -129,16 +118,12 @@ func GetGeneral() *config.General {
 
 func updateExperimental(c *config.Config) {}
 
-func updateDNS(c *config.DNS, generalIPv6 bool) {
+func updateDNS(c *config.DNS) {
 	if !c.Enable {
-		resolver.DisableIPv6 = !generalIPv6
 		resolver.DefaultResolver = nil
 		resolver.DefaultHostMapper = nil
-		resolver.DefaultLocalServer = nil
 		dns.ReCreateServer("", nil, nil)
 		return
-	} else {
-		resolver.DisableIPv6 = !c.IPv6
 	}
 
 	cfg := dns.Config{
@@ -160,6 +145,8 @@ func updateDNS(c *config.DNS, generalIPv6 bool) {
 		ProxyServer: c.ProxyServerNameserver,
 	}
 
+	resolver.DisableIPv6 = !cfg.IPv6
+
 	r := dns.NewResolver(cfg)
 	pr := dns.NewProxyServerHostResolver(r)
 	m := dns.NewEnhancer(cfg)
@@ -171,7 +158,6 @@ func updateDNS(c *config.DNS, generalIPv6 bool) {
 
 	resolver.DefaultResolver = r
 	resolver.DefaultHostMapper = m
-	resolver.DefaultLocalServer = dns.NewLocalServer(r, m)
 
 	if pr.HasProxyServer() {
 		resolver.ProxyServerHostResolver = pr
@@ -199,7 +185,7 @@ func loadProvider(pv provider.Provider) {
 		log.Infoln("Start initial provider %s", (pv).Name())
 	}
 
-	if err := pv.Initial(); err != nil {
+	if err := (pv).Initial(); err != nil {
 		switch pv.Type() {
 		case provider.Proxy:
 			{
@@ -215,46 +201,24 @@ func loadProvider(pv provider.Provider) {
 }
 
 func loadRuleProvider(ruleProviders map[string]provider.RuleProvider) {
-	wg := sync.WaitGroup{}
-	ch := make(chan struct{}, concurrentCount)
 	for _, ruleProvider := range ruleProviders {
-		ruleProvider := ruleProvider
-		wg.Add(1)
-		ch <- struct{}{}
-		go func() {
-			defer func() { <-ch; wg.Done() }()
-			loadProvider(ruleProvider)
-
-		}()
+		loadProvider(ruleProvider)
 	}
-
-	wg.Wait()
 }
 
-func loadProxyProvider(proxyProviders map[string]provider.ProxyProvider) {
-	// limit concurrent size
-	wg := sync.WaitGroup{}
-	ch := make(chan struct{}, concurrentCount)
-	for _, proxyProvider := range proxyProviders {
-		proxyProvider := proxyProvider
-		wg.Add(1)
-		ch <- struct{}{}
-		go func() {
-			defer func() { <-ch; wg.Done() }()
-			loadProvider(proxyProvider)
-		}()
+func loadProxyProvider(ruleProviders map[string]provider.ProxyProvider) {
+	for _, ruleProvider := range ruleProviders {
+		loadProvider(ruleProvider)
 	}
-
-	wg.Wait()
 }
 
-func updateTun(tun *config.Tun) {
-	P.ReCreateTun(tun, tunnel.TCPIn(), tunnel.UDPIn())
+func updateTun(tun *config.Tun, dns *config.DNS) {
+	P.ReCreateTun(tun, dns, tunnel.TCPIn(), tunnel.UDPIn())
 }
 
 func updateSniffer(sniffer *config.Sniffer) {
 	if sniffer.Enable {
-		dispatcher, err := SNI.NewSnifferDispatcher(sniffer.Sniffers, sniffer.ForceDomain, sniffer.SkipDomain, sniffer.Ports)
+		dispatcher, err := SNI.NewSnifferDispatcher(sniffer.Sniffers, sniffer.ForceDomain, sniffer.SkipSNI, sniffer.Ports)
 		if err != nil {
 			log.Warnln("initial sniffer failed, err:%v", err)
 		}
@@ -274,7 +238,6 @@ func updateSniffer(sniffer *config.Sniffer) {
 
 func updateGeneral(general *config.General, force bool) {
 	log.SetLevel(general.LogLevel)
-	process.EnableFindProcess(general.EnableProcess)
 	tunnel.SetMode(general.Mode)
 	dialer.DisableIPv6 = !general.IPv6
 	if !dialer.DisableIPv6 {
@@ -354,7 +317,7 @@ func patchSelectGroup(proxies map[string]C.Proxy) {
 			continue
 		}
 
-		selector, ok := outbound.ProxyAdapter.(outboundgroup.SelectAble)
+		selector, ok := outbound.ProxyAdapter.(*outboundgroup.Selector)
 		if !ok {
 			continue
 		}
@@ -429,7 +392,7 @@ func updateIPTables(cfg *config.Config) {
 }
 
 func Shutdown() {
-	P.Cleanup(false)
+	P.Cleanup()
 	tproxy.CleanupTProxyIPTables()
 	resolver.StoreFakePoolState()
 

hub/route/configs.go

@@ -1,10 +1,8 @@
 package route
 
 import (
-	"github.com/Dreamacro/clash/component/dialer"
 	"net/http"
 	"path/filepath"
-	"sync"
 
 	"github.com/Dreamacro/clash/component/resolver"
 	"github.com/Dreamacro/clash/config"
@@ -18,34 +16,26 @@ import (
 	"github.com/go-chi/render"
 )
 
-var (
-	updateGeoMux sync.Mutex
-	updatingGeo  = false
-)
-
 func configRouter() http.Handler {
 	r := chi.NewRouter()
 	r.Get("/", getConfigs)
 	r.Put("/", updateConfigs)
-	r.Post("/geo", updateGeoDatabases)
 	r.Patch("/", patchConfigs)
 	return r
 }
 
 type configSchema struct {
-	Port          *int               `json:"port"`
-	SocksPort     *int               `json:"socks-port"`
-	RedirPort     *int               `json:"redir-port"`
-	TProxyPort    *int               `json:"tproxy-port"`
-	MixedPort     *int               `json:"mixed-port"`
-	Tun           *config.Tun        `json:"tun"`
-	AllowLan      *bool              `json:"allow-lan"`
-	BindAddress   *string            `json:"bind-address"`
-	Mode          *tunnel.TunnelMode `json:"mode"`
-	LogLevel      *log.LogLevel      `json:"log-level"`
-	IPv6          *bool              `json:"ipv6"`
-	Sniffing      *bool              `json:"sniffing"`
-	TcpConcurrent *bool              `json:"tcp-concurrent"`
+	Port        *int               `json:"port"`
+	SocksPort   *int               `json:"socks-port"`
+	RedirPort   *int               `json:"redir-port"`
+	TProxyPort  *int               `json:"tproxy-port"`
+	MixedPort   *int               `json:"mixed-port"`
+	Tun         *config.Tun        `json:"tun"`
+	AllowLan    *bool              `json:"allow-lan"`
+	BindAddress *string            `json:"bind-address"`
+	Mode        *tunnel.TunnelMode `json:"mode"`
+	LogLevel    *log.LogLevel      `json:"log-level"`
+	IPv6        *bool              `json:"ipv6"`
 }
 
 func getConfigs(w http.ResponseWriter, r *http.Request) {
@@ -77,14 +67,6 @@ func patchConfigs(w http.ResponseWriter, r *http.Request) {
 		P.SetBindAddress(*general.BindAddress)
 	}
 
-	if general.Sniffing != nil {
-		tunnel.SetSniffing(*general.Sniffing)
-	}
-
-	if general.TcpConcurrent != nil {
-		dialer.SetDial(*general.TcpConcurrent)
-	}
-
 	ports := P.GetPorts()
 
 	tcpIn := tunnel.TCPIn()
@@ -156,42 +138,3 @@ func updateConfigs(w http.ResponseWriter, r *http.Request) {
 	executor.ApplyConfig(cfg, force)
 	render.NoContent(w, r)
 }
-
-func updateGeoDatabases(w http.ResponseWriter, r *http.Request) {
-	updateGeoMux.Lock()
-
-	if updatingGeo {
-		updateGeoMux.Unlock()
-		render.Status(r, http.StatusBadRequest)
-		render.JSON(w, r, newError("updating..."))
-		return
-	}
-
-	updatingGeo = true
-	updateGeoMux.Unlock()
-
-	go func() {
-		defer func() {
-			updatingGeo = false
-		}()
-
-		log.Warnln("[REST-API] updating GEO databases...")
-
-		if err := config.UpdateGeoDatabases(); err != nil {
-			log.Errorln("[REST-API] update GEO databases failed: %v", err)
-			return
-		}
-
-		cfg, err := executor.ParseWithPath(constant.Path.Config())
-		if err != nil {
-			log.Errorln("[REST-API] update GEO databases failed: %v", err)
-			return
-		}
-
-		log.Warnln("[REST-API] update GEO databases successful, apply config...")
-
-		executor.ApplyConfig(cfg, false)
-	}()
-
-	render.NoContent(w, r)
-}

hub/route/groups.go

@@ -1,79 +0,0 @@
-package route
-
-import (
-	"context"
-	"github.com/Dreamacro/clash/adapter"
-	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/tunnel"
-	"github.com/go-chi/chi/v5"
-	"github.com/go-chi/render"
-	"net/http"
-	"strconv"
-	"time"
-)
-
-func GroupRouter() http.Handler {
-	r := chi.NewRouter()
-	r.Get("/", getGroups)
-
-	r.Route("/{name}", func(r chi.Router) {
-		r.Use(parseProxyName, findProxyByName)
-		r.Get("/", getGroup)
-		r.Get("/delay", getGroupDelay)
-	})
-	return r
-}
-
-func getGroups(w http.ResponseWriter, r *http.Request) {
-	var gs []C.Proxy
-	for _, p := range tunnel.Proxies() {
-		if _, ok := p.(*adapter.Proxy).ProxyAdapter.(C.Group); ok {
-			gs = append(gs, p)
-		}
-	}
-	render.JSON(w, r, render.M{
-		"proxies": gs,
-	})
-}
-
-func getGroup(w http.ResponseWriter, r *http.Request) {
-	proxy := r.Context().Value(CtxKeyProxy).(C.Proxy)
-	if _, ok := proxy.(*adapter.Proxy).ProxyAdapter.(C.Group); ok {
-		render.JSON(w, r, proxy)
-		return
-	}
-	render.Status(r, http.StatusNotFound)
-	render.JSON(w, r, ErrNotFound)
-}
-
-func getGroupDelay(w http.ResponseWriter, r *http.Request) {
-	proxy := r.Context().Value(CtxKeyProxy).(C.Proxy)
-	group, ok := proxy.(*adapter.Proxy).ProxyAdapter.(C.Group)
-	if !ok {
-		render.Status(r, http.StatusNotFound)
-		render.JSON(w, r, ErrNotFound)
-		return
-	}
-
-	query := r.URL.Query()
-	url := query.Get("url")
-	timeout, err := strconv.ParseInt(query.Get("timeout"), 10, 32)
-	if err != nil {
-		render.Status(r, http.StatusBadRequest)
-		render.JSON(w, r, ErrBadRequest)
-		return
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout))
-	defer cancel()
-
-	dm, err := group.URLTest(ctx, url)
-
-	if err != nil {
-		render.Status(r, http.StatusGatewayTimeout)
-		render.JSON(w, r, newError(err.Error()))
-		return
-	}
-
-	render.JSON(w, r, dm)
-}

hub/route/proxies.go

@@ -83,7 +83,7 @@ func updateProxy(w http.ResponseWriter, r *http.Request) {
 	}
 
 	proxy := r.Context().Value(CtxKeyProxy).(*adapter.Proxy)
-	selector, ok := proxy.ProxyAdapter.(outboundgroup.SelectAble)
+	selector, ok := proxy.ProxyAdapter.(*outboundgroup.Selector)
 	if !ok {
 		render.Status(r, http.StatusBadRequest)
 		render.JSON(w, r, newError("Must be a Selector"))

hub/route/rules.go

@@ -1,7 +1,6 @@
 package route
 
 import (
-	"github.com/Dreamacro/clash/constant"
 	"net/http"
 
 	"github.com/Dreamacro/clash/tunnel"
@@ -20,23 +19,17 @@ type Rule struct {
 	Type    string `json:"type"`
 	Payload string `json:"payload"`
 	Proxy   string `json:"proxy"`
-	Size    int    `json:"size"`
 }
 
 func getRules(w http.ResponseWriter, r *http.Request) {
 	rawRules := tunnel.Rules()
 	rules := []Rule{}
 	for _, rule := range rawRules {
-		r := Rule{
+		rules = append(rules, Rule{
 			Type:    rule.RuleType().String(),
 			Payload: rule.Payload(),
 			Proxy:   rule.Adapter(),
-			Size:    -1,
-		}
-		if rule.RuleType() == constant.GEOIP || rule.RuleType() == constant.GEOSITE {
-			r.Size = rule.(constant.RuleGroup).GetRecodeSize()
-		}
-		rules = append(rules, r)
+		})
 
 	}
 

hub/route/script.go

@@ -0,0 +1,16 @@
+package route
+
+import (
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+func scriptRouter() http.Handler {
+	r := chi.NewRouter()
+	r.Get("/", getScript)
+	return r
+}
+
+func getScript(writer http.ResponseWriter, request *http.Request) {
+	writer.WriteHeader(http.StatusMethodNotAllowed)
+}

hub/route/server.go

@@ -68,11 +68,11 @@ func Start(addr string, secret string) {
 		r.Get("/version", version)
 		r.Mount("/configs", configRouter())
 		r.Mount("/proxies", proxyRouter())
-		r.Mount("/group", GroupRouter())
 		r.Mount("/rules", ruleRouter())
 		r.Mount("/connections", connectionRouter())
 		r.Mount("/providers/proxies", proxyProviderRouter())
 		r.Mount("/providers/rules", ruleProviderRouter())
+		r.Mount("/script", scriptRouter())
 		r.Mount("/cache", cacheRouter())
 	})
 

listener/listener.go

@@ -2,10 +2,11 @@ package proxy
 
 import (
 	"fmt"
+	"github.com/Dreamacro/clash/common/cmd"
 	"github.com/Dreamacro/clash/listener/inner"
-	"github.com/Dreamacro/clash/listener/tun/ipstack/commons"
 	"net"
-	"sort"
+	"os"
+	"runtime"
 	"strconv"
 	"sync"
 
@@ -25,7 +26,6 @@ import (
 var (
 	allowLan    = false
 	bindAddress = "*"
-	lastTunConf *config.Tun
 
 	socksListener     *socks.Listener
 	socksUDPListener  *socks.UDPListener
@@ -55,15 +55,6 @@ type Ports struct {
 	MixedPort  int `json:"mixed-port"`
 }
 
-func GetTunConf() config.Tun {
-	if lastTunConf == nil {
-		return config.Tun{
-			Enable: false,
-		}
-	}
-	return *lastTunConf
-}
-
 func AllowLan() bool {
 	return allowLan
 }
@@ -80,10 +71,6 @@ func SetBindAddress(host string) {
 	bindAddress = host
 }
 
-func NewInner(tcpIn chan<- C.ConnContext) {
-	inner.New(tcpIn)
-}
-
 func ReCreateHTTP(port int, tcpIn chan<- C.ConnContext) {
 	httpMux.Lock()
 	defer httpMux.Unlock()
@@ -128,6 +115,7 @@ func ReCreateSocks(port int, tcpIn chan<- C.ConnContext, udpIn chan<- *inbound.P
 			log.Errorln("Start SOCKS server error: %s", err.Error())
 		}
 	}()
+	inner.New(tcpIn)
 
 	addr := genAddr(bindAddress, port, allowLan)
 
@@ -324,7 +312,7 @@ func ReCreateMixed(port int, tcpIn chan<- C.ConnContext, udpIn chan<- *inbound.P
 	log.Infoln("Mixed(http+socks) proxy listening at: %s", mixedListener.Address())
 }
 
-func ReCreateTun(tunConf *config.Tun, tcpIn chan<- C.ConnContext, udpIn chan<- *inbound.PacketAdapter) {
+func ReCreateTun(tunConf *config.Tun, dnsCfg *config.DNS, tcpIn chan<- C.ConnContext, udpIn chan<- *inbound.PacketAdapter) {
 	tunMux.Lock()
 	defer tunMux.Unlock()
 
@@ -332,23 +320,22 @@ func ReCreateTun(tunConf *config.Tun, tcpIn chan<- C.ConnContext, udpIn chan<- *
 	defer func() {
 		if err != nil {
 			log.Errorln("Start TUN listening error: %s", err.Error())
-			Cleanup(false)
+			os.Exit(2)
 		}
 	}()
 
-	if !hasTunConfigChange(tunConf) {
-		return
+	if tunStackListener != nil {
+		tunStackListener.Close()
+		tunStackListener = nil
 	}
 
-	Cleanup(true)
-
 	if !tunConf.Enable {
 		return
 	}
-
-	tunStackListener, err = tun.New(tunConf, tcpIn, udpIn)
-
-	lastTunConf = tunConf
+	tunStackListener, err = tun.New(tunConf, dnsCfg, tcpIn, udpIn)
+	if err != nil {
+		log.Warnln("Failed to start TUN interface: %s", err.Error())
+	}
 }
 
 // GetPorts return the ports of proxy servers
@@ -407,55 +394,14 @@ func genAddr(host string, port int, allowLan bool) string {
 	return fmt.Sprintf("127.0.0.1:%d", port)
 }
 
-func hasTunConfigChange(tunConf *config.Tun) bool {
-	if lastTunConf == nil {
-		return true
-	}
-
-	if len(lastTunConf.DNSHijack) != len(tunConf.DNSHijack) {
-		return true
-	}
-
-	sort.Slice(lastTunConf.DNSHijack, func(i, j int) bool {
-		return lastTunConf.DNSHijack[i].Addr().Less(lastTunConf.DNSHijack[j].Addr())
-	})
-
-	sort.Slice(tunConf.DNSHijack, func(i, j int) bool {
-		return tunConf.DNSHijack[i].Addr().Less(tunConf.DNSHijack[j].Addr())
-	})
-
-	for i, dns := range tunConf.DNSHijack {
-		if dns != lastTunConf.DNSHijack[i] {
-			return true
-		}
-	}
-
-	if lastTunConf.Enable != tunConf.Enable ||
-		lastTunConf.Device != tunConf.Device ||
-		lastTunConf.Stack != tunConf.Stack ||
-		lastTunConf.AutoRoute != tunConf.AutoRoute ||
-		lastTunConf.AutoDetectInterface != tunConf.AutoDetectInterface {
-		return true
-	}
-
-	if tunConf.TunAddressPrefix.String() != lastTunConf.TunAddressPrefix.String() {
-		return true
-	}
-
-	return false
-}
-
-func Cleanup(wait bool) {
+func Cleanup() {
 	if tunStackListener != nil {
 		_ = tunStackListener.Close()
-		commons.StopDefaultInterfaceChangeMonitor()
-
-		if wait {
-			commons.WaitForTunClose(lastTunConf.Device)
+		if runtime.GOOS == "android" {
+			prefs := []int{9000, 9001, 9002, 9003, 9004}
+			for _, pref := range prefs {
+				_, _ = cmd.ExecCmd(fmt.Sprintf("ip rule del pref %d", pref))
+			}
 		}
-
-		commons.CleanupRule()
 	}
-	tunStackListener = nil
-	lastTunConf = nil
 }

listener/tun/device/device.go

@@ -1,5 +1,3 @@
-//go:build !no_gvisor
-
 package device
 
 import (

listener/tun/device/device_no_gvisor.go

@@ -1,29 +0,0 @@
-//go:build no_gvisor
-
-package device
-
-// Device is the interface that implemented by network layer devices (e.g. tun),
-// and easy to use as stack.LinkEndpoint.
-type Device interface {
-
-	// Name returns the current name of the device.
-	Name() string
-
-	// Type returns the driver type of the device.
-	Type() string
-
-	// Read packets from tun device
-	Read(packet []byte) (int, error)
-
-	// Write packets to tun device
-	Write(packet []byte) (int, error)
-
-	// Close stops and closes the device.
-	Close() error
-
-	// UseEndpoint work for gVisor stack
-	UseEndpoint() error
-
-	// UseIOBased work for other ip stack
-	UseIOBased() error
-}

listener/tun/device/fdbased/fd_unix.go

@@ -4,13 +4,24 @@ package fdbased
 
 import (
 	"fmt"
+	"os"
 	"strconv"
 
 	"github.com/Dreamacro/clash/listener/tun/device"
 
 	"golang.org/x/sys/unix"
+	"gvisor.dev/gvisor/pkg/tcpip/stack"
 )
 
+type FD struct {
+	stack.LinkEndpoint
+
+	fd  int
+	mtu uint32
+
+	file *os.File
+}
+
 func Open(name string, mtu uint32) (device.Device, error) {
 	fd, err := strconv.Atoi(name)
 	if err != nil {

listener/tun/device/fdbased/fd_unix_gvisor.go

@@ -1,17 +0,0 @@
-//go:build !no_gvisor
-
-package fdbased
-
-import (
-	"gvisor.dev/gvisor/pkg/tcpip/stack"
-	"os"
-)
-
-type FD struct {
-	stack.LinkEndpoint
-
-	fd  int
-	mtu uint32
-
-	file *os.File
-}

listener/tun/device/fdbased/fd_unix_no_gvisor.go

@@ -1,14 +0,0 @@
-//go:build no_gvisor
-
-package fdbased
-
-import (
-	"os"
-)
-
-type FD struct {
-	fd  int
-	mtu uint32
-
-	file *os.File
-}

listener/tun/device/fdbased/open_others.go

@@ -7,6 +7,7 @@ import (
 	"os"
 
 	"github.com/Dreamacro/clash/listener/tun/device"
+	"github.com/Dreamacro/clash/listener/tun/device/iobased"
 )
 
 func open(fd int, mtu uint32) (device.Device, error) {
@@ -16,7 +17,12 @@ func open(fd int, mtu uint32) (device.Device, error) {
 }
 
 func (f *FD) useEndpoint() error {
-	return newEp(f)
+	ep, err := iobased.New(os.NewFile(uintptr(f.fd), f.Name()), f.mtu, 0)
+	if err != nil {
+		return fmt.Errorf("create endpoint: %w", err)
+	}
+	f.LinkEndpoint = ep
+	return nil
 }
 
 func (f *FD) useIOBased() error {

listener/tun/device/fdbased/open_others_gvisor.go

@@ -1,19 +0,0 @@
-//go:build !no_gvisor && !linux && !windows
-
-package fdbased
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/Dreamacro/clash/listener/tun/device/iobased"
-)
-
-func newEp(f *FD) error {
-	ep, err := iobased.New(os.NewFile(uintptr(f.fd), f.Name()), f.mtu, 0)
-	if err != nil {
-		return fmt.Errorf("create endpoint: %w", err)
-	}
-	f.LinkEndpoint = ep
-	return nil
-}

listener/tun/device/fdbased/open_others_no_gvisor.go

@@ -1,11 +0,0 @@
-//go:build no_gvisor && !linux && !windows
-
-package fdbased
-
-import (
-	"fmt"
-)
-
-func newEp(f *FD) error {
-	return fmt.Errorf("unsupported gvisor on the build")
-}

listener/tun/device/iobased/endpoint.go

@@ -1,5 +1,3 @@
-//go:build !no_gvisor
-
 // Package iobased provides the implementation of io.ReadWriter
 // based data-link layer endpoints.
 package iobased

listener/tun/device/iobased/iobased.go

@@ -1 +0,0 @@
-package iobased

listener/tun/device/tun/driver/dll_windows.go

@@ -1,233 +0,0 @@
-/* SPDX-License-Identifier: MIT
- *
- * Copyright (C) 2017-2021 WireGuard LLC. All Rights Reserved.
- */
-
-package driver
-
-import (
-	"fmt"
-	"runtime"
-	"sync"
-	"sync/atomic"
-	"syscall"
-	"unsafe"
-
-	"github.com/Dreamacro/clash/log"
-
-	"golang.org/x/sys/windows"
-	"golang.zx2c4.com/wireguard/windows/driver/memmod"
-)
-
-//go:linkname modwintun golang.zx2c4.com/wintun.modwintun
-
-//go:linkname procWintunCreateAdapter golang.zx2c4.com/wintun.procWintunCreateAdapter
-
-//go:linkname procWintunOpenAdapter golang.zx2c4.com/wintun.procWintunOpenAdapter
-
-//go:linkname procWintunCloseAdapter golang.zx2c4.com/wintun.procWintunCloseAdapter
-
-//go:linkname procWintunDeleteDriver golang.zx2c4.com/wintun.procWintunDeleteDriver
-
-//go:linkname procWintunGetAdapterLUID golang.zx2c4.com/wintun.procWintunGetAdapterLUID
-
-//go:linkname procWintunGetRunningDriverVersion golang.zx2c4.com/wintun.procWintunGetRunningDriverVersion
-
-//go:linkname procWintunAllocateSendPacket golang.zx2c4.com/wintun.procWintunAllocateSendPacket
-
-//go:linkname procWintunEndSession golang.zx2c4.com/wintun.procWintunEndSession
-
-//go:linkname procWintunGetReadWaitEvent golang.zx2c4.com/wintun.procWintunGetReadWaitEvent
-
-//go:linkname procWintunReceivePacket golang.zx2c4.com/wintun.procWintunReceivePacket
-
-//go:linkname procWintunReleaseReceivePacket golang.zx2c4.com/wintun.procWintunReleaseReceivePacket
-
-//go:linkname procWintunSendPacket golang.zx2c4.com/wintun.procWintunSendPacket
-
-//go:linkname procWintunStartSession golang.zx2c4.com/wintun.procWintunStartSession
-
-var (
-	modwintun                         *lazyDLL
-	procWintunCreateAdapter           *lazyProc
-	procWintunOpenAdapter             *lazyProc
-	procWintunCloseAdapter            *lazyProc
-	procWintunDeleteDriver            *lazyProc
-	procWintunGetAdapterLUID          *lazyProc
-	procWintunGetRunningDriverVersion *lazyProc
-	procWintunAllocateSendPacket      *lazyProc
-	procWintunEndSession              *lazyProc
-	procWintunGetReadWaitEvent        *lazyProc
-	procWintunReceivePacket           *lazyProc
-	procWintunReleaseReceivePacket    *lazyProc
-	procWintunSendPacket              *lazyProc
-	procWintunStartSession            *lazyProc
-)
-
-type loggerLevel int
-
-const (
-	logInfo loggerLevel = iota
-	logWarn
-	logErr
-)
-
-func init() {
-	modwintun = newLazyDLL("wintun.dll", setupLogger)
-	procWintunCreateAdapter = modwintun.NewProc("WintunCreateAdapter")
-	procWintunOpenAdapter = modwintun.NewProc("WintunOpenAdapter")
-	procWintunCloseAdapter = modwintun.NewProc("WintunCloseAdapter")
-	procWintunDeleteDriver = modwintun.NewProc("WintunDeleteDriver")
-	procWintunGetAdapterLUID = modwintun.NewProc("WintunGetAdapterLUID")
-	procWintunGetRunningDriverVersion = modwintun.NewProc("WintunGetRunningDriverVersion")
-	procWintunAllocateSendPacket = modwintun.NewProc("WintunAllocateSendPacket")
-	procWintunEndSession = modwintun.NewProc("WintunEndSession")
-	procWintunGetReadWaitEvent = modwintun.NewProc("WintunGetReadWaitEvent")
-	procWintunReceivePacket = modwintun.NewProc("WintunReceivePacket")
-	procWintunReleaseReceivePacket = modwintun.NewProc("WintunReleaseReceivePacket")
-	procWintunSendPacket = modwintun.NewProc("WintunSendPacket")
-	procWintunStartSession = modwintun.NewProc("WintunStartSession")
-}
-
-func InitWintun() (err error) {
-	defer func() {
-		if r := recover(); r != nil {
-			err = fmt.Errorf("init wintun.dll error: %v", r)
-		}
-	}()
-
-	if err = modwintun.Load(); err != nil {
-		return
-	}
-
-	procWintunCreateAdapter.Addr()
-	procWintunOpenAdapter.Addr()
-	procWintunCloseAdapter.Addr()
-	procWintunDeleteDriver.Addr()
-	procWintunGetAdapterLUID.Addr()
-	procWintunGetRunningDriverVersion.Addr()
-	procWintunAllocateSendPacket.Addr()
-	procWintunEndSession.Addr()
-	procWintunGetReadWaitEvent.Addr()
-	procWintunReceivePacket.Addr()
-	procWintunReleaseReceivePacket.Addr()
-	procWintunSendPacket.Addr()
-	procWintunStartSession.Addr()
-
-	return
-}
-
-func newLazyDLL(name string, onLoad func(d *lazyDLL)) *lazyDLL {
-	return &lazyDLL{Name: name, onLoad: onLoad}
-}
-
-func logMessage(level loggerLevel, _ uint64, msg *uint16) int {
-	switch level {
-	case logInfo:
-		log.Infoln("[TUN] %s", windows.UTF16PtrToString(msg))
-	case logWarn:
-		log.Warnln("[TUN] %s", windows.UTF16PtrToString(msg))
-	case logErr:
-		log.Errorln("[TUN] %s", windows.UTF16PtrToString(msg))
-	default:
-		log.Debugln("[TUN] %s", windows.UTF16PtrToString(msg))
-	}
-	return 0
-}
-
-func setupLogger(dll *lazyDLL) {
-	var callback uintptr
-	if runtime.GOARCH == "386" {
-		callback = windows.NewCallback(func(level loggerLevel, _, _ uint32, msg *uint16) int {
-			return logMessage(level, 0, msg)
-		})
-	} else if runtime.GOARCH == "arm" {
-		callback = windows.NewCallback(func(level loggerLevel, _, _, _ uint32, msg *uint16) int {
-			return logMessage(level, 0, msg)
-		})
-	} else if runtime.GOARCH == "amd64" || runtime.GOARCH == "arm64" {
-		callback = windows.NewCallback(logMessage)
-	}
-	_, _, _ = syscall.SyscallN(dll.NewProc("WintunSetLogger").Addr(), callback)
-}
-
-func (d *lazyDLL) NewProc(name string) *lazyProc {
-	return &lazyProc{dll: d, Name: name}
-}
-
-type lazyProc struct {
-	Name string
-	mu   sync.Mutex
-	dll  *lazyDLL
-	addr uintptr
-}
-
-func (p *lazyProc) Find() error {
-	if atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&p.addr))) != nil {
-		return nil
-	}
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	if p.addr != 0 {
-		return nil
-	}
-
-	err := p.dll.Load()
-	if err != nil {
-		return fmt.Errorf("error loading DLL: %s, MODULE: %s, error: %w", p.dll.Name, p.Name, err)
-	}
-	addr, err := p.nameToAddr()
-	if err != nil {
-		return fmt.Errorf("error getting %s address: %w", p.Name, err)
-	}
-
-	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&p.addr)), unsafe.Pointer(addr))
-	return nil
-}
-
-func (p *lazyProc) Addr() uintptr {
-	err := p.Find()
-	if err != nil {
-		panic(err)
-	}
-	return p.addr
-}
-
-func (p *lazyProc) Load() error {
-	return p.dll.Load()
-}
-
-type lazyDLL struct {
-	Name   string
-	Base   windows.Handle
-	mu     sync.Mutex
-	module *memmod.Module
-	onLoad func(d *lazyDLL)
-}
-
-func (d *lazyDLL) Load() error {
-	if atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&d.module))) != nil {
-		return nil
-	}
-	d.mu.Lock()
-	defer d.mu.Unlock()
-	if d.module != nil {
-		return nil
-	}
-
-	module, err := memmod.LoadLibrary(dllContent)
-	if err != nil {
-		return fmt.Errorf("unable to load library: %w", err)
-	}
-	d.Base = windows.Handle(module.BaseAddr())
-
-	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&d.module)), unsafe.Pointer(module))
-	if d.onLoad != nil {
-		d.onLoad(d)
-	}
-	return nil
-}
-
-func (p *lazyProc) nameToAddr() (uintptr, error) {
-	return p.dll.module.ProcAddressByName(p.Name)
-}

listener/tun/device/tun/driver/dll_windows_386.go

@@ -1,13 +0,0 @@
-/* SPDX-License-Identifier: MIT
- *
- * Copyright (C) 2017-2021 WireGuard LLC. All Rights Reserved.
- */
-
-package driver
-
-import (
-	_ "embed"
-)
-
-//go:embed x86/wintun.dll
-var dllContent []byte

listener/tun/device/tun/driver/dll_windows_amd64.go

@@ -1,13 +0,0 @@
-/* SPDX-License-Identifier: MIT
- *
- * Copyright (C) 2017-2021 WireGuard LLC. All Rights Reserved.
- */
-
-package driver
-
-import (
-	_ "embed"
-)
-
-//go:embed amd64/wintun.dll
-var dllContent []byte