dlls/version/resource.c

   1 /*
   2  * Implementation of VERSION.DLL - Resource Access routines
   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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <sys/types.h>
  30 #ifdef HAVE_UNISTD_H
  31 # include <unistd.h>
  32 #endif
  33
  34 #define NONAMELESSUNION
  35 #define NONAMELESSSTRUCT
  36 #include "windef.h"
  37 #include "winbase.h"
  38 #include "lzexpand.h"
  39
  40 #include "wine/unicode.h"
  41 #include "wine/winbase16.h"
  42
  43 #include "wine/debug.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(ver);
  46
  47
  48 /**********************************************************************
  49  *  find_entry_by_id
  50  *
  51  * Find an entry by id in a resource directory
  52  * Copied from loader/pe_resource.c
  53  */
  54 static const IMAGE_RESOURCE_DIRECTORY *find_entry_by_id( const IMAGE_RESOURCE_DIRECTORY *dir,
  55                                                          WORD id, const void *root )
  56 {
  57     const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry;
  58     int min, max, pos;
  59
  60     entry = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(dir + 1);
  61     min = dir->NumberOfNamedEntries;
  62     max = min + dir->NumberOfIdEntries - 1;
  63     while (min <= max)
  64     {
  65         pos = (min + max) / 2;
  66         if (entry[pos].u1.s2.Id == id)
  67             return (const IMAGE_RESOURCE_DIRECTORY *)((const char *)root + entry[pos].u2.s3.OffsetToDirectory);
  68         if (entry[pos].u1.s2.Id > id) max = pos - 1;
  69         else min = pos + 1;
  70     }
  71     return NULL;
  72 }
  73
  74
  75 /**********************************************************************
  76  *  find_entry_default
  77  *
  78  * Find a default entry in a resource directory
  79  * Copied from loader/pe_resource.c
  80  */
  81 static const IMAGE_RESOURCE_DIRECTORY *find_entry_default( const IMAGE_RESOURCE_DIRECTORY *dir,
  82                                                            const void *root )
  83 {
  84     const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry;
  85
  86     entry = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(dir + 1);
  87     return (const IMAGE_RESOURCE_DIRECTORY *)((const char *)root + entry->u2.s3.OffsetToDirectory);
  88 }
  89
  90
  91 /**********************************************************************
  92  *  find_entry_by_name
  93  *
  94  * Find an entry by name in a resource directory
  95  * Copied from loader/pe_resource.c
  96  */
  97 static const IMAGE_RESOURCE_DIRECTORY *find_entry_by_name( const IMAGE_RESOURCE_DIRECTORY *dir,
  98                                                            LPCSTR name, const void *root )
  99 {
 100     const IMAGE_RESOURCE_DIRECTORY *ret = NULL;
 101     LPWSTR nameW;
 102     DWORD namelen;
 103
 104     if (!HIWORD(name)) return find_entry_by_id( dir, LOWORD(name), root );
 105     if (name[0] == '#')
 106     {
 107         return find_entry_by_id( dir, atoi(name+1), root );
 108     }
 109
 110     namelen = MultiByteToWideChar( CP_ACP, 0, name, -1, NULL, 0 );
 111     if ((nameW = HeapAlloc( GetProcessHeap(), 0, namelen * sizeof(WCHAR) )))
 112     {
 113         const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry;
 114         const IMAGE_RESOURCE_DIR_STRING_U *str;
 115         int min, max, res, pos;
 116
 117         MultiByteToWideChar( CP_ACP, 0, name, -1, nameW, namelen );
 118         namelen--;  /* remove terminating null */
 119         entry = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(dir + 1);
 120         min = 0;
 121         max = dir->NumberOfNamedEntries - 1;
 122         while (min <= max)
 123         {
 124             pos = (min + max) / 2;
 125             str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const char *)root + entry[pos].u1.s1.NameOffset);
 126             res = strncmpiW( nameW, str->NameString, str->Length );
 127             if (!res && namelen == str->Length)
 128             {
 129                 ret = (const IMAGE_RESOURCE_DIRECTORY *)((const char *)root + entry[pos].u2.s3.OffsetToDirectory);
 130                 break;
 131             }
 132             if (res < 0) max = pos - 1;
 133             else min = pos + 1;
 134         }
 135         HeapFree( GetProcessHeap(), 0, nameW );
 136     }
 137     return ret;
 138 }
 139
 140
 141 /***********************************************************************
 142  *           read_xx_header         [internal]
 143  */
 144 static int read_xx_header( HFILE lzfd )
 145 {
 146     IMAGE_DOS_HEADER mzh;
 147     char magic[3];
 148
 149     LZSeek( lzfd, 0, SEEK_SET );
 150     if ( sizeof(mzh) != LZRead( lzfd, (LPSTR)&mzh, sizeof(mzh) ) )
 151         return 0;
 152     if ( mzh.e_magic != IMAGE_DOS_SIGNATURE )
 153         return 0;
 154
 155     LZSeek( lzfd, mzh.e_lfanew, SEEK_SET );
 156     if ( 2 != LZRead( lzfd, magic, 2 ) )
 157         return 0;
 158
 159     LZSeek( lzfd, mzh.e_lfanew, SEEK_SET );
 160
 161     if ( magic[0] == 'N' && magic[1] == 'E' )
 162         return IMAGE_OS2_SIGNATURE;
 163     if ( magic[0] == 'P' && magic[1] == 'E' )
 164         return IMAGE_NT_SIGNATURE;
 165
 166     magic[2] = '\0';
 167     WARN("Can't handle %s files.\n", magic );
 168     return 0;
 169 }
 170
 171 /***********************************************************************
 172  *           find_ne_resource         [internal]
 173  */
 174 static BOOL find_ne_resource( HFILE lzfd, LPCSTR typeid, LPCSTR resid,
 175                                 DWORD *resLen, DWORD *resOff )
 176 {
 177     IMAGE_OS2_HEADER nehd;
 178     NE_TYPEINFO *typeInfo;
 179     NE_NAMEINFO *nameInfo;
 180     DWORD nehdoffset;
 181     LPBYTE resTab;
 182     DWORD resTabSize;
 183     int count;
 184
 185     /* Read in NE header */
 186     nehdoffset = LZSeek( lzfd, 0, SEEK_CUR );
 187     if ( sizeof(nehd) != LZRead( lzfd, (LPSTR)&nehd, sizeof(nehd) ) ) return 0;
 188
 189     resTabSize = nehd.ne_restab - nehd.ne_rsrctab;
 190     if ( !resTabSize )
 191     {
 192         TRACE("No resources in NE dll\n" );
 193         return FALSE;
 194     }
 195
 196     /* Read in resource table */
 197     resTab = HeapAlloc( GetProcessHeap(), 0, resTabSize );
 198     if ( !resTab ) return FALSE;
 199
 200     LZSeek( lzfd, nehd.ne_rsrctab + nehdoffset, SEEK_SET );
 201     if ( resTabSize != LZRead( lzfd, (char*)resTab, resTabSize ) )
 202     {
 203         HeapFree( GetProcessHeap(), 0, resTab );
 204         return FALSE;
 205     }
 206
 207     /* Find resource */
 208     typeInfo = (NE_TYPEINFO *)(resTab + 2);
 209
 210     if (HIWORD(typeid) != 0)  /* named type */
 211     {
 212         BYTE len = strlen( typeid );
 213         while (typeInfo->type_id)
 214         {
 215             if (!(typeInfo->type_id & 0x8000))
 216             {
 217                 BYTE *p = resTab + typeInfo->type_id;
 218                 if ((*p == len) && !strncasecmp( (char*)p+1, typeid, len )) goto found_type;
 219             }
 220             typeInfo = (NE_TYPEINFO *)((char *)(typeInfo + 1) +
 221                                        typeInfo->count * sizeof(NE_NAMEINFO));
 222         }
 223     }
 224     else  /* numeric type id */
 225     {
 226         WORD id = LOWORD(typeid) | 0x8000;
 227         while (typeInfo->type_id)
 228         {
 229             if (typeInfo->type_id == id) goto found_type;
 230             typeInfo = (NE_TYPEINFO *)((char *)(typeInfo + 1) +
 231                                        typeInfo->count * sizeof(NE_NAMEINFO));
 232         }
 233     }
 234     TRACE("No typeid entry found for %p\n", typeid );
 235     HeapFree( GetProcessHeap(), 0, resTab );
 236     return FALSE;
 237
 238  found_type:
 239     nameInfo = (NE_NAMEINFO *)(typeInfo + 1);
 240
 241     if (HIWORD(resid) != 0)  /* named resource */
 242     {
 243         BYTE len = strlen( resid );
 244         for (count = typeInfo->count; count > 0; count--, nameInfo++)
 245         {
 246             BYTE *p = resTab + nameInfo->id;
 247             if (nameInfo->id & 0x8000) continue;
 248             if ((*p == len) && !strncasecmp( (char*)p+1, resid, len )) goto found_name;
 249         }
 250     }
 251     else  /* numeric resource id */
 252     {
 253         WORD id = LOWORD(resid) | 0x8000;
 254         for (count = typeInfo->count; count > 0; count--, nameInfo++)
 255             if (nameInfo->id == id) goto found_name;
 256     }
 257     TRACE("No resid entry found for %p\n", typeid );
 258     HeapFree( GetProcessHeap(), 0, resTab );
 259     return FALSE;
 260
 261  found_name:
 262     /* Return resource data */
 263     if ( resLen ) *resLen = nameInfo->length << *(WORD *)resTab;
 264     if ( resOff ) *resOff = nameInfo->offset << *(WORD *)resTab;
 265
 266     HeapFree( GetProcessHeap(), 0, resTab );
 267     return TRUE;
 268 }
 269
 270 /***********************************************************************
 271  *           find_pe_resource         [internal]
 272  */
 273 static BOOL find_pe_resource( HFILE lzfd, LPCSTR typeid, LPCSTR resid,
 274                                 DWORD *resLen, DWORD *resOff )
 275 {
 276     IMAGE_NT_HEADERS pehd;
 277     DWORD pehdoffset;
 278     PIMAGE_DATA_DIRECTORY resDataDir;
 279     PIMAGE_SECTION_HEADER sections;
 280     LPBYTE resSection;
 281     DWORD resSectionSize;
 282     const void *resDir;
 283     const IMAGE_RESOURCE_DIRECTORY *resPtr;
 284     const IMAGE_RESOURCE_DATA_ENTRY *resData;
 285     int i, nSections;
 286     BOOL ret = FALSE;
 287
 288     /* Read in PE header */
 289     pehdoffset = LZSeek( lzfd, 0, SEEK_CUR );
 290     if ( sizeof(pehd) != LZRead( lzfd, (LPSTR)&pehd, sizeof(pehd) ) ) return 0;
 291
 292     resDataDir = pehd.OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_RESOURCE;
 293     if ( !resDataDir->Size )
 294     {
 295         TRACE("No resources in PE dll\n" );
 296         return FALSE;
 297     }
 298
 299     /* Read in section table */
 300     nSections = pehd.FileHeader.NumberOfSections;
 301     sections = HeapAlloc( GetProcessHeap(), 0,
 302                           nSections * sizeof(IMAGE_SECTION_HEADER) );
 303     if ( !sections ) return FALSE;
 304
 305     LZSeek( lzfd, pehdoffset +
 306                     sizeof(DWORD) + /* Signature */
 307                     sizeof(IMAGE_FILE_HEADER) +
 308                     pehd.FileHeader.SizeOfOptionalHeader, SEEK_SET );
 309
 310     if ( nSections * sizeof(IMAGE_SECTION_HEADER) !=
 311          LZRead( lzfd, (LPSTR)sections, nSections * sizeof(IMAGE_SECTION_HEADER) ) )
 312     {
 313         HeapFree( GetProcessHeap(), 0, sections );
 314         return FALSE;
 315     }
 316
 317     /* Find resource section */
 318     for ( i = 0; i < nSections; i++ )
 319         if (    resDataDir->VirtualAddress >= sections[i].VirtualAddress
 320              && resDataDir->VirtualAddress <  sections[i].VirtualAddress +
 321                                               sections[i].SizeOfRawData )
 322             break;
 323
 324     if ( i == nSections )
 325     {
 326         HeapFree( GetProcessHeap(), 0, sections );
 327         TRACE("Couldn't find resource section\n" );
 328         return FALSE;
 329     }
 330
 331     /* Read in resource section */
 332     resSectionSize = sections[i].SizeOfRawData;
 333     resSection = HeapAlloc( GetProcessHeap(), 0, resSectionSize );
 334     if ( !resSection )
 335     {
 336         HeapFree( GetProcessHeap(), 0, sections );
 337         return FALSE;
 338     }
 339
 340     LZSeek( lzfd, sections[i].PointerToRawData, SEEK_SET );
 341     if ( resSectionSize != LZRead( lzfd, (char*)resSection, resSectionSize ) ) goto done;
 342
 343     /* Find resource */
 344     resDir = resSection + (resDataDir->VirtualAddress - sections[i].VirtualAddress);
 345
 346     resPtr = (const IMAGE_RESOURCE_DIRECTORY*)resDir;
 347     resPtr = find_entry_by_name( resPtr, typeid, resDir );
 348     if ( !resPtr )
 349     {
 350         TRACE("No typeid entry found for %p\n", typeid );
 351         goto done;
 352     }
 353     resPtr = find_entry_by_name( resPtr, resid, resDir );
 354     if ( !resPtr )
 355     {
 356         TRACE("No resid entry found for %p\n", resid );
 357         goto done;
 358     }
 359     resPtr = find_entry_default( resPtr, resDir );
 360     if ( !resPtr )
 361     {
 362         TRACE("No default language entry found for %p\n", resid );
 363         goto done;
 364     }
 365
 366     /* Find resource data section */
 367     resData = (const IMAGE_RESOURCE_DATA_ENTRY*)resPtr;
 368     for ( i = 0; i < nSections; i++ )
 369         if (    resData->OffsetToData >= sections[i].VirtualAddress
 370              && resData->OffsetToData <  sections[i].VirtualAddress +
 371                                          sections[i].SizeOfRawData )
 372             break;
 373
 374     if ( i == nSections )
 375     {
 376         TRACE("Couldn't find resource data section\n" );
 377         goto done;
 378     }
 379
 380     /* Return resource data */
 381     if ( resLen ) *resLen = resData->Size;
 382     if ( resOff ) *resOff = resData->OffsetToData - sections[i].VirtualAddress
 383                             + sections[i].PointerToRawData;
 384     ret = TRUE;
 385
 386  done:
 387     HeapFree( GetProcessHeap(), 0, resSection );
 388     HeapFree( GetProcessHeap(), 0, sections );
 389     return ret;
 390 }
 391
 392
 393 /*************************************************************************
 394  * GetFileResourceSize                     [VER.2]
 395  */
 396 DWORD WINAPI GetFileResourceSize16( LPCSTR lpszFileName, LPCSTR lpszResType,
 397                                     LPCSTR lpszResId, LPDWORD lpdwFileOffset )
 398 {
 399     BOOL retv = FALSE;
 400     HFILE lzfd;
 401     OFSTRUCT ofs;
 402     DWORD reslen;
 403
 404     TRACE("(%s,type=%p,id=%p,off=%p)\n",
 405           debugstr_a(lpszFileName), lpszResType, lpszResId, lpszResId );
 406
 407     lzfd = LZOpenFileA( (LPSTR)lpszFileName, &ofs, OF_READ );
 408     if ( lzfd < 0 ) return 0;
 409
 410     switch ( read_xx_header( lzfd ) )
 411     {
 412     case IMAGE_OS2_SIGNATURE:
 413         retv = find_ne_resource( lzfd, lpszResType, lpszResId,
 414                                  &reslen, lpdwFileOffset );
 415         break;
 416
 417     case IMAGE_NT_SIGNATURE:
 418         retv = find_pe_resource( lzfd, lpszResType, lpszResId,
 419                                  &reslen, lpdwFileOffset );
 420         break;
 421     }
 422
 423     LZClose( lzfd );
 424     return retv? reslen : 0;
 425 }
 426
 427
 428 /*************************************************************************
 429  * GetFileResource                         [VER.3]
 430  */
 431 DWORD WINAPI GetFileResource16( LPCSTR lpszFileName, LPCSTR lpszResType,
 432                                 LPCSTR lpszResId, DWORD dwFileOffset,
 433                                 DWORD dwResLen, LPVOID lpvData )
 434 {
 435     BOOL retv = FALSE;
 436     HFILE lzfd;
 437     OFSTRUCT ofs;
 438     DWORD reslen = dwResLen;
 439
 440     TRACE("(%s,type=%p,id=%p,off=%d,len=%d,data=%p)\n",
 441                 debugstr_a(lpszFileName), lpszResType, lpszResId,
 442                 dwFileOffset, dwResLen, lpvData );
 443
 444     lzfd = LZOpenFileA( (LPSTR)lpszFileName, &ofs, OF_READ );
 445     if ( lzfd < 0 ) return 0;
 446
 447     if ( !dwFileOffset )
 448     {
 449         switch ( read_xx_header( lzfd ) )
 450         {
 451         case IMAGE_OS2_SIGNATURE:
 452             retv = find_ne_resource( lzfd, lpszResType, lpszResId,
 453                                      &reslen, &dwFileOffset );
 454             break;
 455
 456         case IMAGE_NT_SIGNATURE:
 457             retv = find_pe_resource( lzfd, lpszResType, lpszResId,
 458                                      &reslen, &dwFileOffset );
 459             break;
 460         }
 461
 462         if ( !retv )
 463         {
 464             LZClose( lzfd );
 465             return 0;
 466         }
 467     }
 468
 469     LZSeek( lzfd, dwFileOffset, SEEK_SET );
 470     reslen = LZRead( lzfd, lpvData, min( reslen, dwResLen ) );
 471     LZClose( lzfd );
 472
 473     return reslen;
 474 }