From c4910c85cf40ea075f99086cee5efea395e9b0ee Mon Sep 17 00:00:00 2001
From: sujit <s.baniya.np@gmail.com>
Date: Fri, 4 Oct 2024 12:01:33 +0545
Subject: [PATCH] remove .DS_Store

---
 .DS_Store        | Bin 6148 -> 0 bytes
 .gitignore       |   3 +-
 broker/.DS_Store | Bin 6148 -> 0 bytes
 codec/codec.go   | 158 +++++++++++++++++++++++++++++++++--------------
 4 files changed, 112 insertions(+), 49 deletions(-)
 delete mode 100644 .DS_Store
 delete mode 100644 broker/.DS_Store

diff --git a/.DS_Store b/.DS_Store
deleted file mode 100644
index 49462d09ca6883690e49e9326eba8bddd47e28cf..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6148
zcmeHKOG*SW5UtWt8r;m%Wv(zch(mjVxq$SvDA-Mg5%;-_-o%}F5ijAZR4E;&!G$0q
zRgk<&>XXicPEtg~>xX_tv?QViO^`*I5t*Jf9hvh9kV}qh+V}U{p-X9)N%R+|<l9fF
zqdg_MqsjMUL$zVJS#7py+)Z{-1&*n0yCHS3H~q`w>(krw#n&8T>c92b-5#tnS<+Q!
zz!`7`oB?Oxrwqsy2Wid}y>|wj0cYTo0XZK6nqV}{isk4)S4sfj0@FpHOD!QW!7v(T
zMOYxLp+F5~D=}EZF(1q?8fHZeC${2)ZRL;Rh0E&5ABsD1RP^2%a0Y4yj&-<{`~MQZ
z%xsZghxo`Da0dPv1H5QA?HZf1yY*mua@Pj5D>M=D%c4M_SC0S;<QzFKMzsgg;TH|F
VqGXZz5)Sl-Kq16CXW$nYcn62PHAnye

diff --git a/.gitignore b/.gitignore
index 4bc60d7..d09d700 100644
--- a/.gitignore
+++ b/.gitignore
@@ -19,4 +19,5 @@
 
 # Go workspace file
 go.work
-.idea
\ No newline at end of file
+.idea
+.DS_Store
diff --git a/broker/.DS_Store b/broker/.DS_Store
deleted file mode 100644
index 5008ddfcf53c02e82d7eee2e57c38e5672ef89f6..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6148
zcmeH~Jr2S!425mzP>H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3
zem<@ulZcFPQ@L2!n>{z**<q8>++&mCkOWA81W14cNZ<zv;LbK1Poaz?KmsK2CSc!(
z0ynLxE!0092;Krf2c+FF_Fe*7ECH>lEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ
zLs35+`xjp>T0<F0fCPF1$Cyrb|F7^5{eNG?83~ZUUlGt@xh*qZDeu<Z%US-OSsOPv
j)R!Z4KLME7ReXlK;d!wEw5GODWMKRea10D2@KpjYNUI8I

diff --git a/codec/codec.go b/codec/codec.go
index 8aa5953..aa13a87 100644
--- a/codec/codec.go
+++ b/codec/codec.go
@@ -12,7 +12,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-
+	
 	"github.com/oarkflow/mq/consts"
 )
 
@@ -63,29 +63,19 @@ func VerifyHMAC(key []byte, data []byte, receivedHMAC string) bool {
 	return hmac.Equal([]byte(expectedHMAC), []byte(receivedHMAC))
 }
 
-func (m *Message) Serialize(aesKey []byte, hmacKey []byte) ([]byte, string, error) {
+func (m *Message) Serialize(aesKey, hmacKey []byte) ([]byte, string, error) {
 	var buf bytes.Buffer
-	headersBytes, err := json.Marshal(m.Headers)
-	if err != nil {
-		return nil, "", fmt.Errorf("error marshalling headers: %v", err)
-	}
-	headersLen := uint32(len(headersBytes))
-	if err := binary.Write(&buf, binary.LittleEndian, headersLen); err != nil {
+	
+	if err := writeHeaders(&buf, m.Headers); err != nil {
 		return nil, "", err
 	}
-	buf.Write(headersBytes)
-	topicBytes := []byte(m.Topic)
-	topicLen := uint8(len(topicBytes))
-	if err := binary.Write(&buf, binary.LittleEndian, topicLen); err != nil {
+	if err := writeString(&buf, m.Topic); err != nil {
 		return nil, "", err
 	}
-	buf.Write(topicBytes)
-	if !m.Command.IsValid() {
-		return nil, "", fmt.Errorf("invalid command: %s", m.Command)
-	}
-	if err := binary.Write(&buf, binary.LittleEndian, m.Command); err != nil {
+	if err := writeCommand(&buf, m.Command); err != nil {
 		return nil, "", err
 	}
+	
 	payloadBytes, err := json.Marshal(m.Payload)
 	if err != nil {
 		return nil, "", fmt.Errorf("error marshalling payload: %v", err)
@@ -94,24 +84,96 @@ func (m *Message) Serialize(aesKey []byte, hmacKey []byte) ([]byte, string, erro
 	if err != nil {
 		return nil, "", err
 	}
-	payloadLen := uint32(len(encryptedPayload))
-	if err := binary.Write(&buf, binary.LittleEndian, payloadLen); err != nil {
+	if err := writePayload(&buf, encryptedPayload); err != nil {
 		return nil, "", err
 	}
-	buf.Write(encryptedPayload)
 	buf.Write(nonce)
+	
 	messageBytes := buf.Bytes()
 	hmacSignature := CalculateHMAC(hmacKey, messageBytes)
 	return messageBytes, hmacSignature, nil
 }
 
-func Deserialize(data []byte, aesKey []byte, hmacKey []byte, receivedHMAC string) (*Message, error) {
+func Deserialize(data []byte, aesKey, hmacKey []byte, receivedHMAC string) (*Message, error) {
 	if !VerifyHMAC(hmacKey, data, receivedHMAC) {
 		return nil, fmt.Errorf("HMAC verification failed")
 	}
+	
 	buf := bytes.NewReader(data)
-	var topicLen uint8
-	var payloadLen uint32
+	
+	headers, err := readHeaders(buf)
+	if err != nil {
+		return nil, err
+	}
+	topic, err := readString(buf)
+	if err != nil {
+		return nil, err
+	}
+	command, err := readCommand(buf)
+	if err != nil {
+		return nil, err
+	}
+	encryptedPayload, nonce, err := readPayload(buf)
+	if err != nil {
+		return nil, err
+	}
+	
+	payloadBytes, err := DecryptPayload(aesKey, encryptedPayload, nonce)
+	if err != nil {
+		return nil, err
+	}
+	var payload json.RawMessage
+	if err := json.Unmarshal(payloadBytes, &payload); err != nil {
+		return nil, fmt.Errorf("error unmarshalling payload: %v", err)
+	}
+	
+	return &Message{
+		Headers: headers,
+		Topic:   topic,
+		Command: command,
+		Payload: payload,
+	}, nil
+}
+
+func writeHeaders(buf *bytes.Buffer, headers map[string]string) error {
+	headersBytes, err := json.Marshal(headers)
+	if err != nil {
+		return fmt.Errorf("error marshalling headers: %v", err)
+	}
+	headersLen := uint32(len(headersBytes))
+	if err := binary.Write(buf, binary.LittleEndian, headersLen); err != nil {
+		return err
+	}
+	buf.Write(headersBytes)
+	return nil
+}
+
+func writeString(buf *bytes.Buffer, str string) error {
+	strBytes := []byte(str)
+	if err := binary.Write(buf, binary.LittleEndian, uint8(len(strBytes))); err != nil {
+		return err
+	}
+	buf.Write(strBytes)
+	return nil
+}
+
+func writeCommand(buf *bytes.Buffer, command consts.CMD) error {
+	if !command.IsValid() {
+		return fmt.Errorf("invalid command: %s", command)
+	}
+	return binary.Write(buf, binary.LittleEndian, command)
+}
+
+func writePayload(buf *bytes.Buffer, encryptedPayload []byte) error {
+	payloadLen := uint32(len(encryptedPayload))
+	if err := binary.Write(buf, binary.LittleEndian, payloadLen); err != nil {
+		return err
+	}
+	buf.Write(encryptedPayload)
+	return nil
+}
+
+func readHeaders(buf *bytes.Reader) (map[string]string, error) {
 	var headersLen uint32
 	if err := binary.Read(buf, binary.LittleEndian, &headersLen); err != nil {
 		return nil, err
@@ -124,46 +186,46 @@ func Deserialize(data []byte, aesKey []byte, hmacKey []byte, receivedHMAC string
 	if err := json.Unmarshal(headersBytes, &headers); err != nil {
 		return nil, err
 	}
+	return headers, nil
+}
+
+func readString(buf *bytes.Reader) (string, error) {
+	var topicLen uint8
 	if err := binary.Read(buf, binary.LittleEndian, &topicLen); err != nil {
-		return nil, err
+		return "", err
 	}
 	topicBytes := make([]byte, topicLen)
 	if _, err := buf.Read(topicBytes); err != nil {
-		return nil, err
+		return "", err
 	}
-	topic := string(topicBytes)
+	return string(topicBytes), nil
+}
+
+func readCommand(buf *bytes.Reader) (consts.CMD, error) {
 	var command consts.CMD
 	if err := binary.Read(buf, binary.LittleEndian, &command); err != nil {
-		return nil, err
+		return command, err
 	}
 	if !command.IsValid() {
-		return nil, fmt.Errorf("invalid command: %s", command)
+		return command, fmt.Errorf("invalid command: %s", command)
 	}
+	return command, nil
+}
+
+func readPayload(buf *bytes.Reader) ([]byte, []byte, error) {
+	var payloadLen uint32
 	if err := binary.Read(buf, binary.LittleEndian, &payloadLen); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	encryptedPayload := make([]byte, payloadLen)
 	if _, err := buf.Read(encryptedPayload); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
-	nonce := make([]byte, 12)
+	nonce := make([]byte, 12) // Adjust size as needed
 	if _, err := buf.Read(nonce); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
-	payloadBytes, err := DecryptPayload(aesKey, encryptedPayload, nonce)
-	if err != nil {
-		return nil, err
-	}
-	var payload json.RawMessage
-	if err := json.Unmarshal(payloadBytes, &payload); err != nil {
-		return nil, fmt.Errorf("error unmarshalling payload: %v", err)
-	}
-	return &Message{
-		Headers: headers,
-		Topic:   topic,
-		Command: command,
-		Payload: payload,
-	}, nil
+	return encryptedPayload, nonce, nil
 }
 
 func SendMessage(conn io.Writer, msg *Message, aesKey []byte, hmacKey []byte) error {
@@ -174,7 +236,7 @@ func SendMessage(conn io.Writer, msg *Message, aesKey []byte, hmacKey []byte) er
 	if err := binary.Write(conn, binary.LittleEndian, uint32(len(sentData))); err != nil {
 		return err
 	}
-
+	
 	if _, err := conn.Write(sentData); err != nil {
 		return err
 	}
@@ -193,7 +255,7 @@ func ReadMessage(conn io.Reader, aesKey []byte, hmacKey []byte) (*Message, error
 	if _, err := io.ReadFull(conn, data); err != nil {
 		return nil, err
 	}
-
+	
 	hmacBytes := make([]byte, 64)
 	if _, err := io.ReadFull(conn, hmacBytes); err != nil {
 		return nil, err