/***************************************************************************
- * Copyright (C) 2005-2013 by the Quassel Project *
+ * Copyright (C) 2005-2016 by the Quassel Project *
* devel@quassel-irc.org *
* *
* This program is free software; you can redistribute it and/or modify *
namespace Protocol {
-enum Handler {
- SignalProxy
+const quint32 magic = 0x42b33f00;
+
+enum Type {
+ InternalProtocol = 0x00,
+ LegacyProtocol = 0x01,
+ DataStreamProtocol = 0x02
};
-/*** handled by SignalProxy ***/
+enum Feature {
+ Encryption = 0x01,
+ Compression = 0x02
+};
+
+
+enum class Handler {
+ SignalProxy,
+ AuthHandler
+};
+
+
+/*** Handshake, handled by AuthHandler ***/
-class SyncMessage
+struct HandshakeMessage {
+ inline Handler handler() const { return Handler::AuthHandler; }
+};
+
+
+struct RegisterClient : public HandshakeMessage
{
-public:
- inline SyncMessage(const QByteArray &className, const QString &objectName, const QByteArray &slotName, const QVariantList ¶ms)
- : _className(className), _objectName(objectName), _slotName(slotName), _params(params) {}
+ inline RegisterClient(const QString &clientVersion, const QString &buildDate, bool sslSupported = false)
+ : clientVersion(clientVersion)
+ , buildDate(buildDate)
+ , sslSupported(sslSupported) {}
- inline Handler handler() const { return SignalProxy; }
+ QString clientVersion;
+ QString buildDate;
+
+ // this is only used by the LegacyProtocol in compat mode
+ bool sslSupported;
+};
- inline QByteArray className() const { return _className; }
- inline QString objectName() const { return _objectName; }
- inline QByteArray slotName() const { return _slotName; }
- inline QVariantList params() const { return _params; }
+struct ClientDenied : public HandshakeMessage
+{
+ inline ClientDenied(const QString &errorString)
+ : errorString(errorString) {}
-private:
- QByteArray _className;
- QString _objectName;
- QByteArray _slotName;
- QVariantList _params;
+ QString errorString;
};
-class RpcCall
+struct ClientRegistered : public HandshakeMessage
{
-public:
- inline RpcCall(const QByteArray &slotName, const QVariantList ¶ms)
- : _slotName(slotName), _params(params) {}
+ inline ClientRegistered(quint32 coreFeatures, bool coreConfigured, const QVariantList &backendInfo, bool sslSupported, const QVariantList &authenticatorInfo)
+ : coreFeatures(coreFeatures)
+ , coreConfigured(coreConfigured)
+ , backendInfo(backendInfo)
+ , authenticatorInfo(authenticatorInfo)
+ , sslSupported(sslSupported)
+ {}
+
+ quint32 coreFeatures;
+ bool coreConfigured;
+
+ // The authenticatorInfo should be optional!
+ QVariantList backendInfo; // TODO: abstract this better
+ QVariantList authenticatorInfo;
+
+ // this is only used by the LegacyProtocol in compat mode
+ bool sslSupported;
+};
+
+
+struct SetupData : public HandshakeMessage
+{
+ inline SetupData(const QString &adminUser, const QString &adminPassword, const QString &backend,
+ const QVariantMap &setupData, const QString &authenticator = QString(),
+ const QVariantMap &authSetupData = QVariantMap())
+ : adminUser(adminUser)
+ , adminPassword(adminPassword)
+ , backend(backend)
+ , setupData(setupData)
+ , authenticator(authenticator)
+ , authSetupData(authSetupData)
+ {}
+
+ QString adminUser;
+ QString adminPassword;
+ QString backend;
+ QVariantMap setupData;
+ QString authenticator;
+ QVariantMap authSetupData;
+};
- inline Handler handler() const { return SignalProxy; }
- inline QByteArray slotName() const { return _slotName; }
- inline QVariantList params() const { return _params; }
+struct SetupFailed : public HandshakeMessage
+{
+ inline SetupFailed(const QString &errorString)
+ : errorString(errorString) {}
-private:
- QByteArray _slotName;
- QVariantList _params;
+ QString errorString;
};
-class InitRequest
+struct SetupDone : public HandshakeMessage
{
-public:
- inline InitRequest(const QByteArray &className, const QString &objectName)
- : _className(className), _objectName(objectName) {}
+ inline SetupDone() {}
+};
- inline Handler handler() const { return SignalProxy; }
- inline QByteArray className() const { return _className; }
- inline QString objectName() const { return _objectName; }
+struct Login : public HandshakeMessage
+{
+ inline Login(const QString &user, const QString &password)
+ : user(user), password(password) {}
-private:
- QByteArray _className;
- QString _objectName;
+ QString user;
+ QString password;
};
-class InitData
+struct LoginFailed : public HandshakeMessage
{
-public:
- inline InitData(const QByteArray &className, const QString &objectName, const QVariantMap &initData)
- : _className(className), _objectName(objectName), _initData(initData) {}
+ inline LoginFailed(const QString &errorString)
+ : errorString(errorString) {}
- inline Handler handler() const { return SignalProxy; }
+ QString errorString;
+};
- inline QByteArray className() const { return _className; }
- inline QString objectName() const { return _objectName; }
- inline QVariantMap initData() const { return _initData; }
+struct LoginSuccess : public HandshakeMessage
+{
+ inline LoginSuccess() {}
+};
+
-private:
- QByteArray _className;
- QString _objectName;
- QVariantMap _initData;
+// TODO: more generic format
+struct SessionState : public HandshakeMessage
+{
+ inline SessionState() {} // needed for QMetaType (for the mono client)
+ inline SessionState(const QVariantList &identities, const QVariantList &bufferInfos, const QVariantList &networkIds)
+ : identities(identities), bufferInfos(bufferInfos), networkIds(networkIds) {}
+
+ QVariantList identities;
+ QVariantList bufferInfos;
+ QVariantList networkIds;
};
+/*** handled by SignalProxy ***/
-/*** handled by RemoteConnection ***/
+struct SignalProxyMessage
+{
+ inline Handler handler() const { return Handler::SignalProxy; }
+};
+
+
+struct SyncMessage : public SignalProxyMessage
+{
+ inline SyncMessage(const QByteArray &className, const QString &objectName, const QByteArray &slotName, const QVariantList ¶ms)
+ : className(className), objectName(objectName), slotName(slotName), params(params) {}
+
+ QByteArray className;
+ QString objectName;
+ QByteArray slotName;
+ QVariantList params;
+};
+
+
+struct RpcCall : public SignalProxyMessage
+{
+ inline RpcCall(const QByteArray &slotName, const QVariantList ¶ms)
+ : slotName(slotName), params(params) {}
-class HeartBeat
+ QByteArray slotName;
+ QVariantList params;
+};
+
+
+struct InitRequest : public SignalProxyMessage
{
-public:
- inline HeartBeat(const QDateTime ×tamp) : _timestamp(timestamp) {}
+ inline InitRequest(const QByteArray &className, const QString &objectName)
+ : className(className), objectName(objectName) {}
+
+ QByteArray className;
+ QString objectName;
+};
- inline QDateTime timestamp() const { return _timestamp; }
-private:
- QDateTime _timestamp;
+struct InitData : public SignalProxyMessage
+{
+ inline InitData(const QByteArray &className, const QString &objectName, const QVariantMap &initData)
+ : className(className), objectName(objectName), initData(initData) {}
+
+ QByteArray className;
+ QString objectName;
+ QVariantMap initData;
};
-class HeartBeatReply
+/*** handled by RemoteConnection ***/
+
+struct HeartBeat
{
-public:
- inline HeartBeatReply(const QDateTime ×tamp) : _timestamp(timestamp) {}
+ inline HeartBeat(const QDateTime ×tamp) : timestamp(timestamp) {}
- inline QDateTime timestamp() const { return _timestamp; }
+ QDateTime timestamp;
+};
+
+
+struct HeartBeatReply
+{
+ inline HeartBeatReply(const QDateTime ×tamp) : timestamp(timestamp) {}
-private:
- QDateTime _timestamp;
+ QDateTime timestamp;
};
projects / quassel.git / blobdiff