dlls/wbemprox/class.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 "objbase.h"
  27 #include "wbemcli.h"
  28
  29 #include "wine/debug.h"
  30 #include "wbemprox_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(wbemprox);
  33
  34 struct enum_class_object
  35 {
  36     IEnumWbemClassObject IEnumWbemClassObject_iface;
  37     LONG refs;
  38     struct query *query;
  39     UINT index;
  40 };
  41
  42 static inline struct enum_class_object *impl_from_IEnumWbemClassObject(
  43     IEnumWbemClassObject *iface )
  44 {
  45     return CONTAINING_RECORD(iface, struct enum_class_object, IEnumWbemClassObject_iface);
  46 }
  47
  48 static ULONG WINAPI enum_class_object_AddRef(
  49     IEnumWbemClassObject *iface )
  50 {
  51     struct enum_class_object *ec = impl_from_IEnumWbemClassObject( iface );
  52     return InterlockedIncrement( &ec->refs );
  53 }
  54
  55 static ULONG WINAPI enum_class_object_Release(
  56     IEnumWbemClassObject *iface )
  57 {
  58     struct enum_class_object *ec = impl_from_IEnumWbemClassObject( iface );
  59     LONG refs = InterlockedDecrement( &ec->refs );
  60     if (!refs)
  61     {
  62         TRACE("destroying %p\n", ec);
  63         release_query( ec->query );
  64         heap_free( ec );
  65     }
  66     return refs;
  67 }
  68
  69 static HRESULT WINAPI enum_class_object_QueryInterface(
  70     IEnumWbemClassObject *iface,
  71     REFIID riid,
  72     void **ppvObject )
  73 {
  74     struct enum_class_object *ec = impl_from_IEnumWbemClassObject( iface );
  75
  76     TRACE("%p, %s, %p\n", ec, debugstr_guid( riid ), ppvObject );
  77
  78     if ( IsEqualGUID( riid, &IID_IEnumWbemClassObject ) ||
  79          IsEqualGUID( riid, &IID_IUnknown ) )
  80     {
  81         *ppvObject = ec;
  82     }
  83     else if ( IsEqualGUID( riid, &IID_IClientSecurity ) )
  84     {
  85         *ppvObject = &client_security;
  86         return S_OK;
  87     }
  88     else
  89     {
  90         FIXME("interface %s not implemented\n", debugstr_guid(riid));
  91         return E_NOINTERFACE;
  92     }
  93     IEnumWbemClassObject_AddRef( iface );
  94     return S_OK;
  95 }
  96
  97 static HRESULT WINAPI enum_class_object_Reset(
  98     IEnumWbemClassObject *iface )
  99 {
 100     struct enum_class_object *ec = impl_from_IEnumWbemClassObject( iface );
 101
 102     TRACE("%p\n", iface);
 103
 104     ec->index = 0;
 105     return WBEM_S_NO_ERROR;
 106 }
 107
 108 static HRESULT WINAPI enum_class_object_Next(
 109     IEnumWbemClassObject *iface,
 110     LONG lTimeout,
 111     ULONG uCount,
 112     IWbemClassObject **apObjects,
 113     ULONG *puReturned )
 114 {
 115     struct enum_class_object *ec = impl_from_IEnumWbemClassObject( iface );
 116     struct view *view = ec->query->view;
 117     HRESULT hr;
 118
 119     TRACE("%p, %d, %u, %p, %p\n", iface, lTimeout, uCount, apObjects, puReturned);
 120
 121     if (!uCount) return WBEM_S_FALSE;
 122     if (!apObjects || !puReturned) return WBEM_E_INVALID_PARAMETER;
 123     if (lTimeout != WBEM_INFINITE) FIXME("timeout not supported\n");
 124
 125     *puReturned = 0;
 126     if (ec->index + uCount > view->count) return WBEM_S_FALSE;
 127
 128     hr = create_class_object( view->table->name, iface, ec->index, NULL, apObjects );
 129     if (hr != S_OK) return hr;
 130
 131     ec->index++;
 132     *puReturned = 1;
 133     if (ec->index == view->count) return WBEM_S_FALSE;
 134     if (uCount > 1) return WBEM_S_TIMEDOUT;
 135     return WBEM_S_NO_ERROR;
 136 }
 137
 138 static HRESULT WINAPI enum_class_object_NextAsync(
 139     IEnumWbemClassObject *iface,
 140     ULONG uCount,
 141     IWbemObjectSink *pSink )
 142 {
 143     FIXME("%p, %u, %p\n", iface, uCount, pSink);
 144     return E_NOTIMPL;
 145 }
 146
 147 static HRESULT WINAPI enum_class_object_Clone(
 148     IEnumWbemClassObject *iface,
 149     IEnumWbemClassObject **ppEnum )
 150 {
 151     struct enum_class_object *ec = impl_from_IEnumWbemClassObject( iface );
 152
 153     TRACE("%p, %p\n", iface, ppEnum);
 154
 155     return EnumWbemClassObject_create( NULL, ec->query, (void **)ppEnum );
 156 }
 157
 158 static HRESULT WINAPI enum_class_object_Skip(
 159     IEnumWbemClassObject *iface,
 160     LONG lTimeout,
 161     ULONG nCount )
 162 {
 163     struct enum_class_object *ec = impl_from_IEnumWbemClassObject( iface );
 164     struct view *view = ec->query->view;
 165
 166     TRACE("%p, %d, %u\n", iface, lTimeout, nCount);
 167
 168     if (lTimeout != WBEM_INFINITE) FIXME("timeout not supported\n");
 169
 170     if (!view->count) return WBEM_S_FALSE;
 171
 172     if (nCount > view->count - ec->index)
 173     {
 174         ec->index = view->count - 1;
 175         return WBEM_S_FALSE;
 176     }
 177     ec->index += nCount;
 178     return WBEM_S_NO_ERROR;
 179 }
 180
 181 static const IEnumWbemClassObjectVtbl enum_class_object_vtbl =
 182 {
 183     enum_class_object_QueryInterface,
 184     enum_class_object_AddRef,
 185     enum_class_object_Release,
 186     enum_class_object_Reset,
 187     enum_class_object_Next,
 188     enum_class_object_NextAsync,
 189     enum_class_object_Clone,
 190     enum_class_object_Skip
 191 };
 192
 193 HRESULT EnumWbemClassObject_create(
 194     IUnknown *pUnkOuter, struct query *query, LPVOID *ppObj )
 195 {
 196     struct enum_class_object *ec;
 197
 198     TRACE("%p, %p\n", pUnkOuter, ppObj);
 199
 200     ec = heap_alloc( sizeof(*ec) );
 201     if (!ec) return E_OUTOFMEMORY;
 202
 203     ec->IEnumWbemClassObject_iface.lpVtbl = &enum_class_object_vtbl;
 204     ec->refs  = 1;
 205     ec->query = query;
 206     addref_query( query );
 207     ec->index = 0;
 208
 209     *ppObj = &ec->IEnumWbemClassObject_iface;
 210
 211     TRACE("returning iface %p\n", *ppObj);
 212     return S_OK;
 213 }
 214
 215 static struct record *create_record( const struct column *columns, UINT num_cols )
 216 {
 217     UINT i;
 218     struct record *record;
 219
 220     if (!(record = heap_alloc( sizeof(struct record) ))) return NULL;
 221     if (!(record->fields = heap_alloc( num_cols * sizeof(struct field) )))
 222     {
 223         heap_free( record );
 224         return NULL;
 225     }
 226     for (i = 0; i < num_cols; i++)
 227     {
 228         record->fields[i].type   = columns[i].type;
 229         record->fields[i].u.ival = 0;
 230     }
 231     record->count = num_cols;
 232     return record;
 233 }
 234
 235 void destroy_array( struct array *array, CIMTYPE type )
 236 {
 237     UINT i, size;
 238
 239     if (!array) return;
 240     if (type == CIM_STRING || type == CIM_DATETIME)
 241     {
 242         size = get_type_size( type );
 243         for (i = 0; i < array->count; i++) heap_free( *(WCHAR **)((char *)array->ptr + i * size) );
 244     }
 245     heap_free( array->ptr );
 246     heap_free( array );
 247 }
 248
 249 static void destroy_record( struct record *record )
 250 {
 251     UINT i;
 252
 253     if (!record) return;
 254     for (i = 0; i < record->count; i++)
 255     {
 256         if (record->fields[i].type == CIM_STRING || record->fields[i].type == CIM_DATETIME)
 257             heap_free( record->fields[i].u.sval );
 258         else if (record->fields[i].type & CIM_FLAG_ARRAY)
 259             destroy_array( record->fields[i].u.aval, record->fields[i].type & CIM_TYPE_MASK );
 260     }
 261     heap_free( record->fields );
 262     heap_free( record );
 263 }
 264
 265 struct class_object
 266 {
 267     IWbemClassObject IWbemClassObject_iface;
 268     LONG refs;
 269     WCHAR *name;
 270     IEnumWbemClassObject *iter;
 271     UINT index;
 272     UINT index_method;
 273     UINT index_property;
 274     struct record *record; /* uncommitted instance */
 275 };
 276
 277 static inline struct class_object *impl_from_IWbemClassObject(
 278     IWbemClassObject *iface )
 279 {
 280     return CONTAINING_RECORD(iface, struct class_object, IWbemClassObject_iface);
 281 }
 282
 283 static ULONG WINAPI class_object_AddRef(
 284     IWbemClassObject *iface )
 285 {
 286     struct class_object *co = impl_from_IWbemClassObject( iface );
 287     return InterlockedIncrement( &co->refs );
 288 }
 289
 290 static ULONG WINAPI class_object_Release(
 291     IWbemClassObject *iface )
 292 {
 293     struct class_object *co = impl_from_IWbemClassObject( iface );
 294     LONG refs = InterlockedDecrement( &co->refs );
 295     if (!refs)
 296     {
 297         TRACE("destroying %p\n", co);
 298         if (co->iter) IEnumWbemClassObject_Release( co->iter );
 299         destroy_record( co->record );
 300         heap_free( co->name );
 301         heap_free( co );
 302     }
 303     return refs;
 304 }
 305
 306 static HRESULT WINAPI class_object_QueryInterface(
 307     IWbemClassObject *iface,
 308     REFIID riid,
 309     void **ppvObject )
 310 {
 311     struct class_object *co = impl_from_IWbemClassObject( iface );
 312
 313     TRACE("%p, %s, %p\n", co, debugstr_guid( riid ), ppvObject );
 314
 315     if ( IsEqualGUID( riid, &IID_IWbemClassObject ) ||
 316          IsEqualGUID( riid, &IID_IUnknown ) )
 317     {
 318         *ppvObject = co;
 319     }
 320     else if (IsEqualGUID( riid, &IID_IClientSecurity ))
 321     {
 322         *ppvObject = &client_security;
 323         return S_OK;
 324     }
 325     else
 326     {
 327         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 328         return E_NOINTERFACE;
 329     }
 330     IWbemClassObject_AddRef( iface );
 331     return S_OK;
 332 }
 333
 334 static HRESULT WINAPI class_object_GetQualifierSet(
 335     IWbemClassObject *iface,
 336     IWbemQualifierSet **ppQualSet )
 337 {
 338     FIXME("%p, %p\n", iface, ppQualSet);
 339     return E_NOTIMPL;
 340 }
 341
 342 static HRESULT record_get_value( const struct record *record, UINT index, VARIANT *var, CIMTYPE *type )
 343 {
 344     if (type) *type = record->fields[index].type;
 345
 346     if (record->fields[index].type & CIM_FLAG_ARRAY)
 347     {
 348         V_VT( var ) = VT_ARRAY;
 349         V_ARRAY( var ) = to_safearray( record->fields[index].u.aval, record->fields[index].type & COL_TYPE_MASK );
 350         return S_OK;
 351     }
 352     switch (record->fields[index].type)
 353     {
 354     case CIM_STRING:
 355     case CIM_DATETIME:
 356         V_VT( var ) = VT_BSTR;
 357         V_BSTR( var ) = SysAllocString( record->fields[index].u.sval );
 358         return S_OK;
 359     case CIM_SINT32:
 360         V_VT( var ) = VT_I4;
 361         V_I4( var ) = record->fields[index].u.ival;
 362         return S_OK;
 363     case CIM_UINT32:
 364         V_VT( var ) = VT_UI4;
 365         V_UI4( var ) = record->fields[index].u.ival;
 366         return S_OK;
 367     default:
 368         FIXME("unhandled type %u\n", record->fields[index].type);
 369         break;
 370     }
 371     return WBEM_E_INVALID_PARAMETER;
 372 }
 373
 374 static HRESULT WINAPI class_object_Get(
 375     IWbemClassObject *iface,
 376     LPCWSTR wszName,
 377     LONG lFlags,
 378     VARIANT *pVal,
 379     CIMTYPE *pType,
 380     LONG *plFlavor )
 381 {
 382     struct class_object *co = impl_from_IWbemClassObject( iface );
 383     struct enum_class_object *ec = impl_from_IEnumWbemClassObject( co->iter );
 384
 385     TRACE("%p, %s, %08x, %p, %p, %p\n", iface, debugstr_w(wszName), lFlags, pVal, pType, plFlavor);
 386
 387     if (co->record)
 388     {
 389         struct table *table = grab_table( co->name );
 390         UINT index;
 391         HRESULT hr;
 392
 393         if (!table) return WBEM_E_FAILED;
 394         hr = get_column_index( table, wszName, &index );
 395         release_table( table );
 396         if (hr != S_OK) return hr;
 397         return record_get_value( co->record, index, pVal, pType );
 398     }
 399     return get_propval( ec->query->view, co->index, wszName, pVal, pType, plFlavor );
 400 }
 401
 402 static HRESULT record_set_value( struct record *record, UINT index, VARIANT *var )
 403 {
 404     LONGLONG val;
 405     CIMTYPE type;
 406     HRESULT hr;
 407
 408     if ((hr = to_longlong( var, &val, &type )) != S_OK) return hr;
 409     if (type != record->fields[index].type) return WBEM_E_TYPE_MISMATCH;
 410
 411     if (type & CIM_FLAG_ARRAY)
 412     {
 413         record->fields[index].u.aval = (struct array *)(INT_PTR)val;
 414         return S_OK;
 415     }
 416     switch (type)
 417     {
 418     case CIM_STRING:
 419     case CIM_DATETIME:
 420         record->fields[index].u.sval = (WCHAR *)(INT_PTR)val;
 421         return S_OK;
 422     case CIM_SINT16:
 423     case CIM_UINT16:
 424     case CIM_SINT32:
 425     case CIM_UINT32:
 426         record->fields[index].u.ival = val;
 427         return S_OK;
 428     default:
 429         FIXME("unhandled type %u\n", type);
 430         break;
 431     }
 432     return WBEM_E_INVALID_PARAMETER;
 433 }
 434
 435 static HRESULT WINAPI class_object_Put(
 436     IWbemClassObject *iface,
 437     LPCWSTR wszName,
 438     LONG lFlags,
 439     VARIANT *pVal,
 440     CIMTYPE Type )
 441 {
 442     struct class_object *co = impl_from_IWbemClassObject( iface );
 443     struct enum_class_object *ec = impl_from_IEnumWbemClassObject( co->iter );
 444
 445     TRACE("%p, %s, %08x, %p, %u\n", iface, debugstr_w(wszName), lFlags, pVal, Type);
 446
 447     if (co->record)
 448     {
 449         struct table *table = grab_table( co->name );
 450         UINT index;
 451         HRESULT hr;
 452
 453         if (!table) return WBEM_E_FAILED;
 454         hr = get_column_index( table, wszName, &index );
 455         release_table( table );
 456         if (hr != S_OK) return hr;
 457         return record_set_value( co->record, index, pVal );
 458     }
 459     return put_propval( ec->query->view, co->index, wszName, pVal, Type );
 460 }
 461
 462 static HRESULT WINAPI class_object_Delete(
 463     IWbemClassObject *iface,
 464     LPCWSTR wszName )
 465 {
 466     FIXME("%p, %s\n", iface, debugstr_w(wszName));
 467     return E_NOTIMPL;
 468 }
 469
 470 static HRESULT WINAPI class_object_GetNames(
 471     IWbemClassObject *iface,
 472     LPCWSTR wszQualifierName,
 473     LONG lFlags,
 474     VARIANT *pQualifierVal,
 475     SAFEARRAY **pNames )
 476 {
 477     struct class_object *co = impl_from_IWbemClassObject( iface );
 478     struct enum_class_object *ec = impl_from_IEnumWbemClassObject( co->iter );
 479
 480     TRACE("%p, %s, %08x, %p, %p\n", iface, debugstr_w(wszQualifierName), lFlags, pQualifierVal, pNames);
 481
 482     if (wszQualifierName || pQualifierVal)
 483     {
 484         FIXME("qualifier not supported\n");
 485         return E_NOTIMPL;
 486     }
 487     if (lFlags != WBEM_FLAG_ALWAYS)
 488     {
 489         FIXME("flags %08x not supported\n", lFlags);
 490         return E_NOTIMPL;
 491     }
 492     return get_properties( ec->query->view, pNames );
 493 }
 494
 495 static HRESULT WINAPI class_object_BeginEnumeration(
 496     IWbemClassObject *iface,
 497     LONG lEnumFlags )
 498 {
 499     struct class_object *co = impl_from_IWbemClassObject( iface );
 500
 501     TRACE("%p, %08x\n", iface, lEnumFlags);
 502
 503     if (lEnumFlags) FIXME("flags 0x%08x not supported\n", lEnumFlags);
 504
 505     co->index_property = 0;
 506     return S_OK;
 507 }
 508
 509 static HRESULT WINAPI class_object_Next(
 510     IWbemClassObject *iface,
 511     LONG lFlags,
 512     BSTR *strName,
 513     VARIANT *pVal,
 514     CIMTYPE *pType,
 515     LONG *plFlavor )
 516 {
 517     struct class_object *co = impl_from_IWbemClassObject( iface );
 518     struct enum_class_object *ec = impl_from_IEnumWbemClassObject( co->iter );
 519     struct view *view = ec->query->view;
 520     BSTR property;
 521     HRESULT hr;
 522
 523     TRACE("%p, %08x, %p, %p, %p, %p\n", iface, lFlags, strName, pVal, pType, plFlavor);
 524
 525     if (!(property = get_property_name( co->name, co->index_property ))) return WBEM_S_NO_MORE_DATA;
 526     if ((hr = get_propval( view, co->index, property, pVal, pType, plFlavor ) != S_OK))
 527     {
 528         SysFreeString( property );
 529         return hr;
 530     }
 531     *strName = property;
 532     co->index_property++;
 533     return S_OK;
 534 }
 535
 536 static HRESULT WINAPI class_object_EndEnumeration(
 537     IWbemClassObject *iface )
 538 {
 539     struct class_object *co = impl_from_IWbemClassObject( iface );
 540
 541     TRACE("%p\n", iface);
 542
 543     co->index_property = 0;
 544     return S_OK;
 545 }
 546
 547 static HRESULT WINAPI class_object_GetPropertyQualifierSet(
 548     IWbemClassObject *iface,
 549     LPCWSTR wszProperty,
 550     IWbemQualifierSet **ppQualSet )
 551 {
 552     FIXME("%p, %s, %p\n", iface, debugstr_w(wszProperty), ppQualSet);
 553     return E_NOTIMPL;
 554 }
 555
 556 static HRESULT WINAPI class_object_Clone(
 557     IWbemClassObject *iface,
 558     IWbemClassObject **ppCopy )
 559 {
 560     FIXME("%p, %p\n", iface, ppCopy);
 561     return E_NOTIMPL;
 562 }
 563
 564 static BSTR get_body_text( const struct table *table, UINT row, UINT *len )
 565 {
 566     static const WCHAR fmtW[] = {'\n','\t','%','s',' ','=',' ','%','s',';',0};
 567     BSTR value, ret;
 568     WCHAR *p;
 569     UINT i;
 570
 571     *len = 0;
 572     for (i = 0; i < table->num_cols; i++)
 573     {
 574         *len += sizeof(fmtW) / sizeof(fmtW[0]);
 575         *len += strlenW( table->columns[i].name );
 576         value = get_value_bstr( table, row, i );
 577         *len += SysStringLen( value );
 578         SysFreeString( value );
 579     }
 580     if (!(ret = SysAllocStringLen( NULL, *len ))) return NULL;
 581     p = ret;
 582     for (i = 0; i < table->num_cols; i++)
 583     {
 584         value = get_value_bstr( table, row, i );
 585         p += sprintfW( p, fmtW, table->columns[i].name, value );
 586         SysFreeString( value );
 587     }
 588     return ret;
 589 }
 590
 591 static BSTR get_object_text( const struct view *view, UINT index )
 592 {
 593     static const WCHAR fmtW[] =
 594         {'\n','i','n','s','t','a','n','c','e',' ','o','f',' ','%','s','\n','{','%','s','\n','}',';',0};
 595     UINT len, len_body, row = view->result[index];
 596     BSTR ret, body;
 597
 598     len = sizeof(fmtW) / sizeof(fmtW[0]);
 599     len += strlenW( view->table->name );
 600     if (!(body = get_body_text( view->table, row, &len_body ))) return NULL;
 601     len += len_body;
 602
 603     if (!(ret = SysAllocStringLen( NULL, len ))) return NULL;
 604     sprintfW( ret, fmtW, view->table->name, body );
 605     SysFreeString( body );
 606     return ret;
 607 }
 608
 609 static HRESULT WINAPI class_object_GetObjectText(
 610     IWbemClassObject *iface,
 611     LONG lFlags,
 612     BSTR *pstrObjectText )
 613 {
 614     struct class_object *co = impl_from_IWbemClassObject( iface );
 615     struct enum_class_object *ec = impl_from_IEnumWbemClassObject( co->iter );
 616     struct view *view = ec->query->view;
 617     BSTR text;
 618
 619     TRACE("%p, %08x, %p\n", iface, lFlags, pstrObjectText);
 620
 621     if (lFlags) FIXME("flags %08x not implemented\n", lFlags);
 622
 623     if (!(text = get_object_text( view, co->index ))) return E_OUTOFMEMORY;
 624     *pstrObjectText = text;
 625     return S_OK;
 626 }
 627
 628 static HRESULT WINAPI class_object_SpawnDerivedClass(
 629     IWbemClassObject *iface,
 630     LONG lFlags,
 631     IWbemClassObject **ppNewClass )
 632 {
 633     FIXME("%p, %08x, %p\n", iface, lFlags, ppNewClass);
 634     return E_NOTIMPL;
 635 }
 636
 637 static HRESULT WINAPI class_object_SpawnInstance(
 638     IWbemClassObject *iface,
 639     LONG lFlags,
 640     IWbemClassObject **ppNewInstance )
 641 {
 642     struct class_object *co = impl_from_IWbemClassObject( iface );
 643     struct enum_class_object *ec = impl_from_IEnumWbemClassObject( co->iter );
 644     struct view *view = ec->query->view;
 645     struct record *record;
 646
 647     TRACE("%p, %08x, %p\n", iface, lFlags, ppNewInstance);
 648
 649     if (!(record = create_record( view->table->columns, view->table->num_cols )))
 650         return E_OUTOFMEMORY;
 651
 652     return create_class_object( co->name, NULL, 0, record, ppNewInstance );
 653 }
 654
 655 static HRESULT WINAPI class_object_CompareTo(
 656     IWbemClassObject *iface,
 657     LONG lFlags,
 658     IWbemClassObject *pCompareTo )
 659 {
 660     FIXME("%p, %08x, %p\n", iface, lFlags, pCompareTo);
 661     return E_NOTIMPL;
 662 }
 663
 664 static HRESULT WINAPI class_object_GetPropertyOrigin(
 665     IWbemClassObject *iface,
 666     LPCWSTR wszName,
 667     BSTR *pstrClassName )
 668 {
 669     FIXME("%p, %s, %p\n", iface, debugstr_w(wszName), pstrClassName);
 670     return E_NOTIMPL;
 671 }
 672
 673 static HRESULT WINAPI class_object_InheritsFrom(
 674     IWbemClassObject *iface,
 675     LPCWSTR strAncestor )
 676 {
 677     FIXME("%p, %s\n", iface, debugstr_w(strAncestor));
 678     return E_NOTIMPL;
 679 }
 680
 681 static UINT count_instances( IEnumWbemClassObject *iter )
 682 {
 683     UINT count = 0;
 684     while (!IEnumWbemClassObject_Skip( iter, WBEM_INFINITE, 1 )) count++;
 685     IEnumWbemClassObject_Reset( iter );
 686     return count;
 687 }
 688
 689 static void set_default_value( CIMTYPE type, UINT val, BYTE *ptr )
 690 {
 691     switch (type)
 692     {
 693     case CIM_SINT16:
 694         *(INT16 *)ptr = val;
 695         break;
 696     case CIM_UINT16:
 697         *(UINT16 *)ptr = val;
 698         break;
 699     case CIM_SINT32:
 700         *(INT32 *)ptr = val;
 701         break;
 702     case CIM_UINT32:
 703         *(UINT32 *)ptr = val;
 704         break;
 705     default:
 706         FIXME("unhandled type %u\n", type);
 707         break;
 708     }
 709 }
 710
 711 static HRESULT create_signature_columns_and_data( IEnumWbemClassObject *iter, UINT *num_cols,
 712                                            struct column **cols, BYTE **data )
 713 {
 714     static const WCHAR parameterW[] = {'P','a','r','a','m','e','t','e','r',0};
 715     static const WCHAR typeW[] = {'T','y','p','e',0};
 716     static const WCHAR defaultvalueW[] = {'D','e','f','a','u','l','t','V','a','l','u','e',0};
 717     struct column *columns;
 718     BYTE *row;
 719     IWbemClassObject *param;
 720     VARIANT val;
 721     HRESULT hr = E_OUTOFMEMORY;
 722     UINT offset = 0;
 723     ULONG count;
 724     int i = 0;
 725
 726     count = count_instances( iter );
 727     if (!(columns = heap_alloc( count * sizeof(struct column) ))) return E_OUTOFMEMORY;
 728     if (!(row = heap_alloc_zero( count * sizeof(LONGLONG) ))) goto error;
 729
 730     for (;;)
 731     {
 732         IEnumWbemClassObject_Next( iter, WBEM_INFINITE, 1, &param, &count );
 733         if (!count) break;
 734
 735         hr = IWbemClassObject_Get( param, parameterW, 0, &val, NULL, NULL );
 736         if (hr != S_OK) goto error;
 737         columns[i].name = heap_strdupW( V_BSTR( &val ) );
 738         VariantClear( &val );
 739
 740         hr = IWbemClassObject_Get( param, typeW, 0, &val, NULL, NULL );
 741         if (hr != S_OK) goto error;
 742         columns[i].type    = V_UI4( &val );
 743         columns[i].vartype = 0;
 744
 745         hr = IWbemClassObject_Get( param, defaultvalueW, 0, &val, NULL, NULL );
 746         if (hr != S_OK) goto error;
 747         if (V_UI4( &val )) set_default_value( columns[i].type, V_UI4( &val ), row + offset );
 748         offset += get_type_size( columns[i].type );
 749
 750         IWbemClassObject_Release( param );
 751         i++;
 752     }
 753     *num_cols = i;
 754     *cols = columns;
 755     *data = row;
 756     return S_OK;
 757
 758 error:
 759     for (; i >= 0; i--) heap_free( (WCHAR *)columns[i].name );
 760     heap_free( columns );
 761     heap_free( row );
 762     return hr;
 763 }
 764
 765 static HRESULT create_signature_table( IEnumWbemClassObject *iter, WCHAR *name )
 766 {
 767     HRESULT hr;
 768     struct table *table;
 769     struct column *columns;
 770     UINT num_cols;
 771     BYTE *row;
 772
 773     hr = create_signature_columns_and_data( iter, &num_cols, &columns, &row );
 774     if (hr != S_OK) return hr;
 775
 776     if (!(table = create_table( name, num_cols, columns, 1, row, NULL )))
 777     {
 778         free_columns( columns, num_cols );
 779         heap_free( row );
 780         return E_OUTOFMEMORY;
 781     }
 782     if (!add_table( table )) free_table( table ); /* already exists */
 783     return S_OK;
 784 }
 785
 786 static WCHAR *build_signature_table_name( const WCHAR *class, const WCHAR *method, enum param_direction dir )
 787 {
 788     static const WCHAR fmtW[] = {'_','_','%','s','_','%','s','_','%','s',0};
 789     static const WCHAR outW[] = {'O','U','T',0};
 790     static const WCHAR inW[] = {'I','N',0};
 791     UINT len = SIZEOF(fmtW) + SIZEOF(outW) + strlenW( class ) + strlenW( method );
 792     WCHAR *ret;
 793
 794     if (!(ret = heap_alloc( len * sizeof(WCHAR) ))) return NULL;
 795     sprintfW( ret, fmtW, class, method, dir == PARAM_IN ? inW : outW );
 796     return struprW( ret );
 797 }
 798
 799 static HRESULT create_signature( const WCHAR *class, const WCHAR *method, enum param_direction dir,
 800                                  IWbemClassObject **sig )
 801 {
 802     static const WCHAR selectW[] =
 803         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 804          '_','_','P','A','R','A','M','E','T','E','R','S',' ','W','H','E','R','E',' ',
 805          'C','l','a','s','s','=','\'','%','s','\'',' ','A','N','D',' ',
 806          'M','e','t','h','o','d','=','\'','%','s','\'',' ','A','N','D',' ',
 807          'D','i','r','e','c','t','i','o','n','%','s',0};
 808     static const WCHAR geW[] = {'>','=','0',0};
 809     static const WCHAR leW[] = {'<','=','0',0};
 810     UINT len = SIZEOF(selectW) + SIZEOF(geW);
 811     IEnumWbemClassObject *iter;
 812     WCHAR *query, *name;
 813     HRESULT hr;
 814
 815     len += strlenW( class ) + strlenW( method );
 816     if (!(query = heap_alloc( len * sizeof(WCHAR) ))) return E_OUTOFMEMORY;
 817     sprintfW( query, selectW, class, method, dir >= 0 ? geW : leW );
 818
 819     hr = exec_query( query, &iter );
 820     heap_free( query );
 821     if (hr != S_OK) return hr;
 822
 823     if (!(name = build_signature_table_name( class, method, dir )))
 824     {
 825         IEnumWbemClassObject_Release( iter );
 826         return E_OUTOFMEMORY;
 827     }
 828     hr = create_signature_table( iter, name );
 829     IEnumWbemClassObject_Release( iter );
 830     if (hr != S_OK)
 831     {
 832         heap_free( name );
 833         return hr;
 834     }
 835     return get_object( name, sig );
 836 }
 837
 838 static HRESULT WINAPI class_object_GetMethod(
 839     IWbemClassObject *iface,
 840     LPCWSTR wszName,
 841     LONG lFlags,
 842     IWbemClassObject **ppInSignature,
 843     IWbemClassObject **ppOutSignature )
 844 {
 845     struct class_object *co = impl_from_IWbemClassObject( iface );
 846     HRESULT hr;
 847
 848     TRACE("%p, %s, %08x, %p, %p\n", iface, debugstr_w(wszName), lFlags, ppInSignature, ppOutSignature);
 849
 850     hr = create_signature( co->name, wszName, PARAM_IN, ppInSignature );
 851     if (hr != S_OK) return hr;
 852
 853     hr = create_signature( co->name, wszName, PARAM_OUT, ppOutSignature );
 854     if (hr != S_OK) IWbemClassObject_Release( *ppInSignature );
 855     return hr;
 856 }
 857
 858 static HRESULT WINAPI class_object_PutMethod(
 859     IWbemClassObject *iface,
 860     LPCWSTR wszName,
 861     LONG lFlags,
 862     IWbemClassObject *pInSignature,
 863     IWbemClassObject *pOutSignature )
 864 {
 865     FIXME("%p, %s, %08x, %p, %p\n", iface, debugstr_w(wszName), lFlags, pInSignature, pOutSignature);
 866     return E_NOTIMPL;
 867 }
 868
 869 static HRESULT WINAPI class_object_DeleteMethod(
 870     IWbemClassObject *iface,
 871     LPCWSTR wszName )
 872 {
 873     FIXME("%p, %s\n", iface, debugstr_w(wszName));
 874     return E_NOTIMPL;
 875 }
 876
 877 static HRESULT WINAPI class_object_BeginMethodEnumeration(
 878     IWbemClassObject *iface,
 879     LONG lEnumFlags)
 880 {
 881     struct class_object *co = impl_from_IWbemClassObject( iface );
 882
 883     TRACE("%p, %08x\n", iface, lEnumFlags);
 884
 885     if (lEnumFlags) FIXME("flags 0x%08x not supported\n", lEnumFlags);
 886
 887     if (co->iter)
 888     {
 889         WARN("not allowed on instance\n");
 890         return WBEM_E_ILLEGAL_OPERATION;
 891     }
 892     co->index_method = 0;
 893     return S_OK;
 894 }
 895
 896 static HRESULT WINAPI class_object_NextMethod(
 897     IWbemClassObject *iface,
 898     LONG lFlags,
 899     BSTR *pstrName,
 900     IWbemClassObject **ppInSignature,
 901     IWbemClassObject **ppOutSignature)
 902 {
 903     struct class_object *co = impl_from_IWbemClassObject( iface );
 904     BSTR method;
 905     HRESULT hr;
 906
 907     TRACE("%p, %08x, %p, %p, %p\n", iface, lFlags, pstrName, ppInSignature, ppOutSignature);
 908
 909     if (!(method = get_method_name( co->name, co->index_method ))) return WBEM_S_NO_MORE_DATA;
 910
 911     hr = create_signature( co->name, method, PARAM_IN, ppInSignature );
 912     if (hr != S_OK)
 913     {
 914         SysFreeString( method );
 915         return hr;
 916     }
 917     hr = create_signature( co->name, method, PARAM_OUT, ppOutSignature );
 918     if (hr != S_OK)
 919     {
 920         SysFreeString( method );
 921         IWbemClassObject_Release( *ppInSignature );
 922     }
 923     else
 924     {
 925         *pstrName = method;
 926         co->index_method++;
 927     }
 928     return hr;
 929 }
 930
 931 static HRESULT WINAPI class_object_EndMethodEnumeration(
 932     IWbemClassObject *iface )
 933 {
 934     struct class_object *co = impl_from_IWbemClassObject( iface );
 935
 936     TRACE("%p\n", iface);
 937
 938     co->index_method = 0;
 939     return S_OK;
 940 }
 941
 942 static HRESULT WINAPI class_object_GetMethodQualifierSet(
 943     IWbemClassObject *iface,
 944     LPCWSTR wszMethod,
 945     IWbemQualifierSet **ppQualSet)
 946 {
 947     FIXME("%p, %s, %p\n", iface, debugstr_w(wszMethod), ppQualSet);
 948     return E_NOTIMPL;
 949 }
 950
 951 static HRESULT WINAPI class_object_GetMethodOrigin(
 952     IWbemClassObject *iface,
 953     LPCWSTR wszMethodName,
 954     BSTR *pstrClassName)
 955 {
 956     FIXME("%p, %s, %p\n", iface, debugstr_w(wszMethodName), pstrClassName);
 957     return E_NOTIMPL;
 958 }
 959
 960 static const IWbemClassObjectVtbl class_object_vtbl =
 961 {
 962     class_object_QueryInterface,
 963     class_object_AddRef,
 964     class_object_Release,
 965     class_object_GetQualifierSet,
 966     class_object_Get,
 967     class_object_Put,
 968     class_object_Delete,
 969     class_object_GetNames,
 970     class_object_BeginEnumeration,
 971     class_object_Next,
 972     class_object_EndEnumeration,
 973     class_object_GetPropertyQualifierSet,
 974     class_object_Clone,
 975     class_object_GetObjectText,
 976     class_object_SpawnDerivedClass,
 977     class_object_SpawnInstance,
 978     class_object_CompareTo,
 979     class_object_GetPropertyOrigin,
 980     class_object_InheritsFrom,
 981     class_object_GetMethod,
 982     class_object_PutMethod,
 983     class_object_DeleteMethod,
 984     class_object_BeginMethodEnumeration,
 985     class_object_NextMethod,
 986     class_object_EndMethodEnumeration,
 987     class_object_GetMethodQualifierSet,
 988     class_object_GetMethodOrigin
 989 };
 990
 991 HRESULT create_class_object( const WCHAR *name, IEnumWbemClassObject *iter, UINT index,
 992                              struct record *record, IWbemClassObject **obj )
 993 {
 994     struct class_object *co;
 995
 996     TRACE("%s, %p\n", debugstr_w(name), obj);
 997
 998     co = heap_alloc( sizeof(*co) );
 999     if (!co) return E_OUTOFMEMORY;
1000
1001     co->IWbemClassObject_iface.lpVtbl = &class_object_vtbl;
1002     co->refs  = 1;
1003     co->name  = heap_strdupW( name );
1004     if (!co->name)
1005     {
1006         heap_free( co );
1007         return E_OUTOFMEMORY;
1008     }
1009     co->iter           = iter;
1010     co->index          = index;
1011     co->index_method   = 0;
1012     co->index_property = 0;
1013     co->record         = record;
1014     if (iter) IEnumWbemClassObject_AddRef( iter );
1015
1016     *obj = &co->IWbemClassObject_iface;
1017
1018     TRACE("returning iface %p\n", *obj);
1019     return S_OK;
1020 }