void CRealControlSocket::OnSocketEvent(wxSocketEvent &event)
{
if (!m_pBackend)
return;
if (event.GetId() != m_pBackend->GetId())
return;
switch (event.GetSocketEvent())
{
case wxSOCKET_CONNECTION:
m_onConnectCalled = true;
OnConnect();
break;
case wxSOCKET_INPUT:
if (!m_onConnectCalled)
{
m_onConnectCalled = true;
OnConnect();
}
OnReceive();
break;
case wxSOCKET_OUTPUT:
OnSend();
break;
case wxSOCKET_LOST:
OnClose();
break;
}
}
void QmitkNDIConfigurationWidget::UpdateWidgets()
{
m_Controls->m_DeviceStatus->setText(this->GetStatusText());
if (m_Tracker.IsNull()) // not connected to tracker
{
m_Controls->m_Connect->setText("Connect");
m_Controls->m_lConnection->setText("III. Enable connection to device ");
disconnect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnDisconnect()));
connect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()));
m_Controls->m_DiscoverToolsBtn->setDisabled(true);
m_Controls->m_AddToolBtn->setDisabled(true);
return;
}
if (m_Tracker->GetState() == mitk::TrackingDevice::Setup)
{
m_Controls->m_Connect->setText("Connect");
m_Controls->m_lConnection->setText("III. Enable connection to device ");
disconnect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnDisconnect()));
connect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()));
m_Controls->m_DiscoverToolsBtn->setDisabled(true);
m_Controls->m_AddToolBtn->setDisabled(true);
return;
}
if ((m_Tracker->GetState() == mitk::TrackingDevice::Ready) || (m_Tracker->GetState() == mitk::TrackingDevice::Tracking))
{
m_Controls->m_Connect->setText("Disconnect");
m_Controls->m_lConnection->setText("III. Disable connection to device ");
disconnect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()));
connect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnDisconnect()));
m_Controls->m_DiscoverToolsBtn->setEnabled(true);
m_Controls->m_AddToolBtn->setEnabled(true);
}
}
static BOOL OnCommand(PWLAN_INFO psWLanInfo, WPARAM wParam)
{
BOOL fRet = TRUE;
INT nItemSelected;
nItemSelected = ListView_GetNextItem(psWLanInfo->hwndNetList, -1, LVNI_SELECTED);
switch(LOWORD(wParam))
{
case IDM_WZC_NETWORK_CONNECT:
OnConnect(psWLanInfo, nItemSelected);
break;
case IDS_WZC_ADD_NEW_SETTINGS:
OnAddNewSetting(psWLanInfo);
break;
case IDM_WZC_NETWORK_REMOVE:
OnRemoveSetting(psWLanInfo, nItemSelected);
break;
case IDM_WZC_NETWORK_PROPERTIES:
OnNetworkProperties(psWLanInfo, nItemSelected);
break;
case IDM_WZC_ADVANCED:
DialogBox(HINST_RESDLL, MAKEINTRESOURCE(IDD_WZC_WLAN_ADVANCED), psWLanInfo->hDlg, WZCWLanAdvancedDlgProc);
break;
case IDC_WZC_COMBO_FILTER:
if (HIWORD(wParam) == CBN_SELENDOK)
{
OnChangeNetFilter(psWLanInfo);
}
break;
case IDM_WZC_WIFI_POWERCMD:
OnChangePowerState(psWLanInfo);
break;
case IDOK:
// Since we're applying any changes when the dialog is deactivated, we
// don't need to apply here -- we'll get a deactivate right away.
break;
default:
if (LOWORD(wParam) >= IDM_WZC_MENU_EXT_FIRST && LOWORD(wParam) <= IDM_WZC_MENU_EXT_LAST)
{
SHInvokeContextMenuCommand(psWLanInfo->hwndNetList,
LOWORD(wParam),
psWLanInfo->hContextExt ? psWLanInfo->hContextExt : psWLanInfo->hSoftKeyExt);
}
else
{
fRet = FALSE;
}
}
return fRet;
}
bool CRedisClient::OnInit(std::string& address, int& port)
{
m_address = address;
m_port = port;
struct timeval timeout = { 1, 500000 }; // 1.5 seconds 首次链接
return OnConnect(&timeout);
}
bool STNetEngine::WINIO(int timeout)
{
#ifdef WIN32
STIocp::IO_EVENT e;
if ( !m_pNetMonitor->WaitEvent( e, timeout ) ) return false;
switch( e.type )
{
case STIocp::timeout :
break;
case STIocp::stop :
return false;
break;
case STIocp::connect :
OnConnect( e.client, false );
m_pNetMonitor->AddAccept( e.sock );
break;
case STIocp::recv :
OnData( e.sock, e.pData, e.uDataSize );
break;
case STIocp::close :
OnClose( e.sock );
break;
case STIocp::send :
OnSend( e.sock, e.uDataSize );
break;
default:
break;
}
return true;
#endif
return false;
}
void SessionHandler::WatchStream(int socketDescriptor, bool doWatch)
{
assert((m_fd != 0 && m_fd != socketDescriptor) == false); // only one stream for a socket
if (doWatch)
{
m_tracer.trace0("watching socket %d", socketDescriptor);
m_fd = socketDescriptor;
watch_readable(m_fd, true);
m_readBuffer = new char[m_bufferSize];
m_writeBuffer = new char[m_bufferSize];
m_bytesRead = 0;
m_bytesToWrite = 0;
OnConnect();
}
else if (m_fd != 0)
{
m_tracer.trace0("cleaning up");
watch_readable(m_fd, false);
watch_writable(m_fd, false);
delete [] m_readBuffer;
delete [] m_writeBuffer;
m_readBuffer = nullptr;
m_writeBuffer = nullptr;
m_fd = 0;
m_nextMessageLength = 0;
}
}
HWNewNet::HWNewNet() :
isChief(false),
m_game_connected(false),
netClientState(Disconnected)
{
m_private_game = false;
m_nick_registered = false;
m_roomsListModel = new RoomsListModel(this);
m_playersModel = new PlayersListModel(this);
m_lobbyPlayersModel = new QSortFilterProxyModel(this);
m_lobbyPlayersModel->setSourceModel(m_playersModel);
m_lobbyPlayersModel->setSortRole(PlayersListModel::SortRole);
m_lobbyPlayersModel->setDynamicSortFilter(true);
m_lobbyPlayersModel->sort(0);
m_roomPlayersModel = new QSortFilterProxyModel(this);
m_roomPlayersModel->setSourceModel(m_playersModel);
m_roomPlayersModel->setSortRole(PlayersListModel::SortRole);
m_roomPlayersModel->setDynamicSortFilter(true);
m_roomPlayersModel->sort(0);
m_roomPlayersModel->setFilterRole(PlayersListModel::RoomFilterRole);
m_roomPlayersModel->setFilterFixedString("true");
// socket stuff
connect(&NetSocket, SIGNAL(readyRead()), this, SLOT(ClientRead()));
connect(&NetSocket, SIGNAL(connected()), this, SLOT(OnConnect()));
connect(&NetSocket, SIGNAL(disconnected()), this, SLOT(OnDisconnect()));
connect(&NetSocket, SIGNAL(error(QAbstractSocket::SocketError)), this,
SLOT(displayError(QAbstractSocket::SocketError)));
connect(this, SIGNAL(messageProcessed()), this, SLOT(ClientRead()), Qt::QueuedConnection);
}
void CTransferSocket::OnAccept(int error)
{
m_pControlSocket->SetAlive();
m_pControlSocket->LogMessage(::Debug_Verbose, _T("CTransferSocket::OnAccept(%d)"), error);
if (!m_pSocketServer)
{
m_pControlSocket->LogMessage(::Debug_Warning, _T("No socket server in OnAccept"), error);
return;
}
m_pSocket = m_pSocketServer->Accept(error);
if (!m_pSocket)
{
if (error == EAGAIN)
m_pControlSocket->LogMessage(::Debug_Verbose, _T("No pending connection"));
else
{
m_pControlSocket->LogMessage(::Status, _("Could not accept connection: %s"), CSocket::GetErrorDescription(error).c_str());
TransferEnd(transfer_failure);
}
return;
}
delete m_pSocketServer;
m_pSocketServer = 0;
OnConnect();
}
// Processes pending accept.
void CNDKServer::ProcessPendingAccept(long lErrorCode)
{
if (lErrorCode == 0)
{
CNDKServerSocket* pSocket = new CNDKServerSocket(this);
if (pSocket != NULL)
{
BOOL bResult = FALSE;
if (m_pListeningSocket->Accept(*pSocket))
{
// Ask to accept the new connection
if (pSocket->Initialize() && OnIsConnectionAccepted())
{
OnConnect(m_userMgr.AddUser(pSocket));
bResult = TRUE;
}
}
if (!bResult)
delete pSocket;
}
}
}
void CNetworkConnection::initializeSocket()
{
m_pSocket->disconnect();
connect(m_pSocket, SIGNAL(connected()),
this, SIGNAL(connected()));
connect(m_pSocket, SIGNAL(connected()),
this, SIGNAL(readyToTransfer()));
connect(m_pSocket, SIGNAL(readyRead()),
this, SIGNAL(readyToTransfer()));
connect(m_pSocket, SIGNAL(disconnected()),
this, SIGNAL(disconnected()));
connect(m_pSocket, SIGNAL(error(QAbstractSocket::SocketError)),
this, SIGNAL(error(QAbstractSocket::SocketError)));
connect(m_pSocket, SIGNAL(bytesWritten(qint64)),
this, SIGNAL(bytesWritten(qint64)));
connect(m_pSocket, SIGNAL(stateChanged(QAbstractSocket::SocketState)),
this, SIGNAL(stateChanged(QAbstractSocket::SocketState)));
connect(m_pSocket, SIGNAL(aboutToClose()),
this, SLOT(OnAboutToClose()));
connect(this, SIGNAL(connected()), this, SLOT(OnConnect()), Qt::QueuedConnection);
connect(this, SIGNAL(disconnected()), this, SLOT(OnDisconnect()), Qt::QueuedConnection);
connect(this, SIGNAL(readyRead()), this, SLOT(OnRead()), Qt::QueuedConnection);
connect(this, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(OnError(QAbstractSocket::SocketError)), Qt::QueuedConnection);
connect(this, SIGNAL(stateChanged(QAbstractSocket::SocketState)), this, SLOT(OnStateChange(QAbstractSocket::SocketState)), Qt::QueuedConnection);
}
bool WorldServer::Start(QHostAddress address, quint16 port)
{
if(!m_server->listen(address, port))
return false;
connect(m_server, SIGNAL(newConnection()), this, SLOT(OnConnect()));
return true;
}
void Cube_SocketTCP_Server::run()
{
while (TRUE)
{
OnConnect(Accept());
}
}
void CG2Node::SetupSlots()
{
connect(this, SIGNAL(connected()), this, SLOT(OnConnect()), Qt::QueuedConnection);
connect(this, SIGNAL(disconnected()), this, SLOT(OnDisconnect()), Qt::QueuedConnection);
connect(this, SIGNAL(readyRead()), this, SLOT(OnRead()), Qt::QueuedConnection);
connect(this, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(OnError(QAbstractSocket::SocketError)), Qt::QueuedConnection);
connect(this, SIGNAL(stateChanged(QAbstractSocket::SocketState)), this, SLOT(OnStateChange(QAbstractSocket::SocketState)), Qt::QueuedConnection);
}
void QmitkNDIConfigurationWidget::CreateConnections()
{
connect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()));
connect(m_Controls->m_DiscoverToolsBtn, SIGNAL(clicked()), this, SLOT(OnDiscoverTools()));
connect(m_Controls->m_AddToolBtn, SIGNAL(clicked()), this, SLOT(OnAddPassiveTool()));
connect(m_Controls->m_DisoverDevicesBtn, SIGNAL(clicked()), this, SLOT(OnDiscoverDevices()));
connect(m_Controls->m_ToolTable->model(), SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this, SLOT(UpdateTrackerFromToolTable(const QModelIndex &, const QModelIndex &)));
connect(m_Controls->m_DisoverDevicesBtnInfo, SIGNAL(clicked()), this, SLOT(OnDisoverDevicesBtnInfo()));
}
HRESULT CMackieControlBase::Connect( IUnknown* pUnk, HWND hwndApp )
{
// TRACE("CMackieControlBase::Connect()\n");
// Note: You will probably not need to change this implementation.
// The wizard has already generated code to obtain all of the ISonarXXX
// interfaces that are available.
CCriticalSectionAuto csa( &m_cs );
HRESULT hr = S_OK;
releaseSonarInterfaces();
if (FAILED( hr = pUnk->QueryInterface( IID_ISonarMidiOut, (void**)&m_pMidiOut ) ))
return hr;
if (FAILED( hr = pUnk->QueryInterface( IID_ISonarKeyboard, (void**)&m_pKeyboard ) ))
return hr;
if (FAILED( hr = pUnk->QueryInterface( IID_ISonarCommands, (void**)&m_pCommands ) ))
return hr;
if (FAILED( hr = pUnk->QueryInterface( IID_ISonarProject, (void**)&m_pProject ) ))
return hr;
if (FAILED( hr = pUnk->QueryInterface( IID_ISonarMixer, (void**)&m_pMixer ) ))
return hr;
if (FAILED( hr = pUnk->QueryInterface( IID_ISonarTransport, (void**)&m_pTransport ) ))
return hr;
if (FAILED( pUnk->QueryInterface( IID_ISonarIdentity, (void**)&m_pSonarIdentity ) ))
{
// Don't worry of this fails, it means it's an old version of SONAR
TRACE("No ISonarIdentity interface available\n");
m_pSonarIdentity = NULL; // Just in case
// In this case, use our internal id generator
m_dwUniqueId = m_cState.GetNextUniqueId();
}
else if ( FAILED ( hr = m_pSonarIdentity->GetUniqueSurfaceId( this, &m_dwUniqueId ) ) )
return hr;
if ( FAILED( pUnk->QueryInterface( IID_ISonarMixer2, (void**)&m_pMixer2) ) )
m_pMixer2 = NULL;
if ( FAILED( pUnk->QueryInterface( IID_ISonarParamMapping, (void**)&m_pParamMapping ) ) )
m_pParamMapping = NULL;
if ( FAILED( pUnk->QueryInterface( IID_ISonarIdentity2, (void**)&m_pSonarIdentity2 ) ) )
m_pSonarIdentity2 = NULL;
else if ( FAILED ( hr = m_pSonarIdentity2->GetSupportedRefreshFlags( &m_dwSupportedRefreshFlags ) ) )
return hr;
// Call the child class OnConnect()...
OnConnect();
// OK, now we're connected
m_bConnected = true;
return hr;
}
void NetworkManager::OnEvent(int numOfEvent, int threadId)
{
int strLen = 0;
char buffer[1024];
for(int i=0; i<numOfEvent; i++)
{
int eventFd = m_epollEvent2DList[threadId][i].data.fd;
if(eventFd == m_serverFd) // when clients attempt to connect
{
OnConnect();
}
else // when client request service
{
Session* pSession = m_pSessionMap[eventFd];
strLen = read(eventFd, pSession->buffer, MAX_BUFFER_LENGTH); // Read client request
if(strLen == 0) // Client request to disconnect
{
epoll_ctl(m_epollFdList[threadId], EPOLL_CTL_DEL, m_epollEvent2DList[threadId][i].data.fd, NULL); // remove client info from epoll instance
close(eventFd); // disconnecd
delete pSession;
m_pSessionMap.erase(eventFd);
printf("%d session disconnected\n", eventFd);
}
else if(strLen < 0)
{
/* if(errno != EWOULDBLOCK && errno != EAGAIN)
{
// critical error
fprintf(stderr, "[ERROR] read() ERROR : %s\n", strerror(errno));
exit(1);
}*/
}
else
{
__uint32_t events = m_epollEvent2DList[threadId][i].events;
if(events & EPOLLIN)
{
OnRead(eventFd, strLen);
}
if(events & EPOLLOUT)
{
printf("EPOLLOUT\n");
}
if(events & EPOLLERR)
{
fprintf(stderr, "[ERROR] : EPOLL EVENT ERROR\n");
exit(-1);
}
//pSession->buffer[strLen] = '\0';
//printf("%s\n", pSession->buffer);
// service that someelse
}
}
}
}
HRESULT CACTController::Connect( IUnknown* pUnk, HWND hwndApp )
{
// Note: You will probably not need to change this implementation.
// The wizard has already generated code to obtain all of the ISonarXXX
// interfaces that are available.
CCriticalSectionAuto csa( &m_cs );
HRESULT hr = S_OK;
releaseSonarInterfaces();
if (FAILED( hr = pUnk->QueryInterface( IID_ISonarMidiOut, (void**)&m_pMidiOut ) ))
return hr;
if (FAILED( hr = pUnk->QueryInterface( IID_ISonarKeyboard, (void**)&m_pKeyboard ) ))
return hr;
if (FAILED( hr = pUnk->QueryInterface( IID_ISonarCommands, (void**)&m_pCommands ) ))
return hr;
if (FAILED( hr = pUnk->QueryInterface( IID_ISonarProject, (void**)&m_pProject ) ))
return hr;
if (FAILED( hr = pUnk->QueryInterface( IID_ISonarMixer, (void**)&m_pMixer ) ))
return hr;
if (FAILED( hr = pUnk->QueryInterface( IID_ISonarTransport, (void**)&m_pTransport ) ))
return hr;
// try to obtain the optional ISonarIdentity Interface from the host
hr = pUnk->QueryInterface( IID_ISonarIdentity, (void**)&m_pSonarIdentity );
if ( SUCCEEDED( hr ))
{
// Obtain a unique instance ID. This ID will be the same for this surface each time
// the host is restarted as long as the same surfaces are active in the host.
m_dwSurfaceId = 0;
hr = m_pSonarIdentity->GetUniqueSurfaceId( reinterpret_cast<IControlSurface*>(this), &m_dwSurfaceId );
if ( FAILED( hr ))
return hr;
}
if (FAILED( pUnk->QueryInterface( IID_ISonarParamMapping, (void**)&m_pSonarParamMapping ) ))
{
// Just in case
m_pSonarParamMapping = NULL;
}
if (FAILED( pUnk->QueryInterface( IID_ISonarMixer2, (void**)&m_pSonarMixer2 ) ))
{
// Just in case
m_pSonarMixer2 = NULL;
}
// Call the child class OnConnect()...
OnConnect();
// OK, now we're connected
m_bConnected = true;
return hr;
}
void CAsyncSocketExLayer::CallEvent(int nEvent, int nErrorCode)
{
if (m_nCriticalError)
return;
m_nCriticalError=nErrorCode;
switch (nEvent)
{
case FD_READ:
case FD_FORCEREAD:
if (GetLayerState()==connected)
{
if (nErrorCode)
SetLayerState(aborted);
OnReceive(nErrorCode);
}
break;
case FD_WRITE:
if (GetLayerState()==connected)
{
if (nErrorCode)
SetLayerState(aborted);
OnSend(nErrorCode);
}
break;
case FD_CONNECT:
if (GetLayerState()==connecting)
{
if (!nErrorCode)
SetLayerState(connected);
else
SetLayerState(aborted);
OnConnect(nErrorCode);
}
break;
case FD_ACCEPT:
if (GetLayerState()==listening)
{
if (!nErrorCode)
SetLayerState(connected);
else
SetLayerState(aborted);
OnAccept(nErrorCode);
}
break;
case FD_CLOSE:
if (GetLayerState()==connected)
{
if (nErrorCode)
SetLayerState(aborted);
else
SetLayerState(closed);
OnClose(nErrorCode);
}
break;
}
}
bool CRedisClient::ReConnect()
{
LockerGuard guard(*m_locker);
if( m_pRedisContext )
{
redisFree(m_pRedisContext);
m_pRedisContext = NULL;
}
struct timeval timeout = { 0, 500000 }; // 0.5 seconds 重连
return OnConnect(&timeout);
}
/*========================================================================================
FUNCTION: LBaseSock::WindowProc()
DESCRIPT: Event handler window procedure.
RETURN :
ARGUMENT:
uMsg : (i)Message ID
wParam: (i)Message parameter 1
lParam: (i)Message parameter 2
UPDATE : 2004/07/01, In-hyeok Paek; First work!
========================================================================================*/
LRESULT LBaseSock::WindowProc( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
int nErr; // Socket error code
if( uMsg == WM_SOCK_SOCKET ) {
nErr = WSAGETASYNCERROR( lParam );
switch( WSAGETSELECTEVENT( lParam ) ) {
case FD_ACCEPT:
OnAccept( nErr );
break;
case FD_CONNECT:
::KillTimer( m_hWnd, IDT_SOCK_CONNECT );
OnConnect( nErr );
break;
case FD_CLOSE:
OnClose( nErr );
break;
case FD_READ:
OnReceive( nErr );
break;
case FD_WRITE:
OnSend( nErr );
break;
}
return 0L;
}
else if( uMsg == WM_TIMER ) {
if( wParam == IDT_SOCK_CONNECT ) {
if( m_Sock != INVALID_SOCKET ) {
closesocket( m_Sock );
m_Sock = INVALID_SOCKET;
}
m_nLastErr = WSAETIMEDOUT;
OnConnect( WSAETIMEDOUT );
return 0L;
}
}
return ::DefWindowProc( m_hWnd, uMsg, wParam, lParam );
}
void CPeerLink::Attach( int nHandle, const char *IpAddr, int nPort, IPeerManager *pManager )
{
m_strIPAddr = IpAddr;
m_nPort = nPort;
m_bAccepted = true;
m_nPeerState = PS_ESTABLISHED;
m_nConnTimeoutID = 0;
CWinSocket::Attach(nHandle);
SetPeerManager(pManager);
CWinSocket::SetReactor(m_pPeerManager->GetTorrentTask()->GetSocketReactor());
OnConnect();
}
/**
* Interface: IObjectWithSite::SetSite
*/
STDMETHODIMP CBrowserHelperObject::SetSite(IUnknown *unknown)
{
HRESULT hr = S_OK;
for (;;) {
hr = unknown ? OnConnect(unknown) : OnDisconnect(unknown);
BreakOnFailedWithErrorLog(hr, L"BrowserHelperObject::SetSite failed -> " + logger->parse(hr));
hr = IObjectWithSiteImpl<CBrowserHelperObject>::SetSite(unknown);
break;
}
return hr;
}
void InterprocessServer::DoRun()
{
shared_ptr<InterprocessIo> io = Connect();
if(!io) {
return;
}
if(IsCancelPending()) {
return;
}
OnConnect(io);
}
void CServerSocket::SocketAccept( SOCKET ssocket,char* ip,int port )
{
CCustomClientSocket * ClientSocket =NULL;
Lock();
FreeCorpseClient();
ClientSocket = m_FreeClientPool.DeQueue();
if (ClientSocket != NULL)
{
ClientSocket = CreateClientSocket();
if(ClientSocket == NULL)
{
ClientSocket = new CCustomClientSocket;
}
}
ClientSocket->SetSocketHandle(m_wCurrentHandle);
ClientSocket->setRemoteAddress(ip);
ClientSocket->setRemotePort(port);
ClientSocket->SetIOCPHandle(m_hIOCP);
ClientSocket->SetSocket(ssocket);
ClientSocket->OnInitialize();
m_ActiveClientSocketList.push_back(ClientSocket);
m_iClientCount ++;
m_SessionMap[m_wCurrentHandle]=ClientSocket;
if(ClientSocket->GetSocket() != INVALID_SOCKET)
{
if(CreateIoCompletionPort((HANDLE)ssocket,m_hIOCP,DWORD(ClientSocket),0)==0)
{
OnError((CCustomSocket *)ClientSocket,GetLastError());
ClientSocket->ForceClose();
}
else
{
OnConnect((CCustomSocket *)ClientSocket);
if (ClientSocket->GetSocket() != INVALID_SOCKET)
{
ClientSocket->PrepareRecv(ClientSocket->GetBlock(true));
}
}
}
ClientSocket = NULL;
do {
m_wCurrentHandle++;
if(m_wCurrentHandle < 1000)
{
m_wCurrentHandle = 1000;
}}while (m_SessionMap.find(m_wCurrentHandle)!= m_SessionMap.end());
Unlock();
}
void Connection::HandleConnect(const boost::system::error_code & error)
{
if (error || HasError() || m_hive->HasStopped()) {
StartError(error);
}
else {
if (m_socket.is_open()) {
OnConnect(m_socket.remote_endpoint().address().to_string(), m_socket.remote_endpoint().port());
}
else {
StartError(error);
}
}
}
// -------------------------------------------------------------------------------------------------------------------------------------------------------
int IOCP::ServerAdd(int ServerIndex, SOCKET Socket, char * Ip)
{
memcpy(m_Server[ServerIndex].m_ServerIp, Ip, 16);
// -----
m_Server[ServerIndex].m_Index = ServerIndex;
m_Server[ServerIndex].m_State = SRVS_ONLINE;
m_Server[ServerIndex].m_Socket = Socket;
// -----
m_AddedCount++;
// -----
OnConnect();
// -----
return ServerIndex;
}
void CTcpHandler::TcpAdd(CCommand *pCmd)
{
CTcpAddCommand *pConnectCmd = dynamic_cast<CTcpAddCommand *>(pCmd);
CEventThread *pThread = dynamic_cast<CEventThread *>(GetThread());
m_pBufevt = bufferevent_socket_new(pThread->GetEventBase(),
pConnectCmd->m_iFd, BEV_OPT_THREADSAFE);
bufferevent_setcb(m_pBufevt, CNetThread::OnStaticRead, CNetThread::OnStaticWrite, CNetThread::OnStaticError, this);
bufferevent_enable(m_pBufevt, EV_READ|EV_PERSIST|EV_ET);
bufferevent_setwatermark(m_pBufevt, EV_READ,
OnRead(NULL, 0), 0);
OnConnect();
//告诉listen线程
SetTimeout();
}
///网络读取消息回调函数
bool CWClientSocket::OnSocketReadEvent(NetMessageHead* pNetHead, void* pNetData, UINT uDataSize, CTCPClientSocket* pClientSocket)
{
switch (pNetHead->bMainID)
{
case MDM_CONNECT: ///连接消息
{
return OnConnect(pNetHead, pNetData, uDataSize, pClientSocket);
}
case MDM_GR_USER_LIST:
{
return OnGetUserList(pNetHead, pNetData, uDataSize, pClientSocket);
}
case MDM_GR_LOGON:
{
switch (pNetHead->bAssistantID)
{
case ASS_GR_LOGON_SUCCESS:
{
break;
}
case ASS_GR_LOGON_ERROR:
{
pClientSocket->CloseSocket(false);
if (0 <= pNetHead->bAssistantID && pNetHead->bAssistantID <= 13)
AfxMessageBox(LOGIN_ERR_STRING[pNetHead->bHandleCode]);
else if (pNetHead->bAssistantID == 160 || pNetHead->bAssistantID == 161)
AfxMessageBox(LOGIN_ERR_STRING[13 + pNetHead->bHandleCode - 160 + 1]);
else
AfxMessageBox("未知错误!");
break;
}
}
break;
}
case MDM_GR_USER_ACTION:
{
return OnUserAction(pNetHead, pNetData, uDataSize, pClientSocket);
}
case MDM_GR_ROOM:
{
return OnRoomMsg(pNetHead, pNetData, uDataSize, pClientSocket);
}
case MDM_GR_DESK:
{
return OnLockMsg(pNetHead, pNetData, uDataSize, pClientSocket);
}
}
return true;
}
STDMETHODIMP TffdshowPageBase::SetObjects(ULONG cObjects, LPUNKNOWN *ppUnk)
{
if (cObjects == 1) {
if (!ppUnk || !*ppUnk) {
return E_POINTER;
}
wasobjectset = true;
return OnConnect(*ppUnk);
} else if (cObjects == 0) {
wasobjectset = false;
return OnDisconnect();
} else {
return E_UNEXPECTED;
}
}
int CPeerLink::HandleWrite()
{
if (m_nPeerState == PS_CONNECTING)
{
m_nPeerState = PS_ESTABLISHED;
RemoveHandleMask(WRITE_MASK);
OnConnect();
return 0;
}
m_bCanWrite = true;
return 0;
}
