#include "ban.h"
#include "environment.h"
#include "map.h"
-#include "jthread/jmutexautolock.h"
-#include "main.h"
+#include "threading/mutex_auto_lock.h"
#include "constants.h"
#include "voxel.h"
#include "config.h"
#include "content_abm.h"
#include "content_sao.h"
#include "mods.h"
-#include "util/sha1.h"
-#include "util/base64.h"
#include "sound.h" // dummySoundManager
#include "event_manager.h"
-#include "hex.h"
#include "serverlist.h"
#include "util/string.h"
#include "util/mathconstants.h"
#include "util/serialize.h"
#include "util/thread.h"
#include "defaultsettings.h"
+#include "util/base64.h"
+#include "util/sha1.h"
+#include "util/hex.h"
class ClientNotFoundException : public BaseException
{
{}
};
-class ServerThread : public JThread
+class ServerThread : public Thread
{
- Server *m_server;
-
public:
ServerThread(Server *server):
- JThread(),
+ Thread("Server"),
m_server(server)
- {
- }
+ {}
- void * Thread();
+ void *run();
+
+private:
+ Server *m_server;
};
-void * ServerThread::Thread()
+void *ServerThread::run()
{
- log_register_thread("ServerThread");
-
DSTACK(__FUNCTION_NAME);
BEGIN_DEBUG_EXCEPTION_HANDLER
m_server->AsyncRunStep(true);
- ThreadStarted();
-
- porting::setThreadName("ServerThread");
-
- while(!StopRequested())
- {
- try{
+ while (!stopRequested()) {
+ try {
//TimeTaker timer("AsyncRunStep() + Receive()");
m_server->AsyncRunStep();
m_server->Receive();
- }
- catch(con::NoIncomingDataException &e)
- {
- }
- catch(con::PeerNotFoundException &e)
- {
+ } catch (con::NoIncomingDataException &e) {
+ } catch (con::PeerNotFoundException &e) {
infostream<<"Server: PeerNotFoundException"<<std::endl;
- }
- catch(ClientNotFoundException &e)
- {
- }
- catch(con::ConnectionBindFailed &e)
- {
- m_server->setAsyncFatalError(e.what());
- }
- catch(LuaError &e)
- {
+ } catch (ClientNotFoundException &e) {
+ } catch (con::ConnectionBindFailed &e) {
m_server->setAsyncFatalError(e.what());
+ } catch (LuaError &e) {
+ m_server->setAsyncFatalError("Lua: " + std::string(e.what()));
}
}
m_uptime(0),
m_clients(&m_con),
m_shutdown_requested(false),
+ m_shutdown_ask_reconnect(false),
m_ignore_map_edit_events(false),
m_ignore_map_edit_events_peer_id(0),
m_next_sound_id(0)
infostream<<"- world: "<<m_path_world<<std::endl;
infostream<<"- game: "<<m_gamespec.path<<std::endl;
- // Initialize default settings and override defaults with those provided
- // by the game
- set_default_settings(g_settings);
- Settings gamedefaults;
- getGameMinetestConfig(gamespec.path, gamedefaults);
- override_default_settings(g_settings, &gamedefaults);
+ // Create world if it doesn't exist
+ if(!loadGameConfAndInitWorld(m_path_world, m_gamespec))
+ throw ServerError("Failed to initialize world");
// Create server thread
m_thread = new ServerThread(this);
// Create emerge manager
m_emerge = new EmergeManager(this);
- // Create world if it doesn't exist
- if(!initializeWorld(m_path_world, m_gamespec.id))
- throw ServerError("Failed to initialize world");
-
// Create ban manager
std::string ban_path = m_path_world + DIR_DELIM "ipban.txt";
m_banmanager = new BanManager(ban_path);
m_mods = modconf.getMods();
std::vector<ModSpec> unsatisfied_mods = modconf.getUnsatisfiedMods();
// complain about mods with unsatisfied dependencies
- if(!modconf.isConsistent())
- {
+ if(!modconf.isConsistent()) {
for(std::vector<ModSpec>::iterator it = unsatisfied_mods.begin();
- it != unsatisfied_mods.end(); ++it)
- {
+ it != unsatisfied_mods.end(); ++it) {
ModSpec mod = *it;
errorstream << "mod \"" << mod.name << "\" has unsatisfied dependencies: ";
for(std::set<std::string>::iterator dep_it = mod.unsatisfied_depends.begin();
std::vector<std::string> names = worldmt_settings.getNames();
std::set<std::string> load_mod_names;
for(std::vector<std::string>::iterator it = names.begin();
- it != names.end(); ++it)
- {
+ it != names.end(); ++it) {
std::string name = *it;
if(name.compare(0,9,"load_mod_")==0 && worldmt_settings.getBool(name))
load_mod_names.insert(name.substr(9));
for(std::vector<ModSpec>::iterator it = unsatisfied_mods.begin();
it != unsatisfied_mods.end(); ++it)
load_mod_names.erase((*it).name);
- if(!load_mod_names.empty())
- {
+ if(!load_mod_names.empty()) {
errorstream << "The following mods could not be found:";
for(std::set<std::string>::iterator it = load_mod_names.begin();
it != load_mod_names.end(); ++it)
errorstream << std::endl;
}
- // Lock environment
- JMutexAutoLock envlock(m_env_mutex);
+ //lock environment
+ MutexAutoLock envlock(m_env_mutex);
// Load mapgen params from Settings
m_emerge->loadMapgenParams();
m_script = new GameScripting(this);
- std::string scriptpath = getBuiltinLuaPath() + DIR_DELIM "init.lua";
+ std::string script_path = getBuiltinLuaPath() + DIR_DELIM "init.lua";
+ std::string error_msg;
- if (!m_script->loadScript(scriptpath))
- throw ModError("Failed to load and run " + scriptpath);
+ if (!m_script->loadMod(script_path, BUILTIN_MOD_NAME, &error_msg))
+ throw ModError("Failed to load and run " + script_path
+ + "\nError from Lua:\n" + error_msg);
- // Print 'em
- infostream<<"Server: Loading mods: ";
+ // Print mods
+ infostream << "Server: Loading mods: ";
for(std::vector<ModSpec>::iterator i = m_mods.begin();
- i != m_mods.end(); i++){
+ i != m_mods.end(); ++i) {
const ModSpec &mod = *i;
- infostream<<mod.name<<" ";
+ infostream << mod.name << " ";
}
- infostream<<std::endl;
+ infostream << std::endl;
// Load and run "mod" scripts
- for(std::vector<ModSpec>::iterator i = m_mods.begin();
- i != m_mods.end(); i++){
+ for (std::vector<ModSpec>::iterator i = m_mods.begin();
+ i != m_mods.end(); ++i) {
const ModSpec &mod = *i;
- std::string scriptpath = mod.path + DIR_DELIM + "init.lua";
- infostream<<" ["<<padStringRight(mod.name, 12)<<"] [\""
- <<scriptpath<<"\"]"<<std::endl;
- bool success = m_script->loadMod(scriptpath, mod.name);
- if(!success){
- errorstream<<"Server: Failed to load and run "
- <<scriptpath<<std::endl;
- throw ModError("Failed to load and run "+scriptpath);
+ if (!string_allowed(mod.name, MODNAME_ALLOWED_CHARS)) {
+ std::ostringstream err;
+ err << "Error loading mod \"" << mod.name
+ << "\": mod_name does not follow naming conventions: "
+ << "Only chararacters [a-z0-9_] are allowed." << std::endl;
+ errorstream << err.str().c_str();
+ throw ModError(err.str());
+ }
+ std::string script_path = mod.path + DIR_DELIM "init.lua";
+ infostream << " [" << padStringRight(mod.name, 12) << "] [\""
+ << script_path << "\"]" << std::endl;
+ if (!m_script->loadMod(script_path, mod.name, &error_msg)) {
+ errorstream << "Server: Failed to load and run "
+ << script_path << std::endl;
+ throw ModError("Failed to load and run " + script_path
+ + "\nError from Lua:\n" + error_msg);
}
}
// Apply item aliases in the node definition manager
m_nodedef->updateAliases(m_itemdef);
+ // Apply texture overrides from texturepack/override.txt
+ std::string texture_path = g_settings->get("texture_path");
+ if (texture_path != "" && fs::IsDir(texture_path))
+ m_nodedef->applyTextureOverrides(texture_path + DIR_DELIM + "override.txt");
+
m_nodedef->setNodeRegistrationStatus(true);
// Perform pending node name resolutions
- m_nodedef->runNodeResolverCallbacks();
+ m_nodedef->runNodeResolveCallbacks();
+
+ // init the recipe hashes to speed up crafting
+ m_craftdef->initHashes(this);
// Initialize Environment
m_env = new ServerEnvironment(servermap, m_script, this, m_path_world);
SendChatMessage(PEER_ID_INEXISTENT, L"*** Server shutting down");
{
- JMutexAutoLock envlock(m_env_mutex);
+ MutexAutoLock envlock(m_env_mutex);
// Execute script shutdown hooks
m_script->on_shutdown();
- infostream<<"Server: Saving players"<<std::endl;
+ infostream << "Server: Saving players" << std::endl;
m_env->saveLoadedPlayers();
- infostream<<"Server: Saving environment metadata"<<std::endl;
+ infostream << "Server: Kicking players" << std::endl;
+ std::string kick_msg;
+ bool reconnect = false;
+ if (getShutdownRequested()) {
+ reconnect = m_shutdown_ask_reconnect;
+ kick_msg = m_shutdown_msg;
+ }
+ if (kick_msg == "") {
+ kick_msg = g_settings->get("kick_msg_shutdown");
+ }
+ m_env->kickAllPlayers(SERVER_ACCESSDENIED_SHUTDOWN,
+ kick_msg, reconnect);
+
+ infostream << "Server: Saving environment metadata" << std::endl;
m_env->saveMeta();
}
// Delete detached inventories
for (std::map<std::string, Inventory*>::iterator
i = m_detached_inventories.begin();
- i != m_detached_inventories.end(); i++) {
+ i != m_detached_inventories.end(); ++i) {
delete i->second;
}
}
<< bind_addr.serializeString() <<"..."<<std::endl;
// Stop thread if already running
- m_thread->Stop();
+ m_thread->stop();
// Initialize connection
m_con.SetTimeoutMs(30);
m_con.Serve(bind_addr);
// Start thread
- m_thread->Start();
+ m_thread->start();
// ASCII art for the win!
actionstream
infostream<<"Server: Stopping and waiting threads"<<std::endl;
// Stop threads (set run=false first so both start stopping)
- m_thread->Stop();
+ m_thread->stop();
//m_emergethread.setRun(false);
- m_thread->Wait();
+ m_thread->wait();
//m_emergethread.stop();
infostream<<"Server: Threads stopped"<<std::endl;
if(dtime > 2.0)
dtime = 2.0;
{
- JMutexAutoLock lock(m_step_dtime_mutex);
+ MutexAutoLock lock(m_step_dtime_mutex);
m_step_dtime += dtime;
}
// Throw if fatal error occurred in thread
std::string async_err = m_async_fatal_error.get();
- if(async_err != ""){
- throw ServerError(async_err);
+ if(async_err != "") {
+ if (m_simple_singleplayer_mode) {
+ throw ServerError(async_err);
+ }
+ else {
+ m_env->kickAllPlayers(SERVER_ACCESSDENIED_CRASH,
+ g_settings->get("kick_msg_crash"),
+ g_settings->getBool("ask_reconnect_on_crash"));
+ errorstream << "UNRECOVERABLE error occurred. Stopping server. "
+ << "Please fix the following error:" << std::endl
+ << async_err << std::endl;
+ FATAL_ERROR(async_err.c_str());
+ }
}
}
float dtime;
{
- JMutexAutoLock lock1(m_step_dtime_mutex);
+ MutexAutoLock lock1(m_step_dtime_mutex);
dtime = m_step_dtime;
}
//infostream<<"Server::AsyncRunStep(): dtime="<<dtime<<std::endl;
{
- JMutexAutoLock lock1(m_step_dtime_mutex);
+ MutexAutoLock lock1(m_step_dtime_mutex);
m_step_dtime -= dtime;
}
/*
Update time of day and overall game time
*/
- {
- JMutexAutoLock envlock(m_env_mutex);
+ m_env->setTimeOfDaySpeed(g_settings->getFloat("time_speed"));
- m_env->setTimeOfDaySpeed(g_settings->getFloat("time_speed"));
-
- /*
- Send to clients at constant intervals
- */
+ /*
+ Send to clients at constant intervals
+ */
- m_time_of_day_send_timer -= dtime;
- if(m_time_of_day_send_timer < 0.0)
- {
- m_time_of_day_send_timer = g_settings->getFloat("time_send_interval");
- u16 time = m_env->getTimeOfDay();
- float time_speed = g_settings->getFloat("time_speed");
- SendTimeOfDay(PEER_ID_INEXISTENT, time, time_speed);
- }
+ m_time_of_day_send_timer -= dtime;
+ if(m_time_of_day_send_timer < 0.0) {
+ m_time_of_day_send_timer = g_settings->getFloat("time_send_interval");
+ u16 time = m_env->getTimeOfDay();
+ float time_speed = g_settings->getFloat("time_speed");
+ SendTimeOfDay(PEER_ID_INEXISTENT, time, time_speed);
}
{
- JMutexAutoLock lock(m_env_mutex);
+ MutexAutoLock lock(m_env_mutex);
// Figure out and report maximum lag to environment
float max_lag = m_env->getMaxLagEstimate();
max_lag *= 0.9998; // Decrease slowly (about half per 5 minutes)
static const float map_timer_and_unload_dtime = 2.92;
if(m_map_timer_and_unload_interval.step(dtime, map_timer_and_unload_dtime))
{
- JMutexAutoLock lock(m_env_mutex);
+ MutexAutoLock lock(m_env_mutex);
// Run Map's timers and unload unused data
ScopeProfiler sp(g_profiler, "Server: map timer and unload");
m_env->getMap().timerUpdate(map_timer_and_unload_dtime,
- g_settings->getFloat("server_unload_unused_data_timeout"));
+ g_settings->getFloat("server_unload_unused_data_timeout"),
+ (u32)-1);
}
/*
Do background stuff
*/
- /*
- Handle players
- */
- {
- JMutexAutoLock lock(m_env_mutex);
-
- std::list<u16> clientids = m_clients.getClientIDs();
-
- ScopeProfiler sp(g_profiler, "Server: handle players");
-
- for(std::list<u16>::iterator
- i = clientids.begin();
- i != clientids.end(); ++i)
- {
- PlayerSAO *playersao = getPlayerSAO(*i);
- if(playersao == NULL)
- continue;
-
- /*
- Handle player HPs (die if hp=0)
- */
- if(playersao->m_hp_not_sent && g_settings->getBool("enable_damage"))
- {
- if(playersao->getHP() == 0)
- DiePlayer(*i);
- else
- SendPlayerHP(*i);
- }
-
- /*
- Send player breath if changed
- */
- if(playersao->m_breath_not_sent) {
- SendPlayerBreath(*i);
- }
-
- /*
- Send player inventories if necessary
- */
- if(playersao->m_moved) {
- SendMovePlayer(*i);
- playersao->m_moved = false;
- }
- if(playersao->m_inventory_not_sent) {
- UpdateCrafting(*i);
- SendInventory(*i);
- }
- }
- }
-
/* Transform liquids */
m_liquid_transform_timer += dtime;
if(m_liquid_transform_timer >= m_liquid_transform_every)
{
m_liquid_transform_timer -= m_liquid_transform_every;
- JMutexAutoLock lock(m_env_mutex);
+ MutexAutoLock lock(m_env_mutex);
ScopeProfiler sp(g_profiler, "Server: liquid transform");
*/
{
//infostream<<"Server: Checking added and deleted active objects"<<std::endl;
- JMutexAutoLock envlock(m_env_mutex);
+ MutexAutoLock envlock(m_env_mutex);
- m_clients.Lock();
+ m_clients.lock();
std::map<u16, RemoteClient*> clients = m_clients.getClientList();
ScopeProfiler sp(g_profiler, "Server: checking added and deleted objs");
obj->m_known_by_count++;
}
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_ACTIVE_OBJECT_REMOVE_ADD, 0, client->peer_id);
- pkt->putRawString(data_buffer.c_str(), data_buffer.size());
-
-
+ u32 pktSize = SendActiveObjectRemoveAdd(client->peer_id, data_buffer);
verbosestream << "Server: Sent object remove/add: "
<< removed_objects.size() << " removed, "
<< added_objects.size() << " added, "
- << "packet size is " << pkt->getSize() << std::endl;
-
- Send(pkt);
+ << "packet size is " << pktSize << std::endl;
}
- m_clients.Unlock();
+ m_clients.unlock();
}
/*
Send object messages
*/
{
- JMutexAutoLock envlock(m_env_mutex);
+ MutexAutoLock envlock(m_env_mutex);
ScopeProfiler sp(g_profiler, "Server: sending object messages");
// Key = object id
// Value = data sent by object
- std::map<u16, std::
list<ActiveObjectMessage>* > buffered_messages;
+ std::map<u16, std::
vector<ActiveObjectMessage>* > buffered_messages;
// Get active object messages from environment
- for(;;)
- {
+ for(;;) {
ActiveObjectMessage aom = m_env->getActiveObjectMessage();
- if(aom.id == 0)
+ if (aom.id == 0)
break;
- std::
list<ActiveObjectMessage>* message_list = NULL;
- std::map<u16, std::
list<ActiveObjectMessage>* >::iterator n;
+ std::
vector<ActiveObjectMessage>* message_list = NULL;
+ std::map<u16, std::
vector<ActiveObjectMessage>* >::iterator n;
n = buffered_messages.find(aom.id);
- if(n == buffered_messages.end())
- {
- message_list = new std::list<ActiveObjectMessage>;
+ if (n == buffered_messages.end()) {
+ message_list = new std::vector<ActiveObjectMessage>;
buffered_messages[aom.id] = message_list;
}
- else
- {
+ else {
message_list = n->second;
}
message_list->push_back(aom);
}
- m_clients.Lock();
+ m_clients.lock();
std::map<u16, RemoteClient*> clients = m_clients.getClientList();
// Route data to every client
- for(std::map<u16, RemoteClient*>::iterator
+ for (std::map<u16, RemoteClient*>::iterator
i = clients.begin();
- i != clients.end(); ++i)
- {
+ i != clients.end(); ++i) {
RemoteClient *client = i->second;
std::string reliable_data;
std::string unreliable_data;
// Go through all objects in message buffer
- for
(std::map<u16, std::list<ActiveObjectMessage>* >::iterator
+ for
(std::map<u16, std::vector<ActiveObjectMessage>* >::iterator
j = buffered_messages.begin();
- j != buffered_messages.end(); ++j)
- {
+ j != buffered_messages.end(); ++j) {
// If object is not known by client, skip it
u16 id = j->first;
- if(client->m_known_objects.find(id) == client->m_known_objects.end())
+ if (client->m_known_objects.find(id) == client->m_known_objects.end())
continue;
+
// Get message list of object
- std::
list<ActiveObjectMessage>* list = j->second;
+ std::
vector<ActiveObjectMessage>* list = j->second;
// Go through every message
- for(std::list<ActiveObjectMessage>::iterator
- k = list->begin(); k != list->end(); ++k)
- {
+ for (std::vector<ActiveObjectMessage>::iterator
+ k = list->begin(); k != list->end(); ++k) {
// Compose the full new data with header
ActiveObjectMessage aom = *k;
std::string new_data;
Send them.
*/
if(reliable_data.size() > 0) {
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_ACTIVE_OBJECT_MESSAGES,
- 0, client->peer_id);
-
- pkt->putRawString(reliable_data.c_str(), reliable_data.size());
- Send(pkt);
+ SendActiveObjectMessages(client->peer_id, reliable_data);
}
if(unreliable_data.size() > 0) {
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_ACTIVE_OBJECT_MESSAGES,
- 0, client->peer_id);
-
- pkt->putRawString(unreliable_data.c_str(), unreliable_data.size());
- Send(pkt);
+ SendActiveObjectMessages(client->peer_id, unreliable_data, false);
}
}
- m_clients.Unlock();
+ m_clients.unlock();
// Clear buffered_messages
- for(std::map<u16, std::
list<ActiveObjectMessage>* >::iterator
+ for(std::map<u16, std::
vector<ActiveObjectMessage>* >::iterator
i = buffered_messages.begin();
- i != buffered_messages.end(); ++i)
- {
+ i != buffered_messages.end(); ++i) {
delete i->second;
}
}
*/
{
// We will be accessing the environment
- JMutexAutoLock lock(m_env_mutex);
+ MutexAutoLock lock(m_env_mutex);
// Don't send too many at a time
//u32 count = 0;
while(m_unsent_map_edit_queue.size() != 0)
{
- MapEditEvent* event = m_unsent_map_edit_queue.pop_front();
+ MapEditEvent* event = m_unsent_map_edit_queue.front();
+ m_unsent_map_edit_queue.pop();
// Players far away from the change are stored here.
// Instead of sending the changes, MapBlocks are set not sent
// for them.
- std::list<u16> far_players;
+ std::vector<u16> far_players;
- if(event->type == MEET_ADDNODE || event->type == MEET_SWAPNODE)
- {
- //infostream<<"Server: MEET_ADDNODE"<<std::endl;
+ switch (event->type) {
+ case MEET_ADDNODE:
+ case MEET_SWAPNODE:
prof.add("MEET_ADDNODE", 1);
- if(disable_single_change_sending)
- sendAddNode(event->p, event->n, event->already_known_by_peer,
- &far_players, 5, event->type == MEET_ADDNODE);
- else
- sendAddNode(event->p, event->n, event->already_known_by_peer,
- &far_players, 30, event->type == MEET_ADDNODE);
- }
- else if(event->type == MEET_REMOVENODE)
- {
- //infostream<<"Server: MEET_REMOVENODE"<<std::endl;
+ sendAddNode(event->p, event->n, event->already_known_by_peer,
+ &far_players, disable_single_change_sending ? 5 : 30,
+ event->type == MEET_ADDNODE);
+ break;
+ case MEET_REMOVENODE:
prof.add("MEET_REMOVENODE", 1);
- if(disable_single_change_sending)
- sendRemoveNode(event->p, event->already_known_by_peer,
- &far_players, 5);
- else
- sendRemoveNode(event->p, event->already_known_by_peer,
- &far_players, 30);
- }
- else if(event->type == MEET_BLOCK_NODE_METADATA_CHANGED)
- {
- infostream<<"Server: MEET_BLOCK_NODE_METADATA_CHANGED"<<std::endl;
- prof.add("MEET_BLOCK_NODE_METADATA_CHANGED", 1);
- setBlockNotSent(event->p);
- }
- else if(event->type == MEET_OTHER)
- {
- infostream<<"Server: MEET_OTHER"<<std::endl;
+ sendRemoveNode(event->p, event->already_known_by_peer,
+ &far_players, disable_single_change_sending ? 5 : 30);
+ break;
+ case MEET_BLOCK_NODE_METADATA_CHANGED:
+ infostream << "Server: MEET_BLOCK_NODE_METADATA_CHANGED" << std::endl;
+ prof.add("MEET_BLOCK_NODE_METADATA_CHANGED", 1);
+ setBlockNotSent(event->p);
+ break;
+ case MEET_OTHER:
+ infostream << "Server: MEET_OTHER" << std::endl;
prof.add("MEET_OTHER", 1);
for(std::set<v3s16>::iterator
i = event->modified_blocks.begin();
- i != event->modified_blocks.end(); ++i)
- {
+ i != event->modified_blocks.end(); ++i) {
setBlockNotSent(*i);
}
- }
- else
- {
+ break;
+ default:
prof.add("unknown", 1);
- infostream<<"WARNING: Server: Unknown MapEditEvent "
- <<((u32)event->type)<<std::endl;
+ infostream << "WARNING: Server: Unknown MapEditEvent "
+ << ((u32)event->type) << std::endl;
+ break;
}
/*
Set blocks not sent to far players
*/
- if(!far_players.empty())
- {
+ if(!far_players.empty()) {
// Convert list format to that wanted by SetBlocksNotSent
std::map<v3s16, MapBlock*> modified_blocks2;
for(std::set<v3s16>::iterator
i = event->modified_blocks.begin();
- i != event->modified_blocks.end(); ++i)
- {
+ i != event->modified_blocks.end(); ++i) {
modified_blocks2[*i] =
m_env->getMap().getBlockNoCreateNoEx(*i);
}
+
// Set blocks not sent
- for(std::list<u16>::iterator
+ for(std::vector<u16>::iterator
i = far_players.begin();
- i != far_players.end(); ++i)
- {
- u16 peer_id = *i;
- RemoteClient *client = getClient(peer_id);
- if(client==NULL)
- continue;
- client->SetBlocksNotSent(modified_blocks2);
+ i != far_players.end(); ++i) {
+ if(RemoteClient *client = getClient(*i))
+ client->SetBlocksNotSent(modified_blocks2);
}
}
if(counter >= g_settings->getFloat("server_map_save_interval"))
{
counter = 0.0;
- JMutexAutoLock lock(m_env_mutex);
+ MutexAutoLock lock(m_env_mutex);
ScopeProfiler sp(g_profiler, "Server: saving stuff");
DSTACK(__FUNCTION_NAME);
SharedBuffer<u8> data;
u16 peer_id;
- u32 datasize;
try {
- datasize = m_con.Receive(peer_id,data);
- ProcessData(*data, datasize, peer_id);
+ NetworkPacket pkt;
+ m_con.Receive(&pkt);
+ peer_id = pkt.getPeerId();
+ ProcessData(&pkt);
}
catch(con::InvalidIncomingDataException &e) {
infostream<<"Server::Receive(): "
}
catch(ClientStateError &e) {
errorstream << "ProcessData: peer=" << peer_id << e.what() << std::endl;
- DenyAccess(peer_id, L"Your client sent something server didn't expect."
+ DenyAccess_Legacy(peer_id, L"Your client sent something server didn't expect."
L"Try reconnecting or updating your client");
}
catch(con::PeerNotFoundException &e) {
{
std::string playername = "";
PlayerSAO *playersao = NULL;
- m_clients.Lock();
+ m_clients.lock();
try {
RemoteClient* client = m_clients.lockedGetClientNoEx(peer_id, CS_InitDone);
if (client != NULL) {
playername = client->getName();
- playersao = emergePlayer(playername.c_str(), peer_id);
+ playersao = emergePlayer(playername.c_str(), peer_id, client->net_proto_version);
}
} catch (std::exception &e) {
- m_clients.Unlock();
+ m_clients.unlock();
throw;
}
- m_clients.Unlock();
+ m_clients.unlock();
RemotePlayer *player =
static_cast<RemotePlayer*>(m_env->getPlayer(playername.c_str()));
// If failed, cancel
- if((playersao == NULL) || (player == NULL)) {
- if(player && player->peer_id != 0) {
- errorstream<<"Server: "<<playername<<": Failed to emerge player"
- <<" (player allocated to an another client)"<<std::endl;
- DenyAccess(peer_id, L"Another client is connected with this "
+ if ((playersao == NULL) || (player == NULL)) {
+ if (player && player->peer_id != 0) {
+ actionstream << "Server: Failed to emerge player \"" << playername
+ << "\" (player allocated to an another client)" << std::endl;
+ DenyAccess_Legacy(peer_id, L"Another client is connected with this "
L"name. If your client closed unexpectedly, try again in "
L"a minute.");
} else {
- errorstream<<"Server: "<<playername<<": Failed to emerge player"
- <<std::endl;
- DenyAccess(peer_id, L"Could not allocate player.");
+ errorstream << "Server: " << playername << ": Failed to emerge player"
+ << std::endl;
+ DenyAccess_Legacy(peer_id, L"Could not allocate player.");
}
return NULL;
}
SendPlayerInventoryFormspec(peer_id);
// Send inventory
- UpdateCrafting(peer_id);
- SendInventory(peer_id);
+ SendInventory(playersao);
// Send HP
- if(g_settings->getBool("enable_damage"))
- SendPlayerHP(peer_id);
+ SendPlayerHPOrDie(playersao);
// Send Breath
SendPlayerBreath(peer_id);
// Show death screen if necessary
- if(player->hp == 0)
+ if(player->isDead())
SendDeathscreen(peer_id, false, v3f(0,0,0));
// Note things in chat if not in simple singleplayer mode
actionstream<<player->getName() <<" joins game. List of players: ";
for (std::vector<std::string>::iterator i = names.begin();
- i != names.end(); i++) {
+ i != names.end(); ++i) {
actionstream << *i << " ";
}
(this->*opHandle.handler)(pkt);
}
-void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id)
+void Server::ProcessData(NetworkPacket *pkt)
{
DSTACK(__FUNCTION_NAME);
// Environment is locked first.
- JMutexAutoLock envlock(m_env_mutex);
+ MutexAutoLock envlock(m_env_mutex);
ScopeProfiler sp(g_profiler, "Server::ProcessData");
+ u32 peer_id = pkt->getPeerId();
try {
Address address = getPeerAddress(peer_id);
<< addr_s << "; banned name was "
<< ban_name << std::endl;
// This actually doesn't seem to transfer to the client
- DenyAccess(peer_id, L"Your ip is banned. Banned name was "
- + narrow_to_wide(ban_name));
+ DenyAccess_Legacy(peer_id, L"Your ip is banned. Banned name was "
+ + utf8_to_wide(ban_name));
return;
}
}
* respond for some time, your server was overloaded or
* things like that.
*/
- infostream << "Server::ProcessData(): Cancelling: peer "
+ infostream << "Server::ProcessData(): Canceling: peer "
<< peer_id << " not found" << std::endl;
return;
}
try {
- if(datasize < 2)
- return;
-
- NetworkPacket* pkt = new NetworkPacket(data, datasize, peer_id);
-
ToServerCommand command = (ToServerCommand) pkt->getCommand();
// Command must be handled into ToServerCommandHandler
if (command >= TOSERVER_NUM_MSG_TYPES) {
infostream << "Server: Ignoring unknown command "
<< command << std::endl;
+ return;
}
if (toServerCommandTable[command].state == TOSERVER_STATE_NOT_CONNECTED) {
handleCommand(pkt);
- delete pkt;
return;
}
errorstream << "Server::ProcessData(): Cancelling: Peer"
" serialization format invalid or not initialized."
" Skipping incoming command=" << command << std::endl;
-
- delete pkt;
return;
}
/* Handle commands related to client startup */
if (toServerCommandTable[command].state == TOSERVER_STATE_STARTUP) {
handleCommand(pkt);
- delete pkt;
return;
}
errorstream << "Got packet command: " << command << " for peer id "
<< peer_id << " but client isn't active yet. Dropping packet "
<< std::endl;
-
- delete pkt;
return;
}
handleCommand(pkt);
- delete pkt;
-
- }
- catch(SendFailedException &e) {
+ } catch (SendFailedException &e) {
errorstream << "Server::ProcessData(): SendFailedException: "
<< "what=" << e.what()
<< std::endl;
+ } catch (PacketError &e) {
+ actionstream << "Server::ProcessData(): PacketError: "
+ << "what=" << e.what()
+ << std::endl;
}
}
if(m_ignore_map_edit_events_area.contains(event->getArea()))
return;
MapEditEvent *e = event->clone();
- m_unsent_map_edit_queue.push_back(e);
+ m_unsent_map_edit_queue.push(e);
}
Inventory* Server::getInventory(const InventoryLocation &loc)
}
break;
default:
- assert(0);
+ sanity_check(false); // abort
+ break;
}
return NULL;
}
-void Server::setInventoryModified(const InventoryLocation &loc)
+void Server::setInventoryModified(const InventoryLocation &loc, bool playerSend)
{
switch(loc.type){
case InventoryLocation::UNDEFINED:
break;
case InventoryLocation::PLAYER:
{
+ if (!playerSend)
+ return;
+
Player *player = m_env->getPlayer(loc.name.c_str());
if(!player)
return;
PlayerSAO *playersao = player->getPlayerSAO();
if(!playersao)
return;
- playersao->m_inventory_not_sent = true;
- playersao->m_wielded_item_not_sent = true;
+
+ SendInventory(playersao);
}
break;
case InventoryLocation::NODEMETA:
}
break;
default:
- assert(0);
+ sanity_check(false); // abort
+ break;
}
}
void Server::SetBlocksNotSent(std::map<v3s16, MapBlock *>& block)
{
- std::list<u16> clients = m_clients.getClientIDs();
- m_clients.Lock();
+ std::vector<u16> clients = m_clients.getClientIDs();
+ m_clients.lock();
// Set the modified blocks unsent for all the clients
- for (std::list<u16>::iterator
- i = clients.begin();
+ for (std::vector<u16>::iterator i = clients.begin();
i != clients.end(); ++i) {
- RemoteClient *client = m_clients.lockedGetClientNoEx(*i);
- if (client != NULL)
+ if (RemoteClient *client = m_clients.lockedGetClientNoEx(*i))
client->SetBlocksNotSent(block);
- }
- m_clients.Unlock();
+ }
+ m_clients.unlock();
}
void Server::peerAdded(con::Peer *peer)
c.type = con::PEER_ADDED;
c.peer_id = peer->id;
c.timeout = false;
- m_peer_change_queue.push_back(c);
+ m_peer_change_queue.push(c);
}
void Server::deletingPeer(con::Peer *peer, bool timeout)
c.type = con::PEER_REMOVED;
c.peer_id = peer->id;
c.timeout = timeout;
- m_peer_change_queue.push_back(c);
+ m_peer_change_queue.push(c);
}
bool Server::getClientConInfo(u16 peer_id, con::rtt_stat_type type, float* retval)
)
{
*state = m_clients.getClientState(peer_id);
- m_clients.Lock();
+ m_clients.lock();
RemoteClient* client = m_clients.lockedGetClientNoEx(peer_id, CS_Invalid);
if (client == NULL) {
- m_clients.Unlock();
+ m_clients.unlock();
return false;
}
*patch = client->getPatch();
*vers_string = client->getPatch();
- m_clients.Unlock();
+ m_clients.unlock();
return true;
}
{
while(m_peer_change_queue.size() > 0)
{
- con::PeerChange c = m_peer_change_queue.pop_front();
+ con::PeerChange c = m_peer_change_queue.front();
+ m_peer_change_queue.pop();
verbosestream<<"Server: Handling peer change: "
<<"id="<<c.peer_id<<", timeout="<<c.timeout
break;
default:
- assert("Invalid peer change event received!" == 0);
+ FATAL_ERROR("Invalid peer change event received!");
break;
}
}
DSTACK(__FUNCTION_NAME);
std::ostringstream os(std::ios_base::binary);
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_MOVEMENT, 12 * sizeof(float), peer_id);
+ NetworkPacket pkt(TOCLIENT_MOVEMENT, 12 * sizeof(float), peer_id);
+
+ pkt << g_settings->getFloat("movement_acceleration_default");
+ pkt << g_settings->getFloat("movement_acceleration_air");
+ pkt << g_settings->getFloat("movement_acceleration_fast");
+ pkt << g_settings->getFloat("movement_speed_walk");
+ pkt << g_settings->getFloat("movement_speed_crouch");
+ pkt << g_settings->getFloat("movement_speed_fast");
+ pkt << g_settings->getFloat("movement_speed_climb");
+ pkt << g_settings->getFloat("movement_speed_jump");
+ pkt << g_settings->getFloat("movement_liquid_fluidity");
+ pkt << g_settings->getFloat("movement_liquid_fluidity_smooth");
+ pkt << g_settings->getFloat("movement_liquid_sink");
+ pkt << g_settings->getFloat("movement_gravity");
+
+ Send(&pkt);
+}
+
+void Server::SendPlayerHPOrDie(PlayerSAO *playersao)
+{
+ if (!g_settings->getBool("enable_damage"))
+ return;
- *pkt << g_settings->getFloat("movement_acceleration_default");
- *pkt << g_settings->getFloat("movement_acceleration_air");
- *pkt << g_settings->getFloat("movement_acceleration_fast");
- *pkt << g_settings->getFloat("movement_speed_walk");
- *pkt << g_settings->getFloat("movement_speed_crouch");
- *pkt << g_settings->getFloat("movement_speed_fast");
- *pkt << g_settings->getFloat("movement_speed_climb");
- *pkt << g_settings->getFloat("movement_speed_jump");
- *pkt << g_settings->getFloat("movement_liquid_fluidity");
- *pkt << g_settings->getFloat("movement_liquid_fluidity_smooth");
- *pkt << g_settings->getFloat("movement_liquid_sink");
- *pkt << g_settings->getFloat("movement_gravity");
+ u16 peer_id = playersao->getPeerID();
+ bool is_alive = playersao->getHP() > 0;
- Send(pkt);
+ if (is_alive)
+ SendPlayerHP(peer_id);
+ else
+ DiePlayer(peer_id);
}
void Server::SendHP(u16 peer_id, u8 hp)
{
DSTACK(__FUNCTION_NAME);
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_HP, 1, peer_id);
- *pkt << hp;
- Send(pkt);
+ NetworkPacket pkt(TOCLIENT_HP, 1, peer_id);
+ pkt << hp;
+ Send(&pkt);
}
void Server::SendBreath(u16 peer_id, u16 breath)
{
DSTACK(__FUNCTION_NAME);
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_BREATH, 2, peer_id);
- *pkt << (u16) breath;
- Send(pkt);
+ NetworkPacket pkt(TOCLIENT_BREATH, 2, peer_id);
+ pkt << (u16) breath;
+ Send(&pkt);
}
-void Server::SendAccessDenied(u16 peer_id,const std::wstring &reason)
+void Server::SendAccessDenied(u16 peer_id, AccessDeniedCode reason,
+ const std::string &custom_reason, bool reconnect)
+{
+ assert(reason < SERVER_ACCESSDENIED_MAX);
+
+ NetworkPacket pkt(TOCLIENT_ACCESS_DENIED, 1, peer_id);
+ pkt << (u8)reason;
+ if (reason == SERVER_ACCESSDENIED_CUSTOM_STRING)
+ pkt << custom_reason;
+ else if (reason == SERVER_ACCESSDENIED_SHUTDOWN ||
+ reason == SERVER_ACCESSDENIED_CRASH)
+ pkt << custom_reason << (u8)reconnect;
+ Send(&pkt);
+}
+
+void Server::SendAccessDenied_Legacy(u16 peer_id,const std::wstring &reason)
{
DSTACK(__FUNCTION_NAME);
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_ACCESS_DENIED, 0, peer_id);
- *pkt << reason;
- Send(pkt);
+ NetworkPacket pkt(TOCLIENT_ACCESS_DENIED_LEGACY, 0, peer_id);
+ pkt << reason;
+ Send(&pkt);
}
void Server::SendDeathscreen(u16 peer_id,bool set_camera_point_target,
{
DSTACK(__FUNCTION_NAME);
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_DEATHSCREEN, 1 + sizeof(v3f), peer_id);
- *pkt << set_camera_point_target << camera_point_target;
- Send(pkt);
+ NetworkPacket pkt(TOCLIENT_DEATHSCREEN, 1 + sizeof(v3f), peer_id);
+ pkt << set_camera_point_target << camera_point_target;
+ Send(&pkt);
}
void Server::SendItemDef(u16 peer_id,
{
DSTACK(__FUNCTION_NAME);
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_ITEMDEF, 0, peer_id);
+ NetworkPacket pkt(TOCLIENT_ITEMDEF, 0, peer_id);
/*
u16 command
itemdef->serialize(tmp_os, protocol_version);
std::ostringstream tmp_os2(std::ios::binary);
compressZlib(tmp_os.str(), tmp_os2);
- pkt->putLongString(tmp_os2.str());
+ pkt.putLongString(tmp_os2.str());
// Make data buffer
verbosestream << "Server: Sending item definitions to id(" << peer_id
- << "): size=" << pkt->getSize() << std::endl;
+ << "): size=" << pkt.getSize() << std::endl;
- Send(pkt);
+ Send(&pkt);
}
void Server::SendNodeDef(u16 peer_id,
{
DSTACK(__FUNCTION_NAME);
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_NODEDEF, 0, peer_id);
+ NetworkPacket pkt(TOCLIENT_NODEDEF, 0, peer_id);
/*
u16 command
std::ostringstream tmp_os2(std::ios::binary);
compressZlib(tmp_os.str(), tmp_os2);
- pkt->putLongString(tmp_os2.str());
+ pkt.putLongString(tmp_os2.str());
// Make data buffer
verbosestream << "Server: Sending node definitions to id(" << peer_id
- << "): size=" << pkt->getSize() << std::endl;
+ << "): size=" << pkt.getSize() << std::endl;
- Send(pkt);
+ Send(&pkt);
}
/*
Non-static send methods
*/
-void Server::SendInventory(u16 peer_id)
+void Server::SendInventory(PlayerSAO* playerSAO)
{
DSTACK(__FUNCTION_NAME);
- PlayerSAO *playersao = getPlayerSAO(peer_id);
- assert(playersao);
-
- playersao->m_inventory_not_sent = false;
+ UpdateCrafting(playerSAO->getPlayer());
/*
Serialize it
*/
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_INVENTORY, 0, peer_id);
+ NetworkPacket pkt(TOCLIENT_INVENTORY, 0, playerSAO->getPeerID());
std::ostringstream os;
- playersao->getInventory()->serialize(os);
+ playerSAO->getInventory()->serialize(os);
std::string s = os.str();
- pkt->putRawString(s.c_str(), s.size());
- Send(pkt);
+ pkt.putRawString(s.c_str(), s.size());
+ Send(&pkt);
}
void Server::SendChatMessage(u16 peer_id, const std::wstring &message)
{
DSTACK(__FUNCTION_NAME);
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_CHAT_MESSAGE, 0, peer_id);
- *pkt << message;
+ NetworkPacket pkt(TOCLIENT_CHAT_MESSAGE, 0, peer_id);
+ pkt << message;
if (peer_id != PEER_ID_INEXISTENT) {
- Send(pkt);
+ Send(&pkt);
}
else {
- m_clients.sendToAll(0,pkt,true);
+ m_clients.sendToAll(0, &pkt, true);
}
}
{
DSTACK(__FUNCTION_NAME);
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_SHOW_FORMSPEC, 0 , peer_id);
+ NetworkPacket pkt(TOCLIENT_SHOW_FORMSPEC, 0 , peer_id);
- pkt->putLongString(FORMSPEC_VERSION_STRING + formspec);
- *pkt << formname;
+ pkt.putLongString(FORMSPEC_VERSION_STRING + formspec);
+ pkt << formname;
- Send(pkt);
+ Send(&pkt);
}
// Spawns a particle on peer with peer_id
{
DSTACK(__FUNCTION_NAME);
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_SPAWN_PARTICLE, 0, peer_id);
+ NetworkPacket pkt(TOCLIENT_SPAWN_PARTICLE, 0, peer_id);
- *pkt << pos << velocity << acceleration << expirationtime
+ pkt << pos << velocity << acceleration << expirationtime
<< size << collisiondetection;
- pkt->putLongString(texture);
- *pkt << vertical;
+ pkt.putLongString(texture);
+ pkt << vertical;
if (peer_id != PEER_ID_INEXISTENT) {
- Send(pkt);
+ Send(&pkt);
}
else {
- m_clients.sendToAll(0,pkt,true);
+ m_clients.sendToAll(0, &pkt, true);
}
}
{
DSTACK(__FUNCTION_NAME);
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_ADD_PARTICLESPAWNER, 0, peer_id);
+ NetworkPacket pkt(TOCLIENT_ADD_PARTICLESPAWNER, 0, peer_id);
- *pkt << amount << spawntime << minpos << maxpos << minvel << maxvel
+ pkt << amount << spawntime << minpos << maxpos << minvel << maxvel
<< minacc << maxacc << minexptime << maxexptime << minsize
<< maxsize << collisiondetection;
- pkt->putLongString(texture);
+ pkt.putLongString(texture);
- *pkt << id << vertical;
+ pkt << id << vertical;
if (peer_id != PEER_ID_INEXISTENT) {
- Send(pkt);
+ Send(&pkt);
}
else {
- m_clients.sendToAll(0, pkt, true);
+ m_clients.sendToAll(0, &pkt, true);
}
}
{
DSTACK(__FUNCTION_NAME);
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_DELETE_PARTICLESPAWNER, 2, peer_id);
+ NetworkPacket pkt(TOCLIENT_DELETE_PARTICLESPAWNER_LEGACY, 2, peer_id);
// Ugly error in this packet
- *pkt << (u16) id;
+ pkt << (u16) id;
if (peer_id != PEER_ID_INEXISTENT) {
- Send(pkt);
+ Send(&pkt);
}
else {
- m_clients.sendToAll(0, pkt, true);
+ m_clients.sendToAll(0, &pkt, true);
}
}
void Server::SendHUDAdd(u16 peer_id, u32 id, HudElement *form)
{
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_HUDADD, 0 , peer_id);
+ NetworkPacket pkt(TOCLIENT_HUDADD, 0 , peer_id);
- *pkt << id << (u8) form->type << form->pos << form->name << form->scale
+ pkt << id << (u8) form->type << form->pos << form->name << form->scale
<< form->text << form->number << form->item << form->dir
<< form->align << form->offset << form->world_pos << form->size;
- Send(pkt);
+ Send(&pkt);
}
void Server::SendHUDRemove(u16 peer_id, u32 id)
{
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_HUDRM, 4, peer_id);
- *pkt << id;
- Send(pkt);
+ NetworkPacket pkt(TOCLIENT_HUDRM, 4, peer_id);
+ pkt << id;
+ Send(&pkt);
}
void Server::SendHUDChange(u16 peer_id, u32 id, HudElementStat stat, void *value)
{
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_HUDCHANGE, 0, peer_id);
- *pkt << id << (u8) stat;
+ NetworkPacket pkt(TOCLIENT_HUDCHANGE, 0, peer_id);
+ pkt << id << (u8) stat;
switch (stat) {
case HUD_STAT_POS:
case HUD_STAT_SCALE:
case HUD_STAT_ALIGN:
case HUD_STAT_OFFSET:
- *pkt << *(v2f *) value;
+ pkt << *(v2f *) value;
break;
case HUD_STAT_NAME:
case HUD_STAT_TEXT:
- *pkt << *(std::string *) value;
+ pkt << *(std::string *) value;
break;
case HUD_STAT_WORLD_POS:
- *pkt << *(v3f *) value;
+ pkt << *(v3f *) value;
break;
case HUD_STAT_SIZE:
- *pkt << *(v2s32 *) value;
+ pkt << *(v2s32 *) value;
break;
case HUD_STAT_NUMBER:
case HUD_STAT_ITEM:
case HUD_STAT_DIR:
default:
- *pkt << *(u32 *) value;
+ pkt << *(u32 *) value;
break;
}
- Send(pkt);
+ Send(&pkt);
}
void Server::SendHUDSetFlags(u16 peer_id, u32 flags, u32 mask)
{
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_HUD_SET_FLAGS, 4 + 4, peer_id);
+ NetworkPacket pkt(TOCLIENT_HUD_SET_FLAGS, 4 + 4, peer_id);
flags &= ~(HUD_FLAG_HEALTHBAR_VISIBLE | HUD_FLAG_BREATHBAR_VISIBLE);
- *pkt << flags << mask;
+ pkt << flags << mask;
- Send(pkt);
+ Send(&pkt);
}
void Server::SendHUDSetParam(u16 peer_id, u16 param, const std::string &value)
{
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_HUD_SET_PARAM, 0, peer_id);
- *pkt << param << value;
- Send(pkt);
+ NetworkPacket pkt(TOCLIENT_HUD_SET_PARAM, 0, peer_id);
+ pkt << param << value;
+ Send(&pkt);
}
void Server::SendSetSky(u16 peer_id, const video::SColor &bgcolor,
const std::string &type, const std::vector<std::string> ¶ms)
{
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_SET_SKY, 0, peer_id);
- *pkt << bgcolor << type << (u16) params.size();
+ NetworkPacket pkt(TOCLIENT_SET_SKY, 0, peer_id);
+ pkt << bgcolor << type << (u16) params.size();
for(size_t i=0; i<params.size(); i++)
- *pkt << params[i];
+ pkt << params[i];
- Send(pkt);
+ Send(&pkt);
}
void Server::SendOverrideDayNightRatio(u16 peer_id, bool do_override,
float ratio)
{
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_OVERRIDE_DAY_NIGHT_RATIO,
+ NetworkPacket pkt(TOCLIENT_OVERRIDE_DAY_NIGHT_RATIO,
1 + 2, peer_id);
- *pkt << do_override << (u16) (ratio * 65535);
+ pkt << do_override << (u16) (ratio * 65535);
- Send (pkt);
+ Send(&pkt);
}
void Server::SendTimeOfDay(u16 peer_id, u16 time, f32 time_speed)
{
DSTACK(__FUNCTION_NAME);
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_TIME_OF_DAY, 0, peer_id);
- *pkt << time << time_speed;
+ NetworkPacket pkt(TOCLIENT_TIME_OF_DAY, 0, peer_id);
+ pkt << time << time_speed;
if (peer_id == PEER_ID_INEXISTENT) {
- m_clients.sendToAll(0, pkt, true);
+ m_clients.sendToAll(0, &pkt, true);
}
else {
- Send(pkt);
+ Send(&pkt);
}
}
{
DSTACK(__FUNCTION_NAME);
PlayerSAO *playersao = getPlayerSAO(peer_id);
- assert(playersao);
- playersao->m_hp_not_sent = false;
+ // In some rare case, if the player is disconnected
+ // while Lua call l_punch, for example, this can be NULL
+ if (!playersao)
+ return;
+
SendHP(peer_id, playersao->getHP());
m_script->player_event(playersao,"health_changed");
// Send to other clients
std::string str = gob_cmd_punched(playersao->readDamage(), playersao->getHP());
ActiveObjectMessage aom(playersao->getId(), true, str);
- playersao->m_messages_out.push_back(aom);
+ playersao->m_messages_out.push(aom);
}
void Server::SendPlayerBreath(u16 peer_id)
DSTACK(__FUNCTION_NAME);
PlayerSAO *playersao = getPlayerSAO(peer_id);
assert(playersao);
- playersao->m_breath_not_sent = false;
- m_script->player_event(playersao,"breath_changed");
+
+ m_script->player_event(playersao, "breath_changed");
SendBreath(peer_id, playersao->getBreath());
}
Player *player = m_env->getPlayer(peer_id);
assert(player);
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_MOVE_PLAYER, 0, peer_id);
- *pkt << player->getPosition() << player->getPitch() << player->getYaw();
+ NetworkPacket pkt(TOCLIENT_MOVE_PLAYER, sizeof(v3f) + sizeof(f32) * 2, peer_id);
+ pkt << player->getPosition() << player->getPitch() << player->getYaw();
{
v3f pos = player->getPosition();
f32 pitch = player->getPitch();
f32 yaw = player->getYaw();
- verbosestream<<"Server: Sending TOCLIENT_MOVE_PLAYER"
- <<" pos=("<<pos.X<<","<<pos.Y<<","<<pos.Z<<")"
- <<" pitch="<<pitch
- <<" yaw="<<yaw
- <<std::endl;
+ verbosestream << "Server: Sending TOCLIENT_MOVE_PLAYER"
+ << " pos=(" << pos.X << "," << pos.Y << "," << pos.Z << ")"
+ << " pitch=" << pitch
+ << " yaw=" << yaw
+ << std::endl;
}
- Send(pkt);
+ Send(&pkt);
}
void Server::SendLocalPlayerAnimations(u16 peer_id, v2s32 animation_frames[4], f32 animation_speed)
{
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_LOCAL_PLAYER_ANIMATIONS, 0,
+ NetworkPacket pkt(TOCLIENT_LOCAL_PLAYER_ANIMATIONS, 0,
peer_id);
- *pkt << animation_frames[0] << animation_frames[1] << animation_frames[2]
+ pkt << animation_frames[0] << animation_frames[1] << animation_frames[2]
<< animation_frames[3] << animation_speed;
- Send(pkt);
+ Send(&pkt);
}
void Server::SendEyeOffset(u16 peer_id, v3f first, v3f third)
{
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_EYE_OFFSET, 0, peer_id);
- *pkt << first << third;
- Send(pkt);
+ NetworkPacket pkt(TOCLIENT_EYE_OFFSET, 0, peer_id);
+ pkt << first << third;
+ Send(&pkt);
}
void Server::SendPlayerPrivileges(u16 peer_id)
{
std::set<std::string> privs;
m_script->getAuth(player->getName(), NULL, &privs);
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_PRIVILEGES, 0, peer_id);
- *pkt << (u16) privs.size();
+ NetworkPacket pkt(TOCLIENT_PRIVILEGES, 0, peer_id);
+ pkt << (u16) privs.size();
for(std::set<std::string>::const_iterator i = privs.begin();
- i != privs.end(); i++) {
- *pkt << (*i);
+ i != privs.end(); ++i) {
+ pkt << (*i);
}
- Send(pkt);
+ Send(&pkt);
}
void Server::SendPlayerInventoryFormspec(u16 peer_id)
if(player->peer_id == PEER_ID_INEXISTENT)
return;
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_INVENTORY_FORMSPEC, 0, peer_id);
- pkt->putLongString(FORMSPEC_VERSION_STRING + player->inventory_formspec);
- Send(pkt);
+ NetworkPacket pkt(TOCLIENT_INVENTORY_FORMSPEC, 0, peer_id);
+ pkt.putLongString(FORMSPEC_VERSION_STRING + player->inventory_formspec);
+ Send(&pkt);
+}
+
+u32 Server::SendActiveObjectRemoveAdd(u16 peer_id, const std::string &datas)
+{
+ NetworkPacket pkt(TOCLIENT_ACTIVE_OBJECT_REMOVE_ADD, datas.size(), peer_id);
+ pkt.putRawString(datas.c_str(), datas.size());
+ Send(&pkt);
+ return pkt.getSize();
+}
+
+void Server::SendActiveObjectMessages(u16 peer_id, const std::string &datas, bool reliable)
+{
+ NetworkPacket pkt(TOCLIENT_ACTIVE_OBJECT_MESSAGES,
+ datas.size(), peer_id);
+
+ pkt.putRawString(datas.c_str(), datas.size());
+
+ m_clients.send(pkt.getPeerId(),
+ reliable ? clientCommandFactoryTable[pkt.getCommand()].channel : 1,
+ &pkt, reliable);
+
}
s32 Server::playSound(const SimpleSoundSpec &spec,
return -1;
// Filter destination clients
- std::list<u16> dst_clients;
+ std::vector<u16> dst_clients;
if(params.to_player != "")
{
Player *player = m_env->getPlayer(params.to_player.c_str());
}
dst_clients.push_back(player->peer_id);
}
- else
- {
- std::list<u16> clients = m_clients.getClientIDs();
+ else {
+ std::vector<u16> clients = m_clients.getClientIDs();
- for(std::list<u16>::iterator
- i = clients.begin(); i != clients.end(); ++i)
- {
+ for(std::vector<u16>::iterator
+ i = clients.begin(); i != clients.end(); ++i) {
Player *player = m_env->getPlayer(*i);
if(!player)
continue;
- if(pos_exists){
+
+ if(pos_exists) {
if(player->getPosition().getDistanceFrom(pos) >
params.max_hear_distance)
continue;
dst_clients.push_back(*i);
}
}
+
if(dst_clients.empty())
return -1;
m_playing_sounds[id] = ServerPlayingSound();
ServerPlayingSound &psound = m_playing_sounds[id];
psound.params = params;
- for(std::list<u16>::iterator i = dst_clients.begin();
- i != dst_clients.end(); i++)
- psound.clients.insert(*i);
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_PLAY_SOUND, 0);
- *pkt << id << spec.name << (float) (spec.gain * params.gain)
+ NetworkPacket pkt(TOCLIENT_PLAY_SOUND, 0);
+ pkt << id << spec.name << (float) (spec.gain * params.gain)
<< (u8) params.type << pos << params.object << params.loop;
- for(std::list<u16>::iterator i = dst_clients.begin();
- i != dst_clients.end(); i++) {
- // Send as reliable
- m_clients.send(*i, 0, pkt, true, false);
+
+ for(std::vector<u16>::iterator i = dst_clients.begin();
+ i != dst_clients.end(); ++i) {
+ psound.clients.insert(*i);
+ m_clients.send(*i, 0, &pkt, true);
}
- delete pkt;
return id;
}
void Server::stopSound(s32 handle)
return;
ServerPlayingSound &psound = i->second;
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_STOP_SOUND, 4);
- *pkt << handle;
+ NetworkPacket pkt(TOCLIENT_STOP_SOUND, 4);
+ pkt << handle;
for(std::set<u16>::iterator i = psound.clients.begin();
- i != psound.clients.end(); i++) {
+ i != psound.clients.end(); ++i) {
// Send as reliable
- m_clients.send(*i, 0, pkt, true, false);
+ m_clients.send(*i, 0, &pkt, true);
}
- delete pkt;
// Remove sound reference
m_playing_sounds.erase(i);
}
void Server::sendRemoveNode(v3s16 p, u16 ignore_id,
- std::list<u16> *far_players, float far_d_nodes)
+ std::vector<u16> *far_players, float far_d_nodes)
{
float maxd = far_d_nodes*BS;
v3f p_f = intToFloat(p, BS);
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_REMOVENODE, 2 + 2 + 2);
- *pkt << p;
+ NetworkPacket pkt(TOCLIENT_REMOVENODE, 6);
+ pkt << p;
- std::list<u16> clients = m_clients.getClientIDs();
- for(std::list<u16>::iterator
- i = clients.begin();
- i != clients.end(); ++i)
- {
- if(far_players)
- {
+ std::vector<u16> clients = m_clients.getClientIDs();
+ for(std::vector<u16>::iterator i = clients.begin();
+ i != clients.end(); ++i) {
+ if (far_players) {
// Get player
- Player *player = m_env->getPlayer(*i);
- if(player)
- {
+ if(Player *player = m_env->getPlayer(*i)) {
// If player is far away, only set modified blocks not sent
v3f player_pos = player->getPosition();
- if(player_pos.getDistanceFrom(p_f) > maxd)
- {
+ if(player_pos.getDistanceFrom(p_f) > maxd) {
far_players->push_back(*i);
continue;
}
}
// Send as reliable
- m_clients.send(*i, 0, pkt, true, false);
+ m_clients.send(*i, 0, &pkt, true);
}
- // This loop needs the deletion of the packet here
- delete pkt;
}
void Server::sendAddNode(v3s16 p, MapNode n, u16 ignore_id,
- std::list<u16> *far_players, float far_d_nodes,
+ std::vector<u16> *far_players, float far_d_nodes,
bool remove_metadata)
{
float maxd = far_d_nodes*BS;
v3f p_f = intToFloat(p, BS);
- std::list<u16> clients = m_clients.getClientIDs();
- for(std::list<u16>::iterator
- i = clients.begin();
- i != clients.end(); ++i)
- {
+ std::vector<u16> clients = m_clients.getClientIDs();
+ for(std::vector<u16>::iterator i = clients.begin();
+ i != clients.end(); ++i) {
- if(far_players)
- {
+ if(far_players) {
// Get player
- Player *player = m_env->getPlayer(*i);
- if(player)
- {
+ if(Player *player = m_env->getPlayer(*i)) {
// If player is far away, only set modified blocks not sent
v3f player_pos = player->getPosition();
- if(player_pos.getDistanceFrom(p_f) > maxd)
- {
+ if(player_pos.getDistanceFrom(p_f) > maxd) {
far_players->push_back(*i);
continue;
}
}
}
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_ADDNODE, 0);
- m_clients.Lock();
+ NetworkPacket pkt(TOCLIENT_ADDNODE, 6 + 2 + 1 + 1 + 1);
+ m_clients.lock();
RemoteClient* client = m_clients.lockedGetClientNoEx(*i);
if (client != 0) {
- *pkt << p << n.param0 << n.param1 << n.param2
+ pkt << p << n.param0 << n.param1 << n.param2
<< (u8) (remove_metadata ? 0 : 1);
if (!remove_metadata) {
}
}
}
- m_clients.Unlock();
+ m_clients.unlock();
// Send as reliable
- if (pkt->getSize() > 0)
- m_clients.send(*i, 0, pkt, true);
+ if (pkt.getSize() > 0)
+ m_clients.send(*i, 0, &pkt, true);
}
}
void Server::setBlockNotSent(v3s16 p)
{
- std::list<u16> clients = m_clients.getClientIDs();
- m_clients.Lock();
- for(std::list<u16>::iterator
- i = clients.begin();
- i != clients.end(); ++i)
- {
+ std::vector<u16> clients = m_clients.getClientIDs();
+ m_clients.lock();
+ for(std::vector<u16>::iterator i = clients.begin();
+ i != clients.end(); ++i) {
RemoteClient *client = m_clients.lockedGetClientNoEx(*i);
client->SetBlockNotSent(p);
}
- m_clients.Unlock();
+ m_clients.unlock();
}
void Server::SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver, u16 net_proto_version)
block->serializeNetworkSpecific(os, net_proto_version);
std::string s = os.str();
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_BLOCKDATA,
- 2 + 2 + 2 + 2 + s.size(), peer_id);
+ NetworkPacket pkt(TOCLIENT_BLOCKDATA, 2 + 2 + 2 + 2 + s.size(), peer_id);
- *pkt << p;
- pkt->putRawString(s.c_str(), s.size());
- Send(pkt);
+ pkt << p;
+ pkt.putRawString(s.c_str(), s.size());
+ Send(&pkt);
}
void Server::SendBlocks(float dtime)
{
DSTACK(__FUNCTION_NAME);
- JMutexAutoLock envlock(m_env_mutex);
+ MutexAutoLock envlock(m_env_mutex);
//TODO check if one big lock could be faster then multiple small ones
ScopeProfiler sp(g_profiler, "Server: sel and send blocks to clients");
{
ScopeProfiler sp(g_profiler, "Server: selecting blocks for sending");
- std::list<u16> clients = m_clients.getClientIDs();
+ std::vector<u16> clients = m_clients.getClientIDs();
- m_clients.Lock();
- for(std::list<u16>::iterator
- i = clients.begin();
- i != clients.end(); ++i)
- {
+ m_clients.lock();
+ for(std::vector<u16>::iterator i = clients.begin();
+ i != clients.end(); ++i) {
RemoteClient *client = m_clients.lockedGetClientNoEx(*i, CS_Active);
if (client == NULL)
total_sending += client->SendingCount();
client->GetNextBlocks(m_env,m_emerge, dtime, queue);
}
- m_clients.Unlock();
+ m_clients.unlock();
}
// Sort.
// Lowest is most important.
std::sort(queue.begin(), queue.end());
- m_clients.Lock();
+ m_clients.lock();
for(u32 i=0; i<queue.size(); i++)
{
//TODO: Calculate limit dynamically
client->SentBlock(q.pos);
total_sending++;
}
- m_clients.Unlock();
+ m_clients.unlock();
}
void Server::fillMediaCache()
infostream<<"Server: Calculating media file checksums"<<std::endl;
// Collect all media file paths
- std::list<std::string> paths;
+ std::vector<std::string> paths;
for(std::vector<ModSpec>::iterator i = m_mods.begin();
- i != m_mods.end(); i++){
+ i != m_mods.end(); ++i) {
const ModSpec &mod = *i;
paths.push_back(mod.path + DIR_DELIM + "textures");
paths.push_back(mod.path + DIR_DELIM + "sounds");
paths.push_back(porting::path_user + DIR_DELIM + "textures" + DIR_DELIM + "server");
// Collect media file information from paths into cache
- for(std::list<std::string>::iterator i = paths.begin();
- i != paths.end(); i++)
- {
+ for(std::vector<std::string>::iterator i = paths.begin();
+ i != paths.end(); ++i) {
std::string mediapath = *i;
std::vector<fs::DirListNode> dirlist = fs::GetDirListing(mediapath);
- for(u32 j=0; j<dirlist.size(); j++){
- if(dirlist[j].dir) // Ignode dirs
+ for (u32 j = 0; j < dirlist.size(); j++) {
+ if (dirlist[j].dir) // Ignode dirs
continue;
std::string filename = dirlist[j].name;
// If name contains illegal characters, ignore the file
- if(!string_allowed(filename, TEXTURENAME_ALLOWED_CHARS)){
+ if (!string_allowed(filename, TEXTURENAME_ALLOWED_CHARS)) {
infostream<<"Server: ignoring illegal file name: \""
- <<filename<<"\""<<std::endl;
+ << filename << "\"" << std::endl;
continue;
}
// If name is not in a supported format, ignore it
".x", ".b3d", ".md2", ".obj",
NULL
};
- if(removeStringEnd(filename, supported_ext) == ""){
- infostream<<"Server: ignoring unsupported file extension: \""
- <<filename<<"\""<<std::endl;
+ if (removeStringEnd(filename, supported_ext) == ""){
+ infostream << "Server: ignoring unsupported file extension: \""
+ << filename << "\"" << std::endl;
continue;
}
// Ok, attempt to load the file and add to cache
std::string filepath = mediapath + DIR_DELIM + filename;
// Read data
std::ifstream fis(filepath.c_str(), std::ios_base::binary);
- if(fis.good() == false){
- errorstream<<"Server::fillMediaCache(): Could not open \""
- <<filename<<"\" for reading"<<std::endl;
+ if (!fis.good()) {
+ errorstream << "Server::fillMediaCache(): Could not open \""
+ << filename << "\" for reading" << std::endl;
continue;
}
std::ostringstream tmp_os(std::ios_base::binary);
bool bad = false;
- for(;;){
+ for(;;) {
char buf[1024];
fis.read(buf, 1024);
std::streamsize len = fis.gcount();
tmp_os.write(buf, len);
- if(fis.eof())
+ if (fis.eof())
break;
- if(!fis.good()){
+ if (!fis.good()) {
bad = true;
break;
}
}
- if(bad){
+ if(bad) {
errorstream<<"Server::fillMediaCache(): Failed to read \""
- <<filename<<"\""<<std::endl;
+ << filename << "\"" << std::endl;
continue;
}
- if(tmp_os.str().length() == 0){
- errorstream<<"Server::fillMediaCache(): Empty file \""
- <<filepath<<"\""<<std::endl;
+ if(tmp_os.str().length() == 0) {
+ errorstream << "Server::fillMediaCache(): Empty file \""
+ << filepath << "\"" << std::endl;
continue;
}
free(digest);
// Put in list
- this->m_media[filename] = MediaInfo(filepath, sha1_base64);
- verbosestream<<"Server: "<<sha1_hex<<" is "<<filename<<std::endl;
+ m_media[filename] = MediaInfo(filepath, sha1_base64);
+ verbosestream << "Server: " << sha1_hex << " is " << filename
+ << std::endl;
}
}
}
-struct SendableMediaAnnouncement
-{
- std::string name;
- std::string sha1_digest;
-
- SendableMediaAnnouncement(const std::string &name_="",
- const std::string &sha1_digest_=""):
- name(name_),
- sha1_digest(sha1_digest_)
- {}
-};
-
void Server::sendMediaAnnouncement(u16 peer_id)
{
DSTACK(__FUNCTION_NAME);
- verbosestream<<"Server: Announcing files to id("<<peer_id<<")"
- <<std::endl;
-
- std::list<SendableMediaAnnouncement> file_announcements;
-
- for(std::map<std::string, MediaInfo>::iterator i = m_media.begin();
- i != m_media.end(); i++){
- // Put in list
- file_announcements.push_back(
- SendableMediaAnnouncement(i->first, i->second.sha1_digest));
- }
+ verbosestream << "Server: Announcing files to id(" << peer_id << ")"
+ << std::endl;
// Make packet
std::ostringstream os(std::ios_base::binary);
- /*
- u32 number of files
- for each texture {
- u16 length of name
- string name
- u16 length of sha1_digest
- string sha1_digest
- }
- */
+ NetworkPacket pkt(TOCLIENT_ANNOUNCE_MEDIA, 0, peer_id);
+ pkt << (u16) m_media.size();
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_ANNOUNCE_MEDIA, 0, peer_id);
- *pkt << (u16) file_announcements.size();
-
- for(std::list<SendableMediaAnnouncement>::iterator
- j = file_announcements.begin();
- j != file_announcements.end(); ++j) {
- *pkt << j->name << j->sha1_digest;
+ for (std::map<std::string, MediaInfo>::iterator i = m_media.begin();
+ i != m_media.end(); ++i) {
+ pkt << i->first << i->second.sha1_digest;
}
- *pkt << g_settings->get("remote_media");
- Send(pkt);
+ pkt << g_settings->get("remote_media");
+ Send(&pkt);
}
struct SendableMedia
};
void Server::sendRequestedMedia(u16 peer_id,
- const std::list<std::string> &tosend)
+ const std::vector<std::string> &tosend)
{
DSTACK(__FUNCTION_NAME);
// Put 5kB in one bunch (this is not accurate)
u32 bytes_per_bunch = 5000;
- std::vector< std::list<SendableMedia> > file_bunches;
- file_bunches.push_back(std::list<SendableMedia>());
+ std::vector< std::vector<SendableMedia> > file_bunches;
+ file_bunches.push_back(std::vector<SendableMedia>());
u32 file_size_bunch_total = 0;
- for(std::list<std::string>::const_iterator i = tosend.begin();
- i != tosend.end(); ++i)
- {
+ for(std::vector<std::string>::const_iterator i = tosend.begin();
+ i != tosend.end(); ++i) {
const std::string &name = *i;
if(m_media.find(name) == m_media.end()) {
// Start next bunch if got enough data
if(file_size_bunch_total >= bytes_per_bunch) {
- file_bunches.push_back(std::list<SendableMedia>());
+ file_bunches.push_back(std::vector<SendableMedia>());
file_size_bunch_total = 0;
}
}
*/
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_MEDIA, 0, peer_id);
- *pkt << num_bunches << i << (u32) file_bunches[i].size();
+ NetworkPacket pkt(TOCLIENT_MEDIA, 4 + 0, peer_id);
+ pkt << num_bunches << i << (u32) file_bunches[i].size();
- for(std::list<SendableMedia>::iterator
+ for(std::vector<SendableMedia>::iterator
j = file_bunches[i].begin();
j != file_bunches[i].end(); ++j) {
- *pkt << j->name;
- pkt->putLongString(j->data);
+ pkt << j->name;
+ pkt.putLongString(j->data);
}
verbosestream << "Server::sendRequestedMedia(): bunch "
<< i << "/" << num_bunches
<< " files=" << file_bunches[i].size()
- << " size=" << pkt->getSize() << std::endl;
- Send(pkt);
+ << " size=" << pkt.getSize() << std::endl;
+ Send(&pkt);
}
}
// Make data buffer
std::string s = os.str();
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_DETACHED_INVENTORY, 0, peer_id);
- pkt->putRawString(s.c_str(), s.size());
+ NetworkPacket pkt(TOCLIENT_DETACHED_INVENTORY, 0, peer_id);
+ pkt.putRawString(s.c_str(), s.size());
if (peer_id != PEER_ID_INEXISTENT) {
- Send(pkt);
+ Send(&pkt);
}
else {
- m_clients.sendToAll(0, pkt, true);
+ m_clients.sendToAll(0, &pkt, true);
}
}
for(std::map<std::string, Inventory*>::iterator
i = m_detached_inventories.begin();
- i != m_detached_inventories.end(); i++) {
+ i != m_detached_inventories.end(); ++i) {
const std::string &name = i->first;
//Inventory *inv = i->second;
sendDetachedInventory(name, peer_id);
PlayerSAO *playersao = getPlayerSAO(peer_id);
assert(playersao);
- infostream<<"Server::DiePlayer(): Player "
- <<playersao->getPlayer()->getName()
- <<" dies"<<std::endl;
+ infostream << "Server::DiePlayer(): Player "
+ << playersao->getPlayer()->getName()
+ << " dies" << std::endl;
playersao->setHP(0);
PlayerSAO *playersao = getPlayerSAO(peer_id);
assert(playersao);
- infostream<<"Server::RespawnPlayer(): Player "
- <<playersao->getPlayer()->getName()
- <<" respawns"<<std::endl;
+ infostream << "Server::RespawnPlayer(): Player "
+ << playersao->getPlayer()->getName()
+ << " respawns" << std::endl;
playersao->setHP(PLAYER_MAX_HP);
playersao->setBreath(PLAYER_MAX_BREATH);
+ SendPlayerHP(peer_id);
+ SendPlayerBreath(peer_id);
+
bool repositioned = m_script->on_respawnplayer(playersao);
if(!repositioned){
- v3f pos = findSpawnPos(m_env->getServerMap());
+ v3f pos = findSpawnPos();
+ // setPos will send the new position to client
playersao->setPos(pos);
}
}
-void Server::DenyAccess(u16 peer_id, const std::wstring &reason)
+
+void Server::DenySudoAccess(u16 peer_id)
+{
+ DSTACK(__FUNCTION_NAME);
+
+ NetworkPacket pkt(TOCLIENT_DENY_SUDO_MODE, 0, peer_id);
+ Send(&pkt);
+}
+
+
+void Server::DenyAccessVerCompliant(u16 peer_id, u16 proto_ver, AccessDeniedCode reason,
+ const std::string &str_reason, bool reconnect)
+{
+ if (proto_ver >= 25) {
+ SendAccessDenied(peer_id, reason, str_reason);
+ } else {
+ std::wstring wreason = utf8_to_wide(
+ reason == SERVER_ACCESSDENIED_CUSTOM_STRING ? str_reason :
+ accessDeniedStrings[(u8)reason]);
+ SendAccessDenied_Legacy(peer_id, wreason);
+ }
+
+ m_clients.event(peer_id, CSE_SetDenied);
+ m_con.DisconnectPeer(peer_id);
+}
+
+
+void Server::DenyAccess(u16 peer_id, AccessDeniedCode reason, const std::string &custom_reason)
+{
+ DSTACK(__FUNCTION_NAME);
+
+ SendAccessDenied(peer_id, reason, custom_reason);
+ m_clients.event(peer_id, CSE_SetDenied);
+ m_con.DisconnectPeer(peer_id);
+}
+
+// 13/03/15: remove this function when protocol version 25 will become
+// the minimum version for MT users, maybe in 1 year
+void Server::DenyAccess_Legacy(u16 peer_id, const std::wstring &reason)
{
DSTACK(__FUNCTION_NAME);
- SendAccessDenied(peer_id, reason);
+ SendAccessDenied_Legacy(peer_id, reason);
m_clients.event(peer_id, CSE_SetDenied);
m_con.DisconnectPeer(peer_id);
}
+void Server::acceptAuth(u16 peer_id, bool forSudoMode)
+{
+ DSTACK(__FUNCTION_NAME);
+
+ if (!forSudoMode) {
+ RemoteClient* client = getClient(peer_id, CS_Invalid);
+
+ NetworkPacket resp_pkt(TOCLIENT_AUTH_ACCEPT, 1 + 6 + 8 + 4, peer_id);
+
+ // Right now, the auth mechs don't change between login and sudo mode.
+ u32 sudo_auth_mechs = client->allowed_auth_mechs;
+ client->allowed_sudo_mechs = sudo_auth_mechs;
+
+ resp_pkt << v3f(0,0,0) << (u64) m_env->getServerMap().getSeed()
+ << g_settings->getFloat("dedicated_server_step")
+ << sudo_auth_mechs;
+
+ Send(&resp_pkt);
+ m_clients.event(peer_id, CSE_AuthAccept);
+ } else {
+ NetworkPacket resp_pkt(TOCLIENT_ACCEPT_SUDO_MODE, 1 + 6 + 8 + 4, peer_id);
+
+ // We only support SRP right now
+ u32 sudo_auth_mechs = AUTH_MECHANISM_FIRST_SRP;
+
+ resp_pkt << sudo_auth_mechs;
+ Send(&resp_pkt);
+ m_clients.event(peer_id, CSE_SudoSuccess);
+ }
+}
+
void Server::DeleteClient(u16 peer_id, ClientDeletionReason reason)
{
DSTACK(__FUNCTION_NAME);
if(psound.clients.empty())
m_playing_sounds.erase(i++);
else
- i++;
+ ++i;
}
Player *player = m_env->getPlayer(peer_id);
Print out action
*/
{
- if(player != NULL && reason != CDR_DENY)
- {
+ if(player != NULL && reason != CDR_DENY) {
std::ostringstream os(std::ios_base::binary);
- std::list<u16> clients = m_clients.getClientIDs();
+ std::vector<u16> clients = m_clients.getClientIDs();
- for(std::list<u16>::iterator
- i = clients.begin();
- i != clients.end(); ++i)
- {
+ for(std::vector<u16>::iterator i = clients.begin();
+ i != clients.end(); ++i) {
// Get player
Player *player = m_env->getPlayer(*i);
if(!player)
continue;
+
// Get name of player
- os<<player->getName()<<" ";
+ os << player->getName() << " ";
}
- actionstream<<player->getName()<<" "
- <<(reason==CDR_TIMEOUT?"times out.":"leaves game.")
- <<" List of players: "<<os.str()<<std::endl;
+ actionstream << player->getName() << " "
+ << (reason == CDR_TIMEOUT ? "times out." : "leaves game.")
+ << " List of players: " << os.str() << std::endl;
}
}
{
- JMutexAutoLock env_lock(m_env_mutex);
+ MutexAutoLock env_lock(m_env_mutex);
m_clients.DeleteClient(peer_id);
}
}
SendChatMessage(PEER_ID_INEXISTENT,message);
}
-void Server::UpdateCrafting(u16 peer_id)
+void Server::UpdateCrafting(Player* player)
{
DSTACK(__FUNCTION_NAME);
- Player* player = m_env->getPlayer(peer_id);
- assert(player);
-
// Get a preview for crafting
ItemStack preview;
InventoryLocation loc;
loc.setPlayer(player->getName());
- getCraftingResult(&player->inventory, preview, false, this);
+ std::vector<ItemStack> output_replacements;
+ getCraftingResult(&player->inventory, preview, output_replacements, false, this);
m_env->getScriptIface()->item_CraftPredict(preview, player->getPlayerSAO(), (&player->inventory)->getList("craft"), loc);
// Put the new preview in
InventoryList *plist = player->inventory.getList("craftpreview");
- assert(plist);
- assert(plist->getSize() >= 1);
+ sanity_check(plist);
+ sanity_check(plist->getSize() >= 1);
plist->changeItem(0, preview);
}
std::wostringstream os(std::ios_base::binary);
os<<L"# Server: ";
// Version
- os<<L"version="<<narrow_to_wide(minetest_version_simple);
+ os<<L"version="<<narrow_to_wide(g_version_string);
// Uptime
os<<L", uptime="<<m_uptime.get();
// Max lag estimate
// Information about clients
bool first = true;
os<<L", clients={";
- std::list<u16> clients = m_clients.getClientIDs();
- for(std::list<u16>::iterator i = clients.begin();
- i != clients.end(); ++i)
- {
+ std::vector<u16> clients = m_clients.getClientIDs();
+ for(std::vector<u16>::iterator i = clients.begin();
+ i != clients.end(); ++i) {
// Get player
Player *player = m_env->getPlayer(*i);
// Get name of player
name = narrow_to_wide(player->getName());
// Add name to information string
if(!first)
- os<<L", ";
+ os << L", ";
else
first = false;
- os<<name;
+ os << name;
}
- os<<L"}";
+ os << L"}";
if(((ServerMap*)(&m_env->getMap()))->isSavingEnabled() == false)
os<<std::endl<<L"# Server: "<<" WARNING: Map saving is disabled.";
if(g_settings->get("motd") != "")
void Server::reportPrivsModified(const std::string &name)
{
- if(name == ""){
- std::list<u16> clients = m_clients.getClientIDs();
- for(std::list<u16>::iterator
- i = clients.begin();
- i != clients.end(); ++i){
+ if(name == "") {
+ std::vector<u16> clients = m_clients.getClientIDs();
+ for(std::vector<u16>::iterator i = clients.begin();
+ i != clients.end(); ++i) {
Player *player = m_env->getPlayer(*i);
reportPrivsModified(player->getName());
}
void Server::notifyPlayer(const char *name, const std::wstring &msg)
{
+ // m_env will be NULL if the server is initializing
+ if (!m_env)
+ return;
+
Player *player = m_env->getPlayer(name);
- if(!player)
+ if (!player)
return;
if (player->peer_id == PEER_ID_INEXISTENT)
SendChatMessage(player->peer_id, msg);
}
-bool Server::showFormspec(const char *playername, const std::string &formspec, const std::string &formname)
+bool Server::showFormspec(const char *playername, const std::string &formspec,
+ const std::string &formname)
{
- Player *player = m_env->getPlayer(playername);
+ // m_env will be NULL if the server is initializing
+ if (!m_env)
+ return false;
- if(!player)
- {
- infostream<<"showFormspec: couldn't find player:"<<playername<<std::endl;
+ Player *player = m_env->getPlayer(playername);
+ if (!player)
return false;
- }
SendShowFormspecMessage(player->peer_id, formspec, formname);
return true;
}
-u32 Server::hudAdd(Player *player, HudElement *form) {
+u32 Server::hudAdd(Player *player, HudElement *form)
+{
if (!player)
return -1;
return true;
}
-bool Server::hudChange(Player *player, u32 id, HudElementStat stat, void *data) {
+bool Server::hudChange(Player *player, u32 id, HudElementStat stat, void *data)
+{
if (!player)
return false;
return true;
}
-bool Server::hudSetFlags(Player *player, u32 flags, u32 mask) {
+bool Server::hudSetFlags(Player *player, u32 flags, u32 mask)
+{
if (!player)
return false;
return true;
}
-bool Server::hudSetHotbarItemcount(Player *player, s32 hotbar_itemcount) {
+bool Server::hudSetHotbarItemcount(Player *player, s32 hotbar_itemcount)
+{
if (!player)
return false;
if (hotbar_itemcount <= 0 || hotbar_itemcount > HUD_HOTBAR_ITEMCOUNT_MAX)
return false;
+ player->setHotbarItemcount(hotbar_itemcount);
std::ostringstream os(std::ios::binary);
writeS32(os, hotbar_itemcount);
SendHUDSetParam(player->peer_id, HUD_PARAM_HOTBAR_ITEMCOUNT, os.str());
return true;
}
-void Server::hudSetHotbarImage(Player *player, std::string name) {
+s32 Server::hudGetHotbarItemcount(Player *player)
+{
+ if (!player)
+ return 0;
+ return player->getHotbarItemcount();
+}
+
+void Server::hudSetHotbarImage(Player *player, std::string name)
+{
if (!player)
return;
+ player->setHotbarImage(name);
SendHUDSetParam(player->peer_id, HUD_PARAM_HOTBAR_IMAGE, name);
}
-void Server::hudSetHotbarSelectedImage(Player *player, std::string name) {
+std::string Server::hudGetHotbarImage(Player *player)
+{
+ if (!player)
+ return "";
+ return player->getHotbarImage();
+}
+
+void Server::hudSetHotbarSelectedImage(Player *player, std::string name)
+{
if (!player)
return;
+ player->setHotbarSelectedImage(name);
SendHUDSetParam(player->peer_id, HUD_PARAM_HOTBAR_SELECTED_IMAGE, name);
}
-bool Server::setLocalPlayerAnimations(Player *player, v2s32 animation_frames[4], f32 frame_speed)
+std::string Server::hudGetHotbarSelectedImage(Player *player)
+{
+ if (!player)
+ return "";
+
+ return player->getHotbarSelectedImage();
+}
+
+bool Server::setLocalPlayerAnimations(Player *player,
+ v2s32 animation_frames[4], f32 frame_speed)
{
if (!player)
return false;
+ player->setLocalAnimations(animation_frames, frame_speed);
SendLocalPlayerAnimations(player->peer_id, animation_frames, frame_speed);
return true;
}
if (!player)
return false;
+ player->eye_offset_first = first;
+ player->eye_offset_third = third;
SendEyeOffset(player->peer_id, first, third);
return true;
}
bool Server::setSky(Player *player, const video::SColor &bgcolor,
- const std::string &type, const std::vector<std::string> ¶ms)
+ const std::string &type, const std::vector<std::string> ¶ms)
{
if (!player)
return false;
+ player->setSky(bgcolor, type, params);
SendSetSky(player->peer_id, bgcolor, type, params);
return true;
}
bool Server::overrideDayNightRatio(Player *player, bool do_override,
- float ratio)
+ float ratio)
{
if (!player)
return false;
+ player->overrideDayNightRatio(do_override, ratio);
SendOverrideDayNightRatio(player->peer_id, do_override, ratio);
return true;
}
SendChatMessage(PEER_ID_INEXISTENT,msg);
}
-void Server::spawnParticle(const char *playername, v3f pos,
- v3f velocity, v3f acceleration,
- float expirationtime, float size, bool
- collisiondetection, bool vertical, std::string texture)
+void Server::spawnParticle(const std::string &playername, v3f pos,
+ v3f velocity, v3f acceleration,
+ float expirationtime, float size, bool
+ collisiondetection, bool vertical, const std::string &texture)
{
- Player *player = m_env->getPlayer(playername);
- if(!player)
+ // m_env will be NULL if the server is initializing
+ if (!m_env)
return;
- SendSpawnParticle(player->peer_id, pos, velocity, acceleration,
- expirationtime, size, collisiondetection, vertical, texture);
-}
-void Server::spawnParticleAll(v3f pos, v3f velocity, v3f acceleration,
- float expirationtime, float size,
- bool collisiondetection, bool vertical, std::string texture)
-{
- SendSpawnParticle(PEER_ID_INEXISTENT,pos, velocity, acceleration,
+ u16 peer_id = PEER_ID_INEXISTENT;
+ if (playername != "") {
+ Player* player = m_env->getPlayer(playername.c_str());
+ if (!player)
+ return;
+ peer_id = player->peer_id;
+ }
+
+ SendSpawnParticle(peer_id, pos, velocity, acceleration,
expirationtime, size, collisiondetection, vertical, texture);
}
-u32 Server::addParticleSpawner(const char *playername,
- 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 vertical, std::string texture)
+u32 Server::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 vertical, const std::string &texture,
+ const std::string &playername)
{
- Player *player = m_env->getPlayer(playername);
- if(!player)
+ // m_env will be NULL if the server is initializing
+ if (!m_env)
return -1;
- u32 id = 0;
- for(;;) // look for unused particlespawner id
- {
- id++;
- if (std::find(m_particlespawner_ids.begin(),
- m_particlespawner_ids.end(), id)
- == m_particlespawner_ids.end())
- {
- m_particlespawner_ids.push_back(id);
- break;
- }
+ u16 peer_id = PEER_ID_INEXISTENT;
+ if (playername != "") {
+ Player* player = m_env->getPlayer(playername.c_str());
+ if (!player)
+ return -1;
+ peer_id = player->peer_id;
}
- SendAddParticleSpawner(player->peer_id, amount, spawntime,
- minpos, maxpos, minvel, maxvel, minacc, maxacc,
- minexptime, maxexptime, minsize, maxsize,
- collisiondetection, vertical, texture, id);
-
- return id;
-}
-
-u32 Server::addParticleSpawnerAll(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 vertical, std::string texture)
-{
u32 id = 0;
for(;;) // look for unused particlespawner id
{
}
}
- SendAddParticleSpawner(PEER_ID_INEXISTENT, amount, spawntime,
+ SendAddParticleSpawner(peer_id, amount, spawntime,
minpos, maxpos, minvel, maxvel, minacc, maxacc,
minexptime, maxexptime, minsize, maxsize,
collisiondetection, vertical, texture, id);
return id;
}
-void Server::deleteParticleSpawner(const char *playername, u32 id)
+void Server::deleteParticleSpawner(const std::string &playername, u32 id)
{
- Player *player = m_env->getPlayer(playername);
- if(!player)
- return;
+ // m_env will be NULL if the server is initializing
+ if (!m_env)
+ throw ServerError("Can't delete particle spawners during initialisation!");
- m_particlespawner_ids.erase(
- std::remove(m_particlespawner_ids.begin(),
- m_particlespawner_ids.end(), id),
- m_particlespawner_ids.end());
- SendDeleteParticleSpawner(player->peer_id, id);
-}
+ u16 peer_id = PEER_ID_INEXISTENT;
+ if (playername != "") {
+ Player* player = m_env->getPlayer(playername.c_str());
+ if (!player)
+ return;
+ peer_id = player->peer_id;
+ }
-void Server::deleteParticleSpawnerAll(u32 id)
-{
m_particlespawner_ids.erase(
std::remove(m_particlespawner_ids.begin(),
m_particlespawner_ids.end(), id),
m_particlespawner_ids.end());
- SendDeleteParticleSpawner(PEER_ID_INEXISTENT, id);
+ SendDeleteParticleSpawner(peer_id, id);
}
Inventory* Server::createDetachedInventory(const std::string &name)
infostream<<"Server creating detached inventory \""<<name<<"\""<<std::endl;
}
Inventory *inv = new Inventory(m_itemdef);
- assert(inv);
+ sanity_check(inv);
m_detached_inventories[name] = inv;
//TODO find a better way to do this
sendDetachedInventory(name,PEER_ID_INEXISTENT);
return inv;
}
-class BoolScopeSet
-{
-public:
- BoolScopeSet(bool *dst, bool val):
- m_dst(dst)
- {
- m_orig_state = *m_dst;
- *m_dst = val;
- }
- ~BoolScopeSet()
- {
- *m_dst = m_orig_state;
- }
-private:
- bool *m_dst;
- bool m_orig_state;
-};
-
// actions: time-reversed list
// Return value: success/failure
bool Server::rollbackRevertActions(const std::list<RollbackAction> &actions,
for(std::list<RollbackAction>::const_iterator
i = actions.begin();
- i != actions.end(); i++)
+ i != actions.end(); ++i)
{
const RollbackAction &action = *i;
num_tried++;
// IGameDef interface
// Under envlock
-IItemDefManager* Server::getItemDefManager()
+IItemDefManager *Server::getItemDefManager()
{
return m_itemdef;
}
-INodeDefManager* Server::getNodeDefManager()
+
+INodeDefManager *Server::getNodeDefManager()
{
return m_nodedef;
}
-ICraftDefManager* Server::getCraftDefManager()
+
+ICraftDefManager *Server::getCraftDefManager()
{
return m_craftdef;
}
-ITextureSource* Server::getTextureSource()
+ITextureSource *Server::getTextureSource()
{
return NULL;
}
-IShaderSource* Server::getShaderSource()
+IShaderSource *Server::getShaderSource()
{
return NULL;
}
-scene::ISceneManager* Server::getSceneManager()
+scene::ISceneManager *Server::getSceneManager()
{
return NULL;
}
{
return m_nodedef->allocateDummy(name);
}
-ISoundManager* Server::getSoundManager()
+
+ISoundManager *Server::getSoundManager()
{
return &dummySoundManager;
}
-MtEventManager* Server::getEventManager()
+
+MtEventManager *Server::getEventManager()
{
return m_event;
}
-IWritableItemDefManager* Server::getWritableItemDefManager()
+IWritableItemDefManager *Server::getWritableItemDefManager()
{
return m_itemdef;
}
-IWritableNodeDefManager* Server::getWritableNodeDefManager()
+
+IWritableNodeDefManager *Server::getWritableNodeDefManager()
{
return m_nodedef;
}
-IWritableCraftDefManager* Server::getWritableCraftDefManager()
+
+IWritableCraftDefManager *Server::getWritableCraftDefManager()
{
return m_craftdef;
}
-const ModSpec* Server::getModSpec(const std::string &modname)
+const ModSpec *Server::getModSpec(const std::string &modname) const
{
- for(std::vector<ModSpec>::iterator i = m_mods.begin();
- i != m_mods.end(); i++){
- const ModSpec &mod = *i;
- if(mod.name == modname)
+ std::vector<ModSpec>::const_iterator it;
+ for (it = m_mods.begin(); it != m_mods.end(); ++it) {
+ const ModSpec &mod = *it;
+ if (mod.name == modname)
return &mod;
}
return NULL;
}
-void Server::getModNames(std::list<std::string> &modlist)
+
+void Server::getModNames(std::vector<std::string> &modlist)
{
- for(std::vector<ModSpec>::iterator i = m_mods.begin(); i != m_mods.end(); i++)
- {
- modlist.push_back(i->name);
- }
+ std::vector<ModSpec>::iterator it;
+ for (it = m_mods.begin(); it != m_mods.end(); ++it)
+ modlist.push_back(it->name);
}
+
std::string Server::getBuiltinLuaPath()
{
return porting::path_share + DIR_DELIM + "builtin";
}
-v3f findSpawnPos(ServerMap &map)
+v3f Server::findSpawnPos()
{
- //return v3f(50,50,50)*BS;
-
- v3s16 nodepos;
+ ServerMap &map = m_env->getServerMap();
+ v3f nodeposf;
+ if (g_settings->getV3FNoEx("static_spawnpoint", nodeposf)) {
+ return nodeposf * BS;
+ }
-#if 0
- nodepos = v2s16(0,0);
- groundheight = 20;
-#endif
+ // Default position is static_spawnpoint
+ // We will return it if we don't found a good place
+ v3s16 nodepos(nodeposf.X, nodeposf.Y, nodeposf.Z);
-#if 1
s16 water_level = map.getWaterLevel();
+ bool is_good = false;
+
// Try to find a good place a few times
- for(s32 i=0; i<1000; i++)
- {
+ for(s32 i = 0; i < 1000 && !is_good; i++) {
s32 range = 1 + i;
// We're going to try to throw the player to this position
v2s16 nodepos2d = v2s16(
continue;
nodepos = v3s16(nodepos2d.X, groundheight, nodepos2d.Y);
- bool is_good = false;
+
s32 air_count = 0;
for (s32 i = 0; i < 10; i++) {
v3s16 blockpos = getNodeBlockPos(nodepos);
}
nodepos.Y++;
}
- if(is_good){
- // Found a good place
- //infostream<<"Searched through "<<i<<" places."<<std::endl;
- break;
- }
}
-#endif
return intToFloat(nodepos, BS);
}
-PlayerSAO* Server::emergePlayer(const char *name, u16 peer_id)
+PlayerSAO* Server::emergePlayer(const char *name, u16 peer_id, u16 proto_version)
{
bool newplayer = false;
// Set player position
infostream<<"Server: Finding spawn place for player \""
<<name<<"\""<<std::endl;
- v3f pos = findSpawnPos(m_env->getServerMap());
+ v3f pos = findSpawnPos();
player->setPosition(pos);
// Make sure the player is saved
getPlayerEffectivePrivs(player->getName()),
isSingleplayer());
+ player->protocol_version = proto_version;
+
/* Clean up old HUD elements from previous sessions */
player->clearHud();
}
}
}
-
-
projects / dragonfireclient.git / blobdiff