Example #1
0
    def _processIncomingPacket(self, packet):
        '''
        Takes a raw packet, checks it and returns the correct packet class
        '''
        # Check for special bytes n packet that shouldn't be there
        if protocol.START_BYTE in packet or protocol.END_BYTE in packet:
            raise ParsingException, 'Unescaped bytes found in packet: %s' % protocols.toHex(packet)

        # Process escapes
        processed = 0
        while protocol.ESCAPE_BYTE in packet[processed:]:
            i = packet.index(protocol.ESCAPE_BYTE, processed)
            processed = i+1

            # Convert escaped byte to an integer to XOR, and then convert back to a string
            unescaped = chr(ord(packet[i+1]) ^ 0xFF)

            if unescaped in protocol.SPECIAL_BYTES:
                packet = packet[:i] + unescaped + packet[i+2:]
            else:
                raise ParsingException, 'Wrongly escaped byte found in packet (%s): %s' % (hex(ord(unescaped)), protocols.toHex(packet))

        if not len(packet):
            raise IgnorableParsingException, 'Packet is empty'

        if len(packet) < 4:
            raise ParsingException, 'Packet does not contain required information. Packet content: %s' % protocols.toHex(packet)

        # Split up packet
        contents = {
                'flags':        packet[0],
                'payload_id':   protocols.shortFrom8bit(packet[1:3]),
                'payload':      packet[3:-1],
                'checksum':     packet[-1]
        }

        # Check checksum
        gen_checksum = packetlib.getChecksum(packet[:-1])

        if contents['checksum'] != gen_checksum:
            raise ParsingException, 'Checksum is incorrect! Provided: %d, generated: %d, packet: [%s]' % (ord(contents['checksum']), ord(gen_checksum), protocols.toHex(packet))

        # Create response packet object
        response = responses.getPacket(contents['payload_id'])

        # Populate data
        response.parseHeaderFlags(contents['flags'])
        response.setPayloadId(contents['payload_id'])
        response.parsePayload(contents['payload'])
        response.validate()

        return response
Example #2
0
    def _processBuffer(self):
        '''
        Check for any incoming packets and return if found

        - Removing anything before first START_BYTE
        - Check for END_BYTE
        - Loop though buffer copy
            - If complete packet found, remove length from buffer
            - If incomplete packet, leave buffer and try again later
        '''
        try:
            index = -1

            # Remove any buffer before the first start byte
            if self._cache[0] != protocol.START_BYTE:
                index = self._cache.find(protocol.START_BYTE, 1)
                if index >= 0:
                    if self._cache[:index] == protocol.END_BYTE:
                        raise IgnorableParsingException, 'Ignorable packet found in buffer before start byte %s' % protocols.toHex(self._cache[:index])
                    else:
                        raise ParsingException, 'Bad/incomplete packet found in buffer before start byte %s' % protocols.toHex(self._cache[:index])

        except ParsingException:
            # Catch parsing eceptions and tidy up the buffer
            if index >= 0:
                self._cache = self._cache[index:]
            else:
               self._cache = ''
            
            raise

        # If another start byte in buffer before next end byte
        s = self._cache.find(protocol.START_BYTE, 1)
        if s >= 0:

            # Find end byte before second start byte
            e = self._cache.find(protocol.END_BYTE, 1, s)

            # If no end byte before second byte, incomplete packet
            if e == -1:
                # Remove from buffer
                # Nasty try/raise/except/raise construct here so we can wipe the cache
                try:
                    if self._cache[:s] == protocol.START_BYTE:
                        raise IgnorableParsingException, 'Ignorable packet found in buffer missing end byte %s' % protocols.toHex(self._cache[:s])
                    else:
                        raise ParsingException, 'Bad/incomplete packet found in buffer missing end byte %s' % protocols.toHex(self._cache[:s])

                except ParsingException:
                    # Tidy up buffer
                    self._cache = self._cache[s:]

                    raise

        # If no end byte in buffer, return as it must not contain a complete packet
        if protocol.END_BYTE not in self._cache:
            return

        # Grab packet from buffer (minus start and end bytes)
        end = self._cache.index(protocol.END_BYTE)
        packet = self._cache[1:end] 

        # Clear processed buffer
        self._cache = self._cache[end+1:]

        # Process packet
        return self._processIncomingPacket(packet)
Example #3
0
 def getHex(self):
     '''
     Return a packet as hex strings
     '''
     packet = self._buildPacket()
     return protocols.toHex(packet)