?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
makefiles: Explicitly create destination dirs when installing symlinks.
[wine/zf.git] / dlls / ntdll / version.c
blob46715575225a977e68602b243f132e218a0bc05a
1 /*
2 * Windows and DOS version functions
3 *
4 * Copyright 1997 Marcus Meissner
5 * Copyright 1998 Patrik Stridvall
6 * Copyright 1998, 2003 Andreas Mohr
7 * Copyright 1997, 2003 Alexandre Julliard
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #include <string.h>
25 #include <stdlib.h>
26 #include <stdarg.h>
27 #include <stdio.h>
28 #include "ntstatus.h"
29 #define WIN32_NO_STATUS
30 #include "windef.h"
31 #include "wine/debug.h"
32 #include "ntdll_misc.h"
33 #include "ddk/wdm.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(ver);
36
37 typedef enum
38 {
39 WIN20, /* Windows 2.0 */
40 WIN30, /* Windows 3.0 */
41 WIN31, /* Windows 3.1 */
42 WIN95, /* Windows 95 */
43 WIN98, /* Windows 98 */
44 WINME, /* Windows Me */
45 NT351, /* Windows NT 3.51 */
46 NT40, /* Windows NT 4.0 */
47 NT2K, /* Windows 2000 */
48 WINXP, /* Windows XP */
49 WINXP64, /* Windows XP 64-bit */
50 WIN2K3, /* Windows 2003 */
51 WINVISTA,/* Windows Vista */
52 WIN2K8, /* Windows 2008 */
53 WIN2K8R2,/* Windows 2008 R2 */
54 WIN7, /* Windows 7 */
55 WIN8, /* Windows 8 */
56 WIN81, /* Windows 8.1 */
57 WIN10, /* Windows 10 */
58 NB_WINDOWS_VERSIONS
59 } WINDOWS_VERSION;
60
61 /* FIXME: compare values below with original and fix.
62 * An *excellent* win9x version page (ALL versions !)
63 * can be found at www.mdgx.com/ver.htm */
64 static const RTL_OSVERSIONINFOEXW VersionData[NB_WINDOWS_VERSIONS] =
65 {
66 /* WIN20 FIXME: verify values */
67 {
68 sizeof(RTL_OSVERSIONINFOEXW), 2, 0, 0, VER_PLATFORM_WIN32s,
69 {'W','i','n','3','2','s',' ','1','.','3',0},
70 0, 0, 0, 0, 0
71 },
72 /* WIN30 FIXME: verify values */
73 {
74 sizeof(RTL_OSVERSIONINFOEXW), 3, 0, 0, VER_PLATFORM_WIN32s,
75 {'W','i','n','3','2','s',' ','1','.','3',0},
76 0, 0, 0, 0, 0
77 },
78 /* WIN31 */
79 {
80 sizeof(RTL_OSVERSIONINFOEXW), 3, 10, 0, VER_PLATFORM_WIN32s,
81 {'W','i','n','3','2','s',' ','1','.','3',0},
82 0, 0, 0, 0, 0
83 },
84 /* WIN95 */
85 {
86 /* Win95: 4, 0, 0x40003B6, ""
87 * Win95sp1: 4, 0, 0x40003B6, " A " (according to doc)
88 * Win95osr2: 4, 0, 0x4000457, " B " (according to doc)
89 * Win95osr2.1: 4, 3, 0x40304BC, " B " (according to doc)
90 * Win95osr2.5: 4, 3, 0x40304BE, " C " (according to doc)
91 * Win95a/b can be discerned via regkey SubVersionNumber
92 */
93 sizeof(RTL_OSVERSIONINFOEXW), 4, 0, 0x40003B6, VER_PLATFORM_WIN32_WINDOWS,
94 {0},
95 0, 0, 0, 0, 0
96 },
97 /* WIN98 (second edition) */
98 {
99 /* Win98: 4, 10, 0x40A07CE, " " 4.10.1998
100 * Win98SE: 4, 10, 0x40A08AE, " A " 4.10.2222
101 */
102 sizeof(RTL_OSVERSIONINFOEXW), 4, 10, 0x40A08AE, VER_PLATFORM_WIN32_WINDOWS,
103 {' ','A',' ',0},
104 0, 0, 0, 0, 0
105 },
106 /* WINME */
107 {
108 sizeof(RTL_OSVERSIONINFOEXW), 4, 90, 0x45A0BB8, VER_PLATFORM_WIN32_WINDOWS,
109 {' ',0},
110 0, 0, 0, 0, 0
111 },
112 /* NT351 */
113 {
114 sizeof(RTL_OSVERSIONINFOEXW), 3, 51, 0x421, VER_PLATFORM_WIN32_NT,
115 {'S','e','r','v','i','c','e',' ','P','a','c','k',' ','5',0},
116 5, 0, 0, VER_NT_WORKSTATION, 0
117 },
118 /* NT40 */
119 {
120 sizeof(RTL_OSVERSIONINFOEXW), 4, 0, 0x565, VER_PLATFORM_WIN32_NT,
121 {'S','e','r','v','i','c','e',' ','P','a','c','k',' ','6','a',0},
122 6, 0, 0, VER_NT_WORKSTATION, 0
123 },
124 /* NT2K */
125 {
126 sizeof(RTL_OSVERSIONINFOEXW), 5, 0, 0x893, VER_PLATFORM_WIN32_NT,
127 {'S','e','r','v','i','c','e',' ','P','a','c','k',' ','4',0},
128 4, 0, 0, VER_NT_WORKSTATION, 30 /* FIXME: Great, a reserved field with a value! */
129 },
130 /* WINXP */
131 {
132 sizeof(RTL_OSVERSIONINFOEXW), 5, 1, 0xA28, VER_PLATFORM_WIN32_NT,
133 {'S','e','r','v','i','c','e',' ','P','a','c','k',' ','3',0},
134 3, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION, 30 /* FIXME: Great, a reserved field with a value! */
135 },
136 /* WINXP64 */
137 {
138 sizeof(RTL_OSVERSIONINFOEXW), 5, 2, 0xECE, VER_PLATFORM_WIN32_NT,
139 {'S','e','r','v','i','c','e',' ','P','a','c','k',' ','2',0},
140 2, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION, 0
141 },
142 /* WIN2K3 */
143 {
144 sizeof(RTL_OSVERSIONINFOEXW), 5, 2, 0xECE, VER_PLATFORM_WIN32_NT,
145 {'S','e','r','v','i','c','e',' ','P','a','c','k',' ','2',0},
146 2, 0, VER_SUITE_SINGLEUSERTS, VER_NT_SERVER, 0
147 },
148 /* WINVISTA */
149 {
150 sizeof(RTL_OSVERSIONINFOEXW), 6, 0, 0x1772, VER_PLATFORM_WIN32_NT,
151 {'S','e','r','v','i','c','e',' ','P','a','c','k',' ','2',0},
152 2, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION, 0
153 },
154 /* WIN2K8 */
155 {
156 sizeof(RTL_OSVERSIONINFOEXW), 6, 0, 0x1772, VER_PLATFORM_WIN32_NT,
157 {'S','e','r','v','i','c','e',' ','P','a','c','k',' ','2',0},
158 2, 0, VER_SUITE_SINGLEUSERTS, VER_NT_SERVER, 0
159 },
160 /* WIN7 */
161 {
162 sizeof(RTL_OSVERSIONINFOEXW), 6, 1, 0x1DB1, VER_PLATFORM_WIN32_NT,
163 {'S','e','r','v','i','c','e',' ','P','a','c','k',' ','1',0},
164 1, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION, 0
165 },
166 /* WIN2K8R2 */
167 {
168 sizeof(RTL_OSVERSIONINFOEXW), 6, 1, 0x1DB1, VER_PLATFORM_WIN32_NT,
169 {'S','e','r','v','i','c','e',' ','P','a','c','k',' ','1',0},
170 1, 0, VER_SUITE_SINGLEUSERTS, VER_NT_SERVER, 0
171 },
172 /* WIN8 */
173 {
174 sizeof(RTL_OSVERSIONINFOEXW), 6, 2, 0x23F0, VER_PLATFORM_WIN32_NT,
175 {0}, 0, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION, 0
176 },
177 /* WIN81 */
178 {
179 sizeof(RTL_OSVERSIONINFOEXW), 6, 3, 0x2580, VER_PLATFORM_WIN32_NT,
180 {0}, 0, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION, 0
181 },
182 /* WIN10 */
183 {
184 sizeof(RTL_OSVERSIONINFOEXW), 10, 0, 0x4563, VER_PLATFORM_WIN32_NT,
185 {0}, 0, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION, 0
186 },
187
188 };
189
190 static const struct { WCHAR name[12]; WINDOWS_VERSION ver; } version_names[] =
191 {
192 { {'w','i','n','2','0',0}, WIN20 },
193 { {'w','i','n','3','0',0}, WIN30 },
194 { {'w','i','n','3','1',0}, WIN31 },
195 { {'w','i','n','9','5',0}, WIN95 },
196 { {'w','i','n','9','8',0}, WIN98 },
197 { {'w','i','n','m','e',0}, WINME },
198 { {'n','t','3','5','1',0}, NT351 },
199 { {'n','t','4','0',0}, NT40 },
200 { {'w','i','n','2','0','0','0',0}, NT2K },
201 { {'w','i','n','2','k',0}, NT2K },
202 { {'n','t','2','k',0}, NT2K },
203 { {'n','t','2','0','0','0',0}, NT2K },
204 { {'w','i','n','x','p',0}, WINXP },
205 { {'w','i','n','x','p','6','4',0}, WINXP64 },
206 { {'w','i','n','2','0','0','3',0}, WIN2K3 },
207 { {'w','i','n','2','k','3',0}, WIN2K3 },
208 { {'v','i','s','t','a',0}, WINVISTA },
209 { {'w','i','n','v','i','s','t','a',0}, WINVISTA },
210 { {'w','i','n','2','0','0','8',0}, WIN2K8 },
211 { {'w','i','n','2','k','8',0}, WIN2K8 },
212 { {'w','i','n','2','0','0','8','r','2',0}, WIN2K8R2 },
213 { {'w','i','n','2','k','8','r','2',0}, WIN2K8R2 },
214 { {'w','i','n','7',0}, WIN7 },
215 { {'w','i','n','8',0}, WIN8 },
216 { {'w','i','n','8','1',0}, WIN81 },
217 { {'w','i','n','1','0',0}, WIN10 },
218 };
219
220
221 /* initialized to null so that we crash if we try to retrieve the version too early at startup */
222 static const RTL_OSVERSIONINFOEXW *current_version;
223
224
225 /**********************************************************************
226 * get_nt_registry_version
227 *
228 * Fetch the version information from the NT-style registry keys.
229 */
230 static BOOL get_nt_registry_version( RTL_OSVERSIONINFOEXW *version )
231 {
232 static const WCHAR version_keyW[] = {'M','a','c','h','i','n','e','\\',
233 'S','o','f','t','w','a','r','e','\\',
234 'M','i','c','r','o','s','o','f','t','\\',
235 'W','i','n','d','o','w','s',' ','N','T','\\',
236 'C','u','r','r','e','n','t','V','e','r','s','i','o','n',0};
237 static const WCHAR service_pack_keyW[] = {'M','a','c','h','i','n','e','\\',
238 'S','y','s','t','e','m','\\',
239 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
240 'C','o','n','t','r','o','l','\\',
241 'W','i','n','d','o','w','s',0};
242 static const WCHAR product_keyW[] = {'M','a','c','h','i','n','e','\\',
243 'S','y','s','t','e','m','\\',
244 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
245 'C','o','n','t','r','o','l','\\',
246 'P','r','o','d','u','c','t','O','p','t','i','o','n','s',0};
247 static const WCHAR CurrentBuildNumberW[] = {'C','u','r','r','e','n','t','B','u','i','l','d','N','u','m','b','e','r',0};
248 static const WCHAR CSDVersionW[] = {'C','S','D','V','e','r','s','i','o','n',0};
249 static const WCHAR CurrentVersionW[] = {'C','u','r','r','e','n','t','V','e','r','s','i','o','n',0};
250 static const WCHAR ProductTypeW[] = {'P','r','o','d','u','c','t','T','y','p','e',0};
251 static const WCHAR WinNTW[] = {'W','i','n','N','T',0};
252 static const WCHAR ServerNTW[] = {'S','e','r','v','e','r','N','T',0};
253 static const WCHAR LanmanNTW[] = {'L','a','n','m','a','n','N','T',0};
254
255 OBJECT_ATTRIBUTES attr;
256 UNICODE_STRING nameW, valueW;
257 HANDLE hkey, hkey2;
258 char tmp[64];
259 DWORD count;
260 BOOL ret = FALSE;
261 KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)tmp;
262
263 attr.Length = sizeof(attr);
264 attr.RootDirectory = 0;
265 attr.ObjectName = &nameW;
266 attr.Attributes = 0;
267 attr.SecurityDescriptor = NULL;
268 attr.SecurityQualityOfService = NULL;
269 RtlInitUnicodeString( &nameW, version_keyW );
270
271 if (NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr )) return FALSE;
272
273 memset( version, 0, sizeof(*version) );
274
275 RtlInitUnicodeString( &valueW, CurrentVersionW );
276 if (!NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
277 {
278 WCHAR *p, *str = (WCHAR *)info->Data;
279 str[info->DataLength / sizeof(WCHAR)] = 0;
280 p = wcschr( str, '.' );
281 if (p)
282 {
283 *p++ = 0;
284 version->dwMinorVersion = wcstoul( p, NULL, 10 );
285 }
286 version->dwMajorVersion = wcstoul( str, NULL, 10 );
287 }
288
289 if (version->dwMajorVersion) /* we got the main version, now fetch the other fields */
290 {
291 ret = TRUE;
292 version->dwPlatformId = VER_PLATFORM_WIN32_NT;
293
294 /* get build number */
295
296 RtlInitUnicodeString( &valueW, CurrentBuildNumberW );
297 if (!NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
298 {
299 WCHAR *str = (WCHAR *)info->Data;
300 str[info->DataLength / sizeof(WCHAR)] = 0;
301 version->dwBuildNumber = wcstoul( str, NULL, 10 );
302 }
303
304 /* get version description */
305
306 RtlInitUnicodeString( &valueW, CSDVersionW );
307 if (!NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
308 {
309 DWORD len = min( info->DataLength, sizeof(version->szCSDVersion) - sizeof(WCHAR) );
310 memcpy( version->szCSDVersion, info->Data, len );
311 version->szCSDVersion[len / sizeof(WCHAR)] = 0;
312 }
313
314 /* get service pack version */
315
316 RtlInitUnicodeString( &nameW, service_pack_keyW );
317 if (!NtOpenKey( &hkey2, KEY_ALL_ACCESS, &attr ))
318 {
319 RtlInitUnicodeString( &valueW, CSDVersionW );
320 if (!NtQueryValueKey( hkey2, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp), &count ))
321 {
322 if (info->DataLength >= sizeof(DWORD))
323 {
324 DWORD dw = *(DWORD *)info->Data;
325 version->wServicePackMajor = LOWORD(dw) >> 8;
326 version->wServicePackMinor = LOWORD(dw) & 0xff;
327 }
328 }
329 NtClose( hkey2 );
330 }
331
332 /* get product type */
333
334 RtlInitUnicodeString( &nameW, product_keyW );
335 if (!NtOpenKey( &hkey2, KEY_ALL_ACCESS, &attr ))
336 {
337 RtlInitUnicodeString( &valueW, ProductTypeW );
338 if (!NtQueryValueKey( hkey2, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
339 {
340 WCHAR *str = (WCHAR *)info->Data;
341 str[info->DataLength / sizeof(WCHAR)] = 0;
342 if (!wcsicmp( str, WinNTW )) version->wProductType = VER_NT_WORKSTATION;
343 else if (!wcsicmp( str, LanmanNTW )) version->wProductType = VER_NT_DOMAIN_CONTROLLER;
344 else if (!wcsicmp( str, ServerNTW )) version->wProductType = VER_NT_SERVER;
345 }
346 NtClose( hkey2 );
347 }
348
349 /* FIXME: get wSuiteMask */
350 }
351
352 NtClose( hkey );
353 return ret;
354 }
355
356
357 /**********************************************************************
358 * get_win9x_registry_version
359 *
360 * Fetch the version information from the Win9x-style registry keys.
361 */
362 static BOOL get_win9x_registry_version( RTL_OSVERSIONINFOEXW *version )
363 {
364 static const WCHAR version_keyW[] = {'M','a','c','h','i','n','e','\\',
365 'S','o','f','t','w','a','r','e','\\',
366 'M','i','c','r','o','s','o','f','t','\\',
367 'W','i','n','d','o','w','s','\\',
368 'C','u','r','r','e','n','t','V','e','r','s','i','o','n',0};
369 static const WCHAR VersionNumberW[] = {'V','e','r','s','i','o','n','N','u','m','b','e','r',0};
370 static const WCHAR SubVersionNumberW[] = {'S','u','b','V','e','r','s','i','o','n','N','u','m','b','e','r',0};
371
372 OBJECT_ATTRIBUTES attr;
373 UNICODE_STRING nameW, valueW;
374 HANDLE hkey;
375 char tmp[64];
376 DWORD count;
377 BOOL ret = FALSE;
378 KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)tmp;
379
380 attr.Length = sizeof(attr);
381 attr.RootDirectory = 0;
382 attr.ObjectName = &nameW;
383 attr.Attributes = 0;
384 attr.SecurityDescriptor = NULL;
385 attr.SecurityQualityOfService = NULL;
386 RtlInitUnicodeString( &nameW, version_keyW );
387
388 if (NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr )) return FALSE;
389
390 memset( version, 0, sizeof(*version) );
391
392 RtlInitUnicodeString( &valueW, VersionNumberW );
393 if (!NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
394 {
395 WCHAR *p, *str = (WCHAR *)info->Data;
396 str[info->DataLength / sizeof(WCHAR)] = 0;
397 p = wcschr( str, '.' );
398 if (p) *p++ = 0;
399 version->dwMajorVersion = wcstoul( str, NULL, 10 );
400 if (p)
401 {
402 str = p;
403 p = wcschr( str, '.' );
404 if (p)
405 {
406 *p++ = 0;
407 version->dwBuildNumber = wcstoul( p, NULL, 10 );
408 }
409 version->dwMinorVersion = wcstoul( str, NULL, 10 );
410 }
411 /* build number contains version too on Win9x */
412 version->dwBuildNumber |= MAKEWORD( version->dwMinorVersion, version->dwMajorVersion ) << 16;
413 }
414
415 if (version->dwMajorVersion) /* we got the main version, now fetch the other fields */
416 {
417 ret = TRUE;
418 version->dwPlatformId = VER_PLATFORM_WIN32_WINDOWS;
419
420 RtlInitUnicodeString( &valueW, SubVersionNumberW );
421 if (!NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
422 {
423 DWORD len = min( info->DataLength, sizeof(version->szCSDVersion) - sizeof(WCHAR) );
424 memcpy( version->szCSDVersion, info->Data, len );
425 version->szCSDVersion[len / sizeof(WCHAR)] = 0;
426 }
427 }
428
429 NtClose( hkey );
430 return ret;
431 }
432
433
434 /**********************************************************************
435 * parse_win_version
436 *
437 * Parse the contents of the Version key.
438 */
439 static BOOL parse_win_version( HANDLE hkey )
440 {
441 static const WCHAR VersionW[] = {'V','e','r','s','i','o','n',0};
442
443 UNICODE_STRING valueW;
444 WCHAR *name, tmp[64];
445 KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)tmp;
446 DWORD i, count;
447
448 RtlInitUnicodeString( &valueW, VersionW );
449 if (NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp) - sizeof(WCHAR), &count ))
450 return FALSE;
451
452 name = (WCHAR *)info->Data;
453 name[info->DataLength / sizeof(WCHAR)] = 0;
454
455 for (i = 0; i < ARRAY_SIZE(version_names); i++)
456 {
457 if (wcscmp( version_names[i].name, name )) continue;
458 current_version = &VersionData[version_names[i].ver];
459 TRACE( "got win version %s\n", debugstr_w(version_names[i].name) );
460 return TRUE;
461 }
462
463 ERR( "Invalid Windows version value %s specified in config file.\n", debugstr_w(name) );
464 return FALSE;
465 }
466
467
468 /**********************************************************************
469 * version_init
470 */
471 void version_init(void)
472 {
473 static const WCHAR configW[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e',0};
474 static const WCHAR appdefaultsW[] = {'A','p','p','D','e','f','a','u','l','t','s','\\',0};
475 OBJECT_ATTRIBUTES attr;
476 UNICODE_STRING nameW;
477 HANDLE root, hkey, config_key;
478 BOOL got_win_ver = FALSE;
479 const WCHAR *p, *appname = NtCurrentTeb()->Peb->ProcessParameters->ImagePathName.Buffer;
480 WCHAR appversion[MAX_PATH+20];
481
482 current_version = &VersionData[WIN7];
483
484 RtlOpenCurrentUser( KEY_ALL_ACCESS, &root );
485 attr.Length = sizeof(attr);
486 attr.RootDirectory = root;
487 attr.ObjectName = &nameW;
488 attr.Attributes = 0;
489 attr.SecurityDescriptor = NULL;
490 attr.SecurityQualityOfService = NULL;
491 RtlInitUnicodeString( &nameW, configW );
492
493 /* @@ Wine registry key: HKCU\Software\Wine */
494 if (NtOpenKey( &config_key, KEY_ALL_ACCESS, &attr )) config_key = 0;
495 NtClose( root );
496 if (!config_key) goto done;
497
498 /* open AppDefaults\\appname key */
499
500 if ((p = wcsrchr( appname, '/' ))) appname = p + 1;
501 if ((p = wcsrchr( appname, '\\' ))) appname = p + 1;
502
503 wcscpy( appversion, appdefaultsW );
504 wcscat( appversion, appname );
505 RtlInitUnicodeString( &nameW, appversion );
506 attr.RootDirectory = config_key;
507
508 /* @@ Wine registry key: HKCU\Software\Wine\AppDefaults\app.exe */
509 if (!NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr ))
510 {
511 TRACE( "getting version from %s\n", debugstr_w(appversion) );
512 got_win_ver = parse_win_version( hkey );
513 NtClose( hkey );
514 }
515
516 if (!got_win_ver)
517 {
518 TRACE( "getting default version\n" );
519 got_win_ver = parse_win_version( config_key );
520 }
521 NtClose( config_key );
522
523 done:
524 if (!got_win_ver)
525 {
526 static RTL_OSVERSIONINFOEXW registry_version;
527
528 TRACE( "getting registry version\n" );
529 if (get_nt_registry_version( &registry_version ) ||
530 get_win9x_registry_version( &registry_version ))
531 current_version = &registry_version;
532 }
533
534
535 NtCurrentTeb()->Peb->OSMajorVersion = current_version->dwMajorVersion;
536 NtCurrentTeb()->Peb->OSMinorVersion = current_version->dwMinorVersion;
537 NtCurrentTeb()->Peb->OSBuildNumber = current_version->dwBuildNumber;
538 NtCurrentTeb()->Peb->OSPlatformId = current_version->dwPlatformId;
539
540 TRACE( "got %d.%d platform %d build %x name %s service pack %d.%d product %d\n",
541 current_version->dwMajorVersion, current_version->dwMinorVersion,
542 current_version->dwPlatformId, current_version->dwBuildNumber,
543 debugstr_w(current_version->szCSDVersion),
544 current_version->wServicePackMajor, current_version->wServicePackMinor,
545 current_version->wProductType );
546 }
547
548 /***********************************************************************
549 * RtlGetProductInfo (NTDLL.@)
550 *
551 * Gives info about the current Windows product type, in a format compatible
552 * with the given Windows version
553 *
554 * Returns TRUE if the input is valid, FALSE otherwise
555 */
556 BOOLEAN WINAPI RtlGetProductInfo(DWORD dwOSMajorVersion, DWORD dwOSMinorVersion, DWORD dwSpMajorVersion,
557 DWORD dwSpMinorVersion, PDWORD pdwReturnedProductType)
558 {
559 TRACE("(%d, %d, %d, %d, %p)\n", dwOSMajorVersion, dwOSMinorVersion,
560 dwSpMajorVersion, dwSpMinorVersion, pdwReturnedProductType);
561
562 if (!pdwReturnedProductType)
563 return FALSE;
564
565 if (dwOSMajorVersion < 6)
566 {
567 *pdwReturnedProductType = PRODUCT_UNDEFINED;
568 return FALSE;
569 }
570
571 if (current_version->wProductType == VER_NT_WORKSTATION)
572 *pdwReturnedProductType = PRODUCT_ULTIMATE_N;
573 else
574 *pdwReturnedProductType = PRODUCT_STANDARD_SERVER;
575
576 return TRUE;
577 }
578
579 /***********************************************************************
580 * RtlGetVersion (NTDLL.@)
581 */
582 NTSTATUS WINAPI RtlGetVersion( RTL_OSVERSIONINFOEXW *info )
583 {
584 info->dwMajorVersion = current_version->dwMajorVersion;
585 info->dwMinorVersion = current_version->dwMinorVersion;
586 info->dwBuildNumber = current_version->dwBuildNumber;
587 info->dwPlatformId = current_version->dwPlatformId;
588 wcscpy( info->szCSDVersion, current_version->szCSDVersion );
589 if(info->dwOSVersionInfoSize == sizeof(RTL_OSVERSIONINFOEXW))
590 {
591 info->wServicePackMajor = current_version->wServicePackMajor;
592 info->wServicePackMinor = current_version->wServicePackMinor;
593 info->wSuiteMask = current_version->wSuiteMask;
594 info->wProductType = current_version->wProductType;
595 }
596 return STATUS_SUCCESS;
597 }
598
599
600 /******************************************************************************
601 * RtlGetNtVersionNumbers (NTDLL.@)
602 *
603 * Get the version numbers of the run time library.
604 *
605 * PARAMS
606 * major [O] Destination for the Major version
607 * minor [O] Destination for the Minor version
608 * build [O] Destination for the Build version
609 *
610 * RETURNS
611 * Nothing.
612 *
613 * NOTES
614 * Introduced in Windows XP (NT5.1)
615 */
616 void WINAPI RtlGetNtVersionNumbers( LPDWORD major, LPDWORD minor, LPDWORD build )
617 {
618 if (major) *major = current_version->dwMajorVersion;
619 if (minor) *minor = current_version->dwMinorVersion;
620 /* FIXME: Does anybody know the real formula? */
621 if (build) *build = (0xF0000000 | current_version->dwBuildNumber);
622 }
623
624
625 /******************************************************************************
626 * RtlGetNtProductType (NTDLL.@)
627 */
628 BOOLEAN WINAPI RtlGetNtProductType( LPDWORD type )
629 {
630 if (type) *type = current_version->wProductType;
631 return TRUE;
632 }
633
634 static inline UCHAR version_update_condition(UCHAR *last_condition, UCHAR condition)
635 {
636 switch (*last_condition)
637 {
638 case 0:
639 *last_condition = condition;
640 break;
641 case VER_EQUAL:
642 if (condition >= VER_EQUAL && condition <= VER_LESS_EQUAL)
643 {
644 *last_condition = condition;
645 return condition;
646 }
647 break;
648 case VER_GREATER:
649 case VER_GREATER_EQUAL:
650 if (condition >= VER_EQUAL && condition <= VER_GREATER_EQUAL)
651 return condition;
652 break;
653 case VER_LESS:
654 case VER_LESS_EQUAL:
655 if (condition == VER_EQUAL || (condition >= VER_LESS && condition <= VER_LESS_EQUAL))
656 return condition;
657 break;
658 }
659 if (!condition) *last_condition |= 0x10;
660 return *last_condition & 0xf;
661 }
662
663 static inline NTSTATUS version_compare_values(ULONG left, ULONG right, UCHAR condition)
664 {
665 switch (condition) {
666 case VER_EQUAL:
667 if (left != right) return STATUS_REVISION_MISMATCH;
668 break;
669 case VER_GREATER:
670 if (left <= right) return STATUS_REVISION_MISMATCH;
671 break;
672 case VER_GREATER_EQUAL:
673 if (left < right) return STATUS_REVISION_MISMATCH;
674 break;
675 case VER_LESS:
676 if (left >= right) return STATUS_REVISION_MISMATCH;
677 break;
678 case VER_LESS_EQUAL:
679 if (left > right) return STATUS_REVISION_MISMATCH;
680 break;
681 default:
682 return STATUS_REVISION_MISMATCH;
683 }
684 return STATUS_SUCCESS;
685 }
686
687 /******************************************************************************
688 * RtlVerifyVersionInfo (NTDLL.@)
689 */
690 NTSTATUS WINAPI RtlVerifyVersionInfo( const RTL_OSVERSIONINFOEXW *info,
691 DWORD dwTypeMask, DWORDLONG dwlConditionMask )
692 {
693 RTL_OSVERSIONINFOEXW ver;
694 NTSTATUS status;
695
696 TRACE("(%p,0x%x,0x%s)\n", info, dwTypeMask, wine_dbgstr_longlong(dwlConditionMask));
697
698 ver.dwOSVersionInfoSize = sizeof(ver);
699 if ((status = RtlGetVersion( &ver )) != STATUS_SUCCESS) return status;
700
701 if(!(dwTypeMask && dwlConditionMask)) return STATUS_INVALID_PARAMETER;
702
703 if(dwTypeMask & VER_PRODUCT_TYPE)
704 {
705 status = version_compare_values(ver.wProductType, info->wProductType, dwlConditionMask >> 7*3 & 0x07);
706 if (status != STATUS_SUCCESS)
707 return status;
708 }
709 if(dwTypeMask & VER_SUITENAME)
710 switch(dwlConditionMask >> 6*3 & 0x07)
711 {
712 case VER_AND:
713 if((info->wSuiteMask & ver.wSuiteMask) != info->wSuiteMask)
714 return STATUS_REVISION_MISMATCH;
715 break;
716 case VER_OR:
717 if(!(info->wSuiteMask & ver.wSuiteMask) && info->wSuiteMask)
718 return STATUS_REVISION_MISMATCH;
719 break;
720 default:
721 return STATUS_INVALID_PARAMETER;
722 }
723 if(dwTypeMask & VER_PLATFORMID)
724 {
725 status = version_compare_values(ver.dwPlatformId, info->dwPlatformId, dwlConditionMask >> 3*3 & 0x07);
726 if (status != STATUS_SUCCESS)
727 return status;
728 }
729 if(dwTypeMask & VER_BUILDNUMBER)
730 {
731 status = version_compare_values(ver.dwBuildNumber, info->dwBuildNumber, dwlConditionMask >> 2*3 & 0x07);
732 if (status != STATUS_SUCCESS)
733 return status;
734 }
735
736 if(dwTypeMask & (VER_MAJORVERSION|VER_MINORVERSION|VER_SERVICEPACKMAJOR|VER_SERVICEPACKMINOR))
737 {
738 unsigned char condition, last_condition = 0;
739 BOOLEAN do_next_check = TRUE;
740
741 if(dwTypeMask & VER_MAJORVERSION)
742 {
743 condition = version_update_condition(&last_condition, dwlConditionMask >> 1*3 & 0x07);
744 status = version_compare_values(ver.dwMajorVersion, info->dwMajorVersion, condition);
745 do_next_check = (ver.dwMajorVersion == info->dwMajorVersion) &&
746 ((condition >= VER_EQUAL) && (condition <= VER_LESS_EQUAL));
747 }
748 if((dwTypeMask & VER_MINORVERSION) && do_next_check)
749 {
750 condition = version_update_condition(&last_condition, dwlConditionMask >> 0*3 & 0x07);
751 status = version_compare_values(ver.dwMinorVersion, info->dwMinorVersion, condition);
752 do_next_check = (ver.dwMinorVersion == info->dwMinorVersion) &&
753 ((condition >= VER_EQUAL) && (condition <= VER_LESS_EQUAL));
754 }
755 if((dwTypeMask & VER_SERVICEPACKMAJOR) && do_next_check)
756 {
757 condition = version_update_condition(&last_condition, dwlConditionMask >> 5*3 & 0x07);
758 status = version_compare_values(ver.wServicePackMajor, info->wServicePackMajor, condition);
759 do_next_check = (ver.wServicePackMajor == info->wServicePackMajor) &&
760 ((condition >= VER_EQUAL) && (condition <= VER_LESS_EQUAL));
761 }
762 if((dwTypeMask & VER_SERVICEPACKMINOR) && do_next_check)
763 {
764 condition = version_update_condition(&last_condition, dwlConditionMask >> 4*3 & 0x07);
765 status = version_compare_values(ver.wServicePackMinor, info->wServicePackMinor, condition);
766 }
767
768 if (status != STATUS_SUCCESS)
769 return status;
770 }
771
772 return STATUS_SUCCESS;
773 }
Zebediah Figura's local tree