1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
|
// Copyright 2007-2021 The Mumble Developers. All rights reserved.
// Use of this source code is governed by a BSD-style license
// that can be found in the LICENSE file at the root of the
// Mumble source tree or at <https://www.mumble.info/LICENSE>.
#ifndef MUMBLE_MURMUR_SERVER_H_
#define MUMBLE_MURMUR_SERVER_H_
#include <QtCore/QtGlobal>
#ifdef Q_OS_WIN
# include "win.h"
#endif
#include "ACL.h"
#include "Ban.h"
#include "ChannelListenerManager.h"
#include "HostAddress.h"
#include "Message.h"
#include "Mumble.pb.h"
#include "Timer.h"
#include "User.h"
#ifndef Q_MOC_RUN
# include <boost/function.hpp>
#endif
#include <QtCore/QEvent>
#include <QtCore/QMutex>
#include <QtCore/QQueue>
#include <QtCore/QReadWriteLock>
#include <QtCore/QSocketNotifier>
#include <QtCore/QStringList>
#include <QtCore/QThread>
#include <QtCore/QTimer>
#include <QtCore/QUrl>
#include <QtNetwork/QSslCertificate>
#include <QtNetwork/QSslKey>
#include <QtNetwork/QSslSocket>
#include <QtNetwork/QTcpServer>
#if defined(USE_QSSLDIFFIEHELLMANPARAMETERS)
# include <QtNetwork/QSslDiffieHellmanParameters>
#endif
#ifdef Q_OS_WIN
# include <winsock2.h>
#endif
class Zeroconf;
class Channel;
class PacketDataStream;
class ServerUser;
class User;
class QNetworkAccessManager;
struct TextMessage {
QList< unsigned int > qlSessions;
QList< unsigned int > qlChannels;
QList< unsigned int > qlTrees;
QString qsText;
};
class SslServer : public QTcpServer {
private:
Q_OBJECT;
Q_DISABLE_COPY(SslServer)
protected:
QList< QSslSocket * > qlSockets;
void incomingConnection(qintptr) Q_DECL_OVERRIDE;
public:
QSslSocket *nextPendingSSLConnection();
SslServer(QObject *parent = nullptr);
};
#define EXEC_QEVENT (QEvent::User + 959)
class ExecEvent : public QEvent {
Q_DISABLE_COPY(ExecEvent);
protected:
boost::function< void() > func;
public:
ExecEvent(boost::function< void() >);
void execute();
};
class Server : public QThread {
private:
Q_OBJECT;
Q_DISABLE_COPY(Server);
protected:
bool bRunning;
QNetworkAccessManager *qnamNetwork;
#ifdef USE_ZEROCONF
Zeroconf *zeroconf;
#endif
void startThread();
void stopThread();
void customEvent(QEvent *evt);
// Former ServerParams
public:
QList< QHostAddress > qlBind;
unsigned short usPort;
int iTimeout;
int iMaxBandwidth;
int iMaxUsers;
int iMaxUsersPerChannel;
int iDefaultChan;
bool bRememberChan;
int iRememberChanDuration;
int iMaxTextMessageLength;
int iMaxImageMessageLength;
int iOpusThreshold;
bool bAllowHTML;
QString qsPassword;
QString qsWelcomeText;
QString qsWelcomeTextFile;
bool bCertRequired;
bool bForceExternalAuth;
QString qsRegName;
QString qsRegPassword;
QString qsRegHost;
QString qsRegLocation;
QUrl qurlRegWeb;
bool bBonjour;
bool bAllowPing;
QRegExp qrUserName;
QRegExp qrChannelName;
unsigned int iMessageLimit;
unsigned int iMessageBurst;
unsigned int iPluginMessageLimit;
unsigned int iPluginMessageBurst;
QVariant qvSuggestVersion;
QVariant qvSuggestPositional;
QVariant qvSuggestPushToTalk;
bool bUsingMetaCert;
QSslCertificate qscCert;
QSslKey qskKey;
/// qlIntermediates contains the certificates
/// from this virtual server's certificate PEM
// bundle that do not match the virtual server's
// private key.
///
/// Simply put: it contains any certificates
/// that aren't the main certificate, or "leaf"
/// certificate.
QList< QSslCertificate > qlIntermediates;
#if defined(USE_QSSLDIFFIEHELLMANPARAMETERS)
QSslDiffieHellmanParameters qsdhpDHParams;
#endif
Timer tUptime;
bool bValid;
ChannelListenerManager m_channelListenerManager;
void readParams();
int iCodecAlpha;
int iCodecBeta;
bool bPreferAlpha;
bool bOpus;
void recheckCodecVersions(ServerUser *connectingUser = 0);
#ifdef USE_ZEROCONF
void initZeroconf();
void removeZeroconf();
#endif
// Registration, implementation in Register.cpp
QTimer qtTick;
void initRegister();
private:
int iChannelNestingLimit;
int iChannelCountLimit;
public slots:
void regSslError(const QList< QSslError > &);
void finished();
void update();
// Certificate stuff, implemented partially in Cert.cpp
public:
static bool isKeyForCert(const QSslKey &key, const QSslCertificate &cert);
/// Attempt to load a private key in PEM format from |buf|.
/// If |passphrase| is non-empty, it will be used for decrypting the private key in |buf|.
/// If a valid RSA, DSA or EC key is found, it is returned.
/// If no valid private key is found, a null QSslKey is returned.
static QSslKey privateKeyFromPEM(const QByteArray &buf, const QByteArray &pass = QByteArray());
void initializeCert();
const QString getDigest() const;
public slots:
void newClient();
void connectionClosed(QAbstractSocket::SocketError, const QString &);
void sslError(const QList< QSslError > &);
void message(unsigned int, const QByteArray &, ServerUser *cCon = nullptr);
void checkTimeout();
void tcpTransmitData(QByteArray, unsigned int);
void doSync(unsigned int);
void encrypted();
void udpActivated(int);
signals:
void reqSync(unsigned int);
void tcpTransmit(QByteArray, unsigned int id);
public:
int iServerNum;
QQueue< int > qqIds;
QList< SslServer * > qlServer;
QTimer *qtTimeout;
#ifdef Q_OS_UNIX
int aiNotify[2];
QList< int > qlUdpSocket;
#else
HANDLE hNotify;
QList< SOCKET > qlUdpSocket;
#endif
quint32 uiVersionBlob;
QList< QSocketNotifier * > qlUdpNotifier;
/// This lock provides synchronization between the
/// main thread (where control channel messages and
/// RPC happens), and the Server's voice thread.
///
/// These are the only two threads in Murmur that
/// access a Server's data.
///
/// The easiest way to understand the locking strategy
/// and synchronization between the main thread and the
/// Server's voice thread is by using the concept of
/// ownership.
///
/// A thread owning an object means that it is the only
/// thread that is allowed to write to that object. To
/// make changes to it.
///
/// Most data in the Server class is owned by the main
/// thread. That means that the main thread is the only
/// thread that writes/updates those structures.
///
/// When processing incoming voice data (and re-
/// broadcasting) that voice data), the Server's voice
/// thread needs to access various parts of Server's data,
/// such as qhUsers, qhChannels, User->cChannel, etc.
/// However, these are owned by the main thread.
///
/// To ensure correct synchronization between the two
/// threads, the contract for using qrwlVoiceThread is
/// as follows:
///
/// - When the Server's voice thread needs to read data
/// owned by the main thread, it must hold a read lock
/// on qrwlVoiceThread.
///
/// - The Server's voice thread does not write to any data
/// that is owned by the main thread.
///
/// - When the main thread needs to write to data owned by
/// itself that is accessed by the voice thread, it must
/// hold a write lock on qrwlVoiceThread.
///
/// - When the main thread needs to read data that is owned
/// by itself, it DOES NOT hold a lock on qrwlVoiceThread.
/// That is because ownership of data guarantees that no
/// other thread can write to that data.
QReadWriteLock qrwlVoiceThread;
QHash< unsigned int, ServerUser * > qhUsers;
QHash< QPair< HostAddress, quint16 >, ServerUser * > qhPeerUsers;
QHash< HostAddress, QSet< ServerUser * > > qhHostUsers;
QHash< unsigned int, Channel * > qhChannels;
QMutex qmCache;
ChanACL::ACLCache acCache;
QHash< int, QString > qhUserNameCache;
QHash< QString, int > qhUserIDCache;
QList< Ban > qlBans;
void processMsg(ServerUser *u, const char *data, int len);
void sendMessage(ServerUser *u, const char *data, int len, QByteArray &cache, bool force = false);
void run();
bool validateChannelName(const QString &name);
bool validateUserName(const QString &name);
bool checkDecrypt(ServerUser *u, const char *encrypted, char *plain, unsigned int cryptlen);
bool hasPermission(ServerUser *p, Channel *c, QFlags< ChanACL::Perm > perm);
QFlags< ChanACL::Perm > effectivePermissions(ServerUser *p, Channel *c);
void sendClientPermission(ServerUser *u, Channel *c, bool updatelast = false);
void flushClientPermissionCache(ServerUser *u, MumbleProto::PermissionQuery &mpqq);
void clearACLCache(User *p = nullptr);
void clearWhisperTargetCache();
void sendProtoAll(const ::google::protobuf::Message &msg, unsigned int msgType, unsigned int minversion);
void sendProtoExcept(ServerUser *, const ::google::protobuf::Message &msg, unsigned int msgType,
unsigned int minversion);
void sendProtoMessage(ServerUser *, const ::google::protobuf::Message &msg, unsigned int msgType);
// sendAll sends a protobuf message to all users on the server whose version is either bigger than v or
// lower than ~v. If v == 0 the message is sent to everyone.
#define MUMBLE_MH_MSG(x) \
void sendAll(const MumbleProto::x &msg, unsigned int v = 0) { sendProtoAll(msg, MessageHandler::x, v); } \
void sendExcept(ServerUser *u, const MumbleProto::x &msg, unsigned int v = 0) { \
sendProtoExcept(u, msg, MessageHandler::x, v); \
} \
void sendMessage(ServerUser *u, const MumbleProto::x &msg) { sendProtoMessage(u, msg, MessageHandler::x); }
MUMBLE_MH_ALL
#undef MUMBLE_MH_MSG
static void hashAssign(QString &destination, QByteArray &hash, const QString &str);
static void hashAssign(QByteArray &destination, QByteArray &hash, const QByteArray &source);
bool isTextAllowed(QString &str, bool &changed);
void setLiveConf(const QString &key, const QString &value);
QString addressToString(const QHostAddress &, unsigned short port);
void log(const QString &) const;
void log(ServerUser *u, const QString &) const;
void removeChannel(int id);
void removeChannel(Channel *c, Channel *dest = nullptr);
void userEnterChannel(User *u, Channel *c, MumbleProto::UserState &mpus);
bool unregisterUser(int id);
Server(int snum, QObject *parent = nullptr);
~Server();
bool canNest(Channel *newParent, Channel *channel = nullptr) const;
// RPC functions. Implementation in RPC.cpp
void connectAuthenticator(QObject *p);
void disconnectAuthenticator(QObject *p);
void connectListener(QObject *p);
void disconnectListener(QObject *p);
void setTempGroups(int userid, int sessionId, Channel *cChannel, const QStringList &groups);
void clearTempGroups(User *user, Channel *cChannel = nullptr, bool recurse = true);
void startListeningToChannel(ServerUser *user, Channel *cChannel);
void stopListeningToChannel(ServerUser *user, Channel *cChannel);
void sendWelcomeMessageTo(ServerUser *user);
signals:
void registerUserSig(int &, const QMap< int, QString > &);
void unregisterUserSig(int &, int);
void getRegisteredUsersSig(const QString &, QMap< int, QString > &);
void getRegistrationSig(int &, int, QMap< int, QString > &);
void authenticateSig(int &, QString &, int, const QList< QSslCertificate > &, const QString &, bool,
const QString &);
void setInfoSig(int &, int, const QMap< int, QString > &);
void setTextureSig(int &, int, const QByteArray &);
void idToNameSig(QString &, int);
void nameToIdSig(int &, const QString &);
void idToTextureSig(QByteArray &, int);
void userStateChanged(const User *);
void userTextMessage(const User *, const TextMessage &);
void userConnected(const User *);
void userDisconnected(const User *);
void channelStateChanged(const Channel *);
void channelCreated(const Channel *);
void channelRemoved(const Channel *);
void textMessageFilterSig(int &, const User *, MumbleProto::TextMessage &);
void contextAction(const User *, const QString &, unsigned int, int);
public:
void setUserState(User *p, Channel *parent, bool mute, bool deaf, bool suppressed, bool prioritySpeaker,
const QString &name = QString(), const QString &comment = QString());
/// Update a channel's state using the ChannelState protobuf message and
/// broadcast the changes appropriately to the server. On return, if
/// err is non-empty, the operation failed, and err contains a description
/// of the error.
///
/// This method is equivalent to the logic that happens in
/// Server::msgChannelState when a ChannelState message is received from
/// a user. However, this method doesn't do permissions checking.
///
/// This method is used by the gRPC implementation to perform channel
/// state changes.
bool setChannelStateGRPC(const MumbleProto::ChannelState &cs, QString &err);
bool setChannelState(Channel *c, Channel *parent, const QString &qsName, const QSet< Channel * > &links,
const QString &desc = QString(), const int position = 0);
/// Send a text message using the TextMessage protobuf message
/// as a template.
/// This is equivalent to the logic that happens in Server::msgTextMessage
/// when sending a receieved TextMessage, with the exception that this
/// method does not perform any permission checks.
/// It is used by our gRPC implementation to send text messages.
void sendTextMessageGRPC(const ::MumbleProto::TextMessage &tm);
void sendTextMessage(Channel *cChannel, ServerUser *pUser, bool tree, const QString &text);
/// Returns true if a channel is full. If a user is provided, false will always
/// be returned if the user has write permission in the channel.
bool isChannelFull(Channel *c, ServerUser *u = 0);
// Database / DBus functions. Implementation in ServerDB.cpp
void initialize();
int authenticate(QString &name, const QString &pw, int sessionId = 0, const QStringList &emails = QStringList(),
const QString &certhash = QString(), bool bStrongCert = false,
const QList< QSslCertificate > & = QList< QSslCertificate >());
Channel *addChannel(Channel *c, const QString &name, bool temporary = false, int position = 0,
unsigned int maxUsers = 0);
void removeChannelDB(const Channel *c);
void readChannels(Channel *p = nullptr);
void readLinks();
void updateChannel(const Channel *c);
void readChannelPrivs(Channel *c);
void setLastChannel(const User *u);
int readLastChannel(int id);
/// Set last_disconnect of a registered user to the current time
void setLastDisconnect(const User *u);
void dumpChannel(const Channel *c);
int getUserID(const QString &name);
QString getUserName(int id);
QByteArray getUserTexture(int id);
QMap< int, QString > getRegistration(int id);
int registerUser(const QMap< int, QString > &info);
bool unregisterUserDB(int id);
QList< UserInfo > getRegisteredUsersEx();
QMap< int, QString > getRegisteredUsers(const QString &filter = QString());
bool setInfo(int id, const QMap< int, QString > &info);
bool setTexture(int id, const QByteArray &texture);
bool isUserId(int id);
void addLink(Channel *c, Channel *l);
void removeLink(Channel *c, Channel *l);
void getBans();
void saveBans();
QVariant getConf(const QString &key, QVariant def);
void setConf(const QString &key, const QVariant &value);
void dblog(const QString &str) const;
// From msgHandler. Implementation in Messages.cpp
#define MUMBLE_MH_MSG(x) void msg##x(ServerUser *, MumbleProto::x &);
MUMBLE_MH_ALL
#undef MUMBLE_MH_MSG
};
#endif
|