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