def __init__(self, _id, name, mutable, learnable, pointedID, symbol): """Constructor of AbstractRelationVariable: @type pointedID: string @param pointedID: the pointed variable's ID. """ AbstractVariable.__init__(self, _id, name, mutable, learnable, False) self.log = logging.getLogger('netzob.Common.MMSTD.Dictionary.Variable.AbstractRelationVariable.py') self.pointedID = pointedID self.symbol = symbol self.pointedVariable = None
def __init__(self, _id, name, mutable, learnable, pointedID, symbol): """Constructor of AbstractRelationVariable: @type pointedID: string @param pointedID: the pointed variable's ID. """ AbstractVariable.__init__(self, _id, name, mutable, learnable, False) self.log = logging.getLogger( 'netzob.Common.MMSTD.Dictionary.Variable.AbstractRelationVariable.py' ) self.pointedID = pointedID self.symbol = symbol self.pointedVariable = None
def __init__(self, _id, name, mutable, random, children=None): """Constructor of AbstractNodeVariable: @type children: netzob.Common.MMSTD.Dictionary.Variable.AbstractVariable.AbstractVariable List @param children: the list of this variable's children. """ AbstractVariable.__init__(self, _id, name, mutable, random, True) # create logger with the given configuration self.log = logging.getLogger('netzob.Common.MMSTD.Dictionary.Variable.AbstractNodeVariable.py') self.children = [] if children is not None: self.children.extend(children) self.learning = False # (read access with mutable flag) Tells if the variable reads normally or through an attempt of learning.
def __init__(self, _id, name, mutable, learnable, relationType, pointedID, symbol): """Constructor of ComputedRelationVariable: Mutable and learnable are useless. @type relationType: string @param relationType: the type of computation we will use. """ AbstractVariable.__init__(self, _id, name, mutable, learnable, False) self.log = logging.getLogger('netzob.Common.MMSTD.Dictionary.Variable.ComputedRelationVariable.py') self.relationType = relationType self.currentValue = None self.pointedID = pointedID self.symbol = symbol self.pointedVariable = None
def __init__(self, _id, name, mutable, learnable, children=None): """Constructor of AbstractNodeVariable: @type children: netzob.Common.MMSTD.Dictionary.Variable.AbstractVariable.AbstractVariable List @param children: the list of this variable's children. """ AbstractVariable.__init__(self, _id, name, mutable, learnable, True) # create logger with the given configuration self.log = logging.getLogger( 'netzob.Common.MMSTD.Dictionary.Variable.AbstractNodeVariable.py') self.children = [] if children is not None: for child in children: self.addChild(child) self.learning = False # (read access with mutable flag) Tells if the variable reads normally or through an attempt of learning.
def write(self, writingToken): """write: The relation variable returns a computed or a generated value. """ self.log.debug("[ {0} (relation): write access:".format(AbstractVariable.toString(self))) self.directPointer = self.findDirectPointer() if self.isDefined(writingToken): if not self.directPointer: # We will write the real value at notification time. (An awaiting value is written though.) self.bindValue(writingToken) self.guessValue() else: # We directly retrieve and write the actual value (which would be deprecated and replaced if the variable is directPointer). self.retrieveValue(writingToken) self.writeValue(writingToken) else: self.log.debug("Write abort: the variable is not defined.") writingToken.setOk(False) # Variable notification if writingToken.isOk(): self.notifyBoundedVariables("write", writingToken) self.log.debug("Variable {0}: {1}. ]".format(self.getName(), writingToken.toString()))
def read(self, readingToken): """read: The relation variable tries to compare/learn the read value. """ self.log.debug("[ {0} (relation): read access:".format(AbstractVariable.toString(self))) self.directPointer = self.findDirectPointer() if self.isDefined(readingToken): if self.directPointer: # We directly retrieve and compare the value. self.retrieveValue(readingToken) self.compare(readingToken) else: # We make a small format comparison. self.compareFormat(readingToken) # We will verify the value at notification time. self.bindValue(readingToken) else: self.log.debug("Read abort: the variable is not defined.") readingToken.setOk(False) # Variable notification if readingToken.isOk(): self.notifyBoundedVariables("read", readingToken, self.currentValue) self.log.debug("Variable {0}: {1}. ]".format(self.getName(), readingToken.toString()))
def notifiedWrite(self, writingToken): """notify: A write access called by a notification of the pointed variable (when it has finished its own treatment). It updates the values this variable has written in the writingToken value. @type writingToken: netzob.Common.MMSTD.Dictionary.VariableProcessingToken.VariableWritingToken.VariableWritingToken @param writingToken: a token which contains all critical information on this access. """ self.log.debug("[ {0} (relation): notifiedWrite access:".format(AbstractVariable.toString(self))) if self.isDefined(writingToken): # Compute the value self.retrieveValue(writingToken) # replace the new value in the writing token writingToken.setValueForVariable(self, self.currentValue) else: self.log.debug("Write abort: the variable is neither defined, nor random.") writingToken.setOk(False) # Variable notification if writingToken.isOk(): self.notifyBoundedVariables("write", writingToken) self.log.debug("Variable {0}: {1}. ]".format(self.getName(), writingToken.toString()))
def write(self, writingToken): """write: Each child tries sequentially to write its value. If one of them fails, the whole operation is cancelled. """ self.log.debug("[ {0} (Aggregate): write access:".format(AbstractVariable.toString(self))) self.resetTokenChoppedIndexes() # New write access => new final value and new reference to it. if self.getChildren() is not None: if self.isMutable(): # mutable. self.shuffleChildren() self.writeChildren(writingToken) else: # not mutable. self.writeChildren(writingToken) else: # no child. self.log.debug("Write abort: the variable has no child.") writingToken.setOk(False) # Variable notification if writingToken.isOk(): self.notifyBoundedVariables("write", writingToken) self.log.debug("Variable {0}: {1}. ]".format(self.getName(), writingToken.toString()))
def write(self, writingToken): """write: Each child tries sequentially to write its value. If one of them fails, the whole operation is cancelled. """ self.log.debug("[ {0} (Alternate): write access:".format(AbstractVariable.toString(self))) self.resetTokenChoppedIndexes() # New write access => new final value and new reference to it. if self.getChildren() is not None: if self.isMutable(): # mutable. self.shuffleChildren() self.writeChildren(writingToken) else: # not mutable. self.writeChildren(writingToken) else: # no child. self.log.debug("Write abort: the variable has no child.") writingToken.setOk(False) # Variable notification if writingToken.isOk(): self.notifyBoundedVariables("write", writingToken) self.log.debug("Variable {0}: {1}. ]".format(self.getName(), writingToken.toString()))
def read(self, readingToken): """read: The relation variable tries to compare/learn the read value. """ self.log.debug("[ {0} (relation): read access:".format( AbstractVariable.toString(self))) self.directPointer = self.findDirectPointer() if self.isDefined(readingToken): if self.directPointer: # We directly retrieve and compare the value. self.retrieveValue(readingToken) self.compare(readingToken) else: # We make a small format comparison. self.compareFormat(readingToken) # We will verify the value at notification time. self.bindValue(readingToken) else: self.log.debug("Read abort: the variable is not defined.") readingToken.setOk(False) # Variable notification if readingToken.isOk(): self.notifyBoundedVariables("read", readingToken, self.currentValue) self.log.debug("Variable {0}: {1}. ]".format(self.getName(), readingToken.toString()))
def toString(self): """toString: """ lgth = 0 if self.children is not None: lgth = len(self.children) return _("[Alternate] {0} ({1})").format(AbstractVariable.toString(self), str(lgth))
def read(self, readingToken): """read: Each child tries sequentially to read a part of the read value. If one of them fails, the whole operation is cancelled. """ self.log.debug("[ {0} (Alternate): read access:".format(AbstractVariable.toString(self))) if self.getChildren() is not None: if self.isMutable(): # mutable. self.shuffleChildren() self.readChildren(readingToken) else: # not mutable. self.readChildren(readingToken) else: # no child. self.log.debug("Write abort: the variable has no child.") readingToken.setOk(False) # Variable notification if readingToken.isOk(): self.notifyBoundedVariables("read", readingToken, self.currentValue) self.log.debug("Variable {0}: {1}. ]".format(self.getName(), readingToken.toString()))
def writeChildren(self, writingToken): """write: Each child tries to write its value.. If it fails, it restore it value and the next child try. It stops if one child successes. """ self.log.debug("[ {0} (Alternate): writeChildren:".format(AbstractVariable.toString(self))) savedValue = writingToken.getValue() savedIndex = writingToken.getIndex() for child in self.getChildren(): # Memorized values for the child and its successor. dictOfValues = dict() dictOfValue = child.getDictOfValues(writingToken) for key, val in dictOfValue.iteritems(): dictOfValues[key] = val child.write(writingToken) if writingToken.isOk() and writingToken.getValue() is not None: break else: writingToken.setValue(savedValue) # We restore values for the child and its successor. child.restore(writingToken) vocabulary = writingToken.getVocabulary() for key, val in dictOfValues.iteritems(): vocabulary.getVariableByID(key).setCurrentValue(val) if writingToken.isOk(): # The value of the variable is simply the value we made. self.currentValue = writingToken.getValue()[savedIndex:writingToken.getIndex()] self.log.debug("Variable {0}: {1}. ]".format(self.getName(), writingToken.toString()))
def toString(self): """toString: """ lgth = 0 if self.getChildren() is not None: lgth = len(self.getChildren()) return _("[Aggregate] {0} ({1})").format(AbstractVariable.toString(self), str(lgth))
def read(self, readingToken): """read: Each child tries sequentially to read a part of the read value. If one of them fails, the whole operation is cancelled. """ self.log.debug("[ {0} (Aggregate): read access:".format(AbstractVariable.toString(self))) if self.getChildren() is not None: if self.isMutable(): # mutable. self.sortChildrenToRead(readingToken) self.readChildren(readingToken) else: # not mutable. self.readChildren(readingToken) else: # no child. self.log.debug("Write abort: the variable has no child.") readingToken.setOk(False) # Variable notification if readingToken.isOk(): self.notifyBoundedVariables("read", readingToken, self.currentValue) self.log.debug("Variable {0}: {1}. ]".format(self.getName(), readingToken.toString()))
def loadFromXML(xmlRoot, namespace, version, symbol): """loadFromXML: Loads a repeat variable from an XML definition. We do not trust the user and check every field (even mandatory). """ logging.debug("[ RepeatVariable: loadFromXML:") if version == "0.1": xmlID = xmlRoot.get("id") xmlName = xmlRoot.get("name") xmlMutable = xmlRoot.get("mutable") == "True" xmlLearnable = xmlRoot.get("learnable") == "True" xmlChild = xmlRoot.find("{" + namespace + "}variable") child = AbstractVariable.loadFromXML(xmlChild, namespace, version, symbol) # minIterations xmlMinIterations = xmlRoot.find("{" + namespace + "}minIterations") if xmlMinIterations is not None: minIterations = int(xmlMinIterations.text) else: minIterations = 0 # maxIterations xmlMaxIterations = xmlRoot.find("{" + namespace + "}maxIterations") if xmlMaxIterations is not None: maxIterations = int(xmlMaxIterations.text) else: maxIterations = RepeatVariable.MAX_ITERATIONS result = RepeatVariable(xmlID, xmlName, xmlMutable, xmlLearnable, child, minIterations, maxIterations) logging.debug("RepeatVariable: loadFromXML successes: {0} ]".format(result.toString())) return result logging.debug("RepeatVariable: loadFromXML fails") return None
def notifiedRead(self, readingToken, pointedValue): """notifiedRead: A read access called by a notification of the pointed variable (when it has finished its own treatment). It checks that the new value complies with the reading token value at this very position. @type readingToken: netzob.Common.MMSTD.Dictionary.VariableProcessingToken.VariableReadingToken.VariableReadingToken @param readingToken: a token which contains all critical information on this access. """ self.log.debug("[ {0} (relation): read access:".format(AbstractVariable.toString(self))) if self.isDefined(readingToken): for linkedValue in readingToken.getLinkedValue(): if linkedValue[0] == self.getID(): # We compare the pointed value to the value the current variable wrote in memory. if linkedValue[1] != self.computeValue(pointedValue): readingToken.setOk(False) break else: self.log.debug("Read abort: the variable is neither defined, nor mutable.") readingToken.setOk(False) # Variable notification if readingToken.isOk(): self.notifyBoundedVariables("read", readingToken, pointedValue) self.log.debug("Variable {0}: {1}. ]".format(self.getName(), readingToken.toString()))
def write(self, writingToken): """write: The relation variable returns a computed or a generated value. """ self.log.debug("[ {0} (relation): write access:".format( AbstractVariable.toString(self))) self.resetTokenChoppedIndexes( ) # New write access => new final value and new reference to it. self.directPointer = self.findDirectPointer() if self.isDefined(writingToken): if not self.directPointer: # We will write the real value at notification time. (An awaiting value is written though.) self.bindValue(writingToken) self.guessValue() else: # We directly retrieve and write the actual value (which would be deprecated and replaced if the variable is directPointer). self.retrieveValue(writingToken) self.writeValue(writingToken) else: self.log.debug("Write abort: the variable is not defined.") writingToken.setOk(False) # Variable notification if writingToken.isOk(): self.notifyBoundedVariables("write", writingToken) self.log.debug("Variable {0}: {1}. ]".format(self.getName(), writingToken.toString()))
def notifiedRead(self, readingToken, pointedValue): """notifiedRead: A read access called by a notification of the pointed variable (when it has finished its own treatment). It checks that the new value complies with the reading token value at this very position. @type readingToken: netzob.Common.MMSTD.Dictionary.VariableProcessingToken.VariableReadingToken.VariableReadingToken @param readingToken: a token which contains all critical information on this access. """ self.log.debug("[ {0} (relation): read access:".format( AbstractVariable.toString(self))) if self.isDefined(readingToken): for linkedValue in readingToken.getLinkedValue(): if linkedValue[0] == self.getID(): # We compare the pointed value to the value the current variable wrote in memory. if linkedValue[1] != self.computeValue(pointedValue): readingToken.setOk(False) break else: self.log.debug( "Read abort: the variable is neither defined, nor mutable.") readingToken.setOk(False) # Variable notification if readingToken.isOk(): self.notifyBoundedVariables("read", readingToken, pointedValue) self.log.debug("Variable {0}: {1}. ]".format(self.getName(), readingToken.toString()))
def notifiedWrite(self, writingToken): """notify: A write access called by a notification of the pointed variable (when it has finished its own treatment). It updates the values this variable has written in the writingToken value. @type writingToken: netzob.Common.MMSTD.Dictionary.VariableProcessingToken.VariableWritingToken.VariableWritingToken @param writingToken: a token which contains all critical information on this access. """ self.log.debug("[ {0} (relation): notifiedWrite access:".format( AbstractVariable.toString(self))) if self.isDefined(writingToken): # Compute the value self.retrieveValue(writingToken) # replace the new value in the writing token writingToken.setValueForVariable(self, self.currentValue) else: self.log.debug( "Write abort: the variable is neither defined, nor random.") writingToken.setOk(False) # Variable notification if writingToken.isOk(): self.notifyBoundedVariables("write", writingToken) self.log.debug("Variable {0}: {1}. ]".format(self.getName(), writingToken.toString()))
def toString(self): """toString: """ lgth = 0 if self.getChildren() is not None: lgth = len(self.getChildren()) return _("[Aggregate] {0} ({1})").format( AbstractVariable.toString(self), str(lgth))
def __init__(self, _id, name, mutable, learnable, relationType, pointedID, symbol): """Constructor of ComputedRelationVariable: Mutable and learnable are useless. @type relationType: string @param relationType: the type of computation we will use. """ AbstractVariable.__init__(self, _id, name, mutable, learnable, False) self.log = logging.getLogger( 'netzob.Common.MMSTD.Dictionary.Variable.ComputedRelationVariable.py' ) self.relationType = relationType self.currentValue = None self.pointedID = pointedID self.symbol = symbol self.pointedVariable = None
def read(self, readingToken): """read: The leaf element tries to compare/learn the read value. """ self.log.debug("[ {0} (leaf): read access:".format(AbstractVariable.toString(self))) if self.isMutable(): if self.isLearnable(): if self.isDefined(readingToken): # mutable, learnable and defined. self.forget(readingToken) self.compareFormat(readingToken) self.learn(readingToken) self.memorize(readingToken) else: # mutable, learnable and not defined. self.compareFormat(readingToken) self.learn(readingToken) self.memorize(readingToken) else: if self.isDefined(readingToken): # mutable, not learnable and defined. self.compareFormat(readingToken) else: # mutable, learnable and not defined. self.compareFormat(readingToken) else: if self.isLearnable(): if self.isDefined(readingToken): # not mutable, learnable and defined. self.compare(readingToken) else: # not mutable, learnable and not defined. self.compareFormat(readingToken) self.learn(readingToken) self.memorize(readingToken) else: if self.isDefined(readingToken): # not mutable, not learnable and defined. self.compare(readingToken) else: # not mutable, not learnable and not defined. self.log.debug("Read abort: the variable is neither defined, nor mutable.") readingToken.setOk(False) # Variable notification if readingToken.isOk(): self.notifyBoundedVariables("read", readingToken, self.getValue(readingToken)) self.log.debug("Variable {0}: {1}. ]".format(self.getName(), readingToken.toString()))
def write(self, writingToken): """write: The leaf element returns its value or a generated one. """ self.log.debug("[ {0} (leaf): write access:".format(AbstractVariable.toString(self))) self.resetTokenChoppedIndexes() # New write access => new final value and new reference to it. if self.isMutable(): if self.isLearnable(): if self.isDefined(writingToken): # mutable, learnable and defined. self.mutate(writingToken) self.writeValue(writingToken) else: # mutable, learnable and not defined. self.generate(writingToken) self.memorize(writingToken) self.writeValue(writingToken) else: if self.isDefined(writingToken): # mutable, not learnable, defined. self.generate(writingToken) self.writeValue(writingToken) else: # mutable, not learnable, not defined. self.generate(writingToken) self.writeValue(writingToken) else: if self.isLearnable(): if self.isDefined(writingToken): # not mutable, learnable and defined. self.writeValue(writingToken) else: # not mutable, learnable and not defined. self.generate(writingToken) self.memorize(writingToken) self.writeValue(writingToken) else: if self.isDefined(writingToken): # not mutable, not learnable and defined. self.writeValue(writingToken) else: # not mutable, not learnable and not defined. self.log.debug("Write abort: the variable is neither defined, nor mutable.") writingToken.setOk(False) # Variable notification if writingToken.isOk(): self.notifyBoundedVariables("write", writingToken) self.log.debug("Variable {0}: {1}. ]".format(self.getName(), writingToken.toString()))
def toString(self): """toString: For debugging purpose. """ # We simply avoid to print unreadable binary. if self.type.getType() == BinaryType.TYPE: readableValue = TypeConvertor.bin2strhex(self.originalValue) else: readableValue = self.bin2str(self.originalValue) return "[Data] {0}, type: {1}, original value: {2}".format(AbstractVariable.toString(self), self.type.toString(), readableValue)
def toString(self): """toString: For debugging purpose. """ # We simply avoid to print unreadable binary. if self.type.getType() == BinaryType.TYPE: readableValue = TypeConvertor.bin2strhex(self.originalValue) else: readableValue = self.bin2str(self.originalValue) return "[Data] {0}, type: {1}, original value: {2}".format( AbstractVariable.toString(self), self.type.toString(), readableValue)
def toXML(self, root, namespace): """toXML: Creates the xml tree associated to this variable. Adds every child's own xml definition as xml child to this tree. """ self.log.debug("[ {0} (Aggregate): toXML:".format(AbstractVariable.toString(self))) xmlVariable = etree.SubElement(root, "{" + namespace + "}variable") xmlVariable.set("id", str(self.getID())) xmlVariable.set("name", str(self.getName())) xmlVariable.set("{http://www.w3.org/2001/XMLSchema-instance}type", "netzob:AggregateVariable") xmlVariable.set("mutable", str(self.isMutable())) xmlVariable.set("learnable", str(self.isLearnable())) # Definition of children variables for child in self.getChildren(): child.toXML(xmlVariable, namespace) self.log.debug("Variable {0}. ]".format(self.getName()))
def toXML(self, root, namespace): """toXML: Creates the xml tree associated to this variable. Adds every child's own xml definition as xml child to this tree. """ self.log.debug("[ {0} (Aggregate): toXML:".format( AbstractVariable.toString(self))) xmlVariable = etree.SubElement(root, "{" + namespace + "}variable") xmlVariable.set("id", str(self.getID())) xmlVariable.set("name", str(self.getName())) xmlVariable.set("{http://www.w3.org/2001/XMLSchema-instance}type", "netzob:AggregateVariable") xmlVariable.set("mutable", str(self.isMutable())) xmlVariable.set("learnable", str(self.isLearnable())) # Definition of children variables for child in self.getChildren(): child.toXML(xmlVariable, namespace) self.log.debug("Variable {0}. ]".format(self.getName()))
def loadFromXML(xmlRoot, namespace, version, symbol): """loadFromXML: Loads an aggregate variable from an XML definition. """ logging.debug("[ AggregateVariable: loadFromXML:") if version == "0.1": xmlID = xmlRoot.get("id") xmlName = xmlRoot.get("name") xmlMutable = xmlRoot.get("mutable") == "True" xmlLearnable = xmlRoot.get("learnable") == "True" result = AggregateVariable(xmlID, xmlName, xmlMutable, xmlLearnable, []) for xmlChildren in xmlRoot.findall("{" + namespace + "}variable"): child = AbstractVariable.loadFromXML(xmlChildren, namespace, version, symbol) result.addChild(child) logging.debug("AggregateVariable: loadFromXML successes: {0} ]".format(result.toString())) return result logging.debug("AggregateVariable: loadFromXML fails") return None
def loadFromXML(xmlRoot, namespace, version, symbol): """loadFromXML: Loads an alternate variable from an XML definition. """ logging.debug("[ AlternateVariable: loadFromXML:") if version == "0.1": xmlID = xmlRoot.get("id") xmlName = xmlRoot.get("name") xmlMutable = xmlRoot.get("mutable") == "True" xmlLearnable = xmlRoot.get("learnable") == "True" result = AlternateVariable(xmlID, xmlName, xmlMutable, xmlLearnable, []) for xmlChildren in xmlRoot.findall("{" + namespace + "}variable"): child = AbstractVariable.loadFromXML(xmlChildren, namespace, version, symbol) result.addChild(child) logging.debug("AlternateVariable: loadFromXML successes: {0} ]".format(result.toString())) return result logging.debug("AlternateVariable: loadFromXML fails") return None
def loadFromXML(xmlRoot, namespace, version, symbol): """loadFromXML: Loads a repeat variable from an XML definition. We do not trust the user and check every field (even mandatory). """ logging.debug("[ RepeatVariable: loadFromXML:") if version == "0.1": xmlID = xmlRoot.get("id") xmlName = xmlRoot.get("name") xmlMutable = xmlRoot.get("mutable") == "True" xmlLearnable = xmlRoot.get("learnable") == "True" xmlChild = xmlRoot.find("{" + namespace + "}variable") child = AbstractVariable.loadFromXML(xmlChild, namespace, version, symbol) # minIterations xmlMinIterations = xmlRoot.find("{" + namespace + "}minIterations") if xmlMinIterations is not None: minIterations = int(xmlMinIterations.text) else: minIterations = 0 # maxIterations xmlMaxIterations = xmlRoot.find("{" + namespace + "}maxIterations") if xmlMaxIterations is not None: maxIterations = int(xmlMaxIterations.text) else: maxIterations = RepeatVariable.MAX_ITERATIONS result = RepeatVariable(xmlID, xmlName, xmlMutable, xmlLearnable, child, minIterations, maxIterations) logging.debug( "RepeatVariable: loadFromXML successes: {0} ]".format( result.toString())) return result logging.debug("RepeatVariable: loadFromXML fails") return None
def readChildren(self, readingToken): """read: Each child tries to read the value. If it fails, it restore it value and the next child try. It stops if one child successes. """ self.log.debug("[ {0} (Alternate): readChildren:".format(AbstractVariable.toString(self))) savedIndex = readingToken.getIndex() for child in self.getChildren(): # Memorized values for the child and its successors. dictOfValues = dict() dictOfValue = child.getDictOfValues(readingToken) for key, val in dictOfValue.iteritems(): dictOfValues[key] = val child.read(readingToken) if readingToken.isOk(): break else: readingToken.setIndex(savedIndex) # We restore values for the child and its successors. child.restore(readingToken) vocabulary = readingToken.getVocabulary() for key, val in dictOfValues.iteritems(): vocabulary.getVariableByID(key).setCurrentValue(val) if readingToken.isOk(): # The value of the variable is simply the value we 'ate'. self.currentValue = readingToken.getValue()[savedIndex:readingToken.getIndex()] if self.isLearnable() and not readingToken.isOk() and not self.isLearning(): # If we dont not found a proper child but the node can learn, we learn the value. self.learn(child, readingToken) self.log.debug("Variable {0}: {1}. ]".format(self.getName(), readingToken.toString()))
def toString(self): """toString: """ return "[Repeat] {0}, iterations: ({1}, {2})".format( AbstractVariable.toString(self), str(self.minIterations), str(self.maxIterations))
def __init__(self, _id, name, mutable, learnable): """Constructor of AbstractLeafVariable: """ AbstractVariable.__init__(self, _id, name, mutable, learnable, False) self.log = logging.getLogger('netzob.Common.MMSTD.Dictionary.Variable.AbstractLeafVariable.py')
def write(self, writingToken): """write: The leaf element returns its value or a generated one. """ self.log.debug("[ {0} (leaf): write access:".format( AbstractVariable.toString(self))) self.resetTokenChoppedIndexes( ) # New write access => new final value and new reference to it. if self.isMutable(): if self.isLearnable(): if self.isDefined(writingToken): # mutable, learnable and defined. self.mutate(writingToken) self.writeValue(writingToken) else: # mutable, learnable and not defined. self.generate(writingToken) self.memorize(writingToken) self.writeValue(writingToken) else: if self.isDefined(writingToken): # mutable, not learnable, defined. self.generate(writingToken) self.writeValue(writingToken) else: # mutable, not learnable, not defined. self.generate(writingToken) self.writeValue(writingToken) else: if self.isLearnable(): if self.isDefined(writingToken): # not mutable, learnable and defined. self.writeValue(writingToken) else: # not mutable, learnable and not defined. self.generate(writingToken) self.memorize(writingToken) self.writeValue(writingToken) else: if self.isDefined(writingToken): # not mutable, not learnable and defined. self.writeValue(writingToken) else: # not mutable, not learnable and not defined. self.log.debug( "Write abort: the variable is neither defined, nor mutable." ) writingToken.setOk(False) # Variable notification if writingToken.isOk(): self.notifyBoundedVariables("write", writingToken) self.log.debug("Variable {0}: {1}. ]".format(self.getName(), writingToken.toString()))
def __init__(self, _id, name, mutable, learnable): """Constructor of AbstractLeafVariable: """ AbstractVariable.__init__(self, _id, name, mutable, learnable, False) self.log = logging.getLogger( 'netzob.Common.MMSTD.Dictionary.Variable.AbstractLeafVariable.py')
def toString(self): """toString: """ return "[Computed Relation] {0}, pointed ID: {1}, type: {2}.".format(AbstractVariable.toString(self), str(self.getPointedID()), self.relationType.toString())
def toString(self): """toString: """ return "[Repeat] {0}, iterations: ({1}, {2})".format(AbstractVariable.toString(self), str(self.minIterations), str(self.maxIterations))
def toString(self): """toString: """ return "[Direct Relation] {0}, pointed ID: {1}".format(AbstractVariable.toString(self), str(self.getPointedID()))
def read(self, readingToken): """read: The leaf element tries to compare/learn the read value. """ self.log.debug("[ {0} (leaf): read access:".format( AbstractVariable.toString(self))) if self.isMutable(): if self.isLearnable(): if self.isDefined(readingToken): # mutable, learnable and defined. self.forget(readingToken) self.compareFormat(readingToken) self.learn(readingToken) self.memorize(readingToken) else: # mutable, learnable and not defined. self.compareFormat(readingToken) self.learn(readingToken) self.memorize(readingToken) else: if self.isDefined(readingToken): # mutable, not learnable and defined. self.compareFormat(readingToken) else: # mutable, learnable and not defined. self.compareFormat(readingToken) else: if self.isLearnable(): if self.isDefined(readingToken): # not mutable, learnable and defined. self.compare(readingToken) else: # not mutable, learnable and not defined. self.compareFormat(readingToken) self.learn(readingToken) self.memorize(readingToken) else: if self.isDefined(readingToken): # not mutable, not learnable and defined. self.compare(readingToken) else: # not mutable, not learnable and not defined. self.log.debug( "Read abort: the variable is neither defined, nor mutable." ) readingToken.setOk(False) # Variable notification if readingToken.isOk(): self.notifyBoundedVariables("read", readingToken, self.getValue(readingToken)) self.log.debug("Variable {0}: {1}. ]".format(self.getName(), readingToken.toString()))
def toString(self): """toString: """ return "[Computed Relation] {0}, pointed ID: {1}, type: {2}.".format( AbstractVariable.toString(self), str(self.getPointedID()), self.relationType.toString())