src/common/protocol.h

   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 #ifndef PROTOCOL_H_
  22 #define PROTOCOL_H_
  23
  24 #include <QByteArray>
  25 #include <QDateTime>
  26 #include <QVariantList>
  27
  28 namespace Protocol {
  29
  30 const quint32 magic = 0x42b33f00;
  31
  32 enum Type {
  33     LegacyProtocol = 0x01,
  34     DataStreamProtocol = 0x02
  35 };
  36
  37
  38 enum Feature {
  39     Encryption = 0x01,
  40     Compression = 0x02
  41 };
  42
  43
  44 enum Handler {
  45     SignalProxy,
  46     AuthHandler
  47 };
  48
  49
  50 /*** Handshake, handled by AuthHandler ***/
  51
  52 struct HandshakeMessage {
  53     inline Handler handler() const { return AuthHandler; }
  54 };
  55
  56
  57 struct RegisterClient : public HandshakeMessage
  58 {
  59     inline RegisterClient(const QString &clientVersion, bool sslSupported = false)
  60     : clientVersion(clientVersion)
  61     , sslSupported(sslSupported) {}
  62
  63     QString clientVersion;
  64
  65     // this is only used by the LegacyProtocol in compat mode
  66     bool sslSupported;
  67 };
  68
  69
  70 struct ClientDenied : public HandshakeMessage
  71 {
  72     inline ClientDenied(const QString &errorString)
  73     : errorString(errorString) {}
  74
  75     QString errorString;
  76 };
  77
  78
  79 struct ClientRegistered : public HandshakeMessage
  80 {
  81     inline ClientRegistered(quint32 coreFeatures, bool coreConfigured, const QVariantList &backendInfo, bool sslSupported, const QDateTime &coreStartTime)
  82     : coreFeatures(coreFeatures)
  83     , coreConfigured(coreConfigured)
  84     , backendInfo(backendInfo)
  85     , sslSupported(sslSupported)
  86     , coreStartTime(coreStartTime)
  87     {}
  88
  89     quint32 coreFeatures;
  90     bool coreConfigured;
  91     QVariantList backendInfo; // TODO: abstract this better
  92
  93     // this is only used by the LegacyProtocol in compat mode
  94     bool sslSupported;
  95     QDateTime coreStartTime;
  96 };
  97
  98
  99 struct SetupData : public HandshakeMessage
 100 {
 101     inline SetupData(const QString &adminUser, const QString &adminPassword, const QString &backend, const QVariantMap &setupData)
 102     : adminUser(adminUser), adminPassword(adminPassword), backend(backend), setupData(setupData) {}
 103
 104     QString adminUser;
 105     QString adminPassword;
 106     QString backend;
 107     QVariantMap setupData;
 108 };
 109
 110
 111 struct SetupFailed : public HandshakeMessage
 112 {
 113     inline SetupFailed(const QString &errorString)
 114     : errorString(errorString) {}
 115
 116     QString errorString;
 117 };
 118
 119
 120 struct SetupDone : public HandshakeMessage
 121 {
 122     inline SetupDone() {}
 123 };
 124
 125
 126 struct Login : public HandshakeMessage
 127 {
 128     inline Login(const QString &user, const QString &password)
 129     : user(user), password(password) {}
 130
 131     QString user;
 132     QString password;
 133 };
 134
 135
 136 struct LoginFailed : public HandshakeMessage
 137 {
 138     inline LoginFailed(const QString &errorString)
 139     : errorString(errorString) {}
 140
 141     QString errorString;
 142 };
 143
 144
 145 struct LoginSuccess : public HandshakeMessage
 146 {
 147     inline LoginSuccess() {}
 148 };
 149
 150
 151 // TODO: more generic format
 152 struct SessionState : public HandshakeMessage
 153 {
 154     inline SessionState() {} // needed for QMetaType (for the mono client)
 155     inline SessionState(const QVariantList &identities, const QVariantList &bufferInfos, const QVariantList &networkIds)
 156     : identities(identities), bufferInfos(bufferInfos), networkIds(networkIds) {}
 157
 158     QVariantList identities;
 159     QVariantList bufferInfos;
 160     QVariantList networkIds;
 161 };
 162
 163 /*** handled by SignalProxy ***/
 164
 165 struct SignalProxyMessage
 166 {
 167     inline Handler handler() const { return SignalProxy; }
 168 };
 169
 170
 171 struct SyncMessage : public SignalProxyMessage
 172 {
 173     inline SyncMessage(const QByteArray &className, const QString &objectName, const QByteArray &slotName, const QVariantList &params)
 174     : className(className), objectName(objectName), slotName(slotName), params(params) {}
 175
 176     QByteArray className;
 177     QString objectName;
 178     QByteArray slotName;
 179     QVariantList params;
 180 };
 181
 182
 183 struct RpcCall : public SignalProxyMessage
 184 {
 185     inline RpcCall(const QByteArray &slotName, const QVariantList &params)
 186     : slotName(slotName), params(params) {}
 187
 188     QByteArray slotName;
 189     QVariantList params;
 190 };
 191
 192
 193 struct InitRequest : public SignalProxyMessage
 194 {
 195     inline InitRequest(const QByteArray &className, const QString &objectName)
 196     : className(className), objectName(objectName) {}
 197
 198     QByteArray className;
 199     QString objectName;
 200 };
 201
 202
 203 struct InitData : public SignalProxyMessage
 204 {
 205     inline InitData(const QByteArray &className, const QString &objectName, const QVariantMap &initData)
 206     : className(className), objectName(objectName), initData(initData) {}
 207
 208     QByteArray className;
 209     QString objectName;
 210     QVariantMap initData;
 211 };
 212
 213
 214 /*** handled by RemoteConnection ***/
 215
 216 struct HeartBeat
 217 {
 218     inline HeartBeat(const QDateTime &timestamp) : timestamp(timestamp) {}
 219
 220     QDateTime timestamp;
 221 };
 222
 223
 224 struct HeartBeatReply
 225 {
 226     inline HeartBeatReply(const QDateTime &timestamp) : timestamp(timestamp) {}
 227
 228     QDateTime timestamp;
 229 };
 230
 231
 232 };
 233
 234 #endif