3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU Lesser General Public License as published by
7 the Free Software Foundation; either version 2.1 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public License along
16 with this program; if not, write to the Free Software Foundation, Inc.,
17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23 #include "network/connection.h"
28 #include "serialization.h" // For SER_FMT_VER_INVALID
30 #include "inventorymanager.h"
32 #include "tileanimation.h" // struct TileAnimationParams
33 #include "util/numeric.h"
34 #include "util/thread.h"
35 #include "util/basic_macros.h"
36 #include "serverenvironment.h"
37 #include "chat_interface.h"
38 #include "clientiface.h"
39 #include "remoteplayer.h"
40 #include "network/networkpacket.h"
46 class IWritableItemDefManager;
47 class IWritableNodeDefManager;
48 class IWritableCraftDefManager;
53 class IRollbackManager;
54 struct RollbackAction;
56 class ServerScripting;
57 class ServerEnvironment;
58 struct SimpleSoundSpec;
61 enum ClientDeletionReason {
67 class MapEditEventAreaIgnorer
70 MapEditEventAreaIgnorer(VoxelArea *ignorevariable, const VoxelArea &a):
71 m_ignorevariable(ignorevariable)
73 if(m_ignorevariable->getVolume() == 0)
74 *m_ignorevariable = a;
76 m_ignorevariable = NULL;
79 ~MapEditEventAreaIgnorer()
83 assert(m_ignorevariable->getVolume() != 0);
84 *m_ignorevariable = VoxelArea();
89 VoxelArea *m_ignorevariable;
95 std::string sha1_digest;
97 MediaInfo(const std::string &path_="",
98 const std::string &sha1_digest_=""):
100 sha1_digest(sha1_digest_)
105 struct ServerSoundParams
116 float max_hear_distance = 32*BS;
117 v3f pos = v3f(0, 0, 0);
119 std::string to_player = "";
121 v3f getPos(ServerEnvironment *env, bool *pos_exists) const;
124 struct ServerPlayingSound
126 ServerSoundParams params;
127 SimpleSoundSpec spec;
128 std::unordered_set<u16> clients; // peer ids
131 class Server : public con::PeerHandler, public MapEventReceiver,
132 public InventoryManager, public IGameDef
136 NOTE: Every public method should be thread-safe
140 const std::string &path_world,
141 const SubgameSpec &gamespec,
142 bool simple_singleplayer_mode,
145 ChatInterface *iface = NULL
148 DISABLE_CLASS_COPY(Server);
150 void start(Address bind_addr);
152 // This is mainly a way to pass the time to the server.
153 // Actual processing is done in an another thread.
154 void step(float dtime);
155 // This is run by ServerThread and does the actual processing
156 void AsyncRunStep(bool initial_step=false);
158 PlayerSAO* StageTwoClientInit(u16 peer_id);
164 void handleCommand(NetworkPacket* pkt);
166 void handleCommand_Null(NetworkPacket* pkt) {};
167 void handleCommand_Deprecated(NetworkPacket* pkt);
168 void handleCommand_Init(NetworkPacket* pkt);
169 void handleCommand_Init_Legacy(NetworkPacket* pkt);
170 void handleCommand_Init2(NetworkPacket* pkt);
171 void handleCommand_RequestMedia(NetworkPacket* pkt);
172 void handleCommand_ClientReady(NetworkPacket* pkt);
173 void handleCommand_GotBlocks(NetworkPacket* pkt);
174 void handleCommand_PlayerPos(NetworkPacket* pkt);
175 void handleCommand_DeletedBlocks(NetworkPacket* pkt);
176 void handleCommand_InventoryAction(NetworkPacket* pkt);
177 void handleCommand_ChatMessage(NetworkPacket* pkt);
178 void handleCommand_Damage(NetworkPacket* pkt);
179 void handleCommand_Password(NetworkPacket* pkt);
180 void handleCommand_PlayerItem(NetworkPacket* pkt);
181 void handleCommand_Respawn(NetworkPacket* pkt);
182 void handleCommand_Interact(NetworkPacket* pkt);
183 void handleCommand_RemovedSounds(NetworkPacket* pkt);
184 void handleCommand_NodeMetaFields(NetworkPacket* pkt);
185 void handleCommand_InventoryFields(NetworkPacket* pkt);
186 void handleCommand_FirstSrp(NetworkPacket* pkt);
187 void handleCommand_SrpBytesA(NetworkPacket* pkt);
188 void handleCommand_SrpBytesM(NetworkPacket* pkt);
190 void ProcessData(NetworkPacket *pkt);
192 void Send(NetworkPacket* pkt);
194 // Helper for handleCommand_PlayerPos and handleCommand_Interact
195 void process_PlayerPos(RemotePlayer *player, PlayerSAO *playersao,
198 // Both setter and getter need no envlock,
199 // can be called freely from threads
200 void setTimeOfDay(u32 time);
203 Shall be called with the environment locked.
204 This is accessed by the map, which is inside the environment,
205 so it shouldn't be a problem.
207 void onMapEditEvent(MapEditEvent *event);
210 Shall be called with the environment and the connection locked.
212 Inventory* getInventory(const InventoryLocation &loc);
213 void setInventoryModified(const InventoryLocation &loc, bool playerSend = true);
215 // Connection must be locked when called
216 std::wstring getStatusString();
217 inline double getUptime() const { return m_uptime.m_value; }
219 // read shutdown state
220 inline bool getShutdownRequested() const { return m_shutdown_requested; }
222 // request server to shutdown
223 void requestShutdown(const std::string &msg, bool reconnect, float delay = 0.0f);
225 // Returns -1 if failed, sound handle on success
227 s32 playSound(const SimpleSoundSpec &spec, const ServerSoundParams ¶ms);
228 void stopSound(s32 handle);
229 void fadeSound(s32 handle, float step, float gain);
232 std::set<std::string> getPlayerEffectivePrivs(const std::string &name);
233 bool checkPriv(const std::string &name, const std::string &priv);
234 void reportPrivsModified(const std::string &name=""); // ""=all
235 void reportInventoryFormspecModified(const std::string &name);
237 void setIpBanned(const std::string &ip, const std::string &name);
238 void unsetIpBanned(const std::string &ip_or_name);
239 std::string getBanDescription(const std::string &ip_or_name);
241 void notifyPlayer(const char *name, const std::wstring &msg);
242 void notifyPlayers(const std::wstring &msg);
243 void spawnParticle(const std::string &playername,
244 v3f pos, v3f velocity, v3f acceleration,
245 float expirationtime, float size,
246 bool collisiondetection, bool collision_removal,
247 bool vertical, const std::string &texture,
248 const struct TileAnimationParams &animation, u8 glow);
250 u32 addParticleSpawner(u16 amount, float spawntime,
251 v3f minpos, v3f maxpos,
252 v3f minvel, v3f maxvel,
253 v3f minacc, v3f maxacc,
254 float minexptime, float maxexptime,
255 float minsize, float maxsize,
256 bool collisiondetection, bool collision_removal,
257 ServerActiveObject *attached,
258 bool vertical, const std::string &texture,
259 const std::string &playername, const struct TileAnimationParams &animation,
262 void deleteParticleSpawner(const std::string &playername, u32 id);
264 // Creates or resets inventory
265 Inventory* createDetachedInventory(const std::string &name, const std::string &player="");
267 // Envlock and conlock should be locked when using scriptapi
268 ServerScripting *getScriptIface(){ return m_script; }
270 // actions: time-reversed list
271 // Return value: success/failure
272 bool rollbackRevertActions(const std::list<RollbackAction> &actions,
273 std::list<std::string> *log);
275 // IGameDef interface
277 virtual IItemDefManager* getItemDefManager();
278 virtual INodeDefManager* getNodeDefManager();
279 virtual ICraftDefManager* getCraftDefManager();
280 virtual u16 allocateUnknownNodeId(const std::string &name);
281 virtual MtEventManager* getEventManager();
282 IRollbackManager *getRollbackManager() { return m_rollback; }
283 virtual EmergeManager *getEmergeManager() { return m_emerge; }
285 IWritableItemDefManager* getWritableItemDefManager();
286 IWritableNodeDefManager* getWritableNodeDefManager();
287 IWritableCraftDefManager* getWritableCraftDefManager();
289 virtual const std::vector<ModSpec> &getMods() const { return m_mods; }
290 virtual const ModSpec* getModSpec(const std::string &modname) const;
291 void getModNames(std::vector<std::string> &modlist);
292 std::string getBuiltinLuaPath();
293 virtual std::string getWorldPath() const { return m_path_world; }
294 virtual std::string getModStoragePath() const;
296 inline bool isSingleplayer()
297 { return m_simple_singleplayer_mode; }
299 inline void setAsyncFatalError(const std::string &error)
300 { m_async_fatal_error.set(error); }
302 bool showFormspec(const char *name, const std::string &formspec, const std::string &formname);
303 Map & getMap() { return m_env->getMap(); }
304 ServerEnvironment & getEnv() { return *m_env; }
307 u32 hudAdd(RemotePlayer *player, HudElement *element);
308 bool hudRemove(RemotePlayer *player, u32 id);
309 bool hudChange(RemotePlayer *player, u32 id, HudElementStat stat, void *value);
310 bool hudSetFlags(RemotePlayer *player, u32 flags, u32 mask);
311 bool hudSetHotbarItemcount(RemotePlayer *player, s32 hotbar_itemcount);
312 s32 hudGetHotbarItemcount(RemotePlayer *player) const
313 { return player->getHotbarItemcount(); }
314 void hudSetHotbarImage(RemotePlayer *player, std::string name);
315 std::string hudGetHotbarImage(RemotePlayer *player);
316 void hudSetHotbarSelectedImage(RemotePlayer *player, std::string name);
317 const std::string &hudGetHotbarSelectedImage(RemotePlayer *player) const
319 return player->getHotbarSelectedImage();
322 inline Address getPeerAddress(u16 peer_id)
323 { return m_con.GetPeerAddress(peer_id); }
325 bool setLocalPlayerAnimations(RemotePlayer *player, v2s32 animation_frames[4],
327 bool setPlayerEyeOffset(RemotePlayer *player, v3f first, v3f third);
329 bool setSky(RemotePlayer *player, const video::SColor &bgcolor,
330 const std::string &type, const std::vector<std::string> ¶ms,
332 bool setClouds(RemotePlayer *player, float density,
333 const video::SColor &color_bright,
334 const video::SColor &color_ambient,
339 bool overrideDayNightRatio(RemotePlayer *player, bool do_override, float brightness);
341 /* con::PeerHandler implementation. */
342 void peerAdded(con::Peer *peer);
343 void deletingPeer(con::Peer *peer, bool timeout);
345 void DenySudoAccess(u16 peer_id);
346 void DenyAccessVerCompliant(u16 peer_id, u16 proto_ver, AccessDeniedCode reason,
347 const std::string &str_reason = "", bool reconnect = false);
348 void DenyAccess(u16 peer_id, AccessDeniedCode reason, const std::string &custom_reason="");
349 void acceptAuth(u16 peer_id, bool forSudoMode);
350 void DenyAccess_Legacy(u16 peer_id, const std::wstring &reason);
351 bool getClientConInfo(u16 peer_id, con::rtt_stat_type type,float* retval);
352 bool getClientInfo(u16 peer_id,ClientState* state, u32* uptime,
353 u8* ser_vers, u16* prot_vers, u8* major, u8* minor, u8* patch,
354 std::string* vers_string);
356 void printToConsoleOnly(const std::string &text);
358 void SendPlayerHPOrDie(PlayerSAO *player);
359 void SendPlayerBreath(PlayerSAO *sao);
360 void SendInventory(PlayerSAO* playerSAO);
361 void SendMovePlayer(u16 peer_id);
363 virtual bool registerModStorage(ModMetadata *storage);
364 virtual void unregisterModStorage(const std::string &name);
369 // Environment mutex (envlock)
370 std::mutex m_env_mutex;
374 friend class EmergeThread;
375 friend class RemoteClient;
377 void SendMovement(u16 peer_id);
378 void SendHP(u16 peer_id, u8 hp);
379 void SendBreath(u16 peer_id, u16 breath);
380 void SendAccessDenied(u16 peer_id, AccessDeniedCode reason,
381 const std::string &custom_reason, bool reconnect = false);
382 void SendAccessDenied_Legacy(u16 peer_id, const std::wstring &reason);
383 void SendDeathscreen(u16 peer_id,bool set_camera_point_target, v3f camera_point_target);
384 void SendItemDef(u16 peer_id,IItemDefManager *itemdef, u16 protocol_version);
385 void SendNodeDef(u16 peer_id,INodeDefManager *nodedef, u16 protocol_version);
387 /* mark blocks not sent for all clients */
388 void SetBlocksNotSent(std::map<v3s16, MapBlock *>& block);
391 void SendChatMessage(u16 peer_id, const std::wstring &message);
392 void SendTimeOfDay(u16 peer_id, u16 time, f32 time_speed);
393 void SendPlayerHP(u16 peer_id);
395 void SendLocalPlayerAnimations(u16 peer_id, v2s32 animation_frames[4], f32 animation_speed);
396 void SendEyeOffset(u16 peer_id, v3f first, v3f third);
397 void SendPlayerPrivileges(u16 peer_id);
398 void SendPlayerInventoryFormspec(u16 peer_id);
399 void SendShowFormspecMessage(u16 peer_id, const std::string &formspec, const std::string &formname);
400 void SendHUDAdd(u16 peer_id, u32 id, HudElement *form);
401 void SendHUDRemove(u16 peer_id, u32 id);
402 void SendHUDChange(u16 peer_id, u32 id, HudElementStat stat, void *value);
403 void SendHUDSetFlags(u16 peer_id, u32 flags, u32 mask);
404 void SendHUDSetParam(u16 peer_id, u16 param, const std::string &value);
405 void SendSetSky(u16 peer_id, const video::SColor &bgcolor,
406 const std::string &type, const std::vector<std::string> ¶ms,
408 void SendCloudParams(u16 peer_id, float density,
409 const video::SColor &color_bright,
410 const video::SColor &color_ambient,
414 void SendOverrideDayNightRatio(u16 peer_id, bool do_override, float ratio);
417 Send a node removal/addition event to all clients except ignore_id.
418 Additionally, if far_players!=NULL, players further away than
419 far_d_nodes are ignored and their peer_ids are added to far_players
421 // Envlock and conlock should be locked when calling these
422 void sendRemoveNode(v3s16 p, u16 ignore_id=0,
423 std::vector<u16> *far_players=NULL, float far_d_nodes=100);
424 void sendAddNode(v3s16 p, MapNode n, u16 ignore_id=0,
425 std::vector<u16> *far_players=NULL, float far_d_nodes=100,
426 bool remove_metadata=true);
427 void setBlockNotSent(v3s16 p);
429 // Environment and Connection must be locked when called
430 void SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver, u16 net_proto_version);
432 // Sends blocks to clients (locks env and con on its own)
433 void SendBlocks(float dtime);
435 void fillMediaCache();
436 void sendMediaAnnouncement(u16 peer_id);
437 void sendRequestedMedia(u16 peer_id,
438 const std::vector<std::string> &tosend);
440 void sendDetachedInventory(const std::string &name, u16 peer_id);
441 void sendDetachedInventories(u16 peer_id);
443 // Adds a ParticleSpawner on peer with peer_id (PEER_ID_INEXISTENT == all)
444 void SendAddParticleSpawner(u16 peer_id, u16 protocol_version,
445 u16 amount, float spawntime,
446 v3f minpos, v3f maxpos,
447 v3f minvel, v3f maxvel,
448 v3f minacc, v3f maxacc,
449 float minexptime, float maxexptime,
450 float minsize, float maxsize,
451 bool collisiondetection, bool collision_removal,
453 bool vertical, const std::string &texture, u32 id,
454 const struct TileAnimationParams &animation, u8 glow);
456 void SendDeleteParticleSpawner(u16 peer_id, u32 id);
458 // Spawns particle on peer with peer_id (PEER_ID_INEXISTENT == all)
459 void SendSpawnParticle(u16 peer_id, u16 protocol_version,
460 v3f pos, v3f velocity, v3f acceleration,
461 float expirationtime, float size,
462 bool collisiondetection, bool collision_removal,
463 bool vertical, const std::string &texture,
464 const struct TileAnimationParams &animation, u8 glow);
466 u32 SendActiveObjectRemoveAdd(u16 peer_id, const std::string &datas);
467 void SendActiveObjectMessages(u16 peer_id, const std::string &datas, bool reliable = true);
472 void DiePlayer(u16 peer_id);
473 void RespawnPlayer(u16 peer_id);
474 void DeleteClient(u16 peer_id, ClientDeletionReason reason);
475 void UpdateCrafting(RemotePlayer *player);
477 void handleChatInterfaceEvent(ChatEvent *evt);
479 // This returns the answer to the sender of wmessage, or "" if there is none
480 std::wstring handleChat(const std::string &name, const std::wstring &wname,
481 std::wstring wmessage_input,
482 bool check_shout_priv = false,
483 RemotePlayer *player = NULL);
484 void handleAdminChat(const ChatEventChat *evt);
486 // When called, connection mutex should be locked
487 RemoteClient* getClient(u16 peer_id,ClientState state_min=CS_Active);
488 RemoteClient* getClientNoEx(u16 peer_id,ClientState state_min=CS_Active);
490 // When called, environment mutex should be locked
491 std::string getPlayerName(u16 peer_id);
492 PlayerSAO* getPlayerSAO(u16 peer_id);
495 Get a player from memory or creates one.
496 If player is already connected, return NULL
497 Does not verify/modify auth info and password.
499 Call with env and con locked.
501 PlayerSAO *emergePlayer(const char *name, u16 peer_id, u16 proto_version);
503 void handlePeerChanges();
510 std::string m_path_world;
511 // Subgame specification
512 SubgameSpec m_gamespec;
513 // If true, do not allow multiple players and hide some multiplayer
515 bool m_simple_singleplayer_mode;
516 u16 m_max_chatmessage_length;
517 // For "dedicated" server list flag
520 // Thread can set; step() will throw as ServerError
521 MutexedVariable<std::string> m_async_fatal_error;
524 float m_liquid_transform_timer;
525 float m_liquid_transform_every;
526 float m_masterserver_timer;
527 float m_emergethread_trigger_timer;
528 float m_savemap_timer;
529 IntervalLimiter m_map_timer_and_unload_interval;
532 ServerEnvironment *m_env;
535 con::Connection m_con;
538 BanManager *m_banmanager;
540 // Rollback manager (behind m_env_mutex)
541 IRollbackManager *m_rollback;
542 bool m_enable_rollback_recording; // Updated once in a while
545 EmergeManager *m_emerge;
548 // Envlock and conlock should be locked when using Lua
549 ServerScripting *m_script;
551 // Item definition manager
552 IWritableItemDefManager *m_itemdef;
554 // Node definition manager
555 IWritableNodeDefManager *m_nodedef;
557 // Craft definition manager
558 IWritableCraftDefManager *m_craftdef;
561 EventManager *m_event;
564 std::vector<ModSpec> m_mods;
570 // A buffer for time steps
571 // step() increments and AsyncRunStep() run by m_thread reads it.
573 std::mutex m_step_dtime_mutex;
575 // current server step lag counter
578 // The server mainly operates in this thread
579 ServerThread *m_thread;
585 // Timer for sending time of day over network
586 float m_time_of_day_send_timer;
587 // Uptime of server in seconds
588 MutexedVariable<double> m_uptime;
592 ClientInterface m_clients;
596 Queues stuff from peerAdded() and deletingPeer() to
599 std::queue<con::PeerChange> m_peer_change_queue;
605 bool m_shutdown_requested;
606 std::string m_shutdown_msg;
607 bool m_shutdown_ask_reconnect;
608 float m_shutdown_timer;
610 ChatInterface *m_admin_chat;
611 std::string m_admin_nick;
614 Map edit event queue. Automatically receives all map edits.
615 The constructor of this class registers us to receive them through
618 NOTE: Should these be moved to actually be members of
623 Queue of map edits from the environment for sending to the clients
624 This is behind m_env_mutex
626 std::queue<MapEditEvent*> m_unsent_map_edit_queue;
628 Set to true when the server itself is modifying the map and does
629 all sending of information by itself.
630 This is behind m_env_mutex
632 bool m_ignore_map_edit_events;
634 If a non-empty area, map edit events contained within are left
635 unsent. Done at map generation time to speed up editing of the
636 generated area, as it will be sent anyway.
637 This is behind m_env_mutex
639 VoxelArea m_ignore_map_edit_events_area;
641 If set to !=0, the incoming MapEditEvents are modified to have
642 this peed id as the disabled recipient
643 This is behind m_env_mutex
645 u16 m_ignore_map_edit_events_peer_id;
647 // media files known to server
648 std::unordered_map<std::string, MediaInfo> m_media;
653 std::unordered_map<s32, ServerPlayingSound> m_playing_sounds;
657 Detached inventories (behind m_env_mutex)
660 std::map<std::string, Inventory*> m_detached_inventories;
661 // value = "" (visible to all players) or player name
662 std::map<std::string, std::string> m_detached_inventories_player;
664 std::unordered_map<std::string, ModMetadata *> m_mod_storages;
665 float m_mod_storage_save_timer;
669 Runs a simple dedicated server loop.
671 Shuts down when kill is set to true.
673 void dedicated_server_loop(Server &server, bool &kill);