~ubuntu-branches/ubuntu/vivid/quassel/vivid-updates

 *   Copyright (C) 2005-2013 by the Quassel Project                        *

#include "network.h"

#include "logger.h"

 

#include "protocols/legacy/legacypeer.h"

 

    : _storage(0)

    _configured = initStorage(cs.storageSettings().toMap());

    foreach(RemotePeer *peer, clientInfo.keys()) {

        peer->close(); // disconnect non authed clients

    QVariantMap setupData;

    setupData["AdminUser"] = "AdminUser";

    setupData["AdminPasswd"] = QString::number(pass);

    setupData["Backend"] = QString("SQLite"); // mono client currently needs sqlite

    return setupCore(setupData);

}

 

 

QString Core::setupCore(QVariantMap setupData)

{

    QString user = setupData.take("AdminUser").toString();

    QString password = setupData.take("AdminPasswd").toString();

    if (user.isEmpty() || password.isEmpty()) {

        return tr("Admin user or password not set.");

    }

    if (_configured || !(_configured = initStorage(setupData, true))) {

        return tr("Could not setup storage!");

    }

    CoreSettings s;

    s.setStorageSettings(setupData);

    quInfo() << qPrintable(tr("Creating admin user..."));

    _storage->addUser(user, password);

    startListening(); // TODO check when we need this

    return QString();

bool Core::initStorage(const QString &backend, QVariantMap settings, bool setup)

bool Core::initStorage(QVariantMap dbSettings, bool setup)

{

    return initStorage(dbSettings["Backend"].toString(), dbSettings["ConnectionProperties"].toMap(), setup);

}

 

 

        RemotePeer *peer = new LegacyPeer(socket, this);

 

        connect(peer, SIGNAL(disconnected()), SLOT(clientDisconnected()));

        connect(peer, SIGNAL(dataReceived(QVariant)), SLOT(processClientMessage(QVariant)));

        connect(peer, SIGNAL(error(QAbstractSocket::SocketError)), SLOT(socketError(QAbstractSocket::SocketError)));

 

        clientInfo.insert(peer, QVariantMap());

void Core::processClientMessage(const QVariant &data)

{

    RemotePeer *peer = qobject_cast<RemotePeer *>(sender());

    if (!peer) {

        qWarning() << Q_FUNC_INFO << "Message not sent by RemoteConnection!";

        return;

    }

 

    QVariantMap msg = data.toMap();

    if (!msg.contains("MsgType")) {

        // Client is way too old, does not even use the current init format

        qWarning() << qPrintable(tr("Antique client trying to connect... refusing."));

        peer->close();

        return;

    }

 

    // OK, so we have at least an init message format we can understand

    if (msg["MsgType"] == "ClientInit") {

        QVariantMap reply;

 

        // Just version information -- check it!

        uint ver = msg["ProtocolVersion"].toUInt();

        if (ver < Quassel::buildInfo().coreNeedsProtocol) {

            reply["MsgType"] = "ClientInitReject";

            reply["Error"] = tr("<b>Your Quassel Client is too old!</b><br>"

                                "This core needs at least client/core protocol version %1.<br>"

                                "Please consider upgrading your client.").arg(Quassel::buildInfo().coreNeedsProtocol);

            peer->writeSocketData(reply);

            qWarning() << qPrintable(tr("Client")) << peer->description() << qPrintable(tr("too old, rejecting."));

            peer->close();

            return;

        }

 

        reply["ProtocolVersion"] = Quassel::buildInfo().protocolVersion;

        reply["CoreVersion"] = Quassel::buildInfo().fancyVersionString;

        reply["CoreDate"] = Quassel::buildInfo().buildDate;

        reply["CoreStartTime"] = startTime(); // v10 clients don't necessarily parse this, see below

 

        // FIXME: newer clients no longer use the hardcoded CoreInfo (for now), since it gets the

        //        time zone wrong. With the next protocol bump (10 -> 11), we should remove this

        //        or make it properly configurable.

 

        int uptime = startTime().secsTo(QDateTime::currentDateTime().toUTC());

        int updays = uptime / 86400; uptime %= 86400;

        int uphours = uptime / 3600; uptime %= 3600;

        int upmins = uptime / 60;

        reply["CoreInfo"] = tr("<b>Quassel Core Version %1</b><br>"

                               "Built: %2<br>"

                               "Up %3d%4h%5m (since %6)").arg(Quassel::buildInfo().fancyVersionString)

                            .arg(Quassel::buildInfo().buildDate)

                            .arg(updays).arg(uphours, 2, 10, QChar('0')).arg(upmins, 2, 10, QChar('0')).arg(startTime().toString(Qt::TextDate));

 

        reply["CoreFeatures"] = (int)Quassel::features();

 

#ifdef HAVE_SSL

        SslServer *sslServer = qobject_cast<SslServer *>(&_server);

        QSslSocket *sslSocket = qobject_cast<QSslSocket *>(peer->socket());

        bool supportSsl = sslServer && sslSocket && sslServer->isCertValid();

#else

        bool supportSsl = false;

#endif

 

#ifndef QT_NO_COMPRESS

        bool supportsCompression = true;

#else

        bool supportsCompression = false;

#endif

 

        reply["SupportSsl"] = supportSsl;

        reply["SupportsCompression"] = supportsCompression;

        // switch to ssl/compression after client has been informed about our capabilities (see below)

 

        reply["LoginEnabled"] = true;

 

        // check if we are configured, start wizard otherwise

        if (!_configured) {

            reply["Configured"] = false;

            QList<QVariant> backends;

            foreach(Storage *backend, _storageBackends.values()) {

                QVariantMap v;

                v["DisplayName"] = backend->displayName();

                v["Description"] = backend->description();

                v["SetupKeys"] = backend->setupKeys();

                v["SetupDefaults"] = backend->setupDefaults();

                backends.append(v);

            }

            reply["StorageBackends"] = backends;

            reply["LoginEnabled"] = false;

        }

        else {

            reply["Configured"] = true;

        }

        clientInfo[peer] = msg; // store for future reference

        reply["MsgType"] = "ClientInitAck";

        peer->writeSocketData(reply);

        peer->socket()->flush(); // ensure that the write cache is flushed before we switch to ssl

 

#ifdef HAVE_SSL

        // after we told the client that we are ssl capable we switch to ssl mode

        if (supportSsl && msg["UseSsl"].toBool()) {

            qDebug() << qPrintable(tr("Starting TLS for Client:"))  << peer->description();

            connect(sslSocket, SIGNAL(sslErrors(const QList<QSslError> &)), SLOT(sslErrors(const QList<QSslError> &)));

            sslSocket->startServerEncryption();

        }

#endif

 

#ifndef QT_NO_COMPRESS

        if (supportsCompression && msg["UseCompression"].toBool()) {

            peer->socket()->setProperty("UseCompression", true);

            qDebug() << "Using compression for Client:" << qPrintable(peer->socket()->peerAddress().toString());

        }

#endif

    }

    else {

        // for the rest, we need an initialized connection

        if (!clientInfo.contains(peer)) {

            QVariantMap reply;

            reply["MsgType"] = "ClientLoginReject";

            reply["Error"] = tr("<b>Client not initialized!</b><br>You need to send an init message before trying to login.");

            peer->writeSocketData(reply);

            qWarning() << qPrintable(tr("Client")) << qPrintable(peer->socket()->peerAddress().toString()) << qPrintable(tr("did not send an init message before trying to login, rejecting."));

            peer->close(); return;

        }

        if (msg["MsgType"] == "CoreSetupData") {

            QVariantMap reply;

            QString result = setupCore(msg["SetupData"].toMap());

            if (!result.isEmpty()) {

                reply["MsgType"] = "CoreSetupReject";

                reply["Error"] = result;

            }

            else {

                reply["MsgType"] = "CoreSetupAck";

            }

            peer->writeSocketData(reply);

        }

        else if (msg["MsgType"] == "ClientLogin") {

            QVariantMap reply;

            UserId uid = _storage->validateUser(msg["User"].toString(), msg["Password"].toString());

            if (uid == 0) {

                reply["MsgType"] = "ClientLoginReject";

                reply["Error"] = tr("<b>Invalid username or password!</b><br>The username/password combination you supplied could not be found in the database.");

                peer->writeSocketData(reply);

                return;

            }

            reply["MsgType"] = "ClientLoginAck";

            peer->writeSocketData(reply);

            quInfo() << qPrintable(tr("Client")) << qPrintable(peer->socket()->peerAddress().toString()) << qPrintable(tr("initialized and authenticated successfully as \"%1\" (UserId: %2).").arg(msg["User"].toString()).arg(uid.toInt()));

            setupClientSession(peer, uid);

        }

    }

}

 

 

    RemotePeer *peer = qobject_cast<RemotePeer *>(sender());

    Q_ASSERT(peer);

    quInfo() << qPrintable(tr("Non-authed client disconnected.")) << qPrintable(peer->socket()->peerAddress().toString());

    clientInfo.remove(peer);

    peer->deleteLater();

    disconnect(peer, 0, this, 0);

    peer->socket()->flush();

    clientInfo.remove(peer);

            qWarning() << qPrintable(tr("Could not initialize session for client:")) << qPrintable(peer->socket()->peerAddress().toString());

        qWarning() << qPrintable(tr("Could not find a session for client:")) << qPrintable(peer->socket()->peerAddress().toString());

#ifdef HAVE_SSL

void Core::sslErrors(const QList<QSslError> &errors)

    Q_UNUSED(errors);

    QSslSocket *socket = qobject_cast<QSslSocket *>(sender());

    if (socket)

        socket->ignoreSslErrors();

#endif

 

void Core::socketError(QAbstractSocket::SocketError err)

    RemotePeer *peer = qobject_cast<RemotePeer *>(sender());

    if (peer && err != QAbstractSocket::RemoteHostClosedError)

        qWarning() << "Core::socketError()" << peer->socket() << err << peer->socket()->errorString();