mirror of
https://github.com/Cockatrice/Cockatrice.git
synced 2026-11-05 09:33:25 -08:00
155f7b0143
* [Servatrice] Relay room channel messages over ISL * [Servatrice] Skip audit log for unknown ISL channel per review - externalRoomSay drops messages for channels not in the local catalog, matching Server_Room::say, instead of logging what was never delivered --------- Co-authored-by: Lukas Brübach <Bruebach.Lukas@bdosecurity.de>
295 lines
9.2 KiB
C++
295 lines
9.2 KiB
C++
#ifndef SERVER_H
|
|
#define SERVER_H
|
|
|
|
#include "server_player_reference.h"
|
|
|
|
#include <QList>
|
|
#include <QMap>
|
|
#include <QMultiMap>
|
|
#include <QMutex>
|
|
#include <QMutexLocker>
|
|
#include <QObject>
|
|
#include <QReadWriteLock>
|
|
#include <QString>
|
|
#include <QtGlobal>
|
|
#include <qtmetamacros.h>
|
|
|
|
class Server_DatabaseInterface;
|
|
class Server_Room;
|
|
class Server_ProtocolHandler;
|
|
class Server_AbstractUserInterface;
|
|
class IslMessage;
|
|
class SessionEvent;
|
|
class RoomEvent;
|
|
class ServerInfo_Game;
|
|
class ServerInfo_Room;
|
|
class Response;
|
|
class GameEventContainer;
|
|
class CommandContainer;
|
|
class Command_JoinGame;
|
|
class QThread;
|
|
class ServerInfo_User;
|
|
|
|
enum AuthenticationResult
|
|
{
|
|
NotLoggedIn,
|
|
PasswordRight,
|
|
UnknownUser,
|
|
WouldOverwriteOldSession,
|
|
UserIsBanned,
|
|
UsernameInvalid,
|
|
RegistrationRequired,
|
|
UserIsInactive,
|
|
ClientIdRequired,
|
|
PasswordChangeRequired
|
|
};
|
|
|
|
class Server : public QObject
|
|
{
|
|
Q_OBJECT
|
|
signals:
|
|
void pingClockTimeout();
|
|
void sigSendIslMessage(const IslMessage &message, int serverId);
|
|
void endSession(qint64 sessionId);
|
|
private slots:
|
|
void broadcastRoomUpdate(const ServerInfo_Room &roomInfo, bool sendToIsl = false);
|
|
|
|
public:
|
|
mutable QReadWriteLock clientsLock, roomsLock; // locking order: roomsLock before clientsLock
|
|
explicit Server(QObject *parent = nullptr);
|
|
~Server() override = default;
|
|
AuthenticationResult loginUser(Server_ProtocolHandler *session,
|
|
QString &name,
|
|
const QString &password,
|
|
bool passwordNeedsHash,
|
|
QString &reason,
|
|
int &secondsLeft,
|
|
QString &clientid,
|
|
QString &clientVersion,
|
|
QString &connectionType);
|
|
void broadcastUserInfoUpdate(Server_ProtocolHandler *source);
|
|
|
|
const QMap<int, Server_Room *> &getRooms()
|
|
{
|
|
return rooms;
|
|
}
|
|
|
|
Server_AbstractUserInterface *findUser(const QString &userName) const;
|
|
const QMap<QString, Server_ProtocolHandler *> &getUsers() const
|
|
{
|
|
return users;
|
|
}
|
|
const QMap<qint64, Server_ProtocolHandler *> &getUsersBySessionId() const
|
|
{
|
|
return usersBySessionId;
|
|
}
|
|
virtual QMap<QString, bool> getServerRequiredFeatureList() const
|
|
{
|
|
return QMap<QString, bool>();
|
|
}
|
|
void addClient(Server_ProtocolHandler *player);
|
|
void removeClient(Server_ProtocolHandler *player);
|
|
QList<QString> getOnlineModeratorList() const;
|
|
virtual QString getLoginMessage() const
|
|
{
|
|
return QString();
|
|
}
|
|
virtual SessionEvent *getLoginSessionEvent() const
|
|
{
|
|
return nullptr;
|
|
}
|
|
virtual QString getRequiredFeatures() const
|
|
{
|
|
return QString();
|
|
}
|
|
virtual bool permitUnregisteredUsers() const
|
|
{
|
|
return true;
|
|
}
|
|
virtual bool getGameShouldPing() const
|
|
{
|
|
return false;
|
|
}
|
|
virtual bool getClientIDRequiredEnabled() const
|
|
{
|
|
return false;
|
|
}
|
|
virtual bool getRegOnlyServerEnabled() const
|
|
{
|
|
return false;
|
|
}
|
|
virtual bool getMaxUserLimitEnabled() const
|
|
{
|
|
return false;
|
|
}
|
|
virtual bool getEnableLogQuery() const
|
|
{
|
|
return false;
|
|
}
|
|
virtual bool getStoreReplaysEnabled() const
|
|
{
|
|
return true;
|
|
}
|
|
virtual int getIdleClientTimeout() const
|
|
{
|
|
return 0;
|
|
}
|
|
virtual int getClientKeepAlive() const
|
|
{
|
|
return 0;
|
|
}
|
|
virtual int getMaxGameInactivityTime() const
|
|
{
|
|
return 9999999;
|
|
}
|
|
virtual int getMaxPlayerInactivityTime() const
|
|
{
|
|
return 9999999;
|
|
}
|
|
virtual int getMessageCountingInterval() const
|
|
{
|
|
return 0;
|
|
}
|
|
virtual int getMaxMessageCountPerInterval() const
|
|
{
|
|
return 0;
|
|
}
|
|
virtual int getMaxMessageSizePerInterval() const
|
|
{
|
|
return 0;
|
|
}
|
|
virtual int getMaxGamesPerUser() const
|
|
{
|
|
return -1;
|
|
}
|
|
virtual int getCommandCountingInterval() const
|
|
{
|
|
return 0;
|
|
}
|
|
virtual int getMaxCommandCountPerInterval() const
|
|
{
|
|
return 0;
|
|
}
|
|
virtual int getMaxUserTotal() const
|
|
{
|
|
return 9999999;
|
|
}
|
|
virtual int getServerID() const
|
|
{
|
|
return 0;
|
|
}
|
|
virtual bool permitCreateGameAsJudge() const
|
|
{
|
|
return false;
|
|
}
|
|
/// Called once per actual game start with how long bringing every player's
|
|
/// zones online took, so servers can spot deck sizes that wedge threads.
|
|
virtual void observeGameStartDurationMs(qint64 /* elapsedMs */)
|
|
{
|
|
}
|
|
/**
|
|
* @brief Record a failed login attempt for the (address, username) pair; returns true if now locked out.
|
|
*
|
|
* Keyed by pair so a successful login as one user cannot wipe out another
|
|
* user's failure history from the same address (e.g. a guest login or the
|
|
* attacker's own account clearing the way for further guessing).
|
|
*/
|
|
virtual bool recordFailedLogin(const QString & /*ipAddress*/, const QString & /*userName*/)
|
|
{
|
|
return false;
|
|
}
|
|
/**
|
|
* @brief True if the (address, username) pair is already locked out of logging in.
|
|
*
|
|
* Consulted before any authentication work (database round trip, password
|
|
* verification) so a blocked pair cannot burn server CPU per attempt.
|
|
*/
|
|
virtual bool isLoginRateLimited(const QString & /*ipAddress*/, const QString & /*userName*/)
|
|
{
|
|
return false;
|
|
}
|
|
/**
|
|
* @brief Seconds remaining before the login rate limit for the (address, username) pair lifts.
|
|
* Returns 0 if not limited.
|
|
*/
|
|
virtual int loginRateLimitRemainingSeconds(const QString & /*ipAddress*/, const QString & /*userName*/)
|
|
{
|
|
return 0;
|
|
}
|
|
/** @brief Clear any failed-login lockout for the (address, username) pair, e.g. after a successful login. */
|
|
virtual void clearFailedLogins(const QString & /*ipAddress*/, const QString & /*userName*/)
|
|
{
|
|
}
|
|
|
|
Server_DatabaseInterface *getDatabaseInterface() const;
|
|
int getNextLocalGameId()
|
|
{
|
|
QMutexLocker locker(&nextLocalGameIdMutex);
|
|
return ++nextLocalGameId;
|
|
}
|
|
|
|
void sendIsl_Response(const Response &item, int serverId = -1, qint64 sessionId = -1);
|
|
void sendIsl_SessionEvent(const SessionEvent &item, int serverId = -1, qint64 sessionId = -1);
|
|
void sendIsl_GameEventContainer(const GameEventContainer &item, int serverId = -1, qint64 sessionId = -1);
|
|
void sendIsl_RoomEvent(const RoomEvent &item, int serverId = -1, qint64 sessionId = -1);
|
|
void sendIsl_GameCommand(const CommandContainer &item, int serverId, qint64 sessionId, int roomId, int playerId);
|
|
void sendIsl_RoomCommand(const CommandContainer &item, int serverId, qint64 sessionId, int roomId);
|
|
|
|
const QMap<QString, Server_AbstractUserInterface *> &getExternalUsers() const
|
|
{
|
|
return externalUsers;
|
|
}
|
|
|
|
void addPersistentPlayer(const QString &userName, int roomId, int gameId, int playerId);
|
|
void removePersistentPlayer(const QString &userName, int roomId, int gameId, int playerId);
|
|
QList<PlayerReference> getPersistentPlayerReferences(const QString &userName) const;
|
|
int getUsersCount() const;
|
|
int getGamesCount() const;
|
|
int getTCPUserCount() const
|
|
{
|
|
return tcpUserCount;
|
|
}
|
|
int getWebSocketUserCount() const
|
|
{
|
|
return webSocketUserCount;
|
|
}
|
|
|
|
private:
|
|
QMultiMap<QString, PlayerReference> persistentPlayers;
|
|
mutable QReadWriteLock persistentPlayersLock;
|
|
int nextLocalGameId, tcpUserCount, webSocketUserCount;
|
|
QMutex nextLocalGameIdMutex;
|
|
|
|
protected slots:
|
|
void externalUserJoined(const ServerInfo_User &userInfo);
|
|
void externalUserLeft(const QString &userName);
|
|
void externalRoomUserJoined(int roomId, const ServerInfo_User &userInfo);
|
|
void externalRoomUserLeft(int roomId, const QString &userName);
|
|
void externalRoomSay(int roomId, const QString &userName, const QString &message, const QString &channelId);
|
|
void externalRoomRemoveMessages(int roomId, const QString &userName, int amount);
|
|
void externalRoomGameListChanged(int roomId, const ServerInfo_Game &gameInfo);
|
|
void
|
|
externalJoinGameCommandReceived(const Command_JoinGame &cmd, int cmdId, int roomId, int serverId, qint64 sessionId);
|
|
void
|
|
externalGameCommandContainerReceived(const CommandContainer &cont, int playerId, int serverId, qint64 sessionId);
|
|
void externalGameEventContainerReceived(const GameEventContainer &cont, qint64 sessionId);
|
|
void externalResponseReceived(const Response &resp, qint64 sessionId);
|
|
|
|
virtual void doSendIslMessage(const IslMessage & /* msg */, int /* serverId */)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
void prepareDestroy();
|
|
void setDatabaseInterface(Server_DatabaseInterface *_databaseInterface);
|
|
QList<Server_ProtocolHandler *> clients;
|
|
QMap<qint64, Server_ProtocolHandler *> usersBySessionId;
|
|
QMap<QString, Server_ProtocolHandler *> users;
|
|
QMap<qint64, Server_AbstractUserInterface *> externalUsersBySessionId;
|
|
QMap<QString, Server_AbstractUserInterface *> externalUsers;
|
|
QMap<int, Server_Room *> rooms;
|
|
QMap<QThread *, Server_DatabaseInterface *> databaseInterfaces;
|
|
void addRoom(Server_Room *newRoom);
|
|
};
|
|
|
|
#endif
|