update

services/args.go

@@ -0,0 +1,75 @@
+package services
+
+// tcp := app.Command("tcp", "proxy on tcp mode")
+// t := tcp.Flag("tcp-timeout", "tcp timeout milliseconds when connect to real server or parent proxy").Default("2000").Int()
+
+const (
+	TYPE_TCP     = "tcp"
+	TYPE_UDP     = "udp"
+	TYPE_HTTP    = "http"
+	TYPE_TLS     = "tls"
+	CONN_CONTROL = uint8(1)
+	CONN_SERVER  = uint8(2)
+	CONN_CLIENT  = uint8(3)
+)
+
+type Args struct {
+	Local     *string
+	Parent    *string
+	CertBytes []byte
+	KeyBytes  []byte
+}
+type TunnelServerArgs struct {
+	Args
+	IsUDP   *bool
+	Key     *string
+	Timeout *int
+}
+type TunnelClientArgs struct {
+	Args
+	IsUDP   *bool
+	Key     *string
+	Timeout *int
+}
+type TunnelBridgeArgs struct {
+	Args
+	Timeout *int
+}
+type TCPArgs struct {
+	Args
+	ParentType          *string
+	IsTLS               *bool
+	Timeout             *int
+	PoolSize            *int
+	CheckParentInterval *int
+}
+
+type HTTPArgs struct {
+	Args
+	Always              *bool
+	HTTPTimeout         *int
+	Interval            *int
+	Blocked             *string
+	Direct              *string
+	AuthFile            *string
+	Auth                *[]string
+	ParentType          *string
+	LocalType           *string
+	Timeout             *int
+	PoolSize            *int
+	CheckParentInterval *int
+}
+type UDPArgs struct {
+	Args
+	ParentType          *string
+	Timeout             *int
+	PoolSize            *int
+	CheckParentInterval *int
+}
+
+func (a *TCPArgs) Protocol() string {
+	if *a.IsTLS {
+		return "tls"
+	}
+	return "tcp"
+}

services/http.go

