Chore: update README.md

Chore: update ss-lib for xchacha20-ietf-poly1305
Fix: a typo error
2018-10-17 00:51:04 +08:00 · 2018-10-16 21:29:29 +08:00 · 2018-10-16 17:23:58 +08:00 · 2018-10-16 13:12:36 +08:00 · 2018-10-14 21:22:58 +08:00 · 2018-10-10 12:05:02 +08:00
59 changed files with 1062 additions and 610 deletions
--- a/.travis.yml
+++ b/.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
--- a/8
+++ b/8
@ -2,11 +2,9 @@ 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
-RUN curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh && \
-    mkdir -p /go/src/github.com/Dreamacro/clash
-WORKDIR /go/src/github.com/Dreamacro/clash
-COPY . /go/src/github.com/Dreamacro/clash
-RUN dep ensure && \
+WORKDIR /clash-src
+COPY . /clash-src
+RUN go mod download && \
    GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -ldflags '-w -s' -o /clash && \
    chmod +x /clash

--- a/Gopkg.lock
+++ b/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
--- a/Gopkg.toml
+++ b/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
--- a/README.md
+++ b/README.md
@ -62,51 +62,82 @@ If you have Docker installed, you can run clash directly using `docker-compose`.

 ## Config

-Configuration file at `$HOME/.config/clash/config.ini`
+**NOTE: after v0.8.0, clash using yaml as configuration file**
+
+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
-[General]
-port = 7890
-socks-port = 7891
+```yml
+# port of HTTP
+port: 7890
+
+# port of SOCKS5
+socks-port: 7891

 # redir proxy for Linux and macOS
-redir-port = 7892
+# 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
+log-level: info

 # A RESTful API for clash
-external-controller = 127.0.0.1:8080
+external-controller: 127.0.0.1:9090

-[Proxy]
-# name = ss, server, port, cipher, password(, obfs=tls/http, obfs-host=bing.com)
+# Secret for RESTful API (Optional)
+secret: ""
+
+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
-ss2 = ss, server2, port, AEAD_CHACHA20_POLY1305, password
+# In addition to what go-shadowsocks2 supports, it also supports chacha20 rc4-md5 xchacha20-ietf-poly1305
+- { name: "ss1", type: ss, server: server, port: 443, cipher: AEAD_CHACHA20_POLY1305, password: "password" }
+- { name: "ss2", type: ss, server: server, port: 443, cipher: AEAD_CHACHA20_POLY1305, password: "password", obfs: tls, obfs-host: bing.com }

-# name = vmess, server, port, uuid, alterId, cipher(, tls=true)
+# vmess
 # cipher support auto/aes-128-gcm/chacha20-poly1305/none
-vmess1 = vmess, server, port, uuid, 32, auto, tls=true
+- { name: "vmess1", type: vmess, server: server, port: 443, uuid: uuid, alterId: 32, cipher: auto }
+- { name: "vmess2", type: vmess, server: server, port: 443, uuid: uuid, alterId: 32, cipher: auto, tls: true }

-# name = socks5, server, port
-socks = socks5, server, port
+# socks5
+- { name: "socks", type: socks5, server: server, port: 443 }

-[Proxy Group]
+Proxy Group:
 # url-test select which proxy will be used by benchmarking speed to a URL.
-# name = url-test, [proxies], url, interval(second)
-auto = url-test, ss1, ss2, http://www.google.com/generate_204, 300
+- { name: "auto", type: url-test, proxies: ["ss1", "ss2", "vmess1"], url: http://www.gstatic.com/generate_204, interval: 300 }
+
+# fallback select an available policy by priority. The availability is tested by accessing an URL, just like an auto url-test group.
+- { name: "fallback-auto", type: fallback, proxies: ["ss1", "ss2", "vmess1"], url: http://www.gstatic.com/generate_204, interval: 300 }

 # 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]
-Proxy = select, ss1, ss2, auto
+- { name: "Proxy", type: select, proxies: ["ss1", "ss2", "vmess1", "auto"] }

-[Rule]
-DOMAIN-SUFFIX,google.com,Proxy
-DOMAIN-KEYWORD,google,Proxy
-DOMAIN-SUFFIX,ad.com,REJECT
-GEOIP,CN,DIRECT
-FINAL,,Proxy # note: there is two ","
+Rule:
+- DOMAIN-SUFFIX,google.com,Proxy
+- DOMAIN-KEYWORD,google,Proxy
+- DOMAIN-SUFFIX,ad.com,REJECT
+- GEOIP,CN,DIRECT
+# note: there is two ","
+- FINAL,,Proxy
 ```

 ## Thanks
