def getRoot(self): # We create an aggregate of all the fields rootSymbol = AggregateVariable(self.getID(), self.getName(), False, False, None) for field in self.getExtendedFields(): variable = field.getVariable() rootSymbol.addChild(variable) return rootSymbol
def addAggregate(self, event, rootVariable, rootEntry): # Display the form for the creation of a word variable dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK, None) dialog.set_markup(_("Definition of the Aggregate")) # Create the ID of the new variable variableID = str(uuid.uuid4()) mainTable = gtk.Table(rows=3, columns=2, homogeneous=False) # parent id of the variable variablePIDLabel = gtk.Label(_("Parent ID:")) variablePIDLabel.show() variablePIDValueLabel = gtk.Label(str(rootVariable.getID())) variablePIDValueLabel.set_sensitive(False) variablePIDValueLabel.show() mainTable.attach(variablePIDLabel, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variablePIDValueLabel, 1, 2, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # id of the variable variableIDLabel = gtk.Label(_("ID:")) variableIDLabel.show() variableIDValueLabel = gtk.Label(variableID) variableIDValueLabel.set_sensitive(False) variableIDValueLabel.show() mainTable.attach(variableIDLabel, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variableIDValueLabel, 1, 2, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # name of the variable variableValueLabel = gtk.Label(_("Name:")) variableValueLabel.show() variableValueEntry = gtk.Entry() variableValueEntry.show() mainTable.attach(variableValueLabel, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variableValueEntry, 1, 2, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) dialog.vbox.pack_end(mainTable, True, True, 0) dialog.show_all() result = dialog.run() if result != gtk.RESPONSE_OK: dialog.destroy() return # We retrieve the name of the variable varName = variableValueEntry.get_text() # Creation of the aggregate id, name, mutable, value): aggregateVariable = AggregateVariable(variableID, varName, None) rootVariable.addChild(aggregateVariable) self.datas[str(aggregateVariable.getID())] = aggregateVariable self.treestore.append(rootEntry, [str(aggregateVariable.getID()), _("Aggregate")]) # We close the current dialog dialog.destroy()
def loadFromXML(xmlRoot, namespace, version, symbol): """loadFromXML: Load a variable from an XML definition. Calls its proper heir function for it to create the variable. @type xmlRoot: lxml.etree.Element @param xmlRoot: the root of the XML definition. @type namespace: string @param namespace: the namespace (precision) associated to the variable in the XML definition. @type version: string @param version: the load version. @rtype: netzob.Common.MMSTD.Dictionary.Variable.AbstractVariable.AbstractVariable @type symbol: netzob.Common.Symbol @param symbol: the symbol in which the current variable is placed, used by relation variable. @return: a variable constructed from this XML definition. """ if version == "0.1": logging.debug("[ AbstractVariable: loadFromXML:") # Data Variable if xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:DataVariable": from netzob.Common.MMSTD.Dictionary.Variables.DataVariable import DataVariable return DataVariable.loadFromXML(xmlRoot, namespace, version, symbol) # Aggregate Variable elif xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:AggregateVariable": from netzob.Common.MMSTD.Dictionary.Variables.AggregateVariable import AggregateVariable return AggregateVariable.loadFromXML(xmlRoot, namespace, version, symbol) # Alternate Variable elif xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:AlternateVariable": from netzob.Common.MMSTD.Dictionary.Variables.AlternateVariable import AlternateVariable return AlternateVariable.loadFromXML(xmlRoot, namespace, version, symbol) # Repeat Variable elif xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:RepeatVariable": from netzob.Common.MMSTD.Dictionary.Variables.RepeatVariable import RepeatVariable return RepeatVariable.loadFromXML(xmlRoot, namespace, version, symbol) # Direct Relation Variable #elif xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:DirectRelationVariable": # from netzob.Common.MMSTD.Dictionary.Variables.DirectRelationVariable import DirectRelationVariable # return DirectRelationVariable.loadFromXML(xmlRoot, namespace, version, symbol) # Computed Relation Variable elif xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:ComputedRelationVariable": from netzob.Common.MMSTD.Dictionary.Variables.ComputedRelationVariable import ComputedRelationVariable return ComputedRelationVariable.loadFromXML(xmlRoot, namespace, version, symbol) else: logging.debug("xmlRoot.get(...) returns {0} which does not correspond to a true variable class.").format(xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract")) logging.debug("AbstractVariable: loadFromXML ]") else: logging.debug("Version != 0.1")
def __init__(self, netzob, field, variableId, variableName, defaultValue=None): # create logger with the given configuration self.log = logging.getLogger('netzob.Inference.Vocabulary.VariableView.py') self.netzob = netzob self.project = self.netzob.getCurrentProject() self.varId = variableId self.varName = variableName self.field = field self.defaultValue = defaultValue self.datas = dict() # Add the initial Aggregate self.rootVariable = AggregateVariable(variableId, self.varName, None) if self.defaultValue != None: self.rootVariable.addChild(self.defaultValue)
def loadFromXML(xmlRoot, namespace, version): if version == "0.1": # IPv4 Variable if xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:IPv4Variable": from netzob.Common.MMSTD.Dictionary.Variables.IPv4Variable import IPv4Variable return IPv4Variable.loadFromXML(xmlRoot, namespace, version) # Word Variable if xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:WordVariable": from netzob.Common.MMSTD.Dictionary.Variables.WordVariable import WordVariable return WordVariable.loadFromXML(xmlRoot, namespace, version) # DecimalWord Variable if xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:DecimalWordVariable": from netzob.Common.MMSTD.Dictionary.Variables.DecimalWordVariable import DecimalWordVariable return DecimalWordVariable.loadFromXML(xmlRoot, namespace, version) # Binary Variable if xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:BinaryVariable": from netzob.Common.MMSTD.Dictionary.Variables.BinaryVariable import BinaryVariable return BinaryVariable.loadFromXML(xmlRoot, namespace, version) # Hex Variable if xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:HexVariable": from netzob.Common.MMSTD.Dictionary.Variables.HexVariable import HexVariable return HexVariable.loadFromXML(xmlRoot, namespace, version) # Aggregate Variable if xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:AggregateVariable": from netzob.Common.MMSTD.Dictionary.Variables.AggregateVariable import AggregateVariable return AggregateVariable.loadFromXML(xmlRoot, namespace, version) # Alternate Variable if xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:AlternateVariable": from netzob.Common.MMSTD.Dictionary.Variables.AlternateVariable import AlternateVariable return AlternateVariable.loadFromXML(xmlRoot, namespace, version) # Referenced Variable if xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:ReferencedVariable": from netzob.Common.MMSTD.Dictionary.Variables.ReferencedVariable import ReferencedVariable return ReferencedVariable.loadFromXML(xmlRoot, namespace, version)
class VariableView(object): #+---------------------------------------------- #| Constructor: #+---------------------------------------------- def __init__(self, netzob, field, variableId, variableName, defaultValue=None): # create logger with the given configuration self.log = logging.getLogger('netzob.Inference.Vocabulary.VariableView.py') self.netzob = netzob self.project = self.netzob.getCurrentProject() self.varId = variableId self.varName = variableName self.field = field self.defaultValue = defaultValue self.datas = dict() # Add the initial Aggregate self.rootVariable = AggregateVariable(variableId, self.varName, None) if self.defaultValue != None: self.rootVariable.addChild(self.defaultValue) def display(self): # We display the dedicated dialog for the creation of a variable self.dialog = gtk.Dialog(title=_("Creation of a variable"), flags=0, buttons=None) # Create the main panel self.panel = gtk.Table(rows=2, columns=3, homogeneous=False) self.treestore = gtk.TreeStore(str, str) # id of the data, description self.treeview = gtk.TreeView(self.treestore) self.treeview.connect('button-press-event', self.showMenu) # messages list self.scroll = gtk.ScrolledWindow() self.scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.scroll.show() self.scroll.set_size_request(200, 300) self.scroll.add(self.treeview) self.scroll.show() self.lvcolumn = gtk.TreeViewColumn(_("Description of the variable")) self.lvcolumn.set_sort_column_id(1) cell = gtk.CellRendererText() self.lvcolumn.pack_start(cell, True) self.lvcolumn.set_attributes(cell, text=1) self.treeview.append_column(self.lvcolumn) self.treeview.show() self.panel.attach(self.scroll, 0, 2, 0, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) self.panel.show() # Create button createButton = gtk.Button(_("Create")) createButton.show() createButton.connect("clicked", self.createVariable) self.panel.attach(createButton, 0, 2, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # We register the default values self.registerVariable(None, self.rootVariable, "Root") def registerVariable(self, rootEntry, variable, name): self.log.debug(_("Register: {0}").format(str(name))) self.datas[str(variable.getID())] = variable newEntry = self.treestore.append(rootEntry, [str(variable.getID()), name]) if variable.getTypeVariable() == AggregateVariable.TYPE or variable.getTypeVariable() == AlternateVariable.TYPE: for child in variable.getChildren(): self.registerVariable(newEntry, child, child.getName()) self.dialog.vbox.pack_start(self.panel, True, True, 0) self.dialog.show() def createVariable(self, button): # We register the root variable as the variable of specified field self.field.setVariable(self.rootVariable) self.dialog.destroy() # Update UI page = self.netzob.getCurrentNotebookPage() if page != None: page.update() def showMenu(self, treeview, event): rootVariable = None if event.type == gtk.gdk.BUTTON_PRESS and event.button == 3: x = int(event.x) y = int(event.y) (path, treeviewColumn, x, y) = treeview.get_path_at_pos(x, y) # Retrieve the selected variable variable_id = None aIter = treeview.get_model().get_iter(path) if aIter: if treeview.get_model().iter_is_valid(aIter): variable_id = treeview.get_model().get_value(aIter, 0) for varid in self.datas.keys(): if varid == variable_id: rootVariable = self.datas[varid] if rootVariable == None: self.log.debug(_("Impossible to find the selected variable.")) return # We display the menu for the insertion of sub-elements if its an Aggregate or an Alternative menu = gtk.Menu() subElementMenu = gtk.Menu() # Word Variable itemWord = gtk.MenuItem(_("Word")) itemWord.show() itemWord.connect("activate", self.addWord, rootVariable, aIter) subElementMenu.append(itemWord) # Decimal Word Variable itemDecimalWord = gtk.MenuItem(_("Decimal Word")) itemDecimalWord.show() itemDecimalWord.connect("activate", self.addDecimalWord, rootVariable, aIter) subElementMenu.append(itemDecimalWord) # IPv4 Variable itemIPv4 = gtk.MenuItem(_("IPv4")) itemIPv4.show() itemIPv4.connect("activate", self.addIPv4, rootVariable, aIter) subElementMenu.append(itemIPv4) # Binary Variable itemBinary = gtk.MenuItem(_("Binary")) itemBinary.show() itemBinary.connect("activate", self.addBinary, rootVariable, aIter) subElementMenu.append(itemBinary) # Hexadecimal Variable itemBinary = gtk.MenuItem(_("Hexadecimal")) itemBinary.show() itemBinary.connect("activate", self.addHexadecimal, rootVariable, aIter) subElementMenu.append(itemBinary) # Aggregate Variable itemAggregate = gtk.MenuItem(_("Aggregate")) itemAggregate.show() itemAggregate.connect("activate", self.addAggregate, rootVariable, aIter) subElementMenu.append(itemAggregate) # Alternate Variable itemAlternate = gtk.MenuItem(_("Alternative")) itemAlternate.show() itemAlternate.connect("activate", self.addAlternate, rootVariable, aIter) subElementMenu.append(itemAlternate) # Referenced Variable itemAlternate = gtk.MenuItem(_("Referenced Variable")) itemAlternate.show() itemAlternate.connect("activate", self.addReferencedVariable, rootVariable, aIter) subElementMenu.append(itemAlternate) item = gtk.MenuItem(_("Add a sub-element")) item.set_submenu(subElementMenu) item.show() menu.append(item) menu.popup(None, None, None, event.button, event.time) def addBinary(self, event, rootVariable, rootEntry): # Display the form for the creation of a Binary variable dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK, None) dialog.set_markup(_("Definition of the Binary Variable")) # Create the ID of the new variable varID = uuid.uuid4() variableID = str(varID) mainTable = gtk.Table(rows=3, columns=2, homogeneous=False) # parent id of the variable variablePIDLabel = gtk.Label(_("Parent ID:")) variablePIDLabel.show() variablePIDValueLabel = gtk.Label(str(rootVariable.getID())) variablePIDValueLabel.set_sensitive(False) variablePIDValueLabel.show() mainTable.attach(variablePIDLabel, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variablePIDValueLabel, 1, 2, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # id of the variable variableIDLabel = gtk.Label(_("ID:")) variableIDLabel.show() variableIDValueLabel = gtk.Label(variableID) variableIDValueLabel.set_sensitive(False) variableIDValueLabel.show() mainTable.attach(variableIDLabel, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variableIDValueLabel, 1, 2, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # Original Value originalValueLabel = gtk.Label(_("Original value:")) originalValueLabel.show() originalValueEntry = gtk.Entry() originalValueEntry.show() mainTable.attach(originalValueLabel, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(originalValueEntry, 1, 2, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # Constraints label constraintsLabel = gtk.Label(_("Constraints when parsing / generating")) constraintsLabel.show() mainTable.attach(constraintsLabel, 0, 2, 3, 4, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # start Value minBitsLabel = gtk.Label(_("Minimum number of bits:")) minBitsLabel.show() minBitsEntry = gtk.Entry() minBitsEntry.show() mainTable.attach(minBitsLabel, 0, 1, 4, 5, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(minBitsEntry, 1, 2, 4, 5, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # end Value maxBitsLabel = gtk.Label(_("Maximum number of bits:")) maxBitsLabel.show() maxBitsEntry = gtk.Entry() maxBitsEntry.show() mainTable.attach(maxBitsLabel, 0, 1, 5, 6, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(maxBitsEntry, 1, 2, 5, 6, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) dialog.vbox.pack_end(mainTable, True, True, 0) dialog.show_all() result = dialog.run() if result != gtk.RESPONSE_OK: dialog.destroy() return # Creation of the variable (binary) # original value : originalValue = originalValueEntry.get_text() if len(originalValue) == 0: originalValue = None # constraints minSize = int(minBitsEntry.get_text()) maxSize = int(maxBitsEntry.get_text()) binVariable = BinaryVariable(varID, "binary", originalValue, minSize, maxSize) rootVariable.addChild(binVariable) self.datas[str(binVariable.getID())] = binVariable self.treestore.append(rootEntry, [str(binVariable.getID()), binVariable.getUncontextualizedDescription()]) # We close the current dialog dialog.destroy() def addHexadecimal(self, event, rootVariable, rootEntry): # Display the form for the creation of an Hexadecimal variable dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK, None) dialog.set_markup(_("Definition of the Hexadecimal Variable")) # Create the ID of the new variable varID = uuid.uuid4() variableID = str(varID) mainTable = gtk.Table(rows=3, columns=2, homogeneous=False) # parent id of the variable variablePIDLabel = gtk.Label(_("Parent ID:")) variablePIDLabel.show() variablePIDValueLabel = gtk.Label(str(rootVariable.getID())) variablePIDValueLabel.set_sensitive(False) variablePIDValueLabel.show() mainTable.attach(variablePIDLabel, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variablePIDValueLabel, 1, 2, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # id of the variable variableIDLabel = gtk.Label(_("ID:")) variableIDLabel.show() variableIDValueLabel = gtk.Label(variableID) variableIDValueLabel.set_sensitive(False) variableIDValueLabel.show() mainTable.attach(variableIDLabel, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variableIDValueLabel, 1, 2, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # Original Value originalValueLabel = gtk.Label(_("Original value:")) originalValueLabel.show() originalValueEntry = gtk.Entry() originalValueEntry.show() mainTable.attach(originalValueLabel, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(originalValueEntry, 1, 2, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # Constraints label constraintsLabel = gtk.Label(_("Constraints when parsing / generating")) constraintsLabel.show() mainTable.attach(constraintsLabel, 0, 2, 3, 4, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # start Value minBitsLabel = gtk.Label(_("Minimum number of hex (0xf=1):")) minBitsLabel.show() minBitsEntry = gtk.Entry() minBitsEntry.show() mainTable.attach(minBitsLabel, 0, 1, 4, 5, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(minBitsEntry, 1, 2, 4, 5, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # end Value maxBitsLabel = gtk.Label(_("Maximum number of hex:")) maxBitsLabel.show() maxBitsEntry = gtk.Entry() maxBitsEntry.show() mainTable.attach(maxBitsLabel, 0, 1, 5, 6, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(maxBitsEntry, 1, 2, 5, 6, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) dialog.vbox.pack_end(mainTable, True, True, 0) dialog.show_all() result = dialog.run() if result != gtk.RESPONSE_OK: dialog.destroy() return # Creation of the variable (binary) # original value : originalValue = originalValueEntry.get_text() if len(originalValue) == 0: originalValue = None # constraints minSize = int(minBitsEntry.get_text()) maxSize = int(maxBitsEntry.get_text()) hexVariable = HexVariable(varID, "hexadecimal", originalValue, minSize, maxSize) rootVariable.addChild(hexVariable) self.datas[str(hexVariable.getID())] = hexVariable self.treestore.append(rootEntry, [str(hexVariable.getID()), hexVariable.getUncontextualizedDescription()]) # We close the current dialog dialog.destroy() def addAlternate(self, event, rootVariable, rootEntry): # Display the form for the creation of a word variable dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK, None) dialog.set_markup(_("Definition of the Alternative")) # Create the ID of the new variable variableID = str(uuid.uuid4()) mainTable = gtk.Table(rows=3, columns=2, homogeneous=False) # parent id of the variable variablePIDLabel = gtk.Label(_("Parent ID:")) variablePIDLabel.show() variablePIDValueLabel = gtk.Label(str(rootVariable.getID())) variablePIDValueLabel.set_sensitive(False) variablePIDValueLabel.show() mainTable.attach(variablePIDLabel, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variablePIDValueLabel, 1, 2, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # id of the variable variableIDLabel = gtk.Label(_("ID:")) variableIDLabel.show() variableIDValueLabel = gtk.Label(variableID) variableIDValueLabel.set_sensitive(False) variableIDValueLabel.show() mainTable.attach(variableIDLabel, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variableIDValueLabel, 1, 2, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # name of the variable variableValueLabel = gtk.Label(_("Name:")) variableValueLabel.show() variableValueEntry = gtk.Entry() variableValueEntry.show() mainTable.attach(variableValueLabel, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variableValueEntry, 1, 2, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) dialog.vbox.pack_end(mainTable, True, True, 0) dialog.show_all() result = dialog.run() if result != gtk.RESPONSE_OK: dialog.destroy() return # We retrieve the name of the variable varName = variableValueEntry.get_text() # Creation of the aggregate id, name, mutable, value): alternateVariable = AlternateVariable(variableID, varName, None) rootVariable.addChild(alternateVariable) self.datas[str(alternateVariable.getID())] = alternateVariable self.treestore.append(rootEntry, [str(alternateVariable.getID()), _("Alternate")]) # We close the current dialog dialog.destroy() def addAggregate(self, event, rootVariable, rootEntry): # Display the form for the creation of a word variable dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK, None) dialog.set_markup(_("Definition of the Aggregate")) # Create the ID of the new variable variableID = str(uuid.uuid4()) mainTable = gtk.Table(rows=3, columns=2, homogeneous=False) # parent id of the variable variablePIDLabel = gtk.Label(_("Parent ID:")) variablePIDLabel.show() variablePIDValueLabel = gtk.Label(str(rootVariable.getID())) variablePIDValueLabel.set_sensitive(False) variablePIDValueLabel.show() mainTable.attach(variablePIDLabel, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variablePIDValueLabel, 1, 2, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # id of the variable variableIDLabel = gtk.Label(_("ID:")) variableIDLabel.show() variableIDValueLabel = gtk.Label(variableID) variableIDValueLabel.set_sensitive(False) variableIDValueLabel.show() mainTable.attach(variableIDLabel, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variableIDValueLabel, 1, 2, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # name of the variable variableValueLabel = gtk.Label(_("Name:")) variableValueLabel.show() variableValueEntry = gtk.Entry() variableValueEntry.show() mainTable.attach(variableValueLabel, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variableValueEntry, 1, 2, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) dialog.vbox.pack_end(mainTable, True, True, 0) dialog.show_all() result = dialog.run() if result != gtk.RESPONSE_OK: dialog.destroy() return # We retrieve the name of the variable varName = variableValueEntry.get_text() # Creation of the aggregate id, name, mutable, value): aggregateVariable = AggregateVariable(variableID, varName, None) rootVariable.addChild(aggregateVariable) self.datas[str(aggregateVariable.getID())] = aggregateVariable self.treestore.append(rootEntry, [str(aggregateVariable.getID()), _("Aggregate")]) # We close the current dialog dialog.destroy() def addWord(self, event, rootVariable, rootEntry): # Display the form for the creation of a word variable dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK, None) dialog.set_markup(_("Definition of the WORD")) # Create the ID of the new variable variableID = str(uuid.uuid4()) mainTable = gtk.Table(rows=3, columns=2, homogeneous=False) # parent id of the variable variablePIDLabel = gtk.Label(_("Parent ID:")) variablePIDLabel.show() variablePIDValueLabel = gtk.Label(str(rootVariable.getID())) variablePIDValueLabel.set_sensitive(False) variablePIDValueLabel.show() mainTable.attach(variablePIDLabel, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variablePIDValueLabel, 1, 2, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # id of the variable variableIDLabel = gtk.Label(_("ID:")) variableIDLabel.show() variableIDValueLabel = gtk.Label(variableID) variableIDValueLabel.set_sensitive(False) variableIDValueLabel.show() mainTable.attach(variableIDLabel, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variableIDValueLabel, 1, 2, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # name of the variable variableNameLabel = gtk.Label(_("Name:")) variableNameLabel.show() variableNameEntry = gtk.Entry() variableNameEntry.show() mainTable.attach(variableNameLabel, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variableNameEntry, 1, 2, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # value of the variable variableValueLabel = gtk.Label(_("Value:")) variableValueLabel.show() variableValueEntry = gtk.Entry() variableValueEntry.show() mainTable.attach(variableValueLabel, 0, 1, 3, 4, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variableValueEntry, 1, 2, 3, 4, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) dialog.vbox.pack_end(mainTable, True, True, 0) dialog.show_all() result = dialog.run() if result != gtk.RESPONSE_OK: dialog.destroy() return # We retrieve the value of the variable varName = variableNameEntry.get_text() varValue = variableValueEntry.get_text() if len(varValue) == 0: varValue = None # Creation of the word id, name, mutable, value): wordVariable = WordVariable(variableID, varName, varValue) rootVariable.addChild(wordVariable) self.datas[str(wordVariable.getID())] = wordVariable self.treestore.append(rootEntry, [str(wordVariable.getID()), wordVariable.getUncontextualizedDescription()]) # We close the current dialog dialog.destroy() def addDecimalWord(self, event, rootVariable, rootEntry): # Display the form for the creation of a word variable dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK, None) dialog.set_markup(_("Definition of the Decimal WORD")) # Create the ID of the new variable variableID = str(uuid.uuid4()) mainTable = gtk.Table(rows=3, columns=2, homogeneous=False) # parent id of the variable variablePIDLabel = gtk.Label(_("Parent ID:")) variablePIDLabel.show() variablePIDValueLabel = gtk.Label(str(rootVariable.getID())) variablePIDValueLabel.set_sensitive(False) variablePIDValueLabel.show() mainTable.attach(variablePIDLabel, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variablePIDValueLabel, 1, 2, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # id of the variable variableIDLabel = gtk.Label(_("ID:")) variableIDLabel.show() variableIDValueLabel = gtk.Label(variableID) variableIDValueLabel.set_sensitive(False) variableIDValueLabel.show() mainTable.attach(variableIDLabel, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variableIDValueLabel, 1, 2, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # value of the variable variableValueLabel = gtk.Label(_("Value:")) variableValueLabel.show() variableValueEntry = gtk.Entry() variableValueEntry.show() mainTable.attach(variableValueLabel, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variableValueEntry, 1, 2, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) dialog.vbox.pack_end(mainTable, True, True, 0) dialog.show_all() result = dialog.run() if result != gtk.RESPONSE_OK: dialog.destroy() return # We retrieve the value of the variable varValue = variableValueEntry.get_text() # Creation of the word id, name, mutable, value): decimalwordVariable = DecimalWordVariable(variableID, varValue, None) rootVariable.addChild(decimalwordVariable) self.datas[str(decimalwordVariable.getID())] = decimalwordVariable self.treestore.append(rootEntry, [str(decimalwordVariable.getID()), decimalwordVariable.getUncontextualizedDescription()]) # We close the current dialog dialog.destroy() def addIPv4(self, event, rootVariable, rootEntry): # Display the form for the creation of an IPv4 variable dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK, None) dialog.set_markup(_("Definition of the IPv4 Variable")) # Create the ID of the new variable varID = uuid.uuid4() variableID = str(varID) mainTable = gtk.Table(rows=3, columns=2, homogeneous=False) # parent id of the variable variablePIDLabel = gtk.Label(_("Parent ID:")) variablePIDLabel.show() variablePIDValueLabel = gtk.Label(str(rootVariable.getID())) variablePIDValueLabel.set_sensitive(False) variablePIDValueLabel.show() mainTable.attach(variablePIDLabel, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variablePIDValueLabel, 1, 2, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # id of the variable variableIDLabel = gtk.Label(_("ID:")) variableIDLabel.show() variableIDValueLabel = gtk.Label(variableID) variableIDValueLabel.set_sensitive(False) variableIDValueLabel.show() mainTable.attach(variableIDLabel, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variableIDValueLabel, 1, 2, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # Original Value originalValueLabel = gtk.Label(_("Original value:")) originalValueLabel.show() originalValueEntry = gtk.Entry() originalValueEntry.show() mainTable.attach(originalValueLabel, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(originalValueEntry, 1, 2, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # Constraints label constraintsLabel = gtk.Label(_("Constraints when parsing / generating")) constraintsLabel.show() mainTable.attach(constraintsLabel, 0, 2, 3, 4, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # start Value startValueLabel = gtk.Label(_("Start:")) startValueLabel.show() startValueEntry = gtk.Entry() startValueEntry.show() mainTable.attach(startValueLabel, 0, 1, 4, 5, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(startValueEntry, 1, 2, 4, 5, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # end Value endValueLabel = gtk.Label(_("End:")) endValueLabel.show() endValueEntry = gtk.Entry() endValueEntry.show() mainTable.attach(endValueLabel, 0, 1, 5, 6, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(endValueEntry, 1, 2, 5, 6, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # Format label hdrFormatLabel = gtk.Label(_("Representation")) hdrFormatLabel.show() mainTable.attach(hdrFormatLabel, 0, 2, 7, 8, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # Format Value formatValueLabel = gtk.Label(_("Format:")) formatValueLabel.show() formatValueCombo = gtk.combo_box_entry_new_text() formatValueCombo.show() formatValueComboStore = gtk.ListStore(str) # format name formatValueCombo.set_model(formatValueComboStore) # We retrieve all the existing variables in the project formatValueCombo.get_model().append([Format.HEX]) formatValueCombo.get_model().append([Format.ASCII]) mainTable.attach(formatValueLabel, 0, 1, 8, 9, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(formatValueCombo, 1, 2, 8, 9, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) dialog.vbox.pack_end(mainTable, True, True, 0) dialog.show_all() result = dialog.run() if result != gtk.RESPONSE_OK: dialog.destroy() return # Creation of the variable (ipv4) # original value : originalValue = originalValueEntry.get_text() if len(originalValue) == 0: originalValue = None # constraints startValue = startValueEntry.get_text() if len(startValue) == 0: startValue = None endValue = endValueEntry.get_text() if len(endValue) == 0: endValue = None # format format = formatValueCombo.get_model().get_value(formatValueCombo.get_active_iter(), 0) ipVariable = IPv4Variable(varID, "ipv4", originalValue, startValue, endValue, format) rootVariable.addChild(ipVariable) self.datas[str(ipVariable.getID())] = ipVariable self.treestore.append(rootEntry, [str(ipVariable.getID()), ipVariable.getUncontextualizedDescription()]) # We close the current dialog dialog.destroy() def addReferencedVariable(self, event, rootVariable, rootEntry): # Display the form for the creation of a word variable dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK, None) dialog.set_markup(_("Definition of the ReferencedVariable")) # Create the ID of the new variable variableID = str(uuid.uuid4()) mainTable = gtk.Table(rows=3, columns=2, homogeneous=False) # parent id of the variable variablePIDLabel = gtk.Label(_("Parent ID:")) variablePIDLabel.show() variablePIDValueLabel = gtk.Label(str(rootVariable.getID())) variablePIDValueLabel.set_sensitive(False) variablePIDValueLabel.show() mainTable.attach(variablePIDLabel, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variablePIDValueLabel, 1, 2, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # id of the variable variableIDLabel = gtk.Label(_("ID:")) variableIDLabel.show() variableIDValueLabel = gtk.Label(variableID) variableIDValueLabel.set_sensitive(False) variableIDValueLabel.show() mainTable.attach(variableIDLabel, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(variableIDValueLabel, 1, 2, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) # Selection of the variable varLabel = gtk.Label(_("Referenced Variable:")) varLabel.show() self.varCombo = gtk.combo_box_entry_new_text() self.varCombo.show() self.varStore = gtk.ListStore(str, str) # description, id, self.varCombo.set_model(self.varStore) # We retrieve all the existing variables in the project existingVariables = self.project.getVocabulary().getVariables() for existingVariable in existingVariables: self.varCombo.get_model().append([existingVariable.getUncontextualizedDescription(), existingVariable.getID()]) mainTable.attach(varLabel, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) mainTable.attach(self.varCombo, 1, 2, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5) dialog.vbox.pack_end(mainTable, True, True, 0) dialog.show_all() result = dialog.run() if result != gtk.RESPONSE_OK: dialog.destroy() return idReferencedVariable = self.varCombo.get_model().get_value(self.varCombo.get_active_iter(), 1) referencedVariable = ReferencedVariable(uuid.uuid4(), "Ref", idReferencedVariable) rootVariable.addChild(referencedVariable) self.datas[str(referencedVariable.getID())] = referencedVariable self.treestore.append(rootEntry, [str(referencedVariable.getID()), referencedVariable.getUncontextualizedDescription()]) # We close the current dialog dialog.destroy()
def validateChanges(self, widget): """validateChanges: Validate the changes that a user has done on a variable. Called by a click on the apply button. @type widget: Gtk.widget @param widget: the widget which calls this function. """ dialog = self.view.getWidg("dialog") if self.editOverCreate: anid = self.variable.getID() else: anid = str(uuid.uuid4()) name = self.view.getWidg("nameEntry").get_text() mutable = self.view.getWidg("mutableCheck").get_active() learnable = self.view.getWidg("learnableCheck").get_active() strVarType = self.view.getWidg("variableTypeCombo").get_active_text() variable = None # Aggregate variable if strVarType == AggregateVariable.TYPE: variable = AggregateVariable(anid, name, mutable, learnable) # Alternate Variable elif strVarType == AlternateVariable.TYPE: variable = AlternateVariable(anid, name, mutable, learnable) # Repeat Variable elif strVarType == RepeatVariable.TYPE: minIterations = int(self.view.getWidg("minSpin").get_text()) maxIterations = int(self.view.getWidg("maxSpin").get_text()) variable = RepeatVariable(anid, name, mutable, learnable, None, minIterations, maxIterations) # Data Variable elif strVarType == DataVariable.TYPE: originalValue = str(self.view.getWidg("valueEntry").get_text()) sized = self.view.getWidg("sizedCheck").get_active() if sized: # If the variable is defined by a size. minChars = int(self.view.getWidg("minSpin").get_text()) maxChars = int(self.view.getWidg("maxSpin").get_text()) delimiter = None else: # The variable is defined by a delimiter. minChars = 0 maxChars = 0 delimiter = self.view.getWidg("delimiterEntry").get_text() vtype = AbstractType.makeType(self.view.getWidg("typeCombo").get_active_text(), sized, minChars, maxChars, delimiter) variable = DataVariable(anid, name, mutable, learnable, vtype, originalValue) #=============================================================================== # # Direct Relation Variable # elif strVarType == DirectRelationVariable.TYPE: # # # We find the variable by its ID. # pointedID = str(self.view.getWidg("IDEntry").get_text()) # # variable = DirectRelationVariable(anid, name, mutable, learnable, pointedID, self.treeController.symbol) #=============================================================================== # Computed Relation Variable elif strVarType == ComputedRelationVariable.TYPE: # We find the variable by its ID. pointedID = str(self.view.getWidg("IDEntry").get_text()) sized = self.view.getWidg("sizedCheck").get_active() if sized: # If the variable is defined by a size. minChars = int(self.view.getWidg("minSpin").get_text()) maxChars = int(self.view.getWidg("maxSpin").get_text()) delimiter = None else: # The variable is defined by a delimiter. minChars = 0 maxChars = 0 delimiter = self.view.getWidg("delimiterEntry").get_text() vtype = AbstractRelationType.makeType(self.view.getWidg("relationTypeCombo").get_active_text(), sized, minChars, maxChars, delimiter) variable = ComputedRelationVariable(anid, name, mutable, learnable, vtype, pointedID, self.treeController.symbol) if variable is not None: # This part is for saving and transfering children when transforming a node variable into an other kind of node variable. if self.editOverCreate: father = self.variable.getFathers()[0] # We transform a node variable into a node variable. if (self.variable.getVariableType() == AggregateVariable.TYPE or self.variable.getVariableType() == AlternateVariable.TYPE) and (variable.getVariableType() == AggregateVariable.TYPE or variable.getVariableType() == AlternateVariable.TYPE): children = self.variable.getChildren() self.variable = variable for child in children: self.variable.addChild(child) # We transform a repeat variable into a node variable. elif (self.variable.getVariableType() == RepeatVariable.TYPE) and (variable.getVariableType() == AggregateVariable.TYPE or variable.getVariableType() == AlternateVariable.TYPE): child = self.variable.getChild() self.variable = variable self.variable.addChild(child) # We transform a repeat variable into a repeat variable. elif (self.variable.getVariableType() == RepeatVariable.TYPE) and (variable.getVariableType() == RepeatVariable.TYPE): child = self.variable.getChild() self.variable = variable self.variable.addChild(child) # We do not manage/save children. else: self.variable = variable self.variable.addFather(father) self.treeController.editVariable(self.variable) else: self.variable.addChild(variable) self.treeController.registerVariable(self.rootEntry, variable) dialog.destroy()
def loadFromXML(xmlRoot, namespace, version, symbol): """loadFromXML: Load a variable from an XML definition. Calls its proper heir function for it to create the variable. @type xmlRoot: lxml.etree.Element @param xmlRoot: the root of the XML definition. @type namespace: string @param namespace: the namespace (precision) associated to the variable in the XML definition. @type version: string @param version: the load version. @rtype: netzob.Common.MMSTD.Dictionary.Variable.AbstractVariable.AbstractVariable @type symbol: netzob.Common.Symbol @param symbol: the symbol in which the current variable is placed, used by relation variable. @return: a variable constructed from this XML definition. """ if version == "0.1": logging.debug("[ AbstractVariable: loadFromXML:") # Data Variable if xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:DataVariable": from netzob.Common.MMSTD.Dictionary.Variables.DataVariable import DataVariable return DataVariable.loadFromXML(xmlRoot, namespace, version, symbol) # Aggregate Variable elif xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:AggregateVariable": from netzob.Common.MMSTD.Dictionary.Variables.AggregateVariable import AggregateVariable return AggregateVariable.loadFromXML(xmlRoot, namespace, version, symbol) # Alternate Variable elif xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:AlternateVariable": from netzob.Common.MMSTD.Dictionary.Variables.AlternateVariable import AlternateVariable return AlternateVariable.loadFromXML(xmlRoot, namespace, version, symbol) # Repeat Variable elif xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:RepeatVariable": from netzob.Common.MMSTD.Dictionary.Variables.RepeatVariable import RepeatVariable return RepeatVariable.loadFromXML(xmlRoot, namespace, version, symbol) # Direct Relation Variable #elif xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:DirectRelationVariable": # from netzob.Common.MMSTD.Dictionary.Variables.DirectRelationVariable import DirectRelationVariable # return DirectRelationVariable.loadFromXML(xmlRoot, namespace, version, symbol) # Computed Relation Variable elif xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:ComputedRelationVariable": from netzob.Common.MMSTD.Dictionary.Variables.ComputedRelationVariable import ComputedRelationVariable return ComputedRelationVariable.loadFromXML( xmlRoot, namespace, version, symbol) else: logging.debug( "xmlRoot.get(...) returns {0} which does not correspond to a true variable class." ).format( xmlRoot.get( "{http://www.w3.org/2001/XMLSchema-instance}type", "abstract")) logging.debug("AbstractVariable: loadFromXML ]") else: logging.debug("Version != 0.1")
def learn(self, child, readingToken): """learn: The alternate variable learns the given value and adds it at the end of its children. @type child: netzob.Common.MMSTD.Dictionary.Variable.AbstractVariable.AbstractVariable @param child: the child we expected to find while reading the given value. @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}: learn.".format(self.toString())) dictOfValues = dict() savedIndex = readingToken.getIndex() savedFather = self.getFathers()[0] # TODO: not accurate. But yet we can only have one father selfPosition = savedFather.indexOfChild(self) # We create a fake father for this alternate. if self.getFathers()[0].getType() == AggregateVariable.TYPE: fakeFather = AggregateVariable(str(uuid.uuid4()), "Fake father", False, False) # We add this element and its right brother as child of the fake father in order to pursue the read access from where we are. fakeFather.addChild(self) for rightBrother in self.getFathers()[0].getChildren()[selfPosition:]: fakeFather.addChild(rightBrother) elif self.getFathers()[0].getType() == RepeatVariable.TYPE: (minIterations, maxIterations) = self.getFathers()[0].getNumberIterations() # Some iterations of this treatment could have been made before. The fake father should not make more iterations than it remains for the real father. minIterations = max(0, minIterations - self.getFathers()[0].getCurrentIteration()) maxIterations = max(0, maxIterations - self.getFathers()[0].getCurrentIteration()) fakeFather = RepeatVariable(str(uuid.uuid4()), "Fake father", False, False, self, minIterations, maxIterations) else: self.log.error("The father is neither an aggregate nor a repeat variable.") # We execute the treatment on the fake father. valueToBeRead = readingToken.getValue()[readingToken.getIndex():] for index in len(valueToBeRead): # We search if, by shifting the position of actual variable, we could read the given value. tmpValue = valueToBeRead[:index] tmpChild = DataVariable(str(uuid.uuid4()), "Learned Inserted Variable", True, True, BinaryType(True, len(tmpValue), len(tmpValue)), tmpValue) # We add the new variable at the end, in order to minimize its impact. self.add(tmpChild) # We read this new variable from the father in a learning context. self.setLearning(True) fakeFather.read(readingToken) # If this read access works, we learn the variable. if readingToken.isOk(): break else: # We remove the just added child. self.removeChild(tmpChild) self.removefather(fakeFather) # We restore the action induced by the fake father. readingToken.setIndex(savedIndex) vocabulary = readingToken.getVocabulary() for key, val in dictOfValues.iteritems(): child = vocabulary.getVariableByID(key) # We restore the current values. child.setCurrentValue(val) # We restore the cached values. child.restore(readingToken) if readingToken.isOk(): # We continue the treatment. The real father's treatment will pursue. self.read(readingToken) self.log.debug("Variable {0}: {1}. ] -".format(self.getName(), readingToken.toString()))
def validateChanges(self, widget): """validateChanges: Validate the changes that a user has done on a variable. Called by a click on the apply button. @type widget: Gtk.widget @param widget: the widget which calls this function. """ dialog = self.view.getWidg("dialog") if self.editOverCreate: anid = self.variable.getID() else: anid = str(uuid.uuid4()) name = self.view.getWidg("nameEntry").get_text() mutable = self.view.getWidg("mutableCheck").get_active() learnable = self.view.getWidg("learnableCheck").get_active() varTypeIndex = self.view.getWidg("variableTypeCombo").get_active() variable = None # Aggregate variable if varTypeIndex == VariableTreeController.VARIABLE_INDEX_LIST.index(AggregateVariable.TYPE): variable = AggregateVariable(anid, name, mutable, learnable) # Alternate Variable elif varTypeIndex == VariableTreeController.VARIABLE_INDEX_LIST.index(AlternateVariable.TYPE): variable = AlternateVariable(anid, name, mutable, learnable) # Repeat Variable elif varTypeIndex == VariableTreeController.VARIABLE_INDEX_LIST.index(RepeatVariable.TYPE): minIterations = int(self.view.getWidg("minSpin").get_text()) maxIterations = int(self.view.getWidg("maxSpin").get_text()) variable = RepeatVariable(anid, name, mutable, learnable, None, minIterations, maxIterations) # Data Variable elif varTypeIndex == VariableTreeController.VARIABLE_INDEX_LIST.index(DataVariable.TYPE): sized = self.view.getWidg("sizedCheck").get_active() if sized: # If the variable is defined by a size. minChars = int(self.view.getWidg("minSpin").get_text()) maxChars = int(self.view.getWidg("maxSpin").get_text()) delimiter = None else: # The variable is defined by a delimiter. minChars = 0 maxChars = 0 delimiter = self.view.getWidg("delimiterEntry").get_text() vtype = AbstractType.makeType(VariableTreeController.TYPE_INDEX_LIST[self.view.getWidg("typeCombo").get_active()], sized, minChars, maxChars, delimiter) originalValue = vtype.str2bin(self.view.getWidg("valueEntry").get_text()) variable = DataVariable(anid, name, mutable, learnable, vtype, originalValue) #=============================================================================== # # Direct Relation Variable # elif strVarType == DirectRelationVariable.TYPE: # # # We find the variable by its ID. # pointedID = str(self.view.getWidg("IDEntry").get_text()) # # variable = DirectRelationVariable(anid, name, mutable, learnable, pointedID, self.treeController.symbol) #=============================================================================== # Computed Relation Variable elif varTypeIndex == VariableTreeController.VARIABLE_INDEX_LIST.index(ComputedRelationVariable.TYPE): # We find the variable by its ID. pointedID = str(self.view.getWidg("IDEntry").get_text()) sized = self.view.getWidg("sizedCheck").get_active() if sized: # If the variable is defined by a size. minChars = int(self.view.getWidg("minSpin").get_text()) maxChars = int(self.view.getWidg("maxSpin").get_text()) delimiter = None else: # The variable is defined by a delimiter. minChars = 0 maxChars = 0 delimiter = self.view.getWidg("delimiterEntry").get_text() factor = float(self.view.getWidg("factorEntry").get_text()) offset = float(self.view.getWidg("offsetEntry").get_text()) vtype = AbstractRelationType.makeType(VariableTreeController.RELATION_TYPE_INDEX_LIST[self.view.getWidg("relationTypeCombo").get_active()], sized, minChars, maxChars, delimiter, factor, offset) variable = ComputedRelationVariable(anid, name, mutable, learnable, vtype, pointedID, self.treeController.symbol) if variable is not None: # This part is for saving and transfering children when transforming a node variable into an other kind of node variable. if self.editOverCreate: father = None if len(self.variable.getFathers()) > 0: father = self.variable.getFathers()[0] # We transform a node variable into a node variable. if (self.variable.getVariableType() == AggregateVariable.TYPE or self.variable.getVariableType() == AlternateVariable.TYPE) and (variable.getVariableType() == AggregateVariable.TYPE or variable.getVariableType() == AlternateVariable.TYPE): children = self.variable.getChildren() self.variable = variable for child in children: self.variable.addChild(child) # We transform a repeat variable into a node variable. elif (self.variable.getVariableType() == RepeatVariable.TYPE) and (variable.getVariableType() == AggregateVariable.TYPE or variable.getVariableType() == AlternateVariable.TYPE): child = self.variable.getChild() self.variable = variable self.variable.addChild(child) # We transform a repeat variable into a repeat variable. elif (self.variable.getVariableType() == RepeatVariable.TYPE) and (variable.getVariableType() == RepeatVariable.TYPE): child = self.variable.getChild() self.variable = variable self.variable.setChild(child) # We do not manage/save children. else: self.variable = variable if father is not None: self.variable.addFather(father) self.treeController.editVariable(self.variable) else: if self.variable.getVariableType() == RepeatVariable.TYPE: self.variable.setChild(variable) else: self.variable.addChild(variable) self.treeController.registerVariable(self.rootEntry, variable) dialog.destroy()