X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fserver.h;h=b238bec26e86029b191c03101ce776808d4fb6f0;hb=28660b4c1af1b1b6ac2d3fda6984bda2a1199dc1;hp=b716a7df1d0d21570d2ad5e824b5461712f75520;hpb=6b6c2d37ea1f9075c4fbf0d7e2d52e527e1f86aa;p=oweals%2Fminetest.git

diff --git a/src/server.h b/src/server.h
index b716a7df1..b238bec26 100644
--- a/src/server.h
+++ b/src/server.h
@@ -1,6 +1,6 @@
 /*
 Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -17,10 +17,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
-/*
-(c) 2010 Perttu Ahola <celeron55@gmail.com>
-*/
-
 #ifndef SERVER_HEADER
 #define SERVER_HEADER
 
@@ -28,9 +24,21 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "environment.h"
 #include "common_irrlicht.h"
 #include <string>
-#include "utility.h"
 #include "porting.h"
+#include "map.h"
+#include "inventory.h"
+#include "auth.h"
+#include "ban.h"
 
+/*
+	Some random functions
+*/
+v3f findSpawnPos(ServerMap &map);
+
+/*
+	A structure containing the data needed for queueing the fetching
+	of blocks.
+*/
 struct QueuedBlockEmerge
 {
 	v3s16 pos;
@@ -227,24 +235,23 @@ public:
 	u16 peer_id;
 	// The serialization version to use with the client
 	u8 serialization_version;
+	//
+	u16 net_proto_version;
 	// Version is stored in here after INIT before INIT2
 	u8 pending_serialization_version;
 
 	RemoteClient():
-		m_time_from_building(9999)
+		m_time_from_building(9999),
+		m_excess_gotblocks(0)
 	{
 		peer_id = 0;
 		serialization_version = SER_FMT_VER_INVALID;
+		net_proto_version = 0;
 		pending_serialization_version = SER_FMT_VER_INVALID;
 		m_nearest_unsent_d = 0;
 		m_nearest_unsent_reset_timer = 0.0;
-
-		m_blocks_sent_mutex.Init();
-		m_blocks_sending_mutex.Init();
-		
-		/*m_dig_mutex.Init();
-		m_dig_time_remaining = 0;
-		m_dig_tool_item = -1;*/
+		m_nothing_to_send_counter = 0;
+		m_nothing_to_send_pause_timer = 0;
 	}
 	~RemoteClient()
 	{
@@ -278,7 +285,6 @@ public:
 
 	s32 SendingCount()
 	{
-		JMutexAutoLock lock(m_blocks_sending_mutex);
 		return m_blocks_sending.size();
 	}
 	
@@ -289,40 +295,31 @@ public:
 
 	void PrintInfo(std::ostream &o)
 	{
-		JMutexAutoLock l2(m_blocks_sent_mutex);
-		JMutexAutoLock l3(m_blocks_sending_mutex);
 		o<<"RemoteClient "<<peer_id<<": "
-				<<", m_blocks_sent.size()="<<m_blocks_sent.size()
+				<<"m_blocks_sent.size()="<<m_blocks_sent.size()
 				<<", m_blocks_sending.size()="<<m_blocks_sending.size()
 				<<", m_nearest_unsent_d="<<m_nearest_unsent_d
+				<<", m_excess_gotblocks="<<m_excess_gotblocks
 				<<std::endl;
+		m_excess_gotblocks = 0;
 	}
 
 	// Time from last placing or removing blocks
-	MutexedVariable<float> m_time_from_building;
+	float m_time_from_building;
 	
 	/*JMutex m_dig_mutex;
 	float m_dig_time_remaining;
 	// -1 = not digging
 	s16 m_dig_tool_item;
 	v3s16 m_dig_position;*/
-
-private:
+	
 	/*
-		All members that are accessed by many threads should
-		obviously be behind a mutex. The threads include:
-		- main thread (calls step())
-		- server thread (calls AsyncRunStep() and Receive())
-		- emerge thread 
+		List of active objects that the client knows of.
+		Value is dummy.
 	*/
-	
-	//TODO: core::map<v3s16, MapBlock*> m_active_blocks
-	//NOTE: Not here, it should be server-wide!
-
-	// Number of blocks in the emerge queue that have this client as
-	// a receiver. Used for throttling network usage.
-	//MutexedVariable<s16> m_num_blocks_in_emerge_queue;
+	core::map<u16, bool> m_known_objects;
 
+private:
 	/*
 		Blocks that have been sent to client.
 		- These don't have to be sent again.
@@ -336,7 +333,7 @@ private:
 	s16 m_nearest_unsent_d;
 	v3s16 m_last_center;
 	float m_nearest_unsent_reset_timer;
-	JMutex m_blocks_sent_mutex;
+	
 	/*
 		Blocks that are currently on the line.
 		This is used for throttling the sending of blocks.
@@ -346,28 +343,32 @@ private:
 		Value is time from sending. (not used at the moment)
 	*/
 	core::map<v3s16, float> m_blocks_sending;
-	JMutex m_blocks_sending_mutex;
-};
 
-/*struct ServerSettings
-{
-	ServerSettings()
-	{
-		creative_mode = false;
-	}
-	bool creative_mode;
-};*/
+	/*
+		Count of excess GotBlocks().
+		There is an excess amount because the client sometimes
+		gets a block so late that the server sends it again,
+		and the client then sends two GOTBLOCKs.
+		This is resetted by PrintInfo()
+	*/
+	u32 m_excess_gotblocks;
+	
+	// CPU usage optimization
+	u32 m_nothing_to_send_counter;
+	float m_nothing_to_send_pause_timer;
+};
 
