← Back to branch summary

~ubuntu-branches/ubuntu/trusty/quassel/trusty-proposed

« back to all changes in this revision

Viewing changes to src/common/protocol.h

  • Committer: Package Import Robot
  • Author(s): Scott Kitterman
  • Date: 2014-02-18 23:18:25 UTC
  • mfrom: (1.1.54)
  • Revision ID: package-import@ubuntu.com-20140218231825-6vvoh451otn95pkn
Tags: 0.10~beta1-0ubuntu1
* New upstream beta relase
  - Drop debian/patches/upstream_fix_fullscreen_mode.diff which had been
    cherrypicked from upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/common/protocol.h
1
1
/***************************************************************************
2
 
 *   Copyright (C) 2005-2013 by the Quassel Project                        *
 
2
 *   Copyright (C) 2005-2014 by the Quassel Project                        *
3
3
 *   devel@quassel-irc.org                                                 *
4
4
 *                                                                         *
5
5
 *   This program is free software; you can redistribute it and/or modify  *
27
27
 
28
28
namespace Protocol {
29
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
 
30
44
enum Handler {
31
 
    SignalProxy
32
 
};
33
 
 
 
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
};
34
162
 
35
163
/*** handled by SignalProxy ***/
36
164
 
37
 
class SyncMessage
38
 
{
39
 
public:
 
165
struct SignalProxyMessage
 
166
{
 
167
    inline Handler handler() const { return SignalProxy; }
 
168
};
 
169
 
 
170
 
 
171
struct SyncMessage : public SignalProxyMessage
 
172
{
40
173
    inline SyncMessage(const QByteArray &className, const QString &objectName, const QByteArray &slotName, const QVariantList &params)
41
 
    : _className(className), _objectName(objectName), _slotName(slotName), _params(params) {}
42
 
 
43
 
    inline Handler handler() const { return SignalProxy; }
44
 
 
45
 
    inline QByteArray className() const { return _className; }
46
 
    inline QString objectName() const { return _objectName; }
47
 
    inline QByteArray slotName() const { return _slotName; }
48
 
 
49
 
    inline QVariantList params() const { return _params; }
50
 
 
51
 
private:
52
 
    QByteArray _className;
53
 
    QString _objectName;
54
 
    QByteArray _slotName;
55
 
    QVariantList _params;
 
174
    : className(className), objectName(objectName), slotName(slotName), params(params) {}
 
175
 
 
176
    QByteArray className;
 
177
    QString objectName;
 
178
    QByteArray slotName;
 
179
    QVariantList params;
56
180
};
57
181
 
58
182
 
59
 
class RpcCall
 
183
struct RpcCall : public SignalProxyMessage
60
184
{
61
 
public:
62
185
    inline RpcCall(const QByteArray &slotName, const QVariantList &params)
63
 
    : _slotName(slotName), _params(params) {}
64
 
 
65
 
    inline Handler handler() const { return SignalProxy; }
66
 
 
67
 
    inline QByteArray slotName() const { return _slotName; }
68
 
    inline QVariantList params() const { return _params; }
69
 
 
70
 
private:
71
 
    QByteArray _slotName;
72
 
    QVariantList _params;
 
186
    : slotName(slotName), params(params) {}
 
187
 
 
188
    QByteArray slotName;
 
189
    QVariantList params;
73
190
};
74
191
 
75
192
 
76
 
class InitRequest
 
193
struct InitRequest : public SignalProxyMessage
77
194
{
78
 
public:
79
195
    inline InitRequest(const QByteArray &className, const QString &objectName)
80
 
    : _className(className), _objectName(objectName) {}
81
 
 
82
 
    inline Handler handler() const { return SignalProxy; }
83
 
 
84
 
    inline QByteArray className() const { return _className; }
85
 
    inline QString objectName() const { return _objectName; }
86
 
 
87
 
private:
88
 
    QByteArray _className;
89
 
    QString _objectName;
 
196
    : className(className), objectName(objectName) {}
 
197
 
 
198
    QByteArray className;
 
199
    QString objectName;
90
200
};
91
201
 
92
202
 
93
 
class InitData
 
203
struct InitData : public SignalProxyMessage
94
204
{
95
 
public:
96
205
    inline InitData(const QByteArray &className, const QString &objectName, const QVariantMap &initData)
97
 
    : _className(className), _objectName(objectName), _initData(initData) {}
98
 
 
99
 
    inline Handler handler() const { return SignalProxy; }
100
 
 
101
 
    inline QByteArray className() const { return _className; }
102
 
    inline QString objectName() const { return _objectName; }
103
 
 
104
 
    inline QVariantMap initData() const { return _initData; }
105
 
 
106
 
private:
107
 
    QByteArray _className;
108
 
    QString _objectName;
109
 
    QVariantMap _initData;
 
206
    : className(className), objectName(objectName), initData(initData) {}
 
207
 
 
208
    QByteArray className;
 
209
    QString objectName;
 
210
    QVariantMap initData;
110
211
};
111
212
 
112
213
 
113
214
/*** handled by RemoteConnection ***/
114
215
 
115
 
class HeartBeat
 
216
struct HeartBeat
116
217
{
117
 
public:
118
 
    inline HeartBeat(const QDateTime &timestamp) : _timestamp(timestamp) {}
119
 
 
120
 
    inline QDateTime timestamp() const { return _timestamp; }
121
 
 
122
 
private:
123
 
    QDateTime _timestamp;
 
218
    inline HeartBeat(const QDateTime &timestamp) : timestamp(timestamp) {}
 
219
 
 
220
    QDateTime timestamp;
124
221
};
125
222
 
126
223
 
127
 
class HeartBeatReply
 
224
struct HeartBeatReply
128
225
{
129
 
public:
130
 
    inline HeartBeatReply(const QDateTime &timestamp) : _timestamp(timestamp) {}
131
 
 
132
 
    inline QDateTime timestamp() const { return _timestamp; }
133
 
 
134
 
private:
135
 
    QDateTime _timestamp;
 
226
    inline HeartBeatReply(const QDateTime &timestamp) : timestamp(timestamp) {}
 
227
 
 
228
    QDateTime timestamp;
136
229
};
137
230
 
138
231