src/common/remotepeer.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 <QtEndian>
  22
  23 #include <QHostAddress>
  24 #include <QTimer>
  25
  26 #ifdef HAVE_SSL
  27 #  include <QSslSocket>
  28 #else
  29 #  include <QTcpSocket>
  30 #endif
  31
  32 #include "remotepeer.h"
  33
  34 using namespace Protocol;
  35
  36 const quint32 maxMessageSize = 64 * 1024 * 1024; // This is uncompressed size. 64 MB should be enough for any sort of initData or backlog chunk
  37
  38 RemotePeer::RemotePeer(::AuthHandler *authHandler, QTcpSocket *socket, QObject *parent)
  39     : Peer(authHandler, parent),
  40     _socket(socket),
  41     _signalProxy(0),
  42     _heartBeatTimer(new QTimer(this)),
  43     _heartBeatCount(0),
  44     _lag(0),
  45     _msgSize(0)
  46 {
  47     socket->setParent(this);
  48     connect(socket, SIGNAL(readyRead()), SLOT(onReadyRead()));
  49     connect(socket, SIGNAL(stateChanged(QAbstractSocket::SocketState)), SLOT(onSocketStateChanged(QAbstractSocket::SocketState)));
  50     connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), SLOT(onSocketError(QAbstractSocket::SocketError)));
  51     connect(socket, SIGNAL(disconnected()), SIGNAL(disconnected()));
  52
  53 #ifdef HAVE_SSL
  54     QSslSocket *sslSocket = qobject_cast<QSslSocket *>(socket);
  55     if (sslSocket)
  56         connect(sslSocket, SIGNAL(encrypted()), SIGNAL(secureStateChanged()));
  57 #endif
  58
  59     connect(_heartBeatTimer, SIGNAL(timeout()), SLOT(sendHeartBeat()));
  60
  61     // It's possible that more data has already arrived during the handshake, so readyRead() wouldn't be triggered.
  62     // However, we can't call a virtual function from the ctor, so let's do it asynchronously.
  63     if (socket->bytesAvailable())
  64         QTimer::singleShot(0, this, SLOT(onReadyRead()));
  65 }
  66
  67
  68 void RemotePeer::onSocketStateChanged(QAbstractSocket::SocketState state)
  69 {
  70     if (state == QAbstractSocket::ClosingState) {
  71         emit statusMessage(tr("Disconnecting..."));
  72     }
  73 }
  74
  75
  76 void RemotePeer::onSocketError(QAbstractSocket::SocketError error)
  77 {
  78     emit socketError(error, socket()->errorString());
  79 }
  80
  81
  82 QString RemotePeer::description() const
  83 {
  84     if (socket())
  85         return socket()->peerAddress().toString();
  86
  87     return QString();
  88 }
  89
  90
  91 ::SignalProxy *RemotePeer::signalProxy() const
  92 {
  93     return _signalProxy;
  94 }
  95
  96
  97 void RemotePeer::setSignalProxy(::SignalProxy *proxy)
  98 {
  99     if (proxy == _signalProxy)
 100         return;
 101
 102     if (!proxy) {
 103         _heartBeatTimer->stop();
 104         disconnect(signalProxy(), 0, this, 0);
 105         _signalProxy = 0;
 106         if (isOpen())
 107             close();
 108     }
 109     else {
 110         if (signalProxy()) {
 111             qWarning() << Q_FUNC_INFO << "Setting another SignalProxy not supported, ignoring!";
 112             return;
 113         }
 114         _signalProxy = proxy;
 115         connect(proxy, SIGNAL(heartBeatIntervalChanged(int)), SLOT(changeHeartBeatInterval(int)));
 116         _heartBeatTimer->setInterval(proxy->heartBeatInterval() * 1000);
 117         _heartBeatTimer->start();
 118     }
 119 }
 120
 121
 122 void RemotePeer::changeHeartBeatInterval(int secs)
 123 {
 124     if(secs <= 0)
 125         _heartBeatTimer->stop();
 126     else {
 127         _heartBeatTimer->setInterval(secs * 1000);
 128         _heartBeatTimer->start();
 129     }
 130 }
 131
 132
 133 int RemotePeer::lag() const
 134 {
 135     return _lag;
 136 }
 137
 138
 139 QTcpSocket *RemotePeer::socket() const
 140 {
 141     return _socket;
 142 }
 143
 144
 145 bool RemotePeer::isSecure() const
 146 {
 147     if (socket()) {
 148         if (isLocal())
 149             return true;
 150 #ifdef HAVE_SSL
 151         QSslSocket *sslSocket = qobject_cast<QSslSocket *>(socket());
 152         if (sslSocket && sslSocket->isEncrypted())
 153             return true;
 154 #endif
 155     }
 156     return false;
 157 }
 158
 159
 160 bool RemotePeer::isLocal() const
 161 {
 162     if (socket()) {
 163         if (socket()->peerAddress() == QHostAddress::LocalHost || socket()->peerAddress() == QHostAddress::LocalHostIPv6)
 164             return true;
 165     }
 166     return false;
 167 }
 168
 169
 170 bool RemotePeer::isOpen() const
 171 {
 172     return socket() && socket()->state() == QTcpSocket::ConnectedState;
 173 }
 174
 175
 176 void RemotePeer::close(const QString &reason)
 177 {
 178     if (!reason.isEmpty()) {
 179         qWarning() << "Disconnecting:" << reason;
 180     }
 181
 182     if (socket() && socket()->state() != QTcpSocket::UnconnectedState) {
 183         socket()->disconnectFromHost();
 184     }
 185 }
 186
 187
 188 void RemotePeer::onReadyRead()
 189 {
 190     // don't try to read more data if we're already closing
 191     if (socket()->state() !=  QAbstractSocket::ConnectedState)
 192         return;
 193
 194     QByteArray msg;
 195     while (readMessage(msg))
 196         processMessage(msg);
 197 }
 198
 199
 200 bool RemotePeer::readMessage(QByteArray &msg)
 201 {
 202     if (_msgSize == 0) {
 203         if (socket()->bytesAvailable() < 4)
 204             return false;
 205         socket()->read((char*)&_msgSize, 4);
 206         _msgSize = qFromBigEndian<quint32>(_msgSize);
 207
 208         if (_msgSize > maxMessageSize) {
 209             close("Peer tried to send package larger than max package size!");
 210             return false;
 211         }
 212
 213         if (_msgSize == 0) {
 214             close("Peer tried to send an empty message!");
 215             return false;
 216         }
 217     }
 218
 219     if (socket()->bytesAvailable() < _msgSize) {
 220         emit transferProgress(socket()->bytesAvailable(), _msgSize);
 221         return false;
 222     }
 223
 224     emit transferProgress(_msgSize, _msgSize);
 225
 226     msg.resize(_msgSize);
 227     qint64 bytesRead = socket()->read(msg.data(), _msgSize);
 228     if (bytesRead != _msgSize) {
 229         close("Premature end of data stream!");
 230         return false;
 231     }
 232
 233     _msgSize = 0;
 234     return true;
 235 }
 236
 237
 238 void RemotePeer::writeMessage(const QByteArray &msg)
 239 {
 240     quint32 size = qToBigEndian<quint32>(msg.size());
 241     socket()->write((const char*)&size, 4);
 242     socket()->write(msg.constData(), msg.size());
 243 }
 244
 245
 246 void RemotePeer::handle(const HeartBeat &heartBeat)
 247 {
 248     dispatch(HeartBeatReply(heartBeat.timestamp));
 249 }
 250
 251
 252 void RemotePeer::handle(const HeartBeatReply &heartBeatReply)
 253 {
 254     _heartBeatCount = 0;
 255 #if QT_VERSION >= 0x040700
 256     emit lagUpdated(heartBeatReply.timestamp.msecsTo(QDateTime::currentDateTime().toUTC()) / 2);
 257 #else
 258     emit lagUpdated(heartBeatReply.timestamp.time().msecsTo(QDateTime::currentDateTime().toUTC().time()) / 2);
 259 #endif
 260 }
 261
 262
 263 void RemotePeer::sendHeartBeat()
 264 {
 265     if (signalProxy()->maxHeartBeatCount() > 0 && _heartBeatCount >= signalProxy()->maxHeartBeatCount()) {
 266         qWarning() << "Disconnecting peer:" << description()
 267                    << "(didn't receive a heartbeat for over" << _heartBeatCount *_heartBeatTimer->interval() / 1000 << "seconds)";
 268         socket()->close();
 269         _heartBeatTimer->stop();
 270         return;
 271     }
 272
 273     if (_heartBeatCount > 0) {
 274         _lag = _heartBeatCount * _heartBeatTimer->interval();
 275         emit lagUpdated(_lag);
 276     }
 277
 278     dispatch(HeartBeat(QDateTime::currentDateTime().toUTC()));
 279     ++_heartBeatCount;
 280 }