Validate received messages

for correct header, footer and checksum

Author: brefra

plugwise/exceptions.py

@@ -24,8 +24,20 @@ class CirclePlusError(PlugwiseException):
     """Connection to Circle+ node failed"""
 
 
-class ProtocolError(PlugwiseException):
-    """Error while decode received data"""
+class InvalidMessageLength(PlugwiseException):
+    """Invalid message length"""
+
+
+class InvalidMessageHeader(PlugwiseException):
+    """Invalid message header"""
+
+
+class InvalidMessageFooter(PlugwiseException):
+    """Invalid message footer"""
+
+
+class InvalidMessageChecksum(PlugwiseException):
+    """Invalid data checksum"""
 
 
 class TimeoutException(PlugwiseException):

plugwise/messages/__init__.py

@@ -7,17 +7,20 @@
 class PlugwiseMessage:
     """Plugwise message base."""
 
-    # TODO: none of the self objects are predefined
+    def __init__(self):
+        self.mac = ""
+        self.checksum = None
+        self.args = []
 
     def serialize(self):
         """Return message in a serialized format that can be sent out on wire."""
-        args = b"".join(a.serialize() for a in self.args)
+        _args = b"".join(a.serialize() for a in self.args)
         msg = self.ID
         if self.mac != "":
             msg += self.mac
-        msg += args
-        checksum = self.calculate_checksum(msg)
-        return MESSAGE_HEADER + msg + checksum + MESSAGE_FOOTER
+        msg += _args
+        self.checksum = self.calculate_checksum(msg)
+        return MESSAGE_HEADER + msg + self.checksum + MESSAGE_FOOTER
 
     def calculate_checksum(self, s):
         """Calculate crc checksum."""

plugwise/messages/responses.py

@@ -7,7 +7,12 @@
     MESSAGE_LARGE,
     MESSAGE_SMALL,
 )
-from plugwise.exceptions import ProtocolError
+from plugwise.exceptions import (
+    InvalidMessageChecksum,
+    InvalidMessageFooter,
+    InvalidMessageHeader,
+    InvalidMessageLength,
+)
 from plugwise.messages import PlugwiseMessage
 from plugwise.util import (
     DateTime,
@@ -31,7 +36,6 @@ def __init__(self, format_size=None):
         super().__init__()
         self.format_size = format_size
         self.params = []
-        self.mac = None
         self.timestamp = None
         self.seq_id = None
         self.msg_id = None
@@ -45,13 +49,36 @@ def __init__(self, format_size=None):
 
     def deserialize(self, response):
         self.timestamp = datetime.now()
-        if len(response) != len(self):
-            raise ProtocolError(
-                "message doesn't have expected length, expected %d bytes got %d"
-                % (len(self), len(response))
+        _msg_length = len(response)
+        if _msg_length != len(self):
+            raise InvalidMessageLength(
+                "Invalid message length received for %s, expected %s bytes got %s",
+                self.__class__.__name__,
+                str(len(self)),
+                str(_msg_length),
             )
         if response[:4] != MESSAGE_HEADER:
-            raise ProtocolError("Invalid message header")
+            raise InvalidMessageHeader(
+                "Invalid message header %s for %s",
+                str(response[:4]),
+                self.__class__.__name__,
+            )
+        if response[_msg_length - 2 :] != MESSAGE_FOOTER:
+            raise InvalidMessageFooter(
+                "Invalid message footer %s for %s",
+                str(response[_msg_length - 2 :]),
+                self.__class__.__name__,
+            )
+        _calculated_checksum = self.calculate_checksum(response[4 : _msg_length - 6])
+        _message_checksum = response[_msg_length - 6 : _msg_length - 2]
+        if _calculated_checksum != _message_checksum:
+            raise InvalidMessageChecksum(
+                "Invalid checksum for %s, expected %s got %s",
+                self.__class__.__name__,
+                str(_calculated_checksum),
+                str(_message_checksum),
+            )
+
         self.msg_id = response[4:8]
         self.seq_id = response[8:12]
         response = response[12:]
@@ -61,13 +88,13 @@ def deserialize(self, response):
         if self.format_size != MESSAGE_SMALL:
             self.mac = response[:16]
             response = response[16:]
-
         response = self._parse_params(response)
-        # TODO: unused crc
-        # crc = response[:4]
 
-        if response[4:] != MESSAGE_FOOTER:
-            raise ProtocolError("Invalid message footer")
+        _args = b"".join(a.serialize() for a in self.args)
+        msg = self.ID
+        if self.mac != "":
+            msg += self.mac
+        msg += _args
 
     def _parse_params(self, response):
         for p in self.params:

plugwise/parser.py

@@ -3,6 +3,12 @@
 import logging
 
 from plugwise.constants import MESSAGE_FOOTER, MESSAGE_HEADER
+from plugwise.exceptions import (
+    InvalidMessageChecksum,
+    InvalidMessageFooter,
+    InvalidMessageHeader,
+    InvalidMessageLength,
+)
 from plugwise.messages.responses import get_message_response
 
 _LOGGER = logging.getLogger(__name__)
@@ -86,9 +92,16 @@ def parse_data(self):
                                 self._message.deserialize(
                                     self._buffer[: footer_index + 2]
                                 )
+                            except (
+                                InvalidMessageChecksum,
+                                InvalidMessageFooter,
+                                InvalidMessageHeader,
+                                InvalidMessageLength,
+                            ) as e:
+                                _LOGGER.warning(e)
                             except Exception as e:
                                 _LOGGER.error(
-                                    "Error while decoding %s message (%s)",
+                                    "Failed to parse %s message (%s)",
                                     self._message.__class__.__name__,
                                     str(self._buffer[: footer_index + 2]),
                                 )