bool getFileVersion(const char* filePath, DWORD& fileVersionMS, DWORD& fileVersionLS) { DWORD verSize = GetFileVersionInfoSizeA(filePath, NULL); if (verSize == 0) { DWORD gle = GetLastError(); warning() << "GetFileVersionInfoSizeA on " << filePath << " failed with " << errnoWithDescription(gle); return false; } std::unique_ptr<char[]> verData(new char[verSize]); if (GetFileVersionInfoA(filePath, NULL, verSize, verData.get()) == 0) { DWORD gle = GetLastError(); warning() << "GetFileVersionInfoSizeA on " << filePath << " failed with " << errnoWithDescription(gle); return false; } UINT size; VS_FIXEDFILEINFO* verInfo; if (VerQueryValueA(verData.get(), "\\", (LPVOID*)&verInfo, &size) == 0) { DWORD gle = GetLastError(); warning() << "VerQueryValueA on " << filePath << " failed with " << errnoWithDescription(gle); return false; } if (size != sizeof(VS_FIXEDFILEINFO)) { warning() << "VerQueryValueA on " << filePath << " returned structure with unexpected size"; return false; } fileVersionMS = verInfo->dwFileVersionMS; fileVersionLS = verInfo->dwFileVersionLS; return true; }
/*********************************************************************** * GetFileVersionInfoSizeW [VERSION.@] */ DWORD WINAPI GetFileVersionInfoSizeW( LPCWSTR filename, LPDWORD handle ) { DWORD ret, len = WideCharToMultiByte( CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL ); LPSTR fn = HeapAlloc( GetProcessHeap(), 0, len ); WideCharToMultiByte( CP_ACP, 0, filename, -1, fn, len, NULL, NULL ); ret = GetFileVersionInfoSizeA( fn, handle ); HeapFree( GetProcessHeap(), 0, fn ); return ret; }
int __declspec(dllexport) Load(PLUGINLINK *link) { BOOL bFlag = FALSE; HINSTANCE hDll; #ifndef NDEBUG //mem leak detector :-) Thanks Tornado! int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG); // Get current flag flag |= _CRTDBG_LEAK_CHECK_DF; // Turn on leak-checking bit _CrtSetDbgFlag(flag); // Set flag to the new value #endif pluginLink = link; // set the memory & utf8 managers mir_getMMI( &memoryManagerInterface ); mir_getUTFI( &utfi ); mir_getLP( &pluginInfo ); hDll = LoadLibraryA("riched20.dll"); if ( hDll ) { char modulePath[MAX_PATH]; if (GetModuleFileNameA(hDll, modulePath, MAX_PATH)) { DWORD dummy; VS_FIXEDFILEINFO* vsInfo; UINT vsInfoSize; DWORD size = GetFileVersionInfoSizeA(modulePath, &dummy); BYTE* buffer = (BYTE*) mir_alloc(size); if (GetFileVersionInfoA(modulePath, 0, size, buffer)) if (VerQueryValueA(buffer, "\\", (LPVOID*) &vsInfo, &vsInfoSize)) if (LOWORD(vsInfo->dwFileVersionMS) != 0) bFlag= TRUE; mir_free(buffer); } } if ( !bFlag ) { if (IDYES == MessageBox(0, TranslateT("Miranda could not load the Chat plugin because Microsoft Rich Edit v 3 is missing.\nIf you are using Windows 95/98/NT or WINE please upgrade your Rich Edit control.\n\nDo you want to download an update now?."),TranslateT("Information"),MB_YESNO|MB_ICONINFORMATION)) CallService(MS_UTILS_OPENURL, 1, (LPARAM) "http://members.chello.se/matrix/re3/richupd.exe"); FreeLibrary(GetModuleHandleA("riched20.dll")); return 1; } UpgradeCheck(); g_hMenu = LoadMenu(g_hInst, MAKEINTRESOURCE(IDR_MENU)); InitREOleCallback(); HookEvents(); CreateServiceFunctions(); CreateHookableEvents(); OptionsInit(); TabsInit(); return 0; }
static void test_extra_block(void) { WORD extra_block[] = { 72, 0, 0, 'W', 'i', 'n', 'e', 'T', 'e', 's', 't', '\0', 24, 4, 0, 'B', 'i', 'n', 'a', 'r', 'y', '\0', 0xbeef, 0xdead, 24, 4, 1, 'T', 'e', 'x', 't', '\0', 'B', '-', ')', '\0', }; char buf[MAX_PATH]; UINT len, ret; ULONG w; char *ver, *p; WORD *length; ret = GetModuleFileNameA(NULL, buf, sizeof(buf)); ok(ret, "GetModuleFileNameA failed\n"); len = GetFileVersionInfoSizeA(buf, NULL); ok(len, "GetFileVersionInfoSizeA(%s) error %u\n", buf, GetLastError()); ver = HeapAlloc(GetProcessHeap(), 0, len + sizeof(extra_block) * 2); ok(ver != NULL, "Can't allocate memory\n"); ret = GetFileVersionInfoA(buf, 0, len, ver); ok(ret, "GetFileVersionInfoA error %u\n", GetLastError()); /* forge the string table, as windres dislike an extra block */ length = (WORD *)ver; /* see VS_VERSION_INFO_STRUCT32 for details */ memcpy(ver + *length, extra_block, sizeof(extra_block)); *length += sizeof(extra_block); p = (char *)0xdeadbeef; len = 0xdeadbeef; w = 0xdeadbeef; ret = VerQueryValueA(ver, "WineTest\\Binary", (LPVOID*)&p, &len); ok(ret, "VerQueryValue error %u\n", GetLastError()); ok(len == 4, "VerQueryValue returned %u, expected 4\n", len); ok(p != (char *)0xdeadbeef, "not expected 0xdeadbeef\n"); ok(memcmp(p, &w, sizeof(w)) == 0, "got 0x%08x, expected 0x%08x\n", *(PULONG)p, w); p = (char *)0xdeadbeef; len = 0xdeadbeef; ret = VerQueryValueA(ver, "WineTest\\Text", (LPVOID*)&p, &len); ok(ret, "VerQueryValue error %u\n", GetLastError()); ok(len == 4, "VerQueryValue returned %u, expected 4\n", len); ok(p != (char *)0xdeadbeef, "not expected 0xdeadbeef\n"); ok(strcmp(p, "B-)") == 0, "got '%s', expected '%s'\n", p, "B-)"); HeapFree(GetProcessHeap(), 0, ver); }
std::string get_sysinfo() { #ifdef _WIN32 std::ostringstream oss; LPSTR filePath = new char[MAX_PATH]; UINT blockSize; VS_FIXEDFILEINFO *fixedFileInfo; GetSystemDirectoryA(filePath, MAX_PATH); PathAppendA(filePath, "kernel32.dll"); DWORD dwVersionSize = GetFileVersionInfoSizeA(filePath, NULL); LPBYTE lpVersionInfo = new BYTE[dwVersionSize]; GetFileVersionInfoA(filePath, 0, dwVersionSize, lpVersionInfo); VerQueryValueA(lpVersionInfo, "\\", (LPVOID *)&fixedFileInfo, &blockSize); oss << "Windows/" << HIWORD(fixedFileInfo->dwProductVersionMS) << '.' // Major << LOWORD(fixedFileInfo->dwProductVersionMS) << '.' // Minor << HIWORD(fixedFileInfo->dwProductVersionLS) << ' '; // Build #ifdef _WIN64 oss << "x86_64"; #else BOOL is64 = FALSE; if (IsWow64Process(GetCurrentProcess(), &is64) && is64) oss << "x86_64"; // 32-bit app on 64-bit OS else oss << "x86"; #endif delete[] lpVersionInfo; delete[] filePath; return oss.str(); #else struct utsname osinfo; uname(&osinfo); return std::string(osinfo.sysname) + "/" + osinfo.release + " " + osinfo.machine; #endif }
std::string DynamicLibrary::getVersionStr() { std::string ret = "missing"; DWORD infoHandle; LONG sz = GetFileVersionInfoSizeA(name.c_str(),&infoHandle); if (!sz) return ret; VS_FIXEDFILEINFO * fileInf; std::vector<BYTE> buf(sz*2); if (!GetFileVersionInfoA(name.c_str(),0,sz,&buf[0])) return ret; UINT len; if (!VerQueryValueA(&buf[0],"\\",(LPVOID *) &fileInf,&len)) return ret; std::ostringstream strb; strb << HIWORD(fileInf->dwFileVersionMS) << "." << LOWORD(fileInf->dwFileVersionMS) << "." << HIWORD(fileInf->dwFileVersionLS) << "." << LOWORD(fileInf->dwFileVersionLS); return strb.str(); }
/*********************************************************************** * GetVersionFromFileEx (ADVPACK.@) */ HRESULT WINAPI GetVersionFromFileEx( LPSTR lpszFilename, LPDWORD pdwMSVer, LPDWORD pdwLSVer, BOOL bVersion ) { DWORD hdl, retval; LPVOID pVersionInfo; BOOL boolret; VS_FIXEDFILEINFO *pFixedVersionInfo; UINT uiLength; TRACE("(%s, %p, %p, %d)\n", lpszFilename, pdwMSVer, pdwLSVer, bVersion); if (bVersion) { retval = GetFileVersionInfoSizeA(lpszFilename, &hdl); if (retval == 0 || hdl != 0) return E_FAIL; pVersionInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, retval); if (pVersionInfo == NULL) return E_FAIL; GetFileVersionInfoA( lpszFilename, 0, retval, pVersionInfo); boolret = VerQueryValueA(pVersionInfo, "\\", (LPVOID) &pFixedVersionInfo, &uiLength); HeapFree(GetProcessHeap(), 0, pVersionInfo); if (boolret) { *pdwMSVer = pFixedVersionInfo->dwFileVersionMS; *pdwLSVer = pFixedVersionInfo->dwFileVersionLS; } else return E_FAIL; } else { *pdwMSVer = LOCALE_NEUTRAL; /* GetUserDefaultUILanguage(); */ *pdwLSVer = GetACP(); } return S_OK; }
// plugin.getVariable("$MyVariable"); - get a Torque 3D console variable STDMETHODIMP CIEWebGameCtrl::getVariable(BSTR name, BSTR* value) { std::wstring wstr; std::string sstr; const char* astr; wstr.assign(name); sstr = WebCommon::WStringToString(wstr); astr = sstr.c_str(); const char* avalue = NULL; char vinfo[256]; vinfo[0] = 0; // requesting the version information if (!_stricmp(astr, "$version")) { char plugin[4096]; GetModuleFileNameA(WebCommon::gPluginModule, plugin, 4096); DWORD dwHandle = 0; DWORD dwSize = GetFileVersionInfoSizeA(plugin, &dwHandle); if (dwSize >= 0) { LPBYTE lpInfo = new BYTE[dwSize]; ZeroMemory(lpInfo, dwSize); if(GetFileVersionInfoA(plugin, 0, dwSize, lpInfo)) { UINT valLen = MAX_PATH; LPVOID valPtr = NULL; if(::VerQueryValue(lpInfo, TEXT("\\"), &valPtr, &valLen)) { VS_FIXEDFILEINFO* pFinfo = (VS_FIXEDFILEINFO*)valPtr; sprintf(vinfo, "%i.%i", (pFinfo->dwProductVersionMS >> 16) & 0xFF, (pFinfo->dwFileVersionMS) & 0xFF); }
const char * get_file_version(const char * file_name) { static char version[32]; DWORD size; DWORD handle; size = GetFileVersionInfoSizeA("dsound.dll", &handle); if (size) { char * data = HeapAlloc(GetProcessHeap(), 0, size); if (data) { if (GetFileVersionInfoA("dsound.dll", handle, size, data)) { VS_FIXEDFILEINFO *pFixedVersionInfo; UINT len; if (VerQueryValueA(data, "\\", (LPVOID *)&pFixedVersionInfo, &len)) { sprintf(version, "%ld.%ld.%ld.%ld", pFixedVersionInfo->dwFileVersionMS >> 16, pFixedVersionInfo->dwFileVersionMS & 0xffff, pFixedVersionInfo->dwFileVersionLS >> 16, pFixedVersionInfo->dwFileVersionLS & 0xffff); } else sprintf(version, "not available"); } else
static char * get_file_version(char * file_name) { static char version[32]; DWORD size; DWORD handle; size = GetFileVersionInfoSizeA(file_name, &handle); if (size) { char * data = xmalloc(size); if (data) { if (GetFileVersionInfoA(file_name, handle, size, data)) { static char backslash[] = "\\"; VS_FIXEDFILEINFO *pFixedVersionInfo; UINT len; if (VerQueryValueA(data, backslash, (LPVOID *)&pFixedVersionInfo, &len)) { sprintf(version, "%d.%d.%d.%d", pFixedVersionInfo->dwFileVersionMS >> 16, pFixedVersionInfo->dwFileVersionMS & 0xffff, pFixedVersionInfo->dwFileVersionLS >> 16, pFixedVersionInfo->dwFileVersionLS & 0xffff); } else sprintf(version, "version not available"); } else
/** * Worker for VBoxServiceGetFileVersionString. * * @returns VBox status code. * @param pszFilename ASCII & ANSI & UTF-8 compliant name. */ static int VBoxServiceGetFileVersion(const char *pszFilename, PDWORD pdwMajor, PDWORD pdwMinor, PDWORD pdwBuildNumber, PDWORD pdwRevisionNumber) { int rc; *pdwMajor = *pdwMinor = *pdwBuildNumber = *pdwRevisionNumber = 0; /* * Get the file version info. */ DWORD dwHandleIgnored; DWORD cbVerData = GetFileVersionInfoSizeA(pszFilename, &dwHandleIgnored); if (cbVerData) { LPTSTR pVerData = (LPTSTR)RTMemTmpAllocZ(cbVerData); if (pVerData) { if (GetFileVersionInfoA(pszFilename, dwHandleIgnored, cbVerData, pVerData)) { /* * Try query and parse the FileVersion string our selves first * since this will give us the correct revision number when * it goes beyond the range of an uint16_t / WORD. */ if (VBoxServiceGetFileVersionOwn(pVerData, pdwMajor, pdwMinor, pdwBuildNumber, pdwRevisionNumber)) rc = VINF_SUCCESS; else { /* Fall back on VS_FIXEDFILEINFO */ UINT cbFileInfoIgnored = 0; VS_FIXEDFILEINFO *pFileInfo = NULL; if (VerQueryValue(pVerData, "\\", (LPVOID *)&pFileInfo, &cbFileInfoIgnored)) { *pdwMajor = HIWORD(pFileInfo->dwFileVersionMS); *pdwMinor = LOWORD(pFileInfo->dwFileVersionMS); *pdwBuildNumber = HIWORD(pFileInfo->dwFileVersionLS); *pdwRevisionNumber = LOWORD(pFileInfo->dwFileVersionLS); rc = VINF_SUCCESS; } else { rc = RTErrConvertFromWin32(GetLastError()); VBoxServiceVerbose(3, "No file version value for file \"%s\" available! (%d / rc=%Rrc)\n", pszFilename, GetLastError(), rc); } } } else { rc = RTErrConvertFromWin32(GetLastError()); VBoxServiceVerbose(0, "GetFileVersionInfo(%s) -> %u / %Rrc\n", pszFilename, GetLastError(), rc); } RTMemTmpFree(pVerData); } else { VBoxServiceVerbose(0, "Failed to allocate %u byte for file version info for '%s'\n", cbVerData, pszFilename); rc = VERR_NO_TMP_MEMORY; } } else { rc = RTErrConvertFromWin32(GetLastError()); VBoxServiceVerbose(3, "GetFileVersionInfoSize(%s) -> %u / %Rrc\n", pszFilename, GetLastError(), rc); } return rc; }
/*********************************************************************** * VideoCapDriverDescAndVer [MSVIDEO.22] */ DWORD WINAPI VideoCapDriverDescAndVer16(WORD nr, LPSTR buf1, WORD buf1len, LPSTR buf2, WORD buf2len) { static const char version_info_spec[] = "\\StringFileInfo\\040904E4\\FileDescription"; DWORD verhandle; DWORD infosize; UINT subblocklen; char *s, buf[2048], fn[260]; LPBYTE infobuf; LPVOID subblock; DWORD i, cnt = 0, lRet; DWORD bufLen, fnLen; FILETIME lastWrite; HKEY hKey; BOOL found = FALSE; TRACE("(%d,%p,%d,%p,%d)\n", nr, buf1, buf1len, buf2, buf2len); lRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE, HKLM_DRIVERS32, 0, KEY_QUERY_VALUE, &hKey); if (lRet == ERROR_SUCCESS) { RegQueryInfoKeyA( hKey, 0, 0, 0, &cnt, 0, 0, 0, 0, 0, 0, 0); for (i = 0; i < cnt; i++) { bufLen = sizeof(buf) / sizeof(buf[0]); lRet = RegEnumKeyExA(hKey, i, buf, &bufLen, 0, 0, 0, &lastWrite); if (lRet != ERROR_SUCCESS) continue; if (strncasecmp(buf, "vid", 3)) continue; if (nr--) continue; fnLen = sizeof(fn); lRet = RegQueryValueExA(hKey, buf, 0, 0, (LPBYTE)fn, &fnLen); if (lRet == ERROR_SUCCESS) found = TRUE; break; } RegCloseKey( hKey ); } /* search system.ini if not found in the registry */ if (!found && GetPrivateProfileStringA("drivers32", NULL, NULL, buf, sizeof(buf), "system.ini")) { for (s = buf; *s; s += strlen(s) + 1) { if (strncasecmp(s, "vid", 3)) continue; if (nr--) continue; if (GetPrivateProfileStringA("drivers32", s, NULL, fn, sizeof(fn), "system.ini")) found = TRUE; break; } } if (!found) { TRACE("No more VID* entries found nr=%d\n", nr); return 20; } infosize = GetFileVersionInfoSizeA(fn, &verhandle); if (!infosize) { TRACE("%s has no fileversioninfo.\n", fn); return 18; } infobuf = HeapAlloc(GetProcessHeap(), 0, infosize); if (GetFileVersionInfoA(fn, verhandle, infosize, infobuf)) { /* Yes, two space behind : */ /* FIXME: test for buflen */ snprintf(buf2, buf2len, "Version: %d.%d.%d.%d\n", ((WORD*)infobuf)[0x0f], ((WORD*)infobuf)[0x0e], ((WORD*)infobuf)[0x11], ((WORD*)infobuf)[0x10] ); TRACE("version of %s is %s\n", fn, buf2); } else { TRACE("GetFileVersionInfoA failed for %s.\n", fn); lstrcpynA(buf2, fn, buf2len); /* msvideo.dll appears to copy fn*/ } /* FIXME: language problem? */ if (VerQueryValueA( infobuf, version_info_spec, &subblock, &subblocklen )) { UINT copylen = min(subblocklen,buf1len-1); memcpy(buf1, subblock, copylen); buf1[copylen] = '\0'; TRACE("VQA returned %s\n", (LPCSTR)subblock); } else { TRACE("VQA did not return on query \\StringFileInfo\\040904E4\\FileDescription?\n"); lstrcpynA(buf1, fn, buf1len); /* msvideo.dll appears to copy fn*/ } HeapFree(GetProcessHeap(), 0, infobuf); return 0; }
static void test_info(void) { DWORD hdl, retval; PVOID pVersionInfo = NULL; BOOL boolret; VS_FIXEDFILEINFO *pFixedVersionInfo; UINT uiLength; char VersionString[MAX_PATH]; static const char backslash[] = "\\"; DWORDLONG dwlVersion; hdl = 0x55555555; SetLastError(MY_LAST_ERROR); retval = GetFileVersionInfoSizeA( "kernel32.dll", &hdl); ok( retval, "GetFileVersionInfoSizeA result wrong! <> 0L expected, got 0x%08x\n", retval); ok((NO_ERROR == GetLastError()) || (MY_LAST_ERROR == GetLastError()), "Last error wrong! NO_ERROR/0x%08x (NT4) expected, got %u\n", MY_LAST_ERROR, GetLastError()); ok( hdl == 0L, "Handle wrong! 0L expected, got 0x%08x\n", hdl); if ( retval == 0 || hdl != 0) return; pVersionInfo = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, retval ); ok(pVersionInfo != 0, "HeapAlloc failed\n" ); if (pVersionInfo == 0) return; if (0) { /* this test crashes on WinNT4 */ boolret = GetFileVersionInfoA( "kernel32.dll", 0, retval, 0); ok (!boolret, "GetFileVersionInfoA should have failed: GetLastError = %u\n", GetLastError()); ok ((GetLastError() == ERROR_INVALID_DATA) || (GetLastError() == ERROR_BAD_PATHNAME) || (GetLastError() == NO_ERROR), "Last error wrong! ERROR_INVALID_DATA/ERROR_BAD_PATHNAME (ME)/" "NO_ERROR (95) expected, got %u\n", GetLastError()); } boolret = GetFileVersionInfoA( "kernel32.dll", 0, retval, pVersionInfo ); ok (boolret, "GetFileVersionInfoA failed: GetLastError = %u\n", GetLastError()); if (!boolret) goto cleanup; boolret = VerQueryValueA( pVersionInfo, NULL, (LPVOID *)&pFixedVersionInfo, &uiLength ); ok (boolret || GetLastError() == NO_ERROR /* Win98 */, "VerQueryValueA failed: GetLastError = %u\n", GetLastError()); boolret = VerQueryValueA( pVersionInfo, "", (LPVOID *)&pFixedVersionInfo, &uiLength ); ok (boolret, "VerQueryValueA failed: GetLastError = %u\n", GetLastError()); boolret = VerQueryValueA( pVersionInfo, backslash, (LPVOID *)&pFixedVersionInfo, &uiLength ); ok (boolret, "VerQueryValueA failed: GetLastError = %u\n", GetLastError()); if (!boolret) goto cleanup; dwlVersion = (((DWORDLONG)pFixedVersionInfo->dwFileVersionMS) << 32) + pFixedVersionInfo->dwFileVersionLS; VersionDwordLong2String(dwlVersion, VersionString); trace("kernel32.dll version: %s\n", VersionString); if (0) { /* this test crashes on WinNT4 */ boolret = VerQueryValueA( pVersionInfo, backslash, (LPVOID *)&pFixedVersionInfo, 0); ok (boolret, "VerQueryValue failed: GetLastError = %u\n", GetLastError()); } cleanup: HeapFree( GetProcessHeap(), 0, pVersionInfo); }
MEXP(int) getExeInfo(const char* file_name, char* exe_info, size_t exe_info_size, uint32_t* version, int platform) { const char* base = (char*) 0; unsigned long file_size; FILE* f = (FILE*) 0; int ret; #ifdef MOS_WINDOWS HANDLE hFile; FILETIME ft; SYSTEMTIME st; LPBYTE buf; VS_FIXEDFILEINFO* ffi; DWORD infoSize, bytesRead; #else cm_pe_t pe; cm_pe_resdir_t* root; cm_pe_resdir_t* dir; cm_pe_version_t ffi; size_t i; struct stat st; struct tm* time; #endif if (!file_name || !exe_info || !exe_info_size || !version) return 0; base = get_basename(file_name); switch (platform) { case BNCSUTIL_PLATFORM_X86: #ifdef MOS_WINDOWS infoSize = GetFileVersionInfoSizeA(file_name, &bytesRead); if (infoSize == 0) return 0; buf = (LPBYTE) VirtualAlloc(NULL, infoSize, MEM_COMMIT, PAGE_READWRITE); if (buf == NULL) return 0; if (GetFileVersionInfoA(file_name, NULL, infoSize, buf) == FALSE) return 0; if (!VerQueryValueA(buf, "\\", (LPVOID*) &ffi, (PUINT) &infoSize)) return 0; *version = ((HIWORD(ffi->dwProductVersionMS) & 0xFF) << 24) | ((LOWORD(ffi->dwProductVersionMS) & 0xFF) << 16) | ((HIWORD(ffi->dwProductVersionLS) & 0xFF) << 8) | (LOWORD(ffi->dwProductVersionLS) & 0xFF); #if DEBUG bncsutil_debug_message_a("%s version = %d.%d.%d.%d (0x%08X)", base, (HIWORD(ffi->dwProductVersionMS) & 0xFF), (LOWORD(ffi->dwProductVersionMS) & 0xFF), (HIWORD(ffi->dwProductVersionLS) & 0xFF), (LOWORD(ffi->dwProductVersionLS) & 0xFF), *version); #endif VirtualFree(buf, 0lu, MEM_RELEASE); #else pe = cm_pe_load(file_name); if (!pe) return 0; root = cm_pe_load_resources(pe); if (!root) { cm_pe_unload(pe); return 0; } for (i = 0; i < root->subdir_count; i++) { dir = (root->subdirs + i); if (dir->name == 16) { if (!cm_pe_fixed_version(pe, dir->subdirs->resources, &ffi)) { cm_pe_unload_resources(root); cm_pe_unload(pe); return 0; } break; } } *version = ((HIWORD(ffi.dwProductVersionMS) & 0xFF) << 24) | ((LOWORD(ffi.dwProductVersionMS) & 0xFF) << 16) | ((HIWORD(ffi.dwProductVersionLS) & 0xFF) << 8) | (LOWORD(ffi.dwProductVersionLS) & 0xFF); #if DEBUG bncsutil_debug_message_a("%s version = %d.%d.%d.%d (0x%08X)", base, (HIWORD(ffi.dwProductVersionMS) & 0xFF), (LOWORD(ffi.dwProductVersionMS) & 0xFF), (HIWORD(ffi.dwProductVersionLS) & 0xFF), (LOWORD(ffi.dwProductVersionLS) & 0xFF), *version); #endif cm_pe_unload_resources(root); cm_pe_unload(pe); #endif break; case BNCSUTIL_PLATFORM_MAC: case BNCSUTIL_PLATFORM_OSX: f = fopen(file_name, "r"); if (!f) return 0; if (fseek(f, -4, SEEK_END) != 0) { fclose(f); return 0; } if (fread(version, 4, 1, f) != 1) { fclose(f); return 0; } #ifdef MOS_WINDOWS fclose(f); #endif } #ifdef MOS_WINDOWS hFile = CreateFileA(file_name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (hFile == INVALID_HANDLE_VALUE) return 0; file_size = GetFileSize(hFile, NULL); if (!GetFileTime(hFile, &ft, NULL, NULL)) { CloseHandle(hFile); return 0; } if (!FileTimeToSystemTime(&ft, &st)) { CloseHandle(hFile); return 0; } CloseHandle(hFile); ret = snprintf(exe_info, exe_info_size, "%s %02u/%02u/%02u %02u:%02u:%02u %lu", base, st.wMonth, st.wDay, (st.wYear % 100), st.wHour, st.wMinute, st.wSecond, file_size); #else if (!f) f = fopen(file_name, "r"); if (!f) return 0; if (fseek(f, 0, SEEK_END) == -1) { fclose(f); return 0; } file_size = ftell(f); fclose(f); if (stat(file_name, &st) != 0) return 0; time = gmtime(&st.st_mtime); if (!time) return 0; switch (platform) { case BNCSUTIL_PLATFORM_MAC: case BNCSUTIL_PLATFORM_OSX: if (time->tm_year >= 100) // y2k time->tm_year -= 100; break; } ret = (int) snprintf(exe_info, exe_info_size, "%s %02u/%02u/%02u %02u:%02u:%02u %lu", base, (time->tm_mon+1), time->tm_mday, time->tm_year, time->tm_hour, time->tm_min, time->tm_sec, file_size); #endif #if DEBUG bncsutil_debug_message(exe_info); #endif return ret; }
static void test_32bit_win(void) { DWORD hdlA, retvalA; DWORD hdlW, retvalW = 0; BOOL retA,retW; PVOID pVersionInfoA = NULL; PVOID pVersionInfoW = NULL; char *pBufA; WCHAR *pBufW; UINT uiLengthA, uiLengthW; char mypathA[MAX_PATH]; WCHAR mypathW[MAX_PATH]; char rootA[] = "\\"; WCHAR rootW[] = { '\\', 0 }; WCHAR emptyW[] = { 0 }; char varfileinfoA[] = "\\VarFileInfo\\Translation"; WCHAR varfileinfoW[] = { '\\','V','a','r','F','i','l','e','I','n','f','o', '\\','T','r','a','n','s','l','a','t','i','o','n', 0 }; char WineVarFileInfoA[] = { 0x09, 0x04, 0xE4, 0x04 }; char FileDescriptionA[] = "\\StringFileInfo\\040904E4\\FileDescription"; WCHAR FileDescriptionW[] = { '\\','S','t','r','i','n','g','F','i','l','e','I','n','f','o', '\\','0','4','0','9','0','4','E','4', '\\','F','i','l','e','D','e','s','c','r','i','p','t','i','o','n', 0 }; char WineFileDescriptionA[] = "FileDescription"; WCHAR WineFileDescriptionW[] = { 'F','i','l','e','D','e','s','c','r','i','p','t','i','o','n', 0 }; BOOL is_unicode_enabled = TRUE; /* A copy from dlls/version/info.c */ typedef struct { WORD wLength; WORD wValueLength; WORD wType; WCHAR szKey[1]; #if 0 /* variable length structure */ /* DWORD aligned */ BYTE Value[]; /* DWORD aligned */ VS_VERSION_INFO_STRUCT32 Children[]; #endif } VS_VERSION_INFO_STRUCT32; /* If we call GetFileVersionInfoA on a system that supports Unicode, NT/W2K/XP/W2K3 (by default) and Wine, * the versioninfo will contain Unicode strings. * Part of the test is to call both the A and W versions, which should have the same Version Information * for some requests, on systems that support both calls. */ /* First get the versioninfo via the W versions */ SetLastError(0xdeadbeef); GetModuleFileNameW(NULL, mypathW, MAX_PATH); if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) { win_skip("GetModuleFileNameW not existing on this platform, skipping comparison between A- and W-calls\n"); is_unicode_enabled = FALSE; } if (is_unicode_enabled) { retvalW = GetFileVersionInfoSizeW( mypathW, &hdlW); pVersionInfoW = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, retvalW ); retW = GetFileVersionInfoW( mypathW, 0, retvalW, pVersionInfoW ); ok(retW, "GetFileVersionInfo failed: GetLastError = %u\n", GetLastError()); } GetModuleFileNameA(NULL, mypathA, MAX_PATH); retvalA = GetFileVersionInfoSizeA( mypathA, &hdlA); pVersionInfoA = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, retvalA ); retA = GetFileVersionInfoA( mypathA, 0, retvalA, pVersionInfoA ); ok(retA, "GetFileVersionInfo failed: GetLastError = %u\n", GetLastError()); if (is_unicode_enabled) { ok( retvalA == retvalW, "The size of the struct should be the same for both A/W calls, it is (%d) vs. (%d)\n", retvalA, retvalW); ok( !memcmp(pVersionInfoA, pVersionInfoW, retvalA), "Both structs should be the same, they aren't\n"); } /* The structs on Windows are bigger than just the struct for the basic information. The total struct * contains also an empty part, which is used for converted strings. The converted strings are a result * of calling VerQueryValueA on a 32bit resource and calling VerQueryValueW on a 16bit resource. * The first WORD of the structure (wLength) shows the size of the base struct. The total struct size depends * on the Windows version: * * 16bits resource (numbers are from a sample app): * * Windows Version Retrieved with A/W wLength StructSize * ==================================================================================== * Win98 A 0x01B4 (436) 436 * NT4 A/W 0x01B4 (436) 2048 ??? * W2K/XP/W2K3 A/W 0x01B4 (436) 1536 which is (436 - sizeof(VS_FIXEDFILEINFO)) * 4 * * 32bits resource (numbers are from this test executable version_crosstest.exe): * Windows Version Retrieved with A/W wLength StructSize * ============================================================= * Win98 A 0x01E0 (480) 848 (structure data doesn't seem correct) * NT4 A/W 0x0350 (848) 1272 (848 * 1.5) * W2K/XP/W2K3 A/W 0x0350 (848) 1700 which is (848 * 2) + 4 * * Wine will follow the implementation (eventually) of W2K/XP/W2K3 */ /* Now some tests for the above (only if we are unicode enabled) */ if (is_unicode_enabled) { VS_VERSION_INFO_STRUCT32 *vvis = pVersionInfoW; ok ( retvalW == ((vvis->wLength * 2) + 4) || retvalW == (vvis->wLength * 1.5), "Structure is not of the correct size\n"); } /* Although the 32bit resource structures contain Unicode strings, VerQueryValueA will always return normal strings, * VerQueryValueW will always return Unicode ones. (That means everything returned for StringFileInfo requests). */ /* Get the VS_FIXEDFILEINFO information, this must be the same for both A- and W-Calls */ retA = VerQueryValueA( pVersionInfoA, rootA, (LPVOID *)&pBufA, &uiLengthA ); ok (retA, "VerQueryValueA failed: GetLastError = %u\n", GetLastError()); ok ( uiLengthA == sizeof(VS_FIXEDFILEINFO), "Size (%d) doesn't match the size of the VS_FIXEDFILEINFO struct\n", uiLengthA); if (is_unicode_enabled) { if(0) { /* This causes Vista and w2k8 to crash */ retW = VerQueryValueW( pVersionInfoW, NULL, (LPVOID *)&pBufW, &uiLengthW ); ok (retW, "VerQueryValueW failed: GetLastError = %u\n", GetLastError()); } retW = VerQueryValueW( pVersionInfoW, emptyW, (LPVOID *)&pBufW, &uiLengthW ); ok (retW, "VerQueryValueW failed: GetLastError = %u\n", GetLastError()); retW = VerQueryValueW( pVersionInfoW, rootW, (LPVOID *)&pBufW, &uiLengthW ); ok (retW, "VerQueryValueW failed: GetLastError = %u\n", GetLastError()); ok ( uiLengthW == sizeof(VS_FIXEDFILEINFO), "Size (%d) doesn't match the size of the VS_FIXEDFILEINFO struct\n", uiLengthW ); ok( uiLengthA == uiLengthW, "The size of VS_FIXEDFILEINFO should be the same for both A/W calls, it is (%d) vs. (%d)\n", uiLengthA, uiLengthW); ok( !memcmp(pBufA, pBufW, uiLengthA), "Both values should be the same, they aren't\n"); } /* Get some VarFileInfo information, this must be the same for both A- and W-Calls */ retA = VerQueryValueA( pVersionInfoA, varfileinfoA, (LPVOID *)&pBufA, &uiLengthA ); ok (retA, "VerQueryValueA failed: GetLastError = %u\n", GetLastError()); ok( !memcmp(pBufA, WineVarFileInfoA, uiLengthA), "The VarFileInfo should have matched 0904e404 (non case sensitive)\n"); if (is_unicode_enabled) { retW = VerQueryValueW( pVersionInfoW, varfileinfoW, (LPVOID *)&pBufW, &uiLengthW ); ok (retW, "VerQueryValueW failed: GetLastError = %u\n", GetLastError()); ok( uiLengthA == uiLengthW, "The size of the VarFileInfo information should be the same for both A/W calls, it is (%d) vs. (%d)\n", uiLengthA, uiLengthW); ok( !memcmp(pBufA, pBufW, uiLengthA), "Both values should be the same, they aren't\n"); } /* Get some StringFileInfo information, this will be ANSI for A-Calls and Unicode for W-Calls */ retA = VerQueryValueA( pVersionInfoA, FileDescriptionA, (LPVOID *)&pBufA, &uiLengthA ); ok (retA, "VerQueryValueA failed: GetLastError = %u\n", GetLastError()); ok( !lstrcmpA(WineFileDescriptionA, pBufA), "expected '%s' got '%s'\n", WineFileDescriptionA, pBufA); /* Test a second time */ retA = VerQueryValueA( pVersionInfoA, FileDescriptionA, (LPVOID *)&pBufA, &uiLengthA ); ok (retA, "VerQueryValueA failed: GetLastError = %u\n", GetLastError()); ok( !lstrcmpA(WineFileDescriptionA, pBufA), "expected '%s' got '%s'\n", WineFileDescriptionA, pBufA); if (is_unicode_enabled) { retW = VerQueryValueW( pVersionInfoW, FileDescriptionW, (LPVOID *)&pBufW, &uiLengthW ); ok (retW, "VerQueryValueW failed: GetLastError = %u\n", GetLastError()); ok( !lstrcmpW(WineFileDescriptionW, pBufW), "FileDescription should have been '%s'\n", WineFileDescriptionA); } HeapFree( GetProcessHeap(), 0, pVersionInfoA); if (is_unicode_enabled) HeapFree( GetProcessHeap(), 0, pVersionInfoW); }
static void test_VerQueryValueA(void) { static const char * const value_name[] = { "Product", "CompanyName", "FileDescription", "Internal", "ProductVersion", "InternalName", "File", "LegalCopyright", "FileVersion", "Legal", "OriginalFilename", "ProductName", "Company", "Original" }; char *ver, *p; UINT len, ret, translation, i; char buf[MAX_PATH]; ret = GetModuleFileNameA(NULL, buf, sizeof(buf)); assert(ret); SetLastError(0xdeadbeef); len = GetFileVersionInfoSizeA(buf, NULL); ok(len, "GetFileVersionInfoSizeA(%s) error %u\n", buf, GetLastError()); ver = HeapAlloc(GetProcessHeap(), 0, len); assert(ver); SetLastError(0xdeadbeef); ret = GetFileVersionInfoA(buf, 0, len, ver); ok(ret, "GetFileVersionInfoA error %u\n", GetLastError()); p = (char *)0xdeadbeef; len = 0xdeadbeef; SetLastError(0xdeadbeef); ret = VerQueryValueA(ver, "\\VarFileInfo\\Translation", (LPVOID*)&p, &len); ok(ret, "VerQueryValue error %u\n", GetLastError()); ok(len == 4, "VerQueryValue returned %u, expected 4\n", len); translation = *(UINT *)p; translation = MAKELONG(HIWORD(translation), LOWORD(translation)); p = (char *)0xdeadbeef; len = 0xdeadbeef; SetLastError(0xdeadbeef); ret = VerQueryValueA(ver, "String", (LPVOID*)&p, &len); ok(!ret, "VerQueryValue should fail\n"); ok(GetLastError() == ERROR_RESOURCE_TYPE_NOT_FOUND || GetLastError() == 0xdeadbeef /* NT4, W2K */, "VerQueryValue returned %u\n", GetLastError()); ok(p == (char *)0xdeadbeef, "expected 0xdeadbeef got %p\n", p); ok(len == 0, "expected 0 got %x\n", len); p = (char *)0xdeadbeef; len = 0xdeadbeef; SetLastError(0xdeadbeef); ret = VerQueryValueA(ver, "StringFileInfo", (LPVOID*)&p, &len); ok(ret, "VerQueryValue error %u\n", GetLastError()); ok(len == 0, "VerQueryValue returned %u, expected 0\n", len); ok(p != (char *)0xdeadbeef, "not expected 0xdeadbeef\n"); p = (char *)0xdeadbeef; len = 0xdeadbeef; SetLastError(0xdeadbeef); ret = VerQueryValueA(ver, "\\StringFileInfo", (LPVOID*)&p, &len); ok(ret, "VerQueryValue error %u\n", GetLastError()); ok(len == 0, "VerQueryValue returned %u, expected 0\n", len); ok(p != (char *)0xdeadbeef, "not expected 0xdeadbeef\n"); p = (char *)0xdeadbeef; len = 0xdeadbeef; SetLastError(0xdeadbeef); ret = VerQueryValueA(ver, "\\\\StringFileInfo", (LPVOID*)&p, &len); ok(ret, "VerQueryValue error %u\n", GetLastError()); ok(len == 0, "VerQueryValue returned %u, expected 0\n", len); ok(p != (char *)0xdeadbeef, "not expected 0xdeadbeef\n"); p = (char *)0xdeadbeef; len = 0xdeadbeef; SetLastError(0xdeadbeef); ret = VerQueryValueA(ver, "\\StringFileInfo\\\\", (LPVOID*)&p, &len); ok(ret, "VerQueryValue error %u\n", GetLastError()); ok(len == 0, "VerQueryValue returned %u, expected 0\n", len); ok(p != (char *)0xdeadbeef, "not expected 0xdeadbeef\n"); sprintf(buf, "\\StringFileInfo\\%08x", translation); p = (char *)0xdeadbeef; len = 0xdeadbeef; SetLastError(0xdeadbeef); ret = VerQueryValueA(ver, buf, (LPVOID*)&p, &len); ok(ret, "VerQueryValue error %u\n", GetLastError()); ok(len == 0, "VerQueryValue returned %u, expected 0\n", len); ok(p != (char *)0xdeadbeef, "not expected 0xdeadbeef\n"); for (i = 0; i < sizeof(value_name)/sizeof(value_name[0]); i++) { sprintf(buf, "\\StringFileInfo\\%08x\\%s", translation, value_name[i]); p = (char *)0xdeadbeef; len = 0xdeadbeef; SetLastError(0xdeadbeef); ret = VerQueryValueA(ver, buf, (LPVOID*)&p, &len); ok(ret, "VerQueryValueA(%s) error %u\n", buf, GetLastError()); ok(len == strlen(value_name[i]) + 1, "VerQueryValue returned %u\n", len); ok(!strcmp(value_name[i], p), "expected \"%s\", got \"%s\"\n", value_name[i], p); /* test partial value names */ len = lstrlenA(buf); buf[len - 2] = 0; p = (char *)0xdeadbeef; len = 0xdeadbeef; SetLastError(0xdeadbeef); ret = VerQueryValueA(ver, buf, (LPVOID*)&p, &len); ok(!ret, "VerQueryValueA(%s) succeeded\n", buf); ok(GetLastError() == ERROR_RESOURCE_TYPE_NOT_FOUND || GetLastError() == 0xdeadbeef /* NT4, W2K */, "VerQueryValue returned %u\n", GetLastError()); ok(p == (char *)0xdeadbeef, "expected 0xdeadbeef got %p\n", p); ok(len == 0, "expected 0 or 0xbeef, got %x\n", len); } HeapFree(GetProcessHeap(), 0, ver); }
static void test_info_size(void) { DWORD hdl, retval; char mypath[MAX_PATH] = ""; SetLastError(MY_LAST_ERROR); retval = GetFileVersionInfoSizeA( NULL, NULL); ok( !retval, "GetFileVersionInfoSizeA result wrong! 0L expected, got 0x%08x\n", retval); EXPECT_INVALID__NOT_FOUND; hdl = 0x55555555; SetLastError(MY_LAST_ERROR); retval = GetFileVersionInfoSizeA( NULL, &hdl); ok( !retval, "GetFileVersionInfoSizeA result wrong! 0L expected, got 0x%08x\n", retval); EXPECT_INVALID__NOT_FOUND; ok( hdl == 0L, "Handle wrong! 0L expected, got 0x%08x\n", hdl); SetLastError(MY_LAST_ERROR); retval = GetFileVersionInfoSizeA( "", NULL); ok( !retval, "GetFileVersionInfoSizeA result wrong! 0L expected, got 0x%08x\n", retval); EXPECT_BAD_PATH__NOT_FOUND; hdl = 0x55555555; SetLastError(MY_LAST_ERROR); retval = GetFileVersionInfoSizeA( "", &hdl); ok( !retval, "GetFileVersionInfoSizeA result wrong! 0L expected, got 0x%08x\n", retval); EXPECT_BAD_PATH__NOT_FOUND; ok( hdl == 0L, "Handle wrong! 0L expected, got 0x%08x\n", hdl); SetLastError(MY_LAST_ERROR); retval = GetFileVersionInfoSizeA( "kernel32.dll", NULL); ok( retval, "GetFileVersionInfoSizeA result wrong! <> 0L expected, got 0x%08x\n", retval); ok((NO_ERROR == GetLastError()) || (MY_LAST_ERROR == GetLastError()), "Last error wrong! NO_ERROR/0x%08x (NT4) expected, got %u\n", MY_LAST_ERROR, GetLastError()); hdl = 0x55555555; SetLastError(MY_LAST_ERROR); retval = GetFileVersionInfoSizeA( "kernel32.dll", &hdl); ok( retval, "GetFileVersionInfoSizeA result wrong! <> 0L expected, got 0x%08x\n", retval); ok((NO_ERROR == GetLastError()) || (MY_LAST_ERROR == GetLastError()), "Last error wrong! NO_ERROR/0x%08x (NT4) expected, got %u\n", MY_LAST_ERROR, GetLastError()); ok( hdl == 0L, "Handle wrong! 0L expected, got 0x%08x\n", hdl); SetLastError(MY_LAST_ERROR); retval = GetFileVersionInfoSizeA( "notexist.dll", NULL); ok( !retval, "GetFileVersionInfoSizeA result wrong! 0L expected, got 0x%08x\n", retval); ok( (ERROR_FILE_NOT_FOUND == GetLastError()) || (ERROR_RESOURCE_DATA_NOT_FOUND == GetLastError()) || (MY_LAST_ERROR == GetLastError()) || (ERROR_SUCCESS == GetLastError()), /* win2k */ "Last error wrong! ERROR_FILE_NOT_FOUND/ERROR_RESOURCE_DATA_NOT_FOUND " "(XP)/0x%08x (NT4) expected, got %u\n", MY_LAST_ERROR, GetLastError()); /* test a currently loaded executable */ if(GetModuleFileNameA(NULL, mypath, MAX_PATH)) { hdl = 0x55555555; SetLastError(MY_LAST_ERROR); retval = GetFileVersionInfoSizeA( mypath, &hdl); ok( retval, "GetFileVersionInfoSizeA result wrong! <> 0L expected, got 0x%08x\n", retval); ok((NO_ERROR == GetLastError()) || (MY_LAST_ERROR == GetLastError()), "Last error wrong! NO_ERROR/0x%08x (NT4) expected, got %u\n", MY_LAST_ERROR, GetLastError()); ok( hdl == 0L, "Handle wrong! 0L expected, got 0x%08x\n", hdl); } else trace("skipping GetModuleFileNameA(NULL,..) failed\n"); /* test a not loaded executable */ if(GetSystemDirectoryA(mypath, MAX_PATH)) { lstrcatA(mypath, "\\regsvr32.exe"); if(INVALID_FILE_ATTRIBUTES == GetFileAttributesA(mypath)) trace("GetFileAttributesA(%s) failed\n", mypath); else { hdl = 0x55555555; SetLastError(MY_LAST_ERROR); retval = GetFileVersionInfoSizeA( mypath, &hdl); ok( retval, "GetFileVersionInfoSizeA result wrong! <> 0L expected, got 0x%08x\n", retval); ok((NO_ERROR == GetLastError()) || (MY_LAST_ERROR == GetLastError()), "Last error wrong! NO_ERROR/0x%08x (NT4) expected, got %u\n", MY_LAST_ERROR, GetLastError()); ok( hdl == 0L, "Handle wrong! 0L expected, got 0x%08x\n", hdl); } } else trace("skipping GetSystemDirectoryA(mypath,..) failed\n"); create_file("test.txt"); /* no version info */ SetLastError(0xdeadbeef); hdl = 0xcafe; retval = GetFileVersionInfoSizeA("test.txt", &hdl); ok(retval == 0, "Expected 0, got %d\n", retval); ok(hdl == 0, "Expected 0, got %d\n", hdl); ok(GetLastError() == ERROR_RESOURCE_DATA_NOT_FOUND || GetLastError() == ERROR_SUCCESS, /* win2k */ "Expected ERROR_RESOURCE_DATA_NOT_FOUND, got %d\n", GetLastError()); DeleteFileA("test.txt"); }
/************************************************************************* * GetFileVersionInfoSize [VER.6] */ DWORD WINAPI GetFileVersionInfoSize16( LPCSTR lpszFileName, LPDWORD lpdwHandle ) { TRACE("(%s, %p)\n", debugstr_a(lpszFileName), lpdwHandle ); return GetFileVersionInfoSizeA( lpszFileName, lpdwHandle ); }
std::string GLCaps::getDriverVersion() { if (computeVendor() == MESA) { // Mesa includes the driver version in the renderer version // e.g., "1.5 Mesa 6.4.2" static std::string _glVersion = (char*)glGetString(GL_VERSION); int i = _glVersion.rfind(' '); if (i == (int)std::string::npos) { return "Unknown (bad MESA driver string)"; } else { return _glVersion.substr(i + 1, _glVersion.length() - i); } } # ifdef G3D_WIN32 std::string driver; // Locate the windows\system directory { char sysDir[1024]; int sysSize = GetSystemDirectoryA(sysDir, 1024); if (sysSize == 0) { return "Unknown (can't find Windows directory)"; } driver = sysDir; } switch (computeVendor()) { case ATI: driver = driver + "\\ati2dvag.dll"; break; case NVIDIA: driver = driver + "\\nv4_disp.dll"; break; default: return "Unknown (Unknown vendor)"; } char* lpdriver = const_cast<char*>(driver.c_str()); DWORD dummy; int size = GetFileVersionInfoSizeA(lpdriver, &dummy); if (size == 0) { return "Unknown (Can't find driver)"; } void* buffer = new uint8[size]; if (GetFileVersionInfoA(lpdriver, 0, size, buffer) == 0) { delete[] (uint8*)buffer; return "Unknown"; } // Interpret the VS_VERSIONINFO header pseudo-struct VS_VERSIONINFO* pVS = (VS_VERSIONINFO*)buffer; debugAssert(!wcscmp(pVS->szKey, L"VS_VERSION_INFO")); uint8* pVt = (uint8*) &pVS->szKey[wcslen(pVS->szKey) + 1]; #define roundoffs(a,b,r) (((uint8*)(b) - (uint8*)(a) + ((r) - 1)) & ~((r) - 1)) #define roundpos(b, a, r) (((uint8*)(a)) + roundoffs(a, b, r)) VS_FIXEDFILEINFO* pValue = (VS_FIXEDFILEINFO*) roundpos(pVt, pVS, 4); #undef roundoffs #undef roundpos std::string result = "Unknown (No information)"; if (pVS->wValueLength) { result = format("%d.%d.%d.%d", pValue->dwProductVersionMS >> 16, pValue->dwProductVersionMS & 0xFFFF, pValue->dwProductVersionLS >> 16, pValue->dwProductVersionLS & 0xFFFF); }