/**
* Initializes the global variables related to windows version.
*/
static void rtR3InitWindowsVersion(void)
{
Assert(g_hModNtDll != NULL);
/*
* ASSUMES OSVERSIONINFOEX starts with the exact same layout as OSVERSIONINFO (safe).
*/
AssertCompileMembersSameSizeAndOffset(OSVERSIONINFOEX, szCSDVersion, OSVERSIONINFO, szCSDVersion);
AssertCompileMemberOffset(OSVERSIONINFOEX, wServicePackMajor, sizeof(OSVERSIONINFO));
/*
* Use the NT version of GetVersionExW so we don't get fooled by
* compatability shims.
*/
RT_ZERO(g_WinOsInfoEx);
g_WinOsInfoEx.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW);
LONG (__stdcall *pfnRtlGetVersion)(OSVERSIONINFOEXW *);
*(FARPROC *)&pfnRtlGetVersion = GetProcAddress(g_hModNtDll, "RtlGetVersion");
LONG rcNt = -1;
if (pfnRtlGetVersion)
rcNt = pfnRtlGetVersion(&g_WinOsInfoEx);
if (rcNt != 0)
{
/*
* Couldn't find it or it failed, try the windows version of the API.
*/
RT_ZERO(g_WinOsInfoEx);
g_WinOsInfoEx.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW);
if (!GetVersionExW((POSVERSIONINFOW)&g_WinOsInfoEx))
{
/*
* If that didn't work either, just get the basic version bits.
*/
RT_ZERO(g_WinOsInfoEx);
g_WinOsInfoEx.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
if (GetVersionExW((POSVERSIONINFOW)&g_WinOsInfoEx))
Assert(g_WinOsInfoEx.dwPlatformId != VER_PLATFORM_WIN32_NT || g_WinOsInfoEx.dwMajorVersion < 5);
else
{
AssertBreakpoint();
RT_ZERO(g_WinOsInfoEx);
}
}
}
if (g_WinOsInfoEx.dwOSVersionInfoSize)
g_enmWinVer = rtR3InitWinSimplifiedVersion(&g_WinOsInfoEx);
}
static WINBASEAPI BOOL WINAPI GetVersionExUW(LPOSVERSIONINFOA lpVersionInfo)
{
// Get the version information.
OSVERSIONINFOEXW wVersionInfo;
wVersionInfo.dwOSVersionInfoSize = lpVersionInfo->dwOSVersionInfoSize + sizeof(lpVersionInfo->szCSDVersion);
BOOL bRet = GetVersionExW((OSVERSIONINFOW*)&wVersionInfo);
if (bRet == 0)
return bRet;
// Copy the OSVERSIONINFO struct data.
lpVersionInfo->dwMajorVersion = wVersionInfo.dwMajorVersion;
lpVersionInfo->dwMinorVersion = wVersionInfo.dwMinorVersion;
lpVersionInfo->dwBuildNumber = wVersionInfo.dwBuildNumber;
lpVersionInfo->dwPlatformId = wVersionInfo.dwPlatformId;
// Convert szCSDVersion from UTF-16 to UTF-8.
WideCharToMultiByte(CP_UTF8, 0, wVersionInfo.szCSDVersion,
sizeof(wVersionInfo.szCSDVersion) / sizeof(wVersionInfo.szCSDVersion[0]),
lpVersionInfo->szCSDVersion,
sizeof(lpVersionInfo->szCSDVersion) / sizeof(lpVersionInfo->szCSDVersion[0]),
NULL, NULL);
if (lpVersionInfo->dwOSVersionInfoSize + sizeof(lpVersionInfo->szCSDVersion) == sizeof(OSVERSIONINFOEXW))
{
// OSVERSIONINFOEXW.
LPOSVERSIONINFOEXA lpVersionInfoEx = (OSVERSIONINFOEXA*)lpVersionInfo;
lpVersionInfoEx->wServicePackMajor = wVersionInfo.wServicePackMajor;
lpVersionInfoEx->wServicePackMinor = wVersionInfo.wServicePackMinor;
lpVersionInfoEx->wSuiteMask = wVersionInfo.wSuiteMask;
lpVersionInfoEx->wProductType = wVersionInfo.wProductType;
lpVersionInfoEx->wReserved = wVersionInfo.wReserved;
}
return bRet;
}
/******************************************************************
* dump_system_info
*
* Dumps into File the information about the system
*/
static void dump_system_info(struct dump_context* dc)
{
MINIDUMP_SYSTEM_INFO mdSysInfo;
SYSTEM_INFO sysInfo;
OSVERSIONINFOW osInfo;
DWORD written;
ULONG slen;
GetSystemInfo(&sysInfo);
osInfo.dwOSVersionInfoSize = sizeof(osInfo);
GetVersionExW(&osInfo);
mdSysInfo.ProcessorArchitecture = sysInfo.u.s.wProcessorArchitecture;
mdSysInfo.ProcessorLevel = sysInfo.wProcessorLevel;
mdSysInfo.ProcessorRevision = sysInfo.wProcessorRevision;
mdSysInfo.u.s.NumberOfProcessors = sysInfo.dwNumberOfProcessors;
mdSysInfo.u.s.ProductType = VER_NT_WORKSTATION; /* FIXME */
mdSysInfo.MajorVersion = osInfo.dwMajorVersion;
mdSysInfo.MinorVersion = osInfo.dwMinorVersion;
mdSysInfo.BuildNumber = osInfo.dwBuildNumber;
mdSysInfo.PlatformId = osInfo.dwPlatformId;
mdSysInfo.CSDVersionRva = dc->rva + sizeof(mdSysInfo);
mdSysInfo.u1.Reserved1 = 0;
memset(&mdSysInfo.Cpu, 0, sizeof(mdSysInfo.Cpu));
append(dc, &mdSysInfo, sizeof(mdSysInfo));
slen = lstrlenW(osInfo.szCSDVersion) * sizeof(WCHAR);
WriteFile(dc->hFile, &slen, sizeof(slen), &written, NULL);
WriteFile(dc->hFile, osInfo.szCSDVersion, slen, &written, NULL);
dc->rva += sizeof(ULONG) + slen;
}
bool IsUnicodeOS()
{
OSVERSIONINFOW os;
memset(&os, 0, sizeof(OSVERSIONINFOW));
os.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
return (GetVersionExW(&os) != 0);
}
static
BOOL
IsRemote(DWORD pid, DWORD *exitTag, DWORD *lastErrorCode) {
DWORD sessionId;
if (FALSE == ProcessIdToSessionId(pid, &sessionId)) {
*exitTag = 1;
*lastErrorCode = GetLastError();
return FALSE;
}
OSVERSIONINFOW osvi;
ZeroMemory(&osvi, sizeof(OSVERSIONINFOW));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
GetVersionExW(&osvi);
if (osvi.dwMajorVersion > 5) {
// The case of Vista/Server 2008: 0 and 1 means local, greater than 1 - remote.
return (0 != sessionId) && (1 != sessionId);
} else if ((osvi.dwMajorVersion == 5) && (osvi.dwMinorVersion >= 1)) {
// The case of XP/Server 2003: 0 is local, another value means remote.
return (0 != sessionId);
} else {
*exitTag = 2;
return FALSE;
}
}
BOOL
xDipWindowsXPOrLater()
{
OSVERSIONINFOEXW osvi = {sizeof(OSVERSIONINFOEXW)};
GetVersionExW((LPOSVERSIONINFOW)&osvi);
return osvi.dwMajorVersion > 5 ||
(osvi.dwMajorVersion == 5 && osvi.dwMinorVersion >= 1);
}
static
BOOL
GetOSVersion(WCHAR * szBuffer)
{
OSVERSIONINFOEXW info;
ZeroMemory(&info, sizeof(info));
info.dwOSVersionInfoSize = sizeof(info);
if (GetVersionExW((LPOSVERSIONINFO)&info))
{
/* FIXME retrieve Odyssey version*/
if (info.dwMajorVersion == 4)
{
wcscpy(szBuffer, L"Windows NT 4.0");
if (info.szCSDVersion[0])
{
wcscat(szBuffer, L" ");
wcscat(szBuffer, info.szCSDVersion);
}
return TRUE;
}
if (info.dwMajorVersion == 5 && info.dwMinorVersion == 0)
{
wcscpy(szBuffer, L"Windows 2000");
if (info.szCSDVersion[0])
{
wcscat(szBuffer, L" ");
wcscat(szBuffer, info.szCSDVersion);
}
return TRUE;
}
if (info.dwMajorVersion == 5 && info.dwMinorVersion == 1)
{
wcscpy(szBuffer, L"Windows XP");
if (info.szCSDVersion[0])
{
wcscat(szBuffer, L" ");
wcscat(szBuffer, info.szCSDVersion);
}
return TRUE;
}
if (info.dwMajorVersion == 6 && info.dwMinorVersion == 0)
{
// if (GetVistaVersion(szBuffer))
// return TRUE;
wsprintfW(szBuffer, L"Windows Vista (6.0, Build %04u)", info.dwBuildNumber);
return TRUE;
}
}
return FALSE;
}
/************************************************************
* NetServerGetInfo (NETAPI32.@)
*/
NET_API_STATUS WINAPI NetServerGetInfo(LMSTR servername, DWORD level, LPBYTE* bufptr)
{
NET_API_STATUS ret;
TRACE("%s %d %p\n", debugstr_w( servername ), level, bufptr );
if (servername)
{
if (!NETAPI_IsLocalComputer(servername))
{
FIXME("remote computers not supported\n");
return ERROR_INVALID_LEVEL;
}
}
if (!bufptr) return ERROR_INVALID_PARAMETER;
switch (level)
{
case 100:
case 101:
{
DWORD computerNameLen, size;
WCHAR computerName[MAX_COMPUTERNAME_LENGTH + 1];
computerNameLen = MAX_COMPUTERNAME_LENGTH + 1;
GetComputerNameW(computerName, &computerNameLen);
computerNameLen++; /* include NULL terminator */
size = sizeof(SERVER_INFO_101) + computerNameLen * sizeof(WCHAR);
ret = NetApiBufferAllocate(size, (LPVOID *)bufptr);
if (ret == NERR_Success)
{
/* INFO_100 structure is a subset of INFO_101 */
PSERVER_INFO_101 info = (PSERVER_INFO_101)*bufptr;
OSVERSIONINFOW verInfo;
info->sv101_platform_id = PLATFORM_ID_NT;
info->sv101_name = (LMSTR)(*bufptr + sizeof(SERVER_INFO_101));
memcpy(info->sv101_name, computerName,
computerNameLen * sizeof(WCHAR));
verInfo.dwOSVersionInfoSize = sizeof(verInfo);
GetVersionExW(&verInfo);
info->sv101_version_major = verInfo.dwMajorVersion;
info->sv101_version_minor = verInfo.dwMinorVersion;
/* Use generic type as no wine equivalent of DC / Server */
info->sv101_type = SV_TYPE_NT;
info->sv101_comment = NULL;
}
break;
}
default:
FIXME("level %d unimplemented\n", level);
ret = ERROR_INVALID_LEVEL;
}
return ret;
}
void osInit()
{
OSVERSIONINFOEXW ovi;
memset(&ovi, 0, sizeof(ovi));
ovi.dwOSVersionInfoSize = sizeof(ovi);
GetVersionExW(reinterpret_cast<OSVERSIONINFOW *>(&ovi));
bIsWin7 = (ovi.dwMajorVersion >= 7) || ((ovi.dwMajorVersion == 6) &&(ovi.dwBuildNumber >= 7100));
bIsVistaSP1 = (ovi.dwMajorVersion >= 7) || ((ovi.dwMajorVersion == 6) &&(ovi.dwBuildNumber >= 6001));
}
static void test_assoc_perceived(void)
{
static const struct assoc_test_struct should_not_exist =
{ ".should_not_exist", PERCEIVED_TYPE_UNSPECIFIED, PERCEIVEDFLAG_UNDEFINED, NULL, 0, 0x80070002 };
static const struct assoc_test_struct htm[] =
{
{ ".htm", PERCEIVED_TYPE_TEXT, SOFTCODED_NATIVESUPPORT, "text", 0x600 },
{ ".html", PERCEIVED_TYPE_TEXT, SOFTCODED_NATIVESUPPORT, "text", 0x600 },
};
static const struct assoc_test_struct mp2 =
{ ".mp2", PERCEIVED_TYPE_VIDEO, HARDCODED_NATIVE_WMSDK, "video" };
OSVERSIONINFOEXW osvi;
DWORD version;
size_t i;
if (!pAssocGetPerceivedType)
{
win_skip("AssocGetPerceivedType() is missing\n");
return;
}
memset(&osvi, 0, sizeof(osvi));
osvi.dwOSVersionInfoSize = sizeof(osvi);
GetVersionExW((LPOSVERSIONINFOW)&osvi);
version = (osvi.dwMajorVersion << 8) | osvi.dwMinorVersion;
/* invalid entry results in HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) */
test_assoc_one(&should_not_exist);
for (i = 0; i < sizeof(assoc_perceived_types) / sizeof(assoc_perceived_types[0]); ++i)
{
if (assoc_perceived_types[i].minversion && assoc_perceived_types[i].minversion > version)
continue;
if (!(assoc_perceived_types[i].flags & PERCEIVEDFLAG_HARDCODED))
todo_wine test_assoc_one(&assoc_perceived_types[i]);
else
test_assoc_one(&assoc_perceived_types[i]);
}
/* below Vista */
if (version < 0x600)
{
todo_wine
test_assoc_one(&htm[0]);
todo_wine
test_assoc_one(&htm[1]);
}
/* below Win8 */
if (version < 0x602)
{
test_assoc_one(&mp2);
}
}
/// This function is called by the Mumble client in Mumble's scope
/// mainly to extract the offsets of various functions in the IDXGISwapChain
/// and IDXGIObject interfaces that need to be hooked in target
/// applications. The data is stored in the dxgi shared memory structure.
extern "C" __declspec(dllexport) void __cdecl PrepareDXGI() {
if (! dxgi)
return;
ods("DXGI: Preparing static data for DXGI Injection");
dxgi->wcFileName[0] = 0;
dxgi->offsetPresent = 0;
dxgi->offsetResize = 0;
// Make sure this is Vista or greater as quite a number of <=WinXP users have fake DX10 libs installed
OSVERSIONINFOEXW ovi;
memset(&ovi, 0, sizeof(ovi));
ovi.dwOSVersionInfoSize = sizeof(ovi);
GetVersionExW(reinterpret_cast<OSVERSIONINFOW *>(&ovi));
if (ovi.dwMajorVersion < 6 || (ovi.dwMajorVersion == 6 && ovi.dwBuildNumber < 6001)) {
ods("DXGI: No DXGI pre-Vista - skipping prepare");
return;
}
HMODULE hDXGI = LoadLibrary("DXGI.DLL");
if (hDXGI != NULL) {
GetModuleFileNameW(hDXGI, dxgi->wcFileName, ARRAY_NUM_ELEMENTS(dxgi->wcFileName));
CreateDXGIFactory1Type pCreateDXGIFactory1 = reinterpret_cast<CreateDXGIFactory1Type>(GetProcAddress(hDXGI, "CreateDXGIFactory1"));
ods("DXGI: Got CreateDXGIFactory1 at %p", pCreateDXGIFactory1);
if (pCreateDXGIFactory1) {
IDXGIFactory1 * pFactory;
HRESULT hr = pCreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)(&pFactory));
if (FAILED(hr))
ods("DXGI: Call to pCreateDXGIFactory1 failed!");
if (pFactory) {
IDXGIAdapter1 *pAdapter = NULL;
pFactory->EnumAdapters1(0, &pAdapter);
/// Offsets have to be identified and initialized only once.
bool initializeDXGIData = !dxgi->offsetPresent && !dxgi->offsetResize;
PrepareDXGI10(pAdapter, initializeDXGIData);
initializeDXGIData = !dxgi->offsetPresent && !dxgi->offsetResize;
PrepareDXGI11(pAdapter, initializeDXGIData);
pFactory->Release();
} else {
FreeLibrary(hDXGI);
}
} else {
FreeLibrary(hDXGI);
}
} else {
FreeLibrary(hDXGI);
}
}
/* --------------------- etc, etc, etc... ----------------------- */
BOOL GetVersionExA(OSVERSIONINFOA *v)
{
OSVERSIONINFOW wv;
BOOL b;
LPSTR mb;
b = GetVersionExW(&wv);
mb = wce_wctomb(wv.szCSDVersion);
strcpy( v->szCSDVersion, mb );
free(mb);
return b;
}
std::string EnvironmentImpl::osVersionImpl()
{
OSVERSIONINFOW vi;
vi.dwOSVersionInfoSize = sizeof(vi);
if (GetVersionExW(&vi) == 0) throw SystemException("Cannot get OS version information");
std::ostringstream str;
str << vi.dwMajorVersion << "." << vi.dwMinorVersion << " (Build " << (vi.dwBuildNumber & 0xFFFF);
std::string version;
UnicodeConverter::toUTF8(vi.szCSDVersion, version);
if (!version.empty()) str << ": " << version;
str << ")";
return str.str();
}
/* INTERNAL: Since we can't rely on Winelib startup code calling w/getmainargs,
* we initialise data values during DLL loading. When called by a native
* program we simply return the data we've already initialised. This also means
* you can call multiple times without leaking
*/
void msvcrt_init_args(void)
{
OSVERSIONINFOW osvi;
MSVCRT__acmdln = MSVCRT__strdup( GetCommandLineA() );
MSVCRT__wcmdln = msvcrt_wstrdupa(MSVCRT__acmdln);
MSVCRT___argc = __wine_main_argc;
MSVCRT___argv = __wine_main_argv;
MSVCRT___wargv = __wine_main_wargv;
TRACE("got %s, wide = %s argc=%d\n", debugstr_a(MSVCRT__acmdln),
debugstr_w(MSVCRT__wcmdln),MSVCRT___argc);
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
GetVersionExW( &osvi );
MSVCRT__winver = (osvi.dwMajorVersion << 8) | osvi.dwMinorVersion;
MSVCRT__winmajor = osvi.dwMajorVersion;
MSVCRT__winminor = osvi.dwMinorVersion;
MSVCRT__osver = osvi.dwBuildNumber;
MSVCRT__osplatform = osvi.dwPlatformId;
TRACE( "winver %08x winmajor %08x winminor %08x osver %08x\n",
MSVCRT__winver, MSVCRT__winmajor, MSVCRT__winminor, MSVCRT__osver);
MSVCRT__HUGE = HUGE_VAL;
MSVCRT___setlc_active = 0;
MSVCRT___unguarded_readlc_active = 0;
MSVCRT__fmode = MSVCRT__O_TEXT;
MSVCRT__environ = msvcrt_SnapshotOfEnvironmentA(NULL);
MSVCRT___initenv = msvcrt_SnapshotOfEnvironmentA(NULL);
MSVCRT___winitenv = msvcrt_SnapshotOfEnvironmentW(NULL);
MSVCRT__pgmptr = HeapAlloc(GetProcessHeap(), 0, MAX_PATH);
if (MSVCRT__pgmptr)
{
if (!GetModuleFileNameA(0, MSVCRT__pgmptr, MAX_PATH))
MSVCRT__pgmptr[0] = '\0';
else
MSVCRT__pgmptr[MAX_PATH - 1] = '\0';
}
MSVCRT__wpgmptr = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
if (MSVCRT__wpgmptr)
{
if (!GetModuleFileNameW(0, MSVCRT__wpgmptr, MAX_PATH))
MSVCRT__wpgmptr[0] = '\0';
else
MSVCRT__wpgmptr[MAX_PATH - 1] = '\0';
}
}
DWORD CPluginSettings::GetWindowsBuildNumber()
{
if (m_WindowsBuildNumber == 0)
{
OSVERSIONINFOEX osvi = {};
osvi.dwOSVersionInfoSize = sizeof(osvi);
if (GetVersionExW(reinterpret_cast<OSVERSIONINFO*>(&osvi)) != 0)
{
m_WindowsBuildNumber = osvi.dwBuildNumber;
}
}
return m_WindowsBuildNumber;
}
static HRESULT DXDiag_InitDXDiagSystemInfoContainer(IDxDiagContainer* pSubCont) {
static const WCHAR dwDirectXVersionMajor[] = {'d','w','D','i','r','e','c','t','X','V','e','r','s','i','o','n','M','a','j','o','r',0};
static const WCHAR dwDirectXVersionMinor[] = {'d','w','D','i','r','e','c','t','X','V','e','r','s','i','o','n','M','i','n','o','r',0};
static const WCHAR szDirectXVersionLetter[] = {'s','z','D','i','r','e','c','t','X','V','e','r','s','i','o','n','L','e','t','t','e','r',0};
static const WCHAR szDirectXVersionLetter_v[] = {'c',0};
static const WCHAR bDebug[] = {'b','D','e','b','u','g',0};
static const WCHAR szDirectXVersionEnglish[] = {'s','z','D','i','r','e','c','t','X','V','e','r','s','i','o','n','E','n','g','l','i','s','h',0};
static const WCHAR szDirectXVersionEnglish_v[] = {'4','.','0','9','.','0','0','0','0','.','0','9','0','4',0};
static const WCHAR szDirectXVersionLongEnglish[] = {'s','z','D','i','r','e','c','t','X','V','e','r','s','i','o','n','L','o','n','g','E','n','g','l','i','s','h',0};
static const WCHAR szDirectXVersionLongEnglish_v[] = {'=',' ','"','D','i','r','e','c','t','X',' ','9','.','0','c',' ','(','4','.','0','9','.','0','0','0','0','.','0','9','0','4',')',0};
static const WCHAR ullPhysicalMemory[] = {'u','l','l','P','h','y','s','i','c','a','l','M','e','m','o','r','y',0};
static const WCHAR ullUsedPageFile[] = {'u','l','l','U','s','e','d','P','a','g','e','F','i','l','e',0};
static const WCHAR ullAvailPageFile[] = {'u','l','l','A','v','a','i','l','P','a','g','e','F','i','l','e',0};
/*static const WCHAR szDxDiagVersion[] = {'s','z','D','x','D','i','a','g','V','e','r','s','i','o','n',0};*/
static const WCHAR szWindowsDir[] = {'s','z','W','i','n','d','o','w','s','D','i','r',0};
static const WCHAR dwOSMajorVersion[] = {'d','w','O','S','M','a','j','o','r','V','e','r','s','i','o','n',0};
static const WCHAR dwOSMinorVersion[] = {'d','w','O','S','M','i','n','o','r','V','e','r','s','i','o','n',0};
static const WCHAR dwOSBuildNumber[] = {'d','w','O','S','B','u','i','l','d','N','u','m','b','e','r',0};
static const WCHAR dwOSPlatformID[] = {'d','w','O','S','P','l','a','t','f','o','r','m','I','D',0};
static const WCHAR szCSDVersion[] = {'s','z','C','S','D','V','e','r','s','i','o','n',0};
MEMORYSTATUSEX msex;
OSVERSIONINFOW info;
WCHAR buffer[MAX_PATH];
add_prop_ui4(pSubCont, dwDirectXVersionMajor, 9);
add_prop_ui4(pSubCont, dwDirectXVersionMinor, 0);
add_prop_str(pSubCont, szDirectXVersionLetter, szDirectXVersionLetter_v);
add_prop_str(pSubCont, szDirectXVersionEnglish, szDirectXVersionEnglish_v);
add_prop_str(pSubCont, szDirectXVersionLongEnglish, szDirectXVersionLongEnglish_v);
add_prop_bool(pSubCont, bDebug, FALSE);
msex.dwLength = sizeof(msex);
GlobalMemoryStatusEx( &msex );
add_prop_ull_as_str(pSubCont, ullPhysicalMemory, msex.ullTotalPhys);
add_prop_ull_as_str(pSubCont, ullUsedPageFile, msex.ullTotalPageFile - msex.ullAvailPageFile);
add_prop_ull_as_str(pSubCont, ullAvailPageFile, msex.ullAvailPageFile);
info.dwOSVersionInfoSize = sizeof(info);
GetVersionExW( &info );
add_prop_ui4(pSubCont, dwOSMajorVersion, info.dwMajorVersion);
add_prop_ui4(pSubCont, dwOSMinorVersion, info.dwMinorVersion);
add_prop_ui4(pSubCont, dwOSBuildNumber, info.dwBuildNumber);
add_prop_ui4(pSubCont, dwOSPlatformID, info.dwPlatformId);
add_prop_str(pSubCont, szCSDVersion, info.szCSDVersion);
GetWindowsDirectoryW(buffer, MAX_PATH);
add_prop_str(pSubCont, szWindowsDir, buffer);
return S_OK;
}
/*!
Returns Windows's OSVERSIONINFO structure
*/
OSVERSIONINFOW& UT_GetWinVersion(void)
{
static bool bInitialized = false;
static OSVERSIONINFOW os;
if (!bInitialized)
{
os.dwOSVersionInfoSize = sizeof(os);
BOOL bSuccess = GetVersionExW(&os);
UT_ASSERT(bSuccess);
bInitialized = true;
}
return os;
}
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
switch (fdwReason) {
case DLL_PROCESS_ATTACH:
DisableThreadLibraryCalls(hinstDLL);
OsVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
if (!GetVersionExW(&OsVersionInfo))
return FALSE;
break;
case DLL_PROCESS_DETACH:
UnloadCABINETDll();
break;
}
return TRUE;
}
/*
* @implemented
*/
BOOL
WINAPI
GetVersionExA(IN LPOSVERSIONINFOA lpVersionInformation)
{
OSVERSIONINFOEXW VersionInformation;
LPOSVERSIONINFOEXA lpVersionInformationEx;
UNICODE_STRING CsdVersionW;
NTSTATUS Status;
ANSI_STRING CsdVersionA;
if ((lpVersionInformation->dwOSVersionInfoSize != sizeof(OSVERSIONINFOA)) &&
(lpVersionInformation->dwOSVersionInfoSize != sizeof(OSVERSIONINFOEXA)))
{
SetLastError(ERROR_INSUFFICIENT_BUFFER);
return FALSE;
}
VersionInformation.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW);
if (!GetVersionExW((LPOSVERSIONINFOW)&VersionInformation)) return FALSE;
/* Copy back fields that match both supported structures */
lpVersionInformation->dwMajorVersion = VersionInformation.dwMajorVersion;
lpVersionInformation->dwMinorVersion = VersionInformation.dwMinorVersion;
lpVersionInformation->dwBuildNumber = VersionInformation.dwBuildNumber;
lpVersionInformation->dwPlatformId = VersionInformation.dwPlatformId;
if (lpVersionInformation->dwOSVersionInfoSize == sizeof(OSVERSIONINFOEXA))
{
lpVersionInformationEx = (PVOID)lpVersionInformation;
lpVersionInformationEx->wServicePackMajor = VersionInformation.wServicePackMajor;
lpVersionInformationEx->wServicePackMinor = VersionInformation.wServicePackMinor;
lpVersionInformationEx->wSuiteMask = VersionInformation.wSuiteMask;
lpVersionInformationEx->wProductType = VersionInformation.wProductType;
lpVersionInformationEx->wReserved = VersionInformation.wReserved;
}
/* Convert the CSD string */
RtlInitEmptyAnsiString(&CsdVersionA,
lpVersionInformation->szCSDVersion,
sizeof(lpVersionInformation->szCSDVersion));
RtlInitUnicodeString(&CsdVersionW, VersionInformation.szCSDVersion);
Status = RtlUnicodeStringToAnsiString(&CsdVersionA, &CsdVersionW, FALSE);
return (NT_SUCCESS(Status));
}
void DebugVersionTest()
{
DWORDLONG const dwlConditionMask = VerSetConditionMask(VerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL), VER_MINORVERSION, VER_GREATER_EQUAL);
_ASSERTE(_WIN32_WINNT_WIN7==0x601);
OSVERSIONINFOEXW osvi7 = {sizeof(osvi7), HIBYTE(_WIN32_WINNT_WIN7), LOBYTE(_WIN32_WINNT_WIN7)};
bool bWin7 = VerifyVersionInfoW(&osvi7, VER_MAJORVERSION | VER_MINORVERSION, dwlConditionMask) != 0;
_ASSERTE(_WIN32_WINNT_VISTA==0x600);
OSVERSIONINFOEXW osvi6 = {sizeof(osvi6), HIBYTE(_WIN32_WINNT_VISTA), LOBYTE(_WIN32_WINNT_VISTA)};
bool bWin6 = VerifyVersionInfoW(&osvi6, VER_MAJORVERSION | VER_MINORVERSION, dwlConditionMask) != 0;
OSVERSIONINFOW osv = {sizeof(OSVERSIONINFOW)};
GetVersionExW(&osv);
bool bVerWin7 = ((osv.dwMajorVersion > 6) || ((osv.dwMajorVersion == 6) && (osv.dwMinorVersion >= 1)));
bool bVerWin6 = (osv.dwMajorVersion >= 6);
_ASSERTE(bWin7 == bVerWin7);
_ASSERTE(bWin6 == bVerWin6);
}
static bool sysGetVersionExWByRef(OSVERSIONINFOEXW& osVerInfo)
{
ZeroMemory(&osVerInfo, sizeof(osVerInfo));
osVerInfo.dwOSVersionInfoSize = sizeof(osVerInfo);
typedef NTSTATUS(__stdcall *RtlGetVersionPtr)(RTL_OSVERSIONINFOEXW* pOsInfo);
static HMODULE hNtDll = GetModuleHandleW(L"ntdll.dll");
if (hNtDll != NULL)
{
static RtlGetVersionPtr RtlGetVer = (RtlGetVersionPtr) GetProcAddress(hNtDll, "RtlGetVersion");
if (RtlGetVer && RtlGetVer(&osVerInfo) == 0)
return true;
}
// failed to get OS information directly from ntdll.dll
// use GetVersionExW() as fallback
// note: starting from Windows 8.1 GetVersionExW() may return unfaithful information
if (GetVersionExW((OSVERSIONINFOW*) &osVerInfo) != 0)
return true;
ZeroMemory(&osVerInfo, sizeof(osVerInfo));
return false;
}
int uname(struct utsname* un)
{
OSVERSIONINFOW vi = { sizeof(OSVERSIONINFOW) };
GetVersionExW(&vi);
// OS implementation name
sprintf_s(un->sysname, ARRAY_SIZE(un->sysname), "%ls", wversion_Family());
// release info
const wchar_t* vs = vi.szCSDVersion;
int sp;
if(swscanf_s(vs, L"Service Pack %d", &sp) == 1)
sprintf_s(un->release, ARRAY_SIZE(un->release), "SP %d", sp);
else
un->release[0] = '\0';
// version
sprintf_s(un->version, ARRAY_SIZE(un->version), "%ls.%lu", wversion_String(), vi.dwBuildNumber & 0xFFFF);
// node name
{
WinScopedPreserveLastError s; // GetComputerName
DWORD bufSize = sizeof(un->nodename);
WARN_IF_FALSE(GetComputerNameA(un->nodename, &bufSize));
}
// hardware type
SYSTEM_INFO si;
GetSystemInfo(&si);
if(si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
strcpy_s(un->machine, ARRAY_SIZE(un->machine), "x64");
else
strcpy_s(un->machine, ARRAY_SIZE(un->machine), "x86");
return 0;
}
// Obtain the reading string upon WM_IME_NOTIFY/INM_PRIVATE notification.
void CIME::GetPrivateReadingString()
{
DWORD dwId = GetImeId();
if(!dwId)
{
s_bShowReadingWindow = false;
return;
}
HIMC hImc;
hImc = ImmGetContext(UIGetHWND());
if(!hImc)
{
s_bShowReadingWindow = false;
return;
}
DWORD dwReadingStrLen = 0;
DWORD dwErr = 0;
WCHAR *pwszReadingStringBuffer = NULL; // Buffer for when the IME supports GetReadingString()
WCHAR *wstr = 0;
bool bUnicodeIme = false; // Whether the IME context component is Unicode.
INPUTCONTEXT *lpIC = NULL;
if(_GetReadingString)
{
UINT uMaxUiLen;
BOOL bVertical;
// Obtain the reading string size
dwReadingStrLen = _GetReadingString(hImc, 0, NULL, (PINT)&dwErr, &bVertical, &uMaxUiLen);
if(dwReadingStrLen)
{
wstr = pwszReadingStringBuffer = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * dwReadingStrLen);
if(!pwszReadingStringBuffer)
{
// Out of memory. Exit.
_ImmReleaseContext(UIGetHWND(), hImc);
return;
}
// Obtain the reading string
dwReadingStrLen = _GetReadingString(hImc, dwReadingStrLen, wstr, (PINT)&dwErr, &bVertical, &uMaxUiLen);
}
s_bHorizontalReading = !bVertical;
bUnicodeIme = true;
}
else
{
// IMEs that doesn't implement Reading String API
lpIC = _ImmLockIMC(hImc);
LPBYTE p = 0;
switch(dwId)
{
case IMEID_CHT_VER42: // New(Phonetic/ChanJie)IME98 : 4.2.x.x // Win98
case IMEID_CHT_VER43: // New(Phonetic/ChanJie)IME98a : 4.3.x.x // WinMe, Win2k
case IMEID_CHT_VER44: // New ChanJie IME98b : 4.4.x.x // WinXP
p = *(LPBYTE *)((LPBYTE)_ImmLockIMCC(lpIC->hPrivate) + 24);
if(!p) break;
dwReadingStrLen = *(DWORD *)(p + 7 * 4 + 32 * 4);
dwErr = *(DWORD *)(p + 8 * 4 + 32 * 4);
wstr = (WCHAR *)(p + 56);
bUnicodeIme = true;
break;
case IMEID_CHT_VER50: // 5.0.x.x // WinME
p = *(LPBYTE *)((LPBYTE)_ImmLockIMCC(lpIC->hPrivate) + 3 * 4);
if(!p) break;
p = *(LPBYTE *)((LPBYTE)p + 1*4 + 5*4 + 4*2);
if(!p) break;
dwReadingStrLen = *(DWORD *)(p + 1*4 + (16*2+2*4) + 5*4 + 16);
dwErr = *(DWORD *)(p + 1*4 + (16*2+2*4) + 5*4 + 16 + 1*4);
wstr = (WCHAR *)(p + 1*4 + (16*2+2*4) + 5*4);
bUnicodeIme = false;
break;
case IMEID_CHT_VER51: // 5.1.x.x // IME2002(w/OfficeXP)
case IMEID_CHT_VER52: // 5.2.x.x // (w/whistler)
case IMEID_CHS_VER53: // 5.3.x.x // SCIME2k or MSPY3 (w/OfficeXP and Whistler)
p = *(LPBYTE *)((LPBYTE)_ImmLockIMCC(lpIC->hPrivate) + 4);
if(!p) break;
p = *(LPBYTE *)((LPBYTE)p + 1*4 + 5*4);
if(!p) break;
dwReadingStrLen = *(DWORD *)(p + 1*4 + (16*2+2*4) + 5*4 + 16 * 2);
dwErr = *(DWORD *)(p + 1*4 + (16*2+2*4) + 5*4 + 16 * 2 + 1*4);
wstr = (WCHAR *) (p + 1*4 + (16*2+2*4) + 5*4);
bUnicodeIme = true;
break;
// the code tested only with Win 98 SE (MSPY 1.5/ ver 4.1.0.21)
case IMEID_CHS_VER41:
{
int nOffset;
nOffset = (GetImeId(1) >= 0x00000002) ? 8 : 7;
p = *(LPBYTE *)((LPBYTE)_ImmLockIMCC(lpIC->hPrivate) + nOffset * 4);
if(!p) break;
dwReadingStrLen = *(DWORD *)(p + 7*4 + 16*2*4);
dwErr = *(DWORD *)(p + 8*4 + 16*2*4);
dwErr = __min(dwErr, dwReadingStrLen);
wstr = (WCHAR *)(p + 6*4 + 16*2*1);
bUnicodeIme = true;
break;
}
case IMEID_CHS_VER42: // 4.2.x.x // SCIME98 or MSPY2 (w/Office2k, Win2k, WinME, etc)
{
OSVERSIONINFOW osi;
osi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
GetVersionExW(&osi);
int nTcharSize = (osi.dwPlatformId == VER_PLATFORM_WIN32_NT) ? sizeof(WCHAR) : sizeof(char);
p = *(LPBYTE *)((LPBYTE)_ImmLockIMCC(lpIC->hPrivate) + 1*4 + 1*4 + 6*4);
if(!p) break;
dwReadingStrLen = *(DWORD *)(p + 1*4 + (16*2+2*4) + 5*4 + 16 * nTcharSize);
dwErr = *(DWORD *)(p + 1*4 + (16*2+2*4) + 5*4 + 16 * nTcharSize + 1*4);
wstr = (WCHAR *) (p + 1*4 + (16*2+2*4) + 5*4);
bUnicodeIme = (osi.dwPlatformId == VER_PLATFORM_WIN32_NT) ? true : false;
}
} // switch
}
// Copy the reading string to the candidate list first
s_CandList.awszCandidate[0][0] = 0;
s_CandList.awszCandidate[1][0] = 0;
s_CandList.awszCandidate[2][0] = 0;
s_CandList.awszCandidate[3][0] = 0;
s_CandList.dwCount = dwReadingStrLen;
s_CandList.dwSelection = (DWORD)-1; // do not select any char
if(bUnicodeIme)
{
UINT i;
for(i = 0; i < dwReadingStrLen; ++i) // dwlen > 0, if known IME
{
if(dwErr <= i && s_CandList.dwSelection == (DWORD)-1)
{
// select error char
s_CandList.dwSelection = i;
}
s_CandList.awszCandidate[i][0] = wstr[i];
s_CandList.awszCandidate[i][1] = 0;
}
s_CandList.awszCandidate[i][0] = 0;
}
else
{
char *p = (char *)wstr;
DWORD i, j;
for(i = 0, j = 0; i < dwReadingStrLen; ++i, ++j) // dwlen > 0, if known IME
{
if(dwErr <= i && s_CandList.dwSelection == (DWORD)-1)
{
s_CandList.dwSelection = j;
}
// Obtain the current code page
WCHAR wszCodePage[8];
UINT uCodePage = CP_ACP; // Default code page
if(GetLocaleInfoW(MAKELCID(GetLanguage(), SORT_DEFAULT),
LOCALE_IDEFAULTANSICODEPAGE,
wszCodePage,
sizeof(wszCodePage)/sizeof(wszCodePage[0])))
{
uCodePage = wcstoul(wszCodePage, NULL, 0);
}
MultiByteToWideChar(uCodePage, 0, p + i, IsDBCSLeadByteEx(uCodePage, p[i]) ? 2 : 1,
s_CandList.awszCandidate[j], 1);
if(IsDBCSLeadByteEx(uCodePage, p[i]))
++i;
}
s_CandList.awszCandidate[j][0] = 0;
s_CandList.dwCount = j;
}
if(!_GetReadingString)
{
_ImmUnlockIMCC(lpIC->hPrivate);
_ImmUnlockIMC(hImc);
GetReadingWindowOrientation(dwId);
}
_ImmReleaseContext(UIGetHWND(), hImc);
if(pwszReadingStringBuffer)
HeapFree(GetProcessHeap(), 0, pwszReadingStringBuffer);
// Copy the string to the reading string buffer
if(s_CandList.dwCount > 0)
s_bShowReadingWindow = true;
else
s_bShowReadingWindow = false;
if(s_bHorizontalReading)
{
s_CandList.nReadingError = -1;
s_wstrReadingString.clear();
for(UINT i = 0; i < s_CandList.dwCount; ++i)
{
if(s_CandList.dwSelection == i)
s_CandList.nReadingError = s_wstrReadingString.length();
s_wstrReadingString+=s_CandList.awszCandidate[i];
}
}
s_CandList.dwPageSize = MAX_CANDLIST;
}
static BOOL common_dll_prep(const wchar_t *path) {
HMODULE hmod;
HKEY hkey;
struct _stat stat_buf;
wchar_t test_path[MAX_PATH + 1];
_snwprintf(test_path, sizeof(test_path) / sizeof(wchar_t),
L"%s\\libgtk-win32-2.0-0.dll", path);
test_path[sizeof(test_path) / sizeof(wchar_t) - 1] = L'\0';
if (_wstat(test_path, &stat_buf) != 0) {
printf("Unable to determine GTK+ path. \n"
"Assuming GTK+ is in the PATH.\n");
return FALSE;
}
wprintf(L"GTK+ path found: %s\n", path);
if ((hmod = GetModuleHandleW(L"kernel32.dll"))) {
MySetDllDirectory = (LPFNSETDLLDIRECTORY) GetProcAddress(
hmod, "SetDllDirectoryW");
if (!MySetDllDirectory)
printf("SetDllDirectory not supported\n");
} else
printf("Error getting kernel32.dll module handle\n");
/* For Windows XP SP1+ / Server 2003 we use SetDllDirectory to avoid dll hell */
if (MySetDllDirectory) {
printf("Using SetDllDirectory\n");
MySetDllDirectory(path);
}
/* For the rest, we set the current directory and make sure
* SafeDllSearch is set to 0 where needed. */
else {
OSVERSIONINFOW osinfo;
printf("Setting current directory to GTK+ dll directory\n");
SetCurrentDirectoryW(path);
/* For Windows 2000 (SP3+) / WinXP (No SP):
* If SafeDllSearchMode is set to 1, Windows system directories are
* searched for dlls before the current directory. Therefore we set it
* to 0.
*/
osinfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
GetVersionExW(&osinfo);
if ((osinfo.dwMajorVersion == 5
&& osinfo.dwMinorVersion == 0
&& wcscmp(osinfo.szCSDVersion, L"Service Pack 3") >= 0)
||
(osinfo.dwMajorVersion == 5
&& osinfo.dwMinorVersion == 1
&& wcscmp(osinfo.szCSDVersion, L"") >= 0)
) {
DWORD regval = 1;
DWORD reglen = sizeof(DWORD);
printf("Using Win2k (SP3+) / WinXP (No SP)... Checking SafeDllSearch\n");
read_reg_string(HKEY_LOCAL_MACHINE,
L"System\\CurrentControlSet\\Control\\Session Manager",
L"SafeDllSearchMode",
(LPBYTE) ®val,
®len);
if (regval != 0) {
printf("Trying to set SafeDllSearchMode to 0\n");
regval = 0;
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
L"System\\CurrentControlSet\\Control\\Session Manager",
0, KEY_SET_VALUE, &hkey
) == ERROR_SUCCESS) {
if (RegSetValueExW(hkey,
L"SafeDllSearchMode", 0,
REG_DWORD, (LPBYTE) ®val,
sizeof(DWORD)
) != ERROR_SUCCESS)
printf("Error writing SafeDllSearchMode. Error: %u\n",
(UINT) GetLastError());
RegCloseKey(hkey);
} else
printf("Error opening Session Manager key for writing. Error: %u\n",
(UINT) GetLastError());
} else
printf("SafeDllSearchMode is set to 0\n");
}/*end else*/
}
return TRUE;
}
wchar_t * UT_GetDefaultPrinterName()
{
UT_uint32 iBufferSize = 128; // will become 2x bigger immediately in the loop
wchar_t * pPrinterName = NULL;
DWORD rc;
do
{
iBufferSize *= 2;
if(pPrinterName)
g_free(pPrinterName);
pPrinterName = (wchar_t *) UT_calloc(sizeof(wchar_t),iBufferSize);
UT_return_val_if_fail( pPrinterName, NULL );
// the method of obtaining the name is version specific ...
OSVERSIONINFOW osvi;
DWORD iNeeded, iReturned, iBuffSize;
LPPRINTER_INFO_5W pPrinterInfo;
wchar_t* p;
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
GetVersionExW(&osvi);
if (osvi.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
{
// get size of the buffer needed to call enum printers
if (!EnumPrintersW(PRINTER_ENUM_DEFAULT,NULL,5,NULL,0,&iNeeded,&iReturned))
{
if ((rc = GetLastError()) != ERROR_INSUFFICIENT_BUFFER)
{
return NULL;
}
}
// allocate the buffer
if ((pPrinterInfo = (LPPRINTER_INFO_5W)LocalAlloc(LPTR,iNeeded)) == NULL)
{
rc = GetLastError();
}
else
{
// now get the default printer
if (!EnumPrintersW(PRINTER_ENUM_DEFAULT,NULL,5,
(LPBYTE) pPrinterInfo,iNeeded,&iNeeded,&iReturned))
{
rc = GetLastError();
}
else
{
if (iReturned > 0)
{
// here we copy the name to our own buffer
if ((DWORD) wcslen(pPrinterInfo->pPrinterName) > iBufferSize-1)
{
rc = ERROR_INSUFFICIENT_BUFFER;
}
else
{
wcscpy(pPrinterName,pPrinterInfo->pPrinterName);
rc = ERROR_SUCCESS;
}
}
else
{
*pPrinterName = '0';
rc = ERROR_SUCCESS;
}
}
LocalFree(pPrinterInfo);
}
}
else if (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT)
{
if (osvi.dwMajorVersion >= 5) /* Windows 2000 or later */
{
iBuffSize = iBufferSize;
HMODULE hWinSpool = LoadLibraryW(L"winspool.drv");
if (!hWinSpool)
return NULL;
HRESULT (WINAPI * fnGetDefaultPrinter)(LPWSTR, LPDWORD) =
(HRESULT (WINAPI * )(LPWSTR, LPDWORD)) GetProcAddress(hWinSpool, GETDEFAULTPRINTER);
if (!fnGetDefaultPrinter)
{
FreeLibrary(hWinSpool);
return NULL;
}
bool i =false;
if (!fnGetDefaultPrinter(pPrinterName,&iBuffSize))
i = true;
if(i)
rc = GetLastError();
else
rc = ERROR_SUCCESS;
FreeLibrary(hWinSpool);
}
else /* Windows NT 4.0 or earlier */
{
if (GetProfileStringW(L"windows",L"device",L"",pPrinterName,iBufferSize) == iBufferSize-1)
{
rc = ERROR_INSUFFICIENT_BUFFER;
}
else
{
p = pPrinterName;
while (*p != '0' && *p !=L',')
++p;
*p = '0';
rc = ERROR_SUCCESS;
}
}
}
}
while (rc == ERROR_INSUFFICIENT_BUFFER);
return pPrinterName;
}
BOOL
WINAPI
DllMain(PVOID hinstDll, ULONG dwReason, PVOID reserved)
{
OSVERSIONINFOW osvi;
switch (dwReason)
{
case DLL_PROCESS_ATTACH://1
/* initialize version info */
//DPRINT1("Process Attach %d\n", nAttachCount);
//DPRINT1("Process Attach\n");
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
GetVersionExW( &osvi );
_winver = (osvi.dwMajorVersion << 8) | osvi.dwMinorVersion;
_winmajor = osvi.dwMajorVersion;
_winminor = osvi.dwMinorVersion;
_osplatform = osvi.dwPlatformId;
_osver = osvi.dwBuildNumber;
hHeap = HeapCreate(0, 100000, 0);
if (hHeap == NULL)
return FALSE;
/* create tls stuff */
if (!CreateThreadData())
return FALSE;
if (BlockEnvToEnvironA() < 0)
return FALSE;
if (BlockEnvToEnvironW() < 0)
{
FreeEnvironment(_environ);
return FALSE;
}
_acmdln = _strdup(GetCommandLineA());
_wcmdln = _wcsdup(GetCommandLineW());
/* FIXME: more initializations... */
/* Initialization of the WINE code */
msvcrt_init_mt_locks();
msvcrt_init_io();
setlocale(0, "C");
//_setmbcp(_MB_CP_LOCALE);
TRACE("Attach done\n");
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
FreeThreadData(NULL);
break;
case DLL_PROCESS_DETACH:
//DPRINT1("Detach %d\n", nAttachCount);
//DPRINT("Detach\n");
/* FIXME: more cleanup... */
/* Deinit of the WINE code */
msvcrt_free_io();
msvcrt_free_mt_locks();
_atexit_cleanup();
/* destroy tls stuff */
DestroyThreadData();
if (__winitenv && __winitenv != _wenviron)
FreeEnvironment((char**)__winitenv);
if (_wenviron)
FreeEnvironment((char**)_wenviron);
if (__initenv && __initenv != _environ)
FreeEnvironment(__initenv);
if (_environ)
FreeEnvironment(_environ);
/* destroy heap */
HeapDestroy(hHeap);
TRACE("Detach done\n");
break;
}
return TRUE;
}
BOOL
WINAPI
DllMain(PVOID hinstDll, ULONG dwReason, PVOID reserved)
{
OSVERSIONINFOW osvi;
switch (dwReason)
{
case DLL_PROCESS_ATTACH:
/* initialize version info */
TRACE("Process Attach\n");
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
GetVersionExW( &osvi );
_winver = (osvi.dwMajorVersion << 8) | osvi.dwMinorVersion;
_winmajor = osvi.dwMajorVersion;
_winminor = osvi.dwMinorVersion;
_osplatform = osvi.dwPlatformId;
_osver = osvi.dwBuildNumber;
/* create tls stuff */
if (!msvcrt_init_tls())
return FALSE;
if (BlockEnvToEnvironA() < 0)
return FALSE;
if (BlockEnvToEnvironW() < 0)
{
FreeEnvironment(_environ);
return FALSE;
}
_acmdln = _strdup(GetCommandLineA());
_wcmdln = _wcsdup(GetCommandLineW());
/* Initialization of the WINE code */
msvcrt_init_mt_locks();
//msvcrt_init_math();
msvcrt_init_io();
//msvcrt_init_console();
//msvcrt_init_args();
//msvcrt_init_signals();
TRACE("Attach done\n");
break;
case DLL_THREAD_ATTACH:
//msvcrt_get_thread_data creates data when first called
break;
case DLL_THREAD_DETACH:
msvcrt_free_tls_mem();
break;
case DLL_PROCESS_DETACH:
TRACE("Detach\n");
/* Deinit of the WINE code */
msvcrt_free_io();
if (reserved) break;
msvcrt_free_mt_locks();
//msvcrt_free_console();
//msvcrt_free_args();
//msvcrt_free_signals();
msvcrt_free_tls_mem();
if (!msvcrt_free_tls())
return FALSE;
if(global_locale)
MSVCRT__free_locale(global_locale);
if (__winitenv && __winitenv != _wenviron)
FreeEnvironment((char**)__winitenv);
if (_wenviron)
FreeEnvironment((char**)_wenviron);
if (__initenv && __initenv != _environ)
FreeEnvironment(__initenv);
if (_environ)
FreeEnvironment(_environ);
TRACE("Detach done\n");
break;
}
return TRUE;
}
/*
* Returns the system information obtained by uname system call.
*
* The return value is a hash which has 5 keys at least:
* :sysname, :nodename, :release, :version, :machine
*
* Example:
*
* require 'etc'
* require 'pp'
*
* pp Etc.uname
* #=> {:sysname=>"Linux",
* # :nodename=>"boron",
* # :release=>"2.6.18-6-xen-686",
* # :version=>"#1 SMP Thu Nov 5 19:54:42 UTC 2009",
* # :machine=>"i686"}
*
*/
static VALUE
etc_uname(VALUE obj)
{
#ifdef _WIN32
OSVERSIONINFOW v;
SYSTEM_INFO s;
const char *sysname, *mach;
VALUE result, release, version;
VALUE vbuf, nodename = Qnil;
DWORD len = 0;
WCHAR *buf;
v.dwOSVersionInfoSize = sizeof(v);
if (!GetVersionExW(&v))
rb_sys_fail("GetVersionEx");
result = rb_hash_new();
switch (v.dwPlatformId) {
case VER_PLATFORM_WIN32s:
sysname = "Win32s";
break;
case VER_PLATFORM_WIN32_NT:
sysname = "Windows_NT";
break;
case VER_PLATFORM_WIN32_WINDOWS:
default:
sysname = "Windows";
break;
}
rb_hash_aset(result, ID2SYM(rb_intern("sysname")), rb_str_new_cstr(sysname));
release = rb_sprintf("%lu.%lu.%lu", v.dwMajorVersion, v.dwMinorVersion, v.dwBuildNumber);
rb_hash_aset(result, ID2SYM(rb_intern("release")), release);
version = rb_sprintf("%s Version %"PRIsVALUE": %"PRIsVALUE, sysname, release,
rb_w32_conv_from_wchar(v.szCSDVersion, rb_utf8_encoding()));
rb_hash_aset(result, ID2SYM(rb_intern("version")), version);
# if defined _MSC_VER && _MSC_VER < 1300
# define GET_COMPUTER_NAME(ptr, plen) GetComputerNameW(ptr, plen)
# else
# define GET_COMPUTER_NAME(ptr, plen) GetComputerNameExW(ComputerNameDnsFullyQualified, ptr, plen)
# endif
GET_COMPUTER_NAME(NULL, &len);
buf = ALLOCV_N(WCHAR, vbuf, len);
if (GET_COMPUTER_NAME(buf, &len)) {
nodename = rb_w32_conv_from_wchar(buf, rb_utf8_encoding());
}
ALLOCV_END(vbuf);
if (NIL_P(nodename)) nodename = rb_str_new(0, 0);
rb_hash_aset(result, ID2SYM(rb_intern("nodename")), nodename);
# ifndef PROCESSOR_ARCHITECTURE_AMD64
# define PROCESSOR_ARCHITECTURE_AMD64 9
# endif
# ifndef PROCESSOR_ARCHITECTURE_IA64
# define PROCESSOR_ARCHITECTURE_IA64 6
# endif
# ifndef PROCESSOR_ARCHITECTURE_INTEL
# define PROCESSOR_ARCHITECTURE_INTEL 0
# endif
GetSystemInfo(&s);
switch (s.wProcessorArchitecture) {
case PROCESSOR_ARCHITECTURE_AMD64:
mach = "x64";
break;
case PROCESSOR_ARCHITECTURE_ARM:
mach = "ARM";
break;
case PROCESSOR_ARCHITECTURE_IA64:
mach = "IA64";
break;
case PROCESSOR_ARCHITECTURE_INTEL:
mach = "x86";
break;
default:
mach = "unknown";
break;
}
rb_hash_aset(result, ID2SYM(rb_intern("machine")), rb_str_new_cstr(mach));
#else
struct utsname u;
int ret;
VALUE result;
ret = uname(&u);
if (ret == -1)
rb_sys_fail("uname");
result = rb_hash_new();
rb_hash_aset(result, ID2SYM(rb_intern("sysname")), rb_str_new_cstr(u.sysname));
rb_hash_aset(result, ID2SYM(rb_intern("nodename")), rb_str_new_cstr(u.nodename));
rb_hash_aset(result, ID2SYM(rb_intern("release")), rb_str_new_cstr(u.release));
rb_hash_aset(result, ID2SYM(rb_intern("version")), rb_str_new_cstr(u.version));
rb_hash_aset(result, ID2SYM(rb_intern("machine")), rb_str_new_cstr(u.machine));
#endif
return result;
}
static VOID
ReportProductInfoEvent(VOID)
{
OSVERSIONINFOW versionInfo;
WCHAR szBuffer[512];
DWORD dwLength;
HKEY hKey;
DWORD dwValueLength;
DWORD dwType;
LONG lResult = ERROR_SUCCESS;
ZeroMemory(&versionInfo, sizeof(OSVERSIONINFO));
versionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
/* Get version information */
if (!GetVersionExW(&versionInfo))
return;
ZeroMemory(szBuffer, 512 * sizeof(WCHAR));
/* Write version into the buffer */
dwLength = swprintf(szBuffer,
L"%lu.%lu",
versionInfo.dwMajorVersion,
versionInfo.dwMinorVersion) + 1;
/* Write build number into the buffer */
dwLength += swprintf(&szBuffer[dwLength],
L"%lu",
versionInfo.dwBuildNumber) + 1;
/* Write service pack info into the buffer */
wcscpy(&szBuffer[dwLength], versionInfo.szCSDVersion);
dwLength += wcslen(versionInfo.szCSDVersion) + 1;
/* Read 'CurrentType' from the registry and write it into the buffer */
lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
0,
KEY_QUERY_VALUE,
&hKey);
if (lResult == ERROR_SUCCESS)
{
dwValueLength = 512 - dwLength;
lResult = RegQueryValueEx(hKey,
L"CurrentType",
NULL,
&dwType,
(LPBYTE)&szBuffer[dwLength],
&dwValueLength);
RegCloseKey(hKey);
}
/* Log the product information */
LogfReportEvent(EVENTLOG_INFORMATION_TYPE,
0,
EVENT_EventLogProductInfo,
4,
szBuffer,
0,
NULL);
}
/*
* Determine the *real* Windows version
*/
bool get_real_os_version(unsigned int *const major, unsigned int *const minor, unsigned int *const spack, bool *const pbOverride)
{
static const DWORD MAX_VALUE = 1024;
*major = *minor = *spack = 0;
*pbOverride = false;
//Initialize local variables
OSVERSIONINFOEXW osvi;
memset(&osvi, 0, sizeof(OSVERSIONINFOEXW));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW);
//Try GetVersionEx() first
if(GetVersionExW((LPOSVERSIONINFOW)&osvi) == FALSE)
{
if(g_bStdUtilsVerbose)
{
MessageBox(0, T("GetVersionEx() has failed, cannot detect Windows version!"), T("StdUtils::get_real_os_version"), MB_ICONERROR|MB_TOPMOST);
}
return false;
}
//Make sure we are running on NT
if(osvi.dwPlatformId == VER_PLATFORM_WIN32_NT)
{
*major = osvi.dwMajorVersion;
*minor = osvi.dwMinorVersion;
*spack = osvi.wServicePackMajor;
}
else
{
//Workaround for Windows 9x comaptibility mode
if(verify_os_version(4, 0, 0))
{
*pbOverride = true;
*major = 4;
}
else
{
//Really not running on Windows NT
return false;
}
}
//Determine the real *major* version first
for(DWORD nextMajor = (*major) + 1; nextMajor <= MAX_VALUE; nextMajor++)
{
if(verify_os_version(nextMajor, 0, 0))
{
*major = nextMajor;
*minor = *spack = 0;
*pbOverride = true;
continue;
}
break;
}
//Now also determine the real *minor* version
for(DWORD nextMinor = (*minor) + 1; nextMinor <= MAX_VALUE; nextMinor++)
{
if(verify_os_version((*major), nextMinor, 0))
{
*minor = nextMinor;
*spack = 0;
*pbOverride = true;
continue;
}
break;
}
//Finally determine the real *servicepack* version
for(WORD nextSpack = (*spack) + 1; nextSpack <= MAX_VALUE; nextSpack++)
{
if(verify_os_version((*major), (*minor), nextSpack))
{
*spack = nextSpack;
*pbOverride = true;
continue;
}
break;
}
//Workaround for the mess that is sometimes referred to as "Windows 10"
if(((*major) > 6) || (((*major) == 6) && ((*minor) >= 2)))
{
DWORD kernel32_version[2];
if(read_file_version(T("kernel32"), &kernel32_version[0], &kernel32_version[1]))
{
const DWORD kernel32_major = (kernel32_version[0] & DWORD(0xFFFF0000)) >> 0x10;
const DWORD kernel32_minor = (kernel32_version[0] & DWORD(0x0000FFFF)) >> 0x00;
if((kernel32_major > (*major)) || ((kernel32_major == (*major)) && (kernel32_minor > (*minor))))
{
*major = kernel32_major;
*minor = kernel32_minor;
*spack = 0;
*pbOverride = true;
}
}
}