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