Fix CI

upstream dns port

.github/Dockerfile

@@ -0,0 +1,17 @@
+# Compile
+FROM golang:1.13-alpine AS compiler
+
+RUN apk add --no-cache git make
+
+# enable go modules
+WORKDIR /src
+COPY . .
+
+RUN CGO_ENABLED=0 make build
+
+
+# Build image
+FROM scratch
+
+COPY --from=compiler /src/sower /sower
+ENTRYPOINT [ "/sower" ]

.github/workflows/go.yml

@@ -0,0 +1,53 @@
+name: Go
+on:
+  push:
+    tags:
+      - "v*.*.*"
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/setup-go@v2-beta
+      - uses: actions/checkout@v2
+
+      - name: build matrix
+        run: |
+          cp conf/sower.toml sower.toml
+
+          GOOS=linux GOARCH=amd64 make build
+          tar czvf sower-linux-amd64.tar.gz sower sower.toml
+          GOOS=linux GOARCH=386 make build
+          tar czvf sower-linux-386.tar.gz sower sower.toml
+          GOOS=linux GOARCH=arm make build
+          tar czvf sower-linux-arm.tar.gz sower sower.toml
+          GOOS=linux GOARCH=arm64 make build
+          tar czvf sower-linux-arm64.tar.gz sower sower.toml
+          GOOS=linux GOARCH=mips make build
+          tar czvf sower-linux-mips.tar.gz sower sower.toml
+          GOOS=linux GOARCH=mipsle make build
+          tar czvf sower-linux-mipsle.tar.gz sower sower.toml
+
+          GOOS=darwin GOARCH=amd64 make build
+          tar czvf sower-darwin-amd64.tar.gz sower sower.toml
+
+          GOOS=windows GOARCH=amd64 make build
+          tar czvf sower-windows-amd64.tar.gz sower.exe sower.toml
+          GOOS=windows GOARCH=386 make build
+          tar czvf sower-windows-386.tar.gz sower.exe sower.toml
+
+      - name: Release
+        uses: softprops/action-gh-release@master
+        with:
+          files: |
+            sower-linux-amd64.tar.gz
+            sower-linux-386.tar.gz
+            sower-linux-arm.tar.gz
+            sower-linux-arm64.tar.gz
+            sower-linux-mips.tar.gz
+            sower-linux-mipsle.tar.gz
+            sower-darwin-amd64.tar.gz
+            sower-windows-amd64.tar.gz
+            sower-windows-386.tar.gz
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -12,11 +12,11 @@
 *.out
 
 .DS_Store
-**/.DS_Store
+._*
+*.swp
+*.swo
 .vscode
 .idea
 sower
-cert.pem
-**/cert.pem
-privkey.pem
-**/privkey.pem
+sower.exe*
+/sower.toml

Makefile

@@ -1,19 +1,12 @@
-SERVER:=127.0.0.1:5533
-
-default: build
+default: test build
 
+test:
+	go vet ./...
+	go list ./... | grep -v internal | xargs go test
 build:
-	GOBIN=$(PWD) go install -v
+	go build -ldflags "-w -s \
+		-X conf.version=$(shell git describe --tags --always) \
+		-X conf.date=$(shell date +%Y-%m-%d)"
+image:
+	docker build -t sower -f .github/Dockerfile .
 
-kill:
-	sudo pkill -9 sower || true
-
-client: build kill
-	sudo $(PWD)/sower -f conf/sower.toml -logtostderr
-
-server: build kill
-	$(PWD)/sower -logtostderr -v 1
-
-run: build kill
-	$(PWD)/sower -logtostderr -v 1 &
-	sudo $(PWD)/sower -f conf/sower.toml -logtostderr

README.md

@@ -1,48 +1,87 @@
 # sower