-class Server : public con::PeerHandler
+class Server : public con::PeerHandler, public MapEventReceiver,
+		public InventoryManager
 {
 public:
 	/*
 		NOTE: Every public method should be thread-safe
 	*/
+
 	Server(
 		std::string mapsavedir,
-		HMParams hm_params,
-		MapParams map_params
+		std::string configpath
 	);
 	~Server();
 	void start(unsigned short port);
@@ -380,117 +381,320 @@ public:
 	void Receive();
 	void ProcessData(u8 *data, u32 datasize, u16 peer_id);
 
-	/*void Send(u16 peer_id, u16 channelnum,
-			SharedBuffer<u8> data, bool reliable);*/
+	core::list<PlayerInfo> getPlayerInfo();
 
-	// Environment and Connection must be locked when called
-	void SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver);
-	//TODO: Sending of many blocks in a single packet
+	/*u32 getDayNightRatio()
+	{
+		return time_to_daynight_ratio(m_time_of_day.get());
+	}*/
 	
-	// Environment and Connection must be locked when called
-	//void SendSectorMeta(u16 peer_id, core::list<v2s16> ps, u8 ver);
+	// Environment must be locked when called
+	void setTimeOfDay(u32 time)
+	{
+		m_env.setTimeOfDay(time);
+		m_time_of_day_send_timer = 0;
+	}
 
-	core::list<PlayerInfo> getPlayerInfo();
+	bool getShutdownRequested()
+	{
+		return m_shutdown_requested;
+	}
+	
+	/*
+		Shall be called with the environment locked.
+		This is accessed by the map, which is inside the environment,
+		so it shouldn't be a problem.
+	*/
+	void onMapEditEvent(MapEditEvent *event);
+
+	/*
+		Shall be called with the environment and the connection locked.
+	*/
+	Inventory* getInventory(InventoryContext *c, std::string id);
+	void inventoryModified(InventoryContext *c, std::string id);
+
+	// Connection must be locked when called
+	std::wstring getStatusString();
+
+	void requestShutdown(void)
+	{
+		m_shutdown_requested = true;
+	}
+
+
+	// Envlock and conlock should be locked when calling this
+	void SendMovePlayer(Player *player);
+	
+	u64 getPlayerAuthPrivs(const std::string &name)
+	{
+		try{
+			return m_authmanager.getPrivs(name);
+		}
+		catch(AuthNotFoundException &e)
+		{
+			dstream<<"WARNING: Auth not found for "<<name<<std::endl;
+			return 0;
+		}
+	}
+
+	void setPlayerAuthPrivs(const std::string &name, u64 privs)
+	{
+		try{
+			return m_authmanager.setPrivs(name, privs);
+		}
+		catch(AuthNotFoundException &e)
+		{
+			dstream<<"WARNING: Auth not found for "<<name<<std::endl;
+		}
+	}
+	
+	// Saves g_settings to configpath given at initialization
+	void saveConfig();
+
+	void setIpBanned(const std::string &ip, const std::string &name)
+	{
+		m_banmanager.add(ip, name);
+		return;
+	}
+
+	void unsetIpBanned(const std::string &ip_or_name)
+	{
+		m_banmanager.remove(ip_or_name);
+		return;
+	}
+
+	std::string getBanDescription(const std::string &ip_or_name)
+	{
+		return m_banmanager.getBanDescription(ip_or_name);
+	}
 
