?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
include/mscvpdb.h: Use flexible array members for the rest of structures.
[wine.git] / dlls / wbemprox / query.c
bloba6599334f586adea496fe9516acddd61c3b12d40
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 <stdarg.h>
22
23 #include "windef.h"
24 #include "winbase.h"
25 #include "wbemcli.h"
26
27 #include "wine/debug.h"
28 #include "wbemprox_private.h"
29
30 WINE_DEFAULT_DEBUG_CHANNEL(wbemprox);
31
32 static HRESULT append_table( struct view *view, struct table *table )
33 {
34 struct table **tmp;
35 if (!(tmp = realloc( view->table, (view->table_count + 1) * sizeof(*tmp) ))) return E_OUTOFMEMORY;
36 view->table = tmp;
37 view->table[view->table_count++] = table;
38 return S_OK;
39 }
40
41 HRESULT create_view( enum view_type type, enum wbm_namespace ns, const WCHAR *path, const struct keyword *keywordlist,
42 const WCHAR *class, const struct property *proplist, const struct expr *cond, struct view **ret )
43 {
44 struct view *view = calloc( 1, sizeof(*view) );
45
46 if (!view) return E_OUTOFMEMORY;
47
48 switch (type)
49 {
50 case VIEW_TYPE_ASSOCIATORS:
51 view->path = path;
52 view->keywordlist = keywordlist;
53 break;
54
55 case VIEW_TYPE_SELECT:
56 {
57 struct table *table = find_table( ns, class );
58 HRESULT hr;
59
60 if (table && (hr = append_table( view, table )) != S_OK)
61 {
62 release_table( table );
63 free( view );
64 return hr;
65 }
66 else if (!table && ns == WBEMPROX_NAMESPACE_LAST)
67 {
68 free( view );
69 return WBEM_E_INVALID_CLASS;
70 }
71 view->proplist = proplist;
72 view->cond = cond;
73 break;
74 }
75 default:
76 ERR( "unhandled type %u\n", type );
77 free( view );
78 return E_INVALIDARG;
79 }
80
81 view->type = type;
82 view->ns = ns;
83 *ret = view;
84 return S_OK;
85 }
86
87 void destroy_view( struct view *view )
88 {
89 ULONG i;
90 if (!view) return;
91 for (i = 0; i < view->table_count; i++) release_table( view->table[i] );
92 free( view->table );
93 free( view->result );
94 free( view );
95 }
96
97 static BOOL eval_like( const WCHAR *text, const WCHAR *pattern )
98 {
99 if (wcsstr( pattern, L"[" )) FIXME( "character ranges (i.e. [abc], [^a-z]) are not supported\n" );
100
101 while (*text)
102 {
103 if (pattern[0] == '\\' && pattern[1] == '\\') pattern++;
104
105 if (*pattern == '%')
106 {
107 while (*pattern == '%') pattern++;
108 if (!*pattern) return TRUE;
109 while (!eval_like( text, pattern ) && *text) text++;
110
111 return !!*text;
112 }
113
114 if (*pattern != '_' && towupper( *text ) != towupper( *pattern )) return FALSE;
115 text++; pattern++;
116 }
117
118 while (*pattern == '%') pattern++;
119
120 return *pattern == '\0';
121 }
122
123 static HRESULT eval_strcmp( UINT op, const WCHAR *lstr, const WCHAR *rstr, LONGLONG *val )
124 {
125 if (!lstr || !rstr)
126 {
127 *val = 0;
128 return S_OK;
129 }
130 switch (op)
131 {
132 case OP_EQ:
133 *val = !wcsicmp( lstr, rstr );
134 break;
135 case OP_GT:
136 *val = wcsicmp( lstr, rstr ) > 0;
137 break;
138 case OP_LT:
139 *val = wcsicmp( lstr, rstr ) < 0;
140 break;
141 case OP_LE:
142 *val = wcsicmp( lstr, rstr ) <= 0;
143 break;
144 case OP_GE:
145 *val = wcsicmp( lstr, rstr ) >= 0;
146 break;
147 case OP_NE:
148 *val = wcsicmp( lstr, rstr );
149 break;
150 case OP_LIKE:
151 *val = eval_like( lstr, rstr );
152 break;
153 default:
154 ERR("unhandled operator %u\n", op);
155 return WBEM_E_INVALID_QUERY;
156 }
157 return S_OK;
158 }
159
160 static BOOL is_int( CIMTYPE type )
161 {
162 switch (type)
163 {
164 case CIM_SINT8:
165 case CIM_SINT16:
166 case CIM_SINT32:
167 case CIM_SINT64:
168 case CIM_UINT8:
169 case CIM_UINT16:
170 case CIM_UINT32:
171 case CIM_UINT64:
172 return TRUE;
173 default:
174 return FALSE;
175 }
176 }
177
178 static inline BOOL is_strcmp( const struct complex_expr *expr, UINT ltype, UINT rtype )
179 {
180 if ((ltype == CIM_STRING || is_int( ltype )) && expr->left->type == EXPR_PROPVAL &&
181 expr->right->type == EXPR_SVAL) return TRUE;
182 else if ((rtype == CIM_STRING || is_int( rtype )) && expr->right->type == EXPR_PROPVAL &&
183 expr->left->type == EXPR_SVAL) return TRUE;
184 return FALSE;
185 }
186
187 static inline BOOL is_boolcmp( const struct complex_expr *expr, UINT ltype, UINT rtype )
188 {
189 if (ltype == CIM_BOOLEAN && expr->left->type == EXPR_PROPVAL &&
190 (expr->right->type == EXPR_SVAL || expr->right->type == EXPR_BVAL)) return TRUE;
191 else if (rtype == CIM_BOOLEAN && expr->right->type == EXPR_PROPVAL &&
192 (expr->left->type == EXPR_SVAL || expr->left->type == EXPR_BVAL)) return TRUE;
193 return FALSE;
194 }
195
196 static HRESULT eval_boolcmp( UINT op, LONGLONG lval, LONGLONG rval, UINT ltype, UINT rtype, LONGLONG *val )
197 {
198 if (ltype == CIM_STRING) lval = !wcsicmp( (const WCHAR *)(INT_PTR)lval, L"True" ) ? -1 : 0;
199 else if (rtype == CIM_STRING) rval = !wcsicmp( (const WCHAR *)(INT_PTR)rval, L"True" ) ? -1 : 0;
200
201 switch (op)
202 {
203 case OP_EQ:
204 *val = (lval == rval);
205 break;
206 case OP_NE:
207 *val = (lval != rval);
208 break;
209 default:
210 ERR("unhandled operator %u\n", op);
211 return WBEM_E_INVALID_QUERY;
212 }
213 return S_OK;
214 }
215
216 static inline BOOL is_refcmp( const struct complex_expr *expr, UINT ltype, UINT rtype )
217 {
218 if (ltype == CIM_REFERENCE && expr->left->type == EXPR_PROPVAL && expr->right->type == EXPR_SVAL) return TRUE;
219 else if (rtype == CIM_REFERENCE && expr->right->type == EXPR_PROPVAL && expr->left->type == EXPR_SVAL) return TRUE;
220 return FALSE;
221 }
222
223 static HRESULT eval_refcmp( UINT op, const WCHAR *lstr, const WCHAR *rstr, LONGLONG *val )
224 {
225 if (!lstr || !rstr)
226 {
227 *val = 0;
228 return S_OK;
229 }
230 switch (op)
231 {
232 case OP_EQ:
233 *val = !wcsicmp( lstr, rstr );
234 break;
235 case OP_NE:
236 *val = wcsicmp( lstr, rstr );
237 break;
238 default:
239 ERR("unhandled operator %u\n", op);
240 return WBEM_E_INVALID_QUERY;
241 }
242 return S_OK;
243 }
244
245 static UINT resolve_type( UINT left, UINT right )
246 {
247 switch (left)
248 {
249 case CIM_SINT8:
250 case CIM_SINT16:
251 case CIM_SINT32:
252 case CIM_SINT64:
253 case CIM_UINT8:
254 case CIM_UINT16:
255 case CIM_UINT32:
256 case CIM_UINT64:
257 switch (right)
258 {
259 case CIM_SINT8:
260 case CIM_SINT16:
261 case CIM_SINT32:
262 case CIM_SINT64:
263 case CIM_UINT8:
264 case CIM_UINT16:
265 case CIM_UINT32:
266 case CIM_UINT64:
267 return CIM_UINT64;
268 default: break;
269 }
270 break;
271
272 case CIM_STRING:
273 if (right == CIM_STRING) return CIM_STRING;
274 break;
275
276 case CIM_BOOLEAN:
277 if (right == CIM_BOOLEAN) return CIM_BOOLEAN;
278 break;
279
280 case CIM_REFERENCE:
281 if (right == CIM_REFERENCE) return CIM_REFERENCE;
282 break;
283
284 default:
285 break;
286 }
287 return CIM_ILLEGAL;
288 }
289
290 static const WCHAR *format_int( WCHAR *buf, UINT len, CIMTYPE type, LONGLONG val )
291 {
292 switch (type)
293 {
294 case CIM_SINT8:
295 case CIM_SINT16:
296 case CIM_SINT32:
297 swprintf( buf, len, L"%d", val );
298 return buf;
299
300 case CIM_UINT8:
301 case CIM_UINT16:
302 case CIM_UINT32:
303 swprintf( buf, len, L"%u", val );
304 return buf;
305
306 case CIM_SINT64:
307 wsprintfW( buf, L"%I64d", val );
308 return buf;
309
310 case CIM_UINT64:
311 wsprintfW( buf, L"%I64u", val );
312 return buf;
313
314 default:
315 ERR( "unhandled type %lu\n", type );
316 return NULL;
317 }
318 }
319
320 static HRESULT eval_binary( const struct table *table, UINT row, const struct complex_expr *expr,
321 LONGLONG *val, UINT *type )
322 {
323 HRESULT lret, rret;
324 LONGLONG lval, rval;
325 UINT ltype, rtype;
326
327 lret = eval_cond( table, row, expr->left, &lval, &ltype );
328 rret = eval_cond( table, row, expr->right, &rval, &rtype );
329 if (lret != S_OK || rret != S_OK) return WBEM_E_INVALID_QUERY;
330
331 *type = resolve_type( ltype, rtype );
332
333 if (is_strcmp( expr, ltype, rtype ))
334 {
335 const WCHAR *lstr, *rstr;
336 WCHAR lbuf[21], rbuf[21];
337
338 if (is_int( ltype )) lstr = format_int( lbuf, ARRAY_SIZE( lbuf ), ltype, lval );
339 else lstr = (const WCHAR *)(INT_PTR)lval;
340
341 if (is_int( rtype )) rstr = format_int( rbuf, ARRAY_SIZE( rbuf ), rtype, rval );
342 else rstr = (const WCHAR *)(INT_PTR)rval;
343
344 return eval_strcmp( expr->op, lstr, rstr, val );
345 }
346 if (is_boolcmp( expr, ltype, rtype ))
347 {
348 return eval_boolcmp( expr->op, lval, rval, ltype, rtype, val );
349 }
350 if (is_refcmp( expr, ltype, rtype ))
351 {
352 return eval_refcmp( expr->op, (const WCHAR *)(INT_PTR)lval, (const WCHAR *)(INT_PTR)rval, val );
353 }
354
355 switch (expr->op)
356 {
357 case OP_EQ:
358 *val = (lval == rval);
359 break;
360 case OP_AND:
361 *val = (lval && rval);
362 break;
363 case OP_OR:
364 *val = (lval || rval);
365 break;
366 case OP_GT:
367 *val = (lval > rval);
368 break;
369 case OP_LT:
370 *val = (lval < rval);
371 break;
372 case OP_LE:
373 *val = (lval <= rval);
374 break;
375 case OP_GE:
376 *val = (lval >= rval);
377 break;
378 case OP_NE:
379 *val = (lval != rval);
380 break;
381 default:
382 ERR("unhandled operator %u\n", expr->op);
383 return WBEM_E_INVALID_QUERY;
384 }
385 return S_OK;
386 }
387
388 static HRESULT eval_unary( const struct table *table, UINT row, const struct complex_expr *expr,
389 LONGLONG *val, UINT *type )
390
391 {
392 HRESULT hr;
393 UINT column;
394 LONGLONG lval;
395
396 if (expr->op == OP_NOT)
397 {
398 hr = eval_cond( table, row, expr->left, &lval, type );
399 if (hr != S_OK)
400 return hr;
401 *val = !lval;
402 return S_OK;
403 }
404
405 hr = get_column_index( table, expr->left->u.propval->name, &column );
406 if (hr != S_OK)
407 return hr;
408
409 hr = get_value( table, row, column, &lval );
410 if (hr != S_OK)
411 return hr;
412
413 switch (expr->op)
414 {
415 case OP_ISNULL:
416 *val = !lval;
417 break;
418 case OP_NOTNULL:
419 *val = lval;
420 break;
421 default:
422 ERR("unknown operator %u\n", expr->op);
423 return WBEM_E_INVALID_QUERY;
424 }
425
426 *type = table->columns[column].type & CIM_TYPE_MASK;
427 return S_OK;
428 }
429
430 static HRESULT eval_propval( const struct table *table, UINT row, const struct property *propval,
431 LONGLONG *val, UINT *type )
432
433 {
434 HRESULT hr;
435 UINT column;
436
437 hr = get_column_index( table, propval->name, &column );
438 if (hr != S_OK)
439 return hr;
440
441 *type = table->columns[column].type & CIM_TYPE_MASK;
442 return get_value( table, row, column, val );
443 }
444
445 HRESULT eval_cond( const struct table *table, UINT row, const struct expr *cond, LONGLONG *val, UINT *type )
446 {
447 if (!cond)
448 {
449 *val = 1;
450 *type = CIM_UINT64;
451 return S_OK;
452 }
453 switch (cond->type)
454 {
455 case EXPR_COMPLEX:
456 return eval_binary( table, row, &cond->u.expr, val, type );
457
458 case EXPR_UNARY:
459 return eval_unary( table, row, &cond->u.expr, val, type );
460
461 case EXPR_PROPVAL:
462 return eval_propval( table, row, cond->u.propval, val, type );
463
464 case EXPR_SVAL:
465 *val = (INT_PTR)cond->u.sval;
466 *type = CIM_STRING;
467 return S_OK;
468
469 case EXPR_IVAL:
470 *val = cond->u.ival;
471 *type = CIM_UINT64;
472 return S_OK;
473
474 case EXPR_BVAL:
475 *val = cond->u.ival;
476 *type = CIM_BOOLEAN;
477 return S_OK;
478
479 default:
480 ERR("invalid expression type\n");
481 break;
482 }
483 return WBEM_E_INVALID_QUERY;
484 }
485
486 static WCHAR *build_assoc_query( const WCHAR *class, UINT class_len )
487 {
488 static const WCHAR fmtW[] = L"SELECT * FROM __ASSOCIATORS WHERE Class='%s'";
489 UINT len = class_len + ARRAY_SIZE(fmtW);
490 WCHAR *ret;
491
492 if (!(ret = malloc( len * sizeof(WCHAR) ))) return NULL;
493 swprintf( ret, len, fmtW, class );
494 return ret;
495 }
496
497 static HRESULT create_assoc_enum( enum wbm_namespace ns, const WCHAR *class, UINT class_len,
498 IEnumWbemClassObject **iter )
499 {
500 WCHAR *query;
501 HRESULT hr;
502
503 if (!(query = build_assoc_query( class, class_len ))) return E_OUTOFMEMORY;
504 hr = exec_query( ns, query, iter );
505 free( query );
506 return hr;
507 }
508
509 static WCHAR *build_antecedent_query( const WCHAR *assocclass, const WCHAR *dependent )
510 {
511 static const WCHAR fmtW[] = L"SELECT Antecedent FROM %s WHERE Dependent='%s'";
512 UINT len = lstrlenW(assocclass) + lstrlenW(dependent) + ARRAY_SIZE(fmtW);
513 WCHAR *ret;
514
515 if (!(ret = malloc( len * sizeof(WCHAR) ))) return NULL;
516 swprintf( ret, len, fmtW, assocclass, dependent );
517 return ret;
518 }
519
520 static BSTR build_servername(void)
521 {
522 WCHAR server[MAX_COMPUTERNAME_LENGTH + 1], *p;
523 DWORD len = ARRAY_SIZE( server );
524
525 if (!(GetComputerNameW( server, &len ))) return NULL;
526 for (p = server; *p; p++) *p = towupper( *p );
527 return SysAllocString( server );
528 }
529
530 static BSTR build_namespace(void)
531 {
532 return SysAllocString( L"ROOT\\CIMV2" );
533 }
534
535 static WCHAR *build_canonical_path( const WCHAR *relpath )
536 {
537 BSTR server, namespace;
538 WCHAR *ret;
539 UINT len, i;
540
541 if (!(server = build_servername())) return NULL;
542 if (!(namespace = build_namespace()))
543 {
544 SysFreeString( server );
545 return NULL;
546 }
547
548 len = ARRAY_SIZE( L"\\\\%s\\%s:" ) + SysStringLen( server ) + SysStringLen( namespace ) + lstrlenW( relpath );
549 if ((ret = malloc( len * sizeof(WCHAR ) )))
550 {
551 len = swprintf( ret, len, L"\\\\%s\\%s:", server, namespace );
552 for (i = 0; i < lstrlenW( relpath ); i ++)
553 {
554 if (relpath[i] == '\'') ret[len++] = '"';
555 else ret[len++] = relpath[i];
556 }
557 ret[len] = 0;
558 }
559
560 SysFreeString( server );
561 SysFreeString( namespace );
562 return ret;
563 }
564
565 static HRESULT get_antecedent( enum wbm_namespace ns, const WCHAR *assocclass, const WCHAR *dependent, BSTR *ret )
566 {
567 WCHAR *fullpath, *str;
568 IEnumWbemClassObject *iter = NULL;
569 IWbemClassObject *obj;
570 HRESULT hr = E_OUTOFMEMORY;
571 ULONG count;
572 VARIANT var;
573
574 if (!(fullpath = build_canonical_path( dependent ))) return E_OUTOFMEMORY;
575 if (!(str = build_antecedent_query( assocclass, fullpath ))) goto done;
576 if ((hr = exec_query( ns, str, &iter )) != S_OK) goto done;
577
578 IEnumWbemClassObject_Next( iter, WBEM_INFINITE, 1, &obj, &count );
579 if (!count)
580 {
581 *ret = NULL;
582 goto done;
583 }
584
585 hr = IWbemClassObject_Get( obj, L"Antecedent", 0, &var, NULL, NULL );
586 IWbemClassObject_Release( obj );
587 if (hr != S_OK) goto done;
588 *ret = V_BSTR( &var );
589
590 done:
591 if (iter) IEnumWbemClassObject_Release( iter );
592 free( str );
593 free( fullpath );
594 return hr;
595 }
596
597 static HRESULT do_query( enum wbm_namespace ns, const WCHAR *str, struct query **ret_query )
598 {
599 struct query *query;
600 HRESULT hr;
601
602 if (!(query = create_query( ns ))) return E_OUTOFMEMORY;
603 if ((hr = parse_query( ns, str, &query->view, &query->mem )) != S_OK || (hr = execute_view( query->view )) != S_OK)
604 {
605 release_query( query );
606 return hr;
607 }
608 *ret_query = query;
609 return S_OK;
610 }
611
612 static HRESULT get_antecedent_table( enum wbm_namespace ns, const WCHAR *assocclass, const WCHAR *dependent,
613 struct table **table )
614 {
615 BSTR antecedent = NULL;
616 struct path *path = NULL;
617 WCHAR *str = NULL;
618 struct query *query = NULL;
619 HRESULT hr;
620
621 if ((hr = get_antecedent( ns, assocclass, dependent, &antecedent )) != S_OK) return hr;
622 if (!antecedent)
623 {
624 *table = NULL;
625 return S_OK;
626 }
627 if ((hr = parse_path( antecedent, &path )) != S_OK) goto done;
628 if (!(str = query_from_path( path )))
629 {
630 hr = E_OUTOFMEMORY;
631 goto done;
632 }
633
634 if ((hr = do_query( ns, str, &query )) != S_OK) goto done;
635 if (query->view->table_count) *table = grab_table( query->view->table[0] );
636 else *table = NULL;
637
638 done:
639 if (query) release_query( query );
640 free_path( path );
641 SysFreeString( antecedent );
642 free( str );
643 return hr;
644 }
645
646 static HRESULT exec_assoc_view( struct view *view )
647 {
648 IEnumWbemClassObject *iter = NULL;
649 struct path *path;
650 HRESULT hr;
651
652 if (view->keywordlist) FIXME( "ignoring keywords\n" );
653 if ((hr = parse_path( view->path, &path )) != S_OK) return hr;
654
655 if ((hr = create_assoc_enum( view->ns, path->class, path->class_len, &iter )) != S_OK) goto done;
656 for (;;)
657 {
658 ULONG count;
659 IWbemClassObject *obj;
660 struct table *table;
661 VARIANT var;
662
663 IEnumWbemClassObject_Next( iter, WBEM_INFINITE, 1, &obj, &count );
664 if (!count) break;
665
666 if ((hr = IWbemClassObject_Get( obj, L"AssocClass", 0, &var, NULL, NULL )) != S_OK)
667 {
668 IWbemClassObject_Release( obj );
669 goto done;
670 }
671 IWbemClassObject_Release( obj );
672
673 hr = get_antecedent_table( view->ns, V_BSTR(&var), view->path, &table );
674 VariantClear( &var );
675 if (hr != S_OK) goto done;
676
677 if (table && (hr = append_table( view, table )) != S_OK)
678 {
679 release_table( table );
680 goto done;
681 }
682 }
683
684 if (view->table_count)
685 {
686 if (!(view->result = calloc( view->table_count, sizeof(UINT) ))) hr = E_OUTOFMEMORY;
687 else view->result_count = view->table_count;
688 }
689
690 done:
691 if (iter) IEnumWbemClassObject_Release( iter );
692 free_path( path );
693 return hr;
694 }
695
696 static HRESULT exec_select_view( struct view *view )
697 {
698 UINT i, j = 0, len;
699 enum fill_status status = FILL_STATUS_UNFILTERED;
700 struct table *table;
701
702 if (!view->table_count) return S_OK;
703
704 table = view->table[0];
705 if (table->fill)
706 {
707 clear_table( table );
708 status = table->fill( table, view->cond );
709 }
710 if (status == FILL_STATUS_FAILED) return WBEM_E_FAILED;
711 if (!table->num_rows) return S_OK;
712
713 len = min( table->num_rows, 16 );
714 if (!(view->result = malloc( len * sizeof(UINT) ))) return E_OUTOFMEMORY;
715
716 for (i = 0; i < table->num_rows; i++)
717 {
718 HRESULT hr;
719 LONGLONG val = 0;
720 UINT type;
721
722 if (j >= len)
723 {
724 UINT *tmp;
725 len *= 2;
726 if (!(tmp = realloc( view->result, len * sizeof(UINT) ))) return E_OUTOFMEMORY;
727 view->result = tmp;
728 }
729 if (status == FILL_STATUS_FILTERED) val = 1;
730 else if ((hr = eval_cond( table, i, view->cond, &val, &type )) != S_OK) return hr;
731 if (val) view->result[j++] = i;
732 }
733
734 view->result_count = j;
735 return S_OK;
736 }
737
738 HRESULT execute_view( struct view *view )
739 {
740 switch (view->type)
741 {
742 case VIEW_TYPE_ASSOCIATORS:
743 return exec_assoc_view( view );
744
745 case VIEW_TYPE_SELECT:
746 return exec_select_view( view );
747
748 default:
749 ERR( "unhandled type %u\n", view->type );
750 return E_INVALIDARG;
751 }
752 }
753
754 struct query *create_query( enum wbm_namespace ns )
755 {
756 struct query *query;
757
758 if (!(query = malloc( sizeof(*query) ))) return NULL;
759 list_init( &query->mem );
760 query->ns = ns;
761 query->refs = 1;
762 return query;
763 }
764
765 void free_query( struct query *query )
766 {
767 struct list *mem, *next;
768
769 if (!query) return;
770 destroy_view( query->view );
771 LIST_FOR_EACH_SAFE( mem, next, &query->mem ) { free( mem ); }
772 free( query );
773 }
774
775 struct query *addref_query( struct query *query )
776 {
777 InterlockedIncrement( &query->refs );
778 return query;
779 }
780
781 void release_query( struct query *query )
782 {
783 if (!InterlockedDecrement( &query->refs )) free_query( query );
784 }
785
786 HRESULT exec_query( enum wbm_namespace ns, const WCHAR *str, IEnumWbemClassObject **result )
787 {
788 HRESULT hr;
789 struct query *query;
790
791 *result = NULL;
792 if (!(query = create_query( ns ))) return E_OUTOFMEMORY;
793 hr = parse_query( ns, str, &query->view, &query->mem );
794 if (hr != S_OK) goto done;
795 hr = execute_view( query->view );
796 if (hr != S_OK) goto done;
797 hr = EnumWbemClassObject_create( query, (void **)result );
798
799 done:
800 release_query( query );
801 return hr;
802 }
803
804 BOOL is_result_prop( const struct view *view, const WCHAR *name )
805 {
806 const struct property *prop = view->proplist;
807 if (!prop) return TRUE;
808 while (prop)
809 {
810 if (!wcsicmp( prop->name, name )) return TRUE;
811 prop = prop->next;
812 }
813 return FALSE;
814 }
815
816 static BOOL is_system_prop( const WCHAR *name )
817 {
818 return (name[0] == '_' && name[1] == '_');
819 }
820
821 static BSTR build_proplist( const struct table *table, UINT row, UINT count, UINT *len )
822 {
823 UINT i, j, offset;
824 BSTR *values, ret = NULL;
825
826 if (!(values = malloc( count * sizeof(BSTR) ))) return NULL;
827
828 *len = j = 0;
829 for (i = 0; i < table->num_cols; i++)
830 {
831 if (table->columns[i].type & COL_FLAG_KEY)
832 {
833 const WCHAR *name = table->columns[i].name;
834 values[j] = get_value_bstr( table, row, i );
835 *len += lstrlenW( L"%s=%s" ) + lstrlenW( name ) + lstrlenW( values[j] );
836 j++;
837 }
838 }
839 if ((ret = SysAllocStringLen( NULL, *len )))
840 {
841 offset = j = 0;
842 for (i = 0; i < table->num_cols; i++)
843 {
844 if (table->columns[i].type & COL_FLAG_KEY)
845 {
846 const WCHAR *name = table->columns[i].name;
847 offset += swprintf( ret + offset, *len - offset, L"%s=%s", name, values[j] );
848 if (j < count - 1) ret[offset++] = ',';
849 j++;
850 }
851 }
852 }
853 for (i = 0; i < count; i++) SysFreeString( values[i] );
854 free( values );
855 return ret;
856 }
857
858 static UINT count_key_columns( const struct table *table )
859 {
860 UINT i, num_keys = 0;
861
862 for (i = 0; i < table->num_cols; i++)
863 {
864 if (table->columns[i].type & COL_FLAG_KEY) num_keys++;
865 }
866 return num_keys;
867 }
868
869 static BSTR build_relpath( const struct view *view, UINT table_index, UINT result_index, const WCHAR *name )
870 {
871 BSTR class, proplist, ret = NULL;
872 struct table *table = view->table[table_index];
873 UINT row = view->result[result_index];
874 UINT num_keys, len;
875
876 if (view->proplist) return NULL;
877
878 if (!(class = SysAllocString( view->table[table_index]->name ))) return NULL;
879 if (!(num_keys = count_key_columns( table ))) return class;
880 if (!(proplist = build_proplist( table, row, num_keys, &len ))) goto done;
881
882 len += lstrlenW( L"%s.%s" ) + SysStringLen( class );
883 if (!(ret = SysAllocStringLen( NULL, len ))) goto done;
884 swprintf( ret, len, L"%s.%s", class, proplist );
885
886 done:
887 SysFreeString( class );
888 SysFreeString( proplist );
889 return ret;
890 }
891
892 static BSTR build_path( const struct view *view, UINT table_index, UINT result_index, const WCHAR *name )
893 {
894 BSTR server, namespace = NULL, relpath = NULL, ret = NULL;
895 UINT len;
896
897 if (view->proplist) return NULL;
898
899 if (!(server = build_servername())) return NULL;
900 if (!(namespace = build_namespace())) goto done;
901 if (!(relpath = build_relpath( view, table_index, result_index, name ))) goto done;
902
903 len = lstrlenW( L"\\\\%s\\%s:%s" ) + SysStringLen( server ) + SysStringLen( namespace ) + SysStringLen( relpath );
904 if (!(ret = SysAllocStringLen( NULL, len ))) goto done;
905 swprintf( ret, len, L"\\\\%s\\%s:%s", server, namespace, relpath );
906
907 done:
908 SysFreeString( server );
909 SysFreeString( namespace );
910 SysFreeString( relpath );
911 return ret;
912 }
913
914 BOOL is_method( const struct table *table, UINT column )
915 {
916 return table->columns[column].type & COL_FLAG_METHOD;
917 }
918
919 static UINT count_properties( const struct table *table )
920 {
921 UINT i, num_props = 0;
922
923 for (i = 0; i < table->num_cols; i++)
924 {
925 if (!is_method( table, i )) num_props++;
926 }
927 return num_props;
928 }
929
930 static UINT count_result_properties( const struct view *view, UINT table_index )
931 {
932 const struct property *prop = view->proplist;
933 UINT count;
934
935 if (!prop) return count_properties( view->table[table_index] );
936
937 count = 1;
938 while ((prop = prop->next)) count++;
939 return count;
940 }
941
942 static HRESULT get_system_propval( const struct view *view, UINT table_index, UINT result_index, const WCHAR *name,
943 VARIANT *ret, CIMTYPE *type, LONG *flavor )
944 {
945 if (flavor) *flavor = WBEM_FLAVOR_ORIGIN_SYSTEM;
946
947 if (!wcsicmp( name, L"__CLASS" ))
948 {
949 if (ret)
950 {
951 V_VT( ret ) = VT_BSTR;
952 V_BSTR( ret ) = SysAllocString( view->table[table_index]->name );
953 }
954 if (type) *type = CIM_STRING;
955 return S_OK;
956 }
957 if (!wcsicmp( name, L"__GENUS" ))
958 {
959 if (ret)
960 {
961 V_VT( ret ) = VT_I4;
962 V_I4( ret ) = WBEM_GENUS_INSTANCE; /* FIXME */
963 }
964 if (type) *type = CIM_SINT32;
965 return S_OK;
966 }
967 if (!wcsicmp( name, L"__NAMESPACE" ))
968 {
969 if (ret)
970 {
971 V_VT( ret ) = VT_BSTR;
972 V_BSTR( ret ) = view->proplist ? NULL : build_namespace();
973 if (!V_BSTR( ret )) V_VT( ret ) = VT_NULL;
974 }
975 if (type) *type = CIM_STRING;
976 return S_OK;
977 }
978 if (!wcsicmp( name, L"__PATH" ))
979 {
980 if (ret)
981 {
982 V_VT( ret ) = VT_BSTR;
983 V_BSTR( ret ) = build_path( view, table_index, result_index, name );
984 if (!V_BSTR( ret )) V_VT( ret ) = VT_NULL;
985 }
986 if (type) *type = CIM_STRING;
987 return S_OK;
988 }
989 if (!wcsicmp( name, L"__PROPERTY_COUNT" ))
990 {
991 if (ret)
992 {
993 V_VT( ret ) = VT_I4;
994 V_I4( ret ) = count_result_properties( view, table_index );
995 }
996 if (type) *type = CIM_SINT32;
997 return S_OK;
998 }
999 if (!wcsicmp( name, L"__RELPATH" ))
1000 {
1001 if (ret)
1002 {
1003 V_VT( ret ) = VT_BSTR;
1004 V_BSTR( ret ) = build_relpath( view, table_index, result_index, name );
1005 if (!V_BSTR( ret )) V_VT( ret ) = VT_NULL;
1006 }
1007 if (type) *type = CIM_STRING;
1008 return S_OK;
1009 }
1010 if (!wcsicmp( name, L"__SERVER" ))
1011 {
1012 if (ret)
1013 {
1014 V_VT( ret ) = VT_BSTR;
1015 V_BSTR( ret ) = view->proplist ? NULL : build_servername();
1016 if (!V_BSTR( ret )) V_VT( ret ) = VT_NULL;
1017 }
1018 if (type) *type = CIM_STRING;
1019 return S_OK;
1020 }
1021 if (!wcsicmp( name, L"__DERIVATION" ))
1022 {
1023 if (ret)
1024 {
1025 SAFEARRAY *sa;
1026 FIXME( "returning empty array for __DERIVATION\n" );
1027 if (!(sa = SafeArrayCreateVector( VT_BSTR, 0, 0 ))) return E_OUTOFMEMORY;
1028 V_VT( ret ) = VT_BSTR | VT_ARRAY;
1029 V_ARRAY( ret ) = sa;
1030 }
1031 if (type) *type = CIM_STRING | CIM_FLAG_ARRAY;
1032 return S_OK;
1033 }
1034 FIXME("system property %s not implemented\n", debugstr_w(name));
1035 return WBEM_E_NOT_FOUND;
1036 }
1037
1038 VARTYPE to_vartype( CIMTYPE type )
1039 {
1040 switch (type)
1041 {
1042 case CIM_BOOLEAN: return VT_BOOL;
1043
1044 case CIM_STRING:
1045 case CIM_REFERENCE:
1046 case CIM_DATETIME: return VT_BSTR;
1047
1048 case CIM_SINT8: return VT_I1;
1049 case CIM_UINT8: return VT_UI1;
1050 case CIM_SINT16: return VT_I2;
1051
1052 case CIM_UINT16:
1053 case CIM_SINT32:
1054 case CIM_UINT32: return VT_I4;
1055
1056 case CIM_SINT64: return VT_I8;
1057 case CIM_UINT64: return VT_UI8;
1058
1059 case CIM_REAL32: return VT_R4;
1060
1061 default:
1062 ERR( "unhandled type %lu\n", type );
1063 break;
1064 }
1065 return 0;
1066 }
1067
1068 SAFEARRAY *to_safearray( const struct array *array, CIMTYPE basetype )
1069 {
1070 SAFEARRAY *ret;
1071 VARTYPE vartype = to_vartype( basetype );
1072 LONG i;
1073
1074 if (!array || !(ret = SafeArrayCreateVector( vartype, 0, array->count ))) return NULL;
1075
1076 for (i = 0; i < array->count; i++)
1077 {
1078 void *ptr = (char *)array->ptr + i * array->elem_size;
1079 if (vartype == VT_BSTR)
1080 {
1081 BSTR str = SysAllocString( *(const WCHAR **)ptr );
1082 if (!str || SafeArrayPutElement( ret, &i, str ) != S_OK)
1083 {
1084 SysFreeString( str );
1085 SafeArrayDestroy( ret );
1086 return NULL;
1087 }
1088 SysFreeString( str );
1089 }
1090 else if (SafeArrayPutElement( ret, &i, ptr ) != S_OK)
1091 {
1092 SafeArrayDestroy( ret );
1093 return NULL;
1094 }
1095 }
1096 return ret;
1097 }
1098
1099 void set_variant( VARTYPE type, LONGLONG val, void *val_ptr, VARIANT *ret )
1100 {
1101 if (type & VT_ARRAY)
1102 {
1103 V_VT( ret ) = type;
1104 V_ARRAY( ret ) = val_ptr;
1105 return;
1106 }
1107 switch (type)
1108 {
1109 case VT_BOOL:
1110 V_BOOL( ret ) = val;
1111 break;
1112 case VT_BSTR:
1113 V_BSTR( ret ) = val_ptr;
1114 break;
1115 case VT_I1:
1116 V_I1( ret ) = val;
1117 break;
1118 case VT_UI1:
1119 V_UI1( ret ) = val;
1120 break;
1121 case VT_I2:
1122 V_I2( ret ) = val;
1123 break;
1124 case VT_UI2:
1125 V_UI2( ret ) = val;
1126 break;
1127 case VT_I4:
1128 V_I4( ret ) = val;
1129 break;
1130 case VT_UI4:
1131 V_UI4( ret ) = val;
1132 break;
1133 case VT_NULL:
1134 break;
1135 case VT_R4:
1136 V_R4( ret ) = *(FLOAT *)&val;
1137 break;
1138 default:
1139 ERR("unhandled variant type %u\n", type);
1140 return;
1141 }
1142 V_VT( ret ) = type;
1143 }
1144
1145 static HRESULT map_view_index( const struct view *view, UINT index, UINT *table_index, UINT *result_index )
1146 {
1147 if (!view->table) return WBEM_E_NOT_FOUND;
1148
1149 switch (view->type)
1150 {
1151 case VIEW_TYPE_SELECT:
1152 *table_index = 0;
1153 *result_index = index;
1154 break;
1155
1156 case VIEW_TYPE_ASSOCIATORS:
1157 *table_index = *result_index = index;
1158 break;
1159
1160 default:
1161 ERR( "unhandled view type %u\n", view->type );
1162 return WBEM_E_FAILED;
1163 }
1164 return S_OK;
1165 }
1166
1167 struct table *get_view_table( const struct view *view, UINT index )
1168 {
1169 switch (view->type)
1170 {
1171 case VIEW_TYPE_SELECT:
1172 return view->table[0];
1173
1174 case VIEW_TYPE_ASSOCIATORS:
1175 return view->table[index];
1176
1177 default:
1178 ERR( "unhandled view type %u\n", view->type );
1179 return NULL;
1180 }
1181 }
1182
1183 HRESULT get_propval( const struct view *view, UINT index, const WCHAR *name, VARIANT *ret, CIMTYPE *type,
1184 LONG *flavor )
1185 {
1186 HRESULT hr;
1187 UINT column, row, table_index, result_index;
1188 struct table *table;
1189 VARTYPE vartype;
1190 void *val_ptr = NULL;
1191 LONGLONG val;
1192
1193 if ((hr = map_view_index( view, index, &table_index, &result_index )) != S_OK) return hr;
1194
1195 if (is_system_prop( name )) return get_system_propval( view, table_index, result_index, name, ret, type, flavor );
1196 if (!view->result_count || !is_result_prop( view, name )) return WBEM_E_NOT_FOUND;
1197
1198 table = view->table[table_index];
1199 hr = get_column_index( table, name, &column );
1200 if (hr != S_OK || is_method( table, column )) return WBEM_E_NOT_FOUND;
1201
1202 row = view->result[result_index];
1203 hr = get_value( table, row, column, &val );
1204 if (hr != S_OK) return hr;
1205
1206 if (type) *type = table->columns[column].type & COL_TYPE_MASK;
1207 if (flavor) *flavor = 0;
1208
1209 if (!ret) return S_OK;
1210
1211 vartype = to_vartype( table->columns[column].type & CIM_TYPE_MASK );
1212 if (table->columns[column].type & CIM_FLAG_ARRAY)
1213 {
1214 CIMTYPE basetype = table->columns[column].type & CIM_TYPE_MASK;
1215
1216 val_ptr = to_safearray( (const struct array *)(INT_PTR)val, basetype );
1217 if (!val_ptr) vartype = VT_NULL;
1218 else vartype |= VT_ARRAY;
1219 set_variant( vartype, val, val_ptr, ret );
1220 return S_OK;
1221 }
1222
1223 switch (table->columns[column].type & COL_TYPE_MASK)
1224 {
1225 case CIM_STRING:
1226 case CIM_REFERENCE:
1227 case CIM_DATETIME:
1228 if (val)
1229 {
1230 vartype = VT_BSTR;
1231 val_ptr = SysAllocString( (const WCHAR *)(INT_PTR)val );
1232 }
1233 else
1234 vartype = VT_NULL;
1235 break;
1236 case CIM_SINT64:
1237 vartype = VT_BSTR;
1238 val_ptr = get_value_bstr( table, row, column );
1239 break;
1240 case CIM_UINT64:
1241 vartype = VT_BSTR;
1242 val_ptr = get_value_bstr( table, row, column );
1243 break;
1244 case CIM_BOOLEAN:
1245 case CIM_SINT8:
1246 case CIM_UINT8:
1247 case CIM_SINT16:
1248 case CIM_UINT16:
1249 case CIM_SINT32:
1250 case CIM_UINT32:
1251 case CIM_REAL32:
1252 break;
1253 default:
1254 ERR("unhandled column type %u\n", table->columns[column].type);
1255 return WBEM_E_FAILED;
1256 }
1257
1258 set_variant( vartype, val, val_ptr, ret );
1259 return S_OK;
1260 }
1261
1262 static CIMTYPE to_cimtype( VARTYPE type )
1263 {
1264 switch (type)
1265 {
1266 case VT_BOOL: return CIM_BOOLEAN;
1267 case VT_BSTR: return CIM_STRING;
1268 case VT_I1: return CIM_SINT8;
1269 case VT_UI1: return CIM_UINT8;
1270 case VT_I2: return CIM_SINT16;
1271 case VT_UI2: return CIM_UINT16;
1272 case VT_I4: return CIM_SINT32;
1273 case VT_UI4: return CIM_UINT32;
1274 case VT_I8: return CIM_SINT64;
1275 case VT_UI8: return CIM_UINT64;
1276 default:
1277 ERR("unhandled type %u\n", type);
1278 break;
1279 }
1280 return 0;
1281 }
1282
1283 static struct array *to_array( VARIANT *var, CIMTYPE *type )
1284 {
1285 struct array *ret;
1286 LONG bound, i;
1287 VARTYPE vartype;
1288 CIMTYPE basetype;
1289
1290 if (SafeArrayGetVartype( V_ARRAY( var ), &vartype ) != S_OK) return NULL;
1291 if (!(basetype = to_cimtype( vartype ))) return NULL;
1292 if (SafeArrayGetUBound( V_ARRAY( var ), 1, &bound ) != S_OK) return NULL;
1293 if (!(ret = malloc( sizeof(struct array) ))) return NULL;
1294
1295 ret->count = bound + 1;
1296 ret->elem_size = get_type_size( basetype );
1297 if (!(ret->ptr = calloc( ret->count, ret->elem_size )))
1298 {
1299 free( ret );
1300 return NULL;
1301 }
1302 for (i = 0; i < ret->count; i++)
1303 {
1304 void *ptr = (char *)ret->ptr + i * ret->elem_size;
1305 if (vartype == VT_BSTR)
1306 {
1307 BSTR str;
1308 if (SafeArrayGetElement( V_ARRAY( var ), &i, &str ) != S_OK)
1309 {
1310 destroy_array( ret, basetype );
1311 return NULL;
1312 }
1313 *(WCHAR **)ptr = wcsdup( str );
1314 SysFreeString( str );
1315 if (!*(WCHAR **)ptr)
1316 {
1317 destroy_array( ret, basetype );
1318 return NULL;
1319 }
1320 }
1321 else if (SafeArrayGetElement( V_ARRAY( var ), &i, ptr ) != S_OK)
1322 {
1323 destroy_array( ret, basetype );
1324 return NULL;
1325 }
1326 }
1327 *type = basetype | CIM_FLAG_ARRAY;
1328 return ret;
1329 }
1330
1331 HRESULT to_longlong( VARIANT *var, LONGLONG *val, CIMTYPE *type )
1332 {
1333 if (!var)
1334 {
1335 *val = 0;
1336 return S_OK;
1337 }
1338 if (V_VT( var ) & VT_ARRAY)
1339 {
1340 *val = (INT_PTR)to_array( var, type );
1341 if (!*val) return E_OUTOFMEMORY;
1342 return S_OK;
1343 }
1344 switch (V_VT( var ))
1345 {
1346 case VT_BOOL:
1347 *val = V_BOOL( var );
1348 *type = CIM_BOOLEAN;
1349 break;
1350 case VT_BSTR:
1351 *val = (INT_PTR)wcsdup( V_BSTR( var ) );
1352 if (!*val) return E_OUTOFMEMORY;
1353 *type = CIM_STRING;
1354 break;
1355 case VT_I2:
1356 *val = V_I2( var );
1357 *type = CIM_SINT16;
1358 break;
1359 case VT_UI2:
1360 *val = V_UI2( var );
1361 *type = CIM_UINT16;
1362 break;
1363 case VT_I4:
1364 *val = V_I4( var );
1365 *type = CIM_SINT32;
1366 break;
1367 case VT_UI4:
1368 *val = V_UI4( var );
1369 *type = CIM_UINT32;
1370 break;
1371 case VT_NULL:
1372 *val = 0;
1373 break;
1374 default:
1375 ERR("unhandled type %u\n", V_VT( var ));
1376 return WBEM_E_FAILED;
1377 }
1378 return S_OK;
1379 }
1380
1381 HRESULT put_propval( const struct view *view, UINT index, const WCHAR *name, VARIANT *var, CIMTYPE type )
1382 {
1383 HRESULT hr;
1384 UINT row, column, table_index, result_index;
1385 struct table *table;
1386 LONGLONG val;
1387
1388 if ((hr = map_view_index( view, index, &table_index, &result_index )) != S_OK) return hr;
1389
1390 table = view->table[table_index];
1391 hr = get_column_index( table, name, &column );
1392 if (hr != S_OK)
1393 {
1394 FIXME("no support for creating new properties\n");
1395 return WBEM_E_FAILED;
1396 }
1397 if (is_method( table, column ) || !(table->columns[column].type & COL_FLAG_DYNAMIC))
1398 return WBEM_E_FAILED;
1399
1400 hr = to_longlong( var, &val, &type );
1401 if (hr != S_OK) return hr;
1402
1403 row = view->result[result_index];
1404 return set_value( table, row, column, val, type );
1405 }
1406
1407 HRESULT get_properties( const struct view *view, UINT index, LONG flags, SAFEARRAY **props )
1408 {
1409 static const WCHAR * const system_props[] =
1410 { L"__GENUS", L"__CLASS", L"__RELPATH", L"__PROPERTY_COUNT", L"__DERIVATION", L"__SERVER", L"__NAMESPACE",
1411 L"__PATH" };
1412 SAFEARRAY *sa;
1413 BSTR str;
1414 UINT i, table_index, result_index, count = 0;
1415 struct table *table;
1416 HRESULT hr;
1417 LONG j = 0;
1418
1419 if ((hr = map_view_index( view, index, &table_index, &result_index )) != S_OK) return hr;
1420 table = view->table[table_index];
1421
1422 if (!(flags & WBEM_FLAG_NONSYSTEM_ONLY)) count += ARRAY_SIZE(system_props);
1423 if (!(flags & WBEM_FLAG_SYSTEM_ONLY))
1424 {
1425 for (i = 0; i < table->num_cols; i++)
1426 {
1427 if (!is_method( table, i ) && is_result_prop( view, table->columns[i].name )) count++;
1428 }
1429 }
1430
1431 if (!(sa = SafeArrayCreateVector( VT_BSTR, 0, count ))) return E_OUTOFMEMORY;
1432
1433 if (!(flags & WBEM_FLAG_NONSYSTEM_ONLY))
1434 {
1435 for (j = 0; j < ARRAY_SIZE(system_props); j++)
1436 {
1437 str = SysAllocString( system_props[j] );
1438 if (!str || SafeArrayPutElement( sa, &j, str ) != S_OK)
1439 {
1440 SysFreeString( str );
1441 SafeArrayDestroy( sa );
1442 return E_OUTOFMEMORY;
1443 }
1444 SysFreeString( str );
1445 }
1446 }
1447 if (!(flags & WBEM_FLAG_SYSTEM_ONLY))
1448 {
1449 for (i = 0; i < table->num_cols; i++)
1450 {
1451 if (is_method( table, i ) || !is_result_prop( view, table->columns[i].name )) continue;
1452
1453 str = SysAllocString( table->columns[i].name );
1454 if (!str || SafeArrayPutElement( sa, &j, str ) != S_OK)
1455 {
1456 SysFreeString( str );
1457 SafeArrayDestroy( sa );
1458 return E_OUTOFMEMORY;
1459 }
1460 SysFreeString( str );
1461 j++;
1462 }
1463 }
1464
1465 *props = sa;
1466 return S_OK;
1467 }
Windows API implementation