-Yet another cross platform transparent proxy tool
+[![GitHub release](http://img.shields.io/github/release/wweir/sower.svg?style=popout)](https://github.com/wweir/sower/releases)
+[![Actions Status](https://github.com/wweir/sower/workflows/Go/badge.svg)](https://github.com/wweir/sower/actions)
+[![Docker Cloud Build Status](https://img.shields.io/docker/cloud/build/wweir/sower.svg?style=popout)](https://hub.docker.com/r/wweir/sower)
+[![GitHub issue](https://img.shields.io/github/issues/wweir/sower.svg?style=popout)](https://github.com/wweir/sower/issues)
+[![GitHub star](https://img.shields.io/github/stars/wweir/sower.svg?style=popout)](https://github.com/wweir/sower/stargazers)
+[![GitHub license](https://img.shields.io/github/license/wweir/sower.svg?style=popout)](LICENSE)
 
-## architecture
-```
-          request target servers
-<-------------+              +------------->
-              |              |
-              |              |
-      +------------server-------------+
-      |       | relay service|        |
-      | +-----+---------------------+ |
-      | |                           | |
-      | | parsr http(s) target url  | |
-      | |                           | |
-      | +---------------------------+ |
-      |                               |
-      +--------^----------------------+
-               |           request domain server
-       quic connection          +---------->
-               |                |
-      +--------+---client+------+-----+
-      |                  |            |
-      |                  |            |
-      |  relay service   |     dns    |
-      |                  |    server  |
-      |                  |            |
-      |       127.0.0.1 or other      |
-      |                  |            |
-      +-------^----------+---^----^---+
-              |              |    |
-              |              |    |   +----->
-              |   +----------+    |   |
-              2   1               1   2
-              +   +               +   +
-          block request       normal request
 
+中文介绍见 [Wiki](https://github.com/wweir/sower/wiki)
+
+The sower is a cross-platform intelligent transparent proxy tool.
+
+The first time you visit a new website, the sower will detect if the domain is accessible and add it in the dynamic detect list. So, you do not need to care about the rules, sower will handle it intelligently.
+
+Sower provider both http_proxy/https_proxy and DNS-based proxy. All these kinds of proxy support intelligent router. You can also port-forward any TCP request to remote, such as SSH / SMTP / POP3.
+
+You can enjoy it by setting http_proxy or your DNS without any other settings.
+
+If you already have another proxy solution, you can use it's socks5(h) service as a parent proxy to enjoy the sower's intelligent router.
+
+
+## Installation
+To enjoy the sower, you need to deploy sower on both server-side and client-side.
+
+The installation script has been integrated into the sower. You can install sower as system service by running `./sower -install 'xxx'`
+
+## Server
+*If you already have another proxy solution with socks5h support, you can skip server-side.*
+
+At the server-side, the sower runs just like a web server proxy.
+It redirects HTTP requests to HTTPS and proxy https requests to the upstream HTTP service.
+You can use your certificate or use the auto-generated certificate by the sower.
+
+What you must set is the upstream HTTP service. You can set it by parameter `-s`, eg:
+``` shell
+# sower -s 127.0.0.1:8080
 ```
 
-## install
-1. install server on `server node` by `make server`
-2. write config file, example: [conf/sower.toml](https://github.com/wweir/sower/blob/master/conf/sower.toml)
-3. install client on `client node` by `make client`
-4. add `127.0.0.1` as you first domain server
+## Client
+The easiest way to run it is:
+``` shell
+# sower -c aa.bb.cc # the `aa.bb.cc` can also be `socks5h://127.0.0.1:1080`
+```
+But a configuration file is recommended to persist dynamic rules in client side.
 
-## todo
-- [ ] authenticate
-- [ ] broker
+There are 3 kinds of proxy solutions, they are HTTP(S)_PROXY / DNS-based proxy / port-forward.
+
+### HTTP(S)_PROXY
+An HTTP(S)_PROXY listening on `:8080` is set by default if you run sower as client mode.
+
+### DNS-based proxy
+You can set the `serve_ip` field in the `dns` section in the configuration file to start the DNS-based proxy. You should also set the value of `serve_ip` as your default DNS in OS.
+
+If you want to enjoy the full experience provided by the sower, you can take sower as your private DNS on a long-running server and set it as your default DNS in your router.
+
+### port-forward
+The port-forward can be only setted in configuration file, you can set it in section `client.router.port_mapping`, eg:
+``` toml
+[client.router.port_mapping]
+":2222"="aa.bb.cc:22"
+```
+
+
+## Architecture
+```
+  relay   <--+       +-> target
+http service |       |   service
+     +-------+-------+----+
+     |    sower server    |
+     +----^-------^-------+
+          80     443
+301 http -+       +----- https
+to https          |     service
+               protected
+                by tls
+          socks5  |
+ dns <---+   ^    |  +--> direct
+relay    |   |    |  |   request
+     +---+---+----+--+----+
+     |    sower client    |
+     +----^--^----^---^---+
+          |  |    |   |
+    dns --+  +    +   +-- port
+            80  http(s)  forward
+           443  proxy
+```

conf/conf.go

@@ -2,80 +2,171 @@ package conf
 
 import (
 	"flag"
-	"net"
-	"strconv"
+	"os"
+	"sync"
+	"time"
 
-	"github.com/BurntSushi/toml"
-	"github.com/golang/glog"
-	"github.com/wweir/fsnotify"
+	toml "github.com/pelletier/go-toml"
+	"github.com/wweir/sower/util"
+	"github.com/wweir/utils/log"
 )
 
-var Conf = struct {
-	ConfigFile  string
-	ServerPort  string   `toml:"server_port"`
-	ServerAddr  string   `toml:"server_addr"`
-	DnsServer   string   `toml:"dns_server"`
-	ClientIP    string   `toml:"client_ip"`
-	ClientIPNet net.IP   `toml:"-"`
-	BlockList   []string `toml:"blocklist"`
-	Verbose     int      `toml:"verbose"`
-}{}
+type client struct {
+	Address string `toml:"address"`
+
+	HTTPProxy struct {
+		Address string `toml:"address"`
+	} `toml:"http_proxy"`
+
+	DNS struct {
+		ServeIP  string `toml:"serve_ip"`
+		Upstream string `toml:"upstream"`
+		FlushCmd string `toml:"flush_cmd"`
+	} `toml:"dns"`
+
+	Router struct {
+		PortMapping   map[string]string `toml:"port_mapping"`
+		DetectLevel   int               `toml:"detect_level"`
+		DetectTimeout string            `toml:"detect_timeout"`
+
+		ProxyList    []string `toml:"proxy_list"`
+		DirectList   []string `toml:"direct_list"`
+		DynamicList  []string `toml:"dynamic_list"`
+		directRules  *util.Node
+		proxyRules   *util.Node
+		dynamicRules *util.Node
+	} `toml:"router"`
+}
+type server struct {
+	Upstream  string `toml:"upstream"`
+	CertFile  string `toml:"cert_file"`
+	KeyFile   string `toml:"key_file"`
+	CertEmail string `toml:"cert_email"`
+}
+
+var (
+	version, date string
+
+	flushOnce = sync.Once{}
+	flushMu   = sync.Mutex{}
+	flushCh   = make(chan struct{})
+
+	Server = server{}
+	Client = client{}
+	conf   = struct {
+		file   string
+		Server *server `toml:"server"`
+		Client *client `toml:"client"`
+	}{"", &Server, &Client}
+	Password      string
+	installCmd    string
+	uninstallFlag bool
+)
 
 func init() {
-	flag.StringVar(&Conf.ConfigFile, "f", "", "config file location")
-	flag.StringVar(&Conf.ServerPort, "P", "5533", "server mode listen port")
-	flag.StringVar(&Conf.ServerAddr, "s", "", "server IP (run in client mode if set)")
-	flag.StringVar(&Conf.DnsServer, "d", "114.114.114.114", "client dns server")
-	flag.StringVar(&Conf.ClientIP, "c", "127.0.0.1", "client dns service redirect IP")
+	flag.StringVar(&Password, "password", "", "password")
+	flag.StringVar(&Server.Upstream, "s", "", "upstream http service, eg: 127.0.0.1:8080")
+	flag.StringVar(&Server.CertFile, "s_cert", "", "tls cert file, gen cert from letsencrypt if empty")
+	flag.StringVar(&Server.KeyFile, "s_key", "", "tls key file, gen cert from letsencrypt if empty")
+	flag.StringVar(&Client.Address, "c", "", "remote server domain, eg: aa.bb.cc, socks5h://127.0.0.1:1080")
+	flag.StringVar(&Client.HTTPProxy.Address, "http_proxy", ":8080", "http proxy, empty to disable")
+	flag.StringVar(&Client.DNS.ServeIP, "dns_ip", "", "upstream dns, eg: 127.0.0.1, disable dns proxy if empty")
+	flag.StringVar(&Client.DNS.Upstream, "dns_upstream", "", "dns relay server ip, dynamic detect if empty")
+	flag.IntVar(&Client.Router.DetectLevel, "level", 2, "dynamic rule detect level: 0~4")
+	flag.StringVar(&Client.Router.DetectTimeout, "timeout", "300ms", "dynamic rule detect timeout")
+	flag.BoolVar(&uninstallFlag, "uninstall", false, "uninstall service")
+	Init() // execute platform init logic
 
 	if !flag.Parsed() {
 		flag.Parse()
 	}
+	if uninstallFlag {
+		uninstall()
+		os.Exit(0)
+	}
+	if installCmd != "" {
+		install()
+		os.Exit(0)
+	}
 
-	if Conf.ConfigFile == "" {
+	var err error
+	defer func() {
+		if timeout, err = time.ParseDuration(Client.Router.DetectTimeout); err != nil {
+			log.Fatalw("parse dynamic detect timeout", "val", Client.Router.DetectTimeout, "err", err)
+		}
+
+		log.Infow("start", "version", version, "date", date, "conf", &conf)
+		passwordData = []byte(Password)
+	}()
+
+	if conf.file == "" {
 		return
 	}
-	if err := OnRefreash[0](); err != nil {
-		panic(err)
+
+	for i := range loadConfigFns {
+		if err = loadConfigFns[i].fn(); err != nil {
+			log.Fatalw("load config", "config", conf.file, "step", loadConfigFns[i].step, "err", err)
+		}
 	}
-	watchConfigFile()
 }
 
-var OnRefreash = []func() error{func() error {
-	if _, err := toml.DecodeFile(Conf.ConfigFile, &Conf); err != nil {
+// refreshFns will be executed while init and write new config
+var loadConfigFns = []struct {
+	step string
+	fn   func() error
+}{{"load_config", func() error {
+	f, err := os.OpenFile(conf.file, os.O_RDONLY, 0644)
+	if err != nil {
 		return err
 	}
-	Conf.ClientIPNet = net.ParseIP(Conf.ClientIP)
-	// for glog
-	if err := flag.Set("v", strconv.Itoa(Conf.Verbose)); err != nil {
-		return err
+	defer f.Close()
+
+	return toml.NewDecoder(f).Decode(&conf)
+
+}}, {"load_rules", func() error {
+	Client.Router.directRules = util.NewNodeFromRules(Client.Router.DirectList...)
+	Client.Router.proxyRules = util.NewNodeFromRules(Client.Router.ProxyList...)
+	Client.Router.dynamicRules = util.NewNodeFromRules(Client.Router.DynamicList...)
+	return nil
+
+}}, {"flush_dns", func() error {
+	if Client.DNS.FlushCmd != "" {
+		return execute(Client.DNS.FlushCmd)
 	}
 	return nil
-}}
+}}}
 
-// watchConfigFile changes, fsnotify take too much cpu time, DIY
-func watchConfigFile() {
-	watcher, err := fsnotify.NewWatcher()
-	if err != nil {
-		glog.Fatalln(err)
-	}
-	if err := watcher.Add(Conf.ConfigFile); err != nil {
-		glog.Fatalln(err)
-	}
+func flushConf() {
+	for range flushCh {
+		// safe write
+		if conf.file != "" {
+			f, err := os.OpenFile(conf.file+"~", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
+			if err != nil {
+				log.Errorw("flush config", "step", "flush", "err", err)
+				continue
+			}
 
-	go func() {
-		for {
-			select {
-			case event := <-watcher.Events:
-				glog.Infof("watch %s event: %v", Conf.ConfigFile, event)
-				for i := range OnRefreash {
-					if err := OnRefreash[i](); err != nil {
-						glog.Errorln(err)
-					}
-				}
-			case err := <-watcher.Errors:
-				glog.Fatalln(err)
+			flushMu.Lock()
+			if err := toml.NewEncoder(f).ArraysWithOneElementPerLine(true).Encode(conf); err != nil {
+				log.Errorw("flush config", "step", "flush", "err", err)
+				flushMu.Unlock()
+				f.Close()
+				continue
+			}
+			flushMu.Unlock()
+			f.Close()
+
+			if err = os.Rename(conf.file+"~", conf.file); err != nil {
+				log.Errorw("flush config", "step", "flush", "err", err)
+				continue
 			}
 		}
-	}()
+
+		// reload config
+		for i := range loadConfigFns {
+			if err := loadConfigFns[i].fn(); err != nil {
+				log.Errorw("flush config", "step", loadConfigFns[i].step, "err", err)
+			}
+		}
+	}
 }

conf/conf_darwin.go

@@ -0,0 +1,73 @@
+// +build darwin
+
+package conf
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"time"
+
+	"github.com/wweir/utils/log"
+)
+
+const svcPath = "/Library/LaunchDaemons/sower.plist"
+const svcFile = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>sower</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/bin/sh</string>
+    <string>-c</string>
+    <string>%s %s</string>
+  </array>
+  <key>KeepAlive</key>
+  <true/>
+  <key>RunAtLoad</key>
+  <true/>
+</dict>
+</plist>`
+
+func Init() {
+	flag.StringVar(&conf.file, "f", "", "config file, rewrite all other parameters if set")
+	flag.StringVar(&Client.DNS.FlushCmd, "flush_dns", "pkill mDNSResponder || true", "flush dns command")
+	flag.StringVar(&installCmd, "install", "", "install service with cmd, eg: '-f /etc/sower/sower.toml'")
+}
+
+func install() {
+	execFile, err := filepath.Abs(os.Args[0])
+	if err != nil {
+		log.Fatalw("get binary path", "err", err)
+	}
+
+	if err := ioutil.WriteFile(svcPath, []byte(fmt.Sprintf(svcFile, execFile, installCmd)), 0644); err != nil {
+		log.Fatalw("write service file", "err", err)
+	}
+
+	execute("launchctl unload " + svcPath)
+	if err := execute("launchctl load -w " + svcPath); err != nil {
+		log.Fatalw("install service", "err", err)
+	}
+}
+func uninstall() {
+	execute("launchctl unload " + svcPath)
+	os.Remove(svcPath)
+	os.RemoveAll("/etc/sower")
+}
+func execute(cmd string) error {
+	ctx, cancel := context.WithTimeout(context.TODO(), 5*time.Second)
+	defer cancel()
+
+	out, err := exec.CommandContext(ctx, "sh", "-c", cmd).CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("cmd: %s, err: %s, output: %s", cmd, err, out)
+	}
+	return nil
+}

conf/conf_linux.go

@@ -0,0 +1,73 @@
+// +build linux
+
+package conf
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"time"
+
+	"github.com/wweir/utils/log"
+)
+
+const svcPath = "/etc/systemd/system/sower.service"
+const svcFile = `[Unit]
+Description=Sower client service
+After=network.target
+
+[Install]
+WantedBy=multi-user.target
+
+[Service]
+Type=simple
+User=root
+WorkingDirectory=/tmp
+ExecStart=%s %s
+RestartSec=3
+Restart=on-failure`
+
+func Init() {
+	flag.StringVar(&conf.file, "f", "", "config file, rewrite all other parameters if set")
+	flag.StringVar(&Client.DNS.FlushCmd, "flush_dns", "", "flush dns command")
+	flag.StringVar(&installCmd, "install", "", "install service with cmd, eg: '-f /etc/sower/sower.toml'")
+}
+func install() {
+	execFile, err := filepath.Abs(os.Args[0])
+	if err != nil {
+		log.Fatalw("get binary path", "err", err)
+	}
+
+	if err := ioutil.WriteFile(svcPath, []byte(fmt.Sprintf(svcFile, execFile, installCmd)), 0644); err != nil {
+		log.Fatalw("write service file", "err", err)
+	}
+	if err := execute("systemctl daemon-reload"); err != nil {
+		log.Fatalw("install service", "err", err)
+	}
+	if err := execute("systemctl enable sower"); err != nil {
+		log.Fatalw("install service", "err", err)
+	}
+	if err := execute("systemctl start sower"); err != nil {
+		log.Fatalw("install service", "err", err)
+	}
+}
+func uninstall() {
+	execute("systemctl stop sower")
+	execute("systemctl disable sower")
+	os.Remove(svcPath)
+	os.RemoveAll("/etc/sower")
+}
+func execute(cmd string) error {
+	ctx, cancel := context.WithTimeout(context.TODO(), 5*time.Second)
+	defer cancel()
+
+	out, err := exec.CommandContext(ctx, "sh", "-c", cmd).CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("cmd: %s, err: %s, output: %s", cmd, err, out)
+	}
+	return nil
+}

conf/conf_windows.go

@@ -0,0 +1,174 @@
+// +build windows
+
+package conf
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/wweir/utils/log"
+	"golang.org/x/sys/windows"
+	"golang.org/x/sys/windows/svc"
+	"golang.org/x/sys/windows/svc/eventlog"
+	"golang.org/x/sys/windows/svc/mgr"
+)
+
+const name = "sower"
+const cmdsAccepted = svc.AcceptStop | svc.AcceptShutdown | svc.AcceptPauseAndContinue
+
+var execFile, _ = filepath.Abs(os.Args[0])
+var execDir, _ = filepath.Abs(filepath.Dir(execFile))
+
+func Init() {
+	flag.StringVar(&conf.file, "f", filepath.Join(execDir, "sower.toml"), "config file, rewrite all other parameters if set")
+	flag.StringVar(&installCmd, "install", "", "install service with cmd")
+	flag.StringVar(&Client.DNS.FlushCmd, "flush_dns", "ipconfig /flushdnss", "flush dns command")
+	flag.Parse()
+
+	switch {
+	case installCmd != "":
+	case uninstallFlag:
+	default:
+		os.Chdir(filepath.Dir(os.Args[0]))
+		if active, err := svc.IsAnInteractiveSession(); err != nil {
+			log.Fatalf("failed to determine if we are running in an interactive session: %v", err)
+		} else if !active {
+			go func() {
+				elog, err := eventlog.Open(name)
+				if err != nil {
+					log.Fatalw("install service", "err", err)
+				}
+				defer elog.Close()
+
+				if err := svc.Run(name, &myservice{}); err != nil {
+					elog.Error(1, fmt.Sprintf("%s service failed: %v", name, err))
+					log.Fatalw("install service", "err", err)
+				}
+				elog.Info(1, fmt.Sprintf("winsvc.RunAsService: %s service stopped", name))
+				os.Exit(0)
+			}()
+		}
+	}
+}
+func install() {
+	mgrDo(func(m *mgr.Mgr) error {
+		s, err := m.OpenService(name)
+		if err == nil {
+			s.Close()
+			return fmt.Errorf("service %s already exists", name)
+		}
+		s, err = m.CreateService(name, execFile, mgr.Config{
+			DisplayName: "Sower Proxy",
+			StartType:   windows.SERVICE_AUTO_START,
+		})
+		if err != nil {
+			return err
+		}
+		defer s.Close()
+		err = eventlog.InstallAsEventCreate(name, eventlog.Error|eventlog.Warning|eventlog.Info)
+		if err != nil {
+			s.Delete()
+			return fmt.Errorf("SetupEventLogSource() failed: %s", err)
+		}
+
+		return s.Start()
+	})
+}
+func uninstall() {
+	serviceDo(func(s *mgr.Service) error {
+		err := s.Delete()
+		if err != nil {
+			return err
+		}
+		return eventlog.Remove(name)
+	})
+}
+func serviceDo(fn func(*mgr.Service) error) {
+	mgrDo(func(m *mgr.Mgr) error {
+		s, err := m.OpenService(name)
+		if err != nil {
+			return fmt.Errorf("could not access service: %v", err)
+		}
+		defer s.Close()
+		return fn(s)
+	})
+}
+func mgrDo(fn func(m *mgr.Mgr) error) {
+	m, err := mgr.Connect()
+	if err != nil {
+		log.Fatalw("install service", "err", err)
+	}
+	defer m.Disconnect()
+
+	if err := fn(m); err != nil {
+		log.Fatalw("install service", "err", err)
+	}
+}
+
+type myservice struct{}
+
+func (m *myservice) Execute(args []string, r <-chan svc.ChangeRequest, changes chan<- svc.Status) (ssec bool, errno uint32) {
+	elog, err := eventlog.Open(name)
+	if err != nil {
+		log.Errorw("install service", "err", err)
+		return
+	}
+	defer elog.Close()
+	elog.Info(1, strings.Join(args, "-"))
+
+	changes <- svc.Status{State: svc.StartPending}
+	changes <- svc.Status{State: svc.Running, Accepts: cmdsAccepted}
+	for {
+		c := <-r
+		switch c.Cmd {
+		case svc.Interrogate:
+			changes <- c.CurrentStatus
+			// Testing deadlock from https://code.google.com/p/winsvc/issues/detail?id=4
+			time.Sleep(100 * time.Millisecond)
+			changes <- c.CurrentStatus
+		case svc.Stop, svc.Shutdown:
+			changes <- svc.Status{State: svc.StopPending}
+			return
+		case svc.Pause:
+			changes <- svc.Status{State: svc.Paused, Accepts: cmdsAccepted}
+		case svc.Continue:
+			changes <- svc.Status{State: svc.Running, Accepts: cmdsAccepted}
+		default:
+			elog.Error(1, fmt.Sprintf("unexpected control request #%d", c))
+		}
+	}
+}
+
+func execute(cmd string) error {
+	ctx, cancel := context.WithTimeout(context.TODO(), 5*time.Second)
+	defer cancel()
+
+	var cmds []string
+	for _, cmd := range strings.Split(Client.DNS.FlushCmd, " ") {
+		if cmd == "" {
+			continue
+		}
+		if strings.HasPrefix(cmd, "/") {
+			cmd = strings.Replace(cmd, "/", "-", 1)
+		}
+		cmds = append(cmds, cmd)
+	}
+
+	if len(cmds) != 0 {
+		return nil
+	}
+
+	command := exec.CommandContext(ctx, cmds[0], cmds[1:]...)
+	command.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}
+	if out, err := command.CombinedOutput(); err != nil {
+		return fmt.Errorf("cmd: %s, output: %s, err: %w", Client.DNS.FlushCmd, out, err)
+	}
+	return nil
+}

conf/dynamic_rule.go

@@ -0,0 +1,142 @@
+package conf
+
+import (
+	"crypto/tls"
+	"net"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/wweir/sower/internal/http"
+	"github.com/wweir/sower/internal/socks5"
+	"github.com/wweir/sower/util"
+	"github.com/wweir/utils/log"
+	"github.com/wweir/utils/mem"
+)
+
+type dynamic struct {
+	port http.Port
+}
+
+var cache = mem.New(2 * time.Hour)
+var detect = &dynamic{}
+var passwordData []byte
+var timeout time.Duration
+
+// ShouldProxy check if the domain shoule request though proxy
+func ShouldProxy(domain string) bool {
+	if domain == Client.Address {
+		return true
+	}
+	if Client.Router.directRules.Match(domain) {
+		return false
+	}
+	if Client.Router.proxyRules.Match(domain) {
+		return true
+	}
+	if Client.Router.dynamicRules.Match(domain) {
+		return true
+	}
+
+	cache.Remember(detect, domain)
+	return Client.Router.dynamicRules.Match(domain)
+}
+
+func (d *dynamic) Get(key interface{}) (err error) {
+	// break deadloop, for ugly wildcard setting dns setting
+	domain := strings.TrimSuffix(key.(string), ".")
+	if strings.Count(domain, ".") > 10 {
+		return nil
+	}
+
+	wg := sync.WaitGroup{}
+	httpScore, httpsScore := new(int32), new(int32)
+	for _, ping := range [...]dynamic{{port: http.HTTP}, {port: http.HTTPS}} {
+		wg.Add(1)
+		go func(ping dynamic) {
+			defer wg.Done()
+
+			if err := ping.port.Ping(domain, timeout); err != nil {
+				return
+			}
+
+			switch ping.port {
+			case http.HTTP:
+				if !atomic.CompareAndSwapInt32(httpScore, 0, 2) {
+					atomic.AddInt32(httpScore, 1)
+				}
+			case http.HTTPS:
+				if !atomic.CompareAndSwapInt32(httpsScore, 0, 2) {
+					atomic.AddInt32(httpScore, 1)
+				}
+			}
+		}(ping)
+	}
+	for _, ping := range [...]dynamic{{port: http.HTTP}, {port: http.HTTPS}} {
+		wg.Add(1)
+		go func(ping dynamic) {
+			defer wg.Done()
+
+			var conn net.Conn
+			if addr, ok := socks5.IsSocks5Schema(Client.Address); ok {
+				conn, err = net.Dial("tcp", addr)
+				conn = socks5.ToSocks5(conn, domain, uint16(ping.port))
+
+			} else {
+				conn, err = tls.Dial("tcp", net.JoinHostPort(Client.Address, "443"), &tls.Config{})
+				if ping.port == http.HTTP {
+					conn = http.NewTgtConn(conn, passwordData, http.TGT_HTTP, "", 80)
+				} else {
+					conn = http.NewTgtConn(conn, passwordData, http.TGT_HTTPS, "", 443)
+				}
+			}
+			if err != nil {
+				log.Errorw("sower dial", "addr", Client.Address, "err", err)
+				return
+			}
+
+			if err := ping.port.PingWithConn(domain, conn, timeout); err != nil {
+				return
+			}
+
+			switch ping.port {
+			case http.HTTP:
+				if !atomic.CompareAndSwapInt32(httpScore, 0, -2) {
+					atomic.AddInt32(httpScore, -1)
+				}
+			case http.HTTPS:
+				if !atomic.CompareAndSwapInt32(httpsScore, 0, -2) {
+					atomic.AddInt32(httpScore, -1)
+				}
+			}
+		}(ping)
+	}
+
+	wg.Wait()
+	if int(*httpScore+*httpsScore)+conf.Client.Router.DetectLevel < 0 {
+		addDynamic(domain)
+		log.Infow("add rule", "domain", domain, "http_score", *httpScore, "https_score", *httpsScore)
+	}
+	return nil
+}
+
+// addDynamic add new domain into dynamic list
+func addDynamic(domain string) {
+	flushMu.Lock()
+	Client.Router.DynamicList = util.NewReverseSecSlice(
+		append(Client.Router.DynamicList, domain)).Sort().Uniq()
+	Client.Router.dynamicRules = util.NewNodeFromRules(Client.Router.DynamicList...)
+	flushMu.Unlock()
+
+	flushOnce.Do(func() {
+		if conf.file != "" {
+			go flushConf()
+		}
+	})
+
+	select {
+	case flushCh <- struct{}{}:
+	default:
+	}
+}

conf/sower.toml

@@ -1,70 +1,57 @@
-server_port="5533"
-server_addr="127.0.0.1:5533" # replce it to server "IP"
-server_addr="remote-server:5533" # replce it to remote server
-dns_server="114.114.114.114"
-# client_ip="192.168.0.1"
-blocklist=[
-    "*.google.com", # google
-    "ocsp.pki.goog",
-    "g.co",
-    "*.goo.gl",
-    "*.googleusercontent.com",
-    "*.googleapis.com",
-    "gmail.com",
-    "*.youtube.com", # youtube
-    "*.ytimg.com",
-    "*.ggpht.com",
-    "*.googlevideo.com",
-    "*.vimeo.com",
-    "*.facebook.com", # facebook
-    "*.xx.fbcdn.net",
-    "connect.facebook.net",
-    "*.twitter.com", # twitter
-    "t.co",
-    "*.twimg.com",
-    "www.linkedin.com",
-    "www.reddit.com", # reddit
-    "www.redditmedia.com",
-    "*.blogspot.com", # blogspot
-    "www.blogger.com",
-    "www.feedburner.com",
-    "img1.blogblog.com",
-    "*.aws.amazon.com", # amazon
-    "m.media-amazon.com",
-    "*.awsstatic.com",
-	"*.cloudfront.net", # atlassian
-    "*.medium.com",
-    "accounts-static.cdn.mozilla.net", # firefox
-    "*.services.mozilla.com",
-    "pocket-image-cache.com", # pocket
-    "*.golang.org", # golang
-    "go.googlesource.com",
-    "godoc.org",
-    "gist.github.com", # github
-    "*.k8s.io", # k8s
-    "k8s.gcr.io",
-    "*.wikipedia.org", # wikipeida
-    "*.wikimedia.org",
-    "*.wikisource.org",
-    "lookup-api.apple.com",
-    "lookup-api.apple.com.edgekey.net",
-    "e16991.b.akamaiedge.net",
-    "*.web.telegram.org", # telegram
-    "core.telegram.org",
-    "telegram.me",
-    "t.me",
-    "*.slack.com", #slack
-    "*.slack-edge.com",
-    "js.driftt.com",
-    "cloud.feedly.com", # feedly
-    "static.grammarly.com", # grammarly
-    "apkpure.com", # apkpure
-    "download.apkpure.com",
-    "*.nytimes.com", # New York times
-    "*.nyt.com",
-    "bandwagonhost.com", # bandwagonhost
-    "www.bwh1.net",
-    "*.akadns.net", # suggestions
-    "*.haxx.se",
-]
-verbose=1
+[client]
+  address = "" # aa.bb.cc, socks5h://127.0.0.1:1080
+
+  [client.dns]
+    flush_cmd="" # macOS: pkill mDNSResponder || true, Windows: ipconfig /flushdnss
+    serve_ip = "127.0.0.1"
+    upstream = "" # empty to dynamic detect
+
+  [client.http_proxy]
+    address = ":8080" # empty to disable http_proxy
+
+  [client.router]
+    detect_level = 2 # 0~4, the bigger the harder to add
+    detect_timeout = "300ms"
+    direct_list = [
+      "**.in-addr.arpa",
+      "imap.*.*",
+      "imap.*.*.*",
+      "smtp.*.*",
+      "smtp.*.*.*",
+      "pop.*.*",
+      "pop.*.*.*",
+      "**.cn",
+    ]
+    dynamic_list = []
+    proxy_list = [
+      "**.google.*",
+      "**.goo.gl",
+      "**.googleusercontent.com",
+      "**.googleapis.com",
+      "*.googlesource.com",
+      "**.youtube.com",
+      "**.ytimg.com",
+      "**.ggpht.com",
+      "**.googlevideo.com",
+      "**.facebook.com",
+      "**.fbcdn.net",
+      "**.twitter.com",
+      "**.twimg.com",
+      "**.blogspot.com",
+      "**.appspot.com",
+      "**.wikipedia.org",
+      "*.cloudfront.net",
+      "**.amazon.com",
+      "**.amazonaws.com",
+      "*.githubusercontent.com",
+      "*.github.*",
+    ]
+
+    [client.router.port_mapping]
+      # ":2222"="aa.bb.cc:22"
+
+[server]
+  cert_email = "" # eg: user@aa.bb.cc
+  cert_file = "" # eg: /etc/ssl/server.crt
+  key_file = "" # eg: /etc/ssl/server.key
+  upstream = "" # eg: 127.0.0.1:8080

dns/dns.go

@@ -1,104 +0,0 @@
-package dns
-
-import (
-	"net"
-	"strings"
-	"time"
-
-	"github.com/golang/glog"
-	"github.com/miekg/dns"
-	"github.com/wweir/sower/conf"
-)
-
-func StartDNS(dnsServer string) {
-	dns.HandleFunc(".", func(w dns.ResponseWriter, r *dns.Msg) {
-		// *Msg r has an TSIG record and it was validated
-		if r.IsTsig() != nil && w.TsigStatus() == nil {
-			r.SetTsig(r.Extra[len(r.Extra)-1].(*dns.TSIG).Hdr.Name, dns.HmacMD5, 300, time.Now().Unix())
-		}
-
-		//https://stackoverflow.com/questions/4082081/requesting-a-and-aaaa-records-in-single-dns-query/4083071#4083071
-		if len(r.Question) == 0 {
-			return
-		}
-
-		if len(conf.Conf.BlockList) == 0 {
-			bestTry(w, r, r.Question[0].Name, dnsServer)
-		} else {
-			manual(w, r, r.Question[0].Name, dnsServer)
-		}
-	})
-
-	server := &dns.Server{Addr: ":53", Net: "udp"}
-	glog.Fatalln(server.ListenAndServe())
-}
-
-func bestTry(w dns.ResponseWriter, r *dns.Msg, domain, dnsServer string) {
-	msg, _ := dns.Exchange(r, dnsServer+":53")
-	if msg == nil {
-		return
-	}
-	if len(msg.Answer) == 0 { // expose any response
-		w.WriteMsg(msg)
-		return
-	}
-
-	var ip string
-	switch msg.Answer[0].(type) {
-	case *dns.A:
-		ip = msg.Answer[0].(*dns.A).A.String()
-	case *dns.AAAA:
-		ip = "[" + msg.Answer[0].(*dns.AAAA).AAAA.String() + "]"
-	default:
-		w.WriteMsg(msg)
-		return
-	}
-
-	if _, err := net.DialTimeout("tcp", ip+":http", time.Second); err != nil {
-		glog.V(2).Infoln(ip+":80", err)
-		w.WriteMsg(localA(r, domain))
-		return
-	}
-	w.WriteMsg(msg)
-}
-
-func manual(w dns.ResponseWriter, r *dns.Msg, domain, dnsServer string) {
-	if rule.Match(strings.TrimSuffix(domain, ".")) {
-		glog.V(2).Infof("match %s suss", domain)
-		w.WriteMsg(localA(r, domain))
-		return
-	}
-
-	msg, _ := dns.Exchange(r, dnsServer+":53") // expose any response
-	if msg == nil {
-		glog.V(1).Infof("get dns of %s fail", domain)
-		return
-	}
-	w.WriteMsg(msg)
-
-	if conf.Conf.Verbose != 0 && len(msg.Answer) != 0 {
-		go func() {
-			_, err := net.DialTimeout("tcp", domain+":http", 2*time.Second)
-			if err == nil || !strings.Contains(err.Error(), "timeout") {
-				return
-			}
-
-			_, err = net.DialTimeout("tcp", domain+":https", 3*time.Second)
-			if err == nil || !strings.Contains(err.Error(), "timeout") {
-				return
-			}
-
-			glog.V(1).Infof("SUGGEST check (%s) http(s) service: %s", domain, err)
-		}()
-	}
-}
-
-func localA(r *dns.Msg, domain string) *dns.Msg {
-	m := new(dns.Msg)
-	m.SetReply(r)
-	m.Answer = []dns.RR{&dns.A{
-		Hdr: dns.RR_Header{Name: domain, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 20},
-		A:   conf.Conf.ClientIPNet,
-	}}
-	return m
-}

dns/suffixTree.go

@@ -1,65 +0,0 @@
-package dns
-
-import (
-	"strings"
-)
-
-type Node struct {
-	Node map[string]*Node
-}
-
-func NewNode() *Node {
-	return &Node{Node: map[string]*Node{}}
-}
-func NewNodeFromRule(rules ...string) *Node {
-	node := NewNode()
-	for i := range rules {
-		node.Add(strings.Split(rules[i], "."))
-	}
-	return node
-}
-
-func (n *Node) String() string {
-	return n.string("")
-}
-func (n *Node) string(prefix string) (out string) {
-	for key, val := range n.Node {
-		out += prefix + key + "\n" + val.string(prefix+"    ")
-	}
-	return
-}
-
-func (n *Node) Add(secs []string) {
-	length := len(secs)
-	switch length {
-	case 0:
-		return
-	case 1:
-		n.Node[secs[length-1]] = NewNode()
-	default:
-		subNode, ok := n.Node[secs[length-1]]
-		if !ok {
-			subNode = NewNode()
-			n.Node[secs[length-1]] = subNode
-		}
-		subNode.Add(secs[:length-1])
-	}
-}
-
-func (n *Node) Match(addr string) bool {
-	return n.matchSecs(strings.Split(addr, "."))
-}
-
-func (n *Node) matchSecs(secs []string) bool {
-	length := len(secs)
-	if length == 0 {
-		return len(n.Node) == 0
-	}
-
-	if n, ok := n.Node[secs[length-1]]; ok {
-		return n.matchSecs(secs[:length-1])
-	}
-
-	_, ok := n.Node["*"]
-	return ok
-}

dns/util.go

@@ -1,19 +0,0 @@
-package dns
-
-import (
-	"github.com/golang/glog"
-	"github.com/wweir/sower/conf"
-)
-
-var rule *Node
-
-func init() {
-	rule = NewNodeFromRule(conf.Conf.BlockList...)
-	glog.V(2).Infof("block rule:\n%s", rule)
-
-	conf.OnRefreash = append(conf.OnRefreash, func() error {
-		rule = NewNodeFromRule(conf.Conf.BlockList...)
-		glog.V(2).Infof("block rule:\n%s", rule)
-		return nil
-	})
-}

go.mod

@@ -1,21 +1,14 @@
 module github.com/wweir/sower
 
+go 1.13
+
 require (
-	github.com/BurntSushi/toml v0.3.1
-	github.com/bifurcation/mint v0.0.0-20181105071958-a14404e9a861 // indirect
-	github.com/cheekybits/genny v1.0.0 // indirect
-	github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b
-	github.com/golang/mock v1.1.1 // indirect
-	github.com/hashicorp/golang-lru v0.5.0 // indirect
-	github.com/lucas-clemente/aes12 v0.0.0-20171027163421-cd47fb39b79f // indirect
-	github.com/lucas-clemente/quic-go v0.10.0
-	github.com/lucas-clemente/quic-go-certificates v0.0.0-20160823095156-d2f86524cced // indirect
-	github.com/miekg/dns v1.1.1
-	github.com/onsi/ginkgo v1.7.0 // indirect
-	github.com/onsi/gomega v1.4.3 // indirect
-	github.com/wweir/fsnotify v1.4.8
-	golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9 // indirect
-	golang.org/x/net v0.0.0-20181201002055-351d144fa1fc // indirect
-	golang.org/x/sync v0.0.0-20181108010431-42b317875d0f // indirect
-	golang.org/x/sys v0.0.0-20181128092732-4ed8d59d0b35 // indirect
+	github.com/krolaw/dhcp4 v0.0.0-20190909130307-a50d88189771
+	github.com/libp2p/go-reuseport v0.0.1
+	github.com/miekg/dns v1.1.27
+	github.com/pelletier/go-toml v1.6.0
+	github.com/pkg/errors v0.9.1
+	github.com/wweir/utils v0.0.0-20200214114658-f6f356a08736
+	golang.org/x/crypto v0.0.0-20200214034016-1d94cc7ab1c6
+	golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4
 )

go.sum

@@ -1,54 +1,100 @@
 github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/bifurcation/mint v0.0.0-20181105071958-a14404e9a861 h1:x17NvoJaphEzay72TFej4OSSsgu3xRYBLkbIwdofS/4=
-github.com/bifurcation/mint v0.0.0-20181105071958-a14404e9a861/go.mod h1:zVt7zX3K/aDCk9Tj+VM7YymsX66ERvzCJzw8rFCX2JU=
-github.com/cheekybits/genny v1.0.0 h1:uGGa4nei+j20rOSeDeP5Of12XVm7TGUd4dJA9RDitfE=
-github.com/cheekybits/genny v1.0.0/go.mod h1:+tQajlRqAUrPI7DOSpB0XAqZYtQakVtB7wXkRAgjxjQ=
-github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
-github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=
-github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
-github.com/golang/mock v1.1.1 h1:G5FRp8JnTd7RQH5kemVNlMeyXQAztQ3mOWV95KxsXH8=
-github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/hashicorp/golang-lru v0.5.0 h1:CL2msUPvZTLb5O648aiLNJw3hnBxN2+1Jq8rCOH9wdo=
-github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
-github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
-github.com/lucas-clemente/aes12 v0.0.0-20171027163421-cd47fb39b79f h1:sSeNEkJrs+0F9TUau0CgWTTNEwF23HST3Eq0A+QIx+A=
-github.com/lucas-clemente/aes12 v0.0.0-20171027163421-cd47fb39b79f/go.mod h1:JpH9J1c9oX6otFSgdUHwUBUizmKlrMjxWnIAjff4m04=
-github.com/lucas-clemente/quic-go v0.10.0 h1:xEF+pSHYAOcu+U10Meunf+DTtc8vhQDRqlA0BJ6hufc=
-github.com/lucas-clemente/quic-go v0.10.0/go.mod h1:wuD+2XqEx8G9jtwx5ou2BEYBsE+whgQmlj0Vz/77PrY=
-github.com/lucas-clemente/quic-go-certificates v0.0.0-20160823095156-d2f86524cced h1:zqEC1GJZFbGZA0tRyNZqRjep92K5fujFtFsu5ZW7Aug=
-github.com/lucas-clemente/quic-go-certificates v0.0.0-20160823095156-d2f86524cced/go.mod h1:NCcRLrOTZbzhZvixZLlERbJtDtYsmMw8Jc4vS8Z0g58=
-github.com/miekg/dns v1.1.1 h1:DVkblRdiScEnEr0LR9nTnEQqHYycjkXW9bOjd+2EL2o=
-github.com/miekg/dns v1.1.1/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
-github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.7.0 h1:WSHQ+IS43OoUrWtD1/bbclrwK8TTH5hzp+umCiuxHgs=
-github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/gomega v1.4.3 h1:RE1xgDvH7imwFD45h+u2SgIfERHlS2yNG4DObb5BSKU=
-github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
-github.com/wweir/fsnotify v1.4.8 h1:zxOoqwE5p91F3rmcYLQheoSeTlIVqwi2b5T7UlpElWE=
-github.com/wweir/fsnotify v1.4.8/go.mod h1:4GuxIc23DXfJI1/LhBXG5eE/wJ4CzL+kk5M7woxVprc=
-golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9 h1:mKdxBk7AujPs8kU4m80U72y/zjbZ3UcXC7dClwKbUI0=
-golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20181201002055-351d144fa1fc h1:a3CU5tJYVj92DY2LaA1kUkrsqD5/3mLDhx2NcNqyW+0=
-golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f h1:Bl/8QSvNqXvPGPGXa2z5xUTmV7VDcZyvRZ+QQXkXTZQ=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181128092732-4ed8d59d0b35 h1:YAFjXN64LMvktoUZH9zgY4lGc/msGN7HQfoSuKCgaDU=
-golang.org/x/sys v0.0.0-20181128092732-4ed8d59d0b35/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+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/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
+github.com/go-sql-driver/mysql v1.4.1/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
+github.com/guregu/null v3.4.0+incompatible h1:a4mw37gBO7ypcBlTJeZGuMpSxxFTV9qFfFKgWxQSGaM=
+github.com/guregu/null v3.4.0+incompatible/go.mod h1:ePGpQaN9cw0tj45IR5E5ehMvsFlLlQZAkkOXZurJ3NM=
+github.com/influxdata/influxdb v1.7.9/go.mod h1:qZna6X/4elxqT3yI9iZYdZrWWdeFOOprn86kgg4+IzY=
+github.com/jmoiron/sqlx v1.2.0/go.mod h1:1FEQNm3xlJgrMD+FBdI9+xvCksHtbpVBBw5dYhBSsks=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/krolaw/dhcp4 v0.0.0-20190909130307-a50d88189771 h1:t2c2B9g1ZVhMYduqmANSEGVD3/1WlsrEYNPtVoFlENk=
+github.com/krolaw/dhcp4 v0.0.0-20190909130307-a50d88189771/go.mod h1:0AqAH3ZogsCrvrtUpvc6EtVKbc3w6xwZhkvGLuqyi3o=
+github.com/lib/pq v1.0.0 h1:X5PMW56eZitiTeO7tKzZxFCSpbFZJtkMMooicw2us9A=
+github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
+github.com/libp2p/go-reuseport v0.0.1 h1:7PhkfH73VXfPJYKQ6JwS5I/eVcoyYi9IMNGc6FWpFLw=
+github.com/libp2p/go-reuseport v0.0.1/go.mod h1:jn6RmB1ufnQwl0Q1f+YxAj8isJgDCQzaaxIFYDhcYEA=
+github.com/mattn/go-sqlite3 v1.9.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
+github.com/miekg/dns v1.1.27 h1:aEH/kqUzUxGJ/UHcEKdJY+ugH6WEzsEBBSPa8zuy1aM=
+github.com/miekg/dns v1.1.27/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
+github.com/pelletier/go-toml v1.6.0 h1:aetoXYr0Tv7xRU/V4B4IZJ2QcbtMUFoNb3ORp7TzIK4=
+github.com/pelletier/go-toml v1.6.0/go.mod h1:5N711Q9dKgbdkxHL+MEfF31hpT7l0S0s/t2kKREewys=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+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/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/satori/go.uuid v1.2.0 h1:0uYX9dsZ2yD7q2RtLRtPSdGDWzjeM3TbMJP9utgA0ww=
+github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/ulule/deepcopier v0.0.0-20171107155558-ca99b135e50f h1:QatZ4lsJBY3x1+Imst9g95+vUl7m52dqM9Pi4aSMW8w=
+github.com/ulule/deepcopier v0.0.0-20171107155558-ca99b135e50f/go.mod h1:BNLmYJ8oMJPIPpNx5968jCyUhwEU1XT3YsuOqtbo5qo=
+github.com/wweir/utils v0.0.0-20200214114658-f6f356a08736 h1:x6LiUrnHR4CCqzRzB0zqiB9hzVFcRhSKrVlZDGW0FcM=
+github.com/wweir/utils v0.0.0-20200214114658-f6f356a08736/go.mod h1:Nv4eBGkUJiHDPgVowJJlQNcJYgMfst6IkjaDThH2/yI=
+go.uber.org/atomic v1.5.0 h1:OI5t8sDa1Or+q8AeE+yKeB/SDYioSHAgcVljj9JIETY=
+go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
+go.uber.org/multierr v1.3.0 h1:sFPn2GLc3poCkfrpIXGhBD2X0CMIo4Q/zSULXrj/+uc=
+go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4=
+go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee h1:0mgffUl7nfd+FpvXMVz4IDEaUSmT1ysygQC7qYo7sG4=
+go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=
+go.uber.org/zap v1.13.0 h1:nR6NoDBgAf67s68NhaXbsojM+2gxp3S1hWkHDl27pVU=
+go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200214034016-1d94cc7ab1c6 h1:Sy5bstxEqwwbYs6n0/pBuxKENqOeZUgD45Gp3Q3pqLg=
+golang.org/x/crypto v0.0.0-20200214034016-1d94cc7ab1c6/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de h1:5hukYrvBGR8/eNkX5mdUezrA6JiaEZDtJb9Ei+1LlBs=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190923162816-aa69164e4478 h1:l5EDrHhldLYb3ZRHDUhXF7Om7MvYXnkV9/iQNo1lX6g=
+golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58 h1:8gQV6CLnAEikrhgkHFbMAEhagSSnXWGV915qUMm9mrU=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190228124157-a34e9553db1e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4 h1:sfkvUWPNGwSV+8/fNqctR5lS2AqCSqYwXdrjCxp/dXo=
+golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191216052735-49a3e744a425 h1:VvQyQJN0tSuecqgcIxMWnnfG5kSmgy9KZR9sW3W5QeA=
+golang.org/x/tools v0.0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
-gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
-gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
-gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
-gopkg.in/yaml.v2 v2.2.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE=
-gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4 h1:/eiJrUcujPVeJ3xlSWaiNi3uSVmDGBK1pDHUHAnao1I=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+honnef.co/go/tools v0.0.1-2019.2.3 h1:3JgtbtFHMiCmsznwGVTUWbgGov+pVqnlf1dEJTNAXeM=
+honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=

internal/http/http_ping.go

@@ -0,0 +1,128 @@
+package http
+
+import (
+	"bytes"
+	"crypto/tls"
+	"encoding/binary"
+	"io"
+	"net"
+	"strconv"
+	"time"
+)
+
+// Port ==========================
+type Port uint16
+
+const HTTP Port = 80
+const HTTPS Port = 443
+
+// Ping try connect to a http(s) server with domain though the http addr
+func (p Port) Ping(domain string, timeout time.Duration) error {
+	conn, err := net.DialTimeout("tcp", net.JoinHostPort(domain, p.String()), timeout)
+	if err != nil {
+		return err
+	}
+	defer conn.Close()
+
+	return p.PingWithConn(domain, conn, timeout)
+}
+
+// PingWithConn try connect to a http(s) server with domain though the http addr
+func (p Port) PingWithConn(domain string, conn net.Conn, timeout time.Duration) error {
+	conn.SetDeadline(time.Now().Add(timeout))
+	if _, err := conn.Write(p.PingMsg(domain)); err != nil {
+		return err
+	}
+
+	// err -> nil:		read something succ
+	// err -> io.EOF:	no such domain or connection refused
+	// err -> timeout:	tcp package has been dropped
+	_, err := conn.Read(make([]byte, 1))
+	if err == nil || err == io.EOF {
+		return nil
+	}
+	return err
+}
+
+func (p Port) String() string {
+	return strconv.Itoa(int(p))
+}
+
+func (p Port) PingMsg(domain string) []byte {
+	switch p {
+	case HTTP:
+		return []byte("TRACE / HTTP/1.1\r\nHost: " + domain + "\r\n\r\n")
+	case HTTPS:
+		return NewClientHelloSNIMsg(domain)
+	default:
+		panic("invalid port")
+	}
+}
+
+// SNI ==========================
+type clientHelloSNI struct {
+	ContentType uint8
+	Version     uint16
+	Length      uint16
+	handshakeProtocol
+}
+type handshakeProtocol struct {
+	HandshakeType            uint8
+	LengthExpand             uint8
+	Length                   uint16
+	Version                  uint16
+	Random                   [32]byte
+	SessionIDLength          uint8
+	CipherSuitesLength       uint16
+	CipherSuite              uint16
+	CompressionMethodsLength uint8
+	CompressionMethod        uint8
+	ExtensionsLength         uint16
+	extensionServerName
+}
+type extensionServerName struct {
+	Type   uint16
+	Length uint16
+	serverNameIndicationExtension
+}
+type serverNameIndicationExtension struct {
+	ServerNameListlength uint16
+	ServerNameType       uint8
+	ServerNamelength     uint16
+	// ServerName        []byte // Disable for fix length
+}
+
+func NewClientHelloSNIMsg(domain string) []byte {
+	length := uint16(len(domain))
+	msg := &clientHelloSNI{
+		ContentType: 0x16,   // Content Type: Handshake (22)
+		Version:     0x0301, // Version: TLS 1.0 (0x0301)
+		Length:      length + 56,
+		handshakeProtocol: handshakeProtocol{
+			HandshakeType:            0x01, // Handshake Type: Client Hello (1)
+			Length:                   length + 52,
+			Version:                  0x0303,     // Version: TLS 1.2 (0x0303)
+			Random:                   [32]byte{}, // [32]byte{},
+			SessionIDLength:          0x0,        // Session ID Length: 0
+			CipherSuitesLength:       2,          // Cipher Suites Length: 84
+			CipherSuite:              tls.TLS_RSA_WITH_AES_128_GCM_SHA256,
+			CompressionMethodsLength: 1,    // Compression Methods Length: 1
+			CompressionMethod:        0x00, // Compression null
+			ExtensionsLength:         length + 9,
+			extensionServerName: extensionServerName{
+				Type:   0x0000, // Type: server_name (0)
+				Length: length + 5,
+				serverNameIndicationExtension: serverNameIndicationExtension{
+					ServerNameListlength: length + 3,
+					ServerNameType:       0x00, // Server Name Type: host_name (0)
+					ServerNamelength:     length,
+				},
+			},
+		},
+	}
+
+	buf := bytes.NewBuffer(make([]byte, 0, length+61))
+	binary.Write(buf, binary.BigEndian, msg)
+	buf.WriteString(domain)
+	return buf.Bytes()
+}

internal/http/tgt_parser.go

@@ -0,0 +1,142 @@
+package http
+
+import (
+	"bufio"
+	"crypto/md5"
+	"encoding/binary"
+	"errors"
+	"io"
+	"net"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"github.com/wweir/sower/util"
+)
+
+const (
+	TGT_OTHER byte = iota
+	TGT_HTTP
+	TGT_HTTPS
+)
+
+// Write Addr
+type conn struct {
+	typ      byte
+	password []byte
+	domain   []byte
+	port     uint16
+	init     bool
+	net.Conn
+}
+
+func NewTgtConn(c net.Conn, password []byte, tgtType byte, domain string, port uint16) net.Conn {
+	return &conn{
+		typ:      tgtType,
+		password: password,
+		domain:   []byte(domain),
+		port:     port,
+		init:     true,
+		Conn:     c,
+	}
+}
+
+// other => type + checksum + port + domain_length ++ domain + data
+// http  => type + checksum ++ data
+// https => type + checksum + port ++ data
+type header struct {
+	Type         byte
+	Checksum     byte
+	Port         uint16
+	DomainLength uint8
+}
+
+func (c *conn) Write(b []byte) (n int, err error) {
+	if c.init {
+		c.init = false
+		domainLength := byte(len(c.domain))
+		if err := binary.Write(c.Conn, binary.BigEndian, &header{
+			Type:         c.typ,
+			Checksum:     checksum(c.password, c.port, domainLength),
+			Port:         c.port,
+			DomainLength: domainLength,
+		}); err != nil {
+			return 0, err
+		}
+
+		n, err := c.Conn.Write(append(c.domain, b...))
+		return n - len(c.domain), err
+	}
+
+	return c.Conn.Write(b)
+}
+
+// ParseAddr parse target addr from net.Conn
+func ParseAddr(conn net.Conn, password []byte) (_ net.Conn, domain string, port uint16, err error) {
+	teeConn := &util.TeeConn{Conn: conn}
+	teeConn.StartOrReset()
+	defer teeConn.Stop()
+
+	head := new(header)
+	if err = binary.Read(conn, binary.BigEndian, head); err != nil {
+		return teeConn, "", 0, nil
+	}
+	if head.Checksum != checksum(password, head.Port, head.DomainLength) {
+		return teeConn, "", 0, nil
+	}
+
+	switch head.Type {
+	case TGT_OTHER:
+		buf := make([]byte, int(head.DomainLength))
+		if _, err = io.ReadFull(conn, buf); err != nil {
+			return teeConn, "", 0, err
+		}
+
+		return teeConn, string(buf), head.Port, nil
+
+	case TGT_HTTP:
+		teeConn.DropAndRestart()
+		return ParseHTTP(teeConn)
+
+	case TGT_HTTPS:
+		teeConn.DropAndRestart()
+		conn, domain, err = ParseHTTPS(teeConn)
+		return conn, domain, head.Port, err
+
+	default:
+		return teeConn, "", 0, errors.New("invalid request")
+	}
+}
+func ParseHTTP(teeConn net.Conn) (_ net.Conn, domain string, port uint16, err error) {
+	resp, err := http.ReadRequest(bufio.NewReader(teeConn))
+	if err != nil {
+		return teeConn, "", 0, err
+	}
+
+	idx := strings.LastIndex(resp.Host, ":")
+	if idx == -1 {
+		return teeConn, resp.Host, 80, nil
+	}
+
+	p, err := strconv.ParseUint(resp.Host[idx+1:], 10, 16)
+	if err != nil {
+		return teeConn, "", 0, err
+	}
+	return teeConn, resp.Host[:idx], uint16(p), nil
+}
+func ParseHTTPS(teeConn net.Conn) (_ net.Conn, domain string, err error) {
+	if domain, _, err = extractSNI(teeConn); err != nil {
+		return nil, "", err
+	}
+	return teeConn, domain, nil
+}
+
+var errChecksum = errors.New("invalid checksum")
+
+func checksum(password []byte, port uint16, length uint8) (val byte) {
+	nums := md5.Sum(append(password, byte(port), length))
+	for _, b := range nums {
+		val += b
+	}
+	return val
+}

internal/http/tgt_parser_test.go

@@ -0,0 +1,66 @@
+package http
+
+import (
+	"bufio"
+	"bytes"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"testing"
+)
+
+func TestParseAddr1(t *testing.T) {
+	c1, c2 := net.Pipe()
+
+	go func() {
+		c1 = NewTgtConn(c1, nil, TGT_HTTP, "", 0)
+		req, _ := http.NewRequest("GET", "http://wweir.cc", bytes.NewReader([]byte{1, 2, 3}))
+		req.Write(c1)
+	}()
+
+	c2, host, port, err := ParseAddr(c2, nil)
+
+	if err != nil || host != "wweir.cc" || port != 80 {
+		t.Error(err, host, port)
+	}
+
+	req, err := http.ReadRequest(bufio.NewReader(c2))
+	if err != nil {
+		t.Error(err)
+	}
+
+	data, err := ioutil.ReadAll(req.Body)
+	if err != nil || len(data) != 3 || data[0] != 1 {
+		t.Error(err, data)
+	}
+}
+
+func TestParseAddr2(t *testing.T) {
+	c1, c2 := net.Pipe()
+
+	go func() {
+		c1 = NewTgtConn(c1, nil, TGT_HTTPS, "", 443)
+		c1.Write(HTTPS.PingMsg("wweir.cc"))
+	}()
+
+	_, host, port, err := ParseAddr(c2, nil)
+
+	if err != nil || host != "wweir.cc" || port != 443 {
+		t.Error(err, host, port)
+	}
+}
+
+func TestParseAddr3(t *testing.T) {
+	c1, c2 := net.Pipe()
+
+	go func() {
+		c1 = NewTgtConn(c1, nil, TGT_OTHER, "wweir.cc", 1080)
+		c1.Write(HTTPS.PingMsg("wweir.cc"))
+	}()
+
+	_, host, port, err := ParseAddr(c2, nil)
+
+	if err != nil || host != "wweir.cc" || port != 1080 {
+		t.Error(err, host, port)
+	}
+}

internal/http/tgt_sni.go

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package parser
+package http
 
 import (
 	"encoding/binary"

internal/net/dhcp.go

@@ -0,0 +1,59 @@
+package net
+
+import (
+	"math/rand"
+	"net"
+	"runtime"
+	"time"
+
+	"github.com/krolaw/dhcp4"
+	"github.com/libp2p/go-reuseport"
+	"github.com/pkg/errors"
+)
+
+var xid = make([]byte, 4)
+var broadcastAddr, _ = net.ResolveUDPAddr("udp", "255.255.255.255:67")
+
+func GetDefaultDNSServer() (string, error) {
+	iface, err := PickInternetInterface()
+	if err != nil {
+		return "", errors.Wrap(err, "pick interface")
+	}
+
+	rand.Read(xid)
+	pack := dhcp4.RequestPacket(dhcp4.Discover, iface.HardwareAddr, net.IPv4(0, 0, 0, 0), xid, true, []dhcp4.Option{
+		{Code: dhcp4.OptionRequestedIPAddress, Value: []byte(iface.IP.To4())},
+		{Code: dhcp4.End},
+	})
+
+	var conn net.PacketConn
+	if runtime.GOOS == "windows" {
+		if conn, err = reuseport.ListenPacket("udp4", iface.IP.String()+":68"); err != nil {
+			return "", errors.Wrap(err, "listen dhcp")
+		}
+	} else {
+		if conn, err = reuseport.ListenPacket("udp4", "0.0.0.0:68"); err != nil {
+			return "", errors.Wrap(err, "listen dhcp")
+		}
+	}
+	defer conn.Close()
+	conn.SetDeadline(time.Now().Add(3 * time.Second))
+
+	if _, err := conn.WriteTo([]byte(pack), broadcastAddr); err != nil {
+		return "", errors.Wrap(err, "write broadcast")
+	}
+
+	buf := make([]byte, 1500 /*MTU*/)
+	n, _, err := conn.ReadFrom(buf)
+	if err != nil {
+		return "", errors.Wrap(err, "read dhcp offer")
+	}
+
+	pack = dhcp4.Packet(buf[:n])
+	dnsBytes := pack.ParseOptions()[dhcp4.OptionDomainNameServer]
+	if len(dnsBytes) < 4 {
+		return "", errors.New("no DNS setting in upstream network device")
+	}
+
+	return net.IPv4(dnsBytes[0], dnsBytes[1], dnsBytes[2], dnsBytes[3]).String(), nil
+}

internal/net/dhcp_test.go

@@ -0,0 +1,15 @@
+package net_test
+
+import (
+	"fmt"
+
+	"github.com/wweir/sower/internal/net"
+)
+
+func Example_dns() {
+	got, err := net.GetDefaultDNSServer()
+	if err != nil {
+		panic(err)
+	}
+	fmt.Println(got)
+}

internal/net/pick_iface_other.go

@@ -0,0 +1,30 @@
+// +build !windows
+
+package net
+
+import (
+	"errors"
+	"net"
+)
+
+// PickInternetInterface pick the first active net interface
+func PickInternetInterface() (*Iface, error) {
+	ifaces, err := net.Interfaces()
+	if err != nil {
+		return nil, err
+	}
+
+	for i := range ifaces {
+		if len(ifaces[i].HardwareAddr) == 0 {
+			continue
+		}
+
+		addrs, _ := ifaces[i].Addrs()
+		for _, addr := range addrs {
+			if ip := addr.(*net.IPNet).IP.To4(); ip != nil {
+				return &Iface{ifaces[i].HardwareAddr, ip}, nil
+			}
+		}
+	}
+	return nil, errors.New("no valid interface")
+}

internal/net/pick_iface_test.go

@@ -0,0 +1,15 @@
+package net_test
+
+import (
+	"fmt"
+
+	"github.com/wweir/sower/internal/net"
+)
+
+func Example_iface() {
+	got, err := net.PickInternetInterface()
+	if err != nil {
+		panic(err)
+	}
+	fmt.Println(got)
+}

internal/net/pick_iface_windows.go

@@ -0,0 +1,51 @@
+// +build windows
+
+package net
+
+import (
+	"bytes"
+	"errors"
+	"net"
+	"os"
+	"syscall"
+	"unsafe"
+)
+
+// PickInternetInterface pick the first active net interface
+func PickInternetInterface() (*Iface, error) {
+	list, err := getAdapterList()
+	if err != nil {
+		return nil, err
+	}
+	for {
+		if list.DhcpEnabled == 1 && list.LeaseObtained != 0 {
+			ip := bytes.TrimRight(list.IpAddressList.IpAddress.String[:], string([]byte{0}))
+			return &Iface{net.HardwareAddr(list.Address[:list.AddressLength]), net.ParseIP(string(ip))}, nil
+		}
+
+		if list.Next != nil {
+			list = list.Next
+		} else {
+			return nil, errors.New("no valid interface")
+		}
+	}
+}
+
+func getAdapterList() (*syscall.IpAdapterInfo, error) {
+	b := make([]byte, 1000)
+	l := uint32(len(b))
+	a := (*syscall.IpAdapterInfo)(unsafe.Pointer(&b[0]))
+	// TODO(mikio): GetAdaptersInfo returns IP_ADAPTER_INFO that
+	// contains IPv4 address list only. We should use another API
+	// for fetching IPv6 stuff from the kernel.
+	err := syscall.GetAdaptersInfo(a, &l)
+	if err == syscall.ERROR_BUFFER_OVERFLOW {
+		b = make([]byte, l)
+		a = (*syscall.IpAdapterInfo)(unsafe.Pointer(&b[0]))
+		err = syscall.GetAdaptersInfo(a, &l)
+	}
+	if err != nil {
+		return nil, os.NewSyscallError("GetAdaptersInfo", err)
+	}
+	return a, nil
+}

internal/net/util.go

@@ -0,0 +1,9 @@
+package net
+
+import "net"
+
+// Iface is net interface address info
+type Iface struct {
+	net.HardwareAddr
+	net.IP
+}

internal/socks5/rfc_def.go

@@ -0,0 +1,44 @@
+package socks5
+
+// https://tools.ietf.org/html/rfc1928
+
+type authReq struct {
+	VER      byte
+	NMETHODS byte
+	METHODS  [1]byte // 1 to 255, fix to no authentication
+}
+
+type authResp struct {
+	VER    byte
+	METHOD byte
+}
+
+type request struct {
+	req
+	DST_ADDR []byte // first byte is length
+	DST_PORT []byte // two bytes
+}
+type req struct {
+	VER  byte
+	CMD  byte
+	RSV  byte
+	ATYP byte
+}
+
+func (r *request) Bytes() []byte {
+	out := []byte{r.VER, r.CMD, r.RSV, r.ATYP}
+	out = append(out, r.DST_ADDR...)
+	return append(out, r.DST_PORT...)
+}
+
+type response struct {
+	resp
+	DST_ADDR []byte // first byte is length
+	DST_PORT []byte // two bytes
+}
+type resp struct {
+	VER  byte
+	REP  byte
+	RSV  byte
+	ATYP byte
+}

internal/socks5/socks5.go

@@ -0,0 +1,123 @@
+package socks5
+
+import (
+	"encoding/binary"
+	"fmt"
+	"io"
+	"net"
+	"strings"
+)
+
+func IsSocks5Schema(addr string) (string, bool) {
+	if strings.HasPrefix(addr, "socks5://") {
+		return strings.TrimPrefix(addr, "socks5://"), true
+	}
+
+	if strings.HasPrefix(addr, "socks5h://") {
+		return strings.TrimPrefix(addr, "socks5h://"), true
+	}
+
+	return addr, false
+}
+
+func ToSocks5(c net.Conn, domain string, port uint16) net.Conn {
+	return &conn{
+		init:   make(chan struct{}),
+		Conn:   c,
+		domain: domain,
+		port:   []byte{byte(port >> 8), byte(port)},
+	}
+}
+
+type conn struct {
+	init   chan struct{}
+	domain string
+	port   []byte
+	net.Conn
+}
+
+func (c *conn) Read(b []byte) (n int, err error) {
+	<-c.init
+	return c.Conn.Read(b)
+}
+
+func (c *conn) Write(b []byte) (n int, err error) {
+	select {
+	case <-c.init:
+		return c.Conn.Write(b)
+	default:
+	}
+
+	{
+		req := &authReq{
+			VER:      5,
+			NMETHODS: 1,
+			METHODS:  [1]byte{0}, // NO AUTHENTICATION REQUIRED
+		}
+		if err := binary.Write(c.Conn, binary.BigEndian, req); err != nil {
+			return 0, err
+		}
+	}
+	{
+		resp := &authResp{}
+		if err := binary.Read(c.Conn, binary.BigEndian, resp); err != nil {
+			return 0, err
+		}
+	}
+	{
+		req := &request{
+			req: req{
+				VER:  5, // socks5
+				CMD:  1, // CONNECT
+				RSV:  0, // RESERVED
+				ATYP: 3, // DOMAINNAME
+			},
+			DST_ADDR: append([]byte{byte(len(c.domain))}, []byte(c.domain)...),
+			DST_PORT: c.port,
+		}
+
+		if _, err := c.Conn.Write(req.Bytes()); err != nil {
+			return 0, err
+		}
+	}
+	{
+		resp := &response{}
+		if err := binary.Read(c.Conn, binary.BigEndian, &(resp.resp)); err != nil {
+			return 0, err
+		}
+
+		switch resp.REP {
+		case 0x00:
+		default:
+			return 0, fmt.Errorf("socks5 handshake fail, return code: %d", resp.REP)
+		}
+
+		switch resp.ATYP {
+		case 0x01: // IPv4
+			resp.DST_ADDR = make([]byte, net.IPv4len)
+			if _, err := io.ReadFull(c.Conn, resp.DST_ADDR); err != nil {
+				return 0, err
+			}
+		case 0x03: // domain name
+			if _, err := io.ReadFull(c.Conn, resp.DST_ADDR[:1]); err != nil {
+				return 0, err
+			}
+			if _, err := io.ReadFull(c.Conn, resp.DST_ADDR[1:1+int(resp.DST_ADDR[0])]); err != nil {
+				return 0, err
+			}
+		case 0x04:
+			resp.DST_ADDR = make([]byte, net.IPv6len)
+			if _, err := io.ReadFull(c.Conn, resp.DST_ADDR); err != nil {
+				return 0, err
+			}
+		}
+
+		resp.DST_PORT = make([]byte, 2)
+		if _, err := io.ReadFull(c.Conn, resp.DST_PORT); err != nil {
+			return 0, err
+		}
+	}
+
+	close(c.init)
+	return c.Conn.Write(b)
+}

main.go

@@ -1,19 +1,30 @@
 package main
 
 import (
-	"github.com/golang/glog"
+	"flag"
+	"fmt"
+
 	"github.com/wweir/sower/conf"
-	"github.com/wweir/sower/dns"
 	"github.com/wweir/sower/proxy"
 )
 
 func main() {
-	glog.Infoln("Starting:", conf.Conf)
+	if conf.Server.Upstream != "" {
+		proxy.StartServer(conf.Server.Upstream, conf.Password,
+			conf.Server.CertFile, conf.Server.KeyFile, conf.Server.CertEmail)
+	}
 
-	if conf.Conf.ServerAddr == "" {
-		proxy.StartServer(conf.Conf.ServerPort)
-	} else {
-		go dns.StartDNS(conf.Conf.DnsServer)
-		proxy.StartClient(conf.Conf.ServerAddr)
+	if conf.Client.Address != "" {
+		if conf.Client.DNS.ServeIP != "" {
+			go proxy.StartDNS(conf.Client.DNS.ServeIP, conf.Client.DNS.Upstream)
+		}
+
+		proxy.StartClient(conf.Password, conf.Client.Address, conf.Client.HTTPProxy.Address,
+			conf.Client.DNS.ServeIP, conf.Client.Router.PortMapping)
+	}
+
+	if conf.Server.Upstream == "" && conf.Client.Address == "" {
+		fmt.Println()
+		flag.Usage()
 	}
 }

parser/addr.go

@@ -1,75 +0,0 @@
-package parser
-
-import (
-	"bufio"
-	"fmt"
-	"io"
-	"net"
-	"net/http"
-	"strings"
-)
-
-type TeeConn struct {
-	net.Conn
-	buf    []byte
-	offset int
-	Tee    bool // read
-}
-
-func (t *TeeConn) Reset() {
-	t.offset = 0
-}
-
-func (t *TeeConn) Read(b []byte) (n int, err error) {
-	length := len(t.buf) - t.offset
-	if length > 0 {
-		n = copy(b, t.buf[t.offset:])
-		t.offset += n
-		return
-	}
-
-	n, err = t.Conn.Read(b)
-	if t.Tee {
-		t.buf = append(t.buf, b[:n]...)
-		t.offset += n
-	}
-	return n, err
-}
-
-func ParseAddr(conn net.Conn) (teeConn *TeeConn, addr string, err error) {
-	teeConn = &TeeConn{Conn: conn, Tee: true}
-	defer func() {
-		teeConn.Reset()
-		teeConn.Tee = false
-	}()
-
-	buf := make([]byte, 1)
-	if n, err := teeConn.Read(buf); err != nil || n != 1 {
-		return teeConn, "", fmt.Errorf("Read conn fail: %v, readed: %d %v", err, n, buf)
-	}
-
-	teeConn.Reset()
-
-	// https
-	if buf[0] == 0x16 { // SSL handleshake
-		host, _, err := extractSNI(io.Reader(teeConn))
-		if err != nil {
-			return teeConn, "", err
-		}
-		if strings.Contains(host, ":") {
-			return teeConn, host, nil
-		}
-		return teeConn, host + ":443", nil
-	}
-
-	// http
-	b := bufio.NewReader(teeConn)
-	resp, err := http.ReadRequest(b)
-	if err != nil {
-		return teeConn, "", err
-	}
-	if strings.Contains(resp.Host, ":") {
-		return teeConn, resp.Host, nil
-	}
-	return teeConn, resp.Host + ":80", nil
-}

proxy/client.go

@@ -1,103 +0,0 @@
-package proxy
-
-import (
-	"crypto/tls"
-	"net"
-	"time"
-
-	"github.com/golang/glog"
-	"github.com/lucas-clemente/quic-go"
-)
-
-func StartClient(server string) {
-	connCh := listenLocal([]string{":80", ":443"})
-	reDialCh := make(chan net.Conn, 10)
-	var conn net.Conn
-
-	for {
-		sess, err := quic.DialAddr(server, &tls.Config{InsecureSkipVerify: true}, nil)
-		if err != nil {
-			if sess, err = quic.DialAddr(server, &tls.Config{InsecureSkipVerify: true}, nil); err != nil {
-				glog.Errorf("connect to remote(%s) fail:%s\n", server, err)
-				time.Sleep(2 * time.Second)
-				continue
-			}
-		}
-		glog.Infof("new session from (%s) to (%s)", sess.LocalAddr(), sess.RemoteAddr())
-
-		for { // session rotate logic
-			select {
-			case conn = <-connCh:
-			case conn = <-reDialCh:
-			}
-
-			// sync action to reuse sigle sess
-			if !openStream(conn, sess, reDialCh) {
-				sess.Close()
-				break
-			}
-		}
-	}
-}
-
-func openStream(conn net.Conn, sess quic.Session, reDialCh chan<- net.Conn) bool {
-	glog.V(2).Infoln("new request from", conn.RemoteAddr())
-
-	okCh := make(chan struct{})
-	go func() {
-		stream, err := sess.OpenStream()
-		if err != nil {
-			glog.Warningf("start stream to (%s) fail:%s\n", sess.RemoteAddr(), err)
-			reDialCh <- conn
-			close(okCh)
-			return
-		}
-		defer stream.Close()
-
-		select {
-		case okCh <- struct{}{}:
-		default:
-			close(okCh)
-			return
-		}
-		close(okCh)
-
-		if err := conn.(*net.TCPConn).SetKeepAlive(true); err != nil {
-			glog.Warningln(err)
-		}
-		relay(&streamConn{stream, sess}, conn)
-		conn.Close()
-	}()
-
-	select {
-	case _, ok := <-okCh: // false means close on error
-		return ok
-	case <-time.After(500 * time.Millisecond):
-		return false
-	}
-}
-
-func listenLocal(ports []string) <-chan net.Conn {
-	connCh := make(chan net.Conn, 10)
-	for i := range ports {
-		go func(port string) {
-			ln, err := net.Listen("tcp", port)
-			if err != nil {
-				glog.Fatalln(err)
-			}
-
-			for {
-				conn, err := ln.Accept()
-				if err != nil {
-					glog.Errorln("accept", port, "fail:", err)
-					continue
-				}
-
-				connCh <- conn
-			}
-		}(ports[i])
-	}
-
-	glog.Infoln("listening ports:", ports)
-	return connCh
-}

proxy/dns.go

@@ -0,0 +1,93 @@
+package proxy
+
+import (
+	"net"
+	"strings"
+	"time"
+
+	"github.com/miekg/dns"
+	"github.com/wweir/sower/conf"
+	_net "github.com/wweir/sower/internal/net"
+	"github.com/wweir/utils/log"
+)
+
+func StartDNS(redirectIP, relayServer string) {
+	serveIP := net.ParseIP(redirectIP)
+	if redirectIP == "" || serveIP.String() != redirectIP {
+		log.Fatalw("invalid listen ip", "ip", redirectIP)
+	}
+
+	var err error
+	if relayServer, err = pickRelayAddr(relayServer); err != nil {
+		log.Fatalw("pick upstream dns server", "err", err)
+	}
+	log.Infow("detect upstream dns", "addr", relayServer)
+
+	dns.HandleFunc(".", func(w dns.ResponseWriter, r *dns.Msg) {
+		// *Msg r has an TSIG record and it was validated
+		if r.IsTsig() != nil && w.TsigStatus() == nil {
+			lastTsig := r.Extra[len(r.Extra)-1].(*dns.TSIG)
+			r.SetTsig(lastTsig.Hdr.Name, dns.HmacMD5, 300, time.Now().Unix())
+		}
+
+		//https://stackoverflow.com/questions/4082081/requesting-a-and-aaaa-records-in-single-dns-query/4083071#4083071
+		if len(r.Question) == 0 {
+			return
+		}
+
+		domain := r.Question[0].Name
+		if idx := strings.IndexByte(domain, ':'); idx > 0 {
+			domain = domain[:idx] // trim port
+		}
+
+		if conf.ShouldProxy(domain) {
+			w.WriteMsg(localA(r, domain, serveIP))
+
+		} else if msg, err := dns.Exchange(r, relayServer); err != nil || msg == nil {
+			server, err := pickRelayAddr(relayServer)
+			if err != nil {
+				log.Errorw("detect upstream dns", "err", err)
+			} else if relayServer != server {
+				relayServer = server
+				log.Infow("detect upstream dns", "addr", relayServer)
+			}
+
+		} else {
+			w.WriteMsg(msg)
+		}
+	})
+
+	server := &dns.Server{Addr: net.JoinHostPort(redirectIP, "53"), Net: "udp"}
+	log.Infow("start dns", "addr", server.Addr)
+	log.Fatalw("dns serve fail", "err", server.ListenAndServe())
+}
+
+func pickRelayAddr(relayServer string) (_ string, err error) {
+	if relayServer == "" {
+		if relayServer, err = _net.GetDefaultDNSServer(); err != nil {
+			return "", err
+		}
+	}
+
+	if _, _, err := net.SplitHostPort(relayServer); err != nil {
+		return net.JoinHostPort(relayServer, "53"), nil
+	}
+	return relayServer, nil
+}
+
+func localA(r *dns.Msg, domain string, localIP net.IP) *dns.Msg {
+	m := new(dns.Msg)
+	m.SetReply(r)
+	if localIP.To4() != nil {
+		m.Answer = []dns.RR{&dns.A{
+			Hdr: dns.RR_Header{Name: domain, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 20},
+			A:   localIP,
+		}}
+	} else {
+		m.Answer = []dns.RR{&dns.AAAA{
+			Hdr:  dns.RR_Header{Name: domain, Rrtype: dns.TypeAAAA, Class: dns.ClassINET, Ttl: 20},
+			AAAA: localIP,
+		}}
+	}
+	return m
+}

proxy/http_proxy.go

@@ -0,0 +1,92 @@
+package proxy
+
+import (
+	"context"
+	"crypto/tls"
+	"io"
+	"net"
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/wweir/sower/conf"
+	_http "github.com/wweir/sower/internal/http"
+	"github.com/wweir/sower/util"
+	"github.com/wweir/utils/log"
+)
+
+func startHTTPProxy(httpProxyAddr, serverAddr string, password []byte) {
+	srv := &http.Server{
+		Addr: httpProxyAddr,
+		Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.Method == http.MethodConnect {
+				httpsProxy(w, r, serverAddr, password)
+			} else {
+				httpProxy(w, r, serverAddr, password)
+			}
+		}),
+		// Disable HTTP/2.
+		TLSNextProto: map[string]func(*http.Server, *tls.Conn, http.Handler){},
+		IdleTimeout:  90 * time.Second,
+	}
+
+	go log.Fatalw("serve http proxy", "addr", httpProxyAddr, "err", srv.ListenAndServe())
+}
+
+func httpProxy(w http.ResponseWriter, r *http.Request, serverAddr string, password []byte) {
+	host, port := util.ParseHostPort(r.Host, 80)
+
+	roundTripper := &http.Transport{}
+	if conf.ShouldProxy(host) {
+		roundTripper.DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
+			return dial(serverAddr, password, _http.TGT_HTTP, host, port)
+		}
+	}
+
+	resp, err := roundTripper.RoundTrip(r)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusServiceUnavailable)
+		return
+	}
+	defer resp.Body.Close()
+
+	for k, vs := range resp.Header {
+		for _, v := range vs {
+			w.Header().Add(k, v)
+		}
+	}
+	w.WriteHeader(resp.StatusCode)
+	io.Copy(w, resp.Body)
+}
+
+func httpsProxy(w http.ResponseWriter, r *http.Request, serverAddr string, password []byte) {
+	host, port := util.ParseHostPort(r.Host, 443)
+
+	conn, _, err := w.(http.Hijacker).Hijack()
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusServiceUnavailable)
+		return
+	}
+	conn.(*net.TCPConn).SetKeepAlive(true)
+
+	if _, err := conn.Write([]byte(r.Proto + " 200 Connection established\r\n\r\n")); err != nil {
+		http.Error(w, err.Error(), http.StatusServiceUnavailable)
+		conn.Close()
+		return
+	}
+
+	var rc net.Conn
+	if conf.ShouldProxy(host) {
+		rc, err = dial(serverAddr, password, _http.TGT_HTTPS, host, port)
+	} else {
+		rc, err = net.Dial("tcp", net.JoinHostPort(host, strconv.Itoa(int(port))))
+	}
+	if err != nil {
+		conn.Write([]byte("sower dial " + serverAddr + " fail: " + err.Error()))
+		conn.Close()
+		return
+	}
+	defer rc.Close()
+
+	relay(conn, rc)
+}

proxy/proxy.go

@@ -0,0 +1,158 @@
+package proxy
+
+import (
+	"crypto/tls"
+	"net"
+	"net/http"
+	"strconv"
+
+	_http "github.com/wweir/sower/internal/http"
+	"github.com/wweir/sower/internal/socks5"
+	"github.com/wweir/sower/util"
+	"github.com/wweir/utils/log"
+	"golang.org/x/crypto/acme/autocert"
+)
+
+const configDir = "/etc/sower"
+
+type head struct {
+	checksum byte
+	length   byte
+}
+
+func StartClient(password, serverAddr, httpProxy, dnsServeIP string, forwards map[string]string) {
+	passwordData := []byte(password)
+	_, isSocks5 := socks5.IsSocks5Schema(serverAddr)
+
+	if httpProxy != "" {
+		go startHTTPProxy(httpProxy, serverAddr, passwordData)
+	}
+
+	relayToRemote := func(tgtType byte, lnAddr string, host string, port uint16) {
+		ln, err := net.Listen("tcp", lnAddr)
+		if err != nil {
+			log.Fatalw("tcp listen", "port", lnAddr, "err", err)
+		}
+
+		for {
+			conn, err := ln.Accept()
+			if err != nil {
+				log.Errorw("tcp accept", "port", lnAddr, "err", err)
+				continue
+			}
+
+			go func(conn net.Conn) {
+				defer conn.Close()
+
+				if isSocks5 {
+					teeConn := &util.TeeConn{Conn: conn}
+					teeConn.StartOrReset()
+
+					switch tgtType {
+					case _http.TGT_HTTP:
+						conn, host, port, err = _http.ParseHTTP(teeConn)
+					case _http.TGT_HTTPS:
+						conn, host, err = _http.ParseHTTPS(teeConn)
+					}
+					if err != nil {
+						log.Errorw("parse socks5 target", "err", err)
+						return
+					}
+					teeConn.Stop()
+				}
+
+				rc, err := dial(serverAddr, passwordData, tgtType, host, port)
+				if err != nil {
+					log.Errorw("dial", "addr", serverAddr, "err", err)
+					return
+				}
+				defer rc.Close()
+
+				relay(conn, rc)
+			}(conn)
+		}
+	}
+
+	if dnsServeIP != "" {
+		go relayToRemote(_http.TGT_HTTP, dnsServeIP+":http", "", 80)
+		go relayToRemote(_http.TGT_HTTPS, dnsServeIP+":https", "", 443)
+	}
+
+	for from, to := range forwards {
+		go func(from, to string) {
+			host, port := util.ParseHostPort(to, 0)
+			relayToRemote(_http.TGT_OTHER, from, host, port)
+		}(from, to)
+	}
+
+	select {}
+}
+
+func StartServer(relayTarget, password, certFile, keyFile, email string) {
+	certManager := autocert.Manager{
+		Prompt: autocert.AcceptTOS,
+		Cache:  autocert.DirCache(configDir), //folder for storing certificates
+		Email:  email,
+	}
+	tlsConf := &tls.Config{
+		GetCertificate: certManager.GetCertificate,
+		MinVersion:     tls.VersionTLS12,
+	}
+	if certFile != "" && keyFile != "" {
+		if cert, err := tls.LoadX509KeyPair(certFile, keyFile); err != nil {
+			log.Fatalw("load certificate", "cert", certFile, "key", keyFile, "err", err)
+		} else {
+			tlsConf.GetCertificate = nil
+			tlsConf.Certificates = []tls.Certificate{cert}
+		}
+	}
+
+	// Try to redirect 80 to 443
+	go http.ListenAndServe(":http", certManager.HTTPHandler(http.HandlerFunc(
+		func(w http.ResponseWriter, r *http.Request) {
+			if host, _, err := net.SplitHostPort(r.Host); err != nil {
+				r.URL.Host = r.Host
+			} else {
+				r.URL.Host = host
+			}
+			r.URL.Scheme = "https"
+			http.Redirect(w, r, r.URL.String(), 301)
+		})))
+
+	ln, err := tls.Listen("tcp", ":https", tlsConf)
+	if err != nil {
+		log.Fatalw("tcp listen", "err", err)
+	}
+
+	passwordData := []byte(password)
+	for {
+		conn, err := ln.Accept()
+		if err != nil {
+			log.Errorw("tcp accept", "err", err)
+			continue
+		}
+
+		go func(conn net.Conn) {
+			conn, domain, port, err := _http.ParseAddr(conn, passwordData)
+			if err != nil {
+				log.Errorw("parse relay target", "err", err)
+				return
+			}
+			defer conn.Close()
+
+			addr := relayTarget
+			if domain != "" {
+				addr = net.JoinHostPort(domain, strconv.Itoa(int(port)))
+			}
+
+			rc, err := net.Dial("tcp", addr)
+			if err != nil {
+				log.Errorw("tcp dial", "host", domain, "addr", addr, "err", err)
+				return
+			}
+			defer rc.Close()
+
+			relay(conn, rc)
+		}(conn)
+	}
+}

proxy/server.go

@@ -1,63 +0,0 @@
-package proxy
-
-import (
-	"net"
-
-	"github.com/golang/glog"
-	"github.com/lucas-clemente/quic-go"
-	"github.com/wweir/sower/parser"
-)
-
-func StartServer(port string) {
-	ln, err := quic.ListenAddr(":"+port, mockTlsPem(), nil)
-	if err != nil {
-		glog.Fatalln(err)
-	}
-
-	for {
-		sess, err := ln.Accept()
-		if err != nil {
-			glog.Errorln(err)
-			continue
-		}
-		go acceptSession(sess)
-	}
-}
-
-func acceptSession(sess quic.Session) {
-	glog.V(1).Infoln("new session from ", sess.RemoteAddr())
-	defer sess.Close()
-
-	for {
-		stream, err := sess.AcceptStream()
-		if err != nil {
-			glog.Errorln(err)
-			return
-		}
-
-		go acceptStream(stream, sess)
-	}
-}
-
-func acceptStream(stream quic.Stream, sess quic.Session) {
-	glog.V(1).Infoln("new stream from ", sess.RemoteAddr())
-	defer stream.Close()
-
-	conn, addr, err := parser.ParseAddr(&streamConn{stream, sess})
-	if err != nil {
-		glog.Warningln(err)
-		return
-	}
-	glog.V(1).Infoln(addr)
-
-	rc, err := net.Dial("tcp", addr)
-	if err != nil {
-		glog.Warningln(err)
-		return
-	}
-	defer rc.Close()
-	if err := rc.(*net.TCPConn).SetKeepAlive(true); err != nil {
-		glog.Warningln(err)
-	}
-	relay(rc, conn)
-}

proxy/util.go

@@ -1,74 +1,51 @@
 package proxy
 
 import (
-	"crypto/rand"
-	"crypto/rsa"
 	"crypto/tls"
-	"crypto/x509"
-	"encoding/pem"
 	"io"
-	"math/big"
 	"net"
 	"sync"
 	"sync/atomic"
 	"time"
 
-	"github.com/golang/glog"
-	"github.com/lucas-clemente/quic-go"
+	"github.com/wweir/sower/internal/http"
+	"github.com/wweir/sower/internal/socks5"
 )
 
-type streamConn struct {
-	quic.Stream
-	sess quic.Session
-}
+func dial(serverAddr string, password []byte, tgtType byte, domain string, port uint16) (net.Conn, error) {
+	if addr, ok := socks5.IsSocks5Schema(serverAddr); ok {
+		conn, err := net.Dial("tcp", addr)
+		if err != nil {
+			return nil, err
+		}
+		return socks5.ToSocks5(conn, domain, port), nil
+	}
 
-func (s *streamConn) LocalAddr() net.Addr {
-	return s.sess.LocalAddr()
-}
-
-func (s *streamConn) RemoteAddr() net.Addr {
-	return s.sess.RemoteAddr()
+	conn, err := tls.Dial("tcp", net.JoinHostPort(serverAddr, "443"), &tls.Config{})
+	if err != nil {
+		return nil, err
+	}
+	return http.NewTgtConn(conn, password, tgtType, domain, port), nil
 }
 
 func relay(conn1, conn2 net.Conn) {
 	wg := &sync.WaitGroup{}
 	exitFlag := new(int32)
 	wg.Add(2)
-	go redirect(conn1, conn2, wg, exitFlag)
-	redirect(conn2, conn1, wg, exitFlag)
+	go redirect(conn2, conn1, wg, exitFlag)
+	redirect(conn1, conn2, wg, exitFlag)
 	wg.Wait()
 }
 
-func redirect(conn1, conn2 net.Conn, wg *sync.WaitGroup, exitFlag *int32) {
-	if _, err := io.Copy(conn2, conn1); err != nil && (atomic.LoadInt32(exitFlag) == 0) {
-		glog.V(1).Infof("%s<>%s -> %s<>%s: %s", conn1.RemoteAddr(), conn1.LocalAddr(), conn2.LocalAddr(), conn2.RemoteAddr(), err)
+func redirect(dst, src net.Conn, wg *sync.WaitGroup, exitFlag *int32) {
+	io.Copy(dst, src)
+
+	if atomic.CompareAndSwapInt32(exitFlag, 0, 1) {
+		// wakeup blocked goroutine
+		now := time.Now()
+		src.SetDeadline(now)
+		dst.SetDeadline(now)
 	}
 
-	// wakeup all conn goroutine
-	atomic.AddInt32(exitFlag, 1)
-	now := time.Now()
-	conn1.SetDeadline(now)
-	conn2.SetDeadline(now)
 	wg.Done()
 }
-
-func mockTlsPem() *tls.Config {
-	key, err := rsa.GenerateKey(rand.Reader, 1024)
-	if err != nil {
-		glog.Fatalln(err)
-	}
-	template := x509.Certificate{SerialNumber: big.NewInt(1)}
-	certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key)
-	if err != nil {
-		glog.Fatalln(err)
-	}
-
-	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})
-	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})
-
-	tlsCert, err := tls.X509KeyPair(certPEM, keyPEM)
-	if err != nil {
-		glog.Fatalln(err)
-	}
-	return &tls.Config{Certificates: []tls.Certificate{tlsCert}}
-}

