/*++ Intel Corporation Proprietary Information Copyright (c) 1995 Intel Corporation This listing is supplied under the terms of a license agreement with Intel Corporation and may not be used, copied, nor disclosed except in accordance with the terms of that agreeement. Module Name: dprovide.h Abstract: This module defines the WinSock2 class dprovder along with its methods. Author: Mark Hamilton (mark_hamilton@ccm.jf.intel.com) 7-July-1995 Revision History: 23-Aug-1995 dirk@mink.intel.com Cleanup after code review. Changed names of private data members. Moved single line functions into this header. 25-July-1995 dirk@mink.intel.com Removed process linage data member. 7-July-1995 mark_hamilton Genesis --*/ #ifndef _DPROVIDER_ #define _DPROVIDER_ #include #include #include "dthook.h" class DPROVIDER { public: DPROVIDER(); INT Initialize( IN LPWSTR lpszLibFile, IN LPWSAPROTOCOL_INFOW lpProtocolInfo); SOCKET WSPAccept( IN SOCKET s, OUT struct sockaddr FAR *addr, OUT INT FAR *addrlen, IN LPCONDITIONPROC lpfnCondition, IN DWORD_PTR dwCallbackData, OUT INT FAR *lpErrno); INT WSPAddressToString( IN LPSOCKADDR lpsaAddress, IN DWORD dwAddressLength, IN LPWSAPROTOCOL_INFOW lpProtocolInfo, OUT LPWSTR lpszAddressString, IN OUT LPDWORD lpdwAddressStringLength, OUT LPINT lpErrno ); INT WSPAsyncSelect( IN SOCKET s, IN HWND hWnd, IN unsigned int wMsg, IN long lEvent, OUT INT FAR *lpErrno); INT WSPBind( IN SOCKET s, IN const struct sockaddr FAR *name, IN INT namelen, OUT INT FAR *lpErrno); INT WSPCancelBlockingCall( OUT INT FAR *lpErrno); INT WSPCleanup( OUT INT FAR *lpErrno); INT WSPCloseSocket( IN SOCKET s, OUT INT FAR *lpErrno); INT WSPConnect( IN SOCKET s, IN const struct sockaddr FAR *name, IN INT namelen, IN LPWSABUF lpCallerData, IN LPWSABUF lpCalleeData, IN LPQOS lpSQOS, IN LPQOS lpGQOS, OUT INT FAR *lpErrno); INT WSPDuplicateSocket( IN SOCKET s, IN DWORD dwProcessID, IN LPWSAPROTOCOL_INFOW lpProtocolInfo, OUT INT FAR *lpErrno); INT WSPEnumNetworkEvents( IN SOCKET s, OUT WSAEVENT hEventObject, OUT LPWSANETWORKEVENTS lpNetworkEvents, OUT INT FAR *lpErrno); INT WSPEventSelect( IN SOCKET s, IN OUT WSAEVENT hEventObject, IN long lNetworkEvents, OUT INT FAR *lpErrno); INT WSPGetOverlappedResult( IN SOCKET s, IN LPWSAOVERLAPPED lpOverlapped, IN LPDWORD lpcbTransfer, IN BOOL fWait, OUT LPDWORD lpdwFlags, OUT INT FAR *lpErrno); INT WSPGetPeerName( IN SOCKET s, OUT struct sockaddr FAR *name, OUT INT FAR *namelen, OUT INT FAR *lpErrno); INT WSPGetQOSByName( IN SOCKET s, IN LPWSABUF lpQOSName, IN LPQOS lpQOS, OUT INT FAR *lpErrno); INT WSPGetSockName( IN SOCKET s, OUT struct sockaddr FAR *name, OUT INT FAR *namelen, OUT INT FAR *lpErrno); INT WSPGetSockOpt( IN SOCKET s, IN INT level, IN INT optname, OUT char FAR *optval, OUT INT FAR *optlen, OUT INT FAR *lpErrno); INT WSPIoctl( IN SOCKET s, IN DWORD dwIoControlCode, IN LPVOID lpvInBuffer, IN DWORD cbInBuffer, IN LPVOID lpvOutBuffer, IN DWORD cbOutBuffer, IN LPDWORD lpcbBytesReturned, IN LPWSAOVERLAPPED lpOverlapped, IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, IN LPWSATHREADID lpThreadId, OUT INT FAR *lpErrno); SOCKET WSPJoinLeaf( IN SOCKET s, IN const struct sockaddr FAR *name, IN INT namelen, IN LPWSABUF lpCallerData, IN LPWSABUF lpCalleeData, IN LPQOS lpSQOS, IN LPQOS lpGQOS, IN DWORD dwFlags, OUT INT FAR *lpErrno); INT WSPListen( IN SOCKET s, IN INT backlog, OUT INT FAR *lpErrno); INT WSPRecv( IN SOCKET s, IN LPWSABUF lpBuffers, IN DWORD dwBufferCount, IN LPDWORD lpNumberOfBytesRecvd, IN OUT LPDWORD lpFlags, IN LPWSAOVERLAPPED lpOverlapped, IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, IN LPWSATHREADID lpThreadId, OUT INT FAR *lpErrno); INT WSPRecvDisconnect( IN SOCKET s, IN LPWSABUF lpInboundDisconnectData, OUT INT FAR *lpErrno); INT WSPRecvFrom( IN SOCKET s, IN LPWSABUF lpBuffers, IN DWORD dwBufferCount, IN LPDWORD lpNumberOfBytesRecvd, IN OUT LPDWORD lpFlags, OUT struct sockaddr FAR * lpFrom, IN LPINT lpFromlen, IN LPWSAOVERLAPPED lpOverlapped, IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, IN LPWSATHREADID lpThreadId, OUT INT FAR *lpErrno); INT WSPSelect( IN INT nfds, IN OUT fd_set FAR *readfds, IN OUT fd_set FAR *writefds, IN OUT fd_set FAR *exceptfds, IN const struct timeval FAR *timeout, OUT INT FAR *lpErrno); INT WSPSend( IN SOCKET s, IN LPWSABUF lpBuffers, IN DWORD dwBufferCount, OUT LPDWORD lpNumberOfBytesSent, IN DWORD dwFlags, IN LPWSAOVERLAPPED lpOverlapped, IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, IN LPWSATHREADID lpThreadId, OUT INT FAR *lpErrno); INT WSPSendDisconnect( IN SOCKET s, IN LPWSABUF lpOutboundDisconnectData, OUT INT FAR *lpErrno); INT WSPSendTo( IN SOCKET s, IN LPWSABUF lpBuffers, IN DWORD dbBufferCount, IN LPDWORD lpNumberOfBytesSent, IN DWORD dwFlags, IN const struct sockaddr FAR * lpTo, IN INT iTolen, IN LPWSAOVERLAPPED lpOverlapped, IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, IN LPWSATHREADID lpThreadId, OUT INT FAR *lpErrno); INT WSPSetSockOpt( IN SOCKET s, IN INT level, IN INT optname, IN const char FAR *optval, IN INT optlen, OUT INT FAR *lpErrno); INT WSPShutdown( IN SOCKET s, IN INT how, OUT INT FAR *lpErrno); SOCKET WSPSocket( IN int af, IN int type, IN int protocol, IN LPWSAPROTOCOL_INFOW lpProtocolInfo, IN GROUP g, IN DWORD dwFlags, OUT INT FAR *lpErrno); INT WSPStringToAddress( IN LPWSTR AddressString, IN INT AddressFamily, IN LPWSAPROTOCOL_INFOW lpProtocolInfo, OUT LPSOCKADDR lpAddress, IN OUT LPINT lpAddressLength, IN OUT LPINT lpErrno ); DWORD_PTR GetCancelCallPtr(); VOID Reference (); VOID Dereference (); private: // Destruction should be done using dereferencing ~DPROVIDER(); // Variables LONG m_reference_count; HINSTANCE m_library_handle; WSPPROC_TABLE m_proctable; #ifdef DEBUG_TRACING LPSTR m_lib_name; #endif }; inline VOID DPROVIDER::Reference () { // // Object is created with reference count of 1 // and is destroyed whenever it gets back to 0. // assert (m_reference_count>0); InterlockedIncrement (&m_reference_count); } inline VOID DPROVIDER::Dereference () { assert (m_reference_count>0); if (InterlockedDecrement (&m_reference_count)==0) delete this; } inline DWORD_PTR DPROVIDER::GetCancelCallPtr() { return((DWORD_PTR)m_proctable.lpWSPCancelBlockingCall); } inline SOCKET DPROVIDER::WSPAccept( IN SOCKET s, OUT struct sockaddr FAR *addr, OUT INT FAR *addrlen, IN LPCONDITIONPROC lpfnCondition, IN DWORD_PTR dwCallbackData, OUT INT FAR *lpErrno ) /*++ Routine Description: Conditionally accept a connection based on the return value of a condition function, and optionally create and/or join a socket group. Arguments: s - A descriptor identiying a socket which is listening for connections after a WSPListen(). addr - An optional pointer to a buffer which receives the address of the connecting entity, as known to the service provider. The exact format of the addr arguement is determined by the address family established when the socket was created. addrlen - An optional pointer to an integer which contains the length of the address addr. lpfnCondition - The procedure instance address of an optional, WinSock 2 client supplied condition function which will make an accept/reject decision based on the caller information passed in as parameters, and optionally creaetd and/or join a socket group by assigning an appropriate value to the result parameter of this function. dwCallbackData - Callback data to be passed back to the WinSock 2 client as a condition function parameter. This parameter is not interpreted by the service provider. lpErrno - A pointer to the error code. Return Value: If no error occurs, WSPAccept() returns a value of type SOCKET which is a descriptor for the accepted socket. Otherwise, a value of INVALID_SOCKET is returned, and a specific error code is available in lpErrno. --*/ { SOCKET ReturnValue=INVALID_SOCKET; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPAccept, &ReturnValue, m_lib_name, &s, &addr, &addrlen, &lpfnCondition, &dwCallbackData, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPAccept( s, addr, addrlen, lpfnCondition, dwCallbackData, lpErrno); POSTAPINOTIFY(( DTCODE_WSPAccept, &ReturnValue, m_lib_name, &s, &addr, &addrlen, &lpfnCondition, &dwCallbackData, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPAddressToString( IN LPSOCKADDR lpsaAddress, IN DWORD dwAddressLength, IN LPWSAPROTOCOL_INFOW lpProtocolInfo, OUT LPWSTR lpszAddressString, IN OUT LPDWORD lpdwAddressStringLength, OUT LPINT lpErrno ) /*++ Routine Description: WSPAddressToString() converts a SOCKADDR structure into a human-readable string representation of the address. This is intended to be used mainly for display purposes. If the caller wishes the translation to be done by a particular provider, it should supply the corresponding WSAPROTOCOL_INFOW struct in the lpProtocolInfo parameter. Arguments: lpsaAddress - points to a SOCKADDR structure to translate into a string. dwAddressLength - the length of the Address SOCKADDR. lpProtocolInfo - (optional) the WSAPROTOCOL_INFOW struct for a particular provider. lpszAddressString - a buffer which receives the human-readable address string. lpdwAddressStringLength - on input, the length of the AddressString buffer. On output, returns the length of the string actually copied into the buffer. Return Value: The return value is 0 if the operation was successful. Otherwise the value SOCKET_ERROR is returned --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPAddressToString, &ReturnValue, m_lib_name, &lpsaAddress, &dwAddressLength, &lpProtocolInfo, &lpszAddressString, &lpdwAddressStringLength, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPAddressToString( lpsaAddress, dwAddressLength, lpProtocolInfo, lpszAddressString, lpdwAddressStringLength, lpErrno); POSTAPINOTIFY(( DTCODE_WSPAddressToString, &ReturnValue, m_lib_name, &lpsaAddress, &dwAddressLength, &lpProtocolInfo, &lpszAddressString, &lpdwAddressStringLength, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPAsyncSelect( IN SOCKET s, IN HWND hWnd, IN unsigned int wMsg, IN long lEvent, OUT INT FAR *lpErrno ) /*++ Routine Description: Request Windows message-based event notification of network events for a socket. Arguments: s - A descriptor identiying a socket for which event notification is required. hWnd - A handle identifying the window which should receive a message when a network event occurs. wMsg - The message to be sent when a network event occurs. lEvent - bitmask which specifies a combination of network events in which the WinSock client is interested. lpErrno - A pointer to the error code. Return Value: The return value is 0 if the WinSock client's declaration of interest in the netowrk event set was successful. Otherwise the value SOCKET_ERROR is returned, and a specific error code is available in lpErrno. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPAsyncSelect, &ReturnValue, m_lib_name, &s, &hWnd, &wMsg, &lEvent, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPAsyncSelect( s, hWnd, wMsg, lEvent, lpErrno); POSTAPINOTIFY(( DTCODE_WSPAsyncSelect, &ReturnValue, m_lib_name, &s, &hWnd, &wMsg, &lEvent, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPBind( IN SOCKET s, IN const struct sockaddr FAR *name, IN INT namelen, OUT INT FAR *lpErrno ) /*++ Routine Description: Associate a local address (i.e. name) with a socket. Arguments: s - A descriptor identifying an unbound socket. name - The address to assign to the socket. The sockaddr structure is defined as follows: struct sockaddr { u_short sa_family; char sa_data[14]; }; Except for the sa_family field, sockaddr contents are epxressed in network byte order. namelen - The length of the name. lpErrno - A pointer to the error code. Return Value: If no erro occurs, WSPBind() returns 0. Otherwise, it returns SOCKET_ERROR, and a specific error code is available in lpErrno. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPBind, &ReturnValue, m_lib_name, &s, &name, &namelen, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPBind( s, name, namelen, lpErrno); POSTAPINOTIFY(( DTCODE_WSPBind, &ReturnValue, m_lib_name, &s, &name, &namelen, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPCancelBlockingCall(OUT INT FAR *lpErrno) /*++ Routine Description: Cancel a blocking call which is currently in progress. Arguments: lpErrno - A pointer to the error code. Return Value: The value returned by WSPCancelBlockingCall() is 0 if the operation was successfully canceled. Otherwise the value SOCKET_ERROR is returned, and a specific error code is available in lpErrno. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPCancelBlockingCall, &ReturnValue, m_lib_name, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPCancelBlockingCall( lpErrno); POSTAPINOTIFY(( DTCODE_WSPCancelBlockingCall, &ReturnValue, m_lib_name, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPCloseSocket( IN SOCKET s, OUT INT FAR *lpErrno ) /*++ Routine Description: Close a socket. Arguments: s - A descriptor identifying a socket. lpErrno - A pointer to the error code. Return Value: If no erro occurs, WSPCloseSocket() returns 0. Otherwise, a value of SOCKET_ERROR is returned, and a specific error code is available in lpErrno. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPCloseSocket, &ReturnValue, m_lib_name, &s, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPCloseSocket( s, lpErrno); POSTAPINOTIFY(( DTCODE_WSPCloseSocket, &ReturnValue, m_lib_name, &s, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPConnect( IN SOCKET s, IN const struct sockaddr FAR *name, IN INT namelen, IN LPWSABUF lpCallerData, IN LPWSABUF lpCalleeData, IN LPQOS lpSQOS, IN LPQOS lpGQOS, OUT INT FAR *lpErrno ) /*++ Routine Description: Establish a connection to a peer, exchange connect data, and specify needed quality of service based on the supplied flow spec. Arguments: s - A descriptor identifying an unconnected socket. name - The name of the peer to which the socket is to be connected. namelen - The length of the name. lpCallerData - A pointer to the user data that is to be transferred to the peer during connection established. lpCalleeData - A pointer to a buffer into which may be copied any user data received from the peer during connection establishment. lpSQOS - A pointer to the flow specs for socket s, one for each direction. lpGQOS - A pointer to the flow specs for the socket group (if applicable). lpErrno - A pointer to the error code. Return Value: If no error occurs, WSPConnect() returns ERROR_SUCCESS. Otherwise, it returns SOCKET_ERROR, and a specific erro rcode is available in lpErrno. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPConnect, &ReturnValue, m_lib_name, &s, &name, &namelen, &lpCallerData, &lpCalleeData, &lpSQOS, &lpGQOS, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPConnect( s, name, namelen, lpCallerData, lpCalleeData, lpSQOS, lpGQOS, lpErrno); POSTAPINOTIFY(( DTCODE_WSPConnect, &ReturnValue, m_lib_name, &s, &name, &namelen, &lpCallerData, &lpCalleeData, &lpSQOS, &lpGQOS, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPDuplicateSocket( IN SOCKET s, IN DWORD dwProcessID, IN LPWSAPROTOCOL_INFOW lpProtocolInfo, OUT INT FAR *lpErrno ) /*++ Routine Description: descriptor for a shared socket. Arguments: s - Specifies the local socket descriptor. dwProcessID - Specifies the ID of the target process for which the shared socket will be used. lpProtocolInfo - A pointer to a buffer allocated by the client that is large enough to contain a WSAPROTOCOL_INFOW struct. The service provider copies the protocol info struct contents to this buffer. lpErrno - A pointer to the error code Return Value: If no error occurs, WPSDuplicateSocket() returns zero. Otherwise, the value of SOCKET_ERROR is returned, and a specific error number is available in lpErrno. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPDuplicateSocket, &ReturnValue, m_lib_name, &s, &dwProcessID, &lpProtocolInfo, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPDuplicateSocket( s, dwProcessID, lpProtocolInfo, lpErrno); POSTAPINOTIFY(( DTCODE_WSPDuplicateSocket, &ReturnValue, m_lib_name, &s, &dwProcessID, &lpProtocolInfo, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPEnumNetworkEvents( IN SOCKET s, OUT WSAEVENT hEventObject, OUT LPWSANETWORKEVENTS lpNetworkEvents, OUT INT FAR *lpErrno ) /*++ Routine Description: Report occurrences of network events for the indicated socket. Arguments: s - A descriptor identifying the socket. hEventObject - An optional handle identifying an associated event object to be reset. lpNetworkEvents - A pointer to a WSANETWORKEVENTS struct which is filled with a record of occurred network events and any associated error codes. lpErrno - A pointer to the error code. Return Value: The return value is ERROR_SUCCESS if the operation was successful. Otherwise the value SOCKET_ERROR is returned, and a specific error number is available in lpErrno. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPEnumNetworkEvents, &ReturnValue, m_lib_name, &s, &hEventObject, &lpNetworkEvents, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPEnumNetworkEvents( s, hEventObject, lpNetworkEvents, lpErrno); POSTAPINOTIFY(( DTCODE_WSPEnumNetworkEvents, &ReturnValue, m_lib_name, &s, &hEventObject, &lpNetworkEvents, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPEventSelect( IN SOCKET s, IN OUT WSAEVENT hEventObject, IN long lNetworkEvents, OUT INT FAR *lpErrno ) /*++ Routine Description: Specify an event object to be associated with the supplied set of network events. Arguments: s - A descriptor identifying the socket. hEventObject - A handle identifying the event object to be associated with the supplied set of network events. lNetworkEvents - A bitmask which specifies the combination of network events in which the WinSock client has interest. lpErrno - A pointer to the error code. Return Value: The return value is 0 if the WinSock client's specification of the network events and the associated event object was successful. Otherwise the value SOCKET_ERROR is returned, and a specific error number is available in lpErrno --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPEventSelect, &ReturnValue, m_lib_name, &s, &hEventObject, &lNetworkEvents, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPEventSelect( s, hEventObject, lNetworkEvents, lpErrno); POSTAPINOTIFY(( DTCODE_WSPEventSelect, &ReturnValue, m_lib_name, &s, &hEventObject, &lNetworkEvents, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPGetOverlappedResult( IN SOCKET s, IN LPWSAOVERLAPPED lpOverlapped, IN LPDWORD lpcbTransfer, IN BOOL fWait, OUT LPDWORD lpdwFlags, OUT INT FAR *lpErrno ) /*++ Routine Description: Returns the results of an overlapped operation on the specified socket. Arguments: s - Identifies the socket. This is the same socket that was specified when the overlapped operation was started by a call to WSPRecv(), WSPRecvFrom(), WSPSend(), WSPSendTo(), or WSPIoctl(). lpOverlapped - Points to a WSAOVERLAPPED structure that was specified when the overlapped operation was started. lpcbTransfer - Points to a 32-bit variable that receives the number of bytes that were actually transferred by a send or receive operation, or by WSPIoctl(). fWait - Specifies whether the function should wait for the pending overlapped operation to complete. If TRUE, the function does not return until the operation has been completed. If FALSE and the operation is still pending, the function returns FALSE and lperrno is WSA_IO_INCOMPLETE. lpdwFlags - Points to a 32-bit variable that will receive one or more flags that supplement the completion status. If the overlapped operation was initiated via WSPRecv() or WSPRecvFrom(), this parameter will contain the results value for lpFlags parameter. lpErrno - A pointer to the error code. Return Value: If WSPGetOverlappedResult() succeeds,the return value is TRUE. This means that the overlapped operation has completed successfully and that the value pointed to by lpcbTransfer has been updated. If WSPGetOverlappedResult() returns FALSE, this means that either the overlapped operation has not completed or the overlapped operation completed but with errors, or that completion status could not be determined due to errors in one or more parameters to WSPGetOverlappedResult(). On failure, the value pointed to by lpcbTransfer will not be updated. lpErrno indicates the cause of the failure (either of WSPGetOverlappedResult() or of the associated overlapped operation). --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPGetOverlappedResult, &ReturnValue, m_lib_name, &s, &lpOverlapped, &lpcbTransfer, &fWait, &lpdwFlags, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPGetOverlappedResult( s, lpOverlapped, lpcbTransfer, fWait, lpdwFlags, lpErrno); POSTAPINOTIFY(( DTCODE_WSPGetOverlappedResult, &ReturnValue, m_lib_name, &s, &lpOverlapped, &lpcbTransfer, &fWait, &lpdwFlags, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPGetPeerName( IN SOCKET s, OUT struct sockaddr FAR *name, OUT INT FAR *namelen, OUT INT FAR *lpErrno ) /*++ Routine Description: Get the address of the peer to which a socket is connected. Arguments: s - A descriptor identifying a connected socket. name - A pointer to the structure which is to receive the name of the peer. namelen - A pointer to an integer which, on input, indicates the size of the structure pointed to by name, and on output indicates the size of the returned name. lpErrno - A pointer to the error code. Return Value: If no error occurs, WSPGetPeerName() returns ERROR_SUCCESS. Otherwise, a value of SOCKET_ERROR is returned, and a specific error code is available in lpErrno --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPGetPeerName, &ReturnValue, m_lib_name, &s, &name, &namelen, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPGetPeerName( s, name, namelen, lpErrno); POSTAPINOTIFY(( DTCODE_WSPGetPeerName, &ReturnValue, m_lib_name, &s, &name, &namelen, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPGetQOSByName( IN SOCKET s, IN LPWSABUF lpQOSName, IN LPQOS lpQOS, OUT INT FAR *lpErrno ) /*++ Routine Description: Initializes a QOS structure based on a named template. Arguments: s - A descriptor identifying a socket. lpQOSName - Specifies the QOS template name. lpQOS - A pointer to the QOS structure to be filled. lpErrno - A pointer to the error code. Return Value: If the function succeeds, the return value is TRUE. If the function fails, the return value is FALSE, and a specific error code is available in lpErrno. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPGetQOSByName, &ReturnValue, m_lib_name, &s, &lpQOSName, &lpQOS, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPGetQOSByName( s, lpQOSName, lpQOS, lpErrno); POSTAPINOTIFY(( DTCODE_WSPGetQOSByName, &ReturnValue, m_lib_name, &s, &lpQOSName, &lpQOS, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPGetSockName( IN SOCKET s, OUT struct sockaddr FAR *name, OUT INT FAR *namelen, OUT INT FAR *lpErrno ) /*++ Routine Description: Get the local name for a socket. Arguments: s - A descriptor identifying a bound socket. name - A pointer to a structure used to supply the address (name) of the socket. namelen - A pointer to an integer which, on input, indicates the size of the structure pointed to by name, and on output indicates the size of the returned name lpErrno - A Pointer to the error code. Return Value: If no error occurs, WSPGetSockName() returns ERROR_SUCCESS. Otherwise, a value of SOCKET_ERROR is returned, and a specific error code is available in lpErrno. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPGetSockName, &ReturnValue, m_lib_name, &s, &name, &namelen, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPGetSockName( s, name, namelen, lpErrno); POSTAPINOTIFY(( DTCODE_WSPGetSockName, &ReturnValue, m_lib_name, &s, &name, &namelen, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPGetSockOpt( IN SOCKET s, IN INT level, IN INT optname, OUT char FAR *optval, OUT INT FAR *optlen, OUT INT FAR *lpErrno ) /*++ Routine Description: Retrieve a socket option. Arguments: s - A descriptor identifying a socket. level - The level at which the option is defined; the supported levels include SOL_SOCKET (See annex for more protocol-specific levels.) optname - The socket option for which the value is to be retrieved. optval - A pointer to the buffer in which the value for the requested option is to be returned. optlen - A pointer to the size of the optval buffer. lpErrno - A pointer to the error code. Return Value: If no error occurs, WSPGetSockOpt() returns 0. Otherwise, a value of SOCKET_ERROR is returned, and a specific error code is available in lpErrno. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPGetSockOpt, &ReturnValue, m_lib_name, &s, &level, &optname, &optval, &optlen, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPGetSockOpt( s, level, optname, optval, optlen, lpErrno); POSTAPINOTIFY(( DTCODE_WSPGetSockOpt, &ReturnValue, m_lib_name, &s, &level, &optname, &optval, &optlen, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPIoctl( IN SOCKET s, IN DWORD dwIoControlCode, IN LPVOID lpvInBuffer, IN DWORD cbInBuffer, IN LPVOID lpvOutBuffer, IN DWORD cbOutBuffer, IN LPDWORD lpcbBytesReturned, IN LPWSAOVERLAPPED lpOverlapped, IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, IN LPWSATHREADID lpThreadId, OUT INT FAR *lpErrno ) /*++ Routine Description: Control the mode of a socket. Arguments: s - Handle to a socket dwIoControlCode - Control code of operation to perform lpvInBuffer - Address of input buffer cbInBuffer - Size of input buffer lpvOutBuffer - Address of output buffer cbOutBuffer - Size of output buffer lpcbBytesReturned - A pointer to the size of output buffer's contents. lpOverlapped - Address of WSAOVERLAPPED structure lpCompletionRoutine - A pointer to the completion routine called when the operation has been completed. lpThreadId - A pointer to a thread ID structure to be used by the provider lpErrno - A pointer to the error code. Return Value: If no error occurs and the operation has completed immediately, WSPIoctl() returns 0. Note that in this case the completion routine, if specified, will have already been queued. Otherwise, a value of SOCKET_ERROR is returned, and a specific error code is available in lpErrno. The error code WSA_IO_PENDING indicates that an overlapped operation has been successfully initiated and that conpletion will be indicated at a later time. Any other error code indicates that no overlapped operation was initiated and no completion indication will occur. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPIoctl, &ReturnValue, m_lib_name, &s, &dwIoControlCode, &lpvInBuffer, &cbInBuffer, &lpvOutBuffer, &cbOutBuffer, &lpcbBytesReturned, &lpOverlapped, &lpCompletionRoutine, &lpThreadId, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPIoctl( s, dwIoControlCode, lpvInBuffer, cbInBuffer, lpvOutBuffer, cbOutBuffer, lpcbBytesReturned, lpOverlapped, lpCompletionRoutine, lpThreadId, lpErrno); POSTAPINOTIFY(( DTCODE_WSPIoctl, &ReturnValue, m_lib_name, &s, &dwIoControlCode, &lpvInBuffer, &cbInBuffer, &lpvOutBuffer, &cbOutBuffer, &lpcbBytesReturned, &lpOverlapped, &lpCompletionRoutine, &lpThreadId, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline SOCKET DPROVIDER::WSPJoinLeaf( IN SOCKET s, IN const struct sockaddr FAR *name, IN INT namelen, IN LPWSABUF lpCallerData, IN LPWSABUF lpCalleeData, IN LPQOS lpSQOS, IN LPQOS lpGQOS, IN DWORD dwFlags, OUT INT FAR *lpErrno ) /*++ Routine Description: Join a leaf node into a multipoint session, exchange connect data, and specify needed quality of service based on the supplied flow specs. Arguments: s - A descriptor identifying a multipoint socket. name - The name of the peer to which the socket is to be joined. namelen - The length of the name. lpCallerData - A pointer to the user data that is to be transferred to the peer during multipoint session establishment. lpCalleeData - A pointer to the user data that is to be transferred back from the peer during multipoint session establishment. lpSQOS - A pointer to the flow specs for socket s, one for each direction. lpGQOS - A pointer to the flow specs for the socket group (if applicable). dwFlags - Flags to indicate that the socket is acting as a sender, receiver, or both. lpErrno - A pointer to the error code. Return Value: If no error occurs, WSPJoinLeaf() returns a value of type SOCKET which is a descriptor for the newly created multipoint socket. Otherwise,a value of INVALID_SOCKET is returned, and a specific error code is available in lpErrno. --*/ { SOCKET ReturnValue=INVALID_SOCKET; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPJoinLeaf, &ReturnValue, m_lib_name, &s, &name, &namelen, &lpCallerData, &lpCalleeData, &lpSQOS, &lpGQOS, &dwFlags, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPJoinLeaf( s, name, namelen, lpCallerData, lpCalleeData, lpSQOS, lpGQOS, dwFlags, lpErrno); POSTAPINOTIFY(( DTCODE_WSPJoinLeaf, &ReturnValue, m_lib_name, &s, &name, &namelen, &lpCallerData, &lpCalleeData, &lpSQOS, &lpGQOS, &dwFlags, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPListen( IN SOCKET s, IN INT backlog, OUT INT FAR *lpErrno ) /*++ Routine Description: Establish a socket to listen for incoming connections. Arguments: s - A descriptor identifying a bound, unconnected socket. backlog - The maximum length to which the queue of pending connections may grow. If this value is SOMAXCONN, then the service provider should set the backlog to a maximum "reasonable" value. lpErrno - A pointer to the error code. Return Value: If no error occurs, WSPListen() returns 0. Otherwise, a value of SOCKET_ERROR is returned, and a specific error code is available in lpErrno. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPListen, &ReturnValue, m_lib_name, &s, &backlog, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPListen( s, backlog, lpErrno); POSTAPINOTIFY(( DTCODE_WSPListen, &ReturnValue, m_lib_name, &s, &backlog, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPRecv( IN SOCKET s, IN LPWSABUF lpBuffers, IN DWORD dwBufferCount, IN LPDWORD lpNumberOfBytesRecvd, IN OUT LPDWORD lpFlags, IN LPWSAOVERLAPPED lpOverlapped, IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, IN LPWSATHREADID lpThreadId, OUT INT FAR *lpErrno ) /*++ Routine Description: Receive data on a socket. Arguments: s - A descriptor identifying a connected socket. lpBuffers - A pointer to an array of WSABUF structures. Each WSABUF structure contains a pointer to a buffer and the length of the buffer. dwBufferCount - The number of WSABUF structures in the lpBuffers array. lpNumberOfBytesRecvd - A pointer to the number of bytes received by this call. lpFlags - A pointer to flags. lpOverlapped - A pointer to a WSAOVERLAPPED structure. lpCompletionRoutine - A pointer to the completion routine called when the receive operation has been completed. lpThreadId - A pointer to a thread ID structure to be used by the provider in a subsequent call to WPUQueueApc(). lpErrno - A pointer to the error code. Return Value: If no error occurs and the receive operation has completed immediately, WSPRecv() returns the number of bytes received. If the connection has been closed, it returns 0. Note that in this case the completion routine, if specified, will have already been queued. Otherwise, a value of SOCKET_ERROR is returned, and a specific error code is available in lpErrno. The error code WSA_IO_PENDING indicates that the overlapped an operation has been successfully initiated and that completion will be indicated at a later time. Any other error code indicates that no overlapped operations was initiated and no completion indication will occur. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPRecv, &ReturnValue, m_lib_name, &s, &lpBuffers, &dwBufferCount, &lpNumberOfBytesRecvd, &lpFlags, &lpOverlapped, &lpCompletionRoutine, &lpThreadId, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPRecv( s, lpBuffers, dwBufferCount, lpNumberOfBytesRecvd, lpFlags, lpOverlapped, lpCompletionRoutine, lpThreadId, lpErrno); POSTAPINOTIFY(( DTCODE_WSPRecv, &ReturnValue, m_lib_name, &s, &lpBuffers, &dwBufferCount, &lpNumberOfBytesRecvd, &lpFlags, &lpOverlapped, &lpCompletionRoutine, &lpThreadId, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPRecvDisconnect( IN SOCKET s, IN LPWSABUF lpInboundDisconnectData, OUT INT FAR *lpErrno ) /*++ Routine Description: Terminate reception on a socket, and retrieve the disconnect data if the socket is connection-oriented. Arguments: s - A descriptor identifying a socket. lpInboundDisconnectData - A pointer to a buffer into which disconnect data is to be copied. lpErrno - A pointer to the error code. Return Value: If no error occurs, WSPRecvDisconnect() returns ERROR_SUCCESS. Otherwise, a value of SOCKET_ERROR is returned, and a specific error code is available in lpErrno. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPRecvDisconnect, &ReturnValue, m_lib_name, &s, &lpInboundDisconnectData, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPRecvDisconnect( s, lpInboundDisconnectData, lpErrno); POSTAPINOTIFY(( DTCODE_WSPRecvDisconnect, &ReturnValue, m_lib_name, &s, &lpInboundDisconnectData, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPRecvFrom( IN SOCKET s, IN LPWSABUF lpBuffers, IN DWORD dwBufferCount, IN LPDWORD lpNumberOfBytesRecvd, IN OUT LPDWORD lpFlags, OUT struct sockaddr FAR * lpFrom, IN LPINT lpFromlen, IN LPWSAOVERLAPPED lpOverlapped, IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, IN LPWSATHREADID lpThreadId, OUT INT FAR *lpErrno ) /*++ Routine Description: Receive a datagram and store the source address. Arguments: s - A descriptor identifying a socket. lpBuffers - A pointer to an array of WSABUF structures. Each WSABUF structure contains a pointer to a buffer and the length of the buffer. dwBufferCount - The number of WSABUF structures in the lpBuffers array. lpNumberOfBytesRecvd - A pointer to the number of bytes received by this call. lpFlags - A pointer to flags. lpFrom - An optional pointer to a buffer which will hold the source address upon the completion of the overlapped operation. lpFromlen - A pointer to the size of the from buffer, required only if lpFrom is specified. lpOverlapped - A pointer to a WSAOVERLAPPED structure. CompletionRoutine - A pointer to the completion routine called when the receive operation has been completed. lpThreadId - A pointer to a thread ID structure to be used by the provider in a subsequent call to WPUQueueApc(). lpErrno - A pointer to the error code. Return Value: If no error occurs and the receive operation has completed immediately, WSPRecvFrom() returns the number of bytes received. If the connection has been closed, it returns 0. Note that in this case the completion routine, if specified will have already been queued. Otherwise, a value of SOCKET_ERROR is returned, and a specific error code is available in lpErrno. The error code WSA_IO_PENDING indicates that the overlapped operation has been successfully initiated and that completion will be indicated at a later time. Any other error code indicates that no overlapped operations was initiated and no completion indication will occur. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPRecvFrom, &ReturnValue, m_lib_name, &s, &lpBuffers, &dwBufferCount, &lpNumberOfBytesRecvd, &lpFlags, &lpFrom, &lpFromlen, &lpOverlapped, &lpCompletionRoutine, &lpThreadId, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPRecvFrom( s, lpBuffers, dwBufferCount, lpNumberOfBytesRecvd, lpFlags, lpFrom, lpFromlen, lpOverlapped, lpCompletionRoutine, lpThreadId, lpErrno); POSTAPINOTIFY(( DTCODE_WSPRecvFrom, &ReturnValue, m_lib_name, &s, &lpBuffers, &dwBufferCount, &lpNumberOfBytesRecvd, &lpFlags, &lpFrom, &lpFromlen, &lpOverlapped, &lpCompletionRoutine, &lpThreadId, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPSelect( IN INT nfds, IN OUT fd_set FAR *readfds, IN OUT fd_set FAR *writefds, IN OUT fd_set FAR *exceptfds, IN const struct timeval FAR *timeout, OUT INT FAR *lpErrno ) /*++ Routine Description: Determine the status of one or more sockets. Arguments: nfds - This argument is ignored and included only for the sake of compatibility. readfds - An optional pointer to a set of sockets to be checked for readability. writefds - An optional pointer to a set of sockets to be checked for writability exceptfds - An optional pointer to a set of sockets to be checked for errors. timeout - The maximum time for WSPSelect() to wait, or NULL for a blocking operation. lpErrno - A pointer to the error code. Return Value: WSPSelect() returns the total number of descriptors which are ready and contained in the fd_set structures, 0 if the time limit expired, or SOCKET_ERROR if an error occurred. If the return value is SOCKET_ERROR, a specific error code is available in lpErrno. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPSelect, &ReturnValue, m_lib_name, &nfds, &readfds, &writefds, &exceptfds, &timeout, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPSelect( nfds, readfds, writefds, exceptfds, timeout, lpErrno); POSTAPINOTIFY(( DTCODE_WSPSelect, &ReturnValue, m_lib_name, &nfds, &readfds, &writefds, &exceptfds, &timeout, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPSend( IN SOCKET s, IN LPWSABUF lpBuffers, IN DWORD dwBufferCount, IN LPDWORD lpNumberOfBytesSent, IN DWORD dwFlags, IN LPWSAOVERLAPPED lpOverlapped, IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, IN LPWSATHREADID lpThreadId, OUT INT FAR *lpErrno ) /*++ Routine Description: Send data on a connected socket. Arguments: s - A descriptor identifying a connected socket. lpBuffers - A pointer to an array of WSABUF structures. Each WSABUF structure contains a pointer to a buffer and the length of the buffer. dwBufferCount - The number of WSABUF structures in the lpBuffers array. lpNumberOfBytesSent - A pointer to the number of bytes sent by this call. dwFlags - Flags. lpOverlapped - A pointer to a WSAOVERLAPPED structure. lpCompletionRoutine - A pointer to the completion routine called when the send operation has been completed. lpThreadId - A pointer to a thread ID structure to be used by the provider in a subsequent call to WPUQueueApc(). lpErrno - A pointer to the error code. Return Value: If no error occurs and the send operation has completed immediately, WSPSend() returns the number of bytes received. If the connection has been closed, it returns 0. Note that in this case the completion routine, if specified, will have already been queued. Otherwise, a value of SOCKET_ERROR is returned, and a specific error code is available in lpErrno. The error code WSA_IO_PENDING indicates that the overlapped operation has been successfully initiated and that completion will be indicated at a later time. Any other error code indicates that no overlapped operation was initiated and no completion indication will occur. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPSend, &ReturnValue, m_lib_name, &s, &lpBuffers, &dwBufferCount, &lpNumberOfBytesSent, &dwFlags, &lpOverlapped, &lpCompletionRoutine, &lpThreadId, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPSend( s, lpBuffers, dwBufferCount, lpNumberOfBytesSent, dwFlags, lpOverlapped, lpCompletionRoutine, lpThreadId, lpErrno); POSTAPINOTIFY(( DTCODE_WSPSend, &ReturnValue, m_lib_name, &s, &lpBuffers, &dwBufferCount, &lpNumberOfBytesSent, &dwFlags, &lpOverlapped, &lpCompletionRoutine, &lpThreadId, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPSendDisconnect( IN SOCKET s, IN LPWSABUF lpOutboundDisconnectData, OUT INT FAR *lpErrno ) /*++ Routine Description: Initiate termination of the connection for the socket and send disconnect data. Arguments: s - A descriptor identifying a socket. lpOutboundDisconnectData - A pointer to the outgoing disconnect data. lpErrno - A pointer to the error code. Return Value: If no error occurs, WSPSendDisconnect() returns 0. Otherwise, a value of SOCKET_ERROR is returned, and a specific error code is available in lpErrno. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPSendDisconnect, &ReturnValue, m_lib_name, &s, &lpOutboundDisconnectData, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPSendDisconnect( s, lpOutboundDisconnectData, lpErrno); POSTAPINOTIFY(( DTCODE_WSPSendDisconnect, &ReturnValue, m_lib_name, &s, &lpOutboundDisconnectData, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPSendTo( IN SOCKET s, IN LPWSABUF lpBuffers, IN DWORD dwBufferCount, IN LPDWORD lpNumberOfBytesSent, IN DWORD dwFlags, IN const struct sockaddr FAR * lpTo, IN INT iTolen, IN LPWSAOVERLAPPED lpOverlapped, IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, IN LPWSATHREADID lpThreadId, OUT INT FAR *lpErrno ) /*++ Routine Description: Send data to a specific destination using overlapped I/O. Arguments: s - A descriptor identifying a socket. lpBuffers - A pointer to an array of WSABUF structures. Each WSABUF structure contains a pointer to a buffer and the length of the buffer. dwBufferCount - The number of WSABUF structures in the lpBuffers array. lpNumberOfBytesSent - A pointer to the number of bytes sent by this call. dwFlags - Flags. lpTo - An optional pointer to the address of the target socket. iTolen - The size of the address in lpTo. lpOverlapped - A pointer to a WSAOVERLAPPED structure. lpCompletionRoutine - A pointer to the completion routine called when the send operation has been completed. lpThreadId - A pointer to a thread ID structure to be used by the provider in a subsequent call to WPUQueueApc(). lpErrno - A pointer to the error code. Return Value: If no error occurs and the receive operation has completed immediately, WSPSendTo() returns the number of bytes received. If the connection has been closed,it returns 0. Note that in this case the completion routine, if specified, will have already been queued. Otherwise, a value of SOCKET_ERROR is returned, and a specific error code is available in lpErrno. The error code WSA_IO_PENDING indicates that the overlapped operation has been successfully initiated and that completion will be indicated at a later time. Any other error code indicates that no overlapped operation was initiated and no completion indication will occur. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPSendTo, &ReturnValue, m_lib_name, &s, &lpBuffers, &dwBufferCount, &lpNumberOfBytesSent, &dwFlags, &lpTo, &iTolen, &lpOverlapped, &lpCompletionRoutine, &lpThreadId, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPSendTo( s, lpBuffers, dwBufferCount, lpNumberOfBytesSent, dwFlags, lpTo, iTolen, lpOverlapped, lpCompletionRoutine, lpThreadId, lpErrno); POSTAPINOTIFY(( DTCODE_WSPSendTo, &ReturnValue, m_lib_name, &s, &lpBuffers, &dwBufferCount, &lpNumberOfBytesSent, &dwFlags, &lpTo, &iTolen, &lpOverlapped, &lpCompletionRoutine, &lpThreadId, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPSetSockOpt( IN SOCKET s, IN INT level, IN INT optname, IN const char FAR *optval, IN INT optlen, OUT INT FAR *lpErrno ) /*++ Routine Description: Set a socket option. Arguments: s - A descriptor identifying a socket. level - The level at which the option is defined; the supported levels include SOL_SOCKET. (See annex for more protocol-specific levels.) optname - The socket option for which the value is to be set. optval - A pointer to the buffer in which the value for the requested option is supplied. optlen - The size of the optval buffer. lpErrno - A pointer to the error code. Return Value: If no error occurs, WSPSetSockOpt() returns 0. Otherwise, a value of SOCKET_ERROR is returned, and a specific error code is available in lpErrno. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPSetSockOpt, &ReturnValue, m_lib_name, &s, &level, &optname, &optval, &optlen, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPSetSockOpt( s, level, optname, optval, optlen, lpErrno); POSTAPINOTIFY(( DTCODE_WSPSetSockOpt, &ReturnValue, m_lib_name, &s, &level, &optname, &optval, &optlen, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPShutdown( IN SOCKET s, IN INT how, OUT INT FAR *lpErrno ) /*++ Routine Description: Disable sends and/or receives on a socket. Arguments: s - A descriptor identifying a socket. how - A flag that describes what types of operation will no longer be allowed. lpErrno - A pointer to the error code. Return Value: If no error occurs, WSPShutdown() returns 0. Otherwise, a value of SOCKET_ERROR is returned, and a specific error code is available in lpErrno. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPShutdown, &ReturnValue, m_lib_name, &s, &how, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPShutdown( s, how, lpErrno); POSTAPINOTIFY(( DTCODE_WSPShutdown, &ReturnValue, m_lib_name, &s, &how, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline SOCKET DPROVIDER::WSPSocket( IN int af, IN int type, IN int protocol, IN LPWSAPROTOCOL_INFOW lpProtocolInfo, IN GROUP g, IN DWORD dwFlags, OUT INT FAR *lpErrno ) /*++ Routine Description: Initialize internal data and prepare sockets for usage. Must be called before any other socket routine. Arguments: lpProtocolInfo - Supplies a pointer to a WSAPROTOCOL_INFOW struct that defines the characteristics of the socket to be created. g - Supplies the identifier of the socket group which the new socket is to join. dwFlags - Supplies the socket attribute specification. lpErrno - Returns the error code Return Value: WSPSocket() returns zero if successful. Otherwise it returns an error code as outlined in the SPI. --*/ { SOCKET ReturnValue=INVALID_SOCKET; assert (m_reference_count>0); // Debug/Trace stuff if (PREAPINOTIFY(( DTCODE_WSPSocket, &ReturnValue, m_lib_name, &af, &type, &protocol, &lpProtocolInfo, &g, &dwFlags, &lpErrno)) ) { return(ReturnValue); } // Actual code... ReturnValue = m_proctable.lpWSPSocket( af, type, protocol, lpProtocolInfo, g, dwFlags, lpErrno); // Debug/Trace stuff POSTAPINOTIFY(( DTCODE_WSPSocket, &ReturnValue, m_lib_name, &af, &type, &protocol, &lpProtocolInfo, &g, &dwFlags, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } inline INT DPROVIDER::WSPStringToAddress( IN LPWSTR AddressString, IN INT AddressFamily, IN LPWSAPROTOCOL_INFOW lpProtocolInfo, OUT LPSOCKADDR lpAddress, IN OUT LPINT lpAddressLength, IN OUT LPINT lpErrno ) /*++ Routine Description: WSPStringToAddress() converts a human-readable string to a socket address structure (SOCKADDR) suitable for pass to Windows Sockets routines which take such a structure. If the caller wishes the translation to be done by a particular provider, it should supply the corresponding WSAPROTOCOL_INFOW struct in the lpProtocolInfo parameter. Arguments: AddressString - points to the zero-terminated human-readable string to convert. AddressFamily - the address family to which the string belongs. lpProtocolInfo - (optional) the WSAPROTOCOL_INFOW struct for a particular provider. Address - a buffer which is filled with a single SOCKADDR structure. lpAddressLength - The length of the Address buffer. Returns the size of the resultant SOCKADDR structure. Return Value: The return value is 0 if the operation was successful. Otherwise the value SOCKET_ERROR is returned. --*/ { INT ReturnValue=SOCKET_ERROR; assert (m_reference_count>0); if (PREAPINOTIFY(( DTCODE_WSPStringToAddress, &ReturnValue, m_lib_name, &AddressString, &AddressFamily, &lpProtocolInfo, &lpAddress, &lpAddressLength, &lpErrno)) ) { return(ReturnValue); } ReturnValue = m_proctable.lpWSPStringToAddress( AddressString, AddressFamily, lpProtocolInfo, lpAddress, lpAddressLength, lpErrno); POSTAPINOTIFY(( DTCODE_WSPStringToAddress, &ReturnValue, m_lib_name, &AddressString, &AddressFamily, &lpProtocolInfo, &lpAddress, &lpAddressLength, &lpErrno)); assert (m_reference_count>0); return(ReturnValue); } #endif