src/common/protocols/datastream/datastreampeer.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-2018 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 #include <QDataStream>
  23 #include <QHostAddress>
  24 #include <QTcpSocket>
  25
  26 #include "datastreampeer.h"
  27 #include "quassel.h"
  28 #include "serializers/serializers.h"
  29
  30 using namespace Protocol;
  31
  32 DataStreamPeer::DataStreamPeer(::AuthHandler *authHandler, QTcpSocket *socket, quint16 features, Compressor::CompressionLevel level, QObject *parent)
  33     : RemotePeer(authHandler, socket, level, parent)
  34 {
  35     Q_UNUSED(features);
  36 }
  37
  38
  39 quint16 DataStreamPeer::supportedFeatures()
  40 {
  41     return 0;
  42 }
  43
  44
  45 bool DataStreamPeer::acceptsFeatures(quint16 peerFeatures)
  46 {
  47     Q_UNUSED(peerFeatures);
  48     return true;
  49 }
  50
  51
  52 quint16 DataStreamPeer::enabledFeatures() const
  53 {
  54     return 0;
  55 }
  56
  57
  58 void DataStreamPeer::processMessage(const QByteArray &msg)
  59 {
  60     QDataStream stream(msg);
  61     stream.setVersion(QDataStream::Qt_4_2);
  62     QVariantList list;
  63     if (!Serializers::deserialize(stream, features(), list))
  64         close("Peer sent corrupt data, closing down!");
  65     if (stream.status() != QDataStream::Ok) {
  66         close("Peer sent corrupt data, closing down!");
  67         return;
  68     }
  69
  70     // if no sigproxy is set, we're in handshake mode
  71     if (!signalProxy())
  72         handleHandshakeMessage(list);
  73     else
  74         handlePackedFunc(list);
  75 }
  76
  77
  78 void DataStreamPeer::writeMessage(const QVariantMap &handshakeMsg)
  79 {
  80     QVariantList list;
  81     QVariantMap::const_iterator it = handshakeMsg.begin();
  82     while (it != handshakeMsg.end()) {
  83         list << it.key().toUtf8() << it.value();
  84         ++it;
  85     }
  86
  87     writeMessage(list);
  88 }
  89
  90
  91 void DataStreamPeer::writeMessage(const QVariantList &sigProxyMsg)
  92 {
  93     QByteArray data;
  94     QDataStream msgStream(&data, QIODevice::WriteOnly);
  95     msgStream.setVersion(QDataStream::Qt_4_2);
  96     msgStream << sigProxyMsg;
  97
  98     writeMessage(data);
  99 }
 100
 101
 102 /*** Handshake messages ***/
 103
 104 /* These messages are transmitted during handshake phase, which in case of the legacy protocol means they have
 105  * a structure different from those being used after the handshake.
 106  * Also, the legacy handshake does not fully match the redesigned one, so we'll have to do various mappings here.
 107  */
 108
 109 void DataStreamPeer::handleHandshakeMessage(const QVariantList &mapData)
 110 {
 111     QVariantMap m;
 112     for (int i = 0; i < mapData.count()/2; ++i)
 113         m[QString::fromUtf8(mapData[2*i].toByteArray())] = mapData[2*i+1];
 114
 115     QString msgType = m["MsgType"].toString();
 116     if (msgType.isEmpty()) {
 117         emit protocolError(tr("Invalid handshake message!"));
 118         return;
 119     }
 120
 121     if (msgType == "ClientInit") {
 122         handle(RegisterClient{Quassel::Features{m["FeatureList"].toStringList(), Quassel::LegacyFeatures(m["Features"].toUInt())},
 123                               m["ClientVersion"].toString(),
 124                               m["ClientDate"].toString(),
 125                               false  // UseSsl obsolete
 126                });
 127     }
 128
 129     else if (msgType == "ClientInitReject") {
 130         handle(ClientDenied(m["Error"].toString()));
 131     }
 132
 133     else if (msgType == "ClientInitAck") {
 134         handle(ClientRegistered{Quassel::Features{m["FeatureList"].toStringList(), Quassel::LegacyFeatures(m["CoreFeatures"].toUInt())},
 135                                 m["Configured"].toBool(),
 136                                 m["StorageBackends"].toList(),
 137                                 m["Authenticators"].toList(),
 138                                 false  // SupportsSsl obsolete
 139                });
 140     }
 141
 142     else if (msgType == "CoreSetupData") {
 143         QVariantMap map = m["SetupData"].toMap();
 144         handle(SetupData(map["AdminUser"].toString(), map["AdminPasswd"].toString(), map["Backend"].toString(), map["ConnectionProperties"].toMap(), map["Authenticator"].toString(), map["AuthProperties"].toMap()));
 145     }
 146
 147     else if (msgType == "CoreSetupReject") {
 148         handle(SetupFailed(m["Error"].toString()));
 149     }
 150
 151     else if (msgType == "CoreSetupAck") {
 152         handle(SetupDone());
 153     }
 154
 155     else if (msgType == "ClientLogin") {
 156         handle(Login(m["User"].toString(), m["Password"].toString()));
 157     }
 158
 159     else if (msgType == "ClientLoginReject") {
 160         handle(LoginFailed(m["Error"].toString()));
 161     }
 162
 163     else if (msgType == "ClientLoginAck") {
 164         handle(LoginSuccess());
 165     }
 166
 167     else if (msgType == "SessionInit") {
 168         QVariantMap map = m["SessionState"].toMap();
 169         handle(SessionState(map["Identities"].toList(), map["BufferInfos"].toList(), map["NetworkIds"].toList()));
 170     }
 171
 172     else {
 173         emit protocolError(tr("Unknown protocol message of type %1").arg(msgType));
 174     }
 175 }
 176
 177
 178 void DataStreamPeer::dispatch(const RegisterClient &msg) {
 179     QVariantMap m;
 180     m["MsgType"] = "ClientInit";
 181     m["Features"] = static_cast<quint32>(msg.features.toLegacyFeatures());
 182     m["FeatureList"] = msg.features.toStringList();
 183     m["ClientVersion"] = msg.clientVersion;
 184     m["ClientDate"] = msg.buildDate;
 185
 186     writeMessage(m);
 187 }
 188
 189
 190 void DataStreamPeer::dispatch(const ClientDenied &msg) {
 191     QVariantMap m;
 192     m["MsgType"] = "ClientInitReject";
 193     m["Error"] = msg.errorString;
 194
 195     writeMessage(m);
 196 }
 197
 198
 199 void DataStreamPeer::dispatch(const ClientRegistered &msg) {
 200     QVariantMap m;
 201     m["MsgType"] = "ClientInitAck";
 202     if (hasFeature(Quassel::Feature::ExtendedFeatures)) {
 203         m["FeatureList"] = msg.features.toStringList();
 204     }
 205     else {
 206         m["CoreFeatures"] = static_cast<quint32>(msg.features.toLegacyFeatures());
 207     }
 208     m["LoginEnabled"] = m["Configured"] = msg.coreConfigured;
 209     m["StorageBackends"] = msg.backendInfo;
 210     if (hasFeature(Quassel::Feature::Authenticators)) {
 211         m["Authenticators"] = msg.authenticatorInfo;
 212     }
 213
 214     writeMessage(m);
 215 }
 216
 217
 218 void DataStreamPeer::dispatch(const SetupData &msg)
 219 {
 220     QVariantMap map;
 221     map["AdminUser"] = msg.adminUser;
 222     map["AdminPasswd"] = msg.adminPassword;
 223     map["Backend"] = msg.backend;
 224     map["ConnectionProperties"] = msg.setupData;
 225
 226     // Auth backend properties.
 227     map["Authenticator"] = msg.authenticator;
 228     map["AuthProperties"] = msg.authSetupData;
 229
 230     QVariantMap m;
 231     m["MsgType"] = "CoreSetupData";
 232     m["SetupData"] = map;
 233
 234     writeMessage(m);
 235 }
 236
 237
 238 void DataStreamPeer::dispatch(const SetupFailed &msg)
 239 {
 240     QVariantMap m;
 241     m["MsgType"] = "CoreSetupReject";
 242     m["Error"] = msg.errorString;
 243
 244     writeMessage(m);
 245 }
 246
 247
 248 void DataStreamPeer::dispatch(const SetupDone &msg)
 249 {
 250     Q_UNUSED(msg)
 251
 252     QVariantMap m;
 253     m["MsgType"] = "CoreSetupAck";
 254
 255     writeMessage(m);
 256 }
 257
 258
 259 void DataStreamPeer::dispatch(const Login &msg)
 260 {
 261     QVariantMap m;
 262     m["MsgType"] = "ClientLogin";
 263     m["User"] = msg.user;
 264     m["Password"] = msg.password;
 265
 266     writeMessage(m);
 267 }
 268
 269
 270 void DataStreamPeer::dispatch(const LoginFailed &msg)
 271 {
 272     QVariantMap m;
 273     m["MsgType"] = "ClientLoginReject";
 274     m["Error"] = msg.errorString;
 275
 276     writeMessage(m);
 277 }
 278
 279
 280 void DataStreamPeer::dispatch(const LoginSuccess &msg)
 281 {
 282     Q_UNUSED(msg)
 283
 284     QVariantMap m;
 285     m["MsgType"] = "ClientLoginAck";
 286
 287     writeMessage(m);
 288 }
 289
 290
 291 void DataStreamPeer::dispatch(const SessionState &msg)
 292 {
 293     QVariantMap m;
 294     m["MsgType"] = "SessionInit";
 295
 296     QVariantMap map;
 297     map["BufferInfos"] = msg.bufferInfos;
 298     map["NetworkIds"] = msg.networkIds;
 299     map["Identities"] = msg.identities;
 300     m["SessionState"] = map;
 301
 302     writeMessage(m);
 303 }
 304
 305
 306 /*** Standard messages ***/
 307
 308 void DataStreamPeer::handlePackedFunc(const QVariantList &packedFunc)
 309 {
 310     QVariantList params(packedFunc);
 311
 312     if (params.isEmpty()) {
 313         qWarning() << Q_FUNC_INFO << "Received incompatible data:" << packedFunc;
 314         return;
 315     }
 316
 317     // TODO: make sure that this is a valid request type
 318     RequestType requestType = (RequestType)params.takeFirst().value<qint16>();
 319     switch (requestType) {
 320         case Sync: {
 321             if (params.count() < 3) {
 322                 qWarning() << Q_FUNC_INFO << "Received invalid sync call:" << params;
 323                 return;
 324             }
 325             QByteArray className = params.takeFirst().toByteArray();
 326             QString objectName = QString::fromUtf8(params.takeFirst().toByteArray());
 327             QByteArray slotName = params.takeFirst().toByteArray();
 328             handle(Protocol::SyncMessage(className, objectName, slotName, params));
 329             break;
 330         }
 331         case RpcCall: {
 332             if (params.empty()) {
 333                 qWarning() << Q_FUNC_INFO << "Received empty RPC call!";
 334                 return;
 335             }
 336             QByteArray slotName = params.takeFirst().toByteArray();
 337             handle(Protocol::RpcCall(slotName, params));
 338             break;
 339         }
 340         case InitRequest: {
 341             if (params.count() != 2) {
 342                 qWarning() << Q_FUNC_INFO << "Received invalid InitRequest:" << params;
 343                 return;
 344             }
 345             QByteArray className = params[0].toByteArray();
 346             QString objectName = QString::fromUtf8(params[1].toByteArray());
 347             handle(Protocol::InitRequest(className, objectName));
 348             break;
 349         }
 350         case InitData: {
 351             if (params.count() < 2) {
 352                 qWarning() << Q_FUNC_INFO << "Received invalid InitData:" << params;
 353                 return;
 354             }
 355             QByteArray className = params.takeFirst().toByteArray();
 356             QString objectName = QString::fromUtf8(params.takeFirst().toByteArray());
 357             QVariantMap initData;
 358             for (int i = 0; i < params.count()/2; ++i)
 359                 initData[QString::fromUtf8(params[2*i].toByteArray())] = params[2*i+1];
 360             handle(Protocol::InitData(className, objectName, initData));
 361             break;
 362         }
 363         case HeartBeat: {
 364             if (params.count() != 1) {
 365                 qWarning() << Q_FUNC_INFO << "Received invalid HeartBeat:" << params;
 366                 return;
 367             }
 368             // Note: QDateTime instead of QTime as in the legacy protocol!
 369             handle(Protocol::HeartBeat(params[0].toDateTime()));
 370             break;
 371         }
 372         case HeartBeatReply: {
 373             if (params.count() != 1) {
 374                 qWarning() << Q_FUNC_INFO << "Received invalid HeartBeat:" << params;
 375                 return;
 376             }
 377             // Note: QDateTime instead of QTime as in the legacy protocol!
 378             handle(Protocol::HeartBeatReply(params[0].toDateTime()));
 379             break;
 380         }
 381
 382     }
 383 }
 384
 385
 386 void DataStreamPeer::dispatch(const Protocol::SyncMessage &msg)
 387 {
 388     dispatchPackedFunc(QVariantList() << (qint16)Sync << msg.className << msg.objectName.toUtf8() << msg.slotName << msg.params);
 389 }
 390
 391
 392 void DataStreamPeer::dispatch(const Protocol::RpcCall &msg)
 393 {
 394     dispatchPackedFunc(QVariantList() << (qint16)RpcCall << msg.slotName << msg.params);
 395 }
 396
 397
 398 void DataStreamPeer::dispatch(const Protocol::InitRequest &msg)
 399 {
 400     dispatchPackedFunc(QVariantList() << (qint16)InitRequest << msg.className << msg.objectName.toUtf8());
 401 }
 402
 403
 404 void DataStreamPeer::dispatch(const Protocol::InitData &msg)
 405 {
 406     QVariantList initData;
 407     QVariantMap::const_iterator it = msg.initData.begin();
 408     while (it != msg.initData.end()) {
 409         initData << it.key().toUtf8() << it.value();
 410         ++it;
 411     }
 412     dispatchPackedFunc(QVariantList() << (qint16)InitData << msg.className << msg.objectName.toUtf8() << initData);
 413 }
 414
 415
 416 void DataStreamPeer::dispatch(const Protocol::HeartBeat &msg)
 417 {
 418     dispatchPackedFunc(QVariantList() << (qint16)HeartBeat << msg.timestamp);
 419 }
 420
 421
 422 void DataStreamPeer::dispatch(const Protocol::HeartBeatReply &msg)
 423 {
 424     dispatchPackedFunc(QVariantList() << (qint16)HeartBeatReply << msg.timestamp);
 425 }
 426
 427
 428 void DataStreamPeer::dispatchPackedFunc(const QVariantList &packedFunc)
 429 {
 430     writeMessage(packedFunc);
 431 }