@@ -0,0 +1,219 @@
+package services
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"proxy/utils"
+	"runtime/debug"
+	"strconv"
+)
+
+type HTTP struct {
+	outPool   utils.OutPool
+	cfg       HTTPArgs
+	checker   utils.Checker
+	basicAuth utils.BasicAuth
+}
+
+func NewHTTP() Service {
+	return &HTTP{
+		outPool:   utils.OutPool{},
+		cfg:       HTTPArgs{},
+		checker:   utils.Checker{},
+		basicAuth: utils.BasicAuth{},
+	}
+}
+func (s *HTTP) InitService() {
+	s.InitBasicAuth()
+	if *s.cfg.Parent != "" {
+		s.checker = utils.NewChecker(*s.cfg.HTTPTimeout, int64(*s.cfg.Interval), *s.cfg.Blocked, *s.cfg.Direct)
+	}
+}
+func (s *HTTP) StopService() {
+	if s.outPool.Pool != nil {
+		s.outPool.Pool.ReleaseAll()
+	}
+}
+func (s *HTTP) Start(args interface{}) (err error) {
+	s.cfg = args.(HTTPArgs)
+	if *s.cfg.Parent != "" {
+		log.Printf("use %s parent %s", *s.cfg.ParentType, *s.cfg.Parent)
+		s.InitOutConnPool()
+	}
+
+	s.InitService()
+
+	host, port, _ := net.SplitHostPort(*s.cfg.Local)
+	p, _ := strconv.Atoi(port)
+	sc := utils.NewServerChannel(host, p)
+	if *s.cfg.LocalType == TYPE_TCP {
+		err = sc.ListenTCP(s.callback)
+	} else {
+		err = sc.ListenTls(s.cfg.CertBytes, s.cfg.KeyBytes, s.callback)
+	}
+	if err != nil {
+		return
+	}
+	log.Printf("%s http(s) proxy on %s", *s.cfg.LocalType, (*sc.Listener).Addr())
+	return
+}
+
+func (s *HTTP) Clean() {
+	s.StopService()
+}
+func (s *HTTP) callback(inConn net.Conn) {
+	defer func() {
+		if err := recover(); err != nil {
+			log.Printf("http(s) conn handler crashed with err : %s \nstack: %s", err, string(debug.Stack()))
+		}
+	}()
+	req, err := utils.NewHTTPRequest(&inConn, 4096, s.IsBasicAuth(), &s.basicAuth)
+	if err != nil {
+		if err != io.EOF {
+			log.Printf("decoder error , form %s, ERR:%s", err, inConn.RemoteAddr())
+		}
+		utils.CloseConn(&inConn)
+		return
+	}
+	address := req.Host
+
+	useProxy := true
+	if *s.cfg.Parent == "" {
+		useProxy = false
+	} else if *s.cfg.Always {
+		useProxy = true
+	} else {
+		if req.IsHTTPS() {
+			s.checker.Add(address, true, req.Method, "", nil)
+		} else {
+			s.checker.Add(address, false, req.Method, req.URL, req.HeadBuf)
+		}
+		//var n, m uint
+		useProxy, _, _ = s.checker.IsBlocked(req.Host)
+		//log.Printf("blocked ? : %v, %s , fail:%d ,success:%d", useProxy, address, n, m)
+	}
+	log.Printf("use proxy : %v, %s", useProxy, address)
+	//os.Exit(0)
+	err = s.OutToTCP(useProxy, address, &inConn, &req)
+	if err != nil {
+		if *s.cfg.Parent == "" {
+			log.Printf("connect to %s fail, ERR:%s", address, err)
+		} else {
+			log.Printf("connect to %s parent %s fail", *s.cfg.ParentType, *s.cfg.Parent)
+		}
+		utils.CloseConn(&inConn)
+	}
+}
+func (s *HTTP) OutToTCP(useProxy bool, address string, inConn *net.Conn, req *utils.HTTPRequest) (err error) {
+	inAddr := (*inConn).RemoteAddr().String()
+	inLocalAddr := (*inConn).LocalAddr().String()
+	//防止死循环
+	if s.IsDeadLoop(inLocalAddr, req.Host) {
+		utils.CloseConn(inConn)
+		err = fmt.Errorf("dead loop detected , %s", req.Host)
+		return
+	}
+	var outConn net.Conn
+	var _outConn interface{}
+	if useProxy {
+		_outConn, err = s.outPool.Pool.Get()
+		if err == nil {
+			outConn = _outConn.(net.Conn)
+		}
+	} else {
+		outConn, err = utils.ConnectHost(address, *s.cfg.Timeout)
+	}
+	if err != nil {
+		log.Printf("connect to %s , err:%s", *s.cfg.Parent, err)
+		utils.CloseConn(inConn)
+		return
+	}
+
+	outAddr := outConn.RemoteAddr().String()
+	outLocalAddr := outConn.LocalAddr().String()
+
+	if req.IsHTTPS() && !useProxy {
+		req.HTTPSReply()
+	} else {
+		outConn.Write(req.HeadBuf)
+	}
+	utils.IoBind((*inConn), outConn, func(isSrcErr bool, err error) {
+		log.Printf("conn %s - %s - %s -%s released [%s]", inAddr, inLocalAddr, outLocalAddr, outAddr, req.Host)
+		utils.CloseConn(inConn)
+		utils.CloseConn(&outConn)
+	}, func(n int, d bool) {}, 0)
+	log.Printf("conn %s - %s - %s - %s connected [%s]", inAddr, inLocalAddr, outLocalAddr, outAddr, req.Host)
+	return
+}
+func (s *HTTP) OutToUDP(inConn *net.Conn) (err error) {
+	return
+}
+func (s *HTTP) InitOutConnPool() {
+	if *s.cfg.ParentType == TYPE_TLS || *s.cfg.ParentType == TYPE_TCP {
+		//dur int, isTLS bool, certBytes, keyBytes []byte,
+		//parent string, timeout int, InitialCap int, MaxCap int
+		s.outPool = utils.NewOutPool(
+			*s.cfg.CheckParentInterval,
+			*s.cfg.ParentType == TYPE_TLS,
+			s.cfg.CertBytes, s.cfg.KeyBytes,
+			*s.cfg.Parent,
+			*s.cfg.Timeout,
+			*s.cfg.PoolSize,
+			*s.cfg.PoolSize*2,
+		)
+	}
+}
+func (s *HTTP) InitBasicAuth() (err error) {
+	s.basicAuth = utils.NewBasicAuth()
+	if *s.cfg.AuthFile != "" {
+		var n = 0
+		n, err = s.basicAuth.AddFromFile(*s.cfg.AuthFile)
+		if err != nil {
+			err = fmt.Errorf("auth-file ERR:%s", err)
+			return
+		}
+		log.Printf("auth data added from file %d , total:%d", n, s.basicAuth.Total())
+	}
+	if len(*s.cfg.Auth) > 0 {
+		n := s.basicAuth.Add(*s.cfg.Auth)
+		log.Printf("auth data added %d, total:%d", n, s.basicAuth.Total())
+	}
+	return
+}
+func (s *HTTP) IsBasicAuth() bool {
+	return *s.cfg.AuthFile != "" || len(*s.cfg.Auth) > 0
+}
+func (s *HTTP) IsDeadLoop(inLocalAddr string, host string) bool {
+	inIP, inPort, err := net.SplitHostPort(inLocalAddr)
+	if err != nil {
+		return false
+	}
+	outDomain, outPort, err := net.SplitHostPort(host)
+	if err != nil {
+		return false
+	}
+	if inPort == outPort {
+		var outIPs []net.IP
+		outIPs, err = net.LookupIP(outDomain)
+		if err == nil {
+			for _, ip := range outIPs {
+				if ip.String() == inIP {
+					return true
+				}
+			}
+		}
+		interfaceIPs, err := utils.GetAllInterfaceAddr()
+		if err == nil {
+			for _, localIP := range interfaceIPs {
+				for _, outIP := range outIPs {
+					if localIP.Equal(outIP) {
+						return true
+					}
+				}
+			}
+		}
+	}
+	return false
+}

services/service.go

@@ -0,0 +1,48 @@
+package services
+
+import (
+	"fmt"
+	"log"
+	"runtime/debug"
+)
+
+type Service interface {
+	Start(args interface{}) (err error)
+	Clean()
+}
+type ServiceItem struct {
+	S    Service
+	Args interface{}
+	Name string
+}
+
+var servicesMap = map[string]*ServiceItem{}
+
+func Regist(name string, s Service, args interface{}) {
+	servicesMap[name] = &ServiceItem{
+		S:    s,
+		Args: args,
+		Name: name,
+	}
+}
+func Run(name string) (service *ServiceItem, err error) {
+	service, ok := servicesMap[name]
+	if ok {
+		go func() {
+			defer func() {
+				err := recover()
+				if err != nil {
+					log.Fatalf("%s servcie crashed, ERR: %s\ntrace:%s", name, err, string(debug.Stack()))
+				}
+			}()
+			err := service.S.Start(service.Args)
+			if err != nil {
+				log.Fatalf("%s servcie fail, ERR: %s", name, err)
+			}
+		}()
+	}
+	if !ok {
+		err = fmt.Errorf("service %s not found", name)
+	}
+	return
+}

services/tcp.go