util/rev_sec.go

@@ -0,0 +1,52 @@
+package util
+
+import (
+	"sort"
+	"strings"
+)
+
+type ReverseSecSlice struct {
+	sort.StringSlice
+}
+
+func NewReverseSecSlice(a []string) *ReverseSecSlice {
+	return &ReverseSecSlice{sort.StringSlice(a)}
+}
+
+func (p *ReverseSecSlice) Sort() *ReverseSecSlice {
+	sort.Sort(p)
+	return p
+}
+func (p *ReverseSecSlice) Uniq() []string {
+	olds := []string(p.StringSlice)
+
+	last := ""
+	strs := make([]string, 0, len(olds))
+	for _, str := range olds {
+		if str != last {
+			strs = append(strs, str)
+		}
+		last = str
+	}
+	return strs
+}
+
+func (p *ReverseSecSlice) Less(i, j int) bool {
+	secsI := strings.Split(p.StringSlice[i], ".")
+	secsJ := strings.Split(p.StringSlice[j], ".")
+
+	lenI := len(secsI) - 1
+	lenJ := len(secsJ) - 1
+	length := lenI
+	if lenI > lenJ {
+		length = lenJ
+	}
+
+	for idx := 0; idx <= length; idx++ {
+		if secsI[lenI-idx] == secsJ[lenJ-idx] {
+			continue
+		}
+		return secsI[lenI-idx] < secsJ[lenJ-idx]
+	}
+	return lenI < lenJ
+}

