380 changed files with 6046 additions and 25935 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@ -0,0 +1,96 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: "[Bug]"
+labels: ''
+assignees: ''
+
+---
+
+<!-- The English version is available. -->
+感谢你向 Clash Core 提交 issue！
+在提交之前，请确认：
+
+- [ ] 我已经在 [Issue Tracker](……/) 中找过我要提出的问题
+- [ ] 这是 Clash 核心的问题，并非我所使用的 Clash 衍生版本（如 Openclash、Koolclash 等）的特定问题
+- [ ] 我已经使用 Clash core 的 dev 分支版本测试过，问题依旧存在
+- [ ] 如果你可以自己 debug 并解决的话，提交 PR 吧！
+
+请注意，如果你并没有遵照这个 issue template 填写内容，我们将直接关闭这个 issue。
+
+<!--
+Thanks for submitting 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.
+- [ ] Your issue may already be reported! Please search on the [issue tracker](……/) before creating one.
+- [ ] I have tested using the dev branch, and the issue still exists.
+- [ ] This is an issue related to the Clash core, not to the derivatives of Clash, like Openclash or Koolclash
+
+Please understand that we close issues that fail to follow the issue template.
+-->
+
+我都确认过了，我要继续提交。
+<!-- None of the above, create a bug report -->
+------------------------------------------------------------------
+
+请附上任何可以帮助我们解决这个问题的信息，如果我们收到的信息不足，我们将对这个 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
+
+<!--
+请详细、清晰地表达你要提出的论述，例如这个问题如何影响到你？你想实现什么功能？
+-->
+
+### 重现问题的具体布骤 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
--- a/.github/ISSUE_TEMPLATE/bug_report_en.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report_en.yml
@ -1,124 +0,0 @@
-name: (English) Report a bug of the Clash core
-description: Create a bug report to help us improve
-labels:
-  - bug
-title: "[Bug] <issue title>"
-body:
-  - type: markdown
-    attributes:
-      value: "## Welcome to the official Clash open-source community"
-
-  - type: markdown
-    attributes:
-      value: |
-        Thank you for taking the time to report an issue with the Clash core.  
-        
-        Prior to submitting this issue, please read and follow the guidelines below to ensure that your issue can be resolved as quickly as possible. Options marked with an asterisk (*) are required, while others are optional. If the information you provide does not comply with the requirements, the maintainers may not respond and may directly close the issue.  
-        
-        If you can debug and fix the issue yourself, we welcome you to submit a pull request to merge your changes upstream.
-
-  - type: checkboxes
-    id: ensure
-    attributes:
-      label: Prerequisites
-      description: "If any of the following options do not apply, please do not submit this issue as we will close it"
-      options:
-        - label: "I understand that this is the official open-source version of the Clash core, **only providing support for the open-source version or Premium version**"
-          required: true
-        - label: "I am submitting an issue with the Clash core, not Clash.Meta / OpenClash / ClashX / Clash For Windows or any other derivative version"
-          required: true
-        - label: "I am using the latest version of the Clash or Clash Premium core **in this repository**"
-          required: true
-        - label: "I have searched at the [Issue Tracker](……/) **and have not found any related issues**"
-          required: true
-        - label: "I have read the [official Wiki](https://dreamacro.github.io/clash/) **and was unable to solve the issue**"
-          required: true
-        - label: "(required for Premium core) I've tried the `dev` branch and the issue still exists"
-          required: false
-
-  - type: markdown
-    attributes:
-      value: "## Environment"
-  - type: markdown
-    attributes:
-      value: |
-        Please provide the following information to help us locate the issue.  
-        The issue might be closed if there's not enough information provided.
-
-  - type: input
-    attributes:
-      label: Version
-      description: "Run `clash -v` or look at the bottom-left corner of the Clash Dashboard to find out"
-    validations:
-      required: true
-
-  - type: dropdown
-    id: os
-    attributes:
-      label: Operating System
-      description: "Select all operating systems that apply to this issue"
-      multiple: true
-      options:
-        - Linux
-        - Windows
-        - macOS (darwin)
-        - Android
-        - OpenBSD / FreeBSD
-
-  - type: dropdown
-    id: arch
-    attributes:
-      label: Architecture
-      description: "Select all architectures that apply to this issue"
-      multiple: true
-      options:
-        - amd64
-        - amd64-v3
-        - arm64
-        - "386"
-        - armv5
-        - armv6
-        - armv7
-        - mips-softfloat
-        - mips-hardfloat
-        - mipsle-softfloat
-        - mipsle-hardfloat
-        - mips64
-        - mips64le
-        - riscv64
-
-  - type: markdown
-    attributes:
-      value: "## Clash related information"
-  - type: markdown
-    attributes:
-      value: |
-        Please provide relevant information about your Clash instance here. If you
-        do not provide enough information, the issue may be closed.
-
-  - type: textarea
-    attributes:
-      render: YAML
-      label: Configuration File
-      placeholder: "Ensure that there is no sensitive information (such as server addresses, passwords, or ports) in the configuration file, and provide the minimum reproducible configuration. Do not post configurations with thousands of lines."
-    validations:
-      required: true
-
-  - type: textarea
-    attributes:
-      render: Text
-      label: Log
-      placeholder: "Please attach the corresponding core outout (setting `log-level: debug` in the configuration provides debugging information)."
-
-  - type: textarea
-    attributes:
-      label: Description
-      placeholder: "Please describe your issue in detail here to help us understand (supports Markdown syntax)."
-    validations:
-      required: true
-
-  - type: textarea
-    attributes:
-      label: Reproduction Steps
-      placeholder: "Please provide the specific steps to reproduce the issue here (supports Markdown syntax)."
-
--- a/.github/ISSUE_TEMPLATE/bug_report_zh.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report_zh.yml
@ -1,121 +0,0 @@
-name: （中文）提交 Clash 核心的问题
-description: 如果 Clash 核心运作不符合预期，在这里提交问题
-labels:
-  - bug
-title: "[Bug] <问题标题>"
-body:
-  - type: markdown
-    attributes:
-      value: "## 欢迎来到 Clash 官方开源社区！"
-
-  - type: markdown
-    attributes:
-      value: |
-        感谢你拨冗提交 Clash 内核的问题。在提交之前，请仔细阅读并遵守以下指引，以确保你的问题能够被尽快解决。  
-        带有星号（*）的选项为必填，其他可选填。**如果你填写的资料不符合规范，维护者可能不予回复，并直接关闭这个 issue。**
-        如果你可以自行 debug 并且修正，我们随时欢迎你提交 Pull Request，将你的修改合并到上游。
-
-  - type: checkboxes
-    id: ensure
-    attributes:
-      label: 先决条件
-      description: "若以下任意选项不适用，请勿提交这个 issue，因为我们会把它关闭"
-      options:
-        - label: "我了解这里是官方开源版 Clash 核心仓库，**只提供开源版或者 Premium 内核的支持**"
-          required: true
-        - label: "我要提交 Clash 核心的问题，并非 Clash.Meta / OpenClash / ClashX / Clash For Windows 或其他任何衍生版本的问题"
-          required: true
-        - label: "我使用的是**本仓库**最新版本的 Clash 或 Clash Premium 内核"
-          required: true
-        - label: "我已经在 [Issue Tracker](……/) 中找过我要提出的 bug，**并且没有找到相关问题**"
-          required: true
-        - label: "我已经仔细阅读 [官方 Wiki](https://dreamacro.github.io/clash/) 并无法自行解决问题"
-          required: true
-        - label: "（非 Premium 内核必填）我已经使用 dev 分支版本测试过，问题依旧存在"
-          required: false
-
-  - type: markdown
-    attributes:
-      value: "## 系统环境"
-  - type: markdown
-    attributes:
-      value: |
-        请附上这个问题适用的环境，以帮助我们迅速定位问题并解决。若你提供的信息不足，我们将关闭
-        这个 issue 并要求你提供更多信息。
-
-  - type: input
-    attributes:
-      label: 版本
-      description: "运行 `clash -v` 或者查看 Clash Dashboard 的左下角来找到你现在使用的版本"
-    validations:
-      required: true
-
-  - type: dropdown
-    id: os
-    attributes:
-      label: 适用的作业系统
-      description: "勾选所有适用于这个 issue 的系统"
-      multiple: true
-      options:
-        - Linux
-        - Windows
-        - macOS (darwin)
-        - Android
-        - OpenBSD / FreeBSD
-
-  - type: dropdown
-    id: arch
-    attributes:
-      label: 适用的硬件架构
-      description: "勾选所有适用于这个 issue 的架构"
-      multiple: true
-      options:
-        - amd64
-        - amd64-v3
-        - arm64
-        - "386"
-        - armv5
-        - armv6
-        - armv7
-        - mips-softfloat
-        - mips-hardfloat
-        - mipsle-softfloat
-        - mipsle-hardfloat
-        - mips64
-        - mips64le
-        - riscv64
-
-  - type: markdown
-    attributes:
-      value: "## Clash 相关信息"
-  - type: markdown
-    attributes:
-      value: |
-        请附上与这个问题直接相关的相应信息，以帮助我们迅速定位问题并解决。  
-        若你提供的信息不足，我们将关闭这个 issue 并要求你提供更多信息。
-
-  - type: textarea
-    attributes:
-      render: YAML
-      label: "配置文件"
-      placeholder: "确保配置文件中没有敏感信息（如：服务器地址、密码、端口），并且提供最小可复现配置，严禁贴上上千行的配置"
-    validations:
-      required: true
-
-  - type: textarea
-    attributes:
-      render: Text
-      label: 日志输出
-      placeholder: "在这里附上问题对应的内核日志（在配置中设置 `log-level: debug` 可获得调试信息）"
-
-  - type: textarea
-    attributes:
-      label: 问题描述
-      placeholder: "在这里详细叙述你的问题，帮助我们理解（支持 Markdown 语法）"
-    validations:
-      required: true
-
-  - type: textarea
-    attributes:
-      label: 复现步骤
-      placeholder: "在这里提供问题的具体重现步骤（支持 Markdown 语法）"
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@ -1,9 +0,0 @@
-blank_issues_enabled: false
-
-contact_links:
-  - name: （中文）阅读 Wiki
-    url: https://dreamacro.github.io/clash/zh_CN/
-    about: 如果你是新手，或者想要了解 Clash 的更多信息，请阅读我们撰写的官方 Wiki
-  - name: (English) Read our Wiki page
-    url: https://dreamacro.github.io/clash/
-    about: If you are new to Clash, or want to know more about Clash, please read our Wiki page
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@ -0,0 +1,78 @@
+---
+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
--- a/.github/ISSUE_TEMPLATE/feature_request_en.yml
+++ b/.github/ISSUE_TEMPLATE/feature_request_en.yml
@ -1,43 +0,0 @@
-name: (English) Feature request
-description: Suggest an idea for this project
-labels:
-  - enhancement
-title: "[Feature] <title>"
-body:
-  - type: markdown
-    attributes:
-      value: "## Welcome to the official Clash open-source community"
-
-  - type: markdown
-    attributes:
-      value: |
-        Thank you for taking the time to make a suggestion to the Clash core.  
-        
-        Prior to submitting this issue, please read and follow the guidelines below to ensure that your issue can be resolved as quickly as possible. Options marked with an asterisk (*) are required, while others are optional. If the information you provide does not comply with the requirements, the maintainers may not respond and may directly close the issue.  
-        
-        If you can implement your idea by yourself, we welcome you to submit a pull request to merge your changes upstream.
-
-  - type: checkboxes
-    id: ensure
-    attributes:
-      label: Prerequisites
-      description: "If any of the following options do not apply, please do not submit this issue as we will close it"
-      options:
-        - label: "I understand that this is the official open-source version of the Clash core, **only providing support for the open-source version or Premium version**"
-          required: true
-        - label: "I have looked for my idea in [the issue tracker](https://github.com/Dreamacro/clash/issues?q=is%3Aissue+label%3Aenhancement), **and found none of which being related**"
-          required: true
-        - label: "I have read the [official Wiki](https://dreamacro.github.io/clash/)"
-          required: true
-
-  - type: textarea
-    attributes:
-      label: Description
-      placeholder: "Please explain your suggestions in detail and in a clear manner. For instance, how does this issue impact you? What specific functionality are you hoping to achieve? Also, let us know what Clash Core is currently doing in terms of your suggestion, and what you would like it to do instead."
-    validations:
-      required: true
-
-  - type: textarea
-    attributes:
-      label: Possible Solution
-      placeholder: "Do you have any ideas on the implementation details?"
--- a/.github/ISSUE_TEMPLATE/feature_request_zh.yml
+++ b/.github/ISSUE_TEMPLATE/feature_request_zh.yml
@ -1,41 +0,0 @@
-name: （中文）建议一个新功能
-description: 在这里提供一个的想法或建议
-labels:
-  - enhancement
-title: "[Feature] <标题>"
-body:
-  - type: markdown
-    attributes:
-      value: "## 欢迎来到 Clash 官方开源社区！"
-
-  - type: markdown
-    attributes:
-      value: |
-        感谢你拨冗为 Clash 内核提供建议。在提交之前，请仔细阅读并遵守以下指引，以确保你的建议能够被顺利采纳。  
-        带有星号（*）的选项为必填，其他可选填。**如果你填写的资料不符合规范，维护者可能不予回复，并直接关闭这个 issue。**
-        如果你可以自行添加这个功能，我们随时欢迎你提交 Pull Request，并将你的修改合并到上游。
-
-  - type: checkboxes
-    id: ensure
-    attributes:
-      label: 先决条件
-      description: "若以下任意选项不适用，请勿提交这个 issue，因为我们会把它关闭"
-      options:
-        - label: "我了解这里是 Clash 官方仓库，并非 Clash.Meta / OpenClash / ClashX / Clash For Windows 或其他任何衍生版本"
-          required: true
-        - label: "我已经在[这里](https://github.com/Dreamacro/clash/issues?q=is%3Aissue+label%3Aenhancement)找过我要提出的建议，**并且没有找到相关问题**"
-          required: true
-        - label: "我已经仔细阅读 [官方 Wiki](https://dreamacro.github.io/clash/) "
-          required: true
-
-  - type: textarea
-    attributes:
-      label: 描述
-      placeholder: 请详细、清晰地表达你要提出的论述，例如这个问题如何影响到你？你想实现什么功能？目前 Clash Core 的行为是什么？
-    validations:
-      required: true
-
-  - type: textarea
-    attributes:
-      label: 可能的解决方案
-      placeholder: 此项非必须，但是如果你有想法的话欢迎提出。
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@ -1,30 +0,0 @@
-name: CodeQL
-
-on:
-  push:
-    branches: [master, dev]
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: ['go']
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v3
-
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
-      with:
-        languages: ${{ matrix.language }}
-
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v2
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2
--- a/.github/workflows/deploy-docs.yml
+++ b/.github/workflows/deploy-docs.yml
@ -1,42 +0,0 @@
-name: Deploy
-on:
-  workflow_dispatch: {}
-  push:
-    branches:
-      - master
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [20]
-    permissions:
-      pages: write
-      id-token: write
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-      - uses: pnpm/action-setup@v2
-        with:
-          version: latest
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v3
-        with:
-          node-version: ${{ matrix.node-version }}
-      - name: Install dependencies
-        working-directory: docs
-        run: pnpm install --frozen-lockfile=false
-      - name: Build
-        working-directory: docs
-        run: pnpm run docs:build
-      - uses: actions/configure-pages@v2
-      - uses: actions/upload-pages-artifact@v1
-        with:
-          path: docs/.vitepress/dist
-      - name: Deploy
-        id: deployment
-        uses: actions/deploy-pages@v2
--- a/.github/workflows/docker.yml
+++ b/.github/workflows/docker.yml
@ -1,80 +0,0 @@
-name: Publish Docker Image
-on:
-  push:
-    branches:
-      - dev
-    tags:
-      - '*'
-jobs:
-
-  build:
-    name: Build
-    runs-on: ubuntu-latest
-    steps:
-
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
-        with:
-          platforms: all
-
-      - name: Set up docker buildx
-        id: buildx
-        uses: docker/setup-buildx-action@v2
-        with:
-          version: latest
-
-      - name: Login to DockerHub
-        uses: docker/login-action@v2
-        with:
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
-      
-      - name: Login to Github Package
-        uses: docker/login-action@v2
-        with:
-          registry: ghcr.io
-          username: Dreamacro
-          password: ${{ secrets.PACKAGE_TOKEN }}
-
-      - name: Build dev branch and push
-        if: github.ref == 'refs/heads/dev'
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64
-          push: true
-          tags: 'dreamacro/clash:dev,ghcr.io/dreamacro/clash:dev'
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
-
-      - name: Get all docker tags
-        if: startsWith(github.ref, 'refs/tags/')
-        uses: actions/github-script@v6
-        id: tags
-        with:
-          script: |
-            const ref = context.payload.ref.replace(/\/?refs\/tags\//, '')
-            const tags = [
-              'dreamacro/clash:latest',
-              `dreamacro/clash:${ref}`,
-              'ghcr.io/dreamacro/clash:latest',
-              `ghcr.io/dreamacro/clash:${ref}`
-            ]
-            return tags.join(',')
-          result-encoding: string
-
-      - name: Build release and push
-        if: startsWith(github.ref, 'refs/tags/')
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64
-          push: true
-          tags: ${{steps.tags.outputs.result}}
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@ -1,29 +1,28 @@
-name: Release
-on: [push]
+name: Go
+on: [push, pull_request]
 jobs:
+
  build:
+    name: Build
    runs-on: ubuntu-latest
    steps:
      - name: Setup Go
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@v1
        with:
-          check-latest: true
-          go-version: '1.20'
+          go-version: 1.13.x

      - name: Check out code into the Go module directory
-        uses: actions/checkout@v3
-
+        uses: actions/checkout@v1
+      
      - name: Cache go module
-        uses: actions/cache@v3
+        uses: actions/cache@v1
        with:
-          path: |
-            ~/go/pkg/mod
-            ~/.cache/go-build
+          path: ~/go/pkg/mod
          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
          restore-keys: |
            ${{ runner.os }}-go-

-      - name: Get dependencies, run test
+      - name: Get dependencies and run test
        run: |
          go test ./...

@ -32,11 +31,14 @@ jobs:
        env:
          NAME: clash
          BINDIR: bin
-        run: make -j $(go run ./test/main.go) releases
+        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
--- a/.github/workflows/linter.yml
+++ b/.github/workflows/linter.yml
@ -1,18 +0,0 @@
-name: Linter
-on: [push, pull_request]
-jobs:
-  lint:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Setup Go
-        uses: actions/setup-go@v4
-        with:
-          check-latest: true
-          go-version: '1.20'
-
-      - name: golangci-lint
-        uses: golangci/golangci-lint-action@v3
-        with:
-          version: latest
--- a/.github/workflows/stale.yml
+++ b/.github/workflows/stale.yml
@ -1,18 +0,0 @@
-  
-name: Mark stale issues and pull requests
-
-on:
-  schedule:
-    - cron: "30 1 * * *"
-
-jobs:
-  stale:
-
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/stale@v7
-        with:
-          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
--- a/.gitignore
+++ b/.gitignore
@ -12,7 +12,7 @@ bin/*
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out

-# go mod vendor
+# dep
 vendor

 # GoLand
@ -20,17 +20,3 @@ vendor

 # macOS file
 .DS_Store
-
-# test suite
-test/config/cache*
-
-# docs site generator
-node_modules
-package-lock.json
-pnpm-lock.yaml
-
-# docs site cache
-docs/.vitepress/cache
-
-# docs site build files
-docs/.vitepress/dist
--- a/.golangci.yaml
+++ b/.golangci.yaml
@ -1,23 +0,0 @@
-linters:
-  disable-all: true
-  enable:
-    - gci
-    - gofumpt
-    - gosimple
-    - govet
-    - ineffassign
-    - misspell
-    - staticcheck
-    - unconvert
-    - unused
-    - usestdlibvars
-
-linters-settings:
-  gci:
-    custom-order: true
-    sections:
-      - standard
-      - prefix(github.com/Dreamacro/clash)
-      - default
-  staticcheck:
-    go: '1.20'
--- a/22
+++ b/22
@ -1,22 +1,16 @@
-FROM --platform=${BUILDPLATFORM} golang:alpine as builder
+FROM golang:alpine as builder

-RUN apk add --no-cache make git ca-certificates tzdata && \
+RUN apk add --no-cache make git && \
    wget -O /Country.mmdb https://github.com/Dreamacro/maxmind-geoip/releases/latest/download/Country.mmdb
-WORKDIR /workdir
-COPY --from=tonistiigi/xx:golang / /
-ARG TARGETOS TARGETARCH TARGETVARIANT
-
-RUN --mount=target=. \
-    --mount=type=cache,target=/root/.cache/go-build \
-    --mount=type=cache,target=/go/pkg/mod \
-    make BINDIR= ${TARGETOS}-${TARGETARCH}${TARGETVARIANT} && \
-    mv /clash* /clash
+WORKDIR /clash-src
+COPY . /clash-src
+RUN go mod download && \
+    make linux-amd64 && \
+    mv ./bin/clash-linux-amd64 /clash

 FROM alpine:latest
-LABEL org.opencontainers.image.source="https://github.com/Dreamacro/clash"

-COPY --from=builder /usr/share/zoneinfo /usr/share/zoneinfo
-COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
+RUN apk add --no-cache ca-certificates
 COPY --from=builder /Country.mmdb /root/.config/clash/
 COPY --from=builder /clash /
 ENTRYPOINT ["/clash"]
--- a/Dockerfile.arm32v7
+++ b/Dockerfile.arm32v7
@ -0,0 +1,20 @@
+FROM golang:alpine as builder
+
+RUN apk add --no-cache make git && \
+    wget -O /Country.mmdb https://github.com/Dreamacro/maxmind-geoip/releases/latest/download/Country.mmdb && \
+    wget -O /qemu-arm-static https://github.com/multiarch/qemu-user-static/releases/latest/download/qemu-arm-static && \
+    chmod +x /qemu-arm-static
+
+WORKDIR /clash-src
+COPY . /clash-src
+RUN go mod download && \
+    make linux-armv7 && \
+    mv ./bin/clash-linux-armv7 /clash
+
+FROM arm32v7/alpine:latest
+
+COPY --from=builder /qemu-arm-static /usr/bin/
+COPY --from=builder /Country.mmdb /root/.config/clash/
+COPY --from=builder /clash /
+RUN apk add --no-cache ca-certificates
+ENTRYPOINT ["/clash"]
--- a/Dockerfile.arm64v8
+++ b/Dockerfile.arm64v8
@ -0,0 +1,20 @@
+FROM golang:alpine as builder
+
+RUN apk add --no-cache make git && \
+    wget -O /Country.mmdb https://github.com/Dreamacro/maxmind-geoip/releases/latest/download/Country.mmdb && \
+    wget -O /qemu-aarch64-static https://github.com/multiarch/qemu-user-static/releases/latest/download/qemu-aarch64-static && \
+    chmod +x /qemu-aarch64-static
+
+WORKDIR /clash-src
+COPY . /clash-src
+RUN go mod download && \
+    make linux-armv8 && \
+    mv ./bin/clash-linux-armv8 /clash
+
+FROM arm64v8/alpine:latest
+
+COPY --from=builder /qemu-aarch64-static /usr/bin/
+COPY --from=builder /Country.mmdb /root/.config/clash/
+COPY --from=builder /clash /
+RUN apk add --no-cache ca-certificates
+ENTRYPOINT ["/clash"]
--- a/63
+++ b/63
@ -2,61 +2,42 @@ NAME=clash
 BINDIR=bin
 VERSION=$(shell git describe --tags || echo "unknown version")
 BUILDTIME=$(shell date -u)
-GOBUILD=CGO_ENABLED=0 go build -trimpath -ldflags '-X "github.com/Dreamacro/clash/constant.Version=$(VERSION)" \
+GOBUILD=CGO_ENABLED=0 go build -ldflags '-X "github.com/Dreamacro/clash/constant.Version=$(VERSION)" \
 		-X "github.com/Dreamacro/clash/constant.BuildTime=$(BUILDTIME)" \
-		-w -s -buildid='
+		-w -s'

 PLATFORM_LIST = \
 	darwin-amd64 \
-	darwin-amd64-v3 \
-	darwin-arm64 \
 	linux-386 \
 	linux-amd64 \
-	linux-amd64-v3 \
 	linux-armv5 \
 	linux-armv6 \
 	linux-armv7 \
-	linux-arm64 \
+	linux-armv8 \
 	linux-mips-softfloat \
 	linux-mips-hardfloat \
 	linux-mipsle-softfloat \
 	linux-mipsle-hardfloat \
 	linux-mips64 \
 	linux-mips64le \
-	linux-riscv64 \
-	linux-loong64 \
 	freebsd-386 \
-	freebsd-amd64 \
-	freebsd-amd64-v3 \
-	freebsd-arm64
+	freebsd-amd64

 WINDOWS_ARCH_LIST = \
 	windows-386 \
-	windows-amd64 \
-	windows-amd64-v3 \
-	windows-arm64 \
-	windows-armv7
+	windows-amd64

 all: linux-amd64 darwin-amd64 windows-amd64 # Most used

 darwin-amd64:
 	GOARCH=amd64 GOOS=darwin $(GOBUILD) -o $(BINDIR)/$(NAME)-$@

-darwin-amd64-v3:
-	GOARCH=amd64 GOOS=darwin GOAMD64=v3 $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
-
-darwin-arm64:
-	GOARCH=arm64 GOOS=darwin $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
-
 linux-386:
 	GOARCH=386 GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@

 linux-amd64:
 	GOARCH=amd64 GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@

-linux-amd64-v3:
-	GOARCH=amd64 GOOS=linux GOAMD64=v3 $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
-
 linux-armv5:
 	GOARCH=arm GOOS=linux GOARM=5 $(GOBUILD) -o $(BINDIR)/$(NAME)-$@

@ -66,7 +47,7 @@ linux-armv6:
 linux-armv7:
 	GOARCH=arm GOOS=linux GOARM=7 $(GOBUILD) -o $(BINDIR)/$(NAME)-$@

-linux-arm64:
+linux-armv8:
 	GOARCH=arm64 GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@

 linux-mips-softfloat:
@ -87,39 +68,18 @@ linux-mips64:
 linux-mips64le:
 	GOARCH=mips64le GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@

-linux-riscv64:
-	GOARCH=riscv64 GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@	
-
-linux-loong64:
-	GOARCH=loong64 GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@	
-
 freebsd-386:
 	GOARCH=386 GOOS=freebsd $(GOBUILD) -o $(BINDIR)/$(NAME)-$@

 freebsd-amd64:
 	GOARCH=amd64 GOOS=freebsd $(GOBUILD) -o $(BINDIR)/$(NAME)-$@

-freebsd-amd64-v3:
-	GOARCH=amd64 GOOS=freebsd GOAMD64=v3 $(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-amd64-v3:
-	GOARCH=amd64 GOOS=windows GOAMD64=v3 $(GOBUILD) -o $(BINDIR)/$(NAME)-$@.exe
-
-windows-arm64:
-	GOARCH=arm64 GOOS=windows $(GOBUILD) -o $(BINDIR)/$(NAME)-$@.exe
-
-windows-armv7:
-	GOARCH=arm GOOS=windows GOARM=7 $(GOBUILD) -o $(BINDIR)/$(NAME)-$@.exe
-
 gz_releases=$(addsuffix .gz, $(PLATFORM_LIST))
 zip_releases=$(addsuffix .zip, $(WINDOWS_ARCH_LIST))

@ -133,16 +93,5 @@ $(zip_releases): %.zip : %
 all-arch: $(PLATFORM_LIST) $(WINDOWS_ARCH_LIST)

 releases: $(gz_releases) $(zip_releases)
-
-LINT_OS_LIST := darwin windows linux freebsd openbsd
-
-lint: $(foreach os,$(LINT_OS_LIST),$(os)-lint)
-%-lint:
-	GOOS=$* golangci-lint run ./...
-
-lint-fix: $(foreach os,$(LINT_OS_LIST),$(os)-lint-fix)
-%-lint-fix:
-	GOOS=$* golangci-lint run --fix ./...
-
 clean:
 	rm $(BINDIR)/*
--- a/README.md
+++ b/README.md
@ -7,47 +7,321 @@

 <p align="center">
  <a href="https://github.com/Dreamacro/clash/actions">
-    <img src="https://img.shields.io/github/actions/workflow/status/Dreamacro/clash/release.yml?branch=master&style=flat-square" alt="Github Actions">
+    <img src="https://img.shields.io/github/workflow/status/Dreamacro/clash/Go?style=flat-square" alt="Github Actions">
  </a>
  <a href="https://goreportcard.com/report/github.com/Dreamacro/clash">
    <img src="https://goreportcard.com/badge/github.com/Dreamacro/clash?style=flat-square">
  </a>
-  <img src="https://img.shields.io/github/go-mod/go-version/Dreamacro/clash?style=flat-square">
  <a href="https://github.com/Dreamacro/clash/releases">
    <img src="https://img.shields.io/github/release/Dreamacro/clash/all.svg?style=flat-square">
  </a>
-  <a href="https://github.com/Dreamacro/clash/releases/tag/premium">
-    <img src="https://img.shields.io/badge/release-Premium-00b4f0?style=flat-square">
-  </a>
 </p>

 ## Features

-This is a general overview of the features that comes with Clash.  
+- Local HTTP/HTTPS/SOCKS server
+- GeoIP rule support
+- Supports Vmess, Shadowsocks, Snell and SOCKS5 protocol
+- Supports Netfilter TCP redirecting
+- Comprehensive HTTP API

- Inbound: HTTP, HTTPS, SOCKS5 server, TUN device
- Outbound: Shadowsocks(R), VMess, Trojan, Snell, SOCKS5, HTTP(S), Wireguard
- Rule-based Routing: dynamic scripting, domain, IP addresses, process name and more
- Fake-IP DNS: minimises impact on DNS pollution and improves network performance
- Transparent Proxy: Redirect TCP and TProxy TCP/UDP with automatic route table/rule management
- Proxy Groups: automatic fallback, load balancing or latency testing
- Remote Providers: load remote proxy lists dynamically
- RESTful API: update configuration in-place via a comprehensive API
+## Install

-*Some of the features may only be available in the [Premium core](https://dreamacro.github.io/clash/premium/introduction.html).*
+Clash Requires Go >= 1.13. You can build it from source:

-## Documentation
+```sh
+$ go get -u -v github.com/Dreamacro/clash
+```

-You can find the latest documentation at [https://dreamacro.github.io/clash/](https://dreamacro.github.io/clash/).
+Pre-built binaries are available here: [release](https://github.com/Dreamacro/clash/releases)

-## Credits
+Pre-built TUN mode binaries are available here: [TUN release](https://github.com/Dreamacro/clash/releases/tag/TUN)

- [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)
+Check Clash version with:
+
+```sh
+$ clash -v
+```
+
+## Daemon
+
+Unfortunately, there is no native and elegant way to implement daemons on Golang.
+
+So we can use third-party daemon tools like PM2, Supervisor or the like.
+
+In the case of [pm2](https://github.com/Unitech/pm2), we can start the daemon this way:
+
+```sh
+$ pm2 start clash
+```
+
+If you have Docker installed, you can run clash directly using `docker-compose`.
+
+[Run clash in docker](https://github.com/Dreamacro/clash/wiki/Run-clash-in-docker)
+
+## Config
+
+The default configuration directory is `$HOME/.config/clash`.
+
+The name of the configuration file is `config.yaml`.
+
+If you want to use another directory, use `-d` to control the configuration directory.
+
+For example, you can use the current directory as the configuration directory:
+
+```sh
+$ clash -d .
+```
+
+<details>
+  <summary>This is an example configuration file (click to expand)</summary>
+
+```yml
+# port of HTTP
+port: 7890
+
+# port of SOCKS5
+socks-port: 7891
+
+# redir port for Linux and macOS
+# redir-port: 7892
+
+allow-lan: false
+
+# Only applicable when setting allow-lan to true
+# "*": bind all IP addresses
+# 192.168.122.11: bind a single IPv4 address
+# "[aaaa::a8aa:ff:fe09:57d8]": bind a single IPv6 address
+# bind-address: "*"
+
+# Rule / Global/ Direct (default is Rule)
+mode: Rule
+
+# set log level to stdout (default is info)
+# info / warning / error / debug / silent
+log-level: info
+
+# RESTful API for clash
+external-controller: 127.0.0.1:9090
+
+# you can put the static web resource (such as clash-dashboard) to a directory, and clash would serve in `${API}/ui`
+# input is a relative path to the configuration directory or an absolute path
+# external-ui: folder
+
+# Secret for RESTful API (Optional)
+# secret: ""
+
+# experimental feature
+experimental:
+  ignore-resolve-fail: true # ignore dns resolve fail, default value is true
+  # interface-name: en0 # outbound interface name
+
+# authentication of local SOCKS5/HTTP(S) server
+# authentication:
+#  - "user1:pass1"
+#  - "user2:pass2"
+
+# # experimental hosts, support wildcard (e.g. *.clash.dev Even *.foo.*.example.com)
+# # static domain has a higher priority than wildcard domain (foo.example.com > *.example.com)
+# hosts:
+#   '*.clash.dev': 127.0.0.1
+#   'alpha.clash.dev': '::1'
+
+# dns:
+  # enable: true # set true to enable dns (default is false)
+  # ipv6: false # default is false
+  # listen: 0.0.0.0:53
+  # # default-nameserver: # resolve dns nameserver host, should fill pure IP
+  # #   - 114.114.114.114
+  # #   - 8.8.8.8
+  # enhanced-mode: redir-host # or fake-ip
+  # # fake-ip-range: 198.18.0.1/16 # if you don't know what it is, don't change it
+  # fake-ip-filter: # fake ip white domain list
+  #   - '*.lan'
+  #   - localhost.ptlogin2.qq.com
+  # nameserver:
+  #   - 114.114.114.114
+  #   - tls://dns.rubyfish.cn:853 # dns over tls
+  #   - https://1.1.1.1/dns-query # dns over https
+  # fallback: # concurrent request with nameserver, fallback used when GEOIP country isn't CN
+  #   - tcp://1.1.1.1
+  # fallback-filter:
+  #   geoip: true # default
+  #   ipcidr: # ips in these subnets will be considered polluted
+  #     - 240.0.0.0/4
+
+Proxy:
+  # shadowsocks
+  # The supported ciphers(encrypt methods):
+  #   aes-128-gcm aes-192-gcm aes-256-gcm
+  #   aes-128-cfb aes-192-cfb aes-256-cfb
+  #   aes-128-ctr aes-192-ctr aes-256-ctr
+  #   rc4-md5 chacha20-ietf xchacha20
+  #   chacha20-ietf-poly1305 xchacha20-ietf-poly1305
+  - name: "ss1"
+    type: ss
+    server: server
+    port: 443
+    cipher: chacha20-ietf-poly1305
+    password: "password"
+    # udp: true
+
+  # old obfs configuration format remove after prerelease
+  - name: "ss2"
+    type: ss
+    server: server
+    port: 443
+    cipher: chacha20-ietf-poly1305
+    password: "password"
+    plugin: obfs
+    plugin-opts:
+      mode: tls # or http
+      # host: bing.com
+
+  - name: "ss3"
+    type: ss
+    server: server
+    port: 443
+    cipher: chacha20-ietf-poly1305
+    password: "password"
+    plugin: v2ray-plugin
+    plugin-opts:
+      mode: websocket # no QUIC now
+      # tls: true # wss
+      # skip-cert-verify: true
+      # host: bing.com
+      # path: "/"
+      # mux: true
+      # headers:
+      #   custom: value
+
+  # vmess
+  # cipher support auto/aes-128-gcm/chacha20-poly1305/none
+  - name: "vmess"
+    type: vmess
+    server: server
+    port: 443
+    uuid: uuid
+    alterId: 32
+    cipher: auto
+    # udp: true
+    # tls: true
+    # skip-cert-verify: true
+    # network: ws
+    # ws-path: /path
+    # ws-headers:
+    #   Host: v2ray.com
+
+  # socks5
+  - name: "socks"
+    type: socks5
+    server: server
+    port: 443
+    # username: username
+    # password: password
+    # tls: true
+    # skip-cert-verify: true
+    # udp: true
+
+  # http
+  - name: "http"
+    type: http
+    server: server
+    port: 443
+    # username: username
+    # password: password
+    # tls: true # https
+    # skip-cert-verify: true
+
+  # snell
+  - name: "snell"
+    type: snell
+    server: server
+    port: 44046
+    psk: yourpsk
+    # obfs-opts:
+      # mode: http # or tls
+      # host: bing.com
+
+Proxy Group:
+  # url-test select which proxy will be used by benchmarking speed to a URL.
+  - name: "auto"
+    type: url-test
+    proxies:
+      - ss1
+      - ss2
+      - vmess1
+    url: 'http://www.gstatic.com/generate_204'
+    interval: 300
+
+  # fallback select an available policy by priority. The availability is tested by accessing an URL, just like an auto url-test group.
+  - name: "fallback-auto"
+    type: fallback
+    proxies:
+      - ss1
+      - ss2
+      - vmess1
+    url: 'http://www.gstatic.com/generate_204'
+    interval: 300
+
+  # load-balance: The request of the same eTLD will be dial on the same proxy.
+  - name: "load-balance"
+    type: load-balance
+    proxies:
+      - ss1
+      - ss2
+      - vmess1
+    url: 'http://www.gstatic.com/generate_204'
+    interval: 300
+
+  # select is used for selecting proxy or proxy group
+  # you can use RESTful API to switch proxy, is recommended for use in GUI.
+  - name: Proxy
+    type: select
+    proxies:
+      - ss1
+      - ss2
+      - vmess1
+      - auto
+
+Rule:
+  - DOMAIN-SUFFIX,google.com,auto
+  - DOMAIN-KEYWORD,google,auto
+  - DOMAIN,google.com,auto
+  - DOMAIN-SUFFIX,ad.com,REJECT
+  # rename SOURCE-IP-CIDR and would remove after prerelease
+  - SRC-IP-CIDR,192.168.1.201/32,DIRECT
+  # optional param "no-resolve" for IP rules (GEOIP IP-CIDR)
+  - IP-CIDR,127.0.0.0/8,DIRECT
+  - GEOIP,CN,DIRECT
+  - DST-PORT,80,DIRECT
+  - SRC-PORT,7777,DIRECT
+  # FINAL would remove after prerelease
+  # you also can use `FINAL,Proxy` or `FINAL,,Proxy` now
+  - MATCH,auto
+```
+</details>
+
+## Advanced
+[Provider](https://github.com/Dreamacro/clash/wiki/Provider)
+
+## Documentations
+https://clash.gitbook.io/
+
+## Thanks
+
+[riobard/go-shadowsocks2](https://github.com/riobard/go-shadowsocks2)
+
+[v2ray/v2ray-core](https://github.com/v2ray/v2ray-core)

 ## 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
--- a/adapter/adapter.go
+++ b/adapter/adapter.go
@ -1,203 +0,0 @@
-package adapter
-
-import (
-	"context"
-	"encoding/json"
-	"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 Proxy struct {
-	C.ProxyAdapter
-	history *queue.Queue
-	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(), C.DefaultTCPTimeout)
-	defer cancel()
-	return p.DialContext(ctx, metadata)
-}
-
-// 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{}
-	for _, item := range queue {
-		histories = append(histories, item.(C.DelayHistory))
-	}
-	return histories
-}
-
-// 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() {
-		return max
-	}
-
-	last := p.history.Last()
-	if last == nil {
-		return max
-	}
-	history := last.(C.DelayHistory)
-	if history.Delay == 0 {
-		return max
-	}
-	return history.Delay
-}
-
-// MarshalJSON implements C.ProxyAdapter
-func (p *Proxy) MarshalJSON() ([]byte, error) {
-	inner, err := p.ProxyAdapter.MarshalJSON()
-	if err != nil {
-		return inner, err
-	}
-
-	mapping := map[string]any{}
-	json.Unmarshal(inner, &mapping)
-	mapping["history"] = p.DelayHistory()
-	mapping["alive"] = p.Alive()
-	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) (delay, meanDelay uint16, err error) {
-	defer func() {
-		p.alive.Store(err == nil)
-		record := C.DelayHistory{Time: time.Now()}
-		if err == nil {
-			record.Delay = delay
-			record.MeanDelay = meanDelay
-		}
-		p.history.Put(record)
-		if p.history.Len() > 10 {
-			p.history.Pop()
-		}
-	}()
-
-	addr, err := urlToMetadata(url)
-	if err != nil {
-		return
-	}
-
-	start := time.Now()
-	instance, err := p.DialContext(ctx, &addr)
-	if err != nil {
-		return
-	}
-	defer instance.Close()
-
-	req, err := http.NewRequest(http.MethodHead, url, nil)
-	if err != nil {
-		return
-	}
-	req = req.WithContext(ctx)
-
-	transport := &http.Transport{
-		Dial: func(string, string) (net.Conn, error) {
-			return instance, nil
-		},
-		// from http.DefaultTransport
-		MaxIdleConns:          100,
-		IdleConnTimeout:       90 * time.Second,
-		TLSHandshakeTimeout:   10 * time.Second,
-		ExpectContinueTimeout: 1 * time.Second,
-	}
-
-	client := http.Client{
-		Transport: transport,
-		CheckRedirect: func(req *http.Request, via []*http.Request) error {
-			return http.ErrUseLastResponse
-		},
-	}
-	defer client.CloseIdleConnections()
-
-	resp, err := client.Do(req)
-	if err != nil {
-		return
-	}
-	resp.Body.Close()
-	delay = uint16(time.Since(start) / time.Millisecond)
-
-	resp, err = client.Do(req)
-	if err != nil {
-		// ignore error because some server will hijack the connection and close immediately
-		return delay, 0, nil
-	}
-	resp.Body.Close()
-	meanDelay = uint16(time.Since(start) / time.Millisecond / 2)
-
-	return
-}
-
-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{
-		Host:    u.Hostname(),
-		DstIP:   nil,
-		DstPort: port,
-	}
-	return
-}
--- a/adapter/inbound/http.go
+++ b/adapter/inbound/http.go
@ -1,27 +0,0 @@
-package inbound
-
-import (
-	"net"
-	"net/netip"
-
-	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, originTarget 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
-	}
-	if originTarget != nil {
-		if addrPort, err := netip.ParseAddrPort(originTarget.String()); err == nil {
-			metadata.OriginDst = addrPort
-		}
-	}
-	return context.NewConnContext(conn, metadata)
-}
--- a/adapter/inbound/https.go
+++ b/adapter/inbound/https.go
@ -1,24 +0,0 @@
-package inbound
-
-import (
-	"net"
-	"net/http"
-	"net/netip"
-
-	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/context"
-)
-
-// NewHTTPS receive CONNECT request and return ConnContext
-func NewHTTPS(request *http.Request, conn net.Conn) *context.ConnContext {
-	metadata := parseHTTPAddr(request)
-	metadata.Type = C.HTTPCONNECT
-	if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
-		metadata.SrcIP = ip
-		metadata.SrcPort = port
-	}
-	if addrPort, err := netip.ParseAddrPort(conn.LocalAddr().String()); err == nil {
-		metadata.OriginDst = addrPort
-	}
-	return context.NewConnContext(conn, metadata)
-}
--- a/adapter/inbound/socket.go
+++ b/adapter/inbound/socket.go
@ -1,25 +0,0 @@
-package inbound
-
-import (
-	"net"
-	"net/netip"
-
-	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/context"
-	"github.com/Dreamacro/clash/transport/socks5"
-)
-
-// 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
-	metadata.Type = source
-	if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
-		metadata.SrcIP = ip
-		metadata.SrcPort = port
-	}
-	if addrPort, err := netip.ParseAddrPort(conn.LocalAddr().String()); err == nil {
-		metadata.OriginDst = addrPort
-	}
-	return context.NewConnContext(conn, metadata)
-}
--- a/adapter/outbound/base.go
+++ b/adapter/outbound/base.go
@ -1,138 +0,0 @@
-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()}}
-}
--- a/adapter/outbound/direct.go
+++ b/adapter/outbound/direct.go
@ -1,46 +0,0 @@
-package outbound
-
-import (
-	"context"
-	"net"
-
-	"github.com/Dreamacro/clash/component/dialer"
-	C "github.com/Dreamacro/clash/constant"
-)
-
-type Direct struct {
-	*Base
-}
-
-// 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
-	}
-	tcpKeepAlive(c)
-	return NewConn(c, d), nil
-}
-
-// 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
-	}
-	return newPacketConn(&directPacketConn{pc}, d), nil
-}
-
-type directPacketConn struct {
-	net.PacketConn
-}
-
-func NewDirect() *Direct {
-	return &Direct{
-		Base: &Base{
-			name: "DIRECT",
-			tp:   C.Direct,
-			udp:  true,
-		},
-	}
-}
--- a/adapter/outbound/reject.go
+++ b/adapter/outbound/reject.go
@ -1,62 +0,0 @@
-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 }
--- a/adapter/outbound/shadowsocksr.go
+++ b/adapter/outbound/shadowsocksr.go
@ -1,159 +0,0 @@
-package outbound
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"strconv"
-
-	"github.com/Dreamacro/clash/component/dialer"
-	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/transport/shadowsocks/core"
-	"github.com/Dreamacro/clash/transport/shadowsocks/shadowaead"
-	"github.com/Dreamacro/clash/transport/shadowsocks/shadowstream"
-	"github.com/Dreamacro/clash/transport/ssr/obfs"
-	"github.com/Dreamacro/clash/transport/ssr/protocol"
-)
-
-type ShadowSocksR struct {
-	*Base
-	cipher   core.Cipher
-	obfs     obfs.Obfs
-	protocol protocol.Protocol
-}
-
-type ShadowSocksROption struct {
-	BasicOption
-	Name          string `proxy:"name"`
-	Server        string `proxy:"server"`
-	Port          int    `proxy:"port"`
-	Password      string `proxy:"password"`
-	Cipher        string `proxy:"cipher"`
-	Obfs          string `proxy:"obfs"`
-	ObfsParam     string `proxy:"obfs-param,omitempty"`
-	Protocol      string `proxy:"protocol"`
-	ProtocolParam string `proxy:"protocol-param,omitempty"`
-	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)
-	var (
-		iv  []byte
-		err error
-	)
-	switch conn := c.(type) {
-	case *shadowstream.Conn:
-		iv, err = conn.ObtainWriteIV()
-		if err != nil {
-			return nil, err
-		}
-	case *shadowaead.Conn:
-		return nil, fmt.Errorf("invalid connection type")
-	}
-	c = ssr.protocol.StreamConn(c, iv)
-	_, err = c.Write(serializesSocksAddr(metadata))
-	return c, err
-}
-
-// 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 func(c net.Conn) {
-		safeConnClose(c, err)
-	}(c)
-
-	c, err = ssr.StreamConn(c, metadata)
-	return NewConn(c, ssr), err
-}
-
-// 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
-	}
-
-	pc = ssr.cipher.PacketConn(pc)
-	pc = ssr.protocol.PacketConn(pc)
-	return newPacketConn(&ssPacketConn{PacketConn: pc, rAddr: addr}, ssr), nil
-}
-
-func NewShadowSocksR(option ShadowSocksROption) (*ShadowSocksR, error) {
-	// SSR protocol compatibility
-	// https://github.com/Dreamacro/clash/pull/2056
-	if option.Cipher == "none" {
-		option.Cipher = "dummy"
-	}
-
-	addr := net.JoinHostPort(option.Server, strconv.Itoa(option.Port))
-	cipher := option.Cipher
-	password := option.Password
-	coreCiph, err := core.PickCipher(cipher, nil, password)
-	if err != nil {
-		return nil, fmt.Errorf("ssr %s initialize error: %w", addr, err)
-	}
-	var (
-		ivSize int
-		key    []byte
-	)
-
-	if option.Cipher == "dummy" {
-		ivSize = 0
-		key = core.Kdf(option.Password, 16)
-	} else {
-		ciph, ok := coreCiph.(*core.StreamCipher)
-		if !ok {
-			return nil, fmt.Errorf("%s is not none or a supported stream cipher in ssr", cipher)
-		}
-		ivSize = ciph.IVSize()
-		key = ciph.Key
-	}
-
-	obfs, obfsOverhead, err := obfs.PickObfs(option.Obfs, &obfs.Base{
-		Host:   option.Server,
-		Port:   option.Port,
-		Key:    key,
-		IVSize: ivSize,
-		Param:  option.ObfsParam,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("ssr %s initialize obfs error: %w", addr, err)
-	}
-
-	protocol, err := protocol.PickProtocol(option.Protocol, &protocol.Base{
-		Key:      key,
-		Overhead: obfsOverhead,
-		Param:    option.ProtocolParam,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("ssr %s initialize protocol error: %w", addr, err)
-	}
-
-	return &ShadowSocksR{
-		Base: &Base{
-			name:  option.Name,
-			addr:  addr,
-			tp:    C.ShadowsocksR,
-			udp:   option.UDP,
-			iface: option.Interface,
-			rmark: option.RoutingMark,
-		},
-		cipher:   coreCiph,
-		obfs:     obfs,
-		protocol: protocol,
-	}, nil
-}
--- a/adapter/outbound/snell.go
+++ b/adapter/outbound/snell.go
@ -1,166 +0,0 @@
-package outbound
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"strconv"
-
-	"github.com/Dreamacro/clash/common/structure"
-	"github.com/Dreamacro/clash/component/dialer"
-	C "github.com/Dreamacro/clash/constant"
-	obfs "github.com/Dreamacro/clash/transport/simple-obfs"
-	"github.com/Dreamacro/clash/transport/snell"
-)
-
-type Snell struct {
-	*Base
-	psk        []byte
-	pool       *snell.Pool
-	obfsOption *simpleObfsOption
-	version    int
-}
-
-type SnellOption struct {
-	BasicOption
-	Name     string         `proxy:"name"`
-	Server   string         `proxy:"server"`
-	Port     int            `proxy:"port"`
-	Psk      string         `proxy:"psk"`
-	UDP      bool           `proxy:"udp,omitempty"`
-	Version  int            `proxy:"version,omitempty"`
-	ObfsOpts map[string]any `proxy:"obfs-opts,omitempty"`
-}
-
-type streamOption struct {
-	psk        []byte
-	version    int
-	addr       string
-	obfsOption *simpleObfsOption
-}
-
-func streamConn(c net.Conn, option streamOption) *snell.Snell {
-	switch option.obfsOption.Mode {
-	case "tls":
-		c = obfs.NewTLSObfs(c, option.obfsOption.Host)
-	case "http":
-		_, port, _ := net.SplitHostPort(option.addr)
-		c = obfs.NewHTTPObfs(c, option.obfsOption.Host, port)
-	}
-	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.ParseUint(metadata.DstPort, 10, 16)
-	err := snell.WriteHeader(c, metadata.String(), uint(port), s.version)
-	return c, err
-}
-
-// 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.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, s.Base.DialOptions(opts...)...)
-	if err != nil {
-		return nil, fmt.Errorf("%s connect error: %w", s.addr, err)
-	}
-	tcpKeepAlive(c)
-
-	defer func(c net.Conn) {
-		safeConnClose(c, err)
-	}(c)
-
-	c, err = s.StreamConn(c, metadata)
-	return NewConn(c, s), err
-}
-
-// ListenPacketContext implements C.ProxyAdapter
-func (s *Snell) ListenPacketContext(ctx context.Context, metadata *C.Metadata, opts ...dialer.Option) (C.PacketConn, error) {
-	c, err := dialer.DialContext(ctx, "tcp", s.addr, s.Base.DialOptions(opts...)...)
-	if err != nil {
-		return nil, err
-	}
-	tcpKeepAlive(c)
-	c = streamConn(c, streamOption{s.psk, s.version, s.addr, s.obfsOption})
-
-	err = snell.WriteUDPHeader(c, s.version)
-	if err != nil {
-		return nil, err
-	}
-
-	pc := snell.PacketConn(c)
-	return newPacketConn(pc, s), nil
-}
-
-func NewSnell(option SnellOption) (*Snell, error) {
-	addr := net.JoinHostPort(option.Server, strconv.Itoa(option.Port))
-	psk := []byte(option.Psk)
-
-	decoder := structure.NewDecoder(structure.Option{TagName: "obfs", WeaklyTypedInput: true})
-	obfsOption := &simpleObfsOption{Host: "bing.com"}
-	if err := decoder.Decode(option.ObfsOpts, obfsOption); err != nil {
-		return nil, fmt.Errorf("snell %s initialize obfs error: %w", addr, err)
-	}
-
-	switch obfsOption.Mode {
-	case "tls", "http", "":
-		break
-	default:
-		return nil, fmt.Errorf("snell %s obfs mode error: %s", addr, obfsOption.Mode)
-	}
-
-	// backward compatible
-	if option.Version == 0 {
-		option.Version = snell.DefaultSnellVersion
-	}
-	switch option.Version {
-	case snell.Version1, snell.Version2:
-		if option.UDP {
-			return nil, fmt.Errorf("snell version %d not support UDP", option.Version)
-		}
-	case snell.Version3:
-	default:
-		return nil, fmt.Errorf("snell version error: %d", option.Version)
-	}
-
-	s := &Snell{
-		Base: &Base{
-			name:  option.Name,
-			addr:  addr,
-			tp:    C.Snell,
-			udp:   option.UDP,
-			iface: option.Interface,
-			rmark: option.RoutingMark,
-		},
-		psk:        psk,
-		obfsOption: obfsOption,
-		version:    option.Version,
-	}
-
-	if option.Version == snell.Version2 {
-		s.pool = snell.NewPool(func(ctx context.Context) (*snell.Snell, error) {
-			c, err := dialer.DialContext(ctx, "tcp", addr, s.Base.DialOptions()...)
-			if err != nil {
-				return nil, err
-			}
-
-			tcpKeepAlive(c)
-			return streamConn(c, streamOption{psk, option.Version, addr, obfsOption}), nil
-		})
-	}
-	return s, nil
-}
--- a/adapter/outbound/trojan.go
+++ b/adapter/outbound/trojan.go
@ -1,214 +0,0 @@
-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 func(c net.Conn) {
-		safeConnClose(c, err)
-	}(c)
-
-	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 func(c net.Conn) {
-			safeConnClose(c, err)
-		}(c)
-	} 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 func(c net.Conn) {
-			safeConnClose(c, err)
-		}(c)
-		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,
-			rmark: option.RoutingMark,
-		},
-		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
-}
--- a/adapter/outbound/util.go
+++ b/adapter/outbound/util.go
@ -1,60 +0,0 @@
-package outbound
-
-import (
-	"net"
-	"strconv"
-	"time"
-
-	"github.com/Dreamacro/clash/component/resolver"
-	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/transport/socks5"
-
-	"github.com/Dreamacro/protobytes"
-)
-
-func tcpKeepAlive(c net.Conn) {
-	if tcp, ok := c.(*net.TCPConn); ok {
-		tcp.SetKeepAlive(true)
-		tcp.SetKeepAlivePeriod(30 * time.Second)
-	}
-}
-
-func serializesSocksAddr(metadata *C.Metadata) []byte {
-	buf := protobytes.BytesWriter{}
-
-	addrType := metadata.AddrType()
-	buf.PutUint8(uint8(addrType))
-
-	p, _ := strconv.ParseUint(metadata.DstPort, 10, 16)
-	switch addrType {
-	case socks5.AtypDomainName:
-		buf.PutUint8(uint8(len(metadata.Host)))
-		buf.PutString(metadata.Host)
-	case socks5.AtypIPv4:
-		buf.PutSlice(metadata.DstIP.To4())
-	case socks5.AtypIPv6:
-		buf.PutSlice(metadata.DstIP.To16())
-	}
-
-	buf.PutUint16be(uint16(p))
-	return buf.Bytes()
-}
-
-func resolveUDPAddr(network, address string) (*net.UDPAddr, error) {
-	host, port, err := net.SplitHostPort(address)
-	if err != nil {
-		return nil, err
-	}
-
-	ip, err := resolver.ResolveIP(host)
-	if err != nil {
-		return nil, err
-	}
-	return net.ResolveUDPAddr(network, net.JoinHostPort(ip.String(), port))
-}
-
-func safeConnClose(c net.Conn, err error) {
-	if err != nil {
-		c.Close()
-	}
-}
--- a/adapter/outbound/vmess.go
+++ b/adapter/outbound/vmess.go
@ -1,385 +0,0 @@
-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/socks5"
-	"github.com/Dreamacro/clash/transport/vmess"
-
-	"golang.org/x/net/http2"
-)
-
-var ErrUDPRemoteAddrMismatch = errors.New("udp packet dropped due to mismatched remote address")
-
-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 func(c net.Conn) {
-			safeConnClose(c, err)
-		}(c)
-
-		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 func(c net.Conn) {
-		safeConnClose(c, err)
-	}(c)
-
-	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 func(c net.Conn) {
-			safeConnClose(c, err)
-		}(c)
-
-		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 func(c net.Conn) {
-			safeConnClose(c, err)
-		}(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),
-		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,
-			rmark: option.RoutingMark,
-		},
-		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 socks5.AtypIPv4:
-		addrType = vmess.AtypIPv4
-		addr = make([]byte, net.IPv4len)
-		copy(addr[:], metadata.DstIP.To4())
-	case socks5.AtypIPv6:
-		addrType = vmess.AtypIPv6
-		addr = make([]byte, net.IPv6len)
-		copy(addr[:], metadata.DstIP.To16())
-	case socks5.AtypDomainName:
-		addrType = 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
-}
-
-// WriteTo implments C.PacketConn.WriteTo
-// Since VMess doesn't support full cone NAT by design, we verify if addr matches uc.rAddr, and drop the packet if not.
-func (uc *vmessPacketConn) WriteTo(b []byte, addr net.Addr) (int, error) {
-	allowedAddr := uc.rAddr.(*net.UDPAddr)
-	destAddr := addr.(*net.UDPAddr)
-	if !(allowedAddr.IP.Equal(destAddr.IP) && allowedAddr.Port == destAddr.Port) {
-		return 0, ErrUDPRemoteAddrMismatch
-	}
-	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
-}
--- a/adapter/outboundgroup/common.go
+++ b/adapter/outboundgroup/common.go
@ -1,29 +0,0 @@
-package outboundgroup
-
-import (
-	"time"
-
-	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/constant/provider"
-)
-
-const (
-	defaultGetProxiesDuration = time.Second * 5
-)
-
-func touchProviders(providers []provider.ProxyProvider) {
-	for _, provider := range providers {
-		provider.Touch()
-	}
-}
-
-func getProvidersProxies(providers []provider.ProxyProvider, touch bool) []C.Proxy {
-	proxies := []C.Proxy{}
-	for _, provider := range providers {
-		if touch {
-			provider.Touch()
-		}
-		proxies = append(proxies, provider.Proxies()...)
-	}
-	return proxies
-}
--- a/adapter/outboundgroup/fallback.go
+++ b/adapter/outboundgroup/fallback.go
@ -1,106 +0,0 @@
-package outboundgroup
-
-import (
-	"context"
-	"encoding/json"
-
-	"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
-}
-
-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)
-	}
-	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)
-	}
-	return pc, err
-}
-
-// 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]any{
-		"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() (any, 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,
-	}
-}
--- a/adapter/outboundgroup/loadbalance.go
+++ b/adapter/outboundgroup/loadbalance.go
@ -1,189 +0,0 @@
-package outboundgroup
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net"
-
-	"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"
-)
-
-type strategyFn = func(proxies []C.Proxy, metadata *C.Metadata) C.Proxy
-
-type LoadBalance struct {
-	*outbound.Base
-	disableUDP bool
-	single     *singledo.Single
-	providers  []provider.ProxyProvider
-	strategyFn strategyFn
-}
-
-var errStrategy = errors.New("unsupported strategy")
-
-func parseStrategy(config map[string]any) string {
-	if strategy, ok := config["strategy"].(string); ok {
-		return strategy
-	}
-	return "consistent-hashing"
-}
-
-func getKey(metadata *C.Metadata) string {
-	if metadata.Host != "" {
-		// ip host
-		if ip := net.ParseIP(metadata.Host); ip != nil {
-			return metadata.Host
-		}
-
-		if etld, err := publicsuffix.EffectiveTLDPlusOne(metadata.Host); err == nil {
-			return etld
-		}
-	}
-
-	if metadata.DstIP == nil {
-		return ""
-	}
-
-	return metadata.DstIP.String()
-}
-
-func jumpHash(key uint64, buckets int32) int32 {
-	var b, j int64
-
-	for j < int64(buckets) {
-		b = j
-		key = key*2862933555777941757 + 1
-		j = int64(float64(b+1) * (float64(int64(1)<<31) / float64((key>>33)+1)))
-	}
-
-	return int32(b)
-}
-
-// 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)
-		}
-	}()
-
-	proxy := lb.Unwrap(metadata)
-
-	c, err = proxy.DialContext(ctx, metadata, lb.Base.DialOptions(opts...)...)
-	return
-}
-
-// 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)
-		}
-	}()
-
-	proxy := lb.Unwrap(metadata)
-	return proxy.ListenPacketContext(ctx, metadata, lb.Base.DialOptions(opts...)...)
-}
-
-// SupportUDP implements C.ProxyAdapter
-func (lb *LoadBalance) SupportUDP() bool {
-	return !lb.disableUDP
-}
-
-func strategyRoundRobin() strategyFn {
-	idx := 0
-	return func(proxies []C.Proxy, metadata *C.Metadata) C.Proxy {
-		length := len(proxies)
-		for i := 0; i < length; i++ {
-			idx = (idx + 1) % length
-			proxy := proxies[idx]
-			if proxy.Alive() {
-				return proxy
-			}
-		}
-
-		return proxies[0]
-	}
-}
-
-func strategyConsistentHashing() strategyFn {
-	maxRetry := 5
-	return func(proxies []C.Proxy, metadata *C.Metadata) C.Proxy {
-		key := uint64(murmur3.Sum32([]byte(getKey(metadata))))
-		buckets := int32(len(proxies))
-		for i := 0; i < maxRetry; i, key = i+1, key+1 {
-			idx := jumpHash(key, buckets)
-			proxy := proxies[idx]
-			if proxy.Alive() {
-				return proxy
-			}
-		}
-
-		// when availability is poor, traverse the entire list to get the available nodes
-		for _, proxy := range proxies {
-			if proxy.Alive() {
-				return proxy
-			}
-		}
-
-		return proxies[0]
-	}
-}
-
-// Unwrap implements C.ProxyAdapter
-func (lb *LoadBalance) Unwrap(metadata *C.Metadata) C.Proxy {
-	proxies := lb.proxies(true)
-	return lb.strategyFn(proxies, metadata)
-}
-
-func (lb *LoadBalance) proxies(touch bool) []C.Proxy {
-	elm, _, _ := lb.single.Do(func() (any, error) {
-		return getProvidersProxies(lb.providers, touch), nil
-	})
-
-	return elm.([]C.Proxy)
-}
-
-// MarshalJSON implements C.ProxyAdapter
-func (lb *LoadBalance) MarshalJSON() ([]byte, error) {
-	var all []string
-	for _, proxy := range lb.proxies(false) {
-		all = append(all, proxy.Name())
-	}
-	return json.Marshal(map[string]any{
-		"type": lb.Type().String(),
-		"all":  all,
-	})
-}
-
-func NewLoadBalance(option *GroupCommonOption, providers []provider.ProxyProvider, strategy string) (lb *LoadBalance, err error) {
-	var strategyFn strategyFn
-	switch strategy {
-	case "consistent-hashing":
-		strategyFn = strategyConsistentHashing()
-	case "round-robin":
-		strategyFn = strategyRoundRobin()
-	default:
-		return nil, fmt.Errorf("%w: %s", errStrategy, strategy)
-	}
-	return &LoadBalance{
-		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: option.DisableUDP,
-	}, nil
-}
--- a/adapter/outboundgroup/parser.go
+++ b/adapter/outboundgroup/parser.go
@ -1,166 +0,0 @@
-package outboundgroup
-
-import (
-	"errors"
-	"fmt"
-
-	"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"
-
-	regexp "github.com/dlclark/regexp2"
-)
-
-var (
-	errFormat            = errors.New("format error")
-	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")
-)
-
-type GroupCommonOption struct {
-	outbound.BasicOption
-	Name       string   `group:"name"`
-	Type       string   `group:"type"`
-	Proxies    []string `group:"proxies,omitempty"`
-	Use        []string `group:"use,omitempty"`
-	URL        string   `group:"url,omitempty"`
-	Interval   int      `group:"interval,omitempty"`
-	Lazy       bool     `group:"lazy,omitempty"`
-	DisableUDP bool     `group:"disable-udp,omitempty"`
-	Filter     string   `group:"filter,omitempty"`
-}
-
-func ParseProxyGroup(config map[string]any, proxyMap map[string]C.Proxy, providersMap map[string]types.ProxyProvider) (C.ProxyAdapter, error) {
-	decoder := structure.NewDecoder(structure.Option{TagName: "group", WeaklyTypedInput: true})
-
-	groupOption := &GroupCommonOption{
-		Lazy: true,
-	}
-	if err := decoder.Decode(config, groupOption); err != nil {
-		return nil, errFormat
-	}
-
-	if groupOption.Type == "" || groupOption.Name == "" {
-		return nil, errFormat
-	}
-
-	var (
-		groupName = groupOption.Name
-		filterReg *regexp.Regexp
-	)
-
-	if groupOption.Filter != "" {
-		f, err := regexp.Compile(groupOption.Filter, regexp.None)
-		if err != nil {
-			return nil, fmt.Errorf("%s: invalid filter regex: %w", groupName, err)
-		}
-		filterReg = f
-	}
-
-	if len(groupOption.Proxies) == 0 && len(groupOption.Use) == 0 {
-		return nil, fmt.Errorf("%s: %w", groupName, errMissProxy)
-	}
-
-	providers := []types.ProxyProvider{}
-
-	if len(groupOption.Proxies) != 0 {
-		ps, err := getProxies(proxyMap, groupOption.Proxies)
-		if err != nil {
-			return nil, fmt.Errorf("%s: %w", groupName, err)
-		}
-
-		if _, ok := providersMap[groupName]; ok {
-			return nil, fmt.Errorf("%s: %w", groupName, 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 {
-				return nil, fmt.Errorf("%s: %w", groupName, err)
-			}
-
-			providers = append(providers, pd)
-			providersMap[groupName] = pd
-		} else {
-			if groupOption.URL == "" || groupOption.Interval == 0 {
-				return nil, fmt.Errorf("%s: %w", groupName, errMissHealthCheck)
-			}
-
-			hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval), groupOption.Lazy)
-			pd, err := provider.NewCompatibleProvider(groupName, ps, hc)
-			if err != nil {
-				return nil, fmt.Errorf("%s: %w", groupName, err)
-			}
-
-			providers = append(providers, pd)
-			providersMap[groupName] = pd
-		}
-	}
-
-	if len(groupOption.Use) != 0 {
-		list, err := getProviders(providersMap, groupOption.Use)
-		if err != nil {
-			return nil, fmt.Errorf("%s: %w", groupName, err)
-		}
-		if filterReg != nil {
-			pd := provider.NewFilterableProvider(groupName, list, filterReg)
-			providers = append(providers, pd)
-		} else {
-			providers = append(providers, list...)
-		}
-	}
-
-	var group C.ProxyAdapter
-	switch groupOption.Type {
-	case "url-test":
-		opts := parseURLTestOption(config)
-		group = NewURLTest(groupOption, providers, opts...)
-	case "select":
-		group = NewSelector(groupOption, providers)
-	case "fallback":
-		group = NewFallback(groupOption, providers)
-	case "load-balance":
-		strategy := parseStrategy(config)
-		return NewLoadBalance(groupOption, providers, strategy)
-	case "relay":
-		group = NewRelay(groupOption, providers)
-	default:
-		return nil, fmt.Errorf("%s %w: %s", groupName, errType, groupOption.Type)
-	}
-
-	return group, nil
-}
-
-func getProxies(mapping map[string]C.Proxy, list []string) ([]C.Proxy, error) {
-	var ps []C.Proxy
-	for _, name := range list {
-		p, ok := mapping[name]
-		if !ok {
-			return nil, fmt.Errorf("'%s' not found", name)
-		}
-		ps = append(ps, p)
-	}
-	return ps, nil
-}
-
-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() == types.Compatible {
-			return nil, fmt.Errorf("proxy group %s can't contains in `use`", name)
-		}
-		ps = append(ps, p)
-	}
-	return ps, nil
-}
--- a/adapter/outboundgroup/relay.go
+++ b/adapter/outboundgroup/relay.go
@ -1,114 +0,0 @@
-package outboundgroup
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-
-	"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 {
-	*outbound.Base
-	single    *singledo.Single
-	providers []provider.ProxyProvider
-}
-
-// 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(), r.Base.DialOptions(opts...)...)
-	if err != nil {
-		return nil, fmt.Errorf("%s connect error: %w", first.Addr(), err)
-	}
-	tcpKeepAlive(c)
-
-	var currentMeta *C.Metadata
-	for _, proxy := range proxies[1:] {
-		currentMeta, err = addrToMetadata(proxy.Addr())
-		if err != nil {
-			return nil, err
-		}
-
-		c, err = first.StreamConn(c, currentMeta)
-		if err != nil {
-			return nil, fmt.Errorf("%s connect error: %w", first.Addr(), err)
-		}
-
-		first = proxy
-	}
-
-	c, err = last.StreamConn(c, metadata)
-	if err != nil {
-		return nil, fmt.Errorf("%s connect error: %w", last.Addr(), err)
-	}
-
-	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) {
-		all = append(all, proxy.Name())
-	}
-	return json.Marshal(map[string]any{
-		"type": r.Type().String(),
-		"all":  all,
-	})
-}
-
-func (r *Relay) rawProxies(touch bool) []C.Proxy {
-	elm, _, _ := r.single.Do(func() (any, error) {
-		return getProvidersProxies(r.providers, touch), nil
-	})
-
-	return elm.([]C.Proxy)
-}
-
-func (r *Relay) proxies(metadata *C.Metadata, touch bool) []C.Proxy {
-	proxies := r.rawProxies(touch)
-
-	for n, proxy := range proxies {
-		subproxy := proxy.Unwrap(metadata)
-		for subproxy != nil {
-			proxies[n] = subproxy
-			subproxy = subproxy.Unwrap(metadata)
-		}
-	}
-
-	return proxies
-}
-
-func NewRelay(option *GroupCommonOption, providers []provider.ProxyProvider) *Relay {
-	return &Relay{
-		Base: outbound.NewBase(outbound.BaseOption{
-			Name:        option.Name,
-			Type:        C.Relay,
-			Interface:   option.Interface,
-			RoutingMark: option.RoutingMark,
-		}),
-		single:    singledo.NewSingle(defaultGetProxiesDuration),
-		providers: providers,
-	}
-}
--- a/adapter/outboundgroup/selector.go
+++ b/adapter/outboundgroup/selector.go
@ -1,114 +0,0 @@
-package outboundgroup
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-
-	"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 {
-	*outbound.Base
-	disableUDP bool
-	single     *singledo.Single
-	selected   string
-	providers  []provider.ProxyProvider
-}
-
-// 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
-}
-
-// 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
-	}
-
-	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) {
-		all = append(all, proxy.Name())
-	}
-
-	return json.Marshal(map[string]any{
-		"type": s.Type().String(),
-		"now":  s.Now(),
-		"all":  all,
-	})
-}
-
-func (s *Selector) Now() string {
-	return s.selectedProxy(false).Name()
-}
-
-func (s *Selector) Set(name string) error {
-	for _, proxy := range getProvidersProxies(s.providers, false) {
-		if proxy.Name() == name {
-			s.selected = name
-			s.single.Reset()
-			return nil
-		}
-	}
-
-	return errors.New("proxy not exist")
-}
-
-// Unwrap implements C.ProxyAdapter
-func (s *Selector) Unwrap(metadata *C.Metadata) C.Proxy {
-	return s.selectedProxy(true)
-}
-
-func (s *Selector) selectedProxy(touch bool) C.Proxy {
-	elm, _, _ := s.single.Do(func() (any, error) {
-		proxies := getProvidersProxies(s.providers, touch)
-		for _, proxy := range proxies {
-			if proxy.Name() == s.selected {
-				return proxy, nil
-			}
-		}
-
-		return proxies[0], nil
-	})
-
-	return elm.(C.Proxy)
-}
-
-func NewSelector(option *GroupCommonOption, providers []provider.ProxyProvider) *Selector {
-	selected := providers[0].Proxies()[0].Name()
-	return &Selector{
-		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: option.DisableUDP,
-	}
-}
--- a/adapter/outboundgroup/urltest.go
+++ b/adapter/outboundgroup/urltest.go
@ -1,157 +0,0 @@
-package outboundgroup
-
-import (
-	"context"
-	"encoding/json"
-	"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
-}
-
-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)
-	}
-	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)
-	}
-	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() (any, error) {
-		return getProvidersProxies(u.providers, touch), nil
-	})
-
-	return elm.([]C.Proxy)
-}
-
-func (u *URLTest) fast(touch bool) C.Proxy {
-	elm, _, shared := u.fastSingle.Do(func() (any, 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
-	})
-	if shared && touch { // a shared fastSingle.Do() may cause providers untouched, so we touch them again
-		touchProviders(u.providers)
-	}
-
-	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]any{
-		"type": u.Type().String(),
-		"now":  u.Now(),
-		"all":  all,
-	})
-}
-
-func parseURLTestOption(config map[string]any) []urlTestOption {
-	opts := []urlTestOption{}
-
-	// tolerance
-	if tolerance, ok := config["tolerance"].(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,
-	}
-
-	for _, option := range options {
-		option(urlTest)
-	}
-
-	return urlTest
-}
--- a/adapter/outboundgroup/util.go
+++ b/adapter/outboundgroup/util.go
@ -1,48 +0,0 @@
-package outboundgroup
-
-import (
-	"fmt"
-	"net"
-	"time"
-
-	C "github.com/Dreamacro/clash/constant"
-)
-
-func addrToMetadata(rawAddress string) (addr *C.Metadata, err error) {
-	host, port, err := net.SplitHostPort(rawAddress)
-	if err != nil {
-		err = fmt.Errorf("addrToMetadata failed: %w", err)
-		return
-	}
-
-	ip := net.ParseIP(host)
-	if ip == nil {
-		addr = &C.Metadata{
-			Host:    host,
-			DstIP:   nil,
-			DstPort: port,
-		}
-		return
-	} else if ip4 := ip.To4(); ip4 != nil {
-		addr = &C.Metadata{
-			Host:    "",
-			DstIP:   ip4,
-			DstPort: port,
-		}
-		return
-	}
-
-	addr = &C.Metadata{
-		Host:    "",
-		DstIP:   ip,
-		DstPort: port,
-	}
-	return
-}
-
-func tcpKeepAlive(c net.Conn) {
-	if tcp, ok := c.(*net.TCPConn); ok {
-		tcp.SetKeepAlive(true)
-		tcp.SetKeepAlivePeriod(30 * time.Second)
-	}
-}
--- a/adapter/parser.go
+++ b/adapter/parser.go
@ -1,86 +0,0 @@
-package adapter
-
-import (
-	"fmt"
-
-	"github.com/Dreamacro/clash/adapter/outbound"
-	"github.com/Dreamacro/clash/common/structure"
-	C "github.com/Dreamacro/clash/constant"
-)
-
-func ParseProxy(mapping map[string]any) (C.Proxy, error) {
-	decoder := structure.NewDecoder(structure.Option{TagName: "proxy", WeaklyTypedInput: true})
-	proxyType, existType := mapping["type"].(string)
-	if !existType {
-		return nil, fmt.Errorf("missing type")
-	}
-
-	var (
-		proxy C.ProxyAdapter
-		err   error
-	)
-	switch proxyType {
-	case "ss":
-		ssOption := &outbound.ShadowSocksOption{}
-		err = decoder.Decode(mapping, ssOption)
-		if err != nil {
-			break
-		}
-		proxy, err = outbound.NewShadowSocks(*ssOption)
-	case "ssr":
-		ssrOption := &outbound.ShadowSocksROption{}
-		err = decoder.Decode(mapping, ssrOption)
-		if err != nil {
-			break
-		}
-		proxy, err = outbound.NewShadowSocksR(*ssrOption)
-	case "socks5":
-		socksOption := &outbound.Socks5Option{}
-		err = decoder.Decode(mapping, socksOption)
-		if err != nil {
-			break
-		}
-		proxy = outbound.NewSocks5(*socksOption)
-	case "http":
-		httpOption := &outbound.HttpOption{}
-		err = decoder.Decode(mapping, httpOption)
-		if err != nil {
-			break
-		}
-		proxy = outbound.NewHttp(*httpOption)
-	case "vmess":
-		vmessOption := &outbound.VmessOption{
-			HTTPOpts: outbound.HTTPOptions{
-				Method: "GET",
-				Path:   []string{"/"},
-			},
-		}
-		err = decoder.Decode(mapping, vmessOption)
-		if err != nil {
-			break
-		}
-		proxy, err = outbound.NewVmess(*vmessOption)
-	case "snell":
-		snellOption := &outbound.SnellOption{}
-		err = decoder.Decode(mapping, snellOption)
-		if err != nil {
-			break
-		}
-		proxy, err = outbound.NewSnell(*snellOption)
-	case "trojan":
-		trojanOption := &outbound.TrojanOption{}
-		err = decoder.Decode(mapping, trojanOption)
-		if err != nil {
-			break
-		}
-		proxy, err = outbound.NewTrojan(*trojanOption)
-	default:
-		return nil, fmt.Errorf("unsupport proxy type: %s", proxyType)
-	}
-
-	if err != nil {
-		return nil, err
-	}
-
-	return NewProxy(proxy), nil
-}
--- a/adapter/provider/fetcher.go
+++ b/adapter/provider/fetcher.go
@ -1,197 +0,0 @@
-package provider
-
-import (
-	"bytes"
-	"crypto/md5"
-	"os"
-	"path/filepath"
-	"time"
-
-	types "github.com/Dreamacro/clash/constant/provider"
-	"github.com/Dreamacro/clash/log"
-)
-
-var (
-	fileMode os.FileMode = 0o666
-	dirMode  os.FileMode = 0o755
-)
-
-type parser = func([]byte) (any, error)
-
-type fetcher struct {
-	name      string
-	vehicle   types.Vehicle
-	interval  time.Duration
-	updatedAt *time.Time
-	ticker    *time.Ticker
-	done      chan struct{}
-	hash      [16]byte
-	parser    parser
-	onUpdate  func(any)
-}
-
-func (f *fetcher) Name() string {
-	return f.name
-}
-
-func (f *fetcher) VehicleType() types.VehicleType {
-	return f.vehicle.Type()
-}
-
-func (f *fetcher) Initial() (any, error) {
-	var (
-		buf               []byte
-		err               error
-		isLocal           bool
-		immediatelyUpdate bool
-	)
-	if stat, fErr := os.Stat(f.vehicle.Path()); fErr == nil {
-		buf, err = os.ReadFile(f.vehicle.Path())
-		modTime := stat.ModTime()
-		f.updatedAt = &modTime
-		isLocal = true
-		immediatelyUpdate = time.Since(modTime) > f.interval
-	} else {
-		buf, err = f.vehicle.Read()
-	}
-
-	if err != nil {
-		return nil, err
-	}
-
-	proxies, err := f.parser(buf)
-	if err != nil {
-		if !isLocal {
-			return nil, err
-		}
-
-		// parse local file error, fallback to remote
-		buf, err = f.vehicle.Read()
-		if err != nil {
-			return nil, err
-		}
-
-		proxies, err = f.parser(buf)
-		if err != nil {
-			return nil, err
-		}
-
-		isLocal = false
-	}
-
-	if f.vehicle.Type() != types.File && !isLocal {
-		if err := safeWrite(f.vehicle.Path(), buf); err != nil {
-			return nil, err
-		}
-	}
-
-	f.hash = md5.Sum(buf)
-
-	// pull proxies automatically
-	if f.ticker != nil {
-		go f.pullLoop(immediatelyUpdate)
-	}
-
-	return proxies, nil
-}
-
-func (f *fetcher) Update() (any, bool, error) {
-	buf, err := f.vehicle.Read()
-	if err != nil {
-		return nil, false, err
-	}
-
-	now := time.Now()
-	hash := md5.Sum(buf)
-	if bytes.Equal(f.hash[:], hash[:]) {
-		f.updatedAt = &now
-		os.Chtimes(f.vehicle.Path(), now, now)
-		return nil, true, nil
-	}
-
-	proxies, err := f.parser(buf)
-	if err != nil {
-		return nil, false, err
-	}
-
-	if f.vehicle.Type() != types.File {
-		if err := safeWrite(f.vehicle.Path(), buf); err != nil {
-			return nil, false, err
-		}
-	}
-
-	f.updatedAt = &now
-	f.hash = hash
-
-	return proxies, false, nil
-}
-
-func (f *fetcher) Destroy() error {
-	if f.ticker != nil {
-		f.done <- struct{}{}
-	}
-	return nil
-}
-
-func (f *fetcher) pullLoop(immediately bool) {
-	update := func() {
-		elm, same, err := f.Update()
-		if err != nil {
-			log.Warnln("[Provider] %s pull error: %s", f.Name(), err.Error())
-			return
-		}
-
-		if same {
-			log.Debugln("[Provider] %s's proxies doesn't change", f.Name())
-			return
-		}
-
-		log.Infoln("[Provider] %s's proxies update", f.Name())
-		if f.onUpdate != nil {
-			f.onUpdate(elm)
-		}
-	}
-
-	if immediately {
-		update()
-	}
-
-	for {
-		select {
-		case <-f.ticker.C:
-			update()
-		case <-f.done:
-			f.ticker.Stop()
-			return
-		}
-	}
-}
-
-func safeWrite(path string, buf []byte) error {
-	dir := filepath.Dir(path)
-
-	if _, err := os.Stat(dir); os.IsNotExist(err) {
-		if err := os.MkdirAll(dir, dirMode); err != nil {
-			return err
-		}
-	}
-
-	return os.WriteFile(path, buf, fileMode)
-}
-
-func newFetcher(name string, interval time.Duration, vehicle types.Vehicle, parser parser, onUpdate func(any)) *fetcher {
-	var ticker *time.Ticker
-	if interval != 0 {
-		ticker = time.NewTicker(interval)
-	}
-
-	return &fetcher{
-		name:     name,
-		ticker:   ticker,
-		vehicle:  vehicle,
-		interval: interval,
-		parser:   parser,
-		done:     make(chan struct{}, 1),
-		onUpdate: onUpdate,
-	}
-}
--- a/adapter/provider/healthcheck.go
+++ b/adapter/provider/healthcheck.go
@ -1,100 +0,0 @@
-package provider
-
-import (
-	"context"
-	"time"
-
-	"github.com/Dreamacro/clash/common/batch"
-	C "github.com/Dreamacro/clash/constant"
-
-	"github.com/samber/lo"
-	"go.uber.org/atomic"
-)
-
-const (
-	defaultURLTestTimeout = time.Second * 5
-)
-
-type HealthCheckOption struct {
-	URL      string
-	Interval uint
-}
-
-type HealthCheck struct {
-	url       string
-	proxies   []C.Proxy
-	interval  uint
-	lazy      bool
-	lastTouch *atomic.Int64
-	done      chan struct{}
-}
-
-func (hc *HealthCheck) process() {
-	ticker := time.NewTicker(time.Duration(hc.interval) * time.Second)
-
-	go hc.checkAll()
-	for {
-		select {
-		case <-ticker.C:
-			now := time.Now().Unix()
-			if !hc.lazy || now-hc.lastTouch.Load() < int64(hc.interval) {
-				hc.checkAll()
-			} else { // lazy but still need to check not alive proxies
-				notAliveProxies := lo.Filter(hc.proxies, func(proxy C.Proxy, _ int) bool {
-					return !proxy.Alive()
-				})
-				if len(notAliveProxies) != 0 {
-					hc.check(notAliveProxies)
-				}
-			}
-		case <-hc.done:
-			ticker.Stop()
-			return
-		}
-	}
-}
-
-func (hc *HealthCheck) setProxy(proxies []C.Proxy) {
-	hc.proxies = proxies
-}
-
-func (hc *HealthCheck) auto() bool {
-	return hc.interval != 0
-}
-
-func (hc *HealthCheck) touch() {
-	hc.lastTouch.Store(time.Now().Unix())
-}
-
-func (hc *HealthCheck) checkAll() {
-	hc.check(hc.proxies)
-}
-
-func (hc *HealthCheck) check(proxies []C.Proxy) {
-	b, _ := batch.New(context.Background(), batch.WithConcurrencyNum(10))
-	for _, proxy := range proxies {
-		p := proxy
-		b.Go(p.Name(), func() (any, error) {
-			ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout)
-			defer cancel()
-			p.URLTest(ctx, hc.url)
-			return nil, nil
-		})
-	}
-	b.Wait()
-}
-
-func (hc *HealthCheck) close() {
-	hc.done <- struct{}{}
-}
-
-func NewHealthCheck(proxies []C.Proxy, url string, interval uint, lazy bool) *HealthCheck {
-	return &HealthCheck{
-		proxies:   proxies,
-		url:       url,
-		interval:  interval,
-		lazy:      lazy,
-		lastTouch: atomic.NewInt64(0),
-		done:      make(chan struct{}, 1),
-	}
-}
--- a/adapter/provider/provider.go
+++ b/adapter/provider/provider.go
@ -1,322 +0,0 @@
-package provider
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"runtime"
-	"time"
-
-	"github.com/Dreamacro/clash/adapter"
-	"github.com/Dreamacro/clash/adapter/outbound"
-	"github.com/Dreamacro/clash/common/singledo"
-	C "github.com/Dreamacro/clash/constant"
-	types "github.com/Dreamacro/clash/constant/provider"
-
-	regexp "github.com/dlclark/regexp2"
-	"github.com/samber/lo"
-	"gopkg.in/yaml.v3"
-)
-
-var reject = adapter.NewProxy(outbound.NewReject())
-
-const (
-	ReservedName = "default"
-)
-
-type ProxySchema struct {
-	Proxies []map[string]any `yaml:"proxies"`
-}
-
-// for auto gc
-type ProxySetProvider struct {
-	*proxySetProvider
-}
-
-type proxySetProvider struct {
-	*fetcher
-	proxies     []C.Proxy
-	healthCheck *HealthCheck
-}
-
-func (pp *proxySetProvider) MarshalJSON() ([]byte, error) {
-	return json.Marshal(map[string]any{
-		"name":        pp.Name(),
-		"type":        pp.Type().String(),
-		"vehicleType": pp.VehicleType().String(),
-		"proxies":     pp.Proxies(),
-		"updatedAt":   pp.updatedAt,
-	})
-}
-
-func (pp *proxySetProvider) Name() string {
-	return pp.name
-}
-
-func (pp *proxySetProvider) HealthCheck() {
-	pp.healthCheck.checkAll()
-}
-
-func (pp *proxySetProvider) Update() error {
-	elm, same, err := pp.fetcher.Update()
-	if err == nil && !same {
-		pp.onUpdate(elm)
-	}
-	return err
-}
-
-func (pp *proxySetProvider) Initial() error {
-	elm, err := pp.fetcher.Initial()
-	if err != nil {
-		return err
-	}
-
-	pp.onUpdate(elm)
-	return nil
-}
-
-func (pp *proxySetProvider) Type() types.ProviderType {
-	return types.Proxy
-}
-
-func (pp *proxySetProvider) Proxies() []C.Proxy {
-	return pp.proxies
-}
-
-func (pp *proxySetProvider) Touch() {
-	pp.healthCheck.touch()
-}
-
-func (pp *proxySetProvider) setProxies(proxies []C.Proxy) {
-	pp.proxies = proxies
-	pp.healthCheck.setProxy(proxies)
-	if pp.healthCheck.auto() {
-		go pp.healthCheck.checkAll()
-	}
-}
-
-func stopProxyProvider(pd *ProxySetProvider) {
-	pd.healthCheck.close()
-	pd.fetcher.Destroy()
-}
-
-func NewProxySetProvider(name string, interval time.Duration, filter string, vehicle types.Vehicle, hc *HealthCheck) (*ProxySetProvider, error) {
-	filterReg, err := regexp.Compile(filter, regexp.None)
-	if err != nil {
-		return nil, fmt.Errorf("invalid filter regex: %w", err)
-	}
-
-	if hc.auto() {
-		go hc.process()
-	}
-
-	pd := &proxySetProvider{
-		proxies:     []C.Proxy{},
-		healthCheck: hc,
-	}
-
-	onUpdate := func(elm any) {
-		ret := elm.([]C.Proxy)
-		pd.setProxies(ret)
-	}
-
-	proxiesParseAndFilter := func(buf []byte) (any, 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"].(string); ok && len(filter) > 0 {
-				matched, err := filterReg.MatchString(name)
-				if err != nil {
-					return nil, fmt.Errorf("regex filter failed: %w", err)
-				}
-				if !matched {
-					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, nil
-}
-
-// for auto gc
-type CompatibleProvider struct {
-	*compatibleProvider
-}
-
-type compatibleProvider struct {
-	name        string
-	healthCheck *HealthCheck
-	proxies     []C.Proxy
-}
-
-func (cp *compatibleProvider) MarshalJSON() ([]byte, error) {
-	return json.Marshal(map[string]any{
-		"name":        cp.Name(),
-		"type":        cp.Type().String(),
-		"vehicleType": cp.VehicleType().String(),
-		"proxies":     cp.Proxies(),
-	})
-}
-
-func (cp *compatibleProvider) Name() string {
-	return cp.name
-}
-
-func (cp *compatibleProvider) HealthCheck() {
-	cp.healthCheck.checkAll()
-}
-
-func (cp *compatibleProvider) Update() error {
-	return nil
-}
-
-func (cp *compatibleProvider) Initial() error {
-	return nil
-}
-
-func (cp *compatibleProvider) VehicleType() types.VehicleType {
-	return types.Compatible
-}
-
-func (cp *compatibleProvider) Type() types.ProviderType {
-	return types.Proxy
-}
-
-func (cp *compatibleProvider) Proxies() []C.Proxy {
-	return cp.proxies
-}
-
-func (cp *compatibleProvider) Touch() {
-	cp.healthCheck.touch()
-}
-
-func stopCompatibleProvider(pd *CompatibleProvider) {
-	pd.healthCheck.close()
-}
-
-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")
-	}
-
-	if hc.auto() {
-		go hc.process()
-	}
-
-	pd := &compatibleProvider{
-		name:        name,
-		proxies:     proxies,
-		healthCheck: hc,
-	}
-
-	wrapper := &CompatibleProvider{pd}
-	runtime.SetFinalizer(wrapper, stopCompatibleProvider)
-	return wrapper, nil
-}
-
-var _ types.ProxyProvider = (*FilterableProvider)(nil)
-
-type FilterableProvider struct {
-	name      string
-	providers []types.ProxyProvider
-	filterReg *regexp.Regexp
-	single    *singledo.Single
-}
-
-func (fp *FilterableProvider) MarshalJSON() ([]byte, error) {
-	return json.Marshal(map[string]any{
-		"name":        fp.Name(),
-		"type":        fp.Type().String(),
-		"vehicleType": fp.VehicleType().String(),
-		"proxies":     fp.Proxies(),
-	})
-}
-
-func (fp *FilterableProvider) Name() string {
-	return fp.name
-}
-
-func (fp *FilterableProvider) HealthCheck() {
-}
-
-func (fp *FilterableProvider) Update() error {
-	return nil
-}
-
-func (fp *FilterableProvider) Initial() error {
-	return nil
-}
-
-func (fp *FilterableProvider) VehicleType() types.VehicleType {
-	return types.Compatible
-}
-
-func (fp *FilterableProvider) Type() types.ProviderType {
-	return types.Proxy
-}
-
-func (fp *FilterableProvider) Proxies() []C.Proxy {
-	elm, _, _ := fp.single.Do(func() (any, error) {
-		proxies := lo.FlatMap(
-			fp.providers,
-			func(item types.ProxyProvider, _ int) []C.Proxy {
-				return lo.Filter(
-					item.Proxies(),
-					func(item C.Proxy, _ int) bool {
-						matched, _ := fp.filterReg.MatchString(item.Name())
-						return matched
-					})
-			})
-
-		if len(proxies) == 0 {
-			proxies = append(proxies, reject)
-		}
-		return proxies, nil
-	})
-
-	return elm.([]C.Proxy)
-}
-
-func (fp *FilterableProvider) Touch() {
-	for _, provider := range fp.providers {
-		provider.Touch()
-	}
-}
-
-func NewFilterableProvider(name string, providers []types.ProxyProvider, filterReg *regexp.Regexp) *FilterableProvider {
-	return &FilterableProvider{
-		name:      name,
-		providers: providers,
-		filterReg: filterReg,
-		single:    singledo.NewSingle(time.Second * 10),
-	}
-}
--- a/adapters/inbound/http.go
+++ b/adapters/inbound/http.go
@ -0,0 +1,60 @@
+package inbound
+
+import (
+	"net"
+	"net/http"
+	"strings"
+
+	C "github.com/Dreamacro/clash/constant"
+)
+
+// HTTPAdapter is a adapter for HTTP connection
+type HTTPAdapter struct {
+	net.Conn
+	metadata *C.Metadata
+	R        *http.Request
+}
+
+// Metadata return destination metadata
+func (h *HTTPAdapter) Metadata() *C.Metadata {
+	return h.metadata
+}
+
+// NewHTTP is HTTPAdapter generator
+func NewHTTP(request *http.Request, conn net.Conn) *HTTPAdapter {
+	metadata := parseHTTPAddr(request)
+	metadata.Type = C.HTTP
+	if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
+		metadata.SrcIP = ip
+		metadata.SrcPort = port
+	}
+	return &HTTPAdapter{
+		metadata: metadata,
+		R:        request,
+		Conn:     conn,
+	}
+}
+
+// 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))
+	}
+}
--- a/adapters/inbound/https.go
+++ b/adapters/inbound/https.go
@ -0,0 +1,22 @@
+package inbound
+
+import (
+	"net"
+	"net/http"
+
+	C "github.com/Dreamacro/clash/constant"
+)
+
+// NewHTTPS is HTTPAdapter generator
+func NewHTTPS(request *http.Request, conn net.Conn) *SocketAdapter {
+	metadata := parseHTTPAddr(request)
+	metadata.Type = C.HTTPCONNECT
+	if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
+		metadata.SrcIP = ip
+		metadata.SrcPort = port
+	}
+	return &SocketAdapter{
+		metadata: metadata,
+		Conn:     conn,
+	}
+}
--- a/adapters/inbound/packet.go
+++ b/adapters/inbound/packet.go
@ -1,11 +1,8 @@
 package inbound

 import (
-	"net"
-	"net/netip"
-
+	"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
@ -20,7 +17,7 @@ func (s *PacketAdapter) Metadata() *C.Metadata {
 }

 // NewPacket is PacketAdapter generator
-func NewPacket(target socks5.Addr, originTarget net.Addr, packet C.UDPPacket, source C.Type) *PacketAdapter {
+func NewPacket(target socks5.Addr, packet C.UDPPacket, source C.Type) *PacketAdapter {
 	metadata := parseSocksAddr(target)
 	metadata.NetWork = C.UDP
 	metadata.Type = source
@ -28,11 +25,7 @@ func NewPacket(target socks5.Addr, originTarget net.Addr, packet C.UDPPacket, so
 		metadata.SrcIP = ip
 		metadata.SrcPort = port
 	}
-	if originTarget != nil {
-		if addrPort, err := netip.ParseAddrPort(originTarget.String()); err == nil {
-			metadata.OriginDst = addrPort
-		}
-	}
+
 	return &PacketAdapter{
 		UDPPacket: packet,
 		metadata:  metadata,
--- a/adapters/inbound/socket.go
+++ b/adapters/inbound/socket.go
@ -0,0 +1,35 @@
+package inbound
+
+import (
+	"net"
+
+	"github.com/Dreamacro/clash/component/socks5"
+	C "github.com/Dreamacro/clash/constant"
+)
+
+// SocketAdapter is a adapter for socks and redir connection
+type SocketAdapter struct {
+	net.Conn
+	metadata *C.Metadata
+}
+
+// Metadata return destination metadata
+func (s *SocketAdapter) Metadata() *C.Metadata {
+	return s.metadata
+}
+
+// NewSocket is SocketAdapter generator
+func NewSocket(target socks5.Addr, conn net.Conn, source C.Type, netType C.NetWork) *SocketAdapter {
+	metadata := parseSocksAddr(target)
+	metadata.NetWork = netType
+	metadata.Type = source
+	if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
+		metadata.SrcIP = ip
+		metadata.SrcPort = port
+	}
+
+	return &SocketAdapter{
+		Conn:     conn,
+		metadata: metadata,
+	}
+}
--- a/adapters/inbound/util.go
+++ b/adapters/inbound/util.go
@ -4,19 +4,19 @@ import (
 	"net"
 	"net/http"
 	"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 {
-	metadata := &C.Metadata{}
+	metadata := &C.Metadata{
+		AddrType: int(target[0]),
+	}

 	switch target[0] {
 	case socks5.AtypDomainName:
-		// trim for FQDN
-		metadata.Host = strings.TrimRight(string(target[2:2+target[1]]), ".")
+		metadata.Host = string(target[2 : 2+target[1]])
 		metadata.DstPort = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1]))
 	case socks5.AtypIPv4:
 		ip := net.IP(target[1 : 1+net.IPv4len])
@ -38,17 +38,22 @@ func parseHTTPAddr(request *http.Request) *C.Metadata {
 		port = "80"
 	}

-	// trim FQDN (#737)
-	host = strings.TrimRight(host, ".")
-
 	metadata := &C.Metadata{
-		NetWork: C.TCP,
-		Host:    host,
-		DstIP:   nil,
-		DstPort: port,
+		NetWork:  C.TCP,
+		AddrType: C.AtypDomainName,
+		Host:     host,
+		DstIP:    nil,
+		DstPort:  port,
 	}

-	if ip := net.ParseIP(host); ip != nil {
+	ip := net.ParseIP(host)
+	if ip != nil {
+		switch {
+		case ip.To4() == nil:
+			metadata.AddrType = C.AtypIPv6
+		default:
+			metadata.AddrType = C.AtypIPv4
+		}
 		metadata.DstIP = ip
 	}

--- a/adapters/outbound/base.go
+++ b/adapters/outbound/base.go
@ -0,0 +1,209 @@
+package outbound
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net"
+	"net/http"
+	"time"
+
+	"github.com/Dreamacro/clash/common/queue"
+	C "github.com/Dreamacro/clash/constant"
+)
+
+var (
+	defaultURLTestTimeout = time.Second * 5
+)
+
+type Base struct {
+	name 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) 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 NewBase(name string, tp C.AdapterType, udp bool) *Base {
+	return &Base{name, 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 interface {
+	net.PacketConn
+	WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error)
+}
+
+type packetConn struct {
+	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 PacketConn, a C.ProxyAdapter) C.PacketConn {
+	return &packetConn{pc, []string{a.Name()}}
+}
+
+type Proxy struct {
+	C.ProxyAdapter
+	history *queue.Queue
+	alive   bool
+}
+
+func (p *Proxy) Alive() bool {
+	return p.alive
+}
+
+func (p *Proxy) Dial(metadata *C.Metadata) (C.Conn, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), tcpTimeout)
+	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 = false
+	}
+	return conn, err
+}
+
+func (p *Proxy) DelayHistory() []C.DelayHistory {
+	queue := p.history.Copy()
+	histories := []C.DelayHistory{}
+	for _, item := range queue {
+		histories = append(histories, item.(C.DelayHistory))
+	}
+	return histories
+}
+
+// LastDelay return last history record. if proxy is not alive, return the max value of uint16.
+func (p *Proxy) LastDelay() (delay uint16) {
+	var max uint16 = 0xffff
+	if !p.alive {
+		return max
+	}
+
+	last := p.history.Last()
+	if last == nil {
+		return max
+	}
+	history := last.(C.DelayHistory)
+	if history.Delay == 0 {
+		return max
+	}
+	return history.Delay
+}
+
+func (p *Proxy) MarshalJSON() ([]byte, error) {
+	inner, err := p.ProxyAdapter.MarshalJSON()
+	if err != nil {
+		return inner, err
+	}
+
+	mapping := map[string]interface{}{}
+	json.Unmarshal(inner, &mapping)
+	mapping["history"] = p.DelayHistory()
+	mapping["name"] = p.Name()
+	return json.Marshal(mapping)
+}
+
+// URLTest get the delay for the specified URL
+func (p *Proxy) URLTest(ctx context.Context, url string) (t uint16, err error) {
+	defer func() {
+		p.alive = err == nil
+		record := C.DelayHistory{Time: time.Now()}
+		if err == nil {
+			record.Delay = t
+		}
+		p.history.Put(record)
+		if p.history.Len() > 10 {
+			p.history.Pop()
+		}
+	}()
+
+	addr, err := urlToMetadata(url)
+	if err != nil {
+		return
+	}
+
+	start := time.Now()
+	instance, err := p.DialContext(ctx, &addr)
+	if err != nil {
+		return
+	}
+	defer instance.Close()
+
+	req, err := http.NewRequest(http.MethodHead, url, nil)
+	if err != nil {
+		return
+	}
+	req = req.WithContext(ctx)
+
+	transport := &http.Transport{
+		Dial: func(string, string) (net.Conn, error) {
+			return instance, nil
+		},
+		// from http.DefaultTransport
+		MaxIdleConns:          100,
+		IdleConnTimeout:       90 * time.Second,
+		TLSHandshakeTimeout:   10 * time.Second,
+		ExpectContinueTimeout: 1 * time.Second,
+	}
+
+	client := http.Client{Transport: transport}
+	resp, err := client.Do(req)
+	if err != nil {
+		return
+	}
+	resp.Body.Close()
+	t = uint16(time.Since(start) / time.Millisecond)
+	return
+}
+
+func NewProxy(adapter C.ProxyAdapter) *Proxy {
+	return &Proxy{adapter, queue.New(10), true}
+}
--- a/adapters/outbound/direct.go
+++ b/adapters/outbound/direct.go
@ -0,0 +1,61 @@
+package outbound
+
+import (
+	"context"
+	"net"
+
+	"github.com/Dreamacro/clash/component/dialer"
+	"github.com/Dreamacro/clash/component/resolver"
+	C "github.com/Dreamacro/clash/constant"
+)
+
+type Direct struct {
+	*Base
+}
+
+func (d *Direct) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
+	address := net.JoinHostPort(metadata.Host, metadata.DstPort)
+	if metadata.DstIP != nil {
+		address = net.JoinHostPort(metadata.DstIP.String(), metadata.DstPort)
+	}
+
+	c, err := dialer.DialContext(ctx, "tcp", address)
+	if err != nil {
+		return nil, err
+	}
+	tcpKeepAlive(c)
+	return newConn(c, d), nil
+}
+
+func (d *Direct) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
+	pc, err := dialer.ListenPacket("udp", "")
+	if err != nil {
+		return nil, err
+	}
+	return newPacketConn(&directPacketConn{pc}, d), nil
+}
+
+type directPacketConn struct {
+	net.PacketConn
+}
+
+func (dp *directPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
+	if !metadata.Resolved() {
+		ip, err := resolver.ResolveIP(metadata.Host)
+		if err != nil {
+			return 0, err
+		}
+		metadata.DstIP = ip
+	}
+	return dp.WriteTo(p, metadata.UDPAddr())
+}
+
+func NewDirect() *Direct {
+	return &Direct{
+		Base: &Base{
+			name: "DIRECT",
+			tp:   C.Direct,
+			udp:  true,
+		},
+	}
+}
--- a/adapters/outbound/http.go
+++ b/adapters/outbound/http.go
@ -19,62 +19,39 @@ import (

 type Http struct {
 	*Base
+	addr      string
 	user      string
 	pass      string
 	tlsConfig *tls.Config
-	Headers   http.Header
 }

 type HttpOption struct {
-	BasicOption
-	Name           string            `proxy:"name"`
-	Server         string            `proxy:"server"`
-	Port           int               `proxy:"port"`
-	UserName       string            `proxy:"username,omitempty"`
-	Password       string            `proxy:"password,omitempty"`
-	TLS            bool              `proxy:"tls,omitempty"`
-	SNI            string            `proxy:"sni,omitempty"`
-	SkipCertVerify bool              `proxy:"skip-cert-verify,omitempty"`
-	Headers        map[string]string `proxy:"headers,omitempty"`
+	Name           string `proxy:"name"`
+	Server         string `proxy:"server"`
+	Port           int    `proxy:"port"`
+	UserName       string `proxy:"username,omitempty"`
+	Password       string `proxy:"password,omitempty"`
+	TLS            bool   `proxy:"tls,omitempty"`
+	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 {
+func (h *Http) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
+	c, err := dialer.DialContext(ctx, "tcp", h.addr)
+	if err == nil && h.tlsConfig != nil {
 		cc := tls.Client(c, h.tlsConfig)
-		ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
-		defer cancel()
-		err := cc.HandshakeContext(ctx)
+		err = cc.Handshake()
 		c = cc
-		if err != nil {
-			return nil, fmt.Errorf("%s connect error: %w", h.addr, err)
-		}
 	}

-	if err := h.shakeHand(metadata, c); err != nil {
-		return nil, err
-	}
-	return c, nil
-}
-
-// 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 func(c net.Conn) {
-		safeConnClose(c, err)
-	}(c)
-
-	c, err = h.StreamConn(c, metadata)
-	if err != nil {
+	if err := h.shakeHand(metadata, c); err != nil {
 		return nil, err
 	}

-	return NewConn(c, h), nil
+	return newConn(c, h), nil
 }

 func (h *Http) shakeHand(metadata *C.Metadata, rw io.ReadWriter) error {
@ -84,12 +61,12 @@ func (h *Http) shakeHand(metadata *C.Metadata, rw io.ReadWriter) error {
 		URL: &url.URL{
 			Host: addr,
 		},
-		Host:   addr,
-		Header: h.Headers.Clone(),
+		Host: addr,
+		Header: http.Header{
+			"Proxy-Connection": []string{"Keep-Alive"},
+		},
 	}

-	req.Header.Add("Proxy-Connection", "Keep-Alive")
-
 	if h.user != "" && h.pass != "" {
 		auth := h.user + ":" + h.pass
 		req.Header.Add("Proxy-Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(auth)))
@ -126,32 +103,21 @@ func (h *Http) shakeHand(metadata *C.Metadata, rw io.ReadWriter) error {
 func NewHttp(option HttpOption) *Http {
 	var tlsConfig *tls.Config
 	if option.TLS {
-		sni := option.Server
-		if option.SNI != "" {
-			sni = option.SNI
-		}
 		tlsConfig = &tls.Config{
 			InsecureSkipVerify: option.SkipCertVerify,
-			ServerName:         sni,
+			ClientSessionCache: getClientSessionCache(),
+			ServerName:         option.Server,
 		}
 	}

-	headers := http.Header{}
-	for name, value := range option.Headers {
-		headers.Add(name, value)
-	}
-
 	return &Http{
 		Base: &Base{
-			name:  option.Name,
-			addr:  net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
-			tp:    C.Http,
-			iface: option.Interface,
-			rmark: option.RoutingMark,
+			name: option.Name,
+			tp:   C.Http,
 		},
+		addr:      net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
 		user:      option.UserName,
 		pass:      option.Password,
 		tlsConfig: tlsConfig,
-		Headers:   headers,
 	}
 }
--- a/adapters/outbound/parser.go
+++ b/adapters/outbound/parser.go
@ -0,0 +1,64 @@
+package outbound
+
+import (
+	"fmt"
+
+	"github.com/Dreamacro/clash/common/structure"
+	C "github.com/Dreamacro/clash/constant"
+)
+
+func ParseProxy(mapping map[string]interface{}) (C.Proxy, error) {
+	decoder := structure.NewDecoder(structure.Option{TagName: "proxy", WeaklyTypedInput: true})
+	proxyType, existType := mapping["type"].(string)
+	if !existType {
+		return nil, fmt.Errorf("Missing type")
+	}
+
+	var proxy C.ProxyAdapter
+	err := fmt.Errorf("Cannot parse")
+	switch proxyType {
+	case "ss":
+		ssOption := &ShadowSocksOption{}
+		err = decoder.Decode(mapping, ssOption)
+		if err != nil {
+			break
+		}
+		proxy, err = NewShadowSocks(*ssOption)
+	case "socks5":
+		socksOption := &Socks5Option{}
+		err = decoder.Decode(mapping, socksOption)
+		if err != nil {
+			break
+		}
+		proxy = NewSocks5(*socksOption)
+	case "http":
+		httpOption := &HttpOption{}
+		err = decoder.Decode(mapping, httpOption)
+		if err != nil {
+			break
+		}
+		proxy = NewHttp(*httpOption)
+	case "vmess":
+		vmessOption := &VmessOption{}
+		err = decoder.Decode(mapping, vmessOption)
+		if err != nil {
+			break
+		}
+		proxy, err = NewVmess(*vmessOption)
+	case "snell":
+		snellOption := &SnellOption{}
+		err = decoder.Decode(mapping, snellOption)
+		if err != nil {
+			break
+		}
+		proxy, err = NewSnell(*snellOption)
+	default:
+		return nil, fmt.Errorf("Unsupport proxy type: %s", proxyType)
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	return NewProxy(proxy), nil
+}
--- a/adapters/outbound/reject.go
+++ b/adapters/outbound/reject.go
@ -0,0 +1,61 @@
+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 }
--- a/adapters/outbound/shadowsocks.go
+++ b/adapters/outbound/shadowsocks.go
@ -2,22 +2,25 @@ package outbound

 import (
 	"context"
-	"errors"
+	"crypto/tls"
+	"encoding/json"
 	"fmt"
 	"net"
 	"strconv"

 	"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"
-	"github.com/Dreamacro/clash/transport/shadowsocks/core"
-	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"
 )

 type ShadowSocks struct {
 	*Base
+	server string
 	cipher core.Cipher

 	// obfs
@ -27,19 +30,22 @@ type ShadowSocks struct {
 }

 type ShadowSocksOption struct {
-	BasicOption
-	Name       string         `proxy:"name"`
-	Server     string         `proxy:"server"`
-	Port       int            `proxy:"port"`
-	Password   string         `proxy:"password"`
-	Cipher     string         `proxy:"cipher"`
-	UDP        bool           `proxy:"udp,omitempty"`
-	Plugin     string         `proxy:"plugin,omitempty"`
-	PluginOpts map[string]any `proxy:"plugin-opts,omitempty"`
+	Name       string                 `proxy:"name"`
+	Server     string                 `proxy:"server"`
+	Port       int                    `proxy:"port"`
+	Password   string                 `proxy:"password"`
+	Cipher     string                 `proxy:"cipher"`
+	UDP        bool                   `proxy:"udp,omitempty"`
+	Plugin     string                 `proxy:"plugin,omitempty"`
+	PluginOpts map[string]interface{} `proxy:"plugin-opts,omitempty"`
+
+	// deprecated when bump to 1.0
+	Obfs     string `proxy:"obfs,omitempty"`
+	ObfsHost string `proxy:"obfs-host,omitempty"`
 }

 type simpleObfsOption struct {
-	Mode string `obfs:"mode,omitempty"`
+	Mode string `obfs:"mode"`
 	Host string `obfs:"host,omitempty"`
 }

@ -53,52 +59,38 @@ 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) {
+func (ss *ShadowSocks) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
+	c, err := dialer.DialContext(ctx, "tcp", ss.server)
+	if err != nil {
+		return nil, fmt.Errorf("%s connect error: %w", ss.server, err)
+	}
+	tcpKeepAlive(c)
 	switch ss.obfsMode {
 	case "tls":
 		c = obfs.NewTLSObfs(c, ss.obfsOption.Host)
 	case "http":
-		_, port, _ := net.SplitHostPort(ss.addr)
+		_, port, _ := net.SplitHostPort(ss.server)
 		c = obfs.NewHTTPObfs(c, ss.obfsOption.Host, port)
 	case "websocket":
 		var err error
 		c, err = v2rayObfs.NewV2rayObfs(c, ss.v2rayOption)
 		if err != nil {
-			return nil, fmt.Errorf("%s connect error: %w", ss.addr, err)
+			return nil, fmt.Errorf("%s connect error: %w", ss.server, err)
 		}
 	}
 	c = ss.cipher.StreamConn(c)
-	_, err := c.Write(serializesSocksAddr(metadata))
-	return c, err
+	_, err = c.Write(serializesSocksAddr(metadata))
+	return newConn(c, ss), err
 }

-// 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 func(c net.Conn) {
-		safeConnClose(c, err)
-	}(c)
-
-	c, err = ss.StreamConn(c, metadata)
-	return NewConn(c, ss), err
-}
-
-// 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...)...)
+func (ss *ShadowSocks) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
+	pc, err := dialer.ListenPacket("udp", "")
 	if err != nil {
 		return nil, err
 	}

-	addr, err := resolveUDPAddr("udp", ss.addr)
+	addr, err := resolveUDPAddr("udp", ss.server)
 	if err != nil {
-		pc.Close()
 		return nil, err
 	}

@ -106,63 +98,83 @@ func (ss *ShadowSocks) ListenPacketContext(ctx context.Context, metadata *C.Meta
 	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))
+	server := net.JoinHostPort(option.Server, strconv.Itoa(option.Port))
 	cipher := option.Cipher
 	password := option.Password
 	ciph, err := core.PickCipher(cipher, nil, password)
 	if err != nil {
-		return nil, fmt.Errorf("ss %s initialize error: %w", addr, err)
+		return nil, fmt.Errorf("ss %s initialize error: %w", server, err)
 	}

 	var v2rayOption *v2rayObfs.Option
 	var obfsOption *simpleObfsOption
 	obfsMode := ""

+	// forward compatibility before 1.0
+	if option.Obfs != "" {
+		obfsMode = option.Obfs
+		obfsOption = &simpleObfsOption{
+			Host: "bing.com",
+		}
+		if option.ObfsHost != "" {
+			obfsOption.Host = option.ObfsHost
+		}
+	}
+
 	decoder := structure.NewDecoder(structure.Option{TagName: "obfs", WeaklyTypedInput: true})
 	if option.Plugin == "obfs" {
 		opts := simpleObfsOption{Host: "bing.com"}
 		if err := decoder.Decode(option.PluginOpts, &opts); err != nil {
-			return nil, fmt.Errorf("ss %s initialize obfs error: %w", addr, err)
+			return nil, fmt.Errorf("ss %s initialize obfs error: %w", server, err)
 		}

 		if opts.Mode != "tls" && opts.Mode != "http" {
-			return nil, fmt.Errorf("ss %s obfs mode error: %s", addr, opts.Mode)
+			return nil, fmt.Errorf("ss %s obfs mode error: %s", server, opts.Mode)
 		}
 		obfsMode = opts.Mode
 		obfsOption = &opts
 	} else if option.Plugin == "v2ray-plugin" {
 		opts := v2rayObfsOption{Host: "bing.com", Mux: true}
 		if err := decoder.Decode(option.PluginOpts, &opts); err != nil {
-			return nil, fmt.Errorf("ss %s initialize v2ray-plugin error: %w", addr, err)
+			return nil, fmt.Errorf("ss %s initialize v2ray-plugin error: %w", server, err)
 		}

 		if opts.Mode != "websocket" {
-			return nil, fmt.Errorf("ss %s obfs mode error: %s", addr, opts.Mode)
+			return nil, fmt.Errorf("ss %s obfs mode error: %s", server, opts.Mode)
 		}
 		obfsMode = opts.Mode
-		v2rayOption = &v2rayObfs.Option{
-			Host:    opts.Host,
-			Path:    opts.Path,
-			Headers: opts.Headers,
-			Mux:     opts.Mux,
-		}

+		var tlsConfig *tls.Config
 		if opts.TLS {
-			v2rayOption.TLS = true
-			v2rayOption.SkipCertVerify = opts.SkipCertVerify
+			tlsConfig = &tls.Config{
+				ServerName:         opts.Host,
+				InsecureSkipVerify: opts.SkipCertVerify,
+				ClientSessionCache: getClientSessionCache(),
+			}
+		}
+		v2rayOption = &v2rayObfs.Option{
+			Host:      opts.Host,
+			Path:      opts.Path,
+			Headers:   opts.Headers,
+			TLSConfig: tlsConfig,
+			Mux:       opts.Mux,
 		}
 	}

 	return &ShadowSocks{
 		Base: &Base{
-			name:  option.Name,
-			addr:  addr,
-			tp:    C.Shadowsocks,
-			udp:   option.UDP,
-			iface: option.Interface,
-			rmark: option.RoutingMark,
+			name: option.Name,
+			tp:   C.Shadowsocks,
+			udp:  option.UDP,
 		},
+		server: server,
 		cipher: ciph,

 		obfsMode:    obfsMode,
@ -184,22 +196,20 @@ func (spc *ssPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
 	return spc.PacketConn.WriteTo(packet[3:], spc.rAddr)
 }

+func (spc *ssPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
+	packet, err := socks5.EncodeUDPPacket(socks5.ParseAddr(metadata.RemoteAddress()), p)
+	if err != nil {
+		return
+	}
+	return spc.PacketConn.WriteTo(packet[3:], spc.rAddr)
+}
+
 func (spc *ssPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
 	n, _, e := spc.PacketConn.ReadFrom(b)
 	if e != nil {
 		return 0, nil, e
 	}
-
 	addr := socks5.SplitAddr(b[:n])
-	if addr == nil {
-		return 0, nil, errors.New("parse addr error")
-	}
-
-	udpAddr := addr.UDPAddr()
-	if udpAddr == nil {
-		return 0, nil, errors.New("parse addr error")
-	}
-
 	copy(b, b[len(addr):])
-	return n - len(addr), udpAddr, e
+	return n - len(addr), addr.UDPAddr(), e
 }
--- a/adapters/outbound/snell.go
+++ b/adapters/outbound/snell.go
@ -0,0 +1,73 @@
+package outbound
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"strconv"
+
+	"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"
+)
+
+type Snell struct {
+	*Base
+	server     string
+	psk        []byte
+	obfsOption *simpleObfsOption
+}
+
+type SnellOption struct {
+	Name     string                 `proxy:"name"`
+	Server   string                 `proxy:"server"`
+	Port     int                    `proxy:"port"`
+	Psk      string                 `proxy:"psk"`
+	ObfsOpts map[string]interface{} `proxy:"obfs-opts,omitempty"`
+}
+
+func (s *Snell) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
+	c, err := dialer.DialContext(ctx, "tcp", s.server)
+	if err != nil {
+		return nil, fmt.Errorf("%s connect error: %w", s.server, err)
+	}
+	tcpKeepAlive(c)
+	switch s.obfsOption.Mode {
+	case "tls":
+		c = obfs.NewTLSObfs(c, s.obfsOption.Host)
+	case "http":
+		_, port, _ := net.SplitHostPort(s.server)
+		c = obfs.NewHTTPObfs(c, s.obfsOption.Host, port)
+	}
+	c = snell.StreamConn(c, s.psk)
+	port, _ := strconv.Atoi(metadata.DstPort)
+	err = snell.WriteHeader(c, metadata.String(), uint(port))
+	return newConn(c, s), err
+}
+
+func NewSnell(option SnellOption) (*Snell, error) {
+	server := net.JoinHostPort(option.Server, strconv.Itoa(option.Port))
+	psk := []byte(option.Psk)
+
+	decoder := structure.NewDecoder(structure.Option{TagName: "obfs", WeaklyTypedInput: true})
+	obfsOption := &simpleObfsOption{Host: "bing.com"}
+	if err := decoder.Decode(option.ObfsOpts, obfsOption); err != nil {
+		return nil, fmt.Errorf("snell %s initialize obfs error: %w", server, err)
+	}
+
+	if obfsOption.Mode != "tls" && obfsOption.Mode != "http" {
+		return nil, fmt.Errorf("snell %s obfs mode error: %s", server, obfsOption.Mode)
+	}
+
+	return &Snell{
+		Base: &Base{
+			name: option.Name,
+			tp:   C.Snell,
+		},
+		server:     server,
+		psk:        psk,
+		obfsOption: obfsOption,
+	}, nil
+}
--- a/adapters/outbound/socks5.go
+++ b/adapters/outbound/socks5.go
@ -3,19 +3,20 @@ package outbound
 import (
 	"context"
 	"crypto/tls"
-	"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 {
 	*Base
+	addr           string
 	user           string
 	pass           string
 	tls            bool
@ -24,7 +25,6 @@ type Socks5 struct {
 }

 type Socks5Option struct {
-	BasicOption
 	Name           string `proxy:"name"`
 	Server         string `proxy:"server"`
 	Port           int    `proxy:"port"`
@ -35,19 +35,19 @@ 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 {
+func (ss *Socks5) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
+	c, err := dialer.DialContext(ctx, "tcp", ss.addr)
+
+	if err == nil && ss.tls {
 		cc := tls.Client(c, ss.tlsConfig)
-		ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
-		defer cancel()
-		err := cc.HandshakeContext(ctx)
+		err = cc.Handshake()
 		c = cc
-		if err != nil {
-			return nil, fmt.Errorf("%s connect error: %w", ss.addr, err)
-		}
 	}

+	if err != nil {
+		return nil, fmt.Errorf("%s connect error: %w", ss.addr, err)
+	}
+	tcpKeepAlive(c)
 	var user *socks5.User
 	if ss.user != "" {
 		user = &socks5.User{
@ -58,32 +58,13 @@ func (ss *Socks5) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error)
 	if _, err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdConnect, user); err != nil {
 		return nil, err
 	}
-	return c, nil
+	return newConn(c, ss), nil
 }

-// 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 func(c net.Conn) {
-		safeConnClose(c, err)
-	}(c)
-
-	c, err = ss.StreamConn(c, metadata)
-	if err != nil {
-		return nil, err
-	}
-
-	return NewConn(c, ss), nil
-}
-
-// 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...)...)
+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)
 	if err != nil {
 		err = fmt.Errorf("%s connect error: %w", ss.addr, err)
 		return
@ -91,15 +72,15 @@ func (ss *Socks5) ListenPacketContext(ctx context.Context, metadata *C.Metadata,

 	if ss.tls {
 		cc := tls.Client(c, ss.tlsConfig)
-		ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
-		defer cancel()
-		err = cc.HandshakeContext(ctx)
+		err = cc.Handshake()
 		c = cc
 	}

-	defer func(c net.Conn) {
-		safeConnClose(c, err)
-	}(c)
+	defer func() {
+		if err != nil {
+			c.Close()
+		}
+	}()

 	tcpKeepAlive(c)
 	var user *socks5.User
@ -116,34 +97,20 @@ func (ss *Socks5) ListenPacketContext(ctx context.Context, metadata *C.Metadata,
 		return
 	}

-	pc, err := dialer.ListenPacket(ctx, "udp", "", ss.Base.DialOptions(opts...)...)
+	pc, err := dialer.ListenPacket("udp", "")
 	if err != nil {
 		return
 	}

 	go func() {
-		io.Copy(io.Discard, c)
+		io.Copy(ioutil.Discard, c)
 		c.Close()
 		// A UDP association terminates when the TCP connection that the UDP
 		// ASSOCIATE request arrived on terminates. RFC1928
 		pc.Close()
 	}()

-	// Support unspecified UDP bind address.
-	bindUDPAddr := bindAddr.UDPAddr()
-	if bindUDPAddr == nil {
-		err = errors.New("invalid UDP bind address")
-		return
-	} else if bindUDPAddr.IP.IsUnspecified() {
-		serverAddr, err := resolveUDPAddr("udp", ss.Addr())
-		if err != nil {
-			return nil, err
-		}
-
-		bindUDPAddr.IP = serverAddr.IP
-	}
-
-	return newPacketConn(&socksPacketConn{PacketConn: pc, rAddr: bindUDPAddr, tcpConn: c}, ss), nil
+	return newPacketConn(&socksPacketConn{PacketConn: pc, rAddr: bindAddr.UDPAddr(), tcpConn: c}, ss), nil
 }

 func NewSocks5(option Socks5Option) *Socks5 {
@ -151,19 +118,18 @@ 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,
-			iface: option.Interface,
-			rmark: option.RoutingMark,
+			name: option.Name,
+			tp:   C.Socks5,
+			udp:  option.UDP,
 		},
+		addr:           net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
 		user:           option.UserName,
 		pass:           option.Password,
 		tls:            option.TLS,
@ -186,8 +152,16 @@ func (uc *socksPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
 	return uc.PacketConn.WriteTo(packet, uc.rAddr)
 }

+func (uc *socksPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
+	packet, err := socks5.EncodeUDPPacket(socks5.ParseAddr(metadata.RemoteAddress()), p)
+	if err != nil {
+		return
+	}
+	return uc.PacketConn.WriteTo(packet, uc.rAddr)
+}
+
 func (uc *socksPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
-	n, _, e := uc.PacketConn.ReadFrom(b)
+	n, a, e := uc.PacketConn.ReadFrom(b)
 	if e != nil {
 		return 0, nil, e
 	}
@ -195,15 +169,10 @@ func (uc *socksPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
 	if err != nil {
 		return 0, nil, err
 	}
-
-	udpAddr := addr.UDPAddr()
-	if udpAddr == nil {
-		return 0, nil, errors.New("parse udp addr error")
-	}
-
 	// due to DecodeUDPPacket is mutable, record addr length
+	addrLength := len(addr)
 	copy(b, payload)
-	return n - len(addr) - 3, udpAddr, nil
+	return n - addrLength - 3, a, nil
 }

 func (uc *socksPacketConn) Close() error {
--- a/adapters/outbound/util.go
+++ b/adapters/outbound/util.go
@ -0,0 +1,100 @@
+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"
+)
+
+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)
+		tcp.SetKeepAlivePeriod(30 * time.Second)
+	}
+}
+
+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)
+	port := []byte{uint8(p >> 8), uint8(p & 0xff)}
+	switch metadata.AddrType {
+	case socks5.AtypDomainName:
+		len := uint8(len(metadata.Host))
+		host := []byte(metadata.Host)
+		buf = [][]byte{{aType, len}, host, port}
+	case socks5.AtypIPv4:
+		host := metadata.DstIP.To4()
+		buf = [][]byte{{aType}, host, port}
+	case socks5.AtypIPv6:
+		host := metadata.DstIP.To16()
+		buf = [][]byte{{aType}, host, port}
+	}
+	return bytes.Join(buf, nil)
+}
+
+func resolveUDPAddr(network, address string) (*net.UDPAddr, error) {
+	host, port, err := net.SplitHostPort(address)
+	if err != nil {
+		return nil, err
+	}
+
+	ip, err := resolver.ResolveIP(host)
+	if err != nil {
+		return nil, err
+	}
+	return net.ResolveUDPAddr(network, net.JoinHostPort(ip.String(), port))
+}
--- a/adapters/outbound/vmess.go
+++ b/adapters/outbound/vmess.go
@ -0,0 +1,146 @@
+package outbound
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net"
+	"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
+	server string
+	client *vmess.Client
+}
+
+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"`
+	WSPath         string            `proxy:"ws-path,omitempty"`
+	WSHeaders      map[string]string `proxy:"ws-headers,omitempty"`
+	SkipCertVerify bool              `proxy:"skip-cert-verify,omitempty"`
+}
+
+func (v *Vmess) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
+	c, err := dialer.DialContext(ctx, "tcp", v.server)
+	if err != nil {
+		return nil, fmt.Errorf("%s connect error", v.server)
+	}
+	tcpKeepAlive(c)
+	c, err = v.client.New(c, parseVmessAddr(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.server)
+	if err != nil {
+		return nil, fmt.Errorf("%s connect error", v.server)
+	}
+	tcpKeepAlive(c)
+	c, err = v.client.New(c, parseVmessAddr(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,
+		TLS:              option.TLS,
+		HostName:         option.Server,
+		Port:             strconv.Itoa(option.Port),
+		NetWork:          option.Network,
+		WebSocketPath:    option.WSPath,
+		WebSocketHeaders: option.WSHeaders,
+		SkipCertVerify:   option.SkipCertVerify,
+		SessionCache:     getClientSessionCache(),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return &Vmess{
+		Base: &Base{
+			name: option.Name,
+			tp:   C.Vmess,
+			udp:  true,
+		},
+		server: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
+		client: client,
+	}, 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) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
+	return uc.Conn.Write(p)
+}
+
+func (uc *vmessPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
+	n, err := uc.Conn.Read(b)
+	return n, uc.rAddr, err
+}
--- a/adapters/outboundgroup/common.go
+++ b/adapters/outboundgroup/common.go
@ -0,0 +1,20 @@
+package outboundgroup
+
+import (
+	"time"
+
+	"github.com/Dreamacro/clash/adapters/provider"
+	C "github.com/Dreamacro/clash/constant"
+)
+
+const (
+	defaultGetProxiesDuration = time.Second * 5
+)
+
+func getProvidersProxies(providers []provider.ProxyProvider) []C.Proxy {
+	proxies := []C.Proxy{}
+	for _, provider := range providers {
+		proxies = append(proxies, provider.Proxies()...)
+	}
+	return proxies
+}
--- a/adapters/outboundgroup/fallback.go
+++ b/adapters/outboundgroup/fallback.go
@ -0,0 +1,84 @@
+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
+	single    *singledo.Single
+	providers []provider.ProxyProvider
+}
+
+func (f *Fallback) Now() string {
+	proxy := f.findAliveProxy()
+	return proxy.Name()
+}
+
+func (f *Fallback) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
+	proxy := f.findAliveProxy()
+	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()
+	pc, err := proxy.DialUDP(metadata)
+	if err == nil {
+		pc.AppendToChains(f)
+	}
+	return pc, err
+}
+
+func (f *Fallback) SupportUDP() bool {
+	proxy := f.findAliveProxy()
+	return proxy.SupportUDP()
+}
+
+func (f *Fallback) MarshalJSON() ([]byte, error) {
+	var all []string
+	for _, proxy := range f.proxies() {
+		all = append(all, proxy.Name())
+	}
+	return json.Marshal(map[string]interface{}{
+		"type": f.Type().String(),
+		"now":  f.Now(),
+		"all":  all,
+	})
+}
+
+func (f *Fallback) proxies() []C.Proxy {
+	elm, _, _ := f.single.Do(func() (interface{}, error) {
+		return getProvidersProxies(f.providers), nil
+	})
+
+	return elm.([]C.Proxy)
+}
+
+func (f *Fallback) findAliveProxy() C.Proxy {
+	proxies := f.proxies()
+	for _, proxy := range proxies {
+		if proxy.Alive() {
+			return proxy
+		}
+	}
+
+	return f.proxies()[0]
+}
+
+func NewFallback(name string, providers []provider.ProxyProvider) *Fallback {
+	return &Fallback{
+		Base:      outbound.NewBase(name, C.Fallback, false),
+		single:    singledo.NewSingle(defaultGetProxiesDuration),
+		providers: providers,
+	}
+}
--- a/adapters/outboundgroup/loadbalance.go
+++ b/adapters/outboundgroup/loadbalance.go
@ -0,0 +1,128 @@
+package outboundgroup
+
+import (
+	"context"
+	"encoding/json"
+	"net"
+
+	"github.com/Dreamacro/clash/adapters/outbound"
+	"github.com/Dreamacro/clash/adapters/provider"
+	"github.com/Dreamacro/clash/common/murmur3"
+	"github.com/Dreamacro/clash/common/singledo"
+	C "github.com/Dreamacro/clash/constant"
+
+	"golang.org/x/net/publicsuffix"
+)
+
+type LoadBalance struct {
+	*outbound.Base
+	single    *singledo.Single
+	maxRetry  int
+	providers []provider.ProxyProvider
+}
+
+func getKey(metadata *C.Metadata) string {
+	if metadata.Host != "" {
+		// ip host
+		if ip := net.ParseIP(metadata.Host); ip != nil {
+			return metadata.Host
+		}
+
+		if etld, err := publicsuffix.EffectiveTLDPlusOne(metadata.Host); err == nil {
+			return etld
+		}
+	}
+
+	if metadata.DstIP == nil {
+		return ""
+	}
+
+	return metadata.DstIP.String()
+}
+
+func jumpHash(key uint64, buckets int32) int32 {
+	var b, j int64
+
+	for j < int64(buckets) {
+		b = j
+		key = key*2862933555777941757 + 1
+		j = int64(float64(b+1) * (float64(int64(1)<<31) / float64((key>>33)+1)))
+	}
+
+	return int32(b)
+}
+
+func (lb *LoadBalance) DialContext(ctx context.Context, metadata *C.Metadata) (c C.Conn, err error) {
+	defer func() {
+		if err == nil {
+			c.AppendToChains(lb)
+		}
+	}()
+
+	key := uint64(murmur3.Sum32([]byte(getKey(metadata))))
+	proxies := lb.proxies()
+	buckets := int32(len(proxies))
+	for i := 0; i < lb.maxRetry; i, key = i+1, key+1 {
+		idx := jumpHash(key, buckets)
+		proxy := proxies[idx]
+		if proxy.Alive() {
+			c, err = proxy.DialContext(ctx, metadata)
+			return
+		}
+	}
+	c, err = proxies[0].DialContext(ctx, metadata)
+	return
+}
+
+func (lb *LoadBalance) DialUDP(metadata *C.Metadata) (pc C.PacketConn, err error) {
+	defer func() {
+		if err == nil {
+			pc.AppendToChains(lb)
+		}
+	}()
+
+	key := uint64(murmur3.Sum32([]byte(getKey(metadata))))
+	proxies := lb.proxies()
+	buckets := int32(len(proxies))
+	for i := 0; i < lb.maxRetry; i, key = i+1, key+1 {
+		idx := jumpHash(key, buckets)
+		proxy := proxies[idx]
+		if proxy.Alive() {
+			return proxy.DialUDP(metadata)
+		}
+	}
+
+	return proxies[0].DialUDP(metadata)
+}
+
+func (lb *LoadBalance) SupportUDP() bool {
+	return true
+}
+
+func (lb *LoadBalance) proxies() []C.Proxy {
+	elm, _, _ := lb.single.Do(func() (interface{}, error) {
+		return getProvidersProxies(lb.providers), nil
+	})
+
+	return elm.([]C.Proxy)
+}
+
+func (lb *LoadBalance) MarshalJSON() ([]byte, error) {
+	var all []string
+	for _, proxy := range lb.proxies() {
+		all = append(all, proxy.Name())
+	}
+	return json.Marshal(map[string]interface{}{
+		"type": lb.Type().String(),
+		"all":  all,
+	})
+}
+
+func NewLoadBalance(name string, providers []provider.ProxyProvider) *LoadBalance {
+	return &LoadBalance{
+		Base:      outbound.NewBase(name, C.LoadBalance, false),
+		single:    singledo.NewSingle(defaultGetProxiesDuration),
+		maxRetry:  3,
+		providers: providers,
+	}
+}
--- a/adapters/outboundgroup/parser.go
+++ b/adapters/outboundgroup/parser.go
@ -0,0 +1,144 @@
+package outboundgroup
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/Dreamacro/clash/adapters/provider"
+	"github.com/Dreamacro/clash/common/structure"
+	C "github.com/Dreamacro/clash/constant"
+)
+
+var (
+	errFormat            = errors.New("format error")
+	errType              = errors.New("unsupport type")
+	errMissUse           = errors.New("`use` field should not be empty")
+	errMissProxy         = errors.New("`use` or `proxies` missing")
+	errMissHealthCheck   = errors.New("`url` or `interval` missing")
+	errDuplicateProvider = errors.New("`duplicate provider name")
+)
+
+type GroupCommonOption struct {
+	Name     string   `group:"name"`
+	Type     string   `group:"type"`
+	Proxies  []string `group:"proxies,omitempty"`
+	Use      []string `group:"use,omitempty"`
+	URL      string   `group:"url,omitempty"`
+	Interval int      `group:"interval,omitempty"`
+}
+
+func ParseProxyGroup(config map[string]interface{}, proxyMap map[string]C.Proxy, providersMap map[string]provider.ProxyProvider) (C.ProxyAdapter, error) {
+	decoder := structure.NewDecoder(structure.Option{TagName: "group", WeaklyTypedInput: true})
+
+	groupOption := &GroupCommonOption{}
+	if err := decoder.Decode(config, groupOption); err != nil {
+		return nil, errFormat
+	}
+
+	if groupOption.Type == "" || groupOption.Name == "" {
+		return nil, errFormat
+	}
+
+	groupName := groupOption.Name
+
+	providers := []provider.ProxyProvider{}
+
+	if len(groupOption.Proxies) == 0 && len(groupOption.Use) == 0 {
+		return nil, errMissProxy
+	}
+
+	if len(groupOption.Proxies) != 0 {
+		ps, err := getProxies(proxyMap, groupOption.Proxies)
+		if err != nil {
+			return nil, err
+		}
+
+		// if Use not empty, drop health check options
+		if len(groupOption.Use) != 0 {
+			hc := provider.NewHealthCheck(ps, "", 0)
+			pd, err := provider.NewCompatibleProvider(groupName, ps, hc)
+			if err != nil {
+				return nil, err
+			}
+
+			providers = append(providers, pd)
+		} else {
+			// select don't need health check
+			if groupOption.Type == "select" {
+				hc := provider.NewHealthCheck(ps, "", 0)
+				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))
+				pd, err := provider.NewCompatibleProvider(groupName, ps, hc)
+				if err != nil {
+					return nil, err
+				}
+
+				providers = append(providers, pd)
+				providersMap[groupName] = pd
+			}
+		}
+	}
+
+	if len(groupOption.Use) != 0 {
+		list, err := getProviders(providersMap, groupOption.Use)
+		if err != nil {
+			return nil, err
+		}
+		providers = append(providers, list...)
+	}
+
+	var group C.ProxyAdapter
+	switch groupOption.Type {
+	case "url-test":
+		group = NewURLTest(groupName, providers)
+	case "select":
+		group = NewSelector(groupName, providers)
+	case "fallback":
+		group = NewFallback(groupName, providers)
+	case "load-balance":
+		group = NewLoadBalance(groupName, providers)
+	default:
+		return nil, fmt.Errorf("%w: %s", errType, groupOption.Type)
+	}
+
+	return group, nil
+}
+
+func getProxies(mapping map[string]C.Proxy, list []string) ([]C.Proxy, error) {
+	var ps []C.Proxy
+	for _, name := range list {
+		p, ok := mapping[name]
+		if !ok {
+			return nil, fmt.Errorf("'%s' not found", name)
+		}
+		ps = append(ps, p)
+	}
+	return ps, nil
+}
+
+func getProviders(mapping map[string]provider.ProxyProvider, list []string) ([]provider.ProxyProvider, error) {
+	var ps []provider.ProxyProvider
+	for _, name := range list {
+		p, ok := mapping[name]
+		if !ok {
+			return nil, fmt.Errorf("'%s' not found", name)
+		}
+
+		if p.VehicleType() == provider.Compatible {
+			return nil, fmt.Errorf("proxy group %s can't contains in `use`", name)
+		}
+		ps = append(ps, p)
+	}
+	return ps, nil
+}
--- a/adapters/outboundgroup/selector.go
+++ b/adapters/outboundgroup/selector.go
@ -0,0 +1,85 @@
+package outboundgroup
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+
+	"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 Selector struct {
+	*outbound.Base
+	single    *singledo.Single
+	selected  C.Proxy
+	providers []provider.ProxyProvider
+}
+
+func (s *Selector) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
+	c, err := s.selected.DialContext(ctx, metadata)
+	if err == nil {
+		c.AppendToChains(s)
+	}
+	return c, err
+}
+
+func (s *Selector) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
+	pc, err := s.selected.DialUDP(metadata)
+	if err == nil {
+		pc.AppendToChains(s)
+	}
+	return pc, err
+}
+
+func (s *Selector) SupportUDP() bool {
+	return s.selected.SupportUDP()
+}
+
+func (s *Selector) MarshalJSON() ([]byte, error) {
+	var all []string
+	for _, proxy := range s.proxies() {
+		all = append(all, proxy.Name())
+	}
+
+	return json.Marshal(map[string]interface{}{
+		"type": s.Type().String(),
+		"now":  s.Now(),
+		"all":  all,
+	})
+}
+
+func (s *Selector) Now() string {
+	return s.selected.Name()
+}
+
+func (s *Selector) Set(name string) error {
+	for _, proxy := range s.proxies() {
+		if proxy.Name() == name {
+			s.selected = proxy
+			return nil
+		}
+	}
+
+	return errors.New("Proxy does not exist")
+}
+
+func (s *Selector) proxies() []C.Proxy {
+	elm, _, _ := s.single.Do(func() (interface{}, error) {
+		return getProvidersProxies(s.providers), nil
+	})
+
+	return elm.([]C.Proxy)
+}
+
+func NewSelector(name string, providers []provider.ProxyProvider) *Selector {
+	selected := providers[0].Proxies()[0]
+	return &Selector{
+		Base:      outbound.NewBase(name, C.Selector, false),
+		single:    singledo.NewSingle(defaultGetProxiesDuration),
+		providers: providers,
+		selected:  selected,
+	}
+}
--- a/adapters/outboundgroup/urltest.go
+++ b/adapters/outboundgroup/urltest.go
@ -0,0 +1,94 @@
+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 URLTest struct {
+	*outbound.Base
+	single     *singledo.Single
+	fastSingle *singledo.Single
+	providers  []provider.ProxyProvider
+}
+
+func (u *URLTest) Now() string {
+	return u.fast().Name()
+}
+
+func (u *URLTest) DialContext(ctx context.Context, metadata *C.Metadata) (c C.Conn, err error) {
+	c, err = u.fast().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().DialUDP(metadata)
+	if err == nil {
+		pc.AppendToChains(u)
+	}
+	return pc, err
+}
+
+func (u *URLTest) proxies() []C.Proxy {
+	elm, _, _ := u.single.Do(func() (interface{}, error) {
+		return getProvidersProxies(u.providers), nil
+	})
+
+	return elm.([]C.Proxy)
+}
+
+func (u *URLTest) fast() C.Proxy {
+	elm, _, _ := u.fastSingle.Do(func() (interface{}, error) {
+		proxies := u.proxies()
+		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
+			}
+		}
+		return fast, nil
+	})
+
+	return elm.(C.Proxy)
+}
+
+func (u *URLTest) SupportUDP() bool {
+	return u.fast().SupportUDP()
+}
+
+func (u *URLTest) MarshalJSON() ([]byte, error) {
+	var all []string
+	for _, proxy := range u.proxies() {
+		all = append(all, proxy.Name())
+	}
+	return json.Marshal(map[string]interface{}{
+		"type": u.Type().String(),
+		"now":  u.Now(),
+		"all":  all,
+	})
+}
+
+func NewURLTest(name string, providers []provider.ProxyProvider) *URLTest {
+	return &URLTest{
+		Base:       outbound.NewBase(name, C.URLTest, false),
+		single:     singledo.NewSingle(defaultGetProxiesDuration),
+		fastSingle: singledo.NewSingle(time.Second * 10),
+		providers:  providers,
+	}
+}
--- a/adapters/provider/healthcheck.go
+++ b/adapters/provider/healthcheck.go
@ -0,0 +1,70 @@
+package provider
+
+import (
+	"context"
+	"time"
+
+	C "github.com/Dreamacro/clash/constant"
+)
+
+const (
+	defaultURLTestTimeout = time.Second * 5
+)
+
+type HealthCheckOption struct {
+	URL      string
+	Interval uint
+}
+
+type HealthCheck struct {
+	url      string
+	proxies  []C.Proxy
+	interval uint
+	done     chan struct{}
+}
+
+func (hc *HealthCheck) process() {
+	ticker := time.NewTicker(time.Duration(hc.interval) * time.Second)
+
+	go hc.check()
+	for {
+		select {
+		case <-ticker.C:
+			hc.check()
+		case <-hc.done:
+			ticker.Stop()
+			return
+		}
+	}
+}
+
+func (hc *HealthCheck) setProxy(proxies []C.Proxy) {
+	hc.proxies = proxies
+}
+
+func (hc *HealthCheck) auto() bool {
+	return hc.interval != 0
+}
+
+func (hc *HealthCheck) check() {
+	ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout)
+	for _, proxy := range hc.proxies {
+		go proxy.URLTest(ctx, hc.url)
+	}
+
+	<-ctx.Done()
+	cancel()
+}
+
+func (hc *HealthCheck) close() {
+	hc.done <- struct{}{}
+}
+
+func NewHealthCheck(proxies []C.Proxy, url string, interval uint) *HealthCheck {
+	return &HealthCheck{
+		proxies:  proxies,
+		url:      url,
+		interval: interval,
+		done:     make(chan struct{}, 1),
+	}
+}
--- a/adapters/provider/parser.go
+++ b/adapters/provider/parser.go
@ -7,19 +7,16 @@ 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")
-	errSubPath     = errors.New("path is not subpath of home directory")
 )

 type healthCheckSchema struct {
 	Enable   bool   `provider:"enable"`
 	URL      string `provider:"url"`
 	Interval int    `provider:"interval"`
-	Lazy     bool   `provider:"lazy,omitempty"`
 }

 type proxyProviderSchema struct {
@ -27,44 +24,35 @@ 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]any) (types.ProxyProvider, error) {
+func ParseProxyProvider(name string, mapping map[string]interface{}) (ProxyProvider, error) {
 	decoder := structure.NewDecoder(structure.Option{TagName: "provider", WeaklyTypedInput: true})

-	schema := &proxyProviderSchema{
-		HealthCheck: healthCheckSchema{
-			Lazy: true,
-		},
-	}
+	schema := &proxyProviderSchema{}
 	if err := decoder.Decode(mapping, schema); err != nil {
 		return nil, err
 	}

-	var hcInterval uint
+	var hcInterval uint = 0
 	if schema.HealthCheck.Enable {
 		hcInterval = uint(schema.HealthCheck.Interval)
 	}
-	hc := NewHealthCheck([]C.Proxy{}, schema.HealthCheck.URL, hcInterval, schema.HealthCheck.Lazy)
+	hc := NewHealthCheck([]C.Proxy{}, schema.HealthCheck.URL, hcInterval)

 	path := C.Path.Resolve(schema.Path)

-	var vehicle types.Vehicle
+	var vehicle Vehicle
 	switch schema.Type {
 	case "file":
 		vehicle = NewFileVehicle(path)
 	case "http":
-		if !C.Path.IsSubPath(path) {
-			return nil, fmt.Errorf("%w: %s", errSubPath, path)
-		}
 		vehicle = NewHTTPVehicle(schema.URL, path)
 	default:
 		return nil, fmt.Errorf("%w: %s", errVehicleType, schema.Type)
 	}

 	interval := time.Duration(uint(schema.Interval)) * time.Second
-	filter := schema.Filter
-	return NewProxySetProvider(name, interval, filter, vehicle, hc)
+	return NewProxySetProvider(name, interval, vehicle, hc), nil
 }
--- a/adapters/provider/provider.go
+++ b/adapters/provider/provider.go
@ -0,0 +1,322 @@
+package provider
+
+import (
+	"bytes"
+	"crypto/md5"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"time"
+
+	"github.com/Dreamacro/clash/adapters/outbound"
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/log"
+
+	"gopkg.in/yaml.v2"
+)
+
+const (
+	ReservedName = "default"
+
+	fileMode = 0666
+)
+
+// 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
+	Reload() error
+	Destroy() error
+}
+
+// ProxyProvider interface
+type ProxyProvider interface {
+	Provider
+	Proxies() []C.Proxy
+	HealthCheck()
+	Update() error
+}
+
+type ProxySchema struct {
+	Proxies []map[string]interface{} `yaml:"proxies"`
+}
+
+type ProxySetProvider struct {
+	name        string
+	vehicle     Vehicle
+	hash        [16]byte
+	proxies     []C.Proxy
+	healthCheck *HealthCheck
+	ticker      *time.Ticker
+	updatedAt   *time.Time
+}
+
+func (pp *ProxySetProvider) MarshalJSON() ([]byte, error) {
+	return json.Marshal(map[string]interface{}{
+		"name":        pp.Name(),
+		"type":        pp.Type().String(),
+		"vehicleType": pp.VehicleType().String(),
+		"proxies":     pp.Proxies(),
+		"updatedAt":   pp.updatedAt,
+	})
+}
+
+func (pp *ProxySetProvider) Name() string {
+	return pp.name
+}
+
+func (pp *ProxySetProvider) Reload() error {
+	return nil
+}
+
+func (pp *ProxySetProvider) HealthCheck() {
+	pp.healthCheck.check()
+}
+
+func (pp *ProxySetProvider) Update() error {
+	return pp.pull()
+}
+
+func (pp *ProxySetProvider) Destroy() error {
+	pp.healthCheck.close()
+
+	if pp.ticker != nil {
+		pp.ticker.Stop()
+	}
+
+	return nil
+}
+
+func (pp *ProxySetProvider) Initial() error {
+	var buf []byte
+	var err error
+	if stat, err := os.Stat(pp.vehicle.Path()); err == nil {
+		buf, err = ioutil.ReadFile(pp.vehicle.Path())
+		modTime := stat.ModTime()
+		pp.updatedAt = &modTime
+	} else {
+		buf, err = pp.vehicle.Read()
+	}
+
+	if err != nil {
+		return err
+	}
+
+	proxies, err := pp.parse(buf)
+	if err != nil {
+		// parse local file error, fallback to remote
+		buf, err = pp.vehicle.Read()
+		if err != nil {
+			return err
+		}
+	}
+
+	if err := ioutil.WriteFile(pp.vehicle.Path(), buf, fileMode); err != nil {
+		return err
+	}
+
+	pp.hash = md5.Sum(buf)
+	pp.setProxies(proxies)
+
+	// pull proxies automatically
+	if pp.ticker != nil {
+		go pp.pullLoop()
+	}
+
+	return nil
+}
+
+func (pp *ProxySetProvider) VehicleType() VehicleType {
+	return pp.vehicle.Type()
+}
+
+func (pp *ProxySetProvider) Type() ProviderType {
+	return Proxy
+}
+
+func (pp *ProxySetProvider) Proxies() []C.Proxy {
+	return pp.proxies
+}
+
+func (pp *ProxySetProvider) pullLoop() {
+	for range pp.ticker.C {
+		if err := pp.pull(); err != nil {
+			log.Warnln("[Provider] %s pull error: %s", pp.Name(), err.Error())
+		}
+	}
+}
+
+func (pp *ProxySetProvider) pull() error {
+	buf, err := pp.vehicle.Read()
+	if err != nil {
+		return err
+	}
+
+	now := time.Now()
+	hash := md5.Sum(buf)
+	if bytes.Equal(pp.hash[:], hash[:]) {
+		log.Debugln("[Provider] %s's proxies doesn't change", pp.Name())
+		pp.updatedAt = &now
+		return nil
+	}
+
+	proxies, err := pp.parse(buf)
+	if err != nil {
+		return err
+	}
+	log.Infoln("[Provider] %s's proxies update", pp.Name())
+
+	if err := ioutil.WriteFile(pp.vehicle.Path(), buf, fileMode); err != nil {
+		return err
+	}
+
+	pp.updatedAt = &now
+	pp.hash = hash
+	pp.setProxies(proxies)
+
+	return nil
+}
+
+func (pp *ProxySetProvider) parse(buf []byte) ([]C.Proxy, 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)
+	go pp.healthCheck.check()
+}
+
+func NewProxySetProvider(name string, interval time.Duration, vehicle Vehicle, hc *HealthCheck) *ProxySetProvider {
+	var ticker *time.Ticker
+	if interval != 0 {
+		ticker = time.NewTicker(interval)
+	}
+
+	if hc.auto() {
+		go hc.process()
+	}
+
+	return &ProxySetProvider{
+		name:        name,
+		vehicle:     vehicle,
+		proxies:     []C.Proxy{},
+		healthCheck: hc,
+		ticker:      ticker,
+	}
+}
+
+type CompatibleProvider struct {
+	name        string
+	healthCheck *HealthCheck
+	proxies     []C.Proxy
+}
+
+func (cp *CompatibleProvider) MarshalJSON() ([]byte, error) {
+	return json.Marshal(map[string]interface{}{
+		"name":        cp.Name(),
+		"type":        cp.Type().String(),
+		"vehicleType": cp.VehicleType().String(),
+		"proxies":     cp.Proxies(),
+	})
+}
+
+func (cp *CompatibleProvider) Name() string {
+	return cp.name
+}
+
+func (cp *CompatibleProvider) Reload() error {
+	return nil
+}
+
+func (cp *CompatibleProvider) Destroy() error {
+	cp.healthCheck.close()
+	return nil
+}
+
+func (cp *CompatibleProvider) HealthCheck() {
+	cp.healthCheck.check()
+}
+
+func (cp *CompatibleProvider) Update() error {
+	return nil
+}
+
+func (cp *CompatibleProvider) Initial() error {
+	return nil
+}
+
+func (cp *CompatibleProvider) VehicleType() VehicleType {
+	return Compatible
+}
+
+func (cp *CompatibleProvider) Type() ProviderType {
+	return Proxy
+}
+
+func (cp *CompatibleProvider) Proxies() []C.Proxy {
+	return cp.proxies
+}
+
+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")
+	}
+
+	if hc.auto() {
+		go hc.process()
+	}
+
+	return &CompatibleProvider{
+		name:        name,
+		proxies:     proxies,
+		healthCheck: hc,
+	}, nil
+}
--- a/adapters/provider/vehicle.go
+++ b/adapters/provider/vehicle.go
@ -2,23 +2,48 @@ package provider

 import (
 	"context"
-	"io"
-	"net"
+	"io/ioutil"
 	"net/http"
-	"net/url"
-	"os"
 	"time"

 	"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() types.VehicleType {
-	return types.File
+func (f *FileVehicle) Type() VehicleType {
+	return File
 }

 func (f *FileVehicle) Path() string {
@ -26,7 +51,7 @@ func (f *FileVehicle) Path() string {
 }

 func (f *FileVehicle) Read() ([]byte, error) {
-	return os.ReadFile(f.path)
+	return ioutil.ReadFile(f.path)
 }

 func NewFileVehicle(path string) *FileVehicle {
@ -38,8 +63,8 @@ type HTTPVehicle struct {
 	path string
 }

-func (h *HTTPVehicle) Type() types.VehicleType {
-	return types.HTTP
+func (h *HTTPVehicle) Type() VehicleType {
+	return HTTP
 }

 func (h *HTTPVehicle) Path() string {
@ -50,21 +75,10 @@ func (h *HTTPVehicle) Read() ([]byte, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*20)
 	defer cancel()

-	uri, err := url.Parse(h.url)
+	req, err := http.NewRequest(http.MethodGet, h.url, nil)
 	if err != nil {
 		return nil, err
 	}
-
-	req, err := http.NewRequest(http.MethodGet, uri.String(), nil)
-	if err != nil {
-		return nil, err
-	}
-
-	if user := uri.User; user != nil {
-		password, _ := user.Password()
-		req.SetBasicAuth(user.Username(), password)
-	}
-
 	req = req.WithContext(ctx)

 	transport := &http.Transport{
@ -73,9 +87,7 @@ func (h *HTTPVehicle) Read() ([]byte, error) {
 		IdleConnTimeout:       90 * time.Second,
 		TLSHandshakeTimeout:   10 * time.Second,
 		ExpectContinueTimeout: 1 * time.Second,
-		DialContext: func(ctx context.Context, network, address string) (net.Conn, error) {
-			return dialer.DialContext(ctx, network, address)
-		},
+		DialContext:           dialer.DialContext,
 	}

 	client := http.Client{Transport: transport}
@ -83,9 +95,8 @@ func (h *HTTPVehicle) Read() ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	defer resp.Body.Close()

-	buf, err := io.ReadAll(resp.Body)
+	buf, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
 		return nil, err
 	}
--- a/common/batch/batch.go
+++ b/common/batch/batch.go
@ -1,105 +0,0 @@
-package batch
-
-import (
-	"context"
-	"sync"
-)
-
-type Option = func(b *Batch)
-
-type Result struct {
-	Value any
-	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() (any, 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
-}
--- a/common/batch/batch_test.go
+++ b/common/batch/batch_test.go
@ -1,83 +0,0 @@
-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() (any, error) {
-		time.Sleep(time.Millisecond * 100)
-		return "foo", nil
-	})
-	b.Go("bar", func() (any, 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() (any, 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() (any, error) {
-		time.Sleep(time.Millisecond * 100)
-		return nil, errors.New("test error")
-	})
-
-	b.Go("ctx", func() (any, 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)
-}
--- a/common/cache/cache.go
+++ b/common/cache/cache.go
@ -0,0 +1,106 @@
+package cache
+
+import (
+	"runtime"
+	"sync"
+	"time"
+)
+
+// Cache store element with a expired time
+type Cache struct {
+	*cache
+}
+
+type cache struct {
+	mapping sync.Map
+	janitor *janitor
+}
+
+type element struct {
+	Expired time.Time
+	Payload interface{}
+}
+
+// Put element in Cache with its ttl
+func (c *cache) Put(key interface{}, payload interface{}, ttl time.Duration) {
+	c.mapping.Store(key, &element{
+		Payload: payload,
+		Expired: time.Now().Add(ttl),
+	})
+}
+
+// Get element in Cache, and drop when it expired
+func (c *cache) Get(key interface{}) interface{} {
+	item, exist := c.mapping.Load(key)
+	if !exist {
+		return nil
+	}
+	elm := item.(*element)
+	// expired
+	if time.Since(elm.Expired) > 0 {
+		c.mapping.Delete(key)
+		return nil
+	}
+	return elm.Payload
+}
+
+// GetWithExpire element in Cache with Expire Time
+func (c *cache) GetWithExpire(key interface{}) (payload interface{}, expired time.Time) {
+	item, exist := c.mapping.Load(key)
+	if !exist {
+		return
+	}
+	elm := item.(*element)
+	// expired
+	if time.Since(elm.Expired) > 0 {
+		c.mapping.Delete(key)
+		return
+	}
+	return elm.Payload, elm.Expired
+}
+
+func (c *cache) cleanup() {
+	c.mapping.Range(func(k, v interface{}) bool {
+		key := k.(string)
+		elm := v.(*element)
+		if time.Since(elm.Expired) > 0 {
+			c.mapping.Delete(key)
+		}
+		return true
+	})
+}
+
+type janitor struct {
+	interval time.Duration
+	stop     chan struct{}
+}
+
+func (j *janitor) process(c *cache) {
+	ticker := time.NewTicker(j.interval)
+	for {
+		select {
+		case <-ticker.C:
+			c.cleanup()
+		case <-j.stop:
+			ticker.Stop()
+			return
+		}
+	}
+}
+
+func stopJanitor(c *Cache) {
+	c.janitor.stop <- struct{}{}
+}
+
+// New return *Cache
+func New(interval time.Duration) *Cache {
+	j := &janitor{
+		interval: interval,
+		stop:     make(chan struct{}),
+	}
+	c := &cache{janitor: j}
+	go j.process(c)
+	C := &Cache{c}
+	runtime.SetFinalizer(C, stopJanitor)
+	return C
+}
--- a/common/cache/cache_test.go
+++ b/common/cache/cache_test.go
@ -0,0 +1,70 @@
+package cache
+
+import (
+	"runtime"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCache_Basic(t *testing.T) {
+	interval := 200 * time.Millisecond
+	ttl := 20 * time.Millisecond
+	c := New(interval)
+	c.Put("int", 1, ttl)
+	c.Put("string", "a", ttl)
+
+	i := c.Get("int")
+	assert.Equal(t, i.(int), 1, "should recv 1")
+
+	s := c.Get("string")
+	assert.Equal(t, s.(string), "a", "should recv 'a'")
+}
+
+func TestCache_TTL(t *testing.T) {
+	interval := 200 * time.Millisecond
+	ttl := 20 * time.Millisecond
+	now := time.Now()
+	c := New(interval)
+	c.Put("int", 1, ttl)
+	c.Put("int2", 2, ttl)
+
+	i := c.Get("int")
+	_, expired := c.GetWithExpire("int2")
+	assert.Equal(t, i.(int), 1, "should recv 1")
+	assert.True(t, now.Before(expired))
+
+	time.Sleep(ttl * 2)
+	i = c.Get("int")
+	j, _ := c.GetWithExpire("int2")
+	assert.Nil(t, i, "should recv nil")
+	assert.Nil(t, j, "should recv nil")
+}
+
+func TestCache_AutoCleanup(t *testing.T) {
+	interval := 10 * time.Millisecond
+	ttl := 15 * time.Millisecond
+	c := New(interval)
+	c.Put("int", 1, ttl)
+
+	time.Sleep(ttl * 2)
+	i := c.Get("int")
+	j, _ := c.GetWithExpire("int")
+	assert.Nil(t, i, "should recv nil")
+	assert.Nil(t, j, "should recv nil")
+}
+
+func TestCache_AutoGC(t *testing.T) {
+	sign := make(chan struct{})
+	go func() {
+		interval := 10 * time.Millisecond
+		ttl := 15 * time.Millisecond
+		c := New(interval)
+		c.Put("int", 1, ttl)
+		sign <- struct{}{}
+	}()
+
+	<-sign
+	runtime.GC()
+}
--- a/common/cache/lrucache.go
+++ b/common/cache/lrucache.go
@ -12,7 +12,7 @@ import (
 type Option func(*LruCache)

 // EvictCallback is used to get a callback when a cache entry is evicted
-type EvictCallback = func(key any, value any)
+type EvictCallback = func(key interface{}, value interface{})

 // WithEvict set the evict callback
 func WithEvict(cb EvictCallback) Option {
@ -42,14 +42,6 @@ func WithSize(maxSize int) Option {
 	}
 }

-// WithStale decide whether Stale return is enabled.
-// If this feature is enabled, element will not get Evicted according to `WithAge`.
-func WithStale(stale bool) Option {
-	return func(l *LruCache) {
-		l.staleReturn = stale
-	}
-}
-
 // LruCache is a thread-safe, in-memory lru-cache that evicts the
 // least recently used entries from memory when (if set) the entries are
 // older than maxAge (in seconds).  Use the New constructor to create one.
@ -57,18 +49,17 @@ type LruCache struct {
 	maxAge         int64
 	maxSize        int
 	mu             sync.Mutex
-	cache          map[any]*list.Element
+	cache          map[interface{}]*list.Element
 	lru            *list.List // Front is least-recent
 	updateAgeOnGet bool
-	staleReturn    bool
 	onEvict        EvictCallback
 }

-// New creates an LruCache
-func New(options ...Option) *LruCache {
+// NewLRUCache creates an LruCache
+func NewLRUCache(options ...Option) *LruCache {
 	lc := &LruCache{
 		lru:   list.New(),
-		cache: make(map[any]*list.Element),
+		cache: make(map[interface{}]*list.Element),
 	}

 	for _, option := range options {
@ -78,33 +69,36 @@ func New(options ...Option) *LruCache {
 	return lc
 }

-// Get returns the any representation of a cached response and a bool
+// Get returns the interface{} representation of a cached response and a bool
 // set to true if the key was found.
-func (c *LruCache) Get(key any) (any, bool) {
-	entry := c.get(key)
-	if entry == nil {
+func (c *LruCache) Get(key interface{}) (interface{}, bool) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	le, ok := c.cache[key]
+	if !ok {
 		return nil, false
 	}
+
+	if c.maxAge > 0 && le.Value.(*entry).expires <= time.Now().Unix() {
+		c.deleteElement(le)
+		c.maybeDeleteOldest()
+
+		return nil, false
+	}
+
+	c.lru.MoveToBack(le)
+	entry := le.Value.(*entry)
+	if c.maxAge > 0 && c.updateAgeOnGet {
+		entry.expires = time.Now().Unix() + c.maxAge
+	}
 	value := entry.value

 	return value, true
 }

-// GetWithExpire returns the any representation of a cached response,
-// a time.Time Give expected expires,
-// and a bool set to true if the key was found.
-// This method will NOT check the maxAge of element and will NOT update the expires.
-func (c *LruCache) GetWithExpire(key any) (any, time.Time, bool) {
-	entry := c.get(key)
-	if entry == nil {
-		return nil, time.Time{}, false
-	}
-
-	return entry.value, time.Unix(entry.expires, 0), true
-}
-
 // Exist returns if key exist in cache but not put item to the head of linked list
-func (c *LruCache) Exist(key any) bool {
+func (c *LruCache) Exist(key interface{}) bool {
 	c.mu.Lock()
 	defer c.mu.Unlock()

@ -112,28 +106,23 @@ func (c *LruCache) Exist(key any) bool {
 	return ok
 }

-// Set stores the any representation of a response for a given key.
-func (c *LruCache) Set(key any, value any) {
+// Set stores the interface{} representation of a response for a given key.
+func (c *LruCache) Set(key interface{}, value interface{}) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
 	expires := int64(0)
 	if c.maxAge > 0 {
 		expires = time.Now().Unix() + c.maxAge
 	}
-	c.SetWithExpire(key, value, time.Unix(expires, 0))
-}
-
-// SetWithExpire stores the any representation of a response for a given key and given expires.
-// The expires time will round to second.
-func (c *LruCache) SetWithExpire(key any, value any, expires time.Time) {
-	c.mu.Lock()
-	defer c.mu.Unlock()

 	if le, ok := c.cache[key]; ok {
 		c.lru.MoveToBack(le)
 		e := le.Value.(*entry)
 		e.value = value
-		e.expires = expires.Unix()
+		e.expires = expires
 	} else {
-		e := &entry{key: key, value: value, expires: expires.Unix()}
+		e := &entry{key: key, value: value, expires: expires}
 		c.cache[key] = c.lru.PushBack(e)

 		if c.maxSize > 0 {
@ -146,49 +135,8 @@ func (c *LruCache) SetWithExpire(key any, value any, expires time.Time) {
 	c.maybeDeleteOldest()
 }

-// CloneTo clone and overwrite elements to another LruCache
-func (c *LruCache) CloneTo(n *LruCache) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	n.mu.Lock()
-	defer n.mu.Unlock()
-
-	n.lru = list.New()
-	n.cache = make(map[any]*list.Element)
-
-	for e := c.lru.Front(); e != nil; e = e.Next() {
-		elm := e.Value.(*entry)
-		n.cache[elm.key] = n.lru.PushBack(elm)
-	}
-}
-
-func (c *LruCache) get(key any) *entry {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	le, ok := c.cache[key]
-	if !ok {
-		return nil
-	}
-
-	if !c.staleReturn && c.maxAge > 0 && le.Value.(*entry).expires <= time.Now().Unix() {
-		c.deleteElement(le)
-		c.maybeDeleteOldest()
-
-		return nil
-	}
-
-	c.lru.MoveToBack(le)
-	entry := le.Value.(*entry)
-	if c.maxAge > 0 && c.updateAgeOnGet {
-		entry.expires = time.Now().Unix() + c.maxAge
-	}
-	return entry
-}
-
 // Delete removes the value associated with a key.
-func (c *LruCache) Delete(key any) {
+func (c *LruCache) Delete(key string) {
 	c.mu.Lock()

 	if le, ok := c.cache[key]; ok {
@ -199,7 +147,7 @@ func (c *LruCache) Delete(key any) {
 }

 func (c *LruCache) maybeDeleteOldest() {
-	if !c.staleReturn && c.maxAge > 0 {
+	if c.maxAge > 0 {
 		now := time.Now().Unix()
 		for le := c.lru.Front(); le != nil && le.Value.(*entry).expires <= now; le = c.lru.Front() {
 			c.deleteElement(le)
@ -217,7 +165,7 @@ func (c *LruCache) deleteElement(le *list.Element) {
 }

 type entry struct {
-	key     any
-	value   any
+	key     interface{}
+	value   interface{}
 	expires int64
 }
--- a/common/cache/lrucache_test.go
+++ b/common/cache/lrucache_test.go
@ -19,7 +19,7 @@ var entries = []struct {
 }

 func TestLRUCache(t *testing.T) {
-	c := New()
+	c := NewLRUCache()

 	for _, e := range entries {
 		c.Set(e.key, e.value)
@ -45,7 +45,7 @@ func TestLRUCache(t *testing.T) {
 }

 func TestLRUMaxAge(t *testing.T) {
-	c := New(WithAge(86400))
+	c := NewLRUCache(WithAge(86400))

 	now := time.Now().Unix()
 	expected := now + 86400
@ -88,7 +88,7 @@ func TestLRUMaxAge(t *testing.T) {
 }

 func TestLRUpdateOnGet(t *testing.T) {
-	c := New(WithAge(86400), WithUpdateAgeOnGet())
+	c := NewLRUCache(WithAge(86400), WithUpdateAgeOnGet())

 	now := time.Now().Unix()
 	expires := now + 86400/2
@ -103,7 +103,7 @@ func TestLRUpdateOnGet(t *testing.T) {
 }

 func TestMaxSize(t *testing.T) {
-	c := New(WithSize(2))
+	c := NewLRUCache(WithSize(2))
 	// Add one expired entry
 	c.Set("foo", "bar")
 	_, ok := c.Get("foo")
@ -117,7 +117,7 @@ func TestMaxSize(t *testing.T) {
 }

 func TestExist(t *testing.T) {
-	c := New(WithSize(1))
+	c := NewLRUCache(WithSize(1))
 	c.Set(1, 2)
 	assert.True(t, c.Exist(1))
 	c.Set(2, 3)
@ -126,58 +126,13 @@ func TestExist(t *testing.T) {

 func TestEvict(t *testing.T) {
 	temp := 0
-	evict := func(key any, value any) {
+	evict := func(key interface{}, value interface{}) {
 		temp = key.(int) + value.(int)
 	}

-	c := New(WithEvict(evict), WithSize(1))
+	c := NewLRUCache(WithEvict(evict), WithSize(1))
 	c.Set(1, 2)
 	c.Set(2, 3)

 	assert.Equal(t, temp, 3)
 }
-
-func TestSetWithExpire(t *testing.T) {
-	c := New(WithAge(1))
-	now := time.Now().Unix()
-
-	tenSecBefore := time.Unix(now-10, 0)
-	c.SetWithExpire(1, 2, tenSecBefore)
-
-	// res is expected not to exist, and expires should be empty time.Time
-	res, expires, exist := c.GetWithExpire(1)
-	assert.Equal(t, nil, res)
-	assert.Equal(t, time.Time{}, expires)
-	assert.Equal(t, false, exist)
-}
-
-func TestStale(t *testing.T) {
-	c := New(WithAge(1), WithStale(true))
-	now := time.Now().Unix()
-
-	tenSecBefore := time.Unix(now-10, 0)
-	c.SetWithExpire(1, 2, tenSecBefore)
-
-	res, expires, exist := c.GetWithExpire(1)
-	assert.Equal(t, 2, res)
-	assert.Equal(t, tenSecBefore, expires)
-	assert.Equal(t, true, exist)
-}
-
-func TestCloneTo(t *testing.T) {
-	o := New(WithSize(10))
-	o.Set("1", 1)
-	o.Set("2", 2)
-
-	n := New(WithSize(2))
-	n.Set("3", 3)
-	n.Set("4", 4)
-
-	o.CloneTo(n)
-
-	assert.False(t, n.Exist("3"))
-	assert.True(t, n.Exist("1"))
-
-	n.Set("5", 5)
-	assert.False(t, n.Exist("1"))
-}
--- a/common/murmur3/murmur32.go
+++ b/common/murmur3/murmur32.go
@ -67,6 +67,7 @@ func (d *digest32) bmix(p []byte) (tail []byte) {
 }

 func (d *digest32) Sum32() (h1 uint32) {
+
 	h1 = d.h1

 	var k1 uint32
--- a/common/net/bufconn.go
+++ b/common/net/bufconn.go
@ -1,44 +0,0 @@
-package net
-
-import (
-	"bufio"
-	"net"
-)
-
-type BufferedConn struct {
-	r *bufio.Reader
-	net.Conn
-}
-
-func NewBufferedConn(c net.Conn) *BufferedConn {
-	if bc, ok := c.(*BufferedConn); ok {
-		return bc
-	}
-	return &BufferedConn{bufio.NewReader(c), c}
-}
-
-// Reader returns the internal bufio.Reader.
-func (c *BufferedConn) Reader() *bufio.Reader {
-	return c.r
-}
-
-// Peek returns the next n bytes without advancing the reader.
-func (c *BufferedConn) Peek(n int) ([]byte, error) {
-	return c.r.Peek(n)
-}
-
-func (c *BufferedConn) Read(p []byte) (int, error) {
-	return c.r.Read(p)
-}
-
-func (c *BufferedConn) ReadByte() (byte, error) {
-	return c.r.ReadByte()
-}
-
-func (c *BufferedConn) UnreadByte() error {
-	return c.r.UnreadByte()
-}
-
-func (c *BufferedConn) Buffered() int {
-	return c.r.Buffered()
-}
--- a/common/net/io.go
+++ b/common/net/io.go
@ -1,11 +0,0 @@
-package net
-
-import "io"
-
-type ReadOnlyReader struct {
-	io.Reader
-}
-
-type WriteOnlyWriter struct {
-	io.Writer
-}
--- a/common/net/relay.go
+++ b/common/net/relay.go
@ -1,24 +0,0 @@
-package net
-
-import (
-	"io"
-	"net"
-	"time"
-)
-
-// Relay copies between left and right bidirectionally.
-func Relay(leftConn, rightConn net.Conn) {
-	ch := make(chan error)
-
-	go func() {
-		// Wrapping to avoid using *net.TCPConn.(ReadFrom)
-		// See also https://github.com/Dreamacro/clash/pull/1209
-		_, err := io.Copy(WriteOnlyWriter{Writer: leftConn}, ReadOnlyReader{Reader: rightConn})
-		leftConn.SetReadDeadline(time.Now())
-		ch <- err
-	}()
-
-	io.Copy(WriteOnlyWriter{Writer: rightConn}, ReadOnlyReader{Reader: leftConn})
-	rightConn.SetReadDeadline(time.Now())
-	<-ch
-}
--- a/common/observable/iterable.go
+++ b/common/observable/iterable.go
@ -1,3 +1,3 @@
 package observable

-type Iterable <-chan any
+type Iterable <-chan interface{}
--- a/common/observable/observable_test.go
+++ b/common/observable/observable_test.go
@ -1,16 +1,16 @@
 package observable

 import (
+	"runtime"
 	"sync"
 	"testing"
 	"time"

 	"github.com/stretchr/testify/assert"
-	"go.uber.org/atomic"
 )

-func iterator(item []any) chan any {
-	ch := make(chan any)
+func iterator(item []interface{}) chan interface{} {
+	ch := make(chan interface{})
 	go func() {
 		time.Sleep(100 * time.Millisecond)
 		for _, elm := range item {
@ -22,7 +22,7 @@ func iterator(item []any) chan any {
 }

 func TestObservable(t *testing.T) {
-	iter := iterator([]any{1, 2, 3, 4, 5})
+	iter := iterator([]interface{}{1, 2, 3, 4, 5})
 	src := NewObservable(iter)
 	data, err := src.Subscribe()
 	assert.Nil(t, err)
@ -33,29 +33,29 @@ func TestObservable(t *testing.T) {
 	assert.Equal(t, count, 5)
 }

-func TestObservable_MultiSubscribe(t *testing.T) {
-	iter := iterator([]any{1, 2, 3, 4, 5})
+func TestObservable_MutilSubscribe(t *testing.T) {
+	iter := iterator([]interface{}{1, 2, 3, 4, 5})
 	src := NewObservable(iter)
 	ch1, _ := src.Subscribe()
 	ch2, _ := src.Subscribe()
-	count := atomic.NewInt32(0)
+	count := 0

 	var wg sync.WaitGroup
 	wg.Add(2)
-	waitCh := func(ch <-chan any) {
+	waitCh := func(ch <-chan interface{}) {
 		for range ch {
-			count.Inc()
+			count++
 		}
 		wg.Done()
 	}
 	go waitCh(ch1)
 	go waitCh(ch2)
 	wg.Wait()
-	assert.Equal(t, int32(10), count.Load())
+	assert.Equal(t, count, 10)
 }

 func TestObservable_UnSubscribe(t *testing.T) {
-	iter := iterator([]any{1, 2, 3, 4, 5})
+	iter := iterator([]interface{}{1, 2, 3, 4, 5})
 	src := NewObservable(iter)
 	data, err := src.Subscribe()
 	assert.Nil(t, err)
@ -65,7 +65,7 @@ func TestObservable_UnSubscribe(t *testing.T) {
 }

 func TestObservable_SubscribeClosedSource(t *testing.T) {
-	iter := iterator([]any{1})
+	iter := iterator([]interface{}{1})
 	src := NewObservable(iter)
 	data, _ := src.Subscribe()
 	<-data
@ -75,14 +75,17 @@ func TestObservable_SubscribeClosedSource(t *testing.T) {
 }

 func TestObservable_UnSubscribeWithNotExistSubscription(t *testing.T) {
-	sub := Subscription(make(chan any))
-	iter := iterator([]any{1})
+	sub := Subscription(make(chan interface{}))
+	iter := iterator([]interface{}{1})
 	src := NewObservable(iter)
 	src.UnSubscribe(sub)
 }

 func TestObservable_SubscribeGoroutineLeak(t *testing.T) {
-	iter := iterator([]any{1, 2, 3, 4, 5})
+	// waiting for other goroutine recycle
+	time.Sleep(120 * time.Millisecond)
+	init := runtime.NumGoroutine()
+	iter := iterator([]interface{}{1, 2, 3, 4, 5})
 	src := NewObservable(iter)
 	max := 100

@ -94,7 +97,7 @@ func TestObservable_SubscribeGoroutineLeak(t *testing.T) {

 	var wg sync.WaitGroup
 	wg.Add(max)
-	waitCh := func(ch <-chan any) {
+	waitCh := func(ch <-chan interface{}) {
 		for range ch {
 		}
 		wg.Done()
@ -104,43 +107,6 @@ func TestObservable_SubscribeGoroutineLeak(t *testing.T) {
 		go waitCh(ch)
 	}
 	wg.Wait()
-
-	for _, sub := range list {
-		_, more := <-sub
-		assert.False(t, more)
-	}
-
-	_, more := <-list[0]
-	assert.False(t, more)
-}
-
-func Benchmark_Observable_1000(b *testing.B) {
-	ch := make(chan any)
-	o := NewObservable(ch)
-	num := 1000
-
-	subs := []Subscription{}
-	for i := 0; i < num; i++ {
-		sub, _ := o.Subscribe()
-		subs = append(subs, sub)
-	}
-
-	wg := sync.WaitGroup{}
-	wg.Add(num)
-
-	b.ResetTimer()
-	for _, sub := range subs {
-		go func(s Subscription) {
-			for range s {
-			}
-			wg.Done()
-		}(sub)
-	}
-
-	for i := 0; i < b.N; i++ {
-		ch <- i
-	}
-
-	close(ch)
-	wg.Wait()
+	now := runtime.NumGoroutine()
+	assert.Equal(t, init, now)
 }
--- a/common/observable/subscriber.go
+++ b/common/observable/subscriber.go
@ -2,32 +2,34 @@ package observable

 import (
 	"sync"
+
+	"gopkg.in/eapache/channels.v1"
 )

-type Subscription <-chan any
+type Subscription <-chan interface{}

 type Subscriber struct {
-	buffer chan any
+	buffer *channels.InfiniteChannel
 	once   sync.Once
 }

-func (s *Subscriber) Emit(item any) {
-	s.buffer <- item
+func (s *Subscriber) Emit(item interface{}) {
+	s.buffer.In() <- item
 }

 func (s *Subscriber) Out() Subscription {
-	return s.buffer
+	return s.buffer.Out()
 }

 func (s *Subscriber) Close() {
 	s.once.Do(func() {
-		close(s.buffer)
+		s.buffer.Close()
 	})
 }

 func newSubscriber() *Subscriber {
 	sub := &Subscriber{
-		buffer: make(chan any, 200),
+		buffer: channels.NewInfiniteChannel(),
 	}
 	return sub
 }
--- a/common/picker/picker.go
+++ b/common/picker/picker.go
@ -15,10 +15,8 @@ type Picker struct {

 	wg sync.WaitGroup

-	once    sync.Once
-	errOnce sync.Once
-	result  any
-	err     error
+	once   sync.Once
+	result interface{}
 }

 func newPicker(ctx context.Context, cancel func()) *Picker {
@ -43,7 +41,7 @@ func WithTimeout(ctx context.Context, timeout time.Duration) (*Picker, context.C

 // Wait blocks until all function calls from the Go method have returned,
 // then returns the first nil error result (if any) from them.
-func (p *Picker) Wait() any {
+func (p *Picker) Wait() interface{} {
 	p.wg.Wait()
 	if p.cancel != nil {
 		p.cancel()
@ -51,14 +49,9 @@ func (p *Picker) Wait() any {
 	return p.result
 }

-// Error return the first error (if all success return nil)
-func (p *Picker) Error() error {
-	return p.err
-}
-
 // Go calls the given function in a new goroutine.
 // The first call to return a nil error cancels the group; its result will be returned by Wait.
-func (p *Picker) Go(f func() (any, error)) {
+func (p *Picker) Go(f func() (interface{}, error)) {
 	p.wg.Add(1)

 	go func() {
@ -71,10 +64,6 @@ func (p *Picker) Go(f func() (any, error)) {
 					p.cancel()
 				}
 			})
-		} else {
-			p.errOnce.Do(func() {
-				p.err = err
-			})
 		}
 	}()
 }
--- a/common/picker/picker_test.go
+++ b/common/picker/picker_test.go
@ -8,8 +8,8 @@ import (
 	"github.com/stretchr/testify/assert"
 )

-func sleepAndSend(ctx context.Context, delay int, input any) func() (any, error) {
-	return func() (any, error) {
+func sleepAndSend(ctx context.Context, delay int, input interface{}) func() (interface{}, error) {
+	return func() (interface{}, error) {
 		timer := time.NewTimer(time.Millisecond * time.Duration(delay))
 		select {
 		case <-timer.C:
@ -36,5 +36,4 @@ func TestPicker_Timeout(t *testing.T) {

 	number := picker.Wait()
 	assert.Nil(t, number)
-	assert.NotNil(t, picker.Error())
 }
--- a/common/pool/alloc.go
+++ b/common/pool/alloc.go
@ -1,73 +0,0 @@
-package pool
-
-// Inspired by https://github.com/xtaci/smux/blob/master/alloc.go
-
-import (
-	"errors"
-	"math/bits"
-	"sync"
-)
-
-var defaultAllocator = NewAllocator()
-
-// Allocator for incoming frames, optimized to prevent overwriting after zeroing
-type Allocator struct {
-	buffers []sync.Pool
-}
-
-// NewAllocator initiates a []byte allocator for frames less than 65536 bytes,
-// the waste(memory fragmentation) of space allocation is guaranteed to be
-// no more than 50%.
-func NewAllocator() *Allocator {
-	alloc := new(Allocator)
-	alloc.buffers = make([]sync.Pool, 17) // 1B -> 64K
-	for k := range alloc.buffers {
-		i := k
-		alloc.buffers[k].New = func() any {
-			return make([]byte, 1<<uint32(i))
-		}
-	}
-	return alloc
-}
-
-// Get a []byte from pool with most appropriate cap
-func (alloc *Allocator) Get(size int) []byte {
-	switch {
-	case size < 0:
-		panic("alloc.Get: len out of range")
-	case size == 0:
-		return nil
-	case size > 65536:
-		return make([]byte, size)
-	default:
-		bits := msb(size)
-		if size == 1<<bits {
-			return alloc.buffers[bits].Get().([]byte)[:size]
-		}
-
-		return alloc.buffers[bits+1].Get().([]byte)[:size]
-	}
-}
-
-// Put returns a []byte to pool for future use,
-// which the cap must be exactly 2^n
-func (alloc *Allocator) Put(buf []byte) error {
-	if cap(buf) == 0 || cap(buf) > 65536 {
-		return nil
-	}
-
-	bits := msb(cap(buf))
-	if cap(buf) != 1<<bits {
-		return errors.New("allocator Put() incorrect buffer size")
-	}
-
-	//nolint
-	//lint:ignore SA6002 ignore temporarily
-	alloc.buffers[bits].Put(buf)
-	return nil
-}
-
-// msb return the pos of most significant bit
-func msb(size int) uint16 {
-	return uint16(bits.Len32(uint32(size)) - 1)
-}
--- a/common/pool/alloc_test.go
+++ b/common/pool/alloc_test.go
@ -1,48 +0,0 @@
-package pool
-
-import (
-	"math/rand"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestAllocGet(t *testing.T) {
-	alloc := NewAllocator()
-	assert.Nil(t, alloc.Get(0))
-	assert.Equal(t, 1, len(alloc.Get(1)))
-	assert.Equal(t, 2, len(alloc.Get(2)))
-	assert.Equal(t, 3, len(alloc.Get(3)))
-	assert.Equal(t, 4, cap(alloc.Get(3)))
-	assert.Equal(t, 4, cap(alloc.Get(4)))
-	assert.Equal(t, 1023, len(alloc.Get(1023)))
-	assert.Equal(t, 1024, cap(alloc.Get(1023)))
-	assert.Equal(t, 1024, len(alloc.Get(1024)))
-	assert.Equal(t, 65536, len(alloc.Get(65536)))
-	assert.Equal(t, 65537, len(alloc.Get(65537)))
-}
-
-func TestAllocPut(t *testing.T) {
-	alloc := NewAllocator()
-	assert.Nil(t, alloc.Put(nil), "put nil misbehavior")
-	assert.NotNil(t, alloc.Put(make([]byte, 3)), "put elem:3 []bytes misbehavior")
-	assert.Nil(t, alloc.Put(make([]byte, 4)), "put elem:4 []bytes misbehavior")
-	assert.Nil(t, alloc.Put(make([]byte, 1023, 1024)), "put elem:1024 []bytes misbehavior")
-	assert.Nil(t, alloc.Put(make([]byte, 65536)), "put elem:65536 []bytes misbehavior")
-	assert.Nil(t, alloc.Put(make([]byte, 65537)), "put elem:65537 []bytes misbehavior")
-}
-
-func TestAllocPutThenGet(t *testing.T) {
-	alloc := NewAllocator()
-	data := alloc.Get(4)
-	alloc.Put(data)
-	newData := alloc.Get(4)
-
-	assert.Equal(t, cap(data), cap(newData), "different cap while alloc.Get()")
-}
-
-func BenchmarkMSB(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		msb(rand.Int())
-	}
-}
--- a/common/pool/buffer.go
+++ b/common/pool/buffer.go
@ -1,31 +0,0 @@
-package pool
-
-import (
-	"bytes"
-	"sync"
-
-	"github.com/Dreamacro/protobytes"
-)
-
-var (
-	bufferPool      = sync.Pool{New: func() any { return &bytes.Buffer{} }}
-	bytesBufferPool = sync.Pool{New: func() any { return &protobytes.BytesWriter{} }}
-)
-
-func GetBuffer() *bytes.Buffer {
-	return bufferPool.Get().(*bytes.Buffer)
-}
-
-func PutBuffer(buf *bytes.Buffer) {
-	buf.Reset()
-	bufferPool.Put(buf)
-}
-
-func GetBytesBuffer() *protobytes.BytesWriter {
-	return bytesBufferPool.Get().(*protobytes.BytesWriter)
-}
-
-func PutBytesBuffer(buf *protobytes.BytesWriter) {
-	buf.Reset()
-	bytesBufferPool.Put(buf)
-}
--- a/common/pool/pool.go
+++ b/common/pool/pool.go
@ -1,21 +1,15 @@
 package pool

+import (
+	"sync"
+)
+
 const (
 	// io.Copy default buffer size is 32 KiB
 	// 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
+	bufferSize = 20 * 1024
 )

-func Get(size int) []byte {
-	return defaultAllocator.Get(size)
-}
-
-func Put(buf []byte) error {
-	return defaultAllocator.Put(buf)
-}
+// BufPool provide buffer for relay
+var BufPool = sync.Pool{New: func() interface{} { return make([]byte, bufferSize) }}
--- a/common/queue/queue.go
+++ b/common/queue/queue.go
@ -6,12 +6,12 @@ import (

 // Queue is a simple concurrent safe queue
 type Queue struct {
-	items []any
+	items []interface{}
 	lock  sync.RWMutex
 }

 // Put add the item to the queue.
-func (q *Queue) Put(items ...any) {
+func (q *Queue) Put(items ...interface{}) {
 	if len(items) == 0 {
 		return
 	}
@ -22,7 +22,7 @@ func (q *Queue) Put(items ...any) {
 }

 // Pop returns the head of items.
-func (q *Queue) Pop() any {
+func (q *Queue) Pop() interface{} {
 	if len(q.items) == 0 {
 		return nil
 	}
@ -35,7 +35,7 @@ func (q *Queue) Pop() any {
 }

 // Last returns the last of item.
-func (q *Queue) Last() any {
+func (q *Queue) Last() interface{} {
 	if len(q.items) == 0 {
 		return nil
 	}
@ -47,8 +47,8 @@ func (q *Queue) Last() any {
 }

 // Copy get the copy of queue.
-func (q *Queue) Copy() []any {
-	items := []any{}
+func (q *Queue) Copy() []interface{} {
+	items := []interface{}{}
 	q.lock.RLock()
 	items = append(items, q.items...)
 	q.lock.RUnlock()
@ -66,6 +66,6 @@ func (q *Queue) Len() int64 {
 // New is a constructor for a new concurrent safe queue.
 func New(hint int64) *Queue {
 	return &Queue{
-		items: make([]any, 0, hint),
+		items: make([]interface{}, 0, hint),
 	}
 }
--- a/common/singledo/singledo.go
+++ b/common/singledo/singledo.go
@ -7,7 +7,7 @@ import (

 type call struct {
 	wg  sync.WaitGroup
-	val any
+	val interface{}
 	err error
 }

@ -20,12 +20,11 @@ type Single struct {
 }

 type Result struct {
-	Val any
+	Val interface{}
 	Err error
 }

-// Do single.Do likes sync.singleFlight
-func (s *Single) Do(fn func() (any, error)) (v any, err error, shared bool) {
+func (s *Single) Do(fn func() (interface{}, error)) (v interface{}, err error, shared bool) {
 	s.mux.Lock()
 	now := time.Now()
 	if now.Before(s.last.Add(s.wait)) {
@ -45,19 +44,12 @@ func (s *Single) Do(fn func() (any, error)) (v any, err error, shared bool) {
 	s.mux.Unlock()
 	call.val, call.err = fn()
 	call.wg.Done()
-
-	s.mux.Lock()
 	s.call = nil
 	s.result = &Result{call.val, call.err}
 	s.last = now
-	s.mux.Unlock()
 	return call.val, call.err, false
 }

-func (s *Single) Reset() {
-	s.last = time.Time{}
-}
-
 func NewSingle(wait time.Duration) *Single {
 	return &Single{wait: wait}
 }
--- a/common/singledo/singledo_test.go
+++ b/common/singledo/singledo_test.go
@ -6,27 +6,26 @@ import (
 	"time"

 	"github.com/stretchr/testify/assert"
-	"go.uber.org/atomic"
 )

 func TestBasic(t *testing.T) {
 	single := NewSingle(time.Millisecond * 30)
 	foo := 0
-	shardCount := atomic.NewInt32(0)
-	call := func() (any, error) {
+	shardCount := 0
+	call := func() (interface{}, error) {
 		foo++
 		time.Sleep(time.Millisecond * 5)
 		return nil, nil
 	}

 	var wg sync.WaitGroup
-	const n = 5
+	const n = 10
 	wg.Add(n)
 	for i := 0; i < n; i++ {
 		go func() {
 			_, _, shard := single.Do(call)
 			if shard {
-				shardCount.Inc()
+				shardCount++
 			}
 			wg.Done()
 		}()
@ -34,13 +33,13 @@ func TestBasic(t *testing.T) {

 	wg.Wait()
 	assert.Equal(t, 1, foo)
-	assert.Equal(t, int32(4), shardCount.Load())
+	assert.Equal(t, 9, shardCount)
 }

 func TestTimer(t *testing.T) {
 	single := NewSingle(time.Millisecond * 30)
 	foo := 0
-	call := func() (any, error) {
+	call := func() (interface{}, error) {
 		foo++
 		return nil, nil
 	}
@ -52,18 +51,3 @@ func TestTimer(t *testing.T) {
 	assert.Equal(t, 1, foo)
 	assert.True(t, shard)
 }
-
-func TestReset(t *testing.T) {
-	single := NewSingle(time.Millisecond * 30)
-	foo := 0
-	call := func() (any, error) {
-		foo++
-		return nil, nil
-	}
-
-	single.Do(call)
-	single.Reset()
-	single.Do(call)
-
-	assert.Equal(t, 2, foo)
-}
--- a/common/sockopt/reuseaddr_linux.go
+++ b/common/sockopt/reuseaddr_linux.go
@ -1,19 +0,0 @@
-package sockopt
-
-import (
-	"net"
-	"syscall"
-)
-
-func UDPReuseaddr(c *net.UDPConn) (err error) {
-	rc, err := c.SyscallConn()
-	if err != nil {
-		return
-	}
-
-	rc.Control(func(fd uintptr) {
-		err = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
-	})
-
-	return
-}
--- a/common/sockopt/reuseaddr_other.go
+++ b/common/sockopt/reuseaddr_other.go
@ -1,11 +0,0 @@
-//go:build !linux
-
-package sockopt
-
-import (
-	"net"
-)
-
-func UDPReuseaddr(c *net.UDPConn) (err error) {
-	return
-}
--- a/common/structure/structure.go
+++ b/common/structure/structure.go
@ -28,8 +28,8 @@ func NewDecoder(option Option) *Decoder {
 	return &Decoder{option: &option}
 }

-// Decode transform a map[string]any to a struct
-func (d *Decoder) Decode(src map[string]any, dst any) error {
+// Decode transform a map[string]interface{} to a struct
+func (d *Decoder) Decode(src map[string]interface{}, dst interface{}) error {
 	if reflect.TypeOf(dst).Kind() != reflect.Ptr {
 		return fmt.Errorf("Decode must recive a ptr struct")
 	}
@ -37,16 +37,14 @@ func (d *Decoder) Decode(src map[string]any, dst any) 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)
-		key, omitKey, found := strings.Cut(tag, ",")
-		omitempty := found && omitKey == "omitempty"
+		str := strings.SplitN(tag, ",", 2)
+		key := str[0]
+		omitempty := false
+		if len(str) > 1 {
+			omitempty = str[1] == "omitempty"
+		}

 		value, ok := src[key]
 		if !ok || value == nil {
@ -64,7 +62,7 @@ func (d *Decoder) Decode(src map[string]any, dst any) error {
 	return nil
 }

-func (d *Decoder) decode(name string, data any, val reflect.Value) error {
+func (d *Decoder) decode(name string, data interface{}, val reflect.Value) error {
 	switch val.Kind() {
 	case reflect.Int:
 		return d.decodeInt(name, data, val)
@ -85,14 +83,12 @@ func (d *Decoder) decode(name string, data any, val reflect.Value) error {
 	}
 }

-func (d *Decoder) decodeInt(name string, data any, val reflect.Value) (err error) {
+func (d *Decoder) decodeInt(name string, data interface{}, val reflect.Value) (err error) {
 	dataVal := reflect.ValueOf(data)
 	kind := dataVal.Kind()
 	switch {
 	case kind == reflect.Int:
 		val.SetInt(dataVal.Int())
-	case kind == reflect.Float64 && d.option.WeaklyTypedInput:
-		val.SetInt(int64(dataVal.Float()))
 	case kind == reflect.String && d.option.WeaklyTypedInput:
 		var i int64
 		i, err = strconv.ParseInt(dataVal.String(), 0, val.Type().Bits())
@ -110,7 +106,7 @@ func (d *Decoder) decodeInt(name string, data any, val reflect.Value) (err error
 	return err
 }

-func (d *Decoder) decodeString(name string, data any, val reflect.Value) (err error) {
+func (d *Decoder) decodeString(name string, data interface{}, val reflect.Value) (err error) {
 	dataVal := reflect.ValueOf(data)
 	kind := dataVal.Kind()
 	switch {
@ -127,7 +123,7 @@ func (d *Decoder) decodeString(name string, data any, val reflect.Value) (err er
 	return err
 }

-func (d *Decoder) decodeBool(name string, data any, val reflect.Value) (err error) {
+func (d *Decoder) decodeBool(name string, data interface{}, val reflect.Value) (err error) {
 	dataVal := reflect.ValueOf(data)
 	kind := dataVal.Kind()
 	switch {
@ -144,7 +140,7 @@ func (d *Decoder) decodeBool(name string, data any, val reflect.Value) (err erro
 	return err
 }

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

-func (d *Decoder) decodeMap(name string, data any, val reflect.Value) error {
+func (d *Decoder) decodeMap(name string, data interface{}, val reflect.Value) error {
 	valType := val.Type()
 	valKeyType := valType.Key()
 	valElemType := valType.Elem()
@ -230,11 +216,6 @@ func (d *Decoder) decodeMapFromMap(name string, dataVal reflect.Value, val refle
 		}

 		v := dataVal.MapIndex(k).Interface()
-		if v == nil {
-			errors = append(errors, fmt.Sprintf("filed %s invalid", fieldName))
-			continue
-		}
-
 		currentVal := reflect.Indirect(reflect.New(valElemType))
 		if err := d.decode(fieldName, v, currentVal); err != nil {
 			errors = append(errors, err.Error())
@ -253,7 +234,7 @@ func (d *Decoder) decodeMapFromMap(name string, dataVal reflect.Value, val refle
 	return nil
 }

-func (d *Decoder) decodeStruct(name string, data any, val reflect.Value) error {
+func (d *Decoder) decodeStruct(name string, data interface{}, val reflect.Value) error {
 	dataVal := reflect.Indirect(reflect.ValueOf(data))

 	// If the type of the value to write to and the data match directly,
@ -281,7 +262,7 @@ func (d *Decoder) decodeStructFromMap(name string, dataVal, val reflect.Value) e
 	}

 	dataValKeys := make(map[reflect.Value]struct{})
-	dataValKeysUnused := make(map[any]struct{})
+	dataValKeysUnused := make(map[interface{}]struct{})
 	for _, dataValKey := range dataVal.MapKeys() {
 		dataValKeys[dataValKey] = struct{}{}
 		dataValKeysUnused[dataValKey.Interface()] = struct{}{}
@ -406,7 +387,7 @@ func (d *Decoder) decodeStructFromMap(name string, dataVal, val reflect.Value) e
 	return nil
 }

-func (d *Decoder) setInterface(name string, data any, val reflect.Value) (err error) {
+func (d *Decoder) setInterface(name string, data interface{}, val reflect.Value) (err error) {
 	dataVal := reflect.ValueOf(data)
 	val.Set(dataVal)
 	return nil
--- a/common/structure/structure_test.go
+++ b/common/structure/structure_test.go
@ -1,15 +1,12 @@
 package structure

 import (
+	"reflect"
 	"testing"
-
-	"github.com/stretchr/testify/assert"
 )

-var (
-	decoder         = NewDecoder(Option{TagName: "test"})
-	weakTypeDecoder = NewDecoder(Option{TagName: "test", WeaklyTypedInput: true})
-)
+var decoder = NewDecoder(Option{TagName: "test"})
+var weakTypeDecoder = NewDecoder(Option{TagName: "test", WeaklyTypedInput: true})

 type Baz struct {
 	Foo int    `test:"foo"`
@ -27,7 +24,7 @@ type BazOptional struct {
 }

 func TestStructure_Basic(t *testing.T) {
-	rawMap := map[string]any{
+	rawMap := map[string]interface{}{
 		"foo":   1,
 		"bar":   "test",
 		"extra": false,
@ -40,12 +37,16 @@ func TestStructure_Basic(t *testing.T) {

 	s := &Baz{}
 	err := decoder.Decode(rawMap, s)
-	assert.Nil(t, err)
-	assert.Equal(t, goal, s)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if !reflect.DeepEqual(s, goal) {
+		t.Fatalf("bad: %#v", s)
+	}
 }

 func TestStructure_Slice(t *testing.T) {
-	rawMap := map[string]any{
+	rawMap := map[string]interface{}{
 		"foo": 1,
 		"bar": []string{"one", "two"},
 	}
@ -57,12 +58,16 @@ func TestStructure_Slice(t *testing.T) {

 	s := &BazSlice{}
 	err := decoder.Decode(rawMap, s)
-	assert.Nil(t, err)
-	assert.Equal(t, goal, s)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if !reflect.DeepEqual(s, goal) {
+		t.Fatalf("bad: %#v", s)
+	}
 }

 func TestStructure_Optional(t *testing.T) {
-	rawMap := map[string]any{
+	rawMap := map[string]interface{}{
 		"foo": 1,
 	}

@ -72,40 +77,50 @@ func TestStructure_Optional(t *testing.T) {

 	s := &BazOptional{}
 	err := decoder.Decode(rawMap, s)
-	assert.Nil(t, err)
-	assert.Equal(t, goal, s)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if !reflect.DeepEqual(s, goal) {
+		t.Fatalf("bad: %#v", s)
+	}
 }

 func TestStructure_MissingKey(t *testing.T) {
-	rawMap := map[string]any{
+	rawMap := map[string]interface{}{
 		"foo": 1,
 	}

 	s := &Baz{}
 	err := decoder.Decode(rawMap, s)
-	assert.NotNilf(t, err, "should throw error: %#v", s)
+	if err == nil {
+		t.Fatalf("should throw error: %#v", s)
+	}
 }

 func TestStructure_ParamError(t *testing.T) {
-	rawMap := map[string]any{}
+	rawMap := map[string]interface{}{}
 	s := Baz{}
 	err := decoder.Decode(rawMap, s)
-	assert.NotNilf(t, err, "should throw error: %#v", s)
+	if err == nil {
+		t.Fatalf("should throw error: %#v", s)
+	}
 }

 func TestStructure_SliceTypeError(t *testing.T) {
-	rawMap := map[string]any{
+	rawMap := map[string]interface{}{
 		"foo": 1,
 		"bar": []int{1, 2},
 	}

 	s := &BazSlice{}
 	err := decoder.Decode(rawMap, s)
-	assert.NotNilf(t, err, "should throw error: %#v", s)
+	if err == nil {
+		t.Fatalf("should throw error: %#v", s)
+	}
 }

 func TestStructure_WeakType(t *testing.T) {
-	rawMap := map[string]any{
+	rawMap := map[string]interface{}{
 		"foo": "1",
 		"bar": []int{1},
 	}
@ -117,65 +132,10 @@ func TestStructure_WeakType(t *testing.T) {

 	s := &BazSlice{}
 	err := weakTypeDecoder.Decode(rawMap, s)
-	assert.Nil(t, err)
-	assert.Equal(t, goal, s)
-}
-
-func TestStructure_Nest(t *testing.T) {
-	rawMap := map[string]any{
-		"foo": 1,
-	}
-
-	goal := BazOptional{
-		Foo: 1,
-	}
-
-	s := &struct {
-		BazOptional
-	}{}
-	err := decoder.Decode(rawMap, s)
-	assert.Nil(t, err)
-	assert.Equal(t, s.BazOptional, goal)
-}
-
-func TestStructure_SliceNilValue(t *testing.T) {
-	rawMap := map[string]any{
-		"foo": 1,
-		"bar": []any{"bar", nil},
-	}
-
-	goal := &BazSlice{
-		Foo: 1,
-		Bar: []string{"bar", ""},
-	}
-
-	s := &BazSlice{}
-	err := weakTypeDecoder.Decode(rawMap, s)
-	assert.Nil(t, err)
-	assert.Equal(t, goal.Bar, s.Bar)
-
-	s = &BazSlice{}
-	err = decoder.Decode(rawMap, s)
-	assert.NotNil(t, err)
-}
-
-func TestStructure_SliceNilValueComplex(t *testing.T) {
-	rawMap := map[string]any{
-		"bar": []any{map[string]any{"bar": "foo"}, nil},
-	}
-
-	s := &struct {
-		Bar []map[string]any `test:"bar"`
-	}{}
-
-	err := decoder.Decode(rawMap, s)
-	assert.Nil(t, err)
-	assert.Nil(t, s.Bar[1])
-
-	ss := &struct {
-		Bar []Baz `test:"bar"`
-	}{}
-
-	err = decoder.Decode(rawMap, ss)
-	assert.NotNil(t, err)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if !reflect.DeepEqual(s, goal) {
+		t.Fatalf("bad: %#v", s)
+	}
 }
--- a/component/auth/auth.go
+++ b/component/auth/auth.go
@ -36,7 +36,7 @@ func NewAuthenticator(users []AuthUser) Authenticator {
 		au.storage.Store(user.User, user.Pass)
 	}
 	usernames := make([]string, 0, len(users))
-	au.storage.Range(func(key, value any) bool {
+	au.storage.Range(func(key, value interface{}) bool {
 		usernames = append(usernames, key.(string))
 		return true
 	})
--- a/component/dhcp/conn.go
+++ b/component/dhcp/conn.go
@ -1,28 +0,0 @@
-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"
-	}
-
-	options := []dialer.Option{
-		dialer.WithInterface(ifaceName),
-		dialer.WithAddrReuse(true),
-	}
-
-	// fallback bind on windows, because syscall bind can not receive broadcast
-	if runtime.GOOS == "windows" {
-		options = append(options, dialer.WithFallbackBind(true))
-	}
-
-	return dialer.ListenPacket(ctx, "udp4", listenAddr, options...)
-}
--- a/component/dhcp/dhcp.go
+++ b/component/dhcp/dhcp.go
@ -1,88 +0,0 @@
-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
-	}
-}
--- a/component/dialer/bind_darwin.go
+++ b/component/dialer/bind_darwin.go
@ -1,66 +0,0 @@
-package dialer
-
-import (
-	"net"
-	"syscall"
-
-	"github.com/Dreamacro/clash/component/iface"
-
-	"golang.org/x/sys/unix"
-)
-
-type controlFn = 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
-			}
-		}
-
-		var innerErr error
-		err = c.Control(func(fd uintptr) {
-			switch network {
-			case "tcp4", "udp4":
-				innerErr = unix.SetsockoptInt(int(fd), unix.IPPROTO_IP, unix.IP_BOUND_IF, ifaceIdx)
-			case "tcp6", "udp6":
-				innerErr = unix.SetsockoptInt(int(fd), unix.IPPROTO_IPV6, unix.IPV6_BOUND_IF, ifaceIdx)
-			}
-		})
-
-		if innerErr != nil {
-			err = innerErr
-		}
-
-		return
-	}
-}
-
-func bindIfaceToDialer(ifaceName string, dialer *net.Dialer, _ string, _ net.IP) error {
-	ifaceObj, err := iface.ResolveInterface(ifaceName)
-	if err != nil {
-		return err
-	}
-
-	dialer.Control = bindControl(ifaceObj.Index, dialer.Control)
-	return nil
-}
-
-func bindIfaceToListenConfig(ifaceName string, lc *net.ListenConfig, _, address string) (string, error) {
-	ifaceObj, err := iface.ResolveInterface(ifaceName)
-	if err != nil {
-		return "", err
-	}
-
-	lc.Control = bindControl(ifaceObj.Index, lc.Control)
-	return address, nil
-}
--- a/component/dialer/bind_linux.go
+++ b/component/dialer/bind_linux.go
@ -1,51 +0,0 @@
-package dialer
-
-import (
-	"net"
-	"syscall"
-
-	"golang.org/x/sys/unix"
-)
-
-type controlFn = 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
-			}
-		}
-
-		var innerErr error
-		err = c.Control(func(fd uintptr) {
-			innerErr = unix.BindToDevice(int(fd), ifaceName)
-		})
-
-		if innerErr != nil {
-			err = innerErr
-		}
-
-		return
-	}
-}
-
-func bindIfaceToDialer(ifaceName string, dialer *net.Dialer, _ string, _ net.IP) error {
-	dialer.Control = bindControl(ifaceName, dialer.Control)
-
-	return nil
-}
-
-func bindIfaceToListenConfig(ifaceName string, lc *net.ListenConfig, _, address string) (string, error) {
-	lc.Control = bindControl(ifaceName, lc.Control)
-
-	return address, nil
-}
--- a/Show More
+++ b/Show More