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