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