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->IClientSecurity_iface;
  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, %lu, %lu, %s, %lu, %lu, %p, %#lx\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     enum wbm_namespace ns;
 163     WCHAR *str;
 164 };
 165
 166 static void free_async( struct async_header *async )
 167 {
 168     if (async->sink) IWbemObjectSink_Release( async->sink );
 169     CloseHandle( async->cancel );
 170     CloseHandle( async->wait );
 171     free( async );
 172 }
 173
 174 static BOOL init_async( struct async_header *async, IWbemObjectSink *sink,
 175                         void (*proc)(struct async_header *) )
 176 {
 177     if (!(async->wait = CreateEventW( NULL, FALSE, FALSE, NULL ))) return FALSE;
 178     if (!(async->cancel = CreateEventW( NULL, FALSE, FALSE, NULL )))
 179     {
 180         CloseHandle( async->wait );
 181         return FALSE;
 182     }
 183     async->proc = proc;
 184     async->sink = sink;
 185     IWbemObjectSink_AddRef( sink );
 186     return TRUE;
 187 }
 188
 189 static DWORD CALLBACK async_proc( LPVOID param )
 190 {
 191     struct async_header *async = param;
 192     HANDLE wait = async->wait;
 193
 194     async->proc( async );
 195
 196     WaitForSingleObject( async->cancel, INFINITE );
 197     SetEvent( wait );
 198     return ERROR_SUCCESS;
 199 }
 200
 201 static HRESULT queue_async( struct async_header *async )
 202 {
 203     if (QueueUserWorkItem( async_proc, async, WT_EXECUTELONGFUNCTION )) return S_OK;
 204     return HRESULT_FROM_WIN32( GetLastError() );
 205 }
 206
 207 struct wbem_services
 208 {
 209     IWbemServices IWbemServices_iface;
 210     LONG refs;
 211     CRITICAL_SECTION cs;
 212     enum wbm_namespace ns;
 213     struct async_header *async;
 214     IWbemContext *context;
 215 };
 216
 217 static inline struct wbem_services *impl_from_IWbemServices( IWbemServices *iface )
 218 {
 219     return CONTAINING_RECORD( iface, struct wbem_services, IWbemServices_iface );
 220 }
 221
 222 static ULONG WINAPI wbem_services_AddRef(
 223     IWbemServices *iface )
 224 {
 225     struct wbem_services *ws = impl_from_IWbemServices( iface );
 226     return InterlockedIncrement( &ws->refs );
 227 }
 228
 229 static ULONG WINAPI wbem_services_Release(
 230     IWbemServices *iface )
 231 {
 232     struct wbem_services *ws = impl_from_IWbemServices( iface );
 233     LONG refs = InterlockedDecrement( &ws->refs );
 234     if (!refs)
 235     {
 236         TRACE("destroying %p\n", ws);
 237
 238         EnterCriticalSection( &ws->cs );
 239         if (ws->async) SetEvent( ws->async->cancel );
 240         LeaveCriticalSection( &ws->cs );
 241         if (ws->async)
 242         {
 243             WaitForSingleObject( ws->async->wait, INFINITE );
 244             free_async( ws->async );
 245         }
 246         ws->cs.DebugInfo->Spare[0] = 0;
 247         DeleteCriticalSection( &ws->cs );
 248         if (ws->context)
 249             IWbemContext_Release( ws->context );
 250         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->IWbemServices_iface;
 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, %#lx, %p, %p, %p\n", iface, debugstr_w(strNamespace), lFlags,
 294            pCtx, ppWorkingNamespace, ppResult );
 295
 296     if (ws->ns != WBEMPROX_NAMESPACE_LAST || !strNamespace)
 297         return WBEM_E_INVALID_NAMESPACE;
 298
 299     return WbemServices_create( strNamespace, 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 void free_path( struct path *path )
 340 {
 341     if (!path) return;
 342     free( path->class );
 343     free( path->filter );
 344     free( path );
 345 }
 346
 347 HRESULT parse_path( const WCHAR *str, struct path **ret )
 348 {
 349     struct path *path;
 350     const WCHAR *p = str, *q;
 351     UINT len;
 352
 353     if (!(path = calloc( 1, sizeof(*path) ))) return E_OUTOFMEMORY;
 354
 355     if (*p == '\\')
 356     {
 357         static const WCHAR cimv2W[] = L"ROOT\\CIMV2";
 358         WCHAR server[MAX_COMPUTERNAME_LENGTH+1];
 359         DWORD server_len = ARRAY_SIZE(server);
 360
 361         p++;
 362         if (*p != '\\')
 363         {
 364             free( path );
 365             return WBEM_E_INVALID_OBJECT_PATH;
 366         }
 367         p++;
 368
 369         q = p;
 370         while (*p && *p != '\\') p++;
 371         if (!*p)
 372         {
 373             free( path );
 374             return WBEM_E_INVALID_OBJECT_PATH;
 375         }
 376
 377         len = p - q;
 378         if (!GetComputerNameW( server, &server_len ) || server_len != len || wcsnicmp( q, server, server_len ))
 379         {
 380             free( path );
 381             return WBEM_E_NOT_SUPPORTED;
 382         }
 383
 384         q = ++p;
 385         while (*p && *p != ':') p++;
 386         if (!*p)
 387         {
 388             free( path );
 389             return WBEM_E_INVALID_OBJECT_PATH;
 390         }
 391
 392         len = p - q;
 393         if (len != ARRAY_SIZE(cimv2W) - 1 || wcsnicmp( q, cimv2W, ARRAY_SIZE(cimv2W) - 1 ))
 394         {
 395             free( path );
 396             return WBEM_E_INVALID_NAMESPACE;
 397         }
 398         p++;
 399     }
 400
 401     q = p;
 402     while (*p && *p != '.' && *p != '=') p++;
 403
 404     len = p - q;
 405     if (!(path->class = malloc( (len + 1) * sizeof(WCHAR) )))
 406     {
 407         free( path );
 408         return E_OUTOFMEMORY;
 409     }
 410     memcpy( path->class, q, len * sizeof(WCHAR) );
 411     path->class[len] = 0;
 412     path->class_len = len;
 413
 414     if (p[0] == '.' && p[1])
 415     {
 416         q = ++p;
 417         while (*q) q++;
 418
 419         len = q - p;
 420         if (!(path->filter = malloc( (len + 1) * sizeof(WCHAR) )))
 421         {
 422             free_path( path );
 423             return E_OUTOFMEMORY;
 424         }
 425         memcpy( path->filter, p, len * sizeof(WCHAR) );
 426         path->filter[len] = 0;
 427         path->filter_len = len;
 428     }
 429     else if (p[0] == '=' && p[1])
 430     {
 431         WCHAR *key;
 432         UINT len_key;
 433
 434         while (*q) q++;
 435         len = q - p;
 436
 437         if (!(key = get_first_key_property( WBEMPROX_NAMESPACE_CIMV2, path->class )))
 438         {
 439             free_path( path );
 440             return WBEM_E_INVALID_OBJECT_PATH;
 441         }
 442         len_key = wcslen( key );
 443
 444         if (!(path->filter = malloc( (len + len_key + 1) * sizeof(WCHAR) )))
 445         {
 446             free( key );
 447             free_path( path );
 448             return E_OUTOFMEMORY;
 449         }
 450         wcscpy( path->filter, key );
 451         memcpy( path->filter + len_key, p, len * sizeof(WCHAR) );
 452         path->filter_len = len + len_key;
 453         path->filter[path->filter_len] = 0;
 454         free( key );
 455     }
 456     else if (p[0])
 457     {
 458         free_path( path );
 459         return WBEM_E_INVALID_OBJECT_PATH;
 460     }
 461
 462     *ret = path;
 463     return S_OK;
 464 }
 465
 466 WCHAR *query_from_path( const struct path *path )
 467 {
 468     static const WCHAR selectW[] = L"SELECT * FROM %s WHERE %s";
 469     static const WCHAR select_allW[] = L"SELECT * FROM ";
 470     WCHAR *query;
 471     UINT len;
 472
 473     if (path->filter)
 474     {
 475         len = path->class_len + path->filter_len + ARRAY_SIZE(selectW);
 476         if (!(query = malloc( len * sizeof(WCHAR) ))) return NULL;
 477         swprintf( query, len, selectW, path->class, path->filter );
 478     }
 479     else
 480     {
 481         len = path->class_len + ARRAY_SIZE(select_allW);
 482         if (!(query = malloc( len * sizeof(WCHAR) ))) return NULL;
 483         lstrcpyW( query, select_allW );
 484         lstrcatW( query, path->class );
 485     }
 486     return query;
 487 }
 488
 489 static HRESULT create_instance_enum( enum wbm_namespace ns, const struct path *path, IEnumWbemClassObject **iter )
 490 {
 491     WCHAR *query;
 492     HRESULT hr;
 493
 494     if (!(query = query_from_path( path ))) return E_OUTOFMEMORY;
 495     hr = exec_query( ns, query, iter );
 496     free( query );
 497     return hr;
 498 }
 499
 500 HRESULT get_object( enum wbm_namespace ns, const WCHAR *object_path, IWbemClassObject **obj )
 501 {
 502     IEnumWbemClassObject *iter;
 503     struct path *path;
 504     ULONG count;
 505     HRESULT hr;
 506
 507     hr = parse_path( object_path, &path );
 508     if (hr != S_OK) return hr;
 509
 510     hr = create_instance_enum( ns, path, &iter );
 511     if (hr != S_OK)
 512     {
 513         free_path( path );
 514         return hr;
 515     }
 516     hr = IEnumWbemClassObject_Next( iter, WBEM_INFINITE, 1, obj, &count );
 517     if (hr == WBEM_S_FALSE)
 518     {
 519         hr = WBEM_E_NOT_FOUND;
 520         *obj = NULL;
 521     }
 522     IEnumWbemClassObject_Release( iter );
 523     free_path( path );
 524     return hr;
 525 }
 526
 527 static HRESULT WINAPI wbem_services_GetObject(
 528     IWbemServices *iface,
 529     const BSTR strObjectPath,
 530     LONG lFlags,
 531     IWbemContext *pCtx,
 532     IWbemClassObject **ppObject,
 533     IWbemCallResult **ppCallResult )
 534 {
 535     struct wbem_services *services = impl_from_IWbemServices( iface );
 536
 537     TRACE( "%p, %s, %#lx, %p, %p, %p\n", iface, debugstr_w(strObjectPath), lFlags,
 538            pCtx, ppObject, ppCallResult );
 539
 540     if (lFlags) FIXME( "unsupported flags %#lx\n", lFlags );
 541
 542     if (!strObjectPath || !strObjectPath[0])
 543         return create_class_object( services->ns, NULL, NULL, 0, NULL, ppObject );
 544
 545     return get_object( services->ns, strObjectPath, ppObject );
 546 }
 547
 548 static HRESULT WINAPI wbem_services_GetObjectAsync(
 549     IWbemServices *iface,
 550     const BSTR strObjectPath,
 551     LONG lFlags,
 552     IWbemContext *pCtx,
 553     IWbemObjectSink *pResponseHandler )
 554 {
 555     FIXME("\n");
 556     return WBEM_E_FAILED;
 557 }
 558
 559 static HRESULT WINAPI wbem_services_PutClass(
 560     IWbemServices *iface,
 561     IWbemClassObject *pObject,
 562     LONG lFlags,
 563     IWbemContext *pCtx,
 564     IWbemCallResult **ppCallResult )
 565 {
 566     FIXME("\n");
 567     return WBEM_E_FAILED;
 568 }
 569
 570 static HRESULT WINAPI wbem_services_PutClassAsync(
 571     IWbemServices *iface,
 572     IWbemClassObject *pObject,
 573     LONG lFlags,
 574     IWbemContext *pCtx,
 575     IWbemObjectSink *pResponseHandler )
 576 {
 577     FIXME("\n");
 578     return WBEM_E_FAILED;
 579 }
 580
 581 static HRESULT WINAPI wbem_services_DeleteClass(
 582     IWbemServices *iface,
 583     const BSTR strClass,
 584     LONG lFlags,
 585     IWbemContext *pCtx,
 586     IWbemCallResult **ppCallResult )
 587 {
 588     FIXME("\n");
 589     return WBEM_E_FAILED;
 590 }
 591
 592 static HRESULT WINAPI wbem_services_DeleteClassAsync(
 593     IWbemServices *iface,
 594     const BSTR strClass,
 595     LONG lFlags,
 596     IWbemContext *pCtx,
 597     IWbemObjectSink *pResponseHandler )
 598 {
 599     FIXME("\n");
 600     return WBEM_E_FAILED;
 601 }
 602
 603 static HRESULT WINAPI wbem_services_CreateClassEnum(
 604     IWbemServices *iface,
 605     const BSTR strSuperclass,
 606     LONG lFlags,
 607     IWbemContext *pCtx,
 608     IEnumWbemClassObject **ppEnum )
 609 {
 610     FIXME("\n");
 611     return WBEM_E_FAILED;
 612 }
 613
 614 static HRESULT WINAPI wbem_services_CreateClassEnumAsync(
 615     IWbemServices *iface,
 616     const BSTR strSuperclass,
 617     LONG lFlags,
 618     IWbemContext *pCtx,
 619     IWbemObjectSink *pResponseHandler )
 620 {
 621     FIXME("\n");
 622     return WBEM_E_FAILED;
 623 }
 624
 625 static HRESULT WINAPI wbem_services_PutInstance(
 626     IWbemServices *iface,
 627     IWbemClassObject *pInst,
 628     LONG lFlags,
 629     IWbemContext *pCtx,
 630     IWbemCallResult **ppCallResult )
 631 {
 632     FIXME("\n");
 633     return WBEM_E_FAILED;
 634 }
 635
 636 static HRESULT WINAPI wbem_services_PutInstanceAsync(
 637     IWbemServices *iface,
 638     IWbemClassObject *pInst,
 639     LONG lFlags,
 640     IWbemContext *pCtx,
 641     IWbemObjectSink *pResponseHandler )
 642 {
 643     FIXME("\n");
 644     return WBEM_E_FAILED;
 645 }
 646
 647 static HRESULT WINAPI wbem_services_DeleteInstance(
 648     IWbemServices *iface,
 649     const BSTR strObjectPath,
 650     LONG lFlags,
 651     IWbemContext *pCtx,
 652     IWbemCallResult **ppCallResult )
 653 {
 654     FIXME("\n");
 655     return WBEM_E_FAILED;
 656 }
 657
 658 static HRESULT WINAPI wbem_services_DeleteInstanceAsync(
 659     IWbemServices *iface,
 660     const BSTR strObjectPath,
 661     LONG lFlags,
 662     IWbemContext *pCtx,
 663     IWbemObjectSink *pResponseHandler )
 664 {
 665     FIXME("\n");
 666     return WBEM_E_FAILED;
 667 }
 668
 669 static HRESULT WINAPI wbem_services_CreateInstanceEnum(
 670     IWbemServices *iface,
 671     const BSTR strClass,
 672     LONG lFlags,
 673     IWbemContext *pCtx,
 674     IEnumWbemClassObject **ppEnum )
 675 {
 676     struct wbem_services *services = impl_from_IWbemServices( iface );
 677     struct path *path;
 678     HRESULT hr;
 679
 680     TRACE( "%p, %s, %#lx, %p, %p\n", iface, debugstr_w(strClass), lFlags, pCtx, ppEnum );
 681
 682     if (lFlags) FIXME( "unsupported flags %#lx\n", lFlags );
 683
 684     hr = parse_path( strClass, &path );
 685     if (hr != S_OK) return hr;
 686
 687     hr = create_instance_enum( services->ns, path, ppEnum );
 688     free_path( path );
 689     return hr;
 690 }
 691
 692 static HRESULT WINAPI wbem_services_CreateInstanceEnumAsync(
 693     IWbemServices *iface,
 694     const BSTR strFilter,
 695     LONG lFlags,
 696     IWbemContext *pCtx,
 697     IWbemObjectSink *pResponseHandler )
 698 {
 699     FIXME("\n");
 700     return WBEM_E_FAILED;
 701 }
 702
 703 static HRESULT WINAPI wbem_services_ExecQuery(
 704     IWbemServices *iface,
 705     const BSTR strQueryLanguage,
 706     const BSTR strQuery,
 707     LONG lFlags,
 708     IWbemContext *pCtx,
 709     IEnumWbemClassObject **ppEnum )
 710 {
 711     struct wbem_services *services = impl_from_IWbemServices( iface );
 712
 713     TRACE( "%p, %s, %s, %#lx, %p, %p\n", iface, debugstr_w(strQueryLanguage),
 714            debugstr_w(strQuery), lFlags, pCtx, ppEnum );
 715
 716     if (!strQueryLanguage || !strQuery || !strQuery[0]) return WBEM_E_INVALID_PARAMETER;
 717     if (wcsicmp( strQueryLanguage, L"WQL" )) return WBEM_E_INVALID_QUERY_TYPE;
 718     return exec_query( services->ns, strQuery, ppEnum );
 719 }
 720
 721 static void async_exec_query( struct async_header *hdr )
 722 {
 723     struct async_query *query = (struct async_query *)hdr;
 724     IEnumWbemClassObject *result;
 725     IWbemClassObject *obj;
 726     ULONG count;
 727     HRESULT hr;
 728
 729     hr = exec_query( query->ns, query->str, &result );
 730     if (hr == S_OK)
 731     {
 732         for (;;)
 733         {
 734             IEnumWbemClassObject_Next( result, WBEM_INFINITE, 1, &obj, &count );
 735             if (!count) break;
 736             IWbemObjectSink_Indicate( query->hdr.sink, 1, &obj );
 737             IWbemClassObject_Release( obj );
 738         }
 739         IEnumWbemClassObject_Release( result );
 740     }
 741     IWbemObjectSink_SetStatus( query->hdr.sink, WBEM_STATUS_COMPLETE, hr, NULL, NULL );
 742     free( query->str );
 743 }
 744
 745 static HRESULT WINAPI wbem_services_ExecQueryAsync(
 746     IWbemServices *iface,
 747     const BSTR strQueryLanguage,
 748     const BSTR strQuery,
 749     LONG lFlags,
 750     IWbemContext *pCtx,
 751     IWbemObjectSink *pResponseHandler )
 752 {
 753     struct wbem_services *services = impl_from_IWbemServices( iface );
 754     IWbemObjectSink *sink;
 755     HRESULT hr = E_OUTOFMEMORY;
 756     struct async_header *async;
 757     struct async_query *query;
 758
 759     TRACE( "%p, %s, %s, %#lx, %p, %p\n", iface, debugstr_w(strQueryLanguage), debugstr_w(strQuery),
 760            lFlags, pCtx, pResponseHandler );
 761
 762     if (!pResponseHandler) return WBEM_E_INVALID_PARAMETER;
 763
 764     hr = IWbemObjectSink_QueryInterface( pResponseHandler, &IID_IWbemObjectSink, (void **)&sink );
 765     if (FAILED(hr)) return hr;
 766
 767     EnterCriticalSection( &services->cs );
 768
 769     if (services->async)
 770     {
 771         FIXME("handle more than one pending async\n");
 772         hr = WBEM_E_FAILED;
 773         goto done;
 774     }
 775     if (!(query = calloc( 1, sizeof(*query) ))) goto done;
 776     query->ns = services->ns;
 777     async = (struct async_header *)query;
 778
 779     if (!(init_async( async, sink, async_exec_query )))
 780     {
 781         free_async( async );
 782         goto done;
 783     }
 784     if (!(query->str = wcsdup( strQuery )))
 785     {
 786         free_async( async );
 787         goto done;
 788     }
 789     hr = queue_async( async );
 790     if (hr == S_OK) services->async = async;
 791     else
 792     {
 793         free( query->str );
 794         free_async( async );
 795     }
 796
 797 done:
 798     LeaveCriticalSection( &services->cs );
 799     IWbemObjectSink_Release( sink );
 800     return hr;
 801 }
 802
 803 static HRESULT WINAPI wbem_services_ExecNotificationQuery(
 804     IWbemServices *iface,
 805     const BSTR strQueryLanguage,
 806     const BSTR strQuery,
 807     LONG lFlags,
 808     IWbemContext *pCtx,
 809     IEnumWbemClassObject **ppEnum )
 810 {
 811     FIXME("\n");
 812     return WBEM_E_FAILED;
 813 }
 814
 815 static HRESULT WINAPI wbem_services_ExecNotificationQueryAsync(
 816     IWbemServices *iface,
 817     const BSTR strQueryLanguage,
 818     const BSTR strQuery,
 819     LONG lFlags,
 820     IWbemContext *pCtx,
 821     IWbemObjectSink *pResponseHandler )
 822 {
 823     struct wbem_services *services = impl_from_IWbemServices( iface );
 824     IWbemObjectSink *sink;
 825     HRESULT hr = E_OUTOFMEMORY;
 826     struct async_header *async;
 827     struct async_query *query;
 828
 829     TRACE( "%p, %s, %s, %#lx, %p, %p\n", iface, debugstr_w(strQueryLanguage), debugstr_w(strQuery),
 830            lFlags, pCtx, pResponseHandler );
 831
 832     if (!pResponseHandler) return WBEM_E_INVALID_PARAMETER;
 833
 834     hr = IWbemObjectSink_QueryInterface( pResponseHandler, &IID_IWbemObjectSink, (void **)&sink );
 835     if (FAILED(hr)) return hr;
 836
 837     EnterCriticalSection( &services->cs );
 838
 839     if (services->async)
 840     {
 841         FIXME("handle more than one pending async\n");
 842         hr = WBEM_E_FAILED;
 843         goto done;
 844     }
 845     if (!(query = calloc( 1, sizeof(*query) ))) goto done;
 846     async = (struct async_header *)query;
 847
 848     if (!(init_async( async, sink, async_exec_query )))
 849     {
 850         free_async( async );
 851         goto done;
 852     }
 853     if (!(query->str = wcsdup( strQuery )))
 854     {
 855         free_async( async );
 856         goto done;
 857     }
 858     hr = queue_async( async );
 859     if (hr == S_OK) services->async = async;
 860     else
 861     {
 862         free( query->str );
 863         free_async( async );
 864     }
 865
 866 done:
 867     LeaveCriticalSection( &services->cs );
 868     IWbemObjectSink_Release( sink );
 869     return hr;
 870 }
 871
 872 static HRESULT WINAPI wbem_services_ExecMethod(
 873     IWbemServices *iface,
 874     const BSTR strObjectPath,
 875     const BSTR strMethodName,
 876     LONG lFlags,
 877     IWbemContext *context,
 878     IWbemClassObject *pInParams,
 879     IWbemClassObject **ppOutParams,
 880     IWbemCallResult **ppCallResult )
 881 {
 882     struct wbem_services *services = impl_from_IWbemServices( iface );
 883     IEnumWbemClassObject *result = NULL;
 884     IWbemClassObject *obj = NULL;
 885     struct query *query = NULL;
 886     struct path *path;
 887     WCHAR *str;
 888     class_method *func;
 889     struct table *table;
 890     HRESULT hr;
 891
 892     TRACE( "%p, %s, %s, %#lx, %p, %p, %p, %p\n", iface, debugstr_w(strObjectPath),
 893            debugstr_w(strMethodName), lFlags, context, pInParams, ppOutParams, ppCallResult );
 894
 895     if (lFlags) FIXME( "flags %#lx not supported\n", lFlags );
 896
 897     if ((hr = parse_path( strObjectPath, &path )) != S_OK) return hr;
 898     if (!(str = query_from_path( path )))
 899     {
 900         hr = E_OUTOFMEMORY;
 901         goto done;
 902     }
 903     if (!(query = create_query( services->ns )))
 904     {
 905         hr = E_OUTOFMEMORY;
 906         goto done;
 907     }
 908     hr = parse_query( services->ns, str, &query->view, &query->mem );
 909     if (hr != S_OK) goto done;
 910
 911     hr = execute_view( query->view );
 912     if (hr != S_OK) goto done;
 913
 914     hr = EnumWbemClassObject_create( query, (void **)&result );
 915     if (hr != S_OK) goto done;
 916
 917     table = get_view_table( query->view, 0 );
 918     hr = create_class_object( services->ns, table->name, result, 0, NULL, &obj );
 919     if (hr != S_OK) goto done;
 920
 921     hr = get_method( table, strMethodName, &func );
 922     if (hr != S_OK) goto done;
 923
 924     hr = func( obj, context ? context : services->context, pInParams, ppOutParams );
 925
 926 done:
 927     if (result) IEnumWbemClassObject_Release( result );
 928     if (obj) IWbemClassObject_Release( obj );
 929     free_query( query );
 930     free_path( path );
 931     free( str );
 932     return hr;
 933 }
 934
 935 static HRESULT WINAPI wbem_services_ExecMethodAsync(
 936     IWbemServices *iface,
 937     const BSTR strObjectPath,
 938     const BSTR strMethodName,
 939     LONG lFlags,
 940     IWbemContext *pCtx,
 941     IWbemClassObject *pInParams,
 942     IWbemObjectSink *pResponseHandler )
 943 {
 944     FIXME("\n");
 945     return WBEM_E_FAILED;
 946 }
 947
 948 static const IWbemServicesVtbl wbem_services_vtbl =
 949 {
 950     wbem_services_QueryInterface,
 951     wbem_services_AddRef,
 952     wbem_services_Release,
 953     wbem_services_OpenNamespace,
 954     wbem_services_CancelAsyncCall,
 955     wbem_services_QueryObjectSink,
 956     wbem_services_GetObject,
 957     wbem_services_GetObjectAsync,
 958     wbem_services_PutClass,
 959     wbem_services_PutClassAsync,
 960     wbem_services_DeleteClass,
 961     wbem_services_DeleteClassAsync,
 962     wbem_services_CreateClassEnum,
 963     wbem_services_CreateClassEnumAsync,
 964     wbem_services_PutInstance,
 965     wbem_services_PutInstanceAsync,
 966     wbem_services_DeleteInstance,
 967     wbem_services_DeleteInstanceAsync,
 968     wbem_services_CreateInstanceEnum,
 969     wbem_services_CreateInstanceEnumAsync,
 970     wbem_services_ExecQuery,
 971     wbem_services_ExecQueryAsync,
 972     wbem_services_ExecNotificationQuery,
 973     wbem_services_ExecNotificationQueryAsync,
 974     wbem_services_ExecMethod,
 975     wbem_services_ExecMethodAsync
 976 };
 977
 978 HRESULT WbemServices_create( const WCHAR *namespace, IWbemContext *context, LPVOID *ppObj )
 979 {
 980     struct wbem_services *ws;
 981     enum wbm_namespace ns;
 982
 983     TRACE("namespace %s, context %p, ppObj %p.\n", debugstr_w(namespace), context, ppObj);
 984
 985     if (!namespace)
 986         ns = WBEMPROX_NAMESPACE_LAST;
 987     else if ((ns = get_namespace_from_string( namespace )) == WBEMPROX_NAMESPACE_LAST)
 988         return WBEM_E_INVALID_NAMESPACE;
 989
 990     if (!(ws = calloc( 1, sizeof(*ws) ))) return E_OUTOFMEMORY;
 991
 992     ws->IWbemServices_iface.lpVtbl = &wbem_services_vtbl;
 993     ws->refs      = 1;
 994     ws->ns        = ns;
 995     InitializeCriticalSectionEx( &ws->cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO );
 996     ws->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": wbemprox_services.cs");
 997     if (context)
 998         IWbemContext_Clone( context, &ws->context );
 999
1000     *ppObj = &ws->IWbemServices_iface;
1001
1002     TRACE("returning iface %p\n", *ppObj);
1003     return S_OK;
1004 }
1005
1006 struct wbem_context_value
1007 {
1008     struct list entry;
1009     WCHAR *name;
1010     VARIANT value;
1011 };
1012
1013 struct wbem_context
1014 {
1015     IWbemContext IWbemContext_iface;
1016     LONG refs;
1017     struct list values;
1018 };
1019
1020 static void wbem_context_delete_values(struct wbem_context *context)
1021 {
1022     struct wbem_context_value *value, *next;
1023
1024     LIST_FOR_EACH_ENTRY_SAFE(value, next, &context->values, struct wbem_context_value, entry)
1025     {
1026         list_remove( &value->entry );
1027         VariantClear( &value->value );
1028         free( value->name );
1029         free( value );
1030     }
1031 }
1032
1033 static struct wbem_context *impl_from_IWbemContext( IWbemContext *iface )
1034 {
1035     return CONTAINING_RECORD( iface, struct wbem_context, IWbemContext_iface );
1036 }
1037
1038 static HRESULT WINAPI wbem_context_QueryInterface(
1039     IWbemContext *iface,
1040     REFIID riid,
1041     void **obj)
1042 {
1043     TRACE("%p, %s, %p\n", iface, debugstr_guid( riid ), obj );
1044
1045     if ( IsEqualGUID( riid, &IID_IWbemContext ) ||
1046          IsEqualGUID( riid, &IID_IUnknown ) )
1047     {
1048         *obj = iface;
1049     }
1050     else
1051     {
1052         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1053         return E_NOINTERFACE;
1054     }
1055
1056     IWbemContext_AddRef( iface );
1057     return S_OK;
1058 }
1059
1060 static ULONG WINAPI wbem_context_AddRef(
1061     IWbemContext *iface )
1062 {
1063     struct wbem_context *context = impl_from_IWbemContext( iface );
1064     return InterlockedIncrement( &context->refs );
1065 }
1066
1067 static ULONG WINAPI wbem_context_Release(
1068     IWbemContext *iface )
1069 {
1070     struct wbem_context *context = impl_from_IWbemContext( iface );
1071     LONG refs = InterlockedDecrement( &context->refs );
1072
1073     if (!refs)
1074     {
1075         TRACE("destroying %p\n", context);
1076         wbem_context_delete_values( context );
1077         free( context );
1078     }
1079     return refs;
1080 }
1081
1082 static HRESULT WINAPI wbem_context_Clone(
1083     IWbemContext *iface,
1084     IWbemContext **newcopy )
1085 {
1086     struct wbem_context *context = impl_from_IWbemContext( iface );
1087     struct wbem_context_value *value;
1088     IWbemContext *cloned_context;
1089     HRESULT hr;
1090
1091     TRACE("%p, %p\n", iface, newcopy);
1092
1093     if (SUCCEEDED(hr = WbemContext_create( (void **)&cloned_context, &IID_IWbemContext )))
1094     {
1095         LIST_FOR_EACH_ENTRY( value, &context->values, struct wbem_context_value, entry )
1096         {
1097             if (FAILED(hr = IWbemContext_SetValue( cloned_context, value->name, 0, &value->value ))) break;
1098         }
1099     }
1100
1101     if (SUCCEEDED(hr))
1102     {
1103         *newcopy = cloned_context;
1104     }
1105     else
1106     {
1107         *newcopy = NULL;
1108         IWbemContext_Release( cloned_context );
1109     }
1110
1111     return hr;
1112 }
1113
1114 static HRESULT WINAPI wbem_context_GetNames(
1115     IWbemContext *iface,
1116     LONG flags,
1117     SAFEARRAY **names )
1118 {
1119     FIXME( "%p, %#lx, %p\n", iface, flags, names );
1120
1121     return E_NOTIMPL;
1122 }
1123
1124 static HRESULT WINAPI wbem_context_BeginEnumeration(
1125     IWbemContext *iface,
1126     LONG flags )
1127 {
1128     FIXME( "%p, %#lx\n", iface, flags );
1129
1130     return E_NOTIMPL;
1131 }
1132
1133 static HRESULT WINAPI wbem_context_Next(
1134     IWbemContext *iface,
1135     LONG flags,
1136     BSTR *name,
1137     VARIANT *value )
1138 {
1139     FIXME( "%p, %#lx, %p, %p\n", iface, flags, name, value );
1140
1141     return E_NOTIMPL;
1142 }
1143
1144 static HRESULT WINAPI wbem_context_EndEnumeration(
1145     IWbemContext *iface )
1146 {
1147     FIXME("%p\n", iface);
1148
1149     return E_NOTIMPL;
1150 }
1151
1152 static struct wbem_context_value *wbem_context_get_value( struct wbem_context *context, const WCHAR *name )
1153 {
1154     struct wbem_context_value *value;
1155
1156     LIST_FOR_EACH_ENTRY( value, &context->values, struct wbem_context_value, entry )
1157     {
1158         if (!lstrcmpiW( value->name, name )) return value;
1159     }
1160
1161     return NULL;
1162 }
1163
1164 static HRESULT WINAPI wbem_context_SetValue(
1165     IWbemContext *iface,
1166     LPCWSTR name,
1167     LONG flags,
1168     VARIANT *var )
1169 {
1170     struct wbem_context *context = impl_from_IWbemContext( iface );
1171     struct wbem_context_value *value;
1172     HRESULT hr;
1173
1174     TRACE( "%p, %s, %#lx, %s\n", iface, debugstr_w(name), flags, debugstr_variant(var) );
1175
1176     if (!name || !var)
1177         return WBEM_E_INVALID_PARAMETER;
1178
1179     if ((value = wbem_context_get_value( context, name )))
1180     {
1181         VariantClear( &value->value );
1182         hr = VariantCopy( &value->value, var );
1183     }
1184     else
1185     {
1186         if (!(value = calloc( 1, sizeof(*value) ))) return E_OUTOFMEMORY;
1187         if (!(value->name = wcsdup( name )))
1188         {
1189             free( value );
1190             return E_OUTOFMEMORY;
1191         }
1192         if (FAILED(hr = VariantCopy( &value->value, var )))
1193         {
1194             free( value->name );
1195             free( value );
1196             return hr;
1197         }
1198
1199         list_add_tail( &context->values, &value->entry );
1200     }
1201
1202     return hr;
1203 }
1204
1205 static HRESULT WINAPI wbem_context_GetValue(
1206     IWbemContext *iface,
1207     LPCWSTR name,
1208     LONG flags,
1209     VARIANT *var )
1210 {
1211     struct wbem_context *context = impl_from_IWbemContext( iface );
1212     struct wbem_context_value *value;
1213
1214     TRACE( "%p, %s, %#lx, %p\n", iface, debugstr_w(name), flags, var );
1215
1216     if (!name || !var)
1217         return WBEM_E_INVALID_PARAMETER;
1218
1219     if (!(value = wbem_context_get_value( context, name )))
1220         return WBEM_E_NOT_FOUND;
1221
1222     V_VT(var) = VT_EMPTY;
1223     return VariantCopy( var, &value->value );
1224 }
1225
1226 static HRESULT WINAPI wbem_context_DeleteValue(
1227     IWbemContext *iface,
1228     LPCWSTR name,
1229     LONG flags )
1230 {
1231     FIXME( "%p, %s, %#lx\n", iface, debugstr_w(name), flags );
1232
1233     return E_NOTIMPL;
1234 }
1235
1236 static HRESULT WINAPI wbem_context_DeleteAll(
1237     IWbemContext *iface )
1238 {
1239     FIXME("%p\n", iface);
1240
1241     return E_NOTIMPL;
1242 }
1243
1244 static const IWbemContextVtbl wbem_context_vtbl =
1245 {
1246     wbem_context_QueryInterface,
1247     wbem_context_AddRef,
1248     wbem_context_Release,
1249     wbem_context_Clone,
1250     wbem_context_GetNames,
1251     wbem_context_BeginEnumeration,
1252     wbem_context_Next,
1253     wbem_context_EndEnumeration,
1254     wbem_context_SetValue,
1255     wbem_context_GetValue,
1256     wbem_context_DeleteValue,
1257     wbem_context_DeleteAll,
1258 };
1259
1260 HRESULT WbemContext_create( void **obj, REFIID riid )
1261 {
1262     struct wbem_context *context;
1263
1264     TRACE("(%p)\n", obj);
1265
1266     if ( !IsEqualGUID( riid, &IID_IWbemContext ) &&
1267          !IsEqualGUID( riid, &IID_IUnknown ) )
1268         return E_NOINTERFACE;
1269
1270     if (!(context = malloc( sizeof(*context) ))) return E_OUTOFMEMORY;
1271
1272     context->IWbemContext_iface.lpVtbl = &wbem_context_vtbl;
1273     context->refs = 1;
1274     list_init(&context->values);
1275
1276     *obj = &context->IWbemContext_iface;
1277
1278     TRACE("returning iface %p\n", *obj);
1279     return S_OK;
1280 }