|
|
/****************************************************************************/// wtdint.cpp
//
// Transport driver - Windows specific internal functions.
//
// Copyright (C) 1997-1999 Microsoft Corp.
/****************************************************************************/
#include <adcg.h>
extern "C" {#define TRC_FILE "wtdint"
#define TRC_GROUP TRC_GROUP_NETWORK
#include <atrcapi.h>
}
#include "autil.h"
#include "td.h"
#include "xt.h"
#include "nl.h"
#include "wui.h"
#include "objs.h"
/****************************************************************************//* Name: TDInit *//* *//* Purpose: Initializes _TD. This function allocates the send buffers, *//* creates the TD window and then initializes WinSock. *//* *//* Operation: On error this function calls the UT fatal error handler. *//****************************************************************************/DCVOID DCINTERNAL CTD::TDInit(DCVOID){ DCUINT i; DCUINT pubSndBufSizes[TD_SNDBUF_PUBNUM] = TD_SNDBUF_PUBSIZES; DCUINT priSndBufSizes[TD_SNDBUF_PRINUM] = TD_SNDBUF_PRISIZES; WORD versionRequested; WSADATA wsaData; int intRC;
DC_BEGIN_FN("TDInit");
/************************************************************************/ /* Allocate a buffer into which data will be recieved from Winsock. */ /************************************************************************/ _TD.recvBuffer.pData = (PDCUINT8)UT_Malloc( _pUt, TD_RECV_BUFFER_SIZE); if (NULL != _TD.recvBuffer.pData) { // Got the buffer memory. Record the buffer size. Note we need to
// record slightly less than the allocated size to account for
// the fact that the current MPPC decompression code looks ahead one
// byte, which means that a fault can occur if this lookahead goes
// over the page boundary of this buffer. Leaving a couple of bytes
// at the end of the buffer prevents this. This does not seriously
// affect decoding efficiency -- the server itself sends less than
// a full 8K buffer per send.
TRC_NRM((TB, _T("Allocated %u bytes for recv buffer"), TD_RECV_BUFFER_SIZE)); _TD.recvBuffer.size = TD_RECV_BUFFER_SIZE - 2; } else { /********************************************************************/ /* Didn't get the memory. We can live without it, just keep the */ /* size set at zero. */ /********************************************************************/ TRC_ALT((TB, _T("Failed to alloc %u bytes for recv buffer"), TD_RECV_BUFFER_SIZE)); }
/************************************************************************/ /* Now loop through the public send buffer array and initialize the */ /* array members. */ /************************************************************************/ for (i = 0; i < TD_SNDBUF_PUBNUM; i++) { /********************************************************************/ /* Initialize the buffer information structure and allocate memory */ /* for the actual buffer. */ /********************************************************************/ TDInitBufInfo(&_TD.pubSndBufs[i]); TDAllocBuf(&_TD.pubSndBufs[i], pubSndBufSizes[i]);
TRC_DBG((TB, _T("Initialised public buffer:%u size:%u"), i, pubSndBufSizes[i])); }
/************************************************************************/ /* Loop through the private send buffer array and initialize the array */ /* members. */ /************************************************************************/ for (i = 0; i < TD_SNDBUF_PRINUM; i++) { /********************************************************************/ /* Initialize the buffer. */ /********************************************************************/ TDInitBufInfo(&_TD.priSndBufs[i]); TDAllocBuf(&_TD.priSndBufs[i], priSndBufSizes[i]);
TRC_DBG((TB, _T("Initialised private buffer:%u size:%u"), i, priSndBufSizes[i])); }
/************************************************************************/ /* Create the TD window. */ /************************************************************************/ TDCreateWindow();
#ifdef OS_WINCE
#if (_WIN32_WCE > 300)
if (NULL == (_TD.hevtAddrChange = CreateEvent(NULL, TRUE, FALSE, NULL))) { TRC_ABORT((TB, _T("Failed to create addr change notify event:%d"), GetLastError())); _pUi->UI_FatalError(DC_ERR_OUTOFMEMORY); DC_QUIT; }#endif
#endif
/************************************************************************/ /* We want to use version 1.1 of WinSock. */ /************************************************************************/ versionRequested = MAKEWORD(1, 1);
/************************************************************************/ /* Initialize WinSock. */ /************************************************************************/ intRC = WSAStartup(versionRequested, &wsaData);
if (intRC != 0) { /********************************************************************/ // Trace out the error code - note that we can't use WSAGetLastError
// at this point as WinSock has failed to initialize and so
// WSAGetLastError will just fail.
/********************************************************************/ TRC_ABORT((TB, _T("Failed to initialize WinSock rc:%d"), intRC)); _pUi->UI_FatalError(DC_ERR_WINSOCKINITFAILED); DC_QUIT; }
/************************************************************************/ /* Now confirm that this WinSock supports version 1.1. Note that if */ /* the DLL supports versions greater than 1.1 in addition to 1.1 then */ /* it will still return 1.1 in the version information as that is the */ /* version requested. */ /************************************************************************/ if ((LOBYTE(wsaData.wVersion) != 1) || (HIBYTE(wsaData.wVersion) != 1)) { /********************************************************************/ /* Oops - this WinSock doesn't support version 1.1. */ /********************************************************************/ WSACleanup();
TRC_ABORT((TB, _T("This WinSock doesn't support version 1.1"))); _pUi->UI_FatalError(DC_ERR_WINSOCKINITFAILED); DC_QUIT; }
TRC_NRM((TB, _T("WinSock init version %u:%u"), HIBYTE(wsaData.wVersion), LOBYTE(wsaData.wVersion)));
TRC_NRM((TB, _T("TD successfully initialized")));
DC_EXIT_POINT: DC_END_FN();} /* TDInit */
/****************************************************************************//* Name: TDTerm *//* *//* Purpose: Terminates _TD. It frees the send buffers, cleans up WinSock, *//* destroys the TD window and then unregisters the TD window *//* class. *//****************************************************************************/DCVOID DCINTERNAL CTD::TDTerm(DCVOID){ DCUINT i; int intRC;
DC_BEGIN_FN("TDTerm");
/************************************************************************/ /* Loop through the public and private send buffers and free the */ /* memory. */ /************************************************************************/ for (i = 0; i < TD_SNDBUF_PUBNUM; i++) { UT_Free( _pUt, _TD.pubSndBufs[i].pBuffer); }
for (i = 0; i < TD_SNDBUF_PRINUM; i++) { UT_Free( _pUt, _TD.priSndBufs[i].pBuffer); }
/************************************************************************/ /* Cleanup WinSock. */ /************************************************************************/ intRC = WSACleanup();
if (SOCKET_ERROR == intRC) { TRC_ALT((TB, _T("Failed to cleanup WinSock:%d"), WSAGetLastError())); }
#ifdef OS_WINCE
#if (_WIN32_WCE > 300)
TRC_ASSERT((_TD.hevtAddrChange), (TB, _T("hevtAddrChange is null")));
CloseHandle(_TD.hevtAddrChange); _TD.hevtAddrChange = NULL;#endif
#endif
/************************************************************************/ /* Destroy the window. */ /************************************************************************/ intRC = DestroyWindow(_TD.hWnd); _TD.hWnd = NULL;
if (0 == intRC) { TRC_SYSTEM_ERROR("Destroy Window"); }
/************************************************************************/ /* Unregister the class. */ /************************************************************************/ UnregisterClass(TD_WNDCLASSNAME, _pUi->UI_GetInstanceHandle());
/************************************************************************/ /* Release the recv buffer (if allocated). */ /************************************************************************/ if (0 != _TD.recvBuffer.size) { TRC_ASSERT((!IsBadWritePtr(_TD.recvBuffer.pData, _TD.recvBuffer.size)), (TB, _T("recv buffer %p size %u is invalid"), _TD.recvBuffer.pData, _TD.recvBuffer.size));
UT_Free( _pUt, _TD.recvBuffer.pData); _TD.recvBuffer.pData = NULL; }
TRC_NRM((TB, _T("TD successfully terminated")));
DC_END_FN();} /* TDTerm */
LRESULT CALLBACK CTD::StaticTDWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){ CTD* pTD = (CTD*)GetWindowLongPtr(hwnd, GWLP_USERDATA); if(WM_CREATE == message) { //pull out the this pointer and stuff it in the window class
LPCREATESTRUCT lpcs = (LPCREATESTRUCT) lParam; pTD = (CTD*)lpcs->lpCreateParams;
SetWindowLongPtr( hwnd, GWLP_USERDATA, (LONG_PTR)pTD); } //
// Delegate the message to the appropriate instance
//
return pTD->TDWndProc(hwnd, message, wParam, lParam);}
/****************************************************************************//* Name: TDWndProc *//* *//* Purpose: The TD window procedure. *//* *//* Params: See Windows documentation. *//****************************************************************************/LRESULT CALLBACK CTD::TDWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam){ LRESULT rc = 0; WORD eventWSA; WORD errorWSA; u_long address;
DC_BEGIN_FN("TDWndProc");
// Trace the interesting parameters.
TRC_DBG((TB, _T("uMsg:%u wP:%u lP:%lu"), uMsg, wParam, lParam));
// Special-case FD_READ (most important) and FD_WRITE (happens often).
if (uMsg == TD_WSA_ASYNC) { if (WSAGETSELECTEVENT(lParam) == FD_READ) { TRC_DBG((TB, _T("FD_READ recvd")));
// Check for an error.
if (WSAGETSELECTERROR(lParam) == 0) { // If we're no longer connected, we just ignore the data.
if (_TD.fsmState == TD_ST_CONNECTED) { // There is now some data available so set the
// global variable.
_TD.dataInTD = TRUE;
#ifdef OS_WINCE
// Enable Winsock receive. We perform only one
// WinSock recv per FD_READ.
TD_EnableWSRecv();#endif // OS_WINCE
// Tell XT.
_pXt->XT_OnTDDataAvailable(); } else { TRC_NRM((TB, _T("FD_READ when not connected"))); } } else { TRC_ALT((TB, _T("WSA_ASYNC error:%hu"), WSAGETSELECTERROR(lParam))); }
DC_QUIT; } else if (WSAGETSELECTEVENT(lParam) == FD_WRITE) { TRC_NRM((TB, _T("FD_WRITE received")));
// Check for an error.
if (WSAGETSELECTERROR(lParam) == 0) { // Make sure we're still connected.
if (_TD.fsmState == TD_ST_CONNECTED) { // We're on the receiver thread, notify sender
// thread to flush the send queue.
_pCd->CD_DecoupleSimpleNotification(CD_SND_COMPONENT, this, CD_NOTIFICATION_FUNC(CTD,TDFlushSendQueue), 0);
// Call up to XT to inform the higher layers
// that the back pressure situation has been
// relieved.
_pXt->XT_OnTDBufferAvailable(); } else { TRC_ALT((TB, _T("FD_WRITE when not connected"))); } } else { TRC_ALT((TB, _T("WSA_ASYNC error:%hu"), WSAGETSELECTERROR(lParam))); }
DC_QUIT; } } // Now switch on the message type for other messages.
switch (uMsg) { case WM_TIMER: /****************************************************************/ /* Check that the ID of the timer is as expected. */ /****************************************************************/ if (TD_TIMERID == wParam) { /************************************************************/ /* OK it is our connection time out timer, so call the */ /* state machine. */ /************************************************************/ TRC_NRM((TB, _T("WM_TIMER recvd"))); TDConnectFSMProc(TD_EVT_WMTIMER, NL_MAKE_DISCONNECT_ERR(NL_ERR_TDTIMEOUT)); }#ifdef DC_DEBUG
else if (TD_THROUGHPUTTIMERID == wParam) { /************************************************************/ /* This is the throughput throttling timer. Reset the */ /* byte counts. */ /************************************************************/ TRC_DBG((TB, _T("Throughput timer, reset byte counts to:%u"), _TD.currentThroughput)); _TD.periodSendBytesLeft = _TD.currentThroughput; _TD.periodRecvBytesLeft = _TD.currentThroughput;
/************************************************************/ /* If we're connected then generate FD_READ and FD_WRITE */ /* messages to get the network layer running along. */ /************************************************************/ if (TD_ST_CONNECTED == _TD.fsmState) { PostMessage(_TD.hWnd, TD_WSA_ASYNC, (WPARAM)0, (LPARAM)MAKELONG(FD_READ, 0)); PostMessage(_TD.hWnd, TD_WSA_ASYNC, (WPARAM)0, (LPARAM)MAKELONG(FD_WRITE, 0)); } }#endif /* DC_DEBUG */
else { TRC_ALT((TB, _T("Unexpected timer message id:%u"), wParam)); } break;
case TD_WSA_ASYNC: /****************************************************************/ /* We've received a WSAAsyncSelect() FD_x notification message. */ /* Parse the message to extract the FD_ value and error value */ /* (if there is one). */ /****************************************************************/ eventWSA = WSAGETSELECTEVENT(lParam); errorWSA = WSAGETSELECTERROR(lParam);
TRC_DBG((TB, _T("WSA_ASYNC event:%#hx error:%hu"), eventWSA, errorWSA));
/****************************************************************/ /* Everything is OK so now switch on the event. */ /****************************************************************/ switch (eventWSA) {
case FD_CONNECT: TRC_NRM((TB, _T("FD_CONNECT recvd"))); /********************************************************/ /* Under some circumstances, we can receive FD_CONNECT */ /* for a socket which we have lost interest in. */ /********************************************************/ if (wParam != _TD.hSocket) { TRC_ALT((TB, _T("FD_CONNECT for socket %d, using %d"), wParam, _TD.hSocket)); DC_QUIT; }
/********************************************************/ /* Check for an error. */ /********************************************************/ if (0 != errorWSA) { TRC_ALT((TB, _T("WSA_ASYNC error:%hu"), errorWSA)); TDConnectFSMProc(TD_EVT_ERROR, NL_MAKE_DISCONNECT_ERR(NL_ERR_TDSKTCONNECTFAILED)); DC_QUIT; }
/********************************************************/ /* Advance the state machine. */ /********************************************************/ TDConnectFSMProc(TD_EVT_OK, 0); break;
case FD_CLOSE: { DCBOOL keepOnReceiving = TRUE; int intRC;
TRC_NRM((TB, _T("FD_CLOSE recvd")));
/********************************************************/ /* Check for the remote system aborting the connection. */ /********************************************************/ if (0 != errorWSA) { /****************************************************/ /* The server sends a TCP RST instead of a FIN, */ /* even when a clean disconnection is made. */ /* However, this is handled by the UI (see */ /* UIGoDisconnected). */ /****************************************************/ TRC_ALT((TB, _T("Abortive server close:%hu"), errorWSA));
TDConnectFSMProc(TD_EVT_ERROR, NL_MAKE_DISCONNECT_ERR(NL_ERR_TDFDCLOSE));
DC_QUIT; }
/********************************************************/ /* If we get here then this a response to a graceful */ /* close (i.e. we made a call to shutdown(SD_SEND) */ /* earlier). */ /* */ /* All of the data should have already been read from */ /* the socket before WinSock posted the FD_CLOSE, but */ /* to be safe we loop on recv. */ /********************************************************/ while (keepOnReceiving) { intRC = recv(_TD.hSocket, (char *)_TD.priSndBufs[0].pBuffer, _TD.priSndBufs[0].size, 0);
if ((0 == intRC) || (SOCKET_ERROR == intRC)) { keepOnReceiving = FALSE; TRC_ALT((TB, _T("No more data in WS (rc:%d)"), intRC)); } else { TRC_ALT((TB, _T("Throwing away %d bytes from WS"), intRC)); } }
/********************************************************/ /* Finally call the FSM. */ /********************************************************/ TDConnectFSMProc(TD_EVT_OK, NL_DISCONNECT_LOCAL); } break;
default: TRC_ALT((TB, _T("Unknown FD event %hu recvd"), eventWSA)); break; } break;
case TD_WSA_GETHOSTBYNAME: /****************************************************************/ /* We've received the result of a WSAAsyncGetHostByName */ /* operation. Split the message apart and call the FSM. */ /****************************************************************/ errorWSA = WSAGETASYNCERROR(lParam);
if (0 != errorWSA) { TRC_ALT((TB, _T("GHBN failed:%hu"), errorWSA));
/************************************************************/ /* Call the state machine with the error event. */ /************************************************************/ TDConnectFSMProc(TD_EVT_ERROR, NL_MAKE_DISCONNECT_ERR(NL_ERR_TDGHBNFAILED)); break; }
/****************************************************************/ /* Now get the primary interface address. */ /****************************************************************/ address = *((u_long DCPTR) (((struct hostent DCPTR)_TD.priSndBufs[0].pBuffer)->h_addr));
TRC_ASSERT((address != 0), (TB, _T("GetHostByName returned success but 0 address")));
TRC_NRM((TB, _T("GHBN - address is:%#lx"), address));
TDConnectFSMProc(TD_EVT_OK, (DCUINT32)address); break;
#if (defined(OS_WINCE) && (_WIN32_WCE > 300))
case TD_WSA_NETDOWN: TRC_NRM((TB, _T("TD_WSA_NETDOWN recvd"))); TDConnectFSMProc(TD_EVT_ERROR, NL_MAKE_DISCONNECT_ERR(NL_ERR_TDONCALLTOSEND)); break;#endif
default: rc = DefWindowProc(hWnd, uMsg, wParam, lParam); break; }
DC_EXIT_POINT: DC_END_FN(); return(rc);} /* TDWndProc */
/****************************************************************************//* Name: TDCreateWindow *//* *//* Purpose: Creates the TD window. This function registers the TD *//* window class and then creates a window of that class. On *//* error it calls UI_FatalError. *//****************************************************************************/DCVOID DCINTERNAL CTD::TDCreateWindow(DCVOID){ WNDCLASS wc; WNDCLASS tmpWndClass; ATOM intRC;
DC_BEGIN_FN("TDCreateWindow");
if(!GetClassInfo(_pUi->UI_GetInstanceHandle(),TD_WNDCLASSNAME, &tmpWndClass)) { /************************************************************************/ /* Fill in the class structure. */ /************************************************************************/ wc.style = 0; wc.lpfnWndProc = StaticTDWndProc; wc.cbClsExtra = 0; wc.cbWndExtra = sizeof(void*); //for instance pointer
wc.hInstance = _pUi->UI_GetInstanceHandle(); wc.hIcon = NULL; wc.hCursor = NULL; wc.hbrBackground = NULL; wc.lpszMenuName = NULL; wc.lpszClassName = TD_WNDCLASSNAME; /************************************************************************/ /* Register the class used by the TD window. */ /************************************************************************/ intRC = RegisterClass(&wc);
if (0 == intRC) { TRC_ERR((TB, _T("Failed to register WinSock window class"))); _pUi->UI_FatalError(DC_ERR_CLASSREGISTERFAILED); DC_QUIT; } }
/************************************************************************/ /* Now create the window. */ /************************************************************************/ _TD.hWnd = CreateWindow(TD_WNDCLASSNAME, /* class name */ NULL, /* window title */ 0, /* window style */ 0, /* x-pos */ 0, /* y-pos */ 0, /* width */ 0, /* height */ NULL, /* parent */ NULL, /* menu */ _pUi->UI_GetInstanceHandle(), /* instance */ this); /* ptr to creation data */
if (NULL == _TD.hWnd) { TRC_ERR((TB, _T("Failed to create TD window"))); _pUi->UI_FatalError(DC_ERR_WINDOWCREATEFAILED); DC_QUIT; }
TRC_NRM((TB, _T("Created window:%p"), _TD.hWnd));
DC_EXIT_POINT: DC_END_FN();} /* TDCreateWindow */
/****************************************************************************//* Name: TDBeginDNSLookup *//* *//* Purpose: Starts the address resolution process. On error this *//* function calls into the state machine with an error code. *//* *//* Params: IN pServerAddress - pointer to the server address name. *//****************************************************************************/DCVOID DCINTERNAL CTD::TDBeginDNSLookup(PDCACHAR pServerAddress){ DC_BEGIN_FN("TDBeginDNSLookup");
/************************************************************************/ /* This is an asynchronous operation and will result in us getting a */ /* callback sometime later. We need to provide a buffer which can be */ /* filled in with DNS information, so we make use of the first private */ /* send buffer. */ /************************************************************************/ TRC_ASSERT((_TD.priSndBufs[0].size >= MAXGETHOSTSTRUCT), (TB, _T("Private snd buf size (%u) too small for DNS lookup (need:%u)"), _TD.priSndBufs[0].size, MAXGETHOSTSTRUCT));
/************************************************************************/ /* Issue the call. */ /************************************************************************/ _TD.hGHBN = WSAAsyncGetHostByName(_TD.hWnd, TD_WSA_GETHOSTBYNAME, pServerAddress, (char DCPTR) _TD.priSndBufs[0].pBuffer, MAXGETHOSTSTRUCT); if (0 == _TD.hGHBN) { /********************************************************************/ /* We failed to initiate the operation - so find out what went */ /* wrong. */ /********************************************************************/ TRC_ALT((TB, _T("Failed to initiate GetHostByName - GLE:%d"), WSAGetLastError()));
/********************************************************************/ /* Call the state machine with an error. */ /********************************************************************/ TDConnectFSMProc(TD_EVT_ERROR, NL_MAKE_DISCONNECT_ERR(NL_ERR_TDDNSLOOKUPFAILED)); DC_QUIT; }
TRC_NRM((TB, _T("Initiated GetHostByName OK")));
DC_EXIT_POINT: DC_END_FN();} /* TDBeginDNSLookup */
/****************************************************************************//* Name: TDBeginSktConnectWithConnectedEndpoint *//* *//* Purpose: Establish connection with server already connect *//* on some socket *//* *//* Params: *//* *//****************************************************************************/DCVOID DCINTERNAL CTD::TDBeginSktConnectWithConnectedEndpoint(){ DCBOOL failure = FALSE;#ifndef OS_WINCE
int lastError;#endif
int intRC;
DC_BEGIN_FN("TDBeginSktConnectWithConnectedEndpoint");
/************************************************************************/ /* Socket already connect, setup FD_XXX event with our window */ /* we are assuming mstscax client already make necessary error checking */ /************************************************************************/ _TD.hSocket = _pUi->UI_GetTDSocket();
TRC_ASSERT( (_TD.hSocket != INVALID_SOCKET), (TB, _T("Connected socket not setup properly")) );
if( INVALID_SOCKET == _TD.hSocket ) { failure = TRUE; DC_QUIT; }
/************************************************************************/ /* Set the required options on this socket. We do the following: */ /* */ /* - disable the NAGLE algorithm. */ /* - enable the don't linger option. This means the closesocket call */ /* will return immediately while any data queued for transmission */ /* will be sent, if possible, before the underlying socket is */ /* closed. */ /* */ /* Note that further options are set when the connection is */ /* established. */ /************************************************************************/ TDSetSockOpt(IPPROTO_TCP, TCP_NODELAY, 1); TDSetSockOpt(SOL_SOCKET, SO_DONTLINGER, 1);
/************************************************************************/ /* Now request async notifications for all events on this socket. */ /************************************************************************/ intRC = WSAAsyncSelect(_TD.hSocket, _TD.hWnd, TD_WSA_ASYNC, FD_READ | FD_WRITE | FD_CLOSE);
if (SOCKET_ERROR == intRC) { TRC_ERR((TB, _T("Failed to select async - GLE:%d"), WSAGetLastError())); failure = TRUE; DC_QUIT; }
DC_EXIT_POINT: if (failure) { TRC_ALT((TB, _T("Failed to begin socket connection process")));
/********************************************************************/ /* Call the FSM. */ /********************************************************************/ TDConnectFSMProc(TD_EVT_ERROR, NL_MAKE_DISCONNECT_ERR(NL_ERR_TDSKTCONNECTFAILED)); } else { // use existing code path to setup rest.
PostMessage(_TD.hWnd, TD_WSA_ASYNC, (WPARAM) _TD.hSocket, (LPARAM)MAKELONG(FD_CONNECT, 0)); }
DC_END_FN();} /* TDBeginSktConnectWithConnectedEndpoint */
/****************************************************************************//* Name: TDBeginSktConnect *//* *//* Purpose: Issues a connect at the WinSock socket level. *//* *//* Params: IN address - the address to call (this is a numeric value *//* in network (big-endian) byte order). *//****************************************************************************/DCVOID DCINTERNAL CTD::TDBeginSktConnect(u_long address){ DCBOOL failure = FALSE; int intRC; int lastError; SOCKADDR_IN stDstAddr;
DC_BEGIN_FN("TDBeginSktConnect");
/************************************************************************/ /* First of all get a socket. */ /************************************************************************/ _TD.hSocket = socket(AF_INET, SOCK_STREAM, 0);
if (INVALID_SOCKET == _TD.hSocket) { TRC_ERR((TB, _T("Failed to get a socket - GLE:%d"), WSAGetLastError())); DC_QUIT; }
_pUi->UI_SetTDSocket(_TD.hSocket);
TRC_NRM((TB, _T("Acquired socket:%#x"), _TD.hSocket));
/************************************************************************/ /* Set the required options on this socket. We do the following: */ /* */ /* - disable the NAGLE algorithm. */ /* - enable the don't linger option. This means the closesocket call */ /* will return immediately while any data queued for transmission */ /* will be sent, if possible, before the underlying socket is */ /* closed. */ /* */ /* Note that further options are set when the connection is */ /* established. */ /************************************************************************/ TDSetSockOpt(IPPROTO_TCP, TCP_NODELAY, 1); TDSetSockOpt(SOL_SOCKET, SO_DONTLINGER, 1);
/************************************************************************/ /* Now request async notifications for all events on this socket. */ /************************************************************************/ intRC = WSAAsyncSelect(_TD.hSocket, _TD.hWnd, TD_WSA_ASYNC, FD_CONNECT | FD_READ | FD_WRITE | FD_CLOSE);
if (SOCKET_ERROR == intRC) { TRC_ERR((TB, _T("Failed to select async - GLE:%d"), WSAGetLastError())); failure = TRUE; DC_QUIT; }
/************************************************************************/ /* Now kick off a timer - if the connect does not complete before we */ /* get the WM_TIMER message then we'll abort the connection attempt. */ /************************************************************************//* _TD.hTimer = TDSetTimer(TD_CONNECTTIMEOUT);
if (0 == _TD.hTimer) { failure = TRUE; DC_QUIT; }*/ /************************************************************************/ /* Fill in the address of the remote system we want to connect to. */ /************************************************************************/ stDstAddr.sin_family = PF_INET; stDstAddr.sin_port = htons(_pUi->UI_GetMCSPort()); stDstAddr.sin_addr.s_addr = (u_long) address;
#ifdef OS_WINCE
#if (_WIN32_WCE > 300)
TRC_ASSERT((_TD.hevtAddrChange), (TB, _T("hevtAddrChange is null"))); TRC_ASSERT((_TD.hAddrChangeThread == NULL), (TB, _T("hAddrChangeThread is not null"))); _TD.hAddrChangeThread = CreateThread(NULL, 0, TDAddrChangeProc, &_TD, 0, NULL); if (_TD.hAddrChangeThread == NULL) { TRC_ERR((TB, _T("CreatThread failed - GLE:%d"), GetLastError())); failure = TRUE; DC_QUIT; }
#endif
#endif
/************************************************************************/ /* We're now in a state where we can try to connect to the remote */ /* system so issue the connect now. We expect this call to fail with */ /* an error code of WSAEWOULDBLOCK - any other error code is a genuine */ /* problem. */ /************************************************************************/ intRC = connect(_TD.hSocket, (struct sockaddr DCPTR) &stDstAddr, sizeof(stDstAddr));
if (SOCKET_ERROR == intRC) { /********************************************************************/ /* Get the last error. */ /********************************************************************/ lastError = WSAGetLastError();
/********************************************************************/ /* We expect the connect to return an error of WSAEWOULDBLOCK - */ /* anything else indicates a genuine error. */ /********************************************************************/ if (lastError != WSAEWOULDBLOCK) { TRC_ERR((TB, _T("Connect failed - GLE:%d"), lastError)); failure = TRUE; DC_QUIT; } }
/************************************************************************/ /* We've done as much as we can at this point - all we can do now is */ /* wait for the socket connection to complete. */ /************************************************************************/ TRC_NRM((TB, _T("Waiting for connect to complete...")));
DC_EXIT_POINT: if (failure) { TRC_ALT((TB, _T("Failed to begin socket connection process")));
/********************************************************************/ /* Call the FSM. */ /********************************************************************/ TDConnectFSMProc(TD_EVT_ERROR, NL_MAKE_DISCONNECT_ERR(NL_ERR_TDSKTCONNECTFAILED)); }
DC_END_FN();} /* TDBeginSktConnect */
/****************************************************************************//* Name: TDSetSockOpt *//* *//* Purpose: Sets a given WinSock socket option. Note that this function *//* does not return an error if it fails to set the option as *//* TD can still continue successfully despite failing to set *//* the options to the desired values. *//* *//* Params: IN level - the level at which the option is defined (see *//* docs for setsockopt). *//* IN optName - the socket option for which the value is to be *//* set. *//* IN value - the value to set the option to. *//****************************************************************************/DCVOID DCINTERNAL CTD::TDSetSockOpt(DCINT level, DCINT optName, DCINT value){ int intRC; DCINT size = sizeof(DCINT);#ifdef DC_DEBUG
DCINT oldVal; DCINT newVal;#endif /* DC_DEBUG */
DC_BEGIN_FN("TDSetSockOpt");
#ifdef DC_DEBUG
/************************************************************************/ /* For the debug build trace out the current value of the option */ /* before setting it. */ /************************************************************************/ getsockopt(_TD.hSocket, level, optName, (char DCPTR) &oldVal, &size);#endif /* DC_DEBUG */
/************************************************************************/ /* Now set the option. */ /************************************************************************/ intRC = setsockopt(_TD.hSocket, level, optName, (char DCPTR) &value, size);
if (SOCKET_ERROR == intRC) { TRC_ALT((TB, _T("Failed to set socket option:%d rc:%d (level:%d val:%d)"), optName, WSAGetLastError(), level, value)); DC_QUIT; }
#ifdef DC_DEBUG
/************************************************************************/ /* Get the new value of the option. */ /************************************************************************/ getsockopt(_TD.hSocket, level, optName, (char DCPTR) &newVal, &size);
TRC_NRM((TB, _T("Mod socket option %d:%d from %d to %d"), level, optName, oldVal, newVal));#endif /* DC_DEBUG */
DC_EXIT_POINT: DC_END_FN();} /* TDSetSockOpt */
/****************************************************************************//* Name: TDDisconnect *//* *//* Purpose: Disconnects the transport driver. *//****************************************************************************/DCVOID DCINTERNAL CTD::TDDisconnect(DCVOID){ int intRC; SOCKET socket;
DC_BEGIN_FN("TDDisconnect");
/************************************************************************/ /* Kill the timer. */ /************************************************************************/ TDKillTimer();
/************************************************************************/ /* Ensure the data-in-TD flag is cleared. */ /************************************************************************/ _TD.dataInTD = FALSE;
/************************************************************************/ /* Cancel the outstanding DNS lookup. We can't be sure that the async */ /* operation has completed already and the message is already sitting */ /* on our queue (or being processed by the receive thread). If that is */ /* the case then WSACancelAsyncRequest will fail, but it doesn't */ /* matter. */ /************************************************************************/ intRC = WSACancelAsyncRequest(_TD.hGHBN); if (SOCKET_ERROR == intRC) { TRC_NRM((TB, _T("Failed to cancel async DNS request"))); }
/************************************************************************/ /* Decouple to the sender thread and clear the send queue. */ /************************************************************************/ _pCd->CD_DecoupleSyncNotification(CD_SND_COMPONENT, this, CD_NOTIFICATION_FUNC(CTD,TDClearSendQueue), 0);
#ifdef OS_WINCE
#if (_WIN32_WCE > 300)
SetEvent(_TD.hevtAddrChange);
if (_TD.hAddrChangeThread) { WaitForSingleObject(_TD.hAddrChangeThread, INFINITE); CloseHandle(_TD.hAddrChangeThread); _TD.hAddrChangeThread = NULL; } ResetEvent(_TD.hevtAddrChange);#endif
#endif
if (INVALID_SOCKET == _TD.hSocket) { TRC_NRM((TB, _T("_TD.hSocket is NULL so just quit"))); DC_QUIT; }
/************************************************************************/ /* Now close the socket. */ /************************************************************************/ TRC_NRM((TB, _T("Close the socket")));
socket = _TD.hSocket; _TD.hSocket = INVALID_SOCKET; intRC = closesocket(socket); if (SOCKET_ERROR == intRC) { TRC_ALT((TB, _T("closesocket rc:%d"), WSAGetLastError())); }
DC_EXIT_POINT: DC_END_FN();} /* TDDisconnect */
/****************************************************************************//* Name: TDSetTimer *//* *//* Purpose: Sets the timer. *//* *//* Returns: TRUE on success and FALSE otherwise. *//* *//* Params: IN timeInterval - the time interval of the timer. *//****************************************************************************/DCBOOL DCINTERNAL CTD::TDSetTimer(DCUINT timeInterval){ DCBOOL rc;
DC_BEGIN_FN("TDSetTimer");
/************************************************************************/ /* Set the timer with the passed time interval. */ /************************************************************************/ _TD.hTimer = SetTimer(_TD.hWnd, TD_TIMERID, timeInterval, NULL); if (_TD.hTimer != 0) { // Everything went OK, so set a successful return code.
rc = TRUE; TRC_NRM((TB, _T("Set timer with interval:%u"), timeInterval)); } else { TRC_SYSTEM_ERROR("SetTimer"); rc = FALSE; }
DC_END_FN(); return rc;} /* TDSetTimer */
/****************************************************************************//* Name: TDKillTimer *//* *//* Purpose: Cleans up the timer which is used to time-out connect *//* and disconnect attempts. *//****************************************************************************/DCVOID DCINTERNAL CTD::TDKillTimer(DCVOID){ BOOL rc;
DC_BEGIN_FN("TDKillTimer");
/************************************************************************/ /* Destroy the connection timeout timer. If we fail to get rid of this */ /* timer then there's not much we can do - we'll continue to get */ /* WM_TIMER messages which we'll ignore in retail and assert on in the */ /* debug version. */ /************************************************************************/ if (_TD.hTimer != 0) { rc = KillTimer(_TD.hWnd, TD_TIMERID); _TD.hTimer = 0;
TRC_NRM((TB, _T("Timer has %s been killed"), rc ? _T("") : _T(" NOT"))); } else { TRC_NRM((TB, _T("Timer has not been set"))); }
DC_END_FN();} /* TDKillTimer */
/****************************************************************************/// TDFlushSendQueue
//
// Tries to send all the packets which are waiting in the send queue.
// Must be called on the sender thread, Can be called through direct calls
// or through a CD_Decouple call.
/****************************************************************************/void DCINTERNAL CTD::TDFlushSendQueue(ULONG_PTR unused){ DCUINT bytesSent; PTD_SNDBUF_INFO pOldBuf; int bytesToSend; DCBOOL sentABuffer = FALSE; int WSAErr;
DC_BEGIN_FN("TDFlushSendQueue");
DC_IGNORE_PARAMETER(unused);
// Check for rare re-entrancy.
if (!_TD.inFlushSendQueue) { _TD.inFlushSendQueue = TRUE;
// Check that there are some buffers waiting to be sent.
if (_TD.pFQBuf != NULL) { // Run along the send queue and try to send the data.
// Check for buffers that are inUse because ClearSendQueue could
// potentially clear some buffers before this call comes in
//
while (NULL != _TD.pFQBuf && _TD.pFQBuf->inUse) { // Check that the buffer is in use and that the count of
// bytes waiting to be sent is more than zero.
TRC_ASSERT((_TD.pFQBuf->inUse), (TB, _T("Buffer is not in use"))); TRC_ASSERT((_TD.pFQBuf->bytesLeftToSend > 0), (TB, _T("No bytes waiting to be sent")));
// Trace out the send buffer information.
TD_TRACE_SENDINFO(TRC_LEVEL_DBG);
TRC_DBG((TB, _T("Sending buffer:%p (waiting:%u)"), _TD.pFQBuf, _TD.pFQBuf->bytesLeftToSend));
// Call WinSock to send the buffer. We expect the call to:
// - succeed and send all the bytes requested. In this case
// there is little for us to do.
// - send some of the bytes we asked to be sent. This
// indicates that WinSock is applying back-pressure to us,
// so we update our count of bytes sent for this buffer
// and then quit. We will get a FD_WRITE later and retry
// the send.
// - send none of the bytes that we asked to be sent and
// return SOCKET_ERROR instead. We then use
// WSAGetLastError to determine why the call failed. If
// the reason is WSAEWOULDBLOCK then WinSock has decided
// to fail the call due to back-pressure - this is fine
// by us, so we just quit. Once again we will get an
// FD_WRITE to tell us that back-pressure has been
// relieved. Any other reason code is a genuine error
// so we decouple a call into the state table with an
// error code.
#ifdef DC_DEBUG
// Calculate how many bytes we can send and then decrement
// the count of bytes left to send in this period.
if (0 == _TD.hThroughputTimer) { bytesToSend = (int)_TD.pFQBuf->bytesLeftToSend; } else { bytesToSend = (int) DC_MIN(_TD.pFQBuf->bytesLeftToSend, _TD.periodSendBytesLeft); TRC_DBG((TB, _T("periodSendBytesLeft:%u"), _TD.periodSendBytesLeft)); if (0 == bytesToSend) { TRC_ALT((TB, _T("Constrained SEND network throughput"))); }
_TD.periodSendBytesLeft -= bytesToSend; }#else
bytesToSend = (int)_TD.pFQBuf->bytesLeftToSend;#endif
bytesSent = (DCUINT)send(_TD.hSocket, (char *)_TD.pFQBuf->pDataLeftToSend, bytesToSend, 0); if (SOCKET_ERROR != bytesSent) { TRC_DBG((TB, _T("Sent %u bytes of %u waiting"), bytesSent, _TD.pFQBuf->bytesLeftToSend));
// Update the performance counter.
PRF_ADD_COUNTER(PERF_BYTES_SENT, bytesSent);
// Update the count of bytesWaiting and shuffle the
// pointer to the data along as well.
_TD.pFQBuf->pDataLeftToSend += bytesSent; _TD.pFQBuf->bytesLeftToSend -= bytesSent;
// Check to determine if we managed to send all the data.
if (_TD.pFQBuf->bytesLeftToSend == 0) { // We managed to send all the data in this buffer -
// so it is no longer in use. Get a pointer to this
// buffer.
pOldBuf = _TD.pFQBuf;
// Now update the head of the send queue with the
// next buffer and reset the next field of the buffer
// we've just sent.
_TD.pFQBuf = pOldBuf->pNext;
// Finally update the fields in the old buffer.
pOldBuf->pNext = NULL; pOldBuf->inUse = FALSE; pOldBuf->pDataLeftToSend = NULL; sentABuffer = TRUE;
// Update the performance counter.
PRF_INC_COUNTER(PERF_PKTS_FREED);
TRC_DBG((TB, _T("Sent buffer completely - move to next"))); } else { // We didn't manage to send all the data so trace and
// quit.
TRC_NRM((TB, _T("Didn't send all data in buffer - quit"))); DC_QUIT; } } else { WSAErr = WSAGetLastError();
if (WSAErr == WSAEWOULDBLOCK || WSAErr == WSAENOBUFS) { // WSAEWOULDBLOCK means that the network system is out
// of buffer space so we should wait until we receive
// a FD_WRITE notification indicating that more buffer
// space is available.
//
// WSAENOBUFS means that no buffer space is available
// and indicates a shortage of resources on the
// system.
bytesSent = 0; PRF_INC_COUNTER(PERF_WINSOCK_SEND_FAIL); TRC_NRM((TB, _T("WinSock send returns WSAEWOULDBLOCK")));
// We haven't sent any data, time to get out.
DC_QUIT; } else { bytesSent = 0;
// If this is not a WSAEWOULDBLOCK and it is not a
// WSAENOBUFS error then call the FSM to begin
// disconnect processing.
// Trace out the buffer structure.
TD_TRACE_SENDINFO(TRC_LEVEL_ALT);
// We failed to send any data and the socket returned
// an error. The connection has probably failed or
// ended.
TRC_ALT((TB, _T("Failed to send any data, rc:%d"), WSAErr));
// Decouple across to the recv side event handler at
// this point. It will call the TD FSM.
_pCd->CD_DecoupleSimpleNotification(CD_RCV_COMPONENT, this, CD_NOTIFICATION_FUNC(CTD,TDSendError), 0);
DC_QUIT; } } } } else { TRC_NRM((TB, _T("No buffers waiting to be sent"))); } } else { TRC_ABORT((TB, _T("Re-entered TDFlushSendQueue"))); goto RealExit; }
DC_EXIT_POINT: _TD.inFlushSendQueue = FALSE;
// If we previously failed TD_GetPublicBuffer, and we just
// succeeded in sending a buffer, call the OnBufferAvailable
// callbacks now.
TRC_DBG((TB, _T("Sent a buffer? %d, GetBuffer failed? %d"), sentABuffer, _TD.getBufferFailed)); if (sentABuffer && _TD.getBufferFailed) { TRC_NRM((TB, _T("Signal buffer available"))); _pXt->XT_OnTDBufferAvailable(); _TD.getBufferFailed = FALSE; }
RealExit: DC_END_FN();} /* TDFlushSendQueue */
|