@@ -0,0 +1,170 @@
+package services
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"proxy/utils"
+	"runtime/debug"
+	"time"
+
+	"strconv"
+)
+
+type TCP struct {
+	outPool utils.OutPool
+	cfg     TCPArgs
+}
+
+func NewTCP() Service {
+	return &TCP{
+		outPool: utils.OutPool{},
+		cfg:     TCPArgs{},
+	}
+}
+func (s *TCP) InitService() {
+	s.InitOutConnPool()
+}
+func (s *TCP) StopService() {
+	if s.outPool.Pool != nil {
+		s.outPool.Pool.ReleaseAll()
+	}
+}
+func (s *TCP) Start(args interface{}) (err error) {
+	s.cfg = args.(TCPArgs)
+	if *s.cfg.Parent != "" {
+		log.Printf("use %s parent %s", *s.cfg.ParentType, *s.cfg.Parent)
+	} else {
+		log.Fatalf("parent required for %s %s", s.cfg.Protocol(), *s.cfg.Local)
+	}
+
+	s.InitService()
+
+	host, port, _ := net.SplitHostPort(*s.cfg.Local)
+	p, _ := strconv.Atoi(port)
+	sc := utils.NewServerChannel(host, p)
+	if !*s.cfg.IsTLS {
+		err = sc.ListenTCP(s.callback)
+	} else {
+		err = sc.ListenTls(s.cfg.CertBytes, s.cfg.KeyBytes, s.callback)
+	}
+	if err != nil {
+		return
+	}
+	log.Printf("%s proxy on %s", s.cfg.Protocol(), (*sc.Listener).Addr())
+	return
+}
+
+func (s *TCP) Clean() {
+	s.StopService()
+}
+func (s *TCP) callback(inConn net.Conn) {
+	defer func() {
+		if err := recover(); err != nil {
+			log.Printf("%s conn handler crashed with err : %s \nstack: %s", s.cfg.Protocol(), err, string(debug.Stack()))
+		}
+	}()
+	var err error
+	switch *s.cfg.ParentType {
+	case TYPE_TCP:
+		fallthrough
+	case TYPE_TLS:
+		err = s.OutToTCP(&inConn)
+	case TYPE_UDP:
+		err = s.OutToUDP(&inConn)
+	default:
+		err = fmt.Errorf("unkown parent type %s", *s.cfg.ParentType)
+	}
+	if err != nil {
+		log.Printf("connect to %s parent %s fail, ERR:%s", *s.cfg.ParentType, *s.cfg.Parent, err)
+		utils.CloseConn(&inConn)
+	}
+}
+func (s *TCP) OutToTCP(inConn *net.Conn) (err error) {
+	var outConn net.Conn
+	var _outConn interface{}
+	_outConn, err = s.outPool.Pool.Get()
+	if err == nil {
+		outConn = _outConn.(net.Conn)
+	}
+	if err != nil {
+		log.Printf("connect to %s , err:%s", *s.cfg.Parent, err)
+		utils.CloseConn(inConn)
+		return
+	}
+	inAddr := (*inConn).RemoteAddr().String()
+	inLocalAddr := (*inConn).LocalAddr().String()
+	outAddr := outConn.RemoteAddr().String()
+	outLocalAddr := outConn.LocalAddr().String()
+	utils.IoBind((*inConn), outConn, func(isSrcErr bool, err error) {
+		log.Printf("conn %s - %s - %s -%s released", inAddr, inLocalAddr, outLocalAddr, outAddr)
+		utils.CloseConn(inConn)
+		utils.CloseConn(&outConn)
+	}, func(n int, d bool) {}, 0)
+	log.Printf("conn %s - %s - %s -%s connected", inAddr, inLocalAddr, outLocalAddr, outAddr)
+	return
+}
+func (s *TCP) OutToUDP(inConn *net.Conn) (err error) {
+	log.Printf("conn created , remote : %s ", (*inConn).RemoteAddr())
+	for {
+		srcAddr, body, err := utils.ReadUDPPacket(inConn)
+		if err == io.EOF || err == io.ErrUnexpectedEOF {
+			//log.Printf("connection %s released", srcAddr)
+			utils.CloseConn(inConn)
+			break
+		}
+		//log.Debugf("udp packet revecived:%s,%v", srcAddr, body)
+		dstAddr, err := net.ResolveUDPAddr("udp", *s.cfg.Parent)
+		if err != nil {
+			log.Printf("can't resolve address: %s", err)
+			utils.CloseConn(inConn)
+			break
+		}
+		clientSrcAddr := &net.UDPAddr{IP: net.IPv4zero, Port: 0}
+		conn, err := net.DialUDP("udp", clientSrcAddr, dstAddr)
+		if err != nil {
+			log.Printf("connect to udp %s fail,ERR:%s", dstAddr.String(), err)
+			continue
+		}
+		conn.SetDeadline(time.Now().Add(time.Millisecond * time.Duration(*s.cfg.Timeout)))
+		_, err = conn.Write(body)
+		if err != nil {
+			log.Printf("send udp packet to %s fail,ERR:%s", dstAddr.String(), err)
+			continue
+		}
+		//log.Debugf("send udp packet to %s success", dstAddr.String())
+		buf := make([]byte, 512)
+		len, _, err := conn.ReadFromUDP(buf)
+		if err != nil {
+			log.Printf("read udp response from %s fail ,ERR:%s", dstAddr.String(), err)
+			continue
+		}
+		respBody := buf[0:len]
+		//log.Debugf("revecived udp packet from %s , %v", dstAddr.String(), respBody)
+		_, err = (*inConn).Write(utils.UDPPacket(srcAddr, respBody))
+		if err != nil {
+			log.Printf("send udp response fail ,ERR:%s", err)
+			utils.CloseConn(inConn)
+			break
+		}
+		//log.Printf("send udp response success ,from:%s", dstAddr.String())
+	}
+	return
+
+}
+func (s *TCP) InitOutConnPool() {
+	if *s.cfg.ParentType == TYPE_TLS || *s.cfg.ParentType == TYPE_TCP {
+		//dur int, isTLS bool, certBytes, keyBytes []byte,
+		//parent string, timeout int, InitialCap int, MaxCap int
+		s.outPool = utils.NewOutPool(
+			*s.cfg.CheckParentInterval,
+			*s.cfg.ParentType == TYPE_TLS,
+			s.cfg.CertBytes, s.cfg.KeyBytes,
+			*s.cfg.Parent,
+			*s.cfg.Timeout,
+			*s.cfg.PoolSize,
+			*s.cfg.PoolSize*2,
+		)
+	}
+}

services/tunnel_bridge.go

