if1632/builtin.c

   1 /*
   2  * Built-in modules
   3  *
   4  * Copyright 1996 Alexandre Julliard
   5  */
   6
   7 #include <assert.h>
   8 #include <ctype.h>
   9 #include <string.h>
  10 #include <stdio.h>
  11 #include "winbase.h"
  12 #include "wine/winbase16.h"
  13 #include "wine/winestring.h"
  14 #include "builtin16.h"
  15 #include "global.h"
  16 #include "heap.h"
  17 #include "module.h"
  18 #include "miscemu.h"
  19 #include "stackframe.h"
  20 #include "selectors.h"
  21 #include "task.h"
  22 #include "debugtools.h"
  23 #include "toolhelp.h"
  24
  25 DEFAULT_DEBUG_CHANNEL(module);
  26
  27 /* Table of all built-in DLLs */
  28
  29 #define MAX_DLLS 50
  30
  31 static const BUILTIN16_DESCRIPTOR *builtin_dlls[MAX_DLLS];
  32 static int nb_dlls;
  33
  34
  35 /* patch all the flat cs references of the code segment if necessary */
  36 inline static void patch_code_segment( void *code_segment )
  37 {
  38 #ifdef __i386__
  39     CALLFROM16 *call = code_segment;
  40     if (call->flatcs == __get_cs()) return;  /* nothing to patch */
  41     while (call->pushl == 0x68)
  42     {
  43         call->flatcs = __get_cs();
  44         call++;
  45     }
  46 #endif
  47 }
  48
  49
  50 /***********************************************************************
  51  *           BUILTIN_DoLoadModule16
  52  *
  53  * Load a built-in Win16 module. Helper function for BUILTIN_LoadModule.
  54  */
  55 static HMODULE16 BUILTIN_DoLoadModule16( const BUILTIN16_DESCRIPTOR *descr )
  56 {
  57     NE_MODULE *pModule;
  58     int minsize;
  59     SEGTABLEENTRY *pSegTable;
  60     HMODULE16 hModule;
  61
  62     hModule = GLOBAL_CreateBlock( GMEM_MOVEABLE, descr->module_start,
  63                                   descr->module_size, 0,
  64                                   FALSE, FALSE, FALSE );
  65     if (!hModule) return 0;
  66     FarSetOwner16( hModule, hModule );
  67
  68     pModule = (NE_MODULE *)GlobalLock16( hModule );
  69     pModule->self = hModule;
  70     /* NOTE: (Ab)use the hRsrcMap parameter for resource data pointer */
  71     pModule->hRsrcMap = (void *)descr->rsrc;
  72
  73     TRACE( "Built-in %s: hmodule=%04x\n", descr->name, hModule );
  74
  75     /* Allocate the code segment */
  76
  77     pSegTable = NE_SEG_TABLE( pModule );
  78     pSegTable->hSeg = GLOBAL_CreateBlock( GMEM_FIXED, descr->code_start,
  79                                           pSegTable->minsize, hModule, TRUE, TRUE, FALSE );
  80     if (!pSegTable->hSeg) return 0;
  81     patch_code_segment( descr->code_start );
  82     pSegTable++;
  83
  84     /* Allocate the data segment */
  85
  86     minsize = pSegTable->minsize ? pSegTable->minsize : 0x10000;
  87     minsize += pModule->heap_size;
  88     if (minsize > 0x10000) minsize = 0x10000;
  89     pSegTable->hSeg = GLOBAL_Alloc( GMEM_FIXED, minsize,
  90                                         hModule, FALSE, FALSE, FALSE );
  91     if (!pSegTable->hSeg) return 0;
  92     if (pSegTable->minsize) memcpy( GlobalLock16( pSegTable->hSeg ),
  93                                     descr->data_start, pSegTable->minsize);
  94     if (pModule->heap_size)
  95         LocalInit16( GlobalHandleToSel16(pSegTable->hSeg),
  96                 pSegTable->minsize, minsize );
  97
  98     if (descr->rsrc) NE_InitResourceHandler(hModule);
  99
 100     NE_RegisterModule( pModule );
 101     return hModule;
 102 }
 103
 104
 105 /***********************************************************************
 106  *           BUILTIN_LoadModule
 107  *
 108  * Load a built-in module.
 109  */
 110 HMODULE16 BUILTIN_LoadModule( LPCSTR name )
 111 {
 112     char dllname[20], *p;
 113     void *handle;
 114     int i;
 115
 116     /* Fix the name in case we have a full path and extension */
 117
 118     if ((p = strrchr( name, '\\' ))) name = p + 1;
 119     if ((p = strrchr( name, '/' ))) name = p + 1;
 120
 121     if (strlen(name) >= sizeof(dllname)-4) return (HMODULE16)2;
 122
 123     strcpy( dllname, name );
 124     p = strrchr( dllname, '.' );
 125     if (!p) strcat( dllname, ".dll" );
 126
 127     for (i = 0; i < nb_dlls; i++)
 128     {
 129         const BUILTIN16_DESCRIPTOR *descr = builtin_dlls[i];
 130         NE_MODULE *pModule = (NE_MODULE *)descr->module_start;
 131         OFSTRUCT *pOfs = (OFSTRUCT *)((LPBYTE)pModule + pModule->fileinfo);
 132         if (!strcasecmp( pOfs->szPathName, dllname ))
 133             return BUILTIN_DoLoadModule16( descr );
 134     }
 135
 136     if ((handle = BUILTIN32_dlopen( dllname )))
 137     {
 138         for (i = 0; i < nb_dlls; i++)
 139         {
 140             const BUILTIN16_DESCRIPTOR *descr = builtin_dlls[i];
 141             NE_MODULE *pModule = (NE_MODULE *)descr->module_start;
 142             OFSTRUCT *pOfs = (OFSTRUCT *)((LPBYTE)pModule + pModule->fileinfo);
 143             if (!strcasecmp( pOfs->szPathName, dllname ))
 144                 return BUILTIN_DoLoadModule16( descr );
 145         }
 146         ERR( "loaded .so but dll %s still not found\n", dllname );
 147         BUILTIN32_dlclose( handle );
 148     }
 149
 150     return (HMODULE16)2;
 151 }
 152
 153
 154 /***********************************************************************
 155  *           BUILTIN_GetEntryPoint16
 156  *
 157  * Return the ordinal, name, and type info corresponding to a CS:IP address.
 158  * This is used only by relay debugging.
 159  */
 160 LPCSTR BUILTIN_GetEntryPoint16( STACK16FRAME *frame, LPSTR name, WORD *pOrd )
 161 {
 162     WORD i, max_offset;
 163     register BYTE *p;
 164     NE_MODULE *pModule;
 165     ET_BUNDLE *bundle;
 166     ET_ENTRY *entry;
 167
 168     if (!(pModule = NE_GetPtr( FarGetOwner16( GlobalHandle16( frame->module_cs ) ))))
 169         return NULL;
 170
 171     max_offset = 0;
 172     *pOrd = 0;
 173     bundle = (ET_BUNDLE *)((BYTE *)pModule + pModule->entry_table);
 174     do
 175     {
 176         entry = (ET_ENTRY *)((BYTE *)bundle+6);
 177         for (i = bundle->first + 1; i <= bundle->last; i++)
 178         {
 179             if ((entry->offs < frame->entry_ip)
 180             && (entry->segnum == 1) /* code segment ? */
 181             && (entry->offs >= max_offset))
 182             {
 183                 max_offset = entry->offs;
 184                 *pOrd = i;
 185             }
 186             entry++;
 187         }
 188     } while ( (bundle->next)
 189            && (bundle = (ET_BUNDLE *)((BYTE *)pModule+bundle->next)));
 190
 191     /* Search for the name in the resident names table */
 192     /* (built-in modules have no non-resident table)   */
 193
 194     p = (BYTE *)pModule + pModule->name_table;
 195     while (*p)
 196     {
 197         p += *p + 1 + sizeof(WORD);
 198         if (*(WORD *)(p + *p + 1) == *pOrd) break;
 199     }
 200
 201     sprintf( name, "%.*s.%d: %.*s",
 202              *((BYTE *)pModule + pModule->name_table),
 203              (char *)pModule + pModule->name_table + 1,
 204              *pOrd, *p, (char *)(p + 1) );
 205
 206     /* Retrieve type info string */
 207     return *(LPCSTR *)((LPBYTE)PTR_SEG_OFF_TO_LIN( frame->module_cs, frame->callfrom_ip ) + 4);
 208 }
 209
 210
 211 /***********************************************************************
 212  *           BUILTIN_RegisterDLL
 213  *
 214  * Register a built-in DLL descriptor.
 215  */
 216 void BUILTIN_RegisterDLL( const BUILTIN16_DESCRIPTOR *descr )
 217 {
 218     assert( nb_dlls < MAX_DLLS );
 219     builtin_dlls[nb_dlls++] = descr;
 220 }