loader/ne/resource.c

   1 /*
   2  * NE resource functions
   3  *
   4  * Copyright 1993 Robert J. Amstadt
   5  * Copyright 1995 Alexandre Julliard
   6  * Copyright 1997 Alex Korobka
   7  */
   8
   9 #include <assert.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <sys/types.h>
  14 #include <sys/stat.h>
  15 #include <fcntl.h>
  16 #include <unistd.h>
  17 #include "windows.h"
  18 #include "global.h"
  19 #include "ldt.h"
  20 #include "module.h"
  21 #include "neexe.h"
  22 #include "resource.h"
  23 #include "debug.h"
  24
  25 #define NEXT_TYPEINFO(pTypeInfo) ((NE_TYPEINFO *)((char*)((pTypeInfo) + 1) + \
  26                                    (pTypeInfo)->count * sizeof(NE_NAMEINFO)))
  27
  28 /***********************************************************************
  29  *           NE_FindNameTableId
  30  *
  31  * Find the type and resource id from their names.
  32  * Return value is MAKELONG( typeId, resId ), or 0 if not found.
  33  */
  34 static DWORD NE_FindNameTableId( NE_MODULE *pModule, SEGPTR typeId, SEGPTR resId )
  35 {
  36     NE_TYPEINFO *pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->res_table + 2);
  37     NE_NAMEINFO *pNameInfo;
  38     HGLOBAL16 handle;
  39     WORD *p;
  40     DWORD ret = 0;
  41     int count;
  42
  43     for (; pTypeInfo->type_id != 0;
  44            pTypeInfo = (NE_TYPEINFO *)((char*)(pTypeInfo+1) +
  45                                         pTypeInfo->count * sizeof(NE_NAMEINFO)))
  46     {
  47         if (pTypeInfo->type_id != 0x800f) continue;
  48         pNameInfo = (NE_NAMEINFO *)(pTypeInfo + 1);
  49         for (count = pTypeInfo->count; count > 0; count--, pNameInfo++)
  50         {
  51             TRACE(resource, "NameTable entry: type=%04x id=%04x\n",
  52                               pTypeInfo->type_id, pNameInfo->id );
  53             handle = LoadResource16( pModule->self,
  54                                    (HRSRC16)((int)pNameInfo - (int)pModule) );
  55             for(p = (WORD*)LockResource16(handle); p && *p; p = (WORD *)((char*)p+*p))
  56             {
  57                 TRACE(resource,"  type=%04x '%s' id=%04x '%s'\n",
  58                                   p[1], (char *)(p+3), p[2],
  59                                   (char *)(p+3)+strlen((char *)(p+3))+1 );
  60                 /* Check for correct type */
  61
  62                 if (p[1] & 0x8000)
  63                 {
  64                     if (!HIWORD(typeId)) continue;
  65                     if (lstrcmpi32A( (char *)PTR_SEG_TO_LIN(typeId),
  66                                      (char *)(p + 3) )) continue;
  67                 }
  68                 else if (HIWORD(typeId) || ((typeId & ~0x8000)!= p[1]))
  69                   continue;
  70
  71                 /* Now check for the id */
  72
  73                 if (p[2] & 0x8000)
  74                 {
  75                     if (!HIWORD(resId)) continue;
  76                     if (lstrcmpi32A( (char *)PTR_SEG_TO_LIN(resId),
  77                                (char*)(p+3)+strlen((char*)(p+3))+1 )) continue;
  78
  79                 }
  80                 else if (HIWORD(resId) || ((resId & ~0x8000) != p[2]))
  81                   continue;
  82
  83                 /* If we get here, we've found the entry */
  84
  85                 TRACE(resource, "  Found!\n" );
  86                 ret = MAKELONG( p[1], p[2] );
  87                 break;
  88             }
  89             FreeResource16( handle );
  90             if (ret) return ret;
  91         }
  92     }
  93     return 0;
  94 }
  95
  96 /***********************************************************************
  97  *           NE_FindTypeSection
  98  *
  99  * Find header struct for a particular resource type.
 100  */
 101 static NE_TYPEINFO* NE_FindTypeSection( NE_MODULE *pModule,
 102                                         NE_TYPEINFO *pTypeInfo, SEGPTR typeId )
 103 {
 104     /* start from pTypeInfo */
 105
 106     if (HIWORD(typeId) != 0)  /* Named type */
 107     {
 108         char *str = (char *)PTR_SEG_TO_LIN( typeId );
 109         BYTE len = strlen( str );
 110         while (pTypeInfo->type_id)
 111         {
 112             if (!(pTypeInfo->type_id & 0x8000))
 113             {
 114                 BYTE *p = (BYTE*)pModule + pModule->res_table + pTypeInfo->type_id;
 115                 if ((*p == len) && !lstrncmpi32A( p+1, str, len ))
 116                 {
 117                     TRACE(resource, "  Found type '%s'\n", str );
 118                     return pTypeInfo;
 119                 }
 120             }
 121             TRACE(resource, "  Skipping type %04x\n", pTypeInfo->type_id );
 122             pTypeInfo = NEXT_TYPEINFO(pTypeInfo);
 123         }
 124     }
 125     else  /* Numeric type id */
 126     {
 127         WORD id = LOWORD(typeId) | 0x8000;
 128         while (pTypeInfo->type_id)
 129         {
 130             if (pTypeInfo->type_id == id)
 131             {
 132                 TRACE(resource, "  Found type %04x\n", id );
 133                 return pTypeInfo;
 134             }
 135             TRACE(resource, "  Skipping type %04x\n", pTypeInfo->type_id );
 136             pTypeInfo = NEXT_TYPEINFO(pTypeInfo);
 137         }
 138     }
 139     return NULL;
 140 }
 141
 142 /***********************************************************************
 143  *           NE_FindResourceFromType
 144  *
 145  * Find a resource once the type info structure has been found.
 146  */
 147 static HRSRC16 NE_FindResourceFromType( NE_MODULE *pModule,
 148                                         NE_TYPEINFO *pTypeInfo, SEGPTR resId )
 149 {
 150     BYTE *p;
 151     int count;
 152     NE_NAMEINFO *pNameInfo = (NE_NAMEINFO *)(pTypeInfo + 1);
 153
 154     if (HIWORD(resId) != 0)  /* Named resource */
 155     {
 156         char *str = (char *)PTR_SEG_TO_LIN( resId );
 157         BYTE len = strlen( str );
 158         for (count = pTypeInfo->count; count > 0; count--, pNameInfo++)
 159         {
 160             if (pNameInfo->id & 0x8000) continue;
 161             p = (BYTE *)pModule + pModule->res_table + pNameInfo->id;
 162             if ((*p == len) && !lstrncmpi32A( p+1, str, len ))
 163                 return (HRSRC16)((int)pNameInfo - (int)pModule);
 164         }
 165     }
 166     else  /* Numeric resource id */
 167     {
 168         WORD id = LOWORD(resId) | 0x8000;
 169         for (count = pTypeInfo->count; count > 0; count--, pNameInfo++)
 170             if (pNameInfo->id == id)
 171               return (HRSRC16)((int)pNameInfo - (int)pModule);
 172     }
 173     return 0;
 174 }
 175
 176
 177 /***********************************************************************
 178  *           NE_DefResourceHandler
 179  *
 180  * This is the default LoadProc() function.
 181  */
 182 HGLOBAL16 WINAPI NE_DefResourceHandler( HGLOBAL16 hMemObj, HMODULE16 hModule,
 183                                         HRSRC16 hRsrc )
 184 {
 185     int  fd;
 186     NE_MODULE* pModule = MODULE_GetPtr16( hModule );
 187     if ( pModule && (fd = MODULE_OpenFile( hModule )) >= 0)
 188     {
 189         HGLOBAL16 handle;
 190         WORD sizeShift = *(WORD *)((char *)pModule + pModule->res_table);
 191         NE_NAMEINFO* pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);
 192
 193         TRACE(resource, "loading, pos=%d, len=%d\n",
 194                      (int)pNameInfo->offset << sizeShift,
 195                      (int)pNameInfo->length << sizeShift );
 196         if( hMemObj )
 197             handle = GlobalReAlloc16( hMemObj, pNameInfo->length << sizeShift, 0 );
 198         else
 199             handle = AllocResource( hModule, hRsrc, 0 );
 200
 201         if( handle )
 202         {
 203             lseek( fd, (int)pNameInfo->offset << sizeShift, SEEK_SET );
 204             read( fd, GlobalLock16( handle ), (int)pNameInfo->length << sizeShift );
 205         }
 206         return handle;
 207     }
 208     return (HGLOBAL16)0;
 209 }
 210
 211 /***********************************************************************
 212  *           NE_InitResourceHandler
 213  *
 214  * Fill in 'resloader' fields in the resource table.
 215  */
 216 BOOL32 NE_InitResourceHandler( HMODULE16 hModule )
 217 {
 218     NE_MODULE *pModule = MODULE_GetPtr16( hModule );
 219     NE_TYPEINFO *pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->res_table + 2);
 220
 221     TRACE(resource,"InitResourceHandler[%04x]\n", hModule );
 222
 223     while(pTypeInfo->type_id)
 224     {
 225         pTypeInfo->resloader = (FARPROC16)&NE_DefResourceHandler;
 226         pTypeInfo = NEXT_TYPEINFO(pTypeInfo);
 227     }
 228     return TRUE;
 229 }
 230
 231
 232 /**********************************************************************
 233  *      SetResourceHandler      (KERNEL.43)
 234  */
 235 FARPROC16 WINAPI SetResourceHandler( HMODULE16 hModule, SEGPTR typeId,
 236                                      FARPROC16 resourceHandler )
 237 {
 238     FARPROC16 prevHandler = NULL;
 239     NE_MODULE *pModule = MODULE_GetPtr16( hModule );
 240     NE_TYPEINFO *pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->res_table + 2);
 241
 242     if (!pModule || !pModule->res_table) return NULL;
 243
 244     TRACE( resource, "module=%04x type=%s\n",
 245            hModule, debugres_a(PTR_SEG_TO_LIN(typeId)) );
 246
 247     for (;;)
 248     {
 249         if (!(pTypeInfo = NE_FindTypeSection( pModule, pTypeInfo, typeId )))
 250             break;
 251         prevHandler = pTypeInfo->resloader;
 252         pTypeInfo->resloader = resourceHandler;
 253         pTypeInfo = NEXT_TYPEINFO(pTypeInfo);
 254     }
 255     return prevHandler;
 256 }
 257
 258
 259 /**********************************************************************
 260  *          FindResource16    (KERNEL.60)
 261  */
 262 HRSRC16 WINAPI FindResource16( HMODULE16 hModule, SEGPTR name, SEGPTR type )
 263 {
 264     NE_TYPEINFO *pTypeInfo;
 265     HRSRC16 hRsrc;
 266
 267     NE_MODULE *pModule = MODULE_GetPtr16( hModule );
 268     if (!pModule || !pModule->res_table) return 0;
 269
 270     assert( !__winelib );  /* Can't use Win16 resource functions in Winelib */
 271
 272     TRACE( resource, "module=%04x name=%s type=%s\n",
 273            hModule, debugres_a(PTR_SEG_TO_LIN(name)),
 274            debugres_a(PTR_SEG_TO_LIN(type)) );
 275
 276     if (HIWORD(name))  /* Check for '#xxx' name */
 277     {
 278         char *ptr = PTR_SEG_TO_LIN( name );
 279         if (ptr[0] == '#')
 280             if (!(name = (SEGPTR)atoi( ptr + 1 )))
 281             {
 282                 WARN(resource, "Incorrect resource name: %s\n", ptr);
 283                 return 0;
 284             }
 285     }
 286
 287     if (HIWORD(type))  /* Check for '#xxx' type */
 288     {
 289         char *ptr = PTR_SEG_TO_LIN( type );
 290         if (ptr[0] == '#')
 291             if (!(type = (SEGPTR)atoi( ptr + 1 )))
 292             {
 293                 WARN(resource, "Incorrect resource type: %s\n", ptr);
 294                 return 0;
 295             }
 296     }
 297
 298     if (HIWORD(type) || HIWORD(name))
 299     {
 300         DWORD id = NE_FindNameTableId( pModule, type, name );
 301         if (id)  /* found */
 302         {
 303             type = LOWORD(id);
 304             name = HIWORD(id);
 305         }
 306     }
 307
 308     pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->res_table + 2);
 309
 310     for (;;)
 311     {
 312         if (!(pTypeInfo = NE_FindTypeSection( pModule, pTypeInfo, type )))
 313             break;
 314         if ((hRsrc = NE_FindResourceFromType(pModule, pTypeInfo, name)))
 315         {
 316             TRACE(resource, "    Found id %08lx\n", name );
 317             return hRsrc;
 318         }
 319         TRACE(resource, "    Not found, going on\n" );
 320         pTypeInfo = NEXT_TYPEINFO(pTypeInfo);
 321     }
 322
 323     WARN(resource, "failed!\n");
 324     return 0;
 325 }
 326
 327
 328 /**********************************************************************
 329  *          AllocResource    (KERNEL.66)
 330  */
 331 HGLOBAL16 WINAPI AllocResource( HMODULE16 hModule, HRSRC16 hRsrc, DWORD size)
 332 {
 333     NE_NAMEINFO *pNameInfo=NULL;
 334     WORD sizeShift;
 335
 336     NE_MODULE *pModule = MODULE_GetPtr16( hModule );
 337     if (!pModule || !pModule->res_table || !hRsrc) return 0;
 338
 339     TRACE( resource, "module=%04x res=%04x size=%ld\n", hModule, hRsrc, size );
 340
 341     assert( !__winelib );  /* Can't use Win16 resource functions in Winelib */
 342
 343     sizeShift = *(WORD *)((char *)pModule + pModule->res_table);
 344     pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);
 345     if (size < (DWORD)pNameInfo->length << sizeShift)
 346         size = (DWORD)pNameInfo->length << sizeShift;
 347     return GLOBAL_Alloc( GMEM_FIXED, size, hModule, FALSE, FALSE, FALSE );
 348 }
 349
 350
 351 /**********************************************************************
 352  *      DirectResAlloc    (KERNEL.168)
 353  *
 354  * Check Schulman, p. 232 for details
 355  */
 356 HGLOBAL16 WINAPI DirectResAlloc( HINSTANCE16 hInstance, WORD wType,
 357                                  UINT16 wSize )
 358 {
 359     TRACE(resource,"(%04x,%04x,%04x)\n",
 360                      hInstance, wType, wSize );
 361     if (!(hInstance = GetExePtr( hInstance ))) return 0;
 362     if(wType != 0x10)   /* 0x10 is the only observed value, passed from
 363                            CreateCursorIndirect. */
 364         fprintf(stderr, "DirectResAlloc: wType = %x\n", wType);
 365     return GLOBAL_Alloc(GMEM_MOVEABLE, wSize, hInstance, FALSE, FALSE, FALSE);
 366 }
 367
 368
 369 /**********************************************************************
 370  *          AccessResource16    (KERNEL.64)
 371  */
 372 INT16 WINAPI AccessResource16( HINSTANCE16 hModule, HRSRC16 hRsrc )
 373 {
 374     HFILE32 fd;
 375
 376     NE_MODULE *pModule = MODULE_GetPtr16( hModule );
 377     if (!pModule || !pModule->res_table || !hRsrc) return -1;
 378
 379     TRACE(resource, "module=%04x res=%04x\n", hModule, hRsrc );
 380
 381     assert( !__winelib );  /* Can't use Win16 resource functions in Winelib */
 382
 383     if ((fd = _lopen32( NE_MODULE_NAME(pModule), OF_READ )) != -1)
 384     {
 385         WORD sizeShift = *(WORD *)((char *)pModule + pModule->res_table);
 386         NE_NAMEINFO *pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);
 387         _llseek32( fd, (int)pNameInfo->offset << sizeShift, SEEK_SET );
 388     }
 389     return fd;
 390 }
 391
 392
 393 /**********************************************************************
 394  *          SizeofResource16    (KERNEL.65)
 395  */
 396 DWORD WINAPI SizeofResource16( HMODULE16 hModule, HRSRC16 hRsrc )
 397 {
 398     NE_NAMEINFO *pNameInfo=NULL;
 399     WORD sizeShift;
 400
 401     NE_MODULE *pModule = MODULE_GetPtr16( hModule );
 402     if (!pModule || !pModule->res_table) return 0;
 403
 404     TRACE(resource, "module=%04x res=%04x\n", hModule, hRsrc );
 405
 406     assert( !__winelib );  /* Can't use Win16 resource functions in Winelib */
 407
 408     sizeShift = *(WORD *)((char *)pModule + pModule->res_table);
 409     pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);
 410     return (DWORD)pNameInfo->length << sizeShift;
 411 }
 412
 413
 414 /**********************************************************************
 415  *          LoadResource16    (KERNEL.61)
 416  */
 417 HGLOBAL16 WINAPI LoadResource16( HMODULE16 hModule, HRSRC16 hRsrc )
 418 {
 419     NE_TYPEINFO *pTypeInfo;
 420     NE_NAMEINFO *pNameInfo = NULL;
 421     NE_MODULE *pModule = MODULE_GetPtr16( hModule );
 422     int d;
 423
 424     TRACE( resource, "module=%04x res=%04x\n", hModule, hRsrc );
 425     if (!hRsrc || !pModule || !pModule->res_table) return 0;
 426
 427     assert( !__winelib );  /* Can't use Win16 resource functions in Winelib */
 428
 429     /* First, verify hRsrc (just an offset from pModule to the needed pNameInfo) */
 430
 431     d = pModule->res_table + 2;
 432     pTypeInfo = (NE_TYPEINFO *)((char *)pModule + d);
 433     while( hRsrc > d )
 434     {
 435         if (pTypeInfo->type_id == 0)
 436                 break; /* terminal entry */
 437         d += sizeof(NE_TYPEINFO) + pTypeInfo->count * sizeof(NE_NAMEINFO);
 438         if (hRsrc < d)
 439         {
 440             if( ((d - hRsrc)%sizeof(NE_NAMEINFO)) == 0 )
 441             {
 442                 pNameInfo = (NE_NAMEINFO *)(((char *)pModule) + hRsrc);
 443                 break;
 444             }
 445             else
 446                 break; /* NE_NAMEINFO boundary mismatch */
 447         }
 448         pTypeInfo = (NE_TYPEINFO *)(((char *)pModule) + d);
 449     }
 450
 451     if (pNameInfo)
 452     {
 453         RESOURCEHANDLER16 loader;
 454         if (pNameInfo->handle
 455             && !(GlobalFlags16(pNameInfo->handle) & GMEM_DISCARDED))
 456         {
 457             pNameInfo->usage++;
 458             TRACE(resource, "  Already loaded, new count=%d\n",
 459                               pNameInfo->usage );
 460         }
 461         else
 462         {
 463             if (pTypeInfo->resloader)
 464                 loader = (RESOURCEHANDLER16)pTypeInfo->resloader;
 465             else /* this is really bad */
 466             {
 467                 fprintf( stderr, "[%04x]: Missing resource handler!!!...\n", hModule);
 468                 loader = NE_DefResourceHandler;
 469             }
 470
 471             /* Finally call resource loader */
 472
 473             if ((pNameInfo->handle = loader(pNameInfo->handle, hModule, hRsrc)))
 474             {
 475                 pNameInfo->usage++;
 476                 pNameInfo->flags |= NE_SEGFLAGS_LOADED;
 477             }
 478         }
 479         return pNameInfo->handle;
 480     }
 481     return 0;
 482 }
 483
 484
 485 /**********************************************************************
 486  *          LockResource16    (KERNEL.62)
 487  */
 488 /* 16-bit version */
 489 SEGPTR WINAPI WIN16_LockResource16( HGLOBAL16 handle )
 490 {
 491     TRACE( resource, "handle=%04x\n", handle );
 492     if (!handle) return (SEGPTR)0;
 493
 494     /* May need to reload the resource if discarded */
 495
 496     return (SEGPTR)WIN16_GlobalLock16( handle );
 497 }
 498
 499 /* Winelib 16-bit version */
 500 LPVOID WINAPI LockResource16( HGLOBAL16 handle )
 501 {
 502     assert( !__winelib );  /* Can't use Win16 resource functions in Winelib */
 503
 504     return (LPVOID)PTR_SEG_TO_LIN( WIN16_LockResource16( handle ) );
 505 }
 506
 507
 508 /**********************************************************************
 509  *          FreeResource16    (KERNEL.63)
 510  */
 511 BOOL16 WINAPI FreeResource16( HGLOBAL16 handle )
 512 {
 513     NE_TYPEINFO *pTypeInfo;
 514     NE_NAMEINFO *pNameInfo;
 515     WORD count;
 516     HMODULE16 hModule  = GetExePtr( handle );
 517     NE_MODULE *pModule = MODULE_GetPtr16( hModule );
 518
 519     if (!handle || !pModule || !pModule->res_table) return handle;
 520
 521     TRACE(resource, "handle=%04x\n", handle );
 522
 523     assert( !__winelib );  /* Can't use Win16 resource functions in Winelib */
 524
 525     pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->res_table + 2);
 526     while (pTypeInfo->type_id)
 527     {
 528         pNameInfo = (NE_NAMEINFO *)(pTypeInfo + 1);
 529         for (count = pTypeInfo->count; count > 0; count--)
 530         {
 531             if (pNameInfo->handle == handle)
 532             {
 533                 if (pNameInfo->usage > 0) pNameInfo->usage--;
 534                 if (pNameInfo->usage == 0)
 535                 {
 536                     GlobalFree16( pNameInfo->handle );
 537                     pNameInfo->handle = 0;
 538                     pNameInfo->flags &= ~NE_SEGFLAGS_LOADED;
 539                 }
 540                 return 0;
 541             }
 542             pNameInfo++;
 543         }
 544         pTypeInfo = (NE_TYPEINFO *)pNameInfo;
 545     }
 546
 547     TRACE(resource, "[%04x]: no intrinsic resource for %04x, assuming DirectResAlloc()!\n",
 548                  hModule, handle );
 549     GlobalFree16( handle );
 550     return handle;
 551 }