#include <os2ssrtl.h>
#include <os2tile.h>
#include <os2dbg.h>
#include <os2err.h>
ULONG
LoadLibraryA(PSZ);
ULONG
GetProcAddress(HANDLE, PSZ);
ULONG
GetLastError(VOID);
ULONG
FreeLibrary(HANDLE);
VOID
Od2ProbeForRead(
IN PVOID Address,
IN ULONG Length,
IN ULONG Alignment
);
VOID
Od2ProbeForWrite(
IN PVOID Address,
IN ULONG Length,
IN ULONG Alignment
);
VOID
Od2ExitGP();
typedef (*func) (PVOID);
//
// Dos32LoadModule -
//
// Purpose : Load a win32 thunk DLL that will intermediate between an OS/2
// app and win32 APIs.
//
// Returns : If NO_ERROR is returned, the value pointed by pDllHandle
// is used for other win32 thunk APIs. It is invalid for usage
// with regular OS/2 APIs. If ERROR_MOD_NOT_FOUND is returned,
// the value pointed by pDllHandle is undefined.
//
APIRET
Dos32LoadModule(
IN PSZ DllName,
OUT PULONG pDllHandle
)
{
try {
Od2ProbeForRead((PVOID)DllName, sizeof(ULONG), 1);
Od2ProbeForWrite( pDllHandle, sizeof(ULONG), 1 );
} except( EXCEPTION_EXECUTE_HANDLER ) {
Od2ExitGP();
}
*pDllHandle = (ULONG) LoadLibraryA(DllName);
#if DBG
IF_OD2_DEBUG ( LOADER ) {
DbgPrint("Dos32LoadModule: DllName - %s\n", DllName);
DbgPrint(" DllHandle - 0x%lx\n", *pDllHandle);
}
#endif
if (*pDllHandle == (ULONG)NULL) {
return(ERROR_MOD_NOT_FOUND);
}
return(NO_ERROR);
}
//
// Dos32GetProcAddr -
//
// Purpose : Get a cookie (flat pointer) to a routine in a win32 thunk DLL,
// previously opened by Dos32LoadModule. For example, if the OS/2
// app wants to call the WinSocketFoo API, it builds a win32
// intermediate DLL, named MySock.DLL, that export WinSocketFoo.
// The app calls Dos32LoadModule with "MySock" and then
// Dos32GetProcAddr with pszProcName of value "WinSoketFoo". If no
// error is returned, it can use the value pointed by pWin32Thunk
// in a later call to Dos32Dispatch, for calling the WinSocketFoo
// routine, which in turn will call a real Win32.
//
// Returns : NO_ERROR if the pszProcName is exported by the win32 intermediate
// DLL which relates to DllHandle. If ERROR_PROC_NOT_FOUND or
// ERROR_INVALID_HANDLE are returned, the value pointed by
// pWin32Thunk is undefined.
//
APIRET
Dos32GetProcAddr(
IN HANDLE DllHandle,
IN PSZ pszProcName,
OUT PULONG pWin32Thunk
)
{
try {
Od2ProbeForRead((PVOID)pszProcName, sizeof(ULONG), 1);
Od2ProbeForWrite( pWin32Thunk, sizeof(ULONG), 1 );
} except( EXCEPTION_EXECUTE_HANDLER ) {
Od2ExitGP();
}
*pWin32Thunk = (ULONG) GetProcAddress(DllHandle, pszProcName);
#if DBG
IF_OD2_DEBUG ( LOADER ) {
DbgPrint("Dos32GetProcAddr: DllHandle - 0x%lx\n", DllHandle);
DbgPrint(" ProcName - %s\n", pszProcName);
DbgPrint(" Win32Thunk - 0x%lx\n", *pWin32Thunk);
}
#endif
if (*pWin32Thunk == (ULONG)NULL) {
if (GetLastError() == 6 /* ERROR_INVALID_HANDLE */) {
return(ERROR_INVALID_HANDLE);
}
return(ERROR_PROC_NOT_FOUND);
}
return(NO_ERROR);
}
//
// Dos32Dispatch -
//
// Purpose : Dos32Dispatch calls the 32bit thunk routine Win32Thunk,
// previosly obtained by Dos32GetProcAddr. It returns the error
// code returned by Win32Thunk in pRetCode. It translates the
// pArguments 16:16 pointer to a flat pointer and passes it to the
// Win32Thunk call. The structure pointed by pArguments, and the
// values of pRetCode are app specific and are not interpreted
// or modified by the OS/2 subsystem.
//
// The Win32Thunk has to by defined as following:
//
// ULONG WinSocketFoo(
// PVIOD pFlatArg
// );
//
// Returns : NO_ERROR if the Win32Thunk argument is a valid pointer and no
// exception occured in the call to it.
//
APIRET
Dos32Dispatch(
IN ULONG Win32Thunk,
IN PVOID pArguments,
OUT PULONG pRetCode
)
{
#if DBG
IF_OD2_DEBUG ( LOADER ) {
DbgPrint("Dos32Dispatch: Win32Thunk - 0x%lx\n", Win32Thunk);
}
#endif
try {
*pRetCode = (*(func)Win32Thunk) (pArguments);
} except( EXCEPTION_EXECUTE_HANDLER ) {
Od2ExitGP();
}
return(NO_ERROR);
}
//
// Dos32FreeModule -
//
// Purpose : Unload a win32 thunk DLL that intermediates between an OS/2 app
// and win32 APIs.
//
// Returns : If NO_ERROR is returnd, the DllHandle is used for other win32
// thunk APIs. It is invalid for usage with regular OS/2 APIs.
// If ERROR_INVALID_HANDLE is returned, DllHandle is undefined.
//
APIRET
Dos32FreeModule(
IN HANDLE DllHandle
)
{
#if DBG
IF_OD2_DEBUG ( LOADER ) {
DbgPrint("Dos32FreeMudule: DllHandle - 0x%lx\n", DllHandle);
}
#endif
if (FreeLibrary(DllHandle)) {
return(NO_ERROR);
}
return(ERROR_INVALID_HANDLE);
}
//
// FarPtr2FlatPtr -
//
// Purpose : Translates the segmented pointer FarPtr to a flat pointer
// pointed by pFlatPtr.
//
// Returns : NO_ERROR if the FarPtr is a valid 16:16 pointer. In this
// case pFlatPtr contains a valid 32 bit flat pointer to be used
// by win32 code. If ERROR_INVALID_PARAMETER is returned then
// the 16:16 pointer is not valid and the value pointed by pFlatPtr
// is undefined.
//
APIRET
FarPtr2FlatPtr(
IN ULONG FarPtr,
OUT PULONG pFlatPtr
)
{
try {
Od2ProbeForWrite( pFlatPtr, sizeof( ULONG ), 1 );
} except( EXCEPTION_EXECUTE_HANDLER ) {
Od2ExitGP();
}
try {
Od2ProbeForRead((PVOID)*pFlatPtr = FARPTRTOFLAT(FarPtr),
sizeof(ULONG),
1);
} except( EXCEPTION_CONTINUE_EXECUTION ) {
return(ERROR_INVALID_PARAMETER);
}
if ((*pFlatPtr < BASE_TILE) || (*pFlatPtr >= BASE_TILE + _512M)) {
return(ERROR_INVALID_PARAMETER);
}
#if DBG
IF_OD2_DEBUG ( LOADER ) {
DbgPrint("FarPtr2FlatPtr: FarPtr - 0x%lx\n", FarPtr);
DbgPrint(" FlatPtr - 0x%lx\n", *pFlatPtr);
}
#endif
return(NO_ERROR);
}
//
// FlatPtr2FarPtr -
//
// Purpose : Translates the flat pointer FlatPtr to a far pointer pFarPtr.
//
// Returns : NO_ERROR if the FlatPtr has a valid 16:16 pointer in the
// 16 bit app context. In this case pFarPtr contains a valid 16:16
// segmented pointer to by used by the 16 bit OS/2 code.
// If ERROR_INVALID_PARAMETER is returned then the pFarPtr is
// undefined.
//
APIRET
FlatPtr2FarPtr(
IN ULONG FlatPtr,
OUT PULONG pFarPtr
)
{
if ((FlatPtr < BASE_TILE) || (FlatPtr >= BASE_TILE + _512M)) {
return(ERROR_INVALID_PARAMETER);
}
try {
Od2ProbeForWrite( pFarPtr, sizeof( ULONG ), 1 );
} except( EXCEPTION_EXECUTE_HANDLER ) {
Od2ExitGP();
}
#if DBG
IF_OD2_DEBUG ( LOADER ) {
DbgPrint("FlatPtr2FarPtr: FlatPtr - 0x%lx\n", FlatPtr);
}
#endif
try {
Od2ProbeForRead( (PVOID) FlatPtr, 1, 1 );
} except (EXCEPTION_CONTINUE_EXECUTION ) {
return(ERROR_INVALID_PARAMETER);
}
*pFarPtr = FLATTOFARPTR(FlatPtr);
#if DBG
IF_OD2_DEBUG ( LOADER ) {
DbgPrint(" FarPtr - 0x%lx\n", *pFarPtr);
}
#endif
return(NO_ERROR);
}
