loader/ne_resource.c

   1 #ifndef WINELIB
   2 /*
   3  *
   4  * Copyright 1993 Robert J. Amstadt
   5  * Copyright 1995 Alexandre Julliard
   6  *           1997 Alex Korobka
   7  */
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <sys/types.h>
  13 #include <sys/stat.h>
  14 #include <fcntl.h>
  15 #include <unistd.h>
  16 #include "windows.h"
  17 #include "global.h"
  18 #include "ldt.h"
  19 #include "module.h"
  20 #include "neexe.h"
  21 #include "resource.h"
  22 #include "stddebug.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             dprintf_resource( stddeb, "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                 dprintf_resource( stddeb,"  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                 dprintf_resource( stddeb, "  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                     dprintf_resource( stddeb, "  Found type '%s'\n", str );
 118                     return pTypeInfo;
 119                 }
 120             }
 121             dprintf_resource( stddeb, "  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                 dprintf_resource( stddeb, "  Found type %04x\n", id );
 133                 return pTypeInfo;
 134             }
 135             dprintf_resource( stddeb, "  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_GetPtr( 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         dprintf_resource( stddeb, "NEResourceHandler: 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 = NE_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_GetPtr( hModule );
 219     NE_TYPEINFO *pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->res_table + 2);
 220
 221     dprintf_resource(stddeb,"InitResourceHandler[%04x]\n", hModule );
 222
 223     while(pTypeInfo->type_id)
 224     {
 225         pTypeInfo->resloader = (DWORD)&NE_DefResourceHandler;
 226         pTypeInfo = NEXT_TYPEINFO(pTypeInfo);
 227     }
 228     return TRUE;
 229 }
 230
 231 /***********************************************************************
 232  *           NE_SetResourceHandler
 233  */
 234 FARPROC32 NE_SetResourceHandler( HMODULE16 hModule, SEGPTR typeId,
 235                                  FARPROC32 resourceHandler )
 236 {
 237     NE_MODULE *pModule = MODULE_GetPtr( hModule );
 238     NE_TYPEINFO *pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->res_table + 2);
 239     FARPROC32  prevHandler = NULL;
 240
 241     do
 242     {
 243         pTypeInfo = NE_FindTypeSection( pModule, pTypeInfo, typeId );
 244         if( pTypeInfo )
 245         {
 246             prevHandler = (FARPROC32)pTypeInfo->resloader;
 247             pTypeInfo->resloader = (DWORD)resourceHandler;
 248             pTypeInfo = NEXT_TYPEINFO(pTypeInfo);
 249         }
 250     } while( pTypeInfo );
 251     return prevHandler;
 252 }
 253
 254 /***********************************************************************
 255  *           NE_FindResource
 256  */
 257 HRSRC16 NE_FindResource( HMODULE16 hModule, SEGPTR typeId, SEGPTR resId )
 258 {
 259     NE_TYPEINFO *pTypeInfo;
 260     HRSRC16 hRsrc;
 261
 262     NE_MODULE *pModule = MODULE_GetPtr( hModule );
 263     if (!pModule || !pModule->res_table) return 0;
 264     pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->res_table + 2);
 265
 266     if (HIWORD(typeId) || HIWORD(resId))
 267     {
 268         DWORD id = NE_FindNameTableId( pModule, typeId, resId );
 269         if (id)  /* found */
 270         {
 271             typeId = LOWORD(id);
 272             resId  = HIWORD(id);
 273         }
 274     }
 275
 276     do
 277     {
 278         pTypeInfo = NE_FindTypeSection( pModule, pTypeInfo, typeId );
 279         if( pTypeInfo )
 280         {
 281             hRsrc = NE_FindResourceFromType(pModule, pTypeInfo, resId);
 282             if( hRsrc )
 283             {
 284                 dprintf_resource( stddeb, "    Found id %08lx\n", resId );
 285                 return hRsrc;
 286             }
 287             dprintf_resource( stddeb, "    Not found, going on\n" );
 288             pTypeInfo = NEXT_TYPEINFO(pTypeInfo);
 289         }
 290     } while( pTypeInfo );
 291
 292     dprintf_resource( stddeb, "failed!\n");
 293     return 0;
 294 }
 295
 296
 297 /***********************************************************************
 298  *           NE_AllocResource
 299  */
 300 HGLOBAL16 NE_AllocResource( HMODULE16 hModule, HRSRC16 hRsrc, DWORD size )
 301 {
 302     NE_NAMEINFO *pNameInfo=NULL;
 303     WORD sizeShift;
 304
 305     NE_MODULE *pModule = MODULE_GetPtr( hModule );
 306     if (!pModule || !pModule->res_table) return 0;
 307     sizeShift = *(WORD *)((char *)pModule + pModule->res_table);
 308 #ifndef WINELIB
 309     pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);
 310 #endif
 311     if (size < (DWORD)pNameInfo->length << sizeShift)
 312         size = (DWORD)pNameInfo->length << sizeShift;
 313     return GLOBAL_Alloc( GMEM_FIXED, size, hModule, FALSE, FALSE, FALSE );
 314 }
 315
 316
 317 /***********************************************************************
 318  *           NE_AccessResource
 319  */
 320 int NE_AccessResource( HMODULE16 hModule, HRSRC16 hRsrc )
 321 {
 322     NE_NAMEINFO *pNameInfo=NULL;
 323     HFILE32 fd;
 324
 325     NE_MODULE *pModule = MODULE_GetPtr( hModule );
 326     if (!pModule || !pModule->res_table) return -1;
 327 #ifndef WINELIB
 328     pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);
 329 #endif
 330
 331     if ((fd = _lopen32( NE_MODULE_NAME(pModule), OF_READ )) != -1)
 332     {
 333         WORD sizeShift = *(WORD *)((char *)pModule + pModule->res_table);
 334         _llseek32( fd, (int)pNameInfo->offset << sizeShift, SEEK_SET );
 335     }
 336     return fd;
 337 }
 338
 339
 340 /***********************************************************************
 341  *           NE_SizeofResource
 342  */
 343 DWORD NE_SizeofResource( HMODULE16 hModule, HRSRC16 hRsrc )
 344 {
 345     NE_NAMEINFO *pNameInfo=NULL;
 346     WORD sizeShift;
 347
 348     NE_MODULE *pModule = MODULE_GetPtr( hModule );
 349     if (!pModule || !pModule->res_table) return 0;
 350     sizeShift = *(WORD *)((char *)pModule + pModule->res_table);
 351 #ifndef WINELIB
 352     pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);
 353 #endif
 354     return (DWORD)pNameInfo->length << sizeShift;
 355 }
 356
 357
 358 /***********************************************************************
 359  *           NE_LoadResource
 360  */
 361 HGLOBAL16 NE_LoadResource( HMODULE16 hModule,  HRSRC16 hRsrc )
 362 {
 363     NE_TYPEINFO *pTypeInfo;
 364     NE_NAMEINFO *pNameInfo = NULL;
 365     NE_MODULE *pModule = MODULE_GetPtr( hModule );
 366     int d;
 367
 368     if (!hRsrc || !pModule || !pModule->res_table) return 0;
 369
 370     /* First, verify hRsrc (just an offset from pModule to the needed pNameInfo) */
 371
 372     d = pModule->res_table + 2;
 373     pTypeInfo = (NE_TYPEINFO *)((char *)pModule + d);
 374 #ifndef WINELIB
 375     while( hRsrc > d )
 376     {
 377         if (pTypeInfo->type_id == 0)
 378                 break; /* terminal entry */
 379         d += sizeof(NE_TYPEINFO) + pTypeInfo->count * sizeof(NE_NAMEINFO);
 380         if (hRsrc < d)
 381         {
 382             if( ((d - hRsrc)%sizeof(NE_NAMEINFO)) == 0 )
 383             {
 384                 pNameInfo = (NE_NAMEINFO *)(((char *)pModule) + hRsrc);
 385                 break;
 386             }
 387             else
 388                 break; /* NE_NAMEINFO boundary mismatch */
 389         }
 390         pTypeInfo = (NE_TYPEINFO *)(((char *)pModule) + d);
 391     }
 392 #endif
 393     if (pNameInfo)
 394     {
 395         RESOURCEHANDLER16 __r16loader;
 396         if (pNameInfo->handle
 397             && !(GlobalFlags16(pNameInfo->handle) & GMEM_DISCARDED))
 398         {
 399             pNameInfo->usage++;
 400             dprintf_resource( stddeb, "  Already loaded, new count=%d\n",
 401                               pNameInfo->usage );
 402         }
 403         else
 404         {
 405             if (pTypeInfo->resloader)
 406                 __r16loader = (RESOURCEHANDLER16)pTypeInfo->resloader;
 407             else /* this is really bad */
 408             {
 409                 fprintf( stderr, "[%04x]: Missing resource handler!!!...\n", hModule);
 410                 __r16loader = NE_DefResourceHandler;
 411             }
 412
 413             /* Finally call resource loader */
 414
 415             if ((pNameInfo->handle = __r16loader(pNameInfo->handle, hModule, hRsrc)))
 416             {
 417                 pNameInfo->usage++;
 418                 pNameInfo->flags |= NE_SEGFLAGS_LOADED;
 419             }
 420         }
 421         return pNameInfo->handle;
 422     }
 423     return 0;
 424 }
 425
 426
 427 /***********************************************************************
 428  *           NE_LockResource
 429  */
 430 SEGPTR NE_LockResource( HMODULE16 hModule, HGLOBAL16 handle )
 431 {
 432     /* May need to reload the resource if discarded */
 433
 434     return (SEGPTR)WIN16_GlobalLock16( handle );
 435 }
 436
 437
 438 /***********************************************************************
 439  *           NE_FreeResource
 440  */
 441 BOOL32 NE_FreeResource( HMODULE16 hModule, HGLOBAL16 handle )
 442 {
 443     NE_TYPEINFO *pTypeInfo;
 444     NE_NAMEINFO *pNameInfo;
 445     WORD count;
 446
 447     NE_MODULE *pModule = MODULE_GetPtr( hModule );
 448     if (!handle || !pModule || !pModule->res_table) return handle;
 449     pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->res_table + 2);
 450     while (pTypeInfo->type_id)
 451     {
 452         pNameInfo = (NE_NAMEINFO *)(pTypeInfo + 1);
 453         for (count = pTypeInfo->count; count > 0; count--)
 454         {
 455             if (pNameInfo->handle == handle)
 456             {
 457                 if (pNameInfo->usage > 0) pNameInfo->usage--;
 458                 if (pNameInfo->usage == 0)
 459                 {
 460                     GlobalFree16( pNameInfo->handle );
 461                     pNameInfo->handle = 0;
 462                 }
 463                 return 0;
 464             }
 465             pNameInfo++;
 466         }
 467         pTypeInfo = (NE_TYPEINFO *)pNameInfo;
 468     }
 469
 470     dprintf_resource(stddeb, "NE_FreeResource[%04x]: no intrinsic resource for %04x\n",
 471                               hModule, handle );
 472     GlobalFree16( handle ); /* it could have been DirectResAlloc()'ed */
 473     return handle;
 474 }
 475 #endif /* WINELIB */