Fix: redir-host mode crash

add freebsd support

.gitignore

@@ -4,6 +4,7 @@
 *.dll
 *.so
 *.dylib
+bin/*
 
 # Test binary, build with `go test -c`
 *.test

.travis.yml

@@ -2,14 +2,13 @@ language: go
 sudo: false
 go:
   - "1.11"
-before_install:
-  - go get -u github.com/golang/dep/cmd/dep
 install:
-  - "$GOPATH/bin/dep ensure"
+  - "go mod download"
 env:
   global:
     - NAME=clash
     - BINDIR=bin
+    - GO111MODULE=on
 script:
   - go test ./...
 before_deploy: make -j releases

Dockerfile

@@ -1,19 +1,23 @@
 FROM golang:latest 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 && \
-    cp /tmp/GeoLite2-Country_*/GeoLite2-Country.mmdb /Country.mmdb
+    mv /tmp/GeoLite2-Country_*/GeoLite2-Country.mmdb /Country.mmdb
-RUN curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh && \
+
-    mkdir -p /go/src/github.com/Dreamacro/clash
+WORKDIR /clash-src
-WORKDIR /go/src/github.com/Dreamacro/clash
+
-COPY . /go/src/github.com/Dreamacro/clash
+COPY . /clash-src
-RUN dep ensure && \
+
-    GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -ldflags '-w -s' -o /clash && \
+RUN go mod download && \
-    chmod +x /clash
+    GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -ldflags '-w -s' -o /clash
 
 FROM alpine:latest
-RUN apk --no-cache add ca-certificates && \
+
-    mkdir -p /root/.config/clash
+RUN apk add --no-cache ca-certificates
+
 COPY --from=builder /Country.mmdb /root/.config/clash/
-COPY --from=builder /clash .
+COPY --from=builder /clash /
+
 EXPOSE 7890 7891
+
 ENTRYPOINT ["/clash"]

Gopkg.lock

@@ -1,149 +0,0 @@
-# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
-
-
-[[projects]]
-  branch = "master"
-  digest = "1:8fa55a6e302771a90a86ceae1ca3c0df4ef15d21092198e8313f61dde9eea963"
-  name = "github.com/Yawning/chacha20"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "e3b1f968fc6397b51d963fee8ec8711a47bc0ce8"
-
-[[projects]]
-  digest = "1:444b82bfe35c83bbcaf84e310fb81a1f9ece03edfed586483c869e2c046aef69"
-  name = "github.com/eapache/queue"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "44cc805cf13205b55f69e14bcb69867d1ae92f98"
-  version = "v1.1.0"
-
-[[projects]]
-  digest = "1:b9914f85d95a0968bafd1be1908ba29e2eafafd88d6fd13696be42bf5368c380"
-  name = "github.com/go-chi/chi"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "b5294d10673813fac8558e7f47242bc9e61b4c25"
-  version = "v3.3.3"
-
-[[projects]]
-  digest = "1:dfa416a1bb8139f30832543340f972f65c0db9932034cb6a1b42c5ac615a3fb8"
-  name = "github.com/go-chi/cors"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "dba6525398619dead495962a916728e7ee2ca322"
-  version = "v1.0.0"
-
-[[projects]]
-  digest = "1:54d7b4b9ab2bb2bae35b55eea900bc8fe15cba05a95fc78bf7fd7b82a9a07afa"
-  name = "github.com/go-chi/render"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "3215478343fbc559bd3fc08f7031bb134d6bdad5"
-  version = "v1.0.1"
-
-[[projects]]
-  digest = "1:ce579162ae1341f3e5ab30c0dce767f28b1eb6a81359aad01723f1ba6b4becdf"
-  name = "github.com/gofrs/uuid"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "370558f003bfe29580cd0f698d8640daccdcc45c"
-  version = "v3.1.1"
-
-[[projects]]
-  digest = "1:2e8bdbc8a11d716dab1bf66d326285d7e5c92fa4c996c1574ba1153e57534b85"
-  name = "github.com/oschwald/geoip2-golang"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "7118115686e16b77967cdbf55d1b944fe14ad312"
-  version = "v1.2.1"
-
-[[projects]]
-  digest = "1:07e8589503b7ec22430dae6eed6f2c17e4249ab245574f4fd0ba8fc9c597d138"
-  name = "github.com/oschwald/maxminddb-golang"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "c5bec84d1963260297932a1b7a1753c8420717a7"
-  version = "v1.3.0"
-
-[[projects]]
-  digest = "1:2bfa1a73654feb90893014b04779ce5205f3e19e843c0e32a89ea051d31f12d5"
-  name = "github.com/riobard/go-shadowsocks2"
-  packages = [
-    "core",
-    "shadowaead",
-    "shadowstream",
-    "socks",
-  ]
-  pruneopts = "UT"
-  revision = "8346403248229fc7e10d7a259de8e9352a9d8830"
-  version = "v0.1.0"
-
-[[projects]]
-  digest = "1:d867dfa6751c8d7a435821ad3b736310c2ed68945d05b50fb9d23aee0540c8cc"
-  name = "github.com/sirupsen/logrus"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "3e01752db0189b9157070a0e1668a620f9a85da2"
-  version = "v1.0.6"
-
-[[projects]]
-  branch = "master"
-  digest = "1:d33888518d56c3f0cc9009594f56be4faf33ffff358fe10ff8e7e8cccf0e6617"
-  name = "golang.org/x/crypto"
-  packages = [
-    "chacha20poly1305",
-    "hkdf",
-    "internal/chacha20",
-    "internal/subtle",
-    "poly1305",
-    "ssh/terminal",
-  ]
-  pruneopts = "UT"
-  revision = "0709b304e793a5edb4a2c0145f281ecdc20838a4"
-
-[[projects]]
-  branch = "master"
-  digest = "1:576f8d82185dc836ec6d10c0e5568dc4ff94e4d9f101d33ed5d6bae0cbba65b2"
-  name = "golang.org/x/sys"
-  packages = [
-    "cpu",
-    "unix",
-    "windows",
-  ]
-  pruneopts = "UT"
-  revision = "ebe1bf3edb3325c393447059974de898d5133eb8"
-
-[[projects]]
-  digest = "1:975a4480c40f2d0b95e1f83d3ec1aa29a2774e80179e08a9a4ba2aab86721b23"
-  name = "gopkg.in/eapache/channels.v1"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "47238d5aae8c0fefd518ef2bee46290909cf8263"
-  version = "v1.1.0"
-
-[[projects]]
-  digest = "1:5abd6a22805b1919f6a6bca0ae58b13cef1f3412812f38569978f43ef02743d4"
-  name = "gopkg.in/ini.v1"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "5cf292cae48347c2490ac1a58fe36735fb78df7e"
-  version = "v1.38.2"
-
-[solve-meta]
-  analyzer-name = "dep"
-  analyzer-version = 1
-  input-imports = [
-    "github.com/go-chi/chi",
-    "github.com/go-chi/cors",
-    "github.com/go-chi/render",
-    "github.com/gofrs/uuid",
-    "github.com/oschwald/geoip2-golang",
-    "github.com/riobard/go-shadowsocks2/core",
-    "github.com/riobard/go-shadowsocks2/socks",
-    "github.com/sirupsen/logrus",
-    "golang.org/x/crypto/chacha20poly1305",
-    "gopkg.in/eapache/channels.v1",
-    "gopkg.in/ini.v1",
-  ]
-  solver-name = "gps-cdcl"
-  solver-version = 1

Gopkg.toml

@@ -1,70 +0,0 @@
-# Gopkg.toml example
-#
-# Refer to https://golang.github.io/dep/docs/Gopkg.toml.html
-# for detailed Gopkg.toml documentation.
-#
-# required = ["github.com/user/thing/cmd/thing"]
-# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
-#
-# [[constraint]]
-#   name = "github.com/user/project"
-#   version = "1.0.0"
-#
-# [[constraint]]
-#   name = "github.com/user/project2"
-#   branch = "dev"
-#   source = "github.com/myfork/project2"
-#
-# [[override]]
-#   name = "github.com/x/y"
-#   version = "2.4.0"
-#
-# [prune]
-#   non-go = false
-#   go-tests = true
-#   unused-packages = true
-
-
-[[constraint]]
-  name = "github.com/go-chi/chi"
-  version = "3.3.3"
-
-[[constraint]]
-  name = "github.com/go-chi/cors"
-  version = "1.0.0"
-
-[[constraint]]
-  name = "github.com/go-chi/render"
-  version = "1.0.1"
-
-[[constraint]]
-  name = "github.com/gofrs/uuid"
-  version = "3.1.1"
-
-[[constraint]]
-  name = "github.com/oschwald/geoip2-golang"
-  version = "1.2.1"
-
-[[constraint]]
-  name = "github.com/riobard/go-shadowsocks2"
-  version = "0.1.0"
-
-[[constraint]]
-  name = "github.com/sirupsen/logrus"
-  version = "1.0.6"
-
-[[constraint]]
-  branch = "master"
-  name = "golang.org/x/crypto"
-
-[[constraint]]
-  name = "gopkg.in/eapache/channels.v1"
-  version = "1.1.0"
-
-[[constraint]]
-  name = "gopkg.in/ini.v1"
-  version = "1.38.2"
-
-[prune]
-  go-tests = true
-  unused-packages = true

Makefile

@@ -2,22 +2,88 @@ NAME=clash
 BINDIR=bin
 GOBUILD=CGO_ENABLED=0 go build -ldflags '-w -s'
 
-all: linux macos win64
+PLATFORM_LIST = \
+	darwin-amd64 \
+	linux-386 \
+	linux-amd64 \
+	linux-armv5 \
+	linux-armv6 \
+	linux-armv7 \
+	linux-armv8 \
+	linux-mips-softfloat \
+	linux-mips-hardfloat \
+	linux-mipsle \
+	linux-mips64 \
+	linux-mips64le \
+	freebsd-386 \
+	freebsd-amd64
 
-linux:
+WINDOWS_ARCH_LIST = \
-	GOARCH=amd64 GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
+	windows-386 \
+	windows-amd64
 
-macos:
+all: linux-amd64 darwin-amd64 windows-amd64 # Most used
+
+darwin-amd64:
 	GOARCH=amd64 GOOS=darwin $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
 
-win64:
+linux-386:
+	GOARCH=386 GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
+
+linux-amd64:
+	GOARCH=amd64 GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
+
+linux-armv5:
+	GOARCH=arm GOOS=linux GOARM=5 $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
+
+linux-armv6:
+	GOARCH=arm GOOS=linux GOARM=6 $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
+
+linux-armv7:
+	GOARCH=arm GOOS=linux GOARM=7 $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
+
+linux-armv8:
+	GOARCH=arm64 GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
+
+linux-mips-softfloat:
+	GOARCH=mips GOMIPS=softfloat GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
+
+linux-mips-hardfloat:
+	GOARCH=mips GOMIPS=hardfloat GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
+
+linux-mipsle:
+	GOARCH=mipsle GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
+
+linux-mips64:
+	GOARCH=mips64 GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
+
+linux-mips64le:
+	GOARCH=mips64le GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
+
+freebsd-386:
+	GOARCH=386 GOOS=freebsd $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
+
+freebsd-amd64:
+	GOARCH=amd64 GOOS=freebsd $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
+
+windows-386:
 	GOARCH=amd64 GOOS=windows $(GOBUILD) -o $(BINDIR)/$(NAME)-$@.exe
 
-releases: linux macos win64
+windows-amd64:
-	chmod +x $(BINDIR)/$(NAME)-*
+	GOARCH=amd64 GOOS=windows $(GOBUILD) -o $(BINDIR)/$(NAME)-$@.exe
-	gzip $(BINDIR)/$(NAME)-linux
-	gzip $(BINDIR)/$(NAME)-macos
-	zip -m -j $(BINDIR)/$(NAME)-win64.zip $(BINDIR)/$(NAME)-win64.exe
 
