2 * Copyright 2012 Hans Leidekker for CodeWeavers
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 #define NONAMELESSUNION
21 #define NONAMELESSSTRUCT
27 #define WIN32_NO_STATUS
42 #include "wine/debug.h"
43 #include "wbemprox_private.h"
45 WINE_DEFAULT_DEBUG_CHANNEL(wbemprox
);
47 static const WCHAR class_baseboardW
[] =
48 {'W','i','n','3','2','_','B','a','s','e','B','o','a','r','d',0};
49 static const WCHAR class_biosW
[] =
50 {'W','i','n','3','2','_','B','I','O','S',0};
51 static const WCHAR class_cdromdriveW
[] =
52 {'W','i','n','3','2','_','C','D','R','O','M','D','r','i','v','e',0};
53 static const WCHAR class_compsysW
[] =
54 {'W','i','n','3','2','_','C','o','m','p','u','t','e','r','S','y','s','t','e','m',0};
55 static const WCHAR class_datafileW
[] =
56 {'C','I','M','_','D','a','t','a','F','i','l','e',0};
57 static const WCHAR class_directoryW
[] =
58 {'W','i','n','3','2','_','D','i','r','e','c','t','o','r','y',0};
59 static const WCHAR class_diskdriveW
[] =
60 {'W','i','n','3','2','_','D','i','s','k','D','r','i','v','e',0};
61 static const WCHAR class_diskpartitionW
[] =
62 {'W','i','n','3','2','_','D','i','s','k','P','a','r','t','i','t','i','o','n',0};
63 static const WCHAR class_logicaldiskW
[] =
64 {'W','i','n','3','2','_','L','o','g','i','c','a','l','D','i','s','k',0};
65 static const WCHAR class_logicaldisk2W
[] =
66 {'C','I','M','_','L','o','g','i','c','a','l','D','i','s','k',0};
67 static const WCHAR class_networkadapterW
[] =
68 {'W','i','n','3','2','_','N','e','t','w','o','r','k','A','d','a','p','t','e','r',0};
69 static const WCHAR class_osW
[] =
70 {'W','i','n','3','2','_','O','p','e','r','a','t','i','n','g','S','y','s','t','e','m',0};
71 static const WCHAR class_paramsW
[] =
72 {'_','_','P','A','R','A','M','E','T','E','R','S',0};
73 static const WCHAR class_qualifiersW
[] =
74 {'_','_','Q','U','A','L','I','F','I','E','R','S',0};
75 static const WCHAR class_process_getowner_outW
[] =
76 {'_','_','W','I','N','3','2','_','P','R','O','C','E','S','S','_','G','E','T','O','W',
77 'N','E','R','_','O','U','T',0};
78 static const WCHAR class_processorW
[] =
79 {'W','i','n','3','2','_','P','r','o','c','e','s','s','o','r',0};
80 static const WCHAR class_sounddeviceW
[] =
81 {'W','i','n','3','2','_','S','o','u','n','d','D','e','v','i','c','e',0};
82 static const WCHAR class_videocontrollerW
[] =
83 {'W','i','n','3','2','_','V','i','d','e','o','C','o','n','t','r','o','l','l','e','r',0};
85 static const WCHAR prop_acceptpauseW
[] =
86 {'A','c','c','e','p','t','P','a','u','s','e',0};
87 static const WCHAR prop_acceptstopW
[] =
88 {'A','c','c','e','p','t','S','t','o','p',0};
89 static const WCHAR prop_accessmaskW
[] =
90 {'A','c','c','e','s','s','M','a','s','k',0};
91 static const WCHAR prop_adapterdactypeW
[] =
92 {'A','d','a','p','t','e','r','D','A','C','T','y','p','e',0};
93 static const WCHAR prop_adapterramW
[] =
94 {'A','d','a','p','t','e','r','R','A','M',0};
95 static const WCHAR prop_adaptertypeW
[] =
96 {'A','d','a','p','t','e','r','T','y','p','e',0};
97 static const WCHAR prop_addresswidthW
[] =
98 {'A','d','d','r','e','s','s','W','i','d','t','h',0};
99 static const WCHAR prop_bootableW
[] =
100 {'B','o','o','t','a','b','l','e',0};
101 static const WCHAR prop_bootpartitionW
[] =
102 {'B','o','o','t','P','a','r','t','i','t','i','o','n',0};
103 static const WCHAR prop_captionW
[] =
104 {'C','a','p','t','i','o','n',0};
105 static const WCHAR prop_classW
[] =
106 {'C','l','a','s','s',0};
107 static const WCHAR prop_codesetW
[] =
108 {'C','o','d','e','S','e','t',0};
109 static const WCHAR prop_commandlineW
[] =
110 {'C','o','m','m','a','n','d','L','i','n','e',0};
111 static const WCHAR prop_countrycodeW
[] =
112 {'C','o','u','n','t','r','y','C','o','d','e',0};
113 static const WCHAR prop_cpustatusW
[] =
114 {'C','p','u','S','t','a','t','u','s',0};
115 static const WCHAR prop_csdversionW
[] =
116 {'C','S','D','V','e','r','s','i','o','n',0};
117 static const WCHAR prop_currentbitsperpixelW
[] =
118 {'C','u','r','r','e','n','t','B','i','t','s','P','e','r','P','i','x','e','l',0};
119 static const WCHAR prop_currenthorizontalresW
[] =
120 {'C','u','r','r','e','n','t','H','o','r','i','z','o','n','t','a','l','R','e','s','o','l','u','t','i','o','n',0};
121 static const WCHAR prop_currentverticalresW
[] =
122 {'C','u','r','r','e','n','t','V','e','r','t','i','c','a','l','R','e','s','o','l','u','t','i','o','n',0};
123 static const WCHAR prop_defaultvalueW
[] =
124 {'D','e','f','a','u','l','t','V','a','l','u','e',0};
125 static const WCHAR prop_descriptionW
[] =
126 {'D','e','s','c','r','i','p','t','i','o','n',0};
127 static const WCHAR prop_deviceidW
[] =
128 {'D','e','v','i','c','e','I','d',0};
129 static const WCHAR prop_directionW
[] =
130 {'D','i','r','e','c','t','i','o','n',0};
131 static const WCHAR prop_displaynameW
[] =
132 {'D','i','s','p','l','a','y','N','a','m','e',0};
133 static const WCHAR prop_diskindexW
[] =
134 {'D','i','s','k','I','n','d','e','x',0};
135 static const WCHAR prop_domainW
[] =
136 {'D','o','m','a','i','n',0};
137 static const WCHAR prop_domainroleW
[] =
138 {'D','o','m','a','i','n','R','o','l','e',0};
139 static const WCHAR prop_driveW
[] =
140 {'D','r','i','v','e',0};
141 static const WCHAR prop_drivetypeW
[] =
142 {'D','r','i','v','e','T','y','p','e',0};
143 static const WCHAR prop_familyW
[] =
144 {'F','a','m','i','l','y',0};
145 static const WCHAR prop_filesystemW
[] =
146 {'F','i','l','e','S','y','s','t','e','m',0};
147 static const WCHAR prop_flavorW
[] =
148 {'F','l','a','v','o','r',0};
149 static const WCHAR prop_freespaceW
[] =
150 {'F','r','e','e','S','p','a','c','e',0};
151 static const WCHAR prop_handleW
[] =
152 {'H','a','n','d','l','e',0};
153 static const WCHAR prop_idW
[] =
155 static const WCHAR prop_indexW
[] =
156 {'I','n','d','e','x',0};
157 static const WCHAR prop_interfaceindexW
[] =
158 {'I','n','t','e','r','f','a','c','e','I','n','d','e','x',0};
159 static const WCHAR prop_intvalueW
[] =
160 {'I','n','t','e','g','e','r','V','a','l','u','e',0};
161 static const WCHAR prop_lastbootuptimeW
[] =
162 {'L','a','s','t','B','o','o','t','U','p','T','i','m','e',0};
163 static const WCHAR prop_localdatetimeW
[] =
164 {'L','o','c','a','l','D','a','t','e','T','i','m','e',0};
165 static const WCHAR prop_localeW
[] =
166 {'L','o','c','a','l','e',0};
167 static const WCHAR prop_macaddressW
[] =
168 {'M','A','C','A','d','d','r','e','s','s',0};
169 static const WCHAR prop_manufacturerW
[] =
170 {'M','a','n','u','f','a','c','t','u','r','e','r',0};
171 static const WCHAR prop_maxclockspeedW
[] =
172 {'M','a','x','C','l','o','c','k','S','p','e','e','d',0};
173 static const WCHAR prop_memberW
[] =
174 {'M','e','m','b','e','r',0};
175 static const WCHAR prop_methodW
[] =
176 {'M','e','t','h','o','d',0};
177 static const WCHAR prop_modelW
[] =
178 {'M','o','d','e','l',0};
179 static const WCHAR prop_netconnectionstatusW
[] =
180 {'N','e','t','C','o','n','n','e','c','t','i','o','n','S','t','a','t','u','s',0};
181 static const WCHAR prop_numcoresW
[] =
182 {'N','u','m','b','e','r','O','f','C','o','r','e','s',0};
183 static const WCHAR prop_numlogicalprocessorsW
[] =
184 {'N','u','m','b','e','r','O','f','L','o','g','i','c','a','l','P','r','o','c','e','s','s','o','r','s',0};
185 static const WCHAR prop_numprocessorsW
[] =
186 {'N','u','m','b','e','r','O','f','P','r','o','c','e','s','s','o','r','s',0};
187 static const WCHAR prop_osarchitectureW
[] =
188 {'O','S','A','r','c','h','i','t','e','c','t','u','r','e',0};
189 static const WCHAR prop_oslanguageW
[] =
190 {'O','S','L','a','n','g','u','a','g','e',0};
191 static const WCHAR prop_osproductsuiteW
[] =
192 {'O','S','P','r','o','d','u','c','t','S','u','i','t','e',0};
193 static const WCHAR prop_ostypeW
[] =
194 {'O','S','T','y','p','e',0};
195 static const WCHAR prop_parameterW
[] =
196 {'P','a','r','a','m','e','t','e','r',0};
197 static const WCHAR prop_physicaladapterW
[] =
198 {'P','h','y','s','i','c','a','l','A','d','a','p','t','e','r',0};
199 static const WCHAR prop_pnpdeviceidW
[] =
200 {'P','N','P','D','e','v','i','c','e','I','D',0};
201 static const WCHAR prop_pprocessidW
[] =
202 {'P','a','r','e','n','t','P','r','o','c','e','s','s','I','D',0};
203 static const WCHAR prop_processidW
[] =
204 {'P','r','o','c','e','s','s','I','D',0};
205 static const WCHAR prop_processoridW
[] =
206 {'P','r','o','c','e','s','s','o','r','I','d',0};
207 static const WCHAR prop_productnameW
[] =
208 {'P','r','o','d','u','c','t','N','a','m','e',0};
209 static const WCHAR prop_releasedateW
[] =
210 {'R','e','l','e','a','s','e','D','a','t','e',0};
211 static const WCHAR prop_serialnumberW
[] =
212 {'S','e','r','i','a','l','N','u','m','b','e','r',0};
213 static const WCHAR prop_servicepackmajorW
[] =
214 {'S','e','r','v','i','c','e','P','a','c','k','M','a','j','o','r','V','e','r','s','i','o','n',0};
215 static const WCHAR prop_servicepackminorW
[] =
216 {'S','e','r','v','i','c','e','P','a','c','k','M','i','n','o','r','V','e','r','s','i','o','n',0};
217 static const WCHAR prop_servicetypeW
[] =
218 {'S','e','r','v','i','c','e','T','y','p','e',0};
219 static const WCHAR prop_startmodeW
[] =
220 {'S','t','a','r','t','M','o','d','e',0};
221 static const WCHAR prop_sizeW
[] =
223 static const WCHAR prop_speedW
[] =
224 {'S','p','e','e','d',0};
225 static const WCHAR prop_startingoffsetW
[] =
226 {'S','t','a','r','t','i','n','g','O','f','f','s','e','t',0};
227 static const WCHAR prop_stateW
[] =
228 {'S','t','a','t','e',0};
229 static const WCHAR prop_strvalueW
[] =
230 {'S','t','r','i','n','g','V','a','l','u','e',0};
231 static const WCHAR prop_suitemaskW
[] =
232 {'S','u','i','t','e','M','a','s','k',0};
233 static const WCHAR prop_systemdirectoryW
[] =
234 {'S','y','s','t','e','m','D','i','r','e','c','t','o','r','y',0};
235 static const WCHAR prop_systemnameW
[] =
236 {'S','y','s','t','e','m','N','a','m','e',0};
237 static const WCHAR prop_tagW
[] =
239 static const WCHAR prop_threadcountW
[] =
240 {'T','h','r','e','a','d','C','o','u','n','t',0};
241 static const WCHAR prop_totalphysicalmemoryW
[] =
242 {'T','o','t','a','l','P','h','y','s','i','c','a','l','M','e','m','o','r','y',0};
243 static const WCHAR prop_typeW
[] =
245 static const WCHAR prop_uniqueidW
[] =
246 {'U','n','i','q','u','e','I','d',0};
247 static const WCHAR prop_varianttypeW
[] =
248 {'V','a','r','i','a','n','t','T','y','p','e',0};
249 static const WCHAR prop_versionW
[] =
250 {'V','e','r','s','i','o','n',0};
252 /* column definitions must be kept in sync with record structures below */
253 static const struct column col_baseboard
[] =
255 { prop_manufacturerW
, CIM_STRING
},
256 { prop_serialnumberW
, CIM_STRING
},
257 { prop_tagW
, CIM_STRING
|COL_FLAG_KEY
}
259 static const struct column col_bios
[] =
261 { prop_descriptionW
, CIM_STRING
},
262 { prop_manufacturerW
, CIM_STRING
},
263 { prop_releasedateW
, CIM_DATETIME
},
264 { prop_serialnumberW
, CIM_STRING
},
265 { prop_versionW
, CIM_STRING
|COL_FLAG_KEY
}
267 static const struct column col_cdromdrive
[] =
269 { prop_deviceidW
, CIM_STRING
|COL_FLAG_KEY
},
270 { prop_driveW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
271 { prop_nameW
, CIM_STRING
},
272 { prop_pnpdeviceidW
, CIM_STRING
}
274 static const struct column col_compsys
[] =
276 { prop_descriptionW
, CIM_STRING
},
277 { prop_domainW
, CIM_STRING
},
278 { prop_domainroleW
, CIM_UINT16
},
279 { prop_manufacturerW
, CIM_STRING
},
280 { prop_modelW
, CIM_STRING
},
281 { prop_nameW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
282 { prop_numlogicalprocessorsW
, CIM_UINT32
, VT_I4
},
283 { prop_numprocessorsW
, CIM_UINT32
, VT_I4
},
284 { prop_totalphysicalmemoryW
, CIM_UINT64
}
286 static const struct column col_datafile
[] =
288 { prop_nameW
, CIM_STRING
|COL_FLAG_DYNAMIC
|COL_FLAG_KEY
},
289 { prop_versionW
, CIM_STRING
|COL_FLAG_DYNAMIC
}
291 static const struct column col_directory
[] =
293 { prop_accessmaskW
, CIM_UINT32
},
294 { prop_nameW
, CIM_STRING
|COL_FLAG_DYNAMIC
|COL_FLAG_KEY
}
296 static const struct column col_diskdrive
[] =
298 { prop_deviceidW
, CIM_STRING
|COL_FLAG_KEY
},
299 { prop_indexW
, CIM_UINT32
, VT_I4
},
300 { prop_manufacturerW
, CIM_STRING
},
301 { prop_modelW
, CIM_STRING
},
302 { prop_serialnumberW
, CIM_STRING
}
304 static const struct column col_diskpartition
[] =
306 { prop_bootableW
, CIM_BOOLEAN
},
307 { prop_bootpartitionW
, CIM_BOOLEAN
},
308 { prop_deviceidW
, CIM_STRING
|COL_FLAG_DYNAMIC
|COL_FLAG_KEY
},
309 { prop_diskindexW
, CIM_UINT32
, VT_I4
},
310 { prop_indexW
, CIM_UINT32
, VT_I4
},
311 { prop_pnpdeviceidW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
312 { prop_sizeW
, CIM_UINT64
},
313 { prop_startingoffsetW
, CIM_UINT64
},
314 { prop_typeW
, CIM_STRING
|COL_FLAG_DYNAMIC
}
316 static const struct column col_logicaldisk
[] =
318 { prop_deviceidW
, CIM_STRING
|COL_FLAG_DYNAMIC
|COL_FLAG_KEY
},
319 { prop_drivetypeW
, CIM_UINT32
, VT_I4
},
320 { prop_filesystemW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
321 { prop_freespaceW
, CIM_UINT64
},
322 { prop_nameW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
323 { prop_sizeW
, CIM_UINT64
}
325 static const struct column col_networkadapter
[] =
327 { prop_adaptertypeW
, CIM_STRING
},
328 { prop_deviceidW
, CIM_STRING
|COL_FLAG_DYNAMIC
|COL_FLAG_KEY
},
329 { prop_interfaceindexW
, CIM_UINT32
, VT_I4
},
330 { prop_macaddressW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
331 { prop_manufacturerW
, CIM_STRING
},
332 { prop_netconnectionstatusW
, CIM_UINT16
, VT_I4
},
333 { prop_physicaladapterW
, CIM_BOOLEAN
},
334 { prop_pnpdeviceidW
, CIM_STRING
},
335 { prop_speedW
, CIM_UINT64
}
337 static const struct column col_os
[] =
339 { prop_captionW
, CIM_STRING
},
340 { prop_codesetW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
341 { prop_countrycodeW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
342 { prop_csdversionW
, CIM_STRING
},
343 { prop_lastbootuptimeW
, CIM_DATETIME
|COL_FLAG_DYNAMIC
},
344 { prop_localdatetimeW
, CIM_DATETIME
|COL_FLAG_DYNAMIC
},
345 { prop_localeW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
346 { prop_osarchitectureW
, CIM_STRING
},
347 { prop_oslanguageW
, CIM_UINT32
, VT_I4
},
348 { prop_osproductsuiteW
, CIM_UINT32
, VT_I4
},
349 { prop_ostypeW
, CIM_UINT16
, VT_I4
},
350 { prop_servicepackmajorW
, CIM_UINT16
, VT_I4
},
351 { prop_servicepackminorW
, CIM_UINT16
, VT_I4
},
352 { prop_suitemaskW
, CIM_UINT32
, VT_I4
},
353 { prop_systemdirectoryW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
354 { prop_versionW
, CIM_STRING
}
356 static const struct column col_param
[] =
358 { prop_classW
, CIM_STRING
},
359 { prop_methodW
, CIM_STRING
},
360 { prop_directionW
, CIM_SINT32
},
361 { prop_parameterW
, CIM_STRING
},
362 { prop_typeW
, CIM_UINT32
},
363 { prop_varianttypeW
, CIM_UINT32
},
364 { prop_defaultvalueW
, CIM_UINT32
}
366 static const struct column col_process
[] =
368 { prop_captionW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
369 { prop_commandlineW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
370 { prop_descriptionW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
371 { prop_handleW
, CIM_STRING
|COL_FLAG_DYNAMIC
|COL_FLAG_KEY
},
372 { prop_nameW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
373 { prop_pprocessidW
, CIM_UINT32
, VT_I4
},
374 { prop_processidW
, CIM_UINT32
, VT_I4
},
375 { prop_threadcountW
, CIM_UINT32
, VT_I4
},
377 { method_getownerW
, CIM_FLAG_ARRAY
|COL_FLAG_METHOD
}
379 static const struct column col_processor
[] =
381 { prop_addresswidthW
, CIM_UINT16
, VT_I4
},
382 { prop_cpustatusW
, CIM_UINT16
},
383 { prop_deviceidW
, CIM_STRING
|COL_FLAG_DYNAMIC
|COL_FLAG_KEY
},
384 { prop_familyW
, CIM_UINT16
, VT_I4
},
385 { prop_manufacturerW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
386 { prop_maxclockspeedW
, CIM_UINT32
, VT_I4
},
387 { prop_nameW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
388 { prop_numcoresW
, CIM_UINT32
, VT_I4
},
389 { prop_numlogicalprocessorsW
, CIM_UINT32
, VT_I4
},
390 { prop_processoridW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
391 { prop_uniqueidW
, CIM_STRING
}
393 static const struct column col_qualifier
[] =
395 { prop_classW
, CIM_STRING
},
396 { prop_memberW
, CIM_STRING
},
397 { prop_typeW
, CIM_UINT32
},
398 { prop_flavorW
, CIM_SINT32
},
399 { prop_nameW
, CIM_STRING
},
400 { prop_intvalueW
, CIM_SINT32
},
401 { prop_strvalueW
, CIM_STRING
}
403 static const struct column col_service
[] =
405 { prop_acceptpauseW
, CIM_BOOLEAN
},
406 { prop_acceptstopW
, CIM_BOOLEAN
},
407 { prop_displaynameW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
408 { prop_nameW
, CIM_STRING
|COL_FLAG_DYNAMIC
|COL_FLAG_KEY
},
409 { prop_processidW
, CIM_UINT32
},
410 { prop_servicetypeW
, CIM_STRING
},
411 { prop_startmodeW
, CIM_STRING
},
412 { prop_stateW
, CIM_STRING
},
413 { prop_systemnameW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
415 { method_pauseserviceW
, CIM_FLAG_ARRAY
|COL_FLAG_METHOD
},
416 { method_resumeserviceW
, CIM_FLAG_ARRAY
|COL_FLAG_METHOD
},
417 { method_startserviceW
, CIM_FLAG_ARRAY
|COL_FLAG_METHOD
},
418 { method_stopserviceW
, CIM_FLAG_ARRAY
|COL_FLAG_METHOD
}
420 static const struct column col_sounddevice
[] =
422 { prop_nameW
, CIM_STRING
},
423 { prop_productnameW
, CIM_STRING
}
425 static const struct column col_stdregprov
[] =
427 { method_enumkeyW
, CIM_FLAG_ARRAY
|COL_FLAG_METHOD
},
428 { method_enumvaluesW
, CIM_FLAG_ARRAY
|COL_FLAG_METHOD
},
429 { method_getstringvalueW
, CIM_FLAG_ARRAY
|COL_FLAG_METHOD
}
431 static const struct column col_videocontroller
[] =
433 { prop_adapterdactypeW
, CIM_STRING
},
434 { prop_adapterramW
, CIM_UINT32
, VT_I4
},
435 { prop_currentbitsperpixelW
, CIM_UINT32
},
436 { prop_currenthorizontalresW
, CIM_UINT32
},
437 { prop_currentverticalresW
, CIM_UINT32
},
438 { prop_descriptionW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
439 { prop_deviceidW
, CIM_STRING
|COL_FLAG_KEY
},
440 { prop_nameW
, CIM_STRING
|COL_FLAG_DYNAMIC
},
441 { prop_pnpdeviceidW
, CIM_STRING
|COL_FLAG_DYNAMIC
}
444 static const WCHAR baseboard_manufacturerW
[] =
445 {'I','n','t','e','l',' ','C','o','r','p','o','r','a','t','i','o','n',0};
446 static const WCHAR baseboard_serialnumberW
[] =
448 static const WCHAR baseboard_tagW
[] =
449 {'B','a','s','e',' ','B','o','a','r','d',0};
450 static const WCHAR bios_descriptionW
[] =
451 {'D','e','f','a','u','l','t',' ','S','y','s','t','e','m',' ','B','I','O','S',0};
452 static const WCHAR bios_manufacturerW
[] =
453 {'T','h','e',' ','W','i','n','e',' ','P','r','o','j','e','c','t',0};
454 static const WCHAR bios_releasedateW
[] =
455 {'2','0','1','2','0','6','0','8','0','0','0','0','0','0','.','0','0','0','0','0','0','+','0','0','0',0};
456 static const WCHAR bios_serialnumberW
[] =
458 static const WCHAR bios_versionW
[] =
459 {'W','I','N','E',' ',' ',' ','-',' ','1',0};
460 static const WCHAR cdromdrive_nameW
[] =
461 {'W','i','n','e',' ','C','D','-','R','O','M',' ','A','T','A',' ','D','e','v','i','c','e',0};
462 static const WCHAR cdromdrive_pnpdeviceidW
[]=
463 {'I','D','E','\\','C','D','R','O','M','W','I','N','E','_','C','D','-','R','O','M',
464 '_','_','_','_','_','_','_','_','_','_','_','_','_','_','_','_','_','_','_','_','_','_',
465 '_','_','_','_','_','_','_','1','.','0','_','_','_','_','_','\\','5','&','3','A','2',
466 'A','5','8','5','4','&','0','&','1','.','0','.','0',0};
467 static const WCHAR compsys_descriptionW
[] =
468 {'A','T','/','A','T',' ','C','O','M','P','A','T','I','B','L','E',0};
469 static const WCHAR compsys_domainW
[] =
470 {'W','O','R','K','G','R','O','U','P',0};
471 static const WCHAR compsys_manufacturerW
[] =
472 {'T','h','e',' ','W','i','n','e',' ','P','r','o','j','e','c','t',0};
473 static const WCHAR compsys_modelW
[] =
475 static const WCHAR diskdrive_deviceidW
[] =
476 {'\\','\\','\\','\\','.','\\','\\','P','H','Y','S','I','C','A','L','D','R','I','V','E','0',0};
477 static const WCHAR diskdrive_modelW
[] =
478 {'W','i','n','e',' ','D','i','s','k',' ','D','r','i','v','e',0};
479 static const WCHAR diskdrive_manufacturerW
[] =
480 {'(','S','t','a','n','d','a','r','d',' ','d','i','s','k',' ','d','r','i','v','e','s',')',0};
481 static const WCHAR diskdrive_serialW
[] =
482 {'W','I','N','E','H','D','I','S','K',0};
483 static const WCHAR networkadapter_pnpdeviceidW
[]=
484 {'P','C','I','\\','V','E','N','_','8','0','8','6','&','D','E','V','_','1','0','0','E','&',
485 'S','U','B','S','Y','S','_','0','0','1','E','8','0','8','6','&','R','E','V','_','0','2','\\',
486 '3','&','2','6','7','A','6','1','6','A','&','1','&','1','8',0};
487 static const WCHAR os_captionW
[] =
488 {'M','i','c','r','o','s','o','f','t',' ','W','i','n','d','o','w','s',' ','X','P',' ',
489 'V','e','r','s','i','o','n',' ','=',' ','5','.','1','.','2','6','0','0',0};
490 static const WCHAR os_csdversionW
[] =
491 {'S','e','r','v','i','c','e',' ','P','a','c','k',' ','3',0};
492 static const WCHAR os_32bitW
[] =
493 {'3','2','-','b','i','t',0};
494 static const WCHAR os_64bitW
[] =
495 {'6','4','-','b','i','t',0};
496 static const WCHAR os_versionW
[] =
497 {'5','.','1','.','2','6','0','0',0};
498 static const WCHAR sounddevice_productnameW
[] =
499 {'W','i','n','e',' ','A','u','d','i','o',' ','D','e','v','i','c','e',0};
500 static const WCHAR videocontroller_dactypeW
[] =
501 {'I','n','t','e','g','r','a','t','e','d',' ','R','A','M','D','A','C',0};
502 static const WCHAR videocontroller_deviceidW
[] =
503 {'V','i','d','e','o','C','o','n','t','r','o','l','l','e','r','1',0};
505 #include "pshpack1.h"
506 struct record_baseboard
508 const WCHAR
*manufacturer
;
509 const WCHAR
*serialnumber
;
514 const WCHAR
*description
;
515 const WCHAR
*manufacturer
;
516 const WCHAR
*releasedate
;
517 const WCHAR
*serialnumber
;
518 const WCHAR
*version
;
520 struct record_cdromdrive
522 const WCHAR
*device_id
;
525 const WCHAR
*pnpdevice_id
;
527 struct record_computersystem
529 const WCHAR
*description
;
532 const WCHAR
*manufacturer
;
535 UINT32 num_logical_processors
;
536 UINT32 num_processors
;
537 UINT64 total_physical_memory
;
539 struct record_datafile
542 const WCHAR
*version
;
544 struct record_directory
549 struct record_diskdrive
551 const WCHAR
*device_id
;
553 const WCHAR
*manufacturer
;
555 const WCHAR
*serialnumber
;
557 struct record_diskpartition
561 const WCHAR
*device_id
;
564 const WCHAR
*pnpdevice_id
;
566 UINT64 startingoffset
;
569 struct record_logicaldisk
571 const WCHAR
*device_id
;
573 const WCHAR
*filesystem
;
578 struct record_networkadapter
580 const WCHAR
*adaptertype
;
581 const WCHAR
*device_id
;
582 INT32 interface_index
;
583 const WCHAR
*mac_address
;
584 const WCHAR
*manufacturer
;
585 UINT16 netconnection_status
;
587 const WCHAR
*pnpdevice_id
;
590 struct record_operatingsystem
592 const WCHAR
*caption
;
593 const WCHAR
*codeset
;
594 const WCHAR
*countrycode
;
595 const WCHAR
*csdversion
;
596 const WCHAR
*lastbootuptime
;
597 const WCHAR
*localdatetime
;
599 const WCHAR
*osarchitecture
;
601 UINT32 osproductsuite
;
603 UINT16 servicepackmajor
;
604 UINT16 servicepackminor
;
606 const WCHAR
*systemdirectory
;
607 const WCHAR
*version
;
614 const WCHAR
*parameter
;
619 struct record_process
621 const WCHAR
*caption
;
622 const WCHAR
*commandline
;
623 const WCHAR
*description
;
630 class_method
*get_owner
;
632 struct record_processor
636 const WCHAR
*device_id
;
638 const WCHAR
*manufacturer
;
639 UINT32 maxclockspeed
;
642 UINT32 num_logical_processors
;
643 const WCHAR
*processor_id
;
644 const WCHAR
*unique_id
;
646 struct record_qualifier
654 const WCHAR
*strvalue
;
656 struct record_service
660 const WCHAR
*displayname
;
663 const WCHAR
*servicetype
;
664 const WCHAR
*startmode
;
666 const WCHAR
*systemname
;
668 class_method
*pause_service
;
669 class_method
*resume_service
;
670 class_method
*start_service
;
671 class_method
*stop_service
;
673 struct record_sounddevice
676 const WCHAR
*productname
;
678 struct record_stdregprov
680 class_method
*enumkey
;
681 class_method
*enumvalues
;
682 class_method
*getstringvalue
;
684 struct record_videocontroller
686 const WCHAR
*adapter_dactype
;
688 UINT32 current_bitsperpixel
;
689 UINT32 current_horizontalres
;
690 UINT32 current_verticalres
;
691 const WCHAR
*description
;
692 const WCHAR
*device_id
;
694 const WCHAR
*pnpdevice_id
;
698 static const struct record_baseboard data_baseboard
[] =
700 { baseboard_manufacturerW
, baseboard_serialnumberW
, baseboard_tagW
}
702 static const struct record_bios data_bios
[] =
704 { bios_descriptionW
, bios_manufacturerW
, bios_releasedateW
, bios_serialnumberW
, bios_versionW
}
706 static const struct record_diskdrive data_diskdrive
[] =
708 { diskdrive_deviceidW
, 0, diskdrive_manufacturerW
, diskdrive_modelW
, diskdrive_serialW
}
710 static const struct record_param data_param
[] =
712 { class_processW
, method_getownerW
, -1, param_returnvalueW
, CIM_UINT32
, VT_I4
},
713 { class_processW
, method_getownerW
, -1, param_userW
, CIM_STRING
},
714 { class_processW
, method_getownerW
, -1, param_domainW
, CIM_STRING
},
715 { class_serviceW
, method_pauseserviceW
, -1, param_returnvalueW
, CIM_UINT32
, VT_I4
},
716 { class_serviceW
, method_resumeserviceW
, -1, param_returnvalueW
, CIM_UINT32
, VT_I4
},
717 { class_serviceW
, method_startserviceW
, -1, param_returnvalueW
, CIM_UINT32
, VT_I4
},
718 { class_serviceW
, method_stopserviceW
, -1, param_returnvalueW
, CIM_UINT32
, VT_I4
},
719 { class_stdregprovW
, method_enumkeyW
, 1, param_defkeyW
, CIM_SINT32
, 0, 0x80000002 },
720 { class_stdregprovW
, method_enumkeyW
, 1, param_subkeynameW
, CIM_STRING
},
721 { class_stdregprovW
, method_enumkeyW
, -1, param_returnvalueW
, CIM_UINT32
, VT_I4
},
722 { class_stdregprovW
, method_enumkeyW
, -1, param_namesW
, CIM_STRING
|CIM_FLAG_ARRAY
},
723 { class_stdregprovW
, method_enumvaluesW
, 1, param_defkeyW
, CIM_SINT32
, 0, 0x80000002 },
724 { class_stdregprovW
, method_enumvaluesW
, 1, param_subkeynameW
, CIM_STRING
},
725 { class_stdregprovW
, method_enumvaluesW
, -1, param_returnvalueW
, CIM_UINT32
, VT_I4
},
726 { class_stdregprovW
, method_enumvaluesW
, -1, param_namesW
, CIM_STRING
|CIM_FLAG_ARRAY
},
727 { class_stdregprovW
, method_enumvaluesW
, -1, param_typesW
, CIM_SINT32
|CIM_FLAG_ARRAY
},
728 { class_stdregprovW
, method_getstringvalueW
, 1, param_defkeyW
, CIM_SINT32
, 0, 0x80000002 },
729 { class_stdregprovW
, method_getstringvalueW
, 1, param_subkeynameW
, CIM_STRING
},
730 { class_stdregprovW
, method_getstringvalueW
, 1, param_valuenameW
, CIM_STRING
},
731 { class_stdregprovW
, method_getstringvalueW
, -1, param_returnvalueW
, CIM_UINT32
, VT_I4
},
732 { class_stdregprovW
, method_getstringvalueW
, -1, param_valueW
, CIM_STRING
}
735 #define FLAVOR_ID (WBEM_FLAVOR_FLAG_PROPAGATE_TO_INSTANCE | WBEM_FLAVOR_NOT_OVERRIDABLE |\
736 WBEM_FLAVOR_ORIGIN_PROPAGATED)
738 static const struct record_qualifier data_qualifier
[] =
740 { class_process_getowner_outW
, param_userW
, CIM_SINT32
, FLAVOR_ID
, prop_idW
, 0 },
741 { class_process_getowner_outW
, param_domainW
, CIM_SINT32
, FLAVOR_ID
, prop_idW
, 1 }
743 static const struct record_sounddevice data_sounddevice
[] =
745 { sounddevice_productnameW
, sounddevice_productnameW
}
747 static const struct record_stdregprov data_stdregprov
[] =
749 { reg_enum_key
, reg_enum_values
, reg_get_stringvalue
}
752 /* check if row matches condition and update status */
753 static BOOL
match_row( const struct table
*table
, UINT row
, const struct expr
*cond
, enum fill_status
*status
)
758 *status
= FILL_STATUS_UNFILTERED
;
761 if (eval_cond( table
, row
, cond
, &val
) != S_OK
)
763 *status
= FILL_STATUS_FAILED
;
766 *status
= FILL_STATUS_FILTERED
;
770 static BOOL
resize_table( struct table
*table
, UINT row_count
, UINT row_size
)
772 if (!table
->num_rows_allocated
)
774 if (!(table
->data
= heap_alloc( row_count
* row_size
))) return FALSE
;
775 table
->num_rows_allocated
= row_count
;
778 if (row_count
>= table
->num_rows_allocated
)
781 UINT count
= table
->num_rows_allocated
* 2;
782 if (!(data
= heap_realloc( table
->data
, count
* row_size
))) return FALSE
;
784 table
->num_rows_allocated
= count
;
789 static enum fill_status
fill_cdromdrive( struct table
*table
, const struct expr
*cond
)
791 static const WCHAR fmtW
[] = {'%','c',':',0};
792 WCHAR drive
[3], root
[] = {'A',':','\\',0};
793 struct record_cdromdrive
*rec
;
794 UINT i
, row
= 0, offset
= 0;
795 DWORD drives
= GetLogicalDrives();
796 enum fill_status status
= FILL_STATUS_UNFILTERED
;
798 if (!resize_table( table
, 1, sizeof(*rec
) )) return FILL_STATUS_FAILED
;
800 for (i
= 0; i
< sizeof(drives
); i
++)
802 if (drives
& (1 << i
))
805 if (GetDriveTypeW( root
) != DRIVE_CDROM
)
808 if (!resize_table( table
, row
+ 1, sizeof(*rec
) )) return FILL_STATUS_FAILED
;
810 rec
= (struct record_cdromdrive
*)(table
->data
+ offset
);
811 rec
->device_id
= cdromdrive_pnpdeviceidW
;
812 sprintfW( drive
, fmtW
, 'A' + i
);
813 rec
->drive
= heap_strdupW( drive
);
814 rec
->name
= cdromdrive_nameW
;
815 rec
->pnpdevice_id
= cdromdrive_pnpdeviceidW
;
816 if (!match_row( table
, row
, cond
, &status
))
818 free_row_values( table
, row
);
821 offset
+= sizeof(*rec
);
825 TRACE("created %u rows\n", row
);
826 table
->num_rows
= row
;
830 static UINT
get_processor_count(void)
832 SYSTEM_BASIC_INFORMATION info
;
834 if (NtQuerySystemInformation( SystemBasicInformation
, &info
, sizeof(info
), NULL
)) return 1;
835 return info
.NumberOfProcessors
;
838 static UINT
get_logical_processor_count( UINT
*num_cores
)
840 SYSTEM_LOGICAL_PROCESSOR_INFORMATION
*info
;
841 UINT i
, j
, count
= 0;
845 if (num_cores
) *num_cores
= get_processor_count();
846 status
= NtQuerySystemInformation( SystemLogicalProcessorInformation
, NULL
, 0, &len
);
847 if (status
!= STATUS_INFO_LENGTH_MISMATCH
) return get_processor_count();
849 if (!(info
= heap_alloc( len
))) return get_processor_count();
850 status
= NtQuerySystemInformation( SystemLogicalProcessorInformation
, info
, len
, &len
);
851 if (status
!= STATUS_SUCCESS
)
854 return get_processor_count();
856 if (num_cores
) *num_cores
= 0;
857 for (i
= 0; i
< len
/ sizeof(*info
); i
++)
859 if (info
[i
].Relationship
== RelationProcessorCore
)
861 for (j
= 0; j
< sizeof(ULONG_PTR
); j
++) if (info
[i
].ProcessorMask
& (1 << j
)) count
++;
863 else if (info
[i
].Relationship
== RelationProcessorPackage
&& num_cores
)
865 for (j
= 0; j
< sizeof(ULONG_PTR
); j
++) if (info
[i
].ProcessorMask
& (1 << j
)) (*num_cores
)++;
872 static UINT64
get_total_physical_memory(void)
874 MEMORYSTATUSEX status
;
876 status
.dwLength
= sizeof(status
);
877 if (!GlobalMemoryStatusEx( &status
)) return 1024 * 1024 * 1024;
878 return status
.ullTotalPhys
;
881 static WCHAR
*get_computername(void)
884 DWORD size
= MAX_COMPUTERNAME_LENGTH
;
886 if (!(ret
= heap_alloc( size
* sizeof(WCHAR
) ))) return NULL
;
887 GetComputerNameW( ret
, &size
);
891 static enum fill_status
fill_compsys( struct table
*table
, const struct expr
*cond
)
893 struct record_computersystem
*rec
;
894 enum fill_status status
= FILL_STATUS_UNFILTERED
;
897 if (!resize_table( table
, 1, sizeof(*rec
) )) return FILL_STATUS_FAILED
;
899 rec
= (struct record_computersystem
*)table
->data
;
900 rec
->description
= compsys_descriptionW
;
901 rec
->domain
= compsys_domainW
;
902 rec
->domainrole
= 0; /* standalone workstation */
903 rec
->manufacturer
= compsys_manufacturerW
;
904 rec
->model
= compsys_modelW
;
905 rec
->name
= get_computername();
906 rec
->num_logical_processors
= get_logical_processor_count( NULL
);
907 rec
->num_processors
= get_processor_count();
908 rec
->total_physical_memory
= get_total_physical_memory();
909 if (!match_row( table
, row
, cond
, &status
)) free_row_values( table
, row
);
912 TRACE("created %u rows\n", row
);
913 table
->num_rows
= row
;
925 static struct dirstack
*alloc_dirstack( UINT size
)
927 struct dirstack
*dirstack
;
929 if (!(dirstack
= heap_alloc( sizeof(*dirstack
) ))) return NULL
;
930 if (!(dirstack
->dirs
= heap_alloc( sizeof(WCHAR
*) * size
)))
932 heap_free( dirstack
);
935 if (!(dirstack
->len_dirs
= heap_alloc( sizeof(UINT
) * size
)))
937 heap_free( dirstack
->dirs
);
938 heap_free( dirstack
);
941 dirstack
->num_dirs
= 0;
942 dirstack
->num_allocated
= size
;
946 static void clear_dirstack( struct dirstack
*dirstack
)
949 for (i
= 0; i
< dirstack
->num_dirs
; i
++) heap_free( dirstack
->dirs
[i
] );
950 dirstack
->num_dirs
= 0;
953 static void free_dirstack( struct dirstack
*dirstack
)
955 clear_dirstack( dirstack
);
956 heap_free( dirstack
->dirs
);
957 heap_free( dirstack
->len_dirs
);
958 heap_free( dirstack
);
961 static BOOL
push_dir( struct dirstack
*dirstack
, WCHAR
*dir
, UINT len
)
963 UINT size
, i
= dirstack
->num_dirs
;
965 if (!dir
) return FALSE
;
967 if (i
== dirstack
->num_allocated
)
972 size
= dirstack
->num_allocated
* 2;
973 if (!(tmp
= heap_realloc( dirstack
->dirs
, size
* sizeof(WCHAR
*) ))) return FALSE
;
974 dirstack
->dirs
= tmp
;
975 if (!(len_tmp
= heap_realloc( dirstack
->len_dirs
, size
* sizeof(UINT
) ))) return FALSE
;
976 dirstack
->len_dirs
= len_tmp
;
977 dirstack
->num_allocated
= size
;
979 dirstack
->dirs
[i
] = dir
;
980 dirstack
->len_dirs
[i
] = len
;
981 dirstack
->num_dirs
++;
985 static WCHAR
*pop_dir( struct dirstack
*dirstack
, UINT
*len
)
987 if (!dirstack
->num_dirs
)
992 dirstack
->num_dirs
--;
993 *len
= dirstack
->len_dirs
[dirstack
->num_dirs
];
994 return dirstack
->dirs
[dirstack
->num_dirs
];
997 static const WCHAR
*peek_dir( struct dirstack
*dirstack
)
999 if (!dirstack
->num_dirs
) return NULL
;
1000 return dirstack
->dirs
[dirstack
->num_dirs
- 1];
1003 static WCHAR
*build_glob( WCHAR drive
, const WCHAR
*path
, UINT len
)
1008 if (!(ret
= heap_alloc( (len
+ 6) * sizeof(WCHAR
) ))) return NULL
;
1014 memcpy( ret
+ i
, path
, len
* sizeof(WCHAR
) );
1023 static WCHAR
*build_name( WCHAR drive
, const WCHAR
*path
)
1025 UINT i
= 0, len
= 0;
1029 for (p
= path
; *p
; p
++)
1031 if (*p
== '\\') len
+= 2;
1034 if (!(ret
= heap_alloc( (len
+ 5) * sizeof(WCHAR
) ))) return NULL
;
1039 for (p
= path
; *p
; p
++)
1041 if (*p
!= '\\') ret
[i
++] = *p
;
1052 static WCHAR
*build_dirname( const WCHAR
*path
, UINT
*ret_len
)
1054 const WCHAR
*p
= path
, *start
;
1058 if (!isalphaW( p
[0] ) || p
[1] != ':' || p
[2] != '\\' || p
[3] != '\\' || !p
[4]) return NULL
;
1060 len
= strlenW( start
);
1061 p
= start
+ len
- 1;
1062 if (*p
== '\\') return NULL
;
1064 while (p
>= start
&& *p
!= '\\') { len
--; p
--; };
1065 while (p
>= start
&& *p
== '\\') { len
--; p
--; };
1067 if (!(ret
= heap_alloc( (len
+ 1) * sizeof(WCHAR
) ))) return NULL
;
1068 for (i
= 0, p
= start
; p
< start
+ len
; p
++)
1070 if (p
[0] == '\\' && p
[1] == '\\')
1082 static BOOL
seen_dir( struct dirstack
*dirstack
, const WCHAR
*path
)
1085 for (i
= 0; i
< dirstack
->num_dirs
; i
++) if (!strcmpW( dirstack
->dirs
[i
], path
)) return TRUE
;
1089 /* optimize queries of the form WHERE Name='...' [OR Name='...']* */
1090 static UINT
seed_dirs( struct dirstack
*dirstack
, const struct expr
*cond
, WCHAR root
, UINT
*count
)
1092 const struct expr
*left
, *right
;
1094 if (!cond
|| cond
->type
!= EXPR_COMPLEX
) return *count
= 0;
1096 left
= cond
->u
.expr
.left
;
1097 right
= cond
->u
.expr
.right
;
1098 if (cond
->u
.expr
.op
== OP_EQ
)
1102 const WCHAR
*str
= NULL
;
1104 if (left
->type
== EXPR_PROPVAL
&& right
->type
== EXPR_SVAL
&&
1105 !strcmpW( left
->u
.propval
->name
, prop_nameW
) &&
1106 toupperW( right
->u
.sval
[0] ) == toupperW( root
))
1108 str
= right
->u
.sval
;
1110 else if (left
->type
== EXPR_SVAL
&& right
->type
== EXPR_PROPVAL
&&
1111 !strcmpW( right
->u
.propval
->name
, prop_nameW
) &&
1112 toupperW( left
->u
.sval
[0] ) == toupperW( root
))
1116 if (str
&& (path
= build_dirname( str
, &len
)))
1118 if (seen_dir( dirstack
, path
))
1123 else if (push_dir( dirstack
, path
, len
)) return ++*count
;
1128 else if (cond
->u
.expr
.op
== OP_OR
)
1130 UINT left_count
= 0, right_count
= 0;
1132 if (!(seed_dirs( dirstack
, left
, root
, &left_count
))) return *count
= 0;
1133 if (!(seed_dirs( dirstack
, right
, root
, &right_count
))) return *count
= 0;
1134 return *count
+= left_count
+ right_count
;
1139 static WCHAR
*append_path( const WCHAR
*path
, const WCHAR
*segment
, UINT
*len
)
1141 UINT len_path
= 0, len_segment
= strlenW( segment
);
1145 if (path
) len_path
= strlenW( path
);
1146 if (!(ret
= heap_alloc( (len_path
+ len_segment
+ 2) * sizeof(WCHAR
) ))) return NULL
;
1147 if (path
&& len_path
)
1149 memcpy( ret
, path
, len_path
* sizeof(WCHAR
) );
1150 ret
[len_path
] = '\\';
1151 *len
+= len_path
+ 1;
1153 memcpy( ret
+ *len
, segment
, len_segment
* sizeof(WCHAR
) );
1154 *len
+= len_segment
;
1159 static WCHAR
*get_file_version( const WCHAR
*filename
)
1161 static const WCHAR slashW
[] = {'\\',0}, fmtW
[] = {'%','u','.','%','u','.','%','u','.','%','u',0};
1162 VS_FIXEDFILEINFO
*info
;
1167 if (!(ret
= heap_alloc( (4 * 5 + sizeof(fmtW
) / sizeof(fmtW
[0])) * sizeof(WCHAR
) ))) return NULL
;
1168 if (!(size
= GetFileVersionInfoSizeW( filename
, NULL
)) || !(block
= heap_alloc( size
)))
1173 if (!GetFileVersionInfoW( filename
, 0, size
, block
) ||
1174 !VerQueryValueW( block
, slashW
, (void **)&info
, &size
))
1180 sprintfW( ret
, fmtW
, info
->dwFileVersionMS
>> 16, info
->dwFileVersionMS
& 0xffff,
1181 info
->dwFileVersionLS
>> 16, info
->dwFileVersionLS
& 0xffff );
1186 static enum fill_status
fill_datafile( struct table
*table
, const struct expr
*cond
)
1188 static const WCHAR dotW
[] = {'.',0}, dotdotW
[] = {'.','.',0};
1189 struct record_datafile
*rec
;
1190 UINT i
, len
, row
= 0, offset
= 0, num_expected_rows
;
1191 WCHAR
*glob
= NULL
, *path
= NULL
, *new_path
, root
[] = {'A',':','\\',0};
1192 DWORD drives
= GetLogicalDrives();
1193 WIN32_FIND_DATAW data
;
1195 struct dirstack
*dirstack
= alloc_dirstack(2);
1196 enum fill_status status
= FILL_STATUS_UNFILTERED
;
1198 if (!resize_table( table
, 8, sizeof(*rec
) )) return FILL_STATUS_FAILED
;
1200 for (i
= 0; i
< sizeof(drives
); i
++)
1202 if (!(drives
& (1 << i
))) continue;
1205 if (GetDriveTypeW( root
) != DRIVE_FIXED
) continue;
1207 num_expected_rows
= 0;
1208 if (!seed_dirs( dirstack
, cond
, root
[0], &num_expected_rows
)) clear_dirstack( dirstack
);
1212 path
= pop_dir( dirstack
, &len
);
1213 if (!(glob
= build_glob( root
[0], path
, len
)))
1215 status
= FILL_STATUS_FAILED
;
1218 if ((handle
= FindFirstFileW( glob
, &data
)) != INVALID_HANDLE_VALUE
)
1222 if (!resize_table( table
, row
+ 1, sizeof(*rec
) ))
1224 status
= FILL_STATUS_FAILED
;
1227 if (!strcmpW( data
.cFileName
, dotW
) || !strcmpW( data
.cFileName
, dotdotW
)) continue;
1228 new_path
= append_path( path
, data
.cFileName
, &len
);
1230 if (data
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
1232 if (push_dir( dirstack
, new_path
, len
)) continue;
1233 heap_free( new_path
);
1234 status
= FILL_STATUS_FAILED
;
1237 rec
= (struct record_datafile
*)(table
->data
+ offset
);
1238 rec
->name
= build_name( root
[0], new_path
);
1239 rec
->version
= get_file_version( rec
->name
);
1240 if (!match_row( table
, row
, cond
, &status
))
1242 free_row_values( table
, row
);
1245 else if (num_expected_rows
&& row
== num_expected_rows
- 1)
1248 FindClose( handle
);
1249 status
= FILL_STATUS_FILTERED
;
1252 offset
+= sizeof(*rec
);
1255 while (FindNextFileW( handle
, &data
));
1256 FindClose( handle
);
1258 if (!peek_dir( dirstack
)) break;
1265 free_dirstack( dirstack
);
1269 TRACE("created %u rows\n", row
);
1270 table
->num_rows
= row
;
1274 static enum fill_status
fill_directory( struct table
*table
, const struct expr
*cond
)
1276 static const WCHAR dotW
[] = {'.',0}, dotdotW
[] = {'.','.',0};
1277 struct record_directory
*rec
;
1278 UINT i
, len
, row
= 0, offset
= 0, num_expected_rows
;
1279 WCHAR
*glob
= NULL
, *path
= NULL
, *new_path
, root
[] = {'A',':','\\',0};
1280 DWORD drives
= GetLogicalDrives();
1281 WIN32_FIND_DATAW data
;
1283 struct dirstack
*dirstack
;
1284 enum fill_status status
= FILL_STATUS_UNFILTERED
;
1286 if (!resize_table( table
, 4, sizeof(*rec
) )) return FILL_STATUS_FAILED
;
1288 dirstack
= alloc_dirstack(2);
1290 for (i
= 0; i
< sizeof(drives
); i
++)
1292 if (!(drives
& (1 << i
))) continue;
1295 if (GetDriveTypeW( root
) != DRIVE_FIXED
) continue;
1297 num_expected_rows
= 0;
1298 if (!seed_dirs( dirstack
, cond
, root
[0], &num_expected_rows
)) clear_dirstack( dirstack
);
1302 path
= pop_dir( dirstack
, &len
);
1303 if (!(glob
= build_glob( root
[0], path
, len
)))
1305 status
= FILL_STATUS_FAILED
;
1308 if ((handle
= FindFirstFileW( glob
, &data
)) != INVALID_HANDLE_VALUE
)
1312 if (!resize_table( table
, row
+ 1, sizeof(*rec
) ))
1314 FindClose( handle
);
1315 status
= FILL_STATUS_FAILED
;
1318 if (!(data
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) ||
1319 !strcmpW( data
.cFileName
, dotW
) || !strcmpW( data
.cFileName
, dotdotW
))
1322 new_path
= append_path( path
, data
.cFileName
, &len
);
1323 if (!(push_dir( dirstack
, new_path
, len
)))
1325 heap_free( new_path
);
1326 FindClose( handle
);
1327 status
= FILL_STATUS_FAILED
;
1330 rec
= (struct record_directory
*)(table
->data
+ offset
);
1331 rec
->accessmask
= FILE_ALL_ACCESS
;
1332 rec
->name
= build_name( root
[0], new_path
);
1333 if (!match_row( table
, row
, cond
, &status
))
1335 free_row_values( table
, row
);
1338 else if (num_expected_rows
&& row
== num_expected_rows
- 1)
1341 FindClose( handle
);
1342 status
= FILL_STATUS_FILTERED
;
1345 offset
+= sizeof(*rec
);
1348 while (FindNextFileW( handle
, &data
));
1349 FindClose( handle
);
1351 if (!peek_dir( dirstack
)) break;
1358 free_dirstack( dirstack
);
1362 TRACE("created %u rows\n", row
);
1363 table
->num_rows
= row
;
1367 static WCHAR
*get_filesystem( const WCHAR
*root
)
1369 static const WCHAR ntfsW
[] = {'N','T','F','S',0};
1370 WCHAR buffer
[MAX_PATH
+ 1];
1372 if (GetVolumeInformationW( root
, NULL
, 0, NULL
, NULL
, NULL
, buffer
, MAX_PATH
+ 1 ))
1373 return heap_strdupW( buffer
);
1374 return heap_strdupW( ntfsW
);
1377 static UINT64
get_freespace( const WCHAR
*dir
, UINT64
*disksize
)
1379 WCHAR root
[] = {'\\','\\','.','\\','A',':',0};
1380 ULARGE_INTEGER free
;
1381 DISK_GEOMETRY_EX info
;
1384 free
.QuadPart
= 512 * 1024 * 1024;
1385 GetDiskFreeSpaceExW( dir
, NULL
, NULL
, &free
);
1388 handle
= CreateFileW( root
, GENERIC_READ
, FILE_SHARE_READ
|FILE_SHARE_WRITE
, NULL
, OPEN_EXISTING
, 0, 0 );
1389 if (handle
!= INVALID_HANDLE_VALUE
)
1391 if (DeviceIoControl( handle
, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX
, NULL
, 0, &info
, sizeof(info
), NULL
, NULL
))
1392 *disksize
= info
.DiskSize
.QuadPart
;
1393 CloseHandle( handle
);
1395 return free
.QuadPart
;
1398 static enum fill_status
fill_diskpartition( struct table
*table
, const struct expr
*cond
)
1400 static const WCHAR fmtW
[] =
1401 {'D','i','s','k',' ','#','%','u',',',' ','P','a','r','t','i','t','i','o','n',' ','#','0',0};
1402 WCHAR device_id
[32], root
[] = {'A',':','\\',0};
1403 struct record_diskpartition
*rec
;
1404 UINT i
, row
= 0, offset
= 0, type
, index
= 0;
1405 UINT64 size
= 1024 * 1024 * 1024;
1406 DWORD drives
= GetLogicalDrives();
1407 enum fill_status status
= FILL_STATUS_UNFILTERED
;
1409 if (!resize_table( table
, 4, sizeof(*rec
) )) return FILL_STATUS_FAILED
;
1411 for (i
= 0; i
< sizeof(drives
); i
++)
1413 if (drives
& (1 << i
))
1416 type
= GetDriveTypeW( root
);
1417 if (type
!= DRIVE_FIXED
&& type
!= DRIVE_REMOVABLE
)
1420 if (!resize_table( table
, row
+ 1, sizeof(*rec
) )) return FILL_STATUS_FAILED
;
1422 rec
= (struct record_diskpartition
*)(table
->data
+ offset
);
1423 rec
->bootable
= (i
== 2) ? -1 : 0;
1424 rec
->bootpartition
= (i
== 2) ? -1 : 0;
1425 sprintfW( device_id
, fmtW
, index
);
1426 rec
->device_id
= heap_strdupW( device_id
);
1427 rec
->diskindex
= index
;
1429 rec
->pnpdevice_id
= heap_strdupW( device_id
);
1430 get_freespace( root
, &size
);
1432 rec
->startingoffset
= 0;
1433 rec
->type
= get_filesystem( root
);
1434 if (!match_row( table
, row
, cond
, &status
))
1436 free_row_values( table
, row
);
1439 offset
+= sizeof(*rec
);
1444 TRACE("created %u rows\n", row
);
1445 table
->num_rows
= row
;
1449 static enum fill_status
fill_logicaldisk( struct table
*table
, const struct expr
*cond
)
1451 static const WCHAR fmtW
[] = {'%','c',':',0};
1452 WCHAR device_id
[3], root
[] = {'A',':','\\',0};
1453 struct record_logicaldisk
*rec
;
1454 UINT i
, row
= 0, offset
= 0, type
;
1455 UINT64 size
= 1024 * 1024 * 1024;
1456 DWORD drives
= GetLogicalDrives();
1457 enum fill_status status
= FILL_STATUS_UNFILTERED
;
1459 if (!resize_table( table
, 4, sizeof(*rec
) )) return FILL_STATUS_FAILED
;
1461 for (i
= 0; i
< sizeof(drives
); i
++)
1463 if (drives
& (1 << i
))
1466 type
= GetDriveTypeW( root
);
1467 if (type
!= DRIVE_FIXED
&& type
!= DRIVE_CDROM
&& type
!= DRIVE_REMOVABLE
)
1470 if (!resize_table( table
, row
+ 1, sizeof(*rec
) )) return FILL_STATUS_FAILED
;
1472 rec
= (struct record_logicaldisk
*)(table
->data
+ offset
);
1473 sprintfW( device_id
, fmtW
, 'A' + i
);
1474 rec
->device_id
= heap_strdupW( device_id
);
1475 rec
->drivetype
= type
;
1476 rec
->filesystem
= get_filesystem( root
);
1477 rec
->freespace
= get_freespace( root
, &size
);
1478 rec
->name
= heap_strdupW( device_id
);
1480 if (!match_row( table
, row
, cond
, &status
))
1482 free_row_values( table
, row
);
1485 offset
+= sizeof(*rec
);
1489 TRACE("created %u rows\n", row
);
1490 table
->num_rows
= row
;
1494 static UINT16
get_connection_status( IF_OPER_STATUS status
)
1498 case IfOperStatusDown
:
1499 return 0; /* Disconnected */
1500 case IfOperStatusUp
:
1501 return 2; /* Connected */
1503 ERR("unhandled status %u\n", status
);
1508 static WCHAR
*get_mac_address( const BYTE
*addr
, DWORD len
)
1510 static const WCHAR fmtW
[] =
1511 {'%','0','2','x',':','%','0','2','x',':','%','0','2','x',':',
1512 '%','0','2','x',':','%','0','2','x',':','%','0','2','x',0};
1515 if (len
!= 6 || !(ret
= heap_alloc( 18 * sizeof(WCHAR
) ))) return NULL
;
1516 sprintfW( ret
, fmtW
, addr
[0], addr
[1], addr
[2], addr
[3], addr
[4], addr
[5] );
1519 static const WCHAR
*get_adaptertype( DWORD type
, int *physical
)
1521 static const WCHAR ethernetW
[] = {'E','t','h','e','r','n','e','t',' ','8','0','2','.','3',0};
1522 static const WCHAR wirelessW
[] = {'W','i','r','e','l','e','s','s',0};
1523 static const WCHAR firewireW
[] = {'1','3','9','4',0};
1524 static const WCHAR tunnelW
[] = {'T','u','n','n','e','l',0};
1528 case IF_TYPE_ETHERNET_CSMACD
: *physical
= -1; return ethernetW
;
1529 case IF_TYPE_IEEE80211
: *physical
= -1; return wirelessW
;
1530 case IF_TYPE_IEEE1394
: *physical
= -1; return firewireW
;
1531 case IF_TYPE_TUNNEL
: *physical
= 0; return tunnelW
;
1532 default: *physical
= 0; return NULL
;
1536 static enum fill_status
fill_networkadapter( struct table
*table
, const struct expr
*cond
)
1538 static const WCHAR fmtW
[] = {'%','u',0};
1539 WCHAR device_id
[11];
1540 struct record_networkadapter
*rec
;
1541 IP_ADAPTER_ADDRESSES
*aa
, *buffer
;
1542 UINT row
= 0, offset
= 0, count
= 0;
1543 DWORD size
= 0, ret
;
1545 enum fill_status status
= FILL_STATUS_UNFILTERED
;
1547 ret
= GetAdaptersAddresses( AF_UNSPEC
, 0, NULL
, NULL
, &size
);
1548 if (ret
!= ERROR_BUFFER_OVERFLOW
) return FILL_STATUS_FAILED
;
1550 if (!(buffer
= heap_alloc( size
))) return FILL_STATUS_FAILED
;
1551 if (GetAdaptersAddresses( AF_UNSPEC
, 0, NULL
, buffer
, &size
))
1553 heap_free( buffer
);
1554 return FILL_STATUS_FAILED
;
1556 for (aa
= buffer
; aa
; aa
= aa
->Next
) count
++;
1557 if (!resize_table( table
, count
, sizeof(*rec
) ))
1559 heap_free( buffer
);
1560 return FILL_STATUS_FAILED
;
1562 for (aa
= buffer
; aa
; aa
= aa
->Next
)
1564 rec
= (struct record_networkadapter
*)(table
->data
+ offset
);
1565 sprintfW( device_id
, fmtW
, aa
->u
.s
.IfIndex
);
1566 rec
->adaptertype
= get_adaptertype( aa
->IfType
, &physical
);
1567 rec
->device_id
= heap_strdupW( device_id
);
1568 rec
->interface_index
= aa
->u
.s
.IfIndex
;
1569 rec
->mac_address
= get_mac_address( aa
->PhysicalAddress
, aa
->PhysicalAddressLength
);
1570 rec
->manufacturer
= compsys_manufacturerW
;
1571 rec
->netconnection_status
= get_connection_status( aa
->OperStatus
);
1572 rec
->physicaladapter
= physical
;
1573 rec
->pnpdevice_id
= networkadapter_pnpdeviceidW
;
1574 rec
->speed
= 1000000;
1575 if (!match_row( table
, row
, cond
, &status
))
1577 free_row_values( table
, row
);
1580 offset
+= sizeof(*rec
);
1583 TRACE("created %u rows\n", row
);
1584 table
->num_rows
= row
;
1586 heap_free( buffer
);
1590 static WCHAR
*get_cmdline( DWORD process_id
)
1592 if (process_id
== GetCurrentProcessId()) return heap_strdupW( GetCommandLineW() );
1593 return NULL
; /* FIXME handle different process case */
1596 static enum fill_status
fill_process( struct table
*table
, const struct expr
*cond
)
1598 static const WCHAR fmtW
[] = {'%','u',0};
1600 struct record_process
*rec
;
1601 PROCESSENTRY32W entry
;
1603 enum fill_status status
= FILL_STATUS_FAILED
;
1604 UINT row
= 0, offset
= 0;
1606 snap
= CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS
, 0 );
1607 if (snap
== INVALID_HANDLE_VALUE
) return FILL_STATUS_FAILED
;
1609 entry
.dwSize
= sizeof(entry
);
1610 if (!Process32FirstW( snap
, &entry
)) goto done
;
1611 if (!resize_table( table
, 8, sizeof(*rec
) )) goto done
;
1615 if (!resize_table( table
, row
+ 1, sizeof(*rec
) )) goto done
;
1617 rec
= (struct record_process
*)(table
->data
+ offset
);
1618 rec
->caption
= heap_strdupW( entry
.szExeFile
);
1619 rec
->commandline
= get_cmdline( entry
.th32ProcessID
);
1620 rec
->description
= heap_strdupW( entry
.szExeFile
);
1621 sprintfW( handle
, fmtW
, entry
.th32ProcessID
);
1622 rec
->handle
= heap_strdupW( handle
);
1623 rec
->name
= heap_strdupW( entry
.szExeFile
);
1624 rec
->process_id
= entry
.th32ProcessID
;
1625 rec
->pprocess_id
= entry
.th32ParentProcessID
;
1626 rec
->thread_count
= entry
.cntThreads
;
1627 rec
->get_owner
= process_get_owner
;
1628 if (!match_row( table
, row
, cond
, &status
))
1630 free_row_values( table
, row
);
1633 offset
+= sizeof(*rec
);
1635 } while (Process32NextW( snap
, &entry
));
1637 TRACE("created %u rows\n", row
);
1638 table
->num_rows
= row
;
1639 status
= FILL_STATUS_UNFILTERED
;
1642 CloseHandle( snap
);
1646 static inline void do_cpuid( unsigned int ax
, unsigned int *p
)
1649 __asm__("pushl %%ebx\n\t"
1651 "movl %%ebx, %%esi\n\t"
1653 : "=a" (p
[0]), "=S" (p
[1]), "=c" (p
[2]), "=d" (p
[3])
1658 static void get_processor_id( WCHAR
*processor_id
)
1660 static const WCHAR fmtW
[] = {'%','0','8','X','%','0','8','X',0};
1661 unsigned int regs
[4] = {0, 0, 0, 0};
1663 do_cpuid( 1, regs
);
1664 sprintfW( processor_id
, fmtW
, regs
[3], regs
[0] );
1666 static void regs_to_str( unsigned int *regs
, unsigned int len
, WCHAR
*buffer
)
1669 unsigned char *p
= (unsigned char *)regs
;
1671 for (i
= 0; i
< len
; i
++) { buffer
[i
] = *p
++; }
1674 static void get_processor_manufacturer( WCHAR
*manufacturer
)
1676 unsigned int tmp
, regs
[4] = {0, 0, 0, 0};
1678 do_cpuid( 0, regs
);
1679 tmp
= regs
[2]; /* swap edx and ecx */
1683 regs_to_str( regs
+ 1, 12, manufacturer
);
1685 static void get_processor_name( WCHAR
*name
)
1687 unsigned int regs
[4] = {0, 0, 0, 0};
1689 do_cpuid( 0x80000000, regs
);
1690 if (regs
[0] >= 0x80000004)
1692 do_cpuid( 0x80000002, regs
);
1693 regs_to_str( regs
, 16, name
);
1694 do_cpuid( 0x80000003, regs
);
1695 regs_to_str( regs
, 16, name
+ 16 );
1696 do_cpuid( 0x80000004, regs
);
1697 regs_to_str( regs
, 16, name
+ 32 );
1700 static UINT
get_processor_maxclockspeed( void )
1702 PROCESSOR_POWER_INFORMATION
*info
;
1703 UINT ret
= 1000, size
= get_processor_count() * sizeof(PROCESSOR_POWER_INFORMATION
);
1706 if ((info
= heap_alloc( size
)))
1708 status
= NtPowerInformation( ProcessorInformation
, NULL
, 0, info
, size
);
1709 if (!status
) ret
= info
[0].MaxMhz
;
1714 static const WCHAR
*get_osarchitecture(void)
1717 GetNativeSystemInfo( &info
);
1718 if (info
.u
.s
.wProcessorArchitecture
== PROCESSOR_ARCHITECTURE_AMD64
) return os_64bitW
;
1722 static enum fill_status
fill_processor( struct table
*table
, const struct expr
*cond
)
1724 static const WCHAR fmtW
[] = {'C','P','U','%','u',0};
1725 WCHAR device_id
[14], processor_id
[17], manufacturer
[13], name
[49] = {0};
1726 struct record_processor
*rec
;
1727 UINT i
, offset
= 0, maxclockspeed
, num_cores
, num_logical_processors
, count
= get_processor_count();
1728 enum fill_status status
= FILL_STATUS_UNFILTERED
;
1730 if (!resize_table( table
, count
, sizeof(*rec
) )) return FILL_STATUS_FAILED
;
1732 get_processor_id( processor_id
);
1733 get_processor_manufacturer( manufacturer
);
1734 get_processor_name( name
);
1736 maxclockspeed
= get_processor_maxclockspeed();
1737 num_logical_processors
= get_logical_processor_count( &num_cores
) / count
;
1740 for (i
= 0; i
< count
; i
++)
1742 rec
= (struct record_processor
*)(table
->data
+ offset
);
1743 rec
->addresswidth
= get_osarchitecture() == os_32bitW
? 32 : 64;
1744 rec
->cpu_status
= 1; /* CPU Enabled */
1745 sprintfW( device_id
, fmtW
, i
);
1746 rec
->device_id
= heap_strdupW( device_id
);
1747 rec
->family
= 2; /* Unknown */
1748 rec
->manufacturer
= heap_strdupW( manufacturer
);
1749 rec
->maxclockspeed
= maxclockspeed
;
1750 rec
->name
= heap_strdupW( name
);
1751 rec
->num_cores
= num_cores
;
1752 rec
->num_logical_processors
= num_logical_processors
;
1753 rec
->processor_id
= heap_strdupW( processor_id
);
1754 rec
->unique_id
= NULL
;
1755 if (!match_row( table
, i
, cond
, &status
))
1757 free_row_values( table
, i
);
1760 offset
+= sizeof(*rec
);
1763 TRACE("created %u rows\n", count
);
1764 table
->num_rows
= count
;
1768 static WCHAR
*get_lastbootuptime(void)
1770 static const WCHAR fmtW
[] =
1771 {'%','0','4','u','%','0','2','u','%','0','2','u','%','0','2','u','%','0','2','u','%','0','2','u',
1772 '.','%','0','6','u','+','0','0','0',0};
1773 SYSTEM_TIMEOFDAY_INFORMATION ti
;
1777 if (!(ret
= heap_alloc( 26 * sizeof(WCHAR
) ))) return NULL
;
1779 NtQuerySystemInformation( SystemTimeOfDayInformation
, &ti
, sizeof(ti
), NULL
);
1780 RtlTimeToTimeFields( &ti
.liKeBootTime
, &tf
);
1781 sprintfW( ret
, fmtW
, tf
.Year
, tf
.Month
, tf
.Day
, tf
.Hour
, tf
.Minute
, tf
.Second
, tf
.Milliseconds
* 1000 );
1784 static WCHAR
*get_localdatetime(void)
1786 static const WCHAR fmtW
[] =
1787 {'%','0','4','u','%','0','2','u','%','0','2','u','%','0','2','u','%','0','2','u','%','0','2','u',
1788 '.','%','0','6','u','%','+','0','3','d',0};
1789 TIME_ZONE_INFORMATION tzi
;
1795 Status
= GetTimeZoneInformation(&tzi
);
1797 if(Status
== TIME_ZONE_ID_INVALID
) return NULL
;
1799 if(Status
== TIME_ZONE_ID_DAYLIGHT
)
1800 Bias
+= tzi
.DaylightBias
;
1802 Bias
+= tzi
.StandardBias
;
1803 if (!(ret
= heap_alloc( 26 * sizeof(WCHAR
) ))) return NULL
;
1806 sprintfW( ret
, fmtW
, st
.wYear
, st
.wMonth
, st
.wDay
, st
.wHour
, st
.wMinute
, st
.wSecond
, st
.wMilliseconds
* 1000, -Bias
);
1809 static WCHAR
*get_systemdirectory(void)
1814 if (!(ret
= heap_alloc( MAX_PATH
* sizeof(WCHAR
) ))) return NULL
;
1815 Wow64DisableWow64FsRedirection( &redir
);
1816 GetSystemDirectoryW( ret
, MAX_PATH
);
1817 Wow64RevertWow64FsRedirection( redir
);
1820 static WCHAR
*get_codeset(void)
1822 static const WCHAR fmtW
[] = {'%','u',0};
1823 WCHAR
*ret
= heap_alloc( 11 * sizeof(WCHAR
) );
1824 if (ret
) sprintfW( ret
, fmtW
, GetACP() );
1827 static WCHAR
*get_countrycode(void)
1829 WCHAR
*ret
= heap_alloc( 6 * sizeof(WCHAR
) );
1830 if (ret
) GetLocaleInfoW( LOCALE_SYSTEM_DEFAULT
, LOCALE_ICOUNTRY
, ret
, 6 );
1833 static WCHAR
*get_locale(void)
1835 WCHAR
*ret
= heap_alloc( 5 * sizeof(WCHAR
) );
1836 if (ret
) GetLocaleInfoW( LOCALE_SYSTEM_DEFAULT
, LOCALE_ILANGUAGE
, ret
, 5 );
1840 static enum fill_status
fill_os( struct table
*table
, const struct expr
*cond
)
1842 struct record_operatingsystem
*rec
;
1843 enum fill_status status
= FILL_STATUS_UNFILTERED
;
1846 if (!resize_table( table
, 1, sizeof(*rec
) )) return FILL_STATUS_FAILED
;
1848 rec
= (struct record_operatingsystem
*)table
->data
;
1849 rec
->caption
= os_captionW
;
1850 rec
->codeset
= get_codeset();
1851 rec
->countrycode
= get_countrycode();
1852 rec
->csdversion
= os_csdversionW
;
1853 rec
->lastbootuptime
= get_lastbootuptime();
1854 rec
->localdatetime
= get_localdatetime();
1855 rec
->locale
= get_locale();
1856 rec
->osarchitecture
= get_osarchitecture();
1857 rec
->oslanguage
= GetSystemDefaultLangID();
1858 rec
->osproductsuite
= 2461140; /* Windows XP Professional */
1859 rec
->ostype
= 18; /* WINNT */
1860 rec
->servicepackmajor
= 3;
1861 rec
->servicepackminor
= 0;
1862 rec
->suitemask
= 272; /* Single User + Terminal */
1863 rec
->systemdirectory
= get_systemdirectory();
1864 rec
->version
= os_versionW
;
1865 if (!match_row( table
, row
, cond
, &status
)) free_row_values( table
, row
);
1868 TRACE("created %u rows\n", row
);
1869 table
->num_rows
= row
;
1873 static const WCHAR
*get_service_type( DWORD type
)
1875 static const WCHAR filesystem_driverW
[] =
1876 {'F','i','l','e',' ','S','y','s','t','e','m',' ','D','r','i','v','e','r',0};
1877 static const WCHAR kernel_driverW
[] =
1878 {'K','e','r','n','e','l',' ','D','r','i','v','e','r',0};
1879 static const WCHAR own_processW
[] =
1880 {'O','w','n',' ','P','r','o','c','e','s','s',0};
1881 static const WCHAR share_processW
[] =
1882 {'S','h','a','r','e',' ','P','r','o','c','e','s','s',0};
1884 if (type
& SERVICE_KERNEL_DRIVER
) return kernel_driverW
;
1885 else if (type
& SERVICE_FILE_SYSTEM_DRIVER
) return filesystem_driverW
;
1886 else if (type
& SERVICE_WIN32_OWN_PROCESS
) return own_processW
;
1887 else if (type
& SERVICE_WIN32_SHARE_PROCESS
) return share_processW
;
1888 else ERR("unhandled type 0x%08x\n", type
);
1891 static const WCHAR
*get_service_state( DWORD state
)
1893 static const WCHAR runningW
[] =
1894 {'R','u','n','n','i','n','g',0};
1895 static const WCHAR start_pendingW
[] =
1896 {'S','t','a','r','t',' ','P','e','n','d','i','n','g',0};
1897 static const WCHAR stop_pendingW
[] =
1898 {'S','t','o','p',' ','P','e','n','d','i','n','g',0};
1899 static const WCHAR stoppedW
[] =
1900 {'S','t','o','p','p','e','d',0};
1901 static const WCHAR unknownW
[] =
1902 {'U','n','k','n','o','w','n',0};
1906 case SERVICE_STOPPED
: return stoppedW
;
1907 case SERVICE_START_PENDING
: return start_pendingW
;
1908 case SERVICE_STOP_PENDING
: return stop_pendingW
;
1909 case SERVICE_RUNNING
: return runningW
;
1911 ERR("unknown state %u\n", state
);
1915 static const WCHAR
*get_service_startmode( DWORD mode
)
1917 static const WCHAR bootW
[] = {'B','o','o','t',0};
1918 static const WCHAR systemW
[] = {'S','y','s','t','e','m',0};
1919 static const WCHAR autoW
[] = {'A','u','t','o',0};
1920 static const WCHAR manualW
[] = {'M','a','n','u','a','l',0};
1921 static const WCHAR disabledW
[] = {'D','i','s','a','b','l','e','d',0};
1922 static const WCHAR unknownW
[] = {'U','n','k','n','o','w','n',0};
1926 case SERVICE_BOOT_START
: return bootW
;
1927 case SERVICE_SYSTEM_START
: return systemW
;
1928 case SERVICE_AUTO_START
: return autoW
;
1929 case SERVICE_DEMAND_START
: return manualW
;
1930 case SERVICE_DISABLED
: return disabledW
;
1932 ERR("unknown mode 0x%x\n", mode
);
1936 static QUERY_SERVICE_CONFIGW
*query_service_config( SC_HANDLE manager
, const WCHAR
*name
)
1938 QUERY_SERVICE_CONFIGW
*config
= NULL
;
1942 if (!(service
= OpenServiceW( manager
, name
, SERVICE_QUERY_CONFIG
))) return NULL
;
1943 QueryServiceConfigW( service
, NULL
, 0, &size
);
1944 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER
) goto done
;
1945 if (!(config
= heap_alloc( size
))) goto done
;
1946 if (QueryServiceConfigW( service
, config
, size
, &size
)) goto done
;
1947 heap_free( config
);
1951 CloseServiceHandle( service
);
1955 static enum fill_status
fill_service( struct table
*table
, const struct expr
*cond
)
1957 struct record_service
*rec
;
1959 ENUM_SERVICE_STATUS_PROCESSW
*tmp
, *services
= NULL
;
1960 SERVICE_STATUS_PROCESS
*status
;
1961 WCHAR sysnameW
[MAX_COMPUTERNAME_LENGTH
+ 1];
1962 DWORD len
= sizeof(sysnameW
) / sizeof(sysnameW
[0]);
1963 UINT i
, row
= 0, offset
= 0, size
= 256, needed
, count
;
1964 enum fill_status fill_status
= FILL_STATUS_FAILED
;
1967 if (!(manager
= OpenSCManagerW( NULL
, NULL
, SC_MANAGER_ENUMERATE_SERVICE
))) return FILL_STATUS_FAILED
;
1968 if (!(services
= heap_alloc( size
))) goto done
;
1970 ret
= EnumServicesStatusExW( manager
, SC_ENUM_PROCESS_INFO
, SERVICE_TYPE_ALL
,
1971 SERVICE_STATE_ALL
, (BYTE
*)services
, size
, &needed
,
1972 &count
, NULL
, NULL
);
1975 if (GetLastError() != ERROR_MORE_DATA
) goto done
;
1977 if (!(tmp
= heap_realloc( services
, size
))) goto done
;
1979 ret
= EnumServicesStatusExW( manager
, SC_ENUM_PROCESS_INFO
, SERVICE_TYPE_ALL
,
1980 SERVICE_STATE_ALL
, (BYTE
*)services
, size
, &needed
,
1981 &count
, NULL
, NULL
);
1982 if (!ret
) goto done
;
1984 if (!resize_table( table
, count
, sizeof(*rec
) )) goto done
;
1986 GetComputerNameW( sysnameW
, &len
);
1987 fill_status
= FILL_STATUS_UNFILTERED
;
1989 for (i
= 0; i
< count
; i
++)
1991 QUERY_SERVICE_CONFIGW
*config
;
1993 if (!(config
= query_service_config( manager
, services
[i
].lpServiceName
))) continue;
1995 status
= &services
[i
].ServiceStatusProcess
;
1996 rec
= (struct record_service
*)(table
->data
+ offset
);
1997 rec
->accept_pause
= (status
->dwControlsAccepted
& SERVICE_ACCEPT_PAUSE_CONTINUE
) ? -1 : 0;
1998 rec
->accept_stop
= (status
->dwControlsAccepted
& SERVICE_ACCEPT_STOP
) ? -1 : 0;
1999 rec
->displayname
= heap_strdupW( services
[i
].lpDisplayName
);
2000 rec
->name
= heap_strdupW( services
[i
].lpServiceName
);
2001 rec
->process_id
= status
->dwProcessId
;
2002 rec
->servicetype
= get_service_type( status
->dwServiceType
);
2003 rec
->startmode
= get_service_startmode( config
->dwStartType
);
2004 rec
->state
= get_service_state( status
->dwCurrentState
);
2005 rec
->systemname
= heap_strdupW( sysnameW
);
2006 rec
->pause_service
= service_pause_service
;
2007 rec
->resume_service
= service_resume_service
;
2008 rec
->start_service
= service_start_service
;
2009 rec
->stop_service
= service_stop_service
;
2010 heap_free( config
);
2011 if (!match_row( table
, row
, cond
, &fill_status
))
2013 free_row_values( table
, row
);
2016 offset
+= sizeof(*rec
);
2020 TRACE("created %u rows\n", row
);
2021 table
->num_rows
= row
;
2024 CloseServiceHandle( manager
);
2025 heap_free( services
);
2029 static UINT32
get_bits_per_pixel( UINT
*hres
, UINT
*vres
)
2031 HDC hdc
= GetDC( NULL
);
2034 if (!hdc
) return 32;
2035 ret
= GetDeviceCaps( hdc
, BITSPIXEL
);
2036 *hres
= GetDeviceCaps( hdc
, HORZRES
);
2037 *vres
= GetDeviceCaps( hdc
, VERTRES
);
2038 ReleaseDC( NULL
, hdc
);
2041 static WCHAR
*get_pnpdeviceid( DXGI_ADAPTER_DESC
*desc
)
2043 static const WCHAR fmtW
[] =
2044 {'P','C','I','\\','V','E','N','_','%','0','4','X','&','D','E','V','_','%','0','4','X',
2045 '&','S','U','B','S','Y','S','_','%','0','8','X','&','R','E','V','_','%','0','2','X','\\',
2046 '0','&','D','E','A','D','B','E','E','F','&','0','&','D','E','A','D',0};
2049 if (!(ret
= heap_alloc( sizeof(fmtW
) + 2 * sizeof(WCHAR
) ))) return NULL
;
2050 sprintfW( ret
, fmtW
, desc
->VendorId
, desc
->DeviceId
, desc
->SubSysId
, desc
->Revision
);
2054 static enum fill_status
fill_videocontroller( struct table
*table
, const struct expr
*cond
)
2057 struct record_videocontroller
*rec
;
2059 IDXGIFactory
*factory
= NULL
;
2060 IDXGIAdapter
*adapter
= NULL
;
2061 DXGI_ADAPTER_DESC desc
;
2062 UINT hres
= 1024, vres
= 768, vidmem
= 512 * 1024 * 1024;
2063 const WCHAR
*name
= videocontroller_deviceidW
;
2064 enum fill_status status
= FILL_STATUS_UNFILTERED
;
2067 if (!resize_table( table
, 1, sizeof(*rec
) )) return FILL_STATUS_FAILED
;
2069 memset (&desc
, 0, sizeof(desc
));
2070 hr
= CreateDXGIFactory( &IID_IDXGIFactory
, (void **)&factory
);
2071 if (FAILED(hr
)) goto done
;
2073 hr
= IDXGIFactory_EnumAdapters( factory
, 0, &adapter
);
2074 if (FAILED(hr
)) goto done
;
2076 hr
= IDXGIAdapter_GetDesc( adapter
, &desc
);
2079 vidmem
= desc
.DedicatedVideoMemory
;
2080 name
= desc
.Description
;
2084 rec
= (struct record_videocontroller
*)table
->data
;
2085 rec
->adapter_dactype
= videocontroller_dactypeW
;
2086 rec
->adapter_ram
= vidmem
;
2087 rec
->current_bitsperpixel
= get_bits_per_pixel( &hres
, &vres
);
2088 rec
->current_horizontalres
= hres
;
2089 rec
->current_verticalres
= vres
;
2090 rec
->description
= heap_strdupW( name
);
2091 rec
->device_id
= videocontroller_deviceidW
;
2092 rec
->name
= heap_strdupW( name
);
2093 rec
->pnpdevice_id
= get_pnpdeviceid( &desc
);
2094 if (!match_row( table
, row
, cond
, &status
)) free_row_values( table
, row
);
2097 TRACE("created %u rows\n", row
);
2098 table
->num_rows
= row
;
2100 if (adapter
) IDXGIAdapter_Release( adapter
);
2101 if (factory
) IDXGIFactory_Release( factory
);
2105 static struct table builtin_classes
[] =
2107 { class_baseboardW
, SIZEOF(col_baseboard
), col_baseboard
, SIZEOF(data_baseboard
), 0, (BYTE
*)data_baseboard
},
2108 { class_biosW
, SIZEOF(col_bios
), col_bios
, SIZEOF(data_bios
), 0, (BYTE
*)data_bios
},
2109 { class_cdromdriveW
, SIZEOF(col_cdromdrive
), col_cdromdrive
, 0, 0, NULL
, fill_cdromdrive
},
2110 { class_compsysW
, SIZEOF(col_compsys
), col_compsys
, 0, 0, NULL
, fill_compsys
},
2111 { class_datafileW
, SIZEOF(col_datafile
), col_datafile
, 0, 0, NULL
, fill_datafile
},
2112 { class_directoryW
, SIZEOF(col_directory
), col_directory
, 0, 0, NULL
, fill_directory
},
2113 { class_diskdriveW
, SIZEOF(col_diskdrive
), col_diskdrive
, SIZEOF(data_diskdrive
), 0, (BYTE
*)data_diskdrive
},
2114 { class_diskpartitionW
, SIZEOF(col_diskpartition
), col_diskpartition
, 0, 0, NULL
, fill_diskpartition
},
2115 { class_logicaldiskW
, SIZEOF(col_logicaldisk
), col_logicaldisk
, 0, 0, NULL
, fill_logicaldisk
},
2116 { class_logicaldisk2W
, SIZEOF(col_logicaldisk
), col_logicaldisk
, 0, 0, NULL
, fill_logicaldisk
},
2117 { class_networkadapterW
, SIZEOF(col_networkadapter
), col_networkadapter
, 0, 0, NULL
, fill_networkadapter
},
2118 { class_osW
, SIZEOF(col_os
), col_os
, 0, 0, NULL
, fill_os
},
2119 { class_paramsW
, SIZEOF(col_param
), col_param
, SIZEOF(data_param
), 0, (BYTE
*)data_param
},
2120 { class_processW
, SIZEOF(col_process
), col_process
, 0, 0, NULL
, fill_process
},
2121 { class_processorW
, SIZEOF(col_processor
), col_processor
, 0, 0, NULL
, fill_processor
},
2122 { class_qualifiersW
, SIZEOF(col_qualifier
), col_qualifier
, SIZEOF(data_qualifier
), 0, (BYTE
*)data_qualifier
},
2123 { class_serviceW
, SIZEOF(col_service
), col_service
, 0, 0, NULL
, fill_service
},
2124 { class_sounddeviceW
, SIZEOF(col_sounddevice
), col_sounddevice
, SIZEOF(data_sounddevice
), 0, (BYTE
*)data_sounddevice
},
2125 { class_stdregprovW
, SIZEOF(col_stdregprov
), col_stdregprov
, SIZEOF(data_stdregprov
), 0, (BYTE
*)data_stdregprov
},
2126 { class_videocontrollerW
, SIZEOF(col_videocontroller
), col_videocontroller
, 0, 0, NULL
, fill_videocontroller
}
2129 void init_table_list( void )
2131 static struct list tables
= LIST_INIT( tables
);
2134 for (i
= 0; i
< SIZEOF(builtin_classes
); i
++) list_add_tail( &tables
, &builtin_classes
[i
].entry
);
2135 table_list
= &tables
;