Feature: support relay (proxy chains) (#539)

Co-authored-by: Dreamacro <Dreamacro@vip.qq.com>

.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

.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

.github/workflows/go.yml

@@ -0,0 +1,44 @@
+name: Go
+on: [push, pull_request]
+jobs:
+
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup Go
+        uses: actions/setup-go@v1
+        with:
+          go-version: 1.14.x
+
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v1
+      
+      - name: Cache go module
+        uses: actions/cache@v1
+        with:
+          path: ~/go/pkg/mod
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+
+      - name: Get dependencies and run test
+        run: |
+          go test ./...
+
+      - name: Build
+        if: startsWith(github.ref, 'refs/tags/')
+        env:
+          NAME: clash
+          BINDIR: bin
+        run: make -j releases
+
+      - name: Upload Release
+        uses: softprops/action-gh-release@v1
+        if: startsWith(github.ref, 'refs/tags/')
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          files: bin/*
+          draft: true
+          prerelease: true

.gitignore

@@ -14,3 +14,9 @@ bin/*
 
 # dep
 vendor
+
+# GoLand
+.idea/*
+
+# macOS file
+.DS_Store

.travis.yml

@@ -1,26 +0,0 @@
-language: go
-sudo: false
-go:
-  - '1.12'
-install:
-  - "go mod download"
-env:
-  global:
-    - NAME=clash
-    - BINDIR=bin
-    - GO111MODULE=on
-script:
-  - go test ./...
-before_deploy: make -j releases
-deploy:
-  provider: releases
-  prerelease: true
-  skip_cleanup: true
-  api_key:
-    secure: dp1tc1h0er7aaAZ1hY0Xk/cUKwB0ifsAjg6e0M/Ad5NC87oucP6ESNFkDu0e9rUS1yB826/VnVGzNE/Z5zdjXVzPft+g5v5oRxzI4BKLhf07t9s+x8Z+3sApTxdsC5BvcN9x+5yRbpDLQ3biDPxSFu86j7m2pkEWw6XYNZO3/5y+RZXX7zu+d4MzTLUaA2kWl7KQAP0tEJNuw9ACDhpkw7LYbU/8q3E76prOTeme5/AT6Gxj7XhKUNP27lazhhqBSWM14ybPANqojNLEfMFHN/Eu2phYO07MuLTd4zuOIuw9y65kgvTFcHRlORjwUhnviXyA69obQejjgDI1WDOtU4PqpFaSLrxWtKI6k5VNWHARYggDm/wKl0WG7F0Kgio1KiGGhDg2yrbseXr/zBNaDhBtTFh6XJffqqwmgby1PXB6PWwfvWXooJMaQiFZczLWeMBl8v6XbSN6jtMTh/PQlKai6BcDd4LM8GQ7VHpSeff4qXEU4Vpnadjgs8VDPOHng6/HV+wDs8q2LrlMbnxLWxbCjOMUB6w7YnSrwH9owzKSoUs/531I4tTCRQIgipJtTK2b881/8osVjdMGS1mDXhBWO+OM0LCAdORJz+kN4PIkXXvKLt6jX74k6z4M3swFaqqtlTduN2Yy/ErsjguQO1VZfHmcpNssmJXI5QB9sxA=
-  file: bin/*
-  file_glob: true
-  on:
-    repo: Dreamacro/clash
-    branch: master
-    tags: true

Dockerfile

@@ -1,21 +1,16 @@
-FROM golang:latest as builder
+FROM golang:alpine as builder
-
-RUN wget http://geolite.maxmind.com/download/geoip/database/GeoLite2-Country.tar.gz -O /tmp/GeoLite2-Country.tar.gz && \
-    tar zxvf /tmp/GeoLite2-Country.tar.gz -C /tmp && \
-    mv /tmp/GeoLite2-Country_*/GeoLite2-Country.mmdb /Country.mmdb
 
+RUN apk add --no-cache make git && \
+    wget -O /Country.mmdb https://github.com/Dreamacro/maxmind-geoip/releases/latest/download/Country.mmdb
 WORKDIR /clash-src
-
 COPY . /clash-src
-
 RUN go mod download && \
-    GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -ldflags '-w -s' -o /clash
+    make linux-amd64 && \
+    mv ./bin/clash-linux-amd64 /clash
 
 FROM alpine:latest
 
 RUN apk add --no-cache ca-certificates
-
 COPY --from=builder /Country.mmdb /root/.config/clash/
 COPY --from=builder /clash /
-
 ENTRYPOINT ["/clash"]

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"]

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"]

LICENSE

@@ -1,21 +1,674 @@
-MIT License
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
 
-Copyright (c) 2018 Dreamacro
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
+                            Preamble
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all
+  The GNU General Public License is a free, copyleft license for
-copies or substantial portions of the Software.
+software and other kinds of works.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  The licenses for most software and other practical works are designed
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+to take away your freedom to share and change the works.  By contrast,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+the GNU General Public License is intended to guarantee your freedom to
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+share and change all versions of a program--to make sure it remains free
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+software for all its users.  We, the Free Software Foundation, use the
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+GNU General Public License for most of our software; it applies also to
-SOFTWARE.
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

Makefile

@@ -16,7 +16,8 @@ PLATFORM_LIST = \
 	linux-armv8 \
 	linux-mips-softfloat \
 	linux-mips-hardfloat \
-	linux-mipsle \
+	linux-mipsle-softfloat \
+	linux-mipsle-hardfloat \
 	linux-mips64 \
 	linux-mips64le \
 	freebsd-386 \
@@ -55,8 +56,11 @@ linux-mips-softfloat:
 linux-mips-hardfloat:
 	GOARCH=mips GOMIPS=hardfloat GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
 
-linux-mipsle:
+linux-mipsle-softfloat:
-	GOARCH=mipsle GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
+	GOARCH=mipsle GOMIPS=softfloat GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
+
+linux-mipsle-hardfloat:
+	GOARCH=mipsle GOMIPS=hardfloat GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
 
 linux-mips64:
 	GOARCH=mips64 GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@

README.md

@@ -6,9 +6,8 @@
 <h4 align="center">A rule-based tunnel in Go.</h4>
 
 <p align="center">
-  <a href="https://travis-ci.org/Dreamacro/clash">
+  <a href="https://github.com/Dreamacro/clash/actions">
-    <img src="https://img.shields.io/travis/Dreamacro/clash.svg?style=flat-square"
+    <img src="https://img.shields.io/github/workflow/status/Dreamacro/clash/Go?style=flat-square" alt="Github Actions">
-         alt="Travis-CI">
   </a>
   <a href="https://goreportcard.com/report/github.com/Dreamacro/clash">
     <img src="https://goreportcard.com/badge/github.com/Dreamacro/clash?style=flat-square">
@@ -20,61 +19,60 @@
 
 ## Features
 
-- HTTP/HTTPS and SOCKS protocol
+- Local HTTP/HTTPS/SOCKS server with/without authentication
-- Surge like configuration
+- VMess, Shadowsocks, Trojan (experimental), Snell protocol support for remote connections. UDP is supported.
-- GeoIP rule support
+- Built-in DNS server that aims to minimize DNS pollution attacks, supports DoH/DoT upstream. Fake IP is also supported.
-- Support Vmess/Shadowsocks/Socks5
+- Rules based off domains, GEOIP, IP CIDR or ports to forward packets to different nodes
-- Support for Netfilter TCP redirect
+- Remote groups allow users to implement powerful rules. Supports automatic fallback, load balancing or auto select node based off latency
+- Remote providers, allowing users to get node lists remotely instead of hardcoding in config
+- Netfilter TCP redirecting. You can deploy Clash on your Internet gateway with `iptables`.
+- Comprehensive HTTP API controller
 
 ## Install
 
-You can build from source:
+Clash requires Go >= 1.13. You can build it from source:
 
 ```sh
-go get -u -v github.com/Dreamacro/clash
+$ go get -u -v github.com/Dreamacro/clash
 ```
 
-Pre-built binaries are available: [release](https://github.com/Dreamacro/clash/releases)
+Pre-built binaries are available here: [release](https://github.com/Dreamacro/clash/releases)  
+Pre-built TUN mode binaries are available here: [TUN release](https://github.com/Dreamacro/clash/releases/tag/TUN). Source is not currently available.
 
-Requires Go >= 1.12.
+Check Clash version with:
-
-Checkout Clash version:
 
 ```sh
-clash -v
+$ clash -v
 ```
 
-## Daemon
+## Daemonize Clash
 
-Unfortunately, there is no native elegant way to implement golang's daemon.
+Unfortunately, there is no native or elegant way to implement daemons on Golang. We recommend using third-party daemon management tools like PM2, Supervisor or the like to keep Clash running as a service.
 
-So we can use third-party daemon tools like pm2, supervisor, and so on.
+In the case of [pm2](https://github.com/Unitech/pm2), start the daemon this way:
-
-In the case of [pm2](https://github.com/Unitech/pm2), we can start the daemon this way:
 
 ```sh
-pm2 start clash
+$ pm2 start clash
 ```
 
-If you have Docker installed, you can run clash directly using `docker-compose`.
+If you have Docker installed, it's recommended to deploy Clash directly using `docker-compose`: [run Clash in Docker](https://github.com/Dreamacro/clash/wiki/Run-clash-in-docker)
-
-[Run clash in docker](https://github.com/Dreamacro/clash/wiki/Run-clash-in-docker)
 
 ## Config
 
-The default configuration directory is `$HOME/.config/clash`
+The default configuration directory is `$HOME/.config/clash`.
 
-The name of the configuration file is `config.yaml`
+The name of the configuration file is `config.yaml`.
 
-If you want to use another directory, you can use `-d` to control the configuration directory
+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
+For example, you can use the current directory as the configuration directory:
 
 ```sh
-clash -d .
+$ clash -d .
 ```
 
-Below is a simple demo configuration file:
+<details>
+  <summary>This is an example configuration file (click to expand)</summary>
 
 ```yml
 # port of HTTP
@@ -88,14 +86,20 @@ socks-port: 7891
 
 allow-lan: false
 
-# Rule / Global/ Direct (default is Rule)
+# 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
 
-# A RESTful API for clash
+# 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`
@@ -108,125 +112,250 @@ external-controller: 127.0.0.1:9090
 # 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:
+proxies:
+  # 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
 
-# shadowsocks
+  # old obfs configuration format remove after prerelease
-# The types of cipher are consistent with go-shadowsocks2
+  - name: "ss2"
-# support AEAD_AES_128_GCM AEAD_AES_192_GCM AEAD_AES_256_GCM AEAD_CHACHA20_POLY1305 AES-128-CTR AES-192-CTR AES-256-CTR AES-128-CFB AES-192-CFB AES-256-CFB CHACHA20-IETF XCHACHA20
+    type: ss
-# In addition to what go-shadowsocks2 supports, it also supports chacha20 rc4-md5 xchacha20-ietf-poly1305
+    server: server
-- { name: "ss1", type: ss, server: server, port: 443, cipher: AEAD_CHACHA20_POLY1305, password: "password", udp: true }
+    port: 443
+    cipher: chacha20-ietf-poly1305
+    password: "password"
+    plugin: obfs
+    plugin-opts:
+      mode: tls # or http
+      # host: bing.com
 
-# old obfs configuration remove after prerelease
+  - name: "ss3"
-- name: "ss2"
+    type: ss
-  type: ss
+    server: server
-  server: server
+    port: 443
-  port: 443
+    cipher: chacha20-ietf-poly1305
-  cipher: AEAD_CHACHA20_POLY1305
+    password: "password"
-  password: "password"
+    plugin: v2ray-plugin
-  plugin: obfs
+    plugin-opts:
-  plugin-opts:
+      mode: websocket # no QUIC now
-    mode: tls # or http
+      # tls: true # wss
-    # host: bing.com
+      # skip-cert-verify: true
+      # host: bing.com
+      # path: "/"
+      # mux: true
+      # headers:
+      #   custom: value
 
-- name: "ss3"
+  # vmess
-  type: ss
+  # cipher support auto/aes-128-gcm/chacha20-poly1305/none
-  server: server
+  - name: "vmess"
-  port: 443
+    type: vmess
-  cipher: AEAD_CHACHA20_POLY1305
+    server: server
-  password: "password"
+    port: 443
-  plugin: v2ray-plugin
+    uuid: uuid
-  plugin-opts:
+    alterId: 32
-    mode: websocket # no QUIC now
+    cipher: auto
-    # tls: true # wss
+    # udp: true
+    # tls: true
     # skip-cert-verify: true
-    # host: bing.com
+    # network: ws
-    # path: "/"
+    # ws-path: /path
-    # headers:
+    # ws-headers:
-    #   custom: value
+    #   Host: v2ray.com
 
-# vmess
+  # socks5
-# cipher support auto/aes-128-gcm/chacha20-poly1305/none
+  - name: "socks"
-- { name: "vmess", type: vmess, server: server, port: 443, uuid: uuid, alterId: 32, cipher: auto }
+    type: socks5
-# with tls
+    server: server
-- { name: "vmess", type: vmess, server: server, port: 443, uuid: uuid, alterId: 32, cipher: auto, tls: true }
+    port: 443
-# with tls and skip-cert-verify
+    # username: username
-- { name: "vmess", type: vmess, server: server, port: 443, uuid: uuid, alterId: 32, cipher: auto, tls: true, skip-cert-verify: true }
+    # password: password
-# with ws-path and ws-headers
+    # tls: true
-- { name: "vmess", type: vmess, server: server, port: 443, uuid: uuid, alterId: 32, cipher: auto, network: ws, ws-path: /path, ws-headers: { Host: v2ray.com } }
+    # skip-cert-verify: true
-# with ws + tls
+    # udp: true
-- { name: "vmess", type: vmess, server: server, port: 443, uuid: uuid, alterId: 32, cipher: auto, network: ws, ws-path: /path, tls: true }
 
-# socks5
+  # http
-- { name: "socks", type: socks5, server: server, port: 443 }
+  - name: "http"
-# socks5 with authentication
+    type: http
-- { name: "socks", type: socks5, server: server, port: 443, username: "username", password: "password" }
+    server: server
-# with tls
+    port: 443
-- { name: "socks", type: socks5, server: server, port: 443, tls: true }
+    # username: username
-# with tls and skip-cert-verify
+    # password: password
-- { name: "socks", type: socks5, server: server, port: 443, tls: true, skip-cert-verify: true }
+    # tls: true # https
+    # skip-cert-verify: true
 
-# http
+  # snell
-- { name: "http", type: http, server: server, port: 443 }
+  - name: "snell"
-# http with authentication
+    type: snell
-- { name: "http", type: http, server: server, port: 443, username: "username", password: "password" }
+    server: server
-# with tls (https)
+    port: 44046
-- { name: "http", type: http, server: server, port: 443, tls: true }
+    psk: yourpsk
-# with tls (https) and skip-cert-verify
+    # obfs-opts:
-- { name: "http", type: http, server: server, port: 443, tls: true, skip-cert-verify: true }
+      # mode: http # or tls
+      # host: bing.com
 
-Proxy Group:
+  # trojan
-# url-test select which proxy will be used by benchmarking speed to a URL.
+  - name: "trojan"
-- { name: "auto", type: url-test, proxies: ["ss1", "ss2", "vmess1"], url: "http://www.gstatic.com/generate_204", interval: 300 }
+    type: trojan
+    server: server
+    port: 443
+    password: yourpsk
+    # udp: true
+    # sni: example.com # aka server name
+    # alpn:
+    #   - h2
+    #   - http/1.1
+    # skip-cert-verify: true
 
-# fallback select an available policy by priority. The availability is tested by accessing an URL, just like an auto url-test group.
+proxy-groups:
-- { name: "fallback-auto", type: fallback, proxies: ["ss1", "ss2", "vmess1"], url: "http://www.gstatic.com/generate_204", interval: 300 }
+  # relay chains the proxies. proxies shall not contain a proxy-group. No UDP support.
+  # Traffic: clash <-> http <-> vmess <-> ss1 <-> ss2 <-> Internet
+  - name: "relay"
+    type: relay
+    proxies:
+      - http
+      - vmess
+      - ss1
+      - ss2
 
-# load-balance: The request of the same eTLD will be dial on the same proxy.
+  # url-test select which proxy will be used by benchmarking speed to a URL.
-- { name: "load-balance", type: load-balance, proxies: ["ss1", "ss2", "vmess1"], url: "http://www.gstatic.com/generate_204", interval: 300 }
+  - name: "auto"
+    type: url-test
+    proxies:
+      - ss1
+      - ss2
+      - vmess1
+    url: 'http://www.gstatic.com/generate_204'
+    interval: 300
 
-# select is used for selecting proxy or proxy group
+  # fallback select an available policy by priority. The availability is tested by accessing an URL, just like an auto url-test group.
-# you can use RESTful API to switch proxy, is recommended for use in GUI.
+  - name: "fallback-auto"
-- { name: "Proxy", type: select, proxies: ["ss1", "ss2", "vmess1", "auto"] }
+    type: fallback
+    proxies:
+      - ss1
+      - ss2
+      - vmess1
+    url: 'http://www.gstatic.com/generate_204'
+    interval: 300
 
-Rule:
+  # load-balance: The request of the same eTLD will be dial on the same proxy.
-- DOMAIN-SUFFIX,google.com,auto
+  - name: "load-balance"
-- DOMAIN-KEYWORD,google,auto
+    type: load-balance
-- DOMAIN,google.com,auto
+    proxies:
-- DOMAIN-SUFFIX,ad.com,REJECT
+      - ss1
-- IP-CIDR,127.0.0.0/8,DIRECT
+      - ss2
-# rename SOURCE-IP-CIDR and would remove after prerelease
+      - vmess1
-- SRC-IP-CIDR,192.168.1.201/32,DIRECT
+    url: 'http://www.gstatic.com/generate_204'
-- GEOIP,CN,DIRECT
+    interval: 300
-- DST-PORT,80,DIRECT
+
-- SRC-PORT,7777,DIRECT
+  # select is used for selecting proxy or proxy group
-# FINAL would remove after prerelease
+  # you can use RESTful API to switch proxy, is recommended for use in GUI.
-# you also can use `FINAL,Proxy` or `FINAL,,Proxy` now
+  - name: Proxy
-- MATCH,auto
+    type: select
+    proxies:
+      - ss1
+      - ss2
+      - vmess1
+      - auto
+  
+  - name: UseProvider
+    type: select
+    use:
+      - provider1
+    proxies:
+      - Proxy
+      - DIRECT
+
+proxy-providers:
+  provider1:
+    type: http
+    url: "url"
+    interval: 3600
+    path: ./hk.yaml
+    health-check:
+      enable: true
+      interval: 600
+      url: http://www.gstatic.com/generate_204
+  test:
+    type: file
+    path: /test.yaml
+    health-check:
+      enable: true
+      interval: 36000
+      url: http://www.gstatic.com/generate_204
+
+rules:
+  - 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
+## Credits
 
 [riobard/go-shadowsocks2](https://github.com/riobard/go-shadowsocks2)
 
@@ -241,4 +370,5 @@ https://clash.gitbook.io/
 - [x] Complementing the necessary rule operators
 - [x] Redir proxy
 - [x] UDP support
-- [ ] Connection manager
+- [x] Connection manager
+- [ ] Event API

adapters/inbound/http.go

@@ -1,4 +1,4 @@
-package adapters
+package inbound
 
 import (
 	"net"
@@ -23,6 +23,7 @@ func (h *HTTPAdapter) Metadata() *C.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

adapters/inbound/https.go

@@ -1,13 +1,16 @@
-package adapters
+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

adapters/inbound/packet.go

@@ -0,0 +1,33 @@
+package inbound
+
+import (
+	"github.com/Dreamacro/clash/component/socks5"
+	C "github.com/Dreamacro/clash/constant"
+)
+
+// PacketAdapter is a UDP Packet adapter for socks/redir/tun
+type PacketAdapter struct {
+	C.UDPPacket
+	metadata *C.Metadata
+}
+
+// Metadata returns destination metadata
+func (s *PacketAdapter) Metadata() *C.Metadata {
+	return s.metadata
+}
+
+// NewPacket is PacketAdapter generator
+func NewPacket(target socks5.Addr, packet C.UDPPacket, source C.Type) *PacketAdapter {
+	metadata := parseSocksAddr(target)
+	metadata.NetWork = C.UDP
+	metadata.Type = source
+	if ip, port, err := parseAddr(packet.LocalAddr().String()); err == nil {
+		metadata.SrcIP = ip
+		metadata.SrcPort = port
+	}
+
+	return &PacketAdapter{
+		UDPPacket: packet,
+		metadata:  metadata,
+	}
+}

adapters/inbound/socket.go

@@ -1,4 +1,4 @@
-package adapters
+package inbound
 
 import (
 	"net"

adapters/inbound/util.go

@@ -1,4 +1,4 @@
-package adapters
+package inbound
 
 import (
 	"net"
@@ -20,11 +20,11 @@ func parseSocksAddr(target socks5.Addr) *C.Metadata {
 		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])
-		metadata.DstIP = &ip
+		metadata.DstIP = ip
 		metadata.DstPort = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1]))
 	case socks5.AtypIPv6:
 		ip := net.IP(target[1 : 1+net.IPv6len])
-		metadata.DstIP = &ip
+		metadata.DstIP = ip
 		metadata.DstPort = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1]))
 	}
 
@@ -40,7 +40,6 @@ func parseHTTPAddr(request *http.Request) *C.Metadata {
 
 	metadata := &C.Metadata{
 		NetWork:  C.TCP,
-		Type:     C.HTTP,
 		AddrType: C.AtypDomainName,
 		Host:     host,
 		DstIP:    nil,
@@ -55,18 +54,18 @@ func parseHTTPAddr(request *http.Request) *C.Metadata {
 		default:
 			metadata.AddrType = C.AtypIPv4
 		}
-		metadata.DstIP = &ip
+		metadata.DstIP = ip
 	}
 
 	return metadata
 }
 
-func parseAddr(addr string) (*net.IP, string, error) {
+func parseAddr(addr string) (net.IP, string, error) {
 	host, port, err := net.SplitHostPort(addr)
 	if err != nil {
 		return nil, "", err
 	}
 
 	ip := net.ParseIP(host)
-	return &ip, port, nil
+	return ip, port, nil
 }

adapters/outbound/base.go

@@ -1,6 +1,7 @@
-package adapters
+package outbound
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
 	"net"
@@ -11,8 +12,13 @@ import (
 	C "github.com/Dreamacro/clash/constant"
 )
 
+var (
+	defaultURLTestTimeout = time.Second * 5
+)
+
 type Base struct {
 	name string
+	addr string
 	tp   C.AdapterType
 	udp  bool
 }
@@ -25,22 +31,71 @@ func (b *Base) Type() C.AdapterType {
 	return b.tp
 }
 
-func (b *Base) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
+func (b *Base) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
-	return nil, nil, errors.New("no support")
+	return c, errors.New("no support")
+}
+
+func (b *Base) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
+	return nil, errors.New("no support")
 }
 
 func (b *Base) SupportUDP() bool {
 	return b.udp
 }
 
-func (b *Base) Destroy() {}
-
 func (b *Base) MarshalJSON() ([]byte, error) {
 	return json.Marshal(map[string]string{
 		"type": b.Type().String(),
 	})
 }
 
+func (b *Base) Addr() string {
+	return b.addr
+}
+
+func NewBase(name string, addr string, tp C.AdapterType, udp bool) *Base {
+	return &Base{name, addr, tp, udp}
+}
+
+type conn struct {
+	net.Conn
+	chain C.Chain
+}
+
+func (c *conn) Chains() C.Chain {
+	return c.chain
+}
+
+func (c *conn) AppendToChains(a C.ProxyAdapter) {
+	c.chain = append(c.chain, a.Name())
+}
+
+func NewConn(c net.Conn, a C.ProxyAdapter) C.Conn {
+	return &conn{c, []string{a.Name()}}
+}
+
+type PacketConn 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
@@ -51,8 +106,14 @@ func (p *Proxy) Alive() bool {
 	return p.alive
 }
 
-func (p *Proxy) Dial(metadata *C.Metadata) (net.Conn, error) {
+func (p *Proxy) Dial(metadata *C.Metadata) (C.Conn, error) {
-	conn, err := p.ProxyAdapter.Dial(metadata)
+	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
 	}
@@ -68,18 +129,18 @@ func (p *Proxy) DelayHistory() []C.DelayHistory {
 	return histories
 }
 
-// LastDelay return last history record. if proxy is not alive, return the max value of int16.
+// 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
 	}
 
-	head := p.history.First()
+	last := p.history.Last()
-	if head == nil {
+	if last == nil {
 		return max
 	}
-	history := head.(C.DelayHistory)
+	history := last.(C.DelayHistory)
 	if history.Delay == 0 {
 		return max
 	}
@@ -95,11 +156,12 @@ func (p *Proxy) MarshalJSON() ([]byte, error) {
 	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(url string) (t uint16, err error) {
+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()}
@@ -118,11 +180,18 @@ func (p *Proxy) URLTest(url string) (t uint16, err error) {
 	}
 
 	start := time.Now()
-	instance, err := p.Dial(&addr)
+	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
@@ -133,8 +202,14 @@ func (p *Proxy) URLTest(url string) (t uint16, err error) {
 		TLSHandshakeTimeout:   10 * time.Second,
 		ExpectContinueTimeout: 1 * time.Second,
 	}
-	client := http.Client{Transport: transport}
+
-	resp, err := client.Get(url)
+	client := http.Client{
+		Transport: transport,
+		CheckRedirect: func(req *http.Request, via []*http.Request) error {
+			return http.ErrUseLastResponse
+		},
+	}
+	resp, err := client.Do(req)
 	if err != nil {
 		return
 	}

adapters/outbound/direct.go

@@ -1,8 +1,11 @@
-package adapters
+package outbound
 
 import (
+	"context"
 	"net"
 
+	"github.com/Dreamacro/clash/component/dialer"
+	"github.com/Dreamacro/clash/component/resolver"
 	C "github.com/Dreamacro/clash/constant"
 )
 
@@ -10,31 +13,41 @@ type Direct struct {
 	*Base
 }
 
-func (d *Direct) Dial(metadata *C.Metadata) (net.Conn, error) {
+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 := dialTimeout("tcp", address, tcpTimeout)
+	c, err := dialer.DialContext(ctx, "tcp", address)
 	if err != nil {
 		return nil, err
 	}
 	tcpKeepAlive(c)
-	return c, nil
+	return NewConn(c, d), nil
 }
 
-func (d *Direct) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
+func (d *Direct) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
-	pc, err := net.ListenPacket("udp", "")
+	pc, err := dialer.ListenPacket("udp", "")
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
+	return newPacketConn(&directPacketConn{pc}, d), nil
+}
 
-	addr, err := resolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
+type directPacketConn struct {
-	if err != nil {
+	net.PacketConn
-		return nil, nil, err
+}
+
+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 pc, addr, nil
+	return dp.WriteTo(p, metadata.UDPAddr())
 }
 
 func NewDirect() *Direct {

adapters/outbound/fallback.go

@@ -1,125 +0,0 @@
-package adapters
-
-import (
-	"encoding/json"
-	"errors"
-	"net"
-	"sync"
-	"time"
-
-	C "github.com/Dreamacro/clash/constant"
-)
-
-type Fallback struct {
-	*Base
-	proxies  []C.Proxy
-	rawURL   string
-	interval time.Duration
-	done     chan struct{}
-}
-
-type FallbackOption struct {
-	Name     string   `proxy:"name"`
-	Proxies  []string `proxy:"proxies"`
-	URL      string   `proxy:"url"`
-	Interval int      `proxy:"interval"`
-}
-
-func (f *Fallback) Now() string {
-	proxy := f.findAliveProxy()
-	return proxy.Name()
-}
-
-func (f *Fallback) Dial(metadata *C.Metadata) (net.Conn, error) {
-	proxy := f.findAliveProxy()
-	return proxy.Dial(metadata)
-}
-
-func (f *Fallback) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
-	proxy := f.findAliveProxy()
-	return proxy.DialUDP(metadata)
-}
-
-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) Destroy() {
-	f.done <- struct{}{}
-}
-
-func (f *Fallback) loop() {
-	tick := time.NewTicker(f.interval)
-	go f.validTest()
-Loop:
-	for {
-		select {
-		case <-tick.C:
-			go f.validTest()
-		case <-f.done:
-			break Loop
-		}
-	}
-}
-
-func (f *Fallback) findAliveProxy() C.Proxy {
-	for _, proxy := range f.proxies {
-		if proxy.Alive() {
-			return proxy
-		}
-	}
-	return f.proxies[0]
-}
-
-func (f *Fallback) validTest() {
-	wg := sync.WaitGroup{}
-	wg.Add(len(f.proxies))
-
-	for _, p := range f.proxies {
-		go func(p C.Proxy) {
-			p.URLTest(f.rawURL)
-			wg.Done()
-		}(p)
-	}
-
-	wg.Wait()
-}
-
-func NewFallback(option FallbackOption, proxies []C.Proxy) (*Fallback, error) {
-	_, err := urlToMetadata(option.URL)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(proxies) < 1 {
-		return nil, errors.New("The number of proxies cannot be 0")
-	}
-
-	interval := time.Duration(option.Interval) * time.Second
-
-	Fallback := &Fallback{
-		Base: &Base{
-			name: option.Name,
-			tp:   C.Fallback,
-		},
-		proxies:  proxies,
-		rawURL:   option.URL,
-		interval: interval,
-		done:     make(chan struct{}),
-	}
-	go Fallback.loop()
-	return Fallback, nil
-}

adapters/outbound/http.go

@@ -1,8 +1,8 @@
-package adapters
+package outbound
 
 import (
 	"bufio"
-	"bytes"
+	"context"
 	"crypto/tls"
 	"encoding/base64"
 	"errors"
@@ -10,19 +10,18 @@ import (
 	"io"
 	"net"
 	"net/http"
+	"net/url"
 	"strconv"
 
+	"github.com/Dreamacro/clash/component/dialer"
 	C "github.com/Dreamacro/clash/constant"
 )
 
 type Http struct {
 	*Base
-	addr           string
+	user      string
-	user           string
+	pass      string
-	pass           string
+	tlsConfig *tls.Config
-	tls            bool
-	skipCertVerify bool
-	tlsConfig      *tls.Config
 }
 
 type HttpOption struct {
@@ -35,63 +34,80 @@ type HttpOption struct {
 	SkipCertVerify bool   `proxy:"skip-cert-verify,omitempty"`
 }
 
-func (h *Http) Dial(metadata *C.Metadata) (net.Conn, error) {
+func (h *Http) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
-	c, err := dialTimeout("tcp", h.addr, tcpTimeout)
+	if h.tlsConfig != nil {
-	if err == nil && h.tls {
 		cc := tls.Client(c, h.tlsConfig)
-		err = cc.Handshake()
+		err := cc.Handshake()
 		c = cc
+		if err != nil {
+			return nil, fmt.Errorf("%s connect error: %w", h.addr, err)
+		}
 	}
 
-	if err != nil {
-		return nil, fmt.Errorf("%s connect error", h.addr)
-	}
-	tcpKeepAlive(c)
 	if err := h.shakeHand(metadata, c); err != nil {
 		return nil, err
 	}
-
 	return c, nil
 }
 
-func (h *Http) shakeHand(metadata *C.Metadata, rw io.ReadWriter) error {
+func (h *Http) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
-	var buf bytes.Buffer
+	c, err := dialer.DialContext(ctx, "tcp", h.addr)
-	var err error
+	if err != nil {
+		return nil, fmt.Errorf("%s connect error: %w", h.addr, err)
+	}
+	tcpKeepAlive(c)
 
-	addr := net.JoinHostPort(metadata.String(), metadata.DstPort)
+	c, err = h.StreamConn(c, metadata)
-	buf.WriteString("CONNECT " + addr + " HTTP/1.1\r\n")
+	if err != nil {
-	buf.WriteString("Host: " + metadata.String() + "\r\n")
+		return nil, err
-	buf.WriteString("Proxy-Connection: Keep-Alive\r\n")
+	}
+
+	return NewConn(c, h), nil
+}
+
+func (h *Http) shakeHand(metadata *C.Metadata, rw io.ReadWriter) error {
+	addr := metadata.RemoteAddress()
+	req := &http.Request{
+		Method: http.MethodConnect,
+		URL: &url.URL{
+			Host: addr,
+		},
+		Host: addr,
+		Header: http.Header{
+			"Proxy-Connection": []string{"Keep-Alive"},
+		},
+	}
 
 	if h.user != "" && h.pass != "" {
 		auth := h.user + ":" + h.pass
-		buf.WriteString("Proxy-Authorization: Basic " + base64.StdEncoding.EncodeToString([]byte(auth)) + "\r\n")
+		req.Header.Add("Proxy-Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(auth)))
 	}
-	// header ended
-	buf.WriteString("\r\n")
 
-	_, err = rw.Write(buf.Bytes())
+	if err := req.Write(rw); err != nil {
+		return err
+	}
+
+	resp, err := http.ReadResponse(bufio.NewReader(rw), req)
 	if err != nil {
 		return err
 	}
 
-	var req http.Request
+	if resp.StatusCode == http.StatusOK {
-	resp, err := http.ReadResponse(bufio.NewReader(rw), &req)
-	if err != nil {
-		return err
-	}
-
-	if resp.StatusCode == 200 {
 		return nil
 	}
 
-	if resp.StatusCode == 407 {
+	if resp.StatusCode == http.StatusProxyAuthRequired {
 		return errors.New("HTTP need auth")
 	}
 
-	if resp.StatusCode == 405 {
+	if resp.StatusCode == http.StatusMethodNotAllowed {
 		return errors.New("CONNECT method not allowed by proxy")
 	}
+
+	if resp.StatusCode >= http.StatusInternalServerError {
+		return errors.New(resp.Status)
+	}
+
 	return fmt.Errorf("can not connect remote err code: %d", resp.StatusCode)
 }
 
@@ -108,13 +124,11 @@ func NewHttp(option HttpOption) *Http {
 	return &Http{
 		Base: &Base{
 			name: option.Name,
+			addr: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
 			tp:   C.Http,
 		},
-		addr:           net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
+		user:      option.UserName,
-		user:           option.UserName,
+		pass:      option.Password,
-		pass:           option.Password,
+		tlsConfig: tlsConfig,
-		tls:            option.TLS,
-		skipCertVerify: option.SkipCertVerify,
-		tlsConfig:      tlsConfig,
 	}
 }

adapters/outbound/loadbalance.go

@@ -1,158 +0,0 @@
-package adapters
-
-import (
-	"encoding/json"
-	"errors"
-	"net"
-	"sync"
-	"time"
-
-	"github.com/Dreamacro/clash/common/murmur3"
-	C "github.com/Dreamacro/clash/constant"
-
-	"golang.org/x/net/publicsuffix"
-)
-
-type LoadBalance struct {
-	*Base
-	proxies  []C.Proxy
-	maxRetry int
-	rawURL   string
-	interval time.Duration
-	done     chan struct{}
-}
-
-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) Dial(metadata *C.Metadata) (net.Conn, error) {
-	key := uint64(murmur3.Sum32([]byte(getKey(metadata))))
-	buckets := int32(len(lb.proxies))
-	for i := 0; i < lb.maxRetry; i, key = i+1, key+1 {
-		idx := jumpHash(key, buckets)
-		proxy := lb.proxies[idx]
-		if proxy.Alive() {
-			return proxy.Dial(metadata)
-		}
-	}
-
-	return lb.proxies[0].Dial(metadata)
-}
-
-func (lb *LoadBalance) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
-	key := uint64(murmur3.Sum32([]byte(getKey(metadata))))
-	buckets := int32(len(lb.proxies))
-	for i := 0; i < lb.maxRetry; i, key = i+1, key+1 {
-		idx := jumpHash(key, buckets)
-		proxy := lb.proxies[idx]
-		if proxy.Alive() {
-			return proxy.DialUDP(metadata)
-		}
-	}
-
-	return lb.proxies[0].DialUDP(metadata)
-}
-
-func (lb *LoadBalance) SupportUDP() bool {
-	return true
-}
-
-func (lb *LoadBalance) Destroy() {
-	lb.done <- struct{}{}
-}
-
-func (lb *LoadBalance) validTest() {
-	wg := sync.WaitGroup{}
-	wg.Add(len(lb.proxies))
-
-	for _, p := range lb.proxies {
-		go func(p C.Proxy) {
-			p.URLTest(lb.rawURL)
-			wg.Done()
-		}(p)
-	}
-
-	wg.Wait()
-}
-
-func (lb *LoadBalance) loop() {
-	tick := time.NewTicker(lb.interval)
-	go lb.validTest()
-Loop:
-	for {
-		select {
-		case <-tick.C:
-			go lb.validTest()
-		case <-lb.done:
-			break Loop
-		}
-	}
-}
-
-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,
-	})
-}
-
-type LoadBalanceOption struct {
-	Name     string   `proxy:"name"`
-	Proxies  []string `proxy:"proxies"`
-	URL      string   `proxy:"url"`
-	Interval int      `proxy:"interval"`
-}
-
-func NewLoadBalance(option LoadBalanceOption, proxies []C.Proxy) (*LoadBalance, error) {
-	if len(proxies) == 0 {
-		return nil, errors.New("Provide at least one proxy")
-	}
-
-	interval := time.Duration(option.Interval) * time.Second
-
-	lb := &LoadBalance{
-		Base: &Base{
-			name: option.Name,
-			tp:   C.LoadBalance,
-		},
-		proxies:  proxies,
-		maxRetry: 3,
-		rawURL:   option.URL,
-		interval: interval,
-		done:     make(chan struct{}),
-	}
-	go lb.loop()
-	return lb, nil
-}

adapters/outbound/parser.go

@@ -0,0 +1,71 @@
+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)
+	case "trojan":
+		trojanOption := &TrojanOption{}
+		err = decoder.Decode(mapping, trojanOption)
+		if err != nil {
+			break
+		}
+		proxy, err = NewTrojan(*trojanOption)
+	default:
+		return nil, fmt.Errorf("Unsupport proxy type: %s", proxyType)
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	return NewProxy(proxy), nil
+}

adapters/outbound/reject.go

@@ -1,6 +1,8 @@
-package adapters
+package outbound
 
 import (
+	"context"
+	"errors"
 	"io"
 	"net"
 	"time"
@@ -12,8 +14,12 @@ type Reject struct {
 	*Base
 }
 
-func (r *Reject) Dial(metadata *C.Metadata) (net.Conn, error) {
+func (r *Reject) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
-	return &NopConn{}, nil
+	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 {
@@ -21,6 +27,7 @@ func NewReject() *Reject {
 		Base: &Base{
 			name: "REJECT",
 			tp:   C.Reject,
+			udp:  true,
 		},
 	}
 }

adapters/outbound/selector.go

@@ -1,78 +0,0 @@
-package adapters
-
-import (
-	"encoding/json"
-	"errors"
-	"net"
-
-	C "github.com/Dreamacro/clash/constant"
-)
-
-type Selector struct {
-	*Base
-	selected  C.Proxy
-	proxies   map[string]C.Proxy
-	proxyList []string
-}
-
-type SelectorOption struct {
-	Name    string   `proxy:"name"`
-	Proxies []string `proxy:"proxies"`
-}
-
-func (s *Selector) Dial(metadata *C.Metadata) (net.Conn, error) {
-	return s.selected.Dial(metadata)
-}
-
-func (s *Selector) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
-	return s.selected.DialUDP(metadata)
-}
-
-func (s *Selector) SupportUDP() bool {
-	return s.selected.SupportUDP()
-}
-
-func (s *Selector) MarshalJSON() ([]byte, error) {
-	return json.Marshal(map[string]interface{}{
-		"type": s.Type().String(),
-		"now":  s.Now(),
-		"all":  s.proxyList,
-	})
-}
-
-func (s *Selector) Now() string {
-	return s.selected.Name()
-}
-
-func (s *Selector) Set(name string) error {
-	proxy, exist := s.proxies[name]
-	if !exist {
-		return errors.New("Proxy does not exist")
-	}
-	s.selected = proxy
-	return nil
-}
-
-func NewSelector(name string, proxies []C.Proxy) (*Selector, error) {
-	if len(proxies) == 0 {
-		return nil, errors.New("Provide at least one proxy")
-	}
-
-	mapping := make(map[string]C.Proxy)
-	proxyList := make([]string, len(proxies))
-	for idx, proxy := range proxies {
-		mapping[proxy.Name()] = proxy
-		proxyList[idx] = proxy.Name()
-	}
-
-	s := &Selector{
-		Base: &Base{
-			name: name,
-			tp:   C.Selector,
-		},
-		proxies:   mapping,
-		selected:  proxies[0],
-		proxyList: proxyList,
-	}
-	return s, nil
-}

adapters/outbound/shadowsocks.go

@@ -1,14 +1,16 @@
-package adapters
+package outbound
 
 import (
+	"context"
 	"crypto/tls"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net"
 	"strconv"
 
-	"github.com/Dreamacro/clash/common/pool"
 	"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"
@@ -19,13 +21,12 @@ import (
 
 type ShadowSocks struct {
 	*Base
-	server string
 	cipher core.Cipher
 
 	// obfs
-	obfsMode   string
+	obfsMode    string
-	obfsOption *simpleObfsOption
+	obfsOption  *simpleObfsOption
-	wsOption   *v2rayObfs.WebsocketOption
+	v2rayOption *v2rayObfs.Option
 }
 
 type ShadowSocksOption struct {
@@ -55,50 +56,52 @@ type v2rayObfsOption struct {
 	TLS            bool              `obfs:"tls,omitempty"`
 	Headers        map[string]string `obfs:"headers,omitempty"`
 	SkipCertVerify bool              `obfs:"skip-cert-verify,omitempty"`
+	Mux            bool              `obfs:"mux,omitempty"`
 }
 
-func (ss *ShadowSocks) Dial(metadata *C.Metadata) (net.Conn, error) {
+func (ss *ShadowSocks) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
-	c, err := dialTimeout("tcp", ss.server, tcpTimeout)
-	if err != nil {
-		return nil, fmt.Errorf("%s connect error: %s", ss.server, err.Error())
-	}
-	tcpKeepAlive(c)
 	switch ss.obfsMode {
 	case "tls":
 		c = obfs.NewTLSObfs(c, ss.obfsOption.Host)
 	case "http":
-		_, port, _ := net.SplitHostPort(ss.server)
+		_, port, _ := net.SplitHostPort(ss.addr)
 		c = obfs.NewHTTPObfs(c, ss.obfsOption.Host, port)
 	case "websocket":
 		var err error
-		c, err = v2rayObfs.NewWebsocketObfs(c, ss.wsOption)
+		c, err = v2rayObfs.NewV2rayObfs(c, ss.v2rayOption)
 		if err != nil {
-			return nil, fmt.Errorf("%s connect error: %s", ss.server, err.Error())
+			return nil, fmt.Errorf("%s connect error: %w", ss.addr, err)
 		}
 	}
 	c = ss.cipher.StreamConn(c)
-	_, err = c.Write(serializesSocksAddr(metadata))
+	_, err := c.Write(serializesSocksAddr(metadata))
 	return c, err
 }
 
-func (ss *ShadowSocks) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
+func (ss *ShadowSocks) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
-	pc, err := net.ListenPacket("udp", "")
+	c, err := dialer.DialContext(ctx, "tcp", ss.addr)
 	if err != nil {
-		return nil, nil, err
+		return nil, fmt.Errorf("%s connect error: %w", ss.addr, err)
+	}
+	tcpKeepAlive(c)
+
+	c, err = ss.StreamConn(c, metadata)
+	return NewConn(c, ss), err
+}
+
+func (ss *ShadowSocks) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
+	pc, err := dialer.ListenPacket("udp", "")
+	if err != nil {
+		return nil, err
 	}
 
-	addr, err := resolveUDPAddr("udp", ss.server)
+	addr, err := resolveUDPAddr("udp", ss.addr)
 	if err != nil {
-		return nil, nil, err
+		return nil, err
-	}
-
-	remoteAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
-	if err != nil {
-		return nil, nil, err
 	}
 
 	pc = ss.cipher.PacketConn(pc)
-	return &ssUDPConn{PacketConn: pc, rAddr: remoteAddr}, addr, nil
+	return newPacketConn(&ssPacketConn{PacketConn: pc, rAddr: addr}, ss), nil
 }
 
 func (ss *ShadowSocks) MarshalJSON() ([]byte, error) {
@@ -108,15 +111,15 @@ func (ss *ShadowSocks) MarshalJSON() ([]byte, error) {
 }
 
 func NewShadowSocks(option ShadowSocksOption) (*ShadowSocks, error) {
-	server := net.JoinHostPort(option.Server, strconv.Itoa(option.Port))
+	addr := 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: %s", server, err.Error())
+		return nil, fmt.Errorf("ss %s initialize error: %w", addr, err)
 	}
 
-	var wsOption *v2rayObfs.WebsocketOption
+	var v2rayOption *v2rayObfs.Option
 	var obfsOption *simpleObfsOption
 	obfsMode := ""
 
@@ -135,22 +138,22 @@ func NewShadowSocks(option ShadowSocksOption) (*ShadowSocks, error) {
 	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: %s", server, err.Error())
+			return nil, fmt.Errorf("ss %s initialize obfs error: %w", addr, err)
 		}
 
 		if opts.Mode != "tls" && opts.Mode != "http" {
-			return nil, fmt.Errorf("ss %s obfs mode error: %s", server, opts.Mode)
+			return nil, fmt.Errorf("ss %s obfs mode error: %s", addr, opts.Mode)
 		}
 		obfsMode = opts.Mode
 		obfsOption = &opts
 	} else if option.Plugin == "v2ray-plugin" {
-		opts := v2rayObfsOption{Host: "bing.com"}
+		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: %s", server, err.Error())
+			return nil, fmt.Errorf("ss %s initialize v2ray-plugin error: %w", addr, err)
 		}
 
 		if opts.Mode != "websocket" {
-			return nil, fmt.Errorf("ss %s obfs mode error: %s", server, opts.Mode)
+			return nil, fmt.Errorf("ss %s obfs mode error: %s", addr, opts.Mode)
 		}
 		obfsMode = opts.Mode
 
@@ -162,46 +165,67 @@ func NewShadowSocks(option ShadowSocksOption) (*ShadowSocks, error) {
 				ClientSessionCache: getClientSessionCache(),
 			}
 		}
-		wsOption = &v2rayObfs.WebsocketOption{
+		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,
 		},
-		server: server,
 		cipher: ciph,
 
-		obfsMode:   obfsMode,
+		obfsMode:    obfsMode,
-		wsOption:   wsOption,
+		v2rayOption: v2rayOption,
-		obfsOption: obfsOption,
+		obfsOption:  obfsOption,
 	}, nil
 }
 
-type ssUDPConn struct {
+type ssPacketConn struct {
 	net.PacketConn
 	rAddr net.Addr
 }
 
-func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
+func (spc *ssPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
-	buf := pool.BufPool.Get().([]byte)
+	packet, err := socks5.EncodeUDPPacket(socks5.ParseAddrToSocksAddr(addr), b)
-	defer pool.BufPool.Put(buf[:cap(buf)])
+	if err != nil {
-	rAddr := socks5.ParseAddr(uc.rAddr.String())
+		return
-	copy(buf[len(rAddr):], b)
+	}
-	copy(buf, rAddr)
+	return spc.PacketConn.WriteTo(packet[3:], spc.rAddr)
-	return uc.PacketConn.WriteTo(buf[:len(rAddr)+len(b)], addr)
 }
 
-func (uc *ssUDPConn) ReadFrom(b []byte) (int, net.Addr, error) {
+func (spc *ssPacketConn) WriteWithMetadata(p []byte, metadata *C.Metadata) (n int, err error) {
-	n, a, e := uc.PacketConn.ReadFrom(b)
+	packet, err := socks5.EncodeUDPPacket(socks5.ParseAddr(metadata.RemoteAddress()), p)
-	addr := socks5.SplitAddr(b[:n])
+	if err != nil {
-	copy(b, b[len(addr):])
+		return
-	return n - len(addr), a, e
+	}
+	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
 }

adapters/outbound/snell.go

@@ -0,0 +1,78 @@
+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
+	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) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
+	switch s.obfsOption.Mode {
+	case "tls":
+		c = obfs.NewTLSObfs(c, s.obfsOption.Host)
+	case "http":
+		_, port, _ := net.SplitHostPort(s.addr)
+		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 c, err
+}
+
+func (s *Snell) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
+	c, err := dialer.DialContext(ctx, "tcp", s.addr)
+	if err != nil {
+		return nil, fmt.Errorf("%s connect error: %w", s.addr, err)
+	}
+	tcpKeepAlive(c)
+
+	c, err = s.StreamConn(c, metadata)
+	return NewConn(c, s), err
+}
+
+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)
+	}
+
+	if obfsOption.Mode != "tls" && obfsOption.Mode != "http" {
+		return nil, fmt.Errorf("snell %s obfs mode error: %s", addr, obfsOption.Mode)
+	}
+
+	return &Snell{
+		Base: &Base{
+			name: option.Name,
+			addr: addr,
+			tp:   C.Snell,
+		},
+		psk:        psk,
+		obfsOption: obfsOption,
+	}, nil
+}

