3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU Lesser General Public License as published by
7 the Free Software Foundation; either version 2.1 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public License along
16 with this program; if not, write to the Free Software Foundation, Inc.,
17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24 #include "network/connection.h"
25 #include "network/networkprotocol.h"
26 #include "network/serveropcodes.h"
28 #include "environment.h"
30 #include "threading/mutex_auto_lock.h"
31 #include "constants.h"
37 #include "server/serveractiveobject.h"
41 #include "scripting_server.h"
46 #include "mapgen/mapgen.h"
47 #include "mapgen/mg_biome.h"
48 #include "content_mapnode.h"
49 #include "content_nodemeta.h"
50 #include "content/mods.h"
51 #include "modchannels.h"
52 #include "serverlist.h"
53 #include "util/string.h"
55 #include "util/serialize.h"
56 #include "util/thread.h"
57 #include "defaultsettings.h"
58 #include "server/mods.h"
59 #include "util/base64.h"
60 #include "util/sha1.h"
62 #include "database/database.h"
63 #include "chatmessage.h"
64 #include "chat_interface.h"
65 #include "remoteplayer.h"
66 #include "server/player_sao.h"
67 #include "server/serverinventorymgr.h"
68 #include "translation.h"
70 class ClientNotFoundException : public BaseException
73 ClientNotFoundException(const char *s):
78 class ServerThread : public Thread
82 ServerThread(Server *server):
93 void *ServerThread::run()
95 BEGIN_DEBUG_EXCEPTION_HANDLER
98 * The real business of the server happens on the ServerThread.
100 * AsyncRunStep() runs an actual server step as soon as enough time has
101 * passed (dedicated_server_loop keeps track of that).
102 * Receive() blocks at least(!) 30ms waiting for a packet (so this loop
103 * doesn't busy wait) and will process any remaining packets.
106 m_server->AsyncRunStep(true);
108 while (!stopRequested()) {
110 m_server->AsyncRunStep();
114 } catch (con::PeerNotFoundException &e) {
115 infostream<<"Server: PeerNotFoundException"<<std::endl;
116 } catch (ClientNotFoundException &e) {
117 } catch (con::ConnectionBindFailed &e) {
118 m_server->setAsyncFatalError(e.what());
119 } catch (LuaError &e) {
120 m_server->setAsyncFatalError(
121 "ServerThread::run Lua: " + std::string(e.what()));
125 END_DEBUG_EXCEPTION_HANDLER
130 v3f ServerSoundParams::getPos(ServerEnvironment *env, bool *pos_exists) const
132 if(pos_exists) *pos_exists = false;
137 if(pos_exists) *pos_exists = true;
142 ServerActiveObject *sao = env->getActiveObject(object);
145 if(pos_exists) *pos_exists = true;
146 return sao->getBasePosition(); }
151 void Server::ShutdownState::reset()
155 should_reconnect = false;
156 is_requested = false;
159 void Server::ShutdownState::trigger(float delay, const std::string &msg, bool reconnect)
163 should_reconnect = reconnect;
166 void Server::ShutdownState::tick(float dtime, Server *server)
172 static const float shutdown_msg_times[] =
174 1, 2, 3, 4, 5, 10, 20, 40, 60, 120, 180, 300, 600, 1200, 1800, 3600
177 // Automated messages
178 if (m_timer < shutdown_msg_times[ARRLEN(shutdown_msg_times) - 1]) {
179 for (float t : shutdown_msg_times) {
180 // If shutdown timer matches an automessage, shot it
181 if (m_timer > t && m_timer - dtime < t) {
182 std::wstring periodicMsg = getShutdownTimerMessage();
184 infostream << wide_to_utf8(periodicMsg).c_str() << std::endl;
185 server->SendChatMessage(PEER_ID_INEXISTENT, periodicMsg);
192 if (m_timer < 0.0f) {
198 std::wstring Server::ShutdownState::getShutdownTimerMessage() const
200 std::wstringstream ws;
201 ws << L"*** Server shutting down in "
202 << duration_to_string(myround(m_timer)).c_str() << ".";
211 const std::string &path_world,
212 const SubgameSpec &gamespec,
213 bool simple_singleplayer_mode,
218 m_bind_addr(bind_addr),
219 m_path_world(path_world),
220 m_gamespec(gamespec),
221 m_simple_singleplayer_mode(simple_singleplayer_mode),
222 m_dedicated(dedicated),
223 m_async_fatal_error(""),
224 m_con(std::make_shared<con::Connection>(PROTOCOL_ID,
227 m_bind_addr.isIPv6(),
229 m_itemdef(createItemDefManager()),
230 m_nodedef(createNodeDefManager()),
231 m_craftdef(createCraftDefManager()),
232 m_thread(new ServerThread(this)),
235 m_modchannel_mgr(new ModChannelMgr())
237 if (m_path_world.empty())
238 throw ServerError("Supplied empty world path");
240 if (!gamespec.isValid())
241 throw ServerError("Supplied invalid gamespec");
244 m_metrics_backend = std::unique_ptr<MetricsBackend>(createPrometheusMetricsBackend());
246 m_metrics_backend = std::unique_ptr<MetricsBackend>(new MetricsBackend());
249 m_uptime_counter = m_metrics_backend->addCounter("minetest_core_server_uptime", "Server uptime (in seconds)");
250 m_player_gauge = m_metrics_backend->addGauge("minetest_core_player_number", "Number of connected players");
252 m_timeofday_gauge = m_metrics_backend->addGauge(
253 "minetest_core_timeofday",
254 "Time of day value");
256 m_lag_gauge = m_metrics_backend->addGauge(
257 "minetest_core_latency",
258 "Latency value (in seconds)");
260 m_aom_buffer_counter = m_metrics_backend->addCounter(
261 "minetest_core_aom_generated_count",
262 "Number of active object messages generated");
264 m_packet_recv_counter = m_metrics_backend->addCounter(
265 "minetest_core_server_packet_recv",
266 "Processable packets received");
268 m_packet_recv_processed_counter = m_metrics_backend->addCounter(
269 "minetest_core_server_packet_recv_processed",
270 "Valid received packets processed");
272 m_lag_gauge->set(g_settings->getFloat("dedicated_server_step"));
278 // Send shutdown message
279 SendChatMessage(PEER_ID_INEXISTENT, ChatMessage(CHATMESSAGE_TYPE_ANNOUNCE,
280 L"*** Server shutting down"));
283 MutexAutoLock envlock(m_env_mutex);
285 infostream << "Server: Saving players" << std::endl;
286 m_env->saveLoadedPlayers();
288 infostream << "Server: Kicking players" << std::endl;
289 std::string kick_msg;
290 bool reconnect = false;
291 if (isShutdownRequested()) {
292 reconnect = m_shutdown_state.should_reconnect;
293 kick_msg = m_shutdown_state.message;
295 if (kick_msg.empty()) {
296 kick_msg = g_settings->get("kick_msg_shutdown");
298 m_env->saveLoadedPlayers(true);
299 m_env->kickAllPlayers(SERVER_ACCESSDENIED_SHUTDOWN,
300 kick_msg, reconnect);
303 actionstream << "Server: Shutting down" << std::endl;
305 // Do this before stopping the server in case mapgen callbacks need to access
306 // server-controlled resources (like ModStorages). Also do them before
307 // shutdown callbacks since they may modify state that is finalized in a
310 m_emerge->stopThreads();
313 MutexAutoLock envlock(m_env_mutex);
315 // Execute script shutdown hooks
316 infostream << "Executing shutdown hooks" << std::endl;
317 m_script->on_shutdown();
319 infostream << "Server: Saving environment metadata" << std::endl;
329 // Delete things in the reverse order of creation
338 // Deinitialize scripting
339 infostream << "Server: Deinitializing scripting" << std::endl;
342 while (!m_unsent_map_edit_queue.empty()) {
343 delete m_unsent_map_edit_queue.front();
344 m_unsent_map_edit_queue.pop();
350 infostream << "Server created for gameid \"" << m_gamespec.id << "\"";
351 if (m_simple_singleplayer_mode)
352 infostream << " in simple singleplayer mode" << std::endl;
354 infostream << std::endl;
355 infostream << "- world: " << m_path_world << std::endl;
356 infostream << "- game: " << m_gamespec.path << std::endl;
358 // Create world if it doesn't exist
359 if (!loadGameConfAndInitWorld(m_path_world, m_gamespec))
360 throw ServerError("Failed to initialize world");
362 // Create emerge manager
363 m_emerge = new EmergeManager(this);
365 // Create ban manager
366 std::string ban_path = m_path_world + DIR_DELIM "ipban.txt";
367 m_banmanager = new BanManager(ban_path);
369 m_modmgr = std::unique_ptr<ServerModManager>(new ServerModManager(m_path_world));
370 std::vector<ModSpec> unsatisfied_mods = m_modmgr->getUnsatisfiedMods();
371 // complain about mods with unsatisfied dependencies
372 if (!m_modmgr->isConsistent()) {
373 m_modmgr->printUnsatisfiedModsError();
377 MutexAutoLock envlock(m_env_mutex);
379 // Create the Map (loads map_meta.txt, overriding configured mapgen params)
380 ServerMap *servermap = new ServerMap(m_path_world, this, m_emerge, m_metrics_backend.get());
382 // Initialize scripting
383 infostream << "Server: Initializing Lua" << std::endl;
385 m_script = new ServerScripting(this);
387 // Must be created before mod loading because we have some inventory creation
388 m_inventory_mgr = std::unique_ptr<ServerInventoryManager>(new ServerInventoryManager());
390 m_script->loadMod(getBuiltinLuaPath() + DIR_DELIM "init.lua", BUILTIN_MOD_NAME);
392 m_modmgr->loadMods(m_script);
394 // Read Textures and calculate sha1 sums
397 // Apply item aliases in the node definition manager
398 m_nodedef->updateAliases(m_itemdef);
400 // Apply texture overrides from texturepack/override.txt
401 std::vector<std::string> paths;
402 fs::GetRecursiveDirs(paths, g_settings->get("texture_path"));
403 fs::GetRecursiveDirs(paths, m_gamespec.path + DIR_DELIM + "textures");
404 for (const std::string &path : paths) {
405 TextureOverrideSource override_source(path + DIR_DELIM + "override.txt");
406 m_nodedef->applyTextureOverrides(override_source.getNodeTileOverrides());
407 m_itemdef->applyTextureOverrides(override_source.getItemTextureOverrides());
410 m_nodedef->setNodeRegistrationStatus(true);
412 // Perform pending node name resolutions
413 m_nodedef->runNodeResolveCallbacks();
415 // unmap node names for connected nodeboxes
416 m_nodedef->mapNodeboxConnections();
418 // init the recipe hashes to speed up crafting
419 m_craftdef->initHashes(this);
421 // Initialize Environment
422 m_env = new ServerEnvironment(servermap, m_script, this, m_path_world);
424 m_inventory_mgr->setEnv(m_env);
425 m_clients.setEnv(m_env);
427 if (!servermap->settings_mgr.makeMapgenParams())
428 FATAL_ERROR("Couldn't create any mapgen type");
430 // Initialize mapgens
431 m_emerge->initMapgens(servermap->getMapgenParams());
433 if (g_settings->getBool("enable_rollback_recording")) {
434 // Create rollback manager
435 m_rollback = new RollbackManager(m_path_world, this);
438 // Give environment reference to scripting api
439 m_script->initializeEnvironment(m_env);
441 // Register us to receive map edit events
442 servermap->addEventReceiver(this);
446 // Those settings can be overwritten in world.mt, they are
447 // intended to be cached after environment loading.
448 m_liquid_transform_every = g_settings->getFloat("liquid_update");
449 m_max_chatmessage_length = g_settings->getU16("chat_message_max_size");
450 m_csm_restriction_flags = g_settings->getU64("csm_restriction_flags");
451 m_csm_restriction_noderange = g_settings->getU32("csm_restriction_noderange");
458 infostream << "Starting server on " << m_bind_addr.serializeString()
459 << "..." << std::endl;
461 // Stop thread if already running
464 // Initialize connection
465 m_con->SetTimeoutMs(30);
466 m_con->Serve(m_bind_addr);
471 // ASCII art for the win!
473 << " .__ __ __ " << std::endl
474 << " _____ |__| ____ _____/ |_ ____ _______/ |_ " << std::endl
475 << " / \\| |/ \\_/ __ \\ __\\/ __ \\ / ___/\\ __\\" << std::endl
476 << "| Y Y \\ | | \\ ___/| | \\ ___/ \\___ \\ | | " << std::endl
477 << "|__|_| /__|___| /\\___ >__| \\___ >____ > |__| " << std::endl
478 << " \\/ \\/ \\/ \\/ \\/ " << std::endl;
479 actionstream << "World at [" << m_path_world << "]" << std::endl;
480 actionstream << "Server for gameid=\"" << m_gamespec.id
481 << "\" listening on " << m_bind_addr.serializeString() << ":"
482 << m_bind_addr.getPort() << "." << std::endl;
487 infostream<<"Server: Stopping and waiting threads"<<std::endl;
489 // Stop threads (set run=false first so both start stopping)
491 //m_emergethread.setRun(false);
493 //m_emergethread.stop();
495 infostream<<"Server: Threads stopped"<<std::endl;
498 void Server::step(float dtime)
504 MutexAutoLock lock(m_step_dtime_mutex);
505 m_step_dtime += dtime;
507 // Throw if fatal error occurred in thread
508 std::string async_err = m_async_fatal_error.get();
509 if (!async_err.empty()) {
510 if (!m_simple_singleplayer_mode) {
511 m_env->kickAllPlayers(SERVER_ACCESSDENIED_CRASH,
512 g_settings->get("kick_msg_crash"),
513 g_settings->getBool("ask_reconnect_on_crash"));
515 throw ServerError("AsyncErr: " + async_err);
519 void Server::AsyncRunStep(bool initial_step)
524 MutexAutoLock lock1(m_step_dtime_mutex);
525 dtime = m_step_dtime;
529 // Send blocks to clients
533 if((dtime < 0.001) && !initial_step)
536 ScopeProfiler sp(g_profiler, "Server::AsyncRunStep()", SPT_AVG);
539 MutexAutoLock lock1(m_step_dtime_mutex);
540 m_step_dtime -= dtime;
546 m_uptime_counter->increment(dtime);
551 Update time of day and overall game time
553 m_env->setTimeOfDaySpeed(g_settings->getFloat("time_speed"));
556 Send to clients at constant intervals
559 m_time_of_day_send_timer -= dtime;
560 if (m_time_of_day_send_timer < 0.0) {
561 m_time_of_day_send_timer = g_settings->getFloat("time_send_interval");
562 u16 time = m_env->getTimeOfDay();
563 float time_speed = g_settings->getFloat("time_speed");
564 SendTimeOfDay(PEER_ID_INEXISTENT, time, time_speed);
566 m_timeofday_gauge->set(time);
570 MutexAutoLock lock(m_env_mutex);
571 // Figure out and report maximum lag to environment
572 float max_lag = m_env->getMaxLagEstimate();
573 max_lag *= 0.9998; // Decrease slowly (about half per 5 minutes)
575 if(dtime > 0.1 && dtime > max_lag * 2.0)
576 infostream<<"Server: Maximum lag peaked to "<<dtime
580 m_env->reportMaxLagEstimate(max_lag);
585 static const float map_timer_and_unload_dtime = 2.92;
586 if(m_map_timer_and_unload_interval.step(dtime, map_timer_and_unload_dtime))
588 MutexAutoLock lock(m_env_mutex);
589 // Run Map's timers and unload unused data
590 ScopeProfiler sp(g_profiler, "Server: map timer and unload");
591 m_env->getMap().timerUpdate(map_timer_and_unload_dtime,
592 g_settings->getFloat("server_unload_unused_data_timeout"),
597 Listen to the admin chat, if available
600 if (!m_admin_chat->command_queue.empty()) {
601 MutexAutoLock lock(m_env_mutex);
602 while (!m_admin_chat->command_queue.empty()) {
603 ChatEvent *evt = m_admin_chat->command_queue.pop_frontNoEx();
604 handleChatInterfaceEvent(evt);
608 m_admin_chat->outgoing_queue.push_back(
609 new ChatEventTimeInfo(m_env->getGameTime(), m_env->getTimeOfDay()));
616 /* Transform liquids */
617 m_liquid_transform_timer += dtime;
618 if(m_liquid_transform_timer >= m_liquid_transform_every)
620 m_liquid_transform_timer -= m_liquid_transform_every;
622 MutexAutoLock lock(m_env_mutex);
624 ScopeProfiler sp(g_profiler, "Server: liquid transform");
626 std::map<v3s16, MapBlock*> modified_blocks;
627 m_env->getMap().transformLiquids(modified_blocks, m_env);
630 Set the modified blocks unsent for all the clients
632 if (!modified_blocks.empty()) {
633 SetBlocksNotSent(modified_blocks);
636 m_clients.step(dtime);
638 m_lag_gauge->increment((m_lag_gauge->get() > dtime ? -1 : 1) * dtime/100);
640 // send masterserver announce
642 float &counter = m_masterserver_timer;
643 if (!isSingleplayer() && (!counter || counter >= 300.0) &&
644 g_settings->getBool("server_announce")) {
645 ServerList::sendAnnounce(counter ? ServerList::AA_UPDATE :
646 ServerList::AA_START,
647 m_bind_addr.getPort(),
648 m_clients.getPlayerNames(),
649 m_uptime_counter->get(),
650 m_env->getGameTime(),
653 Mapgen::getMapgenName(m_emerge->mgparams->mgtype),
663 Check added and deleted active objects
666 //infostream<<"Server: Checking added and deleted active objects"<<std::endl;
667 MutexAutoLock envlock(m_env_mutex);
670 const RemoteClientMap &clients = m_clients.getClientList();
671 ScopeProfiler sp(g_profiler, "Server: update objects within range");
673 m_player_gauge->set(clients.size());
674 for (const auto &client_it : clients) {
675 RemoteClient *client = client_it.second;
677 if (client->getState() < CS_DefinitionsSent)
680 // This can happen if the client times out somehow
681 if (!m_env->getPlayer(client->peer_id))
684 PlayerSAO *playersao = getPlayerSAO(client->peer_id);
688 SendActiveObjectRemoveAdd(client, playersao);
692 // Save mod storages if modified
693 m_mod_storage_save_timer -= dtime;
694 if (m_mod_storage_save_timer <= 0.0f) {
695 m_mod_storage_save_timer = g_settings->getFloat("server_map_save_interval");
697 for (std::unordered_map<std::string, ModMetadata *>::const_iterator
698 it = m_mod_storages.begin(); it != m_mod_storages.end(); ++it) {
699 if (it->second->isModified()) {
700 it->second->save(getModStoragePath());
705 infostream << "Saved " << n << " modified mod storages." << std::endl;
713 MutexAutoLock envlock(m_env_mutex);
714 ScopeProfiler sp(g_profiler, "Server: send SAO messages");
717 // Value = data sent by object
718 std::unordered_map<u16, std::vector<ActiveObjectMessage>*> buffered_messages;
720 // Get active object messages from environment
722 ActiveObjectMessage aom = m_env->getActiveObjectMessage();
726 std::vector<ActiveObjectMessage>* message_list = nullptr;
727 std::unordered_map<u16, std::vector<ActiveObjectMessage>* >::iterator n;
728 n = buffered_messages.find(aom.id);
729 if (n == buffered_messages.end()) {
730 message_list = new std::vector<ActiveObjectMessage>;
731 buffered_messages[aom.id] = message_list;
734 message_list = n->second;
736 message_list->push_back(aom);
739 m_aom_buffer_counter->increment(buffered_messages.size());
742 const RemoteClientMap &clients = m_clients.getClientList();
743 // Route data to every client
744 for (const auto &client_it : clients) {
745 RemoteClient *client = client_it.second;
746 PlayerSAO *player = getPlayerSAO(client->peer_id);
747 std::string reliable_data;
748 std::string unreliable_data;
749 // Go through all objects in message buffer
750 for (const auto &buffered_message : buffered_messages) {
751 // If object does not exist or is not known by client, skip it
752 u16 id = buffered_message.first;
753 ServerActiveObject *sao = m_env->getActiveObject(id);
754 if (!sao || client->m_known_objects.find(id) == client->m_known_objects.end())
757 // Get message list of object
758 std::vector<ActiveObjectMessage>* list = buffered_message.second;
759 // Go through every message
760 for (const ActiveObjectMessage &aom : *list) {
761 // Send position updates to players who do not see the attachment
762 if (aom.datastring[0] == AO_CMD_UPDATE_POSITION) {
763 if (sao->getId() == player->getId())
766 // Do not send position updates for attached players
767 // as long the parent is known to the client
768 ServerActiveObject *parent = sao->getParent();
769 if (parent && client->m_known_objects.find(parent->getId()) !=
770 client->m_known_objects.end())
773 // Compose the full new data with header
774 std::string new_data;
777 writeU16((u8*)&buf[0], aom.id);
778 new_data.append(buf, 2);
780 new_data += serializeString(aom.datastring);
781 // Add data to buffer
783 reliable_data += new_data;
785 unreliable_data += new_data;
789 reliable_data and unreliable_data are now ready.
792 if (!reliable_data.empty()) {
793 SendActiveObjectMessages(client->peer_id, reliable_data);
796 if (!unreliable_data.empty()) {
797 SendActiveObjectMessages(client->peer_id, unreliable_data, false);
802 // Clear buffered_messages
803 for (auto &buffered_message : buffered_messages) {
804 delete buffered_message.second;
809 Send queued-for-sending map edit events.
812 // We will be accessing the environment
813 MutexAutoLock lock(m_env_mutex);
815 // Don't send too many at a time
818 // Single change sending is disabled if queue size is not small
819 bool disable_single_change_sending = false;
820 if(m_unsent_map_edit_queue.size() >= 4)
821 disable_single_change_sending = true;
823 int event_count = m_unsent_map_edit_queue.size();
825 // We'll log the amount of each
828 std::list<v3s16> node_meta_updates;
830 while (!m_unsent_map_edit_queue.empty()) {
831 MapEditEvent* event = m_unsent_map_edit_queue.front();
832 m_unsent_map_edit_queue.pop();
834 // Players far away from the change are stored here.
835 // Instead of sending the changes, MapBlocks are set not sent
837 std::unordered_set<u16> far_players;
839 switch (event->type) {
842 prof.add("MEET_ADDNODE", 1);
843 sendAddNode(event->p, event->n, &far_players,
844 disable_single_change_sending ? 5 : 30,
845 event->type == MEET_ADDNODE);
847 case MEET_REMOVENODE:
848 prof.add("MEET_REMOVENODE", 1);
849 sendRemoveNode(event->p, &far_players,
850 disable_single_change_sending ? 5 : 30);
852 case MEET_BLOCK_NODE_METADATA_CHANGED: {
853 prof.add("MEET_BLOCK_NODE_METADATA_CHANGED", 1);
854 if (!event->is_private_change) {
855 // Don't send the change yet. Collect them to eliminate dupes.
856 node_meta_updates.remove(event->p);
857 node_meta_updates.push_back(event->p);
860 if (MapBlock *block = m_env->getMap().getBlockNoCreateNoEx(
861 getNodeBlockPos(event->p))) {
862 block->raiseModified(MOD_STATE_WRITE_NEEDED,
863 MOD_REASON_REPORT_META_CHANGE);
868 prof.add("MEET_OTHER", 1);
869 for (const v3s16 &modified_block : event->modified_blocks) {
870 m_clients.markBlockposAsNotSent(modified_block);
874 prof.add("unknown", 1);
875 warningstream << "Server: Unknown MapEditEvent "
876 << ((u32)event->type) << std::endl;
881 Set blocks not sent to far players
883 if (!far_players.empty()) {
884 // Convert list format to that wanted by SetBlocksNotSent
885 std::map<v3s16, MapBlock*> modified_blocks2;
886 for (const v3s16 &modified_block : event->modified_blocks) {
887 modified_blocks2[modified_block] =
888 m_env->getMap().getBlockNoCreateNoEx(modified_block);
891 // Set blocks not sent
892 for (const u16 far_player : far_players) {
893 if (RemoteClient *client = getClient(far_player))
894 client->SetBlocksNotSent(modified_blocks2);
901 if (event_count >= 5) {
902 infostream << "Server: MapEditEvents:" << std::endl;
903 prof.print(infostream);
904 } else if (event_count != 0) {
905 verbosestream << "Server: MapEditEvents:" << std::endl;
906 prof.print(verbosestream);
909 // Send all metadata updates
910 if (node_meta_updates.size())
911 sendMetadataChanged(node_meta_updates);
915 Trigger emergethread (it somehow gets to a non-triggered but
916 bysy state sometimes)
919 float &counter = m_emergethread_trigger_timer;
921 if (counter >= 2.0) {
924 m_emerge->startThreads();
928 // Save map, players and auth stuff
930 float &counter = m_savemap_timer;
932 static thread_local const float save_interval =
933 g_settings->getFloat("server_map_save_interval");
934 if (counter >= save_interval) {
936 MutexAutoLock lock(m_env_mutex);
938 ScopeProfiler sp(g_profiler, "Server: map saving (sum)");
941 if (m_banmanager->isModified()) {
942 m_banmanager->save();
945 // Save changed parts of map
946 m_env->getMap().save(MOD_STATE_WRITE_NEEDED);
949 m_env->saveLoadedPlayers();
951 // Save environment metadata
956 m_shutdown_state.tick(dtime, this);
959 void Server::Receive()
969 In the first iteration *wait* for a packet, afterwards process
970 all packets that are immediately available (no waiting).
973 m_con->Receive(&pkt);
976 if (!m_con->TryReceive(&pkt))
980 peer_id = pkt.getPeerId();
981 m_packet_recv_counter->increment();
983 m_packet_recv_processed_counter->increment();
984 } catch (const con::InvalidIncomingDataException &e) {
985 infostream << "Server::Receive(): InvalidIncomingDataException: what()="
986 << e.what() << std::endl;
987 } catch (const SerializationError &e) {
988 infostream << "Server::Receive(): SerializationError: what()="
989 << e.what() << std::endl;
990 } catch (const ClientStateError &e) {
991 errorstream << "ProcessData: peer=" << peer_id << " what()="
992 << e.what() << std::endl;
993 DenyAccess_Legacy(peer_id, L"Your client sent something server didn't expect."
994 L"Try reconnecting or updating your client");
995 } catch (const con::PeerNotFoundException &e) {
997 } catch (const con::NoIncomingDataException &e) {
1003 PlayerSAO* Server::StageTwoClientInit(session_t peer_id)
1005 std::string playername;
1006 PlayerSAO *playersao = NULL;
1009 RemoteClient* client = m_clients.lockedGetClientNoEx(peer_id, CS_InitDone);
1011 playername = client->getName();
1012 playersao = emergePlayer(playername.c_str(), peer_id, client->net_proto_version);
1014 } catch (std::exception &e) {
1020 RemotePlayer *player = m_env->getPlayer(playername.c_str());
1022 // If failed, cancel
1023 if (!playersao || !player) {
1024 if (player && player->getPeerId() != PEER_ID_INEXISTENT) {
1025 actionstream << "Server: Failed to emerge player \"" << playername
1026 << "\" (player allocated to an another client)" << std::endl;
1027 DenyAccess_Legacy(peer_id, L"Another client is connected with this "
1028 L"name. If your client closed unexpectedly, try again in "
1031 errorstream << "Server: " << playername << ": Failed to emerge player"
1033 DenyAccess_Legacy(peer_id, L"Could not allocate player.");
1039 Send complete position information
1041 SendMovePlayer(peer_id);
1044 SendPlayerPrivileges(peer_id);
1046 // Send inventory formspec
1047 SendPlayerInventoryFormspec(peer_id);
1050 SendInventory(playersao, false);
1052 // Send HP or death screen
1053 if (playersao->isDead())
1054 SendDeathscreen(peer_id, false, v3f(0,0,0));
1056 SendPlayerHPOrDie(playersao,
1057 PlayerHPChangeReason(PlayerHPChangeReason::SET_HP));
1060 SendPlayerBreath(playersao);
1066 Address addr = getPeerAddress(player->getPeerId());
1067 std::string ip_str = addr.serializeString();
1068 const std::vector<std::string> &names = m_clients.getPlayerNames();
1070 actionstream << player->getName() << " [" << ip_str << "] joins game. List of players: ";
1072 for (const std::string &name : names) {
1073 actionstream << name << " ";
1076 actionstream << player->getName() <<std::endl;
1081 inline void Server::handleCommand(NetworkPacket *pkt)
1083 const ToServerCommandHandler &opHandle = toServerCommandTable[pkt->getCommand()];
1084 (this->*opHandle.handler)(pkt);
1087 void Server::ProcessData(NetworkPacket *pkt)
1089 // Environment is locked first.
1090 MutexAutoLock envlock(m_env_mutex);
1092 ScopeProfiler sp(g_profiler, "Server: Process network packet (sum)");
1093 u32 peer_id = pkt->getPeerId();
1096 Address address = getPeerAddress(peer_id);
1097 std::string addr_s = address.serializeString();
1099 if(m_banmanager->isIpBanned(addr_s)) {
1100 std::string ban_name = m_banmanager->getBanName(addr_s);
1101 infostream << "Server: A banned client tried to connect from "
1102 << addr_s << "; banned name was "
1103 << ban_name << std::endl;
1104 // This actually doesn't seem to transfer to the client
1105 DenyAccess_Legacy(peer_id, L"Your ip is banned. Banned name was "
1106 + utf8_to_wide(ban_name));
1110 catch(con::PeerNotFoundException &e) {
1112 * no peer for this packet found
1113 * most common reason is peer timeout, e.g. peer didn't
1114 * respond for some time, your server was overloaded or
1117 infostream << "Server::ProcessData(): Canceling: peer "
1118 << peer_id << " not found" << std::endl;
1123 ToServerCommand command = (ToServerCommand) pkt->getCommand();
1125 // Command must be handled into ToServerCommandHandler
1126 if (command >= TOSERVER_NUM_MSG_TYPES) {
1127 infostream << "Server: Ignoring unknown command "
1128 << command << std::endl;
1132 if (toServerCommandTable[command].state == TOSERVER_STATE_NOT_CONNECTED) {
1137 u8 peer_ser_ver = getClient(peer_id, CS_InitDone)->serialization_version;
1139 if(peer_ser_ver == SER_FMT_VER_INVALID) {
1140 errorstream << "Server::ProcessData(): Cancelling: Peer"
1141 " serialization format invalid or not initialized."
1142 " Skipping incoming command=" << command << std::endl;
1146 /* Handle commands related to client startup */
1147 if (toServerCommandTable[command].state == TOSERVER_STATE_STARTUP) {
1152 if (m_clients.getClientState(peer_id) < CS_Active) {
1153 if (command == TOSERVER_PLAYERPOS) return;
1155 errorstream << "Got packet command: " << command << " for peer id "
1156 << peer_id << " but client isn't active yet. Dropping packet "
1162 } catch (SendFailedException &e) {
1163 errorstream << "Server::ProcessData(): SendFailedException: "
1164 << "what=" << e.what()
1166 } catch (PacketError &e) {
1167 actionstream << "Server::ProcessData(): PacketError: "
1168 << "what=" << e.what()
1173 void Server::setTimeOfDay(u32 time)
1175 m_env->setTimeOfDay(time);
1176 m_time_of_day_send_timer = 0;
1179 void Server::onMapEditEvent(const MapEditEvent &event)
1181 if (m_ignore_map_edit_events_area.contains(event.getArea()))
1184 m_unsent_map_edit_queue.push(new MapEditEvent(event));
1187 void Server::SetBlocksNotSent(std::map<v3s16, MapBlock *>& block)
1189 std::vector<session_t> clients = m_clients.getClientIDs();
1191 // Set the modified blocks unsent for all the clients
1192 for (const session_t client_id : clients) {
1193 if (RemoteClient *client = m_clients.lockedGetClientNoEx(client_id))
1194 client->SetBlocksNotSent(block);
1199 void Server::peerAdded(con::Peer *peer)
1201 verbosestream<<"Server::peerAdded(): peer->id="
1202 <<peer->id<<std::endl;
1204 m_peer_change_queue.push(con::PeerChange(con::PEER_ADDED, peer->id, false));
1207 void Server::deletingPeer(con::Peer *peer, bool timeout)
1209 verbosestream<<"Server::deletingPeer(): peer->id="
1210 <<peer->id<<", timeout="<<timeout<<std::endl;
1212 m_clients.event(peer->id, CSE_Disconnect);
1213 m_peer_change_queue.push(con::PeerChange(con::PEER_REMOVED, peer->id, timeout));
1216 bool Server::getClientConInfo(session_t peer_id, con::rtt_stat_type type, float* retval)
1218 *retval = m_con->getPeerStat(peer_id,type);
1219 return *retval != -1;
1222 bool Server::getClientInfo(
1231 std::string* vers_string,
1232 std::string* lang_code
1235 *state = m_clients.getClientState(peer_id);
1237 RemoteClient* client = m_clients.lockedGetClientNoEx(peer_id, CS_Invalid);
1244 *uptime = client->uptime();
1245 *ser_vers = client->serialization_version;
1246 *prot_vers = client->net_proto_version;
1248 *major = client->getMajor();
1249 *minor = client->getMinor();
1250 *patch = client->getPatch();
1251 *vers_string = client->getFull();
1252 *lang_code = client->getLangCode();
1259 void Server::handlePeerChanges()
1261 while(!m_peer_change_queue.empty())
1263 con::PeerChange c = m_peer_change_queue.front();
1264 m_peer_change_queue.pop();
1266 verbosestream<<"Server: Handling peer change: "
1267 <<"id="<<c.peer_id<<", timeout="<<c.timeout
1272 case con::PEER_ADDED:
1273 m_clients.CreateClient(c.peer_id);
1276 case con::PEER_REMOVED:
1277 DeleteClient(c.peer_id, c.timeout?CDR_TIMEOUT:CDR_LEAVE);
1281 FATAL_ERROR("Invalid peer change event received!");
1287 void Server::printToConsoleOnly(const std::string &text)
1290 m_admin_chat->outgoing_queue.push_back(
1291 new ChatEventChat("", utf8_to_wide(text)));
1293 std::cout << text << std::endl;
1297 void Server::Send(NetworkPacket *pkt)
1299 Send(pkt->getPeerId(), pkt);
1302 void Server::Send(session_t peer_id, NetworkPacket *pkt)
1304 m_clients.send(peer_id,
1305 clientCommandFactoryTable[pkt->getCommand()].channel,
1307 clientCommandFactoryTable[pkt->getCommand()].reliable);
1310 void Server::SendMovement(session_t peer_id)
1312 std::ostringstream os(std::ios_base::binary);
1314 NetworkPacket pkt(TOCLIENT_MOVEMENT, 12 * sizeof(float), peer_id);
1316 pkt << g_settings->getFloat("movement_acceleration_default");
1317 pkt << g_settings->getFloat("movement_acceleration_air");
1318 pkt << g_settings->getFloat("movement_acceleration_fast");
1319 pkt << g_settings->getFloat("movement_speed_walk");
1320 pkt << g_settings->getFloat("movement_speed_crouch");
1321 pkt << g_settings->getFloat("movement_speed_fast");
1322 pkt << g_settings->getFloat("movement_speed_climb");
1323 pkt << g_settings->getFloat("movement_speed_jump");
1324 pkt << g_settings->getFloat("movement_liquid_fluidity");
1325 pkt << g_settings->getFloat("movement_liquid_fluidity_smooth");
1326 pkt << g_settings->getFloat("movement_liquid_sink");
1327 pkt << g_settings->getFloat("movement_gravity");
1332 void Server::SendPlayerHPOrDie(PlayerSAO *playersao, const PlayerHPChangeReason &reason)
1334 if (playersao->isImmortal())
1337 session_t peer_id = playersao->getPeerID();
1338 bool is_alive = playersao->getHP() > 0;
1341 SendPlayerHP(peer_id);
1343 DiePlayer(peer_id, reason);
1346 void Server::SendHP(session_t peer_id, u16 hp)
1348 NetworkPacket pkt(TOCLIENT_HP, 1, peer_id);
1353 void Server::SendBreath(session_t peer_id, u16 breath)
1355 NetworkPacket pkt(TOCLIENT_BREATH, 2, peer_id);
1356 pkt << (u16) breath;
1360 void Server::SendAccessDenied(session_t peer_id, AccessDeniedCode reason,
1361 const std::string &custom_reason, bool reconnect)
1363 assert(reason < SERVER_ACCESSDENIED_MAX);
1365 NetworkPacket pkt(TOCLIENT_ACCESS_DENIED, 1, peer_id);
1367 if (reason == SERVER_ACCESSDENIED_CUSTOM_STRING)
1368 pkt << custom_reason;
1369 else if (reason == SERVER_ACCESSDENIED_SHUTDOWN ||
1370 reason == SERVER_ACCESSDENIED_CRASH)
1371 pkt << custom_reason << (u8)reconnect;
1375 void Server::SendAccessDenied_Legacy(session_t peer_id,const std::wstring &reason)
1377 NetworkPacket pkt(TOCLIENT_ACCESS_DENIED_LEGACY, 0, peer_id);
1382 void Server::SendDeathscreen(session_t peer_id, bool set_camera_point_target,
1383 v3f camera_point_target)
1385 NetworkPacket pkt(TOCLIENT_DEATHSCREEN, 1 + sizeof(v3f), peer_id);
1386 pkt << set_camera_point_target << camera_point_target;
1390 void Server::SendItemDef(session_t peer_id,
1391 IItemDefManager *itemdef, u16 protocol_version)
1393 NetworkPacket pkt(TOCLIENT_ITEMDEF, 0, peer_id);
1397 u32 length of the next item
1398 zlib-compressed serialized ItemDefManager
1400 std::ostringstream tmp_os(std::ios::binary);
1401 itemdef->serialize(tmp_os, protocol_version);
1402 std::ostringstream tmp_os2(std::ios::binary);
1403 compressZlib(tmp_os.str(), tmp_os2);
1404 pkt.putLongString(tmp_os2.str());
1407 verbosestream << "Server: Sending item definitions to id(" << peer_id
1408 << "): size=" << pkt.getSize() << std::endl;
1413 void Server::SendNodeDef(session_t peer_id,
1414 const NodeDefManager *nodedef, u16 protocol_version)
1416 NetworkPacket pkt(TOCLIENT_NODEDEF, 0, peer_id);
1420 u32 length of the next item
1421 zlib-compressed serialized NodeDefManager
1423 std::ostringstream tmp_os(std::ios::binary);
1424 nodedef->serialize(tmp_os, protocol_version);
1425 std::ostringstream tmp_os2(std::ios::binary);
1426 compressZlib(tmp_os.str(), tmp_os2);
1428 pkt.putLongString(tmp_os2.str());
1431 verbosestream << "Server: Sending node definitions to id(" << peer_id
1432 << "): size=" << pkt.getSize() << std::endl;
1438 Non-static send methods
1441 void Server::SendInventory(PlayerSAO *sao, bool incremental)
1443 RemotePlayer *player = sao->getPlayer();
1445 // Do not send new format to old clients
1446 incremental &= player->protocol_version >= 38;
1448 UpdateCrafting(player);
1454 NetworkPacket pkt(TOCLIENT_INVENTORY, 0, sao->getPeerID());
1456 std::ostringstream os(std::ios::binary);
1457 sao->getInventory()->serialize(os, incremental);
1458 sao->getInventory()->setModified(false);
1459 player->setModified(true);
1461 const std::string &s = os.str();
1462 pkt.putRawString(s.c_str(), s.size());
1466 void Server::SendChatMessage(session_t peer_id, const ChatMessage &message)
1468 NetworkPacket pkt(TOCLIENT_CHAT_MESSAGE, 0, peer_id);
1470 u8 type = message.type;
1471 pkt << version << type << std::wstring(L"") << message.message << (u64)message.timestamp;
1473 if (peer_id != PEER_ID_INEXISTENT) {
1474 RemotePlayer *player = m_env->getPlayer(peer_id);
1480 m_clients.sendToAll(&pkt);
1484 void Server::SendShowFormspecMessage(session_t peer_id, const std::string &formspec,
1485 const std::string &formname)
1487 NetworkPacket pkt(TOCLIENT_SHOW_FORMSPEC, 0, peer_id);
1488 if (formspec.empty()){
1489 //the client should close the formspec
1490 //but make sure there wasn't another one open in meantime
1491 const auto it = m_formspec_state_data.find(peer_id);
1492 if (it != m_formspec_state_data.end() && it->second == formname) {
1493 m_formspec_state_data.erase(peer_id);
1495 pkt.putLongString("");
1497 m_formspec_state_data[peer_id] = formname;
1498 pkt.putLongString(formspec);
1505 // Spawns a particle on peer with peer_id
1506 void Server::SendSpawnParticle(session_t peer_id, u16 protocol_version,
1507 v3f pos, v3f velocity, v3f acceleration,
1508 float expirationtime, float size, bool collisiondetection,
1509 bool collision_removal, bool object_collision,
1510 bool vertical, const std::string &texture,
1511 const struct TileAnimationParams &animation, u8 glow)
1513 static thread_local const float radius =
1514 g_settings->getS16("max_block_send_distance") * MAP_BLOCKSIZE * BS;
1516 if (peer_id == PEER_ID_INEXISTENT) {
1517 std::vector<session_t> clients = m_clients.getClientIDs();
1519 for (const session_t client_id : clients) {
1520 RemotePlayer *player = m_env->getPlayer(client_id);
1524 PlayerSAO *sao = player->getPlayerSAO();
1528 // Do not send to distant clients
1529 if (sao->getBasePosition().getDistanceFrom(pos * BS) > radius)
1532 SendSpawnParticle(client_id, player->protocol_version,
1533 pos, velocity, acceleration,
1534 expirationtime, size, collisiondetection, collision_removal,
1535 object_collision, vertical, texture, animation, glow);
1540 NetworkPacket pkt(TOCLIENT_SPAWN_PARTICLE, 0, peer_id);
1542 pkt << pos << velocity << acceleration << expirationtime
1543 << size << collisiondetection;
1544 pkt.putLongString(texture);
1546 pkt << collision_removal;
1547 // This is horrible but required (why are there two ways to serialize pkts?)
1548 std::ostringstream os(std::ios_base::binary);
1549 animation.serialize(os, protocol_version);
1550 pkt.putRawString(os.str());
1552 pkt << object_collision;
1557 // Adds a ParticleSpawner on peer with peer_id
1558 void Server::SendAddParticleSpawner(session_t peer_id, u16 protocol_version,
1559 u16 amount, float spawntime, v3f minpos, v3f maxpos,
1560 v3f minvel, v3f maxvel, v3f minacc, v3f maxacc, float minexptime, float maxexptime,
1561 float minsize, float maxsize, bool collisiondetection, bool collision_removal,
1562 bool object_collision, u16 attached_id, bool vertical, const std::string &texture, u32 id,
1563 const struct TileAnimationParams &animation, u8 glow)
1565 if (peer_id == PEER_ID_INEXISTENT) {
1566 // This sucks and should be replaced:
1567 std::vector<session_t> clients = m_clients.getClientIDs();
1568 for (const session_t client_id : clients) {
1569 RemotePlayer *player = m_env->getPlayer(client_id);
1572 SendAddParticleSpawner(client_id, player->protocol_version,
1573 amount, spawntime, minpos, maxpos,
1574 minvel, maxvel, minacc, maxacc, minexptime, maxexptime,
1575 minsize, maxsize, collisiondetection, collision_removal,
1576 object_collision, attached_id, vertical, texture, id,
1582 NetworkPacket pkt(TOCLIENT_ADD_PARTICLESPAWNER, 0, peer_id);
1584 pkt << amount << spawntime << minpos << maxpos << minvel << maxvel
1585 << minacc << maxacc << minexptime << maxexptime << minsize
1586 << maxsize << collisiondetection;
1588 pkt.putLongString(texture);
1590 pkt << id << vertical;
1591 pkt << collision_removal;
1593 // This is horrible but required
1594 std::ostringstream os(std::ios_base::binary);
1595 animation.serialize(os, protocol_version);
1596 pkt.putRawString(os.str());
1598 pkt << object_collision;
1603 void Server::SendDeleteParticleSpawner(session_t peer_id, u32 id)
1605 NetworkPacket pkt(TOCLIENT_DELETE_PARTICLESPAWNER, 4, peer_id);
1607 // Ugly error in this packet
1610 if (peer_id != PEER_ID_INEXISTENT)
1613 m_clients.sendToAll(&pkt);
1617 void Server::SendHUDAdd(session_t peer_id, u32 id, HudElement *form)
1619 NetworkPacket pkt(TOCLIENT_HUDADD, 0 , peer_id);
1621 pkt << id << (u8) form->type << form->pos << form->name << form->scale
1622 << form->text << form->number << form->item << form->dir
1623 << form->align << form->offset << form->world_pos << form->size
1629 void Server::SendHUDRemove(session_t peer_id, u32 id)
1631 NetworkPacket pkt(TOCLIENT_HUDRM, 4, peer_id);
1636 void Server::SendHUDChange(session_t peer_id, u32 id, HudElementStat stat, void *value)
1638 NetworkPacket pkt(TOCLIENT_HUDCHANGE, 0, peer_id);
1639 pkt << id << (u8) stat;
1643 case HUD_STAT_SCALE:
1644 case HUD_STAT_ALIGN:
1645 case HUD_STAT_OFFSET:
1646 pkt << *(v2f *) value;
1650 pkt << *(std::string *) value;
1652 case HUD_STAT_WORLD_POS:
1653 pkt << *(v3f *) value;
1656 pkt << *(v2s32 *) value;
1658 case HUD_STAT_NUMBER:
1662 pkt << *(u32 *) value;
1669 void Server::SendHUDSetFlags(session_t peer_id, u32 flags, u32 mask)
1671 NetworkPacket pkt(TOCLIENT_HUD_SET_FLAGS, 4 + 4, peer_id);
1673 flags &= ~(HUD_FLAG_HEALTHBAR_VISIBLE | HUD_FLAG_BREATHBAR_VISIBLE);
1675 pkt << flags << mask;
1680 void Server::SendHUDSetParam(session_t peer_id, u16 param, const std::string &value)
1682 NetworkPacket pkt(TOCLIENT_HUD_SET_PARAM, 0, peer_id);
1683 pkt << param << value;
1687 void Server::SendSetSky(session_t peer_id, const SkyboxParams ¶ms)
1689 NetworkPacket pkt(TOCLIENT_SET_SKY, 0, peer_id);
1691 // Handle prior clients here
1692 if (m_clients.getProtocolVersion(peer_id) < 39) {
1693 pkt << params.bgcolor << params.type << (u16) params.textures.size();
1695 for (const std::string& texture : params.textures)
1698 pkt << params.clouds;
1699 } else { // Handle current clients and future clients
1700 pkt << params.bgcolor << params.type
1701 << params.clouds << params.fog_sun_tint
1702 << params.fog_moon_tint << params.fog_tint_type;
1704 if (params.type == "skybox") {
1705 pkt << (u16) params.textures.size();
1706 for (const std::string &texture : params.textures)
1708 } else if (params.type == "regular") {
1709 pkt << params.sky_color.day_sky << params.sky_color.day_horizon
1710 << params.sky_color.dawn_sky << params.sky_color.dawn_horizon
1711 << params.sky_color.night_sky << params.sky_color.night_horizon
1712 << params.sky_color.indoors;
1719 void Server::SendSetSun(session_t peer_id, const SunParams ¶ms)
1721 NetworkPacket pkt(TOCLIENT_SET_SUN, 0, peer_id);
1722 pkt << params.visible << params.texture
1723 << params.tonemap << params.sunrise
1724 << params.sunrise_visible << params.scale;
1728 void Server::SendSetMoon(session_t peer_id, const MoonParams ¶ms)
1730 NetworkPacket pkt(TOCLIENT_SET_MOON, 0, peer_id);
1732 pkt << params.visible << params.texture
1733 << params.tonemap << params.scale;
1737 void Server::SendSetStars(session_t peer_id, const StarParams ¶ms)
1739 NetworkPacket pkt(TOCLIENT_SET_STARS, 0, peer_id);
1741 pkt << params.visible << params.count
1742 << params.starcolor << params.scale;
1747 void Server::SendCloudParams(session_t peer_id, const CloudParams ¶ms)
1749 NetworkPacket pkt(TOCLIENT_CLOUD_PARAMS, 0, peer_id);
1750 pkt << params.density << params.color_bright << params.color_ambient
1751 << params.height << params.thickness << params.speed;
1755 void Server::SendOverrideDayNightRatio(session_t peer_id, bool do_override,
1758 NetworkPacket pkt(TOCLIENT_OVERRIDE_DAY_NIGHT_RATIO,
1761 pkt << do_override << (u16) (ratio * 65535);
1766 void Server::SendTimeOfDay(session_t peer_id, u16 time, f32 time_speed)
1768 NetworkPacket pkt(TOCLIENT_TIME_OF_DAY, 0, peer_id);
1769 pkt << time << time_speed;
1771 if (peer_id == PEER_ID_INEXISTENT) {
1772 m_clients.sendToAll(&pkt);
1779 void Server::SendPlayerHP(session_t peer_id)
1781 PlayerSAO *playersao = getPlayerSAO(peer_id);
1784 SendHP(peer_id, playersao->getHP());
1785 m_script->player_event(playersao,"health_changed");
1787 // Send to other clients
1788 playersao->sendPunchCommand();
1791 void Server::SendPlayerBreath(PlayerSAO *sao)
1795 m_script->player_event(sao, "breath_changed");
1796 SendBreath(sao->getPeerID(), sao->getBreath());
1799 void Server::SendMovePlayer(session_t peer_id)
1801 RemotePlayer *player = m_env->getPlayer(peer_id);
1803 PlayerSAO *sao = player->getPlayerSAO();
1806 NetworkPacket pkt(TOCLIENT_MOVE_PLAYER, sizeof(v3f) + sizeof(f32) * 2, peer_id);
1807 pkt << sao->getBasePosition() << sao->getLookPitch() << sao->getRotation().Y;
1810 v3f pos = sao->getBasePosition();
1811 verbosestream << "Server: Sending TOCLIENT_MOVE_PLAYER"
1812 << " pos=(" << pos.X << "," << pos.Y << "," << pos.Z << ")"
1813 << " pitch=" << sao->getLookPitch()
1814 << " yaw=" << sao->getRotation().Y
1821 void Server::SendPlayerFov(session_t peer_id)
1823 NetworkPacket pkt(TOCLIENT_FOV, 4 + 1 + 4, peer_id);
1825 PlayerFovSpec fov_spec = m_env->getPlayer(peer_id)->getFov();
1826 pkt << fov_spec.fov << fov_spec.is_multiplier << fov_spec.transition_time;
1831 void Server::SendLocalPlayerAnimations(session_t peer_id, v2s32 animation_frames[4],
1832 f32 animation_speed)
1834 NetworkPacket pkt(TOCLIENT_LOCAL_PLAYER_ANIMATIONS, 0,
1837 pkt << animation_frames[0] << animation_frames[1] << animation_frames[2]
1838 << animation_frames[3] << animation_speed;
1843 void Server::SendEyeOffset(session_t peer_id, v3f first, v3f third)
1845 NetworkPacket pkt(TOCLIENT_EYE_OFFSET, 0, peer_id);
1846 pkt << first << third;
1850 void Server::SendPlayerPrivileges(session_t peer_id)
1852 RemotePlayer *player = m_env->getPlayer(peer_id);
1854 if(player->getPeerId() == PEER_ID_INEXISTENT)
1857 std::set<std::string> privs;
1858 m_script->getAuth(player->getName(), NULL, &privs);
1860 NetworkPacket pkt(TOCLIENT_PRIVILEGES, 0, peer_id);
1861 pkt << (u16) privs.size();
1863 for (const std::string &priv : privs) {
1870 void Server::SendPlayerInventoryFormspec(session_t peer_id)
1872 RemotePlayer *player = m_env->getPlayer(peer_id);
1874 if (player->getPeerId() == PEER_ID_INEXISTENT)
1877 NetworkPacket pkt(TOCLIENT_INVENTORY_FORMSPEC, 0, peer_id);
1878 pkt.putLongString(player->inventory_formspec);
1883 void Server::SendPlayerFormspecPrepend(session_t peer_id)
1885 RemotePlayer *player = m_env->getPlayer(peer_id);
1887 if (player->getPeerId() == PEER_ID_INEXISTENT)
1890 NetworkPacket pkt(TOCLIENT_FORMSPEC_PREPEND, 0, peer_id);
1891 pkt << player->formspec_prepend;
1895 void Server::SendActiveObjectRemoveAdd(RemoteClient *client, PlayerSAO *playersao)
1897 // Radius inside which objects are active
1898 static thread_local const s16 radius =
1899 g_settings->getS16("active_object_send_range_blocks") * MAP_BLOCKSIZE;
1901 // Radius inside which players are active
1902 static thread_local const bool is_transfer_limited =
1903 g_settings->exists("unlimited_player_transfer_distance") &&
1904 !g_settings->getBool("unlimited_player_transfer_distance");
1906 static thread_local const s16 player_transfer_dist =
1907 g_settings->getS16("player_transfer_distance") * MAP_BLOCKSIZE;
1909 s16 player_radius = player_transfer_dist == 0 && is_transfer_limited ?
1910 radius : player_transfer_dist;
1912 s16 my_radius = MYMIN(radius, playersao->getWantedRange() * MAP_BLOCKSIZE);
1916 std::queue<u16> removed_objects, added_objects;
1917 m_env->getRemovedActiveObjects(playersao, my_radius, player_radius,
1918 client->m_known_objects, removed_objects);
1919 m_env->getAddedActiveObjects(playersao, my_radius, player_radius,
1920 client->m_known_objects, added_objects);
1922 int removed_count = removed_objects.size();
1923 int added_count = added_objects.size();
1925 if (removed_objects.empty() && added_objects.empty())
1931 // Handle removed objects
1932 writeU16((u8*)buf, removed_objects.size());
1933 data.append(buf, 2);
1934 while (!removed_objects.empty()) {
1936 u16 id = removed_objects.front();
1937 ServerActiveObject* obj = m_env->getActiveObject(id);
1939 // Add to data buffer for sending
1940 writeU16((u8*)buf, id);
1941 data.append(buf, 2);
1943 // Remove from known objects
1944 client->m_known_objects.erase(id);
1946 if (obj && obj->m_known_by_count > 0)
1947 obj->m_known_by_count--;
1949 removed_objects.pop();
1952 // Handle added objects
1953 writeU16((u8*)buf, added_objects.size());
1954 data.append(buf, 2);
1955 while (!added_objects.empty()) {
1957 u16 id = added_objects.front();
1958 ServerActiveObject *obj = m_env->getActiveObject(id);
1959 added_objects.pop();
1962 warningstream << FUNCTION_NAME << ": NULL object id="
1963 << (int)id << std::endl;
1968 u8 type = obj->getSendType();
1970 // Add to data buffer for sending
1971 writeU16((u8*)buf, id);
1972 data.append(buf, 2);
1973 writeU8((u8*)buf, type);
1974 data.append(buf, 1);
1976 data.append(serializeLongString(
1977 obj->getClientInitializationData(client->net_proto_version)));
1979 // Add to known objects
1980 client->m_known_objects.insert(id);
1982 obj->m_known_by_count++;
1985 NetworkPacket pkt(TOCLIENT_ACTIVE_OBJECT_REMOVE_ADD, data.size(), client->peer_id);
1986 pkt.putRawString(data.c_str(), data.size());
1989 verbosestream << "Server::SendActiveObjectRemoveAdd: "
1990 << removed_count << " removed, " << added_count << " added, "
1991 << "packet size is " << pkt.getSize() << std::endl;
1994 void Server::SendActiveObjectMessages(session_t peer_id, const std::string &datas,
1997 NetworkPacket pkt(TOCLIENT_ACTIVE_OBJECT_MESSAGES,
1998 datas.size(), peer_id);
2000 pkt.putRawString(datas.c_str(), datas.size());
2002 m_clients.send(pkt.getPeerId(),
2003 reliable ? clientCommandFactoryTable[pkt.getCommand()].channel : 1,
2007 void Server::SendCSMRestrictionFlags(session_t peer_id)
2009 NetworkPacket pkt(TOCLIENT_CSM_RESTRICTION_FLAGS,
2010 sizeof(m_csm_restriction_flags) + sizeof(m_csm_restriction_noderange), peer_id);
2011 pkt << m_csm_restriction_flags << m_csm_restriction_noderange;
2015 void Server::SendPlayerSpeed(session_t peer_id, const v3f &added_vel)
2017 NetworkPacket pkt(TOCLIENT_PLAYER_SPEED, 0, peer_id);
2022 inline s32 Server::nextSoundId()
2024 s32 ret = m_next_sound_id;
2025 if (m_next_sound_id == INT32_MAX)
2026 m_next_sound_id = 0; // signed overflow is undefined
2032 s32 Server::playSound(const SimpleSoundSpec &spec,
2033 const ServerSoundParams ¶ms, bool ephemeral)
2035 // Find out initial position of sound
2036 bool pos_exists = false;
2037 v3f pos = params.getPos(m_env, &pos_exists);
2038 // If position is not found while it should be, cancel sound
2039 if(pos_exists != (params.type != ServerSoundParams::SSP_LOCAL))
2042 // Filter destination clients
2043 std::vector<session_t> dst_clients;
2044 if (!params.to_player.empty()) {
2045 RemotePlayer *player = m_env->getPlayer(params.to_player.c_str());
2047 infostream<<"Server::playSound: Player \""<<params.to_player
2048 <<"\" not found"<<std::endl;
2051 if (player->getPeerId() == PEER_ID_INEXISTENT) {
2052 infostream<<"Server::playSound: Player \""<<params.to_player
2053 <<"\" not connected"<<std::endl;
2056 dst_clients.push_back(player->getPeerId());
2058 std::vector<session_t> clients = m_clients.getClientIDs();
2060 for (const session_t client_id : clients) {
2061 RemotePlayer *player = m_env->getPlayer(client_id);
2064 if (!params.exclude_player.empty() &&
2065 params.exclude_player == player->getName())
2068 PlayerSAO *sao = player->getPlayerSAO();
2073 if(sao->getBasePosition().getDistanceFrom(pos) >
2074 params.max_hear_distance)
2077 dst_clients.push_back(client_id);
2081 if(dst_clients.empty())
2086 ServerPlayingSound *psound = nullptr;
2088 id = -1; // old clients will still use this, so pick a reserved ID
2091 // The sound will exist as a reference in m_playing_sounds
2092 m_playing_sounds[id] = ServerPlayingSound();
2093 psound = &m_playing_sounds[id];
2094 psound->params = params;
2095 psound->spec = spec;
2098 float gain = params.gain * spec.gain;
2099 NetworkPacket pkt(TOCLIENT_PLAY_SOUND, 0);
2100 pkt << id << spec.name << gain
2101 << (u8) params.type << pos << params.object
2102 << params.loop << params.fade << params.pitch
2105 bool as_reliable = !ephemeral;
2107 for (const u16 dst_client : dst_clients) {
2109 psound->clients.insert(dst_client);
2110 m_clients.send(dst_client, 0, &pkt, as_reliable);
2114 void Server::stopSound(s32 handle)
2116 // Get sound reference
2117 std::unordered_map<s32, ServerPlayingSound>::iterator i =
2118 m_playing_sounds.find(handle);
2119 if (i == m_playing_sounds.end())
2121 ServerPlayingSound &psound = i->second;
2123 NetworkPacket pkt(TOCLIENT_STOP_SOUND, 4);
2126 for (std::unordered_set<session_t>::const_iterator si = psound.clients.begin();
2127 si != psound.clients.end(); ++si) {
2129 m_clients.send(*si, 0, &pkt, true);
2131 // Remove sound reference
2132 m_playing_sounds.erase(i);
2135 void Server::fadeSound(s32 handle, float step, float gain)
2137 // Get sound reference
2138 std::unordered_map<s32, ServerPlayingSound>::iterator i =
2139 m_playing_sounds.find(handle);
2140 if (i == m_playing_sounds.end())
2143 ServerPlayingSound &psound = i->second;
2144 psound.params.gain = gain;
2146 NetworkPacket pkt(TOCLIENT_FADE_SOUND, 4);
2147 pkt << handle << step << gain;
2149 // Backwards compability
2150 bool play_sound = gain > 0;
2151 ServerPlayingSound compat_psound = psound;
2152 compat_psound.clients.clear();
2154 NetworkPacket compat_pkt(TOCLIENT_STOP_SOUND, 4);
2155 compat_pkt << handle;
2157 for (std::unordered_set<u16>::iterator it = psound.clients.begin();
2158 it != psound.clients.end();) {
2159 if (m_clients.getProtocolVersion(*it) >= 32) {
2161 m_clients.send(*it, 0, &pkt, true);
2164 compat_psound.clients.insert(*it);
2166 m_clients.send(*it, 0, &compat_pkt, true);
2167 psound.clients.erase(it++);
2171 // Remove sound reference
2172 if (!play_sound || psound.clients.empty())
2173 m_playing_sounds.erase(i);
2175 if (play_sound && !compat_psound.clients.empty()) {
2176 // Play new sound volume on older clients
2177 playSound(compat_psound.spec, compat_psound.params);
2181 void Server::sendRemoveNode(v3s16 p, std::unordered_set<u16> *far_players,
2184 float maxd = far_d_nodes * BS;
2185 v3f p_f = intToFloat(p, BS);
2186 v3s16 block_pos = getNodeBlockPos(p);
2188 NetworkPacket pkt(TOCLIENT_REMOVENODE, 6);
2191 std::vector<session_t> clients = m_clients.getClientIDs();
2194 for (session_t client_id : clients) {
2195 RemoteClient *client = m_clients.lockedGetClientNoEx(client_id);
2199 RemotePlayer *player = m_env->getPlayer(client_id);
2200 PlayerSAO *sao = player ? player->getPlayerSAO() : nullptr;
2202 // If player is far away, only set modified blocks not sent
2203 if (!client->isBlockSent(block_pos) || (sao &&
2204 sao->getBasePosition().getDistanceFrom(p_f) > maxd)) {
2206 far_players->emplace(client_id);
2208 client->SetBlockNotSent(block_pos);
2213 m_clients.send(client_id, 0, &pkt, true);
2219 void Server::sendAddNode(v3s16 p, MapNode n, std::unordered_set<u16> *far_players,
2220 float far_d_nodes, bool remove_metadata)
2222 float maxd = far_d_nodes * BS;
2223 v3f p_f = intToFloat(p, BS);
2224 v3s16 block_pos = getNodeBlockPos(p);
2226 NetworkPacket pkt(TOCLIENT_ADDNODE, 6 + 2 + 1 + 1 + 1);
2227 pkt << p << n.param0 << n.param1 << n.param2
2228 << (u8) (remove_metadata ? 0 : 1);
2230 std::vector<session_t> clients = m_clients.getClientIDs();
2233 for (session_t client_id : clients) {
2234 RemoteClient *client = m_clients.lockedGetClientNoEx(client_id);
2238 RemotePlayer *player = m_env->getPlayer(client_id);
2239 PlayerSAO *sao = player ? player->getPlayerSAO() : nullptr;
2241 // If player is far away, only set modified blocks not sent
2242 if (!client->isBlockSent(block_pos) || (sao &&
2243 sao->getBasePosition().getDistanceFrom(p_f) > maxd)) {
2245 far_players->emplace(client_id);
2247 client->SetBlockNotSent(block_pos);
2252 m_clients.send(client_id, 0, &pkt, true);
2258 void Server::sendMetadataChanged(const std::list<v3s16> &meta_updates, float far_d_nodes)
2260 float maxd = far_d_nodes * BS;
2261 NodeMetadataList meta_updates_list(false);
2262 std::vector<session_t> clients = m_clients.getClientIDs();
2266 for (session_t i : clients) {
2267 RemoteClient *client = m_clients.lockedGetClientNoEx(i);
2271 ServerActiveObject *player = m_env->getActiveObject(i);
2272 v3f player_pos = player ? player->getBasePosition() : v3f();
2274 for (const v3s16 &pos : meta_updates) {
2275 NodeMetadata *meta = m_env->getMap().getNodeMetadata(pos);
2280 v3s16 block_pos = getNodeBlockPos(pos);
2281 if (!client->isBlockSent(block_pos) || (player &&
2282 player_pos.getDistanceFrom(intToFloat(pos, BS)) > maxd)) {
2283 client->SetBlockNotSent(block_pos);
2287 // Add the change to send list
2288 meta_updates_list.set(pos, meta);
2290 if (meta_updates_list.size() == 0)
2293 // Send the meta changes
2294 std::ostringstream os(std::ios::binary);
2295 meta_updates_list.serialize(os, client->net_proto_version, false, true);
2296 std::ostringstream oss(std::ios::binary);
2297 compressZlib(os.str(), oss);
2299 NetworkPacket pkt(TOCLIENT_NODEMETA_CHANGED, 0);
2300 pkt.putLongString(oss.str());
2301 m_clients.send(i, 0, &pkt, true);
2303 meta_updates_list.clear();
2309 void Server::SendBlockNoLock(session_t peer_id, MapBlock *block, u8 ver,
2310 u16 net_proto_version)
2313 Create a packet with the block in the right format
2316 std::ostringstream os(std::ios_base::binary);
2317 block->serialize(os, ver, false);
2318 block->serializeNetworkSpecific(os);
2319 std::string s = os.str();
2321 NetworkPacket pkt(TOCLIENT_BLOCKDATA, 2 + 2 + 2 + 2 + s.size(), peer_id);
2323 pkt << block->getPos();
2324 pkt.putRawString(s.c_str(), s.size());
2328 void Server::SendBlocks(float dtime)
2330 MutexAutoLock envlock(m_env_mutex);
2331 //TODO check if one big lock could be faster then multiple small ones
2333 std::vector<PrioritySortedBlockTransfer> queue;
2335 u32 total_sending = 0;
2338 ScopeProfiler sp2(g_profiler, "Server::SendBlocks(): Collect list");
2340 std::vector<session_t> clients = m_clients.getClientIDs();
2343 for (const session_t client_id : clients) {
2344 RemoteClient *client = m_clients.lockedGetClientNoEx(client_id, CS_Active);
2349 total_sending += client->getSendingCount();
2350 client->GetNextBlocks(m_env,m_emerge, dtime, queue);
2356 // Lowest priority number comes first.
2357 // Lowest is most important.
2358 std::sort(queue.begin(), queue.end());
2362 // Maximal total count calculation
2363 // The per-client block sends is halved with the maximal online users
2364 u32 max_blocks_to_send = (m_env->getPlayerCount() + g_settings->getU32("max_users")) *
2365 g_settings->getU32("max_simultaneous_block_sends_per_client") / 4 + 1;
2367 ScopeProfiler sp(g_profiler, "Server::SendBlocks(): Send to clients");
2368 Map &map = m_env->getMap();
2370 for (const PrioritySortedBlockTransfer &block_to_send : queue) {
2371 if (total_sending >= max_blocks_to_send)
2374 MapBlock *block = map.getBlockNoCreateNoEx(block_to_send.pos);
2378 RemoteClient *client = m_clients.lockedGetClientNoEx(block_to_send.peer_id,
2383 SendBlockNoLock(block_to_send.peer_id, block, client->serialization_version,
2384 client->net_proto_version);
2386 client->SentBlock(block_to_send.pos);
2392 bool Server::SendBlock(session_t peer_id, const v3s16 &blockpos)
2394 MapBlock *block = m_env->getMap().getBlockNoCreateNoEx(blockpos);
2399 RemoteClient *client = m_clients.lockedGetClientNoEx(peer_id, CS_Active);
2400 if (!client || client->isBlockSent(blockpos)) {
2404 SendBlockNoLock(peer_id, block, client->serialization_version,
2405 client->net_proto_version);
2411 void Server::fillMediaCache()
2413 infostream<<"Server: Calculating media file checksums"<<std::endl;
2415 // Collect all media file paths
2416 std::vector<std::string> paths;
2417 m_modmgr->getModsMediaPaths(paths);
2418 fs::GetRecursiveDirs(paths, m_gamespec.path + DIR_DELIM + "textures");
2419 fs::GetRecursiveDirs(paths, porting::path_user + DIR_DELIM + "textures" + DIR_DELIM + "server");
2421 // Collect media file information from paths into cache
2422 for (const std::string &mediapath : paths) {
2423 std::vector<fs::DirListNode> dirlist = fs::GetDirListing(mediapath);
2424 for (const fs::DirListNode &dln : dirlist) {
2425 if (dln.dir) // Ignode dirs
2427 std::string filename = dln.name;
2428 // If name contains illegal characters, ignore the file
2429 if (!string_allowed(filename, TEXTURENAME_ALLOWED_CHARS)) {
2430 infostream<<"Server: ignoring illegal file name: \""
2431 << filename << "\"" << std::endl;
2434 // If name is not in a supported format, ignore it
2435 const char *supported_ext[] = {
2436 ".png", ".jpg", ".bmp", ".tga",
2437 ".pcx", ".ppm", ".psd", ".wal", ".rgb",
2439 ".x", ".b3d", ".md2", ".obj",
2440 // Custom translation file format
2444 if (removeStringEnd(filename, supported_ext).empty()){
2445 infostream << "Server: ignoring unsupported file extension: \""
2446 << filename << "\"" << std::endl;
2449 // Ok, attempt to load the file and add to cache
2450 std::string filepath;
2451 filepath.append(mediapath).append(DIR_DELIM).append(filename);
2454 std::ifstream fis(filepath.c_str(), std::ios_base::binary);
2456 errorstream << "Server::fillMediaCache(): Could not open \""
2457 << filename << "\" for reading" << std::endl;
2460 std::ostringstream tmp_os(std::ios_base::binary);
2464 fis.read(buf, 1024);
2465 std::streamsize len = fis.gcount();
2466 tmp_os.write(buf, len);
2475 errorstream<<"Server::fillMediaCache(): Failed to read \""
2476 << filename << "\"" << std::endl;
2479 if(tmp_os.str().length() == 0) {
2480 errorstream << "Server::fillMediaCache(): Empty file \""
2481 << filepath << "\"" << std::endl;
2486 sha1.addBytes(tmp_os.str().c_str(), tmp_os.str().length());
2488 unsigned char *digest = sha1.getDigest();
2489 std::string sha1_base64 = base64_encode(digest, 20);
2490 std::string sha1_hex = hex_encode((char*)digest, 20);
2494 m_media[filename] = MediaInfo(filepath, sha1_base64);
2495 verbosestream << "Server: " << sha1_hex << " is " << filename
2501 void Server::sendMediaAnnouncement(session_t peer_id, const std::string &lang_code)
2504 NetworkPacket pkt(TOCLIENT_ANNOUNCE_MEDIA, 0, peer_id);
2507 std::string lang_suffix;
2508 lang_suffix.append(".").append(lang_code).append(".tr");
2509 for (const auto &i : m_media) {
2510 if (str_ends_with(i.first, ".tr") && !str_ends_with(i.first, lang_suffix))
2517 for (const auto &i : m_media) {
2518 if (str_ends_with(i.first, ".tr") && !str_ends_with(i.first, lang_suffix))
2520 pkt << i.first << i.second.sha1_digest;
2523 pkt << g_settings->get("remote_media");
2526 verbosestream << "Server: Announcing files to id(" << peer_id
2527 << "): count=" << media_sent << " size=" << pkt.getSize() << std::endl;
2530 struct SendableMedia
2536 SendableMedia(const std::string &name_="", const std::string &path_="",
2537 const std::string &data_=""):
2544 void Server::sendRequestedMedia(session_t peer_id,
2545 const std::vector<std::string> &tosend)
2547 verbosestream<<"Server::sendRequestedMedia(): "
2548 <<"Sending files to client"<<std::endl;
2552 // Put 5kB in one bunch (this is not accurate)
2553 u32 bytes_per_bunch = 5000;
2555 std::vector< std::vector<SendableMedia> > file_bunches;
2556 file_bunches.emplace_back();
2558 u32 file_size_bunch_total = 0;
2560 for (const std::string &name : tosend) {
2561 if (m_media.find(name) == m_media.end()) {
2562 errorstream<<"Server::sendRequestedMedia(): Client asked for "
2563 <<"unknown file \""<<(name)<<"\""<<std::endl;
2567 //TODO get path + name
2568 std::string tpath = m_media[name].path;
2571 std::ifstream fis(tpath.c_str(), std::ios_base::binary);
2573 errorstream<<"Server::sendRequestedMedia(): Could not open \""
2574 <<tpath<<"\" for reading"<<std::endl;
2577 std::ostringstream tmp_os(std::ios_base::binary);
2581 fis.read(buf, 1024);
2582 std::streamsize len = fis.gcount();
2583 tmp_os.write(buf, len);
2584 file_size_bunch_total += len;
2593 errorstream<<"Server::sendRequestedMedia(): Failed to read \""
2594 <<name<<"\""<<std::endl;
2597 /*infostream<<"Server::sendRequestedMedia(): Loaded \""
2598 <<tname<<"\""<<std::endl;*/
2600 file_bunches[file_bunches.size()-1].emplace_back(name, tpath, tmp_os.str());
2602 // Start next bunch if got enough data
2603 if(file_size_bunch_total >= bytes_per_bunch) {
2604 file_bunches.emplace_back();
2605 file_size_bunch_total = 0;
2610 /* Create and send packets */
2612 u16 num_bunches = file_bunches.size();
2613 for (u16 i = 0; i < num_bunches; i++) {
2616 u16 total number of texture bunches
2617 u16 index of this bunch
2618 u32 number of files in this bunch
2627 NetworkPacket pkt(TOCLIENT_MEDIA, 4 + 0, peer_id);
2628 pkt << num_bunches << i << (u32) file_bunches[i].size();
2630 for (const SendableMedia &j : file_bunches[i]) {
2632 pkt.putLongString(j.data);
2635 verbosestream << "Server::sendRequestedMedia(): bunch "
2636 << i << "/" << num_bunches
2637 << " files=" << file_bunches[i].size()
2638 << " size=" << pkt.getSize() << std::endl;
2643 void Server::sendDetachedInventory(Inventory *inventory, const std::string &name, session_t peer_id)
2645 NetworkPacket pkt(TOCLIENT_DETACHED_INVENTORY, 0, peer_id);
2649 pkt << false; // Remove inventory
2651 pkt << true; // Update inventory
2653 // Serialization & NetworkPacket isn't a love story
2654 std::ostringstream os(std::ios_base::binary);
2655 inventory->serialize(os);
2656 inventory->setModified(false);
2658 const std::string &os_str = os.str();
2659 pkt << static_cast<u16>(os_str.size()); // HACK: to keep compatibility with 5.0.0 clients
2660 pkt.putRawString(os_str);
2663 if (peer_id == PEER_ID_INEXISTENT)
2664 m_clients.sendToAll(&pkt);
2669 void Server::sendDetachedInventories(session_t peer_id, bool incremental)
2671 // Lookup player name, to filter detached inventories just after
2672 std::string peer_name;
2673 if (peer_id != PEER_ID_INEXISTENT) {
2674 peer_name = getClient(peer_id, CS_Created)->getName();
2677 auto send_cb = [this, peer_id](const std::string &name, Inventory *inv) {
2678 sendDetachedInventory(inv, name, peer_id);
2681 m_inventory_mgr->sendDetachedInventories(peer_name, incremental, send_cb);
2688 void Server::DiePlayer(session_t peer_id, const PlayerHPChangeReason &reason)
2690 PlayerSAO *playersao = getPlayerSAO(peer_id);
2693 infostream << "Server::DiePlayer(): Player "
2694 << playersao->getPlayer()->getName()
2695 << " dies" << std::endl;
2697 playersao->setHP(0, reason);
2698 playersao->clearParentAttachment();
2700 // Trigger scripted stuff
2701 m_script->on_dieplayer(playersao, reason);
2703 SendPlayerHP(peer_id);
2704 SendDeathscreen(peer_id, false, v3f(0,0,0));
2707 void Server::RespawnPlayer(session_t peer_id)
2709 PlayerSAO *playersao = getPlayerSAO(peer_id);
2712 infostream << "Server::RespawnPlayer(): Player "
2713 << playersao->getPlayer()->getName()
2714 << " respawns" << std::endl;
2716 playersao->setHP(playersao->accessObjectProperties()->hp_max,
2717 PlayerHPChangeReason(PlayerHPChangeReason::RESPAWN));
2718 playersao->setBreath(playersao->accessObjectProperties()->breath_max);
2720 bool repositioned = m_script->on_respawnplayer(playersao);
2721 if (!repositioned) {
2722 // setPos will send the new position to client
2723 playersao->setPos(findSpawnPos());
2726 SendPlayerHP(peer_id);
2730 void Server::DenySudoAccess(session_t peer_id)
2732 NetworkPacket pkt(TOCLIENT_DENY_SUDO_MODE, 0, peer_id);
2737 void Server::DenyAccessVerCompliant(session_t peer_id, u16 proto_ver, AccessDeniedCode reason,
2738 const std::string &str_reason, bool reconnect)
2740 SendAccessDenied(peer_id, reason, str_reason, reconnect);
2742 m_clients.event(peer_id, CSE_SetDenied);
2743 DisconnectPeer(peer_id);
2747 void Server::DenyAccess(session_t peer_id, AccessDeniedCode reason,
2748 const std::string &custom_reason)
2750 SendAccessDenied(peer_id, reason, custom_reason);
2751 m_clients.event(peer_id, CSE_SetDenied);
2752 DisconnectPeer(peer_id);
2755 // 13/03/15: remove this function when protocol version 25 will become
2756 // the minimum version for MT users, maybe in 1 year
2757 void Server::DenyAccess_Legacy(session_t peer_id, const std::wstring &reason)
2759 SendAccessDenied_Legacy(peer_id, reason);
2760 m_clients.event(peer_id, CSE_SetDenied);
2761 DisconnectPeer(peer_id);
2764 void Server::DisconnectPeer(session_t peer_id)
2766 m_modchannel_mgr->leaveAllChannels(peer_id);
2767 m_con->DisconnectPeer(peer_id);
2770 void Server::acceptAuth(session_t peer_id, bool forSudoMode)
2773 RemoteClient* client = getClient(peer_id, CS_Invalid);
2775 NetworkPacket resp_pkt(TOCLIENT_AUTH_ACCEPT, 1 + 6 + 8 + 4, peer_id);
2777 // Right now, the auth mechs don't change between login and sudo mode.
2778 u32 sudo_auth_mechs = client->allowed_auth_mechs;
2779 client->allowed_sudo_mechs = sudo_auth_mechs;
2781 resp_pkt << v3f(0,0,0) << (u64) m_env->getServerMap().getSeed()
2782 << g_settings->getFloat("dedicated_server_step")
2786 m_clients.event(peer_id, CSE_AuthAccept);
2788 NetworkPacket resp_pkt(TOCLIENT_ACCEPT_SUDO_MODE, 1 + 6 + 8 + 4, peer_id);
2790 // We only support SRP right now
2791 u32 sudo_auth_mechs = AUTH_MECHANISM_FIRST_SRP;
2793 resp_pkt << sudo_auth_mechs;
2795 m_clients.event(peer_id, CSE_SudoSuccess);
2799 void Server::DeleteClient(session_t peer_id, ClientDeletionReason reason)
2801 std::wstring message;
2804 Clear references to playing sounds
2806 for (std::unordered_map<s32, ServerPlayingSound>::iterator
2807 i = m_playing_sounds.begin(); i != m_playing_sounds.end();) {
2808 ServerPlayingSound &psound = i->second;
2809 psound.clients.erase(peer_id);
2810 if (psound.clients.empty())
2811 m_playing_sounds.erase(i++);
2816 // clear formspec info so the next client can't abuse the current state
2817 m_formspec_state_data.erase(peer_id);
2819 RemotePlayer *player = m_env->getPlayer(peer_id);
2821 /* Run scripts and remove from environment */
2823 PlayerSAO *playersao = player->getPlayerSAO();
2826 playersao->clearChildAttachments();
2827 playersao->clearParentAttachment();
2829 // inform connected clients
2830 const std::string &player_name = player->getName();
2831 NetworkPacket notice(TOCLIENT_UPDATE_PLAYER_LIST, 0, PEER_ID_INEXISTENT);
2832 // (u16) 1 + std::string represents a vector serialization representation
2833 notice << (u8) PLAYER_LIST_REMOVE << (u16) 1 << player_name;
2834 m_clients.sendToAll(¬ice);
2836 m_script->on_leaveplayer(playersao, reason == CDR_TIMEOUT);
2838 playersao->disconnected();
2845 if (player && reason != CDR_DENY) {
2846 std::ostringstream os(std::ios_base::binary);
2847 std::vector<session_t> clients = m_clients.getClientIDs();
2849 for (const session_t client_id : clients) {
2851 RemotePlayer *player = m_env->getPlayer(client_id);
2855 // Get name of player
2856 os << player->getName() << " ";
2859 std::string name = player->getName();
2860 actionstream << name << " "
2861 << (reason == CDR_TIMEOUT ? "times out." : "leaves game.")
2862 << " List of players: " << os.str() << std::endl;
2864 m_admin_chat->outgoing_queue.push_back(
2865 new ChatEventNick(CET_NICK_REMOVE, name));
2869 MutexAutoLock env_lock(m_env_mutex);
2870 m_clients.DeleteClient(peer_id);
2874 // Send leave chat message to all remaining clients
2875 if (!message.empty()) {
2876 SendChatMessage(PEER_ID_INEXISTENT,
2877 ChatMessage(CHATMESSAGE_TYPE_ANNOUNCE, message));
2881 void Server::UpdateCrafting(RemotePlayer *player)
2883 InventoryList *clist = player->inventory.getList("craft");
2884 if (!clist || clist->getSize() == 0)
2887 if (!clist->checkModified())
2890 // Get a preview for crafting
2892 InventoryLocation loc;
2893 loc.setPlayer(player->getName());
2894 std::vector<ItemStack> output_replacements;
2895 getCraftingResult(&player->inventory, preview, output_replacements, false, this);
2896 m_env->getScriptIface()->item_CraftPredict(preview, player->getPlayerSAO(),
2899 InventoryList *plist = player->inventory.getList("craftpreview");
2900 if (plist && plist->getSize() >= 1) {
2901 // Put the new preview in
2902 plist->changeItem(0, preview);
2906 void Server::handleChatInterfaceEvent(ChatEvent *evt)
2908 if (evt->type == CET_NICK_ADD) {
2909 // The terminal informed us of its nick choice
2910 m_admin_nick = ((ChatEventNick *)evt)->nick;
2911 if (!m_script->getAuth(m_admin_nick, NULL, NULL)) {
2912 errorstream << "You haven't set up an account." << std::endl
2913 << "Please log in using the client as '"
2914 << m_admin_nick << "' with a secure password." << std::endl
2915 << "Until then, you can't execute admin tasks via the console," << std::endl
2916 << "and everybody can claim the user account instead of you," << std::endl
2917 << "giving them full control over this server." << std::endl;
2920 assert(evt->type == CET_CHAT);
2921 handleAdminChat((ChatEventChat *)evt);
2925 std::wstring Server::handleChat(const std::string &name, const std::wstring &wname,
2926 std::wstring wmessage, bool check_shout_priv, RemotePlayer *player)
2928 // If something goes wrong, this player is to blame
2929 RollbackScopeActor rollback_scope(m_rollback,
2930 std::string("player:") + name);
2932 if (g_settings->getBool("strip_color_codes"))
2933 wmessage = unescape_enriched(wmessage);
2936 switch (player->canSendChatMessage()) {
2937 case RPLAYER_CHATRESULT_FLOODING: {
2938 std::wstringstream ws;
2939 ws << L"You cannot send more messages. You are limited to "
2940 << g_settings->getFloat("chat_message_limit_per_10sec")
2941 << L" messages per 10 seconds.";
2944 case RPLAYER_CHATRESULT_KICK:
2945 DenyAccess_Legacy(player->getPeerId(),
2946 L"You have been kicked due to message flooding.");
2948 case RPLAYER_CHATRESULT_OK:
2951 FATAL_ERROR("Unhandled chat filtering result found.");
2955 if (m_max_chatmessage_length > 0
2956 && wmessage.length() > m_max_chatmessage_length) {
2957 return L"Your message exceed the maximum chat message limit set on the server. "
2958 L"It was refused. Send a shorter message";
2961 auto message = trim(wide_to_utf8(wmessage));
2962 if (message.find_first_of("\n\r") != std::wstring::npos) {
2963 return L"New lines are not permitted in chat messages";
2966 // Run script hook, exit if script ate the chat message
2967 if (m_script->on_chat_message(name, message))
2972 // Whether to send line to the player that sent the message, or to all players
2973 bool broadcast_line = true;
2975 if (check_shout_priv && !checkPriv(name, "shout")) {
2976 line += L"-!- You don't have permission to shout.";
2977 broadcast_line = false;
2980 Workaround for fixing chat on Android. Lua doesn't handle
2981 the Cyrillic alphabet and some characters on older Android devices
2984 line += L"<" + wname + L"> " + wmessage;
2986 line += narrow_to_wide(m_script->formatChatMessage(name,
2987 wide_to_narrow(wmessage)));
2992 Tell calling method to send the message to sender
2994 if (!broadcast_line)
2998 Send the message to others
3000 actionstream << "CHAT: " << wide_to_narrow(unescape_enriched(line)) << std::endl;
3002 std::vector<session_t> clients = m_clients.getClientIDs();
3005 Send the message back to the inital sender
3006 if they are using protocol version >= 29
3009 session_t peer_id_to_avoid_sending =
3010 (player ? player->getPeerId() : PEER_ID_INEXISTENT);
3012 if (player && player->protocol_version >= 29)
3013 peer_id_to_avoid_sending = PEER_ID_INEXISTENT;
3015 for (u16 cid : clients) {
3016 if (cid != peer_id_to_avoid_sending)
3017 SendChatMessage(cid, ChatMessage(line));
3022 void Server::handleAdminChat(const ChatEventChat *evt)
3024 std::string name = evt->nick;
3025 std::wstring wname = utf8_to_wide(name);
3026 std::wstring wmessage = evt->evt_msg;
3028 std::wstring answer = handleChat(name, wname, wmessage);
3030 // If asked to send answer to sender
3031 if (!answer.empty()) {
3032 m_admin_chat->outgoing_queue.push_back(new ChatEventChat("", answer));
3036 RemoteClient *Server::getClient(session_t peer_id, ClientState state_min)
3038 RemoteClient *client = getClientNoEx(peer_id,state_min);
3040 throw ClientNotFoundException("Client not found");
3044 RemoteClient *Server::getClientNoEx(session_t peer_id, ClientState state_min)
3046 return m_clients.getClientNoEx(peer_id, state_min);
3049 std::string Server::getPlayerName(session_t peer_id)
3051 RemotePlayer *player = m_env->getPlayer(peer_id);
3053 return "[id="+itos(peer_id)+"]";
3054 return player->getName();
3057 PlayerSAO *Server::getPlayerSAO(session_t peer_id)
3059 RemotePlayer *player = m_env->getPlayer(peer_id);
3062 return player->getPlayerSAO();
3065 std::wstring Server::getStatusString()
3067 std::wostringstream os(std::ios_base::binary);
3068 os << L"# Server: ";
3070 os << L"version=" << narrow_to_wide(g_version_string);
3072 os << L", uptime=" << m_uptime_counter->get();
3074 os << L", max_lag=" << (m_env ? m_env->getMaxLagEstimate() : 0);
3076 // Information about clients
3078 os << L", clients={";
3080 std::vector<session_t> clients = m_clients.getClientIDs();
3081 for (session_t client_id : clients) {
3082 RemotePlayer *player = m_env->getPlayer(client_id);
3084 // Get name of player
3085 std::wstring name = L"unknown";
3087 name = narrow_to_wide(player->getName());
3089 // Add name to information string
3100 if (m_env && !((ServerMap*)(&m_env->getMap()))->isSavingEnabled())
3101 os << std::endl << L"# Server: " << " WARNING: Map saving is disabled.";
3103 if (!g_settings->get("motd").empty())
3104 os << std::endl << L"# Server: " << narrow_to_wide(g_settings->get("motd"));
3109 std::set<std::string> Server::getPlayerEffectivePrivs(const std::string &name)
3111 std::set<std::string> privs;
3112 m_script->getAuth(name, NULL, &privs);
3116 bool Server::checkPriv(const std::string &name, const std::string &priv)
3118 std::set<std::string> privs = getPlayerEffectivePrivs(name);
3119 return (privs.count(priv) != 0);
3122 void Server::reportPrivsModified(const std::string &name)
3125 std::vector<session_t> clients = m_clients.getClientIDs();
3126 for (const session_t client_id : clients) {
3127 RemotePlayer *player = m_env->getPlayer(client_id);
3128 reportPrivsModified(player->getName());
3131 RemotePlayer *player = m_env->getPlayer(name.c_str());
3134 SendPlayerPrivileges(player->getPeerId());
3135 PlayerSAO *sao = player->getPlayerSAO();
3138 sao->updatePrivileges(
3139 getPlayerEffectivePrivs(name),
3144 void Server::reportInventoryFormspecModified(const std::string &name)
3146 RemotePlayer *player = m_env->getPlayer(name.c_str());
3149 SendPlayerInventoryFormspec(player->getPeerId());
3152 void Server::reportFormspecPrependModified(const std::string &name)
3154 RemotePlayer *player = m_env->getPlayer(name.c_str());
3157 SendPlayerFormspecPrepend(player->getPeerId());
3160 void Server::setIpBanned(const std::string &ip, const std::string &name)
3162 m_banmanager->add(ip, name);
3165 void Server::unsetIpBanned(const std::string &ip_or_name)
3167 m_banmanager->remove(ip_or_name);
3170 std::string Server::getBanDescription(const std::string &ip_or_name)
3172 return m_banmanager->getBanDescription(ip_or_name);
3175 void Server::notifyPlayer(const char *name, const std::wstring &msg)
3177 // m_env will be NULL if the server is initializing
3181 if (m_admin_nick == name && !m_admin_nick.empty()) {
3182 m_admin_chat->outgoing_queue.push_back(new ChatEventChat("", msg));
3185 RemotePlayer *player = m_env->getPlayer(name);
3190 if (player->getPeerId() == PEER_ID_INEXISTENT)
3193 SendChatMessage(player->getPeerId(), ChatMessage(msg));
3196 bool Server::showFormspec(const char *playername, const std::string &formspec,
3197 const std::string &formname)
3199 // m_env will be NULL if the server is initializing
3203 RemotePlayer *player = m_env->getPlayer(playername);
3207 SendShowFormspecMessage(player->getPeerId(), formspec, formname);
3211 u32 Server::hudAdd(RemotePlayer *player, HudElement *form)
3216 u32 id = player->addHud(form);
3218 SendHUDAdd(player->getPeerId(), id, form);
3223 bool Server::hudRemove(RemotePlayer *player, u32 id) {
3227 HudElement* todel = player->removeHud(id);
3234 SendHUDRemove(player->getPeerId(), id);
3238 bool Server::hudChange(RemotePlayer *player, u32 id, HudElementStat stat, void *data)
3243 SendHUDChange(player->getPeerId(), id, stat, data);
3247 bool Server::hudSetFlags(RemotePlayer *player, u32 flags, u32 mask)
3252 SendHUDSetFlags(player->getPeerId(), flags, mask);
3253 player->hud_flags &= ~mask;
3254 player->hud_flags |= flags;
3256 PlayerSAO* playersao = player->getPlayerSAO();
3261 m_script->player_event(playersao, "hud_changed");
3265 bool Server::hudSetHotbarItemcount(RemotePlayer *player, s32 hotbar_itemcount)
3270 if (hotbar_itemcount <= 0 || hotbar_itemcount > HUD_HOTBAR_ITEMCOUNT_MAX)
3273 player->setHotbarItemcount(hotbar_itemcount);
3274 std::ostringstream os(std::ios::binary);
3275 writeS32(os, hotbar_itemcount);
3276 SendHUDSetParam(player->getPeerId(), HUD_PARAM_HOTBAR_ITEMCOUNT, os.str());
3280 void Server::hudSetHotbarImage(RemotePlayer *player, const std::string &name)
3285 player->setHotbarImage(name);
3286 SendHUDSetParam(player->getPeerId(), HUD_PARAM_HOTBAR_IMAGE, name);
3289 void Server::hudSetHotbarSelectedImage(RemotePlayer *player, const std::string &name)
3294 player->setHotbarSelectedImage(name);
3295 SendHUDSetParam(player->getPeerId(), HUD_PARAM_HOTBAR_SELECTED_IMAGE, name);
3298 Address Server::getPeerAddress(session_t peer_id)
3300 return m_con->GetPeerAddress(peer_id);
3303 void Server::setLocalPlayerAnimations(RemotePlayer *player,
3304 v2s32 animation_frames[4], f32 frame_speed)
3306 sanity_check(player);
3307 player->setLocalAnimations(animation_frames, frame_speed);
3308 SendLocalPlayerAnimations(player->getPeerId(), animation_frames, frame_speed);
3311 void Server::setPlayerEyeOffset(RemotePlayer *player, const v3f &first, const v3f &third)
3313 sanity_check(player);
3314 player->eye_offset_first = first;
3315 player->eye_offset_third = third;
3316 SendEyeOffset(player->getPeerId(), first, third);
3319 void Server::setSky(RemotePlayer *player, const SkyboxParams ¶ms)
3321 sanity_check(player);
3322 player->setSky(params);
3323 SendSetSky(player->getPeerId(), params);
3326 void Server::setSun(RemotePlayer *player, const SunParams ¶ms)
3328 sanity_check(player);
3329 player->setSun(params);
3330 SendSetSun(player->getPeerId(), params);
3333 void Server::setMoon(RemotePlayer *player, const MoonParams ¶ms)
3335 sanity_check(player);
3336 player->setMoon(params);
3337 SendSetMoon(player->getPeerId(), params);
3340 void Server::setStars(RemotePlayer *player, const StarParams ¶ms)
3342 sanity_check(player);
3343 player->setStars(params);
3344 SendSetStars(player->getPeerId(), params);
3347 void Server::setClouds(RemotePlayer *player, const CloudParams ¶ms)
3349 sanity_check(player);
3350 player->setCloudParams(params);
3351 SendCloudParams(player->getPeerId(), params);
3354 void Server::overrideDayNightRatio(RemotePlayer *player, bool do_override,
3357 sanity_check(player);
3358 player->overrideDayNightRatio(do_override, ratio);
3359 SendOverrideDayNightRatio(player->getPeerId(), do_override, ratio);
3362 void Server::notifyPlayers(const std::wstring &msg)
3364 SendChatMessage(PEER_ID_INEXISTENT, ChatMessage(msg));
3367 void Server::spawnParticle(const std::string &playername, v3f pos,
3368 v3f velocity, v3f acceleration,
3369 float expirationtime, float size, bool
3370 collisiondetection, bool collision_removal, bool object_collision,
3371 bool vertical, const std::string &texture,
3372 const struct TileAnimationParams &animation, u8 glow)
3374 // m_env will be NULL if the server is initializing
3378 session_t peer_id = PEER_ID_INEXISTENT;
3380 if (!playername.empty()) {
3381 RemotePlayer *player = m_env->getPlayer(playername.c_str());
3384 peer_id = player->getPeerId();
3385 proto_ver = player->protocol_version;
3388 SendSpawnParticle(peer_id, proto_ver, pos, velocity, acceleration,
3389 expirationtime, size, collisiondetection, collision_removal,
3390 object_collision, vertical, texture, animation, glow);
3393 u32 Server::addParticleSpawner(u16 amount, float spawntime,
3394 v3f minpos, v3f maxpos, v3f minvel, v3f maxvel, v3f minacc, v3f maxacc,
3395 float minexptime, float maxexptime, float minsize, float maxsize,
3396 bool collisiondetection, bool collision_removal, bool object_collision,
3397 ServerActiveObject *attached, bool vertical, const std::string &texture,
3398 const std::string &playername, const struct TileAnimationParams &animation,
3401 // m_env will be NULL if the server is initializing
3405 session_t peer_id = PEER_ID_INEXISTENT;
3407 if (!playername.empty()) {
3408 RemotePlayer *player = m_env->getPlayer(playername.c_str());
3411 peer_id = player->getPeerId();
3412 proto_ver = player->protocol_version;
3415 u16 attached_id = attached ? attached->getId() : 0;
3418 if (attached_id == 0)
3419 id = m_env->addParticleSpawner(spawntime);
3421 id = m_env->addParticleSpawner(spawntime, attached_id);
3423 SendAddParticleSpawner(peer_id, proto_ver, amount, spawntime,
3424 minpos, maxpos, minvel, maxvel, minacc, maxacc,
3425 minexptime, maxexptime, minsize, maxsize, collisiondetection,
3426 collision_removal, object_collision, attached_id, vertical,
3427 texture, id, animation, glow);
3432 void Server::deleteParticleSpawner(const std::string &playername, u32 id)
3434 // m_env will be NULL if the server is initializing
3436 throw ServerError("Can't delete particle spawners during initialisation!");
3438 session_t peer_id = PEER_ID_INEXISTENT;
3439 if (!playername.empty()) {
3440 RemotePlayer *player = m_env->getPlayer(playername.c_str());
3443 peer_id = player->getPeerId();
3446 m_env->deleteParticleSpawner(id);
3447 SendDeleteParticleSpawner(peer_id, id);
3450 // actions: time-reversed list
3451 // Return value: success/failure
3452 bool Server::rollbackRevertActions(const std::list<RollbackAction> &actions,
3453 std::list<std::string> *log)
3455 infostream<<"Server::rollbackRevertActions(len="<<actions.size()<<")"<<std::endl;
3456 ServerMap *map = (ServerMap*)(&m_env->getMap());
3458 // Fail if no actions to handle
3459 if (actions.empty()) {
3461 log->push_back("Nothing to do.");
3468 for (const RollbackAction &action : actions) {
3470 bool success = action.applyRevert(map, m_inventory_mgr.get(), this);
3473 std::ostringstream os;
3474 os<<"Revert of step ("<<num_tried<<") "<<action.toString()<<" failed";
3475 infostream<<"Map::rollbackRevertActions(): "<<os.str()<<std::endl;
3477 log->push_back(os.str());
3479 std::ostringstream os;
3480 os<<"Successfully reverted step ("<<num_tried<<") "<<action.toString();
3481 infostream<<"Map::rollbackRevertActions(): "<<os.str()<<std::endl;
3483 log->push_back(os.str());
3487 infostream<<"Map::rollbackRevertActions(): "<<num_failed<<"/"<<num_tried
3488 <<" failed"<<std::endl;
3490 // Call it done if less than half failed
3491 return num_failed <= num_tried/2;
3494 // IGameDef interface
3496 IItemDefManager *Server::getItemDefManager()
3501 const NodeDefManager *Server::getNodeDefManager()
3506 ICraftDefManager *Server::getCraftDefManager()
3511 u16 Server::allocateUnknownNodeId(const std::string &name)
3513 return m_nodedef->allocateDummy(name);
3516 IWritableItemDefManager *Server::getWritableItemDefManager()
3521 NodeDefManager *Server::getWritableNodeDefManager()
3526 IWritableCraftDefManager *Server::getWritableCraftDefManager()
3531 const std::vector<ModSpec> & Server::getMods() const
3533 return m_modmgr->getMods();
3536 const ModSpec *Server::getModSpec(const std::string &modname) const
3538 return m_modmgr->getModSpec(modname);
3541 void Server::getModNames(std::vector<std::string> &modlist)
3543 m_modmgr->getModNames(modlist);
3546 std::string Server::getBuiltinLuaPath()
3548 return porting::path_share + DIR_DELIM + "builtin";
3551 std::string Server::getModStoragePath() const
3553 return m_path_world + DIR_DELIM + "mod_storage";
3556 v3f Server::findSpawnPos()
3558 ServerMap &map = m_env->getServerMap();
3560 if (g_settings->getV3FNoEx("static_spawnpoint", nodeposf))
3561 return nodeposf * BS;
3563 bool is_good = false;
3564 // Limit spawn range to mapgen edges (determined by 'mapgen_limit')
3565 s32 range_max = map.getMapgenParams()->getSpawnRangeMax();
3567 // Try to find a good place a few times
3568 for (s32 i = 0; i < 4000 && !is_good; i++) {
3569 s32 range = MYMIN(1 + i, range_max);
3570 // We're going to try to throw the player to this position
3571 v2s16 nodepos2d = v2s16(
3572 -range + (myrand() % (range * 2)),
3573 -range + (myrand() % (range * 2)));
3574 // Get spawn level at point
3575 s16 spawn_level = m_emerge->getSpawnLevelAtPoint(nodepos2d);
3576 // Continue if MAX_MAP_GENERATION_LIMIT was returned by the mapgen to
3577 // signify an unsuitable spawn position, or if outside limits.
3578 if (spawn_level >= MAX_MAP_GENERATION_LIMIT ||
3579 spawn_level <= -MAX_MAP_GENERATION_LIMIT)
3582 v3s16 nodepos(nodepos2d.X, spawn_level, nodepos2d.Y);
3583 // Consecutive empty nodes
3586 // Search upwards from 'spawn level' for 2 consecutive empty nodes, to
3587 // avoid obstructions in already-generated mapblocks.
3588 // In ungenerated mapblocks consisting of 'ignore' nodes, there will be
3589 // no obstructions, but mapgen decorations are generated after spawn so
3590 // the player may end up inside one.
3591 for (s32 i = 0; i < 8; i++) {
3592 v3s16 blockpos = getNodeBlockPos(nodepos);
3593 map.emergeBlock(blockpos, true);
3594 content_t c = map.getNode(nodepos).getContent();
3596 // In generated mapblocks allow spawn in all 'airlike' drawtype nodes.
3597 // In ungenerated mapblocks allow spawn in 'ignore' nodes.
3598 if (m_nodedef->get(c).drawtype == NDT_AIRLIKE || c == CONTENT_IGNORE) {
3600 if (air_count >= 2) {
3601 // Spawn in lower empty node
3603 nodeposf = intToFloat(nodepos, BS);
3604 // Don't spawn the player outside map boundaries
3605 if (objectpos_over_limit(nodeposf))
3606 // Exit this loop, positions above are probably over limit
3609 // Good position found, cause an exit from main loop
3623 // No suitable spawn point found, return fallback 0,0,0
3624 return v3f(0.0f, 0.0f, 0.0f);
3627 void Server::requestShutdown(const std::string &msg, bool reconnect, float delay)
3629 if (delay == 0.0f) {
3630 // No delay, shutdown immediately
3631 m_shutdown_state.is_requested = true;
3632 // only print to the infostream, a chat message saying
3633 // "Server Shutting Down" is sent when the server destructs.
3634 infostream << "*** Immediate Server shutdown requested." << std::endl;
3635 } else if (delay < 0.0f && m_shutdown_state.isTimerRunning()) {
3636 // Negative delay, cancel shutdown if requested
3637 m_shutdown_state.reset();
3638 std::wstringstream ws;
3640 ws << L"*** Server shutdown canceled.";
3642 infostream << wide_to_utf8(ws.str()).c_str() << std::endl;
3643 SendChatMessage(PEER_ID_INEXISTENT, ws.str());
3644 // m_shutdown_* are already handled, skip.
3646 } else if (delay > 0.0f) {
3647 // Positive delay, tell the clients when the server will shut down
3648 std::wstringstream ws;
3650 ws << L"*** Server shutting down in "
3651 << duration_to_string(myround(delay)).c_str()
3654 infostream << wide_to_utf8(ws.str()).c_str() << std::endl;
3655 SendChatMessage(PEER_ID_INEXISTENT, ws.str());
3658 m_shutdown_state.trigger(delay, msg, reconnect);
3661 PlayerSAO* Server::emergePlayer(const char *name, session_t peer_id, u16 proto_version)
3664 Try to get an existing player
3666 RemotePlayer *player = m_env->getPlayer(name);
3668 // If player is already connected, cancel
3669 if (player && player->getPeerId() != PEER_ID_INEXISTENT) {
3670 infostream<<"emergePlayer(): Player already connected"<<std::endl;
3675 If player with the wanted peer_id already exists, cancel.
3677 if (m_env->getPlayer(peer_id)) {
3678 infostream<<"emergePlayer(): Player with wrong name but same"
3679 " peer_id already exists"<<std::endl;
3684 player = new RemotePlayer(name, idef());
3687 bool newplayer = false;
3690 PlayerSAO *playersao = m_env->loadPlayer(player, &newplayer, peer_id, isSingleplayer());
3692 // Complete init with server parts
3693 playersao->finalize(player, getPlayerEffectivePrivs(player->getName()));
3694 player->protocol_version = proto_version;
3698 m_script->on_newplayer(playersao);
3704 bool Server::registerModStorage(ModMetadata *storage)
3706 if (m_mod_storages.find(storage->getModName()) != m_mod_storages.end()) {
3707 errorstream << "Unable to register same mod storage twice. Storage name: "
3708 << storage->getModName() << std::endl;
3712 m_mod_storages[storage->getModName()] = storage;
3716 void Server::unregisterModStorage(const std::string &name)
3718 std::unordered_map<std::string, ModMetadata *>::const_iterator it = m_mod_storages.find(name);
3719 if (it != m_mod_storages.end()) {
3720 // Save unconditionaly on unregistration
3721 it->second->save(getModStoragePath());
3722 m_mod_storages.erase(name);
3726 void dedicated_server_loop(Server &server, bool &kill)
3728 verbosestream<<"dedicated_server_loop()"<<std::endl;
3730 IntervalLimiter m_profiler_interval;
3732 static thread_local const float steplen =
3733 g_settings->getFloat("dedicated_server_step");
3734 static thread_local const float profiler_print_interval =
3735 g_settings->getFloat("profiler_print_interval");
3738 * The dedicated server loop only does time-keeping (in Server::step) and
3739 * provides a way to main.cpp to kill the server externally (bool &kill).
3743 // This is kind of a hack but can be done like this
3744 // because server.step() is very light
3745 sleep_ms((int)(steplen*1000.0));
3746 server.step(steplen);
3748 if (server.isShutdownRequested() || kill)
3754 if (profiler_print_interval != 0) {
3755 if(m_profiler_interval.step(steplen, profiler_print_interval))
3757 infostream<<"Profiler:"<<std::endl;
3758 g_profiler->print(infostream);
3759 g_profiler->clear();
3764 infostream << "Dedicated server quitting" << std::endl;
3766 if (g_settings->getBool("server_announce"))
3767 ServerList::sendAnnounce(ServerList::AA_DELETE,
3768 server.m_bind_addr.getPort());
3777 bool Server::joinModChannel(const std::string &channel)
3779 return m_modchannel_mgr->joinChannel(channel, PEER_ID_SERVER) &&
3780 m_modchannel_mgr->setChannelState(channel, MODCHANNEL_STATE_READ_WRITE);
3783 bool Server::leaveModChannel(const std::string &channel)
3785 return m_modchannel_mgr->leaveChannel(channel, PEER_ID_SERVER);
3788 bool Server::sendModChannelMessage(const std::string &channel, const std::string &message)
3790 if (!m_modchannel_mgr->canWriteOnChannel(channel))
3793 broadcastModChannelMessage(channel, message, PEER_ID_SERVER);
3797 ModChannel* Server::getModChannel(const std::string &channel)
3799 return m_modchannel_mgr->getModChannel(channel);
3802 void Server::broadcastModChannelMessage(const std::string &channel,
3803 const std::string &message, session_t from_peer)
3805 const std::vector<u16> &peers = m_modchannel_mgr->getChannelPeers(channel);
3809 if (message.size() > STRING_MAX_LEN) {
3810 warningstream << "ModChannel message too long, dropping before sending "
3811 << " (" << message.size() << " > " << STRING_MAX_LEN << ", channel: "
3812 << channel << ")" << std::endl;
3817 if (from_peer != PEER_ID_SERVER) {
3818 sender = getPlayerName(from_peer);
3821 NetworkPacket resp_pkt(TOCLIENT_MODCHANNEL_MSG,
3822 2 + channel.size() + 2 + sender.size() + 2 + message.size());
3823 resp_pkt << channel << sender << message;
3824 for (session_t peer_id : peers) {
3826 if (peer_id == from_peer)
3829 Send(peer_id, &resp_pkt);
3832 if (from_peer != PEER_ID_SERVER) {
3833 m_script->on_modchannel_message(channel, sender, message);
3837 void Server::loadTranslationLanguage(const std::string &lang_code)
3839 if (g_server_translations->count(lang_code))
3840 return; // Already loaded
3842 std::string suffix = "." + lang_code + ".tr";
3843 for (const auto &i : m_media) {
3844 if (str_ends_with(i.first, suffix)) {
3845 std::ifstream t(i.second.path);
3846 std::string data((std::istreambuf_iterator<char>(t)),
3847 std::istreambuf_iterator<char>());
3849 (*g_server_translations)[lang_code].loadTranslation(data);