encoder (de)serialize

cli.cfg.example

@@ -1,13 +1,15 @@
 {
     "tunnel": {
         "name": "tcp",
+        "addr": "192.168.1.2:5555"
+    },
+    "packet": {
         "encoders": [
             {
                 "name": "zlib",
-                "level": 6
+                "level": 9
             }
-        ],
-        "addr": "192.168.1.2:5555"
+        ]
     },
     "auth": {
         "username": "user",

client.go

@@ -16,6 +16,10 @@ func NewClient(cfg map[string]map[string]interface{}) (cli Client, err error) {
 	var name interface{}
 
 	cli.cfg = cfg
+	if err = InitPacket(cfg); err != nil {
+		return
+	}
+
 	if _, ok := cfg["auth"]; !ok {
 		err = fmt.Errorf("missing `auth`")
 		return
@@ -134,7 +138,8 @@ func (c *Client) nat() error {
 			}
 			if packet.Type == PT_P2P {
 				if _, err := tun.Write(packet.Data); err != nil {
-					return err
+					log.Println("data:", packet.Data, err)
+					//return err
 				}
 			} else {
 				log.Println("end")

encoder.go

@@ -13,18 +13,18 @@ type Encoder interface {
 
 type Encoders []Encoder
 
-var encoders = map[string]reflect.Type{}
+var registered_encoders = map[string]reflect.Type{}
 
 func RegisterEncoder(name string, i interface{}) {
 	t := reflect.TypeOf(i)
 	if _, ok := reflect.New(t).Interface().(Encoder); !ok {
 		panic(fmt.Errorf("invalid encoder: %s", name))
 	}
-	encoders[name] = t
+	registered_encoders[name] = t
 }
 
 func NewEncoder(name string) (en Encoder, err error) {
-	if t, ok := encoders[name]; !ok {
+	if t, ok := registered_encoders[name]; !ok {
 		err = fmt.Errorf("can't find encoder: %s", name)
 		return
 	} else {
@@ -34,7 +34,7 @@ func NewEncoder(name string) (en Encoder, err error) {
 }
 
 func GetEncoders(cfg []interface{}) (Encoders, error) {
-	encoders := make([]Encoder, 0, len(cfg))
+	registered_encoders := make([]Encoder, 0, len(cfg))
 	for _, ic := range cfg {
 		if en_cfg, ok := ic.(map[string]interface{}); !ok {
 			return nil, fmt.Errorf("invalid encoder configure (map[string]interface{} desired)")
@@ -48,11 +48,11 @@ func GetEncoders(cfg []interface{}) (Encoders, error) {
 			} else if err := encoder.Init(en_cfg); err != nil {
 				return nil, err
 			} else {
-				encoders = append(encoders, encoder)
+				registered_encoders = append(registered_encoders, encoder)
 			}
 		}
 	}
-	return encoders, nil
+	return registered_encoders, nil
 }
 
 func (es Encoders) Encode(data []byte) (d []byte, err error) {

packet.go

@@ -3,6 +3,7 @@ package secretun
 import (
 	"bytes"
 	gob "encoding/gob"
+	"fmt"
 )
 
 const (
@@ -18,6 +19,8 @@ type Packet struct {
 	Data []byte
 }
 
+var encoders Encoders
+
 func (p *Packet) Decode(e interface{}) error {
 	buf := bytes.NewBuffer(p.Data)
 	de := gob.NewDecoder(buf)
@@ -34,6 +37,29 @@ func (p *Packet) Encode(e interface{}) error {
 	return nil
 }
 
+func (p *Packet) Serialize() ([]byte, error) {
+	buf := new(bytes.Buffer)
+	if err := buf.WriteByte(p.Type); err != nil {
+		return nil, err
+	}
+	if _, err := buf.Write(p.Data); err != nil {
+		return nil, err
+	}
+	return encoders.Encode(buf.Bytes())
+}
+
+func DeserializePacket(data []byte) (*Packet, error) {
+	if decoded_data, err := encoders.Decode(data); err != nil {
+		return nil, err
+	} else {
+		p := new(Packet)
+		p.Type = decoded_data[0]
+		p.Data = decoded_data[1:]
+		return p, nil
+	}
+	return nil, nil
+}
+
 func NewPacket(t uint8, e interface{}) (pack *Packet) {
 	pack = new(Packet)
 	pack.Type = t
@@ -48,3 +74,19 @@ func NewPacket(t uint8, e interface{}) (pack *Packet) {
 
 	return pack
 }
+
+func InitPacket(cfg map[string]map[string]interface{}) error {
+	if pkg_cfg, ok := cfg["packet"]; !ok {
+		return fmt.Errorf("missing `packet`")
+	} else if iencoders, ok := pkg_cfg["encoders"]; !ok {
+		return fmt.Errorf("missing `packet.encoders`")
+	} else if encoders_cfg, ok := iencoders.([]interface{}); !ok {
+		return fmt.Errorf("encoders invalid type ([]interface{} desired)")
+	} else {
+		var err error
+		if encoders, err = GetEncoders(encoders_cfg); err != nil {
+			return err
+		}
+	}
+	return nil
+}

ser.cfg.example

@@ -1,13 +1,15 @@
 {
     "tunnel": {
         "name": "tcp",
+        "addr": "0.0.0.0:5555"
+    },
+    "packet": {
         "encoders": [
             {
                 "name": "zlib",
                 "level": 9
             }
-        ],
-        "addr": "0.0.0.0:5555"
+        ]
     },
     "auth": {
         "users": "./users"

server.go

@@ -20,6 +20,10 @@ func NewServer(cfg map[string]map[string]interface{}) (ser Server, err error) {
 	var name interface{}
 
 	ser.cfg = cfg
+	if err = InitPacket(cfg); err != nil {
+		return
+	}
+
 	if auth_cfg, ok := cfg["auth"]; !ok {
 		err = fmt.Errorf("missing `auth`")
 		return

tcp_tunnel.go

@@ -5,46 +5,41 @@ import (
 	"encoding/binary"
 	"fmt"
 	"io"
-	"log"
 	"net"
 )
 
 type RawTCP_ST struct {
-	conn     net.Listener
-	encoders Encoders
+	conn net.Listener
 }
 
 type RawTCP_CT struct {
-	conn     net.Conn
-	encoders Encoders
+	conn net.Conn
 }
 
-func packetTunnel(encoders Encoders, conn net.Conn, cli_ch ClientChan) {
+func packetTunnel(conn net.Conn, cli_ch ClientChan) {
 
 	go func() {
-		var err error
 		var size uint16
-		var header [3]byte
+		var header [2]byte
 
 		for {
 			if _, err := io.ReadFull(conn, header[:]); err != nil {
 				cli_ch.End <- err
 				return
 			}
-			size = binary.BigEndian.Uint16(header[1:])
-			packet := new(Packet)
-			packet.Type = header[0]
-			buf := make([]byte, size)
-			if _, err = io.ReadFull(conn, buf); err != nil {
+			size = binary.BigEndian.Uint16(header[:])
+			data := make([]byte, size)
+			if _, err := io.ReadFull(conn, data); err != nil {
 				cli_ch.End <- err
 				return
 			}
-			if packet.Data, err = encoders.Decode(buf); err != nil {
-				log.Println(err)
+
+			if packet, err := DeserializePacket(data); err != nil {
 				cli_ch.End <- err
 				return
+			} else {
+				cli_ch.R <- packet
 			}
-			cli_ch.R <- packet
 		}
 	}()
 	go func() {
@@ -53,17 +48,15 @@ func packetTunnel(encoders Encoders, conn net.Conn, cli_ch ClientChan) {
 			if !ok {
 				return
 			}
-			data, err := encoders.Encode(packet.Data)
+			data, err := packet.Serialize()
 			if err != nil {
-				log.Println(err)
 				cli_ch.End <- err
 				return
 			}
 
 			size := len(data)
-			buf := make([]byte, 0, 3+len(data))
+			buf := make([]byte, 0, 2+len(data))
 			w := bytes.NewBuffer(buf)
-			w.WriteByte(packet.Type)
 			w.WriteByte(byte(size >> 8))
 			w.WriteByte(byte(size & 0xFF))
 			w.Write(data)
@@ -76,16 +69,6 @@ func packetTunnel(encoders Encoders, conn net.Conn, cli_ch ClientChan) {
 }
 
 func (t *RawTCP_ST) Init(cfg map[string]interface{}) (err error) {
-	if iencoders, ok := cfg["encoders"]; !ok {
-		return fmt.Errorf("tcptunnel missing encoders")
-	} else if encoders, ok := iencoders.([]interface{}); !ok {
-		return fmt.Errorf("tcptunnel.encoders invalid type ([]interface{} desired)")
-	} else {
-		if t.encoders, err = GetEncoders(encoders); err != nil {
-			return err
-		}
-	}
-
 	if iaddr, ok := cfg["addr"]; !ok {
 		return fmt.Errorf("missing `tunnel.addr`")
 	} else if addr, ok := iaddr.(string); !ok {
@@ -116,7 +99,7 @@ func (t *RawTCP_ST) Accept() (cli_ch ClientChan, err error) {
 	}
 
 	cli_ch = NewClientChan()
-	packetTunnel(t.encoders, conn, cli_ch)
+	packetTunnel(conn, cli_ch)
 
 	return cli_ch, nil
 }
@@ -126,16 +109,6 @@ func (t *RawTCP_ST) Shutdown() error {
 }
 
 func (t *RawTCP_CT) Init(cfg map[string]interface{}) (err error) {
-	if iencoders, ok := cfg["encoders"]; !ok {
-		return fmt.Errorf("tcptunnel missing encoders")
-	} else if encoders, ok := iencoders.([]interface{}); !ok {
-		return fmt.Errorf("tcptunnel.encoders invalid type ([]interface{} desired)")
-	} else {
-		if t.encoders, err = GetEncoders(encoders); err != nil {
-			return err
-		}
-	}
-
 	if iaddr, ok := cfg["addr"]; !ok {
 		return fmt.Errorf("missing `tunnel.addr`")
 	} else if addr, ok := iaddr.(string); !ok {
@@ -159,7 +132,7 @@ func (t *RawTCP_CT) Init(cfg map[string]interface{}) (err error) {
 }
 
 func (t *RawTCP_CT) Start(cli_ch ClientChan) error {
-	packetTunnel(t.encoders, t.conn, cli_ch)
+	packetTunnel(t.conn, cli_ch)
 	return nil
 }