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     ISWbemServices_tid,
  47     last_tid
  48 };
  49
  50 static ITypeLib *wbemdisp_typelib;
  51 static ITypeInfo *wbemdisp_typeinfo[last_tid];
  52
  53 static REFIID wbemdisp_tid_id[] =
  54 {
  55     &IID_ISWbemLocator,
  56     &IID_ISWbemObject,
  57     &IID_ISWbemObjectSet,
  58     &IID_ISWbemServices
  59 };
  60
  61 static HRESULT get_typeinfo( enum type_id tid, ITypeInfo **ret )
  62 {
  63     HRESULT hr;
  64
  65     if (!wbemdisp_typelib)
  66     {
  67         ITypeLib *typelib;
  68
  69         hr = LoadRegTypeLib( &LIBID_WbemScripting, 1, 2, LOCALE_SYSTEM_DEFAULT, &typelib );
  70         if (FAILED( hr ))
  71         {
  72             ERR( "LoadRegTypeLib failed: %08x\n", hr );
  73             return hr;
  74         }
  75         if (InterlockedCompareExchangePointer( (void **)&wbemdisp_typelib, typelib, NULL ))
  76             ITypeLib_Release( typelib );
  77     }
  78     if (!wbemdisp_typeinfo[tid])
  79     {
  80         ITypeInfo *typeinfo;
  81
  82         hr = ITypeLib_GetTypeInfoOfGuid( wbemdisp_typelib, wbemdisp_tid_id[tid], &typeinfo );
  83         if (FAILED( hr ))
  84         {
  85             ERR( "GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_guid(wbemdisp_tid_id[tid]), hr );
  86             return hr;
  87         }
  88         if (InterlockedCompareExchangePointer( (void **)(wbemdisp_typeinfo + tid), typeinfo, NULL ))
  89             ITypeInfo_Release( typeinfo );
  90     }
  91     *ret = wbemdisp_typeinfo[tid];
  92     ITypeInfo_AddRef( *ret );
  93     return S_OK;
  94 }
  95
  96 #define DISPID_BASE 0x1800000
  97
  98 struct member
  99 {
 100     BSTR name;
 101     DISPID dispid;
 102 };
 103
 104 struct object
 105 {
 106     ISWbemObject ISWbemObject_iface;
 107     LONG refs;
 108     IWbemClassObject *object;
 109     struct member *members;
 110     UINT nb_members;
 111     DISPID last_dispid;
 112 };
 113
 114 static inline struct object *impl_from_ISWbemObject(
 115     ISWbemObject *iface )
 116 {
 117     return CONTAINING_RECORD( iface, struct object, ISWbemObject_iface );
 118 }
 119
 120 static ULONG WINAPI object_AddRef(
 121     ISWbemObject *iface )
 122 {
 123     struct object *object = impl_from_ISWbemObject( iface );
 124     return InterlockedIncrement( &object->refs );
 125 }
 126
 127 static ULONG WINAPI object_Release(
 128     ISWbemObject *iface )
 129 {
 130     struct object *object = impl_from_ISWbemObject( iface );
 131     LONG refs = InterlockedDecrement( &object->refs );
 132     if (!refs)
 133     {
 134         UINT i;
 135
 136         TRACE( "destroying %p\n", object );
 137         IWbemClassObject_Release( object->object );
 138         for (i = 0; i < object->nb_members; i++) SysFreeString( object->members[i].name );
 139         heap_free( object->members );
 140         heap_free( object );
 141     }
 142     return refs;
 143 }
 144
 145 static HRESULT WINAPI object_QueryInterface(
 146     ISWbemObject *iface,
 147     REFIID riid,
 148     void **ppvObject )
 149 {
 150     struct object *object = impl_from_ISWbemObject( iface );
 151
 152     TRACE( "%p %s %p\n", object, debugstr_guid(riid), ppvObject );
 153
 154     if (IsEqualGUID( riid, &IID_ISWbemObject ) ||
 155         IsEqualGUID( riid, &IID_IDispatch ) ||
 156         IsEqualGUID( riid, &IID_IUnknown ))
 157     {
 158         *ppvObject = object;
 159     }
 160     else
 161     {
 162         FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
 163         return E_NOINTERFACE;
 164     }
 165     ISWbemObject_AddRef( iface );
 166     return S_OK;
 167 }
 168
 169 static HRESULT WINAPI object_GetTypeInfoCount(
 170     ISWbemObject *iface,
 171     UINT *count )
 172 {
 173     struct object *object = impl_from_ISWbemObject( iface );
 174
 175     TRACE( "%p, %p\n", object, count );
 176     *count = 1;
 177     return S_OK;
 178 }
 179
 180 static HRESULT WINAPI object_GetTypeInfo(
 181     ISWbemObject *iface,
 182     UINT index,
 183     LCID lcid,
 184     ITypeInfo **info )
 185 {
 186     struct object *object = impl_from_ISWbemObject( iface );
 187     FIXME( "%p, %u, %u, %p\n", object, index, lcid, info );
 188     return E_NOTIMPL;
 189 }
 190
 191 #define DISPID_BASE 0x1800000
 192
 193 static HRESULT init_members( struct object *object )
 194 {
 195     LONG bound, i;
 196     SAFEARRAY *sa;
 197     HRESULT hr;
 198
 199     if (object->members) return S_OK;
 200
 201     hr = IWbemClassObject_GetNames( object->object, NULL, 0, NULL, &sa );
 202     if (FAILED( hr )) return hr;
 203     hr = SafeArrayGetUBound( sa, 1, &bound );
 204     if (FAILED( hr ))
 205     {
 206         SafeArrayDestroy( sa );
 207         return hr;
 208     }
 209     if (!(object->members = heap_alloc( sizeof(struct member) * (bound + 1) )))
 210     {
 211         SafeArrayDestroy( sa );
 212         return E_OUTOFMEMORY;
 213     }
 214     for (i = 0; i <= bound; i++)
 215     {
 216         hr = SafeArrayGetElement( sa, &i, &object->members[i].name );
 217         if (FAILED( hr ))
 218         {
 219             for (i--; i >= 0; i--) SysFreeString( object->members[i].name );
 220             SafeArrayDestroy( sa );
 221             heap_free( object->members );
 222             object->members = NULL;
 223             return E_OUTOFMEMORY;
 224         }
 225         object->members[i].dispid = 0;
 226     }
 227     object->nb_members = bound + 1;
 228     SafeArrayDestroy( sa );
 229     return S_OK;
 230 }
 231
 232 static DISPID get_member_dispid( struct object *object, const WCHAR *name )
 233 {
 234     UINT i;
 235     for (i = 0; i < object->nb_members; i++)
 236     {
 237         if (!strcmpiW( object->members[i].name, name ))
 238         {
 239             if (!object->members[i].dispid) object->members[i].dispid = ++object->last_dispid;
 240             return object->members[i].dispid;
 241         }
 242     }
 243     return DISPID_UNKNOWN;
 244 }
 245
 246 static HRESULT WINAPI object_GetIDsOfNames(
 247     ISWbemObject *iface,
 248     REFIID riid,
 249     LPOLESTR *names,
 250     UINT count,
 251     LCID lcid,
 252     DISPID *dispid )
 253 {
 254     struct object *object = impl_from_ISWbemObject( iface );
 255     HRESULT hr;
 256     UINT i;
 257
 258     TRACE( "%p, %s, %p, %u, %u, %p\n", object, debugstr_guid(riid), names, count, lcid, dispid );
 259
 260     if (!names || !count || !dispid) return E_INVALIDARG;
 261
 262     hr = init_members( object );
 263     if (FAILED( hr )) return hr;
 264
 265     for (i = 0; i < count; i++)
 266     {
 267         if ((dispid[i] = get_member_dispid( object, names[i] )) == DISPID_UNKNOWN) break;
 268     }
 269     if (i != count) return DISP_E_UNKNOWNNAME;
 270     return S_OK;
 271 }
 272
 273 static BSTR get_member_name( struct object *object, DISPID dispid )
 274 {
 275     UINT i;
 276     for (i = 0; i < object->nb_members; i++)
 277     {
 278         if (object->members[i].dispid == dispid) return object->members[i].name;
 279     }
 280     return NULL;
 281 }
 282
 283 static HRESULT WINAPI object_Invoke(
 284     ISWbemObject *iface,
 285     DISPID member,
 286     REFIID riid,
 287     LCID lcid,
 288     WORD flags,
 289     DISPPARAMS *params,
 290     VARIANT *result,
 291     EXCEPINFO *excep_info,
 292     UINT *arg_err )
 293 {
 294     struct object *object = impl_from_ISWbemObject( iface );
 295     BSTR name;
 296
 297     TRACE( "%p, %x, %s, %u, %x, %p, %p, %p, %p\n", object, member, debugstr_guid(riid),
 298            lcid, flags, params, result, excep_info, arg_err );
 299
 300     if (flags != (DISPATCH_METHOD|DISPATCH_PROPERTYGET))
 301     {
 302         FIXME( "flags %x not supported\n", flags );
 303         return E_NOTIMPL;
 304     }
 305     if (!(name = get_member_name( object, member )))
 306         return DISP_E_MEMBERNOTFOUND;
 307
 308     memset( params, 0, sizeof(*params) );
 309     return IWbemClassObject_Get( object->object, name, 0, result, NULL, NULL );
 310 }
 311
 312 static HRESULT WINAPI object_Put_(
 313     ISWbemObject *iface,
 314     LONG iFlags,
 315     IDispatch *objWbemNamedValueSet,
 316     ISWbemObjectPath **objWbemObjectPath )
 317 {
 318     FIXME( "\n" );
 319     return E_NOTIMPL;
 320 }
 321
 322 static const ISWbemObjectVtbl object_vtbl =
 323 {
 324     object_QueryInterface,
 325     object_AddRef,
 326     object_Release,
 327     object_GetTypeInfoCount,
 328     object_GetTypeInfo,
 329     object_GetIDsOfNames,
 330     object_Invoke,
 331     object_Put_
 332 };
 333
 334 static HRESULT SWbemObject_create( IWbemClassObject *wbem_object, ISWbemObject **obj )
 335 {
 336     struct object *object;
 337
 338     TRACE( "%p, %p\n", obj, wbem_object );
 339
 340     if (!(object = heap_alloc( sizeof(*object) ))) return E_OUTOFMEMORY;
 341     object->ISWbemObject_iface.lpVtbl = &object_vtbl;
 342     object->refs = 1;
 343     object->object = wbem_object;
 344     IWbemClassObject_AddRef( object->object );
 345     object->members = NULL;
 346     object->nb_members = 0;
 347     object->last_dispid = DISPID_BASE;
 348
 349     *obj = &object->ISWbemObject_iface;
 350     TRACE( "returning iface %p\n", *obj );
 351     return S_OK;
 352 }
 353
 354 struct objectset
 355 {
 356     ISWbemObjectSet ISWbemObjectSet_iface;
 357     LONG refs;
 358     IEnumWbemClassObject *objectenum;
 359 };
 360
 361 static inline struct objectset *impl_from_ISWbemObjectSet(
 362     ISWbemObjectSet *iface )
 363 {
 364     return CONTAINING_RECORD( iface, struct objectset, ISWbemObjectSet_iface );
 365 }
 366
 367 static ULONG WINAPI objectset_AddRef(
 368     ISWbemObjectSet *iface )
 369 {
 370     struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
 371     return InterlockedIncrement( &objectset->refs );
 372 }
 373
 374 static ULONG WINAPI objectset_Release(
 375     ISWbemObjectSet *iface )
 376 {
 377     struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
 378     LONG refs = InterlockedDecrement( &objectset->refs );
 379     if (!refs)
 380     {
 381         TRACE( "destroying %p\n", objectset );
 382         IEnumWbemClassObject_Release( objectset->objectenum );
 383         heap_free( objectset );
 384     }
 385     return refs;
 386 }
 387
 388 static HRESULT WINAPI objectset_QueryInterface(
 389     ISWbemObjectSet *iface,
 390     REFIID riid,
 391     void **ppvObject )
 392 {
 393     struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
 394
 395     TRACE( "%p %s %p\n", objectset, debugstr_guid(riid), ppvObject );
 396
 397     if (IsEqualGUID( riid, &IID_ISWbemObjectSet ) ||
 398         IsEqualGUID( riid, &IID_IDispatch ) ||
 399         IsEqualGUID( riid, &IID_IUnknown ))
 400     {
 401         *ppvObject = objectset;
 402     }
 403     else
 404     {
 405         FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
 406         return E_NOINTERFACE;
 407     }
 408     ISWbemObjectSet_AddRef( iface );
 409     return S_OK;
 410 }
 411
 412 static HRESULT WINAPI objectset_GetTypeInfoCount(
 413     ISWbemObjectSet *iface,
 414     UINT *count )
 415 {
 416     struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
 417     TRACE( "%p, %p\n", objectset, count );
 418     *count = 1;
 419     return S_OK;
 420 }
 421
 422 static HRESULT WINAPI objectset_GetTypeInfo(
 423     ISWbemObjectSet *iface,
 424     UINT index,
 425     LCID lcid,
 426     ITypeInfo **info )
 427 {
 428     struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
 429     TRACE( "%p, %u, %u, %p\n", objectset, index, lcid, info );
 430
 431     return get_typeinfo( ISWbemObjectSet_tid, info );
 432 }
 433
 434 static HRESULT WINAPI objectset_GetIDsOfNames(
 435     ISWbemObjectSet *iface,
 436     REFIID riid,
 437     LPOLESTR *names,
 438     UINT count,
 439     LCID lcid,
 440     DISPID *dispid )
 441 {
 442     struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
 443     ITypeInfo *typeinfo;
 444     HRESULT hr;
 445
 446     TRACE( "%p, %s, %p, %u, %u, %p\n", objectset, debugstr_guid(riid), names, count, lcid, dispid );
 447
 448     if (!names || !count || !dispid) return E_INVALIDARG;
 449
 450     hr = get_typeinfo( ISWbemObjectSet_tid, &typeinfo );
 451     if (SUCCEEDED(hr))
 452     {
 453         hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
 454         ITypeInfo_Release( typeinfo );
 455     }
 456     return hr;
 457 }
 458
 459 static HRESULT WINAPI objectset_Invoke(
 460     ISWbemObjectSet *iface,
 461     DISPID member,
 462     REFIID riid,
 463     LCID lcid,
 464     WORD flags,
 465     DISPPARAMS *params,
 466     VARIANT *result,
 467     EXCEPINFO *excep_info,
 468     UINT *arg_err )
 469 {
 470     struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
 471     ITypeInfo *typeinfo;
 472     HRESULT hr;
 473
 474     TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", objectset, member, debugstr_guid(riid),
 475            lcid, flags, params, result, excep_info, arg_err );
 476
 477     hr = get_typeinfo( ISWbemObjectSet_tid, &typeinfo );
 478     if (SUCCEEDED(hr))
 479     {
 480         hr = ITypeInfo_Invoke( typeinfo, &objectset->ISWbemObjectSet_iface, member, flags,
 481                                params, result, excep_info, arg_err );
 482         ITypeInfo_Release( typeinfo );
 483     }
 484     return hr;
 485 }
 486
 487 static HRESULT WINAPI objectset_get__NewEnum(
 488     ISWbemObjectSet *iface,
 489     IUnknown **pUnk )
 490 {
 491     struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
 492     IEnumWbemClassObject *objectenum;
 493     HRESULT hr;
 494
 495     TRACE( "%p, %p\n", objectset, pUnk );
 496
 497     hr = IEnumWbemClassObject_Clone( objectset->objectenum, &objectenum );
 498     if (FAILED( hr )) return hr;
 499
 500     hr = EnumVARIANT_create( objectenum, (IEnumVARIANT **)pUnk );
 501     IEnumWbemClassObject_Release( objectenum );
 502     return hr;
 503 }
 504
 505 static HRESULT WINAPI objectset_Item(
 506     ISWbemObjectSet *iface,
 507     BSTR strObjectPath,
 508     LONG iFlags,
 509     ISWbemObject **objWbemObject )
 510 {
 511     FIXME( "\n" );
 512     return E_NOTIMPL;
 513 }
 514
 515 static HRESULT WINAPI objectset_get_Count(
 516     ISWbemObjectSet *iface,
 517     LONG *iCount )
 518 {
 519     struct objectset *objectset = impl_from_ISWbemObjectSet( iface );
 520     LONG count = 0, total = 0;
 521
 522     TRACE( "%p, %p\n", objectset, iCount );
 523
 524     while (IEnumWbemClassObject_Skip( objectset->objectenum, WBEM_INFINITE, 1 ) == S_OK) count++;
 525
 526     IEnumWbemClassObject_Reset( objectset->objectenum );
 527     while (IEnumWbemClassObject_Skip( objectset->objectenum, WBEM_INFINITE, 1 ) == S_OK) total++;
 528
 529     count = total - count;
 530     IEnumWbemClassObject_Reset( objectset->objectenum );
 531     while (count--) IEnumWbemClassObject_Skip( objectset->objectenum, WBEM_INFINITE, 1 );
 532
 533     *iCount = total;
 534     return S_OK;
 535 }
 536
 537 static HRESULT WINAPI objectset_get_Security_(
 538     ISWbemObjectSet *iface,
 539     ISWbemSecurity **objWbemSecurity )
 540 {
 541     FIXME( "\n" );
 542     return E_NOTIMPL;
 543 }
 544
 545 static HRESULT WINAPI objectset_ItemIndex(
 546     ISWbemObjectSet *iface,
 547     LONG lIndex,
 548     ISWbemObject **objWbemObject )
 549 {
 550     FIXME( "\n" );
 551     return E_NOTIMPL;
 552 }
 553
 554 static const ISWbemObjectSetVtbl objectset_vtbl =
 555 {
 556     objectset_QueryInterface,
 557     objectset_AddRef,
 558     objectset_Release,
 559     objectset_GetTypeInfoCount,
 560     objectset_GetTypeInfo,
 561     objectset_GetIDsOfNames,
 562     objectset_Invoke,
 563     objectset_get__NewEnum,
 564     objectset_Item,
 565     objectset_get_Count,
 566     objectset_get_Security_,
 567     objectset_ItemIndex
 568 };
 569
 570 static HRESULT SWbemObjectSet_create( IEnumWbemClassObject *wbem_objectenum, ISWbemObjectSet **obj )
 571 {
 572     struct objectset *objectset;
 573
 574     TRACE( "%p, %p\n", obj, wbem_objectenum );
 575
 576     if (!(objectset = heap_alloc( sizeof(*objectset) ))) return E_OUTOFMEMORY;
 577     objectset->ISWbemObjectSet_iface.lpVtbl = &objectset_vtbl;
 578     objectset->refs = 1;
 579     objectset->objectenum = wbem_objectenum;
 580     IEnumWbemClassObject_AddRef( objectset->objectenum );
 581
 582     *obj = &objectset->ISWbemObjectSet_iface;
 583     TRACE( "returning iface %p\n", *obj );
 584     return S_OK;
 585 }
 586
 587 struct enumvar
 588 {
 589     IEnumVARIANT IEnumVARIANT_iface;
 590     LONG refs;
 591     IEnumWbemClassObject *objectenum;
 592 };
 593
 594 static inline struct enumvar *impl_from_IEnumVARIANT(
 595     IEnumVARIANT *iface )
 596 {
 597     return CONTAINING_RECORD( iface, struct enumvar, IEnumVARIANT_iface );
 598 }
 599
 600 static ULONG WINAPI enumvar_AddRef(
 601     IEnumVARIANT *iface )
 602 {
 603     struct enumvar *enumvar = impl_from_IEnumVARIANT( iface );
 604     return InterlockedIncrement( &enumvar->refs );
 605 }
 606
 607 static ULONG WINAPI enumvar_Release(
 608     IEnumVARIANT *iface )
 609 {
 610     struct enumvar *enumvar = impl_from_IEnumVARIANT( iface );
 611     LONG refs = InterlockedDecrement( &enumvar->refs );
 612     if (!refs)
 613     {
 614         TRACE( "destroying %p\n", enumvar );
 615         IEnumWbemClassObject_Release( enumvar->objectenum );
 616         heap_free( enumvar );
 617     }
 618     return refs;
 619 }
 620
 621 static HRESULT WINAPI enumvar_QueryInterface(
 622     IEnumVARIANT *iface,
 623     REFIID riid,
 624     void **ppvObject )
 625 {
 626     struct enumvar *enumvar = impl_from_IEnumVARIANT( iface );
 627
 628     TRACE( "%p %s %p\n", enumvar, debugstr_guid(riid), ppvObject );
 629
 630     if (IsEqualGUID( riid, &IID_IEnumVARIANT ) ||
 631         IsEqualGUID( riid, &IID_IUnknown ))
 632     {
 633         *ppvObject = enumvar;
 634     }
 635     else
 636     {
 637         FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
 638         return E_NOINTERFACE;
 639     }
 640     IEnumVARIANT_AddRef( iface );
 641     return S_OK;
 642 }
 643
 644 static HRESULT WINAPI enumvar_Next( IEnumVARIANT *iface, ULONG celt, VARIANT *var, ULONG *fetched )
 645 {
 646     struct enumvar *enumvar = impl_from_IEnumVARIANT( iface );
 647     IWbemClassObject *obj;
 648     ULONG count = 0;
 649
 650     TRACE( "%p, %u, %p, %p\n", iface, celt, var, fetched );
 651
 652     if (celt) IEnumWbemClassObject_Next( enumvar->objectenum, WBEM_INFINITE, 1, &obj, &count );
 653     if (count)
 654     {
 655         ISWbemObject *sobj;
 656         HRESULT hr;
 657
 658         hr = SWbemObject_create( obj, &sobj );
 659         IWbemClassObject_Release( obj );
 660         if (FAILED( hr )) return hr;
 661
 662         V_VT( var ) = VT_DISPATCH;
 663         V_DISPATCH( var ) = (IDispatch *)sobj;
 664     }
 665     if (fetched) *fetched = count;
 666     return (count < celt) ? S_FALSE : S_OK;
 667 }
 668
 669 static HRESULT WINAPI enumvar_Skip( IEnumVARIANT *iface, ULONG celt )
 670 {
 671     struct enumvar *enumvar = impl_from_IEnumVARIANT( iface );
 672
 673     TRACE( "%p, %u\n", iface, celt );
 674
 675     return IEnumWbemClassObject_Skip( enumvar->objectenum, WBEM_INFINITE, celt );
 676 }
 677
 678 static HRESULT WINAPI enumvar_Reset( IEnumVARIANT *iface )
 679 {
 680     struct enumvar *enumvar = impl_from_IEnumVARIANT( iface );
 681
 682     TRACE( "%p\n", iface );
 683
 684     return IEnumWbemClassObject_Reset( enumvar->objectenum );
 685 }
 686
 687 static HRESULT WINAPI enumvar_Clone( IEnumVARIANT *iface, IEnumVARIANT **penum )
 688 {
 689     FIXME( "%p, %p\n", iface, penum );
 690     return E_NOTIMPL;
 691 }
 692
 693 static const struct IEnumVARIANTVtbl enumvar_vtbl =
 694 {
 695     enumvar_QueryInterface,
 696     enumvar_AddRef,
 697     enumvar_Release,
 698     enumvar_Next,
 699     enumvar_Skip,
 700     enumvar_Reset,
 701     enumvar_Clone
 702 };
 703
 704 static HRESULT EnumVARIANT_create( IEnumWbemClassObject *objectenum, IEnumVARIANT **obj )
 705 {
 706     struct enumvar *enumvar;
 707
 708     if (!(enumvar = heap_alloc( sizeof(*enumvar) ))) return E_OUTOFMEMORY;
 709     enumvar->IEnumVARIANT_iface.lpVtbl = &enumvar_vtbl;
 710     enumvar->refs = 1;
 711     enumvar->objectenum = objectenum;
 712     IEnumWbemClassObject_AddRef( enumvar->objectenum );
 713
 714     *obj = &enumvar->IEnumVARIANT_iface;
 715     TRACE( "returning iface %p\n", *obj );
 716     return S_OK;
 717 }
 718
 719 struct services
 720 {
 721     ISWbemServices ISWbemServices_iface;
 722     LONG refs;
 723     IWbemServices *services;
 724 };
 725
 726 static inline struct services *impl_from_ISWbemServices(
 727     ISWbemServices *iface )
 728 {
 729     return CONTAINING_RECORD( iface, struct services, ISWbemServices_iface );
 730 }
 731
 732 static ULONG WINAPI services_AddRef(
 733     ISWbemServices *iface )
 734 {
 735     struct services *services = impl_from_ISWbemServices( iface );
 736     return InterlockedIncrement( &services->refs );
 737 }
 738
 739 static ULONG WINAPI services_Release(
 740     ISWbemServices *iface )
 741 {
 742     struct services *services = impl_from_ISWbemServices( iface );
 743     LONG refs = InterlockedDecrement( &services->refs );
 744     if (!refs)
 745     {
 746         TRACE( "destroying %p\n", services );
 747         IWbemServices_Release( services->services );
 748         heap_free( services );
 749     }
 750     return refs;
 751 }
 752
 753 static HRESULT WINAPI services_QueryInterface(
 754     ISWbemServices *iface,
 755     REFIID riid,
 756     void **ppvObject )
 757 {
 758     struct services *services = impl_from_ISWbemServices( iface );
 759
 760     TRACE( "%p %s %p\n", services, debugstr_guid(riid), ppvObject );
 761
 762     if (IsEqualGUID( riid, &IID_ISWbemServices ) ||
 763         IsEqualGUID( riid, &IID_IDispatch ) ||
 764         IsEqualGUID( riid, &IID_IUnknown ))
 765     {
 766         *ppvObject = services;
 767     }
 768     else
 769     {
 770         FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
 771         return E_NOINTERFACE;
 772     }
 773     ISWbemServices_AddRef( iface );
 774     return S_OK;
 775 }
 776
 777 static HRESULT WINAPI services_GetTypeInfoCount(
 778     ISWbemServices *iface,
 779     UINT *count )
 780 {
 781     struct services *services = impl_from_ISWbemServices( iface );
 782     TRACE( "%p, %p\n", services, count );
 783
 784     *count = 1;
 785     return S_OK;
 786 }
 787
 788 static HRESULT WINAPI services_GetTypeInfo(
 789     ISWbemServices *iface,
 790     UINT index,
 791     LCID lcid,
 792     ITypeInfo **info )
 793 {
 794     struct services *services = impl_from_ISWbemServices( iface );
 795     TRACE( "%p, %u, %u, %p\n", services, index, lcid, info );
 796
 797     return get_typeinfo( ISWbemServices_tid, info );
 798 }
 799
 800 static HRESULT WINAPI services_GetIDsOfNames(
 801     ISWbemServices *iface,
 802     REFIID riid,
 803     LPOLESTR *names,
 804     UINT count,
 805     LCID lcid,
 806     DISPID *dispid )
 807 {
 808     struct services *services = impl_from_ISWbemServices( iface );
 809     ITypeInfo *typeinfo;
 810     HRESULT hr;
 811
 812     TRACE( "%p, %s, %p, %u, %u, %p\n", services, debugstr_guid(riid), names, count, lcid, dispid );
 813
 814     if (!names || !count || !dispid) return E_INVALIDARG;
 815
 816     hr = get_typeinfo( ISWbemServices_tid, &typeinfo );
 817     if (SUCCEEDED(hr))
 818     {
 819         hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
 820         ITypeInfo_Release( typeinfo );
 821     }
 822     return hr;
 823 }
 824
 825 static HRESULT WINAPI services_Invoke(
 826     ISWbemServices *iface,
 827     DISPID member,
 828     REFIID riid,
 829     LCID lcid,
 830     WORD flags,
 831     DISPPARAMS *params,
 832     VARIANT *result,
 833     EXCEPINFO *excep_info,
 834     UINT *arg_err )
 835 {
 836     struct services *services = impl_from_ISWbemServices( iface );
 837     ITypeInfo *typeinfo;
 838     HRESULT hr;
 839
 840     TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", services, member, debugstr_guid(riid),
 841            lcid, flags, params, result, excep_info, arg_err );
 842
 843     hr = get_typeinfo( ISWbemServices_tid, &typeinfo );
 844     if (SUCCEEDED(hr))
 845     {
 846         hr = ITypeInfo_Invoke( typeinfo, &services->ISWbemServices_iface, member, flags,
 847                                params, result, excep_info, arg_err );
 848         ITypeInfo_Release( typeinfo );
 849     }
 850     return hr;
 851 }
 852
 853 static HRESULT WINAPI services_Get(
 854     ISWbemServices *iface,
 855     BSTR strObjectPath,
 856     LONG iFlags,
 857     IDispatch *objWbemNamedValueSet,
 858     ISWbemObject **objWbemObject )
 859 {
 860     struct services *services = impl_from_ISWbemServices( iface );
 861     IWbemClassObject *obj;
 862     HRESULT hr;
 863
 864     TRACE( "%p, %s, %d, %p, %p\n", iface, debugstr_w(strObjectPath), iFlags, objWbemNamedValueSet,
 865            objWbemObject );
 866
 867     if (objWbemNamedValueSet) FIXME( "ignoring context\n" );
 868
 869     hr = IWbemServices_GetObject( services->services, strObjectPath, iFlags, NULL, &obj, NULL );
 870     if (hr != S_OK) return hr;
 871
 872     hr = SWbemObject_create( obj, objWbemObject );
 873     IWbemClassObject_Release( obj );
 874     return hr;
 875 }
 876
 877 static HRESULT WINAPI services_GetAsync(
 878     ISWbemServices *iface,
 879     IDispatch *objWbemSink,
 880     BSTR strObjectPath,
 881     LONG iFlags,
 882     IDispatch *objWbemNamedValueSet,
 883     IDispatch *objWbemAsyncContext )
 884 {
 885     FIXME( "\n" );
 886     return E_NOTIMPL;
 887 }
 888
 889 static HRESULT WINAPI services_Delete(
 890     ISWbemServices *iface,
 891     BSTR strObjectPath,
 892     LONG iFlags,
 893     IDispatch *objWbemNamedValueSet )
 894 {
 895     FIXME( "\n" );
 896     return E_NOTIMPL;
 897 }
 898
 899 static HRESULT WINAPI services_DeleteAsync(
 900     ISWbemServices* This,
 901     IDispatch *objWbemSink,
 902     BSTR strObjectPath,
 903     LONG iFlags,
 904     IDispatch *objWbemNamedValueSet,
 905     IDispatch *objWbemAsyncContext )
 906 {
 907     FIXME( "\n" );
 908     return E_NOTIMPL;
 909 }
 910
 911 static BSTR build_query_string( const WCHAR *class )
 912 {
 913     static const WCHAR selectW[] = {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',0};
 914     UINT len = strlenW(class) + sizeof(selectW) / sizeof(selectW[0]);
 915     BSTR ret;
 916
 917     if (!(ret = SysAllocStringLen( NULL, len ))) return NULL;
 918     strcpyW( ret, selectW );
 919     strcatW( ret, class );
 920     return ret;
 921 }
 922
 923 static HRESULT WINAPI services_InstancesOf(
 924     ISWbemServices *iface,
 925     BSTR strClass,
 926     LONG iFlags,
 927     IDispatch *objWbemNamedValueSet,
 928     ISWbemObjectSet **objWbemObjectSet )
 929 {
 930     static const WCHAR wqlW[] = {'W','Q','L',0};
 931     BSTR query, wql = SysAllocString( wqlW );
 932     HRESULT hr;
 933
 934     TRACE( "%p, %s, %x, %p, %p\n", iface, debugstr_w(strClass), iFlags, objWbemNamedValueSet,
 935            objWbemObjectSet );
 936
 937     if (!(query = build_query_string( strClass )))
 938     {
 939         SysFreeString( wql );
 940         return E_OUTOFMEMORY;
 941     }
 942     hr = ISWbemServices_ExecQuery( iface, query, wql, iFlags, objWbemNamedValueSet, objWbemObjectSet );
 943     SysFreeString( wql );
 944     SysFreeString( query );
 945     return hr;
 946 }
 947
 948 static HRESULT WINAPI services_InstancesOfAsync(
 949     ISWbemServices *iface,
 950     IDispatch *objWbemSink,
 951     BSTR strClass,
 952     LONG iFlags,
 953     IDispatch *objWbemNamedValueSet,
 954     IDispatch *objWbemAsyncContext )
 955 {
 956     FIXME( "\n" );
 957     return E_NOTIMPL;
 958 }
 959
 960 static HRESULT WINAPI services_SubclassesOf(
 961     ISWbemServices *iface,
 962     BSTR strSuperclass,
 963     LONG iFlags,
 964     IDispatch *objWbemNamedValueSet,
 965     ISWbemObjectSet **objWbemObjectSet )
 966 {
 967     FIXME( "\n" );
 968     return E_NOTIMPL;
 969 }
 970
 971 static HRESULT WINAPI services_SubclassesOfAsync(
 972     ISWbemServices *iface,
 973     IDispatch *objWbemSink,
 974     BSTR strSuperclass,
 975     LONG iFlags,
 976     IDispatch *objWbemNamedValueSet,
 977     IDispatch *objWbemAsyncContext )
 978 {
 979     FIXME( "\n" );
 980     return E_NOTIMPL;
 981 }
 982
 983 static HRESULT WINAPI services_ExecQuery(
 984     ISWbemServices *iface,
 985     BSTR strQuery,
 986     BSTR strQueryLanguage,
 987     LONG iFlags,
 988     IDispatch *objWbemNamedValueSet,
 989     ISWbemObjectSet **objWbemObjectSet )
 990 {
 991     struct services *services = impl_from_ISWbemServices( iface );
 992     IEnumWbemClassObject *iter;
 993     HRESULT hr;
 994
 995     TRACE( "%p, %s, %s, %x, %p, %p\n", iface, debugstr_w(strQuery), debugstr_w(strQueryLanguage),
 996            iFlags, objWbemNamedValueSet, objWbemObjectSet );
 997
 998     if (objWbemNamedValueSet) FIXME( "ignoring context\n" );
 999
1000     hr = IWbemServices_ExecQuery( services->services, strQueryLanguage, strQuery, iFlags, NULL, &iter );
1001     if (hr != S_OK) return hr;
1002
1003     hr = SWbemObjectSet_create( iter, objWbemObjectSet );
1004     IEnumWbemClassObject_Release( iter );
1005     return hr;
1006 }
1007
1008 static HRESULT WINAPI services_ExecQueryAsync(
1009     ISWbemServices *iface,
1010     IDispatch *objWbemSink,
1011     BSTR strQuery,
1012     BSTR strQueryLanguage,
1013     LONG lFlags,
1014     IDispatch *objWbemNamedValueSet,
1015     IDispatch *objWbemAsyncContext )
1016 {
1017     FIXME( "\n" );
1018     return E_NOTIMPL;
1019 }
1020
1021 static HRESULT WINAPI services_AssociatorsOf(
1022     ISWbemServices *iface,
1023     BSTR strObjectPath,
1024     BSTR strAssocClass,
1025     BSTR strResultClass,
1026     BSTR strResultRole,
1027     BSTR strRole,
1028     VARIANT_BOOL bClassesOnly,
1029     VARIANT_BOOL bSchemaOnly,
1030     BSTR strRequiredAssocQualifier,
1031     BSTR strRequiredQualifier,
1032     LONG iFlags,
1033     IDispatch *objWbemNamedValueSet,
1034     ISWbemObjectSet **objWbemObjectSet )
1035 {
1036     FIXME( "\n" );
1037     return E_NOTIMPL;
1038 }
1039
1040 static HRESULT WINAPI services_AssociatorsOfAsync(
1041     ISWbemServices *iface,
1042     IDispatch *objWbemSink,
1043     BSTR strObjectPath,
1044     BSTR strAssocClass,
1045     BSTR strResultClass,
1046     BSTR strResultRole,
1047     BSTR strRole,
1048     VARIANT_BOOL bClassesOnly,
1049     VARIANT_BOOL bSchemaOnly,
1050     BSTR strRequiredAssocQualifier,
1051     BSTR strRequiredQualifier,
1052     LONG iFlags,
1053     IDispatch *objWbemNamedValueSet,
1054     IDispatch *objWbemAsyncContext )
1055 {
1056     FIXME( "\n" );
1057     return E_NOTIMPL;
1058 }
1059
1060 static HRESULT WINAPI services_ReferencesTo(
1061     ISWbemServices *iface,
1062     BSTR strObjectPath,
1063     BSTR strResultClass,
1064     BSTR strRole,
1065     VARIANT_BOOL bClassesOnly,
1066     VARIANT_BOOL bSchemaOnly,
1067     BSTR strRequiredQualifier,
1068     LONG iFlags,
1069     IDispatch *objWbemNamedValueSet,
1070     ISWbemObjectSet **objWbemObjectSet )
1071 {
1072     FIXME( "\n" );
1073     return E_NOTIMPL;
1074 }
1075
1076 static HRESULT WINAPI services_ReferencesToAsync(
1077     ISWbemServices *iface,
1078     IDispatch *objWbemSink,
1079     BSTR strObjectPath,
1080     BSTR strResultClass,
1081     BSTR strRole,
1082     VARIANT_BOOL bClassesOnly,
1083     VARIANT_BOOL bSchemaOnly,
1084     BSTR strRequiredQualifier,
1085     LONG iFlags,
1086     IDispatch *objWbemNamedValueSet,
1087     IDispatch *objWbemAsyncContext )
1088 {
1089     FIXME( "\n" );
1090     return E_NOTIMPL;
1091 }
1092
1093 static HRESULT WINAPI services_ExecNotificationQuery(
1094     ISWbemServices *iface,
1095     BSTR strQuery,
1096     BSTR strQueryLanguage,
1097     LONG iFlags,
1098     IDispatch *objWbemNamedValueSet,
1099     ISWbemEventSource **objWbemEventSource )
1100 {
1101     FIXME( "\n" );
1102     return E_NOTIMPL;
1103 }
1104
1105 static HRESULT WINAPI services_ExecNotificationQueryAsync(
1106     ISWbemServices *iface,
1107     IDispatch *objWbemSink,
1108     BSTR strQuery,
1109     BSTR strQueryLanguage,
1110     LONG iFlags,
1111     IDispatch *objWbemNamedValueSet,
1112     IDispatch *objWbemAsyncContext )
1113 {
1114     FIXME( "\n" );
1115     return E_NOTIMPL;
1116 }
1117
1118 static HRESULT WINAPI services_ExecMethod(
1119     ISWbemServices *iface,
1120     BSTR strObjectPath,
1121     BSTR strMethodName,
1122     IDispatch *objWbemInParameters,
1123     LONG iFlags,
1124     IDispatch *objWbemNamedValueSet,
1125     ISWbemObject **objWbemOutParameters )
1126 {
1127     FIXME( "\n" );
1128     return E_NOTIMPL;
1129 }
1130
1131 static HRESULT WINAPI services_ExecMethodAsync(
1132     ISWbemServices *iface,
1133     IDispatch *objWbemSink,
1134     BSTR strObjectPath,
1135     BSTR strMethodName,
1136     IDispatch *objWbemInParameters,
1137     LONG iFlags,
1138     IDispatch *objWbemNamedValueSet,
1139     IDispatch *objWbemAsyncContext )
1140 {
1141     FIXME( "\n" );
1142     return E_NOTIMPL;
1143 }
1144
1145 static HRESULT WINAPI services_get_Security_(
1146         ISWbemServices *iface,
1147         ISWbemSecurity **objWbemSecurity )
1148 {
1149     FIXME( "\n" );
1150     return E_NOTIMPL;
1151 }
1152
1153 static const ISWbemServicesVtbl services_vtbl =
1154 {
1155     services_QueryInterface,
1156     services_AddRef,
1157     services_Release,
1158     services_GetTypeInfoCount,
1159     services_GetTypeInfo,
1160     services_GetIDsOfNames,
1161     services_Invoke,
1162     services_Get,
1163     services_GetAsync,
1164     services_Delete,
1165     services_DeleteAsync,
1166     services_InstancesOf,
1167     services_InstancesOfAsync,
1168     services_SubclassesOf,
1169     services_SubclassesOfAsync,
1170     services_ExecQuery,
1171     services_ExecQueryAsync,
1172     services_AssociatorsOf,
1173     services_AssociatorsOfAsync,
1174     services_ReferencesTo,
1175     services_ReferencesToAsync,
1176     services_ExecNotificationQuery,
1177     services_ExecNotificationQueryAsync,
1178     services_ExecMethod,
1179     services_ExecMethodAsync,
1180     services_get_Security_
1181 };
1182
1183 static HRESULT SWbemServices_create( IWbemServices *wbem_services, ISWbemServices **obj )
1184 {
1185     struct services *services;
1186
1187     TRACE( "%p, %p\n", obj, wbem_services );
1188
1189     if (!(services = heap_alloc( sizeof(*services) ))) return E_OUTOFMEMORY;
1190     services->ISWbemServices_iface.lpVtbl = &services_vtbl;
1191     services->refs = 1;
1192     services->services = wbem_services;
1193     IWbemServices_AddRef( services->services );
1194
1195     *obj = &services->ISWbemServices_iface;
1196     TRACE( "returning iface %p\n", *obj );
1197     return S_OK;
1198 }
1199
1200 struct locator
1201 {
1202     ISWbemLocator ISWbemLocator_iface;
1203     LONG refs;
1204     IWbemLocator *locator;
1205 };
1206
1207 static inline struct locator *impl_from_ISWbemLocator( ISWbemLocator *iface )
1208 {
1209     return CONTAINING_RECORD( iface, struct locator, ISWbemLocator_iface );
1210 }
1211
1212 static ULONG WINAPI locator_AddRef(
1213     ISWbemLocator *iface )
1214 {
1215     struct locator *locator = impl_from_ISWbemLocator( iface );
1216     return InterlockedIncrement( &locator->refs );
1217 }
1218
1219 static ULONG WINAPI locator_Release(
1220     ISWbemLocator *iface )
1221 {
1222     struct locator *locator = impl_from_ISWbemLocator( iface );
1223     LONG refs = InterlockedDecrement( &locator->refs );
1224     if (!refs)
1225     {
1226         TRACE( "destroying %p\n", locator );
1227         IWbemLocator_Release( locator->locator );
1228         heap_free( locator );
1229     }
1230     return refs;
1231 }
1232
1233 static HRESULT WINAPI locator_QueryInterface(
1234     ISWbemLocator *iface,
1235     REFIID riid,
1236     void **ppvObject )
1237 {
1238     struct locator *locator = impl_from_ISWbemLocator( iface );
1239
1240     TRACE( "%p, %s, %p\n", locator, debugstr_guid( riid ), ppvObject );
1241
1242     if (IsEqualGUID( riid, &IID_ISWbemLocator ) ||
1243         IsEqualGUID( riid, &IID_IDispatch ) ||
1244         IsEqualGUID( riid, &IID_IUnknown ))
1245     {
1246         *ppvObject = iface;
1247     }
1248     else
1249     {
1250         FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
1251         return E_NOINTERFACE;
1252     }
1253     ISWbemLocator_AddRef( iface );
1254     return S_OK;
1255 }
1256
1257 static HRESULT WINAPI locator_GetTypeInfoCount(
1258     ISWbemLocator *iface,
1259     UINT *count )
1260 {
1261     struct locator *locator = impl_from_ISWbemLocator( iface );
1262
1263     TRACE( "%p, %p\n", locator, count );
1264     *count = 1;
1265     return S_OK;
1266 }
1267
1268 static HRESULT WINAPI locator_GetTypeInfo(
1269     ISWbemLocator *iface,
1270     UINT index,
1271     LCID lcid,
1272     ITypeInfo **info )
1273 {
1274     struct locator *locator = impl_from_ISWbemLocator( iface );
1275     TRACE( "%p, %u, %u, %p\n", locator, index, lcid, info );
1276
1277     return get_typeinfo( ISWbemLocator_tid, info );
1278 }
1279
1280 static HRESULT WINAPI locator_GetIDsOfNames(
1281     ISWbemLocator *iface,
1282     REFIID riid,
1283     LPOLESTR *names,
1284     UINT count,
1285     LCID lcid,
1286     DISPID *dispid )
1287 {
1288     struct locator *locator = impl_from_ISWbemLocator( iface );
1289     ITypeInfo *typeinfo;
1290     HRESULT hr;
1291
1292     TRACE( "%p, %s, %p, %u, %u, %p\n", locator, debugstr_guid(riid), names, count, lcid, dispid );
1293
1294     if (!names || !count || !dispid) return E_INVALIDARG;
1295
1296     hr = get_typeinfo( ISWbemLocator_tid, &typeinfo );
1297     if (SUCCEEDED(hr))
1298     {
1299         hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
1300         ITypeInfo_Release( typeinfo );
1301     }
1302     return hr;
1303 }
1304
1305 static HRESULT WINAPI locator_Invoke(
1306     ISWbemLocator *iface,
1307     DISPID member,
1308     REFIID riid,
1309     LCID lcid,
1310     WORD flags,
1311     DISPPARAMS *params,
1312     VARIANT *result,
1313     EXCEPINFO *excep_info,
1314     UINT *arg_err )
1315 {
1316     struct locator *locator = impl_from_ISWbemLocator( iface );
1317     ITypeInfo *typeinfo;
1318     HRESULT hr;
1319
1320     TRACE( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", locator, member, debugstr_guid(riid),
1321            lcid, flags, params, result, excep_info, arg_err );
1322
1323     hr = get_typeinfo( ISWbemLocator_tid, &typeinfo );
1324     if (SUCCEEDED(hr))
1325     {
1326         hr = ITypeInfo_Invoke( typeinfo, &locator->ISWbemLocator_iface, member, flags,
1327                                params, result, excep_info, arg_err );
1328         ITypeInfo_Release( typeinfo );
1329     }
1330     return hr;
1331 }
1332
1333 static BSTR build_resource_string( BSTR server, BSTR namespace )
1334 {
1335     static const WCHAR defaultW[] = {'r','o','o','t','\\','d','e','f','a','u','l','t',0};
1336     ULONG len, len_server = 0, len_namespace = 0;
1337     BSTR ret;
1338
1339     if (server && *server) len_server = strlenW( server );
1340     else len_server = 1;
1341     if (namespace && *namespace) len_namespace = strlenW( namespace );
1342     else len_namespace = sizeof(defaultW) / sizeof(defaultW[0]) - 1;
1343
1344     if (!(ret = SysAllocStringLen( NULL, 2 + len_server + 1 + len_namespace ))) return NULL;
1345
1346     ret[0] = ret[1] = '\\';
1347     if (server && *server) strcpyW( ret + 2, server );
1348     else ret[2] = '.';
1349
1350     len = len_server + 2;
1351     ret[len++] = '\\';
1352
1353     if (namespace && *namespace) strcpyW( ret + len, namespace );
1354     else strcpyW( ret + len, defaultW );
1355     return ret;
1356 }
1357
1358 static HRESULT WINAPI locator_ConnectServer(
1359     ISWbemLocator *iface,
1360     BSTR strServer,
1361     BSTR strNamespace,
1362     BSTR strUser,
1363     BSTR strPassword,
1364     BSTR strLocale,
1365     BSTR strAuthority,
1366     LONG iSecurityFlags,
1367     IDispatch *objWbemNamedValueSet,
1368     ISWbemServices **objWbemServices )
1369 {
1370     struct locator *locator = impl_from_ISWbemLocator( iface );
1371     IWbemServices *services;
1372     BSTR resource;
1373     HRESULT hr;
1374
1375     TRACE( "%p, %s, %s, %s, %p, %s, %s, 0x%08x, %p, %p\n", iface, debugstr_w(strServer),
1376            debugstr_w(strNamespace), debugstr_w(strUser), strPassword, debugstr_w(strLocale),
1377            debugstr_w(strAuthority), iSecurityFlags, objWbemNamedValueSet, objWbemServices );
1378
1379     if (objWbemNamedValueSet) FIXME( "context not supported\n" );
1380
1381     if (!locator->locator)
1382     {
1383         hr = CoCreateInstance( &CLSID_WbemLocator, NULL, CLSCTX_INPROC_SERVER, &IID_IWbemLocator,
1384                                (void **)&locator->locator );
1385         if (hr != S_OK) return hr;
1386     }
1387
1388     if (!(resource = build_resource_string( strServer, strNamespace ))) return E_OUTOFMEMORY;
1389     hr = IWbemLocator_ConnectServer( locator->locator, resource, strUser, strPassword, strLocale,
1390                                      iSecurityFlags, strAuthority, NULL, &services );
1391     SysFreeString( resource );
1392     if (hr != S_OK) return hr;
1393
1394     hr = SWbemServices_create( services, objWbemServices );
1395     IWbemServices_Release( services );
1396     return hr;
1397 }
1398
1399 static HRESULT WINAPI locator_get_Security_(
1400     ISWbemLocator *iface,
1401     ISWbemSecurity **objWbemSecurity )
1402 {
1403     FIXME( "%p, %p\n", iface, objWbemSecurity );
1404     return E_NOTIMPL;
1405 }
1406
1407 static const ISWbemLocatorVtbl locator_vtbl =
1408 {
1409     locator_QueryInterface,
1410     locator_AddRef,
1411     locator_Release,
1412     locator_GetTypeInfoCount,
1413     locator_GetTypeInfo,
1414     locator_GetIDsOfNames,
1415     locator_Invoke,
1416     locator_ConnectServer,
1417     locator_get_Security_
1418 };
1419
1420 HRESULT SWbemLocator_create( void **obj )
1421 {
1422     struct locator *locator;
1423
1424     TRACE( "%p\n", obj );
1425
1426     if (!(locator = heap_alloc( sizeof(*locator) ))) return E_OUTOFMEMORY;
1427     locator->ISWbemLocator_iface.lpVtbl = &locator_vtbl;
1428     locator->refs = 1;
1429     locator->locator = NULL;
1430
1431     *obj = &locator->ISWbemLocator_iface;
1432     TRACE( "returning iface %p\n", *obj );
1433     return S_OK;
1434 }