reactos/dll/win32/wbemprox/query.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 #include "wbemprox_private.h"
  20
  21 HRESULT create_view( const struct property *proplist, const WCHAR *class,
  22                      const struct expr *cond, struct view **ret )
  23 {
  24     struct view *view = heap_alloc( sizeof(struct view) );
  25
  26     if (!view) return E_OUTOFMEMORY;
  27     view->proplist = proplist;
  28     view->table    = grab_table( class );
  29     view->cond     = cond;
  30     view->result   = NULL;
  31     view->count    = 0;
  32     *ret = view;
  33     return S_OK;
  34 }
  35
  36 void destroy_view( struct view *view )
  37 {
  38     if (!view) return;
  39     if (view->table) release_table( view->table );
  40     heap_free( view->result );
  41     heap_free( view );
  42 }
  43
  44 static BOOL eval_like( const WCHAR *lstr, const WCHAR *rstr )
  45 {
  46     const WCHAR *p = lstr, *q = rstr;
  47
  48     while (*p && *q)
  49     {
  50         if (*q == '%')
  51         {
  52             while (*q == '%') q++;
  53             if (!*q) return TRUE;
  54             while (*p && toupperW( p[1] ) != toupperW( q[1] )) p++;
  55             if (!*p) return TRUE;
  56         }
  57         if (toupperW( *p++ ) != toupperW( *q++ )) return FALSE;
  58     }
  59     return TRUE;
  60 }
  61
  62 static HRESULT eval_strcmp( UINT op, const WCHAR *lstr, const WCHAR *rstr, LONGLONG *val )
  63 {
  64     if (!lstr || !rstr)
  65     {
  66         *val = 0;
  67         return S_OK;
  68     }
  69     switch (op)
  70     {
  71     case OP_EQ:
  72         *val = !strcmpW( lstr, rstr );
  73         break;
  74     case OP_GT:
  75         *val = strcmpW( lstr, rstr ) > 0;
  76         break;
  77     case OP_LT:
  78         *val = strcmpW( lstr, rstr ) < 0;
  79         break;
  80     case OP_LE:
  81         *val = strcmpW( lstr, rstr ) <= 0;
  82         break;
  83     case OP_GE:
  84         *val = strcmpW( lstr, rstr ) >= 0;
  85         break;
  86     case OP_NE:
  87         *val = strcmpW( lstr, rstr );
  88         break;
  89     case OP_LIKE:
  90         *val = eval_like( lstr, rstr );
  91         break;
  92     default:
  93         ERR("unhandled operator %u\n", op);
  94         return WBEM_E_INVALID_QUERY;
  95     }
  96     return S_OK;
  97 }
  98
  99 static inline BOOL is_strcmp( const struct complex_expr *expr )
 100 {
 101     return ((expr->left->type == EXPR_PROPVAL && expr->right->type == EXPR_SVAL) ||
 102             (expr->left->type == EXPR_SVAL && expr->right->type == EXPR_PROPVAL));
 103 }
 104
 105 static HRESULT eval_binary( const struct table *table, UINT row, const struct complex_expr *expr,
 106                             LONGLONG *val )
 107 {
 108     HRESULT lret, rret;
 109     LONGLONG lval, rval;
 110
 111     lret = eval_cond( table, row, expr->left, &lval );
 112     rret = eval_cond( table, row, expr->right, &rval );
 113     if (lret != S_OK || rret != S_OK) return WBEM_E_INVALID_QUERY;
 114
 115     if (is_strcmp( expr ))
 116     {
 117         const WCHAR *lstr = (const WCHAR *)(INT_PTR)lval;
 118         const WCHAR *rstr = (const WCHAR *)(INT_PTR)rval;
 119
 120         return eval_strcmp( expr->op, lstr, rstr, val );
 121     }
 122     switch (expr->op)
 123     {
 124     case OP_EQ:
 125         *val = (lval == rval);
 126         break;
 127     case OP_AND:
 128         *val = (lval && rval);
 129         break;
 130     case OP_OR:
 131         *val = (lval || rval);
 132         break;
 133     case OP_GT:
 134         *val = (lval > rval);
 135         break;
 136     case OP_LT:
 137         *val = (lval < rval);
 138         break;
 139     case OP_LE:
 140         *val = (lval <= rval);
 141         break;
 142     case OP_GE:
 143         *val = (lval >= rval);
 144         break;
 145     case OP_NE:
 146         *val = (lval != rval);
 147         break;
 148     default:
 149         ERR("unhandled operator %u\n", expr->op);
 150         return WBEM_E_INVALID_QUERY;
 151     }
 152     return S_OK;
 153 }
 154
 155 static HRESULT eval_unary( const struct table *table, UINT row, const struct complex_expr *expr,
 156                            LONGLONG *val )
 157
 158 {
 159     HRESULT hr;
 160     UINT column;
 161     LONGLONG lval;
 162
 163     hr = get_column_index( table, expr->left->u.propval->name, &column );
 164     if (hr != S_OK)
 165         return hr;
 166
 167     hr = get_value( table, row, column, &lval );
 168     if (hr != S_OK)
 169         return hr;
 170
 171     switch (expr->op)
 172     {
 173     case OP_ISNULL:
 174         *val = !lval;
 175         break;
 176     case OP_NOTNULL:
 177         *val = lval;
 178         break;
 179     default:
 180         ERR("unknown operator %u\n", expr->op);
 181         return WBEM_E_INVALID_QUERY;
 182     }
 183     return S_OK;
 184 }
 185
 186 static HRESULT eval_propval( const struct table *table, UINT row, const struct property *propval,
 187                              LONGLONG *val )
 188
 189 {
 190     HRESULT hr;
 191     UINT column;
 192
 193     hr = get_column_index( table, propval->name, &column );
 194     if (hr != S_OK)
 195         return hr;
 196
 197     return get_value( table, row, column, val );
 198 }
 199
 200 HRESULT eval_cond( const struct table *table, UINT row, const struct expr *cond, LONGLONG *val )
 201 {
 202     if (!cond)
 203     {
 204         *val = 1;
 205         return S_OK;
 206     }
 207     switch (cond->type)
 208     {
 209     case EXPR_COMPLEX:
 210         return eval_binary( table, row, &cond->u.expr, val );
 211     case EXPR_UNARY:
 212         return eval_unary( table, row, &cond->u.expr, val );
 213     case EXPR_PROPVAL:
 214         return eval_propval( table, row, cond->u.propval, val );
 215     case EXPR_SVAL:
 216         *val = (INT_PTR)cond->u.sval;
 217         return S_OK;
 218     case EXPR_IVAL:
 219     case EXPR_BVAL:
 220         *val = cond->u.ival;
 221         return S_OK;
 222     default:
 223         ERR("invalid expression type\n");
 224         break;
 225     }
 226     return WBEM_E_INVALID_QUERY;
 227 }
 228
 229 HRESULT execute_view( struct view *view )
 230 {
 231     UINT i, j = 0, len;
 232
 233     if (!view->table) return S_OK;
 234     if (view->table->fill)
 235     {
 236         clear_table( view->table );
 237         view->table->fill( view->table, view->cond );
 238     }
 239     if (!view->table->num_rows) return S_OK;
 240
 241     len = min( view->table->num_rows, 16 );
 242     if (!(view->result = heap_alloc( len * sizeof(UINT) ))) return E_OUTOFMEMORY;
 243
 244     for (i = 0; i < view->table->num_rows; i++)
 245     {
 246         HRESULT hr;
 247         LONGLONG val = 0;
 248
 249         if (j >= len)
 250         {
 251             UINT *tmp;
 252             len *= 2;
 253             if (!(tmp = heap_realloc( view->result, len * sizeof(UINT) ))) return E_OUTOFMEMORY;
 254             view->result = tmp;
 255         }
 256         if ((hr = eval_cond( view->table, i, view->cond, &val )) != S_OK) return hr;
 257         if (val) view->result[j++] = i;
 258     }
 259     view->count = j;
 260     return S_OK;
 261 }
 262
 263 struct query *create_query(void)
 264 {
 265     struct query *query;
 266
 267     if (!(query = heap_alloc( sizeof(*query) ))) return NULL;
 268     list_init( &query->mem );
 269     query->refs = 1;
 270     return query;
 271 }
 272
 273 void free_query( struct query *query )
 274 {
 275     struct list *mem, *next;
 276
 277     if (!query) return;
 278     destroy_view( query->view );
 279     LIST_FOR_EACH_SAFE( mem, next, &query->mem ) { heap_free( mem ); }
 280     heap_free( query );
 281 }
 282
 283 struct query *addref_query( struct query *query )
 284 {
 285     InterlockedIncrement( &query->refs );
 286     return query;
 287 }
 288
 289 void release_query( struct query *query )
 290 {
 291     if (!InterlockedDecrement( &query->refs )) free_query( query );
 292 }
 293
 294 HRESULT exec_query( const WCHAR *str, IEnumWbemClassObject **result )
 295 {
 296     HRESULT hr;
 297     struct query *query;
 298
 299     *result = NULL;
 300     if (!(query = create_query())) return E_OUTOFMEMORY;
 301     hr = parse_query( str, &query->view, &query->mem );
 302     if (hr != S_OK) goto done;
 303     hr = execute_view( query->view );
 304     if (hr != S_OK) goto done;
 305     hr = EnumWbemClassObject_create( NULL, query, (void **)result );
 306
 307 done:
 308     release_query( query );
 309     return hr;
 310 }
 311
 312 static BOOL is_selected_prop( const struct view *view, const WCHAR *name )
 313 {
 314     const struct property *prop = view->proplist;
 315
 316     if (!prop) return TRUE;
 317     while (prop)
 318     {
 319         if (!strcmpiW( prop->name, name )) return TRUE;
 320         prop = prop->next;
 321     }
 322     return FALSE;
 323 }
 324
 325 static BOOL is_system_prop( const WCHAR *name )
 326 {
 327     return (name[0] == '_' && name[1] == '_');
 328 }
 329
 330 static BSTR build_servername( const struct view *view )
 331 {
 332     WCHAR server[MAX_COMPUTERNAME_LENGTH + 1], *p;
 333     DWORD len = sizeof(server)/sizeof(server[0]);
 334
 335     if (view->proplist) return NULL;
 336
 337     if (!(GetComputerNameW( server, &len ))) return NULL;
 338     for (p = server; *p; p++) *p = toupperW( *p );
 339     return SysAllocString( server );
 340 }
 341
 342 static BSTR build_classname( const struct view *view )
 343 {
 344     return SysAllocString( view->table->name );
 345 }
 346
 347 static BSTR build_namespace( const struct view *view )
 348 {
 349     static const WCHAR cimv2W[] = {'R','O','O','T','\\','C','I','M','V','2',0};
 350
 351     if (view->proplist) return NULL;
 352     return SysAllocString( cimv2W );
 353 }
 354
 355 static BSTR build_proplist( const struct view *view, UINT index, UINT count, UINT *len )
 356 {
 357     static const WCHAR fmtW[] = {'%','s','=','%','s',0};
 358     UINT i, j, offset, row = view->result[index];
 359     BSTR *values, ret = NULL;
 360
 361     if (!(values = heap_alloc( count * sizeof(BSTR) ))) return NULL;
 362
 363     *len = j = 0;
 364     for (i = 0; i < view->table->num_cols; i++)
 365     {
 366         if (view->table->columns[i].type & COL_FLAG_KEY)
 367         {
 368             const WCHAR *name = view->table->columns[i].name;
 369
 370             values[j] = get_value_bstr( view->table, row, i );
 371             *len += strlenW( fmtW ) + strlenW( name ) + strlenW( values[j] );
 372             j++;
 373         }
 374     }
 375     if ((ret = SysAllocStringLen( NULL, *len )))
 376     {
 377         offset = j = 0;
 378         for (i = 0; i < view->table->num_cols; i++)
 379         {
 380             if (view->table->columns[i].type & COL_FLAG_KEY)
 381             {
 382                 const WCHAR *name = view->table->columns[i].name;
 383
 384                 offset += sprintfW( ret + offset, fmtW, name, values[j] );
 385                 if (j < count - 1) ret[offset++] = ',';
 386                 j++;
 387             }
 388         }
 389     }
 390     for (i = 0; i < count; i++) SysFreeString( values[i] );
 391     heap_free( values );
 392     return ret;
 393 }
 394
 395 static UINT count_key_columns( const struct view *view )
 396 {
 397     UINT i, num_keys = 0;
 398
 399     for (i = 0; i < view->table->num_cols; i++)
 400     {
 401         if (view->table->columns[i].type & COL_FLAG_KEY) num_keys++;
 402     }
 403     return num_keys;
 404 }
 405
 406 static BSTR build_relpath( const struct view *view, UINT index, const WCHAR *name )
 407 {
 408     static const WCHAR fmtW[] = {'%','s','.','%','s',0};
 409     BSTR class, proplist, ret = NULL;
 410     UINT num_keys, len;
 411
 412     if (view->proplist) return NULL;
 413
 414     if (!(class = build_classname( view ))) return NULL;
 415     if (!(num_keys = count_key_columns( view ))) return class;
 416     if (!(proplist = build_proplist( view, index, num_keys, &len ))) goto done;
 417
 418     len += strlenW( fmtW ) + SysStringLen( class );
 419     if (!(ret = SysAllocStringLen( NULL, len ))) goto done;
 420     sprintfW( ret, fmtW, class, proplist );
 421
 422 done:
 423     SysFreeString( class );
 424     SysFreeString( proplist );
 425     return ret;
 426 }
 427
 428 static BSTR build_path( const struct view *view, UINT index, const WCHAR *name )
 429 {
 430     static const WCHAR fmtW[] = {'\\','\\','%','s','\\','%','s',':','%','s',0};
 431     BSTR server, namespace = NULL, relpath = NULL, ret = NULL;
 432     UINT len;
 433
 434     if (view->proplist) return NULL;
 435
 436     if (!(server = build_servername( view ))) return NULL;
 437     if (!(namespace = build_namespace( view ))) goto done;
 438     if (!(relpath = build_relpath( view, index, name ))) goto done;
 439
 440     len = strlenW( fmtW ) + SysStringLen( server ) + SysStringLen( namespace ) + SysStringLen( relpath );
 441     if (!(ret = SysAllocStringLen( NULL, len ))) goto done;
 442     sprintfW( ret, fmtW, server, namespace, relpath );
 443
 444 done:
 445     SysFreeString( server );
 446     SysFreeString( namespace );
 447     SysFreeString( relpath );
 448     return ret;
 449 }
 450
 451 static inline BOOL is_method( const struct table *table, UINT column )
 452 {
 453     return table->columns[column].type & COL_FLAG_METHOD;
 454 }
 455
 456 static UINT count_properties( const struct view *view )
 457 {
 458     UINT i, num_props = 0;
 459
 460     for (i = 0; i < view->table->num_cols; i++)
 461     {
 462         if (!is_method( view->table, i)) num_props++;
 463     }
 464     return num_props;
 465 }
 466
 467 static UINT count_selected_properties( const struct view *view )
 468 {
 469     const struct property *prop = view->proplist;
 470     UINT count;
 471
 472     if (!prop) return count_properties( view );
 473
 474     count = 1;
 475     while ((prop = prop->next)) count++;
 476     return count;
 477 }
 478
 479 static HRESULT get_system_propval( const struct view *view, UINT index, const WCHAR *name,
 480                                    VARIANT *ret, CIMTYPE *type, LONG *flavor )
 481 {
 482     static const WCHAR classW[] = {'_','_','C','L','A','S','S',0};
 483     static const WCHAR genusW[] = {'_','_','G','E','N','U','S',0};
 484     static const WCHAR pathW[] = {'_','_','P','A','T','H',0};
 485     static const WCHAR namespaceW[] = {'_','_','N','A','M','E','S','P','A','C','E',0};
 486     static const WCHAR propcountW[] = {'_','_','P','R','O','P','E','R','T','Y','_','C','O','U','N','T',0};
 487     static const WCHAR relpathW[] = {'_','_','R','E','L','P','A','T','H',0};
 488     static const WCHAR serverW[] = {'_','_','S','E','R','V','E','R',0};
 489
 490     if (flavor) *flavor = WBEM_FLAVOR_ORIGIN_SYSTEM;
 491
 492     if (!strcmpiW( name, classW ))
 493     {
 494         V_VT( ret ) = VT_BSTR;
 495         V_BSTR( ret ) = build_classname( view );
 496         if (type) *type = CIM_STRING;
 497         return S_OK;
 498     }
 499     if (!strcmpiW( name, genusW ))
 500     {
 501         V_VT( ret ) = VT_I4;
 502         V_I4( ret ) = WBEM_GENUS_INSTANCE; /* FIXME */
 503         if (type) *type = CIM_SINT32;
 504         return S_OK;
 505     }
 506     else if (!strcmpiW( name, namespaceW ))
 507     {
 508         V_VT( ret ) = VT_BSTR;
 509         V_BSTR( ret ) = build_namespace( view );
 510         if (type) *type = CIM_STRING;
 511         return S_OK;
 512     }
 513     else if (!strcmpiW( name, pathW ))
 514     {
 515         V_VT( ret ) = VT_BSTR;
 516         V_BSTR( ret ) = build_path( view, index, name );
 517         if (type) *type = CIM_STRING;
 518         return S_OK;
 519     }
 520     if (!strcmpiW( name, propcountW ))
 521     {
 522         V_VT( ret ) = VT_I4;
 523         V_I4( ret ) = count_selected_properties( view );
 524         if (type) *type = CIM_SINT32;
 525         return S_OK;
 526     }
 527     else if (!strcmpiW( name, relpathW ))
 528     {
 529         V_VT( ret ) = VT_BSTR;
 530         V_BSTR( ret ) = build_relpath( view, index, name );
 531         if (type) *type = CIM_STRING;
 532         return S_OK;
 533     }
 534     else if (!strcmpiW( name, serverW ))
 535     {
 536         V_VT( ret ) = VT_BSTR;
 537         V_BSTR( ret ) = build_servername( view );
 538         if (type) *type = CIM_STRING;
 539         return S_OK;
 540     }
 541     FIXME("system property %s not implemented\n", debugstr_w(name));
 542     return WBEM_E_NOT_FOUND;
 543 }
 544
 545 VARTYPE to_vartype( CIMTYPE type )
 546 {
 547     switch (type)
 548     {
 549     case CIM_BOOLEAN:  return VT_BOOL;
 550     case CIM_STRING:
 551     case CIM_DATETIME: return VT_BSTR;
 552     case CIM_SINT16:   return VT_I2;
 553     case CIM_UINT16:   return VT_UI2;
 554     case CIM_SINT32:   return VT_I4;
 555     case CIM_UINT32:   return VT_UI4;
 556     case CIM_SINT64:   return VT_I8;
 557     case CIM_UINT64:   return VT_UI8;
 558     default:
 559         ERR("unhandled type %u\n", type);
 560         break;
 561     }
 562     return 0;
 563 }
 564
 565 SAFEARRAY *to_safearray( const struct array *array, CIMTYPE type )
 566 {
 567     SAFEARRAY *ret;
 568     UINT size = get_type_size( type );
 569     VARTYPE vartype = to_vartype( type );
 570     LONG i;
 571
 572     if (!array || !(ret = SafeArrayCreateVector( vartype, 0, array->count ))) return NULL;
 573
 574     for (i = 0; i < array->count; i++)
 575     {
 576         void *ptr = (char *)array->ptr + i * size;
 577         if (vartype == VT_BSTR)
 578         {
 579             BSTR str = SysAllocString( *(const WCHAR **)ptr );
 580             if (!str || SafeArrayPutElement( ret, &i, str ) != S_OK)
 581             {
 582                 SysFreeString( str );
 583                 SafeArrayDestroy( ret );
 584                 return NULL;
 585             }
 586         }
 587         else if (SafeArrayPutElement( ret, &i, ptr ) != S_OK)
 588         {
 589             SafeArrayDestroy( ret );
 590             return NULL;
 591         }
 592     }
 593     return ret;
 594 }
 595
 596 void set_variant( VARTYPE type, LONGLONG val, void *val_ptr, VARIANT *ret )
 597 {
 598     if (type & VT_ARRAY)
 599     {
 600         V_VT( ret ) = type;
 601         V_ARRAY( ret ) = val_ptr;
 602         return;
 603     }
 604     switch (type)
 605     {
 606     case VT_BOOL:
 607         V_BOOL( ret ) = val;
 608         break;
 609     case VT_BSTR:
 610         V_BSTR( ret ) = val_ptr;
 611         break;
 612     case VT_I2:
 613         V_I2( ret ) = val;
 614         break;
 615     case VT_UI2:
 616         V_UI2( ret ) = val;
 617         break;
 618     case VT_I4:
 619         V_I4( ret ) = val;
 620         break;
 621     case VT_UI4:
 622         V_UI4( ret ) = val;
 623         break;
 624     case VT_NULL:
 625         break;
 626     default:
 627         ERR("unhandled variant type %u\n", type);
 628         return;
 629     }
 630     V_VT( ret ) = type;
 631 }
 632
 633 HRESULT get_propval( const struct view *view, UINT index, const WCHAR *name, VARIANT *ret,
 634                      CIMTYPE *type, LONG *flavor )
 635 {
 636     HRESULT hr;
 637     UINT column, row;
 638     VARTYPE vartype;
 639     void *val_ptr = NULL;
 640     LONGLONG val;
 641
 642     if (is_system_prop( name )) return get_system_propval( view, index, name, ret, type, flavor );
 643     if (!view->count || !is_selected_prop( view, name )) return WBEM_E_NOT_FOUND;
 644
 645     hr = get_column_index( view->table, name, &column );
 646     if (hr != S_OK || is_method( view->table, column )) return WBEM_E_NOT_FOUND;
 647
 648     row = view->result[index];
 649     hr = get_value( view->table, row, column, &val );
 650     if (hr != S_OK) return hr;
 651
 652     vartype = view->table->columns[column].vartype;
 653     if (view->table->columns[column].type & CIM_FLAG_ARRAY)
 654     {
 655         CIMTYPE basetype = view->table->columns[column].type & CIM_TYPE_MASK;
 656
 657         val_ptr = to_safearray( (const struct array *)(INT_PTR)val, basetype );
 658         if (!vartype) vartype = to_vartype( basetype ) | VT_ARRAY;
 659         goto done;
 660     }
 661     switch (view->table->columns[column].type & COL_TYPE_MASK)
 662     {
 663     case CIM_BOOLEAN:
 664         if (!vartype) vartype = VT_BOOL;
 665         break;
 666     case CIM_STRING:
 667     case CIM_DATETIME:
 668         if (val)
 669         {
 670             vartype = VT_BSTR;
 671             val_ptr = SysAllocString( (const WCHAR *)(INT_PTR)val );
 672         }
 673         else
 674             vartype = VT_NULL;
 675         break;
 676     case CIM_SINT16:
 677         if (!vartype) vartype = VT_I2;
 678         break;
 679     case CIM_UINT16:
 680         if (!vartype) vartype = VT_UI2;
 681         break;
 682     case CIM_SINT32:
 683         if (!vartype) vartype = VT_I4;
 684         break;
 685     case CIM_UINT32:
 686         if (!vartype) vartype = VT_UI4;
 687         break;
 688     case CIM_SINT64:
 689         vartype = VT_BSTR;
 690         val_ptr = get_value_bstr( view->table, row, column );
 691         break;
 692     case CIM_UINT64:
 693         vartype = VT_BSTR;
 694         val_ptr = get_value_bstr( view->table, row, column );
 695         break;
 696     default:
 697         ERR("unhandled column type %u\n", view->table->columns[column].type);
 698         return WBEM_E_FAILED;
 699     }
 700
 701 done:
 702     set_variant( vartype, val, val_ptr, ret );
 703     if (type) *type = view->table->columns[column].type & COL_TYPE_MASK;
 704     if (flavor) *flavor = 0;
 705     return S_OK;
 706 }
 707
 708 static CIMTYPE to_cimtype( VARTYPE type )
 709 {
 710     switch (type)
 711     {
 712     case VT_BOOL:  return CIM_BOOLEAN;
 713     case VT_BSTR:  return CIM_STRING;
 714     case VT_I2:    return CIM_SINT16;
 715     case VT_UI2:   return CIM_UINT16;
 716     case VT_I4:    return CIM_SINT32;
 717     case VT_UI4:   return CIM_UINT32;
 718     case VT_I8:    return CIM_SINT64;
 719     case VT_UI8:   return CIM_UINT64;
 720     default:
 721         ERR("unhandled type %u\n", type);
 722         break;
 723     }
 724     return 0;
 725 }
 726
 727 static struct array *to_array( VARIANT *var, CIMTYPE *type )
 728 {
 729     struct array *ret;
 730     LONG bound, i;
 731     VARTYPE vartype;
 732     CIMTYPE basetype;
 733     UINT size;
 734
 735     if (SafeArrayGetVartype( V_ARRAY( var ), &vartype ) != S_OK) return NULL;
 736     if (!(basetype = to_cimtype( vartype ))) return NULL;
 737     if (SafeArrayGetUBound( V_ARRAY( var ), 1, &bound ) != S_OK) return NULL;
 738     if (!(ret = heap_alloc( sizeof(struct array) ))) return NULL;
 739
 740     ret->count = bound + 1;
 741     size = get_type_size( basetype );
 742     if (!(ret->ptr = heap_alloc_zero( ret->count * size )))
 743     {
 744         heap_free( ret );
 745         return NULL;
 746     }
 747     for (i = 0; i < ret->count; i++)
 748     {
 749         void *ptr = (char *)ret->ptr + i * size;
 750         if (vartype == VT_BSTR)
 751         {
 752             BSTR str;
 753             if (SafeArrayGetElement( V_ARRAY( var ), &i, &str ) != S_OK)
 754             {
 755                 destroy_array( ret, basetype );
 756                 return NULL;
 757             }
 758             *(WCHAR **)ptr = heap_strdupW( str );
 759             SysFreeString( str );
 760             if (!*(WCHAR **)ptr)
 761             {
 762                 destroy_array( ret, basetype );
 763                 return NULL;
 764             }
 765         }
 766         else if (SafeArrayGetElement( V_ARRAY( var ), &i, ptr ) != S_OK)
 767         {
 768             destroy_array( ret, basetype );
 769             return NULL;
 770         }
 771     }
 772     *type = basetype | CIM_FLAG_ARRAY;
 773     return ret;
 774 }
 775
 776 HRESULT to_longlong( VARIANT *var, LONGLONG *val, CIMTYPE *type )
 777 {
 778     if (!var)
 779     {
 780         *val = 0;
 781         return S_OK;
 782     }
 783     if (V_VT( var ) & VT_ARRAY)
 784     {
 785         *val = (INT_PTR)to_array( var, type );
 786         if (!*val) return E_OUTOFMEMORY;
 787         return S_OK;
 788     }
 789     switch (V_VT( var ))
 790     {
 791     case VT_BOOL:
 792         *val = V_BOOL( var );
 793         *type = CIM_BOOLEAN;
 794         break;
 795     case VT_BSTR:
 796         *val = (INT_PTR)heap_strdupW( V_BSTR( var ) );
 797         if (!*val) return E_OUTOFMEMORY;
 798         *type = CIM_STRING;
 799         break;
 800     case VT_I2:
 801         *val = V_I2( var );
 802         *type = CIM_SINT16;
 803         break;
 804     case VT_UI2:
 805         *val = V_UI2( var );
 806         *type = CIM_UINT16;
 807         break;
 808     case VT_I4:
 809         *val = V_I4( var );
 810         *type = CIM_SINT32;
 811         break;
 812     case VT_UI4:
 813         *val = V_UI4( var );
 814         *type = CIM_UINT32;
 815         break;
 816     case VT_NULL:
 817         *val = 0;
 818         break;
 819     default:
 820         ERR("unhandled type %u\n", V_VT( var ));
 821         return WBEM_E_FAILED;
 822     }
 823     return S_OK;
 824 }
 825
 826 HRESULT put_propval( const struct view *view, UINT index, const WCHAR *name, VARIANT *var, CIMTYPE type )
 827 {
 828     HRESULT hr;
 829     UINT column, row = view->result[index];
 830     LONGLONG val;
 831
 832     hr = get_column_index( view->table, name, &column );
 833     if (hr != S_OK)
 834     {
 835         FIXME("no support for creating new properties\n");
 836         return WBEM_E_FAILED;
 837     }
 838     if (is_method( view->table, column ) || !(view->table->columns[column].type & COL_FLAG_DYNAMIC))
 839         return WBEM_E_FAILED;
 840
 841     hr = to_longlong( var, &val, &type );
 842     if (hr != S_OK) return hr;
 843
 844     return set_value( view->table, row, column, val, type );
 845 }
 846
 847 HRESULT get_properties( const struct view *view, SAFEARRAY **props )
 848 {
 849     SAFEARRAY *sa;
 850     BSTR str;
 851     LONG i;
 852     UINT num_props = count_properties( view );
 853
 854     if (!(sa = SafeArrayCreateVector( VT_BSTR, 0, num_props ))) return E_OUTOFMEMORY;
 855
 856     for (i = 0; i < view->table->num_cols; i++)
 857     {
 858         if (is_method( view->table, i )) continue;
 859
 860         str = SysAllocString( view->table->columns[i].name );
 861         if (!str || SafeArrayPutElement( sa, &i, str ) != S_OK)
 862         {
 863             SysFreeString( str );
 864             SafeArrayDestroy( sa );
 865             return E_OUTOFMEMORY;
 866         }
 867     }
 868     *props = sa;
 869     return S_OK;
 870 }