Merged Minetest

11 files changed, 342 insertions, 303 deletions

diff --git a/src/network/CMakeLists.txt b/src/network/CMakeLists.txt
index c6995ab22..d2e2f52e9 100644
--- a/src/network/CMakeLists.txt
+++ b/src/network/CMakeLists.txt
@@ -16,8 +16,3 @@ if (BUILD_CLIENT)
 		PARENT_SCOPE
 	)
 endif()
-
-# Haiku networking support
-if(HAIKU)
-	set(PLATFORM_LIBS -lnetwork ${PLATFORM_LIBS})
-endif()
diff --git a/src/network/clientopcodes.cpp b/src/network/clientopcodes.cpp
index f812a08a1..55cfdd4dc 100644
--- a/src/network/clientopcodes.cpp
+++ b/src/network/clientopcodes.cpp
@@ -122,6 +122,7 @@ const ToClientCommandHandler toClientCommandTable[TOCLIENT_NUM_MSG_TYPES] =
 	null_command_handler,
 	{ "TOCLIENT_SRP_BYTES_S_B",            TOCLIENT_STATE_NOT_CONNECTED, &Client::handleCommand_SrpBytesSandB }, // 0x60
 	{ "TOCLIENT_FORMSPEC_PREPEND",         TOCLIENT_STATE_CONNECTED, &Client::handleCommand_FormspecPrepend }, // 0x61,
+	{ "TOCLIENT_MINIMAP_MODES",            TOCLIENT_STATE_CONNECTED, &Client::handleCommand_MinimapModes }, // 0x62,
 };
 
 const static ServerCommandFactory null_command_factory = { "TOSERVER_NULL", 0, false };
diff --git a/src/network/clientpackethandler.cpp b/src/network/clientpackethandler.cpp
index a3f1e668d..c39586f2c 100644
--- a/src/network/clientpackethandler.cpp
+++ b/src/network/clientpackethandler.cpp
@@ -504,7 +504,7 @@ void Client::handleCommand_ActiveObjectMessages(NetworkPacket* pkt)
 			if (!is.good())
 				break;
 
-			std::string message = deSerializeString(is);
+			std::string message = deSerializeString16(is);
 
 			// Pass on to the environment
 			m_env.processActiveObjectMessage(id, message);
@@ -1017,7 +1017,7 @@ void Client::handleCommand_AddParticleSpawner(NetworkPacket* pkt)
 	p.minsize            = readF32(is);
 	p.maxsize            = readF32(is);
 	p.collisiondetection = readU8(is);
-	p.texture            = deSerializeLongString(is);
+	p.texture            = deSerializeString32(is);
 
 	server_id = readU32(is);
 
@@ -1185,26 +1185,32 @@ void Client::handleCommand_HudSetFlags(NetworkPacket* pkt)
 	player->hud_flags |= flags;
 
 	if (g_settings->getBool("hud_flags_bypass"))
-		player->hud_flags = HUD_FLAG_HOTBAR_VISIBLE    | HUD_FLAG_HEALTHBAR_VISIBLE |
+		player->hud_flags = HUD_FLAG_HOTBAR_VISIBLE	| HUD_FLAG_HEALTHBAR_VISIBLE |
 			HUD_FLAG_CROSSHAIR_VISIBLE | HUD_FLAG_WIELDITEM_VISIBLE |
 			HUD_FLAG_BREATHBAR_VISIBLE | HUD_FLAG_MINIMAP_VISIBLE   |
 			HUD_FLAG_MINIMAP_RADAR_VISIBLE;
-	
 
 	m_minimap_disabled_by_server = !(player->hud_flags & HUD_FLAG_MINIMAP_VISIBLE);
 	bool m_minimap_radar_disabled_by_server = !(player->hud_flags & HUD_FLAG_MINIMAP_RADAR_VISIBLE);
 
+	// Not so satisying code to keep compatibility with old fixed mode system
+	// -->
+
 	// Hide minimap if it has been disabled by the server
 	if (m_minimap && m_minimap_disabled_by_server && was_minimap_visible)
 		// defers a minimap update, therefore only call it if really
 		// needed, by checking that minimap was visible before
-		m_minimap->setMinimapMode(MINIMAP_MODE_OFF);
-
-	// Switch to surface mode if radar disabled by server
-	if (m_minimap && m_minimap_radar_disabled_by_server && was_minimap_radar_visible)
-		m_minimap->setMinimapMode(MINIMAP_MODE_SURFACEx1);
-		
-
+		m_minimap->setModeIndex(0);
+
+	// If radar has been disabled, try to find a non radar mode or fall back to 0
+	if (m_minimap && m_minimap_radar_disabled_by_server
+			&& was_minimap_radar_visible) {
+		while (m_minimap->getModeIndex() > 0 &&
+				m_minimap->getModeDef().type == MINIMAP_TYPE_RADAR)
+			m_minimap->nextMode();
+	}
+	// <--
+	// End of 'not so satifying code'
 }
 
 void Client::handleCommand_HudSetParam(NetworkPacket* pkt)
@@ -1239,11 +1245,11 @@ void Client::handleCommand_HudSetSky(NetworkPacket* pkt)
 
 		SkyboxParams skybox;
 		skybox.bgcolor = video::SColor(readARGB8(is));
