misc/version.c

   1 /*
   2  * Windows and DOS version functions
   3  *
   4  * Copyright 1997 Alexandre Julliard
   5  * Copyright 1997 Marcus Meissner
   6  * Copyright 1998 Patrik Stridvall
   7  * Copyright 1998 Andreas Mohr
   8  */
   9
  10 #include <string.h>
  11 #include <stdlib.h>
  12 #include "winbase.h"
  13 #include "winuser.h"
  14 #include "wine/winbase16.h"
  15 #include "process.h"
  16 #include "options.h"
  17 #include "debugtools.h"
  18 #include "neexe.h"
  19 #include "winversion.h"
  20
  21 DEFAULT_DEBUG_CHANNEL(ver)
  22
  23 typedef struct
  24 {
  25     LONG             getVersion16;
  26     LONG             getVersion32;
  27     OSVERSIONINFOA getVersionEx;
  28 } VERSION_DATA;
  29
  30
  31 /* FIXME: compare values below with original and fix */
  32 static VERSION_DATA VersionData[NB_WINDOWS_VERSIONS] =
  33 {
  34     /* WIN31 */
  35     {
  36         MAKELONG( 0x0a03, 0x0616 ), /* DOS 6.22 */
  37         MAKELONG( 0x0a03, 0x8000 ),
  38         {
  39             sizeof(OSVERSIONINFOA), 3, 10, 0,
  40             VER_PLATFORM_WIN32s, "Win32s 1.3"
  41         }
  42     },
  43     /* WIN95 */
  44     {
  45         0x07005F03,
  46         0xC0000004,
  47         {
  48             sizeof(OSVERSIONINFOA), 4, 0, 0x40003B6,
  49             VER_PLATFORM_WIN32_WINDOWS, "Win95"
  50         }
  51     },
  52     /* WIN98 */
  53     {
  54         0x07005F03,     /* FIXME: need DOS value from real Win98 */
  55         0xC0000A04,
  56         {
  57             sizeof(OSVERSIONINFOA), 4, 10, 0x40A07CE,
  58             VER_PLATFORM_WIN32_WINDOWS, "Win98"
  59         }
  60     },
  61     /* NT351 */
  62     {
  63         0x05000A03,
  64         0x04213303,
  65         {
  66             sizeof(OSVERSIONINFOA), 3, 51, 0x421,
  67             VER_PLATFORM_WIN32_NT, "Service Pack 2"
  68         }
  69     },
  70     /* NT40 */
  71     {
  72         0x05000A03,
  73         0x05650004,
  74         {
  75             sizeof(OSVERSIONINFOA), 4, 0, 0x565,
  76             VER_PLATFORM_WIN32_NT, "Service Pack 3"
  77         }
  78     }
  79 };
  80
  81 static const char *WinVersionNames[NB_WINDOWS_VERSIONS] =
  82 {
  83     "win31",
  84     "win95",
  85     "win98",
  86     "nt351",
  87     "nt40"
  88 };
  89
  90 /* the current version has not been autodetected but forced via cmdline */
  91 static BOOL versionForced = FALSE;
  92 static WINDOWS_VERSION defaultWinVersion = WIN31;
  93
  94
  95 /**********************************************************************
  96  *         VERSION_ParseWinVersion
  97  */
  98 void VERSION_ParseWinVersion( const char *arg )
  99 {
 100     int i;
 101     for (i = 0; i < NB_WINDOWS_VERSIONS; i++)
 102     {
 103         if (!strcmp( WinVersionNames[i], arg ))
 104         {
 105             defaultWinVersion = (WINDOWS_VERSION)i;
 106             versionForced = TRUE;
 107             return;
 108         }
 109     }
 110     MESSAGE("Invalid winver value '%s' specified.\n", arg );
 111     MESSAGE("Valid versions are:" );
 112     for (i = 0; i < NB_WINDOWS_VERSIONS; i++)
 113         MESSAGE(" '%s'%c", WinVersionNames[i],
 114             (i == NB_WINDOWS_VERSIONS - 1) ? '\n' : ',' );
 115 }
 116
 117
 118 /**********************************************************************
 119  *         VERSION_ParseDosVersion
 120  */
 121 void VERSION_ParseDosVersion( const char *arg )
 122 {
 123     int hi, lo;
 124     if (sscanf( arg, "%d.%d", &hi, &lo ) == 2)
 125     {
 126         VersionData[WIN31].getVersion16 =
 127             MAKELONG(LOWORD(VersionData[WIN31].getVersion16),
 128                      (hi<<8) + lo);
 129     }
 130     else
 131         fprintf( stderr, "-dosver: Wrong version format. Use \"-dosver x.xx\"\n");
 132 }
 133
 134
 135 WINDOWS_VERSION VERSION_GetImageVersion(PDB *pdb)
 136 {
 137     PIMAGE_NT_HEADERS peheader;
 138
 139         if (!pdb->exe_modref)
 140         {
 141                 /* HACK: if we have loaded a PE image into this address space,
 142                  * we are probably using thunks, so Win95 is our best bet
 143                  */
 144                 if (pdb->modref_list)
 145                         return WIN95;
 146                 /* FIXME: hmm, do anything else ?
 147                    TDB.version doesn't help here
 148                    as it always holds version 3.10 */
 149                         return WIN31;
 150         }
 151         else
 152         {
 153                 peheader = PE_HEADER(pdb->exe_modref->module);
 154 #define OPTHD peheader->OptionalHeader
 155
 156                 TRACE("%02x.%02x/%02x.%02x/%02x.%02x/%02x.%02x\n",
 157                           OPTHD.MajorLinkerVersion,
 158                           OPTHD.MinorLinkerVersion,
 159                           OPTHD.MajorOperatingSystemVersion,
 160                           OPTHD.MinorOperatingSystemVersion,
 161                           OPTHD.MajorImageVersion,
 162                           OPTHD.MinorImageVersion,
 163                           OPTHD.MajorSubsystemVersion,
 164                           OPTHD.MinorSubsystemVersion);
 165
 166         switch (OPTHD.MajorSubsystemVersion)
 167                 {
 168                         case 4:
 169                                 switch (OPTHD.MajorOperatingSystemVersion)
 170                                 {
 171                                         case 5:
 172                                                 return NT40; /* FIXME: this is NT 5, isn't it ? */
 173                                         case 4:
 174                                                 if ((OPTHD.MajorImageVersion == 0) &&
 175                                                         (OPTHD.SectionAlignment == 4096))
 176                                                         return WIN95;
 177                                                 else
 178                                                         return NT40;
 179                                         case 1:
 180                                                 return WIN95;
 181                                         default:
 182                                                 return WIN95; /* FIXME ? */
 183                                 }
 184                         case 3:
 185                                 /* 3.1x versions */
 186                                 if (OPTHD.MinorSubsystemVersion <= 11)
 187                                 {
 188                                         if (OPTHD.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI)
 189                                                 return NT351; /* FIXME: NT 3.1 */
 190                                         else
 191                                                 return WIN31;
 192                                 }
 193                                 else
 194                                 {
 195                                         /* NT 3.51 */
 196                                         if (OPTHD.MinorSubsystemVersion == 50)
 197                                                 return NT351;
 198                                         else
 199                                         if (OPTHD.MinorSubsystemVersion == 51)
 200                                                 return NT351;
 201                                 }
 202                         default:
 203                                 if (OPTHD.MajorSubsystemVersion)
 204                                 ERR("unknown subsystem version: %04x.%04x, please report.\n",
 205                                         OPTHD.MajorSubsystemVersion,
 206                                         OPTHD.MinorSubsystemVersion );
 207                                 return defaultWinVersion;
 208                 }
 209 #undef OPTHD
 210         }
 211 }
 212
 213
 214 /**********************************************************************
 215  *
 216  * Check the version of COMDLG32, SHELL32, COMCTL32 and CTL3D32.
 217  * Not functional yet.
 218  */
 219 DWORD VERSION_GetLinkedDllVersion(PDB *pdb)
 220 {
 221         WINE_MODREF *wm;
 222     WORD VersionCounter[NB_WINDOWS_VERSIONS];
 223
 224     memset(VersionCounter, 0, sizeof(VersionCounter));
 225
 226         VersionCounter[WIN95] = 1;
 227         for ( wm = PROCESS_Current()->modref_list; wm; wm=wm->next ) {
 228             if (!(lstrncmpiA(wm->modname, "CTL3D32", 7)))
 229                         VersionCounter[WIN95]++;
 230         }
 231
 232         return MAKELONG(WIN95, VersionCounter[WIN95]);
 233 }
 234
 235
 236 /**********************************************************************
 237  *         VERSION_GetVersion
 238  *
 239  * Some version data:
 240  * linker/OS/image/subsys       Name                    Intended for
 241  *
 242  * 2.39/1.00/0.00/3.10          freecell.exe    Win32s (any version)
 243  * 2.55/1.00/0.00/4.00          acrord32.exe    Win32s, Win95 supported (?)
 244  *
 245  * 2.50/1.00/4.00/4.00          winhlp32.exe    Win32s 1.30
 246  * 4.20/4.00/1.00/4.00          Asuslm.exe              Win95 (Aaargh !)
 247  * 5.12/4.00/1.07/4.00      clikfixi.exe    NT 4 (service pack files)
 248  * 3.10/4.00/4.00/4.00          PLUMBING.EXE    NT
 249  * ?.??/4.00/97.01/4.00         sse.exe                 huh ?? (damn crackerz ;)
 250  * 5.12/5.00/5.00/4.00          comctl32.dll    NT4 / IE 5.0
 251  * 6.00/5.00/5.00/4.00                                          NT 4 driver update (strange numbers)
 252  *
 253  * Common versions:
 254  * x.xx/1.00/0.00/3.10                                          Win32s (any version ?)
 255  * 2.xx/1.00/0.00/4.00                                          Win95 (Microsoft/system files)
 256  * x.xx/4.00/0.00/4.00                                          Win95 (most applications !)
 257  * x.xx/4.00/4.00/4.00                                          NT 4 (most apps)
 258  * x.xx/5.00/5.00/4.00                                          NT 4 newer files / NT 5 ??
 259  */
 260 WINDOWS_VERSION VERSION_GetVersion(void)
 261 {
 262     PDB *pdb = PROCESS_Current();
 263     DWORD DllVer;
 264
 265     if (versionForced) /* user has overridden any sensible checks */
 266         return defaultWinVersion;
 267
 268     if (pdb->winver == 0xffff) /* to be determined */
 269         {
 270                 DllVer = 0/*VERSION_GetLinkedDllVersion(pdb)*/;
 271                 if (HIWORD(DllVer) > 1)
 272                         pdb->winver = LOWORD(DllVer);
 273             else
 274                         pdb->winver = VERSION_GetImageVersion(pdb);
 275         }
 276
 277         return pdb->winver;
 278 }
 279
 280
 281 /**********************************************************************
 282  *         VERSION_GetVersionName
 283  */
 284 char *VERSION_GetVersionName()
 285 {
 286   WINDOWS_VERSION ver = VERSION_GetVersion();
 287   switch(ver)
 288     {
 289     case WIN31:
 290       return "Windows 3.1";
 291     case WIN95:
 292       return "Windows 95";
 293     case WIN98:
 294       return "Windows 98";
 295     case NT351:
 296       return "Windows NT 3.51";
 297     case NT40:
 298       return "Windows NT 4.0";
 299     default:
 300       FIXME("Windows version %d not named",ver);
 301       return "Windows <Unknown>";
 302     }
 303 }
 304
 305 /***********************************************************************
 306  *         GetVersion16   (KERNEL.3)
 307  */
 308 LONG WINAPI GetVersion16(void)
 309 {
 310     WINDOWS_VERSION ver = VERSION_GetVersion();
 311     return VersionData[ver].getVersion16;
 312 }
 313
 314
 315 /***********************************************************************
 316  *         GetVersion32   (KERNEL32.427)
 317  */
 318 LONG WINAPI GetVersion(void)
 319 {
 320     WINDOWS_VERSION ver = VERSION_GetVersion();
 321     return VersionData[ver].getVersion32;
 322 }
 323
 324
 325 /***********************************************************************
 326  *         GetVersionEx16   (KERNEL.149)
 327  */
 328 BOOL16 WINAPI GetVersionEx16(OSVERSIONINFO16 *v)
 329 {
 330     WINDOWS_VERSION ver = VERSION_GetVersion();
 331     if (v->dwOSVersionInfoSize != sizeof(OSVERSIONINFO16))
 332     {
 333         WARN("wrong OSVERSIONINFO size from app");
 334         return FALSE;
 335     }
 336     v->dwMajorVersion = VersionData[ver].getVersionEx.dwMajorVersion;
 337     v->dwMinorVersion = VersionData[ver].getVersionEx.dwMinorVersion;
 338     v->dwBuildNumber  = VersionData[ver].getVersionEx.dwBuildNumber;
 339     v->dwPlatformId   = VersionData[ver].getVersionEx.dwPlatformId;
 340     strcpy( v->szCSDVersion, VersionData[ver].getVersionEx.szCSDVersion );
 341     return TRUE;
 342 }
 343
 344
 345 /***********************************************************************
 346  *         GetVersionEx32A   (KERNEL32.428)
 347  */
 348 BOOL WINAPI GetVersionExA(OSVERSIONINFOA *v)
 349 {
 350     WINDOWS_VERSION ver = VERSION_GetVersion();
 351     if (v->dwOSVersionInfoSize != sizeof(OSVERSIONINFOA))
 352     {
 353         WARN("wrong OSVERSIONINFO size from app");
 354         return FALSE;
 355     }
 356     v->dwMajorVersion = VersionData[ver].getVersionEx.dwMajorVersion;
 357     v->dwMinorVersion = VersionData[ver].getVersionEx.dwMinorVersion;
 358     v->dwBuildNumber  = VersionData[ver].getVersionEx.dwBuildNumber;
 359     v->dwPlatformId   = VersionData[ver].getVersionEx.dwPlatformId;
 360     strcpy( v->szCSDVersion, VersionData[ver].getVersionEx.szCSDVersion );
 361     return TRUE;
 362 }
 363
 364
 365 /***********************************************************************
 366  *         GetVersionEx32W   (KERNEL32.429)
 367  */
 368 BOOL WINAPI GetVersionExW(OSVERSIONINFOW *v)
 369 {
 370     WINDOWS_VERSION ver = VERSION_GetVersion();
 371
 372     if (v->dwOSVersionInfoSize!=sizeof(OSVERSIONINFOW))
 373     {
 374         WARN("wrong OSVERSIONINFO size from app");
 375         return FALSE;
 376     }
 377     v->dwMajorVersion = VersionData[ver].getVersionEx.dwMajorVersion;
 378     v->dwMinorVersion = VersionData[ver].getVersionEx.dwMinorVersion;
 379     v->dwBuildNumber  = VersionData[ver].getVersionEx.dwBuildNumber;
 380     v->dwPlatformId   = VersionData[ver].getVersionEx.dwPlatformId;
 381     lstrcpyAtoW( v->szCSDVersion, VersionData[ver].getVersionEx.szCSDVersion );
 382     return TRUE;
 383 }
 384
 385
 386 /***********************************************************************
 387  *          GetWinFlags   (KERNEL.132)
 388  */
 389 DWORD WINAPI GetWinFlags16(void)
 390 {
 391   static const long cpuflags[5] =
 392     { WF_CPU086, WF_CPU186, WF_CPU286, WF_CPU386, WF_CPU486 };
 393   SYSTEM_INFO si;
 394   OSVERSIONINFOA ovi;
 395   DWORD result;
 396
 397   GetSystemInfo(&si);
 398
 399   /* There doesn't seem to be any Pentium flag.  */
 400   result = cpuflags[MIN (si.wProcessorLevel, 4)];
 401
 402   switch(Options.mode)
 403   {
 404   case MODE_STANDARD:
 405       result |= WF_STANDARD | WF_PMODE | WF_80x87;
 406       break;
 407
 408   case MODE_ENHANCED:
 409       result |= WF_ENHANCED | WF_PMODE | WF_80x87 | WF_PAGING;
 410       break;
 411
 412   default:
 413       ERR("Unknown mode set? This shouldn't happen. Check GetWinFlags()!\n");
 414       break;
 415   }
 416   if (si.wProcessorLevel >= 4) result |= WF_HASCPUID;
 417   ovi.dwOSVersionInfoSize = sizeof(ovi);
 418   GetVersionExA(&ovi);
 419   if (ovi.dwPlatformId == VER_PLATFORM_WIN32_NT)
 420       result |= WF_WIN32WOW; /* undocumented WF_WINNT */
 421   return result;
 422 }
 423
 424
 425 /***********************************************************************
 426  *          GetWinDebugInfo   (KERNEL.355)
 427  */
 428 BOOL16 WINAPI GetWinDebugInfo16(WINDEBUGINFO *lpwdi, UINT16 flags)
 429 {
 430     FIXME("(%8lx,%d): stub returning 0\n",
 431           (unsigned long)lpwdi, flags);
 432     /* 0 means not in debugging mode/version */
 433     /* Can this type of debugging be used in wine ? */
 434     /* Constants: WDI_OPTIONS WDI_FILTER WDI_ALLOCBREAK */
 435     return 0;
 436 }
 437
 438
 439 /***********************************************************************
 440  *          SetWinDebugInfo   (KERNEL.356)
 441  */
 442 BOOL16 WINAPI SetWinDebugInfo16(WINDEBUGINFO *lpwdi)
 443 {
 444     FIXME("(%8lx): stub returning 0\n", (unsigned long)lpwdi);
 445     /* 0 means not in debugging mode/version */
 446     /* Can this type of debugging be used in wine ? */
 447     /* Constants: WDI_OPTIONS WDI_FILTER WDI_ALLOCBREAK */
 448     return 0;
 449 }
 450
 451
 452 /***********************************************************************
 453  *           DebugFillBuffer                    (KERNEL.329)
 454  *
 455  * TODO:
 456  * Should fill lpBuffer only if DBO_BUFFERFILL has been set by SetWinDebugInfo()
 457  */
 458 void WINAPI DebugFillBuffer(LPSTR lpBuffer, WORD wBytes)
 459 {
 460         memset(lpBuffer, DBGFILL_BUFFER, wBytes);
 461 }
 462
 463 /***********************************************************************
 464  *           DiagQuery                          (KERNEL.339)
 465  *
 466  * returns TRUE if Win called with "/b" (bootlog.txt)
 467  */
 468 BOOL16 WINAPI DiagQuery16()
 469 {
 470         /* perhaps implement a Wine "/b" command line flag sometime ? */
 471         return FALSE;
 472 }
 473
 474 /***********************************************************************
 475  *           DiagOutput                         (KERNEL.340)
 476  *
 477  * writes a debug string into <windir>\bootlog.txt
 478  */
 479 void WINAPI DiagOutput16(LPCSTR str)
 480 {
 481         /* FIXME */
 482         DPRINTF("DIAGOUTPUT:%s\n", debugstr_a(str));
 483 }
 484
 485 /***********************************************************************
 486  *           OaBuildVersion           [OLEAUT32.170]
 487  */
 488 UINT WINAPI OaBuildVersion()
 489 {
 490     WINDOWS_VERSION ver = VERSION_GetVersion();
 491
 492     FIXME("Please report to a.mohr@mailto.de if you get version error messages !\n");
 493     switch(VersionData[ver].getVersion32)
 494     {
 495         case 0x80000a03: /* Win 3.1 */
 496                 return 0x140fd1; /* from Win32s 1.1e */
 497         case 0xc0000004: /* Win 95 */
 498          case 0xc0000a04: /* Win 98: verified same as Win95 */
 499                 return 0x1e10a9; /* some older version: 0x0a0bd3 */
 500         case 0x04213303: /* NT 3.51 */
 501                 FIXME("NT 3.51 version value unknown !\n");
 502                 return 0x1e10a9; /* value borrowed from Win95 */
 503         case 0x05650004: /* NT 4.0 */
 504                 return 0x141016;
 505         default:
 506                 return 0x0;
 507     }
 508 }
 509 /***********************************************************************
 510  *        VERSION_OsIsUnicode   [internal]
 511  *
 512  * NOTES
 513  *   some functions getting sometimes LPSTR sometimes LPWSTR...
 514  *
 515  */
 516 BOOL VERSION_OsIsUnicode(void)
 517 {
 518     switch(VERSION_GetVersion())
 519     {
 520     case NT351:
 521     case NT40:
 522         return TRUE;
 523     default:
 524         return FALSE;
 525     }
 526 }