able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/mvdm/wow32/wsdata.c

1870 lines
45 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1992 Microsoft Corporation
Module Name:
Wsraw.h
Abstract:
Support for database winsock calls for WOW.
Author:
David Treadwell (davidtr) 02-Oct-1992
Revision History:
--*/
#include "precomp.h"
#pragma hdrstop
#include "wsdynmc.h"
#define FIND_16_OFFSET_FROM_32(base16, base32, actual32) \
( (DWORD)base16 + ( (DWORD)actual32 - (DWORD)base32 ) )
DWORD
BytesInHostent32 (
PHOSTENT Hostent32
);
DWORD
CopyHostent32To16 (
PHOSTENT16 Hostent16,
VPHOSTENT16 VHostent16,
int BufferLength,
PHOSTENT Hostent32
);
DWORD
BytesInProtoent32 (
PPROTOENT Protoent32
);
DWORD
CopyProtoent32To16 (
PPROTOENT16 Protoent16,
VPPROTOENT16 VProtoent16,
int BufferLength,
PPROTOENT Protoent32
);
DWORD
BytesInServent32 (
PSERVENT Servent32
);
DWORD
CopyServent32To16 (
PSERVENT16 Servent16,
VPSERVENT16 VServent16,
int BufferLength,
PSERVENT Servent32
);
/*++
GENERIC FUNCTION PROTOTYPE:
==========================
ULONG FASTCALL WWS32<function name>(PVDMFRAME pFrame)
{
ULONG ul;
register P<function name>16 parg16;
GETARGPTR(pFrame, sizeof(<function name>16), parg16);
<get any other required pointers into 16 bit space>
ALLOCVDMPTR
GETVDMPTR
GETMISCPTR
et cetera
<copy any complex structures from 16 bit -> 32 bit space>
<ALWAYS use the FETCHxxx macros>
ul = GET<return type>16(<function name>(parg16->f1,
:
:
parg16->f<n>);
<copy any complex structures from 32 -> 16 bit space>
<ALWAYS use the STORExxx macros>
<free any pointers to 16 bit space you previously got>
<flush any areas of 16 bit memory if they were written to>
FLUSHVDMPTR
FREEARGPTR(parg16);
RETURN(ul);
}
NOTE:
The VDM frame is automatically set up, with all the function parameters
available via parg16->f<number>.
Handles must ALWAYS be mapped for 16 -> 32 -> 16 space via the mapping tables
laid out in WALIAS.C.
Any storage you allocate must be freed (eventually...).
Further to that - if a thunk which allocates memory fails in the 32 bit call
then it must free that memory.
Also, never update structures in 16 bit land if the 32 bit call fails.
Be aware that the GETxxxPTR macros return the CURRENT selector-to-flat_memory
mapping. Calls to some 32-bit functions may indirectly cause callbacks into
16-bit code. These may cause 16-bit memory to move due to allocations
made in 16-bit land. If the 16-bit memory does move, the corresponding 32-bit
ptr in WOW32 needs to be refreshed to reflect the NEW selector-to-flat_memory
mapping.
--*/
ULONG FASTCALL WWS32gethostbyaddr(PVDMFRAME pFrame)
{
ULONG ul;
register PGETHOSTBYADDR16 parg16;
PDWORD paddr16;
PHOSTENT hostent32;
PHOSTENT16 hostent16;
DWORD bytesRequired;
DWORD addr32; // address must be in PF_INET format (length == 4 bytes)
if ( !WWS32IsThreadInitialized ) {
SetLastError( WSANOTINITIALISED );
RETURN((ULONG)NULL);
}
GETARGPTR( pFrame, sizeof(GETHOSTBYADDR16), parg16 );
GETVDMPTR( parg16->Address, sizeof(DWORD), paddr16 );
addr32 = *paddr16; // copy the 4-byte address
hostent32 = (PHOSTENT) (*wsockapis[WOW_GETHOSTBYADDR].lpfn)((CHAR *)&addr32,
parg16->Length,
parg16->Type);
// Note: 16-bit callbacks resulting from above function
// call may have caused 16-bit memory movement
FREEVDMPTR(paddr16);
FREEARGPTR(parg16);
if ( hostent32 != NULL ) {
GETVDMPTR( WWS32vHostent, MAXGETHOSTSTRUCT, hostent16 );
bytesRequired = CopyHostent32To16(
hostent16,
WWS32vHostent,
MAXGETHOSTSTRUCT,
hostent32
);
ASSERT( bytesRequired < MAXGETHOSTSTRUCT );
FLUSHVDMPTR( WWS32vHostent, (USHORT) bytesRequired, hostent16 );
FREEVDMPTR( hostent16 );
ul = WWS32vHostent;
} else {
ul = 0;
}
FREEVDMPTR( paddr16 );
FREEARGPTR(parg16);
RETURN(ul);
} // WWS32gethostbyaddr
ULONG FASTCALL WWS32gethostbyname(PVDMFRAME pFrame)
{
ULONG ul;
register PGETHOSTBYNAME16 parg16;
PHOSTENT hostent32 = NULL;
PHOSTENT16 hostent16;
PSZ name32 = NULL;
PSZ name16;
DWORD bytesRequired;
if ( !WWS32IsThreadInitialized ) {
SetLastError( WSANOTINITIALISED );
RETURN((ULONG)NULL);
}
GETARGPTR( pFrame, sizeof(GETHOSTBYNAME16), parg16 );
GETVDMPTR( parg16->Name, 32, name16 );
if(name16) {
name32 = malloc_w(strlen(name16)+1);
if ( name32 ) {
strcpy(name32, name16);
hostent32 = (PHOSTENT) (*wsockapis[WOW_GETHOSTBYNAME].lpfn)( name32 );
free_w(name32);
}
}
// Note: 16-bit callbacks resulting from above function
// call may have caused 16-bit memory movement
FREEVDMPTR(name16);
FREEARGPTR(parg16);
if ( hostent32 != NULL ) {
GETVDMPTR( WWS32vHostent, MAXGETHOSTSTRUCT, hostent16 );
bytesRequired = CopyHostent32To16(
hostent16,
WWS32vHostent,
MAXGETHOSTSTRUCT,
hostent32
);
ASSERT( bytesRequired < MAXGETHOSTSTRUCT );
FLUSHVDMPTR( WWS32vHostent, (USHORT) bytesRequired, hostent16 );
FREEVDMPTR( hostent16 );
ul = WWS32vHostent;
} else {
ul = 0;
}
RETURN(ul);
} // WWS32gethostbyname
ULONG FASTCALL WWS32gethostname(PVDMFRAME pFrame)
{
ULONG ul;
register PGETHOSTNAME16 parg16;
PCHAR name32 = NULL;
PCHAR name16;
INT NameLength;
VPSZ vpszName;
if ( !WWS32IsThreadInitialized ) {
SetLastError( WSANOTINITIALISED );
RETURN((ULONG)NULL);
}
GETARGPTR( pFrame, sizeof(GETHOSTNAME16), parg16 );
vpszName = FETCHDWORD(parg16->Name);
NameLength = INT32(parg16->NameLength);
if(vpszName) {
name32 = malloc_w(NameLength);
}
ul = GETWORD16( (*wsockapis[WOW_GETHOSTNAME].lpfn)( name32, NameLength ) );
// Note: 16-bit callbacks resulting from above function
// call may have caused 16-bit memory movement
FREEVDMPTR(name16);
FREEARGPTR(parg16);
GETVDMPTR( vpszName, NameLength, name16 );
if(name16 && name32) {
strcpy(name16, name32);
}
FLUSHVDMPTR( vpszName, NameLength, name16 );
FREEVDMPTR( name16 );
FREEARGPTR(parg16);
RETURN(ul);
} // WWS32gethostname
ULONG FASTCALL WWS32WSAAsyncGetHostByAddr(PVDMFRAME pFrame)
{
ULONG ul;
register PWSAASYNCGETHOSTBYADDR16 parg16;
PWINSOCK_ASYNC_CONTEXT_BLOCK context;
PVOID buffer32;
PDWORD paddr16;
if ( !WWS32IsThreadInitialized ) {
SetLastError( WSANOTINITIALISED );
RETURN(0);
}
GETARGPTR( pFrame, sizeof(WSAASYNCGETHOSTBYADDR16), parg16 );
GETVDMPTR( parg16->Address, sizeof(DWORD), paddr16 );
//
// Set up locals so we know how to clean up on exit.
//
context = NULL;
buffer32 = NULL;
ul = 0;
//
// Allocate a context block and 32-bit buffer to use for the request.
//
context = malloc_w( sizeof(*context) );
if ( context == NULL ) {
(*wsockapis[WOW_WSASETLASTERROR].lpfn)( WSAENOBUFS );
goto exit;
}
buffer32 = malloc_w( MAXGETHOSTSTRUCT );
if ( context == NULL ) {
(*wsockapis[WOW_WSASETLASTERROR].lpfn)( WSAENOBUFS );
goto exit;
}
//
// Fill in entries in the context buffer.
//
context->Buffer32 = buffer32;
context->vBuffer16 = parg16->Buffer;
context->Buffer16Length = parg16->BufferLength;
//
// Enter a critical section to synchronize access to the context block
// and their global list.
//
RtlEnterCriticalSection( &WWS32CriticalSection );
context->AsyncTaskHandle32 = (HANDLE) (*wsockapis[WOW_WSAASYNCGETHOSTBYADDR].lpfn)(
(HWND)HWND32(parg16->hWnd),
(parg16->wMsg << 16) |
WWS32_MESSAGE_ASYNC_GETHOST,
(char *)paddr16,
parg16->Length,
parg16->Type,
buffer32,
MAXGETHOSTSTRUCT);
if ( context->AsyncTaskHandle32 != 0 ) {
//
// The call succeeded so get a 16-bit task handle for this
// request and place the context block on the global list. The
// resources will be freed by WWS32PostAsyncGetHost.
//
ul = WWS32GetAsyncTaskHandle16( );
context->AsyncTaskHandle16 = (HAND16)ul;
InsertTailList(
&WWS32AsyncContextBlockListHead,
&context->ContextBlockListEntry
);
}
RtlLeaveCriticalSection( &WWS32CriticalSection );
exit:
if ( ul == 0 ) {
if ( context != NULL ) {
free_w( (PVOID)context );
}
if ( buffer32 != NULL ) {
free_w( buffer32 );
}
}
FREEVDMPTR( paddr16 );
FREEARGPTR( parg16 );
RETURN(ul);
} // WWS32WSAAsyncGetHostByAddr
ULONG FASTCALL WWS32WSAAsyncGetHostByName(PVDMFRAME pFrame)
{
ULONG ul;
register PWSAASYNCGETHOSTBYNAME16 parg16;
PWINSOCK_ASYNC_CONTEXT_BLOCK context;
PVOID buffer32;
PCHAR name32;
if ( !WWS32IsThreadInitialized ) {
SetLastError( WSANOTINITIALISED );
RETURN(0);
}
GETARGPTR( pFrame, sizeof(WSAASYNCGETHOSTBYNAME16), parg16 );
GETVDMPTR( parg16->Name, 32, name32 );
//
// Set up locals so we know how to clean up on exit.
//
context = NULL;
buffer32 = NULL;
ul = 0;
//
// Allocate a context block and 32-bit buffer to use for the request.
//
context = malloc_w( sizeof(*context) );
if ( context == NULL ) {
(*wsockapis[WOW_WSASETLASTERROR].lpfn)( WSAENOBUFS );
goto exit;
}
buffer32 = malloc_w( MAXGETHOSTSTRUCT );
if ( context == NULL ) {
(*wsockapis[WOW_WSASETLASTERROR].lpfn)( WSAENOBUFS );
goto exit;
}
//
// Fill in entries in the context buffer.
//
context->Buffer32 = buffer32;
context->vBuffer16 = parg16->Buffer;
context->Buffer16Length = parg16->BufferLength;
//
// Enter a critical section to synchronize access to the context block
// and their global list.
//
RtlEnterCriticalSection( &WWS32CriticalSection );
context->AsyncTaskHandle32 = (HANDLE) (*wsockapis[WOW_WSAASYNCGETHOSTBYNAME].lpfn)(
(HWND)HWND32(parg16->hWnd),
(parg16->wMsg << 16) |
WWS32_MESSAGE_ASYNC_GETHOST,
name32,
buffer32,
MAXGETHOSTSTRUCT
);
if ( context->AsyncTaskHandle32 != 0 ) {
//
// The call succeeded so get a 16-bit task handle for this
// request and place the context block on the global list. The
// resources will be freed by WWS32PostAsyncGetHost.
//
ul = WWS32GetAsyncTaskHandle16( );
context->AsyncTaskHandle16 = (HAND16)ul;
InsertTailList(
&WWS32AsyncContextBlockListHead,
&context->ContextBlockListEntry
);
}
RtlLeaveCriticalSection( &WWS32CriticalSection );
exit:
if ( ul == 0 ) {
if ( context != NULL ) {
free_w( (PVOID)context );
}
if ( buffer32 != NULL ) {
free_w( buffer32 );
}
}
FREEVDMPTR( name32 );
FREEARGPTR( parg16 );
RETURN(ul);
} // WWS32WSAAsyncGetHostByName
BOOL
WWS32PostAsyncGetHost (
HWND hWnd,
UINT Msg,
WPARAM wParam,
LPARAM lParam
)
{
PWINSOCK_ASYNC_CONTEXT_BLOCK context;
BOOL ret;
PVOID buffer16;
DWORD bytesRequired;
context = WWS32FindAndRemoveAsyncContext( (HANDLE)wParam );
ASSERT( context != NULL );
//
// If the call was successful, copy the 32-bit buffer to the
// 16-bit buffer specified by the application.
//
if ( WSAGETASYNCERROR( lParam ) == 0 ) {
//
// Copy the 32-bit structure to 16-bit buffer.
//
GETVDMPTR( context->vBuffer16, context->Buffer16Length, buffer16 );
bytesRequired = CopyHostent32To16(
buffer16,
context->vBuffer16,
context->Buffer16Length,
context->Buffer32
);
//
// If the application's buffer was too small, return an error
// and information aqbout the buffer size required.
//
if ( bytesRequired > context->Buffer16Length ) {
lParam = WSAMAKEASYNCREPLY( (WORD)bytesRequired, WSAENOBUFS );
}
}
//
// Post the completion message to the 16-bit application.
//
ret = PostMessage(
hWnd,
Msg >> 16,
context->AsyncTaskHandle16,
lParam
);
//
// Free resources and return.
//
free_w( context->Buffer32 );
free_w( (PVOID)context );
return ret;
} // WWS32PostAsyncGetHost
DWORD
CopyHostent32To16 (
PHOSTENT16 Hostent16,
VPHOSTENT16 VHostent16,
int BufferLength,
PHOSTENT Hostent32
)
{
DWORD requiredBufferLength;
DWORD bytesFilled;
PCHAR currentLocation = (PCHAR)Hostent16;
DWORD aliasCount;
DWORD addressCount;
DWORD i;
VPBYTE *addrList16;
VPSZ *aliases16;
//
// Determine how many bytes are needed to fully copy the structure.
//
requiredBufferLength = BytesInHostent32( Hostent32 );
//
// Copy over the hostent structure if it fits.
//
bytesFilled = sizeof(*Hostent32);
if ( bytesFilled > (DWORD)BufferLength ) {
return requiredBufferLength;
}
STOREWORD( Hostent16->h_addrtype, Hostent32->h_addrtype );
STOREWORD( Hostent16->h_length, Hostent32->h_length );
currentLocation = (PCHAR)Hostent16 + bytesFilled;
//
// Count the host's aliases and set up an array to hold pointers to
// them.
//
for ( aliasCount = 0;
Hostent32->h_aliases[aliasCount] != NULL;
aliasCount++ );
bytesFilled += (aliasCount+1) * sizeof(char FAR *);
if ( bytesFilled > (DWORD)BufferLength ) {
Hostent32->h_aliases = NULL;
return requiredBufferLength;
}
Hostent16->h_aliases =
FIND_16_OFFSET_FROM_32( VHostent16, Hostent16, currentLocation );
aliases16 = (VPSZ *)currentLocation;
currentLocation = (PCHAR)Hostent16 + bytesFilled;
//
// Count the host's addresses and set up an array to hold pointers to
// them.
//
for ( addressCount = 0;
Hostent32->h_addr_list[addressCount] != NULL;
addressCount++ );
bytesFilled += (addressCount+1) * sizeof(void FAR *);
if ( bytesFilled > (DWORD)BufferLength ) {
Hostent32->h_addr_list = NULL;
return requiredBufferLength;
}
Hostent16->h_addr_list =
FIND_16_OFFSET_FROM_32( VHostent16, Hostent16, currentLocation );
addrList16 = (VPBYTE *)currentLocation;
currentLocation = (PCHAR)Hostent16 + bytesFilled;
//
// Start filling in addresses. Do addresses before filling in the
// host name and aliases in order to avoid alignment problems.
//
for ( i = 0; i < addressCount; i++ ) {
bytesFilled += Hostent32->h_length;
if ( bytesFilled > (DWORD)BufferLength ) {
STOREDWORD( addrList16[i], 0 );
return requiredBufferLength;
}
STOREDWORD(
addrList16[i],
FIND_16_OFFSET_FROM_32( VHostent16, Hostent16, currentLocation )
);
RtlMoveMemory(
currentLocation,
Hostent32->h_addr_list[i],
Hostent32->h_length
);
currentLocation = (PCHAR)Hostent16 + bytesFilled;
}
STOREDWORD( addrList16[i], 0 );
//
// Copy the host name if it fits.
//
bytesFilled += strlen( Hostent32->h_name ) + 1;
if ( bytesFilled > (DWORD)BufferLength ) {
return requiredBufferLength;
}
Hostent16->h_name =
FIND_16_OFFSET_FROM_32( VHostent16, Hostent16, currentLocation );
RtlMoveMemory( currentLocation, Hostent32->h_name, strlen( Hostent32->h_name ) + 1 );
currentLocation = (PCHAR)Hostent16 + bytesFilled;
//
// Start filling in aliases.
//
for ( i = 0; i < aliasCount; i++ ) {
bytesFilled += strlen( Hostent32->h_aliases[i] ) + 1;
if ( bytesFilled > (DWORD)BufferLength ) {
STOREDWORD( aliases16[i], 0 );
return requiredBufferLength;
}
STOREDWORD(
aliases16[i],
FIND_16_OFFSET_FROM_32( VHostent16, Hostent16, currentLocation )
);
RtlMoveMemory(
currentLocation,
Hostent32->h_aliases[i],
strlen( Hostent32->h_aliases[i] ) + 1
);
currentLocation = (PCHAR)Hostent16 + bytesFilled;
}
STOREDWORD( aliases16[i], 0 );
return requiredBufferLength;
} // CopyHostentToBuffer
DWORD
BytesInHostent32 (
PHOSTENT Hostent32
)
{
DWORD total;
int i;
total = sizeof(HOSTENT);
total += strlen( Hostent32->h_name ) + 1;
total += sizeof(char *) + sizeof(char *);
for ( i = 0; Hostent32->h_aliases[i] != NULL; i++ ) {
total += strlen( Hostent32->h_aliases[i] ) + 1 + sizeof(char *);
}
for ( i = 0; Hostent32->h_addr_list[i] != NULL; i++ ) {
total += Hostent32->h_length + sizeof(char *);
}
return total;
} // BytesInHostent
ULONG FASTCALL WWS32getprotobyname(PVDMFRAME pFrame)
{
ULONG ul;
register PGETPROTOBYNAME16 parg16;
PPROTOENT protoent32 = NULL;
PPROTOENT16 protoent16;
PSZ name32 = NULL;
PBYTE name16;
DWORD bytesRequired;
if ( !WWS32IsThreadInitialized ) {
SetLastError( WSANOTINITIALISED );
RETURN((ULONG)NULL);
}
GETARGPTR( pFrame, sizeof(GETPROTOBYNAME16), parg16 );
GETVDMPTR( parg16->Name, 32, name16 );
if(name16) {
name32 = malloc_w(strlen(name16)+1);
if ( name32 ) {
strcpy(name32, name16);
protoent32 = (PPROTOENT) (*wsockapis[WOW_GETPROTOBYNAME].lpfn)( name32 );
free_w( name32 );
}
}
// Note: 16-bit callbacks resulting from above function
// call may have caused 16-bit memory movement
FREEVDMPTR(name16);
FREEARGPTR(parg16);
if ( protoent32 != NULL ) {
GETVDMPTR( WWS32vProtoent, MAXGETHOSTSTRUCT, protoent16 );
bytesRequired = CopyProtoent32To16(
protoent16,
WWS32vProtoent,
MAXGETHOSTSTRUCT,
protoent32
);
ASSERT( bytesRequired < MAXGETHOSTSTRUCT );
FLUSHVDMPTR( WWS32vProtoent, (USHORT) bytesRequired, protoent16 );
FREEVDMPTR( protoent16 );
ul = WWS32vProtoent;
} else {
ul = 0;
}
RETURN(ul);
} // WWS32getprotobyname
ULONG FASTCALL WWS32getprotobynumber(PVDMFRAME pFrame)
{
ULONG ul;
register PGETPROTOBYNUMBER16 parg16;
PPROTOENT protoent32;
PPROTOENT16 protoent16;
DWORD bytesRequired;
if ( !WWS32IsThreadInitialized ) {
SetLastError( WSANOTINITIALISED );
RETURN((ULONG)NULL);
}
GETARGPTR( pFrame, sizeof(GETPROTOBYNUMBER16), parg16 );
protoent32 = (PPROTOENT) (*wsockapis[WOW_GETPROTOBYNUMBER].lpfn)( parg16->Protocol );
if ( protoent32 != NULL ) {
GETVDMPTR( WWS32vProtoent, MAXGETHOSTSTRUCT, protoent16 );
bytesRequired = CopyProtoent32To16(
protoent16,
WWS32vProtoent,
MAXGETHOSTSTRUCT,
protoent32
);
ASSERT( bytesRequired < MAXGETHOSTSTRUCT );
FLUSHVDMPTR( WWS32vProtoent, (USHORT) bytesRequired, protoent16 );
FREEVDMPTR( protoent16 );
ul = WWS32vProtoent;
} else {
ul = 0;
}
FREEARGPTR(parg16);
RETURN(ul);
} // WWS32getprotobynumber
ULONG FASTCALL WWS32WSAAsyncGetProtoByName(PVDMFRAME pFrame)
{
ULONG ul;
register PWSAASYNCGETPROTOBYNAME16 parg16;
PWINSOCK_ASYNC_CONTEXT_BLOCK context;
PVOID buffer32;
PSZ name32;
if ( !WWS32IsThreadInitialized ) {
SetLastError( WSANOTINITIALISED );
RETURN(0);
}
GETARGPTR( pFrame, sizeof(WSAASYNCGETPROTOBYNAME16), parg16 );
GETVDMPTR( parg16->Name, 32, name32 );
//
// Set up locals so we know how to clean up on exit.
//
context = NULL;
buffer32 = NULL;
ul = 0;
//
// Allocate a context block and 32-bit buffer to use for the request.
//
context = malloc_w( sizeof(*context) );
if ( context == NULL ) {
(*wsockapis[WOW_WSASETLASTERROR].lpfn)( WSAENOBUFS );
goto exit;
}
buffer32 = malloc_w( MAXGETHOSTSTRUCT );
if ( context == NULL ) {
(*wsockapis[WOW_WSASETLASTERROR].lpfn)( WSAENOBUFS );
goto exit;
}
//
// Fill in entries in the context buffer.
//
context->Buffer32 = buffer32;
context->vBuffer16 = parg16->Buffer;
context->Buffer16Length = parg16->BufferLength;
//
// Enter a critical section to synchronize access to the context block
// and their global list.
//
RtlEnterCriticalSection( &WWS32CriticalSection );
context->AsyncTaskHandle32 = (HANDLE) (*wsockapis[WOW_WSAASYNCGETPROTOBYNAME].lpfn)(
(HWND)HWND32(parg16->hWnd),
(parg16->wMsg << 16) |
WWS32_MESSAGE_ASYNC_GETPROTO,
name32,
buffer32,
MAXGETHOSTSTRUCT
);
if ( context->AsyncTaskHandle32 != 0 ) {
//
// The call succeeded so get a 16-bit task handle for this
// request and place the context block on the global list. The
// resources will be freed by WWS32PostAsyncGetProto.
//
ul = WWS32GetAsyncTaskHandle16( );
context->AsyncTaskHandle16 = (HAND16)ul;
InsertTailList(
&WWS32AsyncContextBlockListHead,
&context->ContextBlockListEntry
);
}
RtlLeaveCriticalSection( &WWS32CriticalSection );
exit:
if ( ul == 0 ) {
if ( context != NULL ) {
free_w( (PVOID)context );
}
if ( buffer32 != NULL ) {
free_w( buffer32 );
}
}
FREEARGPTR( name32 );
FREEARGPTR( parg16 );
RETURN(ul);
} // WWS32WSAAsyncGetProtoByName
ULONG FASTCALL WWS32WSAAsyncGetProtoByNumber(PVDMFRAME pFrame)
{
ULONG ul;
register PWSAASYNCGETPROTOBYNUMBER16 parg16;
PWINSOCK_ASYNC_CONTEXT_BLOCK context;
PVOID buffer32;
if ( !WWS32IsThreadInitialized ) {
SetLastError( WSANOTINITIALISED );
RETURN(0);
}
GETARGPTR( pFrame, sizeof(WSAASYNCGETPROTOBYNUMBER16), parg16 );
//
// Set up locals so we know how to clean up on exit.
//
context = NULL;
buffer32 = NULL;
ul = 0;
//
// Allocate a context block and 32-bit buffer to use for the request.
//
context = malloc_w( sizeof(*context) );
if ( context == NULL ) {
(*wsockapis[WOW_WSASETLASTERROR].lpfn)( WSAENOBUFS );
goto exit;
}
buffer32 = malloc_w( MAXGETHOSTSTRUCT );
if ( context == NULL ) {
(*wsockapis[WOW_WSASETLASTERROR].lpfn)( WSAENOBUFS );
goto exit;
}
//
// Fill in entries in the context buffer.
//
context->Buffer32 = buffer32;
context->vBuffer16 = parg16->Buffer;
context->Buffer16Length = parg16->BufferLength;
//
// Enter a critical section to synchronize access to the context block
// and their global list.
//
RtlEnterCriticalSection( &WWS32CriticalSection );
context->AsyncTaskHandle32 = (HANDLE) (*wsockapis[WOW_WSAASYNCGETPROTOBYNUMBER].lpfn)(
(HWND)HWND32(parg16->hWnd),
(parg16->wMsg << 16) |
WWS32_MESSAGE_ASYNC_GETPROTO,
parg16->Number,
buffer32,
MAXGETHOSTSTRUCT
);
if ( context->AsyncTaskHandle32 != 0 ) {
//
// The call succeeded so get a 16-bit task handle for this
// request and place the context block on the global list. The
// resources will be freed by WWS32PostAsyncGetProto.
//
ul = WWS32GetAsyncTaskHandle16( );
context->AsyncTaskHandle16 = (HAND16)ul;
InsertTailList(
&WWS32AsyncContextBlockListHead,
&context->ContextBlockListEntry
);
}
RtlLeaveCriticalSection( &WWS32CriticalSection );
exit:
if ( ul == 0 ) {
if ( context != NULL ) {
free_w( (PVOID)context );
}
if ( buffer32 != NULL ) {
free_w( buffer32 );
}
}
FREEARGPTR( parg16 );
RETURN(ul);
} // WWS32WSAAsyncGetProtoByNumber
BOOL
WWS32PostAsyncGetProto (
HWND hWnd,
UINT Msg,
WPARAM wParam,
LPARAM lParam
)
{
PWINSOCK_ASYNC_CONTEXT_BLOCK context;
BOOL ret;
PVOID buffer16;
DWORD bytesRequired;
context = WWS32FindAndRemoveAsyncContext( (HANDLE)wParam );
ASSERT( context != NULL );
//
// If the call was successful, copy the 32-bit buffer to the
// 16-bit buffer specified by the application.
//
if ( WSAGETASYNCERROR( lParam ) == 0 ) {
//
// Copy the 32-bit structure to 16-bit buffer.
//
GETVDMPTR( context->vBuffer16, context->Buffer16Length, buffer16 );
bytesRequired = CopyProtoent32To16(
buffer16,
context->vBuffer16,
context->Buffer16Length,
context->Buffer32
);
//
// If the application's buffer was too small, return an error
// and information aqbout the buffer size required.
//
if ( bytesRequired > context->Buffer16Length ) {
lParam = WSAMAKEASYNCREPLY( (WORD)bytesRequired, WSAENOBUFS );
}
}
//
// Post the completion message to the 16-bit application.
//
ret = PostMessage(
hWnd,
Msg >> 16,
context->AsyncTaskHandle16,
lParam
);
//
// Free resources and return.
//
free_w( context->Buffer32 );
free_w( (PVOID)context );
return ret;
} // WWS32PostAsyncGetProto
DWORD
CopyProtoent32To16 (
PPROTOENT16 Protoent16,
VPPROTOENT16 VProtoent16,
int BufferLength,
PPROTOENT Protoent32
)
{
DWORD requiredBufferLength;
DWORD bytesFilled;
PCHAR currentLocation = (PCHAR)Protoent16;
DWORD aliasCount;
DWORD i;
VPBYTE *aliases16;
//
// Determine how many bytes are needed to fully copy the structure.
//
requiredBufferLength = BytesInProtoent32( Protoent32 );
//
// Copy over the protoent structure if it fits.
//
bytesFilled = sizeof(*Protoent16);
if ( bytesFilled > (DWORD)BufferLength ) {
return requiredBufferLength;
}
STOREWORD( Protoent16->p_proto, Protoent32->p_proto );
currentLocation = (PCHAR)Protoent16 + bytesFilled;
//
// Count the protocol's aliases and set up an array to hold pointers to
// them.
//
for ( aliasCount = 0;
Protoent32->p_aliases[aliasCount] != NULL;
aliasCount++ );
bytesFilled += (aliasCount+1) * sizeof(char FAR *);
if ( bytesFilled > (DWORD)BufferLength ) {
Protoent16->p_aliases = 0;
return requiredBufferLength;
}
Protoent16->p_aliases =
FIND_16_OFFSET_FROM_32( VProtoent16, Protoent16, currentLocation );
aliases16 = (VPBYTE *)currentLocation;
currentLocation = (PCHAR)Protoent16 + bytesFilled;
//
// Copy the protocol name if it fits.
//
bytesFilled += strlen( Protoent32->p_name ) + 1;
if ( bytesFilled > (DWORD)BufferLength ) {
return requiredBufferLength;
}
Protoent16->p_name =
FIND_16_OFFSET_FROM_32( VProtoent16, Protoent16, currentLocation );
RtlMoveMemory( currentLocation, Protoent32->p_name, strlen( Protoent32->p_name ) + 1 );
currentLocation = (PCHAR)Protoent16 + bytesFilled;
//
// Start filling in aliases.
//
for ( i = 0; i < aliasCount; i++ ) {
bytesFilled += strlen( Protoent32->p_aliases[i] ) + 1;
if ( bytesFilled > (DWORD)BufferLength ) {
STOREDWORD( aliases16[i], 0 );
return requiredBufferLength;
}
STOREDWORD(
aliases16[i],
FIND_16_OFFSET_FROM_32( VProtoent16, Protoent16, currentLocation )
);
RtlMoveMemory(
currentLocation,
Protoent32->p_aliases[i],
strlen( Protoent32->p_aliases[i] ) + 1
);
currentLocation = (PCHAR)Protoent16 + bytesFilled;
}
STOREDWORD( aliases16[i], 0 );
return requiredBufferLength;
} // CopyProtoent32To16
DWORD
BytesInProtoent32 (
PPROTOENT Protoent32
)
{
DWORD total;
int i;
total = sizeof(PROTOENT);
total += strlen( Protoent32->p_name ) + 1;
total += sizeof(char *);
for ( i = 0; Protoent32->p_aliases[i] != NULL; i++ ) {
total += strlen( Protoent32->p_aliases[i] ) + 1 + sizeof(char *);
}
return total;
} // BytesInProtoent32
ULONG FASTCALL WWS32getservbyname(PVDMFRAME pFrame)
{
ULONG ul;
register PGETSERVBYNAME16 parg16;
PSERVENT servent32;
PSERVENT16 servent16;
PSZ name32;
PSZ protocol32;
DWORD bytesRequired;
if ( !WWS32IsThreadInitialized ) {
SetLastError( WSANOTINITIALISED );
RETURN((ULONG)NULL);
}
GETARGPTR( pFrame, sizeof(GETSERVBYNAME16), parg16 );
GETVDMPTR( parg16->Name, 32, name32 );
GETVDMPTR( parg16->Protocol, 32, protocol32 );
servent32 = (PSERVENT) (*wsockapis[WOW_GETSERVBYNAME].lpfn)( name32, protocol32 );
if ( servent32 != NULL ) {
GETVDMPTR( WWS32vServent, MAXGETHOSTSTRUCT, servent16 );
bytesRequired = CopyServent32To16(
servent16,
WWS32vServent,
MAXGETHOSTSTRUCT,
servent32
);
ASSERT( bytesRequired < MAXGETHOSTSTRUCT );
FLUSHVDMPTR( WWS32vServent, (USHORT) bytesRequired, servent16 );
FREEVDMPTR( servent16 );
ul = WWS32vServent;
} else {
ul = 0;
}
FREEVDMPTR( name32 );
FREEVDMPTR( protocol32 );
FREEARGPTR(parg16);
RETURN(ul);
} // WWS32getservbyname
ULONG FASTCALL WWS32getservbyport(PVDMFRAME pFrame)
{
ULONG ul;
register PGETSERVBYPORT16 parg16;
PSERVENT servent32;
PSERVENT16 servent16;
PSZ protocol32;
DWORD bytesRequired;
if ( !WWS32IsThreadInitialized ) {
SetLastError( WSANOTINITIALISED );
RETURN((ULONG)NULL);
}
GETARGPTR( pFrame, sizeof(GETSERVBYPORT16), parg16 );
GETVDMPTR( parg16->Protocol, 32, protocol32 );
servent32 = (PSERVENT) (*wsockapis[WOW_GETSERVBYPORT].lpfn)( parg16->Port, protocol32 );
if ( servent32 != NULL ) {
GETVDMPTR( WWS32vServent, MAXGETHOSTSTRUCT, servent16 );
bytesRequired = CopyServent32To16(
servent16,
WWS32vServent,
MAXGETHOSTSTRUCT,
servent32
);
ASSERT( bytesRequired < MAXGETHOSTSTRUCT );
FLUSHVDMPTR( WWS32vServent, (USHORT) bytesRequired, servent16 );
FREEVDMPTR( servent16 );
ul = WWS32vServent;
} else {
ul = 0;
}
FREEVDMPTR( protocol32 );
FREEARGPTR(parg16);
RETURN(ul);
} // WWS32getservbyport
ULONG FASTCALL WWS32WSAAsyncGetServByPort(PVDMFRAME pFrame)
{
ULONG ul;
register PWSAASYNCGETSERVBYPORT16 parg16;
PWINSOCK_ASYNC_CONTEXT_BLOCK context;
PVOID buffer32;
PSZ proto32;
if ( !WWS32IsThreadInitialized ) {
SetLastError( WSANOTINITIALISED );
RETURN((ULONG)0);
}
GETARGPTR( pFrame, sizeof(WSAASYNCGETSERVBYPORT16), parg16 );
GETVDMPTR( parg16->Protocol, 32, proto32 );
//
// Set up locals so we know how to clean up on exit.
//
context = NULL;
buffer32 = NULL;
ul = 0;
//
// Allocate a context block and 32-bit buffer to use for the request.
//
context = malloc_w( sizeof(*context) );
if ( context == NULL ) {
(*wsockapis[WOW_WSASETLASTERROR].lpfn)( WSAENOBUFS );
goto exit;
}
buffer32 = malloc_w( MAXGETHOSTSTRUCT );
if ( context == NULL ) {
(*wsockapis[WOW_WSASETLASTERROR].lpfn)( WSAENOBUFS );
goto exit;
}
//
// Fill in entries in the context buffer.
//
context->Buffer32 = buffer32;
context->vBuffer16 = parg16->Buffer;
context->Buffer16Length = parg16->BufferLength;
//
// Enter a critical section to synchronize access to the context block
// and their global list.
//
RtlEnterCriticalSection( &WWS32CriticalSection );
context->AsyncTaskHandle32 = (HANDLE) (*wsockapis[WOW_WSAASYNCGETSERVBYPORT].lpfn)(
(HWND)HWND32(parg16->hWnd),
(parg16->wMsg << 16) |
WWS32_MESSAGE_ASYNC_GETSERV,
parg16->Port,
proto32,
buffer32,
MAXGETHOSTSTRUCT
);
if ( context->AsyncTaskHandle32 != 0 ) {
//
// The call succeeded so get a 16-bit task handle for this
// request and place the context block on the global list. The
// resources will be freed by WWS32PostAsyncGetServ.
//
ul = WWS32GetAsyncTaskHandle16( );
context->AsyncTaskHandle16 = (HAND16)ul;
InsertTailList(
&WWS32AsyncContextBlockListHead,
&context->ContextBlockListEntry
);
}
RtlLeaveCriticalSection( &WWS32CriticalSection );
exit:
if ( ul == 0 ) {
if ( context != NULL ) {
free_w( (PVOID)context );
}
if ( buffer32 != NULL ) {
free_w( buffer32 );
}
}
FREEARGPTR( proto32 );
FREEARGPTR( parg16 );
RETURN(ul);
} // WWS32WSAAsyncGetServByPort
ULONG FASTCALL WWS32WSAAsyncGetServByName(PVDMFRAME pFrame)
{
ULONG ul;
register PWSAASYNCGETSERVBYNAME16 parg16;
PWINSOCK_ASYNC_CONTEXT_BLOCK context;
PVOID buffer32;
PSZ name32;
PSZ proto32;
if ( !WWS32IsThreadInitialized ) {
SetLastError( WSANOTINITIALISED );
RETURN((ULONG)0);
}
GETARGPTR( pFrame, sizeof(WSAASYNCGETSERVBYNAME16), parg16 );
GETVDMPTR( parg16->Name, 32, name32 );
GETVDMPTR( parg16->Protocol, 32, proto32 );
//
// Set up locals so we know how to clean up on exit.
//
context = NULL;
buffer32 = NULL;
ul = 0;
//
// Allocate a context block and 32-bit buffer to use for the request.
//
context = malloc_w( sizeof(*context) );
if ( context == NULL ) {
(*wsockapis[WOW_WSASETLASTERROR].lpfn)( WSAENOBUFS );
goto exit;
}
buffer32 = malloc_w( MAXGETHOSTSTRUCT );
if ( context == NULL ) {
(*wsockapis[WOW_WSASETLASTERROR].lpfn)( WSAENOBUFS );
goto exit;
}
//
// Fill in entries in the context buffer.
//
context->Buffer32 = buffer32;
context->vBuffer16 = parg16->Buffer;
context->Buffer16Length = parg16->BufferLength;
//
// Enter a critical section to synchronize access to the context block
// and their global list.
//
RtlEnterCriticalSection( &WWS32CriticalSection );
context->AsyncTaskHandle32 = (HANDLE) (*wsockapis[WOW_WSAASYNCGETSERVBYNAME].lpfn)(
(HWND)HWND32(parg16->hWnd),
(parg16->wMsg << 16) |
WWS32_MESSAGE_ASYNC_GETSERV,
name32,
proto32,
buffer32,
MAXGETHOSTSTRUCT
);
if ( context->AsyncTaskHandle32 != 0 ) {
//
// The call succeeded so get a 16-bit task handle for this
// request and place the context block on the global list. The
// resources will be freed by WWS32PostAsyncGetServ.
//
ul = WWS32GetAsyncTaskHandle16( );
context->AsyncTaskHandle16 = (HAND16)ul;
InsertTailList(
&WWS32AsyncContextBlockListHead,
&context->ContextBlockListEntry
);
}
RtlLeaveCriticalSection( &WWS32CriticalSection );
exit:
if ( ul == 0 ) {
if ( context != NULL ) {
free_w( (PVOID)context );
}
if ( buffer32 != NULL ) {
free_w( buffer32 );
}
}
FREEARGPTR( proto32 );
FREEARGPTR( name32 );
FREEARGPTR( parg16 );
RETURN(ul);
} // WWS32WSAAsyncGetServByName
BOOL
WWS32PostAsyncGetServ (
HWND hWnd,
UINT Msg,
WPARAM wParam,
LPARAM lParam
)
{
PWINSOCK_ASYNC_CONTEXT_BLOCK context;
BOOL ret;
PVOID buffer16;
DWORD bytesRequired;
context = WWS32FindAndRemoveAsyncContext( (HANDLE)wParam );
ASSERT( context != NULL );
//
// If the call was successful, copy the 32-bit buffer to the
// 16-bit buffer specified by the application.
//
if ( WSAGETASYNCERROR( lParam ) == 0 ) {
//
// Copy the 32-bit structure to 16-bit buffer.
//
GETVDMPTR( context->vBuffer16, context->Buffer16Length, buffer16 );
bytesRequired = CopyServent32To16(
buffer16,
context->vBuffer16,
context->Buffer16Length,
context->Buffer32
);
//
// If the application's buffer was too small, return an error
// and information aqbout the buffer size required.
//
if ( bytesRequired > context->Buffer16Length ) {
lParam = WSAMAKEASYNCREPLY( (WORD)bytesRequired, WSAENOBUFS );
}
}
//
// Post the completion message to the 16-bit application.
//
ret = PostMessage(
hWnd,
Msg >> 16,
context->AsyncTaskHandle16,
lParam
);
//
// Free resources and return.
//
free_w( context->Buffer32 );
free_w( (PVOID)context );
return ret;
} // WWS32PostAsyncGetServ
DWORD
CopyServent32To16 (
PSERVENT16 Servent16,
VPSERVENT16 VServent16,
int BufferLength,
PSERVENT Servent32
)
{
DWORD requiredBufferLength;
DWORD bytesFilled;
PCHAR currentLocation = (PCHAR)Servent16;
DWORD aliasCount;
DWORD i;
VPBYTE *aliases16;
//
// Determine how many bytes are needed to fully copy the structure.
//
requiredBufferLength = BytesInServent32( Servent32 );
//
// Copy over the servent structure if it fits.
//
bytesFilled = sizeof(*Servent16);
if ( bytesFilled > (DWORD)BufferLength ) {
return requiredBufferLength;
}
STOREWORD( Servent16->s_port, Servent32->s_port );
currentLocation = (PCHAR)Servent16 + bytesFilled;
//
// Count the service's aliases and set up an array to hold pointers to
// them.
//
for ( aliasCount = 0;
Servent32->s_aliases[aliasCount] != NULL;
aliasCount++ );
bytesFilled += (aliasCount+1) * sizeof(char FAR *);
if ( bytesFilled > (DWORD)BufferLength ) {
STOREDWORD( Servent32->s_aliases, 0 );
return requiredBufferLength;
}
Servent16->s_aliases =
FIND_16_OFFSET_FROM_32( VServent16, Servent16, currentLocation );
aliases16 = (VPBYTE *)currentLocation;
currentLocation = (PCHAR)Servent16 + bytesFilled;
//
// Copy the service name if it fits.
//
bytesFilled += strlen( Servent32->s_name ) + 1;
if ( bytesFilled > (DWORD)BufferLength ) {
return requiredBufferLength;
}
Servent16->s_name =
FIND_16_OFFSET_FROM_32( VServent16, Servent16, currentLocation );
RtlMoveMemory( currentLocation, Servent32->s_name, strlen( Servent32->s_name ) + 1 );
currentLocation = (PCHAR)Servent16 + bytesFilled;
//
// Copy the protocol name if it fits.
//
bytesFilled += strlen( Servent32->s_proto ) + 1;
if ( bytesFilled > (DWORD)BufferLength ) {
return requiredBufferLength;
}
Servent16->s_proto =
FIND_16_OFFSET_FROM_32( VServent16, Servent16, currentLocation );
RtlMoveMemory( currentLocation, Servent32->s_proto, strlen( Servent32->s_proto ) + 1 );
currentLocation = (PCHAR)Servent16 + bytesFilled;
//
// Start filling in aliases.
//
for ( i = 0; i < aliasCount; i++ ) {
bytesFilled += strlen( Servent32->s_aliases[i] ) + 1;
if ( bytesFilled > (DWORD)BufferLength ) {
STOREDWORD( aliases16[i], NULL );
return requiredBufferLength;
}
STOREDWORD(
aliases16[i],
FIND_16_OFFSET_FROM_32( VServent16, Servent16, currentLocation )
);
RtlMoveMemory(
currentLocation,
Servent32->s_aliases[i],
strlen( Servent32->s_aliases[i] ) + 1
);
currentLocation = (PCHAR)Servent16 + bytesFilled;
}
STOREDWORD( aliases16[i], NULL );
return requiredBufferLength;
} // CopyServent32To16
DWORD
BytesInServent32 (
IN PSERVENT Servent32
)
{
DWORD total;
int i;
total = sizeof(SERVENT);
total += strlen( Servent32->s_name ) + 1;
total += strlen( Servent32->s_proto ) + 1;
total += sizeof(char *);
for ( i = 0; Servent32->s_aliases[i] != NULL; i++ ) {
total += strlen( Servent32->s_aliases[i] ) + 1 + sizeof(char *);
}
return total;
} // BytesInServent32
ULONG FASTCALL WWS32WSACancelAsyncRequest(PVDMFRAME pFrame)
{
ULONG ul;
register PWSACANCELASYNCREQUEST16 parg16;
if ( !WWS32IsThreadInitialized ) {
SetLastError( WSANOTINITIALISED );
RETURN((ULONG)SOCKET_ERROR);
}
GETARGPTR(pFrame, sizeof(WSACANCELASYNCREQUEST16), parg16);
//ul = GETWORD16((*wsockapis[WOW_WSACANCELASYNCREQUEST].lpfn)(
// ));
FREEARGPTR(parg16);
ul = (ULONG) SOCKET_ERROR;
SetLastError( WSAEINVAL );
RETURN(ul);
} // WWS32WSACancelAsyncRequest
PWINSOCK_ASYNC_CONTEXT_BLOCK
WWS32FindAndRemoveAsyncContext (
IN HANDLE AsyncTaskHandle32
)
{
PWINSOCK_ASYNC_CONTEXT_BLOCK context;
PLIST_ENTRY listEntry;
RtlEnterCriticalSection( &WWS32CriticalSection );
//
// Walk the global list of async context blocks, looking for
// one that matches the specified task handle.
//
for ( listEntry = WWS32AsyncContextBlockListHead.Flink;
listEntry != &WWS32AsyncContextBlockListHead;
listEntry = listEntry->Flink ) {
context = CONTAINING_RECORD(
listEntry,
WINSOCK_ASYNC_CONTEXT_BLOCK,
ContextBlockListEntry
);
if ( context->AsyncTaskHandle32 == AsyncTaskHandle32 ) {
//
// Found a match. Remove it from the global list, leave
// the critical section, and return the context block.
//
RemoveEntryList( &context->ContextBlockListEntry );
RtlLeaveCriticalSection( &WWS32CriticalSection );
return context;
}
}
//
// A matching context block was not found on the list.
//
RtlLeaveCriticalSection( &WWS32CriticalSection );
return NULL;
} // WWS32FindAndRemoveAsyncContext
HAND16
WWS32GetAsyncTaskHandle16 (
VOID
)
{
HAND16 asyncTaskHandle16;
// *** this routine *must* be called from within the WWS32 critical
// section!
ASSERT( WWS32AsyncTaskHandleCounter != 0 );
asyncTaskHandle16 = (HAND16)WWS32AsyncTaskHandleCounter;
WWS32AsyncTaskHandleCounter++;
//
// 0 is an invalid task handle value; if the counter has wrapped to
// zero, set it to 1.
//
if ( WWS32AsyncTaskHandleCounter == 0 ) {
WWS32AsyncTaskHandleCounter = 1;
}
return WWS32AsyncTaskHandleCounter;
} // WWS32GetAsyncTaskHandle16
Reference in a new issue Copy permalink