dlls/wbemprox/table.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 "wbemcli.h"
  26
  27 #include "wine/debug.h"
  28 #include "wbemprox_private.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(wbemprox);
  31
  32 HRESULT get_column_index( const struct table *table, const WCHAR *name, UINT *column )
  33 {
  34     UINT i;
  35     for (i = 0; i < table->num_cols; i++)
  36     {
  37         if (!wcsicmp( table->columns[i].name, name ))
  38         {
  39             *column = i;
  40             return S_OK;
  41         }
  42     }
  43     return WBEM_E_INVALID_QUERY;
  44 }
  45
  46 UINT get_type_size( CIMTYPE type )
  47 {
  48     if (type & CIM_FLAG_ARRAY) return sizeof(void *);
  49
  50     switch (type)
  51     {
  52     case CIM_BOOLEAN:
  53         return sizeof(int);
  54     case CIM_SINT8:
  55     case CIM_UINT8:
  56         return sizeof(INT8);
  57     case CIM_SINT16:
  58     case CIM_UINT16:
  59         return sizeof(INT16);
  60     case CIM_SINT32:
  61     case CIM_UINT32:
  62         return sizeof(INT32);
  63     case CIM_SINT64:
  64     case CIM_UINT64:
  65         return sizeof(INT64);
  66     case CIM_DATETIME:
  67     case CIM_REFERENCE:
  68     case CIM_STRING:
  69         return sizeof(WCHAR *);
  70     case CIM_REAL32:
  71         return sizeof(FLOAT);
  72     default:
  73         ERR("unhandled type %u\n", type);
  74         break;
  75     }
  76     return sizeof(LONGLONG);
  77 }
  78
  79 static UINT get_column_size( const struct table *table, UINT column )
  80 {
  81     return get_type_size( table->columns[column].type & COL_TYPE_MASK );
  82 }
  83
  84 static UINT get_column_offset( const struct table *table, UINT column )
  85 {
  86     UINT i, offset = 0;
  87     for (i = 0; i < column; i++) offset += get_column_size( table, i );
  88     return offset;
  89 }
  90
  91 static UINT get_row_size( const struct table *table )
  92 {
  93     return get_column_offset( table, table->num_cols - 1 ) + get_column_size( table, table->num_cols - 1 );
  94 }
  95
  96 HRESULT get_value( const struct table *table, UINT row, UINT column, LONGLONG *val )
  97 {
  98     UINT col_offset, row_size;
  99     const BYTE *ptr;
 100
 101     col_offset = get_column_offset( table, column );
 102     row_size = get_row_size( table );
 103     ptr = table->data + row * row_size + col_offset;
 104
 105     if (table->columns[column].type & CIM_FLAG_ARRAY)
 106     {
 107         *val = (INT_PTR)*(const void **)ptr;
 108         return S_OK;
 109     }
 110     switch (table->columns[column].type & COL_TYPE_MASK)
 111     {
 112     case CIM_BOOLEAN:
 113         *val = *(const int *)ptr;
 114         break;
 115     case CIM_DATETIME:
 116     case CIM_REFERENCE:
 117     case CIM_STRING:
 118         *val = (INT_PTR)*(const WCHAR **)ptr;
 119         break;
 120     case CIM_SINT8:
 121         *val = *(const INT8 *)ptr;
 122         break;
 123     case CIM_UINT8:
 124         *val = *(const UINT8 *)ptr;
 125         break;
 126     case CIM_SINT16:
 127         *val = *(const INT16 *)ptr;
 128         break;
 129     case CIM_UINT16:
 130         *val = *(const UINT16 *)ptr;
 131         break;
 132     case CIM_SINT32:
 133         *val = *(const INT32 *)ptr;
 134         break;
 135     case CIM_UINT32:
 136         *val = *(const UINT32 *)ptr;
 137         break;
 138     case CIM_SINT64:
 139         *val = *(const INT64 *)ptr;
 140         break;
 141     case CIM_UINT64:
 142         *val = *(const UINT64 *)ptr;
 143         break;
 144     case CIM_REAL32:
 145         memcpy( val, ptr, sizeof(FLOAT) );
 146         break;
 147     default:
 148         ERR("invalid column type %u\n", table->columns[column].type & COL_TYPE_MASK);
 149         *val = 0;
 150         break;
 151     }
 152     return S_OK;
 153 }
 154
 155 BSTR get_value_bstr( const struct table *table, UINT row, UINT column )
 156 {
 157     LONGLONG val;
 158     BSTR ret;
 159     WCHAR number[22];
 160     UINT len;
 161
 162     if (table->columns[column].type & CIM_FLAG_ARRAY)
 163     {
 164         FIXME("array to string conversion not handled\n");
 165         return NULL;
 166     }
 167     if (get_value( table, row, column, &val ) != S_OK) return NULL;
 168
 169     switch (table->columns[column].type & COL_TYPE_MASK)
 170     {
 171     case CIM_BOOLEAN:
 172         if (val) return SysAllocString( L"TRUE" );
 173         else return SysAllocString( L"FALSE" );
 174
 175     case CIM_DATETIME:
 176     case CIM_REFERENCE:
 177     case CIM_STRING:
 178         if (!val) return NULL;
 179         len = lstrlenW( (const WCHAR *)(INT_PTR)val ) + 2;
 180         if (!(ret = SysAllocStringLen( NULL, len ))) return NULL;
 181         swprintf( ret, len, L"\"%s\"", (const WCHAR *)(INT_PTR)val );
 182         return ret;
 183
 184     case CIM_SINT16:
 185     case CIM_SINT32:
 186         swprintf( number, ARRAY_SIZE( number ), L"%d", val );
 187         return SysAllocString( number );
 188
 189     case CIM_UINT16:
 190     case CIM_UINT32:
 191         swprintf( number, ARRAY_SIZE( number ), L"%u", val );
 192         return SysAllocString( number );
 193
 194     case CIM_SINT64:
 195         wsprintfW( number, L"%I64d", val );
 196         return SysAllocString( number );
 197
 198     case CIM_UINT64:
 199         wsprintfW( number, L"%I64u", val );
 200         return SysAllocString( number );
 201
 202     default:
 203         FIXME("unhandled column type %u\n", table->columns[column].type & COL_TYPE_MASK);
 204         break;
 205     }
 206     return NULL;
 207 }
 208
 209 HRESULT set_value( const struct table *table, UINT row, UINT column, LONGLONG val,
 210                    CIMTYPE type )
 211 {
 212     UINT col_offset, row_size;
 213     BYTE *ptr;
 214
 215     if ((table->columns[column].type & COL_TYPE_MASK) != type) return WBEM_E_TYPE_MISMATCH;
 216
 217     col_offset = get_column_offset( table, column );
 218     row_size = get_row_size( table );
 219     ptr = table->data + row * row_size + col_offset;
 220
 221     switch (table->columns[column].type & COL_TYPE_MASK)
 222     {
 223     case CIM_DATETIME:
 224     case CIM_REFERENCE:
 225     case CIM_STRING:
 226         *(WCHAR **)ptr = (WCHAR *)(INT_PTR)val;
 227         break;
 228     case CIM_SINT8:
 229         *(INT8 *)ptr = val;
 230         break;
 231     case CIM_UINT8:
 232         *(UINT8 *)ptr = val;
 233         break;
 234     case CIM_SINT16:
 235         *(INT16 *)ptr = val;
 236         break;
 237     case CIM_UINT16:
 238         *(UINT16 *)ptr = val;
 239         break;
 240     case CIM_SINT32:
 241         *(INT32 *)ptr = val;
 242         break;
 243     case CIM_UINT32:
 244         *(UINT32 *)ptr = val;
 245         break;
 246     case CIM_SINT64:
 247         *(INT64 *)ptr = val;
 248         break;
 249     case CIM_UINT64:
 250         *(UINT64 *)ptr = val;
 251         break;
 252     default:
 253         FIXME("unhandled column type %u\n", type);
 254         return WBEM_E_FAILED;
 255     }
 256     return S_OK;
 257 }
 258
 259 HRESULT get_method( const struct table *table, const WCHAR *name, class_method **func )
 260 {
 261     UINT i, j;
 262
 263     for (i = 0; i < table->num_rows; i++)
 264     {
 265         for (j = 0; j < table->num_cols; j++)
 266         {
 267             if (table->columns[j].type & COL_FLAG_METHOD && !wcscmp( table->columns[j].name, name ))
 268             {
 269                 HRESULT hr;
 270                 LONGLONG val;
 271
 272                 if ((hr = get_value( table, i, j, &val )) != S_OK) return hr;
 273                 *func = (class_method *)(INT_PTR)val;
 274                 return S_OK;
 275             }
 276         }
 277     }
 278     return WBEM_E_INVALID_METHOD;
 279
 280 }
 281
 282 void free_row_values( const struct table *table, UINT row )
 283 {
 284     UINT i, type;
 285     LONGLONG val;
 286
 287     for (i = 0; i < table->num_cols; i++)
 288     {
 289         if (!(table->columns[i].type & COL_FLAG_DYNAMIC)) continue;
 290
 291         type = table->columns[i].type & COL_TYPE_MASK;
 292         if (type == CIM_STRING || type == CIM_DATETIME || type == CIM_REFERENCE)
 293         {
 294             if (get_value( table, row, i, &val ) == S_OK) heap_free( (void *)(INT_PTR)val );
 295         }
 296         else if (type & CIM_FLAG_ARRAY)
 297         {
 298             if (get_value( table, row, i, &val ) == S_OK)
 299                 destroy_array( (void *)(INT_PTR)val, type & CIM_TYPE_MASK );
 300         }
 301     }
 302 }
 303
 304 void clear_table( struct table *table )
 305 {
 306     UINT i;
 307
 308     if (!table->data) return;
 309
 310     for (i = 0; i < table->num_rows; i++) free_row_values( table, i );
 311     if (table->fill)
 312     {
 313         table->num_rows = 0;
 314         table->num_rows_allocated = 0;
 315         heap_free( table->data );
 316         table->data = NULL;
 317     }
 318 }
 319
 320 void free_columns( struct column *columns, UINT num_cols )
 321 {
 322     UINT i;
 323
 324     for (i = 0; i < num_cols; i++) { heap_free( (WCHAR *)columns[i].name ); }
 325     heap_free( columns );
 326 }
 327
 328 void free_table( struct table *table )
 329 {
 330     if (!table) return;
 331
 332     clear_table( table );
 333     if (table->flags & TABLE_FLAG_DYNAMIC)
 334     {
 335         TRACE("destroying %p\n", table);
 336         heap_free( (WCHAR *)table->name );
 337         free_columns( (struct column *)table->columns, table->num_cols );
 338         heap_free( table->data );
 339         list_remove( &table->entry );
 340         heap_free( table );
 341     }
 342 }
 343
 344 void release_table( struct table *table )
 345 {
 346     if (!InterlockedDecrement( &table->refs )) free_table( table );
 347 }
 348
 349 struct table *addref_table( struct table *table )
 350 {
 351     InterlockedIncrement( &table->refs );
 352     return table;
 353 }
 354
 355 struct table *grab_table( const WCHAR *name )
 356 {
 357     struct table *table;
 358
 359     LIST_FOR_EACH_ENTRY( table, table_list, struct table, entry )
 360     {
 361         if (name && !wcsicmp( table->name, name ))
 362         {
 363             TRACE("returning %p\n", table);
 364             return addref_table( table );
 365         }
 366     }
 367     return NULL;
 368 }
 369
 370 struct table *create_table( const WCHAR *name, UINT num_cols, const struct column *columns,
 371                             UINT num_rows, UINT num_allocated, BYTE *data,
 372                             enum fill_status (*fill)(struct table *, const struct expr *cond) )
 373 {
 374     struct table *table;
 375
 376     if (!(table = heap_alloc( sizeof(*table) ))) return NULL;
 377     table->name               = heap_strdupW( name );
 378     table->num_cols           = num_cols;
 379     table->columns            = columns;
 380     table->num_rows           = num_rows;
 381     table->num_rows_allocated = num_allocated;
 382     table->data               = data;
 383     table->fill               = fill;
 384     table->flags              = TABLE_FLAG_DYNAMIC;
 385     table->refs               = 0;
 386     list_init( &table->entry );
 387     return table;
 388 }
 389
 390 BOOL add_table( struct table *table )
 391 {
 392     struct table *iter;
 393
 394     LIST_FOR_EACH_ENTRY( iter, table_list, struct table, entry )
 395     {
 396         if (!wcsicmp( iter->name, table->name ))
 397         {
 398             TRACE("table %s already exists\n", debugstr_w(table->name));
 399             return FALSE;
 400         }
 401     }
 402     list_add_tail( table_list, &table->entry );
 403     TRACE("added %p\n", table);
 404     return TRUE;
 405 }
 406
 407 BSTR get_method_name( const WCHAR *class, UINT index )
 408 {
 409     struct table *table;
 410     UINT i, count = 0;
 411     BSTR ret;
 412
 413     if (!(table = grab_table( class ))) return NULL;
 414
 415     for (i = 0; i < table->num_cols; i++)
 416     {
 417         if (table->columns[i].type & COL_FLAG_METHOD)
 418         {
 419             if (index == count)
 420             {
 421                 ret = SysAllocString( table->columns[i].name );
 422                 release_table( table );
 423                 return ret;
 424             }
 425             count++;
 426         }
 427     }
 428     release_table( table );
 429     return NULL;
 430 }