2 * Copyright 2012 Hans Leidekker for CodeWeavers
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
29 #include "wine/debug.h"
30 #include "wbemprox_private.h"
32 WINE_DEFAULT_DEBUG_CHANNEL(wbemprox);
34 struct enum_class_object
36 IEnumWbemClassObject IEnumWbemClassObject_iface;
42 static inline struct enum_class_object *impl_from_IEnumWbemClassObject(
43 IEnumWbemClassObject *iface )
45 return CONTAINING_RECORD(iface, struct enum_class_object, IEnumWbemClassObject_iface);
48 static ULONG WINAPI enum_class_object_AddRef(
49 IEnumWbemClassObject *iface )
51 struct enum_class_object *ec = impl_from_IEnumWbemClassObject( iface );
52 return InterlockedIncrement( &ec->refs );
55 static ULONG WINAPI enum_class_object_Release(
56 IEnumWbemClassObject *iface )
58 struct enum_class_object *ec = impl_from_IEnumWbemClassObject( iface );
59 LONG refs = InterlockedDecrement( &ec->refs );
62 TRACE("destroying %p\n", ec);
63 release_query( ec->query );
69 static HRESULT WINAPI enum_class_object_QueryInterface(
70 IEnumWbemClassObject *iface,
74 struct enum_class_object *ec = impl_from_IEnumWbemClassObject( iface );
76 TRACE("%p, %s, %p\n", ec, debugstr_guid( riid ), ppvObject );
78 if ( IsEqualGUID( riid, &IID_IEnumWbemClassObject ) ||
79 IsEqualGUID( riid, &IID_IUnknown ) )
83 else if ( IsEqualGUID( riid, &IID_IClientSecurity ) )
85 *ppvObject = &client_security;
90 FIXME("interface %s not implemented\n", debugstr_guid(riid));
93 IEnumWbemClassObject_AddRef( iface );
97 static HRESULT WINAPI enum_class_object_Reset(
98 IEnumWbemClassObject *iface )
100 struct enum_class_object *ec = impl_from_IEnumWbemClassObject( iface );
102 TRACE("%p\n", iface);
105 return WBEM_S_NO_ERROR;
108 static HRESULT WINAPI enum_class_object_Next(
109 IEnumWbemClassObject *iface,
112 IWbemClassObject **apObjects,
115 struct enum_class_object *ec = impl_from_IEnumWbemClassObject( iface );
116 struct view *view = ec->query->view;
119 TRACE("%p, %d, %u, %p, %p\n", iface, lTimeout, uCount, apObjects, puReturned);
121 if (!uCount) return WBEM_S_FALSE;
122 if (!apObjects || !puReturned) return WBEM_E_INVALID_PARAMETER;
123 if (lTimeout != WBEM_INFINITE) FIXME("timeout not supported\n");
126 if (ec->index + uCount > view->count) return WBEM_S_FALSE;
128 hr = create_class_object( view->table->name, iface, ec->index, NULL, apObjects );
129 if (hr != S_OK) return hr;
133 if (ec->index == view->count) return WBEM_S_FALSE;
134 if (uCount > 1) return WBEM_S_TIMEDOUT;
135 return WBEM_S_NO_ERROR;
138 static HRESULT WINAPI enum_class_object_NextAsync(
139 IEnumWbemClassObject *iface,
141 IWbemObjectSink *pSink )
143 FIXME("%p, %u, %p\n", iface, uCount, pSink);
147 static HRESULT WINAPI enum_class_object_Clone(
148 IEnumWbemClassObject *iface,
149 IEnumWbemClassObject **ppEnum )
151 struct enum_class_object *ec = impl_from_IEnumWbemClassObject( iface );
153 TRACE("%p, %p\n", iface, ppEnum);
155 return EnumWbemClassObject_create( NULL, ec->query, (void **)ppEnum );
158 static HRESULT WINAPI enum_class_object_Skip(
159 IEnumWbemClassObject *iface,
163 struct enum_class_object *ec = impl_from_IEnumWbemClassObject( iface );
164 struct view *view = ec->query->view;
166 TRACE("%p, %d, %u\n", iface, lTimeout, nCount);
168 if (lTimeout != WBEM_INFINITE) FIXME("timeout not supported\n");
170 if (!view->count) return WBEM_S_FALSE;
172 if (nCount > view->count - ec->index)
174 ec->index = view->count - 1;
178 return WBEM_S_NO_ERROR;
181 static const IEnumWbemClassObjectVtbl enum_class_object_vtbl =
183 enum_class_object_QueryInterface,
184 enum_class_object_AddRef,
185 enum_class_object_Release,
186 enum_class_object_Reset,
187 enum_class_object_Next,
188 enum_class_object_NextAsync,
189 enum_class_object_Clone,
190 enum_class_object_Skip
193 HRESULT EnumWbemClassObject_create(
194 IUnknown *pUnkOuter, struct query *query, LPVOID *ppObj )
196 struct enum_class_object *ec;
198 TRACE("%p, %p\n", pUnkOuter, ppObj);
200 ec = heap_alloc( sizeof(*ec) );
201 if (!ec) return E_OUTOFMEMORY;
203 ec->IEnumWbemClassObject_iface.lpVtbl = &enum_class_object_vtbl;
205 ec->query = addref_query( query );
208 *ppObj = &ec->IEnumWbemClassObject_iface;
210 TRACE("returning iface %p\n", *ppObj);
214 static struct record *create_record( struct table *table )
217 struct record *record;
219 if (!(record = heap_alloc( sizeof(struct record) ))) return NULL;
220 if (!(record->fields = heap_alloc( table->num_cols * sizeof(struct field) )))
225 for (i = 0; i < table->num_cols; i++)
227 record->fields[i].type = table->columns[i].type;
228 record->fields[i].vartype = table->columns[i].vartype;
229 record->fields[i].u.ival = 0;
231 record->count = table->num_cols;
232 record->table = addref_table( table );
236 void destroy_array( struct array *array, CIMTYPE type )
241 if (type == CIM_STRING || type == CIM_DATETIME)
243 size = get_type_size( type );
244 for (i = 0; i < array->count; i++) heap_free( *(WCHAR **)((char *)array->ptr + i * size) );
246 heap_free( array->ptr );
250 static void destroy_record( struct record *record )
255 release_table( record->table );
256 for (i = 0; i < record->count; i++)
258 if (record->fields[i].type == CIM_STRING || record->fields[i].type == CIM_DATETIME)
259 heap_free( record->fields[i].u.sval );
260 else if (record->fields[i].type & CIM_FLAG_ARRAY)
261 destroy_array( record->fields[i].u.aval, record->fields[i].type & CIM_TYPE_MASK );
263 heap_free( record->fields );
269 IWbemClassObject IWbemClassObject_iface;
272 IEnumWbemClassObject *iter;
276 struct record *record; /* uncommitted instance */
279 static inline struct class_object *impl_from_IWbemClassObject(
280 IWbemClassObject *iface )
282 return CONTAINING_RECORD(iface, struct class_object, IWbemClassObject_iface);
285 static ULONG WINAPI class_object_AddRef(
286 IWbemClassObject *iface )
288 struct class_object *co = impl_from_IWbemClassObject( iface );
289 return InterlockedIncrement( &co->refs );
292 static ULONG WINAPI class_object_Release(
293 IWbemClassObject *iface )
295 struct class_object *co = impl_from_IWbemClassObject( iface );
296 LONG refs = InterlockedDecrement( &co->refs );
299 TRACE("destroying %p\n", co);
300 if (co->iter) IEnumWbemClassObject_Release( co->iter );
301 destroy_record( co->record );
302 heap_free( co->name );
308 static HRESULT WINAPI class_object_QueryInterface(
309 IWbemClassObject *iface,
313 struct class_object *co = impl_from_IWbemClassObject( iface );
315 TRACE("%p, %s, %p\n", co, debugstr_guid( riid ), ppvObject );
317 if ( IsEqualGUID( riid, &IID_IWbemClassObject ) ||
318 IsEqualGUID( riid, &IID_IUnknown ) )
322 else if (IsEqualGUID( riid, &IID_IClientSecurity ))
324 *ppvObject = &client_security;
329 FIXME("interface %s not implemented\n", debugstr_guid(riid));
330 return E_NOINTERFACE;
332 IWbemClassObject_AddRef( iface );
336 static HRESULT WINAPI class_object_GetQualifierSet(
337 IWbemClassObject *iface,
338 IWbemQualifierSet **ppQualSet )
340 FIXME("%p, %p\n", iface, ppQualSet);
344 static HRESULT record_get_value( const struct record *record, UINT index, VARIANT *var, CIMTYPE *type )
346 VARTYPE vartype = record->fields[index].vartype;
348 if (type) *type = record->fields[index].type;
350 if (record->fields[index].type & CIM_FLAG_ARRAY)
352 V_VT( var ) = vartype ? vartype : to_vartype( record->fields[index].type & CIM_TYPE_MASK ) | VT_ARRAY;
353 V_ARRAY( var ) = to_safearray( record->fields[index].u.aval, record->fields[index].type & CIM_TYPE_MASK );
356 switch (record->fields[index].type)
360 if (!vartype) vartype = VT_BSTR;
361 V_BSTR( var ) = SysAllocString( record->fields[index].u.sval );
364 if (!vartype) vartype = VT_I4;
365 V_I4( var ) = record->fields[index].u.ival;
368 if (!vartype) vartype = VT_UI4;
369 V_UI4( var ) = record->fields[index].u.ival;
372 FIXME("unhandled type %u\n", record->fields[index].type);
373 return WBEM_E_INVALID_PARAMETER;
375 V_VT( var ) = vartype;
379 static HRESULT WINAPI class_object_Get(
380 IWbemClassObject *iface,
387 struct class_object *co = impl_from_IWbemClassObject( iface );
388 struct enum_class_object *ec = impl_from_IEnumWbemClassObject( co->iter );
390 TRACE("%p, %s, %08x, %p, %p, %p\n", iface, debugstr_w(wszName), lFlags, pVal, pType, plFlavor);
397 if ((hr = get_column_index( co->record->table, wszName, &index )) != S_OK) return hr;
398 return record_get_value( co->record, index, pVal, pType );
400 return get_propval( ec->query->view, co->index, wszName, pVal, pType, plFlavor );
403 static HRESULT record_set_value( struct record *record, UINT index, VARIANT *var )
409 if ((hr = to_longlong( var, &val, &type )) != S_OK) return hr;
410 if (type != record->fields[index].type) return WBEM_E_TYPE_MISMATCH;
412 if (type & CIM_FLAG_ARRAY)
414 record->fields[index].u.aval = (struct array *)(INT_PTR)val;
421 record->fields[index].u.sval = (WCHAR *)(INT_PTR)val;
427 record->fields[index].u.ival = val;
430 FIXME("unhandled type %u\n", type);
433 return WBEM_E_INVALID_PARAMETER;
436 static HRESULT WINAPI class_object_Put(
437 IWbemClassObject *iface,
443 struct class_object *co = impl_from_IWbemClassObject( iface );
444 struct enum_class_object *ec = impl_from_IEnumWbemClassObject( co->iter );
446 TRACE("%p, %s, %08x, %p, %u\n", iface, debugstr_w(wszName), lFlags, pVal, Type);
453 if ((hr = get_column_index( co->record->table, wszName, &index )) != S_OK) return hr;
454 return record_set_value( co->record, index, pVal );
456 return put_propval( ec->query->view, co->index, wszName, pVal, Type );
459 static HRESULT WINAPI class_object_Delete(
460 IWbemClassObject *iface,
463 FIXME("%p, %s\n", iface, debugstr_w(wszName));
467 static HRESULT WINAPI class_object_GetNames(
468 IWbemClassObject *iface,
469 LPCWSTR wszQualifierName,
471 VARIANT *pQualifierVal,
474 struct class_object *co = impl_from_IWbemClassObject( iface );
475 struct enum_class_object *ec = impl_from_IEnumWbemClassObject( co->iter );
477 TRACE("%p, %s, %08x, %p, %p\n", iface, debugstr_w(wszQualifierName), lFlags, pQualifierVal, pNames);
479 if (wszQualifierName || pQualifierVal)
481 FIXME("qualifier not supported\n");
484 if (lFlags != WBEM_FLAG_ALWAYS)
486 FIXME("flags %08x not supported\n", lFlags);
489 return get_properties( ec->query->view, pNames );
492 static HRESULT WINAPI class_object_BeginEnumeration(
493 IWbemClassObject *iface,
496 struct class_object *co = impl_from_IWbemClassObject( iface );
498 TRACE("%p, %08x\n", iface, lEnumFlags);
500 if (lEnumFlags) FIXME("flags 0x%08x not supported\n", lEnumFlags);
502 co->index_property = 0;
506 static HRESULT WINAPI class_object_Next(
507 IWbemClassObject *iface,
514 struct class_object *co = impl_from_IWbemClassObject( iface );
515 struct enum_class_object *ec = impl_from_IEnumWbemClassObject( co->iter );
516 struct view *view = ec->query->view;
520 TRACE("%p, %08x, %p, %p, %p, %p\n", iface, lFlags, strName, pVal, pType, plFlavor);
522 if (!(property = get_property_name( co->name, co->index_property ))) return WBEM_S_NO_MORE_DATA;
523 if ((hr = get_propval( view, co->index, property, pVal, pType, plFlavor ) != S_OK))
525 SysFreeString( property );
529 co->index_property++;
533 static HRESULT WINAPI class_object_EndEnumeration(
534 IWbemClassObject *iface )
536 struct class_object *co = impl_from_IWbemClassObject( iface );
538 TRACE("%p\n", iface);
540 co->index_property = 0;
544 static HRESULT WINAPI class_object_GetPropertyQualifierSet(
545 IWbemClassObject *iface,
547 IWbemQualifierSet **ppQualSet )
549 struct class_object *co = impl_from_IWbemClassObject( iface );
551 TRACE("%p, %s, %p\n", iface, debugstr_w(wszProperty), ppQualSet);
553 return WbemQualifierSet_create( NULL, co->name, wszProperty, (void **)ppQualSet );
556 static HRESULT WINAPI class_object_Clone(
557 IWbemClassObject *iface,
558 IWbemClassObject **ppCopy )
560 FIXME("%p, %p\n", iface, ppCopy);
564 static BSTR get_body_text( const struct table *table, UINT row, UINT *len )
566 static const WCHAR fmtW[] = {'\n','\t','%','s',' ','=',' ','%','s',';',0};
572 for (i = 0; i < table->num_cols; i++)
574 if ((value = get_value_bstr( table, row, i )))
576 *len += sizeof(fmtW) / sizeof(fmtW[0]);
577 *len += strlenW( table->columns[i].name );
578 *len += SysStringLen( value );
579 SysFreeString( value );
582 if (!(ret = SysAllocStringLen( NULL, *len ))) return NULL;
584 for (i = 0; i < table->num_cols; i++)
586 if ((value = get_value_bstr( table, row, i )))
588 p += sprintfW( p, fmtW, table->columns[i].name, value );
589 SysFreeString( value );
595 static BSTR get_object_text( const struct view *view, UINT index )
597 static const WCHAR fmtW[] =
598 {'\n','i','n','s','t','a','n','c','e',' ','o','f',' ','%','s','\n','{','%','s','\n','}',';',0};
599 UINT len, len_body, row = view->result[index];
602 len = sizeof(fmtW) / sizeof(fmtW[0]);
603 len += strlenW( view->table->name );
604 if (!(body = get_body_text( view->table, row, &len_body ))) return NULL;
607 if (!(ret = SysAllocStringLen( NULL, len ))) return NULL;
608 sprintfW( ret, fmtW, view->table->name, body );
609 SysFreeString( body );
613 static HRESULT WINAPI class_object_GetObjectText(
614 IWbemClassObject *iface,
616 BSTR *pstrObjectText )
618 struct class_object *co = impl_from_IWbemClassObject( iface );
619 struct enum_class_object *ec = impl_from_IEnumWbemClassObject( co->iter );
620 struct view *view = ec->query->view;
623 TRACE("%p, %08x, %p\n", iface, lFlags, pstrObjectText);
625 if (lFlags) FIXME("flags %08x not implemented\n", lFlags);
627 if (!(text = get_object_text( view, co->index ))) return E_OUTOFMEMORY;
628 *pstrObjectText = text;
632 static HRESULT WINAPI class_object_SpawnDerivedClass(
633 IWbemClassObject *iface,
635 IWbemClassObject **ppNewClass )
637 FIXME("%p, %08x, %p\n", iface, lFlags, ppNewClass);
641 static HRESULT WINAPI class_object_SpawnInstance(
642 IWbemClassObject *iface,
644 IWbemClassObject **ppNewInstance )
646 struct class_object *co = impl_from_IWbemClassObject( iface );
647 struct enum_class_object *ec = impl_from_IEnumWbemClassObject( co->iter );
648 struct view *view = ec->query->view;
649 struct record *record;
651 TRACE("%p, %08x, %p\n", iface, lFlags, ppNewInstance);
653 if (!(record = create_record( view->table ))) return E_OUTOFMEMORY;
655 return create_class_object( co->name, NULL, 0, record, ppNewInstance );
658 static HRESULT WINAPI class_object_CompareTo(
659 IWbemClassObject *iface,
661 IWbemClassObject *pCompareTo )
663 FIXME("%p, %08x, %p\n", iface, lFlags, pCompareTo);
667 static HRESULT WINAPI class_object_GetPropertyOrigin(
668 IWbemClassObject *iface,
670 BSTR *pstrClassName )
672 FIXME("%p, %s, %p\n", iface, debugstr_w(wszName), pstrClassName);
676 static HRESULT WINAPI class_object_InheritsFrom(
677 IWbemClassObject *iface,
678 LPCWSTR strAncestor )
680 FIXME("%p, %s\n", iface, debugstr_w(strAncestor));
684 static UINT count_instances( IEnumWbemClassObject *iter )
687 while (!IEnumWbemClassObject_Skip( iter, WBEM_INFINITE, 1 )) count++;
688 IEnumWbemClassObject_Reset( iter );
692 static void set_default_value( CIMTYPE type, UINT val, BYTE *ptr )
700 *(UINT16 *)ptr = val;
706 *(UINT32 *)ptr = val;
709 FIXME("unhandled type %u\n", type);
714 static HRESULT create_signature_columns_and_data( IEnumWbemClassObject *iter, UINT *num_cols,
715 struct column **cols, BYTE **data )
717 static const WCHAR parameterW[] = {'P','a','r','a','m','e','t','e','r',0};
718 static const WCHAR typeW[] = {'T','y','p','e',0};
719 static const WCHAR varianttypeW[] = {'V','a','r','i','a','n','t','T','y','p','e',0};
720 static const WCHAR defaultvalueW[] = {'D','e','f','a','u','l','t','V','a','l','u','e',0};
721 struct column *columns;
723 IWbemClassObject *param;
725 HRESULT hr = E_OUTOFMEMORY;
730 count = count_instances( iter );
731 if (!(columns = heap_alloc( count * sizeof(struct column) ))) return E_OUTOFMEMORY;
732 if (!(row = heap_alloc_zero( count * sizeof(LONGLONG) ))) goto error;
736 IEnumWbemClassObject_Next( iter, WBEM_INFINITE, 1, ¶m, &count );
739 hr = IWbemClassObject_Get( param, parameterW, 0, &val, NULL, NULL );
740 if (hr != S_OK) goto error;
741 columns[i].name = heap_strdupW( V_BSTR( &val ) );
742 VariantClear( &val );
744 hr = IWbemClassObject_Get( param, typeW, 0, &val, NULL, NULL );
745 if (hr != S_OK) goto error;
746 columns[i].type = V_UI4( &val );
748 hr = IWbemClassObject_Get( param, varianttypeW, 0, &val, NULL, NULL );
749 if (hr != S_OK) goto error;
750 columns[i].vartype = V_UI4( &val );
752 hr = IWbemClassObject_Get( param, defaultvalueW, 0, &val, NULL, NULL );
753 if (hr != S_OK) goto error;
754 if (V_UI4( &val )) set_default_value( columns[i].type, V_UI4( &val ), row + offset );
755 offset += get_type_size( columns[i].type );
757 IWbemClassObject_Release( param );
766 for (; i >= 0; i--) heap_free( (WCHAR *)columns[i].name );
767 heap_free( columns );
772 static HRESULT create_signature_table( IEnumWbemClassObject *iter, WCHAR *name )
776 struct column *columns;
780 hr = create_signature_columns_and_data( iter, &num_cols, &columns, &row );
781 if (hr != S_OK) return hr;
783 if (!(table = create_table( name, num_cols, columns, 1, row, NULL )))
785 free_columns( columns, num_cols );
787 return E_OUTOFMEMORY;
789 if (!add_table( table )) free_table( table ); /* already exists */
793 static WCHAR *build_signature_table_name( const WCHAR *class, const WCHAR *method, enum param_direction dir )
795 static const WCHAR fmtW[] = {'_','_','%','s','_','%','s','_','%','s',0};
796 static const WCHAR outW[] = {'O','U','T',0};
797 static const WCHAR inW[] = {'I','N',0};
798 UINT len = SIZEOF(fmtW) + SIZEOF(outW) + strlenW( class ) + strlenW( method );
801 if (!(ret = heap_alloc( len * sizeof(WCHAR) ))) return NULL;
802 sprintfW( ret, fmtW, class, method, dir == PARAM_IN ? inW : outW );
803 return struprW( ret );
806 HRESULT create_signature( const WCHAR *class, const WCHAR *method, enum param_direction dir,
807 IWbemClassObject **sig )
809 static const WCHAR selectW[] =
810 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
811 '_','_','P','A','R','A','M','E','T','E','R','S',' ','W','H','E','R','E',' ',
812 'C','l','a','s','s','=','\'','%','s','\'',' ','A','N','D',' ',
813 'M','e','t','h','o','d','=','\'','%','s','\'',' ','A','N','D',' ',
814 'D','i','r','e','c','t','i','o','n','%','s',0};
815 static const WCHAR geW[] = {'>','=','0',0};
816 static const WCHAR leW[] = {'<','=','0',0};
817 UINT len = SIZEOF(selectW) + SIZEOF(geW);
818 IEnumWbemClassObject *iter;
822 len += strlenW( class ) + strlenW( method );
823 if (!(query = heap_alloc( len * sizeof(WCHAR) ))) return E_OUTOFMEMORY;
824 sprintfW( query, selectW, class, method, dir >= 0 ? geW : leW );
826 hr = exec_query( query, &iter );
828 if (hr != S_OK) return hr;
830 if (!(name = build_signature_table_name( class, method, dir )))
832 IEnumWbemClassObject_Release( iter );
833 return E_OUTOFMEMORY;
835 hr = create_signature_table( iter, name );
836 IEnumWbemClassObject_Release( iter );
842 return get_object( name, sig );
845 static HRESULT WINAPI class_object_GetMethod(
846 IWbemClassObject *iface,
849 IWbemClassObject **ppInSignature,
850 IWbemClassObject **ppOutSignature )
852 struct class_object *co = impl_from_IWbemClassObject( iface );
853 IWbemClassObject *in, *out;
856 TRACE("%p, %s, %08x, %p, %p\n", iface, debugstr_w(wszName), lFlags, ppInSignature, ppOutSignature);
858 hr = create_signature( co->name, wszName, PARAM_IN, &in );
859 if (hr != S_OK) return hr;
861 hr = create_signature( co->name, wszName, PARAM_OUT, &out );
864 if (ppInSignature) *ppInSignature = in;
865 else IWbemClassObject_Release( in );
866 if (ppOutSignature) *ppOutSignature = out;
867 else IWbemClassObject_Release( out );
869 else IWbemClassObject_Release( in );
873 static HRESULT WINAPI class_object_PutMethod(
874 IWbemClassObject *iface,
877 IWbemClassObject *pInSignature,
878 IWbemClassObject *pOutSignature )
880 FIXME("%p, %s, %08x, %p, %p\n", iface, debugstr_w(wszName), lFlags, pInSignature, pOutSignature);
884 static HRESULT WINAPI class_object_DeleteMethod(
885 IWbemClassObject *iface,
888 FIXME("%p, %s\n", iface, debugstr_w(wszName));
892 static HRESULT WINAPI class_object_BeginMethodEnumeration(
893 IWbemClassObject *iface,
896 struct class_object *co = impl_from_IWbemClassObject( iface );
898 TRACE("%p, %08x\n", iface, lEnumFlags);
900 if (lEnumFlags) FIXME("flags 0x%08x not supported\n", lEnumFlags);
904 WARN("not allowed on instance\n");
905 return WBEM_E_ILLEGAL_OPERATION;
907 co->index_method = 0;
911 static HRESULT WINAPI class_object_NextMethod(
912 IWbemClassObject *iface,
915 IWbemClassObject **ppInSignature,
916 IWbemClassObject **ppOutSignature)
918 struct class_object *co = impl_from_IWbemClassObject( iface );
922 TRACE("%p, %08x, %p, %p, %p\n", iface, lFlags, pstrName, ppInSignature, ppOutSignature);
924 if (!(method = get_method_name( co->name, co->index_method ))) return WBEM_S_NO_MORE_DATA;
926 hr = create_signature( co->name, method, PARAM_IN, ppInSignature );
929 SysFreeString( method );
932 hr = create_signature( co->name, method, PARAM_OUT, ppOutSignature );
935 SysFreeString( method );
936 IWbemClassObject_Release( *ppInSignature );
946 static HRESULT WINAPI class_object_EndMethodEnumeration(
947 IWbemClassObject *iface )
949 struct class_object *co = impl_from_IWbemClassObject( iface );
951 TRACE("%p\n", iface);
953 co->index_method = 0;
957 static HRESULT WINAPI class_object_GetMethodQualifierSet(
958 IWbemClassObject *iface,
960 IWbemQualifierSet **ppQualSet)
962 FIXME("%p, %s, %p\n", iface, debugstr_w(wszMethod), ppQualSet);
966 static HRESULT WINAPI class_object_GetMethodOrigin(
967 IWbemClassObject *iface,
968 LPCWSTR wszMethodName,
971 FIXME("%p, %s, %p\n", iface, debugstr_w(wszMethodName), pstrClassName);
975 static const IWbemClassObjectVtbl class_object_vtbl =
977 class_object_QueryInterface,
979 class_object_Release,
980 class_object_GetQualifierSet,
984 class_object_GetNames,
985 class_object_BeginEnumeration,
987 class_object_EndEnumeration,
988 class_object_GetPropertyQualifierSet,
990 class_object_GetObjectText,
991 class_object_SpawnDerivedClass,
992 class_object_SpawnInstance,
993 class_object_CompareTo,
994 class_object_GetPropertyOrigin,
995 class_object_InheritsFrom,
996 class_object_GetMethod,
997 class_object_PutMethod,
998 class_object_DeleteMethod,
999 class_object_BeginMethodEnumeration,
1000 class_object_NextMethod,
1001 class_object_EndMethodEnumeration,
1002 class_object_GetMethodQualifierSet,
1003 class_object_GetMethodOrigin
1006 HRESULT create_class_object( const WCHAR *name, IEnumWbemClassObject *iter, UINT index,
1007 struct record *record, IWbemClassObject **obj )
1009 struct class_object *co;
1011 TRACE("%s, %p\n", debugstr_w(name), obj);
1013 co = heap_alloc( sizeof(*co) );
1014 if (!co) return E_OUTOFMEMORY;
1016 co->IWbemClassObject_iface.lpVtbl = &class_object_vtbl;
1018 co->name = heap_strdupW( name );
1022 return E_OUTOFMEMORY;
1026 co->index_method = 0;
1027 co->index_property = 0;
1028 co->record = record;
1029 if (iter) IEnumWbemClassObject_AddRef( iter );
1031 *obj = &co->IWbemClassObject_iface;
1033 TRACE("returning iface %p\n", *obj);