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);
}
}
void ClientInfo::threadRun()
{
while(client.IsOpen())
{
try
{
auto packet = client.read();
if(packet->size()>0)
{
EventVariant var = serilizer.deserilize(packet);
recivedPacket(*this, var);
}
else
{
OnDisconnect();
break;
}
}
catch(...)
{
OnDisconnect();
break;
}
}
Cli::writeDebugMsg("ClientInfo Thread is stopped");
}
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
UnixSocketConsumer::NotifyDisconnect()
{
MOZ_ASSERT(NS_IsMainThread());
mConnectionStatus = SOCKET_DISCONNECTED;
OnDisconnect();
}
void RemoteDesktop::Network_Client::_HandleDisconnect(std::shared_ptr<SocketHandler>& s){
if (_Running && OnDisconnect) {
if (!DesktopMonitor::Is_InputDesktopSelected()) _DesktopMonitor->Switch_to_Desktop(DesktopMonitor::Desktops::INPUT);
OnDisconnect(s);
}
_ShouldDisconnect = true;
}
/**
* Application must call this if a WM_ is coming from network.
*/
HRESULT ACWinSock::MsgProc(WPARAM wp, LPARAM lp)
{
WORD wEvent, wError;
// get data
wError = HIWORD(lp);
wEvent = LOWORD(lp);
// which event
switch (wEvent)
{
// confirmacao depois de uma conexao bem sucedida
case FD_CONNECT: break;
// cliente quer aceitacao
case FD_ACCEPT: { return OnAccept(); } break;
// recebemos algo
case FD_READ: { return OnReceive(wp); } break;
// um cliente ficou offline
case FD_CLOSE: { return OnDisconnect(wp); } break;
// nos mandamos algo?
case FD_WRITE: break;
}
return AC_OK;
};
void ASyncTCP::write_end(const boost::system::error_code& error)
{
if (!mIsClosing)
{
if (error)
{
// let listeners know
OnError(error);
mIsConnected = false;
if (!mDoReconnect)
{
OnDisconnect();
return;
}
if (!mIsReconnecting)
{
mIsReconnecting = true;
_log.Log(LOG_STATUS, "TCP: Reconnecting in %d seconds...", RECONNECT_TIME);
// schedule a timer to reconnect after 30 seconds
mReconnectTimer.expires_from_now(boost::posix_time::seconds(RECONNECT_TIME));
mReconnectTimer.async_wait(boost::bind(&ASyncTCP::do_reconnect, this, boost::asio::placeholders::error));
}
}
}
}
void Session::handle_receive( const boost::system::error_code& error, size_t bytes_transferred )
{
if( error )
{
if( error == boost::asio::error::eof )
{
std::cout << "클라이언트와 연결이 끊어졌습니다" << std::endl;
}
else
{
std::cout << "error No: " << error.value() << " error Message: " << error.message() << std::endl;
}
_SessionDesc desc;
desc.sessionType = 0;
desc.identifier = 1;
m_pServer->CloseSession( m_nSessionID );
OnDisconnect(m_nSessionID, desc);
}
else
{
_SessionDesc desc;
desc.sessionType = 0;
desc.identifier = 1;
if (false == OnReceive(m_ReceiveBuffer.data(), bytes_transferred, desc))
{
//강제로 끊게 하는 메소드는?
}
PostReceive();
}
}
// NOTE: Since the old WSAAsync functionality has been exchanged in the favor of WSAEvent, I'm not sure if MsgProc will fire correctly
HRESULT ZFXWS::MsgProc( WPARAM wp, LPARAM lp )
{
WORD wEvent, wError;
wError = HIWORD(lp);
wEvent = LOWORD(lp);
//evaluate what event occurred
switch ( wEvent )
{
//new client accepted
case FD_CONNECT:
break;
//new client is knocking
case FD_ACCEPT:
return OnAccept();
break;
//there is data to be received
case FD_READ:
return OnReceive(wp);
break;
//a socket is closing
case FD_CLOSE:
return OnDisconnect(wp);
break;
//after sending data
case FD_WRITE:
break;
}
return ZFX_OK;
}
//-----------------------------------------------------------------------------------------------------//
STDMETHODIMP CMarketDataProvider::_OnError(ErrorNumberEnum enErrorNumber, BSTR bsDescription,
RequestsTypeEnum enReqType, VARIANT varRequest)
{
CString sDesc = (LPCTSTR)_bstr_t(bsDescription);
if(enErrorNumber == enNotConnected || enErrorNumber == enConnectionWasDisconnected)
{
OnDisconnect(enErrorNumber, bsDescription);
return S_OK;
}
switch(enReqType)
{
case enRequestLastQuote:
{
OnError(enErrorNumber, bsDescription);
break;
}
case enSubscribeQuote:
{
OnError(enErrorNumber, bsDescription);
break;
}
default:
{
OnError(enErrorNumber, bsDescription);
}
}
return S_OK;
}
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);
}
void CPacketInputPin::Disconnect()
{
if (mpPeer) {
OnDisconnect();
mpPeer = NULL;
}
}
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);
}
BOOL CT42Secretary::OnMinute()
{
if(
m_limitTime.GetTotalSeconds() &&
(CTime::GetCurrentTime()-m_logEntry.m_Time)>=m_limitTime
)
OnDisconnect();
return TRUE;
}
// Sends a message to a specified user. If a problem occurs, OnDisconnect
// callback will be called.
BOOL CNDKServer::SendMessageToUser(long lUserId, CNDKMessage &msg)
{
BOOL bResult = m_userMgr.SendMessage(lUserId, msg);
if (!bResult)
OnDisconnect(lUserId, NDKServer_ErrorSendingMessage);
return bResult;
}
bool CNetwork_Asio::Disconnect() {
OnDisconnect();
// networkService_->Get_IO_Service()->post([this]() {
std::error_code ignored;
socket_.shutdown(asio::socket_base::shutdown_both, ignored);
OnDisconnected();
// });
return true;
}
void
SocketConsumerBase::NotifyDisconnect()
{
MOZ_ASSERT(NS_IsMainThread());
mConnectionStatus = SOCKET_DISCONNECTED;
mConnectDelayMs = CalculateConnectDelayMs();
mConnectTimestamp = 0;
OnDisconnect();
}
void RemoteDesktop::Network_Server::_Run(){
std::vector<WSAEVENT> EventArray;
auto sharedrockarray = std::make_shared<std::vector<std::shared_ptr<SocketHandler>>>();
_Sockets = sharedrockarray;
EventArray.reserve(WSA_MAXIMUM_WAIT_EVENTS);
sharedrockarray->reserve(WSA_MAXIMUM_WAIT_EVENTS);
SOCKET listensocket = RemoteDesktop::Listen(_Port, _Host);
if (listensocket == INVALID_SOCKET) return;
auto newevent = WSACreateEvent();
WSAEventSelect(listensocket, newevent, FD_ACCEPT | FD_CLOSE);
EventArray.push_back(newevent);
sharedrockarray->push_back(std::make_shared<SocketHandler>(listensocket, false));
NetworkProcessor processor(DELEGATE(&RemoteDesktop::Network_Server::_HandleReceive), DELEGATE(&RemoteDesktop::Network_Server::_HandleConnect));
WSANETWORKEVENTS NetworkEvents;
auto timer = std::chrono::high_resolution_clock::now();
while (_Running && !EventArray.empty()) {
auto Index = WSAWaitForMultipleEvents(EventArray.size(), EventArray.data(), FALSE, 1000, FALSE);
if ((Index != WSA_WAIT_FAILED) && (Index != WSA_WAIT_TIMEOUT) && _Running) {
WSAEnumNetworkEvents(sharedrockarray->at(Index)->get_Socket(), EventArray[Index], &NetworkEvents);
if (((NetworkEvents.lNetworkEvents & FD_ACCEPT) == FD_ACCEPT) && NetworkEvents.iErrorCode[FD_ACCEPT_BIT] == ERROR_SUCCESS){
if (EventArray.size() >= WSA_MAXIMUM_WAIT_EVENTS - 1) continue;// ignore this event too many connections
_HandleNewConnect(listensocket, EventArray, *sharedrockarray);
}
else if (((NetworkEvents.lNetworkEvents & FD_READ) == FD_READ) && NetworkEvents.iErrorCode[FD_READ_BIT] == ERROR_SUCCESS){
processor.Receive(sharedrockarray->at(Index));
}
else if (((NetworkEvents.lNetworkEvents & FD_CLOSE) == FD_CLOSE) && NetworkEvents.iErrorCode[FD_CLOSE_BIT] == ERROR_SUCCESS){
if (Index == 0) {//stop all processing, set running to false and next loop will fail and cleanup
_Running = false;
continue;
}
}
}
//once every second send a keep alive. this will trigger disconnects
if (std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - timer).count() > 1000){
_CheckForDisconnects(EventArray, *sharedrockarray);
timer = std::chrono::high_resolution_clock::now();
}
}
for (size_t beg = 1; beg < sharedrockarray->size(); beg++){
OnDisconnect(sharedrockarray->at(beg));//let all callers know about the disconnect, skip slot 0 which is the listen socket
}
//cleanup code here
for (auto x : EventArray) WSACloseEvent(x);
DEBUG_MSG("_Listen Exiting");
}
// Sends a message to all users. OnDisconnect callback will be called for
// each user that the message cannot be sent.
BOOL CNDKServer::SendMessageToAllUsers(CNDKMessage& message)
{
CLongList listIds;
BOOL bResult = m_userMgr.SendMessageToAllUsers(message, listIds);
while (!listIds.IsEmpty())
OnDisconnect(listIds.RemoveHead(), NDKServer_ErrorSendingMessage);
return bResult;
}
void CPacketOutputPin::Disconnect()
{
if (mpPeer == NULL) {
return;
}
OnDisconnect();
mpPeer->Disconnect();
mpPeer = NULL;
}
void MsgConnection::SetConnectionLost() {
if(m_connectionlost || m_aborting) {
return;
}
m_connectionlost = true;
Abort();
Close();
OnDisconnect();
}
// -------------------------------------------------------------------------------------------------------------------------------------------------------
void IOCP::ServerDel(int aIndex)
{
m_Server[aIndex].m_Index = -1;
m_Server[aIndex].m_Socket = INVALID_SOCKET;
m_Server[aIndex].m_State = SRVS_OFFLINE;
// -----
memset(m_Server[aIndex].m_ServerIp, 0, sizeof(m_Server[aIndex].m_ServerIp));
// -----
m_AddedCount--;
// -----
OnDisconnect(aIndex);
}
void GCNetLogic::OnUnRegisterApp(const NetMessage* nmsg)
{
MsgUnRegisterApp msg;
if (!MsgFromBytes(nmsg, msg))
return;
auto app = theAppMgr->GetObject(msg.app_id());
if (!app)
return;
OnDisconnect(app->GetIndex());
theAppMgr->RemoveObject(app->GetAppID());
LOG(INFO) << "UnRegisterApp" << LogValue("apptype", msg.app_type()) << LogValue("appid", msg.app_id());
}
void NetworkConnection::HandleDisconnect(const boost::system::error_code & error)
{
if (error == boost::asio::error::connection_reset)
{
StartDisconnect();
OnDisconnect();
}
else
{
StartError(error);
}
}
void cXVDRSession::SignalConnectionLost()
{
if(m_connectionLost)
return;
XVDRLog(XVDR_ERROR, "%s - connection lost !!!", __FUNCTION__);
m_connectionLost = true;
Abort();
Close();
OnDisconnect();
}
void TcpSocket::Disconnect()
{
if(!m_connected) return;
m_connected = false;
OnDisconnect();
sSocketEngine.RemoveSocket(this);
shutdown(m_fd, SD_BOTH);
closesocket(m_fd);
if(!m_deleted)
Delete();
}
/**
* 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 Socket::Disconnect()
{
sLog.outBasic("Socket::Disconnect on socket %u", m_fd);
m_connected = false;
// remove from mgr
sSocketMgr.RemoveSocket(this);
// Call virtual ondisconnect
OnDisconnect();
if(!m_deleted) Delete();
}
void Socket::Disconnect()
{
m_connected = false;
// remove from mgr
sSocketMgr.RemoveSocket(this);
SocketOps::CloseSocket(m_fd);
// Call virtual ondisconnect
OnDisconnect();
if(!m_deleted) Delete();
}
bool IOCPConnection::Close()
{
if( IsConnected() )
OnDisconnect( -999 );
m_bConnected = false;
//FIN날리기
if( m_bAsyncCloseSignal ) ::shutdown( m_socket.GetSocketHandle(), SD_BOTH );
m_socket.Destroy();
return true;
}
