BOOL CNetPTCPConnection::OnEpollEvent(UINT EventID)
{
if(m_Socket.IsConnected())
{
if(EventID&(EPOLLERR|EPOLLHUP))
{
PrintNetLog(0xffffffff,"CNetPTCPConnection::Epoll发生错误%d！",errno);
Disconnect();
return TRUE;
}
if(EventID&EPOLLIN)
{
DoRecv();
}
if(EventID&EPOLLOUT)
{
DoSend();
}
}
else
{
PrintNetLog(0xffffffff,"(%d)Connection未连接，Epoll事件被忽略！",GetID());
}
return FALSE;
}
void
EasyIocp::DoAcceptWithData(CompListenKey *listenKey, int index, EasyIocpBuffer *iocpBuffer, sockaddr_in *serverAddr, sockaddr_in *clientAddr)
{
//acceptSock是用来和客户端进行收发数据的socket
SOCKET acceptSock = listenKey->GetOneAcceptSock(index);
if(acceptSock == INVALID_SOCKET) {
print("EasyIocp::DoAcceptWithData: acceptSock is INVALID_SOCKET.");
return;
}
CompTransmitKey *transKey = easyClients_.NewClient(acceptSock, serverAddr, clientAddr);
if(!transKey) {
print("EasyIocp::DoAcceptWithData: invalid transKey.");
return;
}
//关联套接字与完成端口
if(!CreateIoCompletionPort((HANDLE)acceptSock, hCompPort_, (ULONG_PTR)transKey, 0)) {
ErrorSysMessage("EasyIocp::DoAcceptWithData: associate socket failed.");
easyClients_.RemoveClient(acceptSock);
return;
}
transKey->SetOperType(operRecv);
EasyIocpBuffer *transBuffer = transKey->GetBuffer();
transBuffer->operator=(*iocpBuffer);
DoRecv(transKey, iocpBuffer->GetTransBytes());
}
bool Connection::OnConnected() {
#ifdef _DEBUG
_establish = true;
#endif
if (DoRecv()) {
_session->OnConnected(Kernel::Instance());
_recving = true;
return true;
}
return false;
}
int
ssl_SecureRecv(sslSocket *ss, unsigned char *buf, int len, int flags)
{
int rv = 0;
if (ss->shutdownHow & ssl_SHUTDOWN_RCV) {
PORT_SetError(PR_SOCKET_SHUTDOWN_ERROR);
return PR_FAILURE;
}
if (flags & ~PR_MSG_PEEK) {
PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
return PR_FAILURE;
}
if (!ssl_SocketIsBlocking(ss) && !ss->opt.fdx) {
ssl_GetXmitBufLock(ss);
if (ss->pendingBuf.len != 0) {
rv = ssl_SendSavedWriteData(ss);
if ((rv < 0) && (PORT_GetError() != PR_WOULD_BLOCK_ERROR)) {
ssl_ReleaseXmitBufLock(ss);
return SECFailure;
}
}
ssl_ReleaseXmitBufLock(ss);
}
rv = 0;
if (!PR_CLIST_IS_EMPTY(&ss->ssl3.hs.bufferedEarlyData)) {
PORT_Assert(ss->version >= SSL_LIBRARY_VERSION_TLS_1_3);
return tls13_Read0RttData(ss, buf, len);
}
/* If any of these is non-zero, the initial handshake is not done. */
if (!ss->firstHsDone) {
ssl_Get1stHandshakeLock(ss);
if (ss->handshake) {
rv = ssl_Do1stHandshake(ss);
}
ssl_Release1stHandshakeLock(ss);
}
if (rv < 0) {
return rv;
}
if (len == 0)
return 0;
rv = DoRecv(ss, (unsigned char *)buf, len, flags);
SSL_TRC(2, ("%d: SSL[%d]: recving %d bytes securely (errno=%d)",
SSL_GETPID(), ss->fd, rv, PORT_GetError()));
return rv;
}
int
ssl_SecureRecv(sslSocket *ss, unsigned char *buf, int len, int flags)
{
sslSecurityInfo *sec;
int rv = 0;
sec = &ss->sec;
if (ss->shutdownHow & ssl_SHUTDOWN_RCV) {
PORT_SetError(PR_SOCKET_SHUTDOWN_ERROR);
return PR_FAILURE;
}
if (flags & ~PR_MSG_PEEK) {
PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
return PR_FAILURE;
}
if (!ssl_SocketIsBlocking(ss) && !ss->opt.fdx) {
ssl_GetXmitBufLock(ss);
if (ss->pendingBuf.len != 0) {
rv = ssl_SendSavedWriteData(ss);
if ((rv < 0) && (PORT_GetError() != PR_WOULD_BLOCK_ERROR)) {
ssl_ReleaseXmitBufLock(ss);
return SECFailure;
}
/* XXX short write? */
}
ssl_ReleaseXmitBufLock(ss);
}
rv = 0;
/* If any of these is non-zero, the initial handshake is not done. */
if (!ss->firstHsDone) {
ssl_Get1stHandshakeLock(ss);
if (ss->handshake || ss->nextHandshake || ss->securityHandshake) {
rv = ssl_Do1stHandshake(ss);
}
ssl_Release1stHandshakeLock(ss);
}
if (rv < 0) {
return rv;
}
if (len == 0) return 0;
rv = DoRecv(ss, (unsigned char*) buf, len, flags);
SSL_TRC(2, ("%d: SSL[%d]: recving %d bytes securely (errno=%d)",
SSL_GETPID(), ss->fd, rv, PORT_GetError()));
return rv;
}
void CClient::Initialize()
{
if (g_startType == 0)
{
DoRecv();
m_bEstablished = true;
m_process.AddTotalOpen(1);
}
else
{
m_sockptr->DoConnect(g_remoteIP, g_remotePort, std::bind(& CClient::OnConnected, shared_from_this(), std::placeholders::_1));
}
}
void CSSLClientAsync::OnRecv()
{
if (GetSSLConnectStatus() == TRUE)
{
char szBuf[TCP_RECV_SIZE] = {0};
int32_t nRet = SSL_read(GetSSL(), szBuf, TCP_RECV_SIZE);
if (nRet > 0)
{
int32_t nBufSize = nRet;
char szIP[32] = {0};
int32_t nPort = 0;
S_GetPeerName(GetSocket(), szIP, &nPort);
DoRecv(GetSocketID(), szBuf, nBufSize, szIP, nPort);
}
else if (nRet == 0)
{
int32_t nErrorCode = SSL_get_error(GetSSL(), nRet);
if (SSL_ERROR_ZERO_RETURN == nErrorCode)
{
//对方关闭socket
SOCKET_IO_WARN("recv ssl data error, peer closed.");
DoException(GetSocketID(), SOCKET_IO_SSL_RECV_FAILED);
}
else
{
SOCKET_IO_ERROR("recv ssl data error.");
DoException(GetSocketID(), SOCKET_IO_SSL_RECV_FAILED);
}
}
else
{
int32_t nErrorCode = SSL_get_error(GetSSL(), nRet);
if (SSL_ERROR_WANT_READ == nErrorCode || SSL_ERROR_WANT_WRITE == nErrorCode)
{
//用select/epoll/iocp的方式应该很少会有这个情况出现
SOCKET_IO_DEBUG("recv ssl data error, buffer is blocking.");
}
else
{
SOCKET_IO_ERROR("recv ssl data error, errno: %d.", nErrorCode);
DoException(GetSocketID(), SOCKET_IO_SSL_RECV_FAILED);
}
}
}
else
{
SSLConnect();
}
}
int CTcpNetHandler::HandleEvent(int iConn, int iType) {
switch (iType) {
case TCP_SERVER_ACCEPT:
DoConn(iConn);
break;
case TCP_SERVER_READ:
DoRecv(iConn);
break;
case TCP_SERVER_SEND:
DoSend(iConn);
break;
case TCP_SERVER_CLOSE:
DoClose(iConn);
break;
}
return 0;
}
boost_ec UdpPointImpl::goStart(endpoint local_endpoint)
{
if (init_) return MakeNetworkErrorCode(eNetworkErrorCode::ec_estab);
try {
socket_.reset(new udp::socket(GetUdpIoService(), udp::endpoint(local_endpoint)));
} catch (boost::system::system_error& e) {
return e.code();
}
boost_ec ignore_ec;
local_addr_ = endpoint(socket_->local_endpoint(ignore_ec), local_endpoint.ext());
init_ = true;
auto this_ptr = this->shared_from_this();
go_dispatch(egod_robin) [this_ptr] {
this_ptr->DoRecv();
};
return boost_ec();
}
void CClient::OnRecv(zsummer::network::ErrorCode ec, int nRecvedLen)
{
if (ec)
{
LOGD("remote socket closed");
OnClose();
return;
}
m_recving._len += nRecvedLen;
int needRecv = zsummer::protocol4z::CheckBuffIntegrity(m_recving._orgdata, m_recving._len, _MSG_BUF_LEN);
if ( needRecv == -1)
{
LOGD("killed socket: CheckBuffIntegrity error ");
m_sockptr->DoClose();
OnClose();
return;
}
if (needRecv > 0)
{
m_sockptr->DoRecv(m_recving._orgdata+m_recving._len, needRecv, std::bind(&CClient::OnRecv, shared_from_this(), std::placeholders::_1, std::placeholders::_2));
return ;
}
//! 解包完成 进行消息处理
zsummer::protocol4z::ReadStream rs(m_recving._orgdata, m_recving._len);
try
{
MessageEntry(rs);
}
catch (std::runtime_error e)
{
LOGD("MessageEntry catch one exception: "<< e.what() );
m_sockptr->DoClose();
OnClose();
return ;
}
m_process.AddTotalRecvLen(m_recving._len);
m_process.AddTotalRecvCount(1);
//! 继续收包
DoRecv();
}
void CClient::OnConnected(zsummer::network::ErrorCode ec)
{
if (ec)
{
LOGD("OnConnected failed. ec=" << ec);
return;
}
LOGD("OnConnected success");
DoRecv();
m_bEstablished = true;
m_process.AddTotalOpen(1);
if (g_intervalMs > 0)
{
m_process.GetZSummer().CreateTimer(g_intervalMs, std::bind(&CClient::SendOnce, shared_from_this()));
}
else
{
SendOnce();
}
}
void CTcpSocket::OnRecv( const system::error_code& ec, size_t nByteTransferred )
{
if (ec)
{
LOGError(ec.message().c_str());
DoClose();
return ;
}
m_wHaveRecvLength += nByteTransferred;
// 黏包解析
USHORT wReadLength = 0; //解析长度修改都是完整消息包
while (true)
{
const char *pPacketHead = m_szRecvBuffer + wReadLength;
USHORT wRemainLength = m_wHaveRecvLength - wReadLength;
USHORT wReadPacketLength = ReadPacket(pPacketHead, wRemainLength);
if (wReadPacketLength > 0)
{
wReadLength += wReadPacketLength;
}
else
{
if ((wRemainLength > 0)
&& (wRemainLength != m_wHaveRecvLength))
{
memcpy(m_szRecvBuffer, m_szRecvBuffer+wReadLength, wRemainLength);
}
m_wHaveRecvLength = wRemainLength;
break;
}
}
DoRecv();
}
