fix: msgid must be 32-bit unsigned according to RPC standard

Author: eigen-value

src/client.h

@@ -7,7 +7,7 @@
 
 class RPCClient {
     RpcDecoder<>* decoder = nullptr;
-    int _waiting_msg_id;
+    uint32_t _waiting_msg_id;
 
 public:
     RpcError lastError;
@@ -22,7 +22,7 @@ class RPCClient {
 
     template<typename... Args>
     void notify(const MsgPack::str_t method, Args&&... args)  {
-        int _id;
+        uint32_t _id;
         decoder->send_call(NOTIFY_MSG, method, _id, std::forward<Args>(args)...);
     }
 
@@ -46,7 +46,7 @@ class RPCClient {
 
     template<typename... Args>
     bool send_rpc(const MsgPack::str_t method, Args&&... args) {
-        int msg_id;
+        uint32_t msg_id;
         if (decoder->send_call(CALL_MSG, method, msg_id, std::forward<Args>(args)...)) {
             _waiting_msg_id = msg_id;
             return true;

src/decoder.h

@@ -19,7 +19,7 @@ class RpcDecoder {
     RpcDecoder(ITransport& transport) : _transport(transport) {}
 
     template<typename... Args>
-    bool send_call(const int call_type, const MsgPack::str_t method, int& msg_id, Args&&... args) {
+    bool send_call(const int call_type, const MsgPack::str_t method, uint32_t& msg_id, Args&&... args) {
 
         if (call_type!=CALL_MSG && call_type!=NOTIFY_MSG) return false;
 
@@ -58,7 +58,7 @@ class RpcDecoder {
 
         MsgPack::arr_size_t resp_size;
         int resp_type;
-        int resp_id;
+        uint32_t resp_id;
 
         if (!unpacker.deserialize(resp_size, resp_type, resp_id)) return false;
         if (resp_size.size() != RESPONSE_SIZE) return false;
@@ -157,7 +157,7 @@ class RpcDecoder {
     size_t _bytes_stored = 0;
     int _packet_type = NO_MSG;
     size_t _packet_size = 0;
-    int _msg_id = 0;
+    uint32_t _msg_id = 0;
 
     inline bool buffer_full() const { return _bytes_stored == BufferSize; }
 

src/request.h

@@ -0,0 +1,71 @@
+#ifndef RPCLITE_REQUEST_H
+#define RPCLITE_REQUEST_H
+
+#define RPC_BUFFER_SIZE  1024
+
+
+#include "rpclite_utils.h"
+
+class RPCRequest {
+
+public:
+    uint8_t buffer[RPC_BUFFER_SIZE];
+    size_t size = 0;
+    int type = NO_MSG;
+    int req_id;
+    MsgPack::Packer res_packer;
+    MsgPack::Unpacker req_unpacker;
+    MsgPack::str_t method;
+
+    bool unpack_request_headers(){
+        if (size == 0) return false;
+
+        MsgPack::Unpacker unpacker;
+
+        req_unpacker.clear();
+        if (!req_unpacker.feed(buffer, size)) return false;
+
+        int msg_type;
+        uint32_t msg_id;
+        MsgPack::str_t method;
+        MsgPack::arr_size_t req_size;
+
+        if (!req_unpacker.deserialize(req_size, msg_type)) {
+            return false; // Header not unpackable
+        }
+
+        if (msg_type == CALL_MSG && req_size.size() == REQUEST_SIZE) {
+            if (!req_unpacker.deserialize(msg_id, method)) {
+                return false; // Method not unpackable
+            }
+        } else if (msg_type == NOTIFY_MSG && req_size.size() == NOTIFY_SIZE) {
+            if (!req_unpacker.deserialize(method)) {
+                return false; // Method not unpackable
+            }
+        } else {
+            return false; // Invalid request size/type
+        }
+
+        type = msg_type;
+        req_id = msg_id;
+        return true;
+
+    }
+
+    void pack_response_headers(){
+        res_packer.clear();
+        MsgPack::arr_size_t resp_size(RESPONSE_SIZE);
+        if (msg_type == CALL_MSG) req.res_packer.serialize(resp_size, RESP_MSG, msg_id);
+    }
+
+    void reset(){
+        size = 0;
+        type = NO_MSG;
+        method = "";
+        req_unpacker.clear();
+        res_packer.clear();
+    }
+
+};
+
+#endif RPCLITE_REQUEST_H

src/server.h

@@ -58,7 +58,7 @@ class RPCServer {
         }
 
         int msg_type;
-        int msg_id;
+        uint32_t msg_id;
         MsgPack::str_t method;
         MsgPack::arr_size_t req_size;