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 "debug.h"
  23 #include "flatthunk.h"
  24
  25
  26 /* List of the 16-bit callback functions. This list is used  */
  27 /* by the build program to generate the file if1632/callto16.S */
  28
  29 /* ### start build ### */
  30 extern LONG CALLBACK CallTo16_sreg_(const CONTEXT *context, INT32 offset);
  31 extern LONG CALLBACK CallTo16_lreg_(const CONTEXT *context, INT32 offset);
  32 extern WORD CALLBACK CallTo16_word_     (FARPROC16);
  33 extern LONG CALLBACK CallTo16_long_     (FARPROC16);
  34 extern WORD CALLBACK CallTo16_word_w    (FARPROC16,WORD);
  35 extern LONG CALLBACK CallTo16_long_l    (FARPROC16,LONG);
  36 extern WORD CALLBACK CallTo16_word_ww   (FARPROC16,WORD,WORD);
  37 extern WORD CALLBACK CallTo16_word_wl   (FARPROC16,WORD,LONG);
  38 extern WORD CALLBACK CallTo16_word_ll   (FARPROC16,LONG,LONG);
  39 extern LONG CALLBACK CallTo16_long_ll   (FARPROC16,LONG,LONG);
  40 extern WORD CALLBACK CallTo16_word_www  (FARPROC16,WORD,WORD,WORD);
  41 extern WORD CALLBACK CallTo16_word_wwl  (FARPROC16,WORD,WORD,LONG);
  42 extern WORD CALLBACK CallTo16_word_wlw  (FARPROC16,WORD,LONG,WORD);
  43 extern LONG CALLBACK CallTo16_long_wwl  (FARPROC16,WORD,WORD,LONG);
  44 extern LONG CALLBACK CallTo16_long_lll  (FARPROC16,LONG,LONG,LONG);
  45 extern WORD CALLBACK CallTo16_word_llwl (FARPROC16,LONG,LONG,WORD,LONG);
  46 extern WORD CALLBACK CallTo16_word_lwll (FARPROC16,LONG,WORD,LONG,LONG);
  47 extern WORD CALLBACK CallTo16_word_lwww (FARPROC16,LONG,WORD,WORD,WORD);
  48 extern WORD CALLBACK CallTo16_word_wwll (FARPROC16,WORD,WORD,LONG,LONG);
  49 extern WORD CALLBACK CallTo16_word_llll (FARPROC16,LONG,LONG,LONG,LONG);
  50 extern LONG CALLBACK CallTo16_long_llll (FARPROC16,LONG,LONG,LONG,LONG);
  51 extern WORD CALLBACK CallTo16_word_wllwl(FARPROC16,WORD,LONG,LONG,WORD,LONG);
  52 extern LONG CALLBACK CallTo16_long_lwwll(FARPROC16,LONG,WORD,WORD,LONG,LONG);
  53 extern WORD CALLBACK CallTo16_word_wwlll(FARPROC16,WORD,WORD,LONG,LONG,LONG);
  54 extern WORD CALLBACK CallTo16_word_wwwww(FARPROC16,WORD,WORD,WORD,WORD,WORD);
  55 extern WORD CALLBACK CallTo16_word_lwlll(FARPROC16,LONG,WORD,LONG,LONG,LONG);
  56 extern LONG CALLBACK CallTo16_long_lwlll(FARPROC16,LONG,WORD,LONG,LONG,LONG);
  57 extern LONG CALLBACK CallTo16_long_lllll(FARPROC16,LONG,LONG,LONG,LONG,LONG);
  58 extern LONG CALLBACK CallTo16_long_llllll(FARPROC16,LONG,LONG,LONG,LONG,LONG,
  59                                           LONG);
  60 extern LONG CALLBACK CallTo16_long_lllllll(FARPROC16,LONG,LONG,LONG,LONG,LONG,
  61                                            LONG,LONG);
  62 extern WORD CALLBACK CallTo16_word_llwwlll(FARPROC16,LONG,LONG,WORD,WORD,LONG,
  63                                            LONG,LONG);
  64 extern LONG CALLBACK CallTo16_word_lwwlllll(FARPROC16,LONG,WORD,WORD,LONG,LONG,
  65                                             LONG,LONG,LONG);
  66 extern LONG CALLBACK CallTo16_long_llllllll(FARPROC16,LONG,LONG,LONG,LONG,LONG,
  67                                             LONG,LONG,LONG);
  68 extern LONG CALLBACK CallTo16_long_lllllllll(FARPROC16,LONG,LONG,LONG,LONG,
  69                                              LONG,LONG,LONG,LONG,LONG);
  70 extern LONG CALLBACK CallTo16_long_llllllllll(FARPROC16,LONG,LONG,LONG,LONG,
  71                                               LONG,LONG,LONG,LONG,LONG,LONG);
  72 extern LONG CALLBACK CallTo16_long_lllllllllll(FARPROC16,LONG,LONG,LONG,LONG,
  73                                                LONG,LONG,LONG,LONG,LONG,LONG,
  74                                                LONG);
  75 extern LONG CALLBACK CallTo16_long_llllllllllll(FARPROC16,LONG,LONG,LONG,LONG,
  76                                                 LONG,LONG,LONG,LONG,LONG,LONG,
  77                                                 LONG,LONG);
  78 extern LONG CALLBACK CallTo16_long_lwwllwlllllw(FARPROC16,LONG,WORD,WORD,LONG,
  79                                                 LONG,WORD,LONG,LONG,LONG,LONG,
  80                                                 LONG,WORD);
  81 extern LONG CALLBACK CallTo16_long_lllllllllllll(FARPROC16,LONG,LONG,LONG,LONG,
  82                                                  LONG,LONG,LONG,LONG,LONG,LONG,
  83                                                  LONG,LONG,LONG);
  84 extern LONG CALLBACK CallTo16_long_llllllllllllll(FARPROC16,LONG,LONG,LONG,
  85                                                   LONG,LONG,LONG,LONG,LONG,
  86                                                   LONG,LONG,LONG,LONG,LONG,
  87                                                   LONG);
  88 extern LONG CALLBACK CallTo16_word_lwwwwlwwwwllll(FARPROC16,LONG,WORD,WORD,
  89                                                   WORD,WORD,LONG,WORD,WORD,
  90                                                   WORD,WORD,LONG,LONG,LONG,
  91                                                   LONG);
  92 extern LONG CALLBACK CallTo16_long_lllllllllllllll(FARPROC16,LONG,LONG,LONG,
  93                                                    LONG,LONG,LONG,LONG,LONG,
  94                                                    LONG,LONG,LONG,LONG,LONG,
  95                                                    LONG,LONG);
  96 extern LONG CALLBACK CallTo16_long_llllllllllllllll(FARPROC16,LONG,LONG,LONG,
  97                                                     LONG,LONG,LONG,LONG,LONG,
  98                                                     LONG,LONG,LONG,LONG,LONG,
  99                                                     LONG,LONG,LONG);
 100 /* ### stop build ### */
 101
 102
 103 typedef void (*RELAY)();
 104
 105 #pragma pack(1)
 106
 107 typedef struct tagTHUNK
 108 {
 109     BYTE             popl_eax;           /* 0x58  popl  %eax (return address)*/
 110     BYTE             pushl_func;         /* 0x68  pushl $proc */
 111     FARPROC32        proc WINE_PACKED;
 112     BYTE             pushl_eax;          /* 0x50  pushl %eax */
 113     BYTE             jmp;                /* 0xe9  jmp   relay (relative jump)*/
 114     RELAY            relay WINE_PACKED;
 115     struct tagTHUNK *next WINE_PACKED;
 116 } THUNK;
 117
 118 #pragma pack(4)
 119
 120 #define DECL_THUNK(name,proc,relay) \
 121     THUNK name = { 0x58, 0x68, (FARPROC32)(proc), 0x50, 0xe9, \
 122                    (RELAY)((char *)(relay) - (char *)(&(name).next)), NULL }
 123
 124
 125 static THUNK *firstThunk = NULL;
 126
 127 static LRESULT WINAPI THUNK_CallWndProc16( WNDPROC16 proc, HWND16 hwnd,
 128                                            UINT16 msg, WPARAM16 wParam,
 129                                            LPARAM lParam );
 130 static void WINAPI THUNK_CallTaskReschedule(void);
 131 static BOOL32 WINAPI THUNK_WOWCallback16Ex( FARPROC16,DWORD,DWORD,
 132                                             LPVOID,LPDWORD );
 133
 134 /* TASK_Reschedule() 16-bit entry point */
 135 static FARPROC16 TASK_RescheduleProc;
 136
 137 extern void CallFrom16_p_long_wwwll(void);
 138
 139 /* Callbacks function table for the emulator */
 140 static const CALLBACKS_TABLE CALLBACK_EmulatorTable =
 141 {
 142     (void *)CallTo16_sreg_,                /* CallRegisterShortProc */
 143     (void *)CallTo16_lreg_,                /* CallRegisterLongProc */
 144     THUNK_CallTaskReschedule,              /* CallTaskRescheduleProc */
 145     CallFrom16_p_long_wwwll,               /* CallFrom16WndProc */
 146     THUNK_CallWndProc16,                   /* CallWndProc */
 147     (void *)CallTo16_long_lwwll,           /* CallDriverProc */
 148     (void *)CallTo16_word_wwlll,           /* CallDriverCallback */
 149     (void *)CallTo16_word_wwlll,           /* CallTimeFuncProc */
 150     (void *)CallTo16_word_w,               /* CallWindowsExitProc */
 151     (void *)CallTo16_word_lwww,            /* CallWordBreakProc */
 152     (void *)CallTo16_word_ww,              /* CallBootAppProc */
 153     (void *)CallTo16_word_www,             /* CallLoadAppSegProc */
 154     (void *)CallTo16_word_,                /* CallSystemTimerProc */
 155     (void *)CallTo16_word_www,             /* CallResourceHandlerProc */
 156     (void *)CallTo16_long_l,               /* CallWOWCallbackProc */
 157     THUNK_WOWCallback16Ex,                 /* CallWOWCallback16Ex */
 158     (void *)CallTo16_long_l,               /* CallASPIPostProc */
 159     (void *)CallTo16_word_lwll,            /* CallDrvControlProc */
 160     (void *)CallTo16_word_lwlll,           /* CallDrvEnableProc */
 161     (void *)CallTo16_word_llll,            /* CallDrvEnumDFontsProc */
 162     (void *)CallTo16_word_lwll,            /* CallDrvEnumObjProc */
 163     (void *)CallTo16_word_lwwlllll,        /* CallDrvOutputProc */
 164     (void *)CallTo16_long_lwlll,           /* CallDrvRealizeProc */
 165     (void *)CallTo16_word_lwwwwlwwwwllll,  /* CallDrvStretchBltProc */
 166     (void *)CallTo16_long_lwwllwlllllw,    /* CallDrvExtTextOutProc */
 167     (void *)CallTo16_word_llwwlll          /* CallDrvGetCharWidth */
 168 };
 169
 170
 171 /***********************************************************************
 172  *           THUNK_Init
 173  */
 174 BOOL32 THUNK_Init(void)
 175 {
 176     /* Set the window proc calling functions */
 177     Callbacks = &CALLBACK_EmulatorTable;
 178     /* Get the 16-bit reschedule function pointer */
 179     TASK_RescheduleProc = MODULE_GetWndProcEntry16( "TASK_Reschedule" );
 180     return TRUE;
 181 }
 182
 183
 184 /***********************************************************************
 185  *           THUNK_Alloc
 186  */
 187 static THUNK *THUNK_Alloc( FARPROC32 func, RELAY relay )
 188 {
 189     THUNK *thunk = HeapAlloc( GetProcessHeap(), 0, sizeof(*thunk) );
 190     if (thunk)
 191     {
 192         thunk->popl_eax   = 0x58;
 193         thunk->pushl_func = 0x68;
 194         thunk->proc       = func;
 195         thunk->pushl_eax  = 0x50;
 196         thunk->jmp        = 0xe9;
 197         thunk->relay      = (RELAY)((char *)relay - (char *)(&thunk->next));
 198         thunk->next       = firstThunk;
 199         firstThunk = thunk;
 200     }
 201     return thunk;
 202 }
 203
 204
 205 /***********************************************************************
 206  *           THUNK_Find
 207  */
 208 static THUNK *THUNK_Find( FARPROC32 func )
 209 {
 210     THUNK *thunk = firstThunk;
 211     while (thunk && (thunk->proc != func)) thunk = thunk->next;
 212     return thunk;
 213 }
 214
 215
 216 /***********************************************************************
 217  *           THUNK_Free
 218  */
 219 static void THUNK_Free( THUNK *thunk )
 220 {
 221     if (HEAP_IsInsideHeap( GetProcessHeap(), 0, thunk ))
 222     {
 223         THUNK **prev = &firstThunk;
 224         while (*prev && (*prev != thunk)) prev = &(*prev)->next;
 225         if (*prev)
 226         {
 227             *prev = thunk->next;
 228             HeapFree( GetProcessHeap(), 0, thunk );
 229             return;
 230         }
 231     }
 232     ERR(thunk, "invalid thunk addr %p\n", thunk );
 233 }
 234
 235
 236 /***********************************************************************
 237  *           THUNK_CallWndProc16
 238  *
 239  * Call a 16-bit window procedure
 240  */
 241 static LRESULT WINAPI THUNK_CallWndProc16( WNDPROC16 proc, HWND16 hwnd,
 242                                            UINT16 msg, WPARAM16 wParam,
 243                                            LPARAM lParam )
 244 {
 245     CONTEXT context;
 246     LRESULT ret;
 247     WORD *args;
 248     WND *wndPtr = WIN_FindWndPtr( hwnd );
 249     DWORD offset = 0;
 250     THDB *thdb = THREAD_Current();
 251
 252     /* Window procedures want ax = hInstance, ds = es = ss */
 253
 254     DS_reg(&context)  = SELECTOROF(thdb->cur_stack);
 255     ES_reg(&context)  = DS_reg(&context);
 256     EAX_reg(&context) = wndPtr ? wndPtr->hInstance : DS_reg(&context);
 257     CS_reg(&context)  = SELECTOROF(proc);
 258     EIP_reg(&context) = OFFSETOF(proc);
 259     EBP_reg(&context) = OFFSETOF(thdb->cur_stack)
 260                         + (WORD)&((STACK16FRAME*)0)->bp;
 261
 262     if (lParam)
 263     {
 264         /* Some programs (eg. the "Undocumented Windows" examples, JWP) only
 265            work if structures passed in lParam are placed in the stack/data
 266            segment. Programmers easily make the mistake of converting lParam
 267            to a near rather than a far pointer, since Windows apparently
 268            allows this. We copy the structures to the 16 bit stack; this is
 269            ugly but makes these programs work. */
 270         switch (msg)
 271         {
 272           case WM_CREATE:
 273           case WM_NCCREATE:
 274             offset = sizeof(CREATESTRUCT16); break;
 275           case WM_DRAWITEM:
 276             offset = sizeof(DRAWITEMSTRUCT16); break;
 277           case WM_COMPAREITEM:
 278             offset = sizeof(COMPAREITEMSTRUCT16); break;
 279         }
 280         if (offset)
 281         {
 282             void *s = PTR_SEG_TO_LIN(lParam);
 283             lParam = STACK16_PUSH( thdb, offset );
 284             memcpy( PTR_SEG_TO_LIN(lParam), s, offset );
 285         }
 286     }
 287
 288     args = (WORD *)THREAD_STACK16(thdb) - 5;
 289     args[0] = LOWORD(lParam);
 290     args[1] = HIWORD(lParam);
 291     args[2] = wParam;
 292     args[3] = msg;
 293     args[4] = hwnd;
 294
 295     ret = CallTo16_sreg_( &context, 5 * sizeof(WORD) );
 296     if (offset) STACK16_POP( thdb, offset );
 297     return ret;
 298 }
 299
 300
 301 /***********************************************************************
 302  *           THUNK_CallTaskReschedule
 303  */
 304 static void WINAPI THUNK_CallTaskReschedule(void)
 305 {
 306     CallTo16_word_(TASK_RescheduleProc);
 307 }
 308
 309
 310 /***********************************************************************
 311  *           THUNK_EnumObjects16   (GDI.71)
 312  */
 313 INT16 WINAPI THUNK_EnumObjects16( HDC16 hdc, INT16 nObjType,
 314                                   GOBJENUMPROC16 func, LPARAM lParam )
 315 {
 316     DECL_THUNK( thunk, func, CallTo16_word_ll );
 317     return EnumObjects16( hdc, nObjType, (GOBJENUMPROC16)&thunk, lParam );
 318 }
 319
 320
 321 /*************************************************************************
 322  *           THUNK_EnumFonts16   (GDI.70)
 323  */
 324 INT16 WINAPI THUNK_EnumFonts16( HDC16 hdc, LPCSTR lpFaceName,
 325                                 FONTENUMPROC16 func, LPARAM lParam )
 326 {
 327     DECL_THUNK( thunk, func, CallTo16_word_llwl );
 328     return EnumFonts16( hdc, lpFaceName, (FONTENUMPROC16)&thunk, lParam );
 329 }
 330
 331 /******************************************************************
 332  *           THUNK_EnumMetaFile16   (GDI.175)
 333  */
 334 BOOL16 WINAPI THUNK_EnumMetaFile16( HDC16 hdc, HMETAFILE16 hmf,
 335                                     MFENUMPROC16 func, LPARAM lParam )
 336 {
 337     DECL_THUNK( thunk, func, CallTo16_word_wllwl );
 338     return EnumMetaFile16( hdc, hmf, (MFENUMPROC16)&thunk, lParam );
 339 }
 340
 341
 342 /*************************************************************************
 343  *           THUNK_EnumFontFamilies16   (GDI.330)
 344  */
 345 INT16 WINAPI THUNK_EnumFontFamilies16( HDC16 hdc, LPCSTR lpszFamily,
 346                                        FONTENUMPROC16 func, LPARAM lParam )
 347 {
 348     DECL_THUNK( thunk, func, CallTo16_word_llwl );
 349     return EnumFontFamilies16(hdc, lpszFamily, (FONTENUMPROC16)&thunk, lParam);
 350 }
 351
 352
 353 /*************************************************************************
 354  *           THUNK_EnumFontFamiliesEx16   (GDI.613)
 355  */
 356 INT16 WINAPI THUNK_EnumFontFamiliesEx16( HDC16 hdc, LPLOGFONT16 lpLF,
 357                                          FONTENUMPROCEX16 func, LPARAM lParam,
 358                                          DWORD reserved )
 359 {
 360     DECL_THUNK( thunk, func, CallTo16_word_llwl );
 361     return EnumFontFamiliesEx16( hdc, lpLF, (FONTENUMPROCEX16)&thunk,
 362                                  lParam, reserved );
 363 }
 364
 365
 366 /**********************************************************************
 367  *           THUNK_LineDDA16   (GDI.100)
 368  */
 369 void WINAPI THUNK_LineDDA16( INT16 nXStart, INT16 nYStart, INT16 nXEnd,
 370                              INT16 nYEnd, LINEDDAPROC16 func, LPARAM lParam )
 371 {
 372     DECL_THUNK( thunk, func, CallTo16_word_wwl );
 373     LineDDA16( nXStart, nYStart, nXEnd, nYEnd, (LINEDDAPROC16)&thunk, lParam );
 374 }
 375
 376
 377 /*******************************************************************
 378  *           THUNK_EnumWindows16   (USER.54)
 379  */
 380 BOOL16 WINAPI THUNK_EnumWindows16( WNDENUMPROC16 func, LPARAM lParam )
 381 {
 382     DECL_THUNK( thunk, func, CallTo16_word_wl );
 383     return EnumWindows16( (WNDENUMPROC16)&thunk, lParam );
 384 }
 385
 386
 387 /**********************************************************************
 388  *           THUNK_EnumChildWindows16   (USER.55)
 389  */
 390 BOOL16 WINAPI THUNK_EnumChildWindows16( HWND16 parent, WNDENUMPROC16 func,
 391                                         LPARAM lParam )
 392 {
 393     DECL_THUNK( thunk, func, CallTo16_word_wl );
 394     return EnumChildWindows16( parent, (WNDENUMPROC16)&thunk, lParam );
 395 }
 396
 397
 398 /**********************************************************************
 399  *           THUNK_EnumTaskWindows16   (USER.225)
 400  */
 401 BOOL16 WINAPI THUNK_EnumTaskWindows16( HTASK16 hTask, WNDENUMPROC16 func,
 402                                        LPARAM lParam )
 403 {
 404     DECL_THUNK( thunk, func, CallTo16_word_wl );
 405     return EnumTaskWindows16( hTask, (WNDENUMPROC16)&thunk, lParam );
 406 }
 407
 408
 409 /***********************************************************************
 410  *           THUNK_EnumProps16   (USER.27)
 411  */
 412 INT16 WINAPI THUNK_EnumProps16( HWND16 hwnd, PROPENUMPROC16 func )
 413 {
 414     DECL_THUNK( thunk, func, CallTo16_word_wlw );
 415     return EnumProps16( hwnd, (PROPENUMPROC16)&thunk );
 416 }
 417
 418
 419 /***********************************************************************
 420  *           THUNK_GrayString16   (USER.185)
 421  */
 422 BOOL16 WINAPI THUNK_GrayString16( HDC16 hdc, HBRUSH16 hbr,
 423                                   GRAYSTRINGPROC16 func, LPARAM lParam,
 424                                   INT16 cch, INT16 x, INT16 y,
 425                                   INT16 cx, INT16 cy )
 426 {
 427     DECL_THUNK( thunk, func, CallTo16_word_wlw );
 428     if (!func)
 429         return GrayString16( hdc, hbr, NULL, lParam, cch, x, y, cx, cy );
 430     else
 431         return GrayString16( hdc, hbr, (GRAYSTRINGPROC16)&thunk, lParam, cch,
 432                              x, y, cx, cy );
 433 }
 434
 435
 436 /***********************************************************************
 437  *           THUNK_SetWindowsHook16   (USER.121)
 438  */
 439 FARPROC16 WINAPI THUNK_SetWindowsHook16( INT16 id, HOOKPROC16 proc )
 440 {
 441     HINSTANCE16 hInst = FarGetOwner( HIWORD(proc) );
 442     HTASK16 hTask = (id == WH_MSGFILTER) ? GetCurrentTask() : 0;
 443     THUNK *thunk = THUNK_Alloc( (FARPROC16)proc, (RELAY)CallTo16_long_wwl );
 444     if (!thunk) return 0;
 445     return (FARPROC16)SetWindowsHookEx16( id, (HOOKPROC16)thunk, hInst, hTask);
 446 }
 447
 448
 449 /***********************************************************************
 450  *           THUNK_UnhookWindowsHook16   (USER.234)
 451  */
 452 BOOL16 WINAPI THUNK_UnhookWindowsHook16( INT16 id, HOOKPROC16 proc )
 453 {
 454     BOOL16 ret;
 455     THUNK *thunk = THUNK_Find( (FARPROC16)proc );
 456     if (!thunk) return FALSE;
 457     ret = UnhookWindowsHook16( id, (HOOKPROC16)thunk );
 458     THUNK_Free( thunk );
 459     return ret;
 460 }
 461
 462
 463 /***********************************************************************
 464  *           THUNK_SetWindowsHookEx16   (USER.291)
 465  */
 466 HHOOK WINAPI THUNK_SetWindowsHookEx16( INT16 id, HOOKPROC16 proc,
 467                                        HINSTANCE16 hInst, HTASK16 hTask )
 468 {
 469     THUNK *thunk = THUNK_Alloc( (FARPROC16)proc, (RELAY)CallTo16_long_wwl );
 470     if (!thunk) return 0;
 471     return SetWindowsHookEx16( id, (HOOKPROC16)thunk, hInst, hTask );
 472 }
 473
 474
 475 /***********************************************************************
 476  *           THUNK_UnhookWindowHookEx16   (USER.292)
 477  */
 478 BOOL16 WINAPI THUNK_UnhookWindowsHookEx16( HHOOK hhook )
 479 {
 480     THUNK *thunk = (THUNK *)HOOK_GetProc16( hhook );
 481     BOOL16 ret = UnhookWindowsHookEx16( hhook );
 482     if (thunk) THUNK_Free( thunk );
 483     return ret;
 484 }
 485
 486
 487
 488 static FARPROC16 defDCHookProc = NULL;
 489
 490 /***********************************************************************
 491  *           THUNK_SetDCHook   (GDI.190)
 492  */
 493 BOOL16 WINAPI THUNK_SetDCHook( HDC16 hdc, FARPROC16 proc, DWORD dwHookData )
 494 {
 495     THUNK *thunk, *oldThunk;
 496
 497     if (!defDCHookProc)  /* Get DCHook Win16 entry point */
 498         defDCHookProc = NE_GetEntryPoint( GetModuleHandle16("USER"), 362 );
 499
 500     if (proc != defDCHookProc)
 501     {
 502         thunk = THUNK_Alloc( proc, (RELAY)CallTo16_word_wwll );
 503         if (!thunk) return FALSE;
 504     }
 505     else thunk = (THUNK *)DCHook;
 506
 507     /* Free the previous thunk */
 508     GetDCHook( hdc, (FARPROC16 *)&oldThunk );
 509     if (oldThunk && (oldThunk != (THUNK *)DCHook)) THUNK_Free( oldThunk );
 510
 511     return SetDCHook( hdc, (FARPROC16)thunk, dwHookData );
 512 }
 513
 514
 515 /***********************************************************************
 516  *           THUNK_GetDCHook   (GDI.191)
 517  */
 518 DWORD WINAPI THUNK_GetDCHook( HDC16 hdc, FARPROC16 *phookProc )
 519 {
 520     THUNK *thunk = NULL;
 521     DWORD ret = GetDCHook( hdc, (FARPROC16 *)&thunk );
 522     if (thunk)
 523     {
 524         if (thunk == (THUNK *)DCHook)
 525         {
 526             if (!defDCHookProc)  /* Get DCHook Win16 entry point */
 527                 defDCHookProc = NE_GetEntryPoint(GetModuleHandle16("USER"),362);
 528             *phookProc = defDCHookProc;
 529         }
 530         else *phookProc = thunk->proc;
 531     }
 532     return ret;
 533 }
 534
 535
 536 /***********************************************************************
 537  *           THUNK_SetTaskSignalProc (KERNEL.38)
 538  */
 539 FARPROC16 WINAPI THUNK_SetTaskSignalProc( HTASK16 hTask, FARPROC16 proc )
 540 {
 541     static FARPROC16 defSignalProc16 = NULL;
 542
 543     THUNK *thunk = NULL;
 544
 545     if( !defSignalProc16 )
 546         defSignalProc16 = NE_GetEntryPoint(GetModuleHandle16("USER"), 314 );
 547
 548     if( proc == defSignalProc16 )
 549         thunk = (THUNK*)SetTaskSignalProc( hTask, (FARPROC16)&USER_SignalProc );
 550     else
 551     {
 552         thunk = THUNK_Alloc( proc, (RELAY)CallTo16_word_wwwww );
 553         if( !thunk ) return FALSE;
 554         thunk = (THUNK*)SetTaskSignalProc( hTask, (FARPROC16)thunk );
 555     }
 556
 557     if( thunk != (THUNK*)USER_SignalProc )
 558     {
 559         if( !thunk ) return NULL;
 560
 561         proc = thunk->proc;
 562         THUNK_Free( thunk );
 563         return proc;
 564     }
 565     return defSignalProc16;
 566 }
 567
 568
 569 /***********************************************************************
 570  *           THUNK_WOWCallback16Ex      (WOW32.3)(KERNEL32.55)
 571  * Generic thunking routine to call 16 bit functions from 32bit code.
 572  *
 573  * RETURNS
 574  *      TRUE if the call was done
 575  */
 576 static BOOL32 WINAPI THUNK_WOWCallback16Ex(
 577         FARPROC16 proc,         /* [in] 16bit function to call */
 578         DWORD dwFlags,          /* [in] flags (WCB_*) */
 579         DWORD cbArgs,           /* [in] number of arguments */
 580         LPVOID xargs,           /* [in/out] arguments */
 581         LPDWORD pdwret          /* [out] return value of the 16bit call */
 582 ) {
 583     LPDWORD     args = (LPDWORD)xargs;
 584     DWORD       ret,i;
 585
 586     TRACE(relay,"(%p,0x%08lx,%ld,%p,%p)\n",
 587         proc,dwFlags,cbArgs,xargs,pdwret
 588     );
 589     if (dwFlags == WCB16_CDECL) {
 590         /* swap the arguments */
 591         args = HeapAlloc(GetProcessHeap(),0,cbArgs*sizeof(DWORD));
 592         for (i=0;i<cbArgs;i++)
 593             args[i] = ((DWORD*)xargs)[cbArgs-i-1];
 594     }
 595     switch (cbArgs) {
 596     case 0: ret = CallTo16_long_(proc);break;
 597     case 1: ret = CallTo16_long_l(proc,args[0]);break;
 598     case 2: ret = CallTo16_long_ll(proc,args[0],args[1]);break;
 599     case 3: ret = CallTo16_long_lll(proc,args[0],args[1],args[2]);break;
 600     case 4: ret = CallTo16_long_llll(proc,args[0],args[1],args[2],args[3]);
 601             break;
 602     case 5: ret = CallTo16_long_lllll(proc,args[0],args[1],args[2],args[3],
 603                 args[4]
 604             );
 605             break;
 606     case 6: ret = CallTo16_long_llllll(proc,args[0],args[1],args[2],args[3],
 607                 args[4],args[5]
 608             );
 609             break;
 610     case 7: ret = CallTo16_long_lllllll(proc,args[0],args[1],args[2],args[3],
 611                 args[4],args[5],args[6]
 612             );
 613             break;
 614     case 8: ret = CallTo16_long_llllllll(proc,args[0],args[1],args[2],args[3],
 615                 args[4],args[5],args[6],args[7]
 616             );
 617             break;
 618     case 9: ret = CallTo16_long_lllllllll(proc,args[0],args[1],args[2],args[3],
 619                 args[4],args[5],args[6],args[7],args[8]
 620             );
 621             break;
 622     case 10:ret = CallTo16_long_llllllllll(proc,args[0],args[1],args[2],args[3],
 623                 args[4],args[5],args[6],args[7],args[8],args[9]
 624             );
 625             break;
 626     case 11:ret = CallTo16_long_lllllllllll(proc,args[0],args[1],args[2],
 627                 args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10]
 628             );
 629             break;
 630     case 12:ret = CallTo16_long_llllllllllll(proc,args[0],args[1],args[2],
 631                 args[3],args[4],args[5],args[6],args[7],args[8],args[9],
 632                 args[10],args[11]
 633             );
 634             break;
 635     case 13:ret = CallTo16_long_lllllllllllll(proc,args[0],args[1],args[2],
 636                 args[3],args[4],args[5],args[6],args[7],args[8],args[9],
 637                 args[10],args[11],args[12]
 638             );
 639             break;
 640     case 14:ret = CallTo16_long_llllllllllllll(proc,args[0],args[1],args[2],
 641                 args[3],args[4],args[5],args[6],args[7],args[8],args[9],
 642                 args[10],args[11],args[12],args[13]
 643             );
 644             break;
 645     case 15:ret = CallTo16_long_lllllllllllllll(proc,args[0],args[1],args[2],
 646                 args[3],args[4],args[5],args[6],args[7],args[8],args[9],
 647                 args[10],args[11],args[12],args[13],args[14]
 648             );
 649             break;
 650     case 16:ret = CallTo16_long_llllllllllllllll(proc,args[0],args[1],args[2],
 651                 args[3],args[4],args[5],args[6],args[7],args[8],args[9],
 652                 args[10],args[11],args[12],args[13],args[14],args[15]
 653             );
 654             break;
 655     default:
 656             ERR(thunk,"%ld arguments not supported.\n",cbArgs);
 657             if (dwFlags == WCB16_CDECL)
 658                 HeapFree(GetProcessHeap(),0,args);
 659             return FALSE;
 660     }
 661     if (dwFlags == WCB16_CDECL)
 662         HeapFree(GetProcessHeap(),0,args);
 663     if (pdwret)
 664         *pdwret = ret;
 665     return TRUE;
 666 }
 667
 668
 669 /***********************************************************************
 670  * 16->32 Flat Thunk routines:
 671  */
 672
 673 /***********************************************************************
 674  *              ThunkConnect16          (KERNEL.651)
 675  * Connects a 32bit and a 16bit thunkbuffer.
 676  */
 677 UINT32 WINAPI ThunkConnect16(
 678         LPSTR module16,              /* [in] name of win16 dll */
 679         LPSTR module32,              /* [in] name of win32 dll */
 680         HINSTANCE16 hInst16,         /* [in] hInst of win16 dll */
 681         DWORD dwReason,              /* [in] initialisation argument */
 682         struct ThunkDataCommon *TD,  /* [in/out] thunkbuffer */
 683         LPSTR thunkfun32,            /* [in] win32 thunkfunction */
 684         WORD CS                      /* [in] CS of win16 dll */
 685 ) {
 686     BOOL32 directionSL;
 687
 688     if (!lstrncmp32A(TD->magic, "SL01", 4))
 689     {
 690         directionSL = TRUE;
 691
 692         TRACE(thunk, "SL01 thunk %s (%lx) -> %s (%s), Reason: %ld\n",
 693                      module16, (DWORD)TD, module32, thunkfun32, dwReason);
 694     }
 695     else if (!lstrncmp32A(TD->magic, "LS01", 4))
 696     {
 697         directionSL = FALSE;
 698
 699         TRACE(thunk, "LS01 thunk %s (%lx) <- %s (%s), Reason: %ld\n",
 700                      module16, (DWORD)TD, module32, thunkfun32, dwReason);
 701     }
 702     else
 703     {
 704         ERR(thunk, "Invalid magic %c%c%c%c\n",
 705                    TD->magic[0], TD->magic[1], TD->magic[2], TD->magic[3]);
 706         return 0;
 707     }
 708
 709     switch (dwReason)
 710     {
 711         case DLL_PROCESS_ATTACH:
 712             if (directionSL)
 713             {
 714                 struct ThunkDataSL16 *SL16 = (struct ThunkDataSL16 *)TD;
 715                 struct ThunkDataSL   *SL   = SL16->fpData;
 716
 717                 if (SL == NULL)
 718                 {
 719                     SL = HeapAlloc(GetProcessHeap(), 0, sizeof(*SL));
 720
 721                     SL->common   = SL16->common;
 722                     SL->flags1   = SL16->flags1;
 723                     SL->flags2   = SL16->flags2;
 724
 725                     SL->apiDB    = PTR_SEG_TO_LIN(SL16->apiDatabase);
 726                     SL->targetDB = NULL;
 727
 728                     lstrcpyn32A(SL->pszDll16, module16, 255);
 729                     lstrcpyn32A(SL->pszDll32, module32, 255);
 730
 731                     /* We should create a SEGPTR to the ThunkDataSL,
 732                        but since the contents are not in the original format,
 733                        any access to this by 16-bit code would crash anyway. */
 734                     SL16->spData = 0;
 735                     SL16->fpData = SL;
 736                 }
 737
 738
 739                 if (SL->flags2 & 0x80000000)
 740                 {
 741                     TRACE(thunk, "Preloading 32-bit library\n");
 742                     LoadLibrary32A(module32);
 743                 }
 744             }
 745             else
 746             {
 747                 /* nothing to do */
 748             }
 749             break;
 750
 751         case DLL_PROCESS_DETACH:
 752             /* FIXME: cleanup */
 753             break;
 754     }
 755
 756     return 1;
 757 }
 758
 759
 760 /***********************************************************************
 761  *           C16ThkSL                           (KERNEL.630)
 762  */
 763
 764 void WINAPI C16ThkSL(CONTEXT *context)
 765 {
 766     extern void CallFrom16_t_long_(void);
 767     LPBYTE stub = PTR_SEG_TO_LIN(EAX_reg(context)), x = stub;
 768     WORD cs, ds;
 769     GET_CS(cs);
 770     GET_DS(ds);
 771
 772     /* We produce the following code:
 773      *
 774      *   mov ax, __FLATDS
 775      *   mov es, ax
 776      *   movzx ecx, cx
 777      *   mov edx, es:[ecx + $EDX]
 778      *   push bp
 779      *   push edx
 780      *   call __FLATCS:CallFrom16_t_long_
 781      */
 782
 783     *x++ = 0xB8; *((WORD *)x)++ = ds;
 784     *x++ = 0x8E; *x++ = 0xC0;
 785     *x++ = 0x60; *x++ = 0x0F; *x++ = 0xB7; *x++ = 0xC9;
 786     *x++ = 0x67; *x++ = 0x66; *x++ = 0x26; *x++ = 0x8B;
 787                  *x++ = 0x91; *((DWORD *)x)++ = EDX_reg(context);
 788
 789     *x++ = 0x55;
 790     *x++ = 0x66; *x++ = 0x52;
 791     *x++ = 0x66; *x++ = 0x9A; *((DWORD *)x)++ = (DWORD)CallFrom16_t_long_;
 792                               *((WORD *)x)++ = cs;
 793
 794     /* Jump to the stub code just created */
 795     IP_reg(context) = LOWORD(EAX_reg(context));
 796     CS_reg(context) = HIWORD(EAX_reg(context));
 797
 798     /* Since C16ThkSL got called by a jmp, we need to leave the
 799        orginal return address on the stack */
 800     SP_reg(context) -= 4;
 801 }
 802
 803 /***********************************************************************
 804  *           C16ThkSL01                         (KERNEL.631)
 805  */
 806
 807 void WINAPI C16ThkSL01(CONTEXT *context)
 808 {
 809     LPBYTE stub = PTR_SEG_TO_LIN(EAX_reg(context)), x = stub;
 810
 811     if (stub)
 812     {
 813         struct ThunkDataSL16 *SL16 = PTR_SEG_TO_LIN(EDX_reg(context));
 814         struct ThunkDataSL *td = SL16->fpData;
 815
 816         extern void CallFrom16_t_long_(void);
 817         DWORD procAddress = (DWORD)GetProcAddress16(GetModuleHandle16("KERNEL"), 631);
 818         WORD cs;
 819         GET_CS(cs);
 820
 821         if (!td)
 822         {
 823             ERR(thunk, "ThunkConnect16 was not called!\n");
 824             return;
 825         }
 826
 827         TRACE(thunk, "Creating stub for ThunkDataSL %08lx\n", (DWORD)td);
 828
 829
 830         /* We produce the following code:
 831          *
 832          *   xor eax, eax
 833          *   mov edx, $td
 834          *   call C16ThkSL01
 835          *   push bp
 836          *   push edx
 837          *   call __FLATCS:CallFrom16_t_long_
 838          */
 839
 840         *x++ = 0x66; *x++ = 0x33; *x++ = 0xC0;
 841         *x++ = 0x66; *x++ = 0xBA; *((DWORD *)x)++ = (DWORD)td;
 842         *x++ = 0x9A; *((DWORD *)x)++ = procAddress;
 843
 844         *x++ = 0x55;
 845         *x++ = 0x66; *x++ = 0x52;
 846         *x++ = 0x66; *x++ = 0x9A; *((DWORD *)x)++ = (DWORD)CallFrom16_t_long_;
 847                                   *((WORD *)x)++ = cs;
 848
 849         /* Jump to the stub code just created */
 850         IP_reg(context) = LOWORD(EAX_reg(context));
 851         CS_reg(context) = HIWORD(EAX_reg(context));
 852
 853         /* Since C16ThkSL01 got called by a jmp, we need to leave the
 854            orginal return address on the stack */
 855         SP_reg(context) -= 4;
 856     }
 857     else
 858     {
 859         struct ThunkDataSL *td = (struct ThunkDataSL *)EDX_reg(context);
 860         DWORD targetNr = CX_reg(context) / 4;
 861         struct SLTargetDB *tdb;
 862
 863         TRACE(thunk, "Process %08lx calling target %ld of ThunkDataSL %08lx\n",
 864                      (DWORD)PROCESS_Current(), targetNr, (DWORD)td);
 865
 866         for (tdb = td->targetDB; tdb; tdb = tdb->next)
 867             if (tdb->process == PROCESS_Current())
 868                 break;
 869
 870         if (!tdb)
 871         {
 872             TRACE(thunk, "Loading 32-bit library %s\n", td->pszDll32);
 873             LoadLibrary32A(td->pszDll32);
 874
 875             for (tdb = td->targetDB; tdb; tdb = tdb->next)
 876                 if (tdb->process == PROCESS_Current())
 877                     break;
 878         }
 879
 880         if (tdb)
 881         {
 882             EDX_reg(context) = tdb->targetTable[targetNr];
 883
 884             TRACE(thunk, "Call target is %08lx\n", EDX_reg(context));
 885         }
 886         else
 887         {
 888             WORD *stack = PTR_SEG_OFF_TO_LIN(SS_reg(context), SP_reg(context));
 889             DX_reg(context) = HIWORD(td->apiDB[targetNr].errorReturnValue);
 890             AX_reg(context) = LOWORD(td->apiDB[targetNr].errorReturnValue);
 891             IP_reg(context) = stack[2];
 892             CS_reg(context) = stack[3];
 893             SP_reg(context) += td->apiDB[targetNr].nrArgBytes + 4;
 894
 895             /* Win95 allows delayed loading of the 32-bit DLL.
 896                We don't do that at the moment. */
 897             ERR(thunk, "Process %08lx did not ThunkConnect32 %s to %s\n",
 898                        (DWORD)PROCESS_Current(), td->pszDll32, td->pszDll16);
 899         }
 900     }
 901 }