Massiv refactoring

app.toml

@@ -1,6 +1,6 @@
 [application]
-    key = "server.key"
-    crt = "server.crt"
+    key = "../server.key"
+    crt = "../server.crt"
     log_location = "app.log"
     log_level = 9
 [tcp_cli_test]

lib/net/common/ethernet_frame.go

@@ -1,4 +1,4 @@
-package net
+package common
 
 import "net"
 

lib/net/common/ethertypes.go

@@ -1,4 +1,4 @@
-package net
+package common
 
 type Ethertype [2]byte
 

lib/net/interface/common/tunnel_interface_client.go

@@ -0,0 +1,9 @@
+package common
+
+import (
+	"net"
+)
+
+type TunnelInterfaceClient interface {
+	HandleConnection(conn net.Conn, tconn net.Conn) error
+}

lib/net/interface/common/tunnel_interface_server.go

@@ -1,7 +1,7 @@
-package net
+package common
 
 import "net"
 
-type Vpnserver interface {
+type TunnelInterfaceServer interface {
 	HandleConnection(conn net.Conn) error
 }

lib/net/interface/socks/socks_client.go

@@ -0,0 +1,88 @@
+package socks
+
+import (
+	icommon "hbx.ir/stunning/lib/net/interface/common"
+	tcommon "hbx.ir/stunning/lib/net/tunnel/common"
+	"log"
+	"net"
+)
+
+type SocksClient struct {
+	icommon.TunnelInterfaceClient
+	address    string
+	tun_dialer tcommon.TunnelDialer
+	saddress   string
+	listen     net.Listener
+}
+
+func GetSocksClient(url, surl string, tls_dialer tcommon.TunnelDialer) *SocksClient {
+	s := &SocksClient{}
+	s.address = url
+	s.saddress = surl
+	s.tun_dialer = tls_dialer
+	listen, err := net.Listen("tcp", s.address)
+	if err != nil {
+		log.Panic(err)
+	}
+	s.listen = listen
+	go s.waiting_for_connection()
+	return s
+}
+
+func (t *SocksClient) waiting_for_connection() {
+	for {
+		conn, err := t.listen.Accept()
+		if err != nil {
+			log.Fatalln(err)
+			continue
+		}
+		sconn, serr := t.tun_dialer.Dial("tcp", t.saddress)
+		if serr != nil {
+			log.Fatalln(serr)
+			continue
+		}
+		go t.HandleConnection(conn, sconn)
+	}
+}
+
+func (t *SocksClient) HandleConnection(conn net.Conn, tconn net.Conn) error {
+	log.Printf("Socket to %s handling connection \n", t.address)
+	go tcp_reader(conn, tconn)
+	tcp_writer(conn, tconn)
+	return nil
+}
+
+func tcp_reader(conn net.Conn, tconn net.Conn) {
+	for {
+		buff := make([]byte, 1024)
+		n, err := conn.Read(buff)
+		if err != nil {
+			log.Fatal(err)
+		}
+		buff = buff[:n]
+		wn, werr := tconn.Write(buff)
+		if werr != nil || wn != len(buff) {
+			log.Panicln(werr)
+			log.Printf("wn : %d, n: %d \n", wn, n)
+		}
+		log.Printf("%s : %d bytes wrote to socket", tconn.RemoteAddr().String(), wn)
+	}
+}
+
+func tcp_writer(conn net.Conn, tconn net.Conn) {
+	for {
+		buff := make([]byte, 1024)
+		n, err := tconn.Read(buff)
+		if err != nil {
+			log.Fatal(err)
+		}
+		buff = buff[:n]
+		wn, werr := conn.Write(buff)
+		if werr != nil || wn != len(buff) {
+			log.Panicln(werr)
+			log.Printf("wn : %d, n: %d \n", wn, n)
+		}
+		log.Printf("%s : %d bytes wrote to socket", conn.RemoteAddr().String(), wn)
+	}
+}
+

lib/net/interface/socks/socks_server.go

@@ -1,19 +1,20 @@
-package net
+package socks
 
 import (
 	"github.com/getlantern/go-socks5"
+	icommon "hbx.ir/stunning/lib/net/interface/common"
 	"log"
 	"net"
 )
 
-type socks_server struct {
-	Vpnserver
+type SocksServer struct {
+	icommon.TunnelInterfaceServer
 	conf   *socks5.Config
 	server *socks5.Server
 }
 
-func GetSocksServer() *socks_server {
-	s := &socks_server{}
+func GetSocksServer() SocksServer {
+	s := SocksServer{}
 	s.conf = &socks5.Config{}
 	server, err := socks5.New(s.conf)
 	if err != nil {
@@ -23,7 +24,7 @@ func GetSocksServer() *socks_server {
 	return s
 }
 
-func (s *socks_server) HandleConnection(conn net.Conn) error {
+func (s SocksServer) HandleConnection(conn net.Conn) error {
 	log.Println("Serving connection")
 	return s.server.ServeConn(conn)
 }

lib/net/interface/tcp/tcp_client.go

@@ -0,0 +1,53 @@
+package tcp
+
+import (
+	icommon "hbx.ir/stunning/lib/net/interface/common"
+	tcommon "hbx.ir/stunning/lib/net/tunnel/common"
+	"log"
+	"net"
+)
+
+type TcpClient struct {
+	icommon.TunnelInterfaceClient
+	address    string
+	tun_dialer tcommon.TunnelDialer
+	saddress   string
+	listen     net.Listener
+}
+
+func GetTcpClient(url, surl string, tls_dialer tcommon.TunnelDialer) *TcpClient {
+	s := &TcpClient{}
+	s.address = url
+	s.saddress = surl
+	s.tun_dialer = tls_dialer
+	listen, err := net.Listen("tcp", s.address)
+	if err != nil {
+		log.Panic(err)
+	}
+	s.listen = listen
+	go s.waiting_for_connection()
+	return s
+}
+
+func (t *TcpClient) waiting_for_connection() {
+	for {
+		conn, err := t.listen.Accept()
+		if err != nil {
+			log.Fatalln(err)
+			continue
+		}
+		sconn, serr := t.tun_dialer.Dial("tcp", t.saddress)
+		if serr != nil {
+			log.Fatalln(serr)
+			continue
+		}
+		go t.HandleConnection(conn, sconn)
+	}
+}
+
+func (t *TcpClient) HandleConnection(conn net.Conn, tconn net.Conn) error {
+	log.Printf("Socket to %s handling connection \n", t.address)
+	go tcp_reader(conn, tconn)
+	tcp_writer(conn, tconn)
+	return nil
+}

lib/net/interface/tcp/tcp_server.go

@@ -1,18 +1,19 @@
-package net
+package tcp
 
 import (
+	icommon "hbx.ir/stunning/lib/net/interface/common"
 	"log"
 	"net"
 )
 
-type tcp_server struct {
-	Vpnserver
+type TcpServer struct {
+	icommon.TunnelInterfaceServer
 	address string
 	conn    net.Conn
 }
 
-func GetTcpServer(url string) *tcp_server {
-	s := &tcp_server{}
+func GetTcpServer(url string) TcpServer {
+	s := TcpServer{}
 	s.address = url
 
 	conn, err := net.Dial("tcp", s.address)
@@ -26,14 +27,14 @@ func GetTcpServer(url string) *tcp_server {
 	return s
 }
 
-func (t *tcp_server) HandleConnection(conn net.Conn) error {
+func (t TcpServer) HandleConnection(conn net.Conn) error {
 	log.Printf("Socket to %s handling connection \n", t.address)
-	go tcp_server_reader(conn, t.conn)
-	tcp_server_writer(conn, t.conn)
+	go tcp_reader(conn, t.conn)
+	tcp_writer(conn, t.conn)
 	return nil
 }
 
-func tcp_server_reader(conn net.Conn, tconn net.Conn) {
+func tcp_reader(conn net.Conn, tconn net.Conn) {
 	for {
 		buff := make([]byte, 1024)
 		n, err := conn.Read(buff)
@@ -50,7 +51,7 @@ func tcp_server_reader(conn net.Conn, tconn net.Conn) {
 	}
 }
 
-func tcp_server_writer(conn net.Conn, tconn net.Conn) {
+func tcp_writer(conn net.Conn, tconn net.Conn) {
 	for {
 		buff := make([]byte, 1024)
 		n, err := tconn.Read(buff)

lib/net/interface/tun/tun_iface.go

@@ -1,15 +1,18 @@
-package net
+package tun
 
 import (
 	"github.com/songgao/water"
+	"hbx.ir/stunning/lib/net/common"
+	icommon "hbx.ir/stunning/lib/net/interface/common"
 	"log"
 	"net"
 	"os"
 	"os/exec"
 )
 
-type tun_interface struct {
-	Vpnserver
+type TunInterface struct {
+	icommon.TunnelInterfaceServer
+	icommon.TunnelInterfaceClient
 	conf  TunConfig
 	iface *water.Interface
 	//nat map[net.IP]
@@ -22,7 +25,7 @@ type TunConfig struct {
 	MTU     string
 }
 
-func GetTunIface(config TunConfig) *tun_interface {
+func GetTunIface(config TunConfig) TunInterface {
 	ifce, err := water.New(water.Config{
 		DeviceType: config.DevType,
 	})
@@ -35,22 +38,22 @@ func GetTunIface(config TunConfig) *tun_interface {
 		log.Fatal(err)
 	}
 
-	iface := &tun_interface{
+	iface := TunInterface{
 		iface: ifce,
 		conf:  config,
 	}
 	return iface
 }
 
-func (t *tun_interface) HandleConnection(conn net.Conn) error {
+func (t TunInterface) HandleConnection(conn net.Conn) error {
 	log.Printf("Tun iface %s handling new connection \n", t.iface.Name())
 	go t.reader(conn)
 	t.writer(conn)
 	return nil
 }
 
-func (t *tun_interface) reader(conn net.Conn) {
-	var frame Frame
+func (t *TunInterface) reader(conn net.Conn) {
+	var frame common.Frame
 
 	for {
 		frame.Resize(1500)
@@ -71,8 +74,8 @@ func (t *tun_interface) reader(conn net.Conn) {
 	}
 }
 
-func (t *tun_interface) writer(conn net.Conn) {
-	var frame Frame
+func (t *TunInterface) writer(conn net.Conn) {
+	var frame common.Frame
 	for {
 		frame.Resize(1500)
 		n, err := conn.Read([]byte(frame))

lib/net/interface/udp/udp_client.go

@@ -1,17 +1,18 @@
-package net
+package udp
 
 import (
-	"log"
-	"net"
 	"fmt"
 	"hbx.ir/stunning/lib/utils"
+	"log"
+	"net"
 	"strconv"
-	//"encoding/binary"
+	icommon "hbx.ir/stunning/lib/net/interface/common"
 )
 
 type udp_client struct {
-	address    string
-	conn *net.UDPConn
+	icommon.TunnelInterfaceClient
+	address  string
+	conn     *net.UDPConn
 	replyMap []string
 }
 
@@ -39,8 +40,7 @@ func (c *udp_client) HandleConnection(conn net.Conn) error {
 	return nil
 }
 
-
-func (c *udp_client)udp_client_reader(conn net.Conn) {
+func (c *udp_client) udp_client_reader(conn net.Conn) {
 	for {
 		buff := make([]byte, 1024)
 		n, err := conn.Read(buff)
@@ -58,10 +58,10 @@ func (c *udp_client)udp_client_reader(conn net.Conn) {
 	}
 }
 
-func (c *udp_client)udp_client_writer(conn net.Conn) {
+func (c *udp_client) udp_client_writer(conn net.Conn) {
 	for {
 		buff := make([]byte, 1024)
-		n, addr ,  err := c.conn.ReadFrom(buff)
+		n, addr, err := c.conn.ReadFrom(buff)
 		if err != nil {
 			log.Fatal(err)
 		}
@@ -69,8 +69,8 @@ func (c *udp_client)udp_client_writer(conn net.Conn) {
 		i := utils.ArrayIndex(c.replyMap, addr.String())
 
 		if i == -1 {
-			c.replyMap= append(c.replyMap, addr.String())
-			i = len(c.replyMap)-1
+			c.replyMap = append(c.replyMap, addr.String())
+			i = len(c.replyMap) - 1
 		}
 
 		buff = append(fillIntBytes([]byte(strconv.Itoa(i))), buff[:n]...)
@@ -83,11 +83,11 @@ func (c *udp_client)udp_client_writer(conn net.Conn) {
 	}
 }
 
-func fillIntBytes(in []byte) []byte{
+func fillIntBytes(in []byte) []byte {
 	for len(in) <= 10 {
 		z := make([]byte, 1)
 		z[0] = byte(0)
 		in = append(z, in...)
 	}
 	return in
-}
+}

lib/net/interface/udp/udp_server.go

@@ -1,18 +1,19 @@
-package net
+package udp
 
 import (
 	"log"
 	"net"
+	icommon "hbx.ir/stunning/lib/net/interface/common"
 )
 
-type udp_server struct {
-	Vpnserver
+type UdpServer struct {
+	icommon.TunnelInterfaceServer
 	address string
-	connMap    map[[10]byte]net.Conn
+	connMap map[[10]byte]net.Conn
 }
 
-func GetUdpServer(url string) *udp_server {
-	s := &udp_server{}
+func GetUdpServer(url string) UdpServer {
+	s := UdpServer{}
 	s.address = url
 
 	s.connMap = make(map[[10]byte]net.Conn)
@@ -20,31 +21,31 @@ func GetUdpServer(url string) *udp_server {
 	return s
 }
 
-func(s *udp_server)getConnByAddr(addr [10]byte)net.Conn{
+func (s *UdpServer) getConnByAddr(addr [10]byte) net.Conn {
 
-
-	conn, err := net.Dial("udp", s.address)
+	//conn, err := net.Dial("udp", s.address)
+	_, err := net.Dial("udp", s.address)
 
 	if err != nil {
 		panic(err)
 	}
 }
 
-func (s *udp_server) HandleConnection(conn net.Conn) error {
+func (s UdpServer) HandleConnection(conn net.Conn) error {
 	log.Printf("Socket to %s handling connection \n", s.address)
-	go s.udp_server_reader(conn)
-	s.udp_server_writer(conn)
+	//go s.udp_server_reader(conn, s.connMap)
+	//s.udp_server_writer(conn)
 	return nil
 }
 
-func (s *udp_server) udp_server_reader(conn net.Conn) {
+func (s *UdpServer) udp_server_reader(conn, sconn net.Conn) {
 	for {
 		buff := make([]byte, 1024)
 		n, err := conn.Read(buff)
 		if err != nil {
 			log.Fatal(err)
 		}
-		addr := buff[:10]
+		//addr := buff[:10]
 		buff = buff[10:n]
 		wn, werr := sconn.Write(buff)
 		if werr != nil || wn != len(buff) {
@@ -55,7 +56,7 @@ func (s *udp_server) udp_server_reader(conn net.Conn) {
 	}
 }
 
-func (s *udp_server) udp_server_writer(conn, sconn net.Conn) {
+func (s *UdpServer) udp_server_writer(conn, sconn net.Conn) {
 	for {
 		buff := make([]byte, 1024)
 		n, err := sconn.Read(buff)

lib/net/tcp_client.go

@@ -1,50 +0,0 @@
-package net
-
-import (
-	"log"
-	"net"
-)
-
-type tcp_client struct {
-	address    string
-	tls_dialer *tls_dialer
-	saddress   string
-	listen     net.Listener
-}
-
-func GetTcpClient(url, surl string, tls_dialer *tls_dialer) *tcp_client {
-	s := &tcp_client{}
-	s.address = url
-	s.saddress = surl
-	s.tls_dialer = tls_dialer
-	listen, err := net.Listen("tcp", s.address)
-	if err != nil {
-		log.Panic(err)
-	}
-	s.listen = listen
-	go s.waiting_for_connection()
-	return s
-}
-
-func (t *tcp_client) waiting_for_connection() {
-	for {
-		conn, err := t.listen.Accept()
-		if err != nil {
-			log.Fatalln(err)
-			continue
-		}
-		sconn, serr := t.tls_dialer.Dial("tcp", t.saddress)
-		if serr != nil {
-			log.Fatalln(serr)
-			continue
-		}
-		go t.HandleConnection(conn, sconn)
-	}
-}
-
-func (t *tcp_client) HandleConnection(conn net.Conn, tconn net.Conn) error {
-	log.Printf("Socket to %s handling connection \n", t.address)
-	go tcp_server_reader(conn, tconn)
-	tcp_server_writer(conn, tconn)
-	return nil
-}

lib/net/tls_dialer.go

@@ -1,25 +0,0 @@
-package net
-
-import (
-	"crypto/tls"
-	"golang.org/x/net/proxy"
-	"net"
-)
-
-type tls_dialer struct {
-	proxy.Dialer
-}
-
-func GetTlsDialer() *tls_dialer {
-	return &tls_dialer{}
-}
-
-func (d *tls_dialer) Dial(network, addr string) (c net.Conn, err error) {
-
-	conf := &tls.Config{
-		InsecureSkipVerify: true,
-	}
-
-	conn, err := tls.Dial(network, addr, conf)
-	return conn, err
-}

lib/net/tls_server.go

@@ -1,67 +0,0 @@
-package net
-
-import (
-	"crypto/tls"
-	"log"
-	"net"
-)
-
-type TlsServer struct {
-	server Vpnserver
-	ln     net.Listener
-}
-
-func StartTlsServer(crt, key, address string) *TlsServer {
-	log.SetFlags(log.Lshortfile)
-
-	cer, err := tls.LoadX509KeyPair(crt, key)
-	if err != nil {
-		log.Println(err)
-		return nil
-	}
-
-	config := &tls.Config{Certificates: []tls.Certificate{cer}}
-	ln, err := tls.Listen("tcp", address, config)
-
-	if err != nil {
-		log.Println(err)
-		return nil
-	}
-	//defer ln.Close()
-	serv := &TlsServer{
-		ln: ln,
-	}
-	return serv
-}
-
-func (s *TlsServer) SetSocksServer(ss *socks_server) {
-	s.server = ss
-	go s.waitingForConnection()
-}
-
-func (s *TlsServer) SetTunServer(ss *tun_interface) {
-	s.server = ss
-	go s.waitingForConnection()
-}
-
-func (s *TlsServer) SetTcpServer(ss *tcp_server) {
-	s.server = ss
-	go s.waitingForConnection()
-}
-
-func (s *TlsServer) waitingForConnection() {
-	for {
-		conn, err := s.ln.Accept()
-		log.Println("new connection")
-		if err != nil {
-			log.Println(err)
-			continue
-		}
-		go s.handleConnection(conn)
-	}
-}
-
-func (s *TlsServer) handleConnection(conn net.Conn) {
-	defer conn.Close()
-	s.server.HandleConnection(conn)
-}

lib/net/tunnel/common/tunnel_dialer.go

@@ -0,0 +1,9 @@
+package common
+
+import (
+	"net"
+)
+
+type TunnelDialer interface {
+	Dial(network, addr string) (c net.Conn, err error)
+}

lib/net/tunnel/common/tunnel_server.go

@@ -0,0 +1,52 @@
+package common
+
+import (
+	icommon "hbx.ir/stunning/lib/net/interface/common"
+	//"hbx.ir/stunning/lib/net/interface/socks"
+	//"hbx.ir/stunning/lib/net/interface/tcp"
+	//"hbx.ir/stunning/lib/net/interface/tun"
+	"log"
+	"net"
+)
+
+type TunnelServer struct {
+	Server   icommon.TunnelInterfaceServer
+	Listener net.Listener
+}
+
+func (s *TunnelServer) SetServer(ss icommon.TunnelInterfaceServer) {
+	s.Server = ss
+	go s.WaitingForConnection()
+}
+
+//func (s *TunnelServer) SetSocksServer(ss *socks.SocksServer) {
+//	s.Server = ss
+//	go s.WaitingForConnection()
+//}
+//
+//func (s *TunnelServer) SetTunServer(ss *tun.TunInterface) {
+//	s.Server = ss
+//	go s.WaitingForConnection()
+//}
+//
+//func (s *TunnelServer) SetTcpServer(ss *tcp.TcpServer) {
+//	s.Server = ss
+//	go s.WaitingForConnection()
+//}
+
+func (s *TunnelServer) WaitingForConnection() {
+	for {
+		conn, err := s.Listener.Accept()
+		log.Println("new connection")
+		if err != nil {
+			log.Println(err)
+			continue
+		}
+		go s.HandleConnection(conn)
+	}
+}
+
+func (s *TunnelServer) HandleConnection(conn net.Conn) {
+	defer conn.Close()
+	s.Server.HandleConnection(conn)
+}

lib/net/tunnel/tls/tls_dialer.go

@@ -0,0 +1,36 @@
+package client
+
+import (
+	tcommon "hbx.ir/stunning/lib/net/tunnel/common"
+	"golang.org/x/net/proxy"
+	"net"
+	"crypto/tls"
+)
+
+type TlsDialer struct {
+	tcommon.TunnelDialer
+	network, addr string
+	dialer        proxy.Dialer
+}
+
+func GetTlsDialer() TlsDialer {
+	return TlsDialer{}
+}
+
+
+func (d TlsDialer) Dial(network, addr string) (c net.Conn, err error) {
+
+	if network == "" {
+		network = d.network
+	}
+
+	if addr == "" {
+		addr = d.addr
+	}
+	conf := &tls.Config{
+		InsecureSkipVerify: true,
+	}
+
+	conn, err := tls.Dial(network, addr, conf)
+	return conn, err
+}

lib/net/tunnel/tls/tls_server.go

@@ -0,0 +1,45 @@
+package client
+
+import (
+	"crypto/tls"
+	tcommon "hbx.ir/stunning/lib/net/tunnel/common"
+	"log"
+)
+
+type TlsServer struct {
+	tcommon.TunnelServer
+}
+
+func StartTlsServer(crt, key, address string) *TlsServer {
+	log.SetFlags(log.Lshortfile)
+
+	cer, err := tls.LoadX509KeyPair(crt, key)
+	if err != nil {
+		log.Println(err)
+		return nil
+	}
+
+	config := &tls.Config{Certificates: []tls.Certificate{cer}}
+	ln, err := tls.Listen("tcp", address, config)
+
+	if err != nil {
+		log.Println(err)
+		return nil
+	}
+	//defer ln.Close()
+	serv := &TlsServer{}
+	serv.Listener = ln
+	return serv
+}
+
+func (s *TlsServer) WaitingForConnection() {
+	for {
+		conn, err := s.Listener.Accept()
+		log.Println("new connection")
+		if err != nil {
+			log.Println(err)
+			continue
+		}
+		go s.HandleConnection(conn)
+	}
+}

test/simple_http_test.go

@@ -3,7 +3,8 @@ package test
 import (
 	"fmt"
 	"golang.org/x/net/proxy"
-	"hbx.ir/stunning/lib/net"
+	"hbx.ir/stunning/lib/net/interface/socks"
+	tlstun "hbx.ir/stunning/lib/net/tunnel/tls"
 	"io/ioutil"
 	"log"
 	"net/http"
@@ -13,9 +14,9 @@ import (
 
 func TestHttpGet(t *testing.T) {
 	log.SetOutput(os.Stderr)
-	ts := net.StartTlsServer("server.crt", "server.key", ":4443")
-	ts.SetSocksServer(net.GetSocksServer())
-	dialSocksProxy, err := proxy.SOCKS5("tcp", "127.0.0.1:4443", nil, net.GetTlsDialer())
+	ts := tlstun.StartTlsServer("../server.crt", "../server.key", ":4443")
+	ts.SetServer(socks.GetSocksServer())
+	dialSocksProxy, err := proxy.SOCKS5("tcp", "127.0.0.1:4443", nil, tlstun.GetTlsDialer())
 	if err != nil {
 		log.Println("Error connecting to proxy:", err)
 	}

test/tcp_test.go

@@ -1,7 +1,8 @@
 package test
 
 import (
-	"hbx.ir/stunning/lib/net"
+	"hbx.ir/stunning/lib/net/interface/tcp"
+	tlstun "hbx.ir/stunning/lib/net/tunnel/tls"
 	"hbx.ir/stunning/lib/utils"
 	"log"
 	"os"
@@ -11,10 +12,10 @@ import (
 
 func TestTcp(t *testing.T) {
 	log.SetOutput(os.Stderr)
-	ts := net.StartTlsServer(utils.ReadConf().GetString("application.crt"), utils.ReadConf().GetString("application.key"), utils.ReadConf().GetString("tcp_srv_test.listen"))
-	ts.SetTcpServer(net.GetTcpServer(utils.ReadConf().GetString("tcp_srv_test.connect")))
+	ts := tlstun.StartTlsServer(utils.ReadConf().GetString("application.crt"), utils.ReadConf().GetString("application.key"), utils.ReadConf().GetString("tcp_srv_test.listen"))
+	ts.SetServer(tcp.GetTcpServer(utils.ReadConf().GetString("tcp_srv_test.connect")))
 
 	log.Printf("%v", utils.ReadConf().AllKeys())
-	net.GetTcpClient("127.0.0.1:8080", "127.0.0.1:4443", net.GetTlsDialer())
+	tcp.GetTcpClient("127.0.0.1:8080", "127.0.0.1:4443", tlstun.GetTlsDialer())
 	time.Sleep(100 * time.Second)
 }

test/tuncli_test.go

@@ -2,7 +2,8 @@ package test
 
 import (
 	"github.com/songgao/water"
-	"hbx.ir/stunning/lib/net"
+	"hbx.ir/stunning/lib/net/interface/tun"
+	tlstun "hbx.ir/stunning/lib/net/tunnel/tls"
 	"log"
 	"os"
 	"testing"
@@ -10,30 +11,17 @@ import (
 
 func TestCliTunGet(t *testing.T) {
 	log.SetOutput(os.Stderr)
-	//ts := lib.StartTlsServer()
-	//log.Println("Tls Server started")
-	//stunconf :=lib.TunConfig{
-	//	DevType: water.TUN,
-	//	Address : "10.0.5.1",
-	//	Name: "",
-	//	MTU: "1500",
-	//}
-	//tunserv := lib.GetTunIface(stunconf)
-	//log.Println("Tun Interface is up")
-	//ts.SetTunServer(tunserv)
-	//log.Println("Tun Interface is set to Tls Server")
-
-	stunclientconf := net.TunConfig{
+	stunclientconf := tun.TunConfig{
 		DevType: water.TUN,
 		Address: "10.0.5.2/24",
 		Name:    "",
 		MTU:     "1500",
 	}
-	tuncli := net.GetTunIface(stunclientconf)
+	tuncli := tun.GetTunIface(stunclientconf)
 
 	log.Println("Tun Interface for client is up")
 
-	tc := net.GetTlsDialer()
+	tc := tlstun.GetTlsDialer()
 
 	log.Println("Tls client started")
 	conn, err := tc.Dial("tcp", "10.0.2.2:4443")

test/tunsrv_test.go

@@ -3,7 +3,8 @@ package test
 import (
 	"fmt"
 	"github.com/songgao/water"
-	"hbx.ir/stunning/lib/net"
+	"hbx.ir/stunning/lib/net/interface/tun"
+	tlstun "hbx.ir/stunning/lib/net/tunnel/tls"
 	"log"
 	"os"
 	"testing"
@@ -12,40 +13,19 @@ import (
 
 func TestSrvGet(t *testing.T) {
 	log.SetOutput(os.Stderr)
-	ts := net.StartTlsServer("../server.crt", "../server.key", ":4443")
+	ts := tlstun.StartTlsServer("../server.crt", "../server.key", ":4443")
 	fmt.Println("Tls Server started")
-	stunconf := net.TunConfig{
+	stunconf := tun.TunConfig{
 		DevType: water.TUN,
 		Address: "10.0.5.1/24",
 		Name:    "",
 		MTU:     "1500",
 	}
-	tunserv := net.GetTunIface(stunconf)
+	tunserv := tun.GetTunIface(stunconf)
 	fmt.Println("Tun Interface is up")
-	ts.SetTunServer(tunserv)
+	ts.SetServer(tunserv)
 	fmt.Println("Tun Interface is set to Tls Server")
-
-	//stunclientconf :=lib.TunConfig{
-	//	DevType: water.TUN,
-	//	Address : "10.0.5.2",
-	//	Name: "",
-	//	MTU: "1500",
-	//}
-	//tuncli := lib.GetTunIface(stunclientconf)
-	//
-	//log.Println("Tun Interface for client is up")
-	//
-	//tc := lib.GetTlsDialer()
-	//
-	//log.Println("Tls client started")
-	//conn, err := tc.Dial("tcp", "127.0.0.1:4443")
-	//if err != nil {
-	//	panic(err)
-	//}
-	//log.Println("Tls client connected to server")
-	//tuncli.HandleConnection(conn)
-	//log.Println("Tls client set to client tun interface")
 	for {
-		time.Sleep(1*time.Second)
+		time.Sleep(1 * time.Second)
 	}
 }