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