Chore: remove

.gitignore

@@ -1,15 +0,0 @@
-# Binaries for programs and plugins
-*.exe
-*.exe~
-*.dll
-*.so
-*.dylib
-
-# Test binary, build with `go test -c`
-*.test
-
-# Output of the go coverage tool, specifically when used with LiteIDE
-*.out
-
-# dep
-vendor

.travis.yml

@@ -1,27 +0,0 @@
-language: go
-sudo: false
-go:
-  - "1.10"
-before_install:
-  - go get -u github.com/golang/dep/cmd/dep
-install:
-  - "$GOPATH/bin/dep ensure"
-env:
-  global:
-    - NAME=clash
-    - BINDIR=bin
-script:
-  - go test ./...
-before_deploy: make -j releases
-deploy:
-  provider: releases
-  prerelease: true
-  skip_cleanup: true
-  api_key:
-    secure: dp1tc1h0er7aaAZ1hY0Xk/cUKwB0ifsAjg6e0M/Ad5NC87oucP6ESNFkDu0e9rUS1yB826/VnVGzNE/Z5zdjXVzPft+g5v5oRxzI4BKLhf07t9s+x8Z+3sApTxdsC5BvcN9x+5yRbpDLQ3biDPxSFu86j7m2pkEWw6XYNZO3/5y+RZXX7zu+d4MzTLUaA2kWl7KQAP0tEJNuw9ACDhpkw7LYbU/8q3E76prOTeme5/AT6Gxj7XhKUNP27lazhhqBSWM14ybPANqojNLEfMFHN/Eu2phYO07MuLTd4zuOIuw9y65kgvTFcHRlORjwUhnviXyA69obQejjgDI1WDOtU4PqpFaSLrxWtKI6k5VNWHARYggDm/wKl0WG7F0Kgio1KiGGhDg2yrbseXr/zBNaDhBtTFh6XJffqqwmgby1PXB6PWwfvWXooJMaQiFZczLWeMBl8v6XbSN6jtMTh/PQlKai6BcDd4LM8GQ7VHpSeff4qXEU4Vpnadjgs8VDPOHng6/HV+wDs8q2LrlMbnxLWxbCjOMUB6w7YnSrwH9owzKSoUs/531I4tTCRQIgipJtTK2b881/8osVjdMGS1mDXhBWO+OM0LCAdORJz+kN4PIkXXvKLt6jX74k6z4M3swFaqqtlTduN2Yy/ErsjguQO1VZfHmcpNssmJXI5QB9sxA=
-  file: bin/*
-  file_glob: true
-  on:
-    repo: Dreamacro/clash
-    branch: master
-    tags: true

Dockerfile

@@ -1,19 +0,0 @@
-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 && \
-    GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -ldflags '-w -s' -o /clash && \
-    chmod +x /clash
-
-FROM alpine:latest
-RUN apk --no-cache add ca-certificates && \
-    mkdir -p /root/.config/clash
-COPY --from=builder /Country.mmdb /root/.config/clash/
-COPY --from=builder /clash .
-EXPOSE 7890 7891
-ENTRYPOINT ["/clash"]

Gopkg.lock

@@ -1,103 +0,0 @@
-# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
-
-
-[[projects]]
-  branch = "master"
-  name = "github.com/Yawning/chacha20"
-  packages = ["."]
-  revision = "e3b1f968fc6397b51d963fee8ec8711a47bc0ce8"
-
-[[projects]]
-  name = "github.com/eapache/queue"
-  packages = ["."]
-  revision = "44cc805cf13205b55f69e14bcb69867d1ae92f98"
-  version = "v1.1.0"
-
-[[projects]]
-  name = "github.com/go-chi/chi"
-  packages = ["."]
-  revision = "e83ac2304db3c50cf03d96a2fcd39009d458bc35"
-  version = "v3.3.2"
-
-[[projects]]
-  name = "github.com/go-chi/cors"
-  packages = ["."]
-  revision = "dba6525398619dead495962a916728e7ee2ca322"
-  version = "v1.0.0"
-
-[[projects]]
-  name = "github.com/go-chi/render"
-  packages = ["."]
-  revision = "3215478343fbc559bd3fc08f7031bb134d6bdad5"
-  version = "v1.0.1"
-
-[[projects]]
-  name = "github.com/oschwald/geoip2-golang"
-  packages = ["."]
-  revision = "7118115686e16b77967cdbf55d1b944fe14ad312"
-  version = "v1.2.1"
-
-[[projects]]
-  name = "github.com/oschwald/maxminddb-golang"
-  packages = ["."]
-  revision = "c5bec84d1963260297932a1b7a1753c8420717a7"
-  version = "v1.3.0"
-
-[[projects]]
-  name = "github.com/riobard/go-shadowsocks2"
-  packages = [
-    "core",
-    "shadowaead",
-    "shadowstream",
-    "socks"
-  ]
-  revision = "8346403248229fc7e10d7a259de8e9352a9d8830"
-  version = "v0.1.0"
-
-[[projects]]
-  name = "github.com/sirupsen/logrus"
-  packages = ["."]
-  revision = "c155da19408a8799da419ed3eeb0cb5db0ad5dbc"
-  version = "v1.0.5"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/crypto"
-  packages = [
-    "chacha20poly1305",
-    "hkdf",
-    "internal/chacha20",
-    "internal/subtle",
-    "poly1305",
-    "ssh/terminal"
-  ]
-  revision = "a2144134853fc9a27a7b1e3eb4f19f1a76df13c9"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/sys"
-  packages = [
-    "cpu",
-    "unix",
-    "windows"
-  ]
-  revision = "ac767d655b305d4e9612f5f6e33120b9176c4ad4"
-
-[[projects]]
-  name = "gopkg.in/eapache/channels.v1"
-  packages = ["."]
-  revision = "47238d5aae8c0fefd518ef2bee46290909cf8263"
-  version = "v1.1.0"
-
-[[projects]]
-  name = "gopkg.in/ini.v1"
-  packages = ["."]
-  revision = "358ee7663966325963d4e8b2e1fbd570c5195153"
-  version = "v1.38.1"
-
-[solve-meta]
-  analyzer-name = "dep"
-  analyzer-version = 1
-  inputs-digest = "0ccb06b3617c87e75bd650f92adc99e55b93070e0b2a0bc71634270226e125fc"
-  solver-name = "gps-cdcl"
-  solver-version = 1

Gopkg.toml

@@ -1,62 +0,0 @@
-# Gopkg.toml example
-#
-# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
-# 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.2"
-
-[[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/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.5"
-
-[[constraint]]
-  name = "gopkg.in/eapache/channels.v1"
-  version = "1.1.0"
-
-[[constraint]]
-  name = "gopkg.in/ini.v1"
-  version = "1.38.1"
-
-[prune]
-  go-tests = true
-  unused-packages = true

LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2018 Dreamacro
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

Makefile

@@ -1,23 +0,0 @@
-NAME=clash
-BINDIR=bin
-GOBUILD=CGO_ENABLED=0 go build -ldflags '-w -s'
-
-all: linux macos win64
-
-linux:
-	GOARCH=amd64 GOOS=linux $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
-
-macos:
-	GOARCH=amd64 GOOS=darwin $(GOBUILD) -o $(BINDIR)/$(NAME)-$@
-
-win64:
-	GOARCH=amd64 GOOS=windows $(GOBUILD) -o $(BINDIR)/$(NAME)-$@.exe
-
-releases: linux macos win64
-	chmod +x $(BINDIR)/$(NAME)-*
-	gzip $(BINDIR)/$(NAME)-linux
-	gzip $(BINDIR)/$(NAME)-macos
-	zip -m -j $(BINDIR)/$(NAME)-win64.zip $(BINDIR)/$(NAME)-win64.exe
-
-clean:
-	rm $(BINDIR)/*

README.md

@@ -1,117 +1 @@
-<h1 align="center">
-  <img src="https://github.com/Dreamacro/clash/raw/master/docs/logo.png" alt="Clash" width="200">
-  <br>
-  Clash
-  <br>
-</h1>
-
-<h4 align="center">A rule based proxy in Go.</h4>
-
-<p align="center">
-  <a href="https://travis-ci.org/Dreamacro/clash">
-    <img src="https://img.shields.io/travis/Dreamacro/clash.svg?style=flat-square"
-         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">
-  </a>
-  <a href="https://github.com/Dreamacro/clash/releases">
-    <img src="https://img.shields.io/github/release/Dreamacro/clash/all.svg?style=flat-square">
-  </a>
-</p>
-
-## Features
-
-- HTTP/HTTPS and SOCKS proxy
-- Surge like configuration
-- GeoIP rule support
-
-## Install
-
-You can build from source:
-
-```sh
-go get -u -v github.com/Dreamacro/clash
-```
-
-Pre-built binaries are available: [release](https://github.com/Dreamacro/clash/releases)
-
-Requires Go >= 1.10.
-
-## Daemon
-
-Unfortunately, there is no native elegant way to implement golang's daemon.
-
-So we can use third-party daemon tools like pm2, supervisor, and so on.
-
-In the case of [pm2](https://github.com/Unitech/pm2), we can start the daemon this way:
-
-```sh
-pm2 start clash
-```
-
-If you have Docker installed, you can run clash directly using `docker-compose`.
-
-[Run clash in docker](https://github.com/Dreamacro/clash/wiki/Run-clash-in-docker)
-
-## Config
-
-Configuration file at `$HOME/.config/clash/config.ini`
-
-Below is a simple demo configuration file:
-
-```ini
-[General]
-port = 7890
-socks-port = 7891
-
-# redir proxy for Linux and macOS
-redir-port = 7892
-
-# A RESTful API for clash
-external-controller = 127.0.0.1:8080
-
-[Proxy]
-# name = ss, server, port, cipher, password
-# 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
-
-# name = socks5, server, port
-socks = socks5, server1, port
-
-[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
-
-# 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
-
-[Rule]
-DOMAIN-SUFFIX,google.com,Proxy
-DOMAIN-KEYWORD,google,Proxy
-DOMAIN-SUFFIX,ad.com,REJECT
-GEOIP,CN,DIRECT
-FINAL,,Proxy # note: there is two ","
-```
-
-## Thanks
-
-[riobard/go-shadowsocks2](https://github.com/riobard/go-shadowsocks2)
-
-[google/tcpproxy](https://github.com/google/tcpproxy)
-
-## License
-
-[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2FDreamacro%2Fclash.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2FDreamacro%2Fclash?ref=badge_large)
-
-## TODO
-
-- [x] Complementing the necessary rule operators
-- [x] Redir proxy
-- [ ] UDP support
-- [ ] Connection manager
+Removed

adapters/local/http.go

@@ -1,82 +0,0 @@
-package adapters
-
-import (
-	"bufio"
-	"bytes"
-	"io"
-	"net"
-	"strings"
-
-	C "github.com/Dreamacro/clash/constant"
-)
-
-// PeekedConn handle http connection and buffed HTTP data
-type PeekedConn struct {
-	net.Conn
-	Peeked []byte
-	host   string
-	isHTTP bool
-}
-
-func (c *PeekedConn) Read(p []byte) (n int, err error) {
-	if len(c.Peeked) > 0 {
-		n = copy(p, c.Peeked)
-		c.Peeked = c.Peeked[n:]
-		if len(c.Peeked) == 0 {
-			c.Peeked = nil
-		}
-		return n, nil
-	}
-
-	// Sometimes firefox just open a socket to process multiple domains in HTTP
-	// The temporary solution is to return io.EOF when encountering different HOST
-	if c.isHTTP {
-		br := bufio.NewReader(bytes.NewReader(p))
-		_, hostName := ParserHTTPHostHeader(br)
-		if hostName != "" {
-			if !strings.Contains(hostName, ":") {
-				hostName += ":80"
-			}
-
-			if hostName != c.host {
-				return 0, io.EOF
-			}
-		}
-	}
-
-	return c.Conn.Read(p)
-}
-
-// HTTPAdapter is a adapter for HTTP connection
-type HTTPAdapter struct {
-	addr *C.Addr
-	conn *PeekedConn
-}
-
-// Close HTTP connection
-func (h *HTTPAdapter) Close() {
-	h.conn.Close()
-}
-
-// Addr return destination address
-func (h *HTTPAdapter) Addr() *C.Addr {
-	return h.addr
-}
-
-// Conn return raw net.Conn of HTTP
-func (h *HTTPAdapter) Conn() net.Conn {
-	return h.conn
-}
-
-// NewHTTP is HTTPAdapter generator
-func NewHTTP(host string, peeked []byte, isHTTP bool, conn net.Conn) *HTTPAdapter {
-	return &HTTPAdapter{
-		addr: parseHTTPAddr(host),
-		conn: &PeekedConn{
-			Peeked: peeked,
-			Conn:   conn,
-			host:   host,
-			isHTTP: isHTTP,
-		},
-	}
-}

adapters/local/socks.go

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

adapters/local/util.go

@@ -1,140 +0,0 @@
-package adapters
-
-import (
-	"bufio"
-	"bytes"
-	"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(target string) *C.Addr {
-	host, port, _ := net.SplitHostPort(target)
-	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,
-	}
-}
-
-// ParserHTTPHostHeader returns the HTTP Host header from br without
-// consuming any of its bytes. It returns "" if it can't find one.
-func ParserHTTPHostHeader(br *bufio.Reader) (method, host string) {
-	// br := bufio.NewReader(bytes.NewReader(data))
-	const maxPeek = 4 << 10
-	peekSize := 0
-	for {
-		peekSize++
-		if peekSize > maxPeek {
-			b, _ := br.Peek(br.Buffered())
-			return method, httpHostHeaderFromBytes(b)
-		}
-		b, err := br.Peek(peekSize)
-		if n := br.Buffered(); n > peekSize {
-			b, _ = br.Peek(n)
-			peekSize = n
-		}
-		if len(b) > 0 {
-			if b[0] < 'A' || b[0] > 'Z' {
-				// Doesn't look like an HTTP verb
-				// (GET, POST, etc).
-				return
-			}
-			if bytes.Index(b, crlfcrlf) != -1 || bytes.Index(b, lflf) != -1 {
-				req, err := http.ReadRequest(bufio.NewReader(bytes.NewReader(b)))
-				if err != nil {
-					return
-				}
-				if len(req.Header["Host"]) > 1 {
-					// TODO(bradfitz): what does
-					// ReadRequest do if there are
-					// multiple Host headers?
-					return
-				}
-				return req.Method, req.Host
-			}
-		}
-		if err != nil {
-			return method, httpHostHeaderFromBytes(b)
-		}
-	}
-}
-
-var (
-	lfHostColon = []byte("\nHost:")
-	lfhostColon = []byte("\nhost:")
-	crlf        = []byte("\r\n")
-	lf          = []byte("\n")
-	crlfcrlf    = []byte("\r\n\r\n")
-	lflf        = []byte("\n\n")
-)
-
-func httpHostHeaderFromBytes(b []byte) string {
-	if i := bytes.Index(b, lfHostColon); i != -1 {
-		return string(bytes.TrimSpace(untilEOL(b[i+len(lfHostColon):])))
-	}
-	if i := bytes.Index(b, lfhostColon); i != -1 {
-		return string(bytes.TrimSpace(untilEOL(b[i+len(lfhostColon):])))
-	}
-	return ""
-}
-
-// untilEOL returns v, truncated before the first '\n' byte, if any.
-// The returned slice may include a '\r' at the end.
-func untilEOL(v []byte) []byte {
-	if i := bytes.IndexByte(v, '\n'); i != -1 {
-		return v[:i]
-	}
-	return v
-}

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
-	}
-	c.(*net.TCPConn).SetKeepAlive(true)
-	return &DirectAdapter{conn: c}, nil
-}
-
-func NewDirect() *Direct {
-	return &Direct{}
-}

adapters/remote/reject.go

@@ -1,69 +0,0 @@
-package adapters
-
-import (
-	"io"
-	"net"
-	"time"
-
-	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 {
-}
-
-func (r *Reject) Name() string {
-	return "Reject"
-}
-
-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{}
-}
-
-type NopConn struct{}
-
-func (rw *NopConn) Read(b []byte) (int, error) {
-	return len(b), nil
-}
-
-func (rw *NopConn) Write(b []byte) (int, error) {
-	return 0, io.EOF
-}
-
-// Close is fake function for net.Conn
-func (rw *NopConn) Close() error { return nil }
-
-// LocalAddr is fake function for net.Conn
-func (rw *NopConn) LocalAddr() net.Addr { return nil }
-
-// RemoteAddr is fake function for net.Conn
-func (rw *NopConn) RemoteAddr() net.Addr { return nil }
-
-// SetDeadline is fake function for net.Conn
-func (rw *NopConn) SetDeadline(time.Time) error { return nil }
-
-// SetReadDeadline is fake function for net.Conn
-func (rw *NopConn) SetReadDeadline(time.Time) error { return nil }
-
-// SetWriteDeadline is fake function for net.Conn
-func (rw *NopConn) SetWriteDeadline(time.Time) error { return nil }

adapters/remote/selector.go

@@ -1,67 +0,0 @@
-package adapters
-
-import (
-	"errors"
-	"sort"
-
-	C "github.com/Dreamacro/clash/constant"
-)
-
-type Selector struct {
-	name     string
-	selected C.Proxy
-	proxies  map[string]C.Proxy
-}
-
-func (s *Selector) Name() string {
-	return s.name
-}
-
-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) 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
-}
-
-func (s *Selector) Set(name string) error {
-	proxy, exist := s.proxies[name]
-	if !exist {
-		return errors.New("Proxy does not exist")
-	}
-	s.selected = proxy
-	return nil
-}
-
-func NewSelector(name string, proxies map[string]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 k, v := range proxies {
-		mapping[k] = v
-		init = k
-	}
-	s := &Selector{
-		name:     name,
-		proxies:  mapping,
-		selected: proxies[init],
-	}
-	return s, nil
-}

adapters/remote/shadowsocks.go

@@ -1,101 +0,0 @@
-package adapters
-
-import (
-	"bytes"
-	"fmt"
-	"net"
-	"net/url"
-	"strconv"
-
-	C "github.com/Dreamacro/clash/constant"
-
-	"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
-	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)
-	}
-	c.(*net.TCPConn).SetKeepAlive(true)
-	c = ss.cipher.StreamConn(c)
-	_, err = c.Write(serializesSocksAddr(addr))
-	return &ShadowsocksAdapter{conn: c}, err
-}
-
-func NewShadowSocks(name string, ssURL 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())
-	}
-	return &ShadowSocks{
-		server: server,
-		name:   name,
-		cipher: ciph,
-	}, 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,91 +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)
-	}
-	c.(*net.TCPConn).SetKeepAlive(true)
-
-	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/util.go

@@ -1,86 +0,0 @@
-package adapters
-
-import (
-	"fmt"
-	"net"
-	"net/http"
-	"net/url"
-	"time"
-
-	C "github.com/Dreamacro/clash/constant"
-)
-
-// DelayTest get the delay for the specified URL
-func DelayTest(proxy C.Proxy, url string) (t int16, err error) {
-	addr, err := urlToAddr(url)
-	if err != nil {
-		return
-	}
-
-	start := time.Now()
-	instance, err := proxy.Generator(&addr)
-	if err != nil {
-		return
-	}
-	defer instance.Close()
-	transport := &http.Transport{
-		Dial: func(string, string) (net.Conn, error) {
-			return instance.Conn(), nil
-		},
-		// from http.DefaultTransport
-		MaxIdleConns:          100,
-		IdleConnTimeout:       90 * time.Second,
-		TLSHandshakeTimeout:   10 * time.Second,
-		ExpectContinueTimeout: 1 * time.Second,
-	}
-	client := http.Client{Transport: transport}
-	req, err := client.Get(url)
-	if err != nil {
-		return
-	}
-	req.Body.Close()
-	t = int16(time.Since(start) / time.Millisecond)
-	return
-}
-
-func urlToAddr(rawURL string) (addr C.Addr, err error) {
-	u, err := url.Parse(rawURL)
-	if err != nil {
-		return
-	}
-
-	port := u.Port()
-	if port == "" {
-		if u.Scheme == "https" {
-			port = "443"
-		} else if u.Scheme == "http" {
-			port = "80"
-		} else {
-			err = fmt.Errorf("%s scheme not Support", rawURL)
-			return
-		}
-	}
-
-	addr = C.Addr{
-		AddrType: C.AtypDomainName,
-		Host:     u.Hostname(),
-		IP:       nil,
-		Port:     port,
-	}
-	return
-}
-
-func selectFast(in chan interface{}) chan interface{} {
-	out := make(chan interface{})
-	go func() {
-		p, open := <-in
-		if open {
-			out <- p
-		}
-		close(out)
-		for range in {
-		}
-	}()
-
-	return out
-}

config/config.go

@@ -1,373 +0,0 @@
-package config
-
-import (
-	"fmt"
-	"os"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/Dreamacro/clash/adapters/remote"
-	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"
-)
-
-var (
-	config *Config
-	once   sync.Once
-)
-
-// General config
-type General struct {
-	Port      int
-	SocksPort int
-	RedirPort int
-	AllowLan  bool
-	Mode      Mode
-	LogLevel  C.LogLevel
-}
-
-// ProxyConfig is update proxy schema
-type ProxyConfig struct {
-	Port      *int
-	SocksPort *int
-	RedirPort *int
-	AllowLan  *bool
-}
-
-// Config is clash config manager
-type Config struct {
-	general    *General
-	rules      []C.Rule
-	proxies    map[string]C.Proxy
-	lastUpdate time.Time
-
-	event      chan<- interface{}
-	reportCh   chan interface{}
-	observable *observable.Observable
-}
-
-// Event is event of clash config
-type Event struct {
-	Type    string
-	Payload interface{}
-}
-
-// Subscribe config stream
-func (c *Config) Subscribe() observable.Subscription {
-	sub, _ := c.observable.Subscribe()
-	return sub
-}
-
-// Report return a channel for collecting report message
-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) {
-		return nil, err
-	}
-	return ini.LoadSources(
-		ini.LoadOptions{AllowBooleanKeys: true},
-		C.ConfigPath,
-	)
-}
-
-// Parse config
-func (c *Config) Parse() error {
-	cfg, err := c.readConfig()
-	if err != nil {
-		return err
-	}
-
-	if err := c.parseGeneral(cfg); err != nil {
-		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 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())
-
-	mode, exist := ModeMapping[modeString]
-	if !exist {
-		return fmt.Errorf("General.mode value invalid")
-	}
-
-	logLevel, exist := C.LogLevelMapping[logLevelString]
-	if !exist {
-		return fmt.Errorf("General.log-level value invalid")
-	}
-
-	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 (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
-	}
-
-	if (pc.AllowLan != nil || pc.Port != nil) && *pc.Port != 0 {
-		c.general.Port = *pc.Port
-		c.event <- &Event{Type: "http-addr", Payload: genAddr(*pc.Port, c.general.AllowLan)}
-	}
-
-	if (pc.AllowLan != nil || pc.SocksPort != nil) && *pc.SocksPort != 0 {
-		c.general.SocksPort = *pc.SocksPort
-		c.event <- &Event{Type: "socks-addr", Payload: genAddr(*pc.SocksPort, c.general.AllowLan)}
-	}
-
-	if (pc.AllowLan != nil || pc.RedirPort != nil) && *pc.RedirPort != 0 {
-		c.general.RedirPort = *pc.RedirPort
-		c.event <- &Event{Type: "redir-addr", Payload: genAddr(*pc.RedirPort, c.general.AllowLan)}
-	}
-}
-
-func (c *Config) parseProxies(cfg *ini.File) error {
-	proxies := make(map[string]C.Proxy)
-	proxiesConfig := cfg.Section("Proxy")
-	groupsConfig := cfg.Section("Proxy Group")
-
-	// 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])
-			ss, err := adapters.NewShadowSocks(key.Name(), ssURL)
-			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
-		}
-	}
-
-	// 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
-	c.event <- &Event{Type: "proxies", Payload: proxies}
-	return nil
-}
-
-func (c *Config) parseRules(cfg *ini.File) error {
-	rules := []C.Rule{}
-
-	rulesConfig := cfg.Section("Rule")
-	// parse rules
-	for _, key := range rulesConfig.Keys() {
-		rule := strings.Split(key.Name(), ",")
-		if len(rule) < 3 {
-			continue
-		}
-		rule = trimArr(rule)
-		switch rule[0] {
-		case "DOMAIN-SUFFIX":
-			rules = append(rules, R.NewDomainSuffix(rule[1], rule[2]))
-		case "DOMAIN-KEYWORD":
-			rules = append(rules, R.NewDomainKeyword(rule[1], rule[2]))
-		case "GEOIP":
-			rules = append(rules, R.NewGEOIP(rule[1], rule[2]))
-		case "IP-CIDR", "IP-CIDR6":
-			rules = append(rules, R.NewIPCIDR(rule[1], rule[2]))
-		case "FINAL":
-			rules = append(rules, R.NewFinal(rule[2]))
-		}
-	}
-
-	c.rules = rules
-	c.event <- &Event{Type: "rules", Payload: rules}
-	return nil
-}
-
-func (c *Config) handleResponseMessage() {
-	for elm := range c.reportCh {
-		event := elm.(*Event)
-		switch event.Type {
-		case "http-addr":
-			if event.Payload.(bool) == false {
-				log.Errorf("Listening HTTP proxy at %s error", c.general.Port)
-				c.general.Port = 0
-			}
-		case "socks-addr":
-			if event.Payload.(bool) == false {
-				log.Errorf("Listening SOCKS proxy at %s error", c.general.SocksPort)
-				c.general.SocksPort = 0
-			}
-		case "redir-addr":
-			if event.Payload.(bool) == false {
-				log.Errorf("Listening Redir proxy at %s error", c.general.RedirPort)
-				c.general.RedirPort = 0
-			}
-		}
-	}
-}
-
-func newConfig() *Config {
-	event := make(chan interface{})
-	reportCh := make(chan interface{})
-	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
-func Instance() *Config {
-	once.Do(func() {
-		config = newConfig()
-	})
-	return config
-}

config/initial.go

@@ -1,72 +0,0 @@
-package config
-
-import (
-	"archive/tar"
-	"compress/gzip"
-	"io"
-	"net/http"
-	"os"
-	"strings"
-
-	C "github.com/Dreamacro/clash/constant"
-
-	log "github.com/sirupsen/logrus"
-)
-
-func downloadMMDB(path string) (err error) {
-	resp, err := http.Get("http://geolite.maxmind.com/download/geoip/database/GeoLite2-Country.tar.gz")
-	if err != nil {
-		return
-	}
-	defer resp.Body.Close()
-
-	gr, err := gzip.NewReader(resp.Body)
-	if err != nil {
-		return
-	}
-	defer gr.Close()
-
-	tr := tar.NewReader(gr)
-	for {
-		h, err := tr.Next()
-		if err == io.EOF {
-			break
-		} else if err != nil {
-			return err
-		}
-
-		if !strings.HasSuffix(h.Name, "GeoLite2-Country.mmdb") {
-			continue
-		}
-
-		f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0644)
-		if err != nil {
-			return err
-		}
-		defer f.Close()
-		_, err = io.Copy(f, tr)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// Init prepare necessary files
-func Init() {
-	// initial config.ini
-	if _, err := os.Stat(C.ConfigPath); os.IsNotExist(err) {
-		log.Info("Can't find config, create a empty file")
-		os.OpenFile(C.ConfigPath, os.O_CREATE|os.O_WRONLY, 0644)
-	}
-
-	// initial mmdb
-	if _, err := os.Stat(C.MMDBPath); os.IsNotExist(err) {
-		log.Info("Can't find MMDB, start download")
-		err := downloadMMDB(C.MMDBPath)
-		if err != nil {
-			log.Fatalf("Can't download MMDB: %s", err.Error())
-		}
-	}
-}

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

@@ -1,20 +0,0 @@
-package config
-
-import (
-	"fmt"
-	"strings"
-)
-
-func trimArr(arr []string) (r []string) {
-	for _, e := range arr {
-		r = append(r, strings.Trim(e, " "))
-	}
-	return
-}
-
-func genAddr(port int, allowLan bool) string {
-	if allowLan {
-		return fmt.Sprintf(":%d", port)
-	}
-	return fmt.Sprintf("127.0.0.1:%d", port)
-}

constant/adapters.go

@@ -1,53 +0,0 @@
-package constant
-
-import (
-	"net"
-)
-
-// Adapter Type
-const (
-	Direct AdapterType = iota
-	Reject
-	Selector
-	Shadowsocks
-	Socks5
-	URLTest
-)
-
-type ProxyAdapter interface {
-	Conn() net.Conn
-	Close()
-}
-
-type ServerAdapter interface {
-	Addr() *Addr
-	Close()
-}
-
-type Proxy interface {
-	Name() string
-	Type() AdapterType
-	Generator(addr *Addr) (ProxyAdapter, error)
-}
-
-// AdapterType is enum of adapter type
-type AdapterType int
-
-func (at AdapterType) String() string {
-	switch at {
-	case Direct:
-		return "Direct"
-	case Reject:
-		return "Reject"
-	case Selector:
-		return "Selector"
-	case Shadowsocks:
-		return "Shadowsocks"
-	case Socks5:
-		return "Socks5"
-	case URLTest:
-		return "URLTest"
-	default:
-		return "Unknow"
-	}
-}

constant/addr.go

@@ -1,46 +0,0 @@
-package constant
-
-import (
-	"net"
-)
-
-// Socks addr type
-const (
-	AtypIPv4       = 1
-	AtypDomainName = 3
-	AtypIPv6       = 4
-
-	TCP NetWork = iota
-	UDP
-
-	HTTP SourceType = iota
-	SOCKS
-)
-
-type NetWork int
-
-func (n *NetWork) String() string {
-	if *n == TCP {
-		return "tcp"
-	}
-	return "udp"
-}
-
-type SourceType int
-
-// Addr is used to store connection address
-type Addr struct {
-	NetWork  NetWork
-	Source   SourceType
-	AddrType int
-	Host     string
-	IP       *net.IP
-	Port     string
-}
-
-func (addr *Addr) String() string {
-	if addr.Host == "" {
-		return addr.IP.String()
-	}
-	return addr.Host
-}

constant/config.go

@@ -1,50 +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"`
-	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/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

@@ -1,36 +0,0 @@
-package constant
-
-// Rule Type
-const (
-	DomainSuffix RuleType = iota
-	DomainKeyword
-	GEOIP
-	IPCIDR
-	FINAL
-)
-
-type RuleType int
-
-func (rt RuleType) String() string {
-	switch rt {
-	case DomainSuffix:
-		return "DomainSuffix"
-	case DomainKeyword:
-		return "DomainKeyword"
-	case GEOIP:
-		return "GEOIP"
-	case IPCIDR:
-		return "IPCIDR"
-	case FINAL:
-		return "FINAL"
-	default:
-		return "Unknow"
-	}
-}
-
-type Rule interface {
-	RuleType() RuleType
-	IsMatch(addr *Addr) bool
-	Adapter() string
-	Payload() string
-}

constant/traffic.go

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

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,93 +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"`
-	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,
-		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,
-	})
-
-	w.WriteHeader(http.StatusNoContent)
-}

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/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,142 +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 GetLogs struct {
-	Level string `json:"level"`
-}
-
-type Log struct {
-	Type    string `json:"type"`
-	Payload string `json:"payload"`
-}
-
-func getLogs(w http.ResponseWriter, r *http.Request) {
-	req := &GetLogs{}
-	render.DecodeJSON(r.Body, req)
-	if req.Level == "" {
-		req.Level = "info"
-	}
-
-	level, ok := C.LogLevelMapping[req.Level]
-	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
-}

main.go

@@ -1,30 +0,0 @@
-package main
-
-import (
-	"os"
-	"os/signal"
-	"syscall"
-
-	"github.com/Dreamacro/clash/config"
-	"github.com/Dreamacro/clash/hub"
-	"github.com/Dreamacro/clash/proxy"
-	"github.com/Dreamacro/clash/tunnel"
-
-	log "github.com/sirupsen/logrus"
-)
-
-func main() {
-	tunnel.Instance().Run()
-	proxy.Instance().Run()
-	hub.Run()
-
-	config.Init()
-	err := config.Instance().Parse()
-	if err != nil {
-		log.Fatalf("Parse config error: %s", err.Error())
-	}
-
-	sigCh := make(chan os.Signal, 1)
-	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
-	<-sigCh
-}

observable/iterable.go

@@ -1,3 +0,0 @@
-package observable
-
-type Iterable <-chan interface{}

observable/observable.go

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

observable/observable_test.go

@@ -1,124 +0,0 @@
-package observable
-
-import (
-	"runtime"
-	"sync"
-	"testing"
-	"time"
-)
-
-func iterator(item []interface{}) chan interface{} {
-	ch := make(chan interface{})
-	go func() {
-		time.Sleep(100 * time.Millisecond)
-		for _, elm := range item {
-			ch <- elm
-		}
-		close(ch)
-	}()
-	return ch
-}
-
-func TestObservable(t *testing.T) {
-	iter := iterator([]interface{}{1, 2, 3, 4, 5})
-	src := NewObservable(iter)
-	data, err := src.Subscribe()
-	if err != nil {
-		t.Error(err)
-	}
-	count := 0
-	for range data {
-		count = count + 1
-	}
-	if count != 5 {
-		t.Error("Revc number error")
-	}
-}
-
-func TestObservable_MutilSubscribe(t *testing.T) {
-	iter := iterator([]interface{}{1, 2, 3, 4, 5})
-	src := NewObservable(iter)
-	ch1, _ := src.Subscribe()
-	ch2, _ := src.Subscribe()
-	count := 0
-
-	var wg sync.WaitGroup
-	wg.Add(2)
-	waitCh := func(ch <-chan interface{}) {
-		for range ch {
-			count = count + 1
-		}
-		wg.Done()
-	}
-	go waitCh(ch1)
-	go waitCh(ch2)
-	wg.Wait()
-	if count != 10 {
-		t.Error("Revc number error")
-	}
-}
-
-func TestObservable_UnSubscribe(t *testing.T) {
-	iter := iterator([]interface{}{1, 2, 3, 4, 5})
-	src := NewObservable(iter)
-	data, err := src.Subscribe()
-	if err != nil {
-		t.Error(err)
-	}
-	src.UnSubscribe(data)
-	_, open := <-data
-	if open {
-		t.Error("Revc number error")
-	}
-}
-
-func TestObservable_SubscribeClosedSource(t *testing.T) {
-	iter := iterator([]interface{}{1})
-	src := NewObservable(iter)
-	data, _ := src.Subscribe()
-	<-data
-
-	_, closed := src.Subscribe()
-	if closed == nil {
-		t.Error("Observable should be closed")
-	}
-}
-
-func TestObservable_UnSubscribeWithNotExistSubscription(t *testing.T) {
-	sub := Subscription(make(chan interface{}))
-	iter := iterator([]interface{}{1})
-	src := NewObservable(iter)
-	src.UnSubscribe(sub)
-}
-
-func TestObservable_SubscribeGoroutineLeak(t *testing.T) {
-	// waiting for other goroutine recycle
-	time.Sleep(120 * time.Millisecond)
-	init := runtime.NumGoroutine()
-	iter := iterator([]interface{}{1, 2, 3, 4, 5})
-	src := NewObservable(iter)
-	max := 100
-
-	var list []Subscription
-	for i := 0; i < max; i++ {
-		ch, _ := src.Subscribe()
-		list = append(list, ch)
-	}
-
-	var wg sync.WaitGroup
-	wg.Add(max)
-	waitCh := func(ch <-chan interface{}) {
-		for range ch {
-		}
-		wg.Done()
-	}
-
-	for _, ch := range list {
-		go waitCh(ch)
-	}
-	wg.Wait()
-	now := runtime.NumGoroutine()
-	if init != now {
-		t.Errorf("Goroutine Leak: init %d now %d", init, now)
-	}
-}

observable/subscriber.go

@@ -1,35 +0,0 @@
-package observable
-
-import (
-	"sync"
-
-	"gopkg.in/eapache/channels.v1"
-)
-
-type Subscription <-chan interface{}
-
-type Subscriber struct {
-	buffer *channels.InfiniteChannel
-	once   sync.Once
-}
-
-func (s *Subscriber) Emit(item interface{}) {
-	s.buffer.In() <- item
-}
-
-func (s *Subscriber) Out() Subscription {
-	return s.buffer.Out()
-}
-
-func (s *Subscriber) Close() {
-	s.once.Do(func() {
-		s.buffer.Close()
-	})
-}
-
-func newSubscriber() *Subscriber {
-	sub := &Subscriber{
-		buffer: channels.NewInfiniteChannel(),
-	}
-	return sub
-}

proxy/http/server.go

@@ -1,79 +0,0 @@
-package http
-
-import (
-	"bufio"
-	"net"
-	"net/http"
-	"strings"
-
-	"github.com/Dreamacro/clash/adapters/local"
-	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/tunnel"
-
-	log "github.com/sirupsen/logrus"
-)
-
-var (
-	tun = tunnel.Instance()
-)
-
-func NewHttpProxy(addr string) (*C.ProxySignal, error) {
-	l, err := net.Listen("tcp", addr)
-	if err != nil {
-		return nil, err
-	}
-
-	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)
-		for {
-			c, err := l.Accept()
-			if err != nil {
-				if _, open := <-done; !open {
-					break
-				}
-				continue
-			}
-			go handleConn(c)
-		}
-	}()
-
-	go func() {
-		<-done
-		close(done)
-		l.Close()
-		closed <- struct{}{}
-	}()
-
-	return signal, nil
-}
-
-func handleConn(conn net.Conn) {
-	br := bufio.NewReader(conn)
-	method, hostName := adapters.ParserHTTPHostHeader(br)
-	if hostName == "" {
-		return
-	}
-
-	if !strings.Contains(hostName, ":") {
-		hostName += ":80"
-	}
-
-	var peeked []byte
-	if method == http.MethodConnect {
-		_, err := conn.Write([]byte("HTTP/1.1 200 Connection established\r\n\r\n"))
-		if err != nil {
-			return
-		}
-	} else if n := br.Buffered(); n > 0 {
-		peeked, _ = br.Peek(br.Buffered())
-	}
-
-	tun.Add(adapters.NewHTTP(hostName, peeked, method != http.MethodConnect, conn))
-}

proxy/listener.go

@@ -1,116 +0,0 @@
-package proxy
-
-import (
-	"sync"
-
-	"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
-	once     sync.Once
-)
-
-type Listener struct {
-	// signal for update
-	httpSignal  *C.ProxySignal
-	socksSignal *C.ProxySignal
-	redirSignal *C.ProxySignal
-}
-
-func (l *Listener) updateHTTP(addr string) error {
-	if l.httpSignal != nil {
-		signal := l.httpSignal
-		signal.Done <- struct{}{}
-		<-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 {
-	if l.socksSignal != nil {
-		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 {
-	if l.redirSignal != nil {
-		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{}) {
-	sub := config.Instance().Subscribe()
-	signal <- struct{}{}
-	reportCH := config.Instance().Report()
-	for elm := range sub {
-		event := elm.(*config.Event)
-		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}
-		}
-	}
-}
-
-// Run ensure config monitoring
-func (l *Listener) Run() {
-	signal := make(chan struct{})
-	go l.process(signal)
-	<-signal
-}
-
-func newListener() *Listener {
-	return &Listener{}
-}
-
-// Instance return singleton instance of Listener
-func Instance() *Listener {
-	once.Do(func() {
-		listener = newListener()
-	})
-	return listener
-}

proxy/redir/tcp.go

@@ -1,62 +0,0 @@
-package redir
-
-import (
-	"net"
-
-	"github.com/Dreamacro/clash/adapters/local"
-	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/tunnel"
-
-	log "github.com/sirupsen/logrus"
-)
-
-var (
-	tun = tunnel.Instance()
-)
-
-func NewRedirProxy(addr string) (*C.ProxySignal, error) {
-	l, err := net.Listen("tcp", addr)
-	if err != nil {
-		return nil, err
-	}
-
-	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)
-		for {
-			c, err := l.Accept()
-			if err != nil {
-				if _, open := <-done; !open {
-					break
-				}
-				continue
-			}
-			go handleRedir(c)
-		}
-	}()
-
-	go func() {
-		<-done
-		close(done)
-		l.Close()
-		closed <- struct{}{}
-	}()
-
-	return signal, nil
-}
-
-func handleRedir(conn net.Conn) {
-	target, err := parserPacket(conn)
-	if err != nil {
-		conn.Close()
-		return
-	}
-	conn.(*net.TCPConn).SetKeepAlive(true)
-	tun.Add(adapters.NewSocks(target, conn))
-}

proxy/redir/tcp_darwin.go

@@ -1,58 +0,0 @@
-package redir
-
-import (
-	"net"
-	"syscall"
-	"unsafe"
-
-	"github.com/riobard/go-shadowsocks2/socks"
-)
-
-func parserPacket(c net.Conn) (socks.Addr, error) {
-	const (
-		PfInout     = 0
-		PfIn        = 1
-		PfOut       = 2
-		IOCOut      = 0x40000000
-		IOCIn       = 0x80000000
-		IOCInOut    = IOCIn | IOCOut
-		IOCPARMMask = 0x1FFF
-		LEN         = 4*16 + 4*4 + 4*1
-		// #define	_IOC(inout,group,num,len) (inout | ((len & IOCPARMMask) << 16) | ((group) << 8) | (num))
-		// #define	_IOWR(g,n,t)	_IOC(IOCInOut,	(g), (n), sizeof(t))
-		// #define DIOCNATLOOK		_IOWR('D', 23, struct pfioc_natlook)
-		DIOCNATLOOK = IOCInOut | ((LEN & IOCPARMMask) << 16) | ('D' << 8) | 23
-	)
-
-	fd, err := syscall.Open("/dev/pf", 0, syscall.O_RDONLY)
-	if err != nil {
-		return nil, err
-	}
-	defer syscall.Close(fd)
-
-	nl := struct { // struct pfioc_natlook
-		saddr, daddr, rsaddr, rdaddr       [16]byte
-		sxport, dxport, rsxport, rdxport   [4]byte
-		af, proto, protoVariant, direction uint8
-	}{
-		af:        syscall.AF_INET,
-		proto:     syscall.IPPROTO_TCP,
-		direction: PfOut,
-	}
-	saddr := c.RemoteAddr().(*net.TCPAddr)
-	daddr := c.LocalAddr().(*net.TCPAddr)
-	copy(nl.saddr[:], saddr.IP)
-	copy(nl.daddr[:], daddr.IP)
-	nl.sxport[0], nl.sxport[1] = byte(saddr.Port>>8), byte(saddr.Port)
-	nl.dxport[0], nl.dxport[1] = byte(daddr.Port>>8), byte(daddr.Port)
-
-	if _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, uintptr(fd), DIOCNATLOOK, uintptr(unsafe.Pointer(&nl))); errno != 0 {
-		return nil, errno
-	}
-
-	addr := make([]byte, 1+net.IPv4len+2)
-	addr[0] = socks.AtypIPv4
-	copy(addr[1:1+net.IPv4len], nl.rdaddr[:4])
-	copy(addr[1+net.IPv4len:], nl.rdxport[:2])
-	return addr, nil
-}

proxy/redir/tcp_linux.go

@@ -1,51 +0,0 @@
-package redir
-
-import (
-	"errors"
-	"net"
-	"syscall"
-	"unsafe"
-
-	"github.com/riobard/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)
-	if err := socketcall(GETSOCKOPT, fd, syscall.IPPROTO_IP, SO_ORIGINAL_DST, uintptr(unsafe.Pointer(&raw)), uintptr(unsafe.Pointer(&siz)), 0); err != nil {
-		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_386.go

@@ -1,17 +0,0 @@
-package redir
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-const GETSOCKOPT = 15 // https://golang.org/src/syscall/syscall_linux_386.go#L183
-
-func socketcall(call, a0, a1, a2, a3, a4, a5 uintptr) error {
-	var a [6]uintptr
-	a[0], a[1], a[2], a[3], a[4], a[5] = a0, a1, a2, a3, a4, a5
-	if _, _, errno := syscall.Syscall6(syscall.SYS_SOCKETCALL, call, uintptr(unsafe.Pointer(&a)), 0, 0, 0, 0); errno != 0 {
-		return errno
-	}
-	return nil
-}

proxy/redir/tcp_linux_other.go

@@ -1,14 +0,0 @@
-// +build linux,!386
-
-package redir
-
-import "syscall"
-
-const GETSOCKOPT = syscall.SYS_GETSOCKOPT
-
-func socketcall(call, a0, a1, a2, a3, a4, a5 uintptr) error {
-	if _, _, errno := syscall.Syscall6(call, a0, a1, a2, a3, a4, a5); errno != 0 {
-		return errno
-	}
-	return nil
-}

proxy/redir/tcp_windows.go

@@ -1,12 +0,0 @@
-package redir
-
-import (
-	"errors"
-	"net"
-
-	"github.com/riobard/go-shadowsocks2/socks"
-)
-
-func parserPacket(conn net.Conn) (socks.Addr, error) {
-	return nil, errors.New("Windows not support yet")
-}

proxy/socks/tcp.go

@@ -1,63 +0,0 @@
-package socks
-
-import (
-	"net"
-
-	"github.com/Dreamacro/clash/adapters/local"
-	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/tunnel"
-
-	"github.com/riobard/go-shadowsocks2/socks"
-	log "github.com/sirupsen/logrus"
-)
-
-var (
-	tun = tunnel.Instance()
-)
-
-func NewSocksProxy(addr string) (*C.ProxySignal, error) {
-	l, err := net.Listen("tcp", addr)
-	if err != nil {
-		return nil, err
-	}
-
-	done := make(chan struct{})
-	closed := make(chan struct{})
-	signal := &C.ProxySignal{
-		Done:   done,
-		Closed: closed,
-	}
-
-	go func() {
-		log.Infof("SOCKS proxy listening at: %s", addr)
-		for {
-			c, err := l.Accept()
-			if err != nil {
-				if _, open := <-done; !open {
-					break
-				}
-				continue
-			}
-			go handleSocks(c)
-		}
-	}()
-
-	go func() {
-		<-done
-		close(done)
-		l.Close()
-		closed <- struct{}{}
-	}()
-
-	return signal, nil
-}
-
-func handleSocks(conn net.Conn) {
-	target, err := socks.Handshake(conn)
-	if err != nil {
-		conn.Close()
-		return
-	}
-	conn.(*net.TCPConn).SetKeepAlive(true)
-	tun.Add(adapters.NewSocks(target, conn))
-}

proxy/socks/udp.go

@@ -1 +0,0 @@
-package socks

rules/domain_keyword.go

@@ -1,39 +0,0 @@
-package rules
-
-import (
-	"strings"
-
-	C "github.com/Dreamacro/clash/constant"
-)
-
-type DomainKeyword struct {
-	keyword string
-	adapter string
-}
-
-func (dk *DomainKeyword) RuleType() C.RuleType {
-	return C.DomainKeyword
-}
-
-func (dk *DomainKeyword) IsMatch(addr *C.Addr) bool {
-	if addr.AddrType != C.AtypDomainName {
-		return false
-	}
-	domain := addr.Host
-	return strings.Contains(domain, dk.keyword)
-}
-
-func (dk *DomainKeyword) Adapter() string {
-	return dk.adapter
-}
-
-func (dk *DomainKeyword) Payload() string {
-	return dk.keyword
-}
-
-func NewDomainKeyword(keyword string, adapter string) *DomainKeyword {
-	return &DomainKeyword{
-		keyword: keyword,
-		adapter: adapter,
-	}
-}

rules/domain_suffix.go

@@ -1,39 +0,0 @@
-package rules
-
-import (
-	"strings"
-
-	C "github.com/Dreamacro/clash/constant"
-)
-
-type DomainSuffix struct {
-	suffix  string
-	adapter string
-}
-
-func (ds *DomainSuffix) RuleType() C.RuleType {
-	return C.DomainSuffix
-}
-
-func (ds *DomainSuffix) IsMatch(addr *C.Addr) bool {
-	if addr.AddrType != C.AtypDomainName {
-		return false
-	}
-	domain := addr.Host
-	return strings.HasSuffix(domain, "."+ds.suffix) || domain == ds.suffix
-}
-
-func (ds *DomainSuffix) Adapter() string {
-	return ds.adapter
-}
-
-func (ds *DomainSuffix) Payload() string {
-	return ds.suffix
-}
-
-func NewDomainSuffix(suffix string, adapter string) *DomainSuffix {
-	return &DomainSuffix{
-		suffix:  suffix,
-		adapter: adapter,
-	}
-}

rules/final.go

@@ -1,31 +0,0 @@
-package rules
-
-import (
-	C "github.com/Dreamacro/clash/constant"
-)
-
-type Final struct {
-	adapter string
-}
-
-func (f *Final) RuleType() C.RuleType {
-	return C.FINAL
-}
-
-func (f *Final) IsMatch(addr *C.Addr) bool {
-	return true
-}
-
-func (f *Final) Adapter() string {
-	return f.adapter
-}
-
-func (f *Final) Payload() string {
-	return ""
-}
-
-func NewFinal(adapter string) *Final {
-	return &Final{
-		adapter: adapter,
-	}
-}

rules/geoip.go

@@ -1,54 +0,0 @@
-package rules
-
-import (
-	"sync"
-
-	C "github.com/Dreamacro/clash/constant"
-
-	"github.com/oschwald/geoip2-golang"
-	log "github.com/sirupsen/logrus"
-)
-
-var (
-	mmdb *geoip2.Reader
-	once sync.Once
-)
-
-type GEOIP struct {
-	country string
-	adapter string
-}
-
-func (g *GEOIP) RuleType() C.RuleType {
-	return C.GEOIP
-}
-
-func (g *GEOIP) IsMatch(addr *C.Addr) bool {
-	if addr.IP == nil {
-		return false
-	}
-	record, _ := mmdb.Country(*addr.IP)
-	return record.Country.IsoCode == g.country
-}
-
-func (g *GEOIP) Adapter() string {
-	return g.adapter
-}
-
-func (g *GEOIP) Payload() string {
-	return g.country
-}
-
-func NewGEOIP(country string, adapter string) *GEOIP {
-	once.Do(func() {
-		var err error
-		mmdb, err = geoip2.Open(C.MMDBPath)
-		if err != nil {
-			log.Fatalf("Can't load mmdb: %s", err.Error())
-		}
-	})
-	return &GEOIP{
-		country: country,
-		adapter: adapter,
-	}
-}

rules/ipcidr.go

@@ -1,42 +0,0 @@
-package rules
-
-import (
-	"net"
-
-	C "github.com/Dreamacro/clash/constant"
-)
-
-type IPCIDR struct {
-	ipnet   *net.IPNet
-	adapter string
-}
-
-func (i *IPCIDR) RuleType() C.RuleType {
-	return C.IPCIDR
-}
-
-func (i *IPCIDR) IsMatch(addr *C.Addr) bool {
-	if addr.IP == nil {
-		return false
-	}
-
-	return i.ipnet.Contains(*addr.IP)
-}
-
-func (i *IPCIDR) Adapter() string {
-	return i.adapter
-}
-
-func (i *IPCIDR) Payload() string {
-	return i.ipnet.String()
-}
-
-func NewIPCIDR(s string, adapter string) *IPCIDR {
-	_, ipnet, err := net.ParseCIDR(s)
-	if err != nil {
-	}
-	return &IPCIDR{
-		ipnet:   ipnet,
-		adapter: adapter,
-	}
-}

tunnel/connection.go

@@ -1,29 +0,0 @@
-package tunnel
-
-import (
-	"io"
-
-	"github.com/Dreamacro/clash/adapters/local"
-	C "github.com/Dreamacro/clash/constant"
-)
-
-func (t *Tunnel) handleHTTP(request *adapters.HTTPAdapter, proxy C.ProxyAdapter) {
-	conn := newTrafficTrack(proxy.Conn(), t.traffic)
-
-	// Before we unwrap src and/or dst, copy any buffered data.
-	if wc, ok := request.Conn().(*adapters.PeekedConn); ok && len(wc.Peeked) > 0 {
-		if _, err := conn.Write(wc.Peeked); err != nil {
-			return
-		}
-		wc.Peeked = nil
-	}
-
-	go io.Copy(request.Conn(), conn)
-	io.Copy(conn, request.Conn())
-}
-
-func (t *Tunnel) handleSOCKS(request *adapters.SocksAdapter, proxy C.ProxyAdapter) {
-	conn := newTrafficTrack(proxy.Conn(), t.traffic)
-	go io.Copy(request.Conn(), conn)
-	io.Copy(conn, request.Conn())
-}

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/tunnel.go

@@ -1,161 +0,0 @@
-package tunnel
-
-import (
-	"sync"
-	"time"
-
-	LocalAdapter "github.com/Dreamacro/clash/adapters/local"
-	cfg "github.com/Dreamacro/clash/config"
-	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/observable"
-
-	"gopkg.in/eapache/channels.v1"
-)
-
-var (
-	tunnel *Tunnel
-	once   sync.Once
-)
-
-// Tunnel handle proxy socket and HTTP/SOCKS socket
-type Tunnel struct {
-	queue      *channels.InfiniteChannel
-	rules      []C.Rule
-	proxies    map[string]C.Proxy
-	configLock *sync.RWMutex
-	traffic    *C.Traffic
-
-	// Outbound Rule
-	mode cfg.Mode
-
-	// Log
-	logCh      chan interface{}
-	observable *observable.Observable
-	logLevel   C.LogLevel
-}
-
-// Add request to queue
-func (t *Tunnel) Add(req C.ServerAdapter) {
-	t.queue.In() <- req
-}
-
-// Traffic return traffic of all connections
-func (t *Tunnel) Traffic() *C.Traffic {
-	return t.traffic
-}
-
-// Log return clash log stream
-func (t *Tunnel) Log() *observable.Observable {
-	return t.observable
-}
-
-func (t *Tunnel) configMonitor(signal chan<- struct{}) {
-	sub := cfg.Instance().Subscribe()
-	signal <- struct{}{}
-	for elm := range sub {
-		event := elm.(*cfg.Event)
-		switch event.Type {
-		case "proxies":
-			proxies := event.Payload.(map[string]C.Proxy)
-			t.configLock.Lock()
-			t.proxies = proxies
-			t.configLock.Unlock()
-		case "rules":
-			rules := event.Payload.([]C.Rule)
-			t.configLock.Lock()
-			t.rules = rules
-			t.configLock.Unlock()
-		case "mode":
-			t.mode = event.Payload.(cfg.Mode)
-		case "log-level":
-			t.logLevel = event.Payload.(C.LogLevel)
-		}
-	}
-}
-
-func (t *Tunnel) process() {
-	queue := t.queue.Out()
-	for {
-		elm := <-queue
-		conn := elm.(C.ServerAdapter)
-		go t.handleConn(conn)
-	}
-}
-
-func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
-	defer localConn.Close()
-	addr := localConn.Addr()
-
-	var proxy C.Proxy
-	switch t.mode {
-	case cfg.Direct:
-		proxy = t.proxies["DIRECT"]
-	case cfg.Global:
-		proxy = t.proxies["GLOBAL"]
-	// Rule
-	default:
-		proxy = t.match(addr)
-	}
-	remoConn, err := proxy.Generator(addr)
-	if err != nil {
-		t.logCh <- newLog(C.WARNING, "Proxy connect error: %s", err.Error())
-		return
-	}
-	defer remoConn.Close()
-
-	switch adapter := localConn.(type) {
-	case *LocalAdapter.HTTPAdapter:
-		t.handleHTTP(adapter, remoConn)
-	case *LocalAdapter.SocksAdapter:
-		t.handleSOCKS(adapter, remoConn)
-	}
-}
-
-func (t *Tunnel) match(addr *C.Addr) C.Proxy {
-	t.configLock.RLock()
-	defer t.configLock.RUnlock()
-
-	for _, rule := range t.rules {
-		if rule.IsMatch(addr) {
-			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())
-			return a
-		}
-	}
-	t.logCh <- newLog(C.INFO, "%v doesn't match any rule using DIRECT", addr.String())
-	return t.proxies["DIRECT"]
-}
-
-// 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,
-		logLevel:   C.INFO,
-	}
-}
-
-// Instance return singleton instance of Tunnel
-func Instance() *Tunnel {
-	once.Do(func() {
-		tunnel = newTunnel()
-	})
-	return tunnel
-}

tunnel/util.go

@@ -1,29 +0,0 @@
-package tunnel
-
-import (
-	"net"
-
-	C "github.com/Dreamacro/clash/constant"
-)
-
-// TrafficTrack record traffic of net.Conn
-type TrafficTrack struct {
-	net.Conn
-	traffic *C.Traffic
-}
-
-func (tt *TrafficTrack) Read(b []byte) (int, error) {
-	n, err := tt.Conn.Read(b)
-	tt.traffic.Down() <- int64(n)
-	return n, err
-}
-
-func (tt *TrafficTrack) Write(b []byte) (int, error) {
-	n, err := tt.Conn.Write(b)
-	tt.traffic.Up() <- int64(n)
-	return n, err
-}
-
-func newTrafficTrack(conn net.Conn, traffic *C.Traffic) *TrafficTrack {
-	return &TrafficTrack{traffic: traffic, Conn: conn}
-}