?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
cryptext: Add stubs for CryptExtAddPFX/CryptExtAddPFXW.
[wine.git] / dlls / wbemprox / query.c
blob7ae9a0f1884bd342c1ef6276d8bc3296d3341bff
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 && toupperW( p[1] ) != toupperW( q[1] )) p++;
67 if (!*p) return TRUE;
68 }
69 if (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 }
704 else if (SafeArrayPutElement( ret, &i, ptr ) != S_OK)
705 {
706 SafeArrayDestroy( ret );
707 return NULL;
708 }
709 }
710 return ret;
711 }
712
713 void set_variant( VARTYPE type, LONGLONG val, void *val_ptr, VARIANT *ret )
714 {
715 if (type & VT_ARRAY)
716 {
717 V_VT( ret ) = type;
718 V_ARRAY( ret ) = val_ptr;
719 return;
720 }
721 switch (type)
722 {
723 case VT_BOOL:
724 V_BOOL( ret ) = val;
725 break;
726 case VT_BSTR:
727 V_BSTR( ret ) = val_ptr;
728 break;
729 case VT_I1:
730 V_I1( ret ) = val;
731 break;
732 case VT_UI1:
733 V_UI1( ret ) = val;
734 break;
735 case VT_I2:
736 V_I2( ret ) = val;
737 break;
738 case VT_UI2:
739 V_UI2( ret ) = val;
740 break;
741 case VT_I4:
742 V_I4( ret ) = val;
743 break;
744 case VT_UI4:
745 V_UI4( ret ) = val;
746 break;
747 case VT_NULL:
748 break;
749 default:
750 ERR("unhandled variant type %u\n", type);
751 return;
752 }
753 V_VT( ret ) = type;
754 }
755
756 HRESULT get_propval( const struct view *view, UINT index, const WCHAR *name, VARIANT *ret,
757 CIMTYPE *type, LONG *flavor )
758 {
759 HRESULT hr;
760 UINT column, row;
761 VARTYPE vartype;
762 void *val_ptr = NULL;
763 LONGLONG val;
764
765 if (is_system_prop( name )) return get_system_propval( view, index, name, ret, type, flavor );
766 if (!view->count || !is_selected_prop( view, name )) return WBEM_E_NOT_FOUND;
767
768 hr = get_column_index( view->table, name, &column );
769 if (hr != S_OK || is_method( view->table, column )) return WBEM_E_NOT_FOUND;
770
771 row = view->result[index];
772 hr = get_value( view->table, row, column, &val );
773 if (hr != S_OK) return hr;
774
775 vartype = view->table->columns[column].vartype;
776 if (view->table->columns[column].type & CIM_FLAG_ARRAY)
777 {
778 CIMTYPE basetype = view->table->columns[column].type & CIM_TYPE_MASK;
779
780 val_ptr = to_safearray( (const struct array *)(INT_PTR)val, basetype );
781 if (!vartype) vartype = to_vartype( basetype ) | VT_ARRAY;
782 goto done;
783 }
784 switch (view->table->columns[column].type & COL_TYPE_MASK)
785 {
786 case CIM_BOOLEAN:
787 if (!vartype) vartype = VT_BOOL;
788 break;
789 case CIM_STRING:
790 case CIM_DATETIME:
791 if (val)
792 {
793 vartype = VT_BSTR;
794 val_ptr = SysAllocString( (const WCHAR *)(INT_PTR)val );
795 }
796 else
797 vartype = VT_NULL;
798 break;
799 case CIM_SINT8:
800 if (!vartype) vartype = VT_I1;
801 break;
802 case CIM_UINT8:
803 if (!vartype) vartype = VT_UI1;
804 break;
805 case CIM_SINT16:
806 if (!vartype) vartype = VT_I2;
807 break;
808 case CIM_UINT16:
809 if (!vartype) vartype = VT_UI2;
810 break;
811 case CIM_SINT32:
812 if (!vartype) vartype = VT_I4;
813 break;
814 case CIM_UINT32:
815 if (!vartype) vartype = VT_UI4;
816 break;
817 case CIM_SINT64:
818 vartype = VT_BSTR;
819 val_ptr = get_value_bstr( view->table, row, column );
820 break;
821 case CIM_UINT64:
822 vartype = VT_BSTR;
823 val_ptr = get_value_bstr( view->table, row, column );
824 break;
825 default:
826 ERR("unhandled column type %u\n", view->table->columns[column].type);
827 return WBEM_E_FAILED;
828 }
829
830 done:
831 set_variant( vartype, val, val_ptr, ret );
832 if (type) *type = view->table->columns[column].type & COL_TYPE_MASK;
833 if (flavor) *flavor = 0;
834 return S_OK;
835 }
836
837 static CIMTYPE to_cimtype( VARTYPE type )
838 {
839 switch (type)
840 {
841 case VT_BOOL: return CIM_BOOLEAN;
842 case VT_BSTR: return CIM_STRING;
843 case VT_I1: return CIM_SINT8;
844 case VT_UI1: return CIM_UINT8;
845 case VT_I2: return CIM_SINT16;
846 case VT_UI2: return CIM_UINT16;
847 case VT_I4: return CIM_SINT32;
848 case VT_UI4: return CIM_UINT32;
849 case VT_I8: return CIM_SINT64;
850 case VT_UI8: return CIM_UINT64;
851 default:
852 ERR("unhandled type %u\n", type);
853 break;
854 }
855 return 0;
856 }
857
858 static struct array *to_array( VARIANT *var, CIMTYPE *type )
859 {
860 struct array *ret;
861 LONG bound, i;
862 VARTYPE vartype;
863 CIMTYPE basetype;
864 UINT size;
865
866 if (SafeArrayGetVartype( V_ARRAY( var ), &vartype ) != S_OK) return NULL;
867 if (!(basetype = to_cimtype( vartype ))) return NULL;
868 if (SafeArrayGetUBound( V_ARRAY( var ), 1, &bound ) != S_OK) return NULL;
869 if (!(ret = heap_alloc( sizeof(struct array) ))) return NULL;
870
871 ret->count = bound + 1;
872 size = get_type_size( basetype );
873 if (!(ret->ptr = heap_alloc_zero( ret->count * size )))
874 {
875 heap_free( ret );
876 return NULL;
877 }
878 for (i = 0; i < ret->count; i++)
879 {
880 void *ptr = (char *)ret->ptr + i * size;
881 if (vartype == VT_BSTR)
882 {
883 BSTR str;
884 if (SafeArrayGetElement( V_ARRAY( var ), &i, &str ) != S_OK)
885 {
886 destroy_array( ret, basetype );
887 return NULL;
888 }
889 *(WCHAR **)ptr = heap_strdupW( str );
890 SysFreeString( str );
891 if (!*(WCHAR **)ptr)
892 {
893 destroy_array( ret, basetype );
894 return NULL;
895 }
896 }
897 else if (SafeArrayGetElement( V_ARRAY( var ), &i, ptr ) != S_OK)
898 {
899 destroy_array( ret, basetype );
900 return NULL;
901 }
902 }
903 *type = basetype | CIM_FLAG_ARRAY;
904 return ret;
905 }
906
907 HRESULT to_longlong( VARIANT *var, LONGLONG *val, CIMTYPE *type )
908 {
909 if (!var)
910 {
911 *val = 0;
912 return S_OK;
913 }
914 if (V_VT( var ) & VT_ARRAY)
915 {
916 *val = (INT_PTR)to_array( var, type );
917 if (!*val) return E_OUTOFMEMORY;
918 return S_OK;
919 }
920 switch (V_VT( var ))
921 {
922 case VT_BOOL:
923 *val = V_BOOL( var );
924 *type = CIM_BOOLEAN;
925 break;
926 case VT_BSTR:
927 *val = (INT_PTR)heap_strdupW( V_BSTR( var ) );
928 if (!*val) return E_OUTOFMEMORY;
929 *type = CIM_STRING;
930 break;
931 case VT_I2:
932 *val = V_I2( var );
933 *type = CIM_SINT16;
934 break;
935 case VT_UI2:
936 *val = V_UI2( var );
937 *type = CIM_UINT16;
938 break;
939 case VT_I4:
940 *val = V_I4( var );
941 *type = CIM_SINT32;
942 break;
943 case VT_UI4:
944 *val = V_UI4( var );
945 *type = CIM_UINT32;
946 break;
947 case VT_NULL:
948 *val = 0;
949 break;
950 default:
951 ERR("unhandled type %u\n", V_VT( var ));
952 return WBEM_E_FAILED;
953 }
954 return S_OK;
955 }
956
957 HRESULT put_propval( const struct view *view, UINT index, const WCHAR *name, VARIANT *var, CIMTYPE type )
958 {
959 HRESULT hr;
960 UINT column, row = view->result[index];
961 LONGLONG val;
962
963 hr = get_column_index( view->table, name, &column );
964 if (hr != S_OK)
965 {
966 FIXME("no support for creating new properties\n");
967 return WBEM_E_FAILED;
968 }
969 if (is_method( view->table, column ) || !(view->table->columns[column].type & COL_FLAG_DYNAMIC))
970 return WBEM_E_FAILED;
971
972 hr = to_longlong( var, &val, &type );
973 if (hr != S_OK) return hr;
974
975 return set_value( view->table, row, column, val, type );
976 }
977
978 HRESULT get_properties( const struct view *view, LONG flags, SAFEARRAY **props )
979 {
980 SAFEARRAY *sa;
981 BSTR str;
982 UINT i, num_props = count_selected_properties( view );
983 LONG j;
984
985 if (!(sa = SafeArrayCreateVector( VT_BSTR, 0, num_props ))) return E_OUTOFMEMORY;
986
987 for (i = 0, j = 0; i < view->table->num_cols; i++)
988 {
989 BOOL is_system;
990
991 if (is_method( view->table, i )) continue;
992 if (!is_selected_prop( view, view->table->columns[i].name )) continue;
993
994 is_system = is_system_prop( view->table->columns[i].name );
995 if ((flags & WBEM_FLAG_NONSYSTEM_ONLY) && is_system) continue;
996 else if ((flags & WBEM_FLAG_SYSTEM_ONLY) && !is_system) continue;
997
998 str = SysAllocString( view->table->columns[i].name );
999 if (!str || SafeArrayPutElement( sa, &j, str ) != S_OK)
1000 {
1001 SysFreeString( str );
1002 SafeArrayDestroy( sa );
1003 return E_OUTOFMEMORY;
1004 }
1005 j++;
1006 }
1007 *props = sa;
1008 return S_OK;
1009 }
Windows API implementation