loader/ne_resource.c

   1 #ifndef WINELIB
   2 /*
   3  *
   4  * Copyright 1993 Robert J. Amstadt
   5  * Copyright 1995 Alexandre Julliard
   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 "arch.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
  26 /***********************************************************************
  27  *           NE_FindNameTableId
  28  *
  29  * Find the type and resource id from their names.
  30  * Return value is MAKELONG( typeId, resId ), or 0 if not found.
  31  */
  32 static DWORD NE_FindNameTableId( HMODULE16 hModule, SEGPTR typeId, SEGPTR resId )
  33 {
  34     NE_MODULE *pModule;
  35     NE_TYPEINFO *pTypeInfo;
  36     NE_NAMEINFO *pNameInfo;
  37     HGLOBAL16 handle;
  38     WORD *p;
  39     DWORD ret = 0;
  40     int count;
  41
  42     if (!(pModule = MODULE_GetPtr( hModule ))) return 0;
  43     pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->res_table + 2);
  44     for (; pTypeInfo->type_id != 0;
  45              pTypeInfo = (NE_TYPEINFO *)((char*)(pTypeInfo+1) +
  46                                        pTypeInfo->count * sizeof(NE_NAMEINFO)))
  47     {
  48         if (pTypeInfo->type_id != 0x800f) continue;
  49         pNameInfo = (NE_NAMEINFO *)(pTypeInfo + 1);
  50         for (count = pTypeInfo->count; count > 0; count--, pNameInfo++)
  51         {
  52             dprintf_resource( stddeb, "NameTable entry: type=%04x id=%04x\n",
  53                               pTypeInfo->type_id, pNameInfo->id );
  54             handle = LoadResource16( hModule,
  55                                    (HRSRC16)((int)pNameInfo - (int)pModule) );
  56             for(p = (WORD*)LockResource16(handle); p && *p; p = (WORD *)((char*)p+*p))
  57             {
  58                 dprintf_resource( stddeb,"  type=%04x '%s' id=%04x '%s'\n",
  59                                   p[1], (char *)(p+3), p[2],
  60                                   (char *)(p+3)+strlen((char *)(p+3))+1 );
  61                 /* Check for correct type */
  62
  63                 if (p[1] & 0x8000)
  64                 {
  65                     if (!HIWORD(typeId)) continue;
  66                     if (lstrcmpi32A( (char *)PTR_SEG_TO_LIN(typeId),
  67                                      (char *)(p + 3) )) continue;
  68                 }
  69                 else if (HIWORD(typeId) || ((typeId & ~0x8000)!= p[1]))
  70                   continue;
  71
  72                 /* Now check for the id */
  73
  74                 if (p[2] & 0x8000)
  75                 {
  76                     if (!HIWORD(resId)) continue;
  77                     if (lstrcmpi32A( (char *)PTR_SEG_TO_LIN(resId),
  78                                (char*)(p+3)+strlen((char*)(p+3))+1 )) continue;
  79
  80                 }
  81                 else if (HIWORD(resId) || ((resId & ~0x8000) != p[2]))
  82                   continue;
  83
  84                 /* If we get here, we've found the entry */
  85
  86                 dprintf_resource( stddeb, "  Found!\n" );
  87                 ret = MAKELONG( p[1], p[2] );
  88                 break;
  89             }
  90             FreeResource16( handle );
  91             if (ret) return ret;
  92         }
  93     }
  94     return 0;
  95 }
  96
  97
  98 /***********************************************************************
  99  *           NE_FindResourceFromType
 100  *
 101  * Find a resource once the type info structure has been found.
 102  */
 103 static HRSRC16 NE_FindResourceFromType( NE_MODULE *pModule,
 104                                         NE_TYPEINFO *pTypeInfo, SEGPTR resId )
 105 {
 106     BYTE *p;
 107     int count;
 108     NE_NAMEINFO *pNameInfo = (NE_NAMEINFO *)(pTypeInfo + 1);
 109
 110     if (HIWORD(resId) != 0)  /* Named resource */
 111     {
 112         char *str = (char *)PTR_SEG_TO_LIN( resId );
 113         BYTE len = strlen( str );
 114         for (count = pTypeInfo->count; count > 0; count--, pNameInfo++)
 115         {
 116             if (pNameInfo->id & 0x8000) continue;
 117             p = (BYTE *)pModule + pModule->res_table + pNameInfo->id;
 118             if ((*p == len) && !lstrncmpi32A( p+1, str, len ))
 119                 return (HRSRC16)((int)pNameInfo - (int)pModule);
 120         }
 121     }
 122     else  /* Numeric resource id */
 123     {
 124         WORD id = LOWORD(resId) | 0x8000;
 125         for (count = pTypeInfo->count; count > 0; count--, pNameInfo++)
 126             if (pNameInfo->id == id)
 127               return (HRSRC16)((int)pNameInfo - (int)pModule);
 128     }
 129     return 0;
 130 }
 131
 132
 133 /***********************************************************************
 134  *           NE_FindResource
 135  */
 136 HRSRC16 NE_FindResource( HMODULE16 hModule, SEGPTR typeId, SEGPTR resId )
 137 {
 138     NE_TYPEINFO *pTypeInfo;
 139     HRSRC16 hRsrc;
 140
 141     NE_MODULE *pModule = MODULE_GetPtr( hModule );
 142     if (!pModule || !pModule->res_table) return 0;
 143     pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->res_table + 2);
 144
 145     if (HIWORD(typeId) || HIWORD(resId))
 146     {
 147         /* Search the names in the nametable */
 148         DWORD id = NE_FindNameTableId( hModule, typeId, resId );
 149         if (id)  /* found */
 150         {
 151             typeId = LOWORD(id);
 152             resId  = HIWORD(id);
 153         }
 154     }
 155
 156     if (HIWORD(typeId) != 0)  /* Named type */
 157     {
 158         char *str = (char *)PTR_SEG_TO_LIN( typeId );
 159         BYTE len = strlen( str );
 160         while (pTypeInfo->type_id)
 161         {
 162             if (!(pTypeInfo->type_id & 0x8000))
 163             {
 164                 BYTE *p = (BYTE*)pModule+pModule->res_table+pTypeInfo->type_id;
 165                 if ((*p == len) && !lstrncmpi32A( p+1, str, len ))
 166                 {
 167                     dprintf_resource( stddeb, "  Found type '%s'\n", str );
 168                     hRsrc = NE_FindResourceFromType(pModule, pTypeInfo, resId);
 169                     if (hRsrc)
 170                     {
 171                         dprintf_resource( stddeb, "    Found id %08lx\n", resId );
 172                         return hRsrc;
 173                     }
 174                     dprintf_resource( stddeb, "    Not found, going on\n" );
 175                 }
 176             }
 177             dprintf_resource( stddeb, "  Skipping type %04x\n",
 178                               pTypeInfo->type_id );
 179             pTypeInfo = (NE_TYPEINFO *)((char*)(pTypeInfo+1) +
 180                                        pTypeInfo->count * sizeof(NE_NAMEINFO));
 181         }
 182     }
 183     else  /* Numeric type id */
 184     {
 185         WORD id = LOWORD(typeId) | 0x8000;
 186         while (pTypeInfo->type_id)
 187         {
 188             if (pTypeInfo->type_id == id)
 189             {
 190                 dprintf_resource( stddeb, "  Found type %04x\n", id );
 191                 hRsrc = NE_FindResourceFromType( pModule, pTypeInfo, resId );
 192                 if (hRsrc)
 193                 {
 194                     dprintf_resource( stddeb, "    Found id %08lx\n", resId );
 195                     return hRsrc;
 196                 }
 197                 dprintf_resource( stddeb, "    Not found, going on\n" );
 198             }
 199             dprintf_resource( stddeb, "  Skipping type %04x\n",
 200                               pTypeInfo->type_id );
 201             pTypeInfo = (NE_TYPEINFO *)((char*)(pTypeInfo+1) +
 202                                        pTypeInfo->count * sizeof(NE_NAMEINFO));
 203         }
 204     }
 205     return 0;
 206 }
 207
 208
 209
 210 /***********************************************************************
 211  *           NE_AllocResource
 212  */
 213 HGLOBAL16 NE_AllocResource( HMODULE16 hModule, HRSRC16 hRsrc, DWORD size )
 214 {
 215     NE_NAMEINFO *pNameInfo=NULL;
 216     WORD sizeShift;
 217
 218     NE_MODULE *pModule = MODULE_GetPtr( hModule );
 219     if (!pModule || !pModule->res_table) return 0;
 220     sizeShift = *(WORD *)((char *)pModule + pModule->res_table);
 221 #ifndef WINELIB
 222     pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);
 223 #endif
 224     if (size < (DWORD)pNameInfo->length << sizeShift)
 225         size = (DWORD)pNameInfo->length << sizeShift;
 226     return GLOBAL_Alloc( GMEM_FIXED, size, hModule, FALSE, FALSE, FALSE );
 227 }
 228
 229
 230 /***********************************************************************
 231  *           NE_AccessResource
 232  */
 233 int NE_AccessResource( HMODULE16 hModule, HRSRC16 hRsrc )
 234 {
 235     NE_NAMEINFO *pNameInfo=NULL;
 236     HFILE32 fd;
 237
 238     NE_MODULE *pModule = MODULE_GetPtr( hModule );
 239     if (!pModule || !pModule->res_table) return -1;
 240 #ifndef WINELIB
 241     pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);
 242 #endif
 243
 244     if ((fd = _lopen32( NE_MODULE_NAME(pModule), OF_READ )) != -1)
 245     {
 246         WORD sizeShift = *(WORD *)((char *)pModule + pModule->res_table);
 247         _llseek32( fd, (int)pNameInfo->offset << sizeShift, SEEK_SET );
 248     }
 249     return fd;
 250 }
 251
 252
 253 /***********************************************************************
 254  *           NE_SizeofResource
 255  */
 256 DWORD NE_SizeofResource( HMODULE16 hModule, HRSRC16 hRsrc )
 257 {
 258     NE_NAMEINFO *pNameInfo=NULL;
 259     WORD sizeShift;
 260
 261     NE_MODULE *pModule = MODULE_GetPtr( hModule );
 262     if (!pModule || !pModule->res_table) return 0;
 263     sizeShift = *(WORD *)((char *)pModule + pModule->res_table);
 264 #ifndef WINELIB
 265     pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);
 266 #endif
 267     return (DWORD)pNameInfo->length << sizeShift;
 268 }
 269
 270
 271 /***********************************************************************
 272  *           NE_LoadResource
 273  */
 274 HGLOBAL16 NE_LoadResource( HMODULE16 hModule,  HRSRC16 hRsrc )
 275 {
 276     NE_NAMEINFO *pNameInfo=NULL;
 277     WORD sizeShift;
 278     int fd;
 279
 280     NE_MODULE *pModule = MODULE_GetPtr( hModule );
 281     if (!pModule || !pModule->res_table) return 0;
 282 #ifndef WINELIB
 283     pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);
 284 #endif
 285     if (pNameInfo->handle)
 286     {
 287         pNameInfo->usage++;
 288         dprintf_resource( stddeb, "  Already loaded, new count=%d\n",
 289                           pNameInfo->usage );
 290         return pNameInfo->handle;
 291     }
 292     sizeShift = *(WORD *)((char *)pModule + pModule->res_table);
 293     dprintf_resource( stddeb, "  Loading, pos=%d, len=%d\n",
 294                       (int)pNameInfo->offset << sizeShift,
 295                       (int)pNameInfo->length << sizeShift );
 296     if ((fd = MODULE_OpenFile( hModule )) == -1) return 0;
 297     pNameInfo->handle = NE_AllocResource( hModule, hRsrc, 0 );
 298     pNameInfo->usage = 1;
 299     lseek( fd, (int)pNameInfo->offset << sizeShift, SEEK_SET );
 300     read( fd, GlobalLock16( pNameInfo->handle ),
 301           (int)pNameInfo->length << sizeShift );
 302     return pNameInfo->handle;
 303 }
 304
 305
 306 /***********************************************************************
 307  *           NE_LockResource
 308  */
 309 SEGPTR NE_LockResource( HMODULE16 hModule, HGLOBAL16 handle )
 310 {
 311     /* May need to reload the resource if discarded */
 312
 313     return (SEGPTR)WIN16_GlobalLock16( handle );
 314 }
 315
 316
 317 /***********************************************************************
 318  *           NE_FreeResource
 319  */
 320 BOOL32 NE_FreeResource( HMODULE16 hModule, HGLOBAL16 handle )
 321 {
 322     NE_TYPEINFO *pTypeInfo;
 323     NE_NAMEINFO *pNameInfo;
 324     WORD count;
 325
 326     NE_MODULE *pModule = MODULE_GetPtr( hModule );
 327     if (!pModule || !pModule->res_table) return handle;
 328     pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->res_table + 2);
 329     while (pTypeInfo->type_id)
 330     {
 331         pNameInfo = (NE_NAMEINFO *)(pTypeInfo + 1);
 332         for (count = pTypeInfo->count; count > 0; count--)
 333         {
 334             if (pNameInfo->handle == handle)
 335             {
 336                 if (pNameInfo->usage > 0) pNameInfo->usage--;
 337                 if (pNameInfo->usage == 0)
 338                 {
 339                     GlobalFree16( pNameInfo->handle );
 340                     pNameInfo->handle = 0;
 341                 }
 342                 return 0;
 343             }
 344             pNameInfo++;
 345         }
 346         pTypeInfo = (NE_TYPEINFO *)pNameInfo;
 347     }
 348     fprintf( stderr, "NE_FreeResource: %04x %04x not found!\n", hModule, handle );
 349     return handle;
 350 }
 351 #endif /* WINELIB */