util/rev_sec_test.go

@@ -0,0 +1,65 @@
+package util
+
+import (
+	"sort"
+	"testing"
+)
+
+func TestReverseSecSlice_Less(t *testing.T) {
+	type fields struct {
+		StringSlice sort.StringSlice
+	}
+	type args struct {
+		i int
+		j int
+	}
+	slice := fields{sort.StringSlice([]string{
+		"a.b.c",
+		"a.b.c",
+		"d.b.c",
+		"d.a.b.c",
+		"",
+		"",
+	})}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   bool
+	}{{
+		name:   "equal",
+		fields: slice,
+		args:   args{0, 1},
+		want:   false,
+	}, {
+		name:   "less",
+		fields: slice,
+		args:   args{0, 2},
+		want:   true,
+	}, {
+		name:   "length",
+		fields: slice,
+		args:   args{0, 3},
+		want:   true,
+	}, {
+		name:   "single_empty",
+		fields: slice,
+		args:   args{0, 4},
+		want:   false,
+	}, {
+		name:   "all_empty",
+		fields: slice,
+		args:   args{4, 5},
+		want:   false,
+	}}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			p := &ReverseSecSlice{
+				StringSlice: tt.fields.StringSlice,
+			}
+			if got := p.Less(tt.args.i, tt.args.j); got != tt.want {
+				t.Errorf("ReverseSecSlice.Less() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

util/suffix_tree.go

@@ -0,0 +1,105 @@
+package util
+
+import (
+	"strings"
+	"sync"
+)
+
+type Node struct {
+	node
+	sep string
+	*sync.RWMutex
+}
+type node struct {
+	node map[string]*node
+}
+
+func NewNodeFromRules(rules ...string) *Node {
+	n := &Node{node{node: map[string]*node{}}, ".", &sync.RWMutex{}}
+	for i := range rules {
+		n.Add(rules[i])
+	}
+	return n
+}
+
+func (n *Node) String() string {
+	n.RLock()
+	defer n.RUnlock()
+	return n.string("", "     ")
+}
+func (n *node) string(prefix, indent string) (out string) {
+	for key, val := range n.node {
+		out += prefix + key + "\n" + val.string(prefix+indent, indent)
+	}
+	return
+}
+
+func (n *Node) trim(item string) string {
+	return strings.TrimSuffix(item, n.sep)
+}
+
+func (n *Node) Add(item string) {
+	n.Lock()
+	defer n.Unlock()
+	n.add(strings.Split(n.trim(item), n.sep))
+}
+func (n *node) add(secs []string) {
+	length := len(secs)
+	switch length {
+	case 0:
+		return
+	case 1:
+		n.node[secs[length-1]] = &node{node: map[string]*node{"": &node{}}}
+	default:
+		sec := secs[length-1]
+		if sec == "**" {
+			sec = "*"
+		}
+
+		subNode, ok := n.node[sec]
+		if !ok {
+			subNode = &node{node: map[string]*node{}}
+			n.node[sec] = subNode
+		}
+		subNode.add(secs[:length-1])
+	}
+}
+
+func (n *Node) Match(item string) bool {
+	if n == nil {
+		return false
+	}
+	return n.matchSecs(strings.Split(n.trim(item), n.sep), false)
+}
+
+func (n *node) matchSecs(secs []string, fuzzNode bool) bool {
+	length := len(secs)
+	if length == 0 {
+		if _, ok := n.node[""]; ok {
+			return true
+		}
+		if _, ok := n.node["**"]; ok {
+			return true
+		}
+		if _, ok := n.node["*"]; ok {
+			return !fuzzNode
+		}
+		return false
+	}
+
+	if n, ok := n.node[secs[length-1]]; ok {
+		if n.matchSecs(secs[:length-1], false) {
+			return true
+		}
+	}
+	if n, ok := n.node["*"]; ok {
+		if n.matchSecs(secs[:length-1], true) {
+			return true
+		}
+	}
+	if _, ok := n.node["**"]; ok {
+		return true
+	}
+
+	return false
+}

util/suffix_tree_test.go

@@ -0,0 +1,79 @@
+package util
+
+import (
+	"testing"
+)
+
+func TestNode_Match(t *testing.T) {
+	type test struct {
+		arg  string
+		want bool
+	}
+	tests := []struct {
+		name  string
+		node  *Node
+		tests []test
+	}{{
+		"simple",
+		NewNodeFromRules("a.wweir.cc", "b.wweir.cc"),
+		[]test{
+			{"a.wweir.cc", true},
+			{"b.wweir.cc", true},
+		},
+	}, {
+		"parent",
+		NewNodeFromRules("wweir.cc", "a.wweir.cc"),
+		[]test{
+			{"wweir.cc", true},
+			{"a.wweir.cc", true},
+			{"b.wweir.cc", false},
+		},
+	}, {
+		"fuzz1",
+		NewNodeFromRules("wweir.cc", "a.wweir.cc", "*.wweir.cc"),
+		[]test{
+			{"wweir.cc", true},
+			{"a.wweir.cc", true},
+			{"b.wweir.cc", true},
+			{"a.b.wweir.cc", false},
+		},
+	}, {
+		"fuzz2",
+		NewNodeFromRules("a.*.cc", "c.wweir.*"),
+		[]test{
+			{"wweir.cc", false},
+			{"a.wweir.cc", true},
+			{"b.wweir.cc", false},
+			{"c.wweir.cc", true},
+		},
+	}, {
+		"fuzz3",
+		NewNodeFromRules("*.*.cc", "iamp.*.*"),
+		[]test{
+			{"wweir.cc", false},
+			{"a.wweir.cc", true},
+			{"b.wweir.cc", true},
+			{"iamp.wweir.cc", true},
+		},
+	}, {
+		"fuzz4",
+		NewNodeFromRules("**.cc", "a.**.com", "**.wweir.*"),
+		[]test{
+			{"wweir.cc", true},
+			{"a.wweir.cc", true},
+			{"a.b.wweir.cc", true},
+			{"a.fuzz.com", true},
+			{"b.fuzz.com", false},
+			{"www.wweir.com", true},
+		},
+	}}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			for _, test := range tt.tests {
+				if got := tt.node.Match(test.arg); got != test.want {
+					t.Errorf("Node.Match(%s) = %v, want %v", test.arg, got, test.want)
+				}
+			}
+		})
+	}
+}

