relay32/utthunk.c

   1 /*
   2  * Win32s Universal Thunk API
   3  *
   4  * Copyright 1999 Ulrich Weigand
   5  */
   6
   7 #include "windef.h"
   8 #include "heap.h"
   9 #include "module.h"
  10 #include "selectors.h"
  11 #include "callback.h"
  12 #include "debug.h"
  13 #include "debugstr.h"
  14
  15 #pragma pack(1)
  16
  17 typedef struct
  18 {
  19     BYTE    popl_eax;
  20     BYTE    pushl;
  21     DWORD   target;
  22     BYTE    pushl_eax;
  23     BYTE    ljmp;
  24     DWORD   utglue16;
  25
  26 } UT16THUNK;
  27
  28 typedef struct
  29 {
  30     BYTE    popl_eax;
  31     BYTE    pushl;
  32     DWORD   target;
  33     BYTE    pushl_eax;
  34     BYTE    jmp;
  35     DWORD   utglue32;
  36
  37 } UT32THUNK;
  38
  39 #pragma pack(4)
  40
  41 typedef struct tagUTINFO
  42 {
  43     struct tagUTINFO  *next;
  44     HMODULE            hModule;
  45     HMODULE16          hModule16;
  46
  47     UT16THUNK          ut16;
  48     UT32THUNK          ut32;
  49
  50 } UTINFO;
  51
  52 static UTINFO *utAnchor;
  53
  54 BOOL WINAPI UTRegister( HMODULE hModule, LPSTR lpsz16BITDLL,
  55                         LPSTR lpszInitName, LPSTR lpszProcName,
  56                         FARPROC *ppfn32Thunk, FARPROC pfnUT32CallBack,
  57                         LPVOID lpBuff );
  58
  59 VOID WINAPI UTUnRegister( HMODULE hModule );
  60
  61
  62 /****************************************************************************
  63  *              UTGlue16     (WPROCS.*)
  64  */
  65 DWORD WINAPI UTGlue16( LPVOID lpBuff, DWORD dwUserDefined, SEGPTR translationList[],
  66                        DWORD (CALLBACK *target)( LPVOID lpBuff, DWORD dwUserDefined ) )
  67 {
  68     INT i;
  69
  70     /* Convert arguments to flat pointers */
  71
  72     if ( translationList )
  73         for ( i = 0; translationList[i]; i++ )
  74         {
  75             LPVOID flatPtr = PTR_SEG_TO_LIN( translationList[i] );
  76             *(LPVOID *)flatPtr = PTR_SEG_TO_LIN( *(SEGPTR *)flatPtr );
  77         }
  78
  79     /* Call 32-bit routine */
  80
  81     return target( lpBuff, dwUserDefined );
  82 }
  83
  84 /****************************************************************************
  85  *              UTGlue32
  86  */
  87 DWORD WINAPI UTGlue32( FARPROC16 target, LPVOID lpBuff, DWORD dwUserDefined,
  88                        LPVOID translationList[] )
  89 {
  90     SEGPTR segBuff, *segptrList = NULL;
  91     INT i, nList = 0;
  92     DWORD retv;
  93
  94     /* Convert arguments to SEGPTRs */
  95
  96     if ( translationList )
  97         for ( nList = 0; translationList[nList]; nList++ )
  98             ;
  99
 100     if ( nList )
 101     {
 102         segptrList = HeapAlloc( GetProcessHeap(), 0, sizeof(SEGPTR)*nList );
 103         if ( !segptrList )
 104         {
 105             FIXME( thunk, "Unable to allocate segptrList!" );
 106             return 0;
 107         }
 108
 109         for ( i = 0; i < nList; i++ )
 110             segptrList[i] = *(SEGPTR *)translationList[i]
 111                           = MapLS( *(LPVOID *)translationList[i] );
 112     }
 113
 114     segBuff = MapLS( lpBuff );
 115
 116     /* Call 16-bit routine */
 117
 118     retv = Callbacks->CallUTProc( target, segBuff, dwUserDefined );
 119
 120     /* Free temporary selectors */
 121
 122     UnMapLS( segBuff );
 123
 124     if ( nList )
 125     {
 126         for ( i = 0; i < nList; i++ )
 127             UnMapLS( segptrList[i] );
 128
 129         HeapFree( GetProcessHeap(), 0, segptrList );
 130     }
 131
 132     return retv;
 133 }
 134
 135 /****************************************************************************
 136  *              UTAlloc
 137  */
 138 static UTINFO *UTAlloc( HMODULE hModule, HMODULE16 hModule16,
 139                         FARPROC16 target16, FARPROC target32 )
 140 {
 141     UTINFO *ut = HeapAlloc( SegptrHeap, HEAP_ZERO_MEMORY, sizeof(UTINFO) );
 142     if ( !ut ) return NULL;
 143
 144     ut->hModule   = hModule;
 145     ut->hModule16 = hModule16;
 146
 147     ut->ut16.popl_eax  = 0x58;
 148     ut->ut16.pushl     = 0x68;
 149     ut->ut16.target    = (DWORD)target32;
 150     ut->ut16.pushl_eax = 0x50;
 151     ut->ut16.ljmp      = 0xea;
 152     ut->ut16.utglue16  = (DWORD)MODULE_GetWndProcEntry16( "UTGlue16" );
 153
 154     ut->ut32.popl_eax  = 0x58;
 155     ut->ut32.pushl     = 0x68;
 156     ut->ut32.target    = (DWORD)target16;
 157     ut->ut32.pushl_eax = 0x50;
 158     ut->ut32.jmp       = 0xe9;
 159     ut->ut32.utglue32  = (DWORD)UTGlue32 - ((DWORD)&ut->ut32.utglue32 + sizeof(DWORD));
 160
 161     ut->next = utAnchor;
 162     utAnchor = ut;
 163
 164     return ut;
 165 }
 166
 167 /****************************************************************************
 168  *              UTFree
 169  */
 170 static void UTFree( UTINFO *ut )
 171 {
 172     UTINFO **ptr;
 173
 174     for ( ptr = &utAnchor; *ptr; ptr = &(*ptr)->next )
 175         if ( *ptr == ut )
 176         {
 177             *ptr = ut->next;
 178             break;
 179         }
 180
 181     HeapFree( SegptrHeap, 0, ut );
 182 }
 183
 184 /****************************************************************************
 185  *              UTFind
 186  */
 187 static UTINFO *UTFind( HMODULE hModule )
 188 {
 189     UTINFO *ut;
 190
 191     for ( ut = utAnchor; ut; ut =ut->next )
 192         if ( ut->hModule == hModule )
 193             break;
 194
 195     return ut;
 196 }
 197
 198
 199 /****************************************************************************
 200  *              UTRegister (KERNEL32.697)
 201  */
 202 BOOL WINAPI UTRegister( HMODULE hModule, LPSTR lpsz16BITDLL,
 203                         LPSTR lpszInitName, LPSTR lpszProcName,
 204                         FARPROC *ppfn32Thunk, FARPROC pfnUT32CallBack,
 205                         LPVOID lpBuff )
 206 {
 207     UTINFO *ut;
 208     HMODULE16 hModule16;
 209     FARPROC16 target16, init16;
 210
 211     /* Load 16-bit DLL and get UTProc16 entry point */
 212
 213     if (   (hModule16 = LoadLibrary16( lpsz16BITDLL )) <= 32
 214         || (target16  = WIN32_GetProcAddress16( hModule16, lpszProcName )) == 0 )
 215         return FALSE;
 216
 217     /* Allocate UTINFO struct */
 218
 219     HeapLock( SegptrHeap );  /* FIXME: a bit overkill */
 220     if ( (ut = UTFind( hModule )) != NULL )
 221         ut = NULL;
 222     else
 223         ut = UTAlloc( hModule, hModule16, target16, pfnUT32CallBack );
 224     HeapUnlock( SegptrHeap );
 225
 226     if ( !ut )
 227     {
 228         FreeLibrary16( hModule16 );
 229         return FALSE;
 230     }
 231
 232     /* Call UTInit16 if present */
 233
 234     if (     lpszInitName
 235          && (init16 = WIN32_GetProcAddress16( hModule16, lpszInitName )) != 0 )
 236     {
 237         SEGPTR callback = SEGPTR_GET( &ut->ut16 );
 238         SEGPTR segBuff  = MapLS( lpBuff );
 239
 240         if ( !Callbacks->CallUTProc( init16, callback, segBuff ) )
 241         {
 242             UnMapLS( segBuff );
 243             UTUnRegister( hModule );
 244             return FALSE;
 245         }
 246         UnMapLS( segBuff );
 247     }
 248
 249     /* Return 32-bit thunk */
 250
 251     *ppfn32Thunk = (FARPROC) &ut->ut32;
 252
 253     return TRUE;
 254 }
 255
 256 /****************************************************************************
 257  *              UTUnRegister (KERNEL32.698)
 258  */
 259 VOID WINAPI UTUnRegister( HMODULE hModule )
 260 {
 261     UTINFO *ut;
 262     HMODULE16 hModule16 = 0;
 263
 264     HeapLock( SegptrHeap );  /* FIXME: a bit overkill */
 265     ut = UTFind( hModule );
 266     if ( !ut )
 267     {
 268         hModule16 = ut->hModule16;
 269         UTFree( ut );
 270     }
 271     HeapUnlock( SegptrHeap );
 272
 273     if ( hModule16 )
 274         FreeLibrary16( hModule16 );
 275 }
 276
 277 /****************************************************************************
 278  *              UTInit16     (KERNEL.494)
 279  */
 280 WORD WINAPI UTInit16( DWORD x1, DWORD x2, DWORD x3, DWORD x4 )
 281 {
 282     FIXME( thunk, "(%08lx, %08lx, %08lx, %08lx): stub\n", x1, x2, x3, x4 );
 283     return 0;
 284 }
 285