@@ -0,0 +1,183 @@
+package services
+
+import (
+	"bufio"
+	"encoding/binary"
+	"fmt"
+	"log"
+	"net"
+	"proxy/utils"
+	"strconv"
+	"sync"
+	"time"
+)
+
+type BridgeItem struct {
+	ServerChn     chan *net.Conn
+	ClientChn     chan *net.Conn
+	ClientControl *net.Conn
+	Once          *sync.Once
+	Key           string
+}
+type TunnelBridge struct {
+	cfg TunnelBridgeArgs
+	br  utils.ConcurrentMap
+}
+
+func NewTunnelBridge() Service {
+	return &TunnelBridge{
+		cfg: TunnelBridgeArgs{},
+		br:  utils.NewConcurrentMap(),
+	}
+}
+
+func (s *TunnelBridge) InitService() {
+
+}
+func (s *TunnelBridge) Check() {
+	if s.cfg.CertBytes == nil || s.cfg.KeyBytes == nil {
+		log.Fatalf("cert and key file required")
+	}
+
+}
+func (s *TunnelBridge) StopService() {
+
+}
+func (s *TunnelBridge) Start(args interface{}) (err error) {
+	s.cfg = args.(TunnelBridgeArgs)
+	s.Check()
+	s.InitService()
+	host, port, _ := net.SplitHostPort(*s.cfg.Local)
+	p, _ := strconv.Atoi(port)
+	sc := utils.NewServerChannel(host, p)
+
+	err = sc.ListenTls(s.cfg.CertBytes, s.cfg.KeyBytes, func(inConn net.Conn) {
+		reader := bufio.NewReader(inConn)
+		var connType uint8
+		err = binary.Read(reader, binary.LittleEndian, &connType)
+		if err != nil {
+			utils.CloseConn(&inConn)
+			return
+		}
+		var key string
+		var connTypeStrMap = map[uint8]string{CONN_SERVER: "server", CONN_CLIENT: "client", CONN_CONTROL: "client"}
+		if connType == CONN_SERVER || connType == CONN_CLIENT || connType == CONN_CONTROL {
+			var keyLength uint16
+			err = binary.Read(reader, binary.LittleEndian, &keyLength)
+			if err != nil {
+				return
+			}
+			_key := make([]byte, keyLength)
+			n, err := reader.Read(_key)
+			if err != nil {
+				return
+			}
+			if n != int(keyLength) {
+				return
+			}
+			key = string(_key)
+			log.Printf("connection from %s , key: %s", connTypeStrMap[connType], key)
+		}
+		switch connType {
+		case CONN_SERVER:
+			s.ServerConn(&inConn, key)
+		case CONN_CLIENT:
+			s.ClientConn(&inConn, key)
+		case CONN_CONTROL:
+			s.ClientControlConn(&inConn, key)
+		default:
+			log.Printf("unkown conn type %d", connType)
+			utils.CloseConn(&inConn)
+		}
+	})
+	if err != nil {
+		return
+	}
+	log.Printf("proxy on tunnel bridge mode %s", (*sc.Listener).Addr())
+	return
+}
+func (s *TunnelBridge) Clean() {
+	s.StopService()
+}
+func (s *TunnelBridge) ClientConn(inConn *net.Conn, key string) {
+	chn, _ := s.ConnChn(key, CONN_CLIENT)
+	chn <- inConn
+}
+func (s *TunnelBridge) ServerConn(inConn *net.Conn, key string) {
+	chn, _ := s.ConnChn(key, CONN_SERVER)
+	chn <- inConn
+}
+func (s *TunnelBridge) ClientControlConn(inConn *net.Conn, key string) {
+	_, item := s.ConnChn(key, CONN_CLIENT)
+	utils.CloseConn(item.ClientControl)
+	if item.ClientControl != nil {
+		*item.ClientControl = *inConn
+	} else {
+		item.ClientControl = inConn
+	}
+	log.Printf("set client control conn,remote: %s", (*inConn).RemoteAddr())
+}
+func (s *TunnelBridge) ConnChn(key string, typ uint8) (chn chan *net.Conn, item *BridgeItem) {
+	s.br.SetIfAbsent(key, &BridgeItem{
+		ServerChn: make(chan *net.Conn, 10000),
+		ClientChn: make(chan *net.Conn, 10000),
+		Once:      &sync.Once{},
+		Key:       key,
+	})
+	_item, _ := s.br.Get(key)
+	item = _item.(*BridgeItem)
+	item.Once.Do(func() {
+		s.ChnDeamon(item)
+	})
+	if typ == CONN_CLIENT {
+		chn = item.ClientChn
+	} else {
+		chn = item.ServerChn
+	}
+	return
+}
+func (s *TunnelBridge) ChnDeamon(item *BridgeItem) {
+	go func() {
+		log.Printf("%s conn chan deamon started", item.Key)
+		for {
+			var clientConn *net.Conn
+			var serverConn *net.Conn
+			serverConn = <-item.ServerChn
+			log.Printf("%s server conn picked up", item.Key)
+		OUT:
+			for {
+				_item, _ := s.br.Get(item.Key)
+				Item := _item.(*BridgeItem)
+				var err error
+				if Item.ClientControl != nil && *Item.ClientControl != nil {
+					_, err = (*Item.ClientControl).Write([]byte{'0'})
+				} else {
+					err = fmt.Errorf("client control conn not exists")
+				}
+				if err != nil {
+					log.Printf("%s client control conn write signal fail, err: %s, retrying...", item.Key, err)
+					utils.CloseConn(Item.ClientControl)
+					*Item.ClientControl = nil
+					Item.ClientControl = nil
+					time.Sleep(time.Second * 3)
+					continue
+				} else {
+					select {
+					case clientConn = <-item.ClientChn:
+						log.Printf("%s client conn picked up", item.Key)
+						break OUT
+					case <-time.After(time.Second * time.Duration(*s.cfg.Timeout*5)):
+						log.Printf("%s client conn picked timeout, retrying...", item.Key)
+					}
+				}
+			}
+
+			utils.IoBind(*serverConn, *clientConn, func(isSrcErr bool, err error) {
+				utils.CloseConn(serverConn)
+				utils.CloseConn(clientConn)
+				log.Printf("%s conn %s - %s - %s - %s released", item.Key, (*serverConn).RemoteAddr(), (*serverConn).LocalAddr(), (*clientConn).LocalAddr(), (*clientConn).RemoteAddr())
+			}, func(i int, b bool) {}, 0)
+			log.Printf("%s conn %s - %s - %s - %s created", item.Key, (*serverConn).RemoteAddr(), (*serverConn).LocalAddr(), (*clientConn).LocalAddr(), (*clientConn).RemoteAddr())
+		}
+	}()
+}

