all: improve the method of import for internal packages

1. Change directory structure and Makefile to let GOPATH=`pwd`, so wherever the project directory is, just use make to build.

src/frp/utils/broadcast/broadcast.go

@@ -0,0 +1,73 @@
+package broadcast
+
+type Broadcast struct {
+	listeners  []chan interface{}
+	reg        chan (chan interface{})
+	unreg      chan (chan interface{})
+	in         chan interface{}
+	stop       chan int64
+	stopStatus bool
+}
+
+func NewBroadcast() *Broadcast {
+	b := &Broadcast{
+		listeners:  make([]chan interface{}, 0),
+		reg:        make(chan (chan interface{})),
+		unreg:      make(chan (chan interface{})),
+		in:         make(chan interface{}),
+		stop:       make(chan int64),
+		stopStatus: false,
+	}
+
+	go func() {
+		for {
+			select {
+			case l := <-b.unreg:
+				// remove L from b.listeners
+				// this operation is slow: O(n) but not used frequently
+				// unlike iterating over listeners
+				oldListeners := b.listeners
+				b.listeners = make([]chan interface{}, 0, len(oldListeners))
+				for _, oldL := range oldListeners {
+					if l != oldL {
+						b.listeners = append(b.listeners, oldL)
+					}
+				}
+
+			case l := <-b.reg:
+				b.listeners = append(b.listeners, l)
+
+			case item := <-b.in:
+				for _, l := range b.listeners {
+					l <- item
+				}
+
+			case _ = <-b.stop:
+				b.stopStatus = true
+				break
+			}
+		}
+	}()
+
+	return b
+}
+
+func (b *Broadcast) In() chan interface{} {
+	return b.in
+}
+
+func (b *Broadcast) Reg() chan interface{} {
+	listener := make(chan interface{})
+	b.reg <- listener
+	return listener
+}
+
+func (b *Broadcast) UnReg(listener chan interface{}) {
+	b.unreg <- listener
+}
+
+func (b *Broadcast) Close() {
+	if b.stopStatus == false {
+		b.stop <- 1
+	}
+}

src/frp/utils/broadcast/broadcast_test.go

@@ -0,0 +1,63 @@
+package broadcast
+
+import (
+	"sync"
+	"testing"
+	"time"
+)
+
+var (
+	totalNum int = 5
+	succNum  int = 0
+	mutex    sync.Mutex
+)
+
+func TestBroadcast(t *testing.T) {
+	b := NewBroadcast()
+	if b == nil {
+		t.Errorf("New Broadcast error, nil return")
+	}
+	defer b.Close()
+
+	var wait sync.WaitGroup
+	wait.Add(totalNum)
+	for i := 0; i < totalNum; i++ {
+		go worker(b, &wait)
+	}
+
+	time.Sleep(1e6 * 20)
+	msg := "test"
+	b.In() <- msg
+
+	wait.Wait()
+	if succNum != totalNum {
+		t.Errorf("TotalNum %d, FailNum(timeout) %d", totalNum, totalNum-succNum)
+	}
+}
+
+func worker(b *Broadcast, wait *sync.WaitGroup) {
+	defer wait.Done()
+	msgChan := b.Reg()
+
+	// exit if nothing got in 2 seconds
+	timeout := make(chan bool, 1)
+	go func() {
+		time.Sleep(time.Duration(2) * time.Second)
+		timeout <- true
+	}()
+
+	select {
+	case item := <-msgChan:
+		msg := item.(string)
+		if msg == "test" {
+			mutex.Lock()
+			succNum++
+			mutex.Unlock()
+		} else {
+			break
+		}
+
+	case <-timeout:
+		break
+	}
+}

src/frp/utils/conn/conn.go

