X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fprotocol.h;h=d95a529e16c75edae65264028837c6a98a34a601;hp=af98b8b74f393363c21010df7b60cca3fb3ae5e5;hb=db00831bca59a012242d1ad5fac52a20c6cd2956;hpb=9fc57dc2c000e80fb8bd746a090e2e8210e1278e diff --git a/src/common/protocol.h b/src/common/protocol.h index af98b8b7..d95a529e 100644 --- a/src/common/protocol.h +++ b/src/common/protocol.h @@ -1,5 +1,5 @@ /*************************************************************************** - * Copyright (C) 2005-2013 by the Quassel Project * + * Copyright (C) 2005-2018 by the Quassel Project * * devel@quassel-irc.org * * * * This program is free software; you can redistribute it and/or modify * @@ -18,111 +18,253 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * ***************************************************************************/ -#ifndef PROTOCOL_H_ -#define PROTOCOL_H_ +#pragma once + +#include #include #include #include +#include "quassel.h" + namespace Protocol { -/*** handled by SignalProxy ***/ +const quint32 magic = 0x42b33f00; -class SyncMessage +enum Type { -public: - inline SyncMessage(const QByteArray &className, const QString &objectName, const QByteArray &slotName, const QVariantList ¶ms) - : _className(className), _objectName(objectName), _slotName(slotName), _params(params) {} - - inline QByteArray className() const { return _className; } - inline QString objectName() const { return _objectName; } - inline QByteArray slotName() const { return _slotName; } + InternalProtocol = 0x00, + LegacyProtocol = 0x01, + DataStreamProtocol = 0x02 +}; - inline QVariantList params() const { return _params; } +enum Feature +{ + Encryption = 0x01, + Compression = 0x02 +}; -private: - QByteArray _className; - QString _objectName; - QByteArray _slotName; - QVariantList _params; +enum class Handler +{ + SignalProxy, + AuthHandler }; +/*** Handshake, handled by AuthHandler ***/ + +struct HandshakeMessage +{ + inline Handler handler() const { return Handler::AuthHandler; } +}; -class RpcCall +struct RegisterClient : public HandshakeMessage { -public: - inline RpcCall(const QByteArray &slotName, const QVariantList ¶ms) - : _slotName(slotName), _params(params) {} + inline RegisterClient(Quassel::Features clientFeatures, QString clientVersion, QString buildDate, bool sslSupported = false) + : features(std::move(clientFeatures)) + , clientVersion(std::move(clientVersion)) + , buildDate(std::move(buildDate)) + , sslSupported(sslSupported) + {} + + Quassel::Features features; + QString clientVersion; + QString buildDate; + + // this is only used by the LegacyProtocol in compat mode + bool sslSupported; +}; - inline QByteArray slotName() const { return _slotName; } - inline QVariantList params() const { return _params; } +struct ClientDenied : public HandshakeMessage +{ + inline ClientDenied(QString errorString) + : errorString(std::move(errorString)) + {} -private: - QByteArray _slotName; - QVariantList _params; + QString errorString; }; +struct ClientRegistered : public HandshakeMessage +{ + inline ClientRegistered( + Quassel::Features coreFeatures, bool coreConfigured, QVariantList backendInfo, QVariantList authenticatorInfo, bool sslSupported) + : features(std::move(coreFeatures)) + , coreConfigured(coreConfigured) + , backendInfo(std::move(backendInfo)) + , authenticatorInfo(std::move(authenticatorInfo)) + , sslSupported(sslSupported) + {} + + Quassel::Features features; + bool coreConfigured; + QVariantList backendInfo; // TODO: abstract this better + + // The authenticatorInfo should be optional! + QVariantList authenticatorInfo; + + // this is only used by the LegacyProtocol in compat mode + bool sslSupported; +}; -class InitRequest +struct SetupData : public HandshakeMessage { -public: - inline InitRequest(const QByteArray &className, const QString &objectName) - : _className(className), _objectName(objectName) {} + inline SetupData(QString adminUser, + QString adminPassword, + QString backend, + QVariantMap setupData, + QString authenticator = QString(), + QVariantMap authSetupData = QVariantMap()) + : adminUser(std::move(adminUser)) + , adminPassword(std::move(adminPassword)) + , backend(std::move(backend)) + , setupData(std::move(setupData)) + , authenticator(std::move(authenticator)) + , authSetupData(std::move(authSetupData)) + {} + + QString adminUser; + QString adminPassword; + QString backend; + QVariantMap setupData; + QString authenticator; + QVariantMap authSetupData; +}; - inline QByteArray className() const { return _className; } - inline QString objectName() const { return _objectName; } +struct SetupFailed : public HandshakeMessage +{ + inline SetupFailed(QString errorString) + : errorString(std::move(errorString)) + {} -private: - QByteArray _className; - QString _objectName; + QString errorString; }; +struct SetupDone : public HandshakeMessage +{}; -class InitData +struct Login : public HandshakeMessage { -public: - inline InitData(const QByteArray &className, const QString &objectName, const QVariantMap &initData) - : _className(className), _objectName(objectName), _initData(initData) {} + inline Login(QString user, QString password) + : user(std::move(user)) + , password(std::move(password)) + {} - inline QByteArray className() const { return _className; } - inline QString objectName() const { return _objectName; } + QString user; + QString password; +}; - inline QVariantMap initData() const { return _initData; } +struct LoginFailed : public HandshakeMessage +{ + inline LoginFailed(QString errorString) + : errorString(std::move(errorString)) + {} -private: - QByteArray _className; - QString _objectName; - QVariantMap _initData; + QString errorString; }; +struct LoginSuccess : public HandshakeMessage +{}; -/*** handled by RemoteConnection ***/ +// TODO: more generic format +struct SessionState : public HandshakeMessage +{ + inline SessionState() = default; // needed for QMetaType (for the mono client) + inline SessionState(QVariantList identities, QVariantList bufferInfos, QVariantList networkIds) + : identities(std::move(identities)) + , bufferInfos(std::move(bufferInfos)) + , networkIds(std::move(networkIds)) + {} + + QVariantList identities; + QVariantList bufferInfos; + QVariantList networkIds; +}; -class HeartBeat +/*** handled by SignalProxy ***/ + +struct SignalProxyMessage { -public: - inline HeartBeat(const QDateTime ×tamp) : _timestamp(timestamp) {} + inline Handler handler() const { return Handler::SignalProxy; } +}; - inline QDateTime timestamp() const { return _timestamp; } +struct SyncMessage : public SignalProxyMessage +{ + SyncMessage() = default; + SyncMessage(QByteArray className, QString objectName, QByteArray slotName, QVariantList params) + : className(std::move(className)) + , objectName(std::move(objectName)) + , slotName(std::move(slotName)) + , params(std::move(params)) + {} + + QByteArray className; + QString objectName; + QByteArray slotName; + QVariantList params; +}; -private: - QDateTime _timestamp; +struct RpcCall : public SignalProxyMessage +{ + RpcCall() = default; + RpcCall(QByteArray signalName, QVariantList params) + : signalName(std::move(signalName)) + , params(std::move(params)) + {} + + QByteArray signalName; + QVariantList params; }; +struct InitRequest : public SignalProxyMessage +{ + InitRequest() = default; + InitRequest(QByteArray className, QString objectName) + : className(std::move(className)) + , objectName(std::move(objectName)) + {} + + QByteArray className; + QString objectName; +}; -class HeartBeatReply +struct InitData : public SignalProxyMessage { -public: - inline HeartBeatReply(const QDateTime ×tamp) : _timestamp(timestamp) {} + InitData() = default; + InitData(QByteArray className, QString objectName, QVariantMap initData) + : className(std::move(className)) + , objectName(std::move(objectName)) + , initData(std::move(initData)) + {} + + QByteArray className; + QString objectName; + QVariantMap initData; +}; - inline QDateTime timestamp() const { return _timestamp; } +/*** handled by RemoteConnection ***/ -private: - QDateTime _timestamp; +struct HeartBeat +{ + inline HeartBeat(QDateTime timestamp) + : timestamp(std::move(timestamp)) + {} + + QDateTime timestamp; }; +struct HeartBeatReply +{ + inline HeartBeatReply(QDateTime timestamp) + : timestamp(std::move(timestamp)) + {} + QDateTime timestamp; }; -#endif +} // namespace Protocol + +// Required for InternalPeer +Q_DECLARE_METATYPE(Protocol::SyncMessage) +Q_DECLARE_METATYPE(Protocol::RpcCall) +Q_DECLARE_METATYPE(Protocol::InitRequest) +Q_DECLARE_METATYPE(Protocol::InitData)