VFS_websocket_server.cpp

Go to the documentation of this file.

 
#include "VFS_websocket_server.h"
#include "VFS.h"
#include "VFS_auth/VFS_auth.h"
 
#include <QFile>
#include <QRegExp>
#include <QtNetwork/QSslCertificate>
#include <QtNetwork/QSslKey>
 
VFS_websocket_server::VFS_websocket_server(quint16 port, QString authPaths, QString sessions, QHostAddress addr, QWebSocketServer::SslMode ssl, QString sslCertPath, QString sslKeyPath)
: VFS_node()
, _listenAddress(addr)
, _port(port)
, _ssl(ssl)
, _sslCertPath(sslCertPath)
, _sslKeyPath(sslKeyPath)
, _socket("REMOTO_WS",ssl,this)
, _authPaths(authPaths.split(","))
, _sessionsPath(sessions)
{
        //_listenTimer.setSingleShot(true);
        //_listenTimer.setInterval(100);
 
        _authPaths.replaceInStrings(QRegExp("\\s+(.*)"),"\\1");         //trim the auth paths
        _authPaths.replaceInStrings(QRegExp("(.*)\\s+"),"\\1");         //trim the auth paths
 
        //connect(this,SIGNAL(mounted()),this,SLOT(listen()));                  //bad!  We don't want a connection while the VFS is being built.
        connect(VFS::root(),SIGNAL(initialized()),this,SLOT(listen()));
 
        //connect(VFS::root(),SIGNAL(initialized()),&_listenTimer,SLOT(start()));
        //connect(&_listenTimer, SIGNAL(timeout()),this,SLOT(listen()));                //better! We hope the VFS is fully initialzed after 100ms
}
 
VFS_websocket_server::~VFS_websocket_server()
{
        _socket.close();
}
 
bool VFS_websocket_server::isContainer()
{
        return true;
}
 
bool VFS_websocket_server::listen()
{
        if (_socket.isListening())
        {       VFS::WARN( QString("Websocket was already listening!  Close it first?"), 0, className() );
                return false;
        }
 
        _socket.setMaxPendingConnections(200);
 
        connect(&_socket, SIGNAL(newConnection()), this, SLOT(newConnection()));
        connect(&_socket, SIGNAL(acceptError(QAbstractSocket::SocketError)), this, SLOT(clientError(QAbstractSocket::SocketError)));
        connect(&_socket, SIGNAL(serverError(QWebSocketProtocol::CloseCode)), this, SLOT(serverError(QWebSocketProtocol::CloseCode)));
 
        if (_ssl==QWebSocketServer::SecureMode)
        {
                /*
                qDebug() << "Support SSL:  " << QSslSocket::supportsSsl()
                                << "\nLib Version Number: " << QSslSocket::sslLibraryVersionNumber()
                                << "\nLib Version String: " << QSslSocket::sslLibraryVersionString()
                                << "\nLib Build Version Number: " << QSslSocket::sslLibraryBuildVersionNumber()
                                << "\nLib Build Version String: " << QSslSocket::sslLibraryBuildVersionString();
                */
 
                connect(&_socket, SIGNAL(sslErrors(const QList<QSslError> &)), this, SLOT(sslErrors(const QList<QSslError> &)));
 
                bool c=false,k=false;
 
                QSslConfiguration sslConfiguration;
 
                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);     //Is this correct?  We don't want Auto here?
                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::ERROR( QString("Could not listen on port %1").arg(_port), 0, className() );
        else
                VFS::LOG( QString("%1 listening on port %2 (%3)").arg(className()).arg(_port).arg((_ssl==QWebSocketServer::SecureMode?"secure":"insecure")), 2 );
 
        return l;
}
 
void VFS_websocket_server::newConnection()
{
        while(_socket.hasPendingConnections())
        {
                QWebSocket *s = _socket.nextPendingConnection();
                VFS_websocket_client *client = createWebsocketClient(s);
                //VFS_websocket_client *client = new VFS_websocket_client( s );
 
                connect(        client,         SIGNAL( disconnected()          ),
                                this,           SLOT(   closeConnection()       )                       );
 
                connect(        client,         SIGNAL( readyBinaryMessage(QByteArray)),
                                this,           SLOT(   clientBinaryMessage(QByteArray))                );
 
                connect(        client,         SIGNAL( readyTextMessage(QString)),
                                this,           SLOT(   clientTextMessage(QString))                     );
 
                connect(        client,         SIGNAL( error(QAbstractSocket::SocketError)),
                                this,           SLOT(   clientError(QAbstractSocket::SocketError))      );
 
                //now moved to the VFS_websocket_client::authorized method, which is more stable for HA
                //QHostAddress a = s->peerAddress();
                //QString name = uniqueChildName(a.toString());
                //append(name,client);
        }
}
 
VFS_websocket_client *VFS_websocket_server::createWebsocketClient(QWebSocket *socket)
{
        return new VFS_websocket_client( socket, this );
}
 
