X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fprotocol.h;h=d7c1b1d590ec8cd9a29a4c2767ac88bec5865d78;hp=af98b8b74f393363c21010df7b60cca3fb3ae5e5;hb=d1bf207d30fe62a15d0e8669d186374c68e6eae8;hpb=04315f46a16fc3627218377071e008b6b9744992

diff --git a/src/common/protocol.h b/src/common/protocol.h
index af98b8b7..d7c1b1d5 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-2014 by the Quassel Project                        *
  *   devel@quassel-irc.org                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -27,99 +27,204 @@
 
 namespace Protocol {
 
-/*** handled by SignalProxy ***/
+const quint32 magic = 0x42b33f00;
+
+enum Type {
+    LegacyProtocol = 1
+};
+
+
+enum Feature {
+    Encryption = 0x01,
+    Compression = 0x02
+};
+
+
+enum Handler {
+    SignalProxy,
+    AuthHandler
+};
 
-class SyncMessage
+
+/*** Handshake, handled by AuthHandler ***/
+
+struct HandshakeMessage {
+    inline Handler handler() const { return AuthHandler; }
+};
+
+
+struct RegisterClient : public HandshakeMessage
 {
-public:
-    inline SyncMessage(const QByteArray &className, const QString &objectName, const QByteArray &slotName, const QVariantList &params)
-    : _className(className), _objectName(objectName), _slotName(slotName), _params(params) {}
+    inline RegisterClient(const QString &clientVersion, bool sslSupported = false)
+    : clientVersion(clientVersion)
+    , sslSupported(sslSupported) {}
+
+    QString clientVersion;
 
-    inline QByteArray className() const { return _className; }
-    inline QString objectName() const { return _objectName; }
-    inline QByteArray slotName() const { return _slotName; }
+    // this is only used by the LegacyProtocol in compat mode
+    bool sslSupported;
+};
 
-    inline QVariantList params() const { return _params; }
 
-private:
-    QByteArray _className;
-    QString _objectName;
-    QByteArray _slotName;
-    QVariantList _params;
+struct ClientDenied : public HandshakeMessage
+{
+    inline ClientDenied(const QString &errorString)
+    : errorString(errorString) {}
+
+    QString errorString;
 };
 
 
-class RpcCall
+struct ClientRegistered : public HandshakeMessage
 {
-public:
-    inline RpcCall(const QByteArray &slotName, const QVariantList &params)
-    : _slotName(slotName), _params(params) {}
+    inline ClientRegistered(quint32 coreFeatures, bool coreConfigured, const QVariantList &backendInfo, bool sslSupported, const QDateTime &coreStartTime)
+    : coreFeatures(coreFeatures)
+    , coreConfigured(coreConfigured)
+    , backendInfo(backendInfo)
+    , sslSupported(sslSupported)
+    , coreStartTime(coreStartTime)
+    {}
+
+    quint32 coreFeatures;
+    bool coreConfigured;
+    QVariantList backendInfo; // TODO: abstract this better
+
+    // this is only used by the LegacyProtocol in compat mode
+    bool sslSupported;
+    QDateTime coreStartTime;
+};
 
-    inline QByteArray slotName() const { return _slotName; }
-    inline QVariantList params() const { return _params; }
 
-private:
-    QByteArray _slotName;
-    QVariantList _params;
+struct SetupData : public HandshakeMessage
+{
+    inline SetupData(const QString &adminUser, const QString &adminPassword, const QString &backend, const QVariantMap &setupData)
+    : adminUser(adminUser), adminPassword(adminPassword), backend(backend), setupData(setupData) {}
+
+    QString adminUser;
+    QString adminPassword;
+    QString backend;
+    QVariantMap setupData;
 };
 
 
-class InitRequest
+struct SetupFailed : public HandshakeMessage
 {
-public:
-    inline InitRequest(const QByteArray &className, const QString &objectName)
-    : _className(className), _objectName(objectName) {}
+    inline SetupFailed(const QString &errorString)
+    : errorString(errorString) {}
+
+    QString errorString;
+};
 
-    inline QByteArray className() const { return _className; }
-    inline QString objectName() const { return _objectName; }
 
-private:
-    QByteArray _className;
-    QString _objectName;
+struct SetupDone : public HandshakeMessage
+{
+    inline SetupDone() {}
 };
 
 
-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(const QString &user, const QString &password)
+    : user(user), password(password) {}
+
+    QString user;
+    QString password;
+};
 
-    inline QByteArray className() const { return _className; }
-    inline QString objectName() const { return _objectName; }
 
-    inline QVariantMap initData() const { return _initData; }
+struct LoginFailed : public HandshakeMessage
+{
+    inline LoginFailed(const QString &errorString)
+    : errorString(errorString) {}
 
-private:
-    QByteArray _className;
-    QString _objectName;
-    QVariantMap _initData;
+    QString errorString;
 };
 
 
-/*** handled by RemoteConnection ***/
+struct LoginSuccess : public HandshakeMessage
+{
+    inline LoginSuccess() {}
+};
+
 
-class HeartBeat
+// TODO: more generic format
+struct SessionState : public HandshakeMessage
 {
-public:
-    inline HeartBeat(const QDateTime &timestamp) : _timestamp(timestamp) {}
+    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) {}
 
-    inline QDateTime timestamp() const { return _timestamp; }
+    QVariantList identities;
+    QVariantList bufferInfos;
+    QVariantList networkIds;
+};
+
+/*** handled by SignalProxy ***/
+
+struct SignalProxyMessage
+{
+    inline Handler handler() const { return SignalProxy; }
+};
+
+
+struct SyncMessage : public SignalProxyMessage
+{
+    inline SyncMessage(const QByteArray &className, const QString &objectName, const QByteArray &slotName, const QVariantList &params)
+    : 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 &params)
+    : slotName(slotName), params(params) {}
+
+    QByteArray slotName;
+    QVariantList params;
+};
+
+
+struct InitRequest : public SignalProxyMessage
+{
+    inline InitRequest(const QByteArray &className, const QString &objectName)
+    : className(className), objectName(objectName) {}
 
-private:
-    QDateTime _timestamp;
+    QByteArray className;
+    QString objectName;
 };
 
 
-class HeartBeatReply
+struct InitData : public SignalProxyMessage
 {
-public:
-    inline HeartBeatReply(const QDateTime &timestamp) : _timestamp(timestamp) {}
+    inline InitData(const QByteArray &className, const QString &objectName, const QVariantMap &initData)
+    : className(className), objectName(objectName), initData(initData) {}
+
+    QByteArray className;
+    QString objectName;
+    QVariantMap initData;
+};
+
 
-    inline QDateTime timestamp() const { return _timestamp; }
+/*** handled by RemoteConnection ***/
+
+struct HeartBeat
+{
+    inline HeartBeat(const QDateTime &timestamp) : timestamp(timestamp) {}
+
+    QDateTime timestamp;
+};
+
+
+struct HeartBeatReply
+{
+    inline HeartBeatReply(const QDateTime &timestamp) : timestamp(timestamp) {}
 
-private:
-    QDateTime _timestamp;
+    QDateTime timestamp;
 };