util/tee_conn.go

@@ -0,0 +1,41 @@
+package util
+
+import (
+	"net"
+)
+
+type TeeConn struct {
+	net.Conn
+	buf    []byte
+	offset int
+	tee    bool // read
+}
+
+func (t *TeeConn) StartOrReset() {
+	t.offset = 0
+	t.tee = true
+}
+func (t *TeeConn) DropAndRestart() {
+	t.buf = []byte{}
+	t.tee = true
+}
+func (t *TeeConn) Stop() {
+	t.offset = 0
+	t.tee = false
+}
+
+func (t *TeeConn) Read(b []byte) (n int, err error) {
+	length := len(t.buf) - t.offset
+	if length > 0 {
+		n = copy(b, t.buf[t.offset:])
+		t.offset += n
+		return
+	}
+
+	n, err = t.Conn.Read(b)
+	if t.tee {
+		t.buf = append(t.buf, b[:n]...)
+		t.offset += n
+	}
+	return n, err
+}

util/util.go

@@ -0,0 +1,19 @@
+package util
+
+import (
+	"net"
+	"strconv"
+)
+
+func ParseHostPort(addr string, defaultPort uint16) (string, uint16) {
+	h, p, err := net.SplitHostPort(addr)
+	if err != nil {
+		if defaultPort == 0 {
+			panic("parse port fail with no default, addr: " + addr)
+		}
+		return addr, defaultPort
+	}
+
+	pNum, _ := strconv.ParseUint(p, 10, 16)
+	return h, uint16(pNum)
+}