bool VFS_websocket_server::authenticate(VFS_websocket_client *client, QJsonObject credentials)
{
        credentials.remove("expire");   //prevent a malicious person from setting a long expiration
 
        QString token = credentials["authtoken"].toString("");
        QString tokenonce = credentials["authtokenonce"].toString("");
        QString user = credentials["username"].toString();
        //QString pass = credentials["password"].toString();
 
        //check authtoken first
        if (!token.isEmpty() && !_sessionsPath.isEmpty())
        {
                VFS::LOG( QString("Authenticating token '%1' on '%2'...").arg(token).arg(_sessionsPath), 7 );
                //VFS::LOG( QString("Authenticating token on '%1'...").arg(_sessionsPath), 7 );
 
                VFS_request *r = client->createRequest(VFS_request::read,_sessionsPath+"/tokenauth","server",QJsonDocument(credentials));
                issueRequest(r);
        }
        else if (user.isEmpty() && tokenonce.isEmpty())
        {
                return false;
        }
        else
        {
                int authindex;
                if (!credentials.contains("authindex"))
                        authindex = 0;
                else
                        authindex = credentials["authindex"].toInt()+1;
 
                if (authindex >= _authPaths.size())
                {
                        VFS::ERROR( QString("Exhausted available authpaths, can't authenticate '%1'").arg(user) );
                        //client->close();
                        return false;
                }
 
                QString authpath = _authPaths.at(authindex);
 
                if (!user.isEmpty())
                        VFS::LOG( QString("Authenticating user '%1' on '%2'...").arg(user).arg(authpath), 7 );
                else
                        VFS::LOG( QString("Authenticating on '%1'...").arg(authpath), 7 );
 
                credentials["authindex"] = authindex;
                credentials["authpath"] = authpath;
                credentials["authtoken"] = "";          //reset the authtoken, because we're going to have to create one
 
                VFS_request *r = client->createRequest(VFS_request::read,authpath,"server",QJsonDocument(credentials));
                issueRequest(r);
        }
 
        return true;
}
 
 
void VFS_websocket_server::authorize(VFS_websocket_client *client, QJsonObject authdata)
{
        QString user = authdata["username"].toString();
 
        VFS::LOG( QString("Authorizing user '%1' on '%2'...").arg(user).arg(_sessionsPath), 7 );
 
        VFS_request *r = client->createRequest(VFS_request::create,_sessionsPath,user,QJsonDocument(authdata));
        issueRequest(r);
}
 
 
void VFS_websocket_server::closeConnection()
{
        VFS_websocket_client *s = dynamic_cast< VFS_websocket_client * >(sender());
 
        if (s)
        {
                s->close();
                if (!_children.key(s,"").isEmpty())     //if it was already removed, don't try again.
                {
                        QString n;
                        remove( s,&n );
                        VFS::LOG( QString("Closing %1 connection '%2'").arg(s->className()).arg(n), 2 );
                }
 
                //delete s;
                s->deleteLater();
        }
        else
        {
                VFS::ERROR( "Client was not a VFS_websocket_client... not sure what to do." );
        }
}
 
void VFS_websocket_server::clientBinaryMessage(QByteArray message)
{
        VFS::WARN( QString("%1 clientBinaryMessage() should be overridden in a subclass").arg(className()) );
 
        VFS_websocket_client *s = dynamic_cast< VFS_websocket_client * >(sender());
 
        if (s)
        {
                VFS::LOG( QString("%1=>%2 read:\n%3").arg(className()).arg(s->className()).arg( QString(message) ) );
 
                //s->close();
        }
        else
                VFS::WARN( QString("%1 clientBinaryMessage() called without client!").arg(className()) );
 
}
 
void VFS_websocket_server::clientTextMessage(QString message)
{
        VFS::WARN( QString("%1 clientTextMessage() should be overridden in a subclass").arg(className()) );
 
        VFS_websocket_client *s = dynamic_cast< VFS_websocket_client * >(sender());
 
        if (s)
        {
                VFS::LOG( QString("%1=>%2 read:\n%3").arg(className()).arg(s->className()).arg( message ) );
 
                //s->close();
        }
        else
                VFS::WARN( QString("%1 clientTextMessage() called without client!").arg(className()) );
 
}
 
void VFS_websocket_server::clientError(QAbstractSocket::SocketError error)
{
        if (    error != QAbstractSocket::RemoteHostClosedError &&      //remote connection closed
                error != QAbstractSocket::NetworkError          )       //remote connection error (like when a mobile device sleeps or a network cable is yanked)
        {
                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_websocket_server::serverError(QWebSocketProtocol::CloseCode closeCode)
{
        VFS::ERROR( QString("%1: (%2) %3").arg(className()).arg(closeCode).arg(_socket.errorString()) );
}
 
void VFS_websocket_server::sslErrors(const QList<QSslError> &errors)
{
        for (int i=0;i<errors.size();i++)
                VFS::ERROR( errors.at(i).errorString(), 0, className() );
}