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 <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 "callback.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, LPCSTR typeId, LPCSTR 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( typeId,
  66                                      (char *)(p + 3) )) continue;
  67                 }
  68                 else if (HIWORD(typeId) || (((DWORD)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( resId,
  77                                (char*)(p+3)+strlen((char*)(p+3))+1 )) continue;
  78
  79                 }
  80                 else if (HIWORD(resId) || (((DWORD)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, LPCSTR typeId )
 103 {
 104     /* start from pTypeInfo */
 105
 106     if (HIWORD(typeId) != 0)  /* Named type */
 107     {
 108         LPCSTR str = 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, LPCSTR 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         LPCSTR str = 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     HANDLE32 fd;
 186     NE_MODULE* pModule = NE_GetPtr( hModule );
 187     if (pModule && (fd = NE_OpenFile( pModule )) >= 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             DWORD res;
 204             SetFilePointer( fd, (int)pNameInfo->offset << sizeShift, NULL, SEEK_SET );
 205             ReadFile( fd, GlobalLock16( handle ), (int)pNameInfo->length << sizeShift,
 206                       &res, NULL );
 207         }
 208         return handle;
 209     }
 210     return (HGLOBAL16)0;
 211 }
 212
 213 /***********************************************************************
 214  *           NE_InitResourceHandler
 215  *
 216  * Fill in 'resloader' fields in the resource table.
 217  */
 218 BOOL32 NE_InitResourceHandler( HMODULE16 hModule )
 219 {
 220     NE_MODULE *pModule = NE_GetPtr( hModule );
 221     NE_TYPEINFO *pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->res_table + 2);
 222
 223     FARPROC16 handler = MODULE_GetWndProcEntry16("DefResourceHandler");
 224
 225     TRACE(resource,"InitResourceHandler[%04x]\n", hModule );
 226
 227     while(pTypeInfo->type_id)
 228     {
 229         pTypeInfo->resloader = handler;
 230         pTypeInfo = NEXT_TYPEINFO(pTypeInfo);
 231     }
 232     return TRUE;
 233 }
 234
 235
 236 /**********************************************************************
 237  *      SetResourceHandler      (KERNEL.43)
 238  */
 239 FARPROC16 WINAPI SetResourceHandler( HMODULE16 hModule, SEGPTR typeId,
 240                                      FARPROC16 resourceHandler )
 241 {
 242     FARPROC16 prevHandler = NULL;
 243     NE_MODULE *pModule = NE_GetPtr( hModule );
 244     NE_TYPEINFO *pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->res_table + 2);
 245
 246     if (!pModule || !pModule->res_table) return NULL;
 247
 248     TRACE( resource, "module=%04x type=%s\n",
 249            hModule, debugres_a(PTR_SEG_TO_LIN(typeId)) );
 250
 251     for (;;)
 252     {
 253         if (!(pTypeInfo = NE_FindTypeSection( pModule, pTypeInfo, PTR_SEG_TO_LIN(typeId) )))
 254             break;
 255         prevHandler = pTypeInfo->resloader;
 256         pTypeInfo->resloader = resourceHandler;
 257         pTypeInfo = NEXT_TYPEINFO(pTypeInfo);
 258     }
 259     return prevHandler;
 260 }
 261
 262
 263 /**********************************************************************
 264  *          NE_FindResource
 265  */
 266 HRSRC16 NE_FindResource( NE_MODULE *pModule, LPCSTR name, LPCSTR type )
 267 {
 268     NE_TYPEINFO *pTypeInfo;
 269     HRSRC16 hRsrc;
 270
 271     if (!pModule || !pModule->res_table) return 0;
 272
 273     TRACE( resource, "module=%04x name=%s type=%s\n",
 274            pModule->self, debugres_a(PTR_SEG_TO_LIN(name)),
 275            debugres_a(PTR_SEG_TO_LIN(type)) );
 276
 277     if (HIWORD(name))  /* Check for '#xxx' name */
 278     {
 279         LPCSTR ptr = name;
 280         if (ptr[0] == '#')
 281             if (!(name = (LPCSTR)atoi( ptr + 1 )))
 282             {
 283                 WARN(resource, "Incorrect resource name: %s\n", ptr);
 284                 return 0;
 285             }
 286     }
 287
 288     if (HIWORD(type))  /* Check for '#xxx' type */
 289     {
 290         LPCSTR ptr = type;
 291         if (ptr[0] == '#')
 292             if (!(type = (LPCSTR)atoi( ptr + 1 )))
 293             {
 294                 WARN(resource, "Incorrect resource type: %s\n", ptr);
 295                 return 0;
 296             }
 297     }
 298
 299     if (HIWORD(type) || HIWORD(name))
 300     {
 301         DWORD id = NE_FindNameTableId( pModule, type, name );
 302         if (id)  /* found */
 303         {
 304             type = (LPCSTR)(int)LOWORD(id);
 305             name = (LPCSTR)(int)HIWORD(id);
 306         }
 307     }
 308
 309     pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->res_table + 2);
 310
 311     for (;;)
 312     {
 313         if (!(pTypeInfo = NE_FindTypeSection( pModule, pTypeInfo, type )))
 314             break;
 315         if ((hRsrc = NE_FindResourceFromType(pModule, pTypeInfo, name)))
 316         {
 317             TRACE(resource, "    Found id %08lx\n", (DWORD)name );
 318             return hRsrc;
 319         }
 320         TRACE(resource, "    Not found, going on\n" );
 321         pTypeInfo = NEXT_TYPEINFO(pTypeInfo);
 322     }
 323
 324     WARN(resource, "failed!\n");
 325     return 0;
 326 }
 327
 328
 329 /**********************************************************************
 330  *          AllocResource    (KERNEL.66)
 331  */
 332 HGLOBAL16 WINAPI AllocResource( HMODULE16 hModule, HRSRC16 hRsrc, DWORD size)
 333 {
 334     NE_NAMEINFO *pNameInfo=NULL;
 335     WORD sizeShift;
 336
 337     NE_MODULE *pModule = NE_GetPtr( hModule );
 338     if (!pModule || !pModule->res_table || !hRsrc) return 0;
 339
 340     TRACE( resource, "module=%04x res=%04x size=%ld\n", hModule, hRsrc, size );
 341
 342     sizeShift = *(WORD *)((char *)pModule + pModule->res_table);
 343     pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);
 344     if (size < (DWORD)pNameInfo->length << sizeShift)
 345         size = (DWORD)pNameInfo->length << sizeShift;
 346     return GLOBAL_Alloc( GMEM_FIXED, size, hModule, FALSE, FALSE, FALSE );
 347 }
 348
 349
 350 /**********************************************************************
 351  *      DirectResAlloc    (KERNEL.168)
 352  *
 353  * Check Schulman, p. 232 for details
 354  */
 355 HGLOBAL16 WINAPI DirectResAlloc( HINSTANCE16 hInstance, WORD wType,
 356                                  UINT16 wSize )
 357 {
 358     TRACE(resource,"(%04x,%04x,%04x)\n",
 359                      hInstance, wType, wSize );
 360     if (!(hInstance = GetExePtr( hInstance ))) return 0;
 361     if(wType != 0x10)   /* 0x10 is the only observed value, passed from
 362                            CreateCursorIndirect. */
 363         TRACE(resource, "(wType=%x)\n", wType);
 364     return GLOBAL_Alloc(GMEM_MOVEABLE, wSize, hInstance, FALSE, FALSE, FALSE);
 365 }
 366
 367
 368 /**********************************************************************
 369  *          NE_AccessResource
 370  */
 371 INT16 NE_AccessResource( NE_MODULE *pModule, HRSRC16 hRsrc )
 372 {
 373     HFILE16 fd;
 374
 375     if (!pModule || !pModule->res_table || !hRsrc) return -1;
 376
 377     TRACE(resource, "module=%04x res=%04x\n", pModule->self, hRsrc );
 378
 379     if ((fd = _lopen16( NE_MODULE_NAME(pModule), OF_READ )) != HFILE_ERROR16)
 380     {
 381         WORD sizeShift = *(WORD *)((char *)pModule + pModule->res_table);
 382         NE_NAMEINFO *pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);
 383         _llseek16( fd, (int)pNameInfo->offset << sizeShift, SEEK_SET );
 384     }
 385     return fd;
 386 }
 387
 388
 389 /**********************************************************************
 390  *          NE_SizeofResource
 391  */
 392 DWORD NE_SizeofResource( NE_MODULE *pModule, HRSRC16 hRsrc )
 393 {
 394     NE_NAMEINFO *pNameInfo=NULL;
 395     WORD sizeShift;
 396
 397     if (!pModule || !pModule->res_table) return 0;
 398
 399     TRACE(resource, "module=%04x res=%04x\n", pModule->self, hRsrc );
 400
 401     sizeShift = *(WORD *)((char *)pModule + pModule->res_table);
 402     pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);
 403     return (DWORD)pNameInfo->length << sizeShift;
 404 }
 405
 406
 407 /**********************************************************************
 408  *          NE_LoadResource
 409  */
 410 HGLOBAL16 NE_LoadResource( NE_MODULE *pModule, HRSRC16 hRsrc )
 411 {
 412     NE_TYPEINFO *pTypeInfo;
 413     NE_NAMEINFO *pNameInfo = NULL;
 414     int d;
 415
 416     TRACE( resource, "module=%04x res=%04x\n", pModule->self, hRsrc );
 417     if (!hRsrc || !pModule || !pModule->res_table) return 0;
 418
 419     /* First, verify hRsrc (just an offset from pModule to the needed pNameInfo) */
 420
 421     d = pModule->res_table + 2;
 422     pTypeInfo = (NE_TYPEINFO *)((char *)pModule + d);
 423     while( hRsrc > d )
 424     {
 425         if (pTypeInfo->type_id == 0)
 426                 break; /* terminal entry */
 427         d += sizeof(NE_TYPEINFO) + pTypeInfo->count * sizeof(NE_NAMEINFO);
 428         if (hRsrc < d)
 429         {
 430             if( ((d - hRsrc)%sizeof(NE_NAMEINFO)) == 0 )
 431             {
 432                 pNameInfo = (NE_NAMEINFO *)(((char *)pModule) + hRsrc);
 433                 break;
 434             }
 435             else
 436                 break; /* NE_NAMEINFO boundary mismatch */
 437         }
 438         pTypeInfo = (NE_TYPEINFO *)(((char *)pModule) + d);
 439     }
 440
 441     if (pNameInfo)
 442     {
 443         if (pNameInfo->handle
 444             && !(GlobalFlags16(pNameInfo->handle) & GMEM_DISCARDED))
 445         {
 446             pNameInfo->usage++;
 447             TRACE(resource, "  Already loaded, new count=%d\n",
 448                               pNameInfo->usage );
 449         }
 450         else
 451         {
 452             if (pTypeInfo->resloader)
 453                 pNameInfo->handle = Callbacks->CallResourceHandlerProc(
 454                     pTypeInfo->resloader, pNameInfo->handle, pModule->self, hRsrc );
 455             else /* this is really bad */
 456             {
 457                 ERR(resource, "[%04x]: Missing resource handler!\n", pModule->self);
 458                 pNameInfo->handle = NE_DefResourceHandler(
 459                                          pNameInfo->handle, pModule->self, hRsrc );
 460             }
 461
 462             if (pNameInfo->handle)
 463             {
 464                 pNameInfo->usage++;
 465                 pNameInfo->flags |= NE_SEGFLAGS_LOADED;
 466             }
 467         }
 468         return pNameInfo->handle;
 469     }
 470     return 0;
 471 }
 472
 473
 474 /**********************************************************************
 475  *          NE_FreeResource
 476  */
 477 BOOL16 NE_FreeResource( NE_MODULE *pModule, HGLOBAL16 handle )
 478 {
 479     NE_TYPEINFO *pTypeInfo;
 480     NE_NAMEINFO *pNameInfo;
 481     WORD count;
 482
 483     if (!handle || !pModule || !pModule->res_table) return handle;
 484
 485     TRACE(resource, "handle=%04x\n", handle );
 486
 487     pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->res_table + 2);
 488     while (pTypeInfo->type_id)
 489     {
 490         pNameInfo = (NE_NAMEINFO *)(pTypeInfo + 1);
 491         for (count = pTypeInfo->count; count > 0; count--)
 492         {
 493             if (pNameInfo->handle == handle)
 494             {
 495                 if (pNameInfo->usage > 0) pNameInfo->usage--;
 496                 if (pNameInfo->usage == 0)
 497                 {
 498                     GlobalFree16( pNameInfo->handle );
 499                     pNameInfo->handle = 0;
 500                     pNameInfo->flags &= ~NE_SEGFLAGS_LOADED;
 501                 }
 502                 return 0;
 503             }
 504             pNameInfo++;
 505         }
 506         pTypeInfo = (NE_TYPEINFO *)pNameInfo;
 507     }
 508
 509     TRACE(resource, "[%04x]: no intrinsic resource for %04x, assuming DirectResAlloc()!\n",
 510           pModule->self, handle );
 511     GlobalFree16( handle );
 512     return handle;
 513 }