1.加了几个测试文件

2.加了Windows下的批处理文件
3.找到bug了。server端加密后发送，但是client端第一次只接收到一半，只对于这一半解密，下次再收到后面一段，再解密，所以解密有问题。

Signed-off-by: dmy@lab <dmy@lab.com>

client.bat

@@ -0,0 +1 @@
+.\TransX -destip 127.0.0.1 -destport 1082 -listenport 1080 -encrypt client

main_test.go

@@ -9,7 +9,78 @@ import (
 	"time"
 )
 
-func server(t *testing.T) {
+func serverBin(t *testing.T) {
+	file, _ := os.Open("test/hex.bin")
+	reader := bufio.NewReader(file)
+	listener, err := net.Listen("tcp4", "127.0.0.1:1244")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var nCount byte
+	nCount = 0
+	for {
+		conn, err := listener.Accept()
+		log.Info("Test Server Incoming %s", conn.RemoteAddr().String())
+		if err != nil {
+			log.Error(err.Error())
+		}
+		bytes := make([]byte, 1024*32)
+		n, err := conn.Read(bytes)
+		if err != nil {
+			log.Error("Test Server read %", err)
+			break
+		}
+		log.Info("Test Server read %d bytes from %s", n, conn.RemoteAddr().String())
+		if bytes[0] != nCount {
+			log.Error("package sequence not right. it's %d. should be %d", bytes[0], nCount)
+		}
+
+		log.Info("Test Server receive with count %d", nCount)
+
+		nCount++
+		binBytes := make([]byte, n-1)
+		pos, _ := file.Seek(0, 1)
+		log.Info("Test Server file pos %d", pos)
+		nBinByte, err := reader.Read(binBytes)
+		if err != nil {
+			log.Error("Test Server read bin %s", err.Error())
+			break
+		}
+		log.Info("Test Server read file %d, it should be %d", nBinByte, n-1)
+		for {
+			if nBinByte != n-1 {
+				log.Info("Test Server read file %d, it should be %d", nBinByte, n-1)
+				file.Seek(pos, 0)
+				nBinByte, err = reader.Read(binBytes)
+				if err != nil {
+					log.Error("Test Server read bin %s", err.Error())
+					break
+				}
+				continue
+			}
+			break
+		}
+
+		for i := 0; i < nBinByte; i++ {
+			if binBytes[i] != bytes[i+1] {
+				log.Error("Test Server read not consistent at %d. read:%c receive:%c", i, binBytes[i], bytes[i+1])
+			}
+
+		}
+		log.Info("Test Server. All Matches.")
+
+		//		log.Info("Test Server Receive %s", string(bytes[:n]))
+		_, err = conn.Write([]byte("OK"))
+		log.Info("Test Server write")
+		if err != nil {
+			t.Fatal(err)
+		}
+		conn.Close()
+		log.Info("Test Server closed")
+	}
+}
+
+func serverText(t *testing.T) {
 	file, _ := os.Open("test/cipher.txt")
 	reader := bufio.NewReader(file)
 	listener, err := net.Listen("tcp4", "127.0.0.1:1244")
@@ -30,8 +101,8 @@ func server(t *testing.T) {
 			break
 		}
 		if string(bytes[:n]) != line {
-			log.Error("cipher failed %s", string(bytes[:n]))
-			log.Error("%s %s", len(bytes[:n]), len([]byte(line)))
+			t.Fatalf("cipher failed %s", string(bytes[:n]))
+			t.Fatalf("%s %s", len(bytes[:n]), len([]byte(line)))
 			for i := 0; i < n; i++ {
 				log.Error("%d", bytes[i]-[]byte(line)[i])
 			}
@@ -48,7 +119,47 @@ func server(t *testing.T) {
 	}
 }
 
-func client(t *testing.T) {
+func clientBin(t *testing.T) {
+	file, _ := os.Open("test/hex.bin")
+	reader := bufio.NewReader(file)
+	var nCount byte
+	nCount = 0
+	for {
+		conn, err := net.Dial("tcp4", "127.0.0.1:1200")
+		if err != nil {
+			t.Fatal(err)
+		}
+		binBytes := make([]byte, 1024*4)
+		nBinBytes, err := reader.Read(binBytes)
+		if err != nil {
+			log.Error("client read %", err)
+
+		}
+		toBinWrite := make([]byte, len(binBytes)+1)
+		copy(toBinWrite[1:], binBytes[:nBinBytes])
+		toBinWrite[0] = nCount
+		n, _ := conn.Write(toBinWrite)
+		if n != nBinBytes+1 {
+			log.Error("client not write enough bytes")
+		}
+		//		log.Info("Test Client write %s", string(binBytes[:n]))
+		log.Info("Test Client write with count %d", nCount)
+		nCount++
+		bytes := make([]byte, 1024*32)
+		n, err = conn.Read(bytes)
+		log.Info("Test Client read")
+		if err != nil {
+			t.Fatal(err)
+		}
+		log.Info("Test Client Receive %s", bytes[:n])
+		time.Sleep(time.Second * 2)
+		conn.Close()
+		log.Info("Test Client closed")
+
+	}
+}
+
+func clientText(t *testing.T) {
 	file, _ := os.Open("test/cipher.txt")
 	reader := bufio.NewReader(file)
 	for {
@@ -82,8 +193,8 @@ func client(t *testing.T) {
 func TestTunnel(t *testing.T) {
 	log.LogTo("log.txt", "INFO")
 	log.Info("Test Start testing.")
-	go server(t)
-	go client(t)
+	go serverBin(t)
+	go clientBin(t)
 	trans1 := NewTransTCP()
 	go trans1.Start("1200", "127.0.0.1", "1201", "client")
 	trans2 := NewTransTCP()

server.bat

@@ -0,0 +1 @@
+.\TransX -destip 127.0.0.1 -destport 1084 -listenport 1082 -encrypt server

tcp.go

@@ -62,7 +62,7 @@ func (this *TransTCP) tunnel(src, dest net.Conn, id string, encrypDirection stri
 
 		}
 	}()
-	cache := make([]byte, 1024*32) //128kB
+	cache := make([]byte, 1024*128) //128kB
 	for {
 		//构建Carrier
 		revCarrier := &tscipher.Carrier{
@@ -79,7 +79,7 @@ func (this *TransTCP) tunnel(src, dest net.Conn, id string, encrypDirection stri
 		if err != nil {
 			log.Panic("Read panic. Tunnel id: %s. Remote Add: %s. Err:%s", id, src.RemoteAddr().String(), err)
 		}
-		log.Info("Reived %d bytes. Tunnel: id %s", nByte, id)
+		log.Info("Reived %d bytes from %s. Tunnel: id %s", nByte, src.RemoteAddr().String(), id)
 		log.Debug("Reived %s %s", id, cache[:nByte])
 		sendCarrier := &tscipher.Carrier{
 			dest,
@@ -91,7 +91,7 @@ func (this *TransTCP) tunnel(src, dest net.Conn, id string, encrypDirection stri
 			log.Debug("Write not crypted. Tunnel: %s", id)
 		}
 		_, err = tscipher.SendData(sendCarrier, nByte)
-		log.Info("Write %d bytes. Tunnel: %s", nByte, id)
+		log.Info("Write %d bytes from %s to %s. Tunnel: %s", nByte, dest.LocalAddr(), dest.RemoteAddr().String(), id)
 		log.Debug("Write %s %s", id, cache[:nByte])
 		if err != nil {
 			log.Panic("Write panic. ID: %s, Err: %s, Remote Add: %s", id, err, dest.RemoteAddr().String())

tscipher/cipher.go

@@ -43,6 +43,14 @@ func SendData(carrier *Carrier, nByte int) (n int, err error) {
 	return
 }
 
+func SendData2(carrier *Carrier, nByte int) (n int, err error) {
+	n, err = carrier.Conn.Write(carrier.Cache[:nByte])
+	if err != nil {
+		return
+	}
+	return
+}
+
 func ReceiveData(carrier *Carrier) (n int, err error) {
 	n, err = carrier.Conn.Read(carrier.Cache)
 	if err != nil {
@@ -60,3 +68,12 @@ func ReceiveData(carrier *Carrier) (n int, err error) {
 	}
 	return
 }
+
+func ReceiveData2(carrier *Carrier) (n int, err error) {
+	n, err = carrier.Conn.Read(carrier.Cache)
+	if err != nil {
+		n = 0
+		return
+	}
+	return
+}