Core library

4 files changed, 112 insertions, 4 deletions

diff --git a/cmd/client/main.go b/cmd/client/main.go
index e69de29..244e543 100644
--- a/cmd/client/main.go
+++ b/cmd/client/main.go
@@ -0,0 +1,33 @@
+package main
+
+import (
+	"flag"
+	"log"
+	"net"
+
+	"git.sr.ht/~rctt/solecd/core"
+)
+
+var serverAddr string
+
+func main() {
+	flag.StringVar(&serverAddr, "a", "localhost:9999", "Server address:port")
+	flag.Parse()
+
+	var d net.Dialer
+
+	conn, err := d.Dial("tcp", serverAddr)
+	if err != nil {
+		log.Fatalf("cannot dial", err)
+	}
+	defer conn.Close()
+
+	for {
+		d, err := core.Read(conn)
+		if err != nil {
+			log.Fatalf("cannot read data: %v", err)
+		}
+
+		log.Print(d)
+	}
+}
diff --git a/cmd/mock/main.go b/cmd/daemon/main.go
index ad503c5..ad503c5 100644
--- a/cmd/mock/main.go
+++ b/cmd/daemon/main.go
diff --git a/core/data.go b/core/data.go
index a617f17..0bd8200 100644
--- a/core/data.go
+++ b/core/data.go
@@ -7,7 +7,8 @@ type Marshaler interface {
 type DataType uint8
 
 const (
-	TypeHandshake DataType = 0x01
+	TypeUnknown   DataType = 0x00
+	TypeHandshake          = 0x01
 	TypePing               = 0x02
 	TypePong               = 0x03
 	TypeTest               = 0xFF
@@ -26,5 +27,5 @@ type Test struct {
 }
 
 func (h Test) Marshal() []any {
-	return []any{[]byte(h.Message)}
+	return []any{append([]byte(h.Message), 0x0)}
 }
diff --git a/core/network.go b/core/network.go
index 3065f19..40c4112 100644
--- a/core/network.go
+++ b/core/network.go
@@ -3,20 +3,94 @@ package core
 import (
 	"encoding/binary"
 	"fmt"
+	"io"
 	"net"
+	"strings"
 )
 
 func Send(conn net.Conn, dataType DataType, data Marshaler) error {
 	packet := []any{uint8(dataType)}
 	packet = append(packet, data.Marshal()...)
 
-	fmt.Println(packet)
-
 	for _, v := range packet {
 		err := binary.Write(conn, binary.BigEndian, v)
 		if err != nil {
+			return fmt.Errorf("cannot send: %v", err)
+		}
+	}
+
+	return nil
+}
+
+func Read(r io.Reader) (any, error) {
+	dType, err := ReadDataType(r)
+	if err != nil {
+		return nil, fmt.Errorf("cannot read data type", err)
+	}
+
+	switch dType {
+	case TypeUnknown:
+		return nil, fmt.Errorf("cannot read data type 0x00 (TypeUnknown)")
+	case TypeHandshake:
+		return ReadHandshake(r)
+	case TypeTest:
+		return ReadTest(r)
+	default:
+		return nil, fmt.Errorf("unsupported type: %v", dType)
+	}
+}
+
+func ReadDataType(r io.Reader) (DataType, error) {
+	var data uint8
+	if err := read(r, &data); err != nil {
+		return TypeUnknown, err
+	}
+
+	dType := DataType(data)
+
+	return dType, nil
+}
+
+func ReadHandshake(r io.Reader) (Handshake, error) {
+	var d Handshake
+	err := read(r, &d.Version)
+	return d, err
+}
+
+func ReadTest(r io.Reader) (Test, error) {
+	var d Test
+	err := readString(r, &d.Message)
+	return d, err
+}
+
+func readString(r io.Reader, ptr *string) error {
+	var (
+		sb  strings.Builder
+		buf byte
+	)
+
+	for {
+		if err := read(r, &buf); err != nil {
 			return err
 		}
+
+		if buf == 0x0 {
+			break
+		}
+
+		if err := sb.WriteByte(buf); err != nil {
+			fmt.Errorf("cannot write byte to string buffer: %v", err)
+		}
+	}
+
+	*ptr = sb.String()
+	return nil
+}
+
+func read(r io.Reader, ptr any) error {
+	err := binary.Read(r, binary.BigEndian, ptr)
+	if err != nil {
+		return fmt.Errorf("cannot read: %v", err)
 	}
 
 	return nil