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