cxSocket.cpp

Go to the documentation of this file.

/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.
                 
Copyright (c) SINTEF Department of Medical Technology.
All rights reserved.
                 
CustusX is released under a BSD 3-Clause license.
                 
See Lisence.txt (https://github.com/SINTEFMedtek/CustusX/blob/master/License.txt) for details.
=========================================================================*/
 
 
#include "cxSocket.h"
 
#include <QTcpSocket>
#include "cxLogger.h"
#include <QTcpServer>
#include <QNetworkInterface>
 
namespace cx
{
 
//void SingleConnectionTcpServer::setSocket(QPointer<Socket> socket)
//{
//      mSocket = socket;
//}
 
SingleConnectionTcpServer::SingleConnectionTcpServer(QObject* parent) :
    QTcpServer(parent)
{
}
 
 
void SingleConnectionTcpServer::incomingConnection(qintptr socketDescriptor)
{
    emit incoming(socketDescriptor);
}
 
//---------------------------------------------------------
//---------------------------------------------------------
//---------------------------------------------------------
 
SocketClientConnector::SocketClientConnector(SocketConnection::ConnectionInfo info, QTcpSocket* socket) :
    mInfo(info),
    mSocket(socket)
{
    connect(mSocket, &QTcpSocket::connected, this, &SocketClientConnector::internalConnected);
    connect(mSocket, &QTcpSocket::disconnected, this, &SocketClientConnector::internalDisconnected);
}
 
SocketClientConnector::~SocketClientConnector()
{
 
}
 
void SocketClientConnector::activate()
{
    CX_LOG_INFO() << "Trying to connect to " << mInfo.getDescription();
    emit stateChanged(scsCONNECTING);
    mSocket->connectToHost(mInfo.host, mInfo.port);
}
 
void SocketClientConnector::deactivate()
{
    mSocket->close();
//      this->stopListen();
}
 
CX_SOCKETCONNECTION_STATE SocketClientConnector::getState()
{
    if (mSocket->state() == QAbstractSocket::ConnectedState)
        return scsCONNECTED;
    if (mSocket->state() == QAbstractSocket::UnconnectedState)
        return scsINACTIVE;
    return scsCONNECTING;
}
 
void SocketClientConnector::internalConnected()
{
    CX_LOG_SUCCESS() << "Connected to "  << mInfo.getDescription();
    emit stateChanged(this->getState());
}
 
void SocketClientConnector::internalDisconnected()
{
    CX_LOG_SUCCESS() << "Disconnected";
    this->stateChanged(this->getState());
}
 
 
//---------------------------------------------------------
//---------------------------------------------------------
//---------------------------------------------------------
 
SocketServerConnector::SocketServerConnector(SocketConnection::ConnectionInfo info, QTcpSocket* socket) :
    mInfo(info),
    mSocket(socket)
{
 
}
 
SocketServerConnector::~SocketServerConnector()
{
 
}
 
void SocketServerConnector::activate()
{
    this->startListen();
}
 
void SocketServerConnector::deactivate()
{
    this->stopListen();
}
 
CX_SOCKETCONNECTION_STATE SocketServerConnector::getState()
{
    if (mSocket->state() == QAbstractSocket::ConnectedState)
        return scsCONNECTED;
    if (mServer->isListening())
        return scsLISTENING;
    if (mSocket->state() == QAbstractSocket::UnconnectedState)
        return scsINACTIVE;
    return scsCONNECTING;
}
 
bool SocketServerConnector::startListen()
{
    if (!mServer)
    {
        mServer = new SingleConnectionTcpServer(this);
        connect(mServer.data(), &SingleConnectionTcpServer::incoming, this, &SocketServerConnector::incomingConnection);
//              mServer->setSocket(mSocket);
    }
    emit stateChanged(scsCONNECTING);
 
    bool started = mServer->listen(QHostAddress::Any, mInfo.port);
 
    if (started)
    {
        CX_LOG_INFO() << QString("Server address: %1").arg(this->getAllServerHostnames().join(", "));
        CX_LOG_INFO() << QString("Server is listening to port %1").arg(mServer->serverPort());
    }
    else
    {
        CX_LOG_INFO() << QString("Server failed to start. Error: %1").arg(mServer->errorString());
    }
 
    emit stateChanged(this->getState());
    return started;
}
 
void SocketServerConnector::stopListen()
{
    mSocket->close();
 
    if (mServer && mServer->isListening())
    {
        CX_LOG_INFO() << QString("Server stopped listening to port %1").arg(mServer->serverPort());
        mServer->close();
        emit stateChanged(this->getState());
    }
}
 
void SocketServerConnector::incomingConnection(qintptr socketDescriptor)
{
    CX_LOG_INFO() << "Server: Incoming connection...";
 
    if (this->mSocket->state() == QAbstractSocket::ConnectedState)
    {
        reportError("Incoming connection request rejected: The server can only handle a single connection.");
        return;
    }
 
    int success = mSocket->setSocketDescriptor(socketDescriptor, QAbstractSocket::ConnectedState);
    QString clientName = mSocket->localAddress().toString();
    report("Connected to "+clientName+". Session started." + qstring_cast(success));
 
    emit stateChanged(this->getState());
}
 
QStringList SocketServerConnector::getAllServerHostnames()
{
    QStringList addresses;
 
    foreach(QNetworkInterface interface, QNetworkInterface::allInterfaces())
    {
        if (interface.flags().testFlag(QNetworkInterface::IsRunning))
            foreach (QNetworkAddressEntry entry, interface.addressEntries())
            {
                if ( interface.hardwareAddress() != "00:00:00:00:00:00"
                     && entry.ip().toString() != "127.0.0.1"
                     && entry.ip().toString().contains(".") )
                    addresses << QString("%1: %2").arg(interface.name()).arg(entry.ip().toString());
            }
    }
 
    return addresses;
}
 
 
 
}//namespace cx