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