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