Added a NULL pointer check within DCE_AddClipRects function.
[wine] / relay32 / wowthunk.c
1 /*
2  * Win32 WOW Generic Thunk API
3  *
4  * Copyright 1999 Ulrich Weigand 
5  */
6
7 #include "wine/winbase16.h"
8 #include "winbase.h"
9 #include "wownt32.h"
10 #include "heap.h"
11 #include "miscemu.h"
12 #include "syslevel.h"
13 #include "stackframe.h"
14 #include "builtin16.h"
15 #include "debugtools.h"
16
17 DEFAULT_DEBUG_CHANNEL(thunk)
18
19 /*
20  *  32-bit WOW routines (in WOW32, but actually forwarded to KERNEL32)
21  */
22
23 /**********************************************************************
24  *           WOWGetDescriptor        (WOW32.1) (KERNEL32.70)
25  */
26 BOOL WINAPI WOWGetDescriptor( SEGPTR segptr, LPLDT_ENTRY ldtent )
27 {
28     return GetThreadSelectorEntry( GetCurrentThread(), 
29                                    segptr >> 16, ldtent );
30 }
31
32 /**********************************************************************
33  *           WOWGetVDMPointer        (WOW32.5) (KERNEL32.56)
34  */
35 LPVOID WINAPI WOWGetVDMPointer( DWORD vp, DWORD dwBytes, BOOL fProtectedMode )
36 {
37     /* FIXME: add size check too */
38
39     if ( fProtectedMode )
40         return PTR_SEG_TO_LIN( vp );
41     else
42         return DOSMEM_MapRealToLinear( vp );
43 }
44
45 /**********************************************************************
46  *           WOWGetVDMPointerFix     (WOW32.6) (KERNEL32.68)
47  */
48 LPVOID WINAPI WOWGetVDMPointerFix( DWORD vp, DWORD dwBytes, BOOL fProtectedMode )
49 {
50     /* 
51      * Hmmm. According to the docu, we should call:
52      *
53      *          GlobalFix16( SELECTOROF(vp) );
54      *
55      * But this is unnecessary under Wine, as we never move global
56      * memory segments in linear memory anyway. 
57      *
58      * (I'm not so sure what we are *supposed* to do if 
59      *  fProtectedMode is TRUE, anyway ...)
60      */
61
62     return WOWGetVDMPointer( vp, dwBytes, fProtectedMode );
63 }
64
65 /**********************************************************************
66  *           WOWGetVDMPointerUnFix   (WOW32.7) (KERNEL32.69)
67  */
68 VOID WINAPI WOWGetVDMPointerUnfix( DWORD vp )
69 {
70     /*
71      * See above why we don't call:
72      *
73      * GlobalUnfix16( SELECTOROF(vp) );
74      *
75      */
76 }
77
78 /**********************************************************************
79  *           WOWGlobalAlloc16        (WOW32.8) (KERNEL32.59)
80  */
81 WORD WINAPI WOWGlobalAlloc16( WORD wFlags, DWORD cb )
82 {
83     return (WORD)GlobalAlloc16( wFlags, cb );
84 }
85
86 /**********************************************************************
87  *           WOWGlobalFree16         (WOW32.10) (KERNEL32.62)
88  */
89 WORD WINAPI WOWGlobalFree16( WORD hMem )
90 {
91     return (WORD)GlobalFree16( (HGLOBAL16)hMem );
92 }
93
94 /**********************************************************************
95  *           WOWGlobalLock16         (WOW32.11) (KERNEL32.60)
96  */
97 DWORD WINAPI WOWGlobalLock16( WORD hMem )
98 {
99     return (DWORD)WIN16_GlobalLock16( (HGLOBAL16)hMem );
100 }
101
102 /**********************************************************************
103  *           WOWGlobalUnlock16       (WOW32.13) (KERNEL32.61)
104  */
105 BOOL WINAPI WOWGlobalUnlock16( WORD hMem )
106 {
107     return (BOOL)GlobalUnlock16( (HGLOBAL16)hMem );
108 }
109
110 /**********************************************************************
111  *           WOWGlobalAllocLock16    (WOW32.9) (KERNEL32.63)
112  */
113 DWORD WINAPI WOWGlobalAllocLock16( WORD wFlags, DWORD cb, WORD *phMem )
114 {
115     WORD hMem = WOWGlobalAlloc16( wFlags, cb );
116     if (phMem) *phMem = hMem;
117
118     return WOWGlobalLock16( hMem );
119 }
120
121 /**********************************************************************
122  *           WOWGlobalLockSize16     (WOW32.12) (KERNEL32.65)
123  */
124 DWORD WINAPI WOWGlobalLockSize16( WORD hMem, PDWORD pcb )
125 {
126     if ( pcb ) 
127         *pcb = GlobalSize16( (HGLOBAL16)hMem );
128
129     return WOWGlobalLock16( hMem );
130 }
131
132 /**********************************************************************
133  *           WOWGlobalUnlockFree16   (WOW32.14) (KERNEL32.64)
134  */
135 WORD WINAPI WOWGlobalUnlockFree16( DWORD vpMem )
136 {
137     if ( !WOWGlobalUnlock16( HIWORD(vpMem) ) )
138         return FALSE;
139
140     return WOWGlobalFree16( HIWORD(vpMem) );
141 }
142
143
144 /**********************************************************************
145  *           WOWYield16              (WOW32.17) (KERNEL32.66)
146  */
147 VOID WINAPI WOWYield16( void )
148 {
149     /*
150      * This does the right thing for both Win16 and Win32 tasks.  
151      * More or less, at least :-/
152      */
153     Yield16();
154 }
155
156 /**********************************************************************
157  *           WOWDirectedYield16       (WOW32.4) (KERNEL32.67)
158  */
159 VOID WINAPI WOWDirectedYield16( WORD htask16 )
160 {
161     /*
162      * Argh.  Our scheduler doesn't like DirectedYield by Win32
163      * tasks at all.  So we do hope that this routine is indeed 
164      * only ever called by Win16 tasks that have thunked up ...
165      */
166     DirectedYield16( (HTASK16)htask16 );
167 }
168
169
170 /***********************************************************************
171  *           WOWHandle32              (WOW32.16) (KERNEL32.57)
172  */
173 HANDLE WINAPI WOWHandle32( WORD handle, WOW_HANDLE_TYPE type )
174 {
175     switch ( type )
176     {
177     case WOW_TYPE_HWND:
178     case WOW_TYPE_HMENU:
179     case WOW_TYPE_HDWP:
180     case WOW_TYPE_HDROP:
181     case WOW_TYPE_HDC:
182     case WOW_TYPE_HFONT:
183     case WOW_TYPE_HMETAFILE:
184     case WOW_TYPE_HRGN:
185     case WOW_TYPE_HBITMAP:
186     case WOW_TYPE_HBRUSH:
187     case WOW_TYPE_HPALETTE:
188     case WOW_TYPE_HPEN:
189     case WOW_TYPE_HACCEL:
190     case WOW_TYPE_HTASK:
191     case WOW_TYPE_FULLHWND:
192         return (HANDLE)handle;
193
194     default:
195         ERR( "handle 0x%04x of unknown type %d\n", handle, type );
196         return (HANDLE)handle;
197     }
198 }
199
200 /***********************************************************************
201  *           WOWHandle16              (WOW32.15) (KERNEL32.58)
202  */
203 WORD WINAPI WOWHandle16( HANDLE handle, WOW_HANDLE_TYPE type )
204 {
205     if ( HIWORD(handle ) )
206         ERR( "handle 0x%08x of type %d has non-zero HIWORD\n", handle, type );
207
208     switch ( type )
209     {
210     case WOW_TYPE_HWND:
211     case WOW_TYPE_HMENU:
212     case WOW_TYPE_HDWP:
213     case WOW_TYPE_HDROP:
214     case WOW_TYPE_HDC:
215     case WOW_TYPE_HFONT:
216     case WOW_TYPE_HMETAFILE:
217     case WOW_TYPE_HRGN:
218     case WOW_TYPE_HBITMAP:
219     case WOW_TYPE_HBRUSH:
220     case WOW_TYPE_HPALETTE:
221     case WOW_TYPE_HPEN:
222     case WOW_TYPE_HACCEL:
223     case WOW_TYPE_HTASK:
224     case WOW_TYPE_FULLHWND:
225         return LOWORD(handle);
226
227     default:
228         ERR( "handle 0x%08x of unknown type %d\n", handle, type );
229         return LOWORD(handle);
230     }
231 }
232
233 /**********************************************************************
234  *           WOWCallback16            (WOW32.2) (KERNEL32.54)
235  */
236 DWORD WINAPI WOWCallback16( DWORD vpfn16, DWORD dwParam )
237 {
238     DWORD ret;
239
240     if ( !WOWCallback16Ex( vpfn16, WCB16_PASCAL, 
241                            sizeof(DWORD), &dwParam, &ret ) )
242         ret = 0L;
243
244     return ret;
245 }
246
247 /**********************************************************************
248  *           WOWCallback16Ex         (WOW32.3) (KERNEL32.55)
249  */
250 BOOL WINAPI WOWCallback16Ex( DWORD vpfn16, DWORD dwFlags,
251                              DWORD cbArgs, LPVOID pArgs, LPDWORD pdwRetCode )
252 {
253     DWORD ret;
254
255     /*
256      * Arguments must be prepared in the correct order by the caller
257      * (both for PASCAL and CDECL calling convention), so we simply
258      * copy them to the 16-bit stack ... 
259      */
260     memcpy( (LPBYTE)CURRENT_STACK16 - cbArgs, (LPBYTE)pArgs, cbArgs );
261
262
263     /*
264      * Actually, we should take care whether the called routine cleans up
265      * its stack or not.  Fortunately, our CallTo16 core doesn't rely on 
266      * the callee to do so; after the routine has returned, the 16-bit 
267      * stack pointer is always reset to the position it had before. 
268      */
269
270     ret = CallTo16Long( (FARPROC16)vpfn16, cbArgs );
271
272     if ( pdwRetCode )
273         *pdwRetCode = ret;
274
275     return TRUE;  /* success */
276 }
277
278
279
280 /*
281  *  16-bit WOW routines (in KERNEL)
282  */
283
284 /**********************************************************************
285  *           GetVDMPointer32W16      (KERNEL.516)
286  */
287 DWORD WINAPI GetVDMPointer32W16( SEGPTR vp, UINT16 fMode )
288 {
289     return (DWORD)WOWGetVDMPointer( vp, 0, (DWORD)fMode );
290 }
291
292 /***********************************************************************
293  *           LoadLibraryEx32W16      (KERNEL.513)
294  */
295 DWORD WINAPI LoadLibraryEx32W16( LPCSTR lpszLibFile, DWORD hFile, DWORD dwFlags )
296 {
297     HMODULE hModule;
298
299     SYSLEVEL_ReleaseWin16Lock();
300     hModule = LoadLibraryExA( lpszLibFile, (HANDLE)hFile, dwFlags );
301     SYSLEVEL_RestoreWin16Lock();
302
303     return (DWORD)hModule;
304 }
305
306 /***********************************************************************
307  *           GetProcAddress32W16     (KERNEL.515)
308  */
309 DWORD WINAPI GetProcAddress32W16( DWORD hModule, LPCSTR lpszProc )
310 {
311     return (DWORD)GetProcAddress( (HMODULE)hModule, lpszProc );
312 }
313
314 /***********************************************************************
315  *           FreeLibrary32W16        (KERNEL.514)
316  */
317 DWORD WINAPI FreeLibrary32W16( DWORD hLibModule )
318 {
319     BOOL retv;
320
321     SYSLEVEL_ReleaseWin16Lock();
322     retv = FreeLibrary( (HMODULE)hLibModule );
323     SYSLEVEL_RestoreWin16Lock();
324
325     return (DWORD)retv;
326 }
327
328
329 /**********************************************************************
330  *           WOW_CallProc32W
331  */
332 static DWORD WOW_CallProc32W16( BOOL Ex )
333 {
334     DWORD nrofargs, argconvmask;
335     FARPROC proc32;
336     DWORD *args, ret;
337     VA_LIST16 valist;
338     int i;
339     int aix;
340
341     SYSLEVEL_ReleaseWin16Lock();
342
343     VA_START16( valist );
344     nrofargs    = VA_ARG16( valist, DWORD );
345     argconvmask = VA_ARG16( valist, DWORD );
346     proc32      = VA_ARG16( valist, FARPROC );
347     TRACE("(%ld,%ld,%p, Ex%d args[",nrofargs,argconvmask,proc32,Ex);
348     args = (DWORD*)HeapAlloc( GetProcessHeap(), 0, sizeof(DWORD)*nrofargs );
349     if(args == NULL) proc32 = NULL; /* maybe we should WARN here? */
350     /* CallProcEx doesn't need its args reversed */
351     for (i=0;i<nrofargs;i++) {
352             if (Ex) {
353                aix = i;
354             } else {
355                aix = nrofargs - i - 1;
356             }
357             if (argconvmask & (1<<i))
358             {
359                 SEGPTR ptr = VA_ARG16( valist, SEGPTR );
360                 if (args) args[aix] = (DWORD)PTR_SEG_TO_LIN(ptr);
361                 if (TRACE_ON(thunk)) DPRINTF("%08lx(%p),",ptr,PTR_SEG_TO_LIN(ptr));
362             }
363             else
364             {
365                 DWORD arg = VA_ARG16( valist, DWORD );
366                 if (args) args[aix] = arg;
367                 if (TRACE_ON(thunk)) DPRINTF("%ld,", arg);
368             }
369     }
370     if (TRACE_ON(thunk)) DPRINTF("])\n");
371     VA_END16( valist );
372
373     /*
374      * FIXME:  If ( nrofargs & CPEX_DEST_CDECL ) != 0, we should call a
375      *         32-bit CDECL routine ...
376      */
377
378     if (!proc32) ret = 0;
379     else switch (nrofargs)
380     {
381     case 0: ret = proc32();
382             break;
383     case 1: ret = proc32(args[0]);
384             break;
385     case 2: ret = proc32(args[0],args[1]);
386             break;
387     case 3: ret = proc32(args[0],args[1],args[2]);
388             break;
389     case 4: ret = proc32(args[0],args[1],args[2],args[3]);
390             break;
391     case 5: ret = proc32(args[0],args[1],args[2],args[3],args[4]);
392             break;
393     case 6: ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5]);
394             break;
395     case 7: ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6]);
396             break;
397     case 8: ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7]);
398             break;
399     case 9: ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8]);
400             break;
401     case 10:ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9]);
402             break;
403     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]);
404             break;
405     default:
406             /* FIXME: should go up to 32  arguments */
407             ERR("Unsupported number of arguments %ld, please report.\n",nrofargs);
408             ret = 0;
409             break;
410     }
411
412     /* POP nrofargs DWORD arguments and 3 DWORD parameters */
413     if (!Ex) stack16_pop( (3 + nrofargs) * sizeof(DWORD) );
414
415     TRACE("returns %08lx\n",ret);
416     HeapFree( GetProcessHeap(), 0, args );
417
418     SYSLEVEL_RestoreWin16Lock();
419
420     return ret;
421 }
422
423 /**********************************************************************
424  *           CallProc32W16           (KERNEL.517)
425  *
426  * DWORD PASCAL CallProc32W( DWORD p1, ... , DWORD lpProcAddress,
427  *                           DWORD fAddressConvert, DWORD cParams );
428  */
429 DWORD WINAPI CallProc32W16( void )
430 {
431     return WOW_CallProc32W16( FALSE );
432 }
433
434 /**********************************************************************
435  *           CallProcEx32W16         (KERNEL.518)
436  *
437  * DWORD CallProcEx32W( DWORD cParams, DWORD fAddressConvert, 
438  *                      DWORD lpProcAddress, DWORD p1, ... );
439  */
440 DWORD WINAPI CallProcEx32W16( void )
441 {
442     return WOW_CallProc32W16( TRUE );
443 }
444
445
446 /**********************************************************************
447  *           WOW16Call               (KERNEL.501)
448  *
449  * FIXME!!!
450  *
451  */
452 DWORD WINAPI WOW16Call(WORD x,WORD y,WORD z) 
453 {
454         int     i;
455         DWORD   calladdr;
456         VA_LIST16 args;
457         FIXME("(0x%04x,0x%04x,%d),calling (",x,y,z);
458
459         VA_START16(args);
460         for (i=0;i<x/2;i++) {
461                 WORD    a = VA_ARG16(args,WORD);
462                 DPRINTF("%04x ",a);
463         }
464         calladdr = VA_ARG16(args,DWORD);
465         VA_END16(args);
466         stack16_pop( x + sizeof(DWORD) );
467         DPRINTF(") calling address was 0x%08lx\n",calladdr);
468         return 0;
469 }
470
471