1# -*- coding: utf-8 -*-
2# Copyright (c) 2018, The MITRE Corporation. All rights reserved.
3# See LICENSE.txt for complete terms.
4
5import sys
6
7from mixbox.binding_utils import *
8
9class malwareMetaData(GeneratedsSuper):
10    """This is the top level element for the xml document. Required
11    attribute is version. Open issues: 2. Right way to express
12    commonality in field data so that it can be combined properly 3.
13    How to handle unicode in urls Change list 08/26/2011 Clean-file
14    attribute based changes 1. added digitalSignature to objects 2.
15    added softwarePackage to objects 3. added taggant to objects 4.
16    added numerous elements to fileObject 11/12/2009 1. adding
17    documentation across the schema 2. added partner to
18    OriginTypeEnum 3. made sha1 in fileObject optional 4. added
19    isDamaged as a propertyType 5. changed property name isNon-
20    replicating to isNonReplicating 6/11/2009 1. incremented version
21    2.Rename parents/children in relationship to source/target 3.
22    Add generic relationship, ‘relatedTo’ 4. Make commonality
23    element in fieldDataEntry optional 5. Add unknown element to
24    origintypeenum 6. Remove ipv4 and ipv6 from locationenum 7. Make
25    id on ip object startaddress-endaddress even if startaddress ==
26    endaddress. Added IPRange type 8. Add optional firstSeenDate to
27    fieldDataEntry, for first time entity providing data saw the
28    object 6/4/2009 1. File - id should be a xs:hexBinary 2. File -
29    extraHash should be a xs:string 3. Uri – add optional
30    ipProtocol field, with enumeration of values tcp/udp/icmp etc.
31    4. Uri – add documentation that protocol in uri needs to be
32    either from well known list (from iana.org) or ‘unknown’ 5.
33    Domain - need to fix documentation for domain – example is
34    wrong 6. registry – remove valuedata – it is in a property
35    7. ip object – rename to ip, and give it a start address and
36    end address. Share a single address by making start and end the
37    same. Id will be address or startaddress-endaddress 8. service
38    – delete – subsumed by uri with extra data elements in it 9.
39    classification – remove modifiers (attributes) on category and
40    put in properties 10. classification – add documentation that
41    category is companyname:category 11. objectProperty – move
42    timestamp to be top level instead of on each property and make
43    it required 12. relationship – make timestamp required 13.
44    relationship – add doc on runs. removed 'exploits' - it refers
45    to environment object that no longer exists 14. added comment
46    field to propertyenum 15. made timeStamp -> timestamp for
47    consistency 16.incremented version 5/31/2009 1. incremented
48    version 2. changed url to uri 3. removed environment object and
49    related enumerations 4. added restriction on uri to not allow a
50    question mark (?) 5/15/2009 1. incremented version 2. Added
51    neutral classification type 3. Added numberOfWebsitesHosting and
52    numberOfWebsitesRedirecting to volume units enumeration 4. added
53    referrer, operatingSystem, userAgent and browser to properties
54    5. made classification type attribute required 5/8/2009 1. added
55    new object type for asn 2. moved domain information to
56    properties, so that domains info can be timestamped 3. added
57    properties for geolocation of an ip address 4. added property
58    for location url for a file 5. added VolumeUnitsEnum and volume
59    tag in fieldData. This is to allow sharing of actual prevalence
60    numbers, with various units. 6. Added ipProtocol (tcp/udp) to
61    service object. Also changed names of expectedProtocol and
62    actualProtocol to be expectedApplicationProtocol and
63    actualApplicationProtocol 7. added 'references' surrounding tag
64    to ref tag in fieldDataEntry and objectProperty, so that can
65    assign multiple references if required 8. made id on file back
66    to hexBinary. Use length to figure out what hash it is. 9.
67    incremented version 10. added properties for httpMethod and
68    postData 11. added relationship types 'contactedBy' and
69    'downloadedFrom' 4/17/2009 1. Incremented version 2. Added
70    unwanted to ClassificationTypeEnum 3. Added text about ids for
71    files to documentation 4. Removed filename from file object
72    definition 5. Relaxed requirement on id of file to be an
73    xs:hexString to be an xs:string to allow e.g. md5:aaaaabbbbccc
74    as an id. Not enormously happy about that… 6. Made sha256
75    optional and sha1 required in files 7. Added “open issues”
76    section in documentation for top level element 8. Category is
77    now an xs:string; deleted CategoryTypeEnum 9. Added comment to
78    doc on fieldDataEntry about using standard time periods, but
79    kept start date and end date 10. Added objectProperties element,
80    and example illustratingProperties.xml. Currently allowed
81    properties are filename, filepath, registryValueData and
82    urlParameterString. There is an optional timestamp on each
83    property. I allowed objectProperty to have an id, so that it can
84    be referenced elsewhere, although we might want to re-think
85    that. 11. Added some better documentation to relationships 12.
86    Added more documentation throughout The version of the schema.
87    This is currently fixed to be 1.1. A required identifier for the
88    document."""
89    subclass = None
90    superclass = None
91    def __init__(self, version=None, id=None, company=None, author=None, comment=None, timestamp=None, objects=None, objectProperties=None, relationships=None, fieldData=None):
92        self.version = _cast(float, version)
93        self.id = _cast(None, id)
94        self.company = company
95        self.author = author
96        self.comment = comment
97        self.timestamp = timestamp
98        self.objects = objects
99        self.objectProperties = objectProperties
100        self.relationships = relationships
101        self.fieldData = fieldData
102    def factory(*args_, **kwargs_):
103        if malwareMetaData.subclass:
104            return malwareMetaData.subclass(*args_, **kwargs_)
105        else:
106            return malwareMetaData(*args_, **kwargs_)
107    factory = staticmethod(factory)
108    def get_company(self): return self.company
109    def set_company(self, company): self.company = company
110    def get_author(self): return self.author
111    def set_author(self, author): self.author = author
112    def get_comment(self): return self.comment
113    def set_comment(self, comment): self.comment = comment
114    def get_timestamp(self): return self.timestamp
115    def set_timestamp(self, timestamp): self.timestamp = timestamp
116    def get_objects(self): return self.objects
117    def set_objects(self, objects): self.objects = objects
118    def get_objectProperties(self): return self.objectProperties
119    def set_objectProperties(self, objectProperties): self.objectProperties = objectProperties
120    def get_relationships(self): return self.relationships
121    def set_relationships(self, relationships): self.relationships = relationships
122    def get_fieldData(self): return self.fieldData
123    def set_fieldData(self, fieldData): self.fieldData = fieldData
124    def get_version(self): return self.version
125    def set_version(self, version): self.version = version
126    def get_id(self): return self.id
127    def set_id(self, id): self.id = id
128    def export(self, write, level, namespace_='', name_='malwareMetaData', namespacedef_=''):
129        showIndent(write, level)
130        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
131        already_processed = []
132        self.exportAttributes(write, level, already_processed, namespace_, name_='malwareMetaData')
133        if self.hasContent_():
134            write('>\n')
135            self.exportChildren(write, level + 1, namespace_, name_)
136            showIndent(write, level)
137            write('</%s%s>\n' % (namespace_, name_))
138        else:
139            write('/>\n')
140    def exportAttributes(self, write, level, already_processed, namespace_='', name_='malwareMetaData'):
141        if self.version is not None and 'version' not in already_processed:
142            already_processed.append('version')
143            write(' version="%s"' % self.gds_format_float(self.version, input_name='version'))
144        if self.id is not None and 'id' not in already_processed:
145            already_processed.append('id')
146            write(' id=%s' % (quote_attrib(self.id)))
147    def exportChildren(self, write, level, namespace_='', name_='malwareMetaData', fromsubclass_=False):
148        if self.company is not None:
149            showIndent(write, level)
150            write('<%scompany>%s</%scompany>\n' % (namespace_, quote_xml(self.company), namespace_))
151        if self.author is not None:
152            showIndent(write, level)
153            write('<%sauthor>%s</%sauthor>\n' % (namespace_, quote_xml(self.author), namespace_))
154        if self.comment is not None:
155            showIndent(write, level)
156            write('<%scomment>%s</%scomment>\n' % (namespace_, quote_xml(self.comment), namespace_))
157        if self.timestamp is not None:
158            showIndent(write, level)
159            write('<%stimestamp>%s</%stimestamp>\n' % (namespace_, quote_xml(self.timestamp), namespace_))
160        if self.objects is not None:
161            self.objects.export(write, level, namespace_, name_='objects')
162        if self.objectProperties is not None:
163            self.objectProperties.export(write, level, namespace_, name_='objectProperties')
164        if self.relationships is not None:
165            self.relationships.export(write, level, namespace_, name_='relationships')
166        if self.fieldData is not None:
167            self.fieldData.export(write, level, namespace_, name_='fieldData')
168    def hasContent_(self):
169        if (
170            self.company is not None or
171            self.author is not None or
172            self.comment is not None or
173            self.timestamp is not None or
174            self.objects is not None or
175            self.objectProperties is not None or
176            self.relationships is not None or
177            self.fieldData is not None
178            ):
179            return True
180        else:
181            return False
182    def build(self, node):
183        self.__sourcenode__ = node
184        self.buildAttributes(node, node.attrib, [])
185        for child in node:
186            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
187            self.buildChildren(child, node, nodeName_)
188    def buildAttributes(self, node, attrs, already_processed):
189        value = find_attr_value_('version', node)
190        if value is not None and 'version' not in already_processed:
191            already_processed.append('version')
192            try:
193                self.version = float(value)
194            except ValueError as exp:
195                raise ValueError('Bad float/double attribute (version): %s' % exp)
196        value = find_attr_value_('id', node)
197        if value is not None and 'id' not in already_processed:
198            already_processed.append('id')
199            self.id = value
200    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
201        if nodeName_ == 'company':
202            company_ = child_.text
203            company_ = self.gds_validate_string(company_, node, 'company')
204            self.company = company_
205        elif nodeName_ == 'author':
206            author_ = child_.text
207            author_ = self.gds_validate_string(author_, node, 'author')
208            self.author = author_
209        elif nodeName_ == 'comment':
210            comment_ = child_.text
211            comment_ = self.gds_validate_string(comment_, node, 'comment')
212            self.comment = comment_
213        elif nodeName_ == 'timestamp':
214            timestamp_ = child_.text
215            timestamp_ = self.gds_validate_string(timestamp_, node, 'timestamp')
216            self.timestamp = timestamp_
217        elif nodeName_ == 'objects':
218            obj_ = objects.factory()
219            obj_.build(child_)
220            self.set_objects(obj_)
221        elif nodeName_ == 'objectProperties':
222            obj_ = objectProperties.factory()
223            obj_.build(child_)
224            self.set_objectProperties(obj_)
225        elif nodeName_ == 'relationships':
226            obj_ = relationships.factory()
227            obj_.build(child_)
228            self.set_relationships(obj_)
229        elif nodeName_ == 'fieldData':
230            obj_ = fieldData.factory()
231            obj_.build(child_)
232            self.set_fieldData(obj_)
233# end class malwareMetaData
234
235
236class objects(GeneratedsSuper):
237    """Objects are globally unique files, urls, domain, registry, ipAddress
238    etc. The data within the object is supporting data for the
239    globally unique object. For example, files have an id (by
240    convention the hash, sha256 if available, else weaker ones), and
241    the data for the file is the hashes, sizes etc. Urls have an id
242    (the url itself), and data which is simply the url parts broken
243    out. There are no dates, etc in the objects. These are first
244    class, global objects."""
245    subclass = None
246    superclass = None
247    def __init__(self, file=None, uri=None, domain=None, registry=None, ip=None, asn=None, entity=None, classification=None, softwarePackage=None, digitalSignature=None, taggant=None):
248        if file is None:
249            self.file = []
250        else:
251            self.file = file
252        if uri is None:
253            self.uri = []
254        else:
255            self.uri = uri
256        if domain is None:
257            self.domain = []
258        else:
259            self.domain = domain
260        if registry is None:
261            self.registry = []
262        else:
263            self.registry = registry
264        if ip is None:
265            self.ip = []
266        else:
267            self.ip = ip
268        if asn is None:
269            self.asn = []
270        else:
271            self.asn = asn
272        if entity is None:
273            self.entity = []
274        else:
275            self.entity = entity
276        if classification is None:
277            self.classification = []
278        else:
279            self.classification = classification
280        if softwarePackage is None:
281            self.softwarePackage = []
282        else:
283            self.softwarePackage = softwarePackage
284        if digitalSignature is None:
285            self.digitalSignature = []
286        else:
287            self.digitalSignature = digitalSignature
288        if taggant is None:
289            self.taggant = []
290        else:
291            self.taggant = taggant
292    def factory(*args_, **kwargs_):
293        if objects.subclass:
294            return objects.subclass(*args_, **kwargs_)
295        else:
296            return objects(*args_, **kwargs_)
297    factory = staticmethod(factory)
298    def get_file(self): return self.file
299    def set_file(self, file): self.file = file
300    def add_file(self, value): self.file.append(value)
301    def insert_file(self, index, value): self.file[index] = value
302    def get_uri(self): return self.uri
303    def set_uri(self, uri): self.uri = uri
304    def add_uri(self, value): self.uri.append(value)
305    def insert_uri(self, index, value): self.uri[index] = value
306    def get_domain(self): return self.domain
307    def set_domain(self, domain): self.domain = domain
308    def add_domain(self, value): self.domain.append(value)
309    def insert_domain(self, index, value): self.domain[index] = value
310    def get_registry(self): return self.registry
311    def set_registry(self, registry): self.registry = registry
312    def add_registry(self, value): self.registry.append(value)
313    def insert_registry(self, index, value): self.registry[index] = value
314    def get_ip(self): return self.ip
315    def set_ip(self, ip): self.ip = ip
316    def add_ip(self, value): self.ip.append(value)
317    def insert_ip(self, index, value): self.ip[index] = value
318    def get_asn(self): return self.asn
319    def set_asn(self, asn): self.asn = asn
320    def add_asn(self, value): self.asn.append(value)
321    def insert_asn(self, index, value): self.asn[index] = value
322    def get_entity(self): return self.entity
323    def set_entity(self, entity): self.entity = entity
324    def add_entity(self, value): self.entity.append(value)
325    def insert_entity(self, index, value): self.entity[index] = value
326    def get_classification(self): return self.classification
327    def set_classification(self, classification): self.classification = classification
328    def add_classification(self, value): self.classification.append(value)
329    def insert_classification(self, index, value): self.classification[index] = value
330    def get_softwarePackage(self): return self.softwarePackage
331    def set_softwarePackage(self, softwarePackage): self.softwarePackage = softwarePackage
332    def add_softwarePackage(self, value): self.softwarePackage.append(value)
333    def insert_softwarePackage(self, index, value): self.softwarePackage[index] = value
334    def get_digitalSignature(self): return self.digitalSignature
335    def set_digitalSignature(self, digitalSignature): self.digitalSignature = digitalSignature
336    def add_digitalSignature(self, value): self.digitalSignature.append(value)
337    def insert_digitalSignature(self, index, value): self.digitalSignature[index] = value
338    def get_taggant(self): return self.taggant
339    def set_taggant(self, taggant): self.taggant = taggant
340    def add_taggant(self, value): self.taggant.append(value)
341    def insert_taggant(self, index, value): self.taggant[index] = value
342    def export(self, write, level, namespace_='', name_='objects', namespacedef_=''):
343        showIndent(write, level)
344        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
345        already_processed = []
346        self.exportAttributes(write, level, already_processed, namespace_, name_='objects')
347        if self.hasContent_():
348            write('>\n')
349            self.exportChildren(write, level + 1, namespace_, name_)
350            showIndent(write, level)
351            write('</%s%s>\n' % (namespace_, name_))
352        else:
353            write('/>\n')
354    def exportAttributes(self, write, level, already_processed, namespace_='', name_='objects'):
355        pass
356    def exportChildren(self, write, level, namespace_='', name_='objects', fromsubclass_=False):
357        for file_ in self.file:
358            file_.export(write, level, namespace_, name_='file')
359        for uri_ in self.uri:
360            uri_.export(write, level, namespace_, name_='uri')
361        for domain_ in self.domain:
362            domain_.export(write, level, namespace_, name_='domain')
363        for registry_ in self.registry:
364            registry_.export(write, level, namespace_, name_='registry')
365        for ip_ in self.ip:
366            ip_.export(write, level, namespace_, name_='ip')
367        for asn_ in self.asn:
368            asn_.export(write, level, namespace_, name_='asn')
369        for entity_ in self.entity:
370            entity_.export(write, level, namespace_, name_='entity')
371        for classification_ in self.classification:
372            classification_.export(write, level, namespace_, name_='classification')
373        for softwarePackage_ in self.softwarePackage:
374            softwarePackage_.export(write, level, namespace_, name_='softwarePackage')
375        for digitalSignature_ in self.digitalSignature:
376            digitalSignature_.export(write, level, namespace_, name_='digitalSignature')
377        for taggant_ in self.taggant:
378            taggant_.export(write, level, namespace_, name_='taggant')
379    def hasContent_(self):
380        if (
381            self.file or
382            self.uri or
383            self.domain or
384            self.registry or
385            self.ip or
386            self.asn or
387            self.entity or
388            self.classification or
389            self.softwarePackage or
390            self.digitalSignature or
391            self.taggant
392            ):
393            return True
394        else:
395            return False
396    def build(self, node):
397        self.__sourcenode__ = node
398        self.buildAttributes(node, node.attrib, [])
399        for child in node:
400            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
401            self.buildChildren(child, node, nodeName_)
402    def buildAttributes(self, node, attrs, already_processed):
403        pass
404    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
405        if nodeName_ == 'file':
406            obj_ = fileObject.factory()
407            obj_.build(child_)
408            self.file.append(obj_)
409        elif nodeName_ == 'uri':
410            obj_ = uriObject.factory()
411            obj_.build(child_)
412            self.uri.append(obj_)
413        elif nodeName_ == 'domain':
414            obj_ = domainObject.factory()
415            obj_.build(child_)
416            self.domain.append(obj_)
417        elif nodeName_ == 'registry':
418            obj_ = registryObject.factory()
419            obj_.build(child_)
420            self.registry.append(obj_)
421        elif nodeName_ == 'ip':
422            obj_ = IPObject.factory()
423            obj_.build(child_)
424            self.ip.append(obj_)
425        elif nodeName_ == 'asn':
426            obj_ = ASNObject.factory()
427            obj_.build(child_)
428            self.asn.append(obj_)
429        elif nodeName_ == 'entity':
430            obj_ = entityObject.factory()
431            obj_.build(child_)
432            self.entity.append(obj_)
433        elif nodeName_ == 'classification':
434            obj_ = classificationObject.factory()
435            obj_.build(child_)
436            self.classification.append(obj_)
437        elif nodeName_ == 'softwarePackage':
438            obj_ = softwarePackageObject.factory()
439            obj_.build(child_)
440            self.softwarePackage.append(obj_)
441        elif nodeName_ == 'digitalSignature':
442            obj_ = digitalSignatureObject.factory()
443            obj_.build(child_)
444            self.digitalSignature.append(obj_)
445        elif nodeName_ == 'taggant':
446            obj_ = taggantObject.factory()
447            obj_.build(child_)
448            self.taggant.append(obj_)
449# end class objects
450
451
452class objectProperties(GeneratedsSuper):
453    """Properties of objects that do not make sense as relationships. e.g.
454    file names, url parameter strings, registry value data."""
455    subclass = None
456    superclass = None
457    def __init__(self, objectProperty=None):
458        if objectProperty is None:
459            self.objectProperty = []
460        else:
461            self.objectProperty = objectProperty
462    def factory(*args_, **kwargs_):
463        if objectProperties.subclass:
464            return objectProperties.subclass(*args_, **kwargs_)
465        else:
466            return objectProperties(*args_, **kwargs_)
467    factory = staticmethod(factory)
468    def get_objectProperty(self): return self.objectProperty
469    def set_objectProperty(self, objectProperty): self.objectProperty = objectProperty
470    def add_objectProperty(self, value): self.objectProperty.append(value)
471    def insert_objectProperty(self, index, value): self.objectProperty[index] = value
472    def export(self, write, level, namespace_='', name_='objectProperties', namespacedef_=''):
473        showIndent(write, level)
474        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
475        already_processed = []
476        self.exportAttributes(write, level, already_processed, namespace_, name_='objectProperties')
477        if self.hasContent_():
478            write('>\n')
479            self.exportChildren(write, level + 1, namespace_, name_)
480            showIndent(write, level)
481            write('</%s%s>\n' % (namespace_, name_))
482        else:
483            write('/>\n')
484    def exportAttributes(self, write, level, already_processed, namespace_='', name_='objectProperties'):
485        pass
486    def exportChildren(self, write, level, namespace_='', name_='objectProperties', fromsubclass_=False):
487        for objectProperty_ in self.objectProperty:
488            objectProperty_.export(write, level, namespace_, name_='objectProperty')
489    def hasContent_(self):
490        if (
491            self.objectProperty
492            ):
493            return True
494        else:
495            return False
496    def build(self, node):
497        self.__sourcenode__ = node
498        self.buildAttributes(node, node.attrib, [])
499        for child in node:
500            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
501            self.buildChildren(child, node, nodeName_)
502    def buildAttributes(self, node, attrs, already_processed):
503        pass
504    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
505        if nodeName_ == 'objectProperty':
506            obj_ = objectProperty.factory()
507            obj_.build(child_)
508            self.objectProperty.append(obj_)
509# end class objectProperties
510
511
512class relationships(GeneratedsSuper):
513    """Relationships between objects."""
514    subclass = None
515    superclass = None
516    def __init__(self, relationship=None):
517        if relationship is None:
518            self.relationship = []
519        else:
520            self.relationship = relationship
521    def factory(*args_, **kwargs_):
522        if relationships.subclass:
523            return relationships.subclass(*args_, **kwargs_)
524        else:
525            return relationships(*args_, **kwargs_)
526    factory = staticmethod(factory)
527    def get_relationship(self): return self.relationship
528    def set_relationship(self, relationship): self.relationship = relationship
529    def add_relationship(self, value): self.relationship.append(value)
530    def insert_relationship(self, index, value): self.relationship[index] = value
531    def export(self, write, level, namespace_='', name_='relationships', namespacedef_=''):
532        showIndent(write, level)
533        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
534        already_processed = []
535        self.exportAttributes(write, level, already_processed, namespace_, name_='relationships')
536        if self.hasContent_():
537            write('>\n')
538            self.exportChildren(write, level + 1, namespace_, name_)
539            showIndent(write, level)
540            write('</%s%s>\n' % (namespace_, name_))
541        else:
542            write('/>\n')
543    def exportAttributes(self, write, level, already_processed, namespace_='', name_='relationships'):
544        pass
545    def exportChildren(self, write, level, namespace_='', name_='relationships', fromsubclass_=False):
546        for relationship_ in self.relationship:
547            relationship_.export(write, level, namespace_, name_='relationship')
548    def hasContent_(self):
549        if (
550            self.relationship
551            ):
552            return True
553        else:
554            return False
555    def build(self, node):
556        self.__sourcenode__ = node
557        self.buildAttributes(node, node.attrib, [])
558        for child in node:
559            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
560            self.buildChildren(child, node, nodeName_)
561    def buildAttributes(self, node, attrs, already_processed):
562        pass
563    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
564        if nodeName_ == 'relationship':
565            obj_ = relationship.factory()
566            obj_.build(child_)
567            self.relationship.append(obj_)
568# end class relationships
569
570
571class fieldData(GeneratedsSuper):
572    """Prevalence data."""
573    subclass = None
574    superclass = None
575    def __init__(self, fieldDataEntry=None):
576        if fieldDataEntry is None:
577            self.fieldDataEntry = []
578        else:
579            self.fieldDataEntry = fieldDataEntry
580    def factory(*args_, **kwargs_):
581        if fieldData.subclass:
582            return fieldData.subclass(*args_, **kwargs_)
583        else:
584            return fieldData(*args_, **kwargs_)
585    factory = staticmethod(factory)
586    def get_fieldDataEntry(self): return self.fieldDataEntry
587    def set_fieldDataEntry(self, fieldDataEntry): self.fieldDataEntry = fieldDataEntry
588    def add_fieldDataEntry(self, value): self.fieldDataEntry.append(value)
589    def insert_fieldDataEntry(self, index, value): self.fieldDataEntry[index] = value
590    def export(self, write, level, namespace_='', name_='fieldData', namespacedef_=''):
591        showIndent(write, level)
592        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
593        already_processed = []
594        self.exportAttributes(write, level, already_processed, namespace_, name_='fieldData')
595        if self.hasContent_():
596            write('>\n')
597            self.exportChildren(write, level + 1, namespace_, name_)
598            showIndent(write, level)
599            write('</%s%s>\n' % (namespace_, name_))
600        else:
601            write('/>\n')
602    def exportAttributes(self, write, level, already_processed, namespace_='', name_='fieldData'):
603        pass
604    def exportChildren(self, write, level, namespace_='', name_='fieldData', fromsubclass_=False):
605        for fieldDataEntry_ in self.fieldDataEntry:
606            fieldDataEntry_.export(write, level, namespace_, name_='fieldDataEntry')
607    def hasContent_(self):
608        if (
609            self.fieldDataEntry
610            ):
611            return True
612        else:
613            return False
614    def build(self, node):
615        self.__sourcenode__ = node
616        self.buildAttributes(node, node.attrib, [])
617        for child in node:
618            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
619            self.buildChildren(child, node, nodeName_)
620    def buildAttributes(self, node, attrs, already_processed):
621        pass
622    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
623        if nodeName_ == 'fieldDataEntry':
624            obj_ = fieldDataEntry.factory()
625            obj_.build(child_)
626            self.fieldDataEntry.append(obj_)
627# end class fieldData
628
629
630class fileObject(GeneratedsSuper):
631    """Object definition for files. The required attribute is the id, which
632    needs to be globally unique. By convention, the value used is a
633    hash, the stronger the better. The choice should be: use sha256
634    if you have it, if not use sha1, if not use md5. Other hashes
635    and file sizes are recorded in the elements. File names are put
636    in as properties."""
637    subclass = None
638    superclass = None
639    def __init__(self, id=None, md5=None, sha1=None, sha256=None, sha512=None, size=None, crc32=None, fileType=None, extraHash=None, filename=None, normalizedNativePath=None, filenameWithinInstaller=None, folderWithinInstaller=None, vendor=None, internalName=None, language=None, productName=None, fileVersion=None, productVersion=None, developmentEnvironment=None, checksum=None, architecture=None, buildTimeDateStamp=None, compilerVersion=None, linkerVersion=None, minOSVersionCPE=None, numberOfSections=None, MIMEType=None, requiredPrivilege=None, digitalSignature=None, taggant=None):
640        self.id = _cast(None, id)
641        self.md5 = md5
642        self.sha1 = sha1
643        self.sha256 = sha256
644        self.sha512 = sha512
645        self.size = size
646        self.crc32 = crc32
647        if fileType is None:
648            self.fileType = []
649        else:
650            self.fileType = fileType
651        if extraHash is None:
652            self.extraHash = []
653        else:
654            self.extraHash = extraHash
655        if filename is None:
656            self.filename = []
657        else:
658            self.filename = filename
659        if normalizedNativePath is None:
660            self.normalizedNativePath = []
661        else:
662            self.normalizedNativePath = normalizedNativePath
663        if filenameWithinInstaller is None:
664            self.filenameWithinInstaller = []
665        else:
666            self.filenameWithinInstaller = filenameWithinInstaller
667        if folderWithinInstaller is None:
668            self.folderWithinInstaller = []
669        else:
670            self.folderWithinInstaller = folderWithinInstaller
671        self.vendor = vendor
672        if internalName is None:
673            self.internalName = []
674        else:
675            self.internalName = internalName
676        if language is None:
677            self.language = []
678        else:
679            self.language = language
680        self.productName = productName
681        self.fileVersion = fileVersion
682        self.productVersion = productVersion
683        self.developmentEnvironment = developmentEnvironment
684        self.checksum = checksum
685        self.architecture = architecture
686        self.buildTimeDateStamp = buildTimeDateStamp
687        self.compilerVersion = compilerVersion
688        self.linkerVersion = linkerVersion
689        self.minOSVersionCPE = minOSVersionCPE
690        self.numberOfSections = numberOfSections
691        self.MIMEType = MIMEType
692        self.requiredPrivilege = requiredPrivilege
693        self.digitalSignature = digitalSignature
694        self.taggant = taggant
695    def factory(*args_, **kwargs_):
696        if fileObject.subclass:
697            return fileObject.subclass(*args_, **kwargs_)
698        else:
699            return fileObject(*args_, **kwargs_)
700    factory = staticmethod(factory)
701    def get_md5(self): return self.md5
702    def set_md5(self, md5): self.md5 = md5
703    def get_sha1(self): return self.sha1
704    def set_sha1(self, sha1): self.sha1 = sha1
705    def get_sha256(self): return self.sha256
706    def set_sha256(self, sha256): self.sha256 = sha256
707    def get_sha512(self): return self.sha512
708    def set_sha512(self, sha512): self.sha512 = sha512
709    def get_size(self): return self.size
710    def set_size(self, size): self.size = size
711    def get_crc32(self): return self.crc32
712    def set_crc32(self, crc32): self.crc32 = crc32
713    def get_fileType(self): return self.fileType
714    def set_fileType(self, fileType): self.fileType = fileType
715    def add_fileType(self, value): self.fileType.append(value)
716    def insert_fileType(self, index, value): self.fileType[index] = value
717    def get_extraHash(self): return self.extraHash
718    def set_extraHash(self, extraHash): self.extraHash = extraHash
719    def add_extraHash(self, value): self.extraHash.append(value)
720    def insert_extraHash(self, index, value): self.extraHash[index] = value
721    def get_filename(self): return self.filename
722    def set_filename(self, filename): self.filename = filename
723    def add_filename(self, value): self.filename.append(value)
724    def insert_filename(self, index, value): self.filename[index] = value
725    def get_normalizedNativePath(self): return self.normalizedNativePath
726    def set_normalizedNativePath(self, normalizedNativePath): self.normalizedNativePath = normalizedNativePath
727    def add_normalizedNativePath(self, value): self.normalizedNativePath.append(value)
728    def insert_normalizedNativePath(self, index, value): self.normalizedNativePath[index] = value
729    def get_filenameWithinInstaller(self): return self.filenameWithinInstaller
730    def set_filenameWithinInstaller(self, filenameWithinInstaller): self.filenameWithinInstaller = filenameWithinInstaller
731    def add_filenameWithinInstaller(self, value): self.filenameWithinInstaller.append(value)
732    def insert_filenameWithinInstaller(self, index, value): self.filenameWithinInstaller[index] = value
733    def get_folderWithinInstaller(self): return self.folderWithinInstaller
734    def set_folderWithinInstaller(self, folderWithinInstaller): self.folderWithinInstaller = folderWithinInstaller
735    def add_folderWithinInstaller(self, value): self.folderWithinInstaller.append(value)
736    def insert_folderWithinInstaller(self, index, value): self.folderWithinInstaller[index] = value
737    def get_vendor(self): return self.vendor
738    def set_vendor(self, vendor): self.vendor = vendor
739    def get_internalName(self): return self.internalName
740    def set_internalName(self, internalName): self.internalName = internalName
741    def add_internalName(self, value): self.internalName.append(value)
742    def insert_internalName(self, index, value): self.internalName[index] = value
743    def get_language(self): return self.language
744    def set_language(self, language): self.language = language
745    def add_language(self, value): self.language.append(value)
746    def insert_language(self, index, value): self.language[index] = value
747    def get_productName(self): return self.productName
748    def set_productName(self, productName): self.productName = productName
749    def get_fileVersion(self): return self.fileVersion
750    def set_fileVersion(self, fileVersion): self.fileVersion = fileVersion
751    def get_productVersion(self): return self.productVersion
752    def set_productVersion(self, productVersion): self.productVersion = productVersion
753    def get_developmentEnvironment(self): return self.developmentEnvironment
754    def set_developmentEnvironment(self, developmentEnvironment): self.developmentEnvironment = developmentEnvironment
755    def get_checksum(self): return self.checksum
756    def set_checksum(self, checksum): self.checksum = checksum
757    def get_architecture(self): return self.architecture
758    def set_architecture(self, architecture): self.architecture = architecture
759    def get_buildTimeDateStamp(self): return self.buildTimeDateStamp
760    def set_buildTimeDateStamp(self, buildTimeDateStamp): self.buildTimeDateStamp = buildTimeDateStamp
761    def get_compilerVersion(self): return self.compilerVersion
762    def set_compilerVersion(self, compilerVersion): self.compilerVersion = compilerVersion
763    def get_linkerVersion(self): return self.linkerVersion
764    def set_linkerVersion(self, linkerVersion): self.linkerVersion = linkerVersion
765    def get_minOSVersionCPE(self): return self.minOSVersionCPE
766    def set_minOSVersionCPE(self, minOSVersionCPE): self.minOSVersionCPE = minOSVersionCPE
767    def get_numberOfSections(self): return self.numberOfSections
768    def set_numberOfSections(self, numberOfSections): self.numberOfSections = numberOfSections
769    def get_MIMEType(self): return self.MIMEType
770    def set_MIMEType(self, MIMEType): self.MIMEType = MIMEType
771    def get_requiredPrivilege(self): return self.requiredPrivilege
772    def set_requiredPrivilege(self, requiredPrivilege): self.requiredPrivilege = requiredPrivilege
773    def get_digitalSignature(self): return self.digitalSignature
774    def set_digitalSignature(self, digitalSignature): self.digitalSignature = digitalSignature
775    def get_taggant(self): return self.taggant
776    def set_taggant(self, taggant): self.taggant = taggant
777    def get_id(self): return self.id
778    def set_id(self, id): self.id = id
779    def export(self, write, level, namespace_='', name_='fileObject', namespacedef_=''):
780        showIndent(write, level)
781        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
782        already_processed = []
783        self.exportAttributes(write, level, already_processed, namespace_, name_='fileObject')
784        if self.hasContent_():
785            write('>\n')
786            self.exportChildren(write, level + 1, namespace_, name_)
787            showIndent(write, level)
788            write('</%s%s>\n' % (namespace_, name_))
789        else:
790            write('/>\n')
791    def exportAttributes(self, write, level, already_processed, namespace_='', name_='fileObject'):
792        if self.id is not None and 'id' not in already_processed:
793            already_processed.append('id')
794            write(' id=%s' % (quote_attrib(self.id), ))
795    def exportChildren(self, write, level, namespace_='', name_='fileObject', fromsubclass_=False):
796        if self.md5 is not None:
797            self.md5.export(write, level, namespace_, name_='md5', )
798        if self.sha1 is not None:
799            self.sha1.export(write, level, namespace_, name_='sha1')
800        if self.sha256 is not None:
801            self.sha256.export(write, level, namespace_, name_='sha256')
802        if self.sha512 is not None:
803            self.sha512.export(write, level, namespace_, name_='sha512')
804        if self.size is not None:
805            showIndent(write, level)
806            write('<%ssize>%s</%ssize>\n' % (namespace_, self.gds_format_integer(self.size, input_name='size'), namespace_))
807        if self.crc32 is not None:
808            showIndent(write, level)
809            write('<%scrc32>%s</%scrc32>\n' % (namespace_, quote_xml(self.crc32), namespace_))
810        for fileType_ in self.fileType:
811            showIndent(write, level)
812            write('<%sfileType>%s</%sfileType>\n' % (namespace_, quote_xml(fileType_), namespace_))
813        for extraHash_ in self.extraHash:
814            extraHash_.export(write, level, namespace_, name_='extraHash')
815        for filename_ in self.filename:
816            showIndent(write, level)
817            write('<%sfilename>%s</%sfilename>\n' % (namespace_, quote_xml(filename_), namespace_))
818        for normalizedNativePath_ in self.normalizedNativePath:
819            showIndent(write, level)
820            write('<%snormalizedNativePath>%s</%snormalizedNativePath>\n' % (namespace_, quote_xml(normalizedNativePath_), namespace_))
821        for filenameWithinInstaller_ in self.filenameWithinInstaller:
822            showIndent(write, level)
823            write('<%sfilenameWithinInstaller>%s</%sfilenameWithinInstaller>\n' % (namespace_, quote_xml(filenameWithinInstaller_), namespace_))
824        for folderWithinInstaller_ in self.folderWithinInstaller:
825            showIndent(write, level)
826            write('<%sfolderWithinInstaller>%s</%sfolderWithinInstaller>\n' % (namespace_, quote_xml(folderWithinInstaller_), namespace_))
827        if self.vendor is not None:
828            showIndent(write, level)
829            write('<%svendor>%s</%svendor>\n' % (namespace_, quote_xml(self.vendor), namespace_))
830        for internalName_ in self.internalName:
831            showIndent(write, level)
832            write('<%sinternalName>%s</%sinternalName>\n' % (namespace_, quote_xml(internalName_), namespace_))
833        for language_ in self.language:
834            showIndent(write, level)
835            write('<%slanguage>%s</%slanguage>\n' % (namespace_, quote_xml(language_), namespace_))
836        if self.productName is not None:
837            showIndent(write, level)
838            write('<%sproductName>%s</%sproductName>\n' % (namespace_, quote_xml(self.productName), namespace_))
839        if self.fileVersion is not None:
840            showIndent(write, level)
841            write('<%sfileVersion>%s</%sfileVersion>\n' % (namespace_, quote_xml(self.fileVersion), namespace_))
842        if self.productVersion is not None:
843            showIndent(write, level)
844            write('<%sproductVersion>%s</%sproductVersion>\n' % (namespace_, quote_xml(self.productVersion), namespace_))
845        if self.developmentEnvironment is not None:
846            showIndent(write, level)
847            write('<%sdevelopmentEnvironment>%s</%sdevelopmentEnvironment>\n' % (namespace_, quote_xml(self.developmentEnvironment), namespace_))
848        if self.checksum is not None:
849            self.checksum.export(write, level, namespace_, name_='checksum')
850        if self.architecture is not None:
851            showIndent(write, level)
852            write('<%sarchitecture>%s</%sarchitecture>\n' % (namespace_, quote_xml(self.architecture), namespace_))
853        if self.buildTimeDateStamp is not None:
854            showIndent(write, level)
855            write('<%sbuildTimeDateStamp>%s</%sbuildTimeDateStamp>\n' % (namespace_, quote_xml(self.buildTimeDateStamp), namespace_))
856        if self.compilerVersion is not None:
857            showIndent(write, level)
858            write('<%scompilerVersion>%s</%scompilerVersion>\n' % (namespace_, quote_xml(self.compilerVersion), namespace_))
859        if self.linkerVersion is not None:
860            showIndent(write, level)
861            write('<%slinkerVersion>%s</%slinkerVersion>\n' % (namespace_, self.gds_format_float(self.linkerVersion, input_name='linkerVersion'), namespace_))
862        if self.minOSVersionCPE is not None:
863            showIndent(write, level)
864            write('<%sminOSVersionCPE>%s</%sminOSVersionCPE>\n' % (namespace_, quote_xml(self.minOSVersionCPE), namespace_))
865        if self.numberOfSections is not None:
866            showIndent(write, level)
867            write('<%snumberOfSections>%s</%snumberOfSections>\n' % (namespace_, self.gds_format_integer(self.numberOfSections, input_name='numberOfSections'), namespace_))
868        if self.MIMEType is not None:
869            showIndent(write, level)
870            write('<%sMIMEType>%s</%sMIMEType>\n' % (namespace_, quote_xml(self.MIMEType), namespace_))
871        if self.requiredPrivilege is not None:
872            showIndent(write, level)
873            write('<%srequiredPrivilege>%s</%srequiredPrivilege>\n' % (namespace_, quote_xml(self.requiredPrivilege), namespace_))
874        if self.digitalSignature is not None:
875            self.digitalSignature.export(write, level, namespace_, name_='digitalSignature')
876        if self.taggant is not None:
877            self.taggant.export(write, level, namespace_, name_='taggant')
878    def hasContent_(self):
879        if (
880            self.md5 is not None or
881            self.sha1 is not None or
882            self.sha256 is not None or
883            self.sha512 is not None or
884            self.size is not None or
885            self.crc32 is not None or
886            self.fileType or
887            self.extraHash or
888            self.filename or
889            self.normalizedNativePath or
890            self.filenameWithinInstaller or
891            self.folderWithinInstaller or
892            self.vendor is not None or
893            self.internalName or
894            self.language or
895            self.productName is not None or
896            self.fileVersion is not None or
897            self.productVersion is not None or
898            self.developmentEnvironment is not None or
899            self.checksum is not None or
900            self.architecture is not None or
901            self.buildTimeDateStamp is not None or
902            self.compilerVersion is not None or
903            self.linkerVersion is not None or
904            self.minOSVersionCPE is not None or
905            self.numberOfSections is not None or
906            self.MIMEType is not None or
907            self.requiredPrivilege is not None or
908            self.digitalSignature is not None or
909            self.taggant is not None
910            ):
911            return True
912        else:
913            return False
914    def build(self, node):
915        self.__sourcenode__ = node
916        self.buildAttributes(node, node.attrib, [])
917        for child in node:
918            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
919            self.buildChildren(child, node, nodeName_)
920    def buildAttributes(self, node, attrs, already_processed):
921        value = find_attr_value_('id', node)
922        if value is not None and 'id' not in already_processed:
923            already_processed.append('id')
924            self.id = value
925    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
926        if nodeName_ == 'md5':
927            obj_ = xs_hexBinary.factory()
928            obj_.build(child_)
929            self.set_md5(obj_)
930        elif nodeName_ == 'sha1':
931            obj_ = xs_hexBinary.factory()
932            obj_.build(child_)
933            self.set_sha1(obj_)
934        elif nodeName_ == 'sha256':
935            obj_ = xs_hexBinary.factory()
936            obj_.build(child_)
937            self.set_sha256(obj_)
938        elif nodeName_ == 'sha512':
939            obj_ = xs_hexBinary.factory()
940            obj_.build(child_)
941            self.set_sha512(obj_)
942        elif nodeName_ == 'size':
943            sval_ = child_.text
944            try:
945                ival_ = int(sval_)
946            except (TypeError, ValueError) as exp:
947                raise_parse_error(child_, 'requires integer: %s' % exp)
948            ival_ = self.gds_validate_integer(ival_, node, 'size')
949            self.size = ival_
950        elif nodeName_ == 'crc32':
951            crc32_ = child_.text
952            crc32_ = self.gds_validate_string(crc32_, node, 'crc32')
953            self.crc32 = crc32_
954        elif nodeName_ == 'fileType':
955            fileType_ = child_.text
956            fileType_ = self.gds_validate_string(fileType_, node, 'fileType')
957            self.fileType.append(fileType_)
958        elif nodeName_ == 'extraHash':
959            obj_ = extraHash.factory()
960            obj_.build(child_)
961            self.extraHash.append(obj_)
962        elif nodeName_ == 'filename':
963            filename_ = child_.text
964            filename_ = self.gds_validate_string(filename_, node, 'filename')
965            self.filename.append(filename_)
966        elif nodeName_ == 'normalizedNativePath':
967            normalizedNativePath_ = child_.text
968            normalizedNativePath_ = self.gds_validate_string(normalizedNativePath_, node, 'normalizedNativePath')
969            self.normalizedNativePath.append(normalizedNativePath_)
970        elif nodeName_ == 'filenameWithinInstaller':
971            filenameWithinInstaller_ = child_.text
972            filenameWithinInstaller_ = self.gds_validate_string(filenameWithinInstaller_, node, 'filenameWithinInstaller')
973            self.filenameWithinInstaller.append(filenameWithinInstaller_)
974        elif nodeName_ == 'folderWithinInstaller':
975            folderWithinInstaller_ = child_.text
976            folderWithinInstaller_ = self.gds_validate_string(folderWithinInstaller_, node, 'folderWithinInstaller')
977            self.folderWithinInstaller.append(folderWithinInstaller_)
978        elif nodeName_ == 'vendor':
979            vendor_ = child_.text
980            vendor_ = self.gds_validate_string(vendor_, node, 'vendor')
981            self.vendor = vendor_
982        elif nodeName_ == 'internalName':
983            internalName_ = child_.text
984            internalName_ = self.gds_validate_string(internalName_, node, 'internalName')
985            self.internalName.append(internalName_)
986        elif nodeName_ == 'language':
987            language_ = child_.text
988            language_ = self.gds_validate_string(language_, node, 'language')
989            self.language.append(language_)
990        elif nodeName_ == 'productName':
991            productName_ = child_.text
992            productName_ = self.gds_validate_string(productName_, node, 'productName')
993            self.productName = productName_
994        elif nodeName_ == 'fileVersion':
995            fileVersion_ = child_.text
996            fileVersion_ = self.gds_validate_string(fileVersion_, node, 'fileVersion')
997            self.fileVersion = fileVersion_
998        elif nodeName_ == 'productVersion':
999            productVersion_ = child_.text
1000            productVersion_ = self.gds_validate_string(productVersion_, node, 'productVersion')
1001            self.productVersion = productVersion_
1002        elif nodeName_ == 'developmentEnvironment':
1003            developmentEnvironment_ = child_.text
1004            developmentEnvironment_ = self.gds_validate_string(developmentEnvironment_, node, 'developmentEnvironment')
1005            self.developmentEnvironment = developmentEnvironment_
1006        elif nodeName_ == 'checksum':
1007            obj_ = xs_hexBinary.factory()
1008            obj_.build(child_)
1009            self.set_checksum(obj_)
1010        elif nodeName_ == 'architecture':
1011            architecture_ = child_.text
1012            architecture_ = self.gds_validate_string(architecture_, node, 'architecture')
1013            self.architecture = architecture_
1014        elif nodeName_ == 'buildTimeDateStamp':
1015            buildTimeDateStamp_ = child_.text
1016            buildTimeDateStamp_ = self.gds_validate_string(buildTimeDateStamp_, node, 'buildTimeDateStamp')
1017            self.buildTimeDateStamp = buildTimeDateStamp_
1018        elif nodeName_ == 'compilerVersion':
1019            compilerVersion_ = child_.text
1020            compilerVersion_ = self.gds_validate_string(compilerVersion_, node, 'compilerVersion')
1021            self.compilerVersion = compilerVersion_
1022        elif nodeName_ == 'linkerVersion':
1023            sval_ = child_.text
1024            try:
1025                fval_ = float(sval_)
1026            except (TypeError, ValueError) as exp:
1027                raise_parse_error(child_, 'requires float or double: %s' % exp)
1028            fval_ = self.gds_validate_float(fval_, node, 'linkerVersion')
1029            self.linkerVersion = fval_
1030        elif nodeName_ == 'minOSVersionCPE':
1031            minOSVersionCPE_ = child_.text
1032            minOSVersionCPE_ = self.gds_validate_string(minOSVersionCPE_, node, 'minOSVersionCPE')
1033            self.minOSVersionCPE = minOSVersionCPE_
1034        elif nodeName_ == 'numberOfSections':
1035            sval_ = child_.text
1036            try:
1037                ival_ = int(sval_)
1038            except (TypeError, ValueError) as exp:
1039                raise_parse_error(child_, 'requires integer: %s' % exp)
1040            ival_ = self.gds_validate_integer(ival_, node, 'numberOfSections')
1041            self.numberOfSections = ival_
1042        elif nodeName_ == 'MIMEType':
1043            MIMEType_ = child_.text
1044            MIMEType_ = self.gds_validate_string(MIMEType_, node, 'MIMEType')
1045            self.MIMEType = MIMEType_
1046        elif nodeName_ == 'requiredPrivilege':
1047            requiredPrivilege_ = child_.text
1048            requiredPrivilege_ = self.gds_validate_string(requiredPrivilege_, node, 'requiredPrivilege')
1049            self.requiredPrivilege = requiredPrivilege_
1050        elif nodeName_ == 'digitalSignature':
1051            obj_ = digitalSignatureObject.factory()
1052            obj_.build(child_)
1053            self.set_digitalSignature(obj_)
1054        elif nodeName_ == 'taggant':
1055            obj_ = taggantObject.factory()
1056            obj_.build(child_)
1057            self.set_taggant(obj_)
1058# end class fileObject
1059
1060
1061class extraHash(GeneratedsSuper):
1062    """Element for inserting fuzzy hashes for example pehash, ssdeep. These
1063    are put in with this element, with a required attribute 'type'
1064    used to hold the type of hash."""
1065    subclass = None
1066    superclass = None
1067    def __init__(self, type_=None, valueOf_=None):
1068        self.type_ = _cast(None, type_)
1069        self.valueOf_ = valueOf_
1070    def factory(*args_, **kwargs_):
1071        if extraHash.subclass:
1072            return extraHash.subclass(*args_, **kwargs_)
1073        else:
1074            return extraHash(*args_, **kwargs_)
1075    factory = staticmethod(factory)
1076    def get_type(self): return self.type_
1077    def set_type(self, type_): self.type_ = type_
1078    def get_valueOf_(self): return self.valueOf_
1079    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
1080    def export(self, write, level, namespace_='', name_='extraHash', namespacedef_=''):
1081        showIndent(write, level)
1082        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
1083        already_processed = []
1084        self.exportAttributes(write, level, already_processed, namespace_, name_='extraHash')
1085        if self.hasContent_():
1086            write('>')
1087            write(quote_xml(self.valueOf_))
1088            self.exportChildren(write, level + 1, namespace_, name_)
1089            write('</%s%s>\n' % (namespace_, name_))
1090        else:
1091            write('/>\n')
1092    def exportAttributes(self, write, level, already_processed, namespace_='', name_='extraHash'):
1093        if self.type_ is not None and 'type_' not in already_processed:
1094            already_processed.append('type_')
1095            write(' type=%s' % (quote_attrib(self.type_)))
1096    def exportChildren(self, write, level, namespace_='', name_='extraHash', fromsubclass_=False):
1097        pass
1098    def hasContent_(self):
1099        if (
1100            self.valueOf_
1101            ):
1102            return True
1103        else:
1104            return False
1105    def build(self, node):
1106        self.__sourcenode__ = node
1107        self.buildAttributes(node, node.attrib, [])
1108        self.valueOf_ = get_all_text_(node)
1109        for child in node:
1110            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
1111            self.buildChildren(child, node, nodeName_)
1112    def buildAttributes(self, node, attrs, already_processed):
1113        value = find_attr_value_('type', node)
1114        if value is not None and 'type' not in already_processed:
1115            already_processed.append('type')
1116            self.type_ = value
1117    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
1118        pass
1119# end class extraHash
1120
1121
1122class registryObject(GeneratedsSuper):
1123    """Registry object. The required attribute is 'id', which is taken to
1124    be key\\valueName. Keys end in a \, value names start with a \,
1125    so you have e.g. key =
1126    hklm\software\microsoft\currentversion\windows\run\ value =\foo
1127    making the id
1128    hklm\software\microsoft\currentversion\windows\run\\foo"""
1129    subclass = None
1130    superclass = None
1131    def __init__(self, id=None, key=None, valueName=None):
1132        self.id = _cast(None, id)
1133        self.key = key
1134        self.valueName = valueName
1135    def factory(*args_, **kwargs_):
1136        if registryObject.subclass:
1137            return registryObject.subclass(*args_, **kwargs_)
1138        else:
1139            return registryObject(*args_, **kwargs_)
1140    factory = staticmethod(factory)
1141    def get_key(self): return self.key
1142    def set_key(self, key): self.key = key
1143    def get_valueName(self): return self.valueName
1144    def set_valueName(self, valueName): self.valueName = valueName
1145    def get_id(self): return self.id
1146    def set_id(self, id): self.id = id
1147    def export(self, write, level, namespace_='', name_='registryObject', namespacedef_=''):
1148        showIndent(write, level)
1149        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
1150        already_processed = []
1151        self.exportAttributes(write, level, already_processed, namespace_, name_='registryObject')
1152        if self.hasContent_():
1153            write('>\n')
1154            self.exportChildren(write, level + 1, namespace_, name_)
1155            showIndent(write, level)
1156            write('</%s%s>\n' % (namespace_, name_))
1157        else:
1158            write('/>\n')
1159    def exportAttributes(self, write, level, already_processed, namespace_='', name_='registryObject'):
1160        if self.id is not None and 'id' not in already_processed:
1161            already_processed.append('id')
1162            write(' id=%s' % (quote_attrib(self.id)))
1163    def exportChildren(self, write, level, namespace_='', name_='registryObject', fromsubclass_=False):
1164        if self.key is not None:
1165            showIndent(write, level)
1166            write('<%skey>%s</%skey>\n' % (namespace_, quote_xml(self.key), namespace_))
1167        if self.valueName is not None:
1168            showIndent(write, level)
1169            write('<%svalueName>%s</%svalueName>\n' % (namespace_, quote_xml(self.valueName), namespace_))
1170    def hasContent_(self):
1171        if (
1172            self.key is not None or
1173            self.valueName is not None
1174            ):
1175            return True
1176        else:
1177            return False
1178    def build(self, node):
1179        self.__sourcenode__ = node
1180        self.buildAttributes(node, node.attrib, [])
1181        for child in node:
1182            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
1183            self.buildChildren(child, node, nodeName_)
1184    def buildAttributes(self, node, attrs, already_processed):
1185        value = find_attr_value_('id', node)
1186        if value is not None and 'id' not in already_processed:
1187            already_processed.append('id')
1188            self.id = value
1189    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
1190        if nodeName_ == 'key':
1191            key_ = child_.text
1192            key_ = self.gds_validate_string(key_, node, 'key')
1193            self.key = key_
1194        elif nodeName_ == 'valueName':
1195            valueName_ = child_.text
1196            valueName_ = self.gds_validate_string(valueName_, node, 'valueName')
1197            self.valueName = valueName_
1198# end class registryObject
1199
1200
1201class entityObject(GeneratedsSuper):
1202    """Entity Object. This is used to record groups, companies etc., and
1203    departments within organizations. The globally unique id
1204    (attribute) should be constructed from the company and
1205    department name, e.g. "Company name:Department name",
1206    "Mcafee:AVERT labs", or "Russian Business Network"."""
1207    subclass = None
1208    superclass = None
1209    def __init__(self, id=None, name=None):
1210        self.id = _cast(None, id)
1211        self.name = name
1212    def factory(*args_, **kwargs_):
1213        if entityObject.subclass:
1214            return entityObject.subclass(*args_, **kwargs_)
1215        else:
1216            return entityObject(*args_, **kwargs_)
1217    factory = staticmethod(factory)
1218    def get_name(self): return self.name
1219    def set_name(self, name): self.name = name
1220    def get_id(self): return self.id
1221    def set_id(self, id): self.id = id
1222    def export(self, write, level, namespace_='', name_='entityObject', namespacedef_=''):
1223        showIndent(write, level)
1224        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
1225        already_processed = []
1226        self.exportAttributes(write, level, already_processed, namespace_, name_='entityObject')
1227        if self.hasContent_():
1228            write('>\n')
1229            self.exportChildren(write, level + 1, namespace_, name_)
1230            showIndent(write, level)
1231            write('</%s%s>\n' % (namespace_, name_))
1232        else:
1233            write('/>\n')
1234    def exportAttributes(self, write, level, already_processed, namespace_='', name_='entityObject'):
1235        if self.id is not None and 'id' not in already_processed:
1236            already_processed.append('id')
1237            write(' id=%s' % (quote_attrib(self.id)))
1238    def exportChildren(self, write, level, namespace_='', name_='entityObject', fromsubclass_=False):
1239        if self.name is not None:
1240            showIndent(write, level)
1241            write('<%sname>%s</%sname>\n' % (namespace_, quote_xml(self.name), namespace_))
1242    def hasContent_(self):
1243        if (
1244            self.name is not None
1245            ):
1246            return True
1247        else:
1248            return False
1249    def build(self, node):
1250        self.__sourcenode__ = node
1251        self.buildAttributes(node, node.attrib, [])
1252        for child in node:
1253            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
1254            self.buildChildren(child, node, nodeName_)
1255    def buildAttributes(self, node, attrs, already_processed):
1256        value = find_attr_value_('id', node)
1257        if value is not None and 'id' not in already_processed:
1258            already_processed.append('id')
1259            self.id = value
1260    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
1261        if nodeName_ == 'name':
1262            name_ = child_.text
1263            name_ = self.gds_validate_string(name_, node, 'name')
1264            self.name = name_
1265# end class entityObject
1266
1267
1268class uriObject(GeneratedsSuper):
1269    """Uri object. Only required element is uri string itself. There are
1270    elements for each of the broken out elements. The protocol
1271    should be take from the list at http://www.iana.org/assignments
1272    /port-numbers, or if not in that list have the value 'unknown'.
1273    The ipProtocol should be taken from the list
1274    http://www.iana.org/assignments/protocol-numbers/. The elements
1275    correspond to the usual breakdown of a uri into its component
1276    domain, hostname, path, port etc, as described at
1277    http://en.wikipedia.org/wiki/Uniform_Resource_Locator."""
1278    subclass = None
1279    superclass = None
1280    def __init__(self, id=None, uriString=None, protocol=None, hostname=None, domain=None, port=None, path=None, ipProtocol=None):
1281        self.id = _cast(None, id)
1282        self.uriString = uriString
1283        self.protocol = protocol
1284        self.hostname = hostname
1285        self.domain = domain
1286        self.port = port
1287        self.path = path
1288        self.ipProtocol = ipProtocol
1289    def factory(*args_, **kwargs_):
1290        if uriObject.subclass:
1291            return uriObject.subclass(*args_, **kwargs_)
1292        else:
1293            return uriObject(*args_, **kwargs_)
1294    factory = staticmethod(factory)
1295    def get_uriString(self): return self.uriString
1296    def set_uriString(self, uriString): self.uriString = uriString
1297    def validate_NoQuestionMark(self, value):
1298        # Validate type NoQuestionMark, a restriction on xs:string.
1299        pass
1300    def get_protocol(self): return self.protocol
1301    def set_protocol(self, protocol): self.protocol = protocol
1302    def get_hostname(self): return self.hostname
1303    def set_hostname(self, hostname): self.hostname = hostname
1304    def get_domain(self): return self.domain
1305    def set_domain(self, domain): self.domain = domain
1306    def get_port(self): return self.port
1307    def set_port(self, port): self.port = port
1308    def get_path(self): return self.path
1309    def set_path(self, path): self.path = path
1310    def get_ipProtocol(self): return self.ipProtocol
1311    def set_ipProtocol(self, ipProtocol): self.ipProtocol = ipProtocol
1312    def get_id(self): return self.id
1313    def set_id(self, id): self.id = id
1314    def export(self, write, level, namespace_='', name_='uriObject', namespacedef_=''):
1315        showIndent(write, level)
1316        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
1317        already_processed = []
1318        self.exportAttributes(write, level, already_processed, namespace_, name_='uriObject')
1319        if self.hasContent_():
1320            write('>\n')
1321            self.exportChildren(write, level + 1, namespace_, name_)
1322            showIndent(write, level)
1323            write('</%s%s>\n' % (namespace_, name_))
1324        else:
1325            write('/>\n')
1326    def exportAttributes(self, write, level, already_processed, namespace_='', name_='uriObject'):
1327        if self.id is not None and 'id' not in already_processed:
1328            already_processed.append('id')
1329            write(' id=%s' % (quote_attrib(self.id), ))
1330    def exportChildren(self, write, level, namespace_='', name_='uriObject', fromsubclass_=False):
1331        if self.uriString is not None:
1332            showIndent(write, level)
1333            write('<%suriString>%s</%suriString>\n' % (namespace_, quote_xml(self.uriString), namespace_))
1334        if self.protocol is not None:
1335            showIndent(write, level)
1336            write('<%sprotocol>%s</%sprotocol>\n' % (namespace_, quote_xml(self.protocol), namespace_))
1337        if self.hostname is not None:
1338            showIndent(write, level)
1339            write('<%shostname>%s</%shostname>\n' % (namespace_, quote_xml(self.hostname), namespace_))
1340        if self.domain is not None:
1341            showIndent(write, level)
1342            write('<%sdomain>%s</%sdomain>\n' % (namespace_, quote_xml(self.domain), namespace_))
1343        if self.port is not None:
1344            showIndent(write, level)
1345            write('<%sport>%s</%sport>\n' % (namespace_, self.gds_format_integer(self.port, input_name='port'), namespace_))
1346        if self.path is not None:
1347            showIndent(write, level)
1348            write('<%spath>%s</%spath>\n' % (namespace_, quote_xml(self.path), namespace_))
1349        if self.ipProtocol is not None:
1350            showIndent(write, level)
1351            write('<%sipProtocol>%s</%sipProtocol>\n' % (namespace_, quote_xml(self.ipProtocol), namespace_))
1352    def hasContent_(self):
1353        if (
1354            self.uriString is not None or
1355            self.protocol is not None or
1356            self.hostname is not None or
1357            self.domain is not None or
1358            self.port is not None or
1359            self.path is not None or
1360            self.ipProtocol is not None
1361            ):
1362            return True
1363        else:
1364            return False
1365    def build(self, node):
1366        self.__sourcenode__ = node
1367        self.buildAttributes(node, node.attrib, [])
1368        for child in node:
1369            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
1370            self.buildChildren(child, node, nodeName_)
1371    def buildAttributes(self, node, attrs, already_processed):
1372        value = find_attr_value_('id', node)
1373        if value is not None and 'id' not in already_processed:
1374            already_processed.append('id')
1375            self.id = value
1376            self.validate_NoQuestionMark(self.id)    # validate type NoQuestionMark
1377    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
1378        if nodeName_ == 'uriString':
1379            uriString_ = child_.text
1380            uriString_ = self.gds_validate_string(uriString_, node, 'uriString')
1381            self.uriString = uriString_
1382            self.validate_NoQuestionMark(self.uriString)    # validate type NoQuestionMark
1383        elif nodeName_ == 'protocol':
1384            protocol_ = child_.text
1385            protocol_ = self.gds_validate_string(protocol_, node, 'protocol')
1386            self.protocol = protocol_
1387        elif nodeName_ == 'hostname':
1388            hostname_ = child_.text
1389            hostname_ = self.gds_validate_string(hostname_, node, 'hostname')
1390            self.hostname = hostname_
1391        elif nodeName_ == 'domain':
1392            domain_ = child_.text
1393            domain_ = self.gds_validate_string(domain_, node, 'domain')
1394            self.domain = domain_
1395        elif nodeName_ == 'port':
1396            sval_ = child_.text
1397            try:
1398                ival_ = int(sval_)
1399            except (TypeError, ValueError) as exp:
1400                raise_parse_error(child_, 'requires integer: %s' % exp)
1401            ival_ = self.gds_validate_integer(ival_, node, 'port')
1402            self.port = ival_
1403        elif nodeName_ == 'path':
1404            path_ = child_.text
1405            path_ = self.gds_validate_string(path_, node, 'path')
1406            self.path = path_
1407        elif nodeName_ == 'ipProtocol':
1408            ipProtocol_ = child_.text
1409            ipProtocol_ = self.gds_validate_string(ipProtocol_, node, 'ipProtocol')
1410            self.ipProtocol = ipProtocol_
1411# end class uriObject
1412
1413
1414class IPObject(GeneratedsSuper):
1415    """IP object. Used to hold ipv4, ipv6 ip addresses and address ranges.
1416    The globally unique id is 'startAddress-endAddress'. There are
1417    two required elements, startAddress and endAddress, make these
1418    the same if you are specifying a single address. Thus for ip
1419    range id, would be e.g. 213.23.45.7-213.23.45.19 For a single
1420    ip, id would be e.g. 12.34.56.1-12.34.56.1"""
1421    subclass = None
1422    superclass = None
1423    def __init__(self, id=None, startAddress=None, endAddress=None):
1424        self.id = _cast(None, id)
1425        self.startAddress = startAddress
1426        self.endAddress = endAddress
1427    def factory(*args_, **kwargs_):
1428        if IPObject.subclass:
1429            return IPObject.subclass(*args_, **kwargs_)
1430        else:
1431            return IPObject(*args_, **kwargs_)
1432    factory = staticmethod(factory)
1433    def get_startAddress(self): return self.startAddress
1434    def set_startAddress(self, startAddress): self.startAddress = startAddress
1435    def get_endAddress(self): return self.endAddress
1436    def set_endAddress(self, endAddress): self.endAddress = endAddress
1437    def get_id(self): return self.id
1438    def set_id(self, id): self.id = id
1439    def validate_IPRange(self, value):
1440        # Validate type IPRange, a restriction on xs:string.
1441        pass
1442    def export(self, write, level, namespace_='', name_='IPObject', namespacedef_=''):
1443        showIndent(write, level)
1444        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
1445        already_processed = []
1446        self.exportAttributes(write, level, already_processed, namespace_, name_='IPObject')
1447        if self.hasContent_():
1448            write('>\n')
1449            self.exportChildren(write, level + 1, namespace_, name_)
1450            showIndent(write, level)
1451            write('</%s%s>\n' % (namespace_, name_))
1452        else:
1453            write('/>\n')
1454    def exportAttributes(self, write, level, already_processed, namespace_='', name_='IPObject'):
1455        if self.id is not None and 'id' not in already_processed:
1456            already_processed.append('id')
1457            write(' id=%s' % (quote_attrib(self.id), ))
1458    def exportChildren(self, write, level, namespace_='', name_='IPObject', fromsubclass_=False):
1459        if self.startAddress is not None:
1460            self.startAddress.export(write, level, namespace_, name_='startAddress', )
1461        if self.endAddress is not None:
1462            self.endAddress.export(write, level, namespace_, name_='endAddress', )
1463    def hasContent_(self):
1464        if (
1465            self.startAddress is not None or
1466            self.endAddress is not None
1467            ):
1468            return True
1469        else:
1470            return False
1471    def build(self, node):
1472        self.__sourcenode__ = node
1473        self.buildAttributes(node, node.attrib, [])
1474        for child in node:
1475            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
1476            self.buildChildren(child, node, nodeName_)
1477    def buildAttributes(self, node, attrs, already_processed):
1478        value = find_attr_value_('id', node)
1479        if value is not None and 'id' not in already_processed:
1480            already_processed.append('id')
1481            self.id = value
1482            self.validate_IPRange(self.id)    # validate type IPRange
1483    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
1484        if nodeName_ == 'startAddress':
1485            obj_ = IPAddress.factory()
1486            obj_.build(child_)
1487            self.set_startAddress(obj_)
1488        elif nodeName_ == 'endAddress':
1489            obj_ = IPAddress.factory()
1490            obj_.build(child_)
1491            self.set_endAddress(obj_)
1492# end class IPObject
1493
1494
1495class IPAddress(GeneratedsSuper):
1496    """ip address - string for the actual address and attribute either
1497    ipv4, ipv6."""
1498    subclass = None
1499    superclass = None
1500    def __init__(self, type_=None, valueOf_=None):
1501        self.type_ = _cast(None, type_)
1502        self.valueOf_ = valueOf_
1503    def factory(*args_, **kwargs_):
1504        if IPAddress.subclass:
1505            return IPAddress.subclass(*args_, **kwargs_)
1506        else:
1507            return IPAddress(*args_, **kwargs_)
1508    factory = staticmethod(factory)
1509    def get_type(self): return self.type_
1510    def set_type(self, type_): self.type_ = type_
1511    def validate_IPTypeEnum(self, value):
1512        # Validate type IPTypeEnum, a restriction on xs:string.
1513        pass
1514    def get_valueOf_(self): return self.valueOf_
1515    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
1516    def export(self, write, level, namespace_='', name_='IPAddress', namespacedef_=''):
1517        showIndent(write, level)
1518        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
1519        already_processed = []
1520        self.exportAttributes(write, level, already_processed, namespace_, name_='IPAddress')
1521        if self.hasContent_():
1522            write('>')
1523            write(quote_xml(self.valueOf_))
1524            self.exportChildren(write, level + 1, namespace_, name_)
1525            write('</%s%s>\n' % (namespace_, name_))
1526        else:
1527            write('/>\n')
1528    def exportAttributes(self, write, level, already_processed, namespace_='', name_='IPAddress'):
1529        if self.type_ is not None and 'type_' not in already_processed:
1530            already_processed.append('type_')
1531            write(' type=%s' % (quote_attrib(self.type_), ))
1532    def exportChildren(self, write, level, namespace_='', name_='IPAddress', fromsubclass_=False):
1533        pass
1534    def hasContent_(self):
1535        if (
1536            self.valueOf_
1537            ):
1538            return True
1539        else:
1540            return False
1541    def build(self, node):
1542        self.__sourcenode__ = node
1543        self.buildAttributes(node, node.attrib, [])
1544        self.valueOf_ = get_all_text_(node)
1545        for child in node:
1546            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
1547            self.buildChildren(child, node, nodeName_)
1548    def buildAttributes(self, node, attrs, already_processed):
1549        value = find_attr_value_('type', node)
1550        if value is not None and 'type' not in already_processed:
1551            already_processed.append('type')
1552            self.type_ = value
1553            self.validate_IPTypeEnum(self.type_)    # validate type IPTypeEnum
1554    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
1555        pass
1556# end class IPAddress
1557
1558
1559class domainObject(GeneratedsSuper):
1560    """Domain object, used to hold internet domains, e.g.yahoo.com. The
1561    globally unique identifier (id attribute) is the domain itself.
1562    whois information on domain is recorded using object properties."""
1563    subclass = None
1564    superclass = None
1565    def __init__(self, id=None, domain=None):
1566        self.id = _cast(None, id)
1567        self.domain = domain
1568    def factory(*args_, **kwargs_):
1569        if domainObject.subclass:
1570            return domainObject.subclass(*args_, **kwargs_)
1571        else:
1572            return domainObject(*args_, **kwargs_)
1573    factory = staticmethod(factory)
1574    def get_domain(self): return self.domain
1575    def set_domain(self, domain): self.domain = domain
1576    def get_id(self): return self.id
1577    def set_id(self, id): self.id = id
1578    def export(self, write, level, namespace_='', name_='domainObject', namespacedef_=''):
1579        showIndent(write, level)
1580        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
1581        already_processed = []
1582        self.exportAttributes(write, level, already_processed, namespace_, name_='domainObject')
1583        if self.hasContent_():
1584            write('>\n')
1585            self.exportChildren(write, level + 1, namespace_, name_)
1586            showIndent(write, level)
1587            write('</%s%s>\n' % (namespace_, name_))
1588        else:
1589            write('/>\n')
1590    def exportAttributes(self, write, level, already_processed, namespace_='', name_='domainObject'):
1591        if self.id is not None and 'id' not in already_processed:
1592            already_processed.append('id')
1593            write(' id=%s' % (quote_attrib(self.id)))
1594    def exportChildren(self, write, level, namespace_='', name_='domainObject', fromsubclass_=False):
1595        if self.domain is not None:
1596            showIndent(write, level)
1597            write('<%sdomain>%s</%sdomain>\n' % (namespace_, quote_xml(self.domain), namespace_))
1598    def hasContent_(self):
1599        if (
1600            self.domain is not None
1601            ):
1602            return True
1603        else:
1604            return False
1605    def build(self, node):
1606        self.__sourcenode__ = node
1607        self.buildAttributes(node, node.attrib, [])
1608        for child in node:
1609            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
1610            self.buildChildren(child, node, nodeName_)
1611    def buildAttributes(self, node, attrs, already_processed):
1612        value = find_attr_value_('id', node)
1613        if value is not None and 'id' not in already_processed:
1614            already_processed.append('id')
1615            self.id = value
1616    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
1617        if nodeName_ == 'domain':
1618            domain_ = child_.text
1619            domain_ = self.gds_validate_string(domain_, node, 'domain')
1620            self.domain = domain_
1621# end class domainObject
1622
1623
1624class ASNObject(GeneratedsSuper):
1625    """Object used to hold information on Autonomous System Numbers. An
1626    autonomous system (AS) is a collection of connected Internet
1627    Protocol (IP) routing prefixes under the control of one or more
1628    network operators that presents a common, clearly defined
1629    routing policy to the Internet. The id is the number, written as
1630    an integer for both 16 and 32 bit numbers."""
1631    subclass = None
1632    superclass = None
1633    def __init__(self, id=None, as_number=None):
1634        self.id = _cast(int, id)
1635        self.as_number = as_number
1636    def factory(*args_, **kwargs_):
1637        if ASNObject.subclass:
1638            return ASNObject.subclass(*args_, **kwargs_)
1639        else:
1640            return ASNObject(*args_, **kwargs_)
1641    factory = staticmethod(factory)
1642    def get_as_number(self): return self.as_number
1643    def set_as_number(self, as_number): self.as_number = as_number
1644    def get_id(self): return self.id
1645    def set_id(self, id): self.id = id
1646    def export(self, write, level, namespace_='', name_='ASNObject', namespacedef_=''):
1647        showIndent(write, level)
1648        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
1649        already_processed = []
1650        self.exportAttributes(write, level, already_processed, namespace_, name_='ASNObject')
1651        if self.hasContent_():
1652            write('>\n')
1653            self.exportChildren(write, level + 1, namespace_, name_)
1654            showIndent(write, level)
1655            write('</%s%s>\n' % (namespace_, name_))
1656        else:
1657            write('/>\n')
1658    def exportAttributes(self, write, level, already_processed, namespace_='', name_='ASNObject'):
1659        if self.id is not None and 'id' not in already_processed:
1660            already_processed.append('id')
1661            write(' id="%s"' % self.gds_format_integer(self.id, input_name='id'))
1662    def exportChildren(self, write, level, namespace_='', name_='ASNObject', fromsubclass_=False):
1663        if self.as_number is not None:
1664            showIndent(write, level)
1665            write('<%sas-number>%s</%sas-number>\n' % (namespace_, self.gds_format_integer(self.as_number, input_name='as-number'), namespace_))
1666    def hasContent_(self):
1667        if (
1668            self.as_number is not None
1669            ):
1670            return True
1671        else:
1672            return False
1673    def build(self, node):
1674        self.__sourcenode__ = node
1675        self.buildAttributes(node, node.attrib, [])
1676        for child in node:
1677            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
1678            self.buildChildren(child, node, nodeName_)
1679    def buildAttributes(self, node, attrs, already_processed):
1680        value = find_attr_value_('id', node)
1681        if value is not None and 'id' not in already_processed:
1682            already_processed.append('id')
1683            try:
1684                self.id = int(value)
1685            except ValueError as exp:
1686                raise_parse_error(node, 'Bad integer attribute: %s' % exp)
1687    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
1688        if nodeName_ == 'as-number':
1689            sval_ = child_.text
1690            try:
1691                ival_ = int(sval_)
1692            except (TypeError, ValueError) as exp:
1693                raise_parse_error(child_, 'requires integer: %s' % exp)
1694            ival_ = self.gds_validate_integer(ival_, node, 'as_number')
1695            self.as_number = ival_
1696# end class ASNObject
1697
1698
1699class classificationObject(GeneratedsSuper):
1700    """Classification object, used to hold names or classifications of
1701    objects. The most common use case for this is detection names
1702    for files from av scanners. However, this object could be used
1703    for general classification. The globally unique id (attribute)
1704    should be created from "Company name:internal classification
1705    name", e.g. "Mcafee:Generic.DX". The other required attribute is
1706    the type of classification, e.g. clean, dirty, unknown. There
1707    are elements to capture the category of the classification. The
1708    category should be entered in the same way to the classification
1709    name, e.g. company name:category name, e..g Mcafee:Trojan."""
1710    subclass = None
1711    superclass = None
1712    def __init__(self, type_=None, id=None, classificationName=None, companyName=None, category=None, classificationDetails=None):
1713        self.type_ = _cast(None, type_)
1714        self.id = _cast(None, id)
1715        self.classificationName = classificationName
1716        self.companyName = companyName
1717        self.category = category
1718        self.classificationDetails = classificationDetails
1719    def factory(*args_, **kwargs_):
1720        if classificationObject.subclass:
1721            return classificationObject.subclass(*args_, **kwargs_)
1722        else:
1723            return classificationObject(*args_, **kwargs_)
1724    factory = staticmethod(factory)
1725    def get_classificationName(self): return self.classificationName
1726    def set_classificationName(self, classificationName): self.classificationName = classificationName
1727    def get_companyName(self): return self.companyName
1728    def set_companyName(self, companyName): self.companyName = companyName
1729    def get_category(self): return self.category
1730    def set_category(self, category): self.category = category
1731    def get_classificationDetails(self): return self.classificationDetails
1732    def set_classificationDetails(self, classificationDetails): self.classificationDetails = classificationDetails
1733    def get_type(self): return self.type_
1734    def set_type(self, type_): self.type_ = type_
1735    def validate_ClassificationTypeEnum(self, value):
1736        # Validate type ClassificationTypeEnum, a restriction on xs:string.
1737        pass
1738    def get_id(self): return self.id
1739    def set_id(self, id): self.id = id
1740    def export(self, write, level, namespace_='', name_='classificationObject', namespacedef_=''):
1741        showIndent(write, level)
1742        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
1743        already_processed = []
1744        self.exportAttributes(write, level, already_processed, namespace_, name_='classificationObject')
1745        if self.hasContent_():
1746            write('>\n')
1747            self.exportChildren(write, level + 1, namespace_, name_)
1748            showIndent(write, level)
1749            write('</%s%s>\n' % (namespace_, name_))
1750        else:
1751            write('/>\n')
1752    def exportAttributes(self, write, level, already_processed, namespace_='', name_='classificationObject'):
1753        if self.type_ is not None and 'type_' not in already_processed:
1754            already_processed.append('type_')
1755            write(' type=%s' % (quote_attrib(self.type_), ))
1756        if self.id is not None and 'id' not in already_processed:
1757            already_processed.append('id')
1758            write(' id=%s' % (quote_attrib(self.id)))
1759    def exportChildren(self, write, level, namespace_='', name_='classificationObject', fromsubclass_=False):
1760        if self.classificationName is not None:
1761            showIndent(write, level)
1762            write('<%sclassificationName>%s</%sclassificationName>\n' % ('mmdef:', quote_xml(self.classificationName), 'mmdef:'))
1763        if self.companyName is not None:
1764            showIndent(write, level)
1765            write('<%scompanyName>%s</%scompanyName>\n' % ('mmdef:', quote_xml(self.companyName), 'mmdef:'))
1766        if self.category is not None:
1767            showIndent(write, level)
1768            write('<%scategory>%s</%scategory>\n' % ('mmdef:', quote_xml(self.category), 'mmdef:'))
1769        if self.classificationDetails is not None:
1770            self.classificationDetails.export(write, level, namespace_, name_='classificationDetails')
1771    def hasContent_(self):
1772        if (
1773            self.classificationName is not None or
1774            self.companyName is not None or
1775            self.category is not None or
1776            self.classificationDetails is not None
1777            ):
1778            return True
1779        else:
1780            return False
1781    def build(self, node):
1782        self.__sourcenode__ = node
1783        self.buildAttributes(node, node.attrib, [])
1784        for child in node:
1785            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
1786            self.buildChildren(child, node, nodeName_)
1787    def buildAttributes(self, node, attrs, already_processed):
1788        value = find_attr_value_('type', node)
1789        if value is not None and 'type' not in already_processed:
1790            already_processed.append('type')
1791            self.type_ = value
1792            self.validate_ClassificationTypeEnum(self.type_)    # validate type ClassificationTypeEnum
1793        value = find_attr_value_('id', node)
1794        if value is not None and 'id' not in already_processed:
1795            already_processed.append('id')
1796            self.id = value
1797    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
1798        if nodeName_ == 'classificationName':
1799            classificationName_ = child_.text
1800            classificationName_ = self.gds_validate_string(classificationName_, node, 'classificationName')
1801            self.classificationName = classificationName_
1802        elif nodeName_ == 'companyName':
1803            companyName_ = child_.text
1804            companyName_ = self.gds_validate_string(companyName_, node, 'companyName')
1805            self.companyName = companyName_
1806        elif nodeName_ == 'category':
1807            category_ = child_.text
1808            category_ = self.gds_validate_string(category_, node, 'category')
1809            self.category = category_
1810        elif nodeName_ == 'classificationDetails':
1811            obj_ = classificationDetails.factory()
1812            obj_.build(child_)
1813            self.set_classificationDetails(obj_)
1814# end class classificationObject
1815
1816
1817class classificationDetails(GeneratedsSuper):
1818    """Details of the classification, giving product details, particularly
1819    useful for anti-virus scanner detections."""
1820    subclass = None
1821    superclass = None
1822    def __init__(self, definitionVersion=None, detectionAddedTimeStamp=None, detectionShippedTimeStamp=None, product=None, productVersion=None):
1823        self.definitionVersion = definitionVersion
1824        self.detectionAddedTimeStamp = detectionAddedTimeStamp
1825        self.detectionShippedTimeStamp = detectionShippedTimeStamp
1826        self.product = product
1827        self.productVersion = productVersion
1828    def factory(*args_, **kwargs_):
1829        if classificationDetails.subclass:
1830            return classificationDetails.subclass(*args_, **kwargs_)
1831        else:
1832            return classificationDetails(*args_, **kwargs_)
1833    factory = staticmethod(factory)
1834    def get_definitionVersion(self): return self.definitionVersion
1835    def set_definitionVersion(self, definitionVersion): self.definitionVersion = definitionVersion
1836    def get_detectionAddedTimeStamp(self): return self.detectionAddedTimeStamp
1837    def set_detectionAddedTimeStamp(self, detectionAddedTimeStamp): self.detectionAddedTimeStamp = detectionAddedTimeStamp
1838    def get_detectionShippedTimeStamp(self): return self.detectionShippedTimeStamp
1839    def set_detectionShippedTimeStamp(self, detectionShippedTimeStamp): self.detectionShippedTimeStamp = detectionShippedTimeStamp
1840    def get_product(self): return self.product
1841    def set_product(self, product): self.product = product
1842    def get_productVersion(self): return self.productVersion
1843    def set_productVersion(self, productVersion): self.productVersion = productVersion
1844    def export(self, write, level, namespace_='', name_='classificationDetails', namespacedef_=''):
1845        showIndent(write, level)
1846        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
1847        already_processed = []
1848        self.exportAttributes(write, level, already_processed, namespace_, name_='classificationDetails')
1849        if self.hasContent_():
1850            write('>\n')
1851            self.exportChildren(write, level + 1, namespace_, name_)
1852            showIndent(write, level)
1853            write('</%s%s>\n' % (namespace_, name_))
1854        else:
1855            write('/>\n')
1856    def exportAttributes(self, write, level, already_processed, namespace_='', name_='classificationDetails'):
1857        pass
1858    def exportChildren(self, write, level, namespace_='', name_='classificationDetails', fromsubclass_=False):
1859        if self.definitionVersion is not None:
1860            showIndent(write, level)
1861            write('<%sdefinitionVersion>%s</%sdefinitionVersion>\n' % (namespace_, quote_xml(self.definitionVersion), namespace_))
1862        if self.detectionAddedTimeStamp is not None:
1863            showIndent(write, level)
1864            write('<%sdetectionAddedTimeStamp>%s</%sdetectionAddedTimeStamp>\n' % (namespace_, quote_xml(self.detectionAddedTimeStamp), namespace_))
1865        if self.detectionShippedTimeStamp is not None:
1866            showIndent(write, level)
1867            write('<%sdetectionShippedTimeStamp>%s</%sdetectionShippedTimeStamp>\n' % (namespace_, quote_xml(self.detectionShippedTimeStamp), namespace_))
1868        if self.product is not None:
1869            showIndent(write, level)
1870            write('<%sproduct>%s</%sproduct>\n' % (namespace_, quote_xml(self.product), namespace_))
1871        if self.productVersion is not None:
1872            showIndent(write, level)
1873            write('<%sproductVersion>%s</%sproductVersion>\n' % (namespace_, quote_xml(self.productVersion), namespace_))
1874    def hasContent_(self):
1875        if (
1876            self.definitionVersion is not None or
1877            self.detectionAddedTimeStamp is not None or
1878            self.detectionShippedTimeStamp is not None or
1879            self.product is not None or
1880            self.productVersion is not None
1881            ):
1882            return True
1883        else:
1884            return False
1885    def build(self, node):
1886        self.__sourcenode__ = node
1887        self.buildAttributes(node, node.attrib, [])
1888        for child in node:
1889            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
1890            self.buildChildren(child, node, nodeName_)
1891    def buildAttributes(self, node, attrs, already_processed):
1892        pass
1893    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
1894        if nodeName_ == 'definitionVersion':
1895            definitionVersion_ = child_.text
1896            definitionVersion_ = self.gds_validate_string(definitionVersion_, node, 'definitionVersion')
1897            self.definitionVersion = definitionVersion_
1898        elif nodeName_ == 'detectionAddedTimeStamp':
1899            detectionAddedTimeStamp_ = child_.text
1900            detectionAddedTimeStamp_ = self.gds_validate_string(detectionAddedTimeStamp_, node, 'detectionAddedTimeStamp')
1901            self.detectionAddedTimeStamp = detectionAddedTimeStamp_
1902        elif nodeName_ == 'detectionShippedTimeStamp':
1903            detectionShippedTimeStamp_ = child_.text
1904            detectionShippedTimeStamp_ = self.gds_validate_string(detectionShippedTimeStamp_, node, 'detectionShippedTimeStamp')
1905            self.detectionShippedTimeStamp = detectionShippedTimeStamp_
1906        elif nodeName_ == 'product':
1907            product_ = child_.text
1908            product_ = self.gds_validate_string(product_, node, 'product')
1909            self.product = product_
1910        elif nodeName_ == 'productVersion':
1911            productVersion_ = child_.text
1912            productVersion_ = self.gds_validate_string(productVersion_, node, 'productVersion')
1913            self.productVersion = productVersion_
1914# end class classificationDetails
1915
1916
1917class fieldDataEntry(GeneratedsSuper):
1918    """Data structure to hold prevalence information. The data includes a
1919    reference to another object (which is an xpath expression
1920    pointing to an object inside the 'ref' element), together with a
1921    time period (startDate -> endDate), an origin - where the object
1922    came from, and various location tags. This allows rich
1923    information on prevalence to be recorded. By convention, time
1924    periods should be wherever possible standard time periods, e.g.
1925    minute, hour, 24 hours, week, month, quarter, year. This will
1926    facilitate combination of data from multiple sources. To
1927    represent a single entry, make startDate == endDate. Commonality
1928    is calculated from the sightings of malware objects (and so such
1929    calculation is easier to automate). Importance is reserved for
1930    cases when “commonality” is not available or if there is a
1931    need to communicate the importance when commonality is low. We
1932    define the commonality on a scale 0 to 100 (0 means “never
1933    found in the field” and 100 means “found very
1934    frequently”). Scaling commonality to 0..100 range instead of
1935    using actual sample counts is to avoid the effect of the user
1936    base size on the commonality. We derive commonality from the
1937    number of affected computers – not from the number of samples
1938    (for example, a hundred parasitic infections of the same virus
1939    on a single computer are to be counted as one). To calculate the
1940    commonality we use two-stage approach and logarithmic scale: -
1941    If the number of affected users exceeds 0.1% of your user base
1942    (more frequent than 1 in a 1000) set commonality to “100” -
1943    Otherwise, calculate the ratio of infected computers amongst
1944    your user base by dividing the real number of affected computers
1945    ‘n’ by the total number ‘N’ - Apply the following
1946    formula to get the commonality –( log2(1+n*1000/N) ) * 100 -
1947    Round to the closest integer Obviously, the calculation above
1948    can only be applied to counting of malware sightings on
1949    desktops. If telemetry is collected from a fraction of such
1950    desktops then an appropriate correction should be used. For all
1951    other cases (e.g. sighting on gateways, in some network security
1952    appliance, on an ISP level, etc.) please exercise your best
1953    judgment and apply provided desktop guideline as an example to
1954    make sure the commonality factor is as comparable as possible.
1955    For a URL object the commonality could reflect, for example, how
1956    widely it was spammed. “Importance” should not be used
1957    together with “commonality” (unless commonality=“0”) to
1958    avoid possible confusion. High “importance”, for example,
1959    can be assigned to samples that are over-hyped by media when
1960    their commonality is still “0”. Use the following guidelines
1961    for “importance” which is also defined on a scale 0..100:
1962    100 – you’d expect your CEO and/or media to call you any
1963    second about this object 80 – you might get a call from your
1964    CEO and/or media 60 – you’d expect your boss to call you any
1965    second 40 – you might get a call from your boss 20 – someone
1966    is very likely to contact you about this object 10 – you might
1967    get contacted about this object 0 – you’d be surprised if
1968    anyone would ever contact you about this object"""
1969    subclass = None
1970    superclass = None
1971    def __init__(self, references=None, startDate=None, endDate=None, firstSeenDate=None, origin=None, commonality=None, volume=None, importance=None, location=None):
1972        self.references = references
1973        self.startDate = startDate
1974        self.endDate = endDate
1975        self.firstSeenDate = firstSeenDate
1976        self.origin = origin
1977        self.commonality = commonality
1978        if volume is None:
1979            self.volume = []
1980        else:
1981            self.volume = volume
1982        self.importance = importance
1983        self.location = location
1984    def factory(*args_, **kwargs_):
1985        if fieldDataEntry.subclass:
1986            return fieldDataEntry.subclass(*args_, **kwargs_)
1987        else:
1988            return fieldDataEntry(*args_, **kwargs_)
1989    factory = staticmethod(factory)
1990    def get_references(self): return self.references
1991    def set_references(self, references): self.references = references
1992    def get_startDate(self): return self.startDate
1993    def set_startDate(self, startDate): self.startDate = startDate
1994    def get_endDate(self): return self.endDate
1995    def set_endDate(self, endDate): self.endDate = endDate
1996    def get_firstSeenDate(self): return self.firstSeenDate
1997    def set_firstSeenDate(self, firstSeenDate): self.firstSeenDate = firstSeenDate
1998    def get_origin(self): return self.origin
1999    def set_origin(self, origin): self.origin = origin
2000    def validate_OriginTypeEnum(self, value):
2001        # Validate type OriginTypeEnum, a restriction on xs:string.
2002        pass
2003    def get_commonality(self): return self.commonality
2004    def set_commonality(self, commonality): self.commonality = commonality
2005    def validate_intBetween0and100(self, value):
2006        # Validate type intBetween0and100, a restriction on xs:integer.
2007        pass
2008    def get_volume(self): return self.volume
2009    def set_volume(self, volume): self.volume = volume
2010    def add_volume(self, value): self.volume.append(value)
2011    def insert_volume(self, index, value): self.volume[index] = value
2012    def get_importance(self): return self.importance
2013    def set_importance(self, importance): self.importance = importance
2014    def get_location(self): return self.location
2015    def set_location(self, location): self.location = location
2016    def export(self, write, level, namespace_='', name_='fieldDataEntry', namespacedef_=''):
2017        showIndent(write, level)
2018        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
2019        already_processed = []
2020        self.exportAttributes(write, level, already_processed, namespace_, name_='fieldDataEntry')
2021        if self.hasContent_():
2022            write('>\n')
2023            self.exportChildren(write, level + 1, namespace_, name_)
2024            showIndent(write, level)
2025            write('</%s%s>\n' % (namespace_, name_))
2026        else:
2027            write('/>\n')
2028    def exportAttributes(self, write, level, already_processed, namespace_='', name_='fieldDataEntry'):
2029        pass
2030    def exportChildren(self, write, level, namespace_='', name_='fieldDataEntry', fromsubclass_=False):
2031        if self.references is not None:
2032            self.references.export(write, level, namespace_, name_='references', )
2033        if self.startDate is not None:
2034            showIndent(write, level)
2035            write('<%sstartDate>%s</%sstartDate>\n' % (namespace_, quote_xml(self.startDate), namespace_))
2036        if self.endDate is not None:
2037            showIndent(write, level)
2038            write('<%sendDate>%s</%sendDate>\n' % (namespace_, quote_xml(self.endDate), namespace_))
2039        if self.firstSeenDate is not None:
2040            showIndent(write, level)
2041            write('<%sfirstSeenDate>%s</%sfirstSeenDate>\n' % (namespace_, quote_xml(self.firstSeenDate), namespace_))
2042        if self.origin is not None:
2043            showIndent(write, level)
2044            write('<%sorigin>%s</%sorigin>\n' % (namespace_, quote_xml(self.origin), namespace_))
2045        if self.commonality is not None:
2046            showIndent(write, level)
2047            write('<%scommonality>%s</%scommonality>\n' % (namespace_, self.gds_format_integer(self.commonality, input_name='commonality'), namespace_))
2048        for volume_ in self.volume:
2049            volume_.export(write, level, namespace_, name_='volume')
2050        if self.importance is not None:
2051            showIndent(write, level)
2052            write('<%simportance>%s</%simportance>\n' % (namespace_, self.gds_format_integer(self.importance, input_name='importance'), namespace_))
2053        if self.location is not None:
2054            self.location.export(write, level, namespace_, name_='location')
2055    def hasContent_(self):
2056        if (
2057            self.references is not None or
2058            self.startDate is not None or
2059            self.endDate is not None or
2060            self.firstSeenDate is not None or
2061            self.origin is not None or
2062            self.commonality is not None or
2063            self.volume or
2064            self.importance is not None or
2065            self.location is not None
2066            ):
2067            return True
2068        else:
2069            return False
2070    def build(self, node):
2071        self.__sourcenode__ = node
2072        self.buildAttributes(node, node.attrib, [])
2073        for child in node:
2074            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
2075            self.buildChildren(child, node, nodeName_)
2076    def buildAttributes(self, node, attrs, already_processed):
2077        pass
2078    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
2079        if nodeName_ == 'references':
2080            obj_ = references.factory()
2081            obj_.build(child_)
2082            self.set_references(obj_)
2083        elif nodeName_ == 'startDate':
2084            startDate_ = child_.text
2085            startDate_ = self.gds_validate_string(startDate_, node, 'startDate')
2086            self.startDate = startDate_
2087        elif nodeName_ == 'endDate':
2088            endDate_ = child_.text
2089            endDate_ = self.gds_validate_string(endDate_, node, 'endDate')
2090            self.endDate = endDate_
2091        elif nodeName_ == 'firstSeenDate':
2092            firstSeenDate_ = child_.text
2093            firstSeenDate_ = self.gds_validate_string(firstSeenDate_, node, 'firstSeenDate')
2094            self.firstSeenDate = firstSeenDate_
2095        elif nodeName_ == 'origin':
2096            origin_ = child_.text
2097            origin_ = self.gds_validate_string(origin_, node, 'origin')
2098            self.origin = origin_
2099            self.validate_OriginTypeEnum(self.origin)    # validate type OriginTypeEnum
2100        elif nodeName_ == 'commonality':
2101            sval_ = child_.text
2102            try:
2103                ival_ = int(sval_)
2104            except (TypeError, ValueError) as exp:
2105                raise_parse_error(child_, 'requires integer: %s' % exp)
2106            ival_ = self.gds_validate_integer(ival_, node, 'commonality')
2107            self.commonality = ival_
2108            self.validate_intBetween0and100(self.commonality)    # validate type intBetween0and100
2109        elif nodeName_ == 'volume':
2110            obj_ = volume.factory()
2111            obj_.build(child_)
2112            self.volume.append(obj_)
2113        elif nodeName_ == 'importance':
2114            sval_ = child_.text
2115            try:
2116                ival_ = int(sval_)
2117            except (TypeError, ValueError) as exp:
2118                raise_parse_error(child_, 'requires integer: %s' % exp)
2119            ival_ = self.gds_validate_integer(ival_, node, 'importance')
2120            self.importance = ival_
2121            self.validate_intBetween0and100(self.importance)    # validate type intBetween0and100
2122        elif nodeName_ == 'location':
2123            obj_ = location.factory()
2124            obj_.build(child_)
2125            self.set_location(obj_)
2126# end class fieldDataEntry
2127
2128
2129class references(GeneratedsSuper):
2130    """The objects the prevalence information pertains to."""
2131    subclass = None
2132    superclass = None
2133    def __init__(self, ref=None):
2134        if ref is None:
2135            self.ref = []
2136        else:
2137            self.ref = ref
2138    def factory(*args_, **kwargs_):
2139        if references.subclass:
2140            return references.subclass(*args_, **kwargs_)
2141        else:
2142            return references(*args_, **kwargs_)
2143    factory = staticmethod(factory)
2144    def get_ref(self): return self.ref
2145    def set_ref(self, ref): self.ref = ref
2146    def add_ref(self, value): self.ref.append(value)
2147    def insert_ref(self, index, value): self.ref[index] = value
2148    def export(self, write, level, namespace_='', name_='references', namespacedef_=''):
2149        showIndent(write, level)
2150        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
2151        already_processed = []
2152        self.exportAttributes(write, level, already_processed, namespace_, name_='references')
2153        if self.hasContent_():
2154            write('>\n')
2155            self.exportChildren(write, level + 1, namespace_, name_)
2156            showIndent(write, level)
2157            write('</%s%s>\n' % (namespace_, name_))
2158        else:
2159            write('/>\n')
2160    def exportAttributes(self, write, level, already_processed, namespace_='', name_='references'):
2161        pass
2162    def exportChildren(self, write, level, namespace_='', name_='references', fromsubclass_=False):
2163        for ref_ in self.ref:
2164            ref_.export(write, level, namespace_, name_='ref')
2165    def hasContent_(self):
2166        if (
2167            self.ref
2168            ):
2169            return True
2170        else:
2171            return False
2172    def build(self, node):
2173        self.__sourcenode__ = node
2174        self.buildAttributes(node, node.attrib, [])
2175        for child in node:
2176            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
2177            self.buildChildren(child, node, nodeName_)
2178    def buildAttributes(self, node, attrs, already_processed):
2179        pass
2180    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
2181        if nodeName_ == 'ref':
2182            obj_ = reference.factory()
2183            obj_.build(child_)
2184            self.ref.append(obj_)
2185# end class references
2186
2187
2188class volume(GeneratedsSuper):
2189    """Quantitive measurements of prevalence."""
2190    subclass = None
2191    superclass = None
2192    def __init__(self, units=None, valueOf_=None):
2193        self.units = _cast(None, units)
2194        self.valueOf_ = valueOf_
2195    def factory(*args_, **kwargs_):
2196        if volume.subclass:
2197            return volume.subclass(*args_, **kwargs_)
2198        else:
2199            return volume(*args_, **kwargs_)
2200    factory = staticmethod(factory)
2201    def get_units(self): return self.units
2202    def set_units(self, units): self.units = units
2203    def validate_VolumeUnitsEnum(self, value):
2204        # Validate type VolumeUnitsEnum, a restriction on xs:string.
2205        pass
2206    def get_valueOf_(self): return self.valueOf_
2207    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
2208    def export(self, write, level, namespace_='', name_='volume', namespacedef_=''):
2209        showIndent(write, level)
2210        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
2211        already_processed = []
2212        self.exportAttributes(write, level, already_processed, namespace_, name_='volume')
2213        if self.hasContent_():
2214            write('>')
2215            write(quote_xml(self.valueOf_))
2216            self.exportChildren(write, level + 1, namespace_, name_)
2217            write('</%s%s>\n' % (namespace_, name_))
2218        else:
2219            write('/>\n')
2220    def exportAttributes(self, write, level, already_processed, namespace_='', name_='volume'):
2221        if self.units is not None and 'units' not in already_processed:
2222            already_processed.append('units')
2223            write(' units=%s' % (quote_attrib(self.units), ))
2224    def exportChildren(self, write, level, namespace_='', name_='volume', fromsubclass_=False):
2225        pass
2226    def hasContent_(self):
2227        if (
2228            self.valueOf_
2229            ):
2230            return True
2231        else:
2232            return False
2233    def build(self, node):
2234        self.__sourcenode__ = node
2235        self.buildAttributes(node, node.attrib, [])
2236        self.valueOf_ = get_all_text_(node)
2237        for child in node:
2238            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
2239            self.buildChildren(child, node, nodeName_)
2240    def buildAttributes(self, node, attrs, already_processed):
2241        value = find_attr_value_('units', node)
2242        if value is not None and 'units' not in already_processed:
2243            already_processed.append('units')
2244            self.units = value
2245            self.validate_VolumeUnitsEnum(self.units)    # validate type VolumeUnitsEnum
2246    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
2247        pass
2248# end class volume
2249
2250
2251class location(GeneratedsSuper):
2252    """Geolocation information for prevalence."""
2253    subclass = None
2254    superclass = None
2255    def __init__(self, type_=None, valueOf_=None):
2256        self.type_ = _cast(None, type_)
2257        self.valueOf_ = valueOf_
2258    def factory(*args_, **kwargs_):
2259        if location.subclass:
2260            return location.subclass(*args_, **kwargs_)
2261        else:
2262            return location(*args_, **kwargs_)
2263    factory = staticmethod(factory)
2264    def get_type(self): return self.type_
2265    def set_type(self, type_): self.type_ = type_
2266    def validate_LocationTypeEnum(self, value):
2267        # Validate type LocationTypeEnum, a restriction on xs:string.
2268        pass
2269    def get_valueOf_(self): return self.valueOf_
2270    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
2271    def export(self, write, level, namespace_='', name_='location', namespacedef_=''):
2272        showIndent(write, level)
2273        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
2274        already_processed = []
2275        self.exportAttributes(write, level, already_processed, namespace_, name_='location')
2276        if self.hasContent_():
2277            write('>')
2278            write(quote_xml(self.valueOf_))
2279            self.exportChildren(write, level + 1, namespace_, name_)
2280            write('</%s%s>\n' % (namespace_, name_))
2281        else:
2282            write('/>\n')
2283    def exportAttributes(self, write, level, already_processed, namespace_='', name_='location'):
2284        if self.type_ is not None and 'type_' not in already_processed:
2285            already_processed.append('type_')
2286            write(' type=%s' % (quote_attrib(self.type_), ))
2287    def exportChildren(self, write, level, namespace_='', name_='location', fromsubclass_=False):
2288        pass
2289    def hasContent_(self):
2290        if (
2291            self.valueOf_
2292            ):
2293            return True
2294        else:
2295            return False
2296    def build(self, node):
2297        self.__sourcenode__ = node
2298        self.buildAttributes(node, node.attrib, [])
2299        self.valueOf_ = get_all_text_(node)
2300        for child in node:
2301            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
2302            self.buildChildren(child, node, nodeName_)
2303    def buildAttributes(self, node, attrs, already_processed):
2304        value = find_attr_value_('type', node)
2305        if value is not None and 'type' not in already_processed:
2306            already_processed.append('type')
2307            self.type_ = value
2308            self.validate_LocationTypeEnum(self.type_)    # validate type LocationTypeEnum
2309    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
2310        pass
2311# end class location
2312
2313
2314class reference(GeneratedsSuper):
2315    """Reference element used to hold xpath expressions to objects, for
2316    example file[@id="12345"]."""
2317    subclass = None
2318    superclass = None
2319    def __init__(self, valueOf_=None):
2320        self.valueOf_ = valueOf_
2321    def factory(*args_, **kwargs_):
2322        if reference.subclass:
2323            return reference.subclass(*args_, **kwargs_)
2324        else:
2325            return reference(*args_, **kwargs_)
2326    factory = staticmethod(factory)
2327    def get_valueOf_(self): return self.valueOf_
2328    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
2329    def export(self, write, level, namespace_='', name_='reference', namespacedef_=''):
2330        showIndent(write, level)
2331        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
2332        already_processed = []
2333        self.exportAttributes(write, level, already_processed, namespace_, name_='reference')
2334        if self.hasContent_():
2335            write('>')
2336            write(quote_xml(self.valueOf_))
2337            self.exportChildren(write, level + 1, namespace_, name_)
2338            write('</%s%s>\n' % (namespace_, name_))
2339        else:
2340            write('/>\n')
2341    def exportAttributes(self, write, level, already_processed, namespace_='', name_='reference'):
2342        pass
2343    def exportChildren(self, write, level, namespace_='', name_='reference', fromsubclass_=False):
2344        pass
2345    def hasContent_(self):
2346        if (
2347            self.valueOf_
2348            ):
2349            return True
2350        else:
2351            return False
2352    def build(self, node):
2353        self.__sourcenode__ = node
2354        self.buildAttributes(node, node.attrib, [])
2355        self.valueOf_ = get_all_text_(node)
2356        for child in node:
2357            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
2358            self.buildChildren(child, node, nodeName_)
2359    def buildAttributes(self, node, attrs, already_processed):
2360        pass
2361    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
2362        pass
2363# end class reference
2364
2365
2366class property(GeneratedsSuper):
2367    """A property."""
2368    subclass = None
2369    superclass = None
2370    def __init__(self, type_=None, valueOf_=None):
2371        self.type_ = _cast(None, type_)
2372        self.valueOf_ = valueOf_
2373    def factory(*args_, **kwargs_):
2374        if property.subclass:
2375            return property.subclass(*args_, **kwargs_)
2376        else:
2377            return property(*args_, **kwargs_)
2378    factory = staticmethod(factory)
2379    def get_type(self): return self.type_
2380    def set_type(self, type_): self.type_ = type_
2381    def validate_PropertyTypeEnum(self, value):
2382        # Validate type PropertyTypeEnum, a restriction on xs:string.
2383        pass
2384    def get_valueOf_(self): return self.valueOf_
2385    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
2386    def export(self, write, level, namespace_='', name_='property', namespacedef_=''):
2387        showIndent(write, level)
2388        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
2389        already_processed = []
2390        self.exportAttributes(write, level, already_processed, namespace_, name_='property')
2391        if self.hasContent_():
2392            write('>')
2393            write(quote_xml(self.valueOf_))
2394            self.exportChildren(write, level + 1, namespace_, name_)
2395            write('</%s%s>\n' % (namespace_, name_))
2396        else:
2397            write('/>\n')
2398    def exportAttributes(self, write, level, already_processed, namespace_='', name_='property'):
2399        if self.type_ is not None and 'type_' not in already_processed:
2400            already_processed.append('type_')
2401            write(' type=%s' % (quote_attrib(self.type_), ))
2402    def exportChildren(self, write, level, namespace_='', name_='property', fromsubclass_=False):
2403        pass
2404    def hasContent_(self):
2405        if (
2406            self.valueOf_
2407            ):
2408            return True
2409        else:
2410            return False
2411    def build(self, node):
2412        self.__sourcenode__ = node
2413        self.buildAttributes(node, node.attrib, [])
2414        self.valueOf_ = get_all_text_(node)
2415        for child in node:
2416            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
2417            self.buildChildren(child, node, nodeName_)
2418    def buildAttributes(self, node, attrs, already_processed):
2419        value = find_attr_value_('type', node)
2420        if value is not None and 'type' not in already_processed:
2421            already_processed.append('type')
2422            self.type_ = value
2423            self.validate_PropertyTypeEnum(self.type_)    # validate type PropertyTypeEnum
2424    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
2425        pass
2426# end class property
2427
2428
2429class objectProperty(GeneratedsSuper):
2430    """Property; a reference to the object, a timestamp and an unbounded
2431    set of properties. This is used to describe extra information
2432    about an object. For example, to show the url parameter strings
2433    associated with a particular URI object. Or to show file names
2434    associated with a particular file. Properties can also be
2435    applied to relationships, by referencing the relationship by id.
2436    This allows use such as e.g. recording the post data sent in an
2437    http request between a malware (file object) and a uri (uri
2438    object)."""
2439    subclass = None
2440    superclass = None
2441    def __init__(self, id=None, references=None, timestamp=None, property=None):
2442        self.id = _cast(None, id)
2443        self.references = references
2444        self.timestamp = timestamp
2445        if property is None:
2446            self.property = []
2447        else:
2448            self.property = property
2449    def factory(*args_, **kwargs_):
2450        if objectProperty.subclass:
2451            return objectProperty.subclass(*args_, **kwargs_)
2452        else:
2453            return objectProperty(*args_, **kwargs_)
2454    factory = staticmethod(factory)
2455    def get_references(self): return self.references
2456    def set_references(self, references): self.references = references
2457    def get_timestamp(self): return self.timestamp
2458    def set_timestamp(self, timestamp): self.timestamp = timestamp
2459    def get_property(self): return self.property
2460    def set_property(self, property): self.property = property
2461    def add_property(self, value): self.property.append(value)
2462    def insert_property(self, index, value): self.property[index] = value
2463    def get_id(self): return self.id
2464    def set_id(self, id): self.id = id
2465    def export(self, write, level, namespace_='', name_='objectProperty', namespacedef_=''):
2466        showIndent(write, level)
2467        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
2468        already_processed = []
2469        self.exportAttributes(write, level, already_processed, namespace_, name_='objectProperty')
2470        if self.hasContent_():
2471            write('>\n')
2472            self.exportChildren(write, level + 1, namespace_, name_)
2473            showIndent(write, level)
2474            write('</%s%s>\n' % (namespace_, name_))
2475        else:
2476            write('/>\n')
2477    def exportAttributes(self, write, level, already_processed, namespace_='', name_='objectProperty'):
2478        if self.id is not None and 'id' not in already_processed:
2479            already_processed.append('id')
2480            write(' id=%s' % (quote_attrib(self.id), ))
2481    def exportChildren(self, write, level, namespace_='', name_='objectProperty', fromsubclass_=False):
2482        if self.references is not None:
2483            self.references.export(write, level, namespace_, name_='references', )
2484        if self.timestamp is not None:
2485            showIndent(write, level)
2486            write('<%stimestamp>%s</%stimestamp>\n' % (namespace_, quote_xml(self.timestamp), namespace_))
2487        for property_ in self.property:
2488            property_.export(write, level, namespace_, name_='property')
2489    def hasContent_(self):
2490        if (
2491            self.references is not None or
2492            self.timestamp is not None or
2493            self.property
2494            ):
2495            return True
2496        else:
2497            return False
2498    def build(self, node):
2499        self.__sourcenode__ = node
2500        self.buildAttributes(node, node.attrib, [])
2501        for child in node:
2502            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
2503            self.buildChildren(child, node, nodeName_)
2504    def buildAttributes(self, node, attrs, already_processed):
2505        value = find_attr_value_('id', node)
2506        if value is not None and 'id' not in already_processed:
2507            already_processed.append('id')
2508            self.id = value
2509    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
2510        if nodeName_ == 'references':
2511            obj_ = references.factory()
2512            obj_.build(child_)
2513            self.set_references(obj_)
2514        elif nodeName_ == 'timestamp':
2515            timestamp_ = child_.text
2516            timestamp_ = self.gds_validate_string(timestamp_, node, 'timestamp')
2517            self.timestamp = timestamp_
2518        elif nodeName_ == 'property':
2519            obj_ = property.factory()
2520            obj_.build(child_)
2521            self.property.append(obj_)
2522# end class objectProperty
2523
2524
2525class relationship(GeneratedsSuper):
2526    """Relationships are used to express relationships between objects, and
2527    dates. Relationships have a type (an attribute with a defined
2528    list of allowed relationships), source (a set of xpath
2529    references to the parent end of the relationship), target (xpath
2530    references to the other end of the relationship) and an optional
2531    date. The linking of objects with types is a powerful way of
2532    describing data. The dates can be used to provide context. For
2533    example, to assign a classification to an object, that can done
2534    with an "isClassifiedAs" relationship, with the date meaning
2535    that that was the data that that classification was assigned. To
2536    show urls and the last visited data, this can be expressed as a
2537    "verifiedBy" relationship between the urls and the entity doing
2538    the verification, with the date interpreted as the verification
2539    date."""
2540    subclass = None
2541    superclass = None
2542    def __init__(self, type_=None, id=None, source=None, target=None, timestamp=None):
2543        self.type_ = _cast(None, type_)
2544        self.id = _cast(None, id)
2545        self.source = source
2546        self.target = target
2547        self.timestamp = timestamp
2548    def factory(*args_, **kwargs_):
2549        if relationship.subclass:
2550            return relationship.subclass(*args_, **kwargs_)
2551        else:
2552            return relationship(*args_, **kwargs_)
2553    factory = staticmethod(factory)
2554    def get_source(self): return self.source
2555    def set_source(self, source): self.source = source
2556    def get_target(self): return self.target
2557    def set_target(self, target): self.target = target
2558    def get_timestamp(self): return self.timestamp
2559    def set_timestamp(self, timestamp): self.timestamp = timestamp
2560    def get_type(self): return self.type_
2561    def set_type(self, type_): self.type_ = type_
2562    def validate_RelationshipTypeEnum(self, value):
2563        # Validate type RelationshipTypeEnum, a restriction on xs:string.
2564        pass
2565    def get_id(self): return self.id
2566    def set_id(self, id): self.id = id
2567    def export(self, write, level, namespace_='', name_='relationship', namespacedef_=''):
2568        showIndent(write, level)
2569        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
2570        already_processed = []
2571        self.exportAttributes(write, level, already_processed, namespace_, name_='relationship')
2572        if self.hasContent_():
2573            write('>\n')
2574            self.exportChildren(write, level + 1, namespace_, name_)
2575            showIndent(write, level)
2576            write('</%s%s>\n' % (namespace_, name_))
2577        else:
2578            write('/>\n')
2579    def exportAttributes(self, write, level, already_processed, namespace_='', name_='relationship'):
2580        if self.type_ is not None and 'type_' not in already_processed:
2581            already_processed.append('type_')
2582            write(' type=%s' % (quote_attrib(self.type_), ))
2583        if self.id is not None and 'id' not in already_processed:
2584            already_processed.append('id')
2585            write(' id=%s' % (quote_attrib(self.id), ))
2586    def exportChildren(self, write, level, namespace_='', name_='relationship', fromsubclass_=False):
2587        if self.source is not None:
2588            self.source.export(write, level, namespace_, name_='source', )
2589        if self.target is not None:
2590            self.target.export(write, level, namespace_, name_='target', )
2591        if self.timestamp is not None:
2592            showIndent(write, level)
2593            write('<%stimestamp>%s</%stimestamp>\n' % (namespace_, quote_xml(self.timestamp), namespace_))
2594    def hasContent_(self):
2595        if (
2596            self.source is not None or
2597            self.target is not None or
2598            self.timestamp is not None
2599            ):
2600            return True
2601        else:
2602            return False
2603    def build(self, node):
2604        self.__sourcenode__ = node
2605        self.buildAttributes(node, node.attrib, [])
2606        for child in node:
2607            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
2608            self.buildChildren(child, node, nodeName_)
2609    def buildAttributes(self, node, attrs, already_processed):
2610        value = find_attr_value_('type', node)
2611        if value is not None and 'type' not in already_processed:
2612            already_processed.append('type')
2613            self.type_ = value
2614            self.validate_RelationshipTypeEnum(self.type_)    # validate type RelationshipTypeEnum
2615        value = find_attr_value_('id', node)
2616        if value is not None and 'id' not in already_processed:
2617            already_processed.append('id')
2618            self.id = value
2619    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
2620        if nodeName_ == 'source':
2621            obj_ = source.factory()
2622            obj_.build(child_)
2623            self.set_source(obj_)
2624        elif nodeName_ == 'target':
2625            obj_ = target.factory()
2626            obj_.build(child_)
2627            self.set_target(obj_)
2628        elif nodeName_ == 'timestamp':
2629            timestamp_ = child_.text
2630            timestamp_ = self.gds_validate_string(timestamp_, node, 'timestamp')
2631            self.timestamp = timestamp_
2632# end class relationship
2633
2634
2635class source(GeneratedsSuper):
2636    """References to objects at the parent end of the relationship."""
2637    subclass = None
2638    superclass = None
2639    def __init__(self, ref=None):
2640        if ref is None:
2641            self.ref = []
2642        else:
2643            self.ref = ref
2644    def factory(*args_, **kwargs_):
2645        if source.subclass:
2646            return source.subclass(*args_, **kwargs_)
2647        else:
2648            return source(*args_, **kwargs_)
2649    factory = staticmethod(factory)
2650    def get_ref(self): return self.ref
2651    def set_ref(self, ref): self.ref = ref
2652    def add_ref(self, value): self.ref.append(value)
2653    def insert_ref(self, index, value): self.ref[index] = value
2654    def export(self, write, level, namespace_='', name_='source', namespacedef_=''):
2655        showIndent(write, level)
2656        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
2657        already_processed = []
2658        self.exportAttributes(write, level, already_processed, namespace_, name_='source')
2659        if self.hasContent_():
2660            write('>\n')
2661            self.exportChildren(write, level + 1, namespace_, name_)
2662            showIndent(write, level)
2663            write('</%s%s>\n' % (namespace_, name_))
2664        else:
2665            write('/>\n')
2666    def exportAttributes(self, write, level, already_processed, namespace_='', name_='source'):
2667        pass
2668    def exportChildren(self, write, level, namespace_='', name_='source', fromsubclass_=False):
2669        for ref_ in self.ref:
2670            ref_.export(write, level, namespace_, name_='ref')
2671    def hasContent_(self):
2672        if (
2673            self.ref
2674            ):
2675            return True
2676        else:
2677            return False
2678    def build(self, node):
2679        self.__sourcenode__ = node
2680        self.buildAttributes(node, node.attrib, [])
2681        for child in node:
2682            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
2683            self.buildChildren(child, node, nodeName_)
2684    def buildAttributes(self, node, attrs, already_processed):
2685        pass
2686    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
2687        if nodeName_ == 'ref':
2688            obj_ = reference.factory()
2689            obj_.build(child_)
2690            self.ref.append(obj_)
2691# end class source
2692
2693
2694class target(GeneratedsSuper):
2695    """References to objects at the child end of the relationship."""
2696    subclass = None
2697    superclass = None
2698    def __init__(self, ref=None):
2699        if ref is None:
2700            self.ref = []
2701        else:
2702            self.ref = ref
2703    def factory(*args_, **kwargs_):
2704        if target.subclass:
2705            return target.subclass(*args_, **kwargs_)
2706        else:
2707            return target(*args_, **kwargs_)
2708    factory = staticmethod(factory)
2709    def get_ref(self): return self.ref
2710    def set_ref(self, ref): self.ref = ref
2711    def add_ref(self, value): self.ref.append(value)
2712    def insert_ref(self, index, value): self.ref[index] = value
2713    def export(self, write, level, namespace_='', name_='target', namespacedef_=''):
2714        showIndent(write, level)
2715        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
2716        already_processed = []
2717        self.exportAttributes(write, level, already_processed, namespace_, name_='target')
2718        if self.hasContent_():
2719            write('>\n')
2720            self.exportChildren(write, level + 1, namespace_, name_)
2721            showIndent(write, level)
2722            write('</%s%s>\n' % (namespace_, name_))
2723        else:
2724            write('/>\n')
2725    def exportAttributes(self, write, level, already_processed, namespace_='', name_='target'):
2726        pass
2727    def exportChildren(self, write, level, namespace_='', name_='target', fromsubclass_=False):
2728        for ref_ in self.ref:
2729            ref_.export(write, level, namespace_, name_='ref')
2730    def hasContent_(self):
2731        if (
2732            self.ref
2733            ):
2734            return True
2735        else:
2736            return False
2737    def build(self, node):
2738        self.__sourcenode__ = node
2739        self.buildAttributes(node, node.attrib, [])
2740        for child in node:
2741            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
2742            self.buildChildren(child, node, nodeName_)
2743    def buildAttributes(self, node, attrs, already_processed):
2744        pass
2745    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
2746        if nodeName_ == 'ref':
2747            obj_ = reference.factory()
2748            obj_.build(child_)
2749            self.ref.append(obj_)
2750# end class target
2751
2752
2753class softwarePackageObject(GeneratedsSuper):
2754    """Software package object, used to store information about a software
2755    package, such as the vendor and version. Intended primarily for
2756    the clean-file metadata sharing use case."""
2757    subclass = None
2758    superclass = None
2759    def __init__(self, id=None, vendor=None, productgroup=None, product=None, version=None, update=None, edition=None, language=None, CPEname=None):
2760        self.id = _cast(None, id)
2761        self.vendor = vendor
2762        self.productgroup = productgroup
2763        self.product = product
2764        self.version = version
2765        self.update = update
2766        self.edition = edition
2767        self.language = language
2768        self.CPEname = CPEname
2769    def factory(*args_, **kwargs_):
2770        if softwarePackageObject.subclass:
2771            return softwarePackageObject.subclass(*args_, **kwargs_)
2772        else:
2773            return softwarePackageObject(*args_, **kwargs_)
2774    factory = staticmethod(factory)
2775    def get_vendor(self): return self.vendor
2776    def set_vendor(self, vendor): self.vendor = vendor
2777    def get_productgroup(self): return self.productgroup
2778    def set_productgroup(self, productgroup): self.productgroup = productgroup
2779    def get_product(self): return self.product
2780    def set_product(self, product): self.product = product
2781    def get_version(self): return self.version
2782    def set_version(self, version): self.version = version
2783    def get_update(self): return self.update
2784    def set_update(self, update): self.update = update
2785    def get_edition(self): return self.edition
2786    def set_edition(self, edition): self.edition = edition
2787    def get_language(self): return self.language
2788    def set_language(self, language): self.language = language
2789    def get_CPEname(self): return self.CPEname
2790    def set_CPEname(self, CPEname): self.CPEname = CPEname
2791    def get_id(self): return self.id
2792    def set_id(self, id): self.id = id
2793    def export(self, write, level, namespace_='', name_='softwarePackageObject', namespacedef_=''):
2794        showIndent(write, level)
2795        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
2796        already_processed = []
2797        self.exportAttributes(write, level, already_processed, namespace_, name_='softwarePackageObject')
2798        if self.hasContent_():
2799            write('>\n')
2800            self.exportChildren(write, level + 1, namespace_, name_)
2801            showIndent(write, level)
2802            write('</%s%s>\n' % (namespace_, name_))
2803        else:
2804            write('/>\n')
2805    def exportAttributes(self, write, level, already_processed, namespace_='', name_='softwarePackageObject'):
2806        if self.id is not None and 'id' not in already_processed:
2807            already_processed.append('id')
2808            write(' id=%s' % (quote_attrib(self.id)))
2809    def exportChildren(self, write, level, namespace_='', name_='softwarePackageObject', fromsubclass_=False):
2810        if self.vendor is not None:
2811            showIndent(write, level)
2812            write('<%svendor>%s</%svendor>\n' % (namespace_, quote_xml(self.vendor), namespace_))
2813        if self.productgroup is not None:
2814            showIndent(write, level)
2815            write('<%sproductgroup>%s</%sproductgroup>\n' % (namespace_, quote_xml(self.productgroup), namespace_))
2816        if self.product is not None:
2817            showIndent(write, level)
2818            write('<%sproduct>%s</%sproduct>\n' % (namespace_, quote_xml(self.product), namespace_))
2819        if self.version is not None:
2820            showIndent(write, level)
2821            write('<%sversion>%s</%sversion>\n' % (namespace_, quote_xml(self.version), namespace_))
2822        if self.update is not None:
2823            showIndent(write, level)
2824            write('<%supdate>%s</%supdate>\n' % (namespace_, quote_xml(self.update), namespace_))
2825        if self.edition is not None:
2826            showIndent(write, level)
2827            write('<%sedition>%s</%sedition>\n' % (namespace_, quote_xml(self.edition), namespace_))
2828        if self.language is not None:
2829            showIndent(write, level)
2830            write('<%slanguage>%s</%slanguage>\n' % (namespace_, quote_xml(self.language), namespace_))
2831        if self.CPEname is not None:
2832            self.CPEname.export(write, level, namespace_, name_='CPEname')
2833    def hasContent_(self):
2834        if (
2835            self.vendor is not None or
2836            self.productgroup is not None or
2837            self.product is not None or
2838            self.version is not None or
2839            self.update is not None or
2840            self.edition is not None or
2841            self.language is not None or
2842            self.CPEname is not None
2843            ):
2844            return True
2845        else:
2846            return False
2847    def build(self, node):
2848        self.__sourcenode__ = node
2849        self.buildAttributes(node, node.attrib, [])
2850        for child in node:
2851            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
2852            self.buildChildren(child, node, nodeName_)
2853    def buildAttributes(self, node, attrs, already_processed):
2854        value = find_attr_value_('id', node)
2855        if value is not None and 'id' not in already_processed:
2856            already_processed.append('id')
2857            self.id = value
2858    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
2859        if nodeName_ == 'vendor':
2860            vendor_ = child_.text
2861            vendor_ = self.gds_validate_string(vendor_, node, 'vendor')
2862            self.vendor = vendor_
2863        elif nodeName_ == 'productgroup':
2864            productgroup_ = child_.text
2865            productgroup_ = self.gds_validate_string(productgroup_, node, 'productgroup')
2866            self.productgroup = productgroup_
2867        elif nodeName_ == 'product':
2868            product_ = child_.text
2869            product_ = self.gds_validate_string(product_, node, 'product')
2870            self.product = product_
2871        elif nodeName_ == 'version':
2872            version_ = child_.text
2873            version_ = self.gds_validate_string(version_, node, 'version')
2874            self.version = version_
2875        elif nodeName_ == 'update':
2876            update_ = child_.text
2877            update_ = self.gds_validate_string(update_, node, 'update')
2878            self.update = update_
2879        elif nodeName_ == 'edition':
2880            edition_ = child_.text
2881            edition_ = self.gds_validate_string(edition_, node, 'edition')
2882            self.edition = edition_
2883        elif nodeName_ == 'language':
2884            language_ = child_.text
2885            language_ = self.gds_validate_string(language_, node, 'language')
2886            self.language = language_
2887        elif nodeName_ == 'CPEname':
2888            obj_ = CPEname.factory()
2889            obj_.build(child_)
2890            self.set_CPEname(obj_)
2891# end class softwarePackageObject
2892
2893
2894class CPEname(GeneratedsSuper):
2895    """The Common Platform Enumeration, or CPE, name of the package if one
2896    exists. CPE is a structured naming scheme for IT systems,
2897    software, and packages. For more information on CPE see
2898    http://cpe.mitre.org. For the official CPE dictionary see
2899    http://nvd.nist.gov/cpe.cfm.The version of CPE that is used for
2900    the name in the CPEname element. As of 10/04/2011 this is 2.2."""
2901    subclass = None
2902    superclass = None
2903    def __init__(self, cpeVersion=None, valueOf_=None):
2904        self.cpeVersion = _cast(None, cpeVersion)
2905        self.valueOf_ = valueOf_
2906    def factory(*args_, **kwargs_):
2907        if CPEname.subclass:
2908            return CPEname.subclass(*args_, **kwargs_)
2909        else:
2910            return CPEname(*args_, **kwargs_)
2911    factory = staticmethod(factory)
2912    def get_cpeVersion(self): return self.cpeVersion
2913    def set_cpeVersion(self, cpeVersion): self.cpeVersion = cpeVersion
2914    def get_valueOf_(self): return self.valueOf_
2915    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
2916    def export(self, write, level, namespace_='', name_='CPEname', namespacedef_=''):
2917        showIndent(write, level)
2918        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
2919        already_processed = []
2920        self.exportAttributes(write, level, already_processed, namespace_, name_='CPEname')
2921        if self.hasContent_():
2922            write('>')
2923            write(quote_xml(self.valueOf_))
2924            self.exportChildren(write, level + 1, namespace_, name_)
2925            write('</%s%s>\n' % (namespace_, name_))
2926        else:
2927            write('/>\n')
2928    def exportAttributes(self, write, level, already_processed, namespace_='', name_='CPEname'):
2929        if self.cpeVersion is not None and 'cpeVersion' not in already_processed:
2930            already_processed.append('cpeVersion')
2931            write(' cpeVersion=%s' % (quote_attrib(self.cpeVersion)))
2932    def exportChildren(self, write, level, namespace_='', name_='CPEname', fromsubclass_=False):
2933        pass
2934    def hasContent_(self):
2935        if (
2936            self.valueOf_
2937            ):
2938            return True
2939        else:
2940            return False
2941    def build(self, node):
2942        self.__sourcenode__ = node
2943        self.buildAttributes(node, node.attrib, [])
2944        self.valueOf_ = get_all_text_(node)
2945        for child in node:
2946            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
2947            self.buildChildren(child, node, nodeName_)
2948    def buildAttributes(self, node, attrs, already_processed):
2949        value = find_attr_value_('cpeVersion', node)
2950        if value is not None and 'cpeVersion' not in already_processed:
2951            already_processed.append('cpeVersion')
2952            self.cpeVersion = value
2953    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
2954        pass
2955# end class CPEname
2956
2957
2958class digitalSignatureObject(GeneratedsSuper):
2959    """Digital signature object, used to hold information about digitally
2960    signed binaries with regards to the certificate used and its
2961    validity."""
2962    subclass = None
2963    superclass = None
2964    def __init__(self, type_=None, id=None, certificateIssuer=None, certificateSubject=None, certificateValidity=None, certificateRevocationTimestamp=None, signingTimestamp=None):
2965        self.type_ = _cast(None, type_)
2966        self.id = _cast(None, id)
2967        self.certificateIssuer = certificateIssuer
2968        self.certificateSubject = certificateSubject
2969        self.certificateValidity = certificateValidity
2970        self.certificateRevocationTimestamp = certificateRevocationTimestamp
2971        self.signingTimestamp = signingTimestamp
2972    def factory(*args_, **kwargs_):
2973        if digitalSignatureObject.subclass:
2974            return digitalSignatureObject.subclass(*args_, **kwargs_)
2975        else:
2976            return digitalSignatureObject(*args_, **kwargs_)
2977    factory = staticmethod(factory)
2978    def get_certificateIssuer(self): return self.certificateIssuer
2979    def set_certificateIssuer(self, certificateIssuer): self.certificateIssuer = certificateIssuer
2980    def get_certificateSubject(self): return self.certificateSubject
2981    def set_certificateSubject(self, certificateSubject): self.certificateSubject = certificateSubject
2982    def get_certificateValidity(self): return self.certificateValidity
2983    def set_certificateValidity(self, certificateValidity): self.certificateValidity = certificateValidity
2984    def get_certificateRevocationTimestamp(self): return self.certificateRevocationTimestamp
2985    def set_certificateRevocationTimestamp(self, certificateRevocationTimestamp): self.certificateRevocationTimestamp = certificateRevocationTimestamp
2986    def get_signingTimestamp(self): return self.signingTimestamp
2987    def set_signingTimestamp(self, signingTimestamp): self.signingTimestamp = signingTimestamp
2988    def get_type(self): return self.type_
2989    def set_type(self, type_): self.type_ = type_
2990    def get_id(self): return self.id
2991    def set_id(self, id): self.id = id
2992    def export(self, write, level, namespace_='', name_='digitalSignatureObject', namespacedef_=''):
2993        showIndent(write, level)
2994        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
2995        already_processed = []
2996        self.exportAttributes(write, level, already_processed, namespace_, name_='digitalSignatureObject')
2997        if self.hasContent_():
2998            write('>\n')
2999            self.exportChildren(write, level + 1, namespace_, name_)
3000            showIndent(write, level)
3001            write('</%s%s>\n' % (namespace_, name_))
3002        else:
3003            write('/>\n')
3004    def exportAttributes(self, write, level, already_processed, namespace_='', name_='digitalSignatureObject'):
3005        if self.type_ is not None and 'type_' not in already_processed:
3006            already_processed.append('type_')
3007            write(' type=%s' % (quote_attrib(self.type_)))
3008        if self.id is not None and 'id' not in already_processed:
3009            already_processed.append('id')
3010            write(' id=%s' % (quote_attrib(self.id)))
3011    def exportChildren(self, write, level, namespace_='', name_='digitalSignatureObject', fromsubclass_=False):
3012        if self.certificateIssuer is not None:
3013            showIndent(write, level)
3014            write('<%scertificateIssuer>%s</%scertificateIssuer>\n' % (namespace_, quote_xml(self.certificateIssuer), namespace_))
3015        if self.certificateSubject is not None:
3016            showIndent(write, level)
3017            write('<%scertificateSubject>%s</%scertificateSubject>\n' % (namespace_, quote_xml(self.certificateSubject), namespace_))
3018        if self.certificateValidity is not None:
3019            showIndent(write, level)
3020            write('<%scertificateValidity>%s</%scertificateValidity>\n' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.certificateValidity)), input_name='certificateValidity'), namespace_))
3021        if self.certificateRevocationTimestamp is not None:
3022            showIndent(write, level)
3023            write('<%scertificateRevocationTimestamp>%s</%scertificateRevocationTimestamp>\n' % (namespace_, quote_xml(self.certificateRevocationTimestamp), namespace_))
3024        if self.signingTimestamp is not None:
3025            self.signingTimestamp.export(write, level, namespace_, name_='signingTimestamp')
3026    def hasContent_(self):
3027        if (
3028            self.certificateIssuer is not None or
3029            self.certificateSubject is not None or
3030            self.certificateValidity is not None or
3031            self.certificateRevocationTimestamp is not None or
3032            self.signingTimestamp is not None
3033            ):
3034            return True
3035        else:
3036            return False
3037    def build(self, node):
3038        self.__sourcenode__ = node
3039        self.buildAttributes(node, node.attrib, [])
3040        for child in node:
3041            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
3042            self.buildChildren(child, node, nodeName_)
3043    def buildAttributes(self, node, attrs, already_processed):
3044        value = find_attr_value_('type', node)
3045        if value is not None and 'type' not in already_processed:
3046            already_processed.append('type')
3047            self.type_ = value
3048        value = find_attr_value_('id', node)
3049        if value is not None and 'id' not in already_processed:
3050            already_processed.append('id')
3051            self.id = value
3052    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
3053        if nodeName_ == 'certificateIssuer':
3054            certificateIssuer_ = child_.text
3055            certificateIssuer_ = self.gds_validate_string(certificateIssuer_, node, 'certificateIssuer')
3056            self.certificateIssuer = certificateIssuer_
3057        elif nodeName_ == 'certificateSubject':
3058            certificateSubject_ = child_.text
3059            certificateSubject_ = self.gds_validate_string(certificateSubject_, node, 'certificateSubject')
3060            self.certificateSubject = certificateSubject_
3061        elif nodeName_ == 'certificateValidity':
3062            sval_ = child_.text
3063            if sval_ in ('true', '1'):
3064                ival_ = True
3065            elif sval_ in ('false', '0'):
3066                ival_ = False
3067            else:
3068                raise_parse_error(child_, 'requires boolean')
3069            ival_ = self.gds_validate_boolean(ival_, node, 'certificateValidity')
3070            self.certificateValidity = ival_
3071        elif nodeName_ == 'certificateRevocationTimestamp':
3072            certificateRevocationTimestamp_ = child_.text
3073            certificateRevocationTimestamp_ = self.gds_validate_string(certificateRevocationTimestamp_, node, 'certificateRevocationTimestamp')
3074            self.certificateRevocationTimestamp = certificateRevocationTimestamp_
3075        elif nodeName_ == 'signingTimestamp':
3076            obj_ = signingTimestamp.factory()
3077            obj_.build(child_)
3078            self.set_signingTimestamp(obj_)
3079# end class digitalSignatureObject
3080
3081
3082class signingTimestamp(GeneratedsSuper):
3083    subclass = None
3084    superclass = None
3085    def __init__(self, valid=None, valueOf_=None):
3086        self.valid = _cast(bool, valid)
3087        self.valueOf_ = valueOf_
3088    def factory(*args_, **kwargs_):
3089        if signingTimestamp.subclass:
3090            return signingTimestamp.subclass(*args_, **kwargs_)
3091        else:
3092            return signingTimestamp(*args_, **kwargs_)
3093    factory = staticmethod(factory)
3094    def get_valid(self): return self.valid
3095    def set_valid(self, valid): self.valid = valid
3096    def get_valueOf_(self): return self.valueOf_
3097    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
3098    def export(self, write, level, namespace_='', name_='signingTimestamp', namespacedef_=''):
3099        showIndent(write, level)
3100        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
3101        already_processed = []
3102        self.exportAttributes(write, level, already_processed, namespace_, name_='signingTimestamp')
3103        if self.hasContent_():
3104            write('>')
3105            write(quote_xml(self.valueOf_))
3106            self.exportChildren(write, level + 1, namespace_, name_)
3107            write('</%s%s>\n' % (namespace_, name_))
3108        else:
3109            write('/>\n')
3110    def exportAttributes(self, write, level, already_processed, namespace_='', name_='signingTimestamp'):
3111        if self.valid is not None and 'valid' not in already_processed:
3112            already_processed.append('valid')
3113            write(' valid="%s"' % self.gds_format_boolean(self.gds_str_lower(str(self.valid)), input_name='valid'))
3114    def exportChildren(self, write, level, namespace_='', name_='signingTimestamp', fromsubclass_=False):
3115        pass
3116    def hasContent_(self):
3117        if (
3118            self.valueOf_
3119            ):
3120            return True
3121        else:
3122            return False
3123    def build(self, node):
3124        self.__sourcenode__ = node
3125        self.buildAttributes(node, node.attrib, [])
3126        self.valueOf_ = get_all_text_(node)
3127        for child in node:
3128            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
3129            self.buildChildren(child, node, nodeName_)
3130    def buildAttributes(self, node, attrs, already_processed):
3131        value = find_attr_value_('valid', node)
3132        if value is not None and 'valid' not in already_processed:
3133            already_processed.append('valid')
3134            if value in ('true', '1'):
3135                self.valid = True
3136            elif value in ('false', '0'):
3137                self.valid = False
3138            else:
3139                raise_parse_error(node, 'Bad boolean attribute')
3140    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
3141        pass
3142# end class signingTimestamp
3143
3144
3145class taggantObject(GeneratedsSuper):
3146    """Taggant object, for use in characterizing the software taggant that
3147    may be associated with a file or multiple files. For more
3148    information on the taggant system or the IEEE Malware Working
3149    Group that created it, please see
3150    http://standards.ieee.org/develop/indconn/icsg/malware.html."""
3151    subclass = None
3152    superclass = None
3153    def __init__(self, id=None, vendorID=None, taggantValidity=None, signingTimestamp=None):
3154        self.id = _cast(None, id)
3155        self.vendorID = vendorID
3156        self.taggantValidity = taggantValidity
3157        self.signingTimestamp = signingTimestamp
3158    def factory(*args_, **kwargs_):
3159        if taggantObject.subclass:
3160            return taggantObject.subclass(*args_, **kwargs_)
3161        else:
3162            return taggantObject(*args_, **kwargs_)
3163    factory = staticmethod(factory)
3164    def get_vendorID(self): return self.vendorID
3165    def set_vendorID(self, vendorID): self.vendorID = vendorID
3166    def get_taggantValidity(self): return self.taggantValidity
3167    def set_taggantValidity(self, taggantValidity): self.taggantValidity = taggantValidity
3168    def get_signingTimestamp(self): return self.signingTimestamp
3169    def set_signingTimestamp(self, signingTimestamp): self.signingTimestamp = signingTimestamp
3170    def get_id(self): return self.id
3171    def set_id(self, id): self.id = id
3172    def export(self, write, level, namespace_='', name_='taggantObject', namespacedef_=''):
3173        showIndent(write, level)
3174        write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
3175        already_processed = []
3176        self.exportAttributes(write, level, already_processed, namespace_, name_='taggantObject')
3177        if self.hasContent_():
3178            write('>\n')
3179            self.exportChildren(write, level + 1, namespace_, name_)
3180            showIndent(write, level)
3181            write('</%s%s>\n' % (namespace_, name_))
3182        else:
3183            write('/>\n')
3184    def exportAttributes(self, write, level, already_processed, namespace_='', name_='taggantObject'):
3185        if self.id is not None and 'id' not in already_processed:
3186            already_processed.append('id')
3187            write(' id=%s' % (quote_attrib(self.id)))
3188    def exportChildren(self, write, level, namespace_='', name_='taggantObject', fromsubclass_=False):
3189        if self.vendorID is not None:
3190            showIndent(write, level)
3191            write('<%svendorID>%s</%svendorID>\n' % (namespace_, quote_xml(self.vendorID), namespace_))
3192        if self.taggantValidity is not None:
3193            showIndent(write, level)
3194            write('<%staggantValidity>%s</%staggantValidity>\n' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.taggantValidity)), input_name='taggantValidity'), namespace_))
3195        if self.signingTimestamp is not None:
3196            self.signingTimestamp.export(write, level, namespace_, name_='signingTimestamp')
3197    def hasContent_(self):
3198        if (
3199            self.vendorID is not None or
3200            self.taggantValidity is not None or
3201            self.signingTimestamp is not None
3202            ):
3203            return True
3204        else:
3205            return False
3206    def build(self, node):
3207        self.__sourcenode__ = node
3208        self.buildAttributes(node, node.attrib, [])
3209        for child in node:
3210            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
3211            self.buildChildren(child, node, nodeName_)
3212    def buildAttributes(self, node, attrs, already_processed):
3213        value = find_attr_value_('id', node)
3214        if value is not None and 'id' not in already_processed:
3215            already_processed.append('id')
3216            self.id = value
3217    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
3218        if nodeName_ == 'vendorID':
3219            vendorID_ = child_.text
3220            vendorID_ = self.gds_validate_string(vendorID_, node, 'vendorID')
3221            self.vendorID = vendorID_
3222        elif nodeName_ == 'taggantValidity':
3223            sval_ = child_.text
3224            if sval_ in ('true', '1'):
3225                ival_ = True
3226            elif sval_ in ('false', '0'):
3227                ival_ = False
3228            else:
3229                raise_parse_error(child_, 'requires boolean')
3230            ival_ = self.gds_validate_boolean(ival_, node, 'taggantValidity')
3231            self.taggantValidity = ival_
3232        elif nodeName_ == 'signingTimestamp':
3233            obj_ = signingTimestamp.factory()
3234            obj_.build(child_)
3235            self.set_signingTimestamp(obj_)
3236# end class taggantObject
3237
3238
3239USAGE_TEXT = """
3240Usage: python <Parser>.py [ -s ] <in_xml_file>
3241"""
3242
3243def usage():
3244    print(USAGE_TEXT)
3245    sys.exit(1)
3246
3247def parse(inFileName):
3248    doc = parsexml_(inFileName)
3249    rootNode = doc.getroot()
3250    rootTag, rootClass = get_root_tag(rootNode)
3251    if rootClass is None:
3252        rootTag = 'malwareMetaData'
3253        rootClass = malwareMetaData
3254    rootObj = rootClass.factory()
3255    rootObj.build(rootNode)
3256    # Enable Python to collect the space used by the DOM.
3257    doc = None
3258    sys.stdout.write('<?xml version="1.0" ?>\n')
3259    rootObj.export(sys.stdout, 0, name_=rootTag,
3260        namespacedef_='')
3261    return rootObj
3262
3263
3264def parseString(inString):
3265    from mixbox.vendor.six import StringIO
3266    doc = parsexml_(StringIO(inString))
3267    rootNode = doc.getroot()
3268    rootTag, rootClass = get_root_tag(rootNode)
3269    if rootClass is None:
3270        rootTag = 'malwareMetaData'
3271        rootClass = malwareMetaData
3272    rootObj = rootClass.factory()
3273    rootObj.build(rootNode)
3274    # Enable Python to collect the space used by the DOM.
3275    doc = None
3276    sys.stdout.write('<?xml version="1.0" ?>\n')
3277    rootObj.export(sys.stdout, 0, name_="malwareMetaData",
3278        namespacedef_='')
3279    return rootObj
3280
3281
3282def parseLiteral(inFileName):
3283    doc = parsexml_(inFileName)
3284    rootNode = doc.getroot()
3285    rootTag, rootClass = get_root_tag(rootNode)
3286    if rootClass is None:
3287        rootTag = 'malwareMetaData'
3288        rootClass = malwareMetaData
3289    rootObj = rootClass.factory()
3290    rootObj.build(rootNode)
3291    # Enable Python to collect the space used by the DOM.
3292    doc = None
3293    sys.stdout.write('#from mmdef import *\n\n')
3294    sys.stdout.write('import mmdef as model_\n\n')
3295    sys.stdout.write('rootObj = model_.rootTag(\n')
3296    rootObj.exportLiteral(sys.stdout, 0, name_=rootTag)
3297    sys.stdout.write(')\n')
3298    return rootObj
3299
3300
3301def main():
3302    args = sys.argv[1:]
3303    if len(args) == 1:
3304        parse(args[0])
3305    else:
3306        usage()
3307
3308
3309if __name__ == '__main__':
3310    #import pdb; pdb.set_trace()
3311    main()
3312
3313
3314__all__ = [
3315    "ASNObject",
3316    "CPEname",
3317    "IPAddress",
3318    "IPObject",
3319    "classificationDetails",
3320    "classificationObject",
3321    "digitalSignatureObject",
3322    "domainObject",
3323    "entityObject",
3324    "extraHash",
3325    "fieldData",
3326    "fieldDataEntry",
3327    "fileObject",
3328    "location",
3329    "malwareMetaData",
3330    "objectProperties",
3331    "objectProperty",
3332    "objects",
3333    "property",
3334    "reference",
3335    "references",
3336    "registryObject",
3337    "relationship",
3338    "relationships",
3339    "signingTimestamp",
3340    "softwarePackageObject",
3341    "source",
3342    "taggantObject",
3343    "target",
3344    "uriObject",
3345    "volume"
3346    ]
3347