TItem* CUdpCast::GetSendBuffer()
{
TItem* pItem = nullptr;
if(m_lsSend.Size() > 0)
{
CCriSecLock locallock(m_csSend);
if(m_lsSend.Size() > 0)
pItem = m_lsSend.PopFront();
}
return pItem;
}
TSocketObj* CTcpServer::FindSocketObj(CONNID dwConnID)
{
TSocketObj* pSocketObj = nullptr;
{
CReentrantReadLock locallock(m_csClientSocket);
TSocketObjPtrMapCI it = m_mpClientSocket.find(dwConnID);
if(it != m_mpClientSocket.end())
pSocketObj = it->second;
}
return pSocketObj;
}
BOOL CTcpAgent::CheckStoping()
{
CSpinLock locallock(m_csState);
if(m_enState == SS_STARTED || m_enState == SS_STARTING)
m_enState = SS_STOPPING;
else
{
SetLastError(SE_ILLEGAL_STATE, __FUNCTION__, ERROR_INVALID_OPERATION);
return FALSE;
}
return TRUE;
}
TBuffer* CBufferPool::FindCacheBuffer(ULONG_PTR dwID)
{
ASSERT(dwID != 0);
TBuffer* pBuffer = nullptr;
CReentrantReadLock locallock(m_csBufferMap);
TBufferPtrMapCI it = m_mpBuffer.find(dwID);
if(it != m_mpBuffer.end())
pBuffer = it->second;
return pBuffer;
}
void CTcpServer::ReleaseClientSocket()
{
CReentrantWriteLock locallock(m_csClientSocket);
for(TSocketObjPtrMapI it = m_mpClientSocket.begin(), end = m_mpClientSocket.end(); it != end; ++it)
{
TSocketObj* pSocketObj = it->second;
CloseClientSocketObj(pSocketObj);
DeleteSocketObj(pSocketObj);
}
m_mpClientSocket.clear();
}
BOOL CCookieMgr::RemoveExpiredCookies(LPCSTR lpszDomain, LPCSTR lpszPath)
{
CStringA strDomain;
CStringA strPath;
if(!AdjustDomainAndPath(lpszDomain, lpszPath, strDomain, strPath, TRUE))
return FALSE;
CWriteLock locallock(m_cs);
RemoveExpiredCookiesNoLock(lpszDomain, lpszPath);
return TRUE;
}
void CUdpServer::AddFreeSocketObj(CONNID dwConnID, EnSocketCloseFlag enFlag, EnSocketOperation enOperation, int iErrorCode)
{
BOOL bDone = FALSE;
TUdpSocketObj* pSocketObj = FindSocketObj(dwConnID);
if(TUdpSocketObj::IsValid(pSocketObj))
{
CCriSecLock locallock(pSocketObj->crisec);
if(TUdpSocketObj::IsValid(pSocketObj))
{
TUdpSocketObj::Invalid(pSocketObj);
bDone = TRUE;
}
}
if(bDone)
{
CloseClientSocketObj(pSocketObj, enFlag, enOperation, iErrorCode);
TUdpSocketObj::Release(pSocketObj);
{
CReentrantWriteLock locallock(m_csClientSocket);
m_mpClientAddr.erase(&pSocketObj->remoteAddr);
m_mpClientSocket.erase(dwConnID);
}
{
CCriSecLock locallock(m_csFreeSocket);
m_lsFreeSocket.push_back(pSocketObj);
}
if(m_lsFreeSocket.size() > m_dwFreeSocketObjHold)
CompressFreeSocket(m_dwFreeSocketObjPool);
}
}
TSocketObj* CIocpServer::GetFreeSocketObj()
{
CCriSecLock locallock(m_csFreeSocket);
TSocketObj* pSocketObj = NULL;
if(m_lsFreeSocket.size() > 0)
{
pSocketObj = m_lsFreeSocket.front();
m_lsFreeSocket.pop_front();
}
else
pSocketObj = CreateSocketObj();
return pSocketObj;
}
BOOL CCookieMgr::GetCookies(CCookieSet& cookies, LPCSTR lpszDomain, LPCSTR lpszPath, BOOL bHttp, BOOL bSecure)
{
ASSERT(lpszDomain && lpszPath);
CStringA strDomain;
CStringA strPath;
if(!AdjustDomainAndPath(lpszDomain, lpszPath, strDomain, strPath, FALSE))
return FALSE;
list<LPCSTR> lsDomains(1, lpszDomain);
list<CStringA> lsPaths(1, lpszPath);
char c;
LPCSTR lpszTemp = lpszDomain;
while((c = *(++lpszTemp)) != 0)
{
if(c == COOKIE_DOMAIN_SEP_CHAR)
{
if((c = *(++lpszTemp)) != 0)
lsDomains.push_back(lpszTemp);
else
break;
}
}
lpszTemp = lpszPath + strlen(lpszPath) - 1;
while(--lpszTemp >= lpszPath)
{
if((c = *lpszTemp) == COOKIE_PATH_SEP_CHAR)
{
*(LPSTR)(lpszTemp + 1) = 0;
lsPaths.push_back(lpszPath);
}
}
CReadLock locallock(m_cs);
for(list<LPCSTR>::const_iterator it = lsDomains.begin(), end = lsDomains.end(); it != end; ++it)
{
for(list<CStringA>::const_iterator it2 = lsPaths.begin(), end2 = lsPaths.end(); it2 != end2; ++it2)
MatchCookiesNoLock(cookies, *it, *it2, bHttp, bSecure);
}
return TRUE;
}
EnHandleResult CTcpServer::TriggerFireReceive(TSocketObj* pSocketObj, TBufferObj* pBufferObj)
{
EnHandleResult rs = (EnHandleResult)HR_CLOSED;
if(TSocketObj::IsValid(pSocketObj))
{
CReentrantSpinLock locallock(pSocketObj->csRecv);
if(TSocketObj::IsValid(pSocketObj))
{
rs = FireReceive(pSocketObj, (BYTE*)pBufferObj->buff.buf, pBufferObj->buff.len);
}
}
return rs;
}
void CBufferPool::PutFreeBuffer(ULONG_PTR dwID)
{
ASSERT(dwID != 0);
TBuffer* pBuffer = FindCacheBuffer(dwID);
if(pBuffer != nullptr)
{
{
CReentrantWriteLock locallock(m_csBufferMap);
m_mpBuffer.erase(dwID);
}
PutFreeBuffer(pBuffer);
}
}
void CTcpServer::CompressFreeSocket(size_t size, BOOL bForce)
{
CCriSecLock locallock(m_csFreeSocket);
while(m_lsFreeSocket.size() > size)
{
TSocketObj* pSocketObj = m_lsFreeSocket.front();
if(bForce || ::GetTimeGap32(pSocketObj->freeTime) >= m_dwFreeSocketObjLockTime)
{
m_lsFreeSocket.pop_front();
DeleteSocketObj(pSocketObj);
}
else
break;
}
}
int CTcpAgent::DoSendPack(TSocketObj* pSocketObj)
{
int result = NO_ERROR;
if(TSocketObj::IsPending(pSocketObj))
{
CCriSecLock locallock(pSocketObj->crisec);
if(TSocketObj::IsValid(pSocketObj))
result = SendItem(pSocketObj);
}
if(!IOCP_SUCCESS(result))
CheckError(pSocketObj->connID, SO_SEND, result);
return result;
}
CBufferPtr* CClientSocket::GetSendBuffer()
{
CBufferPtr* pBuffer = nullptr;
if(m_sndBuffers.Size() > 0)
{
CCriSecLock locallock(m_scBuffer);
if(m_sndBuffers.Size() > 0)
{
pBuffer = m_sndBuffers->front();
m_sndBuffers->pop_front();
}
}
return pBuffer;
}
void CItemPool::PutFreeItem(TItem* pItem)
{
ASSERT(pItem != nullptr);
DWORD size = m_lsFreeItem.Size();
if(size < m_dwPoolHold)
{
CCriSecLock locallock(m_csFreeItem);
m_lsFreeItem.PushBack(pItem);
}
else
{
TItem::Destruct(pItem);
CompressFreeItem(m_dwPoolSize);
}
}
BOOL CUdpCast::CheckStarting()
{
CCriSecLock locallock(m_csCheck);
if(m_enState == SS_STOPPED)
{
m_enState = SS_STARTING;
::_ReadWriteBarrier();
}
else
{
SetLastError(SE_ILLEGAL_STATE, __FUNCTION__, ERROR_INVALID_OPERATION);
return FALSE;
}
return TRUE;
}
int CUdpServer::DoSendPack(TUdpSocketObj* pSocketObj)
{
int result = NO_ERROR;
if(TUdpSocketObj::IsPending(pSocketObj))
{
CCriSecLock locallock(pSocketObj->crisec);
if(TUdpSocketObj::IsValid(pSocketObj))
result = SendItem(pSocketObj);
}
if(!IOCP_SUCCESS(result))
VERIFY(!HasStarted());
return result;
}
BOOL CTcpServer::InvalidSocketObj(TSocketObj* pSocketObj)
{
BOOL bDone = FALSE;
if(TSocketObj::IsValid(pSocketObj))
{
CReentrantSpinLock locallock(pSocketObj->csRecv);
CCriSecLock locallock2(pSocketObj->csSend);
if(TSocketObj::IsValid(pSocketObj))
{
TSocketObj::Invalid(pSocketObj);
bDone = TRUE;
}
}
return bDone;
}
VOID CSEMRWLock::ReadDone()
{
ASSERT(m_nActive != 0);
INT iFlag = 0;
if(m_nActive > 0)
{
CSpinLock locallock(m_cs);
if(--m_nActive == 0)
iFlag = Done();
}
else
ASSERT(IsOwner());
Notify(iFlag);
}
TBufferObj* CIocpServer::GetFreeBufferObj(int iLen)
{
if(iLen <= 0) iLen = m_dwIocpBufferSize;
CCriSecLock locallock(m_csFreeBuffer);
TBufferObj* pBufferObj = NULL;
if(m_lsFreeBuffer.size() > 0)
{
pBufferObj = m_lsFreeBuffer.front();
m_lsFreeBuffer.pop_front();
}
else
pBufferObj = CreateBufferObj();
pBufferObj->buff.len = iLen;
return pBufferObj;
}
VOID CSWMR::WaitToWrite()
{
BOOL fResourceOwned;
{
CSpinLock locallock(m_cs);
fResourceOwned = (m_nActive != 0);
if(fResourceOwned)
++m_nWaitingWriters;
else
m_nActive = -1;
}
if(fResourceOwned)
m_smWrite.Wait();
}
VOID CSWMR::WaitToRead()
{
BOOL fResourceWritePending;
{
CSpinLock locallock(m_cs);
fResourceWritePending = (m_nWaitingWriters || (m_nActive < 0));
if(fResourceWritePending)
++m_nWaitingReaders;
else
++m_nActive;
}
if(fResourceWritePending)
m_smRead.Wait();
}
template<class T, USHORT default_port> BOOL CHttpAgentT<T, default_port>::StartHttp(TSocketObj* pSocketObj)
{
if(!pSocketObj->HasConnected())
{
::SetLastError(ERROR_INVALID_STATE);
return FALSE;
}
CCriSecLock locallock(pSocketObj->csSend);
if(!TSocketObj::IsValid(pSocketObj))
{
::SetLastError(ERROR_OBJECT_NOT_FOUND);
return FALSE;
}
if(!pSocketObj->HasConnected())
{
::SetLastError(ERROR_INVALID_STATE);
return FALSE;
}
THttpObj* pHttpObj = FindHttpObj(pSocketObj);
if(pHttpObj != nullptr)
{
::SetLastError(ERROR_ALREADY_INITIALIZED);
return FALSE;
}
DoStartHttp(pSocketObj);
if(!IsSecure())
FireHandShake(pSocketObj);
else
{
#ifdef _SSL_SUPPORT
if(IsSSLAutoHandShake())
StartSSLHandShake(pSocketObj);
#endif
}
return TRUE;
}
void CBufferPool::CompressFreeBuffer(int size)
{
CCriSecLock locallock(m_csFreeBuffer);
DWORD now = ::TimeGetTime();
while(m_lsFreeBuffer.Size() > size)
{
TBuffer* pBuffer = m_lsFreeBuffer.Front();
if(now - pBuffer->freeTime >= m_dwBufferLockTime)
{
m_lsFreeBuffer.PopFront();
TBuffer::Destruct(pBuffer);
}
else
break;
}
}
VOID CMutexRWLock::ReadDone()
{
ASSERT(m_nActive != 0);
if(m_nActive > 0)
{
ASSERT(m_nReadCount > 0);
CSpinLock locallock(m_cs);
if(--m_nActive == 0)
{
for(; m_nReadCount > 0; --m_nReadCount)
m_mtx.unlock_shared();
}
}
else
ASSERT(IsOwner());
}
TItem* CItemPool::PickFreeItem()
{
TItem* pItem = nullptr;
if(m_lsFreeItem.Size() > 0)
{
CCriSecLock locallock(m_csFreeItem);
if(m_lsFreeItem.Size() > 0)
pItem = m_lsFreeItem.PopFront();
}
if(pItem == nullptr)
pItem = TItem::Construct(m_heap, m_dwItemCapacity);
else
pItem->Reset();
return pItem;
}
VOID CSEMRWLock::WriteDone()
{
ASSERT(IsOwner());
ASSERT(m_nActive < 0);
INT iFlag = 0;
{
CSpinLock locallock(m_cs);
if(++m_nActive == 0)
{
DetachOwner();
iFlag = Done();
}
}
Notify(iFlag);
}
void CTcpClient::Reset()
{
CCriSecLock locallock(m_csSend);
m_evSend.Reset();
m_evRecv.Reset();
m_evStop.Reset();
m_lsSend.Clear();
m_itPool.Clear();
m_rcBuffer.Free();
m_strHost.Empty();
m_usPort = 0;
m_nEvents = 0;
m_bPaused = FALSE;
m_enState = SS_STOPPED;
}
void CTcpAgent::CompressFreeSocket(size_t size, BOOL bForce)
{
CCriSecLock locallock(m_csFreeSocket);
DWORD now = ::TimeGetTime();
while(m_lsFreeSocket.size() > size)
{
TSocketObj* pSocketObj = m_lsFreeSocket.front();
if(bForce || (now - pSocketObj->freeTime) >= m_dwFreeSocketObjLockTime)
{
m_lsFreeSocket.pop_front();
DeleteSocketObj(pSocketObj);
}
else
break;
}
}
BOOL CTcpClient::DoSendData(TItem* pItem)
{
while(!pItem->IsEmpty())
{
int rc = 0;
{
CCriSecLock locallock(m_csSend);
rc = send(m_soClient, (char*)pItem->Ptr(), min(pItem->Size(), (int)m_dwSocketBufferSize), 0);
if(rc > 0) m_iPending -= rc;
}
if(rc > 0)
{
if(FireSend(this, pItem->Ptr(), rc) == HR_ERROR)
{
TRACE("<C-CNNID: %Iu> OnSend() event should not return 'HR_ERROR' !!\n", m_dwConnID);
ASSERT(FALSE);
}
pItem->Reduce(rc);
}
else if(rc == SOCKET_ERROR)
{
int code = ::WSAGetLastError();
if(code == WSAEWOULDBLOCK)
break;
else
{
SetLastError(SE_NETWORK, __FUNCTION__, code);
FireError(this, SO_SEND, code);
return FALSE;
}
}
else
ASSERT(FALSE);
}
return TRUE;
}
