CString CGnucleusDoc::GetVersionInfo(void)
{
char szAppName[_MAX_PATH];
DWORD dwHandle, dwSize;
CString version = "9.9.9.9";
if( GetModuleFileName(AfxGetInstanceHandle(), szAppName, sizeof(szAppName)) )
{
dwHandle = 0;
dwSize = GetFileVersionInfoSize(szAppName, &dwHandle);
if( dwSize != 0L )
{
UINT uVerInfoSize;
LPVOID lpStr;
LPVOID lpVerInfo = new BYTE[dwSize];
if( GetFileVersionInfo(szAppName, NULL, dwSize, lpVerInfo) )
{
if( VerQueryValue(lpVerInfo, "\\StringFileInfo\\040904B0\\ProductVersion", &lpStr, &uVerInfoSize) )
version = reinterpret_cast<char *>(lpStr);
}
delete[] lpVerInfo;
}
}
return version;
}
// Returns the version, as two unsigned longs, of the passed in path.
// If there is an error, or the version can't be determined, this will
// return null.
// It is the callers responsibility to free the return value if it is
// non-null.
DWORD *getVersion(const char *path) {
int handle;
int size;
if ((size = GetFileVersionInfoSize((char *)path, &handle)) > 0) {
void *data;
data = malloc(size);
if (GetFileVersionInfo((char *)path, 0, size, data)) {
VS_FIXEDFILEINFO info;
void *infoData;
int infoLength;
if (VerQueryValue(data, "\\", &infoData, &infoLength)) {
VS_FIXEDFILEINFO *defaultInfo = (VS_FIXEDFILEINFO *)infoData;
unsigned long *retValue = (DWORD *)malloc(sizeof(DWORD)
* 2);
retValue[0] = defaultInfo->dwFileVersionMS;
retValue[1] = defaultInfo->dwFileVersionLS;
return retValue;
}
}
}
return NULL;
}
void FileVersionInfo::_readVersion()
{
DWORD dwLen, dwUnUsed;
LPTSTR lpVI = NULL;
assert(m_file.size() >0);
dwLen = GetFileVersionInfoSize(m_file.c_str(), &dwUnUsed);
if (dwLen > 0)
{
lpVI = (LPTSTR) GlobalAlloc(GPTR, dwLen);
}
if (lpVI != NULL)
{
VS_FIXEDFILEINFO *lpFfi;
wchar_t szBuffer[2048];
UINT uLen = 0;
GetFileVersionInfo(m_file.c_str(), NULL, dwLen, lpVI);
if (VerQueryValue(lpVI , L"\\" , (LPVOID *)&lpFfi , &uLen))
{
swprintf_s(szBuffer, L"%d.%d.%d.%d", HIWORD(lpFfi->dwProductVersionMS), LOWORD(lpFfi->dwProductVersionMS),
HIWORD(lpFfi->dwProductVersionLS), LOWORD(lpFfi->dwProductVersionLS));
m_version = szBuffer;
m_majorVersion = HIWORD(lpFfi->dwProductVersionMS);
}
GlobalFree((HGLOBAL)lpVI);
}
g_log.Log(L"FileVersionInfo::ReadVersion. File '%s' version '%s'", (wchar_t*) m_file.c_str(), (wchar_t*) m_version.c_str());
}
int vmsBtSupport::getBtDllVersion()
{
static int ver = -1;
if (ver != -1)
return ver;
CString str = getBtDllFileName ().c_str ();
if (GetFileAttributes (str) == DWORD (-1))
return ver = INT_MAX;
DWORD dw;
DWORD dwSize = GetFileVersionInfoSize (str, &dw);
if (dwSize == 0)
return ver = 0;
LPVOID pvVer = _alloca (dwSize);
ZeroMemory (pvVer, dwSize);
if (FALSE == GetFileVersionInfo (str, 0, dwSize, pvVer))
return ver = 0;
VS_FIXEDFILEINFO *pFileInfo = NULL;
UINT u;
if (FALSE == VerQueryValue (pvVer, _T ("\\"), (LPVOID*)&pFileInfo, &u))
return ver = 0;
return ver = pFileInfo->dwFileVersionLS >> 16;
}
static CComBSTR GetFileVersion(const TCHAR* cszFilePath)
{
CComBSTR strVersion;
TCHAR szFilePath[MAX_PATH]; _tcscpy(szFilePath, cszFilePath);
DWORD hVersionInfo;
DWORD cbVersionInfo = GetFileVersionInfoSize(szFilePath, &hVersionInfo);
if(cbVersionInfo > 0)
{
char *rgchVersionInfo = new char[cbVersionInfo];
if(GetFileVersionInfo(szFilePath, hVersionInfo, cbVersionInfo, rgchVersionInfo))
{
UINT cbFixedFileInfo;
VS_FIXEDFILEINFO* pffiFixedFileInfo;
if(VerQueryValue(rgchVersionInfo, "\\", (void**)&pffiFixedFileInfo, &cbFixedFileInfo))
{
int ver_major = HIWORD( pffiFixedFileInfo->dwFileVersionMS ) ;
int ver_minor = LOWORD( pffiFixedFileInfo->dwFileVersionMS ) ;
int ver_build = HIWORD( pffiFixedFileInfo->dwFileVersionLS ) ;
int ver_year = LOWORD( pffiFixedFileInfo->dwFileVersionLS ) ;
char szVersion[12 * 4 + 3 + 1];
wsprintf(szVersion, "%d.%d.%d.%d", ver_major, ver_minor, ver_build, ver_year);
strVersion = szVersion;
}
}
delete rgchVersionInfo;
}
return strVersion ;
}
String TfrmMain::refreshVersion()
{
DWORD dwHandle = 0, dwVersionInfoSize;
UINT uLength;
LPVOID pFileInfo, ptr;
String sOut; // 리턴될 버전 정보.
String filename = Application->ExeName;
dwVersionInfoSize = GetFileVersionInfoSize(filename.c_str(), &dwHandle);
pFileInfo = (LPVOID) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwVersionInfoSize);
GetFileVersionInfo(filename.c_str(), dwHandle, dwVersionInfoSize, pFileInfo);
VerQueryValue(pFileInfo, TEXT("\\VarFileInfo\\Translation"), &ptr, &uLength);
WORD *id = (WORD *) ptr;
String sQuery = "FileVersion";//{"CompanyName", "FileDescription", "FileVersion", "InternalName", "LegalCopyright", "LegalTradeMarks", "OriginalFileName", "ProductName", "ProductVersion", "Comments"};
String szString = "\\StringFileInfo\\" + IntToHex(id[0], 4) + IntToHex(id[1], 4) + "\\" + sQuery;
VerQueryValue(pFileInfo, szString.c_str(), &ptr, &uLength);
sOut = String((wchar_t *) ptr);
HeapFree(GetProcessHeap(), 0, pFileInfo );
return sOut;
}
BOOL CModuleVersion::GetFileVersionInfo(LPCTSTR filename)
{
// read file version info
DWORD dwDummyHandle;
// will always be set to zero
DWORD len = GetFileVersionInfoSize( (LPTSTR)filename, &dwDummyHandle);
if ( len <= 0 )
return (FALSE);
m_pVersionInfo = new BYTE[len]; // allocate version info
if ( !::GetFileVersionInfo( (LPTSTR) filename, 0, len, m_pVersionInfo) )
return (FALSE);
LPVOID lpvi;
UINT iLen;
if ( !VerQueryValue(m_pVersionInfo, _T("\\"), &lpvi, &iLen) )
return (FALSE);
// copy fixed info to myself, which am derived from VS_FIXEDFILEINFO
*(VS_FIXEDFILEINFO*)this = *(VS_FIXEDFILEINFO*)lpvi;
// Get translation info
if ( VerQueryValue(m_pVersionInfo, _T("\\VarFileInfo\\Translation"),
&lpvi, &iLen) && iLen >= 4 )
{
m_translation = *(TRANSLATION*)lpvi;
//TRACE("code page = %d\n", m_translation.charset);
}
return (dwSignature == VS_FFI_SIGNATURE);
}
BOOL GetFileCorporation(PWCHAR pszFileName, PWCHAR pszFileCorporation)
{
ULONG uLen;
PVOID buf;
PLANGUAGE_CODE_PAGE lpTranslate;
UINT uTranslate;
WCHAR szSubBlock[260];
PVOID szInfo;
UINT uLen1;
if (pszFileName == NULL) return FALSE;
uLen = GetFileVersionInfoSize(pszFileName, 0);
if (uLen <= 0) return FALSE;
buf = GlobalAlloc(GPTR, uLen);
if (!GetFileVersionInfo(pszFileName, NULL, uLen, buf))
{
GlobalFree(buf);
return FALSE;
}
VerQueryValue(buf, L"\\VarFileInfo\\Translation",
(LPVOID*)&lpTranslate, &uTranslate);
wsprintf(szSubBlock, L"\\StringFileInfo\\%04x%04x\\CompanyName",
lpTranslate[0].wLanguage, lpTranslate[0].wCodePage);
if(VerQueryValue(buf,szSubBlock, &szInfo, &uLen1) == FALSE)
{
GlobalFree(buf);
return FALSE;
}
wcscpy(pszFileCorporation, (PWCHAR)szInfo);
GlobalFree(buf);
return TRUE;
}
const char* GetDllVersion(const char* filename)
{
static TCHAR szVersion[32];
szVersion[0] = '\0';
if(filename == NULL || filename[0] == '\0')
{
return szVersion;
}
DWORD dwHandle = 0;
DWORD VersionInfoSize = GetFileVersionInfoSize(filename,&dwHandle);
if(VersionInfoSize > 0)
{
void* pVersionInfo = new BYTE[VersionInfoSize];
if(GetFileVersionInfo(filename, dwHandle, VersionInfoSize, pVersionInfo) == TRUE)
{
UINT uLen;
VS_FIXEDFILEINFO *lpFfi;
if(VerQueryValue(pVersionInfo, TEXT("\\"), (LPVOID *)&lpFfi, &uLen) == TRUE)
{
WORD w1, w2, w3, w4;
w1 = (WORD)(lpFfi->dwFileVersionMS >> 16);
w2 = (WORD)(lpFfi->dwFileVersionMS & 0xFFFF);
w3 = (WORD)(lpFfi->dwFileVersionLS >> 16);
w4 = (WORD)(lpFfi->dwFileVersionLS & 0xFFFF);
wsprintf(szVersion,TEXT("%d.%d.%d.%d\0"),w1,w2,w3,w4);
}
//-----------------------------------------------------------------------------
// Name: GetFileVersion()
// Desc: Returns ULARGE_INTEGER with a file version of a file, or a failure code.
//-----------------------------------------------------------------------------
HRESULT GetFileVersion(TCHAR *szPath, ULARGE_INTEGER *pllFileVersion)
{
if (szPath == NULL || pllFileVersion == NULL)
return E_INVALIDARG;
DWORD dwHandle;
UINT cb;
cb = GetFileVersionInfoSize(szPath, &dwHandle);
if (cb > 0)
{
BYTE *pFileVersionBuffer = new BYTE[cb];
if (pFileVersionBuffer == NULL)
return E_OUTOFMEMORY;
if (GetFileVersionInfo(szPath, 0, cb, pFileVersionBuffer))
{
VS_FIXEDFILEINFO* pVersion = NULL;
if (VerQueryValue(pFileVersionBuffer, TEXT("\\"), (VOID**)&pVersion, &cb) && pVersion != NULL)
{
pllFileVersion->HighPart = pVersion->dwFileVersionMS;
pllFileVersion->LowPart = pVersion->dwFileVersionLS;
delete[] pFileVersionBuffer;
return S_OK;
}
}
delete[] pFileVersionBuffer;
}
return E_FAIL;
}
mileversionimpl::mileversionimpl(const std::string &filename) :
_filename(filename), _haveinfo(false)
{
VS_FIXEDFILEINFO *fileinfo;
DWORD dummy;
DWORD infoSize = GetFileVersionInfoSize(filename.c_str(), &dummy);
if (infoSize > 0)
{
LPCSTR *buffer = new LPCSTR[infoSize];
if (GetFileVersionInfo(filename.c_str(), dummy, infoSize, buffer))
{
LPVOID ptr;
UINT len;
if (VerQueryValue(buffer, "\\", &ptr, &len))
{
_haveinfo = true;
fileinfo = (VS_FIXEDFILEINFO *)ptr;
char vinfo[50];
sprintf(vinfo, "%d.%d.%d.%d",
HIWORD(fileinfo->dwFileVersionMS), LOWORD(fileinfo->dwFileVersionMS),
HIWORD(fileinfo->dwFileVersionLS), LOWORD(fileinfo->dwFileVersionLS));
_fileversion = vinfo;
}
}
delete [] buffer;
}
}
int CAboutDlg::GetWindowsVersion(LPSTR strVersion)
{
TCHAR lpszSysPath[512]; /* address of buffer for Windows directory */
GetWindowsDirectory(lpszSysPath, 512);
lstrcat(lpszSysPath,_T("\\system\\user.exe"));
BYTE abData[512];
DWORD handle;
DWORD dwSize;
typedef struct tagLANGANDCP
{
WORD wLanguage;
WORD wCodePage;
} LANGANDCP;
LANGANDCP FAR *lpBuffer; // holds lang and codepage
dwSize = GetFileVersionInfoSize(lpszSysPath, &handle);
#ifdef _DEBUG
if(!dwSize)
return 0;
#endif
GetFileVersionInfo(lpszSysPath, handle, dwSize, abData);
VerQueryValue(abData, _T("\\VarFileInfo\\Translation"), (VOID FAR* FAR*)&lpBuffer, (UINT FAR *)&dwSize);
VerLanguageName (lpBuffer->wLanguage, strVersion, 512);
return LOBYTE(LOWORD(GetVersion())); // windows version greater than 3.x?
}
static int
ishim_get_file_version (const char * filepath, char * verout, int veroutlen)
{
DWORD dwDummyHandle, len;
BYTE * buf = 0;
unsigned int verlen;
LPVOID lpvi;
VS_FIXEDFILEINFO fileInfo;
if (!filepath || !filepath[0]) return 0;
len = GetFileVersionInfoSize((char *)filepath, &dwDummyHandle);
if (!len) return 0;
buf = (BYTE *)malloc(len * sizeof(BYTE));
if (!buf) return 0;
GetFileVersionInfo((char *)filepath, 0, len, buf);
VerQueryValue(buf, "\\", &lpvi, &verlen);
fileInfo = *(VS_FIXEDFILEINFO*)lpvi;
_snprintf(verout, veroutlen, "FV:%d.%d.%d.%d, PV:%d.%d.%d.%d"
, HIWORD(fileInfo.dwFileVersionMS)
, LOWORD(fileInfo.dwFileVersionMS)
, HIWORD(fileInfo.dwFileVersionLS)
, LOWORD(fileInfo.dwFileVersionLS)
, HIWORD(fileInfo.dwProductVersionMS)
, LOWORD(fileInfo.dwProductVersionMS)
, HIWORD(fileInfo.dwProductVersionLS)
, LOWORD(fileInfo.dwProductVersionLS));
free(buf);
return len;
}
void CXuser32App::GetVersionNumber(WORD nVersion[])
{
TCHAR szPath[128];
DWORD dwSize;
nVersion[0] = nVersion[1] = nVersion[2] = nVersion[3] = 0;
GetModuleFileName( NULL, szPath, 128 );
dwSize = GetFileVersionInfoSize( szPath, &dwSize );
if ( dwSize )
{
BYTE* pBuffer = new BYTE[ dwSize ];
if ( GetFileVersionInfo( szPath, NULL, dwSize, pBuffer ) )
{
VS_FIXEDFILEINFO* pTable;
if ( VerQueryValue( pBuffer, _T("\\"), (VOID**)&pTable, (UINT*)&dwSize ) )
{
nVersion[0] = (WORD)( pTable->dwFileVersionMS >> 16 );
nVersion[1] = (WORD)( pTable->dwFileVersionMS & 0xFFFF );
nVersion[2] = (WORD)( pTable->dwFileVersionLS >> 16 );
nVersion[3] = (WORD)( pTable->dwFileVersionLS & 0xFFFF );
}
}
delete [] pBuffer;
}
void FileVersionInfo::_readLanguageCode()
{
DWORD dwLen, dwUnUsed;
LPTSTR lpVI = NULL;
assert(m_file.size() >0);
dwLen = GetFileVersionInfoSize(m_file.c_str(), &dwUnUsed);
if (dwLen > 0)
{
lpVI = (LPTSTR) GlobalAlloc(GPTR, dwLen);
}
if (lpVI != NULL)
{
GetFileVersionInfo(m_file.c_str(), NULL, dwLen, lpVI);
unsigned int uLen;
VerQueryValue(lpVI,
L"\\VarFileInfo\\Translation", (LPVOID*)&lpTranslate, &uLen);
m_languageCode = lpTranslate->wLanguage;
GlobalFree((HGLOBAL)lpVI);
}
g_log.Log(L"FileVersionInfo::_readLanguageCode. File '%s' language '%u'", (wchar_t*) m_file.c_str(), (wchar_t*) m_languageCode);
}
CSVPEqualizer::CSVPEqualizer(void)
:m_sys_44(NULL)
,m_sys_48(NULL)
,m_rate(0)
{
if(1){
CString path;
GetModuleFileName(NULL, path.GetBuffer(MAX_PATH), MAX_PATH);
path.ReleaseBuffer();
path.MakeLower();
//SVP_LogMsg3("%s", path);
int Ret = -1;
if( path.Find(_T("splayer")) >= 0 || path.Find(_T("svplayer")) >= 0 || path.Find(_T("mplayerc")) >= 0 ){
DWORD dwHandle;
UINT dwLen;
UINT uLen;
UINT cbTranslate;
LPVOID lpBuffer;
dwLen = GetFileVersionInfoSize(path, &dwHandle);
TCHAR * lpData = (TCHAR*) malloc(dwLen);
if(!lpData)
return ;
memset((char*)lpData, 0 , dwLen);
/* GetFileVersionInfo() requires a char *, but the api doesn't
* indicate that it will modify it */
if(GetFileVersionInfo(path, dwHandle, dwLen, lpData) != 0)
{
// Read the file description for each language and code page.
CString szParm( _T("\\StringFileInfo\\000004b0\\FileDescription") );
if(VerQueryValue(lpData, szParm, &lpBuffer, &uLen) != 0)
{
CString szProductName((TCHAR*)lpBuffer);
//SVP_LogMsg3("szProductName %s", szProductName);
szProductName.MakeLower();
if(szProductName.Find(_T("ÉäÊÖ")) >= 0 || szProductName.Find(_T("splayer")) >= 0 ){
Ret = 3854;
}
}
}
}
m_fyy =((Ret-14)%192 == 0);
}
}
void TFileVersionInfo::ReadValues(String fname)
{
ResetValues();
DWORD zeroval;
int size = GetFileVersionInfoSize(fname.c_str(), (LPDWORD)&zeroval);
if (!size)
{
FError = true;
FErrorMsg = "GetFileVersionInfoSize() failed. " + ECC_DEBUGINFO;
return;
}
char* buf = new char[size+1];
try
{
if (GetFileVersionInfo(fname.c_str(), 0, size, (LPVOID)buf) == 0)
ECC_THROW("GetFileVersionInfo() failed");
/* Get language/codepage: */
struct TeccLangAndCP
{
WORD wLanguage;
WORD wCodePage;
} *PeccLangAndCP;
UINT LangLen;
if (VerQueryValue(buf, "\\VarFileInfo\\Translation", (LPVOID*)&PeccLangAndCP, &LangLen) == 0)
ECC_THROW("VerQueryValue() failed while retrieving language/codepage");
/* Get a value: */
String sub_blk = Format("\\StringFileInfo\\%.4x%.4x\\",
ARRAYOFCONST((PeccLangAndCP->wLanguage, PeccLangAndCP->wCodePage)));
void* val;
unsigned int len;
for (int i = 0; i < eccFVIKeyStringsCount; i++)
{
if (VerQueryValue(buf, String(sub_blk + TEccFVIKeyStrings[i]).c_str(), &val, &len))
Values[i] = String((char*)val, len).TrimRight();
//ECC_THROW("VerQueryValue() failed while retrieving value");
else
Values[i] = "Error retrieving value of '" + TEccFVIKeyStrings[i] + "'";
}
/* Ok: */
delete[] buf;
SplitVersionNumber();
}
catch(Exception &ex)
{
FError = true;
FErrorMsg = ex.Message;
delete[] buf;
}
}
bool ZVersionInfo::Load(LPCTSTR szModule)
{
// Check for a NULL or empty string
if (!szModule || TEXT('\0') == *szModule)
return Load(HINSTANCE(NULL));
// Ensure that there is no previous version information block allocated
Unload();
assert(!m_cbVerInfo);
assert(!m_pVerInfo);
assert(!m_pFixed);
// Get the size of the version information of the specified module
BYTE* pVerInfo = NULL;
DWORD cbVerInfo, dummy;
cbVerInfo = GetFileVersionInfoSize(const_cast<LPTSTR>(szModule), &dummy);
if (cbVerInfo)
{
// Allocate space to hold the version information
pVerInfo = new BYTE[cbVerInfo];
if (!pVerInfo)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return false;
}
}
else
cbVerInfo = sizeof(*m_pFixed);
// Attempt to load the version information block
if (!GetFileVersionInfo(const_cast<LPTSTR>(szModule), 0, cbVerInfo, pVerInfo))
{
DWORD dwLastError = GetLastError();
delete [] pVerInfo;
SetLastError(dwLastError ? dwLastError : ERROR_NO_MORE_ITEMS);
return false;
}
// Attempt to get a pointer to the fixed version information
VS_FIXEDFILEINFO* pFixed = NULL;
UINT cbFixed = 0;
if (!VerQueryValue(pVerInfo, TEXT("\\"), (void**)&pFixed, &cbFixed) || cbFixed != sizeof(*pFixed))
{
DWORD dwLastError = GetLastError();
delete [] pVerInfo;
SetLastError(dwLastError);
return false;
}
// Save the size of the version info and the allocated pointers
m_cbVerInfo = cbVerInfo;
m_pVerInfo = pVerInfo;
m_pFixed = pFixed;
// Indicate success
SetLastError(0);
return true;
}
BOOL CModuleVersion::GetDLLVersionInfo(LPCTSTR filename)
{
m_translation.charset = 1252; // default = ANSI code page
memset((VS_FIXEDFILEINFO*)this, 0, sizeof(VS_FIXEDFILEINFO));
// get module handle
//HMODULE hModule = LoadLibrary(filename);
//if (hModule==NULL)
// return FALSE;
// some times, LoadLibrary may fail , --- by bbcallen
HMODULE hModule = LoadLibraryEx(filename, NULL, LOAD_LIBRARY_AS_DATAFILE);
if (hModule==NULL)
return FALSE;
// read file version info
DWORD dwDummyHandle; // will always be set to zero
DWORD len = GetFileVersionInfoSize(filename, &dwDummyHandle);
if (len <= 0)
{
FreeLibrary(hModule);
return FALSE;
}
BYTE* pbData = new BYTE[len]; // allocate version info
if (!pbData)
{
FreeLibrary(hModule);
return FALSE;
}
m_atpVersionInfo.Attach(pbData);
if (!::GetFileVersionInfo(filename, 0, len, m_atpVersionInfo))
{
FreeLibrary(hModule);
return FALSE;
}
LPVOID lpvi;
UINT iLen;
if (!VerQueryValue(m_atpVersionInfo, _T("\\"), &lpvi, &iLen))
{
FreeLibrary(hModule);
return FALSE;
}
// copy fixed info to myself, which am derived from VS_FIXEDFILEINFO
*(VS_FIXEDFILEINFO*)this = *(VS_FIXEDFILEINFO*)lpvi;
// Get translation info
if (VerQueryValue(m_atpVersionInfo,
_T("\\VarFileInfo\\Translation"), &lpvi, &iLen) && iLen >= 4) {
m_translation = *(TRANSLATION*)lpvi;
}
FreeLibrary(hModule);
return dwSignature == VS_FFI_SIGNATURE;
}
Result LoadVersionResource(const string& file, Version::VersionResource& resource)
{
DWORD wtf;
DWORD size = GetFileVersionInfoSize(file.c_str(), &wtf);
LibCC::Blob<BYTE> bindata(size);
GetFileVersionInfo(file.c_str(), 0, size, bindata.GetBuffer());
BinaryMemory mem(bindata.GetBuffer(), size);
return resource.Read(mem);
}
void DumpResourcesToDisk(const string& exe, const string& dump)
{
DWORD wtf;
DWORD size = GetFileVersionInfoSize(exe.c_str(), &wtf);
LibCC::Blob<BYTE> bindata(size);
GetFileVersionInfo(exe.c_str(), 0, size, bindata.GetBuffer());
BinaryFile f(dump, true);
f.Write(bindata.GetBuffer(), bindata.Size());
}
/***************************************************************************
Function: CheckFileVersion
Purpose: Check the version information of a given file
Input: File name
File location (Windows dir, System dir, Current dir or none)
Reference to Major number
Reference to Minor number
Reference to Build number
Output: TRUE only if successful
Remarks: Trashes original file name
****************************************************************************/
BOOL CDLLVersion::CheckFileVersion (LPSTR szFileName,
DWORD &dwMajor, DWORD &dwMinor, DWORD &dwRelease,
DWORD &dwBuildNumber)
{
LPSTR lpVersion; // String pointer to 'version' text
UINT uVersionLen;
DWORD dwVerHnd=0; // An 'ignored' parameter, always '0'
//FixFilePath (szFileName); // Add necessary path prefix to file name
DWORD dwVerInfoSize = GetFileVersionInfoSize (szFileName, &dwVerHnd);
if (!dwVerInfoSize) // Cannot reach the DLL file
return FALSE;
LPSTR lpstrVffInfo = (LPSTR) malloc (dwVerInfoSize); // Alloc memory for file info
if (lpstrVffInfo == NULL)
return FALSE; // Allocation failed
// Try to get the info
if (!GetFileVersionInfo(szFileName, dwVerHnd, dwVerInfoSize, lpstrVffInfo)) {
free (lpstrVffInfo);
return FALSE; // Cannot read the file information -
// wierd, since we could read the information size
}
LANGANDCODEPAGE *lpTranslate;
char szFileVersion[MAX_PATH];
UINT cbTranslate;
VerQueryValue(lpstrVffInfo,
TEXT("\\VarFileInfo\\Translation"),
(LPVOID*)&lpTranslate,
&cbTranslate);
sprintf(szFileVersion, "\\StringFileInfo\\%04x%04x\\FileVersion", lpTranslate[0].wLanguage, lpTranslate[0].wCodePage);
if (!VerQueryValue ( lpstrVffInfo, (LPSTR) (TEXT(szFileVersion)),
(LPVOID *)&lpVersion, (UINT *)&uVersionLen))
{
free (lpstrVffInfo);
return FALSE; // Query was unsuccessful
}
// Now we have a string that looks like this :
// "MajorVersion.MinorVersion.BuildNumber", so let's parse it
BOOL bRes = ParseVersionString (lpVersion, dwMajor, dwMinor, dwRelease, dwBuildNumber, ",");
if (!bRes)
{
bRes = ParseVersionString (lpVersion, dwMajor, dwMinor, dwRelease, dwBuildNumber, ".");
}
free (lpstrVffInfo);
return bRes;
}
//Checks the file version of StarCraft.exe.
//If the version is correct, returns TRUE. Otherwise, this displays appropriate
//error messages and returns FALSE.
BOOL Plugin::checkStarCraftExeVersion(LPCSTR exePath) const {
BOOL result = FALSE;
DWORD dummy;
char errorMessage[500];
const DWORD fileVersionInfoBufferSize = GetFileVersionInfoSize(exePath, &dummy);
if (fileVersionInfoBufferSize > 0) {
VOID *fileVersionInfoBuffer = new BYTE[fileVersionInfoBufferSize];
VS_FIXEDFILEINFO *fileInfo;
UINT fileInfoSize;
if (GetFileVersionInfo(exePath, NULL, fileVersionInfoBufferSize, fileVersionInfoBuffer)
&& VerQueryValue(fileVersionInfoBuffer, "\\", (LPVOID*)&fileInfo, &fileInfoSize))
{
//The FileVersion of StarCraft.exe must be 1.16.1.1
const WORD requiredVersion[4] = { 1, 16, 1, 1 };
const WORD currentVersion[4] = {
HIWORD(fileInfo->dwFileVersionMS), LOWORD(fileInfo->dwFileVersionMS),
HIWORD(fileInfo->dwFileVersionLS), LOWORD(fileInfo->dwFileVersionLS)
};
if (requiredVersion[0] == currentVersion[0]
&& requiredVersion[1] == currentVersion[1]
&& requiredVersion[2] == currentVersion[2]
&& requiredVersion[3] == currentVersion[3])
{
result = TRUE;
}
else {
sprintf(errorMessage,
"Error: Cannot patch %s"
"\n"
"\nThis plugin (" PLUGIN_NAME ") is incompatible with the current version of StarCraft."
" The game will still be loaded, but no plugin features will be available."
"\n"
"\nCurrent StarCraft version: %hu.%hu.%hu.%hu"
"\nRequired StarCraft version: %hu.%hu.%hu.%hu",
exePath,
currentVersion[0], currentVersion[1], currentVersion[2], currentVersion[3],
requiredVersion[0], requiredVersion[1], requiredVersion[2], requiredVersion[3]);
}
}
else {
sprintf(errorMessage, "Cannot retrieve version information from:\n %s", exePath);
}
delete[] fileVersionInfoBuffer;
}
else {
sprintf(errorMessage, "Cannot retrieve version information size from:\n %s", exePath);
}
if (!result)
MessageBox(NULL, errorMessage, NULL, MB_OK);
return result;
}
QString VersionInfo::GetVersionString(const QString& filePath) {
#ifdef __WINDOWS__
//Fill the version info
TCHAR fullpath[MAX_PATH + 10];
if (filePath == "") {
GetModuleFileName(0, fullpath, MAX_PATH + 10);
} else {
for (int i = 0; i < filePath.length(); i++) {
fullpath[i] = filePath[i].toAscii();
}
fullpath[filePath.length()] = _T('\0');
}
TCHAR *str = new TCHAR[_tcslen(fullpath) + 1];
_tcscpy(str, fullpath);
DWORD tmp = 0;
DWORD len = GetFileVersionInfoSize(str, &tmp);
LPVOID pBlock = new char[len];
GetFileVersionInfo(str, 0, len, pBlock);
LPVOID ptr;
UINT ptrlen;
// Structure used to store enumerated languages and code pages.
struct LANGANDCODEPAGE {
WORD wLanguage;
WORD wCodePage;
} *lpTranslate;
UINT cbTranslate;
// Read the list of languages and code pages.
if (VerQueryValue(pBlock,
_T("\\VarFileInfo\\Translation"),
(LPVOID*)&lpTranslate,
&cbTranslate))
{
}
QString version;
//Format the versionstring
if (VerQueryValue(pBlock, _T("\\"), &ptr, &ptrlen)) {
VS_FIXEDFILEINFO *fi = (VS_FIXEDFILEINFO*)ptr;
QTextStream(&version) << HIWORD(fi->dwFileVersionMS) << "." << LOWORD(fi->dwFileVersionMS) << "." << HIWORD(fi->dwFileVersionLS) << "." << LOWORD(fi->dwFileVersionLS);
}
delete [] str;
delete [] pBlock;
return version;
#endif // __WINDOWS__
return "";
}
bool HasFileVersionInfo( LPCTSTR /*Info*/, LPCTSTR FileName )
{
DWORD dwHandle;
DWORD Size = GetFileVersionInfoSize((LPTSTR)FileName,&dwHandle);
if ( Size == 0)
{
return false;
}
return true;
}
BOOL GetVersionText(
LPCSTR /* IN */ szModulePath,
LPCSTR /* IN */ szBlock,
LPSTR /* OUT */ szText,
DWORD /* IN */ dwMaxTextLen
)
{
// Copying version information to buffer
UINT iDataLength=GetFileVersionInfoSize(szModulePath,NULL);
if (iDataLength<2)
return FALSE;
BYTE* pData=new BYTE[iDataLength+2];
if (pData==NULL)
return FALSE;
if (!GetFileVersionInfo(szModulePath,NULL,iDataLength,pData))
{
delete[] pData;
return FALSE;
}
VOID* pTranslations,* pProductVersion=NULL;
char szTranslation[200];
// Checking first translation block
if (!VerQueryValue(pData,"VarFileInfo\\Translation",&pTranslations,&iDataLength))
{
delete[] pData;
return FALSE;
}
sprintf_s(szTranslation,200,"\\StringFileInfo\\%04X%04X\\%s",LPWORD(pTranslations)[0],LPWORD(pTranslations)[1],szBlock);
if (!VerQueryValue(pData,szTranslation,&pProductVersion,&iDataLength))
{
// Checking english if nothing else does not found
sprintf_s(szTranslation,200,"\\StringFileInfo\\040904b0\\%s",szBlock);
if (!VerQueryValue(pData,szTranslation,&pProductVersion,&iDataLength))
{
delete[] pData;
return FALSE;
}
}
// Copying information from pProductVersion to szText
strcpy_s(szText,dwMaxTextLen,(LPCSTR)pProductVersion);
delete[] pData;
return TRUE;
}
void DkUtils::registerFileVersion() {
#ifdef Q_OS_WIN
// this function is based on code from:
// http://stackoverflow.com/questions/316626/how-do-i-read-from-a-version-resource-in-visual-c
QString version(NOMACS_VERSION); // default version (we do not know the build)
// get the filename of the executable containing the version resource
TCHAR szFilename[MAX_PATH + 1] = {0};
if (GetModuleFileName(NULL, szFilename, MAX_PATH) == 0) {
qWarning() << "Sorry, I can't read the module fileInfo name";
return;
}
// allocate a block of memory for the version info
DWORD dummy;
DWORD dwSize = GetFileVersionInfoSize(szFilename, &dummy);
if (dwSize == 0) {
qWarning() << "The version info size is zero\n";
return;
}
std::vector<BYTE> bytes(dwSize);
if (bytes.empty()) {
qWarning() << "The version info is empty\n";
return;
}
// load the version info
if (!bytes.empty() && !GetFileVersionInfo(szFilename, NULL, dwSize, &bytes[0])) {
qWarning() << "Sorry, I can't read the version info\n";
return;
}
// get the name and version strings
UINT uiVerLen = 0;
VS_FIXEDFILEINFO* pFixedInfo = 0; // pointer to fixed file info structure
if (!bytes.empty() && !VerQueryValue(&bytes[0], TEXT("\\"), (void**)&pFixedInfo, (UINT *)&uiVerLen)) {
qWarning() << "Sorry, I can't get the version values...\n";
return;
}
// pFixedInfo contains a lot more information...
version = QString::number(HIWORD(pFixedInfo->dwFileVersionMS)) + "."
+ QString::number(LOWORD(pFixedInfo->dwFileVersionMS)) + "."
+ QString::number(HIWORD(pFixedInfo->dwFileVersionLS)) + "."
+ QString::number(LOWORD(pFixedInfo->dwFileVersionLS));
#else
QString version(NOMACS_VERSION); // default version (we do not know the build)
#endif
QApplication::setApplicationVersion(version);
}
static std::string getProductName(const std::string& path)
{
auto wpath = UTF8ToWide(path);
auto verLength = GetFileVersionInfoSize(wpath.c_str(), nullptr);
if (!verLength) {
return "";
}
auto buffer = malloc(verLength);
if (!GetFileVersionInfo(wpath.c_str(), 0, verLength, buffer)) {
free(buffer);
return "";
}
struct LANGANDCODEPAGE
{
WORD language;
WORD codePage;
} *translations;
UINT translationsLength, nameLength;
WCHAR subBlockName[50];
WCHAR *neutralSubBlock = L"\\StringFileInfo\\00000000\\FileDescription";
WCHAR *name;
if (!VerQueryValue(buffer, L"\\VarFileInfo\\Translation",
(void **)&translations, &translationsLength)) {
free(buffer);
return "";
}
if (translationsLength < sizeof(LANGANDCODEPAGE)) {
free(buffer);
return "";
}
// TODO: try current locale/codepage
if (!VerQueryValue(buffer, neutralSubBlock, (void **)&name, &nameLength)) {
_snwprintf_s(subBlockName, _TRUNCATE,
L"\\StringFileInfo\\%04x%04x\\FileDescription",
translations[0].language, translations[0].codePage);
if (!VerQueryValue(buffer, subBlockName, (void **)&name, &nameLength)) {
free(buffer);
return "";
}
}
std::string result = TCHARToUTF8(name);
free(buffer);
return result;
}
CString HFileVersion::GetVer(CString strSubBlock)
{
CString strRet;
struct LANGANDCODEPAGE
{
WORD wLanguage; //语言代码,简体中文是2052
WORD wCodePage;
} *lpTranslate;
DWORD dwHandle;
DWORD dwInfoSize;
dwInfoSize = GetFileVersionInfoSize((char*)(LPCTSTR)m_strPath, &dwHandle);
if( dwInfoSize != 0 )
{
char* lpData = new char[dwInfoSize];
if( GetFileVersionInfo((char*)(LPCTSTR)m_strPath, 0, dwInfoSize, lpData) )
{
UINT cbTranslate = 0;
VerQueryValue(lpData,
TEXT("\\VarFileInfo\\Translation"),
(LPVOID*)&lpTranslate,
&cbTranslate);
char SubBlock[256];
char* lpBuffer = 0;
UINT dwBytes = 0;
for(int i=0; i < int(cbTranslate/sizeof(struct LANGANDCODEPAGE)); i++ )
{
wsprintf( SubBlock,
TEXT("\\StringFileInfo\\%04x%04x\\%s"),
lpTranslate->wLanguage,
lpTranslate->wCodePage,
strSubBlock);
VerQueryValue(lpData,
SubBlock,
(LPVOID*)&lpBuffer,
&dwBytes);
strRet.Format("%s", lpBuffer);
break; //only retrieve the first language and code page
}
}
delete [] lpData;
lpData = NULL;
}
return strRet;
}
void log_version()
{
DWORD handle;
TCHAR module_fname[MAX_PATH];
TCHAR* info_buf = NULL;
try {
if (!GetModuleFileName(NULL, module_fname, MAX_PATH)) {
throw;
}
DWORD version_inf_size = GetFileVersionInfoSize(module_fname, &handle);
if (version_inf_size == 0) {
throw;
}
TCHAR* info_buf = new TCHAR[version_inf_size];
if (!GetFileVersionInfo(module_fname, handle, version_inf_size, info_buf)) {
throw;
}
UINT size;
VS_FIXEDFILEINFO* file_info;
if (!VerQueryValue(info_buf, L"\\", (VOID**)&file_info, &size) ||
size < sizeof(VS_FIXEDFILEINFO)) {
throw;
}
vd_printf("%lu.%lu.%lu.%lu",
file_info->dwFileVersionMS >> 16,
file_info->dwFileVersionMS & 0x0ffff,
file_info->dwFileVersionLS >> 16,
file_info->dwFileVersionLS & 0x0ffff);
} catch (...) {
vd_printf("get version info failed");
}
delete[] info_buf;
}
