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