51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-/*
-(c) 2010 Perttu Ahola <celeron55@gmail.com>
-*/
-
#ifndef SERVER_HEADER
#define SERVER_HEADER
#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
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;
{
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;
*/
Server(
- std::string mapsavedir
+ std::string mapsavedir,
+ std::string configpath
);
~Server();
void start(unsigned short port);
core::list<PlayerInfo> getPlayerInfo();
- u32 getDayNightRatio()
+ /*u32 getDayNightRatio()
{
return time_to_daynight_ratio(m_time_of_day.get());
- }
-
+ }*/
+
+ // Environment must be locked when called
void setTimeOfDay(u32 time)
{
- m_time_of_day.set(time);
+ m_env.setTimeOfDay(time);
m_time_of_day_send_timer = 0;
}
bool getShutdownRequested()
{
- return m_shutdown_requested.get();
+ return m_shutdown_requested;
}
/*
void requestShutdown(void)
{
- m_shutdown_requested.set(true);
+ 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);
+ }
+
+ Address getPeerAddress(u16 peer_id)
+ {
+ 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.
void peerAdded(con::Peer *peer);
void deletingPeer(con::Peer *peer, bool timeout);
*/
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
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);
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
+ // Environment and Connection must be locked when called
void SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver);
- // Sends blocks to clients
+ // 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();
+ }
+
/*
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);
-
- /*
- Update water pressure.
- This also adds suitable nodes to active_nodes.
-
- environment has to be locked when calling.
- */
- /*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;
- ServerEnvironment 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;
- MutexedVariable<bool> m_shutdown_requested;
+ // 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
*/
u16 m_ignore_map_edit_events_peer_id;
+ Profiler *m_profiler;
+
friend class EmergeThread;
friend class RemoteClient;
};
projects / oweals / minetest.git / blobdiff