git.oblomov.eu Git - wine/blob - 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  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include <stdlib.h>
  24 #include <string.h>
  25
  26 #include "winreg.h"
  27 #include "winver.h"
  28 #include "wine/winuser16.h"
  29 #include "wine/unicode.h"
  30 #include "winerror.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(ver);
  34
  35
  36 /******************************************************************************
  37  *
  38  *   This function will print via dprintf[_]ver to stddeb debug info regarding
  39  *   the file info structure vffi.
  40  *      15-Feb-1998 Dimitrie Paun (dimi@cs.toronto.edu)
  41  *      Added this function to clean up the code.
  42  *
  43  *****************************************************************************/
  44 static void print_vffi_debug(VS_FIXEDFILEINFO *vffi)
  45 {
  46         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",
  47                     HIWORD(vffi->dwStrucVersion),LOWORD(vffi->dwStrucVersion),
  48                     HIWORD(vffi->dwFileVersionMS),LOWORD(vffi->dwFileVersionMS),
  49                     HIWORD(vffi->dwFileVersionLS),LOWORD(vffi->dwFileVersionLS),
  50                     HIWORD(vffi->dwProductVersionMS),LOWORD(vffi->dwProductVersionMS),
  51                     HIWORD(vffi->dwProductVersionLS),LOWORD(vffi->dwProductVersionLS),
  52                     vffi->dwFileFlagsMask,
  53                     (vffi->dwFileFlags & VS_FF_DEBUG) ? "DEBUG," : "",
  54                     (vffi->dwFileFlags & VS_FF_PRERELEASE) ? "PRERELEASE," : "",
  55                     (vffi->dwFileFlags & VS_FF_PATCHED) ? "PATCHED," : "",
  56                     (vffi->dwFileFlags & VS_FF_PRIVATEBUILD) ? "PRIVATEBUILD," : "",
  57                     (vffi->dwFileFlags & VS_FF_INFOINFERRED) ? "INFOINFERRED," : "",
  58                     (vffi->dwFileFlags & VS_FF_SPECIALBUILD) ? "SPECIALBUILD," : ""
  59                     );
  60
  61         TRACE("(");
  62         DPRINTF(" OS=0x%x.0x%x ",
  63                 HIWORD(vffi->dwFileOS),
  64                 LOWORD(vffi->dwFileOS)
  65         );
  66         switch (vffi->dwFileOS&0xFFFF0000) {
  67         case VOS_DOS:DPRINTF("DOS,");break;
  68         case VOS_OS216:DPRINTF("OS/2-16,");break;
  69         case VOS_OS232:DPRINTF("OS/2-32,");break;
  70         case VOS_NT:DPRINTF("NT,");break;
  71         case VOS_UNKNOWN:
  72         default:
  73                 DPRINTF("UNKNOWN(0x%lx),",vffi->dwFileOS&0xFFFF0000);break;
  74         }
  75         switch (LOWORD(vffi->dwFileOS)) {
  76         case VOS__BASE:DPRINTF("BASE");break;
  77         case VOS__WINDOWS16:DPRINTF("WIN16");break;
  78         case VOS__WINDOWS32:DPRINTF("WIN32");break;
  79         case VOS__PM16:DPRINTF("PM16");break;
  80         case VOS__PM32:DPRINTF("PM32");break;
  81         default:DPRINTF("UNKNOWN(0x%x)",LOWORD(vffi->dwFileOS));break;
  82         }
  83         DPRINTF(")\n");
  84
  85         switch (vffi->dwFileType) {
  86         default:
  87         case VFT_UNKNOWN:
  88                 TRACE("filetype=Unknown(0x%lx)",vffi->dwFileType);
  89                 break;
  90         case VFT_APP:TRACE("filetype=APP,");break;
  91         case VFT_DLL:TRACE("filetype=DLL,");break;
  92         case VFT_DRV:
  93                 TRACE("filetype=DRV,");
  94                 switch(vffi->dwFileSubtype) {
  95                 default:
  96                 case VFT2_UNKNOWN:
  97                         DPRINTF("UNKNOWN(0x%lx)",vffi->dwFileSubtype);
  98                         break;
  99                 case VFT2_DRV_PRINTER:
 100                         DPRINTF("PRINTER");
 101                         break;
 102                 case VFT2_DRV_KEYBOARD:
 103                         DPRINTF("KEYBOARD");
 104                         break;
 105                 case VFT2_DRV_LANGUAGE:
 106                         DPRINTF("LANGUAGE");
 107                         break;
 108                 case VFT2_DRV_DISPLAY:
 109                         DPRINTF("DISPLAY");
 110                         break;
 111                 case VFT2_DRV_MOUSE:
 112                         DPRINTF("MOUSE");
 113                         break;
 114                 case VFT2_DRV_NETWORK:
 115                         DPRINTF("NETWORK");
 116                         break;
 117                 case VFT2_DRV_SYSTEM:
 118                         DPRINTF("SYSTEM");
 119                         break;
 120                 case VFT2_DRV_INSTALLABLE:
 121                         DPRINTF("INSTALLABLE");
 122                         break;
 123                 case VFT2_DRV_SOUND:
 124                         DPRINTF("SOUND");
 125                         break;
 126                 case VFT2_DRV_COMM:
 127                         DPRINTF("COMM");
 128                         break;
 129                 case VFT2_DRV_INPUTMETHOD:
 130                         DPRINTF("INPUTMETHOD");
 131                         break;
 132                 }
 133                 break;
 134         case VFT_FONT:
 135                 TRACE("filetype=FONT.");
 136                 switch (vffi->dwFileSubtype) {
 137                 default:
 138                         DPRINTF("UNKNOWN(0x%lx)",vffi->dwFileSubtype);
 139                         break;
 140                 case VFT2_FONT_RASTER:DPRINTF("RASTER");break;
 141                 case VFT2_FONT_VECTOR:DPRINTF("VECTOR");break;
 142                 case VFT2_FONT_TRUETYPE:DPRINTF("TRUETYPE");break;
 143                 }
 144                 break;
 145         case VFT_VXD:TRACE("filetype=VXD");break;
 146         case VFT_STATIC_LIB:TRACE("filetype=STATIC_LIB");break;
 147         }
 148         DPRINTF("\n");
 149         TRACE("  filedata=0x%lx.0x%lx\n",
 150                     vffi->dwFileDateMS,vffi->dwFileDateLS);
 151 }
 152
 153
 154 /***********************************************************************
 155  * Version Info Structure
 156  */
 157
 158 typedef struct
 159 {
 160     WORD  wLength;
 161     WORD  wValueLength;
 162     CHAR  szKey[1];
 163 #if 0   /* variable length structure */
 164     /* DWORD aligned */
 165     BYTE  Value[];
 166     /* DWORD aligned */
 167     VS_VERSION_INFO_STRUCT16 Children[];
 168 #endif
 169 } VS_VERSION_INFO_STRUCT16;
 170
 171 typedef struct
 172 {
 173     WORD  wLength;
 174     WORD  wValueLength;
 175     WORD  bText;
 176     WCHAR szKey[1];
 177 #if 0   /* variable length structure */
 178     /* DWORD aligned */
 179     BYTE  Value[];
 180     /* DWORD aligned */
 181     VS_VERSION_INFO_STRUCT32 Children[];
 182 #endif
 183 } VS_VERSION_INFO_STRUCT32;
 184
 185 #define VersionInfoIs16( ver ) \
 186     ( ((VS_VERSION_INFO_STRUCT16 *)ver)->szKey[0] >= ' ' )
 187
 188 #define DWORD_ALIGN( base, ptr ) \
 189     ( (LPBYTE)(base) + ((((LPBYTE)(ptr) - (LPBYTE)(base)) + 3) & ~3) )
 190
 191 #define VersionInfo16_Value( ver )  \
 192     DWORD_ALIGN( (ver), (ver)->szKey + strlen((ver)->szKey) + 1 )
 193 #define VersionInfo32_Value( ver )  \
 194     DWORD_ALIGN( (ver), (ver)->szKey + strlenW((ver)->szKey) + 1 )
 195
 196 #define VersionInfo16_Children( ver )  \
 197     (VS_VERSION_INFO_STRUCT16 *)( VersionInfo16_Value( ver ) + \
 198                            ( ( (ver)->wValueLength + 3 ) & ~3 ) )
 199 #define VersionInfo32_Children( ver )  \
 200     (VS_VERSION_INFO_STRUCT32 *)( VersionInfo32_Value( ver ) + \
 201                            ( ( (ver)->wValueLength * \
 202                                ((ver)->bText? 2 : 1) + 3 ) & ~3 ) )
 203
 204 #define VersionInfo16_Next( ver ) \
 205     (VS_VERSION_INFO_STRUCT16 *)( (LPBYTE)ver + (((ver)->wLength + 3) & ~3) )
 206 #define VersionInfo32_Next( ver ) \
 207     (VS_VERSION_INFO_STRUCT32 *)( (LPBYTE)ver + (((ver)->wLength + 3) & ~3) )
 208
 209 /***********************************************************************
 210  *           ConvertVersionInfo32To16        [internal]
 211  */
 212 void ConvertVersionInfo32To16( VS_VERSION_INFO_STRUCT32 *info32,
 213                                VS_VERSION_INFO_STRUCT16 *info16 )
 214 {
 215     /* Copy data onto local stack to prevent overwrites */
 216     WORD wLength = info32->wLength;
 217     WORD wValueLength = info32->wValueLength;
 218     WORD bText = info32->bText;
 219     LPBYTE lpValue = VersionInfo32_Value( info32 );
 220     VS_VERSION_INFO_STRUCT32 *child32 = VersionInfo32_Children( info32 );
 221     VS_VERSION_INFO_STRUCT16 *child16;
 222
 223     TRACE("Converting %p to %p\n", info32, info16 );
 224     TRACE("wLength %d, wValueLength %d, bText %d, value %p, child %p\n",
 225                 wLength, wValueLength, bText, lpValue, child32 );
 226
 227     /* Convert key */
 228     WideCharToMultiByte( CP_ACP, 0, info32->szKey, -1, info16->szKey, 0x7fffffff, NULL, NULL );
 229
 230     TRACE("Copied key from %p to %p: %s\n", info32->szKey, info16->szKey,
 231                 debugstr_a(info16->szKey) );
 232
 233     /* Convert value */
 234     if ( wValueLength == 0 )
 235     {
 236         info16->wValueLength = 0;
 237         TRACE("No value present\n" );
 238     }
 239     else if ( bText )
 240     {
 241         info16->wValueLength = WideCharToMultiByte( CP_ACP, 0, (LPCWSTR)lpValue, -1, NULL, 0, NULL, NULL );
 242         WideCharToMultiByte( CP_ACP, 0, (LPCWSTR)lpValue, -1,
 243                              VersionInfo16_Value( info16 ), info16->wValueLength, NULL, NULL );
 244
 245         TRACE("Copied value from %p to %p: %s\n", lpValue,
 246                     VersionInfo16_Value( info16 ),
 247                     debugstr_a(VersionInfo16_Value( info16 )) );
 248     }
 249     else
 250     {
 251         info16->wValueLength = wValueLength;
 252         memmove( VersionInfo16_Value( info16 ), lpValue, wValueLength );
 253
 254         TRACE("Copied value from %p to %p: %d bytes\n", lpValue,
 255                      VersionInfo16_Value( info16 ), wValueLength );
 256     }
 257
 258     /* Convert children */
 259     child16 = VersionInfo16_Children( info16 );
 260     while ( (DWORD)child32 < (DWORD)info32 + wLength && child32->wLength != 0 )
 261     {
 262         VS_VERSION_INFO_STRUCT32 *nextChild = VersionInfo32_Next( child32 );
 263
 264         ConvertVersionInfo32To16( child32, child16 );
 265
 266         child16 = VersionInfo16_Next( child16 );
 267         child32 = nextChild;
 268     }
 269
 270     /* Fixup length */
 271     info16->wLength = (DWORD)child16 - (DWORD)info16;
 272
 273     TRACE("Finished, length is %d (%p - %p)\n",
 274                 info16->wLength, info16, child16 );
 275 }
 276
 277 /***********************************************************************
 278  *           VERSION_GetFileVersionInfo_PE             [internal]
 279  *
 280  *    NOTE: returns size of the PE VERSION resource or 0xFFFFFFFF
 281  *    in the case if file exists, but VERSION_INFO not found.
 282  *    FIXME: handle is not used.
 283  */
 284 static DWORD VERSION_GetFileVersionInfo_PE( LPCSTR filename, LPDWORD handle,
 285                                     DWORD datasize, LPVOID data )
 286 {
 287     VS_FIXEDFILEINFO *vffi;
 288     DWORD len;
 289     BYTE *buf;
 290     HMODULE hModule;
 291     HRSRC hRsrc;
 292     HGLOBAL hMem;
 293
 294     TRACE("(%s,%p)\n", debugstr_a(filename), handle );
 295
 296     hModule = GetModuleHandleA(filename);
 297     if(!hModule)
 298         hModule = LoadLibraryExA(filename, 0, LOAD_LIBRARY_AS_DATAFILE);
 299     else
 300         hModule = LoadLibraryExA(filename, 0, 0);
 301     if(!hModule)
 302     {
 303         WARN("Could not load %s\n", debugstr_a(filename));
 304         return 0;
 305     }
 306     hRsrc = FindResourceW(hModule,
 307                           MAKEINTRESOURCEW(VS_VERSION_INFO),
 308                           MAKEINTRESOURCEW(VS_FILE_INFO));
 309     if(!hRsrc)
 310     {
 311         WARN("Could not find VS_VERSION_INFO in %s\n", debugstr_a(filename));
 312         FreeLibrary(hModule);
 313         return 0xFFFFFFFF;
 314     }
 315     len = SizeofResource(hModule, hRsrc);
 316     hMem = LoadResource(hModule, hRsrc);
 317     if(!hMem)
 318     {
 319         WARN("Could not load VS_VERSION_INFO from %s\n", debugstr_a(filename));
 320         FreeLibrary(hModule);
 321         return 0xFFFFFFFF;
 322     }
 323     buf = LockResource(hMem);
 324
 325     vffi = (VS_FIXEDFILEINFO *)VersionInfo32_Value( (VS_VERSION_INFO_STRUCT32 *)buf );
 326
 327     if ( vffi->dwSignature != VS_FFI_SIGNATURE )
 328     {
 329         WARN("vffi->dwSignature is 0x%08lx, but not 0x%08lx!\n",
 330                    vffi->dwSignature, VS_FFI_SIGNATURE );
 331         len = 0xFFFFFFFF;
 332         goto END;
 333     }
 334
 335     if ( TRACE_ON(ver) )
 336         print_vffi_debug( vffi );
 337
 338     if(data)
 339     {
 340         if(datasize < len)
 341             len = datasize; /* truncate data */
 342         if(len)
 343             memcpy(data, buf, len);
 344         else
 345             len = 0xFFFFFFFF;
 346     }
 347 END:
 348     FreeResource(hMem);
 349     FreeLibrary(hModule);
 350
 351     return len;
 352 }
 353
 354 /***********************************************************************
 355  *           VERSION_GetFileVersionInfo_16             [internal]
 356  *
 357  *    NOTE: returns size of the 16-bit VERSION resource or 0xFFFFFFFF
 358  *    in the case if file exists, but VERSION_INFO not found.
 359  *    FIXME: handle is not used.
 360  */
 361 static DWORD VERSION_GetFileVersionInfo_16( LPCSTR filename, LPDWORD handle,
 362                                     DWORD datasize, LPVOID data )
 363 {
 364     VS_FIXEDFILEINFO *vffi;
 365     DWORD len;
 366     BYTE *buf;
 367     HMODULE16 hModule;
 368     HRSRC16 hRsrc;
 369     HGLOBAL16 hMem;
 370
 371     TRACE("(%s,%p)\n", debugstr_a(filename), handle );
 372
 373     hModule = LoadLibrary16(filename);
 374     if(hModule < 32)
 375     {
 376         WARN("Could not load %s\n", debugstr_a(filename));
 377         return 0;
 378     }
 379     hRsrc = FindResource16(hModule,
 380                           MAKEINTRESOURCEA(VS_VERSION_INFO),
 381                           MAKEINTRESOURCEA(VS_FILE_INFO));
 382     if(!hRsrc)
 383     {
 384         WARN("Could not find VS_VERSION_INFO in %s\n", debugstr_a(filename));
 385         FreeLibrary16(hModule);
 386         return 0xFFFFFFFF;
 387     }
 388     len = SizeofResource16(hModule, hRsrc);
 389     hMem = LoadResource16(hModule, hRsrc);
 390     if(!hMem)
 391     {
 392         WARN("Could not load VS_VERSION_INFO from %s\n", debugstr_a(filename));
 393         FreeLibrary16(hModule);
 394         return 0xFFFFFFFF;
 395     }
 396     buf = LockResource16(hMem);
 397
 398     if(!VersionInfoIs16(buf))
 399         goto END;
 400
 401     vffi = (VS_FIXEDFILEINFO *)VersionInfo16_Value( (VS_VERSION_INFO_STRUCT16 *)buf );
 402
 403     if ( vffi->dwSignature != VS_FFI_SIGNATURE )
 404     {
 405         WARN("vffi->dwSignature is 0x%08lx, but not 0x%08lx!\n",
 406                    vffi->dwSignature, VS_FFI_SIGNATURE );
 407         len = 0xFFFFFFFF;
 408         goto END;
 409     }
 410
 411     if ( TRACE_ON(ver) )
 412         print_vffi_debug( vffi );
 413
 414     if(data)
 415     {
 416         if(datasize < len)
 417             len = datasize; /* truncate data */
 418         if(len)
 419             memcpy(data, buf, len);
 420         else
 421             len = 0xFFFFFFFF;
 422     }
 423 END:
 424     FreeResource16(hMem);
 425     FreeLibrary16(hModule);
 426
 427     return len;
 428 }
 429
 430 /***********************************************************************
 431  *           GetFileVersionInfoSizeA         [VERSION.@]
 432  */
 433 DWORD WINAPI GetFileVersionInfoSizeA( LPCSTR filename, LPDWORD handle )
 434 {
 435     VS_FIXEDFILEINFO *vffi;
 436     DWORD len, ret, offset;
 437     BYTE buf[144];
 438
 439     TRACE("(%s,%p)\n", debugstr_a(filename), handle );
 440
 441     len = VERSION_GetFileVersionInfo_PE(filename, handle, 0, NULL);
 442     /* 0xFFFFFFFF means: file exists, but VERSION_INFO not found */
 443     if(len == 0xFFFFFFFF)
 444     {
 445         SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
 446         return 0;
 447     }
 448     if(len) return len;
 449     len = VERSION_GetFileVersionInfo_16(filename, handle, 0, NULL);
 450     /* 0xFFFFFFFF means: file exists, but VERSION_INFO not found */
 451     if(len == 0xFFFFFFFF)
 452     {
 453         SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
 454         return 0;
 455     }
 456     if(len) return len;
 457
 458     len = GetFileResourceSize16( filename,
 459                                  MAKEINTRESOURCEA(VS_FILE_INFO),
 460                                  MAKEINTRESOURCEA(VS_VERSION_INFO),
 461                                  &offset );
 462     if (!len) return 0;
 463
 464     ret = GetFileResource16( filename,
 465                              MAKEINTRESOURCEA(VS_FILE_INFO),
 466                              MAKEINTRESOURCEA(VS_VERSION_INFO),
 467                              offset, sizeof( buf ), buf );
 468     if (!ret) return 0;
 469
 470     if ( handle ) *handle = offset;
 471
 472     if ( VersionInfoIs16( buf ) )
 473         vffi = (VS_FIXEDFILEINFO *)VersionInfo16_Value( (VS_VERSION_INFO_STRUCT16 *)buf );
 474     else
 475         vffi = (VS_FIXEDFILEINFO *)VersionInfo32_Value( (VS_VERSION_INFO_STRUCT32 *)buf );
 476
 477     if ( vffi->dwSignature != VS_FFI_SIGNATURE )
 478     {
 479         WARN("vffi->dwSignature is 0x%08lx, but not 0x%08lx!\n",
 480                    vffi->dwSignature, VS_FFI_SIGNATURE );
 481         return 0;
 482     }
 483
 484     if ( ((VS_VERSION_INFO_STRUCT16 *)buf)->wLength < len )
 485         len = ((VS_VERSION_INFO_STRUCT16 *)buf)->wLength;
 486
 487     if ( TRACE_ON(ver) )
 488         print_vffi_debug( vffi );
 489
 490     return len;
 491 }
 492
 493 /***********************************************************************
 494  *           GetFileVersionInfoSizeW         [VERSION.@]
 495  */
 496 DWORD WINAPI GetFileVersionInfoSizeW( LPCWSTR filename, LPDWORD handle )
 497 {
 498     DWORD ret, len = WideCharToMultiByte( CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL );
 499     LPSTR fn = HeapAlloc( GetProcessHeap(), 0, len );
 500     WideCharToMultiByte( CP_ACP, 0, filename, -1, fn, len, NULL, NULL );
 501     ret = GetFileVersionInfoSizeA( fn, handle );
 502     HeapFree( GetProcessHeap(), 0, fn );
 503     return ret;
 504 }
 505
 506 /***********************************************************************
 507  *           GetFileVersionInfoA             [VERSION.@]
 508  */
 509 BOOL WINAPI GetFileVersionInfoA( LPCSTR filename, DWORD handle,
 510                                     DWORD datasize, LPVOID data )
 511 {
 512     DWORD len;
 513
 514     TRACE("(%s,%ld,size=%ld,data=%p)\n",
 515                 debugstr_a(filename), handle, datasize, data );
 516
 517     len = VERSION_GetFileVersionInfo_PE(filename, &handle, datasize, data);
 518     /* 0xFFFFFFFF means: file exists, but VERSION_INFO not found */
 519     if(len == 0xFFFFFFFF) return FALSE;
 520     if(len)
 521         goto DO_CONVERT;
 522     len = VERSION_GetFileVersionInfo_16(filename, &handle, datasize, data);
 523     /* 0xFFFFFFFF means: file exists, but VERSION_INFO not found */
 524     if(len == 0xFFFFFFFF) return FALSE;
 525     if(len)
 526         goto DO_CONVERT;
 527
 528     if ( !GetFileResource16( filename, MAKEINTRESOURCEA(VS_FILE_INFO),
 529                                        MAKEINTRESOURCEA(VS_VERSION_INFO),
 530                                        handle, datasize, data ) )
 531         return FALSE;
 532 DO_CONVERT:
 533     if (    datasize >= sizeof(VS_VERSION_INFO_STRUCT16)
 534          && datasize >= ((VS_VERSION_INFO_STRUCT16 *)data)->wLength
 535          && !VersionInfoIs16( data ) )
 536     {
 537         /* convert resource from PE format to NE format */
 538         ConvertVersionInfo32To16( (VS_VERSION_INFO_STRUCT32 *)data,
 539                                   (VS_VERSION_INFO_STRUCT16 *)data );
 540     }
 541
 542     return TRUE;
 543 }
 544
 545 /***********************************************************************
 546  *           GetFileVersionInfoW             [VERSION.@]
 547  */
 548 BOOL WINAPI GetFileVersionInfoW( LPCWSTR filename, DWORD handle,
 549                                     DWORD datasize, LPVOID data )
 550 {
 551     DWORD len = WideCharToMultiByte( CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL );
 552     LPSTR fn = HeapAlloc( GetProcessHeap(), 0, len );
 553     DWORD retv = TRUE;
 554
 555     WideCharToMultiByte( CP_ACP, 0, filename, -1, fn, len, NULL, NULL );
 556
 557     TRACE("(%s,%ld,size=%ld,data=%p)\n",
 558                 debugstr_w(filename), handle, datasize, data );
 559
 560     if(VERSION_GetFileVersionInfo_PE(fn, &handle, datasize, data))
 561         goto END;
 562     if(VERSION_GetFileVersionInfo_16(fn, &handle, datasize, data))
 563         goto END;
 564
 565     if ( !GetFileResource16( fn, MAKEINTRESOURCEA(VS_FILE_INFO),
 566                                  MAKEINTRESOURCEA(VS_VERSION_INFO),
 567                                  handle, datasize, data ) )
 568         retv = FALSE;
 569
 570     else if (    datasize >= sizeof(VS_VERSION_INFO_STRUCT16)
 571               && datasize >= ((VS_VERSION_INFO_STRUCT16 *)data)->wLength
 572               && VersionInfoIs16( data ) )
 573     {
 574         ERR("Cannot access NE resource in %s\n", debugstr_a(fn) );
 575         retv =  FALSE;
 576     }
 577 END:
 578     HeapFree( GetProcessHeap(), 0, fn );
 579     return retv;
 580 }
 581
 582
 583 /***********************************************************************
 584  *           VersionInfo16_FindChild             [internal]
 585  */
 586 static VS_VERSION_INFO_STRUCT16 *VersionInfo16_FindChild( VS_VERSION_INFO_STRUCT16 *info,
 587                                             LPCSTR szKey, UINT cbKey )
 588 {
 589     VS_VERSION_INFO_STRUCT16 *child = VersionInfo16_Children( info );
 590
 591     while ( (DWORD)child < (DWORD)info + info->wLength )
 592     {
 593         if ( !strncasecmp( child->szKey, szKey, cbKey ) )
 594             return child;
 595
 596         if (!(child->wLength)) return NULL;
 597         child = VersionInfo16_Next( child );
 598     }
 599
 600     return NULL;
 601 }
 602
 603 /***********************************************************************
 604  *           VersionInfo32_FindChild             [internal]
 605  */
 606 static VS_VERSION_INFO_STRUCT32 *VersionInfo32_FindChild( VS_VERSION_INFO_STRUCT32 *info,
 607                                             LPCWSTR szKey, UINT cbKey )
 608 {
 609     VS_VERSION_INFO_STRUCT32 *child = VersionInfo32_Children( info );
 610
 611     while ( (DWORD)child < (DWORD)info + info->wLength )
 612     {
 613         if ( !strncmpiW( child->szKey, szKey, cbKey ) )
 614             return child;
 615
 616         child = VersionInfo32_Next( child );
 617     }
 618
 619     return NULL;
 620 }
 621
 622 /***********************************************************************
 623  *           VerQueryValueA              [VERSION.@]
 624  */
 625 DWORD WINAPI VerQueryValueA( LPVOID pBlock, LPCSTR lpSubBlock,
 626                                LPVOID *lplpBuffer, UINT *puLen )
 627 {
 628     VS_VERSION_INFO_STRUCT16 *info = (VS_VERSION_INFO_STRUCT16 *)pBlock;
 629     if ( !VersionInfoIs16( info ) )
 630     {
 631         INT len;
 632         LPWSTR wide_str;
 633         DWORD give;
 634
 635         /* <lawson_whitney@juno.com> Feb 2001 */
 636         /* AOL 5.0 does this, expecting to get this: */
 637         len = MultiByteToWideChar(CP_ACP, 0, lpSubBlock, -1, NULL, 0);
 638         wide_str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 639         MultiByteToWideChar(CP_ACP, 0, lpSubBlock, -1, wide_str, len);
 640
 641         give = VerQueryValueW(pBlock, wide_str, lplpBuffer, puLen);
 642         HeapFree(GetProcessHeap(), 0, wide_str);
 643         return give;
 644     }
 645
 646     TRACE("(%p,%s,%p,%p)\n",
 647                 pBlock, debugstr_a(lpSubBlock), lplpBuffer, puLen );
 648
 649     while ( *lpSubBlock )
 650     {
 651         /* Find next path component */
 652         LPCSTR lpNextSlash;
 653         for ( lpNextSlash = lpSubBlock; *lpNextSlash; lpNextSlash++ )
 654             if ( *lpNextSlash == '\\' )
 655                 break;
 656
 657         /* Skip empty components */
 658         if ( lpNextSlash == lpSubBlock )
 659         {
 660             lpSubBlock++;
 661             continue;
 662         }
 663
 664         /* We have a non-empty component: search info for key */
 665         info = VersionInfo16_FindChild( info, lpSubBlock, lpNextSlash-lpSubBlock );
 666         if ( !info ) return FALSE;
 667
 668         /* Skip path component */
 669         lpSubBlock = lpNextSlash;
 670     }
 671
 672     /* Return value */
 673     *lplpBuffer = VersionInfo16_Value( info );
 674     *puLen = info->wValueLength;
 675
 676     return TRUE;
 677 }
 678
 679 /***********************************************************************
 680  *           VerQueryValueW              [VERSION.@]
 681  */
 682 DWORD WINAPI VerQueryValueW( LPVOID pBlock, LPCWSTR lpSubBlock,
 683                                LPVOID *lplpBuffer, UINT *puLen )
 684 {
 685     VS_VERSION_INFO_STRUCT32 *info = (VS_VERSION_INFO_STRUCT32 *)pBlock;
 686     if ( VersionInfoIs16( info ) )
 687     {
 688         ERR("called on NE resource!\n" );
 689         return FALSE;
 690     }
 691
 692     TRACE("(%p,%s,%p,%p)\n",
 693                 pBlock, debugstr_w(lpSubBlock), lplpBuffer, puLen );
 694
 695     while ( *lpSubBlock )
 696     {
 697         /* Find next path component */
 698         LPCWSTR lpNextSlash;
 699         for ( lpNextSlash = lpSubBlock; *lpNextSlash; lpNextSlash++ )
 700             if ( *lpNextSlash == '\\' )
 701                 break;
 702
 703         /* Skip empty components */
 704         if ( lpNextSlash == lpSubBlock )
 705         {
 706             lpSubBlock++;
 707             continue;
 708         }
 709
 710         /* We have a non-empty component: search info for key */
 711         info = VersionInfo32_FindChild( info, lpSubBlock, lpNextSlash-lpSubBlock );
 712         if ( !info ) return FALSE;
 713
 714         /* Skip path component */
 715         lpSubBlock = lpNextSlash;
 716     }
 717
 718     /* Return value */
 719     *lplpBuffer = VersionInfo32_Value( info );
 720     *puLen = info->wValueLength;
 721
 722     return TRUE;
 723 }