dlls/version/info.c

   1 /*
   2  * Implementation of VERSION.DLL - Version Info access
   3  *
   4  * Copyright 1996,1997 Marcus Meissner
   5  * Copyright 1997 David Cuthbert
   6  * Copyright 1999 Ulrich Weigand
   7  * Copyright 2005 Paul Vriens
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  *
  23  */
  24
  25 #include <stdarg.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winver.h"
  32 #include "winternl.h"
  33 #include "lzexpand.h"
  34 #include "wine/winuser16.h"
  35 #include "wine/unicode.h"
  36 #include "winerror.h"
  37 #include "wine/debug.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(ver);
  40
  41 extern DWORD find_version_resource( HFILE lzfd, DWORD *reslen, DWORD *offset );
  42
  43 /******************************************************************************
  44  *
  45  *   This function will print via standard TRACE, debug info regarding
  46  *   the file info structure vffi.
  47  *      15-Feb-1998 Dimitrie Paun (dimi@cs.toronto.edu)
  48  *      Added this function to clean up the code.
  49  *
  50  *****************************************************************************/
  51 static void print_vffi_debug(const VS_FIXEDFILEINFO *vffi)
  52 {
  53     BOOL    versioned_printer = FALSE;
  54
  55     if((vffi->dwFileType == VFT_DLL) || (vffi->dwFileType == VFT_DRV))
  56     {
  57         if(vffi->dwFileSubtype == VFT2_DRV_VERSIONED_PRINTER)
  58             /* this is documented for newer w2k Drivers and up */
  59             versioned_printer = TRUE;
  60         else if( (vffi->dwFileSubtype == VFT2_DRV_PRINTER) &&
  61                  (vffi->dwFileVersionMS != vffi->dwProductVersionMS) &&
  62                  (vffi->dwFileVersionMS > 0) &&
  63                  (vffi->dwFileVersionMS <= 3) )
  64             /* found this on NT 3.51, NT4.0 and old w2k Drivers */
  65             versioned_printer = TRUE;
  66     }
  67
  68     TRACE("structversion=%u.%u, ",
  69             HIWORD(vffi->dwStrucVersion),LOWORD(vffi->dwStrucVersion));
  70     if(versioned_printer)
  71     {
  72         WORD mode = LOWORD(vffi->dwFileVersionMS);
  73         WORD ver_rev = HIWORD(vffi->dwFileVersionLS);
  74         TRACE("fileversion=%u.%u.%u.%u (%s.major.minor.release), ",
  75             (vffi->dwFileVersionMS),
  76             HIBYTE(ver_rev), LOBYTE(ver_rev), LOWORD(vffi->dwFileVersionLS),
  77             (mode == 3) ? "Usermode" : ((mode <= 2) ? "Kernelmode" : "?") );
  78     }
  79     else
  80     {
  81         TRACE("fileversion=%u.%u.%u.%u, ",
  82             HIWORD(vffi->dwFileVersionMS),LOWORD(vffi->dwFileVersionMS),
  83             HIWORD(vffi->dwFileVersionLS),LOWORD(vffi->dwFileVersionLS));
  84     }
  85     TRACE("productversion=%u.%u.%u.%u\n",
  86           HIWORD(vffi->dwProductVersionMS),LOWORD(vffi->dwProductVersionMS),
  87           HIWORD(vffi->dwProductVersionLS),LOWORD(vffi->dwProductVersionLS));
  88
  89     TRACE("flagmask=0x%x, flags=0x%x %s%s%s%s%s%s\n",
  90           vffi->dwFileFlagsMask, vffi->dwFileFlags,
  91           (vffi->dwFileFlags & VS_FF_DEBUG) ? "DEBUG," : "",
  92           (vffi->dwFileFlags & VS_FF_PRERELEASE) ? "PRERELEASE," : "",
  93           (vffi->dwFileFlags & VS_FF_PATCHED) ? "PATCHED," : "",
  94           (vffi->dwFileFlags & VS_FF_PRIVATEBUILD) ? "PRIVATEBUILD," : "",
  95           (vffi->dwFileFlags & VS_FF_INFOINFERRED) ? "INFOINFERRED," : "",
  96           (vffi->dwFileFlags & VS_FF_SPECIALBUILD) ? "SPECIALBUILD," : "");
  97
  98     TRACE("(");
  99
 100     TRACE("OS=0x%x.0x%x ", HIWORD(vffi->dwFileOS), LOWORD(vffi->dwFileOS));
 101
 102     switch (vffi->dwFileOS&0xFFFF0000)
 103     {
 104     case VOS_DOS:TRACE("DOS,");break;
 105     case VOS_OS216:TRACE("OS/2-16,");break;
 106     case VOS_OS232:TRACE("OS/2-32,");break;
 107     case VOS_NT:TRACE("NT,");break;
 108     case VOS_UNKNOWN:
 109     default:
 110         TRACE("UNKNOWN(0x%x),",vffi->dwFileOS&0xFFFF0000);break;
 111     }
 112
 113     switch (LOWORD(vffi->dwFileOS))
 114     {
 115     case VOS__BASE:TRACE("BASE");break;
 116     case VOS__WINDOWS16:TRACE("WIN16");break;
 117     case VOS__WINDOWS32:TRACE("WIN32");break;
 118     case VOS__PM16:TRACE("PM16");break;
 119     case VOS__PM32:TRACE("PM32");break;
 120     default:
 121         TRACE("UNKNOWN(0x%x)",LOWORD(vffi->dwFileOS));break;
 122     }
 123
 124     TRACE(")\n");
 125
 126     switch (vffi->dwFileType)
 127     {
 128     case VFT_APP:TRACE("filetype=APP");break;
 129     case VFT_DLL:
 130         TRACE("filetype=DLL");
 131         if(vffi->dwFileSubtype != 0)
 132         {
 133             if(versioned_printer) /* NT3.x/NT4.0 or old w2k Driver  */
 134                 TRACE(",PRINTER");
 135             TRACE(" (subtype=0x%x)", vffi->dwFileSubtype);
 136         }
 137         break;
 138     case VFT_DRV:
 139         TRACE("filetype=DRV,");
 140         switch(vffi->dwFileSubtype)
 141         {
 142         case VFT2_DRV_PRINTER:TRACE("PRINTER");break;
 143         case VFT2_DRV_KEYBOARD:TRACE("KEYBOARD");break;
 144         case VFT2_DRV_LANGUAGE:TRACE("LANGUAGE");break;
 145         case VFT2_DRV_DISPLAY:TRACE("DISPLAY");break;
 146         case VFT2_DRV_MOUSE:TRACE("MOUSE");break;
 147         case VFT2_DRV_NETWORK:TRACE("NETWORK");break;
 148         case VFT2_DRV_SYSTEM:TRACE("SYSTEM");break;
 149         case VFT2_DRV_INSTALLABLE:TRACE("INSTALLABLE");break;
 150         case VFT2_DRV_SOUND:TRACE("SOUND");break;
 151         case VFT2_DRV_COMM:TRACE("COMM");break;
 152         case VFT2_DRV_INPUTMETHOD:TRACE("INPUTMETHOD");break;
 153         case VFT2_DRV_VERSIONED_PRINTER:TRACE("VERSIONED_PRINTER");break;
 154         case VFT2_UNKNOWN:
 155         default:
 156             TRACE("UNKNOWN(0x%x)",vffi->dwFileSubtype);break;
 157         }
 158         break;
 159     case VFT_FONT:
 160         TRACE("filetype=FONT,");
 161         switch (vffi->dwFileSubtype)
 162         {
 163         case VFT2_FONT_RASTER:TRACE("RASTER");break;
 164         case VFT2_FONT_VECTOR:TRACE("VECTOR");break;
 165         case VFT2_FONT_TRUETYPE:TRACE("TRUETYPE");break;
 166         default:TRACE("UNKNOWN(0x%x)",vffi->dwFileSubtype);break;
 167         }
 168         break;
 169     case VFT_VXD:TRACE("filetype=VXD");break;
 170     case VFT_STATIC_LIB:TRACE("filetype=STATIC_LIB");break;
 171     case VFT_UNKNOWN:
 172     default:
 173         TRACE("filetype=Unknown(0x%x)",vffi->dwFileType);break;
 174     }
 175
 176     TRACE("\n");
 177     TRACE("filedate=0x%x.0x%x\n",vffi->dwFileDateMS,vffi->dwFileDateLS);
 178 }
 179
 180 /***********************************************************************
 181  * Version Info Structure
 182  */
 183
 184 typedef struct
 185 {
 186     WORD  wLength;
 187     WORD  wValueLength;
 188     CHAR  szKey[1];
 189 #if 0   /* variable length structure */
 190     /* DWORD aligned */
 191     BYTE  Value[];
 192     /* DWORD aligned */
 193     VS_VERSION_INFO_STRUCT16 Children[];
 194 #endif
 195 } VS_VERSION_INFO_STRUCT16;
 196
 197 typedef struct
 198 {
 199     WORD  wLength;
 200     WORD  wValueLength;
 201     WORD  wType;
 202     WCHAR szKey[1];
 203 #if 0   /* variable length structure */
 204     /* DWORD aligned */
 205     BYTE  Value[];
 206     /* DWORD aligned */
 207     VS_VERSION_INFO_STRUCT32 Children[];
 208 #endif
 209 } VS_VERSION_INFO_STRUCT32;
 210
 211 #define VersionInfoIs16( ver ) \
 212     ( ((const VS_VERSION_INFO_STRUCT16 *)ver)->szKey[0] >= ' ' )
 213
 214 #define DWORD_ALIGN( base, ptr ) \
 215     ( (LPBYTE)(base) + ((((LPBYTE)(ptr) - (LPBYTE)(base)) + 3) & ~3) )
 216
 217 #define VersionInfo16_Value( ver )  \
 218     DWORD_ALIGN( (ver), (ver)->szKey + strlen((ver)->szKey) + 1 )
 219 #define VersionInfo32_Value( ver )  \
 220     DWORD_ALIGN( (ver), (ver)->szKey + strlenW((ver)->szKey) + 1 )
 221
 222 #define VersionInfo16_Children( ver )  \
 223     (const VS_VERSION_INFO_STRUCT16 *)( VersionInfo16_Value( ver ) + \
 224                            ( ( (ver)->wValueLength + 3 ) & ~3 ) )
 225 #define VersionInfo32_Children( ver )  \
 226     (const VS_VERSION_INFO_STRUCT32 *)( VersionInfo32_Value( ver ) + \
 227                            ( ( (ver)->wValueLength * \
 228                                ((ver)->wType? 2 : 1) + 3 ) & ~3 ) )
 229
 230 #define VersionInfo16_Next( ver ) \
 231     (VS_VERSION_INFO_STRUCT16 *)( (LPBYTE)ver + (((ver)->wLength + 3) & ~3) )
 232 #define VersionInfo32_Next( ver ) \
 233     (VS_VERSION_INFO_STRUCT32 *)( (LPBYTE)ver + (((ver)->wLength + 3) & ~3) )
 234
 235 /***********************************************************************
 236  *           VERSION_GetFileVersionInfo_PE             [internal]
 237  *
 238  *    NOTE: returns size of the PE VERSION resource or 0xFFFFFFFF
 239  *    in the case the file is a PE module, but VERSION_INFO not found.
 240  */
 241 static DWORD VERSION_GetFileVersionInfo_PE( LPCWSTR filename, DWORD datasize, LPVOID data )
 242 {
 243     const VS_FIXEDFILEINFO *vffi;
 244     DWORD len;
 245     BYTE *buf;
 246     HMODULE hModule;
 247     HRSRC hRsrc;
 248     HGLOBAL hMem;
 249
 250     TRACE("%s\n", debugstr_w(filename));
 251
 252     if (!GetModuleHandleExW(0, filename, &hModule))
 253         hModule = LoadLibraryExW(filename, 0, LOAD_LIBRARY_AS_DATAFILE);
 254
 255     if(!hModule)
 256     {
 257         WARN("Could not load %s\n", debugstr_w(filename));
 258
 259         return 0;
 260     }
 261     hRsrc = FindResourceW(hModule,
 262                           MAKEINTRESOURCEW(VS_VERSION_INFO),
 263                           MAKEINTRESOURCEW(VS_FILE_INFO));
 264     if(!hRsrc)
 265     {
 266         WARN("Could not find VS_VERSION_INFO in %s\n", debugstr_w(filename));
 267         FreeLibrary(hModule);
 268         return 0xFFFFFFFF;
 269     }
 270     len = SizeofResource(hModule, hRsrc);
 271     hMem = LoadResource(hModule, hRsrc);
 272     if(!hMem)
 273     {
 274         WARN("Could not load VS_VERSION_INFO from %s\n", debugstr_w(filename));
 275         FreeLibrary(hModule);
 276         return 0xFFFFFFFF;
 277     }
 278     buf = LockResource(hMem);
 279
 280     vffi = (VS_FIXEDFILEINFO *)VersionInfo32_Value( (VS_VERSION_INFO_STRUCT32 *)buf );
 281
 282     if ( vffi->dwSignature != VS_FFI_SIGNATURE )
 283     {
 284         WARN("vffi->dwSignature is 0x%08x, but not 0x%08lx!\n",
 285                    vffi->dwSignature, VS_FFI_SIGNATURE );
 286         len = 0xFFFFFFFF;
 287         goto END;
 288     }
 289
 290     if ( TRACE_ON(ver) )
 291         print_vffi_debug( vffi );
 292
 293     if(data)
 294     {
 295         if(datasize < len)
 296             len = datasize; /* truncate data */
 297         if(len)
 298             memcpy(data, buf, len);
 299         else
 300             len = 0xFFFFFFFF;
 301     }
 302 END:
 303     FreeResource(hMem);
 304     FreeLibrary(hModule);
 305
 306     return len;
 307 }
 308
 309 /***********************************************************************
 310  *           VERSION_GetFileVersionInfo_16             [internal]
 311  *
 312  *    NOTE: returns size of the 16-bit VERSION resource or 0xFFFFFFFF
 313  *    in the case the file exists, but VERSION_INFO not found.
 314  */
 315 static DWORD VERSION_GetFileVersionInfo_16( LPCSTR filename, DWORD datasize, LPVOID data )
 316 {
 317     const VS_FIXEDFILEINFO *vffi;
 318     DWORD len, offset;
 319     BYTE *buf;
 320     HMODULE16 hModule;
 321     HRSRC16 hRsrc;
 322     HGLOBAL16 hMem;
 323     char dllname[20], owner[20], *p;
 324     const char *basename;
 325     BOOL is_builtin = FALSE;
 326
 327     TRACE("%s\n", debugstr_a(filename));
 328
 329     /* strip path information */
 330
 331     basename = filename;
 332     if (basename[0] && basename[1] == ':') basename += 2;  /* strip drive specification */
 333     if ((p = strrchr( basename, '\\' ))) basename = p + 1;
 334     if ((p = strrchr( basename, '/' ))) basename = p + 1;
 335
 336     if (strlen(basename) < sizeof(dllname)-4)
 337     {
 338         int file_exists;
 339
 340         strcpy( dllname, basename );
 341         p = strrchr( dllname, '.' );
 342         if (!p) strcat( dllname, ".dll" );
 343         for (p = dllname; *p; p++) if (*p >= 'A' && *p <= 'Z') *p += 32;
 344
 345         if (wine_dll_get_owner( dllname, owner, sizeof(owner), &file_exists ) == 0)
 346             is_builtin = TRUE;
 347     }
 348
 349     /* first try without loading a 16-bit module */
 350     len = 0;
 351     if (!is_builtin)
 352     {
 353         OFSTRUCT ofs;
 354         HFILE lzfd = LZOpenFileA( (LPSTR)filename, &ofs, OF_READ );
 355
 356         if (lzfd >= 0)
 357         {
 358             if (find_version_resource( lzfd, &len, &offset ))
 359             {
 360                 if (data)
 361                 {
 362                     LZSeek( lzfd, offset, 0 /* SEEK_SET */ );
 363                     len = LZRead( lzfd, data, min( len, datasize ) );
 364                 }
 365             }
 366             LZClose( lzfd );
 367         }
 368
 369         if (len)
 370         {
 371             if (!data) return len;
 372
 373             vffi = (VS_FIXEDFILEINFO *)VersionInfo16_Value( (VS_VERSION_INFO_STRUCT16 *)data );
 374
 375             if ( vffi->dwSignature == VS_FFI_SIGNATURE )
 376             {
 377                 if ( ((VS_VERSION_INFO_STRUCT16 *)data)->wLength < len )
 378                     len = ((VS_VERSION_INFO_STRUCT16 *)data)->wLength;
 379
 380                 if ( TRACE_ON(ver) )
 381                     print_vffi_debug( vffi );
 382
 383                 return len;
 384             }
 385         }
 386     }
 387
 388     /* this might be a builtin 16-bit module */
 389     hModule = LoadLibrary16(filename);
 390     if(hModule < 32)
 391     {
 392         WARN("Could not load %s\n", debugstr_a(filename));
 393         if (hModule == ERROR_BAD_FORMAT)
 394                 return 0xFFFFFFFF;
 395         else
 396                 return 0x0;
 397     }
 398     hRsrc = FindResource16(hModule,
 399                           MAKEINTRESOURCEA(VS_VERSION_INFO),
 400                           MAKEINTRESOURCEA(VS_FILE_INFO));
 401     if(!hRsrc)
 402     {
 403         WARN("Could not find VS_VERSION_INFO in %s\n", debugstr_a(filename));
 404         FreeLibrary16(hModule);
 405         return 0xFFFFFFFF;
 406     }
 407     len = SizeofResource16(hModule, hRsrc);
 408     hMem = LoadResource16(hModule, hRsrc);
 409     if(!hMem)
 410     {
 411         WARN("Could not load VS_VERSION_INFO from %s\n", debugstr_a(filename));
 412         FreeLibrary16(hModule);
 413         return 0xFFFFFFFF;
 414     }
 415     buf = LockResource16(hMem);
 416
 417     if(!VersionInfoIs16(buf))
 418     {
 419         len = 0xFFFFFFFF;
 420         goto END;
 421     }
 422
 423     vffi = (VS_FIXEDFILEINFO *)VersionInfo16_Value( (VS_VERSION_INFO_STRUCT16 *)buf );
 424
 425     if ( vffi->dwSignature != VS_FFI_SIGNATURE )
 426     {
 427         WARN("vffi->dwSignature is 0x%08x, but not 0x%08lx!\n",
 428                    vffi->dwSignature, VS_FFI_SIGNATURE );
 429         len = 0xFFFFFFFF;
 430         goto END;
 431     }
 432
 433     if ( TRACE_ON(ver) )
 434         print_vffi_debug( vffi );
 435
 436     if(data)
 437     {
 438         if(datasize < len)
 439             len = datasize; /* truncate data */
 440         if(len)
 441             memcpy(data, buf, len);
 442         else
 443             len = 0xFFFFFFFF;
 444     }
 445 END:
 446     FreeResource16(hMem);
 447     FreeLibrary16(hModule);
 448
 449     return len;
 450 }
 451
 452 /***********************************************************************
 453  *           GetFileVersionInfoSizeW         [VERSION.@]
 454  */
 455 DWORD WINAPI GetFileVersionInfoSizeW( LPCWSTR filename, LPDWORD handle )
 456 {
 457     DWORD len;
 458
 459     TRACE("(%s,%p)\n", debugstr_w(filename), handle );
 460
 461     if (handle) *handle = 0;
 462
 463     if (!filename)
 464     {
 465         SetLastError(ERROR_INVALID_PARAMETER);
 466         return 0;
 467     }
 468     if (!*filename)
 469     {
 470         SetLastError(ERROR_BAD_PATHNAME);
 471         return 0;
 472     }
 473
 474     len = VERSION_GetFileVersionInfo_PE(filename, 0, NULL);
 475     /* 0xFFFFFFFF means: file is a PE module, but VERSION_INFO not found */
 476     if(len == 0xFFFFFFFF)
 477     {
 478         SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
 479         return 0;
 480     }
 481
 482     if (!len)
 483     {
 484         LPSTR filenameA;
 485
 486         len = WideCharToMultiByte( CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL );
 487         filenameA = HeapAlloc( GetProcessHeap(), 0, len );
 488         WideCharToMultiByte( CP_ACP, 0, filename, -1, filenameA, len, NULL, NULL );
 489
 490         len = VERSION_GetFileVersionInfo_16(filenameA, 0, NULL);
 491         HeapFree( GetProcessHeap(), 0, filenameA );
 492         /* 0xFFFFFFFF means: file exists, but VERSION_INFO not found */
 493         if (!len)
 494         {
 495             SetLastError(ERROR_FILE_NOT_FOUND);
 496             return 0;
 497         }
 498         if (len == 0xFFFFFFFF)
 499         {
 500             SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
 501             return 0;
 502         }
 503
 504         /* We have a 16bit resource.
 505          *
 506          * XP/W2K/W2K3 uses a buffer which is more than the actual needed space:
 507          *
 508          * (info->wLength - sizeof(VS_FIXEDFILEINFO)) * 4
 509          *
 510          * This extra buffer is used for ANSI to Unicode conversions in W-Calls.
 511          * info->wLength should be the same as len. Currently it isn't but that
 512          * doesn't seem to be a problem (len is bigger than info->wLength).
 513          */
 514          len = (len - sizeof(VS_FIXEDFILEINFO)) * 4;
 515     }
 516     else
 517     {
 518         /* We have a 32bit resource.
 519          *
 520          * XP/W2K/W2K3 uses a buffer which is 2 times the actual needed space + 4 bytes "FE2X"
 521          * This extra buffer is used for Unicode to ANSI conversions in A-Calls
 522          */
 523          len = (len * 2) + 4;
 524     }
 525
 526     SetLastError(0);
 527     return len;
 528 }
 529
 530 /***********************************************************************
 531  *           GetFileVersionInfoSizeA         [VERSION.@]
 532  */
 533 DWORD WINAPI GetFileVersionInfoSizeA( LPCSTR filename, LPDWORD handle )
 534 {
 535     UNICODE_STRING filenameW;
 536     DWORD retval;
 537
 538     TRACE("(%s,%p)\n", debugstr_a(filename), handle );
 539
 540     if(filename)
 541         RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
 542     else
 543         filenameW.Buffer = NULL;
 544
 545     retval = GetFileVersionInfoSizeW(filenameW.Buffer, handle);
 546
 547     RtlFreeUnicodeString(&filenameW);
 548
 549     return retval;
 550 }
 551
 552 /***********************************************************************
 553  *           GetFileVersionInfoW             [VERSION.@]
 554  */
 555 BOOL WINAPI GetFileVersionInfoW( LPCWSTR filename, DWORD handle,
 556                                     DWORD datasize, LPVOID data )
 557 {
 558     DWORD len;
 559     VS_VERSION_INFO_STRUCT32* vvis = data;
 560
 561     TRACE("(%s,%d,size=%d,data=%p)\n",
 562                 debugstr_w(filename), handle, datasize, data );
 563
 564     if (!data)
 565     {
 566         SetLastError(ERROR_INVALID_DATA);
 567         return FALSE;
 568     }
 569     len = VERSION_GetFileVersionInfo_PE(filename, datasize, data);
 570     /* 0xFFFFFFFF means: file is a PE module, but VERSION_INFO not found */
 571     if (len == 0xFFFFFFFF)
 572     {
 573         SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
 574         return FALSE;
 575     }
 576
 577     if (!len)
 578     {
 579         LPSTR filenameA;
 580
 581         len = WideCharToMultiByte( CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL );
 582         filenameA = HeapAlloc( GetProcessHeap(), 0, len );
 583         WideCharToMultiByte( CP_ACP, 0, filename, -1, filenameA, len, NULL, NULL );
 584
 585         len = VERSION_GetFileVersionInfo_16(filenameA, datasize, data);
 586         HeapFree( GetProcessHeap(), 0, filenameA );
 587         /* 0xFFFFFFFF means: file exists, but VERSION_INFO not found */
 588         if (!len || len == 0xFFFFFFFF)
 589         {
 590             SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
 591             return FALSE;
 592         }
 593         /* We have a 16bit resource. */
 594     }
 595     else
 596     {
 597         static const char signature[] = "FE2X";
 598         DWORD bufsize = vvis->wLength + strlen(signature);
 599         DWORD convbuf;
 600
 601         /* We have a 32bit resource.
 602          *
 603          * XP/W2K/W2K3 uses a buffer which is 2 times the actual needed space + 4 bytes "FE2X"
 604          * This extra buffer is used for Unicode to ANSI conversions in A-Calls
 605          */
 606
 607         /* information is truncated to datasize bytes */
 608         if (datasize >= bufsize)
 609         {
 610             convbuf = datasize - vvis->wLength;
 611             memcpy( ((char*)(data))+vvis->wLength, signature, convbuf > 4 ? 4 : convbuf );
 612         }
 613     }
 614
 615     SetLastError(0);
 616     return TRUE;
 617 }
 618
 619 /***********************************************************************
 620  *           GetFileVersionInfoA             [VERSION.@]
 621  */
 622 BOOL WINAPI GetFileVersionInfoA( LPCSTR filename, DWORD handle,
 623                                     DWORD datasize, LPVOID data )
 624 {
 625     UNICODE_STRING filenameW;
 626     BOOL retval;
 627
 628     TRACE("(%s,%d,size=%d,data=%p)\n",
 629                 debugstr_a(filename), handle, datasize, data );
 630
 631     if(filename)
 632         RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
 633     else
 634         filenameW.Buffer = NULL;
 635
 636     retval = GetFileVersionInfoW(filenameW.Buffer, handle, datasize, data);
 637
 638     RtlFreeUnicodeString(&filenameW);
 639
 640     return retval;
 641 }
 642
 643 /***********************************************************************
 644  *           VersionInfo16_FindChild             [internal]
 645  */
 646 static const VS_VERSION_INFO_STRUCT16 *VersionInfo16_FindChild( const VS_VERSION_INFO_STRUCT16 *info,
 647                                             LPCSTR szKey, UINT cbKey )
 648 {
 649     const VS_VERSION_INFO_STRUCT16 *child = VersionInfo16_Children( info );
 650
 651     while ((char *)child < (char *)info + info->wLength )
 652     {
 653         if (!strncasecmp( child->szKey, szKey, cbKey ) && !child->szKey[cbKey])
 654             return child;
 655
 656         if (!(child->wLength)) return NULL;
 657         child = VersionInfo16_Next( child );
 658     }
 659
 660     return NULL;
 661 }
 662
 663 /***********************************************************************
 664  *           VersionInfo32_FindChild             [internal]
 665  */
 666 static const VS_VERSION_INFO_STRUCT32 *VersionInfo32_FindChild( const VS_VERSION_INFO_STRUCT32 *info,
 667                                             LPCWSTR szKey, UINT cbKey )
 668 {
 669     const VS_VERSION_INFO_STRUCT32 *child = VersionInfo32_Children( info );
 670
 671     while ((char *)child < (char *)info + info->wLength )
 672     {
 673         if (!strncmpiW( child->szKey, szKey, cbKey ) && !child->szKey[cbKey])
 674             return child;
 675
 676         if (!(child->wLength)) return NULL;
 677         child = VersionInfo32_Next( child );
 678     }
 679
 680     return NULL;
 681 }
 682
 683 /***********************************************************************
 684  *           VersionInfo16_QueryValue              [internal]
 685  *
 686  *    Gets a value from a 16-bit NE resource
 687  */
 688 static BOOL VersionInfo16_QueryValue( const VS_VERSION_INFO_STRUCT16 *info, LPCSTR lpSubBlock,
 689                                LPVOID *lplpBuffer, UINT *puLen )
 690 {
 691     while ( *lpSubBlock )
 692     {
 693         /* Find next path component */
 694         LPCSTR lpNextSlash;
 695         for ( lpNextSlash = lpSubBlock; *lpNextSlash; lpNextSlash++ )
 696             if ( *lpNextSlash == '\\' )
 697                 break;
 698
 699         /* Skip empty components */
 700         if ( lpNextSlash == lpSubBlock )
 701         {
 702             lpSubBlock++;
 703             continue;
 704         }
 705
 706         /* We have a non-empty component: search info for key */
 707         info = VersionInfo16_FindChild( info, lpSubBlock, lpNextSlash-lpSubBlock );
 708         if ( !info )
 709         {
 710             if (puLen) *puLen = 0 ;
 711             SetLastError( ERROR_RESOURCE_TYPE_NOT_FOUND );
 712             return FALSE;
 713         }
 714
 715         /* Skip path component */
 716         lpSubBlock = lpNextSlash;
 717     }
 718
 719     /* Return value */
 720     *lplpBuffer = VersionInfo16_Value( info );
 721     if (puLen)
 722         *puLen = info->wValueLength;
 723
 724     return TRUE;
 725 }
 726
 727 /***********************************************************************
 728  *           VersionInfo32_QueryValue              [internal]
 729  *
 730  *    Gets a value from a 32-bit PE resource
 731  */
 732 static BOOL VersionInfo32_QueryValue( const VS_VERSION_INFO_STRUCT32 *info, LPCWSTR lpSubBlock,
 733                                LPVOID *lplpBuffer, UINT *puLen )
 734 {
 735     TRACE("lpSubBlock : (%s)\n", debugstr_w(lpSubBlock));
 736
 737     while ( *lpSubBlock )
 738     {
 739         /* Find next path component */
 740         LPCWSTR lpNextSlash;
 741         for ( lpNextSlash = lpSubBlock; *lpNextSlash; lpNextSlash++ )
 742             if ( *lpNextSlash == '\\' )
 743                 break;
 744
 745         /* Skip empty components */
 746         if ( lpNextSlash == lpSubBlock )
 747         {
 748             lpSubBlock++;
 749             continue;
 750         }
 751
 752         /* We have a non-empty component: search info for key */
 753         info = VersionInfo32_FindChild( info, lpSubBlock, lpNextSlash-lpSubBlock );
 754         if ( !info )
 755         {
 756             if (puLen) *puLen = 0 ;
 757             SetLastError( ERROR_RESOURCE_TYPE_NOT_FOUND );
 758             return FALSE;
 759         }
 760
 761         /* Skip path component */
 762         lpSubBlock = lpNextSlash;
 763     }
 764
 765     /* Return value */
 766     *lplpBuffer = VersionInfo32_Value( info );
 767     if (puLen)
 768         *puLen = info->wValueLength;
 769
 770     return TRUE;
 771 }
 772
 773 /***********************************************************************
 774  *           VerQueryValueA              [VERSION.@]
 775  */
 776 BOOL WINAPI VerQueryValueA( LPCVOID pBlock, LPCSTR lpSubBlock,
 777                                LPVOID *lplpBuffer, PUINT puLen )
 778 {
 779     static const char rootA[] = "\\";
 780     static const char varfileinfoA[] = "\\VarFileInfo\\Translation";
 781     const VS_VERSION_INFO_STRUCT16 *info = pBlock;
 782
 783     TRACE("(%p,%s,%p,%p)\n",
 784                 pBlock, debugstr_a(lpSubBlock), lplpBuffer, puLen );
 785
 786      if (!pBlock)
 787         return FALSE;
 788
 789     if (lpSubBlock == NULL || lpSubBlock[0] == '\0')
 790         lpSubBlock = rootA;
 791
 792     if ( !VersionInfoIs16( info ) )
 793     {
 794         BOOL ret;
 795         INT len;
 796         LPWSTR lpSubBlockW;
 797
 798         len  = MultiByteToWideChar(CP_ACP, 0, lpSubBlock, -1, NULL, 0);
 799         lpSubBlockW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 800
 801         if (!lpSubBlockW)
 802             return FALSE;
 803
 804         MultiByteToWideChar(CP_ACP, 0, lpSubBlock, -1, lpSubBlockW, len);
 805
 806         ret = VersionInfo32_QueryValue(pBlock, lpSubBlockW, lplpBuffer, puLen);
 807
 808         HeapFree(GetProcessHeap(), 0, lpSubBlockW);
 809
 810         if (ret && strcasecmp( lpSubBlock, rootA ) && strcasecmp( lpSubBlock, varfileinfoA ))
 811         {
 812             /* Set lpBuffer so it points to the 'empty' area where we store
 813              * the converted strings
 814              */
 815             LPSTR lpBufferA = (LPSTR)pBlock + info->wLength + 4;
 816             DWORD pos = (LPCSTR)*lplpBuffer - (LPCSTR)pBlock;
 817
 818             len = WideCharToMultiByte(CP_ACP, 0, *lplpBuffer, -1,
 819                                       lpBufferA + pos, info->wLength - pos, NULL, NULL);
 820             *lplpBuffer = lpBufferA + pos;
 821             *puLen = len;
 822         }
 823         return ret;
 824     }
 825
 826     return VersionInfo16_QueryValue(info, lpSubBlock, lplpBuffer, puLen);
 827 }
 828
 829 /***********************************************************************
 830  *           VerQueryValueW              [VERSION.@]
 831  */
 832 BOOL WINAPI VerQueryValueW( LPCVOID pBlock, LPCWSTR lpSubBlock,
 833                                LPVOID *lplpBuffer, PUINT puLen )
 834 {
 835     static const WCHAR nullW[] = { 0 };
 836     static const WCHAR rootW[] = { '\\', 0 };
 837     static const WCHAR varfileinfoW[] = { '\\','V','a','r','F','i','l','e','I','n','f','o',
 838                                           '\\','T','r','a','n','s','l','a','t','i','o','n', 0 };
 839
 840     const VS_VERSION_INFO_STRUCT32 *info = pBlock;
 841
 842     TRACE("(%p,%s,%p,%p)\n",
 843                 pBlock, debugstr_w(lpSubBlock), lplpBuffer, puLen );
 844
 845     if (!pBlock)
 846         return FALSE;
 847
 848     if (lpSubBlock == NULL || lpSubBlock[0] == nullW[0])
 849         lpSubBlock = rootW;
 850
 851     if ( VersionInfoIs16( info ) )
 852     {
 853         BOOL ret;
 854         int len;
 855         LPSTR lpSubBlockA;
 856
 857         len = WideCharToMultiByte(CP_ACP, 0, lpSubBlock, -1, NULL, 0, NULL, NULL);
 858         lpSubBlockA = HeapAlloc(GetProcessHeap(), 0, len * sizeof(char));
 859
 860         if (!lpSubBlockA)
 861             return FALSE;
 862
 863         WideCharToMultiByte(CP_ACP, 0, lpSubBlock, -1, lpSubBlockA, len, NULL, NULL);
 864
 865         ret = VersionInfo16_QueryValue(pBlock, lpSubBlockA, lplpBuffer, puLen);
 866
 867         HeapFree(GetProcessHeap(), 0, lpSubBlockA);
 868
 869         if (ret && strcmpiW( lpSubBlock, rootW ) && strcmpiW( lpSubBlock, varfileinfoW ))
 870         {
 871             /* Set lpBuffer so it points to the 'empty' area where we store
 872              * the converted strings
 873              */
 874             LPWSTR lpBufferW = (LPWSTR)((LPSTR)pBlock + info->wLength);
 875             DWORD pos = (LPCSTR)*lplpBuffer - (LPCSTR)pBlock;
 876             DWORD max = (info->wLength - sizeof(VS_FIXEDFILEINFO)) * 4 - info->wLength;
 877
 878             len = MultiByteToWideChar(CP_ACP, 0, *lplpBuffer, -1,
 879                                       lpBufferW + pos, max/sizeof(WCHAR) - pos );
 880             *lplpBuffer = lpBufferW + pos;
 881             *puLen = len;
 882         }
 883         return ret;
 884     }
 885
 886     return VersionInfo32_QueryValue(info, lpSubBlock, lplpBuffer, puLen);
 887 }