--- a/adapters/inbound/http.go
+++ b/adapters/inbound/http.go
@ -10,9 +10,9 @@ import (

 // HTTPAdapter is a adapter for HTTP connection
 type HTTPAdapter struct {
-	addr *C.Addr
-	conn net.Conn
-	R    *http.Request
+	metadata *C.Metadata
+	conn     net.Conn
+	R        *http.Request
 }

 // Close HTTP connection
@ -20,9 +20,9 @@ func (h *HTTPAdapter) Close() {
 	h.conn.Close()
 }

-// Addr return destination address
-func (h *HTTPAdapter) Addr() *C.Addr {
-	return h.addr
+// Metadata return destination metadata
+func (h *HTTPAdapter) Metadata() *C.Metadata {
+	return h.metadata
 }

 // Conn return raw net.Conn of HTTP
@ -33,9 +33,9 @@ func (h *HTTPAdapter) Conn() net.Conn {
 // NewHTTP is HTTPAdapter generator
 func NewHTTP(request *http.Request, conn net.Conn) *HTTPAdapter {
 	return &HTTPAdapter{
-		addr: parseHTTPAddr(request),
-		R:    request,
-		conn: conn,
+		metadata: parseHTTPAddr(request),
+		R:        request,
+		conn:     conn,
 	}
 }

--- a/adapters/inbound/https.go
+++ b/adapters/inbound/https.go
@ -8,7 +8,7 @@ import (
 // NewHTTPS is HTTPAdapter generator
 func NewHTTPS(request *http.Request, conn net.Conn) *SocketAdapter {
 	return &SocketAdapter{
-		addr: parseHTTPAddr(request),
-		conn: conn,
+		metadata: parseHTTPAddr(request),
+		conn:     conn,
 	}
 }
--- a/adapters/inbound/socket.go
+++ b/adapters/inbound/socket.go
@ -4,13 +4,13 @@ import (
 	"net"

 	C "github.com/Dreamacro/clash/constant"
-	"github.com/riobard/go-shadowsocks2/socks"
+	"github.com/Dreamacro/go-shadowsocks2/socks"
 )

 // SocketAdapter is a adapter for socks and redir connection
 type SocketAdapter struct {
-	conn net.Conn
-	addr *C.Addr
+	conn     net.Conn
+	metadata *C.Metadata
 }

 // Close socks and redir connection
@ -18,9 +18,9 @@ func (s *SocketAdapter) Close() {
 	s.conn.Close()
 }

-// Addr return destination address
-func (s *SocketAdapter) Addr() *C.Addr {
-	return s.addr
+// Metadata return destination metadata
+func (s *SocketAdapter) Metadata() *C.Metadata {
+	return s.metadata
 }

 // Conn return raw net.Conn
@ -31,7 +31,7 @@ func (s *SocketAdapter) Conn() net.Conn {
 // NewSocket is SocketAdapter generator
 func NewSocket(target socks.Addr, conn net.Conn) *SocketAdapter {
 	return &SocketAdapter{
-		conn: conn,
-		addr: parseSocksAddr(target),
+		conn:     conn,
+		metadata: parseSocksAddr(target),
 	}
 }
--- a/adapters/inbound/util.go
+++ b/adapters/inbound/util.go
@ -6,10 +6,10 @@ import (
 	"strconv"

 	C "github.com/Dreamacro/clash/constant"
-	"github.com/riobard/go-shadowsocks2/socks"
+	"github.com/Dreamacro/go-shadowsocks2/socks"
 )

-func parseSocksAddr(target socks.Addr) *C.Addr {
+func parseSocksAddr(target socks.Addr) *C.Metadata {
 	var host, port string
 	var ip net.IP

@ -29,7 +29,7 @@ func parseSocksAddr(target socks.Addr) *C.Addr {
 		port = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1]))
 	}

-	return &C.Addr{
+	return &C.Metadata{
 		NetWork:  C.TCP,
 		AddrType: int(target[0]),
 		Host:     host,
@ -38,7 +38,7 @@ func parseSocksAddr(target socks.Addr) *C.Addr {
 	}
 }

-func parseHTTPAddr(request *http.Request) *C.Addr {
+func parseHTTPAddr(request *http.Request) *C.Metadata {
 	host := request.URL.Hostname()
 	port := request.URL.Port()
 	if port == "" {
@ -61,7 +61,7 @@ func parseHTTPAddr(request *http.Request) *C.Addr {
 		addType = socks.AtypIPv4
 	}

-	return &C.Addr{
+	return &C.Metadata{
 		NetWork:  C.TCP,
 		AddrType: addType,
 		Host:     host,
--- a/adapters/outbound/direct.go
+++ b/adapters/outbound/direct.go
@ -31,8 +31,8 @@ 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))
+func (d *Direct) Generator(metadata *C.Metadata) (adapter C.ProxyAdapter, err error) {
+	c, err := net.Dial("tcp", net.JoinHostPort(metadata.String(), metadata.Port))
 	if err != nil {
 		return
 	}
--- a/adapters/outbound/fallback.go
+++ b/adapters/outbound/fallback.go
@ -0,0 +1,136 @@
+package adapters
+
+import (
+	"errors"
+	"sync"
+	"time"
+
+	C "github.com/Dreamacro/clash/constant"
+)
+
+type proxy struct {
+	RawProxy C.Proxy
+	Valid    bool
+}
+
+type Fallback struct {
+	name     string
+	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) Name() string {
+	return f.name
+}
+
+func (f *Fallback) Type() C.AdapterType {
+	return C.Fallback
+}
+
+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) (adapter C.ProxyAdapter, err 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
+	}
+	return f.proxies[0].RawProxy.Generator(metadata)
+}
+
+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{
+		name:     option.Name,
+		proxies:  warpperProxies,
+		rawURL:   option.URL,
+		interval: interval,
+		done:     make(chan struct{}),
+	}
+	go Fallback.loop()
+	return Fallback, nil
+}
--- a/adapters/outbound/reject.go
+++ b/adapters/outbound/reject.go
@ -32,7 +32,7 @@ func (r *Reject) Type() C.AdapterType {
 	return C.Reject
 }

-func (r *Reject) Generator(addr *C.Addr) (adapter C.ProxyAdapter, err error) {
+func (r *Reject) Generator(metadata *C.Metadata) (adapter C.ProxyAdapter, err error) {
 	return &RejectAdapter{conn: &NopConn{}}, nil
 }

--- a/adapters/outbound/selector.go
+++ b/adapters/outbound/selector.go
@ -13,6 +13,11 @@ type Selector struct {
 	proxies  map[string]C.Proxy
 }

+type SelectorOption struct {
+	Name    string   `proxy:"name"`
+	Proxies []string `proxy:"proxies"`
+}
+
 func (s *Selector) Name() string {
 	return s.name
 }
@ -21,8 +26,8 @@ func (s *Selector) Type() C.AdapterType {
 	return C.Selector
 }

-func (s *Selector) Generator(addr *C.Addr) (adapter C.ProxyAdapter, err error) {
-	return s.selected.Generator(addr)
+func (s *Selector) Generator(metadata *C.Metadata) (adapter C.ProxyAdapter, err error) {
+	return s.selected.Generator(metadata)
 }

 func (s *Selector) Now() string {
--- a/adapters/outbound/shadowsocks.go
+++ b/adapters/outbound/shadowsocks.go
@ -4,14 +4,13 @@ import (
 	"bytes"
 	"fmt"
 	"net"
-	"net/url"
 	"strconv"

+	"github.com/Dreamacro/clash/component/simple-obfs"
 	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"
+	"github.com/Dreamacro/go-shadowsocks2/core"
+	"github.com/Dreamacro/go-shadowsocks2/socks"
 )

 // ShadowsocksAdapter is a shadowsocks adapter
@ -36,6 +35,16 @@ type ShadowSocks struct {
 	cipher   core.Cipher
 }

+type ShadowSocksOption struct {
+	Name     string `proxy:"name"`
+	Server   string `proxy:"server"`
+	Port     int    `proxy:"port"`
+	Password string `proxy:"password"`
+	Cipher   string `proxy:"cipher"`
+	Obfs     string `proxy:"obfs,omitempty"`
+	ObfsHost string `proxy:"obfs-host,omitempty"`
+}
+
 func (ss *ShadowSocks) Name() string {
 	return ss.name
 }
@ -44,7 +53,7 @@ func (ss *ShadowSocks) Type() C.AdapterType {
 	return C.Shadowsocks
 }

-func (ss *ShadowSocks) Generator(addr *C.Addr) (adapter C.ProxyAdapter, err error) {
+func (ss *ShadowSocks) Generator(metadata *C.Metadata) (adapter C.ProxyAdapter, err error) {
 	c, err := net.Dial("tcp", ss.server)
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error", ss.server)
@ -58,67 +67,50 @@ func (ss *ShadowSocks) Generator(addr *C.Addr) (adapter C.ProxyAdapter, err erro
 		c = obfs.NewHTTPObfs(c, ss.obfsHost, port)
 	}
 	c = ss.cipher.StreamConn(c)
-	_, err = c.Write(serializesSocksAddr(addr))
+	_, err = c.Write(serializesSocksAddr(metadata))
 	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)
+func NewShadowSocks(option ShadowSocksOption) (*ShadowSocks, error) {
+	server := fmt.Sprintf("%s:%d", option.Server, 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())
 	}

-	obfs := ""
+	obfs := option.Obfs
 	obfsHost := "bing.com"
-	if value, ok := option["obfs"]; ok {
-		obfs = value
-	}
-
-	if value, ok := option["obfs-host"]; ok {
-		obfsHost = value
+	if option.ObfsHost != "" {
+		obfsHost = option.ObfsHost
 	}

 	return &ShadowSocks{
 		server:   server,
-		name:     name,
+		name:     option.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 {
+func serializesSocksAddr(metadata *C.Metadata) []byte {
 	var buf [][]byte
-	aType := uint8(addr.AddrType)
-	p, _ := strconv.Atoi(addr.Port)
+	aType := uint8(metadata.AddrType)
+	p, _ := strconv.Atoi(metadata.Port)
 	port := []byte{uint8(p >> 8), uint8(p & 0xff)}
-	switch addr.AddrType {
+	switch metadata.AddrType {
 	case socks.AtypDomainName:
-		len := uint8(len(addr.Host))
-		host := []byte(addr.Host)
+		len := uint8(len(metadata.Host))
+		host := []byte(metadata.Host)
 		buf = [][]byte{{aType, len}, host, port}
 	case socks.AtypIPv4:
-		host := addr.IP.To4()
+		host := metadata.IP.To4()
 		buf = [][]byte{{aType}, host, port}
 	case socks.AtypIPv6:
-		host := addr.IP.To16()
+		host := metadata.IP.To16()
 		buf = [][]byte{{aType}, host, port}
 	}
-	return bytes.Join(buf, []byte(""))
+	return bytes.Join(buf, nil)
 }
--- a/adapters/outbound/socks5.go
+++ b/adapters/outbound/socks5.go
@ -9,7 +9,7 @@ import (

 	C "github.com/Dreamacro/clash/constant"

-	"github.com/riobard/go-shadowsocks2/socks"
+	"github.com/Dreamacro/go-shadowsocks2/socks"
 )

 // Socks5Adapter is a shadowsocks adapter
@ -31,6 +31,12 @@ type Socks5 struct {
 	name string
 }

+type Socks5Option struct {
+	Name   string `proxy:"name"`
+	Server string `proxy:"server"`
+	Port   int    `proxy:"port"`
+}
+
 func (ss *Socks5) Name() string {
 	return ss.name
 }
@ -39,19 +45,19 @@ func (ss *Socks5) Type() C.AdapterType {
 	return C.Socks5
 }

-func (ss *Socks5) Generator(addr *C.Addr) (adapter C.ProxyAdapter, err error) {
+func (ss *Socks5) Generator(metadata *C.Metadata) (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 {
+	if err := ss.shakeHand(metadata, c); err != nil {
 		return nil, err
 	}
 	return &Socks5Adapter{conn: c}, nil
 }

-func (ss *Socks5) sharkHand(addr *C.Addr, rw io.ReadWriter) error {
+func (ss *Socks5) shakeHand(metadata *C.Metadata, rw io.ReadWriter) error {
 	buf := make([]byte, socks.MaxAddrLen)

 	// VER, CMD, RSV
@ -71,7 +77,7 @@ func (ss *Socks5) sharkHand(addr *C.Addr, rw io.ReadWriter) error {
 	}

 	// VER, CMD, RSV, ADDR
-	if _, err := rw.Write(bytes.Join([][]byte{[]byte{5, 1, 0}, serializesSocksAddr(addr)}, []byte(""))); err != nil {
+	if _, err := rw.Write(bytes.Join([][]byte{{5, 1, 0}, serializesSocksAddr(metadata)}, []byte(""))); err != nil {
 		return err
 	}

@ -82,9 +88,9 @@ func (ss *Socks5) sharkHand(addr *C.Addr, rw io.ReadWriter) error {
 	return nil
 }

-func NewSocks5(name, addr string) *Socks5 {
+func NewSocks5(option Socks5Option) *Socks5 {
 	return &Socks5{
-		addr: addr,
-		name: name,
+		addr: fmt.Sprintf("%s:%d", option.Server, option.Port),
+		name: option.Name,
 	}
 }
--- a/adapters/outbound/urltest.go
+++ b/adapters/outbound/urltest.go
@ -1,6 +1,7 @@
 package adapters

 import (
+	"errors"
 	"sync"
 	"time"

@ -8,12 +9,19 @@ import (
 )

 type URLTest struct {
-	name    string
-	proxies []C.Proxy
-	rawURL  string
-	fast    C.Proxy
-	delay   time.Duration
-	done    chan struct{}
+	name     string
+	proxies  []C.Proxy
+	rawURL   string
+	fast     C.Proxy
+	interval time.Duration
+	done     chan struct{}
+}
+
+type URLTestOption struct {
+	Name     string   `proxy:"name"`
+	Proxies  []string `proxy:"proxies"`
+	URL      string   `proxy:"url"`
+	Interval int      `proxy:"interval"`
 }

 func (u *URLTest) Name() string {
@ -28,8 +36,8 @@ 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) Generator(metadata *C.Metadata) (adapter C.ProxyAdapter, err error) {
+	return u.fast.Generator(metadata)
 }

 func (u *URLTest) Close() {
@ -37,7 +45,7 @@ func (u *URLTest) Close() {
 }

 func (u *URLTest) loop() {
-	tick := time.NewTicker(u.delay)
+	tick := time.NewTicker(u.interval)
 	go u.speedTest()
 Loop:
 	for {
@ -55,7 +63,7 @@ func (u *URLTest) speedTest() {
 	wg.Add(len(u.proxies))
 	c := make(chan interface{})
 	fast := selectFast(c)
-	timer := time.NewTimer(u.delay)
+	timer := time.NewTimer(u.interval)

 	for _, p := range u.proxies {
 		go func(p C.Proxy) {
@ -83,19 +91,23 @@ func (u *URLTest) speedTest() {
 	}
 }

-func NewURLTest(name string, proxies []C.Proxy, rawURL string, delay time.Duration) (*URLTest, error) {
-	_, err := urlToAddr(rawURL)
+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{
-		name:    name,
-		proxies: proxies[:],
-		rawURL:  rawURL,
-		fast:    proxies[0],
-		delay:   delay,
-		done:    make(chan struct{}),
+		name:     option.Name,
+		proxies:  proxies[:],
+		rawURL:   option.URL,
+		fast:     proxies[0],
+		interval: interval,
+		done:     make(chan struct{}),
 	}
 	go urlTest.loop()
 	return urlTest, nil
--- a/adapters/outbound/util.go
+++ b/adapters/outbound/util.go
@ -12,7 +12,7 @@ import (

 // 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
 	}
@ -34,16 +34,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 +61,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 +88,6 @@ 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)
 	}
 }
--- a/adapters/outbound/vmess.go
+++ b/adapters/outbound/vmess.go
@ -6,7 +6,7 @@ import (
 	"strconv"
 	"strings"

-	"github.com/Dreamacro/clash/common/vmess"
+	"github.com/Dreamacro/clash/component/vmess"
 	C "github.com/Dreamacro/clash/constant"
 )

@ -30,6 +30,16 @@ type Vmess struct {
 	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"`
+}
+
 func (ss *Vmess) Name() string {
 	return ss.name
 }
@ -38,55 +48,55 @@ func (ss *Vmess) Type() C.AdapterType {
 	return C.Vmess
 }

-func (ss *Vmess) Generator(addr *C.Addr) (adapter C.ProxyAdapter, err error) {
+func (ss *Vmess) Generator(metadata *C.Metadata) (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))
+	c = ss.client.New(c, parseVmessAddr(metadata))
 	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)
+func NewVmess(option VmessOption) (*Vmess, error) {
+	security := strings.ToLower(option.Cipher)
 	client, err := vmess.NewClient(vmess.Config{
-		UUID:     uuid,
-		AlterID:  alterID,
+		UUID:     option.UUID,
+		AlterID:  uint16(option.AlterID),
 		Security: security,
-		TLS:      option["tls"] == "true",
+		TLS:      option.TLS,
 	})
 	if err != nil {
 		return nil, err
 	}

 	return &Vmess{
-		name:   name,
-		server: server,
+		name:   option.Name,
+		server: fmt.Sprintf("%s:%d", option.Server, option.Port),
 		client: client,
 	}, nil
 }

-func parseVmessAddr(info *C.Addr) *vmess.DstAddr {
+func parseVmessAddr(metadata *C.Metadata) *vmess.DstAddr {
 	var addrType byte
 	var addr []byte
-	switch info.AddrType {
+	switch metadata.AddrType {
 	case C.AtypIPv4:
 		addrType = byte(vmess.AtypIPv4)
 		addr = make([]byte, net.IPv4len)
-		copy(addr[:], info.IP.To4())
+		copy(addr[:], metadata.IP.To4())
 	case C.AtypIPv6:
 		addrType = byte(vmess.AtypIPv6)
 		addr = make([]byte, net.IPv6len)
-		copy(addr[:], info.IP.To16())
+		copy(addr[:], metadata.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))
+		addr = make([]byte, len(metadata.Host)+1)
+		addr[0] = byte(len(metadata.Host))
+		copy(addr[1:], []byte(metadata.Host))
 	}

-	port, _ := strconv.Atoi(info.Port)
+	port, _ := strconv.Atoi(metadata.Port)
 	return &vmess.DstAddr{
 		AddrType: addrType,
 		Addr:     addr,
--- a/common/observable/iterable.go
+++ b/common/observable/iterable.go
--- a/common/observable/observable.go
+++ b/common/observable/observable.go
--- a/common/observable/observable_test.go
+++ b/common/observable/observable_test.go
--- a/common/observable/subscriber.go
+++ b/common/observable/subscriber.go
--- a/common/structure/structure.go
+++ b/common/structure/structure.go
@ -0,0 +1,160 @@
+package structure
+
+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)
+	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
+}
--- a/common/structure/structure_test.go
+++ b/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)
+	}
+}
--- a/component/simple-obfs/http.go
+++ b/component/simple-obfs/http.go
--- a/component/simple-obfs/tls.go
+++ b/component/simple-obfs/tls.go
--- a/component/vmess/aead.go
+++ b/component/vmess/aead.go
--- a/component/vmess/chunk.go
+++ b/component/vmess/chunk.go
--- a/component/vmess/conn.go
+++ b/component/vmess/conn.go
--- a/component/vmess/user.go
+++ b/component/vmess/user.go
--- a/component/vmess/vmess.go
+++ b/component/vmess/vmess.go
--- a/config/config.go
+++ b/config/config.go
@ -1,21 +1,21 @@
 package config

 import (
-	"bufio"
 	"fmt"
+	"io/ioutil"
 	"os"
-	"strconv"
 	"strings"
 	"sync"
 	"time"

-	"github.com/Dreamacro/clash/adapters/remote"
+	adapters "github.com/Dreamacro/clash/adapters/outbound"
+	"github.com/Dreamacro/clash/common/observable"
+	"github.com/Dreamacro/clash/common/structure"
 	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/observable"
 	R "github.com/Dreamacro/clash/rules"

 	log "github.com/sirupsen/logrus"
-	"gopkg.in/ini.v1"
+	yaml "gopkg.in/yaml.v2"
 )

 var (
@ -41,6 +41,22 @@ type ProxyConfig struct {
 	AllowLan  *bool
 }

+// RawConfig is raw config struct
+type RawConfig struct {
+	Port               int    `yaml:"port"`
+	SocksPort          int    `yaml:"socks-port"`
+	RedirPort          int    `yaml:"redir-port"`
+	AllowLan           bool   `yaml:"allow-lan"`
+	Mode               string `yaml:"mode"`
+	LogLevel           string `yaml:"log-level"`
+	ExternalController string `yaml:"external-controller"`
+	Secret             string `yaml:"secret"`
+
+	Proxy      []map[string]interface{} `yaml:"Proxy"`
+	ProxyGroup []map[string]interface{} `yaml:"Proxy Group"`
+	Rule       []string                 `yaml:"Rule"`
+}
+
 // Config is clash config manager
 type Config struct {
 	general    *General
@ -70,17 +86,30 @@ func (c *Config) Report() chan<- interface{} {
 	return c.reportCh
 }

-func (c *Config) readConfig() (*ini.File, error) {
-	if _, err := os.Stat(C.ConfigPath); os.IsNotExist(err) {
+func (c *Config) readConfig() (*RawConfig, error) {
+	if _, err := os.Stat(C.Path.Config()); os.IsNotExist(err) {
 		return nil, err
 	}
-	return ini.LoadSources(
-		ini.LoadOptions{
-			AllowBooleanKeys:    true,
-			UnparseableSections: []string{"Rule"},
-		},
-		C.ConfigPath,
-	)
+	data, err := ioutil.ReadFile(C.Path.Config())
+	if err != nil {
+		return nil, err
+	}
+
+	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:       Rule.String(),
+		LogLevel:   C.INFO.String(),
+		Rule:       []string{},
+		Proxy:      []map[string]interface{}{},
+		ProxyGroup: []map[string]interface{}{},
+	}
+	err = yaml.Unmarshal([]byte(data), &rawConfig)
+	return rawConfig, err
 }

 // Parse config
@ -138,15 +167,13 @@ func (c *Config) UpdateRules() error {
 	return c.parseRules(cfg)
 }

-func (c *Config) parseGeneral(cfg *ini.File) error {
-	general := cfg.Section("General")
-
-	port := general.Key("port").RangeInt(0, 1, 65535)
-	socksPort := general.Key("socks-port").RangeInt(0, 1, 65535)
-	redirPort := general.Key("redir-port").RangeInt(0, 1, 65535)
-	allowLan := general.Key("allow-lan").MustBool()
-	logLevelString := general.Key("log-level").MustString(C.INFO.String())
-	modeString := general.Key("mode").MustString(Rule.String())
+func (c *Config) parseGeneral(cfg *RawConfig) error {
+	port := cfg.Port
+	socksPort := cfg.SocksPort
+	redirPort := cfg.RedirPort
+	allowLan := cfg.AllowLan
+	logLevelString := cfg.LogLevel
+	modeString := cfg.Mode

 	mode, exist := ModeMapping[modeString]
 	if !exist {
@ -167,8 +194,9 @@ func (c *Config) parseGeneral(cfg *ini.File) error {
 		LogLevel:  logLevel,
 	}

-	if restAddr := general.Key("external-controller").String(); restAddr != "" {
+	if restAddr := cfg.ExternalController; restAddr != "" {
 		c.event <- &Event{Type: "external-controller", Payload: restAddr}
+		c.event <- &Event{Type: "secret", Payload: cfg.Secret}
 	}

 	c.UpdateGeneral(*c.general)
@ -209,125 +237,150 @@ func (c *Config) UpdateProxy(pc ProxyConfig) {
 	}
 }

-func (c *Config) parseProxies(cfg *ini.File) error {
+func (c *Config) parseProxies(cfg *RawConfig) error {
 	proxies := make(map[string]C.Proxy)
-	proxiesConfig := cfg.Section("Proxy")
-	groupsConfig := cfg.Section("Proxy Group")
+	proxiesConfig := cfg.Proxy
+	groupsConfig := cfg.ProxyGroup

-	// parse proxy
-	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
-		}
-	}
+	decoder := structure.NewDecoder(structure.Option{TagName: "proxy", WeaklyTypedInput: true})

-	// 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()

+	// parse proxy
+	for idx, mapping := range proxiesConfig {
+		proxyType, existType := mapping["type"].(string)
+		proxyName, existName := mapping["name"].(string)
+		if !existType && existName {
+			return fmt.Errorf("Proxy %d missing type or name", idx)
+		}
+
+		if _, exist := proxies[proxyName]; exist {
+			return fmt.Errorf("Proxy %s is the duplicate name", proxyName)
+		}
+		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 "vmess":
+			vmessOption := &adapters.VmessOption{}
+			err = decoder.Decode(mapping, vmessOption)
+			if err != nil {
+				break
+			}
+			proxy, err = adapters.NewVmess(*vmessOption)
+		default:
+			return fmt.Errorf("Unsupport proxy type: %s", proxyType)
+		}
+		if err != nil {
+			return fmt.Errorf("Proxy %s: %s", proxyName, err.Error())
+		}
+		proxies[proxyName] = proxy
+	}
+
+	// parse proxy group
+	for idx, mapping := range groupsConfig {
+		groupType, existType := mapping["type"].(string)
+		groupName, existName := mapping["name"].(string)
+		if !existType && existName {
+			return fmt.Errorf("ProxyGroup %d: missing type or name", idx)
+		}
+
+		if _, exist := proxies[groupName]; exist {
+			return fmt.Errorf("ProxyGroup %s: the duplicate name", groupName)
+		}
+		var group C.Proxy
+		var err error
+		switch groupType {
+		case "url-test":
+			urlTestOption := &adapters.URLTestOption{}
+			err = decoder.Decode(mapping, urlTestOption)
+			if err != nil {
+				break
+			}
+
+			var ps []C.Proxy
+			for _, name := range urlTestOption.Proxies {
+				p, ok := proxies[name]
+				if !ok {
+					return fmt.Errorf("ProxyGroup %s: proxy or proxy group '%s' not found", groupName, name)
+				}
+				ps = append(ps, p)
+			}
+			group, err = adapters.NewURLTest(*urlTestOption, ps)
+		case "select":
+			selectorOption := &adapters.SelectorOption{}
+			err = decoder.Decode(mapping, selectorOption)
+			if err != nil {
+				break
+			}
+			selectProxy := make(map[string]C.Proxy)
+			for _, name := range selectorOption.Proxies {
+				proxy, exist := proxies[name]
+				if !exist {
+					return fmt.Errorf("ProxyGroup %s: proxy or proxy group '%s' not found", groupName, name)
+				}
+				selectProxy[name] = proxy
+			}
+			group, err = adapters.NewSelector(selectorOption.Name, selectProxy)
+		case "fallback":
+			fallbackOption := &adapters.FallbackOption{}
+			err = decoder.Decode(mapping, fallbackOption)
+			if err != nil {
+				break
+			}
+			var ps []C.Proxy
+			for _, name := range fallbackOption.Proxies {
+				p, ok := proxies[name]
+				if !ok {
+					return fmt.Errorf("ProxyGroup %s: proxy or proxy group '%s' not found", groupName, name)
+				}
+				ps = append(ps, p)
+			}
+			group, err = adapters.NewFallback(*fallbackOption, ps)
+		}
+		if err != nil {
+			return fmt.Errorf("Proxy %s: %s", groupName, err.Error())
+		}
+		proxies[groupName] = group
+	}
+
+	proxies["GLOBAL"], _ = adapters.NewSelector("GLOBAL", proxies)
+
+	// close old goroutine
+	for _, proxy := range c.proxies {
+		switch raw := proxy.(type) {
+		case *adapters.URLTest:
+			raw.Close()
+		case *adapters.Fallback:
+			raw.Close()
+		}
+	}
 	c.proxies = proxies
 	c.event <- &Event{Type: "proxies", Payload: proxies}
 	return nil
 }

-func (c *Config) parseRules(cfg *ini.File) error {
+func (c *Config) parseRules(cfg *RawConfig) error {
 	rules := []C.Rule{}

-	rulesConfig := cfg.Section("Rule")
+	rulesConfig := cfg.Rule
 	// parse rules
-	reader := bufio.NewReader(strings.NewReader(rulesConfig.Body()))
-	for {
-		line, _, err := reader.ReadLine()
-		if err != nil {
-			break
-		}
-
-		rule := strings.Split(string(line), ",")
+	for _, line := range rulesConfig {
+		rule := strings.Split(line, ",")
 		if len(rule) < 3 {
 			continue
 		}
--- a/config/initial.go
+++ b/config/initial.go
@ -55,16 +55,23 @@ func downloadMMDB(path string) (err error) {

 // Init prepare necessary files
 func Init() {
+	// initial homedir
+	if _, err := os.Stat(C.Path.HomeDir()); os.IsNotExist(err) {
+		if err := os.MkdirAll(C.Path.HomeDir(), 0777); err != nil {
+			log.Fatalf("Can't create config directory %s: %s", C.Path.HomeDir(), err.Error())
+		}
+	}
+
 	// initial config.ini
-	if _, err := os.Stat(C.ConfigPath); os.IsNotExist(err) {
+	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())
 		}
--- a/config/utils.go
+++ b/config/utils.go
@ -27,20 +27,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
-}
--- a/constant/adapters.go
+++ b/constant/adapters.go
@ -7,6 +7,7 @@ import (
 // Adapter Type
 const (
 	Direct AdapterType = iota
+	Fallback
 	Reject
 	Selector
 	Shadowsocks
@ -21,14 +22,14 @@ type ProxyAdapter interface {
 }

 type ServerAdapter interface {
-	Addr() *Addr
+	Metadata() *Metadata
 	Close()
 }

 type Proxy interface {
 	Name() string
 	Type() AdapterType
-	Generator(addr *Addr) (ProxyAdapter, error)
+	Generator(metadata *Metadata) (ProxyAdapter, error)
 }

 // AdapterType is enum of adapter type
@ -38,6 +39,8 @@ func (at AdapterType) String() string {
 	switch at {
 	case Direct:
 		return "Direct"
+	case Fallback:
+		return "Fallback"
 	case Reject:
 		return "Reject"
 	case Selector:
--- a/constant/config.go
+++ b/constant/config.go
@ -1,23 +1,5 @@
 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"`
@ -26,26 +8,3 @@ type General struct {
 	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")
-}
--- a/constant/metadata.go
+++ b/constant/metadata.go
@ -28,8 +28,8 @@ func (n *NetWork) String() string {

 type SourceType int

-// Addr is used to store connection address
-type Addr struct {
+// Metadata is used to store connection address
+type Metadata struct {
 	NetWork  NetWork
 	Source   SourceType
 	AddrType int
@ -38,7 +38,7 @@ type Addr struct {
 	Port     string
 }

-func (addr *Addr) String() string {
+func (addr *Metadata) String() string {
 	if addr.Host == "" {
 		return addr.IP.String()
 	}
--- a/constant/path.go
+++ b/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")
+}
--- a/constant/rule.go
+++ b/constant/rule.go
@ -33,7 +33,7 @@ func (rt RuleType) String() string {

 type Rule interface {
 	RuleType() RuleType
-	IsMatch(addr *Addr) bool
+	IsMatch(metadata *Metadata) bool
 	Adapter() string
 	Payload() string
 }
--- a/go.mod
+++ b/go.mod
@ -0,0 +1,16 @@
+module github.com/Dreamacro/clash
+
+require (
+	github.com/Dreamacro/go-shadowsocks2 v0.1.2-0.20181016063207-89bf7cffdaf4
+	github.com/eapache/queue v1.1.0 // indirect
+	github.com/go-chi/chi v3.3.3+incompatible
+	github.com/go-chi/cors v1.0.0
+	github.com/go-chi/render v1.0.1
+	github.com/gofrs/uuid v3.1.0+incompatible
+	github.com/oschwald/geoip2-golang v1.2.1
+	github.com/oschwald/maxminddb-golang v1.3.0 // indirect
+	github.com/sirupsen/logrus v1.1.0
+	golang.org/x/crypto v0.0.0-20181009213950-7c1a557ab941
+	gopkg.in/eapache/channels.v1 v1.1.0
+	gopkg.in/yaml.v2 v2.2.1
+)
--- a/go.sum
+++ b/go.sum
@ -0,0 +1,41 @@
+github.com/Dreamacro/go-shadowsocks2 v0.1.2-0.20181016063207-89bf7cffdaf4 h1:n+F4LoHdFCwsGohVN+4dwfmmx0h2uvdPEeiwdhFeH8g=
+github.com/Dreamacro/go-shadowsocks2 v0.1.2-0.20181016063207-89bf7cffdaf4/go.mod h1:DlkXRxmh5K+99aTPQaVjsZ1fAZNFw42vXGcOjR3Otps=
+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 v3.3.3+incompatible h1:KHkmBEMNkwKuK4FdQL7N2wOeB9jnIx7jR5wsuSBEFI8=
+github.com/go-chi/chi v3.3.3+incompatible/go.mod h1:eB3wogJHnLi3x/kFX2A+IbTBlXxmMeXJVKy9tTv1XzQ=
+github.com/go-chi/cors v1.0.0 h1:e6x8k7uWbUwYs+aXDoiUzeQFT6l0cygBYyNhD7/1Tg0=
+github.com/go-chi/cors v1.0.0/go.mod h1:K2Yje0VW/SJzxiyMYu6iPQYa7hMjQX2i/F491VChg1I=
+github.com/go-chi/render v1.0.1 h1:4/5tis2cKaNdnv9zFLfXzcquC9HbeZgCnxGnKrltBS8=
+github.com/go-chi/render v1.0.1/go.mod h1:pq4Rr7HbnsdaeHagklXub+p6Wd16Af5l9koip1OvJns=
+github.com/gofrs/uuid v3.1.0+incompatible h1:q2rtkjaKT4YEr6E1kamy0Ha4RtepWlQBedyHx0uzKwA=
+github.com/gofrs/uuid v3.1.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
+github.com/konsorten/go-windows-terminal-sequences v0.0.0-20180402223658-b729f2633dfe h1:CHRGQ8V7OlCYtwaKPJi3iA7J+YdNKdo8j7nG5IgDhjs=
+github.com/konsorten/go-windows-terminal-sequences v0.0.0-20180402223658-b729f2633dfe/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+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.1.0 h1:65VZabgUiV9ktjGM5nTq0+YurgTyX+YI2lSSfDjI+qU=
+github.com/sirupsen/logrus v1.1.0/go.mod h1:zrgwTnHtNr00buQ1vSptGe8m1f/BbgsPukg8qsT7A+A=
+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-20181009213950-7c1a557ab941 h1:qBTHLajHecfu+xzRI9PqVDcqx7SdHj9d4B+EzSn3tAc=
+golang.org/x/crypto v0.0.0-20181009213950-7c1a557ab941/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33 h1:I6FyU15t786LL7oL/hn43zqTuEGr4PN7F4XJ1p4E3Y8=
+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.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
--- a/hub/proxies.go
+++ b/hub/proxies.go
@ -6,7 +6,7 @@ import (
 	"strconv"
 	"time"

-	A "github.com/Dreamacro/clash/adapters/remote"
+	A "github.com/Dreamacro/clash/adapters/outbound"
 	C "github.com/Dreamacro/clash/constant"

 	"github.com/go-chi/chi"
@ -37,6 +37,11 @@ type URLTest struct {
 	Now  string `json:"now"`
 }

+type Fallback struct {
+	Type string `json:"type"`
+	Now  string `json:"now"`
+}
+
 func transformProxy(proxy C.Proxy) interface{} {
 	t := proxy.Type()
 	switch t {
@ -52,6 +57,11 @@ func transformProxy(proxy C.Proxy) interface{} {
 			Type: t.String(),
 			Now:  proxy.(*A.URLTest).Now(),
 		}
+	case C.Fallback:
+		return Fallback{
+			Type: t.String(),
+			Now:  proxy.(*A.Fallback).Now(),
+		}
 	default:
 		return SampleProxy{
 			Type: proxy.Type().String(),
--- a/hub/rules.go
+++ b/hub/rules.go
@ -17,6 +17,7 @@ func ruleRouter() http.Handler {
 type Rule struct {
 	Name    string `json:"name"`
 	Payload string `json:"type"`
+	Proxy   string `json:"proxy"`
 }

 type GetRulesResponse struct {
@ -31,6 +32,7 @@ func getRules(w http.ResponseWriter, r *http.Request) {
 		rules = append(rules, Rule{
 			Name:    rule.RuleType().String(),
 			Payload: rule.Payload(),
+			Proxy:   rule.Adapter(),
 		})
 	}

--- a/hub/server.go
+++ b/hub/server.go
@ -3,6 +3,7 @@ package hub
 import (
 	"encoding/json"
 	"net/http"
+	"strings"
 	"time"

 	"github.com/Dreamacro/clash/config"
@ -15,6 +16,8 @@ import (
 	log "github.com/sirupsen/logrus"
 )

+var secret = ""
+
 type Traffic struct {
 	Up   int64 `json:"up"`
 	Down int64 `json:"down"`
@ -24,11 +27,19 @@ func newHub(signal chan struct{}) {
 	var addr string
 	ch := config.Instance().Subscribe()
 	signal <- struct{}{}
+	count := 0
 	for {
 		elm := <-ch
 		event := elm.(*config.Event)
-		if event.Type == "external-controller" {
+		switch event.Type {
+		case "external-controller":
 			addr = event.Payload.(string)
+			count++
+		case "secret":
+			secret = event.Payload.(string)
+			count++
+		}
+		if count == 2 {
 			break
 		}
 	}
@ -38,11 +49,11 @@ func newHub(signal chan struct{}) {
 	cors := cors.New(cors.Options{
 		AllowedOrigins: []string{"*"},
 		AllowedMethods: []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
-		AllowedHeaders: []string{"Content-Type"},
+		AllowedHeaders: []string{"Content-Type", "Authorization"},
 		MaxAge:         300,
 	})

-	r.Use(cors.Handler)
+	r.Use(cors.Handler, authentication)

 	r.With(jsonContentType).Get("/traffic", traffic)
 	r.With(jsonContentType).Get("/logs", getLogs)
@ -65,6 +76,30 @@ func jsonContentType(next http.Handler) http.Handler {
 	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 secret == "" {
+			next.ServeHTTP(w, r)
+			return
+		}
+
+		hasUnvalidHeader := text[0] != "Bearer"
+		hasUnvalidSecret := len(text) == 2 && text[1] != secret
+		if hasUnvalidHeader || hasUnvalidSecret {
+			w.WriteHeader(http.StatusUnauthorized)
+			render.JSON(w, r, Error{
+				Error: "Authentication failed",
+			})
+			return
+		}
+		next.ServeHTTP(w, r)
+	}
+	return http.HandlerFunc(fn)
+}
+
 func traffic(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(http.StatusOK)

--- a/main.go
+++ b/main.go
@ -4,20 +4,40 @@ import (
 	"os"
 	"os/signal"
 	"syscall"
+	"flag"
+	"path"

 	"github.com/Dreamacro/clash/config"
 	"github.com/Dreamacro/clash/hub"
 	"github.com/Dreamacro/clash/proxy"
 	"github.com/Dreamacro/clash/tunnel"
+	C "github.com/Dreamacro/clash/constant"

 	log "github.com/sirupsen/logrus"
 )

+var (
+	homedir string
+)
+
+func init() {
+	flag.StringVar(&homedir, "d", "", "set configuration directory")
+	flag.Parse()
+}
+
 func main() {
 	tunnel.Instance().Run()
 	proxy.Instance().Run()
 	hub.Run()

+	if (homedir != "") {
+		if !path.IsAbs(homedir) {
+			currentDir, _ := os.Getwd()
+			homedir = path.Join(currentDir, homedir)
+		}
+		C.SetHomeDir(homedir)
+	}
+
 	config.Init()
 	err := config.Instance().Parse()
 	if err != nil {
--- a/proxy/http/server.go
+++ b/proxy/http/server.go
@ -5,7 +5,7 @@ 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/tunnel"

--- a/proxy/redir/tcp.go
+++ b/proxy/redir/tcp.go
@ -3,7 +3,7 @@ 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/tunnel"

--- a/proxy/redir/tcp_darwin.go
+++ b/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) {
--- a/proxy/redir/tcp_linux.go
+++ b/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 (
--- a/proxy/redir/tcp_windows.go
+++ b/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) {
--- a/proxy/socks/tcp.go
+++ b/proxy/socks/tcp.go
@ -3,11 +3,11 @@ 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/tunnel"

-	"github.com/riobard/go-shadowsocks2/socks"
+	"github.com/Dreamacro/go-shadowsocks2/socks"
 	log "github.com/sirupsen/logrus"
 )

--- a/rules/domain.go
+++ b/rules/domain.go
@ -13,11 +13,11 @@ func (d *Domain) RuleType() C.RuleType {
 	return C.Domain
 }

-func (d *Domain) IsMatch(addr *C.Addr) bool {
-	if addr.AddrType != C.AtypDomainName {
+func (d *Domain) IsMatch(metadata *C.Metadata) bool {
+	if metadata.AddrType != C.AtypDomainName {
 		return false
 	}
-	return addr.Host == d.domain
+	return metadata.Host == d.domain
 }

 func (d *Domain) Adapter() string {
--- a/rules/domain_keyword.go
+++ b/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 {
-	if addr.AddrType != C.AtypDomainName {
+func (dk *DomainKeyword) IsMatch(metadata *C.Metadata) bool {
+	if metadata.AddrType != C.AtypDomainName {
 		return false
 	}
-	domain := addr.Host
+	domain := metadata.Host
 	return strings.Contains(domain, dk.keyword)
 }

--- a/rules/domain_suffix.go
+++ b/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 {
-	if addr.AddrType != C.AtypDomainName {
+func (ds *DomainSuffix) IsMatch(metadata *C.Metadata) bool {
+	if metadata.AddrType != C.AtypDomainName {
 		return false
 	}
-	domain := addr.Host
+	domain := metadata.Host
 	return strings.HasSuffix(domain, "."+ds.suffix) || domain == ds.suffix
 }

--- a/rules/final.go
+++ b/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
 }

--- a/rules/geoip.go
+++ b/rules/geoip.go
@ -23,11 +23,11 @@ func (g *GEOIP) RuleType() C.RuleType {
 	return C.GEOIP
 }

-func (g *GEOIP) IsMatch(addr *C.Addr) bool {
-	if addr.IP == nil {
+func (g *GEOIP) IsMatch(metadata *C.Metadata) bool {
+	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())
 		}
--- a/rules/ipcidr.go
+++ b/rules/ipcidr.go
@ -15,12 +15,12 @@ func (i *IPCIDR) RuleType() C.RuleType {
 	return C.IPCIDR
 }

-func (i *IPCIDR) IsMatch(addr *C.Addr) bool {
-	if addr.IP == nil {
+func (i *IPCIDR) IsMatch(metadata *C.Metadata) bool {
+	if metadata.IP == nil {
 		return false
 	}

-	return i.ipnet.Contains(*addr.IP)
+	return i.ipnet.Contains(*metadata.IP)
 }

 func (i *IPCIDR) Adapter() string {
--- a/tunnel/connection.go
+++ b/tunnel/connection.go
@ -5,8 +5,9 @@ import (
 	"io"
 	"net"
 	"net/http"
+	"time"

-	"github.com/Dreamacro/clash/adapters/local"
+	"github.com/Dreamacro/clash/adapters/inbound"
 	C "github.com/Dreamacro/clash/constant"
 )

@ -66,9 +67,11 @@ func relay(leftConn, rightConn net.Conn) {

 	go func() {
 		_, err := io.Copy(leftConn, rightConn)
+		leftConn.SetReadDeadline(time.Now())
 		ch <- err
 	}()

 	io.Copy(rightConn, leftConn)
+	rightConn.SetReadDeadline(time.Now())
 	<-ch
 }
--- a/tunnel/tunnel.go
+++ b/tunnel/tunnel.go
@ -4,10 +4,10 @@ import (
 	"sync"
 	"time"

-	LocalAdapter "github.com/Dreamacro/clash/adapters/local"
+	InboundAdapter "github.com/Dreamacro/clash/adapters/inbound"
+	"github.com/Dreamacro/clash/common/observable"
 	cfg "github.com/Dreamacro/clash/config"
 	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/observable"

 	"gopkg.in/eapache/channels.v1"
 )
@ -84,7 +84,7 @@ func (t *Tunnel) process() {

 func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
 	defer localConn.Close()
-	addr := localConn.Addr()
+	metadata := localConn.Metadata()

 	var proxy C.Proxy
 	switch t.mode {
@ -94,9 +94,9 @@ func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
 		proxy = t.proxies["GLOBAL"]
 	// Rule
 	default:
-		proxy = t.match(addr)
+		proxy = t.match(metadata)
 	}
-	remoConn, err := proxy.Generator(addr)
+	remoConn, err := proxy.Generator(metadata)
 	if err != nil {
 		t.logCh <- newLog(C.WARNING, "Proxy connect error: %s", err.Error())
 		return
@ -104,28 +104,28 @@ func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
 	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) match(metadata *C.Metadata) C.Proxy {
 	t.configLock.RLock()
 	defer t.configLock.RUnlock()

 	for _, rule := range t.rules {
-		if rule.IsMatch(addr) {
+		if rule.IsMatch(metadata) {
 			a, ok := t.proxies[rule.Adapter()]
 			if !ok {
 				continue
 			}
-			t.logCh <- newLog(C.INFO, "%v match %s using %s", addr.String(), rule.RuleType().String(), rule.Adapter())
+			t.logCh <- newLog(C.INFO, "%v match %s using %s", metadata.String(), rule.RuleType().String(), rule.Adapter())
 			return a
 		}
 	}
-	t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", addr.String())
+	t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", metadata.String())
 	return t.proxies["DIRECT"]
 }
Author	SHA1	Message	Date
Dreamacro	ce07eda428	Chore: update README.md	2018-10-17 00:51:04 +08:00
Dreamacro	0fd2f8e5ee	Chore: update ss-lib for xchacha20-ietf-poly1305	2018-10-16 21:29:29 +08:00
beyondkmp	e863c66ad9	Fix: a typo error	2018-10-16 17:23:58 +08:00
Dreamacro	b68af43389	Improve: support custom configuration directory	2018-10-16 13:12:36 +08:00
Dreamacro	381f764507	Chore: refactoring code of config path	2018-10-14 21:22:58 +08:00
Dreamacro	64e3791654	Improve: better chacha20 implementation	2018-10-10 12:05:02 +08:00
Dreamacro	40a94be208	Fix: rename delay --> interval	2018-10-06 15:13:44 +08:00
Dreamacro	a0f077b091	Improve: get /rules return proxy now	2018-10-06 14:19:06 +08:00
Dreamacro	7b80377849	Fix: return the first proxy when no proxy valid	2018-10-06 14:17:50 +08:00
Dreamacro	8fff0968bf	Feature: add authorization for API	2018-10-06 13:15:02 +08:00
Dreamacro	ea9cd41197	Chore: update README.md	2018-10-03 12:25:24 +08:00
Dreamacro	5c7fa6b18b	Break Change: use yml, which is easier to parse, as the config format	2018-10-02 15:26:36 +08:00
Dreamacro	16c9445459	Chore: adjust the keep-alive time	2018-10-01 19:42:15 +08:00
Dreamacro	04e05c6a85	Feature: repalce dep with go module	2018-10-01 19:38:54 +08:00
Dreamacro	85a67988b9	Feat: add structure helper	2018-09-30 16:30:11 +08:00
Dreamacro	2fd59cb31c	Chore: make the code more semantic	2018-09-30 12:25:52 +08:00
Dreamacro	220e4f0608	Add: fallback policy group	2018-09-26 00:34:15 +08:00
Dreamacro	3e68faecb2	Improve: add rc4-md5 and chacha20 supported with the fork	2018-09-21 15:27:51 +08:00
Dreamacro	eb778ad6e2	Improve: cleanup code	2018-09-21 11:33:29 +08:00