-		skybox.type = std::string(deSerializeString(is));
+		skybox.type = std::string(deSerializeString16(is));
 		u16 count = readU16(is);
 
 		for (size_t i = 0; i < count; i++)
-			skybox.textures.emplace_back(deSerializeString(is));
+			skybox.textures.emplace_back(deSerializeString16(is));
 
 		skybox.clouds = true;
 		try {
@@ -1645,3 +1651,30 @@ void Client::handleCommand_ModChannelSignal(NetworkPacket *pkt)
 	if (valid_signal)
 		m_script->on_modchannel_signal(channel, signal);
 }
+
+void Client::handleCommand_MinimapModes(NetworkPacket *pkt)
+{
+	u16 count; // modes
+	u16 mode;  // wanted current mode index after change
+
+	*pkt >> count >> mode;
+
+	if (m_minimap)
+		m_minimap->clearModes();
+
+	for (size_t index = 0; index < count; index++) {
+		u16 type;
+		std::string label;
+		u16 size;
+		std::string texture;
+		u16 scale;
+
+		*pkt >> type >> label >> size >> texture >> scale;
+
+		if (m_minimap)
+			m_minimap->addMode(MinimapType(type), size, label, texture, scale);
+	}
+
+	if (m_minimap)
+		m_minimap->setModeIndex(mode);
+}
diff --git a/src/network/connection.cpp b/src/network/connection.cpp
index 3692e45a9..0ba8c36b2 100644
--- a/src/network/connection.cpp
+++ b/src/network/connection.cpp
@@ -1269,7 +1269,8 @@ bool Connection::deletePeer(session_t peer_id, bool timeout)
 			return false;
 		peer = m_peers[peer_id];
 		m_peers.erase(peer_id);
-		m_peer_ids.remove(peer_id);
+		auto it = std::find(m_peer_ids.begin(), m_peer_ids.end(), peer_id);
+		m_peer_ids.erase(it);
 	}
 
 	Address peer_address;