adapters/outbound/socks5.go

@@ -1,18 +1,22 @@
-package adapters
+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"
 )
 
 type Socks5 struct {
 	*Base
-	addr           string
 	user           string
 	pass           string
 	tls            bool
@@ -31,19 +35,16 @@ type Socks5Option struct {
 	SkipCertVerify bool   `proxy:"skip-cert-verify,omitempty"`
 }
 
-func (ss *Socks5) Dial(metadata *C.Metadata) (net.Conn, error) {
+func (ss *Socks5) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
-	c, err := dialTimeout("tcp", ss.addr, tcpTimeout)
+	if ss.tls {
-
-	if err == nil && ss.tls {
 		cc := tls.Client(c, ss.tlsConfig)
-		err = cc.Handshake()
+		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", ss.addr)
-	}
-	tcpKeepAlive(c)
 	var user *socks5.User
 	if ss.user != "" {
 		user = &socks5.User{
@@ -51,24 +52,48 @@ func (ss *Socks5) Dial(metadata *C.Metadata) (net.Conn, error) {
 			Password: ss.pass,
 		}
 	}
-	if err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdConnect, user); err != nil {
+	if _, err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdConnect, user); err != nil {
 		return nil, err
 	}
 	return c, nil
 }
 
-func (ss *Socks5) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
+func (ss *Socks5) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
-	c, err := dialTimeout("tcp", ss.addr, tcpTimeout)
+	c, err := dialer.DialContext(ctx, "tcp", ss.addr)
+	if err != nil {
+		return nil, fmt.Errorf("%s connect error: %w", ss.addr, err)
+	}
+	tcpKeepAlive(c)
 
-	if err == nil && ss.tls {
+	c, err = ss.StreamConn(c, metadata)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewConn(c, ss), nil
+}
+
+func (ss *Socks5) DialUDP(metadata *C.Metadata) (_ C.PacketConn, err error) {
+	ctx, cancel := context.WithTimeout(context.Background(), tcpTimeout)
+	defer cancel()
+	c, err := dialer.DialContext(ctx, "tcp", ss.addr)
+	if err != nil {
+		err = fmt.Errorf("%s connect error: %w", ss.addr, err)
+		return
+	}
+
+	if ss.tls {
 		cc := tls.Client(c, ss.tlsConfig)
 		err = cc.Handshake()
 		c = cc
 	}
 
-	if err != nil {
+	defer func() {
-		return nil, nil, fmt.Errorf("%s connect error", ss.addr)
+		if err != nil {
-	}
+			c.Close()
+		}
+	}()
+
 	tcpKeepAlive(c)
 	var user *socks5.User
 	if ss.user != "" {
@@ -78,10 +103,26 @@ func (ss *Socks5) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error
 		}
 	}
 
-	if err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdUDPAssociate, user); err != nil {
+	bindAddr, err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdUDPAssociate, user)
-		return nil, nil, err
+	if err != nil {
+		err = fmt.Errorf("client hanshake error: %w", err)
+		return
 	}
-	return &fakeUDPConn{Conn: c}, c.LocalAddr(), nil
+
+	pc, err := dialer.ListenPacket("udp", "")
+	if err != nil {
+		return
+	}
+
+	go func() {
+		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()
+	}()
+
+	return newPacketConn(&socksPacketConn{PacketConn: pc, rAddr: bindAddr.UDPAddr(), tcpConn: c}, ss), nil
 }
 
 func NewSocks5(option Socks5Option) *Socks5 {
@@ -97,10 +138,10 @@ func NewSocks5(option Socks5Option) *Socks5 {
 	return &Socks5{
 		Base: &Base{
 			name: option.Name,
+			addr: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
 			tp:   C.Socks5,
 			udp:  option.UDP,
 		},
-		addr:           net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
 		user:           option.UserName,
 		pass:           option.Password,
 		tls:            option.TLS,
@@ -108,3 +149,50 @@ func NewSocks5(option Socks5Option) *Socks5 {
 		tlsConfig:      tlsConfig,
 	}
 }
+
+type socksPacketConn struct {
+	net.PacketConn
+	rAddr   net.Addr
+	tcpConn net.Conn
+}
+
+func (uc *socksPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
+	packet, err := socks5.EncodeUDPPacket(socks5.ParseAddrToSocksAddr(addr), b)
+	if err != nil {
+		return
+	}
+	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)
+	if e != nil {
+		return 0, nil, e
+	}
+	addr, payload, err := socks5.DecodeUDPPacket(b)
+	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
+	copy(b, payload)
+	return n - len(addr) - 3, udpAddr, nil
+}
+
+func (uc *socksPacketConn) Close() error {
+	uc.tcpConn.Close()
+	return uc.PacketConn.Close()
+}

adapters/outbound/trojan.go

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

adapters/outbound/urltest.go

@@ -1,162 +0,0 @@
-package adapters
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"net"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/Dreamacro/clash/common/picker"
-	C "github.com/Dreamacro/clash/constant"
-)
-
-type URLTest struct {
-	*Base
-	proxies  []C.Proxy
-	rawURL   string
-	fast     C.Proxy
-	interval time.Duration
-	done     chan struct{}
-	once     int32
-}
-
-type URLTestOption struct {
-	Name     string   `proxy:"name"`
-	Proxies  []string `proxy:"proxies"`
-	URL      string   `proxy:"url"`
-	Interval int      `proxy:"interval"`
-}
-
-func (u *URLTest) Now() string {
-	return u.fast.Name()
-}
-
-func (u *URLTest) Dial(metadata *C.Metadata) (net.Conn, error) {
-	a, err := u.fast.Dial(metadata)
-	if err != nil {
-		u.fallback()
-	}
-	return a, err
-}
-
-func (u *URLTest) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
-	return u.fast.DialUDP(metadata)
-}
-
-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 (u *URLTest) Destroy() {
-	u.done <- struct{}{}
-}
-
-func (u *URLTest) loop() {
-	tick := time.NewTicker(u.interval)
-	go u.speedTest()
-Loop:
-	for {
-		select {
-		case <-tick.C:
-			go u.speedTest()
-		case <-u.done:
-			break Loop
-		}
-	}
-}
-
-func (u *URLTest) fallback() {
-	fast := u.proxies[0]
-	min := fast.LastDelay()
-	for _, proxy := range u.proxies[1:] {
-		if !proxy.Alive() {
-			continue
-		}
-
-		delay := proxy.LastDelay()
-		if delay < min {
-			fast = proxy
-			min = delay
-		}
-	}
-	u.fast = fast
-}
-
-func (u *URLTest) speedTest() {
-	if !atomic.CompareAndSwapInt32(&u.once, 0, 1) {
-		return
-	}
-	defer atomic.StoreInt32(&u.once, 0)
-
-	wg := sync.WaitGroup{}
-	wg.Add(len(u.proxies))
-	c := make(chan interface{})
-	fast := picker.SelectFast(context.Background(), c)
-	timer := time.NewTimer(u.interval)
-
-	for _, p := range u.proxies {
-		go func(p C.Proxy) {
-			_, err := p.URLTest(u.rawURL)
-			if err == nil {
-				c <- p
-			}
-			wg.Done()
-		}(p)
-	}
-
-	go func() {
-		wg.Wait()
-		close(c)
-	}()
-
-	select {
-	case <-timer.C:
-		// Wait for fast to return or close.
-		<-fast
-	case p, open := <-fast:
-		if open {
-			u.fast = p.(C.Proxy)
-		}
-	}
-}
-
-func NewURLTest(option URLTestOption, proxies []C.Proxy) (*URLTest, error) {
-	_, err := urlToMetadata(option.URL)
-	if err != nil {
-		return nil, err
-	}
-	if len(proxies) < 1 {
-		return nil, errors.New("The number of proxies cannot be 0")
-	}
-
-	interval := time.Duration(option.Interval) * time.Second
-	urlTest := &URLTest{
-		Base: &Base{
-			name: option.Name,
-			tp:   C.URLTest,
-		},
-		proxies:  proxies[:],
-		rawURL:   option.URL,
-		fast:     proxies[0],
-		interval: interval,
-		done:     make(chan struct{}),
-		once:     0,
-	}
-	go urlTest.loop()
-	return urlTest, nil
-}

adapters/outbound/util.go

@@ -1,4 +1,4 @@
-package adapters
+package outbound
 
 import (
 	"bytes"
@@ -10,9 +10,9 @@ import (
 	"sync"
 	"time"
 
+	"github.com/Dreamacro/clash/component/resolver"
 	"github.com/Dreamacro/clash/component/socks5"
 	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/dns"
 )
 
 const (
@@ -32,11 +32,12 @@ func urlToMetadata(rawURL string) (addr C.Metadata, err error) {
 
 	port := u.Port()
 	if port == "" {
-		if u.Scheme == "https" {
+		switch u.Scheme {
+		case "https":
 			port = "443"
-		} else if u.Scheme == "http" {
+		case "http":
 			port = "80"
-		} else {
+		default:
 			err = fmt.Errorf("%s scheme not Support", rawURL)
 			return
 		}
@@ -85,40 +86,13 @@ func serializesSocksAddr(metadata *C.Metadata) []byte {
 	return bytes.Join(buf, nil)
 }
 
-type fakeUDPConn struct {
-	net.Conn
-}
-
-func (fuc *fakeUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
-	return fuc.Conn.Write(b)
-}
-
-func (fuc *fakeUDPConn) ReadFrom(b []byte) (int, net.Addr, error) {
-	n, err := fuc.Conn.Read(b)
-	return n, fuc.RemoteAddr(), err
-}
-
-func dialTimeout(network, address string, timeout time.Duration) (net.Conn, error) {
-	host, port, err := net.SplitHostPort(address)
-	if err != nil {
-		return nil, err
-	}
-
-	ip, err := dns.ResolveIP(host)
-	if err != nil {
-		return nil, err
-	}
-
-	return net.DialTimeout(network, net.JoinHostPort(ip.String(), port), timeout)
-}
-
 func resolveUDPAddr(network, address string) (*net.UDPAddr, error) {
 	host, port, err := net.SplitHostPort(address)
 	if err != nil {
 		return nil, err
 	}
 
-	ip, err := dns.ResolveIP(host)
+	ip, err := resolver.ResolveIP(host)
 	if err != nil {
 		return nil, err
 	}

adapters/outbound/vmess.go

@@ -1,18 +1,21 @@
-package adapters
+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
 }
 
@@ -31,24 +34,43 @@ type VmessOption struct {
 	SkipCertVerify bool              `proxy:"skip-cert-verify,omitempty"`
 }
 
-func (v *Vmess) Dial(metadata *C.Metadata) (net.Conn, error) {
+func (v *Vmess) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
-	c, err := dialTimeout("tcp", v.server, tcpTimeout)
+	return v.client.New(c, parseVmessAddr(metadata))
-	if err != nil {
-		return nil, fmt.Errorf("%s connect error", v.server)
-	}
-	tcpKeepAlive(c)
-	c, err = v.client.New(c, parseVmessAddr(metadata))
-	return c, err
 }
 
-func (v *Vmess) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
+func (v *Vmess) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
-	c, err := dialTimeout("tcp", v.server, tcpTimeout)
+	c, err := dialer.DialContext(ctx, "tcp", v.addr)
 	if err != nil {
-		return nil, nil, fmt.Errorf("%s connect error", v.server)
+		return nil, fmt.Errorf("%s connect error", v.addr)
+	}
+	tcpKeepAlive(c)
+
+	c, err = v.StreamConn(c, metadata)
+	return NewConn(c, v), err
+}
+
+func (v *Vmess) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
+	// vmess use stream-oriented udp, so clash needs a net.UDPAddr
+	if !metadata.Resolved() {
+		ip, err := resolver.ResolveIP(metadata.Host)
+		if err != nil {
+			return nil, errors.New("can't resolve ip")
+		}
+		metadata.DstIP = ip
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), tcpTimeout)
+	defer cancel()
+	c, err := dialer.DialContext(ctx, "tcp", v.addr)
+	if err != nil {
+		return nil, fmt.Errorf("%s connect error", v.addr)
 	}
 	tcpKeepAlive(c)
 	c, err = v.client.New(c, parseVmessAddr(metadata))
-	return &fakeUDPConn{Conn: c}, c.LocalAddr(), err
+	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) {
@@ -64,7 +86,7 @@ func NewVmess(option VmessOption) (*Vmess, error) {
 		WebSocketPath:    option.WSPath,
 		WebSocketHeaders: option.WSHeaders,
 		SkipCertVerify:   option.SkipCertVerify,
-		SessionCacahe:    getClientSessionCache(),
+		SessionCache:     getClientSessionCache(),
 	})
 	if err != nil {
 		return nil, err
@@ -73,10 +95,10 @@ func NewVmess(option VmessOption) (*Vmess, error) {
 	return &Vmess{
 		Base: &Base{
 			name: option.Name,
+			addr: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
 			tp:   C.Vmess,
-			udp:  option.UDP,
+			udp:  true,
 		},
-		server: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
 		client: client,
 	}, nil
 }
@@ -108,3 +130,21 @@ func parseVmessAddr(metadata *C.Metadata) *vmess.DstAddr {
 		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
+}

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
+}

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,
+	}
+}

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,
+	}
+}

adapters/outboundgroup/parser.go

