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 "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 "wbemcli.h"
  29
  30 #include "wine/debug.h"
  31 #include "wine/unicode.h"
  32 #include "wbemprox_private.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(wbemprox);
  35
  36 struct client_security
  37 {
  38     IClientSecurity IClientSecurity_iface;
  39 };
  40
  41 static inline struct client_security *impl_from_IClientSecurity( IClientSecurity *iface )
  42 {
  43     return CONTAINING_RECORD( iface, struct client_security, IClientSecurity_iface );
  44 }
  45
  46 static HRESULT WINAPI client_security_QueryInterface(
  47     IClientSecurity *iface,
  48     REFIID riid,
  49     void **ppvObject )
  50 {
  51     struct client_security *cs = impl_from_IClientSecurity( iface );
  52
  53     TRACE("%p %s %p\n", cs, debugstr_guid( riid ), ppvObject );
  54
  55     if ( IsEqualGUID( riid, &IID_IClientSecurity ) ||
  56          IsEqualGUID( riid, &IID_IUnknown ) )
  57     {
  58         *ppvObject = cs;
  59     }
  60     else
  61     {
  62         FIXME("interface %s not implemented\n", debugstr_guid(riid));
  63         return E_NOINTERFACE;
  64     }
  65     IClientSecurity_AddRef( iface );
  66     return S_OK;
  67 }
  68
  69 static ULONG WINAPI client_security_AddRef(
  70     IClientSecurity *iface )
  71 {
  72     FIXME("%p\n", iface);
  73     return 2;
  74 }
  75
  76 static ULONG WINAPI client_security_Release(
  77     IClientSecurity *iface )
  78 {
  79     FIXME("%p\n", iface);
  80     return 1;
  81 }
  82
  83 static HRESULT WINAPI client_security_QueryBlanket(
  84     IClientSecurity *iface,
  85     IUnknown *pProxy,
  86     DWORD *pAuthnSvc,
  87     DWORD *pAuthzSvc,
  88     OLECHAR **pServerPrincName,
  89     DWORD *pAuthnLevel,
  90     DWORD *pImpLevel,
  91     void **pAuthInfo,
  92     DWORD *pCapabilities )
  93 {
  94     FIXME("\n");
  95     return WBEM_E_FAILED;
  96 }
  97
  98 static HRESULT WINAPI client_security_SetBlanket(
  99     IClientSecurity *iface,
 100     IUnknown *pProxy,
 101     DWORD AuthnSvc,
 102     DWORD AuthzSvc,
 103     OLECHAR *pServerPrincName,
 104     DWORD AuthnLevel,
 105     DWORD ImpLevel,
 106     void *pAuthInfo,
 107     DWORD Capabilities )
 108 {
 109     static const OLECHAR defaultW[] =
 110         {'<','C','O','L','E','_','D','E','F','A','U','L','T','_','P','R','I','N','C','I','P','A','L','>',0};
 111     const OLECHAR *princname = (pServerPrincName == COLE_DEFAULT_PRINCIPAL) ? defaultW : pServerPrincName;
 112
 113     FIXME("%p, %p, %u, %u, %s, %u, %u, %p, 0x%08x\n", iface, pProxy, AuthnSvc, AuthzSvc,
 114           debugstr_w(princname), AuthnLevel, ImpLevel, pAuthInfo, Capabilities);
 115     return WBEM_NO_ERROR;
 116 }
 117
 118 static HRESULT WINAPI client_security_CopyProxy(
 119     IClientSecurity *iface,
 120     IUnknown *pProxy,
 121     IUnknown **ppCopy )
 122 {
 123     FIXME("\n");
 124     return WBEM_E_FAILED;
 125 }
 126
 127 static const IClientSecurityVtbl client_security_vtbl =
 128 {
 129     client_security_QueryInterface,
 130     client_security_AddRef,
 131     client_security_Release,
 132     client_security_QueryBlanket,
 133     client_security_SetBlanket,
 134     client_security_CopyProxy
 135 };
 136
 137 IClientSecurity client_security = { &client_security_vtbl };
 138
 139 struct wbem_services
 140 {
 141     IWbemServices IWbemServices_iface;
 142     LONG refs;
 143     WCHAR *namespace;
 144 };
 145
 146 static inline struct wbem_services *impl_from_IWbemServices( IWbemServices *iface )
 147 {
 148     return CONTAINING_RECORD( iface, struct wbem_services, IWbemServices_iface );
 149 }
 150
 151 static ULONG WINAPI wbem_services_AddRef(
 152     IWbemServices *iface )
 153 {
 154     struct wbem_services *ws = impl_from_IWbemServices( iface );
 155     return InterlockedIncrement( &ws->refs );
 156 }
 157
 158 static ULONG WINAPI wbem_services_Release(
 159     IWbemServices *iface )
 160 {
 161     struct wbem_services *ws = impl_from_IWbemServices( iface );
 162     LONG refs = InterlockedDecrement( &ws->refs );
 163     if (!refs)
 164     {
 165         TRACE("destroying %p\n", ws);
 166         heap_free( ws->namespace );
 167         heap_free( ws );
 168     }
 169     return refs;
 170 }
 171
 172 static HRESULT WINAPI wbem_services_QueryInterface(
 173     IWbemServices *iface,
 174     REFIID riid,
 175     void **ppvObject )
 176 {
 177     struct wbem_services *ws = impl_from_IWbemServices( iface );
 178
 179     TRACE("%p %s %p\n", ws, debugstr_guid( riid ), ppvObject );
 180
 181     if ( IsEqualGUID( riid, &IID_IWbemServices ) ||
 182          IsEqualGUID( riid, &IID_IUnknown ) )
 183     {
 184         *ppvObject = ws;
 185     }
 186     else if ( IsEqualGUID( riid, &IID_IClientSecurity ) )
 187     {
 188         *ppvObject = &client_security;
 189         return S_OK;
 190     }
 191     else
 192     {
 193         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 194         return E_NOINTERFACE;
 195     }
 196     IWbemServices_AddRef( iface );
 197     return S_OK;
 198 }
 199
 200 static HRESULT WINAPI wbem_services_OpenNamespace(
 201     IWbemServices *iface,
 202     const BSTR strNamespace,
 203     LONG lFlags,
 204     IWbemContext *pCtx,
 205     IWbemServices **ppWorkingNamespace,
 206     IWbemCallResult **ppResult )
 207 {
 208     static const WCHAR cimv2W[] = {'c','i','m','v','2',0};
 209     static const WCHAR defaultW[] = {'d','e','f','a','u','l','t',0};
 210     struct wbem_services *ws = impl_from_IWbemServices( iface );
 211
 212     TRACE("%p, %s, 0x%08x, %p, %p, %p\n", iface, debugstr_w(strNamespace), lFlags,
 213           pCtx, ppWorkingNamespace, ppResult);
 214
 215     if ((strcmpiW( strNamespace, cimv2W ) && strcmpiW( strNamespace, defaultW )) || ws->namespace)
 216         return WBEM_E_INVALID_NAMESPACE;
 217
 218     return WbemServices_create( NULL, cimv2W, (void **)ppWorkingNamespace );
 219 }
 220
 221 static HRESULT WINAPI wbem_services_CancelAsyncCall(
 222     IWbemServices *iface,
 223     IWbemObjectSink *pSink )
 224 {
 225     FIXME("\n");
 226     return WBEM_E_FAILED;
 227 }
 228
 229 static HRESULT WINAPI wbem_services_QueryObjectSink(
 230     IWbemServices *iface,
 231     LONG lFlags,
 232     IWbemObjectSink **ppResponseHandler )
 233 {
 234     FIXME("\n");
 235     return WBEM_E_FAILED;
 236 }
 237
 238 struct path
 239 {
 240     WCHAR *class;
 241     UINT   class_len;
 242     WCHAR *filter;
 243     UINT   filter_len;
 244 };
 245
 246 static HRESULT parse_path( const WCHAR *str, struct path **ret )
 247 {
 248     struct path *path;
 249     const WCHAR *p = str, *q;
 250     UINT len;
 251
 252     if (!(path = heap_alloc_zero( sizeof(*path) ))) return E_OUTOFMEMORY;
 253
 254     while (*p && *p != '.') p++;
 255
 256     len = p - str;
 257     if (!(path->class = heap_alloc( (len + 1) * sizeof(WCHAR) )))
 258     {
 259         heap_free( path );
 260         return E_OUTOFMEMORY;
 261     }
 262     memcpy( path->class, str, len * sizeof(WCHAR) );
 263     path->class[len] = 0;
 264     path->class_len = len;
 265
 266     if (p[0] == '.' && p[1])
 267     {
 268         q = ++p;
 269         while (*q) q++;
 270
 271         len = q - p;
 272         if (!(path->filter = heap_alloc( (len + 1) * sizeof(WCHAR) )))
 273         {
 274             heap_free( path->class );
 275             heap_free( path );
 276             return E_OUTOFMEMORY;
 277         }
 278         memcpy( path->filter, p, len * sizeof(WCHAR) );
 279         path->filter[len] = 0;
 280         path->filter_len = len;
 281     }
 282     *ret = path;
 283     return S_OK;
 284 }
 285
 286 static void free_path( struct path *path )
 287 {
 288     heap_free( path->class );
 289     heap_free( path->filter );
 290     heap_free( path );
 291 }
 292
 293 static HRESULT create_instance_enum( const struct path *path, IEnumWbemClassObject **iter )
 294 {
 295     static const WCHAR selectW[] =
 296         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ','%','s',' ',
 297          'W','H','E','R','E',' ','%','s',0};
 298     static const WCHAR select_allW[] =
 299         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',0};
 300     WCHAR *query;
 301     HRESULT hr;
 302     UINT len;
 303
 304     if (path->filter)
 305     {
 306         len = path->class_len + path->filter_len + SIZEOF(selectW);
 307         if (!(query = heap_alloc( len * sizeof(WCHAR) ))) return E_OUTOFMEMORY;
 308         sprintfW( query, selectW, path->class, path->filter );
 309     }
 310     else
 311     {
 312         len = path->class_len + SIZEOF(select_allW);
 313         if (!(query = heap_alloc( len * sizeof(WCHAR) ))) return E_OUTOFMEMORY;
 314         strcpyW( query, select_allW );
 315         strcatW( query, path->class );
 316     }
 317     hr = exec_query( query, iter );
 318     heap_free( query );
 319     return hr;
 320 }
 321
 322 HRESULT get_object( const WCHAR *object_path, IWbemClassObject **obj )
 323 {
 324     IEnumWbemClassObject *iter;
 325     struct path *path;
 326     HRESULT hr;
 327
 328     hr = parse_path( object_path, &path );
 329     if (hr != S_OK) return hr;
 330
 331     hr = create_instance_enum( path, &iter );
 332     if (hr != S_OK)
 333     {
 334         free_path( path );
 335         return hr;
 336     }
 337     hr = create_class_object( path->class, iter, 0, obj );
 338     IEnumWbemClassObject_Release( iter );
 339     free_path( path );
 340     return hr;
 341 }
 342
 343 static HRESULT WINAPI wbem_services_GetObject(
 344     IWbemServices *iface,
 345     const BSTR strObjectPath,
 346     LONG lFlags,
 347     IWbemContext *pCtx,
 348     IWbemClassObject **ppObject,
 349     IWbemCallResult **ppCallResult )
 350 {
 351     TRACE("%p, %s, 0x%08x, %p, %p, %p\n", iface, debugstr_w(strObjectPath), lFlags,
 352           pCtx, ppObject, ppCallResult);
 353
 354     if (lFlags) FIXME("unsupported flags 0x%08x\n", lFlags);
 355
 356     if (!strObjectPath)
 357     {
 358         FIXME("no support for creating new classes\n");
 359         return WBEM_E_FAILED;
 360     }
 361     return get_object( strObjectPath, ppObject );
 362 }
 363
 364 static HRESULT WINAPI wbem_services_GetObjectAsync(
 365     IWbemServices *iface,
 366     const BSTR strObjectPath,
 367     LONG lFlags,
 368     IWbemContext *pCtx,
 369     IWbemObjectSink *pResponseHandler )
 370 {
 371     FIXME("\n");
 372     return WBEM_E_FAILED;
 373 }
 374
 375 static HRESULT WINAPI wbem_services_PutClass(
 376     IWbemServices *iface,
 377     IWbemClassObject *pObject,
 378     LONG lFlags,
 379     IWbemContext *pCtx,
 380     IWbemCallResult **ppCallResult )
 381 {
 382     FIXME("\n");
 383     return WBEM_E_FAILED;
 384 }
 385
 386 static HRESULT WINAPI wbem_services_PutClassAsync(
 387     IWbemServices *iface,
 388     IWbemClassObject *pObject,
 389     LONG lFlags,
 390     IWbemContext *pCtx,
 391     IWbemObjectSink *pResponseHandler )
 392 {
 393     FIXME("\n");
 394     return WBEM_E_FAILED;
 395 }
 396
 397 static HRESULT WINAPI wbem_services_DeleteClass(
 398     IWbemServices *iface,
 399     const BSTR strClass,
 400     LONG lFlags,
 401     IWbemContext *pCtx,
 402     IWbemCallResult **ppCallResult )
 403 {
 404     FIXME("\n");
 405     return WBEM_E_FAILED;
 406 }
 407
 408 static HRESULT WINAPI wbem_services_DeleteClassAsync(
 409     IWbemServices *iface,
 410     const BSTR strClass,
 411     LONG lFlags,
 412     IWbemContext *pCtx,
 413     IWbemObjectSink *pResponseHandler )
 414 {
 415     FIXME("\n");
 416     return WBEM_E_FAILED;
 417 }
 418
 419 static HRESULT WINAPI wbem_services_CreateClassEnum(
 420     IWbemServices *iface,
 421     const BSTR strSuperclass,
 422     LONG lFlags,
 423     IWbemContext *pCtx,
 424     IEnumWbemClassObject **ppEnum )
 425 {
 426     FIXME("\n");
 427     return WBEM_E_FAILED;
 428 }
 429
 430 static HRESULT WINAPI wbem_services_CreateClassEnumAsync(
 431     IWbemServices *iface,
 432     const BSTR strSuperclass,
 433     LONG lFlags,
 434     IWbemContext *pCtx,
 435     IWbemObjectSink *pResponseHandler )
 436 {
 437     FIXME("\n");
 438     return WBEM_E_FAILED;
 439 }
 440
 441 static HRESULT WINAPI wbem_services_PutInstance(
 442     IWbemServices *iface,
 443     IWbemClassObject *pInst,
 444     LONG lFlags,
 445     IWbemContext *pCtx,
 446     IWbemCallResult **ppCallResult )
 447 {
 448     FIXME("\n");
 449     return WBEM_E_FAILED;
 450 }
 451
 452 static HRESULT WINAPI wbem_services_PutInstanceAsync(
 453     IWbemServices *iface,
 454     IWbemClassObject *pInst,
 455     LONG lFlags,
 456     IWbemContext *pCtx,
 457     IWbemObjectSink *pResponseHandler )
 458 {
 459     FIXME("\n");
 460     return WBEM_E_FAILED;
 461 }
 462
 463 static HRESULT WINAPI wbem_services_DeleteInstance(
 464     IWbemServices *iface,
 465     const BSTR strObjectPath,
 466     LONG lFlags,
 467     IWbemContext *pCtx,
 468     IWbemCallResult **ppCallResult )
 469 {
 470     FIXME("\n");
 471     return WBEM_E_FAILED;
 472 }
 473
 474 static HRESULT WINAPI wbem_services_DeleteInstanceAsync(
 475     IWbemServices *iface,
 476     const BSTR strObjectPath,
 477     LONG lFlags,
 478     IWbemContext *pCtx,
 479     IWbemObjectSink *pResponseHandler )
 480 {
 481     FIXME("\n");
 482     return WBEM_E_FAILED;
 483 }
 484
 485 static HRESULT WINAPI wbem_services_CreateInstanceEnum(
 486     IWbemServices *iface,
 487     const BSTR strClass,
 488     LONG lFlags,
 489     IWbemContext *pCtx,
 490     IEnumWbemClassObject **ppEnum )
 491 {
 492     struct path *path;
 493     HRESULT hr;
 494
 495     TRACE("%p, %s, 0%08x, %p, %p\n", iface, debugstr_w(strClass), lFlags, pCtx, ppEnum);
 496
 497     if (lFlags) FIXME("unsupported flags 0x%08x\n", lFlags);
 498
 499     hr = parse_path( strClass, &path );
 500     if (hr != S_OK) return hr;
 501
 502     hr = create_instance_enum( path, ppEnum );
 503     free_path( path );
 504     return hr;
 505 }
 506
 507 static HRESULT WINAPI wbem_services_CreateInstanceEnumAsync(
 508     IWbemServices *iface,
 509     const BSTR strFilter,
 510     LONG lFlags,
 511     IWbemContext *pCtx,
 512     IWbemObjectSink *pResponseHandler )
 513 {
 514     FIXME("\n");
 515     return WBEM_E_FAILED;
 516 }
 517
 518 static HRESULT WINAPI wbem_services_ExecQuery(
 519     IWbemServices *iface,
 520     const BSTR strQueryLanguage,
 521     const BSTR strQuery,
 522     LONG lFlags,
 523     IWbemContext *pCtx,
 524     IEnumWbemClassObject **ppEnum )
 525 {
 526     static const WCHAR wqlW[] = {'W','Q','L',0};
 527
 528     TRACE("%p, %s, %s, 0x%08x, %p, %p\n", iface, debugstr_w(strQueryLanguage),
 529           debugstr_w(strQuery), lFlags, pCtx, ppEnum);
 530
 531     if (!strQueryLanguage || !strQuery) return WBEM_E_INVALID_PARAMETER;
 532     if (strcmpiW( strQueryLanguage, wqlW )) return WBEM_E_INVALID_QUERY_TYPE;
 533     return exec_query( strQuery, ppEnum );
 534 }
 535
 536 static HRESULT WINAPI wbem_services_ExecQueryAsync(
 537     IWbemServices *iface,
 538     const BSTR strQueryLanguage,
 539     const BSTR strQuery,
 540     LONG lFlags,
 541     IWbemContext *pCtx,
 542     IWbemObjectSink *pResponseHandler )
 543 {
 544     FIXME("\n");
 545     return WBEM_E_FAILED;
 546 }
 547
 548 static HRESULT WINAPI wbem_services_ExecNotificationQuery(
 549     IWbemServices *iface,
 550     const BSTR strQueryLanguage,
 551     const BSTR strQuery,
 552     LONG lFlags,
 553     IWbemContext *pCtx,
 554     IEnumWbemClassObject **ppEnum )
 555 {
 556     FIXME("\n");
 557     return WBEM_E_FAILED;
 558 }
 559
 560 static HRESULT WINAPI wbem_services_ExecNotificationQueryAsync(
 561     IWbemServices *iface,
 562     const BSTR strQueryLanguage,
 563     const BSTR strQuery,
 564     LONG lFlags,
 565     IWbemContext *pCtx,
 566     IWbemObjectSink *pResponseHandler )
 567 {
 568     FIXME("\n");
 569     return WBEM_E_FAILED;
 570 }
 571
 572 static HRESULT WINAPI wbem_services_ExecMethod(
 573     IWbemServices *iface,
 574     const BSTR strObjectPath,
 575     const BSTR strMethodName,
 576     LONG lFlags,
 577     IWbemContext *pCtx,
 578     IWbemClassObject *pInParams,
 579     IWbemClassObject **ppOutParams,
 580     IWbemCallResult **ppCallResult )
 581 {
 582     FIXME("\n");
 583     return WBEM_E_FAILED;
 584 }
 585
 586 static HRESULT WINAPI wbem_services_ExecMethodAsync(
 587     IWbemServices *iface,
 588     const BSTR strObjectPath,
 589     const BSTR strMethodName,
 590     LONG lFlags,
 591     IWbemContext *pCtx,
 592     IWbemClassObject *pInParams,
 593     IWbemObjectSink *pResponseHandler )
 594 {
 595     FIXME("\n");
 596     return WBEM_E_FAILED;
 597 }
 598
 599 static const IWbemServicesVtbl wbem_services_vtbl =
 600 {
 601     wbem_services_QueryInterface,
 602     wbem_services_AddRef,
 603     wbem_services_Release,
 604     wbem_services_OpenNamespace,
 605     wbem_services_CancelAsyncCall,
 606     wbem_services_QueryObjectSink,
 607     wbem_services_GetObject,
 608     wbem_services_GetObjectAsync,
 609     wbem_services_PutClass,
 610     wbem_services_PutClassAsync,
 611     wbem_services_DeleteClass,
 612     wbem_services_DeleteClassAsync,
 613     wbem_services_CreateClassEnum,
 614     wbem_services_CreateClassEnumAsync,
 615     wbem_services_PutInstance,
 616     wbem_services_PutInstanceAsync,
 617     wbem_services_DeleteInstance,
 618     wbem_services_DeleteInstanceAsync,
 619     wbem_services_CreateInstanceEnum,
 620     wbem_services_CreateInstanceEnumAsync,
 621     wbem_services_ExecQuery,
 622     wbem_services_ExecQueryAsync,
 623     wbem_services_ExecNotificationQuery,
 624     wbem_services_ExecNotificationQueryAsync,
 625     wbem_services_ExecMethod,
 626     wbem_services_ExecMethodAsync
 627 };
 628
 629 HRESULT WbemServices_create( IUnknown *pUnkOuter, const WCHAR *namespace, LPVOID *ppObj )
 630 {
 631     struct wbem_services *ws;
 632
 633     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 634
 635     ws = heap_alloc( sizeof(*ws) );
 636     if (!ws) return E_OUTOFMEMORY;
 637
 638     ws->IWbemServices_iface.lpVtbl = &wbem_services_vtbl;
 639     ws->refs = 1;
 640     ws->namespace = heap_strdupW( namespace );
 641
 642     *ppObj = &ws->IWbemServices_iface;
 643
 644     TRACE("returning iface %p\n", *ppObj);
 645     return S_OK;
 646 }