def serialize(self): # doc = implementation.createDocument(self.namespace, None, None) doc = Document() ipsec_element = doc.createElementNS(self.namespace, "ipsec") sad_element = doc.createElementNS(self.namespace, "sad") spd_element = doc.createElementNS(self.namespace, "spd") ipsec_element.appendChild(sad_element) ipsec_element.appendChild(spd_element) doc.appendChild(ipsec_element) if self.SAs: for sa in self.SAs: saNode = sa.serialize(doc, self.namespace) sad_element.appendChild(saNode) else: print "No SAD entries." if self.SPs: for sp in self.SPs: spNode = sp.serialize(doc, self.namespace) spd_element.appendChild(spNode) else: print "No SPD entries." # print doc.toprettyxml() return doc
def serach_E(n): for i in elements: if i.name==n: if i.data.hasChildNodes()==False: xmlfile = Document() temp1=xmlfile.createElementNS('xs','complexType') temp1.setAttribute('mixed','true') i.data.appendChild(temp1) temp2=xmlfile.createElementNS('xs','sequence') temp1.appendChild(temp2) return i.data.getElementsByTagName('complexType')[0].getElementsByTagName('sequence')[0] return None
def get_XSD_r(conf): xmlfile = Document() information = xmlfile.createElementNS('xs','schema') information.setAttributeNS('xmlns','xs','http://www.w3.org/2001/XMLSchema') information.setAttribute("targetNamespace",'http://www.w3school.com.cn') information.setAttribute('xmlns','http://www.w3school.com.cn') xmlfile.appendChild(information) conffile=open(conf) father=None while len(elements): elements.pop() for line in conffile.readlines(): temp=line.split('=') for j in range(len(temp)): temp[j]=temp[j].strip() te = xmlfile.createElementNS('xs','element') te.setAttribute('name',temp[0]) elements.append(XMLE(temp[0],te)) if len(temp)>1: temp[0]=temp[1].split(';') for j in temp[0]: j=j.strip() if j == '': continue j=j.split(':') if j[0]=='type': if j[1]=='str': te.setAttribute('type','xs:string') elif j[1]=='int': te.setAttribute('type','xs:positiveInteger') elif j[0]=='fix': te.setAttribute('fixed',j[1]) elif j[0]=='word'or j[0]=='contain' or j[0]=='maxo' or j[0]=='mino': te.setAttribute(j[0],j[1]) elif j[0]=='father': father=serach_E(j[1]) if father == None: te.setAttribute('error','no father node named :%s' % j[1]) if father == None: information.appendChild(te) else: father.appendChild(te) father=None conffile.close() temp = conf.split('\\') f=open('%s.xsdr' % temp[-1].split('.')[0] ,'w') xmlfile.writexml(f, "\t", "\t", "\n", "gbk") f.close()
def createRequestXML(service, action, arguments=None): from xml.dom.minidom import Document doc = Document() # create the envelope element and set its attributes envelope = doc.createElementNS('', 's:Envelope') envelope.setAttribute('xmlns:s', 'http://schemas.xmlsoap.org/soap/envelope/') envelope.setAttribute('s:encodingStyle', 'http://schemas.xmlsoap.org/soap/encoding/') # create the body element body = doc.createElementNS('', 's:Body') # create the function element and set its attribute fn = doc.createElementNS('', 'u:%s' % action) fn.setAttribute('xmlns:u', 'urn:schemas-upnp-org:service:%s' % service) # setup the argument element names and values # using a list of tuples to preserve order # container for created nodes argument_list = [] # iterate over arguments, create nodes, create text nodes, # append text nodes to nodes, and finally add the ready product # to argument_list if arguments is not None: for k, v in arguments: tmp_node = doc.createElement(k) tmp_text_node = doc.createTextNode(v) tmp_node.appendChild(tmp_text_node) argument_list.append(tmp_node) # append the prepared argument nodes to the function element for arg in argument_list: fn.appendChild(arg) # append function element to the body element body.appendChild(fn) # append body element to envelope element envelope.appendChild(body) # append envelope element to document, making it the root element doc.appendChild(envelope) # our tree is ready, conver it to a string return doc.toxml()
def _buildbasicXMLdoc(self): doc = Document() root_element = doc.createElementNS('http://api.uclassify.com/1/RequestSchema', 'uclassify') root_element.setAttribute("version", "1.01") root_element.setAttribute("xmlns", "http://api.uclassify.com/1/server/RequestSchema") doc.appendChild(root_element) return doc,root_element
def export_alignment_table_as_tei(table, indent=None): d = Document() root = d.createElementNS("http://interedition.eu/collatex/ns/1.0", "cx:apparatus") # fake namespace declarations root.setAttribute("xmlns:cx", "http://interedition.eu/collatex/ns/1.0") root.setAttribute("xmlns", "http://www.tei-c.org/ns/1.0") d.appendChild(root) for column in table.columns: value_dict = defaultdict(list) ws_flag = False for key, value in sorted(column.tokens_per_witness.items()): # value_dict key is reading, value is list of witnesses t_readings = "".join(item.token_data["t"] for item in value) if ws_flag == False and t_readings.endswith((" ", r"\u0009", r"\000a")): # space, tab, lf ws_flag = True value_dict[t_readings.strip()].append(key) # REVIEW [RHD]: Isn't there a method on table that can be used instead of this len(next(iter() etc? # otherwise I think there should be. Not sure what len(next(iter(etc))) represents. # # See https://stackoverflow.com/questions/4002874/non-destructive-version-of-pop-for-a-dictionary # It returns the number of witnesses that attest the one reading in the dictionary, that is, it peeks # nondestructively at the value of the single dictionary item, which is a list, and counts the members # of the list if len(value_dict) == 1 and len(next(iter(value_dict.values()))) == len(table.rows): # len(table.rows) is total number of witnesses; guards against nulls, which aren't in table key, value = value_dict.popitem() # there's just one item text_node = d.createTextNode(key) root.appendChild(text_node) else: # variation is either more than one reading, or one reading plus nulls app = d.createElementNS("http://www.tei-c.org/ns/1.0", "app") root.appendChild(app) for key, value in value_dict.items(): # key is reading (with trailing whitespace stripped), value is list of witnesses rdg = d.createElementNS("http://www.tei-c.org/ns/1.0", "rdg") rdg.setAttribute("wit", " ".join(["#" + item for item in value_dict[key]])) text_node = d.createTextNode(key) rdg.appendChild(text_node) app.appendChild(rdg) if ws_flag: text_node = d.createTextNode(" ") root.appendChild(text_node) if indent: result = d.toprettyxml() else: result = d.toxml() return result
def toWorkspaceXml(self, quantity=1, data=None): launchData = {} if self.data != None: for key in self.data: launchData[key] = self.data[key] if data != None: for key in data: launchData[key] = data[key] # why did I think this was a good idea? doc = Document() cluster = doc.createElementNS("http://www.globus.org/2008/06/workspace/metadata/logistics", "cluster") workspace = doc.createElement("workspace"); cluster.appendChild(workspace) name = doc.createElement("name") name.appendChild(doc.createTextNode(self.name)) workspace.appendChild(name) image = doc.createElement("image") image.appendChild(doc.createTextNode(self.ami)) workspace.appendChild(image) quantityNode = doc.createElement("quantity") quantityNode.appendChild(doc.createTextNode(str(quantity))) workspace.appendChild(quantityNode) nic = doc.createElement("nic") nic.setAttribute("wantlogin","true") nic.appendChild(doc.createTextNode("public")) workspace.appendChild(nic) ctx = doc.createElement("ctx") workspace.appendChild(ctx) provides = doc.createElement("provides") provides.appendChild(doc.createElement("identity")) ctx.appendChild(provides) role = doc.createElement("role") role.setAttribute("hostname","true") role.setAttribute("pubkey","true") role.appendChild(doc.createTextNode(self.name)) provides.appendChild(role) requires = doc.createElement("requires") requires.appendChild(doc.createElement("identity")) ctx.appendChild(requires) for key in launchData: dataNode = doc.createElement("data") dataNode.setAttribute("name", key) dataNode.appendChild(doc.createCDATASection(launchData[key])) requires.appendChild(dataNode) return cluster.toxml()
def _testElementReprAndStrUnicodeNS(): dom = Document() el = dom.appendChild( dom.createElementNS(u"http://www.slashdot.org", u"slash:abc")) string1 = repr(el) string2 = str(el) confirm(string1 == string2) confirm(string1.find("slash:abc") != -1) dom.unlink()
def to_xml(self): document = Document() remover = document.createElementNS(XMLDOC_NAMESPACE, STOP_RECORDING_ROOT_NODE) remover.setAttribute(XMLDOC_XMLNS_ATTRIBUTE, XMLDOC_NAMESPACE) document.appendChild(remover) # object id id_node = document.createElement(STOP_RECORDING_ID_NODE) remover.appendChild(id_node) id_node.appendChild(document.createTextNode(self.object_id_)) return document.toxml(encoding=XMLDOC_CODEPAGE)
def _buildbasicXMLdoc(self): doc = Document() root_element = doc.createElementNS('http://api.uclassify.com/1/RequestSchema', 'uclassify') root_element.setAttribute("version", "1.01") root_element.setAttribute("xmlns", "http://api.uclassify.com/1/RequestSchema") doc.appendChild(root_element) #texts = doc.createElement("texts") #root_element.appendChild(texts) #print(doc.toprettyxml()) return doc,root_element
def testRemoveAttrNS(): dom = Document() child = dom.appendChild( dom.createElementNS("http://www.python.org", "python:abc")) child.setAttributeNS("http://www.w3.org", "xmlns:python", "http://www.python.org") child.setAttributeNS("http://www.python.org", "python:abcattr", "foo") confirm(len(child.attributes) == 2) child.removeAttributeNS("http://www.python.org", "abcattr") confirm(len(child.attributes) == 1) dom.unlink()
def init( metadata ): global doc if metadata is None: doc = Document() root = doc.createElementNS( NAMESPACES[ 'kml' ].uri, 'kml' ) root.setAttribute( 'xmlns', NAMESPACES[ 'kml' ].uri ) root.setAttribute( 'xmlns:' + NAMESPACES[ 'foaf' ].prefix, NAMESPACES[ 'foaf' ].uri ) root.setAttribute( 'xmlns:' + NAMESPACES[ 'dc' ].prefix, NAMESPACES[ 'dc' ].uri ) root.setAttribute( 'xmlns:' + NAMESPACES[ 'xml' ].prefix, NAMESPACES[ 'xml' ].uri ) doc.appendChild( root ) else: doc = parseString( metadata )
def createFeed(examples): doc = Document() feed = doc.createElementNS("http://www.w3.org/2005/Atom", "feed") feed.setAttribute("xmlns", "http://www.w3.org/2005/Atom") #ug, is this for real?? for example in examples: s = os.stat("../examples/" + example["example"]) example["modified"] = s.st_mtime examples.sort(key=lambda x:x["modified"]) for example in sorted(examples, key=lambda x:x["modified"], reverse=True): entry = doc.createElementNS("http://www.w3.org/2005/Atom", "entry") title = doc.createElementNS("http://www.w3.org/2005/Atom", "title") title.appendChild(doc.createTextNode(example["title"] or example["example"])) entry.appendChild(title) link = doc.createElementNS("http://www.w3.org/2005/Atom", "link") link.setAttribute("href", example["example"]) entry.appendChild(link) summary = doc.createElementNS("http://www.w3.org/2005/Atom", "summary") summary.appendChild(doc.createTextNode(example["shortdesc"] or example["example"])) entry.appendChild(summary) updated = doc.createElementNS("http://www.w3.org/2005/Atom", "updated") updated.appendChild(doc.createTextNode( time.strftime("%Y-%m-%dT%I:%M:%SZ",time.gmtime(example["modified"])))) entry.appendChild(updated) feed.appendChild(entry) doc.appendChild(feed) return doc
def to_xml(self): document = Document() stop_stream = document.createElementNS(XMLDOC_NAMESPACE, STREAMER_STOP_ROOT_NODE) stop_stream.setAttribute(XMLDOC_XMLNS_ATTRIBUTE, XMLDOC_NAMESPACE) document.appendChild(stop_stream) if self.channel_handle_ != None: channel_handle = document.createElement(STREAMER_CHANNEL_HANDLE_NODE) stop_stream.appendChild(channel_handle) channel_handle.appendChild(document.createTextNode(str(self.channel_handle_))) elif self.client_id_ != None: client_id = document.createElement(STREAMER_CLIENT_ID_NODE) stop_stream.appendChild(client_id) client_id.appendChild(document.createTextNode(str(self.client_id_))) return document.toxml(encoding=XMLDOC_CODEPAGE)
def to_xml(self): document = Document() epg_searcher = document.createElementNS(XMLDOC_NAMESPACE, SEARCHING_ROOT_NODE) epg_searcher.setAttribute(XMLDOC_XMLNS_ATTRIBUTE, XMLDOC_NAMESPACE) document.appendChild(epg_searcher) if self.is_epg_short_: epg_short = document.createElement(SEARCHING_EPG_SHORT_NODE) epg_searcher.appendChild(epg_short) epg_short.appendChild(document.createTextNode(XMLNODE_VALUE_TRUE)) start_time = document.createElement(SEARCHING_START_TIME_NODE) epg_searcher.appendChild(start_time) start_time.appendChild(document.createTextNode(str(self.start_time_))) requested_count = document.createElement(SEARCHING_COUNT_NODE) epg_searcher.appendChild(requested_count) requested_count.appendChild(document.createTextNode(str(self.requested_count_))) end_time = document.createElement(SEARCHING_END_TIME_NODE) epg_searcher.appendChild(end_time) end_time.appendChild(document.createTextNode(str(self.end_time_))) if self.program_id_ != None: program_id = document.createElement(SEARCHING_PROGRAM_ID_NODE) epg_searcher.appendChild(program_id) program_id.appendChild(document.createTextNode(str(self.program_id_))) if self.keywords_ != None: keywords = document.createElement(SEARCHING_KEYWORDS_NODE) epg_searcher.appendChild(keywords) keywords.appendChild(document.createTextNode(self.keywords_.decode(XMLDOC_CODEPAGE))) if self.genre_mask_ != None: genre_mask = document.createElement(SEARCHING_GENRE_MASK_NODE) epg_searcher.appendChild(genre_mask) genre_mask.appendChild(document.createTextNode(str(self.genre_mask_))) if self.channels_ids_: channels_ids = document.createElement(SEARCHING_CHANNELS_IDS_NODE) epg_searcher.appendChild(channels_ids) for id in self.channels_ids_: id_node = document.createElement(SEARCHING_CHANNEL_ID_NODE) channels_ids.appendChild(id_node) id_node.appendChild(document.createTextNode(id)) return document.toxml(encoding=XMLDOC_CODEPAGE)
def append(self, extensionElement): """ Creates an Tag for each attribute and adds them to the given DOM Element 'extensionElement' """ doc = Document() for x in self._attributes: if self._attributes[x]["enabled"]: attribute = doc.createElementNS("urn:oasis:names:tc:SAML:2.0:assertion", "saml2:Attribute") # Namespaces attribute.setAttribute("xmlns:saml2", "urn:oasis:names:tc:SAML:2.0:assertion") attribute.setAttribute("xmlns:eCH-0113", "http://www.ech.ch/xmlns/eCH-0113/1") # Attribute attribute.setAttribute("Name", self._attributes[x]["id"]) attribute.setAttribute("eCH-0113:required", "true") extensionElement.appendChild(attribute)
class WPSException(Exception): """WPSException should be base class for all exceptions """ code = "NoApplicableCode" value = None locator = None def _make_xml(self): # formulate XML self.document = Document() self.ExceptionReport = self.document.createElementNS("http://www.opengis.net/ows","ExceptionReport") self.ExceptionReport.setAttribute("xmlns","http://www.opengis.net/ows/1.1") self.ExceptionReport.setAttribute("xmlns:xsi","http://www.w3.org/2001/XMLSchema-instance") self.ExceptionReport.setAttribute("xsi:schemaLocation","http://www.opengis.net/ows/1.1 http://schemas.opengis.net/ows/1.1.0/owsExceptionReport.xsd") self.ExceptionReport.setAttribute("version","1.0.0") self.document.appendChild(self.ExceptionReport) # make exception self.Exception = self.document.createElement("Exception") self.Exception.setAttribute("exceptionCode",self.code) if self.locator: self.Exception.setAttribute("locator",self.locator) self.ExceptionReport.appendChild(self.Exception) #self.value = None def getResponse(self): return self.document.toprettyxml(indent='\t', newl='\n', encoding="utf-8") # Not sure what this code is doing here - but we could do with SOAP # handling at some point, so I'll leave it here. - JD 9/12/12 # if pywps.Soap.soap == True: # soapCls = SOAP() # response = soapCls.getResponse(response) def __str__(self): error = "PyWPS %s: Locator: %s; Value: %s\n" % (self.code, self.locator, self.value) try: logFile.write(error) #@UndefinedVariable except: sys.stderr.write(error) return self.document.toprettyxml(indent='\t', newl='\n', encoding="utf-8")
def to_xml(self): document = Document() parental_lock = document.createElementNS(XMLDOC_NAMESPACE, PARENTAL_LOCK_ROOT_NODE) parental_lock.setAttribute(XMLDOC_XMLNS_ATTRIBUTE, XMLDOC_NAMESPACE) document.appendChild(parental_lock) if self.is_enable_: is_enable = document.createElement(PARENTAL_LOCK_IS_ENABLE_NODE) parental_lock.appendChild(is_enable) is_enable.appendChild(document.createTextNode(XMLNODE_VALUE_TRUE)) if self.lock_code_ != None: lock_code = document.createElement(PARENTAL_LOCK_CODE_NODE) parental_lock.appendChild(lock_code) lock_code.appendChild(document.createTextNode(self.lock_code_.decode(XMLDOC_CODEPAGE))) if self.client_id_ != None: client_id = document.createElement(PARENTAL_LOCK_CLIENT_ID_NODE) parental_lock.appendChild(client_id) client_id.appendChild(document.createTextNode(self.client_id_)) return document.toxml(encoding=XMLDOC_CODEPAGE)
def to_xml(self): document = Document() stream_info = document.createElementNS(XMLDOC_NAMESPACE, STREAM_INFO_ROOT_NODE) stream_info.setAttribute(XMLDOC_XMLNS_ATTRIBUTE, XMLDOC_NAMESPACE) document.appendChild(stream_info) address_node = document.createElement(STREAM_INFO_SERVER_ADDRESS_NODE) stream_info.appendChild(address_node) address_node.appendChild(document.createTextNode(self.address_)) client_id_node = document.createElement(STREAM_INFO_CLIENT_ID_NODE) stream_info.appendChild(client_id_node) client_id_node.appendChild(document.createTextNode(self.client_id_)) channels_ids = document.createElement(STREAM_INFO_CHANNELS_IDS_NODE) stream_info.appendChild(channels_ids) for id in self.channels_ids_: id_node = document.createElement(STREAM_INFO_CHANNEL_ID_NODE) channels_ids.appendChild(id_node) id_node.appendChild(document.createTextNode(str(id))) return document.toxml(encoding=XMLDOC_CODEPAGE)
def to_xml(self): document = Document() request_stream = document.createElementNS(XMLDOC_NAMESPACE, STREAMER_ROOT_NODE) request_stream.setAttribute(XMLDOC_XMLNS_ATTRIBUTE, XMLDOC_NAMESPACE) document.appendChild(request_stream) if self.channel_dvblink_id_ != None: channel_id = document.createElement(STREAMER_CHANNEL_ID_NODE) request_stream.appendChild(channel_id) channel_id.appendChild(document.createTextNode(str(self.channel_dvblink_id_))) if self.client_id_ != None: client_id = document.createElement(STREAMER_CLIENT_ID_NODE) request_stream.appendChild(client_id) client_id.appendChild(document.createTextNode(str(self.client_id_))) if self.server_address_ != None: address = document.createElement(STREAMER_SERVER_ADDRESS_NODE) request_stream.appendChild(address) address.appendChild(document.createTextNode(str(self.server_address_))) if self.stream_type_ != None: stream_type = document.createElement(STREAMER_STREAM_TYPE_NODE) request_stream.appendChild(stream_type) stream_type.appendChild(document.createTextNode(str(self.stream_type_))) return document.toxml(encoding=XMLDOC_CODEPAGE)
def to_xml(self): document = Document() object_requester = document.createElementNS(XMLDOC_NAMESPACE, OBJECT_REQUESTER_ROOT_NODE) object_requester.setAttribute(XMLDOC_XMLNS_ATTRIBUTE, XMLDOC_NAMESPACE) document.appendChild(object_requester) object_id = document.createElement(OBJECT_REQUESTER_OBJECT_ID_NODE) object_requester.appendChild(object_id) object_id.appendChild(document.createTextNode(str(self.object_id_))) if self.server_address_ != None: server_address = document.createElement(OBJECT_REQUESTER_SERVER_ADDR_NODE) object_requester.appendChild(server_address) server_address.appendChild(document.createTextNode(str(self.server_address_))) object_type = document.createElement(OBJECT_REQUESTER_OBJECT_TYPE_NODE) object_requester.appendChild(object_type) object_type.appendChild(document.createTextNode(str(self.object_type_))) item_type = document.createElement(OBJECT_REQUESTER_ITEM_TYPE_NODE) object_requester.appendChild(item_type) item_type.appendChild(document.createTextNode(str(self.item_type_))) start_position = document.createElement(OBJECT_REQUESTER_POSITION_NODE) object_requester.appendChild(start_position) start_position.appendChild(document.createTextNode(str(self.start_position_))) requested_count = document.createElement(OBJECT_REQUESTER_COUNT_NODE) object_requester.appendChild(requested_count) requested_count.appendChild(document.createTextNode(str(self.requested_count_))) if self.is_children_request_: is_children_request = document.createElement(OBJECT_REQUESTER_TYPE_NODE) object_requester.appendChild(is_children_request) is_children_request.appendChild(document.createTextNode(XMLNODE_VALUE_TRUE)) return document.toxml(encoding=XMLDOC_CODEPAGE)
class XMLDump(object): """ This class purpose is to dump the data into an xml Format. The format of the xml file is described in the scheme file xml/sqlmap.xsd """ def __init__(self): self._outputFile = None self._outputFP = None self.__root = None self.__doc = Document() def _addToRoot(self, element): """ Adds element to the root element """ self.__root.appendChild(element) def __write(self, data, n=True): """ Writes the data into the file """ if n: self._outputFP.write("%s\n" % data) else: self._outputFP.write("%s " % data) self._outputFP.flush() kb.dataOutputFlag = True def _getRootChild(self, elemName): """ Returns the child of the root with the described name """ elements = self.__root.getElementsByTagName(elemName) if elements: return elements[0] return elements def _createTextNode(self, data): """ Creates a text node with utf8 data inside. The text is escaped to an fit the xml text Format. """ if data is None: return self.__doc.createTextNode(u'') else: escaped_data = saxutils.escape(data, ENTITIES) return self.__doc.createTextNode(escaped_data) def _createAttribute(self, attrName, attrValue): """ Creates an attribute node with utf8 data inside. The text is escaped to an fit the xml text Format. """ attr = self.__doc.createAttribute(attrName) if attrValue is None: attr.nodeValue = u'' else: attr.nodeValue = getUnicode(attrValue) return attr def string(self, header, data, sort=True): """ Adds string element to the xml. """ if isinstance(data, (list, tuple, set)): self.lister(header, data, sort) return messagesElem = self._getRootChild(MESSAGES_ELEM_NAME) if (not(messagesElem)): messagesElem = self.__doc.createElement(MESSAGES_ELEM_NAME) self._addToRoot(messagesElem) if data: data = self._formatString(data) else: data = "" elem = self.__doc.createElement(MESSAGE_ELEM) elem.setAttributeNode(self._createAttribute(TYPE_ATTR, header)) elem.appendChild(self._createTextNode(data)) messagesElem.appendChild(elem) def lister(self, header, elements, sort=True): """ Adds information formatted as list element """ lstElem = self.__doc.createElement(LST_ELEM_NAME) lstElem.setAttributeNode(self._createAttribute(TYPE_ATTR, header)) if elements: if sort: try: elements = set(elements) elements = list(elements) elements.sort(key=lambda x: x.lower()) except: pass for element in elements: memberElem = self.__doc.createElement(MEMBER_ELEM) lstElem.appendChild(memberElem) if isinstance(element, basestring): memberElem.setAttributeNode(self._createAttribute(TYPE_ATTR, "string")) memberElem.appendChild(self._createTextNode(element)) elif isinstance(element, (list, tuple, set)): memberElem.setAttributeNode(self._createAttribute(TYPE_ATTR, "list")) for e in element: memberElemStr = self.__doc.createElement(MEMBER_ELEM) memberElemStr.setAttributeNode(self._createAttribute(TYPE_ATTR, "string")) memberElemStr.appendChild(self._createTextNode(getUnicode(e))) memberElem.appendChild(memberElemStr) listsElem = self._getRootChild(LSTS_ELEM_NAME) if not(listsElem): listsElem = self.__doc.createElement(LSTS_ELEM_NAME) self._addToRoot(listsElem) listsElem.appendChild(lstElem) def technic(self, technicType, data): """ Adds information about the technic used to extract data from the db """ technicElem = self.__doc.createElement(TECHNIC_ELEM_NAME) technicElem.setAttributeNode(self._createAttribute(TYPE_ATTR, technicType)) textNode = self._createTextNode(data) technicElem.appendChild(textNode) technicsElem = self._getRootChild(TECHNICS_ELEM_NAME) if not(technicsElem): technicsElem = self.__doc.createElement(TECHNICS_ELEM_NAME) self._addToRoot(technicsElem) technicsElem.appendChild(technicElem) def banner(self, data): """ Adds information about the database banner to the xml. The banner contains information about the type and the version of the database. """ bannerElem = self.__doc.createElement(BANNER_ELEM_NAME) bannerElem.appendChild(self._createTextNode(data)) self._addToRoot(bannerElem) def currentUser(self, data): """ Adds information about the current database user to the xml """ currentUserElem = self.__doc.createElement(CURRENT_USER_ELEM_NAME) textNode = self._createTextNode(data) currentUserElem.appendChild(textNode) self._addToRoot(currentUserElem) def currentDb(self, data): """ Adds information about the current database is use to the xml """ currentDBElem = self.__doc.createElement(CURRENT_DB_ELEM_NAME) textNode = self._createTextNode(data) currentDBElem.appendChild(textNode) self._addToRoot(currentDBElem) def dba(self, isDBA): """ Adds information to the xml that indicates whether the user has DBA privileges """ isDBAElem = self.__doc.createElement(IS_DBA_ELEM_NAME) isDBAElem.setAttributeNode(self._createAttribute(VALUE_ATTR, getUnicode(isDBA))) self._addToRoot(isDBAElem) def users(self, users): """ Adds a list of the existing users to the xml """ usersElem = self.__doc.createElement(USERS_ELEM_NAME) if isinstance(users, basestring): users = [users] if users: for user in users: userElem = self.__doc.createElement(DB_USER_ELEM_NAME) usersElem.appendChild(userElem) userElem.appendChild(self._createTextNode(user)) self._addToRoot(usersElem) def dbs(self, dbs): """ Adds a list of the existing databases to the xml """ dbsElem = self.__doc.createElement(DBS_ELEM_NAME) if dbs: for db in dbs: dbElem = self.__doc.createElement(DB_NAME_ELEM_NAME) dbsElem.appendChild(dbElem) dbElem.appendChild(self._createTextNode(db)) self._addToRoot(dbsElem) def userSettings(self, header, userSettings, subHeader): """ Adds information about the user's settings to the xml. The information can be user's passwords, privileges and etc.. """ self._areAdmins = set() userSettingsElem = self._getRootChild(USER_SETTINGS_ELEM_NAME) if (not(userSettingsElem)): userSettingsElem = self.__doc.createElement(USER_SETTINGS_ELEM_NAME) self._addToRoot(userSettingsElem) userSettingElem = self.__doc.createElement(USER_SETTING_ELEM_NAME) userSettingElem.setAttributeNode(self._createAttribute(TYPE_ATTR, header)) if isinstance(userSettings, (tuple, list, set)): self._areAdmins = userSettings[1] userSettings = userSettings[0] users = userSettings.keys() users.sort(key=lambda x: x.lower()) for user in users: userElem = self.__doc.createElement(USER_ELEM_NAME) userSettingElem.appendChild(userElem) if user in self._areAdmins: userElem.setAttributeNode(self._createAttribute(TYPE_ATTR, ADMIN_USER)) else: userElem.setAttributeNode(self._createAttribute(TYPE_ATTR, REGULAR_USER)) settings = userSettings[user] settings.sort() for setting in settings: settingsElem = self.__doc.createElement(SETTINGS_ELEM_NAME) settingsElem.setAttributeNode(self._createAttribute(TYPE_ATTR, subHeader)) settingTextNode = self._createTextNode(setting) settingsElem.appendChild(settingTextNode) userElem.appendChild(settingsElem) userSettingsElem.appendChild(userSettingElem) def dbTables(self, dbTables): """ Adds information of the existing db tables to the xml """ if not isinstance(dbTables, dict): self.string(TABLES_ELEM_NAME, dbTables) return dbTablesElem = self.__doc.createElement(DB_TABLES_ELEM_NAME) for db, tables in dbTables.items(): tables.sort(key=lambda x: x.lower()) dbElem = self.__doc.createElement(DATABASE_ELEM_NAME) dbElem.setAttributeNode(self._createAttribute(NAME_ATTR, db)) dbTablesElem.appendChild(dbElem) for table in tables: tableElem = self.__doc.createElement(DB_TABLE_ELEM_NAME) tableElem.appendChild(self._createTextNode(table)) dbElem.appendChild(tableElem) self._addToRoot(dbTablesElem) def dbTableColumns(self, tableColumns): """ Adds information about the columns of the existing tables to the xml """ columnsElem = self._getRootChild(COLUMNS_ELEM_NAME) if not(columnsElem): columnsElem = self.__doc.createElement(COLUMNS_ELEM_NAME) for db, tables in tableColumns.items(): if not db: db = DEFAULT_DB dbElem = self.__doc.createElement(DATABASE_COLUMNS_ELEM) dbElem.setAttributeNode(self._createAttribute(NAME_ATTR, db)) columnsElem.appendChild(dbElem) for table, columns in tables.items(): tableElem = self.__doc.createElement(TABLE_ELEM_NAME) tableElem.setAttributeNode(self._createAttribute(NAME_ATTR, table)) colList = columns.keys() colList.sort(key=lambda x: x.lower()) for column in colList: colType = columns[column] colElem = self.__doc.createElement(COLUMN_ELEM_NAME) if colType is not None: colElem.setAttributeNode(self._createAttribute(TYPE_ATTR, colType)) else: colElem.setAttributeNode(self._createAttribute(TYPE_ATTR, UNKNOWN_COLUMN_TYPE)) colElem.appendChild(self._createTextNode(column)) tableElem.appendChild(colElem) self._addToRoot(columnsElem) def dbTableValues(self, tableValues): """ Adds the values of specific table to the xml. The values are organized according to the relevant row and column. """ tableElem = self.__doc.createElement(DB_TABLE_VALUES_ELEM_NAME) if (tableValues is not None): db = tableValues["__infos__"]["db"] if not db: db = "All" table = tableValues["__infos__"]["table"] count = int(tableValues["__infos__"]["count"]) columns = tableValues.keys() columns.sort(key=lambda x: x.lower()) tableElem.setAttributeNode(self._createAttribute(DB_ATTR, db)) tableElem.setAttributeNode(self._createAttribute(NAME_ATTR, table)) for i in range(count): rowElem = self.__doc.createElement(ROW_ELEM_NAME) tableElem.appendChild(rowElem) for column in columns: if column != "__infos__": info = tableValues[column] value = info["values"][i] if re.search("^[\ *]*$", value): value = "NULL" cellElem = self.__doc.createElement(CELL_ELEM_NAME) cellElem.setAttributeNode(self._createAttribute(COLUMN_ATTR, column)) cellElem.appendChild(self._createTextNode(value)) rowElem.appendChild(cellElem) dbValuesElem = self._getRootChild(DB_VALUES_ELEM) if (not(dbValuesElem)): dbValuesElem = self.__doc.createElement(DB_VALUES_ELEM) self._addToRoot(dbValuesElem) dbValuesElem.appendChild(tableElem) logger.info("Table '%s.%s' dumped to XML file" % (db, table)) def dbColumns(self, dbColumns, colConsider, dbs): """ Adds information about the columns """ for column in dbColumns.keys(): printDbs = {} for db, tblData in dbs.items(): for tbl, colData in tblData.items(): for col, dataType in colData.items(): if column in col: if db in printDbs: if tbl in printDbs[db]: printDbs[db][tbl][col] = dataType else: printDbs[db][tbl] = {col: dataType} else: printDbs[db] = {} printDbs[db][tbl] = {col: dataType} continue self.dbTableColumns(printDbs) def query(self, query, queryRes): """ Adds details of an executed query to the xml. The query details are the query itself and its results. """ queryElem = self.__doc.createElement(QUERY_ELEM_NAME) queryElem.setAttributeNode(self._createAttribute(VALUE_ATTR, query)) queryElem.appendChild(self._createTextNode(queryRes)) queriesElem = self._getRootChild(QUERIES_ELEM_NAME) if (not(queriesElem)): queriesElem = self.__doc.createElement(QUERIES_ELEM_NAME) self._addToRoot(queriesElem) queriesElem.appendChild(queryElem) def registerValue(self, registerData): """ Adds information about an extracted registry key to the xml """ registerElem = self.__doc.createElement(REGISTER_DATA_ELEM_NAME) registerElem.appendChild(self._createTextNode(registerData)) registriesElem = self._getRootChild(REGISTERY_ENTRIES_ELEM_NAME) if (not(registriesElem)): registriesElem = self.__doc.createElement(REGISTERY_ENTRIES_ELEM_NAME) self._addToRoot(registriesElem) registriesElem.appendChild(registerElem) def rFile(self, filePath, data): """ Adds an extracted file's content to the xml """ fileContentElem = self.__doc.createElement(FILE_CONTENT_ELEM_NAME) fileContentElem.setAttributeNode(self._createAttribute(NAME_ATTR, filePath)) fileContentElem.appendChild(self._createTextNode(data)) self._addToRoot(fileContentElem) def setOutputFile(self): """ Initiates the xml file from the configuration. """ if (conf.xmlFile): try: self._outputFile = conf.xmlFile self.__root = None if os.path.exists(self._outputFile): try: self.__doc = xml.dom.minidom.parse(self._outputFile) self.__root = self.__doc.childNodes[0] except ExpatError: self.__doc = Document() self._outputFP = codecs.open(self._outputFile, "w+", UNICODE_ENCODING) if self.__root is None: self.__root = self.__doc.createElementNS(NAME_SPACE_ATTR, RESULTS_ELEM_NAME) self.__root.setAttributeNode(self._createAttribute(XMLNS_ATTR, NAME_SPACE_ATTR)) self.__root.setAttributeNode(self._createAttribute(SCHEME_NAME_ATTR, SCHEME_NAME)) self.__doc.appendChild(self.__root) except IOError: raise SqlmapFilePathException("Wrong filename provided for saving the xml file: %s" % conf.xmlFile) def getOutputFile(self): return self._outputFile def finish(self, resultStatus, resultMsg=""): """ Finishes the dumper operation: 1. Adds the session status to the xml 2. Writes the xml to the file 3. Closes the xml file """ if ((self._outputFP is not None) and not(self._outputFP.closed)): statusElem = self.__doc.createElement(STATUS_ELEM_NAME) statusElem.setAttributeNode(self._createAttribute(SUCESS_ATTR, getUnicode(resultStatus))) if not resultStatus: errorElem = self.__doc.createElement(ERROR_ELEM_NAME) if isinstance(resultMsg, Exception): errorElem.setAttributeNode(self._createAttribute(TYPE_ATTR, type(resultMsg).__name__)) else: errorElem.setAttributeNode(self._createAttribute(TYPE_ATTR, UNHANDLED_PROBLEM_TYPE)) errorElem.appendChild(self._createTextNode(getUnicode(resultMsg))) statusElem.appendChild(errorElem) self._addToRoot(statusElem) self.__write(prettyprint.formatXML(self.__doc, encoding=UNICODE_ENCODING)) self._outputFP.close()
def to_xml(self): document = Document() channels = document.createElementNS(XMLDOC_NAMESPACE, CHANNELS_ROOT_NODE) channels.setAttribute(XMLDOC_XMLNS_ATTRIBUTE, XMLDOC_NAMESPACE) document.appendChild(channels) return document.toxml(encoding=XMLDOC_CODEPAGE)
def __call__(self, *args, **kwargs): for i, arg in enumerate(args): try: kwargs[self.param_names[i]] = arg except IndexError: for param in self.param_names: print(param) raise doc = Document() envelope = doc.createElementNS('', 's:Envelope') envelope.setAttribute('xmlns:s', ENVELOPE_XMLNS) envelope.setAttribute('s:encodingStyle', 'http://schemas.xmlsoap.org/soap/encoding/') body = doc.createElementNS('', 's:Body') fn = doc.createElementNS('', self.__name__) fn.setAttribute('xmlns:u', self.service) for i, param in enumerate(self.params): if self.param_names[i] not in kwargs: value = param(None) else: value = param(kwargs[self.param_names[i]]) tmp_node = doc.createElement(self.param_names[i]) tmp_text_node = doc.createTextNode(str(value)) tmp_node.appendChild(tmp_text_node) fn.appendChild(tmp_node) body.appendChild(fn) envelope.appendChild(body) doc.appendChild(envelope) pure_xml = doc.toxml() header = { 'SOAPAction': '"{service}#{method}"'.format(service=self.service, method=self.__name__), 'Content-Type': 'text/xml' } response = requests.post(self.control_url, data=pure_xml, headers=header) envelope = etree.fromstring(response.content) envelope = strip_xmlns(envelope) body = envelope.find('Body') return_value = [] if body is not None: response = body.find(self.__name__ + 'Response') if response is not None: for i, ret_val in enumerate(self.ret_vals): value = response.find(self.ret_val_names[i]) if value is None: value = ret_val(None) else: value = ret_val(value.text) return_value += [value] if not return_value and self.ret_vals: for val in self.ret_vals: return_value += [val(None)] return return_value
def to_xml(self): document = Document() recordings = document.createElementNS(XMLDOC_NAMESPACE, RECORDINGS_ROOT_NODE) recordings.setAttribute(XMLDOC_XMLNS_ATTRIBUTE, XMLDOC_NAMESPACE) document.appendChild(recordings) return document.toxml(encoding=XMLDOC_CODEPAGE)
def generate_name_id(value, sp_nq, sp_format, cert=None, debug=False, nq=None): """ Generates a nameID. :param value: fingerprint :type: string :param sp_nq: SP Name Qualifier :type: string :param sp_format: SP Format :type: string :param cert: IdP Public Cert to encrypt the nameID :type: string :param debug: Activate the xmlsec debug :type: bool :param nq: IDP Name Qualifier :type: string :returns: DOMElement | XMLSec nameID :rtype: string """ doc = Document() name_id_container = doc.createElementNS( OneLogin_Saml2_Constants.NS_SAML, 'container') name_id_container.setAttribute("xmlns:saml", OneLogin_Saml2_Constants.NS_SAML) name_id = doc.createElement('saml:NameID') if sp_nq is not None: name_id.setAttribute('SPNameQualifier', sp_nq) if nq is not None: name_id.setAttribute('NameQualifier', nq) name_id.setAttribute('Format', sp_format) name_id.appendChild(doc.createTextNode(value)) name_id_container.appendChild(name_id) if cert is not None: xml = name_id_container.toxml() elem = fromstring(xml) if debug: xmlsec.set_error_callback(print_xmlsec_errors) # Load the public cert mngr = xmlsec.KeysMngr() file_cert = OneLogin_Saml2_Utils.write_temp_file(cert) key_data = xmlsec.Key.load(file_cert.name, xmlsec.KeyDataFormatCertPem, None) key_data.name = basename(file_cert.name) mngr.addKey(key_data) file_cert.close() # Prepare for encryption enc_data = EncData(xmlsec.TransformAes128Cbc, type=xmlsec.TypeEncElement) enc_data.ensureCipherValue() key_info = enc_data.ensureKeyInfo() # enc_key = key_info.addEncryptedKey(xmlsec.TransformRsaPkcs1) enc_key = key_info.addEncryptedKey(xmlsec.TransformRsaOaep) enc_key.ensureCipherValue() # Encrypt! enc_ctx = xmlsec.EncCtx(mngr) enc_ctx.encKey = xmlsec.Key.generate(xmlsec.KeyDataAes, 128, xmlsec.KeyDataTypeSession) edata = enc_ctx.encryptXml(enc_data, elem[0]) newdoc = parseString( etree.tostring(edata, encoding='unicode').encode('utf-8')) if newdoc.hasChildNodes(): child = newdoc.firstChild child.removeAttribute('xmlns') child.removeAttribute('xmlns:saml') child.setAttribute('xmlns:xenc', OneLogin_Saml2_Constants.NS_XENC) child.setAttribute('xmlns:dsig', OneLogin_Saml2_Constants.NS_DS) nodes = newdoc.getElementsByTagName("*") for node in nodes: if node.tagName == 'ns0:KeyInfo': node.tagName = 'dsig:KeyInfo' node.removeAttribute('xmlns:ns0') node.setAttribute('xmlns:dsig', OneLogin_Saml2_Constants.NS_DS) else: node.tagName = 'xenc:' + node.tagName encrypted_id = newdoc.createElement('saml:EncryptedID') encrypted_data = newdoc.replaceChild(encrypted_id, newdoc.firstChild) encrypted_id.appendChild(encrypted_data) return newdoc.saveXML(encrypted_id) else: return doc.saveXML(name_id)
# test for xml.dom.minidom
class XMLDump: ''' This class purpose is to dump the data into an xml Format. The format of the xml file is described in the scheme file xml/sqlmap.xsd ''' def __init__(self): self.__outputFile = None self.__outputFP = None self.__root = None self.__doc = Document() def __addToRoot(self, element): ''' Adds element to the root element ''' self.__root.appendChild(element) def __write(self, data, n=True): ''' Writes the data into the file ''' if n: self.__outputFP.write("%s\n" % data) else: self.__outputFP.write("%s " % data) self.__outputFP.flush() kb.dataOutputFlag = True def __getRootChild(self, elemName): ''' Returns the child of the root with the described name ''' elements = self.__root.getElementsByTagName(elemName) if elements: return elements[0] return elements def __createTextNode(self, data): ''' Creates a text node with utf8 data inside. The text is escaped to an fit the xml text Format. ''' if data is None: return self.__doc.createTextNode(u'') else: escaped_data = saxutils.escape(data, ENTITIES) return self.__doc.createTextNode(escaped_data) def __createAttribute(self, attrName, attrValue): ''' Creates an attribute node with utf8 data inside. The text is escaped to an fit the xml text Format. ''' attr = self.__doc.createAttribute(attrName) if attrValue is None: attr.nodeValue = u'' else: attr.nodeValue = getUnicode(attrValue) return attr def string(self, header, data, sort=True): ''' Adds string element to the xml. ''' if isinstance(data, (list, tuple, set)): self.lister(header, data, sort) return messagesElem = self.__getRootChild(MESSAGES_ELEM_NAME) if (not (messagesElem)): messagesElem = self.__doc.createElement(MESSAGES_ELEM_NAME) self.__addToRoot(messagesElem) if data: data = self.__formatString(data) else: data = "" elem = self.__doc.createElement(MESSAGE_ELEM) elem.setAttributeNode(self.__createAttribute(TYPE_ATTR, header)) elem.appendChild(self.__createTextNode(data)) messagesElem.appendChild(elem) def lister(self, header, elements, sort=True): ''' Adds information formatted as list element ''' lstElem = self.__doc.createElement(LST_ELEM_NAME) lstElem.setAttributeNode(self.__createAttribute(TYPE_ATTR, header)) if elements: if sort: try: elements = set(elements) elements = list(elements) elements.sort(key=lambda x: x.lower()) except: pass for element in elements: memberElem = self.__doc.createElement(MEMBER_ELEM) lstElem.appendChild(memberElem) if isinstance(element, basestring): memberElem.setAttributeNode( self.__createAttribute(TYPE_ATTR, "string")) memberElem.appendChild(self.__createTextNode(element)) elif isinstance(element, (list, tuple, set)): memberElem.setAttributeNode( self.__createAttribute(TYPE_ATTR, "list")) for e in element: memberElemStr = self.__doc.createElement(MEMBER_ELEM) memberElemStr.setAttributeNode( self.__createAttribute(TYPE_ATTR, "string")) memberElemStr.appendChild( self.__createTextNode(getUnicode(e))) memberElem.appendChild(memberElemStr) listsElem = self.__getRootChild(LSTS_ELEM_NAME) if not (listsElem): listsElem = self.__doc.createElement(LSTS_ELEM_NAME) self.__addToRoot(listsElem) listsElem.appendChild(lstElem) def technic(self, technicType, data): ''' Adds information about the technic used to extract data from the db ''' technicElem = self.__doc.createElement(TECHNIC_ELEM_NAME) technicElem.setAttributeNode( self.__createAttribute(TYPE_ATTR, technicType)) textNode = self.__createTextNode(data) technicElem.appendChild(textNode) technicsElem = self.__getRootChild(TECHNICS_ELEM_NAME) if not (technicsElem): technicsElem = self.__doc.createElement(TECHNICS_ELEM_NAME) self.__addToRoot(technicsElem) technicsElem.appendChild(technicElem) def banner(self, data): ''' Adds information about the database banner to the xml. The banner contains information about the type and the version of the database. ''' bannerElem = self.__doc.createElement(BANNER_ELEM_NAME) bannerElem.appendChild(self.__createTextNode(data)) self.__addToRoot(bannerElem) def currentUser(self, data): ''' Adds information about the current database user to the xml ''' currentUserElem = self.__doc.createElement(CURRENT_USER_ELEM_NAME) textNode = self.__createTextNode(data) currentUserElem.appendChild(textNode) self.__addToRoot(currentUserElem) def currentDb(self, data): ''' Adds information about the current database is use to the xml ''' currentDBElem = self.__doc.createElement(CURRENT_DB_ELEM_NAME) textNode = self.__createTextNode(data) currentDBElem.appendChild(textNode) self.__addToRoot(currentDBElem) def dba(self, isDBA): ''' Adds information to the xml that indicates whether the user has DBA privileges ''' isDBAElem = self.__doc.createElement(IS_DBA_ELEM_NAME) isDBAElem.setAttributeNode( self.__createAttribute(VALUE_ATTR, getUnicode(isDBA))) self.__addToRoot(isDBAElem) def users(self, users): ''' Adds a list of the existing users to the xml ''' usersElem = self.__doc.createElement(USERS_ELEM_NAME) if isinstance(users, basestring): users = [users] if users: for user in users: userElem = self.__doc.createElement(DB_USER_ELEM_NAME) usersElem.appendChild(userElem) userElem.appendChild(self.__createTextNode(user)) self.__addToRoot(usersElem) def dbs(self, dbs): ''' Adds a list of the existing databases to the xml ''' dbsElem = self.__doc.createElement(DBS_ELEM_NAME) if dbs: for db in dbs: dbElem = self.__doc.createElement(DB_NAME_ELEM_NAME) dbsElem.appendChild(dbElem) dbElem.appendChild(self.__createTextNode(db)) self.__addToRoot(dbsElem) def userSettings(self, header, userSettings, subHeader): ''' Adds information about the user's settings to the xml. The information can be user's passwords, privileges and etc.. ''' self.__areAdmins = set() userSettingsElem = self.__getRootChild(USER_SETTINGS_ELEM_NAME) if (not (userSettingsElem)): userSettingsElem = self.__doc.createElement( USER_SETTINGS_ELEM_NAME) self.__addToRoot(userSettingsElem) userSettingElem = self.__doc.createElement(USER_SETTING_ELEM_NAME) userSettingElem.setAttributeNode( self.__createAttribute(TYPE_ATTR, header)) if isinstance(userSettings, (tuple, list, set)): self.__areAdmins = userSettings[1] userSettings = userSettings[0] users = userSettings.keys() users.sort(key=lambda x: x.lower()) for user in users: userElem = self.__doc.createElement(USER_ELEM_NAME) userSettingElem.appendChild(userElem) if user in self.__areAdmins: userElem.setAttributeNode( self.__createAttribute(TYPE_ATTR, ADMIN_USER)) else: userElem.setAttributeNode( self.__createAttribute(TYPE_ATTR, REGULAR_USER)) settings = userSettings[user] settings.sort() for setting in settings: settingsElem = self.__doc.createElement(SETTINGS_ELEM_NAME) settingsElem.setAttributeNode( self.__createAttribute(TYPE_ATTR, subHeader)) settingTextNode = self.__createTextNode(setting) settingsElem.appendChild(settingTextNode) userElem.appendChild(settingsElem) userSettingsElem.appendChild(userSettingElem) def dbTables(self, dbTables): ''' Adds information of the existing db tables to the xml ''' if not isinstance(dbTables, dict): self.string(TABLES_ELEM_NAME, dbTables) return dbTablesElem = self.__doc.createElement(DB_TABLES_ELEM_NAME) for db, tables in dbTables.items(): tables.sort(key=lambda x: x.lower()) dbElem = self.__doc.createElement(DATABASE_ELEM_NAME) dbElem.setAttributeNode(self.__createAttribute(NAME_ATTR, db)) dbTablesElem.appendChild(dbElem) for table in tables: tableElem = self.__doc.createElement(DB_TABLE_ELEM_NAME) tableElem.appendChild(self.__createTextNode(table)) dbElem.appendChild(tableElem) self.__addToRoot(dbTablesElem) def dbTableColumns(self, tableColumns): ''' Adds information about the columns of the existing tables to the xml ''' columnsElem = self.__getRootChild(COLUMNS_ELEM_NAME) if not (columnsElem): columnsElem = self.__doc.createElement(COLUMNS_ELEM_NAME) for db, tables in tableColumns.items(): if not db: db = DEFAULT_DB dbElem = self.__doc.createElement(DATABASE_COLUMNS_ELEM) dbElem.setAttributeNode(self.__createAttribute(NAME_ATTR, db)) columnsElem.appendChild(dbElem) for table, columns in tables.items(): tableElem = self.__doc.createElement(TABLE_ELEM_NAME) tableElem.setAttributeNode( self.__createAttribute(NAME_ATTR, table)) colList = columns.keys() colList.sort(key=lambda x: x.lower()) for column in colList: colType = columns[column] colElem = self.__doc.createElement(COLUMN_ELEM_NAME) if colType is not None: colElem.setAttributeNode( self.__createAttribute(TYPE_ATTR, colType)) else: colElem.setAttributeNode( self.__createAttribute(TYPE_ATTR, UNKNOWN_COLUMN_TYPE)) colElem.appendChild(self.__createTextNode(column)) tableElem.appendChild(colElem) self.__addToRoot(columnsElem) def dbTableValues(self, tableValues): ''' Adds the values of specific table to the xml. The values are organized according to the relevant row and column. ''' tableElem = self.__doc.createElement(DB_TABLE_VALUES_ELEM_NAME) if (tableValues is not None): db = tableValues["__infos__"]["db"] if not db: db = "All" table = tableValues["__infos__"]["table"] count = int(tableValues["__infos__"]["count"]) columns = tableValues.keys() columns.sort(key=lambda x: x.lower()) tableElem.setAttributeNode(self.__createAttribute(DB_ATTR, db)) tableElem.setAttributeNode(self.__createAttribute( NAME_ATTR, table)) for i in range(count): rowElem = self.__doc.createElement(ROW_ELEM_NAME) tableElem.appendChild(rowElem) for column in columns: if column != "__infos__": info = tableValues[column] value = info["values"][i] if re.search("^[\ *]*$", value): value = "NULL" cellElem = self.__doc.createElement(CELL_ELEM_NAME) cellElem.setAttributeNode( self.__createAttribute(COLUMN_ATTR, column)) cellElem.appendChild(self.__createTextNode(value)) rowElem.appendChild(cellElem) dbValuesElem = self.__getRootChild(DB_VALUES_ELEM) if (not (dbValuesElem)): dbValuesElem = self.__doc.createElement(DB_VALUES_ELEM) self.__addToRoot(dbValuesElem) dbValuesElem.appendChild(tableElem) logger.info("Table '%s.%s' dumped to XML file" % (db, table)) def dbColumns(self, dbColumns, colConsider, dbs): ''' Adds information about the columns ''' for column in dbColumns.keys(): printDbs = {} for db, tblData in dbs.items(): for tbl, colData in tblData.items(): for col, dataType in colData.items(): if column in col: if db in printDbs: if tbl in printDbs[db]: printDbs[db][tbl][col] = dataType else: printDbs[db][tbl] = {col: dataType} else: printDbs[db] = {} printDbs[db][tbl] = {col: dataType} continue self.dbTableColumns(printDbs) def query(self, query, queryRes): ''' Adds details of an executed query to the xml. The query details are the query itself and it's results. ''' queryElem = self.__doc.createElement(QUERY_ELEM_NAME) queryElem.setAttributeNode(self.__createAttribute(VALUE_ATTR, query)) queryElem.appendChild(self.__createTextNode(queryRes)) queriesElem = self.__getRootChild(QUERIES_ELEM_NAME) if (not (queriesElem)): queriesElem = self.__doc.createElement(QUERIES_ELEM_NAME) self.__addToRoot(queriesElem) queriesElem.appendChild(queryElem) def registerValue(self, registerData): ''' Adds information about an extracted registry key to the xml ''' registerElem = self.__doc.createElement(REGISTER_DATA_ELEM_NAME) registerElem.appendChild(self.__createTextNode(registerData)) registriesElem = self.__getRootChild(REGISTERY_ENTRIES_ELEM_NAME) if (not (registriesElem)): registriesElem = self.__doc.createElement( REGISTERY_ENTRIES_ELEM_NAME) self.__addToRoot(registriesElem) registriesElem.appendChild(registerElem) def rFile(self, filePath, data): ''' Adds an extracted file's content to the xml ''' fileContentElem = self.__doc.createElement(FILE_CONTENT_ELEM_NAME) fileContentElem.setAttributeNode( self.__createAttribute(NAME_ATTR, filePath)) fileContentElem.appendChild(self.__createTextNode(data)) self.__addToRoot(fileContentElem) def setOutputFile(self): ''' Initiates the xml file from the configuration. ''' if (conf.xmlFile): try: self.__outputFile = conf.xmlFile self.__root = None if os.path.exists(self.__outputFile): try: self.__doc = xml.dom.minidom.parse(self.__outputFile) self.__root = self.__doc.childNodes[0] except ExpatError: self.__doc = Document() self.__outputFP = codecs.open(self.__outputFile, "w+", UNICODE_ENCODING) if self.__root is None: self.__root = self.__doc.createElementNS( NAME_SPACE_ATTR, RESULTS_ELEM_NAME) self.__root.setAttributeNode( self.__createAttribute(XMLNS_ATTR, NAME_SPACE_ATTR)) self.__root.setAttributeNode( self.__createAttribute(SCHEME_NAME_ATTR, SCHEME_NAME)) self.__doc.appendChild(self.__root) except IOError: raise sqlmapFilePathException( "Wrong filename provided for saving the xml file: %s" % conf.xmlFile) def getOutputFile(self): return self.__outputFile def finish(self, resultStatus, resultMsg=""): ''' Finishes the dumper operation: 1. Adds the session status to the xml 2. Writes the xml to the file 3. Closes the xml file ''' if ((self.__outputFP is not None) and not (self.__outputFP.closed)): statusElem = self.__doc.createElement(STATUS_ELEM_NAME) statusElem.setAttributeNode( self.__createAttribute(SUCESS_ATTR, getUnicode(resultStatus))) if not resultStatus: errorElem = self.__doc.createElement(ERROR_ELEM_NAME) if isinstance(resultMsg, Exception): errorElem.setAttributeNode( self.__createAttribute(TYPE_ATTR, type(resultMsg).__name__)) else: errorElem.setAttributeNode( self.__createAttribute(TYPE_ATTR, UNHANDLED_PROBLEM_TYPE)) errorElem.appendChild( self.__createTextNode(getUnicode(resultMsg))) statusElem.appendChild(errorElem) self.__addToRoot(statusElem) self.__write( prettyprint.formatXML(self.__doc, encoding=UNICODE_ENCODING)) self.__outputFP.close()
def SaveSettings(self, saveAccountDetails=None, savePassword=None, game=None): doc = None # Check if settings directory exists if not create if not os.path.exists(self.settingsDir): os.mkdir(self.settingsDir) if not self.osType.usingWindows: os.makedirs(self.settingsDir + "wine/prefix", exist_ok=True) # Check if settings file exists if not create new settings XML if os.path.exists(self.settingsFile): doc = defusedxml.minidom.parse(self.settingsFile) settingsNode = doc.getElementsByTagName("Settings") else: doc = Document() settingsNode = doc.createElementNS(EMPTY_NAMESPACE, "Settings") doc.appendChild(settingsNode) current_game = game if game else self.currentGame # Set default game to current game defaultGameNode = doc.getElementsByTagName("Default.Game") if len(defaultGameNode) > 0: defaultGameNode[0].firstChild.nodeValue = current_game else: defaultGameNode = doc.createElementNS(EMPTY_NAMESPACE, "Default.Game") defaultGameNode.appendChild(doc.createTextNode(current_game)) settingsNode.appendChild(defaultGameNode) # Remove old game block tempNode = doc.getElementsByTagName(current_game) if len(tempNode) > 0: doc.documentElement.removeChild(tempNode[0]) # Create new game block settingsNode = doc.getElementsByTagName("Settings")[0] gameConfigNode = doc.createElementNS(EMPTY_NAMESPACE, current_game) settingsNode.appendChild(gameConfigNode) # Some settings for test/preview clients are saved in normal client settings if current_game.endswith(".Test"): normalClientNode = self.getNormalClientNode(current_game, doc) if not normalClientNode: normalClientNode = doc.createElementNS(EMPTY_NAMESPACE, current_game) settingsNode.appendChild(normalClientNode) if not self.osType.usingWindows: tempNode = doc.createElementNS(EMPTY_NAMESPACE, "Wine.Program") tempNode.appendChild(doc.createTextNode("%s" % (self.wineProg))) gameConfigNode.appendChild(tempNode) tempNode = doc.createElementNS(EMPTY_NAMESPACE, "Wine.Debug") tempNode.appendChild(doc.createTextNode("%s" % (self.wineDebug))) gameConfigNode.appendChild(tempNode) if self.winePrefix != "": tempNode = doc.createElementNS(EMPTY_NAMESPACE, "Wine.Prefix") tempNode.appendChild( doc.createTextNode("%s" % (self.winePrefix))) gameConfigNode.appendChild(tempNode) tempNode = doc.createElementNS(EMPTY_NAMESPACE, "HiRes") if self.hiResEnabled: tempNode.appendChild(doc.createTextNode("True")) else: tempNode.appendChild(doc.createTextNode("False")) gameConfigNode.appendChild(tempNode) tempNode = doc.createElementNS(EMPTY_NAMESPACE, "x64Client") if self.x64ClientEnabled: tempNode.appendChild(doc.createTextNode("True")) else: tempNode.appendChild(doc.createTextNode("False")) gameConfigNode.appendChild(tempNode) tempNode = doc.createElementNS(EMPTY_NAMESPACE, "Game.Directory") tempNode.appendChild(doc.createTextNode("%s" % (self.gameDir))) gameConfigNode.appendChild(tempNode) tempNode = doc.createElementNS(EMPTY_NAMESPACE, "PatchClient") tempNode.appendChild(doc.createTextNode("%s" % (self.patchClient))) gameConfigNode.appendChild(tempNode) tempNode = doc.createElementNS(EMPTY_NAMESPACE, "Language") tempNode.appendChild(doc.createTextNode("%s" % (self.language))) gameConfigNode.appendChild(tempNode) if saveAccountDetails: accountsNode = doc.createElementNS(EMPTY_NAMESPACE, "Accounts") # Adds all saved accounts with their account specific settings. for account in self.accountsDictionary: accountNode = doc.createElementNS(EMPTY_NAMESPACE, account) tempNode = doc.createElementNS(EMPTY_NAMESPACE, "World") tempNode.appendChild( doc.createTextNode("%s" % (self.accountsDictionary[account][0]))) accountNode.appendChild(tempNode) accountsNode.appendChild(accountNode) # Test/preview clients use normal client accounts. I.e they are # saved and loaded to and from the normal client node rather than the test node if current_game.endswith(".Test"): # Delete current accounts node if present. All accounts that were originally # there were loaded as if they were the test client's, so they are not lost. originalAccountsNode = normalClientNode.getElementsByTagName( "Accounts") if originalAccountsNode: normalClientNode.removeChild(originalAccountsNode[0]) normalClientNode.appendChild(accountsNode) else: gameConfigNode.appendChild(accountsNode) if savePassword: tempNode = doc.createElementNS(EMPTY_NAMESPACE, "Save.Password") tempNode.appendChild(doc.createTextNode("True")) gameConfigNode.appendChild(tempNode) startupScriptsNode = doc.createElementNS(EMPTY_NAMESPACE, "StartupScripts") for script in self.startupScripts: scriptNode = doc.createElementNS(EMPTY_NAMESPACE, "script") scriptNode.appendChild(doc.createTextNode("%s" % (script))) startupScriptsNode.appendChild(scriptNode) # Test/Preview clients store startup scripts in normal client settings, # because the add-ons folders are generally shared as well. if current_game.endswith(".Test"): # Delete current startup scripts node if present. All startup scripts # that were originally there were loaded as if they were the test client's, # so they are not lost. originalStartupScriptsNode = normalClientNode.getElementsByTagName( "StartupScripts") if originalStartupScriptsNode: normalClientNode.removeChild(originalStartupScriptsNode[0]) normalClientNode.appendChild(startupScriptsNode) else: gameConfigNode.appendChild(startupScriptsNode) # write new settings file with open(self.settingsFile, "w") as file: pretty_xml = prettify_xml(doc.toxml()) file.write(pretty_xml)
def createFeed(examples): doc = Document() atomuri = "http://www.w3.org/2005/Atom" feed = doc.createElementNS(atomuri, "feed") feed.setAttribute("xmlns", atomuri) title = doc.createElementNS(atomuri, "title") title.appendChild(doc.createTextNode("OpenLayers Examples")) feed.appendChild(title) link = doc.createElementNS(atomuri, "link") link.setAttribute("rel", "self") link.setAttribute("href", feedPath + feedName) modtime = time.strftime("%Y-%m-%dT%I:%M:%SZ", time.gmtime()) id = doc.createElementNS(atomuri, "id") id.appendChild(doc.createTextNode("%s%s#%s" % (feedPath, feedName, modtime))) feed.appendChild(id) updated = doc.createElementNS(atomuri, "updated") updated.appendChild(doc.createTextNode(modtime)) feed.appendChild(updated) examples.sort(key=lambda x: x["modified"]) for example in sorted(examples, key=lambda x: x["modified"], reverse=True): entry = doc.createElementNS(atomuri, "entry") title = doc.createElementNS(atomuri, "title") title.appendChild(doc.createTextNode(example["title"] or example["example"])) entry.appendChild(title) tags = doc.createElementNS(atomuri, "tags") tags.appendChild(doc.createTextNode(example["tags"] or example["example"])) entry.appendChild(tags) link = doc.createElementNS(atomuri, "link") link.setAttribute("href", "%s%s" % (feedPath, example["example"])) entry.appendChild(link) summary = doc.createElementNS(atomuri, "summary") summary.appendChild(doc.createTextNode(example["shortdesc"] or example["example"])) entry.appendChild(summary) updated = doc.createElementNS(atomuri, "updated") updated.appendChild(doc.createTextNode(example["modified"])) entry.appendChild(updated) author = doc.createElementNS(atomuri, "author") name = doc.createElementNS(atomuri, "name") name.appendChild(doc.createTextNode(example["author"])) author.appendChild(name) entry.appendChild(author) id = doc.createElementNS(atomuri, "id") id.appendChild(doc.createTextNode("%s%s#%s" % (feedPath, example["example"], example["modified"]))) entry.appendChild(id) feed.appendChild(entry) doc.appendChild(feed) return doc
from xml.dom.minidom import Document doc = Document() # create the envelope element and set its attributes envelope = doc.createElementNS('', 's:Envelope') envelope.setAttribute('xmlns:s', 'http://schemas.xmlsoap.org/soap/envelope/') envelope.setAttribute('s:encodingStyle', 'http://schemas.xmlsoap.org/soap/encoding/') # create the body element body = doc.createElementNS('', 's:Body') # create the function element and set its attribute fn = doc.createElementNS('', 'u:AddPortMapping') fn.setAttribute('xmlns:u', 'urn:schemas-upnp-org:service:WANIPConnection:1') # setup the argument element names and values # using a list of tuples to preserve order arguments = [ ('NewRemoteHost', ''), ('NewExternalPort', '2400'), # specify port on router ('NewProtocol', 'TCP'), # specify protocol ('NewInternalPort', '2400'), # specify port on internal host ('NewInternalClient', '192.168.0.104'), # specify IP of internal host ('NewEnabled', '1'), # turn mapping ON ('NewPortMappingDescription', 'Test desc'), # add a description ('NewLeaseDuration', '0') ] # how long should it be opened? # NewEnabled should be 1 by default, but better supply it.
# create a DOM object that represents the `directory` document dom = parseString(directory) # find all 'serviceType' elements service_types = dom.getElementsByTagName('serviceType') # iterate over service_types until we get either WANIPConnection # (this should also check for WANPPPConnection, which, if I remember correctly # exposed a similar SOAP interface on ADSL routers. for service in service_types: # I'm using the fact that a 'serviceType' element contains a single text node, who's data can # be accessed by the 'data' attribute. # When I find the right element, I take a step up into its parent and search for 'controlURL' if service.childNodes[0].data.find('WANIPConnection') > 0: path = service.parentNode.getElementsByTagName('controlURL')[0].childNodes[0].data doc = Document() # create the envelope element and set its attributes envelope = doc.createElementNS('', 's:Envelope') envelope.setAttribute('xmlns:s', 'http://schemas.xmlsoap.org/soap/envelope/') envelope.setAttribute('s:encodingStyle', 'http://schemas.xmlsoap.org/soap/encoding/') # create the body element body = doc.createElementNS('', 's:Body') # create the function element and set its attribute fn = doc.createElementNS('', 'u:AddPortMapping') fn.setAttribute('xmlns:u', 'urn:schemas-upnp-org:service:WANIPConnection:1') # setup the argument element names and values # using a list of tuples to preserve order arguments = [ ('NewRemoteHost', ''), ('NewExternalPort', '4242'), # specify port on router ('NewProtocol', 'TCP'), # specify protocol ('NewInternalPort', '4242'), # specify port on internal host ('NewInternalClient', '192.168.0.32'), # specify IP of internal host
def __call__(self, *args, **kwargs): total_params = len(list(kwargs.keys())) + len(args) if len(self.params) < total_params: raise RuntimeError( 'To many parameters specified for UPNP funcion {0}.\n' 'Allowed parameters are {1}'.format( self.__name__, ', '.join(param.__name__ for param in self.params))) for i, arg in enumerate(args): try: kwargs[self.params[i].__name__] = arg except IndexError: for param in self.params: print(param.__name__) raise doc = Document() envelope = doc.createElementNS('', 's:Envelope') envelope.setAttribute('xmlns:s', ENVELOPE_XMLNS) envelope.setAttribute('s:encodingStyle', 'http://schemas.xmlsoap.org/soap/encoding/') body = doc.createElementNS('', 's:Body') fn = doc.createElementNS('', self.__name__) fn.setAttribute('xmlns:u', self.service) for param in self.params: if param.__name__ not in kwargs: value = param(None) else: value = param(kwargs[param.__name__]) tmp_node = doc.createElement(param.__name__) tmp_text_node = doc.createTextNode(str(value)) tmp_node.appendChild(tmp_text_node) fn.appendChild(tmp_node) body.appendChild(fn) envelope.appendChild(body) doc.appendChild(envelope) pure_xml = doc.toxml() header = { 'SOAPAction': '"{service}#{method}"'.format(service=self.service, method=self.__name__), 'Content-Type': 'text/xml' } logger.debug(self.__parent.ip_address + ' <-- (' + self.control_url + ') header: ' + str(header) + ' body: ' + pure_xml) try: response = requests.post(self.control_url, data=pure_xml, headers=header) except (requests.exceptions.ConnectionError, requests.exceptions.ConnectTimeout): return [None] * len(self.ret_vals) logger.debug(self.__parent.ip_address + ' --> (' + self.control_url + ') ' + response.content.decode('utf-8')) try: envelope = etree.fromstring(response.content.decode('utf-8')) except etree.ParseError: return [None] * len(self.ret_vals) except ValueError: try: envelope = etree.fromstring(response.content) except etree.ParseError: return [None] * len(self.ret_vals) envelope = strip_xmlns(envelope) body = envelope.find('Body') return_value = [] if body is not None: response = body.find(self.__name__ + 'Response') if response is not None: for ret_val in self.ret_vals: value = response.find(ret_val.__name__) if value is None: value = ret_val(None) else: value = ret_val(value.text) return_value += [value] if not return_value and self.ret_vals: for val in self.ret_vals: return_value += [val(None)] return return_value
def generate_name_id(value, sp_nq, sp_format, cert=None, debug=False): """ Generates a nameID. :param value: fingerprint :type: string :param sp_nq: SP Name Qualifier :type: string :param sp_format: SP Format :type: string :param cert: IdP Public Cert to encrypt the nameID :type: string :param debug: Activate the xmlsec debug :type: bool :returns: DOMElement | XMLSec nameID :rtype: string """ doc = Document() name_id_container = doc.createElementNS(OneLogin_Saml2_Constants.NS_SAML, 'container') name_id_container.setAttribute("xmlns:saml", OneLogin_Saml2_Constants.NS_SAML) name_id = doc.createElement('saml:NameID') name_id.setAttribute('SPNameQualifier', sp_nq) name_id.setAttribute('Format', sp_format) name_id.appendChild(doc.createTextNode(value)) name_id_container.appendChild(name_id) if cert is not None: xml = name_id_container.toxml() elem = fromstring(xml) xmlsec.initialize() if debug: xmlsec.set_error_callback(print_xmlsec_errors) # Load the public cert mngr = xmlsec.KeysMngr() file_cert = OneLogin_Saml2_Utils.write_temp_file(cert) key_data = xmlsec.Key.load(file_cert.name, xmlsec.KeyDataFormatCertPem, None) key_data.name = basename(file_cert.name) mngr.addKey(key_data) file_cert.close() # Prepare for encryption enc_data = EncData(xmlsec.TransformAes128Cbc, type=xmlsec.TypeEncElement) enc_data.ensureCipherValue() key_info = enc_data.ensureKeyInfo() # enc_key = key_info.addEncryptedKey(xmlsec.TransformRsaPkcs1) enc_key = key_info.addEncryptedKey(xmlsec.TransformRsaOaep) enc_key.ensureCipherValue() # Encrypt! enc_ctx = xmlsec.EncCtx(mngr) enc_ctx.encKey = xmlsec.Key.generate(xmlsec.KeyDataAes, 128, xmlsec.KeyDataTypeSession) edata = enc_ctx.encryptXml(enc_data, elem[0]) newdoc = parseString(etree.tostring(edata)) if newdoc.hasChildNodes(): child = newdoc.firstChild child.removeAttribute('xmlns') child.removeAttribute('xmlns:saml') child.setAttribute('xmlns:xenc', OneLogin_Saml2_Constants.NS_XENC) child.setAttribute('xmlns:dsig', OneLogin_Saml2_Constants.NS_DS) nodes = newdoc.getElementsByTagName("*") for node in nodes: if node.tagName == 'ns0:KeyInfo': node.tagName = 'dsig:KeyInfo' node.removeAttribute('xmlns:ns0') node.setAttribute('xmlns:dsig', OneLogin_Saml2_Constants.NS_DS) else: node.tagName = 'xenc:' + node.tagName encrypted_id = newdoc.createElement('saml:EncryptedID') encrypted_data = newdoc.replaceChild(encrypted_id, newdoc.firstChild) encrypted_id.appendChild(encrypted_data) return newdoc.saveXML(encrypted_id) else: return doc.saveXML(name_id)
def open_port(service_url, external_port, internal_client, internal_port=None, protocol='TCP', duration=0, description=None, enabled=1): parsedurl = urlparse(service_url) if internal_port == None: internal_port = external_port if description == None: description = 'generated by port-forward.py' if not enabled: duration = 1 doc = Document() # create the envelope element and set its attributes envelope = doc.createElementNS('', 's:Envelope') envelope.setAttribute('xmlns:s', 'http://schemas.xmlsoap.org/soap/envelope/') envelope.setAttribute('s:encodingStyle', 'http://schemas.xmlsoap.org/soap/encoding/') # create the body element body = doc.createElementNS('', 's:Body') # create the function element and set its attribute fn = doc.createElementNS('', 'u:AddPortMapping') fn.setAttribute('xmlns:u', 'urn:schemas-upnp-org:service:WANIPConnection:1') # setup the argument element names and values # using a list of tuples to preserve order arguments = [ ('NewRemoteHost', ""), # unused - but required ('NewExternalPort', external_port), # specify port on router ('NewProtocol', protocol), # specify protocol ('NewInternalPort', internal_port), # specify port on internal host ('NewInternalClient', internal_client), # specify IP of internal host ('NewEnabled', enabled), # turn mapping ON ('NewPortMappingDescription', description), # add a description ('NewLeaseDuration', duration) ] # how long should it be opened? # NewEnabled should be 1 by default, but better supply it. # NewPortMappingDescription Can be anything you want, even an empty string. # NewLeaseDuration can be any integer BUT some UPnP devices don't support it, # so set it to 0 for better compatibility. # container for created nodes argument_list = [] # iterate over arguments, create nodes, create text nodes, # append text nodes to nodes, and finally add the ready product # to argument_list for k, v in arguments: v = str(v) tmp_node = doc.createElement(k) tmp_text_node = doc.createTextNode(v) tmp_node.appendChild(tmp_text_node) argument_list.append(tmp_node) # append the prepared argument nodes to the function element for arg in argument_list: fn.appendChild(arg) # append function element to the body element body.appendChild(fn) # append body element to envelope element envelope.appendChild(body) # append envelope element to document, making it the root element doc.appendChild(envelope) # our tree is ready, conver it to a string pure_xml = doc.toxml() # use the object returned by urlparse.urlparse to get the hostname and port conn = HTTPConnection(parsedurl.hostname, parsedurl.port) # use the path of WANIPConnection (or WANPPPConnection) to target that service, # insert the xml payload, # add two headers to make tell the server what we're sending exactly. conn.request( 'POST', parsedurl.path, pure_xml, { 'SOAPAction': '"urn:schemas-upnp-org:service:WANIPConnection:1#AddPortMapping"', 'Content-Type': 'text/xml' }) # wait for a response resp = conn.getresponse() return resp.status, resp.read()
def serializeList(self, itemOrList): prov = 'http://www.w3.org/ns/prov#' nfo = 'http://www.semanticdesktop.org/ontologies/2007/03/22/nfo#' dct = 'http://purl.org/dc/terms/' dom = Document() doc = dom.createElementNS(prov, 'prov:document') doc.setAttribute('xmlns:prov', prov) doc.setAttribute('xmlns:nfo', nfo) doc.setAttribute('xmlns:dct', dct) dom.appendChild(doc) for i, item in enumerate(itemOrList): entity = dom.createElementNS(prov, 'prov:entity') entityId = 'niprov:file'+str(i) entity.setAttribute('id', entityId) fileUrl = dom.createElementNS(nfo, 'nfo:fileUrl') fileUrlVal = dom.createTextNode(item.location.toUrl()) fileUrl.appendChild(fileUrlVal) entity.appendChild(fileUrl) if 'size' in item.provenance: fileSize = dom.createElementNS(nfo, 'nfo:fileSize') fileSizeVal = dom.createTextNode(str(item.provenance['size'])) fileSize.appendChild(fileSizeVal) entity.appendChild(fileSize) if 'created' in item.provenance: fileLastMod = dom.createElementNS(nfo, 'nfo:fileLastModified') fileLastModVal = dom.createTextNode(item.provenance['created'].isoformat()) fileLastMod.appendChild(fileLastModVal) entity.appendChild(fileLastMod) if 'hash' in item.provenance: fileHash = dom.createElementNS(nfo, 'nfo:FileHash') hashId = entityId+'.hash' fileHash.setAttribute('id', hashId) hashAlgo = dom.createElementNS(nfo, 'nfo:hashAlgorithm') hashAlgoVal = dom.createTextNode('MD5') hashAlgo.appendChild(hashAlgoVal) fileHash.appendChild(hashAlgo) hashValue = dom.createElementNS(nfo, 'nfo:hashValue') hashValueVal = dom.createTextNode(item.provenance['hash']) hashValue.appendChild(hashValueVal) fileHash.appendChild(hashValue) hasHash = dom.createElementNS(nfo, 'nfo:hasHash') hasHashVal = dom.createTextNode(hashId) hasHash.appendChild(hasHashVal) entity.appendChild(hasHash) doc.appendChild(fileHash) if 'transformation' in item.provenance: act = dom.createElementNS(prov, 'prov:activity') activityId = entityId+'.xform' act.setAttribute('id', activityId) actTitle = dom.createElementNS(dct, 'dct:title') actTitleVal = dom.createTextNode(item.provenance['transformation']) actTitle.appendChild(actTitleVal) act.appendChild(actTitle) doc.appendChild(act) wasGen = dom.createElementNS(prov, 'prov:wasGeneratedBy') entityRef = dom.createElementNS(prov, 'prov:entity') entityRef.setAttribute('prov:ref', entityId) wasGen.appendChild(entityRef) activityRef = dom.createElementNS(prov, 'prov:activity') activityRef.setAttribute('prov:ref', activityId) wasGen.appendChild(activityRef) doc.appendChild(wasGen) if 'created' in item.provenance: wasGenTime = dom.createElementNS(prov, 'prov:time') wasGenTimeVal = dom.createTextNode(item.provenance['created'].isoformat()) wasGenTime.appendChild(wasGenTimeVal) wasGen.appendChild(wasGenTime) doc.appendChild(entity) return dom.toprettyxml(encoding="UTF-8")
def open_port(service_url,external_port,internal_client,internal_port=None,protocol='TCP',duration=0,description=None,enabled=1): parsedurl = urlparse(service_url) if internal_port==None: internal_port = external_port if description == None: description = 'generated by port-forward.py' if not enabled: duration=1 doc = Document() # create the envelope element and set its attributes envelope = doc.createElementNS('', 's:Envelope') envelope.setAttribute('xmlns:s', 'http://schemas.xmlsoap.org/soap/envelope/') envelope.setAttribute('s:encodingStyle', 'http://schemas.xmlsoap.org/soap/encoding/') # create the body element body = doc.createElementNS('', 's:Body') # create the function element and set its attribute fn = doc.createElementNS('', 'u:AddPortMapping') fn.setAttribute('xmlns:u', 'urn:schemas-upnp-org:service:WANIPConnection:1') # setup the argument element names and values # using a list of tuples to preserve order arguments = [ ('NewExternalPort', external_port), # specify port on router ('NewProtocol', protocol), # specify protocol ('NewInternalPort', internal_port), # specify port on internal host ('NewInternalClient', internal_client), # specify IP of internal host ('NewEnabled', enabled), # turn mapping ON ('NewPortMappingDescription', description), # add a description ('NewLeaseDuration', duration)] # how long should it be opened? # NewEnabled should be 1 by default, but better supply it. # NewPortMappingDescription Can be anything you want, even an empty string. # NewLeaseDuration can be any integer BUT some UPnP devices don't support it, # so set it to 0 for better compatibility. # container for created nodes argument_list = [] # iterate over arguments, create nodes, create text nodes, # append text nodes to nodes, and finally add the ready product # to argument_list for k, v in arguments: v = str(v) tmp_node = doc.createElement(k) tmp_text_node = doc.createTextNode(v) tmp_node.appendChild(tmp_text_node) argument_list.append(tmp_node) # append the prepared argument nodes to the function element for arg in argument_list: fn.appendChild(arg) # append function element to the body element body.appendChild(fn) # append body element to envelope element envelope.appendChild(body) # append envelope element to document, making it the root element doc.appendChild(envelope) # our tree is ready, conver it to a string pure_xml = doc.toxml() # use the object returned by urlparse.urlparse to get the hostname and port conn = httplib.HTTPConnection(parsedurl.hostname, parsedurl.port) # use the path of WANIPConnection (or WANPPPConnection) to target that service, # insert the xml payload, # add two headers to make tell the server what we're sending exactly. conn.request('POST', parsedurl.path, pure_xml, {'SOAPAction': '"urn:schemas-upnp-org:service:WANIPConnection:1#AddPortMapping"', 'Content-Type': 'text/xml'} ) # wait for a response resp = conn.getresponse() return resp.status,resp.read()
def get_XSD(conf): xmlfile = Document() schema = xmlfile.createElementNS('xs','schema') schema.setAttributeNS('xmlns','xs','http://www.w3.org/2001/XMLSchema') schema.setAttribute("targetNamespace",'http://www.w3school.com.cn') schema.setAttribute('xmlns','http://www.w3school.com.cn') schema.setAttribute('elementFormDefault','qualified') xmlfile.appendChild(schema) root=xmlfile.createElementNS('xs','element') root.setAttribute('name','root ') complex = xmlfile.createElementNS('xs','complexType') schema.appendChild(root) root.appendChild(complex) information = xmlfile.createElementNS('xs','sequence') complex.appendChild(information) conffile=open(conf) father=None while len(elements): elements.pop() for line in conffile.readlines(): temp=line.split('=') for j in range(len(temp)): temp[j]=temp[j].strip() te = xmlfile.createElementNS('xs','element') te.setAttribute('name',temp[0]) elements.append(XMLE(temp[0],te)) if len(temp)>1: temp[0]=temp[1].split(';') for j in temp[0]: j=j.strip() if j == '': continue j=j.split(':') if j[0]=='type': if j[1]=='str': te.setAttribute('type','xs:string') elif j[1]=='int': te.setAttribute('type','xs:positiveInteger') elif j[0]=='fix': te.setAttribute('fixed',j[1]) elif j[0]=='maxo' : if j[1]!='INF': te.setAttribute("maxOccurs",j[1]) else: te.setAttribute("maxOccurs","unbounded") elif j[0]=='mino': te.setAttribute("maxOccurs",j[1]) elif j[0]=='father': father=serach_E_R(j[1]) if father == None: te.setAttribute('error','no father node named :%s' % j[1]) if father == None: information.appendChild(te) else: father.appendChild(te) father=None conffile.close() temp = conf.split('\\') f=open('%s.xsd' % temp[-1].split('.')[0] ,'w') xmlfile.writexml(f, "\t", "\t", "\n", "gbk") f.close()
def _prepare_response(): doc = Document() resp = doc.createElementNS('http://www.yale.edu/tp/cas', 'cas:serviceResponse') resp.setAttribute('xmlns:cas', 'http://www.yale.edu/tp/cas') # seriously minidom? doc.appendChild(resp) return (doc, resp)
def createFeed(examples): doc = Document() atomuri = "http://www.w3.org/2005/Atom" feed = doc.createElementNS(atomuri, "feed") feed.setAttribute("xmlns", atomuri) title = doc.createElementNS(atomuri, "title") title.appendChild(doc.createTextNode("procrastinatio.org's web mapping examples")) feed.appendChild(title) link = doc.createElementNS(atomuri, "link") link.setAttribute("rel", "self") link.setAttribute("href", feedPath + feedName) modtime = time.strftime("%Y-%m-%dT%I:%M:%SZ", time.gmtime()) id = doc.createElementNS(atomuri, "id") id.appendChild(doc.createTextNode("%s%s#%s" % (feedPath, feedName, modtime))) feed.appendChild(id) updated = doc.createElementNS(atomuri, "updated") updated.appendChild(doc.createTextNode(modtime)) feed.appendChild(updated) examples.sort(key=lambda x:x["modified"]) for example in sorted(examples, key=lambda x:x["modified"], reverse=True): entry = doc.createElementNS(atomuri, "entry") title = doc.createElementNS(atomuri, "title") title.appendChild(doc.createTextNode(example["title"] or example["example"])) entry.appendChild(title) tags = doc.createElementNS(atomuri, "tags") tags.appendChild(doc.createTextNode(example["tags"] or example["example"])) entry.appendChild(tags) link = doc.createElementNS(atomuri, "link") link.setAttribute("href", "%s%s" % (feedPath, example["example"])) entry.appendChild(link) summary = doc.createElementNS(atomuri, "summary") summary.appendChild(doc.createTextNode(example["shortdesc"] or example["example"])) entry.appendChild(summary) updated = doc.createElementNS(atomuri, "updated") updated.appendChild(doc.createTextNode(example["modified"])) entry.appendChild(updated) author = doc.createElementNS(atomuri, "author") name = doc.createElementNS(atomuri, "name") name.appendChild(doc.createTextNode(example["author"])) author.appendChild(name) entry.appendChild(author) id = doc.createElementNS(atomuri, "id") id.appendChild(doc.createTextNode("%s%s#%s" % (feedPath, example["example"], example["modified"]))) entry.appendChild(id) feed.appendChild(entry) doc.appendChild(feed) return doc
def add_port_mapping(self, local_ip): SSDP_ADDR = "239.255.255.250" SSDP_PORT = 1900 SSDP_MX = 2 SSDP_ST = "urn:schemas-upnp-org:device:InternetGatewayDevice:1" ssdpRequest = "M-SEARCH * HTTP/1.1\r\n" + \ "HOST: %s:%d\r\n" % (SSDP_ADDR, SSDP_PORT) + \ "MAN: \"ssdp:discover\"\r\n" + \ "MX: %d\r\n" % (SSDP_MX, ) + \ "ST: %s\r\n" % (SSDP_ST, ) + "\r\n" sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.sendto(str.encode(ssdpRequest), (SSDP_ADDR, SSDP_PORT)) resp = sock.recv(1000) import re from urllib import parse parsed = re.findall(r'(?P<name>.*?): (?P<value>.*?)\r\n', resp.decode('utf-8')) # get the location header location = list(filter(lambda x: x[0].lower() == "location", parsed)) # use the urlparse function to create an easy to use object to hold a URL router_path = parse.urlparse(location[0][1]) from urllib.request import urlopen from xml.dom.minidom import parseString # get the profile xml file and read it into a variable directory = urlopen(location[0][1]).read() # create a DOM object that represents the `directory` document dom = parseString(directory) # find all 'serviceType' elements service_types = dom.getElementsByTagName('serviceType') # iterate over service_types until we get either WANIPConnection # (this should also check for WANPPPConnection, which, if I remember correctly # exposed a similar SOAP interface on ADSL routers. for service in service_types: # I'm using the fact that a 'serviceType' element contains a single text node, who's data can # be accessed by the 'data' attribute. # When I find the right element, I take a step up into its parent and search for 'controlURL' if service.childNodes[0].data.find('WANIPConnection') > 0: path = str( service.parentNode.getElementsByTagName('controlURL') [0].childNodes[0].data) #path = service.parentNode.getElementsByTagName('controlURL')[0].childNodes[0].data) from xml.dom.minidom import Document doc = Document() # create the envelope element and set its attributes envelope = doc.createElementNS('', 's:Envelope') envelope.setAttribute('xmlns:s', 'http://schemas.xmlsoap.org/soap/envelope/') envelope.setAttribute('s:encodingStyle', 'http://schemas.xmlsoap.org/soap/encoding/') # create the body element body = doc.createElementNS('', 's:Body') # create the function element and set its attribute fn = doc.createElementNS('', 'u:AddPortMapping') fn.setAttribute('xmlns:u', 'urn:schemas-upnp-org:service:WANIPConnection:1') # setup the argument element names and values # using a list of tuples to preserve order arguments = [ ('NewRemoteHost', ''), ('NewExternalPort', '43210'), # specify port on router ('NewProtocol', 'TCP'), # specify protocol ('NewInternalPort', '43210'), # specify port on internal host ('NewInternalClient', local_ip), # specify IP of internal host ('NewEnabled', '1'), # turn mapping ON ('NewPortMappingDescription', 'Maneframe Tensorflow'), # add a description ('NewLeaseDuration', '0') ] # how long should it be opened? # NewEnabled should be 1 by default, but better supply it. # NewPortMappingDescription Can be anything you want, even an empty string. # NewLeaseDuration can be any integer BUT some UPnP devices don't support it, # so set it to 0 for better compatibility. # container for created nodes argument_list = [] # iterate over arguments, create nodes, create text nodes, # append text nodes to nodes, and finally add the ready product # to argument_list for k, v in arguments: tmp_node = doc.createElement(k) tmp_text_node = doc.createTextNode(v) tmp_node.appendChild(tmp_text_node) argument_list.append(tmp_node) # append the prepared argument nodes to the function element for arg in argument_list: fn.appendChild(arg) # append function element to the body element body.appendChild(fn) # append body element to envelope element envelope.appendChild(body) # append envelope element to document, making it the root element doc.appendChild(envelope) # our tree is ready, conver it to a string pure_xml = doc.toxml() import http.client # use the object returned by urlparse.urlparse to get the hostname and port print(pure_xml) conn = http.client.HTTPConnection(router_path.hostname, router_path.port) # use the path of WANIPConnection (or WANPPPConnection) to target that service, # insert the xml payload, # add two headers to make tell the server what we're sending exactly. conn.request( 'POST', path, pure_xml, { 'SOAPAction': '"urn:schemas-upnp-org:service:WANIPConnection:1#AddPortMapping"', 'Content-Type': 'text/xml' }) # wait for a response resp = conn.getresponse() # print the response status print(resp.status) # print the response body print(resp.read())