51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
+#include "chatmessage.h"
#include "server.h"
#include "log.h"
-
-#include "content_abm.h"
#include "content_sao.h"
#include "emerge.h"
-#include "main.h"
+#include "mapblock.h"
+#include "modchannels.h"
#include "nodedef.h"
-#include "player.h"
+#include "remoteplayer.h"
#include "rollback_interface.h"
-#include "scripting_game.h"
+#include "scripting_server.h"
#include "settings.h"
#include "tool.h"
#include "version.h"
+#include "network/connection.h"
#include "network/networkprotocol.h"
#include "network/serveropcodes.h"
+#include "util/auth.h"
#include "util/base64.h"
#include "util/pointedthing.h"
#include "util/serialize.h"
+#include "util/srp.h"
void Server::handleCommand_Deprecated(NetworkPacket* pkt)
{
// First byte after command is maximum supported
// serialization version
u8 client_max;
- u8 compression_modes;
+ u16 supp_compr_modes;
u16 min_net_proto_version = 0;
u16 max_net_proto_version;
+ std::string playerName;
- *pkt >> client_max >> compression_modes >> min_net_proto_version
- >> max_net_proto_version;
+ *pkt >> client_max >> supp_compr_modes >> min_net_proto_version
+ >> max_net_proto_version >> playerName;
u8 our_max = SER_FMT_VER_HIGHEST_READ;
// Use the highest version supported by both
- int deployed = std::min(client_max, our_max);
+ u8 depl_serial_v = std::min(client_max, our_max);
// If it's lower than the lowest supported, give up.
- if (deployed < SER_FMT_VER_LOWEST)
- deployed = SER_FMT_VER_INVALID;
+ if (depl_serial_v < SER_FMT_VER_LOWEST_READ)
+ depl_serial_v = SER_FMT_VER_INVALID;
- if (deployed == SER_FMT_VER_INVALID) {
+ if (depl_serial_v == SER_FMT_VER_INVALID) {
actionstream << "Server: A mismatched client tried to connect from "
<< addr_s << std::endl;
infostream<<"Server: Cannot negotiate serialization version with "
return;
}
- client->setPendingSerializationVersion(deployed);
+ client->setPendingSerializationVersion(depl_serial_v);
/*
Read and check network protocol version
client->net_proto_version = net_proto_version;
- // On this handler protocol version 25 is required
- if (net_proto_version < 25 ||
+ if ((g_settings->getBool("strict_protocol_version_checking") &&
+ net_proto_version != LATEST_PROTOCOL_VERSION) ||
net_proto_version < SERVER_PROTOCOL_VERSION_MIN ||
net_proto_version > SERVER_PROTOCOL_VERSION_MAX) {
actionstream << "Server: A mismatched client tried to connect from "
return;
}
- if (g_settings->getBool("strict_protocol_version_checking")) {
- if (net_proto_version != LATEST_PROTOCOL_VERSION) {
- actionstream << "Server: A mismatched (strict) client tried to "
- << "connect from " << addr_s << std::endl;
- DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_WRONG_VERSION);
- return;
- }
- }
-
- // @TODO: check if we support same modes, but not required now
-
- client->setSupportedCompressionModes(compression_modes);
-
- m_clients.event(pkt->getPeerId(), CSE_Init);
-}
-
-void Server::handleCommand_Auth(NetworkPacket* pkt)
-{
- std::string addr_s;
- try {
- Address address = getPeerAddress(pkt->getPeerId());
- addr_s = address.serializeString();
- }
- catch (con::PeerNotFoundException &e) {
- /*
- * no peer for this packet found
- * most common reason is peer timeout, e.g. peer didn't
- * respond for some time, your server was overloaded or
- * things like that.
- */
- infostream << "Server::ProcessData(): Canceling: peer "
- << pkt->getPeerId() << " not found" << std::endl;
- return;
- }
-
- std::string playerName, playerPassword;
-
- *pkt >> playerName >> playerPassword;
-
+ /*
+ Validate player name
+ */
const char* playername = playerName.c_str();
- if (playerName.size() > PLAYERNAME_SIZE) {
- actionstream << "Server: Player with an too long name "
- << "tried to connect from " << addr_s << std::endl;
+ size_t pns = playerName.size();
+ if (pns == 0 || pns > PLAYERNAME_SIZE) {
+ actionstream << "Server: Player with "
+ << ((pns > PLAYERNAME_SIZE) ? "a too long" : "an empty")
+ << " name tried to connect from " << addr_s << std::endl;
DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_WRONG_NAME);
return;
}
- if (string_allowed(playerName, PLAYERNAME_ALLOWED_CHARS) == false) {
+ if (!string_allowed(playerName, PLAYERNAME_ALLOWED_CHARS)) {
actionstream << "Server: Player with an invalid name "
<< "tried to connect from " << addr_s << std::endl;
DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_WRONG_CHARS_IN_NAME);
return;
}
+ m_clients.setPlayerName(pkt->getPeerId(), playername);
+ //TODO (later) case insensitivity
+
+ std::string legacyPlayerNameCasing = playerName;
+
if (!isSingleplayer() && strcasecmp(playername, "singleplayer") == 0) {
actionstream << "Server: Player with the name \"singleplayer\" "
<< "tried to connect from " << addr_s << std::endl;
{
std::string reason;
- if(m_script->on_prejoinplayer(playername, addr_s, reason)) {
+ if (m_script->on_prejoinplayer(playername, addr_s, &reason)) {
actionstream << "Server: Player with the name \"" << playerName << "\" "
<< "tried to connect from " << addr_s << " "
<< "but it was disallowed for the following reason: "
<< reason << std::endl;
- DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_CUSTOM_STRING,
- narrow_to_wide(reason.c_str()));
+ DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_CUSTOM_STRING, reason);
return;
}
}
- if (playerPassword.size() > PASSWORD_SIZE) {
- actionstream << "Server: Player with an too long password "
- << "tried to connect from " << addr_s << std::endl;
- DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_WRONG_PASSWORD);
- return;
- }
-
infostream << "Server: New connection: \"" << playerName << "\" from "
<< addr_s << " (peer_id=" << pkt->getPeerId() << ")" << std::endl;
- if(!base64_is_valid(playerPassword)){
- actionstream << "Server: " << playerName
- << " supplied invalid password hash" << std::endl;
- DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_WRONG_PASSWORD);
- return;
- }
-
// Enforce user limit.
- // Don't enforce for users that have some admin right
- if (m_clients.getClientIDs(CS_Created).size() >= g_settings->getU16("max_users") &&
- !checkPriv(playername, "server") &&
- !checkPriv(playername, "ban") &&
- !checkPriv(playername, "privs") &&
- !checkPriv(playername, "password") &&
- playername != g_settings->get("name")) {
- actionstream << "Server: " << playername << " tried to join, but there"
- << " are already max_users="
+ // Don't enforce for users that have some admin right or mod permits it.
+ if (m_clients.isUserLimitReached() &&
+ playername != g_settings->get("name") &&
+ !m_script->can_bypass_userlimit(playername, addr_s)) {
+ actionstream << "Server: " << playername << " tried to join from "
+ << addr_s << ", but there" << " are already max_users="
<< g_settings->getU16("max_users") << " players." << std::endl;
DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_TOO_MANY_USERS);
return;
}
- std::string checkpwd; // Password hash to check against
- bool has_auth = m_script->getAuth(playername, &checkpwd, NULL);
-
- // If no authentication info exists for user, create it
- if (!has_auth) {
- if (!isSingleplayer() &&
- g_settings->getBool("disallow_empty_password") &&
- playerPassword.empty()) {
- actionstream << "Server: " << playerName
- << " supplied empty password" << std::endl;
- DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_EMPTY_PASSWORD);
- return;
- }
- std::wstring raw_default_password =
- narrow_to_wide(g_settings->get("default_password"));
- std::string initial_password =
- translatePassword(playername, raw_default_password);
-
- // If default_password is empty, allow any initial password
- if (raw_default_password.length() == 0)
- initial_password = playerPassword.c_str();
-
- m_script->createAuth(playername, initial_password);
- }
-
- has_auth = m_script->getAuth(playername, &checkpwd, NULL);
-
- if(!has_auth) {
- actionstream << "Server: " << playerName << " cannot be authenticated"
- << " (auth handler does not work?)" << std::endl;
- DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_SERVER_FAIL);
- return;
- }
-
- if(playerPassword.c_str() != checkpwd) {
- actionstream << "Server: " << playerName << " supplied wrong password"
- << std::endl;
- DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_WRONG_PASSWORD);
- return;
- }
-
- RemotePlayer *player =
- static_cast<RemotePlayer*>(m_env->getPlayer(playername));
-
- if (player && player->peer_id != 0) {
- errorstream << "Server: " << playername << ": Failed to emerge player"
- << " (player allocated to an another client)" << std::endl;
- DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_ALREADY_CONNECTED);
- }
-
- m_clients.setPlayerName(pkt->getPeerId(), playername);
-
/*
- Answer with a TOCLIENT_INIT
+ Compose auth methods for answer
*/
-
- NetworkPacket resp_pkt(TOCLIENT_AUTH_ACCEPT, 1 + 6 + 8 + 4, pkt->getPeerId());
-
- resp_pkt << v3f(0,0,0) << (u64) m_env->getServerMap().getSeed()
- << g_settings->getFloat("dedicated_server_step");
-
- Send(&resp_pkt);
- m_clients.event(pkt->getPeerId(), CSE_Init);
-}
-
-void Server::handleCommand_Init_Legacy(NetworkPacket* pkt)
-{
- // [0] u8 SER_FMT_VER_HIGHEST_READ
- // [1] u8[20] player_name
- // [21] u8[28] password <--- can be sent without this, from old versions
-
- if (pkt->getSize() < 1+PLAYERNAME_SIZE)
- return;
-
- RemoteClient* client = getClient(pkt->getPeerId(), CS_Created);
-
- std::string addr_s;
- try {
- Address address = getPeerAddress(pkt->getPeerId());
- addr_s = address.serializeString();
- }
- catch (con::PeerNotFoundException &e) {
- /*
- * no peer for this packet found
- * most common reason is peer timeout, e.g. peer didn't
- * respond for some time, your server was overloaded or
- * things like that.
- */
- infostream << "Server::ProcessData(): Cancelling: peer "
- << pkt->getPeerId() << " not found" << std::endl;
- return;
- }
-
- // If net_proto_version is set, this client has already been handled
- if (client->getState() > CS_Created) {
- verbosestream << "Server: Ignoring multiple TOSERVER_INITs from "
- << addr_s << " (peer_id=" << pkt->getPeerId() << ")" << std::endl;
- return;
- }
-
- verbosestream << "Server: Got TOSERVER_INIT from " << addr_s << " (peer_id="
- << pkt->getPeerId() << ")" << std::endl;
-
- // Do not allow multiple players in simple singleplayer mode.
- // This isn't a perfect way to do it, but will suffice for now
- if (m_simple_singleplayer_mode && m_clients.getClientIDs().size() > 1) {
- infostream << "Server: Not allowing another client (" << addr_s
- << ") to connect in simple singleplayer mode" << std::endl;
- DenyAccess_Legacy(pkt->getPeerId(), L"Running in simple singleplayer mode.");
- return;
- }
-
- // First byte after command is maximum supported
- // serialization version
- u8 client_max;
-
- *pkt >> client_max;
-
- u8 our_max = SER_FMT_VER_HIGHEST_READ;
- // Use the highest version supported by both
- int deployed = std::min(client_max, our_max);
- // If it's lower than the lowest supported, give up.
- if (deployed < SER_FMT_VER_LOWEST)
- deployed = SER_FMT_VER_INVALID;
-
- if (deployed == SER_FMT_VER_INVALID) {
- actionstream << "Server: A mismatched client tried to connect from "
- << addr_s << std::endl;
- infostream<<"Server: Cannot negotiate serialization version with "
- << addr_s << std::endl;
- DenyAccess_Legacy(pkt->getPeerId(), std::wstring(
- L"Your client's version is not supported.\n"
- L"Server version is ")
- + narrow_to_wide(minetest_version_simple) + L"."
- );
- return;
- }
-
- client->setPendingSerializationVersion(deployed);
-
- /*
- Read and check network protocol version
- */
-
- u16 min_net_proto_version = 0;
- if (pkt->getSize() >= 1 + PLAYERNAME_SIZE + PASSWORD_SIZE + 2)
- min_net_proto_version = pkt->getU16(1 + PLAYERNAME_SIZE + PASSWORD_SIZE);
-
- // Use same version as minimum and maximum if maximum version field
- // doesn't exist (backwards compatibility)
- u16 max_net_proto_version = min_net_proto_version;
- if (pkt->getSize() >= 1 + PLAYERNAME_SIZE + PASSWORD_SIZE + 2 + 2)
- max_net_proto_version = pkt->getU16(1 + PLAYERNAME_SIZE + PASSWORD_SIZE + 2);
-
- // Start with client's maximum version
- u16 net_proto_version = max_net_proto_version;
-
- // Figure out a working version if it is possible at all
- if (max_net_proto_version >= SERVER_PROTOCOL_VERSION_MIN ||
- min_net_proto_version <= SERVER_PROTOCOL_VERSION_MAX) {
- // If maximum is larger than our maximum, go with our maximum
- if (max_net_proto_version > SERVER_PROTOCOL_VERSION_MAX)
- net_proto_version = SERVER_PROTOCOL_VERSION_MAX;
- // Else go with client's maximum
- else
- net_proto_version = max_net_proto_version;
- }
-
- verbosestream << "Server: " << addr_s << ": Protocol version: min: "
- << min_net_proto_version << ", max: " << max_net_proto_version
- << ", chosen: " << net_proto_version << std::endl;
-
- client->net_proto_version = net_proto_version;
-
- if (net_proto_version < SERVER_PROTOCOL_VERSION_MIN ||
- net_proto_version > SERVER_PROTOCOL_VERSION_MAX) {
- actionstream << "Server: A mismatched client tried to connect from "
- << addr_s << std::endl;
- DenyAccess_Legacy(pkt->getPeerId(), std::wstring(
- L"Your client's version is not supported.\n"
- L"Server version is ")
- + narrow_to_wide(minetest_version_simple) + L",\n"
- + L"server's PROTOCOL_VERSION is "
- + narrow_to_wide(itos(SERVER_PROTOCOL_VERSION_MIN))
- + L"..."
- + narrow_to_wide(itos(SERVER_PROTOCOL_VERSION_MAX))
- + L", client's PROTOCOL_VERSION is "
- + narrow_to_wide(itos(min_net_proto_version))
- + L"..."
- + narrow_to_wide(itos(max_net_proto_version))
- );
- return;
- }
-
- if (g_settings->getBool("strict_protocol_version_checking")) {
- if (net_proto_version != LATEST_PROTOCOL_VERSION) {
- actionstream << "Server: A mismatched (strict) client tried to "
- << "connect from " << addr_s << std::endl;
- DenyAccess_Legacy(pkt->getPeerId(), std::wstring(
- L"Your client's version is not supported.\n"
- L"Server version is ")
- + narrow_to_wide(minetest_version_simple) + L",\n"
- + L"server's PROTOCOL_VERSION (strict) is "
- + narrow_to_wide(itos(LATEST_PROTOCOL_VERSION))
- + L", client's PROTOCOL_VERSION is "
- + narrow_to_wide(itos(min_net_proto_version))
- + L"..."
- + narrow_to_wide(itos(max_net_proto_version))
- );
+ std::string encpwd; // encrypted Password field for the user
+ bool has_auth = m_script->getAuth(playername, &encpwd, NULL);
+ u32 auth_mechs = 0;
+
+ client->chosen_mech = AUTH_MECHANISM_NONE;
+
+ if (has_auth) {
+ std::vector<std::string> pwd_components = str_split(encpwd, '#');
+ if (pwd_components.size() == 4) {
+ if (pwd_components[1] == "1") { // 1 means srp
+ auth_mechs |= AUTH_MECHANISM_SRP;
+ client->enc_pwd = encpwd;
+ } else {
+ actionstream << "User " << playername
+ << " tried to log in, but password field"
+ << " was invalid (unknown mechcode)." << std::endl;
+ DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_SERVER_FAIL);
+ return;
+ }
+ } else if (base64_is_valid(encpwd)) {
+ auth_mechs |= AUTH_MECHANISM_LEGACY_PASSWORD;
+ client->enc_pwd = encpwd;
+ } else {
+ actionstream << "User " << playername
+ << " tried to log in, but password field"
+ << " was invalid (invalid base64)." << std::endl;
+ DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_SERVER_FAIL);
return;
}
+ } else {
+ std::string default_password = g_settings->get("default_password");
+ if (default_password.length() == 0) {
+ auth_mechs |= AUTH_MECHANISM_FIRST_SRP;
+ } else {
+ // Take care of default passwords.
+ client->enc_pwd = get_encoded_srp_verifier(playerName, default_password);
+ auth_mechs |= AUTH_MECHANISM_SRP;
+ // Allocate player in db, but only on successful login.
+ client->create_player_on_auth_success = true;
+ }
}
/*
- Set up player
+ Answer with a TOCLIENT_HELLO
*/
- char playername[PLAYERNAME_SIZE];
- unsigned int playername_length = 0;
- for (; playername_length < PLAYERNAME_SIZE; playername_length++ ) {
- playername[playername_length] = pkt->getChar(1+playername_length);
- if (pkt->getChar(1+playername_length) == 0)
- break;
- }
-
- if (playername_length == PLAYERNAME_SIZE) {
- actionstream << "Server: Player with name exceeding max length "
- << "tried to connect from " << addr_s << std::endl;
- DenyAccess_Legacy(pkt->getPeerId(), L"Name too long");
- return;
- }
-
-
- if (playername[0]=='\0') {
- actionstream << "Server: Player with an empty name "
- << "tried to connect from " << addr_s << std::endl;
- DenyAccess_Legacy(pkt->getPeerId(), L"Empty name");
- return;
- }
-
- if (string_allowed(playername, PLAYERNAME_ALLOWED_CHARS) == false) {
- actionstream << "Server: Player with an invalid name "
- << "tried to connect from " << addr_s << std::endl;
- DenyAccess_Legacy(pkt->getPeerId(), L"Name contains unallowed characters");
- return;
- }
-
- if (!isSingleplayer() && strcasecmp(playername, "singleplayer") == 0) {
- actionstream << "Server: Player with the name \"singleplayer\" "
- << "tried to connect from " << addr_s << std::endl;
- DenyAccess_Legacy(pkt->getPeerId(), L"Name is not allowed");
- return;
- }
-
- {
- std::string reason;
- if (m_script->on_prejoinplayer(playername, addr_s, reason)) {
- actionstream << "Server: Player with the name \"" << playername << "\" "
- << "tried to connect from " << addr_s << " "
- << "but it was disallowed for the following reason: "
- << reason << std::endl;
- DenyAccess_Legacy(pkt->getPeerId(), narrow_to_wide(reason.c_str()));
- return;
- }
- }
-
- infostream<<"Server: New connection: \""<<playername<<"\" from "
- <<addr_s<<" (peer_id="<<pkt->getPeerId()<<")"<<std::endl;
-
- // Get password
- char given_password[PASSWORD_SIZE];
- if (pkt->getSize() < 1 + PLAYERNAME_SIZE + PASSWORD_SIZE) {
- // old version - assume blank password
- given_password[0] = 0;
- }
- else {
- for (u16 i = 0; i < PASSWORD_SIZE - 1; i++) {
- given_password[i] = pkt->getChar(21 + i);
- }
- given_password[PASSWORD_SIZE - 1] = 0;
- }
-
- if (!base64_is_valid(given_password)) {
- actionstream << "Server: " << playername
- << " supplied invalid password hash" << std::endl;
- DenyAccess_Legacy(pkt->getPeerId(), L"Invalid password hash");
- return;
- }
-
- // Enforce user limit.
- // Don't enforce for users that have some admin right
- if (m_clients.getClientIDs(CS_Created).size() >= g_settings->getU16("max_users") &&
- !checkPriv(playername, "server") &&
- !checkPriv(playername, "ban") &&
- !checkPriv(playername, "privs") &&
- !checkPriv(playername, "password") &&
- playername != g_settings->get("name")) {
- actionstream << "Server: " << playername << " tried to join, but there"
- << " are already max_users="
- << g_settings->getU16("max_users") << " players." << std::endl;
- DenyAccess_Legacy(pkt->getPeerId(), L"Too many users.");
- return;
- }
-
- std::string checkpwd; // Password hash to check against
- bool has_auth = m_script->getAuth(playername, &checkpwd, NULL);
-
- // If no authentication info exists for user, create it
- if (!has_auth) {
- if (!isSingleplayer() &&
- g_settings->getBool("disallow_empty_password") &&
- std::string(given_password) == "") {
- actionstream << "Server: " << playername
- << " supplied empty password" << std::endl;
- DenyAccess_Legacy(pkt->getPeerId(), L"Empty passwords are "
- L"disallowed. Set a password and try again.");
- return;
- }
- std::wstring raw_default_password =
- narrow_to_wide(g_settings->get("default_password"));
- std::string initial_password =
- translatePassword(playername, raw_default_password);
-
- // If default_password is empty, allow any initial password
- if (raw_default_password.length() == 0)
- initial_password = given_password;
-
- m_script->createAuth(playername, initial_password);
- }
- has_auth = m_script->getAuth(playername, &checkpwd, NULL);
+ verbosestream << "Sending TOCLIENT_HELLO with auth method field: "
+ << auth_mechs << std::endl;
- if (!has_auth) {
- actionstream << "Server: " << playername << " cannot be authenticated"
- << " (auth handler does not work?)" << std::endl;
- DenyAccess_Legacy(pkt->getPeerId(), L"Not allowed to login");
- return;
- }
-
- if (given_password != checkpwd) {
- actionstream << "Server: " << playername << " supplied wrong password"
- << std::endl;
- DenyAccess_Legacy(pkt->getPeerId(), L"Wrong password");
- return;
- }
-
- RemotePlayer *player =
- static_cast<RemotePlayer*>(m_env->getPlayer(playername));
-
- if (player && player->peer_id != 0) {
- errorstream << "Server: " << playername << ": Failed to emerge player"
- << " (player allocated to an another client)" << std::endl;
- DenyAccess_Legacy(pkt->getPeerId(), L"Another client is connected with this "
- L"name. If your client closed unexpectedly, try again in "
- L"a minute.");
- }
+ NetworkPacket resp_pkt(TOCLIENT_HELLO, 1 + 4
+ + legacyPlayerNameCasing.size(), pkt->getPeerId());
- m_clients.setPlayerName(pkt->getPeerId(), playername);
+ u16 depl_compress_mode = NETPROTO_COMPRESSION_NONE;
+ resp_pkt << depl_serial_v << depl_compress_mode << net_proto_version
+ << auth_mechs << legacyPlayerNameCasing;
- /*
- Answer with a TOCLIENT_INIT
- */
-
- NetworkPacket resp_pkt(TOCLIENT_INIT_LEGACY, 1 + 6 + 8 + 4,
- pkt->getPeerId());
+ Send(&resp_pkt);
- resp_pkt << (u8) deployed << (v3s16) floatToInt(v3f(0,0,0), BS)
- << (u64) m_env->getServerMap().getSeed()
- << g_settings->getFloat("dedicated_server_step");
+ client->allowed_auth_mechs = auth_mechs;
+ client->setDeployedCompressionMode(depl_compress_mode);
- Send(&resp_pkt);
- m_clients.event(pkt->getPeerId(), CSE_Init);
+ m_clients.event(pkt->getPeerId(), CSE_Hello);
}
void Server::handleCommand_Init2(NetworkPacket* pkt)
m_clients.event(pkt->getPeerId(), CSE_GotInit2);
u16 protocol_version = m_clients.getProtocolVersion(pkt->getPeerId());
-
- ///// begin compatibility code
- PlayerSAO* playersao = NULL;
- if (protocol_version <= 22) {
- playersao = StageTwoClientInit(pkt->getPeerId());
-
- if (playersao == NULL) {
- errorstream
- << "TOSERVER_INIT2 stage 2 client init failed for peer "
- << pkt->getPeerId() << std::endl;
- return;
- }
- }
- ///// end compatibility code
+ std::string lang;
+ if (pkt->getSize() > 0)
+ *pkt >> lang;
/*
Send some initialization data
m_clients.event(pkt->getPeerId(), CSE_SetDefinitionsSent);
// Send media announcement
- sendMediaAnnouncement(pkt->getPeerId());
+ sendMediaAnnouncement(pkt->getPeerId(), lang);
// Send detached inventories
sendDetachedInventories(pkt->getPeerId());
float time_speed = g_settings->getFloat("time_speed");
SendTimeOfDay(pkt->getPeerId(), time, time_speed);
- ///// begin compatibility code
- if (protocol_version <= 22) {
- m_clients.event(pkt->getPeerId(), CSE_SetClientReady);
- m_script->on_joinplayer(playersao);
- }
- ///// end compatibility code
+ SendCSMRestrictionFlags(pkt->getPeerId());
// Warnings about protocol version can be issued here
if (getClient(pkt->getPeerId())->net_proto_version < LATEST_PROTOCOL_VERSION) {
- SendChatMessage(pkt->getPeerId(), L"# Server: WARNING: YOUR CLIENT'S "
- L"VERSION MAY NOT BE FULLY COMPATIBLE WITH THIS SERVER!");
+ SendChatMessage(pkt->getPeerId(), ChatMessage(CHATMESSAGE_TYPE_SYSTEM,
+ L"# Server: WARNING: YOUR CLIENT'S VERSION MAY NOT BE FULLY COMPATIBLE "
+ L"WITH THIS SERVER!"));
+
}
}
sendRequestedMedia(pkt->getPeerId(), tosend);
}
-void Server::handleCommand_ReceivedMedia(NetworkPacket* pkt)
-{
-}
-
void Server::handleCommand_ClientReady(NetworkPacket* pkt)
{
- u16 peer_id = pkt->getPeerId();
- u16 peer_proto_ver = getClient(peer_id, CS_InitDone)->net_proto_version;
-
- // clients <= protocol version 22 did not send ready message,
- // they're already initialized
- if (peer_proto_ver <= 22) {
- infostream << "Client sent message not expected by a "
- << "client using protocol version <= 22,"
- << "disconnecing peer_id: " << peer_id << std::endl;
- m_con.DisconnectPeer(peer_id);
- return;
- }
+ session_t peer_id = pkt->getPeerId();
PlayerSAO* playersao = StageTwoClientInit(peer_id);
if (playersao == NULL) {
- errorstream
+ actionstream
<< "TOSERVER_CLIENT_READY stage 2 client init failed for peer_id: "
<< peer_id << std::endl;
- m_con.DisconnectPeer(peer_id);
+ DisconnectPeer(peer_id);
return;
}
errorstream
<< "TOSERVER_CLIENT_READY client sent inconsistent data, disconnecting peer_id: "
<< peer_id << std::endl;
- m_con.DisconnectPeer(peer_id);
+ DisconnectPeer(peer_id);
return;
}
- u8 major_ver, minor_ver, patch_ver;
- *pkt >> major_ver >> minor_ver >> patch_ver;
+ u8 major_ver, minor_ver, patch_ver, reserved;
+ std::string full_ver;
+ *pkt >> major_ver >> minor_ver >> patch_ver >> reserved >> full_ver;
m_clients.setClientVersion(
peer_id, major_ver, minor_ver, patch_ver,
- std::string(pkt->getString(6),(u16) pkt->getU8(4)));
+ full_ver);
+
+ const std::vector<std::string> &players = m_clients.getPlayerNames();
+ NetworkPacket list_pkt(TOCLIENT_UPDATE_PLAYER_LIST, 0, peer_id);
+ list_pkt << (u8) PLAYER_LIST_INIT << (u16) players.size();
+ for (const std::string &player: players) {
+ list_pkt << player;
+ }
+ m_clients.send(peer_id, 0, &list_pkt, true);
+
+ NetworkPacket notice_pkt(TOCLIENT_UPDATE_PLAYER_LIST, 0, PEER_ID_INEXISTENT);
+ // (u16) 1 + std::string represents a pseudo vector serialization representation
+ notice_pkt << (u8) PLAYER_LIST_ADD << (u16) 1 << std::string(playersao->getPlayer()->getName());
+ m_clients.sendToAll(¬ice_pkt);
m_clients.event(peer_id, CSE_SetClientReady);
m_script->on_joinplayer(playersao);
+ // Send shutdown timer if shutdown has been scheduled
+ if (m_shutdown_state.isTimerRunning()) {
+ SendChatMessage(pkt->getPeerId(), m_shutdown_state.getShutdownTimerMessage());
+ }
}
void Server::handleCommand_GotBlocks(NetworkPacket* pkt)
RemoteClient *client = getClient(pkt->getPeerId());
- for (u16 i = 0; i < count; i++) {
- if ((s16)pkt->getSize() < 1 + (i + 1) * 6)
- throw con::InvalidIncomingDataException
+ if ((s16)pkt->getSize() < 1 + (int)count * 6) {
+ throw con::InvalidIncomingDataException
("GOTBLOCKS length is too short");
- v3s16 p;
+ }
+ for (u16 i = 0; i < count; i++) {
+ v3s16 p;
*pkt >> p;
-
client->GotBlock(p);
}
}
-void Server::handleCommand_PlayerPos(NetworkPacket* pkt)
+void Server::process_PlayerPos(RemotePlayer *player, PlayerSAO *playersao,
+ NetworkPacket *pkt)
{
- if (pkt->getSize() < 12 + 12 + 4 + 4)
+ if (pkt->getRemainingBytes() < 12 + 12 + 4 + 4 + 4 + 1 + 1)
return;
v3s32 ps, ss;
s32 f32pitch, f32yaw;
+ u8 f32fov;
*pkt >> ps;
*pkt >> ss;
*pkt >> f32pitch;
*pkt >> f32yaw;
- f32 pitch = (f32)f32pitch / 100.0;
- f32 yaw = (f32)f32yaw / 100.0;
+ f32 pitch = (f32)f32pitch / 100.0f;
+ f32 yaw = (f32)f32yaw / 100.0f;
u32 keyPressed = 0;
- if (pkt->getSize() >= 12 + 12 + 4 + 4 + 4)
- *pkt >> keyPressed;
-
- v3f position((f32)ps.X / 100.0, (f32)ps.Y / 100.0, (f32)ps.Z / 100.0);
- v3f speed((f32)ss.X / 100.0, (f32)ss.Y / 100.0, (f32)ss.Z / 100.0);
+ // default behavior (in case an old client doesn't send these)
+ f32 fov = 0;
+ u8 wanted_range = 0;
- pitch = modulo360f(pitch);
- yaw = modulo360f(yaw);
+ *pkt >> keyPressed;
+ *pkt >> f32fov;
+ fov = (f32)f32fov / 80.0f;
+ *pkt >> wanted_range;
- Player *player = m_env->getPlayer(pkt->getPeerId());
- if (player == NULL) {
- errorstream << "Server::ProcessData(): Cancelling: "
- "No player for peer_id=" << pkt->getPeerId()
- << " disconnecting peer!" << std::endl;
- m_con.DisconnectPeer(pkt->getPeerId());
- return;
- }
+ v3f position((f32)ps.X / 100.0f, (f32)ps.Y / 100.0f, (f32)ps.Z / 100.0f);
+ v3f speed((f32)ss.X / 100.0f, (f32)ss.Y / 100.0f, (f32)ss.Z / 100.0f);
- // If player is dead we don't care of this packet
- if (player->isDead()) {
- verbosestream << "TOSERVER_PLAYERPOS: " << player->getName()
- << " is dead. Ignoring packet";
- return;
- }
-
- PlayerSAO *playersao = player->getPlayerSAO();
- if (playersao == NULL) {
- errorstream << "Server::ProcessData(): Cancelling: "
- "No player object for peer_id=" << pkt->getPeerId()
- << " disconnecting peer!" << std::endl;
- m_con.DisconnectPeer(pkt->getPeerId());
- return;
- }
+ pitch = modulo360f(pitch);
+ yaw = wrapDegrees_0_360(yaw);
- player->setPosition(position);
+ playersao->setBasePosition(position);
player->setSpeed(speed);
- player->setPitch(pitch);
- player->setYaw(yaw);
+ playersao->setLookPitch(pitch);
+ playersao->setPlayerYaw(yaw);
+ playersao->setFov(fov);
+ playersao->setWantedRange(wanted_range);
player->keyPressed = keyPressed;
player->control.up = (keyPressed & 1);
player->control.down = (keyPressed & 2);
}
}
+void Server::handleCommand_PlayerPos(NetworkPacket* pkt)
+{
+ RemotePlayer *player = m_env->getPlayer(pkt->getPeerId());
+ if (player == NULL) {
+ errorstream << "Server::ProcessData(): Canceling: "
+ "No player for peer_id=" << pkt->getPeerId()
+ << " disconnecting peer!" << std::endl;
+ DisconnectPeer(pkt->getPeerId());
+ return;
+ }
+
+ PlayerSAO *playersao = player->getPlayerSAO();
+ if (playersao == NULL) {
+ errorstream << "Server::ProcessData(): Canceling: "
+ "No player object for peer_id=" << pkt->getPeerId()
+ << " disconnecting peer!" << std::endl;
+ DisconnectPeer(pkt->getPeerId());
+ return;
+ }
+
+ // If player is dead we don't care of this packet
+ if (playersao->isDead()) {
+ verbosestream << "TOSERVER_PLAYERPOS: " << player->getName()
+ << " is dead. Ignoring packet";
+ return;
+ }
+
+ process_PlayerPos(player, playersao, pkt);
+}
+
void Server::handleCommand_DeletedBlocks(NetworkPacket* pkt)
{
if (pkt->getSize() < 1)
RemoteClient *client = getClient(pkt->getPeerId());
- for (u16 i = 0; i < count; i++) {
- if ((s16)pkt->getSize() < 1 + (i + 1) * 6)
- throw con::InvalidIncomingDataException
+ if ((s16)pkt->getSize() < 1 + (int)count * 6) {
+ throw con::InvalidIncomingDataException
("DELETEDBLOCKS length is too short");
+ }
+
+ for (u16 i = 0; i < count; i++) {
v3s16 p;
*pkt >> p;
-
client->SetBlockNotSent(p);
}
}
void Server::handleCommand_InventoryAction(NetworkPacket* pkt)
{
- Player *player = m_env->getPlayer(pkt->getPeerId());
+ RemotePlayer *player = m_env->getPlayer(pkt->getPeerId());
+
if (player == NULL) {
- errorstream << "Server::ProcessData(): Cancelling: "
+ errorstream << "Server::ProcessData(): Canceling: "
"No player for peer_id=" << pkt->getPeerId()
<< " disconnecting peer!" << std::endl;
- m_con.DisconnectPeer(pkt->getPeerId());
+ DisconnectPeer(pkt->getPeerId());
return;
}
PlayerSAO *playersao = player->getPlayerSAO();
if (playersao == NULL) {
- errorstream << "Server::ProcessData(): Cancelling: "
+ errorstream << "Server::ProcessData(): Canceling: "
"No player object for peer_id=" << pkt->getPeerId()
<< " disconnecting peer!" << std::endl;
- m_con.DisconnectPeer(pkt->getPeerId());
+ DisconnectPeer(pkt->getPeerId());
return;
}
std::istringstream is(datastring, std::ios_base::binary);
// Create an action
InventoryAction *a = InventoryAction::deSerialize(is);
- if (a == NULL) {
+ if (!a) {
infostream << "TOSERVER_INVENTORY_ACTION: "
<< "InventoryAction::deSerialize() returned NULL"
<< std::endl;
/*
Handle restrictions and special cases of the move action
*/
- if (a->getType() == IACTION_MOVE) {
+ if (a->getType() == IAction::Move) {
IMoveAction *ma = (IMoveAction*)a;
ma->from_inv.applyCurrentPlayer(player->getName());
ma->to_inv.applyCurrentPlayer(player->getName());
- setInventoryModified(ma->from_inv);
- setInventoryModified(ma->to_inv);
+ setInventoryModified(ma->from_inv, false);
+ if (ma->from_inv != ma->to_inv) {
+ setInventoryModified(ma->to_inv, false);
+ }
bool from_inv_is_current_player =
(ma->from_inv.type == InventoryLocation::PLAYER) &&
(ma->to_inv.type == InventoryLocation::PLAYER) &&
(ma->to_inv.name == player->getName());
+ InventoryLocation *remote = from_inv_is_current_player ?
+ &ma->to_inv : &ma->from_inv;
+
+ // Check for out-of-range interaction
+ if (remote->type == InventoryLocation::NODEMETA) {
+ v3f node_pos = intToFloat(remote->p, BS);
+ v3f player_pos = player->getPlayerSAO()->getEyePosition();
+ f32 d = player_pos.getDistanceFrom(node_pos);
+ if (!checkInteractDistance(player, d, "inventory"))
+ return;
+ }
+
/*
Disable moving items out of craftpreview
*/
/*
Handle restrictions and special cases of the drop action
*/
- else if (a->getType() == IACTION_DROP) {
+ else if (a->getType() == IAction::Drop) {
IDropAction *da = (IDropAction*)a;
da->from_inv.applyCurrentPlayer(player->getName());
- setInventoryModified(da->from_inv);
+ setInventoryModified(da->from_inv, false);
/*
Disable dropping items out of craftpreview
delete a;
return;
}
+
+ // Disallow dropping items if dead
+ if (playersao->isDead()) {
+ infostream << "Ignoring IDropAction from "
+ << (da->from_inv.dump()) << ":" << da->from_list
+ << " because player is dead." << std::endl;
+ delete a;
+ return;
+ }
}
/*
Handle restrictions and special cases of the craft action
*/
- else if (a->getType() == IACTION_CRAFT) {
+ else if (a->getType() == IAction::Craft) {
ICraftAction *ca = (ICraftAction*)a;
ca->craft_inv.applyCurrentPlayer(player->getName());
- setInventoryModified(ca->craft_inv);
+ setInventoryModified(ca->craft_inv, false);
//bool craft_inv_is_current_player =
// (ca->craft_inv.type == InventoryLocation::PLAYER) &&
a->apply(this, playersao, this);
// Eat the action
delete a;
+
+ SendInventory(playersao);
}
void Server::handleCommand_ChatMessage(NetworkPacket* pkt)
message += (wchar_t)tmp_wchar;
}
- Player *player = m_env->getPlayer(pkt->getPeerId());
- if (player == NULL) {
- errorstream << "Server::ProcessData(): Cancelling: "
- "No player for peer_id=" << pkt->getPeerId()
- << " disconnecting peer!" << std::endl;
- m_con.DisconnectPeer(pkt->getPeerId());
- return;
- }
-
- // If something goes wrong, this player is to blame
- RollbackScopeActor rollback_scope(m_rollback,
- std::string("player:")+player->getName());
-
- // Get player name of this client
- std::wstring name = narrow_to_wide(player->getName());
-
- // Run script hook
- bool ate = m_script->on_chat_message(player->getName(),
- wide_to_narrow(message));
- // If script ate the message, don't proceed
- if (ate)
- return;
-
- // Line to send to players
- std::wstring line;
- // Whether to send to the player that sent the line
- bool send_to_sender_only = false;
-
- // Commands are implemented in Lua, so only catch invalid
- // commands that were not "eaten" and send an error back
- if (message[0] == L'/') {
- message = message.substr(1);
- send_to_sender_only = true;
- if (message.length() == 0)
- line += L"-!- Empty command";
- else
- line += L"-!- Invalid command: " + str_split(message, L' ')[0];
- }
- else {
- if (checkPriv(player->getName(), "shout")) {
- line += L"<";
- line += name;
- line += L"> ";
- line += message;
- } else {
- line += L"-!- You don't have permission to shout.";
- send_to_sender_only = true;
- }
- }
-
- if (line != L"")
- {
- /*
- Send the message to sender
- */
- if (send_to_sender_only) {
- SendChatMessage(pkt->getPeerId(), line);
- }
- /*
- Send the message to others
- */
- else {
- actionstream << "CHAT: " << wide_to_narrow(line)<<std::endl;
-
- std::vector<u16> clients = m_clients.getClientIDs();
-
- for (std::vector<u16>::iterator i = clients.begin();
- i != clients.end(); ++i) {
- if (*i != pkt->getPeerId())
- SendChatMessage(*i, line);
- }
- }
- }
-}
-
-void Server::handleCommand_Damage(NetworkPacket* pkt)
-{
- u8 damage;
-
- *pkt >> damage;
-
- Player *player = m_env->getPlayer(pkt->getPeerId());
- if (player == NULL) {
- errorstream << "Server::ProcessData(): Cancelling: "
- "No player for peer_id=" << pkt->getPeerId()
- << " disconnecting peer!" << std::endl;
- m_con.DisconnectPeer(pkt->getPeerId());
- return;
- }
-
- PlayerSAO *playersao = player->getPlayerSAO();
- if (playersao == NULL) {
- errorstream << "Server::ProcessData(): Cancelling: "
- "No player object for peer_id=" << pkt->getPeerId()
+ RemotePlayer *player = m_env->getPlayer(pkt->getPeerId());
+ if (player == NULL) {
+ errorstream << "Server::ProcessData(): Canceling: "
+ "No player for peer_id=" << pkt->getPeerId()
<< " disconnecting peer!" << std::endl;
- m_con.DisconnectPeer(pkt->getPeerId());
+ DisconnectPeer(pkt->getPeerId());
return;
}
- if (g_settings->getBool("enable_damage")) {
- actionstream << player->getName() << " damaged by "
- << (int)damage << " hp at " << PP(player->getPosition() / BS)
- << std::endl;
+ // Get player name of this client
+ std::string name = player->getName();
+ std::wstring wname = narrow_to_wide(name);
- playersao->setHP(playersao->getHP() - damage);
- SendPlayerHPOrDie(playersao->getPeerID(), playersao->getHP() == 0);
+ std::wstring answer_to_sender = handleChat(name, wname, message, true, player);
+ if (!answer_to_sender.empty()) {
+ // Send the answer to sender
+ SendChatMessage(pkt->getPeerId(), ChatMessage(CHATMESSAGE_TYPE_NORMAL,
+ answer_to_sender, wname));
}
}
-void Server::handleCommand_Breath(NetworkPacket* pkt)
+void Server::handleCommand_Damage(NetworkPacket* pkt)
{
- u16 breath;
+ u16 damage;
+
+ *pkt >> damage;
- *pkt >> breath;
+ RemotePlayer *player = m_env->getPlayer(pkt->getPeerId());
- Player *player = m_env->getPlayer(pkt->getPeerId());
if (player == NULL) {
- errorstream << "Server::ProcessData(): Cancelling: "
+ errorstream << "Server::ProcessData(): Canceling: "
"No player for peer_id=" << pkt->getPeerId()
<< " disconnecting peer!" << std::endl;
- m_con.DisconnectPeer(pkt->getPeerId());
- return;
- }
-
- /*
- * If player is dead, we don't need to update the breath
- * He is dead !
- */
- if (player->isDead()) {
- verbosestream << "TOSERVER_BREATH: " << player->getName()
- << " is dead. Ignoring packet";
+ DisconnectPeer(pkt->getPeerId());
return;
}
-
PlayerSAO *playersao = player->getPlayerSAO();
if (playersao == NULL) {
- errorstream << "Server::ProcessData(): Cancelling: "
+ errorstream << "Server::ProcessData(): Canceling: "
"No player object for peer_id=" << pkt->getPeerId()
<< " disconnecting peer!" << std::endl;
- m_con.DisconnectPeer(pkt->getPeerId());
+ DisconnectPeer(pkt->getPeerId());
return;
}
- playersao->setBreath(breath);
- SendPlayerBreath(pkt->getPeerId());
+ if (!playersao->isImmortal()) {
+ if (playersao->isDead()) {
+ verbosestream << "Server::ProcessData(): Info: "
+ "Ignoring damage as player " << player->getName()
+ << " is already dead." << std::endl;
+ return;
+ }
+
+ actionstream << player->getName() << " damaged by "
+ << (int)damage << " hp at " << PP(playersao->getBasePosition() / BS)
+ << std::endl;
+
+ PlayerHPChangeReason reason(PlayerHPChangeReason::FALL);
+ playersao->setHP((s32)playersao->getHP() - (s32)damage, reason);
+ SendPlayerHPOrDie(playersao, reason);
+ }
}
void Server::handleCommand_Password(NetworkPacket* pkt)
{
- errorstream << "PAssword packet size: " << pkt->getSize() << " size required: " << PASSWORD_SIZE * 2 << std::endl;
- if ((pkt->getCommand() == TOSERVER_PASSWORD && pkt->getSize() < 4) ||
- pkt->getSize() != PASSWORD_SIZE * 2)
+ if (pkt->getSize() != PASSWORD_SIZE * 2)
return;
std::string oldpwd;
std::string newpwd;
- if (pkt->getCommand() == TOSERVER_PASSWORD) {
- *pkt >> oldpwd >> newpwd;
+ // Deny for clients using the new protocol
+ RemoteClient* client = getClient(pkt->getPeerId(), CS_Created);
+ if (client->net_proto_version >= 25) {
+ infostream << "Server::handleCommand_Password(): Denying change: "
+ << " Client protocol version for peer_id=" << pkt->getPeerId()
+ << " too new!" << std::endl;
+ return;
+ }
+
+ for (u16 i = 0; i < PASSWORD_SIZE - 1; i++) {
+ char c = pkt->getChar(i);
+ if (c == 0)
+ break;
+ oldpwd += c;
}
- // 13/03/15
- // Protocol v24 compat. Please remove in 1 year after
- // client convergence to 0.4.13/0.5.x
- else {
- for (u16 i = 0; i < PASSWORD_SIZE - 1; i++) {
- char c = pkt->getChar(i);
- if (c == 0)
- break;
- oldpwd += c;
- }
- for (u16 i = 0; i < PASSWORD_SIZE - 1; i++) {
- char c = pkt->getChar(PASSWORD_SIZE + i);
- if (c == 0)
- break;
- newpwd += c;
- }
+ for (u16 i = 0; i < PASSWORD_SIZE - 1; i++) {
+ char c = pkt->getChar(PASSWORD_SIZE + i);
+ if (c == 0)
+ break;
+ newpwd += c;
}
- Player *player = m_env->getPlayer(pkt->getPeerId());
+ RemotePlayer *player = m_env->getPlayer(pkt->getPeerId());
if (player == NULL) {
- errorstream << "Server::ProcessData(): Cancelling: "
+ errorstream << "Server::ProcessData(): Canceling: "
"No player for peer_id=" << pkt->getPeerId()
<< " disconnecting peer!" << std::endl;
- m_con.DisconnectPeer(pkt->getPeerId());
+ DisconnectPeer(pkt->getPeerId());
return;
}
infostream<<"Server: " << player->getName() <<
" supplied invalid password hash" << std::endl;
// Wrong old password supplied!!
- SendChatMessage(pkt->getPeerId(), L"Invalid new password hash supplied. Password NOT changed.");
+ SendChatMessage(pkt->getPeerId(), ChatMessage(CHATMESSAGE_TYPE_SYSTEM,
+ L"Invalid new password hash supplied. Password NOT changed."));
return;
}
if (oldpwd != checkpwd) {
infostream << "Server: invalid old password" << std::endl;
// Wrong old password supplied!!
- SendChatMessage(pkt->getPeerId(), L"Invalid old password supplied. Password NOT changed.");
+ SendChatMessage(pkt->getPeerId(), ChatMessage(CHATMESSAGE_TYPE_SYSTEM,
+ L"Invalid old password supplied. Password NOT changed."));
return;
}
bool success = m_script->setPassword(playername, newpwd);
if (success) {
actionstream << player->getName() << " changes password" << std::endl;
- SendChatMessage(pkt->getPeerId(), L"Password change successful.");
+ SendChatMessage(pkt->getPeerId(), ChatMessage(CHATMESSAGE_TYPE_SYSTEM,
+ L"Password change successful."));
} else {
actionstream << player->getName() << " tries to change password but "
<< "it fails" << std::endl;
- SendChatMessage(pkt->getPeerId(), L"Password change failed or inavailable.");
+ SendChatMessage(pkt->getPeerId(), ChatMessage(CHATMESSAGE_TYPE_SYSTEM,
+ L"Password change failed or unavailable."));
}
}
if (pkt->getSize() < 2)
return;
- Player *player = m_env->getPlayer(pkt->getPeerId());
+ RemotePlayer *player = m_env->getPlayer(pkt->getPeerId());
+
if (player == NULL) {
- errorstream << "Server::ProcessData(): Cancelling: "
+ errorstream << "Server::ProcessData(): Canceling: "
"No player for peer_id=" << pkt->getPeerId()
<< " disconnecting peer!" << std::endl;
- m_con.DisconnectPeer(pkt->getPeerId());
+ DisconnectPeer(pkt->getPeerId());
return;
}
PlayerSAO *playersao = player->getPlayerSAO();
if (playersao == NULL) {
- errorstream << "Server::ProcessData(): Cancelling: "
+ errorstream << "Server::ProcessData(): Canceling: "
"No player object for peer_id=" << pkt->getPeerId()
<< " disconnecting peer!" << std::endl;
- m_con.DisconnectPeer(pkt->getPeerId());
+ DisconnectPeer(pkt->getPeerId());
return;
}
void Server::handleCommand_Respawn(NetworkPacket* pkt)
{
- Player *player = m_env->getPlayer(pkt->getPeerId());
+ RemotePlayer *player = m_env->getPlayer(pkt->getPeerId());
if (player == NULL) {
- errorstream << "Server::ProcessData(): Cancelling: "
+ errorstream << "Server::ProcessData(): Canceling: "
"No player for peer_id=" << pkt->getPeerId()
<< " disconnecting peer!" << std::endl;
- m_con.DisconnectPeer(pkt->getPeerId());
+ DisconnectPeer(pkt->getPeerId());
return;
}
- if (!player->isDead())
+ PlayerSAO *playersao = player->getPlayerSAO();
+ assert(playersao);
+
+ if (!playersao->isDead())
return;
RespawnPlayer(pkt->getPeerId());
actionstream << player->getName() << " respawns at "
- << PP(player->getPosition()/BS) << std::endl;
+ << PP(playersao->getBasePosition() / BS) << std::endl;
// ActiveObject is added to environment in AsyncRunStep after
- // the previous addition has been succesfully removed
+ // the previous addition has been successfully removed
}
-void Server::handleCommand_Interact(NetworkPacket* pkt)
+bool Server::checkInteractDistance(RemotePlayer *player, const f32 d, const std::string &what)
{
- std::string datastring(pkt->getString(0), pkt->getSize());
- std::istringstream is(datastring, std::ios_base::binary);
+ PlayerSAO *playersao = player->getPlayerSAO();
+ const InventoryList *hlist = playersao->getInventory()->getList("hand");
+ const ItemDefinition &playeritem_def =
+ playersao->getWieldedItem().getDefinition(m_itemdef);
+ const ItemDefinition &hand_def =
+ hlist ? hlist->getItem(0).getDefinition(m_itemdef) : m_itemdef->get("");
+
+ float max_d = BS * playeritem_def.range;
+ float max_d_hand = BS * hand_def.range;
+
+ if (max_d < 0 && max_d_hand >= 0)
+ max_d = max_d_hand;
+ else if (max_d < 0)
+ max_d = BS * 4.0f;
+
+ // Cube diagonal * 1.5 for maximal supported node extents:
+ // sqrt(3) * 1.5 ≅ 2.6
+ if (d > max_d + 2.6f * BS) {
+ actionstream << "Player " << player->getName()
+ << " tried to access " << what
+ << " from too far: "
+ << "d=" << d <<", max_d=" << max_d
+ << ". ignoring." << std::endl;
+ // Call callbacks
+ m_script->on_cheat(playersao, "interacted_too_far");
+ return false;
+ }
+ return true;
+}
+void Server::handleCommand_Interact(NetworkPacket* pkt)
+{
/*
[0] u16 command
[2] u8 action
[3] u16 item
- [5] u32 length of the next item
+ [5] u32 length of the next item (plen)
[9] serialized PointedThing
+ [9 + plen] player position information
actions:
0: start digging (from undersurface) or use
1: stop digging (all parameters ignored)
2: digging completed
3: place block or item (to abovesurface)
4: use item
+ 5: rightclick air ("activate")
*/
- u8 action = readU8(is);
- u16 item_i = readU16(is);
- std::istringstream tmp_is(deSerializeLongString(is), std::ios::binary);
+ u8 action;
+ u16 item_i;
+ *pkt >> action;
+ *pkt >> item_i;
+ std::istringstream tmp_is(pkt->readLongString(), std::ios::binary);
PointedThing pointed;
pointed.deSerialize(tmp_is);
verbosestream << "TOSERVER_INTERACT: action=" << (int)action << ", item="
<< item_i << ", pointed=" << pointed.dump() << std::endl;
- Player *player = m_env->getPlayer(pkt->getPeerId());
+ RemotePlayer *player = m_env->getPlayer(pkt->getPeerId());
+
if (player == NULL) {
- errorstream << "Server::ProcessData(): Cancelling: "
+ errorstream << "Server::ProcessData(): Canceling: "
"No player for peer_id=" << pkt->getPeerId()
<< " disconnecting peer!" << std::endl;
- m_con.DisconnectPeer(pkt->getPeerId());
+ DisconnectPeer(pkt->getPeerId());
return;
}
PlayerSAO *playersao = player->getPlayerSAO();
if (playersao == NULL) {
- errorstream << "Server::ProcessData(): Cancelling: "
+ errorstream << "Server::ProcessData(): Canceling: "
"No player object for peer_id=" << pkt->getPeerId()
<< " disconnecting peer!" << std::endl;
- m_con.DisconnectPeer(pkt->getPeerId());
+ DisconnectPeer(pkt->getPeerId());
return;
}
- if (player->isDead()) {
- verbosestream << "TOSERVER_INTERACT: " << player->getName()
- << " is dead. Ignoring packet";
+ if (playersao->isDead()) {
+ actionstream << "Server: NoCheat: " << player->getName()
+ << " tried to interact while dead; ignoring." << std::endl;
+ if (pointed.type == POINTEDTHING_NODE) {
+ // Re-send block to revert change on client-side
+ RemoteClient *client = getClient(pkt->getPeerId());
+ v3s16 blockpos = getNodeBlockPos(pointed.node_undersurface);
+ client->SetBlockNotSent(blockpos);
+ }
+ // Call callbacks
+ m_script->on_cheat(playersao, "interacted_while_dead");
return;
}
+ process_PlayerPos(player, playersao, pkt);
+
v3f player_pos = playersao->getLastGoodPosition();
// Update wielded item
pointed_pos_above = pointed_pos_under;
}
- /*
- Check that target is reasonably close
- (only when digging or placing things)
- */
- if (action == 0 || action == 2 || action == 3) {
- float d = player_pos.getDistanceFrom(pointed_pos_under);
- float max_d = BS * 14; // Just some large enough value
- if (d > max_d) {
- actionstream << "Player " << player->getName()
- << " tried to access " << pointed.dump()
- << " from too far: "
- << "d=" << d <<", max_d=" << max_d
- << ". ignoring." << std::endl;
- // Re-send block to revert change on client-side
- RemoteClient *client = getClient(pkt->getPeerId());
- v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_under, BS));
- client->SetBlockNotSent(blockpos);
- // Call callbacks
- m_script->on_cheat(playersao, "interacted_too_far");
- // Do nothing else
- return;
- }
- }
-
/*
Make sure the player is allowed to do it
*/
client->SetBlockNotSent(blockpos);
}
// Placement -> above
- if (action == 3) {
+ else if (action == 3) {
v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_above, BS));
client->SetBlockNotSent(blockpos);
}
return;
}
+ /*
+ Check that target is reasonably close
+ (only when digging or placing things)
+ */
+ static thread_local const bool enable_anticheat =
+ !g_settings->getBool("disable_anticheat");
+
+ if ((action == 0 || action == 2 || action == 3 || action == 4) &&
+ enable_anticheat && !isSingleplayer()) {
+ float d = playersao->getEyePosition()
+ .getDistanceFrom(pointed_pos_under);
+
+ if (!checkInteractDistance(player, d, pointed.dump())) {
+ // Re-send block to revert change on client-side
+ RemoteClient *client = getClient(pkt->getPeerId());
+ v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_under, BS));
+ client->SetBlockNotSent(blockpos);
+ return;
+ }
+ }
+
/*
If something goes wrong, this player is to blame
*/
*/
if (action == 0) {
if (pointed.type == POINTEDTHING_NODE) {
- /*
- NOTE: This can be used in the future to check if
- somebody is cheating, by checking the timing.
- */
MapNode n(CONTENT_IGNORE);
bool pos_ok;
- n = m_env->getMap().getNodeNoEx(p_under, &pos_ok);
- if (pos_ok)
- n = m_env->getMap().getNodeNoEx(p_under, &pos_ok);
+ n = m_env->getMap().getNodeNoEx(p_under, &pos_ok);
if (!pos_ok) {
infostream << "Server: Not punching: Node not found."
<< " Adding block to emerge queue."
<< std::endl;
- m_emerge->enqueueBlockEmerge(pkt->getPeerId(), getNodeBlockPos(p_above), false);
+ m_emerge->enqueueBlockEmerge(pkt->getPeerId(),
+ getNodeBlockPos(p_above), false);
}
if (n.getContent() != CONTENT_IGNORE)
m_script->node_on_punch(p_under, n, playersao, pointed);
+
// Cheat prevention
playersao->noCheatDigStart(p_under);
}
else if (pointed.type == POINTEDTHING_OBJECT) {
- // Skip if object has been removed
- if (pointed_object->m_removed)
+ // Skip if object can't be interacted with anymore
+ if (pointed_object->isGone())
return;
- actionstream<<player->getName()<<" punches object "
- <<pointed.object_id<<": "
- <<pointed_object->getDescription()<<std::endl;
-
- ItemStack punchitem = playersao->getWieldedItem();
+ ItemStack punchitem = playersao->getWieldedItemOrHand();
ToolCapabilities toolcap =
punchitem.getToolCapabilities(m_itemdef);
v3f dir = (pointed_object->getBasePosition() -
- (player->getPosition() + player->getEyeOffset())
+ (playersao->getBasePosition() + playersao->getEyeOffset())
).normalize();
float time_from_last_punch =
playersao->resetTimeFromLastPunch();
- s16 src_original_hp = pointed_object->getHP();
- s16 dst_origin_hp = playersao->getHP();
+ u16 src_original_hp = pointed_object->getHP();
+ u16 dst_origin_hp = playersao->getHP();
pointed_object->punch(dir, &toolcap, playersao,
time_from_last_punch);
// If the object is a player and its HP changed
if (src_original_hp != pointed_object->getHP() &&
pointed_object->getType() == ACTIVEOBJECT_TYPE_PLAYER) {
- SendPlayerHPOrDie(((PlayerSAO*)pointed_object)->getPeerID(),
- pointed_object->getHP() == 0);
+ SendPlayerHPOrDie((PlayerSAO *)pointed_object,
+ PlayerHPChangeReason(PlayerHPChangeReason::PLAYER_PUNCH, playersao));
}
// If the puncher is a player and its HP changed
- if (dst_origin_hp != playersao->getHP()) {
- SendPlayerHPOrDie(playersao->getPeerID(), playersao->getHP() == 0);
- }
+ if (dst_origin_hp != playersao->getHP())
+ SendPlayerHPOrDie(playersao,
+ PlayerHPChangeReason(PlayerHPChangeReason::PLAYER_PUNCH, pointed_object));
}
} // action == 0
MapNode n = m_env->getMap().getNodeNoEx(p_under, &pos_ok);
if (!pos_ok) {
infostream << "Server: Not finishing digging: Node not found."
- << " Adding block to emerge queue."
- << std::endl;
- m_emerge->enqueueBlockEmerge(pkt->getPeerId(), getNodeBlockPos(p_above), false);
+ << " Adding block to emerge queue."
+ << std::endl;
+ m_emerge->enqueueBlockEmerge(pkt->getPeerId(),
+ getNodeBlockPos(p_above), false);
}
/* Cheat prevention */
bool is_valid_dig = true;
- if (!isSingleplayer() && !g_settings->getBool("disable_anticheat")) {
+ if (enable_anticheat && !isSingleplayer()) {
v3s16 nocheat_p = playersao->getNoCheatDigPos();
float nocheat_t = playersao->getNoCheatDigTime();
playersao->noCheatDigEnd();
m_script->on_cheat(playersao, "finished_unknown_dig");
}
// Get player's wielded item
- ItemStack playeritem;
- InventoryList *mlist = playersao->getInventory()->getList("main");
- if (mlist != NULL)
- playeritem = mlist->getItem(playersao->getWieldIndex());
+ ItemStack playeritem = playersao->getWieldedItemOrHand();
ToolCapabilities playeritem_toolcap =
playeritem.getToolCapabilities(m_itemdef);
// Get diggability and expected digging time
&playeritem_toolcap);
// If can't dig, try hand
if (!params.diggable) {
- const ItemDefinition &hand = m_itemdef->get("");
- const ToolCapabilities *tp = hand.tool_capabilities;
+ InventoryList *hlist = playersao->getInventory()->getList("hand");
+ const ToolCapabilities *tp = hlist
+ ? &hlist->getItem(0).getToolCapabilities(m_itemdef)
+ : m_itemdef->get("").tool_capabilities;
+
if (tp)
params = getDigParams(m_nodedef->get(n).groups, tp);
}
if (pointed.type == POINTEDTHING_OBJECT) {
// Right click object
- // Skip if object has been removed
- if (pointed_object->m_removed)
+ // Skip if object can't be interacted with anymore
+ if (pointed_object->isGone())
return;
actionstream << player->getName() << " right-clicks object "
RemoteClient *client = getClient(pkt->getPeerId());
v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_above, BS));
v3s16 blockpos2 = getNodeBlockPos(floatToInt(pointed_pos_under, BS));
- if (item.getDefinition(m_itemdef).node_placement_prediction != "") {
+ if (!item.getDefinition(m_itemdef).node_placement_prediction.empty()) {
client->SetBlockNotSent(blockpos);
if (blockpos2 != blockpos) {
client->SetBlockNotSent(blockpos2);
if (m_script->item_OnUse(
item, playersao, pointed)) {
// Apply returned ItemStack
- playersao->setWieldedItem(item);
+ if (playersao->setWieldedItem(item)) {
+ SendInventory(playersao);
+ }
}
} // action == 4
+ /*
+ 5: rightclick air
+ */
+ else if (action == 5) {
+ ItemStack item = playersao->getWieldedItem();
+
+ actionstream << player->getName() << " activates "
+ << item.name << std::endl;
+
+ if (m_script->item_OnSecondaryUse(
+ item, playersao)) {
+ if( playersao->setWieldedItem(item)) {
+ SendInventory(playersao);
+ }
+ }
+ }
+
/*
Catch invalid actions
*/
else {
- infostream << "WARNING: Server: Invalid action "
+ warningstream << "Server: Invalid action "
<< action << std::endl;
}
}
*pkt >> id;
- std::map<s32, ServerPlayingSound>::iterator i =
+ std::unordered_map<s32, ServerPlayingSound>::iterator i =
m_playing_sounds.find(id);
-
if (i == m_playing_sounds.end())
continue;
*pkt >> p >> formname >> num;
- std::map<std::string, std::string> fields;
+ StringMap fields;
for (u16 k = 0; k < num; k++) {
std::string fieldname;
*pkt >> fieldname;
fields[fieldname] = pkt->readLongString();
}
- Player *player = m_env->getPlayer(pkt->getPeerId());
+ RemotePlayer *player = m_env->getPlayer(pkt->getPeerId());
+
if (player == NULL) {
- errorstream << "Server::ProcessData(): Cancelling: "
+ errorstream << "Server::ProcessData(): Canceling: "
"No player for peer_id=" << pkt->getPeerId()
<< " disconnecting peer!" << std::endl;
- m_con.DisconnectPeer(pkt->getPeerId());
+ DisconnectPeer(pkt->getPeerId());
return;
}
PlayerSAO *playersao = player->getPlayerSAO();
if (playersao == NULL) {
- errorstream << "Server::ProcessData(): Cancelling: "
+ errorstream << "Server::ProcessData(): Canceling: "
"No player object for peer_id=" << pkt->getPeerId()
<< " disconnecting peer!" << std::endl;
- m_con.DisconnectPeer(pkt->getPeerId());
+ DisconnectPeer(pkt->getPeerId());
return;
}
void Server::handleCommand_InventoryFields(NetworkPacket* pkt)
{
- std::string formname;
+ std::string client_formspec_name;
u16 num;
- *pkt >> formname >> num;
+ *pkt >> client_formspec_name >> num;
- std::map<std::string, std::string> fields;
+ StringMap fields;
for (u16 k = 0; k < num; k++) {
std::string fieldname;
*pkt >> fieldname;
fields[fieldname] = pkt->readLongString();
}
- Player *player = m_env->getPlayer(pkt->getPeerId());
+ RemotePlayer *player = m_env->getPlayer(pkt->getPeerId());
+
if (player == NULL) {
errorstream << "Server::ProcessData(): Canceling: "
"No player for peer_id=" << pkt->getPeerId()
<< " disconnecting peer!" << std::endl;
- m_con.DisconnectPeer(pkt->getPeerId());
+ DisconnectPeer(pkt->getPeerId());
return;
}
errorstream << "Server::ProcessData(): Canceling: "
"No player object for peer_id=" << pkt->getPeerId()
<< " disconnecting peer!" << std::endl;
- m_con.DisconnectPeer(pkt->getPeerId());
+ DisconnectPeer(pkt->getPeerId());
+ return;
+ }
+
+ if (client_formspec_name.empty()) { // pass through inventory submits
+ m_script->on_playerReceiveFields(playersao, client_formspec_name, fields);
+ return;
+ }
+
+ // verify that we displayed the formspec to the user
+ const auto peer_state_iterator = m_formspec_state_data.find(pkt->getPeerId());
+ if (peer_state_iterator != m_formspec_state_data.end()) {
+ const std::string &server_formspec_name = peer_state_iterator->second;
+ if (client_formspec_name == server_formspec_name) {
+ auto it = fields.find("quit");
+ if (it != fields.end() && it->second == "true")
+ m_formspec_state_data.erase(peer_state_iterator);
+
+ m_script->on_playerReceiveFields(playersao, client_formspec_name, fields);
+ return;
+ }
+ actionstream << "'" << player->getName()
+ << "' submitted formspec ('" << client_formspec_name
+ << "') but the name of the formspec doesn't match the"
+ " expected name ('" << server_formspec_name << "')";
+
+ } else {
+ actionstream << "'" << player->getName()
+ << "' submitted formspec ('" << client_formspec_name
+ << "') but server hasn't sent formspec to client";
+ }
+ actionstream << ", possible exploitation attempt" << std::endl;
+}
+
+void Server::handleCommand_FirstSrp(NetworkPacket* pkt)
+{
+ RemoteClient* client = getClient(pkt->getPeerId(), CS_Invalid);
+ ClientState cstate = client->getState();
+
+ std::string playername = client->getName();
+
+ std::string salt;
+ std::string verification_key;
+
+ std::string addr_s = getPeerAddress(pkt->getPeerId()).serializeString();
+ u8 is_empty;
+
+ *pkt >> salt >> verification_key >> is_empty;
+
+ verbosestream << "Server: Got TOSERVER_FIRST_SRP from " << addr_s
+ << ", with is_empty=" << (is_empty == 1) << std::endl;
+
+ // Either this packet is sent because the user is new or to change the password
+ if (cstate == CS_HelloSent) {
+ if (!client->isMechAllowed(AUTH_MECHANISM_FIRST_SRP)) {
+ actionstream << "Server: Client from " << addr_s
+ << " tried to set password without being "
+ << "authenticated, or the username being new." << std::endl;
+ DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_UNEXPECTED_DATA);
+ return;
+ }
+
+ if (!isSingleplayer() &&
+ g_settings->getBool("disallow_empty_password") &&
+ is_empty == 1) {
+ actionstream << "Server: " << playername
+ << " supplied empty password from " << addr_s << std::endl;
+ DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_EMPTY_PASSWORD);
+ return;
+ }
+
+ std::string initial_ver_key;
+
+ initial_ver_key = encode_srp_verifier(verification_key, salt);
+ m_script->createAuth(playername, initial_ver_key);
+
+ acceptAuth(pkt->getPeerId(), false);
+ } else {
+ if (cstate < CS_SudoMode) {
+ infostream << "Server::ProcessData(): Ignoring TOSERVER_FIRST_SRP from "
+ << addr_s << ": " << "Client has wrong state " << cstate << "."
+ << std::endl;
+ return;
+ }
+ m_clients.event(pkt->getPeerId(), CSE_SudoLeave);
+ std::string pw_db_field = encode_srp_verifier(verification_key, salt);
+ bool success = m_script->setPassword(playername, pw_db_field);
+ if (success) {
+ actionstream << playername << " changes password" << std::endl;
+ SendChatMessage(pkt->getPeerId(), ChatMessage(CHATMESSAGE_TYPE_SYSTEM,
+ L"Password change successful."));
+ } else {
+ actionstream << playername << " tries to change password but "
+ << "it fails" << std::endl;
+ SendChatMessage(pkt->getPeerId(), ChatMessage(CHATMESSAGE_TYPE_SYSTEM,
+ L"Password change failed or unavailable."));
+ }
+ }
+}
+
+void Server::handleCommand_SrpBytesA(NetworkPacket* pkt)
+{
+ RemoteClient* client = getClient(pkt->getPeerId(), CS_Invalid);
+ ClientState cstate = client->getState();
+
+ bool wantSudo = (cstate == CS_Active);
+
+ if (!((cstate == CS_HelloSent) || (cstate == CS_Active))) {
+ actionstream << "Server: got SRP _A packet in wrong state "
+ << cstate << " from "
+ << getPeerAddress(pkt->getPeerId()).serializeString()
+ << ". Ignoring." << std::endl;
+ return;
+ }
+
+ if (client->chosen_mech != AUTH_MECHANISM_NONE) {
+ actionstream << "Server: got SRP _A packet, while auth"
+ << "is already going on with mech " << client->chosen_mech
+ << " from " << getPeerAddress(pkt->getPeerId()).serializeString()
+ << " (wantSudo=" << wantSudo << "). Ignoring." << std::endl;
+ if (wantSudo) {
+ DenySudoAccess(pkt->getPeerId());
+ return;
+ }
+
+ DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_UNEXPECTED_DATA);
+ return;
+ }
+
+ std::string bytes_A;
+ u8 based_on;
+ *pkt >> bytes_A >> based_on;
+
+ infostream << "Server: TOSERVER_SRP_BYTES_A received with "
+ << "based_on=" << int(based_on) << " and len_A="
+ << bytes_A.length() << "." << std::endl;
+
+ AuthMechanism chosen = (based_on == 0) ?
+ AUTH_MECHANISM_LEGACY_PASSWORD : AUTH_MECHANISM_SRP;
+
+ if (wantSudo) {
+ if (!client->isSudoMechAllowed(chosen)) {
+ actionstream << "Server: Player \"" << client->getName()
+ << "\" at " << getPeerAddress(pkt->getPeerId()).serializeString()
+ << " tried to change password using unallowed mech "
+ << chosen << "." << std::endl;
+ DenySudoAccess(pkt->getPeerId());
+ return;
+ }
+ } else {
+ if (!client->isMechAllowed(chosen)) {
+ actionstream << "Server: Client tried to authenticate from "
+ << getPeerAddress(pkt->getPeerId()).serializeString()
+ << " using unallowed mech " << chosen << "." << std::endl;
+ DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_UNEXPECTED_DATA);
+ return;
+ }
+ }
+
+ client->chosen_mech = chosen;
+
+ std::string salt;
+ std::string verifier;
+
+ if (based_on == 0) {
+
+ generate_srp_verifier_and_salt(client->getName(), client->enc_pwd,
+ &verifier, &salt);
+ } else if (!decode_srp_verifier_and_salt(client->enc_pwd, &verifier, &salt)) {
+ // Non-base64 errors should have been catched in the init handler
+ actionstream << "Server: User " << client->getName()
+ << " tried to log in, but srp verifier field"
+ << " was invalid (most likely invalid base64)." << std::endl;
+ DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_SERVER_FAIL);
+ return;
+ }
+
+ char *bytes_B = 0;
+ size_t len_B = 0;
+
+ client->auth_data = srp_verifier_new(SRP_SHA256, SRP_NG_2048,
+ client->getName().c_str(),
+ (const unsigned char *) salt.c_str(), salt.size(),
+ (const unsigned char *) verifier.c_str(), verifier.size(),
+ (const unsigned char *) bytes_A.c_str(), bytes_A.size(),
+ NULL, 0,
+ (unsigned char **) &bytes_B, &len_B, NULL, NULL);
+
+ if (!bytes_B) {
+ actionstream << "Server: User " << client->getName()
+ << " tried to log in, SRP-6a safety check violated in _A handler."
+ << std::endl;
+ if (wantSudo) {
+ DenySudoAccess(pkt->getPeerId());
+ return;
+ }
+
+ DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_UNEXPECTED_DATA);
+ return;
+ }
+
+ NetworkPacket resp_pkt(TOCLIENT_SRP_BYTES_S_B, 0, pkt->getPeerId());
+ resp_pkt << salt << std::string(bytes_B, len_B);
+ Send(&resp_pkt);
+}
+
+void Server::handleCommand_SrpBytesM(NetworkPacket* pkt)
+{
+ RemoteClient* client = getClient(pkt->getPeerId(), CS_Invalid);
+ ClientState cstate = client->getState();
+
+ bool wantSudo = (cstate == CS_Active);
+
+ verbosestream << "Server: Received TOCLIENT_SRP_BYTES_M." << std::endl;
+
+ if (!((cstate == CS_HelloSent) || (cstate == CS_Active))) {
+ actionstream << "Server: got SRP _M packet in wrong state "
+ << cstate << " from "
+ << getPeerAddress(pkt->getPeerId()).serializeString()
+ << ". Ignoring." << std::endl;
+ return;
+ }
+
+ if (client->chosen_mech != AUTH_MECHANISM_SRP &&
+ client->chosen_mech != AUTH_MECHANISM_LEGACY_PASSWORD) {
+ actionstream << "Server: got SRP _M packet, while auth"
+ << "is going on with mech " << client->chosen_mech
+ << " from " << getPeerAddress(pkt->getPeerId()).serializeString()
+ << " (wantSudo=" << wantSudo << "). Denying." << std::endl;
+ if (wantSudo) {
+ DenySudoAccess(pkt->getPeerId());
+ return;
+ }
+
+ DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_UNEXPECTED_DATA);
+ return;
+ }
+
+ std::string bytes_M;
+ *pkt >> bytes_M;
+
+ if (srp_verifier_get_session_key_length((SRPVerifier *) client->auth_data)
+ != bytes_M.size()) {
+ actionstream << "Server: User " << client->getName()
+ << " at " << getPeerAddress(pkt->getPeerId()).serializeString()
+ << " sent bytes_M with invalid length " << bytes_M.size() << std::endl;
+ DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_UNEXPECTED_DATA);
+ return;
+ }
+
+ unsigned char *bytes_HAMK = 0;
+
+ srp_verifier_verify_session((SRPVerifier *) client->auth_data,
+ (unsigned char *)bytes_M.c_str(), &bytes_HAMK);
+
+ if (!bytes_HAMK) {
+ if (wantSudo) {
+ actionstream << "Server: User " << client->getName()
+ << " at " << getPeerAddress(pkt->getPeerId()).serializeString()
+ << " tried to change their password, but supplied wrong"
+ << " (SRP) password for authentication." << std::endl;
+ DenySudoAccess(pkt->getPeerId());
+ return;
+ }
+
+ std::string ip = getPeerAddress(pkt->getPeerId()).serializeString();
+ actionstream << "Server: User " << client->getName()
+ << " at " << ip
+ << " supplied wrong password (auth mechanism: SRP)."
+ << std::endl;
+ m_script->on_auth_failure(client->getName(), ip);
+ DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_WRONG_PASSWORD);
+ return;
+ }
+
+ if (client->create_player_on_auth_success) {
+ std::string playername = client->getName();
+ m_script->createAuth(playername, client->enc_pwd);
+
+ std::string checkpwd; // not used, but needed for passing something
+ if (!m_script->getAuth(playername, &checkpwd, NULL)) {
+ actionstream << "Server: " << playername << " cannot be authenticated"
+ << " (auth handler does not work?)" << std::endl;
+ DenyAccess(pkt->getPeerId(), SERVER_ACCESSDENIED_SERVER_FAIL);
+ return;
+ }
+ client->create_player_on_auth_success = false;
+ }
+
+ acceptAuth(pkt->getPeerId(), wantSudo);
+}
+
+/*
+ * Mod channels
+ */
+
+void Server::handleCommand_ModChannelJoin(NetworkPacket *pkt)
+{
+ std::string channel_name;
+ *pkt >> channel_name;
+
+ NetworkPacket resp_pkt(TOCLIENT_MODCHANNEL_SIGNAL, 1 + 2 + channel_name.size(),
+ pkt->getPeerId());
+
+ // Send signal to client to notify join succeed or not
+ if (g_settings->getBool("enable_mod_channels") &&
+ m_modchannel_mgr->joinChannel(channel_name, pkt->getPeerId())) {
+ resp_pkt << (u8) MODCHANNEL_SIGNAL_JOIN_OK;
+ infostream << "Peer " << pkt->getPeerId() << " joined channel " << channel_name
+ << std::endl;
+ }
+ else {
+ resp_pkt << (u8)MODCHANNEL_SIGNAL_JOIN_FAILURE;
+ infostream << "Peer " << pkt->getPeerId() << " tried to join channel "
+ << channel_name << ", but was already registered." << std::endl;
+ }
+ resp_pkt << channel_name;
+ Send(&resp_pkt);
+}
+
+void Server::handleCommand_ModChannelLeave(NetworkPacket *pkt)
+{
+ std::string channel_name;
+ *pkt >> channel_name;
+
+ NetworkPacket resp_pkt(TOCLIENT_MODCHANNEL_SIGNAL, 1 + 2 + channel_name.size(),
+ pkt->getPeerId());
+
+ // Send signal to client to notify join succeed or not
+ if (g_settings->getBool("enable_mod_channels") &&
+ m_modchannel_mgr->leaveChannel(channel_name, pkt->getPeerId())) {
+ resp_pkt << (u8)MODCHANNEL_SIGNAL_LEAVE_OK;
+ infostream << "Peer " << pkt->getPeerId() << " left channel " << channel_name
+ << std::endl;
+ } else {
+ resp_pkt << (u8) MODCHANNEL_SIGNAL_LEAVE_FAILURE;
+ infostream << "Peer " << pkt->getPeerId() << " left channel " << channel_name
+ << ", but was not registered." << std::endl;
+ }
+ resp_pkt << channel_name;
+ Send(&resp_pkt);
+}
+
+void Server::handleCommand_ModChannelMsg(NetworkPacket *pkt)
+{
+ std::string channel_name, channel_msg;
+ *pkt >> channel_name >> channel_msg;
+
+ verbosestream << "Mod channel message received from peer " << pkt->getPeerId()
+ << " on channel " << channel_name << " message: " << channel_msg << std::endl;
+
+ // If mod channels are not enabled, discard message
+ if (!g_settings->getBool("enable_mod_channels")) {
+ return;
+ }
+
+ // If channel not registered, signal it and ignore message
+ if (!m_modchannel_mgr->channelRegistered(channel_name)) {
+ NetworkPacket resp_pkt(TOCLIENT_MODCHANNEL_SIGNAL, 1 + 2 + channel_name.size(),
+ pkt->getPeerId());
+ resp_pkt << (u8)MODCHANNEL_SIGNAL_CHANNEL_NOT_REGISTERED << channel_name;
+ Send(&resp_pkt);
return;
}
- m_script->on_playerReceiveFields(playersao, formname, fields);
+ // @TODO: filter, rate limit
+
+ broadcastModChannelMessage(channel_name, channel_msg, pkt->getPeerId());
}
projects / dragonfireclient.git / blobdiff