X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fserver.h;h=7065efacfe6e4d4d3f383402584bbf0b0490f196;hb=785a2fd23a47af3629db824adc5e4e1376880d4d;hp=9c5850bff69bd1c19281d7743ef8aac810895fb8;hpb=d10627a77fe022263e2319be282fbec68e713545;p=minetest.git

diff --git a/src/server.h b/src/server.h
index 9c5850bff..7065efacf 100644
--- a/src/server.h
+++ b/src/server.h
@@ -1,5 +1,20 @@
 /*
-(c) 2010 Perttu Ahola <celeron55@gmail.com>
+Minetest-c55
+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
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
 #ifndef SERVER_HEADER
@@ -9,15 +24,22 @@
 #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"
 
-#ifdef _WIN32
-	#include <windows.h>
-	#define sleep_ms(x) Sleep(x)
-#else
-	#include <unistd.h>
-	#define sleep_ms(x) usleep(x*1000)
-#endif
+/*
+	Some random functions
+*/
+v3f findSpawnPos(ServerMap &map);
 
+/*
+	A structure containing the data needed for queueing the fetching
+	of blocks.
+*/
 struct QueuedBlockEmerge
 {
 	v3s16 pos;
@@ -127,44 +149,6 @@ class BlockEmergeQueue
 	JMutex m_mutex;
 };
 
-class SimpleThread : public JThread
-{
-	bool run;
-	JMutex run_mutex;
-
-public:
-
-	SimpleThread():
-		JThread(),
-		run(true)
-	{
-		run_mutex.Init();
-	}
-
-	virtual ~SimpleThread()
-	{}
-
-	virtual void * Thread() = 0;
-
-	bool getRun()
-	{
-		JMutexAutoLock lock(run_mutex);
-		return run;
-	}
-	void setRun(bool a_run)
-	{
-		JMutexAutoLock lock(run_mutex);
-		run = a_run;
-	}
-
-	void stop()
-	{
-		setRun(false);
-		while(IsRunning())
-			sleep_ms(100);
-	}
-};
-
 class Server;
 
 class ServerThread : public SimpleThread
@@ -252,20 +236,23 @@ class RemoteClient
 	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(0.0)
-		//m_num_blocks_in_emerge_queue(0)
+		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_blocks_sent_mutex.Init();
-		m_blocks_sending_mutex.Init();
+		m_nearest_unsent_reset_timer = 0.0;
+		m_nothing_to_send_counter = 0;
+		m_nothing_to_send_pause_timer = 0;
 	}
 	~RemoteClient()
 	{
@@ -279,9 +266,11 @@ class RemoteClient
 	void GetNextBlocks(Server *server, float dtime,
 			core::array<PrioritySortedBlockTransfer> &dest);
 
-	// Connection and environment should be locked when this is called
-	// steps() objects of blocks not found in active_blocks, then
-	// adds those blocks to active_blocks
+	/*
+		Connection and environment should be locked when this is called.
+		steps() objects of blocks not found in active_blocks, then
+		adds those blocks to active_blocks
+	*/
 	void SendObjectData(
 			Server *server,
 			float dtime,
@@ -295,17 +284,8 @@ class RemoteClient
 	void SetBlockNotSent(v3s16 p);
 	void SetBlocksNotSent(core::map<v3s16, MapBlock*> &blocks);
 
-	//void BlockEmerged();
-
-	/*bool IsSendingBlock(v3s16 p)
-	{
-		JMutexAutoLock lock(m_blocks_sending_mutex);
-		return (m_blocks_sending.find(p) != NULL);
-	}*/
-
 	s32 SendingCount()
 	{
-		JMutexAutoLock lock(m_blocks_sending_mutex);
 		return m_blocks_sending.size();
 	}
 	
@@ -316,36 +296,31 @@ class RemoteClient
 
 	void PrintInfo(std::ostream &o)
 	{
-		JMutexAutoLock l2(m_blocks_sent_mutex);
-		JMutexAutoLock l3(m_blocks_sending_mutex);
 		o<<"RemoteClient "<<peer_id<<": "
-				/*<<"m_num_blocks_in_emerge_queue="
-				<<m_num_blocks_in_emerge_queue.get()*/
-				<<", 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.
@@ -358,7 +333,8 @@ class RemoteClient
 	core::map<v3s16, bool> m_blocks_sent;
 	s16 m_nearest_unsent_d;
 	v3s16 m_last_center;
-	JMutex m_blocks_sent_mutex;
+	float m_nearest_unsent_reset_timer;
+	
 	/*
 		Blocks that are currently on the line.
 		This is used for throttling the sending of blocks.
@@ -368,28 +344,32 @@ class RemoteClient
 		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);
@@ -402,57 +382,315 @@ class Server : public con::PeerHandler
 	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()
+	{
+		if(m_configpath != "")
+			g_settings.updateConfigFile(m_configpath.c_str());
+	}
+
+	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);
+	}
+
+	con::Peer* getPeerNoEx(u16 peer_id)
+	{
+		return m_con.GetPeerNoEx(peer_id);
+	}
+
 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);
+	
+	/*
+		Non-static send methods
+	*/
+
 	// Envlock and conlock should be locked when calling these
 	void SendObjectData(float dtime);
 	void SendPlayerInfos();
 	void SendInventory(u16 peer_id);
-	// Sends blocks to clients
+	// 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);
+	
+	// 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 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();
+	}
+
+	/*
+		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.
+
+		Call with env and con locked.
+	*/
+	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
+	*/
+	
+	// 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.
 
+	// Environment
+	ServerEnvironment m_env;
 	JMutex m_env_mutex;
-	Environment m_env;
-
-	JMutex m_con_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;
 	
+	/*
+		Time related stuff
+	*/
+
+	// 0-23999
+	//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