void XYTCPSocketLayer::Disconnect(XYNetworkErrorCode code)
{
if(_stat == States_Connected)
{
_stat = States_Disconnected;
_IsReadThreadRunning = false;
}
else if(_stat == States_Connecting)
{
pthread_mutex_lock(&_mutex);
_stat = States_Disconnected;
_IsReadThreadRunning = false;
pthread_mutex_unlock(&_mutex);
}
XYThreadManager::ShareIntance()->Stop();
if(shutdown(_fd, SHUT_WR) != 0)
{
//dispatch shutdown error
onError(XYNetworkErrorCode(XYNetworkErrorCode::eXYNetworkErrorCode::SHOWDOWN_ERROR));
}
onDisconnect(code);
}
void
BasicDeviceDriver::disconnect(void)
{
debug("disconnecting");
onDisconnect();
debug("disconnected");
}
void MasterServer::onNewConnection()
{
socket = server->nextPendingConnection();
print ("New incoming connection - " + socket->peerAddress().toString());
connect(socket, SIGNAL(readyRead()), this, SLOT(onReadyRead()));
connect(socket, SIGNAL(disconnected()), this, SLOT(onDisconnect()));
}
void ChunckReceiver::run()
{
if(mCollector == nullptr){
return;
}
mEventLoop = QEventLoopPtr(new QEventLoop());
mSocket = QTcpSocketPtr(new QTcpSocket());
connect(mSocket.get(),
SIGNAL(disconnected()),
this,
SLOT(onDisconnect()),Qt::DirectConnection);
connect(mSocket.get(),
SIGNAL(readyRead()),
this,
SLOT(onReadyRead()), Qt::DirectConnection);
if(!mSocket->setSocketDescriptor(mSocketDescriptor)){
emit error(mSocket->error());
}
mEventLoop->exec();
emit finished();
}
void ARTSPConnection::onMessageReceived(const sp<AMessage> &msg) {
switch (msg->what()) {
case kWhatConnect:
onConnect(msg);
break;
case kWhatDisconnect:
onDisconnect(msg);
break;
case kWhatCompleteConnection:
onCompleteConnection(msg);
break;
case kWhatSendRequest:
onSendRequest(msg);
break;
case kWhatReceiveResponse:
onReceiveResponse();
break;
case kWhatObserveBinaryData:
{
CHECK(msg->findMessage("reply", &mObserveBinaryMessage));
break;
}
default:
TRESPASS();
break;
}
}
void WebSocket::listen() {
EthernetClient cli;
if (cli = server.available()) {
if (cli == true) {
if (state == DISCONNECTED ) {
client = cli;
if (doHandshake() == true) {
state = CONNECTED;
if (onConnect) {
onConnect(*this);
}
}
} else {
if (getFrame() == false) {
// Got unhandled frame, disconnect
#ifdef DEBUG
Serial.println("Disconnecting");
#endif
disconnectStream();
state = DISCONNECTED;
if (onDisconnect) {
onDisconnect(*this);
}
}
}
}
}
}
void BooRedisAsync::onError(const boost::system::error_code &error)
{
if (error == boost::asio::error::operation_aborted)
return;
if (error!=boost::system::error_code()) //If not decode error
onLogMessage("Connection to Redis " + endpointToString(m_endpointIterator) + " failed: "
+ error.message(),LOG_LEVEL_ERR);
m_writeInProgress = false;
m_connected = false;
m_connectTimer->cancel();
try {
closeSocket(); //close socket and cleanup
} catch (...) {}
m_decoder.reset();
onDisconnect();
boost::asio::ip::tcp::resolver::iterator it = getEndpointIterator();
if (!onceConnected() && !isLastEndpoint(it)) { //try another address
setEndpointIterator(++it); //switch to the next endpoint
onLogMessage("Trying next Redis address: " + endpointToString(it),LOG_LEVEL_DEBUG);
} else
sleep(1);
onLogMessage("Reconnecting to Redis " + endpointToString(it),LOG_LEVEL_INFO);
connect(it);
}
void ONIKinectDevice::onDeviceDisconnected(const DeviceInfo* pInfo)
{
onDisconnect();
std::ostringstream out;
out << "Device \"" << pInfo->getUri() << "\" disconnected\n";
onMessage(out.str());
}
void IRC::input() {
string line_buffer = "";
char buffer[RCVBUFSIZE + 1];
while(true) {
int bytesReceived = 0;
//this thread is used for Socket IO
if((bytesReceived = (socket->read(buffer, RCVBUFSIZE))) <= 0) {
//We have been disconnected
break;
}
buffer[bytesReceived] = '\0';
line_buffer += buffer;
//if the line buffer has a new line, flush it to read
size_t line = line_buffer.find("\n");
if(line != string::npos) {
input_buffer.push(line_buffer.substr(0, line));
line_buffer = line_buffer.substr(line + 1);
}
mpSleep(SLEEP_TIME);
}
onDisconnect();
}
SyntroZigbeeGateway::SyntroZigbeeGateway(QSettings *settings, QWidget *parent, Qt::WFlags flags)
: QMainWindow(parent, flags), m_settings(settings)
{
ui.setupUi(this);
initStatusBar();
initStatTable();
loadNodeIDList();
connect(ui.actionExit, SIGNAL(triggered()), this, SLOT(close()));
connect(ui.actionAbout, SIGNAL(triggered()), this, SLOT(onAbout()));
connect(ui.actionConnect, SIGNAL(triggered()), this, SLOT(onConnect()));
connect(ui.actionDisconnect, SIGNAL(triggered()), this, SLOT(onDisconnect()));
connect(ui.actionConfigure, SIGNAL(triggered()), this, SLOT(onConfigure()));
ui.actionDisconnect->setEnabled(false);
m_controller = NULL;
m_refreshTimer = 0;
m_client = new ZigbeeGWClient(this, settings);
m_client->resumeThread();
m_syntroStatusTimer = startTimer(3000);
restoreWindowState();
}
unsigned short ZmqSocket::disconnect(const char* endpoint)
{
CHECK_RET_CODE(sock != 0, ERR_CLOSE);
CHECK_API_RET(zmq_disconnect(sock, endpoint) != -1);
onDisconnect();
return NO_ERR;
}
TcpClient::~TcpClient()
{
m_socket->disconnect(m_socket, SIGNAL(disconnected()), this, SLOT(onDisconnect()));
m_socket->disconnect(m_socket, SIGNAL(readyRead()), this, SLOT(onReadyRead()));
m_socket->close();
m_socket = nullptr;
}
void AndroidBluetooth::listen() {
if(available()){//check if there's any data sent from the remote bluetooth shield
recvChar = read();
// Serial.print(recvChar);
if(message.length() < MESSAGE_LENGTH) {
message.concat(recvChar);
}
} else if(message.length() > 0){
if(message.indexOf("+BTSTATE:1") >= 0) {
state = DISCONNECTED;
if(onDisconnect) onDisconnect();
} else if(message.indexOf("+BTSTATE:4") >= 0) {
state = CONNECTED;
if(onConnect) onConnect();
String temp = "blpins:D";
temp.concat(rxPin);
temp.concat("&D");
temp.concat(txPin);
send(temp);
temp = "";
} else if(message.indexOf("+BTSTATE:3") >= 0) {
} else if(message.indexOf("CONNECT:OK") >= 0) {
} else if(message.indexOf("ERROR") >= 0) {
} else if(message.indexOf("pRQST") >= 0) {
//Get Type Analog vs Digital
(message.charAt(5) == 'A') ? type = 1 : type = 0;
//Get state HIGH vs LOW
if(message.indexOf("false") >= 0) isHigh = 0;
else isHigh = 1;
//Get Pin Number
char *buffer = {"h"};
message.substring(6,8).toCharArray(buffer, 3);
pin = atoi(buffer);
//Send data to callback
if(onPin) onPin(type, pin, isHigh);
if(type == 0) {
Serial.print("Requested:");
Serial.print("Digital Pin ");
Serial.print(pin);
Serial.print(" to ");
if(isHigh) Serial.println("HIGH");
else Serial.println("LOW");
}
else {
send((String)analogRead(pin));
Serial.print("Analog Pin ");
Serial.print(pin);
Serial.print(" Read ");
Serial.println(analogRead(pin));
}
buffer = NULL;
}
else if (onData) onData(message);
message = "";
}
}
void TelemetryManager::onStart()
{
utalk = new UAVTalk(device, objMngr);
telemetry = new Telemetry(utalk, objMngr);
telemetryMon = new TelemetryMonitor(objMngr, telemetry);
connect(telemetryMon, SIGNAL(connected()), this, SLOT(onConnect()));
connect(telemetryMon, SIGNAL(disconnected()), this, SLOT(onDisconnect()));
}
void CustomServerNetworkHandler::disconnectClient(ServerNetworkHandler *real, const RakNet::RakNetGUID &guid, const std::string &message)
{
DisconnectPacket pk;
pk.message = message;
real->sender->send(guid, pk);
onDisconnect(real, guid, message);
}
unsigned short ZmqSocket::close()
{
CHECK_RET_CODE(sock != 0, ERR_CLOSE);
CHECK_API_RET(zmq_close(sock) == 0);
onDisconnect();
sock = 0;
return NO_ERR;
}
void SocketComm::connectToServer(QString host, qint16 port){
socket = new QTcpSocket();
socket->connectToHost(host,port);
socket->waitForConnected(2000);
connect(socket,SIGNAL(connected()),this,SLOT(onConnect()),Qt::DirectConnection);
connect(socket,SIGNAL(disconnected()),this,SLOT(onDisconnect()),Qt::DirectConnection);
}
void kul::https::Server::loop() throw(kul::tcp::Exception){
KUL_DBG_FUNC_ENTER
int32_t newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
if(newsockfd < 0) KEXCEPTION("HTTPS Server error on accept");
ssl = SSL_new(ctx);
SSL_set_fd(ssl, newsockfd);
//Here is the SSL Accept portion. Now all reads and writes must use SSL
int16_t ssl_err = SSL_accept(ssl);
if(ssl_err <= 0){
short se = 0;
SSL_get_error(ssl, se);
KERR << "HTTPS Server SSL ERROR on SSL_ACCEPT error: " << se;
close(newsockfd);
return;
}
KLOG(DBG) << "SSL_get_cipher: " << SSL_get_cipher(ssl);
cc = SSL_get_peer_certificate (ssl);
if(cc != NULL) {
KLOG(DBG) << "Client certificate:";
KLOG(DBG) << "\t subject: " << X509_NAME_oneline (X509_get_subject_name (cc), 0, 0);
KLOG(DBG) << "\t issuer: %s\n" << X509_NAME_oneline (X509_get_issuer_name (cc), 0, 0);
X509_free(cc);
}else KLOG(ERR) << "Client does not have certificate.";
KOUT(DBG) << "New connection , socket fd is " << newsockfd << ", is : " << inet_ntoa(cli_addr.sin_addr) << ", port : "<< ntohs(cli_addr.sin_port);
onConnect(inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port));
int16_t e;
char buffer[_KUL_HTTPS_READ_BUFFER_];
std::stringstream cnt;
do{
bzero(buffer,_KUL_HTTPS_READ_BUFFER_);
e = SSL_read(ssl, buffer, _KUL_HTTPS_READ_BUFFER_ - 1);
if(e) cnt << buffer;
}while(e == (_KUL_HTTPS_READ_BUFFER_ - 1));
if (e < 0){
short se = 0;
SSL_get_error(ssl, se);
if(se) KLOG(ERR) << "SSL_get_error: " << se;
e = -1;
}else
try{
std::string res;
std::shared_ptr<kul::http::ARequest> req = handleRequest(cnt.str(), res);
const kul::http::AResponse& rs(respond(*req.get()));
std::string ret(rs.toString());
e = SSL_write(ssl, ret.c_str(), ret.length());
}catch(const kul::http::Exception& e1){
KERR << e1.what();
e = -1;
}
close(newsockfd);
KOUT(DBG) << "Disconnect , socket fd is " << newsockfd << ", is : " << inet_ntoa(cli_addr.sin_addr) << ", port : "<< ntohs(cli_addr.sin_port);
onDisconnect(inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port));
}
void tstMainWindow::onDisconnected(const QUrl& server)
{
Q_UNUSED(server);
d->host_button->setText("Connect");
QObject::disconnect(d->host_button, SIGNAL(clicked()), this, SLOT(onDisconnect()));
QObject::connect(d->host_button, SIGNAL(clicked()), this, SLOT(onConnect()));
}
void RTAutomationManager::closeEvent(QCloseEvent *)
{
onDisconnect();
if (m_client) {
m_client->exitThread();
m_client = NULL;
}
saveWindowState();
}
void UDPConnection::receivedDisconnect(){
auto udp_interface = std::static_pointer_cast<UDPInterface>(getParent());
conn_send_timer.cancel();
conn_receive_timeout.cancel();
udp_interface->getDisconnectCallback()((int)P2PError::connection_reset, shared_from_this());
m_connected = false;
onDisconnect();
}
void SocketBase::disconnect()
{
if (_handle != INVALID_SOCKET)
{
closesocket(_handle);
_handle = INVALID_SOCKET;
onDisconnect();
}
}
void Server::newConnection()
{
socket = server->nextPendingConnection();
connect(socket, SIGNAL(readyRead()), this, SLOT(readyRead()));
connect(socket, SIGNAL(disconnected()), this, SLOT(onDisconnect()));
/* No more connections, pleeeease */
server->close();
std::cout << "Connection established!";
emit connectionEstablished();
}
ServerClient::ServerClient(qintptr socketDescriptor, ServerCore *server, QObject *parent) : QObject(parent)
{
mainSocket = new QTcpSocket();
mainSocket->setSocketDescriptor(socketDescriptor);
connect(mainSocket,SIGNAL(readyRead()), this, SLOT(onReadyRead()));
connect(mainSocket,SIGNAL(disconnected()), this, SLOT(onDisconnect()));
servPtr = server;
}
MainController::MainController(ProjectorWindow &target) :
ProjectorController(target), m_net(new ProjectorNet(this)), m_stageDataCounter(0),
m_connected(false), m_view(TemplateManager::INDEX),
m_activeQuestionIndex(0), m_activeRound (0) {
connect(m_net, SIGNAL(onConnect()), this, SLOT(onConnect()));
connect(m_net, SIGNAL(onContestState(ushort,CONTEST_STATUS)), this, SLOT(onContestState(ushort,CONTEST_STATUS)));
connect(m_net, SIGNAL(onContestTime(ushort)), this, SLOT(onContestTime(ushort)));
connect(m_net, SIGNAL(onDisconnect()), this, SLOT(onDisconnect()));
connect(m_net, SIGNAL(onError(QString)), this, SLOT(onError(QString)));
connect(m_net, SIGNAL(onQuestionState(ushort,ushort,QUESTION_STATUS)), this, SLOT(onQuestionState(ushort,ushort,QUESTION_STATUS)));
connect(m_net, SIGNAL(onShowAnswer()), this, SLOT(onShowAnswer()));
connect(m_net, SIGNAL(onHideAnswer()), this, SLOT(onHideAnswer()));
connect(m_net, SIGNAL(onShowContestRanks(vector<RankData>)), this, SLOT(onShowContestRanks(vector<RankData>)));
connect(m_net, SIGNAL(onShowContestTime()), this, SLOT(onShowContestTime()));
connect(m_net, SIGNAL(onShowMainScreen()), this, SLOT(onShowMainScreen()));
connect(m_net, SIGNAL(onStageData(ushort, QString)), this, SLOT(onStageData(ushort, QString)));
connect(m_net, SIGNAL(onNumRounds(ushort)), this, SLOT(onRoundsReceived(ushort)));
QTimer::singleShot(CONNECT_DELAY, this, SLOT(connectToServer()));
}
void MainController::onError( const QString& error ) {
(qDebug() << "MainController::onError");
m_lastError = error;
if ( m_connected ) {
//assume onDisconnect will get called...
m_target.displayError("Connection error.", error.toStdString().c_str());
} else {
onDisconnect();
}
}
void RTAutomationManager::clientConnected()
{
QSettings settings;
m_brokerStatus->setText("Connected to " + settings.value(RTAUTOMATION_PARAMS_BROKERADDRESS).toString());
m_serverName->setText(QString("Using automation server: ") + settings.value(RTAUTOMATION_PARAMS_SERVERID).toString());
m_dialog = new DialogMenu(settings.value(RTAUTOMATION_PARAMS_SERVERID).toString(), this);
connect(m_dialog, SIGNAL(sendAppData(QJsonObject)), m_client, SLOT(sendCommandData(QJsonObject)));
connect(m_client, SIGNAL(receiveCommandData(QJsonObject)), m_dialog, SLOT(receiveAppData(QJsonObject)));
m_dialog->exec();
onDisconnect();
}
void ParupaintClientInstance::message(const QString & id, const QByteArray & bytes)
{
const QJsonObject object = QJsonDocument::fromJson(bytes).object();
if(id == "connect"){
emit onConnect();
if(this->url().host() != "localhost"){
emit onSpectateChange(!(client_joined = false));
}
this->doName();
if(this->url().host() == "localhost"){
this->doJoin();
}
} else if(id == "disconnect"){
emit onDisconnect(bytes);
pool->clearCursors();
// we got confirmation
} else if(id == "join"){
emit onSpectateChange(!(client_joined = true));
// TODO clean this up??
// this is to make sure that, even if you reconnect
// you will send fresh data to the new server
shadow_brush.setPressure(0);
shadow_brush.setColor(QColor(-1, -1, -1, -1));
shadow_brush.setSize(-1);
shadow_brush.setTool(-1);
shadow_brush.setDrawing(false);
} else if(id == "leave"){
emit onSpectateChange(!(client_joined = false));
} else if(id == "info") {
if(object["painters"].isDouble()){
emit onPlayerCountChange(object["painters"].toInt());
}
if(object["spectators"].isDouble()){
emit onSpectatorCountChange(object["spectators"].toInt());
}
if(object["password"].isBool()){
remote_password = object["password"].toBool(false);
}
foreach(const QString & key, object.keys()){
QVariant val = object[key].toVariant();
if(key == "project-bgc" && val.type() == QVariant::String) val = QColor(val.toString());
ParupaintCommonOperations::CanvasAttributeOp(pool->canvas(), key, val);
}
} else if(id == "brush"){
void UDPConnection::receivedKeepAlive() {
auto udp_interface = std::static_pointer_cast<UDPInterface>(getParent());
conn_receive_timeout.expires_from_now(std::chrono::seconds(udp_interface->getInactivityTimeout()));
conn_receive_timeout.async_wait([&, this](const boost::system::error_code& error){
if(error != boost::asio::error::operation_aborted){
udp_interface->getDisconnectCallback()((int)P2PError::timed_out, shared_from_this());
m_connected = false;
onDisconnect();
}
});
m_connected = true;
}
/*! \brief Create the context menu for the connections tree. */
void ApplicationViewWidget::createConnectionsViewContextMenu()
{
connContex = new QMenu(ui->connectionList);
connSubMenu = new QMenu("Inspect",connContex);
connConnectAction = new QAction("Connect",connContex);
connDisconnectAction = new QAction("Disconnect",connContex);
connSeparatorAction = new QAction(connContex);
connSeparatorAction->setSeparator(true);
connRefreshAction = new QAction("Refresh Status",connContex);
connSelectAllAction = new QAction("Select All Connections",connContex);
conn1SeparatorAction = new QAction(connContex);
conn1SeparatorAction->setSeparator(connContex);
connYARPViewAction = new QAction("yarpview",connSubMenu);
connYARPReadAction = new QAction("yarpread",connSubMenu);
connYARPHearAction = new QAction("yarphear",connSubMenu);
connYARPScopeAction = new QAction("yarpscope",connSubMenu);
connSelectAllAction->setIcon(QIcon(":/select-all22.svg"));
connRefreshAction->setIcon(QIcon(":/refresh22.svg"));
connConnectAction->setIcon(QIcon(":/connect22.svg"));
connDisconnectAction->setIcon(QIcon(":/disconnect22.svg"));
connect(connConnectAction,SIGNAL(triggered()),this,SLOT(onConnect()));
connect(connDisconnectAction,SIGNAL(triggered()),this,SLOT(onDisconnect()));
connect(connRefreshAction,SIGNAL(triggered()),this,SLOT(onRefresh()));
connect(connSelectAllAction,SIGNAL(triggered()),this,SLOT(selectAllConnections()));
connect(connYARPViewAction,SIGNAL(triggered()),this,SLOT(onYARPView()));
connect(connYARPReadAction,SIGNAL(triggered()),this,SLOT(onYARPRead()));
connect(connYARPHearAction,SIGNAL(triggered()),this,SLOT(onYARPHear()));
connect(connYARPScopeAction,SIGNAL(triggered()),this,SLOT(onYARPScope()));
connContex->addAction(connConnectAction);
connContex->addAction(connDisconnectAction);
connContex->addAction(connSeparatorAction);
connContex->addAction(connRefreshAction);
connContex->addAction(connSelectAllAction);
connContex->addAction(conn1SeparatorAction);
connContex->addMenu(connSubMenu);
connSubMenu->addAction(connYARPViewAction);
connSubMenu->addAction(connYARPReadAction);
connSubMenu->addAction(connYARPHearAction);
connSubMenu->addAction(connYARPScopeAction);
ui->connectionList->setContextMenu(connContex);
}