@@ -0,0 +1,146 @@
+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" || groupOption.Type == "relay" {
+				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)
+	case "relay":
+		group = NewRelay(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
+}

adapters/outboundgroup/relay.go

@@ -0,0 +1,84 @@
+package outboundgroup
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"github.com/Dreamacro/clash/adapters/outbound"
+	"github.com/Dreamacro/clash/adapters/provider"
+	"github.com/Dreamacro/clash/common/singledo"
+	"github.com/Dreamacro/clash/component/dialer"
+	C "github.com/Dreamacro/clash/constant"
+)
+
+type Relay struct {
+	*outbound.Base
+	single    *singledo.Single
+	providers []provider.ProxyProvider
+}
+
+func (r *Relay) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
+	proxies := r.proxies()
+	if len(proxies) == 0 {
+		return nil, errors.New("Proxy does not exist")
+	}
+	first := proxies[0]
+	last := proxies[len(proxies)-1]
+
+	c, err := dialer.DialContext(ctx, "tcp", first.Addr())
+	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
+}
+
+func (r *Relay) MarshalJSON() ([]byte, error) {
+	var all []string
+	for _, proxy := range r.proxies() {
+		all = append(all, proxy.Name())
+	}
+	return json.Marshal(map[string]interface{}{
+		"type": r.Type().String(),
+		"all":  all,
+	})
+}
+
+func (r *Relay) proxies() []C.Proxy {
+	elm, _, _ := r.single.Do(func() (interface{}, error) {
+		return getProvidersProxies(r.providers), nil
+	})
+
+	return elm.([]C.Proxy)
+}
+
+func NewRelay(name string, providers []provider.ProxyProvider) *Relay {
+	return &Relay{
+		Base:      outbound.NewBase(name, "", C.Relay, false),
+		single:    singledo.NewSingle(defaultGetProxiesDuration),
+		providers: providers,
+	}
+}

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,
+	}
+}

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,
+	}
+}

adapters/outboundgroup/util.go

@@ -0,0 +1,53 @@
+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 {
+		if ip.To4() != nil {
+			addr = &C.Metadata{
+				AddrType: C.AtypIPv4,
+				Host:     "",
+				DstIP:    ip,
+				DstPort:  port,
+			}
+			return
+		} else {
+			addr = &C.Metadata{
+				AddrType: C.AtypIPv6,
+				Host:     "",
+				DstIP:    ip,
+				DstPort:  port,
+			}
+			return
+		}
+	} else {
+		addr = &C.Metadata{
+			AddrType: C.AtypDomainName,
+			Host:     host,
+			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)
+	}
+}

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),
+	}
+}

adapters/provider/parser.go

@@ -0,0 +1,58 @@
+package provider
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/Dreamacro/clash/common/structure"
+	C "github.com/Dreamacro/clash/constant"
+)
+
+var (
+	errVehicleType = errors.New("unsupport vehicle type")
+)
+
+type healthCheckSchema struct {
+	Enable   bool   `provider:"enable"`
+	URL      string `provider:"url"`
+	Interval int    `provider:"interval"`
+}
+
+type proxyProviderSchema struct {
+	Type        string            `provider:"type"`
+	Path        string            `provider:"path"`
+	URL         string            `provider:"url,omitempty"`
+	Interval    int               `provider:"interval,omitempty"`
+	HealthCheck healthCheckSchema `provider:"health-check,omitempty"`
+}
+
+func ParseProxyProvider(name string, mapping map[string]interface{}) (ProxyProvider, error) {
+	decoder := structure.NewDecoder(structure.Option{TagName: "provider", WeaklyTypedInput: true})
+
+	schema := &proxyProviderSchema{}
+	if err := decoder.Decode(mapping, schema); err != nil {
+		return nil, err
+	}
+
+	var hcInterval uint = 0
+	if schema.HealthCheck.Enable {
+		hcInterval = uint(schema.HealthCheck.Interval)
+	}
+	hc := NewHealthCheck([]C.Proxy{}, schema.HealthCheck.URL, hcInterval)
+
+	path := C.Path.Resolve(schema.Path)
+
+	var vehicle Vehicle
+	switch schema.Type {
+	case "file":
+		vehicle = NewFileVehicle(path)
+	case "http":
+		vehicle = NewHTTPVehicle(schema.URL, path)
+	default:
+		return nil, fmt.Errorf("%w: %s", errVehicleType, schema.Type)
+	}
+
+	interval := time.Duration(uint(schema.Interval)) * time.Second
+	return NewProxySetProvider(name, interval, vehicle, hc), nil
+}

adapters/provider/provider.go

@@ -0,0 +1,333 @@
+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
+	var isLocal bool
+	if stat, err := os.Stat(pp.vehicle.Path()); err == nil {
+		buf, err = ioutil.ReadFile(pp.vehicle.Path())
+		modTime := stat.ModTime()
+		pp.updatedAt = &modTime
+		isLocal = true
+	} else {
+		buf, err = pp.vehicle.Read()
+	}
+
+	if err != nil {
+		return err
+	}
+
+	proxies, err := pp.parse(buf)
+	if err != nil {
+		if !isLocal {
+			return err
+		}
+
+		// parse local file error, fallback to remote
+		buf, err = pp.vehicle.Read()
+		if err != nil {
+			return err
+		}
+
+		proxies, err = pp.parse(buf)
+		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
+}

adapters/provider/vehicle.go

@@ -0,0 +1,109 @@
+package provider
+
+import (
+	"context"
+	"io/ioutil"
+	"net/http"
+	"time"
+
+	"github.com/Dreamacro/clash/component/dialer"
+)
+
+// Vehicle Type
+const (
+	File VehicleType = iota
+	HTTP
+	Compatible
+)
+
+// VehicleType defined
+type VehicleType int
+
+func (v VehicleType) String() string {
+	switch v {
+	case File:
+		return "File"
+	case HTTP:
+		return "HTTP"
+	case Compatible:
+		return "Compatible"
+	default:
+		return "Unknown"
+	}
+}
+
+type Vehicle interface {
+	Read() ([]byte, error)
+	Path() string
+	Type() VehicleType
+}
+
+type FileVehicle struct {
+	path string
+}
+
+func (f *FileVehicle) Type() VehicleType {
+	return File
+}
+
+func (f *FileVehicle) Path() string {
+	return f.path
+}
+
+func (f *FileVehicle) Read() ([]byte, error) {
+	return ioutil.ReadFile(f.path)
+}
+
+func NewFileVehicle(path string) *FileVehicle {
+	return &FileVehicle{path: path}
+}
+
+type HTTPVehicle struct {
+	url  string
+	path string
+}
+
+func (h *HTTPVehicle) Type() VehicleType {
+	return HTTP
+}
+
+func (h *HTTPVehicle) Path() string {
+	return h.path
+}
+
+func (h *HTTPVehicle) Read() ([]byte, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*20)
+	defer cancel()
+
+	req, err := http.NewRequest(http.MethodGet, h.url, nil)
+	if err != nil {
+		return nil, err
+	}
+	req = req.WithContext(ctx)
+
+	transport := &http.Transport{
+		// from http.DefaultTransport
+		MaxIdleConns:          100,
+		IdleConnTimeout:       90 * time.Second,
+		TLSHandshakeTimeout:   10 * time.Second,
+		ExpectContinueTimeout: 1 * time.Second,
+		DialContext:           dialer.DialContext,
+	}
+
+	client := http.Client{Transport: transport}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	buf, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	return buf, nil
+}
+
+func NewHTTPVehicle(url string, path string) *HTTPVehicle {
+	return &HTTPVehicle{url, path}
+}

common/cache/cache_test.go

@@ -4,6 +4,8 @@ import (
 	"runtime"
 	"testing"
 	"time"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestCache_Basic(t *testing.T) {
@@ -14,32 +16,30 @@ func TestCache_Basic(t *testing.T) {
 	c.Put("string", "a", ttl)
 
 	i := c.Get("int")
-	if i.(int) != 1 {
+	assert.Equal(t, i.(int), 1, "should recv 1")
-		t.Error("should recv 1")
-	}
 
 	s := c.Get("string")
-	if s.(string) != "a" {
+	assert.Equal(t, s.(string), "a", "should recv 'a'")
-		t.Error("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")
-	if i.(int) != 1 {
+	_, expired := c.GetWithExpire("int2")
-		t.Error("should recv 1")
+	assert.Equal(t, i.(int), 1, "should recv 1")
-	}
+	assert.True(t, now.Before(expired))
 
 	time.Sleep(ttl * 2)
 	i = c.Get("int")
-	if i != nil {
+	j, _ := c.GetWithExpire("int2")
-		t.Error("should recv nil")
+	assert.Nil(t, i, "should recv nil")
-	}
+	assert.Nil(t, j, "should recv nil")
 }
 
 func TestCache_AutoCleanup(t *testing.T) {
@@ -50,9 +50,9 @@ func TestCache_AutoCleanup(t *testing.T) {
 
 	time.Sleep(ttl * 2)
 	i := c.Get("int")
-	if i != nil {
+	j, _ := c.GetWithExpire("int")
-		t.Error("should recv nil")
+	assert.Nil(t, i, "should recv nil")
-	}
+	assert.Nil(t, j, "should recv nil")
 }
 
 func TestCache_AutoGC(t *testing.T) {

common/cache/lrucache.go

@@ -0,0 +1,171 @@
+package cache
+
+// Modified by https://github.com/die-net/lrucache
+
+import (
+	"container/list"
+	"sync"
+	"time"
+)
+
+// Option is part of Functional Options Pattern
+type Option func(*LruCache)
+
+// EvictCallback is used to get a callback when a cache entry is evicted
+type EvictCallback = func(key interface{}, value interface{})
+
+// WithEvict set the evict callback
+func WithEvict(cb EvictCallback) Option {
+	return func(l *LruCache) {
+		l.onEvict = cb
+	}
+}
+
+// WithUpdateAgeOnGet update expires when Get element
+func WithUpdateAgeOnGet() Option {
+	return func(l *LruCache) {
+		l.updateAgeOnGet = true
+	}
+}
+
+// WithAge defined element max age (second)
+func WithAge(maxAge int64) Option {
+	return func(l *LruCache) {
+		l.maxAge = maxAge
+	}
+}
+
+// WithSize defined max length of LruCache
+func WithSize(maxSize int) Option {
+	return func(l *LruCache) {
+		l.maxSize = maxSize
+	}
+}
+
+// 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.
+type LruCache struct {
+	maxAge         int64
+	maxSize        int
+	mu             sync.Mutex
+	cache          map[interface{}]*list.Element
+	lru            *list.List // Front is least-recent
+	updateAgeOnGet bool
+	onEvict        EvictCallback
+}
+
+// NewLRUCache creates an LruCache
+func NewLRUCache(options ...Option) *LruCache {
+	lc := &LruCache{
+		lru:   list.New(),
+		cache: make(map[interface{}]*list.Element),
+	}
+
+	for _, option := range options {
+		option(lc)
+	}
+
+	return lc
+}
+
+// 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 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
+}
+
+// Exist returns if key exist in cache but not put item to the head of linked list
+func (c *LruCache) Exist(key interface{}) bool {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	_, ok := c.cache[key]
+	return ok
+}
+
+// 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
+	}
+
+	if le, ok := c.cache[key]; ok {
+		c.lru.MoveToBack(le)
+		e := le.Value.(*entry)
+		e.value = value
+		e.expires = expires
+	} else {
+		e := &entry{key: key, value: value, expires: expires}
+		c.cache[key] = c.lru.PushBack(e)
+
+		if c.maxSize > 0 {
+			if len := c.lru.Len(); len > c.maxSize {
+				c.deleteElement(c.lru.Front())
+			}
+		}
+	}
+
+	c.maybeDeleteOldest()
+}
+
+// Delete removes the value associated with a key.
+func (c *LruCache) Delete(key string) {
+	c.mu.Lock()
+
+	if le, ok := c.cache[key]; ok {
+		c.deleteElement(le)
+	}
+
+	c.mu.Unlock()
+}
+
+func (c *LruCache) maybeDeleteOldest() {
+	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)
+		}
+	}
+}
+
+func (c *LruCache) deleteElement(le *list.Element) {
+	c.lru.Remove(le)
+	e := le.Value.(*entry)
+	delete(c.cache, e.key)
+	if c.onEvict != nil {
+		c.onEvict(e.key, e.value)
+	}
+}
+
+type entry struct {
+	key     interface{}
+	value   interface{}
+	expires int64
+}

common/cache/lrucache_test.go

@@ -0,0 +1,138 @@
+package cache
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var entries = []struct {
+	key   string
+	value string
+}{
+	{"1", "one"},
+	{"2", "two"},
+	{"3", "three"},
+	{"4", "four"},
+	{"5", "five"},
+}
+
+func TestLRUCache(t *testing.T) {
+	c := NewLRUCache()
+
+	for _, e := range entries {
+		c.Set(e.key, e.value)
+	}
+
+	c.Delete("missing")
+	_, ok := c.Get("missing")
+	assert.False(t, ok)
+
+	for _, e := range entries {
+		value, ok := c.Get(e.key)
+		if assert.True(t, ok) {
+			assert.Equal(t, e.value, value.(string))
+		}
+	}
+
+	for _, e := range entries {
+		c.Delete(e.key)
+
+		_, ok := c.Get(e.key)
+		assert.False(t, ok)
+	}
+}
+
+func TestLRUMaxAge(t *testing.T) {
+	c := NewLRUCache(WithAge(86400))
+
+	now := time.Now().Unix()
+	expected := now + 86400
+
+	// Add one expired entry
+	c.Set("foo", "bar")
+	c.lru.Back().Value.(*entry).expires = now
+
+	// Reset
+	c.Set("foo", "bar")
+	e := c.lru.Back().Value.(*entry)
+	assert.True(t, e.expires >= now)
+	c.lru.Back().Value.(*entry).expires = now
+
+	// Set a few and verify expiration times
+	for _, s := range entries {
+		c.Set(s.key, s.value)
+		e := c.lru.Back().Value.(*entry)
+		assert.True(t, e.expires >= expected && e.expires <= expected+10)
+	}
+
+	// Make sure we can get them all
+	for _, s := range entries {
+		_, ok := c.Get(s.key)
+		assert.True(t, ok)
+	}
+
+	// Expire all entries
+	for _, s := range entries {
+		le, ok := c.cache[s.key]
+		if assert.True(t, ok) {
+			le.Value.(*entry).expires = now
+		}
+	}
+
+	// Get one expired entry, which should clear all expired entries
+	_, ok := c.Get("3")
+	assert.False(t, ok)
+	assert.Equal(t, c.lru.Len(), 0)
+}
+
+func TestLRUpdateOnGet(t *testing.T) {
+	c := NewLRUCache(WithAge(86400), WithUpdateAgeOnGet())
+
+	now := time.Now().Unix()
+	expires := now + 86400/2
+
+	// Add one expired entry
+	c.Set("foo", "bar")
+	c.lru.Back().Value.(*entry).expires = expires
+
+	_, ok := c.Get("foo")
+	assert.True(t, ok)
+	assert.True(t, c.lru.Back().Value.(*entry).expires > expires)
+}
+
+func TestMaxSize(t *testing.T) {
+	c := NewLRUCache(WithSize(2))
+	// Add one expired entry
+	c.Set("foo", "bar")
+	_, ok := c.Get("foo")
+	assert.True(t, ok)
+
+	c.Set("bar", "foo")
+	c.Set("baz", "foo")
+
+	_, ok = c.Get("foo")
+	assert.False(t, ok)
+}
+
+func TestExist(t *testing.T) {
+	c := NewLRUCache(WithSize(1))
+	c.Set(1, 2)
+	assert.True(t, c.Exist(1))
+	c.Set(2, 3)
+	assert.False(t, c.Exist(1))
+}
+
+func TestEvict(t *testing.T) {
+	temp := 0
+	evict := func(key interface{}, value interface{}) {
+		temp = key.(int) + value.(int)
+	}
+
+	c := NewLRUCache(WithEvict(evict), WithSize(1))
+	c.Set(1, 2)
+	c.Set(2, 3)
+
+	assert.Equal(t, temp, 3)
+}

common/observable/observable.go

