fix: wrapper not unpacking param array. feat: error check on param # mismatch

Author: eigen-value

examples/rpc_lite_server/rpc_lite_server.ino

@@ -8,6 +8,9 @@ int add(int a, int b){
     return a+b;
 }
 
+MsgPack::str_t greet(){
+    return MsgPack::str_t ("Hello Friend");
+}
 
 void setup() {
     Serial2.begin(115200);
@@ -17,6 +20,7 @@ void setup() {
     while(!Serial);
 
     server.bind("add", add);
+    server.bind("greet", greet);
 
 }
 

examples/wrapper_example/wrapper_example.ino

@@ -46,7 +46,8 @@ void setup() {
 void loop() {
 
     packer.clear();
-    packer.serialize(a, b);
+    MsgPack::arr_size_t param_size(2);
+    packer.serialize(param_size, a, b);
 
     unpacker.clear();
     unpacker.feed(packer.data(), packer.size());
@@ -76,7 +77,7 @@ void loop() {
     float denominator = 0;
 
     packer.clear();
-    packer.serialize(numerator, denominator);
+    packer.serialize(param_size, numerator, denominator);
     unpacker.clear();
     unpacker.feed(packer.data(), packer.size());
     out_packer.clear();

extras/examples/serial_client_example.py

@@ -4,4 +4,11 @@
 
 client = SerialClient(port=PORT, baudrate=115200)
 
-client.call("add", 15, 7)
+
+client.call("add", 10)       # not enough args
+
+client.call("add", 15, 7)   # just enough args
+
+client.call("add", 1, 2, 3) # too many args
+
+client.call("greet")

src/error.h

@@ -9,6 +9,8 @@
 #include "MsgPack.h"
 
 
+#define NO_ERR                   0x00
+#define MALFORMED_CALL_ERR       0xFD
 #define FUNCTION_NOT_FOUND_ERR   0xFE
 #define GENERIC_ERR              0xFF
 

src/server.h

@@ -51,7 +51,7 @@ class RPCServer {
         packer.serialize(resp_size, RESP_MSG, msg_id);
 
         dispatcher.call(method, unpacker, packer);
-
+        flush_buffer();
         send_msg(transport, packer.packet());
 
     }

src/wrapper.h

@@ -77,26 +77,50 @@ class RpcFunctionWrapper<R(Args...)>: public IFunctionWrapper {
     }
 
     bool operator()(MsgPack::Unpacker& unpacker, MsgPack::Packer& packer) override {
-        auto args = deserialize_all<Args...>(unpacker);
+
         MsgPack::object::nil_t nil;
 
 #ifdef HANDLE_RPC_ERRORS
     try {
 #endif
+
+        // First check the parameters size
+        if (!unpacker.isArray()){
+            RpcError error(MALFORMED_CALL_ERR, "Unserializable parameters array");
+            packer.serialize(error, nil);
+            return false;
+        }
+
+        MsgPack::arr_size_t param_size;
+
+        unpacker.deserialize(param_size);
+        if (param_size.size() < sizeof...(Args)){
+            RpcError error(MALFORMED_CALL_ERR, "Missing call parameters (WARNING: Default param resolution is not implemented)");
+            packer.serialize(error, nil);
+            return false;
+        }
+
+        if (param_size.size() > sizeof...(Args)){
+            RpcError error(MALFORMED_CALL_ERR, "Too many parameters");
+            packer.serialize(error, nil);
+            return false;
+        }
+
+        auto args = deserialize_all<Args...>(unpacker);
         if constexpr (std::is_void<R>::value){
             invoke_with_tuple(_func, args, make_index_sequence<sizeof...(Args)>{});
             packer.serialize(nil, nil);
             return true;
         } else {
             R out = invoke_with_tuple(_func, args, make_index_sequence<sizeof...(Args)>{});
+            Serial.println(out);
             packer.serialize(nil, out);
             return true;
         }
 #ifdef HANDLE_RPC_ERRORS
     } catch (const std::exception& e) {
-        RpcError error;
-        error.code = 0xFE;
-        error.traceback = "RPC error";
+        // Should be specialized according to the exception type
+        RpcError error(GENERIC_ERR, "RPC error");
         packer.serialize(error, nil);
         return false;
     }