2 * Copyright 2012 Hans Leidekker for CodeWeavers
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.
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.
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
19 #include "wbemprox_private.h"
23 HRESULT
get_column_index( const struct table
*table
, const WCHAR
*name
, UINT
*column
)
26 for (i
= 0; i
< table
->num_cols
; i
++)
28 if (!strcmpiW( table
->columns
[i
].name
, name
))
34 return WBEM_E_INVALID_QUERY
;
37 UINT
get_type_size( CIMTYPE type
)
39 if (type
& CIM_FLAG_ARRAY
) return sizeof(void *);
59 return sizeof(WCHAR
*);
61 ERR("unhandled type %u\n", type
);
64 return sizeof(LONGLONG
);
67 static UINT
get_column_size( const struct table
*table
, UINT column
)
69 return get_type_size( table
->columns
[column
].type
& COL_TYPE_MASK
);
72 static UINT
get_column_offset( const struct table
*table
, UINT column
)
75 for (i
= 0; i
< column
; i
++) offset
+= get_column_size( table
, i
);
79 static UINT
get_row_size( const struct table
*table
)
81 return get_column_offset( table
, table
->num_cols
- 1 ) + get_column_size( table
, table
->num_cols
- 1 );
84 HRESULT
get_value( const struct table
*table
, UINT row
, UINT column
, LONGLONG
*val
)
86 UINT col_offset
, row_size
;
89 col_offset
= get_column_offset( table
, column
);
90 row_size
= get_row_size( table
);
91 ptr
= table
->data
+ row
* row_size
+ col_offset
;
93 if (table
->columns
[column
].type
& CIM_FLAG_ARRAY
)
95 *val
= (INT_PTR
)*(const void **)ptr
;
98 switch (table
->columns
[column
].type
& COL_TYPE_MASK
)
101 *val
= *(const int *)ptr
;
105 *val
= (INT_PTR
)*(const WCHAR
**)ptr
;
108 *val
= *(const INT8
*)ptr
;
111 *val
= *(const UINT8
*)ptr
;
114 *val
= *(const INT16
*)ptr
;
117 *val
= *(const UINT16
*)ptr
;
120 *val
= *(const INT32
*)ptr
;
123 *val
= *(const UINT32
*)ptr
;
126 *val
= *(const INT64
*)ptr
;
129 *val
= *(const UINT64
*)ptr
;
132 ERR("invalid column type %u\n", table
->columns
[column
].type
& COL_TYPE_MASK
);
139 BSTR
get_value_bstr( const struct table
*table
, UINT row
, UINT column
)
141 static const WCHAR fmt_signedW
[] = {'%','d',0};
142 static const WCHAR fmt_unsignedW
[] = {'%','u',0};
143 static const WCHAR fmt_signed64W
[] = {'%','I','6','4','d',0};
144 static const WCHAR fmt_unsigned64W
[] = {'%','I','6','4','u',0};
145 static const WCHAR fmt_strW
[] = {'\"','%','s','\"',0};
146 static const WCHAR trueW
[] = {'T','R','U','E',0};
147 static const WCHAR falseW
[] = {'F','A','L','S','E',0};
153 if (table
->columns
[column
].type
& CIM_FLAG_ARRAY
)
155 FIXME("array to string conversion not handled\n");
158 if (get_value( table
, row
, column
, &val
) != S_OK
) return NULL
;
160 switch (table
->columns
[column
].type
& COL_TYPE_MASK
)
163 if (val
) return SysAllocString( trueW
);
164 else return SysAllocString( falseW
);
168 if (!val
) return NULL
;
169 len
= strlenW( (const WCHAR
*)(INT_PTR
)val
) + 2;
170 if (!(ret
= SysAllocStringLen( NULL
, len
))) return NULL
;
171 sprintfW( ret
, fmt_strW
, (const WCHAR
*)(INT_PTR
)val
);
176 sprintfW( number
, fmt_signedW
, val
);
177 return SysAllocString( number
);
181 sprintfW( number
, fmt_unsignedW
, val
);
182 return SysAllocString( number
);
185 wsprintfW( number
, fmt_signed64W
, val
);
186 return SysAllocString( number
);
189 wsprintfW( number
, fmt_unsigned64W
, val
);
190 return SysAllocString( number
);
193 FIXME("unhandled column type %u\n", table
->columns
[column
].type
& COL_TYPE_MASK
);
199 HRESULT
set_value( const struct table
*table
, UINT row
, UINT column
, LONGLONG val
,
202 UINT col_offset
, row_size
;
205 if ((table
->columns
[column
].type
& COL_TYPE_MASK
) != type
) return WBEM_E_TYPE_MISMATCH
;
207 col_offset
= get_column_offset( table
, column
);
208 row_size
= get_row_size( table
);
209 ptr
= table
->data
+ row
* row_size
+ col_offset
;
211 switch (table
->columns
[column
].type
& COL_TYPE_MASK
)
215 *(WCHAR
**)ptr
= (WCHAR
*)(INT_PTR
)val
;
227 *(UINT16
*)ptr
= val
;
233 *(UINT32
*)ptr
= val
;
239 *(UINT64
*)ptr
= val
;
242 FIXME("unhandled column type %u\n", type
);
243 return WBEM_E_FAILED
;
248 HRESULT
get_method( const struct table
*table
, const WCHAR
*name
, class_method
**func
)
252 for (i
= 0; i
< table
->num_rows
; i
++)
254 for (j
= 0; j
< table
->num_cols
; j
++)
256 if (table
->columns
[j
].type
& COL_FLAG_METHOD
&& !strcmpW( table
->columns
[j
].name
, name
))
261 if ((hr
= get_value( table
, i
, j
, &val
)) != S_OK
) return hr
;
262 *func
= (class_method
*)(INT_PTR
)val
;
267 return WBEM_E_INVALID_METHOD
;
271 void free_row_values( const struct table
*table
, UINT row
)
276 for (i
= 0; i
< table
->num_cols
; i
++)
278 if (!(table
->columns
[i
].type
& COL_FLAG_DYNAMIC
)) continue;
280 type
= table
->columns
[i
].type
& COL_TYPE_MASK
;
281 if (type
== CIM_STRING
|| type
== CIM_DATETIME
|| (type
& CIM_FLAG_ARRAY
))
283 if (get_value( table
, row
, i
, &val
) == S_OK
) heap_free( (void *)(INT_PTR
)val
);
288 void clear_table( struct table
*table
)
292 if (!table
->data
) return;
294 for (i
= 0; i
< table
->num_rows
; i
++) free_row_values( table
, i
);
298 table
->num_rows_allocated
= 0;
299 heap_free( table
->data
);
304 void free_columns( struct column
*columns
, UINT num_cols
)
308 for (i
= 0; i
< num_cols
; i
++) { heap_free( (WCHAR
*)columns
[i
].name
); }
309 heap_free( columns
);
312 void free_table( struct table
*table
)
316 clear_table( table
);
317 if (table
->flags
& TABLE_FLAG_DYNAMIC
)
319 TRACE("destroying %p\n", table
);
320 heap_free( (WCHAR
*)table
->name
);
321 free_columns( (struct column
*)table
->columns
, table
->num_cols
);
322 list_remove( &table
->entry
);
327 void release_table( struct table
*table
)
329 if (!InterlockedDecrement( &table
->refs
)) free_table( table
);
332 struct table
*addref_table( struct table
*table
)
334 InterlockedIncrement( &table
->refs
);
338 struct table
*grab_table( const WCHAR
*name
)
342 LIST_FOR_EACH_ENTRY( table
, table_list
, struct table
, entry
)
344 if (!strcmpiW( table
->name
, name
))
346 TRACE("returning %p\n", table
);
347 return addref_table( table
);
353 struct table
*create_table( const WCHAR
*name
, UINT num_cols
, const struct column
*columns
,
354 UINT num_rows
, UINT num_allocated
, BYTE
*data
,
355 enum fill_status (*fill
)(struct table
*, const struct expr
*cond
) )
359 if (!(table
= heap_alloc( sizeof(*table
) ))) return NULL
;
360 table
->name
= heap_strdupW( name
);
361 table
->num_cols
= num_cols
;
362 table
->columns
= columns
;
363 table
->num_rows
= num_rows
;
364 table
->num_rows_allocated
= num_allocated
;
367 table
->flags
= TABLE_FLAG_DYNAMIC
;
369 list_init( &table
->entry
);
373 BOOL
add_table( struct table
*table
)
377 LIST_FOR_EACH_ENTRY( iter
, table_list
, struct table
, entry
)
379 if (!strcmpiW( iter
->name
, table
->name
))
381 TRACE("table %s already exists\n", debugstr_w(table
->name
));
385 list_add_tail( table_list
, &table
->entry
);
386 TRACE("added %p\n", table
);
390 BSTR
get_method_name( const WCHAR
*class, UINT index
)
396 if (!(table
= grab_table( class ))) return NULL
;
398 for (i
= 0; i
< table
->num_cols
; i
++)
400 if (table
->columns
[i
].type
& COL_FLAG_METHOD
)
404 ret
= SysAllocString( table
->columns
[i
].name
);
405 release_table( table
);
411 release_table( table
);