dlls/wbemdisp/locator.c

   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 "config.h"
  22 #include <stdarg.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "initguid.h"
  27 #include "objbase.h"
  28 #include "wmiutils.h"
  29 #include "wbemcli.h"
  30 #include "wbemdisp.h"
  31
  32 #include "wine/debug.h"
  33 #include "wine/heap.h"
  34 #include "wine/unicode.h"
  35 #include "wbemdisp_private.h"
  36 #include "wbemdisp_classes.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(wbemdisp);
  39
  40 static HRESULT EnumVARIANT_create( IEnumWbemClassObject *, IEnumVARIANT ** );
  41
  42 enum type_id
  43 {
  44     ISWbemLocator_tid,
  45     ISWbemObject_tid,
  46     ISWbemObjectSet_tid,
  47     ISWbemProperty_tid,
  48     ISWbemPropertySet_tid,
  49     ISWbemServices_tid,
  50     last_tid
  51 };
  52
  53 static ITypeLib *wbemdisp_typelib;
  54 static ITypeInfo *wbemdisp_typeinfo[last_tid];
  55
  56 static REFIID wbemdisp_tid_id[] =
  57 {
  58     &IID_ISWbemLocator,
  59     &IID_ISWbemObject,
  60     &IID_ISWbemObjectSet,
  61     &IID_ISWbemProperty,
  62     &IID_ISWbemPropertySet,
  63     &IID_ISWbemServices
  64 };
  65
  66 static HRESULT get_typeinfo( enum type_id tid, ITypeInfo **ret )
  67 {
  68     HRESULT hr;
  69
  70     if (!wbemdisp_typelib)
  71     {
  72         ITypeLib *typelib;
  73
  74         hr = LoadRegTypeLib( &LIBID_WbemScripting, 1, 2, LOCALE_SYSTEM_DEFAULT, &typelib );
  75         if (FAILED( hr ))
  76         {
  77             ERR( "LoadRegTypeLib failed: %08x\n", hr );
  78             return hr;
  79         }
  80         if (InterlockedCompareExchangePointer( (void **)&wbemdisp_typelib, typelib, NULL ))
  81             ITypeLib_Release( typelib );
  82     }
  83     if (!wbemdisp_typeinfo[tid])
  84     {
  85         ITypeInfo *typeinfo;
  86
  87         hr = ITypeLib_GetTypeInfoOfGuid( wbemdisp_typelib, wbemdisp_tid_id[tid], &typeinfo );
  88         if (FAILED( hr ))
  89         {
  90             ERR( "GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_guid(wbemdisp_tid_id[tid]), hr );
  91             return hr;
  92         }
  93         if (InterlockedCompareExchangePointer( (void **)(wbemdisp_typeinfo + tid), typeinfo, NULL ))
  94             ITypeInfo_Release( typeinfo );
  95     }
  96     *ret = wbemdisp_typeinfo[tid];
  97     ITypeInfo_AddRef( *ret );
  98     return S_OK;
  99 }
 100
 101 struct property
 102 {
 103     ISWbemProperty ISWbemProperty_iface;
 104     LONG refs;
 105     IWbemClassObject *object;
 106     BSTR name;
 107 };
 108
 109 static inline struct property *impl_from_ISWbemProperty( ISWbemProperty *iface )
 110 {
 111     return CONTAINING_RECORD( iface, struct property, ISWbemProperty_iface );
 112 }
 113
 114 static ULONG WINAPI property_AddRef( ISWbemProperty *iface )
 115 {
 116     struct property *property = impl_from_ISWbemProperty( iface );
 117     return InterlockedIncrement( &property->refs );
 118 }
 119
 120 static ULONG WINAPI property_Release( ISWbemProperty *iface )
 121 {
 122     struct property *property = impl_from_ISWbemProperty( iface );
 123     LONG refs = InterlockedDecrement( &property->refs );
 124     if (!refs)
 125     {
 126         TRACE( "destroying %p\n", property );
 127         IWbemClassObject_Release( property->object );
 128         SysFreeString( property->name );
 129         heap_free( property );
 130     }
 131     return refs;
 132 }
 133
 134 static HRESULT WINAPI property_QueryInterface( ISWbemProperty *iface, REFIID riid, void **obj )
 135 {
 136     struct property *property = impl_from_ISWbemProperty( iface );
 137
 138     TRACE( "%p %s %p\n", property, debugstr_guid(riid), obj );
 139
 140     if (IsEqualGUID( riid, &IID_ISWbemProperty ) ||
 141         IsEqualGUID( riid, &IID_IDispatch ) ||
 142         IsEqualGUID( riid, &IID_IUnknown ))
 143     {
 144         *obj = iface;
 145     }
 146     else
 147     {
 148         FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
 149         return E_NOINTERFACE;
 150     }
 151     ISWbemProperty_AddRef( iface );
 152     return S_OK;
 153 }
 154
 155 static HRESULT WINAPI property_GetTypeInfoCount( ISWbemProperty *iface, UINT *count )
 156 {
 157     struct property *property = impl_from_ISWbemProperty( iface );
 158     TRACE( "%p, %p\n", property, count );
 159     *count = 1;
 160     return S_OK;
 161 }
 162
 163 static HRESULT WINAPI property_GetTypeInfo( ISWbemProperty *iface, UINT index,
 164                                             LCID lcid, ITypeInfo **info )
 165 {
 166     struct property *property = impl_from_ISWbemProperty( iface );
 167     TRACE( "%p, %u, %u, %p\n", property, index, lcid, info );
 168
 169     return get_typeinfo( ISWbemProperty_tid, info );
 170 }
 171
 172 static HRESULT WINAPI property_GetIDsOfNames( ISWbemProperty *iface, REFIID riid, LPOLESTR *names,
 173                                               UINT count, LCID lcid, DISPID *dispid )
 174 {
 175     struct property *property = impl_from_ISWbemProperty( iface );
 176     ITypeInfo *typeinfo;
 177     HRESULT hr;
 178
 179     TRACE( "%p, %s, %p, %u, %u, %p\n", property, debugstr_guid(riid), names, count, lcid, dispid );
 180
 181     if (!names || !count || !dispid) return E_INVALIDARG;
 182
 183     hr = get_typeinfo( ISWbemProperty_tid, &typeinfo );
 184     if (SUCCEEDED(hr))
 185     {
 186         hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
 187         ITypeInfo_Release( typeinfo );
 188     }
 189     return hr;
 190 }
 191
 192 static HRESULT WINAPI property_Invoke( ISWbemProperty *iface, DISPID member, REFIID riid,
 193                                        LCID lcid, WORD flags, DISPPARAMS *params,
 194                                        VARIANT *result, EXCEPINFO *excep_info, UINT *arg_err )
 195 {
 196     struct property *property = impl_from_ISWbemProperty( iface );
 197     ITypeInfo *typeinfo;
 198     HRESULT hr;
 199
 200     TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", property, member, debugstr_guid(riid),
 201            lcid, flags, params, result, excep_info, arg_err );
 202
 203     hr = get_typeinfo( ISWbemProperty_tid, &typeinfo );
 204     if (SUCCEEDED(hr))
 205     {
 206         hr = ITypeInfo_Invoke( typeinfo, &property->ISWbemProperty_iface, member, flags,
 207                                params, result, excep_info, arg_err );
 208         ITypeInfo_Release( typeinfo );
 209     }
 210     return hr;
 211 }
 212
 213 static HRESULT WINAPI property_get_Value( ISWbemProperty *iface, VARIANT *value )
 214 {
 215     struct property *property = impl_from_ISWbemProperty( iface );
 216
 217     TRACE( "%p %p\n", property, value );
 218
 219     return IWbemClassObject_Get( property->object, property->name, 0, value, NULL, NULL );
 220 }
 221
 222 static HRESULT WINAPI property_put_Value( ISWbemProperty *iface, VARIANT *varValue )
 223 {
 224     FIXME( "\n" );
 225     return E_NOTIMPL;
 226 }
 227
 228 static HRESULT WINAPI property_get_Name( ISWbemProperty *iface, BSTR *strName )
 229 {
 230     FIXME( "\n" );
 231     return E_NOTIMPL;
 232 }
 233
 234 static HRESULT WINAPI property_get_IsLocal( ISWbemProperty *iface, VARIANT_BOOL *bIsLocal )
 235 {
 236     FIXME( "\n" );
 237     return E_NOTIMPL;
 238 }
 239
 240 static HRESULT WINAPI property_get_Origin( ISWbemProperty *iface, BSTR *strOrigin )
 241 {
 242     FIXME( "\n" );
 243     return E_NOTIMPL;
 244 }
 245
 246 static HRESULT WINAPI property_get_CIMType( ISWbemProperty *iface, WbemCimtypeEnum *iCimType )
 247 {
 248     FIXME( "\n" );
 249     return E_NOTIMPL;
 250 }
 251
 252 static HRESULT WINAPI property_get_Qualifiers_( ISWbemProperty *iface, ISWbemQualifierSet **objWbemQualifierSet )
 253 {
 254     FIXME( "\n" );
 255     return E_NOTIMPL;
 256 }
 257
 258 static HRESULT WINAPI property_get_IsArray( ISWbemProperty *iface, VARIANT_BOOL *bIsArray )
 259 {
 260     FIXME( "\n" );
 261     return E_NOTIMPL;
 262 }
 263
 264 static const ISWbemPropertyVtbl property_vtbl =
 265 {
 266     property_QueryInterface,
 267     property_AddRef,
 268     property_Release,
 269     property_GetTypeInfoCount,
 270     property_GetTypeInfo,
 271     property_GetIDsOfNames,
 272     property_Invoke,
 273     property_get_Value,
 274     property_put_Value,
 275     property_get_Name,
 276     property_get_IsLocal,
 277     property_get_Origin,
 278     property_get_CIMType,
 279     property_get_Qualifiers_,
 280     property_get_IsArray
 281 };
 282
 283 static HRESULT SWbemProperty_create( IWbemClassObject *wbem_object, BSTR name, ISWbemProperty **obj )
 284 {
 285     struct property *property;
 286
 287     TRACE( "%p, %p\n", obj, wbem_object );
 288
 289     if (!(property = heap_alloc( sizeof(*property) ))) return E_OUTOFMEMORY;
 290     property->ISWbemProperty_iface.lpVtbl = &property_vtbl;
 291     property->refs = 1;
 292     property->object = wbem_object;
 293     IWbemClassObject_AddRef( property->object );
 294     property->name = SysAllocStringLen( name, SysStringLen( name ) );
 295     *obj = &property->ISWbemProperty_iface;
 296     TRACE( "returning iface %p\n", *obj );
 297     return S_OK;
 298 }
 299
 300 struct propertyset
 301 {
 302     ISWbemPropertySet ISWbemPropertySet_iface;
 303     LONG refs;
 304     IWbemClassObject *object;
 305 };
 306
 307 static inline struct propertyset *impl_from_ISWbemPropertySet(
 308     ISWbemPropertySet *iface )
 309 {
 310     return CONTAINING_RECORD( iface, struct propertyset, ISWbemPropertySet_iface );
 311 }
 312
 313 static ULONG WINAPI propertyset_AddRef( ISWbemPropertySet *iface )
 314 {
 315     struct propertyset *propertyset = impl_from_ISWbemPropertySet( iface );
 316     return InterlockedIncrement( &propertyset->refs );
 317 }
 318
 319 static ULONG WINAPI propertyset_Release( ISWbemPropertySet *iface )
 320 {
 321     struct propertyset *propertyset = impl_from_ISWbemPropertySet( iface );
 322     LONG refs = InterlockedDecrement( &propertyset->refs );
 323     if (!refs)
 324     {
 325         TRACE( "destroying %p\n", propertyset );
 326         IWbemClassObject_Release( propertyset->object );
 327         heap_free( propertyset );
 328     }
 329     return refs;
 330 }
 331
 332 static HRESULT WINAPI propertyset_QueryInterface( ISWbemPropertySet *iface,
 333                                                   REFIID riid, void **obj )
 334 {
 335     struct propertyset *propertyset = impl_from_ISWbemPropertySet( iface );
 336
 337     TRACE( "%p %s %p\n", propertyset, debugstr_guid(riid), obj );
 338
 339     if (IsEqualGUID( riid, &IID_ISWbemPropertySet ) ||
 340         IsEqualGUID( riid, &IID_IDispatch ) ||
 341         IsEqualGUID( riid, &IID_IUnknown ))
 342     {
 343         *obj = iface;
 344     }
 345     else
 346     {
 347         FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
 348         return E_NOINTERFACE;
 349     }
 350     ISWbemPropertySet_AddRef( iface );
 351     return S_OK;
 352 }
 353
 354 static HRESULT WINAPI propertyset_GetTypeInfoCount( ISWbemPropertySet *iface, UINT *count )
 355 {
 356     struct propertyset *propertyset = impl_from_ISWbemPropertySet( iface );
 357     TRACE( "%p, %p\n", propertyset, count );
 358     *count = 1;
 359     return S_OK;
 360 }
 361
 362 static HRESULT WINAPI propertyset_GetTypeInfo( ISWbemPropertySet *iface,
 363                                                UINT index, LCID lcid, ITypeInfo **info )
 364 {
 365     struct propertyset *propertyset = impl_from_ISWbemPropertySet( iface );
 366     TRACE( "%p, %u, %u, %p\n", propertyset, index, lcid, info );
 367
 368     return get_typeinfo( ISWbemPropertySet_tid, info );
 369 }
 370
 371 static HRESULT WINAPI propertyset_GetIDsOfNames( ISWbemPropertySet *iface, REFIID riid, LPOLESTR *names,
 372                                                  UINT count, LCID lcid, DISPID *dispid )
 373 {
 374     struct propertyset *propertyset = impl_from_ISWbemPropertySet( iface );
 375     ITypeInfo *typeinfo;
 376     HRESULT hr;
 377
 378     TRACE( "%p, %s, %p, %u, %u, %p\n", propertyset, debugstr_guid(riid), names, count, lcid, dispid );
 379
 380     if (!names || !count || !dispid) return E_INVALIDARG;
 381
 382     hr = get_typeinfo( ISWbemPropertySet_tid, &typeinfo );
 383     if (SUCCEEDED(hr))
 384     {
 385         hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
 386         ITypeInfo_Release( typeinfo );
 387     }
 388     return hr;
 389 }
 390
 391 static HRESULT WINAPI propertyset_Invoke( ISWbemPropertySet *iface, DISPID member, REFIID riid,
 392                                           LCID lcid, WORD flags, DISPPARAMS *params,
 393                                           VARIANT *result, EXCEPINFO *excep_info, UINT *arg_err )
 394 {
 395     struct propertyset *propertyset = impl_from_ISWbemPropertySet( iface );
 396     ITypeInfo *typeinfo;
 397     HRESULT hr;
 398
 399     TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", propertyset, member, debugstr_guid(riid),
 400            lcid, flags, params, result, excep_info, arg_err );
 401
 402     hr = get_typeinfo( ISWbemPropertySet_tid, &typeinfo );
 403     if (SUCCEEDED(hr))
 404     {
 405         hr = ITypeInfo_Invoke( typeinfo, &propertyset->ISWbemPropertySet_iface, member, flags,
 406                                params, result, excep_info, arg_err );
 407         ITypeInfo_Release( typeinfo );
 408     }
 409     return hr;
 410 }
 411
 412 static HRESULT WINAPI propertyset_get__NewEnum( ISWbemPropertySet *iface, IUnknown **unk )
 413 {
 414     FIXME( "\n" );
 415     return E_NOTIMPL;
 416 }
 417
 418 static HRESULT WINAPI propertyset_Item( ISWbemPropertySet *iface, BSTR name,
 419                                         LONG flags, ISWbemProperty **prop )
 420 {
 421     struct propertyset *propertyset = impl_from_ISWbemPropertySet( iface );
 422     HRESULT hr;
 423     VARIANT var;
 424
 425     TRACE( "%p, %s, %08x, %p\n", propertyset, debugstr_w(name), flags, prop );
 426
 427     hr = IWbemClassObject_Get( propertyset->object, name, 0, &var, NULL, NULL );
 428     if (SUCCEEDED(hr))
 429     {
 430         hr = SWbemProperty_create( propertyset->object, name, prop );
 431         VariantClear( &var );
 432     }
 433     return hr;
 434 }
 435
 436 static HRESULT WINAPI propertyset_get_Count( ISWbemPropertySet *iface, LONG *count )
 437 {
 438     FIXME( "\n" );
 439     return E_NOTIMPL;
 440 }
 441
 442 static HRESULT WINAPI propertyset_Add( ISWbemPropertySet *iface, BSTR name, WbemCimtypeEnum type,
 443                                        VARIANT_BOOL is_array, LONG flags, ISWbemProperty **prop )
 444 {
 445     FIXME( "\n" );
 446     return E_NOTIMPL;
 447 }
 448
 449 static HRESULT WINAPI propertyset_Remove( ISWbemPropertySet *iface, BSTR name, LONG flags )
 450 {
 451     FIXME( "\n" );
 452     return E_NOTIMPL;
 453 }
 454
 455 static const ISWbemPropertySetVtbl propertyset_vtbl =
 456 {
 457     propertyset_QueryInterface,
 458     propertyset_AddRef,
 459     propertyset_Release,
 460     propertyset_GetTypeInfoCount,
 461     propertyset_GetTypeInfo,
 462     propertyset_GetIDsOfNames,
 463     propertyset_Invoke,
 464     propertyset_get__NewEnum,
 465     propertyset_Item,
 466     propertyset_get_Count,
 467     propertyset_Add,
 468     propertyset_Remove
 469 };
 470
 471 static HRESULT SWbemPropertySet_create( IWbemClassObject *wbem_object, ISWbemPropertySet **obj )
 472 {
 473     struct propertyset *propertyset;
 474
 475     TRACE( "%p, %p\n", obj, wbem_object );
 476
 477     if (!(propertyset = heap_alloc( sizeof(*propertyset) ))) return E_OUTOFMEMORY;
 478     propertyset->ISWbemPropertySet_iface.lpVtbl = &propertyset_vtbl;
 479     propertyset->refs = 1;
 480     propertyset->object = wbem_object;
 481     IWbemClassObject_AddRef( propertyset->object );
 482     *obj = &propertyset->ISWbemPropertySet_iface;
 483
 484     TRACE( "returning iface %p\n", *obj );
 485     return S_OK;
 486 }
 487
 488 #define DISPID_BASE 0x1800000
 489
 490 struct member
 491 {
 492     BSTR name;
 493     DISPID dispid;
 494 };
 495
 496 struct object
 497 {
 498     ISWbemObject ISWbemObject_iface;
 499     LONG refs;
 500     IWbemClassObject *object;
 501     struct member *members;
 502     UINT nb_members;
 503     DISPID last_dispid;
 504 };
 505
 506 static inline struct object *impl_from_ISWbemObject(
 507     ISWbemObject *iface )
 508 {
 509     return CONTAINING_RECORD( iface, struct object, ISWbemObject_iface );
 510 }
 511
 512 static ULONG WINAPI object_AddRef(
 513     ISWbemObject *iface )
 514 {
 515     struct object *object = impl_from_ISWbemObject( iface );
 516     return InterlockedIncrement( &object->refs );
 517 }
 518
 519 static ULONG WINAPI object_Release(
 520     ISWbemObject *iface )
 521 {
 522     struct object *object = impl_from_ISWbemObject( iface );
 523     LONG refs = InterlockedDecrement( &object->refs );
 524     if (!refs)
 525     {
 526         UINT i;
 527
 528         TRACE( "destroying %p\n", object );
 529         IWbemClassObject_Release( object->object );
 530         for (i = 0; i < object->nb_members; i++) SysFreeString( object->members[i].name );
 531         heap_free( object->members );
 532         heap_free( object );
 533     }
 534     return refs;
 535 }
 536
 537 static HRESULT WINAPI object_QueryInterface(
 538     ISWbemObject *iface,
 539     REFIID riid,
 540     void **ppvObject )
 541 {
 542     struct object *object = impl_from_ISWbemObject( iface );
 543
 544     TRACE( "%p %s %p\n", object, debugstr_guid(riid), ppvObject );
 545
 546     if (IsEqualGUID( riid, &IID_ISWbemObject ) ||
 547         IsEqualGUID( riid, &IID_IDispatch ) ||
 548         IsEqualGUID( riid, &IID_IUnknown ))
 549     {
 550         *ppvObject = iface;
 551     }
 552     else
 553     {
 554         FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
 555         return E_NOINTERFACE;
 556     }
 557     ISWbemObject_AddRef( iface );
 558     return S_OK;
 559 }
 560
 561 static HRESULT WINAPI object_GetTypeInfoCount(
 562     ISWbemObject *iface,
 563     UINT *count )
 564 {
 565     struct object *object = impl_from_ISWbemObject( iface );
 566
 567     TRACE( "%p, %p\n", object, count );
 568     *count = 1;
 569     return S_OK;
 570 }
 571
 572 static HRESULT WINAPI object_GetTypeInfo(
 573     ISWbemObject *iface,
 574     UINT index,
 575     LCID lcid,
 576     ITypeInfo **info )
 577 {
 578     struct object *object = impl_from_ISWbemObject( iface );
 579     FIXME( "%p, %u, %u, %p\n", object, index, lcid, info );
 580     return E_NOTIMPL;
 581 }
 582
 583 static HRESULT init_members( struct object *object )
 584 {
 585     LONG bound, i;
 586     SAFEARRAY *sa;
 587     HRESULT hr;
 588
 589     if (object->members) return S_OK;
 590
 591     hr = IWbemClassObject_GetNames( object->object, NULL, 0, NULL, &sa );
 592     if (FAILED( hr )) return hr;
 593     hr = SafeArrayGetUBound( sa, 1, &bound );
 594     if (FAILED( hr ))
 595     {
 596         SafeArrayDestroy( sa );
 597         return hr;
 598     }
 599     if (!(object->members = heap_alloc( sizeof(struct member) * (bound + 1) )))
 600     {
 601         SafeArrayDestroy( sa );
 602         return E_OUTOFMEMORY;
 603     }
 604     for (i = 0; i <= bound; i++)
 605     {
 606         hr = SafeArrayGetElement( sa, &i, &object->members[i].name );
 607         if (FAILED( hr ))
 608         {
 609             for (i--; i >= 0; i--) SysFreeString( object->members[i].name );
 610             SafeArrayDestroy( sa );
 611             heap_free( object->members );
 612             object->members = NULL;
 613             return E_OUTOFMEMORY;
 614         }
 615         object->members[i].dispid = 0;
 616     }
 617     object->nb_members = bound + 1;
 618     SafeArrayDestroy( sa );
 619     return S_OK;
 620 }
 621
 622 static DISPID get_member_dispid( struct object *object, const WCHAR *name )
 623 {
 624     UINT i;
 625     for (i = 0; i < object->nb_members; i++)
 626     {
 627         if (!strcmpiW( object->members[i].name, name ))
 628         {
 629             if (!object->members[i].dispid) object->members[i].dispid = ++object->last_dispid;
 630             return object->members[i].dispid;
 631         }
 632     }
 633     return DISPID_UNKNOWN;
 634 }
 635
 636 static HRESULT WINAPI object_GetIDsOfNames(
 637     ISWbemObject *iface,
 638     REFIID riid,
 639     LPOLESTR *names,
 640     UINT count,
 641     LCID lcid,
 642     DISPID *dispid )
 643 {
 644     struct object *object = impl_from_ISWbemObject( iface );
 645     HRESULT hr;
 646     UINT i;
 647     ITypeInfo *typeinfo;
 648
 649     TRACE( "%p, %s, %p, %u, %u, %p\n", object, debugstr_guid(riid), names, count, lcid, dispid );
 650
 651     if (!names || !count || !dispid) return E_INVALIDARG;
 652
 653     hr = init_members( object );
 654     if (FAILED( hr )) return hr;
 655
 656     hr = get_typeinfo( ISWbemObject_tid, &typeinfo );
 657     if (SUCCEEDED(hr))
 658     {
 659         hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
 660         ITypeInfo_Release( typeinfo );
 661     }
 662     if (SUCCEEDED(hr)) return hr;
 663
 664     for (i = 0; i < count; i++)
 665     {
 666         if ((dispid[i] = get_member_dispid( object, names[i] )) == DISPID_UNKNOWN) break;
 667     }
 668     if (i != count) return DISP_E_UNKNOWNNAME;
 669     return S_OK;
 670 }
 671
 672 static BSTR get_member_name( struct object *object, DISPID dispid )
 673 {
 674     UINT i;
 675     for (i = 0; i < object->nb_members; i++)
 676     {
 677         if (object->members[i].dispid == dispid) return object->members[i].name;
 678     }
 679     return NULL;
 680 }
 681
 682 static HRESULT WINAPI object_Invoke(
 683     ISWbemObject *iface,
 684     DISPID member,
 685     REFIID riid,
 686     LCID lcid,
 687     WORD flags,
 688     DISPPARAMS *params,
 689     VARIANT *result,
 690     EXCEPINFO *excep_info,
 691     UINT *arg_err )
 692 {
 693     struct object *object = impl_from_ISWbemObject( iface );
 694     BSTR name;
 695     ITypeInfo *typeinfo;
 696     HRESULT hr;
 697
 698     TRACE( "%p, %x, %s, %u, %x, %p, %p, %p, %p\n", object, member, debugstr_guid(riid),
 699            lcid, flags, params, result, excep_info, arg_err );
 700
 701     if (member <= DISPID_BASE)
 702     {
 703         hr = get_typeinfo( ISWbemObject_tid, &typeinfo );
 704         if (SUCCEEDED(hr))
 705         {
 706             hr = ITypeInfo_Invoke( typeinfo, &object->ISWbemObject_iface, member, flags,
 707                                    params, result, excep_info, arg_err );
 708             ITypeInfo_Release( typeinfo );
 709         }
 710         return hr;
 711     }
 712
 713     if (flags != (DISPATCH_METHOD|DISPATCH_PROPERTYGET))
 714     {
 715         FIXME( "flags %x not supported\n", flags );
 716         return E_NOTIMPL;
 717     }
 718     if (!(name = get_member_name( object, member )))
 719         return DISP_E_MEMBERNOTFOUND;
 720
 721     memset( params, 0, sizeof(*params) );
 722     return IWbemClassObject_Get( object->object, name, 0, result, NULL, NULL );
 723 }
 724
 725 static HRESULT WINAPI object_Put_(
 726     ISWbemObject *iface,
 727     LONG iFlags,
 728     IDispatch *objWbemNamedValueSet,
 729     ISWbemObjectPath **objWbemObjectPath )
 730 {
 731     FIXME( "\n" );
 732     return E_NOTIMPL;
 733 }
 734
 735 static HRESULT WINAPI object_PutAsync_(
 736     ISWbemObject *iface,
 737     IDispatch *objWbemSink,
 738     LONG iFlags,
 739     IDispatch *objWbemNamedValueSet,
 740     IDispatch *objWbemAsyncContext )
 741 {
 742     FIXME( "\n" );
 743     return E_NOTIMPL;
 744 }
 745
 746 static HRESULT WINAPI object_Delete_(
 747     ISWbemObject *iface,
 748     LONG iFlags,
 749     IDispatch *objWbemNamedValueSet )
 750 {
 751     FIXME( "\n" );
 752     return E_NOTIMPL;
 753 }
 754
 755 static HRESULT WINAPI object_DeleteAsync_(
 756     ISWbemObject *iface,
 757     IDispatch *objWbemSink,
 758     LONG iFlags,
 759     IDispatch *objWbemNamedValueSet,
 760     IDispatch *objWbemAsyncContext )
 761 {
 762     FIXME( "\n" );
 763     return E_NOTIMPL;
 764 }
 765
 766 static HRESULT WINAPI object_Instances_(
 767     ISWbemObject *iface,
 768     LONG iFlags,
 769     IDispatch *objWbemNamedValueSet,
 770     ISWbemObjectSet **objWbemObjectSet )
 771 {
 772     FIXME( "\n" );
 773     return E_NOTIMPL;
 774 }
 775
 776 static HRESULT WINAPI object_InstancesAsync_(
 777     ISWbemObject *iface,
 778     IDispatch *objWbemSink,
 779     LONG iFlags,
 780     IDispatch *objWbemNamedValueSet,
 781     IDispatch *objWbemAsyncContext )
 782 {
 783     FIXME( "\n" );
 784     return E_NOTIMPL;
 785 }
 786
 787 static HRESULT WINAPI object_Subclasses_(
 788     ISWbemObject *iface,
 789     LONG iFlags,
 790     IDispatch *objWbemNamedValueSet,
 791     ISWbemObjectSet **objWbemObjectSet )
 792 {
 793     FIXME( "\n" );
 794     return E_NOTIMPL;
 795 }
 796
 797 static HRESULT WINAPI object_SubclassesAsync_(
 798     ISWbemObject *iface,
 799     IDispatch *objWbemSink,
 800     LONG iFlags,
 801     IDispatch *objWbemNamedValueSet,
 802     IDispatch *objWbemAsyncContext )
 803 {
 804     FIXME( "\n" );
 805     return E_NOTIMPL;
 806 }
 807
 808 static HRESULT WINAPI object_Associators_(
 809     ISWbemObject *iface,
 810     BSTR strAssocClass,
 811     BSTR strResultClass,
 812     BSTR strResultRole,
 813     BSTR strRole,
 814     VARIANT_BOOL bClassesOnly,
 815     VARIANT_BOOL bSchemaOnly,
 816     BSTR strRequiredAssocQualifier,
 817     BSTR strRequiredQualifier,
 818     LONG iFlags,
 819     IDispatch *objWbemNamedValueSet,
 820     ISWbemObjectSet **objWbemObjectSet )
 821 {
 822     FIXME( "\n" );
 823     return E_NOTIMPL;
 824 }
 825
 826 static HRESULT WINAPI object_AssociatorsAsync_(
 827     ISWbemObject *iface,
 828     IDispatch *objWbemSink,
 829     BSTR strAssocClass,
 830     BSTR strResultClass,
 831     BSTR strResultRole,
 832     BSTR strRole,
 833     VARIANT_BOOL bClassesOnly,
 834     VARIANT_BOOL bSchemaOnly,
 835     BSTR strRequiredAssocQualifier,
 836     BSTR strRequiredQualifier,
 837     LONG iFlags,
 838     IDispatch *objWbemNamedValueSet,
 839     IDispatch *objWbemAsyncContext )
 840 {
 841     FIXME( "\n" );
 842     return E_NOTIMPL;
 843 }
 844
 845 static HRESULT WINAPI object_References_(
 846     ISWbemObject *iface,
 847     BSTR strResultClass,
 848     BSTR strRole,
 849     VARIANT_BOOL bClassesOnly,
 850     VARIANT_BOOL bSchemaOnly,
 851     BSTR strRequiredQualifier,
 852     LONG iFlags,
 853     IDispatch *objWbemNamedValueSet,
 854     ISWbemObjectSet **objWbemObjectSet )
 855 {
 856     FIXME( "\n" );
 857     return E_NOTIMPL;
 858 }
 859
 860 static HRESULT WINAPI object_ReferencesAsync_(
 861     ISWbemObject *iface,
 862     IDispatch *objWbemSink,
 863     BSTR strResultClass,
 864     BSTR strRole,
 865     VARIANT_BOOL bClassesOnly,
 866     VARIANT_BOOL bSchemaOnly,
 867     BSTR strRequiredQualifier,
 868     LONG iFlags,
 869     IDispatch *objWbemNamedValueSet,
 870     IDispatch *objWbemAsyncContext )
 871 {
 872     FIXME( "\n" );
 873     return E_NOTIMPL;
 874 }
 875
 876 static HRESULT WINAPI object_ExecMethod_(
 877     ISWbemObject *iface,
 878     BSTR strMethodName,
 879     IDispatch *objWbemInParameters,
 880     LONG iFlags,
 881     IDispatch *objWbemNamedValueSet,
 882     ISWbemObject **objWbemOutParameters )
 883 {
 884     FIXME( "\n" );
 885     return E_NOTIMPL;
 886 }
 887
 888 static HRESULT WINAPI object_ExecMethodAsync_(
 889     ISWbemObject *iface,
 890     IDispatch *objWbemSink,
 891     BSTR strMethodName,
 892     IDispatch *objWbemInParameters,
 893     LONG iFlags,
 894     IDispatch *objWbemNamedValueSet,
 895     IDispatch *objWbemAsyncContext )
 896 {
 897     FIXME( "\n" );
 898     return E_NOTIMPL;
 899 }
 900
 901 static HRESULT WINAPI object_Clone_(
 902     ISWbemObject *iface,
 903     ISWbemObject **objWbemObject )
 904 {
 905     FIXME( "\n" );
 906     return E_NOTIMPL;
 907 }
 908
 909 static HRESULT WINAPI object_GetObjectText_(
 910     ISWbemObject *iface,
 911     LONG iFlags,
 912     BSTR *strObjectText )
 913 {
 914     FIXME( "\n" );
 915     return E_NOTIMPL;
 916 }
 917
 918 static HRESULT WINAPI object_SpawnDerivedClass_(
 919     ISWbemObject *iface,
 920     LONG iFlags,
 921     ISWbemObject **objWbemObject )
 922 {
 923     FIXME( "\n" );
 924     return E_NOTIMPL;
 925 }
 926
 927 static HRESULT WINAPI object_SpawnInstance_(
 928     ISWbemObject *iface,
 929     LONG iFlags,
 930     ISWbemObject **objWbemObject )
 931 {
 932     FIXME( "\n" );
 933     return E_NOTIMPL;
 934 }
 935
 936 static HRESULT WINAPI object_CompareTo_(
 937     ISWbemObject *iface,
 938     IDispatch *objWbemObject,
 939     LONG iFlags,
 940     VARIANT_BOOL *bResult )
 941 {
 942     FIXME( "\n" );
 943     return E_NOTIMPL;
 944 }
 945
 946 static HRESULT WINAPI object_get_Qualifiers_(
 947     ISWbemObject *iface,
 948     ISWbemQualifierSet **objWbemQualifierSet )
 949 {
 950     FIXME( "\n" );
 951     return E_NOTIMPL;
 952 }
 953
 954 static HRESULT WINAPI object_get_Properties_( ISWbemObject *iface, ISWbemPropertySet **prop_set )
 955 {
 956     struct object *object = impl_from_ISWbemObject( iface );
 957
 958     TRACE( "%p, %p\n", object, prop_set );
 959     return SWbemPropertySet_create( object->object, prop_set );
 960 }
 961
 962 static HRESULT WINAPI object_get_Methods_(
 963     ISWbemObject *iface,
 964     ISWbemMethodSet **objWbemMethodSet )
 965 {
 966     FIXME( "\n" );
 967     return E_NOTIMPL;
 968 }
 969
 970 static HRESULT WINAPI object_get_Derivation_(
 971     ISWbemObject *iface,
 972     VARIANT *strClassNameArray )
 973 {
 974     FIXME( "\n" );
 975     return E_NOTIMPL;
 976 }
 977
 978 static HRESULT WINAPI object_get_Path_(
 979     ISWbemObject *iface,
 980     ISWbemObjectPath **objWbemObjectPath )
 981 {
 982     FIXME( "\n" );
 983     return E_NOTIMPL;
 984 }
 985
 986 static HRESULT WINAPI object_get_Security_(
 987     ISWbemObject *iface,
 988     ISWbemSecurity **objWbemSecurity )
 989 {
 990     FIXME( "\n" );
 991     return E_NOTIMPL;
 992 }
 993
 994 static const ISWbemObjectVtbl object_vtbl =
 995 {
 996     object_QueryInterface,
 997     object_AddRef,
 998     object_Release,
 999     object_GetTypeInfoCount,
1000     object_GetTypeInfo,
1001     object_GetIDsOfNames,
1002     object_Invoke,
1003     object_Put_,
1004     object_PutAsync_,
1005     object_Delete_,
1006     object_DeleteAsync_,
1007     object_Instances_,
1008     object_InstancesAsync_,
1009     object_Subclasses_,
1010     object_SubclassesAsync_,
1011     object_Associators_,
1012     object_AssociatorsAsync_,
1013     object_References_,
1014     object_ReferencesAsync_,
1015     object_ExecMethod_,
1016     object_ExecMethodAsync_,
1017     object_Clone_,
1018     object_GetObjectText_,
1019     object_SpawnDerivedClass_,
1020     object_SpawnInstance_,
1021     object_CompareTo_,
1022     object_get_Qualifiers_,
1023     object_get_Properties_,
1024     object_get_Methods_,
1025     object_get_Derivation_,
1026     object_get_Path_,
1027     object_get_Security_
1028 };
1029
1030 static HRESULT SWbemObject_create( IWbemClassObject *wbem_object, ISWbemObject **obj )
1031 {
1032     struct object *object;
1033
1034     TRACE( "%p, %p\n", obj, wbem_object );
1035
1036     if (!(object = heap_alloc( sizeof(*object) ))) return E_OUTOFMEMORY;
1037     object->ISWbemObject_iface.lpVtbl = &object_vtbl;
1038     object->refs = 1;
1039     object->object = wbem_object;
1040     IWbemClassObject_AddRef( object->object );
1041     object->members = NULL;
1042     object->nb_members = 0;
1043     object->last_dispid = DISPID_BASE;
1044
1045     *obj = &object->ISWbemObject_iface;
1046     TRACE( "returning iface %p\n", *obj );
1047     return S_OK;
1048 }
1049
1050 struct objectset
1051 {
1052     ISWbemObjectSet ISWbemObjectSet_iface;
1053     LONG refs;
1054     IEnumWbemClassObject *objectenum;
1055     LONG count;
1056 };
1057
1058 static inline struct objectset *impl_from_ISWbemObjectSet(
1059     ISWbemObjectSet *iface )
1060 {
1061     return CONTAINING_RECORD( iface, struct objectset, ISWbemObjectSet_iface );
1062 }
1063
1064 static ULONG WINAPI objectset_AddRef(
1065     ISWbemObjectSet *iface )
1066 {
1067     struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
1068     return InterlockedIncrement( &objectset->refs );
1069 }
1070
1071 static ULONG WINAPI objectset_Release(
1072     ISWbemObjectSet *iface )
1073 {
1074     struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
1075     LONG refs = InterlockedDecrement( &objectset->refs );
1076     if (!refs)
1077     {
1078         TRACE( "destroying %p\n", objectset );
1079         IEnumWbemClassObject_Release( objectset->objectenum );
1080         heap_free( objectset );
1081     }
1082     return refs;
1083 }
1084
1085 static HRESULT WINAPI objectset_QueryInterface(
1086     ISWbemObjectSet *iface,
1087     REFIID riid,
1088     void **ppvObject )
1089 {
1090     struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
1091
1092     TRACE( "%p %s %p\n", objectset, debugstr_guid(riid), ppvObject );
1093
1094     if (IsEqualGUID( riid, &IID_ISWbemObjectSet ) ||
1095         IsEqualGUID( riid, &IID_IDispatch ) ||
1096         IsEqualGUID( riid, &IID_IUnknown ))
1097     {
1098         *ppvObject = iface;
1099     }
1100     else
1101     {
1102         FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
1103         return E_NOINTERFACE;
1104     }
1105     ISWbemObjectSet_AddRef( iface );
1106     return S_OK;
1107 }
1108
1109 static HRESULT WINAPI objectset_GetTypeInfoCount(
1110     ISWbemObjectSet *iface,
1111     UINT *count )
1112 {
1113     struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
1114     TRACE( "%p, %p\n", objectset, count );
1115     *count = 1;
1116     return S_OK;
1117 }
1118
1119 static HRESULT WINAPI objectset_GetTypeInfo(
1120     ISWbemObjectSet *iface,
1121     UINT index,
1122     LCID lcid,
1123     ITypeInfo **info )
1124 {
1125     struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
1126     TRACE( "%p, %u, %u, %p\n", objectset, index, lcid, info );
1127
1128     return get_typeinfo( ISWbemObjectSet_tid, info );
1129 }
1130
1131 static HRESULT WINAPI objectset_GetIDsOfNames(
1132     ISWbemObjectSet *iface,
1133     REFIID riid,
1134     LPOLESTR *names,
1135     UINT count,
1136     LCID lcid,
1137     DISPID *dispid )
1138 {
1139     struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
1140     ITypeInfo *typeinfo;
1141     HRESULT hr;
1142
1143     TRACE( "%p, %s, %p, %u, %u, %p\n", objectset, debugstr_guid(riid), names, count, lcid, dispid );
1144
1145     if (!names || !count || !dispid) return E_INVALIDARG;
1146
1147     hr = get_typeinfo( ISWbemObjectSet_tid, &typeinfo );
1148     if (SUCCEEDED(hr))
1149     {
1150         hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
1151         ITypeInfo_Release( typeinfo );
1152     }
1153     return hr;
1154 }
1155
1156 static HRESULT WINAPI objectset_Invoke(
1157     ISWbemObjectSet *iface,
1158     DISPID member,
1159     REFIID riid,
1160     LCID lcid,
1161     WORD flags,
1162     DISPPARAMS *params,
1163     VARIANT *result,
1164     EXCEPINFO *excep_info,
1165     UINT *arg_err )
1166 {
1167     struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
1168     ITypeInfo *typeinfo;
1169     HRESULT hr;
1170
1171     TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", objectset, member, debugstr_guid(riid),
1172            lcid, flags, params, result, excep_info, arg_err );
1173
1174     hr = get_typeinfo( ISWbemObjectSet_tid, &typeinfo );
1175     if (SUCCEEDED(hr))
1176     {
1177         hr = ITypeInfo_Invoke( typeinfo, &objectset->ISWbemObjectSet_iface, member, flags,
1178                                params, result, excep_info, arg_err );
1179         ITypeInfo_Release( typeinfo );
1180     }
1181     return hr;
1182 }
1183
1184 static HRESULT WINAPI objectset_get__NewEnum(
1185     ISWbemObjectSet *iface,
1186     IUnknown **pUnk )
1187 {
1188     struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
1189     IEnumWbemClassObject *objectenum;
1190     HRESULT hr;
1191
1192     TRACE( "%p, %p\n", objectset, pUnk );
1193
1194     hr = IEnumWbemClassObject_Clone( objectset->objectenum, &objectenum );
1195     if (FAILED( hr )) return hr;
1196
1197     hr = EnumVARIANT_create( objectenum, (IEnumVARIANT **)pUnk );
1198     IEnumWbemClassObject_Release( objectenum );
1199     return hr;
1200 }
1201
1202 static HRESULT WINAPI objectset_Item(
1203     ISWbemObjectSet *iface,
1204     BSTR strObjectPath,
1205     LONG iFlags,
1206     ISWbemObject **objWbemObject )
1207 {
1208     FIXME( "\n" );
1209     return E_NOTIMPL;
1210 }
1211
1212 static HRESULT WINAPI objectset_get_Count(
1213     ISWbemObjectSet *iface,
1214     LONG *iCount )
1215 {
1216     struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
1217
1218     TRACE( "%p, %p\n", objectset, iCount );
1219
1220     *iCount = objectset->count;
1221     return S_OK;
1222 }
1223
1224 static HRESULT WINAPI objectset_get_Security_(
1225     ISWbemObjectSet *iface,
1226     ISWbemSecurity **objWbemSecurity )
1227 {
1228     FIXME( "\n" );
1229     return E_NOTIMPL;
1230 }
1231
1232 static HRESULT WINAPI objectset_ItemIndex(
1233     ISWbemObjectSet *iface,
1234     LONG lIndex,
1235     ISWbemObject **objWbemObject )
1236 {
1237     struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
1238     LONG count;
1239     HRESULT hr;
1240     IEnumVARIANT *enum_var;
1241     VARIANT var;
1242
1243     TRACE( "%p, %d, %p\n", objectset, lIndex, objWbemObject );
1244
1245     *objWbemObject = NULL;
1246     hr = ISWbemObjectSet_get_Count( iface, &count );
1247     if (FAILED(hr)) return hr;
1248
1249     if (lIndex >= count) return WBEM_E_NOT_FOUND;
1250
1251     hr = ISWbemObjectSet_get__NewEnum( iface, (IUnknown **)&enum_var );
1252     if (FAILED(hr)) return hr;
1253
1254     IEnumVARIANT_Reset( enum_var );
1255     hr = IEnumVARIANT_Skip( enum_var, lIndex );
1256     if (SUCCEEDED(hr))
1257         hr = IEnumVARIANT_Next( enum_var, 1, &var, NULL );
1258     IEnumVARIANT_Release( enum_var );
1259
1260     if (SUCCEEDED(hr))
1261     {
1262         if (V_VT( &var ) == VT_DISPATCH)
1263             hr = IDispatch_QueryInterface( V_DISPATCH( &var ), &IID_ISWbemObject, (void **)objWbemObject );
1264         else
1265             hr = WBEM_E_NOT_FOUND;
1266         VariantClear( &var );
1267     }
1268
1269     return hr;
1270 }
1271
1272 static const ISWbemObjectSetVtbl objectset_vtbl =
1273 {
1274     objectset_QueryInterface,
1275     objectset_AddRef,
1276     objectset_Release,
1277     objectset_GetTypeInfoCount,
1278     objectset_GetTypeInfo,
1279     objectset_GetIDsOfNames,
1280     objectset_Invoke,
1281     objectset_get__NewEnum,
1282     objectset_Item,
1283     objectset_get_Count,
1284     objectset_get_Security_,
1285     objectset_ItemIndex
1286 };
1287
1288 static LONG get_object_count( IEnumWbemClassObject *iter )
1289 {
1290     LONG count = 0;
1291     while (IEnumWbemClassObject_Skip( iter, WBEM_INFINITE, 1 ) == S_OK) count++;
1292     IEnumWbemClassObject_Reset( iter );
1293     return count;
1294 }
1295
1296 static HRESULT SWbemObjectSet_create( IEnumWbemClassObject *wbem_objectenum, ISWbemObjectSet **obj )
1297 {
1298     struct objectset *objectset;
1299
1300     TRACE( "%p, %p\n", obj, wbem_objectenum );
1301
1302     if (!(objectset = heap_alloc( sizeof(*objectset) ))) return E_OUTOFMEMORY;
1303     objectset->ISWbemObjectSet_iface.lpVtbl = &objectset_vtbl;
1304     objectset->refs = 1;
1305     objectset->objectenum = wbem_objectenum;
1306     IEnumWbemClassObject_AddRef( objectset->objectenum );
1307     objectset->count = get_object_count( objectset->objectenum );
1308
1309     *obj = &objectset->ISWbemObjectSet_iface;
1310     TRACE( "returning iface %p\n", *obj );
1311     return S_OK;
1312 }
1313
1314 struct enumvar
1315 {
1316     IEnumVARIANT IEnumVARIANT_iface;
1317     LONG refs;
1318     IEnumWbemClassObject *objectenum;
1319 };
1320
1321 static inline struct enumvar *impl_from_IEnumVARIANT(
1322     IEnumVARIANT *iface )
1323 {
1324     return CONTAINING_RECORD( iface, struct enumvar, IEnumVARIANT_iface );
1325 }
1326
1327 static ULONG WINAPI enumvar_AddRef(
1328     IEnumVARIANT *iface )
1329 {
1330     struct enumvar *enumvar = impl_from_IEnumVARIANT( iface );
1331     return InterlockedIncrement( &enumvar->refs );
1332 }
1333
1334 static ULONG WINAPI enumvar_Release(
1335     IEnumVARIANT *iface )
1336 {
1337     struct enumvar *enumvar = impl_from_IEnumVARIANT( iface );
1338     LONG refs = InterlockedDecrement( &enumvar->refs );
1339     if (!refs)
1340     {
1341         TRACE( "destroying %p\n", enumvar );
1342         IEnumWbemClassObject_Release( enumvar->objectenum );
1343         heap_free( enumvar );
1344     }
1345     return refs;
1346 }
1347
1348 static HRESULT WINAPI enumvar_QueryInterface(
1349     IEnumVARIANT *iface,
1350     REFIID riid,
1351     void **ppvObject )
1352 {
1353     struct enumvar *enumvar = impl_from_IEnumVARIANT( iface );
1354
1355     TRACE( "%p %s %p\n", enumvar, debugstr_guid(riid), ppvObject );
1356
1357     if (IsEqualGUID( riid, &IID_IEnumVARIANT ) ||
1358         IsEqualGUID( riid, &IID_IUnknown ))
1359     {
1360         *ppvObject = iface;
1361     }
1362     else
1363     {
1364         FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
1365         return E_NOINTERFACE;
1366     }
1367     IEnumVARIANT_AddRef( iface );
1368     return S_OK;
1369 }
1370
1371 static HRESULT WINAPI enumvar_Next( IEnumVARIANT *iface, ULONG celt, VARIANT *var, ULONG *fetched )
1372 {
1373     struct enumvar *enumvar = impl_from_IEnumVARIANT( iface );
1374     IWbemClassObject *obj;
1375     ULONG count = 0;
1376
1377     TRACE( "%p, %u, %p, %p\n", iface, celt, var, fetched );
1378
1379     if (celt) IEnumWbemClassObject_Next( enumvar->objectenum, WBEM_INFINITE, 1, &obj, &count );
1380     if (count)
1381     {
1382         ISWbemObject *sobj;
1383         HRESULT hr;
1384
1385         hr = SWbemObject_create( obj, &sobj );
1386         IWbemClassObject_Release( obj );
1387         if (FAILED( hr )) return hr;
1388
1389         V_VT( var ) = VT_DISPATCH;
1390         V_DISPATCH( var ) = (IDispatch *)sobj;
1391     }
1392     if (fetched) *fetched = count;
1393     return (count < celt) ? S_FALSE : S_OK;
1394 }
1395
1396 static HRESULT WINAPI enumvar_Skip( IEnumVARIANT *iface, ULONG celt )
1397 {
1398     struct enumvar *enumvar = impl_from_IEnumVARIANT( iface );
1399
1400     TRACE( "%p, %u\n", iface, celt );
1401
1402     return IEnumWbemClassObject_Skip( enumvar->objectenum, WBEM_INFINITE, celt );
1403 }
1404
1405 static HRESULT WINAPI enumvar_Reset( IEnumVARIANT *iface )
1406 {
1407     struct enumvar *enumvar = impl_from_IEnumVARIANT( iface );
1408
1409     TRACE( "%p\n", iface );
1410
1411     return IEnumWbemClassObject_Reset( enumvar->objectenum );
1412 }
1413
1414 static HRESULT WINAPI enumvar_Clone( IEnumVARIANT *iface, IEnumVARIANT **penum )
1415 {
1416     FIXME( "%p, %p\n", iface, penum );
1417     return E_NOTIMPL;
1418 }
1419
1420 static const struct IEnumVARIANTVtbl enumvar_vtbl =
1421 {
1422     enumvar_QueryInterface,
1423     enumvar_AddRef,
1424     enumvar_Release,
1425     enumvar_Next,
1426     enumvar_Skip,
1427     enumvar_Reset,
1428     enumvar_Clone
1429 };
1430
1431 static HRESULT EnumVARIANT_create( IEnumWbemClassObject *objectenum, IEnumVARIANT **obj )
1432 {
1433     struct enumvar *enumvar;
1434
1435     if (!(enumvar = heap_alloc( sizeof(*enumvar) ))) return E_OUTOFMEMORY;
1436     enumvar->IEnumVARIANT_iface.lpVtbl = &enumvar_vtbl;
1437     enumvar->refs = 1;
1438     enumvar->objectenum = objectenum;
1439     IEnumWbemClassObject_AddRef( enumvar->objectenum );
1440
1441     *obj = &enumvar->IEnumVARIANT_iface;
1442     TRACE( "returning iface %p\n", *obj );
1443     return S_OK;
1444 }
1445
1446 struct services
1447 {
1448     ISWbemServices ISWbemServices_iface;
1449     LONG refs;
1450     IWbemServices *services;
1451 };
1452
1453 static inline struct services *impl_from_ISWbemServices(
1454     ISWbemServices *iface )
1455 {
1456     return CONTAINING_RECORD( iface, struct services, ISWbemServices_iface );
1457 }
1458
1459 static ULONG WINAPI services_AddRef(
1460     ISWbemServices *iface )
1461 {
1462     struct services *services = impl_from_ISWbemServices( iface );
1463     return InterlockedIncrement( &services->refs );
1464 }
1465
1466 static ULONG WINAPI services_Release(
1467     ISWbemServices *iface )
1468 {
1469     struct services *services = impl_from_ISWbemServices( iface );
1470     LONG refs = InterlockedDecrement( &services->refs );
1471     if (!refs)
1472     {
1473         TRACE( "destroying %p\n", services );
1474         IWbemServices_Release( services->services );
1475         heap_free( services );
1476     }
1477     return refs;
1478 }
1479
1480 static HRESULT WINAPI services_QueryInterface(
1481     ISWbemServices *iface,
1482     REFIID riid,
1483     void **ppvObject )
1484 {
1485     struct services *services = impl_from_ISWbemServices( iface );
1486
1487     TRACE( "%p %s %p\n", services, debugstr_guid(riid), ppvObject );
1488
1489     if (IsEqualGUID( riid, &IID_ISWbemServices ) ||
1490         IsEqualGUID( riid, &IID_IDispatch ) ||
1491         IsEqualGUID( riid, &IID_IUnknown ))
1492     {
1493         *ppvObject = iface;
1494     }
1495     else
1496     {
1497         FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
1498         return E_NOINTERFACE;
1499     }
1500     ISWbemServices_AddRef( iface );
1501     return S_OK;
1502 }
1503
1504 static HRESULT WINAPI services_GetTypeInfoCount(
1505     ISWbemServices *iface,
1506     UINT *count )
1507 {
1508     struct services *services = impl_from_ISWbemServices( iface );
1509     TRACE( "%p, %p\n", services, count );
1510
1511     *count = 1;
1512     return S_OK;
1513 }
1514
1515 static HRESULT WINAPI services_GetTypeInfo(
1516     ISWbemServices *iface,
1517     UINT index,
1518     LCID lcid,
1519     ITypeInfo **info )
1520 {
1521     struct services *services = impl_from_ISWbemServices( iface );
1522     TRACE( "%p, %u, %u, %p\n", services, index, lcid, info );
1523
1524     return get_typeinfo( ISWbemServices_tid, info );
1525 }
1526
1527 static HRESULT WINAPI services_GetIDsOfNames(
1528     ISWbemServices *iface,
1529     REFIID riid,
1530     LPOLESTR *names,
1531     UINT count,
1532     LCID lcid,
1533     DISPID *dispid )
1534 {
1535     struct services *services = impl_from_ISWbemServices( iface );
1536     ITypeInfo *typeinfo;
1537     HRESULT hr;
1538
1539     TRACE( "%p, %s, %p, %u, %u, %p\n", services, debugstr_guid(riid), names, count, lcid, dispid );
1540
1541     if (!names || !count || !dispid) return E_INVALIDARG;
1542
1543     hr = get_typeinfo( ISWbemServices_tid, &typeinfo );
1544     if (SUCCEEDED(hr))
1545     {
1546         hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
1547         ITypeInfo_Release( typeinfo );
1548     }
1549     return hr;
1550 }
1551
1552 static HRESULT WINAPI services_Invoke(
1553     ISWbemServices *iface,
1554     DISPID member,
1555     REFIID riid,
1556     LCID lcid,
1557     WORD flags,
1558     DISPPARAMS *params,
1559     VARIANT *result,
1560     EXCEPINFO *excep_info,
1561     UINT *arg_err )
1562 {
1563     struct services *services = impl_from_ISWbemServices( iface );
1564     ITypeInfo *typeinfo;
1565     HRESULT hr;
1566
1567     TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", services, member, debugstr_guid(riid),
1568            lcid, flags, params, result, excep_info, arg_err );
1569
1570     hr = get_typeinfo( ISWbemServices_tid, &typeinfo );
1571     if (SUCCEEDED(hr))
1572     {
1573         hr = ITypeInfo_Invoke( typeinfo, &services->ISWbemServices_iface, member, flags,
1574                                params, result, excep_info, arg_err );
1575         ITypeInfo_Release( typeinfo );
1576     }
1577     return hr;
1578 }
1579
1580 static HRESULT WINAPI services_Get(
1581     ISWbemServices *iface,
1582     BSTR strObjectPath,
1583     LONG iFlags,
1584     IDispatch *objWbemNamedValueSet,
1585     ISWbemObject **objWbemObject )
1586 {
1587     struct services *services = impl_from_ISWbemServices( iface );
1588     IWbemClassObject *obj;
1589     HRESULT hr;
1590
1591     TRACE( "%p, %s, %d, %p, %p\n", iface, debugstr_w(strObjectPath), iFlags, objWbemNamedValueSet,
1592            objWbemObject );
1593
1594     if (objWbemNamedValueSet) FIXME( "ignoring context\n" );
1595
1596     hr = IWbemServices_GetObject( services->services, strObjectPath, iFlags, NULL, &obj, NULL );
1597     if (hr != S_OK) return hr;
1598
1599     hr = SWbemObject_create( obj, objWbemObject );
1600     IWbemClassObject_Release( obj );
1601     return hr;
1602 }
1603
1604 static HRESULT WINAPI services_GetAsync(
1605     ISWbemServices *iface,
1606     IDispatch *objWbemSink,
1607     BSTR strObjectPath,
1608     LONG iFlags,
1609     IDispatch *objWbemNamedValueSet,
1610     IDispatch *objWbemAsyncContext )
1611 {
1612     FIXME( "\n" );
1613     return E_NOTIMPL;
1614 }
1615
1616 static HRESULT WINAPI services_Delete(
1617     ISWbemServices *iface,
1618     BSTR strObjectPath,
1619     LONG iFlags,
1620     IDispatch *objWbemNamedValueSet )
1621 {
1622     FIXME( "\n" );
1623     return E_NOTIMPL;
1624 }
1625
1626 static HRESULT WINAPI services_DeleteAsync(
1627     ISWbemServices* This,
1628     IDispatch *objWbemSink,
1629     BSTR strObjectPath,
1630     LONG iFlags,
1631     IDispatch *objWbemNamedValueSet,
1632     IDispatch *objWbemAsyncContext )
1633 {
1634     FIXME( "\n" );
1635     return E_NOTIMPL;
1636 }
1637
1638 static BSTR build_query_string( const WCHAR *class )
1639 {
1640     static const WCHAR selectW[] = {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',0};
1641     UINT len = strlenW(class) + sizeof(selectW) / sizeof(selectW[0]);
1642     BSTR ret;
1643
1644     if (!(ret = SysAllocStringLen( NULL, len ))) return NULL;
1645     strcpyW( ret, selectW );
1646     strcatW( ret, class );
1647     return ret;
1648 }
1649
1650 static HRESULT WINAPI services_InstancesOf(
1651     ISWbemServices *iface,
1652     BSTR strClass,
1653     LONG iFlags,
1654     IDispatch *objWbemNamedValueSet,
1655     ISWbemObjectSet **objWbemObjectSet )
1656 {
1657     static const WCHAR wqlW[] = {'W','Q','L',0};
1658     BSTR query, wql = SysAllocString( wqlW );
1659     HRESULT hr;
1660
1661     TRACE( "%p, %s, %x, %p, %p\n", iface, debugstr_w(strClass), iFlags, objWbemNamedValueSet,
1662            objWbemObjectSet );
1663
1664     if (!(query = build_query_string( strClass )))
1665     {
1666         SysFreeString( wql );
1667         return E_OUTOFMEMORY;
1668     }
1669     hr = ISWbemServices_ExecQuery( iface, query, wql, iFlags, objWbemNamedValueSet, objWbemObjectSet );
1670     SysFreeString( wql );
1671     SysFreeString( query );
1672     return hr;
1673 }
1674
1675 static HRESULT WINAPI services_InstancesOfAsync(
1676     ISWbemServices *iface,
1677     IDispatch *objWbemSink,
1678     BSTR strClass,
1679     LONG iFlags,
1680     IDispatch *objWbemNamedValueSet,
1681     IDispatch *objWbemAsyncContext )
1682 {
1683     FIXME( "\n" );
1684     return E_NOTIMPL;
1685 }
1686
1687 static HRESULT WINAPI services_SubclassesOf(
1688     ISWbemServices *iface,
1689     BSTR strSuperclass,
1690     LONG iFlags,
1691     IDispatch *objWbemNamedValueSet,
1692     ISWbemObjectSet **objWbemObjectSet )
1693 {
1694     FIXME( "\n" );
1695     return E_NOTIMPL;
1696 }
1697
1698 static HRESULT WINAPI services_SubclassesOfAsync(
1699     ISWbemServices *iface,
1700     IDispatch *objWbemSink,
1701     BSTR strSuperclass,
1702     LONG iFlags,
1703     IDispatch *objWbemNamedValueSet,
1704     IDispatch *objWbemAsyncContext )
1705 {
1706     FIXME( "\n" );
1707     return E_NOTIMPL;
1708 }
1709
1710 static HRESULT WINAPI services_ExecQuery(
1711     ISWbemServices *iface,
1712     BSTR strQuery,
1713     BSTR strQueryLanguage,
1714     LONG iFlags,
1715     IDispatch *objWbemNamedValueSet,
1716     ISWbemObjectSet **objWbemObjectSet )
1717 {
1718     struct services *services = impl_from_ISWbemServices( iface );
1719     IEnumWbemClassObject *iter;
1720     HRESULT hr;
1721
1722     TRACE( "%p, %s, %s, %x, %p, %p\n", iface, debugstr_w(strQuery), debugstr_w(strQueryLanguage),
1723            iFlags, objWbemNamedValueSet, objWbemObjectSet );
1724
1725     if (objWbemNamedValueSet) FIXME( "ignoring context\n" );
1726
1727     hr = IWbemServices_ExecQuery( services->services, strQueryLanguage, strQuery, iFlags, NULL, &iter );
1728     if (hr != S_OK) return hr;
1729
1730     hr = SWbemObjectSet_create( iter, objWbemObjectSet );
1731     IEnumWbemClassObject_Release( iter );
1732     return hr;
1733 }
1734
1735 static HRESULT WINAPI services_ExecQueryAsync(
1736     ISWbemServices *iface,
1737     IDispatch *objWbemSink,
1738     BSTR strQuery,
1739     BSTR strQueryLanguage,
1740     LONG lFlags,
1741     IDispatch *objWbemNamedValueSet,
1742     IDispatch *objWbemAsyncContext )
1743 {
1744     FIXME( "\n" );
1745     return E_NOTIMPL;
1746 }
1747
1748 static HRESULT WINAPI services_AssociatorsOf(
1749     ISWbemServices *iface,
1750     BSTR strObjectPath,
1751     BSTR strAssocClass,
1752     BSTR strResultClass,
1753     BSTR strResultRole,
1754     BSTR strRole,
1755     VARIANT_BOOL bClassesOnly,
1756     VARIANT_BOOL bSchemaOnly,
1757     BSTR strRequiredAssocQualifier,
1758     BSTR strRequiredQualifier,
1759     LONG iFlags,
1760     IDispatch *objWbemNamedValueSet,
1761     ISWbemObjectSet **objWbemObjectSet )
1762 {
1763     FIXME( "\n" );
1764     return E_NOTIMPL;
1765 }
1766
1767 static HRESULT WINAPI services_AssociatorsOfAsync(
1768     ISWbemServices *iface,
1769     IDispatch *objWbemSink,
1770     BSTR strObjectPath,
1771     BSTR strAssocClass,
1772     BSTR strResultClass,
1773     BSTR strResultRole,
1774     BSTR strRole,
1775     VARIANT_BOOL bClassesOnly,
1776     VARIANT_BOOL bSchemaOnly,
1777     BSTR strRequiredAssocQualifier,
1778     BSTR strRequiredQualifier,
1779     LONG iFlags,
1780     IDispatch *objWbemNamedValueSet,
1781     IDispatch *objWbemAsyncContext )
1782 {
1783     FIXME( "\n" );
1784     return E_NOTIMPL;
1785 }
1786
1787 static HRESULT WINAPI services_ReferencesTo(
1788     ISWbemServices *iface,
1789     BSTR strObjectPath,
1790     BSTR strResultClass,
1791     BSTR strRole,
1792     VARIANT_BOOL bClassesOnly,
1793     VARIANT_BOOL bSchemaOnly,
1794     BSTR strRequiredQualifier,
1795     LONG iFlags,
1796     IDispatch *objWbemNamedValueSet,
1797     ISWbemObjectSet **objWbemObjectSet )
1798 {
1799     FIXME( "\n" );
1800     return E_NOTIMPL;
1801 }
1802
1803 static HRESULT WINAPI services_ReferencesToAsync(
1804     ISWbemServices *iface,
1805     IDispatch *objWbemSink,
1806     BSTR strObjectPath,
1807     BSTR strResultClass,
1808     BSTR strRole,
1809     VARIANT_BOOL bClassesOnly,
1810     VARIANT_BOOL bSchemaOnly,
1811     BSTR strRequiredQualifier,
1812     LONG iFlags,
1813     IDispatch *objWbemNamedValueSet,
1814     IDispatch *objWbemAsyncContext )
1815 {
1816     FIXME( "\n" );
1817     return E_NOTIMPL;
1818 }
1819
1820 static HRESULT WINAPI services_ExecNotificationQuery(
1821     ISWbemServices *iface,
1822     BSTR strQuery,
1823     BSTR strQueryLanguage,
1824     LONG iFlags,
1825     IDispatch *objWbemNamedValueSet,
1826     ISWbemEventSource **objWbemEventSource )
1827 {
1828     FIXME( "\n" );
1829     return E_NOTIMPL;
1830 }
1831
1832 static HRESULT WINAPI services_ExecNotificationQueryAsync(
1833     ISWbemServices *iface,
1834     IDispatch *objWbemSink,
1835     BSTR strQuery,
1836     BSTR strQueryLanguage,
1837     LONG iFlags,
1838     IDispatch *objWbemNamedValueSet,
1839     IDispatch *objWbemAsyncContext )
1840 {
1841     FIXME( "\n" );
1842     return E_NOTIMPL;
1843 }
1844
1845 static HRESULT WINAPI services_ExecMethod(
1846     ISWbemServices *iface,
1847     BSTR strObjectPath,
1848     BSTR strMethodName,
1849     IDispatch *objWbemInParameters,
1850     LONG iFlags,
1851     IDispatch *objWbemNamedValueSet,
1852     ISWbemObject **objWbemOutParameters )
1853 {
1854     FIXME( "\n" );
1855     return E_NOTIMPL;
1856 }
1857
1858 static HRESULT WINAPI services_ExecMethodAsync(
1859     ISWbemServices *iface,
1860     IDispatch *objWbemSink,
1861     BSTR strObjectPath,
1862     BSTR strMethodName,
1863     IDispatch *objWbemInParameters,
1864     LONG iFlags,
1865     IDispatch *objWbemNamedValueSet,
1866     IDispatch *objWbemAsyncContext )
1867 {
1868     FIXME( "\n" );
1869     return E_NOTIMPL;
1870 }
1871
1872 static HRESULT WINAPI services_get_Security_(
1873         ISWbemServices *iface,
1874         ISWbemSecurity **objWbemSecurity )
1875 {
1876     FIXME( "\n" );
1877     return E_NOTIMPL;
1878 }
1879
1880 static const ISWbemServicesVtbl services_vtbl =
1881 {
1882     services_QueryInterface,
1883     services_AddRef,
1884     services_Release,
1885     services_GetTypeInfoCount,
1886     services_GetTypeInfo,
1887     services_GetIDsOfNames,
1888     services_Invoke,
1889     services_Get,
1890     services_GetAsync,
1891     services_Delete,
1892     services_DeleteAsync,
1893     services_InstancesOf,
1894     services_InstancesOfAsync,
1895     services_SubclassesOf,
1896     services_SubclassesOfAsync,
1897     services_ExecQuery,
1898     services_ExecQueryAsync,
1899     services_AssociatorsOf,
1900     services_AssociatorsOfAsync,
1901     services_ReferencesTo,
1902     services_ReferencesToAsync,
1903     services_ExecNotificationQuery,
1904     services_ExecNotificationQueryAsync,
1905     services_ExecMethod,
1906     services_ExecMethodAsync,
1907     services_get_Security_
1908 };
1909
1910 static HRESULT SWbemServices_create( IWbemServices *wbem_services, ISWbemServices **obj )
1911 {
1912     struct services *services;
1913
1914     TRACE( "%p, %p\n", obj, wbem_services );
1915
1916     if (!(services = heap_alloc( sizeof(*services) ))) return E_OUTOFMEMORY;
1917     services->ISWbemServices_iface.lpVtbl = &services_vtbl;
1918     services->refs = 1;
1919     services->services = wbem_services;
1920     IWbemServices_AddRef( services->services );
1921
1922     *obj = &services->ISWbemServices_iface;
1923     TRACE( "returning iface %p\n", *obj );
1924     return S_OK;
1925 }
1926
1927 struct locator
1928 {
1929     ISWbemLocator ISWbemLocator_iface;
1930     LONG refs;
1931     IWbemLocator *locator;
1932 };
1933
1934 static inline struct locator *impl_from_ISWbemLocator( ISWbemLocator *iface )
1935 {
1936     return CONTAINING_RECORD( iface, struct locator, ISWbemLocator_iface );
1937 }
1938
1939 static ULONG WINAPI locator_AddRef(
1940     ISWbemLocator *iface )
1941 {
1942     struct locator *locator = impl_from_ISWbemLocator( iface );
1943     return InterlockedIncrement( &locator->refs );
1944 }
1945
1946 static ULONG WINAPI locator_Release(
1947     ISWbemLocator *iface )
1948 {
1949     struct locator *locator = impl_from_ISWbemLocator( iface );
1950     LONG refs = InterlockedDecrement( &locator->refs );
1951     if (!refs)
1952     {
1953         TRACE( "destroying %p\n", locator );
1954         if (locator->locator)
1955             IWbemLocator_Release( locator->locator );
1956         heap_free( locator );
1957     }
1958     return refs;
1959 }
1960
1961 static HRESULT WINAPI locator_QueryInterface(
1962     ISWbemLocator *iface,
1963     REFIID riid,
1964     void **ppvObject )
1965 {
1966     struct locator *locator = impl_from_ISWbemLocator( iface );
1967
1968     TRACE( "%p, %s, %p\n", locator, debugstr_guid( riid ), ppvObject );
1969
1970     if (IsEqualGUID( riid, &IID_ISWbemLocator ) ||
1971         IsEqualGUID( riid, &IID_IDispatch ) ||
1972         IsEqualGUID( riid, &IID_IUnknown ))
1973     {
1974         *ppvObject = iface;
1975     }
1976     else
1977     {
1978         FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
1979         return E_NOINTERFACE;
1980     }
1981     ISWbemLocator_AddRef( iface );
1982     return S_OK;
1983 }
1984
1985 static HRESULT WINAPI locator_GetTypeInfoCount(
1986     ISWbemLocator *iface,
1987     UINT *count )
1988 {
1989     struct locator *locator = impl_from_ISWbemLocator( iface );
1990
1991     TRACE( "%p, %p\n", locator, count );
1992     *count = 1;
1993     return S_OK;
1994 }
1995
1996 static HRESULT WINAPI locator_GetTypeInfo(
1997     ISWbemLocator *iface,
1998     UINT index,
1999     LCID lcid,
2000     ITypeInfo **info )
2001 {
2002     struct locator *locator = impl_from_ISWbemLocator( iface );
2003     TRACE( "%p, %u, %u, %p\n", locator, index, lcid, info );
2004
2005     return get_typeinfo( ISWbemLocator_tid, info );
2006 }
2007
2008 static HRESULT WINAPI locator_GetIDsOfNames(
2009     ISWbemLocator *iface,
2010     REFIID riid,
2011     LPOLESTR *names,
2012     UINT count,
2013     LCID lcid,
2014     DISPID *dispid )
2015 {
2016     struct locator *locator = impl_from_ISWbemLocator( iface );
2017     ITypeInfo *typeinfo;
2018     HRESULT hr;
2019
2020     TRACE( "%p, %s, %p, %u, %u, %p\n", locator, debugstr_guid(riid), names, count, lcid, dispid );
2021
2022     if (!names || !count || !dispid) return E_INVALIDARG;
2023
2024     hr = get_typeinfo( ISWbemLocator_tid, &typeinfo );
2025     if (SUCCEEDED(hr))
2026     {
2027         hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
2028         ITypeInfo_Release( typeinfo );
2029     }
2030     return hr;
2031 }
2032
2033 static HRESULT WINAPI locator_Invoke(
2034     ISWbemLocator *iface,
2035     DISPID member,
2036     REFIID riid,
2037     LCID lcid,
2038     WORD flags,
2039     DISPPARAMS *params,
2040     VARIANT *result,
2041     EXCEPINFO *excep_info,
2042     UINT *arg_err )
2043 {
2044     struct locator *locator = impl_from_ISWbemLocator( iface );
2045     ITypeInfo *typeinfo;
2046     HRESULT hr;
2047
2048     TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", locator, member, debugstr_guid(riid),
2049            lcid, flags, params, result, excep_info, arg_err );
2050
2051     hr = get_typeinfo( ISWbemLocator_tid, &typeinfo );
2052     if (SUCCEEDED(hr))
2053     {
2054         hr = ITypeInfo_Invoke( typeinfo, &locator->ISWbemLocator_iface, member, flags,
2055                                params, result, excep_info, arg_err );
2056         ITypeInfo_Release( typeinfo );
2057     }
2058     return hr;
2059 }
2060
2061 static BSTR build_resource_string( BSTR server, BSTR namespace )
2062 {
2063     static const WCHAR defaultW[] = {'r','o','o','t','\\','d','e','f','a','u','l','t',0};
2064     ULONG len, len_server = 0, len_namespace = 0;
2065     BSTR ret;
2066
2067     if (server && *server) len_server = strlenW( server );
2068     else len_server = 1;
2069     if (namespace && *namespace) len_namespace = strlenW( namespace );
2070     else len_namespace = sizeof(defaultW) / sizeof(defaultW[0]) - 1;
2071
2072     if (!(ret = SysAllocStringLen( NULL, 2 + len_server + 1 + len_namespace ))) return NULL;
2073
2074     ret[0] = ret[1] = '\\';
2075     if (server && *server) strcpyW( ret + 2, server );
2076     else ret[2] = '.';
2077
2078     len = len_server + 2;
2079     ret[len++] = '\\';
2080
2081     if (namespace && *namespace) strcpyW( ret + len, namespace );
2082     else strcpyW( ret + len, defaultW );
2083     return ret;
2084 }
2085
2086 static HRESULT WINAPI locator_ConnectServer(
2087     ISWbemLocator *iface,
2088     BSTR strServer,
2089     BSTR strNamespace,
2090     BSTR strUser,
2091     BSTR strPassword,
2092     BSTR strLocale,
2093     BSTR strAuthority,
2094     LONG iSecurityFlags,
2095     IDispatch *objWbemNamedValueSet,
2096     ISWbemServices **objWbemServices )
2097 {
2098     struct locator *locator = impl_from_ISWbemLocator( iface );
2099     IWbemServices *services;
2100     BSTR resource;
2101     HRESULT hr;
2102
2103     TRACE( "%p, %s, %s, %s, %p, %s, %s, 0x%08x, %p, %p\n", iface, debugstr_w(strServer),
2104            debugstr_w(strNamespace), debugstr_w(strUser), strPassword, debugstr_w(strLocale),
2105            debugstr_w(strAuthority), iSecurityFlags, objWbemNamedValueSet, objWbemServices );
2106
2107     if (objWbemNamedValueSet) FIXME( "context not supported\n" );
2108
2109     if (!locator->locator)
2110     {
2111         hr = CoCreateInstance( &CLSID_WbemLocator, NULL, CLSCTX_INPROC_SERVER, &IID_IWbemLocator,
2112                                (void **)&locator->locator );
2113         if (hr != S_OK) return hr;
2114     }
2115
2116     if (!(resource = build_resource_string( strServer, strNamespace ))) return E_OUTOFMEMORY;
2117     hr = IWbemLocator_ConnectServer( locator->locator, resource, strUser, strPassword, strLocale,
2118                                      iSecurityFlags, strAuthority, NULL, &services );
2119     SysFreeString( resource );
2120     if (hr != S_OK) return hr;
2121
2122     hr = SWbemServices_create( services, objWbemServices );
2123     IWbemServices_Release( services );
2124     return hr;
2125 }
2126
2127 static HRESULT WINAPI locator_get_Security_(
2128     ISWbemLocator *iface,
2129     ISWbemSecurity **objWbemSecurity )
2130 {
2131     FIXME( "%p, %p\n", iface, objWbemSecurity );
2132     return E_NOTIMPL;
2133 }
2134
2135 static const ISWbemLocatorVtbl locator_vtbl =
2136 {
2137     locator_QueryInterface,
2138     locator_AddRef,
2139     locator_Release,
2140     locator_GetTypeInfoCount,
2141     locator_GetTypeInfo,
2142     locator_GetIDsOfNames,
2143     locator_Invoke,
2144     locator_ConnectServer,
2145     locator_get_Security_
2146 };
2147
2148 HRESULT SWbemLocator_create( void **obj )
2149 {
2150     struct locator *locator;
2151
2152     TRACE( "%p\n", obj );
2153
2154     if (!(locator = heap_alloc( sizeof(*locator) ))) return E_OUTOFMEMORY;
2155     locator->ISWbemLocator_iface.lpVtbl = &locator_vtbl;
2156     locator->refs = 1;
2157     locator->locator = NULL;
2158
2159     *obj = &locator->ISWbemLocator_iface;
2160     TRACE( "returning iface %p\n", *obj );
2161     return S_OK;
2162 }