/* * Implementation of VERSION.DLL - Version Info access * * Copyright 1996,1997 Marcus Meissner * Copyright 1997 David Cuthbert * Copyright 1999 Ulrich Weigand * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * TODO * o Verify VerQueryValue() */ #include #include #include #include "windef.h" #include "winbase.h" #include "winreg.h" #include "winver.h" #include "winternl.h" #include "wine/winuser16.h" #include "wine/unicode.h" #include "winerror.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(ver); /****************************************************************************** * * This function will print via dprintf[_]ver to stddeb debug info regarding * the file info structure vffi. * 15-Feb-1998 Dimitrie Paun (dimi@cs.toronto.edu) * Added this function to clean up the code. * *****************************************************************************/ static void print_vffi_debug(VS_FIXEDFILEINFO *vffi) { TRACE(" structversion=%u.%u, fileversion=%u.%u.%u.%u, productversion=%u.%u.%u.%u, flagmask=0x%lx, flags=%s%s%s%s%s%s\n", HIWORD(vffi->dwStrucVersion),LOWORD(vffi->dwStrucVersion), HIWORD(vffi->dwFileVersionMS),LOWORD(vffi->dwFileVersionMS), HIWORD(vffi->dwFileVersionLS),LOWORD(vffi->dwFileVersionLS), HIWORD(vffi->dwProductVersionMS),LOWORD(vffi->dwProductVersionMS), HIWORD(vffi->dwProductVersionLS),LOWORD(vffi->dwProductVersionLS), vffi->dwFileFlagsMask, (vffi->dwFileFlags & VS_FF_DEBUG) ? "DEBUG," : "", (vffi->dwFileFlags & VS_FF_PRERELEASE) ? "PRERELEASE," : "", (vffi->dwFileFlags & VS_FF_PATCHED) ? "PATCHED," : "", (vffi->dwFileFlags & VS_FF_PRIVATEBUILD) ? "PRIVATEBUILD," : "", (vffi->dwFileFlags & VS_FF_INFOINFERRED) ? "INFOINFERRED," : "", (vffi->dwFileFlags & VS_FF_SPECIALBUILD) ? "SPECIALBUILD," : "" ); TRACE("("); TRACE(" OS=0x%x.0x%x ", HIWORD(vffi->dwFileOS), LOWORD(vffi->dwFileOS) ); switch (vffi->dwFileOS&0xFFFF0000) { case VOS_DOS:TRACE("DOS,");break; case VOS_OS216:TRACE("OS/2-16,");break; case VOS_OS232:TRACE("OS/2-32,");break; case VOS_NT:TRACE("NT,");break; case VOS_UNKNOWN: default: TRACE("UNKNOWN(0x%lx),",vffi->dwFileOS&0xFFFF0000);break; } switch (LOWORD(vffi->dwFileOS)) { case VOS__BASE:TRACE("BASE");break; case VOS__WINDOWS16:TRACE("WIN16");break; case VOS__WINDOWS32:TRACE("WIN32");break; case VOS__PM16:TRACE("PM16");break; case VOS__PM32:TRACE("PM32");break; default:TRACE("UNKNOWN(0x%x)",LOWORD(vffi->dwFileOS));break; } TRACE(")\n"); switch (vffi->dwFileType) { default: case VFT_UNKNOWN: TRACE("filetype=Unknown(0x%lx)",vffi->dwFileType); break; case VFT_APP:TRACE("filetype=APP,");break; case VFT_DLL:TRACE("filetype=DLL,");break; case VFT_DRV: TRACE("filetype=DRV,"); switch(vffi->dwFileSubtype) { default: case VFT2_UNKNOWN: TRACE("UNKNOWN(0x%lx)",vffi->dwFileSubtype); break; case VFT2_DRV_PRINTER: TRACE("PRINTER"); break; case VFT2_DRV_KEYBOARD: TRACE("KEYBOARD"); break; case VFT2_DRV_LANGUAGE: TRACE("LANGUAGE"); break; case VFT2_DRV_DISPLAY: TRACE("DISPLAY"); break; case VFT2_DRV_MOUSE: TRACE("MOUSE"); break; case VFT2_DRV_NETWORK: TRACE("NETWORK"); break; case VFT2_DRV_SYSTEM: TRACE("SYSTEM"); break; case VFT2_DRV_INSTALLABLE: TRACE("INSTALLABLE"); break; case VFT2_DRV_SOUND: TRACE("SOUND"); break; case VFT2_DRV_COMM: TRACE("COMM"); break; case VFT2_DRV_INPUTMETHOD: TRACE("INPUTMETHOD"); break; } break; case VFT_FONT: TRACE("filetype=FONT."); switch (vffi->dwFileSubtype) { default: TRACE("UNKNOWN(0x%lx)",vffi->dwFileSubtype); break; case VFT2_FONT_RASTER:TRACE("RASTER");break; case VFT2_FONT_VECTOR:TRACE("VECTOR");break; case VFT2_FONT_TRUETYPE:TRACE("TRUETYPE");break; } break; case VFT_VXD:TRACE("filetype=VXD");break; case VFT_STATIC_LIB:TRACE("filetype=STATIC_LIB");break; } TRACE("\n"); TRACE(" filedata=0x%lx.0x%lx\n", vffi->dwFileDateMS,vffi->dwFileDateLS); } /*********************************************************************** * Version Info Structure */ typedef struct { WORD wLength; WORD wValueLength; CHAR szKey[1]; #if 0 /* variable length structure */ /* DWORD aligned */ BYTE Value[]; /* DWORD aligned */ VS_VERSION_INFO_STRUCT16 Children[]; #endif } VS_VERSION_INFO_STRUCT16; typedef struct { WORD wLength; WORD wValueLength; WORD bText; WCHAR szKey[1]; #if 0 /* variable length structure */ /* DWORD aligned */ BYTE Value[]; /* DWORD aligned */ VS_VERSION_INFO_STRUCT32 Children[]; #endif } VS_VERSION_INFO_STRUCT32; #define VersionInfoIs16( ver ) \ ( ((VS_VERSION_INFO_STRUCT16 *)ver)->szKey[0] >= ' ' ) #define DWORD_ALIGN( base, ptr ) \ ( (LPBYTE)(base) + ((((LPBYTE)(ptr) - (LPBYTE)(base)) + 3) & ~3) ) #define VersionInfo16_Value( ver ) \ DWORD_ALIGN( (ver), (ver)->szKey + strlen((ver)->szKey) + 1 ) #define VersionInfo32_Value( ver ) \ DWORD_ALIGN( (ver), (ver)->szKey + strlenW((ver)->szKey) + 1 ) #define VersionInfo16_Children( ver ) \ (VS_VERSION_INFO_STRUCT16 *)( VersionInfo16_Value( ver ) + \ ( ( (ver)->wValueLength + 3 ) & ~3 ) ) #define VersionInfo32_Children( ver ) \ (VS_VERSION_INFO_STRUCT32 *)( VersionInfo32_Value( ver ) + \ ( ( (ver)->wValueLength * \ ((ver)->bText? 2 : 1) + 3 ) & ~3 ) ) #define VersionInfo16_Next( ver ) \ (VS_VERSION_INFO_STRUCT16 *)( (LPBYTE)ver + (((ver)->wLength + 3) & ~3) ) #define VersionInfo32_Next( ver ) \ (VS_VERSION_INFO_STRUCT32 *)( (LPBYTE)ver + (((ver)->wLength + 3) & ~3) ) /*********************************************************************** * ConvertVersionInfo32To16 [internal] */ void ConvertVersionInfo32To16( VS_VERSION_INFO_STRUCT32 *info32, VS_VERSION_INFO_STRUCT16 *info16 ) { /* Copy data onto local stack to prevent overwrites */ WORD wLength = info32->wLength; WORD wValueLength = info32->wValueLength; WORD bText = info32->bText; LPBYTE lpValue = VersionInfo32_Value( info32 ); VS_VERSION_INFO_STRUCT32 *child32 = VersionInfo32_Children( info32 ); VS_VERSION_INFO_STRUCT16 *child16; TRACE("Converting %p to %p\n", info32, info16 ); TRACE("wLength %d, wValueLength %d, bText %d, value %p, child %p\n", wLength, wValueLength, bText, lpValue, child32 ); /* Convert key */ WideCharToMultiByte( CP_ACP, 0, info32->szKey, -1, info16->szKey, 0x7fffffff, NULL, NULL ); TRACE("Copied key from %p to %p: %s\n", info32->szKey, info16->szKey, debugstr_a(info16->szKey) ); /* Convert value */ if ( wValueLength == 0 ) { info16->wValueLength = 0; TRACE("No value present\n" ); } else if ( bText ) { info16->wValueLength = WideCharToMultiByte( CP_ACP, 0, (LPCWSTR)lpValue, -1, NULL, 0, NULL, NULL ); WideCharToMultiByte( CP_ACP, 0, (LPCWSTR)lpValue, -1, VersionInfo16_Value( info16 ), info16->wValueLength, NULL, NULL ); TRACE("Copied value from %p to %p: %s\n", lpValue, VersionInfo16_Value( info16 ), debugstr_a(VersionInfo16_Value( info16 )) ); } else { info16->wValueLength = wValueLength; memmove( VersionInfo16_Value( info16 ), lpValue, wValueLength ); TRACE("Copied value from %p to %p: %d bytes\n", lpValue, VersionInfo16_Value( info16 ), wValueLength ); } /* Convert children */ child16 = VersionInfo16_Children( info16 ); while ( (DWORD)child32 < (DWORD)info32 + wLength && child32->wLength != 0 ) { VS_VERSION_INFO_STRUCT32 *nextChild = VersionInfo32_Next( child32 ); ConvertVersionInfo32To16( child32, child16 ); child16 = VersionInfo16_Next( child16 ); child32 = nextChild; } /* Fixup length */ info16->wLength = (DWORD)child16 - (DWORD)info16; TRACE("Finished, length is %d (%p - %p)\n", info16->wLength, info16, child16 ); } /*********************************************************************** * VERSION_GetFileVersionInfo_PE [internal] * * NOTE: returns size of the PE VERSION resource or 0xFFFFFFFF * in the case the file is a PE module, but VERSION_INFO not found. */ static DWORD VERSION_GetFileVersionInfo_PE( LPCWSTR filename, DWORD datasize, LPVOID data ) { VS_FIXEDFILEINFO *vffi; DWORD len; BYTE *buf; HMODULE hModule; HRSRC hRsrc; HGLOBAL hMem; TRACE("%s\n", debugstr_w(filename)); hModule = GetModuleHandleW(filename); if(!hModule) hModule = LoadLibraryExW(filename, 0, LOAD_LIBRARY_AS_DATAFILE); else hModule = LoadLibraryExW(filename, 0, 0); if(!hModule) { WARN("Could not load %s\n", debugstr_w(filename)); return 0; } hRsrc = FindResourceW(hModule, MAKEINTRESOURCEW(VS_VERSION_INFO), MAKEINTRESOURCEW(VS_FILE_INFO)); if(!hRsrc) { WARN("Could not find VS_VERSION_INFO in %s\n", debugstr_w(filename)); FreeLibrary(hModule); return 0xFFFFFFFF; } len = SizeofResource(hModule, hRsrc); hMem = LoadResource(hModule, hRsrc); if(!hMem) { WARN("Could not load VS_VERSION_INFO from %s\n", debugstr_w(filename)); FreeLibrary(hModule); return 0xFFFFFFFF; } buf = LockResource(hMem); vffi = (VS_FIXEDFILEINFO *)VersionInfo32_Value( (VS_VERSION_INFO_STRUCT32 *)buf ); if ( vffi->dwSignature != VS_FFI_SIGNATURE ) { WARN("vffi->dwSignature is 0x%08lx, but not 0x%08lx!\n", vffi->dwSignature, VS_FFI_SIGNATURE ); len = 0xFFFFFFFF; goto END; } if ( TRACE_ON(ver) ) print_vffi_debug( vffi ); if(data) { if(datasize < len) len = datasize; /* truncate data */ if(len) memcpy(data, buf, len); else len = 0xFFFFFFFF; } END: FreeResource(hMem); FreeLibrary(hModule); return len; } /*********************************************************************** * VERSION_GetFileVersionInfo_16 [internal] * * NOTE: returns size of the 16-bit VERSION resource or 0xFFFFFFFF * in the case the file exists, but VERSION_INFO not found. */ static DWORD VERSION_GetFileVersionInfo_16( LPCSTR filename, DWORD datasize, LPVOID data ) { VS_FIXEDFILEINFO *vffi; DWORD len, offset; BYTE *buf; HMODULE16 hModule; HRSRC16 hRsrc; HGLOBAL16 hMem; char dllname[20], owner[20], *p; const char *basename; BOOL is_builtin = FALSE; TRACE("%s\n", debugstr_a(filename)); /* strip path information */ basename = filename; if (basename[0] && basename[1] == ':') basename += 2; /* strip drive specification */ if ((p = strrchr( basename, '\\' ))) basename = p + 1; if ((p = strrchr( basename, '/' ))) basename = p + 1; if (strlen(basename) < sizeof(dllname)-4) { int file_exists; strcpy( dllname, basename ); p = strrchr( dllname, '.' ); if (!p) strcat( dllname, ".dll" ); for (p = dllname; *p; p++) if (*p >= 'A' && *p <= 'Z') *p += 32; if (wine_dll_get_owner( dllname, owner, sizeof(owner), &file_exists ) == 0) is_builtin = TRUE; } /* first try without loading a 16-bit module */ if (is_builtin) len = 0; else len = GetFileResourceSize16( filename, MAKEINTRESOURCEA(VS_FILE_INFO), MAKEINTRESOURCEA(VS_VERSION_INFO), &offset ); if (len) { if (!data) return len; len = GetFileResource16( filename, MAKEINTRESOURCEA(VS_FILE_INFO), MAKEINTRESOURCEA(VS_VERSION_INFO), offset, datasize, data ); if (len) { if ( VersionInfoIs16( data ) ) vffi = (VS_FIXEDFILEINFO *)VersionInfo16_Value( (VS_VERSION_INFO_STRUCT16 *)data ); else vffi = (VS_FIXEDFILEINFO *)VersionInfo32_Value( (VS_VERSION_INFO_STRUCT32 *)data ); if ( vffi->dwSignature == VS_FFI_SIGNATURE ) { if ( ((VS_VERSION_INFO_STRUCT16 *)data)->wLength < len ) len = ((VS_VERSION_INFO_STRUCT16 *)data)->wLength; if ( TRACE_ON(ver) ) print_vffi_debug( vffi ); if ( datasize >= sizeof(VS_VERSION_INFO_STRUCT16) && datasize >= ((VS_VERSION_INFO_STRUCT16 *)data)->wLength && !VersionInfoIs16( data ) ) { /* convert resource from PE format to NE format */ ConvertVersionInfo32To16( (VS_VERSION_INFO_STRUCT32 *)data, (VS_VERSION_INFO_STRUCT16 *)data ); } return len; } } } /* this might be a builtin 16-bit module */ hModule = LoadLibrary16(filename); if(hModule < 32) { WARN("Could not load %s\n", debugstr_a(filename)); return 0; } hRsrc = FindResource16(hModule, MAKEINTRESOURCEA(VS_VERSION_INFO), MAKEINTRESOURCEA(VS_FILE_INFO)); if(!hRsrc) { WARN("Could not find VS_VERSION_INFO in %s\n", debugstr_a(filename)); FreeLibrary16(hModule); return 0xFFFFFFFF; } len = SizeofResource16(hModule, hRsrc); hMem = LoadResource16(hModule, hRsrc); if(!hMem) { WARN("Could not load VS_VERSION_INFO from %s\n", debugstr_a(filename)); FreeLibrary16(hModule); return 0xFFFFFFFF; } buf = LockResource16(hMem); if(!VersionInfoIs16(buf)) { len = 0xFFFFFFFF; goto END; } vffi = (VS_FIXEDFILEINFO *)VersionInfo16_Value( (VS_VERSION_INFO_STRUCT16 *)buf ); if ( vffi->dwSignature != VS_FFI_SIGNATURE ) { WARN("vffi->dwSignature is 0x%08lx, but not 0x%08lx!\n", vffi->dwSignature, VS_FFI_SIGNATURE ); len = 0xFFFFFFFF; goto END; } if ( TRACE_ON(ver) ) print_vffi_debug( vffi ); if(data) { if(datasize < len) len = datasize; /* truncate data */ if(len) memcpy(data, buf, len); else len = 0xFFFFFFFF; } END: FreeResource16(hMem); FreeLibrary16(hModule); return len; } /*********************************************************************** * GetFileVersionInfoSizeW [VERSION.@] */ DWORD WINAPI GetFileVersionInfoSizeW( LPCWSTR filename, LPDWORD handle ) { DWORD len; TRACE("(%s,%p)\n", debugstr_w(filename), handle ); if (handle) *handle = 0; if (!filename) { SetLastError(ERROR_INVALID_PARAMETER); return 0; } if (!*filename) { SetLastError(ERROR_BAD_PATHNAME); return 0; } len = VERSION_GetFileVersionInfo_PE(filename, 0, NULL); /* 0xFFFFFFFF means: file is a PE module, but VERSION_INFO not found */ if(len == 0xFFFFFFFF) { SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND); return 0; } if (!len) { LPSTR filenameA; len = WideCharToMultiByte( CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL ); filenameA = HeapAlloc( GetProcessHeap(), 0, len ); WideCharToMultiByte( CP_ACP, 0, filename, -1, filenameA, len, NULL, NULL ); len = VERSION_GetFileVersionInfo_16(filenameA, 0, NULL); HeapFree( GetProcessHeap(), 0, filenameA ); /* 0xFFFFFFFF means: file exists, but VERSION_INFO not found */ if (!len) { SetLastError(ERROR_FILE_NOT_FOUND); return 0; } if (len == 0xFFFFFFFF) { SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND); return 0; } } SetLastError(0); return len; } /*********************************************************************** * GetFileVersionInfoSizeA [VERSION.@] */ DWORD WINAPI GetFileVersionInfoSizeA( LPCSTR filename, LPDWORD handle ) { UNICODE_STRING filenameW; DWORD retval; if(filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename); else filenameW.Buffer = NULL; retval = GetFileVersionInfoSizeW(filenameW.Buffer, handle); RtlFreeUnicodeString(&filenameW); return retval; } /*********************************************************************** * GetFileVersionInfoA [VERSION.@] */ BOOL WINAPI GetFileVersionInfoA( LPCSTR filename, DWORD handle, DWORD datasize, LPVOID data ) { UNICODE_STRING filenameW; DWORD len; TRACE("(%s,%ld,size=%ld,data=%p)\n", debugstr_a(filename), handle, datasize, data ); if (!data) { SetLastError(ERROR_INVALID_DATA); return FALSE; } if(filename) RtlCreateUnicodeStringFromAsciiz(&filenameW, filename); else filenameW.Buffer = NULL; len = VERSION_GetFileVersionInfo_PE(filenameW.Buffer, datasize, data); /* 0xFFFFFFFF means: file is a PE module, but VERSION_INFO not found */ RtlFreeUnicodeString(&filenameW); if (len == 0xFFFFFFFF) { SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND); return FALSE; } if (!len) { len = VERSION_GetFileVersionInfo_16(filename, datasize, data); /* 0xFFFFFFFF means: file exists, but VERSION_INFO not found */ if (!len || len == 0xFFFFFFFF) { SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND); return FALSE; } } if ( datasize >= sizeof(VS_VERSION_INFO_STRUCT16) && datasize >= ((VS_VERSION_INFO_STRUCT16 *)data)->wLength && !VersionInfoIs16( data ) ) { /* convert resource from PE format to NE format */ ConvertVersionInfo32To16( (VS_VERSION_INFO_STRUCT32 *)data, (VS_VERSION_INFO_STRUCT16 *)data ); } SetLastError(0); return TRUE; } /*********************************************************************** * GetFileVersionInfoW [VERSION.@] */ BOOL WINAPI GetFileVersionInfoW( LPCWSTR filename, DWORD handle, DWORD datasize, LPVOID data ) { DWORD len; TRACE("(%s,%ld,size=%ld,data=%p)\n", debugstr_w(filename), handle, datasize, data ); if (!data) { SetLastError(ERROR_INVALID_DATA); return FALSE; } len = VERSION_GetFileVersionInfo_PE(filename, datasize, data); /* 0xFFFFFFFF means: file is a PE module, but VERSION_INFO not found */ if (len == 0xFFFFFFFF) { SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND); return FALSE; } if (!len) { LPSTR filenameA; len = WideCharToMultiByte( CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL ); filenameA = HeapAlloc( GetProcessHeap(), 0, len ); WideCharToMultiByte( CP_ACP, 0, filename, -1, filenameA, len, NULL, NULL ); len = VERSION_GetFileVersionInfo_16(filenameA, datasize, data); HeapFree( GetProcessHeap(), 0, filenameA ); /* 0xFFFFFFFF means: file exists, but VERSION_INFO not found */ if (!len || len == 0xFFFFFFFF) { SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND); return FALSE; } } if ( datasize >= sizeof(VS_VERSION_INFO_STRUCT16) && datasize >= ((VS_VERSION_INFO_STRUCT16 *)data)->wLength && VersionInfoIs16( data ) ) { ERR("Cannot access NE resource in %s\n", debugstr_w(filename) ); SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND); return FALSE; } SetLastError(0); return TRUE; } /*********************************************************************** * VersionInfo16_FindChild [internal] */ static VS_VERSION_INFO_STRUCT16 *VersionInfo16_FindChild( VS_VERSION_INFO_STRUCT16 *info, LPCSTR szKey, UINT cbKey ) { VS_VERSION_INFO_STRUCT16 *child = VersionInfo16_Children( info ); while ( (DWORD)child < (DWORD)info + info->wLength ) { if ( !strncasecmp( child->szKey, szKey, cbKey ) ) return child; if (!(child->wLength)) return NULL; child = VersionInfo16_Next( child ); } return NULL; } /*********************************************************************** * VersionInfo32_FindChild [internal] */ static VS_VERSION_INFO_STRUCT32 *VersionInfo32_FindChild( VS_VERSION_INFO_STRUCT32 *info, LPCWSTR szKey, UINT cbKey ) { VS_VERSION_INFO_STRUCT32 *child = VersionInfo32_Children( info ); while ( (DWORD)child < (DWORD)info + info->wLength ) { if ( !strncmpiW( child->szKey, szKey, cbKey ) ) return child; child = VersionInfo32_Next( child ); } return NULL; } /*********************************************************************** * VersionInfo16_QueryValue [internal] * * Gets a value from a 16-bit NE resource */ DWORD WINAPI VersionInfo16_QueryValue( VS_VERSION_INFO_STRUCT16 *info, LPCSTR lpSubBlock, LPVOID *lplpBuffer, UINT *puLen ) { while ( *lpSubBlock ) { /* Find next path component */ LPCSTR lpNextSlash; for ( lpNextSlash = lpSubBlock; *lpNextSlash; lpNextSlash++ ) if ( *lpNextSlash == '\\' ) break; /* Skip empty components */ if ( lpNextSlash == lpSubBlock ) { lpSubBlock++; continue; } /* We have a non-empty component: search info for key */ info = VersionInfo16_FindChild( info, lpSubBlock, lpNextSlash-lpSubBlock ); if ( !info ) return FALSE; /* Skip path component */ lpSubBlock = lpNextSlash; } /* Return value */ *lplpBuffer = VersionInfo16_Value( info ); if (puLen) *puLen = info->wValueLength; return TRUE; } /*********************************************************************** * VerQueryValueA [VERSION.@] */ DWORD WINAPI VerQueryValueA( LPVOID pBlock, LPCSTR lpSubBlock, LPVOID *lplpBuffer, UINT *puLen ) { VS_VERSION_INFO_STRUCT16 *info = (VS_VERSION_INFO_STRUCT16 *)pBlock; TRACE("(%p,%s,%p,%p)\n", pBlock, debugstr_a(lpSubBlock), lplpBuffer, puLen ); if ( !VersionInfoIs16( info ) ) { INT len; LPWSTR wide_str; DWORD give; /* Feb 2001 */ /* AOL 5.0 does this, expecting to get this: */ len = MultiByteToWideChar(CP_ACP, 0, lpSubBlock, -1, NULL, 0); wide_str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); MultiByteToWideChar(CP_ACP, 0, lpSubBlock, -1, wide_str, len); give = VerQueryValueW(pBlock, wide_str, lplpBuffer, puLen); HeapFree(GetProcessHeap(), 0, wide_str); return give; } return VersionInfo16_QueryValue(info, lpSubBlock, lplpBuffer, puLen); } /*********************************************************************** * VerQueryValueW [VERSION.@] */ DWORD WINAPI VerQueryValueW( LPVOID pBlock, LPCWSTR lpSubBlock, LPVOID *lplpBuffer, UINT *puLen ) { VS_VERSION_INFO_STRUCT32 *info = (VS_VERSION_INFO_STRUCT32 *)pBlock; TRACE("(%p,%s,%p,%p)\n", pBlock, debugstr_w(lpSubBlock), lplpBuffer, puLen ); if ( VersionInfoIs16( info ) ) { DWORD ret; int len = WideCharToMultiByte(CP_ACP, 0, lpSubBlock, -1, NULL, 0, NULL, NULL); LPSTR lpSubBlockA = HeapAlloc(GetProcessHeap(), 0, len * sizeof(char)); if (!lpSubBlockA) return FALSE; WideCharToMultiByte(CP_ACP, 0, lpSubBlock, -1, lpSubBlockA, len, NULL, NULL); ret = VersionInfo16_QueryValue(pBlock, lpSubBlockA, lplpBuffer, puLen); HeapFree(GetProcessHeap(), 0, lpSubBlockA); return ret; } while ( *lpSubBlock ) { /* Find next path component */ LPCWSTR lpNextSlash; for ( lpNextSlash = lpSubBlock; *lpNextSlash; lpNextSlash++ ) if ( *lpNextSlash == '\\' ) break; /* Skip empty components */ if ( lpNextSlash == lpSubBlock ) { lpSubBlock++; continue; } /* We have a non-empty component: search info for key */ info = VersionInfo32_FindChild( info, lpSubBlock, lpNextSlash-lpSubBlock ); if ( !info ) return FALSE; /* Skip path component */ lpSubBlock = lpNextSlash; } /* Return value */ *lplpBuffer = VersionInfo32_Value( info ); if (puLen) *puLen = info->wValueLength; return TRUE; }