VFS_tcp_client.cpp

Go to the documentation of this file.

 
#include <arpa/inet.h>
 
#include <QJsonDocument>
#include <QJsonObject>
#include <QFile>
 
#include "VFS.h"
#include "VFS_tcp_client.h"
 
VFS_tcp_client::VFS_tcp_client(QTcpSocket *socket, bool ssl, QString sslCertPath)
: VFS_node()
, _socket(socket)
, _messageSize(0)
, _initialized(false)
, _ssl(ssl)
, _sslCertPath(sslCertPath)
{
        _address = _socket->peerAddress().toString();
        _port = _socket->peerPort();
 
        //connect(VFS::root(),SIGNAL(initialized()),this,SLOT(init()));
        connect(this,SIGNAL(mounted()),this,SLOT(init()));
        connect(this,SIGNAL(unmounted(VFS_node*)),this,SLOT(close()));
 
        if (_ssl)
        {
                //printf("SSL socket!\n");
                QSslSocket *_sslSocket = dynamic_cast<QSslSocket *> (_socket);
 
                //add certificates
                QList<QSslCertificate> certs = QSslCertificate::fromPath(_sslCertPath, QSsl::Pem);
                if (!certs.length())
                        VFS::WARN(QString("Failed to add '%1' as a cert. Is the format or path bad?").arg(_sslCertPath),0,className());
                //else
                //      VFS::LOG( QString("Using cert file: '%1'").arg(_sslCertPath), 9, className() );
 
                QSslConfiguration sslConfiguration;
                sslConfiguration.addCaCertificates(certs);
                _sslSocket->setSslConfiguration(sslConfiguration);
 
                //peer verify
                connect(_sslSocket, SIGNAL(peerVerifyError(QSslError)), this, SLOT(peerVerifyError(QSslError)));
 
                //sslErrors
                connect(_sslSocket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(sslErrors(QList<QSslError>)));
 
                //mode change
                connect(_sslSocket, SIGNAL(modeChanged(QSslSocket::SslMode)), this, SLOT(modeChanged(QSslSocket::SslMode)));
 
                //encrypted
                connect(_sslSocket, SIGNAL(encrypted()), this, SLOT(sslReady()));
        }
}
 
VFS_tcp_client::VFS_tcp_client(QString address, quint16 port, bool ssl, QString sslCertPath)
: VFS_node()
, _socket(nullptr)
, _messageSize(0)
, _initialized(false)
, _address(address)
, _port(port)
, _ssl(ssl)
, _sslCertPath(sslCertPath)
{
        if (_ssl)
                _socket = new QSslSocket(this);
        else
                _socket = new QTcpSocket(this);
 
        connect(VFS::root(),SIGNAL(initialized()),this,SLOT(init()));
        connect(this,SIGNAL(mounted()),this,SLOT(init()));
        connect(this,SIGNAL(unmounted(VFS_node*)),this,SLOT(close()));
 
        if (_ssl)
        {
                //printf("SSL socket!\n");
                QSslSocket *_sslSocket = dynamic_cast<QSslSocket *> (_socket);
 
                //add certificates
                QList<QSslCertificate> certs = QSslCertificate::fromPath(_sslCertPath, QSsl::Pem);
                if (!certs.length())
                        VFS::WARN(QString("Failed to add '%1' as a cert. Is the format or path bad?").arg(_sslCertPath),0,className());
                //else
                //      VFS::LOG( QString("Using cert file: '%1'").arg(_sslCertPath), 9, className() );
 
                QSslConfiguration sslConfiguration;
                sslConfiguration.addCaCertificates(certs);
                _sslSocket->setSslConfiguration(sslConfiguration);
 
                //peer verify
                connect(_sslSocket, SIGNAL(peerVerifyError(QSslError)), this, SLOT(peerVerifyError(QSslError)));
 
                //sslErrors
                connect(_sslSocket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(sslErrors(QList<QSslError>)));
 
                //mode change
                connect(_sslSocket, SIGNAL(modeChanged(QSslSocket::SslMode)), this, SLOT(modeChanged(QSslSocket::SslMode)));
 
                //encrypted
                connect(_sslSocket, SIGNAL(encrypted()), this, SLOT(sslReady()));
 
                //check for encrypted
                //connect(_sslSocket, SIGNAL(connected()), this, SLOT(initSSL()));
        }
}
 
 
VFS_tcp_client::VFS_tcp_client(QTcpSocket *socket, bool ssl, QSslConfiguration sslConfiguration)
: VFS_node()
, _socket(socket)
, _messageSize(0)
, _initialized(false)
, _ssl(ssl)
{
        _address = _socket->peerAddress().toString();
        _port = _socket->peerPort();
 
        //connect(VFS::root(),SIGNAL(initialized()),this,SLOT(init()));
        connect(this,SIGNAL(mounted()),this,SLOT(init()));
        connect(this,SIGNAL(unmounted(VFS_node*)),this,SLOT(close()));
 
        if (_ssl)
        {
                //printf("SSL socket!\n");
                QSslSocket *_sslSocket = dynamic_cast<QSslSocket *> (_socket);
 
                //add configuration
                _sslSocket->setSslConfiguration(sslConfiguration);
 
                //peer verify
                connect(_sslSocket, SIGNAL(peerVerifyError(QSslError)), this, SLOT(peerVerifyError(QSslError)));
 
                //sslErrors
                connect(_sslSocket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(sslErrors(QList<QSslError>)));
 
                //mode change
                connect(_sslSocket, SIGNAL(modeChanged(QSslSocket::SslMode)), this, SLOT(modeChanged(QSslSocket::SslMode)));
 
                //encrypted
                connect(_sslSocket, SIGNAL(encrypted()), this, SLOT(sslReady()));
 
                //check for encrypted
                //connect(_sslSocket, SIGNAL(connected()), this, SLOT(initSSL()));
        }
}
 
 
VFS_tcp_client::~VFS_tcp_client()
{
        close();
 
        _socket->deleteLater();
}
 
 
void VFS_tcp_client::init()
{
        if (_initialized)
                return;
 
        //printf("TCP_CLIENT INIT\n");
 
        connect(        _socket,        SIGNAL( connected()             ),
                        this,           SLOT(   initSSL()               )               );
 
        //connect(      _socket,        SIGNAL( modeChanged(QSslSocket::SslMode)),
        //              this,           SLOT(   modeChanged(QSslSocket::SslMode))       );
 
        connect(        _socket,        SIGNAL( disconnected()          ),
                        this,           SIGNAL( disconnected()          )               );
 
        connect(        _socket,        SIGNAL( readyRead()             ),
                        this,           SLOT(   readyRead()             )               );
 
        connect(        this,           SIGNAL( moreToRead()            ),
                        this,           SLOT(   readyRead()             )               );
 
        connect(        _socket,        SIGNAL( error(QAbstractSocket::SocketError) ),
                        this,           SIGNAL( error(QAbstractSocket::SocketError) )   );
 
        //initSSL();
 
        _initialized = true;
}
 
