transx/tcp.go

package main

import (
	"github.com/TransX/tscipher"
	//	"io"
	"log"
	"net"
)

type TransTCP struct {
	//	serverConn *net.Conn
	//	clientConn net.Conn
	//	cache      []byte
}

func NewTransTCP() *TransTCP {
	return &TransTCP{}
}

func (this *TransTCP) createTCPClient(ip, port string) (conn net.Conn, err error) {
	conn, err = net.Dial("tcp4", ip+":"+port)
	if err == nil {

	} else {
		conn = nil
	}
	return
}

func (this *TransTCP) createTCPListener(ip, port string) (listen net.Listener, err error) {
	listener, _err := net.Listen("tcp4", ip+":"+port)
	if _err == nil {
		listen = listener
		err = nil
		return
	} else {
		listen = nil
		err = _err
	}
	return
}

func (this *TransTCP) tunnel(src, dest net.Conn) {
	defer func() {
		if r := recover(); r != nil {
			if src != nil {
				src.Close()
			}
			if dest != nil {
				dest.Close()
			}

		}
	}()
	cache := make([]byte, 1024*128) //128kB
	for {
		//构建Carrier
		revCarrier := &tscipher.Carrier{
			src,
			tscipher.NewCipher("default"),
			cache,
		}
		nByte, err := tscipher.ReceiveData(revCarrier)
		if err != nil {
			log.Panicln("Read panic", err, src.RemoteAddr().String())
		}
		log.Println("Reived ", string(cache[:nByte]))
		sendCarrier := &tscipher.Carrier{
			dest,
			tscipher.NewCipher("default"),
			cache,
		}
		_, err = tscipher.SendData(sendCarrier, nByte)
		log.Println("Write")
		if err != nil {
			log.Panicln("Write panic", err, dest.RemoteAddr().String())
		}
	}

}

func (this *TransTCP) Start(listenPort, destIP, destPort string) {

	listener, err := this.createTCPListener("0.0.0.0", listenPort)
	if err != nil {
		log.Fatalln("Failed to create listener.", err)
	}
	for {
		if listenerConn, err := listener.Accept(); err == nil {
			log.Println("Incoming ", listenerConn.RemoteAddr().String())
			//创建到目标的连接
			destConn, err := this.createTCPClient(destIP, destPort)
			if err != nil {
				log.Fatalln("Failed to connect to destination.", err)
			}
			log.Println("Dial", destConn.RemoteAddr().String())
			go this.tunnel(listenerConn, destConn)
			go this.tunnel(destConn, listenerConn)
		} else {
			log.Println("Failed to accept incoming connection.", err)

		}
	}
}