winex11: Add 1280x960 resolution.
[wine.git] / dlls / wbemprox / query.c
blob76f5caa6345e890182981f77435c23ca3e9ae8c2
1 /*
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 #define COBJMACROS
21 #include "config.h"
22 #include <stdarg.h>
24 #include "windef.h"
25 #include "winbase.h"
26 #include "wbemcli.h"
28 #include "wine/debug.h"
29 #include "wbemprox_private.h"
31 WINE_DEFAULT_DEBUG_CHANNEL(wbemprox);
33 HRESULT create_view( const struct property *proplist, const WCHAR *class,
34 const struct expr *cond, struct view **ret )
36 struct view *view = heap_alloc( sizeof(struct view) );
38 if (!view) return E_OUTOFMEMORY;
39 view->proplist = proplist;
40 view->table = grab_table( class );
41 view->cond = cond;
42 view->result = NULL;
43 view->count = 0;
44 *ret = view;
45 return S_OK;
48 void destroy_view( struct view *view )
50 if (!view) return;
51 if (view->table) release_table( view->table );
52 heap_free( view->result );
53 heap_free( view );
56 static BOOL eval_like( const WCHAR *lstr, const WCHAR *rstr )
58 const WCHAR *p = lstr, *q = rstr;
60 while (*p && *q)
62 if (*q == '%')
64 while (*q == '%') q++;
65 if (!*q) return TRUE;
66 while (*p && *q && toupperW( *p ) == toupperW( *q )) { p++; q++; };
67 if (!*p && !*q) return TRUE;
69 if (*q != '%' && toupperW( *p++ ) != toupperW( *q++ )) return FALSE;
71 return TRUE;
74 static HRESULT eval_strcmp( UINT op, const WCHAR *lstr, const WCHAR *rstr, LONGLONG *val )
76 if (!lstr || !rstr)
78 *val = 0;
79 return S_OK;
81 switch (op)
83 case OP_EQ:
84 *val = !strcmpW( lstr, rstr );
85 break;
86 case OP_GT:
87 *val = strcmpW( lstr, rstr ) > 0;
88 break;
89 case OP_LT:
90 *val = strcmpW( lstr, rstr ) < 0;
91 break;
92 case OP_LE:
93 *val = strcmpW( lstr, rstr ) <= 0;
94 break;
95 case OP_GE:
96 *val = strcmpW( lstr, rstr ) >= 0;
97 break;
98 case OP_NE:
99 *val = strcmpW( lstr, rstr );
100 break;
101 case OP_LIKE:
102 *val = eval_like( lstr, rstr );
103 break;
104 default:
105 ERR("unhandled operator %u\n", op);
106 return WBEM_E_INVALID_QUERY;
108 return S_OK;
111 static BOOL is_int( CIMTYPE type )
113 switch (type)
115 case CIM_SINT8:
116 case CIM_SINT16:
117 case CIM_SINT32:
118 case CIM_SINT64:
119 case CIM_UINT8:
120 case CIM_UINT16:
121 case CIM_UINT32:
122 case CIM_UINT64:
123 return TRUE;
124 default:
125 return FALSE;
129 static inline BOOL is_strcmp( const struct complex_expr *expr, UINT ltype, UINT rtype )
131 if ((ltype == CIM_STRING || is_int( ltype )) && expr->left->type == EXPR_PROPVAL &&
132 expr->right->type == EXPR_SVAL) return TRUE;
133 else if ((rtype == CIM_STRING || is_int( rtype )) && expr->right->type == EXPR_PROPVAL &&
134 expr->left->type == EXPR_SVAL) return TRUE;
135 return FALSE;
138 static inline BOOL is_boolcmp( const struct complex_expr *expr, UINT ltype, UINT rtype )
140 if (ltype == CIM_BOOLEAN && expr->left->type == EXPR_PROPVAL &&
141 (expr->right->type == EXPR_SVAL || expr->right->type == EXPR_BVAL)) return TRUE;
142 else if (rtype == CIM_BOOLEAN && expr->right->type == EXPR_PROPVAL &&
143 (expr->left->type == EXPR_SVAL || expr->left->type == EXPR_BVAL)) return TRUE;
144 return FALSE;
147 static HRESULT eval_boolcmp( UINT op, LONGLONG lval, LONGLONG rval, UINT ltype, UINT rtype, LONGLONG *val )
149 static const WCHAR trueW[] = {'T','r','u','e',0};
151 if (ltype == CIM_STRING) lval = !strcmpiW( (const WCHAR *)(INT_PTR)lval, trueW ) ? -1 : 0;
152 else if (rtype == CIM_STRING) rval = !strcmpiW( (const WCHAR *)(INT_PTR)rval, trueW ) ? -1 : 0;
154 switch (op)
156 case OP_EQ:
157 *val = (lval == rval);
158 break;
159 case OP_NE:
160 *val = (lval != rval);
161 break;
162 default:
163 ERR("unhandled operator %u\n", op);
164 return WBEM_E_INVALID_QUERY;
166 return S_OK;
169 static UINT resolve_type( UINT left, UINT right )
171 switch (left)
173 case CIM_SINT8:
174 case CIM_SINT16:
175 case CIM_SINT32:
176 case CIM_SINT64:
177 case CIM_UINT8:
178 case CIM_UINT16:
179 case CIM_UINT32:
180 case CIM_UINT64:
181 switch (right)
183 case CIM_SINT8:
184 case CIM_SINT16:
185 case CIM_SINT32:
186 case CIM_SINT64:
187 case CIM_UINT8:
188 case CIM_UINT16:
189 case CIM_UINT32:
190 case CIM_UINT64:
191 return CIM_UINT64;
192 default: break;
194 break;
196 case CIM_STRING:
197 if (right == CIM_STRING) return CIM_STRING;
198 break;
200 case CIM_BOOLEAN:
201 if (right == CIM_BOOLEAN) return CIM_BOOLEAN;
202 break;
204 default:
205 break;
207 return CIM_ILLEGAL;
210 static const WCHAR *format_int( WCHAR *buf, CIMTYPE type, LONGLONG val )
212 static const WCHAR fmt_signedW[] = {'%','d',0};
213 static const WCHAR fmt_unsignedW[] = {'%','u',0};
214 static const WCHAR fmt_signed64W[] = {'%','I','6','4','d',0};
215 static const WCHAR fmt_unsigned64W[] = {'%','I','6','4','u',0};
217 switch (type)
219 case CIM_SINT8:
220 case CIM_SINT16:
221 case CIM_SINT32:
222 sprintfW( buf, fmt_signedW, val );
223 return buf;
225 case CIM_UINT8:
226 case CIM_UINT16:
227 case CIM_UINT32:
228 sprintfW( buf, fmt_unsignedW, val );
229 return buf;
231 case CIM_SINT64:
232 wsprintfW( buf, fmt_signed64W, val );
233 return buf;
235 case CIM_UINT64:
236 wsprintfW( buf, fmt_unsigned64W, val );
237 return buf;
239 default:
240 ERR( "unhandled type %u\n", type );
241 return NULL;
245 static HRESULT eval_binary( const struct table *table, UINT row, const struct complex_expr *expr,
246 LONGLONG *val, UINT *type )
248 HRESULT lret, rret;
249 LONGLONG lval, rval;
250 UINT ltype, rtype;
252 lret = eval_cond( table, row, expr->left, &lval, &ltype );
253 rret = eval_cond( table, row, expr->right, &rval, &rtype );
254 if (lret != S_OK || rret != S_OK) return WBEM_E_INVALID_QUERY;
256 *type = resolve_type( ltype, rtype );
258 if (is_boolcmp( expr, ltype, rtype ))
259 return eval_boolcmp( expr->op, lval, rval, ltype, rtype, val );
261 if (is_strcmp( expr, ltype, rtype ))
263 const WCHAR *lstr, *rstr;
264 WCHAR lbuf[21], rbuf[21];
266 if (is_int( ltype )) lstr = format_int( lbuf, ltype, lval );
267 else lstr = (const WCHAR *)(INT_PTR)lval;
269 if (is_int( rtype )) rstr = format_int( rbuf, rtype, rval );
270 else rstr = (const WCHAR *)(INT_PTR)rval;
272 return eval_strcmp( expr->op, lstr, rstr, val );
274 switch (expr->op)
276 case OP_EQ:
277 *val = (lval == rval);
278 break;
279 case OP_AND:
280 *val = (lval && rval);
281 break;
282 case OP_OR:
283 *val = (lval || rval);
284 break;
285 case OP_GT:
286 *val = (lval > rval);
287 break;
288 case OP_LT:
289 *val = (lval < rval);
290 break;
291 case OP_LE:
292 *val = (lval <= rval);
293 break;
294 case OP_GE:
295 *val = (lval >= rval);
296 break;
297 case OP_NE:
298 *val = (lval != rval);
299 break;
300 default:
301 ERR("unhandled operator %u\n", expr->op);
302 return WBEM_E_INVALID_QUERY;
304 return S_OK;
307 static HRESULT eval_unary( const struct table *table, UINT row, const struct complex_expr *expr,
308 LONGLONG *val, UINT *type )
311 HRESULT hr;
312 UINT column;
313 LONGLONG lval;
315 if (expr->op == OP_NOT)
317 hr = eval_cond( table, row, expr->left, &lval, type );
318 if (hr != S_OK)
319 return hr;
320 *val = !lval;
321 return S_OK;
324 hr = get_column_index( table, expr->left->u.propval->name, &column );
325 if (hr != S_OK)
326 return hr;
328 hr = get_value( table, row, column, &lval );
329 if (hr != S_OK)
330 return hr;
332 switch (expr->op)
334 case OP_ISNULL:
335 *val = !lval;
336 break;
337 case OP_NOTNULL:
338 *val = lval;
339 break;
340 default:
341 ERR("unknown operator %u\n", expr->op);
342 return WBEM_E_INVALID_QUERY;
345 *type = table->columns[column].type & CIM_TYPE_MASK;
346 return S_OK;
349 static HRESULT eval_propval( const struct table *table, UINT row, const struct property *propval,
350 LONGLONG *val, UINT *type )
353 HRESULT hr;
354 UINT column;
356 hr = get_column_index( table, propval->name, &column );
357 if (hr != S_OK)
358 return hr;
360 *type = table->columns[column].type & CIM_TYPE_MASK;
361 return get_value( table, row, column, val );
364 HRESULT eval_cond( const struct table *table, UINT row, const struct expr *cond, LONGLONG *val, UINT *type )
366 if (!cond)
368 *val = 1;
369 *type = CIM_UINT64;
370 return S_OK;
372 switch (cond->type)
374 case EXPR_COMPLEX:
375 return eval_binary( table, row, &cond->u.expr, val, type );
377 case EXPR_UNARY:
378 return eval_unary( table, row, &cond->u.expr, val, type );
380 case EXPR_PROPVAL:
381 return eval_propval( table, row, cond->u.propval, val, type );
383 case EXPR_SVAL:
384 *val = (INT_PTR)cond->u.sval;
385 *type = CIM_STRING;
386 return S_OK;
388 case EXPR_IVAL:
389 *val = cond->u.ival;
390 *type = CIM_UINT64;
391 return S_OK;
393 case EXPR_BVAL:
394 *val = cond->u.ival;
395 *type = CIM_BOOLEAN;
396 return S_OK;
398 default:
399 ERR("invalid expression type\n");
400 break;
402 return WBEM_E_INVALID_QUERY;
405 HRESULT execute_view( struct view *view )
407 UINT i, j = 0, len;
409 if (!view->table) return S_OK;
410 if (view->table->fill)
412 clear_table( view->table );
413 view->table->fill( view->table, view->cond );
415 if (!view->table->num_rows) return S_OK;
417 len = min( view->table->num_rows, 16 );
418 if (!(view->result = heap_alloc( len * sizeof(UINT) ))) return E_OUTOFMEMORY;
420 for (i = 0; i < view->table->num_rows; i++)
422 HRESULT hr;
423 LONGLONG val = 0;
424 UINT type;
426 if (j >= len)
428 UINT *tmp;
429 len *= 2;
430 if (!(tmp = heap_realloc( view->result, len * sizeof(UINT) ))) return E_OUTOFMEMORY;
431 view->result = tmp;
433 if ((hr = eval_cond( view->table, i, view->cond, &val, &type )) != S_OK) return hr;
434 if (val) view->result[j++] = i;
436 view->count = j;
437 return S_OK;
440 struct query *create_query(void)
442 struct query *query;
444 if (!(query = heap_alloc( sizeof(*query) ))) return NULL;
445 list_init( &query->mem );
446 query->refs = 1;
447 return query;
450 void free_query( struct query *query )
452 struct list *mem, *next;
454 if (!query) return;
455 destroy_view( query->view );
456 LIST_FOR_EACH_SAFE( mem, next, &query->mem ) { heap_free( mem ); }
457 heap_free( query );
460 struct query *addref_query( struct query *query )
462 InterlockedIncrement( &query->refs );
463 return query;
466 void release_query( struct query *query )
468 if (!InterlockedDecrement( &query->refs )) free_query( query );
471 HRESULT exec_query( const WCHAR *str, IEnumWbemClassObject **result )
473 HRESULT hr;
474 struct query *query;
476 *result = NULL;
477 if (!(query = create_query())) return E_OUTOFMEMORY;
478 hr = parse_query( str, &query->view, &query->mem );
479 if (hr != S_OK) goto done;
480 hr = execute_view( query->view );
481 if (hr != S_OK) goto done;
482 hr = EnumWbemClassObject_create( query, (void **)result );
484 done:
485 release_query( query );
486 return hr;
489 BOOL is_selected_prop( const struct view *view, const WCHAR *name )
491 const struct property *prop = view->proplist;
493 if (!prop) return TRUE;
494 while (prop)
496 if (!strcmpiW( prop->name, name )) return TRUE;
497 prop = prop->next;
499 return FALSE;
502 static BOOL is_system_prop( const WCHAR *name )
504 return (name[0] == '_' && name[1] == '_');
507 static BSTR build_servername( const struct view *view )
509 WCHAR server[MAX_COMPUTERNAME_LENGTH + 1], *p;
510 DWORD len = sizeof(server)/sizeof(server[0]);
512 if (view->proplist) return NULL;
514 if (!(GetComputerNameW( server, &len ))) return NULL;
515 for (p = server; *p; p++) *p = toupperW( *p );
516 return SysAllocString( server );
519 static BSTR build_classname( const struct view *view )
521 return SysAllocString( view->table->name );
524 static BSTR build_namespace( const struct view *view )
526 static const WCHAR cimv2W[] = {'R','O','O','T','\\','C','I','M','V','2',0};
528 if (view->proplist) return NULL;
529 return SysAllocString( cimv2W );
532 static BSTR build_proplist( const struct view *view, UINT index, UINT count, UINT *len )
534 static const WCHAR fmtW[] = {'%','s','=','%','s',0};
535 UINT i, j, offset, row = view->result[index];
536 BSTR *values, ret = NULL;
538 if (!(values = heap_alloc( count * sizeof(BSTR) ))) return NULL;
540 *len = j = 0;
541 for (i = 0; i < view->table->num_cols; i++)
543 if (view->table->columns[i].type & COL_FLAG_KEY)
545 const WCHAR *name = view->table->columns[i].name;
547 values[j] = get_value_bstr( view->table, row, i );
548 *len += strlenW( fmtW ) + strlenW( name ) + strlenW( values[j] );
549 j++;
552 if ((ret = SysAllocStringLen( NULL, *len )))
554 offset = j = 0;
555 for (i = 0; i < view->table->num_cols; i++)
557 if (view->table->columns[i].type & COL_FLAG_KEY)
559 const WCHAR *name = view->table->columns[i].name;
561 offset += sprintfW( ret + offset, fmtW, name, values[j] );
562 if (j < count - 1) ret[offset++] = ',';
563 j++;
567 for (i = 0; i < count; i++) SysFreeString( values[i] );
568 heap_free( values );
569 return ret;
572 static UINT count_key_columns( const struct view *view )
574 UINT i, num_keys = 0;
576 for (i = 0; i < view->table->num_cols; i++)
578 if (view->table->columns[i].type & COL_FLAG_KEY) num_keys++;
580 return num_keys;
583 static BSTR build_relpath( const struct view *view, UINT index, const WCHAR *name )
585 static const WCHAR fmtW[] = {'%','s','.','%','s',0};
586 BSTR class, proplist, ret = NULL;
587 UINT num_keys, len;
589 if (view->proplist) return NULL;
591 if (!(class = build_classname( view ))) return NULL;
592 if (!(num_keys = count_key_columns( view ))) return class;
593 if (!(proplist = build_proplist( view, index, num_keys, &len ))) goto done;
595 len += strlenW( fmtW ) + SysStringLen( class );
596 if (!(ret = SysAllocStringLen( NULL, len ))) goto done;
597 sprintfW( ret, fmtW, class, proplist );
599 done:
600 SysFreeString( class );
601 SysFreeString( proplist );
602 return ret;
605 static BSTR build_path( const struct view *view, UINT index, const WCHAR *name )
607 static const WCHAR fmtW[] = {'\\','\\','%','s','\\','%','s',':','%','s',0};
608 BSTR server, namespace = NULL, relpath = NULL, ret = NULL;
609 UINT len;
611 if (view->proplist) return NULL;
613 if (!(server = build_servername( view ))) return NULL;
614 if (!(namespace = build_namespace( view ))) goto done;
615 if (!(relpath = build_relpath( view, index, name ))) goto done;
617 len = strlenW( fmtW ) + SysStringLen( server ) + SysStringLen( namespace ) + SysStringLen( relpath );
618 if (!(ret = SysAllocStringLen( NULL, len ))) goto done;
619 sprintfW( ret, fmtW, server, namespace, relpath );
621 done:
622 SysFreeString( server );
623 SysFreeString( namespace );
624 SysFreeString( relpath );
625 return ret;
628 BOOL is_method( const struct table *table, UINT column )
630 return table->columns[column].type & COL_FLAG_METHOD;
633 static UINT count_properties( const struct view *view )
635 UINT i, num_props = 0;
637 for (i = 0; i < view->table->num_cols; i++)
639 if (!is_method( view->table, i)) num_props++;
641 return num_props;
644 static UINT count_selected_properties( const struct view *view )
646 const struct property *prop = view->proplist;
647 UINT count;
649 if (!prop) return count_properties( view );
651 count = 1;
652 while ((prop = prop->next)) count++;
653 return count;
656 static HRESULT get_system_propval( const struct view *view, UINT index, const WCHAR *name,
657 VARIANT *ret, CIMTYPE *type, LONG *flavor )
659 static const WCHAR classW[] = {'_','_','C','L','A','S','S',0};
660 static const WCHAR genusW[] = {'_','_','G','E','N','U','S',0};
661 static const WCHAR pathW[] = {'_','_','P','A','T','H',0};
662 static const WCHAR namespaceW[] = {'_','_','N','A','M','E','S','P','A','C','E',0};
663 static const WCHAR propcountW[] = {'_','_','P','R','O','P','E','R','T','Y','_','C','O','U','N','T',0};
664 static const WCHAR relpathW[] = {'_','_','R','E','L','P','A','T','H',0};
665 static const WCHAR serverW[] = {'_','_','S','E','R','V','E','R',0};
667 if (flavor) *flavor = WBEM_FLAVOR_ORIGIN_SYSTEM;
669 if (!strcmpiW( name, classW ))
671 V_VT( ret ) = VT_BSTR;
672 V_BSTR( ret ) = build_classname( view );
673 if (type) *type = CIM_STRING;
674 return S_OK;
676 if (!strcmpiW( name, genusW ))
678 V_VT( ret ) = VT_I4;
679 V_I4( ret ) = WBEM_GENUS_INSTANCE; /* FIXME */
680 if (type) *type = CIM_SINT32;
681 return S_OK;
683 else if (!strcmpiW( name, namespaceW ))
685 V_VT( ret ) = VT_BSTR;
686 V_BSTR( ret ) = build_namespace( view );
687 if (type) *type = CIM_STRING;
688 return S_OK;
690 else if (!strcmpiW( name, pathW ))
692 V_VT( ret ) = VT_BSTR;
693 V_BSTR( ret ) = build_path( view, index, name );
694 if (type) *type = CIM_STRING;
695 return S_OK;
697 if (!strcmpiW( name, propcountW ))
699 V_VT( ret ) = VT_I4;
700 V_I4( ret ) = count_selected_properties( view );
701 if (type) *type = CIM_SINT32;
702 return S_OK;
704 else if (!strcmpiW( name, relpathW ))
706 V_VT( ret ) = VT_BSTR;
707 V_BSTR( ret ) = build_relpath( view, index, name );
708 if (type) *type = CIM_STRING;
709 return S_OK;
711 else if (!strcmpiW( name, serverW ))
713 V_VT( ret ) = VT_BSTR;
714 V_BSTR( ret ) = build_servername( view );
715 if (type) *type = CIM_STRING;
716 return S_OK;
718 FIXME("system property %s not implemented\n", debugstr_w(name));
719 return WBEM_E_NOT_FOUND;
722 VARTYPE to_vartype( CIMTYPE type )
724 switch (type)
726 case CIM_BOOLEAN: return VT_BOOL;
727 case CIM_STRING:
728 case CIM_DATETIME: return VT_BSTR;
729 case CIM_SINT8: return VT_I1;
730 case CIM_UINT8: return VT_UI1;
731 case CIM_SINT16: return VT_I2;
732 case CIM_UINT16: return VT_UI2;
733 case CIM_SINT32: return VT_I4;
734 case CIM_UINT32: return VT_UI4;
735 case CIM_SINT64: return VT_I8;
736 case CIM_UINT64: return VT_UI8;
737 default:
738 ERR("unhandled type %u\n", type);
739 break;
741 return 0;
744 SAFEARRAY *to_safearray( const struct array *array, CIMTYPE type )
746 SAFEARRAY *ret;
747 UINT size = get_type_size( type );
748 VARTYPE vartype = to_vartype( type );
749 LONG i;
751 if (!array || !(ret = SafeArrayCreateVector( vartype, 0, array->count ))) return NULL;
753 for (i = 0; i < array->count; i++)
755 void *ptr = (char *)array->ptr + i * size;
756 if (vartype == VT_BSTR)
758 BSTR str = SysAllocString( *(const WCHAR **)ptr );
759 if (!str || SafeArrayPutElement( ret, &i, str ) != S_OK)
761 SysFreeString( str );
762 SafeArrayDestroy( ret );
763 return NULL;
765 SysFreeString( str );
767 else if (SafeArrayPutElement( ret, &i, ptr ) != S_OK)
769 SafeArrayDestroy( ret );
770 return NULL;
773 return ret;
776 void set_variant( VARTYPE type, LONGLONG val, void *val_ptr, VARIANT *ret )
778 if (type & VT_ARRAY)
780 V_VT( ret ) = type;
781 V_ARRAY( ret ) = val_ptr;
782 return;
784 switch (type)
786 case VT_BOOL:
787 V_BOOL( ret ) = val;
788 break;
789 case VT_BSTR:
790 V_BSTR( ret ) = val_ptr;
791 break;
792 case VT_I1:
793 V_I1( ret ) = val;
794 break;
795 case VT_UI1:
796 V_UI1( ret ) = val;
797 break;
798 case VT_I2:
799 V_I2( ret ) = val;
800 break;
801 case VT_UI2:
802 V_UI2( ret ) = val;
803 break;
804 case VT_I4:
805 V_I4( ret ) = val;
806 break;
807 case VT_UI4:
808 V_UI4( ret ) = val;
809 break;
810 case VT_NULL:
811 break;
812 default:
813 ERR("unhandled variant type %u\n", type);
814 return;
816 V_VT( ret ) = type;
819 HRESULT get_propval( const struct view *view, UINT index, const WCHAR *name, VARIANT *ret,
820 CIMTYPE *type, LONG *flavor )
822 HRESULT hr;
823 UINT column, row;
824 VARTYPE vartype;
825 void *val_ptr = NULL;
826 LONGLONG val;
828 if (is_system_prop( name )) return get_system_propval( view, index, name, ret, type, flavor );
829 if (!view->count || !is_selected_prop( view, name )) return WBEM_E_NOT_FOUND;
831 hr = get_column_index( view->table, name, &column );
832 if (hr != S_OK || is_method( view->table, column )) return WBEM_E_NOT_FOUND;
834 row = view->result[index];
835 hr = get_value( view->table, row, column, &val );
836 if (hr != S_OK) return hr;
838 vartype = view->table->columns[column].vartype;
839 if (view->table->columns[column].type & CIM_FLAG_ARRAY)
841 CIMTYPE basetype = view->table->columns[column].type & CIM_TYPE_MASK;
843 val_ptr = to_safearray( (const struct array *)(INT_PTR)val, basetype );
844 if (!val_ptr) vartype = VT_NULL;
845 else if (!vartype) vartype = to_vartype( basetype ) | VT_ARRAY;
846 goto done;
848 switch (view->table->columns[column].type & COL_TYPE_MASK)
850 case CIM_BOOLEAN:
851 if (!vartype) vartype = VT_BOOL;
852 break;
853 case CIM_STRING:
854 case CIM_DATETIME:
855 if (val)
857 vartype = VT_BSTR;
858 val_ptr = SysAllocString( (const WCHAR *)(INT_PTR)val );
860 else
861 vartype = VT_NULL;
862 break;
863 case CIM_SINT8:
864 if (!vartype) vartype = VT_I1;
865 break;
866 case CIM_UINT8:
867 if (!vartype) vartype = VT_UI1;
868 break;
869 case CIM_SINT16:
870 if (!vartype) vartype = VT_I2;
871 break;
872 case CIM_UINT16:
873 if (!vartype) vartype = VT_UI2;
874 break;
875 case CIM_SINT32:
876 if (!vartype) vartype = VT_I4;
877 break;
878 case CIM_UINT32:
879 if (!vartype) vartype = VT_UI4;
880 break;
881 case CIM_SINT64:
882 vartype = VT_BSTR;
883 val_ptr = get_value_bstr( view->table, row, column );
884 break;
885 case CIM_UINT64:
886 vartype = VT_BSTR;
887 val_ptr = get_value_bstr( view->table, row, column );
888 break;
889 default:
890 ERR("unhandled column type %u\n", view->table->columns[column].type);
891 return WBEM_E_FAILED;
894 done:
895 set_variant( vartype, val, val_ptr, ret );
896 if (type) *type = view->table->columns[column].type & COL_TYPE_MASK;
897 if (flavor) *flavor = 0;
898 return S_OK;
901 static CIMTYPE to_cimtype( VARTYPE type )
903 switch (type)
905 case VT_BOOL: return CIM_BOOLEAN;
906 case VT_BSTR: return CIM_STRING;
907 case VT_I1: return CIM_SINT8;
908 case VT_UI1: return CIM_UINT8;
909 case VT_I2: return CIM_SINT16;
910 case VT_UI2: return CIM_UINT16;
911 case VT_I4: return CIM_SINT32;
912 case VT_UI4: return CIM_UINT32;
913 case VT_I8: return CIM_SINT64;
914 case VT_UI8: return CIM_UINT64;
915 default:
916 ERR("unhandled type %u\n", type);
917 break;
919 return 0;
922 static struct array *to_array( VARIANT *var, CIMTYPE *type )
924 struct array *ret;
925 LONG bound, i;
926 VARTYPE vartype;
927 CIMTYPE basetype;
928 UINT size;
930 if (SafeArrayGetVartype( V_ARRAY( var ), &vartype ) != S_OK) return NULL;
931 if (!(basetype = to_cimtype( vartype ))) return NULL;
932 if (SafeArrayGetUBound( V_ARRAY( var ), 1, &bound ) != S_OK) return NULL;
933 if (!(ret = heap_alloc( sizeof(struct array) ))) return NULL;
935 ret->count = bound + 1;
936 size = get_type_size( basetype );
937 if (!(ret->ptr = heap_alloc_zero( ret->count * size )))
939 heap_free( ret );
940 return NULL;
942 for (i = 0; i < ret->count; i++)
944 void *ptr = (char *)ret->ptr + i * size;
945 if (vartype == VT_BSTR)
947 BSTR str;
948 if (SafeArrayGetElement( V_ARRAY( var ), &i, &str ) != S_OK)
950 destroy_array( ret, basetype );
951 return NULL;
953 *(WCHAR **)ptr = heap_strdupW( str );
954 SysFreeString( str );
955 if (!*(WCHAR **)ptr)
957 destroy_array( ret, basetype );
958 return NULL;
961 else if (SafeArrayGetElement( V_ARRAY( var ), &i, ptr ) != S_OK)
963 destroy_array( ret, basetype );
964 return NULL;
967 *type = basetype | CIM_FLAG_ARRAY;
968 return ret;
971 HRESULT to_longlong( VARIANT *var, LONGLONG *val, CIMTYPE *type )
973 if (!var)
975 *val = 0;
976 return S_OK;
978 if (V_VT( var ) & VT_ARRAY)
980 *val = (INT_PTR)to_array( var, type );
981 if (!*val) return E_OUTOFMEMORY;
982 return S_OK;
984 switch (V_VT( var ))
986 case VT_BOOL:
987 *val = V_BOOL( var );
988 *type = CIM_BOOLEAN;
989 break;
990 case VT_BSTR:
991 *val = (INT_PTR)heap_strdupW( V_BSTR( var ) );
992 if (!*val) return E_OUTOFMEMORY;
993 *type = CIM_STRING;
994 break;
995 case VT_I2:
996 *val = V_I2( var );
997 *type = CIM_SINT16;
998 break;
999 case VT_UI2:
1000 *val = V_UI2( var );
1001 *type = CIM_UINT16;
1002 break;
1003 case VT_I4:
1004 *val = V_I4( var );
1005 *type = CIM_SINT32;
1006 break;
1007 case VT_UI4:
1008 *val = V_UI4( var );
1009 *type = CIM_UINT32;
1010 break;
1011 case VT_NULL:
1012 *val = 0;
1013 break;
1014 default:
1015 ERR("unhandled type %u\n", V_VT( var ));
1016 return WBEM_E_FAILED;
1018 return S_OK;
1021 HRESULT put_propval( const struct view *view, UINT index, const WCHAR *name, VARIANT *var, CIMTYPE type )
1023 HRESULT hr;
1024 UINT column, row = view->result[index];
1025 LONGLONG val;
1027 hr = get_column_index( view->table, name, &column );
1028 if (hr != S_OK)
1030 FIXME("no support for creating new properties\n");
1031 return WBEM_E_FAILED;
1033 if (is_method( view->table, column ) || !(view->table->columns[column].type & COL_FLAG_DYNAMIC))
1034 return WBEM_E_FAILED;
1036 hr = to_longlong( var, &val, &type );
1037 if (hr != S_OK) return hr;
1039 return set_value( view->table, row, column, val, type );
1042 HRESULT get_properties( const struct view *view, LONG flags, SAFEARRAY **props )
1044 SAFEARRAY *sa;
1045 BSTR str;
1046 UINT i, num_props = count_selected_properties( view );
1047 LONG j;
1049 if (!(sa = SafeArrayCreateVector( VT_BSTR, 0, num_props ))) return E_OUTOFMEMORY;
1051 for (i = 0, j = 0; i < view->table->num_cols; i++)
1053 BOOL is_system;
1055 if (is_method( view->table, i )) continue;
1056 if (!is_selected_prop( view, view->table->columns[i].name )) continue;
1058 is_system = is_system_prop( view->table->columns[i].name );
1059 if ((flags & WBEM_FLAG_NONSYSTEM_ONLY) && is_system) continue;
1060 else if ((flags & WBEM_FLAG_SYSTEM_ONLY) && !is_system) continue;
1062 str = SysAllocString( view->table->columns[i].name );
1063 if (!str || SafeArrayPutElement( sa, &j, str ) != S_OK)
1065 SysFreeString( str );
1066 SafeArrayDestroy( sa );
1067 return E_OUTOFMEMORY;
1069 SysFreeString( str );
1070 j++;
1072 *props = sa;
1073 return S_OK;