void VFS_tcp_client::initSSL()
{
        //printf("INIT SSL!\n");
        //return;
 
        if (_ssl)
        {
                QSslSocket *_sslSocket = dynamic_cast<QSslSocket *> (_socket);
                if (!_sslSocket->isEncrypted())
                {
                        QString cn = className();
 
                        if (!_sslSocket->waitForEncrypted(500))
                        {
                                //if the socket closes and the destructor is called, className() is no longer available, so we save it ahead of time.
                                VFS::WARN( QString("SSL socket is not in encrypted state.  You may need to enable SSL on the remote side.  Closing socket. (%1:%2)").arg(_address).arg(_port),0,cn);
 
                                //sometimes sockets are closed twice, depending on destructor sequence.
                                if (!__isNode(this))
                                        return;
 
                                //this will also be invalid after the destructor
                                close();
                                //deleteLater();
                                //emit finished(false);
 
                                return;
                        }
                        //else
                        //      VFS::LOG("SSL socket is now in encrypted state.",9,className());
                }
        }
 
        emit connected();
}
 
 
void VFS_tcp_client::close()
{
        _socket->close();
}
 
 
void VFS_tcp_client::readyRead()
{
        if (_messageSize == 0)
        {
                if ( _socket->bytesAvailable() >= (qint64) sizeof(MESSAGE_SIZE) )
                {
                        MESSAGE_SIZE m;
                        _socket->read((char*)&m,sizeof(MESSAGE_SIZE));
                        _messageSize = ntohl(m);
 
                        //printf("RECEIVE MESSAGE SIZE: %d\n",_messageSize);
 
                        if (_messageSize > MAX_MESSAGE_SIZE)
                        {
                                //FIXME
                                VFS::ERROR( QString("%1 message size of %2 was too big.  Wierd stuff is going to happen.").arg(className()).arg(_messageSize) );
                                _messageSize = 0;
                                return;
                        }
                }
                else
                        return;
        }
 
        if (_socket->bytesAvailable() >= _messageSize)
        {
                QByteArray message = _socket->read(_messageSize);
 
                if (message.length() == 0)
                {
                        VFS::ERROR( QString("%1 message was empty.  It should be %2.  Check for errors.").arg(className()).arg(_messageSize) );
                }
 
                _messageSize = 0;
                emit readyMessage(message);
        }
        else
                return;
 
        //allow multiple messages coming in together to process...
        if (_socket->bytesAvailable() > 0)
                emit moreToRead();
}
 
 
void VFS_tcp_client::writeMessage(QByteArray data)
{
        MESSAGE_SIZE s = data.size();
        MESSAGE_SIZE n = htonl(s);
 
        //printf("SEND MESSAGE SIZE: %d %d %d\n",data.length(),s,n);
 
        _socket->write((char*)&n,sizeof(MESSAGE_SIZE));
        _socket->write(data);
}
 
 
void VFS_tcp_client::write(VFS_request *r)
{
        Q_UNUSED(r);
 
        printf("about to write..\n");
        printf("socket parent: %p\n",_socket->thread());
 
        printf("FIXME: VFS_tcp_client::write needs to be defined!");
        //_socket->write(r->_data.toJson());
 
        printf("wrote...\n");
}
 
 
bool VFS_tcp_client::isContainer()
{
        return false;
}
 
 
QString VFS_tcp_client::reportDetails()
{
        return QString("%1:%2 (%3)").arg(_address).arg(_port).arg(_ssl?"secure":"insecure");
}
 
 
void VFS_tcp_client::peerVerifyError(const QSslError &error)
{
        Q_UNUSED(error)
 
        //A peer verify error is also an SSL error, so no need to print twice
        //VFS::ERROR(QString("Peer verify error: %1").arg(error.errorString()),0,className());
}
 
 
void VFS_tcp_client::sslErrors(const QList<QSslError> &errors)
{
        for (int i=0;i<errors.length();i++)
                VFS::ERROR(QString("SSL error: %1").arg(errors[i].errorString()),0,className());
}
 
void VFS_tcp_client::modeChanged(QSslSocket::SslMode mode)
{
        Q_UNUSED(mode);
 
        //VFS::WARN( QString("SOCKET MODE IS NOW: %1").arg(mode), 0, this->metaObject()->className() );
}
 
void VFS_tcp_client::sslReady()
{
        VFS::LOG( "SSL handshake complete.", 9, this->metaObject()->className() );
}