BOOL CUdpClient::HandleClose(WSANETWORKEVENTS& events)
{
int iCode = events.iErrorCode[FD_CLOSE_BIT];
if(iCode == 0)
FireClose(this, SO_CLOSE, SE_OK);
else
FireClose(this, SO_CLOSE, iCode);
return FALSE;
}
BOOL CTcpClient::Stop()
{
BOOL bNeedFireClose = FALSE;
EnServiceState enCurState = m_enState;
DWORD dwCurrentThreadID = ::GetCurrentThreadId();
if(!CheckStoping())
return FALSE;
if(enCurState == SS_STARTED && dwCurrentThreadID != m_dwWorkerID)
bNeedFireClose = TRUE;
WaitForWorkerThreadEnd(dwCurrentThreadID);
if(bNeedFireClose)
FireClose(m_dwConnID);
if(m_evSocket != nullptr)
{
::WSACloseEvent(m_evSocket);
m_evSocket = nullptr;
}
if(m_soClient != INVALID_SOCKET)
{
shutdown(m_soClient, SD_SEND);
closesocket(m_soClient);
m_soClient = INVALID_SOCKET;
}
Reset();
return TRUE;
}
BOOL CUdpCast::Stop()
{
DWORD dwCurrentThreadID = ::GetCurrentThreadId();
if(!CheckStoping(dwCurrentThreadID))
return FALSE;
WaitForWorkerThreadEnd(dwCurrentThreadID);
if(m_ccContext.bFireOnClose)
FireClose(m_ccContext.enOperation, m_ccContext.iErrorCode);
if(m_evSocket != nullptr)
{
::WSACloseEvent(m_evSocket);
m_evSocket = nullptr;
}
if(m_soClient != INVALID_SOCKET)
{
shutdown(m_soClient, SD_SEND);
closesocket(m_soClient);
m_soClient = INVALID_SOCKET;
}
Reset();
return TRUE;
}
BOOL CUdpClient::HandleConnect(WSANETWORKEVENTS& events)
{
BOOL bContinue = TRUE;
int iCode = events.iErrorCode[FD_CONNECT_BIT];
if(iCode == 0)
{
if(::WSAEventSelect(m_soClient, m_evSocket, FD_READ | FD_WRITE | FD_CLOSE) != SOCKET_ERROR)
{
if(FireConnect(this) != HR_ERROR)
{
VERIFY(NeedDetectorThread() || DetectConnection() == NO_ERROR);
m_enState = SS_STARTED;
}
else
iCode = ERROR_CANCELLED;
}
else
iCode = ::WSAGetLastError();
}
if(iCode != 0)
{
if(iCode != ERROR_CANCELLED)
FireClose(this, SO_CONNECT, iCode);
bContinue = FALSE;
}
return bContinue;
}
void CUdpServer::CloseClientSocketObj(TUdpSocketObj* pSocketObj, EnSocketCloseFlag enFlag, EnSocketOperation enOperation, int iErrorCode)
{
ASSERT(TUdpSocketObj::IsExist(pSocketObj));
if(enFlag == SCF_CLOSE)
FireClose(pSocketObj->connID);
else if(enFlag == SCF_ERROR)
FireError(pSocketObj->connID, enOperation, iErrorCode);
}
void CUdpServer::ForceDisconnect(CONNID dwConnID)
{
TUdpSocketObj* pSocketObj = FindSocketObj(dwConnID);
if(pSocketObj != nullptr)
{
FireClose(dwConnID);
AddFreeSocketObj(dwConnID);
}
}
void CTcpAgent::CloseClientSocketObj(TSocketObj* pSocketObj, EnSocketCloseFlag enFlag, EnSocketOperation enOperation, int iErrorCode, int iShutdownFlag)
{
ASSERT(TSocketObj::IsExist(pSocketObj));
if(enFlag == SCF_CLOSE)
FireClose(pSocketObj->connID);
else if(enFlag == SCF_ERROR)
FireError(pSocketObj->connID, enOperation, iErrorCode);
::ManualCloseSocket(pSocketObj->socket, iShutdownFlag);
}
BOOL CUdpClient::SendData()
{
while(TRUE)
{
TItemPtr itPtr(m_itPool, GetSendBuffer());
if(itPtr.IsValid())
{
ASSERT(!itPtr->IsEmpty());
int rc = 0;
{
CCriSecLock locallock(m_csSend);
rc = send(m_soClient, (char*)itPtr->Ptr(), itPtr->Size(), 0);
if(rc > 0) m_iPending -= rc;
}
if(rc > 0)
{
ASSERT(rc == itPtr->Size());
if(FireSend(this, itPtr->Ptr(), rc) == HR_ERROR)
{
TRACE("<C-CNNID: %Iu> OnSend() event should not return 'HR_ERROR' !!\n", m_dwConnID);
ASSERT(FALSE);
}
}
else if(rc == SOCKET_ERROR)
{
int iCode = ::WSAGetLastError();
if(iCode == WSAEWOULDBLOCK)
{
CCriSecLock locallock(m_csSend);
m_lsSend.PushFront(itPtr.Detach());
break;
}
else
{
FireClose(this, SO_SEND, iCode);
return FALSE;
}
}
else
ASSERT(FALSE);
}
else
break;
}
return TRUE;
}
BOOL CUdpClient::ReadData()
{
while(TRUE)
{
int rc = recv(m_soClient, (char*)(BYTE*)m_rcBuffer, m_dwMaxDatagramSize, 0);
if(rc > 0)
{
if(FireReceive(this, m_rcBuffer, rc) == HR_ERROR)
{
TRACE("<C-CNNID: %Iu> OnReceive() event return 'HR_ERROR', connection will be closed !\n", m_dwConnID);
FireClose(this, SO_RECEIVE, ERROR_CANCELLED);
return FALSE;
}
}
else if(rc == SOCKET_ERROR)
{
int code = ::WSAGetLastError();
if(code == WSAEWOULDBLOCK)
break;
else
{
FireClose(this, SO_RECEIVE, code);
return FALSE;
}
}
else if(rc == 0)
{
m_dwDetectFails = 0;
TRACE("<C-CNNID: %Iu> recv 0 bytes (detect package)\n", m_dwConnID);
}
else
ASSERT(FALSE);
}
return TRUE;
}
void CTcpServer::CloseClientSocketObj(TSocketObj* pSocketObj, EnSocketCloseFlag enFlag, EnSocketOperation enOperation, int iErrorCode, int iShutdownFlag)
{
ASSERT(TSocketObj::IsExist(pSocketObj));
if(enFlag == SCF_CLOSE)
FireClose(pSocketObj);
else if(enFlag == SCF_ERROR)
FireError(pSocketObj, enOperation, iErrorCode);
SOCKET socket = pSocketObj->socket;
pSocketObj->socket = INVALID_SOCKET;
::ManualCloseSocket(socket, iShutdownFlag);
}
BOOL CUdpClient::HandleWrite(WSANETWORKEVENTS& events)
{
BOOL bContinue = TRUE;
int iCode = events.iErrorCode[FD_WRITE_BIT];
if(iCode == 0)
bContinue = SendData();
else
{
FireClose(this, SO_SEND, iCode);
bContinue = FALSE;
}
return bContinue;
}
BOOL CUdpClient::HandleRead(WSANETWORKEVENTS& events)
{
BOOL bContinue = TRUE;
int iCode = events.iErrorCode[FD_READ_BIT];
if(iCode == 0)
bContinue = ReadData();
else
{
FireClose(this, SO_RECEIVE, iCode);
bContinue = FALSE;
}
return bContinue;
}
void CIocpServer::HandleIo(TSocketObj* pSocketObj, TBufferObj* pBufferObj, DWORD dwBytes, DWORD dwErrorCode)
{
ASSERT(pBufferObj != NULL);
ASSERT(pSocketObj != NULL);
//判断是否已经标记失败
if(dwErrorCode != NO_ERROR)
{
if(pBufferObj->operation != SO_ACCEPT)
{
FireError(pSocketObj->connID, pBufferObj->operation, dwErrorCode);
AddFreeSocketObj(pSocketObj->connID);
}
else
{
DeleteAcceptSocket(pBufferObj->client, TRUE);
}
AddFreeBufferObj(pBufferObj);
return;
}
if(dwBytes == 0 && pBufferObj->operation != SO_ACCEPT)
{
FireClose(pSocketObj->connID);
AddFreeSocketObj(pSocketObj->connID);
AddFreeBufferObj(pBufferObj);
return;
}
pBufferObj->buff.len = dwBytes;
switch(pBufferObj->operation)
{
case SO_ACCEPT:
HandleAccept((SOCKET)pSocketObj, pBufferObj);
break;
case SO_SEND:
HandleSend(pSocketObj, pBufferObj);
break;
case SO_RECEIVE:
HandleReceive(pSocketObj, pBufferObj);
break;
default:
ASSERT(FALSE);
}
}
BOOL CUdpClient::HandleError(WSANETWORKEVENTS& events)
{
int iCode = ::WSAGetLastError();
EnSocketOperation enOperation = SO_UNKNOWN;
if(events.lNetworkEvents & FD_CONNECT)
enOperation = SO_CONNECT;
else if(events.lNetworkEvents & FD_CLOSE)
enOperation = SO_CLOSE;
else if(events.lNetworkEvents & FD_READ)
enOperation = SO_RECEIVE;
else if(events.lNetworkEvents & FD_WRITE)
enOperation = SO_SEND;
VERIFY(::WSAResetEvent(m_evSocket));
FireClose(this, enOperation, iCode);
return FALSE;
}
BOOL CTcpClient::ReadData()
{
while(TRUE)
{
int rc = recv(m_soClient, (char*)(BYTE*)m_rcBuffer, m_dwSocketBufferSize, 0);
if(rc > 0)
{
if(FireReceive(m_dwConnID, m_rcBuffer, rc) == HR_ERROR)
{
TRACE("<C-CNNID: %Iu> OnReceive() event return 'HR_ERROR', connection will be closed !\n", m_dwConnID);
SetLastError(SE_DATA_PROC, __FUNCTION__, ERROR_FUNCTION_FAILED);
FireError(m_dwConnID, SO_RECEIVE, ERROR_FUNCTION_FAILED);
return FALSE;
}
}
else if(rc == SOCKET_ERROR)
{
int code = ::WSAGetLastError();
if(code == WSAEWOULDBLOCK)
break;
else
{
SetLastError(SE_NETWORK, __FUNCTION__, code);
FireError(m_dwConnID, SO_RECEIVE, code);
return FALSE;
}
}
else if(rc == 0)
{
FireClose(m_dwConnID);
return FALSE;
}
else
ASSERT(FALSE);
}
return TRUE;
}
BOOL CUdpClient::HandleClosse(WSANETWORKEVENTS& events)
{
int iCode = events.iErrorCode[FD_CLOSE_BIT];
if(iCode == 0)
FireClose(this);
else
{
EnSocketOperation enOperation = events.lNetworkEvents & FD_READ ? SO_RECEIVE :
(
events.lNetworkEvents & FD_WRITE ? SO_SEND :
(events.lNetworkEvents & FD_CONNECT ? SO_CONNECT : SO_UNKNOWN)
);
SetLastError(SE_NETWORK, __FUNCTION__, iCode);
FireError(this, enOperation, iCode);
}
return FALSE;
}
BOOL CTcpClient::Stop()
{
if(!CheckStoping())
return FALSE;
SetConnected(FALSE);
WaitForWorkerThreadEnd();
if(m_ccContext.bFireOnClose)
FireClose(m_ccContext.enOperation, m_ccContext.iErrorCode);
if(m_soClient != INVALID_SOCKET)
{
shutdown(m_soClient, SHUT_WR);
closesocket(m_soClient);
m_soClient = INVALID_SOCKET;
}
Reset();
return TRUE;
}
EnHandleResult CTcpServer::TriggerFireClose(TSocketObj* pSocketObj, EnSocketOperation enOperation, int iErrorCode)
{
CReentrantSpinLock locallock(pSocketObj->csRecv);
return FireClose(pSocketObj, enOperation, iErrorCode);
}
BOOL CTcpClient::ProcessNetworkEvent()
{
BOOL bContinue = TRUE;
WSANETWORKEVENTS events;
int rc = ::WSAEnumNetworkEvents(m_soClient, m_evSocket, &events);
if(rc == SOCKET_ERROR)
{
int code = ::WSAGetLastError();
SetLastError(SE_NETWORK, __FUNCTION__, code);
VERIFY(::WSAResetEvent(m_evSocket));
FireError(m_dwConnID, SO_UNKNOWN, code);
bContinue = FALSE;
}
if(bContinue && events.lNetworkEvents & FD_READ)
{
int iCode = events.iErrorCode[FD_READ_BIT];
if(iCode == 0)
bContinue = ReadData();
else
{
SetLastError(SE_NETWORK, __FUNCTION__, iCode);
FireError(m_dwConnID, SO_RECEIVE, iCode);
bContinue = FALSE;
}
}
if(bContinue && events.lNetworkEvents & FD_WRITE)
{
int iCode = events.iErrorCode[FD_WRITE_BIT];
if(iCode == 0)
bContinue = SendData();
else
{
SetLastError(SE_NETWORK, __FUNCTION__, iCode);
FireError(m_dwConnID, SO_SEND, iCode);
bContinue = FALSE;
}
}
if(m_bAsyncConnect && bContinue && events.lNetworkEvents & FD_CONNECT)
{
int iCode = events.iErrorCode[FD_CONNECT_BIT];
if(iCode == 0)
{
if(::WSAEventSelect(m_soClient, m_evSocket, FD_READ | FD_WRITE | FD_CLOSE) != SOCKET_ERROR)
{
if(FireConnect(m_dwConnID) != HR_ERROR)
m_enState = SS_STARTED;
else
iCode = ERROR_FUNCTION_FAILED;
}
else
iCode = ::WSAGetLastError();
}
if(iCode != 0)
{
SetLastError(SE_NETWORK, __FUNCTION__, iCode);
FireError(m_dwConnID, SO_CONNECT, iCode);
bContinue = FALSE;
}
}
if(bContinue && events.lNetworkEvents & FD_CLOSE)
{
int iCode = events.iErrorCode[FD_CLOSE_BIT];
if(iCode == 0)
FireClose(m_dwConnID);
else
{
SetLastError(SE_NETWORK, __FUNCTION__, iCode);
FireError(m_dwConnID, SO_UNKNOWN, iCode);
}
bContinue = FALSE;
}
return bContinue;
}