-	u32 getDayNightRatio()
+	Address getPeerAddress(u16 peer_id)
 	{
-		s32 d = 8;
-		s32 t = (((m_time_of_day.get() + 24000/d/2)%24000)/(24000/d));
-		if(t == d/4 || t == (d-d/4))
-			return 600;
-		else if(t < d/4 || t > (d-d/4))
-			return 300;
-		else
-			return 1000;
+		return m_con.GetPeerAddress(peer_id);
 	}
 	
+	// Envlock and conlock should be locked when calling this
+	void notifyPlayer(const char *name, const std::wstring msg);
+	void notifyPlayers(const std::wstring msg);
+
 private:
 
-	// Virtual methods from con::PeerHandler.
+	// con::PeerHandler implementation.
+	// These queue stuff to be processed by handlePeerChanges().
 	// As of now, these create and remove clients and players.
-	// TODO: Make it possible to leave players on server.
 	void peerAdded(con::Peer *peer);
 	void deletingPeer(con::Peer *peer, bool timeout);
 	
+	/*
+		Static send methods
+	*/
+	
+	static void SendHP(con::Connection &con, u16 peer_id, u8 hp);
+	static void SendAccessDenied(con::Connection &con, u16 peer_id,
+			const std::wstring &reason);
+	static void SendDeathscreen(con::Connection &con, u16 peer_id,
+			bool set_camera_point_target, v3f camera_point_target);
+	
+	/*
+		Non-static send methods
+	*/
+
 	// Envlock and conlock should be locked when calling these
 	void SendObjectData(float dtime);
 	void SendPlayerInfos();
 	void SendInventory(u16 peer_id);
+	// send wielded item info about player to all
+	void SendWieldedItem(const Player *player);
+	// send wielded item info about all players to all players
+	void SendPlayerItems();
 	void SendChatMessage(u16 peer_id, const std::wstring &message);
 	void BroadcastChatMessage(const std::wstring &message);
+	void SendPlayerHP(Player *player);
+	/*
+		Send a node removal/addition event to all clients except ignore_id.
+		Additionally, if far_players!=NULL, players further away than
+		far_d_nodes are ignored and their peer_ids are added to far_players
+	*/
+	// Envlock and conlock should be locked when calling these
+	void sendRemoveNode(v3s16 p, u16 ignore_id=0,
+			core::list<u16> *far_players=NULL, float far_d_nodes=100);
+	void sendAddNode(v3s16 p, MapNode n, u16 ignore_id=0,
+			core::list<u16> *far_players=NULL, float far_d_nodes=100);
+	void setBlockNotSent(v3s16 p);
 	
-	// Sends blocks to clients
+	// Environment and Connection must be locked when called
+	void SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver);
+	
+	// Sends blocks to clients (locks env and con on its own)
 	void SendBlocks(float dtime);
+
+	/*
+		Something random
+	*/
+	
+	void HandlePlayerHP(Player *player, s16 damage);
+	void RespawnPlayer(Player *player);
+	
+	void UpdateCrafting(u16 peer_id);
 	
 	// When called, connection mutex should be locked
 	RemoteClient* getClient(u16 peer_id);
+	
+	// When called, environment mutex should be locked
+	std::string getPlayerName(u16 peer_id)
+	{
+		Player *player = m_env.getPlayer(peer_id);
+		if(player == NULL)
+			return "[id="+itos(peer_id);
+		return player->getName();
+	}
 
 	/*
-		Update water pressure.
-		This also adds suitable nodes to active_nodes.
+		Get a player from memory or creates one.
+		If player is already connected, return NULL
+		The password is not checked here - it is only used to
+		set the password if a new player is created.
 
-		environment has to be locked when calling.
+		Call with env and con locked.
 	*/
