dlls/wbemprox/services.c

   1 /*
   2  * Copyright 2012 Hans Leidekker for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20
  21 #include <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "objbase.h"
  26 #include "wbemcli.h"
  27
  28 #include "wine/debug.h"
  29 #include "wbemprox_private.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(wbemprox);
  32
  33 struct client_security
  34 {
  35     IClientSecurity IClientSecurity_iface;
  36 };
  37
  38 static inline struct client_security *impl_from_IClientSecurity( IClientSecurity *iface )
  39 {
  40     return CONTAINING_RECORD( iface, struct client_security, IClientSecurity_iface );
  41 }
  42
  43 static HRESULT WINAPI client_security_QueryInterface(
  44     IClientSecurity *iface,
  45     REFIID riid,
  46     void **ppvObject )
  47 {
  48     struct client_security *cs = impl_from_IClientSecurity( iface );
  49
  50     TRACE("%p %s %p\n", cs, debugstr_guid( riid ), ppvObject );
  51
  52     if ( IsEqualGUID( riid, &IID_IClientSecurity ) ||
  53          IsEqualGUID( riid, &IID_IUnknown ) )
  54     {
  55         *ppvObject = cs;
  56     }
  57     else
  58     {
  59         FIXME("interface %s not implemented\n", debugstr_guid(riid));
  60         return E_NOINTERFACE;
  61     }
  62     IClientSecurity_AddRef( iface );
  63     return S_OK;
  64 }
  65
  66 static ULONG WINAPI client_security_AddRef(
  67     IClientSecurity *iface )
  68 {
  69     FIXME("%p\n", iface);
  70     return 2;
  71 }
  72
  73 static ULONG WINAPI client_security_Release(
  74     IClientSecurity *iface )
  75 {
  76     FIXME("%p\n", iface);
  77     return 1;
  78 }
  79
  80 static HRESULT WINAPI client_security_QueryBlanket(
  81     IClientSecurity *iface,
  82     IUnknown *pProxy,
  83     DWORD *pAuthnSvc,
  84     DWORD *pAuthzSvc,
  85     OLECHAR **pServerPrincName,
  86     DWORD *pAuthnLevel,
  87     DWORD *pImpLevel,
  88     void **pAuthInfo,
  89     DWORD *pCapabilities )
  90 {
  91     FIXME("semi-stub.\n");
  92
  93     if (pAuthnSvc)
  94         *pAuthnSvc = RPC_C_AUTHN_NONE;
  95     if (pAuthzSvc)
  96         *pAuthzSvc = RPC_C_AUTHZ_NONE;
  97     if (pServerPrincName)
  98         *pServerPrincName = NULL;
  99     if (pAuthnLevel)
 100         *pAuthnLevel = RPC_C_AUTHN_LEVEL_NONE;
 101     if (pImpLevel)
 102         *pImpLevel = RPC_C_IMP_LEVEL_DEFAULT;
 103     if (pAuthInfo)
 104         *pAuthInfo = NULL;
 105     if (pCapabilities)
 106         *pCapabilities = 0;
 107
 108     return WBEM_NO_ERROR;
 109 }
 110
 111 static HRESULT WINAPI client_security_SetBlanket(
 112     IClientSecurity *iface,
 113     IUnknown *pProxy,
 114     DWORD AuthnSvc,
 115     DWORD AuthzSvc,
 116     OLECHAR *pServerPrincName,
 117     DWORD AuthnLevel,
 118     DWORD ImpLevel,
 119     void *pAuthInfo,
 120     DWORD Capabilities )
 121 {
 122     const OLECHAR *princname = (pServerPrincName == COLE_DEFAULT_PRINCIPAL) ?
 123                                L"<COLE_DEFAULT_PRINCIPAL>" : pServerPrincName;
 124
 125     FIXME("%p, %p, %u, %u, %s, %u, %u, %p, 0x%08x\n", iface, pProxy, AuthnSvc, AuthzSvc,
 126           debugstr_w(princname), AuthnLevel, ImpLevel, pAuthInfo, Capabilities);
 127     return WBEM_NO_ERROR;
 128 }
 129
 130 static HRESULT WINAPI client_security_CopyProxy(
 131     IClientSecurity *iface,
 132     IUnknown *pProxy,
 133     IUnknown **ppCopy )
 134 {
 135     FIXME("\n");
 136     return WBEM_E_FAILED;
 137 }
 138
 139 static const IClientSecurityVtbl client_security_vtbl =
 140 {
 141     client_security_QueryInterface,
 142     client_security_AddRef,
 143     client_security_Release,
 144     client_security_QueryBlanket,
 145     client_security_SetBlanket,
 146     client_security_CopyProxy
 147 };
 148
 149 IClientSecurity client_security = { &client_security_vtbl };
 150
 151 struct async_header
 152 {
 153     IWbemObjectSink *sink;
 154     void (*proc)( struct async_header * );
 155     HANDLE cancel;
 156     HANDLE wait;
 157 };
 158
 159 struct async_query
 160 {
 161     struct async_header hdr;
 162     WCHAR *str;
 163 };
 164
 165 static void free_async( struct async_header *async )
 166 {
 167     if (async->sink) IWbemObjectSink_Release( async->sink );
 168     CloseHandle( async->cancel );
 169     CloseHandle( async->wait );
 170     heap_free( async );
 171 }
 172
 173 static BOOL init_async( struct async_header *async, IWbemObjectSink *sink,
 174                         void (*proc)(struct async_header *) )
 175 {
 176     if (!(async->wait = CreateEventW( NULL, FALSE, FALSE, NULL ))) return FALSE;
 177     if (!(async->cancel = CreateEventW( NULL, FALSE, FALSE, NULL )))
 178     {
 179         CloseHandle( async->wait );
 180         return FALSE;
 181     }
 182     async->proc = proc;
 183     async->sink = sink;
 184     IWbemObjectSink_AddRef( sink );
 185     return TRUE;
 186 }
 187
 188 static DWORD CALLBACK async_proc( LPVOID param )
 189 {
 190     struct async_header *async = param;
 191     HANDLE wait = async->wait;
 192
 193     async->proc( async );
 194
 195     WaitForSingleObject( async->cancel, INFINITE );
 196     SetEvent( wait );
 197     return ERROR_SUCCESS;
 198 }
 199
 200 static HRESULT queue_async( struct async_header *async )
 201 {
 202     if (QueueUserWorkItem( async_proc, async, WT_EXECUTELONGFUNCTION )) return S_OK;
 203     return HRESULT_FROM_WIN32( GetLastError() );
 204 }
 205
 206 struct wbem_services
 207 {
 208     IWbemServices IWbemServices_iface;
 209     LONG refs;
 210     CRITICAL_SECTION cs;
 211     WCHAR *namespace;
 212     struct async_header *async;
 213     IWbemContext *context;
 214 };
 215
 216 static inline struct wbem_services *impl_from_IWbemServices( IWbemServices *iface )
 217 {
 218     return CONTAINING_RECORD( iface, struct wbem_services, IWbemServices_iface );
 219 }
 220
 221 static ULONG WINAPI wbem_services_AddRef(
 222     IWbemServices *iface )
 223 {
 224     struct wbem_services *ws = impl_from_IWbemServices( iface );
 225     return InterlockedIncrement( &ws->refs );
 226 }
 227
 228 static ULONG WINAPI wbem_services_Release(
 229     IWbemServices *iface )
 230 {
 231     struct wbem_services *ws = impl_from_IWbemServices( iface );
 232     LONG refs = InterlockedDecrement( &ws->refs );
 233     if (!refs)
 234     {
 235         TRACE("destroying %p\n", ws);
 236
 237         EnterCriticalSection( &ws->cs );
 238         if (ws->async) SetEvent( ws->async->cancel );
 239         LeaveCriticalSection( &ws->cs );
 240         if (ws->async)
 241         {
 242             WaitForSingleObject( ws->async->wait, INFINITE );
 243             free_async( ws->async );
 244         }
 245         ws->cs.DebugInfo->Spare[0] = 0;
 246         DeleteCriticalSection( &ws->cs );
 247         if (ws->context)
 248             IWbemContext_Release( ws->context );
 249         heap_free( ws->namespace );
 250         heap_free( ws );
 251     }
 252     return refs;
 253 }
 254
 255 static HRESULT WINAPI wbem_services_QueryInterface(
 256     IWbemServices *iface,
 257     REFIID riid,
 258     void **ppvObject )
 259 {
 260     struct wbem_services *ws = impl_from_IWbemServices( iface );
 261
 262     TRACE("%p %s %p\n", ws, debugstr_guid( riid ), ppvObject );
 263
 264     if ( IsEqualGUID( riid, &IID_IWbemServices ) ||
 265          IsEqualGUID( riid, &IID_IUnknown ) )
 266     {
 267         *ppvObject = ws;
 268     }
 269     else if ( IsEqualGUID( riid, &IID_IClientSecurity ) )
 270     {
 271         *ppvObject = &client_security;
 272         return S_OK;
 273     }
 274     else
 275     {
 276         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 277         return E_NOINTERFACE;
 278     }
 279     IWbemServices_AddRef( iface );
 280     return S_OK;
 281 }
 282
 283 static HRESULT WINAPI wbem_services_OpenNamespace(
 284     IWbemServices *iface,
 285     const BSTR strNamespace,
 286     LONG lFlags,
 287     IWbemContext *pCtx,
 288     IWbemServices **ppWorkingNamespace,
 289     IWbemCallResult **ppResult )
 290 {
 291     struct wbem_services *ws = impl_from_IWbemServices( iface );
 292
 293     TRACE("%p, %s, 0x%08x, %p, %p, %p\n", iface, debugstr_w(strNamespace), lFlags,
 294           pCtx, ppWorkingNamespace, ppResult);
 295
 296     if ((wcsicmp( strNamespace, L"cimv2" ) && wcsicmp( strNamespace, L"default" )) || ws->namespace)
 297         return WBEM_E_INVALID_NAMESPACE;
 298
 299     return WbemServices_create( L"cimv2", NULL, (void **)ppWorkingNamespace );
 300 }
 301
 302 static HRESULT WINAPI wbem_services_CancelAsyncCall(
 303     IWbemServices *iface,
 304     IWbemObjectSink *pSink )
 305 {
 306     struct wbem_services *services = impl_from_IWbemServices( iface );
 307     struct async_header *async;
 308
 309     TRACE("%p, %p\n", iface, pSink);
 310
 311     if (!pSink) return WBEM_E_INVALID_PARAMETER;
 312
 313     EnterCriticalSection( &services->cs );
 314
 315     if (!(async = services->async))
 316     {
 317         LeaveCriticalSection( &services->cs );
 318         return WBEM_E_INVALID_PARAMETER;
 319     }
 320     services->async = NULL;
 321     SetEvent( async->cancel );
 322
 323     LeaveCriticalSection( &services->cs );
 324
 325     WaitForSingleObject( async->wait, INFINITE );
 326     free_async( async );
 327     return S_OK;
 328 }
 329
 330 static HRESULT WINAPI wbem_services_QueryObjectSink(
 331     IWbemServices *iface,
 332     LONG lFlags,
 333     IWbemObjectSink **ppResponseHandler )
 334 {
 335     FIXME("\n");
 336     return WBEM_E_FAILED;
 337 }
 338
 339 HRESULT parse_path( const WCHAR *str, struct path **ret )
 340 {
 341     struct path *path;
 342     const WCHAR *p = str, *q;
 343     UINT len;
 344
 345     if (!(path = heap_alloc_zero( sizeof(*path) ))) return E_OUTOFMEMORY;
 346
 347     if (*p == '\\')
 348     {
 349         static const WCHAR cimv2W[] = L"ROOT\\CIMV2";
 350         WCHAR server[MAX_COMPUTERNAME_LENGTH+1];
 351         DWORD server_len = ARRAY_SIZE(server);
 352
 353         p++;
 354         if (*p != '\\')
 355         {
 356             heap_free( path );
 357             return WBEM_E_INVALID_OBJECT_PATH;
 358         }
 359         p++;
 360
 361         q = p;
 362         while (*p && *p != '\\') p++;
 363         if (!*p)
 364         {
 365             heap_free( path );
 366             return WBEM_E_INVALID_OBJECT_PATH;
 367         }
 368
 369         len = p - q;
 370         if (!GetComputerNameW( server, &server_len ) || server_len != len || wcsnicmp( q, server, server_len ))
 371         {
 372             heap_free( path );
 373             return WBEM_E_NOT_SUPPORTED;
 374         }
 375
 376         q = ++p;
 377         while (*p && *p != ':') p++;
 378         if (!*p)
 379         {
 380             heap_free( path );
 381             return WBEM_E_INVALID_OBJECT_PATH;
 382         }
 383
 384         len = p - q;
 385         if (len != ARRAY_SIZE(cimv2W) - 1 || wcsnicmp( q, cimv2W, ARRAY_SIZE(cimv2W) - 1 ))
 386         {
 387             heap_free( path );
 388             return WBEM_E_INVALID_NAMESPACE;
 389         }
 390         p++;
 391     }
 392
 393     q = p;
 394     while (*p && *p != '.') p++;
 395
 396     len = p - q;
 397     if (!(path->class = heap_alloc( (len + 1) * sizeof(WCHAR) )))
 398     {
 399         heap_free( path );
 400         return E_OUTOFMEMORY;
 401     }
 402     memcpy( path->class, q, len * sizeof(WCHAR) );
 403     path->class[len] = 0;
 404     path->class_len = len;
 405
 406     if (p[0] == '.' && p[1])
 407     {
 408         q = ++p;
 409         while (*q) q++;
 410
 411         len = q - p;
 412         if (!(path->filter = heap_alloc( (len + 1) * sizeof(WCHAR) )))
 413         {
 414             heap_free( path->class );
 415             heap_free( path );
 416             return E_OUTOFMEMORY;
 417         }
 418         memcpy( path->filter, p, len * sizeof(WCHAR) );
 419         path->filter[len] = 0;
 420         path->filter_len = len;
 421     }
 422     *ret = path;
 423     return S_OK;
 424 }
 425
 426 void free_path( struct path *path )
 427 {
 428     if (!path) return;
 429     heap_free( path->class );
 430     heap_free( path->filter );
 431     heap_free( path );
 432 }
 433
 434 WCHAR *query_from_path( const struct path *path )
 435 {
 436     static const WCHAR selectW[] = L"SELECT * FROM %s WHERE %s";
 437     static const WCHAR select_allW[] = L"SELECT * FROM ";
 438     WCHAR *query;
 439     UINT len;
 440
 441     if (path->filter)
 442     {
 443         len = path->class_len + path->filter_len + ARRAY_SIZE(selectW);
 444         if (!(query = heap_alloc( len * sizeof(WCHAR) ))) return NULL;
 445         swprintf( query, len, selectW, path->class, path->filter );
 446     }
 447     else
 448     {
 449         len = path->class_len + ARRAY_SIZE(select_allW);
 450         if (!(query = heap_alloc( len * sizeof(WCHAR) ))) return NULL;
 451         lstrcpyW( query, select_allW );
 452         lstrcatW( query, path->class );
 453     }
 454     return query;
 455 }
 456
 457 static HRESULT create_instance_enum( const struct path *path, IEnumWbemClassObject **iter )
 458 {
 459     WCHAR *query;
 460     HRESULT hr;
 461
 462     if (!(query = query_from_path( path ))) return E_OUTOFMEMORY;
 463     hr = exec_query( query, iter );
 464     heap_free( query );
 465     return hr;
 466 }
 467
 468 HRESULT get_object( const WCHAR *object_path, IWbemClassObject **obj )
 469 {
 470     IEnumWbemClassObject *iter;
 471     struct path *path;
 472     ULONG count;
 473     HRESULT hr;
 474
 475     hr = parse_path( object_path, &path );
 476     if (hr != S_OK) return hr;
 477
 478     hr = create_instance_enum( path, &iter );
 479     if (hr != S_OK)
 480     {
 481         free_path( path );
 482         return hr;
 483     }
 484     hr = IEnumWbemClassObject_Next( iter, WBEM_INFINITE, 1, obj, &count );
 485     if (hr == WBEM_S_FALSE)
 486     {
 487         hr = WBEM_E_NOT_FOUND;
 488         *obj = NULL;
 489     }
 490     IEnumWbemClassObject_Release( iter );
 491     free_path( path );
 492     return hr;
 493 }
 494
 495 static HRESULT WINAPI wbem_services_GetObject(
 496     IWbemServices *iface,
 497     const BSTR strObjectPath,
 498     LONG lFlags,
 499     IWbemContext *pCtx,
 500     IWbemClassObject **ppObject,
 501     IWbemCallResult **ppCallResult )
 502 {
 503     TRACE("%p, %s, 0x%08x, %p, %p, %p\n", iface, debugstr_w(strObjectPath), lFlags,
 504           pCtx, ppObject, ppCallResult);
 505
 506     if (lFlags) FIXME("unsupported flags 0x%08x\n", lFlags);
 507
 508     if (!strObjectPath || !strObjectPath[0])
 509         return create_class_object( NULL, NULL, 0, NULL, ppObject );
 510
 511     return get_object( strObjectPath, ppObject );
 512 }
 513
 514 static HRESULT WINAPI wbem_services_GetObjectAsync(
 515     IWbemServices *iface,
 516     const BSTR strObjectPath,
 517     LONG lFlags,
 518     IWbemContext *pCtx,
 519     IWbemObjectSink *pResponseHandler )
 520 {
 521     FIXME("\n");
 522     return WBEM_E_FAILED;
 523 }
 524
 525 static HRESULT WINAPI wbem_services_PutClass(
 526     IWbemServices *iface,
 527     IWbemClassObject *pObject,
 528     LONG lFlags,
 529     IWbemContext *pCtx,
 530     IWbemCallResult **ppCallResult )
 531 {
 532     FIXME("\n");
 533     return WBEM_E_FAILED;
 534 }
 535
 536 static HRESULT WINAPI wbem_services_PutClassAsync(
 537     IWbemServices *iface,
 538     IWbemClassObject *pObject,
 539     LONG lFlags,
 540     IWbemContext *pCtx,
 541     IWbemObjectSink *pResponseHandler )
 542 {
 543     FIXME("\n");
 544     return WBEM_E_FAILED;
 545 }
 546
 547 static HRESULT WINAPI wbem_services_DeleteClass(
 548     IWbemServices *iface,
 549     const BSTR strClass,
 550     LONG lFlags,
 551     IWbemContext *pCtx,
 552     IWbemCallResult **ppCallResult )
 553 {
 554     FIXME("\n");
 555     return WBEM_E_FAILED;
 556 }
 557
 558 static HRESULT WINAPI wbem_services_DeleteClassAsync(
 559     IWbemServices *iface,
 560     const BSTR strClass,
 561     LONG lFlags,
 562     IWbemContext *pCtx,
 563     IWbemObjectSink *pResponseHandler )
 564 {
 565     FIXME("\n");
 566     return WBEM_E_FAILED;
 567 }
 568
 569 static HRESULT WINAPI wbem_services_CreateClassEnum(
 570     IWbemServices *iface,
 571     const BSTR strSuperclass,
 572     LONG lFlags,
 573     IWbemContext *pCtx,
 574     IEnumWbemClassObject **ppEnum )
 575 {
 576     FIXME("\n");
 577     return WBEM_E_FAILED;
 578 }
 579
 580 static HRESULT WINAPI wbem_services_CreateClassEnumAsync(
 581     IWbemServices *iface,
 582     const BSTR strSuperclass,
 583     LONG lFlags,
 584     IWbemContext *pCtx,
 585     IWbemObjectSink *pResponseHandler )
 586 {
 587     FIXME("\n");
 588     return WBEM_E_FAILED;
 589 }
 590
 591 static HRESULT WINAPI wbem_services_PutInstance(
 592     IWbemServices *iface,
 593     IWbemClassObject *pInst,
 594     LONG lFlags,
 595     IWbemContext *pCtx,
 596     IWbemCallResult **ppCallResult )
 597 {
 598     FIXME("\n");
 599     return WBEM_E_FAILED;
 600 }
 601
 602 static HRESULT WINAPI wbem_services_PutInstanceAsync(
 603     IWbemServices *iface,
 604     IWbemClassObject *pInst,
 605     LONG lFlags,
 606     IWbemContext *pCtx,
 607     IWbemObjectSink *pResponseHandler )
 608 {
 609     FIXME("\n");
 610     return WBEM_E_FAILED;
 611 }
 612
 613 static HRESULT WINAPI wbem_services_DeleteInstance(
 614     IWbemServices *iface,
 615     const BSTR strObjectPath,
 616     LONG lFlags,
 617     IWbemContext *pCtx,
 618     IWbemCallResult **ppCallResult )
 619 {
 620     FIXME("\n");
 621     return WBEM_E_FAILED;
 622 }
 623
 624 static HRESULT WINAPI wbem_services_DeleteInstanceAsync(
 625     IWbemServices *iface,
 626     const BSTR strObjectPath,
 627     LONG lFlags,
 628     IWbemContext *pCtx,
 629     IWbemObjectSink *pResponseHandler )
 630 {
 631     FIXME("\n");
 632     return WBEM_E_FAILED;
 633 }
 634
 635 static HRESULT WINAPI wbem_services_CreateInstanceEnum(
 636     IWbemServices *iface,
 637     const BSTR strClass,
 638     LONG lFlags,
 639     IWbemContext *pCtx,
 640     IEnumWbemClassObject **ppEnum )
 641 {
 642     struct path *path;
 643     HRESULT hr;
 644
 645     TRACE("%p, %s, 0%08x, %p, %p\n", iface, debugstr_w(strClass), lFlags, pCtx, ppEnum);
 646
 647     if (lFlags) FIXME("unsupported flags 0x%08x\n", lFlags);
 648
 649     hr = parse_path( strClass, &path );
 650     if (hr != S_OK) return hr;
 651
 652     hr = create_instance_enum( path, ppEnum );
 653     free_path( path );
 654     return hr;
 655 }
 656
 657 static HRESULT WINAPI wbem_services_CreateInstanceEnumAsync(
 658     IWbemServices *iface,
 659     const BSTR strFilter,
 660     LONG lFlags,
 661     IWbemContext *pCtx,
 662     IWbemObjectSink *pResponseHandler )
 663 {
 664     FIXME("\n");
 665     return WBEM_E_FAILED;
 666 }
 667
 668 static HRESULT WINAPI wbem_services_ExecQuery(
 669     IWbemServices *iface,
 670     const BSTR strQueryLanguage,
 671     const BSTR strQuery,
 672     LONG lFlags,
 673     IWbemContext *pCtx,
 674     IEnumWbemClassObject **ppEnum )
 675 {
 676     TRACE("%p, %s, %s, 0x%08x, %p, %p\n", iface, debugstr_w(strQueryLanguage),
 677           debugstr_w(strQuery), lFlags, pCtx, ppEnum);
 678
 679     if (!strQueryLanguage || !strQuery || !strQuery[0]) return WBEM_E_INVALID_PARAMETER;
 680     if (wcsicmp( strQueryLanguage, L"WQL" )) return WBEM_E_INVALID_QUERY_TYPE;
 681     return exec_query( strQuery, ppEnum );
 682 }
 683
 684 static void async_exec_query( struct async_header *hdr )
 685 {
 686     struct async_query *query = (struct async_query *)hdr;
 687     IEnumWbemClassObject *result;
 688     IWbemClassObject *obj;
 689     ULONG count;
 690     HRESULT hr;
 691
 692     hr = exec_query( query->str, &result );
 693     if (hr == S_OK)
 694     {
 695         for (;;)
 696         {
 697             IEnumWbemClassObject_Next( result, WBEM_INFINITE, 1, &obj, &count );
 698             if (!count) break;
 699             IWbemObjectSink_Indicate( query->hdr.sink, 1, &obj );
 700             IWbemClassObject_Release( obj );
 701         }
 702         IEnumWbemClassObject_Release( result );
 703     }
 704     IWbemObjectSink_SetStatus( query->hdr.sink, WBEM_STATUS_COMPLETE, hr, NULL, NULL );
 705     heap_free( query->str );
 706 }
 707
 708 static HRESULT WINAPI wbem_services_ExecQueryAsync(
 709     IWbemServices *iface,
 710     const BSTR strQueryLanguage,
 711     const BSTR strQuery,
 712     LONG lFlags,
 713     IWbemContext *pCtx,
 714     IWbemObjectSink *pResponseHandler )
 715 {
 716     struct wbem_services *services = impl_from_IWbemServices( iface );
 717     IWbemObjectSink *sink;
 718     HRESULT hr = E_OUTOFMEMORY;
 719     struct async_header *async;
 720     struct async_query *query;
 721
 722     TRACE("%p, %s, %s, 0x%08x, %p, %p\n", iface, debugstr_w(strQueryLanguage), debugstr_w(strQuery),
 723           lFlags, pCtx, pResponseHandler);
 724
 725     if (!pResponseHandler) return WBEM_E_INVALID_PARAMETER;
 726
 727     hr = IWbemObjectSink_QueryInterface( pResponseHandler, &IID_IWbemObjectSink, (void **)&sink );
 728     if (FAILED(hr)) return hr;
 729
 730     EnterCriticalSection( &services->cs );
 731
 732     if (services->async)
 733     {
 734         FIXME("handle more than one pending async\n");
 735         hr = WBEM_E_FAILED;
 736         goto done;
 737     }
 738     if (!(query = heap_alloc_zero( sizeof(*query) ))) goto done;
 739     async = (struct async_header *)query;
 740
 741     if (!(init_async( async, sink, async_exec_query )))
 742     {
 743         free_async( async );
 744         goto done;
 745     }
 746     if (!(query->str = heap_strdupW( strQuery )))
 747     {
 748         free_async( async );
 749         goto done;
 750     }
 751     hr = queue_async( async );
 752     if (hr == S_OK) services->async = async;
 753     else
 754     {
 755         heap_free( query->str );
 756         free_async( async );
 757     }
 758
 759 done:
 760     LeaveCriticalSection( &services->cs );
 761     IWbemObjectSink_Release( sink );
 762     return hr;
 763 }
 764
 765 static HRESULT WINAPI wbem_services_ExecNotificationQuery(
 766     IWbemServices *iface,
 767     const BSTR strQueryLanguage,
 768     const BSTR strQuery,
 769     LONG lFlags,
 770     IWbemContext *pCtx,
 771     IEnumWbemClassObject **ppEnum )
 772 {
 773     FIXME("\n");
 774     return WBEM_E_FAILED;
 775 }
 776
 777 static HRESULT WINAPI wbem_services_ExecNotificationQueryAsync(
 778     IWbemServices *iface,
 779     const BSTR strQueryLanguage,
 780     const BSTR strQuery,
 781     LONG lFlags,
 782     IWbemContext *pCtx,
 783     IWbemObjectSink *pResponseHandler )
 784 {
 785     struct wbem_services *services = impl_from_IWbemServices( iface );
 786     IWbemObjectSink *sink;
 787     HRESULT hr = E_OUTOFMEMORY;
 788     struct async_header *async;
 789     struct async_query *query;
 790
 791     TRACE("%p, %s, %s, 0x%08x, %p, %p\n", iface, debugstr_w(strQueryLanguage), debugstr_w(strQuery),
 792           lFlags, pCtx, pResponseHandler);
 793
 794     if (!pResponseHandler) return WBEM_E_INVALID_PARAMETER;
 795
 796     hr = IWbemObjectSink_QueryInterface( pResponseHandler, &IID_IWbemObjectSink, (void **)&sink );
 797     if (FAILED(hr)) return hr;
 798
 799     EnterCriticalSection( &services->cs );
 800
 801     if (services->async)
 802     {
 803         FIXME("handle more than one pending async\n");
 804         hr = WBEM_E_FAILED;
 805         goto done;
 806     }
 807     if (!(query = heap_alloc_zero( sizeof(*query) ))) goto done;
 808     async = (struct async_header *)query;
 809
 810     if (!(init_async( async, sink, async_exec_query )))
 811     {
 812         free_async( async );
 813         goto done;
 814     }
 815     if (!(query->str = heap_strdupW( strQuery )))
 816     {
 817         free_async( async );
 818         goto done;
 819     }
 820     hr = queue_async( async );
 821     if (hr == S_OK) services->async = async;
 822     else
 823     {
 824         heap_free( query->str );
 825         free_async( async );
 826     }
 827
 828 done:
 829     LeaveCriticalSection( &services->cs );
 830     IWbemObjectSink_Release( sink );
 831     return hr;
 832 }
 833
 834 static HRESULT WINAPI wbem_services_ExecMethod(
 835     IWbemServices *iface,
 836     const BSTR strObjectPath,
 837     const BSTR strMethodName,
 838     LONG lFlags,
 839     IWbemContext *context,
 840     IWbemClassObject *pInParams,
 841     IWbemClassObject **ppOutParams,
 842     IWbemCallResult **ppCallResult )
 843 {
 844     struct wbem_services *services = impl_from_IWbemServices( iface );
 845     IEnumWbemClassObject *result = NULL;
 846     IWbemClassObject *obj = NULL;
 847     struct query *query = NULL;
 848     struct path *path;
 849     WCHAR *str;
 850     class_method *func;
 851     struct table *table;
 852     HRESULT hr;
 853
 854     TRACE("%p, %s, %s, %08x, %p, %p, %p, %p\n", iface, debugstr_w(strObjectPath),
 855           debugstr_w(strMethodName), lFlags, context, pInParams, ppOutParams, ppCallResult);
 856
 857     if (lFlags) FIXME("flags %08x not supported\n", lFlags);
 858
 859     if ((hr = parse_path( strObjectPath, &path )) != S_OK) return hr;
 860     if (!(str = query_from_path( path )))
 861     {
 862         hr = E_OUTOFMEMORY;
 863         goto done;
 864     }
 865     if (!(query = create_query()))
 866     {
 867         hr = E_OUTOFMEMORY;
 868         goto done;
 869     }
 870     hr = parse_query( str, &query->view, &query->mem );
 871     if (hr != S_OK) goto done;
 872
 873     hr = execute_view( query->view );
 874     if (hr != S_OK) goto done;
 875
 876     hr = EnumWbemClassObject_create( query, (void **)&result );
 877     if (hr != S_OK) goto done;
 878
 879     table = get_view_table( query->view, 0 );
 880     hr = create_class_object( table->name, result, 0, NULL, &obj );
 881     if (hr != S_OK) goto done;
 882
 883     hr = get_method( table, strMethodName, &func );
 884     if (hr != S_OK) goto done;
 885
 886     hr = func( obj, context ? context : services->context, pInParams, ppOutParams );
 887
 888 done:
 889     if (result) IEnumWbemClassObject_Release( result );
 890     if (obj) IWbemClassObject_Release( obj );
 891     free_query( query );
 892     free_path( path );
 893     heap_free( str );
 894     return hr;
 895 }
 896
 897 static HRESULT WINAPI wbem_services_ExecMethodAsync(
 898     IWbemServices *iface,
 899     const BSTR strObjectPath,
 900     const BSTR strMethodName,
 901     LONG lFlags,
 902     IWbemContext *pCtx,
 903     IWbemClassObject *pInParams,
 904     IWbemObjectSink *pResponseHandler )
 905 {
 906     FIXME("\n");
 907     return WBEM_E_FAILED;
 908 }
 909
 910 static const IWbemServicesVtbl wbem_services_vtbl =
 911 {
 912     wbem_services_QueryInterface,
 913     wbem_services_AddRef,
 914     wbem_services_Release,
 915     wbem_services_OpenNamespace,
 916     wbem_services_CancelAsyncCall,
 917     wbem_services_QueryObjectSink,
 918     wbem_services_GetObject,
 919     wbem_services_GetObjectAsync,
 920     wbem_services_PutClass,
 921     wbem_services_PutClassAsync,
 922     wbem_services_DeleteClass,
 923     wbem_services_DeleteClassAsync,
 924     wbem_services_CreateClassEnum,
 925     wbem_services_CreateClassEnumAsync,
 926     wbem_services_PutInstance,
 927     wbem_services_PutInstanceAsync,
 928     wbem_services_DeleteInstance,
 929     wbem_services_DeleteInstanceAsync,
 930     wbem_services_CreateInstanceEnum,
 931     wbem_services_CreateInstanceEnumAsync,
 932     wbem_services_ExecQuery,
 933     wbem_services_ExecQueryAsync,
 934     wbem_services_ExecNotificationQuery,
 935     wbem_services_ExecNotificationQueryAsync,
 936     wbem_services_ExecMethod,
 937     wbem_services_ExecMethodAsync
 938 };
 939
 940 HRESULT WbemServices_create( const WCHAR *namespace, IWbemContext *context, LPVOID *ppObj )
 941 {
 942     struct wbem_services *ws;
 943
 944     TRACE("(%p)\n", ppObj);
 945
 946     ws = heap_alloc_zero( sizeof(*ws) );
 947     if (!ws) return E_OUTOFMEMORY;
 948
 949     ws->IWbemServices_iface.lpVtbl = &wbem_services_vtbl;
 950     ws->refs      = 1;
 951     ws->namespace = heap_strdupW( namespace );
 952     InitializeCriticalSection( &ws->cs );
 953     ws->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": wbemprox_services.cs");
 954     if (context)
 955         IWbemContext_Clone( context, &ws->context );
 956
 957     *ppObj = &ws->IWbemServices_iface;
 958
 959     TRACE("returning iface %p\n", *ppObj);
 960     return S_OK;
 961 }
 962
 963 struct wbem_context_value
 964 {
 965     struct list entry;
 966     WCHAR *name;
 967     VARIANT value;
 968 };
 969
 970 struct wbem_context
 971 {
 972     IWbemContext IWbemContext_iface;
 973     LONG refs;
 974     struct list values;
 975 };
 976
 977 static void wbem_context_delete_values(struct wbem_context *context)
 978 {
 979     struct wbem_context_value *value, *next;
 980
 981     LIST_FOR_EACH_ENTRY_SAFE(value, next, &context->values, struct wbem_context_value, entry)
 982     {
 983         list_remove( &value->entry );
 984         VariantClear( &value->value );
 985         heap_free( value->name );
 986         heap_free( value );
 987     }
 988 }
 989
 990 static struct wbem_context *impl_from_IWbemContext( IWbemContext *iface )
 991 {
 992     return CONTAINING_RECORD( iface, struct wbem_context, IWbemContext_iface );
 993 }
 994
 995 static HRESULT WINAPI wbem_context_QueryInterface(
 996     IWbemContext *iface,
 997     REFIID riid,
 998     void **obj)
 999 {
1000     TRACE("%p, %s, %p\n", iface, debugstr_guid( riid ), obj );
1001
1002     if ( IsEqualGUID( riid, &IID_IWbemContext ) ||
1003          IsEqualGUID( riid, &IID_IUnknown ) )
1004     {
1005         *obj = iface;
1006     }
1007     else
1008     {
1009         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1010         return E_NOINTERFACE;
1011     }
1012
1013     IWbemContext_AddRef( iface );
1014     return S_OK;
1015 }
1016
1017 static ULONG WINAPI wbem_context_AddRef(
1018     IWbemContext *iface )
1019 {
1020     struct wbem_context *context = impl_from_IWbemContext( iface );
1021     return InterlockedIncrement( &context->refs );
1022 }
1023
1024 static ULONG WINAPI wbem_context_Release(
1025     IWbemContext *iface )
1026 {
1027     struct wbem_context *context = impl_from_IWbemContext( iface );
1028     LONG refs = InterlockedDecrement( &context->refs );
1029
1030     if (!refs)
1031     {
1032         TRACE("destroying %p\n", context);
1033         wbem_context_delete_values( context );
1034         heap_free( context );
1035     }
1036     return refs;
1037 }
1038
1039 static HRESULT WINAPI wbem_context_Clone(
1040     IWbemContext *iface,
1041     IWbemContext **newcopy )
1042 {
1043     struct wbem_context *context = impl_from_IWbemContext( iface );
1044     struct wbem_context_value *value;
1045     IWbemContext *cloned_context;
1046     HRESULT hr;
1047
1048     TRACE("%p, %p\n", iface, newcopy);
1049
1050     if (SUCCEEDED(hr = WbemContext_create( (void **)&cloned_context )))
1051     {
1052         LIST_FOR_EACH_ENTRY( value, &context->values, struct wbem_context_value, entry )
1053         {
1054             if (FAILED(hr = IWbemContext_SetValue( cloned_context, value->name, 0, &value->value ))) break;
1055         }
1056     }
1057
1058     if (SUCCEEDED(hr))
1059     {
1060         *newcopy = cloned_context;
1061     }
1062     else
1063     {
1064         *newcopy = NULL;
1065         IWbemContext_Release( cloned_context );
1066     }
1067
1068     return hr;
1069 }
1070
1071 static HRESULT WINAPI wbem_context_GetNames(
1072     IWbemContext *iface,
1073     LONG flags,
1074     SAFEARRAY **names )
1075 {
1076     FIXME("%p, %#x, %p\n", iface, flags, names);
1077
1078     return E_NOTIMPL;
1079 }
1080
1081 static HRESULT WINAPI wbem_context_BeginEnumeration(
1082     IWbemContext *iface,
1083     LONG flags )
1084 {
1085     FIXME("%p, %#x\n", iface, flags);
1086
1087     return E_NOTIMPL;
1088 }
1089
1090 static HRESULT WINAPI wbem_context_Next(
1091     IWbemContext *iface,
1092     LONG flags,
1093     BSTR *name,
1094     VARIANT *value )
1095 {
1096     FIXME("%p, %#x, %p, %p\n", iface, flags, name, value);
1097
1098     return E_NOTIMPL;
1099 }
1100
1101 static HRESULT WINAPI wbem_context_EndEnumeration(
1102     IWbemContext *iface )
1103 {
1104     FIXME("%p\n", iface);
1105
1106     return E_NOTIMPL;
1107 }
1108
1109 static struct wbem_context_value *wbem_context_get_value( struct wbem_context *context, const WCHAR *name )
1110 {
1111     struct wbem_context_value *value;
1112
1113     LIST_FOR_EACH_ENTRY( value, &context->values, struct wbem_context_value, entry )
1114     {
1115         if (!lstrcmpiW( value->name, name )) return value;
1116     }
1117
1118     return NULL;
1119 }
1120
1121 static HRESULT WINAPI wbem_context_SetValue(
1122     IWbemContext *iface,
1123     LPCWSTR name,
1124     LONG flags,
1125     VARIANT *var )
1126 {
1127     struct wbem_context *context = impl_from_IWbemContext( iface );
1128     struct wbem_context_value *value;
1129     HRESULT hr;
1130
1131     TRACE("%p, %s, %#x, %s\n", iface, debugstr_w(name), flags, debugstr_variant(var));
1132
1133     if (!name || !var)
1134         return WBEM_E_INVALID_PARAMETER;
1135
1136     if ((value = wbem_context_get_value( context, name )))
1137     {
1138         VariantClear( &value->value );
1139         hr = VariantCopy( &value->value, var );
1140     }
1141     else
1142     {
1143         if (!(value = heap_alloc_zero( sizeof(*value) ))) return E_OUTOFMEMORY;
1144         if (!(value->name = heap_strdupW( name )))
1145         {
1146             heap_free( value );
1147             return E_OUTOFMEMORY;
1148         }
1149         if (FAILED(hr = VariantCopy( &value->value, var )))
1150         {
1151             heap_free( value->name );
1152             heap_free( value );
1153             return hr;
1154         }
1155
1156         list_add_tail( &context->values, &value->entry );
1157     }
1158
1159     return hr;
1160 }
1161
1162 static HRESULT WINAPI wbem_context_GetValue(
1163     IWbemContext *iface,
1164     LPCWSTR name,
1165     LONG flags,
1166     VARIANT *var )
1167 {
1168     struct wbem_context *context = impl_from_IWbemContext( iface );
1169     struct wbem_context_value *value;
1170
1171     TRACE("%p, %s, %#x, %p\n", iface, debugstr_w(name), flags, var);
1172
1173     if (!name || !var)
1174         return WBEM_E_INVALID_PARAMETER;
1175
1176     if (!(value = wbem_context_get_value( context, name )))
1177         return WBEM_E_NOT_FOUND;
1178
1179     V_VT(var) = VT_EMPTY;
1180     return VariantCopy( var, &value->value );
1181 }
1182
1183 static HRESULT WINAPI wbem_context_DeleteValue(
1184     IWbemContext *iface,
1185     LPCWSTR name,
1186     LONG flags )
1187 {
1188     FIXME("%p, %s, %#x\n", iface, debugstr_w(name), flags);
1189
1190     return E_NOTIMPL;
1191 }
1192
1193 static HRESULT WINAPI wbem_context_DeleteAll(
1194     IWbemContext *iface )
1195 {
1196     FIXME("%p\n", iface);
1197
1198     return E_NOTIMPL;
1199 }
1200
1201 static const IWbemContextVtbl wbem_context_vtbl =
1202 {
1203     wbem_context_QueryInterface,
1204     wbem_context_AddRef,
1205     wbem_context_Release,
1206     wbem_context_Clone,
1207     wbem_context_GetNames,
1208     wbem_context_BeginEnumeration,
1209     wbem_context_Next,
1210     wbem_context_EndEnumeration,
1211     wbem_context_SetValue,
1212     wbem_context_GetValue,
1213     wbem_context_DeleteValue,
1214     wbem_context_DeleteAll,
1215 };
1216
1217 HRESULT WbemContext_create( void **obj )
1218 {
1219     struct wbem_context *context;
1220
1221     TRACE("(%p)\n", obj);
1222
1223     context = heap_alloc( sizeof(*context) );
1224     if (!context) return E_OUTOFMEMORY;
1225
1226     context->IWbemContext_iface.lpVtbl = &wbem_context_vtbl;
1227     context->refs = 1;
1228     list_init(&context->values);
1229
1230     *obj = &context->IWbemContext_iface;
1231
1232     TRACE("returning iface %p\n", *obj);
1233     return S_OK;
1234 }