VFS_tcp_server.cpp

Go to the documentation of this file.

 
#include "VFS_tcp_server.h"
 
#include "VFS.h"
 
#include <QFile>
#include <QtNetwork/QSslCertificate>
#include <QtNetwork/QSslKey>
 
VFSQTcpServer::VFSQTcpServer(QObject *parent, bool ssl)
: QTcpServer(parent)
, _ssl(ssl)
{
}
 
// roughly based on:
// https://github.com/GuiTeK/Qt-SslServer/blob/master/example/Server/Server/SslServer.cpp
 
void VFSQTcpServer::incomingConnection(qintptr socketDescriptor)
{
        if (_ssl)
        {
                QSslSocket *serverSocket = new QSslSocket(this);
                if (serverSocket->setSocketDescriptor(socketDescriptor))
                {
                        serverSocket->setProtocol(QSsl::SecureProtocols);
                        serverSocket->setSslConfiguration(_sslConfiguration);
 
                        connect(serverSocket, SIGNAL(sslErrors(const QList<QSslError> &)), this, SLOT(sslErrors(const QList<QSslError> &)));
 
                        addPendingConnection(serverSocket);
 
                        connect(serverSocket, SIGNAL(encrypted()), this, SLOT(sslReady()));
                        connect(serverSocket, SIGNAL(modeChanged(QSslSocket::SslMode)), this, SLOT(modeChanged(QSslSocket::SslMode)));
                        serverSocket->startServerEncryption();
                }
                else
                {       delete serverSocket;
                        VFS::ERROR("Could not set socket descriptor.  Aborting.");
                }
        }
        else
                QTcpServer::incomingConnection(socketDescriptor);
}
 
void VFSQTcpServer::setSslConfiguration(QSslConfiguration sslConfiguration)
{
        _sslConfiguration = sslConfiguration;
}
 
void VFSQTcpServer::sslErrors(const QList<QSslError> &errors)
{
        for (int i=0;i<errors.size();i++)
                VFS::ERROR( errors.at(i).errorString(), 0, this->metaObject()->className() );
}
 
void VFSQTcpServer::sslReady()
{
        //VFS::WARN( "SSL handshake complete...", 0, this->metaObject()->className() );
}
 
void VFSQTcpServer::modeChanged(QSslSocket::SslMode mode)
{
        Q_UNUSED(mode);
}
 
VFS_tcp_server::VFS_tcp_server(quint16 port, QHostAddress address, bool ssl, QString sslCertPath, QString sslKeyPath)
: VFS_node()
, _listenAddress(address)
, _port(port)
, _ssl(ssl)
, _sslCertPath(sslCertPath)
, _sslKeyPath(sslKeyPath)
, _socket(this,ssl)
{
        //connect(this,SIGNAL(mounted()),this,SLOT(listen()));
        connect(VFS::root(),SIGNAL(initialized()),this,SLOT(listen()));
}
 
VFS_tcp_server::~VFS_tcp_server()
{
        _socket.close();
}
 
bool VFS_tcp_server::isContainer()
{
        return true;
}
 
bool VFS_tcp_server::listen()
{
        if (_socket.isListening())
        {       VFS::WARN( QString("%1 TCP socket was already listening!  Close it first?").arg(className()) );
                return false;
        }
 
        connect(&_socket, SIGNAL(newConnection()), this, SLOT(createNewConnection()));
        connect(&_socket, SIGNAL(acceptError(QAbstractSocket::SocketError)), this, SLOT(clientError(QAbstractSocket::SocketError)));
 
        if (_ssl)
        {
                //connect(&_socket, SIGNAL(sslErrors(const QList<QSslError> &)), this, SLOT(sslErrors(const QList<QSslError> &)));
 
                bool c=false,k=false;
 
                QFile certFile(_sslCertPath);
                QFile keyFile(_sslKeyPath);
 
                if (!(c = certFile.open(QIODevice::ReadOnly)))
                        VFS::ERROR( QString("Unable to open cert file: '%1'.").arg(_sslCertPath), 0, className() );
                else
                        VFS::LOG( QString("Reading cert file: '%1'").arg(_sslCertPath), 7, className() );
 
                if (!(k = keyFile.open(QIODevice::ReadOnly)))
                        VFS::ERROR( QString("Unable to open key file: '%1'.").arg(_sslKeyPath), 0, className() );
                else
                        VFS::LOG( QString("Reading key file: '%1'").arg(_sslKeyPath), 7, className() );
 
                if (!k || !c)
                {       VFS::ERROR( QString("Will not open port %1").arg(_port) );
                        return false;
                }
 
                QSslCertificate certificate(&certFile, QSsl::Pem);
                QSslKey sslKey(&keyFile, QSsl::Rsa, QSsl::Pem);
                certFile.close();
                keyFile.close();
 
                //sslConfiguration.setPeerVerifyMode(QSslSocket::VerifyNone);
                _sslConfiguration.setLocalCertificate(certificate);
                _sslConfiguration.setPrivateKey(sslKey);
                //_sslConfiguration.setProtocol(QSsl::TlsV1SslV3);
                _sslConfiguration.setProtocol(QSsl::SecureProtocols);
 
                _socket.setSslConfiguration(_sslConfiguration);
        }
 
        bool l = _socket.listen( _listenAddress, _port);
 
        if (!l)
                VFS::WARN( QString("%1 could not listen on TCP port %2.  Is it already in use?").arg(className()).arg(_port) );
        else
        {
                if (_port == 0)
                        _port = _socket.serverPort();
                VFS::LOG( QString("%1 listening on TCP port %2 (%3)").arg(className()).arg(_port).arg(_ssl?"secure":"insecure"), 2 );
        }
 
        return l;
}
 