@@ -7,60 +7,58 @@ import (
 
 type Observable struct {
 	iterable Iterable
-	listener *sync.Map
+	listener map[Subscription]*Subscriber
+	mux      sync.Mutex
 	done     bool
-	doneLock sync.RWMutex
 }
 
 func (o *Observable) process() {
 	for item := range o.iterable {
-		o.listener.Range(func(key, value interface{}) bool {
+		o.mux.Lock()
-			elm := value.(*Subscriber)
+		for _, sub := range o.listener {
-			elm.Emit(item)
+			sub.Emit(item)
-			return true
+		}
-		})
+		o.mux.Unlock()
 	}
 	o.close()
 }
 
 func (o *Observable) close() {
-	o.doneLock.Lock()
+	o.mux.Lock()
-	o.done = true
+	defer o.mux.Unlock()
-	o.doneLock.Unlock()
 
-	o.listener.Range(func(key, value interface{}) bool {
+	o.done = true
-		elm := value.(*Subscriber)
+	for _, sub := range o.listener {
-		elm.Close()
+		sub.Close()
-		return true
+	}
-	})
 }
 
 func (o *Observable) Subscribe() (Subscription, error) {
-	o.doneLock.RLock()
+	o.mux.Lock()
-	done := o.done
+	defer o.mux.Unlock()
-	o.doneLock.RUnlock()
+	if o.done {
-	if done == true {
 		return nil, errors.New("Observable is closed")
 	}
 	subscriber := newSubscriber()
-	o.listener.Store(subscriber.Out(), subscriber)
+	o.listener[subscriber.Out()] = subscriber
 	return subscriber.Out(), nil
 }
 
 func (o *Observable) UnSubscribe(sub Subscription) {
-	elm, exist := o.listener.Load(sub)
+	o.mux.Lock()
+	defer o.mux.Unlock()
+	subscriber, exist := o.listener[sub]
 	if !exist {
 		return
 	}
-	subscriber := elm.(*Subscriber)
+	delete(o.listener, sub)
-	o.listener.Delete(subscriber.Out())
 	subscriber.Close()
 }
 
 func NewObservable(any Iterable) *Observable {
 	observable := &Observable{
 		iterable: any,
-		listener: &sync.Map{},
+		listener: map[Subscription]*Subscriber{},
 	}
 	go observable.process()
 	return observable

common/observable/observable_test.go

@@ -5,6 +5,8 @@ import (
 	"sync"
 	"testing"
 	"time"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func iterator(item []interface{}) chan interface{} {
@@ -23,16 +25,12 @@ func TestObservable(t *testing.T) {
 	iter := iterator([]interface{}{1, 2, 3, 4, 5})
 	src := NewObservable(iter)
 	data, err := src.Subscribe()
-	if err != nil {
+	assert.Nil(t, err)
-		t.Error(err)
-	}
 	count := 0
 	for range data {
-		count = count + 1
+		count++
-	}
-	if count != 5 {
-		t.Error("Revc number error")
 	}
+	assert.Equal(t, count, 5)
 }
 
 func TestObservable_MutilSubscribe(t *testing.T) {
@@ -46,30 +44,24 @@ func TestObservable_MutilSubscribe(t *testing.T) {
 	wg.Add(2)
 	waitCh := func(ch <-chan interface{}) {
 		for range ch {
-			count = count + 1
+			count++
 		}
 		wg.Done()
 	}
 	go waitCh(ch1)
 	go waitCh(ch2)
 	wg.Wait()
-	if count != 10 {
+	assert.Equal(t, count, 10)
-		t.Error("Revc number error")
-	}
 }
 
 func TestObservable_UnSubscribe(t *testing.T) {
 	iter := iterator([]interface{}{1, 2, 3, 4, 5})
 	src := NewObservable(iter)
 	data, err := src.Subscribe()
-	if err != nil {
+	assert.Nil(t, err)
-		t.Error(err)
-	}
 	src.UnSubscribe(data)
 	_, open := <-data
-	if open {
+	assert.False(t, open)
-		t.Error("Revc number error")
-	}
 }
 
 func TestObservable_SubscribeClosedSource(t *testing.T) {
@@ -79,9 +71,7 @@ func TestObservable_SubscribeClosedSource(t *testing.T) {
 	<-data
 
 	_, closed := src.Subscribe()
-	if closed == nil {
+	assert.NotNil(t, closed)
-		t.Error("Observable should be closed")
-	}
 }
 
 func TestObservable_UnSubscribeWithNotExistSubscription(t *testing.T) {
@@ -118,7 +108,5 @@ func TestObservable_SubscribeGoroutineLeak(t *testing.T) {
 	}
 	wg.Wait()
 	now := runtime.NumGoroutine()
-	if init != now {
+	assert.Equal(t, init, now)
-		t.Errorf("Goroutine Leak: init %d now %d", init, now)
-	}
 }

common/picker/picker.go

@@ -1,22 +1,69 @@
 package picker
 
-import "context"
+import (
+	"context"
+	"sync"
+	"time"
+)
+
+// Picker provides synchronization, and Context cancelation
+// for groups of goroutines working on subtasks of a common task.
+// Inspired by errGroup
+type Picker struct {
+	ctx    context.Context
+	cancel func()
+
+	wg sync.WaitGroup
+
+	once   sync.Once
+	result interface{}
+}
+
+func newPicker(ctx context.Context, cancel func()) *Picker {
+	return &Picker{
+		ctx:    ctx,
+		cancel: cancel,
+	}
+}
+
+// WithContext returns a new Picker and an associated Context derived from ctx.
+// and cancel when first element return.
+func WithContext(ctx context.Context) (*Picker, context.Context) {
+	ctx, cancel := context.WithCancel(ctx)
+	return newPicker(ctx, cancel), ctx
+}
+
+// WithTimeout returns a new Picker and an associated Context derived from ctx with timeout.
+func WithTimeout(ctx context.Context, timeout time.Duration) (*Picker, context.Context) {
+	ctx, cancel := context.WithTimeout(ctx, timeout)
+	return newPicker(ctx, cancel), ctx
+}
+
+// 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() interface{} {
+	p.wg.Wait()
+	if p.cancel != nil {
+		p.cancel()
+	}
+	return p.result
+}
+
+// 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() (interface{}, error)) {
+	p.wg.Add(1)
 
-func SelectFast(ctx context.Context, in <-chan interface{}) <-chan interface{} {
-	out := make(chan interface{})
 	go func() {
-		select {
+		defer p.wg.Done()
-		case p, open := <-in:
-			if open {
-				out <- p
-			}
-		case <-ctx.Done():
-		}
 
-		close(out)
+		if ret, err := f(); err == nil {
-		for range in {
+			p.once.Do(func() {
+				p.result = ret
+				if p.cancel != nil {
+					p.cancel()
+				}
+			})
 		}
 	}()
-
-	return out
 }

common/picker/picker_test.go

@@ -4,41 +4,36 @@ import (
 	"context"
 	"testing"
 	"time"
+
+	"github.com/stretchr/testify/assert"
 )
 
-func sleepAndSend(delay int, in chan<- interface{}, input interface{}) {
+func sleepAndSend(ctx context.Context, delay int, input interface{}) func() (interface{}, error) {
-	time.Sleep(time.Millisecond * time.Duration(delay))
+	return func() (interface{}, error) {
-	in <- input
+		timer := time.NewTimer(time.Millisecond * time.Duration(delay))
-}
+		select {
-
+		case <-timer.C:
-func sleepAndClose(delay int, in chan interface{}) {
+			return input, nil
-	time.Sleep(time.Millisecond * time.Duration(delay))
+		case <-ctx.Done():
-	close(in)
+			return nil, ctx.Err()
+		}
+	}
 }
 
 func TestPicker_Basic(t *testing.T) {
-	in := make(chan interface{})
+	picker, ctx := WithContext(context.Background())
-	fast := SelectFast(context.Background(), in)
+	picker.Go(sleepAndSend(ctx, 30, 2))
-	go sleepAndSend(20, in, 1)
+	picker.Go(sleepAndSend(ctx, 20, 1))
-	go sleepAndSend(30, in, 2)
-	go sleepAndClose(40, in)
 
-	number, exist := <-fast
+	number := picker.Wait()
-	if !exist || number != 1 {
+	assert.NotNil(t, number)
-		t.Error("should recv 1", exist, number)
+	assert.Equal(t, number.(int), 1)
-	}
 }
 
 func TestPicker_Timeout(t *testing.T) {
-	in := make(chan interface{})
+	picker, ctx := WithTimeout(context.Background(), time.Millisecond*5)
-	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*5)
+	picker.Go(sleepAndSend(ctx, 20, 1))
-	defer cancel()
-	fast := SelectFast(ctx, in)
-	go sleepAndSend(20, in, 1)
-	go sleepAndClose(30, in)
 
-	_, exist := <-fast
+	number := picker.Wait()
-	if exist {
+	assert.Nil(t, number)
-		t.Error("should recv false")
-	}
 }

common/queue/queue.go

@@ -34,16 +34,16 @@ func (q *Queue) Pop() interface{} {
 	return head
 }
 
-// First returns the head of items without deleting.
+// Last returns the last of item.
-func (q *Queue) First() interface{} {
+func (q *Queue) Last() interface{} {
 	if len(q.items) == 0 {
 		return nil
 	}
 
 	q.lock.RLock()
-	head := q.items[0]
+	last := q.items[len(q.items)-1]
 	q.lock.RUnlock()
-	return head
+	return last
 }
 
 // Copy get the copy of queue.

common/singledo/singledo.go

@@ -0,0 +1,55 @@
+package singledo
+
+import (
+	"sync"
+	"time"
+)
+
+type call struct {
+	wg  sync.WaitGroup
+	val interface{}
+	err error
+}
+
+type Single struct {
+	mux    sync.Mutex
+	last   time.Time
+	wait   time.Duration
+	call   *call
+	result *Result
+}
+
+type Result struct {
+	Val interface{}
+	Err error
+}
+
+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)) {
+		s.mux.Unlock()
+		return s.result.Val, s.result.Err, true
+	}
+
+	if call := s.call; call != nil {
+		s.mux.Unlock()
+		call.wg.Wait()
+		return call.val, call.err, true
+	}
+
+	call := &call{}
+	call.wg.Add(1)
+	s.call = call
+	s.mux.Unlock()
+	call.val, call.err = fn()
+	call.wg.Done()
+	s.call = nil
+	s.result = &Result{call.val, call.err}
+	s.last = now
+	return call.val, call.err, false
+}
+
+func NewSingle(wait time.Duration) *Single {
+	return &Single{wait: wait}
+}

common/singledo/singledo_test.go

@@ -0,0 +1,53 @@
+package singledo
+
+import (
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBasic(t *testing.T) {
+	single := NewSingle(time.Millisecond * 30)
+	foo := 0
+	shardCount := 0
+	call := func() (interface{}, error) {
+		foo++
+		time.Sleep(time.Millisecond * 5)
+		return nil, nil
+	}
+
+	var wg sync.WaitGroup
+	const n = 10
+	wg.Add(n)
+	for i := 0; i < n; i++ {
+		go func() {
+			_, _, shard := single.Do(call)
+			if shard {
+				shardCount++
+			}
+			wg.Done()
+		}()
+	}
+
+	wg.Wait()
+	assert.Equal(t, 1, foo)
+	assert.Equal(t, 9, shardCount)
+}
+
+func TestTimer(t *testing.T) {
+	single := NewSingle(time.Millisecond * 30)
+	foo := 0
+	call := func() (interface{}, error) {
+		foo++
+		return nil, nil
+	}
+
+	single.Do(call)
+	time.Sleep(10 * time.Millisecond)
+	_, _, shard := single.Do(call)
+
+	assert.Equal(t, 1, foo)
+	assert.True(t, shard)
+}

common/structure/structure.go

@@ -76,6 +76,8 @@ func (d *Decoder) decode(name string, data interface{}, val reflect.Value) error
 		return d.decodeMap(name, data, val)
 	case reflect.Interface:
 		return d.setInterface(name, data, val)
+	case reflect.Struct:
+		return d.decodeStruct(name, data, val)
 	default:
 		return fmt.Errorf("type %s not support", val.Kind().String())
 	}
@@ -214,6 +216,11 @@ 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())
@@ -232,6 +239,159 @@ func (d *Decoder) decodeMapFromMap(name string, dataVal reflect.Value, val refle
 	return nil
 }
 
+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,
+	// then we just set it directly instead of recursing into the structure.
+	if dataVal.Type() == val.Type() {
+		val.Set(dataVal)
+		return nil
+	}
+
+	dataValKind := dataVal.Kind()
+	switch dataValKind {
+	case reflect.Map:
+		return d.decodeStructFromMap(name, dataVal, val)
+	default:
+		return fmt.Errorf("'%s' expected a map, got '%s'", name, dataVal.Kind())
+	}
+}
+
+func (d *Decoder) decodeStructFromMap(name string, dataVal, val reflect.Value) error {
+	dataValType := dataVal.Type()
+	if kind := dataValType.Key().Kind(); kind != reflect.String && kind != reflect.Interface {
+		return fmt.Errorf(
+			"'%s' needs a map with string keys, has '%s' keys",
+			name, dataValType.Key().Kind())
+	}
+
+	dataValKeys := make(map[reflect.Value]struct{})
+	dataValKeysUnused := make(map[interface{}]struct{})
+	for _, dataValKey := range dataVal.MapKeys() {
+		dataValKeys[dataValKey] = struct{}{}
+		dataValKeysUnused[dataValKey.Interface()] = struct{}{}
+	}
+
+	errors := make([]string, 0)
+
+	// This slice will keep track of all the structs we'll be decoding.
+	// There can be more than one struct if there are embedded structs
+	// that are squashed.
+	structs := make([]reflect.Value, 1, 5)
+	structs[0] = val
+
+	// Compile the list of all the fields that we're going to be decoding
+	// from all the structs.
+	type field struct {
+		field reflect.StructField
+		val   reflect.Value
+	}
+	fields := []field{}
+	for len(structs) > 0 {
+		structVal := structs[0]
+		structs = structs[1:]
+
+		structType := structVal.Type()
+
+		for i := 0; i < structType.NumField(); i++ {
+			fieldType := structType.Field(i)
+			fieldKind := fieldType.Type.Kind()
+
+			// If "squash" is specified in the tag, we squash the field down.
+			squash := false
+			tagParts := strings.Split(fieldType.Tag.Get(d.option.TagName), ",")
+			for _, tag := range tagParts[1:] {
+				if tag == "squash" {
+					squash = true
+					break
+				}
+			}
+
+			if squash {
+				if fieldKind != reflect.Struct {
+					errors = append(errors,
+						fmt.Errorf("%s: unsupported type for squash: %s", fieldType.Name, fieldKind).Error())
+				} else {
+					structs = append(structs, structVal.FieldByName(fieldType.Name))
+				}
+				continue
+			}
+
+			// Normal struct field, store it away
+			fields = append(fields, field{fieldType, structVal.Field(i)})
+		}
+	}
+
+	// for fieldType, field := range fields {
+	for _, f := range fields {
+		field, fieldValue := f.field, f.val
+		fieldName := field.Name
+
+		tagValue := field.Tag.Get(d.option.TagName)
+		tagValue = strings.SplitN(tagValue, ",", 2)[0]
+		if tagValue != "" {
+			fieldName = tagValue
+		}
+
+		rawMapKey := reflect.ValueOf(fieldName)
+		rawMapVal := dataVal.MapIndex(rawMapKey)
+		if !rawMapVal.IsValid() {
+			// Do a slower search by iterating over each key and
+			// doing case-insensitive search.
+			for dataValKey := range dataValKeys {
+				mK, ok := dataValKey.Interface().(string)
+				if !ok {
+					// Not a string key
+					continue
+				}
+
+				if strings.EqualFold(mK, fieldName) {
+					rawMapKey = dataValKey
+					rawMapVal = dataVal.MapIndex(dataValKey)
+					break
+				}
+			}
+
+			if !rawMapVal.IsValid() {
+				// There was no matching key in the map for the value in
+				// the struct. Just ignore.
+				continue
+			}
+		}
+
+		// Delete the key we're using from the unused map so we stop tracking
+		delete(dataValKeysUnused, rawMapKey.Interface())
+
+		if !fieldValue.IsValid() {
+			// This should never happen
+			panic("field is not valid")
+		}
+
+		// If we can't set the field, then it is unexported or something,
+		// and we just continue onwards.
+		if !fieldValue.CanSet() {
+			continue
+		}
+
+		// If the name is empty string, then we're at the root, and we
+		// don't dot-join the fields.
+		if name != "" {
+			fieldName = fmt.Sprintf("%s.%s", name, fieldName)
+		}
+
+		if err := d.decode(fieldName, rawMapVal.Interface(), fieldValue); err != nil {
+			errors = append(errors, err.Error())
+		}
+	}
+
+	if len(errors) > 0 {
+		return fmt.Errorf(strings.Join(errors, ","))
+	}
+
+	return nil
+}
+
 func (d *Decoder) setInterface(name string, data interface{}, val reflect.Value) (err error) {
 	dataVal := reflect.ValueOf(data)
 	val.Set(dataVal)

component/dialer/dialer.go

@@ -0,0 +1,154 @@
+package dialer
+
+import (
+	"context"
+	"errors"
+	"net"
+
+	"github.com/Dreamacro/clash/component/resolver"
+)
+
+func Dialer() *net.Dialer {
+	dialer := &net.Dialer{}
+	if DialerHook != nil {
+		DialerHook(dialer)
+	}
+
+	return dialer
+}
+
+func ListenConfig() *net.ListenConfig {
+	cfg := &net.ListenConfig{}
+	if ListenConfigHook != nil {
+		ListenConfigHook(cfg)
+	}
+
+	return cfg
+}
+
+func Dial(network, address string) (net.Conn, error) {
+	return DialContext(context.Background(), network, address)
+}
+
+func DialContext(ctx context.Context, network, address string) (net.Conn, error) {
+	switch network {
+	case "tcp4", "tcp6", "udp4", "udp6":
+		host, port, err := net.SplitHostPort(address)
+		if err != nil {
+			return nil, err
+		}
+
+		dialer := Dialer()
+
+		var ip net.IP
+		switch network {
+		case "tcp4", "udp4":
+			ip, err = resolver.ResolveIPv4(host)
+		default:
+			ip, err = resolver.ResolveIPv6(host)
+		}
+
+		if err != nil {
+			return nil, err
+		}
+
+		if DialHook != nil {
+			DialHook(dialer, network, ip)
+		}
+		return dialer.DialContext(ctx, network, net.JoinHostPort(ip.String(), port))
+	case "tcp", "udp":
+		return dualStackDailContext(ctx, network, address)
+	default:
+		return nil, errors.New("network invalid")
+	}
+}
+
+func ListenPacket(network, address string) (net.PacketConn, error) {
+	lc := ListenConfig()
+
+	if ListenPacketHook != nil && address == "" {
+		ip := ListenPacketHook()
+		if ip != nil {
+			address = net.JoinHostPort(ip.String(), "0")
+		}
+	}
+	return lc.ListenPacket(context.Background(), network, address)
+}
+
+func dualStackDailContext(ctx context.Context, network, address string) (net.Conn, error) {
+	host, port, err := net.SplitHostPort(address)
+	if err != nil {
+		return nil, err
+	}
+
+	returned := make(chan struct{})
+	defer close(returned)
+
+	type dialResult struct {
+		net.Conn
+		error
+		resolved bool
+		ipv6     bool
+		done     bool
+	}
+	results := make(chan dialResult)
+	var primary, fallback dialResult
+
+	startRacer := func(ctx context.Context, network, host string, ipv6 bool) {
+		dialer := Dialer()
+		result := dialResult{ipv6: ipv6, done: true}
+		defer func() {
+			select {
+			case results <- result:
+			case <-returned:
+				if result.Conn != nil {
+					result.Conn.Close()
+				}
+			}
+		}()
+
+		var ip net.IP
+		if ipv6 {
+			ip, result.error = resolver.ResolveIPv6(host)
+		} else {
+			ip, result.error = resolver.ResolveIPv4(host)
+		}
+		if result.error != nil {
+			return
+		}
+		result.resolved = true
+
+		if DialHook != nil {
+			DialHook(dialer, network, ip)
+		}
+		result.Conn, result.error = dialer.DialContext(ctx, network, net.JoinHostPort(ip.String(), port))
+	}
+
+	go startRacer(ctx, network+"4", host, false)
+	go startRacer(ctx, network+"6", host, true)
+
+	for {
+		select {
+		case res := <-results:
+			if res.error == nil {
+				return res.Conn, nil
+			}
+
+			if !res.ipv6 {
+				primary = res
+			} else {
+				fallback = res
+			}
+
+			if primary.done && fallback.done {
+				if primary.resolved {
+					return nil, primary.error
+				} else if fallback.resolved {
+					return nil, fallback.error
+				} else {
+					return nil, primary.error
+				}
+			}
+		}
+	}
+}

component/dialer/hook.go

@@ -0,0 +1,142 @@
+package dialer
+
+import (
+	"errors"
+	"net"
+	"time"
+
+	"github.com/Dreamacro/clash/common/singledo"
+)
+
+type DialerHookFunc = func(dialer *net.Dialer)
+type DialHookFunc = func(dialer *net.Dialer, network string, ip net.IP)
+type ListenConfigHookFunc = func(*net.ListenConfig)
+type ListenPacketHookFunc = func() net.IP
+
+var (
+	DialerHook       DialerHookFunc
+	DialHook         DialHookFunc
+	ListenConfigHook ListenConfigHookFunc
+	ListenPacketHook ListenPacketHookFunc
+)
+
+var (
+	ErrAddrNotFound      = errors.New("addr not found")
+	ErrNetworkNotSupport = errors.New("network not support")
+)
+
+func lookupTCPAddr(ip net.IP, addrs []net.Addr) (*net.TCPAddr, error) {
+	ipv4 := ip.To4() != nil
+
+	for _, elm := range addrs {
+		addr, ok := elm.(*net.IPNet)
+		if !ok {
+			continue
+		}
+
+		addrV4 := addr.IP.To4() != nil
+
+		if addrV4 && ipv4 {
+			return &net.TCPAddr{IP: addr.IP, Port: 0}, nil
+		} else if !addrV4 && !ipv4 {
+			return &net.TCPAddr{IP: addr.IP, Port: 0}, nil
+		}
+	}
+
+	return nil, ErrAddrNotFound
+}
+
+func lookupUDPAddr(ip net.IP, addrs []net.Addr) (*net.UDPAddr, error) {
+	ipv4 := ip.To4() != nil
+
+	for _, elm := range addrs {
+		addr, ok := elm.(*net.IPNet)
+		if !ok {
+			continue
+		}
+
+		addrV4 := addr.IP.To4() != nil
+
+		if addrV4 && ipv4 {
+			return &net.UDPAddr{IP: addr.IP, Port: 0}, nil
+		} else if !addrV4 && !ipv4 {
+			return &net.UDPAddr{IP: addr.IP, Port: 0}, nil
+		}
+	}
+
+	return nil, ErrAddrNotFound
+}
+
+func ListenPacketWithInterface(name string) ListenPacketHookFunc {
+	single := singledo.NewSingle(5 * time.Second)
+
+	return func() net.IP {
+		elm, err, _ := single.Do(func() (interface{}, error) {
+			iface, err := net.InterfaceByName(name)
+			if err != nil {
+				return nil, err
+			}
+
+			addrs, err := iface.Addrs()
+			if err != nil {
+				return nil, err
+			}
+
+			return addrs, nil
+		})
+
+		if err != nil {
+			return nil
+		}
+
+		addrs := elm.([]net.Addr)
+
+		for _, elm := range addrs {
+			addr, ok := elm.(*net.IPNet)
+			if !ok || addr.IP.To4() == nil {
+				continue
+			}
+
+			return addr.IP
+		}
+
+		return nil
+	}
+}
+
+func DialerWithInterface(name string) DialHookFunc {
+	single := singledo.NewSingle(5 * time.Second)
+
+	return func(dialer *net.Dialer, network string, ip net.IP) {
+		elm, err, _ := single.Do(func() (interface{}, error) {
+			iface, err := net.InterfaceByName(name)
+			if err != nil {
+				return nil, err
+			}
+
+			addrs, err := iface.Addrs()
+			if err != nil {
+				return nil, err
+			}
+
+			return addrs, nil
+		})
+
+		if err != nil {
+			return
+		}
+
+		addrs := elm.([]net.Addr)
+
+		switch network {
+		case "tcp", "tcp4", "tcp6":
+			if addr, err := lookupTCPAddr(ip, addrs); err == nil {
+				dialer.LocalAddr = addr
+			}
+		case "udp", "udp4", "udp6":
+			if addr, err := lookupUDPAddr(ip, addrs); err == nil {
+				dialer.LocalAddr = addr
+			}
+		}
+	}
+}

component/domain-trie/node.go

@@ -0,0 +1,26 @@
+package trie
+
+// Node is the trie's node
+type Node struct {
+	Data     interface{}
+	children map[string]*Node
+}
+
+func (n *Node) getChild(s string) *Node {
+	return n.children[s]
+}
+
+func (n *Node) hasChild(s string) bool {
+	return n.getChild(s) != nil
+}
+
+func (n *Node) addChild(s string, child *Node) {
+	n.children[s] = child
+}
+
+func newNode(data interface{}) *Node {
+	return &Node{
+		Data:     data,
+		children: map[string]*Node{},
+	}
+}

component/domain-trie/tire.go

@@ -0,0 +1,92 @@
+package trie
+
+import (
+	"errors"
+	"strings"
+)
+
+const (
+	wildcard   = "*"
+	domainStep = "."
+)
+
+var (
+	// ErrInvalidDomain means insert domain is invalid
+	ErrInvalidDomain = errors.New("invalid domain")
+)
+
+// Trie contains the main logic for adding and searching nodes for domain segments.
+// support wildcard domain (e.g *.google.com)
+type Trie struct {
+	root *Node
+}
+
+func isValidDomain(domain string) bool {
+	return domain != "" && domain[0] != '.' && domain[len(domain)-1] != '.'
+}
+
+// Insert adds a node to the trie.
+// Support
+// 1. www.example.com
+// 2. *.example.com
+// 3. subdomain.*.example.com
+func (t *Trie) Insert(domain string, data interface{}) error {
+	if !isValidDomain(domain) {
+		return ErrInvalidDomain
+	}
+
+	parts := strings.Split(domain, domainStep)
+	node := t.root
+	// reverse storage domain part to save space
+	for i := len(parts) - 1; i >= 0; i-- {
+		part := parts[i]
+		if !node.hasChild(part) {
+			node.addChild(part, newNode(nil))
+		}
+
+		node = node.getChild(part)
+	}
+
+	node.Data = data
+	return nil
+}
+
+// Search is the most important part of the Trie.
+// Priority as:
+// 1. static part
+// 2. wildcard domain
+func (t *Trie) Search(domain string) *Node {
+	if !isValidDomain(domain) {
+		return nil
+	}
+	parts := strings.Split(domain, domainStep)
+
+	n := t.root
+	for i := len(parts) - 1; i >= 0; i-- {
+		part := parts[i]
+
+		var child *Node
+		if !n.hasChild(part) {
+			if !n.hasChild(wildcard) {
+				return nil
+			}
+
+			child = n.getChild(wildcard)
+		} else {
+			child = n.getChild(part)
+		}
+
+		n = child
+	}
+
+	if n.Data == nil {
+		return nil
+	}
+
+	return n
+}
+
+// New returns a new, empty Trie.
+func New() *Trie {
+	return &Trie{root: newNode(nil)}
+}

component/domain-trie/trie_test.go

@@ -0,0 +1,87 @@
+package trie
+
+import (
+	"net"
+	"testing"
+)
+
+var localIP = net.IP{127, 0, 0, 1}
+
+func TestTrie_Basic(t *testing.T) {
+	tree := New()
+	domains := []string{
+		"example.com",
+		"google.com",
+	}
+
+	for _, domain := range domains {
+		tree.Insert(domain, localIP)
+	}
+
+	node := tree.Search("example.com")
+	if node == nil {
+		t.Error("should not recv nil")
+	}
+
+	if !node.Data.(net.IP).Equal(localIP) {
+		t.Error("should equal 127.0.0.1")
+	}
+
+	if tree.Insert("", localIP) == nil {
+		t.Error("should return error")
+	}
+}
+
+func TestTrie_Wildcard(t *testing.T) {
+	tree := New()
+	domains := []string{
+		"*.example.com",
+		"sub.*.example.com",
+		"*.dev",
+	}
+
+	for _, domain := range domains {
+		tree.Insert(domain, localIP)
+	}
+
+	if tree.Search("sub.example.com") == nil {
+		t.Error("should not recv nil")
+	}
+
+	if tree.Search("sub.foo.example.com") == nil {
+		t.Error("should not recv nil")
+	}
+
+	if tree.Search("foo.sub.example.com") != nil {
+		t.Error("should recv nil")
+	}
+
+	if tree.Search("foo.example.dev") != nil {
+		t.Error("should recv nil")
+	}
+
+	if tree.Search("example.com") != nil {
+		t.Error("should recv nil")
+	}
+}
+
+func TestTrie_Boundary(t *testing.T) {
+	tree := New()
+	tree.Insert("*.dev", localIP)
+
+	if err := tree.Insert(".", localIP); err == nil {
+		t.Error("should recv err")
+	}
+
+	if err := tree.Insert(".com", localIP); err == nil {
+		t.Error("should recv err")
+	}
+
+	if tree.Search("dev") != nil {
+		t.Error("should recv nil")
+	}
+
+	if tree.Search(".dev") != nil {
+		t.Error("should recv nil")
+	}
+}

component/fakeip/pool.go

@@ -4,22 +4,106 @@ import (
 	"errors"
 	"net"
 	"sync"
+
+	"github.com/Dreamacro/clash/common/cache"
+	trie "github.com/Dreamacro/clash/component/domain-trie"
 )
 
 // Pool is a implementation about fake ip generator without storage
 type Pool struct {
-	max    uint32
+	max     uint32
-	min    uint32
+	min     uint32
-	offset uint32
+	gateway uint32
-	mux    *sync.Mutex
+	offset  uint32
+	mux     sync.Mutex
+	host    *trie.Trie
+	cache   *cache.LruCache
 }
 
-// Get return a new fake ip
+// Lookup return a fake ip with host
-func (p *Pool) Get() net.IP {
+func (p *Pool) Lookup(host string) net.IP {
 	p.mux.Lock()
 	defer p.mux.Unlock()
-	ip := uintToIP(p.min + p.offset)
+	if elm, exist := p.cache.Get(host); exist {
-	p.offset = (p.offset + 1) % (p.max - p.min)
+		ip := elm.(net.IP)
+
+		// ensure ip --> host on head of linked list
+		n := ipToUint(ip.To4())
+		offset := n - p.min + 1
+		p.cache.Get(offset)
+		return ip
+	}
+
+	ip := p.get(host)
+	p.cache.Set(host, ip)
+	return ip
+}
+
+// LookBack return host with the fake ip
+func (p *Pool) LookBack(ip net.IP) (string, bool) {
+	p.mux.Lock()
+	defer p.mux.Unlock()
+
+	if ip = ip.To4(); ip == nil {
+		return "", false
+	}
+
+	n := ipToUint(ip.To4())
+	offset := n - p.min + 1
+
+	if elm, exist := p.cache.Get(offset); exist {
+		host := elm.(string)
+
+		// ensure host --> ip on head of linked list
+		p.cache.Get(host)
+		return host, true
+	}
+
+	return "", false
+}
+
+// LookupHost return if domain in host
+func (p *Pool) LookupHost(domain string) bool {
+	if p.host == nil {
+		return false
+	}
+	return p.host.Search(domain) != nil
+}
+
+// Exist returns if given ip exists in fake-ip pool
+func (p *Pool) Exist(ip net.IP) bool {
+	p.mux.Lock()
+	defer p.mux.Unlock()
+
+	if ip = ip.To4(); ip == nil {
+		return false
+	}
+
+	n := ipToUint(ip.To4())
+	offset := n - p.min + 1
+	return p.cache.Exist(offset)
+}
+
+// Gateway return gateway ip
+func (p *Pool) Gateway() net.IP {
+	return uintToIP(p.gateway)
+}
+
+func (p *Pool) get(host string) net.IP {
+	current := p.offset
+	for {
+		p.offset = (p.offset + 1) % (p.max - p.min)
+		// Avoid infinite loops
+		if p.offset == current {
+			break
+		}
+
+		if !p.cache.Exist(p.offset) {
+			break
+		}
+	}
+	ip := uintToIP(p.min + p.offset - 1)
+	p.cache.Set(p.offset, host)
 	return ip
 }
 
@@ -36,8 +120,8 @@ func uintToIP(v uint32) net.IP {
 }
 
 // New return Pool instance
-func New(ipnet *net.IPNet) (*Pool, error) {
+func New(ipnet *net.IPNet, size int, host *trie.Trie) (*Pool, error) {
-	min := ipToUint(ipnet.IP) + 1
+	min := ipToUint(ipnet.IP) + 2
 
 	ones, bits := ipnet.Mask.Size()
 	total := 1<<uint(bits-ones) - 2
@@ -46,10 +130,12 @@ func New(ipnet *net.IPNet) (*Pool, error) {
 		return nil, errors.New("ipnet don't have valid ip")
 	}
 
-	max := min + uint32(total)
+	max := min + uint32(total) - 1
 	return &Pool{
-		min: min,
+		min:     min,
-		max: max,
+		max:     max,
-		mux: &sync.Mutex{},
+		gateway: min - 1,
+		host:    host,
+		cache:   cache.NewLRUCache(cache.WithSize(size * 2)),
 	}, nil
 }

component/fakeip/pool_test.go

@@ -3,42 +3,76 @@ package fakeip
 import (
 	"net"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestPool_Basic(t *testing.T) {
-	_, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
+	_, ipnet, _ := net.ParseCIDR("192.168.0.1/29")
-	pool, _ := New(ipnet)
+	pool, _ := New(ipnet, 10, nil)
 
-	first := pool.Get()
+	first := pool.Lookup("foo.com")
-	last := pool.Get()
+	last := pool.Lookup("bar.com")
+	bar, exist := pool.LookBack(last)
 
-	if !first.Equal(net.IP{192, 168, 0, 1}) {
+	assert.True(t, first.Equal(net.IP{192, 168, 0, 2}))
-		t.Error("should get right first ip, instead of", first.String())
+	assert.True(t, last.Equal(net.IP{192, 168, 0, 3}))
-	}
+	assert.True(t, exist)
-
+	assert.Equal(t, bar, "bar.com")
-	if !last.Equal(net.IP{192, 168, 0, 2}) {
-		t.Error("should get right last ip, instead of", first.String())
-	}
 }
 
 func TestPool_Cycle(t *testing.T) {
 	_, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
-	pool, _ := New(ipnet)
+	pool, _ := New(ipnet, 10, nil)
 
-	first := pool.Get()
+	first := pool.Lookup("foo.com")
-	pool.Get()
+	same := pool.Lookup("baz.com")
-	same := pool.Get()
 
-	if !first.Equal(same) {
+	assert.True(t, first.Equal(same))
-		t.Error("should return same ip", first.String())
+}
-	}
+
+func TestPool_MaxCacheSize(t *testing.T) {
+	_, ipnet, _ := net.ParseCIDR("192.168.0.1/24")
+	pool, _ := New(ipnet, 2, nil)
+
+	first := pool.Lookup("foo.com")
+	pool.Lookup("bar.com")
+	pool.Lookup("baz.com")
+	next := pool.Lookup("foo.com")
+
+	assert.False(t, first.Equal(next))
+}
+
+func TestPool_DoubleMapping(t *testing.T) {
+	_, ipnet, _ := net.ParseCIDR("192.168.0.1/24")
+	pool, _ := New(ipnet, 2, nil)
+
+	// fill cache
+	fooIP := pool.Lookup("foo.com")
+	bazIP := pool.Lookup("baz.com")
+
+	// make foo.com hot
+	pool.Lookup("foo.com")
+
+	// should drop baz.com
+	barIP := pool.Lookup("bar.com")
+
+	_, fooExist := pool.LookBack(fooIP)
+	_, bazExist := pool.LookBack(bazIP)
+	_, barExist := pool.LookBack(barIP)
+
+	newBazIP := pool.Lookup("baz.com")
+
+	assert.True(t, fooExist)
+	assert.False(t, bazExist)
+	assert.True(t, barExist)
+
+	assert.False(t, bazIP.Equal(newBazIP))
 }
 
 func TestPool_Error(t *testing.T) {
 	_, ipnet, _ := net.ParseCIDR("192.168.0.1/31")
-	_, err := New(ipnet)
+	_, err := New(ipnet, 10, nil)
 
-	if err == nil {
+	assert.Error(t, err)
-		t.Error("should return err")
-	}
 }

component/mmdb/mmdb.go

@@ -0,0 +1,35 @@
+package mmdb
+
+import (
+	"sync"
+
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/log"
+
+	"github.com/oschwald/geoip2-golang"
+)
+
+var mmdb *geoip2.Reader
+var once sync.Once
+
+func LoadFromBytes(buffer []byte) {
+	once.Do(func() {
+		var err error
+		mmdb, err = geoip2.FromBytes(buffer)
+		if err != nil {
+			log.Fatalln("Can't load mmdb: %s", err.Error())
+		}
+	})
+}
+
+func Instance() *geoip2.Reader {
+	once.Do(func() {
+		var err error
+		mmdb, err = geoip2.Open(C.Path.MMDB())
+		if err != nil {
+			log.Fatalln("Can't load mmdb: %s", err.Error())
+		}
+	})
+
+	return mmdb
+}

component/nat/table.go

@@ -0,0 +1,37 @@
+package nat
+
+import (
+	"sync"
+
+	C "github.com/Dreamacro/clash/constant"
+)
+
+type Table struct {
+	mapping sync.Map
+}
+
+func (t *Table) Set(key string, pc C.PacketConn) {
+	t.mapping.Store(key, pc)
+}
+
+func (t *Table) Get(key string) C.PacketConn {
+	item, exist := t.mapping.Load(key)
+	if !exist {
+		return nil
+	}
+	return item.(C.PacketConn)
+}
+
+func (t *Table) GetOrCreateLock(key string) (*sync.WaitGroup, bool) {
+	item, loaded := t.mapping.LoadOrStore(key, &sync.WaitGroup{})
+	return item.(*sync.WaitGroup), loaded
+}
+
+func (t *Table) Delete(key string) {
+	t.mapping.Delete(key)
+}
+
+// New return *Cache
+func New() *Table {
+	return &Table{}
+}

component/resolver/resolver.go

@@ -0,0 +1,119 @@
+package resolver
+
+import (
+	"errors"
+	"net"
+	"strings"
+
+	trie "github.com/Dreamacro/clash/component/domain-trie"
+)
+
+var (
+	// DefaultResolver aim to resolve ip
+	DefaultResolver Resolver
+
+	// DefaultHosts aim to resolve hosts
+	DefaultHosts = trie.New()
+)
+
+var (
+	ErrIPNotFound = errors.New("couldn't find ip")
+	ErrIPVersion  = errors.New("ip version error")
+)
+
+type Resolver interface {
+	ResolveIP(host string) (ip net.IP, err error)
+	ResolveIPv4(host string) (ip net.IP, err error)
+	ResolveIPv6(host string) (ip net.IP, err error)
+}
+
+// ResolveIPv4 with a host, return ipv4
+func ResolveIPv4(host string) (net.IP, error) {
+	if node := DefaultHosts.Search(host); node != nil {
+		if ip := node.Data.(net.IP).To4(); ip != nil {
+			return ip, nil
+		}
+	}
+
+	ip := net.ParseIP(host)
+	if ip != nil {
+		if !strings.Contains(host, ":") {
+			return ip, nil
+		}
+		return nil, ErrIPVersion
+	}
+
+	if DefaultResolver != nil {
+		return DefaultResolver.ResolveIPv4(host)
+	}
+
+	ipAddrs, err := net.LookupIP(host)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, ip := range ipAddrs {
+		if ip4 := ip.To4(); ip4 != nil {
+			return ip4, nil
+		}
+	}
+
+	return nil, ErrIPNotFound
+}
+
+// ResolveIPv6 with a host, return ipv6
+func ResolveIPv6(host string) (net.IP, error) {
+	if node := DefaultHosts.Search(host); node != nil {
+		if ip := node.Data.(net.IP).To16(); ip != nil {
+			return ip, nil
+		}
+	}
+
+	ip := net.ParseIP(host)
+	if ip != nil {
+		if strings.Contains(host, ":") {
+			return ip, nil
+		}
+		return nil, ErrIPVersion
+	}
+
+	if DefaultResolver != nil {
+		return DefaultResolver.ResolveIPv6(host)
+	}
+
+	ipAddrs, err := net.LookupIP(host)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, ip := range ipAddrs {
+		if ip.To4() == nil {
+			return ip, nil
+		}
+	}
+
+	return nil, ErrIPNotFound
+}
+
+// ResolveIP with a host, return ip
+func ResolveIP(host string) (net.IP, error) {
+	if node := DefaultHosts.Search(host); node != nil {
+		return node.Data.(net.IP), nil
+	}
+
+	if DefaultResolver != nil {
+		return DefaultResolver.ResolveIP(host)
+	}
+
+	ip := net.ParseIP(host)
+	if ip != nil {
+		return ip, nil
+	}
+
+	ipAddr, err := net.ResolveIPAddr("ip", host)
+	if err != nil {
+		return nil, err
+	}
+
+	return ipAddr.IP, nil
+}

component/snell/cipher.go

@@ -0,0 +1,21 @@
+package snell
+
+import (
+	"crypto/cipher"
+
+	"golang.org/x/crypto/argon2"
+)
+
+type snellCipher struct {
+	psk      []byte
+	makeAEAD func(key []byte) (cipher.AEAD, error)
+}
+
+func (sc *snellCipher) KeySize() int  { return 32 }
+func (sc *snellCipher) SaltSize() int { return 16 }
+func (sc *snellCipher) Encrypter(salt []byte) (cipher.AEAD, error) {
+	return sc.makeAEAD(argon2.IDKey(sc.psk, salt, 3, 8, 1, uint32(sc.KeySize())))
+}
+func (sc *snellCipher) Decrypter(salt []byte) (cipher.AEAD, error) {
+	return sc.makeAEAD(argon2.IDKey(sc.psk, salt, 3, 8, 1, uint32(sc.KeySize())))
+}

component/snell/snell.go

@@ -0,0 +1,91 @@
+package snell
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"io"
+	"net"
+	"sync"
+
+	"github.com/Dreamacro/go-shadowsocks2/shadowaead"
+	"golang.org/x/crypto/chacha20poly1305"
+)
+
+const (
+	CommandPing    byte = 0
+	CommandConnect byte = 1
+
+	CommandTunnel byte = 0
+	CommandError  byte = 2
+
+	Version byte = 1
+)
+
+var (
+	bufferPool = sync.Pool{New: func() interface{} { return &bytes.Buffer{} }}
+)
+
+type Snell struct {
+	net.Conn
+	buffer [1]byte
+	reply  bool
+}
+
+func (s *Snell) Read(b []byte) (int, error) {
+	if s.reply {
+		return s.Conn.Read(b)
+	}
+
+	s.reply = true
+	if _, err := io.ReadFull(s.Conn, s.buffer[:]); err != nil {
+		return 0, err
+	}
+
+	if s.buffer[0] == CommandTunnel {
+		return s.Conn.Read(b)
+	} else if s.buffer[0] != CommandError {
+		return 0, errors.New("Command not support")
+	}
+
+	// CommandError
+	if _, err := io.ReadFull(s.Conn, s.buffer[:]); err != nil {
+		return 0, err
+	}
+
+	length := int(s.buffer[0])
+	msg := make([]byte, length)
+
+	if _, err := io.ReadFull(s.Conn, msg); err != nil {
+		return 0, err
+	}
+
+	return 0, errors.New(string(msg))
+}
+
+func WriteHeader(conn net.Conn, host string, port uint) error {
+	buf := bufferPool.Get().(*bytes.Buffer)
+	buf.Reset()
+	defer bufferPool.Put(buf)
+	buf.WriteByte(Version)
+	buf.WriteByte(CommandConnect)
+
+	// clientID length & id
+	buf.WriteByte(0)
+
+	// host & port
+	buf.WriteByte(uint8(len(host)))
+	buf.WriteString(host)
+	binary.Write(buf, binary.BigEndian, uint16(port))
+
+	if _, err := conn.Write(buf.Bytes()); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func StreamConn(conn net.Conn, psk []byte) net.Conn {
+	cipher := &snellCipher{psk, chacha20poly1305.New}
+	return &Snell{Conn: shadowaead.NewConn(conn, cipher)}
+}

component/socks5/socks5.go

@@ -2,6 +2,7 @@ package socks5
 
 import (
 	"bytes"
+	"encoding/binary"
 	"errors"
 	"io"
 	"net"
@@ -41,7 +42,45 @@ const MaxAddrLen = 1 + 1 + 255 + 2
 const MaxAuthLen = 255
 
 // Addr represents a SOCKS address as defined in RFC 1928 section 5.
-type Addr = []byte
+type Addr []byte
+
+func (a Addr) String() string {
+	var host, port string
+
+	switch a[0] {
+	case AtypDomainName:
+		hostLen := uint16(a[1])
+		host = string(a[2 : 2+hostLen])
+		port = strconv.Itoa((int(a[2+hostLen]) << 8) | int(a[2+hostLen+1]))
+	case AtypIPv4:
+		host = net.IP(a[1 : 1+net.IPv4len]).String()
+		port = strconv.Itoa((int(a[1+net.IPv4len]) << 8) | int(a[1+net.IPv4len+1]))
+	case AtypIPv6:
+		host = net.IP(a[1 : 1+net.IPv6len]).String()
+		port = strconv.Itoa((int(a[1+net.IPv6len]) << 8) | int(a[1+net.IPv6len+1]))
+	}
+
+	return net.JoinHostPort(host, port)
+}
+
+// UDPAddr converts a socks5.Addr to *net.UDPAddr
+func (a Addr) UDPAddr() *net.UDPAddr {
+	if len(a) == 0 {
+		return nil
+	}
+	switch a[0] {
+	case AtypIPv4:
+		var ip [net.IPv4len]byte
+		copy(ip[0:], a[1:1+net.IPv4len])
+		return &net.UDPAddr{IP: net.IP(ip[:]), Port: int(binary.BigEndian.Uint16(a[1+net.IPv4len : 1+net.IPv4len+2]))}
+	case AtypIPv6:
+		var ip [net.IPv6len]byte
+		copy(ip[0:], a[1:1+net.IPv6len])
+		return &net.UDPAddr{IP: net.IP(ip[:]), Port: int(binary.BigEndian.Uint16(a[1+net.IPv6len : 1+net.IPv6len+2]))}
+	}
+	// Other Atyp
+	return nil
+}
 
 // SOCKS errors as defined in RFC 1928 section 6.
 const (
@@ -138,23 +177,33 @@ func ServerHandshake(rw net.Conn, authenticator auth.Authenticator) (addr Addr,
 		return
 	}
 
-	if buf[1] != CmdConnect && buf[1] != CmdUDPAssociate {
-		err = ErrCommandNotSupported
-		return
-	}
-
 	command = buf[1]
-	addr, err = readAddr(rw, buf)
+	addr, err = ReadAddr(rw, buf)
 	if err != nil {
 		return
 	}
-	// write VER REP RSV ATYP BND.ADDR BND.PORT
+
-	_, err = rw.Write([]byte{5, 0, 0, 1, 0, 0, 0, 0, 0, 0})
+	switch command {
+	case CmdConnect, CmdUDPAssociate:
+		// Acquire server listened address info
+		localAddr := ParseAddr(rw.LocalAddr().String())
+		if localAddr == nil {
+			err = ErrAddressNotSupported
+		} else {
+			// write VER REP RSV ATYP BND.ADDR BND.PORT
+			_, err = rw.Write(bytes.Join([][]byte{{5, 0, 0}, localAddr}, []byte{}))
+		}
+	case CmdBind:
+		fallthrough
+	default:
+		err = ErrCommandNotSupported
+	}
+
 	return
 }
 
 // ClientHandshake fast-tracks SOCKS initialization to get target address to connect on client side.
-func ClientHandshake(rw io.ReadWriter, addr Addr, cammand Command, user *User) error {
+func ClientHandshake(rw io.ReadWriter, addr Addr, command Command, user *User) (Addr, error) {
 	buf := make([]byte, MaxAddrLen)
 	var err error
 
@@ -165,16 +214,16 @@ func ClientHandshake(rw io.ReadWriter, addr Addr, cammand Command, user *User) e
 		_, err = rw.Write([]byte{5, 1, 0})
 	}
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	// VER, METHOD
 	if _, err := io.ReadFull(rw, buf[:2]); err != nil {
-		return err
+		return nil, err
 	}
 
 	if buf[0] != 5 {
-		return errors.New("SOCKS version error")
+		return nil, errors.New("SOCKS version error")
 	}
 
 	if buf[1] == 2 {
@@ -187,33 +236,34 @@ func ClientHandshake(rw io.ReadWriter, addr Addr, cammand Command, user *User) e
 		authMsg.WriteString(user.Password)
 
 		if _, err := rw.Write(authMsg.Bytes()); err != nil {
-			return err
+			return nil, err
 		}
 
 		if _, err := io.ReadFull(rw, buf[:2]); err != nil {
-			return err
+			return nil, err
 		}
 
 		if buf[1] != 0 {
-			return errors.New("rejected username/password")
+			return nil, errors.New("rejected username/password")
 		}
 	} else if buf[1] != 0 {
-		return errors.New("SOCKS need auth")
+		return nil, errors.New("SOCKS need auth")
 	}
 
 	// VER, CMD, RSV, ADDR
-	if _, err := rw.Write(bytes.Join([][]byte{{5, cammand, 0}, addr}, []byte(""))); err != nil {
+	if _, err := rw.Write(bytes.Join([][]byte{{5, command, 0}, addr}, []byte{})); err != nil {
-		return err
+		return nil, err
 	}
 
-	if _, err := io.ReadFull(rw, buf[:10]); err != nil {
+	// VER, REP, RSV
-		return err
+	if _, err := io.ReadFull(rw, buf[:3]); err != nil {
+		return nil, err
 	}
 
-	return nil
+	return ReadAddr(rw, buf)
 }
 
-func readAddr(r io.Reader, b []byte) (Addr, error) {
+func ReadAddr(r io.Reader, b []byte) (Addr, error) {
 	if len(b) < MaxAddrLen {
 		return nil, io.ErrShortBuffer
 	}
@@ -307,3 +357,73 @@ func ParseAddr(s string) Addr {
 
 	return addr
 }
+
+// ParseAddrToSocksAddr parse a socks addr from net.addr
+// This is a fast path of ParseAddr(addr.String())
+func ParseAddrToSocksAddr(addr net.Addr) Addr {
+	var hostip net.IP
+	var port int
+	if udpaddr, ok := addr.(*net.UDPAddr); ok {
+		hostip = udpaddr.IP
+		port = udpaddr.Port
+	} else if tcpaddr, ok := addr.(*net.TCPAddr); ok {
+		hostip = tcpaddr.IP
+		port = tcpaddr.Port
+	}
+
+	// fallback parse
+	if hostip == nil {
+		return ParseAddr(addr.String())
+	}
+
+	var parsed Addr
+	if ip4 := hostip.To4(); ip4.DefaultMask() != nil {
+		parsed = make([]byte, 1+net.IPv4len+2)
+		parsed[0] = AtypIPv4
+		copy(parsed[1:], ip4)
+		binary.BigEndian.PutUint16(parsed[1+net.IPv4len:], uint16(port))
+
+	} else {
+		parsed = make([]byte, 1+net.IPv6len+2)
+		parsed[0] = AtypIPv6
+		copy(parsed[1:], hostip)
+		binary.BigEndian.PutUint16(parsed[1+net.IPv6len:], uint16(port))
+	}
+	return parsed
+}
+
+// DecodeUDPPacket split `packet` to addr payload, and this function is mutable with `packet`
+func DecodeUDPPacket(packet []byte) (addr Addr, payload []byte, err error) {
+	if len(packet) < 5 {
+		err = errors.New("insufficient length of packet")
+		return
+	}
+
+	// packet[0] and packet[1] are reserved
+	if !bytes.Equal(packet[:2], []byte{0, 0}) {
+		err = errors.New("reserved fields should be zero")
+		return
+	}
+
+	if packet[2] != 0 /* fragments */ {
+		err = errors.New("discarding fragmented payload")
+		return
+	}
+
+	addr = SplitAddr(packet[3:])
+	if addr == nil {
+		err = errors.New("failed to read UDP header")
+	}
+
+	payload = packet[3+len(addr):]
+	return
+}
+
+func EncodeUDPPacket(addr Addr, payload []byte) (packet []byte, err error) {
+	if addr == nil {
+		err = errors.New("address is invalid")
+		return
+	}
+	packet = bytes.Join([][]byte{{0, 0, 0}, addr, payload}, []byte{})
+	return
+}

component/trojan/trojan.go

@@ -0,0 +1,223 @@
+package trojan
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"crypto/tls"
+	"encoding/binary"
+	"encoding/hex"
+	"errors"
+	"io"
+	"net"
+	"sync"
+
+	"github.com/Dreamacro/clash/component/socks5"
+)
+
+const (
+	// max packet length
+	maxLength = 8192
+)
+
+var (
+	defaultALPN = []string{"h2", "http/1.1"}
+	crlf        = []byte{'\r', '\n'}
+
+	bufPool = sync.Pool{New: func() interface{} { return &bytes.Buffer{} }}
+)
+
+type Command = byte
+
+var (
+	CommandTCP byte = 1
+	CommandUDP byte = 3
+)
+
+type Option struct {
+	Password           string
+	ALPN               []string
+	ServerName         string
+	SkipCertVerify     bool
+	ClientSessionCache tls.ClientSessionCache
+}
+
+type Trojan struct {
+	option      *Option
+	hexPassword []byte
+}
+
+func (t *Trojan) StreamConn(conn net.Conn) (net.Conn, error) {
+	alpn := defaultALPN
+	if len(t.option.ALPN) != 0 {
+		alpn = t.option.ALPN
+	}
+
+	tlsConfig := &tls.Config{
+		NextProtos:         alpn,
+		MinVersion:         tls.VersionTLS12,
+		InsecureSkipVerify: t.option.SkipCertVerify,
+		ServerName:         t.option.ServerName,
+		ClientSessionCache: t.option.ClientSessionCache,
+	}
+
+	tlsConn := tls.Client(conn, tlsConfig)
+	if err := tlsConn.Handshake(); err != nil {
+		return nil, err
+	}
+
+	return tlsConn, nil
+}
+
+func (t *Trojan) WriteHeader(w io.Writer, command Command, socks5Addr []byte) error {
+	buf := bufPool.Get().(*bytes.Buffer)
+	defer buf.Reset()
+	defer bufPool.Put(buf)
+
+	buf.Write(t.hexPassword)
+	buf.Write(crlf)
+
+	buf.WriteByte(command)
+	buf.Write(socks5Addr)
+	buf.Write(crlf)
+
+	_, err := w.Write(buf.Bytes())
+	return err
+}
+
+func (t *Trojan) PacketConn(conn net.Conn) net.PacketConn {
+	return &PacketConn{
+		Conn: conn,
+	}
+}
+
+func writePacket(w io.Writer, socks5Addr, payload []byte) (int, error) {
+	buf := bufPool.Get().(*bytes.Buffer)
+	defer buf.Reset()
+	defer bufPool.Put(buf)
+
+	buf.Write(socks5Addr)
+	binary.Write(buf, binary.BigEndian, uint16(len(payload)))
+	buf.Write(crlf)
+	buf.Write(payload)
+
+	return w.Write(buf.Bytes())
+}
+
+func WritePacket(w io.Writer, socks5Addr, payload []byte) (int, error) {
+	if len(payload) <= maxLength {
+		return writePacket(w, socks5Addr, payload)
+	}
+
+	offset := 0
+	total := len(payload)
+	for {
+		cursor := offset + maxLength
+		if cursor > total {
+			cursor = total
+		}
+
+		n, err := writePacket(w, socks5Addr, payload[offset:cursor])
+		if err != nil {
+			return offset + n, err
+		}
+
+		offset = cursor
+		if offset == total {
+			break
+		}
+	}
+
+	return total, nil
+}
+
+func ReadPacket(r io.Reader, payload []byte) (net.Addr, int, int, error) {
+	addr, err := socks5.ReadAddr(r, payload)
+	if err != nil {
+		return nil, 0, 0, errors.New("read addr error")
+	}
+	uAddr := addr.UDPAddr()
+
+	if _, err = io.ReadFull(r, payload[:2]); err != nil {
+		return nil, 0, 0, errors.New("read length error")
+	}
+
+	total := int(binary.BigEndian.Uint16(payload[:2]))
+	if total > maxLength {
+		return nil, 0, 0, errors.New("packet invalid")
+	}
+
+	// read crlf
+	if _, err = io.ReadFull(r, payload[:2]); err != nil {
+		return nil, 0, 0, errors.New("read crlf error")
+	}
+
+	length := len(payload)
+	if total < length {
+		length = total
+	}
+
+	if _, err = io.ReadFull(r, payload[:length]); err != nil {
+		return nil, 0, 0, errors.New("read packet error")
+	}
+
+	return uAddr, length, total - length, nil
+}
+
+func New(option *Option) *Trojan {
+	return &Trojan{option, hexSha224([]byte(option.Password))}
+}
+
+type PacketConn struct {
+	net.Conn
+	remain int
+	rAddr  net.Addr
+	mux    sync.Mutex
+}
+
+func (pc *PacketConn) WriteTo(b []byte, addr net.Addr) (int, error) {
+	return WritePacket(pc, socks5.ParseAddr(addr.String()), b)
+}
+
+func (pc *PacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
+	pc.mux.Lock()
+	defer pc.mux.Unlock()
+	if pc.remain != 0 {
+		length := len(b)
+		if pc.remain < length {
+			length = pc.remain
+		}
+
+		n, err := pc.Conn.Read(b[:length])
+		if err != nil {
+			return 0, nil, err
+		}
+
+		pc.remain -= n
+		addr := pc.rAddr
+		if pc.remain == 0 {
+			pc.rAddr = nil
+		}
+
+		return n, addr, nil
+	}
+
+	addr, n, remain, err := ReadPacket(pc.Conn, b)
+	if err != nil {
+		return 0, nil, err
+	}
+
+	if remain != 0 {
+		pc.remain = remain
+		pc.rAddr = addr
+	}
+
+	return n, addr, nil
+}
+
+func hexSha224(data []byte) []byte {
+	buf := make([]byte, 56)
+	hash := sha256.New224()
+	hash.Write(data)
+	hex.Encode(buf, hash.Sum(nil))
+	return buf
+}

component/v2ray-plugin/mux.go

@@ -52,7 +52,7 @@ func (m *Mux) Read(b []byte) (int, error) {
 		if err != nil {
 			return 0, err
 		}
-		m.remain = m.remain - n
+		m.remain -= n
 		return n, nil
 	}
 

component/v2ray-plugin/websocket.go

@@ -3,25 +3,32 @@ package obfs
 import (
 	"crypto/tls"
 	"net"
+	"net/http"
 
 	"github.com/Dreamacro/clash/component/vmess"
 )
 
-// WebsocketOption is options of websocket obfs
+// Option is options of websocket obfs
-type WebsocketOption struct {
+type Option struct {
 	Host      string
 	Path      string
 	Headers   map[string]string
 	TLSConfig *tls.Config
+	Mux       bool
 }
 
-// NewWebsocketObfs return a HTTPObfs
+// NewV2rayObfs return a HTTPObfs
-func NewWebsocketObfs(conn net.Conn, option *WebsocketOption) (net.Conn, error) {
+func NewV2rayObfs(conn net.Conn, option *Option) (net.Conn, error) {
+	header := http.Header{}
+	for k, v := range option.Headers {
+		header.Add(k, v)
+	}
+
 	config := &vmess.WebsocketConfig{
 		Host:      option.Host,
 		Path:      option.Path,
 		TLS:       option.TLSConfig != nil,
-		Headers:   option.Headers,
+		Headers:   header,
 		TLSConfig: option.TLSConfig,
 	}
 
@@ -30,10 +37,13 @@ func NewWebsocketObfs(conn net.Conn, option *WebsocketOption) (net.Conn, error)
 	if err != nil {
 		return nil, err
 	}
-	conn = NewMux(conn, MuxOption{
+
-		ID:   [2]byte{0, 0},
+	if option.Mux {
-		Host: "127.0.0.1",
+		conn = NewMux(conn, MuxOption{
-		Port: 0,
+			ID:   [2]byte{0, 0},
-	})
+			Host: "127.0.0.1",
+			Port: 0,
+		})
+	}
 	return conn, nil
 }

component/vmess/vmess.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"math/rand"
 	"net"
+	"net/http"
 	"runtime"
 	"sync"
 
@@ -86,7 +87,7 @@ type Config struct {
 	WebSocketPath    string
 	WebSocketHeaders map[string]string
 	SkipCertVerify   bool
-	SessionCacahe    tls.ClientSessionCache
+	SessionCache     tls.ClientSessionCache
 }
 
 // New return a Conn with net.Conn and DstAddr
@@ -132,6 +133,11 @@ func NewClient(config Config) (*Client, error) {
 		return nil, fmt.Errorf("Unknown network type: %s", config.NetWork)
 	}
 
+	header := http.Header{}
+	for k, v := range config.WebSocketHeaders {
+		header.Add(k, v)
+	}
+
 	host := net.JoinHostPort(config.HostName, config.Port)
 
 	var tlsConfig *tls.Config
@@ -139,11 +145,14 @@ func NewClient(config Config) (*Client, error) {
 		tlsConfig = &tls.Config{
 			ServerName:         config.HostName,
 			InsecureSkipVerify: config.SkipCertVerify,
-			ClientSessionCache: config.SessionCacahe,
+			ClientSessionCache: config.SessionCache,
 		}
 		if tlsConfig.ClientSessionCache == nil {
 			tlsConfig.ClientSessionCache = getClientSessionCache()
 		}
+		if host := header.Get("Host"); host != "" {
+			tlsConfig.ServerName = host
+		}
 	}
 
 	var wsConfig *WebsocketConfig
@@ -151,7 +160,7 @@ func NewClient(config Config) (*Client, error) {
 		wsConfig = &WebsocketConfig{
 			Host:      host,
 			Path:      config.WebSocketPath,
-			Headers:   config.WebSocketHeaders,
+			Headers:   header,
 			TLS:       config.TLS,
 			TLSConfig: tlsConfig,
 		}

component/vmess/websocket.go

@@ -8,6 +8,7 @@ import (
 	"net/http"
 	"net/url"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/gorilla/websocket"
@@ -17,18 +18,24 @@ type websocketConn struct {
 	conn       *websocket.Conn
 	reader     io.Reader
 	remoteAddr net.Addr
+
+	// https://godoc.org/github.com/gorilla/websocket#hdr-Concurrency
+	rMux sync.Mutex
+	wMux sync.Mutex
 }
 
 type WebsocketConfig struct {
 	Host      string
 	Path      string
-	Headers   map[string]string
+	Headers   http.Header
 	TLS       bool
 	TLSConfig *tls.Config
 }
 
 // Read implements net.Conn.Read()
 func (wsc *websocketConn) Read(b []byte) (int, error) {
+	wsc.rMux.Lock()
+	defer wsc.rMux.Unlock()
 	for {
 		reader, err := wsc.getReader()
 		if err != nil {
@@ -46,6 +53,8 @@ func (wsc *websocketConn) Read(b []byte) (int, error) {
 
 // Write implements io.Writer.
 func (wsc *websocketConn) Write(b []byte) (int, error) {
+	wsc.wMux.Lock()
+	defer wsc.wMux.Unlock()
 	if err := wsc.conn.WriteMessage(websocket.BinaryMessage, b); err != nil {
 		return 0, err
 	}
@@ -131,14 +140,14 @@ func NewWebsocketConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
 
 	headers := http.Header{}
 	if c.Headers != nil {
-		for k, v := range c.Headers {
+		for k := range c.Headers {
-			headers.Set(k, v)
+			headers.Add(k, c.Headers.Get(k))
 		}
 	}
 
 	wsConn, resp, err := dialer.Dial(uri.String(), headers)
 	if err != nil {
-		var reason string
+		reason := err.Error()
 		if resp != nil {
 			reason = resp.Status
 		}

config/config.go

@@ -1,17 +1,18 @@
 package config
 
 import (
+	"errors"
 	"fmt"
-	"io/ioutil"
 	"net"
 	"net/url"
 	"os"
-	"path/filepath"
 	"strings"
 
-	adapters "github.com/Dreamacro/clash/adapters/outbound"
+	"github.com/Dreamacro/clash/adapters/outbound"
-	"github.com/Dreamacro/clash/common/structure"
+	"github.com/Dreamacro/clash/adapters/outboundgroup"
+	"github.com/Dreamacro/clash/adapters/provider"
 	"github.com/Dreamacro/clash/component/auth"
+	trie "github.com/Dreamacro/clash/component/domain-trie"
 	"github.com/Dreamacro/clash/component/fakeip"
 	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/dns"
@@ -29,7 +30,8 @@ type General struct {
 	RedirPort          int          `json:"redir-port"`
 	Authentication     []string     `json:"authentication"`
 	AllowLan           bool         `json:"allow-lan"`
-	Mode               T.Mode       `json:"mode"`
+	BindAddress        string       `json:"bind-address"`
+	Mode               T.TunnelMode `json:"mode"`
 	LogLevel           log.LogLevel `json:"log-level"`
 	ExternalController string       `json:"-"`
 	ExternalUI         string       `json:"-"`
@@ -38,18 +40,27 @@ type General struct {
 
 // DNS config
 type DNS struct {
-	Enable       bool             `yaml:"enable"`
+	Enable            bool             `yaml:"enable"`
-	IPv6         bool             `yaml:"ipv6"`
+	IPv6              bool             `yaml:"ipv6"`
-	NameServer   []dns.NameServer `yaml:"nameserver"`
+	NameServer        []dns.NameServer `yaml:"nameserver"`
-	Fallback     []dns.NameServer `yaml:"fallback"`
+	Fallback          []dns.NameServer `yaml:"fallback"`
-	Listen       string           `yaml:"listen"`
+	FallbackFilter    FallbackFilter   `yaml:"fallback-filter"`
-	EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
+	Listen            string           `yaml:"listen"`
-	FakeIPRange  *fakeip.Pool
+	EnhancedMode      dns.EnhancedMode `yaml:"enhanced-mode"`
+	DefaultNameserver []dns.NameServer `yaml:"default-nameserver"`
+	FakeIPRange       *fakeip.Pool
+}
+
+// FallbackFilter config
+type FallbackFilter struct {
+	GeoIP  bool         `yaml:"geoip"`
+	IPCIDR []*net.IPNet `yaml:"ipcidr"`
 }
 
 // Experimental config
 type Experimental struct {
-	IgnoreResolveFail bool `yaml:"ignore-resolve-fail"`
+	IgnoreResolveFail bool   `yaml:"ignore-resolve-fail"`
+	Interface         string `yaml:"interface-name"`
 }
 
 // Config is clash config manager
@@ -57,97 +68,113 @@ type Config struct {
 	General      *General
 	DNS          *DNS
 	Experimental *Experimental
+	Hosts        *trie.Trie
 	Rules        []C.Rule
 	Users        []auth.AuthUser
 	Proxies      map[string]C.Proxy
+	Providers    map[string]provider.ProxyProvider
 }
 
-type rawDNS struct {
+type RawDNS struct {
-	Enable       bool             `yaml:"enable"`
+	Enable            bool              `yaml:"enable"`
-	IPv6         bool             `yaml:"ipv6"`
+	IPv6              bool              `yaml:"ipv6"`
-	NameServer   []string         `yaml:"nameserver"`
+	NameServer        []string          `yaml:"nameserver"`
-	Fallback     []string         `yaml:"fallback"`
+	Fallback          []string          `yaml:"fallback"`
-	Listen       string           `yaml:"listen"`
+	FallbackFilter    RawFallbackFilter `yaml:"fallback-filter"`
-	EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
+	Listen            string            `yaml:"listen"`
-	FakeIPRange  string           `yaml:"fake-ip-range"`
+	EnhancedMode      dns.EnhancedMode  `yaml:"enhanced-mode"`
+	FakeIPRange       string            `yaml:"fake-ip-range"`
+	FakeIPFilter      []string          `yaml:"fake-ip-filter"`
+	DefaultNameserver []string          `yaml:"default-nameserver"`
 }
 
-type rawConfig struct {
+type RawFallbackFilter struct {
+	GeoIP  bool     `yaml:"geoip"`
+	IPCIDR []string `yaml:"ipcidr"`
+}
+
+type RawConfig struct {
 	Port               int          `yaml:"port"`
 	SocksPort          int          `yaml:"socks-port"`
 	RedirPort          int          `yaml:"redir-port"`
 	Authentication     []string     `yaml:"authentication"`
 	AllowLan           bool         `yaml:"allow-lan"`
-	Mode               T.Mode       `yaml:"mode"`
+	BindAddress        string       `yaml:"bind-address"`
+	Mode               T.TunnelMode `yaml:"mode"`
 	LogLevel           log.LogLevel `yaml:"log-level"`
 	ExternalController string       `yaml:"external-controller"`
 	ExternalUI         string       `yaml:"external-ui"`
 	Secret             string       `yaml:"secret"`
 
-	DNS          rawDNS                   `yaml:"dns"`
+	ProxyProvider map[string]map[string]interface{} `yaml:"proxy-providers"`
-	Experimental Experimental             `yaml:"experimental"`
+	Hosts         map[string]string                 `yaml:"hosts"`
-	Proxy        []map[string]interface{} `yaml:"Proxy"`
+	DNS           RawDNS                            `yaml:"dns"`
-	ProxyGroup   []map[string]interface{} `yaml:"Proxy Group"`
+	Experimental  Experimental                      `yaml:"experimental"`
-	Rule         []string                 `yaml:"Rule"`
+	Proxy         []map[string]interface{}          `yaml:"proxies"`
+	ProxyGroup    []map[string]interface{}          `yaml:"proxy-groups"`
+	Rule          []string                          `yaml:"rules"`
+
+	// remove after 1.0
+	ProxyProviderOld map[string]map[string]interface{} `yaml:"proxy-provider"`
+	ProxyOld         []map[string]interface{}          `yaml:"Proxy"`
+	ProxyGroupOld    []map[string]interface{}          `yaml:"Proxy Group"`
+	RuleOld          []string                          `yaml:"Rule"`
 }
 
-// forward compatibility before 1.0
+// Parse config
-func readRawConfig(path string) ([]byte, error) {
+func Parse(buf []byte) (*Config, error) {
-	data, err := ioutil.ReadFile(path)
+	rawCfg, err := UnmarshalRawConfig(buf)
-	if err == nil && len(data) != 0 {
-		return data, nil
-	}
-
-	if filepath.Ext(path) != ".yaml" {
-		return nil, err
-	}
-
-	path = path[:len(path)-5] + ".yml"
-	return ioutil.ReadFile(path)
-}
-
-func readConfig(path string) (*rawConfig, error) {
-	if _, err := os.Stat(path); os.IsNotExist(err) {
-		return nil, err
-	}
-	data, err := readRawConfig(path)
 	if err != nil {
 		return nil, err
 	}
 
-	if len(data) == 0 {
+	return ParseRawConfig(rawCfg)
-		return nil, fmt.Errorf("Configuration file %s is empty", path)
+}
-	}
 
+func UnmarshalRawConfig(buf []byte) (*RawConfig, error) {
 	// config with some default value
-	rawConfig := &rawConfig{
+	rawCfg := &RawConfig{
 		AllowLan:       false,
+		BindAddress:    "*",
 		Mode:           T.Rule,
 		Authentication: []string{},
 		LogLevel:       log.INFO,
+		Hosts:          map[string]string{},
 		Rule:           []string{},
 		Proxy:          []map[string]interface{}{},
 		ProxyGroup:     []map[string]interface{}{},
 		Experimental: Experimental{
 			IgnoreResolveFail: true,
 		},
-		DNS: rawDNS{
+		DNS: RawDNS{
 			Enable:      false,
 			FakeIPRange: "198.18.0.1/16",
+			FallbackFilter: RawFallbackFilter{
+				GeoIP:  true,
+				IPCIDR: []string{},
+			},
+			DefaultNameserver: []string{
+				"114.114.114.114",
+				"8.8.8.8",
+			},
 		},
+
+		// remove after 1.0
+		RuleOld:       []string{},
+		ProxyOld:      []map[string]interface{}{},
+		ProxyGroupOld: []map[string]interface{}{},
 	}
-	err = yaml.Unmarshal([]byte(data), &rawConfig)
-	return rawConfig, err
-}
 
-// Parse config
+	if err := yaml.Unmarshal(buf, &rawCfg); err != nil {
-func Parse(path string) (*Config, error) {
-	config := &Config{}
-
-	rawCfg, err := readConfig(path)
-	if err != nil {
 		return nil, err
 	}
+
+	return rawCfg, nil
+}
+
+func ParseRawConfig(rawCfg *RawConfig) (*Config, error) {
+	config := &Config{}
+
 	config.Experimental = &rawCfg.Experimental
 
 	general, err := parseGeneral(rawCfg)
@@ -156,11 +183,12 @@ func Parse(path string) (*Config, error) {
 	}
 	config.General = general
 
-	proxies, err := parseProxies(rawCfg)
+	proxies, providers, err := parseProxies(rawCfg)
 	if err != nil {
 		return nil, err
 	}
 	config.Proxies = proxies
+	config.Providers = providers
 
 	rules, err := parseRules(rawCfg, proxies)
 	if err != nil {
@@ -174,16 +202,23 @@ func Parse(path string) (*Config, error) {
 	}
 	config.DNS = dnsCfg
 
+	hosts, err := parseHosts(rawCfg)
+	if err != nil {
+		return nil, err
+	}
+	config.Hosts = hosts
+
 	config.Users = parseAuthentication(rawCfg.Authentication)
 
 	return config, nil
 }
 
-func parseGeneral(cfg *rawConfig) (*General, error) {
+func parseGeneral(cfg *RawConfig) (*General, error) {
 	port := cfg.Port
 	socksPort := cfg.SocksPort
 	redirPort := cfg.RedirPort
 	allowLan := cfg.AllowLan
+	bindAddress := cfg.BindAddress
 	externalController := cfg.ExternalController
 	externalUI := cfg.ExternalUI
 	secret := cfg.Secret
@@ -191,9 +226,7 @@ func parseGeneral(cfg *rawConfig) (*General, error) {
 	logLevel := cfg.LogLevel
 
 	if externalUI != "" {
-		if !filepath.IsAbs(externalUI) {
+		externalUI = C.Path.Resolve(externalUI)
-			externalUI = filepath.Join(C.Path.HomeDir(), externalUI)
-		}
 
 		if _, err := os.Stat(externalUI); os.IsNotExist(err) {
 			return nil, fmt.Errorf("external-ui: %s not exist", externalUI)
@@ -205,6 +238,7 @@ func parseGeneral(cfg *rawConfig) (*General, error) {
 		SocksPort:          socksPort,
 		RedirPort:          redirPort,
 		AllowLan:           allowLan,
+		BindAddress:        bindAddress,
 		Mode:               mode,
 		LogLevel:           logLevel,
 		ExternalController: externalController,
@@ -214,171 +248,157 @@ func parseGeneral(cfg *rawConfig) (*General, error) {
 	return general, nil
 }
 
-func parseProxies(cfg *rawConfig) (map[string]C.Proxy, error) {
+func parseProxies(cfg *RawConfig) (proxies map[string]C.Proxy, providersMap map[string]provider.ProxyProvider, err error) {
-	proxies := make(map[string]C.Proxy)
+	proxies = make(map[string]C.Proxy)
+	providersMap = make(map[string]provider.ProxyProvider)
 	proxyList := []string{}
 	proxiesConfig := cfg.Proxy
 	groupsConfig := cfg.ProxyGroup
+	providersConfig := cfg.ProxyProvider
 
-	decoder := structure.NewDecoder(structure.Option{TagName: "proxy", WeaklyTypedInput: true})
+	if len(proxiesConfig) == 0 {
+		proxiesConfig = cfg.ProxyOld
+	}
 
-	proxies["DIRECT"] = adapters.NewProxy(adapters.NewDirect())
+	if len(groupsConfig) == 0 {
-	proxies["REJECT"] = adapters.NewProxy(adapters.NewReject())
+		groupsConfig = cfg.ProxyGroupOld
+	}
+
+	if len(providersConfig) == 0 {
+		providersConfig = cfg.ProxyProviderOld
+	}
+
+	defer func() {
+		// Destroy already created provider when err != nil
+		if err != nil {
+			for _, provider := range providersMap {
+				provider.Destroy()
+			}
+		}
+	}()
+
+	proxies["DIRECT"] = outbound.NewProxy(outbound.NewDirect())
+	proxies["REJECT"] = outbound.NewProxy(outbound.NewReject())
 	proxyList = append(proxyList, "DIRECT", "REJECT")
 
 	// parse proxy
 	for idx, mapping := range proxiesConfig {
-		proxyType, existType := mapping["type"].(string)
+		proxy, err := outbound.ParseProxy(mapping)
-		if !existType {
-			return nil, fmt.Errorf("Proxy %d missing type", idx)
-		}
-
-		var proxy C.ProxyAdapter
-		err := fmt.Errorf("cannot parse")
-		switch proxyType {
-		case "ss":
-			ssOption := &adapters.ShadowSocksOption{}
-			err = decoder.Decode(mapping, ssOption)
-			if err != nil {
-				break
-			}
-			proxy, err = adapters.NewShadowSocks(*ssOption)
-		case "socks5":
-			socksOption := &adapters.Socks5Option{}
-			err = decoder.Decode(mapping, socksOption)
-			if err != nil {
-				break
-			}
-			proxy = adapters.NewSocks5(*socksOption)
-		case "http":
-			httpOption := &adapters.HttpOption{}
-			err = decoder.Decode(mapping, httpOption)
-			if err != nil {
-				break
-			}
-			proxy = adapters.NewHttp(*httpOption)
-		case "vmess":
-			vmessOption := &adapters.VmessOption{}
-			err = decoder.Decode(mapping, vmessOption)
-			if err != nil {
-				break
-			}
-			proxy, err = adapters.NewVmess(*vmessOption)
-		default:
-			return nil, fmt.Errorf("Unsupport proxy type: %s", proxyType)
-		}
-
 		if err != nil {
-			return nil, fmt.Errorf("Proxy [%d]: %s", idx, err.Error())
+			return nil, nil, fmt.Errorf("Proxy %d: %w", idx, err)
 		}
 
 		if _, exist := proxies[proxy.Name()]; exist {
-			return nil, fmt.Errorf("Proxy %s is the duplicate name", proxy.Name())
+			return nil, nil, fmt.Errorf("Proxy %s is the duplicate name", proxy.Name())
 		}
-		proxies[proxy.Name()] = adapters.NewProxy(proxy)
+		proxies[proxy.Name()] = proxy
 		proxyList = append(proxyList, proxy.Name())
 	}
 
+	// keep the origional order of ProxyGroups in config file
+	for idx, mapping := range groupsConfig {
+		groupName, existName := mapping["name"].(string)
+		if !existName {
+			return nil, nil, fmt.Errorf("ProxyGroup %d: missing name", idx)
+		}
+		proxyList = append(proxyList, groupName)
+	}
+
+	// check if any loop exists and sort the ProxyGroups
+	if err := proxyGroupsDagSort(groupsConfig); err != nil {
+		return nil, nil, err
+	}
+
+	// parse and initial providers
+	for name, mapping := range providersConfig {
+		if name == provider.ReservedName {
+			return nil, nil, fmt.Errorf("can not defined a provider called `%s`", provider.ReservedName)
+		}
+
+		pd, err := provider.ParseProxyProvider(name, mapping)
+		if err != nil {
+			return nil, nil, err
+		}
+
+		providersMap[name] = pd
+	}
+
+	for _, provider := range providersMap {
+		log.Infoln("Start initial provider %s", provider.Name())
+		if err := provider.Initial(); err != nil {
+			return nil, nil, err
+		}
+	}
+
 	// parse proxy group
 	for idx, mapping := range groupsConfig {
-		groupType, existType := mapping["type"].(string)
+		group, err := outboundgroup.ParseProxyGroup(mapping, proxies, providersMap)
-		groupName, existName := mapping["name"].(string)
-		if !existType && existName {
-			return nil, fmt.Errorf("ProxyGroup %d: missing type or name", idx)
-		}
-
-		if _, exist := proxies[groupName]; exist {
-			return nil, fmt.Errorf("ProxyGroup %s: the duplicate name", groupName)
-		}
-		var group C.ProxyAdapter
-		ps := []C.Proxy{}
-
-		err := fmt.Errorf("cannot parse")
-		switch groupType {
-		case "url-test":
-			urlTestOption := &adapters.URLTestOption{}
-			err = decoder.Decode(mapping, urlTestOption)
-			if err != nil {
-				break
-			}
-
-			ps, err = getProxies(proxies, urlTestOption.Proxies)
-			if err != nil {
-				return nil, fmt.Errorf("ProxyGroup %s: %s", groupName, err.Error())
-			}
-			group, err = adapters.NewURLTest(*urlTestOption, ps)
-		case "select":
-			selectorOption := &adapters.SelectorOption{}
-			err = decoder.Decode(mapping, selectorOption)
-			if err != nil {
-				break
-			}
-
-			ps, err = getProxies(proxies, selectorOption.Proxies)
-			if err != nil {
-				return nil, fmt.Errorf("ProxyGroup %s: %s", groupName, err.Error())
-			}
-			group, err = adapters.NewSelector(selectorOption.Name, ps)
-		case "fallback":
-			fallbackOption := &adapters.FallbackOption{}
-			err = decoder.Decode(mapping, fallbackOption)
-			if err != nil {
-				break
-			}
-
-			ps, err = getProxies(proxies, fallbackOption.Proxies)
-			if err != nil {
-				return nil, fmt.Errorf("ProxyGroup %s: %s", groupName, err.Error())
-			}
-			group, err = adapters.NewFallback(*fallbackOption, ps)
-		case "load-balance":
-			loadBalanceOption := &adapters.LoadBalanceOption{}
-			err = decoder.Decode(mapping, loadBalanceOption)
-			if err != nil {
-				break
-			}
-
-			ps, err = getProxies(proxies, loadBalanceOption.Proxies)
-			if err != nil {
-				return nil, fmt.Errorf("ProxyGroup %s: %s", groupName, err.Error())
-			}
-			group, err = adapters.NewLoadBalance(*loadBalanceOption, ps)
-		}
 		if err != nil {
-			return nil, fmt.Errorf("Proxy %s: %s", groupName, err.Error())
+			return nil, nil, fmt.Errorf("ProxyGroup[%d]: %w", idx, err)
+		}
+
+		groupName := group.Name()
+		if _, exist := proxies[groupName]; exist {
+			return nil, nil, fmt.Errorf("ProxyGroup %s: the duplicate name", groupName)
+		}
+
+		proxies[groupName] = outbound.NewProxy(group)
+	}
+
+	// initial compatible provider
+	for _, pd := range providersMap {
+		if pd.VehicleType() != provider.Compatible {
+			continue
+		}
+
+		log.Infoln("Start initial compatible provider %s", pd.Name())
+		if err := pd.Initial(); err != nil {
+			return nil, nil, err
 		}
-		proxies[groupName] = adapters.NewProxy(group)
-		proxyList = append(proxyList, groupName)
 	}
 
 	ps := []C.Proxy{}
 	for _, v := range proxyList {
 		ps = append(ps, proxies[v])
 	}
+	hc := provider.NewHealthCheck(ps, "", 0)
+	pd, _ := provider.NewCompatibleProvider(provider.ReservedName, ps, hc)
+	providersMap[provider.ReservedName] = pd
 
-	global, _ := adapters.NewSelector("GLOBAL", ps)
+	global := outboundgroup.NewSelector("GLOBAL", []provider.ProxyProvider{pd})
-	proxies["GLOBAL"] = adapters.NewProxy(global)
+	proxies["GLOBAL"] = outbound.NewProxy(global)
-	return proxies, nil
+	return proxies, providersMap, nil
 }
 
-func parseRules(cfg *rawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) {
+func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) {
 	rules := []C.Rule{}
 
 	rulesConfig := cfg.Rule
+
+	// remove after 1.0
+	if len(rulesConfig) == 0 {
+		rulesConfig = cfg.RuleOld
+	}
+
 	// parse rules
 	for idx, line := range rulesConfig {
 		rule := trimArr(strings.Split(line, ","))
 		var (
 			payload string
 			target  string
+			params  = []string{}
 		)
 
-		switch len(rule) {
+		switch l := len(rule); {
-		case 2:
+		case l == 2:
 			target = rule[1]
-		case 3:
+		case l == 3:
 			payload = rule[1]
 			target = rule[2]
+		case l >= 4:
+			payload = rule[1]
+			target = rule[2]
+			params = rule[3:]
 		default:
 			return nil, fmt.Errorf("Rules[%d] [%s] error: format invalid", idx, line)
 		}
@@ -388,7 +408,12 @@ func parseRules(cfg *rawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) {
 		}
 
 		rule = trimArr(rule)
-		var parsed C.Rule
+		params = trimArr(params)
+		var (
+			parseErr error
+			parsed   C.Rule
+		)
+
 		switch rule[0] {
 		case "DOMAIN":
 			parsed = R.NewDomain(payload, target)
@@ -397,35 +422,31 @@ func parseRules(cfg *rawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) {
 		case "DOMAIN-KEYWORD":
 			parsed = R.NewDomainKeyword(payload, target)
 		case "GEOIP":
-			parsed = R.NewGEOIP(payload, target)
+			noResolve := R.HasNoResolve(params)
+			parsed = R.NewGEOIP(payload, target, noResolve)
 		case "IP-CIDR", "IP-CIDR6":
-			if rule := R.NewIPCIDR(payload, target, false); rule != nil {
+			noResolve := R.HasNoResolve(params)
-				parsed = rule
+			parsed, parseErr = R.NewIPCIDR(payload, target, R.WithIPCIDRNoResolve(noResolve))
-			}
 		// deprecated when bump to 1.0
 		case "SOURCE-IP-CIDR":
 			fallthrough
 		case "SRC-IP-CIDR":
-			if rule := R.NewIPCIDR(payload, target, true); rule != nil {
+			parsed, parseErr = R.NewIPCIDR(payload, target, R.WithIPCIDRSourceIP(true), R.WithIPCIDRNoResolve(true))
-				parsed = rule
-			}
 		case "SRC-PORT":
-			if rule := R.NewPort(payload, target, true); rule != nil {
+			parsed, parseErr = R.NewPort(payload, target, true)
-				parsed = rule
-			}
 		case "DST-PORT":
-			if rule := R.NewPort(payload, target, false); rule != nil {
+			parsed, parseErr = R.NewPort(payload, target, false)
-				parsed = rule
-			}
 		case "MATCH":
 			fallthrough
 		// deprecated when bump to 1.0
 		case "FINAL":
 			parsed = R.NewMatch(target)
+		default:
+			parseErr = fmt.Errorf("unsupported rule type %s", rule[0])
 		}
 
-		if parsed == nil {
+		if parseErr != nil {
-			return nil, fmt.Errorf("Rules[%d] [%s] error: payload invalid", idx, line)
+			return nil, fmt.Errorf("Rules[%d] [%s] error: %s", idx, line, parseErr.Error())
 		}
 
 		rules = append(rules, parsed)
@@ -434,6 +455,21 @@ func parseRules(cfg *rawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) {
 	return rules, nil
 }
 
+func parseHosts(cfg *RawConfig) (*trie.Trie, error) {
+	tree := trie.New()
+	if len(cfg.Hosts) != 0 {
+		for domain, ipStr := range cfg.Hosts {
+			ip := net.ParseIP(ipStr)
+			if ip == nil {
+				return nil, fmt.Errorf("%s is not a valid IP", ipStr)
+			}
+			tree.Insert(domain, ip)
+		}
+	}
+
+	return tree, nil
+}
+
 func hostWithDefaultPort(host string, defPort string) (string, error) {
 	if !strings.Contains(host, ":") {
 		host += ":"
@@ -464,20 +500,20 @@ func parseNameServer(servers []string) ([]dns.NameServer, error) {
 			return nil, fmt.Errorf("DNS NameServer[%d] format error: %s", idx, err.Error())
 		}
 
-		var host, dnsNetType string
+		var addr, dnsNetType string
 		switch u.Scheme {
 		case "udp":
-			host, err = hostWithDefaultPort(u.Host, "53")
+			addr, err = hostWithDefaultPort(u.Host, "53")
 			dnsNetType = "" // UDP
 		case "tcp":
-			host, err = hostWithDefaultPort(u.Host, "53")
+			addr, err = hostWithDefaultPort(u.Host, "53")
 			dnsNetType = "tcp" // TCP
 		case "tls":
-			host, err = hostWithDefaultPort(u.Host, "853")
+			addr, err = hostWithDefaultPort(u.Host, "853")
 			dnsNetType = "tcp-tls" // DNS over TLS
 		case "https":
 			clearURL := url.URL{Scheme: "https", Host: u.Host, Path: u.Path}
-			host = clearURL.String()
+			addr = clearURL.String()
 			dnsNetType = "https" // DNS over HTTPS
 		default:
 			return nil, fmt.Errorf("DNS NameServer[%d] unsupport scheme: %s", idx, u.Scheme)
@@ -491,14 +527,28 @@ func parseNameServer(servers []string) ([]dns.NameServer, error) {
 			nameservers,
 			dns.NameServer{
 				Net:  dnsNetType,
-				Addr: host,
+				Addr: addr,
 			},
 		)
 	}
 	return nameservers, nil
 }
 
-func parseDNS(cfg rawDNS) (*DNS, error) {
+func parseFallbackIPCIDR(ips []string) ([]*net.IPNet, error) {
+	ipNets := []*net.IPNet{}
+
+	for idx, ip := range ips {
+		_, ipnet, err := net.ParseCIDR(ip)
+		if err != nil {
+			return nil, fmt.Errorf("DNS FallbackIP[%d] format error: %s", idx, err.Error())
+		}
+		ipNets = append(ipNets, ipnet)
+	}
+
+	return ipNets, nil
+}
+
+func parseDNS(cfg RawDNS) (*DNS, error) {
 	if cfg.Enable && len(cfg.NameServer) == 0 {
 		return nil, fmt.Errorf("If DNS configuration is turned on, NameServer cannot be empty")
 	}
@@ -508,6 +558,9 @@ func parseDNS(cfg rawDNS) (*DNS, error) {
 		Listen:       cfg.Listen,
 		IPv6:         cfg.IPv6,
 		EnhancedMode: cfg.EnhancedMode,
+		FallbackFilter: FallbackFilter{
+			IPCIDR: []*net.IPNet{},
+		},
 	}
 	var err error
 	if dnsCfg.NameServer, err = parseNameServer(cfg.NameServer); err != nil {
@@ -518,12 +571,36 @@ func parseDNS(cfg rawDNS) (*DNS, error) {
 		return nil, err
 	}
 
+	if len(cfg.DefaultNameserver) == 0 {
+		return nil, errors.New("default nameserver should have at least one nameserver")
+	}
+	if dnsCfg.DefaultNameserver, err = parseNameServer(cfg.DefaultNameserver); err != nil {
+		return nil, err
+	}
+	// check default nameserver is pure ip addr
+	for _, ns := range dnsCfg.DefaultNameserver {
+		host, _, err := net.SplitHostPort(ns.Addr)
+		if err != nil || net.ParseIP(host) == nil {
+			return nil, errors.New("default nameserver should be pure IP")
+		}
+	}
+
 	if cfg.EnhancedMode == dns.FAKEIP {
 		_, ipnet, err := net.ParseCIDR(cfg.FakeIPRange)
 		if err != nil {
 			return nil, err
 		}
-		pool, err := fakeip.New(ipnet)
+
+		var host *trie.Trie
+		// fake ip skip host filter
+		if len(cfg.FakeIPFilter) != 0 {
+			host = trie.New()
+			for _, domain := range cfg.FakeIPFilter {
+				host.Insert(domain, true)
+			}
+		}
+
+		pool, err := fakeip.New(ipnet, 1000, host)
 		if err != nil {
 			return nil, err
 		}
@@ -531,6 +608,11 @@ func parseDNS(cfg rawDNS) (*DNS, error) {
 		dnsCfg.FakeIPRange = pool
 	}
 
+	dnsCfg.FallbackFilter.GeoIP = cfg.FallbackFilter.GeoIP
+	if fallbackip, err := parseFallbackIPCIDR(cfg.FallbackFilter.IPCIDR); err == nil {
+		dnsCfg.FallbackFilter.IPCIDR = fallbackip
+	}
+
 	return dnsCfg, nil
 }
 

config/initial.go

@@ -1,57 +1,30 @@
 package config
 
 import (
-	"archive/tar"
-	"compress/gzip"
 	"fmt"
 	"io"
 	"net/http"
 	"os"
-	"strings"
 
 	C "github.com/Dreamacro/clash/constant"
-
+	"github.com/Dreamacro/clash/log"
-	log "github.com/sirupsen/logrus"
 )
 
 func downloadMMDB(path string) (err error) {
-	resp, err := http.Get("http://geolite.maxmind.com/download/geoip/database/GeoLite2-Country.tar.gz")
+	resp, err := http.Get("https://github.com/Dreamacro/maxmind-geoip/releases/latest/download/Country.mmdb")
 	if err != nil {
 		return
 	}
 	defer resp.Body.Close()
 
-	gr, err := gzip.NewReader(resp.Body)
+	f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0644)
 	if err != nil {
-		return
+		return err
 	}
-	defer gr.Close()
+	defer f.Close()
+	_, err = io.Copy(f, resp.Body)
 
-	tr := tar.NewReader(gr)
+	return err
-	for {
-		h, err := tr.Next()
-		if err == io.EOF {
-			break
-		} else if err != nil {
-			return err
-		}
-
-		if !strings.HasSuffix(h.Name, "GeoLite2-Country.mmdb") {
-			continue
-		}
-
-		f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0644)
-		if err != nil {
-			return err
-		}
-		defer f.Close()
-		_, err = io.Copy(f, tr)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
 }
 
 // Init prepare necessary files
@@ -65,15 +38,19 @@ func Init(dir string) error {
 
 	// initial config.yaml
 	if _, err := os.Stat(C.Path.Config()); os.IsNotExist(err) {
-		log.Info("Can't find config, create an empty file")
+		log.Infoln("Can't find config, create a initial config file")
-		os.OpenFile(C.Path.Config(), os.O_CREATE|os.O_WRONLY, 0644)
+		f, err := os.OpenFile(C.Path.Config(), os.O_CREATE|os.O_WRONLY, 0644)
+		if err != nil {
+			return fmt.Errorf("Can't create file %s: %s", C.Path.Config(), err.Error())
+		}
+		f.Write([]byte(`port: 7890`))
+		f.Close()
 	}
 
 	// initial mmdb
 	if _, err := os.Stat(C.Path.MMDB()); os.IsNotExist(err) {
-		log.Info("Can't find MMDB, start download")
+		log.Infoln("Can't find MMDB, start download")
-		err := downloadMMDB(C.Path.MMDB())
+		if err := downloadMMDB(C.Path.MMDB()); err != nil {
-		if err != nil {
 			return fmt.Errorf("Can't download MMDB: %s", err.Error())
 		}
 	}

config/utils.go

@@ -4,7 +4,8 @@ import (
 	"fmt"
 	"strings"
 
-	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/adapters/outboundgroup"
+	"github.com/Dreamacro/clash/common/structure"
 )
 
 func trimArr(arr []string) (r []string) {
@@ -14,18 +15,6 @@ func trimArr(arr []string) (r []string) {
 	return
 }
 
-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 or(pointers ...*int) *int {
 	for _, p := range pointers {
 		if p != nil {
@@ -34,3 +23,135 @@ func or(pointers ...*int) *int {
 	}
 	return pointers[len(pointers)-1]
 }
+
+// Check if ProxyGroups form DAG(Directed Acyclic Graph), and sort all ProxyGroups by dependency order.
+// Meanwhile, record the original index in the config file.
+// If loop is detected, return an error with location of loop.
+func proxyGroupsDagSort(groupsConfig []map[string]interface{}) error {
+	type graphNode struct {
+		indegree int
+		// topological order
+		topo int
+		// the origional data in `groupsConfig`
+		data map[string]interface{}
+		// `outdegree` and `from` are used in loop locating
+		outdegree int
+		option    *outboundgroup.GroupCommonOption
+		from      []string
+	}
+
+	decoder := structure.NewDecoder(structure.Option{TagName: "group", WeaklyTypedInput: true})
+	graph := make(map[string]*graphNode)
+
+	// Step 1.1 build dependency graph
+	for _, mapping := range groupsConfig {
+		option := &outboundgroup.GroupCommonOption{}
+		if err := decoder.Decode(mapping, option); err != nil {
+			return fmt.Errorf("ProxyGroup %s: %s", option.Name, err.Error())
+		}
+
+		groupName := option.Name
+		if node, ok := graph[groupName]; ok {
+			if node.data != nil {
+				return fmt.Errorf("ProxyGroup %s: duplicate group name", groupName)
+			}
+			node.data = mapping
+			node.option = option
+		} else {
+			graph[groupName] = &graphNode{0, -1, mapping, 0, option, nil}
+		}
+
+		for _, proxy := range option.Proxies {
+			if node, ex := graph[proxy]; ex {
+				node.indegree++
+			} else {
+				graph[proxy] = &graphNode{1, -1, nil, 0, nil, nil}
+			}
+		}
+	}
+	// Step 1.2 Topological Sort
+	// topological index of **ProxyGroup**
+	index := 0
+	queue := make([]string, 0)
+	for name, node := range graph {
+		// in the begning, put nodes that have `node.indegree == 0` into queue.
+		if node.indegree == 0 {
+			queue = append(queue, name)
+		}
+	}
+	// every element in queue have indegree == 0
+	for ; len(queue) > 0; queue = queue[1:] {
+		name := queue[0]
+		node := graph[name]
+		if node.option != nil {
+			index++
+			groupsConfig[len(groupsConfig)-index] = node.data
+			if len(node.option.Proxies) == 0 {
+				delete(graph, name)
+				continue
+			}
+
+			for _, proxy := range node.option.Proxies {
+				child := graph[proxy]
+				child.indegree--
+				if child.indegree == 0 {
+					queue = append(queue, proxy)
+				}
+			}
+		}
+		delete(graph, name)
+	}
+
+	// no loop is detected, return sorted ProxyGroup
+	if len(graph) == 0 {
+		return nil
+	}
+
+	// if loop is detected, locate the loop and throw an error
+	// Step 2.1 rebuild the graph, fill `outdegree` and `from` filed
+	for name, node := range graph {
+		if node.option == nil {
+			continue
+		}
+
+		if len(node.option.Proxies) == 0 {
+			continue
+		}
+
+		for _, proxy := range node.option.Proxies {
+			node.outdegree++
+			child := graph[proxy]
+			if child.from == nil {
+				child.from = make([]string, 0, child.indegree)
+			}
+			child.from = append(child.from, name)
+		}
+	}
+	// Step 2.2 remove nodes outside the loop. so that we have only the loops remain in `graph`
+	queue = make([]string, 0)
+	// initialize queue with node have outdegree == 0
+	for name, node := range graph {
+		if node.outdegree == 0 {
+			queue = append(queue, name)
+		}
+	}
+	// every element in queue have outdegree == 0
+	for ; len(queue) > 0; queue = queue[1:] {
+		name := queue[0]
+		node := graph[name]
+		for _, f := range node.from {
+			graph[f].outdegree--
+			if graph[f].outdegree == 0 {
+				queue = append(queue, f)
+			}
+		}
+		delete(graph, name)
+	}
+	// Step 2.3 report the elements in loop
+	loopElements := make([]string, 0, len(graph))
+	for name := range graph {
+		loopElements = append(loopElements, name)
+		delete(graph, name)
+	}
+	return fmt.Errorf("Loop is detected in ProxyGroup, please check following ProxyGroups: %v", loopElements)
+}

constant/adapters.go

@@ -1,6 +1,8 @@
 package constant
 
 import (
+	"context"
+	"fmt"
 	"net"
 	"time"
 )
@@ -8,14 +10,19 @@ import (
 // Adapter Type
 const (
 	Direct AdapterType = iota
-	Fallback
 	Reject
-	Selector
+
 	Shadowsocks
+	Snell
 	Socks5
 	Http
-	URLTest
 	Vmess
+	Trojan
+
+	Relay
+	Selector
+	Fallback
+	URLTest
 	LoadBalance
 )
 
@@ -24,14 +31,44 @@ type ServerAdapter interface {
 	Metadata() *Metadata
 }
 
+type Connection interface {
+	Chains() Chain
+	AppendToChains(adapter ProxyAdapter)
+}
+
+type Chain []string
+
+func (c Chain) String() string {
+	switch len(c) {
+	case 0:
+		return ""
+	case 1:
+		return c[0]
+	default:
+		return fmt.Sprintf("%s[%s]", c[len(c)-1], c[0])
+	}
+}
+
+type Conn interface {
+	net.Conn
+	Connection
+}
+
+type PacketConn interface {
+	net.PacketConn
+	Connection
+	WriteWithMetadata(p []byte, metadata *Metadata) (n int, err error)
+}
+
 type ProxyAdapter interface {
 	Name() string
 	Type() AdapterType
-	Dial(metadata *Metadata) (net.Conn, error)
+	StreamConn(c net.Conn, metadata *Metadata) (net.Conn, error)
-	DialUDP(metadata *Metadata) (net.PacketConn, net.Addr, error)
+	DialContext(ctx context.Context, metadata *Metadata) (Conn, error)
+	DialUDP(metadata *Metadata) (PacketConn, error)
 	SupportUDP() bool
-	Destroy()
 	MarshalJSON() ([]byte, error)
+	Addr() string
 }
 
 type DelayHistory struct {
@@ -43,8 +80,9 @@ type Proxy interface {
 	ProxyAdapter
 	Alive() bool
 	DelayHistory() []DelayHistory
+	Dial(metadata *Metadata) (Conn, error)
 	LastDelay() uint16
-	URLTest(url string) (uint16, error)
+	URLTest(ctx context.Context, url string) (uint16, error)
 }
 
 // AdapterType is enum of adapter type
@@ -54,25 +92,52 @@ func (at AdapterType) String() string {
 	switch at {
 	case Direct:
 		return "Direct"
-	case Fallback:
-		return "Fallback"
 	case Reject:
 		return "Reject"
-	case Selector:
+
-		return "Selector"
 	case Shadowsocks:
 		return "Shadowsocks"
+	case Snell:
+		return "Snell"
 	case Socks5:
 		return "Socks5"
 	case Http:
 		return "Http"
-	case URLTest:
-		return "URLTest"
 	case Vmess:
 		return "Vmess"
+	case Trojan:
+		return "Trojan"
+
+	case Relay:
+		return "Relay"
+	case Selector:
+		return "Selector"
+	case Fallback:
+		return "Fallback"
+	case URLTest:
+		return "URLTest"
 	case LoadBalance:
 		return "LoadBalance"
+
 	default:
-		return "Unknow"
+		return "Unknown"
 	}
 }
+
+// UDPPacket contains the data of UDP packet, and offers control/info of UDP packet's source
+type UDPPacket interface {
+	// Data get the payload of UDP Packet
+	Data() []byte
+
+	// WriteBack writes the payload with source IP/Port equals addr
+	// - variable source IP/Port is important to STUN
+	// - if addr is not provided, WriteBack will wirte out UDP packet with SourceIP/Prot equals to origional Target,
+	//   this is important when using Fake-IP.
+	WriteBack(b []byte, addr net.Addr) (n int, err error)
+
+	// Close closes the underlaying connection.
+	Close() error
+
+	// LocalAddr returns the source IP/Port of packet
+	LocalAddr() net.Addr
+}

constant/metadata.go

@@ -1,7 +1,9 @@
 package constant
 
 import (
+	"encoding/json"
 	"net"
+	"strconv"
 )
 
 // Socks addr type
@@ -14,6 +16,7 @@ const (
 	UDP
 
 	HTTP Type = iota
+	HTTPCONNECT
 	SOCKS
 	REDIR
 )
@@ -27,25 +30,74 @@ func (n *NetWork) String() string {
 	return "udp"
 }
 
+func (n NetWork) MarshalJSON() ([]byte, error) {
+	return json.Marshal(n.String())
+}
+
 type Type int
 
+func (t Type) String() string {
+	switch t {
+	case HTTP:
+		return "HTTP"
+	case HTTPCONNECT:
+		return "HTTP Connect"
+	case SOCKS:
+		return "Socks5"
+	case REDIR:
+		return "Redir"
+	default:
+		return "Unknown"
+	}
+}
+
+func (t Type) MarshalJSON() ([]byte, error) {
+	return json.Marshal(t.String())
+}
+
 // Metadata is used to store connection address
 type Metadata struct {
-	NetWork  NetWork
+	NetWork  NetWork `json:"network"`
-	Type     Type
+	Type     Type    `json:"type"`
-	SrcIP    *net.IP
+	SrcIP    net.IP  `json:"sourceIP"`
-	DstIP    *net.IP
+	DstIP    net.IP  `json:"destinationIP"`
-	SrcPort  string
+	SrcPort  string  `json:"sourcePort"`
-	DstPort  string
+	DstPort  string  `json:"destinationPort"`
-	AddrType int
+	AddrType int     `json:"-"`
-	Host     string
+	Host     string  `json:"host"`
+}
+
+func (m *Metadata) RemoteAddress() string {
+	return net.JoinHostPort(m.String(), m.DstPort)
+}
+
+func (m *Metadata) SourceAddress() string {
+	return net.JoinHostPort(m.SrcIP.String(), m.SrcPort)
+}
+
+func (m *Metadata) Resolved() bool {
+	return m.DstIP != nil
+}
+
+func (m *Metadata) UDPAddr() *net.UDPAddr {
+	if m.NetWork != UDP || m.DstIP == nil {
+		return nil
+	}
+	port, _ := strconv.Atoi(m.DstPort)
+	return &net.UDPAddr{
+		IP:   m.DstIP,
+		Port: port,
+	}
 }
 
 func (m *Metadata) String() string {
-	if m.Host == "" {
+	if m.Host != "" {
+		return m.Host
+	} else if m.DstIP != nil {
 		return m.DstIP.String()
+	} else {
+		return "<nil>"
 	}
-	return m.Host
 }
 
 func (m *Metadata) Valid() bool {

constant/path.go

@@ -2,8 +2,8 @@ package constant
 
 import (
 	"os"
-	"os/user"
 	P "path"
+	"path/filepath"
 )
 
 const Name = "clash"
@@ -12,39 +12,47 @@ const Name = "clash"
 var Path *path
 
 type path struct {
-	homedir string
+	homeDir    string
+	configFile string
 }
 
 func init() {
-	currentUser, err := user.Current()
+	homeDir, err := os.UserHomeDir()
-	var homedir string
 	if err != nil {
-		dir := os.Getenv("HOME")
+		homeDir, _ = os.Getwd()
-		if dir == "" {
-			dir, _ = os.Getwd()
-		}
-		homedir = dir
-	} else {
-		homedir = currentUser.HomeDir
 	}
 
-	homedir = P.Join(homedir, ".config", Name)
+	homeDir = P.Join(homeDir, ".config", Name)
-	Path = &path{homedir: homedir}
+	Path = &path{homeDir: homeDir, configFile: "config.yaml"}
 }
 
 // SetHomeDir is used to set the configuration path
 func SetHomeDir(root string) {
-	Path = &path{homedir: root}
+	Path.homeDir = root
+}
+
+// SetConfig is used to set the configuration file
+func SetConfig(file string) {
+	Path.configFile = file
 }
 
 func (p *path) HomeDir() string {
-	return p.homedir
+	return p.homeDir
 }
 
 func (p *path) Config() string {
-	return P.Join(p.homedir, "config.yaml")
+	return p.configFile
+}
+
+// Resolve return a absolute path or a relative path with homedir
+func (p *path) Resolve(path string) string {
+	if !filepath.IsAbs(path) {
+		return filepath.Join(p.HomeDir(), path)
+	}
+
+	return path
 }
 
 func (p *path) MMDB() string {
-	return P.Join(p.homedir, "Country.mmdb")
+	return P.Join(p.homeDir, "Country.mmdb")
 }

constant/rule.go

@@ -24,7 +24,7 @@ func (rt RuleType) String() string {
 	case DomainKeyword:
 		return "DomainKeyword"
 	case GEOIP:
-		return "GEOIP"
+		return "GeoIP"
 	case IPCIDR:
 		return "IPCIDR"
 	case SrcIPCIDR:
@@ -34,15 +34,16 @@ func (rt RuleType) String() string {
 	case DstPort:
 		return "DstPort"
 	case MATCH:
-		return "MATCH"
+		return "Match"
 	default:
-		return "Unknow"
+		return "Unknown"
 	}
 }
 
 type Rule interface {
 	RuleType() RuleType
-	IsMatch(metadata *Metadata) bool
+	Match(metadata *Metadata) bool
 	Adapter() string
 	Payload() string
+	NoResolveIP() bool
 }

constant/traffic.go

@@ -1,55 +0,0 @@
-package constant
-
-import (
-	"time"
-)
-
-type Traffic struct {
-	up        chan int64
-	down      chan int64
-	upCount   int64
-	downCount int64
-	upTotal   int64
-	downTotal int64
-	interval  time.Duration
-}
-
-func (t *Traffic) Up() chan<- int64 {
-	return t.up
-}
-
-func (t *Traffic) Down() chan<- int64 {
-	return t.down
-}
-
-func (t *Traffic) Now() (up int64, down int64) {
-	return t.upTotal, t.downTotal
-}
-
-func (t *Traffic) handle() {
-	go t.handleCh(t.up, &t.upCount, &t.upTotal)
-	go t.handleCh(t.down, &t.downCount, &t.downTotal)
-}
-
-func (t *Traffic) handleCh(ch <-chan int64, count *int64, total *int64) {
-	ticker := time.NewTicker(t.interval)
-	for {
-		select {
-		case n := <-ch:
-			*count += n
-		case <-ticker.C:
-			*total = *count
-			*count = 0
-		}
-	}
-}
-
-func NewTraffic(interval time.Duration) *Traffic {
-	t := &Traffic{
-		up:       make(chan int64),
-		down:     make(chan int64),
-		interval: interval,
-	}
-	go t.handle()
-	return t
-}

dns/client.go

@@ -2,13 +2,20 @@ package dns
 
 import (
 	"context"
+	"fmt"
+	"net"
+	"strings"
+
+	"github.com/Dreamacro/clash/component/dialer"
 
 	D "github.com/miekg/dns"
 )
 
 type client struct {
 	*D.Client
-	Address string
+	r    *Resolver
+	port string
+	host string
 }
 
 func (c *client) Exchange(m *D.Msg) (msg *D.Msg, err error) {
@@ -16,6 +23,44 @@ func (c *client) Exchange(m *D.Msg) (msg *D.Msg, err error) {
 }
 
 func (c *client) ExchangeContext(ctx context.Context, m *D.Msg) (msg *D.Msg, err error) {
-	msg, _, err = c.Client.ExchangeContext(ctx, m, c.Address)
+	var ip net.IP
-	return
+	if c.r == nil {
+		// a default ip dns
+		ip = net.ParseIP(c.host)
+	} else {
+		var err error
+		if ip, err = c.r.ResolveIP(c.host); err != nil {
+			return nil, fmt.Errorf("use default dns resolve failed: %w", err)
+		}
+	}
+
+	d := dialer.Dialer()
+	if dialer.DialHook != nil {
+		network := "udp"
+		if strings.HasPrefix(c.Client.Net, "tcp") {
+			network = "tcp"
+		}
+		dialer.DialHook(d, network, ip)
+	}
+
+	c.Client.Dialer = d
+
+	// miekg/dns ExchangeContext doesn't respond to context cancel.
+	// this is a workaround
+	type result struct {
+		msg *D.Msg
+		err error
+	}
+	ch := make(chan result, 1)
+	go func() {
+		msg, _, err := c.Client.Exchange(m, net.JoinHostPort(ip.String(), c.port))
+		ch <- result{msg, err}
+	}()
+
+	select {
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	case ret := <-ch:
+		return ret.msg, ret.err
+	}
 }

dns/doh.go

@@ -5,25 +5,22 @@ import (
 	"context"
 	"crypto/tls"
 	"io/ioutil"
+	"net"
 	"net/http"
 
+	"github.com/Dreamacro/clash/component/dialer"
+
 	D "github.com/miekg/dns"
 )
 
 const (
 	// dotMimeType is the DoH mimetype that should be used.
 	dotMimeType = "application/dns-message"
-
-	// dotPath is the URL path that should be used.
-	dotPath = "/dns-query"
 )
 
-var dohTransport = &http.Transport{
-	TLSClientConfig: &tls.Config{ClientSessionCache: globalSessionCache},
-}
-
 type dohClient struct {
-	url string
+	url       string
+	transport *http.Transport
 }
 
 func (dc *dohClient) Exchange(m *D.Msg) (msg *D.Msg, err error) {
@@ -58,7 +55,7 @@ func (dc *dohClient) newRequest(m *D.Msg) (*http.Request, error) {
 }
 
 func (dc *dohClient) doRequest(req *http.Request) (msg *D.Msg, err error) {
-	client := &http.Client{Transport: dohTransport}
+	client := &http.Client{Transport: dc.transport}
 	resp, err := client.Do(req)
 	if err != nil {
 		return nil, err
@@ -73,3 +70,25 @@ func (dc *dohClient) doRequest(req *http.Request) (msg *D.Msg, err error) {
 	err = msg.Unpack(buf)
 	return msg, err
 }
+
+func newDoHClient(url string, r *Resolver) *dohClient {
+	return &dohClient{
+		url: url,
+		transport: &http.Transport{
+			TLSClientConfig: &tls.Config{ClientSessionCache: globalSessionCache},
+			DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
+				host, port, err := net.SplitHostPort(addr)
+				if err != nil {
+					return nil, err
+				}
+
+				ip, err := r.ResolveIPv4(host)
+				if err != nil {
+					return nil, err
+				}
+
+				return dialer.DialContext(ctx, "tcp4", net.JoinHostPort(ip.String(), port))
+			},
+		},
+	}
+}

dns/filters.go

@@ -0,0 +1,26 @@
+package dns
+
+import (
+	"net"
+
+	"github.com/Dreamacro/clash/component/mmdb"
+)
+
+type fallbackFilter interface {
+	Match(net.IP) bool
+}
+
+type geoipFilter struct{}
+
+func (gf *geoipFilter) Match(ip net.IP) bool {
+	record, _ := mmdb.Instance().Country(ip)
+	return record.Country.IsoCode != "CN" && record.Country.IsoCode != ""
+}
+
+type ipnetFilter struct {
+	ipnet *net.IPNet
+}
+
+func (inf *ipnetFilter) Match(ip net.IP) bool {
+	return inf.ipnet.Contains(ip)
+}

dns/iputil.go

@@ -1,32 +0,0 @@
-package dns
-
-import (
-	"errors"
-	"net"
-)
-
-var (
-	errIPNotFound = errors.New("cannot found ip")
-)
-
-// ResolveIP with a host, return ip
-func ResolveIP(host string) (net.IP, error) {
-	if DefaultResolver != nil {
-		if DefaultResolver.ipv6 {
-			return DefaultResolver.ResolveIP(host)
-		}
-		return DefaultResolver.ResolveIPv4(host)
-	}
-
-	ip := net.ParseIP(host)
-	if ip != nil {
-		return ip, nil
-	}
-
-	ipAddr, err := net.ResolveIPAddr("ip", host)
-	if err != nil {
-		return nil, err
-	}
-
-	return ipAddr.IP, nil
-}

dns/middleware.go

@@ -0,0 +1,85 @@
+package dns
+
+import (
+	"strings"
+
+	"github.com/Dreamacro/clash/component/fakeip"
+	"github.com/Dreamacro/clash/log"
+
+	D "github.com/miekg/dns"
+)
+
+type handler func(w D.ResponseWriter, r *D.Msg)
+type middleware func(next handler) handler
+
+func withFakeIP(fakePool *fakeip.Pool) middleware {
+	return func(next handler) handler {
+		return func(w D.ResponseWriter, r *D.Msg) {
+			q := r.Question[0]
+
+			if q.Qtype == D.TypeAAAA {
+				D.HandleFailed(w, r)
+				return
+			} else if q.Qtype != D.TypeA {
+				next(w, r)
+				return
+			}
+
+			host := strings.TrimRight(q.Name, ".")
+			if fakePool.LookupHost(host) {
+				next(w, r)
+				return
+			}
+
+			rr := &D.A{}
+			rr.Hdr = D.RR_Header{Name: q.Name, Rrtype: D.TypeA, Class: D.ClassINET, Ttl: dnsDefaultTTL}
+			ip := fakePool.Lookup(host)
+			rr.A = ip
+			msg := r.Copy()
+			msg.Answer = []D.RR{rr}
+
+			setMsgTTL(msg, 1)
+			msg.SetRcode(r, msg.Rcode)
+			msg.Authoritative = true
+			w.WriteMsg(msg)
+			return
+		}
+	}
+}
+
+func withResolver(resolver *Resolver) handler {
+	return func(w D.ResponseWriter, r *D.Msg) {
+		msg, err := resolver.Exchange(r)
+		if err != nil {
+			q := r.Question[0]
+			log.Debugln("[DNS Server] Exchange %s failed: %v", q.String(), err)
+			D.HandleFailed(w, r)
+			return
+		}
+		msg.SetRcode(r, msg.Rcode)
+		msg.Authoritative = true
+		w.WriteMsg(msg)
+		return
+	}
+}
+
+func compose(middlewares []middleware, endpoint handler) handler {
+	length := len(middlewares)
+	h := endpoint
+	for i := length - 1; i >= 0; i-- {
+		middleware := middlewares[i]
+		h = middleware(h)
+	}
+
+	return h
+}
+
+func newHandler(resolver *Resolver) handler {
+	middlewares := []middleware{}
+
+	if resolver.FakeIPEnabled() {
+		middlewares = append(middlewares, withFakeIP(resolver.pool))
+	}
+
+	return compose(middlewares, withResolver(resolver))
+}

dns/resolver.go

@@ -4,33 +4,25 @@ import (
 	"context"
 	"crypto/tls"
 	"errors"
+	"math/rand"
 	"net"
 	"strings"
-	"sync"
 	"time"
 
 	"github.com/Dreamacro/clash/common/cache"
 	"github.com/Dreamacro/clash/common/picker"
 	"github.com/Dreamacro/clash/component/fakeip"
-	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/component/resolver"
 
 	D "github.com/miekg/dns"
-	geoip2 "github.com/oschwald/geoip2-golang"
+	"golang.org/x/sync/singleflight"
-)
-
-var (
-	// DefaultResolver aim to resolve ip with host
-	DefaultResolver *Resolver
 )
 
 var (
 	globalSessionCache = tls.NewLRUClientSessionCache(64)
-
-	mmdb *geoip2.Reader
-	once sync.Once
 )
 
-type resolver interface {
+type dnsClient interface {
 	Exchange(m *D.Msg) (msg *D.Msg, err error)
 	ExchangeContext(ctx context.Context, m *D.Msg) (msg *D.Msg, err error)
 }
@@ -41,43 +33,37 @@ type result struct {
 }
 
 type Resolver struct {
-	ipv6     bool
+	ipv6            bool
-	mapping  bool
+	mapping         bool
-	fakeip   bool
+	fakeip          bool
-	pool     *fakeip.Pool
+	pool            *fakeip.Pool
-	fallback []resolver
+	main            []dnsClient
-	main     []resolver
+	fallback        []dnsClient
-	cache    *cache.Cache
+	fallbackFilters []fallbackFilter
+	group           singleflight.Group
+	cache           *cache.Cache
 }
 
-// ResolveIP request with TypeA and TypeAAAA, priority return TypeAAAA
+// ResolveIP request with TypeA and TypeAAAA, priority return TypeA
 func (r *Resolver) ResolveIP(host string) (ip net.IP, err error) {
-	ip = net.ParseIP(host)
+	ch := make(chan net.IP, 1)
-	if ip != nil {
-		return ip, nil
-	}
-
-	ch := make(chan net.IP)
 	go func() {
 		defer close(ch)
-		ip, err := r.resolveIP(host, D.TypeA)
+		ip, err := r.resolveIP(host, D.TypeAAAA)
 		if err != nil {
 			return
 		}
 		ch <- ip
 	}()
 
-	ip, err = r.resolveIP(host, D.TypeAAAA)
+	ip, err = r.resolveIP(host, D.TypeA)
 	if err == nil {
-		go func() {
-			<-ch
-		}()
 		return
 	}
 
 	ip, open := <-ch
 	if !open {
-		return nil, errIPNotFound
+		return nil, resolver.ErrIPNotFound
 	}
 
 	return ip, nil
@@ -85,26 +71,21 @@ func (r *Resolver) ResolveIP(host string) (ip net.IP, err error) {
 
 // ResolveIPv4 request with TypeA
 func (r *Resolver) ResolveIPv4(host string) (ip net.IP, err error) {
-	ip = net.ParseIP(host)
+	return r.resolveIP(host, D.TypeA)
-	if ip != nil {
+}
-		return ip, nil
+
+// ResolveIPv6 request with TypeAAAA
+func (r *Resolver) ResolveIPv6(host string) (ip net.IP, err error) {
+	return r.resolveIP(host, D.TypeAAAA)
+}
+
+func (r *Resolver) shouldFallback(ip net.IP) bool {
+	for _, filter := range r.fallbackFilters {
+		if filter.Match(ip) {
+			return true
+		}
 	}
-
+	return false
-	query := &D.Msg{}
-	query.SetQuestion(D.Fqdn(host), D.TypeA)
-
-	msg, err := r.Exchange(query)
-	if err != nil {
-		return nil, err
-	}
-
-	ips := r.msgToIP(msg)
-	if len(ips) == 0 {
-		return nil, errIPNotFound
-	}
-
-	ip = ips[0]
-	return
 }
 
 // Exchange a batch of dns request, and it use cache
@@ -134,18 +115,28 @@ func (r *Resolver) Exchange(m *D.Msg) (msg *D.Msg, err error) {
 		}
 	}()
 
-	isIPReq := isIPRequest(q)
+	ret, err, _ := r.group.Do(q.String(), func() (interface{}, error) {
-	if isIPReq {
+		isIPReq := isIPRequest(q)
-		msg, err = r.fallbackExchange(m)
+		if isIPReq {
-		return
+			return r.fallbackExchange(m)
+		}
+
+		return r.batchExchange(r.main, m)
+	})
+
+	if err == nil {
+		msg = ret.(*D.Msg)
 	}
 
-	msg, err = r.batchExchange(r.main, m)
 	return
 }
 
 // IPToHost return fake-ip or redir-host mapping host
 func (r *Resolver) IPToHost(ip net.IP) (string, bool) {
+	if r.fakeip {
+		return r.pool.LookBack(ip)
+	}
+
 	cache := r.cache.Get(ip.String())
 	if cache == nil {
 		return "", false
@@ -158,37 +149,36 @@ func (r *Resolver) IsMapping() bool {
 	return r.mapping
 }
 
-func (r *Resolver) IsFakeIP() bool {
+// FakeIPEnabled returns if fake-ip is enabled
+func (r *Resolver) FakeIPEnabled() bool {
 	return r.fakeip
 }
 
-func (r *Resolver) batchExchange(clients []resolver, m *D.Msg) (msg *D.Msg, err error) {
+// IsFakeIP determine if given ip is a fake-ip
-	in := make(chan interface{})
+func (r *Resolver) IsFakeIP(ip net.IP) bool {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	if r.FakeIPEnabled() {
-	defer cancel()
+		return r.pool.Exist(ip)
-	fast := picker.SelectFast(ctx, in)
+	}
+	return false
+}
 
-	wg := sync.WaitGroup{}
+func (r *Resolver) batchExchange(clients []dnsClient, m *D.Msg) (msg *D.Msg, err error) {
-	wg.Add(len(clients))
+	fast, ctx := picker.WithTimeout(context.Background(), time.Second*5)
-	for _, r := range clients {
+	for _, client := range clients {
-		go func(r resolver) {
+		r := client
-			defer wg.Done()
+		fast.Go(func() (interface{}, error) {
-			msg, err := r.ExchangeContext(ctx, m)
+			m, err := r.ExchangeContext(ctx, m)
-			if err != nil || msg.Rcode != D.RcodeSuccess {
+			if err != nil {
-				return
+				return nil, err
+			} else if m.Rcode == D.RcodeServerFailure || m.Rcode == D.RcodeRefused {
+				return nil, errors.New("server failure")
 			}
-			in <- msg
+			return m, nil
-		}(r)
+		})
 	}
 
-	// release in channel
+	elm := fast.Wait()
-	go func() {
+	if elm == nil {
-		wg.Wait()
-		close(in)
-	}()
-
-	elm, exist := <-fast
-	if !exist {
 		return nil, errors.New("All DNS requests failed")
 	}
 
@@ -206,15 +196,10 @@ func (r *Resolver) fallbackExchange(m *D.Msg) (msg *D.Msg, err error) {
 	fallbackMsg := r.asyncExchange(r.fallback, m)
 	res := <-msgCh
 	if res.Error == nil {
-		if mmdb == nil {
-			return nil, errors.New("GeoIP cannot use")
-		}
-
 		if ips := r.msgToIP(res.Msg); len(ips) != 0 {
-			if record, _ := mmdb.Country(ips[0]); record.Country.IsoCode == "CN" || record.Country.IsoCode == "" {
+			if !r.shouldFallback(ips[0]) {
-				// release channel
-				go func() { <-fallbackMsg }()
 				msg = res.Msg
+				err = res.Error
 				return msg, err
 			}
 		}
@@ -226,6 +211,18 @@ func (r *Resolver) fallbackExchange(m *D.Msg) (msg *D.Msg, err error) {
 }
 
 func (r *Resolver) resolveIP(host string, dnsType uint16) (ip net.IP, err error) {
+	ip = net.ParseIP(host)
+	if ip != nil {
+		isIPv4 := ip.To4() != nil
+		if dnsType == D.TypeAAAA && !isIPv4 {
+			return ip, nil
+		} else if dnsType == D.TypeA && isIPv4 {
+			return ip, nil
+		} else {
+			return nil, resolver.ErrIPVersion
+		}
+	}
+
 	query := &D.Msg{}
 	query.SetQuestion(D.Fqdn(host), dnsType)
 
@@ -235,11 +232,12 @@ func (r *Resolver) resolveIP(host string, dnsType uint16) (ip net.IP, err error)
 	}
 
 	ips := r.msgToIP(msg)
-	if len(ips) == 0 {
+	ipLength := len(ips)
-		return nil, errIPNotFound
+	if ipLength == 0 {
+		return nil, resolver.ErrIPNotFound
 	}
 
-	ip = ips[0]
+	ip = ips[rand.Intn(ipLength)]
 	return
 }
 
@@ -258,8 +256,8 @@ func (r *Resolver) msgToIP(msg *D.Msg) []net.IP {
 	return ips
 }
 
-func (r *Resolver) asyncExchange(client []resolver, msg *D.Msg) <-chan *result {
+func (r *Resolver) asyncExchange(client []dnsClient, msg *D.Msg) <-chan *result {
-	ch := make(chan *result)
+	ch := make(chan *result, 1)
 	go func() {
 		res, err := r.batchExchange(client, msg)
 		ch <- &result{Msg: res, Error: err}
@@ -272,28 +270,47 @@ type NameServer struct {
 	Addr string
 }
 
+type FallbackFilter struct {
+	GeoIP  bool
+	IPCIDR []*net.IPNet
+}
+
 type Config struct {
 	Main, Fallback []NameServer
+	Default        []NameServer
 	IPv6           bool
 	EnhancedMode   EnhancedMode
+	FallbackFilter FallbackFilter
 	Pool           *fakeip.Pool
 }
 
 func New(config Config) *Resolver {
-	once.Do(func() {
+	defaultResolver := &Resolver{
-		mmdb, _ = geoip2.Open(C.Path.MMDB())
+		main:  transform(config.Default, nil),
-	})
+		cache: cache.New(time.Second * 60),
+	}
 
 	r := &Resolver{
 		ipv6:    config.IPv6,
-		main:    transform(config.Main),
+		main:    transform(config.Main, defaultResolver),
 		cache:   cache.New(time.Second * 60),
 		mapping: config.EnhancedMode == MAPPING,
 		fakeip:  config.EnhancedMode == FAKEIP,
 		pool:    config.Pool,
 	}
+
 	if len(config.Fallback) != 0 {
-		r.fallback = transform(config.Fallback)
+		r.fallback = transform(config.Fallback, defaultResolver)
 	}
+
+	fallbackFilters := []fallbackFilter{}
+	if config.FallbackFilter.GeoIP {
+		fallbackFilters = append(fallbackFilters, &geoipFilter{})
+	}
+	for _, ipnet := range config.FallbackFilter.IPCIDR {
+		fallbackFilters = append(fallbackFilters, &ipnetFilter{ipnet: ipnet})
+	}
+	r.fallbackFilters = fallbackFilters
+
 	return r
 }

dns/server.go

@@ -1,12 +1,8 @@
 package dns
 
 import (
-	"errors"
-	"fmt"
 	"net"
 
-	"github.com/Dreamacro/clash/log"
-	"github.com/miekg/dns"
 	D "github.com/miekg/dns"
 )
 
@@ -19,79 +15,26 @@ var (
 
 type Server struct {
 	*D.Server
-	r *Resolver
+	handler handler
 }
 
 func (s *Server) ServeDNS(w D.ResponseWriter, r *D.Msg) {
-	if s.r.IsFakeIP() {
+	if len(r.Question) == 0 {
-		msg, err := s.handleFakeIP(r)
-		if err != nil {
-			D.HandleFailed(w, r)
-			return
-		}
-		msg.SetReply(r)
-		w.WriteMsg(msg)
-		return
-	}
-
-	msg, err := s.r.Exchange(r)
-
-	if err != nil {
-		if len(r.Question) > 0 {
-			q := r.Question[0]
-			qString := fmt.Sprintf("%s %s %s", q.Name, D.Class(q.Qclass).String(), D.Type(q.Qtype).String())
-			log.Debugln("[DNS Server] Exchange %s failed: %v", qString, err)
-		}
 		D.HandleFailed(w, r)
 		return
 	}
-	msg.SetReply(r)
+
-	w.WriteMsg(msg)
+	s.handler(w, r)
 }
 
-func (s *Server) handleFakeIP(r *D.Msg) (msg *D.Msg, err error) {
+func (s *Server) setHandler(handler handler) {
-	if len(r.Question) == 0 {
+	s.handler = handler
-		err = errors.New("should have one question at least")
-		return
-	}
-
-	q := r.Question[0]
-
-	cache := s.r.cache.Get("fakeip:" + q.String())
-	if cache != nil {
-		msg = cache.(*D.Msg).Copy()
-		setMsgTTL(msg, 1)
-		return
-	}
-
-	var ip net.IP
-	defer func() {
-		if msg == nil {
-			return
-		}
-
-		putMsgToCache(s.r.cache, "fakeip:"+q.String(), msg)
-		putMsgToCache(s.r.cache, ip.String(), msg)
-
-		setMsgTTL(msg, 1)
-	}()
-
-	rr := &D.A{}
-	rr.Hdr = dns.RR_Header{Name: r.Question[0].Name, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: dnsDefaultTTL}
-	ip = s.r.pool.Get()
-	rr.A = ip
-	msg = r.Copy()
-	msg.Answer = []D.RR{rr}
-	return
-}
-
-func (s *Server) setReslover(r *Resolver) {
-	s.r = r
 }
 
 func ReCreateServer(addr string, resolver *Resolver) error {
-	if addr == address {
+	if addr == address && resolver != nil {
-		server.setReslover(resolver)
+		handler := newHandler(resolver)
+		server.setHandler(handler)
 		return nil
 	}
 
@@ -116,7 +59,8 @@ func ReCreateServer(addr string, resolver *Resolver) error {
 	}
 
 	address = addr
-	server = &Server{r: resolver}
+	handler := newHandler(resolver)
+	server = &Server{handler: handler}
 	server.Server = &D.Server{Addr: addr, PacketConn: p, Handler: server}
 
 	go func() {

dns/util.go

@@ -4,11 +4,11 @@ import (
 	"crypto/tls"
 	"encoding/json"
 	"errors"
+	"net"
 	"time"
 
 	"github.com/Dreamacro/clash/common/cache"
 	"github.com/Dreamacro/clash/log"
-	yaml "gopkg.in/yaml.v2"
 
 	D "github.com/miekg/dns"
 )
@@ -45,8 +45,8 @@ func (e *EnhancedMode) UnmarshalYAML(unmarshal func(interface{}) error) error {
 }
 
 // MarshalYAML serialize EnhancedMode with yaml
-func (e EnhancedMode) MarshalYAML() ([]byte, error) {
+func (e EnhancedMode) MarshalYAML() (interface{}, error) {
-	return yaml.Marshal(e.String())
+	return e.String(), nil
 }
 
 // UnmarshalJSON unserialize EnhancedMode with json
@@ -81,13 +81,14 @@ func (e EnhancedMode) String() string {
 
 func putMsgToCache(c *cache.Cache, key string, msg *D.Msg) {
 	var ttl time.Duration
-	if len(msg.Answer) != 0 {
+	switch {
+	case len(msg.Answer) != 0:
 		ttl = time.Duration(msg.Answer[0].Header().Ttl) * time.Second
-	} else if len(msg.Ns) != 0 {
+	case len(msg.Ns) != 0:
 		ttl = time.Duration(msg.Ns[0].Header().Ttl) * time.Second
-	} else if len(msg.Extra) != 0 {
+	case len(msg.Extra) != 0:
 		ttl = time.Duration(msg.Extra[0].Header().Ttl) * time.Second
-	} else {
+	default:
 		log.Debugln("[DNS] response msg error: %#v", msg)
 		return
 	}
@@ -116,14 +117,15 @@ func isIPRequest(q D.Question) bool {
 	return false
 }
 
-func transform(servers []NameServer) []resolver {
+func transform(servers []NameServer, resolver *Resolver) []dnsClient {
-	ret := []resolver{}
+	ret := []dnsClient{}
 	for _, s := range servers {
 		if s.Net == "https" {
-			ret = append(ret, &dohClient{url: s.Addr})
+			ret = append(ret, newDoHClient(s.Addr, resolver))
 			continue
 		}
 
+		host, port, _ := net.SplitHostPort(s.Addr)
 		ret = append(ret, &client{
 			Client: &D.Client{
 				Net: s.Net,
@@ -133,8 +135,11 @@ func transform(servers []NameServer) []resolver {
 					NextProtos: []string{"dns"},
 				},
 				UDPSize: 4096,
+				Timeout: 5 * time.Second,
 			},
-			Address: s.Addr,
+			port: port,
+			host: host,
+			r:    resolver,
 		})
 	}
 	return ret

go.mod

@@ -1,20 +1,22 @@
 module github.com/Dreamacro/clash
 
+go 1.14
+
 require (
-	github.com/Dreamacro/go-shadowsocks2 v0.1.3
+	github.com/Dreamacro/go-shadowsocks2 v0.1.5
 	github.com/eapache/queue v1.1.0 // indirect
-	github.com/go-chi/chi v4.0.2+incompatible
+	github.com/go-chi/chi v4.0.3+incompatible
 	github.com/go-chi/cors v1.0.0
 	github.com/go-chi/render v1.0.1
 	github.com/gofrs/uuid v3.2.0+incompatible
-	github.com/gorilla/websocket v1.4.0
+	github.com/gorilla/websocket v1.4.1
-	github.com/miekg/dns v1.1.14
+	github.com/miekg/dns v1.1.27
-	github.com/oschwald/geoip2-golang v1.3.0
+	github.com/oschwald/geoip2-golang v1.4.0
-	github.com/oschwald/maxminddb-golang v1.3.1 // indirect
 	github.com/sirupsen/logrus v1.4.2
-	golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734
+	github.com/stretchr/testify v1.5.1
-	golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3
+	golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073
-	golang.org/x/sync v0.0.0-20190423024810-112230192c58 // indirect
+	golang.org/x/net v0.0.0-20200301022130-244492dfa37a
+	golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e
 	gopkg.in/eapache/channels.v1 v1.1.0
-	gopkg.in/yaml.v2 v2.2.2
+	gopkg.in/yaml.v2 v2.2.8
 )

go.sum

@@ -1,52 +1,76 @@
-github.com/Dreamacro/go-shadowsocks2 v0.1.3 h1:1ffY/q4e3o+MnztYgIq1iZiX1BWoWQ6D3AIO1kkb8bc=
+github.com/Dreamacro/go-shadowsocks2 v0.1.5 h1:BizWSjmwzAyQoslz6YhJYMiAGT99j9cnm9zlxVr+kyI=
-github.com/Dreamacro/go-shadowsocks2 v0.1.3/go.mod h1:0x17IhQ+mlY6q/ffKRpzaE7u4aHMxxnitTRSrV5G6TU=
+github.com/Dreamacro/go-shadowsocks2 v0.1.5/go.mod h1:LSXCjyHesPY3pLjhwff1mQX72ItcBT/N2xNC685cYeU=
-github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da h1:KjTM2ks9d14ZYCvmHS9iAKVt9AyzRSqNU1qabPih5BY=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da/go.mod h1:eHEWzANqSiWQsof+nXEI9bUVUyV6F53Fp89EuCh2EAA=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/eapache/queue v1.1.0 h1:YOEu7KNc61ntiQlcEeUIoDTJ2o8mQznoNvUhiigpIqc=
 github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I=
-github.com/go-chi/chi v4.0.2+incompatible h1:maB6vn6FqCxrpz4FqWdh4+lwpyZIQS7YEAUcHlgXVRs=
+github.com/go-chi/chi v4.0.3+incompatible h1:gakN3pDJnzZN5jqFV2TEdF66rTfKeITyR8qu6ekICEY=
-github.com/go-chi/chi v4.0.2+incompatible/go.mod h1:eB3wogJHnLi3x/kFX2A+IbTBlXxmMeXJVKy9tTv1XzQ=
+github.com/go-chi/chi v4.0.3+incompatible/go.mod h1:eB3wogJHnLi3x/kFX2A+IbTBlXxmMeXJVKy9tTv1XzQ=
 github.com/go-chi/cors v1.0.0 h1:e6x8k7uWbUwYs+aXDoiUzeQFT6l0cygBYyNhD7/1Tg0=
 github.com/go-chi/cors v1.0.0/go.mod h1:K2Yje0VW/SJzxiyMYu6iPQYa7hMjQX2i/F491VChg1I=
 github.com/go-chi/render v1.0.1 h1:4/5tis2cKaNdnv9zFLfXzcquC9HbeZgCnxGnKrltBS8=
 github.com/go-chi/render v1.0.1/go.mod h1:pq4Rr7HbnsdaeHagklXub+p6Wd16Af5l9koip1OvJns=
 github.com/gofrs/uuid v3.2.0+incompatible h1:y12jRkkFxsd7GpqdSZ+/KCs/fJbqpEXSGd4+jfEaewE=
 github.com/gofrs/uuid v3.2.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
-github.com/gorilla/websocket v1.4.0 h1:WDFjx/TMzVgy9VdMMQi2K2Emtwi2QcUQsztZ/zLaH/Q=
+github.com/gorilla/websocket v1.4.1 h1:q7AeDBpnBk8AogcD4DSag/Ukw/KV+YhzLj2bP5HvKCM=
-github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/miekg/dns v1.1.14 h1:wkQWn9wIp4mZbwW8XV6Km6owkvRPbOiV004ZM2CkGvA=
+github.com/miekg/dns v1.1.27 h1:aEH/kqUzUxGJ/UHcEKdJY+ugH6WEzsEBBSPa8zuy1aM=
-github.com/miekg/dns v1.1.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
+github.com/miekg/dns v1.1.27/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
-github.com/oschwald/geoip2-golang v1.3.0 h1:D+Hsdos1NARPbzZ2aInUHZL+dApIzo8E0ErJVsWcku8=
+github.com/oschwald/geoip2-golang v1.4.0 h1:5RlrjCgRyIGDz/mBmPfnAF4h8k0IAcRv9PvrpOfz+Ug=
-github.com/oschwald/geoip2-golang v1.3.0/go.mod h1:0LTTzix/Ao1uMvOhAV4iLU0Lz7eCrP94qZWBTDKf0iE=
+github.com/oschwald/geoip2-golang v1.4.0/go.mod h1:8QwxJvRImBH+Zl6Aa6MaIcs5YdlZSTKtzmPGzQqi9ng=
-github.com/oschwald/maxminddb-golang v1.3.1 h1:kPc5+ieL5CC/Zn0IaXJPxDFlUxKTQEU8QBTtmfQDAIo=
+github.com/oschwald/maxminddb-golang v1.6.0 h1:KAJSjdHQ8Kv45nFIbtoLGrGWqHFajOIm7skTyz/+Dls=
-github.com/oschwald/maxminddb-golang v1.3.1/go.mod h1:3jhIUymTJ5VREKyIhWm66LJiQt04F0UCDdodShpjWsY=
+github.com/oschwald/maxminddb-golang v1.6.0/go.mod h1:DUJFucBg2cvqx42YmDa/+xHvb0elJtOm3o4aFQ/nb/w=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/sirupsen/logrus v1.4.2 h1:SPIRibHv4MatM3XXNO2BJeFLZwZ2LvZgfQ5+UNI2im4=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1 h1:2vfRuCMp5sSVIDSqO8oNnWJq7mPa6KVP3iPIwFBuy8A=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734 h1:p/H982KKEjUnLJkM3tt/LemDnOc1GiZL5FCVlORJ5zo=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20191206172530-e9b2fee46413 h1:ULYEB3JvPRE/IfO+9uO7vKV/xzVTO7XPAwm8xbf4w2g=
+golang.org/x/crypto v0.0.0-20191206172530-e9b2fee46413/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073 h1:xMPOj6Pz6UipU1wXLkrtqpHbR0AVFnyPEQq/wRWz9lM=
+golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3 h1:0GoQqolDA55aaLxZyTzK/Y2ePZzZTUrRacwib7cNsYQ=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190923162816-aa69164e4478 h1:l5EDrHhldLYb3ZRHDUhXF7Om7MvYXnkV9/iQNo1lX6g=
+golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200301022130-244492dfa37a h1:GuSPYbZzB5/dcLNCwLQLsg3obCJtX9IJhpXkvY7kzk0=
+golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58 h1:8gQV6CLnAEikrhgkHFbMAEhagSSnXWGV915qUMm9mrU=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e h1:vcxGaoTs7kV8m5Np9uUNQin4BrLOthgV7252N8V+FwY=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d h1:+R4KGOnez64A81RvjARKc4UT5/tI9ujCIVX+P5KiHuI=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190422165155-953cdadca894 h1:Cz4ceDQGXuKRnVBDTS23GTn/pU5OE2C0WrNTOYK1Uuc=
 golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe h1:6fAMxZRR6sl1Uq8U61gxU+kPTs2tR8uOySCbBP7BN/M=
+golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191224085550-c709ea063b76 h1:Dho5nD6R3PcW2SH1or8vS0dszDaXRxIw55lBX7XiE5g=
+golang.org/x/sys v0.0.0-20191224085550-c709ea063b76/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/tools v0.0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/eapache/channels.v1 v1.1.0 h1:5bGAyKKvyCTWjSj7mhefG6Lc68VyN4MH1v8/7OoeeB4=
 gopkg.in/eapache/channels.v1 v1.1.0/go.mod h1:BHIBujSvu9yMTrTYbTCjDD43gUhtmaOtTWDe7sTv1js=
 gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

hooks/pre_build

@@ -0,0 +1,4 @@
+#!/bin/bash
+# Register qemu-*-static for all supported processors except the
+# current one, but also remove all registered binfmt_misc before
+docker run --rm --privileged multiarch/qemu-user-static:register --reset --credential yes

hub/executor/executor.go

@@ -1,16 +1,60 @@
 package executor
 
 import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"github.com/Dreamacro/clash/adapters/provider"
 	"github.com/Dreamacro/clash/component/auth"
+	"github.com/Dreamacro/clash/component/dialer"
+	trie "github.com/Dreamacro/clash/component/domain-trie"
+	"github.com/Dreamacro/clash/component/resolver"
 	"github.com/Dreamacro/clash/config"
 	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/dns"
 	"github.com/Dreamacro/clash/log"
 	P "github.com/Dreamacro/clash/proxy"
 	authStore "github.com/Dreamacro/clash/proxy/auth"
-	T "github.com/Dreamacro/clash/tunnel"
+	"github.com/Dreamacro/clash/tunnel"
 )
 
+// forward compatibility before 1.0
+func readRawConfig(path string) ([]byte, error) {
+	data, err := ioutil.ReadFile(path)
+	if err == nil && len(data) != 0 {
+		return data, nil
+	}
+
+	if filepath.Ext(path) != ".yaml" {
+		return nil, err
+	}
+
+	path = path[:len(path)-5] + ".yml"
+	if _, fallbackErr := os.Stat(path); fallbackErr == nil {
+		return ioutil.ReadFile(path)
+	}
+
+	return data, err
+}
+
+func readConfig(path string) ([]byte, error) {
+	if _, err := os.Stat(path); os.IsNotExist(err) {
+		return nil, err
+	}
+	data, err := readRawConfig(path)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(data) == 0 {
+		return nil, fmt.Errorf("Configuration file %s is empty", path)
+	}
+
+	return data, err
+}
+
 // Parse config with default config path
 func Parse() (*config.Config, error) {
 	return ParseWithPath(C.Path.Config())
@@ -18,7 +62,17 @@ func Parse() (*config.Config, error) {
 
 // ParseWithPath parse config with custom config path
 func ParseWithPath(path string) (*config.Config, error) {
-	return config.Parse(path)
+	buf, err := readConfig(path)
+	if err != nil {
+		return nil, err
+	}
+
+	return ParseWithBytes(buf)
+}
+
+// ParseWithBytes config with buffer
+func ParseWithBytes(buf []byte) (*config.Config, error) {
+	return config.Parse(buf)
 }
 
 // ApplyConfig dispatch configure to all parts
@@ -27,10 +81,11 @@ func ApplyConfig(cfg *config.Config, force bool) {
 	if force {
 		updateGeneral(cfg.General)
 	}
-	updateProxies(cfg.Proxies)
+	updateProxies(cfg.Proxies, cfg.Providers)
 	updateRules(cfg.Rules)
 	updateDNS(cfg.DNS)
-	updateExperimental(cfg.Experimental)
+	updateHosts(cfg.Hosts)
+	updateExperimental(cfg)
 }
 
 func GetGeneral() *config.General {
@@ -46,20 +101,31 @@ func GetGeneral() *config.General {
 		RedirPort:      ports.RedirPort,
 		Authentication: authenticator,
 		AllowLan:       P.AllowLan(),
-		Mode:           T.Instance().Mode(),
+		BindAddress:    P.BindAddress(),
+		Mode:           tunnel.Mode(),
 		LogLevel:       log.Level(),
 	}
 
 	return general
 }
 
-func updateExperimental(c *config.Experimental) {
+func updateExperimental(c *config.Config) {
-	T.Instance().UpdateExperimental(c.IgnoreResolveFail)
+	cfg := c.Experimental
+
+	tunnel.UpdateExperimental(cfg.IgnoreResolveFail)
+	if cfg.Interface != "" && c.DNS.Enable {
+		dialer.DialHook = dialer.DialerWithInterface(cfg.Interface)
+		dialer.ListenPacketHook = dialer.ListenPacketWithInterface(cfg.Interface)
+	} else {
+		dialer.DialHook = nil
+		dialer.ListenPacketHook = nil
+	}
 }
 
 func updateDNS(c *config.DNS) {
 	if c.Enable == false {
-		dns.DefaultResolver = nil
+		resolver.DefaultResolver = nil
+		tunnel.SetResolver(nil)
 		dns.ReCreateServer("", nil)
 		return
 	}
@@ -69,8 +135,14 @@ func updateDNS(c *config.DNS) {
 		IPv6:         c.IPv6,
 		EnhancedMode: c.EnhancedMode,
 		Pool:         c.FakeIPRange,
+		FallbackFilter: dns.FallbackFilter{
+			GeoIP:  c.FallbackFilter.GeoIP,
+			IPCIDR: c.FallbackFilter.IPCIDR,
+		},
+		Default: c.DefaultNameserver,
 	})
-	dns.DefaultResolver = r
+	resolver.DefaultResolver = r
+	tunnel.SetResolver(r)
 	if err := dns.ReCreateServer(c.Listen, r); err != nil {
 		log.Errorln("Start DNS server error: %s", err.Error())
 		return
@@ -81,30 +153,35 @@ func updateDNS(c *config.DNS) {
 	}
 }
 
-func updateProxies(proxies map[string]C.Proxy) {
+func updateHosts(tree *trie.Trie) {
-	tunnel := T.Instance()
+	resolver.DefaultHosts = tree
-	oldProxies := tunnel.Proxies()
+}
 
-	// close proxy group goroutine
+func updateProxies(proxies map[string]C.Proxy, providers map[string]provider.ProxyProvider) {
-	for _, proxy := range oldProxies {
+	oldProviders := tunnel.Providers()
-		proxy.Destroy()
+
+	// close providers goroutine
+	for _, provider := range oldProviders {
+		provider.Destroy()
 	}
 
-	tunnel.UpdateProxies(proxies)
+	tunnel.UpdateProxies(proxies, providers)
 }
 
 func updateRules(rules []C.Rule) {
-	T.Instance().UpdateRules(rules)
+	tunnel.UpdateRules(rules)
 }
 
 func updateGeneral(general *config.General) {
 	log.SetLevel(general.LogLevel)
-	T.Instance().SetMode(general.Mode)
+	tunnel.SetMode(general.Mode)
 
 	allowLan := general.AllowLan
-
 	P.SetAllowLan(allowLan)
 
+	bindAddress := general.BindAddress
+	P.SetBindAddress(bindAddress)
+
 	if err := P.ReCreateHTTP(general.Port); err != nil {
 		log.Errorln("Start HTTP server error: %s", err.Error())
 	}

hub/route/common.go

@@ -0,0 +1,17 @@
+package route
+
+import (
+	"net/http"
+	"net/url"
+
+	"github.com/go-chi/chi"
+)
+
+// When name is composed of a partial escape string, Golang does not unescape it
+func getEscapeParam(r *http.Request, paramName string) string {
+	param := chi.URLParam(r, paramName)
+	if newParam, err := url.PathUnescape(param); err == nil {
+		param = newParam
+	}
+	return param
+}

hub/route/configs.go

@@ -4,10 +4,11 @@ import (
 	"net/http"
 	"path/filepath"
 
+	"github.com/Dreamacro/clash/config"
 	"github.com/Dreamacro/clash/hub/executor"
 	"github.com/Dreamacro/clash/log"
 	P "github.com/Dreamacro/clash/proxy"
-	T "github.com/Dreamacro/clash/tunnel"
+	"github.com/Dreamacro/clash/tunnel"
 
 	"github.com/go-chi/chi"
 	"github.com/go-chi/render"
@@ -22,12 +23,13 @@ func configRouter() http.Handler {
 }
 
 type configSchema struct {
-	Port      *int          `json:"port"`
+	Port        *int               `json:"port"`
-	SocksPort *int          `json:"socks-port"`
+	SocksPort   *int               `json:"socks-port"`
-	RedirPort *int          `json:"redir-port"`
+	RedirPort   *int               `json:"redir-port"`
-	AllowLan  *bool         `json:"allow-lan"`
+	AllowLan    *bool              `json:"allow-lan"`
-	Mode      *T.Mode       `json:"mode"`
+	BindAddress *string            `json:"bind-address"`
-	LogLevel  *log.LogLevel `json:"log-level"`
+	Mode        *tunnel.TunnelMode `json:"mode"`
+	LogLevel    *log.LogLevel      `json:"log-level"`
 }
 
 func getConfigs(w http.ResponseWriter, r *http.Request) {
@@ -55,13 +57,17 @@ func patchConfigs(w http.ResponseWriter, r *http.Request) {
 		P.SetAllowLan(*general.AllowLan)
 	}
 
+	if general.BindAddress != nil {
+		P.SetBindAddress(*general.BindAddress)
+	}
+
 	ports := P.GetPorts()
 	P.ReCreateHTTP(pointerOrDefault(general.Port, ports.Port))
 	P.ReCreateSocks(pointerOrDefault(general.SocksPort, ports.SocksPort))
 	P.ReCreateRedir(pointerOrDefault(general.RedirPort, ports.RedirPort))
 
 	if general.Mode != nil {
-		T.Instance().SetMode(*general.Mode)
+		tunnel.SetMode(*general.Mode)
 	}
 
 	if general.LogLevel != nil {
@@ -72,7 +78,8 @@ func patchConfigs(w http.ResponseWriter, r *http.Request) {
 }
 
 type updateConfigRequest struct {
-	Path string `json:"path"`
+	Path    string `json:"path"`
+	Payload string `json:"payload"`
 }
 
 func updateConfigs(w http.ResponseWriter, r *http.Request) {
@@ -83,18 +90,30 @@ func updateConfigs(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	if !filepath.IsAbs(req.Path) {
-		render.Status(r, http.StatusBadRequest)
-		render.JSON(w, r, newError("path is not a absoluted path"))
-		return
-	}
-
 	force := r.URL.Query().Get("force") == "true"
-	cfg, err := executor.ParseWithPath(req.Path)
+	var cfg *config.Config
-	if err != nil {
+	var err error
-		render.Status(r, http.StatusBadRequest)
+
-		render.JSON(w, r, newError(err.Error()))
+	if req.Payload != "" {
-		return
+		cfg, err = executor.ParseWithBytes([]byte(req.Payload))
+		if err != nil {
+			render.Status(r, http.StatusBadRequest)
+			render.JSON(w, r, newError(err.Error()))
+			return
+		}
+	} else {
+		if !filepath.IsAbs(req.Path) {
+			render.Status(r, http.StatusBadRequest)
+			render.JSON(w, r, newError("path is not a absoluted path"))
+			return
+		}
+
+		cfg, err = executor.ParseWithPath(req.Path)
+		if err != nil {
+			render.Status(r, http.StatusBadRequest)
+			render.JSON(w, r, newError(err.Error()))
+			return
+		}
 	}
 
 	executor.ApplyConfig(cfg, force)

hub/route/connections.go

@@ -0,0 +1,91 @@
+package route
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"strconv"
+	"time"
+
+	T "github.com/Dreamacro/clash/tunnel"
+	"github.com/gorilla/websocket"
+
+	"github.com/go-chi/chi"
+	"github.com/go-chi/render"
+)
+
+func connectionRouter() http.Handler {
+	r := chi.NewRouter()
+	r.Get("/", getConnections)
+	r.Delete("/", closeAllConnections)
+	r.Delete("/{id}", closeConnection)
+	return r
+}
+
+func getConnections(w http.ResponseWriter, r *http.Request) {
+	if !websocket.IsWebSocketUpgrade(r) {
+		snapshot := T.DefaultManager.Snapshot()
+		render.JSON(w, r, snapshot)
+		return
+	}
+
+	conn, err := upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		return
+	}
+
+	intervalStr := r.URL.Query().Get("interval")
+	interval := 1000
+	if intervalStr != "" {
+		t, err := strconv.Atoi(intervalStr)
+		if err != nil {
+			render.Status(r, http.StatusBadRequest)
+			render.JSON(w, r, ErrBadRequest)
+			return
+		}
+
+		interval = t
+	}
+
+	buf := &bytes.Buffer{}
+	sendSnapshot := func() error {
+		buf.Reset()
+		snapshot := T.DefaultManager.Snapshot()
+		if err := json.NewEncoder(buf).Encode(snapshot); err != nil {
+			return err
+		}
+
+		return conn.WriteMessage(websocket.TextMessage, buf.Bytes())
+	}
+
+	if err := sendSnapshot(); err != nil {
+		return
+	}
+
+	tick := time.NewTicker(time.Millisecond * time.Duration(interval))
+	for range tick.C {
+		if err := sendSnapshot(); err != nil {
+			break
+		}
+	}
+}
+
+func closeConnection(w http.ResponseWriter, r *http.Request) {
+	id := chi.URLParam(r, "id")
+	snapshot := T.DefaultManager.Snapshot()
+	for _, c := range snapshot.Connections {
+		if id == c.ID() {
+			c.Close()
+			break
+		}
+	}
+	render.NoContent(w, r)
+}
+
+func closeAllConnections(w http.ResponseWriter, r *http.Request) {
+	snapshot := T.DefaultManager.Snapshot()
+	for _, c := range snapshot.Connections {
+		c.Close()
+	}
+	render.NoContent(w, r)
+}

hub/route/ctxkeys.go

@@ -1,8 +1,10 @@
 package route
 
 var (
-	CtxKeyProxyName = contextKey("proxy name")
+	CtxKeyProxyName    = contextKey("proxy name")
-	CtxKeyProxy     = contextKey("proxy")
+	CtxKeyProviderName = contextKey("provider name")
+	CtxKeyProxy        = contextKey("proxy")
+	CtxKeyProvider     = contextKey("provider")
 )
 
 type contextKey string

hub/route/provider.go

@@ -0,0 +1,77 @@
+package route
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/Dreamacro/clash/adapters/provider"
+	"github.com/Dreamacro/clash/tunnel"
+
+	"github.com/go-chi/chi"
+	"github.com/go-chi/render"
+)
+
+func proxyProviderRouter() http.Handler {
+	r := chi.NewRouter()
+	r.Get("/", getProviders)
+
+	r.Route("/{name}", func(r chi.Router) {
+		r.Use(parseProviderName, findProviderByName)
+		r.Get("/", getProvider)
+		r.Put("/", updateProvider)
+		r.Get("/healthcheck", healthCheckProvider)
+	})
+	return r
+}
+
+func getProviders(w http.ResponseWriter, r *http.Request) {
+	providers := tunnel.Providers()
+	render.JSON(w, r, render.M{
+		"providers": providers,
+	})
+}
+
+func getProvider(w http.ResponseWriter, r *http.Request) {
+	provider := r.Context().Value(CtxKeyProvider).(provider.ProxyProvider)
+	render.JSON(w, r, provider)
+}
+
+func updateProvider(w http.ResponseWriter, r *http.Request) {
+	provider := r.Context().Value(CtxKeyProvider).(provider.ProxyProvider)
+	if err := provider.Update(); err != nil {
+		render.Status(r, http.StatusServiceUnavailable)
+		render.JSON(w, r, newError(err.Error()))
+		return
+	}
+	render.NoContent(w, r)
+}
+
+func healthCheckProvider(w http.ResponseWriter, r *http.Request) {
+	provider := r.Context().Value(CtxKeyProvider).(provider.ProxyProvider)
+	provider.HealthCheck()
+	render.NoContent(w, r)
+}
+
+func parseProviderName(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		name := getEscapeParam(r, "name")
+		ctx := context.WithValue(r.Context(), CtxKeyProviderName, name)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
+
+func findProviderByName(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		name := r.Context().Value(CtxKeyProviderName).(string)
+		providers := tunnel.Providers()
+		provider, exist := providers[name]
+		if !exist {
+			render.Status(r, http.StatusNotFound)
+			render.JSON(w, r, ErrNotFound)
+			return
+		}
+
+		ctx := context.WithValue(r.Context(), CtxKeyProvider, provider)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}

hub/route/proxies.go

@@ -4,13 +4,13 @@ import (
 	"context"
 	"fmt"
 	"net/http"
-	"net/url"
 	"strconv"
 	"time"
 
-	A "github.com/Dreamacro/clash/adapters/outbound"
+	"github.com/Dreamacro/clash/adapters/outbound"
+	"github.com/Dreamacro/clash/adapters/outboundgroup"
 	C "github.com/Dreamacro/clash/constant"
-	T "github.com/Dreamacro/clash/tunnel"
+	"github.com/Dreamacro/clash/tunnel"
 
 	"github.com/go-chi/chi"
 	"github.com/go-chi/render"
@@ -29,13 +29,9 @@ func proxyRouter() http.Handler {
 	return r
 }
 
-// When name is composed of a partial escape string, Golang does not unescape it
 func parseProxyName(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		name := chi.URLParam(r, "name")
+		name := getEscapeParam(r, "name")
-		if newName, err := url.PathUnescape(name); err == nil {
-			name = newName
-		}
 		ctx := context.WithValue(r.Context(), CtxKeyProxyName, name)
 		next.ServeHTTP(w, r.WithContext(ctx))
 	})
@@ -44,7 +40,7 @@ func parseProxyName(next http.Handler) http.Handler {
 func findProxyByName(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		name := r.Context().Value(CtxKeyProxyName).(string)
-		proxies := T.Instance().Proxies()
+		proxies := tunnel.Proxies()
 		proxy, exist := proxies[name]
 		if !exist {
 			render.Status(r, http.StatusNotFound)
@@ -58,7 +54,7 @@ func findProxyByName(next http.Handler) http.Handler {
 }
 
 func getProxies(w http.ResponseWriter, r *http.Request) {
-	proxies := T.Instance().Proxies()
+	proxies := tunnel.Proxies()
 	render.JSON(w, r, render.M{
 		"proxies": proxies,
 	})
@@ -81,8 +77,8 @@ func updateProxy(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	proxy := r.Context().Value(CtxKeyProxy).(*A.Proxy)
+	proxy := r.Context().Value(CtxKeyProxy).(*outbound.Proxy)
-	selector, ok := proxy.ProxyAdapter.(*A.Selector)
+	selector, ok := proxy.ProxyAdapter.(*outboundgroup.Selector)
 	if !ok {
 		render.Status(r, http.StatusBadRequest)
 		render.JSON(w, r, newError("Must be a Selector"))
@@ -110,27 +106,23 @@ func getProxyDelay(w http.ResponseWriter, r *http.Request) {
 
 	proxy := r.Context().Value(CtxKeyProxy).(C.Proxy)
 
-	sigCh := make(chan uint16)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout))
-	go func() {
+	defer cancel()
-		t, err := proxy.URLTest(url)
-		if err != nil {
-			sigCh <- 0
-		}
-		sigCh <- t
-	}()
 
-	select {
+	delay, err := proxy.URLTest(ctx, url)
-	case <-time.After(time.Millisecond * time.Duration(timeout)):
+	if ctx.Err() != nil {
-		render.Status(r, http.StatusRequestTimeout)
+		render.Status(r, http.StatusGatewayTimeout)
 		render.JSON(w, r, ErrRequestTimeout)
-	case t := <-sigCh:
+		return
-		if t == 0 {
-			render.Status(r, http.StatusServiceUnavailable)
-			render.JSON(w, r, newError("An error occurred in the delay test"))
-		} else {
-			render.JSON(w, r, render.M{
-				"delay": t,
-			})
-		}
 	}
+
+	if err != nil || delay == 0 {
+		render.Status(r, http.StatusServiceUnavailable)
+		render.JSON(w, r, newError("An error occurred in the delay test"))
+		return
+	}
+
+	render.JSON(w, r, render.M{
+		"delay": delay,
+	})
 }

hub/route/rules.go

@@ -3,7 +3,7 @@ package route
 import (
 	"net/http"
 
-	T "github.com/Dreamacro/clash/tunnel"
+	"github.com/Dreamacro/clash/tunnel"
 
 	"github.com/go-chi/chi"
 	"github.com/go-chi/render"
@@ -22,7 +22,7 @@ type Rule struct {
 }
 
 func getRules(w http.ResponseWriter, r *http.Request) {
-	rawRules := T.Instance().Rules()
+	rawRules := tunnel.Rules()
 
 	rules := []Rule{}
 	for _, rule := range rawRules {

hub/route/server.go

@@ -1,17 +1,20 @@
 package route
 
 import (
+	"bytes"
 	"encoding/json"
 	"net/http"
 	"strings"
 	"time"
 
+	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/log"
 	T "github.com/Dreamacro/clash/tunnel"
 
 	"github.com/go-chi/chi"
 	"github.com/go-chi/cors"
 	"github.com/go-chi/render"
+	"github.com/gorilla/websocket"
 )
 
 var (
@@ -19,6 +22,12 @@ var (
 	serverAddr   = ""
 
 	uiPath = ""
+
+	upgrader = websocket.Upgrader{
+		CheckOrigin: func(r *http.Request) bool {
+			return true
+		},
+	}
 )
 
 type Traffic struct {
@@ -47,24 +56,25 @@ func Start(addr string, secret string) {
 		MaxAge:         300,
 	})
 
-	root := chi.NewRouter().With(jsonContentType)
+	r.Use(cors.Handler)
-	root.Get("/traffic", traffic)
-	root.Get("/logs", getLogs)
-
-	r.Get("/", hello)
 	r.Group(func(r chi.Router) {
-		r.Use(cors.Handler, authentication)
+		r.Use(authentication)
 
-		r.Mount("/", root)
+		r.Get("/", hello)
+		r.Get("/logs", getLogs)
+		r.Get("/traffic", traffic)
+		r.Get("/version", version)
 		r.Mount("/configs", configRouter())
 		r.Mount("/proxies", proxyRouter())
 		r.Mount("/rules", ruleRouter())
+		r.Mount("/connections", connectionRouter())
+		r.Mount("/providers/proxies", proxyProviderRouter())
 	})
 
 	if uiPath != "" {
 		r.Group(func(r chi.Router) {
 			fs := http.StripPrefix("/ui", http.FileServer(http.Dir(uiPath)))
-			r.Get("/ui", http.RedirectHandler("/ui/", 301).ServeHTTP)
+			r.Get("/ui", http.RedirectHandler("/ui/", http.StatusTemporaryRedirect).ServeHTTP)
 			r.Get("/ui/*", func(w http.ResponseWriter, r *http.Request) {
 				fs.ServeHTTP(w, r)
 			})
@@ -78,24 +88,28 @@ func Start(addr string, secret string) {
 	}
 }
 
-func jsonContentType(next http.Handler) http.Handler {
-	fn := func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		next.ServeHTTP(w, r)
-	}
-	return http.HandlerFunc(fn)
-}
-
 func authentication(next http.Handler) http.Handler {
 	fn := func(w http.ResponseWriter, r *http.Request) {
-		header := r.Header.Get("Authorization")
-		text := strings.SplitN(header, " ", 2)
-
 		if serverSecret == "" {
 			next.ServeHTTP(w, r)
 			return
 		}
 
+		// Browser websocket not support custom header
+		if websocket.IsWebSocketUpgrade(r) && r.URL.Query().Get("token") != "" {
+			token := r.URL.Query().Get("token")
+			if token != serverSecret {
+				render.Status(r, http.StatusUnauthorized)
+				render.JSON(w, r, ErrUnauthorized)
+				return
+			}
+			next.ServeHTTP(w, r)
+			return
+		}
+
+		header := r.Header.Get("Authorization")
+		text := strings.SplitN(header, " ", 2)
+
 		hasUnvalidHeader := text[0] != "Bearer"
 		hasUnvalidSecret := len(text) == 2 && text[1] != serverSecret
 		if hasUnvalidHeader || hasUnvalidSecret {
@@ -113,19 +127,44 @@ func hello(w http.ResponseWriter, r *http.Request) {
 }
 
 func traffic(w http.ResponseWriter, r *http.Request) {
-	render.Status(r, http.StatusOK)
+	var wsConn *websocket.Conn
+	if websocket.IsWebSocketUpgrade(r) {
+		var err error
+		wsConn, err = upgrader.Upgrade(w, r, nil)
+		if err != nil {
+			return
+		}
+	}
+
+	if wsConn == nil {
+		w.Header().Set("Content-Type", "application/json")
+		render.Status(r, http.StatusOK)
+	}
 
 	tick := time.NewTicker(time.Second)
-	t := T.Instance().Traffic()
+	t := T.DefaultManager
+	buf := &bytes.Buffer{}
+	var err error
 	for range tick.C {
+		buf.Reset()
 		up, down := t.Now()
-		if err := json.NewEncoder(w).Encode(Traffic{
+		if err := json.NewEncoder(buf).Encode(Traffic{
 			Up:   up,
 			Down: down,
 		}); err != nil {
 			break
 		}
-		w.(http.Flusher).Flush()
+
+		if wsConn == nil {
+			_, err = w.Write(buf.Bytes())
+			w.(http.Flusher).Flush()
+		} else {
+			err = wsConn.WriteMessage(websocket.TextMessage, buf.Bytes())
+		}
+
+		if err != nil {
+			break
+		}
 	}
 }
 
@@ -147,20 +186,51 @@ func getLogs(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	var wsConn *websocket.Conn
+	if websocket.IsWebSocketUpgrade(r) {
+		var err error
+		wsConn, err = upgrader.Upgrade(w, r, nil)
+		if err != nil {
+			return
+		}
+	}
+
+	if wsConn == nil {
+		w.Header().Set("Content-Type", "application/json")
+		render.Status(r, http.StatusOK)
+	}
+
 	sub := log.Subscribe()
-	render.Status(r, http.StatusOK)
+	defer log.UnSubscribe(sub)
+	buf := &bytes.Buffer{}
+	var err error
 	for elm := range sub {
+		buf.Reset()
 		log := elm.(*log.Event)
 		if log.LogLevel < level {
 			continue
 		}
 
-		if err := json.NewEncoder(w).Encode(Log{
+		if err := json.NewEncoder(buf).Encode(Log{
 			Type:    log.Type(),
 			Payload: log.Payload,
 		}); err != nil {
 			break
 		}
-		w.(http.Flusher).Flush()
+
+		if wsConn == nil {
+			_, err = w.Write(buf.Bytes())
+			w.(http.Flusher).Flush()
+		} else {
+			err = wsConn.WriteMessage(websocket.TextMessage, buf.Bytes())
+		}
+
+		if err != nil {
+			break
+		}
 	}
 }
+
+func version(w http.ResponseWriter, r *http.Request) {
+	render.JSON(w, r, render.M{"version": C.Version})
+}