services/tunnel_client.go

@@ -0,0 +1,215 @@
+package services
+
+import (
+	"bytes"
+	"crypto/tls"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"proxy/utils"
+	"time"
+)
+
+type TunnelClient struct {
+	cfg TunnelClientArgs
+}
+
+func NewTunnelClient() Service {
+	return &TunnelClient{
+		cfg: TunnelClientArgs{},
+	}
+}
+
+func (s *TunnelClient) InitService() {
+}
+func (s *TunnelClient) Check() {
+	if *s.cfg.Parent != "" {
+		log.Printf("use tls parent %s", *s.cfg.Parent)
+	} else {
+		log.Fatalf("parent required")
+	}
+	if s.cfg.CertBytes == nil || s.cfg.KeyBytes == nil {
+		log.Fatalf("cert and key file required")
+	}
+}
+func (s *TunnelClient) StopService() {
+}
+func (s *TunnelClient) Start(args interface{}) (err error) {
+	s.cfg = args.(TunnelClientArgs)
+	s.Check()
+	s.InitService()
+
+	for {
+		ctrlConn, err := s.GetInConn(CONN_CONTROL)
+		if err != nil {
+			log.Printf("control connection err: %s", err)
+			time.Sleep(time.Second * 3)
+			utils.CloseConn(&ctrlConn)
+			continue
+		}
+		if *s.cfg.IsUDP {
+			log.Printf("proxy on udp tunnel client mode")
+		} else {
+			log.Printf("proxy on tcp tunnel client mode")
+		}
+		for {
+			signal := make([]byte, 1)
+			if signal[0] == 1 {
+				continue
+			}
+			_, err = ctrlConn.Read(signal)
+			if err != nil {
+				utils.CloseConn(&ctrlConn)
+				log.Printf("read connection signal err: %s", err)
+				break
+			}
+			log.Printf("signal revecived:%s", signal)
+			if *s.cfg.IsUDP {
+				go s.ServeUDP()
+			} else {
+				go s.ServeConn()
+			}
+		}
+	}
+}
+func (s *TunnelClient) Clean() {
+	s.StopService()
+}
+func (s *TunnelClient) GetInConn(typ uint8) (outConn net.Conn, err error) {
+	outConn, err = s.GetConn()
+	if err != nil {
+		err = fmt.Errorf("connection err: %s", err)
+		return
+	}
+	keyBytes := []byte(*s.cfg.Key)
+	keyLength := uint16(len(keyBytes))
+	pkg := new(bytes.Buffer)
+	binary.Write(pkg, binary.LittleEndian, typ)
+	binary.Write(pkg, binary.LittleEndian, keyLength)
+	binary.Write(pkg, binary.LittleEndian, keyBytes)
+	_, err = outConn.Write(pkg.Bytes())
+	if err != nil {
+		err = fmt.Errorf("write connection data err: %s ,retrying...", err)
+		utils.CloseConn(&outConn)
+		return
+	}
+	return
+}
+func (s *TunnelClient) GetConn() (conn net.Conn, err error) {
+	var _conn tls.Conn
+	_conn, err = utils.TlsConnectHost(*s.cfg.Parent, *s.cfg.Timeout, s.cfg.CertBytes, s.cfg.KeyBytes)
+	if err == nil {
+		conn = net.Conn(&_conn)
+	}
+	return
+}
+func (s *TunnelClient) ServeUDP() {
+	var inConn net.Conn
+	var err error
+	for {
+		for {
+			inConn, err = s.GetInConn(CONN_CLIENT)
+			if err != nil {
+				utils.CloseConn(&inConn)
+				log.Printf("connection err: %s, retrying...", err)
+				time.Sleep(time.Second * 3)
+				continue
+			} else {
+				break
+			}
+		}
+		log.Printf("conn created , remote : %s ", inConn.RemoteAddr())
+		for {
+			srcAddr, body, err := utils.ReadUDPPacket(&inConn)
+			if err == io.EOF || err == io.ErrUnexpectedEOF {
+				log.Printf("connection %s released", srcAddr)
+				utils.CloseConn(&inConn)
+				break
+			}
+			//log.Printf("udp packet revecived:%s,%v", srcAddr, body)
+			go s.processUDPPacket(&inConn, srcAddr, body)
+		}
+	}
+}
+func (s *TunnelClient) processUDPPacket(inConn *net.Conn, srcAddr string, body []byte) {
+	dstAddr, err := net.ResolveUDPAddr("udp", *s.cfg.Local)
+	if err != nil {
+		log.Printf("can't resolve address: %s", err)
+		utils.CloseConn(inConn)
+		return
+	}
+	clientSrcAddr := &net.UDPAddr{IP: net.IPv4zero, Port: 0}
+	conn, err := net.DialUDP("udp", clientSrcAddr, dstAddr)
+	if err != nil {
+		log.Printf("connect to udp %s fail,ERR:%s", dstAddr.String(), err)
+		return
+	}
+	conn.SetDeadline(time.Now().Add(time.Millisecond * time.Duration(*s.cfg.Timeout)))
+	_, err = conn.Write(body)
+	if err != nil {
+		log.Printf("send udp packet to %s fail,ERR:%s", dstAddr.String(), err)
+		return
+	}
+	//log.Printf("send udp packet to %s success", dstAddr.String())
+	buf := make([]byte, 512)
+	len, _, err := conn.ReadFromUDP(buf)
+	if err != nil {
+		log.Printf("read udp response from %s fail ,ERR:%s", dstAddr.String(), err)
+		return
+	}
+	respBody := buf[0:len]
+	//log.Printf("revecived udp packet from %s , %v", dstAddr.String(), respBody)
+	_, err = (*inConn).Write(utils.UDPPacket(srcAddr, respBody))
+	if err != nil {
+		log.Printf("send udp response fail ,ERR:%s", err)
+		utils.CloseConn(inConn)
+		return
+	}
+	//log.Printf("send udp response success ,from:%s", dstAddr.String())
+}
+func (s *TunnelClient) ServeConn() {
+	var inConn, outConn net.Conn
+	var err error
+	for {
+		inConn, err = s.GetInConn(CONN_CLIENT)
+		if err != nil {
+			utils.CloseConn(&inConn)
+			log.Printf("connection err: %s, retrying...", err)
+			time.Sleep(time.Second * 3)
+			continue
+		} else {
+			break
+		}
+	}
+
+	i := 0
+	for {
+		i++
+		outConn, err = utils.ConnectHost(*s.cfg.Local, *s.cfg.Timeout)
+		if err == nil || i == 3 {
+			break
+		} else {
+			if i == 3 {
+				log.Printf("connect to %s err: %s, retrying...", *s.cfg.Local, err)
+				time.Sleep(2 * time.Second)
+				continue
+			}
+		}
+	}
+
+	if err != nil {
+		utils.CloseConn(&inConn)
+		utils.CloseConn(&outConn)
+		log.Printf("build connection error, err: %s", err)
+		return
+	}
+
+	utils.IoBind(inConn, outConn, func(isSrcErr bool, err error) {
+		log.Printf("%s conn %s - %s - %s - %s released", *s.cfg.Key, inConn.RemoteAddr(), inConn.LocalAddr(), outConn.LocalAddr(), outConn.RemoteAddr())
+		utils.CloseConn(&inConn)
+		utils.CloseConn(&outConn)
+	}, func(i int, b bool) {}, 0)
+	log.Printf("%s conn %s - %s - %s - %s created", *s.cfg.Key, inConn.RemoteAddr(), inConn.LocalAddr(), outConn.LocalAddr(), outConn.RemoteAddr())
+}

