/***************************************************************************
- * Copyright (C) 2005-08 by the Quassel IRC Team *
+ * Copyright (C) 2005-09 by the Quassel Project *
* devel@quassel-irc.org *
* *
* This program is free software; you can redistribute it and/or modify *
#endif
#include "client.h"
-#include "global.h"
#include "identity.h"
-#include "ircuser.h"
-#include "ircchannel.h"
#include "network.h"
+#include "networkmodel.h"
+#include "quassel.h"
#include "signalproxy.h"
-
+#include "util.h"
ClientSyncer::ClientSyncer(QObject *parent)
: QObject(parent)
//emit coreConnectionMsg(tr("Connecting..."));
Q_ASSERT(!socket);
-#ifndef QT_NO_OPENSSL
+#ifdef HAVE_SSL
QSslSocket *sock = new QSslSocket(Client::instance());
+ connect(sock, SIGNAL(encrypted()), this, SIGNAL(encrypted()));
#else
if(conn["useSsl"].toBool()) {
emit connectionError(tr("<b>This client is built without SSL Support!</b><br />Disable the usage of SSL in the account settings."));
- emit encrypted(false);
return;
}
QTcpSocket *sock = new QTcpSocket(Client::instance());
//emit coreConnectionMsg(tr("Synchronizing to core..."));
QVariantMap clientInit;
clientInit["MsgType"] = "ClientInit";
- clientInit["ClientVersion"] = Global::quasselVersion;
- clientInit["ClientBuild"] = 860; // FIXME legacy!
- clientInit["ClientDate"] = Global::quasselBuildDate;
- clientInit["ProtocolVersion"] = Global::protocolVersion;
+ clientInit["ClientVersion"] = Quassel::buildInfo().fancyVersionString;
+ clientInit["ClientDate"] = Quassel::buildInfo().buildDate;
+ clientInit["ProtocolVersion"] = Quassel::buildInfo().protocolVersion;
clientInit["UseSsl"] = coreConnectionInfo["useSsl"];
#ifndef QT_NO_COMPRESS
clientInit["UseCompression"] = true;
SignalProxy::writeDataToDevice(socket, clientInit);
}
+void ClientSyncer::useInternalCore() {
+ AccountId internalAccountId;
+
+ CoreAccountSettings accountSettings;
+ QList<AccountId> knownAccounts = accountSettings.knownAccounts();
+ foreach(AccountId id, knownAccounts) {
+ if(!id.isValid())
+ continue;
+ QVariantMap data = accountSettings.retrieveAccountData(id);
+ if(data.contains("InternalAccount") && data["InternalAccount"].toBool()) {
+ internalAccountId = id;
+ break;
+ }
+ }
+
+ if(!internalAccountId.isValid()) {
+ for(AccountId i = 1;; i++) {
+ if(!knownAccounts.contains(i)) {
+ internalAccountId = i;
+ break;
+ }
+ }
+ QVariantMap data;
+ data["InternalAccount"] = true;
+ accountSettings.storeAccountData(internalAccountId, data);
+ }
+
+ coreConnectionInfo["AccountId"] = QVariant::fromValue<AccountId>(internalAccountId);
+ emit startInternalCore(this);
+ emit connectToInternalCore(Client::instance()->signalProxy());
+}
+
void ClientSyncer::coreSocketDisconnected() {
emit socketDisconnected();
Client::instance()->disconnectFromCore();
coreConnectionInfo.clear();
netsToSync.clear();
- channelsToSync.clear();
- usersToSync.clear();
blockSize = 0;
//restartPhaseNull();
}
void ClientSyncer::clientInitAck(const QVariantMap &msg) {
// Core has accepted our version info and sent its own. Let's see if we accept it as well...
- if((msg.contains("CoreBuild") && msg["CoreBuild"].toUInt() < 732) // legacy!
- || (!msg.contains("CoreBuild") && msg["ProtocolVersion"].toUInt() < Global::clientNeedsProtocol)) {
+ uint ver = msg["ProtocolVersion"].toUInt();
+ if(ver < Quassel::buildInfo().clientNeedsProtocol) {
emit connectionError(tr("<b>The Quassel Core you are trying to connect to is too old!</b><br>"
- "Need at least core/client protocol v%1 to connect.").arg(Global::clientNeedsProtocol));
+ "Need at least core/client protocol v%1 to connect.").arg(Quassel::buildInfo().clientNeedsProtocol));
disconnectFromCore();
return;
}
emit connectionMsg(msg["CoreInfo"].toString());
-#ifndef QT_NO_OPENSSL
+#ifndef QT_NO_COMPRESS
+ if(msg["SupportsCompression"].toBool()) {
+ socket->setProperty("UseCompression", true);
+ }
+#endif
+
+ _coreMsgBuffer = msg;
+#ifdef HAVE_SSL
if(coreConnectionInfo["useSsl"].toBool()) {
if(msg["SupportSsl"].toBool()) {
QSslSocket *sslSocket = qobject_cast<QSslSocket *>(socket);
Q_ASSERT(sslSocket);
+ connect(sslSocket, SIGNAL(encrypted()), this, SLOT(sslSocketEncrypted()));
connect(sslSocket, SIGNAL(sslErrors(const QList<QSslError> &)), this, SLOT(sslErrors(const QList<QSslError> &)));
+
sslSocket->startClientEncryption();
- emit encrypted(true);
- Client::instance()->setSecuredConnection();
} else {
emit connectionError(tr("<b>The Quassel Core you are trying to connect to does not support SSL!</b><br />If you want to connect anyways, disable the usage of SSL in the account settings."));
- emit encrypted(false);
disconnectFromCore();
- return;
}
+ return;
}
#endif
+ // if we use SSL we wait for the next step until every SSL warning has been cleared
+ connectionReady();
+}
-#ifndef QT_NO_COMPRESS
- if(msg["SupportsCompression"].toBool()) {
- socket->setProperty("UseCompression", true);
- }
-#endif
-
- if(!msg["Configured"].toBool()) {
+void ClientSyncer::connectionReady() {
+ if(!_coreMsgBuffer["Configured"].toBool()) {
// start wizard
- emit startCoreSetup(msg["StorageBackends"].toList());
- } else if(msg["LoginEnabled"].toBool()) {
+ emit startCoreSetup(_coreMsgBuffer["StorageBackends"].toList());
+ } else if(_coreMsgBuffer["LoginEnabled"].toBool()) {
emit startLogin();
}
+ _coreMsgBuffer.clear();
+ resetWarningsHandler();
}
void ClientSyncer::doCoreSetup(const QVariant &setupData) {
SignalProxy::writeDataToDevice(socket, clientLogin);
}
+void ClientSyncer::internalSessionStateReceived(const QVariant &packedState) {
+ QVariantMap state = packedState.toMap();
+ emit sessionProgress(1, 1);
+ Client::instance()->setConnectedToCore(coreConnectionInfo["AccountId"].value<AccountId>());
+ syncToCore(state);
+}
+
void ClientSyncer::sessionStateReceived(const QVariantMap &state) {
emit sessionProgress(1, 1);
disconnect(this, SIGNAL(recvPartialItem(quint32, quint32)), this, SIGNAL(sessionProgress(quint32, quint32)));
disconnect(socket, 0, this, 0); // rest of communication happens through SignalProxy
- //Client::signalProxy()->addPeer(socket);
- Client::instance()->setConnectedToCore(socket, coreConnectionInfo["AccountId"].value<AccountId>());
+ Client::instance()->setConnectedToCore(coreConnectionInfo["AccountId"].value<AccountId>(), socket);
syncToCore(state);
}
void ClientSyncer::syncToCore(const QVariantMap &sessionState) {
-
// create identities
foreach(QVariant vid, sessionState["Identities"].toList()) {
Client::instance()->coreIdentityCreated(vid.value<Identity>());
// create buffers
// FIXME: get rid of this crap
QVariantList bufferinfos = sessionState["BufferInfos"].toList();
- foreach(QVariant vinfo, bufferinfos) Client::buffer(vinfo.value<BufferInfo>()); // create Buffers and BufferItems
+ NetworkModel *networkModel = Client::networkModel();
+ Q_ASSERT(networkModel);
+ foreach(QVariant vinfo, bufferinfos)
+ networkModel->bufferUpdated(vinfo.value<BufferInfo>()); // create BufferItems
QVariantList networkids = sessionState["NetworkIds"].toList();
- // prepare sync progress thingys... FIXME: Care about removal of networks
+ // prepare sync progress thingys...
+ // FIXME: Care about removal of networks
numNetsToSync = networkids.count();
- numChannelsToSync = 0; //sessionState["IrcChannelCount"].toUInt();
- numUsersToSync = 0; // sessionState["IrcUserCount"].toUInt(); qDebug() << numUsersToSync;
emit networksProgress(0, numNetsToSync);
- emit channelsProgress(0, numChannelsToSync);
- emit ircUsersProgress(0, numUsersToSync);
// create network objects
foreach(QVariant networkid, networkids) {
NetworkId netid = networkid.value<NetworkId>();
+ if(Client::network(netid))
+ continue;
Network *net = new Network(netid, Client::instance());
netsToSync.insert(net);
connect(net, SIGNAL(initDone()), this, SLOT(networkInitDone()));
- connect(net, SIGNAL(ircUserInitDone(IrcUser *)), this, SLOT(ircUserInitDone(IrcUser *)));
- connect(net, SIGNAL(ircUserAdded(IrcUser *)), this, SLOT(ircUserAdded(IrcUser *)));
- connect(net, SIGNAL(ircUserRemoved(QObject *)), this, SLOT(ircUserRemoved(QObject *)));
- connect(net, SIGNAL(ircChannelInitDone(IrcChannel *)), this, SLOT(ircChannelInitDone(IrcChannel *)));
- connect(net, SIGNAL(ircChannelAdded(IrcChannel *)), this, SLOT(ircChannelAdded(IrcChannel *)));
- connect(net, SIGNAL(ircChannelRemoved(QObject *)), this, SLOT(ircChannelRemoved(QObject *)));
Client::addNetwork(net);
}
checkSyncState();
checkSyncState();
}
-void ClientSyncer::ircChannelInitDone(IrcChannel *chan) {
- channelsToSync.remove(chan);
- emit channelsProgress(numChannelsToSync - channelsToSync.count(), numChannelsToSync);
- checkSyncState();
-}
-
-void ClientSyncer::ircChannelAdded(IrcChannel *chan) {
- if(!chan->isInitialized()) {
- channelsToSync.insert(chan);
- numChannelsToSync++;
- emit channelsProgress(numChannelsToSync - channelsToSync.count(), numChannelsToSync);
- checkSyncState();
+void ClientSyncer::checkSyncState() {
+ if(netsToSync.isEmpty()) {
+ Client::instance()->setSyncedToCore();
+ emit syncFinished();
}
}
-void ClientSyncer::ircChannelRemoved(QObject *chan) {
- if(channelsToSync.contains(chan)) {
- numChannelsToSync--;
- channelsToSync.remove(chan);
- emit channelsProgress(numChannelsToSync - channelsToSync.count(), numChannelsToSync);
- checkSyncState();
- }
+void ClientSyncer::setWarningsHandler(const char *slot) {
+ resetWarningsHandler();
+ connect(this, SIGNAL(handleIgnoreWarnings(bool)), this, slot);
}
-void ClientSyncer::ircUserInitDone(IrcUser *user) {
- usersToSync.remove(user);
- emit ircUsersProgress(numUsersToSync - usersToSync.count(), numUsersToSync);
- checkSyncState();
+void ClientSyncer::resetWarningsHandler() {
+ disconnect(this, SIGNAL(handleIgnoreWarnings(bool)), this, 0);
}
-void ClientSyncer::ircUserAdded(IrcUser *user) {
- if(!user->isInitialized()) {
- usersToSync.insert(user);
- numUsersToSync++;
- emit ircUsersProgress(numUsersToSync - usersToSync.count(), numUsersToSync);
- checkSyncState();
+#ifdef HAVE_SSL
+void ClientSyncer::ignoreSslWarnings(bool permanently) {
+ QSslSocket *sock = qobject_cast<QSslSocket *>(socket);
+ if(sock) {
+ // ensure that a proper state is displayed and no longer a warning
+ emit socketStateChanged(sock->state());
}
+ if(permanently) {
+ if(!sock)
+ qWarning() << Q_FUNC_INFO << "unable to save cert digest! Socket is either a nullptr or not a QSslSocket";
+ else
+ KnownHostsSettings().saveKnownHost(sock);
+ }
+ emit connectionMsg(_coreMsgBuffer["CoreInfo"].toString());
+ connectionReady();
}
-void ClientSyncer::ircUserRemoved(QObject *user) {
- if(usersToSync.contains(user)) {
- numUsersToSync--;
- usersToSync.remove(user);
- emit ircUsersProgress(numUsersToSync - usersToSync.count(), numUsersToSync);
- checkSyncState();
+void ClientSyncer::sslSocketEncrypted() {
+ QSslSocket *socket = qobject_cast<QSslSocket *>(sender());
+ if(socket) {
+ QByteArray digest = socket->peerCertificate().digest();
}
}
-void ClientSyncer::checkSyncState() {
- if(usersToSync.count() + channelsToSync.count() + netsToSync.count() == 0) {
- // done syncing!
- /*
- qDebug() << "done";
- foreach(Network *net, _networks.values()) {
- //disconnect(net, 0, this, SLOT(networkInitDone()));
- //disconnect(net, 0, this, SLOT(ircUserInitDone(IrcUser *)));
- //disconnect(net, 0, this, SLOT(ircUserAdded(IrcUser *)));
- //disconnect(net, 0, this, SLOT(ircUserRemoved(QObject *)));
- //disconnect(net, 0, this, SLOT(ircChannelInitDone(IrcChannel *)));
- //disconnect(net, 0, this, SLOT(ircChannelAdded(IrcChannel *)));
- //disconnect(net, 0, this, SLOT(ircChannelRemoved(QObject *)));
- qDebug() << "disconnecting";
- disconnect(net, SIGNAL(initDone()), this, SLOT(networkInitDone()));
- disconnect(net, SIGNAL(ircUserInitDone(IrcUser *)), this, SLOT(ircUserInitDone(IrcUser *)));
- disconnect(net, SIGNAL(ircUserAdded(IrcUser *)), this, SLOT(ircUserAdded(IrcUser *)));
- disconnect(net, SIGNAL(ircUserRemoved(QObject *)), this, SLOT(ircUserRemoved(QObject *)));
- disconnect(net, SIGNAL(ircChannelInitDone(IrcChannel *)), this, SLOT(ircChannelInitDone(IrcChannel *)));
- disconnect(net, SIGNAL(ircChannelAdded(IrcChannel *)), this, SLOT(ircChannelAdded(IrcChannel *)));
- disconnect(net, SIGNAL(ircChannelRemoved(QObject *)), this, SLOT(ircChannelRemoved(QObject *)));
+void ClientSyncer::sslErrors(const QList<QSslError> &errors) {
+ QByteArray knownDigest;
+ QSslSocket *socket = qobject_cast<QSslSocket *>(sender());
+ if(socket) {
+ socket->ignoreSslErrors();
+ knownDigest = KnownHostsSettings().knownDigest(socket);
+ if(knownDigest == socket->peerCertificate().digest()) {
+ connectionReady();
+ return;
}
- */
-
- Client::instance()->setSyncedToCore();
- emit syncFinished();
- //emit connected();
- //emit connectionStateChanged(true);
-
}
-}
-#ifndef QT_NO_OPENSSL
-void ClientSyncer::sslErrors(const QList<QSslError> &errors) {
- qDebug() << "SSL Errors:";
+ QStringList warnings;
+
foreach(QSslError err, errors)
- qDebug() << " " << err;
+ warnings << err.errorString();
- QSslSocket *socket = qobject_cast<QSslSocket *>(sender());
- if(socket)
- socket->ignoreSslErrors();
+ if(!knownDigest.isEmpty()) {
+ warnings << tr("Cert Digest changed! was: %1").arg(QString(prettyDigest(knownDigest)));
+ }
+
+ setWarningsHandler(SLOT(ignoreSslWarnings(bool)));
+ emit connectionWarnings(warnings);
}
#endif