dlls/kernel32/wowthunk.c

   1 /*
   2  * Win32 WOW Generic Thunk API
   3  *
   4  * Copyright 1999 Ulrich Weigand
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <assert.h>
  25 #include <stdarg.h>
  26 #include <errno.h>
  27
  28 #include "wine/winbase16.h"
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winerror.h"
  32 #include "wownt32.h"
  33 #include "excpt.h"
  34 #include "thread.h"
  35 #include "winternl.h"
  36 #include "kernel_private.h"
  37 #include "kernel16_private.h"
  38 #include "wine/exception.h"
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(thunk);
  42 WINE_DECLARE_DEBUG_CHANNEL(relay);
  43 WINE_DECLARE_DEBUG_CHANNEL(snoop);
  44
  45 /*
  46  * These are the 16-bit side WOW routines.  They reside in wownt16.h
  47  * in the SDK; since we don't support Win16 source code anyway, I've
  48  * placed them here for compilation with Wine ...
  49  */
  50
  51 DWORD WINAPI GetVDMPointer32W16(SEGPTR,UINT16);
  52
  53 DWORD WINAPI LoadLibraryEx32W16(LPCSTR,DWORD,DWORD);
  54 DWORD WINAPI GetProcAddress32W16(DWORD,LPCSTR);
  55 DWORD WINAPI FreeLibrary32W16(DWORD);
  56
  57 #define CPEX_DEST_STDCALL   0x00000000L
  58 #define CPEX_DEST_CDECL     0x80000000L
  59
  60
  61 #ifdef __i386__
  62
  63 /* symbols exported from relay16.s */
  64 extern DWORD WINAPI wine_call_to_16( FARPROC16 target, DWORD cbArgs, PEXCEPTION_HANDLER handler );
  65 extern void WINAPI wine_call_to_16_regs( CONTEXT86 *context, DWORD cbArgs, PEXCEPTION_HANDLER handler );
  66 extern void __wine_call_to_16_ret(void);
  67 extern void CALL32_CBClient_Ret();
  68 extern void CALL32_CBClientEx_Ret();
  69 extern void DPMI_PendingEventCheck();
  70 extern void DPMI_PendingEventCheck_Cleanup();
  71 extern void DPMI_PendingEventCheck_Return();
  72 extern BYTE __wine_call16_start[];
  73 extern BYTE __wine_call16_end[];
  74
  75 extern void RELAY16_InitDebugLists(void);
  76
  77 static SEGPTR call16_ret_addr;  /* segptr to __wine_call_to_16_ret routine */
  78
  79 static WORD  dpmi_checker_selector;
  80 static DWORD dpmi_checker_offset_call;
  81 static DWORD dpmi_checker_offset_cleanup;
  82 static DWORD dpmi_checker_offset_return;
  83
  84 /***********************************************************************
  85  *           WOWTHUNK_Init
  86  */
  87 BOOL WOWTHUNK_Init(void)
  88 {
  89     /* allocate the code selector for CallTo16 routines */
  90     LDT_ENTRY entry;
  91     WORD codesel = wine_ldt_alloc_entries(1);
  92
  93     if (!codesel) return FALSE;
  94     wine_ldt_set_base( &entry, __wine_call16_start );
  95     wine_ldt_set_limit( &entry, (BYTE *)(&CallTo16_TebSelector + 1) - __wine_call16_start - 1 );
  96     wine_ldt_set_flags( &entry, WINE_LDT_FLAGS_CODE | WINE_LDT_FLAGS_32BIT );
  97     wine_ldt_set_entry( codesel, &entry );
  98
  99       /* Patch the return addresses for CallTo16 routines */
 100
 101     CallTo16_DataSelector = wine_get_ds();
 102     call16_ret_addr = MAKESEGPTR( codesel, (BYTE *)__wine_call_to_16_ret - __wine_call16_start );
 103     CALL32_CBClient_RetAddr =
 104         MAKESEGPTR( codesel, (BYTE *)CALL32_CBClient_Ret - __wine_call16_start );
 105     CALL32_CBClientEx_RetAddr =
 106         MAKESEGPTR( codesel, (BYTE *)CALL32_CBClientEx_Ret - __wine_call16_start );
 107
 108     /* Prepare selector and offsets for DPMI event checking. */
 109     dpmi_checker_selector = codesel;
 110     dpmi_checker_offset_call = (BYTE *)DPMI_PendingEventCheck - __wine_call16_start;
 111     dpmi_checker_offset_cleanup = (BYTE *)DPMI_PendingEventCheck_Cleanup - __wine_call16_start;
 112     dpmi_checker_offset_return = (BYTE *)DPMI_PendingEventCheck_Return - __wine_call16_start;
 113
 114     if (TRACE_ON(relay) || TRACE_ON(snoop)) RELAY16_InitDebugLists();
 115
 116     return TRUE;
 117 }
 118
 119
 120 /*************************************************************
 121  *            fix_selector
 122  *
 123  * Fix a selector load that caused an exception if it's in the
 124  * 16-bit relay code.
 125  */
 126 static BOOL fix_selector( CONTEXT *context )
 127 {
 128     WORD *stack;
 129     BYTE *instr = (BYTE *)context->Eip;
 130
 131     if (instr < __wine_call16_start || instr >= __wine_call16_end) return FALSE;
 132
 133     /* skip prefixes */
 134     while (*instr == 0x66 || *instr == 0x67) instr++;
 135
 136     switch(instr[0])
 137     {
 138     case 0x07: /* pop es */
 139     case 0x17: /* pop ss */
 140     case 0x1f: /* pop ds */
 141         break;
 142     case 0x0f: /* extended instruction */
 143         switch(instr[1])
 144         {
 145         case 0xa1: /* pop fs */
 146         case 0xa9: /* pop gs */
 147             break;
 148         default:
 149             return FALSE;
 150         }
 151         break;
 152     default:
 153         return FALSE;
 154     }
 155     stack = wine_ldt_get_ptr( context->SegSs, context->Esp );
 156     TRACE( "fixing up selector %x for pop instruction\n", *stack );
 157     *stack = 0;
 158     return TRUE;
 159 }
 160
 161
 162 /*************************************************************
 163  *            insert_event_check
 164  *
 165  * Make resuming the context check for pending DPMI events
 166  * before the original context is restored. This is required
 167  * because DPMI events are asynchronous, they are blocked while
 168  * Wine 32-bit code is being executed and we want to prevent
 169  * a race when returning back to 16-bit or 32-bit DPMI context.
 170  */
 171 static void insert_event_check( CONTEXT *context )
 172 {
 173     char *stack = wine_ldt_get_ptr( context->SegSs, context->Esp );
 174
 175     /* don't do event check while in system code */
 176     if (wine_ldt_is_system(context->SegCs))
 177         return;
 178
 179     if(context->SegCs == dpmi_checker_selector &&
 180        context->Eip   >= dpmi_checker_offset_call &&
 181        context->Eip   <= dpmi_checker_offset_cleanup)
 182     {
 183         /*
 184          * Nested call. Stack will be preserved.
 185          */
 186     }
 187     else if(context->SegCs == dpmi_checker_selector &&
 188             context->Eip   == dpmi_checker_offset_return)
 189     {
 190         /*
 191          * Nested call. We have just finished popping the fs
 192          * register, lets put it back into stack.
 193          */
 194
 195         stack -= sizeof(WORD);
 196         *(WORD*)stack = context->SegFs;
 197
 198         context->Esp -= 2;
 199     }
 200     else
 201     {
 202         /*
 203          * Call is not nested.
 204          * Push modified registers into stack.
 205          * These will be popped by the assembler stub.
 206          */
 207
 208         stack -= sizeof(DWORD);
 209         *(DWORD*)stack = context->EFlags;
 210
 211         stack -= sizeof(DWORD);
 212         *(DWORD*)stack = context->SegCs;
 213
 214         stack -= sizeof(DWORD);
 215         *(DWORD*)stack = context->Eip;
 216
 217         stack -= sizeof(WORD);
 218         *(WORD*)stack = context->SegFs;
 219
 220         context->Esp  -= 14;
 221     }
 222
 223     /*
 224      * Modify the context so that we jump into assembler stub.
 225      * TEB access is made easier by providing the stub
 226      * with the correct fs register value.
 227      */
 228
 229     context->SegCs = dpmi_checker_selector;
 230     context->Eip   = dpmi_checker_offset_call;
 231     context->SegFs = wine_get_fs();
 232 }
 233
 234
 235 /*************************************************************
 236  *            call16_handler
 237  *
 238  * Handler for exceptions occurring in 16-bit code.
 239  */
 240 static DWORD call16_handler( EXCEPTION_RECORD *record, EXCEPTION_REGISTRATION_RECORD *frame,
 241                              CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **pdispatcher )
 242 {
 243     if (record->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND))
 244     {
 245         /* unwinding: restore the stack pointer in the TEB, and leave the Win16 mutex */
 246         STACK32FRAME *frame32 = (STACK32FRAME *)((char *)frame - offsetof(STACK32FRAME,frame));
 247         NtCurrentTeb()->WOW32Reserved = (void *)frame32->frame16;
 248         _LeaveWin16Lock();
 249     }
 250     else if (record->ExceptionCode == EXCEPTION_ACCESS_VIOLATION ||
 251              record->ExceptionCode == EXCEPTION_PRIV_INSTRUCTION)
 252     {
 253         if (wine_ldt_is_system(context->SegCs))
 254         {
 255             if (fix_selector( context )) return ExceptionContinueExecution;
 256         }
 257         else
 258         {
 259             SEGPTR gpHandler;
 260             DWORD ret = __wine_emulate_instruction( record, context );
 261
 262             /*
 263              * Insert check for pending DPMI events. Note that this
 264              * check must be inserted after instructions have been
 265              * emulated because the instruction emulation requires
 266              * original CS:IP and the emulation may change TEB.dpmi_vif.
 267              */
 268             if(NtCurrentTeb()->dpmi_vif)
 269                 insert_event_check( context );
 270
 271             if (ret != ExceptionContinueSearch) return ret;
 272
 273             /* check for Win16 __GP handler */
 274             if ((gpHandler = HasGPHandler16( MAKESEGPTR( context->SegCs, context->Eip ) )))
 275             {
 276                 WORD *stack = wine_ldt_get_ptr( context->SegSs, context->Esp );
 277                 *--stack = context->SegCs;
 278                 *--stack = context->Eip;
 279
 280                 if (!IS_SELECTOR_32BIT(context->SegSs))
 281                     context->Esp = MAKELONG( LOWORD(context->Esp - 2*sizeof(WORD)),
 282                                              HIWORD(context->Esp) );
 283                 else
 284                     context->Esp -= 2*sizeof(WORD);
 285
 286                 context->SegCs = SELECTOROF( gpHandler );
 287                 context->Eip   = OFFSETOF( gpHandler );
 288                 return ExceptionContinueExecution;
 289             }
 290         }
 291     }
 292     else if (record->ExceptionCode == EXCEPTION_VM86_STI)
 293     {
 294         insert_event_check( context );
 295     }
 296     return ExceptionContinueSearch;
 297 }
 298
 299
 300 /*************************************************************
 301  *            vm86_handler
 302  *
 303  * Handler for exceptions occurring in vm86 code.
 304  */
 305 static DWORD vm86_handler( EXCEPTION_RECORD *record, EXCEPTION_REGISTRATION_RECORD *frame,
 306                            CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **pdispatcher )
 307 {
 308     if (record->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND))
 309         return ExceptionContinueSearch;
 310
 311     if (record->ExceptionCode == EXCEPTION_ACCESS_VIOLATION ||
 312         record->ExceptionCode == EXCEPTION_PRIV_INSTRUCTION)
 313     {
 314         return __wine_emulate_instruction( record, context );
 315     }
 316
 317     return ExceptionContinueSearch;
 318 }
 319
 320
 321 #else  /* __i386__ */
 322
 323 BOOL WOWTHUNK_Init(void)
 324 {
 325     return TRUE;
 326 }
 327
 328 #endif  /* __i386__ */
 329
 330
 331 /*
 332  *  32-bit WOW routines (in WOW32, but actually forwarded to KERNEL32)
 333  */
 334
 335 /**********************************************************************
 336  *           K32WOWGetDescriptor        (KERNEL32.70)
 337  */
 338 BOOL WINAPI K32WOWGetDescriptor( SEGPTR segptr, LPLDT_ENTRY ldtent )
 339 {
 340     return GetThreadSelectorEntry( GetCurrentThread(),
 341                                    segptr >> 16, ldtent );
 342 }
 343
 344 /**********************************************************************
 345  *           K32WOWGetVDMPointer        (KERNEL32.56)
 346  */
 347 LPVOID WINAPI K32WOWGetVDMPointer( DWORD vp, DWORD dwBytes, BOOL fProtectedMode )
 348 {
 349     /* FIXME: add size check too */
 350
 351     if ( fProtectedMode )
 352         return MapSL( vp );
 353     else
 354         return DOSMEM_MapRealToLinear( vp );
 355 }
 356
 357 /**********************************************************************
 358  *           K32WOWGetVDMPointerFix     (KERNEL32.68)
 359  */
 360 LPVOID WINAPI K32WOWGetVDMPointerFix( DWORD vp, DWORD dwBytes, BOOL fProtectedMode )
 361 {
 362     /*
 363      * Hmmm. According to the docu, we should call:
 364      *
 365      *          GlobalFix16( SELECTOROF(vp) );
 366      *
 367      * But this is unnecessary under Wine, as we never move global
 368      * memory segments in linear memory anyway.
 369      *
 370      * (I'm not so sure what we are *supposed* to do if
 371      *  fProtectedMode is TRUE, anyway ...)
 372      */
 373
 374     return K32WOWGetVDMPointer( vp, dwBytes, fProtectedMode );
 375 }
 376
 377 /**********************************************************************
 378  *           K32WOWGetVDMPointerUnfix   (KERNEL32.69)
 379  */
 380 VOID WINAPI K32WOWGetVDMPointerUnfix( DWORD vp )
 381 {
 382     /*
 383      * See above why we don't call:
 384      *
 385      * GlobalUnfix16( SELECTOROF(vp) );
 386      *
 387      */
 388 }
 389
 390 /**********************************************************************
 391  *           K32WOWGlobalAlloc16        (KERNEL32.59)
 392  */
 393 WORD WINAPI K32WOWGlobalAlloc16( WORD wFlags, DWORD cb )
 394 {
 395     return (WORD)GlobalAlloc16( wFlags, cb );
 396 }
 397
 398 /**********************************************************************
 399  *           K32WOWGlobalFree16         (KERNEL32.62)
 400  */
 401 WORD WINAPI K32WOWGlobalFree16( WORD hMem )
 402 {
 403     return (WORD)GlobalFree16( (HGLOBAL16)hMem );
 404 }
 405
 406 /**********************************************************************
 407  *           K32WOWGlobalUnlock16       (KERNEL32.61)
 408  */
 409 BOOL WINAPI K32WOWGlobalUnlock16( WORD hMem )
 410 {
 411     return (BOOL)GlobalUnlock16( (HGLOBAL16)hMem );
 412 }
 413
 414 /**********************************************************************
 415  *           K32WOWGlobalAllocLock16    (KERNEL32.63)
 416  */
 417 DWORD WINAPI K32WOWGlobalAllocLock16( WORD wFlags, DWORD cb, WORD *phMem )
 418 {
 419     WORD hMem = K32WOWGlobalAlloc16( wFlags, cb );
 420     if (phMem) *phMem = hMem;
 421
 422     return K32WOWGlobalLock16( hMem );
 423 }
 424
 425 /**********************************************************************
 426  *           K32WOWGlobalLockSize16     (KERNEL32.65)
 427  */
 428 DWORD WINAPI K32WOWGlobalLockSize16( WORD hMem, PDWORD pcb )
 429 {
 430     if ( pcb )
 431         *pcb = GlobalSize16( (HGLOBAL16)hMem );
 432
 433     return K32WOWGlobalLock16( hMem );
 434 }
 435
 436 /**********************************************************************
 437  *           K32WOWGlobalUnlockFree16   (KERNEL32.64)
 438  */
 439 WORD WINAPI K32WOWGlobalUnlockFree16( DWORD vpMem )
 440 {
 441     if ( !K32WOWGlobalUnlock16( HIWORD(vpMem) ) )
 442         return FALSE;
 443
 444     return K32WOWGlobalFree16( HIWORD(vpMem) );
 445 }
 446
 447
 448 /**********************************************************************
 449  *           K32WOWYield16              (KERNEL32.66)
 450  */
 451 VOID WINAPI K32WOWYield16( void )
 452 {
 453     /*
 454      * This does the right thing for both Win16 and Win32 tasks.
 455      * More or less, at least :-/
 456      */
 457     Yield16();
 458 }
 459
 460 /**********************************************************************
 461  *           K32WOWDirectedYield16       (KERNEL32.67)
 462  */
 463 VOID WINAPI K32WOWDirectedYield16( WORD htask16 )
 464 {
 465     /*
 466      * Argh.  Our scheduler doesn't like DirectedYield by Win32
 467      * tasks at all.  So we do hope that this routine is indeed
 468      * only ever called by Win16 tasks that have thunked up ...
 469      */
 470     DirectedYield16( (HTASK16)htask16 );
 471 }
 472
 473
 474 /***********************************************************************
 475  *           K32WOWHandle32              (KERNEL32.57)
 476  */
 477 HANDLE WINAPI K32WOWHandle32( WORD handle, WOW_HANDLE_TYPE type )
 478 {
 479     switch ( type )
 480     {
 481     case WOW_TYPE_HWND:
 482     case WOW_TYPE_HMENU:
 483     case WOW_TYPE_HDWP:
 484     case WOW_TYPE_HDROP:
 485     case WOW_TYPE_HDC:
 486     case WOW_TYPE_HFONT:
 487     case WOW_TYPE_HRGN:
 488     case WOW_TYPE_HBITMAP:
 489     case WOW_TYPE_HBRUSH:
 490     case WOW_TYPE_HPALETTE:
 491     case WOW_TYPE_HPEN:
 492     case WOW_TYPE_HACCEL:
 493         return (HANDLE)(ULONG_PTR)handle;
 494
 495     case WOW_TYPE_HMETAFILE:
 496         FIXME( "conversion of metafile handles not supported yet\n" );
 497         return (HANDLE)(ULONG_PTR)handle;
 498
 499     case WOW_TYPE_HTASK:
 500         return ((TDB *)GlobalLock16(handle))->teb->ClientId.UniqueThread;
 501
 502     case WOW_TYPE_FULLHWND:
 503         FIXME( "conversion of full window handles not supported yet\n" );
 504         return (HANDLE)(ULONG_PTR)handle;
 505
 506     default:
 507         ERR( "handle 0x%04x of unknown type %d\n", handle, type );
 508         return (HANDLE)(ULONG_PTR)handle;
 509     }
 510 }
 511
 512 /***********************************************************************
 513  *           K32WOWHandle16              (KERNEL32.58)
 514  */
 515 WORD WINAPI K32WOWHandle16( HANDLE handle, WOW_HANDLE_TYPE type )
 516 {
 517     switch ( type )
 518     {
 519     case WOW_TYPE_HWND:
 520     case WOW_TYPE_HMENU:
 521     case WOW_TYPE_HDWP:
 522     case WOW_TYPE_HDROP:
 523     case WOW_TYPE_HDC:
 524     case WOW_TYPE_HFONT:
 525     case WOW_TYPE_HRGN:
 526     case WOW_TYPE_HBITMAP:
 527     case WOW_TYPE_HBRUSH:
 528     case WOW_TYPE_HPALETTE:
 529     case WOW_TYPE_HPEN:
 530     case WOW_TYPE_HACCEL:
 531     case WOW_TYPE_FULLHWND:
 532         if ( HIWORD(handle ) )
 533                 ERR( "handle %p of type %d has non-zero HIWORD\n", handle, type );
 534         return LOWORD(handle);
 535
 536     case WOW_TYPE_HMETAFILE:
 537         FIXME( "conversion of metafile handles not supported yet\n" );
 538         return LOWORD(handle);
 539
 540     case WOW_TYPE_HTASK:
 541         return TASK_GetTaskFromThread( (DWORD)handle );
 542
 543     default:
 544         ERR( "handle %p of unknown type %d\n", handle, type );
 545         return LOWORD(handle);
 546     }
 547 }
 548
 549 /**********************************************************************
 550  *           K32WOWCallback16Ex         (KERNEL32.55)
 551  */
 552 BOOL WINAPI K32WOWCallback16Ex( DWORD vpfn16, DWORD dwFlags,
 553                                 DWORD cbArgs, LPVOID pArgs, LPDWORD pdwRetCode )
 554 {
 555 #ifdef __i386__
 556     /*
 557      * Arguments must be prepared in the correct order by the caller
 558      * (both for PASCAL and CDECL calling convention), so we simply
 559      * copy them to the 16-bit stack ...
 560      */
 561     char *stack = (char *)CURRENT_STACK16 - cbArgs;
 562
 563     memcpy( stack, pArgs, cbArgs );
 564
 565     if (dwFlags & (WCB16_REGS|WCB16_REGS_LONG))
 566     {
 567         CONTEXT *context = (CONTEXT *)pdwRetCode;
 568
 569         if (TRACE_ON(relay))
 570         {
 571             DWORD count = cbArgs / sizeof(WORD);
 572             WORD * wstack = (WORD *)stack;
 573
 574             DPRINTF("%04x:CallTo16(func=%04x:%04x,ds=%04x",
 575                     GetCurrentThreadId(),
 576                     context->SegCs, LOWORD(context->Eip), context->SegDs );
 577             while (count) DPRINTF( ",%04x", wstack[--count] );
 578             DPRINTF(") ss:sp=%04x:%04x",
 579                     SELECTOROF(NtCurrentTeb()->WOW32Reserved), OFFSETOF(NtCurrentTeb()->WOW32Reserved) );
 580             DPRINTF(" ax=%04x bx=%04x cx=%04x dx=%04x si=%04x di=%04x bp=%04x es=%04x fs=%04x\n",
 581                     (WORD)context->Eax, (WORD)context->Ebx, (WORD)context->Ecx,
 582                     (WORD)context->Edx, (WORD)context->Esi, (WORD)context->Edi,
 583                     (WORD)context->Ebp, (WORD)context->SegEs, (WORD)context->SegFs );
 584             SYSLEVEL_CheckNotLevel( 2 );
 585         }
 586
 587         if (context->EFlags & 0x00020000)  /* v86 mode */
 588         {
 589             EXCEPTION_REGISTRATION_RECORD frame;
 590             frame.Handler = vm86_handler;
 591             errno = 0;
 592             __wine_push_frame( &frame );
 593             __wine_enter_vm86( context );
 594             __wine_pop_frame( &frame );
 595             if (errno != 0)  /* enter_vm86 will fall with ENOSYS on x64 kernels */
 596             {
 597                 ERR("__wine_enter_vm86 failed (errno=%d)\n", errno);
 598                 if (errno == ENOSYS)
 599                     SetLastError(ERROR_NOT_SUPPORTED);
 600                 else
 601                     SetLastError(ERROR_GEN_FAILURE);
 602                 return FALSE;
 603             }
 604         }
 605         else
 606         {
 607             /* push return address */
 608             if (dwFlags & WCB16_REGS_LONG)
 609             {
 610                 stack -= sizeof(DWORD);
 611                 *((DWORD *)stack) = HIWORD(call16_ret_addr);
 612                 stack -= sizeof(DWORD);
 613                 *((DWORD *)stack) = LOWORD(call16_ret_addr);
 614                 cbArgs += 2 * sizeof(DWORD);
 615             }
 616             else
 617             {
 618                 stack -= sizeof(SEGPTR);
 619                 *((SEGPTR *)stack) = call16_ret_addr;
 620                 cbArgs += sizeof(SEGPTR);
 621             }
 622
 623             /*
 624              * Start call by checking for pending events.
 625              * Note that wine_call_to_16_regs overwrites context stack
 626              * pointer so we may modify it here without a problem.
 627              */
 628             if (NtCurrentTeb()->dpmi_vif)
 629             {
 630                 context->SegSs = wine_get_ds();
 631                 context->Esp   = (DWORD)stack;
 632                 insert_event_check( context );
 633                 cbArgs += (DWORD)stack - context->Esp;
 634             }
 635
 636             _EnterWin16Lock();
 637             wine_call_to_16_regs( context, cbArgs, call16_handler );
 638             _LeaveWin16Lock();
 639         }
 640
 641         if (TRACE_ON(relay))
 642         {
 643             DPRINTF("%04x:RetFrom16() ss:sp=%04x:%04x ",
 644                     GetCurrentThreadId(), SELECTOROF(NtCurrentTeb()->WOW32Reserved),
 645                     OFFSETOF(NtCurrentTeb()->WOW32Reserved));
 646             DPRINTF(" ax=%04x bx=%04x cx=%04x dx=%04x bp=%04x sp=%04x\n",
 647                     (WORD)context->Eax, (WORD)context->Ebx, (WORD)context->Ecx,
 648                     (WORD)context->Edx, (WORD)context->Ebp, (WORD)context->Esp );
 649             SYSLEVEL_CheckNotLevel( 2 );
 650         }
 651     }
 652     else
 653     {
 654         DWORD ret;
 655
 656         if (TRACE_ON(relay))
 657         {
 658             DWORD count = cbArgs / sizeof(WORD);
 659             WORD * wstack = (WORD *)stack;
 660
 661             DPRINTF("%04x:CallTo16(func=%04x:%04x,ds=%04x",
 662                     GetCurrentThreadId(), HIWORD(vpfn16), LOWORD(vpfn16),
 663                     SELECTOROF(NtCurrentTeb()->WOW32Reserved) );
 664             while (count) DPRINTF( ",%04x", wstack[--count] );
 665             DPRINTF(") ss:sp=%04x:%04x\n",
 666                     SELECTOROF(NtCurrentTeb()->WOW32Reserved), OFFSETOF(NtCurrentTeb()->WOW32Reserved) );
 667             SYSLEVEL_CheckNotLevel( 2 );
 668         }
 669
 670         /* push return address */
 671         stack -= sizeof(SEGPTR);
 672         *((SEGPTR *)stack) = call16_ret_addr;
 673         cbArgs += sizeof(SEGPTR);
 674
 675         /*
 676          * Actually, we should take care whether the called routine cleans up
 677          * its stack or not.  Fortunately, our wine_call_to_16 core doesn't rely on
 678          * the callee to do so; after the routine has returned, the 16-bit
 679          * stack pointer is always reset to the position it had before.
 680          */
 681         _EnterWin16Lock();
 682         ret = wine_call_to_16( (FARPROC16)vpfn16, cbArgs, call16_handler );
 683         if (pdwRetCode) *pdwRetCode = ret;
 684         _LeaveWin16Lock();
 685
 686         if (TRACE_ON(relay))
 687         {
 688             DPRINTF("%04x:RetFrom16() ss:sp=%04x:%04x retval=%08x\n",
 689                     GetCurrentThreadId(), SELECTOROF(NtCurrentTeb()->WOW32Reserved),
 690                     OFFSETOF(NtCurrentTeb()->WOW32Reserved), ret);
 691             SYSLEVEL_CheckNotLevel( 2 );
 692         }
 693     }
 694 #else
 695     assert(0);  /* cannot call to 16-bit on non-Intel architectures */
 696 #endif  /* __i386__ */
 697
 698     return TRUE;  /* success */
 699 }
 700
 701 /**********************************************************************
 702  *           K32WOWCallback16            (KERNEL32.54)
 703  */
 704 DWORD WINAPI K32WOWCallback16( DWORD vpfn16, DWORD dwParam )
 705 {
 706     DWORD ret;
 707
 708     if ( !K32WOWCallback16Ex( vpfn16, WCB16_PASCAL,
 709                            sizeof(DWORD), &dwParam, &ret ) )
 710         ret = 0L;
 711
 712     return ret;
 713 }
 714
 715
 716 /*
 717  *  16-bit WOW routines (in KERNEL)
 718  */
 719
 720 /**********************************************************************
 721  *           GetVDMPointer32W      (KERNEL.516)
 722  */
 723 DWORD WINAPI GetVDMPointer32W16( SEGPTR vp, UINT16 fMode )
 724 {
 725     GlobalPageLock16(GlobalHandle16(SELECTOROF(vp)));
 726     return (DWORD)K32WOWGetVDMPointer( vp, 0, (DWORD)fMode );
 727 }
 728
 729 /***********************************************************************
 730  *           LoadLibraryEx32W      (KERNEL.513)
 731  */
 732 DWORD WINAPI LoadLibraryEx32W16( LPCSTR lpszLibFile, DWORD hFile, DWORD dwFlags )
 733 {
 734     HMODULE hModule;
 735     DWORD mutex_count;
 736     OFSTRUCT ofs;
 737     const char *p;
 738
 739     if (!lpszLibFile)
 740     {
 741         SetLastError(ERROR_INVALID_PARAMETER);
 742         return 0;
 743     }
 744
 745     /* if the file cannot be found, call LoadLibraryExA anyway, since it might be
 746        a builtin module. This case is handled in MODULE_LoadLibraryExA */
 747
 748     if ((p = strrchr( lpszLibFile, '.' )) && !strchr( p, '\\' ))  /* got an extension */
 749     {
 750         if (OpenFile16( lpszLibFile, &ofs, OF_EXIST ) != HFILE_ERROR16)
 751             lpszLibFile = ofs.szPathName;
 752     }
 753     else
 754     {
 755         char buffer[MAX_PATH+4];
 756         strcpy( buffer, lpszLibFile );
 757         strcat( buffer, ".dll" );
 758         if (OpenFile16( buffer, &ofs, OF_EXIST ) != HFILE_ERROR16)
 759             lpszLibFile = ofs.szPathName;
 760     }
 761
 762     ReleaseThunkLock( &mutex_count );
 763     hModule = LoadLibraryExA( lpszLibFile, (HANDLE)hFile, dwFlags );
 764     RestoreThunkLock( mutex_count );
 765
 766     return (DWORD)hModule;
 767 }
 768
 769 /***********************************************************************
 770  *           GetProcAddress32W     (KERNEL.515)
 771  */
 772 DWORD WINAPI GetProcAddress32W16( DWORD hModule, LPCSTR lpszProc )
 773 {
 774     return (DWORD)GetProcAddress( (HMODULE)hModule, lpszProc );
 775 }
 776
 777 /***********************************************************************
 778  *           FreeLibrary32W        (KERNEL.514)
 779  */
 780 DWORD WINAPI FreeLibrary32W16( DWORD hLibModule )
 781 {
 782     BOOL retv;
 783     DWORD mutex_count;
 784
 785     ReleaseThunkLock( &mutex_count );
 786     retv = FreeLibrary( (HMODULE)hLibModule );
 787     RestoreThunkLock( mutex_count );
 788     return (DWORD)retv;
 789 }
 790
 791
 792 /**********************************************************************
 793  *           WOW_CallProc32W
 794  */
 795 static DWORD WOW_CallProc32W16( FARPROC proc32, DWORD nrofargs, DWORD *args )
 796 {
 797     DWORD ret;
 798     DWORD mutex_count;
 799
 800     ReleaseThunkLock( &mutex_count );
 801
 802     /*
 803      * FIXME:  If ( nrofargs & CPEX_DEST_CDECL ) != 0, we should call a
 804      *         32-bit CDECL routine ...
 805      */
 806
 807     if (!proc32) ret = 0;
 808     else switch (nrofargs)
 809     {
 810     case 0: ret = proc32();
 811             break;
 812     case 1: ret = proc32(args[0]);
 813             break;
 814     case 2: ret = proc32(args[0],args[1]);
 815             break;
 816     case 3: ret = proc32(args[0],args[1],args[2]);
 817             break;
 818     case 4: ret = proc32(args[0],args[1],args[2],args[3]);
 819             break;
 820     case 5: ret = proc32(args[0],args[1],args[2],args[3],args[4]);
 821             break;
 822     case 6: ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5]);
 823             break;
 824     case 7: ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6]);
 825             break;
 826     case 8: ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7]);
 827             break;
 828     case 9: ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8]);
 829             break;
 830     case 10:ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9]);
 831             break;
 832     case 11:ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10]);
 833             break;
 834     case 12:ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11]);
 835             break;
 836     case 13:ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12]);
 837             break;
 838     case 14:ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13]);
 839             break;
 840     case 15:ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14]);
 841             break;
 842     default:
 843             /* FIXME: should go up to 32  arguments */
 844             ERR("Unsupported number of arguments %d, please report.\n",nrofargs);
 845             ret = 0;
 846             break;
 847     }
 848
 849     RestoreThunkLock( mutex_count );
 850
 851     TRACE("returns %08x\n",ret);
 852     return ret;
 853 }
 854
 855 /**********************************************************************
 856  *           CallProc32W           (KERNEL.517)
 857  */
 858 DWORD WINAPIV CallProc32W16( DWORD nrofargs, DWORD argconvmask, FARPROC proc32, VA_LIST16 valist )
 859 {
 860     DWORD args[32];
 861     unsigned int i;
 862
 863     TRACE("(%d,%d,%p args[",nrofargs,argconvmask,proc32);
 864
 865     for (i=0;i<nrofargs;i++)
 866     {
 867         if (argconvmask & (1<<i))
 868         {
 869             SEGPTR ptr = VA_ARG16( valist, SEGPTR );
 870             /* pascal convention, have to reverse the arguments order */
 871             args[nrofargs - i - 1] = (DWORD)MapSL(ptr);
 872             TRACE("%08x(%p),",ptr,MapSL(ptr));
 873         }
 874         else
 875         {
 876             DWORD arg = VA_ARG16( valist, DWORD );
 877             /* pascal convention, have to reverse the arguments order */
 878             args[nrofargs - i - 1] = arg;
 879             TRACE("%d,", arg);
 880         }
 881     }
 882     TRACE("])\n");
 883
 884     /* POP nrofargs DWORD arguments and 3 DWORD parameters */
 885     stack16_pop( (3 + nrofargs) * sizeof(DWORD) );
 886
 887     return WOW_CallProc32W16( proc32, nrofargs, args );
 888 }
 889
 890 /**********************************************************************
 891  *           _CallProcEx32W         (KERNEL.518)
 892  */
 893 DWORD WINAPIV CallProcEx32W16( DWORD nrofargs, DWORD argconvmask, FARPROC proc32, VA_LIST16 valist )
 894 {
 895     DWORD args[32];
 896     unsigned int i;
 897
 898     TRACE("(%d,%d,%p args[",nrofargs,argconvmask,proc32);
 899
 900     for (i=0;i<nrofargs;i++)
 901     {
 902         if (argconvmask & (1<<i))
 903         {
 904             SEGPTR ptr = VA_ARG16( valist, SEGPTR );
 905             args[i] = (DWORD)MapSL(ptr);
 906             TRACE("%08x(%p),",ptr,MapSL(ptr));
 907         }
 908         else
 909         {
 910             DWORD arg = VA_ARG16( valist, DWORD );
 911             args[i] = arg;
 912             TRACE("%d,", arg);
 913         }
 914     }
 915     TRACE("])\n");
 916     return WOW_CallProc32W16( proc32, nrofargs, args );
 917 }
 918
 919
 920 /**********************************************************************
 921  *           WOW16Call               (KERNEL.500)
 922  *
 923  * FIXME!!!
 924  *
 925  */
 926 DWORD WINAPIV WOW16Call(WORD x, WORD y, WORD z, VA_LIST16 args)
 927 {
 928         int     i;
 929         DWORD   calladdr;
 930         FIXME("(0x%04x,0x%04x,%d),calling (",x,y,z);
 931
 932         for (i=0;i<x/2;i++) {
 933                 WORD    a = VA_ARG16(args,WORD);
 934                 DPRINTF("%04x ",a);
 935         }
 936         calladdr = VA_ARG16(args,DWORD);
 937         stack16_pop( 3*sizeof(WORD) + x + sizeof(DWORD) );
 938         DPRINTF(") calling address was 0x%08x\n",calladdr);
 939         return 0;
 940 }