feat: get_discard_packages (client/server/decoder)

mod: recoded decoder.get_response logic discarding broken packages with right ID

Author: eigen-value

src/client.h

@@ -67,12 +67,12 @@ class RPCClient {
         if (decoder->get_response(wait_id, result, error)) {
             lastError.copy(error);
             return true;
-        } else if (error.code == PARSING_ERR) {     // catches the parsing error
-            lastError.copy(error);
         }
         return false;
     }
 
+    uint32_t get_discarded_packets() const {return decoder->get_discarded_packets();}
+
 };
 
 #endif //RPCLITE_CLIENT_H

src/decoder.h

@@ -68,50 +68,48 @@ class RpcDecoder {
         int resp_type;
         uint32_t resp_id;
 
-        if (!unpacker.deserialize(resp_size, resp_type, resp_id)) {
+        if (!unpacker.deserialize(resp_size, resp_type, resp_id)) return false;
+
+        // ReSharper disable once CppDFAUnreachableCode
+        if (resp_id != msg_id) return false;
+
+        // msg_id OK packet will be consumed.
+        if (resp_type != RESP_MSG) {
+            // This should never happen
             error.code = PARSING_ERR;
-            error.traceback = "Non parsable RPC response headers (check type)";
+            error.traceback = "Unexpected response type";
             discard();
-            return false;
+            return true;
         }
+
         if (resp_size.size() != RESPONSE_SIZE) {
-            error.code = PARSING_ERR;
-            error.traceback = "Wrong RPC response size";
-            discard();
-            return false;
-        }
-        if (resp_type != RESP_MSG) {
             // This should never happen
-            error.code = GENERIC_ERR;
-            error.traceback = "Unexpected response type";
+            error.code = PARSING_ERR;
+            error.traceback = "Unexpected RPC response size";
             discard();
-            return false;
+            return true;
         }
 
-        // DO NOT MODIFY THIS if resp_id is not what is expected then the RPC response belongs to s/o else
-        if (resp_id != msg_id) return false;
-
         MsgPack::object::nil_t nil;
         if (unpacker.unpackable(nil)){  // No error
             if (!unpacker.deserialize(nil, result)) {
                 error.code = PARSING_ERR;
                 error.traceback = "Result not parsable (check type)";
                 discard();
-                return false;
+                return true;
             }
         } else {                        // RPC returned an error
             if (!unpacker.deserialize(error, nil)) {
                 error.code = PARSING_ERR;
                 error.traceback = "RPC Error not parsable (check type)";
                 discard();
-                return false;
+                return true;
             }
         }
 
         consume(_packet_size);
         reset_packet();
         return true;
-
     }
 
     bool send_response(const MsgPack::Packer& packer) const {
@@ -143,6 +141,7 @@ class RpcDecoder {
             return ""; // Header not unpackable
         }
 
+        // ReSharper disable once CppDFAUnreachableCode
         if (msg_type == CALL_MSG && req_size.size() == REQUEST_SIZE) {
             uint32_t msg_id;
             if (!unpacker.deserialize(msg_id, method)) {
@@ -205,11 +204,13 @@ class RpcDecoder {
 
                 if (type != CALL_MSG && type != RESP_MSG && type != NOTIFY_MSG) {
                     consume(bytes_checked);
+                    _discarded_packets++;
                     break; // Not a valid RPC type (could be type=WRONG_MSG)
                 }
 
                 if ((type == CALL_MSG && container_size != REQUEST_SIZE) || (type == RESP_MSG && container_size != RESPONSE_SIZE) || (type == NOTIFY_MSG && container_size != NOTIFY_SIZE)) {
                     consume(bytes_checked);
+                    _discarded_packets++;
                     break; // Not a valid RPC format
                 }
 
@@ -232,6 +233,8 @@ class RpcDecoder {
 
     size_t size() const {return _bytes_stored;}
 
+    uint32_t get_discarded_packets() const {return _discarded_packets;}
+
     friend class DecoderTester;
 
 private:
@@ -241,6 +244,7 @@ class RpcDecoder {
     int _packet_type = NO_MSG;
     size_t _packet_size = 0;
     uint32_t _msg_id = 0;
+    uint32_t _discarded_packets = 0;
 
     bool buffer_full() const { return _bytes_stored == BufferSize; }
 
@@ -277,6 +281,7 @@ class RpcDecoder {
     void discard() {
         consume(_packet_size);
         reset_packet();
+        _discarded_packets++;
     }
 
     void reset_packet() {

src/server.h

@@ -87,6 +87,8 @@ class RPCServer {
 
     }
 
+    uint32_t get_discarded_packets() const {return decoder->get_discarded_packets();}
+
 private:
     RpcDecoder<>* decoder = nullptr;
     RpcFunctionDispatcher<MAX_CALLBACKS> dispatcher{};