# This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. # # Copyright (c) 2015 Digi International Inc. All Rights Reserved. """Define protocol handlers for different classes of protocols These protocols all wrap some base message schema and provide all the necessary hooks for pushing in a stream of bytes and getting out packets in the order they were found. The protocol handlers will also provide notifications of error conditions (for instance, unexpected bytes or a bad checksum). """ from functools import partial import six from suitcase.fields import Magic class StreamProtocolHandler(object): """Protocol handler that deals fluidly with a stream of bytes The protocol handler is agnostic to the data source or methodology being used to collect the data (blocking reads on a socket to async IO on a serial port). Here's an example of what one usage might look like (very simple approach for parsing a simple TCP protocol:: from suitcase.protocol import StreamProtocolHandler from suitcase.fields import LengthField, UBInt16, VariableRawPayload from suitcase.structure import Structure import socket class SimpleFramedMessage(Structure): length = LengthField(UBInt16()) payload = VariableRawPayload(length) def packet_received(packet): print(packet) def run_forever(host, port): protocol_handler = StreamProtocolHandler(SimpleFramedMessage, packet_received) sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect(host, port) sock.setblocking(1) while True: bytes = sock.recv(1024) if len(bytes) == 0: print("Socket closed... exiting") return else: protocol_handler.feed(bytes) :param message_schema: The top-level message schema that defines the packets for the protocol to be used. :param packet_callback: A callback to be executed with the form ``callback(packet)`` when a fully-formed packet is detected. """ def __init__(self, message_schema, packet_callback): # configuration parameters self.message_schema = message_schema self.packet_callback = packet_callback # internal state self._available_bytes = b"" self._packet_generator = self._create_packet_generator() def _create_packet_generator(self): while True: curmsg = self.message_schema() for i, (_name, field) in enumerate(curmsg): bytes_required = field.bytes_required if i == 0 and isinstance(field, Magic): magic_seq = field.getval() while True: if len(self._available_bytes) < bytes_required: yield None continue idx = self._available_bytes.find(magic_seq) if idx == -1: # no match in buffer # Since we know the entire magic_seq is not here, there can be at most # bytes_required - 1 bytes of the magic_seq available. Thus we keep # that many bytes around in case it is the start of the magic field. self._available_bytes = self._available_bytes[-(bytes_required - 1):] yield None else: self._available_bytes = self._available_bytes[idx:] break # continue processing # For a specific field, read until we have enough bytes # and then give the field a try. while True: bytes_available = len(self._available_bytes) if bytes_required <= bytes_available: field_bytes = self._available_bytes[:bytes_required] new_bytes = self._available_bytes[bytes_required:] self._available_bytes = new_bytes field.unpack(field_bytes) break else: yield None yield curmsg def feed(self, new_bytes): """Feed a new set of bytes into the protocol handler These bytes will be immediately fed into the parsing state machine and if new packets are found, the ``packet_callback`` will be executed with the fully-formed message. :param new_bytes: The new bytes to be fed into the stream protocol handler. """ self._available_bytes += new_bytes callbacks =  try: while True: packet = six.next(self._packet_generator) if packet is None: break else: callbacks.append(partial(self.packet_callback, packet)) except Exception: # When we receive an exception, we assume that the _available_bytes # has already been updated and we just choked on a field. That # is, unless the number of _available_bytes has not changed. In # that case, we reset the buffered entirely # TODO: black hole may not be the best. What should the logging # behavior be? self.reset() # callbacks are partials that are bound to packet already. We do # this in order to separate out parsing activity (and error handling) # from the execution of callbacks. Callbacks should not in any way # rely on the parsers position in the byte stream. for callback in callbacks: callback() def reset(self): """Reset the internal state machine to a fresh state If the protocol in use does not properly handle cases of possible de-synchronization it might be necessary to issue a reset if bytes are being received but no packets are coming out of the state machine. A reset is issue internally whenever an unexpected exception is encountered while processing bytes from the stream. """ self._packet_generator = self._create_packet_generator() self._available_bytes = b""