?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ntoskrnl.exe/tests: Add some IOCTL_HID_WRITE_REPORT tests.
[wine.git] / dlls / wbemdisp / locator.c
blob3e2566d52209ae7f744a7d40881e2b370a5e6c8f
1 /*
2 * Copyright 2013 Hans Leidekker for CodeWeavers
3 *
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.
8 *
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.
13 *
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
17 */
18
19 #define COBJMACROS
20
21 #include <stdarg.h>
22
23 #include "windef.h"
24 #include "winbase.h"
25 #include "initguid.h"
26 #include "objbase.h"
27 #include "wmiutils.h"
28 #include "wbemcli.h"
29 #include "wbemdisp.h"
30
31 #include "wine/debug.h"
32 #include "wine/heap.h"
33 #include "wbemdisp_private.h"
34 #include "wbemdisp_classes.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(wbemdisp);
37
38 struct namedvalueset
39 {
40 ISWbemNamedValueSet ISWbemNamedValueSet_iface;
41 LONG refs;
42
43 IWbemContext *context;
44 };
45
46 static struct namedvalueset *unsafe_valueset_impl_from_IDispatch(IDispatch *iface);
47
48 static IWbemContext * unsafe_get_context_from_namedvalueset( IDispatch *disp )
49 {
50 struct namedvalueset *valueset = unsafe_valueset_impl_from_IDispatch( disp );
51 return valueset ? valueset->context : NULL;
52 }
53
54 static WCHAR *heap_strdupW( const WCHAR *src )
55 {
56 WCHAR *dst;
57 if (!src) return NULL;
58 if ((dst = heap_alloc( (lstrlenW( src ) + 1) * sizeof(WCHAR) ))) lstrcpyW( dst, src );
59 return dst;
60 }
61
62 struct services;
63
64 static HRESULT EnumVARIANT_create( struct services *, IEnumWbemClassObject *, IEnumVARIANT ** );
65 static HRESULT ISWbemSecurity_create( ISWbemSecurity ** );
66 static HRESULT SWbemObject_create( struct services *, IWbemClassObject *, ISWbemObject ** );
67
68 enum type_id
69 {
70 ISWbemLocator_tid,
71 ISWbemObject_tid,
72 ISWbemObjectSet_tid,
73 ISWbemProperty_tid,
74 ISWbemPropertySet_tid,
75 ISWbemServices_tid,
76 ISWbemSecurity_tid,
77 ISWbemNamedValueSet_tid,
78 ISWbemNamedValue_tid,
79 ISWbemMethodSet_tid,
80 ISWbemMethod_tid,
81 last_tid
82 };
83
84 static ITypeLib *wbemdisp_typelib;
85 static ITypeInfo *wbemdisp_typeinfo[last_tid];
86
87 static REFIID wbemdisp_tid_id[] =
88 {
89 &IID_ISWbemLocator,
90 &IID_ISWbemObject,
91 &IID_ISWbemObjectSet,
92 &IID_ISWbemProperty,
93 &IID_ISWbemPropertySet,
94 &IID_ISWbemServices,
95 &IID_ISWbemSecurity,
96 &IID_ISWbemNamedValueSet,
97 &IID_ISWbemNamedValue,
98 &IID_ISWbemMethodSet,
99 &IID_ISWbemMethod,
100 };
101
102 static HRESULT get_typeinfo( enum type_id tid, ITypeInfo **ret )
103 {
104 HRESULT hr;
105
106 if (!wbemdisp_typelib)
107 {
108 ITypeLib *typelib;
109
110 hr = LoadRegTypeLib( &LIBID_WbemScripting, 1, 2, LOCALE_SYSTEM_DEFAULT, &typelib );
111 if (FAILED( hr ))
112 {
113 ERR( "LoadRegTypeLib failed: %08x\n", hr );
114 return hr;
115 }
116 if (InterlockedCompareExchangePointer( (void **)&wbemdisp_typelib, typelib, NULL ))
117 ITypeLib_Release( typelib );
118 }
119 if (!wbemdisp_typeinfo[tid])
120 {
121 ITypeInfo *typeinfo;
122
123 hr = ITypeLib_GetTypeInfoOfGuid( wbemdisp_typelib, wbemdisp_tid_id[tid], &typeinfo );
124 if (FAILED( hr ))
125 {
126 ERR( "GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_guid(wbemdisp_tid_id[tid]), hr );
127 return hr;
128 }
129 if (InterlockedCompareExchangePointer( (void **)(wbemdisp_typeinfo + tid), typeinfo, NULL ))
130 ITypeInfo_Release( typeinfo );
131 }
132 *ret = wbemdisp_typeinfo[tid];
133 ITypeInfo_AddRef( *ret );
134 return S_OK;
135 }
136
137 struct property
138 {
139 ISWbemProperty ISWbemProperty_iface;
140 LONG refs;
141 IWbemClassObject *object;
142 BSTR name;
143 };
144
145 static inline struct property *impl_from_ISWbemProperty( ISWbemProperty *iface )
146 {
147 return CONTAINING_RECORD( iface, struct property, ISWbemProperty_iface );
148 }
149
150 static ULONG WINAPI property_AddRef( ISWbemProperty *iface )
151 {
152 struct property *property = impl_from_ISWbemProperty( iface );
153 return InterlockedIncrement( &property->refs );
154 }
155
156 static ULONG WINAPI property_Release( ISWbemProperty *iface )
157 {
158 struct property *property = impl_from_ISWbemProperty( iface );
159 LONG refs = InterlockedDecrement( &property->refs );
160 if (!refs)
161 {
162 TRACE( "destroying %p\n", property );
163 IWbemClassObject_Release( property->object );
164 SysFreeString( property->name );
165 heap_free( property );
166 }
167 return refs;
168 }
169
170 static HRESULT WINAPI property_QueryInterface( ISWbemProperty *iface, REFIID riid, void **obj )
171 {
172 struct property *property = impl_from_ISWbemProperty( iface );
173
174 TRACE( "%p %s %p\n", property, debugstr_guid(riid), obj );
175
176 if (IsEqualGUID( riid, &IID_ISWbemProperty ) ||
177 IsEqualGUID( riid, &IID_IDispatch ) ||
178 IsEqualGUID( riid, &IID_IUnknown ))
179 {
180 *obj = iface;
181 }
182 else
183 {
184 WARN( "interface %s not implemented\n", debugstr_guid(riid) );
185 return E_NOINTERFACE;
186 }
187 ISWbemProperty_AddRef( iface );
188 return S_OK;
189 }
190
191 static HRESULT WINAPI property_GetTypeInfoCount( ISWbemProperty *iface, UINT *count )
192 {
193 struct property *property = impl_from_ISWbemProperty( iface );
194 TRACE( "%p, %p\n", property, count );
195 *count = 1;
196 return S_OK;
197 }
198
199 static HRESULT WINAPI property_GetTypeInfo( ISWbemProperty *iface, UINT index,
200 LCID lcid, ITypeInfo **info )
201 {
202 struct property *property = impl_from_ISWbemProperty( iface );
203 TRACE( "%p, %u, %u, %p\n", property, index, lcid, info );
204
205 return get_typeinfo( ISWbemProperty_tid, info );
206 }
207
208 static HRESULT WINAPI property_GetIDsOfNames( ISWbemProperty *iface, REFIID riid, LPOLESTR *names,
209 UINT count, LCID lcid, DISPID *dispid )
210 {
211 struct property *property = impl_from_ISWbemProperty( iface );
212 ITypeInfo *typeinfo;
213 HRESULT hr;
214
215 TRACE( "%p, %s, %p, %u, %u, %p\n", property, debugstr_guid(riid), names, count, lcid, dispid );
216
217 if (!names || !count || !dispid) return E_INVALIDARG;
218
219 hr = get_typeinfo( ISWbemProperty_tid, &typeinfo );
220 if (SUCCEEDED(hr))
221 {
222 hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
223 ITypeInfo_Release( typeinfo );
224 }
225 return hr;
226 }
227
228 static HRESULT WINAPI property_Invoke( ISWbemProperty *iface, DISPID member, REFIID riid,
229 LCID lcid, WORD flags, DISPPARAMS *params,
230 VARIANT *result, EXCEPINFO *excep_info, UINT *arg_err )
231 {
232 struct property *property = impl_from_ISWbemProperty( iface );
233 ITypeInfo *typeinfo;
234 HRESULT hr;
235
236 TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", property, member, debugstr_guid(riid),
237 lcid, flags, params, result, excep_info, arg_err );
238
239 hr = get_typeinfo( ISWbemProperty_tid, &typeinfo );
240 if (SUCCEEDED(hr))
241 {
242 hr = ITypeInfo_Invoke( typeinfo, &property->ISWbemProperty_iface, member, flags,
243 params, result, excep_info, arg_err );
244 ITypeInfo_Release( typeinfo );
245 }
246 return hr;
247 }
248
249 static HRESULT WINAPI property_get_Value( ISWbemProperty *iface, VARIANT *value )
250 {
251 struct property *property = impl_from_ISWbemProperty( iface );
252
253 TRACE( "%p %p\n", property, value );
254
255 return IWbemClassObject_Get( property->object, property->name, 0, value, NULL, NULL );
256 }
257
258 static HRESULT WINAPI property_put_Value( ISWbemProperty *iface, VARIANT *varValue )
259 {
260 FIXME( "\n" );
261 return E_NOTIMPL;
262 }
263
264 static HRESULT WINAPI property_get_Name( ISWbemProperty *iface, BSTR *strName )
265 {
266 FIXME( "\n" );
267 return E_NOTIMPL;
268 }
269
270 static HRESULT WINAPI property_get_IsLocal( ISWbemProperty *iface, VARIANT_BOOL *bIsLocal )
271 {
272 FIXME( "\n" );
273 return E_NOTIMPL;
274 }
275
276 static HRESULT WINAPI property_get_Origin( ISWbemProperty *iface, BSTR *strOrigin )
277 {
278 FIXME( "\n" );
279 return E_NOTIMPL;
280 }
281
282 static HRESULT WINAPI property_get_CIMType( ISWbemProperty *iface, WbemCimtypeEnum *iCimType )
283 {
284 FIXME( "\n" );
285 return E_NOTIMPL;
286 }
287
288 static HRESULT WINAPI property_get_Qualifiers_( ISWbemProperty *iface, ISWbemQualifierSet **objWbemQualifierSet )
289 {
290 FIXME( "\n" );
291 return E_NOTIMPL;
292 }
293
294 static HRESULT WINAPI property_get_IsArray( ISWbemProperty *iface, VARIANT_BOOL *bIsArray )
295 {
296 FIXME( "\n" );
297 return E_NOTIMPL;
298 }
299
300 static const ISWbemPropertyVtbl property_vtbl =
301 {
302 property_QueryInterface,
303 property_AddRef,
304 property_Release,
305 property_GetTypeInfoCount,
306 property_GetTypeInfo,
307 property_GetIDsOfNames,
308 property_Invoke,
309 property_get_Value,
310 property_put_Value,
311 property_get_Name,
312 property_get_IsLocal,
313 property_get_Origin,
314 property_get_CIMType,
315 property_get_Qualifiers_,
316 property_get_IsArray
317 };
318
319 static HRESULT SWbemProperty_create( IWbemClassObject *wbem_object, BSTR name, ISWbemProperty **obj )
320 {
321 struct property *property;
322
323 TRACE( "%p, %p\n", obj, wbem_object );
324
325 if (!(property = heap_alloc( sizeof(*property) ))) return E_OUTOFMEMORY;
326 property->ISWbemProperty_iface.lpVtbl = &property_vtbl;
327 property->refs = 1;
328 property->object = wbem_object;
329 IWbemClassObject_AddRef( property->object );
330 property->name = SysAllocStringLen( name, SysStringLen( name ) );
331 *obj = &property->ISWbemProperty_iface;
332 TRACE( "returning iface %p\n", *obj );
333 return S_OK;
334 }
335
336 struct propertyset
337 {
338 ISWbemPropertySet ISWbemPropertySet_iface;
339 LONG refs;
340 IWbemClassObject *object;
341 };
342
343 static inline struct propertyset *impl_from_ISWbemPropertySet(
344 ISWbemPropertySet *iface )
345 {
346 return CONTAINING_RECORD( iface, struct propertyset, ISWbemPropertySet_iface );
347 }
348
349 static ULONG WINAPI propertyset_AddRef( ISWbemPropertySet *iface )
350 {
351 struct propertyset *propertyset = impl_from_ISWbemPropertySet( iface );
352 return InterlockedIncrement( &propertyset->refs );
353 }
354
355 static ULONG WINAPI propertyset_Release( ISWbemPropertySet *iface )
356 {
357 struct propertyset *propertyset = impl_from_ISWbemPropertySet( iface );
358 LONG refs = InterlockedDecrement( &propertyset->refs );
359 if (!refs)
360 {
361 TRACE( "destroying %p\n", propertyset );
362 IWbemClassObject_Release( propertyset->object );
363 heap_free( propertyset );
364 }
365 return refs;
366 }
367
368 static HRESULT WINAPI propertyset_QueryInterface( ISWbemPropertySet *iface,
369 REFIID riid, void **obj )
370 {
371 struct propertyset *propertyset = impl_from_ISWbemPropertySet( iface );
372
373 TRACE( "%p %s %p\n", propertyset, debugstr_guid(riid), obj );
374
375 if (IsEqualGUID( riid, &IID_ISWbemPropertySet ) ||
376 IsEqualGUID( riid, &IID_IDispatch ) ||
377 IsEqualGUID( riid, &IID_IUnknown ))
378 {
379 *obj = iface;
380 }
381 else
382 {
383 WARN( "interface %s not implemented\n", debugstr_guid(riid) );
384 return E_NOINTERFACE;
385 }
386 ISWbemPropertySet_AddRef( iface );
387 return S_OK;
388 }
389
390 static HRESULT WINAPI propertyset_GetTypeInfoCount( ISWbemPropertySet *iface, UINT *count )
391 {
392 struct propertyset *propertyset = impl_from_ISWbemPropertySet( iface );
393 TRACE( "%p, %p\n", propertyset, count );
394 *count = 1;
395 return S_OK;
396 }
397
398 static HRESULT WINAPI propertyset_GetTypeInfo( ISWbemPropertySet *iface,
399 UINT index, LCID lcid, ITypeInfo **info )
400 {
401 struct propertyset *propertyset = impl_from_ISWbemPropertySet( iface );
402 TRACE( "%p, %u, %u, %p\n", propertyset, index, lcid, info );
403
404 return get_typeinfo( ISWbemPropertySet_tid, info );
405 }
406
407 static HRESULT WINAPI propertyset_GetIDsOfNames( ISWbemPropertySet *iface, REFIID riid, LPOLESTR *names,
408 UINT count, LCID lcid, DISPID *dispid )
409 {
410 struct propertyset *propertyset = impl_from_ISWbemPropertySet( iface );
411 ITypeInfo *typeinfo;
412 HRESULT hr;
413
414 TRACE( "%p, %s, %p, %u, %u, %p\n", propertyset, debugstr_guid(riid), names, count, lcid, dispid );
415
416 if (!names || !count || !dispid) return E_INVALIDARG;
417
418 hr = get_typeinfo( ISWbemPropertySet_tid, &typeinfo );
419 if (SUCCEEDED(hr))
420 {
421 hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
422 ITypeInfo_Release( typeinfo );
423 }
424 return hr;
425 }
426
427 static HRESULT WINAPI propertyset_Invoke( ISWbemPropertySet *iface, DISPID member, REFIID riid,
428 LCID lcid, WORD flags, DISPPARAMS *params,
429 VARIANT *result, EXCEPINFO *excep_info, UINT *arg_err )
430 {
431 struct propertyset *propertyset = impl_from_ISWbemPropertySet( iface );
432 ITypeInfo *typeinfo;
433 HRESULT hr;
434
435 TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", propertyset, member, debugstr_guid(riid),
436 lcid, flags, params, result, excep_info, arg_err );
437
438 hr = get_typeinfo( ISWbemPropertySet_tid, &typeinfo );
439 if (SUCCEEDED(hr))
440 {
441 hr = ITypeInfo_Invoke( typeinfo, &propertyset->ISWbemPropertySet_iface, member, flags,
442 params, result, excep_info, arg_err );
443 ITypeInfo_Release( typeinfo );
444 }
445 return hr;
446 }
447
448 static HRESULT WINAPI propertyset_get__NewEnum( ISWbemPropertySet *iface, IUnknown **unk )
449 {
450 FIXME( "\n" );
451 return E_NOTIMPL;
452 }
453
454 static HRESULT WINAPI propertyset_Item( ISWbemPropertySet *iface, BSTR name,
455 LONG flags, ISWbemProperty **prop )
456 {
457 struct propertyset *propertyset = impl_from_ISWbemPropertySet( iface );
458 HRESULT hr;
459 VARIANT var;
460
461 TRACE( "%p, %s, %08x, %p\n", propertyset, debugstr_w(name), flags, prop );
462
463 hr = IWbemClassObject_Get( propertyset->object, name, 0, &var, NULL, NULL );
464 if (SUCCEEDED(hr))
465 {
466 hr = SWbemProperty_create( propertyset->object, name, prop );
467 VariantClear( &var );
468 }
469 return hr;
470 }
471
472 static HRESULT WINAPI propertyset_get_Count( ISWbemPropertySet *iface, LONG *count )
473 {
474 struct propertyset *propertyset = impl_from_ISWbemPropertySet( iface );
475 HRESULT hr;
476 VARIANT val;
477
478 TRACE( "%p, %p\n", propertyset, count );
479
480 hr = IWbemClassObject_Get( propertyset->object, L"__PROPERTY_COUNT", 0, &val, NULL, NULL );
481 if (SUCCEEDED(hr))
482 {
483 *count = V_I4( &val );
484 }
485 return hr;
486 }
487
488 static HRESULT WINAPI propertyset_Add( ISWbemPropertySet *iface, BSTR name, WbemCimtypeEnum type,
489 VARIANT_BOOL is_array, LONG flags, ISWbemProperty **prop )
490 {
491 FIXME( "\n" );
492 return E_NOTIMPL;
493 }
494
495 static HRESULT WINAPI propertyset_Remove( ISWbemPropertySet *iface, BSTR name, LONG flags )
496 {
497 FIXME( "\n" );
498 return E_NOTIMPL;
499 }
500
501 static const ISWbemPropertySetVtbl propertyset_vtbl =
502 {
503 propertyset_QueryInterface,
504 propertyset_AddRef,
505 propertyset_Release,
506 propertyset_GetTypeInfoCount,
507 propertyset_GetTypeInfo,
508 propertyset_GetIDsOfNames,
509 propertyset_Invoke,
510 propertyset_get__NewEnum,
511 propertyset_Item,
512 propertyset_get_Count,
513 propertyset_Add,
514 propertyset_Remove
515 };
516
517 static HRESULT SWbemPropertySet_create( IWbemClassObject *wbem_object, ISWbemPropertySet **obj )
518 {
519 struct propertyset *propertyset;
520
521 TRACE( "%p, %p\n", obj, wbem_object );
522
523 if (!(propertyset = heap_alloc( sizeof(*propertyset) ))) return E_OUTOFMEMORY;
524 propertyset->ISWbemPropertySet_iface.lpVtbl = &propertyset_vtbl;
525 propertyset->refs = 1;
526 propertyset->object = wbem_object;
527 IWbemClassObject_AddRef( propertyset->object );
528 *obj = &propertyset->ISWbemPropertySet_iface;
529
530 TRACE( "returning iface %p\n", *obj );
531 return S_OK;
532 }
533
534 struct services
535 {
536 ISWbemServices ISWbemServices_iface;
537 LONG refs;
538 IWbemServices *services;
539 };
540
541 struct member
542 {
543 BSTR name;
544 BOOL is_method;
545 DISPID dispid;
546 CIMTYPE type;
547 };
548
549 struct object
550 {
551 ISWbemObject ISWbemObject_iface;
552 LONG refs;
553 IWbemClassObject *object;
554 struct member *members;
555 UINT nb_members;
556 DISPID last_dispid;
557 DISPID last_dispid_method;
558 struct services *services;
559 };
560
561 struct methodset
562 {
563 ISWbemMethodSet ISWbemMethodSet_iface;
564 LONG refs;
565 struct object *object;
566 };
567
568 struct method
569 {
570 ISWbemMethod ISWbemMethod_iface;
571 LONG refs;
572 struct methodset *set;
573 WCHAR *name;
574 };
575
576 static struct method *impl_from_ISWbemMethod( ISWbemMethod *iface )
577 {
578 return CONTAINING_RECORD( iface, struct method, ISWbemMethod_iface );
579 }
580
581 static HRESULT WINAPI method_QueryInterface( ISWbemMethod *iface, REFIID riid, void **ppvObject )
582 {
583 struct method *method = impl_from_ISWbemMethod( iface );
584
585 TRACE( "%p %s %p\n", method, debugstr_guid(riid), ppvObject );
586
587 if (IsEqualGUID( riid, &IID_ISWbemMethod ) ||
588 IsEqualGUID( riid, &IID_IDispatch ) ||
589 IsEqualGUID( riid, &IID_IUnknown ))
590 {
591 *ppvObject = iface;
592 }
593 else
594 {
595 WARN( "interface %s not implemented\n", debugstr_guid(riid) );
596 return E_NOINTERFACE;
597 }
598 ISWbemMethod_AddRef( iface );
599 return S_OK;
600 }
601
602 static ULONG WINAPI method_AddRef( ISWbemMethod *iface )
603 {
604 struct method *method = impl_from_ISWbemMethod( iface );
605 return InterlockedIncrement( &method->refs );
606 }
607
608 static ULONG WINAPI method_Release( ISWbemMethod *iface )
609 {
610 struct method *method = impl_from_ISWbemMethod( iface );
611 LONG refs = InterlockedDecrement( &method->refs );
612 if (!refs)
613 {
614 TRACE( "destroying %p\n", method );
615 ISWbemMethodSet_Release( &method->set->ISWbemMethodSet_iface );
616 heap_free( method->name );
617 heap_free( method );
618 }
619 return refs;
620 }
621
622 static HRESULT WINAPI method_GetTypeInfoCount(
623 ISWbemMethod *iface,
624 UINT *count )
625 {
626 struct method *method = impl_from_ISWbemMethod( iface );
627
628 TRACE( "%p, %p\n", method, count );
629 *count = 1;
630 return S_OK;
631 }
632
633 static HRESULT WINAPI method_GetTypeInfo(
634 ISWbemMethod *iface,
635 UINT index,
636 LCID lcid,
637 ITypeInfo **info )
638 {
639 struct method *method = impl_from_ISWbemMethod( iface );
640
641 TRACE( "%p, %u, %u, %p\n", method, index, lcid, info );
642
643 return get_typeinfo( ISWbemMethod_tid, info );
644 }
645
646 static HRESULT WINAPI method_GetIDsOfNames(
647 ISWbemMethod *iface,
648 REFIID riid,
649 LPOLESTR *names,
650 UINT count,
651 LCID lcid,
652 DISPID *dispid )
653 {
654 struct method *method = impl_from_ISWbemMethod( iface );
655 ITypeInfo *typeinfo;
656 HRESULT hr;
657
658 TRACE( "%p, %s, %p, %u, %u, %p\n", method, debugstr_guid(riid), names, count, lcid, dispid );
659
660 if (!names || !count || !dispid) return E_INVALIDARG;
661
662 hr = get_typeinfo( ISWbemMethod_tid, &typeinfo );
663 if (SUCCEEDED(hr))
664 {
665 hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
666 ITypeInfo_Release( typeinfo );
667 }
668 return hr;
669 }
670
671 static HRESULT WINAPI method_Invoke(
672 ISWbemMethod *iface,
673 DISPID member,
674 REFIID riid,
675 LCID lcid,
676 WORD flags,
677 DISPPARAMS *params,
678 VARIANT *result,
679 EXCEPINFO *excep_info,
680 UINT *arg_err )
681 {
682 struct method *method = impl_from_ISWbemMethod( iface );
683 ITypeInfo *typeinfo;
684 HRESULT hr;
685
686 TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", method, member, debugstr_guid(riid),
687 lcid, flags, params, result, excep_info, arg_err );
688
689 hr = get_typeinfo( ISWbemMethod_tid, &typeinfo );
690 if (SUCCEEDED(hr))
691 {
692 hr = ITypeInfo_Invoke( typeinfo, &method->ISWbemMethod_iface, member, flags,
693 params, result, excep_info, arg_err );
694 ITypeInfo_Release( typeinfo );
695 }
696 return hr;
697 }
698
699 static HRESULT WINAPI method_get_Name(
700 ISWbemMethod *iface,
701 BSTR *name )
702 {
703 FIXME("\n");
704
705 return E_NOTIMPL;
706 }
707
708 static HRESULT WINAPI method_get_Origin(
709 ISWbemMethod *iface,
710 BSTR *origin )
711 {
712 FIXME("\n");
713
714 return E_NOTIMPL;
715 }
716
717 static HRESULT WINAPI method_get_InParameters(
718 ISWbemMethod *iface,
719 ISWbemObject **params )
720 {
721 struct method *method = impl_from_ISWbemMethod( iface );
722 IWbemClassObject *in_sign = NULL, *instance;
723 HRESULT hr;
724
725 TRACE("%p, %p\n", method, params);
726
727 *params = NULL;
728
729 if (SUCCEEDED(hr = IWbemClassObject_GetMethod( method->set->object->object,
730 method->name, 0, &in_sign, NULL )) && in_sign != NULL)
731 {
732 hr = IWbemClassObject_SpawnInstance( in_sign, 0, &instance );
733 IWbemClassObject_Release( in_sign );
734 if (SUCCEEDED(hr))
735 {
736 hr = SWbemObject_create( method->set->object->services, instance, params );
737 IWbemClassObject_Release( instance );
738 }
739 }
740
741 return hr;
742 }
743
744 static HRESULT WINAPI method_get_OutParameters(
745 ISWbemMethod *iface,
746 ISWbemObject **params )
747 {
748 FIXME("\n");
749
750 return E_NOTIMPL;
751 }
752
753 static HRESULT WINAPI method_get_Qualifiers_(
754 ISWbemMethod *iface,
755 ISWbemQualifierSet **qualifiers )
756 {
757 FIXME("\n");
758
759 return E_NOTIMPL;
760 }
761
762 static const ISWbemMethodVtbl methodvtbl =
763 {
764 method_QueryInterface,
765 method_AddRef,
766 method_Release,
767 method_GetTypeInfoCount,
768 method_GetTypeInfo,
769 method_GetIDsOfNames,
770 method_Invoke,
771 method_get_Name,
772 method_get_Origin,
773 method_get_InParameters,
774 method_get_OutParameters,
775 method_get_Qualifiers_,
776 };
777
778 static HRESULT SWbemMethod_create( struct methodset *set, const WCHAR *name, ISWbemMethod **obj )
779 {
780 struct method *method;
781
782 if (!(method = heap_alloc(sizeof(*method))))
783 return E_OUTOFMEMORY;
784
785 method->ISWbemMethod_iface.lpVtbl = &methodvtbl;
786 method->refs = 1;
787 method->set = set;
788 ISWbemMethodSet_AddRef( &method->set->ISWbemMethodSet_iface );
789 if (!(method->name = heap_strdupW( name )))
790 {
791 ISWbemMethod_Release( &method->ISWbemMethod_iface );
792 return E_OUTOFMEMORY;
793 }
794
795 *obj = &method->ISWbemMethod_iface;
796
797 return S_OK;
798 }
799
800 static struct methodset *impl_from_ISWbemMethodSet( ISWbemMethodSet *iface )
801 {
802 return CONTAINING_RECORD( iface, struct methodset, ISWbemMethodSet_iface );
803 }
804
805 static HRESULT WINAPI methodset_QueryInterface( ISWbemMethodSet *iface, REFIID riid, void **ppvObject )
806 {
807 struct methodset *set = impl_from_ISWbemMethodSet( iface );
808
809 TRACE( "%p %s %p\n", set, debugstr_guid(riid), ppvObject );
810
811 if (IsEqualGUID( riid, &IID_ISWbemMethodSet ) ||
812 IsEqualGUID( riid, &IID_IDispatch ) ||
813 IsEqualGUID( riid, &IID_IUnknown ))
814 {
815 *ppvObject = iface;
816 }
817 else
818 {
819 WARN( "interface %s not implemented\n", debugstr_guid(riid) );
820 return E_NOINTERFACE;
821 }
822 ISWbemMethodSet_AddRef( iface );
823 return S_OK;
824 }
825
826 static ULONG WINAPI methodset_AddRef( ISWbemMethodSet *iface )
827 {
828 struct methodset *set = impl_from_ISWbemMethodSet( iface );
829 return InterlockedIncrement( &set->refs );
830 }
831
832 static ULONG WINAPI methodset_Release( ISWbemMethodSet *iface )
833 {
834 struct methodset *set = impl_from_ISWbemMethodSet( iface );
835 LONG refs = InterlockedDecrement( &set->refs );
836 if (!refs)
837 {
838 TRACE( "destroying %p\n", set );
839 ISWbemObject_Release( &set->object->ISWbemObject_iface );
840 heap_free( set );
841 }
842 return refs;
843 }
844
845 static HRESULT WINAPI methodset_GetTypeInfoCount(
846 ISWbemMethodSet *iface,
847 UINT *count )
848 {
849 struct methodset *set = impl_from_ISWbemMethodSet( iface );
850
851 TRACE( "%p, %p\n", set, count );
852 *count = 1;
853 return S_OK;
854 }
855
856 static HRESULT WINAPI methodset_GetTypeInfo( ISWbemMethodSet *iface,
857 UINT index,
858 LCID lcid,
859 ITypeInfo **info )
860 {
861 struct methodset *set = impl_from_ISWbemMethodSet( iface );
862
863 TRACE( "%p, %u, %u, %p\n", set, index, lcid, info );
864
865 return get_typeinfo( ISWbemMethodSet_tid, info );
866 }
867
868 static HRESULT WINAPI methodset_GetIDsOfNames(
869 ISWbemMethodSet *iface,
870 REFIID riid,
871 LPOLESTR *names,
872 UINT count,
873 LCID lcid,
874 DISPID *dispid )
875 {
876 struct methodset *set = impl_from_ISWbemMethodSet( iface );
877 ITypeInfo *typeinfo;
878 HRESULT hr;
879
880 TRACE( "%p, %s, %p, %u, %u, %p\n", set, debugstr_guid(riid), names, count, lcid, dispid );
881
882 if (!names || !count || !dispid) return E_INVALIDARG;
883
884 hr = get_typeinfo( ISWbemMethodSet_tid, &typeinfo );
885 if (SUCCEEDED(hr))
886 {
887 hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
888 ITypeInfo_Release( typeinfo );
889 }
890 return hr;
891 }
892
893 static HRESULT WINAPI methodset_Invoke(
894 ISWbemMethodSet *iface,
895 DISPID member,
896 REFIID riid,
897 LCID lcid,
898 WORD flags,
899 DISPPARAMS *params,
900 VARIANT *result,
901 EXCEPINFO *excep_info,
902 UINT *arg_err )
903 {
904 struct methodset *set = impl_from_ISWbemMethodSet( iface );
905 ITypeInfo *typeinfo;
906 HRESULT hr;
907
908 TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", set, member, debugstr_guid(riid),
909 lcid, flags, params, result, excep_info, arg_err );
910
911 hr = get_typeinfo( ISWbemMethodSet_tid, &typeinfo );
912 if (SUCCEEDED(hr))
913 {
914 hr = ITypeInfo_Invoke( typeinfo, &set->ISWbemMethodSet_iface, member, flags,
915 params, result, excep_info, arg_err );
916 ITypeInfo_Release( typeinfo );
917 }
918 return hr;
919 }
920
921 static HRESULT WINAPI methodset_get__NewEnum(
922 ISWbemMethodSet *iface,
923 IUnknown **unk )
924 {
925 FIXME("\n");
926
927 return E_NOTIMPL;
928 }
929
930 static HRESULT WINAPI methodset_Item(
931 ISWbemMethodSet *iface,
932 BSTR name,
933 LONG flags,
934 ISWbemMethod **method )
935 {
936 struct methodset *set = impl_from_ISWbemMethodSet( iface );
937 IWbemClassObject *in_sign, *out_sign;
938 HRESULT hr;
939
940 TRACE("%p, %s, %#x, %p\n", set, debugstr_w(name), flags, method);
941
942 *method = NULL;
943
944 if (SUCCEEDED(hr = IWbemClassObject_GetMethod( set->object->object,
945 name, flags, &in_sign, &out_sign )))
946 {
947 if (in_sign)
948 IWbemClassObject_Release( in_sign );
949 if (out_sign)
950 IWbemClassObject_Release( out_sign );
951
952 return SWbemMethod_create( set, name, method );
953 }
954
955 return hr;
956 }
957
958 static HRESULT WINAPI methodset_get_Count(
959 ISWbemMethodSet *iface,
960 LONG *count )
961 {
962 FIXME("\n");
963
964 return E_NOTIMPL;
965 }
966
967 static const ISWbemMethodSetVtbl methodsetvtbl =
968 {
969 methodset_QueryInterface,
970 methodset_AddRef,
971 methodset_Release,
972 methodset_GetTypeInfoCount,
973 methodset_GetTypeInfo,
974 methodset_GetIDsOfNames,
975 methodset_Invoke,
976 methodset_get__NewEnum,
977 methodset_Item,
978 methodset_get_Count,
979 };
980
981 static HRESULT SWbemMethodSet_create( struct object *object, ISWbemMethodSet **obj )
982 {
983 struct methodset *set;
984
985 if (!(set = heap_alloc(sizeof(*set))))
986 return E_OUTOFMEMORY;
987
988 set->ISWbemMethodSet_iface.lpVtbl = &methodsetvtbl;
989 set->refs = 1;
990 set->object = object;
991 ISWbemObject_AddRef( &object->ISWbemObject_iface );
992
993 *obj = &set->ISWbemMethodSet_iface;
994
995 return S_OK;
996 }
997
998 #define DISPID_BASE 0x1800000
999 #define DISPID_BASE_METHOD 0x1000000
1000
1001 static inline struct object *impl_from_ISWbemObject(
1002 ISWbemObject *iface )
1003 {
1004 return CONTAINING_RECORD( iface, struct object, ISWbemObject_iface );
1005 }
1006
1007 static ULONG WINAPI object_AddRef(
1008 ISWbemObject *iface )
1009 {
1010 struct object *object = impl_from_ISWbemObject( iface );
1011 return InterlockedIncrement( &object->refs );
1012 }
1013
1014 static ULONG WINAPI object_Release(
1015 ISWbemObject *iface )
1016 {
1017 struct object *object = impl_from_ISWbemObject( iface );
1018 LONG refs = InterlockedDecrement( &object->refs );
1019 if (!refs)
1020 {
1021 UINT i;
1022
1023 TRACE( "destroying %p\n", object );
1024 IWbemClassObject_Release( object->object );
1025 ISWbemServices_Release( &object->services->ISWbemServices_iface );
1026 for (i = 0; i < object->nb_members; i++) SysFreeString( object->members[i].name );
1027 heap_free( object->members );
1028 heap_free( object );
1029 }
1030 return refs;
1031 }
1032
1033 static HRESULT WINAPI object_QueryInterface(
1034 ISWbemObject *iface,
1035 REFIID riid,
1036 void **ppvObject )
1037 {
1038 struct object *object = impl_from_ISWbemObject( iface );
1039
1040 TRACE( "%p %s %p\n", object, debugstr_guid(riid), ppvObject );
1041
1042 if (IsEqualGUID( riid, &IID_ISWbemObject ) ||
1043 IsEqualGUID( riid, &IID_IDispatch ) ||
1044 IsEqualGUID( riid, &IID_IUnknown ))
1045 {
1046 *ppvObject = iface;
1047 }
1048 else
1049 {
1050 WARN( "interface %s not implemented\n", debugstr_guid(riid) );
1051 return E_NOINTERFACE;
1052 }
1053 ISWbemObject_AddRef( iface );
1054 return S_OK;
1055 }
1056
1057 static HRESULT WINAPI object_GetTypeInfoCount(
1058 ISWbemObject *iface,
1059 UINT *count )
1060 {
1061 struct object *object = impl_from_ISWbemObject( iface );
1062
1063 TRACE( "%p, %p\n", object, count );
1064 *count = 1;
1065 return S_OK;
1066 }
1067
1068 static HRESULT WINAPI object_GetTypeInfo(
1069 ISWbemObject *iface,
1070 UINT index,
1071 LCID lcid,
1072 ITypeInfo **info )
1073 {
1074 struct object *object = impl_from_ISWbemObject( iface );
1075 FIXME( "%p, %u, %u, %p\n", object, index, lcid, info );
1076 return E_NOTIMPL;
1077 }
1078
1079 static BOOL object_reserve_member( struct object *object, unsigned int count, unsigned int *capacity )
1080 {
1081 unsigned int new_capacity, max_capacity;
1082 struct member *new_members;
1083
1084 if (count <= *capacity)
1085 return TRUE;
1086
1087 max_capacity = ~0u / sizeof(*object->members);
1088 if (count > max_capacity)
1089 return FALSE;
1090
1091 new_capacity = max(4, *capacity);
1092 while (new_capacity < count && new_capacity <= max_capacity / 2)
1093 new_capacity *= 2;
1094 if (new_capacity < count)
1095 new_capacity = max_capacity;
1096
1097 if (!(new_members = heap_realloc( object->members, new_capacity * sizeof(*new_members) )))
1098 return FALSE;
1099
1100 object->members = new_members;
1101 *capacity = new_capacity;
1102
1103 return TRUE;
1104 }
1105
1106 static HRESULT init_members( struct object *object )
1107 {
1108 IWbemClassObject *sig_in, *sig_out;
1109 unsigned int i, capacity = 0, count = 0;
1110 CIMTYPE type;
1111 HRESULT hr;
1112 BSTR name;
1113
1114 if (object->members) return S_OK;
1115
1116 hr = IWbemClassObject_BeginEnumeration( object->object, 0 );
1117 if (SUCCEEDED( hr ))
1118 {
1119 while (IWbemClassObject_Next( object->object, 0, &name, NULL, &type, NULL ) == S_OK)
1120 {
1121 if (!object_reserve_member( object, count + 1, &capacity )) goto error;
1122 object->members[count].name = name;
1123 object->members[count].is_method = FALSE;
1124 object->members[count].dispid = 0;
1125 object->members[count].type = type;
1126 count++;
1127 TRACE( "added property %s\n", debugstr_w(name) );
1128 }
1129 IWbemClassObject_EndEnumeration( object->object );
1130 }
1131
1132 hr = IWbemClassObject_BeginMethodEnumeration( object->object, 0 );
1133 if (SUCCEEDED( hr ))
1134 {
1135 while (IWbemClassObject_NextMethod( object->object, 0, &name, &sig_in, &sig_out ) == S_OK)
1136 {
1137 if (!object_reserve_member( object, count + 1, &capacity )) goto error;
1138 object->members[count].name = name;
1139 object->members[count].is_method = TRUE;
1140 object->members[count].dispid = 0;
1141 count++;
1142 if (sig_in) IWbemClassObject_Release( sig_in );
1143 if (sig_out) IWbemClassObject_Release( sig_out );
1144 TRACE( "added method %s\n", debugstr_w(name) );
1145 }
1146 IWbemClassObject_EndMethodEnumeration( object->object );
1147 }
1148
1149 object->nb_members = count;
1150 TRACE( "added %u members\n", object->nb_members );
1151 return S_OK;
1152
1153 error:
1154 for (i = 0; i < count; ++i)
1155 SysFreeString( object->members[i].name );
1156 heap_free( object->members );
1157 object->members = NULL;
1158 object->nb_members = 0;
1159 return E_FAIL;
1160 }
1161
1162 static DISPID get_member_dispid( struct object *object, const WCHAR *name )
1163 {
1164 UINT i;
1165 for (i = 0; i < object->nb_members; i++)
1166 {
1167 if (!wcsicmp( object->members[i].name, name ))
1168 {
1169 if (!object->members[i].dispid)
1170 {
1171 if (object->members[i].is_method)
1172 object->members[i].dispid = ++object->last_dispid_method;
1173 else
1174 object->members[i].dispid = ++object->last_dispid;
1175 }
1176 return object->members[i].dispid;
1177 }
1178 }
1179 return DISPID_UNKNOWN;
1180 }
1181
1182 static HRESULT WINAPI object_GetIDsOfNames(
1183 ISWbemObject *iface,
1184 REFIID riid,
1185 LPOLESTR *names,
1186 UINT count,
1187 LCID lcid,
1188 DISPID *dispid )
1189 {
1190 struct object *object = impl_from_ISWbemObject( iface );
1191 HRESULT hr;
1192 UINT i;
1193 ITypeInfo *typeinfo;
1194
1195 TRACE( "%p, %s, %p, %u, %u, %p\n", object, debugstr_guid(riid), names, count, lcid, dispid );
1196
1197 if (!names || !count || !dispid) return E_INVALIDARG;
1198
1199 hr = init_members( object );
1200 if (FAILED( hr )) return hr;
1201
1202 hr = get_typeinfo( ISWbemObject_tid, &typeinfo );
1203 if (SUCCEEDED(hr))
1204 {
1205 hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
1206 ITypeInfo_Release( typeinfo );
1207 }
1208 if (SUCCEEDED(hr)) return hr;
1209
1210 for (i = 0; i < count; i++)
1211 {
1212 if ((dispid[i] = get_member_dispid( object, names[i] )) == DISPID_UNKNOWN) break;
1213 }
1214 if (i != count) return DISP_E_UNKNOWNNAME;
1215 return S_OK;
1216 }
1217
1218 static BSTR get_member_name( struct object *object, DISPID dispid, CIMTYPE *type )
1219 {
1220 UINT i;
1221 for (i = 0; i < object->nb_members; i++)
1222 {
1223 if (object->members[i].dispid == dispid)
1224 {
1225 *type = object->members[i].type;
1226 return object->members[i].name;
1227 }
1228 }
1229 return NULL;
1230 }
1231
1232 static VARTYPE to_vartype( CIMTYPE type )
1233 {
1234 switch (type)
1235 {
1236 case CIM_BOOLEAN: return VT_BOOL;
1237
1238 case CIM_STRING:
1239 case CIM_REFERENCE:
1240 case CIM_DATETIME: return VT_BSTR;
1241
1242 case CIM_SINT8: return VT_I1;
1243 case CIM_UINT8: return VT_UI1;
1244 case CIM_SINT16: return VT_I2;
1245
1246 case CIM_UINT16:
1247 case CIM_SINT32: return VT_I4;
1248
1249 case CIM_UINT32: return VT_UI4;
1250
1251 case CIM_SINT64: return VT_I8;
1252 case CIM_UINT64: return VT_UI8;
1253
1254 case CIM_REAL32: return VT_R4;
1255
1256 default:
1257 ERR("unhandled type %u\n", type);
1258 break;
1259 }
1260 return 0;
1261 }
1262
1263 static HRESULT WINAPI object_Invoke(
1264 ISWbemObject *iface,
1265 DISPID member,
1266 REFIID riid,
1267 LCID lcid,
1268 WORD flags,
1269 DISPPARAMS *params,
1270 VARIANT *result,
1271 EXCEPINFO *excep_info,
1272 UINT *arg_err )
1273 {
1274 struct object *object = impl_from_ISWbemObject( iface );
1275 BSTR name;
1276 ITypeInfo *typeinfo;
1277 VARTYPE vartype;
1278 VARIANT value;
1279 CIMTYPE type;
1280 HRESULT hr;
1281
1282 TRACE( "%p, %x, %s, %u, %x, %p, %p, %p, %p\n", object, member, debugstr_guid(riid),
1283 lcid, flags, params, result, excep_info, arg_err );
1284
1285 if (member <= DISPID_BASE_METHOD)
1286 {
1287 hr = get_typeinfo( ISWbemObject_tid, &typeinfo );
1288 if (SUCCEEDED(hr))
1289 {
1290 hr = ITypeInfo_Invoke( typeinfo, &object->ISWbemObject_iface, member, flags,
1291 params, result, excep_info, arg_err );
1292 ITypeInfo_Release( typeinfo );
1293 }
1294 return hr;
1295 }
1296
1297 if (!(name = get_member_name( object, member, &type )))
1298 return DISP_E_MEMBERNOTFOUND;
1299
1300 if (flags == (DISPATCH_METHOD|DISPATCH_PROPERTYGET))
1301 {
1302 memset( params, 0, sizeof(*params) );
1303 return IWbemClassObject_Get( object->object, name, 0, result, NULL, NULL );
1304 }
1305 else if (flags == DISPATCH_PROPERTYPUT)
1306 {
1307 if (!params->cArgs || !params->rgvarg)
1308 {
1309 WARN( "Missing put property value\n" );
1310 return E_INVALIDARG;
1311 }
1312
1313 vartype = to_vartype( type );
1314 V_VT( &value ) = VT_EMPTY;
1315 if (SUCCEEDED(hr = VariantChangeType( &value, params->rgvarg, 0, vartype )))
1316 {
1317 hr = IWbemClassObject_Put( object->object, name, 0, &value, 0 );
1318 VariantClear( &value );
1319 }
1320 return hr;
1321 }
1322 else
1323 {
1324 FIXME( "flags %x not supported\n", flags );
1325 return E_NOTIMPL;
1326 }
1327 }
1328
1329 static HRESULT WINAPI object_Put_(
1330 ISWbemObject *iface,
1331 LONG iFlags,
1332 IDispatch *objWbemNamedValueSet,
1333 ISWbemObjectPath **objWbemObjectPath )
1334 {
1335 FIXME( "\n" );
1336 return E_NOTIMPL;
1337 }
1338
1339 static HRESULT WINAPI object_PutAsync_(
1340 ISWbemObject *iface,
1341 IDispatch *objWbemSink,
1342 LONG iFlags,
1343 IDispatch *objWbemNamedValueSet,
1344 IDispatch *objWbemAsyncContext )
1345 {
1346 FIXME( "\n" );
1347 return E_NOTIMPL;
1348 }
1349
1350 static HRESULT WINAPI object_Delete_(
1351 ISWbemObject *iface,
1352 LONG iFlags,
1353 IDispatch *objWbemNamedValueSet )
1354 {
1355 FIXME( "\n" );
1356 return E_NOTIMPL;
1357 }
1358
1359 static HRESULT WINAPI object_DeleteAsync_(
1360 ISWbemObject *iface,
1361 IDispatch *objWbemSink,
1362 LONG iFlags,
1363 IDispatch *objWbemNamedValueSet,
1364 IDispatch *objWbemAsyncContext )
1365 {
1366 FIXME( "\n" );
1367 return E_NOTIMPL;
1368 }
1369
1370 static HRESULT WINAPI object_Instances_(
1371 ISWbemObject *iface,
1372 LONG iFlags,
1373 IDispatch *objWbemNamedValueSet,
1374 ISWbemObjectSet **objWbemObjectSet )
1375 {
1376 FIXME( "\n" );
1377 return E_NOTIMPL;
1378 }
1379
1380 static HRESULT WINAPI object_InstancesAsync_(
1381 ISWbemObject *iface,
1382 IDispatch *objWbemSink,
1383 LONG iFlags,
1384 IDispatch *objWbemNamedValueSet,
1385 IDispatch *objWbemAsyncContext )
1386 {
1387 FIXME( "\n" );
1388 return E_NOTIMPL;
1389 }
1390
1391 static HRESULT WINAPI object_Subclasses_(
1392 ISWbemObject *iface,
1393 LONG iFlags,
1394 IDispatch *objWbemNamedValueSet,
1395 ISWbemObjectSet **objWbemObjectSet )
1396 {
1397 FIXME( "\n" );
1398 return E_NOTIMPL;
1399 }
1400
1401 static HRESULT WINAPI object_SubclassesAsync_(
1402 ISWbemObject *iface,
1403 IDispatch *objWbemSink,
1404 LONG iFlags,
1405 IDispatch *objWbemNamedValueSet,
1406 IDispatch *objWbemAsyncContext )
1407 {
1408 FIXME( "\n" );
1409 return E_NOTIMPL;
1410 }
1411
1412 static HRESULT WINAPI object_Associators_(
1413 ISWbemObject *iface,
1414 BSTR strAssocClass,
1415 BSTR strResultClass,
1416 BSTR strResultRole,
1417 BSTR strRole,
1418 VARIANT_BOOL bClassesOnly,
1419 VARIANT_BOOL bSchemaOnly,
1420 BSTR strRequiredAssocQualifier,
1421 BSTR strRequiredQualifier,
1422 LONG iFlags,
1423 IDispatch *objWbemNamedValueSet,
1424 ISWbemObjectSet **objWbemObjectSet )
1425 {
1426 FIXME( "\n" );
1427 return E_NOTIMPL;
1428 }
1429
1430 static HRESULT WINAPI object_AssociatorsAsync_(
1431 ISWbemObject *iface,
1432 IDispatch *objWbemSink,
1433 BSTR strAssocClass,
1434 BSTR strResultClass,
1435 BSTR strResultRole,
1436 BSTR strRole,
1437 VARIANT_BOOL bClassesOnly,
1438 VARIANT_BOOL bSchemaOnly,
1439 BSTR strRequiredAssocQualifier,
1440 BSTR strRequiredQualifier,
1441 LONG iFlags,
1442 IDispatch *objWbemNamedValueSet,
1443 IDispatch *objWbemAsyncContext )
1444 {
1445 FIXME( "\n" );
1446 return E_NOTIMPL;
1447 }
1448
1449 static HRESULT WINAPI object_References_(
1450 ISWbemObject *iface,
1451 BSTR strResultClass,
1452 BSTR strRole,
1453 VARIANT_BOOL bClassesOnly,
1454 VARIANT_BOOL bSchemaOnly,
1455 BSTR strRequiredQualifier,
1456 LONG iFlags,
1457 IDispatch *objWbemNamedValueSet,
1458 ISWbemObjectSet **objWbemObjectSet )
1459 {
1460 FIXME( "\n" );
1461 return E_NOTIMPL;
1462 }
1463
1464 static HRESULT WINAPI object_ReferencesAsync_(
1465 ISWbemObject *iface,
1466 IDispatch *objWbemSink,
1467 BSTR strResultClass,
1468 BSTR strRole,
1469 VARIANT_BOOL bClassesOnly,
1470 VARIANT_BOOL bSchemaOnly,
1471 BSTR strRequiredQualifier,
1472 LONG iFlags,
1473 IDispatch *objWbemNamedValueSet,
1474 IDispatch *objWbemAsyncContext )
1475 {
1476 FIXME( "\n" );
1477 return E_NOTIMPL;
1478 }
1479
1480 static HRESULT WINAPI object_ExecMethod_(
1481 ISWbemObject *iface,
1482 BSTR method,
1483 IDispatch *in_params,
1484 LONG flags,
1485 IDispatch *valueset,
1486 ISWbemObject **out_params )
1487 {
1488 struct object *object = impl_from_ISWbemObject( iface );
1489 VARIANT path;
1490 HRESULT hr;
1491
1492 TRACE( "%p, %s, %p, %#x, %p, %p\n", object, debugstr_w(method), in_params, flags, valueset, out_params );
1493
1494 V_VT( &path ) = VT_EMPTY;
1495 hr = IWbemClassObject_Get( object->object, L"__PATH", 0, &path, NULL, NULL );
1496 if (SUCCEEDED(hr))
1497 {
1498 if (V_VT( &path ) != VT_BSTR)
1499 {
1500 WARN( "Unexpected object path value type.\n" );
1501 VariantClear( &path );
1502 return E_UNEXPECTED;
1503 }
1504
1505 hr = ISWbemServices_ExecMethod( &object->services->ISWbemServices_iface, V_BSTR( &path ), method,
1506 in_params, flags, valueset, out_params );
1507
1508 VariantClear( &path );
1509 }
1510
1511 return hr;
1512 }
1513
1514 static HRESULT WINAPI object_ExecMethodAsync_(
1515 ISWbemObject *iface,
1516 IDispatch *objWbemSink,
1517 BSTR strMethodName,
1518 IDispatch *objWbemInParameters,
1519 LONG iFlags,
1520 IDispatch *objWbemNamedValueSet,
1521 IDispatch *objWbemAsyncContext )
1522 {
1523 FIXME( "\n" );
1524 return E_NOTIMPL;
1525 }
1526
1527 static HRESULT WINAPI object_Clone_(
1528 ISWbemObject *iface,
1529 ISWbemObject **objWbemObject )
1530 {
1531 FIXME( "\n" );
1532 return E_NOTIMPL;
1533 }
1534
1535 static HRESULT WINAPI object_GetObjectText_(
1536 ISWbemObject *iface,
1537 LONG flags,
1538 BSTR *text )
1539 {
1540 struct object *object = impl_from_ISWbemObject( iface );
1541
1542 TRACE( "%p, %#x, %p\n", object, flags, text );
1543
1544 return IWbemClassObject_GetObjectText( object->object, flags, text );
1545 }
1546
1547 static HRESULT WINAPI object_SpawnDerivedClass_(
1548 ISWbemObject *iface,
1549 LONG iFlags,
1550 ISWbemObject **objWbemObject )
1551 {
1552 FIXME( "\n" );
1553 return E_NOTIMPL;
1554 }
1555
1556 static HRESULT WINAPI object_SpawnInstance_(
1557 ISWbemObject *iface,
1558 LONG iFlags,
1559 ISWbemObject **objWbemObject )
1560 {
1561 FIXME( "\n" );
1562 return E_NOTIMPL;
1563 }
1564
1565 static HRESULT WINAPI object_CompareTo_(
1566 ISWbemObject *iface,
1567 IDispatch *objWbemObject,
1568 LONG iFlags,
1569 VARIANT_BOOL *bResult )
1570 {
1571 FIXME( "\n" );
1572 return E_NOTIMPL;
1573 }
1574
1575 static HRESULT WINAPI object_get_Qualifiers_(
1576 ISWbemObject *iface,
1577 ISWbemQualifierSet **objWbemQualifierSet )
1578 {
1579 FIXME( "\n" );
1580 return E_NOTIMPL;
1581 }
1582
1583 static HRESULT WINAPI object_get_Properties_( ISWbemObject *iface, ISWbemPropertySet **prop_set )
1584 {
1585 struct object *object = impl_from_ISWbemObject( iface );
1586
1587 TRACE( "%p, %p\n", object, prop_set );
1588 return SWbemPropertySet_create( object->object, prop_set );
1589 }
1590
1591 static HRESULT WINAPI object_get_Methods_(
1592 ISWbemObject *iface,
1593 ISWbemMethodSet **set )
1594 {
1595 struct object *object = impl_from_ISWbemObject( iface );
1596
1597 TRACE( "%p, %p\n", object, set );
1598 return SWbemMethodSet_create( object, set );
1599 }
1600
1601 static HRESULT WINAPI object_get_Derivation_(
1602 ISWbemObject *iface,
1603 VARIANT *strClassNameArray )
1604 {
1605 FIXME( "\n" );
1606 return E_NOTIMPL;
1607 }
1608
1609 static HRESULT WINAPI object_get_Path_(
1610 ISWbemObject *iface,
1611 ISWbemObjectPath **objWbemObjectPath )
1612 {
1613 FIXME( "\n" );
1614 return E_NOTIMPL;
1615 }
1616
1617 static HRESULT WINAPI object_get_Security_(
1618 ISWbemObject *iface,
1619 ISWbemSecurity **objWbemSecurity )
1620 {
1621 FIXME( "\n" );
1622 return E_NOTIMPL;
1623 }
1624
1625 static const ISWbemObjectVtbl object_vtbl =
1626 {
1627 object_QueryInterface,
1628 object_AddRef,
1629 object_Release,
1630 object_GetTypeInfoCount,
1631 object_GetTypeInfo,
1632 object_GetIDsOfNames,
1633 object_Invoke,
1634 object_Put_,
1635 object_PutAsync_,
1636 object_Delete_,
1637 object_DeleteAsync_,
1638 object_Instances_,
1639 object_InstancesAsync_,
1640 object_Subclasses_,
1641 object_SubclassesAsync_,
1642 object_Associators_,
1643 object_AssociatorsAsync_,
1644 object_References_,
1645 object_ReferencesAsync_,
1646 object_ExecMethod_,
1647 object_ExecMethodAsync_,
1648 object_Clone_,
1649 object_GetObjectText_,
1650 object_SpawnDerivedClass_,
1651 object_SpawnInstance_,
1652 object_CompareTo_,
1653 object_get_Qualifiers_,
1654 object_get_Properties_,
1655 object_get_Methods_,
1656 object_get_Derivation_,
1657 object_get_Path_,
1658 object_get_Security_
1659 };
1660
1661 static struct object *unsafe_object_impl_from_IDispatch(IDispatch *iface)
1662 {
1663 if (!iface)
1664 return NULL;
1665 if (iface->lpVtbl != (IDispatchVtbl *)&object_vtbl)
1666 {
1667 FIXME( "External implementations are not supported.\n" );
1668 return NULL;
1669 }
1670 return CONTAINING_RECORD(iface, struct object, ISWbemObject_iface);
1671 }
1672
1673 static HRESULT SWbemObject_create( struct services *services, IWbemClassObject *wbem_object,
1674 ISWbemObject **obj )
1675 {
1676 struct object *object;
1677
1678 TRACE( "%p, %p\n", obj, wbem_object );
1679
1680 if (!(object = heap_alloc( sizeof(*object) ))) return E_OUTOFMEMORY;
1681 object->ISWbemObject_iface.lpVtbl = &object_vtbl;
1682 object->refs = 1;
1683 object->object = wbem_object;
1684 IWbemClassObject_AddRef( object->object );
1685 object->members = NULL;
1686 object->nb_members = 0;
1687 object->last_dispid = DISPID_BASE;
1688 object->last_dispid_method = DISPID_BASE_METHOD;
1689 object->services = services;
1690 ISWbemServices_AddRef( &object->services->ISWbemServices_iface );
1691
1692 *obj = &object->ISWbemObject_iface;
1693 TRACE( "returning iface %p\n", *obj );
1694 return S_OK;
1695 }
1696
1697 struct objectset
1698 {
1699 ISWbemObjectSet ISWbemObjectSet_iface;
1700 LONG refs;
1701 IEnumWbemClassObject *objectenum;
1702 LONG count;
1703 struct services *services;
1704 };
1705
1706 static inline struct objectset *impl_from_ISWbemObjectSet(
1707 ISWbemObjectSet *iface )
1708 {
1709 return CONTAINING_RECORD( iface, struct objectset, ISWbemObjectSet_iface );
1710 }
1711
1712 static ULONG WINAPI objectset_AddRef(
1713 ISWbemObjectSet *iface )
1714 {
1715 struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
1716 return InterlockedIncrement( &objectset->refs );
1717 }
1718
1719 static ULONG WINAPI objectset_Release(
1720 ISWbemObjectSet *iface )
1721 {
1722 struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
1723 LONG refs = InterlockedDecrement( &objectset->refs );
1724 if (!refs)
1725 {
1726 TRACE( "destroying %p\n", objectset );
1727 IEnumWbemClassObject_Release( objectset->objectenum );
1728 ISWbemServices_Release( &objectset->services->ISWbemServices_iface );
1729 heap_free( objectset );
1730 }
1731 return refs;
1732 }
1733
1734 static HRESULT WINAPI objectset_QueryInterface(
1735 ISWbemObjectSet *iface,
1736 REFIID riid,
1737 void **ppvObject )
1738 {
1739 struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
1740
1741 TRACE( "%p %s %p\n", objectset, debugstr_guid(riid), ppvObject );
1742
1743 if (IsEqualGUID( riid, &IID_ISWbemObjectSet ) ||
1744 IsEqualGUID( riid, &IID_IDispatch ) ||
1745 IsEqualGUID( riid, &IID_IUnknown ))
1746 {
1747 *ppvObject = iface;
1748 }
1749 else
1750 {
1751 WARN( "interface %s not implemented\n", debugstr_guid(riid) );
1752 return E_NOINTERFACE;
1753 }
1754 ISWbemObjectSet_AddRef( iface );
1755 return S_OK;
1756 }
1757
1758 static HRESULT WINAPI objectset_GetTypeInfoCount(
1759 ISWbemObjectSet *iface,
1760 UINT *count )
1761 {
1762 struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
1763 TRACE( "%p, %p\n", objectset, count );
1764 *count = 1;
1765 return S_OK;
1766 }
1767
1768 static HRESULT WINAPI objectset_GetTypeInfo(
1769 ISWbemObjectSet *iface,
1770 UINT index,
1771 LCID lcid,
1772 ITypeInfo **info )
1773 {
1774 struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
1775 TRACE( "%p, %u, %u, %p\n", objectset, index, lcid, info );
1776
1777 return get_typeinfo( ISWbemObjectSet_tid, info );
1778 }
1779
1780 static HRESULT WINAPI objectset_GetIDsOfNames(
1781 ISWbemObjectSet *iface,
1782 REFIID riid,
1783 LPOLESTR *names,
1784 UINT count,
1785 LCID lcid,
1786 DISPID *dispid )
1787 {
1788 struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
1789 ITypeInfo *typeinfo;
1790 HRESULT hr;
1791
1792 TRACE( "%p, %s, %p, %u, %u, %p\n", objectset, debugstr_guid(riid), names, count, lcid, dispid );
1793
1794 if (!names || !count || !dispid) return E_INVALIDARG;
1795
1796 hr = get_typeinfo( ISWbemObjectSet_tid, &typeinfo );
1797 if (SUCCEEDED(hr))
1798 {
1799 hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
1800 ITypeInfo_Release( typeinfo );
1801 }
1802 return hr;
1803 }
1804
1805 static HRESULT WINAPI objectset_Invoke(
1806 ISWbemObjectSet *iface,
1807 DISPID member,
1808 REFIID riid,
1809 LCID lcid,
1810 WORD flags,
1811 DISPPARAMS *params,
1812 VARIANT *result,
1813 EXCEPINFO *excep_info,
1814 UINT *arg_err )
1815 {
1816 struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
1817 ITypeInfo *typeinfo;
1818 HRESULT hr;
1819
1820 TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", objectset, member, debugstr_guid(riid),
1821 lcid, flags, params, result, excep_info, arg_err );
1822
1823 hr = get_typeinfo( ISWbemObjectSet_tid, &typeinfo );
1824 if (SUCCEEDED(hr))
1825 {
1826 hr = ITypeInfo_Invoke( typeinfo, &objectset->ISWbemObjectSet_iface, member, flags,
1827 params, result, excep_info, arg_err );
1828 ITypeInfo_Release( typeinfo );
1829 }
1830 return hr;
1831 }
1832
1833 static HRESULT WINAPI objectset_get__NewEnum(
1834 ISWbemObjectSet *iface,
1835 IUnknown **pUnk )
1836 {
1837 struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
1838 IEnumWbemClassObject *objectenum;
1839 HRESULT hr;
1840
1841 TRACE( "%p, %p\n", objectset, pUnk );
1842
1843 hr = IEnumWbemClassObject_Clone( objectset->objectenum, &objectenum );
1844 if (FAILED( hr )) return hr;
1845
1846 hr = EnumVARIANT_create( objectset->services, objectenum, (IEnumVARIANT **)pUnk );
1847 IEnumWbemClassObject_Release( objectenum );
1848 return hr;
1849 }
1850
1851 static HRESULT WINAPI objectset_Item(
1852 ISWbemObjectSet *iface,
1853 BSTR strObjectPath,
1854 LONG iFlags,
1855 ISWbemObject **objWbemObject )
1856 {
1857 FIXME( "\n" );
1858 return E_NOTIMPL;
1859 }
1860
1861 static HRESULT WINAPI objectset_get_Count(
1862 ISWbemObjectSet *iface,
1863 LONG *iCount )
1864 {
1865 struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
1866
1867 TRACE( "%p, %p\n", objectset, iCount );
1868
1869 *iCount = objectset->count;
1870 return S_OK;
1871 }
1872
1873 static HRESULT WINAPI objectset_get_Security_(
1874 ISWbemObjectSet *iface,
1875 ISWbemSecurity **objWbemSecurity )
1876 {
1877 FIXME( "\n" );
1878 return E_NOTIMPL;
1879 }
1880
1881 static HRESULT WINAPI objectset_ItemIndex(
1882 ISWbemObjectSet *iface,
1883 LONG lIndex,
1884 ISWbemObject **objWbemObject )
1885 {
1886 struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
1887 LONG count;
1888 HRESULT hr;
1889 IEnumVARIANT *enum_var;
1890 VARIANT var;
1891
1892 TRACE( "%p, %d, %p\n", objectset, lIndex, objWbemObject );
1893
1894 *objWbemObject = NULL;
1895 hr = ISWbemObjectSet_get_Count( iface, &count );
1896 if (FAILED(hr)) return hr;
1897
1898 if (lIndex >= count) return WBEM_E_NOT_FOUND;
1899
1900 hr = ISWbemObjectSet_get__NewEnum( iface, (IUnknown **)&enum_var );
1901 if (FAILED(hr)) return hr;
1902
1903 IEnumVARIANT_Reset( enum_var );
1904 hr = IEnumVARIANT_Skip( enum_var, lIndex );
1905 if (SUCCEEDED(hr))
1906 hr = IEnumVARIANT_Next( enum_var, 1, &var, NULL );
1907 IEnumVARIANT_Release( enum_var );
1908
1909 if (SUCCEEDED(hr))
1910 {
1911 if (V_VT( &var ) == VT_DISPATCH)
1912 hr = IDispatch_QueryInterface( V_DISPATCH( &var ), &IID_ISWbemObject, (void **)objWbemObject );
1913 else
1914 hr = WBEM_E_NOT_FOUND;
1915 VariantClear( &var );
1916 }
1917
1918 return hr;
1919 }
1920
1921 static const ISWbemObjectSetVtbl objectset_vtbl =
1922 {
1923 objectset_QueryInterface,
1924 objectset_AddRef,
1925 objectset_Release,
1926 objectset_GetTypeInfoCount,
1927 objectset_GetTypeInfo,
1928 objectset_GetIDsOfNames,
1929 objectset_Invoke,
1930 objectset_get__NewEnum,
1931 objectset_Item,
1932 objectset_get_Count,
1933 objectset_get_Security_,
1934 objectset_ItemIndex
1935 };
1936
1937 static LONG get_object_count( IEnumWbemClassObject *iter )
1938 {
1939 LONG count = 0;
1940 while (IEnumWbemClassObject_Skip( iter, WBEM_INFINITE, 1 ) == S_OK) count++;
1941 IEnumWbemClassObject_Reset( iter );
1942 return count;
1943 }
1944
1945 static HRESULT SWbemObjectSet_create( struct services *services, IEnumWbemClassObject *wbem_objectenum,
1946 ISWbemObjectSet **obj )
1947 {
1948 struct objectset *objectset;
1949
1950 TRACE( "%p, %p\n", obj, wbem_objectenum );
1951
1952 if (!(objectset = heap_alloc( sizeof(*objectset) ))) return E_OUTOFMEMORY;
1953 objectset->ISWbemObjectSet_iface.lpVtbl = &objectset_vtbl;
1954 objectset->refs = 1;
1955 objectset->objectenum = wbem_objectenum;
1956 IEnumWbemClassObject_AddRef( objectset->objectenum );
1957 objectset->count = get_object_count( objectset->objectenum );
1958 objectset->services = services;
1959 ISWbemServices_AddRef( &services->ISWbemServices_iface );
1960
1961 *obj = &objectset->ISWbemObjectSet_iface;
1962 TRACE( "returning iface %p\n", *obj );
1963 return S_OK;
1964 }
1965
1966 struct enumvar
1967 {
1968 IEnumVARIANT IEnumVARIANT_iface;
1969 LONG refs;
1970 IEnumWbemClassObject *objectenum;
1971 struct services *services;
1972 };
1973
1974 static inline struct enumvar *impl_from_IEnumVARIANT(
1975 IEnumVARIANT *iface )
1976 {
1977 return CONTAINING_RECORD( iface, struct enumvar, IEnumVARIANT_iface );
1978 }
1979
1980 static ULONG WINAPI enumvar_AddRef(
1981 IEnumVARIANT *iface )
1982 {
1983 struct enumvar *enumvar = impl_from_IEnumVARIANT( iface );
1984 return InterlockedIncrement( &enumvar->refs );
1985 }
1986
1987 static ULONG WINAPI enumvar_Release(
1988 IEnumVARIANT *iface )
1989 {
1990 struct enumvar *enumvar = impl_from_IEnumVARIANT( iface );
1991 LONG refs = InterlockedDecrement( &enumvar->refs );
1992 if (!refs)
1993 {
1994 TRACE( "destroying %p\n", enumvar );
1995 IEnumWbemClassObject_Release( enumvar->objectenum );
1996 ISWbemServices_Release( &enumvar->services->ISWbemServices_iface );
1997 heap_free( enumvar );
1998 }
1999 return refs;
2000 }
2001
2002 static HRESULT WINAPI enumvar_QueryInterface(
2003 IEnumVARIANT *iface,
2004 REFIID riid,
2005 void **ppvObject )
2006 {
2007 struct enumvar *enumvar = impl_from_IEnumVARIANT( iface );
2008
2009 TRACE( "%p %s %p\n", enumvar, debugstr_guid(riid), ppvObject );
2010
2011 if (IsEqualGUID( riid, &IID_IEnumVARIANT ) ||
2012 IsEqualGUID( riid, &IID_IUnknown ))
2013 {
2014 *ppvObject = iface;
2015 }
2016 else
2017 {
2018 WARN( "interface %s not implemented\n", debugstr_guid(riid) );
2019 return E_NOINTERFACE;
2020 }
2021 IEnumVARIANT_AddRef( iface );
2022 return S_OK;
2023 }
2024
2025 static HRESULT WINAPI enumvar_Next( IEnumVARIANT *iface, ULONG celt, VARIANT *var, ULONG *fetched )
2026 {
2027 struct enumvar *enumvar = impl_from_IEnumVARIANT( iface );
2028 IWbemClassObject *obj;
2029 ULONG count = 0;
2030
2031 TRACE( "%p, %u, %p, %p\n", iface, celt, var, fetched );
2032
2033 if (celt) IEnumWbemClassObject_Next( enumvar->objectenum, WBEM_INFINITE, 1, &obj, &count );
2034 if (count)
2035 {
2036 ISWbemObject *sobj;
2037 HRESULT hr;
2038
2039 hr = SWbemObject_create( enumvar->services, obj, &sobj );
2040 IWbemClassObject_Release( obj );
2041 if (FAILED( hr )) return hr;
2042
2043 V_VT( var ) = VT_DISPATCH;
2044 V_DISPATCH( var ) = (IDispatch *)sobj;
2045 }
2046 if (fetched) *fetched = count;
2047 return (count < celt) ? S_FALSE : S_OK;
2048 }
2049
2050 static HRESULT WINAPI enumvar_Skip( IEnumVARIANT *iface, ULONG celt )
2051 {
2052 struct enumvar *enumvar = impl_from_IEnumVARIANT( iface );
2053
2054 TRACE( "%p, %u\n", iface, celt );
2055
2056 return IEnumWbemClassObject_Skip( enumvar->objectenum, WBEM_INFINITE, celt );
2057 }
2058
2059 static HRESULT WINAPI enumvar_Reset( IEnumVARIANT *iface )
2060 {
2061 struct enumvar *enumvar = impl_from_IEnumVARIANT( iface );
2062
2063 TRACE( "%p\n", iface );
2064
2065 return IEnumWbemClassObject_Reset( enumvar->objectenum );
2066 }
2067
2068 static HRESULT WINAPI enumvar_Clone( IEnumVARIANT *iface, IEnumVARIANT **penum )
2069 {
2070 FIXME( "%p, %p\n", iface, penum );
2071 return E_NOTIMPL;
2072 }
2073
2074 static const struct IEnumVARIANTVtbl enumvar_vtbl =
2075 {
2076 enumvar_QueryInterface,
2077 enumvar_AddRef,
2078 enumvar_Release,
2079 enumvar_Next,
2080 enumvar_Skip,
2081 enumvar_Reset,
2082 enumvar_Clone
2083 };
2084
2085 static HRESULT EnumVARIANT_create( struct services *services, IEnumWbemClassObject *objectenum,
2086 IEnumVARIANT **obj )
2087 {
2088 struct enumvar *enumvar;
2089
2090 if (!(enumvar = heap_alloc( sizeof(*enumvar) ))) return E_OUTOFMEMORY;
2091 enumvar->IEnumVARIANT_iface.lpVtbl = &enumvar_vtbl;
2092 enumvar->refs = 1;
2093 enumvar->objectenum = objectenum;
2094 IEnumWbemClassObject_AddRef( enumvar->objectenum );
2095 enumvar->services = services;
2096 ISWbemServices_AddRef( &services->ISWbemServices_iface );
2097
2098 *obj = &enumvar->IEnumVARIANT_iface;
2099 TRACE( "returning iface %p\n", *obj );
2100 return S_OK;
2101 }
2102
2103 static inline struct services *impl_from_ISWbemServices(
2104 ISWbemServices *iface )
2105 {
2106 return CONTAINING_RECORD( iface, struct services, ISWbemServices_iface );
2107 }
2108
2109 static ULONG WINAPI services_AddRef(
2110 ISWbemServices *iface )
2111 {
2112 struct services *services = impl_from_ISWbemServices( iface );
2113 return InterlockedIncrement( &services->refs );
2114 }
2115
2116 static ULONG WINAPI services_Release(
2117 ISWbemServices *iface )
2118 {
2119 struct services *services = impl_from_ISWbemServices( iface );
2120 LONG refs = InterlockedDecrement( &services->refs );
2121 if (!refs)
2122 {
2123 TRACE( "destroying %p\n", services );
2124 IWbemServices_Release( services->services );
2125 heap_free( services );
2126 }
2127 return refs;
2128 }
2129
2130 static HRESULT WINAPI services_QueryInterface(
2131 ISWbemServices *iface,
2132 REFIID riid,
2133 void **ppvObject )
2134 {
2135 struct services *services = impl_from_ISWbemServices( iface );
2136
2137 TRACE( "%p %s %p\n", services, debugstr_guid(riid), ppvObject );
2138
2139 if (IsEqualGUID( riid, &IID_ISWbemServices ) ||
2140 IsEqualGUID( riid, &IID_IDispatch ) ||
2141 IsEqualGUID( riid, &IID_IUnknown ))
2142 {
2143 *ppvObject = iface;
2144 }
2145 else
2146 {
2147 WARN( "interface %s not implemented\n", debugstr_guid(riid) );
2148 return E_NOINTERFACE;
2149 }
2150 ISWbemServices_AddRef( iface );
2151 return S_OK;
2152 }
2153
2154 static HRESULT WINAPI services_GetTypeInfoCount(
2155 ISWbemServices *iface,
2156 UINT *count )
2157 {
2158 struct services *services = impl_from_ISWbemServices( iface );
2159 TRACE( "%p, %p\n", services, count );
2160
2161 *count = 1;
2162 return S_OK;
2163 }
2164
2165 static HRESULT WINAPI services_GetTypeInfo(
2166 ISWbemServices *iface,
2167 UINT index,
2168 LCID lcid,
2169 ITypeInfo **info )
2170 {
2171 struct services *services = impl_from_ISWbemServices( iface );
2172 TRACE( "%p, %u, %u, %p\n", services, index, lcid, info );
2173
2174 return get_typeinfo( ISWbemServices_tid, info );
2175 }
2176
2177 static HRESULT WINAPI services_GetIDsOfNames(
2178 ISWbemServices *iface,
2179 REFIID riid,
2180 LPOLESTR *names,
2181 UINT count,
2182 LCID lcid,
2183 DISPID *dispid )
2184 {
2185 struct services *services = impl_from_ISWbemServices( iface );
2186 ITypeInfo *typeinfo;
2187 HRESULT hr;
2188
2189 TRACE( "%p, %s, %p, %u, %u, %p\n", services, debugstr_guid(riid), names, count, lcid, dispid );
2190
2191 if (!names || !count || !dispid) return E_INVALIDARG;
2192
2193 hr = get_typeinfo( ISWbemServices_tid, &typeinfo );
2194 if (SUCCEEDED(hr))
2195 {
2196 hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
2197 ITypeInfo_Release( typeinfo );
2198 }
2199 return hr;
2200 }
2201
2202 static HRESULT WINAPI services_Invoke(
2203 ISWbemServices *iface,
2204 DISPID member,
2205 REFIID riid,
2206 LCID lcid,
2207 WORD flags,
2208 DISPPARAMS *params,
2209 VARIANT *result,
2210 EXCEPINFO *excep_info,
2211 UINT *arg_err )
2212 {
2213 struct services *services = impl_from_ISWbemServices( iface );
2214 ITypeInfo *typeinfo;
2215 HRESULT hr;
2216
2217 TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", services, member, debugstr_guid(riid),
2218 lcid, flags, params, result, excep_info, arg_err );
2219
2220 hr = get_typeinfo( ISWbemServices_tid, &typeinfo );
2221 if (SUCCEEDED(hr))
2222 {
2223 hr = ITypeInfo_Invoke( typeinfo, &services->ISWbemServices_iface, member, flags,
2224 params, result, excep_info, arg_err );
2225 ITypeInfo_Release( typeinfo );
2226 }
2227 return hr;
2228 }
2229
2230 static HRESULT WINAPI services_Get(
2231 ISWbemServices *iface,
2232 BSTR strObjectPath,
2233 LONG iFlags,
2234 IDispatch *objWbemNamedValueSet,
2235 ISWbemObject **objWbemObject )
2236 {
2237 struct services *services = impl_from_ISWbemServices( iface );
2238 IWbemClassObject *obj;
2239 HRESULT hr;
2240
2241 TRACE( "%p, %s, %d, %p, %p\n", iface, debugstr_w(strObjectPath), iFlags, objWbemNamedValueSet,
2242 objWbemObject );
2243
2244 if (objWbemNamedValueSet) FIXME( "ignoring context\n" );
2245
2246 hr = IWbemServices_GetObject( services->services, strObjectPath, iFlags, NULL, &obj, NULL );
2247 if (hr != S_OK) return hr;
2248
2249 hr = SWbemObject_create( services, obj, objWbemObject );
2250 IWbemClassObject_Release( obj );
2251 return hr;
2252 }
2253
2254 static HRESULT WINAPI services_GetAsync(
2255 ISWbemServices *iface,
2256 IDispatch *objWbemSink,
2257 BSTR strObjectPath,
2258 LONG iFlags,
2259 IDispatch *objWbemNamedValueSet,
2260 IDispatch *objWbemAsyncContext )
2261 {
2262 FIXME( "\n" );
2263 return E_NOTIMPL;
2264 }
2265
2266 static HRESULT WINAPI services_Delete(
2267 ISWbemServices *iface,
2268 BSTR strObjectPath,
2269 LONG iFlags,
2270 IDispatch *objWbemNamedValueSet )
2271 {
2272 FIXME( "\n" );
2273 return E_NOTIMPL;
2274 }
2275
2276 static HRESULT WINAPI services_DeleteAsync(
2277 ISWbemServices* This,
2278 IDispatch *objWbemSink,
2279 BSTR strObjectPath,
2280 LONG iFlags,
2281 IDispatch *objWbemNamedValueSet,
2282 IDispatch *objWbemAsyncContext )
2283 {
2284 FIXME( "\n" );
2285 return E_NOTIMPL;
2286 }
2287
2288 static BSTR build_query_string( const WCHAR *class )
2289 {
2290 UINT len = lstrlenW(class) + ARRAY_SIZE(L"SELECT * FROM ");
2291 BSTR ret;
2292
2293 if (!(ret = SysAllocStringLen( NULL, len ))) return NULL;
2294 lstrcpyW( ret, L"SELECT * FROM " );
2295 lstrcatW( ret, class );
2296 return ret;
2297 }
2298
2299 static HRESULT WINAPI services_InstancesOf(
2300 ISWbemServices *iface,
2301 BSTR strClass,
2302 LONG iFlags,
2303 IDispatch *objWbemNamedValueSet,
2304 ISWbemObjectSet **objWbemObjectSet )
2305 {
2306 BSTR query, wql = SysAllocString( L"WQL" );
2307 HRESULT hr;
2308
2309 TRACE( "%p, %s, %x, %p, %p\n", iface, debugstr_w(strClass), iFlags, objWbemNamedValueSet,
2310 objWbemObjectSet );
2311
2312 if (!(query = build_query_string( strClass )))
2313 {
2314 SysFreeString( wql );
2315 return E_OUTOFMEMORY;
2316 }
2317 hr = ISWbemServices_ExecQuery( iface, query, wql, iFlags, objWbemNamedValueSet, objWbemObjectSet );
2318 SysFreeString( wql );
2319 SysFreeString( query );
2320 return hr;
2321 }
2322
2323 static HRESULT WINAPI services_InstancesOfAsync(
2324 ISWbemServices *iface,
2325 IDispatch *objWbemSink,
2326 BSTR strClass,
2327 LONG iFlags,
2328 IDispatch *objWbemNamedValueSet,
2329 IDispatch *objWbemAsyncContext )
2330 {
2331 FIXME( "\n" );
2332 return E_NOTIMPL;
2333 }
2334
2335 static HRESULT WINAPI services_SubclassesOf(
2336 ISWbemServices *iface,
2337 BSTR strSuperclass,
2338 LONG iFlags,
2339 IDispatch *objWbemNamedValueSet,
2340 ISWbemObjectSet **objWbemObjectSet )
2341 {
2342 FIXME( "\n" );
2343 return E_NOTIMPL;
2344 }
2345
2346 static HRESULT WINAPI services_SubclassesOfAsync(
2347 ISWbemServices *iface,
2348 IDispatch *objWbemSink,
2349 BSTR strSuperclass,
2350 LONG iFlags,
2351 IDispatch *objWbemNamedValueSet,
2352 IDispatch *objWbemAsyncContext )
2353 {
2354 FIXME( "\n" );
2355 return E_NOTIMPL;
2356 }
2357
2358 static HRESULT WINAPI services_ExecQuery(
2359 ISWbemServices *iface,
2360 BSTR strQuery,
2361 BSTR strQueryLanguage,
2362 LONG iFlags,
2363 IDispatch *objWbemNamedValueSet,
2364 ISWbemObjectSet **objWbemObjectSet )
2365 {
2366 struct services *services = impl_from_ISWbemServices( iface );
2367 IEnumWbemClassObject *iter;
2368 HRESULT hr;
2369
2370 TRACE( "%p, %s, %s, %x, %p, %p\n", iface, debugstr_w(strQuery), debugstr_w(strQueryLanguage),
2371 iFlags, objWbemNamedValueSet, objWbemObjectSet );
2372
2373 if (objWbemNamedValueSet) FIXME( "ignoring context\n" );
2374
2375 hr = IWbemServices_ExecQuery( services->services, strQueryLanguage, strQuery, iFlags, NULL, &iter );
2376 if (hr != S_OK) return hr;
2377
2378 hr = SWbemObjectSet_create( services, iter, objWbemObjectSet );
2379 IEnumWbemClassObject_Release( iter );
2380 return hr;
2381 }
2382
2383 static HRESULT WINAPI services_ExecQueryAsync(
2384 ISWbemServices *iface,
2385 IDispatch *objWbemSink,
2386 BSTR strQuery,
2387 BSTR strQueryLanguage,
2388 LONG lFlags,
2389 IDispatch *objWbemNamedValueSet,
2390 IDispatch *objWbemAsyncContext )
2391 {
2392 FIXME( "\n" );
2393 return E_NOTIMPL;
2394 }
2395
2396 static HRESULT WINAPI services_AssociatorsOf(
2397 ISWbemServices *iface,
2398 BSTR strObjectPath,
2399 BSTR strAssocClass,
2400 BSTR strResultClass,
2401 BSTR strResultRole,
2402 BSTR strRole,
2403 VARIANT_BOOL bClassesOnly,
2404 VARIANT_BOOL bSchemaOnly,
2405 BSTR strRequiredAssocQualifier,
2406 BSTR strRequiredQualifier,
2407 LONG iFlags,
2408 IDispatch *objWbemNamedValueSet,
2409 ISWbemObjectSet **objWbemObjectSet )
2410 {
2411 FIXME( "\n" );
2412 return E_NOTIMPL;
2413 }
2414
2415 static HRESULT WINAPI services_AssociatorsOfAsync(
2416 ISWbemServices *iface,
2417 IDispatch *objWbemSink,
2418 BSTR strObjectPath,
2419 BSTR strAssocClass,
2420 BSTR strResultClass,
2421 BSTR strResultRole,
2422 BSTR strRole,
2423 VARIANT_BOOL bClassesOnly,
2424 VARIANT_BOOL bSchemaOnly,
2425 BSTR strRequiredAssocQualifier,
2426 BSTR strRequiredQualifier,
2427 LONG iFlags,
2428 IDispatch *objWbemNamedValueSet,
2429 IDispatch *objWbemAsyncContext )
2430 {
2431 FIXME( "\n" );
2432 return E_NOTIMPL;
2433 }
2434
2435 static HRESULT WINAPI services_ReferencesTo(
2436 ISWbemServices *iface,
2437 BSTR strObjectPath,
2438 BSTR strResultClass,
2439 BSTR strRole,
2440 VARIANT_BOOL bClassesOnly,
2441 VARIANT_BOOL bSchemaOnly,
2442 BSTR strRequiredQualifier,
2443 LONG iFlags,
2444 IDispatch *objWbemNamedValueSet,
2445 ISWbemObjectSet **objWbemObjectSet )
2446 {
2447 FIXME( "\n" );
2448 return E_NOTIMPL;
2449 }
2450
2451 static HRESULT WINAPI services_ReferencesToAsync(
2452 ISWbemServices *iface,
2453 IDispatch *objWbemSink,
2454 BSTR strObjectPath,
2455 BSTR strResultClass,
2456 BSTR strRole,
2457 VARIANT_BOOL bClassesOnly,
2458 VARIANT_BOOL bSchemaOnly,
2459 BSTR strRequiredQualifier,
2460 LONG iFlags,
2461 IDispatch *objWbemNamedValueSet,
2462 IDispatch *objWbemAsyncContext )
2463 {
2464 FIXME( "\n" );
2465 return E_NOTIMPL;
2466 }
2467
2468 static HRESULT WINAPI services_ExecNotificationQuery(
2469 ISWbemServices *iface,
2470 BSTR strQuery,
2471 BSTR strQueryLanguage,
2472 LONG iFlags,
2473 IDispatch *objWbemNamedValueSet,
2474 ISWbemEventSource **objWbemEventSource )
2475 {
2476 FIXME( "\n" );
2477 return E_NOTIMPL;
2478 }
2479
2480 static HRESULT WINAPI services_ExecNotificationQueryAsync(
2481 ISWbemServices *iface,
2482 IDispatch *objWbemSink,
2483 BSTR strQuery,
2484 BSTR strQueryLanguage,
2485 LONG iFlags,
2486 IDispatch *objWbemNamedValueSet,
2487 IDispatch *objWbemAsyncContext )
2488 {
2489 FIXME( "\n" );
2490 return E_NOTIMPL;
2491 }
2492
2493 static HRESULT WINAPI services_ExecMethod(
2494 ISWbemServices *iface,
2495 BSTR path,
2496 BSTR method,
2497 IDispatch *in_sparams,
2498 LONG flags,
2499 IDispatch *valueset,
2500 ISWbemObject **out_sparams )
2501 {
2502 struct services *services = impl_from_ISWbemServices( iface );
2503 IWbemClassObject *out_params = NULL;
2504 struct object *in_params;
2505 IWbemContext *context;
2506 HRESULT hr;
2507
2508 TRACE( "%p, %s, %s, %p, %#x, %p, %p\n", services, debugstr_w(path), debugstr_w(method), in_sparams,
2509 flags, valueset, out_sparams );
2510
2511 in_params = unsafe_object_impl_from_IDispatch( in_sparams );
2512 out_params = NULL;
2513
2514 context = unsafe_get_context_from_namedvalueset( valueset );
2515
2516 hr = IWbemServices_ExecMethod( services->services, path, method, flags, context, in_params ? in_params->object : NULL,
2517 out_sparams ? &out_params : NULL, NULL );
2518
2519 if (SUCCEEDED(hr) && out_params)
2520 {
2521 hr = SWbemObject_create( services, out_params, out_sparams );
2522 IWbemClassObject_Release( out_params );
2523 }
2524
2525 return hr;
2526 }
2527
2528 static HRESULT WINAPI services_ExecMethodAsync(
2529 ISWbemServices *iface,
2530 IDispatch *objWbemSink,
2531 BSTR strObjectPath,
2532 BSTR strMethodName,
2533 IDispatch *objWbemInParameters,
2534 LONG iFlags,
2535 IDispatch *objWbemNamedValueSet,
2536 IDispatch *objWbemAsyncContext )
2537 {
2538 FIXME( "\n" );
2539 return E_NOTIMPL;
2540 }
2541
2542 static HRESULT WINAPI services_get_Security_(
2543 ISWbemServices *iface,
2544 ISWbemSecurity **objWbemSecurity )
2545 {
2546 TRACE( "%p, %p\n", iface, objWbemSecurity );
2547
2548 if (!objWbemSecurity)
2549 return E_INVALIDARG;
2550
2551 return ISWbemSecurity_create( objWbemSecurity );
2552 }
2553
2554 static const ISWbemServicesVtbl services_vtbl =
2555 {
2556 services_QueryInterface,
2557 services_AddRef,
2558 services_Release,
2559 services_GetTypeInfoCount,
2560 services_GetTypeInfo,
2561 services_GetIDsOfNames,
2562 services_Invoke,
2563 services_Get,
2564 services_GetAsync,
2565 services_Delete,
2566 services_DeleteAsync,
2567 services_InstancesOf,
2568 services_InstancesOfAsync,
2569 services_SubclassesOf,
2570 services_SubclassesOfAsync,
2571 services_ExecQuery,
2572 services_ExecQueryAsync,
2573 services_AssociatorsOf,
2574 services_AssociatorsOfAsync,
2575 services_ReferencesTo,
2576 services_ReferencesToAsync,
2577 services_ExecNotificationQuery,
2578 services_ExecNotificationQueryAsync,
2579 services_ExecMethod,
2580 services_ExecMethodAsync,
2581 services_get_Security_
2582 };
2583
2584 static HRESULT SWbemServices_create( IWbemServices *wbem_services, ISWbemServices **obj )
2585 {
2586 struct services *services;
2587
2588 TRACE( "%p, %p\n", obj, wbem_services );
2589
2590 if (!(services = heap_alloc( sizeof(*services) ))) return E_OUTOFMEMORY;
2591 services->ISWbemServices_iface.lpVtbl = &services_vtbl;
2592 services->refs = 1;
2593 services->services = wbem_services;
2594 IWbemServices_AddRef( services->services );
2595
2596 *obj = &services->ISWbemServices_iface;
2597 TRACE( "returning iface %p\n", *obj );
2598 return S_OK;
2599 }
2600
2601 struct locator
2602 {
2603 ISWbemLocator ISWbemLocator_iface;
2604 LONG refs;
2605 IWbemLocator *locator;
2606 };
2607
2608 static inline struct locator *impl_from_ISWbemLocator( ISWbemLocator *iface )
2609 {
2610 return CONTAINING_RECORD( iface, struct locator, ISWbemLocator_iface );
2611 }
2612
2613 static ULONG WINAPI locator_AddRef(
2614 ISWbemLocator *iface )
2615 {
2616 struct locator *locator = impl_from_ISWbemLocator( iface );
2617 return InterlockedIncrement( &locator->refs );
2618 }
2619
2620 static ULONG WINAPI locator_Release(
2621 ISWbemLocator *iface )
2622 {
2623 struct locator *locator = impl_from_ISWbemLocator( iface );
2624 LONG refs = InterlockedDecrement( &locator->refs );
2625 if (!refs)
2626 {
2627 TRACE( "destroying %p\n", locator );
2628 if (locator->locator)
2629 IWbemLocator_Release( locator->locator );
2630 heap_free( locator );
2631 }
2632 return refs;
2633 }
2634
2635 static HRESULT WINAPI locator_QueryInterface(
2636 ISWbemLocator *iface,
2637 REFIID riid,
2638 void **ppvObject )
2639 {
2640 struct locator *locator = impl_from_ISWbemLocator( iface );
2641
2642 TRACE( "%p, %s, %p\n", locator, debugstr_guid( riid ), ppvObject );
2643
2644 if (IsEqualGUID( riid, &IID_ISWbemLocator ) ||
2645 IsEqualGUID( riid, &IID_IDispatch ) ||
2646 IsEqualGUID( riid, &IID_IUnknown ))
2647 {
2648 *ppvObject = iface;
2649 }
2650 else
2651 {
2652 WARN( "interface %s not implemented\n", debugstr_guid(riid) );
2653 return E_NOINTERFACE;
2654 }
2655 ISWbemLocator_AddRef( iface );
2656 return S_OK;
2657 }
2658
2659 static HRESULT WINAPI locator_GetTypeInfoCount(
2660 ISWbemLocator *iface,
2661 UINT *count )
2662 {
2663 struct locator *locator = impl_from_ISWbemLocator( iface );
2664
2665 TRACE( "%p, %p\n", locator, count );
2666 *count = 1;
2667 return S_OK;
2668 }
2669
2670 static HRESULT WINAPI locator_GetTypeInfo(
2671 ISWbemLocator *iface,
2672 UINT index,
2673 LCID lcid,
2674 ITypeInfo **info )
2675 {
2676 struct locator *locator = impl_from_ISWbemLocator( iface );
2677 TRACE( "%p, %u, %u, %p\n", locator, index, lcid, info );
2678
2679 return get_typeinfo( ISWbemLocator_tid, info );
2680 }
2681
2682 static HRESULT WINAPI locator_GetIDsOfNames(
2683 ISWbemLocator *iface,
2684 REFIID riid,
2685 LPOLESTR *names,
2686 UINT count,
2687 LCID lcid,
2688 DISPID *dispid )
2689 {
2690 struct locator *locator = impl_from_ISWbemLocator( iface );
2691 ITypeInfo *typeinfo;
2692 HRESULT hr;
2693
2694 TRACE( "%p, %s, %p, %u, %u, %p\n", locator, debugstr_guid(riid), names, count, lcid, dispid );
2695
2696 if (!names || !count || !dispid) return E_INVALIDARG;
2697
2698 hr = get_typeinfo( ISWbemLocator_tid, &typeinfo );
2699 if (SUCCEEDED(hr))
2700 {
2701 hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
2702 ITypeInfo_Release( typeinfo );
2703 }
2704 return hr;
2705 }
2706
2707 static HRESULT WINAPI locator_Invoke(
2708 ISWbemLocator *iface,
2709 DISPID member,
2710 REFIID riid,
2711 LCID lcid,
2712 WORD flags,
2713 DISPPARAMS *params,
2714 VARIANT *result,
2715 EXCEPINFO *excep_info,
2716 UINT *arg_err )
2717 {
2718 struct locator *locator = impl_from_ISWbemLocator( iface );
2719 ITypeInfo *typeinfo;
2720 HRESULT hr;
2721
2722 TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", locator, member, debugstr_guid(riid),
2723 lcid, flags, params, result, excep_info, arg_err );
2724
2725 hr = get_typeinfo( ISWbemLocator_tid, &typeinfo );
2726 if (SUCCEEDED(hr))
2727 {
2728 hr = ITypeInfo_Invoke( typeinfo, &locator->ISWbemLocator_iface, member, flags,
2729 params, result, excep_info, arg_err );
2730 ITypeInfo_Release( typeinfo );
2731 }
2732 return hr;
2733 }
2734
2735 static BSTR build_resource_string( BSTR server, BSTR namespace )
2736 {
2737 ULONG len, len_server = 0, len_namespace = 0;
2738 BSTR ret;
2739
2740 if (server && *server) len_server = lstrlenW( server );
2741 else len_server = 1;
2742 if (namespace && *namespace) len_namespace = lstrlenW( namespace );
2743 else len_namespace = ARRAY_SIZE(L"root\\default") - 1;
2744
2745 if (!(ret = SysAllocStringLen( NULL, 2 + len_server + 1 + len_namespace ))) return NULL;
2746
2747 ret[0] = ret[1] = '\\';
2748 if (server && *server) lstrcpyW( ret + 2, server );
2749 else ret[2] = '.';
2750
2751 len = len_server + 2;
2752 ret[len++] = '\\';
2753
2754 if (namespace && *namespace) lstrcpyW( ret + len, namespace );
2755 else lstrcpyW( ret + len, L"root\\default" );
2756 return ret;
2757 }
2758
2759 static HRESULT WINAPI locator_ConnectServer(
2760 ISWbemLocator *iface,
2761 BSTR strServer,
2762 BSTR strNamespace,
2763 BSTR strUser,
2764 BSTR strPassword,
2765 BSTR strLocale,
2766 BSTR strAuthority,
2767 LONG iSecurityFlags,
2768 IDispatch *objWbemNamedValueSet,
2769 ISWbemServices **objWbemServices )
2770 {
2771 struct locator *locator = impl_from_ISWbemLocator( iface );
2772 IWbemServices *services;
2773 IWbemContext *context;
2774 BSTR resource;
2775 HRESULT hr;
2776
2777 TRACE( "%p, %s, %s, %s, %p, %s, %s, 0x%08x, %p, %p\n", iface, debugstr_w(strServer),
2778 debugstr_w(strNamespace), debugstr_w(strUser), strPassword, debugstr_w(strLocale),
2779 debugstr_w(strAuthority), iSecurityFlags, objWbemNamedValueSet, objWbemServices );
2780
2781 if (!locator->locator)
2782 {
2783 hr = CoCreateInstance( &CLSID_WbemLocator, NULL, CLSCTX_INPROC_SERVER, &IID_IWbemLocator,
2784 (void **)&locator->locator );
2785 if (hr != S_OK) return hr;
2786 }
2787
2788 context = unsafe_get_context_from_namedvalueset( objWbemNamedValueSet );
2789
2790 if (!(resource = build_resource_string( strServer, strNamespace ))) return E_OUTOFMEMORY;
2791 hr = IWbemLocator_ConnectServer( locator->locator, resource, strUser, strPassword, strLocale,
2792 iSecurityFlags, strAuthority, context, &services );
2793 SysFreeString( resource );
2794 if (hr != S_OK) return hr;
2795
2796 hr = SWbemServices_create( services, objWbemServices );
2797 IWbemServices_Release( services );
2798 return hr;
2799 }
2800
2801 static HRESULT WINAPI locator_get_Security_(
2802 ISWbemLocator *iface,
2803 ISWbemSecurity **objWbemSecurity )
2804 {
2805 TRACE( "%p, %p\n", iface, objWbemSecurity );
2806
2807 if (!objWbemSecurity)
2808 return E_INVALIDARG;
2809
2810 return ISWbemSecurity_create( objWbemSecurity );
2811 }
2812
2813 static const ISWbemLocatorVtbl locator_vtbl =
2814 {
2815 locator_QueryInterface,
2816 locator_AddRef,
2817 locator_Release,
2818 locator_GetTypeInfoCount,
2819 locator_GetTypeInfo,
2820 locator_GetIDsOfNames,
2821 locator_Invoke,
2822 locator_ConnectServer,
2823 locator_get_Security_
2824 };
2825
2826 HRESULT SWbemLocator_create( void **obj )
2827 {
2828 struct locator *locator;
2829
2830 TRACE( "%p\n", obj );
2831
2832 if (!(locator = heap_alloc( sizeof(*locator) ))) return E_OUTOFMEMORY;
2833 locator->ISWbemLocator_iface.lpVtbl = &locator_vtbl;
2834 locator->refs = 1;
2835 locator->locator = NULL;
2836
2837 *obj = &locator->ISWbemLocator_iface;
2838 TRACE( "returning iface %p\n", *obj );
2839 return S_OK;
2840 }
2841
2842 struct security
2843 {
2844 ISWbemSecurity ISWbemSecurity_iface;
2845 LONG refs;
2846 WbemImpersonationLevelEnum implevel;
2847 WbemAuthenticationLevelEnum authlevel;
2848 };
2849
2850 static inline struct security *impl_from_ISWbemSecurity( ISWbemSecurity *iface )
2851 {
2852 return CONTAINING_RECORD( iface, struct security, ISWbemSecurity_iface );
2853 }
2854
2855 static ULONG WINAPI security_AddRef(
2856 ISWbemSecurity *iface )
2857 {
2858 struct security *security = impl_from_ISWbemSecurity( iface );
2859 return InterlockedIncrement( &security->refs );
2860 }
2861
2862 static ULONG WINAPI security_Release(
2863 ISWbemSecurity *iface )
2864 {
2865 struct security *security = impl_from_ISWbemSecurity( iface );
2866 LONG refs = InterlockedDecrement( &security->refs );
2867 if (!refs)
2868 {
2869 TRACE( "destroying %p\n", security );
2870 heap_free( security );
2871 }
2872 return refs;
2873 }
2874
2875 static HRESULT WINAPI security_QueryInterface(
2876 ISWbemSecurity *iface,
2877 REFIID riid,
2878 void **ppvObject )
2879 {
2880 struct security *security = impl_from_ISWbemSecurity( iface );
2881 TRACE( "%p, %s, %p\n", security, debugstr_guid( riid ), ppvObject );
2882
2883 if (IsEqualGUID( riid, &IID_ISWbemSecurity ) ||
2884 IsEqualGUID( riid, &IID_IDispatch ) ||
2885 IsEqualGUID( riid, &IID_IUnknown ))
2886 {
2887 *ppvObject = iface;
2888 }
2889 else
2890 {
2891 WARN( "interface %s not implemented\n", debugstr_guid(riid) );
2892 return E_NOINTERFACE;
2893 }
2894 ISWbemSecurity_AddRef( iface );
2895 return S_OK;
2896 }
2897
2898 static HRESULT WINAPI security_GetTypeInfoCount(
2899 ISWbemSecurity *iface,
2900 UINT *count )
2901 {
2902 struct security *security = impl_from_ISWbemSecurity( iface );
2903 TRACE( "%p, %p\n", security, count );
2904
2905 *count = 1;
2906 return S_OK;
2907 }
2908
2909 static HRESULT WINAPI security_GetTypeInfo(
2910 ISWbemSecurity *iface,
2911 UINT index,
2912 LCID lcid,
2913 ITypeInfo **info )
2914 {
2915 struct security *security = impl_from_ISWbemSecurity( iface );
2916 TRACE( "%p, %u, %u, %p\n", security, index, lcid, info );
2917
2918 return get_typeinfo( ISWbemSecurity_tid, info );
2919 }
2920
2921 static HRESULT WINAPI security_GetIDsOfNames(
2922 ISWbemSecurity *iface,
2923 REFIID riid,
2924 LPOLESTR *names,
2925 UINT count,
2926 LCID lcid,
2927 DISPID *dispid )
2928 {
2929 struct security *security = impl_from_ISWbemSecurity( iface );
2930 ITypeInfo *typeinfo;
2931 HRESULT hr;
2932
2933 TRACE( "%p, %s, %p, %u, %u, %p\n", security, debugstr_guid(riid), names, count, lcid, dispid );
2934
2935 if (!names || !count || !dispid) return E_INVALIDARG;
2936
2937 hr = get_typeinfo( ISWbemSecurity_tid, &typeinfo );
2938 if (SUCCEEDED(hr))
2939 {
2940 hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
2941 ITypeInfo_Release( typeinfo );
2942 }
2943 return hr;
2944 }
2945
2946 static HRESULT WINAPI security_Invoke(
2947 ISWbemSecurity *iface,
2948 DISPID member,
2949 REFIID riid,
2950 LCID lcid,
2951 WORD flags,
2952 DISPPARAMS *params,
2953 VARIANT *result,
2954 EXCEPINFO *excep_info,
2955 UINT *arg_err )
2956 {
2957 struct security *security = impl_from_ISWbemSecurity( iface );
2958 ITypeInfo *typeinfo;
2959 HRESULT hr;
2960
2961 TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", security, member, debugstr_guid(riid),
2962 lcid, flags, params, result, excep_info, arg_err );
2963
2964 hr = get_typeinfo( ISWbemSecurity_tid, &typeinfo );
2965 if (SUCCEEDED(hr))
2966 {
2967 hr = ITypeInfo_Invoke( typeinfo, &security->ISWbemSecurity_iface, member, flags,
2968 params, result, excep_info, arg_err );
2969 ITypeInfo_Release( typeinfo );
2970 }
2971 return hr;
2972 }
2973
2974 static HRESULT WINAPI security_get_ImpersonationLevel(
2975 ISWbemSecurity *iface,
2976 WbemImpersonationLevelEnum *impersonation_level )
2977 {
2978 struct security *security = impl_from_ISWbemSecurity( iface );
2979 FIXME( "%p, %p: stub\n", security, impersonation_level );
2980
2981 if (!impersonation_level)
2982 return E_INVALIDARG;
2983
2984 *impersonation_level = security->implevel;
2985 return S_OK;
2986 }
2987
2988 static HRESULT WINAPI security_put_ImpersonationLevel(
2989 ISWbemSecurity *iface,
2990 WbemImpersonationLevelEnum impersonation_level )
2991 {
2992 struct security *security = impl_from_ISWbemSecurity( iface );
2993 FIXME( "%p, %d: stub\n", security, impersonation_level );
2994
2995 security->implevel = impersonation_level;
2996 return S_OK;
2997 }
2998
2999 static HRESULT WINAPI security_get_AuthenticationLevel(
3000 ISWbemSecurity *iface,
3001 WbemAuthenticationLevelEnum *authentication_level )
3002 {
3003 struct security *security = impl_from_ISWbemSecurity( iface );
3004 FIXME( "%p, %p: stub\n", security, authentication_level );
3005
3006 if (!authentication_level)
3007 return E_INVALIDARG;
3008
3009 *authentication_level = security->authlevel;
3010 return S_OK;
3011 }
3012
3013 static HRESULT WINAPI security_put_AuthenticationLevel(
3014 ISWbemSecurity *iface,
3015 WbemAuthenticationLevelEnum authentication_level )
3016 {
3017 struct security *security = impl_from_ISWbemSecurity( iface );
3018 FIXME( "%p, %d: stub\n", security, authentication_level );
3019
3020 security->authlevel = authentication_level;
3021 return S_OK;
3022 }
3023
3024 static HRESULT WINAPI security_get_Privileges(
3025 ISWbemSecurity *iface,
3026 ISWbemPrivilegeSet **privilege_set )
3027 {
3028 struct security *security = impl_from_ISWbemSecurity( iface );
3029 FIXME( "%p, %p: stub\n", security, privilege_set );
3030
3031 if (!privilege_set)
3032 return E_INVALIDARG;
3033
3034 return E_NOTIMPL;
3035 }
3036
3037 static const ISWbemSecurityVtbl security_vtbl =
3038 {
3039 security_QueryInterface,
3040 security_AddRef,
3041 security_Release,
3042 security_GetTypeInfoCount,
3043 security_GetTypeInfo,
3044 security_GetIDsOfNames,
3045 security_Invoke,
3046 security_get_ImpersonationLevel,
3047 security_put_ImpersonationLevel,
3048 security_get_AuthenticationLevel,
3049 security_put_AuthenticationLevel,
3050 security_get_Privileges
3051 };
3052
3053 static HRESULT ISWbemSecurity_create( ISWbemSecurity **obj )
3054 {
3055 struct security *security;
3056
3057 TRACE( "%p\n", obj );
3058
3059 if (!(security = heap_alloc( sizeof(*security) ))) return E_OUTOFMEMORY;
3060 security->ISWbemSecurity_iface.lpVtbl = &security_vtbl;
3061 security->refs = 1;
3062 security->implevel = wbemImpersonationLevelImpersonate;
3063 security->authlevel = wbemAuthenticationLevelPktPrivacy;
3064
3065 *obj = &security->ISWbemSecurity_iface;
3066 TRACE( "returning iface %p\n", *obj );
3067 return S_OK;
3068 }
3069
3070 struct namedvalue
3071 {
3072 ISWbemNamedValue ISWbemNamedValue_iface;
3073 LONG refs;
3074 };
3075
3076 static struct namedvalueset *impl_from_ISWbemNamedValueSet( ISWbemNamedValueSet *iface )
3077 {
3078 return CONTAINING_RECORD( iface, struct namedvalueset, ISWbemNamedValueSet_iface );
3079 }
3080
3081 static struct namedvalue *impl_from_ISWbemNamedValue( ISWbemNamedValue *iface )
3082 {
3083 return CONTAINING_RECORD( iface, struct namedvalue, ISWbemNamedValue_iface );
3084 }
3085
3086 static HRESULT WINAPI namedvalue_QueryInterface(
3087 ISWbemNamedValue *iface,
3088 REFIID riid,
3089 void **ppvObject )
3090 {
3091 struct namedvalue *value = impl_from_ISWbemNamedValue( iface );
3092
3093 TRACE( "%p, %s, %p\n", value, debugstr_guid( riid ), ppvObject );
3094
3095 if (IsEqualGUID( riid, &IID_ISWbemNamedValue ) ||
3096 IsEqualGUID( riid, &IID_IDispatch ) ||
3097 IsEqualGUID( riid, &IID_IUnknown ))
3098 {
3099 *ppvObject = iface;
3100 }
3101 else
3102 {
3103 WARN( "interface %s not implemented\n", debugstr_guid(riid) );
3104 return E_NOINTERFACE;
3105 }
3106 ISWbemNamedValue_AddRef( iface );
3107 return S_OK;
3108 }
3109
3110 static ULONG WINAPI namedvalue_AddRef(
3111 ISWbemNamedValue *iface )
3112 {
3113 struct namedvalue *value = impl_from_ISWbemNamedValue( iface );
3114 return InterlockedIncrement( &value->refs );
3115 }
3116
3117 static ULONG WINAPI namedvalue_Release(
3118 ISWbemNamedValue *iface )
3119 {
3120 struct namedvalue *value = impl_from_ISWbemNamedValue( iface );
3121 LONG refs = InterlockedDecrement( &value->refs );
3122 if (!refs)
3123 {
3124 TRACE( "destroying %p\n", value );
3125 heap_free( value );
3126 }
3127 return refs;
3128 }
3129
3130 static HRESULT WINAPI namedvalue_GetTypeInfoCount(
3131 ISWbemNamedValue *iface,
3132 UINT *count )
3133 {
3134 struct namedvalue *value = impl_from_ISWbemNamedValue( iface );
3135 TRACE( "%p, %p\n", value, count );
3136
3137 *count = 1;
3138 return S_OK;
3139 }
3140
3141 static HRESULT WINAPI namedvalue_GetTypeInfo(
3142 ISWbemNamedValue *iface,
3143 UINT index,
3144 LCID lcid,
3145 ITypeInfo **info )
3146 {
3147 struct namedvalue *value = impl_from_ISWbemNamedValue( iface );
3148
3149 TRACE( "%p, %u, %u, %p\n", value, index, lcid, info );
3150
3151 return get_typeinfo( ISWbemNamedValue_tid, info );
3152 }
3153
3154 static HRESULT WINAPI namedvalue_GetIDsOfNames(
3155 ISWbemNamedValue *iface,
3156 REFIID riid,
3157 LPOLESTR *names,
3158 UINT count,
3159 LCID lcid,
3160 DISPID *dispid )
3161 {
3162 struct namedvalue *value = impl_from_ISWbemNamedValue( iface );
3163 ITypeInfo *typeinfo;
3164 HRESULT hr;
3165
3166 TRACE( "%p, %s, %p, %u, %u, %p\n", value, debugstr_guid(riid), names, count, lcid, dispid );
3167
3168 if (!names || !count || !dispid) return E_INVALIDARG;
3169
3170 hr = get_typeinfo( ISWbemNamedValue_tid, &typeinfo );
3171 if (SUCCEEDED(hr))
3172 {
3173 hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
3174 ITypeInfo_Release( typeinfo );
3175 }
3176 return hr;
3177 }
3178
3179 static HRESULT WINAPI namedvalue_Invoke(
3180 ISWbemNamedValue *iface,
3181 DISPID member,
3182 REFIID riid,
3183 LCID lcid,
3184 WORD flags,
3185 DISPPARAMS *params,
3186 VARIANT *result,
3187 EXCEPINFO *excep_info,
3188 UINT *arg_err )
3189 {
3190 struct namedvalue *set = impl_from_ISWbemNamedValue( iface );
3191 ITypeInfo *typeinfo;
3192 HRESULT hr;
3193
3194 TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", set, member, debugstr_guid(riid),
3195 lcid, flags, params, result, excep_info, arg_err );
3196
3197 hr = get_typeinfo( ISWbemNamedValue_tid, &typeinfo );
3198 if (SUCCEEDED(hr))
3199 {
3200 hr = ITypeInfo_Invoke( typeinfo, &set->ISWbemNamedValue_iface, member, flags,
3201 params, result, excep_info, arg_err );
3202 ITypeInfo_Release( typeinfo );
3203 }
3204 return hr;
3205 }
3206
3207 static HRESULT WINAPI namedvalue_get_Value(
3208 ISWbemNamedValue *iface,
3209 VARIANT *var )
3210 {
3211 FIXME("\n");
3212
3213 return E_NOTIMPL;
3214 }
3215
3216 static HRESULT WINAPI namedvalue_put_Value(
3217 ISWbemNamedValue *iface,
3218 VARIANT *var )
3219 {
3220 FIXME("\n");
3221
3222 return E_NOTIMPL;
3223 }
3224
3225 static HRESULT WINAPI namedvalue_get_Name(
3226 ISWbemNamedValue *iface,
3227 BSTR *name )
3228 {
3229 FIXME("\n");
3230
3231 return E_NOTIMPL;
3232 }
3233
3234 static const ISWbemNamedValueVtbl namedvaluevtbl =
3235 {
3236 namedvalue_QueryInterface,
3237 namedvalue_AddRef,
3238 namedvalue_Release,
3239 namedvalue_GetTypeInfoCount,
3240 namedvalue_GetTypeInfo,
3241 namedvalue_GetIDsOfNames,
3242 namedvalue_Invoke,
3243 namedvalue_get_Value,
3244 namedvalue_put_Value,
3245 namedvalue_get_Name
3246 };
3247
3248 static HRESULT namedvalue_create( ISWbemNamedValue **value )
3249 {
3250 struct namedvalue *object;
3251
3252 if (!(object = heap_alloc(sizeof(*object))))
3253 return E_OUTOFMEMORY;
3254
3255 object->ISWbemNamedValue_iface.lpVtbl = &namedvaluevtbl;
3256 object->refs = 1;
3257
3258 *value = &object->ISWbemNamedValue_iface;
3259
3260 return S_OK;
3261 }
3262
3263 static HRESULT WINAPI namedvalueset_QueryInterface(
3264 ISWbemNamedValueSet *iface,
3265 REFIID riid,
3266 void **ppvObject )
3267 {
3268 struct namedvalueset *set = impl_from_ISWbemNamedValueSet( iface );
3269
3270 TRACE( "%p, %s, %p\n", set, debugstr_guid( riid ), ppvObject );
3271
3272 if (IsEqualGUID( riid, &IID_ISWbemNamedValueSet ) ||
3273 IsEqualGUID( riid, &IID_IDispatch ) ||
3274 IsEqualGUID( riid, &IID_IUnknown ))
3275 {
3276 *ppvObject = iface;
3277 }
3278 else
3279 {
3280 WARN( "interface %s not implemented\n", debugstr_guid(riid) );
3281 return E_NOINTERFACE;
3282 }
3283 ISWbemNamedValueSet_AddRef( iface );
3284 return S_OK;
3285 }
3286
3287 static ULONG WINAPI namedvalueset_AddRef(
3288 ISWbemNamedValueSet *iface )
3289 {
3290 struct namedvalueset *set = impl_from_ISWbemNamedValueSet( iface );
3291 return InterlockedIncrement( &set->refs );
3292 }
3293
3294 static ULONG WINAPI namedvalueset_Release(
3295 ISWbemNamedValueSet *iface )
3296 {
3297 struct namedvalueset *set = impl_from_ISWbemNamedValueSet( iface );
3298 LONG refs = InterlockedDecrement( &set->refs );
3299 if (!refs)
3300 {
3301 TRACE( "destroying %p\n", set );
3302 if (set->context)
3303 IWbemContext_Release( set->context );
3304 heap_free( set );
3305 }
3306 return refs;
3307 }
3308
3309 static HRESULT WINAPI namedvalueset_GetTypeInfoCount(
3310 ISWbemNamedValueSet *iface,
3311 UINT *count )
3312 {
3313 struct namedvalueset *set = impl_from_ISWbemNamedValueSet( iface );
3314 TRACE( "%p, %p\n", set, count );
3315
3316 *count = 1;
3317 return S_OK;
3318 }
3319
3320 static HRESULT WINAPI namedvalueset_GetTypeInfo(
3321 ISWbemNamedValueSet *iface,
3322 UINT index,
3323 LCID lcid,
3324 ITypeInfo **info )
3325 {
3326 struct namedvalueset *set = impl_from_ISWbemNamedValueSet( iface );
3327
3328 TRACE( "%p, %u, %u, %p\n", set, index, lcid, info );
3329
3330 return get_typeinfo( ISWbemNamedValueSet_tid, info );
3331 }
3332
3333 static HRESULT WINAPI namedvalueset_GetIDsOfNames(
3334 ISWbemNamedValueSet *iface,
3335 REFIID riid,
3336 LPOLESTR *names,
3337 UINT count,
3338 LCID lcid,
3339 DISPID *dispid )
3340 {
3341 struct namedvalueset *set = impl_from_ISWbemNamedValueSet( iface );
3342 ITypeInfo *typeinfo;
3343 HRESULT hr;
3344
3345 TRACE( "%p, %s, %p, %u, %u, %p\n", set, debugstr_guid(riid), names, count, lcid, dispid );
3346
3347 if (!names || !count || !dispid) return E_INVALIDARG;
3348
3349 hr = get_typeinfo( ISWbemNamedValueSet_tid, &typeinfo );
3350 if (SUCCEEDED(hr))
3351 {
3352 hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
3353 ITypeInfo_Release( typeinfo );
3354 }
3355 return hr;
3356 }
3357
3358 static HRESULT WINAPI namedvalueset_Invoke(
3359 ISWbemNamedValueSet *iface,
3360 DISPID member,
3361 REFIID riid,
3362 LCID lcid,
3363 WORD flags,
3364 DISPPARAMS *params,
3365 VARIANT *result,
3366 EXCEPINFO *excep_info,
3367 UINT *arg_err )
3368 {
3369 struct namedvalueset *set = impl_from_ISWbemNamedValueSet( iface );
3370 ITypeInfo *typeinfo;
3371 HRESULT hr;
3372
3373 TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", set, member, debugstr_guid(riid),
3374 lcid, flags, params, result, excep_info, arg_err );
3375
3376 hr = get_typeinfo( ISWbemNamedValueSet_tid, &typeinfo );
3377 if (SUCCEEDED(hr))
3378 {
3379 hr = ITypeInfo_Invoke( typeinfo, &set->ISWbemNamedValueSet_iface, member, flags,
3380 params, result, excep_info, arg_err );
3381 ITypeInfo_Release( typeinfo );
3382 }
3383 return hr;
3384 }
3385
3386 static HRESULT WINAPI namedvalueset_get__NewEnum(
3387 ISWbemNamedValueSet *iface,
3388 IUnknown **unk )
3389 {
3390 FIXME("\n");
3391
3392 return E_NOTIMPL;
3393 }
3394
3395 static HRESULT WINAPI namedvalueset_Item(
3396 ISWbemNamedValueSet *iface,
3397 BSTR name,
3398 LONG flags,
3399 ISWbemNamedValue **value )
3400 {
3401 struct namedvalueset *set = impl_from_ISWbemNamedValueSet( iface );
3402 VARIANT var;
3403 HRESULT hr;
3404
3405 TRACE("%p, %s, %#x, %p\n", set, debugstr_w(name), flags, value);
3406
3407 if (SUCCEEDED(hr = IWbemContext_GetValue( set->context, name, flags, &var )))
3408 {
3409 VariantClear( &var );
3410 hr = namedvalue_create( value );
3411 }
3412
3413 return hr;
3414 }
3415
3416 static HRESULT WINAPI namedvalueset_get_Count(
3417 ISWbemNamedValueSet *iface,
3418 LONG *count )
3419 {
3420 FIXME("\n");
3421
3422 return E_NOTIMPL;
3423 }
3424
3425 static HRESULT WINAPI namedvalueset_Add(
3426 ISWbemNamedValueSet *iface,
3427 BSTR name,
3428 VARIANT *var,
3429 LONG flags,
3430 ISWbemNamedValue **value )
3431 {
3432 struct namedvalueset *set = impl_from_ISWbemNamedValueSet( iface );
3433 HRESULT hr;
3434
3435 TRACE("%p, %s, %s, %#x, %p\n", set, debugstr_w(name), debugstr_variant(var), flags, value);
3436
3437 if (!name || !var || !value)
3438 return WBEM_E_INVALID_PARAMETER;
3439
3440 if (SUCCEEDED(hr = IWbemContext_SetValue( set->context, name, flags, var )))
3441 {
3442 hr = namedvalue_create( value );
3443 }
3444
3445 return hr;
3446 }
3447
3448 static HRESULT WINAPI namedvalueset_Remove(
3449 ISWbemNamedValueSet *iface,
3450 BSTR name,
3451 LONG flags )
3452 {
3453 struct namedvalueset *set = impl_from_ISWbemNamedValueSet( iface );
3454
3455 TRACE("%p, %s, %#x\n", set, debugstr_w(name), flags);
3456
3457 return IWbemContext_DeleteValue( set->context, name, flags );
3458 }
3459
3460 static HRESULT WINAPI namedvalueset_Clone(
3461 ISWbemNamedValueSet *iface,
3462 ISWbemNamedValueSet **valueset )
3463 {
3464 FIXME("\n");
3465
3466 return E_NOTIMPL;
3467 }
3468
3469 static HRESULT WINAPI namedvalueset_DeleteAll(
3470 ISWbemNamedValueSet *iface )
3471 {
3472 struct namedvalueset *set = impl_from_ISWbemNamedValueSet( iface );
3473
3474 TRACE("%p\n", set);
3475
3476 return IWbemContext_DeleteAll( set->context );
3477 }
3478
3479 static const ISWbemNamedValueSetVtbl namedvalueset_vtbl =
3480 {
3481 namedvalueset_QueryInterface,
3482 namedvalueset_AddRef,
3483 namedvalueset_Release,
3484 namedvalueset_GetTypeInfoCount,
3485 namedvalueset_GetTypeInfo,
3486 namedvalueset_GetIDsOfNames,
3487 namedvalueset_Invoke,
3488 namedvalueset_get__NewEnum,
3489 namedvalueset_Item,
3490 namedvalueset_get_Count,
3491 namedvalueset_Add,
3492 namedvalueset_Remove,
3493 namedvalueset_Clone,
3494 namedvalueset_DeleteAll,
3495 };
3496
3497 static struct namedvalueset *unsafe_valueset_impl_from_IDispatch(IDispatch *iface)
3498 {
3499 if (!iface)
3500 return NULL;
3501 if (iface->lpVtbl != (IDispatchVtbl *)&namedvalueset_vtbl)
3502 {
3503 FIXME( "External implementations are not supported.\n" );
3504 return NULL;
3505 }
3506 return CONTAINING_RECORD(iface, struct namedvalueset, ISWbemNamedValueSet_iface);
3507 }
3508
3509 HRESULT SWbemNamedValueSet_create( void **obj )
3510 {
3511 struct namedvalueset *set;
3512 HRESULT hr;
3513
3514 TRACE( "%p\n", obj );
3515
3516 if (!(set = heap_alloc_zero( sizeof(*set) ))) return E_OUTOFMEMORY;
3517 set->ISWbemNamedValueSet_iface.lpVtbl = &namedvalueset_vtbl;
3518 set->refs = 1;
3519
3520 if (FAILED(hr = CoCreateInstance( &CLSID_WbemContext, NULL, CLSCTX_INPROC_SERVER, &IID_IWbemContext,
3521 (void **)&set->context )))
3522 {
3523 ISWbemNamedValueSet_Release( &set->ISWbemNamedValueSet_iface );
3524 return hr;
3525 }
3526
3527 *obj = &set->ISWbemNamedValueSet_iface;
3528 TRACE( "returning iface %p\n", *obj );
3529 return hr;
3530 }
Windows API implementation