#include "environment.h"
#include "map.h"
#include "jthread/jmutexautolock.h"
-#include "main.h"
#include "constants.h"
#include "voxel.h"
#include "config.h"
infostream<<"- game: "<<m_gamespec.path<<std::endl;
// Create world if it doesn't exist
- if(!initializeWorld(m_path_world, m_gamespec.id))
+ if(!loadGameConfAndInitWorld(m_path_world, m_gamespec))
throw ServerError("Failed to initialize world");
// Create server thread
m_script = new GameScripting(this);
- std::string scriptpath = getBuiltinLuaPath() + DIR_DELIM "init.lua";
+ std::string script_path = getBuiltinLuaPath() + DIR_DELIM "init.lua";
- if (!m_script->loadScript(scriptpath))
- throw ModError("Failed to load and run " + scriptpath);
+ if (!m_script->loadMod(script_path, BUILTIN_MOD_NAME)) {
+ throw ModError("Failed to load and run " + script_path);
+ }
- // 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++){
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)) {
+ errorstream << "Error loading mod \"" << mod.name
+ << "\": mod_name does not follow naming conventions: "
+ << "Only chararacters [a-z0-9_] are allowed." << std::endl;
+ throw ModError("Mod \"" + mod.name + "\" does not follow naming conventions.");
+ }
+ 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)) {
+ errorstream << "Server: Failed to load and run "
+ << script_path << std::endl;
+ throw ModError("Failed to load and run " + script_path);
}
}
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);
}
// 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 {
+ errorstream << "UNRECOVERABLE error occurred. Stopping server. "
+ << "Please fix the following error:" << std::endl
+ << async_err << std::endl;
+ FATAL_ERROR(async_err.c_str());
+ }
}
}
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();
}
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();
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) {
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 "
+ 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.");
+ DenyAccess_Legacy(peer_id, L"Could not allocate player.");
}
return NULL;
}
SendInventory(playersao);
// Send HP
- if(g_settings->getBool("enable_damage"))
- SendPlayerHP(peer_id);
+ SendPlayerHPOrDie(peer_id, playersao->getHP() == 0);
// Send Breath
SendPlayerBreath(peer_id);
(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);
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 "
+ DenyAccess_Legacy(peer_id, L"Your ip is banned. Banned name was "
+ narrow_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 (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;
}
}
}
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;
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");
+ 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);
+ Send(&pkt);
}
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)
{
DSTACK(__FUNCTION_NAME);
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_ACCESS_DENIED, 0, peer_id);
- *pkt << reason;
- Send(pkt);
+ NetworkPacket pkt(TOCLIENT_ACCESS_DENIED, 1, peer_id);
+ pkt << (u8) reason;
+
+ if (reason == SERVER_ACCESSDENIED_CUSTOM_STRING) {
+ pkt << custom_reason;
+ }
+ Send(&pkt);
+}
+
+void Server::SendAccessDenied_Legacy(u16 peer_id,const std::wstring &reason)
+{
+ DSTACK(__FUNCTION_NAME);
+
+ 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);
}
/*
Serialize it
*/
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_INVENTORY, 0,
- playerSAO->getPeerID());
+ NetworkPacket pkt(TOCLIENT_INVENTORY, 0, playerSAO->getPeerID());
std::ostringstream 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);
+ // 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");
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);
+ 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,
ServerPlayingSound &psound = m_playing_sounds[id];
psound.params = params;
- 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::vector<u16>::iterator i = dst_clients.begin();
i != dst_clients.end(); i++) {
psound.clients.insert(*i);
- m_clients.send(*i, 0, pkt, true, false);
+ 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++) {
// 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);
}
float maxd = far_d_nodes*BS;
v3f p_f = intToFloat(p, BS);
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_REMOVENODE, 6);
- *pkt << p;
+ NetworkPacket pkt(TOCLIENT_REMOVENODE, 6);
+ pkt << p;
std::vector<u16> clients = m_clients.getClientIDs();
for(std::vector<u16>::iterator i = clients.begin();
}
// 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,
}
}
- NetworkPacket* pkt = new NetworkPacket(TOCLIENT_ADDNODE, 6 + 2 + 1 + 1 + 1);
+ 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();
// 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);
}
}
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)
// 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 = new NetworkPacket(TOCLIENT_ANNOUNCE_MEDIA, 0, peer_id);
- *pkt << (u16) file_announcements.size();
+ NetworkPacket pkt(TOCLIENT_ANNOUNCE_MEDIA, 0, peer_id);
+ pkt << (u16) file_announcements.size();
for (std::vector<SendableMediaAnnouncement>::iterator
j = file_announcements.begin();
j != file_announcements.end(); ++j) {
- *pkt << j->name << j->sha1_digest;
+ pkt << j->name << j->sha1_digest;
}
- *pkt << g_settings->get("remote_media");
- Send(pkt);
+ pkt << g_settings->get("remote_media");
+ Send(&pkt);
}
struct SendableMedia
}
*/
- 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::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);
}
}
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::DenySudoAccess(u16 peer_id)
+{
+ DSTACK(__FUNCTION_NAME);
+
+ NetworkPacket pkt(TOCLIENT_DENY_SUDO_MODE, 0, peer_id);
+ Send(&pkt);
+}
-void Server::DenyAccess(u16 peer_id, const std::wstring &reason)
+void Server::DenyAccess(u16 peer_id, AccessDeniedCode reason, const std::string &custom_reason)
{
DSTACK(__FUNCTION_NAME);
- SendAccessDenied(peer_id, reason);
+ 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_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);
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
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();
+ for(std::vector<ModSpec>::const_iterator i = m_mods.begin();
i != m_mods.end(); i++){
const ModSpec &mod = *i;
if(mod.name == modname)
return porting::path_share + DIR_DELIM + "builtin";
}
-v3f findSpawnPos(ServerMap &map)
+v3f Server::findSpawnPos()
{
- //return v3f(50,50,50)*BS;
+ ServerMap &map = m_env->getServerMap();
+ v3f nodeposf;
+ if (g_settings->getV3FNoEx("static_spawnpoint", nodeposf)) {
+ return nodeposf * BS;
+ }
- v3s16 nodepos;
+ // 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 0
- nodepos = v2s16(0,0);
- groundheight = 20;
-#endif
-
-#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);
}
// 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
projects / dragonfireclient.git / blobdiff