X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fserver.cpp;h=3aff2fb977e6e601cd7ef65ae4a58c396cb3bd22;hb=6f2d785d0ff761961912d7e79a7d16c4adf86861;hp=262970c09a195bdd96615121d2b0e8e40683097d;hpb=c061bdd37ff91a4dd6f837f618fa2f48350e1ae6;p=minetest.git

diff --git a/src/server.cpp b/src/server.cpp
index 262970c09..3aff2fb97 100644
--- a/src/server.cpp
+++ b/src/server.cpp
@@ -21,12 +21,12 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include <iostream>
 #include <queue>
 #include <algorithm>
-#include "clientserver.h"
+#include "network/networkprotocol.h"
+#include "network/serveropcodes.h"
 #include "ban.h"
 #include "environment.h"
 #include "map.h"
-#include "jthread/jmutexautolock.h"
-#include "main.h"
+#include "threading/mutex_auto_lock.h"
 #include "constants.h"
 #include "voxel.h"
 #include "config.h"
@@ -44,26 +44,24 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "craftdef.h"
 #include "emerge.h"
 #include "mapgen.h"
-#include "biome.h"
+#include "mg_biome.h"
 #include "content_mapnode.h"
 #include "content_nodemeta.h"
 #include "content_abm.h"
 #include "content_sao.h"
 #include "mods.h"
-#include "sha1.h"
-#include "base64.h"
-#include "tool.h"
 #include "sound.h" // dummySoundManager
 #include "event_manager.h"
-#include "hex.h"
 #include "serverlist.h"
 #include "util/string.h"
-#include "util/pointedthing.h"
 #include "util/mathconstants.h"
 #include "rollback.h"
 #include "util/serialize.h"
 #include "util/thread.h"
 #include "defaultsettings.h"
+#include "util/base64.h"
+#include "util/sha1.h"
+#include "util/hex.h"
 
 class ClientNotFoundException : public BaseException
 {
@@ -73,65 +71,48 @@ class ClientNotFoundException : public BaseException
 	{}
 };
 
-class ServerThread : public JThread
+class ServerThread : public Thread
 {
-	Server *m_server;
-
 public:
 
 	ServerThread(Server *server):
-		JThread(),
+		Thread("Server"),
 		m_server(server)
-	{
-	}
+	{}
+
+	void *run();
 
-	void * Thread();
+private:
+	Server *m_server;
 };
 
