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