void LLBC_IocpPoller::HandleEv_Monitor(LLBC_PollerEvent &ev)
{
// Wait return value.
const int waitRet = *reinterpret_cast<int *>(ev.un.monitorEv);
// Overlapped pointer.
int off = sizeof(int);
LLBC_POverlapped ol = *reinterpret_cast<LLBC_POverlapped *>(ev.un.monitorEv + off);
// Error No.
off += sizeof(LLBC_POverlapped);
int errNo = *reinterpret_cast<int *>(ev.un.monitorEv + off);
// Sub-Error No.
off += sizeof(int);
int subErrNo = *reinterpret_cast<int *>(ev.un.monitorEv + off);
LLBC_Free(ev.un.monitorEv);
if (HandleConnecting(waitRet, ol, errNo, subErrNo))
return;
_Sockets::iterator it = _sockets.find(ol->sock);
if (UNLIKELY(it == _sockets.end()))
{
if (ol->acceptSock != LLBC_INVALID_SOCKET_HANDLE)
LLBC_CloseSocket(ol->acceptSock);
if (ol->data)
LLBC_Delete(reinterpret_cast<LLBC_MessageBlock *>(ol->data));
LLBC_Delete(ol);
return;
}
LLBC_Session *session = it->second;
if (waitRet == LLBC_FAILED)
{
session->OnClose(ol, LLBC_New2(LLBC_SessionCloseInfo, errNo, subErrNo));
}
else
{
if (session->IsListen())
Accept(session, ol);
else if (ol->opcode == LLBC_OverlappedOpcode::Send)
session->OnSend(ol);
else if (ol->opcode == LLBC_OverlappedOpcode::Receive)
session->OnRecv(ol);
}
}
void NetClient::MyRun()
{
int socket_max_fd = notify_socket_fd_;
bool socket_set_changed = false;
std::map<int, void*> tcp_socket_map_tmp;
std::map<int, void*> udp_socket_map_tmp;
running_ = true;
while (running_)
{
if(notify_socket_fd_ > socket_max_fd)
{
socket_max_fd = notify_socket_fd_;
}
fd_set fds_read;
fd_set fds_write;
fd_set fds_error;
FD_ZERO(&fds_read);
FD_ZERO(&fds_write);
FD_ZERO(&fds_error);
FD_SET(notify_socket_fd_, &fds_read);
socket_map connecting_map_tmp;
lock_connecting_map_.Lock();
if (!connecting_map_.empty()) {
connecting_map_tmp = connecting_map_;
}
lock_connecting_map_.UnLock();
FillFdset(connecting_map_tmp, &fds_read, &fds_write, &fds_error, socket_max_fd, false);
FillFdset(tcp_socket_map_tmp, &fds_read, &fds_write, &fds_error, socket_max_fd, true);
FillFdset(udp_socket_map_tmp, &fds_read, NULL,/*&fds_write,*/ &fds_error, socket_max_fd, false);
int result = select(socket_max_fd+1, &fds_read, &fds_write, &fds_error, 0);
if (0 >= result)
{
//LogWARNING("select error: %s\r\n", strerror(errno));
//for( size_t i = 0; i < fds_error.fd_count; i++ )
//{
//LogWARNING("fd error fd:%u", fds_error.fd_array[i]);
//}
lock_tcp_map_.Lock();
tcp_socket_map_tmp = tcp_socket_map_;
lock_tcp_map_.UnLock();
lock_udp_map_.Lock();
udp_socket_map_tmp = udp_socket_map_;
lock_udp_map_.UnLock();
continue;
}
if (FD_ISSET(notify_socket_fd_, &fds_read))
{
char data;
uint32_t ip;
uint16_t port;
int nErrorCode = 0;
int nRet = RecvUdpData(notify_socket_fd_, &data, sizeof (char), ip, port);
if (nRet < 0 && !IsIgnoreSocketError_UDP(nErrorCode))
{
//ios re open the notify socket
LogINFO("Notify socket is closed.socket is:%d, error code is %d, error des:%s", notify_socket_fd_, nErrorCode, strerror(nErrorCode));
close_socket(notify_socket_fd_);
int nLocalSocket = CreatUdpSocket();
if (INVALID_SOCKET != nLocalSocket)
{
notify_socket_port_ = 0;
if (0 > Bind(nLocalSocket, ntohl(inet_addr("127.0.0.1")), notify_socket_port_))
{
close_socket(nLocalSocket);
}
else
{
notify_socket_fd_ = nLocalSocket;
LogINFO("Notify socket is opened ok!.%d", notify_socket_fd_);
}
}
}
if( NULL != timer_event_ && data == '1')
{
timer_event_->OnTimerEvent();
}
lock_tcp_map_.Lock();
tcp_socket_map_tmp = tcp_socket_map_;
lock_tcp_map_.UnLock();
lock_udp_map_.Lock();
udp_socket_map_tmp = udp_socket_map_;
lock_udp_map_.UnLock();
}
HandleConnecting(connecting_map_tmp, &fds_read, &fds_write, &fds_error);
HandleEvent(tcp_socket_map_tmp, &fds_read, &fds_write, &fds_error, HandleTcpSocketEvent);
HandleEvent(udp_socket_map_tmp, &fds_read, &fds_write, &fds_error, HandleUdpSocketEvent);
}
}
