X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fserver.cpp;h=753c71701139d02a01543a8f990064a39dbfb9f7;hb=db42542e271a00efd017b192f3a63e04f5b3dbf4;hp=293b32a81595403fa7c9c269f5efc6c52718fed8;hpb=ba66fce8339f818a638f97679bd29da064a8c1c6;p=oweals%2Fminetest.git diff --git a/src/server.cpp b/src/server.cpp index 293b32a81..753c71701 100644 --- a/src/server.cpp +++ b/src/server.cpp @@ -21,6 +21,7 @@ with this program; if not, write to the Free Software Foundation, Inc., #include #include #include +#include "network/connection.h" #include "network/networkprotocol.h" #include "network/serveropcodes.h" #include "ban.h" @@ -38,28 +39,32 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "settings.h" #include "profiler.h" #include "log.h" -#include "serverscripting.h" +#include "scripting_server.h" #include "nodedef.h" #include "itemdef.h" #include "craftdef.h" #include "emerge.h" -#include "mapgen.h" -#include "mg_biome.h" +#include "mapgen/mapgen.h" +#include "mapgen/mg_biome.h" #include "content_mapnode.h" #include "content_nodemeta.h" -#include "content_abm.h" #include "content_sao.h" -#include "mods.h" -#include "event_manager.h" +#include "content/mods.h" +#include "modchannels.h" #include "serverlist.h" #include "util/string.h" #include "rollback.h" #include "util/serialize.h" #include "util/thread.h" #include "defaultsettings.h" +#include "server/mods.h" #include "util/base64.h" #include "util/sha1.h" #include "util/hex.h" +#include "database/database.h" +#include "chatmessage.h" +#include "chat_interface.h" +#include "remoteplayer.h" class ClientNotFoundException : public BaseException { @@ -86,15 +91,12 @@ private: void *ServerThread::run() { - DSTACK(FUNCTION_NAME); BEGIN_DEBUG_EXCEPTION_HANDLER m_server->AsyncRunStep(true); while (!stopRequested()) { try { - //TimeTaker timer("AsyncRunStep() + Receive()"); - m_server->AsyncRunStep(); m_server->Receive(); @@ -113,7 +115,7 @@ void *ServerThread::run() END_DEBUG_EXCEPTION_HANDLER - return NULL; + return nullptr; } v3f ServerSoundParams::getPos(ServerEnvironment *env, bool *pos_exists) const @@ -137,7 +139,60 @@ v3f ServerSoundParams::getPos(ServerEnvironment *env, bool *pos_exists) const return v3f(0,0,0); } +void Server::ShutdownState::reset() +{ + m_timer = 0.0f; + message.clear(); + should_reconnect = false; + is_requested = false; +} +void Server::ShutdownState::trigger(float delay, const std::string &msg, bool reconnect) +{ + m_timer = delay; + message = msg; + should_reconnect = reconnect; +} + +void Server::ShutdownState::tick(float dtime, Server *server) +{ + if (m_timer <= 0.0f) + return; + + // Timed shutdown + static const float shutdown_msg_times[] = + { + 1, 2, 3, 4, 5, 10, 20, 40, 60, 120, 180, 300, 600, 1200, 1800, 3600 + }; + + // Automated messages + if (m_timer < shutdown_msg_times[ARRLEN(shutdown_msg_times) - 1]) { + for (float t : shutdown_msg_times) { + // If shutdown timer matches an automessage, shot it + if (m_timer > t && m_timer - dtime < t) { + std::wstring periodicMsg = getShutdownTimerMessage(); + + infostream << wide_to_utf8(periodicMsg).c_str() << std::endl; + server->SendChatMessage(PEER_ID_INEXISTENT, periodicMsg); + break; + } + } + } + + m_timer -= dtime; + if (m_timer < 0.0f) { + m_timer = 0.0f; + is_requested = true; + } +} + +std::wstring Server::ShutdownState::getShutdownTimerMessage() const +{ + std::wstringstream ws; + ws << L"*** Server shutting down in " + << duration_to_string(myround(m_timer)).c_str() << "."; + return ws.str(); +} /* Server @@ -147,65 +202,121 @@ Server::Server( const std::string &path_world, const SubgameSpec &gamespec, bool simple_singleplayer_mode, - bool ipv6, + Address bind_addr, + bool dedicated, ChatInterface *iface ): + m_bind_addr(bind_addr), m_path_world(path_world), m_gamespec(gamespec), m_simple_singleplayer_mode(simple_singleplayer_mode), + m_dedicated(dedicated), m_async_fatal_error(""), - m_env(NULL), - m_con(PROTOCOL_ID, + m_con(std::make_shared(PROTOCOL_ID, 512, CONNECTION_TIMEOUT, - ipv6, - this), - m_banmanager(NULL), - m_rollback(NULL), - m_enable_rollback_recording(false), - m_emerge(NULL), - m_script(NULL), + m_bind_addr.isIPv6(), + this)), m_itemdef(createItemDefManager()), m_nodedef(createNodeDefManager()), m_craftdef(createCraftDefManager()), - m_event(new EventManager()), - m_thread(NULL), - m_time_of_day_send_timer(0), m_uptime(0), - m_clients(&m_con), - m_shutdown_requested(false), - m_shutdown_ask_reconnect(false), + m_clients(m_con), m_admin_chat(iface), - m_ignore_map_edit_events(false), - m_ignore_map_edit_events_peer_id(0), - m_next_sound_id(0), - m_mod_storage_save_timer(10.0f) -{ - m_liquid_transform_timer = 0.0; - m_liquid_transform_every = 1.0; - m_masterserver_timer = 0.0; - m_emergethread_trigger_timer = 0.0; - m_savemap_timer = 0.0; - - m_step_dtime = 0.0; + m_modchannel_mgr(new ModChannelMgr()) +{ m_lag = g_settings->getFloat("dedicated_server_step"); - if(path_world == "") + if (m_path_world.empty()) throw ServerError("Supplied empty world path"); - if(!gamespec.isValid()) + if (!gamespec.isValid()) throw ServerError("Supplied invalid gamespec"); +} + +Server::~Server() +{ + infostream << "Server destructing" << std::endl; + + // Send shutdown message + SendChatMessage(PEER_ID_INEXISTENT, ChatMessage(CHATMESSAGE_TYPE_ANNOUNCE, + L"*** Server shutting down")); - infostream<<"Server created for gameid \""<saveLoadedPlayers(); + + infostream << "Server: Kicking players" << std::endl; + std::string kick_msg; + bool reconnect = false; + if (isShutdownRequested()) { + reconnect = m_shutdown_state.should_reconnect; + kick_msg = m_shutdown_state.message; + } + if (kick_msg.empty()) { + kick_msg = g_settings->get("kick_msg_shutdown"); + } + m_env->kickAllPlayers(SERVER_ACCESSDENIED_SHUTDOWN, + kick_msg, reconnect); + } + + // Do this before stopping the server in case mapgen callbacks need to access + // server-controlled resources (like ModStorages). Also do them before + // shutdown callbacks since they may modify state that is finalized in a + // callback. + if (m_emerge) + m_emerge->stopThreads(); + + if (m_env) { + MutexAutoLock envlock(m_env_mutex); + + // Execute script shutdown hooks + infostream << "Executing shutdown hooks" << std::endl; + m_script->on_shutdown(); + + infostream << "Server: Saving environment metadata" << std::endl; + m_env->saveMeta(); + } + + // Stop threads + if (m_thread) { + stop(); + delete m_thread; + } + + // Delete things in the reverse order of creation + delete m_emerge; + delete m_env; + delete m_rollback; + delete m_banmanager; + delete m_itemdef; + delete m_nodedef; + delete m_craftdef; + + // Deinitialize scripting + infostream << "Server: Deinitializing scripting" << std::endl; + delete m_script; + + // Delete detached inventories + for (auto &detached_inventory : m_detached_inventories) { + delete detached_inventory.second; + } +} + +void Server::init() +{ + infostream << "Server created for gameid \"" << m_gamespec.id << "\""; + if (m_simple_singleplayer_mode) + infostream << " in simple singleplayer mode" << std::endl; else - infostream< unsatisfied_mods = modconf.getUnsatisfiedMods(); + m_modmgr = std::unique_ptr(new ServerModManager(m_path_world)); + std::vector unsatisfied_mods = m_modmgr->getUnsatisfiedMods(); // complain about mods with unsatisfied dependencies - if (!modconf.isConsistent()) { - modconf.printUnsatisfiedModsError(); - } - - Settings worldmt_settings; - std::string worldmt = m_path_world + DIR_DELIM + "world.mt"; - worldmt_settings.readConfigFile(worldmt.c_str()); - std::vector names = worldmt_settings.getNames(); - std::set load_mod_names; - for(std::vector::iterator it = names.begin(); - it != names.end(); ++it) { - std::string name = *it; - if(name.compare(0,9,"load_mod_")==0 && worldmt_settings.getBool(name)) - load_mod_names.insert(name.substr(9)); - } - // complain about mods declared to be loaded, but not found - for(std::vector::iterator it = m_mods.begin(); - it != m_mods.end(); ++it) - load_mod_names.erase((*it).name); - for(std::vector::iterator it = unsatisfied_mods.begin(); - it != unsatisfied_mods.end(); ++it) - load_mod_names.erase((*it).name); - if(!load_mod_names.empty()) { - errorstream << "The following mods could not be found:"; - for(std::set::iterator it = load_mod_names.begin(); - it != load_mod_names.end(); ++it) - errorstream << " \"" << (*it) << "\""; - errorstream << std::endl; + if (!m_modmgr->isConsistent()) { + m_modmgr->printUnsatisfiedModsError(); } //lock environment MutexAutoLock envlock(m_env_mutex); // Create the Map (loads map_meta.txt, overriding configured mapgen params) - ServerMap *servermap = new ServerMap(path_world, this, m_emerge); + ServerMap *servermap = new ServerMap(m_path_world, this, m_emerge); // Initialize scripting - infostream<<"Server: Initializing Lua"<loadMod(getBuiltinLuaPath() + DIR_DELIM "init.lua", BUILTIN_MOD_NAME); - // Print mods - infostream << "Server: Loading mods: "; - for (std::vector::const_iterator i = m_mods.begin(); - i != m_mods.end(); ++i) { - infostream << (*i).name << " "; - } - infostream << std::endl; - // Load and run "mod" scripts - for (std::vector::const_iterator it = m_mods.begin(); - it != m_mods.end(); ++it) { - const ModSpec &mod = *it; - if (!string_allowed(mod.name, MODNAME_ALLOWED_CHARS)) { - throw ModError("Error loading mod \"" + mod.name + - "\": Mod name does not follow naming conventions: " - "Only chararacters [a-z0-9_] are allowed."); - } - std::string script_path = mod.path + DIR_DELIM + "init.lua"; - infostream << " [" << padStringRight(mod.name, 12) << "] [\"" - << script_path << "\"]" << std::endl; - m_script->loadMod(script_path, mod.name); - } + m_modmgr->loadMods(m_script); // Read Textures and calculate sha1 sums fillMediaCache(); @@ -294,9 +358,11 @@ Server::Server( m_nodedef->updateAliases(m_itemdef); // Apply texture overrides from texturepack/override.txt - std::string texture_path = g_settings->get("texture_path"); - if (texture_path != "" && fs::IsDir(texture_path)) - m_nodedef->applyTextureOverrides(texture_path + DIR_DELIM + "override.txt"); + std::vector paths; + fs::GetRecursiveDirs(paths, g_settings->get("texture_path")); + fs::GetRecursiveDirs(paths, m_gamespec.path + DIR_DELIM + "textures"); + for (const std::string &path : paths) + m_nodedef->applyTextureOverrides(path + DIR_DELIM + "override.txt"); m_nodedef->setNodeRegistrationStatus(true); @@ -320,8 +386,7 @@ Server::Server( // Initialize mapgens m_emerge->initMapgens(servermap->getMapgenParams()); - m_enable_rollback_recording = g_settings->getBool("enable_rollback_recording"); - if (m_enable_rollback_recording) { + if (g_settings->getBool("enable_rollback_recording")) { // Create rollback manager m_rollback = new RollbackManager(m_path_world, this); } @@ -332,121 +397,45 @@ Server::Server( // Register us to receive map edit events servermap->addEventReceiver(this); - // If file exists, load environment metadata - if (fs::PathExists(m_path_world + DIR_DELIM "env_meta.txt")) { - infostream << "Server: Loading environment metadata" << std::endl; - m_env->loadMeta(); - } else { - m_env->loadDefaultMeta(); - } - - // Add some test ActiveBlockModifiers to environment - add_legacy_abms(m_env, m_nodedef); + m_env->loadMeta(); m_liquid_transform_every = g_settings->getFloat("liquid_update"); m_max_chatmessage_length = g_settings->getU16("chat_message_max_size"); + m_csm_restriction_flags = g_settings->getU64("csm_restriction_flags"); + m_csm_restriction_noderange = g_settings->getU32("csm_restriction_noderange"); } -Server::~Server() +void Server::start() { - infostream<<"Server destructing"<on_shutdown(); - - infostream << "Server: Saving players" << std::endl; - m_env->saveLoadedPlayers(); - - infostream << "Server: Kicking players" << std::endl; - std::string kick_msg; - bool reconnect = false; - if (getShutdownRequested()) { - reconnect = m_shutdown_ask_reconnect; - kick_msg = m_shutdown_msg; - } - if (kick_msg == "") { - kick_msg = g_settings->get("kick_msg_shutdown"); - } - m_env->kickAllPlayers(SERVER_ACCESSDENIED_SHUTDOWN, - kick_msg, reconnect); - - infostream << "Server: Saving environment metadata" << std::endl; - m_env->saveMeta(); - } - - // Stop threads - stop(); - delete m_thread; - - // stop all emerge threads before deleting players that may have - // requested blocks to be emerged - m_emerge->stopThreads(); - - // Delete things in the reverse order of creation - delete m_emerge; - delete m_env; - delete m_rollback; - delete m_banmanager; - delete m_event; - delete m_itemdef; - delete m_nodedef; - delete m_craftdef; - - // Deinitialize scripting - infostream<<"Server: Deinitializing scripting"<::iterator - i = m_detached_inventories.begin(); - i != m_detached_inventories.end(); ++i) { - delete i->second; - } -} - -void Server::start(Address bind_addr) -{ - DSTACK(FUNCTION_NAME); - - m_bind_addr = bind_addr; - - infostream<<"Starting server on " - << bind_addr.serializeString() <<"..."<stop(); // Initialize connection - m_con.SetTimeoutMs(30); - m_con.Serve(bind_addr); + m_con->SetTimeoutMs(30); + m_con->Serve(m_bind_addr); // Start thread m_thread->start(); // ASCII art for the win! - actionstream - <<" .__ __ __ "<__| \\___ >____ > |__| "<__| \\___ >____ > |__| " << std::endl + << " \\/ \\/ \\/ \\/ \\/ " << std::endl; + actionstream << "World at [" << m_path_world << "]" << std::endl; + actionstream << "Server for gameid=\"" << m_gamespec.id + << "\" listening on " << m_bind_addr.serializeString() << ":" + << m_bind_addr.getPort() << "." << std::endl; } void Server::stop() { - DSTACK(FUNCTION_NAME); - infostream<<"Server: Stopping and waiting threads"< 2.0) dtime = 2.0; @@ -482,8 +470,6 @@ void Server::step(float dtime) void Server::AsyncRunStep(bool initial_step) { - DSTACK(FUNCTION_NAME); - g_profiler->add("Server::AsyncRunStep (num)", 1); float dtime; @@ -497,7 +483,7 @@ void Server::AsyncRunStep(bool initial_step) SendBlocks(dtime); } - if((dtime < 0.001) && (initial_step == false)) + if((dtime < 0.001) && !initial_step) return; g_profiler->add("Server::AsyncRunStep with dtime (num)", 1); @@ -596,29 +582,12 @@ void Server::AsyncRunStep(bool initial_step) ScopeProfiler sp(g_profiler, "Server: liquid transform"); std::map modified_blocks; - m_env->getMap().transformLiquids(modified_blocks); -#if 0 - /* - Update lighting - */ - core::map lighting_modified_blocks; - ServerMap &map = ((ServerMap&)m_env->getMap()); - map.updateLighting(modified_blocks, lighting_modified_blocks); - - // Add blocks modified by lighting to modified_blocks - for(core::map::Iterator - i = lighting_modified_blocks.getIterator(); - i.atEnd() == false; i++) - { - MapBlock *block = i.getNode()->getValue(); - modified_blocks.insert(block->getPos(), block); - } -#endif + m_env->getMap().transformLiquids(modified_blocks, m_env); + /* Set the modified blocks unsent for all the clients */ - if(!modified_blocks.empty()) - { + if (!modified_blocks.empty()) { SetBlocksNotSent(modified_blocks); } } @@ -629,10 +598,10 @@ void Server::AsyncRunStep(bool initial_step) // send masterserver announce { float &counter = m_masterserver_timer; - if(!isSingleplayer() && (!counter || counter >= 300.0) && - g_settings->getBool("server_announce")) - { - ServerList::sendAnnounce(counter ? "update" : "start", + if (!isSingleplayer() && (!counter || counter >= 300.0) && + g_settings->getBool("server_announce")) { + ServerList::sendAnnounce(counter ? ServerList::AA_UPDATE : + ServerList::AA_START, m_bind_addr.getPort(), m_clients.getPlayerNames(), m_uptime.get(), @@ -640,7 +609,8 @@ void Server::AsyncRunStep(bool initial_step) m_lag, m_gamespec.id, Mapgen::getMapgenName(m_emerge->mgparams->mgtype), - m_mods); + m_modmgr->getMods(), + m_dedicated); counter = 0.01; } counter += dtime; @@ -655,25 +625,25 @@ void Server::AsyncRunStep(bool initial_step) MutexAutoLock envlock(m_env_mutex); m_clients.lock(); - UNORDERED_MAP clients = m_clients.getClientList(); + const RemoteClientMap &clients = m_clients.getClientList(); ScopeProfiler sp(g_profiler, "Server: checking added and deleted objs"); // Radius inside which objects are active - static const s16 radius = + static thread_local const s16 radius = g_settings->getS16("active_object_send_range_blocks") * MAP_BLOCKSIZE; // Radius inside which players are active - static const bool is_transfer_limited = + static thread_local const bool is_transfer_limited = g_settings->exists("unlimited_player_transfer_distance") && !g_settings->getBool("unlimited_player_transfer_distance"); - static const s16 player_transfer_dist = g_settings->getS16("player_transfer_distance") * MAP_BLOCKSIZE; + static thread_local const s16 player_transfer_dist = + g_settings->getS16("player_transfer_distance") * MAP_BLOCKSIZE; s16 player_radius = player_transfer_dist; if (player_radius == 0 && is_transfer_limited) player_radius = radius; - for (UNORDERED_MAP::iterator i = clients.begin(); - i != clients.end(); ++i) { - RemoteClient *client = i->second; + for (const auto &client_it : clients) { + RemoteClient *client = client_it.second; // If definitions and textures have not been sent, don't // send objects either @@ -681,16 +651,13 @@ void Server::AsyncRunStep(bool initial_step) continue; RemotePlayer *player = m_env->getPlayer(client->peer_id); - if (player == NULL) { + if (!player) { // This can happen if the client timeouts somehow - /*warningstream<peer_id - <<" has no associated player"<getPlayerSAO(); - if (playersao == NULL) + if (!playersao) continue; s16 my_radius = MYMIN(radius, playersao->getWantedRange() * MAP_BLOCKSIZE); @@ -743,9 +710,8 @@ void Server::AsyncRunStep(bool initial_step) // Get object type u8 type = ACTIVEOBJECT_TYPE_INVALID; - if(obj == NULL) - warningstream<getSendType(); @@ -782,7 +748,7 @@ void Server::AsyncRunStep(bool initial_step) if (m_mod_storage_save_timer <= 0.0f) { infostream << "Saving registered mod storages." << std::endl; m_mod_storage_save_timer = g_settings->getFloat("server_map_save_interval"); - for (UNORDERED_MAP::const_iterator + for (std::unordered_map::const_iterator it = m_mod_storages.begin(); it != m_mod_storages.end(); ++it) { if (it->second->isModified()) { it->second->save(getModStoragePath()); @@ -800,7 +766,7 @@ void Server::AsyncRunStep(bool initial_step) // Key = object id // Value = data sent by object - UNORDERED_MAP* > buffered_messages; + std::unordered_map*> buffered_messages; // Get active object messages from environment for(;;) { @@ -808,8 +774,8 @@ void Server::AsyncRunStep(bool initial_step) if (aom.id == 0) break; - std::vector* message_list = NULL; - UNORDERED_MAP* >::iterator n; + std::vector* message_list = nullptr; + std::unordered_map* >::iterator n; n = buffered_messages.find(aom.id); if (n == buffered_messages.end()) { message_list = new std::vector; @@ -822,29 +788,24 @@ void Server::AsyncRunStep(bool initial_step) } m_clients.lock(); - UNORDERED_MAP clients = m_clients.getClientList(); + const RemoteClientMap &clients = m_clients.getClientList(); // Route data to every client - for (UNORDERED_MAP::iterator i = clients.begin(); - i != clients.end(); ++i) { - RemoteClient *client = i->second; + for (const auto &client_it : clients) { + RemoteClient *client = client_it.second; std::string reliable_data; std::string unreliable_data; // Go through all objects in message buffer - for (UNORDERED_MAP* >::iterator - j = buffered_messages.begin(); - j != buffered_messages.end(); ++j) { + for (const auto &buffered_message : buffered_messages) { // If object is not known by client, skip it - u16 id = j->first; + u16 id = buffered_message.first; if (client->m_known_objects.find(id) == client->m_known_objects.end()) continue; // Get message list of object - std::vector* list = j->second; + std::vector* list = buffered_message.second; // Go through every message - for (std::vector::iterator - k = list->begin(); k != list->end(); ++k) { + for (const ActiveObjectMessage &aom : *list) { // Compose the full new data with header - ActiveObjectMessage aom = *k; std::string new_data; // Add object id char buf[2]; @@ -853,7 +814,7 @@ void Server::AsyncRunStep(bool initial_step) // Add data new_data += serializeString(aom.datastring); // Add data to buffer - if(aom.reliable) + if (aom.reliable) reliable_data += new_data; else unreliable_data += new_data; @@ -863,21 +824,19 @@ void Server::AsyncRunStep(bool initial_step) reliable_data and unreliable_data are now ready. Send them. */ - if(reliable_data.size() > 0) { + if (!reliable_data.empty()) { SendActiveObjectMessages(client->peer_id, reliable_data); } - if(unreliable_data.size() > 0) { + if (!unreliable_data.empty()) { SendActiveObjectMessages(client->peer_id, unreliable_data, false); } } m_clients.unlock(); // Clear buffered_messages - for (UNORDERED_MAP* >::iterator - i = buffered_messages.begin(); - i != buffered_messages.end(); ++i) { - delete i->second; + for (auto &buffered_message : buffered_messages) { + delete buffered_message.second; } } @@ -901,8 +860,7 @@ void Server::AsyncRunStep(bool initial_step) // We'll log the amount of each Profiler prof; - while(m_unsent_map_edit_queue.size() != 0) - { + while (!m_unsent_map_edit_queue.empty()) { MapEditEvent* event = m_unsent_map_edit_queue.front(); m_unsent_map_edit_queue.pop(); @@ -927,15 +885,13 @@ void Server::AsyncRunStep(bool initial_step) case MEET_BLOCK_NODE_METADATA_CHANGED: infostream << "Server: MEET_BLOCK_NODE_METADATA_CHANGED" << std::endl; prof.add("MEET_BLOCK_NODE_METADATA_CHANGED", 1); - setBlockNotSent(event->p); + m_clients.markBlockposAsNotSent(event->p); break; case MEET_OTHER: infostream << "Server: MEET_OTHER" << std::endl; prof.add("MEET_OTHER", 1); - for(std::set::iterator - i = event->modified_blocks.begin(); - i != event->modified_blocks.end(); ++i) { - setBlockNotSent(*i); + for (const v3s16 &modified_block : event->modified_blocks) { + m_clients.markBlockposAsNotSent(modified_block); } break; default: @@ -948,38 +904,29 @@ void Server::AsyncRunStep(bool initial_step) /* Set blocks not sent to far players */ - if(!far_players.empty()) { + if (!far_players.empty()) { // Convert list format to that wanted by SetBlocksNotSent std::map modified_blocks2; - for(std::set::iterator - i = event->modified_blocks.begin(); - i != event->modified_blocks.end(); ++i) { - modified_blocks2[*i] = - m_env->getMap().getBlockNoCreateNoEx(*i); + for (const v3s16 &modified_block : event->modified_blocks) { + modified_blocks2[modified_block] = + m_env->getMap().getBlockNoCreateNoEx(modified_block); } // Set blocks not sent - for(std::vector::iterator - i = far_players.begin(); - i != far_players.end(); ++i) { - if(RemoteClient *client = getClient(*i)) + for (const u16 far_player : far_players) { + if (RemoteClient *client = getClient(far_player)) client->SetBlocksNotSent(modified_blocks2); } } delete event; - - /*// Don't send too many at a time - count++; - if(count >= 1 && m_unsent_map_edit_queue.size() < 100) - break;*/ } - if(event_count >= 5){ - infostream<<"Server: MapEditEvents:"<= 5) { + infostream << "Server: MapEditEvents:" << std::endl; prof.print(infostream); - } else if(event_count != 0){ - verbosestream<<"Server: MapEditEvents:"<getFloat("server_map_save_interval"); if (counter >= save_interval) { counter = 0.0; @@ -1026,47 +973,41 @@ void Server::AsyncRunStep(bool initial_step) m_env->saveMeta(); } } + + m_shutdown_state.tick(dtime, this); } void Server::Receive() { - DSTACK(FUNCTION_NAME); - SharedBuffer data; - u16 peer_id; + session_t peer_id; try { NetworkPacket pkt; - m_con.Receive(&pkt); + m_con->Receive(&pkt); peer_id = pkt.getPeerId(); ProcessData(&pkt); - } - catch(con::InvalidIncomingDataException &e) { - infostream<<"Server::Receive(): " - "InvalidIncomingDataException: what()=" - <getName(); playersao = emergePlayer(playername.c_str(), peer_id, client->net_proto_version); } @@ -1079,8 +1020,8 @@ PlayerSAO* Server::StageTwoClientInit(u16 peer_id) RemotePlayer *player = m_env->getPlayer(playername.c_str()); // If failed, cancel - if ((playersao == NULL) || (player == NULL)) { - if (player && player->peer_id != 0) { + if (!playersao || !player) { + if (player && player->getPeerId() != PEER_ID_INEXISTENT) { actionstream << "Server: Failed to emerge player \"" << playername << "\" (player allocated to an another client)" << std::endl; DenyAccess_Legacy(peer_id, L"Another client is connected with this " @@ -1108,22 +1049,22 @@ PlayerSAO* Server::StageTwoClientInit(u16 peer_id) // Send inventory SendInventory(playersao); - // Send HP - SendPlayerHPOrDie(playersao); + // Send HP or death screen + if (playersao->isDead()) + SendDeathscreen(peer_id, false, v3f(0,0,0)); + else + SendPlayerHPOrDie(playersao, + PlayerHPChangeReason(PlayerHPChangeReason::SET_HP)); // Send Breath SendPlayerBreath(playersao); - // Show death screen if necessary - if (playersao->isDead()) - SendDeathscreen(peer_id, false, v3f(0,0,0)); - // Note things in chat if not in simple singleplayer mode if (!m_simple_singleplayer_mode && g_settings->getBool("show_statusline_on_connect")) { // Send information about server to player in chat - SendChatMessage(peer_id, getStatusString()); + SendChatMessage(peer_id, ChatMessage(CHATMESSAGE_TYPE_SYSTEM, getStatusString())); } - Address addr = getPeerAddress(player->peer_id); + Address addr = getPeerAddress(player->getPeerId()); std::string ip_str = addr.serializeString(); actionstream<getName() <<" [" << ip_str << "] joins game. " << std::endl; /* @@ -1134,9 +1075,8 @@ PlayerSAO* Server::StageTwoClientInit(u16 peer_id) actionstream << player->getName() << " joins game. List of players: "; - for (std::vector::const_iterator i = names.begin(); - i != names.end(); ++i) { - actionstream << *i << " "; + for (const std::string &name : names) { + actionstream << name << " "; } actionstream << player->getName() <getArea())) + if (m_ignore_map_edit_events_area.contains(event->getArea())) return; MapEditEvent *e = event->clone(); m_unsent_map_edit_queue.push(e); @@ -1261,7 +1198,7 @@ Inventory* Server::getInventory(const InventoryLocation &loc) break; case InventoryLocation::PLAYER: { - RemotePlayer *player = dynamic_cast(m_env->getPlayer(loc.name.c_str())); + RemotePlayer *player = m_env->getPlayer(loc.name.c_str()); if(!player) return NULL; PlayerSAO *playersao = player->getPlayerSAO(); @@ -1301,8 +1238,7 @@ void Server::setInventoryModified(const InventoryLocation &loc, bool playerSend) if (!playerSend) return; - RemotePlayer *player = - dynamic_cast(m_env->getPlayer(loc.name.c_str())); + RemotePlayer *player = m_env->getPlayer(loc.name.c_str()); if (!player) return; @@ -1319,10 +1255,10 @@ void Server::setInventoryModified(const InventoryLocation &loc, bool playerSend) v3s16 blockpos = getNodeBlockPos(loc.p); MapBlock *block = m_env->getMap().getBlockNoCreateNoEx(blockpos); - if(block) + if (block) block->raiseModified(MOD_STATE_WRITE_NEEDED); - setBlockNotSent(blockpos); + m_clients.markBlockposAsNotSent(blockpos); } break; case InventoryLocation::DETACHED: @@ -1338,12 +1274,11 @@ void Server::setInventoryModified(const InventoryLocation &loc, bool playerSend) void Server::SetBlocksNotSent(std::map& block) { - std::vector clients = m_clients.getClientIDs(); + std::vector clients = m_clients.getClientIDs(); m_clients.lock(); // Set the modified blocks unsent for all the clients - for (std::vector::iterator i = clients.begin(); - i != clients.end(); ++i) { - if (RemoteClient *client = m_clients.lockedGetClientNoEx(*i)) + for (const session_t client_id : clients) { + if (RemoteClient *client = m_clients.lockedGetClientNoEx(client_id)) client->SetBlocksNotSent(block); } m_clients.unlock(); @@ -1351,40 +1286,29 @@ void Server::SetBlocksNotSent(std::map& block) void Server::peerAdded(con::Peer *peer) { - DSTACK(FUNCTION_NAME); verbosestream<<"Server::peerAdded(): peer->id=" <id<id; - c.timeout = false; - m_peer_change_queue.push(c); + m_peer_change_queue.push(con::PeerChange(con::PEER_ADDED, peer->id, false)); } void Server::deletingPeer(con::Peer *peer, bool timeout) { - DSTACK(FUNCTION_NAME); verbosestream<<"Server::deletingPeer(): peer->id=" <id<<", timeout="<id, CSE_Disconnect); - con::PeerChange c; - c.type = con::PEER_REMOVED; - c.peer_id = peer->id; - c.timeout = timeout; - m_peer_change_queue.push(c); + m_peer_change_queue.push(con::PeerChange(con::PEER_REMOVED, peer->id, timeout)); } -bool Server::getClientConInfo(u16 peer_id, con::rtt_stat_type type, float* retval) +bool Server::getClientConInfo(session_t peer_id, con::rtt_stat_type type, float* retval) { - *retval = m_con.getPeerStat(peer_id,type); - if (*retval == -1) return false; - return true; + *retval = m_con->getPeerStat(peer_id,type); + return *retval != -1; } bool Server::getClientInfo( - u16 peer_id, + session_t peer_id, ClientState* state, u32* uptime, u8* ser_vers, @@ -1399,7 +1323,7 @@ bool Server::getClientInfo( m_clients.lock(); RemoteClient* client = m_clients.lockedGetClientNoEx(peer_id, CS_Invalid); - if (client == NULL) { + if (!client) { m_clients.unlock(); return false; } @@ -1420,7 +1344,7 @@ bool Server::getClientInfo( void Server::handlePeerChanges() { - while(m_peer_change_queue.size() > 0) + while(!m_peer_change_queue.empty()) { con::PeerChange c = m_peer_change_queue.front(); m_peer_change_queue.pop(); @@ -1456,17 +1380,21 @@ void Server::printToConsoleOnly(const std::string &text) } } -void Server::Send(NetworkPacket* pkt) +void Server::Send(NetworkPacket *pkt) { - m_clients.send(pkt->getPeerId(), + Send(pkt->getPeerId(), pkt); +} + +void Server::Send(session_t peer_id, NetworkPacket *pkt) +{ + m_clients.send(peer_id, clientCommandFactoryTable[pkt->getCommand()].channel, pkt, clientCommandFactoryTable[pkt->getCommand()].reliable); } -void Server::SendMovement(u16 peer_id) +void Server::SendMovement(session_t peer_id) { - DSTACK(FUNCTION_NAME); std::ostringstream os(std::ios_base::binary); NetworkPacket pkt(TOCLIENT_MOVEMENT, 12 * sizeof(float), peer_id); @@ -1487,39 +1415,35 @@ void Server::SendMovement(u16 peer_id) Send(&pkt); } -void Server::SendPlayerHPOrDie(PlayerSAO *playersao) +void Server::SendPlayerHPOrDie(PlayerSAO *playersao, const PlayerHPChangeReason &reason) { if (!g_settings->getBool("enable_damage")) return; - u16 peer_id = playersao->getPeerID(); + session_t peer_id = playersao->getPeerID(); bool is_alive = playersao->getHP() > 0; if (is_alive) SendPlayerHP(peer_id); else - DiePlayer(peer_id); + DiePlayer(peer_id, reason); } -void Server::SendHP(u16 peer_id, u8 hp) +void Server::SendHP(session_t peer_id, u16 hp) { - DSTACK(FUNCTION_NAME); - NetworkPacket pkt(TOCLIENT_HP, 1, peer_id); pkt << hp; Send(&pkt); } -void Server::SendBreath(u16 peer_id, u16 breath) +void Server::SendBreath(session_t peer_id, u16 breath) { - DSTACK(FUNCTION_NAME); - NetworkPacket pkt(TOCLIENT_BREATH, 2, peer_id); pkt << (u16) breath; Send(&pkt); } -void Server::SendAccessDenied(u16 peer_id, AccessDeniedCode reason, +void Server::SendAccessDenied(session_t peer_id, AccessDeniedCode reason, const std::string &custom_reason, bool reconnect) { assert(reason < SERVER_ACCESSDENIED_MAX); @@ -1534,30 +1458,24 @@ void Server::SendAccessDenied(u16 peer_id, AccessDeniedCode reason, Send(&pkt); } -void Server::SendAccessDenied_Legacy(u16 peer_id,const std::wstring &reason) +void Server::SendAccessDenied_Legacy(session_t peer_id,const std::wstring &reason) { - DSTACK(FUNCTION_NAME); - NetworkPacket pkt(TOCLIENT_ACCESS_DENIED_LEGACY, 0, peer_id); pkt << reason; Send(&pkt); } -void Server::SendDeathscreen(u16 peer_id,bool set_camera_point_target, +void Server::SendDeathscreen(session_t peer_id, bool set_camera_point_target, v3f camera_point_target) { - DSTACK(FUNCTION_NAME); - NetworkPacket pkt(TOCLIENT_DEATHSCREEN, 1 + sizeof(v3f), peer_id); pkt << set_camera_point_target << camera_point_target; Send(&pkt); } -void Server::SendItemDef(u16 peer_id, +void Server::SendItemDef(session_t peer_id, IItemDefManager *itemdef, u16 protocol_version) { - DSTACK(FUNCTION_NAME); - NetworkPacket pkt(TOCLIENT_ITEMDEF, 0, peer_id); /* @@ -1578,11 +1496,9 @@ void Server::SendItemDef(u16 peer_id, Send(&pkt); } -void Server::SendNodeDef(u16 peer_id, - INodeDefManager *nodedef, u16 protocol_version) +void Server::SendNodeDef(session_t peer_id, + const NodeDefManager *nodedef, u16 protocol_version) { - DSTACK(FUNCTION_NAME); - NetworkPacket pkt(TOCLIENT_NODEDEF, 0, peer_id); /* @@ -1610,8 +1526,6 @@ void Server::SendNodeDef(u16 peer_id, void Server::SendInventory(PlayerSAO* playerSAO) { - DSTACK(FUNCTION_NAME); - UpdateCrafting(playerSAO->getPlayer()); /* @@ -1629,31 +1543,34 @@ void Server::SendInventory(PlayerSAO* playerSAO) Send(&pkt); } -void Server::SendChatMessage(u16 peer_id, const std::wstring &message) +void Server::SendChatMessage(session_t peer_id, const ChatMessage &message) { - DSTACK(FUNCTION_NAME); - NetworkPacket pkt(TOCLIENT_CHAT_MESSAGE, 0, peer_id); - pkt << message; + u8 version = 1; + u8 type = message.type; + pkt << version << type << std::wstring(L"") << message.message << message.timestamp; if (peer_id != PEER_ID_INEXISTENT) { + RemotePlayer *player = m_env->getPlayer(peer_id); + if (!player) + return; + Send(&pkt); - } - else { - m_clients.sendToAll(0, &pkt, true); + } else { + m_clients.sendToAll(&pkt); } } -void Server::SendShowFormspecMessage(u16 peer_id, const std::string &formspec, +void Server::SendShowFormspecMessage(session_t peer_id, const std::string &formspec, const std::string &formname) { - DSTACK(FUNCTION_NAME); - NetworkPacket pkt(TOCLIENT_SHOW_FORMSPEC, 0 , peer_id); - if (formspec == "" ){ + if (formspec.empty()){ //the client should close the formspec + m_formspec_state_data.erase(peer_id); pkt.putLongString(""); } else { + m_formspec_state_data[peer_id] = formname; pkt.putLongString(FORMSPEC_VERSION_STRING + formspec); } pkt << formname; @@ -1662,22 +1579,33 @@ void Server::SendShowFormspecMessage(u16 peer_id, const std::string &formspec, } // Spawns a particle on peer with peer_id -void Server::SendSpawnParticle(u16 peer_id, u16 protocol_version, +void Server::SendSpawnParticle(session_t peer_id, u16 protocol_version, v3f pos, v3f velocity, v3f acceleration, float expirationtime, float size, bool collisiondetection, bool collision_removal, bool vertical, const std::string &texture, const struct TileAnimationParams &animation, u8 glow) { - DSTACK(FUNCTION_NAME); + static thread_local const float radius = + g_settings->getS16("max_block_send_distance") * MAP_BLOCKSIZE * BS; + if (peer_id == PEER_ID_INEXISTENT) { - // This sucks and should be replaced by a better solution in a refactor: - std::vector clients = m_clients.getClientIDs(); - for (std::vector::iterator i = clients.begin(); i != clients.end(); ++i) { - RemotePlayer *player = m_env->getPlayer(*i); + std::vector clients = m_clients.getClientIDs(); + + for (const session_t client_id : clients) { + RemotePlayer *player = m_env->getPlayer(client_id); if (!player) continue; - SendSpawnParticle(*i, player->protocol_version, + + PlayerSAO *sao = player->getPlayerSAO(); + if (!sao) + continue; + + // Do not send to distant clients + if (sao->getBasePosition().getDistanceFrom(pos * BS) > radius) + continue; + + SendSpawnParticle(client_id, player->protocol_version, pos, velocity, acceleration, expirationtime, size, collisiondetection, collision_removal, vertical, texture, animation, glow); @@ -1702,22 +1630,21 @@ void Server::SendSpawnParticle(u16 peer_id, u16 protocol_version, } // Adds a ParticleSpawner on peer with peer_id -void Server::SendAddParticleSpawner(u16 peer_id, u16 protocol_version, +void Server::SendAddParticleSpawner(session_t peer_id, u16 protocol_version, u16 amount, float spawntime, v3f minpos, v3f maxpos, v3f minvel, v3f maxvel, v3f minacc, v3f maxacc, float minexptime, float maxexptime, float minsize, float maxsize, bool collisiondetection, bool collision_removal, u16 attached_id, bool vertical, const std::string &texture, u32 id, const struct TileAnimationParams &animation, u8 glow) { - DSTACK(FUNCTION_NAME); if (peer_id == PEER_ID_INEXISTENT) { // This sucks and should be replaced: - std::vector clients = m_clients.getClientIDs(); - for (std::vector::iterator i = clients.begin(); i != clients.end(); ++i) { - RemotePlayer *player = m_env->getPlayer(*i); + std::vector clients = m_clients.getClientIDs(); + for (const session_t client_id : clients) { + RemotePlayer *player = m_env->getPlayer(client_id); if (!player) continue; - SendAddParticleSpawner(*i, player->protocol_version, + SendAddParticleSpawner(client_id, player->protocol_version, amount, spawntime, minpos, maxpos, minvel, maxvel, minacc, maxacc, minexptime, maxexptime, minsize, maxsize, collisiondetection, collision_removal, @@ -1746,25 +1673,21 @@ void Server::SendAddParticleSpawner(u16 peer_id, u16 protocol_version, Send(&pkt); } -void Server::SendDeleteParticleSpawner(u16 peer_id, u32 id) +void Server::SendDeleteParticleSpawner(session_t peer_id, u32 id) { - DSTACK(FUNCTION_NAME); - - NetworkPacket pkt(TOCLIENT_DELETE_PARTICLESPAWNER_LEGACY, 2, peer_id); + NetworkPacket pkt(TOCLIENT_DELETE_PARTICLESPAWNER, 4, peer_id); // Ugly error in this packet - pkt << (u16) id; + pkt << id; - if (peer_id != PEER_ID_INEXISTENT) { + if (peer_id != PEER_ID_INEXISTENT) Send(&pkt); - } - else { - m_clients.sendToAll(0, &pkt, true); - } + else + m_clients.sendToAll(&pkt); } -void Server::SendHUDAdd(u16 peer_id, u32 id, HudElement *form) +void Server::SendHUDAdd(session_t peer_id, u32 id, HudElement *form) { NetworkPacket pkt(TOCLIENT_HUDADD, 0 , peer_id); @@ -1775,14 +1698,14 @@ void Server::SendHUDAdd(u16 peer_id, u32 id, HudElement *form) Send(&pkt); } -void Server::SendHUDRemove(u16 peer_id, u32 id) +void Server::SendHUDRemove(session_t peer_id, u32 id) { NetworkPacket pkt(TOCLIENT_HUDRM, 4, peer_id); pkt << id; Send(&pkt); } -void Server::SendHUDChange(u16 peer_id, u32 id, HudElementStat stat, void *value) +void Server::SendHUDChange(session_t peer_id, u32 id, HudElementStat stat, void *value) { NetworkPacket pkt(TOCLIENT_HUDCHANGE, 0, peer_id); pkt << id << (u8) stat; @@ -1815,7 +1738,7 @@ void Server::SendHUDChange(u16 peer_id, u32 id, HudElementStat stat, void *value Send(&pkt); } -void Server::SendHUDSetFlags(u16 peer_id, u32 flags, u32 mask) +void Server::SendHUDSetFlags(session_t peer_id, u32 flags, u32 mask) { NetworkPacket pkt(TOCLIENT_HUD_SET_FLAGS, 4 + 4, peer_id); @@ -1826,26 +1749,37 @@ void Server::SendHUDSetFlags(u16 peer_id, u32 flags, u32 mask) Send(&pkt); } -void Server::SendHUDSetParam(u16 peer_id, u16 param, const std::string &value) +void Server::SendHUDSetParam(session_t peer_id, u16 param, const std::string &value) { NetworkPacket pkt(TOCLIENT_HUD_SET_PARAM, 0, peer_id); pkt << param << value; Send(&pkt); } -void Server::SendSetSky(u16 peer_id, const video::SColor &bgcolor, - const std::string &type, const std::vector ¶ms) +void Server::SendSetSky(session_t peer_id, const video::SColor &bgcolor, + const std::string &type, const std::vector ¶ms, + bool &clouds) { NetworkPacket pkt(TOCLIENT_SET_SKY, 0, peer_id); pkt << bgcolor << type << (u16) params.size(); - for(size_t i=0; iplayer_event(sao, "breath_changed"); SendBreath(sao->getPeerID(), sao->getBreath()); } -void Server::SendMovePlayer(u16 peer_id) +void Server::SendMovePlayer(session_t peer_id) { - DSTACK(FUNCTION_NAME); RemotePlayer *player = m_env->getPlayer(peer_id); assert(player); PlayerSAO *sao = player->getPlayerSAO(); @@ -1921,7 +1850,8 @@ void Server::SendMovePlayer(u16 peer_id) Send(&pkt); } -void Server::SendLocalPlayerAnimations(u16 peer_id, v2s32 animation_frames[4], f32 animation_speed) +void Server::SendLocalPlayerAnimations(session_t peer_id, v2s32 animation_frames[4], + f32 animation_speed) { NetworkPacket pkt(TOCLIENT_LOCAL_PLAYER_ANIMATIONS, 0, peer_id); @@ -1932,17 +1862,18 @@ void Server::SendLocalPlayerAnimations(u16 peer_id, v2s32 animation_frames[4], f Send(&pkt); } -void Server::SendEyeOffset(u16 peer_id, v3f first, v3f third) +void Server::SendEyeOffset(session_t peer_id, v3f first, v3f third) { NetworkPacket pkt(TOCLIENT_EYE_OFFSET, 0, peer_id); pkt << first << third; Send(&pkt); } -void Server::SendPlayerPrivileges(u16 peer_id) + +void Server::SendPlayerPrivileges(session_t peer_id) { RemotePlayer *player = m_env->getPlayer(peer_id); assert(player); - if(player->peer_id == PEER_ID_INEXISTENT) + if(player->getPeerId() == PEER_ID_INEXISTENT) return; std::set privs; @@ -1951,19 +1882,18 @@ void Server::SendPlayerPrivileges(u16 peer_id) NetworkPacket pkt(TOCLIENT_PRIVILEGES, 0, peer_id); pkt << (u16) privs.size(); - for(std::set::const_iterator i = privs.begin(); - i != privs.end(); ++i) { - pkt << (*i); + for (const std::string &priv : privs) { + pkt << priv; } Send(&pkt); } -void Server::SendPlayerInventoryFormspec(u16 peer_id) +void Server::SendPlayerInventoryFormspec(session_t peer_id) { RemotePlayer *player = m_env->getPlayer(peer_id); assert(player); - if(player->peer_id == PEER_ID_INEXISTENT) + if (player->getPeerId() == PEER_ID_INEXISTENT) return; NetworkPacket pkt(TOCLIENT_INVENTORY_FORMSPEC, 0, peer_id); @@ -1971,7 +1901,19 @@ void Server::SendPlayerInventoryFormspec(u16 peer_id) Send(&pkt); } -u32 Server::SendActiveObjectRemoveAdd(u16 peer_id, const std::string &datas) +void Server::SendPlayerFormspecPrepend(session_t peer_id) +{ + RemotePlayer *player = m_env->getPlayer(peer_id); + assert(player); + if (player->getPeerId() == PEER_ID_INEXISTENT) + return; + + NetworkPacket pkt(TOCLIENT_FORMSPEC_PREPEND, 0, peer_id); + pkt << FORMSPEC_VERSION_STRING + player->formspec_prepend; + Send(&pkt); +} + +u32 Server::SendActiveObjectRemoveAdd(session_t peer_id, const std::string &datas) { NetworkPacket pkt(TOCLIENT_ACTIVE_OBJECT_REMOVE_ADD, datas.size(), peer_id); pkt.putRawString(datas.c_str(), datas.size()); @@ -1979,7 +1921,8 @@ u32 Server::SendActiveObjectRemoveAdd(u16 peer_id, const std::string &datas) return pkt.getSize(); } -void Server::SendActiveObjectMessages(u16 peer_id, const std::string &datas, bool reliable) +void Server::SendActiveObjectMessages(session_t peer_id, const std::string &datas, + bool reliable) { NetworkPacket pkt(TOCLIENT_ACTIVE_OBJECT_MESSAGES, datas.size(), peer_id); @@ -1989,7 +1932,14 @@ void Server::SendActiveObjectMessages(u16 peer_id, const std::string &datas, boo m_clients.send(pkt.getPeerId(), reliable ? clientCommandFactoryTable[pkt.getCommand()].channel : 1, &pkt, reliable); +} +void Server::SendCSMRestrictionFlags(session_t peer_id) +{ + NetworkPacket pkt(TOCLIENT_CSM_RESTRICTION_FLAGS, + sizeof(m_csm_restriction_flags) + sizeof(m_csm_restriction_noderange), peer_id); + pkt << m_csm_restriction_flags << m_csm_restriction_noderange; + Send(&pkt); } s32 Server::playSound(const SimpleSoundSpec &spec, @@ -2003,27 +1953,25 @@ s32 Server::playSound(const SimpleSoundSpec &spec, return -1; // Filter destination clients - std::vector dst_clients; - if(params.to_player != "") - { + std::vector dst_clients; + if(!params.to_player.empty()) { RemotePlayer *player = m_env->getPlayer(params.to_player.c_str()); if(!player){ infostream<<"Server::playSound: Player \""<peer_id == PEER_ID_INEXISTENT){ + if (player->getPeerId() == PEER_ID_INEXISTENT) { infostream<<"Server::playSound: Player \""<peer_id); - } - else { - std::vector clients = m_clients.getClientIDs(); + dst_clients.push_back(player->getPeerId()); + } else { + std::vector clients = m_clients.getClientIDs(); - for (std::vector::iterator i = clients.begin(); i != clients.end(); ++i) { - RemotePlayer *player = m_env->getPlayer(*i); + for (const session_t client_id : clients) { + RemotePlayer *player = m_env->getPlayer(client_id); if (!player) continue; @@ -2036,7 +1984,7 @@ s32 Server::playSound(const SimpleSoundSpec &spec, params.max_hear_distance) continue; } - dst_clients.push_back(*i); + dst_clients.push_back(client_id); } } @@ -2049,22 +1997,30 @@ s32 Server::playSound(const SimpleSoundSpec &spec, m_playing_sounds[id] = ServerPlayingSound(); ServerPlayingSound &psound = m_playing_sounds[id]; psound.params = params; + psound.spec = spec; + float gain = params.gain * spec.gain; NetworkPacket pkt(TOCLIENT_PLAY_SOUND, 0); - pkt << id << spec.name << (float) (spec.gain * params.gain) - << (u8) params.type << pos << params.object << params.loop; + pkt << id << spec.name << gain + << (u8) params.type << pos << params.object + << params.loop << params.fade << params.pitch; - for(std::vector::iterator i = dst_clients.begin(); - i != dst_clients.end(); ++i) { - psound.clients.insert(*i); - m_clients.send(*i, 0, &pkt, true); + // Backwards compability + bool play_sound = gain > 0; + + for (const u16 dst_client : dst_clients) { + if (play_sound || m_clients.getProtocolVersion(dst_client) >= 32) { + psound.clients.insert(dst_client); + m_clients.send(dst_client, 0, &pkt, true); + } } return id; } void Server::stopSound(s32 handle) { // Get sound reference - UNORDERED_MAP::iterator i = m_playing_sounds.find(handle); + std::unordered_map::iterator i = + m_playing_sounds.find(handle); if (i == m_playing_sounds.end()) return; ServerPlayingSound &psound = i->second; @@ -2072,15 +2028,61 @@ void Server::stopSound(s32 handle) NetworkPacket pkt(TOCLIENT_STOP_SOUND, 4); pkt << handle; - for (UNORDERED_SET::iterator i = psound.clients.begin(); - i != psound.clients.end(); ++i) { + for (std::unordered_set::const_iterator si = psound.clients.begin(); + si != psound.clients.end(); ++si) { // Send as reliable - m_clients.send(*i, 0, &pkt, true); + m_clients.send(*si, 0, &pkt, true); } // Remove sound reference m_playing_sounds.erase(i); } +void Server::fadeSound(s32 handle, float step, float gain) +{ + // Get sound reference + std::unordered_map::iterator i = + m_playing_sounds.find(handle); + if (i == m_playing_sounds.end()) + return; + + ServerPlayingSound &psound = i->second; + psound.params.gain = gain; + + NetworkPacket pkt(TOCLIENT_FADE_SOUND, 4); + pkt << handle << step << gain; + + // Backwards compability + bool play_sound = gain > 0; + ServerPlayingSound compat_psound = psound; + compat_psound.clients.clear(); + + NetworkPacket compat_pkt(TOCLIENT_STOP_SOUND, 4); + compat_pkt << handle; + + for (std::unordered_set::iterator it = psound.clients.begin(); + it != psound.clients.end();) { + if (m_clients.getProtocolVersion(*it) >= 32) { + // Send as reliable + m_clients.send(*it, 0, &pkt, true); + ++it; + } else { + compat_psound.clients.insert(*it); + // Stop old sound + m_clients.send(*it, 0, &compat_pkt, true); + psound.clients.erase(it++); + } + } + + // Remove sound reference + if (!play_sound || psound.clients.empty()) + m_playing_sounds.erase(i); + + if (play_sound && !compat_psound.clients.empty()) { + // Play new sound volume on older clients + playSound(compat_psound.spec, compat_psound.params); + } +} + void Server::sendRemoveNode(v3s16 p, u16 ignore_id, std::vector *far_players, float far_d_nodes) { @@ -2090,11 +2092,11 @@ void Server::sendRemoveNode(v3s16 p, u16 ignore_id, NetworkPacket pkt(TOCLIENT_REMOVENODE, 6); pkt << p; - std::vector clients = m_clients.getClientIDs(); - for (std::vector::iterator i = clients.begin(); i != clients.end(); ++i) { + std::vector clients = m_clients.getClientIDs(); + for (session_t client_id : clients) { if (far_players) { // Get player - if (RemotePlayer *player = m_env->getPlayer(*i)) { + if (RemotePlayer *player = m_env->getPlayer(client_id)) { PlayerSAO *sao = player->getPlayerSAO(); if (!sao) continue; @@ -2102,14 +2104,14 @@ void Server::sendRemoveNode(v3s16 p, u16 ignore_id, // If player is far away, only set modified blocks not sent v3f player_pos = sao->getBasePosition(); if (player_pos.getDistanceFrom(p_f) > maxd) { - far_players->push_back(*i); + far_players->push_back(client_id); continue; } } } // Send as reliable - m_clients.send(*i, 0, &pkt, true); + m_clients.send(client_id, 0, &pkt, true); } } @@ -2120,11 +2122,11 @@ void Server::sendAddNode(v3s16 p, MapNode n, u16 ignore_id, float maxd = far_d_nodes*BS; v3f p_f = intToFloat(p, BS); - std::vector clients = m_clients.getClientIDs(); - for(std::vector::iterator i = clients.begin(); i != clients.end(); ++i) { + std::vector clients = m_clients.getClientIDs(); + for (const session_t client_id : clients) { if (far_players) { // Get player - if (RemotePlayer *player = m_env->getPlayer(*i)) { + if (RemotePlayer *player = m_env->getPlayer(client_id)) { PlayerSAO *sao = player->getPlayerSAO(); if (!sao) continue; @@ -2132,7 +2134,7 @@ void Server::sendAddNode(v3s16 p, MapNode n, u16 ignore_id, // If player is far away, only set modified blocks not sent v3f player_pos = sao->getBasePosition(); if(player_pos.getDistanceFrom(p_f) > maxd) { - far_players->push_back(*i); + far_players->push_back(client_id); continue; } } @@ -2140,65 +2142,40 @@ void Server::sendAddNode(v3s16 p, MapNode n, u16 ignore_id, NetworkPacket pkt(TOCLIENT_ADDNODE, 6 + 2 + 1 + 1 + 1); m_clients.lock(); - RemoteClient* client = m_clients.lockedGetClientNoEx(*i); - if (client != 0) { + RemoteClient* client = m_clients.lockedGetClientNoEx(client_id); + if (client) { pkt << p << n.param0 << n.param1 << n.param2 << (u8) (remove_metadata ? 0 : 1); - - if (!remove_metadata) { - if (client->net_proto_version <= 21) { - // Old clients always clear metadata; fix it - // by sending the full block again. - client->SetBlockNotSent(getNodeBlockPos(p)); - } - } } m_clients.unlock(); // Send as reliable if (pkt.getSize() > 0) - m_clients.send(*i, 0, &pkt, true); + m_clients.send(client_id, 0, &pkt, true); } } -void Server::setBlockNotSent(v3s16 p) +void Server::SendBlockNoLock(session_t peer_id, MapBlock *block, u8 ver, + u16 net_proto_version) { - std::vector clients = m_clients.getClientIDs(); - m_clients.lock(); - for(std::vector::iterator i = clients.begin(); - i != clients.end(); ++i) { - RemoteClient *client = m_clients.lockedGetClientNoEx(*i); - client->SetBlockNotSent(p); - } - m_clients.unlock(); -} - -void Server::SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver, u16 net_proto_version) -{ - DSTACK(FUNCTION_NAME); - - v3s16 p = block->getPos(); - /* Create a packet with the block in the right format */ std::ostringstream os(std::ios_base::binary); block->serialize(os, ver, false); - block->serializeNetworkSpecific(os, net_proto_version); + block->serializeNetworkSpecific(os); std::string s = os.str(); NetworkPacket pkt(TOCLIENT_BLOCKDATA, 2 + 2 + 2 + 2 + s.size(), peer_id); - pkt << p; + pkt << block->getPos(); pkt.putRawString(s.c_str(), s.size()); Send(&pkt); } void Server::SendBlocks(float dtime) { - DSTACK(FUNCTION_NAME); - MutexAutoLock envlock(m_env_mutex); //TODO check if one big lock could be faster then multiple small ones @@ -2206,22 +2183,21 @@ void Server::SendBlocks(float dtime) std::vector queue; - s32 total_sending = 0; + u32 total_sending = 0; { - ScopeProfiler sp(g_profiler, "Server: selecting blocks for sending"); + ScopeProfiler sp2(g_profiler, "Server: selecting blocks for sending"); - std::vector clients = m_clients.getClientIDs(); + std::vector clients = m_clients.getClientIDs(); m_clients.lock(); - for(std::vector::iterator i = clients.begin(); - i != clients.end(); ++i) { - RemoteClient *client = m_clients.lockedGetClientNoEx(*i, CS_Active); + for (const session_t client_id : clients) { + RemoteClient *client = m_clients.lockedGetClientNoEx(client_id, CS_Active); - if (client == NULL) + if (!client) continue; - total_sending += client->SendingCount(); + total_sending += client->getSendingCount(); client->GetNextBlocks(m_env,m_emerge, dtime, queue); } m_clients.unlock(); @@ -2233,33 +2209,32 @@ void Server::SendBlocks(float dtime) std::sort(queue.begin(), queue.end()); m_clients.lock(); - for(u32 i=0; i= g_settings->getS32 - ("max_simultaneous_block_sends_server_total")) - break; - PrioritySortedBlockTransfer q = queue[i]; + // Maximal total count calculation + // The per-client block sends is halved with the maximal online users + u32 max_blocks_to_send = (m_env->getPlayerCount() + g_settings->getU32("max_users")) * + g_settings->getU32("max_simultaneous_block_sends_per_client") / 4 + 1; - MapBlock *block = NULL; - try - { - block = m_env->getMap().getBlockNoCreate(q.pos); - } - catch(InvalidPositionException &e) - { + for (const PrioritySortedBlockTransfer &block_to_send : queue) { + if (total_sending >= max_blocks_to_send) + break; + + MapBlock *block = nullptr; + try { + block = m_env->getMap().getBlockNoCreate(block_to_send.pos); + } catch (const InvalidPositionException &e) { continue; } - RemoteClient *client = m_clients.lockedGetClientNoEx(q.peer_id, CS_Active); - - if(!client) + RemoteClient *client = m_clients.lockedGetClientNoEx(block_to_send.peer_id, + CS_Active); + if (!client) continue; - SendBlockNoLock(q.peer_id, block, client->serialization_version, client->net_proto_version); + SendBlockNoLock(block_to_send.peer_id, block, client->serialization_version, + client->net_proto_version); - client->SentBlock(q.pos); + client->SentBlock(block_to_send.pos); total_sending++; } m_clients.unlock(); @@ -2267,31 +2242,21 @@ void Server::SendBlocks(float dtime) void Server::fillMediaCache() { - DSTACK(FUNCTION_NAME); - infostream<<"Server: Calculating media file checksums"< paths; - for(std::vector::iterator i = m_mods.begin(); - i != m_mods.end(); ++i) { - const ModSpec &mod = *i; - paths.push_back(mod.path + DIR_DELIM + "textures"); - paths.push_back(mod.path + DIR_DELIM + "sounds"); - paths.push_back(mod.path + DIR_DELIM + "media"); - paths.push_back(mod.path + DIR_DELIM + "models"); - } - paths.push_back(porting::path_user + DIR_DELIM + "textures" + DIR_DELIM + "server"); + m_modmgr->getModsMediaPaths(paths); + fs::GetRecursiveDirs(paths, m_gamespec.path + DIR_DELIM + "textures"); + fs::GetRecursiveDirs(paths, porting::path_user + DIR_DELIM + "textures" + DIR_DELIM + "server"); // Collect media file information from paths into cache - for(std::vector::iterator i = paths.begin(); - i != paths.end(); ++i) { - std::string mediapath = *i; + for (const std::string &mediapath : paths) { std::vector dirlist = fs::GetDirListing(mediapath); - for (u32 j = 0; j < dirlist.size(); j++) { - if (dirlist[j].dir) // Ignode dirs + for (const fs::DirListNode &dln : dirlist) { + if (dln.dir) // Ignode dirs continue; - std::string filename = dirlist[j].name; + std::string filename = dln.name; // If name contains illegal characters, ignore the file if (!string_allowed(filename, TEXTURENAME_ALLOWED_CHARS)) { infostream<<"Server: ignoring illegal file name: \"" @@ -2304,15 +2269,19 @@ void Server::fillMediaCache() ".pcx", ".ppm", ".psd", ".wal", ".rgb", ".ogg", ".x", ".b3d", ".md2", ".obj", + // Custom translation file format + ".tr", NULL }; - if (removeStringEnd(filename, supported_ext) == ""){ + if (removeStringEnd(filename, supported_ext).empty()){ infostream << "Server: ignoring unsupported file extension: \"" << filename << "\"" << std::endl; continue; } // Ok, attempt to load the file and add to cache - std::string filepath = mediapath + DIR_DELIM + filename; + std::string filepath; + filepath.append(mediapath).append(DIR_DELIM).append(filename); + // Read data std::ifstream fis(filepath.c_str(), std::ios_base::binary); if (!fis.good()) { @@ -2361,22 +2330,29 @@ void Server::fillMediaCache() } } -void Server::sendMediaAnnouncement(u16 peer_id) +void Server::sendMediaAnnouncement(session_t peer_id, const std::string &lang_code) { - DSTACK(FUNCTION_NAME); - verbosestream << "Server: Announcing files to id(" << peer_id << ")" << std::endl; // Make packet - std::ostringstream os(std::ios_base::binary); - NetworkPacket pkt(TOCLIENT_ANNOUNCE_MEDIA, 0, peer_id); - pkt << (u16) m_media.size(); - for (UNORDERED_MAP::iterator i = m_media.begin(); - i != m_media.end(); ++i) { - pkt << i->first << i->second.sha1_digest; + u16 media_sent = 0; + std::string lang_suffix; + lang_suffix.append(".").append(lang_code).append(".tr"); + for (const auto &i : m_media) { + if (str_ends_with(i.first, ".tr") && !str_ends_with(i.first, lang_suffix)) + continue; + media_sent++; + } + + pkt << media_sent; + + for (const auto &i : m_media) { + if (str_ends_with(i.first, ".tr") && !str_ends_with(i.first, lang_suffix)) + continue; + pkt << i.first << i.second.sha1_digest; } pkt << g_settings->get("remote_media"); @@ -2397,11 +2373,9 @@ struct SendableMedia {} }; -void Server::sendRequestedMedia(u16 peer_id, +void Server::sendRequestedMedia(session_t peer_id, const std::vector &tosend) { - DSTACK(FUNCTION_NAME); - verbosestream<<"Server::sendRequestedMedia(): " <<"Sending files to client"< > file_bunches; - file_bunches.push_back(std::vector()); + file_bunches.emplace_back(); u32 file_size_bunch_total = 0; - for(std::vector::const_iterator i = tosend.begin(); - i != tosend.end(); ++i) { - const std::string &name = *i; - + for (const std::string &name : tosend) { if (m_media.find(name) == m_media.end()) { errorstream<<"Server::sendRequestedMedia(): Client asked for " <<"unknown file \""<<(name)<<"\""<= bytes_per_bunch) { - file_bunches.push_back(std::vector()); + file_bunches.emplace_back(); file_size_bunch_total = 0; } @@ -2472,7 +2442,7 @@ void Server::sendRequestedMedia(u16 peer_id, /* Create and send packets */ u16 num_bunches = file_bunches.size(); - for(u16 i = 0; i < num_bunches; i++) { + for (u16 i = 0; i < num_bunches; i++) { /* u16 command u16 total number of texture bunches @@ -2489,11 +2459,9 @@ void Server::sendRequestedMedia(u16 peer_id, NetworkPacket pkt(TOCLIENT_MEDIA, 4 + 0, peer_id); pkt << num_bunches << i << (u32) file_bunches[i].size(); - for(std::vector::iterator - j = file_bunches[i].begin(); - j != file_bunches[i].end(); ++j) { - pkt << j->name; - pkt.putLongString(j->data); + for (const SendableMedia &j : file_bunches[i]) { + pkt << j.name; + pkt.putLongString(j.data); } verbosestream << "Server::sendRequestedMedia(): bunch " @@ -2504,7 +2472,7 @@ void Server::sendRequestedMedia(u16 peer_id, } } -void Server::sendDetachedInventory(const std::string &name, u16 peer_id) +void Server::sendDetachedInventory(const std::string &name, session_t peer_id) { if(m_detached_inventories.count(name) == 0) { errorstream<getPlayer(check.c_str()); if (p) - m_clients.send(p->peer_id, 0, &pkt, true); + m_clients.send(p->getPeerId(), 0, &pkt, true); } else { - if (check == "" || getPlayerName(peer_id) == check) + if (check.empty() || getPlayerName(peer_id) == check) Send(&pkt); } } -void Server::sendDetachedInventories(u16 peer_id) +void Server::sendDetachedInventories(session_t peer_id) { - DSTACK(FUNCTION_NAME); - - for(std::map::iterator - i = m_detached_inventories.begin(); - i != m_detached_inventories.end(); ++i) { - const std::string &name = i->first; + for (const auto &detached_inventory : m_detached_inventories) { + const std::string &name = detached_inventory.first; //Inventory *inv = i->second; sendDetachedInventory(name, peer_id); } @@ -2552,9 +2516,8 @@ void Server::sendDetachedInventories(u16 peer_id) Something random */ -void Server::DiePlayer(u16 peer_id) +void Server::DiePlayer(session_t peer_id, const PlayerHPChangeReason &reason) { - DSTACK(FUNCTION_NAME); PlayerSAO *playersao = getPlayerSAO(peer_id); // In some rare cases this can be NULL -- if the player is disconnected // when a Lua function modifies l_punch, for example @@ -2565,19 +2528,18 @@ void Server::DiePlayer(u16 peer_id) << playersao->getPlayer()->getName() << " dies" << std::endl; - playersao->setHP(0); + playersao->setHP(0, reason); + playersao->clearParentAttachment(); // Trigger scripted stuff - m_script->on_dieplayer(playersao); + m_script->on_dieplayer(playersao, reason); SendPlayerHP(peer_id); SendDeathscreen(peer_id, false, v3f(0,0,0)); } -void Server::RespawnPlayer(u16 peer_id) +void Server::RespawnPlayer(session_t peer_id) { - DSTACK(FUNCTION_NAME); - PlayerSAO *playersao = getPlayerSAO(peer_id); assert(playersao); @@ -2585,70 +2547,62 @@ void Server::RespawnPlayer(u16 peer_id) << playersao->getPlayer()->getName() << " respawns" << std::endl; - playersao->setHP(PLAYER_MAX_HP); - playersao->setBreath(PLAYER_MAX_BREATH); + playersao->setHP(playersao->accessObjectProperties()->hp_max, + PlayerHPChangeReason(PlayerHPChangeReason::RESPAWN)); + playersao->setBreath(playersao->accessObjectProperties()->breath_max); bool repositioned = m_script->on_respawnplayer(playersao); if (!repositioned) { - v3f pos = findSpawnPos(); // setPos will send the new position to client - playersao->setPos(pos); + playersao->setPos(findSpawnPos()); } SendPlayerHP(peer_id); } -void Server::DenySudoAccess(u16 peer_id) +void Server::DenySudoAccess(session_t peer_id) { - DSTACK(FUNCTION_NAME); - NetworkPacket pkt(TOCLIENT_DENY_SUDO_MODE, 0, peer_id); Send(&pkt); } -void Server::DenyAccessVerCompliant(u16 peer_id, u16 proto_ver, AccessDeniedCode reason, +void Server::DenyAccessVerCompliant(session_t peer_id, u16 proto_ver, AccessDeniedCode reason, const std::string &str_reason, bool reconnect) { - if (proto_ver >= 25) { - SendAccessDenied(peer_id, reason, str_reason, reconnect); - } else { - std::wstring wreason = utf8_to_wide( - reason == SERVER_ACCESSDENIED_CUSTOM_STRING ? str_reason : - accessDeniedStrings[(u8)reason]); - SendAccessDenied_Legacy(peer_id, wreason); - } + SendAccessDenied(peer_id, reason, str_reason, reconnect); m_clients.event(peer_id, CSE_SetDenied); - m_con.DisconnectPeer(peer_id); + DisconnectPeer(peer_id); } -void Server::DenyAccess(u16 peer_id, AccessDeniedCode reason, const std::string &custom_reason) +void Server::DenyAccess(session_t peer_id, AccessDeniedCode reason, + const std::string &custom_reason) { - DSTACK(FUNCTION_NAME); - SendAccessDenied(peer_id, reason, custom_reason); m_clients.event(peer_id, CSE_SetDenied); - m_con.DisconnectPeer(peer_id); + DisconnectPeer(peer_id); } // 13/03/15: remove this function when protocol version 25 will become // the minimum version for MT users, maybe in 1 year -void Server::DenyAccess_Legacy(u16 peer_id, const std::wstring &reason) +void Server::DenyAccess_Legacy(session_t peer_id, const std::wstring &reason) { - DSTACK(FUNCTION_NAME); - SendAccessDenied_Legacy(peer_id, reason); m_clients.event(peer_id, CSE_SetDenied); - m_con.DisconnectPeer(peer_id); + DisconnectPeer(peer_id); } -void Server::acceptAuth(u16 peer_id, bool forSudoMode) +void Server::DisconnectPeer(session_t peer_id) { - DSTACK(FUNCTION_NAME); + m_modchannel_mgr->leaveAllChannels(peer_id); + m_con->DisconnectPeer(peer_id); +} +void Server::acceptAuth(session_t peer_id, bool forSudoMode) +{ if (!forSudoMode) { RemoteClient* client = getClient(peer_id, CS_Invalid); @@ -2676,15 +2630,14 @@ void Server::acceptAuth(u16 peer_id, bool forSudoMode) } } -void Server::DeleteClient(u16 peer_id, ClientDeletionReason reason) +void Server::DeleteClient(session_t peer_id, ClientDeletionReason reason) { - DSTACK(FUNCTION_NAME); std::wstring message; { /* Clear references to playing sounds */ - for (UNORDERED_MAP::iterator + for (std::unordered_map::iterator i = m_playing_sounds.begin(); i != m_playing_sounds.end();) { ServerPlayingSound &psound = i->second; psound.clients.erase(peer_id); @@ -2694,13 +2647,25 @@ void Server::DeleteClient(u16 peer_id, ClientDeletionReason reason) ++i; } + // clear formspec info so the next client can't abuse the current state + m_formspec_state_data.erase(peer_id); + RemotePlayer *player = m_env->getPlayer(peer_id); /* Run scripts and remove from environment */ - if (player != NULL) { + if (player) { PlayerSAO *playersao = player->getPlayerSAO(); assert(playersao); + playersao->clearChildAttachments(); + playersao->clearParentAttachment(); + + // inform connected clients + NetworkPacket notice(TOCLIENT_UPDATE_PLAYER_LIST, 0, PEER_ID_INEXISTENT); + // (u16) 1 + std::string represents a vector serialization representation + notice << (u8) PLAYER_LIST_REMOVE << (u16) 1 << std::string(playersao->getPlayer()->getName()); + m_clients.sendToAll(¬ice); + // run scripts m_script->on_leaveplayer(playersao, reason == CDR_TIMEOUT); playersao->disconnected(); @@ -2710,14 +2675,13 @@ void Server::DeleteClient(u16 peer_id, ClientDeletionReason reason) Print out action */ { - if(player != NULL && reason != CDR_DENY) { + if (player && reason != CDR_DENY) { std::ostringstream os(std::ios_base::binary); - std::vector clients = m_clients.getClientIDs(); + std::vector clients = m_clients.getClientIDs(); - for(std::vector::iterator i = clients.begin(); - i != clients.end(); ++i) { + for (const session_t client_id : clients) { // Get player - RemotePlayer *player = m_env->getPlayer(*i); + RemotePlayer *player = m_env->getPlayer(client_id); if (!player) continue; @@ -2741,13 +2705,17 @@ void Server::DeleteClient(u16 peer_id, ClientDeletionReason reason) } // Send leave chat message to all remaining clients - if(message.length() != 0) - SendChatMessage(PEER_ID_INEXISTENT,message); + if (!message.empty()) { + SendChatMessage(PEER_ID_INEXISTENT, + ChatMessage(CHATMESSAGE_TYPE_ANNOUNCE, message)); + } } void Server::UpdateCrafting(RemotePlayer *player) { - DSTACK(FUNCTION_NAME); + InventoryList *clist = player->inventory.getList("craft"); + if (!clist || clist->getSize() == 0) + return; // Get a preview for crafting ItemStack preview; @@ -2756,13 +2724,13 @@ void Server::UpdateCrafting(RemotePlayer *player) std::vector output_replacements; getCraftingResult(&player->inventory, preview, output_replacements, false, this); m_env->getScriptIface()->item_CraftPredict(preview, player->getPlayerSAO(), - (&player->inventory)->getList("craft"), loc); + clist, loc); - // Put the new preview in InventoryList *plist = player->inventory.getList("craftpreview"); - sanity_check(plist); - sanity_check(plist->getSize() >= 1); - plist->changeItem(0, preview); + if (plist && plist->getSize() >= 1) { + // Put the new preview in + plist->changeItem(0, preview); + } } void Server::handleChatInterfaceEvent(ChatEvent *evt) @@ -2785,12 +2753,15 @@ void Server::handleChatInterfaceEvent(ChatEvent *evt) } std::wstring Server::handleChat(const std::string &name, const std::wstring &wname, - const std::wstring &wmessage, bool check_shout_priv, RemotePlayer *player) + std::wstring wmessage, bool check_shout_priv, RemotePlayer *player) { // If something goes wrong, this player is to blame RollbackScopeActor rollback_scope(m_rollback, std::string("player:") + name); + if (g_settings->getBool("strip_color_codes")) + wmessage = unescape_enriched(wmessage); + if (player) { switch (player->canSendChatMessage()) { case RPLAYER_CHATRESULT_FLOODING: { @@ -2801,7 +2772,7 @@ std::wstring Server::handleChat(const std::string &name, const std::wstring &wna return ws.str(); } case RPLAYER_CHATRESULT_KICK: - DenyAccess_Legacy(player->peer_id, + DenyAccess_Legacy(player->getPeerId(), L"You have been kicked due to message flooding."); return L""; case RPLAYER_CHATRESULT_OK: @@ -2826,54 +2797,43 @@ std::wstring Server::handleChat(const std::string &name, const std::wstring &wna // Whether to send line to the player that sent the message, or to all players bool broadcast_line = true; - // Commands are implemented in Lua, so only catch invalid - // commands that were not "eaten" and send an error back - if (wmessage[0] == L'/') { - std::wstring wcmd = wmessage.substr(1); + if (check_shout_priv && !checkPriv(name, "shout")) { + line += L"-!- You don't have permission to shout."; broadcast_line = false; - if (wcmd.length() == 0) - line += L"-!- Empty command"; - else - line += L"-!- Invalid command: " + str_split(wcmd, L' ')[0]; } else { - if (check_shout_priv && !checkPriv(name, "shout")) { - line += L"-!- You don't have permission to shout."; - broadcast_line = false; - } else { - line += L"<"; - line += wname; - line += L"> "; - line += wmessage; - } + line += L"<"; + line += wname; + line += L"> "; + line += wmessage; } /* Tell calling method to send the message to sender */ - if (!broadcast_line) { + if (!broadcast_line) return line; - } else { - /* - Send the message to others - */ - actionstream << "CHAT: " << wide_to_narrow(line) << std::endl; - std::vector clients = m_clients.getClientIDs(); + /* + Send the message to others + */ + actionstream << "CHAT: " << wide_to_narrow(unescape_enriched(line)) << std::endl; - /* - Send the message back to the inital sender - if they are using protocol version >= 29 - */ + std::vector clients = m_clients.getClientIDs(); + + /* + Send the message back to the inital sender + if they are using protocol version >= 29 + */ - u16 peer_id_to_avoid_sending = (player ? player->peer_id : PEER_ID_INEXISTENT); - if (player && player->protocol_version >= 29) - peer_id_to_avoid_sending = PEER_ID_INEXISTENT; + session_t peer_id_to_avoid_sending = + (player ? player->getPeerId() : PEER_ID_INEXISTENT); - for (u16 i = 0; i < clients.size(); i++) { - u16 cid = clients[i]; - if (cid != peer_id_to_avoid_sending) - SendChatMessage(cid, line); - } + if (player && player->protocol_version >= 29) + peer_id_to_avoid_sending = PEER_ID_INEXISTENT; + + for (u16 cid : clients) { + if (cid != peer_id_to_avoid_sending) + SendChatMessage(cid, ChatMessage(line)); } return L""; } @@ -2892,7 +2852,7 @@ void Server::handleAdminChat(const ChatEventChat *evt) } } -RemoteClient* Server::getClient(u16 peer_id, ClientState state_min) +RemoteClient *Server::getClient(session_t peer_id, ClientState state_min) { RemoteClient *client = getClientNoEx(peer_id,state_min); if(!client) @@ -2900,23 +2860,23 @@ RemoteClient* Server::getClient(u16 peer_id, ClientState state_min) return client; } -RemoteClient* Server::getClientNoEx(u16 peer_id, ClientState state_min) +RemoteClient *Server::getClientNoEx(session_t peer_id, ClientState state_min) { return m_clients.getClientNoEx(peer_id, state_min); } -std::string Server::getPlayerName(u16 peer_id) +std::string Server::getPlayerName(session_t peer_id) { RemotePlayer *player = m_env->getPlayer(peer_id); - if (player == NULL) + if (!player) return "[id="+itos(peer_id)+"]"; return player->getName(); } -PlayerSAO* Server::getPlayerSAO(u16 peer_id) +PlayerSAO *Server::getPlayerSAO(session_t peer_id) { RemotePlayer *player = m_env->getPlayer(peer_id); - if (player == NULL) + if (!player) return NULL; return player->getPlayerSAO(); } @@ -2934,13 +2894,13 @@ std::wstring Server::getStatusString() // Information about clients bool first = true; os< clients = m_clients.getClientIDs(); - for (std::vector::iterator i = clients.begin(); i != clients.end(); ++i) { + std::vector clients = m_clients.getClientIDs(); + for (session_t client_id : clients) { // Get player - RemotePlayer *player = m_env->getPlayer(*i); + RemotePlayer *player = m_env->getPlayer(client_id); // Get name of player std::wstring name = L"unknown"; - if (player != NULL) + if (player) name = narrow_to_wide(player->getName()); // Add name to information string if(!first) @@ -2950,9 +2910,11 @@ std::wstring Server::getStatusString() os << name; } os << L"}"; - if(((ServerMap*)(&m_env->getMap()))->isSavingEnabled() == false) + + if (!((ServerMap*)(&m_env->getMap()))->isSavingEnabled()) os<get("motd") != "") + + if (!g_settings->get("motd").empty()) os<get("motd")); return os.str(); } @@ -2972,18 +2934,17 @@ bool Server::checkPriv(const std::string &name, const std::string &priv) void Server::reportPrivsModified(const std::string &name) { - if(name == "") { - std::vector clients = m_clients.getClientIDs(); - for(std::vector::iterator i = clients.begin(); - i != clients.end(); ++i) { - RemotePlayer *player = m_env->getPlayer(*i); + if (name.empty()) { + std::vector clients = m_clients.getClientIDs(); + for (const session_t client_id : clients) { + RemotePlayer *player = m_env->getPlayer(client_id); reportPrivsModified(player->getName()); } } else { RemotePlayer *player = m_env->getPlayer(name.c_str()); if (!player) return; - SendPlayerPrivileges(player->peer_id); + SendPlayerPrivileges(player->getPeerId()); PlayerSAO *sao = player->getPlayerSAO(); if(!sao) return; @@ -2998,7 +2959,15 @@ void Server::reportInventoryFormspecModified(const std::string &name) RemotePlayer *player = m_env->getPlayer(name.c_str()); if (!player) return; - SendPlayerInventoryFormspec(player->peer_id); + SendPlayerInventoryFormspec(player->getPeerId()); +} + +void Server::reportFormspecPrependModified(const std::string &name) +{ + RemotePlayer *player = m_env->getPlayer(name.c_str()); + if (!player) + return; + SendPlayerFormspecPrepend(player->getPeerId()); } void Server::setIpBanned(const std::string &ip, const std::string &name) @@ -3031,10 +3000,10 @@ void Server::notifyPlayer(const char *name, const std::wstring &msg) return; } - if (player->peer_id == PEER_ID_INEXISTENT) + if (player->getPeerId() == PEER_ID_INEXISTENT) return; - SendChatMessage(player->peer_id, msg); + SendChatMessage(player->getPeerId(), ChatMessage(msg)); } bool Server::showFormspec(const char *playername, const std::string &formspec, @@ -3048,7 +3017,7 @@ bool Server::showFormspec(const char *playername, const std::string &formspec, if (!player) return false; - SendShowFormspecMessage(player->peer_id, formspec, formname); + SendShowFormspecMessage(player->getPeerId(), formspec, formname); return true; } @@ -3059,7 +3028,7 @@ u32 Server::hudAdd(RemotePlayer *player, HudElement *form) u32 id = player->addHud(form); - SendHUDAdd(player->peer_id, id, form); + SendHUDAdd(player->getPeerId(), id, form); return id; } @@ -3075,7 +3044,7 @@ bool Server::hudRemove(RemotePlayer *player, u32 id) { delete todel; - SendHUDRemove(player->peer_id, id); + SendHUDRemove(player->getPeerId(), id); return true; } @@ -3084,7 +3053,7 @@ bool Server::hudChange(RemotePlayer *player, u32 id, HudElementStat stat, void * if (!player) return false; - SendHUDChange(player->peer_id, id, stat, data); + SendHUDChange(player->getPeerId(), id, stat, data); return true; } @@ -3093,13 +3062,13 @@ bool Server::hudSetFlags(RemotePlayer *player, u32 flags, u32 mask) if (!player) return false; - SendHUDSetFlags(player->peer_id, flags, mask); + SendHUDSetFlags(player->getPeerId(), flags, mask); player->hud_flags &= ~mask; player->hud_flags |= flags; PlayerSAO* playersao = player->getPlayerSAO(); - if (playersao == NULL) + if (!playersao) return false; m_script->player_event(playersao, "hud_changed"); @@ -3117,7 +3086,7 @@ bool Server::hudSetHotbarItemcount(RemotePlayer *player, s32 hotbar_itemcount) player->setHotbarItemcount(hotbar_itemcount); std::ostringstream os(std::ios::binary); writeS32(os, hotbar_itemcount); - SendHUDSetParam(player->peer_id, HUD_PARAM_HOTBAR_ITEMCOUNT, os.str()); + SendHUDSetParam(player->getPeerId(), HUD_PARAM_HOTBAR_ITEMCOUNT, os.str()); return true; } @@ -3127,14 +3096,7 @@ void Server::hudSetHotbarImage(RemotePlayer *player, std::string name) return; player->setHotbarImage(name); - SendHUDSetParam(player->peer_id, HUD_PARAM_HOTBAR_IMAGE, name); -} - -std::string Server::hudGetHotbarImage(RemotePlayer *player) -{ - if (!player) - return ""; - return player->getHotbarImage(); + SendHUDSetParam(player->getPeerId(), HUD_PARAM_HOTBAR_IMAGE, name); } void Server::hudSetHotbarSelectedImage(RemotePlayer *player, std::string name) @@ -3143,40 +3105,44 @@ void Server::hudSetHotbarSelectedImage(RemotePlayer *player, std::string name) return; player->setHotbarSelectedImage(name); - SendHUDSetParam(player->peer_id, HUD_PARAM_HOTBAR_SELECTED_IMAGE, name); + SendHUDSetParam(player->getPeerId(), HUD_PARAM_HOTBAR_SELECTED_IMAGE, name); } -bool Server::setLocalPlayerAnimations(RemotePlayer *player, - v2s32 animation_frames[4], f32 frame_speed) +Address Server::getPeerAddress(session_t peer_id) { - if (!player) - return false; + return m_con->GetPeerAddress(peer_id); +} +void Server::setLocalPlayerAnimations(RemotePlayer *player, + v2s32 animation_frames[4], f32 frame_speed) +{ + sanity_check(player); player->setLocalAnimations(animation_frames, frame_speed); - SendLocalPlayerAnimations(player->peer_id, animation_frames, frame_speed); - return true; + SendLocalPlayerAnimations(player->getPeerId(), animation_frames, frame_speed); } -bool Server::setPlayerEyeOffset(RemotePlayer *player, v3f first, v3f third) +void Server::setPlayerEyeOffset(RemotePlayer *player, const v3f &first, const v3f &third) { - if (!player) - return false; - + sanity_check(player); player->eye_offset_first = first; player->eye_offset_third = third; - SendEyeOffset(player->peer_id, first, third); - return true; + SendEyeOffset(player->getPeerId(), first, third); } -bool Server::setSky(RemotePlayer *player, const video::SColor &bgcolor, - const std::string &type, const std::vector ¶ms) +void Server::setSky(RemotePlayer *player, const video::SColor &bgcolor, + const std::string &type, const std::vector ¶ms, + bool &clouds) { - if (!player) - return false; + sanity_check(player); + player->setSky(bgcolor, type, params, clouds); + SendSetSky(player->getPeerId(), bgcolor, type, params, clouds); +} - player->setSky(bgcolor, type, params); - SendSetSky(player->peer_id, bgcolor, type, params); - return true; +void Server::setClouds(RemotePlayer *player, const CloudParams ¶ms) +{ + sanity_check(player); + player->setCloudParams(params); + SendCloudParams(player->getPeerId(), params); } bool Server::overrideDayNightRatio(RemotePlayer *player, bool do_override, @@ -3186,13 +3152,13 @@ bool Server::overrideDayNightRatio(RemotePlayer *player, bool do_override, return false; player->overrideDayNightRatio(do_override, ratio); - SendOverrideDayNightRatio(player->peer_id, do_override, ratio); + SendOverrideDayNightRatio(player->getPeerId(), do_override, ratio); return true; } void Server::notifyPlayers(const std::wstring &msg) { - SendChatMessage(PEER_ID_INEXISTENT,msg); + SendChatMessage(PEER_ID_INEXISTENT, ChatMessage(msg)); } void Server::spawnParticle(const std::string &playername, v3f pos, @@ -3206,12 +3172,13 @@ void Server::spawnParticle(const std::string &playername, v3f pos, if (!m_env) return; - u16 peer_id = PEER_ID_INEXISTENT, proto_ver = 0; - if (playername != "") { + session_t peer_id = PEER_ID_INEXISTENT; + u16 proto_ver = 0; + if (!playername.empty()) { RemotePlayer *player = m_env->getPlayer(playername.c_str()); if (!player) return; - peer_id = player->peer_id; + peer_id = player->getPeerId(); proto_ver = player->protocol_version; } @@ -3232,12 +3199,13 @@ u32 Server::addParticleSpawner(u16 amount, float spawntime, if (!m_env) return -1; - u16 peer_id = PEER_ID_INEXISTENT, proto_ver = 0; - if (playername != "") { + session_t peer_id = PEER_ID_INEXISTENT; + u16 proto_ver = 0; + if (!playername.empty()) { RemotePlayer *player = m_env->getPlayer(playername.c_str()); if (!player) return -1; - peer_id = player->peer_id; + peer_id = player->getPeerId(); proto_ver = player->protocol_version; } @@ -3264,12 +3232,12 @@ void Server::deleteParticleSpawner(const std::string &playername, u32 id) if (!m_env) throw ServerError("Can't delete particle spawners during initialisation!"); - u16 peer_id = PEER_ID_INEXISTENT; - if (playername != "") { + session_t peer_id = PEER_ID_INEXISTENT; + if (!playername.empty()) { RemotePlayer *player = m_env->getPlayer(playername.c_str()); if (!player) return; - peer_id = player->peer_id; + peer_id = player->getPeerId(); } m_env->deleteParticleSpawner(id); @@ -3302,7 +3270,8 @@ bool Server::rollbackRevertActions(const std::list &actions, ServerMap *map = (ServerMap*)(&m_env->getMap()); // Fail if no actions to handle - if(actions.empty()){ + if (actions.empty()) { + assert(log); log->push_back("Nothing to do."); return false; } @@ -3310,11 +3279,7 @@ bool Server::rollbackRevertActions(const std::list &actions, int num_tried = 0; int num_failed = 0; - for(std::list::const_iterator - i = actions.begin(); - i != actions.end(); ++i) - { - const RollbackAction &action = *i; + for (const RollbackAction &action : actions) { num_tried++; bool success = action.applyRevert(map, this, this); if(!success){ @@ -3322,13 +3287,13 @@ bool Server::rollbackRevertActions(const std::list &actions, std::ostringstream os; os<<"Revert of step ("<push_back(os.str()); }else{ std::ostringstream os; os<<"Successfully reverted step ("<push_back(os.str()); } } @@ -3347,7 +3312,7 @@ IItemDefManager *Server::getItemDefManager() return m_itemdef; } -INodeDefManager *Server::getNodeDefManager() +const NodeDefManager *Server::getNodeDefManager() { return m_nodedef; } @@ -3362,17 +3327,12 @@ u16 Server::allocateUnknownNodeId(const std::string &name) return m_nodedef->allocateDummy(name); } -MtEventManager *Server::getEventManager() -{ - return m_event; -} - IWritableItemDefManager *Server::getWritableItemDefManager() { return m_itemdef; } -IWritableNodeDefManager *Server::getWritableNodeDefManager() +NodeDefManager *Server::getWritableNodeDefManager() { return m_nodedef; } @@ -3382,22 +3342,19 @@ IWritableCraftDefManager *Server::getWritableCraftDefManager() return m_craftdef; } +const std::vector & Server::getMods() const +{ + return m_modmgr->getMods(); +} + const ModSpec *Server::getModSpec(const std::string &modname) const { - std::vector::const_iterator it; - for (it = m_mods.begin(); it != m_mods.end(); ++it) { - const ModSpec &mod = *it; - if (mod.name == modname) - return &mod; - } - return NULL; + return m_modmgr->getModSpec(modname); } void Server::getModNames(std::vector &modlist) { - std::vector::iterator it; - for (it = m_mods.begin(); it != m_mods.end(); ++it) - modlist.push_back(it->name); + m_modmgr->getModNames(modlist); } std::string Server::getBuiltinLuaPath() @@ -3419,14 +3376,16 @@ v3f Server::findSpawnPos() } bool is_good = false; + // Limit spawn range to mapgen edges (determined by 'mapgen_limit') + s32 range_max = map.getMapgenParams()->getSpawnRangeMax(); // Try to find a good place a few times for(s32 i = 0; i < 4000 && !is_good; i++) { - s32 range = 1 + i; + s32 range = MYMIN(1 + i, range_max); // We're going to try to throw the player to this position v2s16 nodepos2d = v2s16( - -range + (myrand() % (range * 2)), - -range + (myrand() % (range * 2))); + -range + (myrand() % (range * 2)), + -range + (myrand() % (range * 2))); // Get spawn level at point s16 spawn_level = m_emerge->getSpawnLevelAtPoint(nodepos2d); @@ -3460,17 +3419,49 @@ v3f Server::findSpawnPos() return nodeposf; } -PlayerSAO* Server::emergePlayer(const char *name, u16 peer_id, u16 proto_version) +void Server::requestShutdown(const std::string &msg, bool reconnect, float delay) { - bool newplayer = false; + if (delay == 0.0f) { + // No delay, shutdown immediately + m_shutdown_state.is_requested = true; + // only print to the infostream, a chat message saying + // "Server Shutting Down" is sent when the server destructs. + infostream << "*** Immediate Server shutdown requested." << std::endl; + } else if (delay < 0.0f && m_shutdown_state.isTimerRunning()) { + // Negative delay, cancel shutdown if requested + m_shutdown_state.reset(); + std::wstringstream ws; + + ws << L"*** Server shutdown canceled."; + + infostream << wide_to_utf8(ws.str()).c_str() << std::endl; + SendChatMessage(PEER_ID_INEXISTENT, ws.str()); + // m_shutdown_* are already handled, skip. + return; + } else if (delay > 0.0f) { + // Positive delay, tell the clients when the server will shut down + std::wstringstream ws; + + ws << L"*** Server shutting down in " + << duration_to_string(myround(delay)).c_str() + << "."; + + infostream << wide_to_utf8(ws.str()).c_str() << std::endl; + SendChatMessage(PEER_ID_INEXISTENT, ws.str()); + } + + m_shutdown_state.trigger(delay, msg, reconnect); +} +PlayerSAO* Server::emergePlayer(const char *name, session_t peer_id, u16 proto_version) +{ /* Try to get an existing player */ RemotePlayer *player = m_env->getPlayer(name); // If player is already connected, cancel - if (player != NULL && player->peer_id != 0) { + if (player && player->getPeerId() != PEER_ID_INEXISTENT) { infostream<<"emergePlayer(): Player already connected"<getPlayer(peer_id) != NULL) { + if (m_env->getPlayer(peer_id)) { infostream<<"emergePlayer(): Player with wrong name but same" " peer_id already exists"<loadPlayer(name, playersao); - - // Create player if it doesn't exist if (!player) { - newplayer = true; - player = new RemotePlayer(name, this->idef()); - // Set player position - infostream<<"Server: Finding spawn place for player \"" - <setBasePosition(findSpawnPos()); - - // Make sure the player is saved - player->setModified(true); - - // Add player to environment - m_env->addPlayer(player); - } else { - // If the player exists, ensure that they respawn inside legal bounds - // This fixes an assert crash when the player can't be added - // to the environment - if (objectpos_over_limit(playersao->getBasePosition())) { - actionstream << "Respawn position for player \"" - << name << "\" outside limits, resetting" << std::endl; - playersao->setBasePosition(findSpawnPos()); - } + player = new RemotePlayer(name, idef()); } - playersao->initialize(player, getPlayerEffectivePrivs(player->getName())); - - player->protocol_version = proto_version; + bool newplayer = false; - /* Clean up old HUD elements from previous sessions */ - player->clearHud(); + // Load player + PlayerSAO *playersao = m_env->loadPlayer(player, &newplayer, peer_id, isSingleplayer()); - /* Add object to environment */ - m_env->addActiveObject(playersao); + // Complete init with server parts + playersao->finalize(player, getPlayerEffectivePrivs(player->getName())); + player->protocol_version = proto_version; /* Run scripts */ if (newplayer) { @@ -3545,7 +3510,7 @@ bool Server::registerModStorage(ModMetadata *storage) void Server::unregisterModStorage(const std::string &name) { - UNORDERED_MAP::const_iterator it = m_mod_storages.find(name); + std::unordered_map::const_iterator it = m_mod_storages.find(name); if (it != m_mod_storages.end()) { // Save unconditionaly on unregistration it->second->save(getModStoragePath()); @@ -3555,14 +3520,13 @@ void Server::unregisterModStorage(const std::string &name) void dedicated_server_loop(Server &server, bool &kill) { - DSTACK(FUNCTION_NAME); - verbosestream<<"dedicated_server_loop()"<getFloat("dedicated_server_step"); - static const float profiler_print_interval = + static thread_local const float steplen = + g_settings->getFloat("dedicated_server_step"); + static thread_local const float profiler_print_interval = g_settings->getFloat("profiler_print_interval"); for(;;) { @@ -3574,15 +3538,8 @@ void dedicated_server_loop(Server &server, bool &kill) } server.step(steplen); - if(server.getShutdownRequested() || kill) - { - infostream<<"Dedicated server quitting"<getBool("server_announce")) - ServerList::sendAnnounce("delete", server.m_bind_addr.getPort()); -#endif + if (server.isShutdownRequested() || kill) break; - } /* Profiler @@ -3596,4 +3553,76 @@ void dedicated_server_loop(Server &server, bool &kill) } } } + + infostream << "Dedicated server quitting" << std::endl; +#if USE_CURL + if (g_settings->getBool("server_announce")) + ServerList::sendAnnounce(ServerList::AA_DELETE, + server.m_bind_addr.getPort()); +#endif +} + +/* + * Mod channels + */ + + +bool Server::joinModChannel(const std::string &channel) +{ + return m_modchannel_mgr->joinChannel(channel, PEER_ID_SERVER) && + m_modchannel_mgr->setChannelState(channel, MODCHANNEL_STATE_READ_WRITE); +} + +bool Server::leaveModChannel(const std::string &channel) +{ + return m_modchannel_mgr->leaveChannel(channel, PEER_ID_SERVER); +} + +bool Server::sendModChannelMessage(const std::string &channel, const std::string &message) +{ + if (!m_modchannel_mgr->canWriteOnChannel(channel)) + return false; + + broadcastModChannelMessage(channel, message, PEER_ID_SERVER); + return true; +} + +ModChannel* Server::getModChannel(const std::string &channel) +{ + return m_modchannel_mgr->getModChannel(channel); +} + +void Server::broadcastModChannelMessage(const std::string &channel, + const std::string &message, session_t from_peer) +{ + const std::vector &peers = m_modchannel_mgr->getChannelPeers(channel); + if (peers.empty()) + return; + + if (message.size() > STRING_MAX_LEN) { + warningstream << "ModChannel message too long, dropping before sending " + << " (" << message.size() << " > " << STRING_MAX_LEN << ", channel: " + << channel << ")" << std::endl; + return; + } + + std::string sender; + if (from_peer != PEER_ID_SERVER) { + sender = getPlayerName(from_peer); + } + + NetworkPacket resp_pkt(TOCLIENT_MODCHANNEL_MSG, + 2 + channel.size() + 2 + sender.size() + 2 + message.size()); + resp_pkt << channel << sender << message; + for (session_t peer_id : peers) { + // Ignore sender + if (peer_id == from_peer) + continue; + + Send(peer_id, &resp_pkt); + } + + if (from_peer != PEER_ID_SERVER) { + m_script->on_modchannel_message(channel, sender, message); + } }