|
|
/*++
Copyright (c) 1998 Microsoft Corporation
Module Name:
emaccept.cpp
Abstract:
Contains all the event manager routines which manage the overlapped accept operations.
Environment:
User Mode - Win32
History:
1. created Ajay Chitturi (ajaych) 12-Jun-1998
--*/
///////////////////////////////////////////////////////////////////////////////
// //
// Include files //
// //
///////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
///////////////////////////////////////////////////////////////////////////////
// //
// Constants //
// //
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// //
// Global Variables //
// //
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// //
// Externally defined identifiers //
// //
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// //
// Overlapped accept functions //
// //
///////////////////////////////////////////////////////////////////////////////
HRESULT EventMgrCreateAcceptContext( IN OVERLAPPED_PROCESSOR *pOvProcessor, IN OUT struct sockaddr_in *pBindAddress, OUT PAcceptContext *ppAcceptCtxt )/*++
Routine Description:
This function creates a socket, binds it to bindAddress and issues a listen. It creates the Accept I/O Context and returns it to the caller.
Arguments:
pOvProcessor - pointer to the overlapped processor object. Once the accept completes the callback of this object is called.
pBindAddress - pointer to the address to listen on.
ppAcceptCtxt - A new Accept I/O context is allocated initialized and returned through this OUT parameter.
Return Values:
Returns S_OK on success, E_OUTOFMEMORY if the memory allocator fails or E_FAIL if any of the Winsock functions fail.
--*/
{ SOCKET listenSock; int Error; HRESULT Result; BOOL KeepaliveOption; PAcceptContext pAcceptCtxt; *ppAcceptCtxt = NULL;
// Create an overlapped socket
listenSock = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
if (listenSock == INVALID_SOCKET) { Error = WSAGetLastError (); DebugF(_T("H323: 0x%x error creating listener socket error: %d pOvProcessor: %p.\n"), &pOvProcessor -> GetCallBridge (), Error, pOvProcessor); return HRESULT_FROM_WIN32 (Error); }
//
// Set RCV and SND buffers to zero
// Yes, it is ugly and bad practice but this is a QFE
// for details look up bug# WinSE 31054, 691666 (read both 35928 and 33546).
//
ULONG Option = 0; setsockopt( listenSock, SOL_SOCKET, SO_SNDBUF, (PCHAR)&Option, sizeof(Option) ); Option = 0; setsockopt( listenSock, SOL_SOCKET, SO_SNDBUF, (PCHAR)&Option, sizeof(Option) );
// Bind the socket to the listen address
if (bind(listenSock, (struct sockaddr *)pBindAddress, sizeof(struct sockaddr_in)) == SOCKET_ERROR) { Error = WSAGetLastError (); DebugF (_T("H323: 0x%x bind() failed error: %d.\n"), &pOvProcessor -> GetCallBridge (), Error); closesocket(listenSock); listenSock = INVALID_SOCKET; return HRESULT_FROM_WIN32 (Error); }
// Set keepalive on the socket
KeepaliveOption = TRUE; if (SOCKET_ERROR == setsockopt(listenSock, SOL_SOCKET, SO_KEEPALIVE, (PCHAR) &KeepaliveOption, sizeof (KeepaliveOption))) { Error = WSAGetLastError (); DebugF (_T("H323: 0x%x failed to set keepalive on listen socket. Error %d.\n"), &pOvProcessor -> GetCallBridge (), Error); closesocket(listenSock); listenSock = INVALID_SOCKET; return HRESULT_FROM_WIN32 (Error); }
// Bind the socket handle to the I/O completion port
if (EventMgrBindIoHandle(listenSock) != S_OK) { DebugF (_T("H323: 0x%x binding socket:%d to IOCP failed.\n"), &pOvProcessor -> GetCallBridge (), listenSock); closesocket(listenSock); listenSock = INVALID_SOCKET; return E_FAIL; }
if (listen(listenSock, MAX_LISTEN_BACKLOG) == SOCKET_ERROR) { Error = WSAGetLastError (); DebugF (_T("H323: 0x%x listen() failed: 0x%x pOvProcessor; %p.\n"), &pOvProcessor -> GetCallBridge (), Error, pOvProcessor); closesocket(listenSock); listenSock = INVALID_SOCKET; return HRESULT_FROM_WIN32 (Error); } // Allocate memory from a private heap for accept contexts
pAcceptCtxt = (PAcceptContext) HeapAlloc (GetProcessHeap (), 0, // No Flags
sizeof(AcceptContext)); if (!pAcceptCtxt) { DebugF (_T("H323: 0x%x could not allocate Accept context.\n"), &pOvProcessor -> GetCallBridge ()); closesocket(listenSock); listenSock = INVALID_SOCKET;
return E_OUTOFMEMORY; }
memset(pAcceptCtxt, 0, sizeof(AcceptContext)); pAcceptCtxt->ioCtxt.reqType = EMGR_OV_IO_REQ_ACCEPT; pAcceptCtxt->ioCtxt.pOvProcessor = pOvProcessor; pAcceptCtxt->listenSock = listenSock; pAcceptCtxt->acceptSock = INVALID_SOCKET; *ppAcceptCtxt = pAcceptCtxt; return S_OK;} // EventMgrCreateAcceptContext
voidEventMgrFreeAcceptContext ( PAcceptContext pAcceptCtxt )/*++
Routine Description:
This function frees the pAcceptCtxt. OvProcessor is owned by the Call Bridge Machine and so we do not free it.
Arguments:
pAcceptCtxt - pointer to the AcceptCtxt to be freed.
Return Values:
This function has not return value.
--*/
{ if (pAcceptCtxt->acceptSock != INVALID_SOCKET) { closesocket(pAcceptCtxt->acceptSock); pAcceptCtxt -> acceptSock = INVALID_SOCKET; }
HeapFree (GetProcessHeap (), 0, // no flags
pAcceptCtxt);} // EventMgrFreeAcceptContext
HRESULTEventMgrIssueAcceptHelperFn( PAcceptContext pAcceptCtxt )/*++
Routine Description:
This function issues an Asynchronous overlapped accept using AcceptEx(). The accept socket is created and stored in the Accept context before making the call to AcceptEx().
In case of an error, the caller needs to free pAcceptCtxt.
Arguments:
pAcceptCtxt - pointer to the Accept I/O context.
Return Values:
This function returns S_OK in case of success or E_FAIL in case of an error. CODEWORK: Need to convert Winsock errors to HRESULT and return them instead.
--*/
{ SOCKET acceptSock; DWORD lastError, bytesRead; HRESULT Result; BOOL KeepaliveOption;
_ASSERTE(pAcceptCtxt);
// create an overlapped socket
acceptSock = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
if (acceptSock == INVALID_SOCKET) { DebugF (_T("H323: 0x%x error creating accept socket: %d.\n"), &pAcceptCtxt -> ioCtxt.pOvProcessor -> GetCallBridge (), WSAGetLastError()); return E_FAIL; }
//
// Set RCV and SND buffers to zero
// Yes, it is ugly and bad practice but this is a QFE
// for details look up bug# WinSE 31054, regular 691666 (read both 35928 and 33546).
//
ULONG Option = 0; setsockopt( acceptSock, SOL_SOCKET, SO_SNDBUF, (PCHAR)&Option, sizeof(Option) ); Option = 0; setsockopt( acceptSock, SOL_SOCKET, SO_SNDBUF, (PCHAR)&Option, sizeof(Option) );
pAcceptCtxt->acceptSock = acceptSock;
// Bind the socket handle to the I/O completion port
if (EventMgrBindIoHandle(acceptSock) != S_OK) { DebugF (_T("H323: 0x%x binding socket:%d to IOCP failed.\n"), &pAcceptCtxt -> ioCtxt.pOvProcessor -> GetCallBridge (), acceptSock); return E_FAIL; }
memset(&pAcceptCtxt->ioCtxt.ov, 0, sizeof(OVERLAPPED));
// Set keepalive on the socket
KeepaliveOption = TRUE; if (SOCKET_ERROR == setsockopt (acceptSock, SOL_SOCKET, SO_KEEPALIVE, (PCHAR) &KeepaliveOption, sizeof (KeepaliveOption))) { DebugF (_T("H323: 0x%x failed to set keepalive on accept socket. Error %d.\n"), &pAcceptCtxt -> ioCtxt.pOvProcessor -> GetCallBridge (), WSAGetLastError()); return E_FAIL; }
pAcceptCtxt->ioCtxt.pOvProcessor->GetCallBridge().AddRef(); // Issue overlapped accept
if (!AcceptEx(pAcceptCtxt->listenSock, acceptSock, pAcceptCtxt->addrBuf, 0, // Read nothing from socket
sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16, &bytesRead, &pAcceptCtxt->ioCtxt.ov)) { lastError = WSAGetLastError(); if (lastError != ERROR_IO_PENDING) { pAcceptCtxt->ioCtxt.pOvProcessor->GetCallBridge().Release(); // This means the overlapped AcceptEx() failed
DebugF(_T("H323: 0x%x AcceptEx() failed error: %d listenSock: %d acceptSock: %d.\n"), &pAcceptCtxt -> ioCtxt.pOvProcessor -> GetCallBridge (), lastError, pAcceptCtxt->listenSock, pAcceptCtxt->acceptSock); return E_FAIL; } }
return S_OK;}
HRESULTEventMgrIssueAccept( IN DWORD bindIPAddress, IN OVERLAPPED_PROCESSOR &rOvProcessor, OUT WORD& rBindPort, OUT SOCKET& rListenSock )/*++
Routine Description:
This function is exported to the Call Bridge machine for making an asynchronous accept request for H.245 connections. Once the accept is completed, the accept callback function on rOvProcessor is called. This function calls bind() with on IP address "bindIPAddress" and port 0. Winsock allocates a free port which is got using getsockname(). This port is returned using the OUT param rBindPort.
This function also returns the listen socket using the OUT param rListenSock. The Call Bridge machine can use this socket to cancel the asynchronous Accept() request. Once this function succeeds only the Call bridge frees the listen socket.
Arguments:
bindIPAddress - This is the IP address to listen on. This is in host byte order.
rOvProcessor - A reference to the Overlapped processor. This is stored in the Accept I/O context. Once the accept completes the AcceptCallback() on this object is called.
rBindPort - The port on which the listen is issued is returned through this OUT param. This function calls bind() with on IP address "bindIPAddress" and port 0. Winsock allocates a free port which is got using getsockname(). This port is returned using the OUT param rBindPort. The port returned is in host byte order.
rListenSock - The listening socket is returned through this OUT param. The Call Bridge machine can use this socket to cancel the asynchronous Accept() request. Once this function succeeds only the Call bridge frees the listen socket.
Return Values:
This function returns S_OK in case of success or E_FAIL in case of a failure.
--*/
{ PAcceptContext pAcceptCtxt; struct sockaddr_in bindAddress; HRESULT hRes; int bindAddressLen = sizeof(struct sockaddr_in);
memset(&bindAddress, 0, sizeof(bindAddress));
bindAddress.sin_family = AF_INET; bindAddress.sin_addr.s_addr = htonl(bindIPAddress); bindAddress.sin_port = htons(0); hRes = EventMgrCreateAcceptContext(&rOvProcessor, &bindAddress, &pAcceptCtxt); if (hRes != S_OK) return hRes;
if (!pAcceptCtxt) return E_FAIL;
// Get the port
if (getsockname(pAcceptCtxt->listenSock, (struct sockaddr *)&bindAddress, &bindAddressLen)) { closesocket(pAcceptCtxt->listenSock); pAcceptCtxt->listenSock = INVALID_SOCKET;
EventMgrFreeAcceptContext(pAcceptCtxt); return E_FAIL; }
rBindPort = ntohs(bindAddress.sin_port);
hRes = EventMgrIssueAcceptHelperFn(pAcceptCtxt);
if (hRes != S_OK) { closesocket(pAcceptCtxt->listenSock); pAcceptCtxt->listenSock = INVALID_SOCKET;
EventMgrFreeAcceptContext(pAcceptCtxt); return hRes; }
rListenSock = pAcceptCtxt->listenSock; return S_OK;} // EventMgrIssueAccept
voidHandleAcceptCompletion( PAcceptContext pAcceptCtxt, DWORD status )/*++
Routine Description:
This function is called by the event loop when an accept I/O completes. The Call Bridge Machine's accept callback function is called for H.245 connections. This function always frees pAcceptCtxt if another accept is not issued. Arguments:
pAcceptCtxt - The Accept I/O context. This contains the overlapped context on which the accept callback is called in the case of H.245 connections and the listen and accept sockets.
status - This conveys the WIN32 error status.
Return Values:
This function does not return any error code. In case of an error, the call bridge machine is notified about the error in the callback.
--*/
{ int locallen = sizeof(struct sockaddr_in); int remotelen = sizeof(struct sockaddr_in); struct sockaddr_in *pLocalAddr; struct sockaddr_in *pRemoteAddr;
// If H.245 call the accept callback on overlapped processor
// and free the accept I/O context.
// The listening socket is closed by the Call bridge machine.
if (status == NO_ERROR) { if (setsockopt(pAcceptCtxt->acceptSock, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, (char*)(&pAcceptCtxt->listenSock), sizeof(SOCKET)) == SOCKET_ERROR) { DebugF (_T("H323: 0x%x setsockopt SO_UPDATE_ACCEPT_CONTEXT failed acceptSock: %d listenSock: %d err: %d.\n"), &pAcceptCtxt -> ioCtxt.pOvProcessor -> GetCallBridge (), pAcceptCtxt->acceptSock, pAcceptCtxt->listenSock, WSAGetLastError());
// make callback conveying the error
SOCKADDR_IN LocalAddress; SOCKADDR_IN RemoteAddress;
ZeroMemory (&LocalAddress, sizeof (SOCKADDR_IN)); ZeroMemory (&RemoteAddress, sizeof (SOCKADDR_IN));
pAcceptCtxt->ioCtxt.pOvProcessor->AcceptCallback( WSAGetLastError(), INVALID_SOCKET, &LocalAddress, &RemoteAddress);
} else {
// This function does not return anything
GetAcceptExSockaddrs(pAcceptCtxt->addrBuf, 0, sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16, (struct sockaddr**)&pLocalAddr, &locallen, (struct sockaddr**)&pRemoteAddr, &remotelen);
// make the callback
pAcceptCtxt->ioCtxt.pOvProcessor->AcceptCallback( S_OK, pAcceptCtxt->acceptSock, pLocalAddr, pRemoteAddr);
// ownership of pAcceptCtxt -> acceptSock has been transferred,
// so we need to make sure the acceptSock won't be used
pAcceptCtxt -> acceptSock = INVALID_SOCKET; }
} // if (status == NO_ERROR)
else { DebugF (_T("H245: 0x%x error %d on accept callback.\n"), &pAcceptCtxt -> ioCtxt.pOvProcessor -> GetCallBridge (), status);
SOCKADDR_IN LocalAddress; SOCKADDR_IN RemoteAddress;
ZeroMemory (&LocalAddress, sizeof (SOCKADDR_IN)); ZeroMemory (&RemoteAddress, sizeof (SOCKADDR_IN));
// make callback conveying the error
pAcceptCtxt->ioCtxt.pOvProcessor->AcceptCallback( HRESULT_FROM_WIN32_ERROR_CODE(status), INVALID_SOCKET, &LocalAddress, &RemoteAddress);
}
EventMgrFreeAcceptContext (pAcceptCtxt);} // HandleAcceptCompletion(
|
