X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fserver.cpp;h=b74bba258c0dd79368985ca10aa80f61707c382a;hb=37f771a95bd54e2072f07783df142da4a91e7bff;hp=41493a8628586bc0b7df1bb347c2302672a31362;hpb=85511a642f851100d0d856f4ecbe7fea7a7bb049;p=oweals%2Fminetest.git diff --git a/src/server.cpp b/src/server.cpp index 41493a862..b74bba258 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" @@ -43,25 +44,27 @@ with this program; if not, write to the Free Software Foundation, Inc., #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_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.h" +#include "database/database.h" #include "chatmessage.h" #include "chat_interface.h" +#include "remoteplayer.h" class ClientNotFoundException : public BaseException { @@ -88,20 +91,25 @@ private: void *ServerThread::run() { - DSTACK(FUNCTION_NAME); BEGIN_DEBUG_EXCEPTION_HANDLER + /* + * The real business of the server happens on the ServerThread. + * How this works: + * AsyncRunStep() runs an actual server step as soon as enough time has + * passed (dedicated_server_loop keeps track of that). + * Receive() blocks at least(!) 30ms waiting for a packet (so this loop + * doesn't busy wait) and will process any remaining packets. + */ + m_server->AsyncRunStep(true); while (!stopRequested()) { try { - //TimeTaker timer("AsyncRunStep() + Receive()"); - m_server->AsyncRunStep(); m_server->Receive(); - } catch (con::NoIncomingDataException &e) { } catch (con::PeerNotFoundException &e) { infostream<<"Server: PeerNotFoundException"< 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 @@ -149,51 +210,131 @@ 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_con(PROTOCOL_ID, + m_con(std::make_shared(PROTOCOL_ID, 512, CONNECTION_TIMEOUT, - ipv6, - this), + m_bind_addr.isIPv6(), + this)), m_itemdef(createItemDefManager()), m_nodedef(createNodeDefManager()), m_craftdef(createCraftDefManager()), - m_event(new EventManager()), + m_thread(new ServerThread(this)), m_uptime(0), - m_clients(&m_con), - m_admin_chat(iface) + m_clients(m_con), + m_admin_chat(iface), + m_modchannel_mgr(new ModChannelMgr()) { m_lag = g_settings->getFloat("dedicated_server_step"); - if (path_world.empty()) + if (m_path_world.empty()) throw ServerError("Supplied empty world path"); - if(!gamespec.isValid()) + if (!gamespec.isValid()) throw ServerError("Supplied invalid gamespec"); +} + +Server::~Server() +{ + + // Send shutdown message + SendChatMessage(PEER_ID_INEXISTENT, ChatMessage(CHATMESSAGE_TYPE_ANNOUNCE, + L"*** Server shutting down")); + + if (m_env) { + MutexAutoLock envlock(m_env_mutex); + + infostream << "Server: Saving players" << std::endl; + m_env->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->saveLoadedPlayers(true); + m_env->kickAllPlayers(SERVER_ACCESSDENIED_SHUTDOWN, + kick_msg, reconnect); + } + + actionstream << "Server: Shutting down" << std::endl; + + // 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; + } - infostream<<"Server created for gameid \""< 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(); + 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 characters [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(); @@ -251,9 +371,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.empty() && 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); @@ -277,8 +399,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); } @@ -289,121 +410,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(); - } + 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_flavour_limits = g_settings->getU64("csm_flavour_limits"); - m_csm_noderange_limit = g_settings->getU32("csm_flavour_noderange_limit"); -} - -Server::~Server() -{ - 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.empty()) { - 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; - } + m_csm_restriction_flags = g_settings->getU64("csm_restriction_flags"); + m_csm_restriction_noderange = g_settings->getU32("csm_restriction_noderange"); } -void Server::start(Address bind_addr) +void Server::start() { - 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; @@ -439,9 +483,6 @@ void Server::step(float dtime) void Server::AsyncRunStep(bool initial_step) { - DSTACK(FUNCTION_NAME); - - g_profiler->add("Server::AsyncRunStep (num)", 1); float dtime; { @@ -457,10 +498,7 @@ void Server::AsyncRunStep(bool initial_step) if((dtime < 0.001) && !initial_step) return; - g_profiler->add("Server::AsyncRunStep with dtime (num)", 1); - - //infostream<<"Server steps "<reportMaxLagEstimate(max_lag); // Step environment - ScopeProfiler sp(g_profiler, "SEnv step"); - ScopeProfiler sp2(g_profiler, "SEnv step avg", SPT_AVG); m_env->step(dtime); } @@ -558,8 +594,7 @@ void Server::AsyncRunStep(bool initial_step) /* Set the modified blocks unsent for all the clients */ - if(!modified_blocks.empty()) - { + if (!modified_blocks.empty()) { SetBlocksNotSent(modified_blocks); } } @@ -581,7 +616,7 @@ 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; } @@ -598,124 +633,27 @@ void Server::AsyncRunStep(bool initial_step) m_clients.lock(); const RemoteClientMap &clients = m_clients.getClientList(); - ScopeProfiler sp(g_profiler, "Server: checking added and deleted objs"); - - // Radius inside which objects are active - static thread_local const s16 radius = - g_settings->getS16("active_object_send_range_blocks") * MAP_BLOCKSIZE; - - // Radius inside which players are active - static thread_local const bool is_transfer_limited = - g_settings->exists("unlimited_player_transfer_distance") && - !g_settings->getBool("unlimited_player_transfer_distance"); - 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; + ScopeProfiler sp(g_profiler, "Server: update objects within range"); for (const auto &client_it : clients) { RemoteClient *client = client_it.second; - // If definitions and textures have not been sent, don't - // send objects either if (client->getState() < CS_DefinitionsSent) continue; - RemotePlayer *player = m_env->getPlayer(client->peer_id); - if (!player) { - // This can happen if the client timeouts somehow + // This can happen if the client times out somehow + if (!m_env->getPlayer(client->peer_id)) continue; - } - PlayerSAO *playersao = player->getPlayerSAO(); + PlayerSAO *playersao = getPlayerSAO(client->peer_id); if (!playersao) continue; - s16 my_radius = MYMIN(radius, playersao->getWantedRange() * MAP_BLOCKSIZE); - if (my_radius <= 0) my_radius = radius; - //infostream << "Server: Active Radius " << my_radius << std::endl; - - std::queue removed_objects; - std::queue added_objects; - m_env->getRemovedActiveObjects(playersao, my_radius, player_radius, - client->m_known_objects, removed_objects); - m_env->getAddedActiveObjects(playersao, my_radius, player_radius, - client->m_known_objects, added_objects); - - // Ignore if nothing happened - if (removed_objects.empty() && added_objects.empty()) { - continue; - } - - std::string data_buffer; - - char buf[4]; - - // Handle removed objects - writeU16((u8*)buf, removed_objects.size()); - data_buffer.append(buf, 2); - while (!removed_objects.empty()) { - // Get object - u16 id = removed_objects.front(); - ServerActiveObject* obj = m_env->getActiveObject(id); - - // Add to data buffer for sending - writeU16((u8*)buf, id); - data_buffer.append(buf, 2); - - // Remove from known objects - client->m_known_objects.erase(id); - - if(obj && obj->m_known_by_count > 0) - obj->m_known_by_count--; - removed_objects.pop(); - } - - // Handle added objects - writeU16((u8*)buf, added_objects.size()); - data_buffer.append(buf, 2); - while (!added_objects.empty()) { - // Get object - u16 id = added_objects.front(); - ServerActiveObject* obj = m_env->getActiveObject(id); - - // Get object type - u8 type = ACTIVEOBJECT_TYPE_INVALID; - if (!obj) - warningstream << FUNCTION_NAME << ": NULL object" << std::endl; - else - type = obj->getSendType(); - - // Add to data buffer for sending - writeU16((u8*)buf, id); - data_buffer.append(buf, 2); - writeU8((u8*)buf, type); - data_buffer.append(buf, 1); - - if(obj) - data_buffer.append(serializeLongString( - obj->getClientInitializationData(client->net_proto_version))); - else - data_buffer.append(serializeLongString("")); - - // Add to known objects - client->m_known_objects.insert(id); - - if(obj) - obj->m_known_by_count++; - - added_objects.pop(); - } - - u32 pktSize = SendActiveObjectRemoveAdd(client->peer_id, data_buffer); - verbosestream << "Server: Sent object remove/add: " - << removed_objects.size() << " removed, " - << added_objects.size() << " added, " - << "packet size is " << pktSize << std::endl; + SendActiveObjectRemoveAdd(client, playersao); } m_clients.unlock(); + // Save mod storages if modified m_mod_storage_save_timer -= dtime; if (m_mod_storage_save_timer <= 0.0f) { infostream << "Saving registered mod storages." << std::endl; @@ -734,7 +672,7 @@ void Server::AsyncRunStep(bool initial_step) */ { MutexAutoLock envlock(m_env_mutex); - ScopeProfiler sp(g_profiler, "Server: sending object messages"); + ScopeProfiler sp(g_profiler, "Server: send SAO messages"); // Key = object id // Value = data sent by object @@ -764,19 +702,33 @@ void Server::AsyncRunStep(bool initial_step) // Route data to every client for (const auto &client_it : clients) { RemoteClient *client = client_it.second; + PlayerSAO *player = getPlayerSAO(client->peer_id); std::string reliable_data; std::string unreliable_data; // Go through all objects in message buffer for (const auto &buffered_message : buffered_messages) { - // If object is not known by client, skip it + // If object does not exist or is not known by client, skip it u16 id = buffered_message.first; - if (client->m_known_objects.find(id) == client->m_known_objects.end()) + ServerActiveObject *sao = m_env->getActiveObject(id); + if (!sao || client->m_known_objects.find(id) == client->m_known_objects.end()) continue; // Get message list of object std::vector* list = buffered_message.second; // Go through every message for (const ActiveObjectMessage &aom : *list) { + // Send position updates to players who do not see the attachment + if (aom.datastring[0] == GENERIC_CMD_UPDATE_POSITION) { + if (sao->getId() == player->getId()) + continue; + + // Do not send position updates for attached players + // as long the parent is known to the client + ServerActiveObject *parent = sao->getParent(); + if (parent && client->m_known_objects.find(parent->getId()) != + client->m_known_objects.end()) + continue; + } // Compose the full new data with header std::string new_data; // Add object id @@ -832,6 +784,8 @@ void Server::AsyncRunStep(bool initial_step) // We'll log the amount of each Profiler prof; + std::list node_meta_updates; + while (!m_unsent_map_edit_queue.empty()) { MapEditEvent* event = m_unsent_map_edit_queue.front(); m_unsent_map_edit_queue.pop(); @@ -839,31 +793,42 @@ void Server::AsyncRunStep(bool initial_step) // Players far away from the change are stored here. // Instead of sending the changes, MapBlocks are set not sent // for them. - std::vector far_players; + std::unordered_set far_players; switch (event->type) { case MEET_ADDNODE: case MEET_SWAPNODE: prof.add("MEET_ADDNODE", 1); - sendAddNode(event->p, event->n, event->already_known_by_peer, - &far_players, disable_single_change_sending ? 5 : 30, + sendAddNode(event->p, event->n, &far_players, + disable_single_change_sending ? 5 : 30, event->type == MEET_ADDNODE); break; case MEET_REMOVENODE: prof.add("MEET_REMOVENODE", 1); - sendRemoveNode(event->p, event->already_known_by_peer, - &far_players, disable_single_change_sending ? 5 : 30); + sendRemoveNode(event->p, &far_players, + disable_single_change_sending ? 5 : 30); break; - 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); + case MEET_BLOCK_NODE_METADATA_CHANGED: { + verbosestream << "Server: MEET_BLOCK_NODE_METADATA_CHANGED" << std::endl; + prof.add("MEET_BLOCK_NODE_METADATA_CHANGED", 1); + if (!event->is_private_change) { + // Don't send the change yet. Collect them to eliminate dupes. + node_meta_updates.remove(event->p); + node_meta_updates.push_back(event->p); + } + + if (MapBlock *block = m_env->getMap().getBlockNoCreateNoEx( + getNodeBlockPos(event->p))) { + block->raiseModified(MOD_STATE_WRITE_NEEDED, + MOD_REASON_REPORT_META_CHANGE); + } break; + } case MEET_OTHER: infostream << "Server: MEET_OTHER" << std::endl; prof.add("MEET_OTHER", 1); for (const v3s16 &modified_block : event->modified_blocks) { - setBlockNotSent(modified_block); + m_clients.markBlockposAsNotSent(modified_block); } break; default: @@ -902,6 +867,9 @@ void Server::AsyncRunStep(bool initial_step) prof.print(verbosestream); } + // Send all metadata updates + if (node_meta_updates.size()) + sendMetadataChanged(node_meta_updates); } /* @@ -928,7 +896,7 @@ void Server::AsyncRunStep(bool initial_step) counter = 0.0; MutexAutoLock lock(m_env_mutex); - ScopeProfiler sp(g_profiler, "Server: saving stuff"); + ScopeProfiler sp(g_profiler, "Server: map saving (sum)"); // Save ban file if (m_banmanager->isModified()) { @@ -946,71 +914,52 @@ void Server::AsyncRunStep(bool initial_step) } } - // Timed shutdown - static const float shutdown_msg_times[] = - { - 1, 2, 3, 4, 5, 10, 15, 20, 25, 30, 45, 60, 120, 180, 300, 600, 1200, 1800, 3600 - }; - - if (m_shutdown_timer > 0.0f) { - // Automated messages - if (m_shutdown_timer < shutdown_msg_times[ARRLEN(shutdown_msg_times) - 1]) { - for (u16 i = 0; i < ARRLEN(shutdown_msg_times) - 1; i++) { - // If shutdown timer matches an automessage, shot it - if (m_shutdown_timer > shutdown_msg_times[i] && - m_shutdown_timer - dtime < shutdown_msg_times[i]) { - std::wstringstream ws; - - ws << L"*** Server shutting down in " - << duration_to_string(myround(m_shutdown_timer - dtime)).c_str() - << "."; - - infostream << wide_to_utf8(ws.str()).c_str() << std::endl; - SendChatMessage(PEER_ID_INEXISTENT, ws.str()); - break; - } - } - } - - m_shutdown_timer -= dtime; - if (m_shutdown_timer < 0.0f) { - m_shutdown_timer = 0.0f; - m_shutdown_requested = true; - } - } + m_shutdown_state.tick(dtime, this); } void Server::Receive() { - DSTACK(FUNCTION_NAME); - u16 peer_id; - try { - NetworkPacket pkt; - m_con.Receive(&pkt); - peer_id = pkt.getPeerId(); - ProcessData(&pkt); - } - catch(con::InvalidIncomingDataException &e) { - infostream<<"Server::Receive(): " - "InvalidIncomingDataException: what()=" - <Receive(&pkt); + first = false; + } else { + if (!m_con->TryReceive(&pkt)) + return; + } + + peer_id = pkt.getPeerId(); + ProcessData(&pkt); + } catch (const con::InvalidIncomingDataException &e) { + infostream << "Server::Receive(): InvalidIncomingDataException: what()=" + << e.what() << std::endl; + } catch (const SerializationError &e) { + infostream << "Server::Receive(): SerializationError: what()=" + << e.what() << std::endl; + } catch (const ClientStateError &e) { + errorstream << "ProcessData: peer=" << peer_id << " what()=" + << e.what() << std::endl; + DenyAccess_Legacy(peer_id, L"Your client sent something server didn't expect." + L"Try reconnecting or updating your client"); + } catch (const con::PeerNotFoundException &e) { + // Do nothing + } catch (const con::NoIncomingDataException &e) { + return; + } } } -PlayerSAO* Server::StageTwoClientInit(u16 peer_id) +PlayerSAO* Server::StageTwoClientInit(session_t peer_id) { std::string playername; PlayerSAO *playersao = NULL; @@ -1031,7 +980,7 @@ PlayerSAO* Server::StageTwoClientInit(u16 peer_id) // If failed, cancel if (!playersao || !player) { - if (player && player->peer_id != 0) { + 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 " @@ -1057,23 +1006,19 @@ PlayerSAO* Server::StageTwoClientInit(u16 peer_id) SendPlayerInventoryFormspec(peer_id); // Send inventory - SendInventory(playersao); + SendInventory(playersao, false); // Send HP or death screen if (playersao->isDead()) SendDeathscreen(peer_id, false, v3f(0,0,0)); else - SendPlayerHPOrDie(playersao); + SendPlayerHPOrDie(playersao, + PlayerHPChangeReason(PlayerHPChangeReason::SET_HP)); // Send Breath SendPlayerBreath(playersao); - // 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, 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; /* @@ -1093,19 +1038,18 @@ PlayerSAO* Server::StageTwoClientInit(u16 peer_id) return playersao; } -inline void Server::handleCommand(NetworkPacket* pkt) +inline void Server::handleCommand(NetworkPacket *pkt) { - const ToServerCommandHandler& opHandle = toServerCommandTable[pkt->getCommand()]; + const ToServerCommandHandler &opHandle = toServerCommandTable[pkt->getCommand()]; (this->*opHandle.handler)(pkt); } void Server::ProcessData(NetworkPacket *pkt) { - DSTACK(FUNCTION_NAME); // Environment is locked first. MutexAutoLock envlock(m_env_mutex); - ScopeProfiler sp(g_profiler, "Server::ProcessData"); + ScopeProfiler sp(g_profiler, "Server: Process network packet (sum)"); u32 peer_id = pkt->getPeerId(); try { @@ -1192,14 +1136,12 @@ void Server::setTimeOfDay(u32 time) m_time_of_day_send_timer = 0; } -void Server::onMapEditEvent(MapEditEvent *event) +void Server::onMapEditEvent(const MapEditEvent &event) { - if(m_ignore_map_edit_events) + if (m_ignore_map_edit_events_area.contains(event.getArea())) return; - if(m_ignore_map_edit_events_area.contains(event->getArea())) - return; - MapEditEvent *e = event->clone(); - m_unsent_map_edit_queue.push(e); + + m_unsent_map_edit_queue.push(new MapEditEvent(event)); } Inventory* Server::getInventory(const InventoryLocation &loc) @@ -1240,42 +1182,36 @@ Inventory* Server::getInventory(const InventoryLocation &loc) } return NULL; } -void Server::setInventoryModified(const InventoryLocation &loc, bool playerSend) + +void Server::setInventoryModified(const InventoryLocation &loc) { switch(loc.type){ case InventoryLocation::UNDEFINED: break; case InventoryLocation::PLAYER: { - if (!playerSend) - return; RemotePlayer *player = m_env->getPlayer(loc.name.c_str()); if (!player) return; - PlayerSAO *playersao = player->getPlayerSAO(); - if(!playersao) - return; - - SendInventory(playersao); + player->setModified(true); + player->inventory.setModified(true); + // Updates are sent in ServerEnvironment::step() } break; case InventoryLocation::NODEMETA: { - v3s16 blockpos = getNodeBlockPos(loc.p); - - MapBlock *block = m_env->getMap().getBlockNoCreateNoEx(blockpos); - if (block) - block->raiseModified(MOD_STATE_WRITE_NEEDED); - - setBlockNotSent(blockpos); + MapEditEvent event; + event.type = MEET_BLOCK_NODE_METADATA_CHANGED; + event.p = loc.p; + m_env->getMap().dispatchEvent(event); } break; case InventoryLocation::DETACHED: { - sendDetachedInventory(loc.name,PEER_ID_INEXISTENT); + // Updates are sent in ServerEnvironment::step() } break; default: @@ -1286,10 +1222,10 @@ 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 (const u16 client_id : clients) { + for (const session_t client_id : clients) { if (RemoteClient *client = m_clients.lockedGetClientNoEx(client_id)) client->SetBlocksNotSent(block); } @@ -1298,7 +1234,6 @@ void Server::SetBlocksNotSent(std::map& block) void Server::peerAdded(con::Peer *peer) { - DSTACK(FUNCTION_NAME); verbosestream<<"Server::peerAdded(): peer->id=" <id<id=" <id<<", timeout="<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); + *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, @@ -1349,7 +1283,7 @@ bool Server::getClientInfo( *major = client->getMajor(); *minor = client->getMinor(); *patch = client->getPatch(); - *vers_string = client->getPatch(); + *vers_string = client->getFull(); m_clients.unlock(); @@ -1394,17 +1328,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); @@ -1425,39 +1363,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")) + if (playersao->isImmortal()) 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); @@ -1472,30 +1406,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); /* @@ -1516,11 +1444,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); /* @@ -1546,64 +1472,64 @@ void Server::SendNodeDef(u16 peer_id, Non-static send methods */ -void Server::SendInventory(PlayerSAO* playerSAO) +void Server::SendInventory(PlayerSAO *sao, bool incremental) { - DSTACK(FUNCTION_NAME); + RemotePlayer *player = sao->getPlayer(); + + // Do not send new format to old clients + incremental &= player->protocol_version >= 38; - UpdateCrafting(playerSAO->getPlayer()); + UpdateCrafting(player); /* Serialize it */ - NetworkPacket pkt(TOCLIENT_INVENTORY, 0, playerSAO->getPeerID()); + NetworkPacket pkt(TOCLIENT_INVENTORY, 0, sao->getPeerID()); - std::ostringstream os; - playerSAO->getInventory()->serialize(os); - - std::string s = os.str(); + std::ostringstream os(std::ios::binary); + sao->getInventory()->serialize(os, incremental); + sao->getInventory()->setModified(false); + player->setModified(true); + const std::string &s = os.str(); pkt.putRawString(s.c_str(), s.size()); Send(&pkt); } -void Server::SendChatMessage(u16 peer_id, const ChatMessage &message) +void Server::SendChatMessage(session_t peer_id, const ChatMessage &message) { - DSTACK(FUNCTION_NAME); - - NetworkPacket legacypkt(TOCLIENT_CHAT_MESSAGE_OLD, 0, peer_id); - legacypkt << message.message; - NetworkPacket pkt(TOCLIENT_CHAT_MESSAGE, 0, peer_id); u8 version = 1; u8 type = message.type; - pkt << version << type << std::wstring(L"") << message.message << message.timestamp; + pkt << version << type << std::wstring(L"") << message.message << (u64)message.timestamp; if (peer_id != PEER_ID_INEXISTENT) { RemotePlayer *player = m_env->getPlayer(peer_id); if (!player) return; - if (player->protocol_version < 35) - Send(&legacypkt); - else - Send(&pkt); + Send(&pkt); } else { - m_clients.sendToAllCompat(&pkt, &legacypkt, 35); + m_clients.sendToAll(&pkt); } } -void Server::SendShowFormspecMessage(u16 peer_id, const std::string &formspec, - const std::string &formname) +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); + NetworkPacket pkt(TOCLIENT_SHOW_FORMSPEC, 0, peer_id); if (formspec.empty()){ //the client should close the formspec + //but make sure there wasn't another one open in meantime + const auto it = m_formspec_state_data.find(peer_id); + if (it != m_formspec_state_data.end() && it->second == formname) { + m_formspec_state_data.erase(peer_id); + } pkt.putLongString(""); } else { - pkt.putLongString(FORMSPEC_VERSION_STRING + formspec); + m_formspec_state_data[peer_id] = formname; + pkt.putLongString(formspec); } pkt << formname; @@ -1611,21 +1537,20 @@ 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 collision_removal, bool object_collision, 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) { - std::vector clients = m_clients.getClientIDs(); + std::vector clients = m_clients.getClientIDs(); - for (const u16 client_id : clients) { + for (const session_t client_id : clients) { RemotePlayer *player = m_env->getPlayer(client_id); if (!player) continue; @@ -1640,8 +1565,8 @@ void Server::SendSpawnParticle(u16 peer_id, u16 protocol_version, SendSpawnParticle(client_id, player->protocol_version, pos, velocity, acceleration, - expirationtime, size, collisiondetection, - collision_removal, vertical, texture, animation, glow); + expirationtime, size, collisiondetection, collision_removal, + object_collision, vertical, texture, animation, glow); } return; } @@ -1658,23 +1583,23 @@ void Server::SendSpawnParticle(u16 peer_id, u16 protocol_version, animation.serialize(os, protocol_version); pkt.putRawString(os.str()); pkt << glow; + pkt << object_collision; Send(&pkt); } // 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, + bool object_collision, 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 (const u16 client_id : clients) { + std::vector clients = m_clients.getClientIDs(); + for (const session_t client_id : clients) { RemotePlayer *player = m_env->getPlayer(client_id); if (!player) continue; @@ -1682,7 +1607,8 @@ void Server::SendAddParticleSpawner(u16 peer_id, u16 protocol_version, amount, spawntime, minpos, maxpos, minvel, maxvel, minacc, maxacc, minexptime, maxexptime, minsize, maxsize, collisiondetection, collision_removal, - attached_id, vertical, texture, id, animation, glow); + object_collision, attached_id, vertical, texture, id, + animation, glow); } return; } @@ -1703,47 +1629,45 @@ void Server::SendAddParticleSpawner(u16 peer_id, u16 protocol_version, animation.serialize(os, protocol_version); pkt.putRawString(os.str()); pkt << glow; + pkt << object_collision; 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 { + 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); pkt << id << (u8) form->type << form->pos << form->name << form->scale << form->text << form->number << form->item << form->dir - << form->align << form->offset << form->world_pos << form->size; + << form->align << form->offset << form->world_pos << form->size + << form->z_index; 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; @@ -1776,7 +1700,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); @@ -1787,14 +1711,14 @@ 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, +void Server::SendSetSky(session_t peer_id, const video::SColor &bgcolor, const std::string &type, const std::vector ¶ms, bool &clouds) { @@ -1809,21 +1733,15 @@ void Server::SendSetSky(u16 peer_id, const video::SColor &bgcolor, Send(&pkt); } -void Server::SendCloudParams(u16 peer_id, float density, - const video::SColor &color_bright, - const video::SColor &color_ambient, - float height, - float thickness, - const v2f &speed) +void Server::SendCloudParams(session_t peer_id, const CloudParams ¶ms) { NetworkPacket pkt(TOCLIENT_CLOUD_PARAMS, 0, peer_id); - pkt << density << color_bright << color_ambient - << height << thickness << speed; - + pkt << params.density << params.color_bright << params.color_ambient + << params.height << params.thickness << params.speed; Send(&pkt); } -void Server::SendOverrideDayNightRatio(u16 peer_id, bool do_override, +void Server::SendOverrideDayNightRatio(session_t peer_id, bool do_override, float ratio) { NetworkPacket pkt(TOCLIENT_OVERRIDE_DAY_NIGHT_RATIO, @@ -1834,10 +1752,8 @@ void Server::SendOverrideDayNightRatio(u16 peer_id, bool do_override, Send(&pkt); } -void Server::SendTimeOfDay(u16 peer_id, u16 time, f32 time_speed) +void Server::SendTimeOfDay(session_t peer_id, u16 time, f32 time_speed) { - DSTACK(FUNCTION_NAME); - NetworkPacket pkt(TOCLIENT_TIME_OF_DAY, 0, peer_id); pkt << time << time_speed; @@ -1849,9 +1765,8 @@ void Server::SendTimeOfDay(u16 peer_id, u16 time, f32 time_speed) } } -void Server::SendPlayerHP(u16 peer_id) +void Server::SendPlayerHP(session_t peer_id) { - DSTACK(FUNCTION_NAME); PlayerSAO *playersao = getPlayerSAO(peer_id); // In some rare case if the player is disconnected // while Lua call l_punch, for example, this can be NULL @@ -1862,44 +1777,53 @@ void Server::SendPlayerHP(u16 peer_id) m_script->player_event(playersao,"health_changed"); // Send to other clients - std::string str = gob_cmd_punched(playersao->readDamage(), playersao->getHP()); + std::string str = gob_cmd_punched(playersao->getHP()); ActiveObjectMessage aom(playersao->getId(), true, str); playersao->m_messages_out.push(aom); } void Server::SendPlayerBreath(PlayerSAO *sao) { - DSTACK(FUNCTION_NAME); assert(sao); m_script->player_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(); assert(sao); NetworkPacket pkt(TOCLIENT_MOVE_PLAYER, sizeof(v3f) + sizeof(f32) * 2, peer_id); - pkt << sao->getBasePosition() << sao->getPitch() << sao->getYaw(); + pkt << sao->getBasePosition() << sao->getLookPitch() << sao->getRotation().Y; { v3f pos = sao->getBasePosition(); verbosestream << "Server: Sending TOCLIENT_MOVE_PLAYER" << " pos=(" << pos.X << "," << pos.Y << "," << pos.Z << ")" - << " pitch=" << sao->getPitch() - << " yaw=" << sao->getYaw() + << " pitch=" << sao->getLookPitch() + << " yaw=" << sao->getRotation().Y << std::endl; } Send(&pkt); } -void Server::SendLocalPlayerAnimations(u16 peer_id, v2s32 animation_frames[4], f32 animation_speed) +void Server::SendPlayerFov(session_t peer_id) +{ + NetworkPacket pkt(TOCLIENT_FOV, 4 + 1, peer_id); + + PlayerFovSpec fov_spec = m_env->getPlayer(peer_id)->getFov(); + pkt << fov_spec.fov << fov_spec.is_multiplier; + + Send(&pkt); +} + +void Server::SendLocalPlayerAnimations(session_t peer_id, v2s32 animation_frames[4], + f32 animation_speed) { NetworkPacket pkt(TOCLIENT_LOCAL_PLAYER_ANIMATIONS, 0, peer_id); @@ -1910,17 +1834,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; @@ -1936,50 +1861,162 @@ void Server::SendPlayerPrivileges(u16 peer_id) 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); - pkt.putLongString(FORMSPEC_VERSION_STRING + player->inventory_formspec); + pkt.putLongString(player->inventory_formspec); + Send(&pkt); } -u32 Server::SendActiveObjectRemoveAdd(u16 peer_id, const std::string &datas) +void Server::SendPlayerFormspecPrepend(session_t peer_id) { - NetworkPacket pkt(TOCLIENT_ACTIVE_OBJECT_REMOVE_ADD, datas.size(), peer_id); - pkt.putRawString(datas.c_str(), datas.size()); + 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 << player->formspec_prepend; Send(&pkt); - return pkt.getSize(); } -void Server::SendActiveObjectMessages(u16 peer_id, const std::string &datas, bool reliable) +void Server::SendActiveObjectRemoveAdd(RemoteClient *client, PlayerSAO *playersao) { - NetworkPacket pkt(TOCLIENT_ACTIVE_OBJECT_MESSAGES, - datas.size(), peer_id); + // Radius inside which objects are active + static thread_local const s16 radius = + g_settings->getS16("active_object_send_range_blocks") * MAP_BLOCKSIZE; - pkt.putRawString(datas.c_str(), datas.size()); + // Radius inside which players are active + static thread_local const bool is_transfer_limited = + g_settings->exists("unlimited_player_transfer_distance") && + !g_settings->getBool("unlimited_player_transfer_distance"); - m_clients.send(pkt.getPeerId(), - reliable ? clientCommandFactoryTable[pkt.getCommand()].channel : 1, - &pkt, reliable); -} + static thread_local const s16 player_transfer_dist = + g_settings->getS16("player_transfer_distance") * MAP_BLOCKSIZE; -void Server::SendCSMFlavourLimits(u16 peer_id) -{ - NetworkPacket pkt(TOCLIENT_CSM_FLAVOUR_LIMITS, - sizeof(m_csm_flavour_limits) + sizeof(m_csm_noderange_limit), peer_id); - pkt << m_csm_flavour_limits << m_csm_noderange_limit; - Send(&pkt); -} + s16 player_radius = player_transfer_dist == 0 && is_transfer_limited ? + radius : player_transfer_dist; -s32 Server::playSound(const SimpleSoundSpec &spec, - const ServerSoundParams ¶ms) -{ - // Find out initial position of sound + s16 my_radius = MYMIN(radius, playersao->getWantedRange() * MAP_BLOCKSIZE); + if (my_radius <= 0) + my_radius = radius; + + std::queue removed_objects, added_objects; + m_env->getRemovedActiveObjects(playersao, my_radius, player_radius, + client->m_known_objects, removed_objects); + m_env->getAddedActiveObjects(playersao, my_radius, player_radius, + client->m_known_objects, added_objects); + + int removed_count = removed_objects.size(); + int added_count = added_objects.size(); + + if (removed_objects.empty() && added_objects.empty()) + return; + + char buf[4]; + std::string data; + + // Handle removed objects + writeU16((u8*)buf, removed_objects.size()); + data.append(buf, 2); + while (!removed_objects.empty()) { + // Get object + u16 id = removed_objects.front(); + ServerActiveObject* obj = m_env->getActiveObject(id); + + // Add to data buffer for sending + writeU16((u8*)buf, id); + data.append(buf, 2); + + // Remove from known objects + client->m_known_objects.erase(id); + + if (obj && obj->m_known_by_count > 0) + obj->m_known_by_count--; + + removed_objects.pop(); + } + + // Handle added objects + writeU16((u8*)buf, added_objects.size()); + data.append(buf, 2); + while (!added_objects.empty()) { + // Get object + u16 id = added_objects.front(); + ServerActiveObject *obj = m_env->getActiveObject(id); + added_objects.pop(); + + if (!obj) { + warningstream << FUNCTION_NAME << ": NULL object id=" + << (int)id << std::endl; + continue; + } + + // Get object type + u8 type = obj->getSendType(); + + // Add to data buffer for sending + writeU16((u8*)buf, id); + data.append(buf, 2); + writeU8((u8*)buf, type); + data.append(buf, 1); + + data.append(serializeLongString( + obj->getClientInitializationData(client->net_proto_version))); + + // Add to known objects + client->m_known_objects.insert(id); + + obj->m_known_by_count++; + } + + NetworkPacket pkt(TOCLIENT_ACTIVE_OBJECT_REMOVE_ADD, data.size(), client->peer_id); + pkt.putRawString(data.c_str(), data.size()); + Send(&pkt); + + verbosestream << "Server::SendActiveObjectRemoveAdd: " + << removed_count << " removed, " << added_count << " added, " + << "packet size is " << pkt.getSize() << std::endl; +} + +void Server::SendActiveObjectMessages(session_t peer_id, const std::string &datas, + bool reliable) +{ + NetworkPacket pkt(TOCLIENT_ACTIVE_OBJECT_MESSAGES, + datas.size(), peer_id); + + pkt.putRawString(datas.c_str(), datas.size()); + + 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); +} + +void Server::SendPlayerSpeed(session_t peer_id, const v3f &added_vel) +{ + NetworkPacket pkt(TOCLIENT_PLAYER_SPEED, 0, peer_id); + pkt << added_vel; + Send(&pkt); +} + +s32 Server::playSound(const SimpleSoundSpec &spec, + const ServerSoundParams ¶ms) +{ + // Find out initial position of sound bool pos_exists = false; v3f pos = params.getPos(m_env, &pos_exists); // If position is not found while it should be, cancel sound @@ -1987,7 +2024,7 @@ s32 Server::playSound(const SimpleSoundSpec &spec, return -1; // Filter destination clients - std::vector dst_clients; + std::vector dst_clients; if(!params.to_player.empty()) { RemotePlayer *player = m_env->getPlayer(params.to_player.c_str()); if(!player){ @@ -1995,16 +2032,16 @@ s32 Server::playSound(const SimpleSoundSpec &spec, <<"\" not found"<peer_id == PEER_ID_INEXISTENT){ + if (player->getPeerId() == PEER_ID_INEXISTENT) { infostream<<"Server::playSound: Player \""<peer_id); + dst_clients.push_back(player->getPeerId()); } else { - std::vector clients = m_clients.getClientIDs(); + std::vector clients = m_clients.getClientIDs(); - for (const u16 client_id : clients) { + for (const session_t client_id : clients) { RemotePlayer *player = m_env->getPlayer(client_id); if (!player) continue; @@ -2062,7 +2099,7 @@ void Server::stopSound(s32 handle) NetworkPacket pkt(TOCLIENT_STOP_SOUND, 4); pkt << handle; - for (std::unordered_set::const_iterator si = psound.clients.begin(); + for (std::unordered_set::const_iterator si = psound.clients.begin(); si != psound.clients.end(); ++si) { // Send as reliable m_clients.send(*si, 0, &pkt, true); @@ -2117,95 +2154,137 @@ void Server::fadeSound(s32 handle, float step, float gain) } } -void Server::sendRemoveNode(v3s16 p, u16 ignore_id, - std::vector *far_players, float far_d_nodes) +void Server::sendRemoveNode(v3s16 p, std::unordered_set *far_players, + float far_d_nodes) { - float maxd = far_d_nodes*BS; + float maxd = far_d_nodes * BS; v3f p_f = intToFloat(p, BS); + v3s16 block_pos = getNodeBlockPos(p); NetworkPacket pkt(TOCLIENT_REMOVENODE, 6); pkt << p; - std::vector clients = m_clients.getClientIDs(); - for (u16 client_id : clients) { - if (far_players) { - // Get player - if (RemotePlayer *player = m_env->getPlayer(client_id)) { - PlayerSAO *sao = player->getPlayerSAO(); - if (!sao) - continue; + std::vector clients = m_clients.getClientIDs(); + m_clients.lock(); - // 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(client_id); - continue; - } - } + for (session_t client_id : clients) { + RemoteClient *client = m_clients.lockedGetClientNoEx(client_id); + if (!client) + continue; + + RemotePlayer *player = m_env->getPlayer(client_id); + PlayerSAO *sao = player ? player->getPlayerSAO() : nullptr; + + // If player is far away, only set modified blocks not sent + if (!client->isBlockSent(block_pos) || (sao && + sao->getBasePosition().getDistanceFrom(p_f) > maxd)) { + if (far_players) + far_players->emplace(client_id); + else + client->SetBlockNotSent(block_pos); + continue; } // Send as reliable m_clients.send(client_id, 0, &pkt, true); } + + m_clients.unlock(); } -void Server::sendAddNode(v3s16 p, MapNode n, u16 ignore_id, - std::vector *far_players, float far_d_nodes, - bool remove_metadata) +void Server::sendAddNode(v3s16 p, MapNode n, std::unordered_set *far_players, + float far_d_nodes, bool remove_metadata) { - float maxd = far_d_nodes*BS; + float maxd = far_d_nodes * BS; v3f p_f = intToFloat(p, BS); + v3s16 block_pos = getNodeBlockPos(p); - std::vector clients = m_clients.getClientIDs(); - for (const u16 client_id : clients) { - if (far_players) { - // Get player - if (RemotePlayer *player = m_env->getPlayer(client_id)) { - PlayerSAO *sao = player->getPlayerSAO(); - if (!sao) - continue; + NetworkPacket pkt(TOCLIENT_ADDNODE, 6 + 2 + 1 + 1 + 1); + pkt << p << n.param0 << n.param1 << n.param2 + << (u8) (remove_metadata ? 0 : 1); - // 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(client_id); - continue; - } - } - } + std::vector clients = m_clients.getClientIDs(); + m_clients.lock(); - NetworkPacket pkt(TOCLIENT_ADDNODE, 6 + 2 + 1 + 1 + 1); - m_clients.lock(); - RemoteClient* client = m_clients.lockedGetClientNoEx(client_id); - if (client) { - pkt << p << n.param0 << n.param1 << n.param2 - << (u8) (remove_metadata ? 0 : 1); + for (session_t client_id : clients) { + RemoteClient *client = m_clients.lockedGetClientNoEx(client_id); + if (!client) + continue; + + RemotePlayer *player = m_env->getPlayer(client_id); + PlayerSAO *sao = player ? player->getPlayerSAO() : nullptr; + + // If player is far away, only set modified blocks not sent + if (!client->isBlockSent(block_pos) || (sao && + sao->getBasePosition().getDistanceFrom(p_f) > maxd)) { + if (far_players) + far_players->emplace(client_id); + else + client->SetBlockNotSent(block_pos); + continue; } - m_clients.unlock(); // Send as reliable - if (pkt.getSize() > 0) - m_clients.send(client_id, 0, &pkt, true); + m_clients.send(client_id, 0, &pkt, true); } + + m_clients.unlock(); } -void Server::setBlockNotSent(v3s16 p) +void Server::sendMetadataChanged(const std::list &meta_updates, float far_d_nodes) { - std::vector clients = m_clients.getClientIDs(); + float maxd = far_d_nodes * BS; + NodeMetadataList meta_updates_list(false); + std::vector clients = m_clients.getClientIDs(); + m_clients.lock(); - for (const u16 i : clients) { + + for (session_t i : clients) { RemoteClient *client = m_clients.lockedGetClientNoEx(i); - client->SetBlockNotSent(p); + if (!client) + continue; + + ServerActiveObject *player = m_env->getActiveObject(i); + v3f player_pos = player ? player->getBasePosition() : v3f(); + + for (const v3s16 &pos : meta_updates) { + NodeMetadata *meta = m_env->getMap().getNodeMetadata(pos); + + if (!meta) + continue; + + v3s16 block_pos = getNodeBlockPos(pos); + if (!client->isBlockSent(block_pos) || (player && + player_pos.getDistanceFrom(intToFloat(pos, BS)) > maxd)) { + client->SetBlockNotSent(block_pos); + continue; + } + + // Add the change to send list + meta_updates_list.set(pos, meta); + } + if (meta_updates_list.size() == 0) + continue; + + // Send the meta changes + std::ostringstream os(std::ios::binary); + meta_updates_list.serialize(os, client->net_proto_version, false, true); + std::ostringstream oss(std::ios::binary); + compressZlib(os.str(), oss); + + NetworkPacket pkt(TOCLIENT_NODEMETA_CHANGED, 0); + pkt.putLongString(oss.str()); + m_clients.send(i, 0, &pkt, true); + + meta_updates_list.clear(); } + m_clients.unlock(); } -void Server::SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver, u16 net_proto_version) +void Server::SendBlockNoLock(session_t 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 */ @@ -2217,37 +2296,33 @@ void Server::SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver, u16 net_proto 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 - ScopeProfiler sp(g_profiler, "Server: sel and send blocks to clients"); - std::vector queue; - s32 total_sending = 0; + u32 total_sending = 0; { - ScopeProfiler sp2(g_profiler, "Server: selecting blocks for sending"); + ScopeProfiler sp2(g_profiler, "Server::SendBlocks(): Collect list"); - std::vector clients = m_clients.getClientIDs(); + std::vector clients = m_clients.getClientIDs(); m_clients.lock(); - for (const u16 client_id : clients) { + for (const session_t client_id : clients) { RemoteClient *client = m_clients.lockedGetClientNoEx(client_id, CS_Active); if (!client) continue; - total_sending += client->SendingCount(); + total_sending += client->getSendingCount(); client->GetNextBlocks(m_env,m_emerge, dtime, queue); } m_clients.unlock(); @@ -2259,59 +2334,73 @@ 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 = nullptr; - try { - block = m_env->getMap().getBlockNoCreate(q.pos); - } catch(const InvalidPositionException &e) { + ScopeProfiler sp(g_profiler, "Server::SendBlocks(): Send to clients"); + Map &map = m_env->getMap(); + + for (const PrioritySortedBlockTransfer &block_to_send : queue) { + if (total_sending >= max_blocks_to_send) + break; + + MapBlock *block = map.getBlockNoCreateNoEx(block_to_send.pos); + if (!block) continue; - } - RemoteClient *client = m_clients.lockedGetClientNoEx(q.peer_id, CS_Active); + 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(); } -void Server::fillMediaCache() +bool Server::SendBlock(session_t peer_id, const v3s16 &blockpos) { - DSTACK(FUNCTION_NAME); + MapBlock *block = m_env->getMap().getBlockNoCreateNoEx(blockpos); + if (!block) + return false; + + m_clients.lock(); + RemoteClient *client = m_clients.lockedGetClientNoEx(peer_id, CS_Active); + if (!client || client->isBlockSent(blockpos)) { + m_clients.unlock(); + return false; + } + SendBlockNoLock(peer_id, block, client->serialization_version, + client->net_proto_version); + m_clients.unlock(); + + return true; +} +void Server::fillMediaCache() +{ infostream<<"Server: Calculating media file checksums"< paths; - for (const ModSpec &mod : m_mods) { - 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: \"" @@ -2324,6 +2413,8 @@ void Server::fillMediaCache() ".pcx", ".ppm", ".psd", ".wal", ".rgb", ".ogg", ".x", ".b3d", ".md2", ".obj", + // Custom translation file format + ".tr", NULL }; if (removeStringEnd(filename, supported_ext).empty()){ @@ -2332,7 +2423,9 @@ void Server::fillMediaCache() 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()) { @@ -2381,20 +2474,28 @@ 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(); + 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; } @@ -2416,11 +2517,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"<serialize(os); + if (player_it == m_detached_inventories_player.end() || + player_it->second.empty()) { + // OK. Send to everyone + } else { + if (!m_env) + return; // Mods are not done loading - // Make data buffer - std::string s = os.str(); + RemotePlayer *p = m_env->getPlayer(player_it->second.c_str()); + if (!p) + return; // Player is offline + + if (peer_id != PEER_ID_INEXISTENT && peer_id != p->getPeerId()) + return; // Caller requested send to a different player, so don't send. + + peer_id = p->getPeerId(); + } NetworkPacket pkt(TOCLIENT_DETACHED_INVENTORY, 0, peer_id); - pkt.putRawString(s.c_str(), s.size()); + pkt << name; - const std::string &check = m_detached_inventories_player[name]; - if (peer_id == PEER_ID_INEXISTENT) { - if (check.empty()) - return m_clients.sendToAll(&pkt); - RemotePlayer *p = m_env->getPlayer(check.c_str()); - if (p) - m_clients.send(p->peer_id, 0, &pkt, true); + if (inv_it == m_detached_inventories.end()) { + pkt << false; // Remove inventory } else { - if (check.empty() || getPlayerName(peer_id) == check) - Send(&pkt); + pkt << true; // Update inventory + + // Serialization & NetworkPacket isn't a love story + std::ostringstream os(std::ios_base::binary); + inv_it->second->serialize(os); + inv_it->second->setModified(false); + + const std::string &os_str = os.str(); + pkt << static_cast(os_str.size()); // HACK: to keep compatibility with 5.0.0 clients + pkt.putRawString(os_str); } + + if (peer_id == PEER_ID_INEXISTENT) + m_clients.sendToAll(&pkt); + else + Send(&pkt); } -void Server::sendDetachedInventories(u16 peer_id) +void Server::sendDetachedInventories(session_t peer_id, bool incremental) { - DSTACK(FUNCTION_NAME); - for (const auto &detached_inventory : m_detached_inventories) { const std::string &name = detached_inventory.first; - //Inventory *inv = i->second; + if (incremental) { + Inventory *inv = detached_inventory.second; + if (!inv || !inv->checkModified()) + continue; + } + sendDetachedInventory(name, peer_id); } } @@ -2563,9 +2680,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 @@ -2576,19 +2692,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); @@ -2596,8 +2711,9 @@ 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) { @@ -2609,56 +2725,48 @@ void Server::RespawnPlayer(u16 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); @@ -2686,9 +2794,8 @@ 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; { /* @@ -2704,6 +2811,9 @@ 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 */ @@ -2711,10 +2821,14 @@ void Server::DeleteClient(u16 peer_id, ClientDeletionReason reason) PlayerSAO *playersao = player->getPlayerSAO(); assert(playersao); + playersao->clearChildAttachments(); + playersao->clearParentAttachment(); + // inform connected clients + const std::string &player_name = player->getName(); 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()); + notice << (u8) PLAYER_LIST_REMOVE << (u16) 1 << player_name; m_clients.sendToAll(¬ice); // run scripts m_script->on_leaveplayer(playersao, reason == CDR_TIMEOUT); @@ -2728,9 +2842,9 @@ void Server::DeleteClient(u16 peer_id, ClientDeletionReason reason) { 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 (const u16 client_id : clients) { + for (const session_t client_id : clients) { // Get player RemotePlayer *player = m_env->getPlayer(client_id); if (!player) @@ -2764,7 +2878,14 @@ void Server::DeleteClient(u16 peer_id, ClientDeletionReason reason) void Server::UpdateCrafting(RemotePlayer *player) { - DSTACK(FUNCTION_NAME); + InventoryList *clist = player->inventory.getList("craft"); + if (!clist || clist->getSize() == 0) + return; + + if (!clist->checkModified()) { + verbosestream << "Skip Server::UpdateCrafting(): list unmodified" << std::endl; + return; + } // Get a preview for crafting ItemStack preview; @@ -2773,13 +2894,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) @@ -2806,28 +2927,28 @@ std::wstring Server::handleChat(const std::string &name, const std::wstring &wna { // If something goes wrong, this player is to blame RollbackScopeActor rollback_scope(m_rollback, - std::string("player:") + name); + std::string("player:") + name); if (g_settings->getBool("strip_color_codes")) wmessage = unescape_enriched(wmessage); if (player) { switch (player->canSendChatMessage()) { - case RPLAYER_CHATRESULT_FLOODING: { - std::wstringstream ws; - ws << L"You cannot send more messages. You are limited to " - << g_settings->getFloat("chat_message_limit_per_10sec") - << L" messages per 10 seconds."; - return ws.str(); - } - case RPLAYER_CHATRESULT_KICK: - DenyAccess_Legacy(player->peer_id, - L"You have been kicked due to message flooding."); - return L""; - case RPLAYER_CHATRESULT_OK: - break; - default: - FATAL_ERROR("Unhandled chat filtering result found."); + case RPLAYER_CHATRESULT_FLOODING: { + std::wstringstream ws; + ws << L"You cannot send more messages. You are limited to " + << g_settings->getFloat("chat_message_limit_per_10sec") + << L" messages per 10 seconds."; + return ws.str(); + } + case RPLAYER_CHATRESULT_KICK: + DenyAccess_Legacy(player->getPeerId(), + L"You have been kicked due to message flooding."); + return L""; + case RPLAYER_CHATRESULT_OK: + break; + default: + FATAL_ERROR("Unhandled chat filtering result found."); } } @@ -2837,8 +2958,13 @@ std::wstring Server::handleChat(const std::string &name, const std::wstring &wna L"It was refused. Send a shorter message"; } + auto message = trim(wide_to_utf8(wmessage)); + if (message.find_first_of("\n\r") != std::wstring::npos) { + return L"New lines are not permitted in chat messages"; + } + // Run script hook, exit if script ate the chat message - if (m_script->on_chat_message(name, wide_to_utf8(wmessage))) + if (m_script->on_chat_message(name, message)) return L""; // Line to send @@ -2850,10 +2976,8 @@ std::wstring Server::handleChat(const std::string &name, const std::wstring &wna line += L"-!- You don't have permission to shout."; broadcast_line = false; } else { - line += L"<"; - line += wname; - line += L"> "; - line += wmessage; + line += narrow_to_wide(m_script->formatChatMessage(name, + wide_to_narrow(wmessage))); } /* @@ -2867,14 +2991,16 @@ std::wstring Server::handleChat(const std::string &name, const std::wstring &wna */ actionstream << "CHAT: " << wide_to_narrow(unescape_enriched(line)) << std::endl; - std::vector clients = m_clients.getClientIDs(); + 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); + session_t peer_id_to_avoid_sending = + (player ? player->getPeerId() : PEER_ID_INEXISTENT); + if (player && player->protocol_version >= 29) peer_id_to_avoid_sending = PEER_ID_INEXISTENT; @@ -2899,7 +3025,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) @@ -2907,12 +3033,12 @@ 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) @@ -2920,7 +3046,7 @@ std::string Server::getPlayerName(u16 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) @@ -2931,38 +3057,44 @@ PlayerSAO* Server::getPlayerSAO(u16 peer_id) std::wstring Server::getStatusString() { std::wostringstream os(std::ios_base::binary); - os< clients = m_clients.getClientIDs(); - for (u16 client_id : clients) { - // Get player - RemotePlayer *player = m_env->getPlayer(client_id); - // Get name of player - std::wstring name = L"unknown"; - if (player) - name = narrow_to_wide(player->getName()); - // Add name to information string - if(!first) - os << L", "; - else - first = false; - os << name; + os << L", clients={"; + if (m_env) { + std::vector clients = m_clients.getClientIDs(); + for (session_t client_id : clients) { + RemotePlayer *player = m_env->getPlayer(client_id); + + // Get name of player + std::wstring name = L"unknown"; + if (player) + name = narrow_to_wide(player->getName()); + + // Add name to information string + if (!first) + os << L", "; + else + first = false; + + os << name; + } } os << L"}"; - if (!((ServerMap*)(&m_env->getMap()))->isSavingEnabled()) - os<getMap()))->isSavingEnabled()) + os << std::endl << L"# Server: " << " WARNING: Map saving is disabled."; if (!g_settings->get("motd").empty()) - os<get("motd")); + os << std::endl << L"# Server: " << narrow_to_wide(g_settings->get("motd")); + return os.str(); } @@ -2982,8 +3114,8 @@ bool Server::checkPriv(const std::string &name, const std::string &priv) void Server::reportPrivsModified(const std::string &name) { if (name.empty()) { - std::vector clients = m_clients.getClientIDs(); - for (const u16 client_id : clients) { + std::vector clients = m_clients.getClientIDs(); + for (const session_t client_id : clients) { RemotePlayer *player = m_env->getPlayer(client_id); reportPrivsModified(player->getName()); } @@ -2991,7 +3123,7 @@ void Server::reportPrivsModified(const std::string &name) 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; @@ -3006,7 +3138,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) @@ -3039,10 +3179,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, ChatMessage(msg)); + SendChatMessage(player->getPeerId(), ChatMessage(msg)); } bool Server::showFormspec(const char *playername, const std::string &formspec, @@ -3056,7 +3196,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; } @@ -3067,7 +3207,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; } @@ -3083,7 +3223,7 @@ bool Server::hudRemove(RemotePlayer *player, u32 id) { delete todel; - SendHUDRemove(player->peer_id, id); + SendHUDRemove(player->getPeerId(), id); return true; } @@ -3092,7 +3232,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; } @@ -3101,7 +3241,7 @@ 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; @@ -3125,83 +3265,63 @@ 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; } -void Server::hudSetHotbarImage(RemotePlayer *player, std::string name) +void Server::hudSetHotbarImage(RemotePlayer *player, const std::string &name) { if (!player) 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) +void Server::hudSetHotbarSelectedImage(RemotePlayer *player, const std::string &name) { if (!player) 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, +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->peer_id, bgcolor, type, params, clouds); - return true; + SendSetSky(player->getPeerId(), bgcolor, type, params, clouds); } -bool Server::setClouds(RemotePlayer *player, float density, - const video::SColor &color_bright, - const video::SColor &color_ambient, - float height, - float thickness, - const v2f &speed) +void Server::setClouds(RemotePlayer *player, const CloudParams ¶ms) { - if (!player) - return false; - - SendCloudParams(player->peer_id, density, - color_bright, color_ambient, height, - thickness, speed); - return true; + sanity_check(player); + player->setCloudParams(params); + SendCloudParams(player->getPeerId(), params); } bool Server::overrideDayNightRatio(RemotePlayer *player, bool do_override, @@ -3211,7 +3331,7 @@ 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; } @@ -3223,7 +3343,7 @@ void Server::notifyPlayers(const std::wstring &msg) void Server::spawnParticle(const std::string &playername, v3f pos, v3f velocity, v3f acceleration, float expirationtime, float size, bool - collisiondetection, bool collision_removal, + collisiondetection, bool collision_removal, bool object_collision, bool vertical, const std::string &texture, const struct TileAnimationParams &animation, u8 glow) { @@ -3231,24 +3351,25 @@ void Server::spawnParticle(const std::string &playername, v3f pos, if (!m_env) return; - u16 peer_id = PEER_ID_INEXISTENT, proto_ver = 0; + 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; } SendSpawnParticle(peer_id, proto_ver, pos, velocity, acceleration, - expirationtime, size, collisiondetection, - collision_removal, vertical, texture, animation, glow); + expirationtime, size, collisiondetection, collision_removal, + object_collision, vertical, texture, animation, glow); } u32 Server::addParticleSpawner(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, + bool collisiondetection, bool collision_removal, bool object_collision, ServerActiveObject *attached, bool vertical, const std::string &texture, const std::string &playername, const struct TileAnimationParams &animation, u8 glow) @@ -3257,12 +3378,13 @@ u32 Server::addParticleSpawner(u16 amount, float spawntime, if (!m_env) return -1; - u16 peer_id = PEER_ID_INEXISTENT, proto_ver = 0; + 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; } @@ -3276,8 +3398,8 @@ u32 Server::addParticleSpawner(u16 amount, float spawntime, SendAddParticleSpawner(peer_id, proto_ver, amount, spawntime, minpos, maxpos, minvel, maxvel, minacc, maxacc, - minexptime, maxexptime, minsize, maxsize, - collisiondetection, collision_removal, attached_id, vertical, + minexptime, maxexptime, minsize, maxsize, collisiondetection, + collision_removal, object_collision, attached_id, vertical, texture, id, animation, glow); return id; @@ -3289,12 +3411,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; + 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); @@ -3312,12 +3434,41 @@ Inventory* Server::createDetachedInventory(const std::string &name, const std::s Inventory *inv = new Inventory(m_itemdef); sanity_check(inv); m_detached_inventories[name] = inv; - m_detached_inventories_player[name] = player; + if (!player.empty()) + m_detached_inventories_player[name] = player; + //TODO find a better way to do this sendDetachedInventory(name,PEER_ID_INEXISTENT); return inv; } +bool Server::removeDetachedInventory(const std::string &name) +{ + const auto &inv_it = m_detached_inventories.find(name); + if (inv_it == m_detached_inventories.end()) + return false; + + delete inv_it->second; + m_detached_inventories.erase(inv_it); + + if (!m_env) // Mods are not done loading + return true; + + const auto &player_it = m_detached_inventories_player.find(name); + if (player_it != m_detached_inventories_player.end()) { + RemotePlayer *player = m_env->getPlayer(player_it->second.c_str()); + + if (player && player->getPeerId() != PEER_ID_INEXISTENT) + sendDetachedInventory(name, player->getPeerId()); + + m_detached_inventories_player.erase(player_it); + } else { + // Notify all players about the change + sendDetachedInventory(name, PEER_ID_INEXISTENT); + } + return true; +} + // actions: time-reversed list // Return value: success/failure bool Server::rollbackRevertActions(const std::list &actions, @@ -3327,7 +3478,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; } @@ -3368,7 +3520,7 @@ IItemDefManager *Server::getItemDefManager() return m_itemdef; } -INodeDefManager *Server::getNodeDefManager() +const NodeDefManager *Server::getNodeDefManager() { return m_nodedef; } @@ -3383,17 +3535,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; } @@ -3403,22 +3550,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() @@ -3435,92 +3579,108 @@ v3f Server::findSpawnPos() { ServerMap &map = m_env->getServerMap(); v3f nodeposf; - if (g_settings->getV3FNoEx("static_spawnpoint", nodeposf)) { + if (g_settings->getV3FNoEx("static_spawnpoint", nodeposf)) return nodeposf * BS; - } 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++) { + for (s32 i = 0; i < 4000 && !is_good; 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))); - // Get spawn level at point s16 spawn_level = m_emerge->getSpawnLevelAtPoint(nodepos2d); - // Continue if MAX_MAP_GENERATION_LIMIT was returned by - // the mapgen to signify an unsuitable spawn position - if (spawn_level == MAX_MAP_GENERATION_LIMIT) + // Continue if MAX_MAP_GENERATION_LIMIT was returned by the mapgen to + // signify an unsuitable spawn position, or if outside limits. + if (spawn_level >= MAX_MAP_GENERATION_LIMIT || + spawn_level <= -MAX_MAP_GENERATION_LIMIT) continue; v3s16 nodepos(nodepos2d.X, spawn_level, nodepos2d.Y); - + // Consecutive empty nodes s32 air_count = 0; - for (s32 i = 0; i < 10; i++) { + + // Search upwards from 'spawn level' for 2 consecutive empty nodes, to + // avoid obstructions in already-generated mapblocks. + // In ungenerated mapblocks consisting of 'ignore' nodes, there will be + // no obstructions, but mapgen decorations are generated after spawn so + // the player may end up inside one. + for (s32 i = 0; i < 8; i++) { v3s16 blockpos = getNodeBlockPos(nodepos); map.emergeBlock(blockpos, true); - content_t c = map.getNodeNoEx(nodepos).getContent(); - if (c == CONTENT_AIR || c == CONTENT_IGNORE) { + content_t c = map.getNode(nodepos).getContent(); + + // In generated mapblocks allow spawn in all 'airlike' drawtype nodes. + // In ungenerated mapblocks allow spawn in 'ignore' nodes. + if (m_nodedef->get(c).drawtype == NDT_AIRLIKE || c == CONTENT_IGNORE) { air_count++; if (air_count >= 2) { + // Spawn in lower empty node + nodepos.Y--; nodeposf = intToFloat(nodepos, BS); // Don't spawn the player outside map boundaries if (objectpos_over_limit(nodeposf)) - continue; + // Exit this loop, positions above are probably over limit + break; + + // Good position found, cause an exit from main loop is_good = true; break; } + } else { + air_count = 0; } nodepos.Y++; } } - return nodeposf; + if (is_good) + return nodeposf; + + // No suitable spawn point found, return fallback 0,0,0 + return v3f(0.0f, 0.0f, 0.0f); } void Server::requestShutdown(const std::string &msg, bool reconnect, float delay) { - m_shutdown_timer = delay; - m_shutdown_msg = msg; - m_shutdown_ask_reconnect = reconnect; - if (delay == 0.0f) { // No delay, shutdown immediately - m_shutdown_requested = true; + 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_timer > 0.0f) { - // Negative delay, cancel shutdown if requested - m_shutdown_timer = 0.0f; - m_shutdown_msg = ""; - m_shutdown_ask_reconnect = false; - m_shutdown_requested = false; + } 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(m_shutdown_timer)).c_str() + << 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, u16 peer_id, u16 proto_version) +PlayerSAO* Server::emergePlayer(const char *name, session_t peer_id, u16 proto_version) { /* Try to get an existing player @@ -3528,7 +3688,7 @@ PlayerSAO* Server::emergePlayer(const char *name, u16 peer_id, u16 proto_version RemotePlayer *player = m_env->getPlayer(name); // If player is already connected, cancel - if (player && player->peer_id != 0) { + if (player && player->getPeerId() != PEER_ID_INEXISTENT) { infostream<<"emergePlayer(): Player already connected"<getFloat("profiler_print_interval"); + /* + * The dedicated server loop only does time-keeping (in Server::step) and + * provides a way to main.cpp to kill the server externally (bool &kill). + */ + for(;;) { // This is kind of a hack but can be done like this // because server.step() is very light - { - ScopeProfiler sp(g_profiler, "dedicated server sleep"); - sleep_ms((int)(steplen*1000.0)); - } + sleep_ms((int)(steplen*1000.0)); server.step(steplen); - if (server.getShutdownRequested() || kill) + if (server.isShutdownRequested() || kill) break; /* @@ -3630,3 +3790,68 @@ void dedicated_server_loop(Server &server, bool &kill) 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); + } +}