services/tunnel_server.go

@@ -0,0 +1,209 @@
+package services
+
+import (
+	"bufio"
+	"bytes"
+	"crypto/tls"
+	"encoding/binary"
+	"io"
+	"log"
+	"net"
+	"proxy/utils"
+	"runtime/debug"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type TunnelServer struct {
+	cfg    TunnelServerArgs
+	udpChn chan UDPItem
+	sc     utils.ServerChannel
+}
+
+func NewTunnelServer() Service {
+	return &TunnelServer{
+		cfg:    TunnelServerArgs{},
+		udpChn: make(chan UDPItem, 50000),
+	}
+}
+
+type UDPItem struct {
+	packet    *[]byte
+	localAddr *net.UDPAddr
+	srcAddr   *net.UDPAddr
+}
+
+func (s *TunnelServer) InitService() {
+	s.UDPConnDeamon()
+}
+func (s *TunnelServer) Check() {
+	if *s.cfg.Parent != "" {
+		log.Printf("use tls parent %s", *s.cfg.Parent)
+	} else {
+		log.Fatalf("parent required")
+	}
+	if s.cfg.CertBytes == nil || s.cfg.KeyBytes == nil {
+		log.Fatalf("cert and key file required")
+	}
+}
+func (s *TunnelServer) StopService() {
+}
+func (s *TunnelServer) Start(args interface{}) (err error) {
+	s.cfg = args.(TunnelServerArgs)
+	s.Check()
+	s.InitService()
+	host, port, _ := net.SplitHostPort(*s.cfg.Local)
+	p, _ := strconv.Atoi(port)
+	s.sc = utils.NewServerChannel(host, p)
+
+	if *s.cfg.IsUDP {
+		err = s.sc.ListenUDP(func(packet []byte, localAddr, srcAddr *net.UDPAddr) {
+			s.udpChn <- UDPItem{
+				packet:    &packet,
+				localAddr: localAddr,
+				srcAddr:   srcAddr,
+			}
+		})
+		if err != nil {
+			return
+		}
+		log.Printf("proxy on udp tunnel server mode %s", (*s.sc.UDPListener).LocalAddr())
+	} else {
+		err = s.sc.ListenTCP(func(inConn net.Conn) {
+			defer func() {
+				if err := recover(); err != nil {
+					log.Printf("tserver conn handler crashed with err : %s \nstack: %s", err, string(debug.Stack()))
+				}
+			}()
+			var outConn net.Conn
+			for {
+				outConn, err = s.GetOutConn()
+				if err != nil {
+					utils.CloseConn(&outConn)
+					log.Printf("connect to %s fail, err: %s, retrying...", *s.cfg.Parent, err)
+					time.Sleep(time.Second * 3)
+					continue
+				} else {
+					break
+				}
+			}
+
+			utils.IoBind(inConn, outConn, func(isSrcErr bool, err error) {
+				utils.CloseConn(&outConn)
+				utils.CloseConn(&inConn)
+				log.Printf("%s conn %s - %s - %s - %s released", *s.cfg.Key, inConn.RemoteAddr(), inConn.LocalAddr(), outConn.LocalAddr(), outConn.RemoteAddr())
+			}, func(i int, b bool) {}, 0)
+
+			log.Printf("%s conn %s - %s - %s - %s created", *s.cfg.Key, inConn.RemoteAddr(), inConn.LocalAddr(), outConn.LocalAddr(), outConn.RemoteAddr())
+		})
+		if err != nil {
+			return
+		}
+		log.Printf("proxy on tunnel server mode %s", (*s.sc.Listener).Addr())
+	}
+	return
+}
+func (s *TunnelServer) Clean() {
+	s.StopService()
+}
+func (s *TunnelServer) GetOutConn() (outConn net.Conn, err error) {
+	outConn, err = s.GetConn()
+	if err != nil {
+		log.Printf("connection err: %s", err)
+		return
+	}
+	keyBytes := []byte(*s.cfg.Key)
+	keyLength := uint16(len(keyBytes))
+	pkg := new(bytes.Buffer)
+	binary.Write(pkg, binary.LittleEndian, CONN_SERVER)
+	binary.Write(pkg, binary.LittleEndian, keyLength)
+	binary.Write(pkg, binary.LittleEndian, keyBytes)
+	_, err = outConn.Write(pkg.Bytes())
+	if err != nil {
+		log.Printf("write connection data err: %s ,retrying...", err)
+		utils.CloseConn(&outConn)
+		return
+	}
+	return
+}
+func (s *TunnelServer) GetConn() (conn net.Conn, err error) {
+	var _conn tls.Conn
+	_conn, err = utils.TlsConnectHost(*s.cfg.Parent, *s.cfg.Timeout, s.cfg.CertBytes, s.cfg.KeyBytes)
+	if err == nil {
+		conn = net.Conn(&_conn)
+	}
+	return
+}
+func (s *TunnelServer) UDPConnDeamon() {
+	go func() {
+		defer func() {
+			if err := recover(); err != nil {
+				log.Printf("udp conn deamon crashed with err : %s \nstack: %s", err, string(debug.Stack()))
+			}
+		}()
+		var outConn net.Conn
+		var cmdChn = make(chan bool, 1)
+
+		var err error
+		for {
+			item := <-s.udpChn
+		RETRY:
+			if outConn == nil {
+				for {
+					outConn, err = s.GetOutConn()
+					if err != nil {
+						cmdChn <- true
+						outConn = nil
+						utils.CloseConn(&outConn)
+						log.Printf("connect to %s fail, err: %s, retrying...", *s.cfg.Parent, err)
+						time.Sleep(time.Second * 3)
+						continue
+					} else {
+						go func(outConn net.Conn) {
+							go func() {
+								<-cmdChn
+								outConn.Close()
+							}()
+							for {
+								srcAddrFromConn, body, err := utils.ReadUDPPacket(&outConn)
+								if err == io.EOF || err == io.ErrUnexpectedEOF {
+									log.Printf("udp connection deamon exited, %s -> %s", outConn.LocalAddr(), outConn.RemoteAddr())
+									break
+								}
+								if err != nil {
+									log.Printf("parse revecived udp packet fail, err: %s", err)
+									continue
+								}
+								//log.Printf("udp packet revecived over parent , local:%s", srcAddrFromConn)
+								_srcAddr := strings.Split(srcAddrFromConn, ":")
+								if len(_srcAddr) != 2 {
+									log.Printf("parse revecived udp packet fail, addr error : %s", srcAddrFromConn)
+									continue
+								}
+								port, _ := strconv.Atoi(_srcAddr[1])
+								dstAddr := &net.UDPAddr{IP: net.ParseIP(_srcAddr[0]), Port: port}
+								_, err = s.sc.UDPListener.WriteToUDP(body, dstAddr)
+								if err != nil {
+									log.Printf("udp response to local %s fail,ERR:%s", srcAddrFromConn, err)
+									continue
+								}
+								//log.Printf("udp response to local %s success", srcAddrFromConn)
+							}
+						}(outConn)
+						break
+					}
+				}
+			}
+			writer := bufio.NewWriter(outConn)
+			writer.Write(utils.UDPPacket(item.srcAddr.String(), *item.packet))
+			err := writer.Flush()
+			if err != nil {
+				outConn = nil
+				log.Printf("write udp packet to %s fail ,flush err:%s", *s.cfg.Parent, err)
+				goto RETRY
+			}
+			//log.Printf("write packet %v", *item.packet)
+		}
+	}()
+}

services/udp.go

@@ -0,0 +1,211 @@
+package services
+
+import (
+	"bufio"
+	"fmt"
+	"hash/crc32"
+	"io"
+	"log"
+	"net"
+	"proxy/utils"
+	"runtime/debug"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type UDP struct {
+	p       utils.ConcurrentMap
+	outPool utils.OutPool
+	cfg     UDPArgs
+	sc      *utils.ServerChannel
+}
+
+func NewUDP() Service {
+	return &UDP{
+		outPool: utils.OutPool{},
+		p:       utils.NewConcurrentMap(),
+	}
+}
+func (s *UDP) InitService() {
+	if *s.cfg.ParentType != TYPE_UDP {
+		s.InitOutConnPool()
+	}
+}
+func (s *UDP) StopService() {
+	if s.outPool.Pool != nil {
+		s.outPool.Pool.ReleaseAll()
+	}
+}
+func (s *UDP) Start(args interface{}) (err error) {
+	s.cfg = args.(UDPArgs)
+	if *s.cfg.Parent != "" {
+		log.Printf("use %s parent %s", *s.cfg.ParentType, *s.cfg.Parent)
+	} else {
+		log.Fatalf("parent required for udp %s", *s.cfg.Local)
+	}
+
+	s.InitService()
+
+	host, port, _ := net.SplitHostPort(*s.cfg.Local)
+	p, _ := strconv.Atoi(port)
+	sc := utils.NewServerChannel(host, p)
+	s.sc = &sc
+	err = sc.ListenUDP(s.callback)
+	if err != nil {
+		return
+	}
+	log.Printf("udp proxy on %s", (*sc.UDPListener).LocalAddr())
+	return
+}
+
+func (s *UDP) Clean() {
+	s.StopService()
+}
+func (s *UDP) callback(packet []byte, localAddr, srcAddr *net.UDPAddr) {
+	defer func() {
+		if err := recover(); err != nil {
+			log.Printf("udp conn handler crashed with err : %s \nstack: %s", err, string(debug.Stack()))
+		}
+	}()
+	var err error
+	switch *s.cfg.ParentType {
+	case TYPE_TCP:
+		fallthrough
+	case TYPE_TLS:
+		err = s.OutToTCP(packet, localAddr, srcAddr)
+	case TYPE_UDP:
+		err = s.OutToUDP(packet, localAddr, srcAddr)
+	default:
+		err = fmt.Errorf("unkown parent type %s", *s.cfg.ParentType)
+	}
+	if err != nil {
+		log.Printf("connect to %s parent %s fail, ERR:%s", *s.cfg.ParentType, *s.cfg.Parent, err)
+	}
+}
+func (s *UDP) GetConn(connKey string) (conn net.Conn, isNew bool, err error) {
+	isNew = !s.p.Has(connKey)
+	var _conn interface{}
+	if isNew {
+		_conn, err = s.outPool.Pool.Get()
+		if err != nil {
+			return nil, false, err
+		}
+		s.p.Set(connKey, _conn)
+	} else {
+		_conn, _ = s.p.Get(connKey)
+	}
+	conn = _conn.(net.Conn)
+	return
+}
+func (s *UDP) OutToTCP(packet []byte, localAddr, srcAddr *net.UDPAddr) (err error) {
+	numLocal := crc32.ChecksumIEEE([]byte(localAddr.String()))
+	numSrc := crc32.ChecksumIEEE([]byte(srcAddr.String()))
+	mod := uint32(*s.cfg.PoolSize)
+	if mod == 0 {
+		mod = 10
+	}
+	connKey := uint64((numLocal/10)*10 + numSrc%mod)
+	conn, isNew, err := s.GetConn(fmt.Sprintf("%d", connKey))
+	if err != nil {
+		log.Printf("upd get conn to %s parent %s fail, ERR:%s", *s.cfg.ParentType, *s.cfg.Parent, err)
+		return
+	}
+	if isNew {
+		go func() {
+			defer func() {
+				if err := recover(); err != nil {
+					log.Printf("udp conn handler out to tcp crashed with err : %s \nstack: %s", err, string(debug.Stack()))
+				}
+			}()
+			log.Printf("conn %d created , local: %s", connKey, srcAddr.String())
+			for {
+				srcAddrFromConn, body, err := utils.ReadUDPPacket(&conn)
+				if err == io.EOF || err == io.ErrUnexpectedEOF {
+					//log.Printf("connection %d released", connKey)
+					s.p.Remove(fmt.Sprintf("%d", connKey))
+					break
+				}
+				if err != nil {
+					log.Printf("parse revecived udp packet fail, err: %s", err)
+					continue
+				}
+				//log.Printf("udp packet revecived over parent , local:%s", srcAddrFromConn)
+				_srcAddr := strings.Split(srcAddrFromConn, ":")
+				if len(_srcAddr) != 2 {
+					log.Printf("parse revecived udp packet fail, addr error : %s", srcAddrFromConn)
+					continue
+				}
+				port, _ := strconv.Atoi(_srcAddr[1])
+				dstAddr := &net.UDPAddr{IP: net.ParseIP(_srcAddr[0]), Port: port}
+				_, err = s.sc.UDPListener.WriteToUDP(body, dstAddr)
+				if err != nil {
+					log.Printf("udp response to local %s fail,ERR:%s", srcAddr, err)
+					continue
+				}
+				//log.Printf("udp response to local %s success", srcAddr)
+			}
+		}()
+	}
+	//log.Printf("select conn %d , local: %s", connKey, srcAddr.String())
+	writer := bufio.NewWriter(conn)
+	//fmt.Println(conn, writer)
+	writer.Write(utils.UDPPacket(srcAddr.String(), packet))
+	err = writer.Flush()
+	if err != nil {
+		log.Printf("write udp packet to %s fail ,flush err:%s", *s.cfg.Parent, err)
+		return
+	}
+	//log.Printf("write packet %v", packet)
+	return
+}
+func (s *UDP) OutToUDP(packet []byte, localAddr, srcAddr *net.UDPAddr) (err error) {
+	//log.Printf("udp packet revecived:%s,%v", srcAddr, packet)
+	dstAddr, err := net.ResolveUDPAddr("udp", *s.cfg.Parent)
+	if err != nil {
+		log.Printf("resolve udp addr %s fail  fail,ERR:%s", dstAddr.String(), err)
+		return
+	}
+	clientSrcAddr := &net.UDPAddr{IP: net.IPv4zero, Port: 0}
+	conn, err := net.DialUDP("udp", clientSrcAddr, dstAddr)
+	if err != nil {
+		log.Printf("connect to udp %s fail,ERR:%s", dstAddr.String(), err)
+		return
+	}
+	conn.SetDeadline(time.Now().Add(time.Millisecond * time.Duration(*s.cfg.Timeout)))
+	_, err = conn.Write(packet)
+	if err != nil {
+		log.Printf("send udp packet to %s fail,ERR:%s", dstAddr.String(), err)
+		return
+	}
+	//log.Printf("send udp packet to %s success", dstAddr.String())
+	buf := make([]byte, 512)
+	len, _, err := conn.ReadFromUDP(buf)
+	if err != nil {
+		log.Printf("read udp response from %s fail ,ERR:%s", dstAddr.String(), err)
+		return
+	}
+	//log.Printf("revecived udp packet from %s , %v", dstAddr.String(), respBody)
+	_, err = s.sc.UDPListener.WriteToUDP(buf[0:len], srcAddr)
+	if err != nil {
+		log.Printf("send udp response to cluster fail ,ERR:%s", err)
+		return
+	}
+	//log.Printf("send udp response to cluster success ,from:%s", dstAddr.String())
+	return
+}
+func (s *UDP) InitOutConnPool() {
+	if *s.cfg.ParentType == TYPE_TLS || *s.cfg.ParentType == TYPE_TCP {
+		//dur int, isTLS bool, certBytes, keyBytes []byte,
+		//parent string, timeout int, InitialCap int, MaxCap int
+		s.outPool = utils.NewOutPool(
+			*s.cfg.CheckParentInterval,
+			*s.cfg.ParentType == TYPE_TLS,
+			s.cfg.CertBytes, s.cfg.KeyBytes,
+			*s.cfg.Parent,
+			*s.cfg.Timeout,
+			*s.cfg.PoolSize,
+			*s.cfg.PoolSize*2,
+		)
+	}
+}