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