def __init__(self, channel, symbols): self.channel = channel self.symbols = symbols self.memory = Memory() self.specializer = MessageSpecializer(memory=self.memory) self.parser = MessageParser(memory=self.memory) self.flow_parser = FlowParser(memory=self.memory)
def __init__(self, channel, symbols): self.channel = channel self.symbols = symbols self.memory = Memory() self.specializer = MessageSpecializer(memory=self.memory) self.parser = MessageParser(memory=self.memory) self.flow_parser = FlowParser(memory=self.memory)
def execute(self): """Execute the alignment of data following specified field """ if self.data is None: raise TypeError("Data cannot be None") if self.field is None: raise TypeError("Field cannot be None") # Aligned messages are stored in a MatrixList for better display result = MatrixList() # We retrieve all the leaf fields of the root of the provided field rootLeafFields = self.__root.getLeafFields(depth=self.depth) # if self.__root != self.field: # targetedFieldLeafFields = self.field.getLeafFields(depth=self.depth) # else: targetedFieldLeafFields = rootLeafFields result.headers = [str(field.name) for field in targetedFieldLeafFields] from netzob.Model.Vocabulary.Domain.Parser.MessageParser import MessageParser for d in self.data: mp = MessageParser() # alignedMsg = mp.parseRaw(TypeConverter.convert(d, HexaString, Raw), targetedFieldLeafFields) alignedMsg = next(mp.parseRaw(d, targetedFieldLeafFields)) alignedEncodedMsg = [] for ifield, currentField in enumerate(targetedFieldLeafFields): # now we apply encoding and mathematic functions fieldValue = alignedMsg[ifield] if self.encoded and len( list(currentField.encodingFunctions.values())) > 0: for encodingFunction in list( currentField.encodingFunctions.values()): fieldValue = encodingFunction.encode(fieldValue) else: fieldValue = TypeConverter.convert(fieldValue, BitArray, Raw) if currentField in self.field.getLeafFields(depth=self.depth): alignedEncodedMsg.append(fieldValue) result.append(alignedEncodedMsg) return result
def _parseFlow_internal(self, data_to_parse_bitarray, symbols, memory): """Parses the specified data""" if data_to_parse_bitarray is None or len(data_to_parse_bitarray) == 0: raise Exception("Nothing to parse") for symbol in symbols: self._logger.debug("Parsing '{}' with Symbol '{}'".format( data_to_parse_bitarray, symbol.name)) flow_parsing_results = [] try: mp = MessageParser(memory=memory) results = mp.parseBitarray( data_to_parse_bitarray.copy(), symbol.getLeafFields(), must_consume_everything=False) for parse_result in results: parse_result_len = sum( [len(value) for value in parse_result]) remainings_bitarray = data_to_parse_bitarray[ parse_result_len:] if len(remainings_bitarray) > 0: self._logger.debug( "Try to parse the remaining data '{}' with another symbol". format(remainings_bitarray)) try: child_flow_parsings = self._parseFlow_internal( remainings_bitarray, symbols, memory.duplicate()) for child_flow_parsing in child_flow_parsings: flow_parsing_results = [(symbol, parse_result) ] + child_flow_parsing yield flow_parsing_results except InvalidParsingPathException: pass else: flow_parsing_results = [(symbol, parse_result)] yield flow_parsing_results except InvalidParsingPathException: pass
def _parseFlow_internal(self, data_to_parse_bitarray, symbols, memory): """Parses the specified data""" if data_to_parse_bitarray is None or len(data_to_parse_bitarray) == 0: raise Exception("Nothing to parse") for symbol in symbols: self._logger.debug("Parsing '{}' with Symbol '{}'".format( data_to_parse_bitarray, symbol.name)) flow_parsing_results = [] try: mp = MessageParser(memory=memory) results = mp.parseBitarray( data_to_parse_bitarray.copy(), symbol._getLeafFields(), must_consume_everything=False) for parse_result in results: parse_result_len = sum( [len(value) for value in parse_result]) remainings_bitarray = data_to_parse_bitarray[ parse_result_len:] if len(remainings_bitarray) > 0: self._logger.debug( "Try to parse the remaining data '{}' with another symbol". format(remainings_bitarray)) try: child_flow_parsings = self._parseFlow_internal( remainings_bitarray, symbols, memory.duplicate()) for child_flow_parsing in child_flow_parsings: flow_parsing_results = [(symbol, parse_result) ] + child_flow_parsing yield flow_parsing_results except InvalidParsingPathException: pass else: flow_parsing_results = [(symbol, parse_result)] yield flow_parsing_results except InvalidParsingPathException: pass
class AbstractionLayer(object): """An abstraction layer specializes a symbol into a message before emitting it and on the other way, abstracts a received message into a symbol. >>> from netzob.all import * >>> symbol = Symbol([Field(b"Hello Zoby !")], name = "Symbol_Hello") >>> channelIn = UDPServer(localIP="127.0.0.1", localPort=8889) >>> abstractionLayerIn = AbstractionLayer(channelIn, [symbol]) >>> abstractionLayerIn.openChannel() >>> channelOut = UDPClient(remoteIP="127.0.0.1", remotePort=8889) >>> abstractionLayerOut = AbstractionLayer(channelOut, [symbol]) >>> abstractionLayerOut.openChannel() >>> abstractionLayerOut.writeSymbol(symbol) >>> (receivedSymbol, receivedMessage) = abstractionLayerIn.readSymbol() >>> print(receivedSymbol.name) Symbol_Hello >>> print(receivedMessage) b'Hello Zoby !' The abstraction layer can also handle a message flow. >>> symbolflow = Symbol([Field(b"Hello Zoby !Whats up ?")], name = "Symbol Flow") >>> symbol1 = Symbol([Field(b"Hello Zoby !")], name = "Symbol_Hello") >>> symbol2 = Symbol([Field(b"Whats up ?")], name = "Symbol_WUP") >>> channelIn = UDPServer(localIP="127.0.0.1", localPort=8889) >>> abstractionLayerIn = AbstractionLayer(channelIn, [symbol1, symbol2]) >>> abstractionLayerIn.openChannel() >>> channelOut = UDPClient(remoteIP="127.0.0.1", remotePort=8889) >>> abstractionLayerOut = AbstractionLayer(channelOut, [symbolflow]) >>> abstractionLayerOut.openChannel() >>> abstractionLayerOut.writeSymbol(symbolflow) >>> (receivedSymbols, receivedMessage) = abstractionLayerIn.readSymbols() >>> print(receivedSymbols) [Symbol_Hello, Symbol_WUP] """ def __init__(self, channel, symbols): self.channel = channel self.symbols = symbols self.memory = Memory() self.specializer = MessageSpecializer(memory=self.memory) self.parser = MessageParser(memory=self.memory) self.flow_parser = FlowParser(memory=self.memory) @typeCheck(Symbol) def writeSymbol(self, symbol): """Write the specified symbol on the communication channel after specializing it into a contextualized message. :param symbol: the symbol to write on the channel :type symbol: :class:`netzob.Model.Vocabulary.Symbol.Symbol` :raise TypeError if parameter is not valid and Exception if an exception occurs. """ if symbol is None: raise TypeError( "The symbol to write on the channel cannot be None") self._logger.debug("Specializing symbol '{0}' (id={1}).".format( symbol.name, symbol.id)) dataBin = self.specializer.specializeSymbol(symbol).generatedContent self.memory = self.specializer.memory self.parser.memory = self.memory data = TypeConverter.convert(dataBin, BitArray, Raw) self.channel.write(data) self._logger.debug("Writing to commnunication channel done..") @typeCheck(int) def readSymbols(self, timeout=EmptySymbol.defaultReceptionTimeout()): """Read from the abstraction layer a flow and abstract it with one or more consecutive symbols The timeout parameter represents the amount of time (in millisecond) above which no reception of a message triggers the reception of an :class:`netzob.Model.Vocabulary.EmptySymbol.EmptySymbol`. If timeout set to None or to a negative value means it always wait for the reception of a message. :keyword timeout: the time above which no reception of message triggers the reception of an :class:`netzob.Model.Vocabulary.EmptySymbol.EmptySymbol` :type timeout: :class:`int` :raise TypeError if the parameter is not valid and Exception if an error occurs. """ self._logger.debug("Reading data from communication channel...") data = self.channel.read(timeout=timeout) self._logger.debug("Received : {}".format(repr(data))) symbols = [] # if we read some bytes, we try to abstract them if len(data) > 0: try: symbols_and_data = self.flow_parser.parseFlow( RawMessage(data), self.symbols) for (symbol, alignment) in symbols_and_data: symbols.append(symbol) except Exception as e: self._logger.error(e) if len(symbols) > 0: self.memory = self.flow_parser.memory self.specializer.memory = self.memory else: symbols.append(EmptySymbol()) if len(symbols) == 0 and len(data) > 0: msg = RawMessage(data) symbols.append(UnknownSymbol(message=msg)) return (symbols, data) @typeCheck(int) def readSymbol(self, timeout=EmptySymbol.defaultReceptionTimeout()): """Read from the abstraction layer a message and abstract it into a message. The timeout parameter represents the amount of time (in millisecond) above which no reception of a message triggers the reception of an :class:`netzob.Model.Vocabulary.EmptySymbol.EmptySymbol`. If timeout set to None or to a negative value means it always wait for the reception of a message. :keyword timeout: the time above which no reception of message triggers the reception of an :class:`netzob.Model.Vocabulary.EmptySymbol.EmptySymbol` :type timeout: :class:`int` :raise TypeError if the parameter is not valid and Exception if an error occurs. """ self._logger.debug("Reading data from communication channel...") data = self.channel.read(timeout=timeout) self._logger.debug("Received : {}".format(repr(data))) symbol = None # if we read some bytes, we try to abstract them if len(data) > 0: for potential in self.symbols: try: self.parser.parseMessage(RawMessage(data), potential) symbol = potential self.memory = self.parser.memory self.specializer.memory = self.memory break except Exception: symbol = None if symbol is None and len(data) > 0: msg = RawMessage(data) symbol = UnknownSymbol(message=msg) elif symbol is None and len(data) == 0: symbol = EmptySymbol() return (symbol, data) def openChannel(self): self.channel.open() self._logger.debug("Communication channel opened.") def closeChannel(self): self.channel.close() self._logger.debug("Communication channel close.") def reset(self): self._logger.debug("Reseting abstraction layer") self.memory = Memory() self.specializer = MessageSpecializer(memory=self.memory) self.parser = MessageParser(memory=self.memory) self.flow_parser = FlowParser(memory=self.memory)
def reset(self): self._logger.debug("Reseting abstraction layer") self.memory = Memory() self.specializer = MessageSpecializer(memory=self.memory) self.parser = MessageParser(memory=self.memory) self.flow_parser = FlowParser(memory=self.memory)
class AbstractionLayer(object): """An abstraction layer specializes a symbol into a message before emitting it and on the other way, abstracts a received message into a symbol. >>> from netzob.all import * >>> symbol = Symbol([Field(b"Hello Zoby !")], name = "Symbol_Hello") >>> channelIn = UDPServer(localIP="127.0.0.1", localPort=8889) >>> abstractionLayerIn = AbstractionLayer(channelIn, [symbol]) >>> abstractionLayerIn.openChannel() >>> channelOut = UDPClient(remoteIP="127.0.0.1", remotePort=8889) >>> abstractionLayerOut = AbstractionLayer(channelOut, [symbol]) >>> abstractionLayerOut.openChannel() >>> abstractionLayerOut.writeSymbol(symbol) 12 >>> (receivedSymbol, receivedMessage) = abstractionLayerIn.readSymbol() >>> print(receivedSymbol.name) Symbol_Hello >>> print(receivedMessage) b'Hello Zoby !' The abstraction layer can also handle a message flow. >>> symbolflow = Symbol([Field(b"Hello Zoby !Whats up ?")], name = "Symbol Flow") >>> symbol1 = Symbol([Field(b"Hello Zoby !")], name = "Symbol_Hello") >>> symbol2 = Symbol([Field(b"Whats up ?")], name = "Symbol_WUP") >>> channelIn = UDPServer(localIP="127.0.0.1", localPort=8889) >>> abstractionLayerIn = AbstractionLayer(channelIn, [symbol1, symbol2]) >>> abstractionLayerIn.openChannel() >>> channelOut = UDPClient(remoteIP="127.0.0.1", remotePort=8889) >>> abstractionLayerOut = AbstractionLayer(channelOut, [symbolflow]) >>> abstractionLayerOut.openChannel() >>> abstractionLayerOut.writeSymbol(symbolflow) 22 >>> (receivedSymbols, receivedMessage) = abstractionLayerIn.readSymbols() >>> print(receivedSymbols) [Symbol_Hello, Symbol_WUP] """ def __init__(self, channel, symbols): self.channel = channel self.symbols = symbols self.memory = Memory() self.specializer = MessageSpecializer(memory=self.memory) self.parser = MessageParser(memory=self.memory) self.flow_parser = FlowParser(memory=self.memory) @typeCheck(Symbol) def writeSymbol(self, symbol, rate=None, duration=None, presets=None): """Write the specified symbol on the communication channel after specializing it into a contextualized message. :param symbol: the symbol to write on the channel :type symbol: :class:`netzob.Model.Vocabulary.Symbol.Symbol` :param rate: specifies the bandwidth in octets to respect durring traffic emission (should be used with duration= parameter) :type rate: int :param duration: tells how much seconds the symbol is continuously written on the channel :type duration: int :param presets: specifies how to parameterize the emitted symbol :type presets: dict :raise TypeError if parameter is not valid and Exception if an exception occurs. """ if symbol is None: raise TypeError( "The symbol to write on the channel cannot be None") len_data = 0 if duration is None: len_data = self._writeSymbol(symbol, presets=presets) else: t_start = time.time() t_elapsed = 0 t_delta = 0 while True: t_elapsed = time.time() - t_start if t_elapsed > duration: break # Specialize the symbol and send it over the channel len_data += self._writeSymbol(symbol, presets=presets) if rate is None: t_tmp = t_elapsed t_elapsed = time.time() - t_start t_delta += t_elapsed - t_tmp else: # Wait some time to that we follow a specific rate while True: t_tmp = t_elapsed t_elapsed = time.time() - t_start t_delta += t_elapsed - t_tmp if (len_data / t_elapsed) > rate: time.sleep(0.001) else: break # Show some log every seconds if t_delta > 1: t_delta = 0 self._logger.debug("Rate rule: {} ko/s, current rate: {} ko/s, sent data: {} ko, nb seconds elapsed: {}".format(round(rate / 1024, 2), round((len_data / t_elapsed) / 1024, 2), round(len_data / 1024, 2), round(t_elapsed, 2))) return len_data def _writeSymbol(self, symbol, presets=None): """Write the specified symbol on the communication channel after specializing it into a contextualized message. :param symbol: the symbol to write on the channel :type symbol: :class:`netzob.Model.Vocabulary.Symbol.Symbol` :param presets: specifies how to parameterize the emitted symbol :type presets: dict :raise TypeError if parameter is not valid and Exception if an exception occurs. """ self._logger.debug("Specializing symbol '{0}' (id={1}).".format( symbol.name, symbol.id)) self.specializer.presets = presets dataBin = self.specializer.specializeSymbol(symbol).generatedContent self.specializer.presets = None self.memory = self.specializer.memory self.parser.memory = self.memory data = TypeConverter.convert(dataBin, BitArray, Raw) len_data = self.channel.write(data) self._logger.debug("Writing {} octets to commnunication channel done..".format(len_data)) return len_data @typeCheck(int) def readSymbols(self, timeout=EmptySymbol.defaultReceptionTimeout()): """Read from the abstraction layer a flow and abstract it with one or more consecutive symbols The timeout parameter represents the amount of time (in millisecond) above which no reception of a message triggers the reception of an :class:`netzob.Model.Vocabulary.EmptySymbol.EmptySymbol`. If timeout set to None or to a negative value means it always wait for the reception of a message. :keyword timeout: the time above which no reception of message triggers the reception of an :class:`netzob.Model.Vocabulary.EmptySymbol.EmptySymbol` :type timeout: :class:`int` :raise TypeError if the parameter is not valid and Exception if an error occurs. """ self._logger.debug("Reading data from communication channel...") data = self.channel.read(timeout=timeout) self._logger.debug("Received : {}".format(repr(data))) symbols = [] # if we read some bytes, we try to abstract them if len(data) > 0: try: symbols_and_data = self.flow_parser.parseFlow( RawMessage(data), self.symbols) for (symbol, alignment) in symbols_and_data: symbols.append(symbol) except Exception as e: self._logger.error(e) if len(symbols) > 0: self.memory = self.flow_parser.memory self.specializer.memory = self.memory else: symbols.append(EmptySymbol()) if len(symbols) == 0 and len(data) > 0: msg = RawMessage(data) symbols.append(UnknownSymbol(message=msg)) return (symbols, data) @typeCheck(int) def readSymbol(self, timeout=EmptySymbol.defaultReceptionTimeout()): """Read from the abstraction layer a message and abstract it into a message. The timeout parameter represents the amount of time (in millisecond) above which no reception of a message triggers the reception of an :class:`netzob.Model.Vocabulary.EmptySymbol.EmptySymbol`. If timeout set to None or to a negative value means it always wait for the reception of a message. :keyword timeout: the time above which no reception of message triggers the reception of an :class:`netzob.Model.Vocabulary.EmptySymbol.EmptySymbol` :type timeout: :class:`int` :raise TypeError if the parameter is not valid and Exception if an error occurs. """ self._logger.debug("Reading data from communication channel...") data = self.channel.read(timeout=timeout) self._logger.debug("Received : {}".format(repr(data))) symbol = None # if we read some bytes, we try to abstract them if len(data) > 0: for potential in self.symbols: try: self.parser.parseMessage(RawMessage(data), potential) symbol = potential self.memory = self.parser.memory self.specializer.memory = self.memory break except Exception: symbol = None if symbol is None and len(data) > 0: msg = RawMessage(data) symbol = UnknownSymbol(message=msg) elif symbol is None and len(data) == 0: symbol = EmptySymbol() return (symbol, data) def openChannel(self): self.channel.open() self._logger.debug("Communication channel opened.") def closeChannel(self): self.channel.close() self._logger.debug("Communication channel close.") def reset(self): self._logger.debug("Reseting abstraction layer") self.memory = Memory() self.specializer = MessageSpecializer(memory=self.memory) self.parser = MessageParser(memory=self.memory) self.flow_parser = FlowParser(memory=self.memory)
def reset(self): self._logger.debug("Reseting abstraction layer") self.memory = Memory() self.specializer = MessageSpecializer(memory=self.memory) self.parser = MessageParser(memory=self.memory) self.flow_parser = FlowParser(memory=self.memory)
class AbstractionLayer(object): """An abstraction layer specializes a symbol into a message before emitting it and on the other way, abstracts a received message into a symbol. >>> from netzob.all import * >>> symbol = Symbol([Field(b"Hello Zoby !")], name = "Symbol_Hello") >>> channelIn = UDPServer(localIP="127.0.0.1", localPort=8889) >>> abstractionLayerIn = AbstractionLayer(channelIn, [symbol]) >>> abstractionLayerIn.openChannel() >>> channelOut = UDPClient(remoteIP="127.0.0.1", remotePort=8889) >>> abstractionLayerOut = AbstractionLayer(channelOut, [symbol]) >>> abstractionLayerOut.openChannel() >>> abstractionLayerOut.writeSymbol(symbol) 12 >>> (receivedSymbol, receivedMessage) = abstractionLayerIn.readSymbol() >>> print(receivedSymbol.name) Symbol_Hello >>> print(receivedMessage) b'Hello Zoby !' The abstraction layer can also handle a message flow. >>> symbolflow = Symbol([Field(b"Hello Zoby !Whats up ?")], name = "Symbol Flow") >>> symbol1 = Symbol([Field(b"Hello Zoby !")], name = "Symbol_Hello") >>> symbol2 = Symbol([Field(b"Whats up ?")], name = "Symbol_WUP") >>> channelIn = UDPServer(localIP="127.0.0.1", localPort=8889) >>> abstractionLayerIn = AbstractionLayer(channelIn, [symbol1, symbol2]) >>> abstractionLayerIn.openChannel() >>> channelOut = UDPClient(remoteIP="127.0.0.1", remotePort=8889) >>> abstractionLayerOut = AbstractionLayer(channelOut, [symbolflow]) >>> abstractionLayerOut.openChannel() >>> abstractionLayerOut.writeSymbol(symbolflow) 22 >>> (receivedSymbols, receivedMessage) = abstractionLayerIn.readSymbols() >>> print(receivedSymbols) [Symbol_Hello, Symbol_WUP] """ def __init__(self, channel, symbols): self.channel = channel self.symbols = symbols self.memory = Memory() self.specializer = MessageSpecializer(memory=self.memory) self.parser = MessageParser(memory=self.memory) self.flow_parser = FlowParser(memory=self.memory) @typeCheck(Symbol) def writeSymbol(self, symbol, rate=None, duration=None, presets=None): """Write the specified symbol on the communication channel after specializing it into a contextualized message. :param symbol: the symbol to write on the channel :type symbol: :class:`netzob.Model.Vocabulary.Symbol.Symbol` :param rate: specifies the bandwidth in octets to respect durring traffic emission (should be used with duration= parameter) :type rate: int :param duration: tells how much seconds the symbol is continuously written on the channel :type duration: int :param presets: specifies how to parameterize the emitted symbol :type presets: dict :raise TypeError if parameter is not valid and Exception if an exception occurs. """ if symbol is None: raise TypeError( "The symbol to write on the channel cannot be None") len_data = 0 if duration is None: len_data = self._writeSymbol(symbol, presets=presets) else: t_start = time.time() t_elapsed = 0 t_delta = 0 while True: t_elapsed = time.time() - t_start if t_elapsed > duration: break # Specialize the symbol and send it over the channel len_data += self._writeSymbol(symbol, presets=presets) if rate is None: t_tmp = t_elapsed t_elapsed = time.time() - t_start t_delta += t_elapsed - t_tmp else: # Wait some time to that we follow a specific rate while True: t_tmp = t_elapsed t_elapsed = time.time() - t_start t_delta += t_elapsed - t_tmp if (len_data / t_elapsed) > rate: time.sleep(0.001) else: break # Show some log every seconds if t_delta > 1: t_delta = 0 self._logger.debug( "Rate rule: {} ko/s, current rate: {} ko/s, sent data: {} ko, nb seconds elapsed: {}" .format(round(rate / 1024, 2), round((len_data / t_elapsed) / 1024, 2), round(len_data / 1024, 2), round(t_elapsed, 2))) return len_data def _writeSymbol(self, symbol, presets=None): """Write the specified symbol on the communication channel after specializing it into a contextualized message. :param symbol: the symbol to write on the channel :type symbol: :class:`netzob.Model.Vocabulary.Symbol.Symbol` :param presets: specifies how to parameterize the emitted symbol :type presets: dict :raise TypeError if parameter is not valid and Exception if an exception occurs. """ self._logger.debug("Specializing symbol '{0}' (id={1}).".format( symbol.name, symbol.id)) self.specializer.presets = presets dataBin = self.specializer.specializeSymbol(symbol).generatedContent self.specializer.presets = None self.memory = self.specializer.memory self.parser.memory = self.memory data = TypeConverter.convert(dataBin, BitArray, Raw) len_data = self.channel.write(data) self._logger.debug( "Writing {} octets to commnunication channel done..".format( len_data)) return len_data @typeCheck(int) def readSymbols(self, timeout=EmptySymbol.defaultReceptionTimeout()): """Read from the abstraction layer a flow and abstract it with one or more consecutive symbols The timeout parameter represents the amount of time (in millisecond) above which no reception of a message triggers the reception of an :class:`netzob.Model.Vocabulary.EmptySymbol.EmptySymbol`. If timeout set to None or to a negative value means it always wait for the reception of a message. :keyword timeout: the time above which no reception of message triggers the reception of an :class:`netzob.Model.Vocabulary.EmptySymbol.EmptySymbol` :type timeout: :class:`int` :raise TypeError if the parameter is not valid and Exception if an error occurs. """ self._logger.debug("Reading data from communication channel...") data = self.channel.read(timeout=timeout) self._logger.debug("Received : {}".format(repr(data))) symbols = [] # if we read some bytes, we try to abstract them if len(data) > 0: try: symbols_and_data = self.flow_parser.parseFlow( RawMessage(data), self.symbols) for (symbol, alignment) in symbols_and_data: symbols.append(symbol) except Exception as e: self._logger.error(e) if len(symbols) > 0: self.memory = self.flow_parser.memory self.specializer.memory = self.memory else: symbols.append(EmptySymbol()) if len(symbols) == 0 and len(data) > 0: msg = RawMessage(data) symbols.append(UnknownSymbol(message=msg)) return (symbols, data) @typeCheck(int) def readSymbol(self, timeout=EmptySymbol.defaultReceptionTimeout()): """Read from the abstraction layer a message and abstract it into a message. The timeout parameter represents the amount of time (in millisecond) above which no reception of a message triggers the reception of an :class:`netzob.Model.Vocabulary.EmptySymbol.EmptySymbol`. If timeout set to None or to a negative value means it always wait for the reception of a message. :keyword timeout: the time above which no reception of message triggers the reception of an :class:`netzob.Model.Vocabulary.EmptySymbol.EmptySymbol` :type timeout: :class:`int` :raise TypeError if the parameter is not valid and Exception if an error occurs. """ self._logger.debug("Reading data from communication channel...") data = self.channel.read(timeout=timeout) self._logger.debug("Received : {}".format(repr(data))) symbol = None # if we read some bytes, we try to abstract them if len(data) > 0: for potential in self.symbols: try: self.parser.parseMessage(RawMessage(data), potential) symbol = potential self.memory = self.parser.memory self.specializer.memory = self.memory break except Exception: symbol = None if symbol is None and len(data) > 0: msg = RawMessage(data) symbol = UnknownSymbol(message=msg) elif symbol is None and len(data) == 0: symbol = EmptySymbol() return (symbol, data) def openChannel(self): self.channel.open() self._logger.debug("Communication channel opened.") def closeChannel(self): self.channel.close() self._logger.debug("Communication channel close.") def reset(self): self._logger.debug("Reseting abstraction layer") self.memory = Memory() self.specializer = MessageSpecializer(memory=self.memory) self.parser = MessageParser(memory=self.memory) self.flow_parser = FlowParser(memory=self.memory)