git.oblomov.eu Git - wine/blob - 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 "windows.h"
  13 #include "winbase.h"
  14 #include "process.h"
  15 #include "options.h"
  16 #include "debug.h"
  17 #include "ole.h"
  18 #include "winversion.h"
  19
  20 typedef struct
  21 {
  22     LONG             getVersion16;
  23     LONG             getVersion32;
  24     OSVERSIONINFO32A getVersionEx;
  25 } VERSION_DATA;
  26
  27
  28 /* FIXME: compare values below with original and fix */
  29 static VERSION_DATA VersionData[NB_WINDOWS_VERSIONS] =
  30 {
  31     /* WIN31 */
  32     {
  33         MAKELONG( 0x0a03, 0x0616 ), /* DOS 6.22 */
  34         MAKELONG( 0x0a03, 0x8000 ),
  35         {
  36             sizeof(OSVERSIONINFO32A), 3, 10, 0,
  37             VER_PLATFORM_WIN32s, "Win32s 1.3"
  38         }
  39     },
  40     /* WIN95 */
  41     {
  42         0x07005F03,
  43         0xC0000004,
  44         {
  45             sizeof(OSVERSIONINFO32A), 4, 0, 0x40003B6,
  46             VER_PLATFORM_WIN32_WINDOWS, "Win95"
  47         }
  48     },
  49     /* NT351 */
  50     {
  51         0x05000A03,
  52         0x04213303,
  53         {
  54             sizeof(OSVERSIONINFO32A), 3, 51, 0x421,
  55             VER_PLATFORM_WIN32_NT, "Service Pack 2"
  56         }
  57     },
  58     /* NT40 */
  59     {
  60         0x05000A03,
  61         0x05650004,
  62         {
  63             sizeof(OSVERSIONINFO32A), 4, 0, 0x565,
  64             VER_PLATFORM_WIN32_NT, "Service Pack 3"
  65         }
  66     }
  67 };
  68
  69 static const char *WinVersionNames[NB_WINDOWS_VERSIONS] =
  70 {
  71     "win31",
  72     "win95",
  73     "nt351",
  74     "nt40"
  75 };
  76
  77 /* the current version has not been autodetected but forced via cmdline */
  78 static BOOL32 versionForced = FALSE;
  79 static WINDOWS_VERSION defaultWinVersion = WIN31;
  80
  81
  82 /**********************************************************************
  83  *         VERSION_ParseWinVersion
  84  */
  85 void VERSION_ParseWinVersion( const char *arg )
  86 {
  87     int i;
  88     for (i = 0; i < NB_WINDOWS_VERSIONS; i++)
  89     {
  90         if (!strcmp( WinVersionNames[i], arg ))
  91         {
  92             defaultWinVersion = (WINDOWS_VERSION)i;
  93             versionForced = TRUE;
  94             return;
  95         }
  96     }
  97     MSG("Invalid winver value '%s' specified.\n", arg );
  98     MSG("Valid versions are:" );
  99     for (i = 0; i < NB_WINDOWS_VERSIONS; i++)
 100         MSG(" '%s'%c", WinVersionNames[i],
 101             (i == NB_WINDOWS_VERSIONS - 1) ? '\n' : ',' );
 102 }
 103
 104
 105 /**********************************************************************
 106  *         VERSION_ParseDosVersion
 107  */
 108 void VERSION_ParseDosVersion( const char *arg )
 109 {
 110     int hi, lo;
 111     if (sscanf( arg, "%d.%d", &hi, &lo ) == 2)
 112     {
 113         VersionData[WIN31].getVersion16 =
 114             MAKELONG(LOWORD(VersionData[WIN31].getVersion16),
 115                      (hi<<8) + lo);
 116     }
 117     else
 118         fprintf( stderr, "-dosver: Wrong version format. Use \"-dosver x.xx\"\n");
 119 }
 120
 121
 122 /**********************************************************************
 123  *         VERSION_GetVersion
 124  */
 125 WINDOWS_VERSION VERSION_GetVersion(void)
 126 {
 127     PIMAGE_NT_HEADERS peheader;
 128
 129     if (versionForced) /* user has overridden any sensible checks */
 130         return defaultWinVersion;
 131     if (!PROCESS_Current()->exe_modref)
 132     {
 133         /* HACK: if we have loaded a PE image into this address space,
 134          * we are probably using thunks, so Win95 is our best bet
 135          */
 136         if (PROCESS_Current()->modref_list) return WIN95;
 137         return WIN31; /* FIXME: hmm, look at DDB.version ? */
 138     }
 139     peheader = PE_HEADER(PROCESS_Current()->exe_modref->module);
 140     if (peheader->OptionalHeader.MajorSubsystemVersion == 4) {
 141         /* FIXME: check probably not 100% good, verify with win98 too */
 142         if (peheader->OptionalHeader.MajorOperatingSystemVersion == 4)
 143             return NT40;
 144         return WIN95;
 145     }
 146     if (peheader->OptionalHeader.MajorSubsystemVersion == 3)
 147     {
 148         /* Win3.10 */
 149         if (peheader->OptionalHeader.MinorSubsystemVersion <= 11) return WIN31;
 150         /* NT 3.51 */
 151         if (peheader->OptionalHeader.MinorSubsystemVersion == 50) return NT351;
 152         if (peheader->OptionalHeader.MinorSubsystemVersion == 51) return NT351;
 153     }
 154     if (peheader->OptionalHeader.MajorSubsystemVersion)
 155         ERR(ver,"unknown subsystem version: %04x.%04x, please report.\n",
 156             peheader->OptionalHeader.MajorSubsystemVersion,
 157             peheader->OptionalHeader.MinorSubsystemVersion );
 158     return defaultWinVersion;
 159 }
 160
 161
 162 /**********************************************************************
 163  *         VERSION_GetVersionName
 164  */
 165 char *VERSION_GetVersionName()
 166 {
 167   WINDOWS_VERSION ver = VERSION_GetVersion();
 168   switch(ver)
 169     {
 170     case WIN31:
 171       return "Windows 3.1";
 172     case WIN95:
 173       return "Windows 95";
 174     case NT351:
 175       return "Windows NT 3.51";
 176     case NT40:
 177       return "Windows NT 4.0";
 178     default:
 179       FIXME(ver,"Windows version %d not named",ver);
 180       return "Windows <Unknown>";
 181     }
 182 }
 183
 184 /***********************************************************************
 185  *         GetVersion16   (KERNEL.3)
 186  */
 187 LONG WINAPI GetVersion16(void)
 188 {
 189     WINDOWS_VERSION ver = VERSION_GetVersion();
 190     return VersionData[ver].getVersion16;
 191 }
 192
 193
 194 /***********************************************************************
 195  *         GetVersion32   (KERNEL32.427)
 196  */
 197 LONG WINAPI GetVersion32(void)
 198 {
 199     WINDOWS_VERSION ver = VERSION_GetVersion();
 200     return VersionData[ver].getVersion32;
 201 }
 202
 203
 204 /***********************************************************************
 205  *         GetVersionEx16   (KERNEL.149)
 206  */
 207 BOOL16 WINAPI GetVersionEx16(OSVERSIONINFO16 *v)
 208 {
 209     WINDOWS_VERSION ver = VERSION_GetVersion();
 210     if (v->dwOSVersionInfoSize != sizeof(OSVERSIONINFO16))
 211     {
 212         WARN(ver,"wrong OSVERSIONINFO size from app");
 213         return FALSE;
 214     }
 215     v->dwMajorVersion = VersionData[ver].getVersionEx.dwMajorVersion;
 216     v->dwMinorVersion = VersionData[ver].getVersionEx.dwMinorVersion;
 217     v->dwBuildNumber  = VersionData[ver].getVersionEx.dwBuildNumber;
 218     v->dwPlatformId   = VersionData[ver].getVersionEx.dwPlatformId;
 219     strcpy( v->szCSDVersion, VersionData[ver].getVersionEx.szCSDVersion );
 220     return TRUE;
 221 }
 222
 223
 224 /***********************************************************************
 225  *         GetVersionEx32A   (KERNEL32.428)
 226  */
 227 BOOL32 WINAPI GetVersionEx32A(OSVERSIONINFO32A *v)
 228 {
 229     WINDOWS_VERSION ver = VERSION_GetVersion();
 230     if (v->dwOSVersionInfoSize != sizeof(OSVERSIONINFO32A))
 231     {
 232         WARN(ver,"wrong OSVERSIONINFO size from app");
 233         return FALSE;
 234     }
 235     v->dwMajorVersion = VersionData[ver].getVersionEx.dwMajorVersion;
 236     v->dwMinorVersion = VersionData[ver].getVersionEx.dwMinorVersion;
 237     v->dwBuildNumber  = VersionData[ver].getVersionEx.dwBuildNumber;
 238     v->dwPlatformId   = VersionData[ver].getVersionEx.dwPlatformId;
 239     strcpy( v->szCSDVersion, VersionData[ver].getVersionEx.szCSDVersion );
 240     return TRUE;
 241 }
 242
 243
 244 /***********************************************************************
 245  *         GetVersionEx32W   (KERNEL32.429)
 246  */
 247 BOOL32 WINAPI GetVersionEx32W(OSVERSIONINFO32W *v)
 248 {
 249     WINDOWS_VERSION ver = VERSION_GetVersion();
 250
 251     if (v->dwOSVersionInfoSize!=sizeof(OSVERSIONINFO32W))
 252     {
 253         WARN(ver,"wrong OSVERSIONINFO size from app");
 254         return FALSE;
 255     }
 256     v->dwMajorVersion = VersionData[ver].getVersionEx.dwMajorVersion;
 257     v->dwMinorVersion = VersionData[ver].getVersionEx.dwMinorVersion;
 258     v->dwBuildNumber  = VersionData[ver].getVersionEx.dwBuildNumber;
 259     v->dwPlatformId   = VersionData[ver].getVersionEx.dwPlatformId;
 260     lstrcpyAtoW( v->szCSDVersion, VersionData[ver].getVersionEx.szCSDVersion );
 261     return TRUE;
 262 }
 263
 264
 265 /***********************************************************************
 266  *          GetWinFlags   (KERNEL.132)
 267  */
 268 DWORD WINAPI GetWinFlags(void)
 269 {
 270   static const long cpuflags[5] =
 271     { WF_CPU086, WF_CPU186, WF_CPU286, WF_CPU386, WF_CPU486 };
 272   SYSTEM_INFO si;
 273   OSVERSIONINFO32A ovi;
 274   DWORD result;
 275
 276   GetSystemInfo(&si);
 277
 278   /* There doesn't seem to be any Pentium flag.  */
 279   result = cpuflags[MIN (si.wProcessorLevel, 4)];
 280
 281   switch(Options.mode)
 282   {
 283   case MODE_STANDARD:
 284       result |= WF_STANDARD | WF_PMODE | WF_80x87;
 285       break;
 286
 287   case MODE_ENHANCED:
 288       result |= WF_ENHANCED | WF_PMODE | WF_80x87 | WF_PAGING;
 289       break;
 290
 291   default:
 292       ERR(ver, "Unknown mode set? This shouldn't happen. Check GetWinFlags()!\n");
 293       break;
 294   }
 295   if (si.wProcessorLevel >= 4) result |= WF_HASCPUID;
 296   ovi.dwOSVersionInfoSize = sizeof(ovi);
 297   GetVersionEx32A(&ovi);
 298   if (ovi.dwPlatformId == VER_PLATFORM_WIN32_NT)
 299       result |= WF_WIN32WOW; /* undocumented WF_WINNT */
 300   return result;
 301 }
 302
 303
 304 /***********************************************************************
 305  *          GetWinDebugInfo   (KERNEL.355)
 306  */
 307 BOOL16 WINAPI GetWinDebugInfo(WINDEBUGINFO *lpwdi, UINT16 flags)
 308 {
 309     FIXME(ver, "(%8lx,%d): stub returning 0\n",
 310           (unsigned long)lpwdi, flags);
 311     /* 0 means not in debugging mode/version */
 312     /* Can this type of debugging be used in wine ? */
 313     /* Constants: WDI_OPTIONS WDI_FILTER WDI_ALLOCBREAK */
 314     return 0;
 315 }
 316
 317
 318 /***********************************************************************
 319  *          SetWinDebugInfo   (KERNEL.356)
 320  */
 321 BOOL16 WINAPI SetWinDebugInfo(WINDEBUGINFO *lpwdi)
 322 {
 323     FIXME(ver, "(%8lx): stub returning 0\n", (unsigned long)lpwdi);
 324     /* 0 means not in debugging mode/version */
 325     /* Can this type of debugging be used in wine ? */
 326     /* Constants: WDI_OPTIONS WDI_FILTER WDI_ALLOCBREAK */
 327     return 0;
 328 }
 329
 330
 331 /***********************************************************************
 332  *           DebugFillBuffer                    (KERNEL.329)
 333  *
 334  * TODO:
 335  * Should fill lpBuffer only if DBO_BUFFERFILL has been set by SetWinDebugInfo()
 336  */
 337 void WINAPI DebugFillBuffer(LPSTR lpBuffer, WORD wBytes)
 338 {
 339         memset(lpBuffer, DBGFILL_BUFFER, wBytes);
 340 }
 341
 342 /***********************************************************************
 343  *           DiagQuery                          (KERNEL.339)
 344  *
 345  * returns TRUE if Win called with "/b" (bootlog.txt)
 346  */
 347 BOOL16 WINAPI DiagQuery()
 348 {
 349         /* perhaps implement a Wine "/b" command line flag sometime ? */
 350         return FALSE;
 351 }
 352
 353 /***********************************************************************
 354  *           DiagOutput                         (KERNEL.340)
 355  *
 356  * writes a debug string into <windir>\bootlog.txt
 357  */
 358 void WINAPI DiagOutput(LPCSTR str)
 359 {
 360         /* FIXME */
 361         DPRINTF("DIAGOUTPUT:%s\n", debugstr_a(str));
 362 }
 363
 364 /***********************************************************************
 365  *           OaBuildVersion           [OLEAUT32.170]
 366  */
 367 UINT32 WINAPI OaBuildVersion()
 368 {
 369     WINDOWS_VERSION ver = VERSION_GetVersion();
 370
 371     FIXME(ver, "Please report to a.mohr@mailto.de if you get version error messages !\n");
 372     switch(VersionData[ver].getVersion32)
 373     {
 374         case 0x80000a03: /* Win 3.1 */
 375                 return 0x140fd1; /* from Win32s 1.1e */
 376         case 0xc0000004: /* Win 95 */
 377                 return 0x1e10a9; /* some older version: 0x0a0bd3 */
 378         case 0x04213303: /* NT 3.51 */
 379                 FIXME(ver, "NT 3.51 version value unknown !\n");
 380                 return 0x1e10a9; /* value borrowed from Win95 */
 381         case 0x05650004: /* NT 4.0 */
 382                 return 0x141016;
 383         default:
 384                 return 0x0;
 385     }
 386 }
 387 /***********************************************************************
 388  *        VERSION_OsIsUnicode   [internal]
 389  *
 390  * NOTES
 391  *   some functions getting sometimes LPSTR sometimes LPWSTR...
 392  *
 393  */
 394 BOOL32 VERSION_OsIsUnicode(void)
 395 {
 396     switch(VERSION_GetVersion())
 397     {
 398     case NT351:
 399     case NT40:
 400         return TRUE;
 401     default:
 402         return FALSE;
 403     }
 404 }