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