@@ -0,0 +1,149 @@
+package conn
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"net"
+	"sync"
+
+	"frp/utils/log"
+)
+
+type Listener struct {
+	addr      net.Addr
+	l         *net.TCPListener
+	conns     chan *Conn
+	closeFlag bool
+}
+
+func Listen(bindAddr string, bindPort int64) (l *Listener, err error) {
+	tcpAddr, err := net.ResolveTCPAddr("tcp4", fmt.Sprintf("%s:%d", bindAddr, bindPort))
+	listener, err := net.ListenTCP("tcp", tcpAddr)
+	if err != nil {
+		return l, err
+	}
+
+	l = &Listener{
+		addr:      listener.Addr(),
+		l:         listener,
+		conns:     make(chan *Conn),
+		closeFlag: false,
+	}
+
+	go func() {
+		for {
+			conn, err := l.l.AcceptTCP()
+			if err != nil {
+				if l.closeFlag {
+					return
+				}
+				continue
+			}
+
+			c := &Conn{
+				TcpConn:   conn,
+				closeFlag: false,
+			}
+			c.Reader = bufio.NewReader(c.TcpConn)
+			l.conns <- c
+		}
+	}()
+	return l, err
+}
+
+// wait util get one new connection or listener is closed
+// if listener is closed, err returned
+func (l *Listener) GetConn() (conn *Conn, err error) {
+	var ok bool
+	conn, ok = <-l.conns
+	if !ok {
+		return conn, fmt.Errorf("channel close")
+	}
+	return conn, nil
+}
+
+func (l *Listener) Close() {
+	if l.l != nil && l.closeFlag == false {
+		l.closeFlag = true
+		l.l.Close()
+		close(l.conns)
+	}
+}
+
+// wrap for TCPConn
+type Conn struct {
+	TcpConn   *net.TCPConn
+	Reader    *bufio.Reader
+	closeFlag bool
+}
+
+func ConnectServer(host string, port int64) (c *Conn, err error) {
+	c = &Conn{}
+	servertAddr, err := net.ResolveTCPAddr("tcp4", fmt.Sprintf("%s:%d", host, port))
+	if err != nil {
+		return
+	}
+	conn, err := net.DialTCP("tcp", nil, servertAddr)
+	if err != nil {
+		return
+	}
+	c.TcpConn = conn
+	c.Reader = bufio.NewReader(c.TcpConn)
+	c.closeFlag = false
+	return c, nil
+}
+
+func (c *Conn) GetRemoteAddr() (addr string) {
+	return c.TcpConn.RemoteAddr().String()
+}
+
+func (c *Conn) GetLocalAddr() (addr string) {
+	return c.TcpConn.LocalAddr().String()
+}
+
+func (c *Conn) ReadLine() (buff string, err error) {
+	buff, err = c.Reader.ReadString('\n')
+	if err == io.EOF {
+		c.closeFlag = true
+	}
+	return buff, err
+}
+
+func (c *Conn) Write(content string) (err error) {
+	_, err = c.TcpConn.Write([]byte(content))
+	return err
+}
+
+func (c *Conn) Close() {
+	if c.TcpConn != nil && c.closeFlag == false {
+		c.closeFlag = true
+		c.TcpConn.Close()
+	}
+}
+
+func (c *Conn) IsClosed() bool {
+	return c.closeFlag
+}
+
+// will block until connection close
+func Join(c1 *Conn, c2 *Conn) {
+	var wait sync.WaitGroup
+	pipe := func(to *Conn, from *Conn) {
+		defer to.Close()
+		defer from.Close()
+		defer wait.Done()
+
+		var err error
+		_, err = io.Copy(to.TcpConn, from.TcpConn)
+		if err != nil {
+			log.Warn("join conns error, %v", err)
+		}
+	}
+
+	wait.Add(2)
+	go pipe(c1, c2)
+	go pipe(c2, c1)
+	wait.Wait()
+	return
+}

src/frp/utils/log/log.go

@@ -0,0 +1,64 @@
+package log
+
+import (
+	"github.com/astaxie/beego/logs"
+)
+
+var Log *logs.BeeLogger
+
+func init() {
+	Log = logs.NewLogger(1000)
+	Log.EnableFuncCallDepth(true)
+	Log.SetLogFuncCallDepth(Log.GetLogFuncCallDepth() + 1)
+}
+
+func InitLog(logWay string, logFile string, logLevel string) {
+	SetLogFile(logWay, logFile)
+	SetLogLevel(logLevel)
+}
+
+// logWay: such as file or console
+func SetLogFile(logWay string, logFile string) {
+	if logWay == "console" {
+		Log.SetLogger("console", "")
+	} else {
+		Log.SetLogger("file", `{"filename": "`+logFile+`"}`)
+	}
+}
+
+// value: error, warning, info, debug
+func SetLogLevel(logLevel string) {
+	level := 4 // warning
+
+	switch logLevel {
+	case "error":
+		level = 3
+	case "warn":
+		level = 4
+	case "info":
+		level = 6
+	case "debug":
+		level = 7
+	default:
+		level = 4
+	}
+
+	Log.SetLevel(level)
+}
+
+// wrap log
+func Error(format string, v ...interface{}) {
+	Log.Error(format, v...)
+}
+
+func Warn(format string, v ...interface{}) {
+	Log.Warn(format, v...)
+}
+
+func Info(format string, v ...interface{}) {
+	Log.Info(format, v...)
+}
+
+func Debug(format string, v ...interface{}) {
+	Log.Debug(format, v...)
+}

