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