-	void UpdateBlockWaterPressure(MapBlock *block,
-			core::map<v3s16, MapBlock*> &modified_blocks);
+	Player *emergePlayer(const char *name, const char *password, u16 peer_id);
 	
 	// Locks environment and connection by its own
 	struct PeerChange;
 	void handlePeerChange(PeerChange &c);
 	void handlePeerChanges();
+
+	u64 getPlayerPrivs(Player *player);
+
+	/*
+		Variables
+	*/
 	
-	float m_flowwater_timer;
+	// Some timers
+	float m_liquid_transform_timer;
 	float m_print_info_timer;
 	float m_objectdata_timer;
 	float m_emergethread_trigger_timer;
 	float m_savemap_timer;
+	IntervalLimiter m_map_timer_and_unload_interval;
 	
 	// NOTE: If connection and environment are both to be locked,
 	// environment shall be locked first.
-	JMutex m_env_mutex;
-	Environment m_env;
 
-	JMutex m_con_mutex;
+	// Environment
+	ServerEnvironment m_env;
+	JMutex m_env_mutex;
+	
+	// Connection
 	con::Connection m_con;
-	core::map<u16, RemoteClient*> m_clients; // Behind the con mutex
+	JMutex m_con_mutex;
+	// Connected clients (behind the con mutex)
+	core::map<u16, RemoteClient*> m_clients;
+
+	// User authentication
+	AuthManager m_authmanager;
 
+	// Bann checking
+	BanManager m_banmanager;
+	
+	/*
+		Threads
+	*/
+	
+	// A buffer for time steps
+	// step() increments and AsyncRunStep() run by m_thread reads it.
 	float m_step_dtime;
 	JMutex m_step_dtime_mutex;
 
+	// The server mainly operates in this thread
 	ServerThread m_thread;
+	// This thread fetches and generates map
 	EmergeThread m_emergethread;
-
+	// Queue of block coordinates to be processed by the emerge thread
 	BlockEmergeQueue m_emerge_queue;
 	
-	// Nodes that are destinations of flowing liquid at the moment
-	core::map<v3s16, u8> m_flow_active_nodes;
+	/*
+		Time related stuff
+	*/
 
 	// 0-23999
-	MutexedVariable<u32> m_time_of_day;
+	//MutexedVariable<u32> m_time_of_day;
 	// Used to buffer dtime for adding to m_time_of_day
 	float m_time_counter;
+	// Timer for sending time of day over network
 	float m_time_of_day_send_timer;
-	
+	// Uptime of server in seconds
 	MutexedVariable<double> m_uptime;
-
+	
+	/*
+		Peer change queue.
+		Queues stuff from peerAdded() and deletingPeer() to
+		handlePeerChanges()
+	*/
 	enum PeerChangeType
 	{
 		PEER_ADDED,
 		PEER_REMOVED
 	};
-
 	struct PeerChange
 	{
 		PeerChangeType type;
 		u16 peer_id;
 		bool timeout;
 	};
-	
 	Queue<PeerChange> m_peer_change_queue;
 
+	/*
+		Random stuff
+	*/
+
+	// Map directory
+	std::string m_mapsavedir;
+
+	// Configuration path ("" = no configuration file)
+	std::string m_configpath;
+
+	bool m_shutdown_requested;
+	
+	/*
+		Map edit event queue. Automatically receives all map edits.
+		The constructor of this class registers us to receive them through
+		onMapEditEvent
+
+		NOTE: Should these be moved to actually be members of
+		ServerEnvironment?
+	*/
+
+	/*
+		Queue of map edits from the environment for sending to the clients
+		This is behind m_env_mutex
+	*/
+	Queue<MapEditEvent*> m_unsent_map_edit_queue;
+	/*
+		Set to true when the server itself is modifying the map and does
+		all sending of information by itself.
+		This is behind m_env_mutex
+	*/
+	bool m_ignore_map_edit_events;
+	/*
+		If set to !=0, the incoming MapEditEvents are modified to have
+		this peed id as the disabled recipient
+		This is behind m_env_mutex
+	*/
+	u16 m_ignore_map_edit_events_peer_id;
+
+	Profiler *m_profiler;
+
 	friend class EmergeThread;
 	friend class RemoteClient;
 };
 
+/*
+	Runs a simple dedicated server loop.
+
+	Shuts down when run is set to false.
+*/
+void dedicated_server_loop(Server &server, bool &run);
+
 #endif