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