ReactOS  0.4.14-dev-583-g2a1ba2c
path.c
Go to the documentation of this file.
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 "ole2.h"
26 #include "wbemcli.h"
27 #include "wmiutils.h"
28 
29 #include "wine/debug.h"
30 #include "wmiutils_private.h"
31 
33 
34 struct keylist
35 {
39 };
40 
41 struct key
42 {
44  int len_name;
46  int len_value;
47 };
48 
49 struct path
50 {
55  int len_text;
61  WCHAR *class;
62  int len_class;
63  struct key *keys;
64  unsigned int num_keys;
66 };
67 
68 static inline struct keylist *impl_from_IWbemPathKeyList( IWbemPathKeyList *iface )
69 {
70  return CONTAINING_RECORD(iface, struct keylist, IWbemPathKeyList_iface);
71 }
72 
73 static inline struct path *impl_from_IWbemPath( IWbemPath *iface )
74 {
75  return CONTAINING_RECORD(iface, struct path, IWbemPath_iface);
76 }
77 
79  IWbemPathKeyList *iface )
80 {
81  struct keylist *keylist = impl_from_IWbemPathKeyList( iface );
82  return InterlockedIncrement( &keylist->refs );
83 }
84 
86  IWbemPathKeyList *iface )
87 {
88  struct keylist *keylist = impl_from_IWbemPathKeyList( iface );
90  if (!refs)
91  {
92  TRACE("destroying %p\n", keylist);
93  IWbemPath_Release( keylist->parent );
94  heap_free( keylist );
95  }
96  return refs;
97 }
98 
100  IWbemPathKeyList *iface,
101  REFIID riid,
102  void **ppvObject )
103 {
104  struct keylist *keylist = impl_from_IWbemPathKeyList( iface );
105 
106  TRACE("%p, %s, %p\n", keylist, debugstr_guid(riid), ppvObject);
107 
108  if (IsEqualGUID( riid, &IID_IWbemPathKeyList ) ||
110  {
111  *ppvObject = iface;
112  }
113  else
114  {
115  FIXME("interface %s not implemented\n", debugstr_guid(riid));
116  return E_NOINTERFACE;
117  }
118  IWbemPathKeyList_AddRef( iface );
119  return S_OK;
120 }
121 
123  IWbemPathKeyList *iface,
124  ULONG *puKeyCount )
125 {
126  struct keylist *keylist = impl_from_IWbemPathKeyList( iface );
128 
129  TRACE("%p, %p\n", iface, puKeyCount);
130 
131  if (!puKeyCount) return WBEM_E_INVALID_PARAMETER;
132 
134 
135  *puKeyCount = parent->num_keys;
136 
138  return S_OK;
139 }
140 
142  IWbemPathKeyList *iface,
143  LPCWSTR wszName,
144  ULONG uFlags,
145  ULONG uCimType,
146  LPVOID pKeyVal )
147 {
148  FIXME("%p, %s, 0x%x, %u, %p\n", iface, debugstr_w(wszName), uFlags, uCimType, pKeyVal);
149  return E_NOTIMPL;
150 }
151 
153  IWbemPathKeyList *iface,
154  LPCWSTR wszName,
155  ULONG uFlags,
156  ULONG uCimType,
157  VARIANT *pKeyVal )
158 {
159  FIXME("%p, %s, 0x%x, %u, %p\n", iface, debugstr_w(wszName), uFlags, uCimType, pKeyVal);
160  return E_NOTIMPL;
161 }
162 
164  IWbemPathKeyList *iface,
165  ULONG uKeyIx,
166  ULONG uFlags,
167  ULONG *puNameBufSize,
168  LPWSTR pszKeyName,
169  ULONG *puKeyValBufSize,
170  LPVOID pKeyVal,
171  ULONG *puApparentCimType )
172 {
173  FIXME("%p, %u, 0x%x, %p, %p, %p, %p, %p\n", iface, uKeyIx, uFlags, puNameBufSize,
174  pszKeyName, puKeyValBufSize, pKeyVal, puApparentCimType);
175  return E_NOTIMPL;
176 }
177 
179  IWbemPathKeyList *iface,
180  ULONG uKeyIx,
181  ULONG uFlags,
182  ULONG *puNameBufSize,
183  LPWSTR pszKeyName,
184  VARIANT *pKeyValue,
185  ULONG *puApparentCimType )
186 {
187  FIXME("%p, %u, 0x%x, %p, %p, %p, %p\n", iface, uKeyIx, uFlags, puNameBufSize,
188  pszKeyName, pKeyValue, puApparentCimType);
189  return E_NOTIMPL;
190 }
191 
193  IWbemPathKeyList *iface,
194  LPCWSTR wszName,
195  ULONG uFlags )
196 {
197  FIXME("%p, %s, 0x%x\n", iface, debugstr_w(wszName), uFlags);
198  return E_NOTIMPL;
199 }
200 
201 static void free_keys( struct key *keys, unsigned int count )
202 {
203  unsigned int i;
204 
205  for (i = 0; i < count; i++)
206  {
207  heap_free( keys[i].name );
208  heap_free( keys[i].value );
209  }
210  heap_free( keys );
211 }
212 
214  IWbemPathKeyList *iface,
215  ULONG uFlags )
216 {
217  struct keylist *keylist = impl_from_IWbemPathKeyList( iface );
219 
220  TRACE("%p, 0x%x\n", iface, uFlags);
221 
222  if (uFlags) return WBEM_E_INVALID_PARAMETER;
223 
225 
226  free_keys( parent->keys, parent->num_keys );
227  parent->num_keys = 0;
228  parent->keys = NULL;
229 
231  return S_OK;
232 }
233 
235  IWbemPathKeyList *iface,
236  boolean bSet )
237 {
238  FIXME("%p, %d\n", iface, bSet);
239  return E_NOTIMPL;
240 }
241 
243  IWbemPathKeyList *iface,
244  ULONG uRequestedInfo,
245  ULONGLONG *puResponse )
246 {
247  FIXME("%p, %u, %p\n", iface, uRequestedInfo, puResponse);
248  return E_NOTIMPL;
249 }
250 
252  IWbemPathKeyList *iface,
253  LONG lFlags,
254  ULONG *puBuffLength,
255  LPWSTR pszText )
256 {
257  FIXME("%p, 0x%x, %p, %p\n", iface, lFlags, puBuffLength, pszText);
258  return E_NOTIMPL;
259 }
260 
261 static const struct IWbemPathKeyListVtbl keylist_vtbl =
262 {
276 };
277 
279 {
280  struct keylist *keylist;
281 
282  TRACE("%p\n", ppObj);
283 
284  if (!(keylist = heap_alloc( sizeof(*keylist) ))) return E_OUTOFMEMORY;
285 
287  keylist->refs = 1;
288  keylist->parent = parent;
289  IWbemPath_AddRef( keylist->parent );
290 
291  *ppObj = &keylist->IWbemPathKeyList_iface;
292 
293  TRACE("returning iface %p\n", *ppObj);
294  return S_OK;
295 }
296 
297 static void init_path( struct path *path )
298 {
299  path->text = NULL;
300  path->len_text = 0;
301  path->server = NULL;
302  path->len_server = 0;
303  path->namespaces = NULL;
305  path->num_namespaces = 0;
306  path->class = NULL;
307  path->len_class = 0;
308  path->keys = NULL;
309  path->num_keys = 0;
310  path->flags = 0;
311 }
312 
313 static void clear_path( struct path *path )
314 {
315  unsigned int i;
316 
317  heap_free( path->text );
318  heap_free( path->server );
319  for (i = 0; i < path->num_namespaces; i++) heap_free( path->namespaces[i] );
322  heap_free( path->class );
324  init_path( path );
325 }
326 
328  IWbemPath *iface )
329 {
330  struct path *path = impl_from_IWbemPath( iface );
331  return InterlockedIncrement( &path->refs );
332 }
333 
335  IWbemPath *iface )
336 {
337  struct path *path = impl_from_IWbemPath( iface );
339  if (!refs)
340  {
341  TRACE("destroying %p\n", path);
342  clear_path( path );
343  path->cs.DebugInfo->Spare[0] = 0;
345  heap_free( path );
346  }
347  return refs;
348 }
349 
351  IWbemPath *iface,
352  REFIID riid,
353  void **ppvObject )
354 {
355  struct path *path = impl_from_IWbemPath( iface );
356 
357  TRACE("%p, %s, %p\n", path, debugstr_guid( riid ), ppvObject );
358 
359  if ( IsEqualGUID( riid, &IID_IWbemPath ) ||
361  {
362  *ppvObject = iface;
363  }
364  else
365  {
366  FIXME("interface %s not implemented\n", debugstr_guid(riid));
367  return E_NOINTERFACE;
368  }
369  IWbemPath_AddRef( iface );
370  return S_OK;
371 }
372 
373 static HRESULT parse_key( struct key *key, const WCHAR *str, unsigned int *ret_len )
374 {
375  const WCHAR *p, *q;
376  unsigned int len;
377 
378  p = q = str;
379  while (*q && *q != '=')
380  {
381  if (*q == ',' || iswspace( *q )) return WBEM_E_INVALID_PARAMETER;
382  q++;
383  }
384  len = q - p;
385  if (!(key->name = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return E_OUTOFMEMORY;
386  memcpy( key->name, p, len * sizeof(WCHAR) );
387  key->name[len] = 0;
388  key->len_name = len;
389 
390  p = ++q;
391  if (!*p || *p == ',' || iswspace( *p )) return WBEM_E_INVALID_PARAMETER;
392 
393  while (*q && *q != ',') q++;
394  len = q - p;
395  if (!(key->value = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return E_OUTOFMEMORY;
396  memcpy( key->value, p, len * sizeof(WCHAR) );
397  key->value[len] = 0;
398  key->len_value = len;
399 
400  *ret_len = q - str;
401  if (*q == ',') (*ret_len)++;
402  return S_OK;
403 }
404 
405 static HRESULT parse_text( struct path *path, ULONG mode, const WCHAR *text )
406 {
408  const WCHAR *p, *q;
409  unsigned int i, len;
410 
411  p = q = text;
412  if ((p[0] == '\\' && p[1] == '\\') || (p[0] == '/' && p[1] == '/'))
413  {
414  p += 2;
415  q = p;
416  while (*q && *q != '\\' && *q != '/') q++;
417  len = q - p;
418  if (!(path->server = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto done;
419  memcpy( path->server, p, len * sizeof(WCHAR) );
420  path->server[len] = 0;
421  path->len_server = len;
423  }
424  p = q;
425  if (wcschr( p, '\\' ) || wcschr( p, '/' ))
426  {
427  if (*q != '\\' && *q != '/' && *q != ':')
428  {
429  path->num_namespaces = 1;
430  q++;
431  }
432  while (*q && *q != ':')
433  {
434  if (*q == '\\' || *q == '/') path->num_namespaces++;
435  q++;
436  }
437  }
438  if (path->num_namespaces)
439  {
440  if (!(path->namespaces = heap_alloc( path->num_namespaces * sizeof(WCHAR *) ))) goto done;
441  if (!(path->len_namespaces = heap_alloc( path->num_namespaces * sizeof(int) ))) goto done;
442 
443  i = 0;
444  q = p;
445  if (*q && *q != '\\' && *q != '/' && *q != ':')
446  {
447  p = q;
448  while (*p && *p != '\\' && *p != '/' && *p != ':') p++;
449  len = p - q;
450  if (!(path->namespaces[i] = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto done;
451  memcpy( path->namespaces[i], q, len * sizeof(WCHAR) );
452  path->namespaces[i][len] = 0;
453  path->len_namespaces[i] = len;
454  q = p;
455  i++;
456  }
457  while (*q && *q != ':')
458  {
459  if (*q == '\\' || *q == '/')
460  {
461  p = q + 1;
462  while (*p && *p != '\\' && *p != '/' && *p != ':') p++;
463  len = p - q - 1;
464  if (!(path->namespaces[i] = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto done;
465  memcpy( path->namespaces[i], q + 1, len * sizeof(WCHAR) );
466  path->namespaces[i][len] = 0;
467  path->len_namespaces[i] = len;
468  i++;
469  }
470  q++;
471  }
472  }
473  if (*q == ':') q++;
474  p = q;
475  while (*q && *q != '.') q++;
476  len = q - p;
477  if (!(path->class = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto done;
478  memcpy( path->class, p, len * sizeof(WCHAR) );
479  path->class[len] = 0;
480  path->len_class = len;
481 
482  if (*q == '.')
483  {
484  p = ++q;
485  path->num_keys++;
486  while (*q)
487  {
488  if (*q == ',') path->num_keys++;
489  q++;
490  }
491  if (!(path->keys = heap_alloc_zero( path->num_keys * sizeof(struct key) ))) goto done;
492  i = 0;
493  q = p;
494  while (*q)
495  {
496  if (i >= path->num_keys) break;
497  hr = parse_key( &path->keys[i], q, &len );
498  if (hr != S_OK) goto done;
499  q += len;
500  i++;
501  }
502  }
503  hr = S_OK;
504 
505 done:
506  if (hr != S_OK) clear_path( path );
508  return hr;
509 }
510 
512  IWbemPath *iface,
513  ULONG uMode,
514  LPCWSTR pszPath)
515 {
516  struct path *path = impl_from_IWbemPath( iface );
517  HRESULT hr = S_OK;
518  int len;
519 
520  TRACE("%p, %u, %s\n", iface, uMode, debugstr_w(pszPath));
521 
522  if (!uMode || !pszPath) return WBEM_E_INVALID_PARAMETER;
523 
525 
526  clear_path( path );
527  if (!pszPath[0]) goto done;
528  if ((hr = parse_text( path, uMode, pszPath )) != S_OK) goto done;
529 
530  len = lstrlenW( pszPath );
531  if (!(path->text = heap_alloc( (len + 1) * sizeof(WCHAR) )))
532  {
533  clear_path( path );
534  hr = E_OUTOFMEMORY;
535  goto done;
536  }
537  lstrcpyW( path->text, pszPath );
538  path->len_text = len;
539 
540 done:
542  return hr;
543 }
544 
545 static WCHAR *build_namespace( struct path *path, int *len, BOOL leading_slash )
546 {
547  WCHAR *ret, *p;
548  int i;
549 
550  *len = 0;
551  for (i = 0; i < path->num_namespaces; i++)
552  {
553  if (i > 0 || leading_slash) *len += 1;
554  *len += path->len_namespaces[i];
555  }
556  if (!(p = ret = heap_alloc( (*len + 1) * sizeof(WCHAR) ))) return NULL;
557  for (i = 0; i < path->num_namespaces; i++)
558  {
559  if (i > 0 || leading_slash) *p++ = '\\';
560  memcpy( p, path->namespaces[i], path->len_namespaces[i] * sizeof(WCHAR) );
561  p += path->len_namespaces[i];
562  }
563  *p = 0;
564  return ret;
565 }
566 
567 static WCHAR *build_server( struct path *path, int *len )
568 {
569  WCHAR *ret, *p;
570 
571  *len = 0;
572  if (path->len_server) *len += 2 + path->len_server;
573  else *len += 3;
574  if (!(p = ret = heap_alloc( (*len + 1) * sizeof(WCHAR) ))) return NULL;
575  if (path->len_server)
576  {
577  p[0] = p[1] = '\\';
578  lstrcpyW( p + 2, path->server );
579  }
580  else
581  {
582  p[0] = p[1] = '\\';
583  p[2] = '.';
584  p[3] = 0;
585  }
586  return ret;
587 }
588 
589 static WCHAR *build_keylist( struct path *path, int *len )
590 {
591  WCHAR *ret, *p;
592  unsigned int i;
593 
594  *len = 0;
595  for (i = 0; i < path->num_keys; i++)
596  {
597  if (i > 0) *len += 1;
598  *len += path->keys[i].len_name + path->keys[i].len_value + 1;
599  }
600  if (!(p = ret = heap_alloc( (*len + 1) * sizeof(WCHAR) ))) return NULL;
601  for (i = 0; i < path->num_keys; i++)
602  {
603  if (i > 0) *p++ = ',';
604  memcpy( p, path->keys[i].name, path->keys[i].len_name * sizeof(WCHAR) );
605  p += path->keys[i].len_name;
606  *p++ = '=';
607  memcpy( p, path->keys[i].value, path->keys[i].len_value * sizeof(WCHAR) );
608  p += path->keys[i].len_value;
609  }
610  *p = 0;
611  return ret;
612 }
613 
614 static WCHAR *build_path( struct path *path, LONG flags, int *len )
615 {
616  *len = 0;
617  switch (flags)
618  {
619  case 0:
620  {
621  int len_namespace, len_keylist;
622  WCHAR *ret, *namespace = build_namespace( path, &len_namespace, FALSE );
623  WCHAR *keylist = build_keylist( path, &len_keylist );
624 
625  if (!namespace || !keylist)
626  {
627  heap_free( namespace );
628  heap_free( keylist );
629  return NULL;
630  }
631  *len = len_namespace;
632  if (path->len_class)
633  {
634  *len += path->len_class + 1;
635  if (path->num_keys) *len += len_keylist + 1;
636  }
637  if (!(ret = heap_alloc( (*len + 1) * sizeof(WCHAR) )))
638  {
639  heap_free( namespace );
640  heap_free( keylist );
641  return NULL;
642  }
643  lstrcpyW( ret, namespace );
644  if (path->len_class)
645  {
646  ret[len_namespace] = ':';
647  lstrcpyW( ret + len_namespace + 1, path->class );
648  if (path->num_keys)
649  {
650  ret[len_namespace + path->len_class + 1] = '.';
651  lstrcpyW( ret + len_namespace + path->len_class + 2, keylist );
652  }
653  }
654  heap_free( namespace );
655  heap_free( keylist );
656  return ret;
657 
658  }
660  {
661  int len_keylist;
662  WCHAR *ret, *keylist;
663 
664  if (!path->len_class) return NULL;
665  if (!(keylist = build_keylist( path, &len_keylist ))) return NULL;
666 
667  *len = path->len_class;
668  if (path->num_keys) *len += len_keylist + 1;
669  if (!(ret = heap_alloc( (*len + 1) * sizeof(WCHAR) )))
670  {
671  heap_free( keylist );
672  return NULL;
673  }
674  lstrcpyW( ret, path->class );
675  if (path->num_keys)
676  {
677  ret[path->len_class] = '.';
678  lstrcpyW( ret + path->len_class + 1, keylist );
679  }
680  heap_free( keylist );
681  return ret;
682  }
684  {
685  int len_namespace, len_server, len_keylist;
686  WCHAR *p, *ret, *namespace = build_namespace( path, &len_namespace, TRUE );
687  WCHAR *server = build_server( path, &len_server );
688  WCHAR *keylist = build_keylist( path, &len_keylist );
689 
690  if (!namespace || !server || !keylist)
691  {
692  heap_free( namespace );
693  heap_free( server );
694  heap_free( keylist );
695  return NULL;
696  }
697  *len = len_namespace + len_server;
698  if (path->len_class)
699  {
700  *len += path->len_class + 1;
701  if (path->num_keys) *len += len_keylist + 1;
702  }
703  if (!(p = ret = heap_alloc( (*len + 1) * sizeof(WCHAR) )))
704  {
705  heap_free( namespace );
706  heap_free( server );
707  heap_free( keylist );
708  return NULL;
709  }
710  lstrcpyW( p, server );
711  p += len_server;
712  lstrcpyW( p, namespace );
713  p += len_namespace;
714  if (path->len_class)
715  {
716  *p++ = ':';
717  lstrcpyW( p, path->class );
718  if (path->num_keys)
719  {
720  p[path->len_class] = '.';
721  lstrcpyW( p + path->len_class + 1, keylist );
722  }
723  }
724  heap_free( namespace );
725  heap_free( server );
726  heap_free( keylist );
727  return ret;
728  }
730  {
731  int len_namespace, len_server;
732  WCHAR *p, *ret, *namespace = build_namespace( path, &len_namespace, TRUE );
733  WCHAR *server = build_server( path, &len_server );
734 
735  if (!namespace || !server)
736  {
737  heap_free( namespace );
738  heap_free( server );
739  return NULL;
740  }
741  *len = len_namespace + len_server;
742  if (!(p = ret = heap_alloc( (*len + 1) * sizeof(WCHAR) )))
743  {
744  heap_free( namespace );
745  heap_free( server );
746  return NULL;
747  }
748  lstrcpyW( p, server );
749  p += len_server;
750  lstrcpyW( p, namespace );
751  heap_free( namespace );
752  heap_free( server );
753  return ret;
754  }
756  return build_namespace( path, len, FALSE );
757 
759  if (!path->len_text) return NULL;
760  *len = path->len_text;
761  return strdupW( path->text );
762 
763  default:
764  ERR("unhandled flags 0x%x\n", flags);
765  return NULL;
766  }
767 }
768 
770  IWbemPath *iface,
771  LONG lFlags,
772  ULONG *puBufferLength,
773  LPWSTR pszText)
774 {
775  struct path *path = impl_from_IWbemPath( iface );
776  HRESULT hr = S_OK;
777  WCHAR *str;
778  int len;
779 
780  TRACE("%p, 0x%x, %p, %p\n", iface, lFlags, puBufferLength, pszText);
781 
782  if (!puBufferLength) return WBEM_E_INVALID_PARAMETER;
783 
785 
786  str = build_path( path, lFlags, &len );
787  if (*puBufferLength < len + 1)
788  {
789  *puBufferLength = len + 1;
790  goto done;
791  }
792  if (!pszText)
793  {
795  goto done;
796  }
797  if (str) lstrcpyW( pszText, str );
798  else pszText[0] = 0;
799  *puBufferLength = len + 1;
800 
801  TRACE("returning %s\n", debugstr_w(pszText));
802 
803 done:
804  heap_free( str );
806  return hr;
807 }
808 
810  IWbemPath *iface,
811  ULONG info,
812  ULONGLONG *response)
813 {
814  struct path *path = impl_from_IWbemPath( iface );
815 
816  TRACE("%p, %u, %p\n", iface, info, response);
817 
818  if (info || !response) return WBEM_E_INVALID_PARAMETER;
819 
820  FIXME("some flags are not implemented\n");
821 
823 
824  *response = path->flags;
825  if (!path->server || (path->len_server == 1 && path->server[0] == '.'))
827  else
828  *response |= WBEMPATH_INFO_HAS_MACHINE_NAME;
829 
830  if (!path->class)
832  else
833  {
834  *response |= WBEMPATH_INFO_HAS_SUBSCOPES;
835  if (path->num_keys)
836  *response |= WBEMPATH_INFO_IS_INST_REF;
837  else
838  *response |= WBEMPATH_INFO_IS_CLASS_REF;
839  }
840 
842  return S_OK;
843 }
844 
846  IWbemPath *iface,
847  LPCWSTR name)
848 {
849  struct path *path = impl_from_IWbemPath( iface );
850  static const ULONGLONG flags =
853  WCHAR *server;
854 
855  TRACE("%p, %s\n", iface, debugstr_w(name));
856 
858 
859  if (name)
860  {
861  if (!(server = strdupW( name )))
862  {
864  return WBEM_E_OUT_OF_MEMORY;
865  }
866  heap_free( path->server );
867  path->server = server;
869  path->flags |= flags;
870  }
871  else
872  {
873  heap_free( path->server );
874  path->server = NULL;
875  path->len_server = 0;
876  path->flags &= ~flags;
877  }
878 
880  return S_OK;
881 }
882 
884  IWbemPath *iface,
885  ULONG *len,
886  LPWSTR name)
887 {
888  struct path *path = impl_from_IWbemPath( iface );
889 
890  TRACE("%p, %p, %p\n", iface, len, name);
891 
892  if (!len || (*len && !name)) return WBEM_E_INVALID_PARAMETER;
893 
895 
896  if (!path->server)
897  {
899  return WBEM_E_NOT_AVAILABLE;
900  }
901  if (*len > path->len_server) lstrcpyW( name, path->server );
902  *len = path->len_server + 1;
903 
905  return S_OK;
906 }
907 
909  IWbemPath *iface,
910  ULONG *puCount)
911 {
912  struct path *path = impl_from_IWbemPath( iface );
913 
914  TRACE("%p, %p\n", iface, puCount);
915 
916  if (!puCount) return WBEM_E_INVALID_PARAMETER;
917 
919  *puCount = path->num_namespaces;
921  return S_OK;
922 }
923 
925  IWbemPath *iface,
926  ULONG idx,
927  LPCWSTR name)
928 {
929  struct path *path = impl_from_IWbemPath( iface );
930  static const ULONGLONG flags =
933  int i, *tmp_len;
934  WCHAR **tmp, *new;
935  DWORD size;
936 
937  TRACE("%p, %u, %s\n", iface, idx, debugstr_w(name));
938 
940 
941  if (idx > path->num_namespaces || !name)
942  {
945  }
946  if (!(new = strdupW( name )))
947  {
949  return WBEM_E_OUT_OF_MEMORY;
950  }
951  size = (path->num_namespaces + 1) * sizeof(WCHAR *);
952  if (path->namespaces) tmp = heap_realloc( path->namespaces, size );
953  else tmp = heap_alloc( size );
954  if (!tmp)
955  {
956  heap_free( new );
958  return WBEM_E_OUT_OF_MEMORY;
959  }
960  path->namespaces = tmp;
961  size = (path->num_namespaces + 1) * sizeof(int);
963  else tmp_len = heap_alloc( size );
964  if (!tmp_len)
965  {
966  heap_free( new );
968  return WBEM_E_OUT_OF_MEMORY;
969  }
970  path->len_namespaces = tmp_len;
971  for (i = idx; i < path->num_namespaces; i++)
972  {
973  path->namespaces[i + 1] = path->namespaces[i];
975  }
976  path->namespaces[idx] = new;
977  path->len_namespaces[idx] = lstrlenW( new );
978  path->num_namespaces++;
979  path->flags |= flags;
980 
982  return S_OK;
983 }
984 
986  IWbemPath *iface,
987  ULONG idx,
988  ULONG *len,
989  LPWSTR name)
990 {
991  struct path *path = impl_from_IWbemPath( iface );
992 
993  TRACE("%p, %u, %p, %p\n", iface, idx, len, name);
994 
996 
997  if (!len || (*len && !name) || idx >= path->num_namespaces)
998  {
1000  return WBEM_E_INVALID_PARAMETER;
1001  }
1003  *len = path->len_namespaces[idx] + 1;
1004 
1006  return S_OK;
1007 }
1008 
1010  IWbemPath *iface,
1011  ULONG idx)
1012 {
1013  struct path *path = impl_from_IWbemPath( iface );
1014 
1015  TRACE("%p, %u\n", iface, idx);
1016 
1018 
1019  if (idx >= path->num_namespaces)
1020  {
1022  return WBEM_E_INVALID_PARAMETER;
1023  }
1025  while (idx < path->num_namespaces - 1)
1026  {
1027  path->namespaces[idx] = path->namespaces[idx + 1];
1029  idx++;
1030  }
1031  path->num_namespaces--;
1032 
1034  return S_OK;
1035 }
1036 
1038  IWbemPath *iface)
1039 {
1040  struct path *path = impl_from_IWbemPath( iface );
1041  int i;
1042 
1043  TRACE("%p\n", iface);
1044 
1046 
1047  for (i = 0; i < path->num_namespaces; i++) heap_free( path->namespaces[i] );
1048  path->num_namespaces = 0;
1050  path->namespaces = NULL;
1053 
1055  return S_OK;
1056 }
1057 
1059  IWbemPath *iface,
1060  ULONG *puCount)
1061 {
1062  FIXME("%p, %p\n", iface, puCount);
1063  return E_NOTIMPL;
1064 }
1065 
1067  IWbemPath *iface,
1068  ULONG uIndex,
1069  LPWSTR pszClass)
1070 {
1071  FIXME("%p, %u, %s\n", iface, uIndex, debugstr_w(pszClass));
1072  return E_NOTIMPL;
1073 }
1074 
1076  IWbemPath *iface,
1077  ULONG uIndex,
1078  LPWSTR pszText)
1079 {
1080  FIXME("%p, %u, %s\n", iface, uIndex, debugstr_w(pszText));
1081  return E_NOTIMPL;
1082 }
1083 
1085  IWbemPath *iface,
1086  ULONG uIndex,
1087  ULONG *puClassNameBufSize,
1088  LPWSTR pszClass,
1089  IWbemPathKeyList **pKeyList)
1090 {
1091  FIXME("%p, %u, %p, %p, %p\n", iface, uIndex, puClassNameBufSize, pszClass, pKeyList);
1092  return E_NOTIMPL;
1093 }
1094 
1096  IWbemPath *iface,
1097  ULONG uIndex,
1098  ULONG *puTextBufSize,
1099  LPWSTR pszText)
1100 {
1101  FIXME("%p, %u, %p, %p\n", iface, uIndex, puTextBufSize, pszText);
1102  return E_NOTIMPL;
1103 }
1104 
1106  IWbemPath *iface,
1107  ULONG uIndex)
1108 {
1109  FIXME("%p, %u\n", iface, uIndex);
1110  return E_NOTIMPL;
1111 }
1112 
1114  IWbemPath *iface)
1115 {
1116  FIXME("%p\n", iface);
1117  return E_NOTIMPL;
1118 }
1119 
1121  IWbemPath *iface,
1122  LPCWSTR name)
1123 {
1124  struct path *path = impl_from_IWbemPath( iface );
1125  WCHAR *class;
1126 
1127  TRACE("%p, %s\n", iface, debugstr_w(name));
1128 
1129  if (!name) return WBEM_E_INVALID_PARAMETER;
1130  if (!(class = strdupW( name ))) return WBEM_E_OUT_OF_MEMORY;
1131 
1133 
1134  heap_free( path->class );
1135  path->class = class;
1136  path->len_class = lstrlenW( path->class );
1138 
1140  return S_OK;
1141 }
1142 
1144  IWbemPath *iface,
1145  ULONG *len,
1146  LPWSTR name)
1147 {
1148  struct path *path = impl_from_IWbemPath( iface );
1149 
1150  TRACE("%p, %p, %p\n", iface, len, name);
1151 
1152  if (!len || (*len && !name)) return WBEM_E_INVALID_PARAMETER;
1153 
1155 
1156  if (!path->class)
1157  {
1160  }
1161  if (*len > path->len_class) lstrcpyW( name, path->class );
1162  *len = path->len_class + 1;
1163 
1165  return S_OK;
1166 }
1167 
1169  IWbemPath *iface,
1170  IWbemPathKeyList **pOut)
1171 {
1172  struct path *path = impl_from_IWbemPath( iface );
1173  HRESULT hr;
1174 
1175  TRACE("%p, %p\n", iface, pOut);
1176 
1178 
1179  if (!path->class)
1180  {
1182  return WBEM_E_INVALID_PARAMETER;
1183  }
1184  hr = WbemPathKeyList_create( iface, (void **)pOut );
1185 
1187  return hr;
1188 }
1189 
1191  IWbemPath *iface,
1192  LONG lFlags,
1193  LPCWSTR Name)
1194 {
1195  FIXME("%p, 0x%x, %s\n", iface, lFlags, debugstr_w(Name));
1196  return E_NOTIMPL;
1197 }
1198 
1200  IWbemPath *iface,
1201  LONG lFlags)
1202 {
1203  FIXME("%p, 0x%x\n", iface, lFlags);
1204  return E_NOTIMPL;
1205 }
1206 
1208  IWbemPath *iface,
1209  LPWSTR wszMachine,
1210  LPWSTR wszNamespace)
1211 {
1212  FIXME("%p, %s, %s\n", iface, debugstr_w(wszMachine), debugstr_w(wszNamespace));
1213  return FALSE;
1214 }
1215 
1217  IWbemPath *iface,
1218  LPWSTR wszMachine,
1219  LPWSTR wszNamespace,
1220  LONG lFlags)
1221 {
1222  FIXME("%p, %s, %s, 0x%x\n", iface, debugstr_w(wszMachine), debugstr_w(wszNamespace), lFlags);
1223  return FALSE;
1224 }
1225 
1227  IWbemPath *iface,
1228  LPCWSTR wszMachine)
1229 {
1230  FIXME("%p, %s\n", iface, debugstr_w(wszMachine));
1231  return FALSE;
1232 }
1233 
1235  IWbemPath *iface,
1236  LPCWSTR wszClass)
1237 {
1238  FIXME("%p, %s\n", iface, debugstr_w(wszClass));
1239  return FALSE;
1240 }
1241 
1242 static const struct IWbemPathVtbl path_vtbl =
1243 {
1245  path_AddRef,
1246  path_Release,
1247  path_SetText,
1248  path_GetText,
1249  path_GetInfo,
1258  path_SetScope,
1260  path_GetScope,
1271  path_IsLocal,
1273 };
1274 
1276 {
1277  struct path *path;
1278 
1279  TRACE("%p\n", ppObj);
1280 
1281  if (!(path = heap_alloc( sizeof(*path) ))) return E_OUTOFMEMORY;
1282 
1283  path->IWbemPath_iface.lpVtbl = &path_vtbl;
1284  path->refs = 1;
1286  path->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": wmiutils_path.cs");
1287  init_path( path );
1288 
1289  *ppObj = &path->IWbemPath_iface;
1290 
1291  TRACE("returning iface %p\n", *ppObj);
1292  return S_OK;
1293 }
WCHAR ** namespaces
Definition: path.c:58
static BOOL WINAPI path_IsRelative(IWbemPath *iface, LPWSTR wszMachine, LPWSTR wszNamespace)
Definition: path.c:1207
static HRESULT WINAPI path_GetNamespaceAt(IWbemPath *iface, ULONG idx, ULONG *len, LPWSTR name)
Definition: path.c:985
#define REFIID
Definition: guiddef.h:118
#define TRUE
Definition: types.h:120
static HRESULT WINAPI path_RemoveNamespaceAt(IWbemPath *iface, ULONG idx)
Definition: path.c:1009
#define E_NOINTERFACE
Definition: winerror.h:2364
static WCHAR * build_keylist(struct path *path, int *len)
Definition: path.c:589
static rfbScreenInfoPtr server
Definition: vnc.c:74
int len_server
Definition: path.c:57
#define DWORD_PTR
Definition: treelist.c:76
HRESULT hr
Definition: shlfolder.c:183
static HRESULT WINAPI keylist_GetKey(IWbemPathKeyList *iface, ULONG uKeyIx, ULONG uFlags, ULONG *puNameBufSize, LPWSTR pszKeyName, ULONG *puKeyValBufSize, LPVOID pKeyVal, ULONG *puApparentCimType)
Definition: path.c:163
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
WCHAR * name
Definition: path.c:43
IWbemPath * parent
Definition: path.c:37
static HRESULT WINAPI keylist_GetText(IWbemPathKeyList *iface, LONG lFlags, ULONG *puBuffLength, LPWSTR pszText)
Definition: path.c:251
static ULONG WINAPI keylist_Release(IWbemPathKeyList *iface)
Definition: path.c:85
static WCHAR * strdupW(const WCHAR *src)
Definition: main.c:92
REFIID riid
Definition: precomp.h:44
static HRESULT WbemPathKeyList_create(IWbemPath *parent, LPVOID *ppObj)
Definition: path.c:278
const WCHAR * text
Definition: package.c:1827
GLuint GLuint GLsizei count
Definition: gl.h:1545
int num_namespaces
Definition: path.c:60
static HRESULT WINAPI keylist_QueryInterface(IWbemPathKeyList *iface, REFIID riid, void **ppvObject)
Definition: path.c:99
static HRESULT WINAPI path_GetText(IWbemPath *iface, LONG lFlags, ULONG *puBufferLength, LPWSTR pszText)
Definition: path.c:769
LONG refs
Definition: path.c:52
static BOOL WINAPI path_IsLocal(IWbemPath *iface, LPCWSTR wszMachine)
Definition: path.c:1226
static HRESULT WINAPI path_SetScopeFromText(IWbemPath *iface, ULONG uIndex, LPWSTR pszText)
Definition: path.c:1075
UINT uFlags
Definition: api.c:59
static HRESULT WINAPI path_GetServer(IWbemPath *iface, ULONG *len, LPWSTR name)
Definition: path.c:883
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
static HRESULT parse_key(struct key *key, const WCHAR *str, unsigned int *ret_len)
Definition: path.c:373
#define lstrlenW
Definition: compat.h:415
static void * heap_realloc(void *mem, size_t len)
Definition: appwiz.h:70
DWORD ret
Definition: path.c:47
static void * heap_alloc(size_t len)
Definition: appwiz.h:65
static HRESULT parse_text(struct path *path, ULONG mode, const WCHAR *text)
Definition: path.c:405
static HRESULT WINAPI path_GetKeyList(IWbemPath *iface, IWbemPathKeyList **pOut)
Definition: path.c:1168
static HRESULT WINAPI path_SetClassName(IWbemPath *iface, LPCWSTR name)
Definition: path.c:1120
static HRESULT WINAPI path_GetInfo(IWbemPath *iface, ULONG info, ULONGLONG *response)
Definition: path.c:809
static HRESULT WINAPI path_SetText(IWbemPath *iface, ULONG uMode, LPCWSTR pszPath)
Definition: path.c:511
static HRESULT WINAPI keylist_GetInfo(IWbemPathKeyList *iface, ULONG uRequestedInfo, ULONGLONG *puResponse)
Definition: path.c:242
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
int * len_namespaces
Definition: path.c:59
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
static const struct IWbemPathKeyListVtbl keylist_vtbl
Definition: path.c:261
#define debugstr_w
Definition: kernel32.h:32
#define FIXME(fmt,...)
Definition: debug.h:110
unsigned int idx
Definition: utils.c:41
static void free_keys(struct key *keys, unsigned int count)
Definition: path.c:201
const WCHAR * str
static HRESULT WINAPI keylist_RemoveAllKeys(IWbemPathKeyList *iface, ULONG uFlags)
Definition: path.c:213
WCHAR * value
Definition: path.c:45
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
smooth NULL
Definition: ftsmooth.c:416
static HRESULT WINAPI path_QueryInterface(IWbemPath *iface, REFIID riid, void **ppvObject)
Definition: path.c:350
#define debugstr_guid
Definition: kernel32.h:35
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
static struct path * impl_from_IWbemPath(IWbemPath *iface)
Definition: path.c:73
const char * path
Definition: path.c:46
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
CRITICAL_SECTION cs
Definition: path.c:53
static HRESULT WINAPI path_GetScope(IWbemPath *iface, ULONG uIndex, ULONG *puClassNameBufSize, LPWSTR pszClass, IWbemPathKeyList **pKeyList)
Definition: path.c:1084
static HRESULT WINAPI keylist_RemoveKey(IWbemPathKeyList *iface, LPCWSTR wszName, ULONG uFlags)
Definition: path.c:192
WCHAR * class
_CONST_RETURN wchar_t *__cdecl wcschr(_In_z_ const wchar_t *_Str, wchar_t _Ch)
r parent
Definition: btrfs.c:2869
__wchar_t WCHAR
Definition: xmlstorage.h:180
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
static WCHAR * build_path(struct path *path, LONG flags, int *len)
Definition: path.c:614
static ULONG WINAPI path_AddRef(IWbemPath *iface)
Definition: path.c:327
LONG HRESULT
Definition: typedefs.h:77
uint64_t ULONGLONG
Definition: typedefs.h:65
int len_class
Definition: path.c:62
const GUID IID_IUnknown
static HRESULT WINAPI path_SetServer(IWbemPath *iface, LPCWSTR name)
Definition: path.c:845
#define WINAPI
Definition: msvc.h:6
static HRESULT WINAPI path_RemoveScope(IWbemPath *iface, ULONG uIndex)
Definition: path.c:1105
static struct keylist * impl_from_IWbemPathKeyList(IWbemPathKeyList *iface)
Definition: path.c:68
ULONGLONG flags
Definition: path.c:65
unsigned long DWORD
Definition: ntddk_ex.h:95
WCHAR * server
Definition: path.c:56
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
static WCHAR * build_namespace(struct path *path, int *len, BOOL leading_slash)
Definition: path.c:545
static HRESULT WINAPI path_GetScopeAsText(IWbemPath *iface, ULONG uIndex, ULONG *puTextBufSize, LPWSTR pszText)
Definition: path.c:1095
static JOBOBJECTINFOCLASS LPVOID DWORD LPDWORD ret_len
Definition: process.c:79
static HRESULT WINAPI keylist_MakeSingleton(IWbemPathKeyList *iface, boolean bSet)
Definition: path.c:234
PCRITICAL_SECTION_DEBUG DebugInfo
Definition: winbase.h:866
GLbitfield flags
Definition: glext.h:7161
LONG refs
Definition: path.c:38
static WCHAR * build_server(struct path *path, int *len)
Definition: path.c:567
#define iswspace(_c)
Definition: ctype.h:669
#define InterlockedDecrement
Definition: armddk.h:52
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
static HRESULT WINAPI path_GetClassName(IWbemPath *iface, ULONG *len, LPWSTR name)
Definition: path.c:1143
static HRESULT WINAPI path_RemoveAllScopes(IWbemPath *iface)
Definition: path.c:1113
REFIID LPVOID * ppvObject
Definition: precomp.h:44
GLenum mode
Definition: glext.h:6217
WINE_DEFAULT_DEBUG_CHANNEL(dbghelp)
static HRESULT WINAPI keylist_SetKey(IWbemPathKeyList *iface, LPCWSTR wszName, ULONG uFlags, ULONG uCimType, LPVOID pKeyVal)
Definition: path.c:141
#define ERR(fmt,...)
Definition: debug.h:109
WCHAR * text
Definition: path.c:54
static ULONG WINAPI keylist_AddRef(IWbemPathKeyList *iface)
Definition: path.c:78
static HRESULT WINAPI path_GetNamespaceCount(IWbemPath *iface, ULONG *puCount)
Definition: path.c:908
static HRESULT WINAPI path_DeleteClassPart(IWbemPath *iface, LONG lFlags)
Definition: path.c:1199
#define S_OK
Definition: intsafe.h:59
#define InterlockedIncrement
Definition: armddk.h:53
#define lstrcpyW
Definition: compat.h:414
unsigned int num_keys
Definition: path.c:64
static HRESULT WINAPI keylist_GetKey2(IWbemPathKeyList *iface, ULONG uKeyIx, ULONG uFlags, ULONG *puNameBufSize, LPWSTR pszKeyName, VARIANT *pKeyValue, ULONG *puApparentCimType)
Definition: path.c:178
static HRESULT WINAPI path_CreateClassPart(IWbemPath *iface, LONG lFlags, LPCWSTR Name)
Definition: path.c:1190
#define E_NOTIMPL
Definition: ddrawi.h:99
static BOOL WINAPI path_IsSameClassName(IWbemPath *iface, LPCWSTR wszClass)
Definition: path.c:1234
struct key * keys
Definition: path.c:63
static HRESULT WINAPI path_SetScope(IWbemPath *iface, ULONG uIndex, LPWSTR pszClass)
Definition: path.c:1066
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:4112
int len_text
Definition: path.c:55
static void init_path(struct path *path)
Definition: path.c:297
Definition: name.c:38
static ULONG WINAPI path_Release(IWbemPath *iface)
Definition: path.c:334
int len_name
Definition: path.c:44
static HRESULT WINAPI path_SetNamespaceAt(IWbemPath *iface, ULONG idx, LPCWSTR name)
Definition: path.c:924
unsigned int ULONG
Definition: retypes.h:1
IWbemPath IWbemPath_iface
Definition: path.c:51
static HRESULT WINAPI path_RemoveAllNamespaces(IWbemPath *iface)
Definition: path.c:1037
int len_value
Definition: path.c:46
static BOOL WINAPI path_IsRelativeOrChild(IWbemPath *iface, LPWSTR wszMachine, LPWSTR wszNamespace, LONG lFlags)
Definition: path.c:1216
static void clear_path(struct path *path)
Definition: path.c:313
static HRESULT WINAPI keylist_SetKey2(IWbemPathKeyList *iface, LPCWSTR wszName, ULONG uFlags, ULONG uCimType, VARIANT *pKeyVal)
Definition: path.c:152
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
GLfloat GLfloat p
Definition: glext.h:8902
WCHAR * LPWSTR
Definition: xmlstorage.h:184
static const struct IWbemPathVtbl path_vtbl
Definition: path.c:1242
static HRESULT WINAPI keylist_GetCount(IWbemPathKeyList *iface, ULONG *puKeyCount)
Definition: path.c:122
HRESULT WbemPath_create(LPVOID *ppObj)
Definition: path.c:1275
static HRESULT WINAPI path_GetScopeCount(IWbemPath *iface, ULONG *puCount)
Definition: path.c:1058
Definition: path.c:34
DWORD_PTR Spare[8/sizeof(DWORD_PTR)]
Definition: winbase.h:859
IWbemPathKeyList IWbemPathKeyList_iface
Definition: path.c:36
Definition: path.c:41
static BOOL heap_free(void *mem)
Definition: appwiz.h:75