src/client/clientauthhandler.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-2014 by the Quassel Project                        *
   3  *   devel@quassel-irc.org                                                 *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) version 3.                                           *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  19  ***************************************************************************/
  20
  21 #include "clientauthhandler.h"
  22
  23 // TODO: support system application proxy (new in Qt 4.6)
  24
  25 #include <QtEndian>
  26
  27 #ifdef HAVE_SSL
  28     #include <QSslSocket>
  29 #else
  30     #include <QTcpSocket>
  31 #endif
  32
  33 #include "client.h"
  34 #include "clientsettings.h"
  35 #include "peerfactory.h"
  36
  37 #include "protocols/legacy/legacypeer.h"
  38
  39 using namespace Protocol;
  40
  41 ClientAuthHandler::ClientAuthHandler(CoreAccount account, QObject *parent)
  42     : AuthHandler(parent),
  43     _peer(0),
  44     _account(account),
  45     _probing(false),
  46     _legacy(false),
  47     _connectionFeatures(0)
  48 {
  49
  50 }
  51
  52
  53 void ClientAuthHandler::connectToCore()
  54 {
  55     CoreAccountSettings s;
  56
  57 #ifdef HAVE_SSL
  58     QSslSocket *socket = new QSslSocket(this);
  59     // make sure the warning is shown if we happen to connect without SSL support later
  60     s.setAccountValue("ShowNoClientSslWarning", true);
  61 #else
  62     if (_account.useSsl()) {
  63         if (s.accountValue("ShowNoClientSslWarning", true).toBool()) {
  64             bool accepted = false;
  65             emit handleNoSslInClient(&accepted);
  66             if (!accepted) {
  67                 emit errorMessage(tr("Unencrypted connection canceled"));
  68                 return;
  69             }
  70             s.setAccountValue("ShowNoClientSslWarning", false);
  71         }
  72     }
  73     QTcpSocket *socket = new QTcpSocket(this);
  74 #endif
  75
  76 // TODO: Handle system proxy
  77 #ifndef QT_NO_NETWORKPROXY
  78     if (_account.useProxy()) {
  79         QNetworkProxy proxy(_account.proxyType(), _account.proxyHostName(), _account.proxyPort(), _account.proxyUser(), _account.proxyPassword());
  80         socket->setProxy(proxy);
  81     }
  82 #endif
  83
  84     setSocket(socket);
  85     connect(socket, SIGNAL(stateChanged(QAbstractSocket::SocketState)), SLOT(onSocketStateChanged(QAbstractSocket::SocketState)));
  86     connect(socket, SIGNAL(readyRead()), SLOT(onReadyRead()));
  87     connect(socket, SIGNAL(connected()), SLOT(onSocketConnected()));
  88
  89     emit statusMessage(tr("Connecting to %1...").arg(_account.accountName()));
  90     socket->connectToHost(_account.hostName(), _account.port());
  91 }
  92
  93
  94 void ClientAuthHandler::onSocketStateChanged(QAbstractSocket::SocketState socketState)
  95 {
  96     QString text;
  97
  98     switch(socketState) {
  99         case QAbstractSocket::HostLookupState:
 100             if (!_legacy)
 101                 text = tr("Looking up %1...").arg(_account.hostName());
 102             break;
 103         case QAbstractSocket::ConnectingState:
 104             if (!_legacy)
 105                 text = tr("Connecting to %1...").arg(_account.hostName());
 106             break;
 107         case QAbstractSocket::ConnectedState:
 108             text = tr("Connected to %1").arg(_account.hostName());
 109             break;
 110         case QAbstractSocket::ClosingState:
 111             if (!_probing)
 112                 text = tr("Disconnecting from %1...").arg(_account.hostName());
 113             break;
 114         case QAbstractSocket::UnconnectedState:
 115             if (!_probing) {
 116                 text = tr("Disconnected");
 117                 // Ensure the disconnected() signal is sent even if we haven't reached the Connected state yet.
 118                 // The baseclass implementation will make sure to only send the signal once.
 119                 onSocketDisconnected();
 120             }
 121             break;
 122         default:
 123             break;
 124     }
 125
 126     if (!text.isEmpty()) {
 127         emit statusMessage(text);
 128     }
 129 }
 130
 131 void ClientAuthHandler::onSocketError(QAbstractSocket::SocketError error)
 132 {
 133     if (_probing && error == QAbstractSocket::RemoteHostClosedError) {
 134         _legacy = true;
 135         return;
 136     }
 137
 138     _probing = false; // all other errors are unrelated to probing and should be handled
 139     AuthHandler::onSocketError(error);
 140 }
 141
 142
 143 void ClientAuthHandler::onSocketDisconnected()
 144 {
 145     if (_probing && _legacy) {
 146         // Remote host has closed the connection while probing
 147         _probing = false;
 148         disconnect(socket(), SIGNAL(readyRead()), this, SLOT(onReadyRead()));
 149         emit statusMessage(tr("Reconnecting in compatibility mode..."));
 150         socket()->connectToHost(_account.hostName(), _account.port());
 151         return;
 152     }
 153
 154     AuthHandler::onSocketDisconnected();
 155 }
 156
 157
 158 void ClientAuthHandler::onSocketConnected()
 159 {
 160     if (_peer) {
 161         qWarning() << Q_FUNC_INFO << "Peer already exists!";
 162         return;
 163     }
 164
 165     socket()->setSocketOption(QAbstractSocket::KeepAliveOption, true);
 166
 167     if (!_legacy) {
 168         // First connection attempt, try probing for a capable core
 169         _probing = true;
 170
 171         QDataStream stream(socket()); // stream handles the endianness for us
 172
 173         quint32 magic = Protocol::magic;
 174 #ifdef HAVE_SSL
 175         if (_account.useSsl())
 176             magic |= Protocol::Encryption;
 177 #endif
 178         //magic |= Protocol::Compression; // not implemented yet
 179
 180         stream << magic;
 181
 182         // here goes the list of protocols we support, in order of preference
 183         stream << ((quint32)Protocol::LegacyProtocol | 0x80000000); // end list
 184
 185         socket()->flush(); // make sure the probing data is sent immediately
 186         return;
 187     }
 188
 189     // If we arrive here, it's the second connection attempt, meaning probing was not successful -> enable legacy support
 190
 191     qDebug() << "Legacy core detected, switching to compatibility mode";
 192
 193     RemotePeer *peer = new LegacyPeer(this, socket(), this);
 194     // Only needed for the legacy peer, as all others check the protocol version before instantiation
 195     connect(peer, SIGNAL(protocolVersionMismatch(int,int)), SLOT(onProtocolVersionMismatch(int,int)));
 196
 197     setPeer(peer);
 198 }
 199
 200
 201 void ClientAuthHandler::onReadyRead()
 202 {
 203     if (socket()->bytesAvailable() < 4)
 204         return;
 205
 206     if (!_probing)
 207         return; // make sure to not read more data than needed
 208
 209     _probing = false;
 210     disconnect(socket(), SIGNAL(readyRead()), this, SLOT(onReadyRead()));
 211
 212     quint32 reply;
 213     socket()->read((char *)&reply, 4);
 214     reply = qFromBigEndian<quint32>(reply);
 215
 216     Protocol::Type type = static_cast<Protocol::Type>(reply & 0xff);
 217     quint16 protoFeatures = static_cast<quint16>(reply>>8 & 0xffff);
 218     _connectionFeatures = static_cast<quint8>(reply>>24);
 219
 220     RemotePeer *peer = PeerFactory::createPeer(PeerFactory::ProtoDescriptor(type, protoFeatures), this, socket(), this);
 221     if (!peer) {
 222         qWarning() << "No valid protocol supported for this core!";
 223         emit errorPopup(tr("<b>Incompatible Quassel Core!</b><br>"
 224                            "None of the protocols this client speaks are supported by the core you are trying to connect to."));
 225
 226         requestDisconnect(tr("Core speaks none of the protocols we support"));
 227         return;
 228     }
 229
 230     if (peer->protocol() == Protocol::LegacyProtocol) {
 231         connect(peer, SIGNAL(protocolVersionMismatch(int,int)), SLOT(onProtocolVersionMismatch(int,int)));
 232         _legacy = true;
 233     }
 234
 235     setPeer(peer);
 236 }
 237
 238
 239 void ClientAuthHandler::onProtocolVersionMismatch(int actual, int expected)
 240 {
 241     emit errorPopup(tr("<b>The Quassel Core you are trying to connect to is too old!</b><br>"
 242            "We need at least protocol v%1, but the core speaks v%2 only.").arg(expected, actual));
 243     requestDisconnect(tr("Incompatible protocol version, connection to core refused"));
 244 }
 245
 246
 247 void ClientAuthHandler::setPeer(RemotePeer *peer)
 248 {
 249     _peer = peer;
 250     connect(_peer, SIGNAL(transferProgress(int,int)), SIGNAL(transferProgress(int,int)));
 251
 252     // The legacy protocol enables SSL later, after registration
 253     if (!_account.useSsl() || _legacy)
 254         startRegistration();
 255     // otherwise, do it now
 256     else
 257         checkAndEnableSsl(_connectionFeatures & Protocol::Encryption);
 258 }
 259
 260
 261 void ClientAuthHandler::startRegistration()
 262 {
 263     emit statusMessage(tr("Synchronizing to core..."));
 264
 265     // useSsl will be ignored by non-legacy peers
 266     bool useSsl = false;
 267 #ifdef HAVE_SSL
 268     useSsl = _account.useSsl();
 269 #endif
 270
 271     _peer->dispatch(RegisterClient(Quassel::buildInfo().fancyVersionString, useSsl));
 272 }
 273
 274
 275 void ClientAuthHandler::handle(const ClientDenied &msg)
 276 {
 277     emit errorPopup(msg.errorString);
 278     requestDisconnect(tr("The core refused connection from this client"));
 279 }
 280
 281
 282 void ClientAuthHandler::handle(const ClientRegistered &msg)
 283 {
 284     _coreConfigured = msg.coreConfigured;
 285     _backendInfo = msg.backendInfo;
 286
 287     Client::setCoreFeatures(static_cast<Quassel::Features>(msg.coreFeatures));
 288
 289     // The legacy protocol enables SSL at this point
 290     if(_legacy && _account.useSsl())
 291         checkAndEnableSsl(msg.sslSupported);
 292     else
 293         onConnectionReady();
 294 }
 295
 296
 297 void ClientAuthHandler::onConnectionReady()
 298 {
 299     emit connectionReady();
 300     emit statusMessage(tr("Connected to %1").arg(_account.accountName()));
 301
 302     if (!_coreConfigured) {
 303         // start wizard
 304         emit startCoreSetup(_backendInfo);
 305     }
 306     else // TODO: check if we need LoginEnabled
 307         login();
 308 }
 309
 310
 311 void ClientAuthHandler::setupCore(const SetupData &setupData)
 312 {
 313     _peer->dispatch(setupData);
 314 }
 315
 316
 317 void ClientAuthHandler::handle(const SetupFailed &msg)
 318 {
 319     emit coreSetupFailed(msg.errorString);
 320 }
 321
 322
 323 void ClientAuthHandler::handle(const SetupDone &msg)
 324 {
 325     Q_UNUSED(msg)
 326
 327     emit coreSetupSuccessful();
 328 }
 329
 330
 331 void ClientAuthHandler::login(const QString &user, const QString &password, bool remember)
 332 {
 333     _account.setUser(user);
 334     _account.setPassword(password);
 335     _account.setStorePassword(remember);
 336     login();
 337 }
 338
 339
 340 void ClientAuthHandler::login(const QString &previousError)
 341 {
 342     emit statusMessage(tr("Logging in..."));
 343     if (_account.user().isEmpty() || _account.password().isEmpty() || !previousError.isEmpty()) {
 344         bool valid = false;
 345         emit userAuthenticationRequired(&_account, &valid, previousError); // *must* be a synchronous call
 346         if (!valid || _account.user().isEmpty() || _account.password().isEmpty()) {
 347             requestDisconnect(tr("Login canceled"));
 348             return;
 349         }
 350     }
 351
 352     _peer->dispatch(Login(_account.user(), _account.password()));
 353 }
 354
 355
 356 void ClientAuthHandler::handle(const LoginFailed &msg)
 357 {
 358     login(msg.errorString);
 359 }
 360
 361
 362 void ClientAuthHandler::handle(const LoginSuccess &msg)
 363 {
 364     Q_UNUSED(msg)
 365
 366     emit loginSuccessful(_account);
 367 }
 368
 369
 370 void ClientAuthHandler::handle(const SessionState &msg)
 371 {
 372     disconnect(socket(), 0, this, 0); // this is the last message we shall ever get
 373
 374     // give up ownership of the peer; CoreSession takes responsibility now
 375     _peer->setParent(0);
 376     emit handshakeComplete(_peer, msg);
 377 }
 378
 379
 380 /*** SSL Stuff ***/
 381
 382 void ClientAuthHandler::checkAndEnableSsl(bool coreSupportsSsl)
 383 {
 384 #ifndef HAVE_SSL
 385     Q_UNUSED(coreSupportsSsl);
 386 #else
 387     CoreAccountSettings s;
 388     if (coreSupportsSsl && _account.useSsl()) {
 389         // Make sure the warning is shown next time we don't have SSL in the core
 390         s.setAccountValue("ShowNoCoreSslWarning", true);
 391
 392         QSslSocket *sslSocket = qobject_cast<QSslSocket *>(socket());
 393         Q_ASSERT(sslSocket);
 394         connect(sslSocket, SIGNAL(encrypted()), SLOT(onSslSocketEncrypted()));
 395         connect(sslSocket, SIGNAL(sslErrors(QList<QSslError>)), SLOT(onSslErrors()));
 396         qDebug() << "Starting encryption...";
 397         sslSocket->flush();
 398         sslSocket->startClientEncryption();
 399     }
 400     else {
 401         if (s.accountValue("ShowNoCoreSslWarning", true).toBool()) {
 402             bool accepted = false;
 403             emit handleNoSslInCore(&accepted);
 404             if (!accepted) {
 405                 requestDisconnect(tr("Unencrypted connection cancelled"));
 406                 return;
 407             }
 408             s.setAccountValue("ShowNoCoreSslWarning", false);
 409             s.setAccountValue("SslCert", QString());
 410         }
 411         if (_legacy)
 412             onConnectionReady();
 413         else
 414             startRegistration();
 415     }
 416 #endif
 417 }
 418
 419 #ifdef HAVE_SSL
 420
 421 void ClientAuthHandler::onSslSocketEncrypted()
 422 {
 423     QSslSocket *socket = qobject_cast<QSslSocket *>(sender());
 424     Q_ASSERT(socket);
 425
 426     if (!socket->sslErrors().count()) {
 427         // Cert is valid, so we don't want to store it as known
 428         // That way, a warning will appear in case it becomes invalid at some point
 429         CoreAccountSettings s;
 430         s.setAccountValue("SSLCert", QString());
 431     }
 432
 433     emit encrypted(true);
 434
 435     if (_legacy)
 436         onConnectionReady();
 437     else
 438         startRegistration();
 439 }
 440
 441
 442 void ClientAuthHandler::onSslErrors()
 443 {
 444     QSslSocket *socket = qobject_cast<QSslSocket *>(sender());
 445     Q_ASSERT(socket);
 446
 447     CoreAccountSettings s;
 448     QByteArray knownDigest = s.accountValue("SslCert").toByteArray();
 449
 450     if (knownDigest != socket->peerCertificate().digest()) {
 451         bool accepted = false;
 452         bool permanently = false;
 453         emit handleSslErrors(socket, &accepted, &permanently);
 454
 455         if (!accepted) {
 456             requestDisconnect(tr("Unencrypted connection canceled"));
 457             return;
 458         }
 459
 460         if (permanently)
 461             s.setAccountValue("SslCert", socket->peerCertificate().digest());
 462         else
 463             s.setAccountValue("SslCert", QString());
 464     }
 465
 466     socket->ignoreSslErrors();
 467 }
 468
 469 #endif /* HAVE_SSL */