-void * ServerThread::Thread()
+void *ServerThread::run()
 {
-	log_register_thread("ServerThread");
-
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 	BEGIN_DEBUG_EXCEPTION_HANDLER
 
 	m_server->AsyncRunStep(true);
 
-	ThreadStarted();
-
-	porting::setThreadName("ServerThread");
-
-	while(!StopRequested())
-	{
-		try{
+	while (!stopRequested()) {
+		try {
 			//TimeTaker timer("AsyncRunStep() + Receive()");
 
 			m_server->AsyncRunStep();
 
 			m_server->Receive();
 
-		}
-		catch(con::NoIncomingDataException &e)
-		{
-		}
-		catch(con::PeerNotFoundException &e)
-		{
+		} catch (con::NoIncomingDataException &e) {
+		} catch (con::PeerNotFoundException &e) {
 			infostream<<"Server: PeerNotFoundException"<<std::endl;
-		}
-		catch(ClientNotFoundException &e)
-		{
-		}
-		catch(con::ConnectionBindFailed &e)
-		{
-			m_server->setAsyncFatalError(e.what());
-		}
-		catch(LuaError &e)
-		{
+		} catch (ClientNotFoundException &e) {
+		} catch (con::ConnectionBindFailed &e) {
 			m_server->setAsyncFatalError(e.what());
+		} catch (LuaError &e) {
+			m_server->setAsyncFatalError("Lua: " + std::string(e.what()));
 		}
 	}
 
-	END_DEBUG_EXCEPTION_HANDLER(errorstream)
+	END_DEBUG_EXCEPTION_HANDLER
 
 	return NULL;
 }
@@ -181,7 +162,6 @@ Server::Server(
 			this),
 	m_banmanager(NULL),
 	m_rollback(NULL),
-	m_rollback_sink_enabled(true),
 	m_enable_rollback_recording(false),
 	m_emerge(NULL),
 	m_script(NULL),
@@ -194,8 +174,10 @@ Server::Server(
 	m_uptime(0),
 	m_clients(&m_con),
 	m_shutdown_requested(false),
+	m_shutdown_ask_reconnect(false),
 	m_ignore_map_edit_events(false),
-	m_ignore_map_edit_events_peer_id(0)
+	m_ignore_map_edit_events_peer_id(0),
+	m_next_sound_id(0)
 
 {
 	m_liquid_transform_timer = 0.0;
@@ -223,12 +205,9 @@ Server::Server(
 	infostream<<"- world:  "<<m_path_world<<std::endl;
 	infostream<<"- game:   "<<m_gamespec.path<<std::endl;
 
-	// Initialize default settings and override defaults with those provided
-	// by the game
-	set_default_settings(g_settings);
-	Settings gamedefaults;
-	getGameMinetestConfig(gamespec.path, gamedefaults);
-	override_default_settings(g_settings, &gamedefaults);
+	// Create world if it doesn't exist
+	if(!loadGameConfAndInitWorld(m_path_world, m_gamespec))
+		throw ServerError("Failed to initialize world");
 
 	// Create server thread
 	m_thread = new ServerThread(this);
@@ -236,27 +215,17 @@ Server::Server(
 	// Create emerge manager
 	m_emerge = new EmergeManager(this);
 
-	// Create world if it doesn't exist
-	if(!initializeWorld(m_path_world, m_gamespec.id))
-		throw ServerError("Failed to initialize world");
-
 	// Create ban manager
-	std::string ban_path = m_path_world+DIR_DELIM+"ipban.txt";
+	std::string ban_path = m_path_world + DIR_DELIM "ipban.txt";
 	m_banmanager = new BanManager(ban_path);
 
-	// Create rollback manager
-	std::string rollback_path = m_path_world+DIR_DELIM+"rollback.txt";
-	m_rollback = createRollbackManager(rollback_path, this);
-
 	ModConfiguration modconf(m_path_world);
 	m_mods = modconf.getMods();
 	std::vector<ModSpec> unsatisfied_mods = modconf.getUnsatisfiedMods();
 	// complain about mods with unsatisfied dependencies
-	if(!modconf.isConsistent())
-	{
+	if(!modconf.isConsistent()) {
 		for(std::vector<ModSpec>::iterator it = unsatisfied_mods.begin();
-			it != unsatisfied_mods.end(); ++it)
-		{
+			it != unsatisfied_mods.end(); ++it) {
 			ModSpec mod = *it;
 			errorstream << "mod \"" << mod.name << "\" has unsatisfied dependencies: ";
 			for(std::set<std::string>::iterator dep_it = mod.unsatisfied_depends.begin();
@@ -272,8 +241,7 @@ Server::Server(
 	std::vector<std::string> names = worldmt_settings.getNames();
 	std::set<std::string> load_mod_names;
 	for(std::vector<std::string>::iterator it = names.begin();
-		it != names.end(); ++it)
-	{
+		it != names.end(); ++it) {
 		std::string name = *it;
 		if(name.compare(0,9,"load_mod_")==0 && worldmt_settings.getBool(name))
 			load_mod_names.insert(name.substr(9));
@@ -285,8 +253,7 @@ Server::Server(
 	for(std::vector<ModSpec>::iterator it = unsatisfied_mods.begin();
 			it != unsatisfied_mods.end(); ++it)
 		load_mod_names.erase((*it).name);
-	if(!load_mod_names.empty())
-	{
+	if(!load_mod_names.empty()) {
 		errorstream << "The following mods could not be found:";
 		for(std::set<std::string>::iterator it = load_mod_names.begin();
 			it != load_mod_names.end(); ++it)
@@ -294,41 +261,55 @@ Server::Server(
 		errorstream << std::endl;
 	}
 
-	// Lock environment
-	JMutexAutoLock envlock(m_env_mutex);
+	//lock environment
+	MutexAutoLock envlock(m_env_mutex);
+
+	// Load mapgen params from Settings
+	m_emerge->loadMapgenParams();
+
+	// Create the Map (loads map_meta.txt, overriding configured mapgen params)
+	ServerMap *servermap = new ServerMap(path_world, this, m_emerge);
 
 	// Initialize scripting
 	infostream<<"Server: Initializing Lua"<<std::endl;
 
 	m_script = new GameScripting(this);
 
-	std::string scriptpath = getBuiltinLuaPath() + DIR_DELIM "init.lua";
-
-	if (!m_script->loadScript(scriptpath)) {
-		throw ModError("Failed to load and run " + scriptpath);
-	}
+	std::string script_path = getBuiltinLuaPath() + DIR_DELIM "init.lua";
+	std::string error_msg;
 
+	if (!m_script->loadMod(script_path, BUILTIN_MOD_NAME, &error_msg))
+		throw ModError("Failed to load and run " + script_path
+				+ "\nError from Lua:\n" + error_msg);
 
-	// Print 'em
-	infostream<<"Server: Loading mods: ";
+	// Print mods
+	infostream << "Server: Loading mods: ";
 	for(std::vector<ModSpec>::iterator i = m_mods.begin();
-			i != m_mods.end(); i++){
+			i != m_mods.end(); ++i) {
 		const ModSpec &mod = *i;
-		infostream<<mod.name<<" ";
+		infostream << mod.name << " ";
 	}
-	infostream<<std::endl;
+	infostream << std::endl;
 	// Load and run "mod" scripts
-	for(std::vector<ModSpec>::iterator i = m_mods.begin();
-			i != m_mods.end(); i++){
+	for (std::vector<ModSpec>::iterator i = m_mods.begin();
+			i != m_mods.end(); ++i) {
 		const ModSpec &mod = *i;
-		std::string scriptpath = mod.path + DIR_DELIM + "init.lua";
-		infostream<<"  ["<<padStringRight(mod.name, 12)<<"] [\""
-				<<scriptpath<<"\"]"<<std::endl;
-		bool success = m_script->loadMod(scriptpath, mod.name);
-		if(!success){
-			errorstream<<"Server: Failed to load and run "
-					<<scriptpath<<std::endl;
-			throw ModError("Failed to load and run "+scriptpath);
+		if (!string_allowed(mod.name, MODNAME_ALLOWED_CHARS)) {
+			std::ostringstream err;
+			err << "Error loading mod \"" << mod.name
+					<< "\": mod_name does not follow naming conventions: "
+					<< "Only chararacters [a-z0-9_] are allowed." << std::endl;
+			errorstream << err.str().c_str();
+			throw ModError(err.str());
+		}
+		std::string script_path = mod.path + DIR_DELIM "init.lua";
+		infostream << "  [" << padStringRight(mod.name, 12) << "] [\""
+				<< script_path << "\"]" << std::endl;
+		if (!m_script->loadMod(script_path, mod.name, &error_msg)) {
+			errorstream << "Server: Failed to load and run "
+					<< script_path << std::endl;
+			throw ModError("Failed to load and run " + script_path
+					+ "\nError from Lua:\n" + error_msg);
 		}
 	}
 
@@ -338,22 +319,33 @@ Server::Server(
 	// Apply item aliases in the node definition manager
 	m_nodedef->updateAliases(m_itemdef);
 
-	// Load the mapgen params from global settings now after any
-	// initial overrides have been set by the mods
-	m_emerge->loadMapgenParams();
+	// Apply texture overrides from texturepack/override.txt
+	std::string texture_path = g_settings->get("texture_path");
+	if (texture_path != "" && fs::IsDir(texture_path))
+		m_nodedef->applyTextureOverrides(texture_path + DIR_DELIM + "override.txt");
+
+	m_nodedef->setNodeRegistrationStatus(true);
+
+	// Perform pending node name resolutions
+	m_nodedef->runNodeResolveCallbacks();
+
+	// init the recipe hashes to speed up crafting
+	m_craftdef->initHashes(this);
 
 	// Initialize Environment
-	ServerMap *servermap = new ServerMap(path_world, this, m_emerge);
 	m_env = new ServerEnvironment(servermap, m_script, this, m_path_world);
 
 	m_clients.setEnv(m_env);
 
-	// Run some callbacks after the MG params have been set up but before activation
-	m_script->environment_OnMapgenInit(&m_emerge->params);
-
 	// Initialize mapgens
 	m_emerge->initMapgens();
 
+	m_enable_rollback_recording = g_settings->getBool("enable_rollback_recording");
+	if (m_enable_rollback_recording) {
+		// Create rollback manager
+		m_rollback = new RollbackManager(m_path_world, this);
+	}
+
 	// Give environment reference to scripting api
 	m_script->initializeEnvironment(m_env);
 
@@ -381,15 +373,28 @@ Server::~Server()
 	SendChatMessage(PEER_ID_INEXISTENT, L"*** Server shutting down");
 
 	{
-		JMutexAutoLock envlock(m_env_mutex);
+		MutexAutoLock envlock(m_env_mutex);
 
 		// Execute script shutdown hooks
 		m_script->on_shutdown();
 
-		infostream<<"Server: Saving players"<<std::endl;
+		infostream << "Server: Saving players" << std::endl;
 		m_env->saveLoadedPlayers();
 
-		infostream<<"Server: Saving environment metadata"<<std::endl;
+		infostream << "Server: Kicking players" << std::endl;
+		std::string kick_msg;
+		bool reconnect = false;
+		if (getShutdownRequested()) {
+			reconnect = m_shutdown_ask_reconnect;
+			kick_msg = m_shutdown_msg;
+		}
+		if (kick_msg == "") {
+			kick_msg = g_settings->get("kick_msg_shutdown");
+		}
+		m_env->kickAllPlayers(SERVER_ACCESSDENIED_SHUTDOWN,
+			kick_msg, reconnect);
+
+		infostream << "Server: Saving environment metadata" << std::endl;
 		m_env->saveMeta();
 	}
 
@@ -421,26 +426,29 @@ Server::~Server()
 	// Delete detached inventories
 	for (std::map<std::string, Inventory*>::iterator
 			i = m_detached_inventories.begin();
-			i != m_detached_inventories.end(); i++) {
+			i != m_detached_inventories.end(); ++i) {
 		delete i->second;
 	}
 }
 
 void Server::start(Address bind_addr)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
+
+	m_bind_addr = bind_addr;
+
 	infostream<<"Starting server on "
 			<< bind_addr.serializeString() <<"..."<<std::endl;
 
 	// Stop thread if already running
-	m_thread->Stop();
+	m_thread->stop();
 
 	// Initialize connection
 	m_con.SetTimeoutMs(30);
 	m_con.Serve(bind_addr);
 
 	// Start thread
-	m_thread->Start();
+	m_thread->start();
 
 	// ASCII art for the win!
 	actionstream
@@ -458,14 +466,14 @@ void Server::start(Address bind_addr)
 
 void Server::stop()
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 
 	infostream<<"Server: Stopping and waiting threads"<<std::endl;
 
 	// Stop threads (set run=false first so both start stopping)
-	m_thread->Stop();
+	m_thread->stop();
 	//m_emergethread.setRun(false);
-	m_thread->Wait();
+	m_thread->wait();
 	//m_emergethread.stop();
 
 	infostream<<"Server: Threads stopped"<<std::endl;
@@ -473,30 +481,41 @@ void Server::stop()
 
 void Server::step(float dtime)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 	// Limit a bit
 	if(dtime > 2.0)
 		dtime = 2.0;
 	{
-		JMutexAutoLock lock(m_step_dtime_mutex);
+		MutexAutoLock lock(m_step_dtime_mutex);
 		m_step_dtime += dtime;
 	}
 	// Throw if fatal error occurred in thread
 	std::string async_err = m_async_fatal_error.get();
-	if(async_err != ""){
-		throw ServerError(async_err);
+	if(async_err != "") {
+		if (m_simple_singleplayer_mode) {
+			throw ServerError(async_err);
+		}
+		else {
+			m_env->kickAllPlayers(SERVER_ACCESSDENIED_CRASH,
+				g_settings->get("kick_msg_crash"),
+				g_settings->getBool("ask_reconnect_on_crash"));
+			errorstream << "UNRECOVERABLE error occurred. Stopping server. "
+					<< "Please fix the following error:" << std::endl
+					<< async_err << std::endl;
+			FATAL_ERROR(async_err.c_str());
+		}
 	}
 }
 
 void Server::AsyncRunStep(bool initial_step)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 
 	g_profiler->add("Server::AsyncRunStep (num)", 1);
 
 	float dtime;
 	{
-		JMutexAutoLock lock1(m_step_dtime_mutex);
+		MutexAutoLock lock1(m_step_dtime_mutex);
 		dtime = m_step_dtime;
 	}
 
@@ -514,7 +533,7 @@ void Server::AsyncRunStep(bool initial_step)
 	//infostream<<"Server::AsyncRunStep(): dtime="<<dtime<<std::endl;
 
 	{
-		JMutexAutoLock lock1(m_step_dtime_mutex);
+		MutexAutoLock lock1(m_step_dtime_mutex);
 		m_step_dtime -= dtime;
 	}
 
@@ -530,27 +549,22 @@ void Server::AsyncRunStep(bool initial_step)
 	/*
 		Update time of day and overall game time
 	*/
-	{
-		JMutexAutoLock envlock(m_env_mutex);
-
-		m_env->setTimeOfDaySpeed(g_settings->getFloat("time_speed"));
+	m_env->setTimeOfDaySpeed(g_settings->getFloat("time_speed"));
 
-		/*
-			Send to clients at constant intervals
-		*/
+	/*
+		Send to clients at constant intervals
+	*/
 
-		m_time_of_day_send_timer -= dtime;
-		if(m_time_of_day_send_timer < 0.0)
-		{
-			m_time_of_day_send_timer = g_settings->getFloat("time_send_interval");
-			u16 time = m_env->getTimeOfDay();
-			float time_speed = g_settings->getFloat("time_speed");
-			SendTimeOfDay(PEER_ID_INEXISTENT, time, time_speed);
-		}
+	m_time_of_day_send_timer -= dtime;
+	if(m_time_of_day_send_timer < 0.0) {
+		m_time_of_day_send_timer = g_settings->getFloat("time_send_interval");
+		u16 time = m_env->getTimeOfDay();
+		float time_speed = g_settings->getFloat("time_speed");
+		SendTimeOfDay(PEER_ID_INEXISTENT, time, time_speed);
 	}
 
 	{
-		JMutexAutoLock lock(m_env_mutex);
+		MutexAutoLock lock(m_env_mutex);
 		// Figure out and report maximum lag to environment
 		float max_lag = m_env->getMaxLagEstimate();
 		max_lag *= 0.9998; // Decrease slowly (about half per 5 minutes)
@@ -567,77 +581,28 @@ void Server::AsyncRunStep(bool initial_step)
 		m_env->step(dtime);
 	}
 
-	const float map_timer_and_unload_dtime = 2.92;
+	static const float map_timer_and_unload_dtime = 2.92;
 	if(m_map_timer_and_unload_interval.step(dtime, map_timer_and_unload_dtime))
 	{
-		JMutexAutoLock lock(m_env_mutex);
+		MutexAutoLock lock(m_env_mutex);
 		// Run Map's timers and unload unused data
 		ScopeProfiler sp(g_profiler, "Server: map timer and unload");
 		m_env->getMap().timerUpdate(map_timer_and_unload_dtime,
-				g_settings->getFloat("server_unload_unused_data_timeout"));
+			g_settings->getFloat("server_unload_unused_data_timeout"),
+			U32_MAX);
 	}
 
 	/*
 		Do background stuff
 	*/
 
-	/*
-		Handle players
-	*/
-	{
-		JMutexAutoLock lock(m_env_mutex);
-
-		std::list<u16> clientids = m_clients.getClientIDs();
-
-		ScopeProfiler sp(g_profiler, "Server: handle players");
-
-		for(std::list<u16>::iterator
-			i = clientids.begin();
-			i != clientids.end(); ++i)
-		{
-			PlayerSAO *playersao = getPlayerSAO(*i);
-			if(playersao == NULL)
-				continue;
-
-			/*
-				Handle player HPs (die if hp=0)
-			*/
-			if(playersao->m_hp_not_sent && g_settings->getBool("enable_damage"))
-			{
-				if(playersao->getHP() == 0)
-					DiePlayer(*i);
-				else
-					SendPlayerHP(*i);
-			}
-
-			/*
-				Send player breath if changed
-			*/
-			if(playersao->m_breath_not_sent) {
-				SendPlayerBreath(*i);
-			}
-
-			/*
-				Send player inventories if necessary
-			*/
-			if(playersao->m_moved){
-				SendMovePlayer(*i);
-				playersao->m_moved = false;
-			}
-			if(playersao->m_inventory_not_sent){
-				UpdateCrafting(*i);
-				SendInventory(*i);
-			}
-		}
-	}
-
 	/* Transform liquids */
 	m_liquid_transform_timer += dtime;
 	if(m_liquid_transform_timer >= m_liquid_transform_every)
 	{
 		m_liquid_transform_timer -= m_liquid_transform_every;
 
-		JMutexAutoLock lock(m_env_mutex);
+		MutexAutoLock lock(m_env_mutex);
 
 		ScopeProfiler sp(g_profiler, "Server: liquid transform");
 
@@ -663,7 +628,7 @@ void Server::AsyncRunStep(bool initial_step)
 		/*
 			Set the modified blocks unsent for all the clients
 		*/
-		if(modified_blocks.size() > 0)
+		if(!modified_blocks.empty())
 		{
 			SetBlocksNotSent(modified_blocks);
 		}
@@ -679,11 +644,13 @@ void Server::AsyncRunStep(bool initial_step)
 				g_settings->getBool("server_announce"))
 		{
 			ServerList::sendAnnounce(counter ? "update" : "start",
+					m_bind_addr.getPort(),
 					m_clients.getPlayerNames(),
 					m_uptime.get(),
 					m_env->getGameTime(),
 					m_lag,
 					m_gamespec.id,
+					m_emerge->params.mg_name,
 					m_mods);
 			counter = 0.01;
 		}
@@ -696,20 +663,26 @@ void Server::AsyncRunStep(bool initial_step)
 	*/
 	{
 		//infostream<<"Server: Checking added and deleted active objects"<<std::endl;
-		JMutexAutoLock envlock(m_env_mutex);
+		MutexAutoLock envlock(m_env_mutex);
 
-		m_clients.Lock();
+		m_clients.lock();
 		std::map<u16, RemoteClient*> clients = m_clients.getClientList();
 		ScopeProfiler sp(g_profiler, "Server: checking added and deleted objs");
 
 		// Radius inside which objects are active
 		s16 radius = g_settings->getS16("active_object_send_range_blocks");
+		s16 player_radius = g_settings->getS16("player_transfer_distance");
+
+		if (player_radius == 0 && g_settings->exists("unlimited_player_transfer_distance") &&
+				!g_settings->getBool("unlimited_player_transfer_distance"))
+			player_radius = radius;
+
 		radius *= MAP_BLOCKSIZE;
+		player_radius *= MAP_BLOCKSIZE;
 
-		for(std::map<u16, RemoteClient*>::iterator
+		for (std::map<u16, RemoteClient*>::iterator
 			i = clients.begin();
-			i != clients.end(); ++i)
-		{
+			i != clients.end(); ++i) {
 			RemoteClient *client = i->second;
 
 			// If definitions and textures have not been sent, don't
@@ -718,27 +691,23 @@ void Server::AsyncRunStep(bool initial_step)
 				continue;
 
 			Player *player = m_env->getPlayer(client->peer_id);
-			if(player==NULL)
-			{
+			if(player == NULL) {
 				// This can happen if the client timeouts somehow
-				/*infostream<<"WARNING: "<<__FUNCTION_NAME<<": Client "
+				/*warningstream<<FUNCTION_NAME<<": Client "
 						<<client->peer_id
 						<<" has no associated player"<<std::endl;*/
 				continue;
 			}
-			v3s16 pos = floatToInt(player->getPosition(), BS);
 
-			std::set<u16> removed_objects;
-			std::set<u16> added_objects;
-			m_env->getRemovedActiveObjects(pos, radius,
+			std::queue<u16> removed_objects;
+			std::queue<u16> added_objects;
+			m_env->getRemovedActiveObjects(player, radius, player_radius,
 					client->m_known_objects, removed_objects);
-			m_env->getAddedActiveObjects(pos, radius,
+			m_env->getAddedActiveObjects(player, radius, player_radius,
 					client->m_known_objects, added_objects);
 
 			// Ignore if nothing happened
-			if(removed_objects.size() == 0 && added_objects.size() == 0)
-			{
-				//infostream<<"active objects: none changed"<<std::endl;
+			if (removed_objects.empty() && added_objects.empty()) {
 				continue;
 			}
 
@@ -749,12 +718,9 @@ void Server::AsyncRunStep(bool initial_step)
 			// Handle removed objects
 			writeU16((u8*)buf, removed_objects.size());
 			data_buffer.append(buf, 2);
-			for(std::set<u16>::iterator
-					i = removed_objects.begin();
-					i != removed_objects.end(); ++i)
-			{
+			while (!removed_objects.empty()) {
 				// Get object
-				u16 id = *i;
+				u16 id = removed_objects.front();
 				ServerActiveObject* obj = m_env->getActiveObject(id);
 
 				// Add to data buffer for sending
@@ -766,23 +732,21 @@ void Server::AsyncRunStep(bool initial_step)
 
 				if(obj && obj->m_known_by_count > 0)
 					obj->m_known_by_count--;
+				removed_objects.pop();
 			}
 
 			// Handle added objects
 			writeU16((u8*)buf, added_objects.size());
 			data_buffer.append(buf, 2);
-			for(std::set<u16>::iterator
-					i = added_objects.begin();
-					i != added_objects.end(); ++i)
-			{
+			while (!added_objects.empty()) {
 				// Get object
-				u16 id = *i;
+				u16 id = added_objects.front();
 				ServerActiveObject* obj = m_env->getActiveObject(id);
 
 				// Get object type
 				u8 type = ACTIVEOBJECT_TYPE_INVALID;
 				if(obj == NULL)
-					infostream<<"WARNING: "<<__FUNCTION_NAME
+					warningstream<<FUNCTION_NAME
 							<<": NULL object"<<std::endl;
 				else
 					type = obj->getSendType();
@@ -804,108 +768,72 @@ void Server::AsyncRunStep(bool initial_step)
 
 				if(obj)
 					obj->m_known_by_count++;
-			}
-
-			// Send packet
-			SharedBuffer<u8> reply(2 + data_buffer.size());
-			writeU16(&reply[0], TOCLIENT_ACTIVE_OBJECT_REMOVE_ADD);
-			memcpy((char*)&reply[2], data_buffer.c_str(),
-					data_buffer.size());
-			// Send as reliable
-			m_clients.send(client->peer_id, 0, reply, true);
-
-			verbosestream<<"Server: Sent object remove/add: "
-					<<removed_objects.size()<<" removed, "
-					<<added_objects.size()<<" added, "
-					<<"packet size is "<<reply.getSize()<<std::endl;
-		}
-		m_clients.Unlock();
-#if 0
-		/*
-			Collect a list of all the objects known by the clients
-			and report it back to the environment.
-		*/
-
-		core::map<u16, bool> all_known_objects;
 
-		for(core::map<u16, RemoteClient*>::Iterator
-			i = m_clients.getIterator();
-			i.atEnd() == false; i++)
-		{
-			RemoteClient *client = i.getNode()->getValue();
-			// Go through all known objects of client
-			for(core::map<u16, bool>::Iterator
-					i = client->m_known_objects.getIterator();
-					i.atEnd()==false; i++)
-			{
-				u16 id = i.getNode()->getKey();
-				all_known_objects[id] = true;
+				added_objects.pop();
 			}
-		}
-
-		m_env->setKnownActiveObjects(whatever);
-#endif
 
+			u32 pktSize = SendActiveObjectRemoveAdd(client->peer_id, data_buffer);
+			verbosestream << "Server: Sent object remove/add: "
+					<< removed_objects.size() << " removed, "
+					<< added_objects.size() << " added, "
+					<< "packet size is " << pktSize << std::endl;
+		}
+		m_clients.unlock();
 	}
 
 	/*
 		Send object messages
 	*/
 	{
-		JMutexAutoLock envlock(m_env_mutex);
+		MutexAutoLock envlock(m_env_mutex);
 		ScopeProfiler sp(g_profiler, "Server: sending object messages");
 
 		// Key = object id
 		// Value = data sent by object
-		std::map<u16, std::list<ActiveObjectMessage>* > buffered_messages;
+		std::map<u16, std::vector<ActiveObjectMessage>* > buffered_messages;
 
 		// Get active object messages from environment
-		for(;;)
-		{
+		for(;;) {
 			ActiveObjectMessage aom = m_env->getActiveObjectMessage();
-			if(aom.id == 0)
+			if (aom.id == 0)
 				break;
 
-			std::list<ActiveObjectMessage>* message_list = NULL;
-			std::map<u16, std::list<ActiveObjectMessage>* >::iterator n;
+			std::vector<ActiveObjectMessage>* message_list = NULL;
+			std::map<u16, std::vector<ActiveObjectMessage>* >::iterator n;
 			n = buffered_messages.find(aom.id);
-			if(n == buffered_messages.end())
-			{
-				message_list = new std::list<ActiveObjectMessage>;
+			if (n == buffered_messages.end()) {
+				message_list = new std::vector<ActiveObjectMessage>;
 				buffered_messages[aom.id] = message_list;
 			}
-			else
-			{
+			else {
 				message_list = n->second;
 			}
 			message_list->push_back(aom);
 		}
 
-		m_clients.Lock();
+		m_clients.lock();
 		std::map<u16, RemoteClient*> clients = m_clients.getClientList();
 		// Route data to every client
-		for(std::map<u16, RemoteClient*>::iterator
+		for (std::map<u16, RemoteClient*>::iterator
 			i = clients.begin();
-			i != clients.end(); ++i)
-		{
+			i != clients.end(); ++i) {
 			RemoteClient *client = i->second;
 			std::string reliable_data;
 			std::string unreliable_data;
 			// Go through all objects in message buffer
-			for(std::map<u16, std::list<ActiveObjectMessage>* >::iterator
+			for (std::map<u16, std::vector<ActiveObjectMessage>* >::iterator
 					j = buffered_messages.begin();
-					j != buffered_messages.end(); ++j)
-			{
+					j != buffered_messages.end(); ++j) {
 				// If object is not known by client, skip it
 				u16 id = j->first;
-				if(client->m_known_objects.find(id) == client->m_known_objects.end())
+				if (client->m_known_objects.find(id) == client->m_known_objects.end())
 					continue;
+
 				// Get message list of object
-				std::list<ActiveObjectMessage>* list = j->second;
+				std::vector<ActiveObjectMessage>* list = j->second;
 				// Go through every message
-				for(std::list<ActiveObjectMessage>::iterator
-						k = list->begin(); k != list->end(); ++k)
-				{
+				for (std::vector<ActiveObjectMessage>::iterator
+						k = list->begin(); k != list->end(); ++k) {
 					// Compose the full new data with header
 					ActiveObjectMessage aom = *k;
 					std::string new_data;
@@ -926,40 +854,20 @@ void Server::AsyncRunStep(bool initial_step)
 				reliable_data and unreliable_data are now ready.
 				Send them.
 			*/
-			if(reliable_data.size() > 0)
-			{
-				SharedBuffer<u8> reply(2 + reliable_data.size());
-				writeU16(&reply[0], TOCLIENT_ACTIVE_OBJECT_MESSAGES);
-				memcpy((char*)&reply[2], reliable_data.c_str(),
-						reliable_data.size());
-				// Send as reliable
-				m_clients.send(client->peer_id, 0, reply, true);
-			}
-			if(unreliable_data.size() > 0)
-			{
-				SharedBuffer<u8> reply(2 + unreliable_data.size());
-				writeU16(&reply[0], TOCLIENT_ACTIVE_OBJECT_MESSAGES);
-				memcpy((char*)&reply[2], unreliable_data.c_str(),
-						unreliable_data.size());
-				// Send as unreliable
-				m_clients.send(client->peer_id, 1, reply, false);
+			if(reliable_data.size() > 0) {
+				SendActiveObjectMessages(client->peer_id, reliable_data);
 			}
 
-			/*if(reliable_data.size() > 0 || unreliable_data.size() > 0)
-			{
-				infostream<<"Server: Size of object message data: "
-						<<"reliable: "<<reliable_data.size()
-						<<", unreliable: "<<unreliable_data.size()
-						<<std::endl;
-			}*/
+			if(unreliable_data.size() > 0) {
+				SendActiveObjectMessages(client->peer_id, unreliable_data, false);
+			}
 		}
-		m_clients.Unlock();
+		m_clients.unlock();
 
 		// Clear buffered_messages
-		for(std::map<u16, std::list<ActiveObjectMessage>* >::iterator
+		for(std::map<u16, std::vector<ActiveObjectMessage>* >::iterator
 				i = buffered_messages.begin();
-				i != buffered_messages.end(); ++i)
-		{
+				i != buffered_messages.end(); ++i) {
 			delete i->second;
 		}
 	}
@@ -969,7 +877,7 @@ void Server::AsyncRunStep(bool initial_step)
 	*/
 	{
 		// We will be accessing the environment
-		JMutexAutoLock lock(m_env_mutex);
+		MutexAutoLock lock(m_env_mutex);
 
 		// Don't send too many at a time
 		//u32 count = 0;
@@ -986,83 +894,67 @@ void Server::AsyncRunStep(bool initial_step)
 
 		while(m_unsent_map_edit_queue.size() != 0)
 		{
-			MapEditEvent* event = m_unsent_map_edit_queue.pop_front();
+			MapEditEvent* event = m_unsent_map_edit_queue.front();
+			m_unsent_map_edit_queue.pop();
 
 			// Players far away from the change are stored here.
 			// Instead of sending the changes, MapBlocks are set not sent
 			// for them.
-			std::list<u16> far_players;
+			std::vector<u16> far_players;
 
-			if(event->type == MEET_ADDNODE || event->type == MEET_SWAPNODE)
-			{
-				//infostream<<"Server: MEET_ADDNODE"<<std::endl;
+			switch (event->type) {
+			case MEET_ADDNODE:
+			case MEET_SWAPNODE:
 				prof.add("MEET_ADDNODE", 1);
-				if(disable_single_change_sending)
-					sendAddNode(event->p, event->n, event->already_known_by_peer,
-							&far_players, 5, event->type == MEET_ADDNODE);
-				else
-					sendAddNode(event->p, event->n, event->already_known_by_peer,
-							&far_players, 30, event->type == MEET_ADDNODE);
-			}
-			else if(event->type == MEET_REMOVENODE)
-			{
-				//infostream<<"Server: MEET_REMOVENODE"<<std::endl;
+				sendAddNode(event->p, event->n, event->already_known_by_peer,
+						&far_players, disable_single_change_sending ? 5 : 30,
+						event->type == MEET_ADDNODE);
+				break;
+			case MEET_REMOVENODE:
 				prof.add("MEET_REMOVENODE", 1);
-				if(disable_single_change_sending)
-					sendRemoveNode(event->p, event->already_known_by_peer,
-							&far_players, 5);
-				else
-					sendRemoveNode(event->p, event->already_known_by_peer,
-							&far_players, 30);
-			}
-			else if(event->type == MEET_BLOCK_NODE_METADATA_CHANGED)
-			{
-				infostream<<"Server: MEET_BLOCK_NODE_METADATA_CHANGED"<<std::endl;
-				prof.add("MEET_BLOCK_NODE_METADATA_CHANGED", 1);
-				setBlockNotSent(event->p);
-			}
-			else if(event->type == MEET_OTHER)
-			{
-				infostream<<"Server: MEET_OTHER"<<std::endl;
+				sendRemoveNode(event->p, event->already_known_by_peer,
+						&far_players, disable_single_change_sending ? 5 : 30);
+				break;
+			case MEET_BLOCK_NODE_METADATA_CHANGED:
+				infostream << "Server: MEET_BLOCK_NODE_METADATA_CHANGED" << std::endl;
+						prof.add("MEET_BLOCK_NODE_METADATA_CHANGED", 1);
+						setBlockNotSent(event->p);
+				break;
+			case MEET_OTHER:
+				infostream << "Server: MEET_OTHER" << std::endl;
 				prof.add("MEET_OTHER", 1);
 				for(std::set<v3s16>::iterator
 						i = event->modified_blocks.begin();
-						i != event->modified_blocks.end(); ++i)
-				{
+						i != event->modified_blocks.end(); ++i) {
 					setBlockNotSent(*i);
 				}
-			}
-			else
-			{
+				break;
+			default:
 				prof.add("unknown", 1);
-				infostream<<"WARNING: Server: Unknown MapEditEvent "
-						<<((u32)event->type)<<std::endl;
+				warningstream << "Server: Unknown MapEditEvent "
+						<< ((u32)event->type) << std::endl;
+				break;
 			}
 
 			/*
 				Set blocks not sent to far players
 			*/
-			if(far_players.size() > 0)
-			{
+			if(!far_players.empty()) {
 				// Convert list format to that wanted by SetBlocksNotSent
 				std::map<v3s16, MapBlock*> modified_blocks2;
 				for(std::set<v3s16>::iterator
 						i = event->modified_blocks.begin();
-						i != event->modified_blocks.end(); ++i)
-				{
+						i != event->modified_blocks.end(); ++i) {
 					modified_blocks2[*i] =
 							m_env->getMap().getBlockNoCreateNoEx(*i);
 				}
+
 				// Set blocks not sent
-				for(std::list<u16>::iterator
+				for(std::vector<u16>::iterator
 						i = far_players.begin();
-						i != far_players.end(); ++i)
-				{
-					u16 peer_id = *i;
-					RemoteClient *client = getClient(peer_id);
-					if(client==NULL)
-						continue;
-					client->SetBlocksNotSent(modified_blocks2);
+						i != far_players.end(); ++i) {
+					if(RemoteClient *client = getClient(*i))
+						client->SetBlocksNotSent(modified_blocks2);
 				}
 			}
 
@@ -1096,10 +988,6 @@ void Server::AsyncRunStep(bool initial_step)
 			counter = 0.0;
 
 			m_emerge->startThreads();
-
-			// Update m_enable_rollback_recording here too
-			m_enable_rollback_recording =
-					g_settings->getBool("enable_rollback_recording");
 		}
 	}
 
@@ -1110,7 +998,7 @@ void Server::AsyncRunStep(bool initial_step)
 		if(counter >= g_settings->getFloat("server_map_save_interval"))
 		{
 			counter = 0.0;
-			JMutexAutoLock lock(m_env_mutex);
+			MutexAutoLock lock(m_env_mutex);
 
 			ScopeProfiler sp(g_profiler, "Server: saving stuff");
 
@@ -1133,16 +1021,16 @@ void Server::AsyncRunStep(bool initial_step)
 
 void Server::Receive()
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 	SharedBuffer<u8> data;
 	u16 peer_id;
-	u32 datasize;
-	try{
-		datasize = m_con.Receive(peer_id,data);
-		ProcessData(*data, datasize, peer_id);
+	try {
+		NetworkPacket pkt;
+		m_con.Receive(&pkt);
+		peer_id = pkt.getPeerId();
+		ProcessData(&pkt);
 	}
-	catch(con::InvalidIncomingDataException &e)
-	{
+	catch(con::InvalidIncomingDataException &e) {
 		infostream<<"Server::Receive(): "
 				"InvalidIncomingDataException: what()="
 				<<e.what()<<std::endl;
@@ -1152,14 +1040,12 @@ void Server::Receive()
 				"SerializationError: what()="
 				<<e.what()<<std::endl;
 	}
-	catch(ClientStateError &e)
-	{
+	catch(ClientStateError &e) {
 		errorstream << "ProcessData: peer=" << peer_id  << e.what() << std::endl;
-		DenyAccess(peer_id, L"Your client sent something server didn't expect."
+		DenyAccess_Legacy(peer_id, L"Your client sent something server didn't expect."
 				L"Try reconnecting or updating your client");
 	}
-	catch(con::PeerNotFoundException &e)
-	{
+	catch(con::PeerNotFoundException &e) {
 		// Do nothing
 	}
 }
@@ -1168,35 +1054,34 @@ PlayerSAO* Server::StageTwoClientInit(u16 peer_id)
 {
 	std::string playername = "";
 	PlayerSAO *playersao = NULL;
-	m_clients.Lock();
+	m_clients.lock();
 	try {
 		RemoteClient* client = m_clients.lockedGetClientNoEx(peer_id, CS_InitDone);
 		if (client != NULL) {
 			playername = client->getName();
-			playersao = emergePlayer(playername.c_str(), peer_id);
+			playersao = emergePlayer(playername.c_str(), peer_id, client->net_proto_version);
 		}
 	} catch (std::exception &e) {
-		m_clients.Unlock();
+		m_clients.unlock();
 		throw;
 	}
-	m_clients.Unlock();
+	m_clients.unlock();
 
 	RemotePlayer *player =
 		static_cast<RemotePlayer*>(m_env->getPlayer(playername.c_str()));
 
 	// If failed, cancel
-	if((playersao == NULL) || (player == NULL))
-	{
-		if(player && player->peer_id != 0){
-			errorstream<<"Server: "<<playername<<": Failed to emerge player"
-					<<" (player allocated to an another client)"<<std::endl;
-			DenyAccess(peer_id, L"Another client is connected with this "
+	if ((playersao == NULL) || (player == NULL)) {
+		if (player && player->peer_id != 0) {
+			actionstream << "Server: Failed to emerge player \"" << playername
+					<< "\" (player allocated to an another client)" << std::endl;
+			DenyAccess_Legacy(peer_id, L"Another client is connected with this "
 					L"name. If your client closed unexpectedly, try again in "
 					L"a minute.");
 		} else {
-			errorstream<<"Server: "<<playername<<": Failed to emerge player"
-					<<std::endl;
-			DenyAccess(peer_id, L"Could not allocate player.");
+			errorstream << "Server: " << playername << ": Failed to emerge player"
+					<< std::endl;
+			DenyAccess_Legacy(peer_id, L"Could not allocate player.");
 		}
 		return NULL;
 	}
@@ -1213,23 +1098,20 @@ PlayerSAO* Server::StageTwoClientInit(u16 peer_id)
 	SendPlayerInventoryFormspec(peer_id);
 
 	// Send inventory
-	UpdateCrafting(peer_id);
-	SendInventory(peer_id);
+	SendInventory(playersao);
 
 	// Send HP
-	if(g_settings->getBool("enable_damage"))
-		SendPlayerHP(peer_id);
+	SendPlayerHPOrDie(playersao);
 
 	// Send Breath
 	SendPlayerBreath(peer_id);
 
 	// Show death screen if necessary
-	if(player->hp == 0)
+	if(player->isDead())
 		SendDeathscreen(peer_id, false, v3f(0,0,0));
 
 	// Note things in chat if not in simple singleplayer mode
-	if(!m_simple_singleplayer_mode)
-	{
+	if(!m_simple_singleplayer_mode) {
 		// Send information about server to player in chat
 		SendChatMessage(peer_id, getStatusString());
 
@@ -1259,8 +1141,7 @@ PlayerSAO* Server::StageTwoClientInit(u16 peer_id)
 		actionstream<<player->getName() <<" joins game. List of players: ";
 
 		for (std::vector<std::string>::iterator i = names.begin();
-				i != names.end(); i++)
-		{
+				i != names.end(); ++i) {
 			actionstream << *i << " ";
 		}
 
@@ -1269,1548 +1150,173 @@ PlayerSAO* Server::StageTwoClientInit(u16 peer_id)
 	return playersao;
 }
 
-void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id)
+inline void Server::handleCommand(NetworkPacket* pkt)
+{
+	const ToServerCommandHandler& opHandle = toServerCommandTable[pkt->getCommand()];
+	(this->*opHandle.handler)(pkt);
+}
+
+void Server::ProcessData(NetworkPacket *pkt)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 	// Environment is locked first.
-	JMutexAutoLock envlock(m_env_mutex);
+	MutexAutoLock envlock(m_env_mutex);
 
 	ScopeProfiler sp(g_profiler, "Server::ProcessData");
+	u32 peer_id = pkt->getPeerId();
 
-	std::string addr_s;
-	try{
+	try {
 		Address address = getPeerAddress(peer_id);
-		addr_s = address.serializeString();
+		std::string addr_s = address.serializeString();
 
-		// drop player if is ip is banned
-		if(m_banmanager->isIpBanned(addr_s)){
+		if(m_banmanager->isIpBanned(addr_s)) {
 			std::string ban_name = m_banmanager->getBanName(addr_s);
-			infostream<<"Server: A banned client tried to connect from "
-					<<addr_s<<"; banned name was "
-					<<ban_name<<std::endl;
+			infostream << "Server: A banned client tried to connect from "
+					<< addr_s << "; banned name was "
+					<< ban_name << std::endl;
 			// This actually doesn't seem to transfer to the client
-			DenyAccess(peer_id, L"Your ip is banned. Banned name was "
-					+narrow_to_wide(ban_name));
+			DenyAccess_Legacy(peer_id, L"Your ip is banned. Banned name was "
+					+ utf8_to_wide(ban_name));
 			return;
 		}
 	}
-	catch(con::PeerNotFoundException &e)
-	{
+	catch(con::PeerNotFoundException &e) {
 		/*
 		 * no peer for this packet found
 		 * most common reason is peer timeout, e.g. peer didn't
 		 * respond for some time, your server was overloaded or
 		 * things like that.
 		 */
-		infostream<<"Server::ProcessData(): Cancelling: peer "
-				<<peer_id<<" not found"<<std::endl;
+		infostream << "Server::ProcessData(): Canceling: peer "
+				<< peer_id << " not found" << std::endl;
 		return;
 	}
 
-	try
-	{
-
-	if(datasize < 2)
-		return;
-
-	ToServerCommand command = (ToServerCommand)readU16(&data[0]);
-
-	if(command == TOSERVER_INIT)
-	{
-		// [0] u16 TOSERVER_INIT
-		// [2] u8 SER_FMT_VER_HIGHEST_READ
-		// [3] u8[20] player_name
-		// [23] u8[28] password <--- can be sent without this, from old versions
+	try {
+		ToServerCommand command = (ToServerCommand) pkt->getCommand();
 
-		if(datasize < 2+1+PLAYERNAME_SIZE)
+		// Command must be handled into ToServerCommandHandler
+		if (command >= TOSERVER_NUM_MSG_TYPES) {
+			infostream << "Server: Ignoring unknown command "
+					 << command << std::endl;
 			return;
+		}
 
-		RemoteClient* client = getClient(peer_id, CS_Created);
-
-		// If net_proto_version is set, this client has already been handled
-		if(client->getState() > CS_Created)
-		{
-			verbosestream<<"Server: Ignoring multiple TOSERVER_INITs from "
-					<<addr_s<<" (peer_id="<<peer_id<<")"<<std::endl;
+		if (toServerCommandTable[command].state == TOSERVER_STATE_NOT_CONNECTED) {
+			handleCommand(pkt);
 			return;
 		}
 
-		verbosestream<<"Server: Got TOSERVER_INIT from "<<addr_s<<" (peer_id="
-				<<peer_id<<")"<<std::endl;
+		u8 peer_ser_ver = getClient(peer_id, CS_InitDone)->serialization_version;
 
-		// Do not allow multiple players in simple singleplayer mode.
-		// This isn't a perfect way to do it, but will suffice for now
-		if(m_simple_singleplayer_mode && m_clients.getClientIDs().size() > 1){
-			infostream<<"Server: Not allowing another client ("<<addr_s
-					<<") to connect in simple singleplayer mode"<<std::endl;
-			DenyAccess(peer_id, L"Running in simple singleplayer mode.");
+		if(peer_ser_ver == SER_FMT_VER_INVALID) {
+			errorstream << "Server::ProcessData(): Cancelling: Peer"
+					" serialization format invalid or not initialized."
+					" Skipping incoming command=" << command << std::endl;
 			return;
 		}
 
-		// First byte after command is maximum supported
-		// serialization version
-		u8 client_max = data[2];
-		u8 our_max = SER_FMT_VER_HIGHEST_READ;
-		// Use the highest version supported by both
-		u8 deployed = std::min(client_max, our_max);
-		// If it's lower than the lowest supported, give up.
-		if(deployed < SER_FMT_VER_LOWEST)
-			deployed = SER_FMT_VER_INVALID;
-
-		if(deployed == SER_FMT_VER_INVALID)
-		{
-			actionstream<<"Server: A mismatched client tried to connect from "
-					<<addr_s<<std::endl;
-			infostream<<"Server: Cannot negotiate serialization version with "
-					<<addr_s<<std::endl;
-			DenyAccess(peer_id, std::wstring(
-					L"Your client's version is not supported.\n"
-					L"Server version is ")
-					+ narrow_to_wide(minetest_version_simple) + L"."
-			);
+		/* Handle commands related to client startup */
+		if (toServerCommandTable[command].state == TOSERVER_STATE_STARTUP) {
+			handleCommand(pkt);
 			return;
 		}
 
-		client->setPendingSerializationVersion(deployed);
-
-		/*
-			Read and check network protocol version
-		*/
-
-		u16 min_net_proto_version = 0;
-		if(datasize >= 2+1+PLAYERNAME_SIZE+PASSWORD_SIZE+2)
-			min_net_proto_version = readU16(&data[2+1+PLAYERNAME_SIZE+PASSWORD_SIZE]);
-
-		// Use same version as minimum and maximum if maximum version field
-		// doesn't exist (backwards compatibility)
-		u16 max_net_proto_version = min_net_proto_version;
-		if(datasize >= 2+1+PLAYERNAME_SIZE+PASSWORD_SIZE+2+2)
-			max_net_proto_version = readU16(&data[2+1+PLAYERNAME_SIZE+PASSWORD_SIZE+2]);
-
-		// Start with client's maximum version
-		u16 net_proto_version = max_net_proto_version;
-
-		// Figure out a working version if it is possible at all
-		if(max_net_proto_version >= SERVER_PROTOCOL_VERSION_MIN ||
-				min_net_proto_version <= SERVER_PROTOCOL_VERSION_MAX)
-		{
-			// If maximum is larger than our maximum, go with our maximum
-			if(max_net_proto_version > SERVER_PROTOCOL_VERSION_MAX)
-				net_proto_version = SERVER_PROTOCOL_VERSION_MAX;
-			// Else go with client's maximum
-			else
-				net_proto_version = max_net_proto_version;
-		}
-
-		verbosestream<<"Server: "<<addr_s<<": Protocol version: min: "
-				<<min_net_proto_version<<", max: "<<max_net_proto_version
-				<<", chosen: "<<net_proto_version<<std::endl;
+		if (m_clients.getClientState(peer_id) < CS_Active) {
+			if (command == TOSERVER_PLAYERPOS) return;
 
-		client->net_proto_version = net_proto_version;
-
-		if(net_proto_version < SERVER_PROTOCOL_VERSION_MIN ||
-				net_proto_version > SERVER_PROTOCOL_VERSION_MAX)
-		{
-			actionstream<<"Server: A mismatched client tried to connect from "
-					<<addr_s<<std::endl;
-			DenyAccess(peer_id, std::wstring(
-					L"Your client's version is not supported.\n"
-					L"Server version is ")
-					+ narrow_to_wide(minetest_version_simple) + L",\n"
-					+ L"server's PROTOCOL_VERSION is "
-					+ narrow_to_wide(itos(SERVER_PROTOCOL_VERSION_MIN))
-					+ L"..."
-					+ narrow_to_wide(itos(SERVER_PROTOCOL_VERSION_MAX))
-					+ L", client's PROTOCOL_VERSION is "
-					+ narrow_to_wide(itos(min_net_proto_version))
-					+ L"..."
-					+ narrow_to_wide(itos(max_net_proto_version))
-			);
+			errorstream << "Got packet command: " << command << " for peer id "
+					<< peer_id << " but client isn't active yet. Dropping packet "
+					<< std::endl;
 			return;
 		}
 
-		if(g_settings->getBool("strict_protocol_version_checking"))
-		{
-			if(net_proto_version != LATEST_PROTOCOL_VERSION)
-			{
-				actionstream<<"Server: A mismatched (strict) client tried to "
-						<<"connect from "<<addr_s<<std::endl;
-				DenyAccess(peer_id, std::wstring(
-						L"Your client's version is not supported.\n"
-						L"Server version is ")
-						+ narrow_to_wide(minetest_version_simple) + L",\n"
-						+ L"server's PROTOCOL_VERSION (strict) is "
-						+ narrow_to_wide(itos(LATEST_PROTOCOL_VERSION))
-						+ L", client's PROTOCOL_VERSION is "
-						+ narrow_to_wide(itos(min_net_proto_version))
-						+ L"..."
-						+ narrow_to_wide(itos(max_net_proto_version))
-				);
-				return;
-			}
-		}
-
-		/*
-			Set up player
-		*/
-		char playername[PLAYERNAME_SIZE];
-		unsigned int playername_length = 0;
-		for (; playername_length < PLAYERNAME_SIZE; playername_length++ ) {
-			playername[playername_length] = data[3+playername_length];
-			if (data[3+playername_length] == 0)
-				break;
-		}
+		handleCommand(pkt);
+	} catch (SendFailedException &e) {
+		errorstream << "Server::ProcessData(): SendFailedException: "
+				<< "what=" << e.what()
+				<< std::endl;
+	} catch (PacketError &e) {
+		actionstream << "Server::ProcessData(): PacketError: "
+				<< "what=" << e.what()
+				<< std::endl;
+	}
+}
 
-		if (playername_length == PLAYERNAME_SIZE) {
-			actionstream<<"Server: Player with name exceeding max length "
-					<<"tried to connect from "<<addr_s<<std::endl;
-			DenyAccess(peer_id, L"Name too long");
-			return;
-		}
+void Server::setTimeOfDay(u32 time)
+{
+	m_env->setTimeOfDay(time);
+	m_time_of_day_send_timer = 0;
+}
 
+void Server::onMapEditEvent(MapEditEvent *event)
+{
+	if(m_ignore_map_edit_events)
+		return;
+	if(m_ignore_map_edit_events_area.contains(event->getArea()))
+		return;
+	MapEditEvent *e = event->clone();
+	m_unsent_map_edit_queue.push(e);
+}
 
-		if(playername[0]=='\0')
-		{
-			actionstream<<"Server: Player with an empty name "
-					<<"tried to connect from "<<addr_s<<std::endl;
-			DenyAccess(peer_id, L"Empty name");
+Inventory* Server::getInventory(const InventoryLocation &loc)
+{
+	switch (loc.type) {
+	case InventoryLocation::UNDEFINED:
+	case InventoryLocation::CURRENT_PLAYER:
+		break;
+	case InventoryLocation::PLAYER:
+	{
+		Player *player = m_env->getPlayer(loc.name.c_str());
+		if(!player)
+			return NULL;
+		PlayerSAO *playersao = player->getPlayerSAO();
+		if(!playersao)
+			return NULL;
+		return playersao->getInventory();
+	}
+		break;
+	case InventoryLocation::NODEMETA:
+	{
+		NodeMetadata *meta = m_env->getMap().getNodeMetadata(loc.p);
+		if(!meta)
+			return NULL;
+		return meta->getInventory();
+	}
+		break;
+	case InventoryLocation::DETACHED:
+	{
+		if(m_detached_inventories.count(loc.name) == 0)
+			return NULL;
+		return m_detached_inventories[loc.name];
+	}
+		break;
+	default:
+		sanity_check(false); // abort
+		break;
+	}
+	return NULL;
+}
+void Server::setInventoryModified(const InventoryLocation &loc, bool playerSend)
+{
+	switch(loc.type){
+	case InventoryLocation::UNDEFINED:
+		break;
+	case InventoryLocation::PLAYER:
+	{
+		if (!playerSend)
 			return;
-		}
 
-		if(string_allowed(playername, PLAYERNAME_ALLOWED_CHARS)==false)
-		{
-			actionstream<<"Server: Player with an invalid name "
-					<<"tried to connect from "<<addr_s<<std::endl;
-			DenyAccess(peer_id, L"Name contains unallowed characters");
-			return;
-		}
-
-		if(!isSingleplayer() && strcasecmp(playername, "singleplayer") == 0)
-		{
-			actionstream<<"Server: Player with the name \"singleplayer\" "
-					<<"tried to connect from "<<addr_s<<std::endl;
-			DenyAccess(peer_id, L"Name is not allowed");
-			return;
-		}
-
-		{
-			std::string reason;
-			if(m_script->on_prejoinplayer(playername, addr_s, reason))
-			{
-				actionstream<<"Server: Player with the name \""<<playername<<"\" "
-						<<"tried to connect from "<<addr_s<<" "
-						<<"but it was disallowed for the following reason: "
-						<<reason<<std::endl;
-				DenyAccess(peer_id, narrow_to_wide(reason.c_str()));
-				return;
-			}
-		}
-
-		infostream<<"Server: New connection: \""<<playername<<"\" from "
-				<<addr_s<<" (peer_id="<<peer_id<<")"<<std::endl;
-
-		// Get password
-		char given_password[PASSWORD_SIZE];
-		if(datasize < 2+1+PLAYERNAME_SIZE+PASSWORD_SIZE)
-		{
-			// old version - assume blank password
-			given_password[0] = 0;
-		}
-		else
-		{
-			for(u32 i=0; i<PASSWORD_SIZE-1; i++)
-			{
-				given_password[i] = data[23+i];
-			}
-			given_password[PASSWORD_SIZE-1] = 0;
-		}
-
-		if(!base64_is_valid(given_password)){
-			actionstream<<"Server: "<<playername
-					<<" supplied invalid password hash"<<std::endl;
-			DenyAccess(peer_id, L"Invalid password hash");
-			return;
-		}
-
-		// Enforce user limit.
-		// Don't enforce for users that have some admin right
-		if(m_clients.getClientIDs(CS_Created).size() >= g_settings->getU16("max_users") &&
-				!checkPriv(playername, "server") &&
-				!checkPriv(playername, "ban") &&
-				!checkPriv(playername, "privs") &&
-				!checkPriv(playername, "password") &&
-				playername != g_settings->get("name"))
-		{
-			actionstream<<"Server: "<<playername<<" tried to join, but there"
-					<<" are already max_users="
-					<<g_settings->getU16("max_users")<<" players."<<std::endl;
-			DenyAccess(peer_id, L"Too many users.");
-			return;
-		}
-
-		std::string checkpwd; // Password hash to check against
-		bool has_auth = m_script->getAuth(playername, &checkpwd, NULL);
-
-		// If no authentication info exists for user, create it
-		if(!has_auth){
-			if(!isSingleplayer() &&
-					g_settings->getBool("disallow_empty_password") &&
-					std::string(given_password) == ""){
-				actionstream<<"Server: "<<playername
-						<<" supplied empty password"<<std::endl;
-				DenyAccess(peer_id, L"Empty passwords are "
-						L"disallowed. Set a password and try again.");
-				return;
-			}
-			std::wstring raw_default_password =
-				narrow_to_wide(g_settings->get("default_password"));
-			std::string initial_password =
-				translatePassword(playername, raw_default_password);
-
-			// If default_password is empty, allow any initial password
-			if (raw_default_password.length() == 0)
-				initial_password = given_password;
-
-			m_script->createAuth(playername, initial_password);
-		}
-
-		has_auth = m_script->getAuth(playername, &checkpwd, NULL);
-
-		if(!has_auth){
-			actionstream<<"Server: "<<playername<<" cannot be authenticated"
-					<<" (auth handler does not work?)"<<std::endl;
-			DenyAccess(peer_id, L"Not allowed to login");
-			return;
-		}
-
-		if(given_password != checkpwd){
-			actionstream<<"Server: "<<playername<<" supplied wrong password"
-					<<std::endl;
-			DenyAccess(peer_id, L"Wrong password");
-			return;
-		}
-
-		RemotePlayer *player =
-				static_cast<RemotePlayer*>(m_env->getPlayer(playername));
-
-		if(player && player->peer_id != 0){
-			errorstream<<"Server: "<<playername<<": Failed to emerge player"
-					<<" (player allocated to an another client)"<<std::endl;
-			DenyAccess(peer_id, L"Another client is connected with this "
-					L"name. If your client closed unexpectedly, try again in "
-					L"a minute.");
-		}
-
-		m_clients.setPlayerName(peer_id,playername);
-
-		/*
-			Answer with a TOCLIENT_INIT
-		*/
-		{
-			SharedBuffer<u8> reply(2+1+6+8+4);
-			writeU16(&reply[0], TOCLIENT_INIT);
-			writeU8(&reply[2], deployed);
-			//send dummy pos for legacy reasons only
-			writeV3S16(&reply[2+1], floatToInt(v3f(0,0,0), BS));
-			writeU64(&reply[2+1+6], m_env->getServerMap().getSeed());
-			writeF1000(&reply[2+1+6+8], g_settings->getFloat("dedicated_server_step"));
-
-			// Send as reliable
-			m_clients.send(peer_id, 0, reply, true);
-			m_clients.event(peer_id, CSE_Init);
-		}
-
-		return;
-	}
-
-	if(command == TOSERVER_INIT2)
-	{
-
-		verbosestream<<"Server: Got TOSERVER_INIT2 from "
-				<<peer_id<<std::endl;
-
-		m_clients.event(peer_id, CSE_GotInit2);
-		u16 protocol_version = m_clients.getProtocolVersion(peer_id);
-
-
-		///// begin compatibility code
-		PlayerSAO* playersao = NULL;
-		if (protocol_version <= 22) {
-			playersao = StageTwoClientInit(peer_id);
-
-			if (playersao == NULL) {
-				errorstream
-					<< "TOSERVER_INIT2 stage 2 client init failed for peer "
-					<< peer_id << std::endl;
-				return;
-			}
-		}
-		///// end compatibility code
-
-		/*
-			Send some initialization data
-		*/
-
-		infostream<<"Server: Sending content to "
-				<<getPlayerName(peer_id)<<std::endl;
-
-		// Send player movement settings
-		SendMovement(peer_id);
-
-		// Send item definitions
-		SendItemDef(peer_id, m_itemdef, protocol_version);
-
-		// Send node definitions
-		SendNodeDef(peer_id, m_nodedef, protocol_version);
-
-		m_clients.event(peer_id, CSE_SetDefinitionsSent);
-
-		// Send media announcement
-		sendMediaAnnouncement(peer_id);
-
-		// Send detached inventories
-		sendDetachedInventories(peer_id);
-
-		// Send time of day
-		u16 time = m_env->getTimeOfDay();
-		float time_speed = g_settings->getFloat("time_speed");
-		SendTimeOfDay(peer_id, time, time_speed);
-
-		///// begin compatibility code
-		if (protocol_version <= 22) {
-			m_clients.event(peer_id, CSE_SetClientReady);
-			m_script->on_joinplayer(playersao);
-		}
-		///// end compatibility code
-
-		// Warnings about protocol version can be issued here
-		if(getClient(peer_id)->net_proto_version < LATEST_PROTOCOL_VERSION)
-		{
-			SendChatMessage(peer_id, L"# Server: WARNING: YOUR CLIENT'S "
-					L"VERSION MAY NOT BE FULLY COMPATIBLE WITH THIS SERVER!");
-		}
-
-		return;
-	}
-
-	u8 peer_ser_ver = getClient(peer_id, CS_InitDone)->serialization_version;
-	u16 peer_proto_ver = getClient(peer_id, CS_InitDone)->net_proto_version;
-
-	if(peer_ser_ver == SER_FMT_VER_INVALID)
-	{
-		errorstream<<"Server::ProcessData(): Cancelling: Peer"
-				" serialization format invalid or not initialized."
-				" Skipping incoming command="<<command<<std::endl;
-		return;
-	}
-
-	/* Handle commands relate to client startup */
-	if(command == TOSERVER_REQUEST_MEDIA) {
-		std::string datastring((char*)&data[2], datasize-2);
-		std::istringstream is(datastring, std::ios_base::binary);
-
-		std::list<std::string> tosend;
-		u16 numfiles = readU16(is);
-
-		infostream<<"Sending "<<numfiles<<" files to "
-				<<getPlayerName(peer_id)<<std::endl;
-		verbosestream<<"TOSERVER_REQUEST_MEDIA: "<<std::endl;
-
-		for(int i = 0; i < numfiles; i++) {
-			std::string name = deSerializeString(is);
-			tosend.push_back(name);
-			verbosestream<<"TOSERVER_REQUEST_MEDIA: requested file "
-					<<name<<std::endl;
-		}
-
-		sendRequestedMedia(peer_id, tosend);
-		return;
-	}
-	else if(command == TOSERVER_RECEIVED_MEDIA) {
-		return;
-	}
-	else if(command == TOSERVER_CLIENT_READY) {
-		// clients <= protocol version 22 did not send ready message,
-		// they're already initialized
-		if (peer_proto_ver <= 22) {
-			infostream << "Client sent message not expected by a "
-				<< "client using protocol version <= 22,"
-				<< "disconnecing peer_id: " << peer_id << std::endl;
-			m_con.DisconnectPeer(peer_id);
-			return;
-		}
-
-		PlayerSAO* playersao = StageTwoClientInit(peer_id);
-
-		if (playersao == NULL) {
-			errorstream
-				<< "TOSERVER_CLIENT_READY stage 2 client init failed for peer_id: "
-				<< peer_id << std::endl;
-			m_con.DisconnectPeer(peer_id);
-			return;
-		}
-
-
-		if(datasize < 2+8) {
-			errorstream
-				<< "TOSERVER_CLIENT_READY client sent inconsistent data, disconnecting peer_id: "
-				<< peer_id << std::endl;
-			m_con.DisconnectPeer(peer_id);
-			return;
-		}
-
-		m_clients.setClientVersion(
-				peer_id,
-				data[2], data[3], data[4],
-				std::string((char*) &data[8],(u16) data[6]));
-
-		m_clients.event(peer_id, CSE_SetClientReady);
-		m_script->on_joinplayer(playersao);
-
-	}
-	else if(command == TOSERVER_GOTBLOCKS)
-	{
-		if(datasize < 2+1)
-			return;
-
-		/*
-			[0] u16 command
-			[2] u8 count
-			[3] v3s16 pos_0
-			[3+6] v3s16 pos_1
-			...
-		*/
-
-		u16 count = data[2];
-		for(u16 i=0; i<count; i++)
-		{
-			if((s16)datasize < 2+1+(i+1)*6)
-				throw con::InvalidIncomingDataException
-					("GOTBLOCKS length is too short");
-			v3s16 p = readV3S16(&data[2+1+i*6]);
-			/*infostream<<"Server: GOTBLOCKS ("
-					<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
-			RemoteClient *client = getClient(peer_id);
-			client->GotBlock(p);
-		}
-		return;
-	}
-
-	if (m_clients.getClientState(peer_id) < CS_Active)
-	{
-		if (command == TOSERVER_PLAYERPOS) return;
-
-		errorstream<<"Got packet command: " << command << " for peer id "
-				<< peer_id << " but client isn't active yet. Dropping packet "
-				<<std::endl;
-		return;
-	}
-
-	Player *player = m_env->getPlayer(peer_id);
-	if(player == NULL) {
-		errorstream<<"Server::ProcessData(): Cancelling: "
-				"No player for peer_id="<<peer_id
-				<< " disconnecting peer!" <<std::endl;
-		m_con.DisconnectPeer(peer_id);
-		return;
-	}
-
-	PlayerSAO *playersao = player->getPlayerSAO();
-	if(playersao == NULL) {
-		errorstream<<"Server::ProcessData(): Cancelling: "
-				"No player object for peer_id="<<peer_id
-				<< " disconnecting peer!" <<std::endl;
-		m_con.DisconnectPeer(peer_id);
-		return;
-	}
-
-	if(command == TOSERVER_PLAYERPOS)
-	{
-		if(datasize < 2+12+12+4+4)
-			return;
-
-		u32 start = 0;
-		v3s32 ps = readV3S32(&data[start+2]);
-		v3s32 ss = readV3S32(&data[start+2+12]);
-		f32 pitch = (f32)readS32(&data[2+12+12]) / 100.0;
-		f32 yaw = (f32)readS32(&data[2+12+12+4]) / 100.0;
-		u32 keyPressed = 0;
-		if(datasize >= 2+12+12+4+4+4)
-			keyPressed = (u32)readU32(&data[2+12+12+4+4]);
-		v3f position((f32)ps.X/100., (f32)ps.Y/100., (f32)ps.Z/100.);
-		v3f speed((f32)ss.X/100., (f32)ss.Y/100., (f32)ss.Z/100.);
-		pitch = wrapDegrees(pitch);
-		yaw = wrapDegrees(yaw);
-
-		player->setPosition(position);
-		player->setSpeed(speed);
-		player->setPitch(pitch);
-		player->setYaw(yaw);
-		player->keyPressed=keyPressed;
-		player->control.up = (bool)(keyPressed&1);
-		player->control.down = (bool)(keyPressed&2);
-		player->control.left = (bool)(keyPressed&4);
-		player->control.right = (bool)(keyPressed&8);
-		player->control.jump = (bool)(keyPressed&16);
-		player->control.aux1 = (bool)(keyPressed&32);
-		player->control.sneak = (bool)(keyPressed&64);
-		player->control.LMB = (bool)(keyPressed&128);
-		player->control.RMB = (bool)(keyPressed&256);
-
-		bool cheated = playersao->checkMovementCheat();
-		if(cheated){
-			// Call callbacks
-			m_script->on_cheat(playersao, "moved_too_fast");
-		}
-
-		/*infostream<<"Server::ProcessData(): Moved player "<<peer_id<<" to "
-				<<"("<<position.X<<","<<position.Y<<","<<position.Z<<")"
-				<<" pitch="<<pitch<<" yaw="<<yaw<<std::endl;*/
-	}
-	else if(command == TOSERVER_DELETEDBLOCKS)
-	{
-		if(datasize < 2+1)
-			return;
-
-		/*
-			[0] u16 command
-			[2] u8 count
-			[3] v3s16 pos_0
-			[3+6] v3s16 pos_1
-			...
-		*/
-
-		u16 count = data[2];
-		for(u16 i=0; i<count; i++)
-		{
-			if((s16)datasize < 2+1+(i+1)*6)
-				throw con::InvalidIncomingDataException
-					("DELETEDBLOCKS length is too short");
-			v3s16 p = readV3S16(&data[2+1+i*6]);
-			/*infostream<<"Server: DELETEDBLOCKS ("
-					<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
-			RemoteClient *client = getClient(peer_id);
-			client->SetBlockNotSent(p);
-		}
-	}
-	else if(command == TOSERVER_CLICK_OBJECT)
-	{
-		infostream<<"Server: CLICK_OBJECT not supported anymore"<<std::endl;
-		return;
-	}
-	else if(command == TOSERVER_CLICK_ACTIVEOBJECT)
-	{
-		infostream<<"Server: CLICK_ACTIVEOBJECT not supported anymore"<<std::endl;
-		return;
-	}
-	else if(command == TOSERVER_GROUND_ACTION)
-	{
-		infostream<<"Server: GROUND_ACTION not supported anymore"<<std::endl;
-		return;
-
-	}
-	else if(command == TOSERVER_RELEASE)
-	{
-		infostream<<"Server: RELEASE not supported anymore"<<std::endl;
-		return;
-	}
-	else if(command == TOSERVER_SIGNTEXT)
-	{
-		infostream<<"Server: SIGNTEXT not supported anymore"
-				<<std::endl;
-		return;
-	}
-	else if(command == TOSERVER_SIGNNODETEXT)
-	{
-		infostream<<"Server: SIGNNODETEXT not supported anymore"
-				<<std::endl;
-		return;
-	}
-	else if(command == TOSERVER_INVENTORY_ACTION)
-	{
-		// Strip command and create a stream
-		std::string datastring((char*)&data[2], datasize-2);
-		verbosestream<<"TOSERVER_INVENTORY_ACTION: data="<<datastring<<std::endl;
-		std::istringstream is(datastring, std::ios_base::binary);
-		// Create an action
-		InventoryAction *a = InventoryAction::deSerialize(is);
-		if(a == NULL)
-		{
-			infostream<<"TOSERVER_INVENTORY_ACTION: "
-					<<"InventoryAction::deSerialize() returned NULL"
-					<<std::endl;
-			return;
-		}
-
-		// If something goes wrong, this player is to blame
-		RollbackScopeActor rollback_scope(m_rollback,
-				std::string("player:")+player->getName());
-
-		/*
-			Note: Always set inventory not sent, to repair cases
-			where the client made a bad prediction.
-		*/
-
-		/*
-			Handle restrictions and special cases of the move action
-		*/
-		if(a->getType() == IACTION_MOVE)
-		{
-			IMoveAction *ma = (IMoveAction*)a;
-
-			ma->from_inv.applyCurrentPlayer(player->getName());
-			ma->to_inv.applyCurrentPlayer(player->getName());
-
-			setInventoryModified(ma->from_inv);
-			setInventoryModified(ma->to_inv);
-
-			bool from_inv_is_current_player =
-				(ma->from_inv.type == InventoryLocation::PLAYER) &&
-				(ma->from_inv.name == player->getName());
-
-			bool to_inv_is_current_player =
-				(ma->to_inv.type == InventoryLocation::PLAYER) &&
-				(ma->to_inv.name == player->getName());
-
-			/*
-				Disable moving items out of craftpreview
-			*/
-			if(ma->from_list == "craftpreview")
-			{
-				infostream<<"Ignoring IMoveAction from "
-						<<(ma->from_inv.dump())<<":"<<ma->from_list
-						<<" to "<<(ma->to_inv.dump())<<":"<<ma->to_list
-						<<" because src is "<<ma->from_list<<std::endl;
-				delete a;
-				return;
-			}
-
-			/*
-				Disable moving items into craftresult and craftpreview
-			*/
-			if(ma->to_list == "craftpreview" || ma->to_list == "craftresult")
-			{
-				infostream<<"Ignoring IMoveAction from "
-						<<(ma->from_inv.dump())<<":"<<ma->from_list
-						<<" to "<<(ma->to_inv.dump())<<":"<<ma->to_list
-						<<" because dst is "<<ma->to_list<<std::endl;
-				delete a;
-				return;
-			}
-
-			// Disallow moving items in elsewhere than player's inventory
-			// if not allowed to interact
-			if(!checkPriv(player->getName(), "interact") &&
-					(!from_inv_is_current_player ||
-					!to_inv_is_current_player))
-			{
-				infostream<<"Cannot move outside of player's inventory: "
-						<<"No interact privilege"<<std::endl;
-				delete a;
-				return;
-			}
-		}
-		/*
-			Handle restrictions and special cases of the drop action
-		*/
-		else if(a->getType() == IACTION_DROP)
-		{
-			IDropAction *da = (IDropAction*)a;
-
-			da->from_inv.applyCurrentPlayer(player->getName());
-
-			setInventoryModified(da->from_inv);
-
-			/*
-				Disable dropping items out of craftpreview
-			*/
-			if(da->from_list == "craftpreview")
-			{
-				infostream<<"Ignoring IDropAction from "
-						<<(da->from_inv.dump())<<":"<<da->from_list
-						<<" because src is "<<da->from_list<<std::endl;
-				delete a;
-				return;
-			}
-
-			// Disallow dropping items if not allowed to interact
-			if(!checkPriv(player->getName(), "interact"))
-			{
-				delete a;
-				return;
-			}
-		}
-		/*
-			Handle restrictions and special cases of the craft action
-		*/
-		else if(a->getType() == IACTION_CRAFT)
-		{
-			ICraftAction *ca = (ICraftAction*)a;
-
-			ca->craft_inv.applyCurrentPlayer(player->getName());
-
-			setInventoryModified(ca->craft_inv);
-
-			//bool craft_inv_is_current_player =
-			//	(ca->craft_inv.type == InventoryLocation::PLAYER) &&
-			//	(ca->craft_inv.name == player->getName());
-
-			// Disallow crafting if not allowed to interact
-			if(!checkPriv(player->getName(), "interact"))
-			{
-				infostream<<"Cannot craft: "
-						<<"No interact privilege"<<std::endl;
-				delete a;
-				return;
-			}
-		}
-
-		// Do the action
-		a->apply(this, playersao, this);
-		// Eat the action
-		delete a;
-	}
-	else if(command == TOSERVER_CHAT_MESSAGE)
-	{
-		/*
-			u16 command
-			u16 length
-			wstring message
-		*/
-		u8 buf[6];
-		std::string datastring((char*)&data[2], datasize-2);
-		std::istringstream is(datastring, std::ios_base::binary);
-
-		// Read stuff
-		is.read((char*)buf, 2);
-		u16 len = readU16(buf);
-
-		std::wstring message;
-		for(u16 i=0; i<len; i++)
-		{
-			is.read((char*)buf, 2);
-			message += (wchar_t)readU16(buf);
-		}
-
-		// If something goes wrong, this player is to blame
-		RollbackScopeActor rollback_scope(m_rollback,
-				std::string("player:")+player->getName());
-
-		// Get player name of this client
-		std::wstring name = narrow_to_wide(player->getName());
-
-		// Run script hook
-		bool ate = m_script->on_chat_message(player->getName(),
-				wide_to_narrow(message));
-		// If script ate the message, don't proceed
-		if(ate)
-			return;
-
-		// Line to send to players
-		std::wstring line;
-		// Whether to send to the player that sent the line
-		bool send_to_sender_only = false;
-
-		// Commands are implemented in Lua, so only catch invalid
-		// commands that were not "eaten" and send an error back
-		if(message[0] == L'/')
-		{
-			message = message.substr(1);
-			send_to_sender_only = true;
-			if(message.length() == 0)
-				line += L"-!- Empty command";
-			else
-				line += L"-!- Invalid command: " + str_split(message, L' ')[0];
-		}
-		else
-		{
-			if(checkPriv(player->getName(), "shout")){
-				line += L"<";
-				line += name;
-				line += L"> ";
-				line += message;
-			} else {
-				line += L"-!- You don't have permission to shout.";
-				send_to_sender_only = true;
-			}
-		}
-
-		if(line != L"")
-		{
-			/*
-				Send the message to sender
-			*/
-			if (send_to_sender_only)
-			{
-				SendChatMessage(peer_id, line);
-			}
-			/*
-				Send the message to others
-			*/
-			else
-			{
-				actionstream<<"CHAT: "<<wide_to_narrow(line)<<std::endl;
-
-				std::list<u16> clients = m_clients.getClientIDs();
-
-				for(std::list<u16>::iterator
-					i = clients.begin();
-					i != clients.end(); ++i)
-				{
-					if (*i != peer_id)
-						SendChatMessage(*i, line);
-				}
-			}
-		}
-	}
-	else if(command == TOSERVER_DAMAGE)
-	{
-		std::string datastring((char*)&data[2], datasize-2);
-		std::istringstream is(datastring, std::ios_base::binary);
-		u8 damage = readU8(is);
-
-		if(g_settings->getBool("enable_damage"))
-		{
-			actionstream<<player->getName()<<" damaged by "
-					<<(int)damage<<" hp at "<<PP(player->getPosition()/BS)
-					<<std::endl;
-
-			playersao->setHP(playersao->getHP() - damage);
-
-			if(playersao->getHP() == 0 && playersao->m_hp_not_sent)
-				DiePlayer(peer_id);
-
-			if(playersao->m_hp_not_sent)
-				SendPlayerHP(peer_id);
-		}
-	}
-	else if(command == TOSERVER_BREATH)
-	{
-		std::string datastring((char*)&data[2], datasize-2);
-		std::istringstream is(datastring, std::ios_base::binary);
-		u16 breath = readU16(is);
-		playersao->setBreath(breath);
-		m_script->player_event(playersao,"breath_changed");
-	}
-	else if(command == TOSERVER_PASSWORD)
-	{
-		/*
-			[0] u16 TOSERVER_PASSWORD
-			[2] u8[28] old password
-			[30] u8[28] new password
-		*/
-
-		if(datasize != 2+PASSWORD_SIZE*2)
-			return;
-		/*char password[PASSWORD_SIZE];
-		for(u32 i=0; i<PASSWORD_SIZE-1; i++)
-			password[i] = data[2+i];
-		password[PASSWORD_SIZE-1] = 0;*/
-		std::string oldpwd;
-		for(u32 i=0; i<PASSWORD_SIZE-1; i++)
-		{
-			char c = data[2+i];
-			if(c == 0)
-				break;
-			oldpwd += c;
-		}
-		std::string newpwd;
-		for(u32 i=0; i<PASSWORD_SIZE-1; i++)
-		{
-			char c = data[2+PASSWORD_SIZE+i];
-			if(c == 0)
-				break;
-			newpwd += c;
-		}
-
-		if(!base64_is_valid(newpwd)){
-			infostream<<"Server: "<<player->getName()<<" supplied invalid password hash"<<std::endl;
-			// Wrong old password supplied!!
-			SendChatMessage(peer_id, L"Invalid new password hash supplied. Password NOT changed.");
-			return;
-		}
-
-		infostream<<"Server: Client requests a password change from "
-				<<"'"<<oldpwd<<"' to '"<<newpwd<<"'"<<std::endl;
-
-		std::string playername = player->getName();
-
-		std::string checkpwd;
-		m_script->getAuth(playername, &checkpwd, NULL);
-
-		if(oldpwd != checkpwd)
-		{
-			infostream<<"Server: invalid old password"<<std::endl;
-			// Wrong old password supplied!!
-			SendChatMessage(peer_id, L"Invalid old password supplied. Password NOT changed.");
-			return;
-		}
-
-		bool success = m_script->setPassword(playername, newpwd);
-		if(success){
-			actionstream<<player->getName()<<" changes password"<<std::endl;
-			SendChatMessage(peer_id, L"Password change successful.");
-		} else {
-			actionstream<<player->getName()<<" tries to change password but "
-					<<"it fails"<<std::endl;
-			SendChatMessage(peer_id, L"Password change failed or inavailable.");
-		}
-	}
-	else if(command == TOSERVER_PLAYERITEM)
-	{
-		if (datasize < 2+2)
-			return;
-
-		u16 item = readU16(&data[2]);
-		playersao->setWieldIndex(item);
-	}
-	else if(command == TOSERVER_RESPAWN)
-	{
-		if(player->hp != 0 || !g_settings->getBool("enable_damage"))
-			return;
-
-		RespawnPlayer(peer_id);
-
-		actionstream<<player->getName()<<" respawns at "
-				<<PP(player->getPosition()/BS)<<std::endl;
-
-		// ActiveObject is added to environment in AsyncRunStep after
-		// the previous addition has been succesfully removed
-	}
-	else if(command == TOSERVER_INTERACT)
-	{
-		std::string datastring((char*)&data[2], datasize-2);
-		std::istringstream is(datastring, std::ios_base::binary);
-
-		/*
-			[0] u16 command
-			[2] u8 action
-			[3] u16 item
-			[5] u32 length of the next item
-			[9] serialized PointedThing
-			actions:
-			0: start digging (from undersurface) or use
-			1: stop digging (all parameters ignored)
-			2: digging completed
-			3: place block or item (to abovesurface)
-			4: use item
-		*/
-		u8 action = readU8(is);
-		u16 item_i = readU16(is);
-		std::istringstream tmp_is(deSerializeLongString(is), std::ios::binary);
-		PointedThing pointed;
-		pointed.deSerialize(tmp_is);
-
-		verbosestream<<"TOSERVER_INTERACT: action="<<(int)action<<", item="
-				<<item_i<<", pointed="<<pointed.dump()<<std::endl;
-
-		if(player->hp == 0)
-		{
-			verbosestream<<"TOSERVER_INTERACT: "<<player->getName()
-				<<" tried to interact, but is dead!"<<std::endl;
-			return;
-		}
-
-		v3f player_pos = playersao->getLastGoodPosition();
-
-		// Update wielded item
-		playersao->setWieldIndex(item_i);
-
-		// Get pointed to node (undefined if not POINTEDTYPE_NODE)
-		v3s16 p_under = pointed.node_undersurface;
-		v3s16 p_above = pointed.node_abovesurface;
-
-		// Get pointed to object (NULL if not POINTEDTYPE_OBJECT)
-		ServerActiveObject *pointed_object = NULL;
-		if(pointed.type == POINTEDTHING_OBJECT)
-		{
-			pointed_object = m_env->getActiveObject(pointed.object_id);
-			if(pointed_object == NULL)
-			{
-				verbosestream<<"TOSERVER_INTERACT: "
-					"pointed object is NULL"<<std::endl;
-				return;
-			}
-
-		}
-
-		v3f pointed_pos_under = player_pos;
-		v3f pointed_pos_above = player_pos;
-		if(pointed.type == POINTEDTHING_NODE)
-		{
-			pointed_pos_under = intToFloat(p_under, BS);
-			pointed_pos_above = intToFloat(p_above, BS);
-		}
-		else if(pointed.type == POINTEDTHING_OBJECT)
-		{
-			pointed_pos_under = pointed_object->getBasePosition();
-			pointed_pos_above = pointed_pos_under;
-		}
-
-		/*
-			Check that target is reasonably close
-			(only when digging or placing things)
-		*/
-		if(action == 0 || action == 2 || action == 3)
-		{
-			float d = player_pos.getDistanceFrom(pointed_pos_under);
-			float max_d = BS * 14; // Just some large enough value
-			if(d > max_d){
-				actionstream<<"Player "<<player->getName()
-						<<" tried to access "<<pointed.dump()
-						<<" from too far: "
-						<<"d="<<d<<", max_d="<<max_d
-						<<". ignoring."<<std::endl;
-				// Re-send block to revert change on client-side
-				RemoteClient *client = getClient(peer_id);
-				v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_under, BS));
-				client->SetBlockNotSent(blockpos);
-				// Call callbacks
-				m_script->on_cheat(playersao, "interacted_too_far");
-				// Do nothing else
-				return;
-			}
-		}
-
-		/*
-			Make sure the player is allowed to do it
-		*/
-		if(!checkPriv(player->getName(), "interact"))
-		{
-			actionstream<<player->getName()<<" attempted to interact with "
-					<<pointed.dump()<<" without 'interact' privilege"
-					<<std::endl;
-			// Re-send block to revert change on client-side
-			RemoteClient *client = getClient(peer_id);
-			// Digging completed -> under
-			if(action == 2){
-				v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_under, BS));
-				client->SetBlockNotSent(blockpos);
-			}
-			// Placement -> above
-			if(action == 3){
-				v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_above, BS));
-				client->SetBlockNotSent(blockpos);
-			}
-			return;
-		}
-
-		/*
-			If something goes wrong, this player is to blame
-		*/
-		RollbackScopeActor rollback_scope(m_rollback,
-				std::string("player:")+player->getName());
-
-		/*
-			0: start digging or punch object
-		*/
-		if(action == 0)
-		{
-			if(pointed.type == POINTEDTHING_NODE)
-			{
-				/*
-					NOTE: This can be used in the future to check if
-					somebody is cheating, by checking the timing.
-				*/
-				MapNode n(CONTENT_IGNORE);
-				try
-				{
-					n = m_env->getMap().getNode(p_under);
-				}
-				catch(InvalidPositionException &e)
-				{
-					infostream<<"Server: Not punching: Node not found."
-							<<" Adding block to emerge queue."
-							<<std::endl;
-					m_emerge->enqueueBlockEmerge(peer_id, getNodeBlockPos(p_above), false);
-				}
-				if(n.getContent() != CONTENT_IGNORE)
-					m_script->node_on_punch(p_under, n, playersao, pointed);
-				// Cheat prevention
-				playersao->noCheatDigStart(p_under);
-			}
-			else if(pointed.type == POINTEDTHING_OBJECT)
-			{
-				// Skip if object has been removed
-				if(pointed_object->m_removed)
-					return;
-
-				actionstream<<player->getName()<<" punches object "
-						<<pointed.object_id<<": "
-						<<pointed_object->getDescription()<<std::endl;
-
-				ItemStack punchitem = playersao->getWieldedItem();
-				ToolCapabilities toolcap =
-						punchitem.getToolCapabilities(m_itemdef);
-				v3f dir = (pointed_object->getBasePosition() -
-						(player->getPosition() + player->getEyeOffset())
-							).normalize();
-				float time_from_last_punch =
-					playersao->resetTimeFromLastPunch();
-				pointed_object->punch(dir, &toolcap, playersao,
-						time_from_last_punch);
-			}
-
-		} // action == 0
-
-		/*
-			1: stop digging
-		*/
-		else if(action == 1)
-		{
-		} // action == 1
-
-		/*
-			2: Digging completed
-		*/
-		else if(action == 2)
-		{
-			// Only digging of nodes
-			if(pointed.type == POINTEDTHING_NODE)
-			{
-				MapNode n(CONTENT_IGNORE);
-				try
-				{
-					n = m_env->getMap().getNode(p_under);
-				}
-				catch(InvalidPositionException &e)
-				{
-					infostream<<"Server: Not finishing digging: Node not found."
-							<<" Adding block to emerge queue."
-							<<std::endl;
-					m_emerge->enqueueBlockEmerge(peer_id, getNodeBlockPos(p_above), false);
-				}
-
-				/* Cheat prevention */
-				bool is_valid_dig = true;
-				if(!isSingleplayer() && !g_settings->getBool("disable_anticheat"))
-				{
-					v3s16 nocheat_p = playersao->getNoCheatDigPos();
-					float nocheat_t = playersao->getNoCheatDigTime();
-					playersao->noCheatDigEnd();
-					// If player didn't start digging this, ignore dig
-					if(nocheat_p != p_under){
-						infostream<<"Server: NoCheat: "<<player->getName()
-								<<" started digging "
-								<<PP(nocheat_p)<<" and completed digging "
-								<<PP(p_under)<<"; not digging."<<std::endl;
-						is_valid_dig = false;
-						// Call callbacks
-						m_script->on_cheat(playersao, "finished_unknown_dig");
-					}
-					// Get player's wielded item
-					ItemStack playeritem;
-					InventoryList *mlist = playersao->getInventory()->getList("main");
-					if(mlist != NULL)
-						playeritem = mlist->getItem(playersao->getWieldIndex());
-					ToolCapabilities playeritem_toolcap =
-							playeritem.getToolCapabilities(m_itemdef);
-					// Get diggability and expected digging time
-					DigParams params = getDigParams(m_nodedef->get(n).groups,
-							&playeritem_toolcap);
-					// If can't dig, try hand
-					if(!params.diggable){
-						const ItemDefinition &hand = m_itemdef->get("");
-						const ToolCapabilities *tp = hand.tool_capabilities;
-						if(tp)
-							params = getDigParams(m_nodedef->get(n).groups, tp);
-					}
-					// If can't dig, ignore dig
-					if(!params.diggable){
-						infostream<<"Server: NoCheat: "<<player->getName()
-								<<" completed digging "<<PP(p_under)
-								<<", which is not diggable with tool. not digging."
-								<<std::endl;
-						is_valid_dig = false;
-						// Call callbacks
-						m_script->on_cheat(playersao, "dug_unbreakable");
-					}
-					// Check digging time
-					// If already invalidated, we don't have to
-					if(!is_valid_dig){
-						// Well not our problem then
-					}
-					// Clean and long dig
-					else if(params.time > 2.0 && nocheat_t * 1.2 > params.time){
-						// All is good, but grab time from pool; don't care if
-						// it's actually available
-						playersao->getDigPool().grab(params.time);
-					}
-					// Short or laggy dig
-					// Try getting the time from pool
-					else if(playersao->getDigPool().grab(params.time)){
-						// All is good
-					}
-					// Dig not possible
-					else{
-						infostream<<"Server: NoCheat: "<<player->getName()
-								<<" completed digging "<<PP(p_under)
-								<<"too fast; not digging."<<std::endl;
-						is_valid_dig = false;
-						// Call callbacks
-						m_script->on_cheat(playersao, "dug_too_fast");
-					}
-				}
-
-				/* Actually dig node */
-
-				if(is_valid_dig && n.getContent() != CONTENT_IGNORE)
-					m_script->node_on_dig(p_under, n, playersao);
-
-				v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_under, BS));
-				RemoteClient *client = getClient(peer_id);
-				// Send unusual result (that is, node not being removed)
-				if(m_env->getMap().getNodeNoEx(p_under).getContent() != CONTENT_AIR)
-				{
-					// Re-send block to revert change on client-side
-					client->SetBlockNotSent(blockpos);
-				}
-				else {
-					client->ResendBlockIfOnWire(blockpos);
-				}
-			}
-		} // action == 2
-
-		/*
-			3: place block or right-click object
-		*/
-		else if(action == 3)
-		{
-			ItemStack item = playersao->getWieldedItem();
-
-			// Reset build time counter
-			if(pointed.type == POINTEDTHING_NODE &&
-					item.getDefinition(m_itemdef).type == ITEM_NODE)
-				getClient(peer_id)->m_time_from_building = 0.0;
-
-			if(pointed.type == POINTEDTHING_OBJECT)
-			{
-				// Right click object
-
-				// Skip if object has been removed
-				if(pointed_object->m_removed)
-					return;
-
-				actionstream<<player->getName()<<" right-clicks object "
-						<<pointed.object_id<<": "
-						<<pointed_object->getDescription()<<std::endl;
-
-				// Do stuff
-				pointed_object->rightClick(playersao);
-			}
-			else if(m_script->item_OnPlace(
-					item, playersao, pointed))
-			{
-				// Placement was handled in lua
-
-				// Apply returned ItemStack
-				playersao->setWieldedItem(item);
-			}
-
-			// If item has node placement prediction, always send the
-			// blocks to make sure the client knows what exactly happened
-			RemoteClient *client = getClient(peer_id);
-			v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_above, BS));
-			v3s16 blockpos2 = getNodeBlockPos(floatToInt(pointed_pos_under, BS));
-			if(item.getDefinition(m_itemdef).node_placement_prediction != "") {
-				client->SetBlockNotSent(blockpos);
-				if(blockpos2 != blockpos) {
-					client->SetBlockNotSent(blockpos2);
-				}
-			}
-			else {
-				client->ResendBlockIfOnWire(blockpos);
-				if(blockpos2 != blockpos) {
-					client->ResendBlockIfOnWire(blockpos2);
-				}
-			}
-		} // action == 3
-
-		/*
-			4: use
-		*/
-		else if(action == 4)
-		{
-			ItemStack item = playersao->getWieldedItem();
-
-			actionstream<<player->getName()<<" uses "<<item.name
-					<<", pointing at "<<pointed.dump()<<std::endl;
-
-			if(m_script->item_OnUse(
-					item, playersao, pointed))
-			{
-				// Apply returned ItemStack
-				playersao->setWieldedItem(item);
-			}
-
-		} // action == 4
-		
-
-		/*
-			Catch invalid actions
-		*/
-		else
-		{
-			infostream<<"WARNING: Server: Invalid action "
-					<<action<<std::endl;
-		}
-	}
-	else if(command == TOSERVER_REMOVED_SOUNDS)
-	{
-		std::string datastring((char*)&data[2], datasize-2);
-		std::istringstream is(datastring, std::ios_base::binary);
-
-		int num = readU16(is);
-		for(int k=0; k<num; k++){
-			s32 id = readS32(is);
-			std::map<s32, ServerPlayingSound>::iterator i =
-					m_playing_sounds.find(id);
-			if(i == m_playing_sounds.end())
-				continue;
-			ServerPlayingSound &psound = i->second;
-			psound.clients.erase(peer_id);
-			if(psound.clients.size() == 0)
-				m_playing_sounds.erase(i++);
-		}
-	}
-	else if(command == TOSERVER_NODEMETA_FIELDS)
-	{
-		std::string datastring((char*)&data[2], datasize-2);
-		std::istringstream is(datastring, std::ios_base::binary);
-
-		v3s16 p = readV3S16(is);
-		std::string formname = deSerializeString(is);
-		int num = readU16(is);
-		std::map<std::string, std::string> fields;
-		for(int k=0; k<num; k++){
-			std::string fieldname = deSerializeString(is);
-			std::string fieldvalue = deSerializeLongString(is);
-			fields[fieldname] = fieldvalue;
-		}
-
-		// If something goes wrong, this player is to blame
-		RollbackScopeActor rollback_scope(m_rollback,
-				std::string("player:")+player->getName());
-
-		// Check the target node for rollback data; leave others unnoticed
-		RollbackNode rn_old(&m_env->getMap(), p, this);
-
-		m_script->node_on_receive_fields(p, formname, fields,playersao);
-
-		// Report rollback data
-		RollbackNode rn_new(&m_env->getMap(), p, this);
-		if(rollback() && rn_new != rn_old){
-			RollbackAction action;
-			action.setSetNode(p, rn_old, rn_new);
-			rollback()->reportAction(action);
-		}
-	}
-	else if(command == TOSERVER_INVENTORY_FIELDS)
-	{
-		std::string datastring((char*)&data[2], datasize-2);
-		std::istringstream is(datastring, std::ios_base::binary);
-
-		std::string formname = deSerializeString(is);
-		int num = readU16(is);
-		std::map<std::string, std::string> fields;
-		for(int k=0; k<num; k++){
-			std::string fieldname = deSerializeString(is);
-			std::string fieldvalue = deSerializeLongString(is);
-			fields[fieldname] = fieldvalue;
-		}
-
-		m_script->on_playerReceiveFields(playersao, formname, fields);
-	}
-	else
-	{
-		infostream<<"Server::ProcessData(): Ignoring "
-				"unknown command "<<command<<std::endl;
-	}
-
-	} //try
-	catch(SendFailedException &e)
-	{
-		errorstream<<"Server::ProcessData(): SendFailedException: "
-				<<"what="<<e.what()
-				<<std::endl;
-	}
-}
-
-void Server::setTimeOfDay(u32 time)
-{
-	m_env->setTimeOfDay(time);
-	m_time_of_day_send_timer = 0;
-}
-
-void Server::onMapEditEvent(MapEditEvent *event)
-{
-	//infostream<<"Server::onMapEditEvent()"<<std::endl;
-	if(m_ignore_map_edit_events)
-		return;
-	if(m_ignore_map_edit_events_area.contains(event->getArea()))
-		return;
-	MapEditEvent *e = event->clone();
-	m_unsent_map_edit_queue.push_back(e);
-}
-
-Inventory* Server::getInventory(const InventoryLocation &loc)
-{
-	switch(loc.type){
-	case InventoryLocation::UNDEFINED:
-	{}
-	break;
-	case InventoryLocation::CURRENT_PLAYER:
-	{}
-	break;
-	case InventoryLocation::PLAYER:
-	{
-		Player *player = m_env->getPlayer(loc.name.c_str());
-		if(!player)
-			return NULL;
-		PlayerSAO *playersao = player->getPlayerSAO();
-		if(!playersao)
-			return NULL;
-		return playersao->getInventory();
-	}
-	break;
-	case InventoryLocation::NODEMETA:
-	{
-		NodeMetadata *meta = m_env->getMap().getNodeMetadata(loc.p);
-		if(!meta)
-			return NULL;
-		return meta->getInventory();
-	}
-	break;
-	case InventoryLocation::DETACHED:
-	{
-		if(m_detached_inventories.count(loc.name) == 0)
-			return NULL;
-		return m_detached_inventories[loc.name];
-	}
-	break;
-	default:
-		assert(0);
-	}
-	return NULL;
-}
-void Server::setInventoryModified(const InventoryLocation &loc)
-{
-	switch(loc.type){
-	case InventoryLocation::UNDEFINED:
-	{}
-	break;
-	case InventoryLocation::PLAYER:
-	{
-		Player *player = m_env->getPlayer(loc.name.c_str());
-		if(!player)
+		Player *player = m_env->getPlayer(loc.name.c_str());
+		if(!player)
 			return;
 		PlayerSAO *playersao = player->getPlayerSAO();
 		if(!playersao)
 			return;
-		playersao->m_inventory_not_sent = true;
-		playersao->m_wielded_item_not_sent = true;
+
+		SendInventory(playersao);
 	}
-	break;
+		break;
 	case InventoryLocation::NODEMETA:
 	{
 		v3s16 blockpos = getNodeBlockPos(loc.p);
@@ -2821,35 +1327,34 @@ void Server::setInventoryModified(const InventoryLocation &loc)
 
 		setBlockNotSent(blockpos);
 	}
-	break;
+		break;
 	case InventoryLocation::DETACHED:
 	{
 		sendDetachedInventory(loc.name,PEER_ID_INEXISTENT);
 	}
-	break;
+		break;
 	default:
-		assert(0);
+		sanity_check(false); // abort
+		break;
 	}
 }
 
 void Server::SetBlocksNotSent(std::map<v3s16, MapBlock *>& block)
 {
-	std::list<u16> clients = m_clients.getClientIDs();
-	m_clients.Lock();
+	std::vector<u16> clients = m_clients.getClientIDs();
+	m_clients.lock();
 	// Set the modified blocks unsent for all the clients
-	for (std::list<u16>::iterator
-		 i = clients.begin();
+	for (std::vector<u16>::iterator i = clients.begin();
 		 i != clients.end(); ++i) {
-			RemoteClient *client = m_clients.lockedGetClientNoEx(*i);
-			if (client != NULL)
+			if (RemoteClient *client = m_clients.lockedGetClientNoEx(*i))
 				client->SetBlocksNotSent(block);
-		}
-	m_clients.Unlock();
+	}
+	m_clients.unlock();
 }
 
 void Server::peerAdded(con::Peer *peer)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 	verbosestream<<"Server::peerAdded(): peer->id="
 			<<peer->id<<std::endl;
 
@@ -2857,12 +1362,12 @@ void Server::peerAdded(con::Peer *peer)
 	c.type = con::PEER_ADDED;
 	c.peer_id = peer->id;
 	c.timeout = false;
-	m_peer_change_queue.push_back(c);
+	m_peer_change_queue.push(c);
 }
 
 void Server::deletingPeer(con::Peer *peer, bool timeout)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 	verbosestream<<"Server::deletingPeer(): peer->id="
 			<<peer->id<<", timeout="<<timeout<<std::endl;
 
@@ -2871,7 +1376,7 @@ void Server::deletingPeer(con::Peer *peer, bool timeout)
 	c.type = con::PEER_REMOVED;
 	c.peer_id = peer->id;
 	c.timeout = timeout;
-	m_peer_change_queue.push_back(c);
+	m_peer_change_queue.push(c);
 }
 
 bool Server::getClientConInfo(u16 peer_id, con::rtt_stat_type type, float* retval)
@@ -2894,11 +1399,11 @@ bool Server::getClientInfo(
 	)
 {
 	*state = m_clients.getClientState(peer_id);
-	m_clients.Lock();
+	m_clients.lock();
 	RemoteClient* client = m_clients.lockedGetClientNoEx(peer_id, CS_Invalid);
 
 	if (client == NULL) {
-		m_clients.Unlock();
+		m_clients.unlock();
 		return false;
 	}
 
@@ -2911,7 +1416,7 @@ bool Server::getClientInfo(
 	*patch = client->getPatch();
 	*vers_string = client->getPatch();
 
-	m_clients.Unlock();
+	m_clients.unlock();
 
 	return true;
 }
@@ -2920,7 +1425,8 @@ void Server::handlePeerChanges()
 {
 	while(m_peer_change_queue.size() > 0)
 	{
-		con::PeerChange c = m_peer_change_queue.pop_front();
+		con::PeerChange c = m_peer_change_queue.front();
+		m_peer_change_queue.pop();
 
 		verbosestream<<"Server: Handling peer change: "
 				<<"id="<<c.peer_id<<", timeout="<<c.timeout
@@ -2937,242 +1443,211 @@ void Server::handlePeerChanges()
 			break;
 
 		default:
-			assert("Invalid peer change event received!" == 0);
+			FATAL_ERROR("Invalid peer change event received!");
 			break;
 		}
 	}
 }
 
+void Server::Send(NetworkPacket* pkt)
+{
+	m_clients.send(pkt->getPeerId(),
+		clientCommandFactoryTable[pkt->getCommand()].channel,
+		pkt,
+		clientCommandFactoryTable[pkt->getCommand()].reliable);
+}
+
 void Server::SendMovement(u16 peer_id)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 	std::ostringstream os(std::ios_base::binary);
 
-	writeU16(os, TOCLIENT_MOVEMENT);
-	writeF1000(os, g_settings->getFloat("movement_acceleration_default"));
-	writeF1000(os, g_settings->getFloat("movement_acceleration_air"));
-	writeF1000(os, g_settings->getFloat("movement_acceleration_fast"));
-	writeF1000(os, g_settings->getFloat("movement_speed_walk"));
-	writeF1000(os, g_settings->getFloat("movement_speed_crouch"));
-	writeF1000(os, g_settings->getFloat("movement_speed_fast"));
-	writeF1000(os, g_settings->getFloat("movement_speed_climb"));
-	writeF1000(os, g_settings->getFloat("movement_speed_jump"));
-	writeF1000(os, g_settings->getFloat("movement_liquid_fluidity"));
-	writeF1000(os, g_settings->getFloat("movement_liquid_fluidity_smooth"));
-	writeF1000(os, g_settings->getFloat("movement_liquid_sink"));
-	writeF1000(os, g_settings->getFloat("movement_gravity"));
+	NetworkPacket pkt(TOCLIENT_MOVEMENT, 12 * sizeof(float), peer_id);
 
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
-	// Send as reliable
-	m_clients.send(peer_id, 0, data, true);
+	pkt << g_settings->getFloat("movement_acceleration_default");
+	pkt << g_settings->getFloat("movement_acceleration_air");
+	pkt << g_settings->getFloat("movement_acceleration_fast");
+	pkt << g_settings->getFloat("movement_speed_walk");
+	pkt << g_settings->getFloat("movement_speed_crouch");
+	pkt << g_settings->getFloat("movement_speed_fast");
+	pkt << g_settings->getFloat("movement_speed_climb");
+	pkt << g_settings->getFloat("movement_speed_jump");
+	pkt << g_settings->getFloat("movement_liquid_fluidity");
+	pkt << g_settings->getFloat("movement_liquid_fluidity_smooth");
+	pkt << g_settings->getFloat("movement_liquid_sink");
+	pkt << g_settings->getFloat("movement_gravity");
+
+	Send(&pkt);
 }
 
-void Server::SendHP(u16 peer_id, u8 hp)
+void Server::SendPlayerHPOrDie(PlayerSAO *playersao)
 {
-	DSTACK(__FUNCTION_NAME);
-	std::ostringstream os(std::ios_base::binary);
+	if (!g_settings->getBool("enable_damage"))
+		return;
 
-	writeU16(os, TOCLIENT_HP);
-	writeU8(os, hp);
+	u16 peer_id   = playersao->getPeerID();
+	bool is_alive = playersao->getHP() > 0;
 
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
-	// Send as reliable
-	m_clients.send(peer_id, 0, data, true);
+	if (is_alive)
+		SendPlayerHP(peer_id);
+	else
+		DiePlayer(peer_id);
 }
 
-void Server::SendBreath(u16 peer_id, u16 breath)
+void Server::SendHP(u16 peer_id, u8 hp)
 {
-	DSTACK(__FUNCTION_NAME);
-	std::ostringstream os(std::ios_base::binary);
+	DSTACK(FUNCTION_NAME);
 
-	writeU16(os, TOCLIENT_BREATH);
-	writeU16(os, breath);
+	NetworkPacket pkt(TOCLIENT_HP, 1, peer_id);
+	pkt << hp;
+	Send(&pkt);
+}
 
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
-	// Send as reliable
-	m_clients.send(peer_id, 0, data, true);
+void Server::SendBreath(u16 peer_id, u16 breath)
+{
+	DSTACK(FUNCTION_NAME);
+
+	NetworkPacket pkt(TOCLIENT_BREATH, 2, peer_id);
+	pkt << (u16) breath;
+	Send(&pkt);
 }
 
-void Server::SendAccessDenied(u16 peer_id,const std::wstring &reason)
+void Server::SendAccessDenied(u16 peer_id, AccessDeniedCode reason,
+		const std::string &custom_reason, bool reconnect)
 {
-	DSTACK(__FUNCTION_NAME);
-	std::ostringstream os(std::ios_base::binary);
+	assert(reason < SERVER_ACCESSDENIED_MAX);
 
-	writeU16(os, TOCLIENT_ACCESS_DENIED);
-	os<<serializeWideString(reason);
+	NetworkPacket pkt(TOCLIENT_ACCESS_DENIED, 1, peer_id);
+	pkt << (u8)reason;
+	if (reason == SERVER_ACCESSDENIED_CUSTOM_STRING)
+		pkt << custom_reason;
+	else if (reason == SERVER_ACCESSDENIED_SHUTDOWN ||
+			reason == SERVER_ACCESSDENIED_CRASH)
+		pkt << custom_reason << (u8)reconnect;
+	Send(&pkt);
+}
 
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
-	// Send as reliable
-	m_clients.send(peer_id, 0, data, true);
+void Server::SendAccessDenied_Legacy(u16 peer_id,const std::wstring &reason)
+{
+	DSTACK(FUNCTION_NAME);
+
+	NetworkPacket pkt(TOCLIENT_ACCESS_DENIED_LEGACY, 0, peer_id);
+	pkt << reason;
+	Send(&pkt);
 }
 
 void Server::SendDeathscreen(u16 peer_id,bool set_camera_point_target,
 		v3f camera_point_target)
 {
-	DSTACK(__FUNCTION_NAME);
-	std::ostringstream os(std::ios_base::binary);
+	DSTACK(FUNCTION_NAME);
 
-	writeU16(os, TOCLIENT_DEATHSCREEN);
-	writeU8(os, set_camera_point_target);
-	writeV3F1000(os, camera_point_target);
-
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
-	// Send as reliable
-	m_clients.send(peer_id, 0, data, true);
+	NetworkPacket pkt(TOCLIENT_DEATHSCREEN, 1 + sizeof(v3f), peer_id);
+	pkt << set_camera_point_target << camera_point_target;
+	Send(&pkt);
 }
 
 void Server::SendItemDef(u16 peer_id,
 		IItemDefManager *itemdef, u16 protocol_version)
 {
-	DSTACK(__FUNCTION_NAME);
-	std::ostringstream os(std::ios_base::binary);
+	DSTACK(FUNCTION_NAME);
+
+	NetworkPacket pkt(TOCLIENT_ITEMDEF, 0, peer_id);
 
 	/*
 		u16 command
 		u32 length of the next item
 		zlib-compressed serialized ItemDefManager
 	*/
-	writeU16(os, TOCLIENT_ITEMDEF);
 	std::ostringstream tmp_os(std::ios::binary);
 	itemdef->serialize(tmp_os, protocol_version);
 	std::ostringstream tmp_os2(std::ios::binary);
 	compressZlib(tmp_os.str(), tmp_os2);
-	os<<serializeLongString(tmp_os2.str());
+	pkt.putLongString(tmp_os2.str());
 
 	// Make data buffer
-	std::string s = os.str();
-	verbosestream<<"Server: Sending item definitions to id("<<peer_id
-			<<"): size="<<s.size()<<std::endl;
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
-	// Send as reliable
-	m_clients.send(peer_id, 0, data, true);
+	verbosestream << "Server: Sending item definitions to id(" << peer_id
+			<< "): size=" << pkt.getSize() << std::endl;
+
+	Send(&pkt);
 }
 
 void Server::SendNodeDef(u16 peer_id,
 		INodeDefManager *nodedef, u16 protocol_version)
 {
-	DSTACK(__FUNCTION_NAME);
-	std::ostringstream os(std::ios_base::binary);
+	DSTACK(FUNCTION_NAME);
+
+	NetworkPacket pkt(TOCLIENT_NODEDEF, 0, peer_id);
 
 	/*
 		u16 command
 		u32 length of the next item
 		zlib-compressed serialized NodeDefManager
 	*/
-	writeU16(os, TOCLIENT_NODEDEF);
 	std::ostringstream tmp_os(std::ios::binary);
 	nodedef->serialize(tmp_os, protocol_version);
 	std::ostringstream tmp_os2(std::ios::binary);
 	compressZlib(tmp_os.str(), tmp_os2);
-	os<<serializeLongString(tmp_os2.str());
+
+	pkt.putLongString(tmp_os2.str());
 
 	// Make data buffer
-	std::string s = os.str();
-	verbosestream<<"Server: Sending node definitions to id("<<peer_id
-			<<"): size="<<s.size()<<std::endl;
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
-	// Send as reliable
-	m_clients.send(peer_id, 0, data, true);
+	verbosestream << "Server: Sending node definitions to id(" << peer_id
+			<< "): size=" << pkt.getSize() << std::endl;
+
+	Send(&pkt);
 }
 
 /*
 	Non-static send methods
 */
 
-void Server::SendInventory(u16 peer_id)
+void Server::SendInventory(PlayerSAO* playerSAO)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 
-	PlayerSAO *playersao = getPlayerSAO(peer_id);
-	assert(playersao);
-
-	playersao->m_inventory_not_sent = false;
+	UpdateCrafting(playerSAO->getPlayer());
 
 	/*
 		Serialize it
 	*/
 
+	NetworkPacket pkt(TOCLIENT_INVENTORY, 0, playerSAO->getPeerID());
+
 	std::ostringstream os;
-	playersao->getInventory()->serialize(os);
+	playerSAO->getInventory()->serialize(os);
 
 	std::string s = os.str();
 
-	SharedBuffer<u8> data(s.size()+2);
-	writeU16(&data[0], TOCLIENT_INVENTORY);
-	memcpy(&data[2], s.c_str(), s.size());
-
-	// Send as reliable
-	m_clients.send(peer_id, 0, data, true);
+	pkt.putRawString(s.c_str(), s.size());
+	Send(&pkt);
 }
 
 void Server::SendChatMessage(u16 peer_id, const std::wstring &message)
 {
-	DSTACK(__FUNCTION_NAME);
-
-	std::ostringstream os(std::ios_base::binary);
-	u8 buf[12];
-
-	// Write command
-	writeU16(buf, TOCLIENT_CHAT_MESSAGE);
-	os.write((char*)buf, 2);
-
-	// Write length
-	writeU16(buf, message.size());
-	os.write((char*)buf, 2);
-
-	// Write string
-	for(u32 i=0; i<message.size(); i++)
-	{
-		u16 w = message[i];
-		writeU16(buf, w);
-		os.write((char*)buf, 2);
-	}
+	DSTACK(FUNCTION_NAME);
 
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
+	NetworkPacket pkt(TOCLIENT_CHAT_MESSAGE, 0, peer_id);
+	pkt << message;
 
-	if (peer_id != PEER_ID_INEXISTENT)
-	{
-		// Send as reliable
-		m_clients.send(peer_id, 0, data, true);
+	if (peer_id != PEER_ID_INEXISTENT) {
+		Send(&pkt);
 	}
-	else
-	{
-		m_clients.sendToAll(0,data,true);
+	else {
+		m_clients.sendToAll(0, &pkt, true);
 	}
 }
 
 void Server::SendShowFormspecMessage(u16 peer_id, const std::string &formspec,
                                      const std::string &formname)
 {
-	DSTACK(__FUNCTION_NAME);
-
-	std::ostringstream os(std::ios_base::binary);
-	u8 buf[12];
+	DSTACK(FUNCTION_NAME);
 
+	NetworkPacket pkt(TOCLIENT_SHOW_FORMSPEC, 0 , peer_id);
 
-	// Write command
-	writeU16(buf, TOCLIENT_SHOW_FORMSPEC);
-	os.write((char*)buf, 2);
-	os<<serializeLongString(FORMSPEC_VERSION_STRING + formspec);
-	os<<serializeString(formname);
+	pkt.putLongString(FORMSPEC_VERSION_STRING + formspec);
+	pkt << formname;
 
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
-	// Send as reliable
-	m_clients.send(peer_id, 0, data, true);
+	Send(&pkt);
 }
 
 // Spawns a particle on peer with peer_id
@@ -3180,31 +1655,20 @@ void Server::SendSpawnParticle(u16 peer_id, v3f pos, v3f velocity, v3f accelerat
 				float expirationtime, float size, bool collisiondetection,
 				bool vertical, std::string texture)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 
-	std::ostringstream os(std::ios_base::binary);
-	writeU16(os, TOCLIENT_SPAWN_PARTICLE);
-	writeV3F1000(os, pos);
-	writeV3F1000(os, velocity);
-	writeV3F1000(os, acceleration);
-	writeF1000(os, expirationtime);
-	writeF1000(os, size);
-	writeU8(os,  collisiondetection);
-	os<<serializeLongString(texture);
-	writeU8(os, vertical);
+	NetworkPacket pkt(TOCLIENT_SPAWN_PARTICLE, 0, peer_id);
 
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
+	pkt << pos << velocity << acceleration << expirationtime
+			<< size << collisiondetection;
+	pkt.putLongString(texture);
+	pkt << vertical;
 
-	if (peer_id != PEER_ID_INEXISTENT)
-	{
-	// Send as reliable
-		m_clients.send(peer_id, 0, data, true);
+	if (peer_id != PEER_ID_INEXISTENT) {
+		Send(&pkt);
 	}
-	else
-	{
-		m_clients.sendToAll(0,data,true);
+	else {
+		m_clients.sendToAll(0, &pkt, true);
 	}
 }
 
@@ -3213,326 +1677,218 @@ void Server::SendAddParticleSpawner(u16 peer_id, u16 amount, float spawntime, v3
 	v3f minvel, v3f maxvel, v3f minacc, v3f maxacc, float minexptime, float maxexptime,
 	float minsize, float maxsize, bool collisiondetection, bool vertical, std::string texture, u32 id)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 
-	std::ostringstream os(std::ios_base::binary);
-	writeU16(os, TOCLIENT_ADD_PARTICLESPAWNER);
-
-	writeU16(os, amount);
-	writeF1000(os, spawntime);
-	writeV3F1000(os, minpos);
-	writeV3F1000(os, maxpos);
-	writeV3F1000(os, minvel);
-	writeV3F1000(os, maxvel);
-	writeV3F1000(os, minacc);
-	writeV3F1000(os, maxacc);
-	writeF1000(os, minexptime);
-	writeF1000(os, maxexptime);
-	writeF1000(os, minsize);
-	writeF1000(os, maxsize);
-	writeU8(os,  collisiondetection);
-	os<<serializeLongString(texture);
-	writeU32(os, id);
-	writeU8(os, vertical);
+	NetworkPacket pkt(TOCLIENT_ADD_PARTICLESPAWNER, 0, peer_id);
 
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
+	pkt << amount << spawntime << minpos << maxpos << minvel << maxvel
+			<< minacc << maxacc << minexptime << maxexptime << minsize
+			<< maxsize << collisiondetection;
 
-	if (peer_id != PEER_ID_INEXISTENT)
-	{
-		// Send as reliable
-		m_clients.send(peer_id, 0, data, true);
+	pkt.putLongString(texture);
+
+	pkt << id << vertical;
+
+	if (peer_id != PEER_ID_INEXISTENT) {
+		Send(&pkt);
 	}
 	else {
-		m_clients.sendToAll(0,data,true);
+		m_clients.sendToAll(0, &pkt, true);
 	}
 }
 
 void Server::SendDeleteParticleSpawner(u16 peer_id, u32 id)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 
-	std::ostringstream os(std::ios_base::binary);
-	writeU16(os, TOCLIENT_DELETE_PARTICLESPAWNER);
-
-	writeU16(os, id);
+	NetworkPacket pkt(TOCLIENT_DELETE_PARTICLESPAWNER_LEGACY, 2, peer_id);
 
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
+	// Ugly error in this packet
+	pkt << (u16) id;
 
 	if (peer_id != PEER_ID_INEXISTENT) {
-		// Send as reliable
-		m_clients.send(peer_id, 0, data, true);
+		Send(&pkt);
 	}
 	else {
-		m_clients.sendToAll(0,data,true);
+		m_clients.sendToAll(0, &pkt, true);
 	}
 
 }
 
 void Server::SendHUDAdd(u16 peer_id, u32 id, HudElement *form)
 {
-	std::ostringstream os(std::ios_base::binary);
+	NetworkPacket pkt(TOCLIENT_HUDADD, 0 , peer_id);
 
-	// Write command
-	writeU16(os, TOCLIENT_HUDADD);
-	writeU32(os, id);
-	writeU8(os, (u8)form->type);
-	writeV2F1000(os, form->pos);
-	os << serializeString(form->name);
-	writeV2F1000(os, form->scale);
-	os << serializeString(form->text);
-	writeU32(os, form->number);
-	writeU32(os, form->item);
-	writeU32(os, form->dir);
-	writeV2F1000(os, form->align);
-	writeV2F1000(os, form->offset);
-	writeV3F1000(os, form->world_pos);
-	writeV2S32(os,form->size);
+	pkt << id << (u8) form->type << form->pos << form->name << form->scale
+			<< form->text << form->number << form->item << form->dir
+			<< form->align << form->offset << form->world_pos << form->size;
 
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
-	// Send as reliable
-	m_clients.send(peer_id, 1, data, true);
+	Send(&pkt);
 }
 
 void Server::SendHUDRemove(u16 peer_id, u32 id)
 {
-	std::ostringstream os(std::ios_base::binary);
-
-	// Write command
-	writeU16(os, TOCLIENT_HUDRM);
-	writeU32(os, id);
-
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
-	// Send as reliable
-
-	m_clients.send(peer_id, 1, data, true);
+	NetworkPacket pkt(TOCLIENT_HUDRM, 4, peer_id);
+	pkt << id;
+	Send(&pkt);
 }
 
 void Server::SendHUDChange(u16 peer_id, u32 id, HudElementStat stat, void *value)
 {
-	std::ostringstream os(std::ios_base::binary);
+	NetworkPacket pkt(TOCLIENT_HUDCHANGE, 0, peer_id);
+	pkt << id << (u8) stat;
 
-	// Write command
-	writeU16(os, TOCLIENT_HUDCHANGE);
-	writeU32(os, id);
-	writeU8(os, (u8)stat);
 	switch (stat) {
 		case HUD_STAT_POS:
 		case HUD_STAT_SCALE:
 		case HUD_STAT_ALIGN:
 		case HUD_STAT_OFFSET:
-			writeV2F1000(os, *(v2f *)value);
+			pkt << *(v2f *) value;
 			break;
 		case HUD_STAT_NAME:
 		case HUD_STAT_TEXT:
-			os << serializeString(*(std::string *)value);
+			pkt << *(std::string *) value;
 			break;
 		case HUD_STAT_WORLD_POS:
-			writeV3F1000(os, *(v3f *)value);
+			pkt << *(v3f *) value;
 			break;
 		case HUD_STAT_SIZE:
-			writeV2S32(os,*(v2s32 *)value);
+			pkt << *(v2s32 *) value;
 			break;
 		case HUD_STAT_NUMBER:
 		case HUD_STAT_ITEM:
 		case HUD_STAT_DIR:
 		default:
-			writeU32(os, *(u32 *)value);
+			pkt << *(u32 *) value;
 			break;
 	}
 
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8 *)s.c_str(), s.size());
-	// Send as reliable
-	m_clients.send(peer_id, 0, data, true);
+	Send(&pkt);
 }
 
 void Server::SendHUDSetFlags(u16 peer_id, u32 flags, u32 mask)
 {
-	std::ostringstream os(std::ios_base::binary);
+	NetworkPacket pkt(TOCLIENT_HUD_SET_FLAGS, 4 + 4, peer_id);
 
-	// Write command
-	writeU16(os, TOCLIENT_HUD_SET_FLAGS);
-
-	//////////////////////////// compatibility code to be removed //////////////
 	flags &= ~(HUD_FLAG_HEALTHBAR_VISIBLE | HUD_FLAG_BREATHBAR_VISIBLE);
-	////////////////////////////////////////////////////////////////////////////
-	writeU32(os, flags);
-	writeU32(os, mask);
 
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8 *)s.c_str(), s.size());
-	// Send as reliable
-	m_clients.send(peer_id, 0, data, true);
+	pkt << flags << mask;
+
+	Send(&pkt);
 }
 
 void Server::SendHUDSetParam(u16 peer_id, u16 param, const std::string &value)
 {
-	std::ostringstream os(std::ios_base::binary);
-
-	// Write command
-	writeU16(os, TOCLIENT_HUD_SET_PARAM);
-	writeU16(os, param);
-	os<<serializeString(value);
-
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8 *)s.c_str(), s.size());
-	// Send as reliable
-	m_clients.send(peer_id, 0, data, true);
+	NetworkPacket pkt(TOCLIENT_HUD_SET_PARAM, 0, peer_id);
+	pkt << param << value;
+	Send(&pkt);
 }
 
 void Server::SendSetSky(u16 peer_id, const video::SColor &bgcolor,
 		const std::string &type, const std::vector<std::string> &params)
 {
-	std::ostringstream os(std::ios_base::binary);
+	NetworkPacket pkt(TOCLIENT_SET_SKY, 0, peer_id);
+	pkt << bgcolor << type << (u16) params.size();
 
-	// Write command
-	writeU16(os, TOCLIENT_SET_SKY);
-	writeARGB8(os, bgcolor);
-	os<<serializeString(type);
-	writeU16(os, params.size());
 	for(size_t i=0; i<params.size(); i++)
-		os<<serializeString(params[i]);
+		pkt << params[i];
 
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8 *)s.c_str(), s.size());
-	// Send as reliable
-	m_clients.send(peer_id, 0, data, true);
+	Send(&pkt);
 }
 
 void Server::SendOverrideDayNightRatio(u16 peer_id, bool do_override,
 		float ratio)
 {
-	std::ostringstream os(std::ios_base::binary);
+	NetworkPacket pkt(TOCLIENT_OVERRIDE_DAY_NIGHT_RATIO,
+			1 + 2, peer_id);
 
-	// Write command
-	writeU16(os, TOCLIENT_OVERRIDE_DAY_NIGHT_RATIO);
-	writeU8(os, do_override);
-	writeU16(os, ratio*65535);
+	pkt << do_override << (u16) (ratio * 65535);
 
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8 *)s.c_str(), s.size());
-	// Send as reliable
-	m_clients.send(peer_id, 0, data, true);
+	Send(&pkt);
 }
 
 void Server::SendTimeOfDay(u16 peer_id, u16 time, f32 time_speed)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 
-	// Make packet
-	SharedBuffer<u8> data(2+2+4);
-	writeU16(&data[0], TOCLIENT_TIME_OF_DAY);
-	writeU16(&data[2], time);
-	writeF1000(&data[4], time_speed);
+	NetworkPacket pkt(TOCLIENT_TIME_OF_DAY, 0, peer_id);
+	pkt << time << time_speed;
 
 	if (peer_id == PEER_ID_INEXISTENT) {
-		m_clients.sendToAll(0,data,true);
+		m_clients.sendToAll(0, &pkt, true);
 	}
 	else {
-		// Send as reliable
-		m_clients.send(peer_id, 0, data, true);
+		Send(&pkt);
 	}
 }
 
 void Server::SendPlayerHP(u16 peer_id)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 	PlayerSAO *playersao = getPlayerSAO(peer_id);
-	assert(playersao);
-	playersao->m_hp_not_sent = false;
+	// In some rare case, if the player is disconnected
+	// while Lua call l_punch, for example, this can be NULL
+	if (!playersao)
+		return;
+
 	SendHP(peer_id, playersao->getHP());
 	m_script->player_event(playersao,"health_changed");
 
 	// Send to other clients
 	std::string str = gob_cmd_punched(playersao->readDamage(), playersao->getHP());
 	ActiveObjectMessage aom(playersao->getId(), true, str);
-	playersao->m_messages_out.push_back(aom);
+	playersao->m_messages_out.push(aom);
 }
 
 void Server::SendPlayerBreath(u16 peer_id)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 	PlayerSAO *playersao = getPlayerSAO(peer_id);
 	assert(playersao);
-	playersao->m_breath_not_sent = false;
-	m_script->player_event(playersao,"breath_changed");
+
+	m_script->player_event(playersao, "breath_changed");
 	SendBreath(peer_id, playersao->getBreath());
 }
 
 void Server::SendMovePlayer(u16 peer_id)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 	Player *player = m_env->getPlayer(peer_id);
 	assert(player);
 
-	std::ostringstream os(std::ios_base::binary);
-	writeU16(os, TOCLIENT_MOVE_PLAYER);
-	writeV3F1000(os, player->getPosition());
-	writeF1000(os, player->getPitch());
-	writeF1000(os, player->getYaw());
+	NetworkPacket pkt(TOCLIENT_MOVE_PLAYER, sizeof(v3f) + sizeof(f32) * 2, peer_id);
+	pkt << player->getPosition() << player->getPitch() << player->getYaw();
 
 	{
 		v3f pos = player->getPosition();
 		f32 pitch = player->getPitch();
 		f32 yaw = player->getYaw();
-		verbosestream<<"Server: Sending TOCLIENT_MOVE_PLAYER"
-				<<" pos=("<<pos.X<<","<<pos.Y<<","<<pos.Z<<")"
-				<<" pitch="<<pitch
-				<<" yaw="<<yaw
-				<<std::endl;
+		verbosestream << "Server: Sending TOCLIENT_MOVE_PLAYER"
+				<< " pos=(" << pos.X << "," << pos.Y << "," << pos.Z << ")"
+				<< " pitch=" << pitch
+				<< " yaw=" << yaw
+				<< std::endl;
 	}
 
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
-	// Send as reliable
-	m_clients.send(peer_id, 0, data, true);
+	Send(&pkt);
 }
 
 void Server::SendLocalPlayerAnimations(u16 peer_id, v2s32 animation_frames[4], f32 animation_speed)
 {
-	std::ostringstream os(std::ios_base::binary);
+	NetworkPacket pkt(TOCLIENT_LOCAL_PLAYER_ANIMATIONS, 0,
+		peer_id);
 
-	writeU16(os, TOCLIENT_LOCAL_PLAYER_ANIMATIONS);
-	writeV2S32(os, animation_frames[0]);
-	writeV2S32(os, animation_frames[1]);
-	writeV2S32(os, animation_frames[2]);
-	writeV2S32(os, animation_frames[3]);
-	writeF1000(os, animation_speed);
+	pkt << animation_frames[0] << animation_frames[1] << animation_frames[2]
+			<< animation_frames[3] << animation_speed;
 
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8 *)s.c_str(), s.size());
-	// Send as reliable
-	m_clients.send(peer_id, 0, data, true);
+	Send(&pkt);
 }
 
 void Server::SendEyeOffset(u16 peer_id, v3f first, v3f third)
 {
-	std::ostringstream os(std::ios_base::binary);
-
-	writeU16(os, TOCLIENT_EYE_OFFSET);
-	writeV3F1000(os, first);
-	writeV3F1000(os, third);
-
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8 *)s.c_str(), s.size());
-	// Send as reliable
-	m_clients.send(peer_id, 0, data, true);
+	NetworkPacket pkt(TOCLIENT_EYE_OFFSET, 0, peer_id);
+	pkt << first << third;
+	Send(&pkt);
 }
 void Server::SendPlayerPrivileges(u16 peer_id)
 {
@@ -3544,19 +1900,15 @@ void Server::SendPlayerPrivileges(u16 peer_id)
 	std::set<std::string> privs;
 	m_script->getAuth(player->getName(), NULL, &privs);
 
-	std::ostringstream os(std::ios_base::binary);
-	writeU16(os, TOCLIENT_PRIVILEGES);
-	writeU16(os, privs.size());
+	NetworkPacket pkt(TOCLIENT_PRIVILEGES, 0, peer_id);
+	pkt << (u16) privs.size();
+
 	for(std::set<std::string>::const_iterator i = privs.begin();
-			i != privs.end(); i++){
-		os<<serializeString(*i);
+			i != privs.end(); ++i) {
+		pkt << (*i);
 	}
 
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
-	// Send as reliable
-	m_clients.send(peer_id, 0, data, true);
+	Send(&pkt);
 }
 
 void Server::SendPlayerInventoryFormspec(u16 peer_id)
@@ -3566,15 +1918,30 @@ void Server::SendPlayerInventoryFormspec(u16 peer_id)
 	if(player->peer_id == PEER_ID_INEXISTENT)
 		return;
 
-	std::ostringstream os(std::ios_base::binary);
-	writeU16(os, TOCLIENT_INVENTORY_FORMSPEC);
-	os<<serializeLongString(FORMSPEC_VERSION_STRING + player->inventory_formspec);
+	NetworkPacket pkt(TOCLIENT_INVENTORY_FORMSPEC, 0, peer_id);
+	pkt.putLongString(FORMSPEC_VERSION_STRING + player->inventory_formspec);
+	Send(&pkt);
+}
+
+u32 Server::SendActiveObjectRemoveAdd(u16 peer_id, const std::string &datas)
+{
+	NetworkPacket pkt(TOCLIENT_ACTIVE_OBJECT_REMOVE_ADD, datas.size(), peer_id);
+	pkt.putRawString(datas.c_str(), datas.size());
+	Send(&pkt);
+	return pkt.getSize();
+}
+
+void Server::SendActiveObjectMessages(u16 peer_id, const std::string &datas, bool reliable)
+{
+	NetworkPacket pkt(TOCLIENT_ACTIVE_OBJECT_MESSAGES,
+			datas.size(), peer_id);
+
+	pkt.putRawString(datas.c_str(), datas.size());
+
+	m_clients.send(pkt.getPeerId(),
+			reliable ? clientCommandFactoryTable[pkt.getCommand()].channel : 1,
+			&pkt, reliable);
 
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
-	// Send as reliable
-	m_clients.send(peer_id, 0, data, true);
 }
 
 s32 Server::playSound(const SimpleSoundSpec &spec,
@@ -3588,7 +1955,7 @@ s32 Server::playSound(const SimpleSoundSpec &spec,
 		return -1;
 
 	// Filter destination clients
-	std::list<u16> dst_clients;
+	std::vector<u16> dst_clients;
 	if(params.to_player != "")
 	{
 		Player *player = m_env->getPlayer(params.to_player.c_str());
@@ -3604,17 +1971,16 @@ s32 Server::playSound(const SimpleSoundSpec &spec,
 		}
 		dst_clients.push_back(player->peer_id);
 	}
-	else
-	{
-		std::list<u16> clients = m_clients.getClientIDs();
+	else {
+		std::vector<u16> clients = m_clients.getClientIDs();
 
-		for(std::list<u16>::iterator
-				i = clients.begin(); i != clients.end(); ++i)
-		{
+		for(std::vector<u16>::iterator
+				i = clients.begin(); i != clients.end(); ++i) {
 			Player *player = m_env->getPlayer(*i);
 			if(!player)
 				continue;
-			if(pos_exists){
+
+			if(pos_exists) {
 				if(player->getPosition().getDistanceFrom(pos) >
 						params.max_hear_distance)
 					continue;
@@ -3622,7 +1988,8 @@ s32 Server::playSound(const SimpleSoundSpec &spec,
 			dst_clients.push_back(*i);
 		}
 	}
-	if(dst_clients.size() == 0)
+
+	if(dst_clients.empty())
 		return -1;
 
 	// Create the sound
@@ -3631,27 +1998,15 @@ s32 Server::playSound(const SimpleSoundSpec &spec,
 	m_playing_sounds[id] = ServerPlayingSound();
 	ServerPlayingSound &psound = m_playing_sounds[id];
 	psound.params = params;
-	for(std::list<u16>::iterator i = dst_clients.begin();
-			i != dst_clients.end(); i++)
+
+	NetworkPacket pkt(TOCLIENT_PLAY_SOUND, 0);
+	pkt << id << spec.name << (float) (spec.gain * params.gain)
+			<< (u8) params.type << pos << params.object << params.loop;
+
+	for(std::vector<u16>::iterator i = dst_clients.begin();
+			i != dst_clients.end(); ++i) {
 		psound.clients.insert(*i);
-	// Create packet
-	std::ostringstream os(std::ios_base::binary);
-	writeU16(os, TOCLIENT_PLAY_SOUND);
-	writeS32(os, id);
-	os<<serializeString(spec.name);
-	writeF1000(os, spec.gain * params.gain);
-	writeU8(os, params.type);
-	writeV3F1000(os, pos);
-	writeU16(os, params.object);
-	writeU8(os, params.loop);
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
-	// Send
-	for(std::list<u16>::iterator i = dst_clients.begin();
-			i != dst_clients.end(); i++){
-		// Send as reliable
-		m_clients.send(*i, 0, data, true);
+		m_clients.send(*i, 0, &pkt, true);
 	}
 	return id;
 }
@@ -3663,52 +2018,37 @@ void Server::stopSound(s32 handle)
 	if(i == m_playing_sounds.end())
 		return;
 	ServerPlayingSound &psound = i->second;
-	// Create packet
-	std::ostringstream os(std::ios_base::binary);
-	writeU16(os, TOCLIENT_STOP_SOUND);
-	writeS32(os, handle);
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
-	// Send
+
+	NetworkPacket pkt(TOCLIENT_STOP_SOUND, 4);
+	pkt << handle;
+
 	for(std::set<u16>::iterator i = psound.clients.begin();
-			i != psound.clients.end(); i++){
+			i != psound.clients.end(); ++i) {
 		// Send as reliable
-		m_clients.send(*i, 0, data, true);
+		m_clients.send(*i, 0, &pkt, true);
 	}
 	// Remove sound reference
 	m_playing_sounds.erase(i);
 }
 
 void Server::sendRemoveNode(v3s16 p, u16 ignore_id,
-	std::list<u16> *far_players, float far_d_nodes)
+	std::vector<u16> *far_players, float far_d_nodes)
 {
 	float maxd = far_d_nodes*BS;
 	v3f p_f = intToFloat(p, BS);
 
-	// Create packet
-	u32 replysize = 8;
-	SharedBuffer<u8> reply(replysize);
-	writeU16(&reply[0], TOCLIENT_REMOVENODE);
-	writeS16(&reply[2], p.X);
-	writeS16(&reply[4], p.Y);
-	writeS16(&reply[6], p.Z);
-
-	std::list<u16> clients = m_clients.getClientIDs();
-	for(std::list<u16>::iterator
-		i = clients.begin();
-		i != clients.end(); ++i)
-	{
-		if(far_players)
-		{
+	NetworkPacket pkt(TOCLIENT_REMOVENODE, 6);
+	pkt << p;
+
+	std::vector<u16> clients = m_clients.getClientIDs();
+	for(std::vector<u16>::iterator i = clients.begin();
+		i != clients.end(); ++i) {
+		if (far_players) {
 			// Get player
-			Player *player = m_env->getPlayer(*i);
-			if(player)
-			{
+			if(Player *player = m_env->getPlayer(*i)) {
 				// If player is far away, only set modified blocks not sent
 				v3f player_pos = player->getPosition();
-				if(player_pos.getDistanceFrom(p_f) > maxd)
-				{
+				if(player_pos.getDistanceFrom(p_f) > maxd) {
 					far_players->push_back(*i);
 					continue;
 				}
@@ -3716,111 +2056,74 @@ void Server::sendRemoveNode(v3s16 p, u16 ignore_id,
 		}
 
 		// Send as reliable
-		m_clients.send(*i, 0, reply, true);
+		m_clients.send(*i, 0, &pkt, true);
 	}
 }
 
 void Server::sendAddNode(v3s16 p, MapNode n, u16 ignore_id,
-		std::list<u16> *far_players, float far_d_nodes,
+		std::vector<u16> *far_players, float far_d_nodes,
 		bool remove_metadata)
 {
 	float maxd = far_d_nodes*BS;
 	v3f p_f = intToFloat(p, BS);
 
-	std::list<u16> clients = m_clients.getClientIDs();
-		for(std::list<u16>::iterator
-			i = clients.begin();
-			i != clients.end(); ++i)
-		{
+	std::vector<u16> clients = m_clients.getClientIDs();
+	for(std::vector<u16>::iterator i = clients.begin();
+			i != clients.end(); ++i) {
 
-		if(far_players)
-		{
+		if(far_players) {
 			// Get player
-			Player *player = m_env->getPlayer(*i);
-			if(player)
-			{
+			if(Player *player = m_env->getPlayer(*i)) {
 				// If player is far away, only set modified blocks not sent
 				v3f player_pos = player->getPosition();
-				if(player_pos.getDistanceFrom(p_f) > maxd)
-				{
+				if(player_pos.getDistanceFrom(p_f) > maxd) {
 					far_players->push_back(*i);
 					continue;
 				}
 			}
 		}
-		SharedBuffer<u8> reply(0);
-		m_clients.Lock();
+
+		NetworkPacket pkt(TOCLIENT_ADDNODE, 6 + 2 + 1 + 1 + 1);
+		m_clients.lock();
 		RemoteClient* client = m_clients.lockedGetClientNoEx(*i);
-		if (client != 0)
-		{
-			// Create packet
-			u32 replysize = 9 + MapNode::serializedLength(client->serialization_version);
-			reply = SharedBuffer<u8>(replysize);
-			writeU16(&reply[0], TOCLIENT_ADDNODE);
-			writeS16(&reply[2], p.X);
-			writeS16(&reply[4], p.Y);
-			writeS16(&reply[6], p.Z);
-			n.serialize(&reply[8], client->serialization_version);
-			u32 index = 8 + MapNode::serializedLength(client->serialization_version);
-			writeU8(&reply[index], remove_metadata ? 0 : 1);
+		if (client != 0) {
+			pkt << p << n.param0 << n.param1 << n.param2
+					<< (u8) (remove_metadata ? 0 : 1);
 
 			if (!remove_metadata) {
 				if (client->net_proto_version <= 21) {
 					// Old clients always clear metadata; fix it
 					// by sending the full block again.
-					client->SetBlockNotSent(p);
+					client->SetBlockNotSent(getNodeBlockPos(p));
 				}
 			}
 		}
-		m_clients.Unlock();
+		m_clients.unlock();
 
 		// Send as reliable
-		if (reply.getSize() > 0)
-			m_clients.send(*i, 0, reply, true);
+		if (pkt.getSize() > 0)
+			m_clients.send(*i, 0, &pkt, true);
 	}
 }
 
 void Server::setBlockNotSent(v3s16 p)
 {
-	std::list<u16> clients = m_clients.getClientIDs();
-	m_clients.Lock();
-	for(std::list<u16>::iterator
-		i = clients.begin();
-		i != clients.end(); ++i)
-	{
+	std::vector<u16> clients = m_clients.getClientIDs();
+	m_clients.lock();
+	for(std::vector<u16>::iterator i = clients.begin();
+		i != clients.end(); ++i) {
 		RemoteClient *client = m_clients.lockedGetClientNoEx(*i);
 		client->SetBlockNotSent(p);
 	}
-	m_clients.Unlock();
+	m_clients.unlock();
 }
 
 void Server::SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver, u16 net_proto_version)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 
 	v3s16 p = block->getPos();
 
-#if 0
-	// Analyze it a bit
-	bool completely_air = true;
-	for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
-	for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
-	for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
-	{
-		if(block->getNodeNoEx(v3s16(x0,y0,z0)).d != CONTENT_AIR)
-		{
-			completely_air = false;
-			x0 = y0 = z0 = MAP_BLOCKSIZE; // Break out
-		}
-	}
-
-	// Print result
-	infostream<<"Server: Sending block ("<<p.X<<","<<p.Y<<","<<p.Z<<"): ";
-	if(completely_air)
-		infostream<<"[completely air] ";
-	infostream<<std::endl;
-#endif
-
 	/*
 		Create a packet with the block in the right format
 	*/
@@ -3829,30 +2132,19 @@ void Server::SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver, u16 net_proto
 	block->serialize(os, ver, false);
 	block->serializeNetworkSpecific(os, net_proto_version);
 	std::string s = os.str();
-	SharedBuffer<u8> blockdata((u8*)s.c_str(), s.size());
 
-	u32 replysize = 8 + blockdata.getSize();
-	SharedBuffer<u8> reply(replysize);
-	writeU16(&reply[0], TOCLIENT_BLOCKDATA);
-	writeS16(&reply[2], p.X);
-	writeS16(&reply[4], p.Y);
-	writeS16(&reply[6], p.Z);
-	memcpy(&reply[8], *blockdata, blockdata.getSize());
+	NetworkPacket pkt(TOCLIENT_BLOCKDATA, 2 + 2 + 2 + 2 + s.size(), peer_id);
 
-	/*infostream<<"Server: Sending block ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
-			<<":  \tpacket size: "<<replysize<<std::endl;*/
-
-	/*
-		Send packet
-	*/
-	m_clients.send(peer_id, 2, reply, true);
+	pkt << p;
+	pkt.putRawString(s.c_str(), s.size());
+	Send(&pkt);
 }
 
 void Server::SendBlocks(float dtime)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 
-	JMutexAutoLock envlock(m_env_mutex);
+	MutexAutoLock envlock(m_env_mutex);
 	//TODO check if one big lock could be faster then multiple small ones
 
 	ScopeProfiler sp(g_profiler, "Server: sel and send blocks to clients");
@@ -3864,13 +2156,11 @@ void Server::SendBlocks(float dtime)
 	{
 		ScopeProfiler sp(g_profiler, "Server: selecting blocks for sending");
 
-		std::list<u16> clients = m_clients.getClientIDs();
+		std::vector<u16> clients = m_clients.getClientIDs();
 
-		m_clients.Lock();
-		for(std::list<u16>::iterator
-			i = clients.begin();
-			i != clients.end(); ++i)
-		{
+		m_clients.lock();
+		for(std::vector<u16>::iterator i = clients.begin();
+			i != clients.end(); ++i) {
 			RemoteClient *client = m_clients.lockedGetClientNoEx(*i, CS_Active);
 
 			if (client == NULL)
@@ -3879,7 +2169,7 @@ void Server::SendBlocks(float dtime)
 			total_sending += client->SendingCount();
 			client->GetNextBlocks(m_env,m_emerge, dtime, queue);
 		}
-		m_clients.Unlock();
+		m_clients.unlock();
 	}
 
 	// Sort.
@@ -3887,7 +2177,7 @@ void Server::SendBlocks(float dtime)
 	// Lowest is most important.
 	std::sort(queue.begin(), queue.end());
 
-	m_clients.Lock();
+	m_clients.lock();
 	for(u32 i=0; i<queue.size(); i++)
 	{
 		//TODO: Calculate limit dynamically
@@ -3917,19 +2207,19 @@ void Server::SendBlocks(float dtime)
 		client->SentBlock(q.pos);
 		total_sending++;
 	}
-	m_clients.Unlock();
+	m_clients.unlock();
 }
 
 void Server::fillMediaCache()
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 
 	infostream<<"Server: Calculating media file checksums"<<std::endl;
 
 	// Collect all media file paths
-	std::list<std::string> paths;
+	std::vector<std::string> paths;
 	for(std::vector<ModSpec>::iterator i = m_mods.begin();
-			i != m_mods.end(); i++){
+			i != m_mods.end(); ++i) {
 		const ModSpec &mod = *i;
 		paths.push_back(mod.path + DIR_DELIM + "textures");
 		paths.push_back(mod.path + DIR_DELIM + "sounds");
@@ -3939,19 +2229,18 @@ void Server::fillMediaCache()
 	paths.push_back(porting::path_user + DIR_DELIM + "textures" + DIR_DELIM + "server");
 
 	// Collect media file information from paths into cache
-	for(std::list<std::string>::iterator i = paths.begin();
-			i != paths.end(); i++)
-	{
+	for(std::vector<std::string>::iterator i = paths.begin();
+			i != paths.end(); ++i) {
 		std::string mediapath = *i;
 		std::vector<fs::DirListNode> dirlist = fs::GetDirListing(mediapath);
-		for(u32 j=0; j<dirlist.size(); j++){
-			if(dirlist[j].dir) // Ignode dirs
+		for (u32 j = 0; j < dirlist.size(); j++) {
+			if (dirlist[j].dir) // Ignode dirs
 				continue;
 			std::string filename = dirlist[j].name;
 			// If name contains illegal characters, ignore the file
-			if(!string_allowed(filename, TEXTURENAME_ALLOWED_CHARS)){
+			if (!string_allowed(filename, TEXTURENAME_ALLOWED_CHARS)) {
 				infostream<<"Server: ignoring illegal file name: \""
-						<<filename<<"\""<<std::endl;
+						<< filename << "\"" << std::endl;
 				continue;
 			}
 			// If name is not in a supported format, ignore it
@@ -3962,42 +2251,42 @@ void Server::fillMediaCache()
 				".x", ".b3d", ".md2", ".obj",
 				NULL
 			};
-			if(removeStringEnd(filename, supported_ext) == ""){
-				infostream<<"Server: ignoring unsupported file extension: \""
-						<<filename<<"\""<<std::endl;
+			if (removeStringEnd(filename, supported_ext) == ""){
+				infostream << "Server: ignoring unsupported file extension: \""
+						<< filename << "\"" << std::endl;
 				continue;
 			}
 			// Ok, attempt to load the file and add to cache
 			std::string filepath = mediapath + DIR_DELIM + filename;
 			// Read data
 			std::ifstream fis(filepath.c_str(), std::ios_base::binary);
-			if(fis.good() == false){
-				errorstream<<"Server::fillMediaCache(): Could not open \""
-						<<filename<<"\" for reading"<<std::endl;
+			if (!fis.good()) {
+				errorstream << "Server::fillMediaCache(): Could not open \""
+						<< filename << "\" for reading" << std::endl;
 				continue;
 			}
 			std::ostringstream tmp_os(std::ios_base::binary);
 			bool bad = false;
-			for(;;){
+			for(;;) {
 				char buf[1024];
 				fis.read(buf, 1024);
 				std::streamsize len = fis.gcount();
 				tmp_os.write(buf, len);
-				if(fis.eof())
+				if (fis.eof())
 					break;
-				if(!fis.good()){
+				if (!fis.good()) {
 					bad = true;
 					break;
 				}
 			}
-			if(bad){
+			if(bad) {
 				errorstream<<"Server::fillMediaCache(): Failed to read \""
-						<<filename<<"\""<<std::endl;
+						<< filename << "\"" << std::endl;
 				continue;
 			}
-			if(tmp_os.str().length() == 0){
-				errorstream<<"Server::fillMediaCache(): Empty file \""
-						<<filepath<<"\""<<std::endl;
+			if(tmp_os.str().length() == 0) {
+				errorstream << "Server::fillMediaCache(): Empty file \""
+						<< filepath << "\"" << std::endl;
 				continue;
 			}
 
@@ -4010,71 +2299,33 @@ void Server::fillMediaCache()
 			free(digest);
 
 			// Put in list
-			this->m_media[filename] = MediaInfo(filepath, sha1_base64);
-			verbosestream<<"Server: "<<sha1_hex<<" is "<<filename<<std::endl;
+			m_media[filename] = MediaInfo(filepath, sha1_base64);
+			verbosestream << "Server: " << sha1_hex << " is " << filename
+					<< std::endl;
 		}
 	}
 }
 
-struct SendableMediaAnnouncement
-{
-	std::string name;
-	std::string sha1_digest;
-
-	SendableMediaAnnouncement(const std::string &name_="",
-	                          const std::string &sha1_digest_=""):
-		name(name_),
-		sha1_digest(sha1_digest_)
-	{}
-};
-
 void Server::sendMediaAnnouncement(u16 peer_id)
 {
-	DSTACK(__FUNCTION_NAME);
-
-	verbosestream<<"Server: Announcing files to id("<<peer_id<<")"
-			<<std::endl;
+	DSTACK(FUNCTION_NAME);
 
-	std::list<SendableMediaAnnouncement> file_announcements;
-
-	for(std::map<std::string, MediaInfo>::iterator i = m_media.begin();
-			i != m_media.end(); i++){
-		// Put in list
-		file_announcements.push_back(
-				SendableMediaAnnouncement(i->first, i->second.sha1_digest));
-	}
+	verbosestream << "Server: Announcing files to id(" << peer_id << ")"
+		<< std::endl;
 
 	// Make packet
 	std::ostringstream os(std::ios_base::binary);
 
-	/*
-		u16 command
-		u32 number of files
-		for each texture {
-			u16 length of name
-			string name
-			u16 length of sha1_digest
-			string sha1_digest
-		}
-	*/
-
-	writeU16(os, TOCLIENT_ANNOUNCE_MEDIA);
-	writeU16(os, file_announcements.size());
+	NetworkPacket pkt(TOCLIENT_ANNOUNCE_MEDIA, 0, peer_id);
+	pkt << (u16) m_media.size();
 
-	for(std::list<SendableMediaAnnouncement>::iterator
-			j = file_announcements.begin();
-			j != file_announcements.end(); ++j){
-		os<<serializeString(j->name);
-		os<<serializeString(j->sha1_digest);
+	for (std::map<std::string, MediaInfo>::iterator i = m_media.begin();
+			i != m_media.end(); ++i) {
+		pkt << i->first << i->second.sha1_digest;
 	}
-	os<<serializeString(g_settings->get("remote_media"));
-
-	// Make data buffer
-	std::string s = os.str();
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
 
-	// Send as reliable
-	m_clients.send(peer_id, 0, data, true);
+	pkt << g_settings->get("remote_media");
+	Send(&pkt);
 }
 
 struct SendableMedia
@@ -4092,9 +2343,9 @@ struct SendableMedia
 };
 
 void Server::sendRequestedMedia(u16 peer_id,
-		const std::list<std::string> &tosend)
+		const std::vector<std::string> &tosend)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 
 	verbosestream<<"Server::sendRequestedMedia(): "
 			<<"Sending files to client"<<std::endl;
@@ -4104,17 +2355,16 @@ void Server::sendRequestedMedia(u16 peer_id,
 	// Put 5kB in one bunch (this is not accurate)
 	u32 bytes_per_bunch = 5000;
 
-	std::vector< std::list<SendableMedia> > file_bunches;
-	file_bunches.push_back(std::list<SendableMedia>());
+	std::vector< std::vector<SendableMedia> > file_bunches;
+	file_bunches.push_back(std::vector<SendableMedia>());
 
 	u32 file_size_bunch_total = 0;
 
-	for(std::list<std::string>::const_iterator i = tosend.begin();
-			i != tosend.end(); ++i)
-	{
+	for(std::vector<std::string>::const_iterator i = tosend.begin();
+			i != tosend.end(); ++i) {
 		const std::string &name = *i;
 
-		if(m_media.find(name) == m_media.end()){
+		if(m_media.find(name) == m_media.end()) {
 			errorstream<<"Server::sendRequestedMedia(): Client asked for "
 					<<"unknown file \""<<(name)<<"\""<<std::endl;
 			continue;
@@ -4132,7 +2382,7 @@ void Server::sendRequestedMedia(u16 peer_id,
 		}
 		std::ostringstream tmp_os(std::ios_base::binary);
 		bool bad = false;
-		for(;;){
+		for(;;) {
 			char buf[1024];
 			fis.read(buf, 1024);
 			std::streamsize len = fis.gcount();
@@ -4140,12 +2390,12 @@ void Server::sendRequestedMedia(u16 peer_id,
 			file_size_bunch_total += len;
 			if(fis.eof())
 				break;
-			if(!fis.good()){
+			if(!fis.good()) {
 				bad = true;
 				break;
 			}
 		}
-		if(bad){
+		if(bad) {
 			errorstream<<"Server::sendRequestedMedia(): Failed to read \""
 					<<name<<"\""<<std::endl;
 			continue;
@@ -4157,8 +2407,8 @@ void Server::sendRequestedMedia(u16 peer_id,
 				SendableMedia(name, tpath, tmp_os.str()));
 
 		// Start next bunch if got enough data
-		if(file_size_bunch_total >= bytes_per_bunch){
-			file_bunches.push_back(std::list<SendableMedia>());
+		if(file_size_bunch_total >= bytes_per_bunch) {
+			file_bunches.push_back(std::vector<SendableMedia>());
 			file_size_bunch_total = 0;
 		}
 
@@ -4166,11 +2416,8 @@ void Server::sendRequestedMedia(u16 peer_id,
 
 	/* Create and send packets */
 
-	u32 num_bunches = file_bunches.size();
-	for(u32 i=0; i<num_bunches; i++)
-	{
-		std::ostringstream os(std::ios_base::binary);
-
+	u16 num_bunches = file_bunches.size();
+	for(u16 i = 0; i < num_bunches; i++) {
 		/*
 			u16 command
 			u16 total number of texture bunches
@@ -4184,65 +2431,57 @@ void Server::sendRequestedMedia(u16 peer_id,
 			}
 		*/
 
-		writeU16(os, TOCLIENT_MEDIA);
-		writeU16(os, num_bunches);
-		writeU16(os, i);
-		writeU32(os, file_bunches[i].size());
+		NetworkPacket pkt(TOCLIENT_MEDIA, 4 + 0, peer_id);
+		pkt << num_bunches << i << (u32) file_bunches[i].size();
 
-		for(std::list<SendableMedia>::iterator
+		for(std::vector<SendableMedia>::iterator
 				j = file_bunches[i].begin();
-				j != file_bunches[i].end(); ++j){
-			os<<serializeString(j->name);
-			os<<serializeLongString(j->data);
+				j != file_bunches[i].end(); ++j) {
+			pkt << j->name;
+			pkt.putLongString(j->data);
 		}
 
-		// Make data buffer
-		std::string s = os.str();
-		verbosestream<<"Server::sendRequestedMedia(): bunch "
-				<<i<<"/"<<num_bunches
-				<<" files="<<file_bunches[i].size()
-				<<" size=" <<s.size()<<std::endl;
-		SharedBuffer<u8> data((u8*)s.c_str(), s.size());
-		// Send as reliable
-		m_clients.send(peer_id, 2, data, true);
+		verbosestream << "Server::sendRequestedMedia(): bunch "
+				<< i << "/" << num_bunches
+				<< " files=" << file_bunches[i].size()
+				<< " size="  << pkt.getSize() << std::endl;
+		Send(&pkt);
 	}
 }
 
 void Server::sendDetachedInventory(const std::string &name, u16 peer_id)
 {
-	if(m_detached_inventories.count(name) == 0){
-		errorstream<<__FUNCTION_NAME<<": \""<<name<<"\" not found"<<std::endl;
+	if(m_detached_inventories.count(name) == 0) {
+		errorstream<<FUNCTION_NAME<<": \""<<name<<"\" not found"<<std::endl;
 		return;
 	}
 	Inventory *inv = m_detached_inventories[name];
-
 	std::ostringstream os(std::ios_base::binary);
-	writeU16(os, TOCLIENT_DETACHED_INVENTORY);
-	os<<serializeString(name);
+
+	os << serializeString(name);
 	inv->serialize(os);
 
 	// Make data buffer
 	std::string s = os.str();
-	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
 
-	if (peer_id != PEER_ID_INEXISTENT)
-	{
-		// Send as reliable
-		m_clients.send(peer_id, 0, data, true);
+	NetworkPacket pkt(TOCLIENT_DETACHED_INVENTORY, 0, peer_id);
+	pkt.putRawString(s.c_str(), s.size());
+
+	if (peer_id != PEER_ID_INEXISTENT) {
+		Send(&pkt);
 	}
-	else
-	{
-		m_clients.sendToAll(0,data,true);
+	else {
+		m_clients.sendToAll(0, &pkt, true);
 	}
 }
 
 void Server::sendDetachedInventories(u16 peer_id)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 
 	for(std::map<std::string, Inventory*>::iterator
 			i = m_detached_inventories.begin();
-			i != m_detached_inventories.end(); i++){
+			i != m_detached_inventories.end(); ++i) {
 		const std::string &name = i->first;
 		//Inventory *inv = i->second;
 		sendDetachedInventory(name, peer_id);
@@ -4255,14 +2494,14 @@ void Server::sendDetachedInventories(u16 peer_id)
 
 void Server::DiePlayer(u16 peer_id)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 
 	PlayerSAO *playersao = getPlayerSAO(peer_id);
 	assert(playersao);
 
-	infostream<<"Server::DiePlayer(): Player "
-			<<playersao->getPlayer()->getName()
-			<<" dies"<<std::endl;
+	infostream << "Server::DiePlayer(): Player "
+			<< playersao->getPlayer()->getName()
+			<< " dies" << std::endl;
 
 	playersao->setHP(0);
 
@@ -4275,36 +2514,110 @@ void Server::DiePlayer(u16 peer_id)
 
 void Server::RespawnPlayer(u16 peer_id)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 
 	PlayerSAO *playersao = getPlayerSAO(peer_id);
 	assert(playersao);
 
-	infostream<<"Server::RespawnPlayer(): Player "
-			<<playersao->getPlayer()->getName()
-			<<" respawns"<<std::endl;
+	infostream << "Server::RespawnPlayer(): Player "
+			<< playersao->getPlayer()->getName()
+			<< " respawns" << std::endl;
 
 	playersao->setHP(PLAYER_MAX_HP);
+	playersao->setBreath(PLAYER_MAX_BREATH);
+
+	SendPlayerHP(peer_id);
+	SendPlayerBreath(peer_id);
 
 	bool repositioned = m_script->on_respawnplayer(playersao);
 	if(!repositioned){
-		v3f pos = findSpawnPos(m_env->getServerMap());
+		v3f pos = findSpawnPos();
+		// setPos will send the new position to client
 		playersao->setPos(pos);
 	}
 }
 
-void Server::DenyAccess(u16 peer_id, const std::wstring &reason)
+
+void Server::DenySudoAccess(u16 peer_id)
+{
+	DSTACK(FUNCTION_NAME);
+
+	NetworkPacket pkt(TOCLIENT_DENY_SUDO_MODE, 0, peer_id);
+	Send(&pkt);
+}
+
+
+void Server::DenyAccessVerCompliant(u16 peer_id, u16 proto_ver, AccessDeniedCode reason,
+		const std::string &str_reason, bool reconnect)
+{
+	if (proto_ver >= 25) {
+		SendAccessDenied(peer_id, reason, str_reason);
+	} else {
+		std::wstring wreason = utf8_to_wide(
+			reason == SERVER_ACCESSDENIED_CUSTOM_STRING ? str_reason :
+			accessDeniedStrings[(u8)reason]);
+		SendAccessDenied_Legacy(peer_id, wreason);
+	}
+
+	m_clients.event(peer_id, CSE_SetDenied);
+	m_con.DisconnectPeer(peer_id);
+}
+
+
+void Server::DenyAccess(u16 peer_id, AccessDeniedCode reason, const std::string &custom_reason)
+{
+	DSTACK(FUNCTION_NAME);
+
+	SendAccessDenied(peer_id, reason, custom_reason);
+	m_clients.event(peer_id, CSE_SetDenied);
+	m_con.DisconnectPeer(peer_id);
+}
+
+// 13/03/15: remove this function when protocol version 25 will become
+// the minimum version for MT users, maybe in 1 year
+void Server::DenyAccess_Legacy(u16 peer_id, const std::wstring &reason)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 
-	SendAccessDenied(peer_id, reason);
+	SendAccessDenied_Legacy(peer_id, reason);
 	m_clients.event(peer_id, CSE_SetDenied);
 	m_con.DisconnectPeer(peer_id);
 }
 
+void Server::acceptAuth(u16 peer_id, bool forSudoMode)
+{
+	DSTACK(FUNCTION_NAME);
+
+	if (!forSudoMode) {
+		RemoteClient* client = getClient(peer_id, CS_Invalid);
+
+		NetworkPacket resp_pkt(TOCLIENT_AUTH_ACCEPT, 1 + 6 + 8 + 4, peer_id);
+
+		// Right now, the auth mechs don't change between login and sudo mode.
+		u32 sudo_auth_mechs = client->allowed_auth_mechs;
+		client->allowed_sudo_mechs = sudo_auth_mechs;
+
+		resp_pkt << v3f(0,0,0) << (u64) m_env->getServerMap().getSeed()
+				<< g_settings->getFloat("dedicated_server_step")
+				<< sudo_auth_mechs;
+
+		Send(&resp_pkt);
+		m_clients.event(peer_id, CSE_AuthAccept);
+	} else {
+		NetworkPacket resp_pkt(TOCLIENT_ACCEPT_SUDO_MODE, 1 + 6 + 8 + 4, peer_id);
+
+		// We only support SRP right now
+		u32 sudo_auth_mechs = AUTH_MECHANISM_FIRST_SRP;
+
+		resp_pkt << sudo_auth_mechs;
+		Send(&resp_pkt);
+		m_clients.event(peer_id, CSE_SudoSuccess);
+	}
+}
+
 void Server::DeleteClient(u16 peer_id, ClientDeletionReason reason)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 	std::wstring message;
 	{
 		/*
@@ -4316,10 +2629,10 @@ void Server::DeleteClient(u16 peer_id, ClientDeletionReason reason)
 		{
 			ServerPlayingSound &psound = i->second;
 			psound.clients.erase(peer_id);
-			if(psound.clients.size() == 0)
+			if(psound.clients.empty())
 				m_playing_sounds.erase(i++);
 			else
-				i++;
+				++i;
 		}
 
 		Player *player = m_env->getPlayer(peer_id);
@@ -4354,30 +2667,28 @@ void Server::DeleteClient(u16 peer_id, ClientDeletionReason reason)
 			Print out action
 		*/
 		{
-			if(player != NULL && reason != CDR_DENY)
-			{
+			if(player != NULL && reason != CDR_DENY) {
 				std::ostringstream os(std::ios_base::binary);
-				std::list<u16> clients = m_clients.getClientIDs();
+				std::vector<u16> clients = m_clients.getClientIDs();
 
-				for(std::list<u16>::iterator
-					i = clients.begin();
-					i != clients.end(); ++i)
-				{
+				for(std::vector<u16>::iterator i = clients.begin();
+					i != clients.end(); ++i) {
 					// Get player
 					Player *player = m_env->getPlayer(*i);
 					if(!player)
 						continue;
+
 					// Get name of player
-					os<<player->getName()<<" ";
+					os << player->getName() << " ";
 				}
 
-				actionstream<<player->getName()<<" "
-						<<(reason==CDR_TIMEOUT?"times out.":"leaves game.")
-						<<" List of players: "<<os.str()<<std::endl;
+				actionstream << player->getName() << " "
+						<< (reason == CDR_TIMEOUT ? "times out." : "leaves game.")
+						<< " List of players: " << os.str() << std::endl;
 			}
 		}
 		{
-			JMutexAutoLock env_lock(m_env_mutex);
+			MutexAutoLock env_lock(m_env_mutex);
 			m_clients.DeleteClient(peer_id);
 		}
 	}
@@ -4387,24 +2698,22 @@ void Server::DeleteClient(u16 peer_id, ClientDeletionReason reason)
 		SendChatMessage(PEER_ID_INEXISTENT,message);
 }
 
-void Server::UpdateCrafting(u16 peer_id)
+void Server::UpdateCrafting(Player* player)
 {
-	DSTACK(__FUNCTION_NAME);
-
-	Player* player = m_env->getPlayer(peer_id);
-	assert(player);
+	DSTACK(FUNCTION_NAME);
 
 	// Get a preview for crafting
 	ItemStack preview;
 	InventoryLocation loc;
 	loc.setPlayer(player->getName());
-	getCraftingResult(&player->inventory, preview, false, this);
+	std::vector<ItemStack> output_replacements;
+	getCraftingResult(&player->inventory, preview, output_replacements, false, this);
 	m_env->getScriptIface()->item_CraftPredict(preview, player->getPlayerSAO(), (&player->inventory)->getList("craft"), loc);
 
 	// Put the new preview in
 	InventoryList *plist = player->inventory.getList("craftpreview");
-	assert(plist);
-	assert(plist->getSize() >= 1);
+	sanity_check(plist);
+	sanity_check(plist->getSize() >= 1);
 	plist->changeItem(0, preview);
 }
 
@@ -4442,7 +2751,7 @@ std::wstring Server::getStatusString()
 	std::wostringstream os(std::ios_base::binary);
 	os<<L"# Server: ";
 	// Version
-	os<<L"version="<<narrow_to_wide(minetest_version_simple);
+	os<<L"version="<<narrow_to_wide(g_version_string);
 	// Uptime
 	os<<L", uptime="<<m_uptime.get();
 	// Max lag estimate
@@ -4450,10 +2759,9 @@ std::wstring Server::getStatusString()
 	// Information about clients
 	bool first = true;
 	os<<L", clients={";
-	std::list<u16> clients = m_clients.getClientIDs();
-	for(std::list<u16>::iterator i = clients.begin();
-		i != clients.end(); ++i)
-	{
+	std::vector<u16> clients = m_clients.getClientIDs();
+	for(std::vector<u16>::iterator i = clients.begin();
+		i != clients.end(); ++i) {
 		// Get player
 		Player *player = m_env->getPlayer(*i);
 		// Get name of player
@@ -4462,12 +2770,12 @@ std::wstring Server::getStatusString()
 			name = narrow_to_wide(player->getName());
 		// Add name to information string
 		if(!first)
-			os<<L",";
+			os << L", ";
 		else
 			first = false;
-		os<<name;
+		os << name;
 	}
-	os<<L"}";
+	os << L"}";
 	if(((ServerMap*)(&m_env->getMap()))->isSavingEnabled() == false)
 		os<<std::endl<<L"# Server: "<<" WARNING: Map saving is disabled.";
 	if(g_settings->get("motd") != "")
@@ -4490,11 +2798,10 @@ bool Server::checkPriv(const std::string &name, const std::string &priv)
 
 void Server::reportPrivsModified(const std::string &name)
 {
-	if(name == ""){
-		std::list<u16> clients = m_clients.getClientIDs();
-		for(std::list<u16>::iterator
-				i = clients.begin();
-				i != clients.end(); ++i){
+	if(name == "") {
+		std::vector<u16> clients = m_clients.getClientIDs();
+		for(std::vector<u16>::iterator i = clients.begin();
+				i != clients.end(); ++i) {
 			Player *player = m_env->getPlayer(*i);
 			reportPrivsModified(player->getName());
 		}
@@ -4537,8 +2844,12 @@ std::string Server::getBanDescription(const std::string &ip_or_name)
 
 void Server::notifyPlayer(const char *name, const std::wstring &msg)
 {
+	// m_env will be NULL if the server is initializing
+	if (!m_env)
+		return;
+
 	Player *player = m_env->getPlayer(name);
-	if(!player)
+	if (!player)
 		return;
 
 	if (player->peer_id == PEER_ID_INEXISTENT)
@@ -4547,24 +2858,26 @@ void Server::notifyPlayer(const char *name, const std::wstring &msg)
 	SendChatMessage(player->peer_id, msg);
 }
 
-bool Server::showFormspec(const char *playername, const std::string &formspec, const std::string &formname)
+bool Server::showFormspec(const char *playername, const std::string &formspec,
+	const std::string &formname)
 {
-	Player *player = m_env->getPlayer(playername);
+	// m_env will be NULL if the server is initializing
+	if (!m_env)
+		return false;
 
-	if(!player)
-	{
-		infostream<<"showFormspec: couldn't find player:"<<playername<<std::endl;
+	Player *player = m_env->getPlayer(playername);
+	if (!player)
 		return false;
-	}
 
 	SendShowFormspecMessage(player->peer_id, formspec, formname);
 	return true;
 }
 
-u32 Server::hudAdd(Player *player, HudElement *form) {
+u32 Server::hudAdd(Player *player, HudElement *form)
+{
 	if (!player)
 		return -1;
-	
+
 	u32 id = player->addHud(form);
 
 	SendHUDAdd(player->peer_id, id, form);
@@ -4580,14 +2893,15 @@ bool Server::hudRemove(Player *player, u32 id) {
 
 	if (!todel)
 		return false;
-	
+
 	delete todel;
 
 	SendHUDRemove(player->peer_id, id);
 	return true;
 }
 
-bool Server::hudChange(Player *player, u32 id, HudElementStat stat, void *data) {
+bool Server::hudChange(Player *player, u32 id, HudElementStat stat, void *data)
+{
 	if (!player)
 		return false;
 
@@ -4595,15 +2909,16 @@ bool Server::hudChange(Player *player, u32 id, HudElementStat stat, void *data)
 	return true;
 }
 
-bool Server::hudSetFlags(Player *player, u32 flags, u32 mask) {
+bool Server::hudSetFlags(Player *player, u32 flags, u32 mask)
+{
 	if (!player)
 		return false;
 
 	SendHUDSetFlags(player->peer_id, flags, mask);
 	player->hud_flags = flags;
-	
+
 	PlayerSAO* playersao = player->getPlayerSAO();
-	
+
 	if (playersao == NULL)
 		return false;
 
@@ -4611,37 +2926,67 @@ bool Server::hudSetFlags(Player *player, u32 flags, u32 mask) {
 	return true;
 }
 
-bool Server::hudSetHotbarItemcount(Player *player, s32 hotbar_itemcount) {
+bool Server::hudSetHotbarItemcount(Player *player, s32 hotbar_itemcount)
+{
 	if (!player)
 		return false;
 	if (hotbar_itemcount <= 0 || hotbar_itemcount > HUD_HOTBAR_ITEMCOUNT_MAX)
 		return false;
 
+	player->setHotbarItemcount(hotbar_itemcount);
 	std::ostringstream os(std::ios::binary);
 	writeS32(os, hotbar_itemcount);
 	SendHUDSetParam(player->peer_id, HUD_PARAM_HOTBAR_ITEMCOUNT, os.str());
 	return true;
 }
 
-void Server::hudSetHotbarImage(Player *player, std::string name) {
+s32 Server::hudGetHotbarItemcount(Player *player)
+{
+	if (!player)
+		return 0;
+	return player->getHotbarItemcount();
+}
+
+void Server::hudSetHotbarImage(Player *player, std::string name)
+{
 	if (!player)
 		return;
 
+	player->setHotbarImage(name);
 	SendHUDSetParam(player->peer_id, HUD_PARAM_HOTBAR_IMAGE, name);
 }
 
-void Server::hudSetHotbarSelectedImage(Player *player, std::string name) {
+std::string Server::hudGetHotbarImage(Player *player)
+{
+	if (!player)
+		return "";
+	return player->getHotbarImage();
+}
+
+void Server::hudSetHotbarSelectedImage(Player *player, std::string name)
+{
 	if (!player)
 		return;
 
+	player->setHotbarSelectedImage(name);
 	SendHUDSetParam(player->peer_id, HUD_PARAM_HOTBAR_SELECTED_IMAGE, name);
 }
 
-bool Server::setLocalPlayerAnimations(Player *player, v2s32 animation_frames[4], f32 frame_speed)
+std::string Server::hudGetHotbarSelectedImage(Player *player)
+{
+	if (!player)
+		return "";
+
+	return player->getHotbarSelectedImage();
+}
+
+bool Server::setLocalPlayerAnimations(Player *player,
+	v2s32 animation_frames[4], f32 frame_speed)
 {
 	if (!player)
 		return false;
 
+	player->setLocalAnimations(animation_frames, frame_speed);
 	SendLocalPlayerAnimations(player->peer_id, animation_frames, frame_speed);
 	return true;
 }
@@ -4651,26 +2996,30 @@ bool Server::setPlayerEyeOffset(Player *player, v3f first, v3f third)
 	if (!player)
 		return false;
 
+	player->eye_offset_first = first;
+	player->eye_offset_third = third;
 	SendEyeOffset(player->peer_id, first, third);
 	return true;
 }
 
 bool Server::setSky(Player *player, const video::SColor &bgcolor,
-		const std::string &type, const std::vector<std::string> &params)
+	const std::string &type, const std::vector<std::string> &params)
 {
 	if (!player)
 		return false;
 
+	player->setSky(bgcolor, type, params);
 	SendSetSky(player->peer_id, bgcolor, type, params);
 	return true;
 }
 
 bool Server::overrideDayNightRatio(Player *player, bool do_override,
-		float ratio)
+	float ratio)
 {
 	if (!player)
 		return false;
 
+	player->overrideDayNightRatio(do_override, ratio);
 	SendOverrideDayNightRatio(player->peer_id, do_override, ratio);
 	return true;
 }
@@ -4680,68 +3029,45 @@ void Server::notifyPlayers(const std::wstring &msg)
 	SendChatMessage(PEER_ID_INEXISTENT,msg);
 }
 
-void Server::spawnParticle(const char *playername, v3f pos,
-		v3f velocity, v3f acceleration,
-		float expirationtime, float size, bool
-		collisiondetection, bool vertical, std::string texture)
+void Server::spawnParticle(const std::string &playername, v3f pos,
+	v3f velocity, v3f acceleration,
+	float expirationtime, float size, bool
+	collisiondetection, bool vertical, const std::string &texture)
 {
-	Player *player = m_env->getPlayer(playername);
-	if(!player)
+	// m_env will be NULL if the server is initializing
+	if (!m_env)
 		return;
-	SendSpawnParticle(player->peer_id, pos, velocity, acceleration,
-			expirationtime, size, collisiondetection, vertical, texture);
-}
 
-void Server::spawnParticleAll(v3f pos, v3f velocity, v3f acceleration,
-		float expirationtime, float size,
-		bool collisiondetection, bool vertical, std::string texture)
-{
-	SendSpawnParticle(PEER_ID_INEXISTENT,pos, velocity, acceleration,
+	u16 peer_id = PEER_ID_INEXISTENT;
+	if (playername != "") {
+		Player* player = m_env->getPlayer(playername.c_str());
+		if (!player)
+			return;
+		peer_id = player->peer_id;
+	}
+
+	SendSpawnParticle(peer_id, pos, velocity, acceleration,
 			expirationtime, size, collisiondetection, vertical, texture);
 }
 
-u32 Server::addParticleSpawner(const char *playername,
-		u16 amount, float spawntime,
-		v3f minpos, v3f maxpos,
-		v3f minvel, v3f maxvel,
-		v3f minacc, v3f maxacc,
-		float minexptime, float maxexptime,
-		float minsize, float maxsize,
-		bool collisiondetection, bool vertical, std::string texture)
+u32 Server::addParticleSpawner(u16 amount, float spawntime,
+	v3f minpos, v3f maxpos, v3f minvel, v3f maxvel, v3f minacc, v3f maxacc,
+	float minexptime, float maxexptime, float minsize, float maxsize,
+	bool collisiondetection, bool vertical, const std::string &texture,
+	const std::string &playername)
 {
-	Player *player = m_env->getPlayer(playername);
-	if(!player)
+	// m_env will be NULL if the server is initializing
+	if (!m_env)
 		return -1;
 
-	u32 id = 0;
-	for(;;) // look for unused particlespawner id
-	{
-		id++;
-		if (std::find(m_particlespawner_ids.begin(),
-				m_particlespawner_ids.end(), id)
-				== m_particlespawner_ids.end())
-		{
-			m_particlespawner_ids.push_back(id);
-			break;
-		}
+	u16 peer_id = PEER_ID_INEXISTENT;
+	if (playername != "") {
+		Player* player = m_env->getPlayer(playername.c_str());
+		if (!player)
+			return -1;
+		peer_id = player->peer_id;
 	}
 
-	SendAddParticleSpawner(player->peer_id, amount, spawntime,
-		minpos, maxpos, minvel, maxvel, minacc, maxacc,
-		minexptime, maxexptime, minsize, maxsize,
-		collisiondetection, vertical, texture, id);
-
-	return id;
-}
-
-u32 Server::addParticleSpawnerAll(u16 amount, float spawntime,
-		v3f minpos, v3f maxpos,
-		v3f minvel, v3f maxvel,
-		v3f minacc, v3f maxacc,
-		float minexptime, float maxexptime,
-		float minsize, float maxsize,
-		bool collisiondetection, bool vertical, std::string texture)
-{
 	u32 id = 0;
 	for(;;) // look for unused particlespawner id
 	{
@@ -4755,7 +3081,7 @@ u32 Server::addParticleSpawnerAll(u16 amount, float spawntime,
 		}
 	}
 
-	SendAddParticleSpawner(PEER_ID_INEXISTENT, amount, spawntime,
+	SendAddParticleSpawner(peer_id, amount, spawntime,
 		minpos, maxpos, minvel, maxvel, minacc, maxacc,
 		minexptime, maxexptime, minsize, maxsize,
 		collisiondetection, vertical, texture, id);
@@ -4763,26 +3089,25 @@ u32 Server::addParticleSpawnerAll(u16 amount, float spawntime,
 	return id;
 }
 
-void Server::deleteParticleSpawner(const char *playername, u32 id)
+void Server::deleteParticleSpawner(const std::string &playername, u32 id)
 {
-	Player *player = m_env->getPlayer(playername);
-	if(!player)
-		return;
+	// m_env will be NULL if the server is initializing
+	if (!m_env)
+		throw ServerError("Can't delete particle spawners during initialisation!");
 
-	m_particlespawner_ids.erase(
-			std::remove(m_particlespawner_ids.begin(),
-			m_particlespawner_ids.end(), id),
-			m_particlespawner_ids.end());
-	SendDeleteParticleSpawner(player->peer_id, id);
-}
+	u16 peer_id = PEER_ID_INEXISTENT;
+	if (playername != "") {
+		Player* player = m_env->getPlayer(playername.c_str());
+		if (!player)
+			return;
+		peer_id = player->peer_id;
+	}
 
-void Server::deleteParticleSpawnerAll(u32 id)
-{
 	m_particlespawner_ids.erase(
 			std::remove(m_particlespawner_ids.begin(),
 			m_particlespawner_ids.end(), id),
 			m_particlespawner_ids.end());
-	SendDeleteParticleSpawner(PEER_ID_INEXISTENT, id);
+	SendDeleteParticleSpawner(peer_id, id);
 }
 
 Inventory* Server::createDetachedInventory(const std::string &name)
@@ -4794,31 +3119,13 @@ Inventory* Server::createDetachedInventory(const std::string &name)
 		infostream<<"Server creating detached inventory \""<<name<<"\""<<std::endl;
 	}
 	Inventory *inv = new Inventory(m_itemdef);
-	assert(inv);
+	sanity_check(inv);
 	m_detached_inventories[name] = inv;
 	//TODO find a better way to do this
 	sendDetachedInventory(name,PEER_ID_INEXISTENT);
 	return inv;
 }
 
-class BoolScopeSet
-{
-public:
-	BoolScopeSet(bool *dst, bool val):
-		m_dst(dst)
-	{
-		m_orig_state = *m_dst;
-		*m_dst = val;
-	}
-	~BoolScopeSet()
-	{
-		*m_dst = m_orig_state;
-	}
-private:
-	bool *m_dst;
-	bool m_orig_state;
-};
-
 // actions: time-reversed list
 // Return value: success/failure
 bool Server::rollbackRevertActions(const std::list<RollbackAction> &actions,
@@ -4826,8 +3133,6 @@ bool Server::rollbackRevertActions(const std::list<RollbackAction> &actions,
 {
 	infostream<<"Server::rollbackRevertActions(len="<<actions.size()<<")"<<std::endl;
 	ServerMap *map = (ServerMap*)(&m_env->getMap());
-	// Disable rollback report sink while reverting
-	BoolScopeSet rollback_scope_disable(&m_rollback_sink_enabled, false);
 
 	// Fail if no actions to handle
 	if(actions.empty()){
@@ -4840,7 +3145,7 @@ bool Server::rollbackRevertActions(const std::list<RollbackAction> &actions,
 
 	for(std::list<RollbackAction>::const_iterator
 			i = actions.begin();
-			i != actions.end(); i++)
+			i != actions.end(); ++i)
 	{
 		const RollbackAction &action = *i;
 		num_tried++;
@@ -4870,99 +3175,100 @@ bool Server::rollbackRevertActions(const std::list<RollbackAction> &actions,
 
 // IGameDef interface
 // Under envlock
-IItemDefManager* Server::getItemDefManager()
+IItemDefManager *Server::getItemDefManager()
 {
 	return m_itemdef;
 }
-INodeDefManager* Server::getNodeDefManager()
+
+INodeDefManager *Server::getNodeDefManager()
 {
 	return m_nodedef;
 }
-ICraftDefManager* Server::getCraftDefManager()
+
+ICraftDefManager *Server::getCraftDefManager()
 {
 	return m_craftdef;
 }
-ITextureSource* Server::getTextureSource()
+ITextureSource *Server::getTextureSource()
 {
 	return NULL;
 }
-IShaderSource* Server::getShaderSource()
+IShaderSource *Server::getShaderSource()
 {
 	return NULL;
 }
+scene::ISceneManager *Server::getSceneManager()
+{
+	return NULL;
+}
+
 u16 Server::allocateUnknownNodeId(const std::string &name)
 {
 	return m_nodedef->allocateDummy(name);
 }
-ISoundManager* Server::getSoundManager()
+
+ISoundManager *Server::getSoundManager()
 {
 	return &dummySoundManager;
 }
-MtEventManager* Server::getEventManager()
+
+MtEventManager *Server::getEventManager()
 {
 	return m_event;
 }
-IRollbackReportSink* Server::getRollbackReportSink()
-{
-	if(!m_enable_rollback_recording)
-		return NULL;
-	if(!m_rollback_sink_enabled)
-		return NULL;
-	return m_rollback;
-}
 
-IWritableItemDefManager* Server::getWritableItemDefManager()
+IWritableItemDefManager *Server::getWritableItemDefManager()
 {
 	return m_itemdef;
 }
-IWritableNodeDefManager* Server::getWritableNodeDefManager()
+
+IWritableNodeDefManager *Server::getWritableNodeDefManager()
 {
 	return m_nodedef;
 }
-IWritableCraftDefManager* Server::getWritableCraftDefManager()
+
+IWritableCraftDefManager *Server::getWritableCraftDefManager()
 {
 	return m_craftdef;
 }
 
-const ModSpec* Server::getModSpec(const std::string &modname)
+const ModSpec *Server::getModSpec(const std::string &modname) const
 {
-	for(std::vector<ModSpec>::iterator i = m_mods.begin();
-			i != m_mods.end(); i++){
-		const ModSpec &mod = *i;
-		if(mod.name == modname)
+	std::vector<ModSpec>::const_iterator it;
+	for (it = m_mods.begin(); it != m_mods.end(); ++it) {
+		const ModSpec &mod = *it;
+		if (mod.name == modname)
 			return &mod;
 	}
 	return NULL;
 }
-void Server::getModNames(std::list<std::string> &modlist)
+
+void Server::getModNames(std::vector<std::string> &modlist)
 {
-	for(std::vector<ModSpec>::iterator i = m_mods.begin(); i != m_mods.end(); i++)
-	{
-		modlist.push_back(i->name);
-	}
+	std::vector<ModSpec>::iterator it;
+	for (it = m_mods.begin(); it != m_mods.end(); ++it)
+		modlist.push_back(it->name);
 }
+
 std::string Server::getBuiltinLuaPath()
 {
 	return porting::path_share + DIR_DELIM + "builtin";
 }
 
-v3f findSpawnPos(ServerMap &map)
+v3f Server::findSpawnPos()
 {
-	//return v3f(50,50,50)*BS;
-
-	v3s16 nodepos;
-
-#if 0
-	nodepos = v2s16(0,0);
-	groundheight = 20;
-#endif
+	ServerMap &map = m_env->getServerMap();
+	v3f nodeposf;
+	if (g_settings->getV3FNoEx("static_spawnpoint", nodeposf)) {
+		return nodeposf * BS;
+	}
 
-#if 1
 	s16 water_level = map.getWaterLevel();
 
+	bool is_good = false;
+
 	// Try to find a good place a few times
-	for(s32 i=0; i<1000; i++)
-	{
+	for(s32 i = 0; i < 1000 && !is_good; i++) {
 		s32 range = 1 + i;
 		// We're going to try to throw the player to this position
 		v2s16 nodepos2d = v2s16(
@@ -4976,8 +3282,8 @@ v3f findSpawnPos(ServerMap &map)
 		if (groundheight > water_level + 6) // Don't go to high places
 			continue;
 
-		nodepos = v3s16(nodepos2d.X, groundheight, nodepos2d.Y);
-		bool is_good = false;
+		v3s16 nodepos(nodepos2d.X, groundheight, nodepos2d.Y);
+
 		s32 air_count = 0;
 		for (s32 i = 0; i < 10; i++) {
 			v3s16 blockpos = getNodeBlockPos(nodepos);
@@ -4985,33 +3291,30 @@ v3f findSpawnPos(ServerMap &map)
 			content_t c = map.getNodeNoEx(nodepos).getContent();
 			if (c == CONTENT_AIR || c == CONTENT_IGNORE) {
 				air_count++;
-				if (air_count >= 2){
+				if (air_count >= 2) {
+					nodeposf = intToFloat(nodepos, BS);
+					// Don't spawn the player outside map boundaries
+					if (objectpos_over_limit(nodeposf))
+						continue;
 					is_good = true;
 					break;
 				}
 			}
 			nodepos.Y++;
 		}
-		if(is_good){
-			// Found a good place
-			//infostream<<"Searched through "<<i<<" places."<<std::endl;
-			break;
-		}
 	}
-#endif
 
-	return intToFloat(nodepos, BS);
+	return nodeposf;
 }
 
-PlayerSAO* Server::emergePlayer(const char *name, u16 peer_id)
+PlayerSAO* Server::emergePlayer(const char *name, u16 peer_id, u16 proto_version)
 {
-	RemotePlayer *player = NULL;
 	bool newplayer = false;
 
 	/*
 		Try to get an existing player
 	*/
-	player = static_cast<RemotePlayer*>(m_env->getPlayer(name));
+	RemotePlayer *player = static_cast<RemotePlayer*>(m_env->getPlayer(name));
 
 	// If player is already connected, cancel
 	if(player != NULL && player->peer_id != 0)
@@ -5038,16 +3341,28 @@ PlayerSAO* Server::emergePlayer(const char *name, u16 peer_id)
 	// Create player if it doesn't exist
 	if (!player) {
 		newplayer = true;
-		player = new RemotePlayer(this);
-		player->updateName(name);
-		/* Set player position */
+		player = new RemotePlayer(this, name);
+		// Set player position
 		infostream<<"Server: Finding spawn place for player \""
 				<<name<<"\""<<std::endl;
-		v3f pos = findSpawnPos(m_env->getServerMap());
+		v3f pos = findSpawnPos();
 		player->setPosition(pos);
 
-		/* Add player to environment */
+		// Make sure the player is saved
+		player->setModified(true);
+
+		// Add player to environment
 		m_env->addPlayer(player);
+	} else {
+		// If the player exists, ensure that they respawn inside legal bounds
+		// This fixes an assert crash when the player can't be added
+		// to the environment
+		if (objectpos_over_limit(player->getPosition())) {
+			actionstream << "Respawn position for player \""
+				<< name << "\" outside limits, resetting" << std::endl;
+			v3f pos = findSpawnPos();
+			player->setPosition(pos);
+		}
 	}
 
 	// Create a new player active object
@@ -5055,6 +3370,8 @@ PlayerSAO* Server::emergePlayer(const char *name, u16 peer_id)
 			getPlayerEffectivePrivs(player->getName()),
 			isSingleplayer());
 
+	player->protocol_version = proto_version;
+
 	/* Clean up old HUD elements from previous sessions */
 	player->clearHud();
 
@@ -5071,7 +3388,7 @@ PlayerSAO* Server::emergePlayer(const char *name, u16 peer_id)
 
 void dedicated_server_loop(Server &server, bool &kill)
 {
-	DSTACK(__FUNCTION_NAME);
+	DSTACK(FUNCTION_NAME);
 
 	verbosestream<<"dedicated_server_loop()"<<std::endl;
 
@@ -5092,8 +3409,8 @@ void dedicated_server_loop(Server &server, bool &kill)
 		{
 			infostream<<"Dedicated server quitting"<<std::endl;
 #if USE_CURL
-			if(g_settings->getBool("server_announce") == true)
-				ServerList::sendAnnounce("delete");
+			if(g_settings->getBool("server_announce"))
+				ServerList::sendAnnounce("delete", server.m_bind_addr.getPort());
 #endif
 			break;
 		}
@@ -5114,5 +3431,3 @@ void dedicated_server_loop(Server &server, bool &kill)
 		}
 	}
 }
-
-