merge clash 1.9.0

# Conflicts:
#	.github/workflows/docker.yml
#	dns/server.go
#	go.mod
#	go.sum
#	hub/executor/executor.go
#	test/go.mod
#	test/go.sum

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,100 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: "[Bug]"
-labels: ''
-assignees: ''
-
----
-
-<!--
-感谢你向 Clash Core 提交 issue！
-在提交之前，请确认：
-
-- [ ] 如果你可以自己 debug 并解决的话，提交 PR 吧！
-- [ ] 我已经在 [Issue Tracker](……/) 中找过我要提出的问题
-- [ ] 我已经使用 dev 分支版本测试过，问题依旧存在
-- [ ] 我已经仔细看过 [Documentation](https://github.com/Dreamacro/clash/wiki/) 并无法自行解决问题
-- [ ] 这是 Clash 核心的问题，并非我所使用的 Clash 衍生版本（如 OpenClash、KoolClash 等）的特定问题
-
-请注意，如果你并没有遵照这个 issue template 填写内容，我们将直接关闭这个 issue。
-
-Thanks for opening an issue towards the Clash core!
-But before so, please do the following checklist:
-
-- [ ] Is this something you can **debug and fix**? Send a pull request! Bug fixes and documentation fixes are welcome.
-- [ ] I have searched on the [issue tracker](……/) for a related issue.
-- [ ] I have tested using the dev branch, and the issue still exists.
-- [ ] I have read the [documentation](https://github.com/Dreamacro/clash/wiki/) and was unable to solve the issue
-- [ ] This is an issue of the Clash core *per se*, not to the derivatives of Clash, like OpenClash or KoolClash
-
-Please understand that we close issues that fail to follow this issue template.
--->
-
-------------------------------------------------------------------
-
-<!-- 
-请附上任何可以帮助我们解决这个问题的信息，如果我们收到的信息不足，我们将对这个 issue 加上 *Needs more information* 标记并在收到更多资讯之前关闭 issue。
-Make sure to add **all the information needed to understand the bug** so that someone can help. If the info is missing we'll add the 'Needs more information' label and close the issue until there is enough information.
--->
-
-### Clash config
-<!--
-在下方附上 Clash core 脱敏后配置文件的内容
-Paste the Clash core configuration below.
--->
-<details>
-  <summary>config.yaml</summary>
-
-```yaml
-……
-```
-
-</details>
-
-### Clash log
-<!--
-在下方附上 Clash Core 的日志，log level 使用 DEBUG
-Paste the Clash core log below with the log level set to `DEBUG`.
--->
-```
-……
-```
-
-### 环境 Environment
-
-* 操作系统 (the OS that the Clash core is running on)
-……
-* 网路环境或拓扑 (network conditions/topology)
-……
-* iptables，如果适用 (if applicable)
-……
-* ISP 有没有进行 DNS 污染 (is your ISP performing DNS pollution?)
-……
-* 其他 (any other information that would be useful)
-……
-
-### 说明 Description
-
-<!--
-请详细、清晰地表达你要提出的论述，例如这个问题如何影响到你？你想实现什么功能？
--->
-
-### 重现问题的具体布骤 Steps to Reproduce
-
-1. [First Step]
-2. [Second Step]
-3. ……
-
-**我预期会发生……？**
-<!-- **Expected behavior:** [What you expected to happen] -->
-
-**实际上发生了什么？**
-<!-- **Actual behavior:** [What actually happened] -->
-
-### 可能的解决方案 Possible Solution
-<!-- 此项非必须，但是如果你有想法的话欢迎提出。 -->
-<!-- Not obligatory, but suggest a fix/reason for the bug, -->
-<!-- or ideas how to implement the addition or change -->
-
-### 更多信息 More Information

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,78 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: "[Feature]"
-labels: ''
-assignees: ''
-
----
-
-<!-- The English version is available. -->
-感谢你向 Clash Core 提交 Feature Request！
-在提交之前，请确认：
-
-- [ ] 我已经在 [Issue Tracker](……/) 中找过我要提出的请求
-
-请注意，如果你并没有遵照这个 issue template 填写内容，我们将直接关闭这个 issue。
-
-<!--
-Thanks for submitting a feature request towards the Clash core!
-But before so, please do the following checklist:
-
-- [ ] I have searched on the [issue tracker](……/) before creating the issue.
-
-Please understand that we close issues that fail to follow the issue template.
--->
-
-我都确认过了，我要继续提交。
-<!-- None of the above, create a feature request -->
-------------------------------------------------------------------
-
-请附上任何可以帮助我们解决这个问题的信息，如果我们收到的信息不足，我们将对这个 issue 加上 *Needs more information* 标记并在收到更多资讯之前关闭 issue。
-<!-- Make sure to add **all the information needed to understand the bug** so that someone can help. If the info is missing we'll add the 'Needs more information' label and close the issue until there is enough information. -->
-
-### Clash core config
-<!--
-在下方附上 Clash Core 脱敏后的配置内容
-Paste the Clash core configuration below.
--->
-```
-……
-```
-
-### Clash log
-<!--
-在下方附上 Clash Core 的日志，log level 请使用 DEBUG
-Paste the Clash core log below with the log level set to `DEBUG`.
--->
-```
-……
-```
-
-### 环境 Environment
-
-* Clash Core 的操作系统 (the OS that the Clash core is running on)
-……
-* 使用者的操作系统 (the OS running on the client)
-……
-* 网路环境或拓扑 (network conditions/topology)
-……
-* iptables，如果适用 (if applicable)
-……
-* ISP 有没有进行 DNS 污染 (is your ISP performing DNS pollution?)
-……
-* 其他
-……
-
-### 说明 Description
-
-<!--
-请详细、清晰地表达你要提出的论述，例如这个问题如何影响到你？你想实现什么功能？目前 Clash Core 的行为是什麽？
--->
-
-### 可能的解决方案 Possible Solution
-<!-- 此项非必须，但是如果你有想法的话欢迎提出。 -->
-<!-- Not obligatory, but suggest a fix/reason for the bug, -->
-<!-- or ideas how to implement the addition or change -->
-
-### 更多信息 More Information

.github/workflows/docker.yml

@@ -46,13 +46,13 @@ jobs:
         uses: docker/build-push-action@v2
         with:
           context: .
-          platforms: linux/amd64,linux/arm/v7,linux/arm64
+          platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64
           push: true
           tags: 'dreamacro/clash:dev,ghcr.io/dreamacro/clash:dev'
 
       - name: Get all docker tags
         if: startsWith(github.ref, 'refs/tags/')
-        uses: actions/github-script@v3
+        uses: actions/github-script@v4
         id: tags
         with:
           script: |
@@ -71,6 +71,6 @@ jobs:
         uses: docker/build-push-action@v2
         with:
           context: .
-          platforms: linux/amd64,linux/arm/v7,linux/arm64
+          platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64
           push: true
           tags: ${{steps.tags.outputs.result}}

.github/workflows/go.yml

@@ -1,47 +0,0 @@
-name: Go
-on: [push, pull_request]
-jobs:
-
-  build:
-    name: Build
-    runs-on: ubuntu-latest
-    steps:
-      - name: Setup Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: 1.16
-
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v2
-
-      - 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: Get dependencies, run test and static check
-        run: |
-          go test ./...
-          go vet ./...
-          go get -u honnef.co/go/tools/cmd/staticcheck
-          staticcheck -- $(go list ./...)
-
-      - name: Build
-        if: startsWith(github.ref, 'refs/tags/')
-        env:
-          NAME: clash
-          BINDIR: bin
-        run: make -j releases
-
-      - name: Upload Release
-        uses: softprops/action-gh-release@v1
-        if: startsWith(github.ref, 'refs/tags/')
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          files: bin/*
-          draft: true
-          prerelease: true

.github/workflows/stale.yml

@@ -1,19 +0,0 @@
-  
-name: Mark stale issues and pull requests
-
-on:
-  schedule:
-    - cron: "30 1 * * *"
-
-jobs:
-  stale:
-
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/stale@v3
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-          stale-issue-message: 'This issue is stale because it has been open 60 days with no activity. Remove stale label or comment or this will be closed in 5 days'
-          days-before-stale: 60
-          days-before-close: 5

.gitignore

@@ -12,7 +12,7 @@ bin/*
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 
-# dep
+# go mod vendor
 vendor
 
 # GoLand
@@ -20,3 +20,6 @@ vendor
 
 # macOS file
 .DS_Store
+
+# test suite
+test/config/cache*

Makefile

@@ -1,35 +1,32 @@
-NAME=clash
+NAME=Clash.Meta
 BINDIR=bin
 VERSION=$(shell git describe --tags || echo "unknown version")
 BUILDTIME=$(shell date -u)
+AUTOIPTABLES=Enable
 GOBUILD=CGO_ENABLED=0 go build -trimpath -ldflags '-X "github.com/Dreamacro/clash/constant.Version=$(VERSION)" \
 		-X "github.com/Dreamacro/clash/constant.BuildTime=$(BUILDTIME)" \
 		-w -s -buildid='
 
+GOBUILDOP=CGO_ENABLED=0 go build -trimpath -ldflags '-X "github.com/Dreamacro/clash/constant.Version=$(VERSION)" \
+		-X "github.com/Dreamacro/clash/constant.BuildTime=$(BUILDTIME)" \
+		-X "github.com/Dreamacro/clash/constant.AutoIptables=$(AUTOIPTABLES)"  \
+		-w -s -buildid='
+
 PLATFORM_LIST = \
 	darwin-amd64 \
 	darwin-arm64 \
-	linux-386 \
+	linux-arm64 \
 	linux-amd64 \
-	linux-armv5 \
-	linux-armv6 \
-	linux-armv7 \
-	linux-armv8 \
-	linux-mips-softfloat \
-	linux-mips-hardfloat \
-	linux-mipsle-softfloat \
-	linux-mipsle-hardfloat \
-	linux-mips64 \
-	linux-mips64le \
-	freebsd-386 \
-	freebsd-amd64
+	linux-arm64-AutoIptables\
+	linux-amd64-AutoIptables
+
 
 WINDOWS_ARCH_LIST = \
 	windows-386 \
-	windows-amd64 \
-	windows-arm32v7
+	windows-amd64
 
-all: linux-amd64 darwin-amd64 windows-amd64 # Most used
+
+all: linux-arm64-AutoIptables linux-amd64-AutoIptables linux-arm64 linux-amd64 darwin-amd64 darwin-arm64 windows-amd64 windows-386  # Most used
 
 docker:
 	$(GOBUILD) -o $(BINDIR)/$(NAME)-$@
@@ -46,18 +43,39 @@ linux-386:
 linux-amd64:
 	GOARCH=amd64 GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
 
+linux-amd64-AutoIptables:
+	GOARCH=amd64 GOOS=linux $(GOBUILDOP) -o $(BINDIR)/$(NAME)-$@
+
+linux-arm64:
+	GOARCH=arm64 GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
+
+linux-arm64-AutoIptables:
+	GOARCH=arm64 GOOS=linux $(GOBUILDOP) -o $(BINDIR)/$(NAME)-$@
+
 linux-armv5:
 	GOARCH=arm GOOS=linux GOARM=5 $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
 
+linux-armv5-AutoIptables:
+	GOARCH=arm GOOS=linux GOARM=5 $(GOBUILDOP) -o $(BINDIR)/$(NAME)-$@
+
 linux-armv6:
 	GOARCH=arm GOOS=linux GOARM=6 $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
 
+linux-armv6-AutoIptables:
+	GOARCH=arm GOOS=linux GOARM=6 $(GOBUILDOP) -o $(BINDIR)/$(NAME)-$@
+
 linux-armv7:
 	GOARCH=arm GOOS=linux GOARM=7 $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
 
+linux-armv7-AutoIptables:
+	GOARCH=arm GOOS=linux GOARM=7 $(GOBUILDOP) -o $(BINDIR)/$(NAME)-$@
+
 linux-armv8:
 	GOARCH=arm64 GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
 
+linux-armv8-AutoIptables:
+	GOARCH=arm64 GOOS=linux $(GOBUILDOP) -o $(BINDIR)/$(NAME)-$@
+
 linux-mips-softfloat:
 	GOARCH=mips GOMIPS=softfloat GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
 
@@ -82,12 +100,15 @@ freebsd-386:
 freebsd-amd64:
 	GOARCH=amd64 GOOS=freebsd $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
 
+freebsd-arm64:
+	GOARCH=arm64 GOOS=freebsd $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
+
 windows-386:
 	GOARCH=386 GOOS=windows $(GOBUILD) -o $(BINDIR)/$(NAME)-$@.exe
 
 windows-amd64:
 	GOARCH=amd64 GOOS=windows $(GOBUILD) -o $(BINDIR)/$(NAME)-$@.exe
-	
+
 windows-arm32v7:
 	GOARCH=arm GOOS=windows GOARM=7 $(GOBUILD) -o $(BINDIR)/$(NAME)-$@.exe
 
@@ -105,4 +126,4 @@ all-arch: $(PLATFORM_LIST) $(WINDOWS_ARCH_LIST)
 
 releases: $(gz_releases) $(zip_releases)
 clean:
-	rm $(BINDIR)/*
+	rm $(BINDIR)/*

README.md

@@ -1,19 +1,20 @@
 <h1 align="center">
-  <img src="https://github.com/Dreamacro/clash/raw/master/docs/logo.png" alt="Clash" width="200">
-  <br>Clash<br>
+  <img src="Meta.png" alt="Meta Kennel" width="200">
+  <br>Meta Kennel<br>
 </h1>
 
-<h4 align="center">A rule-based tunnel in Go.</h4>
+<h3 align="center">Another Clash Kennel.</h3>
 
 <p align="center">
-  <a href="https://github.com/Dreamacro/clash/actions">
-    <img src="https://img.shields.io/github/workflow/status/Dreamacro/clash/Go?style=flat-square" alt="Github Actions">
+  <a href="https://goreportcard.com/report/github.com/Clash-Mini/Clash.Meta">
+    <img src="https://goreportcard.com/badge/github.com/Clash-Mini/Clash.Meta?style=flat-square">
   </a>
-  <a href="https://goreportcard.com/report/github.com/Dreamacro/clash">
-    <img src="https://goreportcard.com/badge/github.com/Dreamacro/clash?style=flat-square">
+  <img src="https://img.shields.io/github/go-mod/go-version/Dreamacro/clash?style=flat-square">
+  <a href="https://github.com/Clash-Mini/Clash.Meta/releases">
+    <img src="https://img.shields.io/github/release/Clash-Mini/Clash.Meta/all.svg?style=flat-square">
   </a>
-  <a href="https://github.com/Dreamacro/clash/releases">
-    <img src="https://img.shields.io/github/release/Dreamacro/clash/all.svg?style=flat-square">
+  <a href="https://github.com/Clash-Mini/Clash.Meta">
+    <img src="https://img.shields.io/badge/release-Meta-00b4f0?style=flat-square">
   </a>
 </p>
 
@@ -22,39 +23,197 @@
 - Local HTTP/HTTPS/SOCKS server with authentication support
 - VMess, Shadowsocks, Trojan, Snell protocol support for remote connections
 - Built-in DNS server that aims to minimize DNS pollution attack impact, supports DoH/DoT upstream and fake IP.
-- Rules based off domains, GEOIP, IP CIDR or ports to forward packets to different nodes
+- Rules based off domains, GEOIP, IPCIDR or Process to forward packets to different nodes
 - Remote groups allow users to implement powerful rules. Supports automatic fallback, load balancing or auto select node based off latency
 - Remote providers, allowing users to get node lists remotely instead of hardcoding in config
 - Netfilter TCP redirecting. Deploy Clash on your Internet gateway with `iptables`.
 - Comprehensive HTTP RESTful API controller
 
-## Premium Features
-
-- TUN mode on macOS, Linux and Windows. [Doc](https://github.com/Dreamacro/clash/wiki/premium-core-features#tun-device)
-- Match your tunnel by [Script](https://github.com/Dreamacro/clash/wiki/premium-core-features#script)
-- [Rule Provider](https://github.com/Dreamacro/clash/wiki/premium-core-features#rule-providers)
-
 ## Getting Started
 Documentations are now moved to [GitHub Wiki](https://github.com/Dreamacro/clash/wiki).
 
-## Premium Release
-[Release](https://github.com/Dreamacro/clash/releases/tag/premium)
+## Advanced usage for this branch
+### DNS configuration
+Support resolve ip with a proxy tunnel.
+
+Support `geosite` with `fallback-filter`.
+```yaml
+dns:
+  enable: true
+  use-hosts: true
+  ipv6: false
+  enhanced-mode: fake-ip
+  fake-ip-range: 198.18.0.1/16
+  listen: 127.0.0.1:6868
+  default-nameserver:
+    - 119.29.29.29
+    - 114.114.114.114
+  nameserver:
+    - https://doh.pub/dns-query
+    - tls://223.5.5.5:853
+  fallback:
+    - 'https://1.0.0.1/dns-query#Proxy'  # append the proxy adapter name to the end of DNS URL with '#' prefix.
+    - 'tls://8.8.4.4:853#Proxy'
+  fallback-filter:
+    geoip: false
+    geosite:
+      - gfw  # `geosite` filter only use fallback server to resolve ip, prevent DNS leaks to unsafe DNS providers.
+    domain:
+      - +.example.com
+    ipcidr:
+      - 0.0.0.0/32
+```
+
+### TUN configuration
+
+Supports macOS, Linux and Windows.
+
+Built-in [Wintun](https://www.wintun.net) driver.
+
+```yaml
+# Enable the TUN listener
+tun:
+  enable: true
+  stack: gvisor #  system or gvisor
+  dns-listen: 0.0.0.0:53 # additional dns server listen on TUN
+  auto-route: true # auto set global route
+```
+### Rules configuration
+- Support rule `GEOSITE`.
+- Support rule-providers `RULE-SET`.
+- Support `multiport` condition for rule `SRC-PORT` and `DST-PORT`.
+- Support `network` condition for all rules.
+- Support source IPCIDR condition for all rules, just append to the end.
+- The `GEOSITE` databases via https://github.com/Loyalsoldier/v2ray-rules-dat.
+```yaml
+rules:
+
+  # network(tcp/udp) condition for all rules
+  - DOMAIN-SUFFIX,bilibili.com,DIRECT,tcp
+  - DOMAIN-SUFFIX,bilibili.com,REJECT,udp
+    
+  # multiport condition for rules SRC-PORT and DST-PORT
+  - DST-PORT,123/136/137-139,DIRECT,udp
+  
+  # rule GEOSITE
+  - GEOSITE,category-ads-all,REJECT
+  - GEOSITE,icloud@cn,DIRECT
+  - GEOSITE,apple@cn,DIRECT
+  - GEOSITE,apple-cn,DIRECT
+  - GEOSITE,microsoft@cn,DIRECT
+  - GEOSITE,facebook,PROXY
+  - GEOSITE,youtube,PROXY
+  - GEOSITE,geolocation-cn,DIRECT
+  - GEOSITE,geolocation-!cn,PROXY
+    
+  # source IPCIDR condition for all rules in gateway proxy
+  #- GEOSITE,geolocation-!cn,REJECT,192.168.1.88/32,192.168.1.99/32
+
+  - GEOIP,telegram,PROXY,no-resolve
+  - GEOIP,private,DIRECT,no-resolve
+  - GEOIP,cn,DIRECT
+  
+  - MATCH,PROXY
+```
+
+
+### Proxies configuration
+Support outbound transport protocol `VLESS`.
+
+The XTLS only support TCP transport by the XRAY-CORE.
+```yaml
+proxies:
+  - name: "vless-tcp"
+    type: vless
+    server: server
+    port: 443
+    uuid: uuid
+    network: tcp
+    servername: example.com # AKA SNI
+    # flow: xtls-rprx-direct # xtls-rprx-origin  # enable XTLS
+    # skip-cert-verify: true
+    
+  - name: "vless-ws"
+    type: vless
+    server: server
+    port: 443
+    uuid: uuid
+    udp: true
+    network: ws
+    servername: example.com # priority over wss host
+    # skip-cert-verify: true
+    ws-path: /path
+    ws-headers:
+      Host: example.com
+```
+
+### IPTABLES auto-configuration
+Only work on Linux OS who support `iptables`, Clash will auto-configuration iptables for tproxy listener when `tproxy-port` value isn't zero.
+
+If `TPROXY` is enabled, the `TUN` must be disabled.
+```yaml
+# Enable the TPROXY listener
+tproxy-port: 9898
+# Disable the TUN listener
+tun:
+  enable: false
+```
+Create user given name `Clash.Meta`.
+
+Run Meta Kennel by user `Clash.Meta` as a daemon.
+
+Create the systemd configuration file at /etc/systemd/system/clash.service:
+
+```
+[Unit]
+Description=Clash.Meta Daemon, Another Clash Kennel.
+After=network.target
+
+[Service]
+Type=simple
+User=Clash.Meta
+Group=Clash.Meta
+CapabilityBoundingSet=cap_net_admin
+AmbientCapabilities=cap_net_admin
+Restart=always
+ExecStart=/usr/local/bin/Clash.Meta -d /etc/Clash.Meta
+
+[Install]
+WantedBy=multi-user.target
+```
+Launch clashd on system startup with:
+```shell
+$ systemctl enable Clash.Meta
+```
+Launch clashd immediately with:
+
+```shell
+$ systemctl start Clash.Meta
+```
+
+### Display Process name
+
+Clash add field `Process` to `Metadata` and prepare to get process name for Restful API `GET /connections`.
+
+To display process name in GUI please use [Dashboard For Meta](https://github.com/Clash-Mini/Dashboard).
+
+![img.png](https://github.com/Clash-Mini/Dashboard/raw/master/View/Dashboard-Process.png)
+
+## Development
+
+If you want to build an application that uses clash as a library, check out the
+the [GitHub Wiki](https://github.com/Dreamacro/clash/wiki/use-clash-as-a-library)
 
 ## Credits
 
+* [Dreamacro/clash](https://github.com/Dreamacro/clash)
 * [riobard/go-shadowsocks2](https://github.com/riobard/go-shadowsocks2)
 * [v2ray/v2ray-core](https://github.com/v2ray/v2ray-core)
+* [WireGuard/wireguard-go](https://github.com/WireGuard/wireguard-go)
+* [yaling888/clash-plus-pro](https://github.com/yaling888/clash)
 
 ## License
 
 This software is released under the GPL-3.0 license.
 
 [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2FDreamacro%2Fclash.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2FDreamacro%2Fclash?ref=badge_large)
-
-## TODO
-
-- [x] Complementing the necessary rule operators
-- [x] Redir proxy
-- [x] UDP support
-- [x] Connection manager
-- [ ] ~~Event API~~

adapter/adapter.go

@@ -1,97 +1,22 @@
-package outbound
+package adapter
 
 import (
 	"context"
 	"encoding/json"
-	"errors"
+	"fmt"
 	"net"
 	"net/http"
+	"net/url"
 	"time"
 
 	"github.com/Dreamacro/clash/common/queue"
+	"github.com/Dreamacro/clash/component/dialer"
 	C "github.com/Dreamacro/clash/constant"
 
 	"go.uber.org/atomic"
 )
 
-type Base struct {
-	name string
-	addr string
-	tp   C.AdapterType
-	udp  bool
-}
-
-func (b *Base) Name() string {
-	return b.name
-}
-
-func (b *Base) Type() C.AdapterType {
-	return b.tp
-}
-
-func (b *Base) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
-	return c, errors.New("no support")
-}
-
-func (b *Base) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
-	return nil, errors.New("no support")
-}
-
-func (b *Base) SupportUDP() bool {
-	return b.udp
-}
-
-func (b *Base) MarshalJSON() ([]byte, error) {
-	return json.Marshal(map[string]string{
-		"type": b.Type().String(),
-	})
-}
-
-func (b *Base) Addr() string {
-	return b.addr
-}
-
-func (b *Base) Unwrap(metadata *C.Metadata) C.Proxy {
-	return nil
-}
-
-func NewBase(name string, addr string, tp C.AdapterType, udp bool) *Base {
-	return &Base{name, addr, tp, udp}
-}
-
-type conn struct {
-	net.Conn
-	chain C.Chain
-}
-
-func (c *conn) Chains() C.Chain {
-	return c.chain
-}
-
-func (c *conn) AppendToChains(a C.ProxyAdapter) {
-	c.chain = append(c.chain, a.Name())
-}
-
-func NewConn(c net.Conn, a C.ProxyAdapter) C.Conn {
-	return &conn{c, []string{a.Name()}}
-}
-
-type packetConn struct {
-	net.PacketConn
-	chain C.Chain
-}
-
-func (c *packetConn) Chains() C.Chain {
-	return c.chain
-}
-
-func (c *packetConn) AppendToChains(a C.ProxyAdapter) {
-	c.chain = append(c.chain, a.Name())
-}
-
-func newPacketConn(pc net.PacketConn, a C.ProxyAdapter) C.PacketConn {
-	return &packetConn{pc, []string{a.Name()}}
-}
+var UnifiedDelay = atomic.NewBool(false)
 
 type Proxy struct {
 	C.ProxyAdapter
@@ -99,24 +24,40 @@ type Proxy struct {
 	alive   *atomic.Bool
 }
 
+// Alive implements C.Proxy
 func (p *Proxy) Alive() bool {
 	return p.alive.Load()
 }
 
+// Dial implements C.Proxy
 func (p *Proxy) Dial(metadata *C.Metadata) (C.Conn, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), tcpTimeout)
+	ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTCPTimeout)
 	defer cancel()
 	return p.DialContext(ctx, metadata)
 }
 
-func (p *Proxy) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
-	conn, err := p.ProxyAdapter.DialContext(ctx, metadata)
-	if err != nil {
-		p.alive.Store(false)
-	}
+// DialContext implements C.ProxyAdapter
+func (p *Proxy) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.Conn, error) {
+	conn, err := p.ProxyAdapter.DialContext(ctx, metadata, opts...)
+	p.alive.Store(err == nil)
 	return conn, err
 }
 
+// DialUDP implements C.ProxyAdapter
+func (p *Proxy) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), C.DefaultUDPTimeout)
+	defer cancel()
+	return p.ListenPacketContext(ctx, metadata)
+}
+
+// ListenPacketContext implements C.ProxyAdapter
+func (p *Proxy) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.PacketConn, error) {
+	pc, err := p.ProxyAdapter.ListenPacketContext(ctx, metadata, opts...)
+	p.alive.Store(err == nil)
+	return pc, err
+}
+
+// DelayHistory implements C.Proxy
 func (p *Proxy) DelayHistory() []C.DelayHistory {
 	queue := p.history.Copy()
 	histories := []C.DelayHistory{}
@@ -127,6 +68,7 @@ func (p *Proxy) DelayHistory() []C.DelayHistory {
 }
 
 // LastDelay return last history record. if proxy is not alive, return the max value of uint16.
+// implements C.Proxy
 func (p *Proxy) LastDelay() (delay uint16) {
 	var max uint16 = 0xffff
 	if !p.alive.Load() {
@@ -144,6 +86,7 @@ func (p *Proxy) LastDelay() (delay uint16) {
 	return history.Delay
 }
 
+// MarshalJSON implements C.ProxyAdapter
 func (p *Proxy) MarshalJSON() ([]byte, error) {
 	inner, err := p.ProxyAdapter.MarshalJSON()
 	if err != nil {
@@ -154,10 +97,12 @@ func (p *Proxy) MarshalJSON() ([]byte, error) {
 	json.Unmarshal(inner, &mapping)
 	mapping["history"] = p.DelayHistory()
 	mapping["name"] = p.Name()
+	mapping["udp"] = p.SupportUDP()
 	return json.Marshal(mapping)
 }
 
 // URLTest get the delay for the specified URL
+// implements C.Proxy
 func (p *Proxy) URLTest(ctx context.Context, url string) (t uint16, err error) {
 	defer func() {
 		p.alive.Store(err == nil)
@@ -171,6 +116,8 @@ func (p *Proxy) URLTest(ctx context.Context, url string) (t uint16, err error) {
 		}
 	}()
 
+	unifiedDelay := UnifiedDelay.Load()
+
 	addr, err := urlToMetadata(url)
 	if err != nil {
 		return
@@ -206,10 +153,20 @@ func (p *Proxy) URLTest(ctx context.Context, url string) (t uint16, err error) {
 			return http.ErrUseLastResponse
 		},
 	}
+	defer client.CloseIdleConnections()
 	resp, err := client.Do(req)
 	if err != nil {
 		return
 	}
+
+	if unifiedDelay {
+		start = time.Now()
+		resp, err = client.Do(req)
+		if err != nil {
+			return
+		}
+	}
+
 	resp.Body.Close()
 	t = uint16(time.Since(start) / time.Millisecond)
 	return
@@ -218,3 +175,31 @@ func (p *Proxy) URLTest(ctx context.Context, url string) (t uint16, err error) {
 func NewProxy(adapter C.ProxyAdapter) *Proxy {
 	return &Proxy{adapter, queue.New(10), atomic.NewBool(true)}
 }
+
+func urlToMetadata(rawURL string) (addr C.Metadata, err error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return
+	}
+
+	port := u.Port()
+	if port == "" {
+		switch u.Scheme {
+		case "https":
+			port = "443"
+		case "http":
+			port = "80"
+		default:
+			err = fmt.Errorf("%s scheme not Support", rawURL)
+			return
+		}
+	}
+
+	addr = C.Metadata{
+		AddrType: C.AtypDomainName,
+		Host:     u.Hostname(),
+		DstIP:    nil,
+		DstPort:  port,
+	}
+	return
+}

adapter/inbound/http.go

@@ -0,0 +1,21 @@
+package inbound
+
+import (
+	"net"
+
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/context"
+	"github.com/Dreamacro/clash/transport/socks5"
+)
+
+// NewHTTP receive normal http request and return HTTPContext
+func NewHTTP(target socks5.Addr, source net.Addr, conn net.Conn) *context.ConnContext {
+	metadata := parseSocksAddr(target)
+	metadata.NetWork = C.TCP
+	metadata.Type = C.HTTP
+	if ip, port, err := parseAddr(source.String()); err == nil {
+		metadata.SrcIP = ip
+		metadata.SrcPort = port
+	}
+	return context.NewConnContext(conn, metadata)
+}

adapter/inbound/https.go

@@ -8,7 +8,7 @@ import (
 	"github.com/Dreamacro/clash/context"
 )
 
-// NewHTTPS recieve CONNECT request and return ConnContext
+// NewHTTPS receive CONNECT request and return ConnContext
 func NewHTTPS(request *http.Request, conn net.Conn) *context.ConnContext {
 	metadata := parseHTTPAddr(request)
 	metadata.Type = C.HTTPCONNECT

adapter/inbound/packet.go

@@ -1,8 +1,8 @@
 package inbound
 
 import (
-	"github.com/Dreamacro/clash/component/socks5"
 	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/transport/socks5"
 )
 
 // PacketAdapter is a UDP Packet adapter for socks/redir/tun

adapter/inbound/socket.go

@@ -3,12 +3,12 @@ package inbound
 import (
 	"net"
 
-	"github.com/Dreamacro/clash/component/socks5"
 	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/context"
+	"github.com/Dreamacro/clash/transport/socks5"
 )
 
-// NewSocket recieve TCP inbound and return ConnContext
+// NewSocket receive TCP inbound and return ConnContext
 func NewSocket(target socks5.Addr, conn net.Conn, source C.Type) *context.ConnContext {
 	metadata := parseSocksAddr(target)
 	metadata.NetWork = C.TCP

adapter/inbound/util.go

@@ -6,8 +6,8 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/Dreamacro/clash/component/socks5"
 	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/transport/socks5"
 )
 
 func parseSocksAddr(target socks5.Addr) *C.Metadata {

adapter/outbound/base.go

@@ -0,0 +1,138 @@
+package outbound
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net"
+
+	"github.com/Dreamacro/clash/component/dialer"
+	C "github.com/Dreamacro/clash/constant"
+)
+
+type Base struct {
+	name  string
+	addr  string
+	iface string
+	tp    C.AdapterType
+	udp   bool
+	rmark int
+}
+
+// Name implements C.ProxyAdapter
+func (b *Base) Name() string {
+	return b.name
+}
+
+// Type implements C.ProxyAdapter
+func (b *Base) Type() C.AdapterType {
+	return b.tp
+}
+
+// StreamConn implements C.ProxyAdapter
+func (b *Base) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
+	return c, 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")
+}
+
+// SupportUDP implements C.ProxyAdapter
+func (b *Base) SupportUDP() bool {
+	return b.udp
+}
+
+// MarshalJSON implements C.ProxyAdapter
+func (b *Base) MarshalJSON() ([]byte, error) {
+	return json.Marshal(map[string]string{
+		"type": b.Type().String(),
+	})
+}
+
+// Addr implements C.ProxyAdapter
+func (b *Base) Addr() string {
+	return b.addr
+}
+
+// Unwrap implements C.ProxyAdapter
+func (b *Base) Unwrap(metadata *C.Metadata) C.Proxy {
+	return nil
+}
+
+// DialOptions return []dialer.Option from struct
+func (b *Base) DialOptions(opts ...dialer.Option) []dialer.Option {
+	if b.iface != "" {
+		opts = append(opts, dialer.WithInterface(b.iface))
+	}
+
+	if b.rmark != 0 {
+		opts = append(opts, dialer.WithRoutingMark(b.rmark))
+	}
+
+	return opts
+}
+
+type BasicOption struct {
+	Interface   string `proxy:"interface-name,omitempty" group:"interface-name,omitempty"`
+	RoutingMark int    `proxy:"routing-mark,omitempty" group:"routing-mark,omitempty"`
+}
+
+type BaseOption struct {
+	Name        string
+	Addr        string
+	Type        C.AdapterType
+	UDP         bool
+	Interface   string
+	RoutingMark int
+}
+
+func NewBase(opt BaseOption) *Base {
+	return &Base{
+		name:  opt.Name,
+		addr:  opt.Addr,
+		tp:    opt.Type,
+		udp:   opt.UDP,
+		iface: opt.Interface,
+		rmark: opt.RoutingMark,
+	}
+}
+
+type conn struct {
+	net.Conn
+	chain C.Chain
+}
+
+// Chains implements C.Connection
+func (c *conn) Chains() C.Chain {
+	return c.chain
+}
+
+// AppendToChains implements C.Connection
+func (c *conn) AppendToChains(a C.ProxyAdapter) {
+	c.chain = append(c.chain, a.Name())
+}
+
+func NewConn(c net.Conn, a C.ProxyAdapter) C.Conn {
+	return &conn{c, []string{a.Name()}}
+}
+
+type packetConn struct {
+	net.PacketConn
+	chain C.Chain
+}
+
+// Chains implements C.Connection
+func (c *packetConn) Chains() C.Chain {
+	return c.chain
+}
+
+// AppendToChains implements C.Connection
+func (c *packetConn) AppendToChains(a C.ProxyAdapter) {
+	c.chain = append(c.chain, a.Name())
+}
+
+func newPacketConn(pc net.PacketConn, a C.ProxyAdapter) C.PacketConn {
+	return &packetConn{pc, []string{a.Name()}}
+}

adapter/outbound/direct.go

@@ -12,10 +12,9 @@ type Direct struct {
 	*Base
 }
 
-func (d *Direct) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
-	address := net.JoinHostPort(metadata.String(), metadata.DstPort)
-
-	c, err := dialer.DialContext(ctx, "tcp", address)
+// DialContext implements C.ProxyAdapter
+func (d *Direct) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.Conn, error) {
+	c, err := dialer.DialContext(ctx, "tcp", metadata.RemoteAddress(), d.Base.DialOptions(opts...)...)
 	if err != nil {
 		return nil, err
 	}
@@ -23,8 +22,9 @@ func (d *Direct) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn,
 	return NewConn(c, d), nil
 }
 
-func (d *Direct) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
-	pc, err := dialer.ListenPacket("udp", "")
+// ListenPacketContext implements C.ProxyAdapter
+func (d *Direct) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.PacketConn, error) {
+	pc, err := dialer.ListenPacket(ctx, "udp", "", d.Base.DialOptions(opts...)...)
 	if err != nil {
 		return nil, err
 	}

adapter/outbound/http.go

@@ -25,6 +25,7 @@ type Http struct {
 }
 
 type HttpOption struct {
+	BasicOption
 	Name           string `proxy:"name"`
 	Server         string `proxy:"server"`
 	Port           int    `proxy:"port"`
@@ -35,6 +36,7 @@ type HttpOption struct {
 	SkipCertVerify bool   `proxy:"skip-cert-verify,omitempty"`
 }
 
+// StreamConn implements C.ProxyAdapter
 func (h *Http) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
 	if h.tlsConfig != nil {
 		cc := tls.Client(c, h.tlsConfig)
@@ -51,13 +53,16 @@ func (h *Http) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
 	return c, nil
 }
 
-func (h *Http) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
-	c, err := dialer.DialContext(ctx, "tcp", h.addr)
+// DialContext implements C.ProxyAdapter
+func (h *Http) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (_ C.Conn, err error) {
+	c, err := dialer.DialContext(ctx, "tcp", h.addr, h.Base.DialOptions(opts...)...)
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error: %w", h.addr, err)
 	}
 	tcpKeepAlive(c)
 
+	defer safeConnClose(c, err)
+
 	c, err = h.StreamConn(c, metadata)
 	if err != nil {
 		return nil, err
@@ -121,16 +126,16 @@ func NewHttp(option HttpOption) *Http {
 		}
 		tlsConfig = &tls.Config{
 			InsecureSkipVerify: option.SkipCertVerify,
-			ClientSessionCache: getClientSessionCache(),
 			ServerName:         sni,
 		}
 	}
 
 	return &Http{
 		Base: &Base{
-			name: option.Name,
-			addr: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
-			tp:   C.Http,
+			name:  option.Name,
+			addr:  net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
+			tp:    C.Http,
+			iface: option.Interface,
 		},
 		user:      option.UserName,
 		pass:      option.Password,

adapter/outbound/reject.go

@@ -0,0 +1,62 @@
+package outbound
+
+import (
+	"context"
+	"io"
+	"net"
+	"time"
+
+	"github.com/Dreamacro/clash/component/dialer"
+	C "github.com/Dreamacro/clash/constant"
+)
+
+type Reject struct {
+	*Base
+}
+
+// DialContext implements C.ProxyAdapter
+func (r *Reject) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.Conn, error) {
+	return NewConn(&nopConn{}, r), nil
+}
+
+// ListenPacketContext implements C.ProxyAdapter
+func (r *Reject) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.PacketConn, error) {
+	return newPacketConn(&nopPacketConn{}, r), nil
+}
+
+func NewReject() *Reject {
+	return &Reject{
+		Base: &Base{
+			name: "REJECT",
+			tp:   C.Reject,
+			udp:  true,
+		},
+	}
+}
+
+type nopConn struct{}
+
+func (rw *nopConn) Read(b []byte) (int, error) {
+	return 0, io.EOF
+}
+
+func (rw *nopConn) Write(b []byte) (int, error) {
+	return 0, io.EOF
+}
+
+func (rw *nopConn) Close() error                     { return nil }
+func (rw *nopConn) LocalAddr() net.Addr              { return nil }
+func (rw *nopConn) RemoteAddr() net.Addr             { return nil }
+func (rw *nopConn) SetDeadline(time.Time) error      { return nil }
+func (rw *nopConn) SetReadDeadline(time.Time) error  { return nil }
+func (rw *nopConn) SetWriteDeadline(time.Time) error { return nil }
+
+type nopPacketConn struct{}
+
+func (npc *nopPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) { return len(b), nil }
+func (npc *nopPacketConn) ReadFrom(b []byte) (int, net.Addr, error)           { return 0, nil, io.EOF }
+func (npc *nopPacketConn) Close() error                                       { return nil }
+func (npc *nopPacketConn) LocalAddr() net.Addr                                { return &net.UDPAddr{IP: net.IPv4zero, Port: 0} }
+func (npc *nopPacketConn) SetDeadline(time.Time) error                        { return nil }
+func (npc *nopPacketConn) SetReadDeadline(time.Time) error                    { return nil }
+func (npc *nopPacketConn) SetWriteDeadline(time.Time) error                   { return nil }

adapter/outbound/shadowsocks.go

@@ -2,7 +2,6 @@ package outbound
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"net"
@@ -10,10 +9,10 @@ import (
 
 	"github.com/Dreamacro/clash/common/structure"
 	"github.com/Dreamacro/clash/component/dialer"
-	obfs "github.com/Dreamacro/clash/component/simple-obfs"
-	"github.com/Dreamacro/clash/component/socks5"
-	v2rayObfs "github.com/Dreamacro/clash/component/v2ray-plugin"
 	C "github.com/Dreamacro/clash/constant"
+	obfs "github.com/Dreamacro/clash/transport/simple-obfs"
+	"github.com/Dreamacro/clash/transport/socks5"
+	v2rayObfs "github.com/Dreamacro/clash/transport/v2ray-plugin"
 
 	"github.com/Dreamacro/go-shadowsocks2/core"
 )
@@ -29,6 +28,7 @@ type ShadowSocks struct {
 }
 
 type ShadowSocksOption struct {
+	BasicOption
 	Name       string                 `proxy:"name"`
 	Server     string                 `proxy:"server"`
 	Port       int                    `proxy:"port"`
@@ -54,6 +54,7 @@ type v2rayObfsOption struct {
 	Mux            bool              `obfs:"mux,omitempty"`
 }
 
+// StreamConn implements C.ProxyAdapter
 func (ss *ShadowSocks) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
 	switch ss.obfsMode {
 	case "tls":
@@ -73,25 +74,30 @@ func (ss *ShadowSocks) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, e
 	return c, err
 }
 
-func (ss *ShadowSocks) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
-	c, err := dialer.DialContext(ctx, "tcp", ss.addr)
+// DialContext implements C.ProxyAdapter
+func (ss *ShadowSocks) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (_ C.Conn, err error) {
+	c, err := dialer.DialContext(ctx, "tcp", ss.addr, ss.Base.DialOptions(opts...)...)
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error: %w", ss.addr, err)
 	}
 	tcpKeepAlive(c)
 
+	defer safeConnClose(c, err)
+
 	c, err = ss.StreamConn(c, metadata)
 	return NewConn(c, ss), err
 }
 
-func (ss *ShadowSocks) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
-	pc, err := dialer.ListenPacket("udp", "")
+// ListenPacketContext implements C.ProxyAdapter
+func (ss *ShadowSocks) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.PacketConn, error) {
+	pc, err := dialer.ListenPacket(ctx, "udp", "", ss.Base.DialOptions(opts...)...)
 	if err != nil {
 		return nil, err
 	}
 
 	addr, err := resolveUDPAddr("udp", ss.addr)
 	if err != nil {
+		pc.Close()
 		return nil, err
 	}
 
@@ -99,12 +105,6 @@ func (ss *ShadowSocks) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
 	return newPacketConn(&ssPacketConn{PacketConn: pc, rAddr: addr}, ss), nil
 }
 
-func (ss *ShadowSocks) MarshalJSON() ([]byte, error) {
-	return json.Marshal(map[string]string{
-		"type": ss.Type().String(),
-	})
-}
-
 func NewShadowSocks(option ShadowSocksOption) (*ShadowSocks, error) {
 	addr := net.JoinHostPort(option.Server, strconv.Itoa(option.Port))
 	cipher := option.Cipher
@@ -150,16 +150,16 @@ func NewShadowSocks(option ShadowSocksOption) (*ShadowSocks, error) {
 		if opts.TLS {
 			v2rayOption.TLS = true
 			v2rayOption.SkipCertVerify = opts.SkipCertVerify
-			v2rayOption.SessionCache = getClientSessionCache()
 		}
 	}
 
 	return &ShadowSocks{
 		Base: &Base{
-			name: option.Name,
-			addr: addr,
-			tp:   C.Shadowsocks,
-			udp:  option.UDP,
+			name:  option.Name,
+			addr:  addr,
+			tp:    C.Shadowsocks,
+			udp:   option.UDP,
+			iface: option.Interface,
 		},
 		cipher: ciph,
 

adapter/outbound/shadowsocksr.go

@@ -2,15 +2,15 @@ package outbound
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"net"
 	"strconv"
 
 	"github.com/Dreamacro/clash/component/dialer"
-	"github.com/Dreamacro/clash/component/ssr/obfs"
-	"github.com/Dreamacro/clash/component/ssr/protocol"
 	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/transport/ssr/obfs"
+	"github.com/Dreamacro/clash/transport/ssr/protocol"
+
 	"github.com/Dreamacro/go-shadowsocks2/core"
 	"github.com/Dreamacro/go-shadowsocks2/shadowaead"
 	"github.com/Dreamacro/go-shadowsocks2/shadowstream"
@@ -24,6 +24,7 @@ type ShadowSocksR struct {
 }
 
 type ShadowSocksROption struct {
+	BasicOption
 	Name          string `proxy:"name"`
 	Server        string `proxy:"server"`
 	Port          int    `proxy:"port"`
@@ -36,6 +37,7 @@ type ShadowSocksROption struct {
 	UDP           bool   `proxy:"udp,omitempty"`
 }
 
+// StreamConn implements C.ProxyAdapter
 func (ssr *ShadowSocksR) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
 	c = ssr.obfs.StreamConn(c)
 	c = ssr.cipher.StreamConn(c)
@@ -57,25 +59,30 @@ func (ssr *ShadowSocksR) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn,
 	return c, err
 }
 
-func (ssr *ShadowSocksR) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
-	c, err := dialer.DialContext(ctx, "tcp", ssr.addr)
+// DialContext implements C.ProxyAdapter
+func (ssr *ShadowSocksR) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (_ C.Conn, err error) {
+	c, err := dialer.DialContext(ctx, "tcp", ssr.addr, ssr.Base.DialOptions(opts...)...)
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error: %w", ssr.addr, err)
 	}
 	tcpKeepAlive(c)
 
+	defer safeConnClose(c, err)
+
 	c, err = ssr.StreamConn(c, metadata)
 	return NewConn(c, ssr), err
 }
 
-func (ssr *ShadowSocksR) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
-	pc, err := dialer.ListenPacket("udp", "")
+// ListenPacketContext implements C.ProxyAdapter
+func (ssr *ShadowSocksR) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.PacketConn, error) {
+	pc, err := dialer.ListenPacket(ctx, "udp", "", ssr.Base.DialOptions(opts...)...)
 	if err != nil {
 		return nil, err
 	}
 
 	addr, err := resolveUDPAddr("udp", ssr.addr)
 	if err != nil {
+		pc.Close()
 		return nil, err
 	}
 
@@ -84,12 +91,6 @@ func (ssr *ShadowSocksR) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
 	return newPacketConn(&ssPacketConn{PacketConn: pc, rAddr: addr}, ssr), nil
 }
 
-func (ssr *ShadowSocksR) MarshalJSON() ([]byte, error) {
-	return json.Marshal(map[string]string{
-		"type": ssr.Type().String(),
-	})
-}
-
 func NewShadowSocksR(option ShadowSocksROption) (*ShadowSocksR, error) {
 	addr := net.JoinHostPort(option.Server, strconv.Itoa(option.Port))
 	cipher := option.Cipher
@@ -136,10 +137,11 @@ func NewShadowSocksR(option ShadowSocksROption) (*ShadowSocksR, error) {
 
 	return &ShadowSocksR{
 		Base: &Base{
-			name: option.Name,
-			addr: addr,
-			tp:   C.ShadowsocksR,
-			udp:  option.UDP,
+			name:  option.Name,
+			addr:  addr,
+			tp:    C.ShadowsocksR,
+			udp:   option.UDP,
+			iface: option.Interface,
 		},
 		cipher:   coreCiph,
 		obfs:     obfs,

adapter/outbound/snell.go

@@ -8,9 +8,9 @@ import (
 
 	"github.com/Dreamacro/clash/common/structure"
 	"github.com/Dreamacro/clash/component/dialer"
-	obfs "github.com/Dreamacro/clash/component/simple-obfs"
-	"github.com/Dreamacro/clash/component/snell"
 	C "github.com/Dreamacro/clash/constant"
+	obfs "github.com/Dreamacro/clash/transport/simple-obfs"
+	"github.com/Dreamacro/clash/transport/snell"
 )
 
 type Snell struct {
@@ -22,6 +22,7 @@ type Snell struct {
 }
 
 type SnellOption struct {
+	BasicOption
 	Name     string                 `proxy:"name"`
 	Server   string                 `proxy:"server"`
 	Port     int                    `proxy:"port"`
@@ -48,31 +49,38 @@ func streamConn(c net.Conn, option streamOption) *snell.Snell {
 	return snell.StreamConn(c, option.psk, option.version)
 }
 
+// StreamConn implements C.ProxyAdapter
 func (s *Snell) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
 	c = streamConn(c, streamOption{s.psk, s.version, s.addr, s.obfsOption})
-	port, _ := strconv.Atoi(metadata.DstPort)
+	port, _ := strconv.ParseUint(metadata.DstPort, 10, 16)
 	err := snell.WriteHeader(c, metadata.String(), uint(port), s.version)
 	return c, err
 }
 
-func (s *Snell) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
-	if s.version == snell.Version2 {
+// DialContext implements C.ProxyAdapter
+func (s *Snell) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (_ C.Conn, err error) {
+	if s.version == snell.Version2 && len(opts) == 0 {
 		c, err := s.pool.Get()
 		if err != nil {
 			return nil, err
 		}
 
-		port, _ := strconv.Atoi(metadata.DstPort)
-		err = snell.WriteHeader(c, metadata.String(), uint(port), s.version)
+		port, _ := strconv.ParseUint(metadata.DstPort, 10, 16)
+		if err = snell.WriteHeader(c, metadata.String(), uint(port), s.version); err != nil {
+			c.Close()
+			return nil, err
+		}
 		return NewConn(c, s), err
 	}
 
-	c, err := dialer.DialContext(ctx, "tcp", s.addr)
+	c, err := dialer.DialContext(ctx, "tcp", s.addr, s.Base.DialOptions(opts...)...)
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error: %w", s.addr, err)
 	}
 	tcpKeepAlive(c)
 
+	defer safeConnClose(c, err)
+
 	c, err = s.StreamConn(c, metadata)
 	return NewConn(c, s), err
 }
@@ -104,9 +112,10 @@ func NewSnell(option SnellOption) (*Snell, error) {
 
 	s := &Snell{
 		Base: &Base{
-			name: option.Name,
-			addr: addr,
-			tp:   C.Snell,
+			name:  option.Name,
+			addr:  addr,
+			tp:    C.Snell,
+			iface: option.Interface,
 		},
 		psk:        psk,
 		obfsOption: obfsOption,
@@ -115,7 +124,7 @@ func NewSnell(option SnellOption) (*Snell, error) {
 
 	if option.Version == snell.Version2 {
 		s.pool = snell.NewPool(func(ctx context.Context) (*snell.Snell, error) {
-			c, err := dialer.DialContext(ctx, "tcp", addr)
+			c, err := dialer.DialContext(ctx, "tcp", addr, s.Base.DialOptions()...)
 			if err != nil {
 				return nil, err
 			}

adapter/outbound/socks5.go

@@ -6,13 +6,12 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"net"
 	"strconv"
 
 	"github.com/Dreamacro/clash/component/dialer"
-	"github.com/Dreamacro/clash/component/socks5"
 	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/transport/socks5"
 )
 
 type Socks5 struct {
@@ -25,6 +24,7 @@ type Socks5 struct {
 }
 
 type Socks5Option struct {
+	BasicOption
 	Name           string `proxy:"name"`
 	Server         string `proxy:"server"`
 	Port           int    `proxy:"port"`
@@ -35,6 +35,7 @@ type Socks5Option struct {
 	SkipCertVerify bool   `proxy:"skip-cert-verify,omitempty"`
 }
 
+// StreamConn implements C.ProxyAdapter
 func (ss *Socks5) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
 	if ss.tls {
 		cc := tls.Client(c, ss.tlsConfig)
@@ -58,13 +59,16 @@ func (ss *Socks5) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error)
 	return c, nil
 }
 
-func (ss *Socks5) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
-	c, err := dialer.DialContext(ctx, "tcp", ss.addr)
+// DialContext implements C.ProxyAdapter
+func (ss *Socks5) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (_ C.Conn, err error) {
+	c, err := dialer.DialContext(ctx, "tcp", ss.addr, ss.Base.DialOptions(opts...)...)
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error: %w", ss.addr, err)
 	}
 	tcpKeepAlive(c)
 
+	defer safeConnClose(c, err)
+
 	c, err = ss.StreamConn(c, metadata)
 	if err != nil {
 		return nil, err
@@ -73,10 +77,9 @@ func (ss *Socks5) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn
 	return NewConn(c, ss), nil
 }
 
-func (ss *Socks5) DialUDP(metadata *C.Metadata) (_ C.PacketConn, err error) {
-	ctx, cancel := context.WithTimeout(context.Background(), tcpTimeout)
-	defer cancel()
-	c, err := dialer.DialContext(ctx, "tcp", ss.addr)
+// ListenPacketContext implements C.ProxyAdapter
+func (ss *Socks5) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (_ C.PacketConn, err error) {
+	c, err := dialer.DialContext(ctx, "tcp", ss.addr, ss.Base.DialOptions(opts...)...)
 	if err != nil {
 		err = fmt.Errorf("%s connect error: %w", ss.addr, err)
 		return
@@ -88,11 +91,7 @@ func (ss *Socks5) DialUDP(metadata *C.Metadata) (_ C.PacketConn, err error) {
 		c = cc
 	}
 
-	defer func() {
-		if err != nil {
-			c.Close()
-		}
-	}()
+	defer safeConnClose(c, err)
 
 	tcpKeepAlive(c)
 	var user *socks5.User
@@ -109,13 +108,13 @@ func (ss *Socks5) DialUDP(metadata *C.Metadata) (_ C.PacketConn, err error) {
 		return
 	}
 
-	pc, err := dialer.ListenPacket("udp", "")
+	pc, err := dialer.ListenPacket(ctx, "udp", "", ss.Base.DialOptions(opts...)...)
 	if err != nil {
 		return
 	}
 
 	go func() {
-		io.Copy(ioutil.Discard, c)
+		io.Copy(io.Discard, c)
 		c.Close()
 		// A UDP association terminates when the TCP connection that the UDP
 		// ASSOCIATE request arrived on terminates. RFC1928
@@ -144,17 +143,17 @@ func NewSocks5(option Socks5Option) *Socks5 {
 	if option.TLS {
 		tlsConfig = &tls.Config{
 			InsecureSkipVerify: option.SkipCertVerify,
-			ClientSessionCache: getClientSessionCache(),
 			ServerName:         option.Server,
 		}
 	}
 
 	return &Socks5{
 		Base: &Base{
-			name: option.Name,
-			addr: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
-			tp:   C.Socks5,
-			udp:  option.UDP,
+			name:  option.Name,
+			addr:  net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
+			tp:    C.Socks5,
+			udp:   option.UDP,
+			iface: option.Interface,
 		},
 		user:           option.UserName,
 		pass:           option.Password,

adapter/outbound/trojan.go

@@ -0,0 +1,207 @@
+package outbound
+
+import (
+	"context"
+	"crypto/tls"
+	"fmt"
+	"net"
+	"net/http"
+	"strconv"
+
+	"github.com/Dreamacro/clash/component/dialer"
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/transport/gun"
+	"github.com/Dreamacro/clash/transport/trojan"
+
+	"golang.org/x/net/http2"
+)
+
+type Trojan struct {
+	*Base
+	instance *trojan.Trojan
+	option   *TrojanOption
+
+	// for gun mux
+	gunTLSConfig *tls.Config
+	gunConfig    *gun.Config
+	transport    *http2.Transport
+}
+
+type TrojanOption struct {
+	BasicOption
+	Name           string      `proxy:"name"`
+	Server         string      `proxy:"server"`
+	Port           int         `proxy:"port"`
+	Password       string      `proxy:"password"`
+	ALPN           []string    `proxy:"alpn,omitempty"`
+	SNI            string      `proxy:"sni,omitempty"`
+	SkipCertVerify bool        `proxy:"skip-cert-verify,omitempty"`
+	UDP            bool        `proxy:"udp,omitempty"`
+	Network        string      `proxy:"network,omitempty"`
+	GrpcOpts       GrpcOptions `proxy:"grpc-opts,omitempty"`
+	WSOpts         WSOptions   `proxy:"ws-opts,omitempty"`
+}
+
+func (t *Trojan) plainStream(c net.Conn) (net.Conn, error) {
+	if t.option.Network == "ws" {
+		host, port, _ := net.SplitHostPort(t.addr)
+		wsOpts := &trojan.WebsocketOption{
+			Host: host,
+			Port: port,
+			Path: t.option.WSOpts.Path,
+		}
+
+		if t.option.SNI != "" {
+			wsOpts.Host = t.option.SNI
+		}
+
+		if len(t.option.WSOpts.Headers) != 0 {
+			header := http.Header{}
+			for key, value := range t.option.WSOpts.Headers {
+				header.Add(key, value)
+			}
+			wsOpts.Headers = header
+		}
+
+		return t.instance.StreamWebsocketConn(c, wsOpts)
+	}
+
+	return t.instance.StreamConn(c)
+}
+
+// StreamConn implements C.ProxyAdapter
+func (t *Trojan) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
+	var err error
+	if t.transport != nil {
+		c, err = gun.StreamGunWithConn(c, t.gunTLSConfig, t.gunConfig)
+	} else {
+		c, err = t.plainStream(c)
+	}
+
+	if err != nil {
+		return nil, fmt.Errorf("%s connect error: %w", t.addr, err)
+	}
+
+	err = t.instance.WriteHeader(c, trojan.CommandTCP, serializesSocksAddr(metadata))
+	return c, err
+}
+
+// DialContext implements C.ProxyAdapter
+func (t *Trojan) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (_ C.Conn, err error) {
+	// gun transport
+	if t.transport != nil && len(opts) == 0 {
+		c, err := gun.StreamGunWithTransport(t.transport, t.gunConfig)
+		if err != nil {
+			return nil, err
+		}
+
+		if err = t.instance.WriteHeader(c, trojan.CommandTCP, serializesSocksAddr(metadata)); err != nil {
+			c.Close()
+			return nil, err
+		}
+
+		return NewConn(c, t), nil
+	}
+
+	c, err := dialer.DialContext(ctx, "tcp", t.addr, t.Base.DialOptions(opts...)...)
+	if err != nil {
+		return nil, fmt.Errorf("%s connect error: %w", t.addr, err)
+	}
+	tcpKeepAlive(c)
+
+	defer safeConnClose(c, err)
+
+	c, err = t.StreamConn(c, metadata)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewConn(c, t), err
+}
+
+// ListenPacketContext implements C.ProxyAdapter
+func (t *Trojan) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (_ C.PacketConn, err error) {
+	var c net.Conn
+
+	// grpc transport
+	if t.transport != nil && len(opts) == 0 {
+		c, err = gun.StreamGunWithTransport(t.transport, t.gunConfig)
+		if err != nil {
+			return nil, fmt.Errorf("%s connect error: %w", t.addr, err)
+		}
+		defer safeConnClose(c, err)
+	} else {
+		c, err = dialer.DialContext(ctx, "tcp", t.addr, t.Base.DialOptions(opts...)...)
+		if err != nil {
+			return nil, fmt.Errorf("%s connect error: %w", t.addr, err)
+		}
+		defer safeConnClose(c, err)
+		tcpKeepAlive(c)
+		c, err = t.plainStream(c)
+		if err != nil {
+			return nil, fmt.Errorf("%s connect error: %w", t.addr, err)
+		}
+	}
+
+	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
+}
+
+func NewTrojan(option TrojanOption) (*Trojan, error) {
+	addr := net.JoinHostPort(option.Server, strconv.Itoa(option.Port))
+
+	tOption := &trojan.Option{
+		Password:       option.Password,
+		ALPN:           option.ALPN,
+		ServerName:     option.Server,
+		SkipCertVerify: option.SkipCertVerify,
+	}
+
+	if option.SNI != "" {
+		tOption.ServerName = option.SNI
+	}
+
+	t := &Trojan{
+		Base: &Base{
+			name:  option.Name,
+			addr:  addr,
+			tp:    C.Trojan,
+			udp:   option.UDP,
+			iface: option.Interface,
+		},
+		instance: trojan.New(tOption),
+		option:   &option,
+	}
+
+	if option.Network == "grpc" {
+		dialFn := func(network, addr string) (net.Conn, error) {
+			c, err := dialer.DialContext(context.Background(), "tcp", t.addr, t.Base.DialOptions()...)
+			if err != nil {
+				return nil, fmt.Errorf("%s connect error: %s", t.addr, err.Error())
+			}
+			tcpKeepAlive(c)
+			return c, nil
+		}
+
+		tlsConfig := &tls.Config{
+			NextProtos:         option.ALPN,
+			MinVersion:         tls.VersionTLS12,
+			InsecureSkipVerify: tOption.SkipCertVerify,
+			ServerName:         tOption.ServerName,
+		}
+
+		t.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
+		t.gunTLSConfig = tlsConfig
+		t.gunConfig = &gun.Config{
+			ServiceName: option.GrpcOpts.GrpcServiceName,
+			Host:        tOption.ServerName,
+		}
+	}
+
+	return t, nil
+}

adapter/outbound/util.go

@@ -2,56 +2,15 @@ package outbound
 
 import (
 	"bytes"
-	"crypto/tls"
-	"fmt"
 	"net"
-	"net/url"
 	"strconv"
-	"sync"
 	"time"
 
 	"github.com/Dreamacro/clash/component/resolver"
-	"github.com/Dreamacro/clash/component/socks5"
 	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/transport/socks5"
 )
 
-const (
-	tcpTimeout = 5 * time.Second
-)
-
-var (
-	globalClientSessionCache tls.ClientSessionCache
-	once                     sync.Once
-)
-
-func urlToMetadata(rawURL string) (addr C.Metadata, err error) {
-	u, err := url.Parse(rawURL)
-	if err != nil {
-		return
-	}
-
-	port := u.Port()
-	if port == "" {
-		switch u.Scheme {
-		case "https":
-			port = "443"
-		case "http":
-			port = "80"
-		default:
-			err = fmt.Errorf("%s scheme not Support", rawURL)
-			return
-		}
-	}
-
-	addr = C.Metadata{
-		AddrType: C.AtypDomainName,
-		Host:     u.Hostname(),
-		DstIP:    nil,
-		DstPort:  port,
-	}
-	return
-}
-
 func tcpKeepAlive(c net.Conn) {
 	if tcp, ok := c.(*net.TCPConn); ok {
 		tcp.SetKeepAlive(true)
@@ -59,17 +18,10 @@ func tcpKeepAlive(c net.Conn) {
 	}
 }
 
-func getClientSessionCache() tls.ClientSessionCache {
-	once.Do(func() {
-		globalClientSessionCache = tls.NewLRUClientSessionCache(128)
-	})
-	return globalClientSessionCache
-}
-
 func serializesSocksAddr(metadata *C.Metadata) []byte {
 	var buf [][]byte
 	aType := uint8(metadata.AddrType)
-	p, _ := strconv.Atoi(metadata.DstPort)
+	p, _ := strconv.ParseUint(metadata.DstPort, 10, 16)
 	port := []byte{uint8(p >> 8), uint8(p & 0xff)}
 	switch metadata.AddrType {
 	case socks5.AtypDomainName:
@@ -98,3 +50,9 @@ func resolveUDPAddr(network, address string) (*net.UDPAddr, error) {
 	}
 	return net.ResolveUDPAddr(network, net.JoinHostPort(ip.String(), port))
 }
+
+func safeConnClose(c net.Conn, err error) {
+	if err != nil {
+		c.Close()
+	}
+}

adapter/outbound/vless.go

@@ -0,0 +1,444 @@
+package outbound
+
+import (
+	"context"
+	"crypto/tls"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"strconv"
+	"sync"
+
+	"github.com/Dreamacro/clash/component/dialer"
+	"github.com/Dreamacro/clash/component/resolver"
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/transport/gun"
+	"github.com/Dreamacro/clash/transport/vless"
+	"github.com/Dreamacro/clash/transport/vmess"
+	"golang.org/x/net/http2"
+)
+
+const (
+	// max packet length
+	maxLength = 8192
+)
+
+type Vless struct {
+	*Base
+	client *vless.Client
+	option *VlessOption
+
+	// for gun mux
+	gunTLSConfig *tls.Config
+	gunConfig    *gun.Config
+	transport    *http2.Transport
+}
+
+type VlessOption struct {
+	BasicOption
+	Name           string            `proxy:"name"`
+	Server         string            `proxy:"server"`
+	Port           int               `proxy:"port"`
+	UUID           string            `proxy:"uuid"`
+	Flow           string            `proxy:"flow,omitempty"`
+	FlowShow       bool              `proxy:"flow-show,omitempty"`
+	TLS            bool              `proxy:"tls,omitempty"`
+	UDP            bool              `proxy:"udp,omitempty"`
+	Network        string            `proxy:"network,omitempty"`
+	HTTPOpts       HTTPOptions       `proxy:"http-opts,omitempty"`
+	HTTP2Opts      HTTP2Options      `proxy:"h2-opts,omitempty"`
+	GrpcOpts       GrpcOptions       `proxy:"grpc-opts,omitempty"`
+	WSOpts         WSOptions         `proxy:"ws-opts,omitempty"`
+	WSPath         string            `proxy:"ws-path,omitempty"`
+	WSHeaders      map[string]string `proxy:"ws-headers,omitempty"`
+	SkipCertVerify bool              `proxy:"skip-cert-verify,omitempty"`
+	ServerName     string            `proxy:"servername,omitempty"`
+}
+
+func (v *Vless) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
+	var err error
+	switch v.option.Network {
+	case "ws":
+		if v.option.WSOpts.Path == "" {
+			v.option.WSOpts.Path = v.option.WSPath
+		}
+		if len(v.option.WSOpts.Headers) == 0 {
+			v.option.WSOpts.Headers = v.option.WSHeaders
+		}
+
+		host, port, _ := net.SplitHostPort(v.addr)
+		wsOpts := &vmess.WebsocketConfig{
+			Host:                host,
+			Port:                port,
+			Path:                v.option.WSOpts.Path,
+			MaxEarlyData:        v.option.WSOpts.MaxEarlyData,
+			EarlyDataHeaderName: v.option.WSOpts.EarlyDataHeaderName,
+		}
+
+		if len(v.option.WSOpts.Headers) != 0 {
+			header := http.Header{}
+			for key, value := range v.option.WSOpts.Headers {
+				header.Add(key, value)
+			}
+			wsOpts.Headers = header
+		}
+
+		if v.option.TLS {
+			wsOpts.TLS = true
+			wsOpts.TLSConfig = &tls.Config{
+				ServerName:         host,
+				InsecureSkipVerify: v.option.SkipCertVerify,
+				NextProtos:         []string{"http/1.1"},
+			}
+			if v.option.ServerName != "" {
+				wsOpts.TLSConfig.ServerName = v.option.ServerName
+			} else if host := wsOpts.Headers.Get("Host"); host != "" {
+				wsOpts.TLSConfig.ServerName = host
+			}
+		}
+		c, err = vmess.StreamWebsocketConn(c, wsOpts)
+	case "http":
+		// readability first, so just copy default TLS logic
+		c, err = v.streamTLSOrXTLSConn(c, false)
+		if err != nil {
+			return nil, err
+		}
+
+		host, _, _ := net.SplitHostPort(v.addr)
+		httpOpts := &vmess.HTTPConfig{
+			Host:    host,
+			Method:  v.option.HTTPOpts.Method,
+			Path:    v.option.HTTPOpts.Path,
+			Headers: v.option.HTTPOpts.Headers,
+		}
+
+		c = vmess.StreamHTTPConn(c, httpOpts)
+	case "h2":
+		c, err = v.streamTLSOrXTLSConn(c, true)
+		if err != nil {
+			return nil, err
+		}
+
+		h2Opts := &vmess.H2Config{
+			Hosts: v.option.HTTP2Opts.Host,
+			Path:  v.option.HTTP2Opts.Path,
+		}
+
+		c, err = vmess.StreamH2Conn(c, h2Opts)
+	case "grpc":
+		if v.isXTLSEnabled() {
+			c, err = gun.StreamGunWithXTLSConn(c, v.gunTLSConfig, v.gunConfig)
+		} else {
+			c, err = gun.StreamGunWithConn(c, v.gunTLSConfig, v.gunConfig)
+		}
+	default:
+		// handle TLS And XTLS
+		c, err = v.streamTLSOrXTLSConn(c, false)
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	return v.client.StreamConn(c, parseVlessAddr(metadata))
+}
+
+func (v *Vless) streamTLSOrXTLSConn(conn net.Conn, isH2 bool) (net.Conn, error) {
+	host, _, _ := net.SplitHostPort(v.addr)
+
+	if v.isXTLSEnabled() {
+		xtlsOpts := vless.XTLSConfig{
+			Host:           host,
+			SkipCertVerify: v.option.SkipCertVerify,
+		}
+
+		if isH2 {
+			xtlsOpts.NextProtos = []string{"h2"}
+		}
+
+		if v.option.ServerName != "" {
+			xtlsOpts.Host = v.option.ServerName
+		}
+
+		return vless.StreamXTLSConn(conn, &xtlsOpts)
+
+	} else if v.option.TLS {
+		tlsOpts := vmess.TLSConfig{
+			Host:           host,
+			SkipCertVerify: v.option.SkipCertVerify,
+		}
+
+		if isH2 {
+			tlsOpts.NextProtos = []string{"h2"}
+		}
+
+		if v.option.ServerName != "" {
+			tlsOpts.Host = v.option.ServerName
+		}
+
+		return vmess.StreamTLSConn(conn, &tlsOpts)
+	}
+
+	return conn, nil
+}
+
+func (v *Vless) isXTLSEnabled() bool {
+	return v.client.Addons != nil
+}
+
+// DialContext implements C.ProxyAdapter
+func (v *Vless) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (_ C.Conn, err error) {
+	// gun transport
+	if v.transport != nil && len(opts) == 0 {
+		c, err := gun.StreamGunWithTransport(v.transport, v.gunConfig)
+		if err != nil {
+			return nil, err
+		}
+		defer safeConnClose(c, err)
+
+		c, err = v.client.StreamConn(c, parseVlessAddr(metadata))
+		if err != nil {
+			return nil, err
+		}
+
+		return NewConn(c, v), nil
+	}
+
+	c, err := dialer.DialContext(ctx, "tcp", v.addr, v.Base.DialOptions(opts...)...)
+	if err != nil {
+		return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
+	}
+	tcpKeepAlive(c)
+	defer safeConnClose(c, err)
+
+	c, err = v.StreamConn(c, metadata)
+	return NewConn(c, v), err
+}
+
+// ListenPacketContext implements C.ProxyAdapter
+func (v *Vless) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (_ C.PacketConn, err error) {
+	// vmess use stream-oriented udp with a special address, so we needs a net.UDPAddr
+	if !metadata.Resolved() {
+		ip, err := resolver.ResolveIP(metadata.Host)
+		if err != nil {
+			return nil, errors.New("can't resolve ip")
+		}
+		metadata.DstIP = ip
+	}
+
+	var c net.Conn
+	// gun transport
+	if v.transport != nil && len(opts) == 0 {
+		c, err = gun.StreamGunWithTransport(v.transport, v.gunConfig)
+		if err != nil {
+			return nil, err
+		}
+		defer safeConnClose(c, err)
+
+		c, err = v.client.StreamConn(c, parseVlessAddr(metadata))
+	} else {
+		c, err = dialer.DialContext(ctx, "tcp", v.addr, v.Base.DialOptions(opts...)...)
+		if err != nil {
+			return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
+		}
+		tcpKeepAlive(c)
+		defer safeConnClose(c, err)
+
+		c, err = v.StreamConn(c, metadata)
+	}
+
+	if err != nil {
+		return nil, fmt.Errorf("new vless client error: %v", err)
+	}
+
+	return newPacketConn(&vlessPacketConn{Conn: c, rAddr: metadata.UDPAddr()}, v), nil
+}
+
+func parseVlessAddr(metadata *C.Metadata) *vless.DstAddr {
+	var addrType byte
+	var addr []byte
+	switch metadata.AddrType {
+	case C.AtypIPv4:
+		addrType = byte(vless.AtypIPv4)
+		addr = make([]byte, net.IPv4len)
+		copy(addr[:], metadata.DstIP.To4())
+	case C.AtypIPv6:
+		addrType = byte(vless.AtypIPv6)
+		addr = make([]byte, net.IPv6len)
+		copy(addr[:], metadata.DstIP.To16())
+	case C.AtypDomainName:
+		addrType = byte(vless.AtypDomainName)
+		addr = make([]byte, len(metadata.Host)+1)
+		addr[0] = byte(len(metadata.Host))
+		copy(addr[1:], []byte(metadata.Host))
+	}
+
+	port, _ := strconv.Atoi(metadata.DstPort)
+	return &vless.DstAddr{
+		UDP:      metadata.NetWork == C.UDP,
+		AddrType: addrType,
+		Addr:     addr,
+		Port:     uint(port),
+	}
+}
+
+type vlessPacketConn struct {
+	net.Conn
+	rAddr net.Addr
+	remain int
+	mux    sync.Mutex
+	cache  []byte
+}
+
+func (c *vlessPacketConn) writePacket(b []byte, addr net.Addr) (int, error) {
+	length := len(b)
+	defer func() {
+		c.cache = c.cache[:0]
+	}()
+	c.cache = append(c.cache, byte(length>>8), byte(length))
+	c.cache = append(c.cache, b...)
+	n, err := c.Conn.Write(c.cache)
+	if n > 2 {
+		return n - 2, err
+	}
+
+	return 0, err
+}
+
+func (c *vlessPacketConn) WriteTo(b []byte, addr net.Addr) (int, error) {
+	if len(b) <= maxLength {
+		return c.writePacket(b, addr)
+	}
+
+	offset := 0
+	total := len(b)
+	for offset < total {
+		cursor := offset + maxLength
+		if cursor > total {
+			cursor = total
+		}
+
+		n, err := c.writePacket(b[offset:cursor], addr)
+		if err != nil {
+			return offset + n, err
+		}
+
+		offset = cursor
+	}
+
+	return total, nil
+}
+
+
+func (c *vlessPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
+	c.mux.Lock()
+	defer c.mux.Unlock()
+
+	length := len(b)
+	if c.remain > 0 {
+		if c.remain < length {
+			length = c.remain
+		}
+
+		n, err := c.Conn.Read(b[:length])
+		if err != nil {
+			return 0, nil, err
+		}
+
+		c.remain -= n
+		return n, c.rAddr, nil
+	}
+
+	var packetLength uint16
+	if err := binary.Read(c.Conn, binary.BigEndian, &packetLength); err != nil {
+		return 0, nil, err
+	}
+
+	remain := int(packetLength)
+	n, err := c.Conn.Read(b[:length])
+	remain -= n
+	if remain > 0 {
+		c.remain = remain
+	}
+	return n, c.rAddr, err
+}
+
+
+func NewVless(option VlessOption) (*Vless, error) {
+	if !option.TLS && option.Network == "grpc" {
+		return nil, fmt.Errorf("TLS must be true with vless-grpc")
+	}
+
+	var addons *vless.Addons
+	if option.Network != "ws" && len(option.Flow) >= 16 {
+		option.Flow = option.Flow[:16]
+		switch option.Flow {
+		case vless.XRO, vless.XRD, vless.XRS:
+			addons = &vless.Addons{
+				Flow: option.Flow,
+			}
+		default:
+			return nil, fmt.Errorf("unsupported vless flow type: %s", option.Flow)
+		}
+	}
+
+	client, err := vless.NewClient(option.UUID, addons, option.FlowShow)
+	if err != nil {
+		return nil, err
+	}
+
+	v := &Vless{
+		Base: &Base{
+			name:  option.Name,
+			addr:  net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
+			tp:    C.Vless,
+			udp:   option.UDP,
+			iface: option.Interface,
+		},
+		client: client,
+		option: &option,
+	}
+
+	switch option.Network {
+	case "h2":
+		if len(option.HTTP2Opts.Host) == 0 {
+			option.HTTP2Opts.Host = append(option.HTTP2Opts.Host, "www.example.com")
+		}
+	case "grpc":
+		dialFn := func(network, addr string) (net.Conn, error) {
+			c, err := dialer.DialContext(context.Background(), "tcp", v.addr, v.Base.DialOptions()...)
+			if err != nil {
+				return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
+			}
+			tcpKeepAlive(c)
+			return c, nil
+		}
+
+		gunConfig := &gun.Config{
+			ServiceName: v.option.GrpcOpts.GrpcServiceName,
+			Host:        v.option.ServerName,
+		}
+		tlsConfig := &tls.Config{
+			InsecureSkipVerify: v.option.SkipCertVerify,
+			ServerName:         v.option.ServerName,
+		}
+
+		if v.option.ServerName == "" {
+			host, _, _ := net.SplitHostPort(v.addr)
+			tlsConfig.ServerName = host
+			gunConfig.Host = host
+		}
+
+		v.gunTLSConfig = tlsConfig
+		v.gunConfig = gunConfig
+		if v.isXTLSEnabled() {
+			v.transport = gun.NewHTTP2XTLSClient(dialFn, tlsConfig)
+		} else {
+			v.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
+		}
+	}
+
+	return v, nil
+}

adapter/outbound/vmess.go

@@ -0,0 +1,366 @@
+package outbound
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"github.com/Dreamacro/clash/component/dialer"
+	"github.com/Dreamacro/clash/component/resolver"
+	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 {
+	*Base
+	client *vmess.Client
+	option *VmessOption
+
+	// for gun mux
+	gunTLSConfig *tls.Config
+	gunConfig    *gun.Config
+	transport    *http2.Transport
+}
+
+type VmessOption struct {
+	BasicOption
+	Name           string       `proxy:"name"`
+	Server         string       `proxy:"server"`
+	Port           int          `proxy:"port"`
+	UUID           string       `proxy:"uuid"`
+	AlterID        int          `proxy:"alterId"`
+	Cipher         string       `proxy:"cipher"`
+	UDP            bool         `proxy:"udp,omitempty"`
+	Network        string       `proxy:"network,omitempty"`
+	TLS            bool         `proxy:"tls,omitempty"`
+	SkipCertVerify bool         `proxy:"skip-cert-verify,omitempty"`
+	ServerName     string       `proxy:"servername,omitempty"`
+	HTTPOpts       HTTPOptions  `proxy:"http-opts,omitempty"`
+	HTTP2Opts      HTTP2Options `proxy:"h2-opts,omitempty"`
+	GrpcOpts       GrpcOptions  `proxy:"grpc-opts,omitempty"`
+	WSOpts         WSOptions    `proxy:"ws-opts,omitempty"`
+}
+
+type HTTPOptions struct {
+	Method  string              `proxy:"method,omitempty"`
+	Path    []string            `proxy:"path,omitempty"`
+	Headers map[string][]string `proxy:"headers,omitempty"`
+}
+
+type HTTP2Options struct {
+	Host []string `proxy:"host,omitempty"`
+	Path string   `proxy:"path,omitempty"`
+}
+
+type GrpcOptions struct {
+	GrpcServiceName string `proxy:"grpc-service-name,omitempty"`
+}
+
+type WSOptions struct {
+	Path                string            `proxy:"path,omitempty"`
+	Headers             map[string]string `proxy:"headers,omitempty"`
+	MaxEarlyData        int               `proxy:"max-early-data,omitempty"`
+	EarlyDataHeaderName string            `proxy:"early-data-header-name,omitempty"`
+}
+
+// StreamConn implements C.ProxyAdapter
+func (v *Vmess) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
+	var err error
+	switch v.option.Network {
+	case "ws":
+		host, port, _ := net.SplitHostPort(v.addr)
+		wsOpts := &vmess.WebsocketConfig{
+			Host:                host,
+			Port:                port,
+			Path:                v.option.WSOpts.Path,
+			MaxEarlyData:        v.option.WSOpts.MaxEarlyData,
+			EarlyDataHeaderName: v.option.WSOpts.EarlyDataHeaderName,
+		}
+
+		if len(v.option.WSOpts.Headers) != 0 {
+			header := http.Header{}
+			for key, value := range v.option.WSOpts.Headers {
+				header.Add(key, value)
+			}
+			wsOpts.Headers = header
+		}
+
+		if v.option.TLS {
+			wsOpts.TLS = true
+			wsOpts.TLSConfig = &tls.Config{
+				ServerName:         host,
+				InsecureSkipVerify: v.option.SkipCertVerify,
+				NextProtos:         []string{"http/1.1"},
+			}
+			if v.option.ServerName != "" {
+				wsOpts.TLSConfig.ServerName = v.option.ServerName
+			} else if host := wsOpts.Headers.Get("Host"); host != "" {
+				wsOpts.TLSConfig.ServerName = host
+			}
+		}
+		c, err = vmess.StreamWebsocketConn(c, wsOpts)
+	case "http":
+		// readability first, so just copy default TLS logic
+		if v.option.TLS {
+			host, _, _ := net.SplitHostPort(v.addr)
+			tlsOpts := &vmess.TLSConfig{
+				Host:           host,
+				SkipCertVerify: v.option.SkipCertVerify,
+			}
+
+			if v.option.ServerName != "" {
+				tlsOpts.Host = v.option.ServerName
+			}
+
+			c, err = vmess.StreamTLSConn(c, tlsOpts)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		host, _, _ := net.SplitHostPort(v.addr)
+		httpOpts := &vmess.HTTPConfig{
+			Host:    host,
+			Method:  v.option.HTTPOpts.Method,
+			Path:    v.option.HTTPOpts.Path,
+			Headers: v.option.HTTPOpts.Headers,
+		}
+
+		c = vmess.StreamHTTPConn(c, httpOpts)
+	case "h2":
+		host, _, _ := net.SplitHostPort(v.addr)
+		tlsOpts := vmess.TLSConfig{
+			Host:           host,
+			SkipCertVerify: v.option.SkipCertVerify,
+			NextProtos:     []string{"h2"},
+		}
+
+		if v.option.ServerName != "" {
+			tlsOpts.Host = v.option.ServerName
+		}
+
+		c, err = vmess.StreamTLSConn(c, &tlsOpts)
+		if err != nil {
+			return nil, err
+		}
+
+		h2Opts := &vmess.H2Config{
+			Hosts: v.option.HTTP2Opts.Host,
+			Path:  v.option.HTTP2Opts.Path,
+		}
+
+		c, err = vmess.StreamH2Conn(c, h2Opts)
+	case "grpc":
+		c, err = gun.StreamGunWithConn(c, v.gunTLSConfig, v.gunConfig)
+	default:
+		// handle TLS
+		if v.option.TLS {
+			host, _, _ := net.SplitHostPort(v.addr)
+			tlsOpts := &vmess.TLSConfig{
+				Host:           host,
+				SkipCertVerify: v.option.SkipCertVerify,
+			}
+
+			if v.option.ServerName != "" {
+				tlsOpts.Host = v.option.ServerName
+			}
+
+			c, err = vmess.StreamTLSConn(c, tlsOpts)
+		}
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	return v.client.StreamConn(c, parseVmessAddr(metadata))
+}
+
+// DialContext implements C.ProxyAdapter
+func (v *Vmess) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (_ C.Conn, err error) {
+	// gun transport
+	if v.transport != nil && len(opts) == 0 {
+		c, err := gun.StreamGunWithTransport(v.transport, v.gunConfig)
+		if err != nil {
+			return nil, err
+		}
+		defer safeConnClose(c, err)
+
+		c, err = v.client.StreamConn(c, parseVmessAddr(metadata))
+		if err != nil {
+			return nil, err
+		}
+
+		return NewConn(c, v), nil
+	}
+
+	c, err := dialer.DialContext(ctx, "tcp", v.addr, v.Base.DialOptions(opts...)...)
+	if err != nil {
+		return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
+	}
+	tcpKeepAlive(c)
+	defer safeConnClose(c, err)
+
+	c, err = v.StreamConn(c, metadata)
+	return NewConn(c, v), err
+}
+
+// ListenPacketContext implements C.ProxyAdapter
+func (v *Vmess) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (_ C.PacketConn, err error) {
+	// vmess use stream-oriented udp with a special address, so we needs a net.UDPAddr
+	if !metadata.Resolved() {
+		ip, err := resolver.ResolveIP(metadata.Host)
+		if err != nil {
+			return nil, errors.New("can't resolve ip")
+		}
+		metadata.DstIP = ip
+	}
+
+	var c net.Conn
+	// gun transport
+	if v.transport != nil && len(opts) == 0 {
+		c, err = gun.StreamGunWithTransport(v.transport, v.gunConfig)
+		if err != nil {
+			return nil, err
+		}
+		defer safeConnClose(c, err)
+
+		c, err = v.client.StreamConn(c, parseVmessAddr(metadata))
+	} else {
+		c, err = dialer.DialContext(ctx, "tcp", v.addr, v.Base.DialOptions(opts...)...)
+		if err != nil {
+			return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
+		}
+		tcpKeepAlive(c)
+		defer safeConnClose(c, err)
+
+		c, err = v.StreamConn(c, metadata)
+	}
+
+	if err != nil {
+		return nil, fmt.Errorf("new vmess client error: %v", err)
+	}
+
+	return newPacketConn(&vmessPacketConn{Conn: c, rAddr: metadata.UDPAddr()}, v), nil
+}
+
+func NewVmess(option VmessOption) (*Vmess, error) {
+	security := strings.ToLower(option.Cipher)
+	client, err := vmess.NewClient(vmess.Config{
+		UUID:     option.UUID,
+		AlterID:  uint16(option.AlterID),
+		Security: security,
+		HostName: option.Server,
+		Port:     strconv.Itoa(option.Port),
+		IsAead:   option.AlterID == 0,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	switch option.Network {
+	case "h2", "grpc":
+		if !option.TLS {
+			return nil, fmt.Errorf("TLS must be true with h2/grpc network")
+		}
+	}
+
+	v := &Vmess{
+		Base: &Base{
+			name:  option.Name,
+			addr:  net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
+			tp:    C.Vmess,
+			udp:   option.UDP,
+			iface: option.Interface,
+		},
+		client: client,
+		option: &option,
+	}
+
+	switch option.Network {
+	case "h2":
+		if len(option.HTTP2Opts.Host) == 0 {
+			option.HTTP2Opts.Host = append(option.HTTP2Opts.Host, "www.example.com")
+		}
+	case "grpc":
+		dialFn := func(network, addr string) (net.Conn, error) {
+			c, err := dialer.DialContext(context.Background(), "tcp", v.addr, v.Base.DialOptions()...)
+			if err != nil {
+				return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
+			}
+			tcpKeepAlive(c)
+			return c, nil
+		}
+
+		gunConfig := &gun.Config{
+			ServiceName: v.option.GrpcOpts.GrpcServiceName,
+			Host:        v.option.ServerName,
+		}
+		tlsConfig := &tls.Config{
+			InsecureSkipVerify: v.option.SkipCertVerify,
+			ServerName:         v.option.ServerName,
+		}
+
+		if v.option.ServerName == "" {
+			host, _, _ := net.SplitHostPort(v.addr)
+			tlsConfig.ServerName = host
+			gunConfig.Host = host
+		}
+
+		v.gunTLSConfig = tlsConfig
+		v.gunConfig = gunConfig
+		v.transport = gun.NewHTTP2Client(dialFn, tlsConfig)
+	}
+
+	return v, nil
+}
+
+func parseVmessAddr(metadata *C.Metadata) *vmess.DstAddr {
+	var addrType byte
+	var addr []byte
+	switch metadata.AddrType {
+	case C.AtypIPv4:
+		addrType = byte(vmess.AtypIPv4)
+		addr = make([]byte, net.IPv4len)
+		copy(addr[:], metadata.DstIP.To4())
+	case C.AtypIPv6:
+		addrType = byte(vmess.AtypIPv6)
+		addr = make([]byte, net.IPv6len)
+		copy(addr[:], metadata.DstIP.To16())
+	case C.AtypDomainName:
+		addrType = byte(vmess.AtypDomainName)
+		addr = make([]byte, len(metadata.Host)+1)
+		addr[0] = byte(len(metadata.Host))
+		copy(addr[1:], []byte(metadata.Host))
+	}
+
+	port, _ := strconv.ParseUint(metadata.DstPort, 10, 16)
+	return &vmess.DstAddr{
+		UDP:      metadata.NetWork == C.UDP,
+		AddrType: addrType,
+		Addr:     addr,
+		Port:     uint(port),
+	}
+}
+
+type vmessPacketConn struct {
+	net.Conn
+	rAddr net.Addr
+}
+
+func (uc *vmessPacketConn) WriteTo(b []byte, addr net.Addr) (int, error) {
+	return uc.Conn.Write(b)
+}
+
+func (uc *vmessPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
+	n, err := uc.Conn.Read(b)
+	return n, uc.rAddr, err
+}

adapter/outboundgroup/common.go

@@ -3,8 +3,8 @@ package outboundgroup
 import (
 	"time"
 
-	"github.com/Dreamacro/clash/adapters/provider"
 	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/constant/provider"
 )
 
 const (

adapter/outboundgroup/fallback.go

@@ -0,0 +1,147 @@
+package outboundgroup
+
+import (
+	"context"
+	"encoding/json"
+	"github.com/Dreamacro/clash/log"
+	"go.uber.org/atomic"
+	"time"
+
+	"github.com/Dreamacro/clash/adapter/outbound"
+	"github.com/Dreamacro/clash/common/singledo"
+	"github.com/Dreamacro/clash/component/dialer"
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/constant/provider"
+)
+
+type Fallback struct {
+	*outbound.Base
+	disableUDP  bool
+	single      *singledo.Single
+	providers   []provider.ProxyProvider
+	failedTimes *atomic.Int32
+	failedTime  *atomic.Int64
+}
+
+func (f *Fallback) Now() string {
+	proxy := f.findAliveProxy(false)
+	return proxy.Name()
+}
+
+// DialContext implements C.ProxyAdapter
+func (f *Fallback) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.Conn, error) {
+	proxy := f.findAliveProxy(true)
+	c, err := proxy.DialContext(ctx, metadata, f.Base.DialOptions(opts...)...)
+	if err == nil {
+		c.AppendToChains(f)
+		f.failedTimes.Store(-1)
+		f.failedTime.Store(-1)
+	} else {
+		f.onDialFailed()
+	}
+
+	return c, err
+}
+
+// ListenPacketContext implements C.ProxyAdapter
+func (f *Fallback) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.PacketConn, error) {
+	proxy := f.findAliveProxy(true)
+	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*1000 {
+			f.failedTimes.Store(-1)
+			f.failedTime.Store(-1)
+		} else {
+			f.failedTimes.Inc()
+			failedCount := f.failedTimes.Load()
+			log.Warnln("%s failed count: %d", f.Name(), failedCount)
+			if failedCount > 5 {
+				log.Debugln("%s failed multiple times.", f.Name())
+				for _, proxyProvider := range f.providers {
+					go proxyProvider.HealthCheck()
+				}
+			}
+		}
+	}
+}
+
+// SupportUDP implements C.ProxyAdapter
+func (f *Fallback) SupportUDP() bool {
+	if f.disableUDP {
+		return false
+	}
+
+	proxy := f.findAliveProxy(false)
+	return proxy.SupportUDP()
+}
+
+// MarshalJSON implements C.ProxyAdapter
+func (f *Fallback) MarshalJSON() ([]byte, error) {
+	var all []string
+	for _, proxy := range f.proxies(false) {
+		all = append(all, proxy.Name())
+	}
+	return json.Marshal(map[string]interface{}{
+		"type": f.Type().String(),
+		"now":  f.Now(),
+		"all":  all,
+	})
+}
+
+// Unwrap implements C.ProxyAdapter
+func (f *Fallback) Unwrap(metadata *C.Metadata) C.Proxy {
+	proxy := f.findAliveProxy(true)
+	return proxy
+}
+
+func (f *Fallback) proxies(touch bool) []C.Proxy {
+	elm, _, _ := f.single.Do(func() (interface{}, error) {
+		return getProvidersProxies(f.providers, touch), nil
+	})
+
+	return elm.([]C.Proxy)
+}
+
+func (f *Fallback) findAliveProxy(touch bool) C.Proxy {
+	proxies := f.proxies(touch)
+	for _, proxy := range proxies {
+		if proxy.Alive() {
+			return proxy
+		}
+	}
+
+	return proxies[0]
+}
+
+func NewFallback(option *GroupCommonOption, providers []provider.ProxyProvider) *Fallback {
+	return &Fallback{
+		Base: outbound.NewBase(outbound.BaseOption{
+			Name:        option.Name,
+			Type:        C.Fallback,
+			Interface:   option.Interface,
+			RoutingMark: option.RoutingMark,
+		}),
+		single:      singledo.NewSingle(defaultGetProxiesDuration),
+		providers:   providers,
+		disableUDP:  option.DisableUDP,
+		failedTimes: atomic.NewInt32(-1),
+		failedTime:  atomic.NewInt64(-1),
+	}
+}

adapter/outboundgroup/loadbalance.go

@@ -7,11 +7,12 @@ import (
 	"fmt"
 	"net"
 
-	"github.com/Dreamacro/clash/adapters/outbound"
-	"github.com/Dreamacro/clash/adapters/provider"
+	"github.com/Dreamacro/clash/adapter/outbound"
 	"github.com/Dreamacro/clash/common/murmur3"
 	"github.com/Dreamacro/clash/common/singledo"
+	"github.com/Dreamacro/clash/component/dialer"
 	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/constant/provider"
 
 	"golang.org/x/net/publicsuffix"
 )
@@ -68,7 +69,8 @@ func jumpHash(key uint64, buckets int32) int32 {
 	return int32(b)
 }
 
-func (lb *LoadBalance) DialContext(ctx context.Context, metadata *C.Metadata) (c C.Conn, err error) {
+// DialContext implements C.ProxyAdapter
+func (lb *LoadBalance) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (c C.Conn, err error) {
 	defer func() {
 		if err == nil {
 			c.AppendToChains(lb)
@@ -77,11 +79,12 @@ func (lb *LoadBalance) DialContext(ctx context.Context, metadata *C.Metadata) (c
 
 	proxy := lb.Unwrap(metadata)
 
-	c, err = proxy.DialContext(ctx, metadata)
+	c, err = proxy.DialContext(ctx, metadata, lb.Base.DialOptions(opts...)...)
 	return
 }
 
-func (lb *LoadBalance) DialUDP(metadata *C.Metadata) (pc C.PacketConn, err error) {
+// ListenPacketContext implements C.ProxyAdapter
+func (lb *LoadBalance) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (pc C.PacketConn, err error) {
 	defer func() {
 		if err == nil {
 			pc.AppendToChains(lb)
@@ -89,10 +92,10 @@ func (lb *LoadBalance) DialUDP(metadata *C.Metadata) (pc C.PacketConn, err error
 	}()
 
 	proxy := lb.Unwrap(metadata)
-
-	return proxy.DialUDP(metadata)
+	return proxy.ListenPacketContext(ctx, metadata, lb.Base.DialOptions(opts...)...)
 }
 
+// SupportUDP implements C.ProxyAdapter
 func (lb *LoadBalance) SupportUDP() bool {
 	return !lb.disableUDP
 }
@@ -130,6 +133,7 @@ func strategyConsistentHashing() strategyFn {
 	}
 }
 
+// Unwrap implements C.ProxyAdapter
 func (lb *LoadBalance) Unwrap(metadata *C.Metadata) C.Proxy {
 	proxies := lb.proxies(true)
 	return lb.strategyFn(proxies, metadata)
@@ -143,6 +147,7 @@ func (lb *LoadBalance) proxies(touch bool) []C.Proxy {
 	return elm.([]C.Proxy)
 }
 
+// MarshalJSON implements C.ProxyAdapter
 func (lb *LoadBalance) MarshalJSON() ([]byte, error) {
 	var all []string
 	for _, proxy := range lb.proxies(false) {
@@ -154,7 +159,7 @@ func (lb *LoadBalance) MarshalJSON() ([]byte, error) {
 	})
 }
 
-func NewLoadBalance(options *GroupCommonOption, providers []provider.ProxyProvider, strategy string) (lb *LoadBalance, err error) {
+func NewLoadBalance(option *GroupCommonOption, providers []provider.ProxyProvider, strategy string) (lb *LoadBalance, err error) {
 	var strategyFn strategyFn
 	switch strategy {
 	case "consistent-hashing":
@@ -165,10 +170,15 @@ func NewLoadBalance(options *GroupCommonOption, providers []provider.ProxyProvid
 		return nil, fmt.Errorf("%w: %s", errStrategy, strategy)
 	}
 	return &LoadBalance{
-		Base:       outbound.NewBase(options.Name, "", C.LoadBalance, false),
+		Base: outbound.NewBase(outbound.BaseOption{
+			Name:        option.Name,
+			Type:        C.LoadBalance,
+			Interface:   option.Interface,
+			RoutingMark: option.RoutingMark,
+		}),
 		single:     singledo.NewSingle(defaultGetProxiesDuration),
 		providers:  providers,
 		strategyFn: strategyFn,
-		disableUDP: options.DisableUDP,
+		disableUDP: option.DisableUDP,
 	}, nil
 }

adapter/outboundgroup/parser.go

@@ -4,9 +4,11 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/Dreamacro/clash/adapters/provider"
+	"github.com/Dreamacro/clash/adapter/outbound"
+	"github.com/Dreamacro/clash/adapter/provider"
 	"github.com/Dreamacro/clash/common/structure"
 	C "github.com/Dreamacro/clash/constant"
+	types "github.com/Dreamacro/clash/constant/provider"
 )
 
 var (
@@ -14,10 +16,11 @@ var (
 	errType              = errors.New("unsupport type")
 	errMissProxy         = errors.New("`use` or `proxies` missing")
 	errMissHealthCheck   = errors.New("`url` or `interval` missing")
-	errDuplicateProvider = errors.New("`duplicate provider name")
+	errDuplicateProvider = errors.New("duplicate provider name")
 )
 
 type GroupCommonOption struct {
+	outbound.BasicOption
 	Name       string   `group:"name"`
 	Type       string   `group:"type"`
 	Proxies    []string `group:"proxies,omitempty"`
@@ -28,7 +31,7 @@ type GroupCommonOption struct {
 	DisableUDP bool     `group:"disable-udp,omitempty"`
 }
 
-func ParseProxyGroup(config map[string]interface{}, proxyMap map[string]C.Proxy, providersMap map[string]provider.ProxyProvider) (C.ProxyAdapter, error) {
+func ParseProxyGroup(config map[string]interface{}, proxyMap map[string]C.Proxy, providersMap map[string]types.ProxyProvider) (C.ProxyAdapter, error) {
 	decoder := structure.NewDecoder(structure.Option{TagName: "group", WeaklyTypedInput: true})
 
 	groupOption := &GroupCommonOption{
@@ -44,7 +47,7 @@ func ParseProxyGroup(config map[string]interface{}, proxyMap map[string]C.Proxy,
 
 	groupName := groupOption.Name
 
-	providers := []provider.ProxyProvider{}
+	providers := []types.ProxyProvider{}
 
 	if len(groupOption.Proxies) == 0 && len(groupOption.Use) == 0 {
 		return nil, errMissProxy
@@ -56,8 +59,12 @@ func ParseProxyGroup(config map[string]interface{}, proxyMap map[string]C.Proxy,
 			return nil, err
 		}
 
-		// if Use not empty, drop health check options
-		if len(groupOption.Use) != 0 {
+		if _, ok := providersMap[groupName]; ok {
+			return nil, errDuplicateProvider
+		}
+
+		// select don't need health check
+		if groupOption.Type == "select" || groupOption.Type == "relay" {
 			hc := provider.NewHealthCheck(ps, "", 0, true)
 			pd, err := provider.NewCompatibleProvider(groupName, ps, hc)
 			if err != nil {
@@ -65,35 +72,20 @@ func ParseProxyGroup(config map[string]interface{}, proxyMap map[string]C.Proxy,
 			}
 
 			providers = append(providers, pd)
+			providersMap[groupName] = pd
 		} else {
-			if _, ok := providersMap[groupName]; ok {
-				return nil, errDuplicateProvider
+			if groupOption.URL == "" || groupOption.Interval == 0 {
+				return nil, errMissHealthCheck
 			}
 
-			// select don't need health check
-			if groupOption.Type == "select" || groupOption.Type == "relay" {
-				hc := provider.NewHealthCheck(ps, "", 0, true)
-				pd, err := provider.NewCompatibleProvider(groupName, ps, hc)
-				if err != nil {
-					return nil, err
-				}
-
-				providers = append(providers, pd)
-				providersMap[groupName] = pd
-			} else {
-				if groupOption.URL == "" || groupOption.Interval == 0 {
-					return nil, errMissHealthCheck
-				}
-
-				hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval), groupOption.Lazy)
-				pd, err := provider.NewCompatibleProvider(groupName, ps, hc)
-				if err != nil {
-					return nil, err
-				}
-
-				providers = append(providers, pd)
-				providersMap[groupName] = pd
+			hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval), groupOption.Lazy)
+			pd, err := provider.NewCompatibleProvider(groupName, ps, hc)
+			if err != nil {
+				return nil, err
 			}
+
+			providers = append(providers, pd)
+			providersMap[groupName] = pd
 		}
 	}
 
@@ -138,15 +130,15 @@ func getProxies(mapping map[string]C.Proxy, list []string) ([]C.Proxy, error) {
 	return ps, nil
 }
 
-func getProviders(mapping map[string]provider.ProxyProvider, list []string) ([]provider.ProxyProvider, error) {
-	var ps []provider.ProxyProvider
+func getProviders(mapping map[string]types.ProxyProvider, list []string) ([]types.ProxyProvider, error) {
+	var ps []types.ProxyProvider
 	for _, name := range list {
 		p, ok := mapping[name]
 		if !ok {
 			return nil, fmt.Errorf("'%s' not found", name)
 		}
 
-		if p.VehicleType() == provider.Compatible {
+		if p.VehicleType() == types.Compatible {
 			return nil, fmt.Errorf("proxy group %s can't contains in `use`", name)
 		}
 		ps = append(ps, p)

adapter/outboundgroup/relay.go

@@ -3,14 +3,13 @@ package outboundgroup
 import (
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 
-	"github.com/Dreamacro/clash/adapters/outbound"
-	"github.com/Dreamacro/clash/adapters/provider"
+	"github.com/Dreamacro/clash/adapter/outbound"
 	"github.com/Dreamacro/clash/common/singledo"
 	"github.com/Dreamacro/clash/component/dialer"
 	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/constant/provider"
 )
 
 type Relay struct {
@@ -19,15 +18,26 @@ type Relay struct {
 	providers []provider.ProxyProvider
 }
 
-func (r *Relay) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
-	proxies := r.proxies(metadata, true)
-	if len(proxies) == 0 {
-		return nil, errors.New("proxy does not exist")
+// DialContext implements C.ProxyAdapter
+func (r *Relay) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.Conn, error) {
+	var proxies []C.Proxy
+	for _, proxy := range r.proxies(metadata, true) {
+		if proxy.Type() != C.Direct {
+			proxies = append(proxies, proxy)
+		}
 	}
+
+	switch len(proxies) {
+	case 0:
+		return outbound.NewDirect().DialContext(ctx, metadata, r.Base.DialOptions(opts...)...)
+	case 1:
+		return proxies[0].DialContext(ctx, metadata, r.Base.DialOptions(opts...)...)
+	}
+
 	first := proxies[0]
 	last := proxies[len(proxies)-1]
 
-	c, err := dialer.DialContext(ctx, "tcp", first.Addr())
+	c, err := dialer.DialContext(ctx, "tcp", first.Addr(), r.Base.DialOptions(opts...)...)
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error: %w", first.Addr(), err)
 	}
@@ -56,6 +66,7 @@ func (r *Relay) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn,
 	return outbound.NewConn(c, r), nil
 }
 
+// MarshalJSON implements C.ProxyAdapter
 func (r *Relay) MarshalJSON() ([]byte, error) {
 	var all []string
 	for _, proxy := range r.rawProxies(false) {
@@ -89,9 +100,14 @@ func (r *Relay) proxies(metadata *C.Metadata, touch bool) []C.Proxy {
 	return proxies
 }
 
-func NewRelay(options *GroupCommonOption, providers []provider.ProxyProvider) *Relay {
+func NewRelay(option *GroupCommonOption, providers []provider.ProxyProvider) *Relay {
 	return &Relay{
-		Base:      outbound.NewBase(options.Name, "", C.Relay, false),
+		Base: outbound.NewBase(outbound.BaseOption{
+			Name:        option.Name,
+			Type:        C.Relay,
+			Interface:   option.Interface,
+			RoutingMark: option.RoutingMark,
+		}),
 		single:    singledo.NewSingle(defaultGetProxiesDuration),
 		providers: providers,
 	}

adapter/outboundgroup/selector.go

@@ -5,10 +5,11 @@ import (
 	"encoding/json"
 	"errors"
 
-	"github.com/Dreamacro/clash/adapters/outbound"
-	"github.com/Dreamacro/clash/adapters/provider"
+	"github.com/Dreamacro/clash/adapter/outbound"
 	"github.com/Dreamacro/clash/common/singledo"
+	"github.com/Dreamacro/clash/component/dialer"
 	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/constant/provider"
 )
 
 type Selector struct {
@@ -19,22 +20,25 @@ type Selector struct {
 	providers  []provider.ProxyProvider
 }
 
-func (s *Selector) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
-	c, err := s.selectedProxy(true).DialContext(ctx, metadata)
+// DialContext implements C.ProxyAdapter
+func (s *Selector) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.Conn, error) {
+	c, err := s.selectedProxy(true).DialContext(ctx, metadata, s.Base.DialOptions(opts...)...)
 	if err == nil {
 		c.AppendToChains(s)
 	}
 	return c, err
 }
 
-func (s *Selector) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
-	pc, err := s.selectedProxy(true).DialUDP(metadata)
+// ListenPacketContext implements C.ProxyAdapter
+func (s *Selector) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.PacketConn, error) {
+	pc, err := s.selectedProxy(true).ListenPacketContext(ctx, metadata, s.Base.DialOptions(opts...)...)
 	if err == nil {
 		pc.AppendToChains(s)
 	}
 	return pc, err
 }
 
+// SupportUDP implements C.ProxyAdapter
 func (s *Selector) SupportUDP() bool {
 	if s.disableUDP {
 		return false
@@ -43,6 +47,7 @@ func (s *Selector) SupportUDP() bool {
 	return s.selectedProxy(false).SupportUDP()
 }
 
+// MarshalJSON implements C.ProxyAdapter
 func (s *Selector) MarshalJSON() ([]byte, error) {
 	var all []string
 	for _, proxy := range getProvidersProxies(s.providers, false) {
@@ -72,6 +77,7 @@ func (s *Selector) Set(name string) error {
 	return errors.New("proxy not exist")
 }
 
+// Unwrap implements C.ProxyAdapter
 func (s *Selector) Unwrap(metadata *C.Metadata) C.Proxy {
 	return s.selectedProxy(true)
 }
@@ -91,13 +97,18 @@ func (s *Selector) selectedProxy(touch bool) C.Proxy {
 	return elm.(C.Proxy)
 }
 
-func NewSelector(options *GroupCommonOption, providers []provider.ProxyProvider) *Selector {
+func NewSelector(option *GroupCommonOption, providers []provider.ProxyProvider) *Selector {
 	selected := providers[0].Proxies()[0].Name()
 	return &Selector{
-		Base:       outbound.NewBase(options.Name, "", C.Selector, false),
+		Base: outbound.NewBase(outbound.BaseOption{
+			Name:        option.Name,
+			Type:        C.Selector,
+			Interface:   option.Interface,
+			RoutingMark: option.RoutingMark,
+		}),
 		single:     singledo.NewSingle(defaultGetProxiesDuration),
 		providers:  providers,
 		selected:   selected,
-		disableUDP: options.DisableUDP,
+		disableUDP: option.DisableUDP,
 	}
 }

adapter/outboundgroup/urltest.go

@@ -0,0 +1,196 @@
+package outboundgroup
+
+import (
+	"context"
+	"encoding/json"
+	"github.com/Dreamacro/clash/log"
+	"go.uber.org/atomic"
+	"time"
+
+	"github.com/Dreamacro/clash/adapter/outbound"
+	"github.com/Dreamacro/clash/common/singledo"
+	"github.com/Dreamacro/clash/component/dialer"
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/constant/provider"
+)
+
+type urlTestOption func(*URLTest)
+
+func urlTestWithTolerance(tolerance uint16) urlTestOption {
+	return func(u *URLTest) {
+		u.tolerance = tolerance
+	}
+}
+
+type URLTest struct {
+	*outbound.Base
+	tolerance   uint16
+	disableUDP  bool
+	fastNode    C.Proxy
+	single      *singledo.Single
+	fastSingle  *singledo.Single
+	providers   []provider.ProxyProvider
+	failedTimes *atomic.Int32
+	failedTime  *atomic.Int64
+}
+
+func (u *URLTest) Now() string {
+	return u.fast(false).Name()
+}
+
+// DialContext implements C.ProxyAdapter
+func (u *URLTest) DialContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (c C.Conn, err error) {
+	c, err = u.fast(true).DialContext(ctx, metadata, u.Base.DialOptions(opts...)...)
+	if err == nil {
+		c.AppendToChains(u)
+		u.failedTimes.Store(-1)
+		u.failedTime.Store(-1)
+	} else {
+		u.onDialFailed()
+	}
+
+	return c, err
+}
+
+// ListenPacketContext implements C.ProxyAdapter
+func (u *URLTest) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.PacketConn, error) {
+	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
+}
+
+// Unwrap implements C.ProxyAdapter
+func (u *URLTest) Unwrap(metadata *C.Metadata) C.Proxy {
+	return u.fast(true)
+}
+
+func (u *URLTest) proxies(touch bool) []C.Proxy {
+	elm, _, _ := u.single.Do(func() (interface{}, error) {
+		return getProvidersProxies(u.providers, touch), nil
+	})
+
+	return elm.([]C.Proxy)
+}
+
+func (u *URLTest) fast(touch bool) C.Proxy {
+	elm, _, _ := u.fastSingle.Do(func() (interface{}, error) {
+		proxies := u.proxies(touch)
+		fast := proxies[0]
+		min := fast.LastDelay()
+		fastNotExist := true
+
+		for _, proxy := range proxies[1:] {
+			if u.fastNode != nil && proxy.Name() == u.fastNode.Name() {
+				fastNotExist = false
+			}
+
+			if !proxy.Alive() {
+				continue
+			}
+
+			delay := proxy.LastDelay()
+			if delay < min {
+				fast = proxy
+				min = delay
+			}
+		}
+
+		// tolerance
+		if u.fastNode == nil || fastNotExist || !u.fastNode.Alive() || u.fastNode.LastDelay() > fast.LastDelay()+u.tolerance {
+			u.fastNode = fast
+		}
+
+		return u.fastNode, nil
+	})
+
+	return elm.(C.Proxy)
+}
+
+// SupportUDP implements C.ProxyAdapter
+func (u *URLTest) SupportUDP() bool {
+	if u.disableUDP {
+		return false
+	}
+
+	return u.fast(false).SupportUDP()
+}
+
+// MarshalJSON implements C.ProxyAdapter
+func (u *URLTest) MarshalJSON() ([]byte, error) {
+	var all []string
+	for _, proxy := range u.proxies(false) {
+		all = append(all, proxy.Name())
+	}
+	return json.Marshal(map[string]interface{}{
+		"type": u.Type().String(),
+		"now":  u.Now(),
+		"all":  all,
+	})
+}
+
+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 {
+			u.failedTimes.Inc()
+			failedCount := u.failedTimes.Load()
+			log.Warnln("%s failed count: %d", u.Name(), failedCount)
+			if failedCount > 5 {
+				log.Debugln("%s failed multiple times.", u.Name())
+				for _, proxyProvider := range u.providers {
+					go proxyProvider.HealthCheck()
+				}
+			}
+		}
+	}
+}
+
+func parseURLTestOption(config map[string]interface{}) []urlTestOption {
+	opts := []urlTestOption{}
+
+	// tolerance
+	if elm, ok := config["tolerance"]; ok {
+		if tolerance, ok := elm.(int); ok {
+			opts = append(opts, urlTestWithTolerance(uint16(tolerance)))
+		}
+	}
+
+	return opts
+}
+
+func NewURLTest(option *GroupCommonOption, providers []provider.ProxyProvider, options ...urlTestOption) *URLTest {
+	urlTest := &URLTest{
+		Base: outbound.NewBase(outbound.BaseOption{
+			Name:        option.Name,
+			Type:        C.URLTest,
+			Interface:   option.Interface,
+			RoutingMark: option.RoutingMark,
+		}),
+		single:      singledo.NewSingle(defaultGetProxiesDuration),
+		fastSingle:  singledo.NewSingle(time.Second * 10),
+		providers:   providers,
+		disableUDP:  option.DisableUDP,
+		failedTimes: atomic.NewInt32(-1),
+		failedTime:  atomic.NewInt64(-1),
+	}
+
+	for _, option := range options {
+		option(urlTest)
+	}
+
+	return urlTest
+}

adapter/outboundgroup/util.go

@@ -16,25 +16,7 @@ func addrToMetadata(rawAddress string) (addr *C.Metadata, err error) {
 	}
 
 	ip := net.ParseIP(host)
-	if ip != nil {
-		if ip.To4() != nil {
-			addr = &C.Metadata{
-				AddrType: C.AtypIPv4,
-				Host:     "",
-				DstIP:    ip,
-				DstPort:  port,
-			}
-			return
-		} else {
-			addr = &C.Metadata{
-				AddrType: C.AtypIPv6,
-				Host:     "",
-				DstIP:    ip,
-				DstPort:  port,
-			}
-			return
-		}
-	} else {
+	if ip == nil {
 		addr = &C.Metadata{
 			AddrType: C.AtypDomainName,
 			Host:     host,
@@ -42,7 +24,23 @@ func addrToMetadata(rawAddress string) (addr *C.Metadata, err error) {
 			DstPort:  port,
 		}
 		return
+	} else if ip4 := ip.To4(); ip4 != nil {
+		addr = &C.Metadata{
+			AddrType: C.AtypIPv4,
+			Host:     "",
+			DstIP:    ip4,
+			DstPort:  port,
+		}
+		return
 	}
+
+	addr = &C.Metadata{
+		AddrType: C.AtypIPv6,
+		Host:     "",
+		DstIP:    ip,
+		DstPort:  port,
+	}
+	return
 }
 
 func tcpKeepAlive(c net.Conn) {

adapter/parser.go

@@ -1,8 +1,9 @@
-package outbound
+package adapter
 
 import (
 	"fmt"
 
+	"github.com/Dreamacro/clash/adapter/outbound"
 	"github.com/Dreamacro/clash/common/structure"
 	C "github.com/Dreamacro/clash/constant"
 )
@@ -20,36 +21,36 @@ func ParseProxy(mapping map[string]interface{}) (C.Proxy, error) {
 	)
 	switch proxyType {
 	case "ss":
-		ssOption := &ShadowSocksOption{}
+		ssOption := &outbound.ShadowSocksOption{}
 		err = decoder.Decode(mapping, ssOption)
 		if err != nil {
 			break
 		}
-		proxy, err = NewShadowSocks(*ssOption)
+		proxy, err = outbound.NewShadowSocks(*ssOption)
 	case "ssr":
-		ssrOption := &ShadowSocksROption{}
+		ssrOption := &outbound.ShadowSocksROption{}
 		err = decoder.Decode(mapping, ssrOption)
 		if err != nil {
 			break
 		}
-		proxy, err = NewShadowSocksR(*ssrOption)
+		proxy, err = outbound.NewShadowSocksR(*ssrOption)
 	case "socks5":
-		socksOption := &Socks5Option{}
+		socksOption := &outbound.Socks5Option{}
 		err = decoder.Decode(mapping, socksOption)
 		if err != nil {
 			break
 		}
-		proxy = NewSocks5(*socksOption)
+		proxy = outbound.NewSocks5(*socksOption)
 	case "http":
-		httpOption := &HttpOption{}
+		httpOption := &outbound.HttpOption{}
 		err = decoder.Decode(mapping, httpOption)
 		if err != nil {
 			break
 		}
-		proxy = NewHttp(*httpOption)
+		proxy = outbound.NewHttp(*httpOption)
 	case "vmess":
-		vmessOption := &VmessOption{
-			HTTPOpts: HTTPOptions{
+		vmessOption := &outbound.VmessOption{
+			HTTPOpts: outbound.HTTPOptions{
 				Method: "GET",
 				Path:   []string{"/"},
 			},
@@ -58,21 +59,28 @@ func ParseProxy(mapping map[string]interface{}) (C.Proxy, error) {
 		if err != nil {
 			break
 		}
-		proxy, err = NewVmess(*vmessOption)
+		proxy, err = outbound.NewVmess(*vmessOption)
+	case "vless":
+		vlessOption := &outbound.VlessOption{}
+		err = decoder.Decode(mapping, vlessOption)
+		if err != nil {
+			break
+		}
+		proxy, err = outbound.NewVless(*vlessOption)
 	case "snell":
-		snellOption := &SnellOption{}
+		snellOption := &outbound.SnellOption{}
 		err = decoder.Decode(mapping, snellOption)
 		if err != nil {
 			break
 		}
-		proxy, err = NewSnell(*snellOption)
+		proxy, err = outbound.NewSnell(*snellOption)
 	case "trojan":
-		trojanOption := &TrojanOption{}
+		trojanOption := &outbound.TrojanOption{}
 		err = decoder.Decode(mapping, trojanOption)
 		if err != nil {
 			break
 		}
-		proxy, err = NewTrojan(*trojanOption)
+		proxy, err = outbound.NewTrojan(*trojanOption)
 	default:
 		return nil, fmt.Errorf("unsupport proxy type: %s", proxyType)
 	}

adapter/provider/fetcher.go

@@ -3,24 +3,24 @@ package provider
 import (
 	"bytes"
 	"crypto/md5"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"time"
 
+	types "github.com/Dreamacro/clash/constant/provider"
 	"github.com/Dreamacro/clash/log"
 )
 
 var (
-	fileMode os.FileMode = 0666
-	dirMode  os.FileMode = 0755
+	fileMode os.FileMode = 0o666
+	dirMode  os.FileMode = 0o755
 )
 
 type parser = func([]byte) (interface{}, error)
 
 type fetcher struct {
 	name      string
-	vehicle   Vehicle
+	vehicle   types.Vehicle
 	updatedAt *time.Time
 	ticker    *time.Ticker
 	done      chan struct{}
@@ -33,7 +33,7 @@ func (f *fetcher) Name() string {
 	return f.name
 }
 
-func (f *fetcher) VehicleType() VehicleType {
+func (f *fetcher) VehicleType() types.VehicleType {
 	return f.vehicle.Type()
 }
 
@@ -44,7 +44,7 @@ func (f *fetcher) Initial() (interface{}, error) {
 		isLocal bool
 	)
 	if stat, fErr := os.Stat(f.vehicle.Path()); fErr == nil {
-		buf, err = ioutil.ReadFile(f.vehicle.Path())
+		buf, err = os.ReadFile(f.vehicle.Path())
 		modTime := stat.ModTime()
 		f.updatedAt = &modTime
 		isLocal = true
@@ -72,9 +72,11 @@ func (f *fetcher) Initial() (interface{}, error) {
 		if err != nil {
 			return nil, err
 		}
+
+		isLocal = false
 	}
 
-	if f.vehicle.Type() != File && !isLocal {
+	if f.vehicle.Type() != types.File && !isLocal {
 		if err := safeWrite(f.vehicle.Path(), buf); err != nil {
 			return nil, err
 		}
@@ -108,7 +110,7 @@ func (f *fetcher) Update() (interface{}, bool, error) {
 		return nil, false, err
 	}
 
-	if f.vehicle.Type() != File {
+	if f.vehicle.Type() != types.File {
 		if err := safeWrite(f.vehicle.Path(), buf); err != nil {
 			return nil, false, err
 		}
@@ -162,10 +164,10 @@ func safeWrite(path string, buf []byte) error {
 		}
 	}
 
-	return ioutil.WriteFile(path, buf, fileMode)
+	return os.WriteFile(path, buf, fileMode)
 }
 
-func newFetcher(name string, interval time.Duration, vehicle Vehicle, parser parser, onUpdate func(interface{})) *fetcher {
+func newFetcher(name string, interval time.Duration, vehicle types.Vehicle, parser parser, onUpdate func(interface{})) *fetcher {
 	var ticker *time.Ticker
 	if interval != 0 {
 		ticker = time.NewTicker(interval)

adapter/provider/healthcheck.go

@@ -2,9 +2,9 @@ package provider
 
 import (
 	"context"
-	"sync"
 	"time"
 
+	"github.com/Dreamacro/clash/common/batch"
 	C "github.com/Dreamacro/clash/constant"
 
 	"go.uber.org/atomic"
@@ -59,20 +59,17 @@ func (hc *HealthCheck) touch() {
 }
 
 func (hc *HealthCheck) check() {
-	ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout)
-	wg := &sync.WaitGroup{}
-
+	b, _ := batch.New(context.Background(), batch.WithConcurrencyNum(10))
 	for _, proxy := range hc.proxies {
-		wg.Add(1)
-
-		go func(p C.Proxy) {
+		p := proxy
+		b.Go(p.Name(), func() (interface{}, error) {
+			ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout)
+			defer cancel()
 			p.URLTest(ctx, hc.url)
-			wg.Done()
-		}(proxy)
+			return nil, nil
+		})
 	}
-
-	wg.Wait()
-	cancel()
+	b.Wait()
 }
 
 func (hc *HealthCheck) close() {

adapter/provider/parser.go

@@ -7,11 +7,10 @@ import (
 
 	"github.com/Dreamacro/clash/common/structure"
 	C "github.com/Dreamacro/clash/constant"
+	types "github.com/Dreamacro/clash/constant/provider"
 )
 
-var (
-	errVehicleType = errors.New("unsupport vehicle type")
-)
+var errVehicleType = errors.New("unsupport vehicle type")
 
 type healthCheckSchema struct {
 	Enable   bool   `provider:"enable"`
@@ -25,10 +24,11 @@ type proxyProviderSchema struct {
 	Path        string            `provider:"path"`
 	URL         string            `provider:"url,omitempty"`
 	Interval    int               `provider:"interval,omitempty"`
+	Filter      string            `provider:"filter,omitempty"`
 	HealthCheck healthCheckSchema `provider:"health-check,omitempty"`
 }
 
-func ParseProxyProvider(name string, mapping map[string]interface{}) (ProxyProvider, error) {
+func ParseProxyProvider(name string, mapping map[string]interface{}) (types.ProxyProvider, error) {
 	decoder := structure.NewDecoder(structure.Option{TagName: "provider", WeaklyTypedInput: true})
 
 	schema := &proxyProviderSchema{
@@ -40,7 +40,7 @@ func ParseProxyProvider(name string, mapping map[string]interface{}) (ProxyProvi
 		return nil, err
 	}
 
-	var hcInterval uint = 0
+	var hcInterval uint
 	if schema.HealthCheck.Enable {
 		hcInterval = uint(schema.HealthCheck.Interval)
 	}
@@ -48,7 +48,7 @@ func ParseProxyProvider(name string, mapping map[string]interface{}) (ProxyProvi
 
 	path := C.Path.Resolve(schema.Path)
 
-	var vehicle Vehicle
+	var vehicle types.Vehicle
 	switch schema.Type {
 	case "file":
 		vehicle = NewFileVehicle(path)
@@ -59,5 +59,6 @@ func ParseProxyProvider(name string, mapping map[string]interface{}) (ProxyProvi
 	}
 
 	interval := time.Duration(uint(schema.Interval)) * time.Second
-	return NewProxySetProvider(name, interval, vehicle, hc), nil
+	filter := schema.Filter
+	return NewProxySetProvider(name, interval, filter, vehicle, hc)
 }

adapter/provider/provider.go

@@ -4,11 +4,13 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"regexp"
 	"runtime"
 	"time"
 
-	"github.com/Dreamacro/clash/adapters/outbound"
+	"github.com/Dreamacro/clash/adapter"
 	C "github.com/Dreamacro/clash/constant"
+	types "github.com/Dreamacro/clash/constant/provider"
 
 	"gopkg.in/yaml.v2"
 )
@@ -17,45 +19,6 @@ const (
 	ReservedName = "default"
 )
 
-// Provider Type
-const (
-	Proxy ProviderType = iota
-	Rule
-)
-
-// ProviderType defined
-type ProviderType int
-
-func (pt ProviderType) String() string {
-	switch pt {
-	case Proxy:
-		return "Proxy"
-	case Rule:
-		return "Rule"
-	default:
-		return "Unknown"
-	}
-}
-
-// Provider interface
-type Provider interface {
-	Name() string
-	VehicleType() VehicleType
-	Type() ProviderType
-	Initial() error
-	Update() error
-}
-
-// ProxyProvider interface
-type ProxyProvider interface {
-	Provider
-	Proxies() []C.Proxy
-	// ProxiesWithTouch is used to inform the provider that the proxy is actually being used while getting the list of proxies.
-	// Commonly used in Dial and DialUDP
-	ProxiesWithTouch() []C.Proxy
-	HealthCheck()
-}
-
 type ProxySchema struct {
 	Proxies []map[string]interface{} `yaml:"proxies"`
 }
@@ -107,8 +70,8 @@ func (pp *proxySetProvider) Initial() error {
 	return nil
 }
 
-func (pp *proxySetProvider) Type() ProviderType {
-	return Proxy
+func (pp *proxySetProvider) Type() types.ProviderType {
+	return types.Proxy
 }
 
 func (pp *proxySetProvider) Proxies() []C.Proxy {
@@ -120,33 +83,6 @@ func (pp *proxySetProvider) ProxiesWithTouch() []C.Proxy {
 	return pp.Proxies()
 }
 
-func proxiesParse(buf []byte) (interface{}, error) {
-	schema := &ProxySchema{}
-
-	if err := yaml.Unmarshal(buf, schema); err != nil {
-		return nil, err
-	}
-
-	if schema.Proxies == nil {
-		return nil, errors.New("file must have a `proxies` field")
-	}
-
-	proxies := []C.Proxy{}
-	for idx, mapping := range schema.Proxies {
-		proxy, err := outbound.ParseProxy(mapping)
-		if err != nil {
-			return nil, fmt.Errorf("proxy %d error: %w", idx, err)
-		}
-		proxies = append(proxies, proxy)
-	}
-
-	if len(proxies) == 0 {
-		return nil, errors.New("file doesn't have any valid proxy")
-	}
-
-	return proxies, nil
-}
-
 func (pp *proxySetProvider) setProxies(proxies []C.Proxy) {
 	pp.proxies = proxies
 	pp.healthCheck.setProxy(proxies)
@@ -160,7 +96,12 @@ func stopProxyProvider(pd *ProxySetProvider) {
 	pd.fetcher.Destroy()
 }
 
-func NewProxySetProvider(name string, interval time.Duration, vehicle Vehicle, hc *HealthCheck) *ProxySetProvider {
+func NewProxySetProvider(name string, interval time.Duration, filter string, vehicle types.Vehicle, hc *HealthCheck) (*ProxySetProvider, error) {
+	filterReg, err := regexp.Compile(filter)
+	if err != nil {
+		return nil, fmt.Errorf("invalid filter regex: %w", err)
+	}
+
 	if hc.auto() {
 		go hc.process()
 	}
@@ -175,12 +116,45 @@ func NewProxySetProvider(name string, interval time.Duration, vehicle Vehicle, h
 		pd.setProxies(ret)
 	}
 
-	fetcher := newFetcher(name, interval, vehicle, proxiesParse, onUpdate)
+	proxiesParseAndFilter := func(buf []byte) (interface{}, error) {
+		schema := &ProxySchema{}
+
+		if err := yaml.Unmarshal(buf, schema); err != nil {
+			return nil, err
+		}
+
+		if schema.Proxies == nil {
+			return nil, errors.New("file must have a `proxies` field")
+		}
+
+		proxies := []C.Proxy{}
+		for idx, mapping := range schema.Proxies {
+			if name, ok := mapping["name"]; ok && len(filter) > 0 && !filterReg.MatchString(name.(string)) {
+				continue
+			}
+			proxy, err := adapter.ParseProxy(mapping)
+			if err != nil {
+				return nil, fmt.Errorf("proxy %d error: %w", idx, err)
+			}
+			proxies = append(proxies, proxy)
+		}
+
+		if len(proxies) == 0 {
+			if len(filter) > 0 {
+				return nil, errors.New("doesn't match any proxy, please check your filter")
+			}
+			return nil, errors.New("file doesn't have any proxy")
+		}
+
+		return proxies, nil
+	}
+
+	fetcher := newFetcher(name, interval, vehicle, proxiesParseAndFilter, onUpdate)
 	pd.fetcher = fetcher
 
 	wrapper := &ProxySetProvider{pd}
 	runtime.SetFinalizer(wrapper, stopProxyProvider)
-	return wrapper
+	return wrapper, nil
 }
 
 // for auto gc
@@ -219,12 +193,12 @@ func (cp *compatibleProvider) Initial() error {
 	return nil
 }
 
-func (cp *compatibleProvider) VehicleType() VehicleType {
-	return Compatible
+func (cp *compatibleProvider) VehicleType() types.VehicleType {
+	return types.Compatible
 }
 
-func (cp *compatibleProvider) Type() ProviderType {
-	return Proxy
+func (cp *compatibleProvider) Type() types.ProviderType {
+	return types.Proxy
 }
 
 func (cp *compatibleProvider) Proxies() []C.Proxy {
@@ -242,7 +216,7 @@ func stopCompatibleProvider(pd *CompatibleProvider) {
 
 func NewCompatibleProvider(name string, proxies []C.Proxy, hc *HealthCheck) (*CompatibleProvider, error) {
 	if len(proxies) == 0 {
-		return nil, errors.New("Provider need one proxy at least")
+		return nil, errors.New("provider need one proxy at least")
 	}
 
 	if hc.auto() {

adapter/provider/vehicle.go

@@ -2,49 +2,24 @@ package provider
 
 import (
 	"context"
-	"io/ioutil"
+	"io"
+	"net"
 	"net/http"
 	"net/url"
+	"os"
 	"time"
 
+	netHttp "github.com/Dreamacro/clash/common/net"
 	"github.com/Dreamacro/clash/component/dialer"
+	types "github.com/Dreamacro/clash/constant/provider"
 )
 
-// Vehicle Type
-const (
-	File VehicleType = iota
-	HTTP
-	Compatible
-)
-
-// VehicleType defined
-type VehicleType int
-
-func (v VehicleType) String() string {
-	switch v {
-	case File:
-		return "File"
-	case HTTP:
-		return "HTTP"
-	case Compatible:
-		return "Compatible"
-	default:
-		return "Unknown"
-	}
-}
-
-type Vehicle interface {
-	Read() ([]byte, error)
-	Path() string
-	Type() VehicleType
-}
-
 type FileVehicle struct {
 	path string
 }
 
-func (f *FileVehicle) Type() VehicleType {
-	return File
+func (f *FileVehicle) Type() types.VehicleType {
+	return types.File
 }
 
 func (f *FileVehicle) Path() string {
@@ -52,7 +27,7 @@ func (f *FileVehicle) Path() string {
 }
 
 func (f *FileVehicle) Read() ([]byte, error) {
-	return ioutil.ReadFile(f.path)
+	return os.ReadFile(f.path)
 }
 
 func NewFileVehicle(path string) *FileVehicle {
@@ -64,8 +39,8 @@ type HTTPVehicle struct {
 	path string
 }
 
-func (h *HTTPVehicle) Type() VehicleType {
-	return HTTP
+func (h *HTTPVehicle) Type() types.VehicleType {
+	return types.HTTP
 }
 
 func (h *HTTPVehicle) Path() string {
@@ -82,6 +57,8 @@ func (h *HTTPVehicle) Read() ([]byte, error) {
 	}
 
 	req, err := http.NewRequest(http.MethodGet, uri.String(), nil)
+	req.Header.Set("user-agent", netHttp.UA)
+
 	if err != nil {
 		return nil, err
 	}
@@ -99,7 +76,9 @@ func (h *HTTPVehicle) Read() ([]byte, error) {
 		IdleConnTimeout:       90 * time.Second,
 		TLSHandshakeTimeout:   10 * time.Second,
 		ExpectContinueTimeout: 1 * time.Second,
-		DialContext:           dialer.DialContext,
+		DialContext: func(ctx context.Context, network, address string) (net.Conn, error) {
+			return dialer.DialContext(ctx, network, address)
+		},
 	}
 
 	client := http.Client{Transport: transport}
@@ -109,7 +88,7 @@ func (h *HTTPVehicle) Read() ([]byte, error) {
 	}
 	defer resp.Body.Close()
 
-	buf, err := ioutil.ReadAll(resp.Body)
+	buf, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return nil, err
 	}

adapters/inbound/http.go

@@ -1,45 +0,0 @@
-package inbound
-
-import (
-	"net"
-	"net/http"
-	"strings"
-
-	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/context"
-)
-
-// NewHTTP recieve normal http request and return HTTPContext
-func NewHTTP(request *http.Request, conn net.Conn) *context.HTTPContext {
-	metadata := parseHTTPAddr(request)
-	metadata.Type = C.HTTP
-	if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
-		metadata.SrcIP = ip
-		metadata.SrcPort = port
-	}
-	return context.NewHTTPContext(conn, request, metadata)
-}
-
-// RemoveHopByHopHeaders remove hop-by-hop header
-func RemoveHopByHopHeaders(header http.Header) {
-	// Strip hop-by-hop header based on RFC:
-	// http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.5.1
-	// https://www.mnot.net/blog/2011/07/11/what_proxies_must_do
-
-	header.Del("Proxy-Connection")
-	header.Del("Proxy-Authenticate")
-	header.Del("Proxy-Authorization")
-	header.Del("TE")
-	header.Del("Trailers")
-	header.Del("Transfer-Encoding")
-	header.Del("Upgrade")
-
-	connections := header.Get("Connection")
-	header.Del("Connection")
-	if len(connections) == 0 {
-		return
-	}
-	for _, h := range strings.Split(connections, ",") {
-		header.Del(strings.TrimSpace(h))
-	}
-}

adapters/outbound/reject.go

@@ -1,61 +0,0 @@
-package outbound
-
-import (
-	"context"
-	"errors"
-	"io"
-	"net"
-	"time"
-
-	C "github.com/Dreamacro/clash/constant"
-)
-
-type Reject struct {
-	*Base
-}
-
-func (r *Reject) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
-	return NewConn(&NopConn{}, r), nil
-}
-
-func (r *Reject) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
-	return nil, errors.New("match reject rule")
-}
-
-func NewReject() *Reject {
-	return &Reject{
-		Base: &Base{
-			name: "REJECT",
-			tp:   C.Reject,
-			udp:  true,
-		},
-	}
-}
-
-type NopConn struct{}
-
-func (rw *NopConn) Read(b []byte) (int, error) {
-	return 0, io.EOF
-}
-
-func (rw *NopConn) Write(b []byte) (int, error) {
-	return 0, io.EOF
-}
-
-// Close is fake function for net.Conn
-func (rw *NopConn) Close() error { return nil }
-
-// LocalAddr is fake function for net.Conn
-func (rw *NopConn) LocalAddr() net.Addr { return nil }
-
-// RemoteAddr is fake function for net.Conn
-func (rw *NopConn) RemoteAddr() net.Addr { return nil }
-
-// SetDeadline is fake function for net.Conn
-func (rw *NopConn) SetDeadline(time.Time) error { return nil }
-
-// SetReadDeadline is fake function for net.Conn
-func (rw *NopConn) SetReadDeadline(time.Time) error { return nil }
-
-// SetWriteDeadline is fake function for net.Conn
-func (rw *NopConn) SetWriteDeadline(time.Time) error { return nil }

adapters/outbound/trojan.go

@@ -1,107 +0,0 @@
-package outbound
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net"
-	"strconv"
-
-	"github.com/Dreamacro/clash/component/dialer"
-	"github.com/Dreamacro/clash/component/trojan"
-	C "github.com/Dreamacro/clash/constant"
-)
-
-type Trojan struct {
-	*Base
-	instance *trojan.Trojan
-}
-
-type TrojanOption struct {
-	Name           string   `proxy:"name"`
-	Server         string   `proxy:"server"`
-	Port           int      `proxy:"port"`
-	Password       string   `proxy:"password"`
-	ALPN           []string `proxy:"alpn,omitempty"`
-	SNI            string   `proxy:"sni,omitempty"`
-	SkipCertVerify bool     `proxy:"skip-cert-verify,omitempty"`
-	UDP            bool     `proxy:"udp,omitempty"`
-}
-
-func (t *Trojan) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
-	c, err := t.instance.StreamConn(c)
-	if err != nil {
-		return nil, fmt.Errorf("%s connect error: %w", t.addr, err)
-	}
-
-	err = t.instance.WriteHeader(c, trojan.CommandTCP, serializesSocksAddr(metadata))
-	return c, err
-}
-
-func (t *Trojan) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
-	c, err := dialer.DialContext(ctx, "tcp", t.addr)
-	if err != nil {
-		return nil, fmt.Errorf("%s connect error: %w", t.addr, err)
-	}
-	tcpKeepAlive(c)
-	c, err = t.StreamConn(c, metadata)
-	if err != nil {
-		return nil, err
-	}
-
-	return NewConn(c, t), err
-}
-
-func (t *Trojan) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), tcpTimeout)
-	defer cancel()
-	c, err := dialer.DialContext(ctx, "tcp", t.addr)
-	if err != nil {
-		return nil, fmt.Errorf("%s connect error: %w", t.addr, err)
-	}
-	tcpKeepAlive(c)
-	c, err = t.instance.StreamConn(c)
-	if err != nil {
-		return nil, fmt.Errorf("%s connect error: %w", t.addr, err)
-	}
-
-	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
-}
-
-func (t *Trojan) MarshalJSON() ([]byte, error) {
-	return json.Marshal(map[string]string{
-		"type": t.Type().String(),
-	})
-}
-
-func NewTrojan(option TrojanOption) (*Trojan, error) {
-	addr := net.JoinHostPort(option.Server, strconv.Itoa(option.Port))
-
-	tOption := &trojan.Option{
-		Password:           option.Password,
-		ALPN:               option.ALPN,
-		ServerName:         option.Server,
-		SkipCertVerify:     option.SkipCertVerify,
-		ClientSessionCache: getClientSessionCache(),
-	}
-
-	if option.SNI != "" {
-		tOption.ServerName = option.SNI
-	}
-
-	return &Trojan{
-		Base: &Base{
-			name: option.Name,
-			addr: addr,
-			tp:   C.Trojan,
-			udp:  option.UDP,
-		},
-		instance: trojan.New(tOption),
-	}, nil
-}

adapters/outbound/vmess.go

@@ -1,260 +0,0 @@
-package outbound
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net"
-	"net/http"
-	"strconv"
-	"strings"
-
-	"github.com/Dreamacro/clash/component/dialer"
-	"github.com/Dreamacro/clash/component/resolver"
-	"github.com/Dreamacro/clash/component/vmess"
-	C "github.com/Dreamacro/clash/constant"
-)
-
-type Vmess struct {
-	*Base
-	client *vmess.Client
-	option *VmessOption
-}
-
-type VmessOption struct {
-	Name           string            `proxy:"name"`
-	Server         string            `proxy:"server"`
-	Port           int               `proxy:"port"`
-	UUID           string            `proxy:"uuid"`
-	AlterID        int               `proxy:"alterId"`
-	Cipher         string            `proxy:"cipher"`
-	TLS            bool              `proxy:"tls,omitempty"`
-	UDP            bool              `proxy:"udp,omitempty"`
-	Network        string            `proxy:"network,omitempty"`
-	HTTPOpts       HTTPOptions       `proxy:"http-opts,omitempty"`
-	HTTP2Opts      HTTP2Options      `proxy:"h2-opts,omitempty"`
-	WSPath         string            `proxy:"ws-path,omitempty"`
-	WSHeaders      map[string]string `proxy:"ws-headers,omitempty"`
-	SkipCertVerify bool              `proxy:"skip-cert-verify,omitempty"`
-	ServerName     string            `proxy:"servername,omitempty"`
-}
-
-type HTTPOptions struct {
-	Method  string              `proxy:"method,omitempty"`
-	Path    []string            `proxy:"path,omitempty"`
-	Headers map[string][]string `proxy:"headers,omitempty"`
-}
-
-type HTTP2Options struct {
-	Host []string `proxy:"host,omitempty"`
-	Path string   `proxy:"path,omitempty"`
-}
-
-func (v *Vmess) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
-	var err error
-	switch v.option.Network {
-	case "ws":
-		host, port, _ := net.SplitHostPort(v.addr)
-		wsOpts := &vmess.WebsocketConfig{
-			Host: host,
-			Port: port,
-			Path: v.option.WSPath,
-		}
-
-		if len(v.option.WSHeaders) != 0 {
-			header := http.Header{}
-			for key, value := range v.option.WSHeaders {
-				header.Add(key, value)
-			}
-			wsOpts.Headers = header
-		}
-
-		if v.option.TLS {
-			wsOpts.TLS = true
-			wsOpts.SessionCache = getClientSessionCache()
-			wsOpts.SkipCertVerify = v.option.SkipCertVerify
-			wsOpts.ServerName = v.option.ServerName
-		}
-		c, err = vmess.StreamWebsocketConn(c, wsOpts)
-	case "http":
-		// readability first, so just copy default TLS logic
-		if v.option.TLS {
-			host, _, _ := net.SplitHostPort(v.addr)
-			tlsOpts := &vmess.TLSConfig{
-				Host:           host,
-				SkipCertVerify: v.option.SkipCertVerify,
-				SessionCache:   getClientSessionCache(),
-			}
-
-			if v.option.ServerName != "" {
-				tlsOpts.Host = v.option.ServerName
-			}
-
-			c, err = vmess.StreamTLSConn(c, tlsOpts)
-			if err != nil {
-				return nil, err
-			}
-		}
-
-		host, _, _ := net.SplitHostPort(v.addr)
-		httpOpts := &vmess.HTTPConfig{
-			Host:    host,
-			Method:  v.option.HTTPOpts.Method,
-			Path:    v.option.HTTPOpts.Path,
-			Headers: v.option.HTTPOpts.Headers,
-		}
-
-		c = vmess.StreamHTTPConn(c, httpOpts)
-	case "h2":
-		host, _, _ := net.SplitHostPort(v.addr)
-		tlsOpts := vmess.TLSConfig{
-			Host:           host,
-			SkipCertVerify: v.option.SkipCertVerify,
-			SessionCache:   getClientSessionCache(),
-			NextProtos:     []string{"h2"},
-		}
-
-		if v.option.ServerName != "" {
-			tlsOpts.Host = v.option.ServerName
-		}
-
-		c, err = vmess.StreamTLSConn(c, &tlsOpts)
-		if err != nil {
-			return nil, err
-		}
-
-		h2Opts := &vmess.H2Config{
-			Hosts: v.option.HTTP2Opts.Host,
-			Path:  v.option.HTTP2Opts.Path,
-		}
-
-		c, err = vmess.StreamH2Conn(c, h2Opts)
-	default:
-		// handle TLS
-		if v.option.TLS {
-			host, _, _ := net.SplitHostPort(v.addr)
-			tlsOpts := &vmess.TLSConfig{
-				Host:           host,
-				SkipCertVerify: v.option.SkipCertVerify,
-				SessionCache:   getClientSessionCache(),
-			}
-
-			if v.option.ServerName != "" {
-				tlsOpts.Host = v.option.ServerName
-			}
-
-			c, err = vmess.StreamTLSConn(c, tlsOpts)
-		}
-	}
-
-	if err != nil {
-		return nil, err
-	}
-
-	return v.client.StreamConn(c, parseVmessAddr(metadata))
-}
-
-func (v *Vmess) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
-	c, err := dialer.DialContext(ctx, "tcp", v.addr)
-	if err != nil {
-		return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
-	}
-	tcpKeepAlive(c)
-
-	c, err = v.StreamConn(c, metadata)
-	return NewConn(c, v), err
-}
-
-func (v *Vmess) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
-	// vmess use stream-oriented udp, so clash needs a net.UDPAddr
-	if !metadata.Resolved() {
-		ip, err := resolver.ResolveIP(metadata.Host)
-		if err != nil {
-			return nil, errors.New("can't resolve ip")
-		}
-		metadata.DstIP = ip
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), tcpTimeout)
-	defer cancel()
-	c, err := dialer.DialContext(ctx, "tcp", v.addr)
-	if err != nil {
-		return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
-	}
-	tcpKeepAlive(c)
-	c, err = v.StreamConn(c, metadata)
-	if err != nil {
-		return nil, fmt.Errorf("new vmess client error: %v", err)
-	}
-	return newPacketConn(&vmessPacketConn{Conn: c, rAddr: metadata.UDPAddr()}, v), nil
-}
-
-func NewVmess(option VmessOption) (*Vmess, error) {
-	security := strings.ToLower(option.Cipher)
-	client, err := vmess.NewClient(vmess.Config{
-		UUID:     option.UUID,
-		AlterID:  uint16(option.AlterID),
-		Security: security,
-		HostName: option.Server,
-		Port:     strconv.Itoa(option.Port),
-	})
-	if err != nil {
-		return nil, err
-	}
-	if option.Network == "h2" && !option.TLS {
-		return nil, fmt.Errorf("TLS must be true with h2 network")
-	}
-
-	return &Vmess{
-		Base: &Base{
-			name: option.Name,
-			addr: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
-			tp:   C.Vmess,
-			udp:  option.UDP,
-		},
-		client: client,
-		option: &option,
-	}, nil
-}
-
-func parseVmessAddr(metadata *C.Metadata) *vmess.DstAddr {
-	var addrType byte
-	var addr []byte
-	switch metadata.AddrType {
-	case C.AtypIPv4:
-		addrType = byte(vmess.AtypIPv4)
-		addr = make([]byte, net.IPv4len)
-		copy(addr[:], metadata.DstIP.To4())
-	case C.AtypIPv6:
-		addrType = byte(vmess.AtypIPv6)
-		addr = make([]byte, net.IPv6len)
-		copy(addr[:], metadata.DstIP.To16())
-	case C.AtypDomainName:
-		addrType = byte(vmess.AtypDomainName)
-		addr = make([]byte, len(metadata.Host)+1)
-		addr[0] = byte(len(metadata.Host))
-		copy(addr[1:], []byte(metadata.Host))
-	}
-
-	port, _ := strconv.Atoi(metadata.DstPort)
-	return &vmess.DstAddr{
-		UDP:      metadata.NetWork == C.UDP,
-		AddrType: addrType,
-		Addr:     addr,
-		Port:     uint(port),
-	}
-}
-
-type vmessPacketConn struct {
-	net.Conn
-	rAddr net.Addr
-}
-
-func (uc *vmessPacketConn) WriteTo(b []byte, addr net.Addr) (int, error) {
-	return uc.Conn.Write(b)
-}
-
-func (uc *vmessPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
-	n, err := uc.Conn.Read(b)
-	return n, uc.rAddr, err
-}

adapters/outboundgroup/fallback.go

@@ -1,95 +0,0 @@
-package outboundgroup
-
-import (
-	"context"
-	"encoding/json"
-
-	"github.com/Dreamacro/clash/adapters/outbound"
-	"github.com/Dreamacro/clash/adapters/provider"
-	"github.com/Dreamacro/clash/common/singledo"
-	C "github.com/Dreamacro/clash/constant"
-)
-
-type Fallback struct {
-	*outbound.Base
-	disableUDP bool
-	single     *singledo.Single
-	providers  []provider.ProxyProvider
-}
-
-func (f *Fallback) Now() string {
-	proxy := f.findAliveProxy(false)
-	return proxy.Name()
-}
-
-func (f *Fallback) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
-	proxy := f.findAliveProxy(true)
-	c, err := proxy.DialContext(ctx, metadata)
-	if err == nil {
-		c.AppendToChains(f)
-	}
-	return c, err
-}
-
-func (f *Fallback) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
-	proxy := f.findAliveProxy(true)
-	pc, err := proxy.DialUDP(metadata)
-	if err == nil {
-		pc.AppendToChains(f)
-	}
-	return pc, err
-}
-
-func (f *Fallback) SupportUDP() bool {
-	if f.disableUDP {
-		return false
-	}
-
-	proxy := f.findAliveProxy(false)
-	return proxy.SupportUDP()
-}
-
-func (f *Fallback) MarshalJSON() ([]byte, error) {
-	var all []string
-	for _, proxy := range f.proxies(false) {
-		all = append(all, proxy.Name())
-	}
-	return json.Marshal(map[string]interface{}{
-		"type": f.Type().String(),
-		"now":  f.Now(),
-		"all":  all,
-	})
-}
-
-func (f *Fallback) Unwrap(metadata *C.Metadata) C.Proxy {
-	proxy := f.findAliveProxy(true)
-	return proxy
-}
-
-func (f *Fallback) proxies(touch bool) []C.Proxy {
-	elm, _, _ := f.single.Do(func() (interface{}, error) {
-		return getProvidersProxies(f.providers, touch), nil
-	})
-
-	return elm.([]C.Proxy)
-}
-
-func (f *Fallback) findAliveProxy(touch bool) C.Proxy {
-	proxies := f.proxies(touch)
-	for _, proxy := range proxies {
-		if proxy.Alive() {
-			return proxy
-		}
-	}
-
-	return proxies[0]
-}
-
-func NewFallback(options *GroupCommonOption, providers []provider.ProxyProvider) *Fallback {
-	return &Fallback{
-		Base:       outbound.NewBase(options.Name, "", C.Fallback, false),
-		single:     singledo.NewSingle(defaultGetProxiesDuration),
-		providers:  providers,
-		disableUDP: options.DisableUDP,
-	}
-}

adapters/outboundgroup/urltest.go

@@ -1,139 +0,0 @@
-package outboundgroup
-
-import (
-	"context"
-	"encoding/json"
-	"time"
-
-	"github.com/Dreamacro/clash/adapters/outbound"
-	"github.com/Dreamacro/clash/adapters/provider"
-	"github.com/Dreamacro/clash/common/singledo"
-	C "github.com/Dreamacro/clash/constant"
-)
-
-type urlTestOption func(*URLTest)
-
-func urlTestWithTolerance(tolerance uint16) urlTestOption {
-	return func(u *URLTest) {
-		u.tolerance = tolerance
-	}
-}
-
-type URLTest struct {
-	*outbound.Base
-	tolerance  uint16
-	disableUDP bool
-	fastNode   C.Proxy
-	single     *singledo.Single
-	fastSingle *singledo.Single
-	providers  []provider.ProxyProvider
-}
-
-func (u *URLTest) Now() string {
-	return u.fast(false).Name()
-}
-
-func (u *URLTest) DialContext(ctx context.Context, metadata *C.Metadata) (c C.Conn, err error) {
-	c, err = u.fast(true).DialContext(ctx, metadata)
-	if err == nil {
-		c.AppendToChains(u)
-	}
-	return c, err
-}
-
-func (u *URLTest) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
-	pc, err := u.fast(true).DialUDP(metadata)
-	if err == nil {
-		pc.AppendToChains(u)
-	}
-	return pc, err
-}
-
-func (u *URLTest) Unwrap(metadata *C.Metadata) C.Proxy {
-	return u.fast(true)
-}
-
-func (u *URLTest) proxies(touch bool) []C.Proxy {
-	elm, _, _ := u.single.Do(func() (interface{}, error) {
-		return getProvidersProxies(u.providers, touch), nil
-	})
-
-	return elm.([]C.Proxy)
-}
-
-func (u *URLTest) fast(touch bool) C.Proxy {
-	elm, _, _ := u.fastSingle.Do(func() (interface{}, error) {
-		proxies := u.proxies(touch)
-		fast := proxies[0]
-		min := fast.LastDelay()
-		for _, proxy := range proxies[1:] {
-			if !proxy.Alive() {
-				continue
-			}
-
-			delay := proxy.LastDelay()
-			if delay < min {
-				fast = proxy
-				min = delay
-			}
-		}
-
-		// tolerance
-		if u.fastNode == nil || u.fastNode.LastDelay() > fast.LastDelay()+u.tolerance {
-			u.fastNode = fast
-		}
-
-		return u.fastNode, nil
-	})
-
-	return elm.(C.Proxy)
-}
-
-func (u *URLTest) SupportUDP() bool {
-	if u.disableUDP {
-		return false
-	}
-
-	return u.fast(false).SupportUDP()
-}
-
-func (u *URLTest) MarshalJSON() ([]byte, error) {
-	var all []string
-	for _, proxy := range u.proxies(false) {
-		all = append(all, proxy.Name())
-	}
-	return json.Marshal(map[string]interface{}{
-		"type": u.Type().String(),
-		"now":  u.Now(),
-		"all":  all,
-	})
-}
-
-func parseURLTestOption(config map[string]interface{}) []urlTestOption {
-	opts := []urlTestOption{}
-
-	// tolerance
-	if elm, ok := config["tolerance"]; ok {
-		if tolerance, ok := elm.(int); ok {
-			opts = append(opts, urlTestWithTolerance(uint16(tolerance)))
-		}
-	}
-
-	return opts
-}
-
-func NewURLTest(commonOptions *GroupCommonOption, providers []provider.ProxyProvider, options ...urlTestOption) *URLTest {
-	urlTest := &URLTest{
-		Base:       outbound.NewBase(commonOptions.Name, "", C.URLTest, false),
-		single:     singledo.NewSingle(defaultGetProxiesDuration),
-		fastSingle: singledo.NewSingle(time.Second * 10),
-		providers:  providers,
-		disableUDP: commonOptions.DisableUDP,
-	}
-
-	for _, option := range options {
-		option(urlTest)
-	}
-
-	return urlTest
-}

common/batch/batch.go

@@ -0,0 +1,105 @@
+package batch
+
+import (
+	"context"
+	"sync"
+)
+
+type Option = func(b *Batch)
+
+type Result struct {
+	Value interface{}
+	Err   error
+}
+
+type Error struct {
+	Key string
+	Err error
+}
+
+func WithConcurrencyNum(n int) Option {
+	return func(b *Batch) {
+		q := make(chan struct{}, n)
+		for i := 0; i < n; i++ {
+			q <- struct{}{}
+		}
+		b.queue = q
+	}
+}
+
+// Batch similar to errgroup, but can control the maximum number of concurrent
+type Batch struct {
+	result map[string]Result
+	queue  chan struct{}
+	wg     sync.WaitGroup
+	mux    sync.Mutex
+	err    *Error
+	once   sync.Once
+	cancel func()
+}
+
+func (b *Batch) Go(key string, fn func() (interface{}, error)) {
+	b.wg.Add(1)
+	go func() {
+		defer b.wg.Done()
+		if b.queue != nil {
+			<-b.queue
+			defer func() {
+				b.queue <- struct{}{}
+			}()
+		}
+
+		value, err := fn()
+		if err != nil {
+			b.once.Do(func() {
+				b.err = &Error{key, err}
+				if b.cancel != nil {
+					b.cancel()
+				}
+			})
+		}
+
+		ret := Result{value, err}
+		b.mux.Lock()
+		defer b.mux.Unlock()
+		b.result[key] = ret
+	}()
+}
+
+func (b *Batch) Wait() *Error {
+	b.wg.Wait()
+	if b.cancel != nil {
+		b.cancel()
+	}
+	return b.err
+}
+
+func (b *Batch) WaitAndGetResult() (map[string]Result, *Error) {
+	err := b.Wait()
+	return b.Result(), err
+}
+
+func (b *Batch) Result() map[string]Result {
+	b.mux.Lock()
+	defer b.mux.Unlock()
+	copy := map[string]Result{}
+	for k, v := range b.result {
+		copy[k] = v
+	}
+	return copy
+}
+
+func New(ctx context.Context, opts ...Option) (*Batch, context.Context) {
+	ctx, cancel := context.WithCancel(ctx)
+
+	b := &Batch{
+		result: map[string]Result{},
+	}
+
+	for _, o := range opts {
+		o(b)
+	}
+
+	b.cancel = cancel
+	return b, ctx
+}

common/batch/batch_test.go

@@ -0,0 +1,83 @@
+package batch
+
+import (
+	"context"
+	"errors"
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBatch(t *testing.T) {
+	b, _ := New(context.Background())
+
+	now := time.Now()
+	b.Go("foo", func() (interface{}, error) {
+		time.Sleep(time.Millisecond * 100)
+		return "foo", nil
+	})
+	b.Go("bar", func() (interface{}, error) {
+		time.Sleep(time.Millisecond * 150)
+		return "bar", nil
+	})
+	result, err := b.WaitAndGetResult()
+
+	assert.Nil(t, err)
+
+	duration := time.Since(now)
+	assert.Less(t, duration, time.Millisecond*200)
+	assert.Equal(t, 2, len(result))
+
+	for k, v := range result {
+		assert.NoError(t, v.Err)
+		assert.Equal(t, k, v.Value.(string))
+	}
+}
+
+func TestBatchWithConcurrencyNum(t *testing.T) {
+	b, _ := New(
+		context.Background(),
+		WithConcurrencyNum(3),
+	)
+
+	now := time.Now()
+	for i := 0; i < 7; i++ {
+		idx := i
+		b.Go(strconv.Itoa(idx), func() (interface{}, error) {
+			time.Sleep(time.Millisecond * 100)
+			return strconv.Itoa(idx), nil
+		})
+	}
+	result, _ := b.WaitAndGetResult()
+	duration := time.Since(now)
+	assert.Greater(t, duration, time.Millisecond*260)
+	assert.Equal(t, 7, len(result))
+
+	for k, v := range result {
+		assert.NoError(t, v.Err)
+		assert.Equal(t, k, v.Value.(string))
+	}
+}
+
+func TestBatchContext(t *testing.T) {
+	b, ctx := New(context.Background())
+
+	b.Go("error", func() (interface{}, error) {
+		time.Sleep(time.Millisecond * 100)
+		return nil, errors.New("test error")
+	})
+
+	b.Go("ctx", func() (interface{}, error) {
+		<-ctx.Done()
+		return nil, ctx.Err()
+	})
+
+	result, err := b.WaitAndGetResult()
+
+	assert.NotNil(t, err)
+	assert.Equal(t, "error", err.Key)
+
+	assert.Equal(t, ctx.Err(), result["ctx"].Err)
+}

common/cache/lrucache_test.go

@@ -149,7 +149,6 @@ func TestSetWithExpire(t *testing.T) {
 	assert.Equal(t, nil, res)
 	assert.Equal(t, time.Time{}, expires)
 	assert.Equal(t, false, exist)
-
 }
 
 func TestStale(t *testing.T) {

common/murmur3/murmur32.go

@@ -67,7 +67,6 @@ func (d *digest32) bmix(p []byte) (tail []byte) {
 }
 
 func (d *digest32) Sum32() (h1 uint32) {
-
 	h1 = d.h1
 
 	var k1 uint32

common/net/bufconn.go

@@ -1,4 +1,4 @@
-package mixed
+package net
 
 import (
 	"bufio"
@@ -11,6 +11,9 @@ type BufferedConn struct {
 }
 
 func NewBufferedConn(c net.Conn) *BufferedConn {
+	if bc, ok := c.(*BufferedConn); ok {
+		return bc
+	}
 	return &BufferedConn{bufio.NewReader(c), c}
 }
 

common/net/http.go

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

common/observable/observable_test.go

@@ -38,7 +38,7 @@ func TestObservable_MultiSubscribe(t *testing.T) {
 	src := NewObservable(iter)
 	ch1, _ := src.Subscribe()
 	ch2, _ := src.Subscribe()
-	var count = atomic.NewInt32(0)
+	count := atomic.NewInt32(0)
 
 	var wg sync.WaitGroup
 	wg.Add(2)

common/pool/alloc.go

@@ -8,11 +8,7 @@ import (
 	"sync"
 )
 
-var defaultAllocator *Allocator
-
-func init() {
-	defaultAllocator = NewAllocator()
-}
+var defaultAllocator = NewAllocator()
 
 // Allocator for incoming frames, optimized to prevent overwriting after zeroing
 type Allocator struct {
@@ -57,6 +53,7 @@ func (alloc *Allocator) Put(buf []byte) error {
 	}
 
 	//lint:ignore SA6002 ignore temporarily
+	//nolint
 	alloc.buffers[bits].Put(buf)
 	return nil
 }

common/pool/buffer.go

@@ -0,0 +1,17 @@
+package pool
+
+import (
+	"bytes"
+	"sync"
+)
+
+var bufferPool = sync.Pool{New: func() interface{} { return &bytes.Buffer{} }}
+
+func GetBuffer() *bytes.Buffer {
+	return bufferPool.Get().(*bytes.Buffer)
+}
+
+func PutBuffer(buf *bytes.Buffer) {
+	buf.Reset()
+	bufferPool.Put(buf)
+}

common/pool/pool.go

@@ -5,6 +5,11 @@ const (
 	// but the maximum packet size of vmess/shadowsocks is about 16 KiB
 	// so define a buffer of 20 KiB to reduce the memory of each TCP relay
 	RelayBufferSize = 20 * 1024
+
+	// RelayBufferSize uses 20KiB, but due to the allocator it will actually
+	// request 32Kib. Most UDPs are smaller than the MTU, and the TUN's MTU
+	// set to 9000, so the UDP Buffer size set to 16Kib
+	UDPBufferSize = 16 * 1024
 )
 
 func Get(size int) []byte {

common/singledo/singledo_test.go

@@ -12,7 +12,7 @@ import (
 func TestBasic(t *testing.T) {
 	single := NewSingle(time.Millisecond * 30)
 	foo := 0
-	var shardCount = atomic.NewInt32(0)
+	shardCount := atomic.NewInt32(0)
 	call := func() (interface{}, error) {
 		foo++
 		time.Sleep(time.Millisecond * 5)

common/sockopt/reuseaddr_other.go

@@ -1,3 +1,4 @@
+//go:build !linux
 // +build !linux
 
 package sockopt

common/structure/structure.go

@@ -37,6 +37,12 @@ func (d *Decoder) Decode(src map[string]interface{}, dst interface{}) error {
 	v := reflect.ValueOf(dst).Elem()
 	for idx := 0; idx < v.NumField(); idx++ {
 		field := t.Field(idx)
+		if field.Anonymous {
+			if err := d.decodeStruct(field.Name, src, v.Field(idx)); err != nil {
+				return err
+			}
+			continue
+		}
 
 		tag := field.Tag.Get(d.option.TagName)
 		str := strings.SplitN(tag, ",", 2)

common/structure/structure_test.go

@@ -1,12 +1,15 @@
 package structure
 
 import (
-	"reflect"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
-var decoder = NewDecoder(Option{TagName: "test"})
-var weakTypeDecoder = NewDecoder(Option{TagName: "test", WeaklyTypedInput: true})
+var (
+	decoder         = NewDecoder(Option{TagName: "test"})
+	weakTypeDecoder = NewDecoder(Option{TagName: "test", WeaklyTypedInput: true})
+)
 
 type Baz struct {
 	Foo int    `test:"foo"`
@@ -37,12 +40,8 @@ func TestStructure_Basic(t *testing.T) {
 
 	s := &Baz{}
 	err := decoder.Decode(rawMap, s)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-	if !reflect.DeepEqual(s, goal) {
-		t.Fatalf("bad: %#v", s)
-	}
+	assert.Nil(t, err)
+	assert.Equal(t, goal, s)
 }
 
 func TestStructure_Slice(t *testing.T) {
@@ -58,12 +57,8 @@ func TestStructure_Slice(t *testing.T) {
 
 	s := &BazSlice{}
 	err := decoder.Decode(rawMap, s)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-	if !reflect.DeepEqual(s, goal) {
-		t.Fatalf("bad: %#v", s)
-	}
+	assert.Nil(t, err)
+	assert.Equal(t, goal, s)
 }
 
 func TestStructure_Optional(t *testing.T) {
@@ -77,12 +72,8 @@ func TestStructure_Optional(t *testing.T) {
 
 	s := &BazOptional{}
 	err := decoder.Decode(rawMap, s)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-	if !reflect.DeepEqual(s, goal) {
-		t.Fatalf("bad: %#v", s)
-	}
+	assert.Nil(t, err)
+	assert.Equal(t, goal, s)
 }
 
 func TestStructure_MissingKey(t *testing.T) {
@@ -92,18 +83,14 @@ func TestStructure_MissingKey(t *testing.T) {
 
 	s := &Baz{}
 	err := decoder.Decode(rawMap, s)
-	if err == nil {
-		t.Fatalf("should throw error: %#v", s)
-	}
+	assert.NotNilf(t, err, "should throw error: %#v", s)
 }
 
 func TestStructure_ParamError(t *testing.T) {
 	rawMap := map[string]interface{}{}
 	s := Baz{}
 	err := decoder.Decode(rawMap, s)
-	if err == nil {
-		t.Fatalf("should throw error: %#v", s)
-	}
+	assert.NotNilf(t, err, "should throw error: %#v", s)
 }
 
 func TestStructure_SliceTypeError(t *testing.T) {
@@ -114,9 +101,7 @@ func TestStructure_SliceTypeError(t *testing.T) {
 
 	s := &BazSlice{}
 	err := decoder.Decode(rawMap, s)
-	if err == nil {
-		t.Fatalf("should throw error: %#v", s)
-	}
+	assert.NotNilf(t, err, "should throw error: %#v", s)
 }
 
 func TestStructure_WeakType(t *testing.T) {
@@ -132,10 +117,23 @@ func TestStructure_WeakType(t *testing.T) {
 
 	s := &BazSlice{}
 	err := weakTypeDecoder.Decode(rawMap, s)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-	if !reflect.DeepEqual(s, goal) {
-		t.Fatalf("bad: %#v", s)
-	}
+	assert.Nil(t, err)
+	assert.Equal(t, goal, s)
+}
+
+func TestStructure_Nest(t *testing.T) {
+	rawMap := map[string]interface{}{
+		"foo": 1,
+	}
+
+	goal := BazOptional{
+		Foo: 1,
+	}
+
+	s := &struct {
+		BazOptional
+	}{}
+	err := decoder.Decode(rawMap, s)
+	assert.Nil(t, err)
+	assert.Equal(t, s.BazOptional, goal)
 }

component/dhcp/conn.go

@@ -0,0 +1,18 @@
+package dhcp
+
+import (
+	"context"
+	"net"
+	"runtime"
+
+	"github.com/Dreamacro/clash/component/dialer"
+)
+
+func ListenDHCPClient(ctx context.Context, ifaceName string) (net.PacketConn, error) {
+	listenAddr := "0.0.0.0:68"
+	if runtime.GOOS == "linux" || runtime.GOOS == "android" {
+		listenAddr = "255.255.255.255:68"
+	}
+
+	return dialer.ListenPacket(ctx, "udp4", listenAddr, dialer.WithInterface(ifaceName), dialer.WithAddrReuse(true))
+}

component/dhcp/dhcp.go

@@ -0,0 +1,88 @@
+package dhcp
+
+import (
+	"context"
+	"errors"
+	"net"
+
+	"github.com/Dreamacro/clash/component/iface"
+
+	"github.com/insomniacslk/dhcp/dhcpv4"
+)
+
+var (
+	ErrNotResponding = errors.New("DHCP not responding")
+	ErrNotFound      = errors.New("DNS option not found")
+)
+
+func ResolveDNSFromDHCP(context context.Context, ifaceName string) ([]net.IP, error) {
+	conn, err := ListenDHCPClient(context, ifaceName)
+	if err != nil {
+		return nil, err
+	}
+	defer conn.Close()
+
+	result := make(chan []net.IP, 1)
+
+	ifaceObj, err := iface.ResolveInterface(ifaceName)
+	if err != nil {
+		return nil, err
+	}
+
+	discovery, err := dhcpv4.NewDiscovery(ifaceObj.HardwareAddr, dhcpv4.WithBroadcast(true), dhcpv4.WithRequestedOptions(dhcpv4.OptionDomainNameServer))
+	if err != nil {
+		return nil, err
+	}
+
+	go receiveOffer(conn, discovery.TransactionID, result)
+
+	_, err = conn.WriteTo(discovery.ToBytes(), &net.UDPAddr{IP: net.IPv4bcast, Port: 67})
+	if err != nil {
+		return nil, err
+	}
+
+	select {
+	case r, ok := <-result:
+		if !ok {
+			return nil, ErrNotFound
+		}
+		return r, nil
+	case <-context.Done():
+		return nil, ErrNotResponding
+	}
+}
+
+func receiveOffer(conn net.PacketConn, id dhcpv4.TransactionID, result chan<- []net.IP) {
+	defer close(result)
+
+	buf := make([]byte, dhcpv4.MaxMessageSize)
+
+	for {
+		n, _, err := conn.ReadFrom(buf)
+		if err != nil {
+			return
+		}
+
+		pkt, err := dhcpv4.FromBytes(buf[:n])
+		if err != nil {
+			continue
+		}
+
+		if pkt.MessageType() != dhcpv4.MessageTypeOffer {
+			continue
+		}
+
+		if pkt.TransactionID != id {
+			continue
+		}
+
+		dns := pkt.DNS()
+		if len(dns) == 0 {
+			return
+		}
+
+		result <- dns
+
+		return
+	}
+}

component/dialer/bind.go

@@ -1,118 +0,0 @@
-package dialer
-
-import (
-	"errors"
-	"net"
-	"time"
-
-	"github.com/Dreamacro/clash/common/singledo"
-)
-
-// In some OS, such as Windows, it takes a little longer to get interface information
-var ifaceSingle = singledo.NewSingle(time.Second * 20)
-
-var (
-	errPlatformNotSupport = errors.New("unsupport platform")
-)
-
-func lookupTCPAddr(ip net.IP, addrs []net.Addr) (*net.TCPAddr, error) {
-	ipv4 := ip.To4() != nil
-
-	for _, elm := range addrs {
-		addr, ok := elm.(*net.IPNet)
-		if !ok {
-			continue
-		}
-
-		addrV4 := addr.IP.To4() != nil
-
-		if addrV4 && ipv4 {
-			return &net.TCPAddr{IP: addr.IP, Port: 0}, nil
-		} else if !addrV4 && !ipv4 {
-			return &net.TCPAddr{IP: addr.IP, Port: 0}, nil
-		}
-	}
-
-	return nil, ErrAddrNotFound
-}
-
-func lookupUDPAddr(ip net.IP, addrs []net.Addr) (*net.UDPAddr, error) {
-	ipv4 := ip.To4() != nil
-
-	for _, elm := range addrs {
-		addr, ok := elm.(*net.IPNet)
-		if !ok {
-			continue
-		}
-
-		addrV4 := addr.IP.To4() != nil
-
-		if addrV4 && ipv4 {
-			return &net.UDPAddr{IP: addr.IP, Port: 0}, nil
-		} else if !addrV4 && !ipv4 {
-			return &net.UDPAddr{IP: addr.IP, Port: 0}, nil
-		}
-	}
-
-	return nil, ErrAddrNotFound
-}
-
-func fallbackBindToDialer(dialer *net.Dialer, network string, ip net.IP, name string) error {
-	if !ip.IsGlobalUnicast() {
-		return nil
-	}
-
-	iface, err, _ := ifaceSingle.Do(func() (interface{}, error) {
-		return net.InterfaceByName(name)
-	})
-	if err != nil {
-		return err
-	}
-
-	addrs, err := iface.(*net.Interface).Addrs()
-	if err != nil {
-		return err
-	}
-
-	switch network {
-	case "tcp", "tcp4", "tcp6":
-		if addr, err := lookupTCPAddr(ip, addrs); err == nil {
-			dialer.LocalAddr = addr
-		} else {
-			return err
-		}
-	case "udp", "udp4", "udp6":
-		if addr, err := lookupUDPAddr(ip, addrs); err == nil {
-			dialer.LocalAddr = addr
-		} else {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func fallbackBindToListenConfig(name string) (string, error) {
-	iface, err, _ := ifaceSingle.Do(func() (interface{}, error) {
-		return net.InterfaceByName(name)
-	})
-	if err != nil {
-		return "", err
-	}
-
-	addrs, err := iface.(*net.Interface).Addrs()
-	if err != nil {
-		return "", err
-	}
-
-	for _, elm := range addrs {
-		addr, ok := elm.(*net.IPNet)
-		if !ok || addr.IP.To4() == nil {
-			continue
-		}
-
-		return net.JoinHostPort(addr.IP.String(), "0"), nil
-	}
-
-	return "", ErrAddrNotFound
-}

component/dialer/bind_darwin.go

@@ -3,51 +3,64 @@ package dialer
 import (
 	"net"
 	"syscall"
+
+	"golang.org/x/sys/unix"
+
+	"github.com/Dreamacro/clash/component/iface"
 )
 
 type controlFn = func(network, address string, c syscall.RawConn) error
 
-func bindControl(ifaceIdx int) controlFn {
-	return func(network, address string, c syscall.RawConn) error {
+func bindControl(ifaceIdx int, chain controlFn) controlFn {
+	return func(network, address string, c syscall.RawConn) (err error) {
+		defer func() {
+			if err == nil && chain != nil {
+				err = chain(network, address, c)
+			}
+		}()
+
 		ipStr, _, err := net.SplitHostPort(address)
 		if err == nil {
 			ip := net.ParseIP(ipStr)
 			if ip != nil && !ip.IsGlobalUnicast() {
-				return nil
+				return
 			}
 		}
 
-		return c.Control(func(fd uintptr) {
+		var innerErr error
+		err = c.Control(func(fd uintptr) {
 			switch network {
 			case "tcp4", "udp4":
-				syscall.SetsockoptInt(int(fd), syscall.IPPROTO_IP, syscall.IP_BOUND_IF, ifaceIdx)
+				innerErr = unix.SetsockoptInt(int(fd), unix.IPPROTO_IP, unix.IP_BOUND_IF, ifaceIdx)
 			case "tcp6", "udp6":
-				syscall.SetsockoptInt(int(fd), syscall.IPPROTO_IPV6, syscall.IPV6_BOUND_IF, ifaceIdx)
+				innerErr = unix.SetsockoptInt(int(fd), unix.IPPROTO_IPV6, unix.IPV6_BOUND_IF, ifaceIdx)
 			}
 		})
+
+		if innerErr != nil {
+			err = innerErr
+		}
+
+		return
 	}
 }
 
-func bindIfaceToDialer(dialer *net.Dialer, ifaceName string) error {
-	iface, err, _ := ifaceSingle.Do(func() (interface{}, error) {
-		return net.InterfaceByName(ifaceName)
-	})
+func bindIfaceToDialer(ifaceName string, dialer *net.Dialer, _ string, _ net.IP) error {
+	ifaceObj, err := iface.ResolveInterface(ifaceName)
 	if err != nil {
 		return err
 	}
 
-	dialer.Control = bindControl(iface.(*net.Interface).Index)
+	dialer.Control = bindControl(ifaceObj.Index, dialer.Control)
 	return nil
 }
 
-func bindIfaceToListenConfig(lc *net.ListenConfig, ifaceName string) error {
-	iface, err, _ := ifaceSingle.Do(func() (interface{}, error) {
-		return net.InterfaceByName(ifaceName)
-	})
+func bindIfaceToListenConfig(ifaceName string, lc *net.ListenConfig, _, address string) (string, error) {
+	ifaceObj, err := iface.ResolveInterface(ifaceName)
 	if err != nil {
-		return err
+		return "", err
 	}
 
-	lc.Control = bindControl(iface.(*net.Interface).Index)
-	return nil
+	lc.Control = bindControl(ifaceObj.Index, lc.Control)
+	return address, nil
 }

component/dialer/bind_linux.go

@@ -3,34 +3,49 @@ package dialer
 import (
 	"net"
 	"syscall"
+
+	"golang.org/x/sys/unix"
 )
 
 type controlFn = func(network, address string, c syscall.RawConn) error
 
-func bindControl(ifaceName string) controlFn {
-	return func(network, address string, c syscall.RawConn) error {
+func bindControl(ifaceName string, chain controlFn) controlFn {
+	return func(network, address string, c syscall.RawConn) (err error) {
+		defer func() {
+			if err == nil && chain != nil {
+				err = chain(network, address, c)
+			}
+		}()
+
 		ipStr, _, err := net.SplitHostPort(address)
 		if err == nil {
 			ip := net.ParseIP(ipStr)
 			if ip != nil && !ip.IsGlobalUnicast() {
-				return nil
+				return
 			}
 		}
 
-		return c.Control(func(fd uintptr) {
-			syscall.BindToDevice(int(fd), ifaceName)
+		var innerErr error
+		err = c.Control(func(fd uintptr) {
+			innerErr = unix.BindToDevice(int(fd), ifaceName)
 		})
+
+		if innerErr != nil {
+			err = innerErr
+		}
+
+		return
 	}
 }
 
-func bindIfaceToDialer(dialer *net.Dialer, ifaceName string) error {
-	dialer.Control = bindControl(ifaceName)
+func bindIfaceToDialer(ifaceName string, dialer *net.Dialer, _ string, _ net.IP) error {
+	dialer.Control = bindControl(ifaceName, dialer.Control)
 
 	return nil
 }
 
-func bindIfaceToListenConfig(lc *net.ListenConfig, ifaceName string) error {
-	lc.Control = bindControl(ifaceName)
+func bindIfaceToListenConfig(ifaceName string, lc *net.ListenConfig, _, address string) (string, error) {
+	lc.Control = bindControl(ifaceName, lc.Control)
 
-	return nil
+	return address, nil
 }

component/dialer/bind_others.go

@@ -1,13 +1,93 @@
+//go:build !linux && !darwin
 // +build !linux,!darwin
 
 package dialer
 
-import "net"
+import (
+	"net"
+	"strconv"
+	"strings"
 
-func bindIfaceToDialer(dialer *net.Dialer, ifaceName string) error {
-	return errPlatformNotSupport
+	"github.com/Dreamacro/clash/component/iface"
+)
+
+func lookupLocalAddr(ifaceName string, network string, destination net.IP, port int) (net.Addr, error) {
+	ifaceObj, err := iface.ResolveInterface(ifaceName)
+	if err != nil {
+		return nil, err
+	}
+
+	var addr *net.IPNet
+	switch network {
+	case "udp4", "tcp4":
+		addr, err = ifaceObj.PickIPv4Addr(destination)
+	case "tcp6", "udp6":
+		addr, err = ifaceObj.PickIPv6Addr(destination)
+	default:
+		if destination != nil {
+			if destination.To4() != nil {
+				addr, err = ifaceObj.PickIPv4Addr(destination)
+			} else {
+				addr, err = ifaceObj.PickIPv6Addr(destination)
+			}
+		} else {
+			addr, err = ifaceObj.PickIPv4Addr(destination)
+		}
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	if strings.HasPrefix(network, "tcp") {
+		return &net.TCPAddr{
+			IP:   addr.IP,
+			Port: port,
+		}, nil
+	} else if strings.HasPrefix(network, "udp") {
+		return &net.UDPAddr{
+			IP:   addr.IP,
+			Port: port,
+		}, nil
+	}
+
+	return nil, iface.ErrAddrNotFound
 }
 
-func bindIfaceToListenConfig(lc *net.ListenConfig, ifaceName string) error {
-	return errPlatformNotSupport
+func bindIfaceToDialer(ifaceName string, dialer *net.Dialer, network string, destination net.IP) error {
+	if !destination.IsGlobalUnicast() {
+		return nil
+	}
+
+	local := uint64(0)
+	if dialer.LocalAddr != nil {
+		_, port, err := net.SplitHostPort(dialer.LocalAddr.String())
+		if err == nil {
+			local, _ = strconv.ParseUint(port, 10, 16)
+		}
+	}
+
+	addr, err := lookupLocalAddr(ifaceName, network, destination, int(local))
+	if err != nil {
+		return err
+	}
+
+	dialer.LocalAddr = addr
+
+	return nil
+}
+
+func bindIfaceToListenConfig(ifaceName string, _ *net.ListenConfig, network, address string) (string, error) {
+	_, port, err := net.SplitHostPort(address)
+	if err != nil {
+		port = "0"
+	}
+
+	local, _ := strconv.ParseUint(port, 10, 16)
+
+	addr, err := lookupLocalAddr(ifaceName, network, nil, int(local))
+	if err != nil {
+		return "", err
+	}
+
+	return addr.String(), nil
 }

component/dialer/dialer.go

@@ -8,22 +8,19 @@ import (
 	"github.com/Dreamacro/clash/component/resolver"
 )
 
-func Dialer() (*net.Dialer, error) {
-	dialer := &net.Dialer{}
-	if DialerHook != nil {
-		if err := DialerHook(dialer); err != nil {
-			return nil, err
-		}
+func DialContext(ctx context.Context, network, address string, options ...Option) (net.Conn, error) {
+	opt := &option{
+		interfaceName: DefaultInterface.Load(),
 	}
 
-	return dialer, nil
-}
+	for _, o := range DefaultOptions {
+		o(opt)
+	}
 
-func Dial(network, address string) (net.Conn, error) {
-	return DialContext(context.Background(), network, address)
-}
+	for _, o := range options {
+		o(opt)
+	}
 
-func DialContext(ctx context.Context, network, address string) (net.Conn, error) {
 	switch network {
 	case "tcp4", "tcp6", "udp4", "udp6":
 		host, port, err := net.SplitHostPort(address)
@@ -31,50 +28,79 @@ func DialContext(ctx context.Context, network, address string) (net.Conn, error)
 			return nil, err
 		}
 
-		dialer, err := Dialer()
-		if err != nil {
-			return nil, err
-		}
-
 		var ip net.IP
 		switch network {
 		case "tcp4", "udp4":
-			ip, err = resolver.ResolveIPv4(host)
+			if opt.interfaceName != "" {
+				ip, err = resolver.ResolveIPv4WithMain(host)
+			} else {
+				ip, err = resolver.ResolveIPv4(host)
+			}
 		default:
-			ip, err = resolver.ResolveIPv6(host)
+			if opt.interfaceName != "" {
+				ip, err = resolver.ResolveIPv6WithMain(host)
+			} else {
+				ip, err = resolver.ResolveIPv6(host)
+			}
 		}
-
 		if err != nil {
 			return nil, err
 		}
 
-		if DialHook != nil {
-			if err := DialHook(dialer, network, ip); err != nil {
-				return nil, err
-			}
-		}
-		return dialer.DialContext(ctx, network, net.JoinHostPort(ip.String(), port))
+		return dialContext(ctx, network, ip, port, opt)
 	case "tcp", "udp":
-		return dualStackDialContext(ctx, network, address)
+		return dualStackDialContext(ctx, network, address, opt)
 	default:
 		return nil, errors.New("network invalid")
 	}
 }
 
-func ListenPacket(network, address string) (net.PacketConn, error) {
-	cfg := &net.ListenConfig{}
-	if ListenPacketHook != nil {
-		var err error
-		address, err = ListenPacketHook(cfg, address)
+func ListenPacket(ctx context.Context, network, address string, options ...Option) (net.PacketConn, error) {
+	cfg := &option{
+		interfaceName: DefaultInterface.Load(),
+	}
+
+	for _, o := range DefaultOptions {
+		o(cfg)
+	}
+
+	for _, o := range options {
+		o(cfg)
+	}
+
+	lc := &net.ListenConfig{}
+	if cfg.interfaceName != "" {
+		addr, err := bindIfaceToListenConfig(cfg.interfaceName, lc, network, address)
 		if err != nil {
 			return nil, err
 		}
+		address = addr
+	}
+	if cfg.addrReuse {
+		addrReuseToListenConfig(lc)
+	}
+	if cfg.routingMark != 0 {
+		bindMarkToListenConfig(cfg.routingMark, lc, network, address)
 	}
 
-	return cfg.ListenPacket(context.Background(), network, address)
+	return lc.ListenPacket(ctx, network, address)
 }
 
-func dualStackDialContext(ctx context.Context, network, address string) (net.Conn, error) {
+func dialContext(ctx context.Context, network string, destination net.IP, port string, opt *option) (net.Conn, error) {
+	dialer := &net.Dialer{}
+	if opt.interfaceName != "" {
+		if err := bindIfaceToDialer(opt.interfaceName, dialer, network, destination); err != nil {
+			return nil, err
+		}
+	}
+	if opt.routingMark != 0 {
+		bindMarkToDialer(opt.routingMark, dialer, network, destination)
+	}
+
+	return dialer.DialContext(ctx, network, net.JoinHostPort(destination.String(), port))
+}
+
+func dualStackDialContext(ctx context.Context, network, address string, opt *option) (net.Conn, error) {
 	host, port, err := net.SplitHostPort(address)
 	if err != nil {
 		return nil, err
@@ -105,29 +131,26 @@ func dualStackDialContext(ctx context.Context, network, address string) (net.Con
 			}
 		}()
 
-		dialer, err := Dialer()
-		if err != nil {
-			result.error = err
-			return
-		}
-
 		var ip net.IP
 		if ipv6 {
-			ip, result.error = resolver.ResolveIPv6(host)
+			if opt.interfaceName != "" {
+				ip, result.error = resolver.ResolveIPv6WithMain(host)
+			} else {
+				ip, result.error = resolver.ResolveIPv6(host)
+			}
 		} else {
-			ip, result.error = resolver.ResolveIPv4(host)
+			if opt.interfaceName != "" {
+				ip, result.error = resolver.ResolveIPv4WithMain(host)
+			} else {
+				ip, result.error = resolver.ResolveIPv4(host)
+			}
 		}
 		if result.error != nil {
 			return
 		}
 		result.resolved = true
 
-		if DialHook != nil {
-			if result.error = DialHook(dialer, network, ip); result.error != nil {
-				return
-			}
-		}
-		result.Conn, result.error = dialer.DialContext(ctx, network, net.JoinHostPort(ip.String(), port))
+		result.Conn, result.error = dialContext(ctx, network, ip, port, opt)
 	}
 
 	go startRacer(ctx, network+"4", host, false)

component/dialer/hook.go

@@ -1,43 +0,0 @@
-package dialer
-
-import (
-	"errors"
-	"net"
-)
-
-type DialerHookFunc = func(dialer *net.Dialer) error
-type DialHookFunc = func(dialer *net.Dialer, network string, ip net.IP) error
-type ListenPacketHookFunc = func(lc *net.ListenConfig, address string) (string, error)
-
-var (
-	DialerHook       DialerHookFunc
-	DialHook         DialHookFunc
-	ListenPacketHook ListenPacketHookFunc
-)
-
-var (
-	ErrAddrNotFound      = errors.New("addr not found")
-	ErrNetworkNotSupport = errors.New("network not support")
-)
-
-func ListenPacketWithInterface(name string) ListenPacketHookFunc {
-	return func(lc *net.ListenConfig, address string) (string, error) {
-		err := bindIfaceToListenConfig(lc, name)
-		if err == errPlatformNotSupport {
-			address, err = fallbackBindToListenConfig(name)
-		}
-
-		return address, err
-	}
-}
-
-func DialerWithInterface(name string) DialHookFunc {
-	return func(dialer *net.Dialer, network string, ip net.IP) error {
-		err := bindIfaceToDialer(dialer, name)
-		if err == errPlatformNotSupport {
-			err = fallbackBindToDialer(dialer, network, ip, name)
-		}
-
-		return err
-	}
-}

component/dialer/mark_linux.go

@@ -0,0 +1,44 @@
+//go:build linux
+// +build linux
+
+package dialer
+
+import (
+	"net"
+	"syscall"
+)
+
+func bindMarkToDialer(mark int, dialer *net.Dialer, _ string, _ net.IP) {
+	dialer.Control = bindMarkToControl(mark, dialer.Control)
+}
+
+func bindMarkToListenConfig(mark int, lc *net.ListenConfig, _, address string) {
+	lc.Control = bindMarkToControl(mark, lc.Control)
+}
+
+func bindMarkToControl(mark int, chain controlFn) controlFn {
+	return func(network, address string, c syscall.RawConn) (err error) {
+		defer func() {
+			if err == nil && chain != nil {
+				err = chain(network, address, c)
+			}
+		}()
+
+		ipStr, _, err := net.SplitHostPort(address)
+		if err == nil {
+			ip := net.ParseIP(ipStr)
+			if ip != nil && !ip.IsGlobalUnicast() {
+				return
+			}
+		}
+
+		return c.Control(func(fd uintptr) {
+			switch network {
+			case "tcp4", "udp4":
+				syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_MARK, mark)
+			case "tcp6", "udp6":
+				syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_MARK, mark)
+			}
+		})
+	}
+}

component/dialer/mark_nonlinux.go

@@ -0,0 +1,27 @@
+//go:build !linux
+// +build !linux
+
+package dialer
+
+import (
+	"net"
+	"sync"
+
+	"github.com/Dreamacro/clash/log"
+)
+
+var printMarkWarnOnce sync.Once
+
+func printMarkWarn() {
+	printMarkWarnOnce.Do(func() {
+		log.Warnln("Routing mark on socket is not supported on current platform")
+	})
+}
+
+func bindMarkToDialer(mark int, dialer *net.Dialer, _ string, _ net.IP) {
+	printMarkWarn()
+}
+
+func bindMarkToListenConfig(mark int, lc *net.ListenConfig, _, address string) {
+	printMarkWarn()
+}

component/dialer/options.go

@@ -0,0 +1,34 @@
+package dialer
+
+import "go.uber.org/atomic"
+
+var (
+	DefaultOptions   []Option
+	DefaultInterface = atomic.NewString("")
+)
+
+type option struct {
+	interfaceName string
+	addrReuse     bool
+	routingMark   int
+}
+
+type Option func(opt *option)
+
+func WithInterface(name string) Option {
+	return func(opt *option) {
+		opt.interfaceName = name
+	}
+}
+
+func WithAddrReuse(reuse bool) Option {
+	return func(opt *option) {
+		opt.addrReuse = reuse
+	}
+}
+
+func WithRoutingMark(mark int) Option {
+	return func(opt *option) {
+		opt.routingMark = mark
+	}
+}

component/dialer/reuse_others.go

@@ -0,0 +1,10 @@
+//go:build !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !windows
+// +build !darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd,!solaris,!windows
+
+package dialer
+
+import (
+	"net"
+)
+
+func addrReuseToListenConfig(*net.ListenConfig) {}

component/dialer/reuse_unix.go

@@ -0,0 +1,28 @@
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
+// +build darwin dragonfly freebsd linux netbsd openbsd solaris
+
+package dialer
+
+import (
+	"net"
+	"syscall"
+
+	"golang.org/x/sys/unix"
+)
+
+func addrReuseToListenConfig(lc *net.ListenConfig) {
+	chain := lc.Control
+
+	lc.Control = func(network, address string, c syscall.RawConn) (err error) {
+		defer func() {
+			if err == nil && chain != nil {
+				err = chain(network, address, c)
+			}
+		}()
+
+		return c.Control(func(fd uintptr) {
+			unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEADDR, 1)
+			unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEPORT, 1)
+		})
+	}
+}

component/dialer/reuse_windows.go

@@ -0,0 +1,24 @@
+package dialer
+
+import (
+	"net"
+	"syscall"
+
+	"golang.org/x/sys/windows"
+)
+
+func addrReuseToListenConfig(lc *net.ListenConfig) {
+	chain := lc.Control
+
+	lc.Control = func(network, address string, c syscall.RawConn) (err error) {
+		defer func() {
+			if err == nil && chain != nil {
+				err = chain(network, address, c)
+			}
+		}()
+
+		return c.Control(func(fd uintptr) {
+			windows.SetsockoptInt(windows.Handle(fd), windows.SOL_SOCKET, windows.SO_REUSEADDR, 1)
+		})
+	}
+}

component/fakeip/cachefile.go

@@ -0,0 +1,55 @@
+package fakeip
+
+import (
+	"net"
+
+	"github.com/Dreamacro/clash/component/profile/cachefile"
+)
+
+type cachefileStore struct {
+	cache *cachefile.CacheFile
+}
+
+// GetByHost implements store.GetByHost
+func (c *cachefileStore) GetByHost(host string) (net.IP, bool) {
+	elm := c.cache.GetFakeip([]byte(host))
+	if elm == nil {
+		return nil, false
+	}
+	return net.IP(elm), true
+}
+
+// PutByHost implements store.PutByHost
+func (c *cachefileStore) PutByHost(host string, ip net.IP) {
+	c.cache.PutFakeip([]byte(host), ip)
+}
+
+// GetByIP implements store.GetByIP
+func (c *cachefileStore) GetByIP(ip net.IP) (string, bool) {
+	elm := c.cache.GetFakeip(ip.To4())
+	if elm == nil {
+		return "", false
+	}
+	return string(elm), true
+}
+
+// PutByIP implements store.PutByIP
+func (c *cachefileStore) PutByIP(ip net.IP, host string) {
+	c.cache.PutFakeip(ip.To4(), []byte(host))
+}
+
+// DelByIP implements store.DelByIP
+func (c *cachefileStore) DelByIP(ip net.IP) {
+	ip = ip.To4()
+	c.cache.DelFakeipPair(ip, c.cache.GetFakeip(ip.To4()))
+}
+
+// Exist implements store.Exist
+func (c *cachefileStore) Exist(ip net.IP) bool {
+	_, exist := c.GetByIP(ip)
+	return exist
+}
+
+// CloneTo implements store.CloneTo
+// already persistence
+func (c *cachefileStore) CloneTo(store store) {}

component/fakeip/memory.go

@@ -0,0 +1,69 @@
+package fakeip
+
+import (
+	"net"
+
+	"github.com/Dreamacro/clash/common/cache"
+)
+
+type memoryStore struct {
+	cache *cache.LruCache
+}
+
+// GetByHost implements store.GetByHost
+func (m *memoryStore) GetByHost(host string) (net.IP, bool) {
+	if elm, exist := m.cache.Get(host); exist {
+		ip := elm.(net.IP)
+
+		// ensure ip --> host on head of linked list
+		m.cache.Get(ipToUint(ip.To4()))
+		return ip, true
+	}
+
+	return nil, false
+}
+
+// PutByHost implements store.PutByHost
+func (m *memoryStore) PutByHost(host string, ip net.IP) {
+	m.cache.Set(host, ip)
+}
+
+// GetByIP implements store.GetByIP
+func (m *memoryStore) GetByIP(ip net.IP) (string, bool) {
+	if elm, exist := m.cache.Get(ipToUint(ip.To4())); exist {
+		host := elm.(string)
+
+		// ensure host --> ip on head of linked list
+		m.cache.Get(host)
+		return host, true
+	}
+
+	return "", false
+}
+
+// PutByIP implements store.PutByIP
+func (m *memoryStore) PutByIP(ip net.IP, host string) {
+	m.cache.Set(ipToUint(ip.To4()), host)
+}
+
+// DelByIP implements store.DelByIP
+func (m *memoryStore) DelByIP(ip net.IP) {
+	ipNum := ipToUint(ip.To4())
+	if elm, exist := m.cache.Get(ipNum); exist {
+		m.cache.Delete(elm.(string))
+	}
+	m.cache.Delete(ipNum)
+}
+
+// Exist implements store.Exist
+func (m *memoryStore) Exist(ip net.IP) bool {
+	return m.cache.Exist(ipToUint(ip.To4()))
+}
+
+// CloneTo implements store.CloneTo
+// only for memoryStore to memoryStore
+func (m *memoryStore) CloneTo(store store) {
+	if ms, ok := store.(*memoryStore); ok {
+		m.cache.CloneTo(ms.cache)
+	}
+}

component/fakeip/pool.go

@@ -6,9 +6,20 @@ import (
 	"sync"
 
 	"github.com/Dreamacro/clash/common/cache"
+	"github.com/Dreamacro/clash/component/profile/cachefile"
 	"github.com/Dreamacro/clash/component/trie"
 )
 
+type store interface {
+	GetByHost(host string) (net.IP, bool)
+	PutByHost(host string, ip net.IP)
+	GetByIP(ip net.IP) (string, bool)
+	PutByIP(ip net.IP, host string)
+	DelByIP(ip net.IP)
+	Exist(ip net.IP) bool
+	CloneTo(store)
+}
+
 // Pool is a implementation about fake ip generator without storage
 type Pool struct {
 	max     uint32
@@ -18,25 +29,19 @@ type Pool struct {
 	mux     sync.Mutex
 	host    *trie.DomainTrie
 	ipnet   *net.IPNet
-	cache   *cache.LruCache
+	store   store
 }
 
 // Lookup return a fake ip with host
 func (p *Pool) Lookup(host string) net.IP {
 	p.mux.Lock()
 	defer p.mux.Unlock()
-	if elm, exist := p.cache.Get(host); exist {
-		ip := elm.(net.IP)
-
-		// ensure ip --> host on head of linked list
-		n := ipToUint(ip.To4())
-		offset := n - p.min + 1
-		p.cache.Get(offset)
+	if ip, exist := p.store.GetByHost(host); exist {
 		return ip
 	}
 
 	ip := p.get(host)
-	p.cache.Set(host, ip)
+	p.store.PutByHost(host, ip)
 	return ip
 }
 
@@ -49,22 +54,11 @@ func (p *Pool) LookBack(ip net.IP) (string, bool) {
 		return "", false
 	}
 
-	n := ipToUint(ip.To4())
-	offset := n - p.min + 1
-
-	if elm, exist := p.cache.Get(offset); exist {
-		host := elm.(string)
-
-		// ensure host --> ip on head of linked list
-		p.cache.Get(host)
-		return host, true
-	}
-
-	return "", false
+	return p.store.GetByIP(ip)
 }
 
-// LookupHost return if domain in host
-func (p *Pool) LookupHost(domain string) bool {
+// ShouldSkipped return if domain should be skipped
+func (p *Pool) ShouldSkipped(domain string) bool {
 	if p.host == nil {
 		return false
 	}
@@ -80,9 +74,7 @@ func (p *Pool) Exist(ip net.IP) bool {
 		return false
 	}
 
-	n := ipToUint(ip.To4())
-	offset := n - p.min + 1
-	return p.cache.Exist(offset)
+	return p.store.Exist(ip)
 }
 
 // Gateway return gateway ip
@@ -95,9 +87,9 @@ func (p *Pool) IPNet() *net.IPNet {
 	return p.ipnet
 }
 
-// PatchFrom clone cache from old pool
-func (p *Pool) PatchFrom(o *Pool) {
-	o.cache.CloneTo(p.cache)
+// CloneFrom clone cache from old pool
+func (p *Pool) CloneFrom(o *Pool) {
+	o.store.CloneTo(p.store)
 }
 
 func (p *Pool) get(host string) net.IP {
@@ -106,15 +98,19 @@ func (p *Pool) get(host string) net.IP {
 		p.offset = (p.offset + 1) % (p.max - p.min)
 		// Avoid infinite loops
 		if p.offset == current {
+			p.offset = (p.offset + 1) % (p.max - p.min)
+			ip := uintToIP(p.min + p.offset - 1)
+			p.store.DelByIP(ip)
 			break
 		}
 
-		if !p.cache.Exist(p.offset) {
+		ip := uintToIP(p.min + p.offset - 1)
+		if !p.store.Exist(ip) {
 			break
 		}
 	}
 	ip := uintToIP(p.min + p.offset - 1)
-	p.cache.Set(p.offset, host)
+	p.store.PutByIP(ip, host)
 	return ip
 }
 
@@ -130,11 +126,24 @@ func uintToIP(v uint32) net.IP {
 	return net.IP{byte(v >> 24), byte(v >> 16), byte(v >> 8), byte(v)}
 }
 
-// New return Pool instance
-func New(ipnet *net.IPNet, size int, host *trie.DomainTrie) (*Pool, error) {
-	min := ipToUint(ipnet.IP) + 2
+type Options struct {
+	IPNet *net.IPNet
+	Host  *trie.DomainTrie
 
-	ones, bits := ipnet.Mask.Size()
+	// Size sets the maximum number of entries in memory
+	// and does not work if Persistence is true
+	Size int
+
+	// Persistence will save the data to disk.
+	// Size will not work and record will be fully stored.
+	Persistence bool
+}
+
+// New return Pool instance
+func New(options Options) (*Pool, error) {
+	min := ipToUint(options.IPNet.IP) + 2
+
+	ones, bits := options.IPNet.Mask.Size()
 	total := 1<<uint(bits-ones) - 2
 
 	if total <= 0 {
@@ -142,12 +151,22 @@ func New(ipnet *net.IPNet, size int, host *trie.DomainTrie) (*Pool, error) {
 	}
 
 	max := min + uint32(total) - 1
-	return &Pool{
+	pool := &Pool{
 		min:     min,
 		max:     max,
 		gateway: min - 1,
-		host:    host,
-		ipnet:   ipnet,
-		cache:   cache.NewLRUCache(cache.WithSize(size * 2)),
-	}, nil
+		host:    options.Host,
+		ipnet:   options.IPNet,
+	}
+	if options.Persistence {
+		pool.store = &cachefileStore{
+			cache: cachefile.Cache(),
+		}
+	} else {
+		pool.store = &memoryStore{
+			cache: cache.NewLRUCache(cache.WithSize(options.Size * 2)),
+		}
+	}
+
+	return pool, nil
 }

component/fakeip/pool_test.go

@@ -1,39 +1,126 @@
 package fakeip
 
 import (
+	"fmt"
 	"net"
+	"os"
 	"testing"
+	"time"
+
+	"github.com/Dreamacro/clash/component/profile/cachefile"
+	"github.com/Dreamacro/clash/component/trie"
 
 	"github.com/stretchr/testify/assert"
+	"go.etcd.io/bbolt"
 )
 
+func createPools(options Options) ([]*Pool, string, error) {
+	pool, err := New(options)
+	if err != nil {
+		return nil, "", err
+	}
+	filePool, tempfile, err := createCachefileStore(options)
+	if err != nil {
+		return nil, "", err
+	}
+
+	return []*Pool{pool, filePool}, tempfile, nil
+}
+
+func createCachefileStore(options Options) (*Pool, string, error) {
+	pool, err := New(options)
+	if err != nil {
+		return nil, "", err
+	}
+	f, err := os.CreateTemp("", "clash")
+	if err != nil {
+		return nil, "", err
+	}
+
+	db, err := bbolt.Open(f.Name(), 0o666, &bbolt.Options{Timeout: time.Second})
+	if err != nil {
+		return nil, "", err
+	}
+
+	pool.store = &cachefileStore{
+		cache: &cachefile.CacheFile{DB: db},
+	}
+	return pool, f.Name(), nil
+}
+
 func TestPool_Basic(t *testing.T) {
 	_, ipnet, _ := net.ParseCIDR("192.168.0.1/29")
-	pool, _ := New(ipnet, 10, nil)
+	pools, tempfile, err := createPools(Options{
+		IPNet: ipnet,
+		Size:  10,
+	})
+	assert.Nil(t, err)
+	defer os.Remove(tempfile)
 
-	first := pool.Lookup("foo.com")
-	last := pool.Lookup("bar.com")
-	bar, exist := pool.LookBack(last)
+	for _, pool := range pools {
+		first := pool.Lookup("foo.com")
+		last := pool.Lookup("bar.com")
+		bar, exist := pool.LookBack(last)
 
-	assert.True(t, first.Equal(net.IP{192, 168, 0, 2}))
-	assert.True(t, last.Equal(net.IP{192, 168, 0, 3}))
-	assert.True(t, exist)
-	assert.Equal(t, bar, "bar.com")
+		assert.True(t, first.Equal(net.IP{192, 168, 0, 2}))
+		assert.Equal(t, pool.Lookup("foo.com"), net.IP{192, 168, 0, 2})
+		assert.True(t, last.Equal(net.IP{192, 168, 0, 3}))
+		assert.True(t, exist)
+		assert.Equal(t, bar, "bar.com")
+		assert.Equal(t, pool.Gateway(), net.IP{192, 168, 0, 1})
+		assert.Equal(t, pool.IPNet().String(), ipnet.String())
+		assert.True(t, pool.Exist(net.IP{192, 168, 0, 3}))
+		assert.False(t, pool.Exist(net.IP{192, 168, 0, 4}))
+		assert.False(t, pool.Exist(net.ParseIP("::1")))
+	}
 }
 
-func TestPool_Cycle(t *testing.T) {
+func TestPool_CycleUsed(t *testing.T) {
+	_, ipnet, _ := net.ParseCIDR("192.168.0.1/29")
+	pools, tempfile, err := createPools(Options{
+		IPNet: ipnet,
+		Size:  10,
+	})
+	assert.Nil(t, err)
+	defer os.Remove(tempfile)
+
+	for _, pool := range pools {
+		foo := pool.Lookup("foo.com")
+		bar := pool.Lookup("bar.com")
+		for i := 0; i < 3; i++ {
+			pool.Lookup(fmt.Sprintf("%d.com", i))
+		}
+		baz := pool.Lookup("baz.com")
+		next := pool.Lookup("foo.com")
+		assert.True(t, foo.Equal(baz))
+		assert.True(t, next.Equal(bar))
+	}
+}
+
+func TestPool_Skip(t *testing.T) {
 	_, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
-	pool, _ := New(ipnet, 10, nil)
+	tree := trie.New()
+	tree.Insert("example.com", tree)
+	pools, tempfile, err := createPools(Options{
+		IPNet: ipnet,
+		Size:  10,
+		Host:  tree,
+	})
+	assert.Nil(t, err)
+	defer os.Remove(tempfile)
 
-	first := pool.Lookup("foo.com")
-	same := pool.Lookup("baz.com")
-
-	assert.True(t, first.Equal(same))
+	for _, pool := range pools {
+		assert.True(t, pool.ShouldSkipped("example.com"))
+		assert.False(t, pool.ShouldSkipped("foo.com"))
+	}
 }
 
 func TestPool_MaxCacheSize(t *testing.T) {
 	_, ipnet, _ := net.ParseCIDR("192.168.0.1/24")
-	pool, _ := New(ipnet, 2, nil)
+	pool, _ := New(Options{
+		IPNet: ipnet,
+		Size:  2,
+	})
 
 	first := pool.Lookup("foo.com")
 	pool.Lookup("bar.com")
@@ -45,7 +132,10 @@ func TestPool_MaxCacheSize(t *testing.T) {
 
 func TestPool_DoubleMapping(t *testing.T) {
 	_, ipnet, _ := net.ParseCIDR("192.168.0.1/24")
-	pool, _ := New(ipnet, 2, nil)
+	pool, _ := New(Options{
+		IPNet: ipnet,
+		Size:  2,
+	})
 
 	// fill cache
 	fooIP := pool.Lookup("foo.com")
@@ -70,9 +160,35 @@ func TestPool_DoubleMapping(t *testing.T) {
 	assert.False(t, bazIP.Equal(newBazIP))
 }
 
+func TestPool_Clone(t *testing.T) {
+	_, ipnet, _ := net.ParseCIDR("192.168.0.1/24")
+	pool, _ := New(Options{
+		IPNet: ipnet,
+		Size:  2,
+	})
+
+	first := pool.Lookup("foo.com")
+	last := pool.Lookup("bar.com")
+	assert.True(t, first.Equal(net.IP{192, 168, 0, 2}))
+	assert.True(t, last.Equal(net.IP{192, 168, 0, 3}))
+
+	newPool, _ := New(Options{
+		IPNet: ipnet,
+		Size:  2,
+	})
+	newPool.CloneFrom(pool)
+	_, firstExist := newPool.LookBack(first)
+	_, lastExist := newPool.LookBack(last)
+	assert.True(t, firstExist)
+	assert.True(t, lastExist)
+}
+
 func TestPool_Error(t *testing.T) {
 	_, ipnet, _ := net.ParseCIDR("192.168.0.1/31")
-	_, err := New(ipnet, 10, nil)
+	_, err := New(Options{
+		IPNet: ipnet,
+		Size:  10,
+	})
 
 	assert.Error(t, err)
 }

component/geodata/attr.go

@@ -0,0 +1,51 @@
+package geodata
+
+import (
+	"strings"
+
+	"github.com/Dreamacro/clash/component/geodata/router"
+)
+
+type AttributeList struct {
+	matcher []AttributeMatcher
+}
+
+func (al *AttributeList) Match(domain *router.Domain) bool {
+	for _, matcher := range al.matcher {
+		if !matcher.Match(domain) {
+			return false
+		}
+	}
+	return true
+}
+
+func (al *AttributeList) IsEmpty() bool {
+	return len(al.matcher) == 0
+}
+
+func parseAttrs(attrs []string) *AttributeList {
+	al := new(AttributeList)
+	for _, attr := range attrs {
+		trimmedAttr := strings.ToLower(strings.TrimSpace(attr))
+		if len(trimmedAttr) == 0 {
+			continue
+		}
+		al.matcher = append(al.matcher, BooleanMatcher(trimmedAttr))
+	}
+	return al
+}
+
+type AttributeMatcher interface {
+	Match(*router.Domain) bool
+}
+
+type BooleanMatcher string
+
+func (m BooleanMatcher) Match(domain *router.Domain) bool {
+	for _, attr := range domain.Attribute {
+		if strings.EqualFold(attr.GetKey(), string(m)) {
+			return true
+		}
+	}
+	return false
+}

component/geodata/geodata.go

@@ -0,0 +1,86 @@
+package geodata
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/Dreamacro/clash/component/geodata/router"
+	"github.com/Dreamacro/clash/log"
+)
+
+type loader struct {
+	LoaderImplementation
+}
+
+func (l *loader) LoadGeoSite(list string) ([]*router.Domain, error) {
+	return l.LoadGeoSiteWithAttr("geosite.dat", list)
+}
+
+func (l *loader) LoadGeoSiteWithAttr(file string, siteWithAttr string) ([]*router.Domain, error) {
+	parts := strings.Split(siteWithAttr, "@")
+	if len(parts) == 0 {
+		return nil, errors.New("empty rule")
+	}
+	list := strings.TrimSpace(parts[0])
+	attrVal := parts[1:]
+
+	if len(list) == 0 {
+		return nil, fmt.Errorf("empty listname in rule: %s", siteWithAttr)
+	}
+
+	domains, err := l.LoadSite(file, list)
+	if err != nil {
+		return nil, err
+	}
+
+	attrs := parseAttrs(attrVal)
+	if attrs.IsEmpty() {
+		if strings.Contains(siteWithAttr, "@") {
+			log.Warnln("empty attribute list: %s", siteWithAttr)
+		}
+		return domains, nil
+	}
+
+	filteredDomains := make([]*router.Domain, 0, len(domains))
+	hasAttrMatched := false
+	for _, domain := range domains {
+		if attrs.Match(domain) {
+			hasAttrMatched = true
+			filteredDomains = append(filteredDomains, domain)
+		}
+	}
+	if !hasAttrMatched {
+		log.Warnln("attribute match no rule: geosite: %s", siteWithAttr)
+	}
+
+	return filteredDomains, nil
+}
+
+func (l *loader) LoadGeoIP(country string) ([]*router.CIDR, error) {
+	return l.LoadIP("geoip.dat", country)
+}
+
+var loaders map[string]func() LoaderImplementation
+
+func RegisterGeoDataLoaderImplementationCreator(name string, loader func() LoaderImplementation) {
+	if loaders == nil {
+		loaders = map[string]func() LoaderImplementation{}
+	}
+	loaders[name] = loader
+}
+
+func getGeoDataLoaderImplementation(name string) (LoaderImplementation, error) {
+	if geoLoader, ok := loaders[name]; ok {
+		return geoLoader(), nil
+	}
+	return nil, fmt.Errorf("unable to locate GeoData loader %s", name)
+}
+
+func GetGeoDataLoader(name string) (Loader, error) {
+	loadImpl, err := getGeoDataLoaderImplementation(name)
+	if err == nil {
+		return &loader{loadImpl}, nil
+	}
+	return nil, err
+}

component/geodata/geodataproto.go

@@ -0,0 +1,17 @@
+package geodata
+
+import (
+	"github.com/Dreamacro/clash/component/geodata/router"
+)
+
+type LoaderImplementation interface {
+	LoadSite(filename, list string) ([]*router.Domain, error)
+	LoadIP(filename, country string) ([]*router.CIDR, error)
+}
+
+type Loader interface {
+	LoaderImplementation
+	LoadGeoSite(list string) ([]*router.Domain, error)
+	LoadGeoSiteWithAttr(file string, siteWithAttr string) ([]*router.Domain, error)
+	LoadGeoIP(country string) ([]*router.CIDR, error)
+}

component/geodata/memconservative/cache.go

@@ -0,0 +1,142 @@
+package memconservative
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/Dreamacro/clash/component/geodata/router"
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/log"
+	"google.golang.org/protobuf/proto"
+)
+
+type GeoIPCache map[string]*router.GeoIP
+
+func (g GeoIPCache) Has(key string) bool {
+	return !(g.Get(key) == nil)
+}
+
+func (g GeoIPCache) Get(key string) *router.GeoIP {
+	if g == nil {
+		return nil
+	}
+	return g[key]
+}
+
+func (g GeoIPCache) Set(key string, value *router.GeoIP) {
+	if g == nil {
+		g = make(map[string]*router.GeoIP)
+	}
+	g[key] = value
+}
+
+func (g GeoIPCache) Unmarshal(filename, code string) (*router.GeoIP, error) {
+	asset := C.Path.GetAssetLocation(filename)
+	idx := strings.ToLower(asset + ":" + code)
+	if g.Has(idx) {
+		return g.Get(idx), nil
+	}
+
+	geoipBytes, err := Decode(asset, code)
+	switch err {
+	case nil:
+		var geoip router.GeoIP
+		if err := proto.Unmarshal(geoipBytes, &geoip); err != nil {
+			return nil, err
+		}
+		g.Set(idx, &geoip)
+		return &geoip, nil
+
+	case errCodeNotFound:
+		return nil, fmt.Errorf("country code %s%s%s", code, " not found in ", filename)
+
+	case errFailedToReadBytes, errFailedToReadExpectedLenBytes,
+		errInvalidGeodataFile, errInvalidGeodataVarintLength:
+		log.Warnln("failed to decode geoip file: %s%s", filename, ", fallback to the original ReadFile method")
+		geoipBytes, err = os.ReadFile(asset)
+		if err != nil {
+			return nil, err
+		}
+		var geoipList router.GeoIPList
+		if err := proto.Unmarshal(geoipBytes, &geoipList); err != nil {
+			return nil, err
+		}
+		for _, geoip := range geoipList.GetEntry() {
+			if strings.EqualFold(code, geoip.GetCountryCode()) {
+				g.Set(idx, geoip)
+				return geoip, nil
+			}
+		}
+
+	default:
+		return nil, err
+	}
+
+	return nil, fmt.Errorf("country code %s%s%s", code, " not found in ", filename)
+}
+
+type GeoSiteCache map[string]*router.GeoSite
+
+func (g GeoSiteCache) Has(key string) bool {
+	return !(g.Get(key) == nil)
+}
+
+func (g GeoSiteCache) Get(key string) *router.GeoSite {
+	if g == nil {
+		return nil
+	}
+	return g[key]
+}
+
+func (g GeoSiteCache) Set(key string, value *router.GeoSite) {
+	if g == nil {
+		g = make(map[string]*router.GeoSite)
+	}
+	g[key] = value
+}
+
+func (g GeoSiteCache) Unmarshal(filename, code string) (*router.GeoSite, error) {
+	asset := C.Path.GetAssetLocation(filename)
+	idx := strings.ToLower(asset + ":" + code)
+	if g.Has(idx) {
+		return g.Get(idx), nil
+	}
+
+	geositeBytes, err := Decode(asset, code)
+	switch err {
+	case nil:
+		var geosite router.GeoSite
+		if err := proto.Unmarshal(geositeBytes, &geosite); err != nil {
+			return nil, err
+		}
+		g.Set(idx, &geosite)
+		return &geosite, nil
+
+	case errCodeNotFound:
+		return nil, fmt.Errorf("list %s%s%s", code, " not found in ", filename)
+
+	case errFailedToReadBytes, errFailedToReadExpectedLenBytes,
+		errInvalidGeodataFile, errInvalidGeodataVarintLength:
+		log.Warnln("failed to decode geoip file: %s%s", filename, ", fallback to the original ReadFile method")
+		geositeBytes, err = os.ReadFile(asset)
+		if err != nil {
+			return nil, err
+		}
+		var geositeList router.GeoSiteList
+		if err := proto.Unmarshal(geositeBytes, &geositeList); err != nil {
+			return nil, err
+		}
+		for _, geosite := range geositeList.GetEntry() {
+			if strings.EqualFold(code, geosite.GetCountryCode()) {
+				g.Set(idx, geosite)
+				return geosite, nil
+			}
+		}
+
+	default:
+		return nil, err
+	}
+
+	return nil, fmt.Errorf("list %s%s%s", code, " not found in ", filename)
+}

component/geodata/memconservative/decode.go

@@ -0,0 +1,107 @@
+package memconservative
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"google.golang.org/protobuf/encoding/protowire"
+)
+
+var (
+	errFailedToReadBytes            = errors.New("failed to read bytes")
+	errFailedToReadExpectedLenBytes = errors.New("failed to read expected length of bytes")
+	errInvalidGeodataFile           = errors.New("invalid geodata file")
+	errInvalidGeodataVarintLength   = errors.New("invalid geodata varint length")
+	errCodeNotFound                 = errors.New("code not found")
+)
+
+func emitBytes(f io.ReadSeeker, code string) ([]byte, error) {
+	count := 1
+	isInner := false
+	tempContainer := make([]byte, 0, 5)
+
+	var result []byte
+	var advancedN uint64 = 1
+	var geoDataVarintLength, codeVarintLength, varintLenByteLen uint64 = 0, 0, 0
+
+Loop:
+	for {
+		container := make([]byte, advancedN)
+		bytesRead, err := f.Read(container)
+		if err == io.EOF {
+			return nil, errCodeNotFound
+		}
+		if err != nil {
+			return nil, errFailedToReadBytes
+		}
+		if bytesRead != len(container) {
+			return nil, errFailedToReadExpectedLenBytes
+		}
+
+		switch count {
+		case 1, 3: // data type ((field_number << 3) | wire_type)
+			if container[0] != 10 { // byte `0A` equals to `10` in decimal
+				return nil, errInvalidGeodataFile
+			}
+			advancedN = 1
+			count++
+		case 2, 4: // data length
+			tempContainer = append(tempContainer, container...)
+			if container[0] > 127 { // max one-byte-length byte `7F`(0FFF FFFF) equals to `127` in decimal
+				advancedN = 1
+				goto Loop
+			}
+			lenVarint, n := protowire.ConsumeVarint(tempContainer)
+			if n < 0 {
+				return nil, errInvalidGeodataVarintLength
+			}
+			tempContainer = nil
+			if !isInner {
+				isInner = true
+				geoDataVarintLength = lenVarint
+				advancedN = 1
+			} else {
+				isInner = false
+				codeVarintLength = lenVarint
+				varintLenByteLen = uint64(n)
+				advancedN = codeVarintLength
+			}
+			count++
+		case 5: // data value
+			if strings.EqualFold(string(container), code) {
+				count++
+				offset := -(1 + int64(varintLenByteLen) + int64(codeVarintLength))
+				_, _ = f.Seek(offset, 1)        // back to the start of GeoIP or GeoSite varint
+				advancedN = geoDataVarintLength // the number of bytes to be read in next round
+			} else {
+				count = 1
+				offset := int64(geoDataVarintLength) - int64(codeVarintLength) - int64(varintLenByteLen) - 1
+				_, _ = f.Seek(offset, 1) // skip the unmatched GeoIP or GeoSite varint
+				advancedN = 1            // the next round will be the start of another GeoIPList or GeoSiteList
+			}
+		case 6: // matched GeoIP or GeoSite varint
+			result = container
+			break Loop
+		}
+	}
+	return result, nil
+}
+
+func Decode(filename, code string) ([]byte, error) {
+	f, err := os.Open(filename)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open file: %s, base error: %s", filename, err.Error())
+	}
+	defer func(f *os.File) {
+		_ = f.Close()
+	}(f)
+
+	geoBytes, err := emitBytes(f, code)
+	if err != nil {
+		return nil, err
+	}
+	return geoBytes, nil
+}

component/geodata/memconservative/memc.go

@@ -0,0 +1,40 @@
+package memconservative
+
+import (
+	"fmt"
+	"runtime"
+
+	"github.com/Dreamacro/clash/component/geodata"
+	"github.com/Dreamacro/clash/component/geodata/router"
+)
+
+type memConservativeLoader struct {
+	geoipcache   GeoIPCache
+	geositecache GeoSiteCache
+}
+
+func (m *memConservativeLoader) LoadIP(filename, country string) ([]*router.CIDR, error) {
+	defer runtime.GC()
+	geoip, err := m.geoipcache.Unmarshal(filename, country)
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode geodata file: %s, base error: %s", filename, err.Error())
+	}
+	return geoip.Cidr, nil
+}
+
+func (m *memConservativeLoader) LoadSite(filename, list string) ([]*router.Domain, error) {
+	defer runtime.GC()
+	geosite, err := m.geositecache.Unmarshal(filename, list)
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode geodata file: %s, base error: %s", filename, err.Error())
+	}
+	return geosite.Domain, nil
+}
+
+func newMemConservativeLoader() geodata.LoaderImplementation {
+	return &memConservativeLoader{make(map[string]*router.GeoIP), make(map[string]*router.GeoSite)}
+}
+
+func init() {
+	geodata.RegisterGeoDataLoaderImplementationCreator("memconservative", newMemConservativeLoader)
+}

component/geodata/package_info.go

@@ -0,0 +1,4 @@
+// Modified from: https://github.com/v2fly/v2ray-core/tree/master/infra/conf/geodata
+// License: MIT
+
+package geodata

component/geodata/router/condition.go

@@ -0,0 +1,71 @@
+package router
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/Dreamacro/clash/component/geodata/strmatcher"
+)
+
+var matcherTypeMap = map[Domain_Type]strmatcher.Type{
+	Domain_Plain:  strmatcher.Substr,
+	Domain_Regex:  strmatcher.Regex,
+	Domain_Domain: strmatcher.Domain,
+	Domain_Full:   strmatcher.Full,
+}
+
+func domainToMatcher(domain *Domain) (strmatcher.Matcher, error) {
+	matcherType, f := matcherTypeMap[domain.Type]
+	if !f {
+		return nil, fmt.Errorf("unsupported domain type %v", domain.Type)
+	}
+
+	matcher, err := matcherType.New(domain.Value)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create domain matcher, base error: %s", err.Error())
+	}
+
+	return matcher, nil
+}
+
+type DomainMatcher struct {
+	matchers strmatcher.IndexMatcher
+}
+
+func NewMphMatcherGroup(domains []*Domain) (*DomainMatcher, error) {
+	g := strmatcher.NewMphMatcherGroup()
+	for _, d := range domains {
+		matcherType, f := matcherTypeMap[d.Type]
+		if !f {
+			return nil, fmt.Errorf("unsupported domain type %v", d.Type)
+		}
+		_, err := g.AddPattern(d.Value, matcherType)
+		if err != nil {
+			return nil, err
+		}
+	}
+	g.Build()
+	return &DomainMatcher{
+		matchers: g,
+	}, nil
+}
+
+// NewDomainMatcher new domain matcher.
+func NewDomainMatcher(domains []*Domain) (*DomainMatcher, error) {
+	g := new(strmatcher.MatcherGroup)
+	for _, d := range domains {
+		m, err := domainToMatcher(d)
+		if err != nil {
+			return nil, err
+		}
+		g.Add(m)
+	}
+
+	return &DomainMatcher{
+		matchers: g,
+	}, nil
+}
+
+func (m *DomainMatcher) ApplyDomain(domain string) bool {
+	return len(m.matchers.Match(strings.ToLower(domain))) > 0
+}

component/geodata/router/config.pb.go

@@ -0,0 +1,725 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.27.1
+// 	protoc        v3.17.3
+// source: component/geodata/router/config.proto
+
+package router
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+// Type of domain value.
+type Domain_Type int32
+
+const (
+	// The value is used as is.
+	Domain_Plain Domain_Type = 0
+	// The value is used as a regular expression.
+	Domain_Regex Domain_Type = 1
+	// The value is a root domain.
+	Domain_Domain Domain_Type = 2
+	// The value is a domain.
+	Domain_Full Domain_Type = 3
+)
+
+// Enum value maps for Domain_Type.
+var (
+	Domain_Type_name = map[int32]string{
+		0: "Plain",
+		1: "Regex",
+		2: "Domain",
+		3: "Full",
+	}
+	Domain_Type_value = map[string]int32{
+		"Plain":  0,
+		"Regex":  1,
+		"Domain": 2,
+		"Full":   3,
+	}
+)
+
+func (x Domain_Type) Enum() *Domain_Type {
+	p := new(Domain_Type)
+	*p = x
+	return p
+}
+
+func (x Domain_Type) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Domain_Type) Descriptor() protoreflect.EnumDescriptor {
+	return file_component_geodata_router_config_proto_enumTypes[0].Descriptor()
+}
+
+func (Domain_Type) Type() protoreflect.EnumType {
+	return &file_component_geodata_router_config_proto_enumTypes[0]
+}
+
+func (x Domain_Type) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use Domain_Type.Descriptor instead.
+func (Domain_Type) EnumDescriptor() ([]byte, []int) {
+	return file_component_geodata_router_config_proto_rawDescGZIP(), []int{0, 0}
+}
+
+// Domain for routing decision.
+type Domain struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Domain matching type.
+	Type Domain_Type `protobuf:"varint,1,opt,name=type,proto3,enum=clash.component.geodata.router.Domain_Type" json:"type,omitempty"`
+	// Domain value.
+	Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
+	// Attributes of this domain. May be used for filtering.
+	Attribute []*Domain_Attribute `protobuf:"bytes,3,rep,name=attribute,proto3" json:"attribute,omitempty"`
+}
+
+func (x *Domain) Reset() {
+	*x = Domain{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_component_geodata_router_config_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Domain) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Domain) ProtoMessage() {}
+
+func (x *Domain) ProtoReflect() protoreflect.Message {
+	mi := &file_component_geodata_router_config_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Domain.ProtoReflect.Descriptor instead.
+func (*Domain) Descriptor() ([]byte, []int) {
+	return file_component_geodata_router_config_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Domain) GetType() Domain_Type {
+	if x != nil {
+		return x.Type
+	}
+	return Domain_Plain
+}
+
+func (x *Domain) GetValue() string {
+	if x != nil {
+		return x.Value
+	}
+	return ""
+}
+
+func (x *Domain) GetAttribute() []*Domain_Attribute {
+	if x != nil {
+		return x.Attribute
+	}
+	return nil
+}
+
+// IP for routing decision, in CIDR form.
+type CIDR struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// IP address, should be either 4 or 16 bytes.
+	Ip []byte `protobuf:"bytes,1,opt,name=ip,proto3" json:"ip,omitempty"`
+	// Number of leading ones in the network mask.
+	Prefix uint32 `protobuf:"varint,2,opt,name=prefix,proto3" json:"prefix,omitempty"`
+}
+
+func (x *CIDR) Reset() {
+	*x = CIDR{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_component_geodata_router_config_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *CIDR) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CIDR) ProtoMessage() {}
+
+func (x *CIDR) ProtoReflect() protoreflect.Message {
+	mi := &file_component_geodata_router_config_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use CIDR.ProtoReflect.Descriptor instead.
+func (*CIDR) Descriptor() ([]byte, []int) {
+	return file_component_geodata_router_config_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *CIDR) GetIp() []byte {
+	if x != nil {
+		return x.Ip
+	}
+	return nil
+}
+
+func (x *CIDR) GetPrefix() uint32 {
+	if x != nil {
+		return x.Prefix
+	}
+	return 0
+}
+
+type GeoIP struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	CountryCode  string  `protobuf:"bytes,1,opt,name=country_code,json=countryCode,proto3" json:"country_code,omitempty"`
+	Cidr         []*CIDR `protobuf:"bytes,2,rep,name=cidr,proto3" json:"cidr,omitempty"`
+	ReverseMatch bool    `protobuf:"varint,3,opt,name=reverse_match,json=reverseMatch,proto3" json:"reverse_match,omitempty"`
+}
+
+func (x *GeoIP) Reset() {
+	*x = GeoIP{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_component_geodata_router_config_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *GeoIP) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GeoIP) ProtoMessage() {}
+
+func (x *GeoIP) ProtoReflect() protoreflect.Message {
+	mi := &file_component_geodata_router_config_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GeoIP.ProtoReflect.Descriptor instead.
+func (*GeoIP) Descriptor() ([]byte, []int) {
+	return file_component_geodata_router_config_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *GeoIP) GetCountryCode() string {
+	if x != nil {
+		return x.CountryCode
+	}
+	return ""
+}
+
+func (x *GeoIP) GetCidr() []*CIDR {
+	if x != nil {
+		return x.Cidr
+	}
+	return nil
+}
+
+func (x *GeoIP) GetReverseMatch() bool {
+	if x != nil {
+		return x.ReverseMatch
+	}
+	return false
+}
+
+type GeoIPList struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Entry []*GeoIP `protobuf:"bytes,1,rep,name=entry,proto3" json:"entry,omitempty"`
+}
+
+func (x *GeoIPList) Reset() {
+	*x = GeoIPList{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_component_geodata_router_config_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *GeoIPList) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GeoIPList) ProtoMessage() {}
+
+func (x *GeoIPList) ProtoReflect() protoreflect.Message {
+	mi := &file_component_geodata_router_config_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GeoIPList.ProtoReflect.Descriptor instead.
+func (*GeoIPList) Descriptor() ([]byte, []int) {
+	return file_component_geodata_router_config_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *GeoIPList) GetEntry() []*GeoIP {
+	if x != nil {
+		return x.Entry
+	}
+	return nil
+}
+
+type GeoSite struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	CountryCode string    `protobuf:"bytes,1,opt,name=country_code,json=countryCode,proto3" json:"country_code,omitempty"`
+	Domain      []*Domain `protobuf:"bytes,2,rep,name=domain,proto3" json:"domain,omitempty"`
+}
+
+func (x *GeoSite) Reset() {
+	*x = GeoSite{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_component_geodata_router_config_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *GeoSite) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GeoSite) ProtoMessage() {}
+
+func (x *GeoSite) ProtoReflect() protoreflect.Message {
+	mi := &file_component_geodata_router_config_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GeoSite.ProtoReflect.Descriptor instead.
+func (*GeoSite) Descriptor() ([]byte, []int) {
+	return file_component_geodata_router_config_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *GeoSite) GetCountryCode() string {
+	if x != nil {
+		return x.CountryCode
+	}
+	return ""
+}
+
+func (x *GeoSite) GetDomain() []*Domain {
+	if x != nil {
+		return x.Domain
+	}
+	return nil
+}
+
+type GeoSiteList struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Entry []*GeoSite `protobuf:"bytes,1,rep,name=entry,proto3" json:"entry,omitempty"`
+}
+
+func (x *GeoSiteList) Reset() {
+	*x = GeoSiteList{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_component_geodata_router_config_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *GeoSiteList) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GeoSiteList) ProtoMessage() {}
+
+func (x *GeoSiteList) ProtoReflect() protoreflect.Message {
+	mi := &file_component_geodata_router_config_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GeoSiteList.ProtoReflect.Descriptor instead.
+func (*GeoSiteList) Descriptor() ([]byte, []int) {
+	return file_component_geodata_router_config_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *GeoSiteList) GetEntry() []*GeoSite {
+	if x != nil {
+		return x.Entry
+	}
+	return nil
+}
+
+type Domain_Attribute struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+	// Types that are assignable to TypedValue:
+	//	*Domain_Attribute_BoolValue
+	//	*Domain_Attribute_IntValue
+	TypedValue isDomain_Attribute_TypedValue `protobuf_oneof:"typed_value"`
+}
+
+func (x *Domain_Attribute) Reset() {
+	*x = Domain_Attribute{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_component_geodata_router_config_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Domain_Attribute) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Domain_Attribute) ProtoMessage() {}
+
+func (x *Domain_Attribute) ProtoReflect() protoreflect.Message {
+	mi := &file_component_geodata_router_config_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Domain_Attribute.ProtoReflect.Descriptor instead.
+func (*Domain_Attribute) Descriptor() ([]byte, []int) {
+	return file_component_geodata_router_config_proto_rawDescGZIP(), []int{0, 0}
+}
+
+func (x *Domain_Attribute) GetKey() string {
+	if x != nil {
+		return x.Key
+	}
+	return ""
+}
+
+func (m *Domain_Attribute) GetTypedValue() isDomain_Attribute_TypedValue {
+	if m != nil {
+		return m.TypedValue
+	}
+	return nil
+}
+
+func (x *Domain_Attribute) GetBoolValue() bool {
+	if x, ok := x.GetTypedValue().(*Domain_Attribute_BoolValue); ok {
+		return x.BoolValue
+	}
+	return false
+}
+
+func (x *Domain_Attribute) GetIntValue() int64 {
+	if x, ok := x.GetTypedValue().(*Domain_Attribute_IntValue); ok {
+		return x.IntValue
+	}
+	return 0
+}
+
+type isDomain_Attribute_TypedValue interface {
+	isDomain_Attribute_TypedValue()
+}
+
+type Domain_Attribute_BoolValue struct {
+	BoolValue bool `protobuf:"varint,2,opt,name=bool_value,json=boolValue,proto3,oneof"`
+}
+
+type Domain_Attribute_IntValue struct {
+	IntValue int64 `protobuf:"varint,3,opt,name=int_value,json=intValue,proto3,oneof"`
+}
+
+func (*Domain_Attribute_BoolValue) isDomain_Attribute_TypedValue() {}
+
+func (*Domain_Attribute_IntValue) isDomain_Attribute_TypedValue() {}
+
+var File_component_geodata_router_config_proto protoreflect.FileDescriptor
+
+var file_component_geodata_router_config_proto_rawDesc = []byte{
+	0x0a, 0x25, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2f, 0x67, 0x65, 0x6f, 0x64,
+	0x61, 0x74, 0x61, 0x2f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2f, 0x63, 0x6f, 0x6e, 0x66, 0x69,
+	0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1e, 0x63, 0x6c, 0x61, 0x73, 0x68, 0x2e, 0x63,
+	0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x67, 0x65, 0x6f, 0x64, 0x61, 0x74, 0x61,
+	0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x22, 0xd1, 0x02, 0x0a, 0x06, 0x44, 0x6f, 0x6d, 0x61,
+	0x69, 0x6e, 0x12, 0x3f, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e,
+	0x32, 0x2b, 0x2e, 0x63, 0x6c, 0x61, 0x73, 0x68, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65,
+	0x6e, 0x74, 0x2e, 0x67, 0x65, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65,
+	0x72, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74,
+	0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x4e, 0x0a, 0x09, 0x61, 0x74, 0x74,
+	0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x63,
+	0x6c, 0x61, 0x73, 0x68, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x67,
+	0x65, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x44, 0x6f,
+	0x6d, 0x61, 0x69, 0x6e, 0x2e, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x52, 0x09,
+	0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x1a, 0x6c, 0x0a, 0x09, 0x41, 0x74, 0x74,
+	0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x1f, 0x0a, 0x0a, 0x62, 0x6f, 0x6f, 0x6c,
+	0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x09,
+	0x62, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1d, 0x0a, 0x09, 0x69, 0x6e, 0x74,
+	0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x08,
+	0x69, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x0d, 0x0a, 0x0b, 0x74, 0x79, 0x70, 0x65,
+	0x64, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x32, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12,
+	0x09, 0x0a, 0x05, 0x50, 0x6c, 0x61, 0x69, 0x6e, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x52, 0x65,
+	0x67, 0x65, 0x78, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x10,
+	0x02, 0x12, 0x08, 0x0a, 0x04, 0x46, 0x75, 0x6c, 0x6c, 0x10, 0x03, 0x22, 0x2e, 0x0a, 0x04, 0x43,
+	0x49, 0x44, 0x52, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52,
+	0x02, 0x69, 0x70, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0d, 0x52, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x22, 0x89, 0x01, 0x0a, 0x05,
+	0x47, 0x65, 0x6f, 0x49, 0x50, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x79,
+	0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x75,
+	0x6e, 0x74, 0x72, 0x79, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x38, 0x0a, 0x04, 0x63, 0x69, 0x64, 0x72,
+	0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x63, 0x6c, 0x61, 0x73, 0x68, 0x2e, 0x63,
+	0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x67, 0x65, 0x6f, 0x64, 0x61, 0x74, 0x61,
+	0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x43, 0x49, 0x44, 0x52, 0x52, 0x04, 0x63, 0x69,
+	0x64, 0x72, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x5f, 0x6d, 0x61,
+	0x74, 0x63, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x76, 0x65, 0x72,
+	0x73, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x22, 0x48, 0x0a, 0x09, 0x47, 0x65, 0x6f, 0x49, 0x50,
+	0x4c, 0x69, 0x73, 0x74, 0x12, 0x3b, 0x0a, 0x05, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x18, 0x01, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x63, 0x6c, 0x61, 0x73, 0x68, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
+	0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x67, 0x65, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x72, 0x6f,
+	0x75, 0x74, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x6f, 0x49, 0x50, 0x52, 0x05, 0x65, 0x6e, 0x74, 0x72,
+	0x79, 0x22, 0x6c, 0x0a, 0x07, 0x47, 0x65, 0x6f, 0x53, 0x69, 0x74, 0x65, 0x12, 0x21, 0x0a, 0x0c,
+	0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x79, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x79, 0x43, 0x6f, 0x64, 0x65, 0x12,
+	0x3e, 0x0a, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x26, 0x2e, 0x63, 0x6c, 0x61, 0x73, 0x68, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e,
+	0x74, 0x2e, 0x67, 0x65, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72,
+	0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x52, 0x06, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x22,
+	0x4c, 0x0a, 0x0b, 0x47, 0x65, 0x6f, 0x53, 0x69, 0x74, 0x65, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x3d,
+	0x0a, 0x05, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e,
+	0x63, 0x6c, 0x61, 0x73, 0x68, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e,
+	0x67, 0x65, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x47,
+	0x65, 0x6f, 0x53, 0x69, 0x74, 0x65, 0x52, 0x05, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x7c, 0x0a,
+	0x22, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6c, 0x61, 0x73, 0x68, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f,
+	0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x67, 0x65, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x72, 0x6f, 0x75,
+	0x74, 0x65, 0x72, 0x50, 0x01, 0x5a, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f,
+	0x6d, 0x2f, 0x44, 0x72, 0x65, 0x61, 0x6d, 0x61, 0x63, 0x72, 0x6f, 0x2f, 0x63, 0x6c, 0x61, 0x73,
+	0x68, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2f, 0x67, 0x65, 0x6f, 0x64,
+	0x61, 0x74, 0x61, 0x2f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0xaa, 0x02, 0x1e, 0x43, 0x6c, 0x61,
+	0x73, 0x68, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x47, 0x65, 0x6f,
+	0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x33,
+}
+
+var (
+	file_component_geodata_router_config_proto_rawDescOnce sync.Once
+	file_component_geodata_router_config_proto_rawDescData = file_component_geodata_router_config_proto_rawDesc
+)
+
+func file_component_geodata_router_config_proto_rawDescGZIP() []byte {
+	file_component_geodata_router_config_proto_rawDescOnce.Do(func() {
+		file_component_geodata_router_config_proto_rawDescData = protoimpl.X.CompressGZIP(file_component_geodata_router_config_proto_rawDescData)
+	})
+	return file_component_geodata_router_config_proto_rawDescData
+}
+
+var file_component_geodata_router_config_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
+var file_component_geodata_router_config_proto_msgTypes = make([]protoimpl.MessageInfo, 7)
+var file_component_geodata_router_config_proto_goTypes = []interface{}{
+	(Domain_Type)(0),         // 0: clash.component.geodata.router.Domain.Type
+	(*Domain)(nil),           // 1: clash.component.geodata.router.Domain
+	(*CIDR)(nil),             // 2: clash.component.geodata.router.CIDR
+	(*GeoIP)(nil),            // 3: clash.component.geodata.router.GeoIP
+	(*GeoIPList)(nil),        // 4: clash.component.geodata.router.GeoIPList
+	(*GeoSite)(nil),          // 5: clash.component.geodata.router.GeoSite
+	(*GeoSiteList)(nil),      // 6: clash.component.geodata.router.GeoSiteList
+	(*Domain_Attribute)(nil), // 7: clash.component.geodata.router.Domain.Attribute
+}
+var file_component_geodata_router_config_proto_depIdxs = []int32{
+	0, // 0: clash.component.geodata.router.Domain.type:type_name -> clash.component.geodata.router.Domain.Type
+	7, // 1: clash.component.geodata.router.Domain.attribute:type_name -> clash.component.geodata.router.Domain.Attribute
+	2, // 2: clash.component.geodata.router.GeoIP.cidr:type_name -> clash.component.geodata.router.CIDR
+	3, // 3: clash.component.geodata.router.GeoIPList.entry:type_name -> clash.component.geodata.router.GeoIP
+	1, // 4: clash.component.geodata.router.GeoSite.domain:type_name -> clash.component.geodata.router.Domain
+	5, // 5: clash.component.geodata.router.GeoSiteList.entry:type_name -> clash.component.geodata.router.GeoSite
+	6, // [6:6] is the sub-list for method output_type
+	6, // [6:6] is the sub-list for method input_type
+	6, // [6:6] is the sub-list for extension type_name
+	6, // [6:6] is the sub-list for extension extendee
+	0, // [0:6] is the sub-list for field type_name
+}
+
+func init() { file_component_geodata_router_config_proto_init() }
+func file_component_geodata_router_config_proto_init() {
+	if File_component_geodata_router_config_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_component_geodata_router_config_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Domain); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_component_geodata_router_config_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*CIDR); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_component_geodata_router_config_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GeoIP); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_component_geodata_router_config_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GeoIPList); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_component_geodata_router_config_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GeoSite); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_component_geodata_router_config_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GeoSiteList); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_component_geodata_router_config_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Domain_Attribute); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	file_component_geodata_router_config_proto_msgTypes[6].OneofWrappers = []interface{}{
+		(*Domain_Attribute_BoolValue)(nil),
+		(*Domain_Attribute_IntValue)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_component_geodata_router_config_proto_rawDesc,
+			NumEnums:      1,
+			NumMessages:   7,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_component_geodata_router_config_proto_goTypes,
+		DependencyIndexes: file_component_geodata_router_config_proto_depIdxs,
+		EnumInfos:         file_component_geodata_router_config_proto_enumTypes,
+		MessageInfos:      file_component_geodata_router_config_proto_msgTypes,
+	}.Build()
+	File_component_geodata_router_config_proto = out.File
+	file_component_geodata_router_config_proto_rawDesc = nil
+	file_component_geodata_router_config_proto_goTypes = nil
+	file_component_geodata_router_config_proto_depIdxs = nil
+}

component/geodata/router/config.proto

@@ -0,0 +1,68 @@
+syntax = "proto3";
+
+package clash.component.geodata.router;
+option csharp_namespace = "Clash.Component.Geodata.Router";
+option go_package = "github.com/Dreamacro/clash/component/geodata/router";
+option java_package = "com.clash.component.geodata.router";
+option java_multiple_files = true;
+
+// Domain for routing decision.
+message Domain {
+  // Type of domain value.
+  enum Type {
+    // The value is used as is.
+    Plain = 0;
+    // The value is used as a regular expression.
+    Regex = 1;
+    // The value is a root domain.
+    Domain = 2;
+    // The value is a domain.
+    Full = 3;
+  }
+
+  // Domain matching type.
+  Type type = 1;
+
+  // Domain value.
+  string value = 2;
+
+  message Attribute {
+    string key = 1;
+
+    oneof typed_value {
+      bool bool_value = 2;
+      int64 int_value = 3;
+    }
+  }
+
+  // Attributes of this domain. May be used for filtering.
+  repeated Attribute attribute = 3;
+}
+
+// IP for routing decision, in CIDR form.
+message CIDR {
+  // IP address, should be either 4 or 16 bytes.
+  bytes ip = 1;
+
+  // Number of leading ones in the network mask.
+  uint32 prefix = 2;
+}
+
+message GeoIP {
+  string country_code = 1;
+  repeated CIDR cidr = 2;
+  bool reverse_match = 3;
+}
+
+message GeoIPList {
+  repeated GeoIP entry = 1;
+}
+
+message GeoSite {
+  string country_code = 1;
+  repeated Domain domain = 2;
+}
+
+message GeoSiteList {
+  repeated GeoSite entry = 1;
+}

component/geodata/standard/standard.go

@@ -0,0 +1,83 @@
+package standard
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/Dreamacro/clash/component/geodata"
+	"github.com/Dreamacro/clash/component/geodata/router"
+	C "github.com/Dreamacro/clash/constant"
+	"google.golang.org/protobuf/proto"
+)
+
+func ReadFile(path string) ([]byte, error) {
+	reader, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer func(reader *os.File) {
+		_ = reader.Close()
+	}(reader)
+
+	return io.ReadAll(reader)
+}
+
+func ReadAsset(file string) ([]byte, error) {
+	return ReadFile(C.Path.GetAssetLocation(file))
+}
+
+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
+	}
+
+	for _, geoip := range geoipList.Entry {
+		if strings.EqualFold(geoip.CountryCode, country) {
+			return geoip.Cidr, nil
+		}
+	}
+
+	return nil, fmt.Errorf("country not found in %s%s%s", filename, ": ", country)
+}
+
+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
+	}
+
+	for _, site := range geositeList.Entry {
+		if strings.EqualFold(site.CountryCode, list) {
+			return site.Domain, nil
+		}
+	}
+
+	return nil, fmt.Errorf("list not found in %s%s%s", filename, ": ", list)
+}
+
+type standardLoader struct{}
+
+func (d standardLoader) LoadSite(filename, list string) ([]*router.Domain, error) {
+	return loadSite(filename, list)
+}
+
+func (d standardLoader) LoadIP(filename, country string) ([]*router.CIDR, error) {
+	return loadIP(filename, country)
+}
+
+func init() {
+	geodata.RegisterGeoDataLoaderImplementationCreator("standard", func() geodata.LoaderImplementation {
+		return standardLoader{}
+	})
+}

component/geodata/strmatcher/ac_automaton_matcher.go

@@ -0,0 +1,241 @@
+package strmatcher
+
+import (
+	"container/list"
+)
+
+const validCharCount = 53
+
+type MatchType struct {
+	matchType Type
+	exist     bool
+}
+
+const (
+	TrieEdge bool = true
+	FailEdge bool = false
+)
+
+type Edge struct {
+	edgeType bool
+	nextNode int
+}
+
+type ACAutomaton struct {
+	trie   [][validCharCount]Edge
+	fail   []int
+	exists []MatchType
+	count  int
+}
+
+func newNode() [validCharCount]Edge {
+	var s [validCharCount]Edge
+	for i := range s {
+		s[i] = Edge{
+			edgeType: FailEdge,
+			nextNode: 0,
+		}
+	}
+	return s
+}
+
+var char2Index = []int{
+	'A':  0,
+	'a':  0,
+	'B':  1,
+	'b':  1,
+	'C':  2,
+	'c':  2,
+	'D':  3,
+	'd':  3,
+	'E':  4,
+	'e':  4,
+	'F':  5,
+	'f':  5,
+	'G':  6,
+	'g':  6,
+	'H':  7,
+	'h':  7,
+	'I':  8,
+	'i':  8,
+	'J':  9,
+	'j':  9,
+	'K':  10,
+	'k':  10,
+	'L':  11,
+	'l':  11,
+	'M':  12,
+	'm':  12,
+	'N':  13,
+	'n':  13,
+	'O':  14,
+	'o':  14,
+	'P':  15,
+	'p':  15,
+	'Q':  16,
+	'q':  16,
+	'R':  17,
+	'r':  17,
+	'S':  18,
+	's':  18,
+	'T':  19,
+	't':  19,
+	'U':  20,
+	'u':  20,
+	'V':  21,
+	'v':  21,
+	'W':  22,
+	'w':  22,
+	'X':  23,
+	'x':  23,
+	'Y':  24,
+	'y':  24,
+	'Z':  25,
+	'z':  25,
+	'!':  26,
+	'$':  27,
+	'&':  28,
+	'\'': 29,
+	'(':  30,
+	')':  31,
+	'*':  32,
+	'+':  33,
+	',':  34,
+	';':  35,
+	'=':  36,
+	':':  37,
+	'%':  38,
+	'-':  39,
+	'.':  40,
+	'_':  41,
+	'~':  42,
+	'0':  43,
+	'1':  44,
+	'2':  45,
+	'3':  46,
+	'4':  47,
+	'5':  48,
+	'6':  49,
+	'7':  50,
+	'8':  51,
+	'9':  52,
+}
+
+func NewACAutomaton() *ACAutomaton {
+	ac := new(ACAutomaton)
+	ac.trie = append(ac.trie, newNode())
+	ac.fail = append(ac.fail, 0)
+	ac.exists = append(ac.exists, MatchType{
+		matchType: Full,
+		exist:     false,
+	})
+	return ac
+}
+
+func (ac *ACAutomaton) Add(domain string, t Type) {
+	node := 0
+	for i := len(domain) - 1; i >= 0; i-- {
+		idx := char2Index[domain[i]]
+		if ac.trie[node][idx].nextNode == 0 {
+			ac.count++
+			if len(ac.trie) < ac.count+1 {
+				ac.trie = append(ac.trie, newNode())
+				ac.fail = append(ac.fail, 0)
+				ac.exists = append(ac.exists, MatchType{
+					matchType: Full,
+					exist:     false,
+				})
+			}
+			ac.trie[node][idx] = Edge{
+				edgeType: TrieEdge,
+				nextNode: ac.count,
+			}
+		}
+		node = ac.trie[node][idx].nextNode
+	}
+	ac.exists[node] = MatchType{
+		matchType: t,
+		exist:     true,
+	}
+	switch t {
+	case Domain:
+		ac.exists[node] = MatchType{
+			matchType: Full,
+			exist:     true,
+		}
+		idx := char2Index['.']
+		if ac.trie[node][idx].nextNode == 0 {
+			ac.count++
+			if len(ac.trie) < ac.count+1 {
+				ac.trie = append(ac.trie, newNode())
+				ac.fail = append(ac.fail, 0)
+				ac.exists = append(ac.exists, MatchType{
+					matchType: Full,
+					exist:     false,
+				})
+			}
+			ac.trie[node][idx] = Edge{
+				edgeType: TrieEdge,
+				nextNode: ac.count,
+			}
+		}
+		node = ac.trie[node][idx].nextNode
+		ac.exists[node] = MatchType{
+			matchType: t,
+			exist:     true,
+		}
+	default:
+		break
+	}
+}
+
+func (ac *ACAutomaton) Build() {
+	queue := list.New()
+	for i := 0; i < validCharCount; i++ {
+		if ac.trie[0][i].nextNode != 0 {
+			queue.PushBack(ac.trie[0][i])
+		}
+	}
+	for {
+		front := queue.Front()
+		if front == nil {
+			break
+		} else {
+			node := front.Value.(Edge).nextNode
+			queue.Remove(front)
+			for i := 0; i < validCharCount; i++ {
+				if ac.trie[node][i].nextNode != 0 {
+					ac.fail[ac.trie[node][i].nextNode] = ac.trie[ac.fail[node]][i].nextNode
+					queue.PushBack(ac.trie[node][i])
+				} else {
+					ac.trie[node][i] = Edge{
+						edgeType: FailEdge,
+						nextNode: ac.trie[ac.fail[node]][i].nextNode,
+					}
+				}
+			}
+		}
+	}
+}
+
+func (ac *ACAutomaton) Match(s string) bool {
+	node := 0
+	fullMatch := true
+	// 1. the match string is all through trie edge. FULL MATCH or DOMAIN
+	// 2. the match string is through a fail edge. NOT FULL MATCH
+	// 2.1 Through a fail edge, but there exists a valid node. SUBSTR
+	for i := len(s) - 1; i >= 0; i-- {
+		idx := char2Index[s[i]]
+		fullMatch = fullMatch && ac.trie[node][idx].edgeType
+		node = ac.trie[node][idx].nextNode
+		switch ac.exists[node].matchType {
+		case Substr:
+			return true
+		case Domain:
+			if fullMatch {
+				return true
+			}
+		}
+	}
+	return fullMatch && ac.exists[node].exist
+}

component/geodata/strmatcher/domain_matcher.go

@@ -0,0 +1,98 @@
+package strmatcher
+
+import "strings"
+
+func breakDomain(domain string) []string {
+	return strings.Split(domain, ".")
+}
+
+type node struct {
+	values []uint32
+	sub    map[string]*node
+}
+
+// DomainMatcherGroup is a IndexMatcher for a large set of Domain matchers.
+// Visible for testing only.
+type DomainMatcherGroup struct {
+	root *node
+}
+
+func (g *DomainMatcherGroup) Add(domain string, value uint32) {
+	if g.root == nil {
+		g.root = new(node)
+	}
+
+	current := g.root
+	parts := breakDomain(domain)
+	for i := len(parts) - 1; i >= 0; i-- {
+		part := parts[i]
+		if current.sub == nil {
+			current.sub = make(map[string]*node)
+		}
+		next := current.sub[part]
+		if next == nil {
+			next = new(node)
+			current.sub[part] = next
+		}
+		current = next
+	}
+
+	current.values = append(current.values, value)
+}
+
+func (g *DomainMatcherGroup) addMatcher(m domainMatcher, value uint32) {
+	g.Add(string(m), value)
+}
+
+func (g *DomainMatcherGroup) Match(domain string) []uint32 {
+	if domain == "" {
+		return nil
+	}
+
+	current := g.root
+	if current == nil {
+		return nil
+	}
+
+	nextPart := func(idx int) int {
+		for i := idx - 1; i >= 0; i-- {
+			if domain[i] == '.' {
+				return i
+			}
+		}
+		return -1
+	}
+
+	matches := [][]uint32{}
+	idx := len(domain)
+	for {
+		if idx == -1 || current.sub == nil {
+			break
+		}
+
+		nidx := nextPart(idx)
+		part := domain[nidx+1 : idx]
+		next := current.sub[part]
+		if next == nil {
+			break
+		}
+		current = next
+		idx = nidx
+		if len(current.values) > 0 {
+			matches = append(matches, current.values)
+		}
+	}
+	switch len(matches) {
+	case 0:
+		return nil
+	case 1:
+		return matches[0]
+	default:
+		result := []uint32{}
+		for idx := range matches {
+			// Insert reversely, the subdomain that matches further ranks higher
+			result = append(result, matches[len(matches)-1-idx]...)
+		}
+		return result
+	}
+}

component/geodata/strmatcher/full_matcher.go

@@ -0,0 +1,25 @@
+package strmatcher
+
+type FullMatcherGroup struct {
+	matchers map[string][]uint32
+}
+
+func (g *FullMatcherGroup) Add(domain string, value uint32) {
+	if g.matchers == nil {
+		g.matchers = make(map[string][]uint32)
+	}
+
+	g.matchers[domain] = append(g.matchers[domain], value)
+}
+
+func (g *FullMatcherGroup) addMatcher(m fullMatcher, value uint32) {
+	g.Add(string(m), value)
+}
+
+func (g *FullMatcherGroup) Match(str string) []uint32 {
+	if g.matchers == nil {
+		return nil
+	}
+
+	return g.matchers[str]
+}

component/geodata/strmatcher/matchers.go

@@ -0,0 +1,52 @@
+package strmatcher
+
+import (
+	"regexp"
+	"strings"
+)
+
+type fullMatcher string
+
+func (m fullMatcher) Match(s string) bool {
+	return string(m) == s
+}
+
+func (m fullMatcher) String() string {
+	return "full:" + string(m)
+}
+
+type substrMatcher string
+
+func (m substrMatcher) Match(s string) bool {
+	return strings.Contains(s, string(m))
+}
+
+func (m substrMatcher) String() string {
+	return "keyword:" + string(m)
+}
+
+type domainMatcher string
+
+func (m domainMatcher) Match(s string) bool {
+	pattern := string(m)
+	if !strings.HasSuffix(s, pattern) {
+		return false
+	}
+	return len(s) == len(pattern) || s[len(s)-len(pattern)-1] == '.'
+}
+
+func (m domainMatcher) String() string {
+	return "domain:" + string(m)
+}
+
+type regexMatcher struct {
+	pattern *regexp.Regexp
+}
+
+func (m *regexMatcher) Match(s string) bool {
+	return m.pattern.MatchString(s)
+}
+
+func (m *regexMatcher) String() string {
+	return "regexp:" + m.pattern.String()
+}

component/geodata/strmatcher/mph_matcher.go

@@ -0,0 +1,304 @@
+package strmatcher
+
+import (
+	"math/bits"
+	"regexp"
+	"sort"
+	"strings"
+	"unsafe"
+)
+
+// PrimeRK is the prime base used in Rabin-Karp algorithm.
+const PrimeRK = 16777619
+
+// calculate the rolling murmurHash of given string
+func RollingHash(s string) uint32 {
+	h := uint32(0)
+	for i := len(s) - 1; i >= 0; i-- {
+		h = h*PrimeRK + uint32(s[i])
+	}
+	return h
+}
+
+// A MphMatcherGroup is divided into three parts:
+// 1. `full` and `domain` patterns are matched by Rabin-Karp algorithm and minimal perfect hash table;
+// 2. `substr` patterns are matched by ac automaton;
+// 3. `regex` patterns are matched with the regex library.
+type MphMatcherGroup struct {
+	ac            *ACAutomaton
+	otherMatchers []matcherEntry
+	rules         []string
+	level0        []uint32
+	level0Mask    int
+	level1        []uint32
+	level1Mask    int
+	count         uint32
+	ruleMap       *map[string]uint32
+}
+
+func (g *MphMatcherGroup) AddFullOrDomainPattern(pattern string, t Type) {
+	h := RollingHash(pattern)
+	switch t {
+	case Domain:
+		(*g.ruleMap)["."+pattern] = h*PrimeRK + uint32('.')
+		fallthrough
+	case Full:
+		(*g.ruleMap)[pattern] = h
+	default:
+	}
+}
+
+func NewMphMatcherGroup() *MphMatcherGroup {
+	return &MphMatcherGroup{
+		ac:            nil,
+		otherMatchers: nil,
+		rules:         nil,
+		level0:        nil,
+		level0Mask:    0,
+		level1:        nil,
+		level1Mask:    0,
+		count:         1,
+		ruleMap:       &map[string]uint32{},
+	}
+}
+
+// AddPattern adds a pattern to MphMatcherGroup
+func (g *MphMatcherGroup) AddPattern(pattern string, t Type) (uint32, error) {
+	switch t {
+	case Substr:
+		if g.ac == nil {
+			g.ac = NewACAutomaton()
+		}
+		g.ac.Add(pattern, t)
+	case Full, Domain:
+		pattern = strings.ToLower(pattern)
+		g.AddFullOrDomainPattern(pattern, t)
+	case Regex:
+		r, err := regexp.Compile(pattern)
+		if err != nil {
+			return 0, err
+		}
+		g.otherMatchers = append(g.otherMatchers, matcherEntry{
+			m:  &regexMatcher{pattern: r},
+			id: g.count,
+		})
+	default:
+		panic("Unknown type")
+	}
+	return g.count, nil
+}
+
+// Build builds a minimal perfect hash table and ac automaton from insert rules
+func (g *MphMatcherGroup) Build() {
+	if g.ac != nil {
+		g.ac.Build()
+	}
+	keyLen := len(*g.ruleMap)
+	if keyLen == 0 {
+		keyLen = 1
+		(*g.ruleMap)["empty___"] = RollingHash("empty___")
+	}
+	g.level0 = make([]uint32, nextPow2(keyLen/4))
+	g.level0Mask = len(g.level0) - 1
+	g.level1 = make([]uint32, nextPow2(keyLen))
+	g.level1Mask = len(g.level1) - 1
+	sparseBuckets := make([][]int, len(g.level0))
+	var ruleIdx int
+	for rule, hash := range *g.ruleMap {
+		n := int(hash) & g.level0Mask
+		g.rules = append(g.rules, rule)
+		sparseBuckets[n] = append(sparseBuckets[n], ruleIdx)
+		ruleIdx++
+	}
+	g.ruleMap = nil
+	var buckets []indexBucket
+	for n, vals := range sparseBuckets {
+		if len(vals) > 0 {
+			buckets = append(buckets, indexBucket{n, vals})
+		}
+	}
+	sort.Sort(bySize(buckets))
+
+	occ := make([]bool, len(g.level1))
+	var tmpOcc []int
+	for _, bucket := range buckets {
+		seed := uint32(0)
+		for {
+			findSeed := true
+			tmpOcc = tmpOcc[:0]
+			for _, i := range bucket.vals {
+				n := int(strhashFallback(unsafe.Pointer(&g.rules[i]), uintptr(seed))) & g.level1Mask
+				if occ[n] {
+					for _, n := range tmpOcc {
+						occ[n] = false
+					}
+					seed++
+					findSeed = false
+					break
+				}
+				occ[n] = true
+				tmpOcc = append(tmpOcc, n)
+				g.level1[n] = uint32(i)
+			}
+			if findSeed {
+				g.level0[bucket.n] = seed
+				break
+			}
+		}
+	}
+}
+
+func nextPow2(v int) int {
+	if v <= 1 {
+		return 1
+	}
+	const MaxUInt = ^uint(0)
+	n := (MaxUInt >> bits.LeadingZeros(uint(v))) + 1
+	return int(n)
+}
+
+// Lookup searches for s in t and returns its index and whether it was found.
+func (g *MphMatcherGroup) Lookup(h uint32, s string) bool {
+	i0 := int(h) & g.level0Mask
+	seed := g.level0[i0]
+	i1 := int(strhashFallback(unsafe.Pointer(&s), uintptr(seed))) & g.level1Mask
+	n := g.level1[i1]
+	return s == g.rules[int(n)]
+}
+
+// Match implements IndexMatcher.Match.
+func (g *MphMatcherGroup) Match(pattern string) []uint32 {
+	result := []uint32{}
+	hash := uint32(0)
+	for i := len(pattern) - 1; i >= 0; i-- {
+		hash = hash*PrimeRK + uint32(pattern[i])
+		if pattern[i] == '.' {
+			if g.Lookup(hash, pattern[i:]) {
+				result = append(result, 1)
+				return result
+			}
+		}
+	}
+	if g.Lookup(hash, pattern) {
+		result = append(result, 1)
+		return result
+	}
+	if g.ac != nil && g.ac.Match(pattern) {
+		result = append(result, 1)
+		return result
+	}
+	for _, e := range g.otherMatchers {
+		if e.m.Match(pattern) {
+			result = append(result, e.id)
+			return result
+		}
+	}
+	return nil
+}
+
+type indexBucket struct {
+	n    int
+	vals []int
+}
+
+type bySize []indexBucket
+
+func (s bySize) Len() int           { return len(s) }
+func (s bySize) Less(i, j int) bool { return len(s[i].vals) > len(s[j].vals) }
+func (s bySize) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
+type stringStruct struct {
+	str unsafe.Pointer
+	len int
+}
+
+func strhashFallback(a unsafe.Pointer, h uintptr) uintptr {
+	x := (*stringStruct)(a)
+	return memhashFallback(x.str, h, uintptr(x.len))
+}
+
+const (
+	// Constants for multiplication: four random odd 64-bit numbers.
+	m1 = 16877499708836156737
+	m2 = 2820277070424839065
+	m3 = 9497967016996688599
+	m4 = 15839092249703872147
+)
+
+var hashkey = [4]uintptr{1, 1, 1, 1}
+
+func memhashFallback(p unsafe.Pointer, seed, s uintptr) uintptr {
+	h := uint64(seed + s*hashkey[0])
+tail:
+	switch {
+	case s == 0:
+	case s < 4:
+		h ^= uint64(*(*byte)(p))
+		h ^= uint64(*(*byte)(add(p, s>>1))) << 8
+		h ^= uint64(*(*byte)(add(p, s-1))) << 16
+		h = rotl31(h*m1) * m2
+	case s <= 8:
+		h ^= uint64(readUnaligned32(p))
+		h ^= uint64(readUnaligned32(add(p, s-4))) << 32
+		h = rotl31(h*m1) * m2
+	case s <= 16:
+		h ^= readUnaligned64(p)
+		h = rotl31(h*m1) * m2
+		h ^= readUnaligned64(add(p, s-8))
+		h = rotl31(h*m1) * m2
+	case s <= 32:
+		h ^= readUnaligned64(p)
+		h = rotl31(h*m1) * m2
+		h ^= readUnaligned64(add(p, 8))
+		h = rotl31(h*m1) * m2
+		h ^= readUnaligned64(add(p, s-16))
+		h = rotl31(h*m1) * m2
+		h ^= readUnaligned64(add(p, s-8))
+		h = rotl31(h*m1) * m2
+	default:
+		v1 := h
+		v2 := uint64(seed * hashkey[1])
+		v3 := uint64(seed * hashkey[2])
+		v4 := uint64(seed * hashkey[3])
+		for s >= 32 {
+			v1 ^= readUnaligned64(p)
+			v1 = rotl31(v1*m1) * m2
+			p = add(p, 8)
+			v2 ^= readUnaligned64(p)
+			v2 = rotl31(v2*m2) * m3
+			p = add(p, 8)
+			v3 ^= readUnaligned64(p)
+			v3 = rotl31(v3*m3) * m4
+			p = add(p, 8)
+			v4 ^= readUnaligned64(p)
+			v4 = rotl31(v4*m4) * m1
+			p = add(p, 8)
+			s -= 32
+		}
+		h = v1 ^ v2 ^ v3 ^ v4
+		goto tail
+	}
+
+	h ^= h >> 29
+	h *= m3
+	h ^= h >> 32
+	return uintptr(h)
+}
+
+func add(p unsafe.Pointer, x uintptr) unsafe.Pointer {
+	return unsafe.Pointer(uintptr(p) + x)
+}
+
+func readUnaligned32(p unsafe.Pointer) uint32 {
+	q := (*[4]byte)(p)
+	return uint32(q[0]) | uint32(q[1])<<8 | uint32(q[2])<<16 | uint32(q[3])<<24
+}
+
+func rotl31(x uint64) uint64 {
+	return (x << 31) | (x >> (64 - 31))
+}
+
+func readUnaligned64(p unsafe.Pointer) uint64 {
+	q := (*[8]byte)(p)
+	return uint64(q[0]) | uint64(q[1])<<8 | uint64(q[2])<<16 | uint64(q[3])<<24 | uint64(q[4])<<32 | uint64(q[5])<<40 | uint64(q[6])<<48 | uint64(q[7])<<56
+}

component/geodata/strmatcher/package_info.go

@@ -0,0 +1,4 @@
+// Modified from: https://github.com/v2fly/v2ray-core/tree/master/common/strmatcher
+// License: MIT
+
+package strmatcher

component/geodata/strmatcher/strmatcher.go

@@ -0,0 +1,107 @@
+package strmatcher
+
+import (
+	"regexp"
+)
+
+// Matcher is the interface to determine a string matches a pattern.
+type Matcher interface {
+	// Match returns true if the given string matches a predefined pattern.
+	Match(string) bool
+	String() string
+}
+
+// Type is the type of the matcher.
+type Type byte
+
+const (
+	// Full is the type of matcher that the input string must exactly equal to the pattern.
+	Full Type = iota
+	// Substr is the type of matcher that the input string must contain the pattern as a sub-string.
+	Substr
+	// Domain is the type of matcher that the input string must be a sub-domain or itself of the pattern.
+	Domain
+	// Regex is the type of matcher that the input string must matches the regular-expression pattern.
+	Regex
+)
+
+// New creates a new Matcher based on the given pattern.
+func (t Type) New(pattern string) (Matcher, error) {
+	// 1. regex matching is case-sensitive
+	switch t {
+	case Full:
+		return fullMatcher(pattern), nil
+	case Substr:
+		return substrMatcher(pattern), nil
+	case Domain:
+		return domainMatcher(pattern), nil
+	case Regex:
+		r, err := regexp.Compile(pattern)
+		if err != nil {
+			return nil, err
+		}
+		return &regexMatcher{
+			pattern: r,
+		}, nil
+	default:
+		panic("Unknown type")
+	}
+}
+
+// IndexMatcher is the interface for matching with a group of matchers.
+type IndexMatcher interface {
+	// Match returns the index of a matcher that matches the input. It returns empty array if no such matcher exists.
+	Match(input string) []uint32
+}
+
+type matcherEntry struct {
+	m  Matcher
+	id uint32
+}
+
+// MatcherGroup is an implementation of IndexMatcher.
+// Empty initialization works.
+type MatcherGroup struct {
+	count         uint32
+	fullMatcher   FullMatcherGroup
+	domainMatcher DomainMatcherGroup
+	otherMatchers []matcherEntry
+}
+
+// Add adds a new Matcher into the MatcherGroup, and returns its index. The index will never be 0.
+func (g *MatcherGroup) Add(m Matcher) uint32 {
+	g.count++
+	c := g.count
+
+	switch tm := m.(type) {
+	case fullMatcher:
+		g.fullMatcher.addMatcher(tm, c)
+	case domainMatcher:
+		g.domainMatcher.addMatcher(tm, c)
+	default:
+		g.otherMatchers = append(g.otherMatchers, matcherEntry{
+			m:  m,
+			id: c,
+		})
+	}
+
+	return c
+}
+
+// Match implements IndexMatcher.Match.
+func (g *MatcherGroup) Match(pattern string) []uint32 {
+	result := []uint32{}
+	result = append(result, g.fullMatcher.Match(pattern)...)
+	result = append(result, g.domainMatcher.Match(pattern)...)
+	for _, e := range g.otherMatchers {
+		if e.m.Match(pattern) {
+			result = append(result, e.id)
+		}
+	}
+	return result
+}
+
+// Size returns the number of matchers in the MatcherGroup.
+func (g *MatcherGroup) Size() uint32 {
+	return g.count
+}

component/geodata/utils.go

@@ -0,0 +1,30 @@
+package geodata
+
+import (
+	"github.com/Dreamacro/clash/component/geodata/router"
+)
+
+func LoadGeoSiteMatcher(countryCode string) (*router.DomainMatcher, int, error) {
+	geoLoaderName := "standard"
+	geoLoader, err := GetGeoDataLoader(geoLoaderName)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	domains, err := geoLoader.LoadGeoSite(countryCode)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	/**
+	linear: linear algorithm
+	matcher, err := router.NewDomainMatcher(domains)
+	mph：minimal perfect hash algorithm
+	*/
+	matcher, err := router.NewMphMatcherGroup(domains)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return matcher, len(domains), nil
+}

component/iface/iface.go

@@ -0,0 +1,115 @@
+package iface
+
+import (
+	"errors"
+	"net"
+	"time"
+
+	"github.com/Dreamacro/clash/common/singledo"
+)
+
+type Interface struct {
+	Index        int
+	Name         string
+	Addrs        []*net.IPNet
+	HardwareAddr net.HardwareAddr
+}
+
+var (
+	ErrIfaceNotFound = errors.New("interface not found")
+	ErrAddrNotFound  = errors.New("addr not found")
+)
+
+var interfaces = singledo.NewSingle(time.Second * 20)
+
+func ResolveInterface(name string) (*Interface, error) {
+	value, err, _ := interfaces.Do(func() (interface{}, error) {
+		ifaces, err := net.Interfaces()
+		if err != nil {
+			return nil, err
+		}
+
+		r := map[string]*Interface{}
+
+		for _, iface := range ifaces {
+			addrs, err := iface.Addrs()
+			if err != nil {
+				continue
+			}
+
+			ipNets := make([]*net.IPNet, 0, len(addrs))
+			for _, addr := range addrs {
+				ipNet := addr.(*net.IPNet)
+				if v4 := ipNet.IP.To4(); v4 != nil {
+					ipNet.IP = v4
+				}
+
+				ipNets = append(ipNets, ipNet)
+			}
+
+			r[iface.Name] = &Interface{
+				Index:        iface.Index,
+				Name:         iface.Name,
+				Addrs:        ipNets,
+				HardwareAddr: iface.HardwareAddr,
+			}
+		}
+
+		return r, nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	ifaces := value.(map[string]*Interface)
+	iface, ok := ifaces[name]
+	if !ok {
+		return nil, ErrIfaceNotFound
+	}
+
+	return iface, nil
+}
+
+func FlushCache() {
+	interfaces.Reset()
+}
+
+func (iface *Interface) PickIPv4Addr(destination net.IP) (*net.IPNet, error) {
+	return iface.pickIPAddr(destination, func(addr *net.IPNet) bool {
+		return addr.IP.To4() != nil
+	})
+}
+
+func (iface *Interface) PickIPv6Addr(destination net.IP) (*net.IPNet, error) {
+	return iface.pickIPAddr(destination, func(addr *net.IPNet) bool {
+		return addr.IP.To4() == nil
+	})
+}
+
+func (iface *Interface) pickIPAddr(destination net.IP, accept func(addr *net.IPNet) bool) (*net.IPNet, error) {
+	var fallback *net.IPNet
+
+	for _, addr := range iface.Addrs {
+		if !accept(addr) {
+			continue
+		}
+
+		if fallback == nil && !addr.IP.IsLinkLocalUnicast() {
+			fallback = addr
+
+			if destination == nil {
+				break
+			}
+		}
+
+		if destination != nil && addr.Contains(destination) {
+			return addr, nil
+		}
+	}
+
+	if fallback == nil {
+		return nil, ErrAddrNotFound
+	}
+
+	return fallback, nil
+}

component/mmdb/mmdb.go

@@ -9,8 +9,10 @@ import (
 	"github.com/oschwald/geoip2-golang"
 )
 
-var mmdb *geoip2.Reader
-var once sync.Once
+var (
+	mmdb *geoip2.Reader
+	once sync.Once
+)
 
 func LoadFromBytes(buffer []byte) {
 	once.Do(func() {