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