loader/ne_resource.c

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