/*** int TCPServer::availableClients(void)
**
** Synopsis:
** Checks to see how many pending clients are availabe to be accepted.
**
** Parameters:
** None
**
** Return Values:
** The number of waiting TCPSockets to be accepted.
**
** Errors:
** None
**
** Notes:
**
** This is the workhorse of the TCPServer Class
** It will update pending clients if a connection is detected
** It will attempt to start listening if a socket comes avalialbe for listening
** It will clean up disconnected clients
*/
int TCPServer::availableClients(int& cListening, int& cWaiting, IPSTATUS * pStatus)
{
int cAvailable = 0;
cWaiting = 0;
cListening = 0;
FFLL * pffllSocket = NULL;
if(_pDEIPcK == NULL)
{
AssignStatusSafely(pStatus, ipsNotInitialized);
return(0);
}
if(ILIsIPNetworkReady(_pDEIPcK->_pLLAdp, pStatus))
{
while((pffllSocket = (FFLL *) FFNext(&_ffptSockets, pffllSocket)) != NULL)
{
TCPSocket& tcpSocket = *((TCPSocket *) (pffllSocket->_this)); // for syntax sake
if(TCPIsEstablished(&tcpSocket._socket, NULL))
{
cAvailable++;
}
else if(TCPIsConnected(&tcpSocket._socket, NULL))
{
cWaiting++;
}
else if(tcpSocket._socket.tcpState == tcpListen)
{
cListening++;
}
}
}
return(cAvailable);
}
/*****************************************************************************
Function:
bool TCPIsConnected(SOCKET * pSocket, IPSTATUS * pStatus)
Description:
This is sort of like TCPIsEstablished except it is for any connected state. Think
of being connected as being in the process of getting or closing a connection and being established.
Established is a fully connected duplex condtion where both sides are ready to send and receive data.
Parameters:
pSocket: The socket to see if it is in the established state
pStatus: A pointer to a status variable to recieve the status of the connection
This may be NULL if you don't care about the status
Returns:
true if the connection is in the process of connecting, half or full duplex
connection, or in the process of closing but not yet closed.
false if the conneciton is not in any kind of active condition.
***************************************************************************/
bool TCPIsConnected(HSOCKET hSocket, IPSTATUS * pStatus)
{
TCPSOCKET * pSocket = (TCPSOCKET *) hSocket;
IPSTATUS status = ipsUnknowTCPState;
// check to see if we are even connected
if(pSocket == NULL)
{
AssignStatusSafely(pStatus, ipsSocketNULL);
return(false);
}
// Otherwise, what is our state?
switch(pSocket->tcpState)
{
case tcpListen:
case tcpSynSent:
case tcpSynReceivedWhileListening:
case tcpSynReceived:
case tcpEstablished:
case tcpFinWait1:
case tcpFinWait2:
case tcpCloseWait:
case tcpClosing:
case tcpLastAck:
status = IPStatusFromTCPState(pSocket->tcpState);
break;
case tcpWaitUserClose:
if(TCPAvailable(pSocket, NULL) > 0)
{
status = IPStatusFromTCPState(pSocket->tcpState);
}
else
{
status = IPErrorFromTCPState(pSocket->tcpState);
}
break;
case tcpUnassigned:
case tcpAllocated:
case tcpInvalid:
case tcpClosed:
status = IPErrorFromTCPState(pSocket->tcpState);
break;
default:
status = ipsUnknowTCPState;
break;
}
AssignStatusSafely(pStatus, status);
if(IsIPStatusAnError(status))
{
return(false);
}
else if(!ILIsIPNetworkReady(pSocket->s.pLLAdp, &status))
{
AssignStatusSafely(pStatus, status);
return(false);
}
else if(pSocket->tcpState == tcpListen)
{
return(false);
}
return(true);
}
