2 * Win32s Universal Thunk API
4 * Copyright 1999 Ulrich Weigand
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include "wine/winbase16.h"
29 #include "wine/debug.h"
31 WINE_DEFAULT_DEBUG_CHANNEL(thunk);
59 typedef struct _UTINFO
70 static UTINFO *UT_head; /* head of Universal Thunk list */
72 typedef DWORD (CALLBACK *UTGLUEPROC)( LPVOID lpBuff, DWORD dwUserDefined );
74 BOOL WINAPI UTRegister( HMODULE hModule, LPSTR lpsz16BITDLL,
75 LPSTR lpszInitName, LPSTR lpszProcName,
76 FARPROC *ppfn32Thunk, FARPROC pfnUT32CallBack,
79 VOID WINAPI UTUnRegister( HMODULE hModule );
82 /****************************************************************************
83 * UTGlue16 (KERNEL.666) (KERNEL Wine-specific export)
85 DWORD WINAPI UTGlue16( LPVOID lpBuff, DWORD dwUserDefined, SEGPTR *translationList,
90 /* Convert arguments to flat pointers */
92 if ( translationList )
93 for ( i = 0; translationList[i]; i++ )
95 LPVOID flatPtr = MapSL( translationList[i] );
96 *(LPVOID *)flatPtr = MapSL( *(SEGPTR *)flatPtr );
99 /* Call 32-bit routine */
101 return target( lpBuff, dwUserDefined );
104 /****************************************************************************
107 static DWORD WINAPI UTGlue32( FARPROC16 target, LPVOID lpBuff, DWORD dwUserDefined,
108 LPVOID translationList[] )
110 SEGPTR segBuff, *segptrList = NULL;
115 /* Convert arguments to SEGPTRs */
117 if ( translationList )
118 for ( nList = 0; translationList[nList]; nList++ )
123 segptrList = HeapAlloc( GetProcessHeap(), 0, sizeof(SEGPTR)*nList );
126 FIXME("Unable to allocate segptrList!\n" );
130 for ( i = 0; i < nList; i++ )
131 segptrList[i] = *(SEGPTR *)translationList[i]
132 = MapLS( *(LPVOID *)translationList[i] );
135 segBuff = MapLS( lpBuff );
137 /* Call 16-bit routine */
139 args[3] = SELECTOROF(segBuff);
140 args[2] = OFFSETOF(segBuff);
141 args[1] = HIWORD(dwUserDefined);
142 args[0] = LOWORD(dwUserDefined);
143 WOWCallback16Ex( (DWORD)target, WCB16_PASCAL, sizeof(args), args, &retv );
145 /* Free temporary selectors */
151 for ( i = 0; i < nList; i++ )
152 UnMapLS( segptrList[i] );
154 HeapFree( GetProcessHeap(), 0, segptrList );
160 /****************************************************************************
163 static UTINFO *UTAlloc( HMODULE hModule, HMODULE16 hModule16,
164 FARPROC16 target16, FARPROC target32 )
166 static FARPROC16 UTGlue16_Segptr = NULL;
169 if ( !UTGlue16_Segptr )
171 HMODULE16 hModule = GetModuleHandle16( "KERNEL" );
172 UTGlue16_Segptr = GetProcAddress16( hModule, "UTGlue16" );
173 if ( !UTGlue16_Segptr ) return NULL;
176 ut = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(UTINFO) );
177 if ( !ut ) return NULL;
179 ut->hModule = hModule;
180 ut->hModule16 = hModule16;
182 ut->ut16.popl_eax = 0x58;
183 ut->ut16.pushl = 0x68;
184 ut->ut16.target = (DWORD)target32;
185 ut->ut16.pushl_eax = 0x50;
186 ut->ut16.ljmp = 0xea;
187 ut->ut16.utglue16 = (DWORD)UTGlue16_Segptr;
189 ut->ut32.popl_eax = 0x58;
190 ut->ut32.pushl = 0x68;
191 ut->ut32.target = (DWORD)target16;
192 ut->ut32.pushl_eax = 0x50;
194 ut->ut32.utglue32 = (DWORD)UTGlue32 - ((DWORD)&ut->ut32.utglue32 + sizeof(DWORD));
202 /****************************************************************************
205 static void UTFree( UTINFO *ut )
209 for ( ptr = &UT_head; *ptr; ptr = &(*ptr)->next )
216 HeapFree( GetProcessHeap(), 0, ut );
219 /****************************************************************************
222 static UTINFO *UTFind( HMODULE hModule )
226 for ( ut = UT_head; ut; ut =ut->next )
227 if ( ut->hModule == hModule )
234 /****************************************************************************
235 * UTRegister (KERNEL32.@)
237 BOOL WINAPI UTRegister( HMODULE hModule, LPSTR lpsz16BITDLL,
238 LPSTR lpszInitName, LPSTR lpszProcName,
239 FARPROC *ppfn32Thunk, FARPROC pfnUT32CallBack,
244 FARPROC16 target16, init16;
246 /* Load 16-bit DLL and get UTProc16 entry point */
248 if ( (hModule16 = LoadLibrary16( lpsz16BITDLL )) <= 32
249 || (target16 = GetProcAddress16( hModule16, lpszProcName )) == 0 )
252 /* Allocate UTINFO struct */
255 if ( (ut = UTFind( hModule )) != NULL )
258 ut = UTAlloc( hModule, hModule16, target16, pfnUT32CallBack );
263 FreeLibrary16( hModule16 );
267 /* Call UTInit16 if present */
270 && (init16 = GetProcAddress16( hModule16, lpszInitName )) != 0 )
272 SEGPTR callback = MapLS( &ut->ut16 );
273 SEGPTR segBuff = MapLS( lpBuff );
277 args[3] = SELECTOROF(callback);
278 args[2] = OFFSETOF(callback);
279 args[1] = SELECTOROF(segBuff);
280 args[0] = OFFSETOF(segBuff);
281 WOWCallback16Ex( (DWORD)init16, WCB16_PASCAL, sizeof(args), args, &ret );
286 UTUnRegister( hModule );
291 /* Return 32-bit thunk */
293 *ppfn32Thunk = (FARPROC) &ut->ut32;
298 /****************************************************************************
299 * UTUnRegister (KERNEL32.@)
301 VOID WINAPI UTUnRegister( HMODULE hModule )
304 HMODULE16 hModule16 = 0;
307 ut = UTFind( hModule );
310 hModule16 = ut->hModule16;
316 FreeLibrary16( hModule16 );
319 /****************************************************************************
320 * UTInit (KERNEL.493)
322 WORD WINAPI UTInit16( DWORD x1, DWORD x2, DWORD x3, DWORD x4 )
324 FIXME("(%08lx, %08lx, %08lx, %08lx): stub\n", x1, x2, x3, x4 );