+gz_releases=$(addsuffix .gz, $(PLATFORM_LIST))
+zip_releases=$(addsuffix .zip, $(WINDOWS_ARCH_LIST))
+
+$(gz_releases): %.gz : %
+	chmod +x $(BINDIR)/$(NAME)-$(basename $@)
+	gzip -f $(BINDIR)/$(NAME)-$(basename $@)
+
+$(zip_releases): %.zip : %
+	zip -m -j $(BINDIR)/$(NAME)-$(basename $@).zip $(BINDIR)/$(NAME)-$(basename $@).exe
+
+all-arch: $(PLATFORM_LIST) $(WINDOWS_ARCH_LIST)
+
+releases: $(gz_releases) $(zip_releases)
 clean:
 	rm $(BINDIR)/*

README.md

@@ -1,11 +1,9 @@
 <h1 align="center">
   <img src="https://github.com/Dreamacro/clash/raw/master/docs/logo.png" alt="Clash" width="200">
-  <br>
+  <br>Clash<br>
-  Clash
-  <br>
 </h1>
 
-<h4 align="center">A rule based proxy in Go.</h4>
+<h4 align="center">A rule-based tunnel in Go.</h4>
 
 <p align="center">
   <a href="https://travis-ci.org/Dreamacro/clash">
@@ -13,7 +11,7 @@
          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">
+    <img src="https://goreportcard.com/badge/github.com/Dreamacro/clash?style=flat-square">
   </a>
   <a href="https://github.com/Dreamacro/clash/releases">
     <img src="https://img.shields.io/github/release/Dreamacro/clash/all.svg?style=flat-square">
@@ -22,16 +20,12 @@
 
 ## Features
 
-- HTTP/HTTPS and SOCKS proxy
+- HTTP/HTTPS and SOCKS protocol
 - Surge like configuration
 - GeoIP rule support
 - Support Vmess/Shadowsocks/Socks5
 - Support for Netfilter TCP redirect
 
-## Discussion
-
-[Telegram Group](https://t.me/clash_discuss)
-
 ## Install
 
 You can build from source:
@@ -42,7 +36,7 @@ go get -u -v github.com/Dreamacro/clash
 
 Pre-built binaries are available: [release](https://github.com/Dreamacro/clash/releases)
 
-Requires Go >= 1.10.
+Requires Go >= 1.11.
 
 ## Daemon
 
@@ -62,51 +56,146 @@ If you have Docker installed, you can run clash directly using `docker-compose`.
 
 ## Config
 
-Configuration file at `$HOME/.config/clash/config.ini`
+The default configuration directory is `$HOME/.config/clash`
+
+The name of the configuration file is `config.yml`
+
+If you want to use another directory, you can use `-d` to control the configuration directory
+
+For example, you can use the current directory as the configuration directory
+
+```sh
+clash -d .
+```
 
 Below is a simple demo configuration file:
 
-```ini
+```yml
-[General]
+# port of HTTP
-port = 7890
+port: 7890
-socks-port = 7891
 
-# redir proxy for Linux and macOS
+# port of SOCKS5
-redir-port = 7892
+socks-port: 7891
+
+# redir port for Linux and macOS
+# redir-port: 7892
+
+allow-lan: false
+
+# 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
-external-controller = 127.0.0.1:8080
+external-controller: 127.0.0.1:9090
 
-[Proxy]
+# you can put the static web resource (such as clash-dashboard) to a directory, and clash would serve in `${API}/ui`
-# name = ss, server, port, cipher, password(, obfs=tls/http, obfs-host=bing.com)
+# input is a relative path to the configuration directory or an absolute path
+# external-ui: folder
+
+# Secret for RESTful API (Optional)
+# secret: ""
+
+# dns:
+  # enable: true # set true to enable dns (default is false)
+  # ipv6: false # default is false
+  # listen: 0.0.0.0:53
+  # enhanced-mode: redir-host
+  # nameserver:
+  #   - 114.114.114.114
+  #   - tls://dns.rubyfish.cn:853 # dns over tls
+  # fallback: # concurrent request with nameserver, fallback used when GEOIP country isn't CN
+  #   - 8.8.8.8
+
+Proxy:
+
+# shadowsocks
 # The types of cipher are consistent with go-shadowsocks2
 # 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
-ss1 = ss, server1, port, AEAD_CHACHA20_POLY1305, password
+# In addition to what go-shadowsocks2 supports, it also supports chacha20 rc4-md5 xchacha20-ietf-poly1305
-ss2 = ss, server2, port, AEAD_CHACHA20_POLY1305, password
+- { name: "ss1", type: ss, server: server, port: 443, cipher: AEAD_CHACHA20_POLY1305, password: "password" }
 
-# name = vmess, server, port, uuid, alterId, cipher(, tls=true)
+# old obfs configuration remove after prerelease
+- name: "ss2"
+  type: ss
+  server: server
+  port: 443
+  cipher: AEAD_CHACHA20_POLY1305
+  password: "password"
+  plugin: obfs
+  plugin-opts:
+    mode: tls # or http
+    # host: bing.com
+
+- name: "ss3"
+  type: ss
+  server: server
+  port: 443
+  cipher: AEAD_CHACHA20_POLY1305
+  password: "password"
+  plugin: v2ray-plugin
+  plugin-opts:
+    mode: websocket # no QUIC now
+    # tls: true # wss
+    # skip-cert-verify: true
+    # host: bing.com
+    # path: "/"
+
+# vmess
 # cipher support auto/aes-128-gcm/chacha20-poly1305/none
-vmess1 = vmess, server, port, uuid, 32, auto, tls=true
+- { name: "vmess", type: vmess, server: server, port: 443, uuid: uuid, alterId: 32, cipher: auto }
+# with tls
+- { name: "vmess", type: vmess, server: server, port: 443, uuid: uuid, alterId: 32, cipher: auto, tls: true }
+# with tls and skip-cert-verify
+- { name: "vmess", type: vmess, server: server, port: 443, uuid: uuid, alterId: 32, cipher: auto, tls: true, skip-cert-verify: true }
+# with ws-path and ws-headers
+- { name: "vmess", type: vmess, server: server, port: 443, uuid: uuid, alterId: 32, cipher: auto, network: ws, ws-path: /path, ws-headers: { Host: v2ray.com } }
+# with ws + tls
+- { name: "vmess", type: vmess, server: server, port: 443, uuid: uuid, alterId: 32, cipher: auto, network: ws, ws-path: /path, tls: true }
 
-# name = socks5, server, port
+# socks5
-socks = socks5, server, port
+- { name: "socks", type: socks5, server: server, port: 443 }
+# socks5 with authentication
+- { name: "socks", type: socks5, server: server, port: 443, username: "username", password: "password" }
+# with tls
+- { name: "socks", type: socks5, server: server, port: 443, tls: true }
+# with tls and skip-cert-verify
+- { name: "socks", type: socks5, server: server, port: 443, tls: true, skip-cert-verify: true }
 
-[Proxy Group]
+# http
+- { name: "http", type: http, server: server, port: 443 }
+# http with authentication
+- { name: "http", type: http, server: server, port: 443, username: "username", password: "password" }
+# with tls (https)
+- { name: "http", type: http, server: server, port: 443, tls: true }
+# with tls (https) and skip-cert-verify
+- { name: "http", type: http, server: server, port: 443, tls: true, skip-cert-verify: true }
+
+Proxy Group:
 # url-test select which proxy will be used by benchmarking speed to a URL.
-# name = url-test, [proxies], url, interval(second)
+- { name: "auto", type: url-test, proxies: ["ss1", "ss2", "vmess1"], url: "http://www.gstatic.com/generate_204", interval: 300 }
-auto = url-test, ss1, ss2, http://www.google.com/generate_204, 300
+
+# fallback select an available policy by priority. The availability is tested by accessing an URL, just like an auto url-test group.
+- { name: "fallback-auto", type: fallback, proxies: ["ss1", "ss2", "vmess1"], url: "http://www.gstatic.com/generate_204", interval: 300 }
 
 # select is used for selecting proxy or proxy group
 # you can use RESTful API to switch proxy, is recommended for use in GUI.
-# name = select, [proxies]
+- { name: "Proxy", type: select, proxies: ["ss1", "ss2", "vmess1", "auto"] }
-Proxy = select, ss1, ss2, auto
 
-[Rule]
+Rule:
-DOMAIN-SUFFIX,google.com,Proxy
+- DOMAIN-SUFFIX,google.com,Proxy
-DOMAIN-KEYWORD,google,Proxy
+- DOMAIN-KEYWORD,google,Proxy
-DOMAIN-SUFFIX,ad.com,REJECT
+- DOMAIN,google.com,Proxy
-GEOIP,CN,DIRECT
+- DOMAIN-SUFFIX,ad.com,REJECT
-FINAL,,Proxy # note: there is two ","
+- IP-CIDR,127.0.0.0/8,DIRECT
+- SOURCE-IP-CIDR,192.168.1.201/32,DIRECT
+- GEOIP,CN,DIRECT
+# FINAL would remove after prerelease
+# you also can use `FINAL,Proxy` or `FINAL,,Proxy` now
+- MATCH,Proxy
 ```
 
 ## Thanks

adapters/inbound/http.go

@@ -10,9 +10,9 @@ import (
 
 // HTTPAdapter is a adapter for HTTP connection
 type HTTPAdapter struct {
-	addr *C.Addr
+	metadata *C.Metadata
-	conn net.Conn
+	conn     net.Conn
-	R    *http.Request
+	R        *http.Request
 }
 
 // Close HTTP connection
@@ -20,9 +20,9 @@ func (h *HTTPAdapter) Close() {
 	h.conn.Close()
 }
 
-// Addr return destination address
+// Metadata return destination metadata
-func (h *HTTPAdapter) Addr() *C.Addr {
+func (h *HTTPAdapter) Metadata() *C.Metadata {
-	return h.addr
+	return h.metadata
 }
 
 // Conn return raw net.Conn of HTTP
@@ -32,10 +32,12 @@ func (h *HTTPAdapter) Conn() net.Conn {
 
 // NewHTTP is HTTPAdapter generator
 func NewHTTP(request *http.Request, conn net.Conn) *HTTPAdapter {
+	metadata := parseHTTPAddr(request)
+	metadata.SourceIP = parseSourceIP(conn)
 	return &HTTPAdapter{
-		addr: parseHTTPAddr(request),
+		metadata: metadata,
-		R:    request,
+		R:        request,
-		conn: conn,
+		conn:     conn,
 	}
 }
 

adapters/inbound/https.go

@@ -7,8 +7,10 @@ import (
 
 // NewHTTPS is HTTPAdapter generator
 func NewHTTPS(request *http.Request, conn net.Conn) *SocketAdapter {
+	metadata := parseHTTPAddr(request)
+	metadata.SourceIP = parseSourceIP(conn)
 	return &SocketAdapter{
-		addr: parseHTTPAddr(request),
+		metadata: metadata,
-		conn: conn,
+		conn:     conn,
 	}
 }

adapters/inbound/socket.go

@@ -0,0 +1,41 @@
+package adapters
+
+import (
+	"net"
+
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/go-shadowsocks2/socks"
+)
+
+// SocketAdapter is a adapter for socks and redir connection
+type SocketAdapter struct {
+	conn     net.Conn
+	metadata *C.Metadata
+}
+
+// Close socks and redir connection
+func (s *SocketAdapter) Close() {
+	s.conn.Close()
+}
+
+// Metadata return destination metadata
+func (s *SocketAdapter) Metadata() *C.Metadata {
+	return s.metadata
+}
+
+// Conn return raw net.Conn
+func (s *SocketAdapter) Conn() net.Conn {
+	return s.conn
+}
+
+// NewSocket is SocketAdapter generator
+func NewSocket(target socks.Addr, conn net.Conn, source C.SourceType) *SocketAdapter {
+	metadata := parseSocksAddr(target)
+	metadata.Source = source
+	metadata.SourceIP = parseSourceIP(conn)
+
+	return &SocketAdapter{
+		conn:     conn,
+		metadata: metadata,
+	}
+}

adapters/inbound/util.go

@@ -0,0 +1,70 @@
+package adapters
+
+import (
+	"net"
+	"net/http"
+	"strconv"
+
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/go-shadowsocks2/socks"
+)
+
+func parseSocksAddr(target socks.Addr) *C.Metadata {
+	metadata := &C.Metadata{
+		NetWork:  C.TCP,
+		AddrType: int(target[0]),
+	}
+
+	switch target[0] {
+	case socks.AtypDomainName:
+		metadata.Host = string(target[2 : 2+target[1]])
+		metadata.Port = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1]))
+	case socks.AtypIPv4:
+		ip := net.IP(target[1 : 1+net.IPv4len])
+		metadata.IP = &ip
+		metadata.Port = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1]))
+	case socks.AtypIPv6:
+		ip := net.IP(target[1 : 1+net.IPv6len])
+		metadata.IP = &ip
+		metadata.Port = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1]))
+	}
+
+	return metadata
+}
+
+func parseHTTPAddr(request *http.Request) *C.Metadata {
+	host := request.URL.Hostname()
+	port := request.URL.Port()
+	if port == "" {
+		port = "80"
+	}
+
+	metadata := &C.Metadata{
+		NetWork:  C.TCP,
+		Source:   C.HTTP,
+		AddrType: C.AtypDomainName,
+		Host:     host,
+		IP:       nil,
+		Port:     port,
+	}
+
+	ip := net.ParseIP(host)
+	if ip != nil {
+		switch {
+		case ip.To4() == nil:
+			metadata.AddrType = C.AtypIPv6
+		default:
+			metadata.AddrType = C.AtypIPv4
+		}
+		metadata.IP = &ip
+	}
+
+	return metadata
+}
+
+func parseSourceIP(conn net.Conn) *net.IP {
+	if addr, ok := conn.RemoteAddr().(*net.TCPAddr); ok {
+		return &addr.IP
+	}
+	return nil
+}

adapters/local/socket.go

@@ -1,37 +0,0 @@
-package adapters
-
-import (
-	"net"
-
-	C "github.com/Dreamacro/clash/constant"
-	"github.com/riobard/go-shadowsocks2/socks"
-)
-
-// SocketAdapter is a adapter for socks and redir connection
-type SocketAdapter struct {
-	conn net.Conn
-	addr *C.Addr
-}
-
-// Close socks and redir connection
-func (s *SocketAdapter) Close() {
-	s.conn.Close()
-}
-
-// Addr return destination address
-func (s *SocketAdapter) Addr() *C.Addr {
-	return s.addr
-}
-
-// Conn return raw net.Conn
-func (s *SocketAdapter) Conn() net.Conn {
-	return s.conn
-}
-
-// NewSocket is SocketAdapter generator
-func NewSocket(target socks.Addr, conn net.Conn) *SocketAdapter {
-	return &SocketAdapter{
-		conn: conn,
-		addr: parseSocksAddr(target),
-	}
-}

adapters/local/util.go

@@ -1,71 +0,0 @@
-package adapters
-
-import (
-	"net"
-	"net/http"
-	"strconv"
-
-	C "github.com/Dreamacro/clash/constant"
-	"github.com/riobard/go-shadowsocks2/socks"
-)
-
-func parseSocksAddr(target socks.Addr) *C.Addr {
-	var host, port string
-	var ip net.IP
-
-	switch target[0] {
-	case socks.AtypDomainName:
-		host = string(target[2 : 2+target[1]])
-		port = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1]))
-		ipAddr, err := net.ResolveIPAddr("ip", host)
-		if err == nil {
-			ip = ipAddr.IP
-		}
-	case socks.AtypIPv4:
-		ip = net.IP(target[1 : 1+net.IPv4len])
-		port = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1]))
-	case socks.AtypIPv6:
-		ip = net.IP(target[1 : 1+net.IPv6len])
-		port = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1]))
-	}
-
-	return &C.Addr{
-		NetWork:  C.TCP,
-		AddrType: int(target[0]),
-		Host:     host,
-		IP:       &ip,
-		Port:     port,
-	}
-}
-
-func parseHTTPAddr(request *http.Request) *C.Addr {
-	host := request.URL.Hostname()
-	port := request.URL.Port()
-	if port == "" {
-		port = "80"
-	}
-	ipAddr, err := net.ResolveIPAddr("ip", host)
-	var resolveIP *net.IP
-	if err == nil {
-		resolveIP = &ipAddr.IP
-	}
-
-	var addType int
-	ip := net.ParseIP(host)
-	switch {
-	case ip == nil:
-		addType = socks.AtypDomainName
-	case ip.To4() == nil:
-		addType = socks.AtypIPv6
-	default:
-		addType = socks.AtypIPv4
-	}
-
-	return &C.Addr{
-		NetWork:  C.TCP,
-		AddrType: addType,
-		Host:     host,
-		IP:       resolveIP,
-		Port:     port,
-	}
-}

adapters/outbound/base.go

@@ -0,0 +1,26 @@
+package adapters
+
+import (
+	"encoding/json"
+
+	C "github.com/Dreamacro/clash/constant"
+)
+
+type Base struct {
+	name string
+	tp   C.AdapterType
+}
+
+func (b *Base) Name() string {
+	return b.name
+}
+
+func (b *Base) Type() C.AdapterType {
+	return b.tp
+}
+
+func (b *Base) MarshalJSON() ([]byte, error) {
+	return json.Marshal(map[string]string{
+		"type": b.Type().String(),
+	})
+}

adapters/outbound/direct.go

@@ -0,0 +1,34 @@
+package adapters
+
+import (
+	"net"
+
+	C "github.com/Dreamacro/clash/constant"
+)
+
+type Direct struct {
+	*Base
+}
+
+func (d *Direct) Generator(metadata *C.Metadata) (net.Conn, error) {
+	address := net.JoinHostPort(metadata.Host, metadata.Port)
+	if metadata.IP != nil {
+		address = net.JoinHostPort(metadata.IP.String(), metadata.Port)
+	}
+
+	c, err := net.DialTimeout("tcp", address, tcpTimeout)
+	if err != nil {
+		return nil, err
+	}
+	tcpKeepAlive(c)
+	return c, nil
+}
+
+func NewDirect() *Direct {
+	return &Direct{
+		Base: &Base{
+			name: "DIRECT",
+			tp:   C.Direct,
+		},
+	}
+}

adapters/outbound/fallback.go

@@ -0,0 +1,145 @@
+package adapters
+
+import (
+	"encoding/json"
+	"errors"
+	"net"
+	"sync"
+	"time"
+
+	C "github.com/Dreamacro/clash/constant"
+)
+
+type proxy struct {
+	RawProxy C.Proxy
+	Valid    bool
+}
+
+type Fallback struct {
+	*Base
+	proxies  []*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.findNextValidProxy(0)
+	if proxy != nil {
+		return proxy.RawProxy.Name()
+	}
+	return f.proxies[0].RawProxy.Name()
+}
+
+func (f *Fallback) Generator(metadata *C.Metadata) (net.Conn, error) {
+	idx := 0
+	var proxy *proxy
+	for {
+		idx, proxy = f.findNextValidProxy(idx)
+		if proxy == nil {
+			break
+		}
+		adapter, err := proxy.RawProxy.Generator(metadata)
+		if err != nil {
+			proxy.Valid = false
+			idx++
+			continue
+		}
+		return adapter, err
+	}
+	return f.proxies[0].RawProxy.Generator(metadata)
+}
+
+func (f *Fallback) MarshalJSON() ([]byte, error) {
+	var all []string
+	for _, proxy := range f.proxies {
+		all = append(all, proxy.RawProxy.Name())
+	}
+	return json.Marshal(map[string]interface{}{
+		"type": f.Type().String(),
+		"now":  f.Now(),
+		"all":  all,
+	})
+}
+
+func (f *Fallback) Close() {
+	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) findNextValidProxy(start int) (int, *proxy) {
+	for i := start; i < len(f.proxies); i++ {
+		if f.proxies[i].Valid {
+			return i, f.proxies[i]
+		}
+	}
+	return -1, nil
+}
+
+func (f *Fallback) validTest() {
+	wg := sync.WaitGroup{}
+	wg.Add(len(f.proxies))
+
+	for _, p := range f.proxies {
+		go func(p *proxy) {
+			_, err := DelayTest(p.RawProxy, f.rawURL)
+			p.Valid = err == nil
+			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
+	warpperProxies := make([]*proxy, len(proxies))
+	for idx := range proxies {
+		warpperProxies[idx] = &proxy{
+			RawProxy: proxies[idx],
+			Valid:    true,
+		}
+	}
+
+	Fallback := &Fallback{
+		Base: &Base{
+			name: option.Name,
+			tp:   C.Fallback,
+		},
+		proxies:  warpperProxies,
+		rawURL:   option.URL,
+		interval: interval,
+		done:     make(chan struct{}),
+	}
+	go Fallback.loop()
+	return Fallback, nil
+}

adapters/outbound/http.go

@@ -0,0 +1,122 @@
+package adapters
+
+import (
+	"bufio"
+	"bytes"
+	"crypto/tls"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"strconv"
+
+	C "github.com/Dreamacro/clash/constant"
+)
+
+type Http struct {
+	*Base
+	addr           string
+	user           string
+	pass           string
+	tls            bool
+	skipCertVerify bool
+	tlsConfig      *tls.Config
+}
+
+type HttpOption struct {
+	Name           string `proxy:"name"`
+	Server         string `proxy:"server"`
+	Port           int    `proxy:"port"`
+	UserName       string `proxy:"username,omitempty"`
+	Password       string `proxy:"password,omitempty"`
+	TLS            bool   `proxy:"tls,omitempty"`
+	SkipCertVerify bool   `proxy:"skip-cert-verify,omitempty"`
+}
+
+func (h *Http) Generator(metadata *C.Metadata) (net.Conn, error) {
+	c, err := net.DialTimeout("tcp", h.addr, tcpTimeout)
+	if err == nil && h.tls {
+		cc := tls.Client(c, h.tlsConfig)
+		err = cc.Handshake()
+		c = cc
+	}
+
+	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 {
+	var buf bytes.Buffer
+	var err error
+
+	addr := net.JoinHostPort(metadata.Host, metadata.Port)
+	buf.WriteString("CONNECT " + addr + " HTTP/1.1\r\n")
+	buf.WriteString("Host: " + metadata.Host + "\r\n")
+	buf.WriteString("Proxy-Connection: Keep-Alive\r\n")
+
+	if h.user != "" && h.pass != "" {
+		auth := h.user + ":" + h.pass
+		buf.WriteString("Proxy-Authorization: Basic " + base64.StdEncoding.EncodeToString([]byte(auth)) + "\r\n")
+	}
+	// header ended
+	buf.WriteString("\r\n")
+
+	_, err = rw.Write(buf.Bytes())
+	if err != nil {
+		return err
+	}
+
+	var req http.Request
+	resp, err := http.ReadResponse(bufio.NewReader(rw), &req)
+	if err != nil {
+		return err
+	}
+
+	if resp.StatusCode == 200 {
+		return nil
+	}
+
+	if resp.StatusCode == 407 {
+		return errors.New("HTTP need auth")
+	}
+
+	if resp.StatusCode == 405 {
+		return errors.New("CONNECT method not allowed by proxy")
+	}
+	return fmt.Errorf("can not connect remote err code: %d", resp.StatusCode)
+}
+
+func NewHttp(option HttpOption) *Http {
+	var tlsConfig *tls.Config
+	if option.TLS {
+		tlsConfig = &tls.Config{
+			InsecureSkipVerify: option.SkipCertVerify,
+			ClientSessionCache: getClientSessionCache(),
+			MinVersion:         tls.VersionTLS11,
+			MaxVersion:         tls.VersionTLS12,
+			ServerName:         option.Server,
+		}
+	}
+
+	return &Http{
+		Base: &Base{
+			name: option.Name,
+			tp:   C.Http,
+		},
+		addr:           net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
+		user:           option.UserName,
+		pass:           option.Password,
+		tls:            option.TLS,
+		skipCertVerify: option.SkipCertVerify,
+		tlsConfig:      tlsConfig,
+	}
+}

adapters/outbound/reject.go

@@ -8,42 +8,27 @@ import (
 	C "github.com/Dreamacro/clash/constant"
 )
 
-// RejectAdapter is a reject connected adapter
-type RejectAdapter struct {
-	conn net.Conn
-}
-
-// Close is used to close connection
-func (r *RejectAdapter) Close() {}
-
-// Conn is used to http request
-func (r *RejectAdapter) Conn() net.Conn {
-	return r.conn
-}
-
 type Reject struct {
+	*Base
 }
 
-func (r *Reject) Name() string {
+func (r *Reject) Generator(metadata *C.Metadata) (net.Conn, error) {
-	return "Reject"
+	return &NopConn{}, nil
-}
-
-func (r *Reject) Type() C.AdapterType {
-	return C.Reject
-}
-
-func (r *Reject) Generator(addr *C.Addr) (adapter C.ProxyAdapter, err error) {
-	return &RejectAdapter{conn: &NopConn{}}, nil
 }
 
 func NewReject() *Reject {
-	return &Reject{}
+	return &Reject{
+		Base: &Base{
+			name: "REJECT",
+			tp:   C.Reject,
+		},
+	}
 }
 
 type NopConn struct{}
 
 func (rw *NopConn) Read(b []byte) (int, error) {
-	return len(b), nil
+	return 0, io.EOF
 }
 
 func (rw *NopConn) Write(b []byte) (int, error) {

adapters/outbound/selector.go

@@ -1,41 +1,44 @@
 package adapters
 
 import (
+	"encoding/json"
 	"errors"
+	"net"
 	"sort"
 
 	C "github.com/Dreamacro/clash/constant"
 )
 
 type Selector struct {
-	name     string
+	*Base
 	selected C.Proxy
 	proxies  map[string]C.Proxy
 }
 
-func (s *Selector) Name() string {
+type SelectorOption struct {
-	return s.name
+	Name    string   `proxy:"name"`
+	Proxies []string `proxy:"proxies"`
 }
 
-func (s *Selector) Type() C.AdapterType {
+func (s *Selector) Generator(metadata *C.Metadata) (net.Conn, error) {
-	return C.Selector
+	return s.selected.Generator(metadata)
 }
 
-func (s *Selector) Generator(addr *C.Addr) (adapter C.ProxyAdapter, err error) {
+func (s *Selector) MarshalJSON() ([]byte, error) {
-	return s.selected.Generator(addr)
-}
-
-func (s *Selector) Now() string {
-	return s.selected.Name()
-}
-
-func (s *Selector) All() []string {
 	var all []string
 	for k := range s.proxies {
 		all = append(all, k)
 	}
 	sort.Strings(all)
-	return all
+	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 {
@@ -47,21 +50,23 @@ func (s *Selector) Set(name string) error {
 	return nil
 }
 
-func NewSelector(name string, proxies map[string]C.Proxy) (*Selector, error) {
+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)
-	var init string
+	for _, proxy := range proxies {
-	for k, v := range proxies {
+		mapping[proxy.Name()] = proxy
-		mapping[k] = v
-		init = k
 	}
+
 	s := &Selector{
-		name:     name,
+		Base: &Base{
+			name: name,
+			tp:   C.Selector,
+		},
 		proxies:  mapping,
-		selected: proxies[init],
+		selected: proxies[0],
 	}
 	return s, nil
 }

adapters/outbound/shadowsocks.go

@@ -0,0 +1,174 @@
+package adapters
+
+import (
+	"bytes"
+	"crypto/tls"
+	"encoding/json"
+	"fmt"
+	"net"
+	"strconv"
+
+	"github.com/Dreamacro/clash/common/structure"
+	obfs "github.com/Dreamacro/clash/component/simple-obfs"
+	v2rayObfs "github.com/Dreamacro/clash/component/v2ray-plugin"
+	C "github.com/Dreamacro/clash/constant"
+
+	"github.com/Dreamacro/go-shadowsocks2/core"
+	"github.com/Dreamacro/go-shadowsocks2/socks"
+)
+
+type ShadowSocks struct {
+	*Base
+	server string
+	cipher core.Cipher
+
+	// obfs
+	obfsMode   string
+	obfsOption *simpleObfsOption
+	wsOption   *v2rayObfs.WebsocketOption
+}
+
+type ShadowSocksOption struct {
+	Name       string                 `proxy:"name"`
+	Server     string                 `proxy:"server"`
+	Port       int                    `proxy:"port"`
+	Password   string                 `proxy:"password"`
+	Cipher     string                 `proxy:"cipher"`
+	Plugin     string                 `proxy:"plugin,omitempty"`
+	PluginOpts map[string]interface{} `proxy:"plugin-opts,omitempty"`
+
+	// deprecated when bump to 1.0
+	Obfs     string `proxy:"obfs,omitempty"`
+	ObfsHost string `proxy:"obfs-host,omitempty"`
+}
+
+type simpleObfsOption struct {
+	Mode string `obfs:"mode"`
+	Host string `obfs:"host,omitempty"`
+}
+
+type v2rayObfsOption struct {
+	Mode           string `obfs:"mode"`
+	Host           string `obfs:"host,omitempty"`
+	Path           string `obfs:"path,omitempty"`
+	TLS            bool   `obfs:"tls,omitempty"`
+	SkipCertVerify bool   `obfs:"skip-cert-verify,omitempty"`
+}
+
+func (ss *ShadowSocks) Generator(metadata *C.Metadata) (net.Conn, error) {
+	c, err := net.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)
+		c = obfs.NewHTTPObfs(c, ss.obfsOption.Host, port)
+	case "websocket":
+		var err error
+		c, err = v2rayObfs.NewWebsocketObfs(c, ss.wsOption)
+		if err != nil {
+			return nil, fmt.Errorf("%s connect error: %s", ss.server, err.Error())
+		}
+	}
+	c = ss.cipher.StreamConn(c)
+	_, err = c.Write(serializesSocksAddr(metadata))
+	return c, err
+}
+
+func (ss *ShadowSocks) MarshalJSON() ([]byte, error) {
+	return json.Marshal(map[string]string{
+		"type": ss.Type().String(),
+	})
+}
+
+func NewShadowSocks(option ShadowSocksOption) (*ShadowSocks, error) {
+	server := net.JoinHostPort(option.Server, strconv.Itoa(option.Port))
+	cipher := option.Cipher
+	password := option.Password
+	ciph, err := core.PickCipher(cipher, nil, password)
+	if err != nil {
+		return nil, fmt.Errorf("ss %s initialize error: %s", server, err.Error())
+	}
+
+	var wsOption *v2rayObfs.WebsocketOption
+	var obfsOption *simpleObfsOption
+	obfsMode := ""
+
+	// forward compatibility before 1.0
+	if option.Obfs != "" {
+		obfsMode = option.Obfs
+		obfsOption = &simpleObfsOption{
+			Host: "bing.com",
+		}
+		if option.ObfsHost != "" {
+			obfsOption.Host = option.ObfsHost
+		}
+	}
+
+	decoder := structure.NewDecoder(structure.Option{TagName: "obfs", WeaklyTypedInput: true})
+	if option.Plugin == "obfs" {
+		opts := simpleObfsOption{Host: "bing.com"}
+		if err := decoder.Decode(option.PluginOpts, &opts); err != nil {
+			return nil, fmt.Errorf("ss %s initialize obfs error: %s", server, err.Error())
+		}
+		obfsMode = opts.Mode
+		obfsOption = &opts
+	} else if option.Plugin == "v2ray-plugin" {
+		opts := v2rayObfsOption{Host: "bing.com"}
+		if err := decoder.Decode(option.PluginOpts, &opts); err != nil {
+			return nil, fmt.Errorf("ss %s initialize v2ray-plugin error: %s", server, err.Error())
+		}
+		obfsMode = opts.Mode
+		var tlsConfig *tls.Config
+		if opts.TLS {
+			tlsConfig = &tls.Config{
+				ServerName:         opts.Host,
+				InsecureSkipVerify: opts.SkipCertVerify,
+				ClientSessionCache: getClientSessionCache(),
+			}
+		}
+
+		wsOption = &v2rayObfs.WebsocketOption{
+			Host:      opts.Host,
+			Path:      opts.Path,
+			TLSConfig: tlsConfig,
+		}
+	}
+
+	return &ShadowSocks{
+		Base: &Base{
+			name: option.Name,
+			tp:   C.Shadowsocks,
+		},
+		server: server,
+		cipher: ciph,
+
+		obfsMode:   obfsMode,
+		wsOption:   wsOption,
+		obfsOption: obfsOption,
+	}, nil
+}
+
+func serializesSocksAddr(metadata *C.Metadata) []byte {
+	var buf [][]byte
+	aType := uint8(metadata.AddrType)
+	p, _ := strconv.Atoi(metadata.Port)
+	port := []byte{uint8(p >> 8), uint8(p & 0xff)}
+	switch metadata.AddrType {
+	case socks.AtypDomainName:
+		len := uint8(len(metadata.Host))
+		host := []byte(metadata.Host)
+		buf = [][]byte{{aType, len}, host, port}
+	case socks.AtypIPv4:
+		host := metadata.IP.To4()
+		buf = [][]byte{{aType}, host, port}
+	case socks.AtypIPv6:
+		host := metadata.IP.To16()
+		buf = [][]byte{{aType}, host, port}
+	}
+	return bytes.Join(buf, nil)
+}

adapters/outbound/socks5.go

@@ -0,0 +1,139 @@
+package adapters
+
+import (
+	"bytes"
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"strconv"
+
+	C "github.com/Dreamacro/clash/constant"
+
+	"github.com/Dreamacro/go-shadowsocks2/socks"
+)
+
+type Socks5 struct {
+	*Base
+	addr           string
+	user           string
+	pass           string
+	tls            bool
+	skipCertVerify bool
+	tlsConfig      *tls.Config
+}
+
+type Socks5Option struct {
+	Name           string `proxy:"name"`
+	Server         string `proxy:"server"`
+	Port           int    `proxy:"port"`
+	UserName       string `proxy:"username,omitempty"`
+	Password       string `proxy:"password,omitempty"`
+	TLS            bool   `proxy:"tls,omitempty"`
+	SkipCertVerify bool   `proxy:"skip-cert-verify,omitempty"`
+}
+
+func (ss *Socks5) Generator(metadata *C.Metadata) (net.Conn, error) {
+	c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout)
+
+	if err == nil && ss.tls {
+		cc := tls.Client(c, ss.tlsConfig)
+		err = cc.Handshake()
+		c = cc
+	}
+
+	if err != nil {
+		return nil, fmt.Errorf("%s connect error", ss.addr)
+	}
+	tcpKeepAlive(c)
+	if err := ss.shakeHand(metadata, c); err != nil {
+		return nil, err
+	}
+	return c, nil
+}
+
+func (ss *Socks5) shakeHand(metadata *C.Metadata, rw io.ReadWriter) error {
+	buf := make([]byte, socks.MaxAddrLen)
+	var err error
+
+	// VER, NMETHODS, METHODS
+	if len(ss.user) > 0 {
+		_, err = rw.Write([]byte{5, 1, 2})
+	} else {
+		_, err = rw.Write([]byte{5, 1, 0})
+	}
+	if err != nil {
+		return err
+	}
+
+	// VER, METHOD
+	if _, err := io.ReadFull(rw, buf[:2]); err != nil {
+		return err
+	}
+
+	if buf[0] != 5 {
+		return errors.New("SOCKS version error")
+	}
+
+	if buf[1] == 2 {
+		// password protocol version
+		authMsg := &bytes.Buffer{}
+		authMsg.WriteByte(1)
+		authMsg.WriteByte(uint8(len(ss.user)))
+		authMsg.WriteString(ss.user)
+		authMsg.WriteByte(uint8(len(ss.pass)))
+		authMsg.WriteString(ss.pass)
+
+		if _, err := rw.Write(authMsg.Bytes()); err != nil {
+			return err
+		}
+
+		if _, err := io.ReadFull(rw, buf[:2]); err != nil {
+			return err
+		}
+
+		if buf[1] != 0 {
+			return errors.New("rejected username/password")
+		}
+	} else if buf[1] != 0 {
+		return errors.New("SOCKS need auth")
+	}
+
+	// VER, CMD, RSV, ADDR
+	if _, err := rw.Write(bytes.Join([][]byte{{5, 1, 0}, serializesSocksAddr(metadata)}, []byte(""))); err != nil {
+		return err
+	}
+
+	if _, err := io.ReadFull(rw, buf[:10]); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func NewSocks5(option Socks5Option) *Socks5 {
+	var tlsConfig *tls.Config
+	if option.TLS {
+		tlsConfig = &tls.Config{
+			InsecureSkipVerify: option.SkipCertVerify,
+			ClientSessionCache: getClientSessionCache(),
+			MinVersion:         tls.VersionTLS11,
+			MaxVersion:         tls.VersionTLS12,
+			ServerName:         option.Server,
+		}
+	}
+
+	return &Socks5{
+		Base: &Base{
+			name: option.Name,
+			tp:   C.Socks5,
+		},
+		addr:           net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
+		user:           option.UserName,
+		pass:           option.Password,
+		tls:            option.TLS,
+		skipCertVerify: option.SkipCertVerify,
+		tlsConfig:      tlsConfig,
+	}
+}

adapters/outbound/urltest.go

@@ -0,0 +1,137 @@
+package adapters
+
+import (
+	"encoding/json"
+	"errors"
+	"net"
+	"sort"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	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) Generator(metadata *C.Metadata) (net.Conn, error) {
+	a, err := u.fast.Generator(metadata)
+	if err != nil {
+		go u.speedTest()
+	}
+	return a, err
+}
+
+func (u *URLTest) MarshalJSON() ([]byte, error) {
+	var all []string
+	for _, proxy := range u.proxies {
+		all = append(all, proxy.Name())
+	}
+	sort.Strings(all)
+	return json.Marshal(map[string]interface{}{
+		"type": u.Type().String(),
+		"now":  u.Now(),
+		"all":  all,
+	})
+}
+
+func (u *URLTest) Close() {
+	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) speedTest() {
+	if atomic.AddInt32(&u.once, 1) != 1 {
+		return
+	}
+	defer atomic.StoreInt32(&u.once, 0)
+
+	wg := sync.WaitGroup{}
+	wg.Add(len(u.proxies))
+	c := make(chan interface{})
+	fast := selectFast(c)
+	timer := time.NewTimer(u.interval)
+
+	for _, p := range u.proxies {
+		go func(p C.Proxy) {
+			_, err := DelayTest(p, 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,18 +1,29 @@
 package adapters
 
 import (
+	"crypto/tls"
 	"fmt"
 	"net"
 	"net/http"
 	"net/url"
+	"sync"
 	"time"
 
 	C "github.com/Dreamacro/clash/constant"
 )
 
+const (
+	tcpTimeout = 5 * time.Second
+)
+
+var (
+	globalClientSessionCache tls.ClientSessionCache
+	once                     sync.Once
+)
+
 // DelayTest get the delay for the specified URL
 func DelayTest(proxy C.Proxy, url string) (t int16, err error) {
-	addr, err := urlToAddr(url)
+	addr, err := urlToMetadata(url)
 	if err != nil {
 		return
 	}
@@ -25,7 +36,7 @@ func DelayTest(proxy C.Proxy, url string) (t int16, err error) {
 	defer instance.Close()
 	transport := &http.Transport{
 		Dial: func(string, string) (net.Conn, error) {
-			return instance.Conn(), nil
+			return instance, nil
 		},
 		// from http.DefaultTransport
 		MaxIdleConns:          100,
@@ -34,16 +45,16 @@ func DelayTest(proxy C.Proxy, url string) (t int16, err error) {
 		ExpectContinueTimeout: 1 * time.Second,
 	}
 	client := http.Client{Transport: transport}
-	req, err := client.Get(url)
+	resp, err := client.Get(url)
 	if err != nil {
 		return
 	}
-	req.Body.Close()
+	resp.Body.Close()
 	t = int16(time.Since(start) / time.Millisecond)
 	return
 }
 
-func urlToAddr(rawURL string) (addr C.Addr, err error) {
+func urlToMetadata(rawURL string) (addr C.Metadata, err error) {
 	u, err := url.Parse(rawURL)
 	if err != nil {
 		return
@@ -61,7 +72,7 @@ func urlToAddr(rawURL string) (addr C.Addr, err error) {
 		}
 	}
 
-	addr = C.Addr{
+	addr = C.Metadata{
 		AddrType: C.AtypDomainName,
 		Host:     u.Hostname(),
 		IP:       nil,
@@ -88,6 +99,13 @@ func selectFast(in chan interface{}) chan interface{} {
 func tcpKeepAlive(c net.Conn) {
 	if tcp, ok := c.(*net.TCPConn); ok {
 		tcp.SetKeepAlive(true)
-		tcp.SetKeepAlivePeriod(3 * time.Minute)
+		tcp.SetKeepAlivePeriod(30 * time.Second)
 	}
 }
+
+func getClientSessionCache() tls.ClientSessionCache {
+	once.Do(func() {
+		globalClientSessionCache = tls.NewLRUClientSessionCache(128)
+	})
+	return globalClientSessionCache
+}

adapters/outbound/vmess.go

@@ -0,0 +1,97 @@
+package adapters
+
+import (
+	"fmt"
+	"net"
+	"strconv"
+	"strings"
+
+	"github.com/Dreamacro/clash/component/vmess"
+	C "github.com/Dreamacro/clash/constant"
+)
+
+type Vmess struct {
+	*Base
+	server string
+	client *vmess.Client
+}
+
+type VmessOption struct {
+	Name           string            `proxy:"name"`
+	Server         string            `proxy:"server"`
+	Port           int               `proxy:"port"`
+	UUID           string            `proxy:"uuid"`
+	AlterID        int               `proxy:"alterId"`
+	Cipher         string            `proxy:"cipher"`
+	TLS            bool              `proxy:"tls,omitempty"`
+	Network        string            `proxy:"network,omitempty"`
+	WSPath         string            `proxy:"ws-path,omitempty"`
+	WSHeaders      map[string]string `proxy:"ws-headers,omitempty"`
+	SkipCertVerify bool              `proxy:"skip-cert-verify,omitempty"`
+}
+
+func (v *Vmess) Generator(metadata *C.Metadata) (net.Conn, error) {
+	c, err := net.DialTimeout("tcp", v.server, tcpTimeout)
+	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 NewVmess(option VmessOption) (*Vmess, error) {
+	security := strings.ToLower(option.Cipher)
+	client, err := vmess.NewClient(vmess.Config{
+		UUID:             option.UUID,
+		AlterID:          uint16(option.AlterID),
+		Security:         security,
+		TLS:              option.TLS,
+		HostName:         option.Server,
+		Port:             strconv.Itoa(option.Port),
+		NetWork:          option.Network,
+		WebSocketPath:    option.WSPath,
+		WebSocketHeaders: option.WSHeaders,
+		SkipCertVerify:   option.SkipCertVerify,
+		SessionCacahe:    getClientSessionCache(),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return &Vmess{
+		Base: &Base{
+			name: option.Name,
+			tp:   C.Vmess,
+		},
+		server: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
+		client: client,
+	}, nil
+}
+
+func parseVmessAddr(metadata *C.Metadata) *vmess.DstAddr {
+	var addrType byte
+	var addr []byte
+	switch metadata.AddrType {
+	case C.AtypIPv4:
+		addrType = byte(vmess.AtypIPv4)
+		addr = make([]byte, net.IPv4len)
+		copy(addr[:], metadata.IP.To4())
+	case C.AtypIPv6:
+		addrType = byte(vmess.AtypIPv6)
+		addr = make([]byte, net.IPv6len)
+		copy(addr[:], metadata.IP.To16())
+	case C.AtypDomainName:
+		addrType = byte(vmess.AtypDomainName)
+		addr = make([]byte, len(metadata.Host)+1)
+		addr[0] = byte(len(metadata.Host))
+		copy(addr[1:], []byte(metadata.Host))
+	}
+
+	port, _ := strconv.Atoi(metadata.Port)
+	return &vmess.DstAddr{
+		AddrType: addrType,
+		Addr:     addr,
+		Port:     uint(port),
+	}
+}

adapters/remote/direct.go

@@ -1,45 +0,0 @@
-package adapters
-
-import (
-	"net"
-
-	C "github.com/Dreamacro/clash/constant"
-)
-
-// DirectAdapter is a directly connected adapter
-type DirectAdapter struct {
-	conn net.Conn
-}
-
-// Close is used to close connection
-func (d *DirectAdapter) Close() {
-	d.conn.Close()
-}
-
-// Conn is used to http request
-func (d *DirectAdapter) Conn() net.Conn {
-	return d.conn
-}
-
-type Direct struct{}
-
-func (d *Direct) Name() string {
-	return "Direct"
-}
-
-func (d *Direct) Type() C.AdapterType {
-	return C.Direct
-}
-
-func (d *Direct) Generator(addr *C.Addr) (adapter C.ProxyAdapter, err error) {
-	c, err := net.Dial("tcp", net.JoinHostPort(addr.String(), addr.Port))
-	if err != nil {
-		return
-	}
-	tcpKeepAlive(c)
-	return &DirectAdapter{conn: c}, nil
-}
-
-func NewDirect() *Direct {
-	return &Direct{}
-}

adapters/remote/shadowsocks.go

@@ -1,124 +0,0 @@
-package adapters
-
-import (
-	"bytes"
-	"fmt"
-	"net"
-	"net/url"
-	"strconv"
-
-	C "github.com/Dreamacro/clash/constant"
-
-	"github.com/Dreamacro/clash/common/simple-obfs"
-	"github.com/riobard/go-shadowsocks2/core"
-	"github.com/riobard/go-shadowsocks2/socks"
-)
-
-// ShadowsocksAdapter is a shadowsocks adapter
-type ShadowsocksAdapter struct {
-	conn net.Conn
-}
-
-// Close is used to close connection
-func (ss *ShadowsocksAdapter) Close() {
-	ss.conn.Close()
-}
-
-func (ss *ShadowsocksAdapter) Conn() net.Conn {
-	return ss.conn
-}
-
-type ShadowSocks struct {
-	server   string
-	name     string
-	obfs     string
-	obfsHost string
-	cipher   core.Cipher
-}
-
-func (ss *ShadowSocks) Name() string {
-	return ss.name
-}
-
-func (ss *ShadowSocks) Type() C.AdapterType {
-	return C.Shadowsocks
-}
-
-func (ss *ShadowSocks) Generator(addr *C.Addr) (adapter C.ProxyAdapter, err error) {
-	c, err := net.Dial("tcp", ss.server)
-	if err != nil {
-		return nil, fmt.Errorf("%s connect error", ss.server)
-	}
-	tcpKeepAlive(c)
-	switch ss.obfs {
-	case "tls":
-		c = obfs.NewTLSObfs(c, ss.obfsHost)
-	case "http":
-		_, port, _ := net.SplitHostPort(ss.server)
-		c = obfs.NewHTTPObfs(c, ss.obfsHost, port)
-	}
-	c = ss.cipher.StreamConn(c)
-	_, err = c.Write(serializesSocksAddr(addr))
-	return &ShadowsocksAdapter{conn: c}, err
-}
-
-func NewShadowSocks(name string, ssURL string, option map[string]string) (*ShadowSocks, error) {
-	var key []byte
-	server, cipher, password, _ := parseURL(ssURL)
-	ciph, err := core.PickCipher(cipher, key, password)
-	if err != nil {
-		return nil, fmt.Errorf("ss %s initialize error: %s", server, err.Error())
-	}
-
-	obfs := ""
-	obfsHost := "bing.com"
-	if value, ok := option["obfs"]; ok {
-		obfs = value
-	}
-
-	if value, ok := option["obfs-host"]; ok {
-		obfsHost = value
-	}
-
-	return &ShadowSocks{
-		server:   server,
-		name:     name,
-		cipher:   ciph,
-		obfs:     obfs,
-		obfsHost: obfsHost,
-	}, nil
-}
-
-func parseURL(s string) (addr, cipher, password string, err error) {
-	u, err := url.Parse(s)
-	if err != nil {
-		return
-	}
-
-	addr = u.Host
-	if u.User != nil {
-		cipher = u.User.Username()
-		password, _ = u.User.Password()
-	}
-	return
-}
-
-func serializesSocksAddr(addr *C.Addr) []byte {
-	var buf [][]byte
-	aType := uint8(addr.AddrType)
-	p, _ := strconv.Atoi(addr.Port)
-	port := []byte{uint8(p >> 8), uint8(p & 0xff)}
-	switch addr.AddrType {
-	case socks.AtypDomainName:
-		len := uint8(len(addr.Host))
-		host := []byte(addr.Host)
-		buf = [][]byte{{aType, len}, host, port}
-	case socks.AtypIPv4:
-		host := addr.IP.To4()
-		buf = [][]byte{{aType}, host, port}
-	case socks.AtypIPv6:
-		host := addr.IP.To16()
-		buf = [][]byte{{aType}, host, port}
-	}
-	return bytes.Join(buf, []byte(""))
-}

adapters/remote/socks5.go

@@ -1,90 +0,0 @@
-package adapters
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
-	"net"
-
-	C "github.com/Dreamacro/clash/constant"
-
-	"github.com/riobard/go-shadowsocks2/socks"
-)
-
-// Socks5Adapter is a shadowsocks adapter
-type Socks5Adapter struct {
-	conn net.Conn
-}
-
-// Close is used to close connection
-func (ss *Socks5Adapter) Close() {
-	ss.conn.Close()
-}
-
-func (ss *Socks5Adapter) Conn() net.Conn {
-	return ss.conn
-}
-
-type Socks5 struct {
-	addr string
-	name string
-}
-
-func (ss *Socks5) Name() string {
-	return ss.name
-}
-
-func (ss *Socks5) Type() C.AdapterType {
-	return C.Socks5
-}
-
-func (ss *Socks5) Generator(addr *C.Addr) (adapter C.ProxyAdapter, err error) {
-	c, err := net.Dial("tcp", ss.addr)
-	if err != nil {
-		return nil, fmt.Errorf("%s connect error", ss.addr)
-	}
-	tcpKeepAlive(c)
-	if err := ss.sharkHand(addr, c); err != nil {
-		return nil, err
-	}
-	return &Socks5Adapter{conn: c}, nil
-}
-
-func (ss *Socks5) sharkHand(addr *C.Addr, rw io.ReadWriter) error {
-	buf := make([]byte, socks.MaxAddrLen)
-
-	// VER, CMD, RSV
-	_, err := rw.Write([]byte{5, 1, 0})
-	if err != nil {
-		return err
-	}
-
-	if _, err := io.ReadFull(rw, buf[:2]); err != nil {
-		return err
-	}
-
-	if buf[0] != 5 {
-		return errors.New("SOCKS version error")
-	} else if buf[1] != 0 {
-		return errors.New("SOCKS need auth")
-	}
-
-	// VER, CMD, RSV, ADDR
-	if _, err := rw.Write(bytes.Join([][]byte{[]byte{5, 1, 0}, serializesSocksAddr(addr)}, []byte(""))); err != nil {
-		return err
-	}
-
-	if _, err := io.ReadFull(rw, buf[:10]); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func NewSocks5(name, addr string) *Socks5 {
-	return &Socks5{
-		addr: addr,
-		name: name,
-	}
-}

adapters/remote/urltest.go

@@ -1,102 +0,0 @@
-package adapters
-
-import (
-	"sync"
-	"time"
-
-	C "github.com/Dreamacro/clash/constant"
-)
-
-type URLTest struct {
-	name    string
-	proxies []C.Proxy
-	rawURL  string
-	fast    C.Proxy
-	delay   time.Duration
-	done    chan struct{}
-}
-
-func (u *URLTest) Name() string {
-	return u.name
-}
-
-func (u *URLTest) Type() C.AdapterType {
-	return C.URLTest
-}
-
-func (u *URLTest) Now() string {
-	return u.fast.Name()
-}
-
-func (u *URLTest) Generator(addr *C.Addr) (adapter C.ProxyAdapter, err error) {
-	return u.fast.Generator(addr)
-}
-
-func (u *URLTest) Close() {
-	u.done <- struct{}{}
-}
-
-func (u *URLTest) loop() {
-	tick := time.NewTicker(u.delay)
-	go u.speedTest()
-Loop:
-	for {
-		select {
-		case <-tick.C:
-			go u.speedTest()
-		case <-u.done:
-			break Loop
-		}
-	}
-}
-
-func (u *URLTest) speedTest() {
-	wg := sync.WaitGroup{}
-	wg.Add(len(u.proxies))
-	c := make(chan interface{})
-	fast := selectFast(c)
-	timer := time.NewTimer(u.delay)
-
-	for _, p := range u.proxies {
-		go func(p C.Proxy) {
-			_, err := DelayTest(p, 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(name string, proxies []C.Proxy, rawURL string, delay time.Duration) (*URLTest, error) {
-	_, err := urlToAddr(rawURL)
-	if err != nil {
-		return nil, err
-	}
-
-	urlTest := &URLTest{
-		name:    name,
-		proxies: proxies[:],
-		rawURL:  rawURL,
-		fast:    proxies[0],
-		delay:   delay,
-		done:    make(chan struct{}),
-	}
-	go urlTest.loop()
-	return urlTest, nil
-}

adapters/remote/vmess.go

@@ -1,95 +0,0 @@
-package adapters
-
-import (
-	"fmt"
-	"net"
-	"strconv"
-	"strings"
-
-	"github.com/Dreamacro/clash/common/vmess"
-	C "github.com/Dreamacro/clash/constant"
-)
-
-// VmessAdapter is a vmess adapter
-type VmessAdapter struct {
-	conn net.Conn
-}
-
-// Close is used to close connection
-func (v *VmessAdapter) Close() {
-	v.conn.Close()
-}
-
-func (v *VmessAdapter) Conn() net.Conn {
-	return v.conn
-}
-
-type Vmess struct {
-	name   string
-	server string
-	client *vmess.Client
-}
-
-func (ss *Vmess) Name() string {
-	return ss.name
-}
-
-func (ss *Vmess) Type() C.AdapterType {
-	return C.Vmess
-}
-
-func (ss *Vmess) Generator(addr *C.Addr) (adapter C.ProxyAdapter, err error) {
-	c, err := net.Dial("tcp", ss.server)
-	if err != nil {
-		return nil, fmt.Errorf("%s connect error", ss.server)
-	}
-	tcpKeepAlive(c)
-	c = ss.client.New(c, parseVmessAddr(addr))
-	return &VmessAdapter{conn: c}, err
-}
-
-func NewVmess(name string, server string, uuid string, alterID uint16, security string, option map[string]string) (*Vmess, error) {
-	security = strings.ToLower(security)
-	client, err := vmess.NewClient(vmess.Config{
-		UUID:     uuid,
-		AlterID:  alterID,
-		Security: security,
-		TLS:      option["tls"] == "true",
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return &Vmess{
-		name:   name,
-		server: server,
-		client: client,
-	}, nil
-}
-
-func parseVmessAddr(info *C.Addr) *vmess.DstAddr {
-	var addrType byte
-	var addr []byte
-	switch info.AddrType {
-	case C.AtypIPv4:
-		addrType = byte(vmess.AtypIPv4)
-		addr = make([]byte, net.IPv4len)
-		copy(addr[:], info.IP.To4())
-	case C.AtypIPv6:
-		addrType = byte(vmess.AtypIPv6)
-		addr = make([]byte, net.IPv6len)
-		copy(addr[:], info.IP.To16())
-	case C.AtypDomainName:
-		addrType = byte(vmess.AtypDomainName)
-		addr = make([]byte, len(info.Host)+1)
-		addr[0] = byte(len(info.Host))
-		copy(addr[1:], []byte(info.Host))
-	}
-
-	port, _ := strconv.Atoi(info.Port)
-	return &vmess.DstAddr{
-		AddrType: addrType,
-		Addr:     addr,
-		Port:     uint(port),
-	}
-}

common/cache/cache.go

@@ -0,0 +1,106 @@
+package cache
+
+import (
+	"runtime"
+	"sync"
+	"time"
+)
+
+// Cache store element with a expired time
+type Cache struct {
+	*cache
+}
+
+type cache struct {
+	mapping sync.Map
+	janitor *janitor
+}
+
+type element struct {
+	Expired time.Time
+	Payload interface{}
+}
+
+// Put element in Cache with its ttl
+func (c *cache) Put(key interface{}, payload interface{}, ttl time.Duration) {
+	c.mapping.Store(key, &element{
+		Payload: payload,
+		Expired: time.Now().Add(ttl),
+	})
+}
+
+// Get element in Cache, and drop when it expired
+func (c *cache) Get(key interface{}) interface{} {
+	item, exist := c.mapping.Load(key)
+	if !exist {
+		return nil
+	}
+	elm := item.(*element)
+	// expired
+	if time.Since(elm.Expired) > 0 {
+		c.mapping.Delete(key)
+		return nil
+	}
+	return elm.Payload
+}
+
+// GetWithExpire element in Cache with Expire Time
+func (c *cache) GetWithExpire(key interface{}) (payload interface{}, expired time.Time) {
+	item, exist := c.mapping.Load(key)
+	if !exist {
+		return
+	}
+	elm := item.(*element)
+	// expired
+	if time.Since(elm.Expired) > 0 {
+		c.mapping.Delete(key)
+		return
+	}
+	return elm.Payload, elm.Expired
+}
+
+func (c *cache) cleanup() {
+	c.mapping.Range(func(k, v interface{}) bool {
+		key := k.(string)
+		elm := v.(*element)
+		if time.Since(elm.Expired) > 0 {
+			c.mapping.Delete(key)
+		}
+		return true
+	})
+}
+
+type janitor struct {
+	interval time.Duration
+	stop     chan struct{}
+}
+
+func (j *janitor) process(c *cache) {
+	ticker := time.NewTicker(j.interval)
+	for {
+		select {
+		case <-ticker.C:
+			c.cleanup()
+		case <-j.stop:
+			ticker.Stop()
+			return
+		}
+	}
+}
+
+func stopJanitor(c *Cache) {
+	c.janitor.stop <- struct{}{}
+}
+
+// New return *Cache
+func New(interval time.Duration) *Cache {
+	j := &janitor{
+		interval: interval,
+		stop:     make(chan struct{}),
+	}
+	c := &cache{janitor: j}
+	go j.process(c)
+	C := &Cache{c}
+	runtime.SetFinalizer(C, stopJanitor)
+	return C
+}

common/cache/cache_test.go

@@ -0,0 +1,70 @@
+package cache
+
+import (
+	"runtime"
+	"testing"
+	"time"
+)
+
+func TestCache_Basic(t *testing.T) {
+	interval := 200 * time.Millisecond
+	ttl := 20 * time.Millisecond
+	c := New(interval)
+	c.Put("int", 1, ttl)
+	c.Put("string", "a", ttl)
+
+	i := c.Get("int")
+	if i.(int) != 1 {
+		t.Error("should recv 1")
+	}
+
+	s := c.Get("string")
+	if s.(string) != "a" {
+		t.Error("should recv 'a'")
+	}
+}
+
+func TestCache_TTL(t *testing.T) {
+	interval := 200 * time.Millisecond
+	ttl := 20 * time.Millisecond
+	c := New(interval)
+	c.Put("int", 1, ttl)
+
+	i := c.Get("int")
+	if i.(int) != 1 {
+		t.Error("should recv 1")
+	}
+
+	time.Sleep(ttl * 2)
+	i = c.Get("int")
+	if i != nil {
+		t.Error("should recv nil")
+	}
+}
+
+func TestCache_AutoCleanup(t *testing.T) {
+	interval := 10 * time.Millisecond
+	ttl := 15 * time.Millisecond
+	c := New(interval)
+	c.Put("int", 1, ttl)
+
+	time.Sleep(ttl * 2)
+	i := c.Get("int")
+	if i != nil {
+		t.Error("should recv nil")
+	}
+}
+
+func TestCache_AutoGC(t *testing.T) {
+	sign := make(chan struct{})
+	go func() {
+		interval := 10 * time.Millisecond
+		ttl := 15 * time.Millisecond
+		c := New(interval)
+		c.Put("int", 1, ttl)
+		sign <- struct{}{}
+	}()
+
+	<-sign
+	runtime.GC()
+}

common/picker/picker.go

@@ -0,0 +1,22 @@
+package picker
+
+import "context"
+
+func SelectFast(ctx context.Context, in <-chan interface{}) <-chan interface{} {
+	out := make(chan interface{})
+	go func() {
+		select {
+		case p, open := <-in:
+			if open {
+				out <- p
+			}
+		case <-ctx.Done():
+		}
+
+		close(out)
+		for range in {
+		}
+	}()
+
+	return out
+}

common/picker/picker_test.go

@@ -0,0 +1,44 @@
+package picker
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+func sleepAndSend(delay int, in chan<- interface{}, input interface{}) {
+	time.Sleep(time.Millisecond * time.Duration(delay))
+	in <- input
+}
+
+func sleepAndClose(delay int, in chan interface{}) {
+	time.Sleep(time.Millisecond * time.Duration(delay))
+	close(in)
+}
+
+func TestPicker_Basic(t *testing.T) {
+	in := make(chan interface{})
+	fast := SelectFast(context.Background(), in)
+	go sleepAndSend(20, in, 1)
+	go sleepAndSend(30, in, 2)
+	go sleepAndClose(40, in)
+
+	number, exist := <-fast
+	if !exist || number != 1 {
+		t.Error("should recv 1", exist, number)
+	}
+}
+
+func TestPicker_Timeout(t *testing.T) {
+	in := make(chan interface{})
+	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*5)
+	defer cancel()
+	fast := SelectFast(ctx, in)
+	go sleepAndSend(20, in, 1)
+	go sleepAndClose(30, in)
+
+	_, exist := <-fast
+	if exist {
+		t.Error("should recv false")
+	}
+}

common/structure/structure.go

@@ -0,0 +1,239 @@
+package structure
+
+// references: https://github.com/mitchellh/mapstructure
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// Option is the configuration that is used to create a new decoder
+type Option struct {
+	TagName          string
+	WeaklyTypedInput bool
+}
+
+// Decoder is the core of structure
+type Decoder struct {
+	option *Option
+}
+
+// NewDecoder return a Decoder by Option
+func NewDecoder(option Option) *Decoder {
+	if option.TagName == "" {
+		option.TagName = "structure"
+	}
+	return &Decoder{option: &option}
+}
+
+// Decode transform a map[string]interface{} to a struct
+func (d *Decoder) Decode(src map[string]interface{}, dst interface{}) error {
+	if reflect.TypeOf(dst).Kind() != reflect.Ptr {
+		return fmt.Errorf("Decode must recive a ptr struct")
+	}
+	t := reflect.TypeOf(dst).Elem()
+	v := reflect.ValueOf(dst).Elem()
+	for idx := 0; idx < v.NumField(); idx++ {
+		field := t.Field(idx)
+
+		tag := field.Tag.Get(d.option.TagName)
+		str := strings.SplitN(tag, ",", 2)
+		key := str[0]
+		omitempty := false
+		if len(str) > 1 {
+			omitempty = str[1] == "omitempty"
+		}
+
+		value, ok := src[key]
+		if !ok {
+			if omitempty {
+				continue
+			}
+			return fmt.Errorf("key %s missing", key)
+		}
+
+		err := d.decode(key, value, v.Field(idx))
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (d *Decoder) decode(name string, data interface{}, val reflect.Value) error {
+	switch val.Kind() {
+	case reflect.Int:
+		return d.decodeInt(name, data, val)
+	case reflect.String:
+		return d.decodeString(name, data, val)
+	case reflect.Bool:
+		return d.decodeBool(name, data, val)
+	case reflect.Slice:
+		return d.decodeSlice(name, data, val)
+	case reflect.Map:
+		return d.decodeMap(name, data, val)
+	case reflect.Interface:
+		return d.setInterface(name, data, val)
+	default:
+		return fmt.Errorf("type %s not support", val.Kind().String())
+	}
+}
+
+func (d *Decoder) decodeInt(name string, data interface{}, val reflect.Value) (err error) {
+	dataVal := reflect.ValueOf(data)
+	kind := dataVal.Kind()
+	switch {
+	case kind == reflect.Int:
+		val.SetInt(dataVal.Int())
+	case kind == reflect.String && d.option.WeaklyTypedInput:
+		var i int64
+		i, err = strconv.ParseInt(dataVal.String(), 0, val.Type().Bits())
+		if err == nil {
+			val.SetInt(i)
+		} else {
+			err = fmt.Errorf("cannot parse '%s' as int: %s", name, err)
+		}
+	default:
+		err = fmt.Errorf(
+			"'%s' expected type '%s', got unconvertible type '%s'",
+			name, val.Type(), dataVal.Type(),
+		)
+	}
+	return err
+}
+
+func (d *Decoder) decodeString(name string, data interface{}, val reflect.Value) (err error) {
+	dataVal := reflect.ValueOf(data)
+	kind := dataVal.Kind()
+	switch {
+	case kind == reflect.String:
+		val.SetString(dataVal.String())
+	case kind == reflect.Int && d.option.WeaklyTypedInput:
+		val.SetString(strconv.FormatInt(dataVal.Int(), 10))
+	default:
+		err = fmt.Errorf(
+			"'%s' expected type'%s', got unconvertible type '%s'",
+			name, val.Type(), dataVal.Type(),
+		)
+	}
+	return err
+}
+
+func (d *Decoder) decodeBool(name string, data interface{}, val reflect.Value) (err error) {
+	dataVal := reflect.ValueOf(data)
+	kind := dataVal.Kind()
+	switch {
+	case kind == reflect.Bool:
+		val.SetBool(dataVal.Bool())
+	case kind == reflect.Int && d.option.WeaklyTypedInput:
+		val.SetBool(dataVal.Int() != 0)
+	default:
+		err = fmt.Errorf(
+			"'%s' expected type'%s', got unconvertible type '%s'",
+			name, val.Type(), dataVal.Type(),
+		)
+	}
+	return err
+}
+
+func (d *Decoder) decodeSlice(name string, data interface{}, val reflect.Value) error {
+	dataVal := reflect.Indirect(reflect.ValueOf(data))
+	valType := val.Type()
+	valElemType := valType.Elem()
+
+	if dataVal.Kind() != reflect.Slice {
+		return fmt.Errorf("'%s' is not a slice", name)
+	}
+
+	valSlice := val
+	for i := 0; i < dataVal.Len(); i++ {
+		currentData := dataVal.Index(i).Interface()
+		for valSlice.Len() <= i {
+			valSlice = reflect.Append(valSlice, reflect.Zero(valElemType))
+		}
+		currentField := valSlice.Index(i)
+
+		fieldName := fmt.Sprintf("%s[%d]", name, i)
+		if err := d.decode(fieldName, currentData, currentField); err != nil {
+			return err
+		}
+	}
+
+	val.Set(valSlice)
+	return nil
+}
+
+func (d *Decoder) decodeMap(name string, data interface{}, val reflect.Value) error {
+	valType := val.Type()
+	valKeyType := valType.Key()
+	valElemType := valType.Elem()
+
+	valMap := val
+
+	if valMap.IsNil() {
+		mapType := reflect.MapOf(valKeyType, valElemType)
+		valMap = reflect.MakeMap(mapType)
+	}
+
+	dataVal := reflect.Indirect(reflect.ValueOf(data))
+	if dataVal.Kind() != reflect.Map {
+		return fmt.Errorf("'%s' expected a map, got '%s'", name, dataVal.Kind())
+	}
+
+	return d.decodeMapFromMap(name, dataVal, val, valMap)
+}
+
+func (d *Decoder) decodeMapFromMap(name string, dataVal reflect.Value, val reflect.Value, valMap reflect.Value) error {
+	valType := val.Type()
+	valKeyType := valType.Key()
+	valElemType := valType.Elem()
+
+	errors := make([]string, 0)
+
+	if dataVal.Len() == 0 {
+		if dataVal.IsNil() {
+			if !val.IsNil() {
+				val.Set(dataVal)
+			}
+		} else {
+			val.Set(valMap)
+		}
+
+		return nil
+	}
+
+	for _, k := range dataVal.MapKeys() {
+		fieldName := fmt.Sprintf("%s[%s]", name, k)
+
+		currentKey := reflect.Indirect(reflect.New(valKeyType))
+		if err := d.decode(fieldName, k.Interface(), currentKey); err != nil {
+			errors = append(errors, err.Error())
+			continue
+		}
+
+		v := dataVal.MapIndex(k).Interface()
+		currentVal := reflect.Indirect(reflect.New(valElemType))
+		if err := d.decode(fieldName, v, currentVal); err != nil {
+			errors = append(errors, err.Error())
+			continue
+		}
+
+		valMap.SetMapIndex(currentKey, currentVal)
+	}
+
+	val.Set(valMap)
+
+	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)
+	return nil
+}

common/structure/structure_test.go

@@ -0,0 +1,141 @@
+package structure
+
+import (
+	"reflect"
+	"testing"
+)
+
+var decoder = NewDecoder(Option{TagName: "test"})
+var weakTypeDecoder = NewDecoder(Option{TagName: "test", WeaklyTypedInput: true})
+
+type Baz struct {
+	Foo int    `test:"foo"`
+	Bar string `test:"bar"`
+}
+
+type BazSlice struct {
+	Foo int      `test:"foo"`
+	Bar []string `test:"bar"`
+}
+
+type BazOptional struct {
+	Foo int    `test:"foo,omitempty"`
+	Bar string `test:"bar,omitempty"`
+}
+
+func TestStructure_Basic(t *testing.T) {
+	rawMap := map[string]interface{}{
+		"foo":   1,
+		"bar":   "test",
+		"extra": false,
+	}
+
+	goal := &Baz{
+		Foo: 1,
+		Bar: "test",
+	}
+
+	s := &Baz{}
+	err := decoder.Decode(rawMap, s)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if !reflect.DeepEqual(s, goal) {
+		t.Fatalf("bad: %#v", s)
+	}
+}
+
+func TestStructure_Slice(t *testing.T) {
+	rawMap := map[string]interface{}{
+		"foo": 1,
+		"bar": []string{"one", "two"},
+	}
+
+	goal := &BazSlice{
+		Foo: 1,
+		Bar: []string{"one", "two"},
+	}
+
+	s := &BazSlice{}
+	err := decoder.Decode(rawMap, s)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if !reflect.DeepEqual(s, goal) {
+		t.Fatalf("bad: %#v", s)
+	}
+}
+
+func TestStructure_Optional(t *testing.T) {
+	rawMap := map[string]interface{}{
+		"foo": 1,
+	}
+
+	goal := &BazOptional{
+		Foo: 1,
+	}
+
+	s := &BazOptional{}
+	err := decoder.Decode(rawMap, s)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if !reflect.DeepEqual(s, goal) {
+		t.Fatalf("bad: %#v", s)
+	}
+}
+
+func TestStructure_MissingKey(t *testing.T) {
+	rawMap := map[string]interface{}{
+		"foo": 1,
+	}
+
+	s := &Baz{}
+	err := decoder.Decode(rawMap, s)
+	if err == nil {
+		t.Fatalf("should throw error: %#v", s)
+	}
+}
+
+func TestStructure_ParamError(t *testing.T) {
+	rawMap := map[string]interface{}{}
+	s := Baz{}
+	err := decoder.Decode(rawMap, s)
+	if err == nil {
+		t.Fatalf("should throw error: %#v", s)
+	}
+}
+
+func TestStructure_SliceTypeError(t *testing.T) {
+	rawMap := map[string]interface{}{
+		"foo": 1,
+		"bar": []int{1, 2},
+	}
+
+	s := &BazSlice{}
+	err := decoder.Decode(rawMap, s)
+	if err == nil {
+		t.Fatalf("should throw error: %#v", s)
+	}
+}
+
+func TestStructure_WeakType(t *testing.T) {
+	rawMap := map[string]interface{}{
+		"foo": "1",
+		"bar": []int{1},
+	}
+
+	goal := &BazSlice{
+		Foo: 1,
+		Bar: []string{"1"},
+	}
+
+	s := &BazSlice{}
+	err := weakTypeDecoder.Decode(rawMap, s)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if !reflect.DeepEqual(s, goal) {
+		t.Fatalf("bad: %#v", s)
+	}
+}

common/vmess/vmess.go

@@ -1,117 +0,0 @@
-package vmess
-
-import (
-	"crypto/tls"
-	"fmt"
-	"math/rand"
-	"net"
-	"runtime"
-
-	"github.com/gofrs/uuid"
-)
-
-// Version of vmess
-const Version byte = 1
-
-// Request Options
-const (
-	OptionChunkStream  byte = 1
-	OptionChunkMasking byte = 4
-)
-
-// Security type vmess
-type Security = byte
-
-// Cipher types
-const (
-	SecurityAES128GCM        Security = 3
-	SecurityCHACHA20POLY1305 Security = 4
-	SecurityNone             Security = 5
-)
-
-// CipherMapping return
-var CipherMapping = map[string]byte{
-	"none":              SecurityNone,
-	"aes-128-gcm":       SecurityAES128GCM,
-	"chacha20-poly1305": SecurityCHACHA20POLY1305,
-}
-
-var tlsConfig = &tls.Config{
-	InsecureSkipVerify: true,
-}
-
-// Command types
-const (
-	CommandTCP byte = 1
-	CommandUDP byte = 2
-)
-
-// Addr types
-const (
-	AtypIPv4       byte = 1
-	AtypDomainName byte = 2
-	AtypIPv6       byte = 3
-)
-
-// DstAddr store destination address
-type DstAddr struct {
-	AddrType byte
-	Addr     []byte
-	Port     uint
-}
-
-// Client is vmess connection generator
-type Client struct {
-	user     []*ID
-	uuid     *uuid.UUID
-	security Security
-	tls      bool
-}
-
-// Config of vmess
-type Config struct {
-	UUID     string
-	AlterID  uint16
-	Security string
-	TLS      bool
-}
-
-// New return a Conn with net.Conn and DstAddr
-func (c *Client) New(conn net.Conn, dst *DstAddr) net.Conn {
-	r := rand.Intn(len(c.user))
-	if c.tls {
-		conn = tls.Client(conn, tlsConfig)
-	}
-	return newConn(conn, c.user[r], dst, c.security)
-}
-
-// NewClient return Client instance
-func NewClient(config Config) (*Client, error) {
-	uid, err := uuid.FromString(config.UUID)
-	if err != nil {
-		return nil, err
-	}
-
-	var security Security
-	switch config.Security {
-	case "aes-128-gcm":
-		security = SecurityAES128GCM
-	case "chacha20-poly1305":
-		security = SecurityCHACHA20POLY1305
-	case "none":
-		security = SecurityNone
-	case "auto":
-		security = SecurityCHACHA20POLY1305
-		if runtime.GOARCH == "amd64" || runtime.GOARCH == "s390x" || runtime.GOARCH == "arm64" {
-			security = SecurityAES128GCM
-		}
-	default:
-		return nil, fmt.Errorf("Unknown security type: %s", config.Security)
-	}
-	return &Client{
-		user:     newAlterIDs(newID(&uid), config.AlterID),
-		uuid:     &uid,
-		security: security,
-		tls:      config.TLS,
-	}, nil
-}

component/simple-obfs/tls.go

@@ -14,6 +14,10 @@ func init() {
 	rand.Seed(time.Now().Unix())
 }
 
+const (
+	chunkSize = 1 << 14 // 2 ** 14 == 16 * 1024
+)
+
 var bufPool = sync.Pool{New: func() interface{} { return make([]byte, 2048) }}
 
 // TLSObfs is shadowsocks tls simple-obfs implementation
@@ -75,8 +79,23 @@ func (to *TLSObfs) Read(b []byte) (int, error) {
 	// type + ver = 3
 	return to.read(b, 3)
 }
-
 func (to *TLSObfs) Write(b []byte) (int, error) {
+	length := len(b)
+	for i := 0; i < length; i += chunkSize {
+		end := i + chunkSize
+		if end > length {
+			end = length
+		}
+
+		n, err := to.write(b[i:end])
+		if err != nil {
+			return n, err
+		}
+	}
+	return length, nil
+}
+
+func (to *TLSObfs) write(b []byte) (int, error) {
 	if to.firstRequest {
 		helloMsg := makeClientHelloMsg(b, to.server)
 		_, err := to.Conn.Write(helloMsg)
@@ -107,9 +126,8 @@ func NewTLSObfs(conn net.Conn, server string) net.Conn {
 }
 
 func makeClientHelloMsg(data []byte, server string) []byte {
-	random := make([]byte, 32)
+	random := make([]byte, 28)
 	sessionID := make([]byte, 32)
-	size := make([]byte, 2)
 	rand.Read(random)
 	rand.Read(sessionID)
 
@@ -124,12 +142,12 @@ func makeClientHelloMsg(data []byte, server string) []byte {
 
 	// clientHello, length, TLS 1.2 version
 	buf.WriteByte(1)
-	binary.BigEndian.PutUint16(size, uint16(208+len(data)+len(server)))
 	buf.WriteByte(0)
-	buf.Write(size)
+	binary.Write(buf, binary.BigEndian, uint16(208+len(data)+len(server)))
 	buf.Write([]byte{0x03, 0x03})
 
-	// random, sid len, sid
+	// random with timestamp, sid len, sid
+	binary.Write(buf, binary.BigEndian, uint32(time.Now().Unix()))
 	buf.Write(random)
 	buf.WriteByte(32)
 	buf.Write(sessionID)
@@ -147,24 +165,19 @@ func makeClientHelloMsg(data []byte, server string) []byte {
 	buf.Write([]byte{0x01, 0x00})
 
 	// extension length
-	binary.BigEndian.PutUint16(size, uint16(79+len(data)+len(server)))
+	binary.Write(buf, binary.BigEndian, uint16(79+len(data)+len(server)))
-	buf.Write(size)
 
 	// session ticket
 	buf.Write([]byte{0x00, 0x23})
-	binary.BigEndian.PutUint16(size, uint16(len(data)))
+	binary.Write(buf, binary.BigEndian, uint16(len(data)))
-	buf.Write(size)
 	buf.Write(data)
 
 	// server name
 	buf.Write([]byte{0x00, 0x00})
-	binary.BigEndian.PutUint16(size, uint16(len(server)+5))
+	binary.Write(buf, binary.BigEndian, uint16(len(server)+5))
-	buf.Write(size)
+	binary.Write(buf, binary.BigEndian, uint16(len(server)+3))
-	binary.BigEndian.PutUint16(size, uint16(len(server)+3))
-	buf.Write(size)
 	buf.WriteByte(0)
-	binary.BigEndian.PutUint16(size, uint16(len(server)))
+	binary.Write(buf, binary.BigEndian, uint16(len(server)))
-	buf.Write(size)
 	buf.Write([]byte(server))
 
 	// ec_point

component/v2ray-plugin/mux.go

@@ -0,0 +1,173 @@
+package obfs
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"io"
+	"net"
+)
+
+type SessionStatus = byte
+
+const (
+	SessionStatusNew       SessionStatus = 0x01
+	SessionStatusKeep      SessionStatus = 0x02
+	SessionStatusEnd       SessionStatus = 0x03
+	SessionStatusKeepAlive SessionStatus = 0x04
+)
+
+const (
+	OptionNone  = byte(0x00)
+	OptionData  = byte(0x01)
+	OptionError = byte(0x02)
+)
+
+type MuxOption struct {
+	ID   [2]byte
+	Port uint16
+	Host string
+	Type string
+}
+
+// Mux is an mux-compatible client for v2ray-plugin, not a complete implementation
+type Mux struct {
+	net.Conn
+	buf    bytes.Buffer
+	id     [2]byte
+	length [2]byte
+	status [2]byte
+	otb    []byte
+	remain int
+}
+
+func (m *Mux) Read(b []byte) (int, error) {
+	if m.remain != 0 {
+		length := m.remain
+		if len(b) < m.remain {
+			length = len(b)
+		}
+
+		n, err := m.Conn.Read(b[:length])
+		if err != nil {
+			return 0, err
+		}
+		m.remain = m.remain - n
+		return n, nil
+	}
+
+	for {
+		_, err := io.ReadFull(m.Conn, m.length[:])
+		if err != nil {
+			return 0, err
+		}
+		length := binary.BigEndian.Uint16(m.length[:])
+		if length > 512 {
+			return 0, errors.New("invalid metalen")
+		}
+
+		_, err = io.ReadFull(m.Conn, m.id[:])
+		if err != nil {
+			return 0, err
+		}
+
+		_, err = m.Conn.Read(m.status[:])
+		if err != nil {
+			return 0, err
+		}
+
+		opcode := m.status[0]
+		if opcode == SessionStatusKeepAlive {
+			continue
+		}
+
+		opts := m.status[1]
+
+		if opts != OptionData {
+			continue
+		}
+
+		_, err = io.ReadFull(m.Conn, m.length[:])
+		if err != nil {
+			return 0, err
+		}
+		dataLen := int(binary.BigEndian.Uint16(m.length[:]))
+		m.remain = dataLen
+		if dataLen > len(b) {
+			dataLen = len(b)
+		}
+
+		n, err := m.Conn.Read(b[:dataLen])
+		m.remain -= n
+		return n, err
+	}
+}
+
+func (m *Mux) Write(b []byte) (int, error) {
+	if m.otb != nil {
+		// create a sub connection
+		if _, err := m.Conn.Write(m.otb); err != nil {
+			return 0, err
+		}
+		m.otb = nil
+	}
+	m.buf.Reset()
+	binary.Write(&m.buf, binary.BigEndian, uint16(4))
+	m.buf.Write(m.id[:])
+	m.buf.WriteByte(SessionStatusKeep)
+	m.buf.WriteByte(OptionData)
+	binary.Write(&m.buf, binary.BigEndian, uint16(len(b)))
+	m.buf.Write(b)
+
+	return m.Conn.Write(m.buf.Bytes())
+}
+
+func (m *Mux) Close() error {
+	_, err := m.Conn.Write([]byte{0x0, 0x4, m.id[0], m.id[1], SessionStatusEnd, OptionNone})
+	if err != nil {
+		return err
+	}
+	return m.Conn.Close()
+}
+
+func NewMux(conn net.Conn, option MuxOption) *Mux {
+	buf := &bytes.Buffer{}
+
+	// fill empty length
+	buf.Write([]byte{0x0, 0x0})
+	buf.Write(option.ID[:])
+	buf.WriteByte(SessionStatusNew)
+	buf.WriteByte(OptionNone)
+
+	// tcp
+	netType := byte(0x1)
+	if option.Type == "udp" {
+		netType = byte(0x2)
+	}
+	buf.WriteByte(netType)
+
+	// port
+	binary.Write(buf, binary.BigEndian, option.Port)
+
+	// address
+	ip := net.ParseIP(option.Host)
+	if ip == nil {
+		buf.WriteByte(0x2)
+		buf.WriteString(option.Host)
+	} else if ipv4 := ip.To4(); ipv4 != nil {
+		buf.WriteByte(0x1)
+		buf.Write(ipv4)
+	} else {
+		buf.WriteByte(0x3)
+		buf.Write(ip.To16())
+	}
+
+	metadata := buf.Bytes()
+	binary.BigEndian.PutUint16(metadata[:2], uint16(len(metadata)-2))
+
+	return &Mux{
+		Conn: conn,
+		id:   option.ID,
+		otb:  metadata,
+	}
+}

component/v2ray-plugin/websocket.go

@@ -0,0 +1,37 @@
+package obfs
+
+import (
+	"crypto/tls"
+	"net"
+
+	"github.com/Dreamacro/clash/component/vmess"
+)
+
+// WebsocketOption is options of websocket obfs
+type WebsocketOption struct {
+	Host      string
+	Path      string
+	TLSConfig *tls.Config
+}
+
+// NewWebsocketObfs return a HTTPObfs
+func NewWebsocketObfs(conn net.Conn, option *WebsocketOption) (net.Conn, error) {
+	config := &vmess.WebsocketConfig{
+		Host:      option.Host,
+		Path:      option.Path,
+		TLS:       option.TLSConfig != nil,
+		TLSConfig: option.TLSConfig,
+	}
+
+	var err error
+	conn, err = vmess.NewWebsocketConn(conn, config)
+	if err != nil {
+		return nil, err
+	}
+	conn = NewMux(conn, MuxOption{
+		ID:   [2]byte{0, 0},
+		Host: "127.0.0.1",
+		Port: 0,
+	})
+	return conn, nil
+}

component/vmess/conn.go

@@ -65,11 +65,10 @@ func (vc *Conn) Read(b []byte) (int, error) {
 }
 
 func (vc *Conn) sendRequest() error {
-	timestamp := make([]byte, 8)
+	timestamp := time.Now()
-	binary.BigEndian.PutUint64(timestamp, uint64(time.Now().UTC().Unix()))
 
 	h := hmac.New(md5.New, vc.id.UUID.Bytes())
-	h.Write(timestamp)
+	binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
 	_, err := vc.Conn.Write(h.Sum(nil))
 	if err != nil {
 		return err
@@ -111,7 +110,7 @@ func (vc *Conn) sendRequest() error {
 		return err
 	}
 
-	stream := cipher.NewCFBEncrypter(block, hashTimestamp(time.Now().UTC()))
+	stream := cipher.NewCFBEncrypter(block, hashTimestamp(timestamp))
 	stream.XORKeyStream(buf.Bytes(), buf.Bytes())
 	_, err = vc.Conn.Write(buf.Bytes())
 	return err
@@ -145,7 +144,7 @@ func (vc *Conn) recvResponse() error {
 func hashTimestamp(t time.Time) []byte {
 	md5hash := md5.New()
 	ts := make([]byte, 8)
-	binary.BigEndian.PutUint64(ts, uint64(t.UTC().Unix()))
+	binary.BigEndian.PutUint64(ts, uint64(t.Unix()))
 	md5hash.Write(ts)
 	md5hash.Write(ts)
 	md5hash.Write(ts)

component/vmess/user.go

@@ -50,5 +50,6 @@ func newAlterIDs(primary *ID, alterIDCount uint16) []*ID {
 		alterIDs[idx] = &ID{UUID: newid, CmdKey: primary.CmdKey[:]}
 		prevID = newid
 	}
+	alterIDs = append(alterIDs, primary)
 	return alterIDs
 }

component/vmess/vmess.go

@@ -0,0 +1,175 @@
+package vmess
+
+import (
+	"crypto/tls"
+	"fmt"
+	"math/rand"
+	"net"
+	"runtime"
+	"sync"
+
+	"github.com/gofrs/uuid"
+)
+
+// Version of vmess
+const Version byte = 1
+
+// Request Options
+const (
+	OptionChunkStream  byte = 1
+	OptionChunkMasking byte = 4
+)
+
+// Security type vmess
+type Security = byte
+
+// Cipher types
+const (
+	SecurityAES128GCM        Security = 3
+	SecurityCHACHA20POLY1305 Security = 4
+	SecurityNone             Security = 5
+)
+
+// CipherMapping return
+var CipherMapping = map[string]byte{
+	"none":              SecurityNone,
+	"aes-128-gcm":       SecurityAES128GCM,
+	"chacha20-poly1305": SecurityCHACHA20POLY1305,
+}
+
+var (
+	clientSessionCache tls.ClientSessionCache
+	once               sync.Once
+)
+
+// Command types
+const (
+	CommandTCP byte = 1
+	CommandUDP byte = 2
+)
+
+// Addr types
+const (
+	AtypIPv4       byte = 1
+	AtypDomainName byte = 2
+	AtypIPv6       byte = 3
+)
+
+// DstAddr store destination address
+type DstAddr struct {
+	AddrType byte
+	Addr     []byte
+	Port     uint
+}
+
+// Client is vmess connection generator
+type Client struct {
+	user      []*ID
+	uuid      *uuid.UUID
+	security  Security
+	tls       bool
+	host      string
+	wsConfig  *WebsocketConfig
+	tlsConfig *tls.Config
+}
+
+// Config of vmess
+type Config struct {
+	UUID             string
+	AlterID          uint16
+	Security         string
+	TLS              bool
+	HostName         string
+	Port             string
+	NetWork          string
+	WebSocketPath    string
+	WebSocketHeaders map[string]string
+	SkipCertVerify   bool
+	SessionCacahe    tls.ClientSessionCache
+}
+
+// New return a Conn with net.Conn and DstAddr
+func (c *Client) New(conn net.Conn, dst *DstAddr) (net.Conn, error) {
+	var err error
+	r := rand.Intn(len(c.user))
+	if c.wsConfig != nil {
+		conn, err = NewWebsocketConn(conn, c.wsConfig)
+		if err != nil {
+			return nil, err
+		}
+	} else if c.tls {
+		conn = tls.Client(conn, c.tlsConfig)
+	}
+	return newConn(conn, c.user[r], dst, c.security), nil
+}
+
+// NewClient return Client instance
+func NewClient(config Config) (*Client, error) {
+	uid, err := uuid.FromString(config.UUID)
+	if err != nil {
+		return nil, err
+	}
+
+	var security Security
+	switch config.Security {
+	case "aes-128-gcm":
+		security = SecurityAES128GCM
+	case "chacha20-poly1305":
+		security = SecurityCHACHA20POLY1305
+	case "none":
+		security = SecurityNone
+	case "auto":
+		security = SecurityCHACHA20POLY1305
+		if runtime.GOARCH == "amd64" || runtime.GOARCH == "s390x" || runtime.GOARCH == "arm64" {
+			security = SecurityAES128GCM
+		}
+	default:
+		return nil, fmt.Errorf("Unknown security type: %s", config.Security)
+	}
+
+	if config.NetWork != "" && config.NetWork != "ws" {
+		return nil, fmt.Errorf("Unknown network type: %s", config.NetWork)
+	}
+
+	host := net.JoinHostPort(config.HostName, config.Port)
+
+	var tlsConfig *tls.Config
+	if config.TLS {
+		tlsConfig = &tls.Config{
+			ServerName:         config.HostName,
+			InsecureSkipVerify: config.SkipCertVerify,
+			ClientSessionCache: config.SessionCacahe,
+		}
+		if tlsConfig.ClientSessionCache == nil {
+			tlsConfig.ClientSessionCache = getClientSessionCache()
+		}
+	}
+
+	var wsConfig *WebsocketConfig
+	if config.NetWork == "ws" {
+		wsConfig = &WebsocketConfig{
+			Host:      host,
+			Path:      config.WebSocketPath,
+			Headers:   config.WebSocketHeaders,
+			TLS:       config.TLS,
+			TLSConfig: tlsConfig,
+		}
+	}
+
+	return &Client{
+		user:      newAlterIDs(newID(&uid), config.AlterID),
+		uuid:      &uid,
+		security:  security,
+		tls:       config.TLS,
+		host:      host,
+		wsConfig:  wsConfig,
+		tlsConfig: tlsConfig,
+	}, nil
+}
+
+func getClientSessionCache() tls.ClientSessionCache {
+	once.Do(func() {
+		clientSessionCache = tls.NewLRUClientSessionCache(128)
+	})
+	return clientSessionCache
+}

component/vmess/websocket.go

@@ -0,0 +1,152 @@
+package vmess
+
+import (
+	"crypto/tls"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+type websocketConn struct {
+	conn       *websocket.Conn
+	reader     io.Reader
+	remoteAddr net.Addr
+}
+
+type WebsocketConfig struct {
+	Host      string
+	Path      string
+	Headers   map[string]string
+	TLS       bool
+	TLSConfig *tls.Config
+}
+
+// Read implements net.Conn.Read()
+func (wsc *websocketConn) Read(b []byte) (int, error) {
+	for {
+		reader, err := wsc.getReader()
+		if err != nil {
+			return 0, err
+		}
+
+		nBytes, err := reader.Read(b)
+		if err == io.EOF {
+			wsc.reader = nil
+			continue
+		}
+		return nBytes, err
+	}
+}
+
+// Write implements io.Writer.
+func (wsc *websocketConn) Write(b []byte) (int, error) {
+	if err := wsc.conn.WriteMessage(websocket.BinaryMessage, b); err != nil {
+		return 0, err
+	}
+	return len(b), nil
+}
+
+func (wsc *websocketConn) Close() error {
+	var errors []string
+	if err := wsc.conn.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""), time.Now().Add(time.Second*5)); err != nil {
+		errors = append(errors, err.Error())
+	}
+	if err := wsc.conn.Close(); err != nil {
+		errors = append(errors, err.Error())
+	}
+	if len(errors) > 0 {
+		return fmt.Errorf("Failed to close connection: %s", strings.Join(errors, ","))
+	}
+	return nil
+}
+
+func (wsc *websocketConn) getReader() (io.Reader, error) {
+	if wsc.reader != nil {
+		return wsc.reader, nil
+	}
+
+	_, reader, err := wsc.conn.NextReader()
+	if err != nil {
+		return nil, err
+	}
+	wsc.reader = reader
+	return reader, nil
+}
+
+func (wsc *websocketConn) LocalAddr() net.Addr {
+	return wsc.conn.LocalAddr()
+}
+
+func (wsc *websocketConn) RemoteAddr() net.Addr {
+	return wsc.remoteAddr
+}
+
+func (wsc *websocketConn) SetDeadline(t time.Time) error {
+	if err := wsc.SetReadDeadline(t); err != nil {
+		return err
+	}
+	return wsc.SetWriteDeadline(t)
+}
+
+func (wsc *websocketConn) SetReadDeadline(t time.Time) error {
+	return wsc.conn.SetReadDeadline(t)
+}
+
+func (wsc *websocketConn) SetWriteDeadline(t time.Time) error {
+	return wsc.conn.SetWriteDeadline(t)
+}
+
+func NewWebsocketConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
+	dialer := &websocket.Dialer{
+		NetDial: func(network, addr string) (net.Conn, error) {
+			return conn, nil
+		},
+		ReadBufferSize:   4 * 1024,
+		WriteBufferSize:  4 * 1024,
+		HandshakeTimeout: time.Second * 8,
+	}
+
+	scheme := "ws"
+	if c.TLS {
+		scheme = "wss"
+		dialer.TLSClientConfig = c.TLSConfig
+	}
+
+	host, port, _ := net.SplitHostPort(c.Host)
+	if (scheme == "ws" && port != "80") || (scheme == "wss" && port != "443") {
+		host = c.Host
+	}
+
+	uri := url.URL{
+		Scheme: scheme,
+		Host:   host,
+		Path:   c.Path,
+	}
+
+	headers := http.Header{}
+	if c.Headers != nil {
+		for k, v := range c.Headers {
+			headers.Set(k, v)
+		}
+	}
+
+	wsConn, resp, err := dialer.Dial(uri.String(), headers)
+	if err != nil {
+		var reason string
+		if resp != nil {
+			reason = resp.Status
+		}
+		return nil, fmt.Errorf("Dial %s error: %s", host, reason)
+	}
+
+	return &websocketConn{
+		conn:       wsConn,
+		remoteAddr: conn.RemoteAddr(),
+	}, nil
+}

config/config.go

@@ -1,402 +1,427 @@
 package config
 
 import (
-	"bufio"
 	"fmt"
+	"io/ioutil"
+	"net"
+	"net/url"
 	"os"
-	"strconv"
+	"path/filepath"
 	"strings"
-	"sync"
-	"time"
 
-	"github.com/Dreamacro/clash/adapters/remote"
+	adapters "github.com/Dreamacro/clash/adapters/outbound"
+	"github.com/Dreamacro/clash/common/structure"
 	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/observable"
+	"github.com/Dreamacro/clash/dns"
+	"github.com/Dreamacro/clash/log"
 	R "github.com/Dreamacro/clash/rules"
+	T "github.com/Dreamacro/clash/tunnel"
 
-	log "github.com/sirupsen/logrus"
+	yaml "gopkg.in/yaml.v2"
-	"gopkg.in/ini.v1"
-)
-
-var (
-	config *Config
-	once   sync.Once
 )
 
 // General config
 type General struct {
-	Port      int
+	Port               int          `json:"port"`
-	SocksPort int
+	SocksPort          int          `json:"socks-port"`
-	RedirPort int
+	RedirPort          int          `json:"redir-port"`
-	AllowLan  bool
+	AllowLan           bool         `json:"allow-lan"`
-	Mode      Mode
+	Mode               T.Mode       `json:"mode"`
-	LogLevel  C.LogLevel
+	LogLevel           log.LogLevel `json:"log-level"`
+	ExternalController string       `json:"-"`
+	ExternalUI         string       `json:"-"`
+	Secret             string       `json:"-"`
 }
 
-// ProxyConfig is update proxy schema
+// DNS config
-type ProxyConfig struct {
+type DNS struct {
-	Port      *int
+	Enable       bool             `yaml:"enable"`
-	SocksPort *int
+	IPv6         bool             `yaml:"ipv6"`
-	RedirPort *int
+	NameServer   []dns.NameServer `yaml:"nameserver"`
-	AllowLan  *bool
+	Fallback     []dns.NameServer `yaml:"fallback"`
+	Listen       string           `yaml:"listen"`
+	EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
 }
 
 // Config is clash config manager
 type Config struct {
-	general    *General
+	General *General
-	rules      []C.Rule
+	DNS     *DNS
-	proxies    map[string]C.Proxy
+	Rules   []C.Rule
-	lastUpdate time.Time
+	Proxies map[string]C.Proxy
-
-	event      chan<- interface{}
-	reportCh   chan interface{}
-	observable *observable.Observable
 }
 
-// Event is event of clash config
+type rawDNS struct {
-type Event struct {
+	Enable       bool             `yaml:"enable"`
-	Type    string
+	IPv6         bool             `yaml:"ipv6"`
-	Payload interface{}
+	NameServer   []string         `yaml:"nameserver"`
+	Fallback     []string         `yaml:"fallback"`
+	Listen       string           `yaml:"listen"`
+	EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
 }
 
-// Subscribe config stream
+type rawConfig struct {
-func (c *Config) Subscribe() observable.Subscription {
+	Port               int          `yaml:"port"`
-	sub, _ := c.observable.Subscribe()
+	SocksPort          int          `yaml:"socks-port"`
-	return sub
+	RedirPort          int          `yaml:"redir-port"`
+	AllowLan           bool         `yaml:"allow-lan"`
+	Mode               T.Mode       `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"`
+	Proxy      []map[string]interface{} `yaml:"Proxy"`
+	ProxyGroup []map[string]interface{} `yaml:"Proxy Group"`
+	Rule       []string                 `yaml:"Rule"`
 }
 
-// Report return a channel for collecting report message
+func readConfig(path string) (*rawConfig, error) {
-func (c *Config) Report() chan<- interface{} {
+	if _, err := os.Stat(path); os.IsNotExist(err) {
-	return c.reportCh
-}
-
-func (c *Config) readConfig() (*ini.File, error) {
-	if _, err := os.Stat(C.ConfigPath); os.IsNotExist(err) {
 		return nil, err
 	}
-	return ini.LoadSources(
+	data, err := ioutil.ReadFile(path)
-		ini.LoadOptions{
+	if err != nil {
-			AllowBooleanKeys:    true,
+		return nil, err
-			UnparseableSections: []string{"Rule"},
+	}
+
+	if len(data) == 0 {
+		return nil, fmt.Errorf("Configuration file %s is empty", C.Path.Config())
+	}
+
+	// config with some default value
+	rawConfig := &rawConfig{
+		AllowLan:   false,
+		Mode:       T.Rule,
+		LogLevel:   log.INFO,
+		Rule:       []string{},
+		Proxy:      []map[string]interface{}{},
+		ProxyGroup: []map[string]interface{}{},
+		DNS: rawDNS{
+			Enable: false,
 		},
-		C.ConfigPath,
+	}
-	)
+	err = yaml.Unmarshal([]byte(data), &rawConfig)
+	return rawConfig, err
 }
 
 // Parse config
-func (c *Config) Parse() error {
+func Parse(path string) (*Config, error) {
-	cfg, err := c.readConfig()
+	config := &Config{}
+
+	rawCfg, err := readConfig(path)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	if err := c.parseGeneral(cfg); err != nil {
+	general, err := parseGeneral(rawCfg)
-		return err
-	}
-
-	if err := c.parseProxies(cfg); err != nil {
-		return err
-	}
-
-	return c.parseRules(cfg)
-}
-
-// Proxies return proxies of clash
-func (c *Config) Proxies() map[string]C.Proxy {
-	return c.proxies
-}
-
-// Rules return rules of clash
-func (c *Config) Rules() []C.Rule {
-	return c.rules
-}
-
-// SetMode change mode of clash
-func (c *Config) SetMode(mode Mode) {
-	c.general.Mode = mode
-	c.event <- &Event{Type: "mode", Payload: mode}
-}
-
-// SetLogLevel change log level of clash
-func (c *Config) SetLogLevel(level C.LogLevel) {
-	c.general.LogLevel = level
-	c.event <- &Event{Type: "log-level", Payload: level}
-}
-
-// General return clash general config
-func (c *Config) General() General {
-	return *c.general
-}
-
-// UpdateRules is a function for hot reload rules
-func (c *Config) UpdateRules() error {
-	cfg, err := c.readConfig()
 	if err != nil {
-		return err
+		return nil, err
 	}
+	config.General = general
 
-	return c.parseRules(cfg)
+	proxies, err := parseProxies(rawCfg)
+	if err != nil {
+		return nil, err
+	}
+	config.Proxies = proxies
+
+	rules, err := parseRules(rawCfg)
+	if err != nil {
+		return nil, err
+	}
+	config.Rules = rules
+
+	dnsCfg, err := parseDNS(rawCfg.DNS)
+	if err != nil {
+		return nil, err
+	}
+	config.DNS = dnsCfg
+
+	return config, nil
 }
 
-func (c *Config) parseGeneral(cfg *ini.File) error {
+func parseGeneral(cfg *rawConfig) (*General, error) {
-	general := cfg.Section("General")
+	port := cfg.Port
+	socksPort := cfg.SocksPort
+	redirPort := cfg.RedirPort
+	allowLan := cfg.AllowLan
+	externalController := cfg.ExternalController
+	externalUI := cfg.ExternalUI
+	secret := cfg.Secret
+	mode := cfg.Mode
+	logLevel := cfg.LogLevel
 
-	port := general.Key("port").RangeInt(0, 1, 65535)
+	if externalUI != "" {
-	socksPort := general.Key("socks-port").RangeInt(0, 1, 65535)
+		if !filepath.IsAbs(externalUI) {
-	redirPort := general.Key("redir-port").RangeInt(0, 1, 65535)
+			externalUI = filepath.Join(C.Path.HomeDir(), externalUI)
-	allowLan := general.Key("allow-lan").MustBool()
+		}
-	logLevelString := general.Key("log-level").MustString(C.INFO.String())
-	modeString := general.Key("mode").MustString(Rule.String())
 
-	mode, exist := ModeMapping[modeString]
+		if _, err := os.Stat(externalUI); os.IsNotExist(err) {
-	if !exist {
+			return nil, fmt.Errorf("external-ui: %s not exist", externalUI)
-		return fmt.Errorf("General.mode value invalid")
+		}
 	}
 
-	logLevel, exist := C.LogLevelMapping[logLevelString]
+	general := &General{
-	if !exist {
+		Port:               port,
-		return fmt.Errorf("General.log-level value invalid")
+		SocksPort:          socksPort,
+		RedirPort:          redirPort,
+		AllowLan:           allowLan,
+		Mode:               mode,
+		LogLevel:           logLevel,
+		ExternalController: externalController,
+		ExternalUI:         externalUI,
+		Secret:             secret,
 	}
-
+	return general, nil
-	c.general = &General{
-		Port:      port,
-		SocksPort: socksPort,
-		RedirPort: redirPort,
-		AllowLan:  allowLan,
-		Mode:      mode,
-		LogLevel:  logLevel,
-	}
-
-	if restAddr := general.Key("external-controller").String(); restAddr != "" {
-		c.event <- &Event{Type: "external-controller", Payload: restAddr}
-	}
-
-	c.UpdateGeneral(*c.general)
-	return nil
 }
 
-// UpdateGeneral dispatch update event
+func parseProxies(cfg *rawConfig) (map[string]C.Proxy, error) {
-func (c *Config) UpdateGeneral(general General) {
-	c.UpdateProxy(ProxyConfig{
-		Port:      &general.Port,
-		SocksPort: &general.SocksPort,
-		RedirPort: &general.RedirPort,
-		AllowLan:  &general.AllowLan,
-	})
-	c.event <- &Event{Type: "mode", Payload: general.Mode}
-	c.event <- &Event{Type: "log-level", Payload: general.LogLevel}
-}
-
-// UpdateProxy dispatch update proxy event
-func (c *Config) UpdateProxy(pc ProxyConfig) {
-	if pc.AllowLan != nil {
-		c.general.AllowLan = *pc.AllowLan
-	}
-
-	c.general.Port = *or(pc.Port, &c.general.Port)
-	if c.general.Port != 0 && (pc.AllowLan != nil || pc.Port != nil) {
-		c.event <- &Event{Type: "http-addr", Payload: genAddr(c.general.Port, c.general.AllowLan)}
-	}
-
-	c.general.SocksPort = *or(pc.SocksPort, &c.general.SocksPort)
-	if c.general.SocksPort != 0 && (pc.AllowLan != nil || pc.SocksPort != nil) {
-		c.event <- &Event{Type: "socks-addr", Payload: genAddr(c.general.SocksPort, c.general.AllowLan)}
-	}
-
-	c.general.RedirPort = *or(pc.RedirPort, &c.general.RedirPort)
-	if c.general.RedirPort != 0 && (pc.AllowLan != nil || pc.RedirPort != nil) {
-		c.event <- &Event{Type: "redir-addr", Payload: genAddr(c.general.RedirPort, c.general.AllowLan)}
-	}
-}
-
-func (c *Config) parseProxies(cfg *ini.File) error {
 	proxies := make(map[string]C.Proxy)
-	proxiesConfig := cfg.Section("Proxy")
+	proxiesConfig := cfg.Proxy
-	groupsConfig := cfg.Section("Proxy Group")
+	groupsConfig := cfg.ProxyGroup
 
-	// parse proxy
+	decoder := structure.NewDecoder(structure.Option{TagName: "proxy", WeaklyTypedInput: true})
-	for _, key := range proxiesConfig.Keys() {
-		proxy := key.Strings(",")
-		if len(proxy) == 0 {
-			continue
-		}
-		switch proxy[0] {
-		// ss, server, port, cipter, password
-		case "ss":
-			if len(proxy) < 5 {
-				continue
-			}
-			ssURL := fmt.Sprintf("ss://%s:%s@%s:%s", proxy[3], proxy[4], proxy[1], proxy[2])
-			option := parseOptions(5, proxy...)
-			ss, err := adapters.NewShadowSocks(key.Name(), ssURL, option)
-			if err != nil {
-				return err
-			}
-			proxies[key.Name()] = ss
-		// socks5, server, port
-		case "socks5":
-			if len(proxy) < 3 {
-				continue
-			}
-			addr := fmt.Sprintf("%s:%s", proxy[1], proxy[2])
-			socks5 := adapters.NewSocks5(key.Name(), addr)
-			proxies[key.Name()] = socks5
-		// vmess, server, port, uuid, alterId, security
-		case "vmess":
-			if len(proxy) < 6 {
-				continue
-			}
-			addr := fmt.Sprintf("%s:%s", proxy[1], proxy[2])
-			alterID, err := strconv.Atoi(proxy[4])
-			if err != nil {
-				return err
-			}
-			option := parseOptions(6, proxy...)
-			vmess, err := adapters.NewVmess(key.Name(), addr, proxy[3], uint16(alterID), proxy[5], option)
-			if err != nil {
-				return err
-			}
-			proxies[key.Name()] = vmess
-		}
-	}
 
-	// parse proxy group
-	for _, key := range groupsConfig.Keys() {
-		rule := strings.Split(key.Value(), ",")
-		rule = trimArr(rule)
-		switch rule[0] {
-		case "url-test":
-			if len(rule) < 4 {
-				return fmt.Errorf("URLTest need more than 4 param")
-			}
-			proxyNames := rule[1 : len(rule)-2]
-			delay, _ := strconv.Atoi(rule[len(rule)-1])
-			url := rule[len(rule)-2]
-			var ps []C.Proxy
-			for _, name := range proxyNames {
-				if p, ok := proxies[name]; ok {
-					ps = append(ps, p)
-				}
-			}
-
-			adapter, err := adapters.NewURLTest(key.Name(), ps, url, time.Duration(delay)*time.Second)
-			if err != nil {
-				return fmt.Errorf("Config error: %s", err.Error())
-			}
-			proxies[key.Name()] = adapter
-		case "select":
-			if len(rule) < 2 {
-				return fmt.Errorf("Selector need more than 2 param")
-			}
-			proxyNames := rule[1:]
-			selectProxy := make(map[string]C.Proxy)
-			for _, name := range proxyNames {
-				proxy, exist := proxies[name]
-				if !exist {
-					return fmt.Errorf("Proxy %s not exist", name)
-				}
-				selectProxy[name] = proxy
-			}
-			selector, err := adapters.NewSelector(key.Name(), selectProxy)
-			if err != nil {
-				return fmt.Errorf("Selector create error: %s", err.Error())
-			}
-			proxies[key.Name()] = selector
-		}
-	}
-
-	// init proxy
-	proxies["GLOBAL"], _ = adapters.NewSelector("GLOBAL", proxies)
 	proxies["DIRECT"] = adapters.NewDirect()
 	proxies["REJECT"] = adapters.NewReject()
 
-	c.proxies = proxies
+	// parse proxy
-	c.event <- &Event{Type: "proxies", Payload: proxies}
+	for idx, mapping := range proxiesConfig {
-	return nil
+		proxyType, existType := mapping["type"].(string)
+		if !existType {
+			return nil, fmt.Errorf("Proxy %d missing type", idx)
+		}
+
+		var proxy C.Proxy
+		var err error
+		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())
+		}
+
+		if _, exist := proxies[proxy.Name()]; exist {
+			return nil, fmt.Errorf("Proxy %s is the duplicate name", proxy.Name())
+		}
+		proxies[proxy.Name()] = proxy
+	}
+
+	// parse proxy group
+	for idx, mapping := range groupsConfig {
+		groupType, existType := mapping["type"].(string)
+		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.Proxy
+		var ps []C.Proxy
+		var err error
+		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)
+		}
+		if err != nil {
+			return nil, fmt.Errorf("Proxy %s: %s", groupName, err.Error())
+		}
+		proxies[groupName] = group
+	}
+
+	var ps []C.Proxy
+	for _, v := range proxies {
+		ps = append(ps, v)
+	}
+
+	proxies["GLOBAL"], _ = adapters.NewSelector("GLOBAL", ps)
+	return proxies, nil
 }
 
-func (c *Config) parseRules(cfg *ini.File) error {
+func parseRules(cfg *rawConfig) ([]C.Rule, error) {
 	rules := []C.Rule{}
 
-	rulesConfig := cfg.Section("Rule")
+	rulesConfig := cfg.Rule
 	// parse rules
-	reader := bufio.NewReader(strings.NewReader(rulesConfig.Body()))
+	for idx, line := range rulesConfig {
-	for {
+		rule := trimArr(strings.Split(line, ","))
-		line, _, err := reader.ReadLine()
+		var (
-		if err != nil {
+			payload string
-			break
+			target  string
+		)
+
+		switch len(rule) {
+		case 2:
+			target = rule[1]
+		case 3:
+			payload = rule[1]
+			target = rule[2]
+		default:
+			return nil, fmt.Errorf("Rules[%d] [- %s] error: format invalid", idx, line)
 		}
 
-		rule := strings.Split(string(line), ",")
-		if len(rule) < 3 {
-			continue
-		}
 		rule = trimArr(rule)
 		switch rule[0] {
 		case "DOMAIN":
-			rules = append(rules, R.NewDomain(rule[1], rule[2]))
+			rules = append(rules, R.NewDomain(payload, target))
 		case "DOMAIN-SUFFIX":
-			rules = append(rules, R.NewDomainSuffix(rule[1], rule[2]))
+			rules = append(rules, R.NewDomainSuffix(payload, target))
 		case "DOMAIN-KEYWORD":
-			rules = append(rules, R.NewDomainKeyword(rule[1], rule[2]))
+			rules = append(rules, R.NewDomainKeyword(payload, target))
 		case "GEOIP":
-			rules = append(rules, R.NewGEOIP(rule[1], rule[2]))
+			rules = append(rules, R.NewGEOIP(payload, target))
 		case "IP-CIDR", "IP-CIDR6":
-			rules = append(rules, R.NewIPCIDR(rule[1], rule[2]))
+			rules = append(rules, R.NewIPCIDR(payload, target, false))
+		case "SOURCE-IP-CIDR":
+			rules = append(rules, R.NewIPCIDR(payload, target, true))
+		case "MATCH":
+			fallthrough
 		case "FINAL":
-			rules = append(rules, R.NewFinal(rule[2]))
+			rules = append(rules, R.NewFinal(target))
 		}
 	}
 
-	c.rules = rules
+	return rules, nil
-	c.event <- &Event{Type: "rules", Payload: rules}
-	return nil
 }
 
-func (c *Config) handleResponseMessage() {
+func hostWithDefaultPort(host string, defPort string) (string, error) {
-	for elm := range c.reportCh {
+	if !strings.Contains(host, ":") {
-		event := elm.(*Event)
+		host += ":"
-		switch event.Type {
+	}
-		case "http-addr":
+
-			if event.Payload.(bool) == false {
+	hostname, port, err := net.SplitHostPort(host)
-				log.Errorf("Listening HTTP proxy at %d error", c.general.Port)
+	if err != nil {
-				c.general.Port = 0
+		return "", err
-			}
+	}
-		case "socks-addr":
+
-			if event.Payload.(bool) == false {
+	if port == "" {
-				log.Errorf("Listening SOCKS proxy at %d error", c.general.SocksPort)
+		port = defPort
-				c.general.SocksPort = 0
+	}
-			}
+
-		case "redir-addr":
+	return net.JoinHostPort(hostname, port), nil
-			if event.Payload.(bool) == false {
+}
-				log.Errorf("Listening Redir proxy at %d error", c.general.RedirPort)
+
-				c.general.RedirPort = 0
+func parseNameServer(servers []string) ([]dns.NameServer, error) {
-			}
+	nameservers := []dns.NameServer{}
+
+	for idx, server := range servers {
+		// parse without scheme .e.g 8.8.8.8:53
+		if host, err := hostWithDefaultPort(server, "53"); err == nil {
+			nameservers = append(
+				nameservers,
+				dns.NameServer{Addr: host},
+			)
+			continue
 		}
+
+		u, err := url.Parse(server)
+		if err != nil {
+			return nil, fmt.Errorf("DNS NameServer[%d] format error: %s", idx, err.Error())
+		}
+
+		if u.Scheme != "tls" {
+			return nil, fmt.Errorf("DNS NameServer[%d] unsupport scheme: %s", idx, u.Scheme)
+		}
+
+		host, err := hostWithDefaultPort(u.Host, "853")
+		nameservers = append(
+			nameservers,
+			dns.NameServer{
+				Net:  "tcp-tls",
+				Addr: host,
+			},
+		)
 	}
+
+	return nameservers, nil
 }
 
-func newConfig() *Config {
+func parseDNS(cfg rawDNS) (*DNS, error) {
-	event := make(chan interface{})
+	if cfg.Enable && len(cfg.NameServer) == 0 {
-	reportCh := make(chan interface{})
+		return nil, fmt.Errorf("If DNS configuration is turned on, NameServer cannot be empty")
-	config := &Config{
-		general:    &General{},
-		proxies:    make(map[string]C.Proxy),
-		rules:      []C.Rule{},
-		lastUpdate: time.Now(),
-
-		event:      event,
-		reportCh:   reportCh,
-		observable: observable.NewObservable(event),
 	}
-	go config.handleResponseMessage()
-	return config
-}
 
-// Instance return singleton instance of Config
+	dnsCfg := &DNS{
-func Instance() *Config {
+		Enable:       cfg.Enable,
-	once.Do(func() {
+		Listen:       cfg.Listen,
-		config = newConfig()
+		EnhancedMode: cfg.EnhancedMode,
-	})
+	}
-	return config
+
+	if nameserver, err := parseNameServer(cfg.NameServer); err == nil {
+		dnsCfg.NameServer = nameserver
+	}
+
+	if fallback, err := parseNameServer(cfg.Fallback); err == nil {
+		dnsCfg.Fallback = fallback
+	}
+
+	return dnsCfg, nil
 }

config/initial.go

@@ -3,6 +3,7 @@ package config
 import (
 	"archive/tar"
 	"compress/gzip"
+	"fmt"
 	"io"
 	"net/http"
 	"os"
@@ -54,19 +55,27 @@ func downloadMMDB(path string) (err error) {
 }
 
 // Init prepare necessary files
-func Init() {
+func Init(dir string) error {
-	// initial config.ini
+	// initial homedir
-	if _, err := os.Stat(C.ConfigPath); os.IsNotExist(err) {
+	if _, err := os.Stat(dir); os.IsNotExist(err) {
+		if err := os.MkdirAll(dir, 0777); err != nil {
+			return fmt.Errorf("Can't create config directory %s: %s", dir, err.Error())
+		}
+	}
+
+	// initial config.yml
+	if _, err := os.Stat(C.Path.Config()); os.IsNotExist(err) {
 		log.Info("Can't find config, create a empty file")
-		os.OpenFile(C.ConfigPath, os.O_CREATE|os.O_WRONLY, 0644)
+		os.OpenFile(C.Path.Config(), os.O_CREATE|os.O_WRONLY, 0644)
 	}
 
 	// initial mmdb
-	if _, err := os.Stat(C.MMDBPath); os.IsNotExist(err) {
+	if _, err := os.Stat(C.Path.MMDB()); os.IsNotExist(err) {
 		log.Info("Can't find MMDB, start download")
-		err := downloadMMDB(C.MMDBPath)
+		err := downloadMMDB(C.Path.MMDB())
 		if err != nil {
-			log.Fatalf("Can't download MMDB: %s", err.Error())
+			return fmt.Errorf("Can't download MMDB: %s", err.Error())
 		}
 	}
+	return nil
 }

config/mode.go

@@ -1,31 +0,0 @@
-package config
-
-type Mode int
-
-var (
-	// ModeMapping is a mapping for Mode enum
-	ModeMapping = map[string]Mode{
-		"Global": Global,
-		"Rule":   Rule,
-		"Direct": Direct,
-	}
-)
-
-const (
-	Global Mode = iota
-	Rule
-	Direct
-)
-
-func (m Mode) String() string {
-	switch m {
-	case Global:
-		return "Global"
-	case Rule:
-		return "Rule"
-	case Direct:
-		return "Direct"
-	default:
-		return "Unknow"
-	}
-}

config/utils.go

@@ -3,6 +3,8 @@ package config
 import (
 	"fmt"
 	"strings"
+
+	C "github.com/Dreamacro/clash/constant"
 )
 
 func trimArr(arr []string) (r []string) {
@@ -12,11 +14,16 @@ func trimArr(arr []string) (r []string) {
 	return
 }
 
-func genAddr(port int, allowLan bool) string {
+func getProxies(mapping map[string]C.Proxy, list []string) ([]C.Proxy, error) {
-	if allowLan {
+	var ps []C.Proxy
-		return fmt.Sprintf(":%d", port)
+	for _, name := range list {
+		p, ok := mapping[name]
+		if !ok {
+			return nil, fmt.Errorf("'%s' not found", name)
+		}
+		ps = append(ps, p)
 	}
-	return fmt.Sprintf("127.0.0.1:%d", port)
+	return ps, nil
 }
 
 func or(pointers ...*int) *int {
@@ -27,20 +34,3 @@ func or(pointers ...*int) *int {
 	}
 	return pointers[len(pointers)-1]
 }
-
-func parseOptions(startIdx int, params ...string) map[string]string {
-	mapping := make(map[string]string)
-	if len(params) <= startIdx {
-		return mapping
-	}
-
-	for _, option := range params[startIdx:] {
-		pair := strings.SplitN(option, "=", 2)
-		if len(pair) != 2 {
-			continue
-		}
-
-		mapping[strings.Trim(pair[0], " ")] = strings.Trim(pair[1], " ")
-	}
-	return mapping
-}

constant/adapters.go

@@ -7,28 +7,26 @@ import (
 // Adapter Type
 const (
 	Direct AdapterType = iota
+	Fallback
 	Reject
 	Selector
 	Shadowsocks
 	Socks5
+	Http
 	URLTest
 	Vmess
 )
 
-type ProxyAdapter interface {
-	Conn() net.Conn
-	Close()
-}
-
 type ServerAdapter interface {
-	Addr() *Addr
+	Metadata() *Metadata
 	Close()
 }
 
 type Proxy interface {
 	Name() string
 	Type() AdapterType
-	Generator(addr *Addr) (ProxyAdapter, error)
+	Generator(metadata *Metadata) (net.Conn, error)
+	MarshalJSON() ([]byte, error)
 }
 
 // AdapterType is enum of adapter type
@@ -38,6 +36,8 @@ func (at AdapterType) String() string {
 	switch at {
 	case Direct:
 		return "Direct"
+	case Fallback:
+		return "Fallback"
 	case Reject:
 		return "Reject"
 	case Selector:
@@ -46,6 +46,8 @@ func (at AdapterType) String() string {
 		return "Shadowsocks"
 	case Socks5:
 		return "Socks5"
+	case Http:
+		return "Http"
 	case URLTest:
 		return "URLTest"
 	case Vmess:

constant/config.go

@@ -1,51 +0,0 @@
-package constant
-
-import (
-	"os"
-	"os/user"
-	"path"
-
-	log "github.com/sirupsen/logrus"
-)
-
-const (
-	Name = "clash"
-)
-
-var (
-	HomeDir    string
-	ConfigPath string
-	MMDBPath   string
-)
-
-type General struct {
-	Mode      *string `json:"mode,omitempty"`
-	AllowLan  *bool   `json:"allow-lan,omitempty"`
-	Port      *int    `json:"port,omitempty"`
-	SocksPort *int    `json:"socks-port,omitempty"`
-	RedirPort *int    `json:"redir-port,omitempty"`
-	LogLevel  *string `json:"log-level,omitempty"`
-}
-
-func init() {
-	currentUser, err := user.Current()
-	if err != nil {
-		dir := os.Getenv("HOME")
-		if dir == "" {
-			log.Fatalf("Can't get current user: %s", err.Error())
-		}
-		HomeDir = dir
-	} else {
-		HomeDir = currentUser.HomeDir
-	}
-
-	dirPath := path.Join(HomeDir, ".config", Name)
-	if _, err := os.Stat(dirPath); os.IsNotExist(err) {
-		if err := os.MkdirAll(dirPath, 0777); err != nil {
-			log.Fatalf("Can't create config directory %s: %s", dirPath, err.Error())
-		}
-	}
-
-	ConfigPath = path.Join(dirPath, "config.ini")
-	MMDBPath = path.Join(dirPath, "Country.mmdb")
-}

constant/log.go

@@ -1,35 +0,0 @@
-package constant
-
-var (
-	// LogLevelMapping is a mapping for LogLevel enum
-	LogLevelMapping = map[string]LogLevel{
-		"error":   ERROR,
-		"warning": WARNING,
-		"info":    INFO,
-		"debug":   DEBUG,
-	}
-)
-
-const (
-	ERROR LogLevel = iota
-	WARNING
-	INFO
-	DEBUG
-)
-
-type LogLevel int
-
-func (l LogLevel) String() string {
-	switch l {
-	case INFO:
-		return "info"
-	case WARNING:
-		return "warning"
-	case ERROR:
-		return "error"
-	case DEBUG:
-		return "debug"
-	default:
-		return "unknow"
-	}
-}

constant/metadata.go

@@ -15,6 +15,7 @@ const (
 
 	HTTP SourceType = iota
 	SOCKS
+	REDIR
 )
 
 type NetWork int
@@ -28,19 +29,24 @@ func (n *NetWork) String() string {
 
 type SourceType int
 
-// Addr is used to store connection address
+// Metadata is used to store connection address
-type Addr struct {
+type Metadata struct {
 	NetWork  NetWork
 	Source   SourceType
+	SourceIP *net.IP
 	AddrType int
 	Host     string
 	IP       *net.IP
 	Port     string
 }
 
-func (addr *Addr) String() string {
+func (m *Metadata) String() string {
-	if addr.Host == "" {
+	if m.Host == "" {
-		return addr.IP.String()
+		return m.IP.String()
 	}
-	return addr.Host
+	return m.Host
+}
+
+func (m *Metadata) Valid() bool {
+	return m.Host != "" || m.IP != nil
 }

constant/path.go

@@ -0,0 +1,49 @@
+package constant
+
+import (
+	"os"
+	"os/user"
+	P "path"
+)
+
+const Name = "clash"
+
+// Path is used to get the configuration path
+var Path *path
+
+type path struct {
+	homedir string
+}
+
+func init() {
+	currentUser, err := user.Current()
+	var homedir string
+	if err != nil {
+		dir := os.Getenv("HOME")
+		if dir == "" {
+			dir, _ = os.Getwd()
+		}
+		homedir = dir
+	} else {
+		homedir = currentUser.HomeDir
+	}
+	homedir = P.Join(homedir, ".config", Name)
+	Path = &path{homedir: homedir}
+}
+
+// SetHomeDir is used to set the configuration path
+func SetHomeDir(root string) {
+	Path = &path{homedir: root}
+}
+
+func (p *path) HomeDir() string {
+	return p.homedir
+}
+
+func (p *path) Config() string {
+	return P.Join(p.homedir, "config.yml")
+}
+
+func (p *path) MMDB() string {
+	return P.Join(p.homedir, "Country.mmdb")
+}

constant/proxy.go

@@ -1,7 +0,0 @@
-package constant
-
-// ProxySignal is used to handle graceful shutdown of proxy
-type ProxySignal struct {
-	Done   chan<- struct{}
-	Closed <-chan struct{}
-}

constant/rule.go

@@ -7,6 +7,7 @@ const (
 	DomainKeyword
 	GEOIP
 	IPCIDR
+	SourceIPCIDR
 	FINAL
 )
 
@@ -24,6 +25,8 @@ func (rt RuleType) String() string {
 		return "GEOIP"
 	case IPCIDR:
 		return "IPCIDR"
+	case SourceIPCIDR:
+		return "SourceIPCIDR"
 	case FINAL:
 		return "FINAL"
 	default:
@@ -33,7 +36,7 @@ func (rt RuleType) String() string {
 
 type Rule interface {
 	RuleType() RuleType
-	IsMatch(addr *Addr) bool
+	IsMatch(metadata *Metadata) bool
 	Adapter() string
 	Payload() string
 }

dns/client.go

@@ -0,0 +1,273 @@
+package dns
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"net"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/Dreamacro/clash/common/cache"
+	"github.com/Dreamacro/clash/common/picker"
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/log"
+
+	D "github.com/miekg/dns"
+	geoip2 "github.com/oschwald/geoip2-golang"
+)
+
+var (
+	globalSessionCache = tls.NewLRUClientSessionCache(64)
+
+	mmdb     *geoip2.Reader
+	once     sync.Once
+	resolver *Resolver
+)
+
+type Resolver struct {
+	ipv6     bool
+	mapping  bool
+	fallback []*nameserver
+	main     []*nameserver
+	cache    *cache.Cache
+}
+
+type result struct {
+	Msg   *D.Msg
+	Error error
+}
+
+func isIPRequest(q D.Question) bool {
+	if q.Qclass == D.ClassINET && (q.Qtype == D.TypeA || q.Qtype == D.TypeAAAA) {
+		return true
+	}
+	return false
+}
+
+func (r *Resolver) Exchange(m *D.Msg) (msg *D.Msg, err error) {
+	if len(m.Question) == 0 {
+		return nil, errors.New("should have one question at least")
+	}
+
+	q := m.Question[0]
+	cache, expireTime := r.cache.GetWithExpire(q.String())
+	if cache != nil {
+		msg = cache.(*D.Msg).Copy()
+		if len(msg.Answer) > 0 {
+			ttl := uint32(expireTime.Sub(time.Now()).Seconds())
+			for _, answer := range msg.Answer {
+				answer.Header().Ttl = ttl
+			}
+		}
+		return
+	}
+	defer func() {
+		if msg != nil {
+			putMsgToCache(r.cache, q.String(), msg)
+			if r.mapping {
+				ips, err := r.msgToIP(msg)
+				if err != nil {
+					log.Debugln("[DNS] msg to ip error: %s", err.Error())
+					return
+				}
+				for _, ip := range ips {
+					putMsgToCache(r.cache, ip.String(), msg)
+				}
+			}
+		}
+	}()
+
+	isIPReq := isIPRequest(q)
+	if isIPReq {
+		msg, err = r.resolveIP(m)
+		return
+	}
+
+	msg, err = r.exchange(r.main, m)
+	return
+}
+
+func (r *Resolver) exchange(servers []*nameserver, m *D.Msg) (msg *D.Msg, err error) {
+	in := make(chan interface{})
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+	fast := picker.SelectFast(ctx, in)
+
+	wg := sync.WaitGroup{}
+	wg.Add(len(servers))
+	for _, server := range servers {
+		go func(s *nameserver) {
+			defer wg.Done()
+			msg, _, err := s.Client.Exchange(m, s.Address)
+			if err != nil || msg.Rcode != D.RcodeSuccess {
+				return
+			}
+			in <- &result{Msg: msg, Error: err}
+		}(server)
+	}
+
+	// release in channel
+	go func() {
+		wg.Wait()
+		close(in)
+	}()
+
+	elm, exist := <-fast
+	if !exist {
+		return nil, errors.New("All DNS requests failed")
+	}
+
+	resp := elm.(*result)
+	msg, err = resp.Msg, resp.Error
+	return
+}
+
+func (r *Resolver) resolveIP(m *D.Msg) (msg *D.Msg, err error) {
+	msgCh := r.resolve(r.main, m)
+	if r.fallback == nil {
+		res := <-msgCh
+		msg, err = res.Msg, res.Error
+		return
+	}
+	fallbackMsg := r.resolve(r.fallback, m)
+	res := <-msgCh
+	if res.Error == nil {
+		if mmdb == nil {
+			return nil, errors.New("GeoIP can't use")
+		}
+
+		ips, err := r.msgToIP(res.Msg)
+		if err == nil {
+			if record, _ := mmdb.Country(ips[0]); record.Country.IsoCode == "CN" || record.Country.IsoCode == "" {
+				// release channel
+				go func() { <-fallbackMsg }()
+				msg = res.Msg
+				return msg, err
+			}
+		}
+	}
+
+	res = <-fallbackMsg
+	msg, err = res.Msg, res.Error
+	return
+}
+
+func (r *Resolver) ResolveIP(host string) (ip net.IP, err error) {
+	ip = net.ParseIP(host)
+	if ip != nil {
+		return ip, nil
+	}
+
+	query := &D.Msg{}
+	dnsType := D.TypeA
+	if r.ipv6 {
+		dnsType = D.TypeAAAA
+	}
+	query.SetQuestion(D.Fqdn(host), dnsType)
+
+	msg, err := r.Exchange(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var ips []net.IP
+	ips, err = r.msgToIP(msg)
+	if err != nil {
+		return nil, err
+	}
+
+	ip = ips[0]
+	return
+}
+
+func (r *Resolver) msgToIP(msg *D.Msg) ([]net.IP, error) {
+	var ips []net.IP
+
+	for _, answer := range msg.Answer {
+		switch ans := answer.(type) {
+		case *D.AAAA:
+			ips = append(ips, ans.AAAA)
+		case *D.A:
+			ips = append(ips, ans.A)
+		}
+	}
+
+	if len(ips) == 0 {
+		return nil, errors.New("Can't parse msg")
+	}
+
+	return ips, nil
+}
+
+func (r *Resolver) IPToHost(ip net.IP) (string, bool) {
+	cache := r.cache.Get(ip.String())
+	if cache == nil {
+		return "", false
+	}
+	fqdn := cache.(*D.Msg).Question[0].Name
+	return strings.TrimRight(fqdn, "."), true
+}
+
+func (r *Resolver) resolve(client []*nameserver, msg *D.Msg) <-chan *result {
+	ch := make(chan *result)
+	go func() {
+		res, err := r.exchange(client, msg)
+		ch <- &result{Msg: res, Error: err}
+	}()
+	return ch
+}
+
+func (r *Resolver) IsMapping() bool {
+	return r.mapping
+}
+
+type NameServer struct {
+	Net  string
+	Addr string
+}
+
+type nameserver struct {
+	Client  *D.Client
+	Address string
+}
+
+type Config struct {
+	Main, Fallback []NameServer
+	IPv6           bool
+	EnhancedMode   EnhancedMode
+}
+
+func transform(servers []NameServer) []*nameserver {
+	var ret []*nameserver
+	for _, s := range servers {
+		ret = append(ret, &nameserver{
+			Client: &D.Client{
+				Net: s.Net,
+				TLSConfig: &tls.Config{
+					ClientSessionCache: globalSessionCache,
+				},
+			},
+			Address: s.Addr,
+		})
+	}
+	return ret
+}
+
+func New(config Config) *Resolver {
+	once.Do(func() {
+		mmdb, _ = geoip2.Open(C.Path.MMDB())
+	})
+
+	r := &Resolver{
+		main:    transform(config.Main),
+		ipv6:    config.IPv6,
+		cache:   cache.New(time.Second * 60),
+		mapping: config.EnhancedMode == MAPPING,
+	}
+	if config.Fallback != nil {
+		r.fallback = transform(config.Fallback)
+	}
+	return r
+}

dns/server.go

@@ -0,0 +1,62 @@
+package dns
+
+import (
+	"net"
+
+	D "github.com/miekg/dns"
+)
+
+var (
+	address string
+	server  = &Server{}
+)
+
+type Server struct {
+	*D.Server
+	r *Resolver
+}
+
+func (s *Server) ServeDNS(w D.ResponseWriter, r *D.Msg) {
+	msg, err := s.r.Exchange(r)
+
+	if err != nil {
+		D.HandleFailed(w, r)
+		return
+	}
+	msg.SetReply(r)
+	w.WriteMsg(msg)
+}
+
+func ReCreateServer(addr string, resolver *Resolver) error {
+	if server.Server != nil {
+		server.Shutdown()
+	}
+
+	if addr == address {
+		return nil
+	}
+
+	_, port, err := net.SplitHostPort(addr)
+	if port == "0" || port == "" || err != nil {
+		return nil
+	}
+
+	udpAddr, err := net.ResolveUDPAddr("udp", addr)
+	if err != nil {
+		return err
+	}
+
+	p, err := net.ListenUDP("udp", udpAddr)
+	if err != nil {
+		return err
+	}
+
+	address = addr
+	server = &Server{r: resolver}
+	server.Server = &D.Server{Addr: addr, PacketConn: p, Handler: server}
+
+	go func() {
+		server.ActivateAndServe()
+	}()
+	return nil
+}

dns/util.go

@@ -0,0 +1,89 @@
+package dns
+
+import (
+	"encoding/json"
+	"errors"
+	"time"
+
+	"github.com/Dreamacro/clash/common/cache"
+	"github.com/Dreamacro/clash/log"
+	yaml "gopkg.in/yaml.v2"
+
+	D "github.com/miekg/dns"
+)
+
+var (
+	// EnhancedModeMapping is a mapping for EnhancedMode enum
+	EnhancedModeMapping = map[string]EnhancedMode{
+		NORMAL.String():  NORMAL,
+		FAKEIP.String():  FAKEIP,
+		MAPPING.String(): MAPPING,
+	}
+)
+
+const (
+	NORMAL EnhancedMode = iota
+	FAKEIP
+	MAPPING
+)
+
+type EnhancedMode int
+
+// UnmarshalYAML unserialize EnhancedMode with yaml
+func (e *EnhancedMode) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var tp string
+	if err := unmarshal(&tp); err != nil {
+		return err
+	}
+	mode, exist := EnhancedModeMapping[tp]
+	if !exist {
+		return errors.New("invalid mode")
+	}
+	*e = mode
+	return nil
+}
+
+// MarshalYAML serialize EnhancedMode with yaml
+func (e EnhancedMode) MarshalYAML() ([]byte, error) {
+	return yaml.Marshal(e.String())
+}
+
+// UnmarshalJSON unserialize EnhancedMode with json
+func (e *EnhancedMode) UnmarshalJSON(data []byte) error {
+	var tp string
+	json.Unmarshal(data, &tp)
+	mode, exist := EnhancedModeMapping[tp]
+	if !exist {
+		return errors.New("invalid mode")
+	}
+	*e = mode
+	return nil
+}
+
+// MarshalJSON serialize EnhancedMode with json
+func (e EnhancedMode) MarshalJSON() ([]byte, error) {
+	return json.Marshal(e.String())
+}
+
+func (e EnhancedMode) String() string {
+	switch e {
+	case NORMAL:
+		return "normal"
+	case FAKEIP:
+		return "fakeip"
+	case MAPPING:
+		return "redir-host"
+	default:
+		return "unknown"
+	}
+}
+
+func putMsgToCache(c *cache.Cache, key string, msg *D.Msg) {
+	if len(msg.Answer) == 0 {
+		log.Debugln("[DNS] answer length is zero: %#v", msg)
+		return
+	}
+
+	ttl := time.Duration(msg.Answer[0].Header().Ttl) * time.Second
+	c.Put(key, msg, ttl)
+}

go.mod

@@ -0,0 +1,20 @@
+module github.com/Dreamacro/clash
+
+require (
+	github.com/Dreamacro/go-shadowsocks2 v0.1.3-0.20190202135136-da4602d8f112
+	github.com/eapache/queue v1.1.0 // indirect
+	github.com/go-chi/chi v4.0.1+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/miekg/dns v1.1.4
+	github.com/oschwald/geoip2-golang v1.2.1
+	github.com/oschwald/maxminddb-golang v1.3.0 // indirect
+	github.com/sirupsen/logrus v1.3.0
+	golang.org/x/crypto v0.0.0-20190131182504-b8fe1690c613
+	golang.org/x/net v0.0.0-20181108082009-03003ca0c849 // indirect
+	golang.org/x/sync v0.0.0-20181108010431-42b317875d0f // indirect
+	gopkg.in/eapache/channels.v1 v1.1.0
+	gopkg.in/yaml.v2 v2.2.2
+)

go.sum

@@ -0,0 +1,49 @@
+github.com/Dreamacro/go-shadowsocks2 v0.1.3-0.20190202135136-da4602d8f112 h1:1axYxE0ZLJy40+ulq46XQt7MaJDJr4iGer1NQz7jmKw=
+github.com/Dreamacro/go-shadowsocks2 v0.1.3-0.20190202135136-da4602d8f112/go.mod h1:giIuN+TuUudTxHc1jjTOyyQYiJ3VXp1pWOHdJbSCAPo=
+github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da h1:KjTM2ks9d14ZYCvmHS9iAKVt9AyzRSqNU1qabPih5BY=
+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.1+incompatible h1:RSRC5qmFPtO90t7pTL0DBMNpZFsb/sHF3RXVlDgFisA=
+github.com/go-chi/chi v4.0.1+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.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+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.4 h1:rCMZsU2ScVSYcAsOXgmC6+AKOK+6pmQTOcw03nfwYV0=
+github.com/miekg/dns v1.1.4/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
+github.com/oschwald/geoip2-golang v1.2.1 h1:3iz+jmeJc6fuCyWeKgtXSXu7+zvkxJbHFXkMT5FVebU=
+github.com/oschwald/geoip2-golang v1.2.1/go.mod h1:0LTTzix/Ao1uMvOhAV4iLU0Lz7eCrP94qZWBTDKf0iE=
+github.com/oschwald/maxminddb-golang v1.3.0 h1:oTh8IBSj10S5JNlUDg5WjJ1QdBMdeaZIkPEVfESSWgE=
+github.com/oschwald/maxminddb-golang v1.3.0/go.mod h1:3jhIUymTJ5VREKyIhWm66LJiQt04F0UCDdodShpjWsY=
+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.3.0 h1:hI/7Q+DtNZ2kINb6qt/lS+IyXnHQe9e90POfeewL/ME=
+github.com/sirupsen/logrus v1.3.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+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=
+golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190131182504-b8fe1690c613 h1:MQ/ZZiDsUapFFiMS+vzwXkCTeEKaum+Do5rINYJDmxc=
+golang.org/x/crypto v0.0.0-20190131182504-b8fe1690c613/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/net v0.0.0-20181108082009-03003ca0c849 h1:FSqE2GGG7wzsYUsWiQ8MZrvEd1EOyU3NCF0AW3Wtltg=
+golang.org/x/net v0.0.0-20181108082009-03003ca0c849/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f h1:Bl/8QSvNqXvPGPGXa2z5xUTmV7VDcZyvRZ+QQXkXTZQ=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181005133103-4497e2df6f9e h1:EfdBzeKbFSvOjoIqSZcfS8wp0FBLokGBEs9lz1OtSg0=
+golang.org/x/sys v0.0.0-20181005133103-4497e2df6f9e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+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=

hub/common.go

@@ -1,33 +0,0 @@
-package hub
-
-import (
-	"github.com/Dreamacro/clash/config"
-	"github.com/Dreamacro/clash/proxy"
-	T "github.com/Dreamacro/clash/tunnel"
-)
-
-var (
-	tunnel   = T.Instance()
-	cfg      = config.Instance()
-	listener = proxy.Instance()
-)
-
-type Error struct {
-	Error string `json:"error"`
-}
-
-type Errors struct {
-	Errors map[string]string `json:"errors"`
-}
-
-func formatErrors(errorsMap map[string]error) (bool, Errors) {
-	errors := make(map[string]string)
-	hasError := false
-	for key, err := range errorsMap {
-		if err != nil {
-			errors[key] = err.Error()
-			hasError = true
-		}
-	}
-	return hasError, Errors{Errors: errors}
-}

hub/configs.go

@@ -1,96 +0,0 @@
-package hub
-
-import (
-	"fmt"
-	"net/http"
-
-	"github.com/Dreamacro/clash/config"
-	C "github.com/Dreamacro/clash/constant"
-
-	"github.com/go-chi/chi"
-	"github.com/go-chi/render"
-)
-
-func configRouter() http.Handler {
-	r := chi.NewRouter()
-	r.Get("/", getConfigs)
-	r.Put("/", updateConfigs)
-	return r
-}
-
-type configSchema struct {
-	Port      int    `json:"port"`
-	SocksPort int    `json:"socket-port"`
-	RedirPort int    `json:"redir-port"`
-	AllowLan  bool   `json:"allow-lan"`
-	Mode      string `json:"mode"`
-	LogLevel  string `json:"log-level"`
-}
-
-func getConfigs(w http.ResponseWriter, r *http.Request) {
-	general := cfg.General()
-	render.JSON(w, r, configSchema{
-		Port:      general.Port,
-		SocksPort: general.SocksPort,
-		RedirPort: general.RedirPort,
-		AllowLan:  general.AllowLan,
-		Mode:      general.Mode.String(),
-		LogLevel:  general.LogLevel.String(),
-	})
-}
-
-func updateConfigs(w http.ResponseWriter, r *http.Request) {
-	general := &C.General{}
-	err := render.DecodeJSON(r.Body, general)
-	if err != nil {
-		w.WriteHeader(http.StatusBadRequest)
-		render.JSON(w, r, Error{
-			Error: "Format error",
-		})
-		return
-	}
-
-	// update errors
-	var modeErr, logLevelErr error
-
-	// update mode
-	if general.Mode != nil {
-		mode, ok := config.ModeMapping[*general.Mode]
-		if !ok {
-			modeErr = fmt.Errorf("Mode error")
-		} else {
-			cfg.SetMode(mode)
-		}
-	}
-
-	// update log-level
-	if general.LogLevel != nil {
-		level, ok := C.LogLevelMapping[*general.LogLevel]
-		if !ok {
-			logLevelErr = fmt.Errorf("Log Level error")
-		} else {
-			cfg.SetLogLevel(level)
-		}
-	}
-
-	hasError, errors := formatErrors(map[string]error{
-		"mode":      modeErr,
-		"log-level": logLevelErr,
-	})
-
-	if hasError {
-		w.WriteHeader(http.StatusBadRequest)
-		render.JSON(w, r, errors)
-		return
-	}
-
-	// update proxy
-	cfg.UpdateProxy(config.ProxyConfig{
-		AllowLan:  general.AllowLan,
-		Port:      general.Port,
-		SocksPort: general.SocksPort,
-		RedirPort: general.RedirPort,
-	})
-
-	w.WriteHeader(http.StatusNoContent)
-}

hub/executor/executor.go

@@ -0,0 +1,104 @@
+package executor
+
+import (
+	adapters "github.com/Dreamacro/clash/adapters/outbound"
+	"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"
+	T "github.com/Dreamacro/clash/tunnel"
+)
+
+// Parse config with default config path
+func Parse() (*config.Config, error) {
+	return ParseWithPath(C.Path.Config())
+}
+
+// ParseWithPath parse config with custom config path
+func ParseWithPath(path string) (*config.Config, error) {
+	return config.Parse(path)
+}
+
+// ApplyConfig dispatch configure to all parts
+func ApplyConfig(cfg *config.Config, force bool) {
+	if force {
+		updateGeneral(cfg.General)
+	}
+	updateProxies(cfg.Proxies)
+	updateRules(cfg.Rules)
+	updateDNS(cfg.DNS)
+}
+
+func GetGeneral() *config.General {
+	ports := P.GetPorts()
+	return &config.General{
+		Port:      ports.Port,
+		SocksPort: ports.SocksPort,
+		RedirPort: ports.RedirPort,
+		AllowLan:  P.AllowLan(),
+		Mode:      T.Instance().Mode(),
+		LogLevel:  log.Level(),
+	}
+}
+
+func updateDNS(c *config.DNS) {
+	if c.Enable == false {
+		T.Instance().SetResolver(nil)
+		dns.ReCreateServer("", nil)
+		return
+	}
+	r := dns.New(dns.Config{
+		Main:         c.NameServer,
+		Fallback:     c.Fallback,
+		IPv6:         c.IPv6,
+		EnhancedMode: c.EnhancedMode,
+	})
+	T.Instance().SetResolver(r)
+	if err := dns.ReCreateServer(c.Listen, r); err != nil {
+		log.Errorln("Start DNS server error: %s", err.Error())
+		return
+	}
+	log.Infoln("DNS server listening at: %s", c.Listen)
+}
+
+func updateProxies(proxies map[string]C.Proxy) {
+	tunnel := T.Instance()
+	oldProxies := tunnel.Proxies()
+
+	// close old goroutine
+	for _, proxy := range oldProxies {
+		switch raw := proxy.(type) {
+		case *adapters.URLTest:
+			raw.Close()
+		case *adapters.Fallback:
+			raw.Close()
+		}
+	}
+
+	tunnel.UpdateProxies(proxies)
+}
+
+func updateRules(rules []C.Rule) {
+	T.Instance().UpdateRules(rules)
+}
+
+func updateGeneral(general *config.General) {
+	log.SetLevel(general.LogLevel)
+	T.Instance().SetMode(general.Mode)
+
+	allowLan := general.AllowLan
+
+	P.SetAllowLan(allowLan)
+	if err := P.ReCreateHTTP(general.Port); err != nil {
+		log.Errorln("Start HTTP server error: %s", err.Error())
+	}
+
+	if err := P.ReCreateSocks(general.SocksPort); err != nil {
+		log.Errorln("Start SOCKS5 server error: %s", err.Error())
+	}
+
+	if err := P.ReCreateRedir(general.RedirPort); err != nil {
+		log.Errorln("Start Redir server error: %s", err.Error())
+	}
+}

hub/hub.go

@@ -0,0 +1,25 @@
+package hub
+
+import (
+	"github.com/Dreamacro/clash/hub/executor"
+	"github.com/Dreamacro/clash/hub/route"
+)
+
+// Parse call at the beginning of clash
+func Parse() error {
+	cfg, err := executor.Parse()
+	if err != nil {
+		return err
+	}
+
+	if cfg.General.ExternalUI != "" {
+		route.SetUIPath(cfg.General.ExternalUI)
+	}
+
+	if cfg.General.ExternalController != "" {
+		go route.Start(cfg.General.ExternalController, cfg.General.Secret)
+	}
+
+	executor.ApplyConfig(cfg, true)
+	return nil
+}

hub/proxies.go

@@ -1,193 +0,0 @@
-package hub
-
-import (
-	"fmt"
-	"net/http"
-	"strconv"
-	"time"
-
-	A "github.com/Dreamacro/clash/adapters/remote"
-	C "github.com/Dreamacro/clash/constant"
-
-	"github.com/go-chi/chi"
-	"github.com/go-chi/render"
-)
-
-func proxyRouter() http.Handler {
-	r := chi.NewRouter()
-	r.Get("/", getProxies)
-	r.Get("/{name}", getProxy)
-	r.Get("/{name}/delay", getProxyDelay)
-	r.Put("/{name}", updateProxy)
-	return r
-}
-
-type SampleProxy struct {
-	Type string `json:"type"`
-}
-
-type Selector struct {
-	Type string   `json:"type"`
-	Now  string   `json:"now"`
-	All  []string `json:"all"`
-}
-
-type URLTest struct {
-	Type string `json:"type"`
-	Now  string `json:"now"`
-}
-
-func transformProxy(proxy C.Proxy) interface{} {
-	t := proxy.Type()
-	switch t {
-	case C.Selector:
-		selector := proxy.(*A.Selector)
-		return Selector{
-			Type: t.String(),
-			Now:  selector.Now(),
-			All:  selector.All(),
-		}
-	case C.URLTest:
-		return URLTest{
-			Type: t.String(),
-			Now:  proxy.(*A.URLTest).Now(),
-		}
-	default:
-		return SampleProxy{
-			Type: proxy.Type().String(),
-		}
-	}
-}
-
-type GetProxiesResponse struct {
-	Proxies map[string]interface{} `json:"proxies"`
-}
-
-func getProxies(w http.ResponseWriter, r *http.Request) {
-	rawProxies := cfg.Proxies()
-	proxies := make(map[string]interface{})
-	for name, proxy := range rawProxies {
-		proxies[name] = transformProxy(proxy)
-	}
-	render.JSON(w, r, GetProxiesResponse{Proxies: proxies})
-}
-
-func getProxy(w http.ResponseWriter, r *http.Request) {
-	name := chi.URLParam(r, "name")
-	proxies := cfg.Proxies()
-	proxy, exist := proxies[name]
-	if !exist {
-		w.WriteHeader(http.StatusNotFound)
-		render.JSON(w, r, Error{
-			Error: "Proxy not found",
-		})
-		return
-	}
-	render.JSON(w, r, transformProxy(proxy))
-}
-
-type UpdateProxyRequest struct {
-	Name string `json:"name"`
-}
-
-func updateProxy(w http.ResponseWriter, r *http.Request) {
-	req := UpdateProxyRequest{}
-	if err := render.DecodeJSON(r.Body, &req); err != nil {
-		w.WriteHeader(http.StatusBadRequest)
-		render.JSON(w, r, Error{
-			Error: "Format error",
-		})
-		return
-	}
-
-	name := chi.URLParam(r, "name")
-	proxies := cfg.Proxies()
-	proxy, exist := proxies[name]
-	if !exist {
-		w.WriteHeader(http.StatusNotFound)
-		render.JSON(w, r, Error{
-			Error: "Proxy not found",
-		})
-		return
-	}
-
-	selector, ok := proxy.(*A.Selector)
-	if !ok {
-		w.WriteHeader(http.StatusBadRequest)
-		render.JSON(w, r, Error{
-			Error: "Proxy can't update",
-		})
-		return
-	}
-
-	if err := selector.Set(req.Name); err != nil {
-		w.WriteHeader(http.StatusBadRequest)
-		render.JSON(w, r, Error{
-			Error: fmt.Sprintf("Selector update error: %s", err.Error()),
-		})
-		return
-	}
-
-	w.WriteHeader(http.StatusNoContent)
-}
-
-type GetProxyDelayRequest struct {
-	URL     string `json:"url"`
-	Timeout int16  `json:"timeout"`
-}
-
-type GetProxyDelayResponse struct {
-	Delay int16 `json:"delay"`
-}
-
-func getProxyDelay(w http.ResponseWriter, r *http.Request) {
-	query := r.URL.Query()
-	url := query.Get("url")
-	timeout, err := strconv.ParseInt(query.Get("timeout"), 10, 16)
-	if err != nil {
-		w.WriteHeader(http.StatusBadRequest)
-		render.JSON(w, r, Error{
-			Error: "Format error",
-		})
-		return
-	}
-
-	name := chi.URLParam(r, "name")
-	proxies := cfg.Proxies()
-	proxy, exist := proxies[name]
-	if !exist {
-		w.WriteHeader(http.StatusNotFound)
-		render.JSON(w, r, Error{
-			Error: "Proxy not found",
-		})
-		return
-	}
-
-	sigCh := make(chan int16)
-	go func() {
-		t, err := A.DelayTest(proxy, url)
-		if err != nil {
-			sigCh <- 0
-		}
-		sigCh <- t
-	}()
-
-	select {
-	case <-time.After(time.Millisecond * time.Duration(timeout)):
-		w.WriteHeader(http.StatusRequestTimeout)
-		render.JSON(w, r, Error{
-			Error: "Proxy delay test timeout",
-		})
-	case t := <-sigCh:
-		if t == 0 {
-			w.WriteHeader(http.StatusServiceUnavailable)
-			render.JSON(w, r, Error{
-				Error: "An error occurred in the delay test",
-			})
-		} else {
-			render.JSON(w, r, GetProxyDelayResponse{
-				Delay: t,
-			})
-		}
-	}
-}

hub/route/configs.go

@@ -0,0 +1,102 @@
+package route
+
+import (
+	"net/http"
+	"path/filepath"
+
+	"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/go-chi/chi"
+	"github.com/go-chi/render"
+)
+
+func configRouter() http.Handler {
+	r := chi.NewRouter()
+	r.Get("/", getConfigs)
+	r.Put("/", updateConfigs)
+	r.Patch("/", patchConfigs)
+	return r
+}
+
+type configSchema struct {
+	Port      *int          `json:"port"`
+	SocksPort *int          `json:"socks-port"`
+	RedirPort *int          `json:"redir-port"`
+	AllowLan  *bool         `json:"allow-lan"`
+	Mode      *T.Mode       `json:"mode"`
+	LogLevel  *log.LogLevel `json:"log-level"`
+}
+
+func getConfigs(w http.ResponseWriter, r *http.Request) {
+	general := executor.GetGeneral()
+	render.JSON(w, r, general)
+}
+
+func pointerOrDefault(p *int, def int) int {
+	if p != nil {
+		return *p
+	}
+
+	return def
+}
+
+func patchConfigs(w http.ResponseWriter, r *http.Request) {
+	general := &configSchema{}
+	if err := render.DecodeJSON(r.Body, general); err != nil {
+		render.Status(r, http.StatusBadRequest)
+		render.JSON(w, r, ErrBadRequest)
+		return
+	}
+
+	if general.AllowLan != nil {
+		P.SetAllowLan(*general.AllowLan)
+	}
+
+	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)
+	}
+
+	if general.LogLevel != nil {
+		log.SetLevel(*general.LogLevel)
+	}
+
+	render.NoContent(w, r)
+}
+
+type updateConfigRequest struct {
+	Path string `json:"path"`
+}
+
+func updateConfigs(w http.ResponseWriter, r *http.Request) {
+	req := updateConfigRequest{}
+	if err := render.DecodeJSON(r.Body, &req); err != nil {
+		render.Status(r, http.StatusBadRequest)
+		render.JSON(w, r, ErrBadRequest)
+		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)
+	if err != nil {
+		render.Status(r, http.StatusBadRequest)
+		render.JSON(w, r, newError(err.Error()))
+		return
+	}
+
+	executor.ApplyConfig(cfg, force)
+	render.NoContent(w, r)
+}

hub/route/ctxkeys.go

@@ -0,0 +1,12 @@
+package route
+
+var (
+	CtxKeyProxyName = contextKey("proxy name")
+	CtxKeyProxy     = contextKey("proxy")
+)
+
+type contextKey string
+
+func (c contextKey) String() string {
+	return "clash context key " + string(c)
+}

hub/route/errors.go

@@ -0,0 +1,22 @@
+package route
+
+var (
+	ErrUnauthorized   = newError("Unauthorized")
+	ErrBadRequest     = newError("Body invalid")
+	ErrForbidden      = newError("Forbidden")
+	ErrNotFound       = newError("Resource not found")
+	ErrRequestTimeout = newError("Timeout")
+)
+
+// HTTPError is custom HTTP error for API
+type HTTPError struct {
+	Message string `json:"message"`
+}
+
+func (e *HTTPError) Error() string {
+	return e.Message
+}
+
+func newError(msg string) *HTTPError {
+	return &HTTPError{Message: msg}
+}

hub/route/proxies.go

@@ -0,0 +1,137 @@
+package route
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+	"time"
+
+	A "github.com/Dreamacro/clash/adapters/outbound"
+	C "github.com/Dreamacro/clash/constant"
+	T "github.com/Dreamacro/clash/tunnel"
+
+	"github.com/go-chi/chi"
+	"github.com/go-chi/render"
+)
+
+func proxyRouter() http.Handler {
+	r := chi.NewRouter()
+	r.Get("/", getProxies)
+
+	r.Route("/{name}", func(r chi.Router) {
+		r.Use(parseProxyName, findProxyByName)
+		r.Get("/", getProxy)
+		r.Get("/delay", getProxyDelay)
+		r.Put("/", updateProxy)
+	})
+	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")
+		if newName, err := url.PathUnescape(name); err == nil {
+			name = newName
+		}
+		ctx := context.WithValue(r.Context(), CtxKeyProxyName, name)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
+
+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()
+		proxy, exist := proxies[name]
+		if !exist {
+			render.Status(r, http.StatusNotFound)
+			render.JSON(w, r, ErrNotFound)
+			return
+		}
+
+		ctx := context.WithValue(r.Context(), CtxKeyProxy, proxy)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
+
+func getProxies(w http.ResponseWriter, r *http.Request) {
+	proxies := T.Instance().Proxies()
+	render.JSON(w, r, map[string]map[string]C.Proxy{
+		"proxies": proxies,
+	})
+}
+
+func getProxy(w http.ResponseWriter, r *http.Request) {
+	proxy := r.Context().Value(CtxKeyProxy).(C.Proxy)
+	render.JSON(w, r, proxy)
+}
+
+type UpdateProxyRequest struct {
+	Name string `json:"name"`
+}
+
+func updateProxy(w http.ResponseWriter, r *http.Request) {
+	req := UpdateProxyRequest{}
+	if err := render.DecodeJSON(r.Body, &req); err != nil {
+		render.Status(r, http.StatusBadRequest)
+		render.JSON(w, r, ErrBadRequest)
+		return
+	}
+
+	proxy := r.Context().Value(CtxKeyProxy).(C.Proxy)
+
+	selector, ok := proxy.(*A.Selector)
+	if !ok {
+		render.Status(r, http.StatusBadRequest)
+		render.JSON(w, r, ErrBadRequest)
+		return
+	}
+
+	if err := selector.Set(req.Name); err != nil {
+		render.Status(r, http.StatusBadRequest)
+		render.JSON(w, r, newError(fmt.Sprintf("Selector update error: %s", err.Error())))
+		return
+	}
+
+	render.NoContent(w, r)
+}
+
+func getProxyDelay(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	url := query.Get("url")
+	timeout, err := strconv.ParseInt(query.Get("timeout"), 10, 16)
+	if err != nil {
+		render.Status(r, http.StatusBadRequest)
+		render.JSON(w, r, ErrBadRequest)
+		return
+	}
+
+	proxy := r.Context().Value(CtxKeyProxy).(C.Proxy)
+
+	sigCh := make(chan int16)
+	go func() {
+		t, err := A.DelayTest(proxy, url)
+		if err != nil {
+			sigCh <- 0
+		}
+		sigCh <- t
+	}()
+
+	select {
+	case <-time.After(time.Millisecond * time.Duration(timeout)):
+		render.Status(r, http.StatusRequestTimeout)
+		render.JSON(w, r, ErrRequestTimeout)
+	case t := <-sigCh:
+		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, map[string]int16{
+				"delay": t,
+			})
+		}
+	}
+}

hub/route/rules.go

@@ -0,0 +1,39 @@
+package route
+
+import (
+	"net/http"
+
+	T "github.com/Dreamacro/clash/tunnel"
+
+	"github.com/go-chi/chi"
+	"github.com/go-chi/render"
+)
+
+func ruleRouter() http.Handler {
+	r := chi.NewRouter()
+	r.Get("/", getRules)
+	return r
+}
+
+type Rule struct {
+	Type    string `json:"type"`
+	Payload string `json:"payload"`
+	Proxy   string `json:"proxy"`
+}
+
+func getRules(w http.ResponseWriter, r *http.Request) {
+	rawRules := T.Instance().Rules()
+
+	var rules []Rule
+	for _, rule := range rawRules {
+		rules = append(rules, Rule{
+			Type:    rule.RuleType().String(),
+			Payload: rule.Payload(),
+			Proxy:   rule.Adapter(),
+		})
+	}
+
+	render.JSON(w, r, map[string][]Rule{
+		"rules": rules,
+	})
+}

hub/route/server.go

@@ -0,0 +1,166 @@
+package route
+
+import (
+	"encoding/json"
+	"net/http"
+	"strings"
+	"time"
+
+	"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"
+)
+
+var (
+	serverSecret = ""
+	serverAddr   = ""
+
+	uiPath = ""
+)
+
+type Traffic struct {
+	Up   int64 `json:"up"`
+	Down int64 `json:"down"`
+}
+
+func SetUIPath(path string) {
+	uiPath = path
+}
+
+func Start(addr string, secret string) {
+	if serverAddr != "" {
+		return
+	}
+
+	serverAddr = addr
+	serverSecret = secret
+
+	r := chi.NewRouter()
+
+	cors := cors.New(cors.Options{
+		AllowedOrigins: []string{"*"},
+		AllowedMethods: []string{"GET", "POST", "PUT", "PATCH", "DELETE"},
+		AllowedHeaders: []string{"Content-Type", "Authorization"},
+		MaxAge:         300,
+	})
+
+	root := chi.NewRouter().With(jsonContentType)
+	root.Get("/traffic", traffic)
+	root.Get("/logs", getLogs)
+
+	r.Get("/", hello)
+	r.Group(func(r chi.Router) {
+		r.Use(cors.Handler, authentication)
+
+		r.Mount("/", root)
+		r.Mount("/configs", configRouter())
+		r.Mount("/proxies", proxyRouter())
+		r.Mount("/rules", ruleRouter())
+	})
+
+	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/*", func(w http.ResponseWriter, r *http.Request) {
+				fs.ServeHTTP(w, r)
+			})
+		})
+	}
+
+	log.Infoln("RESTful API listening at: %s", addr)
+	err := http.ListenAndServe(addr, r)
+	if err != nil {
+		log.Errorln("External controller error: %s", err.Error())
+	}
+}
+
+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
+		}
+
+		hasUnvalidHeader := text[0] != "Bearer"
+		hasUnvalidSecret := len(text) == 2 && text[1] != serverSecret
+		if hasUnvalidHeader || hasUnvalidSecret {
+			render.Status(r, http.StatusUnauthorized)
+			render.JSON(w, r, ErrUnauthorized)
+			return
+		}
+		next.ServeHTTP(w, r)
+	}
+	return http.HandlerFunc(fn)
+}
+
+func hello(w http.ResponseWriter, r *http.Request) {
+	render.JSON(w, r, render.M{"hello": "clash"})
+}
+
+func traffic(w http.ResponseWriter, r *http.Request) {
+	render.Status(r, http.StatusOK)
+
+	tick := time.NewTicker(time.Second)
+	t := T.Instance().Traffic()
+	for range tick.C {
+		up, down := t.Now()
+		if err := json.NewEncoder(w).Encode(Traffic{
+			Up:   up,
+			Down: down,
+		}); err != nil {
+			break
+		}
+		w.(http.Flusher).Flush()
+	}
+}
+
+type Log struct {
+	Type    string `json:"type"`
+	Payload string `json:"payload"`
+}
+
+func getLogs(w http.ResponseWriter, r *http.Request) {
+	levelText := r.URL.Query().Get("level")
+	if levelText == "" {
+		levelText = "info"
+	}
+
+	level, ok := log.LogLevelMapping[levelText]
+	if !ok {
+		render.Status(r, http.StatusBadRequest)
+		render.JSON(w, r, ErrBadRequest)
+		return
+	}
+
+	sub := log.Subscribe()
+	render.Status(r, http.StatusOK)
+	for elm := range sub {
+		log := elm.(*log.Event)
+		if log.LogLevel < level {
+			continue
+		}
+
+		if err := json.NewEncoder(w).Encode(Log{
+			Type:    log.Type(),
+			Payload: log.Payload,
+		}); err != nil {
+			break
+		}
+		w.(http.Flusher).Flush()
+	}
+}

hub/rules.go

@@ -1,53 +0,0 @@
-package hub
-
-import (
-	"net/http"
-
-	"github.com/go-chi/chi"
-	"github.com/go-chi/render"
-)
-
-func ruleRouter() http.Handler {
-	r := chi.NewRouter()
-	r.Get("/", getRules)
-	r.Put("/", updateRules)
-	return r
-}
-
-type Rule struct {
-	Name    string `json:"name"`
-	Payload string `json:"type"`
-}
-
-type GetRulesResponse struct {
-	Rules []Rule `json:"rules"`
-}
-
-func getRules(w http.ResponseWriter, r *http.Request) {
-	rawRules := cfg.Rules()
-
-	var rules []Rule
-	for _, rule := range rawRules {
-		rules = append(rules, Rule{
-			Name:    rule.RuleType().String(),
-			Payload: rule.Payload(),
-		})
-	}
-
-	w.WriteHeader(http.StatusOK)
-	render.JSON(w, r, GetRulesResponse{
-		Rules: rules,
-	})
-}
-
-func updateRules(w http.ResponseWriter, r *http.Request) {
-	err := cfg.UpdateRules()
-	if err != nil {
-		w.WriteHeader(http.StatusInternalServerError)
-		render.JSON(w, r, Error{
-			Error: err.Error(),
-		})
-		return
-	}
-	w.WriteHeader(http.StatusNoContent)
-}

hub/server.go

@@ -1,137 +0,0 @@
-package hub
-
-import (
-	"encoding/json"
-	"net/http"
-	"time"
-
-	"github.com/Dreamacro/clash/config"
-	C "github.com/Dreamacro/clash/constant"
-	T "github.com/Dreamacro/clash/tunnel"
-
-	"github.com/go-chi/chi"
-	"github.com/go-chi/cors"
-	"github.com/go-chi/render"
-	log "github.com/sirupsen/logrus"
-)
-
-type Traffic struct {
-	Up   int64 `json:"up"`
-	Down int64 `json:"down"`
-}
-
-func newHub(signal chan struct{}) {
-	var addr string
-	ch := config.Instance().Subscribe()
-	signal <- struct{}{}
-	for {
-		elm := <-ch
-		event := elm.(*config.Event)
-		if event.Type == "external-controller" {
-			addr = event.Payload.(string)
-			break
-		}
-	}
-
-	r := chi.NewRouter()
-
-	cors := cors.New(cors.Options{
-		AllowedOrigins: []string{"*"},
-		AllowedMethods: []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
-		AllowedHeaders: []string{"Content-Type"},
-		MaxAge:         300,
-	})
-
-	r.Use(cors.Handler)
-
-	r.With(jsonContentType).Get("/traffic", traffic)
-	r.With(jsonContentType).Get("/logs", getLogs)
-	r.Mount("/configs", configRouter())
-	r.Mount("/proxies", proxyRouter())
-	r.Mount("/rules", ruleRouter())
-
-	log.Infof("RESTful API listening at: %s", addr)
-	err := http.ListenAndServe(addr, r)
-	if err != nil {
-		log.Errorf("External controller error: %s", err.Error())
-	}
-}
-
-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 traffic(w http.ResponseWriter, r *http.Request) {
-	w.WriteHeader(http.StatusOK)
-
-	tick := time.NewTicker(time.Second)
-	t := tunnel.Traffic()
-	for range tick.C {
-		up, down := t.Now()
-		if err := json.NewEncoder(w).Encode(Traffic{
-			Up:   up,
-			Down: down,
-		}); err != nil {
-			break
-		}
-		w.(http.Flusher).Flush()
-	}
-}
-
-type Log struct {
-	Type    string `json:"type"`
-	Payload string `json:"payload"`
-}
-
-func getLogs(w http.ResponseWriter, r *http.Request) {
-	levelText := r.URL.Query().Get("level")
-	if levelText == "" {
-		levelText = "info"
-	}
-
-	level, ok := C.LogLevelMapping[levelText]
-	if !ok {
-		w.WriteHeader(http.StatusBadRequest)
-		render.JSON(w, r, Error{
-			Error: "Level error",
-		})
-		return
-	}
-
-	src := tunnel.Log()
-	sub, err := src.Subscribe()
-	defer src.UnSubscribe(sub)
-	if err != nil {
-		w.WriteHeader(http.StatusInternalServerError)
-		render.JSON(w, r, Error{
-			Error: err.Error(),
-		})
-		return
-	}
-	render.Status(r, http.StatusOK)
-	for elm := range sub {
-		log := elm.(T.Log)
-		if log.LogLevel > level {
-			continue
-		}
-
-		if err := json.NewEncoder(w).Encode(Log{
-			Type:    log.Type(),
-			Payload: log.Payload,
-		}); err != nil {
-			break
-		}
-		w.(http.Flusher).Flush()
-	}
-}
-
-// Run initial hub
-func Run() {
-	signal := make(chan struct{})
-	go newHub(signal)
-	<-signal
-}

log/level.go

@@ -0,0 +1,73 @@
+package log
+
+import (
+	"encoding/json"
+	"errors"
+)
+
+var (
+	// LogLevelMapping is a mapping for LogLevel enum
+	LogLevelMapping = map[string]LogLevel{
+		ERROR.String():   ERROR,
+		WARNING.String(): WARNING,
+		INFO.String():    INFO,
+		DEBUG.String():   DEBUG,
+		SILENT.String():  SILENT,
+	}
+)
+
+const (
+	DEBUG LogLevel = iota
+	INFO
+	WARNING
+	ERROR
+	SILENT
+)
+
+type LogLevel int
+
+// UnmarshalYAML unserialize LogLevel with yaml
+func (l *LogLevel) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var tp string
+	unmarshal(&tp)
+	level, exist := LogLevelMapping[tp]
+	if !exist {
+		return errors.New("invalid mode")
+	}
+	*l = level
+	return nil
+}
+
+// UnmarshalJSON unserialize LogLevel with json
+func (l *LogLevel) UnmarshalJSON(data []byte) error {
+	var tp string
+	json.Unmarshal(data, &tp)
+	level, exist := LogLevelMapping[tp]
+	if !exist {
+		return errors.New("invalid mode")
+	}
+	*l = level
+	return nil
+}
+
+// MarshalJSON serialize LogLevel with json
+func (l LogLevel) MarshalJSON() ([]byte, error) {
+	return json.Marshal(l.String())
+}
+
+func (l LogLevel) String() string {
+	switch l {
+	case INFO:
+		return "info"
+	case WARNING:
+		return "warning"
+	case ERROR:
+		return "error"
+	case DEBUG:
+		return "debug"
+	case SILENT:
+		return "silent"
+	default:
+		return "unknown"
+	}
+}

log/log.go

@@ -0,0 +1,93 @@
+package log
+
+import (
+	"fmt"
+
+	"github.com/Dreamacro/clash/common/observable"
+
+	log "github.com/sirupsen/logrus"
+)
+
+var (
+	logCh  = make(chan interface{})
+	source = observable.NewObservable(logCh)
+	level  = INFO
+)
+
+func init() {
+	log.SetLevel(log.DebugLevel)
+}
+
+type Event struct {
+	LogLevel LogLevel
+	Payload  string
+}
+
+func (e *Event) Type() string {
+	return e.LogLevel.String()
+}
+
+func Infoln(format string, v ...interface{}) {
+	event := newLog(INFO, format, v...)
+	logCh <- event
+	print(event)
+}
+
+func Warnln(format string, v ...interface{}) {
+	event := newLog(WARNING, format, v...)
+	logCh <- event
+	print(event)
+}
+
+func Errorln(format string, v ...interface{}) {
+	event := newLog(ERROR, format, v...)
+	logCh <- event
+	print(event)
+}
+
+func Debugln(format string, v ...interface{}) {
+	event := newLog(DEBUG, format, v...)
+	logCh <- event
+	print(event)
+}
+
+func Fatalln(format string, v ...interface{}) {
+	log.Fatalf(format, v...)
+}
+
+func Subscribe() observable.Subscription {
+	sub, _ := source.Subscribe()
+	return sub
+}
+
+func Level() LogLevel {
+	return level
+}
+
+func SetLevel(newLevel LogLevel) {
+	level = newLevel
+}
+
+func print(data *Event) {
+	if data.LogLevel < level {
+		return
+	}
+
+	switch data.LogLevel {
+	case INFO:
+		log.Infoln(data.Payload)
+	case WARNING:
+		log.Warnln(data.Payload)
+	case ERROR:
+		log.Errorln(data.Payload)
+	case DEBUG:
+		log.Debugln(data.Payload)
+	}
+}
+
+func newLog(logLevel LogLevel, format string, v ...interface{}) *Event {
+	return &Event{
+		LogLevel: logLevel,
+		Payload:  fmt.Sprintf(format, v...),
+	}
+}

main.go

@@ -1,26 +1,42 @@
 package main
 
 import (
+	"flag"
 	"os"
 	"os/signal"
+	"path/filepath"
 	"syscall"
 
 	"github.com/Dreamacro/clash/config"
+	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/hub"
-	"github.com/Dreamacro/clash/proxy"
-	"github.com/Dreamacro/clash/tunnel"
 
 	log "github.com/sirupsen/logrus"
 )
 
-func main() {
+var (
-	tunnel.Instance().Run()
+	homedir string
-	proxy.Instance().Run()
+)
-	hub.Run()
 
-	config.Init()
+func init() {
-	err := config.Instance().Parse()
+	flag.StringVar(&homedir, "d", "", "set configuration directory")
-	if err != nil {
+	flag.Parse()
+}
+
+func main() {
+	if homedir != "" {
+		if !filepath.IsAbs(homedir) {
+			currentDir, _ := os.Getwd()
+			homedir = filepath.Join(currentDir, homedir)
+		}
+		C.SetHomeDir(homedir)
+	}
+
+	if err := config.Init(C.Path.HomeDir()); err != nil {
+		log.Fatalf("Initial configuration directory error: %s", err.Error())
+	}
+
+	if err := hub.Parse(); err != nil {
 		log.Fatalf("Parse config error: %s", err.Error())
 	}
 

proxy/http/server.go

@@ -5,36 +5,34 @@ import (
 	"net"
 	"net/http"
 
-	"github.com/Dreamacro/clash/adapters/local"
+	"github.com/Dreamacro/clash/adapters/inbound"
-	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/log"
 	"github.com/Dreamacro/clash/tunnel"
-
-	log "github.com/sirupsen/logrus"
 )
 
 var (
 	tun = tunnel.Instance()
 )
 
-func NewHttpProxy(addr string) (*C.ProxySignal, error) {
+type HttpListener struct {
+	net.Listener
+	address string
+	closed  bool
+}
+
+func NewHttpProxy(addr string) (*HttpListener, error) {
 	l, err := net.Listen("tcp", addr)
 	if err != nil {
 		return nil, err
 	}
-
+	hl := &HttpListener{l, addr, false}
-	done := make(chan struct{})
-	closed := make(chan struct{})
-	signal := &C.ProxySignal{
-		Done:   done,
-		Closed: closed,
-	}
 
 	go func() {
-		log.Infof("HTTP proxy listening at: %s", addr)
+		log.Infoln("HTTP proxy listening at: %s", addr)
 		for {
-			c, err := l.Accept()
+			c, err := hl.Accept()
 			if err != nil {
-				if _, open := <-done; !open {
+				if hl.closed {
 					break
 				}
 				continue
@@ -43,14 +41,16 @@ func NewHttpProxy(addr string) (*C.ProxySignal, error) {
 		}
 	}()
 
-	go func() {
+	return hl, nil
-		<-done
+}
-		close(done)
-		l.Close()
-		closed <- struct{}{}
-	}()
 
-	return signal, nil
+func (l *HttpListener) Close() {
+	l.closed = true
+	l.Listener.Close()
+}
+
+func (l *HttpListener) Address() string {
+	return l.address
 }
 
 func handleConn(conn net.Conn) {

proxy/listener.go

@@ -1,116 +1,150 @@
 package proxy
 
 import (
-	"sync"
+	"fmt"
+	"net"
+	"strconv"
 
-	"github.com/Dreamacro/clash/config"
-	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/proxy/http"
 	"github.com/Dreamacro/clash/proxy/redir"
 	"github.com/Dreamacro/clash/proxy/socks"
 )
 
 var (
-	listener *Listener
+	allowLan = false
-	once     sync.Once
+
+	socksListener *socks.SockListener
+	httpListener  *http.HttpListener
+	redirListener *redir.RedirListener
 )
 
-type Listener struct {
+type listener interface {
-	// signal for update
+	Close()
-	httpSignal  *C.ProxySignal
+	Address() string
-	socksSignal *C.ProxySignal
-	redirSignal *C.ProxySignal
 }
 
-func (l *Listener) updateHTTP(addr string) error {
+type Ports struct {
-	if l.httpSignal != nil {
+	Port      int `json:"port"`
-		signal := l.httpSignal
+	SocksPort int `json:"socks-port"`
-		signal.Done <- struct{}{}
+	RedirPort int `json:"redir-port"`
-		<-signal.Closed
-		l.httpSignal = nil
-	}
-
-	signal, err := http.NewHttpProxy(addr)
-	if err != nil {
-		return err
-	}
-
-	l.httpSignal = signal
-	return nil
 }
 
-func (l *Listener) updateSocks(addr string) error {
+func AllowLan() bool {
-	if l.socksSignal != nil {
+	return allowLan
-		signal := l.socksSignal
-		signal.Done <- struct{}{}
-		<-signal.Closed
-		l.socksSignal = nil
-	}
-
-	signal, err := socks.NewSocksProxy(addr)
-	if err != nil {
-		return err
-	}
-
-	l.socksSignal = signal
-	return nil
 }
 
-func (l *Listener) updateRedir(addr string) error {
+func SetAllowLan(al bool) {
-	if l.redirSignal != nil {
+	allowLan = al
-		signal := l.redirSignal
-		signal.Done <- struct{}{}
-		<-signal.Closed
-		l.redirSignal = nil
-	}
-
-	signal, err := redir.NewRedirProxy(addr)
-	if err != nil {
-		return err
-	}
-
-	l.redirSignal = signal
-	return nil
 }
 
-func (l *Listener) process(signal chan<- struct{}) {
+func ReCreateHTTP(port int) error {
-	sub := config.Instance().Subscribe()
+	addr := genAddr(port, allowLan)
-	signal <- struct{}{}
+
-	reportCH := config.Instance().Report()
+	if httpListener != nil {
-	for elm := range sub {
+		if httpListener.Address() == addr {
-		event := elm.(*config.Event)
+			return nil
-		switch event.Type {
-		case "http-addr":
-			addr := event.Payload.(string)
-			err := l.updateHTTP(addr)
-			reportCH <- &config.Event{Type: "http-addr", Payload: err == nil}
-		case "socks-addr":
-			addr := event.Payload.(string)
-			err := l.updateSocks(addr)
-			reportCH <- &config.Event{Type: "socks-addr", Payload: err == nil}
-		case "redir-addr":
-			addr := event.Payload.(string)
-			err := l.updateRedir(addr)
-			reportCH <- &config.Event{Type: "redir-addr", Payload: err == nil}
 		}
+		httpListener.Close()
+		httpListener = nil
 	}
+
+	if portIsZero(addr) {
+		return nil
+	}
+
+	var err error
+	httpListener, err = http.NewHttpProxy(addr)
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
-// Run ensure config monitoring
+func ReCreateSocks(port int) error {
-func (l *Listener) Run() {
+	addr := genAddr(port, allowLan)
-	signal := make(chan struct{})
+
-	go l.process(signal)
+	if socksListener != nil {
-	<-signal
+		if socksListener.Address() == addr {
+			return nil
+		}
+		socksListener.Close()
+		socksListener = nil
+	}
+
+	if portIsZero(addr) {
+		return nil
+	}
+
+	var err error
+	socksListener, err = socks.NewSocksProxy(addr)
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
-func newListener() *Listener {
+func ReCreateRedir(port int) error {
-	return &Listener{}
+	addr := genAddr(port, allowLan)
+
+	if redirListener != nil {
+		if redirListener.Address() == addr {
+			return nil
+		}
+		redirListener.Close()
+		redirListener = nil
+	}
+
+	if portIsZero(addr) {
+		return nil
+	}
+
+	var err error
+	redirListener, err = redir.NewRedirProxy(addr)
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
-// Instance return singleton instance of Listener
+// GetPorts return the ports of proxy servers
-func Instance() *Listener {
+func GetPorts() *Ports {
-	once.Do(func() {
+	ports := &Ports{}
-		listener = newListener()
+
-	})
+	if httpListener != nil {
-	return listener
+		_, portStr, _ := net.SplitHostPort(httpListener.Address())
+		port, _ := strconv.Atoi(portStr)
+		ports.Port = port
+	}
+
+	if socksListener != nil {
+		_, portStr, _ := net.SplitHostPort(socksListener.Address())
+		port, _ := strconv.Atoi(portStr)
+		ports.SocksPort = port
+	}
+
+	if redirListener != nil {
+		_, portStr, _ := net.SplitHostPort(redirListener.Address())
+		port, _ := strconv.Atoi(portStr)
+		ports.RedirPort = port
+	}
+
+	return ports
+}
+
+func portIsZero(addr string) bool {
+	_, port, err := net.SplitHostPort(addr)
+	if port == "0" || port == "" || err != nil {
+		return true
+	}
+	return false
+}
+
+func genAddr(port int, allowLan bool) string {
+	if allowLan {
+		return fmt.Sprintf(":%d", port)
+	}
+	return fmt.Sprintf("127.0.0.1:%d", port)
 }

proxy/redir/tcp.go

@@ -3,36 +3,35 @@ package redir
 import (
 	"net"
 
-	"github.com/Dreamacro/clash/adapters/local"
+	"github.com/Dreamacro/clash/adapters/inbound"
 	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/log"
 	"github.com/Dreamacro/clash/tunnel"
-
-	log "github.com/sirupsen/logrus"
 )
 
 var (
 	tun = tunnel.Instance()
 )
 
-func NewRedirProxy(addr string) (*C.ProxySignal, error) {
+type RedirListener struct {
+	net.Listener
+	address string
+	closed  bool
+}
+
+func NewRedirProxy(addr string) (*RedirListener, error) {
 	l, err := net.Listen("tcp", addr)
 	if err != nil {
 		return nil, err
 	}
-
+	rl := &RedirListener{l, addr, false}
-	done := make(chan struct{})
-	closed := make(chan struct{})
-	signal := &C.ProxySignal{
-		Done:   done,
-		Closed: closed,
-	}
 
 	go func() {
-		log.Infof("Redir proxy listening at: %s", addr)
+		log.Infoln("Redir proxy listening at: %s", addr)
 		for {
 			c, err := l.Accept()
 			if err != nil {
-				if _, open := <-done; !open {
+				if rl.closed {
 					break
 				}
 				continue
@@ -41,14 +40,16 @@ func NewRedirProxy(addr string) (*C.ProxySignal, error) {
 		}
 	}()
 
-	go func() {
+	return rl, nil
-		<-done
+}
-		close(done)
-		l.Close()
-		closed <- struct{}{}
-	}()
 
-	return signal, nil
+func (l *RedirListener) Close() {
+	l.closed = true
+	l.Listener.Close()
+}
+
+func (l *RedirListener) Address() string {
+	return l.address
 }
 
 func handleRedir(conn net.Conn) {
@@ -58,5 +59,5 @@ func handleRedir(conn net.Conn) {
 		return
 	}
 	conn.(*net.TCPConn).SetKeepAlive(true)
-	tun.Add(adapters.NewSocket(target, conn))
+	tun.Add(adapters.NewSocket(target, conn, C.REDIR))
 }

proxy/redir/tcp_darwin.go

@@ -5,7 +5,7 @@ import (
 	"syscall"
 	"unsafe"
 
-	"github.com/riobard/go-shadowsocks2/socks"
+	"github.com/Dreamacro/go-shadowsocks2/socks"
 )
 
 func parserPacket(c net.Conn) (socks.Addr, error) {

proxy/redir/tcp_freebsd.go

@@ -0,0 +1,52 @@
+package redir
+
+import (
+	"errors"
+	"net"
+	"syscall"
+	"unsafe"
+
+	"github.com/Dreamacro/go-shadowsocks2/socks"
+)
+
+const (
+	SO_ORIGINAL_DST      = 80 // from linux/include/uapi/linux/netfilter_ipv4.h
+	IP6T_SO_ORIGINAL_DST = 80 // from linux/include/uapi/linux/netfilter_ipv6/ip6_tables.h
+)
+
+func parserPacket(conn net.Conn) (socks.Addr, error) {
+	c, ok := conn.(*net.TCPConn)
+	if !ok {
+		return nil, errors.New("only work with TCP connection")
+	}
+
+	rc, err := c.SyscallConn()
+	if err != nil {
+		return nil, err
+	}
+
+	var addr socks.Addr
+
+	rc.Control(func(fd uintptr) {
+		addr, err = getorigdst(fd)
+	})
+
+	return addr, err
+}
+
+// Call getorigdst() from linux/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
+func getorigdst(fd uintptr) (socks.Addr, error) {
+	raw := syscall.RawSockaddrInet4{}
+	siz := unsafe.Sizeof(raw)
+	_, _, err := syscall.Syscall6(syscall.SYS_GETSOCKOPT, fd, syscall.IPPROTO_IP, SO_ORIGINAL_DST, uintptr(unsafe.Pointer(&raw)), uintptr(unsafe.Pointer(&siz)), 0)
+	if err != 0 {
+		return nil, err
+	}
+
+	addr := make([]byte, 1+net.IPv4len+2)
+	addr[0] = socks.AtypIPv4
+	copy(addr[1:1+net.IPv4len], raw.Addr[:])
+	port := (*[2]byte)(unsafe.Pointer(&raw.Port)) // big-endian
+	addr[1+net.IPv4len], addr[1+net.IPv4len+1] = port[0], port[1]
+	return addr, nil
+}

proxy/redir/tcp_linux.go

@@ -6,7 +6,7 @@ import (
 	"syscall"
 	"unsafe"
 
-	"github.com/riobard/go-shadowsocks2/socks"
+	"github.com/Dreamacro/go-shadowsocks2/socks"
 )
 
 const (

proxy/redir/tcp_windows.go

@@ -4,7 +4,7 @@ import (
 	"errors"
 	"net"
 
-	"github.com/riobard/go-shadowsocks2/socks"
+	"github.com/Dreamacro/go-shadowsocks2/socks"
 )
 
 func parserPacket(conn net.Conn) (socks.Addr, error) {

proxy/socks/tcp.go

@@ -3,37 +3,37 @@ package socks
 import (
 	"net"
 
-	"github.com/Dreamacro/clash/adapters/local"
+	"github.com/Dreamacro/clash/adapters/inbound"
 	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/log"
 	"github.com/Dreamacro/clash/tunnel"
 
-	"github.com/riobard/go-shadowsocks2/socks"
+	"github.com/Dreamacro/go-shadowsocks2/socks"
-	log "github.com/sirupsen/logrus"
 )
 
 var (
 	tun = tunnel.Instance()
 )
 
-func NewSocksProxy(addr string) (*C.ProxySignal, error) {
+type SockListener struct {
+	net.Listener
+	address string
+	closed  bool
+}
+
+func NewSocksProxy(addr string) (*SockListener, error) {
 	l, err := net.Listen("tcp", addr)
 	if err != nil {
 		return nil, err
 	}
 
-	done := make(chan struct{})
+	sl := &SockListener{l, addr, false}
-	closed := make(chan struct{})
-	signal := &C.ProxySignal{
-		Done:   done,
-		Closed: closed,
-	}
-
 	go func() {
-		log.Infof("SOCKS proxy listening at: %s", addr)
+		log.Infoln("SOCKS proxy listening at: %s", addr)
 		for {
 			c, err := l.Accept()
 			if err != nil {
-				if _, open := <-done; !open {
+				if sl.closed {
 					break
 				}
 				continue
@@ -42,14 +42,16 @@ func NewSocksProxy(addr string) (*C.ProxySignal, error) {
 		}
 	}()
 
-	go func() {
+	return sl, nil
-		<-done
+}
-		close(done)
-		l.Close()
-		closed <- struct{}{}
-	}()
 
-	return signal, nil
+func (l *SockListener) Close() {
+	l.closed = true
+	l.Listener.Close()
+}
+
+func (l *SockListener) Address() string {
+	return l.address
 }
 
 func handleSocks(conn net.Conn) {
@@ -59,5 +61,5 @@ func handleSocks(conn net.Conn) {
 		return
 	}
 	conn.(*net.TCPConn).SetKeepAlive(true)
-	tun.Add(adapters.NewSocket(target, conn))
+	tun.Add(adapters.NewSocket(target, conn, C.SOCKS))
 }

rules/domain.go

@@ -1,6 +1,8 @@
 package rules
 
 import (
+	"strings"
+
 	C "github.com/Dreamacro/clash/constant"
 )
 
@@ -13,11 +15,11 @@ func (d *Domain) RuleType() C.RuleType {
 	return C.Domain
 }
 
-func (d *Domain) IsMatch(addr *C.Addr) bool {
+func (d *Domain) IsMatch(metadata *C.Metadata) bool {
-	if addr.AddrType != C.AtypDomainName {
+	if metadata.AddrType != C.AtypDomainName {
 		return false
 	}
-	return addr.Host == d.domain
+	return metadata.Host == d.domain
 }
 
 func (d *Domain) Adapter() string {
@@ -30,7 +32,7 @@ func (d *Domain) Payload() string {
 
 func NewDomain(domain string, adapter string) *Domain {
 	return &Domain{
-		domain:  domain,
+		domain:  strings.ToLower(domain),
 		adapter: adapter,
 	}
 }

rules/domain_keyword.go

@@ -15,11 +15,11 @@ func (dk *DomainKeyword) RuleType() C.RuleType {
 	return C.DomainKeyword
 }
 
-func (dk *DomainKeyword) IsMatch(addr *C.Addr) bool {
+func (dk *DomainKeyword) IsMatch(metadata *C.Metadata) bool {
-	if addr.AddrType != C.AtypDomainName {
+	if metadata.AddrType != C.AtypDomainName {
 		return false
 	}
-	domain := addr.Host
+	domain := metadata.Host
 	return strings.Contains(domain, dk.keyword)
 }
 
@@ -33,7 +33,7 @@ func (dk *DomainKeyword) Payload() string {
 
 func NewDomainKeyword(keyword string, adapter string) *DomainKeyword {
 	return &DomainKeyword{
-		keyword: keyword,
+		keyword: strings.ToLower(keyword),
 		adapter: adapter,
 	}
 }

rules/domain_suffix.go

@@ -15,11 +15,11 @@ func (ds *DomainSuffix) RuleType() C.RuleType {
 	return C.DomainSuffix
 }
 
-func (ds *DomainSuffix) IsMatch(addr *C.Addr) bool {
+func (ds *DomainSuffix) IsMatch(metadata *C.Metadata) bool {
-	if addr.AddrType != C.AtypDomainName {
+	if metadata.AddrType != C.AtypDomainName {
 		return false
 	}
-	domain := addr.Host
+	domain := metadata.Host
 	return strings.HasSuffix(domain, "."+ds.suffix) || domain == ds.suffix
 }
 
@@ -33,7 +33,7 @@ func (ds *DomainSuffix) Payload() string {
 
 func NewDomainSuffix(suffix string, adapter string) *DomainSuffix {
 	return &DomainSuffix{
-		suffix:  suffix,
+		suffix:  strings.ToLower(suffix),
 		adapter: adapter,
 	}
 }

rules/final.go

@@ -12,7 +12,7 @@ func (f *Final) RuleType() C.RuleType {
 	return C.FINAL
 }
 
-func (f *Final) IsMatch(addr *C.Addr) bool {
+func (f *Final) IsMatch(metadata *C.Metadata) bool {
 	return true
 }
 

rules/geoip.go

@@ -23,11 +23,11 @@ func (g *GEOIP) RuleType() C.RuleType {
 	return C.GEOIP
 }
 
-func (g *GEOIP) IsMatch(addr *C.Addr) bool {
+func (g *GEOIP) IsMatch(metadata *C.Metadata) bool {
-	if addr.IP == nil {
+	if metadata.IP == nil {
 		return false
 	}
-	record, _ := mmdb.Country(*addr.IP)
+	record, _ := mmdb.Country(*metadata.IP)
 	return record.Country.IsoCode == g.country
 }
 
@@ -42,7 +42,7 @@ func (g *GEOIP) Payload() string {
 func NewGEOIP(country string, adapter string) *GEOIP {
 	once.Do(func() {
 		var err error
-		mmdb, err = geoip2.Open(C.MMDBPath)
+		mmdb, err = geoip2.Open(C.Path.MMDB())
 		if err != nil {
 			log.Fatalf("Can't load mmdb: %s", err.Error())
 		}

rules/ipcidr.go

@@ -7,20 +7,24 @@ import (
 )
 
 type IPCIDR struct {
-	ipnet   *net.IPNet
+	ipnet      *net.IPNet
-	adapter string
+	adapter    string
+	isSourceIP bool
 }
 
 func (i *IPCIDR) RuleType() C.RuleType {
+	if i.isSourceIP {
+		return C.SourceIPCIDR
+	}
 	return C.IPCIDR
 }
 
-func (i *IPCIDR) IsMatch(addr *C.Addr) bool {
+func (i *IPCIDR) IsMatch(metadata *C.Metadata) bool {
-	if addr.IP == nil {
+	ip := metadata.IP
-		return false
+	if i.isSourceIP {
+		ip = metadata.SourceIP
 	}
-
+	return i.ipnet.Contains(*ip)
-	return i.ipnet.Contains(*addr.IP)
 }
 
 func (i *IPCIDR) Adapter() string {
@@ -31,12 +35,13 @@ func (i *IPCIDR) Payload() string {
 	return i.ipnet.String()
 }
 
-func NewIPCIDR(s string, adapter string) *IPCIDR {
+func NewIPCIDR(s string, adapter string, isSourceIP bool) *IPCIDR {
 	_, ipnet, err := net.ParseCIDR(s)
 	if err != nil {
 	}
 	return &IPCIDR{
-		ipnet:   ipnet,
+		ipnet:      ipnet,
-		adapter: adapter,
+		adapter:    adapter,
+		isSourceIP: isSourceIP,
 	}
 }

tunnel/connection.go

@@ -5,17 +5,33 @@ import (
 	"io"
 	"net"
 	"net/http"
+	"strings"
+	"sync"
+	"time"
 
-	"github.com/Dreamacro/clash/adapters/local"
+	adapters "github.com/Dreamacro/clash/adapters/inbound"
-	C "github.com/Dreamacro/clash/constant"
 )
 
-func (t *Tunnel) handleHTTP(request *adapters.HTTPAdapter, proxy C.ProxyAdapter) {
+const (
-	conn := newTrafficTrack(proxy.Conn(), t.traffic)
+	// io.Copy default buffer size is 32 KiB
+	// but the maximum packet size of vmess/shadowsocks is about 16 KiB
+	// so define a buffer of 20 KiB to reduce the memory of each TCP relay
+	bufferSize = 20 * 1024
+)
+
+var bufPool = sync.Pool{New: func() interface{} { return make([]byte, bufferSize) }}
+
+func (t *Tunnel) handleHTTP(request *adapters.HTTPAdapter, outbound net.Conn) {
+	conn := newTrafficTrack(outbound, t.traffic)
 	req := request.R
 	host := req.Host
+	keepalive := true
 
 	for {
+		if strings.ToLower(req.Header.Get("Connection")) == "close" {
+			keepalive = false
+		}
+
 		req.Header.Set("Connection", "close")
 		req.RequestURI = ""
 		adapters.RemoveHopByHopHeaders(req.Header)
@@ -42,6 +58,10 @@ func (t *Tunnel) handleHTTP(request *adapters.HTTPAdapter, proxy C.ProxyAdapter)
 			break
 		}
 
+		if !keepalive {
+			break
+		}
+
 		req, err = http.ReadRequest(bufio.NewReader(request.Conn()))
 		if err != nil {
 			break
@@ -55,8 +75,8 @@ func (t *Tunnel) handleHTTP(request *adapters.HTTPAdapter, proxy C.ProxyAdapter)
 	}
 }
 
-func (t *Tunnel) handleSOCKS(request *adapters.SocketAdapter, proxy C.ProxyAdapter) {
+func (t *Tunnel) handleSOCKS(request *adapters.SocketAdapter, outbound net.Conn) {
-	conn := newTrafficTrack(proxy.Conn(), t.traffic)
+	conn := newTrafficTrack(outbound, t.traffic)
 	relay(request.Conn(), conn)
 }
 
@@ -65,10 +85,16 @@ func relay(leftConn, rightConn net.Conn) {
 	ch := make(chan error)
 
 	go func() {
-		_, err := io.Copy(leftConn, rightConn)
+		buf := bufPool.Get().([]byte)
+		_, err := io.CopyBuffer(leftConn, rightConn, buf)
+		bufPool.Put(buf[:cap(buf)])
+		leftConn.SetReadDeadline(time.Now())
 		ch <- err
 	}()
 
-	io.Copy(rightConn, leftConn)
+	buf := bufPool.Get().([]byte)
+	io.CopyBuffer(rightConn, leftConn, buf)
+	bufPool.Put(buf[:cap(buf)])
+	rightConn.SetReadDeadline(time.Now())
 	<-ch
 }

tunnel/log.go

@@ -1,51 +0,0 @@
-package tunnel
-
-import (
-	"fmt"
-
-	C "github.com/Dreamacro/clash/constant"
-
-	log "github.com/sirupsen/logrus"
-)
-
-type Log struct {
-	LogLevel C.LogLevel
-	Payload  string
-}
-
-func (l *Log) Type() string {
-	return l.LogLevel.String()
-}
-
-func print(data Log) {
-	switch data.LogLevel {
-	case C.INFO:
-		log.Infoln(data.Payload)
-	case C.WARNING:
-		log.Warnln(data.Payload)
-	case C.ERROR:
-		log.Errorln(data.Payload)
-	case C.DEBUG:
-		log.Debugln(data.Payload)
-	}
-}
-
-func (t *Tunnel) subscribeLogs() {
-	sub, err := t.observable.Subscribe()
-	if err != nil {
-		log.Fatalf("Can't subscribe tunnel log: %s", err.Error())
-	}
-	for elm := range sub {
-		data := elm.(Log)
-		if data.LogLevel <= t.logLevel {
-			print(data)
-		}
-	}
-}
-
-func newLog(logLevel C.LogLevel, format string, v ...interface{}) Log {
-	return Log{
-		LogLevel: logLevel,
-		Payload:  fmt.Sprintf(format, v...),
-	}
-}

tunnel/mode.go

@@ -0,0 +1,65 @@
+package tunnel
+
+import (
+	"encoding/json"
+	"errors"
+)
+
+type Mode int
+
+var (
+	// ModeMapping is a mapping for Mode enum
+	ModeMapping = map[string]Mode{
+		Global.String(): Global,
+		Rule.String():   Rule,
+		Direct.String(): Direct,
+	}
+)
+
+const (
+	Global Mode = iota
+	Rule
+	Direct
+)
+
+// UnmarshalJSON unserialize Mode
+func (m *Mode) UnmarshalJSON(data []byte) error {
+	var tp string
+	json.Unmarshal(data, &tp)
+	mode, exist := ModeMapping[tp]
+	if !exist {
+		return errors.New("invalid mode")
+	}
+	*m = mode
+	return nil
+}
+
+// UnmarshalYAML unserialize Mode with yaml
+func (m *Mode) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var tp string
+	unmarshal(&tp)
+	mode, exist := ModeMapping[tp]
+	if !exist {
+		return errors.New("invalid mode")
+	}
+	*m = mode
+	return nil
+}
+
+// MarshalJSON serialize Mode
+func (m Mode) MarshalJSON() ([]byte, error) {
+	return json.Marshal(m.String())
+}
+
+func (m Mode) String() string {
+	switch m {
+	case Global:
+		return "Global"
+	case Rule:
+		return "Rule"
+	case Direct:
+		return "Direct"
+	default:
+		return "Unknow"
+	}
+}

tunnel/tunnel.go

@@ -1,15 +1,17 @@
 package tunnel
 
 import (
+	"fmt"
+	"net"
 	"sync"
 	"time"
 
-	LocalAdapter "github.com/Dreamacro/clash/adapters/local"
+	InboundAdapter "github.com/Dreamacro/clash/adapters/inbound"
-	cfg "github.com/Dreamacro/clash/config"
 	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/observable"
+	"github.com/Dreamacro/clash/dns"
+	"github.com/Dreamacro/clash/log"
 
-	"gopkg.in/eapache/channels.v1"
+	channels "gopkg.in/eapache/channels.v1"
 )
 
 var (
@@ -24,14 +26,10 @@ type Tunnel struct {
 	proxies    map[string]C.Proxy
 	configLock *sync.RWMutex
 	traffic    *C.Traffic
+	resolver   *dns.Resolver
 
 	// Outbound Rule
-	mode cfg.Mode
+	mode Mode
-
-	// Log
-	logCh      chan interface{}
-	observable *observable.Observable
-	logLevel   C.LogLevel
 }
 
 // Add request to queue
@@ -44,33 +42,47 @@ func (t *Tunnel) Traffic() *C.Traffic {
 	return t.traffic
 }
 
-// Log return clash log stream
+// Rules return all rules
-func (t *Tunnel) Log() *observable.Observable {
+func (t *Tunnel) Rules() []C.Rule {
-	return t.observable
+	return t.rules
 }
 
-func (t *Tunnel) configMonitor(signal chan<- struct{}) {
+// UpdateRules handle update rules
-	sub := cfg.Instance().Subscribe()
+func (t *Tunnel) UpdateRules(rules []C.Rule) {
-	signal <- struct{}{}
+	t.configLock.Lock()
-	for elm := range sub {
+	t.rules = rules
-		event := elm.(*cfg.Event)
+	t.configLock.Unlock()
-		switch event.Type {
+}
-		case "proxies":
+
-			proxies := event.Payload.(map[string]C.Proxy)
+// Proxies return all proxies
-			t.configLock.Lock()
+func (t *Tunnel) Proxies() map[string]C.Proxy {
-			t.proxies = proxies
+	return t.proxies
-			t.configLock.Unlock()
+}
-		case "rules":
+
-			rules := event.Payload.([]C.Rule)
+// UpdateProxies handle update proxies
-			t.configLock.Lock()
+func (t *Tunnel) UpdateProxies(proxies map[string]C.Proxy) {
-			t.rules = rules
+	t.configLock.Lock()
-			t.configLock.Unlock()
+	t.proxies = proxies
-		case "mode":
+	t.configLock.Unlock()
-			t.mode = event.Payload.(cfg.Mode)
+}
-		case "log-level":
+
-			t.logLevel = event.Payload.(C.LogLevel)
+// Mode return current mode
-		}
+func (t *Tunnel) Mode() Mode {
-	}
+	return t.mode
+}
+
+// SetMode change the mode of tunnel
+func (t *Tunnel) SetMode(mode Mode) {
+	t.mode = mode
+}
+
+// SetResolver change the resolver of tunnel
+func (t *Tunnel) SetResolver(resolver *dns.Resolver) {
+	t.resolver = resolver
+}
+
+func (t *Tunnel) hasResolver() bool {
+	return t.resolver != nil
 }
 
 func (t *Tunnel) process() {
@@ -82,73 +94,106 @@ func (t *Tunnel) process() {
 	}
 }
 
+func (t *Tunnel) resolveIP(host string) (net.IP, error) {
+	if t.resolver == nil {
+		ipAddr, err := net.ResolveIPAddr("ip", host)
+		if err != nil {
+			return nil, err
+		}
+
+		return ipAddr.IP, nil
+	}
+
+	return t.resolver.ResolveIP(host)
+}
+
+func (t *Tunnel) needLookupIP(metadata *C.Metadata) bool {
+	return t.hasResolver() && t.resolver.IsMapping() && metadata.Host == "" && metadata.IP != nil
+}
+
 func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
 	defer localConn.Close()
-	addr := localConn.Addr()
+	metadata := localConn.Metadata()
+
+	if t.needLookupIP(metadata) {
+		host, exist := t.resolver.IPToHost(*metadata.IP)
+		if exist {
+			metadata.Host = host
+			metadata.AddrType = C.AtypDomainName
+		}
+	}
 
 	var proxy C.Proxy
 	switch t.mode {
-	case cfg.Direct:
+	case Direct:
 		proxy = t.proxies["DIRECT"]
-	case cfg.Global:
+	case Global:
 		proxy = t.proxies["GLOBAL"]
 	// Rule
 	default:
-		proxy = t.match(addr)
+		var err error
+		proxy, err = t.match(metadata)
+		if err != nil {
+			return
+		}
 	}
-	remoConn, err := proxy.Generator(addr)
+
+	if !metadata.Valid() {
+		log.Warnln("[Metadata] not valid: %#v", metadata)
+		return
+	}
+
+	remoConn, err := proxy.Generator(metadata)
 	if err != nil {
-		t.logCh <- newLog(C.WARNING, "Proxy connect error: %s", err.Error())
+		log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SourceIP.String(), metadata.String(), err.Error())
 		return
 	}
 	defer remoConn.Close()
 
 	switch adapter := localConn.(type) {
-	case *LocalAdapter.HTTPAdapter:
+	case *InboundAdapter.HTTPAdapter:
 		t.handleHTTP(adapter, remoConn)
-	case *LocalAdapter.SocketAdapter:
+	case *InboundAdapter.SocketAdapter:
 		t.handleSOCKS(adapter, remoConn)
 	}
 }
 
-func (t *Tunnel) match(addr *C.Addr) C.Proxy {
+func (t *Tunnel) shouldResolveIP(rule C.Rule, metadata *C.Metadata) bool {
+	return (rule.RuleType() == C.GEOIP || rule.RuleType() == C.IPCIDR) && metadata.Host != "" && metadata.IP == nil
+}
+
+func (t *Tunnel) match(metadata *C.Metadata) (C.Proxy, error) {
 	t.configLock.RLock()
 	defer t.configLock.RUnlock()
 
 	for _, rule := range t.rules {
-		if rule.IsMatch(addr) {
+		if t.shouldResolveIP(rule, metadata) {
-			a, ok := t.proxies[rule.Adapter()]
+			ip, err := t.resolveIP(metadata.Host)
-			if !ok {
+			if err != nil {
-				continue
+				return nil, fmt.Errorf("[DNS] resolve %s error: %s", metadata.Host, err.Error())
+			}
+			log.Debugln("[DNS] %s --> %s", metadata.Host, ip.String())
+			metadata.IP = &ip
+		}
+
+		if rule.IsMatch(metadata) {
+			if a, ok := t.proxies[rule.Adapter()]; ok {
+				log.Infoln("%s --> %v match %s using %s", metadata.SourceIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter())
+				return a, nil
 			}
-			t.logCh <- newLog(C.INFO, "%v match %s using %s", addr.String(), rule.RuleType().String(), rule.Adapter())
-			return a
 		}
 	}
-	t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", addr.String())
+	log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SourceIP.String(), metadata.String())
-	return t.proxies["DIRECT"]
+	return t.proxies["DIRECT"], nil
-}
-
-// Run initial task
-func (t *Tunnel) Run() {
-	go t.process()
-	go t.subscribeLogs()
-	signal := make(chan struct{})
-	go t.configMonitor(signal)
-	<-signal
 }
 
 func newTunnel() *Tunnel {
-	logCh := make(chan interface{})
 	return &Tunnel{
 		queue:      channels.NewInfiniteChannel(),
 		proxies:    make(map[string]C.Proxy),
-		observable: observable.NewObservable(logCh),
-		logCh:      logCh,
 		configLock: &sync.RWMutex{},
 		traffic:    C.NewTraffic(time.Second),
-		mode:       cfg.Rule,
+		mode:       Rule,
-		logLevel:   C.INFO,
 	}
 }
 
@@ -156,6 +201,7 @@ func newTunnel() *Tunnel {
 func Instance() *Tunnel {
 	once.Do(func() {
 		tunnel = newTunnel()
+		go tunnel.process()
 	})
 	return tunnel
 }