1# Copyright (c) 2003-2016 CORE Security Technologies 2# 3# This software is provided under under a slightly modified version 4# of the Apache Software License. See the accompanying LICENSE file 5# for more information. 6# 7# Author: Alberto Solino (@agsolino) 8# 9# Description: 10# [MS-WMI]/[MS-WMIO] : Windows Management Instrumentation Remote Protocol. Partial implementation 11# 12# Best way to learn how to use these calls is to grab the protocol standard 13# so you understand what the call does, and then read the test case located 14# at https://github.com/CoreSecurity/impacket/tree/master/impacket/testcases/SMB_RPC 15# 16# Since DCOM is like an OO RPC, instead of helper functions you will see the 17# classes described in the standards developed. 18# There are test cases for them too. 19# 20from struct import unpack, calcsize, pack 21from functools import partial 22import collections 23import logging 24 25from impacket.dcerpc.v5.ndr import NDRSTRUCT, NDRUniConformantArray, NDRPOINTER, NDRUniConformantVaryingArray, NDRUNION, \ 26 NDRENUM 27from impacket.dcerpc.v5.dcomrt import DCOMCALL, DCOMANSWER, IRemUnknown, PMInterfacePointer, INTERFACE, \ 28 PMInterfacePointer_ARRAY, BYTE_ARRAY, PPMInterfacePointer, OBJREF_CUSTOM 29from impacket.dcerpc.v5.dcom.oaut import BSTR 30from impacket.dcerpc.v5.dtypes import ULONG, DWORD, NULL, LPWSTR, LONG, HRESULT, PGUID, LPCSTR, GUID 31from impacket.dcerpc.v5.enum import Enum 32from impacket.dcerpc.v5.rpcrt import DCERPCException 33from impacket import hresult_errors, LOG 34from impacket.uuid import string_to_bin, uuidtup_to_bin 35from impacket.structure import Structure 36 37 38def format_structure(d, level=0): 39 x = "" 40 if isinstance(d, collections.Mapping): 41 lenk = max(map(lambda x: len(str(x)), d.keys())) 42 for k, v in d.items(): 43 key_text = "\n" + " "*level + " "*(lenk - len(str(k))) + str(k) 44 x += key_text + ": " + format_structure(v, level=level+lenk) 45 elif isinstance(d, collections.Iterable) and not isinstance(d, basestring): 46 for e in d: 47 x += "\n" + " "*level + "- " + format_structure(e, level=level+4) 48 else: 49 x = str(d) 50 return x 51try: 52 from collections import OrderedDict 53except: 54 try: 55 from ordereddict.ordereddict import OrderedDict 56 except: 57 from ordereddict import OrderedDict 58 59class DCERPCSessionError(DCERPCException): 60 def __init__(self, error_string=None, error_code=None, packet=None): 61 DCERPCException.__init__(self, error_string, error_code, packet) 62 63 def __str__( self ): 64 if hresult_errors.ERROR_MESSAGES.has_key(self.error_code): 65 error_msg_short = hresult_errors.ERROR_MESSAGES[self.error_code][0] 66 error_msg_verbose = hresult_errors.ERROR_MESSAGES[self.error_code][1] 67 return 'WMI SessionError: code: 0x%x - %s - %s' % (self.error_code, error_msg_short, error_msg_verbose) 68 else: 69 # Let's see if we have it as WBEMSTATUS 70 try: 71 return 'WMI Session Error: code: 0x%x - %s' % (self.error_code, WBEMSTATUS.enumItems(self.error_code).name) 72 except: 73 return 'WMI SessionError: unknown error code: 0x%x' % self.error_code 74 75################################################################################ 76# WMIO Structures and Constants 77################################################################################ 78WBEM_FLAVOR_FLAG_PROPAGATE_O_INSTANCE = 0x01 79WBEM_FLAVOR_FLAG_PROPAGATE_O_DERIVED_CLASS = 0x02 80WBEM_FLAVOR_NOT_OVERRIDABLE = 0x10 81WBEM_FLAVOR_ORIGIN_PROPAGATED = 0x20 82WBEM_FLAVOR_ORIGIN_SYSTEM = 0x40 83WBEM_FLAVOR_AMENDED = 0x80 84 85# 2.2.6 ObjectFlags 86OBJECT_FLAGS = 'B=0' 87 88#2.2.77 Signature 89SIGNATURE = '<L=0x12345678' 90 91# 2.2.4 ObjectEncodingLength 92OBJECT_ENCODING_LENGTH = '<L=0' 93 94# 2.2.73 EncodingLength 95ENCODING_LENGTH = '<L=0' 96 97# 2.2.78 Encoded-String 98ENCODED_STRING_FLAG = 'B=0' 99 100# 2.2.76 ReservedOctet 101RESERVED_OCTET = 'B=0' 102 103# 2.2.28 NdTableValueTableLength 104NDTABLE_VALUE_TABLE_LENGTH = '<L=0' 105 106# 2.2.80 DictionaryReference 107DICTIONARY_REFERENCE = { 108 0 : '"', 109 1 : 'key', 110 2 : 'NADA', 111 3 : 'read', 112 4 : 'write', 113 5 : 'volatile', 114 6 : 'provider', 115 7 : 'dynamic', 116 8 : 'cimwin32', 117 9 : 'DWORD', 118 10 : 'CIMTYPE', 119} 120 121class ENCODED_STRING(Structure): 122 commonHdr = ( 123 ('Encoded_String_Flag', ENCODED_STRING_FLAG), 124 ) 125 126 tascii = ( 127 ('Character', 'z'), 128 ) 129 130 tunicode = ( 131 ('Character', 'u'), 132 ) 133 134 def __init__(self, data = None, alignment = 0): 135 Structure.__init__(self, data, alignment) 136 if data is not None: 137 # Let's first check the commonHdr 138 self.fromString(data) 139 self.structure = () 140 self.isUnicode = False 141 if len(data) > 1: 142 if self['Encoded_String_Flag'] == 0: 143 self.structure += self.tascii 144 # Let's search for the end of the string 145 index = data[1:].find('\x00') 146 data = data[:index+1+1] 147 else: 148 self.structure = self.tunicode 149 self.isUnicode = True 150 151 self.fromString(data) 152 else: 153 self.structure = self.tascii 154 self.data = None 155 156 def __getitem__(self, key): 157 if key == 'Character' and self.isUnicode: 158 return self.fields['Character'].decode('utf-16le') 159 return Structure.__getitem__(self, key) 160 161 162# 2.2.8 DecServerName 163DEC_SERVER_NAME = ENCODED_STRING 164 165# 2.2.9 DecNamespaceName 166DEC_NAMESPACE_NAME = ENCODED_STRING 167 168# 2.2.7 Decoration 169class DECORATION(Structure): 170 structure = ( 171 ('DecServerName', ':', DEC_SERVER_NAME), 172 ('DecNamespaceName', ':', DEC_NAMESPACE_NAME), 173 ) 174 175# 2.2.69 HeapRef 176HEAPREF = '<L=0' 177 178# 2.2.68 HeapStringRef 179HEAP_STRING_REF = HEAPREF 180 181# 2.2.19 ClassNameRef 182CLASS_NAME_REF = HEAP_STRING_REF 183 184# 2.2.16 ClassHeader 185class CLASS_HEADER(Structure): 186 structure = ( 187 ('EncodingLength', ENCODING_LENGTH), 188 ('ReservedOctet', RESERVED_OCTET), 189 ('ClassNameRef', CLASS_NAME_REF), 190 ('NdTableValueTableLength', NDTABLE_VALUE_TABLE_LENGTH), 191 ) 192 193# 2.2.17 DerivationList 194class DERIVATION_LIST(Structure): 195 structure = ( 196 ('EncodingLength', ENCODING_LENGTH), 197 ('_ClassNameEncoding','_-ClassNameEncoding', 'self["EncodingLength"]-4'), 198 ('ClassNameEncoding', ':'), 199 ) 200 201# 2.2.82 CimType 202CIM_TYPE = '<L=0' 203CIM_ARRAY_FLAG = 0x2000 204 205class EnumType(type): 206 def __getattr__(self, attr): 207 return self.enumItems[attr].value 208 209class CIM_TYPE_ENUM(Enum): 210# __metaclass__ = EnumType 211 CIM_TYPE_SINT8 = 16 212 CIM_TYPE_UINT8 = 17 213 CIM_TYPE_SINT16 = 2 214 CIM_TYPE_UINT16 = 18 215 CIM_TYPE_SINT32 = 3 216 CIM_TYPE_UINT32 = 19 217 CIM_TYPE_SINT64 = 20 218 CIM_TYPE_UINT64 = 21 219 CIM_TYPE_REAL32 = 4 220 CIM_TYPE_REAL64 = 5 221 CIM_TYPE_BOOLEAN = 11 222 CIM_TYPE_STRING = 8 223 CIM_TYPE_DATETIME = 101 224 CIM_TYPE_REFERENCE = 102 225 CIM_TYPE_CHAR16 = 103 226 CIM_TYPE_OBJECT = 13 227 CIM_ARRAY_SINT8 = 8208 228 CIM_ARRAY_UINT8 = 8209 229 CIM_ARRAY_SINT16 = 8194 230 CIM_ARRAY_UINT16 = 8210 231 CIM_ARRAY_SINT32 = 8195 232 CIM_ARRAY_UINT32 = 8201 233 CIM_ARRAY_SINT64 = 8202 234 CIM_ARRAY_UINT64 = 8203 235 CIM_ARRAY_REAL32 = 8196 236 CIM_ARRAY_REAL64 = 8197 237 CIM_ARRAY_BOOLEAN = 8203 238 CIM_ARRAY_STRING = 8200 239 CIM_ARRAY_DATETIME = 8293 240 CIM_ARRAY_REFERENCE = 8294 241 CIM_ARRAY_CHAR16 = 8295 242 CIM_ARRAY_OBJECT = 8205 243 244CIM_TYPES_REF = { 245 CIM_TYPE_ENUM.CIM_TYPE_SINT8.value : 'b=0', 246 CIM_TYPE_ENUM.CIM_TYPE_UINT8.value : 'B=0', 247 CIM_TYPE_ENUM.CIM_TYPE_SINT16.value : '<h=0', 248 CIM_TYPE_ENUM.CIM_TYPE_UINT16.value : '<H=0', 249 CIM_TYPE_ENUM.CIM_TYPE_SINT32.value : '<l=0', 250 CIM_TYPE_ENUM.CIM_TYPE_UINT32.value : '<L=0', 251 CIM_TYPE_ENUM.CIM_TYPE_SINT64.value : '<q=0', 252 CIM_TYPE_ENUM.CIM_TYPE_UINT64.value : '<Q=0', 253 CIM_TYPE_ENUM.CIM_TYPE_REAL32.value : '<f=0', 254 CIM_TYPE_ENUM.CIM_TYPE_REAL64.value : '<d=0', 255 CIM_TYPE_ENUM.CIM_TYPE_BOOLEAN.value : '<H=0', 256 CIM_TYPE_ENUM.CIM_TYPE_STRING.value : HEAPREF, 257 CIM_TYPE_ENUM.CIM_TYPE_DATETIME.value : HEAPREF, 258 CIM_TYPE_ENUM.CIM_TYPE_REFERENCE.value: HEAPREF, 259 CIM_TYPE_ENUM.CIM_TYPE_CHAR16.value : '<H=0', 260 CIM_TYPE_ENUM.CIM_TYPE_OBJECT.value : HEAPREF, 261} 262 263CIM_TYPE_TO_NAME = { 264 CIM_TYPE_ENUM.CIM_TYPE_SINT8.value : 'sint8', 265 CIM_TYPE_ENUM.CIM_TYPE_UINT8.value : 'uint8', 266 CIM_TYPE_ENUM.CIM_TYPE_SINT16.value : 'sint16', 267 CIM_TYPE_ENUM.CIM_TYPE_UINT16.value : 'uint16', 268 CIM_TYPE_ENUM.CIM_TYPE_SINT32.value : 'sint32', 269 CIM_TYPE_ENUM.CIM_TYPE_UINT32.value : 'uint32', 270 CIM_TYPE_ENUM.CIM_TYPE_SINT64.value : 'sint64', 271 CIM_TYPE_ENUM.CIM_TYPE_UINT64.value : 'uint64', 272 CIM_TYPE_ENUM.CIM_TYPE_REAL32.value : 'real32', 273 CIM_TYPE_ENUM.CIM_TYPE_REAL64.value : 'real64', 274 CIM_TYPE_ENUM.CIM_TYPE_BOOLEAN.value : 'bool', 275 CIM_TYPE_ENUM.CIM_TYPE_STRING.value : 'string', 276 CIM_TYPE_ENUM.CIM_TYPE_DATETIME.value : 'datetime', 277 CIM_TYPE_ENUM.CIM_TYPE_REFERENCE.value: 'reference', 278 CIM_TYPE_ENUM.CIM_TYPE_CHAR16.value : 'char16', 279 CIM_TYPE_ENUM.CIM_TYPE_OBJECT.value : 'object', 280} 281 282# 2.2.61 QualifierName 283QUALIFIER_NAME = HEAP_STRING_REF 284 285# 2.2.62 QualifierFlavor 286QUALIFIER_FLAVOR = 'B=0' 287 288# 2.2.63 QualifierType 289QUALIFIER_TYPE = CIM_TYPE 290 291# 2.2.71 EncodedValue 292class ENCODED_VALUE(Structure): 293 structure = ( 294 ('QualifierName', QUALIFIER_NAME), 295 ) 296 297 @classmethod 298 def getValue(cls, cimType, entry, heap): 299 # Let's get the default Values 300 pType = cimType & (~(CIM_ARRAY_FLAG|Inherited)) 301 302 if entry != 0xffffffff: 303 heapData = heap[entry:] 304 if cimType & CIM_ARRAY_FLAG: 305 # We have an array, let's set the right unpackStr and dataSize for the array contents 306 dataSize = calcsize(HEAPREF[:-2]) 307 numItems = unpack(HEAPREF[:-2], heapData[:dataSize])[0] 308 heapData = heapData[dataSize:] 309 array = list() 310 unpackStrArray = CIM_TYPES_REF[pType][:-2] 311 dataSizeArray = calcsize(unpackStrArray) 312 if cimType == CIM_TYPE_ENUM.CIM_ARRAY_STRING.value: 313 # We have an array of strings 314 # First items are DWORDs with the string pointers 315 # inside the heap. We don't need those ones 316 heapData = heapData[4*numItems:] 317 # Let's now grab the strings 318 for _ in range(numItems): 319 item = ENCODED_STRING(heapData) 320 array.append(item['Character']) 321 heapData = heapData[len(str(item)):] 322 elif cimType == CIM_TYPE_ENUM.CIM_ARRAY_OBJECT.value: 323 # Discard the pointers 324 heapData = heapData[dataSize*numItems:] 325 for item in range(numItems): 326 msb = METHOD_SIGNATURE_BLOCK(heapData) 327 unit = ENCODING_UNIT() 328 unit['ObjectEncodingLength'] = msb['EncodingLength'] 329 unit['ObjectBlock'] = msb['ObjectBlock'] 330 array.append(unit) 331 heapData = heapData[msb['EncodingLength']+4:] 332 else: 333 for item in range(numItems): 334 # ToDo: Learn to unpack the rest of the array of things 335 array.append(unpack(unpackStrArray, heapData[:dataSizeArray])[0]) 336 heapData = heapData[dataSizeArray:] 337 value = array 338 elif pType == CIM_TYPE_ENUM.CIM_TYPE_BOOLEAN.value: 339 if entry == 0xffff: 340 value = 'True' 341 else: 342 value = 'False' 343 elif pType == CIM_TYPE_ENUM.CIM_TYPE_OBJECT.value: 344 # If the value type is CIM-TYPE-OBJECT, the EncodedValue is a HeapRef to the object encoded as an 345 # ObjectEncodingLength (section 2.2.4) followed by an ObjectBlock (section 2.2.5). 346 347 # ToDo: This is a hack.. We should parse this better. We need to have an ENCODING_UNIT. 348 # I'm going through a METHOD_SIGNATURE_BLOCK first just to parse the ObjectBlock 349 msb = METHOD_SIGNATURE_BLOCK(heapData) 350 unit = ENCODING_UNIT() 351 unit['ObjectEncodingLength'] = msb['EncodingLength'] 352 unit['ObjectBlock'] = msb['ObjectBlock'] 353 value = unit 354 elif pType not in (CIM_TYPE_ENUM.CIM_TYPE_STRING.value, CIM_TYPE_ENUM.CIM_TYPE_DATETIME.value, 355 CIM_TYPE_ENUM.CIM_TYPE_REFERENCE.value): 356 value = entry 357 else: 358 value = ENCODED_STRING(heapData)['Character'] 359 360 return value 361 362# 2.2.64 QualifierValue 363QUALIFIER_VALUE = ENCODED_VALUE 364 365# 2.2.60 Qualifier 366class QUALIFIER(Structure): 367 commonHdr = ( 368 ('QualifierName', QUALIFIER_NAME), 369 ('QualifierFlavor', QUALIFIER_FLAVOR), 370 ('QualifierType', QUALIFIER_TYPE), 371 ) 372 def __init__(self, data = None, alignment = 0): 373 Structure.__init__(self, data, alignment) 374 if data is not None: 375 # Let's first check the commonHdr 376 self.fromString(data) 377 self.structure = (('QualifierValue', CIM_TYPES_REF[self["QualifierType"] & (~CIM_ARRAY_FLAG)]),) 378 self.fromString(data) 379 else: 380 self.data = None 381 382# 2.2.59 QualifierSet 383class QUALIFIER_SET(Structure): 384 structure = ( 385 ('EncodingLength', ENCODING_LENGTH), 386 ('_Qualifier','_-Qualifier', 'self["EncodingLength"]-4'), 387 ('Qualifier', ':'), 388 ) 389 390 def getQualifiers(self, heap): 391 data = self['Qualifier'] 392 qualifiers = dict() 393 while len(data) > 0: 394 itemn = QUALIFIER(data) 395 if itemn['QualifierName'] == 0xffffffff: 396 qName = '' 397 elif itemn['QualifierName'] & 0x80000000: 398 qName = DICTIONARY_REFERENCE[itemn['QualifierName'] & 0x7fffffff] 399 else: 400 qName = ENCODED_STRING(heap[itemn['QualifierName']:])['Character'] 401 402 value = ENCODED_VALUE.getValue(itemn['QualifierType'], itemn['QualifierValue'], heap) 403 qualifiers[qName] = value 404 data = data[len(itemn):] 405 406 return qualifiers 407 408# 2.2.20 ClassQualifierSet 409CLASS_QUALIFIER_SET = QUALIFIER_SET 410 411# 2.2.22 PropertyCount 412PROPERTY_COUNT = '<L=0' 413 414# 2.2.24 PropertyNameRef 415PROPERTY_NAME_REF = HEAP_STRING_REF 416 417# 2.2.25 PropertyInfoRef 418PROPERTY_INFO_REF = HEAPREF 419 420# 2.2.23 PropertyLookup 421class PropertyLookup(Structure): 422 structure = ( 423 ('PropertyNameRef', PROPERTY_NAME_REF), 424 ('PropertyInfoRef', PROPERTY_INFO_REF), 425 ) 426 427# 2.2.31 PropertyType 428PROPERTY_TYPE = '<L=0' 429 430# 2.2.33 DeclarationOrder 431DECLARATION_ORDER = '<H=0' 432 433# 2.2.34 ValueTableOffset 434VALUE_TABLE_OFFSET = '<L=0' 435 436# 2.2.35 ClassOfOrigin 437CLASS_OF_ORIGIN = '<L=0' 438 439# 2.2.36 PropertyQualifierSet 440PROPERTY_QUALIFIER_SET = QUALIFIER_SET 441 442# 2.2.30 PropertyInfo 443class PROPERTY_INFO(Structure): 444 structure = ( 445 ('PropertyType', PROPERTY_TYPE), 446 ('DeclarationOrder', DECLARATION_ORDER), 447 ('ValueTableOffset', VALUE_TABLE_OFFSET), 448 ('ClassOfOrigin', CLASS_OF_ORIGIN), 449 ('PropertyQualifierSet', ':', PROPERTY_QUALIFIER_SET), 450 ) 451 452# 2.2.32 Inherited 453Inherited = 0x4000 454 455# 2.2.21 PropertyLookupTable 456class PROPERTY_LOOKUP_TABLE(Structure): 457 PropertyLookupSize = len(PropertyLookup()) 458 structure = ( 459 ('PropertyCount', PROPERTY_COUNT), 460 ('_PropertyLookup','_-PropertyLookup', 'self["PropertyCount"]*self.PropertyLookupSize'), 461 ('PropertyLookup', ':'), 462 ) 463 464 def getProperties(self, heap): 465 propTable = self['PropertyLookup'] 466 properties = dict() 467 for property in range(self['PropertyCount']): 468 propItemDict = dict() 469 propItem = PropertyLookup(propTable) 470 if propItem['PropertyNameRef'] & 0x80000000: 471 propName = DICTIONARY_REFERENCE[propItem['PropertyNameRef'] & 0x7fffffff] 472 else: 473 propName = ENCODED_STRING(heap[propItem['PropertyNameRef']:])['Character'] 474 propInfo = PROPERTY_INFO(heap[propItem['PropertyInfoRef']:]) 475 pType = propInfo['PropertyType'] 476 pType &= (~CIM_ARRAY_FLAG) 477 pType &= (~Inherited) 478 sType = CIM_TYPE_TO_NAME[pType] 479 480 propItemDict['stype'] = sType 481 propItemDict['name'] = propName 482 propItemDict['type'] = propInfo['PropertyType'] 483 propItemDict['order'] = propInfo['DeclarationOrder'] 484 propItemDict['inherited'] = propInfo['PropertyType'] & Inherited 485 propItemDict['value'] = None 486 487 qualifiers = dict() 488 qualifiersBuf = propInfo['PropertyQualifierSet']['Qualifier'] 489 while len(qualifiersBuf) > 0: 490 record = QUALIFIER(qualifiersBuf) 491 if record['QualifierName'] & 0x80000000: 492 qualifierName = DICTIONARY_REFERENCE[record['QualifierName'] & 0x7fffffff] 493 else: 494 qualifierName = ENCODED_STRING(heap[record['QualifierName']:])['Character'] 495 qualifierValue = ENCODED_VALUE.getValue(record['QualifierType'], record['QualifierValue'], heap) 496 qualifiersBuf = qualifiersBuf[len(record):] 497 qualifiers[qualifierName] = qualifierValue 498 499 propItemDict['qualifiers'] = qualifiers 500 properties[propName] = propItemDict 501 502 propTable = propTable[self.PropertyLookupSize:] 503 504 return OrderedDict(sorted(properties.items(), key=lambda x:x[1]['order'])) 505 #return properties 506 507# 2.2.66 Heap 508HEAP_LENGTH = '<L=0' 509 510class HEAP(Structure): 511 structure = ( 512 ('HeapLength', HEAP_LENGTH), 513 # HeapLength is a 32-bit value with the most significant bit always set 514 # (using little-endian binary encoding for the 32-bit value), so that the 515 # length is actually only 31 bits. 516 ('_HeapItem','_-HeapItem', 'self["HeapLength"]&0x7fffffff'), 517 ('HeapItem', ':'), 518 ) 519 520# 2.2.37 ClassHeap 521CLASS_HEAP = HEAP 522 523# 2.2.15 ClassPart 524class CLASS_PART(Structure): 525 commonHdr = ( 526 ('ClassHeader', ':', CLASS_HEADER), 527 ('DerivationList', ':', DERIVATION_LIST), 528 ('ClassQualifierSet', ':', CLASS_QUALIFIER_SET), 529 ('PropertyLookupTable', ':', PROPERTY_LOOKUP_TABLE), 530 ('_NdTable_ValueTable','_-NdTable_ValueTable', 'self["ClassHeader"]["NdTableValueTableLength"]'), 531 ('NdTable_ValueTable',':'), 532 ('ClassHeap', ':', CLASS_HEAP), 533 ('_Garbage', '_-Garbage', 'self["ClassHeader"]["EncodingLength"]-len(self)'), 534 ('Garbage', ':=""'), 535 ) 536 def getQualifiers(self): 537 return self["ClassQualifierSet"].getQualifiers(self["ClassHeap"]["HeapItem"]) 538 539 def getProperties(self): 540 heap = self["ClassHeap"]["HeapItem"] 541 properties = self["PropertyLookupTable"].getProperties(self["ClassHeap"]["HeapItem"]) 542 sorted_props = sorted(properties.keys(), key=lambda k: properties[k]['order']) 543 valueTableOff = (len(properties) - 1) / 4 + 1 544 valueTable = self['NdTable_ValueTable'][valueTableOff:] 545 for key in sorted_props: 546 # Let's get the default Values 547 pType = properties[key]['type'] & (~(CIM_ARRAY_FLAG|Inherited)) 548 if properties[key]['type'] & CIM_ARRAY_FLAG: 549 unpackStr = HEAPREF[:-2] 550 else: 551 unpackStr = CIM_TYPES_REF[pType][:-2] 552 dataSize = calcsize(unpackStr) 553 try: 554 itemValue = unpack(unpackStr, valueTable[:dataSize])[0] 555 except: 556 LOG.error("getProperties: Error unpacking!!") 557 itemValue = 0xffffffff 558 559 if itemValue != 0xffffffff and itemValue > 0: 560 value = ENCODED_VALUE.getValue(properties[key]['type'], itemValue, heap) 561 properties[key]['value'] = "%s" % value 562 valueTable = valueTable[dataSize:] 563 return properties 564 565# 2.2.39 MethodCount 566METHOD_COUNT = '<H=0' 567 568# 2.2.40 MethodCountPadding 569METHOD_COUNT_PADDING = '<H=0' 570 571# 2.2.42 MethodName 572METHOD_NAME = HEAP_STRING_REF 573 574# 2.2.43 MethodFlags 575METHOD_FLAGS = 'B=0' 576 577# 2.2.44 MethodPadding 578METHOD_PADDING = "3s=''" 579 580# 2.2.45 MethodOrigin 581METHOD_ORIGIN = '<L=0' 582 583# 2.2.47 HeapQualifierSetRef 584HEAP_QUALIFIER_SET_REF = HEAPREF 585 586# 2.2.46 MethodQualifiers 587METHOD_QUALIFIERS = HEAP_QUALIFIER_SET_REF 588 589# 2.2.51 HeapMethodSignatureBlockRef 590HEAP_METHOD_SIGNATURE_BLOCK_REF = HEAPREF 591 592# 2.2.50 MethodSignature 593METHOD_SIGNATURE = HEAP_METHOD_SIGNATURE_BLOCK_REF 594 595# 2.2.48 InputSignature 596INPUT_SIGNATURE = METHOD_SIGNATURE 597 598# 2.2.49 OutputSignature 599OUTPUT_SIGNATURE = METHOD_SIGNATURE 600 601# 2.2.52 MethodHeap 602METHOD_HEAP = HEAP 603 604# 2.2.41 MethodDescription 605class METHOD_DESCRIPTION(Structure): 606 structure = ( 607 ('MethodName',METHOD_NAME), 608 ('MethodFlags', METHOD_FLAGS), 609 ('MethodPadding', METHOD_PADDING), 610 ('MethodOrigin', METHOD_ORIGIN), 611 ('MethodQualifiers', METHOD_QUALIFIERS), 612 ('InputSignature', INPUT_SIGNATURE), 613 ('OutputSignature', OUTPUT_SIGNATURE), 614 ) 615 616# 2.2.38 MethodsPart 617class METHODS_PART(Structure): 618 MethodDescriptionSize = len(METHOD_DESCRIPTION()) 619 structure = ( 620 ('EncodingLength',ENCODING_LENGTH), 621 ('MethodCount', METHOD_COUNT), 622 ('MethodCountPadding', METHOD_COUNT_PADDING), 623 ('_MethodDescription', '_-MethodDescription', 'self["MethodCount"]*self.MethodDescriptionSize'), 624 ('MethodDescription', ':'), 625 ('MethodHeap', ':', METHOD_HEAP), 626 ) 627 628 def getMethods(self): 629 methods = OrderedDict() 630 data = self['MethodDescription'] 631 heap = self['MethodHeap']['HeapItem'] 632 633 for method in range(self['MethodCount']): 634 methodDict = OrderedDict() 635 itemn = METHOD_DESCRIPTION(data) 636 if itemn['MethodFlags'] & WBEM_FLAVOR_ORIGIN_PROPAGATED: 637 # ToDo 638 #print "WBEM_FLAVOR_ORIGIN_PROPAGATED not yet supported!" 639 #raise 640 pass 641 methodDict['name'] = ENCODED_STRING(heap[itemn['MethodName']:])['Character'] 642 methodDict['origin'] = itemn['MethodOrigin'] 643 if itemn['MethodQualifiers'] != 0xffffffff: 644 # There are qualifiers 645 qualifiersSet = QUALIFIER_SET(heap[itemn['MethodQualifiers']:]) 646 qualifiers = qualifiersSet.getQualifiers(heap) 647 methodDict['qualifiers'] = qualifiers 648 if itemn['InputSignature'] != 0xffffffff: 649 inputSignature = METHOD_SIGNATURE_BLOCK(heap[itemn['InputSignature']:]) 650 if inputSignature['EncodingLength'] > 0: 651 methodDict['InParams'] = inputSignature['ObjectBlock']['ClassType']['CurrentClass'].getProperties() 652 methodDict['InParamsRaw'] = inputSignature['ObjectBlock'] 653 #print methodDict['InParams'] 654 else: 655 methodDict['InParams'] = None 656 if itemn['OutputSignature'] != 0xffffffff: 657 outputSignature = METHOD_SIGNATURE_BLOCK(heap[itemn['OutputSignature']:]) 658 if outputSignature['EncodingLength'] > 0: 659 methodDict['OutParams'] = outputSignature['ObjectBlock']['ClassType']['CurrentClass'].getProperties() 660 methodDict['OutParamsRaw'] = outputSignature['ObjectBlock'] 661 else: 662 methodDict['OutParams'] = None 663 data = data[len(itemn):] 664 methods[methodDict['name']] = methodDict 665 666 return methods 667 668# 2.2.14 ClassAndMethodsPart 669class CLASS_AND_METHODS_PART(Structure): 670 structure = ( 671 ('ClassPart', ':', CLASS_PART), 672 ('MethodsPart', ':', METHODS_PART), 673 ) 674 675 def getClassName(self): 676 pClassName = self['ClassPart']['ClassHeader']['ClassNameRef'] 677 cHeap = self['ClassPart']['ClassHeap']['HeapItem'] 678 if pClassName == 0xffffffff: 679 return 'None' 680 else: 681 className = ENCODED_STRING(cHeap[pClassName:])['Character'] 682 derivationList = self['ClassPart']['DerivationList']['ClassNameEncoding'] 683 while len(derivationList) > 0: 684 superClass = ENCODED_STRING(derivationList)['Character'] 685 className += ' : %s ' % superClass 686 derivationList = derivationList[len(ENCODED_STRING(derivationList))+4:] 687 return className 688 689 def getQualifiers(self): 690 return self["ClassPart"].getQualifiers() 691 692 def getProperties(self): 693 #print format_structure(self["ClassPart"].getProperties()) 694 return self["ClassPart"].getProperties() 695 696 def getMethods(self): 697 return self["MethodsPart"].getMethods() 698 699# 2.2.13 CurrentClass 700CURRENT_CLASS = CLASS_AND_METHODS_PART 701 702# 2.2.54 InstanceFlags 703INSTANCE_FLAGS = 'B=0' 704 705# 2.2.55 InstanceClassName 706INSTANCE_CLASS_NAME = HEAP_STRING_REF 707 708# 2.2.27 NullAndDefaultFlag 709NULL_AND_DEFAULT_FLAG = 'B=0' 710 711# 2.2.26 NdTable 712NDTABLE = NULL_AND_DEFAULT_FLAG 713 714# 2.2.56 InstanceData 715#InstanceData = ValueTable 716 717class CURRENT_CLASS_NO_METHODS(CLASS_AND_METHODS_PART): 718 structure = ( 719 ('ClassPart', ':', CLASS_PART), 720 ) 721 def getMethods(self): 722 return () 723 724# 2.2.65 InstancePropQualifierSet 725INST_PROP_QUAL_SET_FLAG = 'B=0' 726class INSTANCE_PROP_QUALIFIER_SET(Structure): 727 commonHdr = ( 728 ('InstPropQualSetFlag', INST_PROP_QUAL_SET_FLAG), 729 ) 730 tail = ( 731 # ToDo: this is wrong.. this should be an array of QualifierSet, see documentation 732 #('QualifierSet', ':', QualifierSet), 733 ('QualifierSet', ':', QUALIFIER_SET), 734 ) 735 736 def __init__(self, data = None, alignment = 0): 737 Structure.__init__(self, data, alignment) 738 self.structure = () 739 if data is not None: 740 # Let's first check the commonHdr 741 self.fromString(data) 742 if self['InstPropQualSetFlag'] == 2: 743 # We don't support this yet! 744 raise Exception("self['InstPropQualSetFlag'] == 2") 745 self.fromString(data) 746 else: 747 self.data = None 748 749# 2.2.57 InstanceQualifierSet 750class INSTANCE_QUALIFIER_SET(Structure): 751 structure = ( 752 ('QualifierSet', ':', QUALIFIER_SET), 753 ('InstancePropQualifierSet', ':', INSTANCE_PROP_QUALIFIER_SET), 754 ) 755 756# 2.2.58 InstanceHeap 757INSTANCE_HEAP = HEAP 758 759# 2.2.53 InstanceType 760class INSTANCE_TYPE(Structure): 761 commonHdr = ( 762 ('CurrentClass', ':', CURRENT_CLASS_NO_METHODS), 763 ('EncodingLength', ENCODING_LENGTH), 764 ('InstanceFlags', INSTANCE_FLAGS), 765 ('InstanceClassName', INSTANCE_CLASS_NAME), 766 ('_NdTable_ValueTable', '_-NdTable_ValueTable', 767 'self["CurrentClass"]["ClassPart"]["ClassHeader"]["NdTableValueTableLength"]'), 768 ('NdTable_ValueTable',':'), 769 ('InstanceQualifierSet', ':', INSTANCE_QUALIFIER_SET), 770 ('InstanceHeap', ':', INSTANCE_HEAP), 771 ) 772 773 def __init__(self, data = None, alignment = 0): 774 Structure.__init__(self, data, alignment) 775 self.structure = () 776 if data is not None: 777 # Let's first check the commonHdr 778 self.fromString(data) 779 #hexdump(data[len(self.getData()):]) 780 self.NdTableSize = (self['CurrentClass']['ClassPart']['PropertyLookupTable']['PropertyCount'] - 1) /4 + 1 781 #self.InstanceDataSize = self['CurrentClass']['ClassPart']['PropertyLookupTable']['PropertyCount'] * len(InstanceData()) 782 self.fromString(data) 783 else: 784 self.data = None 785 786 def getValues(self, properties): 787 heap = self["InstanceHeap"]["HeapItem"] 788 valueTableOff = (len(properties) - 1) / 4 + 1 789 valueTable = self['NdTable_ValueTable'][valueTableOff:] 790 sorted_props = sorted(properties.keys(), key=lambda k: properties[k]['order']) 791 for key in sorted_props: 792 pType = properties[key]['type'] & (~(CIM_ARRAY_FLAG|Inherited)) 793 if properties[key]['type'] & CIM_ARRAY_FLAG: 794 unpackStr = HEAPREF[:-2] 795 else: 796 unpackStr = CIM_TYPES_REF[pType][:-2] 797 dataSize = calcsize(unpackStr) 798 try: 799 itemValue = unpack(unpackStr, valueTable[:dataSize])[0] 800 except: 801 LOG.error("getValues: Error Unpacking!") 802 itemValue = 0xffffffff 803 804 # if itemValue == 0, default value remains 805 if itemValue != 0: 806 value = ENCODED_VALUE.getValue( properties[key]['type'], itemValue, heap) 807 else: 808 value = 0 809 properties[key]['value'] = value 810 valueTable = valueTable[dataSize:] 811 return properties 812 813# 2.2.12 ParentClass 814PARENT_CLASS = CLASS_AND_METHODS_PART 815 816# 2.2.13 CurrentClass 817CURRENT_CLASS = CLASS_AND_METHODS_PART 818 819class CLASS_TYPE(Structure): 820 structure = ( 821 ('ParentClass', ':', PARENT_CLASS), 822 ('CurrentClass', ':', CURRENT_CLASS), 823 ) 824 825# 2.2.5 ObjectBlock 826class OBJECT_BLOCK(Structure): 827 commonHdr = ( 828 ('ObjectFlags', OBJECT_FLAGS), 829 ) 830 831 decoration = ( 832 ('Decoration', ':', DECORATION), 833 ) 834 835 instanceType = ( 836 ('InstanceType', ':', INSTANCE_TYPE), 837 ) 838 839 classType = ( 840 ('ClassType', ':', CLASS_TYPE), 841 ) 842 def __init__(self, data = None, alignment = 0): 843 Structure.__init__(self, data, alignment) 844 self.ctParent = None 845 self.ctCurrent = None 846 847 if data is not None: 848 self.structure = () 849 if ord(data[0]) & 0x4: 850 # WMIO - 2.2.6 - 0x04 If this flag is set, the object has a Decoration block. 851 self.structure += self.decoration 852 if ord(data[0]) & 0x01: 853 # The object is a CIM class. 854 self.structure += self.classType 855 else: 856 self.structure += self.instanceType 857 858 self.fromString(data) 859 else: 860 self.data = None 861 862 def isInstance(self): 863 if self['ObjectFlags'] & 0x01: 864 return False 865 return True 866 867 def printClass(self, pClass, cInstance = None): 868 qualifiers = pClass.getQualifiers() 869 870 for qualifier in qualifiers: 871 print "[%s]" % qualifier 872 873 className = pClass.getClassName() 874 875 print "class %s \n{" % className 876 877 properties = pClass.getProperties() 878 if cInstance is not None: 879 properties = cInstance.getValues(properties) 880 881 for pName in properties: 882 #if property['inherited'] == 0: 883 qualifiers = properties[pName]['qualifiers'] 884 for qName in qualifiers: 885 if qName != 'CIMTYPE': 886 print '\t[%s(%s)]' % (qName, qualifiers[qName]) 887 print "\t%s %s" % (properties[pName]['stype'], properties[pName]['name']), 888 if properties[pName]['value'] is not None: 889 if properties[pName]['type'] == CIM_TYPE_ENUM.CIM_TYPE_OBJECT.value: 890 print '= IWbemClassObject\n' 891 elif properties[pName]['type'] == CIM_TYPE_ENUM.CIM_ARRAY_OBJECT.value: 892 if properties[pName]['value'] == 0: 893 print '= %s\n' % properties[pName]['value'] 894 else: 895 print '= %s\n' % list('IWbemClassObject' for _ in range(len(properties[pName]['value']))) 896 else: 897 print '= %s\n' % properties[pName]['value'] 898 else: 899 print '\n' 900 901 print 902 methods = pClass.getMethods() 903 for methodName in methods: 904 for qualifier in methods[methodName]['qualifiers']: 905 print '\t[%s]' % qualifier 906 907 if methods[methodName]['InParams'] is None and methods[methodName]['OutParams'] is None: 908 print '\t%s %s();\n' % ('void', methodName) 909 if methods[methodName]['InParams'] is None and len(methods[methodName]['OutParams']) == 1: 910 print '\t%s %s();\n' % (methods[methodName]['OutParams']['ReturnValue']['stype'], methodName) 911 else: 912 returnValue = '' 913 if methods[methodName]['OutParams'] is not None: 914 # Search the Return Value 915 #returnValue = (item for item in method['OutParams'] if item["name"] == "ReturnValue").next() 916 if methods[methodName]['OutParams'].has_key('ReturnValue'): 917 returnValue = methods[methodName]['OutParams']['ReturnValue']['stype'] 918 919 print '\t%s %s(\n' % (returnValue, methodName), 920 if methods[methodName]['InParams'] is not None: 921 for pName in methods[methodName]['InParams']: 922 print '\t\t[in] %s %s,' % (methods[methodName]['InParams'][pName]['stype'], pName) 923 924 if methods[methodName]['OutParams'] is not None: 925 for pName in methods[methodName]['OutParams']: 926 if pName != 'ReturnValue': 927 print '\t\t[out] %s %s,' % (methods[methodName]['OutParams'][pName]['stype'], pName) 928 929 print '\t);\n' 930 931 print "}" 932 933 def parseClass(self, pClass, cInstance = None): 934 classDict = OrderedDict() 935 classDict['name'] = pClass.getClassName() 936 classDict['qualifiers'] = pClass.getQualifiers() 937 classDict['properties'] = pClass.getProperties() 938 classDict['methods'] = pClass.getMethods() 939 if cInstance is not None: 940 classDict['values'] = cInstance.getValues(classDict['properties']) 941 else: 942 classDict['values'] = None 943 944 return classDict 945 946 def parseObject(self): 947 if (self['ObjectFlags'] & 0x01) == 0: 948 # instance 949 ctCurrent = self['InstanceType']['CurrentClass'] 950 currentName = ctCurrent.getClassName() 951 if currentName is not None: 952 self.ctCurrent = self.parseClass(ctCurrent, self['InstanceType']) 953 return 954 else: 955 ctParent = self['ClassType']['ParentClass'] 956 ctCurrent = self['ClassType']['CurrentClass'] 957 958 parentName = ctParent.getClassName() 959 if parentName is not None: 960 self.ctParent = self.parseClass(ctParent) 961 962 currentName = ctCurrent.getClassName() 963 if currentName is not None: 964 self.ctCurrent = self.parseClass(ctCurrent) 965 966 def printInformation(self): 967 # First off, do we have a class? 968 if (self['ObjectFlags'] & 0x01) == 0: 969 # instance 970 ctCurrent = self['InstanceType']['CurrentClass'] 971 currentName = ctCurrent.getClassName() 972 if currentName is not None: 973 self.printClass(ctCurrent, self['InstanceType']) 974 return 975 else: 976 ctParent = self['ClassType']['ParentClass'] 977 ctCurrent = self['ClassType']['CurrentClass'] 978 979 parentName = ctParent.getClassName() 980 if parentName is not None: 981 self.printClass(ctParent) 982 983 currentName = ctCurrent.getClassName() 984 if currentName is not None: 985 self.printClass(ctCurrent) 986 987# 2.2.70 MethodSignatureBlock 988class METHOD_SIGNATURE_BLOCK(Structure): 989 commonHdr = ( 990 ('EncodingLength', ENCODING_LENGTH), 991 ) 992 tail = ( 993 ('_ObjectBlock', '_-ObjectBlock', 'self["EncodingLength"]'), 994 ('ObjectBlock', ':', OBJECT_BLOCK), 995 ) 996 def __init__(self, data = None, alignment = 0): 997 Structure.__init__(self, data, alignment) 998 if data is not None: 999 self.fromString(data) 1000 if self['EncodingLength'] > 0: 1001 self.structure = () 1002 self.structure += self.tail 1003 self.fromString(data) 1004 else: 1005 self.data = None 1006 1007# 2.2.1 EncodingUnit 1008class ENCODING_UNIT(Structure): 1009 structure = ( 1010 ('Signature', SIGNATURE), 1011 ('ObjectEncodingLength', OBJECT_ENCODING_LENGTH), 1012 ('_ObjectBlock', '_-ObjectBlock', 'self["ObjectEncodingLength"]'), 1013 ('ObjectBlock', ':', OBJECT_BLOCK), 1014 ) 1015 1016################################################################################ 1017# CONSTANTS 1018################################################################################ 1019# 1.9 Standards Assignments 1020CLSID_WbemLevel1Login = string_to_bin('8BC3F05E-D86B-11D0-A075-00C04FB68820') 1021CLSID_WbemBackupRestore = string_to_bin('C49E32C6-BC8B-11D2-85D4-00105A1F8304') 1022CLSID_WbemClassObject = string_to_bin('4590F812-1D3A-11D0-891F-00AA004B2E24') 1023 1024IID_IWbemLevel1Login = uuidtup_to_bin(('F309AD18-D86A-11d0-A075-00C04FB68820', '0.0')) 1025IID_IWbemLoginClientID = uuidtup_to_bin(('d4781cd6-e5d3-44df-ad94-930efe48a887', '0.0')) 1026IID_IWbemLoginHelper = uuidtup_to_bin(('541679AB-2E5F-11d3-B34E-00104BCC4B4A', '0.0')) 1027IID_IWbemServices = uuidtup_to_bin(('9556DC99-828C-11CF-A37E-00AA003240C7', '0.0')) 1028IID_IWbemBackupRestore = uuidtup_to_bin(('C49E32C7-BC8B-11d2-85D4-00105A1F8304', '0.0')) 1029IID_IWbemBackupRestoreEx = uuidtup_to_bin(('A359DEC5-E813-4834-8A2A-BA7F1D777D76', '0.0')) 1030IID_IWbemClassObject = uuidtup_to_bin(('DC12A681-737F-11CF-884D-00AA004B2E24', '0.0')) 1031IID_IWbemContext = uuidtup_to_bin(('44aca674-e8fc-11d0-a07c-00c04fb68820', '0.0')) 1032IID_IEnumWbemClassObject = uuidtup_to_bin(('027947e1-d731-11ce-a357-000000000001', '0.0')) 1033IID_IWbemCallResult = uuidtup_to_bin(('44aca675-e8fc-11d0-a07c-00c04fb68820', '0.0')) 1034IID_IWbemFetchSmartEnum = uuidtup_to_bin(('1C1C45EE-4395-11d2-B60B-00104B703EFD', '0.0')) 1035IID_IWbemWCOSmartEnum = uuidtup_to_bin(('423EC01E-2E35-11d2-B604-00104B703EFD', '0.0')) 1036 1037error_status_t = ULONG 1038 1039# lFlags 1040WBEM_FLAG_RETURN_WBEM_COMPLETE = 0x00000000 1041WBEM_FLAG_UPDATE_ONLY = 0x00000001 1042WBEM_FLAG_CREATE_ONLY = 0x00000002 1043WBEM_FLAG_RETURN_IMMEDIATELY = 0x00000010 1044WBEM_FLAG_UPDATE_SAFE_MODE = 0x00000020 1045WBEM_FLAG_FORWARD_ONLY = 0x00000020 1046WBEM_FLAG_NO_ERROR_OBJECT = 0x00000040 1047WBEM_FLAG_UPDATE_FORCE_MODE = 0x00000040 1048WBEM_FLAG_SEND_STATUS = 0x00000080 1049WBEM_FLAG_ENSURE_LOCATABLE = 0x00000100 1050WBEM_FLAG_DIRECT_READ = 0x00000200 1051WBEM_MASK_RESERVED_FLAGS = 0x0001F000 1052WBEM_FLAG_USE_AMENDED_QUALIFIERS = 0x00020000 1053WBEM_FLAG_STRONG_VALIDATION = 0x00100000 1054WBEM_FLAG_BACKUP_RESTORE_FORCE_SHUTDOWN = 0x00000001 1055 1056WBEM_INFINITE = 0xffffffff 1057 1058################################################################################ 1059# STRUCTURES 1060################################################################################ 1061class UCHAR_ARRAY_CV(NDRUniConformantVaryingArray): 1062 item = 'c' 1063 1064class PUCHAR_ARRAY_CV(NDRPOINTER): 1065 referent = ( 1066 ('Data', UCHAR_ARRAY_CV), 1067 ) 1068 1069class PMInterfacePointer_ARRAY_CV(NDRUniConformantVaryingArray): 1070 item = PMInterfacePointer 1071 1072REFGUID = PGUID 1073 1074class ULONG_ARRAY(NDRUniConformantArray): 1075 item = ULONG 1076 1077class PULONG_ARRAY(NDRPOINTER): 1078 referent = ( 1079 ('Data', ULONG_ARRAY), 1080 ) 1081 1082# 2.2.5 WBEM_CHANGE_FLAG_TYPE Enumeration 1083class WBEM_CHANGE_FLAG_TYPE(NDRENUM): 1084 # [v1_enum] type 1085 structure = ( 1086 ('Data', '<L'), 1087 ) 1088 class enumItems(Enum): 1089 WBEM_FLAG_CREATE_OR_UPDATE = 0x00 1090 WBEM_FLAG_UPDATE_ONLY = 0x01 1091 WBEM_FLAG_CREATE_ONLY = 0x02 1092 WBEM_FLAG_UPDATE_SAFE_MODE = 0x20 1093 WBEM_FLAG_UPDATE_FORCE_MODE = 0x40 1094 1095# 2.2.6 WBEM_GENERIC_FLAG_TYPE Enumeration 1096class WBEM_GENERIC_FLAG_TYPE(NDRENUM): 1097 # [v1_enum] type 1098 structure = ( 1099 ('Data', '<L'), 1100 ) 1101 class enumItems(Enum): 1102 WBEM_FLAG_RETURN_WBEM_COMPLETE = 0x00 1103 WBEM_FLAG_RETURN_IMMEDIATELY = 0x10 1104 WBEM_FLAG_FORWARD_ONLY = 0x20 1105 WBEM_FLAG_NO_ERROR_OBJECT = 0x40 1106 WBEM_FLAG_SEND_STATUS = 0x80 1107 WBEM_FLAG_ENSURE_LOCATABLE = 0x100 1108 WBEM_FLAG_DIRECT_READ = 0x200 1109 WBEM_MASK_RESERVED_FLAGS = 0x1F000 1110 WBEM_FLAG_USE_AMENDED_QUALIFIERS = 0x20000 1111 WBEM_FLAG_STRONG_VALIDATION = 0x100000 1112 1113# 2.2.7 WBEM_STATUS_TYPE Enumeration 1114class WBEM_STATUS_TYPE(NDRENUM): 1115 class enumItems(Enum): 1116 WBEM_STATUS_COMPLETE = 0x00 1117 WBEM_STATUS_REQUIREMENTS = 0x01 1118 WBEM_STATUS_PROGRESS = 0x02 1119 1120# 2.2.8 WBEM_TIMEOUT_TYPE Enumeration 1121class WBEM_TIMEOUT_TYPE(NDRENUM): 1122 # [v1_enum] type 1123 structure = ( 1124 ('Data', '<L'), 1125 ) 1126 class enumItems(Enum): 1127 WBEM_NO_WAIT = 0x00000000 1128 WBEM_INFINITE = 0xFFFFFFFF 1129 1130# 2.2.9 WBEM_QUERY_FLAG_TYPE Enumeration 1131class WBEM_QUERY_FLAG_TYPE(NDRENUM): 1132 # [v1_enum] type 1133 structure = ( 1134 ('Data', '<L'), 1135 ) 1136 class enumItems(Enum): 1137 WBEM_FLAG_DEEP = 0x00000000 1138 WBEM_FLAG_SHALLOW = 0x00000001 1139 WBEM_FLAG_PROTOTYPE = 0x00000002 1140 1141# 2.2.10 WBEM_BACKUP_RESTORE_FLAGS Enumeration 1142class WBEM_BACKUP_RESTORE_FLAGS(NDRENUM): 1143 # [v1_enum] type 1144 structure = ( 1145 ('Data', '<L'), 1146 ) 1147 class enumItems(Enum): 1148 WBEM_FLAG_BACKUP_RESTORE_FORCE_SHUTDOWN = 0x00000001 1149 1150# 2.2.11 WBEMSTATUS Enumeration 1151class WBEMSTATUS(NDRENUM): 1152 # [v1_enum] type 1153 structure = ( 1154 ('Data', '<L'), 1155 ) 1156 class enumItems(Enum): 1157 WBEM_S_NO_ERROR = 0x00000000 1158 WBEM_S_FALSE = 0x00000001 1159 WBEM_S_TIMEDOUT = 0x00040004 1160 WBEM_S_NEW_STYLE = 0x000400FF 1161 WBEM_S_PARTIAL_RESULTS = 0x00040010 1162 WBEM_E_FAILED = 0x80041001 1163 WBEM_E_NOT_FOUND = 0x80041002 1164 WBEM_E_ACCESS_DENIED = 0x80041003 1165 WBEM_E_PROVIDER_FAILURE = 0x80041004 1166 WBEM_E_TYPE_MISMATCH = 0x80041005 1167 WBEM_E_OUT_OF_MEMORY = 0x80041006 1168 WBEM_E_INVALID_CONTEXT = 0x80041007 1169 WBEM_E_INVALID_PARAMETER = 0x80041008 1170 WBEM_E_NOT_AVAILABLE = 0x80041009 1171 WBEM_E_CRITICAL_ERROR = 0x8004100a 1172 WBEM_E_NOT_SUPPORTED = 0x8004100c 1173 WBEM_E_PROVIDER_NOT_FOUND = 0x80041011 1174 WBEM_E_INVALID_PROVIDER_REGISTRATION = 0x80041012 1175 WBEM_E_PROVIDER_LOAD_FAILURE = 0x80041013 1176 WBEM_E_INITIALIZATION_FAILURE = 0x80041014 1177 WBEM_E_TRANSPORT_FAILURE = 0x80041015 1178 WBEM_E_INVALID_OPERATION = 0x80041016 1179 WBEM_E_ALREADY_EXISTS = 0x80041019 1180 WBEM_E_UNEXPECTED = 0x8004101d 1181 WBEM_E_INCOMPLETE_CLASS = 0x80041020 1182 WBEM_E_SHUTTING_DOWN = 0x80041033 1183 E_NOTIMPL = 0x80004001 1184 WBEM_E_INVALID_SUPERCLASS = 0x8004100D 1185 WBEM_E_INVALID_NAMESPACE = 0x8004100E 1186 WBEM_E_INVALID_OBJECT = 0x8004100F 1187 WBEM_E_INVALID_CLASS = 0x80041010 1188 WBEM_E_INVALID_QUERY = 0x80041017 1189 WBEM_E_INVALID_QUERY_TYPE = 0x80041018 1190 WBEM_E_PROVIDER_NOT_CAPABLE = 0x80041024 1191 WBEM_E_CLASS_HAS_CHILDREN = 0x80041025 1192 WBEM_E_CLASS_HAS_INSTANCES = 0x80041026 1193 WBEM_E_ILLEGAL_NULL = 0x80041028 1194 WBEM_E_INVALID_CIM_TYPE = 0x8004102D 1195 WBEM_E_INVALID_METHOD = 0x8004102E 1196 WBEM_E_INVALID_METHOD_PARAMETERS = 0x8004102F 1197 WBEM_E_INVALID_PROPERTY = 0x80041031 1198 WBEM_E_CALL_CANCELLED = 0x80041032 1199 WBEM_E_INVALID_OBJECT_PATH = 0x8004103A 1200 WBEM_E_OUT_OF_DISK_SPACE = 0x8004103B 1201 WBEM_E_UNSUPPORTED_PUT_EXTENSION = 0x8004103D 1202 WBEM_E_QUOTA_VIOLATION = 0x8004106c 1203 WBEM_E_SERVER_TOO_BUSY = 0x80041045 1204 WBEM_E_METHOD_NOT_IMPLEMENTED = 0x80041055 1205 WBEM_E_METHOD_DISABLED = 0x80041056 1206 WBEM_E_UNPARSABLE_QUERY = 0x80041058 1207 WBEM_E_NOT_EVENT_CLASS = 0x80041059 1208 WBEM_E_MISSING_GROUP_WITHIN = 0x8004105A 1209 WBEM_E_MISSING_AGGREGATION_LIST = 0x8004105B 1210 WBEM_E_PROPERTY_NOT_AN_OBJECT = 0x8004105c 1211 WBEM_E_AGGREGATING_BY_OBJECT = 0x8004105d 1212 WBEM_E_BACKUP_RESTORE_WINMGMT_RUNNING= 0x80041060 1213 WBEM_E_QUEUE_OVERFLOW = 0x80041061 1214 WBEM_E_PRIVILEGE_NOT_HELD = 0x80041062 1215 WBEM_E_INVALID_OPERATOR = 0x80041063 1216 WBEM_E_CANNOT_BE_ABSTRACT = 0x80041065 1217 WBEM_E_AMENDED_OBJECT = 0x80041066 1218 WBEM_E_VETO_PUT = 0x8004107A 1219 WBEM_E_PROVIDER_SUSPENDED = 0x80041081 1220 WBEM_E_ENCRYPTED_CONNECTION_REQUIRED = 0x80041087 1221 WBEM_E_PROVIDER_TIMED_OUT = 0x80041088 1222 WBEM_E_NO_KEY = 0x80041089 1223 WBEM_E_PROVIDER_DISABLED = 0x8004108a 1224 WBEM_E_REGISTRATION_TOO_BROAD = 0x80042001 1225 WBEM_E_REGISTRATION_TOO_PRECISE = 0x80042002 1226 1227# 2.2.12 WBEM_CONNECT_OPTIONS Enumeration 1228class WBEM_CONNECT_OPTIONS(NDRENUM): 1229 # [v1_enum] type 1230 structure = ( 1231 ('Data', '<L'), 1232 ) 1233 class enumItems(Enum): 1234 WBEM_FLAG_CONNECT_REPOSITORY_ONLY = 0x40 1235 WBEM_FLAG_CONNECT_PROVIDERS = 0x100 1236 1237# 2.2.14 ObjectArray Structure 1238class ObjectArray(Structure): 1239 structure = ( 1240 ('dwByteOrdering', '<L=0'), 1241 ('abSignature', '8s="WBEMDATA"'), 1242 ('dwSizeOfHeader1', '<L=0x1a'), 1243 ('dwDataSize1', '<L=0'), 1244 ('dwFlags', '<L=0'), 1245 ('bVersion', 'B=1'), 1246 ('bPacketType', 'B=0'), 1247 ('dwSizeOfHeader2', '<L=8'), 1248 ('dwDataSize2', '<L', 'len(self["wbemObjects"])+12'), 1249 ('dwSizeOfHeader3', '<L=12'), 1250 ('dwDataSize3', '<L', 'len(self["dwDataSize2"])-12)'), 1251 ('dwNumObjects', '<L=0'), 1252 ('_wbemObjects', '_-wbemObjects', 'self["dwDataSize3"]'), 1253 ('wbemObjects', ':'), 1254 ) 1255 1256# 2.2.14.1 WBEM_DATAPACKET_OBJECT Structure 1257class WBEM_DATAPACKET_OBJECT(Structure): 1258 structure = ( 1259 ('dwSizeOfHeader', '<L=9'), 1260 ('dwSizeOfData', '<L','len(self["Object"])'), 1261 ('bObjectType', 'B=0'), 1262 ('_Object', '_-Object', 'self["dwSizeOfData"]'), 1263 ('Object', ':'), 1264 ) 1265 1266# 2.2.14.2 WBEMOBJECT_CLASS Structure 1267class WBEMOBJECT_CLASS(Structure): 1268 structure = ( 1269 ('dwSizeOfHeader', '<L=8'), 1270 ('dwSizeOfData', '<L','len(self["ObjectData"])'), 1271 ('_ObjectData', '_-ObjectData', 'self["dwSizeOfData"]'), 1272 ('ObjectData', ':'), 1273 ) 1274 1275# 2.2.14.3 WBEMOBJECT_INSTANCE Structure 1276class WBEMOBJECT_INSTANCE(Structure): 1277 structure = ( 1278 ('dwSizeOfHeader', '<L=0x18'), 1279 ('dwSizeOfData', '<L','len(self["ObjectData"])'), 1280 ('classID', '16s="\x00"*16'), 1281 ('_ObjectData', '_-ObjectData', 'self["dwSizeOfData"]'), 1282 ('ObjectData', ':'), 1283 ) 1284 1285# 2.2.14.4 WBEMOBJECT_INSTANCE_NOCLASS Structure 1286class WBEMOBJECT_INSTANCE_NOCLASS(Structure): 1287 structure = ( 1288 ('dwSizeOfHeader', '<L=0x18'), 1289 ('dwSizeOfData', '<L','len(self["ObjectData"])'), 1290 ('classID', '16s="\x00"*16'), 1291 ('_ObjectData', '_-ObjectData', 'self["dwSizeOfData"]'), 1292 ('ObjectData', ':'), 1293 ) 1294 1295# 2.2.15 WBEM_REFRESHED_OBJECT Structure 1296class WBEM_REFRESHED_OBJECT(NDRSTRUCT): 1297 structure = ( 1298 ('m_lRequestId', LONG), 1299 ('m_lBlobType', LONG), 1300 ('m_lBlobLength', LONG), 1301 ('m_pBlob', BYTE_ARRAY), 1302 ) 1303 1304class WBEM_REFRESHED_OBJECT_ARRAY(NDRUniConformantArray): 1305 item = WBEM_REFRESHED_OBJECT 1306 1307class PWBEM_REFRESHED_OBJECT_ARRAY(NDRPOINTER): 1308 referent = ( 1309 ('Data', WBEM_REFRESHED_OBJECT_ARRAY), 1310 ) 1311 1312# 2.2.16 WBEM_INSTANCE_BLOB Enumeration 1313class WBEM_INSTANCE_BLOB(Structure): 1314 structure = ( 1315 ('Version', '<L=0x1'), 1316 ('numObjects', '<L=0'), 1317 ('Objects', ':'), 1318 ) 1319 1320# 2.2.17 WBEM_INSTANCE_BLOB_TYPE Enumeration 1321class WBEM_INSTANCE_BLOB_TYPE(NDRENUM): 1322 # [v1_enum] type 1323 structure = ( 1324 ('Data', '<L'), 1325 ) 1326 class enumItems(Enum): 1327 WBEM_FLAG_CONNECT_REPOSITORY_ONLY = 0x40 1328 WBEM_FLAG_CONNECT_PROVIDERS = 0x100 1329 1330# 2.2.26 _WBEM_REFRESH_INFO_NON_HIPERF Structure 1331class _WBEM_REFRESH_INFO_NON_HIPERF(NDRSTRUCT): 1332 structure = ( 1333 ('m_wszNamespace', LPWSTR), 1334 ('m_pTemplate', PMInterfacePointer), 1335 ) 1336 1337# 2.2.27 _WBEM_REFRESH_INFO_REMOTE Structure 1338class _WBEM_REFRESH_INFO_REMOTE(NDRSTRUCT): 1339 structure = ( 1340 ('m_pRefresher', PMInterfacePointer), 1341 ('m_pTemplate', PMInterfacePointer), 1342 ('m_Guid', GUID), 1343 ) 1344 1345# 2.2.25 WBEM_REFRESH_TYPE Enumeration 1346class WBEM_REFRESH_TYPE(NDRENUM): 1347 class enumItems(Enum): 1348 WBEM_REFRESH_TYPE_INVALID = 0 1349 WBEM_REFRESH_TYPE_REMOTE = 3 1350 WBEM_REFRESH_TYPE_NON_HIPERF = 6 1351 1352# 2.2.28 _WBEM_REFRESH_INFO_UNION Union 1353class _WBEM_REFRESH_INFO_UNION(NDRUNION): 1354 commonHdr = ( 1355 ('tag', LONG), 1356 ) 1357 union = { 1358 WBEM_REFRESH_TYPE.WBEM_REFRESH_TYPE_REMOTE : ('m_Remote', _WBEM_REFRESH_INFO_REMOTE), 1359 WBEM_REFRESH_TYPE.WBEM_REFRESH_TYPE_NON_HIPERF: ('m_NonHiPerf', _WBEM_REFRESH_INFO_NON_HIPERF), 1360 WBEM_REFRESH_TYPE.WBEM_REFRESH_TYPE_INVALID : ('m_hres', HRESULT), 1361 } 1362 1363# 2.2.20 _WBEM_REFRESH_INFO Structure 1364class _WBEM_REFRESH_INFO(NDRSTRUCT): 1365 structure = ( 1366 ('m_lType', LONG), 1367 ('m_Info', _WBEM_REFRESH_INFO_UNION), 1368 ('m_lCancelId', LONG), 1369 ) 1370 1371# 2.2.21 _WBEM_REFRESHER_ID Structure 1372class _WBEM_REFRESHER_ID(NDRSTRUCT): 1373 structure = ( 1374 ('m_szMachineName', LPCSTR), 1375 ('m_dwProcessId', DWORD), 1376 ('m_guidRefresherId', GUID), 1377 ) 1378 1379# 2.2.22 _WBEM_RECONNECT_INFO Structure 1380class _WBEM_RECONNECT_INFO(NDRSTRUCT): 1381 structure = ( 1382 ('m_lType', LPCSTR), 1383 ('m_pwcsPath', LPWSTR), 1384 ) 1385 1386class _WBEM_RECONNECT_INFO_ARRAY(NDRUniConformantArray): 1387 item = _WBEM_RECONNECT_INFO 1388 1389# 2.2.23 _WBEM_RECONNECT_RESULTS Structure 1390class _WBEM_RECONNECT_RESULTS(NDRSTRUCT): 1391 structure = ( 1392 ('m_lId', LONG), 1393 ('m_hr', HRESULT), 1394 ) 1395 1396class _WBEM_RECONNECT_RESULTS_ARRAY(NDRUniConformantArray): 1397 item = _WBEM_RECONNECT_INFO 1398 1399 1400################################################################################ 1401# RPC CALLS 1402################################################################################ 1403# 3.1.4.1 IWbemLevel1Login Interface 1404# 3.1.4.1.1 IWbemLevel1Login::EstablishPosition (Opnum 3) 1405class IWbemLevel1Login_EstablishPosition(DCOMCALL): 1406 opnum = 3 1407 structure = ( 1408 ('reserved1', LPWSTR), 1409 ('reserved2', DWORD), 1410 ) 1411 1412class IWbemLevel1Login_EstablishPositionResponse(DCOMANSWER): 1413 structure = ( 1414 ('LocaleVersion', DWORD), 1415 ('ErrorCode', error_status_t), 1416 ) 1417 1418# 3.1.4.1.2 IWbemLevel1Login::RequestChallenge (Opnum 4) 1419class IWbemLevel1Login_RequestChallenge(DCOMCALL): 1420 opnum = 4 1421 structure = ( 1422 ('reserved1', LPWSTR), 1423 ('reserved2', LPWSTR), 1424 ) 1425 1426class IWbemLevel1Login_RequestChallengeResponse(DCOMANSWER): 1427 structure = ( 1428 ('reserved3', UCHAR_ARRAY_CV), 1429 ('ErrorCode', error_status_t), 1430 ) 1431 1432# 3.1.4.1.3 IWbemLevel1Login::WBEMLogin (Opnum 5) 1433class IWbemLevel1Login_WBEMLogin(DCOMCALL): 1434 opnum = 5 1435 structure = ( 1436 ('reserved1', LPWSTR), 1437 ('reserved2', PUCHAR_ARRAY_CV), 1438 ('reserved3', LONG), 1439 ('reserved4', PMInterfacePointer), 1440 ) 1441 1442class IWbemLevel1Login_WBEMLoginResponse(DCOMANSWER): 1443 structure = ( 1444 ('reserved5', UCHAR_ARRAY_CV), 1445 ('ErrorCode', error_status_t), 1446 ) 1447 1448# 3.1.4.1.4 IWbemLevel1Login::NTLMLogin (Opnum 6) 1449class IWbemLevel1Login_NTLMLogin(DCOMCALL): 1450 opnum = 6 1451 structure = ( 1452 ('wszNetworkResource', LPWSTR), 1453 ('wszPreferredLocale', LPWSTR), 1454 ('lFlags', LONG), 1455 ('pCtx', PMInterfacePointer), 1456 ) 1457 1458class IWbemLevel1Login_NTLMLoginResponse(DCOMANSWER): 1459 structure = ( 1460 ('ppNamespace', PMInterfacePointer), 1461 ('ErrorCode', error_status_t), 1462 ) 1463 1464# 3.1.4.2 IWbemObjectSink Interface Server Details 1465# 3.1.4.2.1 IWbemObjectSink::Indicate (Opnum 3) Server details 1466class IWbemObjectSink_Indicate(DCOMCALL): 1467 opnum = 3 1468 structure = ( 1469 ('lObjectCount', LONG), 1470 ('apObjArray', PMInterfacePointer_ARRAY), 1471 ) 1472 1473class IWbemObjectSink_IndicateResponse(DCOMANSWER): 1474 structure = ( 1475 ('ErrorCode', error_status_t), 1476 ) 1477 1478# 3.1.4.2.2 IWbemObjectSink::SetStatus (Opnum 4) Server Details 1479class IWbemObjectSink_SetStatus(DCOMCALL): 1480 opnum = 4 1481 structure = ( 1482 ('lFlags', LONG), 1483 ('hResult', HRESULT), 1484 ('strParam', BSTR), 1485 ('pObjParam', PMInterfacePointer), 1486 ) 1487 1488class IWbemObjectSink_SetStatusResponse(DCOMANSWER): 1489 structure = ( 1490 ('ErrorCode', error_status_t), 1491 ) 1492 1493# 3.1.4.3 IWbemServices Interface 1494# 3.1.4.3.1 IWbemServices::OpenNamespace (Opnum 3) 1495class IWbemServices_OpenNamespace(DCOMCALL): 1496 opnum = 3 1497 structure = ( 1498 ('strNamespace', BSTR), 1499 ('lFlags', LONG), 1500 ('pCtx', PMInterfacePointer), 1501 ('ppWorkingNamespace', PMInterfacePointer), 1502 ('ppResult', PMInterfacePointer), 1503 ) 1504 1505class IWbemServices_OpenNamespaceResponse(DCOMANSWER): 1506 structure = ( 1507 ('ppWorkingNamespace', PPMInterfacePointer), 1508 ('ppResult', PPMInterfacePointer), 1509 ('ErrorCode', error_status_t), 1510 ) 1511 1512# 3.1.4.3.2 IWbemServices::CancelAsyncCall (Opnum 4) 1513class IWbemServices_CancelAsyncCall(DCOMCALL): 1514 opnum = 4 1515 structure = ( 1516 ('IWbemObjectSink', PMInterfacePointer), 1517 ) 1518 1519class IWbemServices_CancelAsyncCallResponse(DCOMANSWER): 1520 structure = ( 1521 ('ErrorCode', error_status_t), 1522 ) 1523 1524# 3.1.4.3.3 IWbemServices::QueryObjectSink (Opnum 5) 1525class IWbemServices_QueryObjectSink(DCOMCALL): 1526 opnum = 5 1527 structure = ( 1528 ('lFlags', LONG), 1529 ) 1530 1531class IWbemServices_QueryObjectSinkResponse(DCOMANSWER): 1532 structure = ( 1533 ('ppResponseHandler', PMInterfacePointer), 1534 ('ErrorCode', error_status_t), 1535 ) 1536 1537# 3.1.4.3.4 IWbemServices::GetObject (Opnum 6) 1538class IWbemServices_GetObject(DCOMCALL): 1539 opnum = 6 1540 structure = ( 1541 ('strObjectPath', BSTR), 1542 ('lFlags', LONG), 1543 ('pCtx', PMInterfacePointer), 1544 ('ppObject', PMInterfacePointer), 1545 ('ppCallResult', PMInterfacePointer), 1546 ) 1547 1548class IWbemServices_GetObjectResponse(DCOMANSWER): 1549 structure = ( 1550 ('ppObject', PPMInterfacePointer), 1551 ('ppCallResult', PPMInterfacePointer), 1552 ('ErrorCode', error_status_t), 1553 ) 1554 1555# 3.1.4.3.5 IWbemServices::GetObjectAsync (Opnum 7) 1556class IWbemServices_GetObjectAsync(DCOMCALL): 1557 opnum = 7 1558 structure = ( 1559 ('strObjectPath', BSTR), 1560 ('lFlags', LONG), 1561 ('pCtx', PMInterfacePointer), 1562 ('pResponseHandler', PMInterfacePointer), 1563 ) 1564 1565class IWbemServices_GetObjectAsyncResponse(DCOMANSWER): 1566 structure = ( 1567 ('ErrorCode', error_status_t), 1568 ) 1569 1570# 3.1.4.3.6 IWbemServices::PutClass (Opnum 8) 1571class IWbemServices_PutClass(DCOMCALL): 1572 opnum = 8 1573 structure = ( 1574 ('pObject', PMInterfacePointer), 1575 ('lFlags', LONG), 1576 ('pCtx', PMInterfacePointer), 1577 ('pResponseHandler', PMInterfacePointer), 1578 ('ppCallResult', PMInterfacePointer), 1579 ) 1580 1581class IWbemServices_PutClassResponse(DCOMANSWER): 1582 structure = ( 1583 ('ppCallResult', PPMInterfacePointer), 1584 ('ErrorCode', error_status_t), 1585 ) 1586 1587# 3.1.4.3.7 IWbemServices::PutClassAsync (Opnum 9) 1588class IWbemServices_PutClassAsync(DCOMCALL): 1589 opnum = 9 1590 structure = ( 1591 ('pObject', PMInterfacePointer), 1592 ('lFlags', LONG), 1593 ('pCtx', PMInterfacePointer), 1594 ('pResponseHandler', PMInterfacePointer), 1595 ) 1596 1597class IWbemServices_PutClassAsyncResponse(DCOMANSWER): 1598 structure = ( 1599 ('ErrorCode', error_status_t), 1600 ) 1601 1602# 3.1.4.3.8 IWbemServices::DeleteClass (Opnum 10) 1603class IWbemServices_DeleteClass(DCOMCALL): 1604 opnum = 10 1605 structure = ( 1606 ('strClass', BSTR), 1607 ('lFlags', LONG), 1608 ('pCtx', PMInterfacePointer), 1609 ('ppCallResult', PMInterfacePointer), 1610 ) 1611 1612class IWbemServices_DeleteClassResponse(DCOMANSWER): 1613 structure = ( 1614 ('ppCallResult', PPMInterfacePointer), 1615 ('ErrorCode', error_status_t), 1616 ) 1617 1618# 3.1.4.3.9 IWbemServices::DeleteClassAsync (Opnum 11) 1619class IWbemServices_DeleteClassAsync(DCOMCALL): 1620 opnum = 11 1621 structure = ( 1622 ('strClass', BSTR), 1623 ('lFlags', LONG), 1624 ('pCtx', PMInterfacePointer), 1625 ('pResponseHandler', PMInterfacePointer), 1626 ) 1627 1628class IWbemServices_DeleteClassAsyncResponse(DCOMANSWER): 1629 structure = ( 1630 ('ErrorCode', error_status_t), 1631 ) 1632 1633# 3.1.4.3.10 IWbemServices::CreateClassEnum (Opnum 12) 1634class IWbemServices_CreateClassEnum(DCOMCALL): 1635 opnum = 12 1636 structure = ( 1637 ('strSuperClass', BSTR), 1638 ('lFlags', LONG), 1639 ('pCtx', PMInterfacePointer), 1640 ) 1641 1642class IWbemServices_CreateClassEnumResponse(DCOMANSWER): 1643 structure = ( 1644 ('ppEnum', PMInterfacePointer), 1645 ('ErrorCode', error_status_t), 1646 ) 1647 1648# 3.1.4.3.11 IWbemServices::CreateClassEnumAsync (Opnum 13) 1649class IWbemServices_CreateClassEnumAsync(DCOMCALL): 1650 opnum = 13 1651 structure = ( 1652 ('strSuperClass', BSTR), 1653 ('lFlags', LONG), 1654 ('pCtx', PMInterfacePointer), 1655 ('pResponseHandler', PMInterfacePointer), 1656 ) 1657 1658class IWbemServices_CreateClassEnumAsyncResponse(DCOMANSWER): 1659 structure = ( 1660 ('ErrorCode', error_status_t), 1661 ) 1662 1663# 3.1.4.3.12 IWbemServices::PutInstance (Opnum 14) 1664class IWbemServices_PutInstance(DCOMCALL): 1665 opnum = 14 1666 structure = ( 1667 ('pInst', PMInterfacePointer), 1668 ('lFlags', LONG), 1669 ('pCtx', PMInterfacePointer), 1670 ('ppCallResult', PMInterfacePointer), 1671 ) 1672 1673class IWbemServices_PutInstanceResponse(DCOMANSWER): 1674 structure = ( 1675 ('ppCallResult', PPMInterfacePointer), 1676 ('ErrorCode', error_status_t), 1677 ) 1678 1679# 3.1.4.3.13 IWbemServices::PutInstanceAsync (Opnum 15) 1680class IWbemServices_PutInstanceAsync(DCOMCALL): 1681 opnum = 15 1682 structure = ( 1683 ('pInst', PMInterfacePointer), 1684 ('lFlags', LONG), 1685 ('pCtx', PMInterfacePointer), 1686 ('pResponseHandler', PMInterfacePointer), 1687 ) 1688 1689class IWbemServices_PutInstanceAsyncResponse(DCOMANSWER): 1690 structure = ( 1691 ('ErrorCode', error_status_t), 1692 ) 1693 1694# 3.1.4.3.14 IWbemServices::DeleteInstance (Opnum 16) 1695class IWbemServices_DeleteInstance(DCOMCALL): 1696 opnum = 16 1697 structure = ( 1698 ('strObjectPath', BSTR), 1699 ('lFlags', LONG), 1700 ('pCtx', PMInterfacePointer), 1701 ('ppCallResult', PMInterfacePointer), 1702 ) 1703 1704class IWbemServices_DeleteInstanceResponse(DCOMANSWER): 1705 structure = ( 1706 ('ppCallResult', PPMInterfacePointer), 1707 ('ErrorCode', error_status_t), 1708 ) 1709 1710# 3.1.4.3.15 IWbemServices::DeleteInstanceAsync (Opnum 17) 1711class IWbemServices_DeleteInstanceAsync(DCOMCALL): 1712 opnum = 17 1713 structure = ( 1714 ('strObjectPath', BSTR), 1715 ('lFlags', LONG), 1716 ('pCtx', PMInterfacePointer), 1717 ('pResponseHandler', PMInterfacePointer), 1718 ) 1719 1720class IWbemServices_DeleteInstanceAsyncResponse(DCOMANSWER): 1721 structure = ( 1722 ('ErrorCode', error_status_t), 1723 ) 1724 1725# 3.1.4.3.16 IWbemServices::CreateInstanceEnum (Opnum 18) 1726class IWbemServices_CreateInstanceEnum(DCOMCALL): 1727 opnum = 18 1728 structure = ( 1729 ('strSuperClass', BSTR), 1730 ('lFlags', LONG), 1731 ('pCtx', PMInterfacePointer), 1732 ) 1733 1734class IWbemServices_CreateInstanceEnumResponse(DCOMANSWER): 1735 structure = ( 1736 ('ppEnum', PMInterfacePointer), 1737 ('ErrorCode', error_status_t), 1738 ) 1739 1740# 3.1.4.3.17 IWbemServices::CreateInstanceEnumAsync (Opnum 19) 1741class IWbemServices_CreateInstanceEnumAsync(DCOMCALL): 1742 opnum = 19 1743 structure = ( 1744 ('strSuperClass', BSTR), 1745 ('lFlags', LONG), 1746 ('pCtx', PMInterfacePointer), 1747 ('pResponseHandler', PMInterfacePointer), 1748 ) 1749 1750class IWbemServices_CreateInstanceEnumAsyncResponse(DCOMANSWER): 1751 structure = ( 1752 ('ErrorCode', error_status_t), 1753 ) 1754 1755# 3.1.4.3.18 IWbemServices::ExecQuery (Opnum 20) 1756class IWbemServices_ExecQuery(DCOMCALL): 1757 opnum = 20 1758 structure = ( 1759 ('strQueryLanguage', BSTR), 1760 ('strQuery', BSTR), 1761 ('lFlags', LONG), 1762 ('pCtx', PMInterfacePointer), 1763 ) 1764 1765class IWbemServices_ExecQueryResponse(DCOMANSWER): 1766 structure = ( 1767 ('ppEnum', PMInterfacePointer), 1768 ('ErrorCode', error_status_t), 1769 ) 1770 1771# 3.1.4.3.19 IWbemServices::ExecQueryAsync (Opnum 21) 1772class IWbemServices_ExecQueryAsync(DCOMCALL): 1773 opnum = 21 1774 structure = ( 1775 ('strQueryLanguage', BSTR), 1776 ('strQuery', BSTR), 1777 ('lFlags', LONG), 1778 ('pCtx', PMInterfacePointer), 1779 ('pResponseHandler', PMInterfacePointer), 1780 ) 1781 1782class IWbemServices_ExecQueryAsyncResponse(DCOMANSWER): 1783 structure = ( 1784 ('ErrorCode', error_status_t), 1785 ) 1786 1787# 3.1.4.3.20 IWbemServices::ExecNotificationQuery (Opnum 22) 1788class IWbemServices_ExecNotificationQuery(DCOMCALL): 1789 opnum = 22 1790 structure = ( 1791 ('strQueryLanguage', BSTR), 1792 ('strQuery', BSTR), 1793 ('lFlags', LONG), 1794 ('pCtx', PMInterfacePointer), 1795 ) 1796 1797class IWbemServices_ExecNotificationQueryResponse(DCOMANSWER): 1798 structure = ( 1799 ('ppEnum', PMInterfacePointer), 1800 ('ErrorCode', error_status_t), 1801 ) 1802 1803# 3.1.4.3.21 IWbemServices::ExecNotificationQueryAsync (Opnum 23) 1804class IWbemServices_ExecNotificationQueryAsync(DCOMCALL): 1805 opnum = 23 1806 structure = ( 1807 ('strQueryLanguage', BSTR), 1808 ('strQuery', BSTR), 1809 ('lFlags', LONG), 1810 ('pCtx', PMInterfacePointer), 1811 ('pResponseHandler', PMInterfacePointer), 1812 ) 1813 1814class IWbemServices_ExecNotificationQueryAsyncResponse(DCOMANSWER): 1815 structure = ( 1816 ('ErrorCode', error_status_t), 1817 ) 1818 1819# 3.1.4.3.22 IWbemServices::ExecMethod (Opnum 24) 1820class IWbemServices_ExecMethod(DCOMCALL): 1821 opnum = 24 1822 structure = ( 1823 ('strObjectPath', BSTR), 1824 ('strMethodName', BSTR), 1825 ('lFlags', LONG), 1826 ('pCtx', PMInterfacePointer), 1827 ('pInParams', PMInterfacePointer), 1828 ('ppOutParams', PPMInterfacePointer), 1829 ('ppCallResult', PPMInterfacePointer), 1830 ) 1831 1832class IWbemServices_ExecMethodResponse(DCOMANSWER): 1833 structure = ( 1834 ('ppOutParams', PPMInterfacePointer), 1835 ('ppCallResult', PPMInterfacePointer), 1836 ('ErrorCode', error_status_t), 1837 ) 1838 1839# 3.1.4.3.23 IWbemServices::ExecMethodAsync (Opnum 25) 1840class IWbemServices_ExecMethodAsync(DCOMCALL): 1841 opnum = 25 1842 structure = ( 1843 ('strObjectPath', BSTR), 1844 ('strMethodName', BSTR), 1845 ('lFlags', LONG), 1846 ('pCtx', PMInterfacePointer), 1847 ('pInParams', PMInterfacePointer), 1848 ('pResponseHandler', PMInterfacePointer), 1849 ) 1850 1851class IWbemServices_ExecMethodAsyncResponse(DCOMANSWER): 1852 structure = ( 1853 ('ErrorCode', error_status_t), 1854 ) 1855 1856# 3.1.4.4 IEnumWbemClassObject Interface 1857# 3.1.4.4.1 IEnumWbemClassObject::Reset (Opnum 3) 1858class IEnumWbemClassObject_Reset(DCOMCALL): 1859 opnum = 3 1860 structure = ( 1861 ) 1862 1863class IEnumWbemClassObject_ResetResponse(DCOMANSWER): 1864 structure = ( 1865 ('ErrorCode', error_status_t), 1866 ) 1867 1868# 3.1.4.4.2 IEnumWbemClassObject::Next (Opnum 4) 1869class IEnumWbemClassObject_Next(DCOMCALL): 1870 opnum = 4 1871 structure = ( 1872 ('lTimeout', ULONG), 1873 ('uCount', ULONG), 1874 ) 1875 1876class IEnumWbemClassObject_NextResponse(DCOMANSWER): 1877 structure = ( 1878 ('apObjects', PMInterfacePointer_ARRAY_CV), 1879 ('puReturned', ULONG), 1880 ('ErrorCode', error_status_t), 1881 ) 1882 1883# 3.1.4.4.3 IEnumWbemClassObject::NextAsync (Opnum 5) 1884class IEnumWbemClassObject_NextAsync(DCOMCALL): 1885 opnum = 5 1886 structure = ( 1887 ('lTimeout', LONG), 1888 ('pSink', PMInterfacePointer), 1889 ) 1890 1891class IEnumWbemClassObject_NextAsyncResponse(DCOMANSWER): 1892 structure = ( 1893 ('ErrorCode', error_status_t), 1894 ) 1895 1896# 3.1.4.4.4 IEnumWbemClassObject::Clone (Opnum 6) 1897class IEnumWbemClassObject_Clone(DCOMCALL): 1898 opnum = 6 1899 structure = ( 1900 ) 1901 1902class IEnumWbemClassObject_CloneResponse(DCOMANSWER): 1903 structure = ( 1904 ('ppEnum', PMInterfacePointer), 1905 ('ErrorCode', error_status_t), 1906 ) 1907 1908# 3.1.4.4.5 IEnumWbemClassObject::Skip (Opnum 7) 1909class IEnumWbemClassObject_Skip(DCOMCALL): 1910 opnum = 7 1911 structure = ( 1912 ('lTimeout', LONG), 1913 ('uCount', ULONG), 1914 ) 1915 1916class IEnumWbemClassObject_SkipResponse(DCOMANSWER): 1917 structure = ( 1918 ('ErrorCode', error_status_t), 1919 ) 1920 1921# 3.1.4.5 IWbemCallResult Interface 1922# 3.1.4.5.1 IWbemCallResult::GetResultObject (Opnum 3) 1923class IWbemCallResult_GetResultObject(DCOMCALL): 1924 opnum = 3 1925 structure = ( 1926 ('lTimeout', LONG), 1927 ) 1928 1929class IWbemCallResult_GetResultObjectResponse(DCOMANSWER): 1930 structure = ( 1931 ('ppResultObject', PMInterfacePointer), 1932 ('ErrorCode', error_status_t), 1933 ) 1934 1935# 3.1.4.5.2 IWbemCallResult::GetResultString (Opnum 4) 1936class IWbemCallResult_GetResultString(DCOMCALL): 1937 opnum = 4 1938 structure = ( 1939 ('lTimeout', LONG), 1940 ) 1941 1942class IWbemCallResult_GetResultStringResponse(DCOMANSWER): 1943 structure = ( 1944 ('pstrResultString', BSTR), 1945 ('ErrorCode', error_status_t), 1946 ) 1947 1948# 3.1.4.5.3 IWbemCallResult::GetResultServices (Opnum 5) 1949class IWbemCallResult_GetResultServices(DCOMCALL): 1950 opnum = 5 1951 structure = ( 1952 ('lTimeout', LONG), 1953 ) 1954 1955class IWbemCallResult_GetResultServicesResponse(DCOMANSWER): 1956 structure = ( 1957 ('ppServices', PMInterfacePointer), 1958 ('ErrorCode', error_status_t), 1959 ) 1960 1961# 3.1.4.5.4 IWbemCallResult::GetCallStatus (Opnum 6) 1962class IWbemCallResult_GetCallStatus(DCOMCALL): 1963 opnum = 6 1964 structure = ( 1965 ('lTimeout', LONG), 1966 ) 1967 1968class IWbemCallResult_GetCallStatusResponse(DCOMANSWER): 1969 structure = ( 1970 ('plStatus', LONG), 1971 ('ErrorCode', error_status_t), 1972 ) 1973 1974# 3.1.4.6 IWbemFetchSmartEnum Interface 1975# 3.1.4.6.1 IWbemFetchSmartEnum::GetSmartEnum (Opnum 3) 1976class IWbemFetchSmartEnum_GetSmartEnum(DCOMCALL): 1977 opnum = 3 1978 structure = ( 1979 ) 1980 1981class IWbemFetchSmartEnum_GetSmartEnumResponse(DCOMANSWER): 1982 structure = ( 1983 ('ppSmartEnum', PMInterfacePointer), 1984 ('ErrorCode', error_status_t), 1985 ) 1986 1987# 3.1.4.7 IWbemWCOSmartEnum Interface 1988# 3.1.4.7.1 IWbemWCOSmartEnum::Next (Opnum 3) 1989class IWbemWCOSmartEnum_Next(DCOMCALL): 1990 opnum = 3 1991 structure = ( 1992 ('proxyGUID', REFGUID), 1993 ('lTimeout', LONG), 1994 ('uCount', ULONG), 1995 ) 1996 1997class IWbemWCOSmartEnum_NextResponse(DCOMANSWER): 1998 structure = ( 1999 ('puReturned', ULONG), 2000 ('pdwBuffSize', ULONG), 2001 ('pBuffer', BYTE_ARRAY), 2002 ('ErrorCode', error_status_t), 2003 ) 2004 2005# 3.1.4.8 IWbemLoginClientID Interface 2006# 3.1.4.8.1 IWbemLoginClientID::SetClientInfo (Opnum 3) 2007class IWbemLoginClientID_SetClientInfo(DCOMCALL): 2008 opnum = 3 2009 structure = ( 2010 ('wszClientMachine', LPWSTR), 2011 ('lClientProcId', LONG), 2012 ('lReserved', LONG), 2013 ) 2014 2015class IWbemLoginClientID_SetClientInfoResponse(DCOMANSWER): 2016 structure = ( 2017 ('ErrorCode', error_status_t), 2018 ) 2019 2020# 3.1.4.9 IWbemLoginHelper Interface 2021# 3.1.4.9.1 IWbemLoginHelper::SetEvent (Opnum 3) 2022class IWbemLoginHelper_SetEvent(DCOMCALL): 2023 opnum = 3 2024 structure = ( 2025 ('sEventToSet', LPCSTR), 2026 ) 2027 2028class IWbemLoginHelper_SetEventResponse(DCOMANSWER): 2029 structure = ( 2030 ('ErrorCode', error_status_t), 2031 ) 2032 2033#AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 2034# 3.1.4.10 IWbemBackupRestore Interface 2035# 3.1.4.10.1 IWbemBackupRestore::Backup (Opnum 3) 2036class IWbemBackupRestore_Backup(DCOMCALL): 2037 opnum = 3 2038 structure = ( 2039 ('strBackupToFile', LPWSTR), 2040 ('lFlags', LONG), 2041 ) 2042 2043class IWbemBackupRestore_BackupResponse(DCOMANSWER): 2044 structure = ( 2045 ('ErrorCode', error_status_t), 2046 ) 2047 2048# 3.1.4.10.2 IWbemBackupRestore::Restore (Opnum 4) 2049class IWbemBackupRestore_Restore(DCOMCALL): 2050 opnum = 4 2051 structure = ( 2052 ('strRestoreFromFile', LPWSTR), 2053 ('lFlags', LONG), 2054 ) 2055 2056class IWbemBackupRestore_RestoreResponse(DCOMANSWER): 2057 structure = ( 2058 ('ErrorCode', error_status_t), 2059 ) 2060 2061# 3.1.4.11 IWbemBackupRestoreEx Interface 2062# 3.1.4.11.1 IWbemBackupRestoreEx::Pause (Opnum 5) 2063class IWbemBackupRestoreEx_Pause(DCOMCALL): 2064 opnum = 5 2065 structure = ( 2066 ) 2067 2068class IWbemBackupRestoreEx_PauseResponse(DCOMANSWER): 2069 structure = ( 2070 ('ErrorCode', error_status_t), 2071 ) 2072 2073# 3.1.4.11.2 IWbemBackupRestoreEx::Resume (Opnum 6) 2074class IWbemBackupRestoreEx_Resume(DCOMCALL): 2075 opnum = 6 2076 structure = ( 2077 ) 2078 2079class IWbemBackupRestoreEx_ResumeResponse(DCOMANSWER): 2080 structure = ( 2081 ('ErrorCode', error_status_t), 2082 ) 2083 2084# 3.1.4.12 IWbemRefreshingServices Interface 2085# 3.1.4.12.1 IWbemRefreshingServices::AddObjectToRefresher (Opnum 3) 2086class IWbemRefreshingServices_AddObjectToRefresher(DCOMCALL): 2087 opnum = 3 2088 structure = ( 2089 ('pRefresherId', _WBEM_REFRESHER_ID), 2090 ('wszPath', LPWSTR), 2091 ('lFlags', LONG), 2092 ('pContext', PMInterfacePointer), 2093 ('dwClientRefrVersion', DWORD), 2094 ) 2095 2096class IWbemRefreshingServices_AddObjectToRefresherResponse(DCOMANSWER): 2097 structure = ( 2098 ('pInfo', _WBEM_REFRESH_INFO), 2099 ('pdwSvrRefrVersion', DWORD), 2100 ('ErrorCode', error_status_t), 2101 ) 2102 2103# 3.1.4.12.2 IWbemRefreshingServices::AddObjectToRefresherByTemplate (Opnum 4) 2104class IWbemRefreshingServices_AddObjectToRefresherByTemplate(DCOMCALL): 2105 opnum = 4 2106 structure = ( 2107 ('pRefresherId', _WBEM_REFRESHER_ID), 2108 ('pTemplate', PMInterfacePointer), 2109 ('lFlags', LONG), 2110 ('pContext', PMInterfacePointer), 2111 ('dwClientRefrVersion', DWORD), 2112 ) 2113 2114class IWbemRefreshingServices_AddObjectToRefresherByTemplateResponse(DCOMANSWER): 2115 structure = ( 2116 ('pInfo', _WBEM_REFRESH_INFO), 2117 ('pdwSvrRefrVersion', DWORD), 2118 ('ErrorCode', error_status_t), 2119 ) 2120 2121# 3.1.4.12.3 IWbemRefreshingServices::AddEnumToRefresher (Opnum 5) 2122class IWbemRefreshingServices_AddEnumToRefresher(DCOMCALL): 2123 opnum = 5 2124 structure = ( 2125 ('pRefresherId', _WBEM_REFRESHER_ID), 2126 ('wszClass', LPWSTR), 2127 ('lFlags', LONG), 2128 ('pContext', PMInterfacePointer), 2129 ('dwClientRefrVersion', DWORD), 2130 ) 2131 2132class IWbemRefreshingServices_AddEnumToRefresherResponse(DCOMANSWER): 2133 structure = ( 2134 ('pInfo', _WBEM_REFRESH_INFO), 2135 ('pdwSvrRefrVersion', DWORD), 2136 ('ErrorCode', error_status_t), 2137 ) 2138 2139# 3.1.4.12.4 IWbemRefreshingServices::RemoveObjectFromRefresher (Opnum 6) 2140class IWbemRefreshingServices_RemoveObjectFromRefresher(DCOMCALL): 2141 opnum = 6 2142 structure = ( 2143 ('pRefresherId', _WBEM_REFRESHER_ID), 2144 ('lId', LONG), 2145 ('lFlags', LONG), 2146 ('dwClientRefrVersion', DWORD), 2147 ) 2148 2149class IWbemRefreshingServices_RemoveObjectFromRefresherResponse(DCOMANSWER): 2150 structure = ( 2151 ('pdwSvrRefrVersion', DWORD), 2152 ('ErrorCode', error_status_t), 2153 ) 2154 2155# 3.1.4.12.5 IWbemRefreshingServices::GetRemoteRefresher (Opnum 7) 2156class IWbemRefreshingServices_GetRemoteRefresher(DCOMCALL): 2157 opnum = 7 2158 structure = ( 2159 ('pRefresherId', _WBEM_REFRESHER_ID), 2160 ('lFlags', LONG), 2161 ('dwClientRefrVersion', DWORD), 2162 ) 2163 2164class IWbemRefreshingServices_GetRemoteRefresherResponse(DCOMANSWER): 2165 structure = ( 2166 ('ppRemRefresher', PMInterfacePointer), 2167 ('pGuid', GUID), 2168 ('pdwSvrRefrVersion', DWORD), 2169 ('ErrorCode', error_status_t), 2170 ) 2171 2172# 3.1.4.12.6 IWbemRefreshingServices::ReconnectRemoteRefresher (Opnum 8) 2173class IWbemRefreshingServices_ReconnectRemoteRefresher(DCOMCALL): 2174 opnum = 8 2175 structure = ( 2176 ('pRefresherId', _WBEM_REFRESHER_ID), 2177 ('lFlags', LONG), 2178 ('lNumObjects', LONG), 2179 ('dwClientRefrVersion', DWORD), 2180 ('apReconnectInfo', _WBEM_RECONNECT_INFO_ARRAY), 2181 ) 2182 2183class IWbemRefreshingServices_ReconnectRemoteRefresherResponse(DCOMANSWER): 2184 structure = ( 2185 ('apReconnectResults', _WBEM_RECONNECT_RESULTS_ARRAY), 2186 ('pdwSvrRefrVersion', DWORD), 2187 ('ErrorCode', error_status_t), 2188 ) 2189 2190# 3.1.4.13 IWbemRemoteRefresher Interface 2191# 3.1.4.13.1 IWbemRemoteRefresher::RemoteRefresh (Opnum 3) 2192class IWbemRemoteRefresher_RemoteRefresh(DCOMCALL): 2193 opnum = 3 2194 structure = ( 2195 ('lFlags', LONG), 2196 ) 2197 2198class IWbemRemoteRefresher_RemoteRefreshResponse(DCOMANSWER): 2199 structure = ( 2200 ('plNumObjects', _WBEM_RECONNECT_RESULTS_ARRAY), 2201 ('paObjects', PWBEM_REFRESHED_OBJECT_ARRAY), 2202 ('ErrorCode', error_status_t), 2203 ) 2204 2205# 3.1.4.13.2 IWbemRemoteRefresher::StopRefreshing (Opnum 4) 2206class IWbemRemoteRefresher_StopRefreshing(DCOMCALL): 2207 opnum = 4 2208 structure = ( 2209 ('lNumIds', LONG), 2210 ('aplIds', PULONG_ARRAY), 2211 ('lFlags', LONG), 2212 ) 2213 2214class IWbemRemoteRefresher_StopRefreshingResponse(DCOMANSWER): 2215 structure = ( 2216 ('ErrorCode', error_status_t), 2217 ) 2218 2219# 3.1.4.14 IWbemShutdown Interface 2220# 3.1.4.14.1 IWbemShutdown::Shutdown (Opnum 3) 2221class IWbemShutdown_Shutdown(DCOMCALL): 2222 opnum = 3 2223 structure = ( 2224 ('reserved1', LONG), 2225 ('reserved2', ULONG), 2226 ('reserved3', PMInterfacePointer), 2227 ) 2228 2229class IWbemShutdown_ShutdownResponse(DCOMANSWER): 2230 structure = ( 2231 ('ErrorCode', error_status_t), 2232 ) 2233 2234# 3.1.4.15 IUnsecuredApartment Interface 2235# 3.1.4.15.1 IUnsecuredApartment::CreateObjectStub (Opnum 3) 2236class IUnsecuredApartment_CreateObjectStub(DCOMCALL): 2237 opnum = 3 2238 structure = ( 2239 ('reserved1', PMInterfacePointer), 2240 ) 2241 2242class IUnsecuredApartment_CreateObjectStubResponse(DCOMANSWER): 2243 structure = ( 2244 ('reserved2', PMInterfacePointer), 2245 ('ErrorCode', error_status_t), 2246 ) 2247 2248# 3.1.4.16 IWbemUnsecuredApartment Interface 2249# 3.1.4.16.1 IWbemUnsecuredApartment::CreateSinkStub (Opnum 3) 2250class IWbemUnsecuredApartment_CreateSinkStub(DCOMCALL): 2251 opnum = 3 2252 structure = ( 2253 ('reserved1', PMInterfacePointer), 2254 ('reserved2', DWORD), 2255 ('reserved3', LPWSTR), 2256 ) 2257 2258class IWbemUnsecuredApartment_CreateSinkStubResponse(DCOMANSWER): 2259 structure = ( 2260 ('reserved4', PMInterfacePointer), 2261 ('ErrorCode', error_status_t), 2262 ) 2263 2264################################################################################ 2265# OPNUMs and their corresponding structures 2266################################################################################ 2267OPNUMS = { 2268} 2269 2270################################################################################ 2271# HELPER FUNCTIONS AND INTERFACES 2272################################################################################ 2273def checkNullString(string): 2274 if string == NULL: 2275 return string 2276 2277 if string[-1:] != '\x00': 2278 return string + '\x00' 2279 else: 2280 return string 2281 2282class IWbemClassObject(IRemUnknown): 2283 def __init__(self, interface, iWbemServices = None): 2284 IRemUnknown.__init__(self,interface) 2285 self._iid = IID_IWbemClassObject 2286 self.__iWbemServices = iWbemServices 2287 self.__methods = None 2288 2289 objRef = self.get_objRef() 2290 objRef = OBJREF_CUSTOM(objRef) 2291 self.encodingUnit = ENCODING_UNIT(objRef['pObjectData']) 2292 self.parseObject() 2293 if self.encodingUnit['ObjectBlock'].isInstance() is False: 2294 self.createMethods(self.getClassName(), self.getMethods()) 2295 else: 2296 self.createProperties(self.getProperties()) 2297 2298 def __getattr__(self, attr): 2299 if attr.startswith('__') is not True: 2300 properties = self.getProperties() 2301 # Let's see if there's a key property so we can ExecMethod 2302 keyProperty = None 2303 for pName in properties: 2304 if properties[pName]['qualifiers'].has_key('key'): 2305 keyProperty = pName 2306 2307 if keyProperty is None: 2308 LOG.error("I don't have a key property in this set!") 2309 else: 2310 if self.__methods is None: 2311 classObject,_ = self.__iWbemServices.GetObject(self.getClassName()) 2312 self.__methods = classObject.getMethods() 2313 2314 if self.__methods.has_key(attr): 2315 # Now we gotta build the class name to be called through ExecMethod 2316 if self.getProperties()[keyProperty]['stype'] != 'string': 2317 instanceName = '%s.%s=%s' % ( 2318 self.getClassName(), keyProperty, self.getProperties()[keyProperty]['value']) 2319 else: 2320 instanceName = '%s.%s="%s"' % ( 2321 self.getClassName(), keyProperty, self.getProperties()[keyProperty]['value']) 2322 2323 self.createMethods(instanceName , self.__methods) 2324 #print dir(self) 2325 return getattr(self, attr) 2326 2327 raise AttributeError("%r object has no attribute %r" % 2328 (self.__class__, attr)) 2329 2330 def parseObject(self): 2331 self.encodingUnit['ObjectBlock'].parseObject() 2332 2333 def getObject(self): 2334 return self.encodingUnit['ObjectBlock'] 2335 2336 def getClassName(self): 2337 if self.encodingUnit['ObjectBlock'].isInstance() is False: 2338 return self.encodingUnit['ObjectBlock']['ClassType']['CurrentClass'].getClassName().split(' ')[0] 2339 else: 2340 return self.encodingUnit['ObjectBlock']['InstanceType']['CurrentClass'].getClassName().split(' ')[0] 2341 2342 def printInformation(self): 2343 return self.encodingUnit['ObjectBlock'].printInformation() 2344 2345 def getProperties(self): 2346 if self.encodingUnit['ObjectBlock'].ctCurrent is None: 2347 return () 2348 return self.encodingUnit['ObjectBlock'].ctCurrent['properties'] 2349 2350 def getMethods(self): 2351 if self.encodingUnit['ObjectBlock'].ctCurrent is None: 2352 return () 2353 return self.encodingUnit['ObjectBlock'].ctCurrent['methods'] 2354 2355 def marshalMe(self): 2356 # So, in theory, we have the OBJCUSTOM built, but 2357 # we need to update the values 2358 # That's what we'll do 2359 2360 instanceHeap = '' 2361 valueTable = '' 2362 ndTable = 0 2363 parametersClass = ENCODED_STRING() 2364 parametersClass['Character'] = self.getClassName() 2365 instanceHeap += str(parametersClass) 2366 curHeapPtr = len(instanceHeap) 2367 properties = self.getProperties() 2368 for i, propName in enumerate(properties): 2369 propRecord = properties[propName] 2370 itemValue = getattr(self, propName) 2371 2372 pType = propRecord['type'] & (~(CIM_ARRAY_FLAG|Inherited)) 2373 if propRecord['type'] & CIM_ARRAY_FLAG: 2374 # Not yet ready 2375 packStr = HEAPREF[:-2] 2376 else: 2377 packStr = CIM_TYPES_REF[pType][:-2] 2378 2379 if propRecord['type'] & CIM_ARRAY_FLAG: 2380 if itemValue is None: 2381 valueTable += pack(packStr, 0) 2382 else: 2383 valueTable += pack('<L', curHeapPtr) 2384 arraySize = pack(HEAPREF[:-2], len(itemValue)) 2385 packStrArray = CIM_TYPES_REF[pType][:-2] 2386 arrayItems = '' 2387 for j in range(len(itemValue)): 2388 arrayItems += pack(packStrArray, itemValue[j]) 2389 instanceHeap += arraySize + str(arrayItems) 2390 curHeapPtr = len(instanceHeap) 2391 elif pType not in (CIM_TYPE_ENUM.CIM_TYPE_STRING.value, CIM_TYPE_ENUM.CIM_TYPE_DATETIME.value, 2392 CIM_TYPE_ENUM.CIM_TYPE_REFERENCE.value, CIM_TYPE_ENUM.CIM_TYPE_OBJECT.value): 2393 if itemValue is None: 2394 valueTable += pack(packStr, -1) 2395 else: 2396 valueTable += pack(packStr, itemValue) 2397 elif pType == CIM_TYPE_ENUM.CIM_TYPE_OBJECT.value: 2398 # For now we just pack None 2399 valueTable += '\x00'*4 2400 # The default property value is NULL, and it is 2401 # inherited from a parent class. 2402 if itemValue is None: 2403 ndTable |= 3 << (2*i) 2404 else: 2405 if itemValue is '': 2406 ndTable |= 1 << (2*i) 2407 valueTable += pack('<L', 0) 2408 else: 2409 strIn = ENCODED_STRING() 2410 strIn['Character'] = itemValue 2411 valueTable += pack('<L', curHeapPtr) 2412 instanceHeap += str(strIn) 2413 curHeapPtr = len(instanceHeap) 2414 2415 ndTableLen = (len(properties) - 1) / 4 + 1 2416 packedNdTable = '' 2417 for i in range(ndTableLen): 2418 packedNdTable += pack('B', ndTable & 0xff) 2419 ndTable >>= 8 2420 2421 # Now let's update the structure 2422 objRef = self.get_objRef() 2423 objRef = OBJREF_CUSTOM(objRef) 2424 encodingUnit = ENCODING_UNIT(objRef['pObjectData']) 2425 2426 currentClass = encodingUnit['ObjectBlock']['InstanceType']['CurrentClass'] 2427 encodingUnit['ObjectBlock']['InstanceType']['CurrentClass'] = '' 2428 2429 encodingUnit['ObjectBlock']['InstanceType']['NdTable_ValueTable'] = packedNdTable + valueTable 2430 encodingUnit['ObjectBlock']['InstanceType']['InstanceHeap']['HeapLength'] = len(instanceHeap) | 0x80000000 2431 encodingUnit['ObjectBlock']['InstanceType']['InstanceHeap']['HeapItem'] = instanceHeap 2432 2433 encodingUnit['ObjectBlock']['InstanceType']['EncodingLength'] = len(encodingUnit['ObjectBlock']['InstanceType']) 2434 encodingUnit['ObjectBlock']['InstanceType']['CurrentClass'] = currentClass 2435 2436 encodingUnit['ObjectEncodingLength'] = len(encodingUnit['ObjectBlock']) 2437 2438 #encodingUnit.dump() 2439 #ENCODING_UNIT(str(encodingUnit)).dump() 2440 2441 objRef['pObjectData'] = encodingUnit 2442 2443 return objRef 2444 2445 def SpawnInstance(self): 2446 # Doing something similar to: 2447 # http://msdn.microsoft.com/en-us/library/aa391458(v=vs.85).aspx 2448 # 2449 if self.encodingUnit['ObjectBlock'].isInstance() is False: 2450 # We need to convert some things to transform a class into an instance 2451 encodingUnit = ENCODING_UNIT() 2452 2453 instanceData = OBJECT_BLOCK() 2454 instanceData.structure += OBJECT_BLOCK.decoration 2455 instanceData.structure += OBJECT_BLOCK.instanceType 2456 instanceData['ObjectFlags'] = 6 2457 instanceData['Decoration'] = str(self.encodingUnit['ObjectBlock']['Decoration']) 2458 2459 instanceType = INSTANCE_TYPE() 2460 instanceType['CurrentClass'] = '' 2461 2462 # Let's create the heap for the parameters 2463 instanceHeap = '' 2464 valueTable = '' 2465 parametersClass = ENCODED_STRING() 2466 parametersClass['Character'] = self.getClassName() 2467 instanceHeap += str(parametersClass) 2468 curHeapPtr = len(instanceHeap) 2469 2470 ndTable = 0 2471 properties = self.getProperties() 2472 2473 # Let's initialize the values 2474 for i, propName in enumerate(properties): 2475 propRecord = properties[propName] 2476 2477 pType = propRecord['type'] & (~(CIM_ARRAY_FLAG|Inherited)) 2478 if propRecord['type'] & CIM_ARRAY_FLAG: 2479 # Not yet ready 2480 #print paramDefinition 2481 #raise 2482 packStr = HEAPREF[:-2] 2483 else: 2484 packStr = CIM_TYPES_REF[pType][:-2] 2485 2486 if propRecord['type'] & CIM_ARRAY_FLAG: 2487 valueTable += pack(packStr, 0) 2488 elif pType not in (CIM_TYPE_ENUM.CIM_TYPE_STRING.value, CIM_TYPE_ENUM.CIM_TYPE_DATETIME.value, 2489 CIM_TYPE_ENUM.CIM_TYPE_REFERENCE.value, CIM_TYPE_ENUM.CIM_TYPE_OBJECT.value): 2490 valueTable += pack(packStr, 0) 2491 elif pType == CIM_TYPE_ENUM.CIM_TYPE_OBJECT.value: 2492 # For now we just pack None 2493 valueTable += '\x00'*4 2494 # The default property value is NULL, and it is 2495 # inherited from a parent class. 2496 ndTable |= 3 << (2*i) 2497 else: 2498 strIn = ENCODED_STRING() 2499 strIn['Character'] = '' 2500 valueTable += pack('<L', curHeapPtr) 2501 instanceHeap += str(strIn) 2502 curHeapPtr = len(instanceHeap) 2503 2504 ndTableLen = (len(properties) - 1) / 4 + 1 2505 packedNdTable = '' 2506 for i in range(ndTableLen): 2507 packedNdTable += pack('B', ndTable & 0xff) 2508 ndTable >>= 8 2509 2510 instanceType['NdTable_ValueTable'] = packedNdTable + valueTable 2511 2512 instanceType['InstanceQualifierSet'] = '\x04\x00\x00\x00\x01' 2513 2514 instanceType['InstanceHeap'] = HEAP() 2515 instanceType['InstanceHeap']['HeapItem'] = instanceHeap 2516 instanceType['InstanceHeap']['HeapLength'] = len(instanceHeap) | 0x80000000 2517 instanceType['EncodingLength'] = len(instanceType) 2518 2519 instanceType['CurrentClass'] = self.encodingUnit['ObjectBlock']['ClassType']['CurrentClass']['ClassPart'] 2520 instanceData['InstanceType'] = str(instanceType) 2521 2522 encodingUnit['ObjectBlock'] = instanceData 2523 encodingUnit['ObjectEncodingLength'] = len(instanceData) 2524 2525 #ENCODING_UNIT(str(encodingUnit)).dump() 2526 2527 objRefCustomIn = OBJREF_CUSTOM() 2528 objRefCustomIn['iid'] = self._iid 2529 objRefCustomIn['clsid'] = CLSID_WbemClassObject 2530 objRefCustomIn['cbExtension'] = 0 2531 objRefCustomIn['ObjectReferenceSize'] = len(encodingUnit) 2532 objRefCustomIn['pObjectData'] = encodingUnit 2533 2534 # There's gotta be a better way to do this 2535 # I will reimplement this stuff once I know it works 2536 import copy 2537 newObj = copy.deepcopy(self) 2538 newObj.set_objRef(str(objRefCustomIn)) 2539 newObj.process_interface(str(objRefCustomIn)) 2540 newObj.encodingUnit = ENCODING_UNIT(str(encodingUnit)) 2541 newObj.parseObject() 2542 if newObj.encodingUnit['ObjectBlock'].isInstance() is False: 2543 newObj.createMethods(newObj.getClassName(), newObj.getMethods()) 2544 else: 2545 newObj.createProperties(newObj.getProperties()) 2546 2547 return newObj 2548 else: 2549 return self 2550 2551 def createProperties(self, properties): 2552 for property in properties: 2553 # Do we have an object property? 2554 if properties[property]['type'] == CIM_TYPE_ENUM.CIM_TYPE_OBJECT.value: 2555 # Yes.. let's create an Object for it too 2556 objRef = OBJREF_CUSTOM() 2557 objRef['iid'] = self._iid 2558 objRef['clsid'] = CLSID_WbemClassObject 2559 objRef['cbExtension'] = 0 2560 objRef['ObjectReferenceSize'] = len(str(properties[property]['value'])) 2561 objRef['pObjectData'] = properties[property]['value'] 2562 value = IWbemClassObject( INTERFACE(self.get_cinstance(), objRef.getData(), self.get_ipidRemUnknown(), 2563 oxid=self.get_oxid(), target=self.get_target())) 2564 elif properties[property]['type'] == CIM_TYPE_ENUM.CIM_ARRAY_OBJECT.value: 2565 if isinstance(properties[property]['value'], list): 2566 value = list() 2567 for item in properties[property]['value']: 2568 # Yes.. let's create an Object for it too 2569 objRef = OBJREF_CUSTOM() 2570 objRef['iid'] = self._iid 2571 objRef['clsid'] = CLSID_WbemClassObject 2572 objRef['cbExtension'] = 0 2573 objRef['ObjectReferenceSize'] = len(str(item)) 2574 objRef['pObjectData'] = item 2575 wbemClass = IWbemClassObject( 2576 INTERFACE(self.get_cinstance(), objRef.getData(), self.get_ipidRemUnknown(), 2577 oxid=self.get_oxid(), target=self.get_target())) 2578 value.append(wbemClass) 2579 else: 2580 value = properties[property]['value'] 2581 else: 2582 value = properties[property]['value'] 2583 setattr(self, property, value) 2584 2585 def createMethods(self, classOrInstance, methods): 2586 class FunctionPool: 2587 def __init__(self,function): 2588 self.function = function 2589 def __getitem__(self,item): 2590 return partial(self.function,item) 2591 2592 @FunctionPool 2593 def innerMethod(staticArgs, *args): 2594 classOrInstance = staticArgs[0] 2595 methodDefinition = staticArgs[1] 2596 if methodDefinition['InParams'] is not None: 2597 if len(args) != len(methodDefinition['InParams']): 2598 LOG.error("Function called with %d parameters instead of %d!" % (len(args), len(methodDefinition['InParams']))) 2599 return None 2600 # In Params 2601 encodingUnit = ENCODING_UNIT() 2602 2603 inParams = OBJECT_BLOCK() 2604 inParams.structure += OBJECT_BLOCK.instanceType 2605 inParams['ObjectFlags'] = 2 2606 inParams['Decoration'] = '' 2607 2608 instanceType = INSTANCE_TYPE() 2609 instanceType['CurrentClass'] = '' 2610 instanceType['InstanceQualifierSet'] = '\x04\x00\x00\x00\x01' 2611 2612 # Let's create the heap for the parameters 2613 instanceHeap = '' 2614 valueTable = '' 2615 parametersClass = ENCODED_STRING() 2616 parametersClass['Character'] = '__PARAMETERS' 2617 instanceHeap += str(parametersClass) 2618 curHeapPtr = len(instanceHeap) 2619 2620 ndTable = 0 2621 for i in range(len(args)): 2622 paramDefinition = methodDefinition['InParams'].values()[i] 2623 inArg = args[i] 2624 2625 pType = paramDefinition['type'] & (~(CIM_ARRAY_FLAG|Inherited)) 2626 if paramDefinition['type'] & CIM_ARRAY_FLAG: 2627 # Not yet ready 2628 #print paramDefinition 2629 #raise 2630 packStr = HEAPREF[:-2] 2631 else: 2632 packStr = CIM_TYPES_REF[pType][:-2] 2633 2634 if paramDefinition['type'] & CIM_ARRAY_FLAG: 2635 2636 if inArg is None: 2637 valueTable += pack(packStr, 0) 2638 else: 2639 # ToDo 2640 # Not yet ready 2641 raise Exception('inArg not None') 2642 elif pType not in (CIM_TYPE_ENUM.CIM_TYPE_STRING.value, CIM_TYPE_ENUM.CIM_TYPE_DATETIME.value, 2643 CIM_TYPE_ENUM.CIM_TYPE_REFERENCE.value, CIM_TYPE_ENUM.CIM_TYPE_OBJECT.value): 2644 valueTable += pack(packStr, inArg) 2645 elif pType == CIM_TYPE_ENUM.CIM_TYPE_OBJECT.value: 2646 # For now we just pack None 2647 valueTable += '\x00'*4 2648 # The default property value is NULL, and it is 2649 # inherited from a parent class. 2650 if inArg is None: 2651 ndTable |= 3 << (2*i) 2652 else: 2653 strIn = ENCODED_STRING() 2654 if type(inArg) is unicode: 2655 # The Encoded-String-Flag is set to 0x01 if the sequence of characters that follows 2656 # consists of UTF-16 characters (as specified in [UNICODE]) followed by a UTF-16 null 2657 # terminator. 2658 strIn['Encoded_String_Flag'] = 0x1 2659 strIn.structure = strIn.tunicode 2660 strIn['Character'] = inArg.encode('utf-16le') 2661 else: 2662 strIn['Character'] = inArg 2663 valueTable += pack('<L', curHeapPtr) 2664 instanceHeap += str(strIn) 2665 curHeapPtr = len(instanceHeap) 2666 2667 ndTableLen = (len(args) - 1) / 4 + 1 2668 2669 packedNdTable = '' 2670 for i in range(ndTableLen): 2671 packedNdTable += pack('B', ndTable & 0xff) 2672 ndTable >>= 8 2673 2674 instanceType['NdTable_ValueTable'] = packedNdTable + valueTable 2675 heapRecord = HEAP() 2676 heapRecord['HeapLength'] = len(instanceHeap) | 0x80000000 2677 heapRecord['HeapItem'] = instanceHeap 2678 2679 instanceType['InstanceHeap'] = heapRecord 2680 2681 instanceType['EncodingLength'] = len(instanceType) 2682 inMethods = methodDefinition['InParamsRaw']['ClassType']['CurrentClass']['ClassPart'] 2683 inMethods['ClassHeader']['EncodingLength'] = len( 2684 str(methodDefinition['InParamsRaw']['ClassType']['CurrentClass']['ClassPart'])) 2685 instanceType['CurrentClass'] = inMethods 2686 2687 inParams['InstanceType'] = str(instanceType) 2688 2689 encodingUnit['ObjectBlock'] = inParams 2690 encodingUnit['ObjectEncodingLength'] = len(inParams) 2691 2692 objRefCustomIn = OBJREF_CUSTOM() 2693 objRefCustomIn['iid'] = self._iid 2694 objRefCustomIn['clsid'] = CLSID_WbemClassObject 2695 objRefCustomIn['cbExtension'] = 0 2696 objRefCustomIn['ObjectReferenceSize'] = len(encodingUnit) 2697 objRefCustomIn['pObjectData'] = encodingUnit 2698 else: 2699 objRefCustomIn = NULL 2700 2701 ### OutParams 2702 encodingUnit = ENCODING_UNIT() 2703 2704 outParams = OBJECT_BLOCK() 2705 outParams.structure += OBJECT_BLOCK.instanceType 2706 outParams['ObjectFlags'] = 2 2707 outParams['Decoration'] = '' 2708 2709 instanceType = INSTANCE_TYPE() 2710 instanceType['CurrentClass'] = '' 2711 instanceType['NdTable_ValueTable'] = '' 2712 instanceType['InstanceQualifierSet'] = '' 2713 instanceType['InstanceHeap'] = '' 2714 instanceType['EncodingLength'] = len(instanceType) 2715 instanceType['CurrentClass'] = str(methodDefinition['OutParamsRaw']['ClassType']['CurrentClass']['ClassPart']) 2716 outParams['InstanceType'] = str(instanceType) 2717 2718 2719 encodingUnit['ObjectBlock'] = outParams 2720 encodingUnit['ObjectEncodingLength'] = len(outParams) 2721 2722 objRefCustom = OBJREF_CUSTOM() 2723 objRefCustom['iid'] = self._iid 2724 objRefCustom['clsid'] = CLSID_WbemClassObject 2725 objRefCustom['cbExtension'] = 0 2726 objRefCustom['ObjectReferenceSize'] = len(encodingUnit) 2727 objRefCustom['pObjectData'] = encodingUnit 2728 try: 2729 return self.__iWbemServices.ExecMethod(classOrInstance, methodDefinition['name'], pInParams = objRefCustomIn ) 2730 #return self.__iWbemServices.ExecMethod('Win32_Process.Handle="436"', methodDefinition['name'], 2731 # pInParams=objRefCustomIn).getObject().ctCurrent['properties'] 2732 except Exception, e: 2733 if LOG.level == logging.DEBUG: 2734 import traceback 2735 traceback.print_exc() 2736 LOG.error(str(e)) 2737 2738 for methodName in methods: 2739 innerMethod.__name__ = methodName 2740 setattr(self,innerMethod.__name__,innerMethod[classOrInstance,methods[methodName]]) 2741 #methods = self.encodingUnit['ObjectBlock'] 2742 2743 2744class IWbemLoginClientID(IRemUnknown): 2745 def __init__(self, interface): 2746 IRemUnknown.__init__(self,interface) 2747 self._iid = IID_IWbemLoginClientID 2748 2749 def SetClientInfo(self, wszClientMachine, lClientProcId = 1234): 2750 request = IWbemLoginClientID_SetClientInfo() 2751 request['wszClientMachine'] = checkNullString(wszClientMachine) 2752 request['lClientProcId'] = lClientProcId 2753 request['lReserved'] = 0 2754 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2755 return resp 2756 2757class IWbemLoginHelper(IRemUnknown): 2758 def __init__(self, interface): 2759 IRemUnknown.__init__(self,interface) 2760 self._iid = IID_IWbemLoginHelper 2761 2762 def SetEvent(self, sEventToSet): 2763 request = IWbemLoginHelper_SetEvent() 2764 request['sEventToSet'] = sEventToSet 2765 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2766 resp.dump() 2767 return resp 2768 2769 2770class IWbemWCOSmartEnum(IRemUnknown): 2771 def __init__(self, interface): 2772 IRemUnknown.__init__(self,interface) 2773 self._iid = IID_IWbemWCOSmartEnum 2774 2775 def Next(self, proxyGUID, lTimeout, uCount): 2776 request = IWbemWCOSmartEnum_Next() 2777 request['proxyGUID'] = proxyGUID 2778 request['lTimeout'] = lTimeout 2779 request['uCount'] = uCount 2780 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2781 resp.dump() 2782 return resp 2783 2784class IWbemFetchSmartEnum(IRemUnknown): 2785 def __init__(self, interface): 2786 IRemUnknown.__init__(self,interface) 2787 self._iid = IID_IWbemFetchSmartEnum 2788 2789 def GetSmartEnum(self, lTimeout): 2790 request = IWbemFetchSmartEnum_GetSmartEnum() 2791 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2792 resp.dump() 2793 return resp 2794 2795class IWbemCallResult(IRemUnknown): 2796 def __init__(self, interface): 2797 IRemUnknown.__init__(self,interface) 2798 self._iid = IID_IWbemCallResult 2799 2800 def GetResultObject(self, lTimeout): 2801 request = IWbemCallResult_GetResultObject() 2802 request['lTimeout'] = lTimeout 2803 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2804 resp.dump() 2805 return resp 2806 2807 def GetResultString(self, lTimeout): 2808 request = IWbemCallResult_GetResultString() 2809 request['lTimeout'] = lTimeout 2810 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2811 resp.dump() 2812 return resp 2813 2814 def GetResultServices(self, lTimeout): 2815 request = IWbemCallResult_GetResultServices() 2816 request['lTimeout'] = lTimeout 2817 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2818 resp.dump() 2819 return resp 2820 2821 def GetCallStatus(self, lTimeout): 2822 request = IWbemCallResult_GetCallStatus() 2823 request['lTimeout'] = lTimeout 2824 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2825 return resp['plStatus'] 2826 2827class IEnumWbemClassObject(IRemUnknown): 2828 def __init__(self, interface, iWbemServices = None): 2829 IRemUnknown.__init__(self,interface) 2830 self._iid = IID_IEnumWbemClassObject 2831 self.__iWbemServices = iWbemServices 2832 2833 def Reset(self): 2834 request = IEnumWbemClassObject_Reset() 2835 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2836 resp.dump() 2837 return resp 2838 2839 def Next(self, lTimeout, uCount): 2840 request = IEnumWbemClassObject_Next() 2841 request['lTimeout'] = lTimeout 2842 request['uCount'] = uCount 2843 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2844 interfaces = list() 2845 for interface in resp['apObjects']: 2846 interfaces.append(IWbemClassObject( 2847 INTERFACE(self.get_cinstance(), ''.join(interface['abData']), self.get_ipidRemUnknown(), 2848 oxid=self.get_oxid(), target=self.get_target()), self.__iWbemServices)) 2849 2850 return interfaces 2851 2852 def NextAsync(self, lTimeout, pSink): 2853 request = IEnumWbemClassObject_NextAsync() 2854 request['lTimeout'] = lTimeout 2855 request['pSink'] = pSink 2856 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2857 resp.dump() 2858 return resp 2859 2860 def Clone(self): 2861 request = IEnumWbemClassObject_Clone() 2862 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2863 resp.dump() 2864 return resp 2865 2866 def Skip(self, lTimeout, uCount): 2867 request = IEnumWbemClassObject_Skip() 2868 request['lTimeout'] = lTimeout 2869 request['uCount'] = uCount 2870 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2871 resp.dump() 2872 return resp 2873 2874class IWbemServices(IRemUnknown): 2875 def __init__(self, interface): 2876 IRemUnknown.__init__(self,interface) 2877 self._iid = IID_IWbemServices 2878 2879 def OpenNamespace(self, strNamespace, lFlags=0, pCtx = NULL): 2880 request = IWbemServices_OpenNamespace() 2881 request['strNamespace']['asData'] = strNamespace 2882 request['lFlags'] = lFlags 2883 request['pCtx'] = pCtx 2884 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2885 resp.dump() 2886 return resp 2887 2888 def CancelAsyncCall(self,IWbemObjectSink ): 2889 request = IWbemServices_CancelAsyncCall() 2890 request['IWbemObjectSink'] = IWbemObjectSink 2891 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2892 return resp['ErrorCode'] 2893 2894 def QueryObjectSink(self): 2895 request = IWbemServices_QueryObjectSink() 2896 request['lFlags'] = 0 2897 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2898 return INTERFACE(self.get_cinstance(), ''.join(resp['ppResponseHandler']['abData']), self.get_ipidRemUnknown(), 2899 target=self.get_target()) 2900 2901 def GetObject(self, strObjectPath, lFlags=0, pCtx=NULL): 2902 request = IWbemServices_GetObject() 2903 request['strObjectPath']['asData'] = strObjectPath 2904 request['lFlags'] = lFlags 2905 request['pCtx'] = pCtx 2906 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2907 ppObject = IWbemClassObject( 2908 INTERFACE(self.get_cinstance(), ''.join(resp['ppObject']['abData']), self.get_ipidRemUnknown(), 2909 oxid=self.get_oxid(), target=self.get_target()), self) 2910 if resp['ppCallResult'] != NULL: 2911 ppcallResult = IWbemCallResult( 2912 INTERFACE(self.get_cinstance(), ''.join(resp['ppObject']['abData']), self.get_ipidRemUnknown(), 2913 target=self.get_target())) 2914 else: 2915 ppcallResult = NULL 2916 return ppObject, ppcallResult 2917 2918 def GetObjectAsync(self, strNamespace, lFlags=0, pCtx = NULL): 2919 request = IWbemServices_GetObjectAsync() 2920 request['strObjectPath']['asData'] = checkNullString(strNamespace) 2921 request['lFlags'] = lFlags 2922 request['pCtx'] = pCtx 2923 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2924 resp.dump() 2925 return resp 2926 2927 def PutClass(self, pObject, lFlags=0, pCtx=NULL): 2928 request = IWbemServices_PutClass() 2929 request['pObject'] = pObject 2930 request['lFlags'] = lFlags 2931 request['pCtx'] = pCtx 2932 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2933 resp.dump() 2934 return resp 2935 2936 def PutClassAsync(self, pObject, lFlags=0, pCtx=NULL): 2937 request = IWbemServices_PutClassAsync() 2938 request['pObject'] = pObject 2939 request['lFlags'] = lFlags 2940 request['pCtx'] = pCtx 2941 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2942 resp.dump() 2943 return resp 2944 2945 def DeleteClass(self, strClass, lFlags=0, pCtx=NULL): 2946 request = IWbemServices_DeleteClass() 2947 request['strClass']['asData'] = checkNullString(strClass) 2948 request['lFlags'] = lFlags 2949 request['pCtx'] = pCtx 2950 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2951 resp.dump() 2952 return resp 2953 2954 def DeleteClassAsync(self, strClass, lFlags=0, pCtx=NULL): 2955 request = IWbemServices_DeleteClassAsync() 2956 request['strClass']['asData'] = checkNullString(strClass) 2957 request['lFlags'] = lFlags 2958 request['pCtx'] = pCtx 2959 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2960 resp.dump() 2961 return resp 2962 2963 def CreateClassEnum(self, strSuperClass, lFlags=0, pCtx=NULL): 2964 request = IWbemServices_CreateClassEnum() 2965 request['strSuperClass']['asData'] = checkNullString(strSuperClass) 2966 request['lFlags'] = lFlags 2967 request['pCtx'] = pCtx 2968 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2969 resp.dump() 2970 return resp 2971 2972 def CreateClassEnumAsync(self, strSuperClass, lFlags=0, pCtx=NULL): 2973 request = IWbemServices_CreateClassEnumAsync() 2974 request['strSuperClass']['asData'] = checkNullString(strSuperClass) 2975 request['lFlags'] = lFlags 2976 request['pCtx'] = pCtx 2977 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2978 resp.dump() 2979 return resp 2980 2981 def PutInstance(self, pInst, lFlags=0, pCtx=NULL): 2982 request = IWbemServices_PutInstance() 2983 2984 if pInst is NULL: 2985 request['pInst'] = pInst 2986 else: 2987 request['pInst']['ulCntData'] = len(pInst) 2988 request['pInst']['abData'] = list(str(pInst)) 2989 request['lFlags'] = lFlags 2990 request['pCtx'] = pCtx 2991 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 2992 return IWbemCallResult( 2993 INTERFACE(self.get_cinstance(), ''.join(resp['ppCallResult']['abData']), self.get_ipidRemUnknown(), 2994 target=self.get_target())) 2995 2996 def PutInstanceAsync(self, pInst, lFlags=0, pCtx=NULL): 2997 request = IWbemServices_PutInstanceAsync() 2998 request['pInst'] = pInst 2999 request['lFlags'] = lFlags 3000 request['pCtx'] = pCtx 3001 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 3002 resp.dump() 3003 return resp 3004 3005 def DeleteInstance(self, strObjectPath, lFlags=0, pCtx=NULL): 3006 request = IWbemServices_DeleteInstance() 3007 request['strObjectPath']['asData'] = checkNullString(strObjectPath) 3008 request['lFlags'] = lFlags 3009 request['pCtx'] = pCtx 3010 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 3011 return IWbemCallResult( 3012 INTERFACE(self.get_cinstance(), ''.join(resp['ppCallResult']['abData']), self.get_ipidRemUnknown(), 3013 target=self.get_target())) 3014 3015 def DeleteInstanceAsync(self, strObjectPath, lFlags=0, pCtx=NULL): 3016 request = IWbemServices_DeleteInstanceAsync() 3017 request['strObjectPath']['asData'] = checkNullString(strObjectPath) 3018 request['lFlags'] = lFlags 3019 request['pCtx'] = pCtx 3020 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 3021 resp.dump() 3022 return resp 3023 3024 def CreateInstanceEnum(self, strSuperClass, lFlags=0, pCtx=NULL): 3025 request = IWbemServices_CreateInstanceEnum() 3026 request['strSuperClass']['asData'] = strSuperClass 3027 request['lFlags'] = lFlags 3028 request['pCtx'] = pCtx 3029 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 3030 resp.dump() 3031 return IEnumWbemClassObject( 3032 INTERFACE(self.get_cinstance(), ''.join(resp['ppEnum']['abData']), self.get_ipidRemUnknown(), 3033 target=self.get_target())) 3034 3035 def CreateInstanceEnumAsync(self, strSuperClass, lFlags=0, pCtx=NULL): 3036 request = IWbemServices_CreateInstanceEnumAsync() 3037 request['strSuperClass']['asData'] = checkNullString(strSuperClass) 3038 request['lFlags'] = lFlags 3039 request['pCtx'] = pCtx 3040 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 3041 resp.dump() 3042 return resp 3043 3044 #def ExecQuery(self, strQuery, lFlags=WBEM_QUERY_FLAG_TYPE.WBEM_FLAG_PROTOTYPE, pCtx=NULL): 3045 def ExecQuery(self, strQuery, lFlags=0, pCtx=NULL): 3046 request = IWbemServices_ExecQuery() 3047 request['strQueryLanguage']['asData'] = checkNullString('WQL') 3048 request['strQuery']['asData'] = checkNullString(strQuery) 3049 request['lFlags'] = lFlags 3050 request['pCtx'] = pCtx 3051 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 3052 return IEnumWbemClassObject( 3053 INTERFACE(self.get_cinstance(), ''.join(resp['ppEnum']['abData']), self.get_ipidRemUnknown(), 3054 target=self.get_target()), self) 3055 3056 def ExecQueryAsync(self, strQuery, lFlags=0, pCtx=NULL): 3057 request = IWbemServices_ExecQueryAsync() 3058 request['strQueryLanguage']['asData'] = checkNullString('WQL') 3059 request['strQuery']['asData'] = checkNullString(strQuery) 3060 request['lFlags'] = lFlags 3061 request['pCtx'] = pCtx 3062 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 3063 resp.dump() 3064 return resp 3065 3066 def ExecNotificationQuery(self, strQuery, lFlags=0, pCtx=NULL): 3067 request = IWbemServices_ExecNotificationQuery() 3068 request['strQueryLanguage']['asData'] = checkNullString('WQL') 3069 request['strQuery']['asData'] = checkNullString(strQuery) 3070 request['lFlags'] = lFlags 3071 request['pCtx'] = pCtx 3072 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 3073 return IEnumWbemClassObject( 3074 INTERFACE(self.get_cinstance(), ''.join(resp['ppEnum']['abData']), self.get_ipidRemUnknown(), 3075 target=self.get_target()), self) 3076 3077 def ExecNotificationQueryAsync(self, strQuery, lFlags=0, pCtx=NULL): 3078 request = IWbemServices_ExecNotificationQueryAsync() 3079 request['strQueryLanguage']['asData'] = checkNullString('WQL') 3080 request['strQuery']['asData'] = checkNullString(strQuery) 3081 request['lFlags'] = lFlags 3082 request['pCtx'] = pCtx 3083 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 3084 resp.dump() 3085 return resp 3086 3087 def ExecMethod(self, strObjectPath, strMethodName, lFlags=0, pCtx=NULL, pInParams=NULL, ppOutParams = NULL): 3088 request = IWbemServices_ExecMethod() 3089 request['strObjectPath']['asData'] = checkNullString(strObjectPath) 3090 request['strMethodName']['asData'] = checkNullString(strMethodName) 3091 request['lFlags'] = lFlags 3092 request['pCtx'] = pCtx 3093 if pInParams is NULL: 3094 request['pInParams'] = pInParams 3095 else: 3096 request['pInParams']['ulCntData'] = len(pInParams) 3097 request['pInParams']['abData'] = list(str(pInParams)) 3098 3099 request.fields['ppCallResult'] = NULL 3100 if ppOutParams is NULL: 3101 request.fields['ppOutParams'].fields['Data'] = NULL 3102 else: 3103 request['ppOutParams']['ulCntData'] = len(str(ppOutParams)) 3104 request['ppOutParams']['abData'] = list(str(ppOutParams)) 3105 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 3106 return IWbemClassObject( 3107 INTERFACE(self.get_cinstance(), ''.join(resp['ppOutParams']['abData']), self.get_ipidRemUnknown(), 3108 oxid=self.get_oxid(), target=self.get_target())) 3109 3110 def ExecMethodAsync(self, strObjectPath, strMethodName, lFlags=0, pCtx=NULL, pInParams=NULL): 3111 request = IWbemServices_ExecMethodAsync() 3112 request['strObjectPath']['asData'] = checkNullString(strObjectPath) 3113 request['strMethodName']['asData'] = checkNullString(strMethodName) 3114 request['lFlags'] = lFlags 3115 request['pCtx'] = pCtx 3116 request['pInParams'] = pInParams 3117 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 3118 resp.dump() 3119 return resp 3120 3121class IWbemLevel1Login(IRemUnknown): 3122 def __init__(self, interface): 3123 IRemUnknown.__init__(self,interface) 3124 self._iid = IID_IWbemLevel1Login 3125 3126 def EstablishPosition(self): 3127 request = IWbemLevel1Login_EstablishPosition() 3128 request['reserved1'] = NULL 3129 request['reserved2'] = 0 3130 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 3131 return resp['LocaleVersion'] 3132 3133 def RequestChallenge(self): 3134 request = IWbemLevel1Login_RequestChallenge() 3135 request['reserved1'] = NULL 3136 request['reserved2'] = NULL 3137 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 3138 return resp['reserved3'] 3139 3140 def WBEMLogin(self): 3141 request = IWbemLevel1Login_WBEMLogin() 3142 request['reserved1'] = NULL 3143 request['reserved2'] = NULL 3144 request['reserved3'] = 0 3145 request['reserved4'] = NULL 3146 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 3147 return resp['reserved5'] 3148 3149 def NTLMLogin(self, wszNetworkResource, wszPreferredLocale, pCtx): 3150 request = IWbemLevel1Login_NTLMLogin() 3151 request['wszNetworkResource'] = checkNullString(wszNetworkResource) 3152 request['wszPreferredLocale'] = checkNullString(wszPreferredLocale) 3153 request['lFlags'] = 0 3154 request['pCtx'] = pCtx 3155 resp = self.request(request, iid = self._iid, uuid = self.get_iPid()) 3156 return IWbemServices( 3157 INTERFACE(self.get_cinstance(), ''.join(resp['ppNamespace']['abData']), self.get_ipidRemUnknown(), 3158 target=self.get_target())) 3159 3160 3161if __name__ == '__main__': 3162 # Example 1 3163 baseClass = 'xV4\x12\xd0\x00\x00\x00\x05\x00DPRAVAT-DEV\x00\x00ROOT\x00\x1d\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80f\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x01\x00\x00\x00\x06\x00\x00\x00\n\x00\x00\x00\x05\xff\xff\xff\xff<\x00\x00\x80\x00Base\x00\x00Id\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\n\x00\x00\x80\x03\x08\x00\x00\x004\x00\x00\x00\x01\x00\x00\x80\x13\x0b\x00\x00\x00\xff\xff\x00sint32\x00\x0c\x00\x00\x00\x00\x004\x00\x00\x00\x00\x80\x00\x80\x13\x0b\x00\x00\x00\xff\xff\x00sint32\x00' 3164 3165 #encodingUnit = EncodingUnit(baseClass) 3166 #encodingUnit.dump() 3167 #encodingUnit['ObjectBlock'].printInformation() 3168 #print "LEN ", len(baseClass), len(encodingUnit) 3169 3170 myClass = "xV4\x12.\x02\x00\x00\x05\x00DPRAVAT-DEV\x00\x00ROOT\x00f\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x01\x00\x00\x00\x06\x00\x00\x00\n\x00\x00\x00\x05\xff\xff\xff\xff<\x00\x00\x80\x00Base\x00\x00Id\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\n\x00\x00\x80\x03\x08\x00\x00\x004\x00\x00\x00\x01\x00\x00\x80\x13\x0b\x00\x00\x00\xff\xff\x00sint32\x00\x0c\x00\x00\x00\x00\x004\x00\x00\x00\x00\x80v\x01\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x0e\x00\x00\x00\x00Base\x00\x06\x00\x00\x00\x11\x00\x00\x00\t\x00\x00\x00\x00\x08\x00\x00\x00\x16\x00\x00\x00\x04\x00\x00\x00'\x00\x00\x00.\x00\x00\x00U\x00\x00\x00\\\x00\x00\x00\x99\x00\x00\x00\xa0\x00\x00\x00\xc7\x00\x00\x00\xcb\x00\x00\x00G\xff\xff\xff\xff\xff\xff\xff\xff\xfd\x00\x00\x00\xff\xff\xff\xff\x11\x01\x00\x80\x00MyClass\x00\x00Description\x00\x00MyClass Example\x00\x00Array\x00\x13 \x00\x00\x03\x00\x0c\x00\x00\x00\x01\x00\x00\x00\x11\x00\x00\x00\n\x00\x00\x80\x03\x08\x00\x00\x00M\x00\x00\x00\x00uint32\x00\x00Data1\x00\x08\x00\x00\x00\x01\x00\x04\x00\x00\x00\x01\x00\x00\x00'\x00\x00\x00\n\x00\x00\x80\x03\x08\x00\x00\x00\x91\x00\x00\x00\x03\x00\x00\x80\x00\x0b\x00\x00\x00\xff\xff\x04\x00\x00\x80\x00\x0b\x00\x00\x00\xff\xff\x00string\x00\x00Data2\x00\x08\x00\x00\x00\x02\x00\x08\x00\x00\x00\x01\x00\x00\x00\x11\x00\x00\x00\n\x00\x00\x80\x03\x08\x00\x00\x00\xbf\x00\x00\x00\x00string\x00\x00Id\x00\x03@\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\n\x00\x00\x80#\x08\x00\x00\x00\xf5\x00\x00\x00\x01\x00\x00\x803\x0b\x00\x00\x00\xff\xff\x00sint32\x00\x00defaultValue\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00s\x00\x00\x00\x802\x00\x00defaultValue\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00" 3171 #hexdump(myClass) 3172 #encodingUnit = EncodingUnit(myClass) 3173 #print "LEN ", len(myClass), len(encodingUnit) 3174 #encodingUnit.dump() 3175 #encodingUnit['ObjectBlock'].printInformation() 3176 3177 instanceMyClass = "xV4\x12\xd3\x01\x00\x00\x06\x00DPRAVAT-DEV\x00\x00ROOT\x00v\x01\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x0e\x00\x00\x00\x00Base\x00\x06\x00\x00\x00\x11\x00\x00\x00\t\x00\x00\x00\x00\x08\x00\x00\x00\x16\x00\x00\x00\x04\x00\x00\x00'\x00\x00\x00.\x00\x00\x00U\x00\x00\x00\\\x00\x00\x00\x99\x00\x00\x00\xa0\x00\x00\x00\xc7\x00\x00\x00\xcb\x00\x00\x00G\xff\xff\xff\xff\xff\xff\xff\xff\xfd\x00\x00\x00\xff\xff\xff\xff\x11\x01\x00\x80\x00MyClass\x00\x00Description\x00\x00MyClass Example\x00\x00Array\x00\x13 \x00\x00\x03\x00\x0c\x00\x00\x00\x01\x00\x00\x00\x11\x00\x00\x00\n\x00\x00\x80\x03\x08\x00\x00\x00M\x00\x00\x00\x00uint32\x00\x00Data1\x00\x08\x00\x00\x00\x01\x00\x04\x00\x00\x00\x01\x00\x00\x00'\x00\x00\x00\n\x00\x00\x80\x03\x08\x00\x00\x00\x91\x00\x00\x00\x03\x00\x00\x80\x00\x0b\x00\x00\x00\xff\xff\x04\x00\x00\x80\x00\x0b\x00\x00\x00\xff\xff\x00string\x00\x00Data2\x00\x08\x00\x00\x00\x02\x00\x08\x00\x00\x00\x01\x00\x00\x00\x11\x00\x00\x00\n\x00\x00\x80\x03\x08\x00\x00\x00\xbf\x00\x00\x00\x00string\x00\x00Id\x00\x03@\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\n\x00\x00\x80#\x08\x00\x00\x00\xf5\x00\x00\x00\x01\x00\x00\x803\x0b\x00\x00\x00\xff\xff\x00sint32\x00\x00defaultValue\x00\x00\x00\x00\x00\x00\x00I\x00\x00\x00\x00\x00\x00\x00\x00 {\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\t\x00\x00\x00\x04\x00\x00\x00\x01&\x00\x00\x80\x00MyClass\x00\x03\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x00StringField\x00" 3178 #encodingUnit = EncodingUnit(instanceMyClass) 3179 #encodingUnit.dump() 3180 #encodingUnit['ObjectBlock'].printInformation() 3181 3182