/*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 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
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 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.
+GNU Lesser General Public License for more details.
-You should have received a copy of the GNU General Public License along
+You should have received a copy of the GNU Lesser 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
-#define SERVER_HEADER
+#pragma once
-#include "connection.h"
-#include "environment.h"
-#include "common_irrlicht.h"
-#include <string>
-#include "porting.h"
+#include "irr_v3d.h"
#include "map.h"
-#include "inventory.h"
-#include "auth.h"
-#include "ban.h"
+#include "hud.h"
#include "gamedef.h"
#include "serialization.h" // For SER_FMT_VER_INVALID
-#include "serverremoteplayer.h"
#include "mods.h"
#include "inventorymanager.h"
#include "subgame.h"
-struct LuaState;
-typedef struct lua_State lua_State;
+#include "tileanimation.h" // struct TileAnimationParams
+#include "network/peerhandler.h"
+#include "network/address.h"
+#include "util/numeric.h"
+#include "util/thread.h"
+#include "util/basic_macros.h"
+#include "serverenvironment.h"
+#include "clientiface.h"
+#include "chatmessage.h"
+#include <string>
+#include <list>
+#include <map>
+#include <vector>
+
+class ChatEvent;
+struct ChatEventChat;
+struct ChatInterface;
class IWritableItemDefManager;
class IWritableNodeDefManager;
class IWritableCraftDefManager;
-
-class ServerError : public std::exception
-{
-public:
- ServerError(const std::string &s)
- {
- m_s = "ServerError: ";
- m_s += s;
- }
- virtual ~ServerError() throw()
- {}
- virtual const char * what() const throw()
- {
- return m_s.c_str();
- }
- std::string m_s;
+class BanManager;
+class EventManager;
+class Inventory;
+class RemotePlayer;
+class PlayerSAO;
+class IRollbackManager;
+struct RollbackAction;
+class EmergeManager;
+class ServerScripting;
+class ServerEnvironment;
+struct SimpleSoundSpec;
+class ServerThread;
+
+enum ClientDeletionReason {
+ CDR_LEAVE,
+ CDR_TIMEOUT,
+ CDR_DENY
};
-/*
- Some random functions
-*/
-v3f findSpawnPos(ServerMap &map);
-
-/*
- A structure containing the data needed for queueing the fetching
- of blocks.
-*/
-struct QueuedBlockEmerge
-{
- v3s16 pos;
- // key = peer_id, value = flags
- core::map<u16, u8> peer_ids;
-};
-
-/*
- This is a thread-safe class.
-*/
-class BlockEmergeQueue
-{
-public:
- BlockEmergeQueue()
- {
- m_mutex.Init();
- }
-
- ~BlockEmergeQueue()
- {
- JMutexAutoLock lock(m_mutex);
-
- core::list<QueuedBlockEmerge*>::Iterator i;
- for(i=m_queue.begin(); i!=m_queue.end(); i++)
- {
- QueuedBlockEmerge *q = *i;
- delete q;
- }
- }
-
- /*
- peer_id=0 adds with nobody to send to
- */
- void addBlock(u16 peer_id, v3s16 pos, u8 flags)
- {
- DSTACK(__FUNCTION_NAME);
-
- JMutexAutoLock lock(m_mutex);
-
- if(peer_id != 0)
- {
- /*
- Find if block is already in queue.
- If it is, update the peer to it and quit.
- */
- core::list<QueuedBlockEmerge*>::Iterator i;
- for(i=m_queue.begin(); i!=m_queue.end(); i++)
- {
- QueuedBlockEmerge *q = *i;
- if(q->pos == pos)
- {
- q->peer_ids[peer_id] = flags;
- return;
- }
- }
- }
-
- /*
- Add the block
- */
- QueuedBlockEmerge *q = new QueuedBlockEmerge;
- q->pos = pos;
- if(peer_id != 0)
- q->peer_ids[peer_id] = flags;
- m_queue.push_back(q);
- }
-
- // Returned pointer must be deleted
- // Returns NULL if queue is empty
- QueuedBlockEmerge * pop()
- {
- JMutexAutoLock lock(m_mutex);
-
- core::list<QueuedBlockEmerge*>::Iterator i = m_queue.begin();
- if(i == m_queue.end())
- return NULL;
- QueuedBlockEmerge *q = *i;
- m_queue.erase(i);
- return q;
- }
-
- u32 size()
- {
- JMutexAutoLock lock(m_mutex);
- return m_queue.size();
- }
-
- u32 peerItemCount(u16 peer_id)
- {
- JMutexAutoLock lock(m_mutex);
-
- u32 count = 0;
-
- core::list<QueuedBlockEmerge*>::Iterator i;
- for(i=m_queue.begin(); i!=m_queue.end(); i++)
- {
- QueuedBlockEmerge *q = *i;
- if(q->peer_ids.find(peer_id) != NULL)
- count++;
- }
-
- return count;
- }
-
-private:
- core::list<QueuedBlockEmerge*> m_queue;
- JMutex m_mutex;
-};
-
-class Server;
-
-class ServerThread : public SimpleThread
-{
- Server *m_server;
-
-public:
-
- ServerThread(Server *server):
- SimpleThread(),
- m_server(server)
- {
- }
-
- void * Thread();
-};
-
-class EmergeThread : public SimpleThread
-{
- Server *m_server;
-
-public:
-
- EmergeThread(Server *server):
- SimpleThread(),
- m_server(server)
- {
- }
-
- void * Thread();
-
- void trigger()
- {
- setRun(true);
- if(IsRunning() == false)
- {
- Start();
- }
- }
-};
-
-struct PlayerInfo
-{
- u16 id;
- char name[PLAYERNAME_SIZE];
- v3f position;
- Address address;
- float avg_rtt;
-
- PlayerInfo();
- void PrintLine(std::ostream *s);
-};
-
-/*
- Used for queueing and sorting block transfers in containers
-
- Lower priority number means higher priority.
-*/
-struct PrioritySortedBlockTransfer
-{
- PrioritySortedBlockTransfer(float a_priority, v3s16 a_pos, u16 a_peer_id)
- {
- priority = a_priority;
- pos = a_pos;
- peer_id = a_peer_id;
- }
- bool operator < (PrioritySortedBlockTransfer &other)
- {
- return priority < other.priority;
- }
- float priority;
- v3s16 pos;
- u16 peer_id;
-};
-
-struct TextureRequest
-{
- std::string name;
-
- TextureRequest(const std::string &name_=""):
- name(name_)
- {}
-};
-
-struct TextureInformation
+struct MediaInfo
{
std::string path;
std::string sha1_digest;
- TextureInformation(const std::string path_="",
- const std::string sha1_digest_=""):
+ MediaInfo(const std::string &path_="",
+ const std::string &sha1_digest_=""):
path(path_),
sha1_digest(sha1_digest_)
{
}
};
-class RemoteClient
+struct ServerSoundParams
{
-public:
- // peer_id=0 means this client has no associated peer
- // NOTE: If client is made allowed to exist while peer doesn't,
- // this has to be set to 0 when there is no peer.
- // Also, the client must be moved to some other container.
- 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;
-
- bool definitions_sent;
-
- RemoteClient():
- 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;
- definitions_sent = false;
- m_nearest_unsent_d = 0;
- m_nearest_unsent_reset_timer = 0.0;
- m_nothing_to_send_counter = 0;
- m_nothing_to_send_pause_timer = 0;
- }
- ~RemoteClient()
- {
- }
-
- /*
- Finds block that should be sent next to the client.
- Environment should be locked when this is called.
- dtime is used for resetting send radius at slow interval
- */
- void GetNextBlocks(Server *server, float dtime,
- core::array<PrioritySortedBlockTransfer> &dest);
-
- void GotBlock(v3s16 p);
-
- void SentBlock(v3s16 p);
-
- void SetBlockNotSent(v3s16 p);
- void SetBlocksNotSent(core::map<v3s16, MapBlock*> &blocks);
-
- s32 SendingCount()
- {
- return m_blocks_sending.size();
- }
-
- // Increments timeouts and removes timed-out blocks from list
- // NOTE: This doesn't fix the server-not-sending-block bug
- // because it is related to emerging, not sending.
- //void RunSendingTimeouts(float dtime, float timeout);
-
- void PrintInfo(std::ostream &o)
- {
- o<<"RemoteClient "<<peer_id<<": "
- <<"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
- 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;*/
-
- /*
- List of active objects that the client knows of.
- Value is dummy.
- */
- core::map<u16, bool> m_known_objects;
-
-private:
- /*
- Blocks that have been sent to client.
- - These don't have to be sent again.
- - A block is cleared from here when client says it has
- deleted it from it's memory
-
- Key is position, value is dummy.
- No MapBlock* is stored here because the blocks can get deleted.
- */
- core::map<v3s16, bool> m_blocks_sent;
- s16 m_nearest_unsent_d;
- v3s16 m_last_center;
- float m_nearest_unsent_reset_timer;
-
- /*
- Blocks that are currently on the line.
- This is used for throttling the sending of blocks.
- - The size of this list is limited to some value
- Block is added when it is sent with BLOCKDATA.
- Block is removed when GOTBLOCKS is received.
- Value is time from sending. (not used at the moment)
- */
- core::map<v3s16, float> m_blocks_sending;
+ enum Type {
+ SSP_LOCAL,
+ SSP_POSITIONAL,
+ SSP_OBJECT
+ } type = SSP_LOCAL;
+ float gain = 1.0f;
+ float fade = 0.0f;
+ float pitch = 1.0f;
+ bool loop = false;
+ float max_hear_distance = 32 * BS;
+ v3f pos;
+ u16 object = 0;
+ std::string to_player = "";
+
+ v3f getPos(ServerEnvironment *env, bool *pos_exists) const;
+};
- /*
- 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;
+struct ServerPlayingSound
+{
+ ServerSoundParams params;
+ SimpleSoundSpec spec;
+ std::unordered_set<u16> clients; // peer ids
};
class Server : public con::PeerHandler, public MapEventReceiver,
- public InventoryManager, public IGameDef,
- public IBackgroundBlockEmerger
+ public InventoryManager, public IGameDef
{
public:
/*
NOTE: Every public method should be thread-safe
*/
-
+
Server(
const std::string &path_world,
- const std::string &path_config,
- const SubgameSpec &gamespec
+ const SubgameSpec &gamespec,
+ bool simple_singleplayer_mode,
+ bool ipv6,
+ bool dedicated,
+ ChatInterface *iface = nullptr
);
~Server();
- void start(unsigned short port);
+ DISABLE_CLASS_COPY(Server);
+
+ void start(Address bind_addr);
void stop();
// This is mainly a way to pass the time to the server.
// Actual processing is done in an another thread.
void step(float dtime);
// This is run by ServerThread and does the actual processing
- void AsyncRunStep();
+ void AsyncRunStep(bool initial_step=false);
void Receive();
- void ProcessData(u8 *data, u32 datasize, u16 peer_id);
+ PlayerSAO* StageTwoClientInit(u16 peer_id);
- core::list<PlayerInfo> getPlayerInfo();
-
- /*u32 getDayNightRatio()
- {
- return time_to_daynight_ratio(m_time_of_day.get());
- }*/
-
- // Environment must be locked when called
- void setTimeOfDay(u32 time)
- {
- m_env->setTimeOfDay(time);
- m_time_of_day_send_timer = 0;
- }
+ /*
+ * Command Handlers
+ */
+
+ void handleCommand(NetworkPacket* pkt);
+
+ void handleCommand_Null(NetworkPacket* pkt) {};
+ void handleCommand_Deprecated(NetworkPacket* pkt);
+ void handleCommand_Init(NetworkPacket* pkt);
+ void handleCommand_Init2(NetworkPacket* pkt);
+ void handleCommand_RequestMedia(NetworkPacket* pkt);
+ void handleCommand_ClientReady(NetworkPacket* pkt);
+ void handleCommand_GotBlocks(NetworkPacket* pkt);
+ void handleCommand_PlayerPos(NetworkPacket* pkt);
+ void handleCommand_DeletedBlocks(NetworkPacket* pkt);
+ void handleCommand_InventoryAction(NetworkPacket* pkt);
+ void handleCommand_ChatMessage(NetworkPacket* pkt);
+ void handleCommand_Damage(NetworkPacket* pkt);
+ void handleCommand_Password(NetworkPacket* pkt);
+ void handleCommand_PlayerItem(NetworkPacket* pkt);
+ void handleCommand_Respawn(NetworkPacket* pkt);
+ void handleCommand_Interact(NetworkPacket* pkt);
+ void handleCommand_RemovedSounds(NetworkPacket* pkt);
+ void handleCommand_NodeMetaFields(NetworkPacket* pkt);
+ void handleCommand_InventoryFields(NetworkPacket* pkt);
+ void handleCommand_FirstSrp(NetworkPacket* pkt);
+ void handleCommand_SrpBytesA(NetworkPacket* pkt);
+ void handleCommand_SrpBytesM(NetworkPacket* pkt);
+
+ void ProcessData(NetworkPacket *pkt);
+
+ void Send(NetworkPacket* pkt);
+
+ // Helper for handleCommand_PlayerPos and handleCommand_Interact
+ void process_PlayerPos(RemotePlayer *player, PlayerSAO *playersao,
+ NetworkPacket *pkt);
+
+ // Both setter and getter need no envlock,
+ // can be called freely from threads
+ void setTimeOfDay(u32 time);
- bool getShutdownRequested()
- {
- return m_shutdown_requested;
- }
-
/*
Shall be called with the environment locked.
This is accessed by the map, which is inside the environment,
Shall be called with the environment and the connection locked.
*/
Inventory* getInventory(const InventoryLocation &loc);
- std::string getInventoryOwner(const InventoryLocation &loc);
- void setInventoryModified(const InventoryLocation &loc);
+ void setInventoryModified(const InventoryLocation &loc, bool playerSend = true);
// Connection must be locked when called
std::wstring getStatusString();
+ inline double getUptime() const { return m_uptime.m_value; }
+
+ // read shutdown state
+ inline bool getShutdownRequested() const { return m_shutdown_requested; }
+
+ // request server to shutdown
+ void requestShutdown(const std::string &msg, bool reconnect, float delay = 0.0f);
+
+ // Returns -1 if failed, sound handle on success
+ // Envlock
+ s32 playSound(const SimpleSoundSpec &spec, const ServerSoundParams ¶ms);
+ void stopSound(s32 handle);
+ void fadeSound(s32 handle, float step, float gain);
+
+ // Envlock
+ std::set<std::string> getPlayerEffectivePrivs(const std::string &name);
+ bool checkPriv(const std::string &name, const std::string &priv);
+ void reportPrivsModified(const std::string &name=""); // ""=all
+ void reportInventoryFormspecModified(const std::string &name);
+
+ void setIpBanned(const std::string &ip, const std::string &name);
+ void unsetIpBanned(const std::string &ip_or_name);
+ std::string getBanDescription(const std::string &ip_or_name);
+
+ void notifyPlayer(const char *name, const std::wstring &msg);
+ void notifyPlayers(const std::wstring &msg);
+ void spawnParticle(const std::string &playername,
+ v3f pos, v3f velocity, v3f acceleration,
+ float expirationtime, float size,
+ bool collisiondetection, bool collision_removal,
+ bool vertical, const std::string &texture,
+ const struct TileAnimationParams &animation, u8 glow);
+
+ u32 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 collision_removal,
+ ServerActiveObject *attached,
+ bool vertical, const std::string &texture,
+ const std::string &playername, const struct TileAnimationParams &animation,
+ u8 glow);
+
+ void deleteParticleSpawner(const std::string &playername, u32 id);
+
+ // Creates or resets inventory
+ Inventory* createDetachedInventory(const std::string &name, const std::string &player="");
+
+ // Envlock and conlock should be locked when using scriptapi
+ ServerScripting *getScriptIface(){ return m_script; }
+
+ // actions: time-reversed list
+ // Return value: success/failure
+ bool rollbackRevertActions(const std::list<RollbackAction> &actions,
+ std::list<std::string> *log);
- 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;
- }
- }
-
- // Changes a player's password, password must be given as plaintext
- // If the player doesn't exist, a new entry is added to the auth manager
- void setPlayerPassword(const std::string &name, const std::wstring &password);
-
- // 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);
-
- void queueBlockEmerge(v3s16 blockpos, bool allow_generate);
-
- // Envlock and conlock should be locked when using Lua
- lua_State *getLua(){ return m_lua; }
-
// IGameDef interface
// Under envlock
virtual IItemDefManager* getItemDefManager();
virtual INodeDefManager* getNodeDefManager();
virtual ICraftDefManager* getCraftDefManager();
- virtual ITextureSource* getTextureSource();
virtual u16 allocateUnknownNodeId(const std::string &name);
-
+ virtual MtEventManager* getEventManager();
+ IRollbackManager *getRollbackManager() { return m_rollback; }
+ virtual EmergeManager *getEmergeManager() { return m_emerge; }
+
IWritableItemDefManager* getWritableItemDefManager();
IWritableNodeDefManager* getWritableNodeDefManager();
IWritableCraftDefManager* getWritableCraftDefManager();
- const ModSpec* getModSpec(const std::string &modname);
-
- std::string getWorldPath(){ return m_path_world; }
+ virtual const std::vector<ModSpec> &getMods() const { return m_mods; }
+ virtual const ModSpec* getModSpec(const std::string &modname) const;
+ void getModNames(std::vector<std::string> &modlist);
+ std::string getBuiltinLuaPath();
+ virtual std::string getWorldPath() const { return m_path_world; }
+ virtual std::string getModStoragePath() const;
+
+ inline bool isSingleplayer()
+ { return m_simple_singleplayer_mode; }
+
+ inline void setAsyncFatalError(const std::string &error)
+ { m_async_fatal_error.set(error); }
+
+ bool showFormspec(const char *name, const std::string &formspec, const std::string &formname);
+ Map & getMap() { return m_env->getMap(); }
+ ServerEnvironment & getEnv() { return *m_env; }
+ v3f findSpawnPos();
+
+ u32 hudAdd(RemotePlayer *player, HudElement *element);
+ bool hudRemove(RemotePlayer *player, u32 id);
+ bool hudChange(RemotePlayer *player, u32 id, HudElementStat stat, void *value);
+ bool hudSetFlags(RemotePlayer *player, u32 flags, u32 mask);
+ bool hudSetHotbarItemcount(RemotePlayer *player, s32 hotbar_itemcount);
+ s32 hudGetHotbarItemcount(RemotePlayer *player) const;
+ void hudSetHotbarImage(RemotePlayer *player, std::string name);
+ std::string hudGetHotbarImage(RemotePlayer *player);
+ void hudSetHotbarSelectedImage(RemotePlayer *player, std::string name);
+ const std::string &hudGetHotbarSelectedImage(RemotePlayer *player) const;
+
+ Address getPeerAddress(u16 peer_id);
+
+ bool setLocalPlayerAnimations(RemotePlayer *player, v2s32 animation_frames[4],
+ f32 frame_speed);
+ bool setPlayerEyeOffset(RemotePlayer *player, v3f first, v3f third);
+
+ bool setSky(RemotePlayer *player, const video::SColor &bgcolor,
+ const std::string &type, const std::vector<std::string> ¶ms,
+ bool &clouds);
+ bool setClouds(RemotePlayer *player, float density,
+ const video::SColor &color_bright,
+ const video::SColor &color_ambient,
+ float height,
+ float thickness,
+ const v2f &speed);
+
+ bool overrideDayNightRatio(RemotePlayer *player, bool do_override, float brightness);
+
+ /* con::PeerHandler implementation. */
+ void peerAdded(con::Peer *peer);
+ void deletingPeer(con::Peer *peer, bool timeout);
- void setAsyncFatalError(const std::string &error)
- {
- m_async_fatal_error.set(error);
- }
+ void DenySudoAccess(u16 peer_id);
+ void DenyAccessVerCompliant(u16 peer_id, u16 proto_ver, AccessDeniedCode reason,
+ const std::string &str_reason = "", bool reconnect = false);
+ void DenyAccess(u16 peer_id, AccessDeniedCode reason, const std::string &custom_reason="");
+ void acceptAuth(u16 peer_id, bool forSudoMode);
+ void DenyAccess_Legacy(u16 peer_id, const std::wstring &reason);
+ bool getClientConInfo(u16 peer_id, con::rtt_stat_type type, float* retval);
+ bool getClientInfo(u16 peer_id,ClientState* state, u32* uptime,
+ u8* ser_vers, u16* prot_vers, u8* major, u8* minor, u8* patch,
+ std::string* vers_string);
+
+ void printToConsoleOnly(const std::string &text);
+
+ void SendPlayerHPOrDie(PlayerSAO *player);
+ void SendPlayerBreath(PlayerSAO *sao);
+ void SendInventory(PlayerSAO* playerSAO);
+ void SendMovePlayer(u16 peer_id);
+
+ virtual bool registerModStorage(ModMetadata *storage);
+ virtual void unregisterModStorage(const std::string &name);
+
+ // Bind address
+ Address m_bind_addr;
+
+ // Environment mutex (envlock)
+ std::mutex m_env_mutex;
private:
- // 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 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);
- static void SendItemDef(con::Connection &con, u16 peer_id,
- IItemDefManager *itemdef);
- static void SendNodeDef(con::Connection &con, u16 peer_id,
- INodeDefManager *nodedef);
-
- /*
- Non-static send methods.
- Conlock should be always used.
- Envlock usage is documented badly but it's easy to figure out
- which ones access the environment.
- */
+ friend class EmergeThread;
+ friend class RemoteClient;
+
+ void SendMovement(u16 peer_id);
+ void SendHP(u16 peer_id, u16 hp);
+ void SendBreath(u16 peer_id, u16 breath);
+ void SendAccessDenied(u16 peer_id, AccessDeniedCode reason,
+ const std::string &custom_reason, bool reconnect = false);
+ void SendAccessDenied_Legacy(u16 peer_id, const std::wstring &reason);
+ void SendDeathscreen(u16 peer_id,bool set_camera_point_target, v3f camera_point_target);
+ void SendItemDef(u16 peer_id,IItemDefManager *itemdef, u16 protocol_version);
+ void SendNodeDef(u16 peer_id,INodeDefManager *nodedef, u16 protocol_version);
+
+ /* mark blocks not sent for all clients */
+ void SetBlocksNotSent(std::map<v3s16, MapBlock *>& block);
+
+
+ void SendChatMessage(u16 peer_id, const ChatMessage &message);
+ void SendTimeOfDay(u16 peer_id, u16 time, f32 time_speed);
+ void SendPlayerHP(u16 peer_id);
+
+ void SendLocalPlayerAnimations(u16 peer_id, v2s32 animation_frames[4], f32 animation_speed);
+ void SendEyeOffset(u16 peer_id, v3f first, v3f third);
+ void SendPlayerPrivileges(u16 peer_id);
+ void SendPlayerInventoryFormspec(u16 peer_id);
+ void SendShowFormspecMessage(u16 peer_id, const std::string &formspec, const std::string &formname);
+ void SendHUDAdd(u16 peer_id, u32 id, HudElement *form);
+ void SendHUDRemove(u16 peer_id, u32 id);
+ void SendHUDChange(u16 peer_id, u32 id, HudElementStat stat, void *value);
+ void SendHUDSetFlags(u16 peer_id, u32 flags, u32 mask);
+ void SendHUDSetParam(u16 peer_id, u16 param, const std::string &value);
+ void SendSetSky(u16 peer_id, const video::SColor &bgcolor,
+ const std::string &type, const std::vector<std::string> ¶ms,
+ bool &clouds);
+ void SendCloudParams(u16 peer_id, float density,
+ const video::SColor &color_bright,
+ const video::SColor &color_ambient,
+ float height,
+ float thickness,
+ const v2f &speed);
+ void SendOverrideDayNightRatio(u16 peer_id, bool do_override, float ratio);
- // Envlock and conlock should be locked when calling these
- void SendInventory(u16 peer_id);
- // send wielded item info about player to all
- void SendWieldedItem(const ServerRemotePlayer *srp);
- // 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
*/
// 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);
+ std::vector<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);
+ std::vector<u16> *far_players=NULL, float far_d_nodes=100,
+ bool remove_metadata=true);
void setBlockNotSent(v3s16 p);
-
+
// Environment and Connection must be locked when called
- void SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver);
-
+ void SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver, u16 net_proto_version);
+
// Sends blocks to clients (locks env and con on its own)
void SendBlocks(float dtime);
-
- void PrepareTextures();
-
- void SendTextureAnnouncement(u16 peer_id);
- void SendTexturesRequested(u16 peer_id,core::list<TextureRequest> tosend);
+ void fillMediaCache();
+ void sendMediaAnnouncement(u16 peer_id, const std::string &lang_code);
+ void sendRequestedMedia(u16 peer_id,
+ const std::vector<std::string> &tosend);
+
+ void sendDetachedInventory(const std::string &name, u16 peer_id);
+ void sendDetachedInventories(u16 peer_id);
+
+ // Adds a ParticleSpawner on peer with peer_id (PEER_ID_INEXISTENT == all)
+ void SendAddParticleSpawner(u16 peer_id, u16 protocol_version,
+ 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 collision_removal,
+ u16 attached_id,
+ bool vertical, const std::string &texture, u32 id,
+ const struct TileAnimationParams &animation, u8 glow);
+
+ void SendDeleteParticleSpawner(u16 peer_id, u32 id);
+
+ // Spawns particle on peer with peer_id (PEER_ID_INEXISTENT == all)
+ void SendSpawnParticle(u16 peer_id, u16 protocol_version,
+ v3f pos, v3f velocity, v3f acceleration,
+ float expirationtime, float size,
+ bool collisiondetection, bool collision_removal,
+ bool vertical, const std::string &texture,
+ const struct TileAnimationParams &animation, u8 glow);
+
+ u32 SendActiveObjectRemoveAdd(u16 peer_id, const std::string &datas);
+ void SendActiveObjectMessages(u16 peer_id, const std::string &datas, bool reliable = true);
+ void SendCSMFlavourLimits(u16 peer_id);
/*
Something random
*/
-
- void DiePlayer(Player *player);
- void RespawnPlayer(Player *player);
-
- void UpdateCrafting(u16 peer_id);
-
+
+ void DiePlayer(u16 peer_id);
+ void RespawnPlayer(u16 peer_id);
+ void DeleteClient(u16 peer_id, ClientDeletionReason reason);
+ void UpdateCrafting(RemotePlayer *player);
+
+ void handleChatInterfaceEvent(ChatEvent *evt);
+
+ // This returns the answer to the sender of wmessage, or "" if there is none
+ std::wstring handleChat(const std::string &name, const std::wstring &wname,
+ std::wstring wmessage_input,
+ bool check_shout_priv = false,
+ RemotePlayer *player = NULL);
+ void handleAdminChat(const ChatEventChat *evt);
+
// When called, connection mutex should be locked
- RemoteClient* getClient(u16 peer_id);
-
+ RemoteClient* getClient(u16 peer_id,ClientState state_min=CS_Active);
+ RemoteClient* getClientNoEx(u16 peer_id,ClientState state_min=CS_Active);
+
// 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();
- }
+ std::string getPlayerName(u16 peer_id);
+ PlayerSAO* getPlayerSAO(u16 peer_id);
/*
Get a player from memory or creates one.
Call with env and con locked.
*/
- ServerRemotePlayer *emergePlayer(const char *name, u16 peer_id);
-
- // Locks environment and connection by its own
- struct PeerChange;
- void handlePeerChange(PeerChange &c);
- void handlePeerChanges();
+ PlayerSAO *emergePlayer(const char *name, u16 peer_id, u16 proto_version);
- u64 getPlayerPrivs(Player *player);
+ void handlePeerChanges();
/*
Variables
*/
-
+
// World directory
std::string m_path_world;
- // Path to user's configuration file ("" = no configuration file)
- std::string m_path_config;
// Subgame specification
SubgameSpec m_gamespec;
+ // If true, do not allow multiple players and hide some multiplayer
+ // functionality
+ bool m_simple_singleplayer_mode;
+ u16 m_max_chatmessage_length;
+ // For "dedicated" server list flag
+ bool m_dedicated;
- // Equivalent of /usr/share/minetest/server
- std::string m_path_share;
-
// Thread can set; step() will throw as ServerError
MutexedVariable<std::string> m_async_fatal_error;
-
+
// 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;
+ float m_liquid_transform_timer = 0.0f;
+ float m_liquid_transform_every = 1.0f;
+ float m_masterserver_timer = 0.0f;
+ float m_emergethread_trigger_timer = 0.0f;
+ float m_savemap_timer = 0.0f;
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;
-
- // Connection
- con::Connection m_con;
- JMutex m_con_mutex;
- // Connected clients (behind the con mutex)
- core::map<u16, RemoteClient*> m_clients;
+ ServerEnvironment *m_env = nullptr;
- // User authentication
- AuthManager m_authmanager;
+ // server connection
+ std::shared_ptr<con::Connection> m_con;
- // Bann checking
- BanManager m_banmanager;
+ // Ban checking
+ BanManager *m_banmanager = nullptr;
+
+ // Rollback manager (behind m_env_mutex)
+ IRollbackManager *m_rollback = nullptr;
+ bool m_enable_rollback_recording = false; // Updated once in a while
+
+ // Emerge manager
+ EmergeManager *m_emerge = nullptr;
// Scripting
// Envlock and conlock should be locked when using Lua
- lua_State *m_lua;
+ ServerScripting *m_script = nullptr;
// Item definition manager
IWritableItemDefManager *m_itemdef;
-
+
// Node definition manager
IWritableNodeDefManager *m_nodedef;
-
+
// Craft definition manager
IWritableCraftDefManager *m_craftdef;
-
+
+ // Event manager
+ EventManager *m_event;
+
// Mods
- core::list<ModSpec> m_mods;
-
+ std::vector<ModSpec> m_mods;
+
/*
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;
+ float m_step_dtime = 0.0f;
+ std::mutex m_step_dtime_mutex;
+
+ // current server step lag counter
+ float m_lag;
// 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;
-
+ ServerThread *m_thread = nullptr;
+
/*
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;
+ float m_time_of_day_send_timer = 0.0f;
// Uptime of server in seconds
MutexedVariable<double> m_uptime;
-
+ /*
+ Client interface
+ */
+ ClientInterface m_clients;
+
/*
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;
+ std::queue<con::PeerChange> m_peer_change_queue;
/*
Random stuff
*/
-
- // Mod parent directory paths
- core::list<std::string> m_modspaths;
- bool m_shutdown_requested;
+ bool m_shutdown_requested = false;
+ std::string m_shutdown_msg;
+ bool m_shutdown_ask_reconnect = false;
+ float m_shutdown_timer = 0.0f;
+
+ ChatInterface *m_admin_chat;
+ std::string m_admin_nick;
/*
Map edit event queue. Automatically receives all map edits.
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;
+ std::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;
+ bool m_ignore_map_edit_events = false;
+ /*
+ If a non-empty area, map edit events contained within are left
+ unsent. Done at map generation time to speed up editing of the
+ generated area, as it will be sent anyway.
+ This is behind m_env_mutex
+ */
+ VoxelArea m_ignore_map_edit_events_area;
/*
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;
+ u16 m_ignore_map_edit_events_peer_id = 0;
- friend class EmergeThread;
- friend class RemoteClient;
+ // media files known to server
+ std::unordered_map<std::string, MediaInfo> m_media;
+
+ /*
+ Sounds
+ */
+ std::unordered_map<s32, ServerPlayingSound> m_playing_sounds;
+ s32 m_next_sound_id = 0;
- std::map<std::string,TextureInformation> m_Textures;
+ /*
+ Detached inventories (behind m_env_mutex)
+ */
+ // key = name
+ std::map<std::string, Inventory*> m_detached_inventories;
+ // value = "" (visible to all players) or player name
+ std::map<std::string, std::string> m_detached_inventories_player;
+
+ std::unordered_map<std::string, ModMetadata *> m_mod_storages;
+ float m_mod_storage_save_timer = 10.0f;
+
+ // CSM flavour limits byteflag
+ u64 m_csm_flavour_limits = CSMFlavourLimit::CSM_FL_NONE;
+ u32 m_csm_noderange_limit = 8;
};
/*
Runs a simple dedicated server loop.
- Shuts down when run is set to false.
+ Shuts down when kill is set to true.
*/
-void dedicated_server_loop(Server &server, bool &run);
-
-#endif
-
+void dedicated_server_loop(Server &server, bool &kill);