?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wbemdisp: Implement GetObjectText_().
[wine/zf.git] / dlls / ntdll / version.c
blob740d8403f5ed4b200b004b16728c22593fc04343
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 L"Win32s 1.3", 0, 0, 0, 0, 0
70 },
71 /* WIN30 FIXME: verify values */
72 {
73 sizeof(RTL_OSVERSIONINFOEXW), 3, 0, 0, VER_PLATFORM_WIN32s,
74 L"Win32s 1.3", 0, 0, 0, 0, 0
75 },
76 /* WIN31 */
77 {
78 sizeof(RTL_OSVERSIONINFOEXW), 3, 10, 0, VER_PLATFORM_WIN32s,
79 L"Win32s 1.3", 0, 0, 0, 0, 0
80 },
81 /* WIN95 */
82 {
83 /* Win95: 4, 0, 0x40003B6, ""
84 * Win95sp1: 4, 0, 0x40003B6, " A " (according to doc)
85 * Win95osr2: 4, 0, 0x4000457, " B " (according to doc)
86 * Win95osr2.1: 4, 3, 0x40304BC, " B " (according to doc)
87 * Win95osr2.5: 4, 3, 0x40304BE, " C " (according to doc)
88 * Win95a/b can be discerned via regkey SubVersionNumber
89 */
90 sizeof(RTL_OSVERSIONINFOEXW), 4, 0, 0x40003B6, VER_PLATFORM_WIN32_WINDOWS,
91 L"", 0, 0, 0, 0, 0
92 },
93 /* WIN98 (second edition) */
94 {
95 /* Win98: 4, 10, 0x40A07CE, " " 4.10.1998
96 * Win98SE: 4, 10, 0x40A08AE, " A " 4.10.2222
97 */
98 sizeof(RTL_OSVERSIONINFOEXW), 4, 10, 0x40A08AE, VER_PLATFORM_WIN32_WINDOWS,
99 L" A ", 0, 0, 0, 0, 0
100 },
101 /* WINME */
102 {
103 sizeof(RTL_OSVERSIONINFOEXW), 4, 90, 0x45A0BB8, VER_PLATFORM_WIN32_WINDOWS,
104 L" ", 0, 0, 0, 0, 0
105 },
106 /* NT351 */
107 {
108 sizeof(RTL_OSVERSIONINFOEXW), 3, 51, 0x421, VER_PLATFORM_WIN32_NT,
109 L"Service Pack 5", 5, 0, 0, VER_NT_WORKSTATION, 0
110 },
111 /* NT40 */
112 {
113 sizeof(RTL_OSVERSIONINFOEXW), 4, 0, 0x565, VER_PLATFORM_WIN32_NT,
114 L"Service Pack 6a", 6, 0, 0, VER_NT_WORKSTATION, 0
115 },
116 /* NT2K */
117 {
118 sizeof(RTL_OSVERSIONINFOEXW), 5, 0, 0x893, VER_PLATFORM_WIN32_NT,
119 L"Service Pack 4", 4, 0, 0, VER_NT_WORKSTATION,
120 30 /* FIXME: Great, a reserved field with a value! */
121 },
122 /* WINXP */
123 {
124 sizeof(RTL_OSVERSIONINFOEXW), 5, 1, 0xA28, VER_PLATFORM_WIN32_NT,
125 L"Service Pack 3", 3, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION,
126 30 /* FIXME: Great, a reserved field with a value! */
127 },
128 /* WINXP64 */
129 {
130 sizeof(RTL_OSVERSIONINFOEXW), 5, 2, 0xECE, VER_PLATFORM_WIN32_NT,
131 L"Service Pack 2", 2, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION, 0
132 },
133 /* WIN2K3 */
134 {
135 sizeof(RTL_OSVERSIONINFOEXW), 5, 2, 0xECE, VER_PLATFORM_WIN32_NT,
136 L"Service Pack 2", 2, 0, VER_SUITE_SINGLEUSERTS, VER_NT_SERVER, 0
137 },
138 /* WINVISTA */
139 {
140 sizeof(RTL_OSVERSIONINFOEXW), 6, 0, 0x1772, VER_PLATFORM_WIN32_NT,
141 L"Service Pack 2", 2, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION, 0
142 },
143 /* WIN2K8 */
144 {
145 sizeof(RTL_OSVERSIONINFOEXW), 6, 0, 0x1772, VER_PLATFORM_WIN32_NT,
146 L"Service Pack 2", 2, 0, VER_SUITE_SINGLEUSERTS, VER_NT_SERVER, 0
147 },
148 /* WIN7 */
149 {
150 sizeof(RTL_OSVERSIONINFOEXW), 6, 1, 0x1DB1, VER_PLATFORM_WIN32_NT,
151 L"Service Pack 1", 1, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION, 0
152 },
153 /* WIN2K8R2 */
154 {
155 sizeof(RTL_OSVERSIONINFOEXW), 6, 1, 0x1DB1, VER_PLATFORM_WIN32_NT,
156 L"Service Pack 1", 1, 0, VER_SUITE_SINGLEUSERTS, VER_NT_SERVER, 0
157 },
158 /* WIN8 */
159 {
160 sizeof(RTL_OSVERSIONINFOEXW), 6, 2, 0x23F0, VER_PLATFORM_WIN32_NT,
161 L"", 0, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION, 0
162 },
163 /* WIN81 */
164 {
165 sizeof(RTL_OSVERSIONINFOEXW), 6, 3, 0x2580, VER_PLATFORM_WIN32_NT,
166 L"", 0, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION, 0
167 },
168 /* WIN10 */
169 {
170 sizeof(RTL_OSVERSIONINFOEXW), 10, 0, 0x4563, VER_PLATFORM_WIN32_NT,
171 L"", 0, 0, VER_SUITE_SINGLEUSERTS, VER_NT_WORKSTATION, 0
172 },
173
174 };
175
176 static const struct { WCHAR name[12]; WINDOWS_VERSION ver; } version_names[] =
177 {
178 { L"win20", WIN20 },
179 { L"win30", WIN30 },
180 { L"win31", WIN31 },
181 { L"win95", WIN95 },
182 { L"win98", WIN98 },
183 { L"winme", WINME },
184 { L"nt351", NT351 },
185 { L"nt40", NT40 },
186 { L"win2000", NT2K },
187 { L"win2k", NT2K },
188 { L"nt2k", NT2K },
189 { L"nt2000", NT2K },
190 { L"winxp", WINXP },
191 { L"winxp64", WINXP64 },
192 { L"win2003", WIN2K3 },
193 { L"win2k3", WIN2K3 },
194 { L"vista", WINVISTA },
195 { L"winvista", WINVISTA },
196 { L"win2008", WIN2K8 },
197 { L"win2k8", WIN2K8 },
198 { L"win2008r2", WIN2K8R2 },
199 { L"win2k8r2", WIN2K8R2 },
200 { L"win7", WIN7 },
201 { L"win8", WIN8 },
202 { L"win81", WIN81 },
203 { L"win10", WIN10 },
204 };
205
206
207 /* initialized to null so that we crash if we try to retrieve the version too early at startup */
208 static const RTL_OSVERSIONINFOEXW *current_version;
209
210
211 /**********************************************************************
212 * get_nt_registry_version
213 *
214 * Fetch the version information from the NT-style registry keys.
215 */
216 static BOOL get_nt_registry_version( RTL_OSVERSIONINFOEXW *version )
217 {
218 OBJECT_ATTRIBUTES attr;
219 UNICODE_STRING nameW, valueW;
220 HANDLE hkey, hkey2;
221 char tmp[64];
222 DWORD count;
223 BOOL ret = FALSE;
224 KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)tmp;
225
226 attr.Length = sizeof(attr);
227 attr.RootDirectory = 0;
228 attr.ObjectName = &nameW;
229 attr.Attributes = 0;
230 attr.SecurityDescriptor = NULL;
231 attr.SecurityQualityOfService = NULL;
232 RtlInitUnicodeString( &nameW, L"Machine\\Software\\Microsoft\\Windows NT\\CurrentVersion" );
233
234 if (NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr )) return FALSE;
235
236 memset( version, 0, sizeof(*version) );
237
238 RtlInitUnicodeString( &valueW, L"CurrentVersion" );
239 if (!NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
240 {
241 WCHAR *p, *str = (WCHAR *)info->Data;
242 str[info->DataLength / sizeof(WCHAR)] = 0;
243 p = wcschr( str, '.' );
244 if (p)
245 {
246 *p++ = 0;
247 version->dwMinorVersion = wcstoul( p, NULL, 10 );
248 }
249 version->dwMajorVersion = wcstoul( str, NULL, 10 );
250 }
251
252 if (version->dwMajorVersion) /* we got the main version, now fetch the other fields */
253 {
254 ret = TRUE;
255 version->dwPlatformId = VER_PLATFORM_WIN32_NT;
256
257 /* get build number */
258
259 RtlInitUnicodeString( &valueW, L"CurrentBuildNumber" );
260 if (!NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
261 {
262 WCHAR *str = (WCHAR *)info->Data;
263 str[info->DataLength / sizeof(WCHAR)] = 0;
264 version->dwBuildNumber = wcstoul( str, NULL, 10 );
265 }
266
267 /* get version description */
268
269 RtlInitUnicodeString( &valueW, L"CSDVersion" );
270 if (!NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
271 {
272 DWORD len = min( info->DataLength, sizeof(version->szCSDVersion) - sizeof(WCHAR) );
273 memcpy( version->szCSDVersion, info->Data, len );
274 version->szCSDVersion[len / sizeof(WCHAR)] = 0;
275 }
276
277 /* get service pack version */
278
279 RtlInitUnicodeString( &nameW, L"Machine\\System\\CurrentControlSet\\Control\\Windows" );
280 if (!NtOpenKey( &hkey2, KEY_ALL_ACCESS, &attr ))
281 {
282 RtlInitUnicodeString( &valueW, L"CSDVersion" );
283 if (!NtQueryValueKey( hkey2, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp), &count ))
284 {
285 if (info->DataLength >= sizeof(DWORD))
286 {
287 DWORD dw = *(DWORD *)info->Data;
288 version->wServicePackMajor = LOWORD(dw) >> 8;
289 version->wServicePackMinor = LOWORD(dw) & 0xff;
290 }
291 }
292 NtClose( hkey2 );
293 }
294
295 /* get product type */
296
297 RtlInitUnicodeString( &nameW, L"Machine\\System\\CurrentControlSet\\Control\\ProductOptions" );
298 if (!NtOpenKey( &hkey2, KEY_ALL_ACCESS, &attr ))
299 {
300 RtlInitUnicodeString( &valueW, L"ProductType" );
301 if (!NtQueryValueKey( hkey2, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
302 {
303 WCHAR *str = (WCHAR *)info->Data;
304 str[info->DataLength / sizeof(WCHAR)] = 0;
305 if (!wcsicmp( str, L"WinNT" )) version->wProductType = VER_NT_WORKSTATION;
306 else if (!wcsicmp( str, L"LanmanNT" )) version->wProductType = VER_NT_DOMAIN_CONTROLLER;
307 else if (!wcsicmp( str, L"ServerNT" )) version->wProductType = VER_NT_SERVER;
308 }
309 NtClose( hkey2 );
310 }
311
312 /* FIXME: get wSuiteMask */
313 }
314
315 NtClose( hkey );
316 return ret;
317 }
318
319
320 /**********************************************************************
321 * get_win9x_registry_version
322 *
323 * Fetch the version information from the Win9x-style registry keys.
324 */
325 static BOOL get_win9x_registry_version( RTL_OSVERSIONINFOEXW *version )
326 {
327 OBJECT_ATTRIBUTES attr;
328 UNICODE_STRING nameW, valueW;
329 HANDLE hkey;
330 char tmp[64];
331 DWORD count;
332 BOOL ret = FALSE;
333 KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)tmp;
334
335 attr.Length = sizeof(attr);
336 attr.RootDirectory = 0;
337 attr.ObjectName = &nameW;
338 attr.Attributes = 0;
339 attr.SecurityDescriptor = NULL;
340 attr.SecurityQualityOfService = NULL;
341 RtlInitUnicodeString( &nameW, L"Machine\\Software\\Microsoft\\Windows\\CurrentVersion" );
342
343 if (NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr )) return FALSE;
344
345 memset( version, 0, sizeof(*version) );
346
347 RtlInitUnicodeString( &valueW, L"VersionNumber" );
348 if (!NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
349 {
350 WCHAR *p, *str = (WCHAR *)info->Data;
351 str[info->DataLength / sizeof(WCHAR)] = 0;
352 p = wcschr( str, '.' );
353 if (p) *p++ = 0;
354 version->dwMajorVersion = wcstoul( str, NULL, 10 );
355 if (p)
356 {
357 str = p;
358 p = wcschr( str, '.' );
359 if (p)
360 {
361 *p++ = 0;
362 version->dwBuildNumber = wcstoul( p, NULL, 10 );
363 }
364 version->dwMinorVersion = wcstoul( str, NULL, 10 );
365 }
366 /* build number contains version too on Win9x */
367 version->dwBuildNumber |= MAKEWORD( version->dwMinorVersion, version->dwMajorVersion ) << 16;
368 }
369
370 if (version->dwMajorVersion) /* we got the main version, now fetch the other fields */
371 {
372 ret = TRUE;
373 version->dwPlatformId = VER_PLATFORM_WIN32_WINDOWS;
374
375 RtlInitUnicodeString( &valueW, L"SubVersionNumber" );
376 if (!NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
377 {
378 DWORD len = min( info->DataLength, sizeof(version->szCSDVersion) - sizeof(WCHAR) );
379 memcpy( version->szCSDVersion, info->Data, len );
380 version->szCSDVersion[len / sizeof(WCHAR)] = 0;
381 }
382 }
383
384 NtClose( hkey );
385 return ret;
386 }
387
388
389 /**********************************************************************
390 * parse_win_version
391 *
392 * Parse the contents of the Version key.
393 */
394 static BOOL parse_win_version( HANDLE hkey )
395 {
396 UNICODE_STRING valueW;
397 WCHAR *name, tmp[64];
398 KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)tmp;
399 DWORD i, count;
400
401 RtlInitUnicodeString( &valueW, L"Version" );
402 if (NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp) - sizeof(WCHAR), &count ))
403 return FALSE;
404
405 name = (WCHAR *)info->Data;
406 name[info->DataLength / sizeof(WCHAR)] = 0;
407
408 for (i = 0; i < ARRAY_SIZE(version_names); i++)
409 {
410 if (wcscmp( version_names[i].name, name )) continue;
411 current_version = &VersionData[version_names[i].ver];
412 TRACE( "got win version %s\n", debugstr_w(version_names[i].name) );
413 return TRUE;
414 }
415
416 ERR( "Invalid Windows version value %s specified in config file.\n", debugstr_w(name) );
417 return FALSE;
418 }
419
420
421 /**********************************************************************
422 * version_init
423 */
424 void version_init(void)
425 {
426 OBJECT_ATTRIBUTES attr;
427 UNICODE_STRING nameW;
428 HANDLE root, hkey, config_key;
429 BOOL got_win_ver = FALSE;
430 const WCHAR *p, *appname = NtCurrentTeb()->Peb->ProcessParameters->ImagePathName.Buffer;
431 WCHAR appversion[MAX_PATH+20];
432
433 current_version = &VersionData[WIN7];
434
435 RtlOpenCurrentUser( KEY_ALL_ACCESS, &root );
436 attr.Length = sizeof(attr);
437 attr.RootDirectory = root;
438 attr.ObjectName = &nameW;
439 attr.Attributes = 0;
440 attr.SecurityDescriptor = NULL;
441 attr.SecurityQualityOfService = NULL;
442 RtlInitUnicodeString( &nameW, L"Software\\Wine" );
443
444 /* @@ Wine registry key: HKCU\Software\Wine */
445 if (NtOpenKey( &config_key, KEY_ALL_ACCESS, &attr )) config_key = 0;
446 NtClose( root );
447 if (!config_key) goto done;
448
449 /* open AppDefaults\\appname key */
450
451 if ((p = wcsrchr( appname, '/' ))) appname = p + 1;
452 if ((p = wcsrchr( appname, '\\' ))) appname = p + 1;
453
454 wcscpy( appversion, L"AppDefaults\\" );
455 wcscat( appversion, appname );
456 RtlInitUnicodeString( &nameW, appversion );
457 attr.RootDirectory = config_key;
458
459 /* @@ Wine registry key: HKCU\Software\Wine\AppDefaults\app.exe */
460 if (!NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr ))
461 {
462 TRACE( "getting version from %s\n", debugstr_w(appversion) );
463 got_win_ver = parse_win_version( hkey );
464 NtClose( hkey );
465 }
466
467 if (!got_win_ver)
468 {
469 TRACE( "getting default version\n" );
470 got_win_ver = parse_win_version( config_key );
471 }
472 NtClose( config_key );
473
474 done:
475 if (!got_win_ver)
476 {
477 static RTL_OSVERSIONINFOEXW registry_version;
478
479 TRACE( "getting registry version\n" );
480 if (get_nt_registry_version( &registry_version ) ||
481 get_win9x_registry_version( &registry_version ))
482 current_version = &registry_version;
483 }
484
485
486 NtCurrentTeb()->Peb->OSMajorVersion = current_version->dwMajorVersion;
487 NtCurrentTeb()->Peb->OSMinorVersion = current_version->dwMinorVersion;
488 NtCurrentTeb()->Peb->OSBuildNumber = current_version->dwBuildNumber;
489 NtCurrentTeb()->Peb->OSPlatformId = current_version->dwPlatformId;
490
491 TRACE( "got %d.%d platform %d build %x name %s service pack %d.%d product %d\n",
492 current_version->dwMajorVersion, current_version->dwMinorVersion,
493 current_version->dwPlatformId, current_version->dwBuildNumber,
494 debugstr_w(current_version->szCSDVersion),
495 current_version->wServicePackMajor, current_version->wServicePackMinor,
496 current_version->wProductType );
497 }
498
499 /***********************************************************************
500 * RtlGetProductInfo (NTDLL.@)
501 *
502 * Gives info about the current Windows product type, in a format compatible
503 * with the given Windows version
504 *
505 * Returns TRUE if the input is valid, FALSE otherwise
506 */
507 BOOLEAN WINAPI RtlGetProductInfo(DWORD dwOSMajorVersion, DWORD dwOSMinorVersion, DWORD dwSpMajorVersion,
508 DWORD dwSpMinorVersion, PDWORD pdwReturnedProductType)
509 {
510 TRACE("(%d, %d, %d, %d, %p)\n", dwOSMajorVersion, dwOSMinorVersion,
511 dwSpMajorVersion, dwSpMinorVersion, pdwReturnedProductType);
512
513 if (!pdwReturnedProductType)
514 return FALSE;
515
516 if (dwOSMajorVersion < 6)
517 {
518 *pdwReturnedProductType = PRODUCT_UNDEFINED;
519 return FALSE;
520 }
521
522 if (current_version->wProductType == VER_NT_WORKSTATION)
523 *pdwReturnedProductType = PRODUCT_ULTIMATE_N;
524 else
525 *pdwReturnedProductType = PRODUCT_STANDARD_SERVER;
526
527 return TRUE;
528 }
529
530 /***********************************************************************
531 * RtlGetVersion (NTDLL.@)
532 */
533 NTSTATUS WINAPI RtlGetVersion( RTL_OSVERSIONINFOEXW *info )
534 {
535 info->dwMajorVersion = current_version->dwMajorVersion;
536 info->dwMinorVersion = current_version->dwMinorVersion;
537 info->dwBuildNumber = current_version->dwBuildNumber;
538 info->dwPlatformId = current_version->dwPlatformId;
539 wcscpy( info->szCSDVersion, current_version->szCSDVersion );
540 if(info->dwOSVersionInfoSize == sizeof(RTL_OSVERSIONINFOEXW))
541 {
542 info->wServicePackMajor = current_version->wServicePackMajor;
543 info->wServicePackMinor = current_version->wServicePackMinor;
544 info->wSuiteMask = current_version->wSuiteMask;
545 info->wProductType = current_version->wProductType;
546 }
547 return STATUS_SUCCESS;
548 }
549
550
551 /******************************************************************************
552 * RtlGetNtVersionNumbers (NTDLL.@)
553 *
554 * Get the version numbers of the run time library.
555 *
556 * PARAMS
557 * major [O] Destination for the Major version
558 * minor [O] Destination for the Minor version
559 * build [O] Destination for the Build version
560 *
561 * RETURNS
562 * Nothing.
563 *
564 * NOTES
565 * Introduced in Windows XP (NT5.1)
566 */
567 void WINAPI RtlGetNtVersionNumbers( LPDWORD major, LPDWORD minor, LPDWORD build )
568 {
569 if (major) *major = current_version->dwMajorVersion;
570 if (minor) *minor = current_version->dwMinorVersion;
571 /* FIXME: Does anybody know the real formula? */
572 if (build) *build = (0xF0000000 | current_version->dwBuildNumber);
573 }
574
575
576 /******************************************************************************
577 * RtlGetNtProductType (NTDLL.@)
578 */
579 BOOLEAN WINAPI RtlGetNtProductType( LPDWORD type )
580 {
581 if (type) *type = current_version->wProductType;
582 return TRUE;
583 }
584
585 static inline UCHAR version_update_condition(UCHAR *last_condition, UCHAR condition)
586 {
587 switch (*last_condition)
588 {
589 case 0:
590 *last_condition = condition;
591 break;
592 case VER_EQUAL:
593 if (condition >= VER_EQUAL && condition <= VER_LESS_EQUAL)
594 {
595 *last_condition = condition;
596 return condition;
597 }
598 break;
599 case VER_GREATER:
600 case VER_GREATER_EQUAL:
601 if (condition >= VER_EQUAL && condition <= VER_GREATER_EQUAL)
602 return condition;
603 break;
604 case VER_LESS:
605 case VER_LESS_EQUAL:
606 if (condition == VER_EQUAL || (condition >= VER_LESS && condition <= VER_LESS_EQUAL))
607 return condition;
608 break;
609 }
610 if (!condition) *last_condition |= 0x10;
611 return *last_condition & 0xf;
612 }
613
614 static inline NTSTATUS version_compare_values(ULONG left, ULONG right, UCHAR condition)
615 {
616 switch (condition) {
617 case VER_EQUAL:
618 if (left != right) return STATUS_REVISION_MISMATCH;
619 break;
620 case VER_GREATER:
621 if (left <= right) return STATUS_REVISION_MISMATCH;
622 break;
623 case VER_GREATER_EQUAL:
624 if (left < right) return STATUS_REVISION_MISMATCH;
625 break;
626 case VER_LESS:
627 if (left >= right) return STATUS_REVISION_MISMATCH;
628 break;
629 case VER_LESS_EQUAL:
630 if (left > right) return STATUS_REVISION_MISMATCH;
631 break;
632 default:
633 return STATUS_REVISION_MISMATCH;
634 }
635 return STATUS_SUCCESS;
636 }
637
638 /******************************************************************************
639 * RtlVerifyVersionInfo (NTDLL.@)
640 */
641 NTSTATUS WINAPI RtlVerifyVersionInfo( const RTL_OSVERSIONINFOEXW *info,
642 DWORD dwTypeMask, DWORDLONG dwlConditionMask )
643 {
644 RTL_OSVERSIONINFOEXW ver;
645 NTSTATUS status;
646
647 TRACE("(%p,0x%x,0x%s)\n", info, dwTypeMask, wine_dbgstr_longlong(dwlConditionMask));
648
649 ver.dwOSVersionInfoSize = sizeof(ver);
650 if ((status = RtlGetVersion( &ver )) != STATUS_SUCCESS) return status;
651
652 if(!(dwTypeMask && dwlConditionMask)) return STATUS_INVALID_PARAMETER;
653
654 if(dwTypeMask & VER_PRODUCT_TYPE)
655 {
656 status = version_compare_values(ver.wProductType, info->wProductType, dwlConditionMask >> 7*3 & 0x07);
657 if (status != STATUS_SUCCESS)
658 return status;
659 }
660 if(dwTypeMask & VER_SUITENAME)
661 switch(dwlConditionMask >> 6*3 & 0x07)
662 {
663 case VER_AND:
664 if((info->wSuiteMask & ver.wSuiteMask) != info->wSuiteMask)
665 return STATUS_REVISION_MISMATCH;
666 break;
667 case VER_OR:
668 if(!(info->wSuiteMask & ver.wSuiteMask) && info->wSuiteMask)
669 return STATUS_REVISION_MISMATCH;
670 break;
671 default:
672 return STATUS_INVALID_PARAMETER;
673 }
674 if(dwTypeMask & VER_PLATFORMID)
675 {
676 status = version_compare_values(ver.dwPlatformId, info->dwPlatformId, dwlConditionMask >> 3*3 & 0x07);
677 if (status != STATUS_SUCCESS)
678 return status;
679 }
680 if(dwTypeMask & VER_BUILDNUMBER)
681 {
682 status = version_compare_values(ver.dwBuildNumber, info->dwBuildNumber, dwlConditionMask >> 2*3 & 0x07);
683 if (status != STATUS_SUCCESS)
684 return status;
685 }
686
687 if(dwTypeMask & (VER_MAJORVERSION|VER_MINORVERSION|VER_SERVICEPACKMAJOR|VER_SERVICEPACKMINOR))
688 {
689 unsigned char condition, last_condition = 0;
690 BOOLEAN do_next_check = TRUE;
691
692 if(dwTypeMask & VER_MAJORVERSION)
693 {
694 condition = version_update_condition(&last_condition, dwlConditionMask >> 1*3 & 0x07);
695 status = version_compare_values(ver.dwMajorVersion, info->dwMajorVersion, condition);
696 do_next_check = (ver.dwMajorVersion == info->dwMajorVersion) &&
697 ((condition >= VER_EQUAL) && (condition <= VER_LESS_EQUAL));
698 }
699 if((dwTypeMask & VER_MINORVERSION) && do_next_check)
700 {
701 condition = version_update_condition(&last_condition, dwlConditionMask >> 0*3 & 0x07);
702 status = version_compare_values(ver.dwMinorVersion, info->dwMinorVersion, condition);
703 do_next_check = (ver.dwMinorVersion == info->dwMinorVersion) &&
704 ((condition >= VER_EQUAL) && (condition <= VER_LESS_EQUAL));
705 }
706 if((dwTypeMask & VER_SERVICEPACKMAJOR) && do_next_check)
707 {
708 condition = version_update_condition(&last_condition, dwlConditionMask >> 5*3 & 0x07);
709 status = version_compare_values(ver.wServicePackMajor, info->wServicePackMajor, condition);
710 do_next_check = (ver.wServicePackMajor == info->wServicePackMajor) &&
711 ((condition >= VER_EQUAL) && (condition <= VER_LESS_EQUAL));
712 }
713 if((dwTypeMask & VER_SERVICEPACKMINOR) && do_next_check)
714 {
715 condition = version_update_condition(&last_condition, dwlConditionMask >> 4*3 & 0x07);
716 status = version_compare_values(ver.wServicePackMinor, info->wServicePackMinor, condition);
717 }
718
719 if (status != STATUS_SUCCESS)
720 return status;
721 }
722
723 return STATUS_SUCCESS;
724 }
Zebediah Figura's local tree