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