Implement inital handshake and receive loop

agwpe.go

@@ -14,11 +14,13 @@ type Config struct {
 type Option func(*Config)
 
 type PacketEngine struct {
-	address string
-	cfg     Config
-	Ready   bool
-	conn    net.Conn
-	mu      sync.Mutex
+	address  string
+	cfg      Config
+	Ready    bool
+	conn     net.Conn
+	mu       sync.Mutex
+	Messages chan []byte
+	version  string
 }
 
 func WithTimeout(d time.Duration) Option {
@@ -27,7 +29,7 @@ func WithTimeout(d time.Duration) Option {
 	}
 }
 
-func NewPacketEngine(address string, opts ...Option) (*PacketEngine, error) {
+func NewPacketEngine(address string, opts ...Option) *PacketEngine {
 	defaultCfg := Config{
 		Timeout: 5 * time.Second,
 	}
@@ -36,11 +38,14 @@ func NewPacketEngine(address string, opts ...Option) (*PacketEngine, error) {
 		opt(&defaultCfg)
 	}
 
-	return &PacketEngine{
-		address: address,
-		cfg:     defaultCfg,
-		Ready:   false,
-	}, nil
+	pe := PacketEngine{
+		address:  address,
+		cfg:      defaultCfg,
+		Ready:    false,
+		Messages: make(chan []byte),
+	}
+
+	return &pe
 }
 
 func (pe *PacketEngine) Connect() error {
@@ -50,6 +55,7 @@ func (pe *PacketEngine) Connect() error {
 	}
 	pe.conn = conn
 	fmt.Println("Connected to", pe.address)
+	go pe.receiveLoop()
 
 	return nil
 }
@@ -65,34 +71,36 @@ func (pe *PacketEngine) Disconnect() error {
 	return nil
 }
 
-// import "encoding/binary"
+func (pe *PacketEngine) Send(data []byte) error {
+	_, err := pe.conn.Write(data)
 
-// type Frame struct {
-// 	Port      byte
-// 	Reserved0 [3]byte
-// 	DataKind  byte
-// 	Reserved1 byte
-// 	PID       byte
-// 	Reserved2 byte
-// 	CallFrom  [10]byte
-// 	CallTo    [10]byte
-// 	DataLen   uint32
-// 	User      [4]byte
-// }
+	return err
+}
 
-// func (f *Frame) Serialize() []byte {
-// 	buf := make([]byte, 36)
+func (pe *PacketEngine) receiveLoop() {
+	defer close(pe.Messages)
 
-// 	buf[0] = f.Port
-// 	// Ignore reserved bytes 1 to 3
-// 	buf[4] = f.DataKind
-// 	// Ignore reserved byte 5
-// 	buf[6] = f.PID
-// 	// Ignore reserved byte 7
-// 	copy(buf[8:18], f.CallFrom[:])
-// 	copy(buf[18:28], f.CallTo[:])
-// 	binary.LittleEndian.PutUint32(buf[28:32], f.DataLen)
-// 	copy(buf[32:36], f.User[:])
+	for {
+		buf := make([]byte, 1024)
+		n, err := pe.conn.Read(buf)
+		if err != nil {
+			// FIXME: handle error
+			panic(err)
+		}
 
-// 	return buf
-// }
+		data := buf[:n]
+
+		pe.Messages <- data
+	}
+}
+
+func (pe *PacketEngine) Version() string {
+	if pe.conn == nil {
+		return ""
+	}
+	if pe.version != "" {
+		return pe.version
+	}
+
+	return fmt.Sprintf("%d.%d")
+}

cmd/basic_usage/main.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+import "git.smith.eu/m/go-agwpe"
+
+func main() {
+	engine := agwpe.NewPacketEngine("172.16.0.4:8000")
+
+	err := engine.Connect()
+	if err != nil {
+		fmt.Printf("Error connecting: %v\n", err)
+	}
+	defer engine.Disconnect()
+
+	version := engine.Version()
+	fmt.Printf("AGWPE version: %s\n", version)
+
+	frame := agwpe.NewVersionFrame()
+	frameData, err := frame.Serialize()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Serialization error: %v\n", err)
+	}
+
+	err = engine.Send(frameData)
+	if err != nil {
+		fmt.Println("Error:", err)
+	}
+
+	for msg := range engine.Messages {
+		major_verion := (uint16(msg[37]) << 8) | uint16(msg[36])
+		minor_verion := (uint16(msg[41]) << 8) | uint16(msg[40])
+		fmt.Printf("AGWPE version: %d.%d\n", major_verion, minor_verion)
+	}
+}

frame.go

@@ -0,0 +1,69 @@
+package agwpe
+
+import (
+	"encoding/binary"
+	"fmt"
+)
+
+type Header struct {
+	Port      byte
+	Reserved0 [3]byte
+	DataKind  byte
+	Reserved1 byte
+	PID       byte
+	Reserved2 byte
+	CallFrom  [10]byte
+	CallTo    [10]byte
+	DataLen   uint32
+	User      [4]byte
+}
+
+func serializeHeader(h Header) []byte {
+	data := make([]byte, 36)
+
+	data[0] = h.Port
+	// Ignore reserved bytes 1 to 3
+	data[4] = h.DataKind
+	// Ignore reserved byte 5
+	data[6] = h.PID
+	// Ignore reserved byte 7
+	copy(data[8:18], h.CallFrom[:])
+	copy(data[18:28], h.CallTo[:])
+	binary.LittleEndian.PutUint32(data[28:32], h.DataLen)
+	copy(data[32:36], h.User[:])
+
+	return data
+}
+
+type Frame interface {
+	Header() Header
+}
+
+type VersionFrame struct {
+	header       Header
+	major, minor uint16
+}
+
+func NewVersionFrame() *VersionFrame {
+	return &VersionFrame{
+		header: Header{
+			Port:     0x01,
+			DataKind: 0x52},
+	}
+}
+
+func (f *VersionFrame) Header() Header {
+	return f.header
+}
+
+func (f *VersionFrame) Serialize() ([]byte, error) {
+	data := serializeHeader(f.header)
+
+	return data, nil
+}
+
+func (f *VersionFrame) parseVersion(data []byte) {
+	f.major = (uint16(data[37]) << 8) | uint16(data[36])
+	f.minor = (uint16(data[41]) << 8) | uint16(data[40])
+	fmt.Printf("AGWPE version: %d.%d\n", f.major, f.minor)
+}

frame_test.go

@@ -0,0 +1,13 @@
+package agwpe
+
+import (
+	"testing"
+)
+
+func TestNewFrameHeader(t *testing.T) {
+
+}
+
+func TestFrameHeader_Serialize(t *testing.T) {
+
+}