QString VFS_tcp_server::reportDetails()
{
        return QString("address: %1\nport: %2\nlistening: %3").arg(_listenAddress.toString()).arg(_port).arg(_socket.isListening()?"true":"false");
}
 
void VFS_tcp_server::createNewConnection()
{
        //VFS::WARN( QString("%1 newConnection() should be overridden in a subclass").arg(className()) );
 
        while(_socket.hasPendingConnections())
        {
                QTcpSocket *s = _socket.nextPendingConnection();
 
                VFS_tcp_client *client = newClient( s, _ssl, _sslConfiguration );
 
                connect(        client, SIGNAL( disconnected() ),
                                this,   SLOT(   closeConnection() )     );
 
                //moved to newConnection() so it can be overridden.
                //connect(      client, SIGNAL( readyMessage(QByteArray)),
                //              this,   SLOT(   clientMessage(QByteArray))      );
 
                connect(        client, SIGNAL( error(QAbstractSocket::SocketError) ),
                                this,   SLOT(   clientError(QAbstractSocket::SocketError) )     );
 
                QHostAddress a = s->peerAddress();
                QString name = uniqueChildName(a.toString());
 
                if (append(name,client))
                {
                        VFS::LOG( QString("New connection from '%1' to port %2 (%3)\n").arg(client->_address).arg(_port).arg(_ssl?"secure":"insecure"), 8, className() );
                        newConnection(client);
                }
                else
                        delete client;
        }
}
 
//FIXME -- add some kind of auth here?
void VFS_tcp_server::newConnection(VFS_tcp_client *client)
{
        connect(        client, SIGNAL( readyMessage(QByteArray)),
                        this,   SLOT(   clientMessage(QByteArray))      );
 
        client->initSSL();
 
        /*
        if (false)
        {
                //by default not authorized
                VFS::ERROR( QString("Client '%1' is not authorized!\n").arg(client->_address) );
                client->close();
        }
        */
}
 
VFS_tcp_client *VFS_tcp_server::newClient(QTcpSocket *socket, bool ssl, QSslConfiguration sslConfiguration)
{
        return new VFS_tcp_client( socket, ssl, sslConfiguration);
}
 
 
void VFS_tcp_server::closeConnection()
{
        VFS_tcp_client *s = dynamic_cast< VFS_tcp_client * >(sender());
 
        if (s)
        {
                QString n;
                s->close();
                remove( s,&n );
 
                VFS::LOG( QString("Closing %1 connection '%2'").arg(s->className()).arg(n), 3 );
 
                delete s;
                //s->deleteLater();
        }
        else
        {
                VFS::WARN( QString("Disconnection, however could not cast sender to VFS_tcp_client.") );
        }
}
 
void VFS_tcp_server::clientMessage(QByteArray message)
{
        VFS::WARN( QString("%1 clientMessage() should be overridden in a subclass").arg(className()) );
 
        VFS_tcp_client *s = dynamic_cast< VFS_tcp_client * >(sender());
 
        if (s)
        {
                VFS::LOG( QString("%1=>%2 read: %3").arg(className()).arg(s->className()).arg( QString(message) ) );
 
                //s->close();
        }
        else
                VFS::WARN( QString("%1 clientData() called without client!").arg(className()) );
 
}
 
void VFS_tcp_server::clientError(QAbstractSocket::SocketError error)
{
        if (error != QAbstractSocket::RemoteHostClosedError )
        {
                //VFS::ERROR( QString("%1: (%2) %3").arg(className()).arg(error).arg(_socket.errorString()) );
                //VFS::WARN( QString("(%1) Seems like something should happen here.").arg(className()) );
        }
}
 
void VFS_tcp_server::read(VFS_request *r)
{
        VFS_node::ls(r);
}
 
void VFS_tcp_server::metadata(VFS_request *r)
{
        VFS_node::metadata(r);
 
        r->_metadata["address"] = _listenAddress.toString();
        r->_metadata["port"] = _port;
}