src/frp/utils/pcrypto/pcrypto.go

@@ -0,0 +1,87 @@
+package pcrypto
+
+import (
+	"bytes"
+	"compress/gzip"
+	"crypto/aes"
+	"crypto/cipher"
+	"encoding/base64"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io/ioutil"
+)
+
+type Pcrypto struct {
+	pkey []byte
+	paes cipher.Block
+}
+
+func (pc *Pcrypto) Init(key []byte) error {
+	var err error
+	pc.pkey = PKCS7Padding(key, aes.BlockSize)
+	pc.paes, err = aes.NewCipher(pc.pkey)
+
+	return err
+}
+
+func (pc *Pcrypto) Encrypto(src []byte) ([]byte, error) {
+	// aes
+	src = PKCS7Padding(src, aes.BlockSize)
+	blockMode := cipher.NewCBCEncrypter(pc.paes, pc.pkey)
+	crypted := make([]byte, len(src))
+	blockMode.CryptBlocks(crypted, src)
+
+	// gzip
+	var zbuf bytes.Buffer
+	zwr := gzip.NewWriter(&zbuf)
+	defer zwr.Close()
+	zwr.Write(crypted)
+	zwr.Flush()
+
+	// base64
+	return []byte(base64.StdEncoding.EncodeToString(zbuf.Bytes())), nil
+}
+
+func (pc *Pcrypto) Decrypto(str []byte) ([]byte, error) {
+	// base64
+	data, err := base64.StdEncoding.DecodeString(string(str))
+	if err != nil {
+		return nil, err
+	}
+
+	// gunzip
+	zbuf := bytes.NewBuffer(data)
+	zrd, _ := gzip.NewReader(zbuf)
+	defer zrd.Close()
+	data, _ = ioutil.ReadAll(zrd)
+
+	// aes
+	decryptText, err := hex.DecodeString(fmt.Sprintf("%x", data))
+	if err != nil {
+		return nil, err
+	}
+
+	if len(decryptText)%aes.BlockSize != 0 {
+		return nil, errors.New("crypto/cipher: ciphertext is not a multiple of the block size")
+	}
+
+	blockMode := cipher.NewCBCDecrypter(pc.paes, pc.pkey)
+
+	blockMode.CryptBlocks(decryptText, decryptText)
+	decryptText = PKCS7UnPadding(decryptText)
+
+	return decryptText, nil
+}
+
+func PKCS7Padding(ciphertext []byte, blockSize int) []byte {
+	padding := blockSize - len(ciphertext)%blockSize
+	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
+	return append(ciphertext, padtext...)
+}
+
+func PKCS7UnPadding(origData []byte) []byte {
+	length := len(origData)
+	unpadding := int(origData[length-1])
+	return origData[:(length - unpadding)]
+}

src/frp/utils/pcrypto/pcrypto_test.go

@@ -0,0 +1,47 @@
+package pcrypto
+
+import (
+	"crypto/aes"
+	"fmt"
+	"testing"
+)
+
+func TestEncrypto(t *testing.T) {
+	pp := new(Pcrypto)
+	pp.Init([]byte("Hana"))
+	res, err := pp.Encrypto([]byte("Just One Test!"))
+	if err != nil {
+		t.Error(err)
+	}
+
+	fmt.Printf("[%x]\n", res)
+}
+
+func TestDecrypto(t *testing.T) {
+	pp := new(Pcrypto)
+	pp.Init([]byte("Hana"))
+	res, err := pp.Encrypto([]byte("Just One Test!"))
+	if err != nil {
+		t.Error(err)
+	}
+
+	res, err = pp.Decrypto(res)
+	if err != nil {
+		t.Error(err)
+	}
+
+	fmt.Printf("[%s]\n", string(res))
+}
+
+func TestPKCS7Padding(t *testing.T) {
+	ltt := []byte("Test_PKCS7Padding")
+	ltt = PKCS7Padding(ltt, aes.BlockSize)
+	fmt.Printf("[%x]\n", (ltt))
+}
+
+func TestPKCS7UnPadding(t *testing.T) {
+	ltt := []byte("Test_PKCS7Padding")
+	ltt = PKCS7Padding(ltt, aes.BlockSize)
+	ltt = PKCS7UnPadding(ltt)
+	fmt.Printf("[%x]\n", ltt)
+}