d246fa39fe
Implemented the ability to set the server to only allow registered users. Also updated client to reflect the log-in rejection as well as put a check in place for the server to not start if db connection is not available yet registration is required.
596 lines
19 KiB
C++
596 lines
19 KiB
C++
/***************************************************************************
|
|
* Copyright (C) 2008 by Max-Wilhelm Bruker *
|
|
* brukie@laptop *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
* This program is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU General Public License *
|
|
* along with this program; if not, write to the *
|
|
* Free Software Foundation, Inc., *
|
|
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
|
|
***************************************************************************/
|
|
#include "server.h"
|
|
#include "server_game.h"
|
|
#include "server_player.h"
|
|
#include "server_counter.h"
|
|
#include "server_room.h"
|
|
#include "server_protocolhandler.h"
|
|
#include "server_remoteuserinterface.h"
|
|
#include "server_metatypes.h"
|
|
#include "server_database_interface.h"
|
|
#include "pb/event_user_joined.pb.h"
|
|
#include "pb/event_user_left.pb.h"
|
|
#include "pb/event_list_rooms.pb.h"
|
|
#include "pb/session_event.pb.h"
|
|
#include "pb/isl_message.pb.h"
|
|
#include <QCoreApplication>
|
|
#include <QThread>
|
|
#include <QDebug>
|
|
#include <QSettings>
|
|
|
|
Server::Server(bool _threaded, QObject *parent)
|
|
: QObject(parent), threaded(_threaded), nextLocalGameId(0)
|
|
{
|
|
qRegisterMetaType<ServerInfo_Game>("ServerInfo_Game");
|
|
qRegisterMetaType<ServerInfo_Room>("ServerInfo_Room");
|
|
qRegisterMetaType<ServerInfo_User>("ServerInfo_User");
|
|
qRegisterMetaType<CommandContainer>("CommandContainer");
|
|
qRegisterMetaType<Response>("Response");
|
|
qRegisterMetaType<GameEventContainer>("GameEventContainer");
|
|
qRegisterMetaType<IslMessage>("IslMessage");
|
|
qRegisterMetaType<Command_JoinGame>("Command_JoinGame");
|
|
|
|
connect(this, SIGNAL(sigSendIslMessage(IslMessage, int)), this, SLOT(doSendIslMessage(IslMessage, int)), Qt::QueuedConnection);
|
|
}
|
|
|
|
Server::~Server()
|
|
{
|
|
}
|
|
|
|
void Server::prepareDestroy()
|
|
{
|
|
// dirty :(
|
|
if (threaded) {
|
|
clientsLock.lockForRead();
|
|
for (int i = 0; i < clients.size(); ++i)
|
|
QMetaObject::invokeMethod(clients.at(i), "prepareDestroy", Qt::QueuedConnection);
|
|
clientsLock.unlock();
|
|
|
|
bool done = false;
|
|
|
|
class SleeperThread : public QThread
|
|
{
|
|
public:
|
|
static void msleep(unsigned long msecs) { QThread::usleep(msecs); }
|
|
};
|
|
|
|
do {
|
|
SleeperThread::msleep(10);
|
|
clientsLock.lockForRead();
|
|
if (clients.isEmpty())
|
|
done = true;
|
|
clientsLock.unlock();
|
|
} while (!done);
|
|
} else {
|
|
// no locking is needed in unthreaded mode
|
|
while (!clients.isEmpty())
|
|
clients.first()->prepareDestroy();
|
|
}
|
|
|
|
roomsLock.lockForWrite();
|
|
QMapIterator<int, Server_Room *> roomIterator(rooms);
|
|
while (roomIterator.hasNext())
|
|
delete roomIterator.next().value();
|
|
rooms.clear();
|
|
roomsLock.unlock();
|
|
}
|
|
|
|
void Server::setDatabaseInterface(Server_DatabaseInterface *_databaseInterface)
|
|
{
|
|
connect(this, SIGNAL(endSession(qint64)), _databaseInterface, SLOT(endSession(qint64)));
|
|
databaseInterfaces.insert(QThread::currentThread(), _databaseInterface);
|
|
}
|
|
|
|
Server_DatabaseInterface *Server::getDatabaseInterface() const
|
|
{
|
|
return databaseInterfaces.value(QThread::currentThread());
|
|
}
|
|
|
|
AuthenticationResult Server::loginUser(Server_ProtocolHandler *session, QString &name, const QString &password, QString &reasonStr, int &secondsLeft)
|
|
{
|
|
if (name.size() > 35)
|
|
name = name.left(35);
|
|
|
|
Server_DatabaseInterface *databaseInterface = getDatabaseInterface();
|
|
|
|
QWriteLocker locker(&clientsLock);
|
|
|
|
AuthenticationResult authState = databaseInterface->checkUserPassword(session, name, password, reasonStr, secondsLeft);
|
|
if ((authState == NotLoggedIn) || (authState == UserIsBanned || authState == UsernameInvalid))
|
|
return authState;
|
|
|
|
ServerInfo_User data = databaseInterface->getUserData(name, true);
|
|
data.set_address(session->getAddress().toStdString());
|
|
name = QString::fromStdString(data.name()); // Compensate for case indifference
|
|
|
|
databaseInterface->lockSessionTables();
|
|
|
|
if (authState == PasswordRight) {
|
|
if (users.contains(name) || databaseInterface->userSessionExists(name)) {
|
|
qDebug("Login denied: would overwrite old session");
|
|
databaseInterface->unlockSessionTables();
|
|
return WouldOverwriteOldSession;
|
|
}
|
|
} else if (authState == UnknownUser) {
|
|
// Change user name so that no two users have the same names,
|
|
// don't interfere with registered user names though.
|
|
QSettings *settings = new QSettings("servatrice.ini", QSettings::IniFormat);
|
|
bool requireReg = settings->value("server/regonly").toBool();
|
|
if (requireReg) {
|
|
qDebug("Login denied: registration required");
|
|
databaseInterface->unlockSessionTables();
|
|
return RegistrationRequired;
|
|
}
|
|
|
|
QString tempName = name;
|
|
int i = 0;
|
|
while (users.contains(tempName) || databaseInterface->userExists(tempName) || databaseInterface->userSessionExists(tempName))
|
|
tempName = name + "_" + QString::number(++i);
|
|
name = tempName;
|
|
data.set_name(name.toStdString());
|
|
}
|
|
|
|
users.insert(name, session);
|
|
qDebug() << "Server::loginUser:" << session << "name=" << name;
|
|
|
|
data.set_session_id(databaseInterface->startSession(name, session->getAddress()));
|
|
databaseInterface->unlockSessionTables();
|
|
|
|
usersBySessionId.insert(data.session_id(), session);
|
|
|
|
qDebug() << "session id:" << data.session_id();
|
|
session->setUserInfo(data);
|
|
|
|
Event_UserJoined event;
|
|
event.mutable_user_info()->CopyFrom(session->copyUserInfo(false));
|
|
SessionEvent *se = Server_ProtocolHandler::prepareSessionEvent(event);
|
|
for (int i = 0; i < clients.size(); ++i)
|
|
if (clients[i]->getAcceptsUserListChanges())
|
|
clients[i]->sendProtocolItem(*se);
|
|
delete se;
|
|
|
|
event.mutable_user_info()->CopyFrom(session->copyUserInfo(true, true, true));
|
|
locker.unlock();
|
|
|
|
se = Server_ProtocolHandler::prepareSessionEvent(event);
|
|
sendIsl_SessionEvent(*se);
|
|
delete se;
|
|
|
|
return authState;
|
|
}
|
|
|
|
void Server::addPersistentPlayer(const QString &userName, int roomId, int gameId, int playerId)
|
|
{
|
|
QWriteLocker locker(&persistentPlayersLock);
|
|
persistentPlayers.insert(userName, PlayerReference(roomId, gameId, playerId));
|
|
}
|
|
|
|
void Server::removePersistentPlayer(const QString &userName, int roomId, int gameId, int playerId)
|
|
{
|
|
QWriteLocker locker(&persistentPlayersLock);
|
|
persistentPlayers.remove(userName, PlayerReference(roomId, gameId, playerId));
|
|
}
|
|
|
|
QList<PlayerReference> Server::getPersistentPlayerReferences(const QString &userName) const
|
|
{
|
|
QReadLocker locker(&persistentPlayersLock);
|
|
return persistentPlayers.values(userName);
|
|
}
|
|
|
|
Server_AbstractUserInterface *Server::findUser(const QString &userName) const
|
|
{
|
|
// Call this only with clientsLock set.
|
|
|
|
Server_AbstractUserInterface *userHandler = users.value(userName);
|
|
if (userHandler)
|
|
return userHandler;
|
|
else
|
|
return externalUsers.value(userName);
|
|
}
|
|
|
|
void Server::addClient(Server_ProtocolHandler *client)
|
|
{
|
|
QWriteLocker locker(&clientsLock);
|
|
clients << client;
|
|
}
|
|
|
|
void Server::removeClient(Server_ProtocolHandler *client)
|
|
{
|
|
QWriteLocker locker(&clientsLock);
|
|
clients.removeAt(clients.indexOf(client));
|
|
ServerInfo_User *data = client->getUserInfo();
|
|
if (data) {
|
|
Event_UserLeft event;
|
|
event.set_name(data->name());
|
|
SessionEvent *se = Server_ProtocolHandler::prepareSessionEvent(event);
|
|
for (int i = 0; i < clients.size(); ++i)
|
|
if (clients[i]->getAcceptsUserListChanges())
|
|
clients[i]->sendProtocolItem(*se);
|
|
sendIsl_SessionEvent(*se);
|
|
delete se;
|
|
|
|
users.remove(QString::fromStdString(data->name()));
|
|
qDebug() << "Server::removeClient: name=" << QString::fromStdString(data->name());
|
|
|
|
if (data->has_session_id()) {
|
|
const qint64 sessionId = data->session_id();
|
|
usersBySessionId.remove(sessionId);
|
|
emit endSession(sessionId);
|
|
qDebug() << "closed session id:" << sessionId;
|
|
}
|
|
}
|
|
qDebug() << "Server::removeClient: removed" << (void *) client << ";" << clients.size() << "clients; " << users.size() << "users left";
|
|
}
|
|
|
|
void Server::externalUserJoined(const ServerInfo_User &userInfo)
|
|
{
|
|
// This function is always called from the main thread via signal/slot.
|
|
clientsLock.lockForWrite();
|
|
|
|
Server_RemoteUserInterface *newUser = new Server_RemoteUserInterface(this, ServerInfo_User_Container(userInfo));
|
|
externalUsers.insert(QString::fromStdString(userInfo.name()), newUser);
|
|
externalUsersBySessionId.insert(userInfo.session_id(), newUser);
|
|
|
|
Event_UserJoined event;
|
|
event.mutable_user_info()->CopyFrom(userInfo);
|
|
|
|
SessionEvent *se = Server_ProtocolHandler::prepareSessionEvent(event);
|
|
for (int i = 0; i < clients.size(); ++i)
|
|
if (clients[i]->getAcceptsUserListChanges())
|
|
clients[i]->sendProtocolItem(*se);
|
|
delete se;
|
|
clientsLock.unlock();
|
|
|
|
ResponseContainer rc(-1);
|
|
newUser->joinPersistentGames(rc);
|
|
newUser->sendResponseContainer(rc, Response::RespNothing);
|
|
}
|
|
|
|
void Server::externalUserLeft(const QString &userName)
|
|
{
|
|
// This function is always called from the main thread via signal/slot.
|
|
|
|
clientsLock.lockForWrite();
|
|
Server_AbstractUserInterface *user = externalUsers.take(userName);
|
|
externalUsersBySessionId.remove(user->getUserInfo()->session_id());
|
|
clientsLock.unlock();
|
|
|
|
QMap<int, QPair<int, int> > userGames(user->getGames());
|
|
QMapIterator<int, QPair<int, int> > userGamesIterator(userGames);
|
|
roomsLock.lockForRead();
|
|
while (userGamesIterator.hasNext()) {
|
|
userGamesIterator.next();
|
|
Server_Room *room = rooms.value(userGamesIterator.value().first);
|
|
if (!room)
|
|
continue;
|
|
|
|
QReadLocker roomGamesLocker(&room->gamesLock);
|
|
Server_Game *game = room->getGames().value(userGamesIterator.key());
|
|
if (!game)
|
|
continue;
|
|
|
|
QMutexLocker gameLocker(&game->gameMutex);
|
|
Server_Player *player = game->getPlayers().value(userGamesIterator.value().second);
|
|
if (!player)
|
|
continue;
|
|
|
|
player->disconnectClient();
|
|
}
|
|
roomsLock.unlock();
|
|
|
|
delete user;
|
|
|
|
Event_UserLeft event;
|
|
event.set_name(userName.toStdString());
|
|
|
|
SessionEvent *se = Server_ProtocolHandler::prepareSessionEvent(event);
|
|
clientsLock.lockForRead();
|
|
for (int i = 0; i < clients.size(); ++i)
|
|
if (clients[i]->getAcceptsUserListChanges())
|
|
clients[i]->sendProtocolItem(*se);
|
|
clientsLock.unlock();
|
|
delete se;
|
|
}
|
|
|
|
void Server::externalRoomUserJoined(int roomId, const ServerInfo_User &userInfo)
|
|
{
|
|
// This function is always called from the main thread via signal/slot.
|
|
QReadLocker locker(&roomsLock);
|
|
|
|
Server_Room *room = rooms.value(roomId);
|
|
if (!room) {
|
|
qDebug() << "externalRoomUserJoined: room id=" << roomId << "not found";
|
|
return;
|
|
}
|
|
room->addExternalUser(userInfo);
|
|
}
|
|
|
|
void Server::externalRoomUserLeft(int roomId, const QString &userName)
|
|
{
|
|
// This function is always called from the main thread via signal/slot.
|
|
QReadLocker locker(&roomsLock);
|
|
|
|
Server_Room *room = rooms.value(roomId);
|
|
if (!room) {
|
|
qDebug() << "externalRoomUserLeft: room id=" << roomId << "not found";
|
|
return;
|
|
}
|
|
room->removeExternalUser(userName);
|
|
}
|
|
|
|
void Server::externalRoomSay(int roomId, const QString &userName, const QString &message)
|
|
{
|
|
// This function is always called from the main thread via signal/slot.
|
|
QReadLocker locker(&roomsLock);
|
|
|
|
Server_Room *room = rooms.value(roomId);
|
|
if (!room) {
|
|
qDebug() << "externalRoomSay: room id=" << roomId << "not found";
|
|
return;
|
|
}
|
|
room->say(userName, message, false);
|
|
}
|
|
|
|
void Server::externalRoomGameListChanged(int roomId, const ServerInfo_Game &gameInfo)
|
|
{
|
|
// This function is always called from the main thread via signal/slot.
|
|
QReadLocker locker(&roomsLock);
|
|
|
|
Server_Room *room = rooms.value(roomId);
|
|
if (!room) {
|
|
qDebug() << "externalRoomGameListChanged: room id=" << roomId << "not found";
|
|
return;
|
|
}
|
|
room->updateExternalGameList(gameInfo);
|
|
}
|
|
|
|
void Server::externalJoinGameCommandReceived(const Command_JoinGame &cmd, int cmdId, int roomId, int serverId, qint64 sessionId)
|
|
{
|
|
// This function is always called from the main thread via signal/slot.
|
|
|
|
try {
|
|
QReadLocker roomsLocker(&roomsLock);
|
|
QReadLocker clientsLocker(&clientsLock);
|
|
|
|
Server_Room *room = rooms.value(roomId);
|
|
if (!room) {
|
|
qDebug() << "externalJoinGameCommandReceived: room id=" << roomId << "not found";
|
|
throw Response::RespNotInRoom;
|
|
}
|
|
Server_AbstractUserInterface *userInterface = externalUsersBySessionId.value(sessionId);
|
|
if (!userInterface) {
|
|
qDebug() << "externalJoinGameCommandReceived: session id=" << sessionId << "not found";
|
|
throw Response::RespNotInRoom;
|
|
}
|
|
|
|
ResponseContainer responseContainer(cmdId);
|
|
Response::ResponseCode responseCode = room->processJoinGameCommand(cmd, responseContainer, userInterface);
|
|
userInterface->sendResponseContainer(responseContainer, responseCode);
|
|
} catch (Response::ResponseCode code) {
|
|
Response response;
|
|
response.set_cmd_id(cmdId);
|
|
response.set_response_code(code);
|
|
|
|
sendIsl_Response(response, serverId, sessionId);
|
|
}
|
|
}
|
|
|
|
void Server::externalGameCommandContainerReceived(const CommandContainer &cont, int playerId, int serverId, qint64 sessionId)
|
|
{
|
|
// This function is always called from the main thread via signal/slot.
|
|
|
|
try {
|
|
ResponseContainer responseContainer(cont.cmd_id());
|
|
Response::ResponseCode finalResponseCode = Response::RespOk;
|
|
|
|
QReadLocker roomsLocker(&roomsLock);
|
|
Server_Room *room = rooms.value(cont.room_id());
|
|
if (!room) {
|
|
qDebug() << "externalGameCommandContainerReceived: room id=" << cont.room_id() << "not found";
|
|
throw Response::RespNotInRoom;
|
|
}
|
|
|
|
QReadLocker roomGamesLocker(&room->gamesLock);
|
|
Server_Game *game = room->getGames().value(cont.game_id());
|
|
if (!game) {
|
|
qDebug() << "externalGameCommandContainerReceived: game id=" << cont.game_id() << "not found";
|
|
throw Response::RespNotInRoom;
|
|
}
|
|
|
|
QMutexLocker gameLocker(&game->gameMutex);
|
|
Server_Player *player = game->getPlayers().value(playerId);
|
|
if (!player) {
|
|
qDebug() << "externalGameCommandContainerReceived: player id=" << playerId << "not found";
|
|
throw Response::RespNotInRoom;
|
|
}
|
|
|
|
GameEventStorage ges;
|
|
for (int i = cont.game_command_size() - 1; i >= 0; --i) {
|
|
const GameCommand &sc = cont.game_command(i);
|
|
qDebug() << "[ISL]" << QString::fromStdString(sc.ShortDebugString());
|
|
|
|
Response::ResponseCode resp = player->processGameCommand(sc, responseContainer, ges);
|
|
|
|
if (resp != Response::RespOk)
|
|
finalResponseCode = resp;
|
|
}
|
|
ges.sendToGame(game);
|
|
|
|
if (finalResponseCode != Response::RespNothing) {
|
|
player->playerMutex.lock();
|
|
player->getUserInterface()->sendResponseContainer(responseContainer, finalResponseCode);
|
|
player->playerMutex.unlock();
|
|
}
|
|
} catch (Response::ResponseCode code) {
|
|
Response response;
|
|
response.set_cmd_id(cont.cmd_id());
|
|
response.set_response_code(code);
|
|
|
|
sendIsl_Response(response, serverId, sessionId);
|
|
}
|
|
}
|
|
|
|
void Server::externalGameEventContainerReceived(const GameEventContainer &cont, qint64 sessionId)
|
|
{
|
|
// This function is always called from the main thread via signal/slot.
|
|
|
|
QReadLocker usersLocker(&clientsLock);
|
|
|
|
Server_ProtocolHandler *client = usersBySessionId.value(sessionId);
|
|
if (!client) {
|
|
qDebug() << "externalGameEventContainerReceived: session" << sessionId << "not found";
|
|
return;
|
|
}
|
|
client->sendProtocolItem(cont);
|
|
}
|
|
|
|
void Server::externalResponseReceived(const Response &resp, qint64 sessionId)
|
|
{
|
|
// This function is always called from the main thread via signal/slot.
|
|
|
|
QReadLocker usersLocker(&clientsLock);
|
|
|
|
Server_ProtocolHandler *client = usersBySessionId.value(sessionId);
|
|
if (!client) {
|
|
qDebug() << "externalResponseReceived: session" << sessionId << "not found";
|
|
return;
|
|
}
|
|
client->sendProtocolItem(resp);
|
|
}
|
|
|
|
void Server::broadcastRoomUpdate(const ServerInfo_Room &roomInfo, bool sendToIsl)
|
|
{
|
|
// This function is always called from the main thread via signal/slot.
|
|
|
|
Event_ListRooms event;
|
|
event.add_room_list()->CopyFrom(roomInfo);
|
|
|
|
SessionEvent *se = Server_ProtocolHandler::prepareSessionEvent(event);
|
|
|
|
clientsLock.lockForRead();
|
|
for (int i = 0; i < clients.size(); ++i)
|
|
if (clients[i]->getAcceptsRoomListChanges())
|
|
clients[i]->sendProtocolItem(*se);
|
|
clientsLock.unlock();
|
|
|
|
if (sendToIsl)
|
|
sendIsl_SessionEvent(*se);
|
|
|
|
delete se;
|
|
}
|
|
|
|
void Server::addRoom(Server_Room *newRoom)
|
|
{
|
|
QWriteLocker locker(&roomsLock);
|
|
qDebug() << "Adding room: ID=" << newRoom->getId() << "name=" << newRoom->getName();
|
|
rooms.insert(newRoom->getId(), newRoom);
|
|
connect(newRoom, SIGNAL(roomInfoChanged(ServerInfo_Room)), this, SLOT(broadcastRoomUpdate(const ServerInfo_Room &)), Qt::QueuedConnection);
|
|
}
|
|
|
|
int Server::getUsersCount() const
|
|
{
|
|
QReadLocker locker(&clientsLock);
|
|
return users.size();
|
|
}
|
|
|
|
int Server::getGamesCount() const
|
|
{
|
|
int result = 0;
|
|
QReadLocker locker(&roomsLock);
|
|
QMapIterator<int, Server_Room *> roomIterator(rooms);
|
|
while (roomIterator.hasNext()) {
|
|
Server_Room *room = roomIterator.next().value();
|
|
QReadLocker roomLocker(&room->gamesLock);
|
|
result += room->getGames().size();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void Server::sendIsl_Response(const Response &item, int serverId, qint64 sessionId)
|
|
{
|
|
IslMessage msg;
|
|
msg.set_message_type(IslMessage::RESPONSE);
|
|
if (sessionId != -1)
|
|
msg.set_session_id(sessionId);
|
|
msg.mutable_response()->CopyFrom(item);
|
|
|
|
emit sigSendIslMessage(msg, serverId);
|
|
}
|
|
|
|
void Server::sendIsl_SessionEvent(const SessionEvent &item, int serverId, qint64 sessionId)
|
|
{
|
|
IslMessage msg;
|
|
msg.set_message_type(IslMessage::SESSION_EVENT);
|
|
if (sessionId != -1)
|
|
msg.set_session_id(sessionId);
|
|
msg.mutable_session_event()->CopyFrom(item);
|
|
|
|
emit sigSendIslMessage(msg, serverId);
|
|
}
|
|
|
|
void Server::sendIsl_GameEventContainer(const GameEventContainer &item, int serverId, qint64 sessionId)
|
|
{
|
|
IslMessage msg;
|
|
msg.set_message_type(IslMessage::GAME_EVENT_CONTAINER);
|
|
if (sessionId != -1)
|
|
msg.set_session_id(sessionId);
|
|
msg.mutable_game_event_container()->CopyFrom(item);
|
|
|
|
emit sigSendIslMessage(msg, serverId);
|
|
}
|
|
|
|
void Server::sendIsl_RoomEvent(const RoomEvent &item, int serverId, qint64 sessionId)
|
|
{
|
|
IslMessage msg;
|
|
msg.set_message_type(IslMessage::ROOM_EVENT);
|
|
if (sessionId != -1)
|
|
msg.set_session_id(sessionId);
|
|
msg.mutable_room_event()->CopyFrom(item);
|
|
|
|
emit sigSendIslMessage(msg, serverId);
|
|
}
|
|
|
|
void Server::sendIsl_GameCommand(const CommandContainer &item, int serverId, qint64 sessionId, int roomId, int playerId)
|
|
{
|
|
IslMessage msg;
|
|
msg.set_message_type(IslMessage::GAME_COMMAND_CONTAINER);
|
|
msg.set_session_id(sessionId);
|
|
msg.set_player_id(playerId);
|
|
|
|
CommandContainer *cont = msg.mutable_game_command();
|
|
cont->CopyFrom(item);
|
|
cont->set_room_id(roomId);
|
|
|
|
emit sigSendIslMessage(msg, serverId);
|
|
}
|
|
|
|
void Server::sendIsl_RoomCommand(const CommandContainer &item, int serverId, qint64 sessionId, int roomId)
|
|
{
|
|
IslMessage msg;
|
|
msg.set_message_type(IslMessage::ROOM_COMMAND_CONTAINER);
|
|
msg.set_session_id(sessionId);
|
|
|
|
CommandContainer *cont = msg.mutable_room_command();
|
|
cont->CopyFrom(item);
|
|
cont->set_room_id(roomId);
|
|
|
|
emit sigSendIslMessage(msg, serverId);
|
|
}
|