loader/ne_resource.c

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