/* * Emulator thunks * * Copyright 1996, 1997 Alexandre Julliard */ #include #include "windows.h" #include "callback.h" #include "resource.h" #include "task.h" #include "user.h" #include "heap.h" #include "hook.h" #include "module.h" #include "stackframe.h" #include "selectors.h" #include "task.h" #include "except.h" #include "win.h" #include "stddebug.h" #include "debug.h" /* List of the 16-bit callback functions. This list is used */ /* by the build program to generate the file if1632/callto16.S */ /* ### start build ### */ extern LONG CALLBACK CallTo16_sreg_(const CONTEXT *context, INT32 offset); extern LONG CALLBACK CallTo16_lreg_(const CONTEXT *context, INT32 offset); extern WORD CALLBACK CallTo16_word_ (FARPROC16); extern WORD CALLBACK CallTo16_word_w (FARPROC16,WORD); extern LONG CALLBACK CallTo16_long_l (FARPROC16,LONG); extern WORD CALLBACK CallTo16_word_ww (FARPROC16,WORD,WORD); extern WORD CALLBACK CallTo16_word_wl (FARPROC16,WORD,LONG); extern WORD CALLBACK CallTo16_word_ll (FARPROC16,LONG,LONG); extern WORD CALLBACK CallTo16_word_www (FARPROC16,WORD,WORD,WORD); extern WORD CALLBACK CallTo16_word_wwl (FARPROC16,WORD,WORD,LONG); extern WORD CALLBACK CallTo16_word_wlw (FARPROC16,WORD,LONG,WORD); extern LONG CALLBACK CallTo16_long_wwl (FARPROC16,WORD,WORD,LONG); extern WORD CALLBACK CallTo16_word_llwl (FARPROC16,LONG,LONG,WORD,LONG); extern WORD CALLBACK CallTo16_word_lwll (FARPROC16,LONG,WORD,LONG,LONG); extern WORD CALLBACK CallTo16_word_lwww (FARPROC16,LONG,WORD,WORD,WORD); extern WORD CALLBACK CallTo16_word_wwll (FARPROC16,WORD,WORD,LONG,LONG); extern WORD CALLBACK CallTo16_word_wllwl(FARPROC16,WORD,LONG,LONG,WORD,LONG); extern LONG CALLBACK CallTo16_long_lwwll(FARPROC16,LONG,WORD,WORD,LONG,LONG); extern WORD CALLBACK CallTo16_word_wwlll(FARPROC16,WORD,WORD,LONG,LONG,LONG); extern WORD CALLBACK CallTo16_word_wwwww(FARPROC16,WORD,WORD,WORD,WORD,WORD); extern WORD CALLBACK CallTo16_word_lwlll(FARPROC16,LONG,WORD,LONG,LONG,LONG); extern WORD CALLBACK CallTo16_word_llll (FARPROC16,LONG,LONG,LONG,LONG); extern LONG CALLBACK CallTo16_long_lwlll(FARPROC16,LONG,WORD,LONG,LONG,LONG); extern LONG CALLBACK CallTo16_word_lwwlllll(FARPROC16,LONG,WORD,WORD,LONG,LONG, LONG,LONG,WORD); extern LONG CALLBACK CallTo16_long_lwwllwlllllw(FARPROC16,LONG,WORD,WORD,LONG, LONG,WORD,LONG,LONG,LONG,LONG, LONG,WORD); extern LONG CALLBACK CallTo16_word_lwwwwlwwwwllll(FARPROC16,LONG,WORD,WORD, WORD,WORD,LONG,WORD,WORD, WORD,WORD,LONG,LONG,LONG, LONG); /* ### stop build ### */ typedef void (*RELAY)(); #pragma pack(1) typedef struct tagTHUNK { BYTE popl_eax; /* 0x58 popl %eax (return address)*/ BYTE pushl_func; /* 0x68 pushl $proc */ FARPROC32 proc WINE_PACKED; BYTE pushl_eax; /* 0x50 pushl %eax */ BYTE jmp; /* 0xe9 jmp relay (relative jump)*/ RELAY relay WINE_PACKED; struct tagTHUNK *next WINE_PACKED; } THUNK; #pragma pack(4) #define DECL_THUNK(name,proc,relay) \ THUNK name = { 0x58, 0x68, (FARPROC32)(proc), 0x50, 0xe9, \ (RELAY)((char *)(relay) - (char *)(&(name).next)), NULL } static THUNK *firstThunk = NULL; static LRESULT WINAPI THUNK_CallWndProc16( WNDPROC16 proc, HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam ); static void WINAPI THUNK_CallTaskReschedule(void); /* TASK_Reschedule() 16-bit entry point */ static FARPROC16 TASK_RescheduleProc; extern void CallFrom16_long_wwwll(void); /* Callbacks function table for the emulator */ static const CALLBACKS_TABLE CALLBACK_EmulatorTable = { (void *)CallTo16_sreg_, /* CallRegisterShortProc */ (void *)CallTo16_lreg_, /* CallRegisterLongProc */ THUNK_CallTaskReschedule, /* CallTaskRescheduleProc */ CallFrom16_long_wwwll, /* CallFrom16WndProc */ THUNK_CallWndProc16, /* CallWndProc */ (void *)CallTo16_long_lwwll, /* CallDriverProc */ (void *)CallTo16_word_wwlll, /* CallDriverCallback */ (void *)CallTo16_word_wwlll, /* CallTimeFuncProc */ (void *)CallTo16_word_w, /* CallWindowsExitProc */ (void *)CallTo16_word_lwww, /* CallWordBreakProc */ (void *)CallTo16_word_ww, /* CallBootAppProc */ (void *)CallTo16_word_www, /* CallLoadAppSegProc */ (void *)CallTo16_word_, /* CallSystemTimerProc */ (void *)CallTo16_long_l, /* CallWOWCallbackProc */ (void *)CallTo16_long_l, /* CallASPIPostProc */ (void *)CallTo16_word_lwll, /* CallDrvControlProc */ (void *)CallTo16_word_lwlll, /* CallDrvEnableProc */ (void *)CallTo16_word_llll, /* CallDrvEnumDFontsProc */ (void *)CallTo16_word_lwll, /* CallDrvEnumObjProc */ (void *)CallTo16_word_lwwlllll, /* CallDrvOutputProc */ (void *)CallTo16_long_lwlll, /* CallDrvRealizeProc */ (void *)CallTo16_word_lwwwwlwwwwllll, /* CallDrvStretchBltProc */ (void *)CallTo16_long_lwwllwlllllw /* CallDrvExtTextOutProc */ }; /*********************************************************************** * THUNK_Init */ BOOL32 THUNK_Init(void) { /* Set the window proc calling functions */ Callbacks = &CALLBACK_EmulatorTable; /* Get the 16-bit reschedule function pointer */ TASK_RescheduleProc = MODULE_GetWndProcEntry16( "TASK_Reschedule" ); return TRUE; } /*********************************************************************** * THUNK_Alloc */ static THUNK *THUNK_Alloc( FARPROC32 func, RELAY relay ) { THUNK *thunk = HeapAlloc( GetProcessHeap(), 0, sizeof(*thunk) ); if (thunk) { thunk->popl_eax = 0x58; thunk->pushl_func = 0x68; thunk->proc = func; thunk->pushl_eax = 0x50; thunk->jmp = 0xe9; thunk->relay = (RELAY)((char *)relay - (char *)(&thunk->next)); thunk->next = firstThunk; firstThunk = thunk; } return thunk; } /*********************************************************************** * THUNK_Find */ static THUNK *THUNK_Find( FARPROC32 func ) { THUNK *thunk = firstThunk; while (thunk && (thunk->proc != func)) thunk = thunk->next; return thunk; } /*********************************************************************** * THUNK_Free */ static void THUNK_Free( THUNK *thunk ) { if (HEAP_IsInsideHeap( GetProcessHeap(), 0, thunk )) { THUNK **prev = &firstThunk; while (*prev && (*prev != thunk)) prev = &(*prev)->next; if (*prev) { *prev = thunk->next; HeapFree( GetProcessHeap(), 0, thunk ); return; } } dprintf_thunk( stddeb, "THUNK_Free: invalid thunk addr %p\n", thunk ); } /*********************************************************************** * THUNK_CallWndProc16 * * Call a 16-bit window procedure */ static LRESULT WINAPI THUNK_CallWndProc16( WNDPROC16 proc, HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam ) { CONTEXT context; LRESULT ret; WORD *args; WND *wndPtr = WIN_FindWndPtr( hwnd ); DWORD offset = 0; /* Window procedures want ax = hInstance, ds = es = ss */ DS_reg(&context) = SELECTOROF(IF1632_Saved16_ss_sp); ES_reg(&context) = DS_reg(&context); EAX_reg(&context) = wndPtr ? wndPtr->hInstance : DS_reg(&context); CS_reg(&context) = SELECTOROF(proc); EIP_reg(&context) = OFFSETOF(proc); EBP_reg(&context) = OFFSETOF(IF1632_Saved16_ss_sp) + (WORD)&((STACK16FRAME*)0)->bp; if (lParam) { /* Some programs (eg. the "Undocumented Windows" examples, JWP) only work if structures passed in lParam are placed in the stack/data segment. Programmers easily make the mistake of converting lParam to a near rather than a far pointer, since Windows apparently allows this. We copy the structures to the 16 bit stack; this is ugly but makes these programs work. */ switch (msg) { case WM_CREATE: case WM_NCCREATE: offset = sizeof(CREATESTRUCT16); break; case WM_DRAWITEM: offset = sizeof(DRAWITEMSTRUCT16); break; case WM_COMPAREITEM: offset = sizeof(COMPAREITEMSTRUCT16); break; } if (offset) { void *s = PTR_SEG_TO_LIN(lParam); lParam = STACK16_PUSH( offset ); memcpy( PTR_SEG_TO_LIN(lParam), s, offset ); } } args = (WORD *)CURRENT_STACK16 - 7; args[0] = LOWORD(lParam); args[1] = HIWORD(lParam); args[2] = wParam; args[3] = msg; args[4] = hwnd; /* args[5] and args[6] are used by relay code to store the stack pointer */ ret = CallTo16_sreg_( &context, -(5 * sizeof(WORD)) ); if (offset) STACK16_POP(offset); return ret; } /*********************************************************************** * THUNK_CallTaskReschedule */ static void WINAPI THUNK_CallTaskReschedule(void) { CallTo16_word_(TASK_RescheduleProc); } /*********************************************************************** * THUNK_EnumObjects16 (GDI.71) */ INT16 WINAPI THUNK_EnumObjects16( HDC16 hdc, INT16 nObjType, GOBJENUMPROC16 func, LPARAM lParam ) { DECL_THUNK( thunk, func, CallTo16_word_ll ); return EnumObjects16( hdc, nObjType, (GOBJENUMPROC16)&thunk, lParam ); } /************************************************************************* * THUNK_EnumFonts16 (GDI.70) */ INT16 WINAPI THUNK_EnumFonts16( HDC16 hdc, LPCSTR lpFaceName, FONTENUMPROC16 func, LPARAM lParam ) { DECL_THUNK( thunk, func, CallTo16_word_llwl ); return EnumFonts16( hdc, lpFaceName, (FONTENUMPROC16)&thunk, lParam ); } /****************************************************************** * THUNK_EnumMetaFile16 (GDI.175) */ BOOL16 WINAPI THUNK_EnumMetaFile16( HDC16 hdc, HMETAFILE16 hmf, MFENUMPROC16 func, LPARAM lParam ) { DECL_THUNK( thunk, func, CallTo16_word_wllwl ); return EnumMetaFile16( hdc, hmf, (MFENUMPROC16)&thunk, lParam ); } /************************************************************************* * THUNK_EnumFontFamilies16 (GDI.330) */ INT16 WINAPI THUNK_EnumFontFamilies16( HDC16 hdc, LPCSTR lpszFamily, FONTENUMPROC16 func, LPARAM lParam ) { DECL_THUNK( thunk, func, CallTo16_word_llwl ); return EnumFontFamilies16(hdc, lpszFamily, (FONTENUMPROC16)&thunk, lParam); } /************************************************************************* * THUNK_EnumFontFamiliesEx16 (GDI.613) */ INT16 WINAPI THUNK_EnumFontFamiliesEx16( HDC16 hdc, LPLOGFONT16 lpLF, FONTENUMPROCEX16 func, LPARAM lParam, DWORD reserved ) { DECL_THUNK( thunk, func, CallTo16_word_llwl ); return EnumFontFamiliesEx16( hdc, lpLF, (FONTENUMPROCEX16)&thunk, lParam, reserved ); } /********************************************************************** * THUNK_LineDDA16 (GDI.100) */ void WINAPI THUNK_LineDDA16( INT16 nXStart, INT16 nYStart, INT16 nXEnd, INT16 nYEnd, LINEDDAPROC16 func, LPARAM lParam ) { DECL_THUNK( thunk, func, CallTo16_word_wwl ); LineDDA16( nXStart, nYStart, nXEnd, nYEnd, (LINEDDAPROC16)&thunk, lParam ); } /******************************************************************* * THUNK_EnumWindows16 (USER.54) */ BOOL16 WINAPI THUNK_EnumWindows16( WNDENUMPROC16 func, LPARAM lParam ) { DECL_THUNK( thunk, func, CallTo16_word_wl ); return EnumWindows16( (WNDENUMPROC16)&thunk, lParam ); } /********************************************************************** * THUNK_EnumChildWindows16 (USER.55) */ BOOL16 WINAPI THUNK_EnumChildWindows16( HWND16 parent, WNDENUMPROC16 func, LPARAM lParam ) { DECL_THUNK( thunk, func, CallTo16_word_wl ); return EnumChildWindows16( parent, (WNDENUMPROC16)&thunk, lParam ); } /********************************************************************** * THUNK_EnumTaskWindows16 (USER.225) */ BOOL16 WINAPI THUNK_EnumTaskWindows16( HTASK16 hTask, WNDENUMPROC16 func, LPARAM lParam ) { DECL_THUNK( thunk, func, CallTo16_word_wl ); return EnumTaskWindows16( hTask, (WNDENUMPROC16)&thunk, lParam ); } /*********************************************************************** * THUNK_EnumProps16 (USER.27) */ INT16 WINAPI THUNK_EnumProps16( HWND16 hwnd, PROPENUMPROC16 func ) { DECL_THUNK( thunk, func, CallTo16_word_wlw ); return EnumProps16( hwnd, (PROPENUMPROC16)&thunk ); } /*********************************************************************** * THUNK_GrayString16 (USER.185) */ BOOL16 WINAPI THUNK_GrayString16( HDC16 hdc, HBRUSH16 hbr, GRAYSTRINGPROC16 func, LPARAM lParam, INT16 cch, INT16 x, INT16 y, INT16 cx, INT16 cy ) { DECL_THUNK( thunk, func, CallTo16_word_wlw ); if (!func) return GrayString16( hdc, hbr, NULL, lParam, cch, x, y, cx, cy ); else return GrayString16( hdc, hbr, (GRAYSTRINGPROC16)&thunk, lParam, cch, x, y, cx, cy ); } /*********************************************************************** * THUNK_SetWindowsHook16 (USER.121) */ FARPROC16 WINAPI THUNK_SetWindowsHook16( INT16 id, HOOKPROC16 proc ) { HINSTANCE16 hInst = FarGetOwner( HIWORD(proc) ); HTASK16 hTask = (id == WH_MSGFILTER) ? GetCurrentTask() : 0; THUNK *thunk = THUNK_Alloc( (FARPROC16)proc, (RELAY)CallTo16_long_wwl ); if (!thunk) return 0; return (FARPROC16)SetWindowsHookEx16( id, (HOOKPROC16)thunk, hInst, hTask); } /*********************************************************************** * THUNK_UnhookWindowsHook16 (USER.234) */ BOOL16 WINAPI THUNK_UnhookWindowsHook16( INT16 id, HOOKPROC16 proc ) { BOOL16 ret; THUNK *thunk = THUNK_Find( (FARPROC16)proc ); if (!thunk) return FALSE; ret = UnhookWindowsHook16( id, (HOOKPROC16)thunk ); THUNK_Free( thunk ); return ret; } /*********************************************************************** * THUNK_SetWindowsHookEx16 (USER.291) */ HHOOK WINAPI THUNK_SetWindowsHookEx16( INT16 id, HOOKPROC16 proc, HINSTANCE16 hInst, HTASK16 hTask ) { THUNK *thunk = THUNK_Alloc( (FARPROC16)proc, (RELAY)CallTo16_long_wwl ); if (!thunk) return 0; return SetWindowsHookEx16( id, (HOOKPROC16)thunk, hInst, hTask ); } /*********************************************************************** * THUNK_UnhookWindowHookEx16 (USER.292) */ BOOL16 WINAPI THUNK_UnhookWindowsHookEx16( HHOOK hhook ) { THUNK *thunk = (THUNK *)HOOK_GetProc16( hhook ); BOOL16 ret = UnhookWindowsHookEx16( hhook ); if (thunk) THUNK_Free( thunk ); return ret; } static FARPROC16 defDCHookProc = NULL; /*********************************************************************** * THUNK_SetDCHook (GDI.190) */ BOOL16 WINAPI THUNK_SetDCHook( HDC16 hdc, FARPROC16 proc, DWORD dwHookData ) { THUNK *thunk, *oldThunk; if (!defDCHookProc) /* Get DCHook Win16 entry point */ defDCHookProc = MODULE_GetEntryPoint( GetModuleHandle16("USER"), 362 ); if (proc != defDCHookProc) { thunk = THUNK_Alloc( proc, (RELAY)CallTo16_word_wwll ); if (!thunk) return FALSE; } else thunk = (THUNK *)DCHook; /* Free the previous thunk */ GetDCHook( hdc, (FARPROC16 *)&oldThunk ); if (oldThunk && (oldThunk != (THUNK *)DCHook)) THUNK_Free( oldThunk ); return SetDCHook( hdc, (FARPROC16)thunk, dwHookData ); } /*********************************************************************** * THUNK_GetDCHook (GDI.191) */ DWORD WINAPI THUNK_GetDCHook( HDC16 hdc, FARPROC16 *phookProc ) { THUNK *thunk = NULL; DWORD ret = GetDCHook( hdc, (FARPROC16 *)&thunk ); if (thunk) { if (thunk == (THUNK *)DCHook) { if (!defDCHookProc) /* Get DCHook Win16 entry point */ defDCHookProc = MODULE_GetEntryPoint(GetModuleHandle16("USER"), 362 ); *phookProc = defDCHookProc; } else *phookProc = thunk->proc; } return ret; } /*********************************************************************** * THUNK_SetTaskSignalProc (KERNEL.38) */ FARPROC16 WINAPI THUNK_SetTaskSignalProc( HTASK16 hTask, FARPROC16 proc ) { static FARPROC16 defSignalProc16 = NULL; THUNK *thunk = NULL; if( !defSignalProc16 ) defSignalProc16 = MODULE_GetEntryPoint(GetModuleHandle16("USER"), 314 ); if( proc == defSignalProc16 ) thunk = (THUNK*)SetTaskSignalProc( hTask, (FARPROC16)&USER_SignalProc ); else { thunk = THUNK_Alloc( proc, (RELAY)CallTo16_word_wwwww ); if( !thunk ) return FALSE; thunk = (THUNK*)SetTaskSignalProc( hTask, (FARPROC16)thunk ); } if( thunk != (THUNK*)USER_SignalProc ) { if( !thunk ) return NULL; proc = thunk->proc; THUNK_Free( thunk ); return proc; } return defSignalProc16; } /*********************************************************************** * THUNK_SetResourceHandler (KERNEL.67) */ FARPROC16 WINAPI THUNK_SetResourceHandler( HMODULE16 hModule, SEGPTR typeId, FARPROC16 proc ) { /* loader/ne_resource.c */ extern HGLOBAL16 WINAPI NE_DefResourceHandler(HGLOBAL16,HMODULE16,HRSRC16); static FARPROC16 defDIBIconLoader16 = NULL; static FARPROC16 defDIBCursorLoader16 = NULL; static FARPROC16 defResourceLoader16 = NULL; THUNK *thunk = NULL; if( !defResourceLoader16 ) { HMODULE16 hUser = GetModuleHandle16("USER"); defDIBIconLoader16 = MODULE_GetEntryPoint( hUser, 357 ); defDIBCursorLoader16 = MODULE_GetEntryPoint( hUser, 356 ); defResourceLoader16 = MODULE_GetWndProcEntry16( "DefResourceHandler" ); } if( proc == defResourceLoader16 ) thunk = (THUNK*)&NE_DefResourceHandler; else if( proc == defDIBIconLoader16 ) thunk = (THUNK*)&LoadDIBIconHandler; else if( proc == defDIBCursorLoader16 ) thunk = (THUNK*)&LoadDIBCursorHandler; else { thunk = THUNK_Alloc( proc, (RELAY)CallTo16_word_www ); if( !thunk ) return FALSE; } thunk = (THUNK*)SetResourceHandler( hModule, typeId, (FARPROC16)thunk ); if( thunk == (THUNK*)&NE_DefResourceHandler ) return defResourceLoader16; if( thunk == (THUNK*)&LoadDIBIconHandler ) return defDIBIconLoader16; if( thunk == (THUNK*)&LoadDIBCursorHandler ) return defDIBCursorLoader16; if( thunk ) { proc = thunk->proc; THUNK_Free( thunk ); return proc; } return NULL; }