if1632/thunk.c

   1 /*
   2  * Emulator thunks
   3  *
   4  * Copyright 1996, 1997 Alexandre Julliard
   5  * Copyright 1998       Ulrich Weigand
   6  */
   7
   8 #include "windows.h"
   9 #include "callback.h"
  10 #include "resource.h"
  11 #include "task.h"
  12 #include "user.h"
  13 #include "heap.h"
  14 #include "hook.h"
  15 #include "module.h"
  16 #include "process.h"
  17 #include "stackframe.h"
  18 #include "selectors.h"
  19 #include "task.h"
  20 #include "except.h"
  21 #include "win.h"
  22 #include "flatthunk.h"
  23 #include "mouse.h"
  24 #include "keyboard.h"
  25 #include "debug.h"
  26
  27
  28 /* List of the 16-bit callback functions. This list is used  */
  29 /* by the build program to generate the file if1632/callto16.S */
  30
  31 /* ### start build ### */
  32 extern LONG CALLBACK CallTo16_sreg_(const CONTEXT *context, INT32 offset);
  33 extern LONG CALLBACK CallTo16_lreg_(const CONTEXT *context, INT32 offset);
  34 extern WORD CALLBACK CallTo16_word_     (FARPROC16);
  35 extern LONG CALLBACK CallTo16_long_     (FARPROC16);
  36 extern WORD CALLBACK CallTo16_word_w    (FARPROC16,WORD);
  37 extern WORD CALLBACK CallTo16_word_l    (FARPROC16,LONG);
  38 extern LONG CALLBACK CallTo16_long_l    (FARPROC16,LONG);
  39 extern WORD CALLBACK CallTo16_word_ww   (FARPROC16,WORD,WORD);
  40 extern WORD CALLBACK CallTo16_word_wl   (FARPROC16,WORD,LONG);
  41 extern WORD CALLBACK CallTo16_word_ll   (FARPROC16,LONG,LONG);
  42 extern LONG CALLBACK CallTo16_long_ll   (FARPROC16,LONG,LONG);
  43 extern WORD CALLBACK CallTo16_word_www  (FARPROC16,WORD,WORD,WORD);
  44 extern WORD CALLBACK CallTo16_word_wwl  (FARPROC16,WORD,WORD,LONG);
  45 extern WORD CALLBACK CallTo16_word_wlw  (FARPROC16,WORD,LONG,WORD);
  46 extern LONG CALLBACK CallTo16_long_wwl  (FARPROC16,WORD,WORD,LONG);
  47 extern LONG CALLBACK CallTo16_long_lll  (FARPROC16,LONG,LONG,LONG);
  48 extern WORD CALLBACK CallTo16_word_llwl (FARPROC16,LONG,LONG,WORD,LONG);
  49 extern WORD CALLBACK CallTo16_word_lwll (FARPROC16,LONG,WORD,LONG,LONG);
  50 extern WORD CALLBACK CallTo16_word_lwww (FARPROC16,LONG,WORD,WORD,WORD);
  51 extern WORD CALLBACK CallTo16_word_wlww (FARPROC16,WORD,LONG,WORD,WORD);
  52 extern WORD CALLBACK CallTo16_word_wwll (FARPROC16,WORD,WORD,LONG,LONG);
  53 extern WORD CALLBACK CallTo16_word_wwwl (FARPROC16,WORD,WORD,WORD,LONG);
  54 extern LONG CALLBACK CallTo16_long_wwwl (FARPROC16,WORD,WORD,WORD,LONG);
  55 extern WORD CALLBACK CallTo16_word_llll (FARPROC16,LONG,LONG,LONG,LONG);
  56 extern LONG CALLBACK CallTo16_long_llll (FARPROC16,LONG,LONG,LONG,LONG);
  57 extern WORD CALLBACK CallTo16_word_wllwl(FARPROC16,WORD,LONG,LONG,WORD,LONG);
  58 extern WORD CALLBACK CallTo16_word_lwwww(FARPROC16,LONG,WORD,WORD,WORD,WORD);
  59 extern LONG CALLBACK CallTo16_long_lwwll(FARPROC16,LONG,WORD,WORD,LONG,LONG);
  60 extern WORD CALLBACK CallTo16_word_wwlll(FARPROC16,WORD,WORD,LONG,LONG,LONG);
  61 extern WORD CALLBACK CallTo16_word_wwwww(FARPROC16,WORD,WORD,WORD,WORD,WORD);
  62 extern WORD CALLBACK CallTo16_word_lwlll(FARPROC16,LONG,WORD,LONG,LONG,LONG);
  63 extern LONG CALLBACK CallTo16_long_lwlll(FARPROC16,LONG,WORD,LONG,LONG,LONG);
  64 extern LONG CALLBACK CallTo16_long_lllll(FARPROC16,LONG,LONG,LONG,LONG,LONG);
  65 extern LONG CALLBACK CallTo16_long_llllll(FARPROC16,LONG,LONG,LONG,LONG,LONG,
  66                                           LONG);
  67 extern LONG CALLBACK CallTo16_long_lllllll(FARPROC16,LONG,LONG,LONG,LONG,LONG,
  68                                            LONG,LONG);
  69 extern WORD CALLBACK CallTo16_word_llwwlll(FARPROC16,LONG,LONG,WORD,WORD,LONG,
  70                                            LONG,LONG);
  71 extern LONG CALLBACK CallTo16_word_lwwlllll(FARPROC16,LONG,WORD,WORD,LONG,LONG,
  72                                             LONG,LONG,LONG);
  73 extern LONG CALLBACK CallTo16_long_llllllll(FARPROC16,LONG,LONG,LONG,LONG,LONG,
  74                                             LONG,LONG,LONG);
  75 extern LONG CALLBACK CallTo16_long_lllllllll(FARPROC16,LONG,LONG,LONG,LONG,
  76                                              LONG,LONG,LONG,LONG,LONG);
  77 extern LONG CALLBACK CallTo16_long_llllllllll(FARPROC16,LONG,LONG,LONG,LONG,
  78                                               LONG,LONG,LONG,LONG,LONG,LONG);
  79 extern LONG CALLBACK CallTo16_long_lllllllllll(FARPROC16,LONG,LONG,LONG,LONG,
  80                                                LONG,LONG,LONG,LONG,LONG,LONG,
  81                                                LONG);
  82 extern LONG CALLBACK CallTo16_long_llllllllllll(FARPROC16,LONG,LONG,LONG,LONG,
  83                                                 LONG,LONG,LONG,LONG,LONG,LONG,
  84                                                 LONG,LONG);
  85 extern LONG CALLBACK CallTo16_long_lwwllwlllllw(FARPROC16,LONG,WORD,WORD,LONG,
  86                                                 LONG,WORD,LONG,LONG,LONG,LONG,
  87                                                 LONG,WORD);
  88 extern LONG CALLBACK CallTo16_long_lllllllllllll(FARPROC16,LONG,LONG,LONG,LONG,
  89                                                  LONG,LONG,LONG,LONG,LONG,LONG,
  90                                                  LONG,LONG,LONG);
  91 extern LONG CALLBACK CallTo16_long_llllllllllllll(FARPROC16,LONG,LONG,LONG,
  92                                                   LONG,LONG,LONG,LONG,LONG,
  93                                                   LONG,LONG,LONG,LONG,LONG,
  94                                                   LONG);
  95 extern LONG CALLBACK CallTo16_word_lwwwwlwwwwllll(FARPROC16,LONG,WORD,WORD,
  96                                                   WORD,WORD,LONG,WORD,WORD,
  97                                                   WORD,WORD,LONG,LONG,LONG,
  98                                                   LONG);
  99 extern LONG CALLBACK CallTo16_long_lllllllllllllll(FARPROC16,LONG,LONG,LONG,
 100                                                    LONG,LONG,LONG,LONG,LONG,
 101                                                    LONG,LONG,LONG,LONG,LONG,
 102                                                    LONG,LONG);
 103 extern LONG CALLBACK CallTo16_long_llllllllllllllll(FARPROC16,LONG,LONG,LONG,
 104                                                     LONG,LONG,LONG,LONG,LONG,
 105                                                     LONG,LONG,LONG,LONG,LONG,
 106                                                     LONG,LONG,LONG);
 107 /* ### stop build ### */
 108
 109
 110 typedef void (*RELAY)();
 111
 112 #pragma pack(1)
 113
 114 typedef struct tagTHUNK
 115 {
 116     BYTE             popl_eax;           /* 0x58  popl  %eax (return address)*/
 117     BYTE             pushl_func;         /* 0x68  pushl $proc */
 118     FARPROC32        proc WINE_PACKED;
 119     BYTE             pushl_eax;          /* 0x50  pushl %eax */
 120     BYTE             jmp;                /* 0xe9  jmp   relay (relative jump)*/
 121     RELAY            relay WINE_PACKED;
 122     struct tagTHUNK *next WINE_PACKED;
 123 } THUNK;
 124
 125 #pragma pack(4)
 126
 127 #define DECL_THUNK(name,proc,relay) \
 128     THUNK name = { 0x58, 0x68, (FARPROC32)(proc), 0x50, 0xe9, \
 129                    (RELAY)((char *)(relay) - (char *)(&(name).next)), NULL }
 130
 131
 132 static THUNK *firstThunk = NULL;
 133
 134 static LRESULT WINAPI THUNK_CallWndProc16( WNDPROC16 proc, HWND16 hwnd,
 135                                            UINT16 msg, WPARAM16 wParam,
 136                                            LPARAM lParam );
 137 static BOOL32 WINAPI THUNK_CallTaskReschedule(void);
 138 static BOOL32 WINAPI THUNK_WOWCallback16Ex( FARPROC16,DWORD,DWORD,
 139                                             LPVOID,LPDWORD );
 140
 141 /* TASK_Reschedule() 16-bit entry point */
 142 static FARPROC16 TASK_RescheduleProc;
 143
 144 static BOOL32 THUNK_ThunkletInit( void );
 145
 146 extern void CallFrom16_p_long_wwwll(void);
 147
 148 /* Callbacks function table for the emulator */
 149 static const CALLBACKS_TABLE CALLBACK_EmulatorTable =
 150 {
 151     (void *)CallTo16_sreg_,                /* CallRegisterShortProc */
 152     (void *)CallTo16_lreg_,                /* CallRegisterLongProc */
 153     THUNK_CallTaskReschedule,              /* CallTaskRescheduleProc */
 154     CallFrom16_p_long_wwwll,               /* CallFrom16WndProc */
 155     THUNK_CallWndProc16,                   /* CallWndProc */
 156     (void *)CallTo16_long_lwwll,           /* CallDriverProc */
 157     (void *)CallTo16_word_wwlll,           /* CallDriverCallback */
 158     (void *)CallTo16_word_wwlll,           /* CallTimeFuncProc */
 159     (void *)CallTo16_word_w,               /* CallWindowsExitProc */
 160     (void *)CallTo16_word_lwww,            /* CallWordBreakProc */
 161     (void *)CallTo16_word_ww,              /* CallBootAppProc */
 162     (void *)CallTo16_word_www,             /* CallLoadAppSegProc */
 163     (void *)CallTo16_word_www,             /* CallLocalNotifyFunc */
 164     (void *)CallTo16_word_www,             /* CallResourceHandlerProc */
 165     (void *)CallTo16_long_l,               /* CallWOWCallbackProc */
 166     THUNK_WOWCallback16Ex,                 /* CallWOWCallback16Ex */
 167     (void *)CallTo16_long_l,               /* CallASPIPostProc */
 168     (void *)CallTo16_word_lwll,            /* CallDrvControlProc */
 169     (void *)CallTo16_word_lwlll,           /* CallDrvEnableProc */
 170     (void *)CallTo16_word_llll,            /* CallDrvEnumDFontsProc */
 171     (void *)CallTo16_word_lwll,            /* CallDrvEnumObjProc */
 172     (void *)CallTo16_word_lwwlllll,        /* CallDrvOutputProc */
 173     (void *)CallTo16_long_lwlll,           /* CallDrvRealizeProc */
 174     (void *)CallTo16_word_lwwwwlwwwwllll,  /* CallDrvStretchBltProc */
 175     (void *)CallTo16_long_lwwllwlllllw,    /* CallDrvExtTextOutProc */
 176     (void *)CallTo16_word_llwwlll,         /* CallDrvGetCharWidth */
 177     (void *)CallTo16_word_ww               /* CallDrvAbortProc */
 178 };
 179
 180
 181 /***********************************************************************
 182  *           THUNK_Init
 183  */
 184 BOOL32 THUNK_Init(void)
 185 {
 186     /* Set the window proc calling functions */
 187     Callbacks = &CALLBACK_EmulatorTable;
 188     /* Get the 16-bit reschedule function pointer */
 189     TASK_RescheduleProc = MODULE_GetWndProcEntry16( "TASK_Reschedule" );
 190     /* Initialize Thunklets */
 191     return THUNK_ThunkletInit();
 192 }
 193
 194 /***********************************************************************
 195  *           THUNK_Alloc
 196  */
 197 static THUNK *THUNK_Alloc( FARPROC32 func, RELAY relay )
 198 {
 199     THUNK *thunk = HeapAlloc( GetProcessHeap(), 0, sizeof(*thunk) );
 200     if (thunk)
 201     {
 202         thunk->popl_eax   = 0x58;
 203         thunk->pushl_func = 0x68;
 204         thunk->proc       = func;
 205         thunk->pushl_eax  = 0x50;
 206         thunk->jmp        = 0xe9;
 207         thunk->relay      = (RELAY)((char *)relay - (char *)(&thunk->next));
 208         thunk->next       = firstThunk;
 209         firstThunk = thunk;
 210     }
 211     return thunk;
 212 }
 213
 214
 215 /***********************************************************************
 216  *           THUNK_Find
 217  */
 218 static THUNK *THUNK_Find( FARPROC32 func )
 219 {
 220     THUNK *thunk = firstThunk;
 221     while (thunk && (thunk->proc != func)) thunk = thunk->next;
 222     return thunk;
 223 }
 224
 225
 226 /***********************************************************************
 227  *           THUNK_Free
 228  */
 229 static void THUNK_Free( THUNK *thunk )
 230 {
 231     if (HEAP_IsInsideHeap( GetProcessHeap(), 0, thunk ))
 232     {
 233         THUNK **prev = &firstThunk;
 234         while (*prev && (*prev != thunk)) prev = &(*prev)->next;
 235         if (*prev)
 236         {
 237             *prev = thunk->next;
 238             HeapFree( GetProcessHeap(), 0, thunk );
 239             return;
 240         }
 241     }
 242     ERR(thunk, "invalid thunk addr %p\n", thunk );
 243 }
 244
 245
 246 /***********************************************************************
 247  *           THUNK_CallWndProc16
 248  *
 249  * Call a 16-bit window procedure
 250  */
 251 static LRESULT WINAPI THUNK_CallWndProc16( WNDPROC16 proc, HWND16 hwnd,
 252                                            UINT16 msg, WPARAM16 wParam,
 253                                            LPARAM lParam )
 254 {
 255     CONTEXT context;
 256     LRESULT ret;
 257     WORD *args;
 258     WND *wndPtr = WIN_FindWndPtr( hwnd );
 259     DWORD offset = 0;
 260     THDB *thdb = THREAD_Current();
 261
 262     /* Window procedures want ax = hInstance, ds = es = ss */
 263
 264     memset(&context, '\0', sizeof(context));
 265     DS_reg(&context)  = SELECTOROF(thdb->cur_stack);
 266     ES_reg(&context)  = DS_reg(&context);
 267     EAX_reg(&context) = wndPtr ? wndPtr->hInstance : DS_reg(&context);
 268     CS_reg(&context)  = SELECTOROF(proc);
 269     EIP_reg(&context) = OFFSETOF(proc);
 270     EBP_reg(&context) = OFFSETOF(thdb->cur_stack)
 271                         + (WORD)&((STACK16FRAME*)0)->bp;
 272
 273     if (lParam)
 274     {
 275         /* Some programs (eg. the "Undocumented Windows" examples, JWP) only
 276            work if structures passed in lParam are placed in the stack/data
 277            segment. Programmers easily make the mistake of converting lParam
 278            to a near rather than a far pointer, since Windows apparently
 279            allows this. We copy the structures to the 16 bit stack; this is
 280            ugly but makes these programs work. */
 281         switch (msg)
 282         {
 283           case WM_CREATE:
 284           case WM_NCCREATE:
 285             offset = sizeof(CREATESTRUCT16); break;
 286           case WM_DRAWITEM:
 287             offset = sizeof(DRAWITEMSTRUCT16); break;
 288           case WM_COMPAREITEM:
 289             offset = sizeof(COMPAREITEMSTRUCT16); break;
 290         }
 291         if (offset)
 292         {
 293             void *s = PTR_SEG_TO_LIN(lParam);
 294             lParam = STACK16_PUSH( thdb, offset );
 295             memcpy( PTR_SEG_TO_LIN(lParam), s, offset );
 296         }
 297     }
 298
 299     args = (WORD *)THREAD_STACK16(thdb) - 5;
 300     args[0] = LOWORD(lParam);
 301     args[1] = HIWORD(lParam);
 302     args[2] = wParam;
 303     args[3] = msg;
 304     args[4] = hwnd;
 305
 306     ret = CallTo16_sreg_( &context, 5 * sizeof(WORD) );
 307     if (offset) STACK16_POP( thdb, offset );
 308     return ret;
 309 }
 310
 311
 312 /***********************************************************************
 313  *           THUNK_CallTaskReschedule
 314  */
 315 static BOOL32 WINAPI THUNK_CallTaskReschedule(void)
 316 {
 317     return CallTo16_word_(TASK_RescheduleProc);
 318 }
 319
 320
 321 /***********************************************************************
 322  *           THUNK_EnumObjects16   (GDI.71)
 323  */
 324 INT16 WINAPI THUNK_EnumObjects16( HDC16 hdc, INT16 nObjType,
 325                                   GOBJENUMPROC16 func, LPARAM lParam )
 326 {
 327     DECL_THUNK( thunk, func, CallTo16_word_ll );
 328     return EnumObjects16( hdc, nObjType, (GOBJENUMPROC16)&thunk, lParam );
 329 }
 330
 331
 332 /*************************************************************************
 333  *           THUNK_EnumFonts16   (GDI.70)
 334  */
 335 INT16 WINAPI THUNK_EnumFonts16( HDC16 hdc, LPCSTR lpFaceName,
 336                                 FONTENUMPROC16 func, LPARAM lParam )
 337 {
 338     DECL_THUNK( thunk, func, CallTo16_word_llwl );
 339     return EnumFonts16( hdc, lpFaceName, (FONTENUMPROC16)&thunk, lParam );
 340 }
 341
 342 /******************************************************************
 343  *           THUNK_EnumMetaFile16   (GDI.175)
 344  */
 345 BOOL16 WINAPI THUNK_EnumMetaFile16( HDC16 hdc, HMETAFILE16 hmf,
 346                                     MFENUMPROC16 func, LPARAM lParam )
 347 {
 348     DECL_THUNK( thunk, func, CallTo16_word_wllwl );
 349     return EnumMetaFile16( hdc, hmf, (MFENUMPROC16)&thunk, lParam );
 350 }
 351
 352
 353 /*************************************************************************
 354  *           THUNK_EnumFontFamilies16   (GDI.330)
 355  */
 356 INT16 WINAPI THUNK_EnumFontFamilies16( HDC16 hdc, LPCSTR lpszFamily,
 357                                        FONTENUMPROC16 func, LPARAM lParam )
 358 {
 359     DECL_THUNK( thunk, func, CallTo16_word_llwl );
 360     return EnumFontFamilies16(hdc, lpszFamily, (FONTENUMPROC16)&thunk, lParam);
 361 }
 362
 363
 364 /*************************************************************************
 365  *           THUNK_EnumFontFamiliesEx16   (GDI.613)
 366  */
 367 INT16 WINAPI THUNK_EnumFontFamiliesEx16( HDC16 hdc, LPLOGFONT16 lpLF,
 368                                          FONTENUMPROCEX16 func, LPARAM lParam,
 369                                          DWORD reserved )
 370 {
 371     DECL_THUNK( thunk, func, CallTo16_word_llwl );
 372     return EnumFontFamiliesEx16( hdc, lpLF, (FONTENUMPROCEX16)&thunk,
 373                                  lParam, reserved );
 374 }
 375
 376
 377 /**********************************************************************
 378  *           THUNK_LineDDA16   (GDI.100)
 379  */
 380 void WINAPI THUNK_LineDDA16( INT16 nXStart, INT16 nYStart, INT16 nXEnd,
 381                              INT16 nYEnd, LINEDDAPROC16 func, LPARAM lParam )
 382 {
 383     DECL_THUNK( thunk, func, CallTo16_word_wwl );
 384     LineDDA16( nXStart, nYStart, nXEnd, nYEnd, (LINEDDAPROC16)&thunk, lParam );
 385 }
 386
 387
 388 /*******************************************************************
 389  *           THUNK_EnumWindows16   (USER.54)
 390  */
 391 BOOL16 WINAPI THUNK_EnumWindows16( WNDENUMPROC16 func, LPARAM lParam )
 392 {
 393     DECL_THUNK( thunk, func, CallTo16_word_wl );
 394     return EnumWindows16( (WNDENUMPROC16)&thunk, lParam );
 395 }
 396
 397
 398 /**********************************************************************
 399  *           THUNK_EnumChildWindows16   (USER.55)
 400  */
 401 BOOL16 WINAPI THUNK_EnumChildWindows16( HWND16 parent, WNDENUMPROC16 func,
 402                                         LPARAM lParam )
 403 {
 404     DECL_THUNK( thunk, func, CallTo16_word_wl );
 405     return EnumChildWindows16( parent, (WNDENUMPROC16)&thunk, lParam );
 406 }
 407
 408
 409 /**********************************************************************
 410  *           THUNK_EnumTaskWindows16   (USER.225)
 411  */
 412 BOOL16 WINAPI THUNK_EnumTaskWindows16( HTASK16 hTask, WNDENUMPROC16 func,
 413                                        LPARAM lParam )
 414 {
 415     DECL_THUNK( thunk, func, CallTo16_word_wl );
 416     return EnumTaskWindows16( hTask, (WNDENUMPROC16)&thunk, lParam );
 417 }
 418
 419
 420 /***********************************************************************
 421  *           THUNK_EnumProps16   (USER.27)
 422  */
 423 INT16 WINAPI THUNK_EnumProps16( HWND16 hwnd, PROPENUMPROC16 func )
 424 {
 425     DECL_THUNK( thunk, func, CallTo16_word_wlw );
 426     return EnumProps16( hwnd, (PROPENUMPROC16)&thunk );
 427 }
 428
 429
 430 /***********************************************************************
 431  *           THUNK_GrayString16   (USER.185)
 432  */
 433 BOOL16 WINAPI THUNK_GrayString16( HDC16 hdc, HBRUSH16 hbr,
 434                                   GRAYSTRINGPROC16 func, LPARAM lParam,
 435                                   INT16 cch, INT16 x, INT16 y,
 436                                   INT16 cx, INT16 cy )
 437 {
 438     DECL_THUNK( thunk, func, CallTo16_word_wlw );
 439     if (!func)
 440         return GrayString16( hdc, hbr, NULL, lParam, cch, x, y, cx, cy );
 441     else
 442         return GrayString16( hdc, hbr, (GRAYSTRINGPROC16)&thunk, lParam, cch,
 443                              x, y, cx, cy );
 444 }
 445
 446
 447 /***********************************************************************
 448  *           THUNK_SetWindowsHook16   (USER.121)
 449  */
 450 FARPROC16 WINAPI THUNK_SetWindowsHook16( INT16 id, HOOKPROC16 proc )
 451 {
 452     HINSTANCE16 hInst = FarGetOwner( HIWORD(proc) );
 453     HTASK16 hTask = (id == WH_MSGFILTER) ? GetCurrentTask() : 0;
 454     THUNK *thunk = THUNK_Alloc( (FARPROC16)proc, (RELAY)CallTo16_long_wwl );
 455     if (!thunk) return 0;
 456     return (FARPROC16)SetWindowsHookEx16( id, (HOOKPROC16)thunk, hInst, hTask);
 457 }
 458
 459
 460 /***********************************************************************
 461  *           THUNK_UnhookWindowsHook16   (USER.234)
 462  */
 463 BOOL16 WINAPI THUNK_UnhookWindowsHook16( INT16 id, HOOKPROC16 proc )
 464 {
 465     BOOL16 ret;
 466     THUNK *thunk = THUNK_Find( (FARPROC16)proc );
 467     if (!thunk) return FALSE;
 468     ret = UnhookWindowsHook16( id, (HOOKPROC16)thunk );
 469     THUNK_Free( thunk );
 470     return ret;
 471 }
 472
 473
 474 /***********************************************************************
 475  *           THUNK_SetWindowsHookEx16   (USER.291)
 476  */
 477 HHOOK WINAPI THUNK_SetWindowsHookEx16( INT16 id, HOOKPROC16 proc,
 478                                        HINSTANCE16 hInst, HTASK16 hTask )
 479 {
 480     THUNK *thunk = THUNK_Alloc( (FARPROC16)proc, (RELAY)CallTo16_long_wwl );
 481     if (!thunk) return 0;
 482     return SetWindowsHookEx16( id, (HOOKPROC16)thunk, hInst, hTask );
 483 }
 484
 485
 486 /***********************************************************************
 487  *           THUNK_UnhookWindowHookEx16   (USER.292)
 488  */
 489 BOOL16 WINAPI THUNK_UnhookWindowsHookEx16( HHOOK hhook )
 490 {
 491     THUNK *thunk = (THUNK *)HOOK_GetProc16( hhook );
 492     BOOL16 ret = UnhookWindowsHookEx16( hhook );
 493     if (thunk) THUNK_Free( thunk );
 494     return ret;
 495 }
 496
 497
 498
 499 static FARPROC16 defDCHookProc = NULL;
 500
 501 /***********************************************************************
 502  *           THUNK_SetDCHook   (GDI.190)
 503  */
 504 BOOL16 WINAPI THUNK_SetDCHook( HDC16 hdc, FARPROC16 proc, DWORD dwHookData )
 505 {
 506     THUNK *thunk, *oldThunk;
 507
 508     if (!defDCHookProc)  /* Get DCHook Win16 entry point */
 509         defDCHookProc = NE_GetEntryPoint( GetModuleHandle16("USER"), 362 );
 510
 511     if (proc != defDCHookProc)
 512     {
 513         thunk = THUNK_Alloc( proc, (RELAY)CallTo16_word_wwll );
 514         if (!thunk) return FALSE;
 515     }
 516     else thunk = (THUNK *)DCHook;
 517
 518     /* Free the previous thunk */
 519     GetDCHook( hdc, (FARPROC16 *)&oldThunk );
 520     if (oldThunk && (oldThunk != (THUNK *)DCHook)) THUNK_Free( oldThunk );
 521
 522     return SetDCHook( hdc, (FARPROC16)thunk, dwHookData );
 523 }
 524
 525
 526 /***********************************************************************
 527  *           THUNK_GetDCHook   (GDI.191)
 528  */
 529 DWORD WINAPI THUNK_GetDCHook( HDC16 hdc, FARPROC16 *phookProc )
 530 {
 531     THUNK *thunk = NULL;
 532     DWORD ret = GetDCHook( hdc, (FARPROC16 *)&thunk );
 533     if (thunk)
 534     {
 535         if (thunk == (THUNK *)DCHook)
 536         {
 537             if (!defDCHookProc)  /* Get DCHook Win16 entry point */
 538                 defDCHookProc = NE_GetEntryPoint(GetModuleHandle16("USER"),362);
 539             *phookProc = defDCHookProc;
 540         }
 541         else *phookProc = thunk->proc;
 542     }
 543     return ret;
 544 }
 545
 546
 547 /***********************************************************************
 548  *           THUNK_SetTaskSignalProc (KERNEL.38)
 549  */
 550 FARPROC16 WINAPI THUNK_SetTaskSignalProc( HTASK16 hTask, FARPROC16 proc )
 551 {
 552     static FARPROC16 defSignalProc16 = NULL;
 553
 554     THUNK *thunk = NULL;
 555
 556     if( !defSignalProc16 )
 557         defSignalProc16 = NE_GetEntryPoint(GetModuleHandle16("USER"), 314 );
 558
 559     if( proc == defSignalProc16 )
 560         thunk = (THUNK*)SetTaskSignalProc( hTask, (FARPROC16)&USER_SignalProc );
 561     else
 562     {
 563         thunk = THUNK_Alloc( proc, (RELAY)CallTo16_word_wwwww );
 564         if( !thunk ) return FALSE;
 565         thunk = (THUNK*)SetTaskSignalProc( hTask, (FARPROC16)thunk );
 566     }
 567
 568     if( thunk != (THUNK*)USER_SignalProc )
 569     {
 570         if( !thunk ) return NULL;
 571
 572         proc = thunk->proc;
 573         THUNK_Free( thunk );
 574         return proc;
 575     }
 576     return defSignalProc16;
 577 }
 578
 579 /***********************************************************************
 580  *           THUNK_CreateThread16   (KERNEL.441)
 581  */
 582 static DWORD CALLBACK THUNK_StartThread16( LPVOID threadArgs )
 583 {
 584     FARPROC16 start = ((FARPROC16 *)threadArgs)[0];
 585     DWORD     param = ((DWORD *)threadArgs)[1];
 586     HeapFree( GetProcessHeap(), 0, threadArgs );
 587
 588     return CallTo16_long_l( start, param );
 589 }
 590 HANDLE32 WINAPI THUNK_CreateThread16( SECURITY_ATTRIBUTES *sa, DWORD stack,
 591                                       FARPROC16 start, SEGPTR param,
 592                                       DWORD flags, LPDWORD id )
 593 {
 594     DWORD *threadArgs = HeapAlloc( GetProcessHeap(), 0, 2*sizeof(DWORD) );
 595     if (!threadArgs) return INVALID_HANDLE_VALUE32;
 596     threadArgs[0] = (DWORD)start;
 597     threadArgs[1] = (DWORD)param;
 598
 599     return CreateThread( sa, stack, THUNK_StartThread16, threadArgs, flags, id );
 600 }
 601
 602 /***********************************************************************
 603  *           THUNK_WOWCallback16Ex      (WOW32.3)(KERNEL32.55)
 604  * Generic thunking routine to call 16 bit functions from 32bit code.
 605  *
 606  * RETURNS
 607  *      TRUE if the call was done
 608  */
 609 static BOOL32 WINAPI THUNK_WOWCallback16Ex(
 610         FARPROC16 proc,         /* [in] 16bit function to call */
 611         DWORD dwFlags,          /* [in] flags (WCB_*) */
 612         DWORD cbArgs,           /* [in] number of arguments */
 613         LPVOID xargs,           /* [in/out] arguments */
 614         LPDWORD pdwret          /* [out] return value of the 16bit call */
 615 ) {
 616     LPDWORD     args = (LPDWORD)xargs;
 617     DWORD       ret,i;
 618
 619     TRACE(relay,"(%p,0x%08lx,%ld,%p,%p)\n",
 620         proc,dwFlags,cbArgs,xargs,pdwret
 621     );
 622     if (dwFlags == WCB16_CDECL) {
 623         /* swap the arguments */
 624         args = HeapAlloc(GetProcessHeap(),0,cbArgs*sizeof(DWORD));
 625         for (i=0;i<cbArgs;i++)
 626             args[i] = ((DWORD*)xargs)[cbArgs-i-1];
 627     }
 628     switch (cbArgs) {
 629     case 0: ret = CallTo16_long_(proc);break;
 630     case 1: ret = CallTo16_long_l(proc,args[0]);break;
 631     case 2: ret = CallTo16_long_ll(proc,args[0],args[1]);break;
 632     case 3: ret = CallTo16_long_lll(proc,args[0],args[1],args[2]);break;
 633     case 4: ret = CallTo16_long_llll(proc,args[0],args[1],args[2],args[3]);
 634             break;
 635     case 5: ret = CallTo16_long_lllll(proc,args[0],args[1],args[2],args[3],
 636                 args[4]
 637             );
 638             break;
 639     case 6: ret = CallTo16_long_llllll(proc,args[0],args[1],args[2],args[3],
 640                 args[4],args[5]
 641             );
 642             break;
 643     case 7: ret = CallTo16_long_lllllll(proc,args[0],args[1],args[2],args[3],
 644                 args[4],args[5],args[6]
 645             );
 646             break;
 647     case 8: ret = CallTo16_long_llllllll(proc,args[0],args[1],args[2],args[3],
 648                 args[4],args[5],args[6],args[7]
 649             );
 650             break;
 651     case 9: ret = CallTo16_long_lllllllll(proc,args[0],args[1],args[2],args[3],
 652                 args[4],args[5],args[6],args[7],args[8]
 653             );
 654             break;
 655     case 10:ret = CallTo16_long_llllllllll(proc,args[0],args[1],args[2],args[3],
 656                 args[4],args[5],args[6],args[7],args[8],args[9]
 657             );
 658             break;
 659     case 11:ret = CallTo16_long_lllllllllll(proc,args[0],args[1],args[2],
 660                 args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10]
 661             );
 662             break;
 663     case 12:ret = CallTo16_long_llllllllllll(proc,args[0],args[1],args[2],
 664                 args[3],args[4],args[5],args[6],args[7],args[8],args[9],
 665                 args[10],args[11]
 666             );
 667             break;
 668     case 13:ret = CallTo16_long_lllllllllllll(proc,args[0],args[1],args[2],
 669                 args[3],args[4],args[5],args[6],args[7],args[8],args[9],
 670                 args[10],args[11],args[12]
 671             );
 672             break;
 673     case 14:ret = CallTo16_long_llllllllllllll(proc,args[0],args[1],args[2],
 674                 args[3],args[4],args[5],args[6],args[7],args[8],args[9],
 675                 args[10],args[11],args[12],args[13]
 676             );
 677             break;
 678     case 15:ret = CallTo16_long_lllllllllllllll(proc,args[0],args[1],args[2],
 679                 args[3],args[4],args[5],args[6],args[7],args[8],args[9],
 680                 args[10],args[11],args[12],args[13],args[14]
 681             );
 682             break;
 683     case 16:ret = CallTo16_long_llllllllllllllll(proc,args[0],args[1],args[2],
 684                 args[3],args[4],args[5],args[6],args[7],args[8],args[9],
 685                 args[10],args[11],args[12],args[13],args[14],args[15]
 686             );
 687             break;
 688     default:
 689             ERR(thunk,"%ld arguments not supported.\n",cbArgs);
 690             if (dwFlags == WCB16_CDECL)
 691                 HeapFree(GetProcessHeap(),0,args);
 692             return FALSE;
 693     }
 694     if (dwFlags == WCB16_CDECL)
 695         HeapFree(GetProcessHeap(),0,args);
 696     if (pdwret)
 697         *pdwret = ret;
 698     return TRUE;
 699 }
 700
 701 /***********************************************************************
 702  *           THUNK_MOUSE_Enable   (MOUSE.2)
 703  */
 704 static VOID WINAPI THUNK_CallMouseEventProc( FARPROC16 proc,
 705                                              DWORD dwFlags, DWORD dx, DWORD dy,
 706                                              DWORD cButtons, DWORD dwExtraInfo )
 707 {
 708     CONTEXT context;
 709
 710     memset( &context, 0, sizeof(context) );
 711     CS_reg(&context)  = SELECTOROF( proc );
 712     EIP_reg(&context) = OFFSETOF( proc );
 713     AX_reg(&context)  = (WORD)dwFlags;
 714     BX_reg(&context)  = (WORD)dx;
 715     CX_reg(&context)  = (WORD)dy;
 716     DX_reg(&context)  = (WORD)cButtons;
 717     SI_reg(&context)  = LOWORD( dwExtraInfo );
 718     DI_reg(&context)  = HIWORD( dwExtraInfo );
 719
 720     CallTo16_sreg_( &context, 0 );
 721 }
 722 VOID WINAPI THUNK_MOUSE_Enable( FARPROC16 proc )
 723 {
 724     static THUNK *lastThunk = NULL;
 725     static FARPROC16 lastProc = NULL;
 726
 727     if ( lastProc != proc )
 728     {
 729         if ( lastThunk )
 730             THUNK_Free( lastThunk );
 731
 732         if ( !proc )
 733             lastThunk = NULL;
 734         else
 735             lastThunk = THUNK_Alloc( proc, (RELAY)THUNK_CallMouseEventProc );
 736
 737         lastProc = proc;
 738     }
 739
 740     return MOUSE_Enable( (LPMOUSE_EVENT_PROC)lastThunk );
 741 }
 742
 743 /***********************************************************************
 744  *           GetMouseEventProc   (USER.337)
 745  */
 746 FARPROC16 WINAPI GetMouseEventProc(void)
 747 {
 748     HMODULE16 hmodule = GetModuleHandle16("USER");
 749     return NE_GetEntryPoint( hmodule, NE_GetOrdinal( hmodule, "mouse_event" ));
 750 }
 751
 752
 753 /***********************************************************************
 754  *           WIN16_mouse_event   (USER.299)
 755  */
 756 void WINAPI WIN16_mouse_event( CONTEXT *context )
 757 {
 758     mouse_event( AX_reg(context), BX_reg(context), CX_reg(context),
 759                  DX_reg(context), MAKELONG(SI_reg(context), DI_reg(context)) );
 760 }
 761
 762
 763 /***********************************************************************
 764  *           THUNK_KEYBD_Enable   (KEYBOARD.2)
 765  */
 766 static VOID WINAPI THUNK_CallKeybdEventProc( FARPROC16 proc,
 767                                              BYTE bVk, BYTE bScan,
 768                                              DWORD dwFlags, DWORD dwExtraInfo )
 769 {
 770     CONTEXT context;
 771
 772     memset( &context, 0, sizeof(context) );
 773     CS_reg(&context)  = SELECTOROF( proc );
 774     EIP_reg(&context) = OFFSETOF( proc );
 775     AH_reg(&context)  = (dwFlags & KEYEVENTF_KEYUP)? 0x80 : 0;
 776     AL_reg(&context)  = bVk;
 777     BH_reg(&context)  = (dwFlags & KEYEVENTF_EXTENDEDKEY)? 1 : 0;
 778     BL_reg(&context)  = bScan;
 779     SI_reg(&context)  = LOWORD( dwExtraInfo );
 780     DI_reg(&context)  = HIWORD( dwExtraInfo );
 781
 782     CallTo16_sreg_( &context, 0 );
 783 }
 784 VOID WINAPI THUNK_KEYBOARD_Enable( FARPROC16 proc, LPBYTE lpKeyState )
 785 {
 786     static THUNK *lastThunk = NULL;
 787     static FARPROC16 lastProc = NULL;
 788
 789     if ( lastProc != proc )
 790     {
 791         if ( lastThunk )
 792             THUNK_Free( lastThunk );
 793
 794         if ( !proc )
 795             lastThunk = NULL;
 796         else
 797             lastThunk = THUNK_Alloc( proc, (RELAY)THUNK_CallKeybdEventProc );
 798
 799         lastProc = proc;
 800     }
 801
 802     return KEYBOARD_Enable( (LPKEYBD_EVENT_PROC)lastThunk, lpKeyState );
 803 }
 804
 805 /***********************************************************************
 806  *           WIN16_keybd_event   (USER.289)
 807  */
 808 void WINAPI WIN16_keybd_event( CONTEXT *context )
 809 {
 810     DWORD dwFlags = 0;
 811
 812     if (AH_reg(context) & 0x80) dwFlags |= KEYEVENTF_KEYUP;
 813     if (BH_reg(context) & 1   ) dwFlags |= KEYEVENTF_EXTENDEDKEY;
 814
 815     keybd_event( AL_reg(context), BL_reg(context),
 816                  dwFlags, MAKELONG(SI_reg(context), DI_reg(context)) );
 817 }
 818
 819
 820 /***********************************************************************
 821  *           WIN16_CreateSystemTimer   (SYSTEM.2)
 822  */
 823 static void CALLBACK THUNK_CallSystemTimerProc( FARPROC16 proc, WORD timer )
 824 {
 825     CONTEXT context;
 826     memset( &context, '\0', sizeof(context) );
 827
 828     CS_reg( &context ) = SELECTOROF( proc );
 829     IP_reg( &context ) = OFFSETOF( proc );
 830     BP_reg( &context ) = OFFSETOF( THREAD_Current()->cur_stack )
 831                          + (WORD)&((STACK16FRAME*)0)->bp;
 832
 833     AX_reg( &context ) = timer;
 834
 835     CallTo16_sreg_( &context, 0 );
 836
 837     /* FIXME: This does not work if the signal occurs while some thread
 838               is currently in 16-bit code. With the current structure
 839               of the Wine thunking code, this seems to be hard to fix ... */
 840 }
 841 WORD WINAPI WIN16_CreateSystemTimer( WORD rate, FARPROC16 proc )
 842 {
 843     THUNK *thunk = THUNK_Alloc( proc, (RELAY)THUNK_CallSystemTimerProc );
 844     WORD timer = 0;
 845
 846 #if 1
 847     FIXME(system,"are currently broken, returning 0.\n");
 848 #else
 849     timer = CreateSystemTimer( rate, (SYSTEMTIMERPROC)thunk );
 850 #endif
 851
 852     if (!timer) THUNK_Free( thunk );
 853     return timer;
 854 }
 855
 856 /***********************************************************************
 857  *           THUNK_InitCallout
 858  */
 859 void THUNK_InitCallout(void)
 860 {
 861     HMODULE32 hModule = GetModuleHandle32A( "USER32" );
 862     if ( hModule )
 863     {
 864 #define GETADDR( var, name )  \
 865         *(FARPROC32 *)&Callout.##var = GetProcAddress32( hModule, name )
 866
 867         GETADDR( PeekMessage32A, "PeekMessageA" );
 868         GETADDR( PeekMessage32W, "PeekMessageW" );
 869         GETADDR( GetMessage32A, "GetMessageA" );
 870         GETADDR( GetMessage32W, "GetMessageW" );
 871         GETADDR( SendMessage32A, "SendMessageA" );
 872         GETADDR( SendMessage32W, "SendMessageW" );
 873         GETADDR( PostMessage32A, "PostMessageA" );
 874         GETADDR( PostMessage32W, "PostMessageW" );
 875         GETADDR( PostThreadMessage32A, "PostThreadMessageA" );
 876         GETADDR( PostThreadMessage32W, "PostThreadMessageW" );
 877         GETADDR( TranslateMessage32, "TranslateMessage" );
 878         GETADDR( DispatchMessage32W, "DispatchMessageW" );
 879         GETADDR( DispatchMessage32A, "DispatchMessageA" );
 880         GETADDR( RedrawWindow32, "RedrawWindow" );
 881
 882 #undef GETADDR
 883     }
 884
 885     hModule = GetModuleHandle16( "USER" );
 886     if ( hModule )
 887     {
 888 #define GETADDR( var, name, thk )  \
 889         *(FARPROC32 *)&Callout.##var = (FARPROC32) \
 890               THUNK_Alloc( WIN32_GetProcAddress16( hModule, name ), \
 891                            (RELAY)CallTo16_##thk )
 892
 893         GETADDR( PeekMessage16, "PeekMessage", word_lwwww );
 894         GETADDR( GetMessage16, "GetMessage", word_lwww );
 895         GETADDR( SendMessage16, "SendMessage", long_wwwl );
 896         GETADDR( PostMessage16, "PostMessage", word_wwwl );
 897         GETADDR( PostAppMessage16, "PostAppMessage", word_wwwl );
 898         GETADDR( TranslateMessage16, "TranslateMessage", word_l );
 899         GETADDR( DispatchMessage16, "DispatchMessage", long_l );
 900         GETADDR( RedrawWindow16, "RedrawWindow", word_wlww );
 901         GETADDR( InitThreadInput, "InitThreadInput", word_ww );
 902         GETADDR( UserYield, "UserYield", word_ );
 903
 904 #undef GETADDR
 905     }
 906 }
 907
 908 /***********************************************************************
 909  * 16->32 Flat Thunk routines:
 910  */
 911
 912 /***********************************************************************
 913  *              ThunkConnect16          (KERNEL.651)
 914  * Connects a 32bit and a 16bit thunkbuffer.
 915  */
 916 UINT32 WINAPI ThunkConnect16(
 917         LPSTR module16,              /* [in] name of win16 dll */
 918         LPSTR module32,              /* [in] name of win32 dll */
 919         HINSTANCE16 hInst16,         /* [in] hInst of win16 dll */
 920         DWORD dwReason,              /* [in] initialisation argument */
 921         struct ThunkDataCommon *TD,  /* [in/out] thunkbuffer */
 922         LPSTR thunkfun32,            /* [in] win32 thunkfunction */
 923         WORD cs                      /* [in] CS of win16 dll */
 924 ) {
 925     BOOL32 directionSL;
 926
 927     if (!lstrncmp32A(TD->magic, "SL01", 4))
 928     {
 929         directionSL = TRUE;
 930
 931         TRACE(thunk, "SL01 thunk %s (%lx) -> %s (%s), Reason: %ld\n",
 932                      module16, (DWORD)TD, module32, thunkfun32, dwReason);
 933     }
 934     else if (!lstrncmp32A(TD->magic, "LS01", 4))
 935     {
 936         directionSL = FALSE;
 937
 938         TRACE(thunk, "LS01 thunk %s (%lx) <- %s (%s), Reason: %ld\n",
 939                      module16, (DWORD)TD, module32, thunkfun32, dwReason);
 940     }
 941     else
 942     {
 943         ERR(thunk, "Invalid magic %c%c%c%c\n",
 944                    TD->magic[0], TD->magic[1], TD->magic[2], TD->magic[3]);
 945         return 0;
 946     }
 947
 948     switch (dwReason)
 949     {
 950         case DLL_PROCESS_ATTACH:
 951             if (directionSL)
 952             {
 953                 struct ThunkDataSL16 *SL16 = (struct ThunkDataSL16 *)TD;
 954                 struct ThunkDataSL   *SL   = SL16->fpData;
 955
 956                 if (SL == NULL)
 957                 {
 958                     SL = HeapAlloc(GetProcessHeap(), 0, sizeof(*SL));
 959
 960                     SL->common   = SL16->common;
 961                     SL->flags1   = SL16->flags1;
 962                     SL->flags2   = SL16->flags2;
 963
 964                     SL->apiDB    = PTR_SEG_TO_LIN(SL16->apiDatabase);
 965                     SL->targetDB = NULL;
 966
 967                     lstrcpyn32A(SL->pszDll16, module16, 255);
 968                     lstrcpyn32A(SL->pszDll32, module32, 255);
 969
 970                     /* We should create a SEGPTR to the ThunkDataSL,
 971                        but since the contents are not in the original format,
 972                        any access to this by 16-bit code would crash anyway. */
 973                     SL16->spData = 0;
 974                     SL16->fpData = SL;
 975                 }
 976
 977
 978                 if (SL->flags2 & 0x80000000)
 979                 {
 980                     TRACE(thunk, "Preloading 32-bit library\n");
 981                     LoadLibrary32A(module32);
 982                 }
 983             }
 984             else
 985             {
 986                 /* nothing to do */
 987             }
 988             break;
 989
 990         case DLL_PROCESS_DETACH:
 991             /* FIXME: cleanup */
 992             break;
 993     }
 994
 995     return 1;
 996 }
 997
 998
 999 /***********************************************************************
1000  *           C16ThkSL                           (KERNEL.630)
1001  */
1002
1003 void WINAPI C16ThkSL(CONTEXT *context)
1004 {
1005     extern void CallFrom16_t_long_(void);
1006     LPBYTE stub = PTR_SEG_TO_LIN(EAX_reg(context)), x = stub;
1007     WORD cs, ds;
1008     GET_CS(cs);
1009     GET_DS(ds);
1010
1011     /* We produce the following code:
1012      *
1013      *   mov ax, __FLATDS
1014      *   mov es, ax
1015      *   movzx ecx, cx
1016      *   mov edx, es:[ecx + $EDX]
1017      *   push bp
1018      *   push edx
1019      *   call __FLATCS:CallFrom16_t_long_
1020      */
1021
1022     *x++ = 0xB8; *((WORD *)x)++ = ds;
1023     *x++ = 0x8E; *x++ = 0xC0;
1024     *x++ = 0x66; *x++ = 0x0F; *x++ = 0xB7; *x++ = 0xC9;
1025     *x++ = 0x67; *x++ = 0x66; *x++ = 0x26; *x++ = 0x8B;
1026                  *x++ = 0x91; *((DWORD *)x)++ = EDX_reg(context);
1027
1028     *x++ = 0x55;
1029     *x++ = 0x66; *x++ = 0x52;
1030     *x++ = 0x66; *x++ = 0x9A; *((DWORD *)x)++ = (DWORD)CallFrom16_t_long_;
1031                               *((WORD *)x)++ = cs;
1032
1033     /* Jump to the stub code just created */
1034     IP_reg(context) = LOWORD(EAX_reg(context));
1035     CS_reg(context) = HIWORD(EAX_reg(context));
1036
1037     /* Since C16ThkSL got called by a jmp, we need to leave the
1038        orginal return address on the stack */
1039     SP_reg(context) -= 4;
1040 }
1041
1042 /***********************************************************************
1043  *           C16ThkSL01                         (KERNEL.631)
1044  */
1045
1046 void WINAPI C16ThkSL01(CONTEXT *context)
1047 {
1048     LPBYTE stub = PTR_SEG_TO_LIN(EAX_reg(context)), x = stub;
1049
1050     if (stub)
1051     {
1052         struct ThunkDataSL16 *SL16 = PTR_SEG_TO_LIN(EDX_reg(context));
1053         struct ThunkDataSL *td = SL16->fpData;
1054
1055         extern void CallFrom16_t_long_(void);
1056         DWORD procAddress = (DWORD)GetProcAddress16(GetModuleHandle16("KERNEL"), 631);
1057         WORD cs;
1058         GET_CS(cs);
1059
1060         if (!td)
1061         {
1062             ERR(thunk, "ThunkConnect16 was not called!\n");
1063             return;
1064         }
1065
1066         TRACE(thunk, "Creating stub for ThunkDataSL %08lx\n", (DWORD)td);
1067
1068
1069         /* We produce the following code:
1070          *
1071          *   xor eax, eax
1072          *   mov edx, $td
1073          *   call C16ThkSL01
1074          *   push bp
1075          *   push edx
1076          *   call __FLATCS:CallFrom16_t_long_
1077          */
1078
1079         *x++ = 0x66; *x++ = 0x33; *x++ = 0xC0;
1080         *x++ = 0x66; *x++ = 0xBA; *((DWORD *)x)++ = (DWORD)td;
1081         *x++ = 0x9A; *((DWORD *)x)++ = procAddress;
1082
1083         *x++ = 0x55;
1084         *x++ = 0x66; *x++ = 0x52;
1085         *x++ = 0x66; *x++ = 0x9A; *((DWORD *)x)++ = (DWORD)CallFrom16_t_long_;
1086                                   *((WORD *)x)++ = cs;
1087
1088         /* Jump to the stub code just created */
1089         IP_reg(context) = LOWORD(EAX_reg(context));
1090         CS_reg(context) = HIWORD(EAX_reg(context));
1091
1092         /* Since C16ThkSL01 got called by a jmp, we need to leave the
1093            orginal return address on the stack */
1094         SP_reg(context) -= 4;
1095     }
1096     else
1097     {
1098         struct ThunkDataSL *td = (struct ThunkDataSL *)EDX_reg(context);
1099         DWORD targetNr = CX_reg(context) / 4;
1100         struct SLTargetDB *tdb;
1101
1102         TRACE(thunk, "Process %08lx calling target %ld of ThunkDataSL %08lx\n",
1103                      (DWORD)PROCESS_Current(), targetNr, (DWORD)td);
1104
1105         for (tdb = td->targetDB; tdb; tdb = tdb->next)
1106             if (tdb->process == PROCESS_Current())
1107                 break;
1108
1109         if (!tdb)
1110         {
1111             TRACE(thunk, "Loading 32-bit library %s\n", td->pszDll32);
1112             LoadLibrary32A(td->pszDll32);
1113
1114             for (tdb = td->targetDB; tdb; tdb = tdb->next)
1115                 if (tdb->process == PROCESS_Current())
1116                     break;
1117         }
1118
1119         if (tdb)
1120         {
1121             EDX_reg(context) = tdb->targetTable[targetNr];
1122
1123             TRACE(thunk, "Call target is %08lx\n", EDX_reg(context));
1124         }
1125         else
1126         {
1127             WORD *stack = PTR_SEG_OFF_TO_LIN(SS_reg(context), SP_reg(context));
1128             DX_reg(context) = HIWORD(td->apiDB[targetNr].errorReturnValue);
1129             AX_reg(context) = LOWORD(td->apiDB[targetNr].errorReturnValue);
1130             IP_reg(context) = stack[2];
1131             CS_reg(context) = stack[3];
1132             SP_reg(context) += td->apiDB[targetNr].nrArgBytes + 4;
1133
1134             ERR(thunk, "Process %08lx did not ThunkConnect32 %s to %s\n",
1135                        (DWORD)PROCESS_Current(), td->pszDll32, td->pszDll16);
1136         }
1137     }
1138 }
1139
1140 DWORD WINAPI
1141 WOW16Call(WORD x,WORD y,WORD z) {
1142         int     i;
1143         DWORD   calladdr;
1144         FIXME(thunk,"(0x%04x,0x%04x,%d),calling (",x,y,z);
1145
1146         for (i=0;i<x/2;i++) {
1147                 WORD    a = STACK16_POP(THREAD_Current(),2);
1148                 DPRINTF("%04x ",a);
1149         }
1150         calladdr = STACK16_POP(THREAD_Current(),4);
1151         DPRINTF(") calling address was 0x%08lx\n",calladdr);
1152         return 0;
1153 }
1154
1155
1156 /***********************************************************************
1157  * 16<->32 Thunklet/Callback API:
1158  */
1159
1160 #pragma pack(1)
1161 typedef struct _THUNKLET
1162 {
1163     BYTE        prefix_target;
1164     BYTE        pushl_target;
1165     DWORD       target;
1166
1167     BYTE        prefix_relay;
1168     BYTE        pushl_relay;
1169     DWORD       relay;
1170
1171     BYTE        jmp_glue;
1172     DWORD       glue;
1173
1174     BYTE        type;
1175     HINSTANCE16 owner;
1176     struct _THUNKLET *next;
1177 } THUNKLET;
1178 #pragma pack(4)
1179
1180 #define THUNKLET_TYPE_LS  1
1181 #define THUNKLET_TYPE_SL  2
1182
1183 static HANDLE32  ThunkletHeap = 0;
1184 static THUNKLET *ThunkletAnchor = NULL;
1185
1186 static FARPROC32 ThunkletSysthunkGlueLS = 0;
1187 static SEGPTR    ThunkletSysthunkGlueSL = 0;
1188
1189 static FARPROC32 ThunkletCallbackGlueLS = 0;
1190 static SEGPTR    ThunkletCallbackGlueSL = 0;
1191
1192 /***********************************************************************
1193  *     THUNK_ThunkletInit
1194  */
1195 static BOOL32 THUNK_ThunkletInit( void )
1196 {
1197     LPBYTE thunk;
1198
1199     ThunkletHeap = HeapCreate(HEAP_WINE_SEGPTR | HEAP_WINE_CODE16SEG, 0, 0);
1200     if (!ThunkletHeap) return FALSE;
1201
1202     thunk = HeapAlloc( ThunkletHeap, 0, 5 );
1203     if (!thunk) return FALSE;
1204
1205     ThunkletSysthunkGlueLS = (FARPROC32)thunk;
1206     *thunk++ = 0x58;                             /* popl eax */
1207     *thunk++ = 0xC3;                             /* ret      */
1208
1209     ThunkletSysthunkGlueSL = HEAP_GetSegptr( ThunkletHeap, 0, thunk );
1210     *thunk++ = 0x66; *thunk++ = 0x58;            /* popl eax */
1211     *thunk++ = 0xCB;                             /* lret     */
1212
1213     return TRUE;
1214 }
1215
1216 /***********************************************************************
1217  *     SetThunkletCallbackGlue             (KERNEL.560)
1218  */
1219 void WINAPI SetThunkletCallbackGlue( FARPROC32 glueLS, SEGPTR glueSL )
1220 {
1221     ThunkletCallbackGlueLS = glueLS;
1222     ThunkletCallbackGlueSL = glueSL;
1223 }
1224
1225
1226 /***********************************************************************
1227  *     THUNK_FindThunklet
1228  */
1229 THUNKLET *THUNK_FindThunklet( DWORD target, DWORD relay,
1230                               DWORD glue, BYTE type )
1231 {
1232     THUNKLET *thunk;
1233
1234     for (thunk = ThunkletAnchor; thunk; thunk = thunk->next)
1235         if (    thunk->type   == type
1236              && thunk->target == target
1237              && thunk->relay  == relay
1238              && thunk->glue   == glue )
1239             return thunk;
1240
1241      return NULL;
1242 }
1243
1244 /***********************************************************************
1245  *     THUNK_AllocLSThunklet
1246  */
1247 FARPROC32 THUNK_AllocLSThunklet( SEGPTR target, DWORD relay,
1248                                  FARPROC32 glue, HTASK16 owner )
1249 {
1250     THUNKLET *thunk = THUNK_FindThunklet( (DWORD)target, relay, (DWORD)glue,
1251                                           THUNKLET_TYPE_LS );
1252     if (!thunk)
1253     {
1254         TDB *pTask = (TDB*)GlobalLock16( owner );
1255
1256         if ( !(thunk = HeapAlloc( ThunkletHeap, 0, sizeof(THUNKLET) )) )
1257             return 0;
1258
1259         thunk->prefix_target = thunk->prefix_relay = 0x90;
1260         thunk->pushl_target  = thunk->pushl_relay  = 0x68;
1261         thunk->jmp_glue = 0xE9;
1262
1263         thunk->target  = (DWORD)target;
1264         thunk->relay   = (DWORD)relay;
1265         thunk->glue    = (DWORD)glue - (DWORD)&thunk->type;
1266
1267         thunk->type    = THUNKLET_TYPE_LS;
1268         thunk->owner   = pTask? pTask->hInstance : 0;
1269
1270         thunk->next    = ThunkletAnchor;
1271         ThunkletAnchor = thunk;
1272     }
1273
1274     return (FARPROC32)thunk;
1275 }
1276
1277 /***********************************************************************
1278  *     THUNK_AllocSLThunklet
1279  */
1280 SEGPTR THUNK_AllocSLThunklet( FARPROC32 target, DWORD relay,
1281                               SEGPTR glue, HTASK16 owner )
1282 {
1283     THUNKLET *thunk = THUNK_FindThunklet( (DWORD)target, relay, (DWORD)glue,
1284                                           THUNKLET_TYPE_SL );
1285     if (!thunk)
1286     {
1287         TDB *pTask = (TDB*)GlobalLock16( owner );
1288
1289         if ( !(thunk = HeapAlloc( ThunkletHeap, 0, sizeof(THUNKLET) )) )
1290             return 0;
1291
1292         thunk->prefix_target = thunk->prefix_relay = 0x66;
1293         thunk->pushl_target  = thunk->pushl_relay  = 0x68;
1294         thunk->jmp_glue = 0xEA;
1295
1296         thunk->target  = (DWORD)target;
1297         thunk->relay   = (DWORD)relay;
1298         thunk->glue    = (DWORD)glue;
1299
1300         thunk->type    = THUNKLET_TYPE_SL;
1301         thunk->owner   = pTask? pTask->hInstance : 0;
1302
1303         thunk->next    = ThunkletAnchor;
1304         ThunkletAnchor = thunk;
1305     }
1306
1307     return HEAP_GetSegptr( ThunkletHeap, 0, thunk );
1308 }
1309
1310 /**********************************************************************
1311  *     IsLSThunklet
1312  */
1313 BOOL16 WINAPI IsLSThunklet( THUNKLET *thunk )
1314 {
1315     return    thunk->prefix_target == 0x90 && thunk->pushl_target == 0x68
1316            && thunk->prefix_relay  == 0x90 && thunk->pushl_relay  == 0x68
1317            && thunk->jmp_glue == 0xE9 && thunk->type == THUNKLET_TYPE_LS;
1318 }
1319
1320 /**********************************************************************
1321  *     IsSLThunklet                        (KERNEL.612)
1322  */
1323 BOOL16 WINAPI IsSLThunklet( THUNKLET *thunk )
1324 {
1325     return    thunk->prefix_target == 0x66 && thunk->pushl_target == 0x68
1326            && thunk->prefix_relay  == 0x66 && thunk->pushl_relay  == 0x68
1327            && thunk->jmp_glue == 0xEA && thunk->type == THUNKLET_TYPE_SL;
1328 }
1329
1330
1331
1332 /***********************************************************************
1333  *     AllocLSThunkletSysthunk             (KERNEL.607)
1334  */
1335 FARPROC32 WINAPI AllocLSThunkletSysthunk( SEGPTR target,
1336                                           FARPROC32 relay, DWORD dummy )
1337 {
1338     return THUNK_AllocLSThunklet( (SEGPTR)relay, (DWORD)target,
1339                                   ThunkletSysthunkGlueLS, GetCurrentTask() );
1340 }
1341
1342 /***********************************************************************
1343  *     AllocSLThunkletSysthunk             (KERNEL.608)
1344  */
1345 SEGPTR WINAPI AllocSLThunkletSysthunk( FARPROC32 target,
1346                                        SEGPTR relay, DWORD dummy )
1347 {
1348     return THUNK_AllocSLThunklet( (FARPROC32)relay, (DWORD)target,
1349                                   ThunkletSysthunkGlueSL, GetCurrentTask() );
1350 }
1351
1352
1353 /***********************************************************************
1354  *     AllocLSThunkletCallbackEx           (KERNEL.567)
1355  */
1356 FARPROC32 WINAPI AllocLSThunkletCallbackEx( SEGPTR target,
1357                                             DWORD relay, HTASK16 task )
1358 {
1359     THUNKLET *thunk = (THUNKLET *)PTR_SEG_TO_LIN( target );
1360     if (   IsSLThunklet( thunk ) && thunk->relay == relay
1361         && thunk->glue == (DWORD)ThunkletCallbackGlueSL )
1362         return (FARPROC32)thunk->target;
1363
1364     return THUNK_AllocLSThunklet( target, relay,
1365                                   ThunkletCallbackGlueLS, task );
1366 }
1367
1368 /***********************************************************************
1369  *     AllocSLThunkletCallbackEx           (KERNEL.568)
1370  */
1371 SEGPTR WINAPI AllocSLThunkletCallbackEx( FARPROC32 target,
1372                                          DWORD relay, HTASK16 task )
1373 {
1374     THUNKLET *thunk = (THUNKLET *)target;
1375     if (   IsLSThunklet( thunk ) && thunk->relay == relay
1376         && thunk->glue == (DWORD)ThunkletCallbackGlueLS )
1377         return (SEGPTR)thunk->target;
1378
1379     return THUNK_AllocSLThunklet( target, relay,
1380                                   ThunkletCallbackGlueSL, task );
1381 }
1382
1383 /***********************************************************************
1384  *     AllocLSThunkletCallback             (KERNEL.561) (KERNEL.606)
1385  */
1386 FARPROC32 WINAPI AllocLSThunkletCallback( SEGPTR target, DWORD relay )
1387 {
1388     return AllocLSThunkletCallbackEx( target, relay, GetCurrentTask() );
1389 }
1390
1391 /***********************************************************************
1392  *     AllocSLThunkletCallback             (KERNEL.562) (KERNEL.605)
1393  */
1394 SEGPTR WINAPI AllocSLThunkletCallback( FARPROC32 target, DWORD relay )
1395 {
1396     return AllocSLThunkletCallbackEx( target, relay, GetCurrentTask() );
1397 }
1398
1399 /***********************************************************************
1400  *     FindLSThunkletCallback              (KERNEL.563) (KERNEL.609)
1401  */
1402 FARPROC32 WINAPI FindLSThunkletCallback( SEGPTR target, DWORD relay )
1403 {
1404     THUNKLET *thunk = (THUNKLET *)PTR_SEG_TO_LIN( target );
1405     if (   thunk && IsSLThunklet( thunk ) && thunk->relay == relay
1406         && thunk->glue == (DWORD)ThunkletCallbackGlueSL )
1407         return (FARPROC32)thunk->target;
1408
1409     thunk = THUNK_FindThunklet( (DWORD)target, relay,
1410                                 (DWORD)ThunkletCallbackGlueLS,
1411                                 THUNKLET_TYPE_LS );
1412     return (FARPROC32)thunk;
1413 }
1414
1415 /***********************************************************************
1416  *     FindSLThunkletCallback              (KERNEL.564) (KERNEL.610)
1417  */
1418 SEGPTR WINAPI FindSLThunkletCallback( FARPROC32 target, DWORD relay )
1419 {
1420     THUNKLET *thunk = (THUNKLET *)target;
1421     if (   thunk && IsLSThunklet( thunk ) && thunk->relay == relay
1422         && thunk->glue == (DWORD)ThunkletCallbackGlueLS )
1423         return (SEGPTR)thunk->target;
1424
1425     thunk = THUNK_FindThunklet( (DWORD)target, relay,
1426                                 (DWORD)ThunkletCallbackGlueSL,
1427                                 THUNKLET_TYPE_SL );
1428     return HEAP_GetSegptr( ThunkletHeap, 0, thunk );
1429 }
1430
1431
1432 /***********************************************************************
1433  * Callback Client API
1434  */
1435
1436 #define N_CBC_FIXED    20
1437 #define N_CBC_VARIABLE 10
1438 #define N_CBC_TOTAL    (N_CBC_FIXED + N_CBC_VARIABLE)
1439
1440 static SEGPTR    *CBClientRelay16[ N_CBC_TOTAL ];
1441 static FARPROC32 *CBClientRelay32[ N_CBC_TOTAL ];
1442
1443 /***********************************************************************
1444  *     RegisterCBClient                    (KERNEL.619)
1445  */
1446 INT16 WINAPI RegisterCBClient( INT16 wCBCId,
1447                                SEGPTR *relay16, FARPROC32 *relay32 )
1448 {
1449     /* Search for free Callback ID */
1450     if ( wCBCId == -1 )
1451         for ( wCBCId = N_CBC_FIXED; wCBCId < N_CBC_TOTAL; wCBCId++ )
1452             if ( !CBClientRelay16[ wCBCId ] )
1453                 break;
1454
1455     /* Register Callback ID */
1456     if ( wCBCId > 0 && wCBCId < N_CBC_TOTAL )
1457     {
1458         CBClientRelay16[ wCBCId ] = relay16;
1459         CBClientRelay32[ wCBCId ] = relay32;
1460     }
1461     else
1462         wCBCId = 0;
1463
1464     return wCBCId;
1465 }
1466
1467 /***********************************************************************
1468  *     UnRegisterCBClient                  (KERNEL.622)
1469  */
1470 INT16 WINAPI UnRegisterCBClient( INT16 wCBCId,
1471                                  SEGPTR *relay16, FARPROC32 *relay32 )
1472 {
1473     if (    wCBCId >= N_CBC_FIXED && wCBCId < N_CBC_TOTAL
1474          && CBClientRelay16[ wCBCId ] == relay16
1475          && CBClientRelay32[ wCBCId ] == relay32 )
1476     {
1477         CBClientRelay16[ wCBCId ] = 0;
1478         CBClientRelay32[ wCBCId ] = 0;
1479     }
1480     else
1481         wCBCId = 0;
1482
1483     return wCBCId;
1484 }
1485
1486
1487 /***********************************************************************
1488  *     InitCBClient                        (KERNEL.623)
1489  */
1490 void WINAPI InitCBClient( FARPROC32 glueLS )
1491 {
1492     HMODULE16 kernel = GetModuleHandle16( "KERNEL" );
1493     SEGPTR glueSL = (SEGPTR)WIN32_GetProcAddress16( kernel, (LPCSTR)604 );
1494
1495     SetThunkletCallbackGlue( glueLS, glueSL );
1496 }
1497
1498 /***********************************************************************
1499  *     CBClientGlueSL                      (KERNEL.604)
1500  */
1501 void WINAPI CBClientGlueSL( CONTEXT *context )
1502 {
1503     /* Create stack frame */
1504     SEGPTR stackSeg = STACK16_PUSH( THREAD_Current(), 12 );
1505     LPWORD stackLin = PTR_SEG_TO_LIN( stackSeg );
1506     SEGPTR glue;
1507
1508     stackLin[3] = BP_reg( context );
1509     stackLin[2] = SI_reg( context );
1510     stackLin[1] = DI_reg( context );
1511     stackLin[0] = DS_reg( context );
1512
1513     BP_reg( context ) = OFFSETOF( stackSeg ) + 6;
1514     SP_reg( context ) = OFFSETOF( stackSeg ) - 4;
1515     GS_reg( context ) = 0;
1516
1517     /* Jump to 16-bit relay code */
1518     glue = CBClientRelay16[ stackLin[5] ][ stackLin[4] ];
1519     CS_reg ( context ) = SELECTOROF( glue );
1520     EIP_reg( context ) = OFFSETOF  ( glue );
1521 }
1522
1523 /***********************************************************************
1524  *     CBClientThunkSL                      (KERNEL.620)
1525  */
1526 void WINAPI CBClientThunkSL( CONTEXT *context )
1527 {
1528     /* Call 32-bit relay code */
1529     extern DWORD WINAPI CALL32_CBClient( FARPROC32 proc, LPWORD args );
1530
1531     LPWORD args = PTR_SEG_OFF_TO_LIN( SS_reg( context ), BP_reg( context ) );
1532     FARPROC32 proc = CBClientRelay32[ args[2] ][ args[1] ];
1533
1534     EAX_reg(context) = CALL32_CBClient( proc, args );
1535 }
1536