@@ -1565,7 +1566,7 @@ void Connection::sendAck(session_t peer_id, u8 channelnum, u16 seqnum)
 
 UDPPeer* Connection::createServerPeer(Address& address)
 {
-	if (getPeerNoEx(PEER_ID_SERVER) != 0)
+	if (ConnectedToServer())
 	{
 		throw ConnectionException("Already connected to a server");
 	}
diff --git a/src/network/connection.h b/src/network/connection.h
index 47b0805ce..24cd4fe4a 100644
--- a/src/network/connection.h
+++ b/src/network/connection.h
@@ -30,7 +30,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "networkprotocol.h"
 #include <iostream>
 #include <fstream>
-#include <list>
+#include <vector>
 #include <map>
 
 class NetworkPacket;
@@ -795,7 +795,7 @@ protected:
 
 	void PrintInfo(std::ostream &out);
 
-	std::list<session_t> getPeerIDs()
+	std::vector<session_t> getPeerIDs()
 	{
 		MutexAutoLock peerlock(m_peers_mutex);
 		return m_peer_ids;
@@ -809,6 +809,11 @@ protected:
 	void putEvent(ConnectionEvent &e);
 
 	void TriggerSend();
+	
+	bool ConnectedToServer() 
+	{
+		return getPeerNoEx(PEER_ID_SERVER) != nullptr;
+	}
 private:
 	MutexedQueue<ConnectionEvent> m_event_queue;
 
@@ -816,7 +821,7 @@ private:
 	u32 m_protocol_id;
 
 	std::map<session_t, Peer *> m_peers;
-	std::list<session_t> m_peer_ids;
+	std::vector<session_t> m_peer_ids;
 	std::mutex m_peers_mutex;
 
 	std::unique_ptr<ConnectionSendThread> m_sendThread;
diff --git a/src/network/connectionthreads.cpp b/src/network/connectionthreads.cpp
index 9a6617a1c..7b62bc792 100644
--- a/src/network/connectionthreads.cpp
+++ b/src/network/connectionthreads.cpp
@@ -144,7 +144,7 @@ void ConnectionSendThread::Trigger()
 
 bool ConnectionSendThread::packetsQueued()
 {
-	std::list<session_t> peerIds = m_connection->getPeerIDs();
+	std::vector<session_t> peerIds = m_connection->getPeerIDs();
 
 	if (!m_outgoing_queue.empty() && !peerIds.empty())
 		return true;
@@ -171,8 +171,8 @@ bool ConnectionSendThread::packetsQueued()
 
 void ConnectionSendThread::runTimeouts(float dtime)
 {
-	std::list<session_t> timeouted_peers;
-	std::list<session_t> peerIds = m_connection->getPeerIDs();
+	std::vector<session_t> timeouted_peers;
+	std::vector<session_t> peerIds = m_connection->getPeerIDs();
 
 	for (session_t &peerId : peerIds) {
 		PeerHelper peer = m_connection->getPeerNoEx(peerId);
@@ -548,7 +548,7 @@ void ConnectionSendThread::disconnect()
 
 
 	// Send to all
-	std::list<session_t> peerids = m_connection->getPeerIDs();
+	std::vector<session_t> peerids = m_connection->getPeerIDs();
 
 	for (session_t peerid : peerids) {
 		sendAsPacket(peerid, 0, data, false);
@@ -620,7 +620,7 @@ void ConnectionSendThread::sendReliable(ConnectionCommand &c)
 
 void ConnectionSendThread::sendToAll(u8 channelnum, const SharedBuffer<u8> &data)
 {
-	std::list<session_t> peerids = m_connection->getPeerIDs();
+	std::vector<session_t> peerids = m_connection->getPeerIDs();
 
 	for (session_t peerid : peerids) {
 		send(peerid, channelnum, data);
@@ -629,7 +629,7 @@ void ConnectionSendThread::sendToAll(u8 channelnum, const SharedBuffer<u8> &data
 
 void ConnectionSendThread::sendToAllReliable(ConnectionCommand &c)
 {
-	std::list<session_t> peerids = m_connection->getPeerIDs();
+	std::vector<session_t> peerids = m_connection->getPeerIDs();
 
 	for (session_t peerid : peerids) {
 		PeerHelper peer = m_connection->getPeerNoEx(peerid);
@@ -643,8 +643,8 @@ void ConnectionSendThread::sendToAllReliable(ConnectionCommand &c)
 
 void ConnectionSendThread::sendPackets(float dtime)
 {
-	std::list<session_t> peerIds = m_connection->getPeerIDs();
-	std::list<session_t> pendingDisconnect;
+	std::vector<session_t> peerIds = m_connection->getPeerIDs();
+	std::vector<session_t> pendingDisconnect;
 	std::map<session_t, bool> pending_unreliable;
 
 	const unsigned int peer_packet_quota = m_iteration_packets_avaialble
@@ -843,13 +843,11 @@ void *ConnectionReceiveThread::run()
 		if (debug_print_timer > 20.0) {
 			debug_print_timer -= 20.0;
 
-			std::list<session_t> peerids = m_connection->getPeerIDs();
+			std::vector<session_t> peerids = m_connection->getPeerIDs();
 
-			for (std::list<session_t>::iterator i = peerids.begin();
-					i != peerids.end();
-					i++)
+			for (auto id : peerids)
 			{
-				PeerHelper peer = m_connection->getPeerNoEx(*i);
+				PeerHelper peer = m_connection->getPeerNoEx(id);
 				if (!peer)
 					continue;
 
@@ -958,8 +956,11 @@ void ConnectionReceiveThread::receive(SharedBuffer<u8> &packetdata,
 			// command was sent reliably.
 		}
 
-		/* The peer was not found in our lists. Add it. */
 		if (peer_id == PEER_ID_INEXISTENT) {
+			/* Ignore it if we are a client */
+			if (m_connection->ConnectedToServer())
+				return;
+			/* The peer was not found in our lists. Add it. */
 			peer_id = m_connection->createPeer(sender, MTP_MINETEST_RELIABLE_UDP, 0);
 		}
 
@@ -1039,7 +1040,7 @@ void ConnectionReceiveThread::receive(SharedBuffer<u8> &packetdata,
 
 bool ConnectionReceiveThread::getFromBuffers(session_t &peer_id, SharedBuffer<u8> &dst)
 {
-	std::list<session_t> peerids = m_connection->getPeerIDs();
+	std::vector<session_t> peerids = m_connection->getPeerIDs();
 
 	for (session_t peerid : peerids) {
 		PeerHelper peer = m_connection->getPeerNoEx(peerid);
diff --git a/src/network/networkpacket.cpp b/src/network/networkpacket.cpp
index 4d531b611..6d0abb12c 100644
--- a/src/network/networkpacket.cpp
+++ b/src/network/networkpacket.cpp
@@ -223,13 +223,6 @@ NetworkPacket& NetworkPacket::operator>>(char& dst)
 	return *this;
 }
 
-char NetworkPacket::getChar(u32 offset)
-{
-	checkReadOffset(offset, 1);
-
-	return readU8(&m_data[offset]);
-}
-
 NetworkPacket& NetworkPacket::operator<<(char src)
 {
 	checkDataSize(1);
diff --git a/src/network/networkpacket.h b/src/network/networkpacket.h
index fc8617651..e77bfb744 100644
--- a/src/network/networkpacket.h
+++ b/src/network/networkpacket.h
@@ -64,7 +64,6 @@ public:
 
 	std::string readLongString();
 
-	char getChar(u32 offset);
 	NetworkPacket &operator>>(char &dst);
 	NetworkPacket &operator<<(char src);
 
diff --git a/src/network/networkprotocol.h b/src/network/networkprotocol.h
index e57a7a794..98d143c89 100644
--- a/src/network/networkprotocol.h
+++ b/src/network/networkprotocol.h
@@ -204,6 +204,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 	PROTOCOL VERSION 39:
 		Updated set_sky packet
 		Adds new sun, moon and stars packets
+		Minimap modes
 */
 
 #define LATEST_PROTOCOL_VERSION 40
@@ -764,6 +765,17 @@ enum ToClientCommand
 		u8[len] formspec
 	*/
 
+	TOCLIENT_MINIMAP_MODES = 0x62,
+	/*
+		u16 count // modes
+		u16 mode  // wanted current mode index after change
+		for each mode
+			u16 type
+			std::string label
+			u16 size
+			std::string extra
+	*/
+
 	TOCLIENT_NUM_MSG_TYPES = 0x63,
 };
 
@@ -1034,7 +1046,7 @@ const static std::string accessDeniedStrings[SERVER_ACCESSDENIED_MAX] = {
 	"This server has experienced an internal error. You will now be disconnected."
 };
 
-enum PlayerListModifer: u8
+enum PlayerListModifer : u8
 {
 	PLAYER_LIST_INIT,
 	PLAYER_LIST_ADD,
diff --git a/src/network/serveropcodes.cpp b/src/network/serveropcodes.cpp
index 2fc3197c2..aea5d7174 100644
--- a/src/network/serveropcodes.cpp
+++ b/src/network/serveropcodes.cpp
@@ -221,4 +221,5 @@ const ClientCommandFactory clientCommandFactoryTable[TOCLIENT_NUM_MSG_TYPES] =
 	null_command_factory, // 0x5f
 	{ "TOSERVER_SRP_BYTES_S_B",            0, true }, // 0x60
 	{ "TOCLIENT_FORMSPEC_PREPEND",         0, true }, // 0x61
+	{ "TOCLIENT_MINIMAP_MODES",            0, true }, // 0x62
 };
diff --git a/src/network/serverpackethandler.cpp b/src/network/serverpackethandler.cpp
index b3008bb50..3db4eb286 100644
--- a/src/network/serverpackethandler.cpp
+++ b/src/network/serverpackethandler.cpp
@@ -491,17 +491,18 @@ void Server::process_PlayerPos(RemotePlayer *player, PlayerSAO *playersao,
 	playersao->setPlayerYaw(yaw);
 	playersao->setFov(fov);
 	playersao->setWantedRange(wanted_range);
+
 	player->keyPressed = keyPressed;
-	player->control.up = (keyPressed & 1);
-	player->control.down = (keyPressed & 2);
-	player->control.left = (keyPressed & 4);
-	player->control.right = (keyPressed & 8);
-	player->control.jump = (keyPressed & 16);
-	player->control.aux1 = (keyPressed & 32);
-	player->control.sneak = (keyPressed & 64);
-	player->control.LMB = (keyPressed & 128);
-	player->control.RMB = (keyPressed & 256);
-	player->control.zoom = (keyPressed & 512);
+	player->control.up    = (keyPressed & (0x1 << 0));
+	player->control.down  = (keyPressed & (0x1 << 1));
+	player->control.left  = (keyPressed & (0x1 << 2));
+	player->control.right = (keyPressed & (0x1 << 3));
+	player->control.jump  = (keyPressed & (0x1 << 4));
+	player->control.aux1  = (keyPressed & (0x1 << 5));
+	player->control.sneak = (keyPressed & (0x1 << 6));
+	player->control.dig   = (keyPressed & (0x1 << 7));
+	player->control.place = (keyPressed & (0x1 << 8));
+	player->control.zoom  = (keyPressed & (0x1 << 9));
 
 	if (playersao->checkMovementCheat()) {
 		// Call callbacks
@@ -599,7 +600,7 @@ void Server::handleCommand_InventoryAction(NetworkPacket* pkt)
 		<< std::endl;
 	std::istringstream is(datastring, std::ios_base::binary);
 	// Create an action
-	InventoryAction *a = InventoryAction::deSerialize(is);
+	std::unique_ptr<InventoryAction> a(InventoryAction::deSerialize(is));
 	if (!a) {
 		infostream << "TOSERVER_INVENTORY_ACTION: "
 				<< "InventoryAction::deSerialize() returned NULL"
@@ -616,11 +617,30 @@ void Server::handleCommand_InventoryAction(NetworkPacket* pkt)
 		where the client made a bad prediction.
 	*/
 
+	const bool player_has_interact = checkPriv(player->getName(), "interact");
+
+	auto check_inv_access = [player, player_has_interact] (
+			const InventoryLocation &loc) -> bool {
+		if (loc.type == InventoryLocation::CURRENT_PLAYER)
+			return false; // Only used internally on the client, never sent
+		if (loc.type == InventoryLocation::PLAYER) {
+			// Allow access to own inventory in all cases
+			return loc.name == player->getName();
+		}
+
+		if (!player_has_interact) {
+			infostream << "Cannot modify foreign inventory: "
+					<< "No interact privilege" << std::endl;
+			return false;
+		}
+		return true;
+	};
+
 	/*
 		Handle restrictions and special cases of the move action
 	*/
 	if (a->getType() == IAction::Move) {
-		IMoveAction *ma = (IMoveAction*)a;
+		IMoveAction *ma = (IMoveAction*)a.get();
 
 		ma->from_inv.applyCurrentPlayer(player->getName());
 		ma->to_inv.applyCurrentPlayer(player->getName());
@@ -629,15 +649,11 @@ void Server::handleCommand_InventoryAction(NetworkPacket* pkt)
 		if (ma->from_inv != ma->to_inv)
 			m_inventory_mgr->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());
+		if (!check_inv_access(ma->from_inv) ||
+				!check_inv_access(ma->to_inv))
+			return;
 
-		InventoryLocation *remote = from_inv_is_current_player ?
+		InventoryLocation *remote = ma->from_inv.type == InventoryLocation::PLAYER ?
 			&ma->to_inv : &ma->from_inv;
 
 		// Check for out-of-range interaction
@@ -657,7 +673,6 @@ void Server::handleCommand_InventoryAction(NetworkPacket* pkt)
 					<< (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;
 		}
 
@@ -669,18 +684,6 @@ void Server::handleCommand_InventoryAction(NetworkPacket* pkt)
 					<< (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;
 		}
 	}
@@ -688,7 +691,7 @@ void Server::handleCommand_InventoryAction(NetworkPacket* pkt)
 		Handle restrictions and special cases of the drop action
 	*/
 	else if (a->getType() == IAction::Drop) {
-		IDropAction *da = (IDropAction*)a;
+		IDropAction *da = (IDropAction*)a.get();
 
 		da->from_inv.applyCurrentPlayer(player->getName());
 
@@ -701,22 +704,18 @@ void Server::handleCommand_InventoryAction(NetworkPacket* pkt)
 			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;
+		if (!player_has_interact || !check_inv_access(da->from_inv))
 			return;
-		}
 
 		// Disallow dropping items if dead
 		if (playersao->isDead()) {
 			infostream << "Ignoring IDropAction from "
 					<< (da->from_inv.dump()) << ":" << da->from_list
 					<< " because player is dead." << std::endl;
-			delete a;
 			return;
 		}
 	}
@@ -724,29 +723,28 @@ void Server::handleCommand_InventoryAction(NetworkPacket* pkt)
 		Handle restrictions and special cases of the craft action
 	*/
 	else if (a->getType() == IAction::Craft) {
-		ICraftAction *ca = (ICraftAction*)a;
+		ICraftAction *ca = (ICraftAction*)a.get();
 
 		ca->craft_inv.applyCurrentPlayer(player->getName());
 
 		m_inventory_mgr->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")) {
+		if (!player_has_interact) {
 			infostream << "Cannot craft: "
 					<< "No interact privilege" << std::endl;
-			delete a;
 			return;
 		}
+
+		if (!check_inv_access(ca->craft_inv))
+			return;
+	} else {
+		// Unknown action. Ignored.
+		return;
 	}
 
 	// Do the action
 	a->apply(m_inventory_mgr.get(), playersao, this);
-	// Eat the action
-	delete a;
 }
 
 void Server::handleCommand_ChatMessage(NetworkPacket* pkt)
@@ -862,6 +860,15 @@ void Server::handleCommand_PlayerItem(NetworkPacket* pkt)
 
 	*pkt >> item;
 
+	if (item >= player->getHotbarItemcount()) {
+		actionstream << "Player: " << player->getName()
+			<< " tried to access item=" << item
+			<< " out of hotbar_itemcount="
+			<< player->getHotbarItemcount()
+			<< "; ignoring." << std::endl;
+		return;
+	}
+
 	playersao->getPlayer()->setWieldIndex(item);
 }
 
@@ -977,11 +984,17 @@ void Server::handleCommand_Interact(NetworkPacket *pkt)
 	v3f player_pos = playersao->getLastGoodPosition();
 
 	// Update wielded item
-	playersao->getPlayer()->setWieldIndex(item_i);
 
-	// Get pointed to node (undefined if not POINTEDTYPE_NODE)
-	v3s16 p_under = pointed.node_undersurface;
-	v3s16 p_above = pointed.node_abovesurface;
+	if (item_i >= player->getHotbarItemcount()) {
+		actionstream << "Player: " << player->getName()
+			<< " tried to access item=" << item_i
+			<< " out of hotbar_itemcount="
+			<< player->getHotbarItemcount()
+			<< "; ignoring." << std::endl;
+		return;
+	}
+
+	playersao->getPlayer()->setWieldIndex(item_i);
 
 	// Get pointed to object (NULL if not POINTEDTYPE_OBJECT)
 	ServerActiveObject *pointed_object = NULL;
@@ -995,17 +1008,6 @@ void Server::handleCommand_Interact(NetworkPacket *pkt)
 
 	}
 
-	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;
-	}
-
 	/*
 		Make sure the player is allowed to do it
 	*/
@@ -1013,16 +1015,19 @@ void Server::handleCommand_Interact(NetworkPacket *pkt)
 		actionstream << player->getName() << " attempted to interact with " <<
 				pointed.dump() << " without 'interact' privilege" << std::endl;
 
+		if (pointed.type != POINTEDTHING_NODE)
+			return;
+
 		// Re-send block to revert change on client-side
 		RemoteClient *client = getClient(peer_id);
 		// Digging completed -> under
 		if (action == INTERACT_DIGGING_COMPLETED) {
-			v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_under, BS));
+			v3s16 blockpos = getNodeBlockPos(pointed.node_undersurface);
 			client->SetBlockNotSent(blockpos);
 		}
 		// Placement -> above
 		else if (action == INTERACT_PLACE) {
-			v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_above, BS));
+			v3s16 blockpos = getNodeBlockPos(pointed.node_abovesurface);
 			client->SetBlockNotSent(blockpos);
 		}
 		return;
@@ -1030,7 +1035,6 @@ void Server::handleCommand_Interact(NetworkPacket *pkt)
 
 	/*
 		Check that target is reasonably close
-		(only when digging or placing things)
 	*/
 	static thread_local const bool enable_anticheat =
 			!g_settings->getBool("disable_anticheat");
@@ -1038,13 +1042,21 @@ void Server::handleCommand_Interact(NetworkPacket *pkt)
 	if ((action == INTERACT_START_DIGGING || action == INTERACT_DIGGING_COMPLETED ||
 			action == INTERACT_PLACE || action == INTERACT_USE) &&
 			enable_anticheat && !isSingleplayer()) {
-		float d = playersao->getEyePosition().getDistanceFrom(pointed_pos_under);
+		v3f target_pos = player_pos;
+		if (pointed.type == POINTEDTHING_NODE) {
+			target_pos = intToFloat(pointed.node_undersurface, BS);
+		} else if (pointed.type == POINTEDTHING_OBJECT) {
+			target_pos = pointed_object->getBasePosition();
+		}
+		float d = playersao->getEyePosition().getDistanceFrom(target_pos);
 
 		if (!checkInteractDistance(player, d, pointed.dump())) {
-			// 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);
+			if (pointed.type == POINTEDTHING_NODE) {
+				// Re-send block to revert change on client-side
+				RemoteClient *client = getClient(peer_id);
+				v3s16 blockpos = getNodeBlockPos(pointed.node_undersurface);
+				client->SetBlockNotSent(blockpos);
+			}
 			return;
 		}
 	}
@@ -1055,20 +1067,20 @@ void Server::handleCommand_Interact(NetworkPacket *pkt)
 	RollbackScopeActor rollback_scope(m_rollback,
 			std::string("player:")+player->getName());
 
-	/*
-		0: start digging or punch object
-	*/
-	if (action == INTERACT_START_DIGGING) {
+	switch (action) {
+	// Start digging or punch object
+	case INTERACT_START_DIGGING: {
 		if (pointed.type == POINTEDTHING_NODE) {
 			MapNode n(CONTENT_IGNORE);
 			bool pos_ok;
 
+			v3s16 p_under = pointed.node_undersurface;
 			n = m_env->getMap().getNode(p_under, &pos_ok);
 			if (!pos_ok) {
 				infostream << "Server: Not punching: Node not found. "
 					"Adding block to emerge queue." << std::endl;
-				m_emerge->enqueueBlockEmerge(peer_id, getNodeBlockPos(p_above),
-					false);
+				m_emerge->enqueueBlockEmerge(peer_id,
+					getNodeBlockPos(pointed.node_abovesurface), false);
 			}
 
 			if (n.getContent() != CONTENT_IGNORE)
@@ -1076,159 +1088,155 @@ void Server::handleCommand_Interact(NetworkPacket *pkt)
 
 			// Cheat prevention
 			playersao->noCheatDigStart(p_under);
+
+			return;
 		}
-		else if (pointed.type == POINTEDTHING_OBJECT) {
-			// Skip if object can't be interacted with anymore
-			if (pointed_object->isGone())
-				return;
 
-			ItemStack selected_item, hand_item;
-			ItemStack tool_item = playersao->getWieldedItem(&selected_item, &hand_item);
-			ToolCapabilities toolcap =
-					tool_item.getToolCapabilities(m_itemdef);
-			v3f dir = (pointed_object->getBasePosition() -
-					(playersao->getBasePosition() + playersao->getEyeOffset())
-						).normalize();
-			float time_from_last_punch =
-				playersao->resetTimeFromLastPunch();
-
-			u16 src_original_hp = pointed_object->getHP();
-			u16 dst_origin_hp = playersao->getHP();
-
-			u16 wear = pointed_object->punch(dir, &toolcap, playersao,
-					time_from_last_punch);
-
-			// Callback may have changed item, so get it again
-			playersao->getWieldedItem(&selected_item);
-			bool changed = selected_item.addWear(wear, m_itemdef);
-			if (changed)
-				playersao->setWieldedItem(selected_item);
-
-			// If the object is a player and its HP changed
-			if (src_original_hp != pointed_object->getHP() &&
-					pointed_object->getType() == ACTIVEOBJECT_TYPE_PLAYER) {
-				SendPlayerHPOrDie((PlayerSAO *)pointed_object,
-						PlayerHPChangeReason(PlayerHPChangeReason::PLAYER_PUNCH, playersao));
-			}
+		// Skip if the object can't be interacted with anymore
+		if (pointed.type != POINTEDTHING_OBJECT || pointed_object->isGone())
+			return;
 
-			// If the puncher is a player and its HP changed
-			if (dst_origin_hp != playersao->getHP())
-				SendPlayerHPOrDie(playersao,
-						PlayerHPChangeReason(PlayerHPChangeReason::PLAYER_PUNCH, pointed_object));
+		ItemStack selected_item, hand_item;
+		ItemStack tool_item = playersao->getWieldedItem(&selected_item, &hand_item);
+		ToolCapabilities toolcap =
+				tool_item.getToolCapabilities(m_itemdef);
+		v3f dir = (pointed_object->getBasePosition() -
+				(playersao->getBasePosition() + playersao->getEyeOffset())
+					).normalize();
+		float time_from_last_punch =
+			playersao->resetTimeFromLastPunch();
+
+		u16 src_original_hp = pointed_object->getHP();
+		u16 dst_origin_hp = playersao->getHP();
+
+		u16 wear = pointed_object->punch(dir, &toolcap, playersao,
+				time_from_last_punch);
+
+		// Callback may have changed item, so get it again
+		playersao->getWieldedItem(&selected_item);
+		bool changed = selected_item.addWear(wear, m_itemdef);
+		if (changed)
+			playersao->setWieldedItem(selected_item);
+
+		// If the object is a player and its HP changed
+		if (src_original_hp != pointed_object->getHP() &&
+				pointed_object->getType() == ACTIVEOBJECT_TYPE_PLAYER) {
+			SendPlayerHPOrDie((PlayerSAO *)pointed_object,
+					PlayerHPChangeReason(PlayerHPChangeReason::PLAYER_PUNCH, playersao));
 		}
 
+		// If the puncher is a player and its HP changed
+		if (dst_origin_hp != playersao->getHP())
+			SendPlayerHPOrDie(playersao,
+					PlayerHPChangeReason(PlayerHPChangeReason::PLAYER_PUNCH, pointed_object));
+
+		return;
 	} // action == INTERACT_START_DIGGING
 
-	/*
-		1: stop digging
-	*/
-	else if (action == INTERACT_STOP_DIGGING) {
-	} // action == INTERACT_STOP_DIGGING
+	case INTERACT_STOP_DIGGING:
+		// Nothing to do
+		return;
 
-	/*
-		2: Digging completed
-	*/
-	else if (action == INTERACT_DIGGING_COMPLETED) {
+	case INTERACT_DIGGING_COMPLETED: {
 		// Only digging of nodes
-		if (pointed.type == POINTEDTHING_NODE) {
-			bool pos_ok;
-			MapNode n = m_env->getMap().getNode(p_under, &pos_ok);
-			if (!pos_ok) {
-				infostream << "Server: Not finishing digging: Node not found. "
-					"Adding block to emerge queue." << std::endl;
-				m_emerge->enqueueBlockEmerge(peer_id, getNodeBlockPos(p_above),
-					false);
-			}
-
-			/* Cheat prevention */
-			bool is_valid_dig = true;
-			if (enable_anticheat && !isSingleplayer()) {
-				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: " << 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");
-				}
+		if (pointed.type != POINTEDTHING_NODE)
+			return;
+		bool pos_ok;
+		v3s16 p_under = pointed.node_undersurface;
+		MapNode n = m_env->getMap().getNode(p_under, &pos_ok);
+		if (!pos_ok) {
+			infostream << "Server: Not finishing digging: Node not found. "
+				"Adding block to emerge queue." << std::endl;
+			m_emerge->enqueueBlockEmerge(peer_id,
+				getNodeBlockPos(pointed.node_abovesurface), false);
+		}
 
-				// Get player's wielded item
-				// See also: Game::handleDigging
-				ItemStack selected_item, hand_item;
-				playersao->getPlayer()->getWieldedItem(&selected_item, &hand_item);
-
-				// Get diggability and expected digging time
-				DigParams params = getDigParams(m_nodedef->get(n).groups,
-						&selected_item.getToolCapabilities(m_itemdef));
-				// If can't dig, try hand
-				if (!params.diggable) {
-					params = getDigParams(m_nodedef->get(n).groups,
-						&hand_item.getToolCapabilities(m_itemdef));
-				}
-				// If can't dig, ignore dig
-				if (!params.diggable) {
-					infostream << "Server: " << 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: " << 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");
-				}
+		/* Cheat prevention */
+		bool is_valid_dig = true;
+		if (enable_anticheat && !isSingleplayer()) {
+			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: " << 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");
 			}
 
-			/* 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().getNode(p_under).getContent() != CONTENT_AIR) {
-				// Re-send block to revert change on client-side
-				client->SetBlockNotSent(blockpos);
+			// Get player's wielded item
+			// See also: Game::handleDigging
+			ItemStack selected_item, hand_item;
+			playersao->getPlayer()->getWieldedItem(&selected_item, &hand_item);
+
+			// Get diggability and expected digging time
+			DigParams params = getDigParams(m_nodedef->get(n).groups,
+					&selected_item.getToolCapabilities(m_itemdef));
+			// If can't dig, try hand
+			if (!params.diggable) {
+				params = getDigParams(m_nodedef->get(n).groups,
+					&hand_item.getToolCapabilities(m_itemdef));
+			}
+			// If can't dig, ignore dig
+			if (!params.diggable) {
+				infostream << "Server: " << 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 {
-				client->ResendBlockIfOnWire(blockpos);
+				infostream << "Server: " << 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(p_under);
+		RemoteClient *client = getClient(peer_id);
+		// Send unusual result (that is, node not being removed)
+		if (m_env->getMap().getNode(p_under).getContent() != CONTENT_AIR)
+			// Re-send block to revert change on client-side
+			client->SetBlockNotSent(blockpos);
+		else
+			client->ResendBlockIfOnWire(blockpos);
+
+		return;
 	} // action == INTERACT_DIGGING_COMPLETED
 
-	/*
-		3: place block or right-click object
-	*/
-	else if (action == INTERACT_PLACE) {
+	// Place block or right-click object
+	case INTERACT_PLACE: {
 		ItemStack selected_item;
 		playersao->getWieldedItem(&selected_item, nullptr);
 
@@ -1257,59 +1265,54 @@ void Server::handleCommand_Interact(NetworkPacket *pkt)
 			}
 
 			pointed_object->rightClick(playersao);
-		} else if (m_script->item_OnPlace(
-				selected_item, playersao, pointed)) {
+		} else if (m_script->item_OnPlace(selected_item, playersao, pointed)) {
 			// Placement was handled in lua
 
 			// Apply returned ItemStack
-			if (playersao->setWieldedItem(selected_item)) {
+			if (playersao->setWieldedItem(selected_item))
 				SendInventory(playersao, true);
-			}
 		}
 
+		if (pointed.type != POINTEDTHING_NODE)
+			return;
+
 		// 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 (!selected_item.getDefinition(m_itemdef).node_placement_prediction.empty()) {
+		v3s16 blockpos = getNodeBlockPos(pointed.node_abovesurface);
+		v3s16 blockpos2 = getNodeBlockPos(pointed.node_undersurface);
+		if (!selected_item.getDefinition(m_itemdef
+				).node_placement_prediction.empty()) {
 			client->SetBlockNotSent(blockpos);
-			if (blockpos2 != blockpos) {
+			if (blockpos2 != blockpos)
 				client->SetBlockNotSent(blockpos2);
-			}
-		}
-		else {
+		} else {
 			client->ResendBlockIfOnWire(blockpos);
-			if (blockpos2 != blockpos) {
+			if (blockpos2 != blockpos)
 				client->ResendBlockIfOnWire(blockpos2);
-			}
 		}
+
+		return;
 	} // action == INTERACT_PLACE
 
-	/*
-		4: use
-	*/
-	else if (action == INTERACT_USE) {
+	case INTERACT_USE: {
 		ItemStack selected_item;
 		playersao->getWieldedItem(&selected_item, nullptr);
 
 		actionstream << player->getName() << " uses " << selected_item.name
 				<< ", pointing at " << pointed.dump() << std::endl;
 
-		if (m_script->item_OnUse(
-				selected_item, playersao, pointed)) {
+		if (m_script->item_OnUse(selected_item, playersao, pointed)) {
 			// Apply returned ItemStack
-			if (playersao->setWieldedItem(selected_item)) {
+			if (playersao->setWieldedItem(selected_item))
 				SendInventory(playersao, true);
-			}
 		}
 
-	} // action == INTERACT_USE
+		return;
+	}
 
-	/*
-		5: rightclick air
-	*/
-	else if (action == INTERACT_ACTIVATE) {
+	// Rightclick air
+	case INTERACT_ACTIVATE: {
 		ItemStack selected_item;
 		playersao->getWieldedItem(&selected_item, nullptr);
 
@@ -1318,21 +1321,17 @@ void Server::handleCommand_Interact(NetworkPacket *pkt)
 
 		pointed.type = POINTEDTHING_NOTHING; // can only ever be NOTHING
 
-		if (m_script->item_OnSecondaryUse(
-				selected_item, playersao, pointed)) {
-			if (playersao->setWieldedItem(selected_item)) {
+		if (m_script->item_OnSecondaryUse(selected_item, playersao, pointed)) {
+			if (playersao->setWieldedItem(selected_item))
 				SendInventory(playersao, true);
-			}
 		}
-	} // action == INTERACT_ACTIVATE
 
+		return;
+	}
+
+	default:
+		warningstream << "Server: Invalid action " << action << std::endl;
 
-	/*
-		Catch invalid actions
-	*/
-	else {
-		warningstream << "Server: Invalid action "
-				<< action << std::endl;
 	}
 }
 
@@ -1658,19 +1657,18 @@ void Server::handleCommand_SrpBytesM(NetworkPacket* pkt)
 
 	bool wantSudo = (cstate == CS_Active);
 
-	verbosestream << "Server: Received TOCLIENT_SRP_BYTES_M." << std::endl;
+	verbosestream << "Server: Received TOSERVER_SRP_BYTES_M." << std::endl;
 
 	if (!((cstate == CS_HelloSent) || (cstate == CS_Active))) {
-		actionstream << "Server: got SRP _M packet in wrong state "
-			<< cstate << " from " << addr_s
-			<< ". Ignoring." << std::endl;
+		warningstream << "Server: got SRP_M packet in wrong state "
+			<< cstate << " from " << addr_s << ". Ignoring." << std::endl;
 		return;
 	}
 
 	if (client->chosen_mech != AUTH_MECHANISM_SRP &&
 			client->chosen_mech != AUTH_MECHANISM_LEGACY_PASSWORD) {
-		actionstream << "Server: got SRP _M packet, while auth"
-			<< "is going on with mech " << client->chosen_mech << " from " 
+		warningstream << "Server: got SRP_M packet, while auth "
+			"is going on with mech " << client->chosen_mech << " from "
 			<< addr_s << " (wantSudo=" << wantSudo << "). Denying." << std::endl;
 		if (wantSudo) {
 			DenySudoAccess(peer_id);
@@ -1718,7 +1716,7 @@ void Server::handleCommand_SrpBytesM(NetworkPacket* pkt)
 
 		std::string checkpwd; // not used, but needed for passing something
 		if (!m_script->getAuth(playername, &checkpwd, NULL)) {
-			actionstream << "Server: " << playername <<
+			errorstream << "Server: " << playername <<
 				" cannot be authenticated (auth handler does not work?)" <<
 				std::endl;
 			DenyAccess(peer_id, SERVER_ACCESSDENIED_SERVER_FAIL);