Coverage for /root/GitHubProjects/impacket/impacket/dcerpc/v5/dcom/wmi.py : 66%

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