diff options
| -rw-r--r-- | src/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | src/client.cpp | 18 | ||||
| -rw-r--r-- | src/clientiface.cpp | 769 | ||||
| -rw-r--r-- | src/clientiface.h | 306 | ||||
| -rw-r--r-- | src/clientmedia.cpp | 8 | ||||
| -rw-r--r-- | src/connection.cpp | 170 | ||||
| -rw-r--r-- | src/connection.h | 44 | ||||
| -rw-r--r-- | src/emerge.cpp | 15 | ||||
| -rw-r--r-- | src/server.cpp | 1732 | ||||
| -rw-r--r-- | src/server.h | 310 |
10 files changed, 1791 insertions, 1582 deletions
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index f0b98f44b..025b549cf 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -308,6 +308,7 @@ set(common_SRCS connection.cpp environment.cpp server.cpp + clientiface.cpp socket.cpp mapblock.cpp mapsector.cpp diff --git a/src/client.cpp b/src/client.cpp index 6c4d9eea8..cc1ec2a98 100644 --- a/src/client.cpp +++ b/src/client.cpp @@ -383,13 +383,6 @@ void Client::step(float dtime) // 0ms ReceiveAll(); } - - { - //TimeTaker timer("m_con_mutex + m_con.RunTimeouts()", m_device); - // 0ms - //JMutexAutoLock lock(m_con_mutex); //bulk comment-out - m_con.RunTimeouts(dtime); - } /* Packet counter @@ -758,6 +751,7 @@ void Client::step(float dtime) if (m_media_downloader && m_media_downloader->isStarted()) { m_media_downloader->step(this); if (m_media_downloader->isDone()) { + received_media(); delete m_media_downloader; m_media_downloader = NULL; } @@ -1610,11 +1604,6 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) } m_media_downloader->step(this); - if (m_media_downloader->isDone()) { - // might be done already if all media is in the cache - delete m_media_downloader; - m_media_downloader = NULL; - } } else if(command == TOCLIENT_MEDIA) { @@ -1666,11 +1655,6 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) m_media_downloader->conventionalTransferDone( name, data, this); } - - if (m_media_downloader->isDone()) { - delete m_media_downloader; - m_media_downloader = NULL; - } } else if(command == TOCLIENT_TOOLDEF) { diff --git a/src/clientiface.cpp b/src/clientiface.cpp new file mode 100644 index 000000000..2468ef333 --- /dev/null +++ b/src/clientiface.cpp @@ -0,0 +1,769 @@ +/* +Minetest +Copyright (C) 2010-2014 celeron55, Perttu Ahola <celeron55@gmail.com> + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License along +with this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#include "clientiface.h" +#include "player.h" +#include "settings.h" +#include "mapblock.h" +#include "connection.h" +#include "environment.h" +#include "map.h" +#include "emerge.h" +#include "serverobject.h" // TODO this is used for cleanup of only + +#include "util/numeric.h" + +#include "main.h" // for g_settings + +void RemoteClient::GetNextBlocks( + ServerEnvironment *env, + EmergeManager * emerge, + float dtime, + std::vector<PrioritySortedBlockTransfer> &dest) +{ + DSTACK(__FUNCTION_NAME); + + + // Increment timers + m_nothing_to_send_pause_timer -= dtime; + m_nearest_unsent_reset_timer += dtime; + + if(m_nothing_to_send_pause_timer >= 0) + return; + + Player *player = env->getPlayer(peer_id); + // This can happen sometimes; clients and players are not in perfect sync. + if(player == NULL) + return; + + // Won't send anything if already sending + if(m_blocks_sending.size() >= g_settings->getU16 + ("max_simultaneous_block_sends_per_client")) + { + //infostream<<"Not sending any blocks, Queue full."<<std::endl; + return; + } + + v3f playerpos = player->getPosition(); + v3f playerspeed = player->getSpeed(); + v3f playerspeeddir(0,0,0); + if(playerspeed.getLength() > 1.0*BS) + playerspeeddir = playerspeed / playerspeed.getLength(); + // Predict to next block + v3f playerpos_predicted = playerpos + playerspeeddir*MAP_BLOCKSIZE*BS; + + v3s16 center_nodepos = floatToInt(playerpos_predicted, BS); + + v3s16 center = getNodeBlockPos(center_nodepos); + + // Camera position and direction + v3f camera_pos = player->getEyePosition(); + v3f camera_dir = v3f(0,0,1); + camera_dir.rotateYZBy(player->getPitch()); + camera_dir.rotateXZBy(player->getYaw()); + + /*infostream<<"camera_dir=("<<camera_dir.X<<","<<camera_dir.Y<<"," + <<camera_dir.Z<<")"<<std::endl;*/ + + /* + Get the starting value of the block finder radius. + */ + + if(m_last_center != center) + { + m_nearest_unsent_d = 0; + m_last_center = center; + } + + /*infostream<<"m_nearest_unsent_reset_timer=" + <<m_nearest_unsent_reset_timer<<std::endl;*/ + + // Reset periodically to workaround for some bugs or stuff + if(m_nearest_unsent_reset_timer > 20.0) + { + m_nearest_unsent_reset_timer = 0; + m_nearest_unsent_d = 0; + //infostream<<"Resetting m_nearest_unsent_d for " + // <<server->getPlayerName(peer_id)<<std::endl; + } + + //s16 last_nearest_unsent_d = m_nearest_unsent_d; + s16 d_start = m_nearest_unsent_d; + + //infostream<<"d_start="<<d_start<<std::endl; + + u16 max_simul_sends_setting = g_settings->getU16 + ("max_simultaneous_block_sends_per_client"); + u16 max_simul_sends_usually = max_simul_sends_setting; + + /* + Check the time from last addNode/removeNode. + + Decrease send rate if player is building stuff. + */ + m_time_from_building += dtime; + if(m_time_from_building < g_settings->getFloat( + "full_block_send_enable_min_time_from_building")) + { + max_simul_sends_usually + = LIMITED_MAX_SIMULTANEOUS_BLOCK_SENDS; + } + + /* + Number of blocks sending + number of blocks selected for sending + */ + u32 num_blocks_selected = m_blocks_sending.size(); + + /* + next time d will be continued from the d from which the nearest + unsent block was found this time. + + This is because not necessarily any of the blocks found this + time are actually sent. + */ + s32 new_nearest_unsent_d = -1; + + s16 d_max = g_settings->getS16("max_block_send_distance"); + s16 d_max_gen = g_settings->getS16("max_block_generate_distance"); + + // Don't loop very much at a time + s16 max_d_increment_at_time = 2; + if(d_max > d_start + max_d_increment_at_time) + d_max = d_start + max_d_increment_at_time; + + s32 nearest_emerged_d = -1; + s32 nearest_emergefull_d = -1; + s32 nearest_sent_d = -1; + bool queue_is_full = false; + + s16 d; + for(d = d_start; d <= d_max; d++) + { + /* + Get the border/face dot coordinates of a "d-radiused" + box + */ + std::list<v3s16> list; + getFacePositions(list, d); + + std::list<v3s16>::iterator li; + for(li=list.begin(); li!=list.end(); ++li) + { + v3s16 p = *li + center; + + /* + Send throttling + - Don't allow too many simultaneous transfers + - EXCEPT when the blocks are very close + + Also, don't send blocks that are already flying. + */ + + // Start with the usual maximum + u16 max_simul_dynamic = max_simul_sends_usually; + + // If block is very close, allow full maximum + if(d <= BLOCK_SEND_DISABLE_LIMITS_MAX_D) + max_simul_dynamic = max_simul_sends_setting; + + // Don't select too many blocks for sending + if(num_blocks_selected >= max_simul_dynamic) + { + queue_is_full = true; + goto queue_full_break; + } + + // Don't send blocks that are currently being transferred + if(m_blocks_sending.find(p) != m_blocks_sending.end()) + continue; + + /* + Do not go over-limit + */ + if(p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE + || p.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE + || p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE + || p.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE + || p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE + || p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE) + continue; + + // If this is true, inexistent block will be made from scratch + bool generate = d <= d_max_gen; + + { + /*// Limit the generating area vertically to 2/3 + if(abs(p.Y - center.Y) > d_max_gen - d_max_gen / 3) + generate = false;*/ + + // Limit the send area vertically to 1/2 + if(abs(p.Y - center.Y) > d_max / 2) + continue; + } + + /* + Don't generate or send if not in sight + FIXME This only works if the client uses a small enough + FOV setting. The default of 72 degrees is fine. + */ + + float camera_fov = (72.0*M_PI/180) * 4./3.; + if(isBlockInSight(p, camera_pos, camera_dir, camera_fov, 10000*BS) == false) + { + continue; + } + + /* + Don't send already sent blocks + */ + { + if(m_blocks_sent.find(p) != m_blocks_sent.end()) + { + continue; + } + } + + /* + Check if map has this block + */ + MapBlock *block = env->getMap().getBlockNoCreateNoEx(p); + + bool surely_not_found_on_disk = false; + bool block_is_invalid = false; + if(block != NULL) + { + // Reset usage timer, this block will be of use in the future. + block->resetUsageTimer(); + + // Block is dummy if data doesn't exist. + // It means it has been not found from disk and not generated + if(block->isDummy()) + { + surely_not_found_on_disk = true; + } + + // Block is valid if lighting is up-to-date and data exists + if(block->isValid() == false) + { + block_is_invalid = true; + } + + if(block->isGenerated() == false) + block_is_invalid = true; + + /* + If block is not close, don't send it unless it is near + ground level. + + Block is near ground level if night-time mesh + differs from day-time mesh. + */ + if(d >= 4) + { + if(block->getDayNightDiff() == false) + continue; + } + } + + /* + If block has been marked to not exist on disk (dummy) + and generating new ones is not wanted, skip block. + */ + if(generate == false && surely_not_found_on_disk == true) + { + // get next one. + continue; + } + + /* + Add inexistent block to emerge queue. + */ + if(block == NULL || surely_not_found_on_disk || block_is_invalid) + { + if (emerge->enqueueBlockEmerge(peer_id, p, generate)) { + if (nearest_emerged_d == -1) + nearest_emerged_d = d; + } else { + if (nearest_emergefull_d == -1) + nearest_emergefull_d = d; + goto queue_full_break; + } + + // get next one. + continue; + } + + if(nearest_sent_d == -1) + nearest_sent_d = d; + + /* + Add block to send queue + */ + PrioritySortedBlockTransfer q((float)d, p, peer_id); + + dest.push_back(q); + + num_blocks_selected += 1; + } + } +queue_full_break: + + // If nothing was found for sending and nothing was queued for + // emerging, continue next time browsing from here + if(nearest_emerged_d != -1){ + new_nearest_unsent_d = nearest_emerged_d; + } else if(nearest_emergefull_d != -1){ + new_nearest_unsent_d = nearest_emergefull_d; + } else { + if(d > g_settings->getS16("max_block_send_distance")){ + new_nearest_unsent_d = 0; + m_nothing_to_send_pause_timer = 2.0; + } else { + if(nearest_sent_d != -1) + new_nearest_unsent_d = nearest_sent_d; + else + new_nearest_unsent_d = d; + } + } + + if(new_nearest_unsent_d != -1) + m_nearest_unsent_d = new_nearest_unsent_d; +} + +void RemoteClient::GotBlock(v3s16 p) +{ + if(m_blocks_sending.find(p) != m_blocks_sending.end()) + m_blocks_sending.erase(p); + else + { + m_excess_gotblocks++; + } + m_blocks_sent.insert(p); +} + +void RemoteClient::SentBlock(v3s16 p) +{ + if(m_blocks_sending.find(p) == m_blocks_sending.end()) + m_blocks_sending[p] = 0.0; + else + infostream<<"RemoteClient::SentBlock(): Sent block" + " already in m_blocks_sending"<<std::endl; +} + +void RemoteClient::SetBlockNotSent(v3s16 p) +{ + m_nearest_unsent_d = 0; + + if(m_blocks_sending.find(p) != m_blocks_sending.end()) + m_blocks_sending.erase(p); + if(m_blocks_sent.find(p) != m_blocks_sent.end()) + m_blocks_sent.erase(p); +} + +void RemoteClient::SetBlocksNotSent(std::map<v3s16, MapBlock*> &blocks) +{ + m_nearest_unsent_d = 0; + + for(std::map<v3s16, MapBlock*>::iterator + i = blocks.begin(); + i != blocks.end(); ++i) + { + v3s16 p = i->first; + + if(m_blocks_sending.find(p) != m_blocks_sending.end()) + m_blocks_sending.erase(p); + if(m_blocks_sent.find(p) != m_blocks_sent.end()) + m_blocks_sent.erase(p); + } +} + +void RemoteClient::notifyEvent(ClientStateEvent event) +{ + switch (m_state) + { + case Invalid: + assert("State update for client in invalid state" != 0); + break; + + case Created: + switch(event) + { + case Init: + m_state = InitSent; + break; + + case Disconnect: + m_state = Disconnecting; + break; + + case SetDenied: + m_state = Denied; + break; + + /* GotInit2 SetDefinitionsSent SetMediaSent */ + default: + assert("Invalid client state transition!" == 0); + } + break; + + case Denied: + /* don't do anything if in denied state */ + break; + + case InitSent: + switch(event) + { + case GotInit2: + confirmSerializationVersion(); + m_state = InitDone; + break; + + case Disconnect: + m_state = Disconnecting; + break; + + case SetDenied: + m_state = Denied; + break; + + /* Init SetDefinitionsSent SetMediaSent */ + default: + assert("Invalid client state transition!" == 0); + } + break; + + case InitDone: + switch(event) + { + case SetDefinitionsSent: + m_state = DefinitionsSent; + break; + + case Disconnect: + m_state = Disconnecting; + break; + + case SetDenied: + m_state = Denied; + break; + + /* Init GotInit2 SetMediaSent */ + default: + assert("Invalid client state transition!" == 0); + } + break; + + case DefinitionsSent: + switch(event) + { + case SetMediaSent: + m_state = Active; + break; + + case Disconnect: + m_state = Disconnecting; + break; + + case SetDenied: + m_state = Denied; + break; + + /* Init GotInit2 SetDefinitionsSent */ + default: + assert("Invalid client state transition!" == 0); + } + break; + + case Active: + switch(event) + { + case SetDenied: + m_state = Denied; + break; + + case Disconnect: + m_state = Disconnecting; + break; + + /* Init GotInit2 SetDefinitionsSent SetMediaSent SetDenied */ + default: + assert("Invalid client state transition!" == 0); + break; + } + break; + + case Disconnecting: + /* we are already disconnecting */ + break; + } +} + +ClientInterface::ClientInterface(con::Connection* con) +: + m_con(con), + m_env(NULL), + m_print_info_timer(0.0) +{ + +} +ClientInterface::~ClientInterface() +{ + /* + Delete clients + */ + { + JMutexAutoLock clientslock(m_clients_mutex); + + for(std::map<u16, RemoteClient*>::iterator + i = m_clients.begin(); + i != m_clients.end(); ++i) + { + + // Delete client + delete i->second; + } + } +} + +std::list<u16> ClientInterface::getClientIDs(ClientState min_state) +{ + std::list<u16> reply; + JMutexAutoLock clientslock(m_clients_mutex); + + for(std::map<u16, RemoteClient*>::iterator + i = m_clients.begin(); + i != m_clients.end(); ++i) + { + if (i->second->getState() >= min_state) + reply.push_back(i->second->peer_id); + } + + return reply; +} + +std::vector<std::string> ClientInterface::getPlayerNames() +{ + return m_clients_names; +} + + +void ClientInterface::step(float dtime) +{ + m_print_info_timer += dtime; + if(m_print_info_timer >= 30.0) + { + m_print_info_timer = 0.0; + UpdatePlayerList(); + } +} + +void ClientInterface::UpdatePlayerList() +{ + if (m_env != NULL) + { + std::list<u16> clients = getClientIDs(); + m_clients_names.clear(); + + + if(clients.size() != 0) + infostream<<"Players:"<<std::endl; + for(std::list<u16>::iterator + i = clients.begin(); + i != clients.end(); ++i) + { + Player *player = m_env->getPlayer(*i); + if(player==NULL) + continue; + infostream<<"* "<<player->getName()<<"\t"; + + { + JMutexAutoLock clientslock(m_clients_mutex); + RemoteClient* client = lockedGetClientNoEx(*i); + if(client != NULL) + client->PrintInfo(infostream); + } + m_clients_names.push_back(player->getName()); + } + } +} + +void ClientInterface::send(u16 peer_id,u8 channelnum, + SharedBuffer<u8> data, bool reliable) +{ + m_con->Send(peer_id, channelnum, data, reliable); +} + +void ClientInterface::sendToAll(u16 channelnum, + SharedBuffer<u8> data, bool reliable) +{ + JMutexAutoLock clientslock(m_clients_mutex); + for(std::map<u16, RemoteClient*>::iterator + i = m_clients.begin(); + i != m_clients.end(); ++i) + { + RemoteClient *client = i->second; + + if (client->net_proto_version != 0) + { + m_con->Send(client->peer_id, channelnum, data, reliable); + } + } +} + +RemoteClient* ClientInterface::getClientNoEx(u16 peer_id, ClientState state_min) +{ + JMutexAutoLock clientslock(m_clients_mutex); + std::map<u16, RemoteClient*>::iterator n; + n = m_clients.find(peer_id); + // The client may not exist; clients are immediately removed if their + // access is denied, and this event occurs later then. + if(n == m_clients.end()) + return NULL; + + if (n->second->getState() >= state_min) + return n->second; + else + return NULL; +} + +RemoteClient* ClientInterface::lockedGetClientNoEx(u16 peer_id, ClientState state_min) +{ + std::map<u16, RemoteClient*>::iterator n; + n = m_clients.find(peer_id); + // The client may not exist; clients are immediately removed if their + // access is denied, and this event occurs later then. + if(n == m_clients.end()) + return NULL; + + if (n->second->getState() >= state_min) + return n->second; + else + return NULL; +} + +ClientState ClientInterface::getClientState(u16 peer_id) +{ + JMutexAutoLock clientslock(m_clients_mutex); + std::map<u16, RemoteClient*>::iterator n; + n = m_clients.find(peer_id); + // The client may not exist; clients are immediately removed if their + // access is denied, and this event occurs later then. + if(n == m_clients.end()) + return Invalid; + + return n->second->getState(); +} + +void ClientInterface::setPlayerName(u16 peer_id,std::string name) +{ + JMutexAutoLock clientslock(m_clients_mutex); + std::map<u16, RemoteClient*>::iterator n; + n = m_clients.find(peer_id); + // The client may not exist; clients are immediately removed if their + // access is denied, and this event occurs later then. + if(n != m_clients.end()) + n->second->setName(name); +} + +void ClientInterface::DeleteClient(u16 peer_id) +{ + JMutexAutoLock conlock(m_clients_mutex); + + // Error check + std::map<u16, RemoteClient*>::iterator n; + n = m_clients.find(peer_id); + // The client may not exist; clients are immediately removed if their + // access is denied, and this event occurs later then. + if(n == m_clients.end()) + return; + + /* + Mark objects to be not known by the client + */ + //TODO this should be done by client destructor!!! + RemoteClient *client = n->second; + // Handle objects + for(std::set<u16>::iterator + i = client->m_known_objects.begin(); + i != client->m_known_objects.end(); ++i) + { + // Get object + u16 id = *i; + ServerActiveObject* obj = m_env->getActiveObject(id); + + if(obj && obj->m_known_by_count > 0) + obj->m_known_by_count--; + } + + // Delete client + delete m_clients[peer_id]; + m_clients.erase(peer_id); +} + +void ClientInterface::CreateClient(u16 peer_id) +{ + JMutexAutoLock conlock(m_clients_mutex); + + // Error check + std::map<u16, RemoteClient*>::iterator n; + n = m_clients.find(peer_id); + // The client shouldn't already exist + if(n != m_clients.end()) return; + + // Create client + RemoteClient *client = new RemoteClient(); + client->peer_id = peer_id; + m_clients[client->peer_id] = client; +} + +void ClientInterface::event(u16 peer_id, ClientStateEvent event) +{ + { + JMutexAutoLock clientlock(m_clients_mutex); + + // Error check + std::map<u16, RemoteClient*>::iterator n; + n = m_clients.find(peer_id); + + // No client to deliver event + if (n == m_clients.end()) + return; + n->second->notifyEvent(event); + } + + if ((event == SetMediaSent) || (event == Disconnect) || (event == SetDenied)) + { + UpdatePlayerList(); + } +} + +u16 ClientInterface::getProtocolVersion(u16 peer_id) +{ + JMutexAutoLock conlock(m_clients_mutex); + + // Error check + std::map<u16, RemoteClient*>::iterator n; + n = m_clients.find(peer_id); + + // No client to deliver event + if (n == m_clients.end()) + return 0; + + return n->second->net_proto_version; +} diff --git a/src/clientiface.h b/src/clientiface.h new file mode 100644 index 000000000..a2315b3bd --- /dev/null +++ b/src/clientiface.h @@ -0,0 +1,306 @@ +/* +Minetest +Copyright (C) 2010-2014 celeron55, Perttu Ahola <celeron55@gmail.com> + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License along +with this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ +#ifndef _CLIENTIFACE_H_ +#define _CLIENTIFACE_H_ + +#include "irr_v3d.h" // for irrlicht datatypes + +#include "constants.h" +#include "serialization.h" // for SER_FMT_VER_INVALID +#include "jthread/jmutex.h" + +#include <list> +#include <vector> +#include <map> +#include <set> + +class MapBlock; +class ServerEnvironment; +class EmergeManager; + +namespace con { + class Connection; +} + +enum ClientState +{ + Invalid, + Disconnecting, + Denied, + Created, + InitSent, + InitDone, + DefinitionsSent, + Active +}; + +enum ClientStateEvent +{ + Init, + GotInit2, + SetDenied, + SetDefinitionsSent, + SetMediaSent, + Disconnect +}; + +/* + Used for queueing and sorting block transfers in containers + + Lower priority number means higher priority. +*/ +struct PrioritySortedBlockTransfer +{ + PrioritySortedBlockTransfer(float a_priority, v3s16 a_pos, u16 a_peer_id) + { + priority = a_priority; + pos = a_pos; + peer_id = a_peer_id; + } + bool operator < (const PrioritySortedBlockTransfer &other) const + { + return priority < other.priority; + } + float priority; + v3s16 pos; + u16 peer_id; +}; + +class RemoteClient +{ +public: + // peer_id=0 means this client has no associated peer + // NOTE: If client is made allowed to exist while peer doesn't, + // this has to be set to 0 when there is no peer. + // Also, the client must be moved to some other container. + u16 peer_id; + // The serialization version to use with the client + u8 serialization_version; + // + u16 net_proto_version; + + RemoteClient(): + peer_id(PEER_ID_INEXISTENT), + serialization_version(SER_FMT_VER_INVALID), + net_proto_version(0), + m_time_from_building(9999), + m_pending_serialization_version(SER_FMT_VER_INVALID), + m_state(Created), + m_nearest_unsent_d(0), + m_nearest_unsent_reset_timer(0.0), + m_excess_gotblocks(0), + m_nothing_to_send_counter(0), + m_nothing_to_send_pause_timer(0.0), + m_name("") + { + } + ~RemoteClient() + { + } + + /* + Finds block that should be sent next to the client. + Environment should be locked when this is called. + dtime is used for resetting send radius at slow interval + */ + void GetNextBlocks(ServerEnvironment *env, EmergeManager* emerge, + float dtime, std::vector<PrioritySortedBlockTransfer> &dest); + + void GotBlock(v3s16 p); + + void SentBlock(v3s16 p); + + void SetBlockNotSent(v3s16 p); + void SetBlocksNotSent(std::map<v3s16, MapBlock*> &blocks); + + s32 SendingCount() + { + return m_blocks_sending.size(); + } + + // Increments timeouts and removes timed-out blocks from list + // NOTE: This doesn't fix the server-not-sending-block bug + // because it is related to emerging, not sending. + //void RunSendingTimeouts(float dtime, float timeout); + + void PrintInfo(std::ostream &o) + { + o<<"RemoteClient "<<peer_id<<": " + <<"m_blocks_sent.size()="<<m_blocks_sent.size() + <<", m_blocks_sending.size()="<<m_blocks_sending.size() + <<", m_nearest_unsent_d="<<m_nearest_unsent_d + <<", m_excess_gotblocks="<<m_excess_gotblocks + <<std::endl; + m_excess_gotblocks = 0; + } + + // Time from last placing or removing blocks + float m_time_from_building; + + /* + List of active objects that the client knows of. + Value is dummy. + */ + std::set<u16> m_known_objects; + + ClientState getState() + { return m_state; } + + std::string getName() + { return m_name; } + + void setName(std::string name) + { m_name = name; } + + /* update internal client state */ + void notifyEvent(ClientStateEvent event); + + /* set expected serialization version */ + void setPendingSerializationVersion(u8 version) + { m_pending_serialization_version = version; } + + void confirmSerializationVersion() + { serialization_version = m_pending_serialization_version; } + +private: + // Version is stored in here after INIT before INIT2 + u8 m_pending_serialization_version; + + /* current state of client */ + ClientState m_state; + + /* + Blocks that have been sent to client. + - These don't have to be sent again. + - A block is cleared from here when client says it has + deleted it from it's memory + + Key is position, value is dummy. + No MapBlock* is stored here because the blocks can get deleted. + */ + std::set<v3s16> m_blocks_sent; + s16 m_nearest_unsent_d; + v3s16 m_last_center; + float m_nearest_unsent_reset_timer; + + /* + Blocks that are currently on the line. + This is used for throttling the sending of blocks. + - The size of this list is limited to some value + Block is added when it is sent with BLOCKDATA. + Block is removed when GOTBLOCKS is received. + Value is time from sending. (not used at the moment) + */ + std::map<v3s16, float> m_blocks_sending; + + /* + Count of excess GotBlocks(). + There is an excess amount because the client sometimes + gets a block so late that the server sends it again, + and the client then sends two GOTBLOCKs. + This is resetted by PrintInfo() + */ + u32 m_excess_gotblocks; + + // CPU usage optimization + u32 m_nothing_to_send_counter; + float m_nothing_to_send_pause_timer; + std::string m_name; +}; + +class ClientInterface { +public: + + friend class Server; + + ClientInterface(con::Connection* con); + ~ClientInterface(); + + /* run sync step */ + void step(float dtime); + + /* get list of active client id's */ + std::list<u16> getClientIDs(ClientState min_state=Active); + + /* get list of client player names */ + std::vector<std::string> getPlayerNames(); + + /* send message to client */ + void send(u16 peer_id, u8 channelnum, SharedBuffer<u8> data, bool reliable); + + /* send to all clients */ + void sendToAll(u16 channelnum, SharedBuffer<u8> data, bool reliable); + + /* delete a client */ + void DeleteClient(u16 peer_id); + + /* create client */ + void CreateClient(u16 peer_id); + + /* get a client by peer_id */ + RemoteClient* getClientNoEx(u16 peer_id, ClientState state_min=Active); + + /* get client by peer_id (make sure you have list lock before!*/ + RemoteClient* lockedGetClientNoEx(u16 peer_id, ClientState state_min=Active); + + /* get state of client by id*/ + ClientState getClientState(u16 peer_id); + + /* set client playername */ + void setPlayerName(u16 peer_id,std::string name); + + /* get protocol version of client */ + u16 getProtocolVersion(u16 peer_id); + + /* event to update client state */ + void event(u16 peer_id, ClientStateEvent event); + + /* set environment */ + void setEnv(ServerEnvironment* env) + { assert(m_env == 0); m_env = env; } + +protected: + //TODO find way to avoid this functions + void Lock() + { m_clients_mutex.Lock(); } + void Unlock() + { m_clients_mutex.Unlock(); } + + std::map<u16, RemoteClient*>& getClientList() + { return m_clients; } + +private: + /* update internal player list */ + void UpdatePlayerList(); + + // Connection + con::Connection* m_con; + JMutex m_clients_mutex; + // Connected clients (behind the con mutex) + std::map<u16, RemoteClient*> m_clients; + std::vector<std::string> m_clients_names; //for announcing masterserver + + // Environment + ServerEnvironment *m_env; + JMutex m_env_mutex; + + float m_print_info_timer; +}; + +#endif diff --git a/src/clientmedia.cpp b/src/clientmedia.cpp index 8260d5f5a..dcae44023 100644 --- a/src/clientmedia.cpp +++ b/src/clientmedia.cpp @@ -480,13 +480,7 @@ void ClientMediaDownloader::startConventionalTransfers(Client *client) { assert(m_httpfetch_active == 0); - if (m_uncached_received_count == m_uncached_count) { - // In this case all media was found in the cache or - // has been downloaded from some remote server; - // report this fact to the server - client->received_media(); - } - else { + if (m_uncached_received_count != m_uncached_count) { // Some media files have not been received yet, use the // conventional slow method (minetest protocol) to get them std::list<std::string> file_requests; diff --git a/src/connection.cpp b/src/connection.cpp index 2e126a770..92f9f8ec2 100644 --- a/src/connection.cpp +++ b/src/connection.cpp @@ -34,6 +34,14 @@ with this program; if not, write to the Free Software Foundation, Inc., namespace con { +/******************************************************************************/ +/* defines used for debugging and profiling */ +/******************************************************************************/ +#ifdef NDEBUG +#define LOG(a) a +#define PROFILE(a) +#undef DEBUG_CONNECTION_KBPS +#else /* this mutex is used to achieve log message consistency */ JMutex log_message_mutex; #define LOG(a) \ @@ -41,15 +49,10 @@ JMutex log_message_mutex; JMutexAutoLock loglock(log_message_mutex); \ a; \ } - -/******************************************************************************/ -/* defines used for debugging and profiling */ -/******************************************************************************/ #define PROFILE(a) a -//#define PROFILE(a) - //#define DEBUG_CONNECTION_KBPS #undef DEBUG_CONNECTION_KBPS +#endif static inline float CALC_DTIME(unsigned int lasttime, unsigned int curtime) { @@ -960,15 +963,12 @@ void Peer::Drop() UDPPeer::UDPPeer(u16 a_id, Address a_address, Connection* connection) : Peer(a_address,a_id,connection), + m_pending_disconnect(false), resend_timeout(0.5), m_legacy_peer(true) { } -UDPPeer::~UDPPeer() -{ -} - bool UDPPeer::getAddress(MTProtocols type,Address& toset) { if ((type == UDP) || (type == MINETEST_RELIABLE_UDP) || (type == PRIMARY)) @@ -980,6 +980,15 @@ bool UDPPeer::getAddress(MTProtocols type,Address& toset) return false; } +void UDPPeer::setNonLegacyPeer() +{ + m_legacy_peer = false; + for(unsigned int i=0; i< CHANNEL_COUNT; i++) + { + channels->setWindowSize(g_settings->getU16("max_packets_per_iteration")); + } +} + void UDPPeer::reportRTT(float rtt) { if (rtt < 0.0) { @@ -1014,6 +1023,9 @@ bool UDPPeer::Ping(float dtime,SharedBuffer<u8>& data) void UDPPeer::PutReliableSendCommand(ConnectionCommand &c, unsigned int max_packet_size) { + if (m_pending_disconnect) + return; + if ( channels[c.channelnum].queued_commands.empty() && /* don't queue more packets then window size */ (channels[c.channelnum].queued_reliables.size() @@ -1040,6 +1052,9 @@ bool UDPPeer::processReliableSendCommand( ConnectionCommand &c, unsigned int max_packet_size) { + if (m_pending_disconnect) + return true; + u32 chunksize_max = max_packet_size - BASE_HEADER_SIZE - RELIABLE_HEADER_SIZE; @@ -1564,7 +1579,6 @@ void ConnectionSendThread::processReliableCommand(ConnectionCommand &c) case CONNCMD_SERVE: case CONNCMD_CONNECT: case CONNCMD_DISCONNECT: - case CONNCMD_DELETE_PEER: case CONCMD_ACK: assert("Got command that shouldn't be reliable as reliable command" == 0); default: @@ -1606,10 +1620,6 @@ void ConnectionSendThread::processNonReliableCommand(ConnectionCommand &c) LOG(dout_con<<m_connection->getDesc()<<" UDP processing CONNCMD_SEND_TO_ALL"<<std::endl); sendToAll(c.channelnum, c.data); return; - case CONNCMD_DELETE_PEER: - LOG(dout_con<<m_connection->getDesc()<<" UDP processing CONNCMD_DELETE_PEER"<<std::endl); - m_connection->deletePeer(c.peer_id, false); - return; case CONCMD_ACK: LOG(dout_con<<m_connection->getDesc()<<" UDP processing CONCMD_ACK"<<std::endl); sendAsPacket(c.peer_id,c.channelnum,c.data,true); @@ -1686,6 +1696,18 @@ void ConnectionSendThread::disconnect_peer(u16 peer_id) writeU8(&data[0], TYPE_CONTROL); writeU8(&data[1], CONTROLTYPE_DISCO); sendAsPacket(peer_id, 0,data,false); + + PeerHelper peer = m_connection->getPeerNoEx(peer_id); + + if (!peer) + return; + + if (dynamic_cast<UDPPeer*>(&peer) == 0) + { + return; + } + + dynamic_cast<UDPPeer*>(&peer)->m_pending_disconnect = true; } void ConnectionSendThread::send(u16 peer_id, u8 channelnum, @@ -1764,6 +1786,8 @@ void ConnectionSendThread::sendToAllReliable(ConnectionCommand &c) void ConnectionSendThread::sendPackets(float dtime) { std::list<u16> peerIds = m_connection->getPeerIDs(); + std::list<u16> pendingDisconnect; + std::map<u16,bool> pending_unreliable; for(std::list<u16>::iterator j = peerIds.begin(); @@ -1782,6 +1806,11 @@ void ConnectionSendThread::sendPackets(float dtime) continue; } + if (dynamic_cast<UDPPeer*>(&peer)->m_pending_disconnect) + { + pendingDisconnect.push_back(*j); + } + PROFILE(std::stringstream peerIdentifier); PROFILE(peerIdentifier << "sendPackets[" << m_connection->getDesc() << ";" << *j << ";RELIABLE]"); PROFILE(ScopeProfiler peerprofiler(g_profiler, peerIdentifier.str(), SPT_AVG)); @@ -1877,6 +1906,17 @@ void ConnectionSendThread::sendPackets(float dtime) } else { m_outgoing_queue.push_back(packet); + pending_unreliable[packet.peer_id] = true; + } + } + + for(std::list<u16>::iterator + k = pendingDisconnect.begin(); + k != pendingDisconnect.end(); ++k) + { + if (!pending_unreliable[*k]) + { + m_connection->deletePeer(*k,false); } } } @@ -1986,11 +2026,10 @@ void * ConnectionReceiveThread::Thread() // Receive packets from the network and buffers and create ConnectionEvents void ConnectionReceiveThread::receive() { - /* now reorder reliables */ - u32 datasize = m_max_packet_size * 2; // Double it just to be safe - // TODO: We can not know how many layers of header there are. - // For now, just assume there are no other than the base headers. - u32 packet_maxsize = datasize + BASE_HEADER_SIZE; + // use IPv6 minimum allowed MTU as receive buffer size as this is + // theoretical reliable upper boundary of a udp packet for all IPv6 enabled + // infrastructure + unsigned int packet_maxsize = 1500; SharedBuffer<u8> packetdata(packet_maxsize); bool packet_queued = true; @@ -2126,7 +2165,7 @@ void ConnectionReceiveThread::receive() LOG(dout_con<<m_connection->getDesc() <<" ProcessPacket from peer_id: " << peer_id - << ",channel: " << channelnum << ", returned " + << ",channel: " << (channelnum & 0xFF) << ", returned " << resultdata.getSize() << " bytes" <<std::endl); ConnectionEvent e; @@ -2262,6 +2301,10 @@ SharedBuffer<u8> ConnectionReceiveThread::processPacket(Channel *channel, } //put bytes for max bandwidth calculation channel->UpdateBytesSent(p.data.getSize(),1); + if (channel->outgoing_reliables_sent.size() == 0) + { + m_connection->TriggerSend(); + } } catch(NotFoundException &e){ LOG(derr_con<<m_connection->getDesc() @@ -2534,7 +2577,8 @@ Connection::Connection(u32 protocol_id, u32 max_packet_size, float timeout, m_info_mutex(), m_bc_peerhandler(0), m_bc_receive_timeout(0), - m_shutting_down(false) + m_shutting_down(false), + m_next_remote_peer_id(2) { m_udpSocket.setTimeoutMs(5); @@ -2554,7 +2598,8 @@ Connection::Connection(u32 protocol_id, u32 max_packet_size, float timeout, m_info_mutex(), m_bc_peerhandler(peerhandler), m_bc_receive_timeout(0), - m_shutting_down(false) + m_shutting_down(false), + m_next_remote_peer_id(2) { m_udpSocket.setTimeoutMs(5); @@ -2810,11 +2855,6 @@ void Connection::Send(u16 peer_id, u8 channelnum, putCommand(c); } -void Connection::RunTimeouts(float dtime) -{ - // No-op -} - Address Connection::GetPeerAddress(u16 peer_id) { PeerHelper peer = getPeerNoEx(peer_id); @@ -2838,46 +2878,43 @@ u16 Connection::createPeer(Address& sender, MTProtocols protocol, int fd) // Somebody wants to make a new connection // Get a unique peer id (2 or higher) - u16 peer_id_new = 2; + u16 peer_id_new = m_next_remote_peer_id; u16 overflow = MAX_UDP_PEERS; /* Find an unused peer id */ - bool out_of_ids = false; - for(;;) { - // Check if exists - if(m_peers.find(peer_id_new) == m_peers.end()) - break; - // Check for overflow - if(peer_id_new == overflow){ - out_of_ids = true; - break; + JMutexAutoLock lock(m_peers_mutex); + bool out_of_ids = false; + for(;;) + { + // Check if exists + if(m_peers.find(peer_id_new) == m_peers.end()) + break; + // Check for overflow + if(peer_id_new == overflow){ + out_of_ids = true; + break; + } + peer_id_new++; + } + if(out_of_ids){ + errorstream<<getDesc()<<" ran out of peer ids"<<std::endl; + return PEER_ID_INEXISTENT; } - peer_id_new++; - } - if(out_of_ids){ - errorstream<<getDesc()<<" ran out of peer ids"<<std::endl; - return PEER_ID_INEXISTENT; - } - - LOG(dout_con<<getDesc() - <<"createPeer(): giving peer_id="<<peer_id_new<<std::endl); - // Create a peer - Peer *peer = 0; + // Create a peer + Peer *peer = 0; + peer = new UDPPeer(peer_id_new, sender, this); - peer = new UDPPeer(peer_id_new, sender, this); + m_peers[peer->id] = peer; + } - m_peers_mutex.Lock(); - m_peers[peer->id] = peer; - m_peers_mutex.Unlock(); + m_next_remote_peer_id = (peer_id_new +1) % MAX_UDP_PEERS; - // Create peer addition event - ConnectionEvent e; - e.peerAdded(peer_id_new, sender); - putEvent(e); + LOG(dout_con<<getDesc() + <<"createPeer(): giving peer_id="<<peer_id_new<<std::endl); ConnectionCommand cmd; SharedBuffer<u8> reply(4); @@ -2887,17 +2924,15 @@ u16 Connection::createPeer(Address& sender, MTProtocols protocol, int fd) cmd.createPeer(peer_id_new,reply); this->putCommand(cmd); + // Create peer addition event + ConnectionEvent e; + e.peerAdded(peer_id_new, sender); + putEvent(e); + // We're now talking to a valid peer_id return peer_id_new; } -void Connection::DeletePeer(u16 peer_id) -{ - ConnectionCommand c; - c.deletePeer(peer_id); - putCommand(c); -} - void Connection::PrintInfo(std::ostream &out) { m_info_mutex.Lock(); @@ -2915,6 +2950,13 @@ const std::string Connection::getDesc() return std::string("con(")+itos(m_udpSocket.GetHandle())+"/"+itos(m_peer_id)+")"; } +void Connection::DisconnectPeer(u16 peer_id) +{ + ConnectionCommand discon; + discon.disconnect_peer(peer_id); + putCommand(discon); +} + void Connection::sendAck(u16 peer_id, u8 channelnum, u16 seqnum) { assert(channelnum < CHANNEL_COUNT); diff --git a/src/connection.h b/src/connection.h index e43d93fb3..c9474032d 100644 --- a/src/connection.h +++ b/src/connection.h @@ -71,14 +71,6 @@ public: {} }; -/*class ThrottlingException : public BaseException -{ -public: - ThrottlingException(const char *s): - BaseException(s) - {} -};*/ - class InvalidIncomingDataException : public BaseException { public: @@ -406,7 +398,6 @@ enum ConnectionCommandType{ CONNCMD_DISCONNECT_PEER, CONNCMD_SEND, CONNCMD_SEND_TO_ALL, - CONNCMD_DELETE_PEER, CONCMD_ACK, CONCMD_CREATE_PEER, CONCMD_DISABLE_LEGACY @@ -460,11 +451,6 @@ struct ConnectionCommand data = data_; reliable = reliable_; } - void deletePeer(u16 peer_id_) - { - type = CONNCMD_DELETE_PEER; - peer_id = peer_id_; - } void ack(u16 peer_id_, u8 channelnum_, SharedBuffer<u8> data_) { @@ -580,16 +566,29 @@ private: class Peer; +enum PeerChangeType +{ + PEER_ADDED, + PEER_REMOVED +}; +struct PeerChange +{ + PeerChangeType type; + u16 peer_id; + bool timeout; +}; + class PeerHandler { public: + PeerHandler() { } virtual ~PeerHandler() { } - + /* This is called after the Peer has been inserted into the Connection's peer container. @@ -771,7 +770,7 @@ public: friend class ConnectionSendThread; UDPPeer(u16 a_id, Address a_address, Connection* connection); - virtual ~UDPPeer(); + virtual ~UDPPeer() {}; void PutReliableSendCommand(ConnectionCommand &c, unsigned int max_packet_size); @@ -781,8 +780,7 @@ public: bool getAddress(MTProtocols type, Address& toset); - void setNonLegacyPeer() - { m_legacy_peer = false; } + void setNonLegacyPeer(); bool getLegacyPeer() { return m_legacy_peer; } @@ -793,6 +791,8 @@ public: SharedBuffer<u8> addSpiltPacket(u8 channel, BufferedPacket toadd, bool reliable); + + protected: /* Calculates avg_rtt and resend_timeout. @@ -813,6 +813,7 @@ protected: bool Ping(float dtime,SharedBuffer<u8>& data); Channel channels[CHANNEL_COUNT]; + bool m_pending_disconnect; private: // This is changed dynamically float resend_timeout; @@ -1002,13 +1003,12 @@ public: u32 Receive(u16 &peer_id, SharedBuffer<u8> &data); void SendToAll(u8 channelnum, SharedBuffer<u8> data, bool reliable); void Send(u16 peer_id, u8 channelnum, SharedBuffer<u8> data, bool reliable); - void RunTimeouts(float dtime); // dummy u16 GetPeerID(){ return m_peer_id; } Address GetPeerAddress(u16 peer_id); float GetPeerAvgRTT(u16 peer_id); - void DeletePeer(u16 peer_id); const u32 GetProtocolID() const { return m_protocol_id; }; const std::string getDesc(); + void DisconnectPeer(u16 peer_id); protected: PeerHelper getPeer(u16 peer_id); @@ -1033,6 +1033,8 @@ protected: void putEvent(ConnectionEvent &e); + void TriggerSend() + { m_sendThread.Trigger(); } private: std::list<Peer*> getPeers(); @@ -1054,6 +1056,8 @@ private: int m_bc_receive_timeout; bool m_shutting_down; + + u16 m_next_remote_peer_id; }; } // namespace diff --git a/src/emerge.cpp b/src/emerge.cpp index bd9b7c7bd..f63bc5dfe 100644 --- a/src/emerge.cpp +++ b/src/emerge.cpp @@ -592,23 +592,12 @@ void *EmergeThread::Thread() { /* Set sent status of modified blocks on clients */ - - // NOTE: Server's clients are also behind the connection mutex - //conlock: consistently takes 30-40ms to acquire - JMutexAutoLock lock(m_server->m_con_mutex); // Add the originally fetched block to the modified list if (block) modified_blocks[p] = block; - // Set the modified blocks unsent for all the clients - for (std::map<u16, RemoteClient*>::iterator - i = m_server->m_clients.begin(); - i != m_server->m_clients.end(); ++i) { - RemoteClient *client = i->second; - if (modified_blocks.size() > 0) { - // Remove block from sent history - client->SetBlocksNotSent(modified_blocks); - } + if (modified_blocks.size() > 0) { + m_server->SetBlocksNotSent(modified_blocks); } } catch (VersionMismatchException &e) { diff --git a/src/server.cpp b/src/server.cpp index 9fb0455eb..ce0b44110 100644 --- a/src/server.cpp +++ b/src/server.cpp @@ -104,13 +104,10 @@ void * ServerThread::Thread() try{ //TimeTaker timer("AsyncRunStep() + Receive()"); - { - //TimeTaker timer("AsyncRunStep()"); - m_server->AsyncRunStep(); - } + m_server->AsyncRunStep(); - //infostream<<"Running m_server->Receive()"<<std::endl; m_server->Receive(); + } catch(con::NoIncomingDataException &e) { @@ -158,481 +155,7 @@ v3f ServerSoundParams::getPos(ServerEnvironment *env, bool *pos_exists) const return v3f(0,0,0); } -void RemoteClient::GetNextBlocks(Server *server, float dtime, - std::vector<PrioritySortedBlockTransfer> &dest) -{ - DSTACK(__FUNCTION_NAME); - - /*u32 timer_result; - TimeTaker timer("RemoteClient::GetNextBlocks", &timer_result);*/ - - // Increment timers - m_nothing_to_send_pause_timer -= dtime; - m_nearest_unsent_reset_timer += dtime; - - if(m_nothing_to_send_pause_timer >= 0) - return; - - Player *player = server->m_env->getPlayer(peer_id); - // This can happen sometimes; clients and players are not in perfect sync. - if(player == NULL) - return; - - // Won't send anything if already sending - if(m_blocks_sending.size() >= g_settings->getU16 - ("max_simultaneous_block_sends_per_client")) - { - //infostream<<"Not sending any blocks, Queue full."<<std::endl; - return; - } - - //TimeTaker timer("RemoteClient::GetNextBlocks"); - - v3f playerpos = player->getPosition(); - v3f playerspeed = player->getSpeed(); - v3f playerspeeddir(0,0,0); - if(playerspeed.getLength() > 1.0*BS) - playerspeeddir = playerspeed / playerspeed.getLength(); - // Predict to next block - v3f playerpos_predicted = playerpos + playerspeeddir*MAP_BLOCKSIZE*BS; - - v3s16 center_nodepos = floatToInt(playerpos_predicted, BS); - - v3s16 center = getNodeBlockPos(center_nodepos); - - // Camera position and direction - v3f camera_pos = player->getEyePosition(); - v3f camera_dir = v3f(0,0,1); - camera_dir.rotateYZBy(player->getPitch()); - camera_dir.rotateXZBy(player->getYaw()); - - /*infostream<<"camera_dir=("<<camera_dir.X<<","<<camera_dir.Y<<"," - <<camera_dir.Z<<")"<<std::endl;*/ - /* - Get the starting value of the block finder radius. - */ - - if(m_last_center != center) - { - m_nearest_unsent_d = 0; - m_last_center = center; - } - - /*infostream<<"m_nearest_unsent_reset_timer=" - <<m_nearest_unsent_reset_timer<<std::endl;*/ - - // Reset periodically to workaround for some bugs or stuff - if(m_nearest_unsent_reset_timer > 20.0) - { - m_nearest_unsent_reset_timer = 0; - m_nearest_unsent_d = 0; - //infostream<<"Resetting m_nearest_unsent_d for " - // <<server->getPlayerName(peer_id)<<std::endl; - } - - //s16 last_nearest_unsent_d = m_nearest_unsent_d; - s16 d_start = m_nearest_unsent_d; - - //infostream<<"d_start="<<d_start<<std::endl; - - u16 max_simul_sends_setting = g_settings->getU16 - ("max_simultaneous_block_sends_per_client"); - u16 max_simul_sends_usually = max_simul_sends_setting; - - /* - Check the time from last addNode/removeNode. - - Decrease send rate if player is building stuff. - */ - m_time_from_building += dtime; - if(m_time_from_building < g_settings->getFloat( - "full_block_send_enable_min_time_from_building")) - { - max_simul_sends_usually - = LIMITED_MAX_SIMULTANEOUS_BLOCK_SENDS; - } - - /* - Number of blocks sending + number of blocks selected for sending - */ - u32 num_blocks_selected = m_blocks_sending.size(); - - /* - next time d will be continued from the d from which the nearest - unsent block was found this time. - - This is because not necessarily any of the blocks found this - time are actually sent. - */ - s32 new_nearest_unsent_d = -1; - - s16 d_max = g_settings->getS16("max_block_send_distance"); - s16 d_max_gen = g_settings->getS16("max_block_generate_distance"); - - // Don't loop very much at a time - s16 max_d_increment_at_time = 2; - if(d_max > d_start + max_d_increment_at_time) - d_max = d_start + max_d_increment_at_time; - /*if(d_max_gen > d_start+2) - d_max_gen = d_start+2;*/ - - //infostream<<"Starting from "<<d_start<<std::endl; - - s32 nearest_emerged_d = -1; - s32 nearest_emergefull_d = -1; - s32 nearest_sent_d = -1; - bool queue_is_full = false; - - s16 d; - for(d = d_start; d <= d_max; d++) - { - /*errorstream<<"checking d="<<d<<" for " - <<server->getPlayerName(peer_id)<<std::endl;*/ - //infostream<<"RemoteClient::SendBlocks(): d="<<d<<std::endl; - - /* - If m_nearest_unsent_d was changed by the EmergeThread - (it can change it to 0 through SetBlockNotSent), - update our d to it. - Else update m_nearest_unsent_d - */ - /*if(m_nearest_unsent_d != last_nearest_unsent_d) - { - d = m_nearest_unsent_d; - last_nearest_unsent_d = m_nearest_unsent_d; - }*/ - - /* - Get the border/face dot coordinates of a "d-radiused" - box - */ - std::list<v3s16> list; - getFacePositions(list, d); - - std::list<v3s16>::iterator li; - for(li=list.begin(); li!=list.end(); ++li) - { - v3s16 p = *li + center; - - /* - Send throttling - - Don't allow too many simultaneous transfers - - EXCEPT when the blocks are very close - - Also, don't send blocks that are already flying. - */ - - // Start with the usual maximum - u16 max_simul_dynamic = max_simul_sends_usually; - - // If block is very close, allow full maximum - if(d <= BLOCK_SEND_DISABLE_LIMITS_MAX_D) - max_simul_dynamic = max_simul_sends_setting; - - // Don't select too many blocks for sending - if(num_blocks_selected >= max_simul_dynamic) - { - queue_is_full = true; - goto queue_full_break; - } - - // Don't send blocks that are currently being transferred - if(m_blocks_sending.find(p) != m_blocks_sending.end()) - continue; - - /* - Do not go over-limit - */ - if(p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE - || p.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE - || p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE - || p.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE - || p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE - || p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE) - continue; - - // If this is true, inexistent block will be made from scratch - bool generate = d <= d_max_gen; - - { - /*// Limit the generating area vertically to 2/3 - if(abs(p.Y - center.Y) > d_max_gen - d_max_gen / 3) - generate = false;*/ - - // Limit the send area vertically to 1/2 - if(abs(p.Y - center.Y) > d_max / 2) - continue; - } - -#if 0 - /* - If block is far away, don't generate it unless it is - near ground level. - */ - if(d >= 4) - { - #if 1 - // Block center y in nodes - f32 y = (f32)(p.Y * MAP_BLOCKSIZE + MAP_BLOCKSIZE/2); - // Don't generate if it's very high or very low - if(y < -64 || y > 64) - generate = false; - #endif - #if 0 - v2s16 p2d_nodes_center( - MAP_BLOCKSIZE*p.X, - MAP_BLOCKSIZE*p.Z); - - // Get ground height in nodes - s16 gh = server->m_env->getServerMap().findGroundLevel( - p2d_nodes_center); - - // If differs a lot, don't generate - if(fabs(gh - y) > MAP_BLOCKSIZE*2) - generate = false; - // Actually, don't even send it - //continue; - #endif - } -#endif - - //infostream<<"d="<<d<<std::endl; -#if 1 - /* - Don't generate or send if not in sight - FIXME This only works if the client uses a small enough - FOV setting. The default of 72 degrees is fine. - */ - - float camera_fov = (72.0*M_PI/180) * 4./3.; - if(isBlockInSight(p, camera_pos, camera_dir, camera_fov, 10000*BS) == false) - { - continue; - } -#endif - /* - Don't send already sent blocks - */ - { - if(m_blocks_sent.find(p) != m_blocks_sent.end()) - { - continue; - } - } - - /* - Check if map has this block - */ - MapBlock *block = server->m_env->getMap().getBlockNoCreateNoEx(p); - - bool surely_not_found_on_disk = false; - bool block_is_invalid = false; - if(block != NULL) - { - // Reset usage timer, this block will be of use in the future. - block->resetUsageTimer(); - - // Block is dummy if data doesn't exist. - // It means it has been not found from disk and not generated - if(block->isDummy()) - { - surely_not_found_on_disk = true; - } - - // Block is valid if lighting is up-to-date and data exists - if(block->isValid() == false) - { - block_is_invalid = true; - } - - /*if(block->isFullyGenerated() == false) - { - block_is_invalid = true; - }*/ - -#if 0 - v2s16 p2d(p.X, p.Z); - ServerMap *map = (ServerMap*)(&server->m_env->getMap()); - v2s16 chunkpos = map->sector_to_chunk(p2d); - if(map->chunkNonVolatile(chunkpos) == false) - block_is_invalid = true; -#endif - if(block->isGenerated() == false) - block_is_invalid = true; -#if 1 - /* - If block is not close, don't send it unless it is near - ground level. - - Block is near ground level if night-time mesh - differs from day-time mesh. - */ - if(d >= 4) - { - if(block->getDayNightDiff() == false) - continue; - } -#endif - } - - /* - If block has been marked to not exist on disk (dummy) - and generating new ones is not wanted, skip block. - */ - if(generate == false && surely_not_found_on_disk == true) - { - // get next one. - continue; - } - - /* - Add inexistent block to emerge queue. - */ - if(block == NULL || surely_not_found_on_disk || block_is_invalid) - { - /* //TODO: Get value from somewhere - // Allow only one block in emerge queue - //if(server->m_emerge_queue.peerItemCount(peer_id) < 1) - // Allow two blocks in queue per client - //if(server->m_emerge_queue.peerItemCount(peer_id) < 2) - u32 max_emerge = 5; - // Make it more responsive when needing to generate stuff - if(surely_not_found_on_disk) - max_emerge = 1; - if(server->m_emerge_queue.peerItemCount(peer_id) < max_emerge) - { - //infostream<<"Adding block to emerge queue"<<std::endl; - - // Add it to the emerge queue and trigger the thread - - u8 flags = 0; - if(generate == false) - flags |= BLOCK_EMERGE_FLAG_FROMDISK; - - server->m_emerge_queue.addBlock(peer_id, p, flags); - server->m_emergethread.trigger(); - - if(nearest_emerged_d == -1) - nearest_emerged_d = d; - } else { - if(nearest_emergefull_d == -1) - nearest_emergefull_d = d; - goto queue_full_break; - } - */ - - if (server->m_emerge->enqueueBlockEmerge(peer_id, p, generate)) { - if (nearest_emerged_d == -1) - nearest_emerged_d = d; - } else { - if (nearest_emergefull_d == -1) - nearest_emergefull_d = d; - goto queue_full_break; - } - - // get next one. - continue; - } - - if(nearest_sent_d == -1) - nearest_sent_d = d; - - /* - Add block to send queue - */ - - /*errorstream<<"sending from d="<<d<<" to " - <<server->getPlayerName(peer_id)<<std::endl;*/ - - PrioritySortedBlockTransfer q((float)d, p, peer_id); - - dest.push_back(q); - - num_blocks_selected += 1; - } - } -queue_full_break: - - //infostream<<"Stopped at "<<d<<std::endl; - - // If nothing was found for sending and nothing was queued for - // emerging, continue next time browsing from here - if(nearest_emerged_d != -1){ - new_nearest_unsent_d = nearest_emerged_d; - } else if(nearest_emergefull_d != -1){ - new_nearest_unsent_d = nearest_emergefull_d; - } else { - if(d > g_settings->getS16("max_block_send_distance")){ - new_nearest_unsent_d = 0; - m_nothing_to_send_pause_timer = 2.0; - /*infostream<<"GetNextBlocks(): d wrapped around for " - <<server->getPlayerName(peer_id) - <<"; setting to 0 and pausing"<<std::endl;*/ - } else { - if(nearest_sent_d != -1) - new_nearest_unsent_d = nearest_sent_d; - else - new_nearest_unsent_d = d; - } - } - - if(new_nearest_unsent_d != -1) - m_nearest_unsent_d = new_nearest_unsent_d; - - /*timer_result = timer.stop(true); - if(timer_result != 0) - infostream<<"GetNextBlocks timeout: "<<timer_result<<" (!=0)"<<std::endl;*/ -} - -void RemoteClient::GotBlock(v3s16 p) -{ - if(m_blocks_sending.find(p) != m_blocks_sending.end()) - m_blocks_sending.erase(p); - else - { - /*infostream<<"RemoteClient::GotBlock(): Didn't find in" - " m_blocks_sending"<<std::endl;*/ - m_excess_gotblocks++; - } - m_blocks_sent.insert(p); -} - -void RemoteClient::SentBlock(v3s16 p) -{ - if(m_blocks_sending.find(p) == m_blocks_sending.end()) - m_blocks_sending[p] = 0.0; - else - infostream<<"RemoteClient::SentBlock(): Sent block" - " already in m_blocks_sending"<<std::endl; -} - -void RemoteClient::SetBlockNotSent(v3s16 p) -{ - m_nearest_unsent_d = 0; - - if(m_blocks_sending.find(p) != m_blocks_sending.end()) - m_blocks_sending.erase(p); - if(m_blocks_sent.find(p) != m_blocks_sent.end()) - m_blocks_sent.erase(p); -} - -void RemoteClient::SetBlocksNotSent(std::map<v3s16, MapBlock*> &blocks) -{ - m_nearest_unsent_d = 0; - - for(std::map<v3s16, MapBlock*>::iterator - i = blocks.begin(); - i != blocks.end(); ++i) - { - v3s16 p = i->first; - - if(m_blocks_sending.find(p) != m_blocks_sending.end()) - m_blocks_sending.erase(p); - if(m_blocks_sent.find(p) != m_blocks_sent.end()) - m_blocks_sent.erase(p); - } -} /* Server @@ -648,8 +171,11 @@ Server::Server( m_simple_singleplayer_mode(simple_singleplayer_mode), m_async_fatal_error(""), m_env(NULL), - m_con(PROTOCOL_ID, 512, CONNECTION_TIMEOUT, - g_settings->getBool("enable_ipv6") && g_settings->getBool("ipv6_server"), this), + m_con(PROTOCOL_ID, + 512, + CONNECTION_TIMEOUT, + g_settings->getBool("enable_ipv6") && g_settings->getBool("ipv6_server"), + this), m_banmanager(NULL), m_rollback(NULL), m_rollback_sink_enabled(true), @@ -663,9 +189,11 @@ Server::Server( m_thread(NULL), m_time_of_day_send_timer(0), m_uptime(0), + m_clients(&m_con), m_shutdown_requested(false), m_ignore_map_edit_events(false), m_ignore_map_edit_events_peer_id(0) + { m_liquid_transform_timer = 0.0; m_liquid_transform_every = 1.0; @@ -768,10 +296,8 @@ Server::Server( // Lock environment JMutexAutoLock envlock(m_env_mutex); - JMutexAutoLock conlock(m_con_mutex); // Initialize scripting - infostream<<"Server: Initializing Lua"<<std::endl; m_script = new GameScripting(this); @@ -818,11 +344,13 @@ Server::Server( // Initialize Environment ServerMap *servermap = new ServerMap(path_world, this, m_emerge); m_env = new ServerEnvironment(servermap, m_script, this, m_emerge); - + + m_clients.setEnv(m_env); + // Run some callbacks after the MG params have been set up but before activation MapgenParams *mgparams = servermap->getMapgenParams(); m_script->environment_OnMapgenInit(mgparams); - + // Initialize mapgens m_emerge->initMapgens(mgparams); servermap->setMapgenParams(m_emerge->params); @@ -860,34 +388,12 @@ Server::~Server() Send shutdown message */ { - JMutexAutoLock conlock(m_con_mutex); - std::wstring line = L"*** Server shutting down"; - - /* - Send the message to clients - */ - for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); ++i) - { - // Get client and check that it is valid - RemoteClient *client = i->second; - assert(client->peer_id == i->first); - if(client->serialization_version == SER_FMT_VER_INVALID) - continue; - - try{ - SendChatMessage(client->peer_id, line); - } - catch(con::PeerNotFoundException &e) - {} - } + SendChatMessage(PEER_ID_INEXISTENT, line); } { JMutexAutoLock envlock(m_env_mutex); - JMutexAutoLock conlock(m_con_mutex); /* Execute script shutdown hooks @@ -921,22 +427,6 @@ Server::~Server() // requested blocks to be emerged m_emerge->stopThreads(); - /* - Delete clients - */ - { - JMutexAutoLock clientslock(m_con_mutex); - - for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); ++i) - { - - // Delete client - delete i->second; - } - } - // Delete things in the reverse order of creation delete m_env; @@ -1061,18 +551,7 @@ void Server::AsyncRunStep(bool initial_step) m_uptime.set(m_uptime.get() + dtime); } - { - // Process connection's timeouts - JMutexAutoLock lock2(m_con_mutex); - ScopeProfiler sp(g_profiler, "Server: connection timeout processing"); - m_con.RunTimeouts(dtime); - } - - { - // This has to be called so that the client list gets synced - // with the peer list of the connection - handlePeerChanges(); - } + handlePeerChanges(); /* Update time of day and overall game time @@ -1090,20 +569,9 @@ void Server::AsyncRunStep(bool initial_step) if(m_time_of_day_send_timer < 0.0) { m_time_of_day_send_timer = g_settings->getFloat("time_send_interval"); - - //JMutexAutoLock envlock(m_env_mutex); - JMutexAutoLock conlock(m_con_mutex); - u16 time = m_env->getTimeOfDay(); float time_speed = g_settings->getFloat("time_speed"); - - for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); ++i) - { - RemoteClient *client = i->second; - SendTimeOfDay(client->peer_id, time, time_speed); - } + SendTimeOfDay(PEER_ID_INEXISTENT, time, time_speed); } } @@ -1144,16 +612,16 @@ void Server::AsyncRunStep(bool initial_step) */ { JMutexAutoLock lock(m_env_mutex); - JMutexAutoLock lock2(m_con_mutex); + + std::list<u16> clientids = m_clients.getClientIDs(); ScopeProfiler sp(g_profiler, "Server: handle players"); - for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); ++i) + for(std::list<u16>::iterator + i = clientids.begin(); + i != clientids.end(); ++i) { - RemoteClient *client = i->second; - PlayerSAO *playersao = getPlayerSAO(client->peer_id); + PlayerSAO *playersao = getPlayerSAO(*i); if(playersao == NULL) continue; @@ -1163,28 +631,28 @@ void Server::AsyncRunStep(bool initial_step) if(playersao->m_hp_not_sent && g_settings->getBool("enable_damage")) { if(playersao->getHP() == 0) - DiePlayer(client->peer_id); + DiePlayer(*i); else - SendPlayerHP(client->peer_id); + SendPlayerHP(*i); } /* Send player breath if changed */ if(playersao->m_breath_not_sent){ - SendPlayerBreath(client->peer_id); + SendPlayerBreath(*i); } /* Send player inventories if necessary */ if(playersao->m_moved){ - SendMovePlayer(client->peer_id); + SendMovePlayer(*i); playersao->m_moved = false; } if(playersao->m_inventory_not_sent){ - UpdateCrafting(client->peer_id); - SendInventory(client->peer_id); + UpdateCrafting(*i); + SendInventory(*i); } } } @@ -1221,77 +689,43 @@ void Server::AsyncRunStep(bool initial_step) /* Set the modified blocks unsent for all the clients */ - - JMutexAutoLock lock2(m_con_mutex); - - for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); ++i) + if(modified_blocks.size() > 0) { - RemoteClient *client = i->second; - - if(modified_blocks.size() > 0) - { - // Remove block from sent history - client->SetBlocksNotSent(modified_blocks); - } + SetBlocksNotSent(modified_blocks); } } - - // Periodically print some info - { - float &counter = m_print_info_timer; - counter += dtime; - if(counter >= 30.0) - { - counter = 0.0; - - JMutexAutoLock lock2(m_con_mutex); - m_clients_names.clear(); - if(m_clients.size() != 0) - infostream<<"Players:"<<std::endl; - for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); ++i) - { - //u16 peer_id = i.getNode()->getKey(); - RemoteClient *client = i->second; - Player *player = m_env->getPlayer(client->peer_id); - if(player==NULL) - continue; - infostream<<"* "<<player->getName()<<"\t"; - client->PrintInfo(infostream); - m_clients_names.push_back(player->getName()); - } - } - } - + m_clients.step(dtime); m_lag += (m_lag > dtime ? -1 : 1) * dtime/100; #if USE_CURL // send masterserver announce { float &counter = m_masterserver_timer; - if(!isSingleplayer() && (!counter || counter >= 300.0) && g_settings->getBool("server_announce") == true) + if(!isSingleplayer() && (!counter || counter >= 300.0) && + g_settings->getBool("server_announce") == true) { - ServerList::sendAnnounce(!counter ? "start" : "update", m_clients_names, m_uptime.get(), m_env->getGameTime(), m_lag, m_gamespec.id, m_mods); + ServerList::sendAnnounce(!counter ? "start" : "update", + m_clients.getPlayerNames(), + m_uptime.get(), + m_env->getGameTime(), + m_lag, + m_gamespec.id, + m_mods); counter = 0.01; } counter += dtime; } #endif - //if(g_settings->getBool("enable_experimental")) - { - /* Check added and deleted active objects */ { //infostream<<"Server: Checking added and deleted active objects"<<std::endl; JMutexAutoLock envlock(m_env_mutex); - JMutexAutoLock conlock(m_con_mutex); + m_clients.Lock(); + std::map<u16, RemoteClient*> clients = m_clients.getClientList(); ScopeProfiler sp(g_profiler, "Server: checking added and deleted objs"); // Radius inside which objects are active @@ -1299,14 +733,14 @@ void Server::AsyncRunStep(bool initial_step) radius *= MAP_BLOCKSIZE; for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); ++i) + i = clients.begin(); + i != clients.end(); ++i) { RemoteClient *client = i->second; // If definitions and textures have not been sent, don't // send objects either - if(!client->definitions_sent) + if (client->getState() < DefinitionsSent) continue; Player *player = m_env->getPlayer(client->peer_id); @@ -1404,14 +838,14 @@ void Server::AsyncRunStep(bool initial_step) memcpy((char*)&reply[2], data_buffer.c_str(), data_buffer.size()); // Send as reliable - m_con.Send(client->peer_id, 0, reply, true); + m_clients.send(client->peer_id, 0, reply, true); verbosestream<<"Server: Sent object remove/add: " <<removed_objects.size()<<" removed, " <<added_objects.size()<<" added, " <<"packet size is "<<reply.getSize()<<std::endl; } - + m_clients.Unlock(); #if 0 /* Collect a list of all the objects known by the clients @@ -1445,8 +879,6 @@ void Server::AsyncRunStep(bool initial_step) */ { JMutexAutoLock envlock(m_env_mutex); - JMutexAutoLock conlock(m_con_mutex); - ScopeProfiler sp(g_profiler, "Server: sending object messages"); // Key = object id @@ -1475,10 +907,12 @@ void Server::AsyncRunStep(bool initial_step) message_list->push_back(aom); } + m_clients.Lock(); + std::map<u16, RemoteClient*> clients = m_clients.getClientList(); // Route data to every client for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); ++i) + i = clients.begin(); + i != clients.end(); ++i) { RemoteClient *client = i->second; std::string reliable_data; @@ -1525,7 +959,7 @@ void Server::AsyncRunStep(bool initial_step) memcpy((char*)&reply[2], reliable_data.c_str(), reliable_data.size()); // Send as reliable - m_con.Send(client->peer_id, 0, reply, true); + m_clients.send(client->peer_id, 0, reply, true); } if(unreliable_data.size() > 0) { @@ -1534,7 +968,7 @@ void Server::AsyncRunStep(bool initial_step) memcpy((char*)&reply[2], unreliable_data.c_str(), unreliable_data.size()); // Send as unreliable - m_con.Send(client->peer_id, 1, reply, false); + m_clients.send(client->peer_id, 1, reply, false); } /*if(reliable_data.size() > 0 || unreliable_data.size() > 0) @@ -1545,6 +979,7 @@ void Server::AsyncRunStep(bool initial_step) <<std::endl; }*/ } + m_clients.Unlock(); // Clear buffered_messages for(std::map<u16, std::list<ActiveObjectMessage>* >::iterator @@ -1555,15 +990,12 @@ void Server::AsyncRunStep(bool initial_step) } } - } // enable_experimental - /* Send queued-for-sending map edit events. */ { - // We will be accessing the environment and the connection + // We will be accessing the environment JMutexAutoLock lock(m_env_mutex); - JMutexAutoLock conlock(m_con_mutex); // Don't send too many at a time //u32 count = 0; @@ -1731,15 +1163,7 @@ void Server::Receive() u16 peer_id; u32 datasize; try{ - { - JMutexAutoLock conlock(m_con_mutex); - datasize = m_con.Receive(peer_id, data); - } - - // This has to be called so that the client list gets synced - // with the peer list of the connection - handlePeerChanges(); - + datasize = m_con.Receive(peer_id,data); ProcessData(*data, datasize, peer_id); } catch(con::InvalidIncomingDataException &e) @@ -1770,13 +1194,12 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) DSTACK(__FUNCTION_NAME); // Environment is locked first. JMutexAutoLock envlock(m_env_mutex); - JMutexAutoLock conlock(m_con_mutex); ScopeProfiler sp(g_profiler, "Server::ProcessData"); std::string addr_s; try{ - Address address = m_con.GetPeerAddress(peer_id); + Address address = getPeerAddress(peer_id); addr_s = address.serializeString(); // drop player if is ip is banned @@ -1788,19 +1211,16 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) // 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)); - m_con.DeletePeer(peer_id); return; } } catch(con::PeerNotFoundException &e) { - infostream<<"Server::ProcessData(): Cancelling: peer " + errorstream<<"Server::ProcessData(): Cancelling: peer " <<peer_id<<" not found"<<std::endl; return; } - u8 peer_ser_ver = getClient(peer_id)->serialization_version; - try { @@ -1819,8 +1239,11 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) if(datasize < 2+1+PLAYERNAME_SIZE) return; + RemoteClient* client = getClient(peer_id,Created); + // If net_proto_version is set, this client has already been handled - if(getClient(peer_id)->net_proto_version != 0){ + if(client->getState() > Created) + { verbosestream<<"Server: Ignoring multiple TOSERVER_INITs from " <<addr_s<<" (peer_id="<<peer_id<<")"<<std::endl; return; @@ -1830,8 +1253,8 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) <<peer_id<<")"<<std::endl; // Do not allow multiple players in simple singleplayer mode. - // This isn't a perfect way to do it, but will suffice for now. - if(m_simple_singleplayer_mode && m_clients.size() > 1){ + // This isn't a perfect way to do it, but will suffice for now + if(m_simple_singleplayer_mode && m_clients.getClientIDs().size() > 1){ infostream<<"Server: Not allowing another client ("<<addr_s <<") to connect in simple singleplayer mode"<<std::endl; DenyAccess(peer_id, L"Running in simple singleplayer mode."); @@ -1848,9 +1271,6 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) if(deployed < SER_FMT_VER_LOWEST) deployed = SER_FMT_VER_INVALID; - //peer->serialization_version = deployed; - getClient(peer_id)->pending_serialization_version = deployed; - if(deployed == SER_FMT_VER_INVALID) { actionstream<<"Server: A mismatched client tried to connect from " @@ -1865,6 +1285,8 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) return; } + client->setPendingSerializationVersion(deployed); + /* Read and check network protocol version */ @@ -1898,7 +1320,7 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) <<min_net_proto_version<<", max: "<<max_net_proto_version <<", chosen: "<<net_proto_version<<std::endl; - getClient(peer_id)->net_proto_version = net_proto_version; + client->net_proto_version = net_proto_version; if(net_proto_version < SERVER_PROTOCOL_VERSION_MIN || net_proto_version > SERVER_PROTOCOL_VERSION_MAX) @@ -2019,7 +1441,7 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) // Enforce user limit. // Don't enforce for users that have some admin right - if(m_clients.size() >= g_settings->getU16("max_users") && + if(m_clients.getClientIDs(Created).size() >= g_settings->getU16("max_users") && !checkPriv(playername, "server") && !checkPriv(playername, "ban") && !checkPriv(playername, "privs") && @@ -2075,28 +1497,19 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) return; } - // Get player - PlayerSAO *playersao = emergePlayer(playername, peer_id); + RemotePlayer *player = + static_cast<RemotePlayer*>(m_env->getPlayer(playername)); - // If failed, cancel - if(playersao == NULL) - { - RemotePlayer *player = - static_cast<RemotePlayer*>(m_env->getPlayer(playername)); - 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 " - 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."); - } - return; + 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 " + L"name. If your client closed unexpectedly, try again in " + L"a minute."); } + m_clients.setPlayerName(peer_id,playername); + /* Answer with a TOCLIENT_INIT */ @@ -2104,37 +1517,27 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) SharedBuffer<u8> reply(2+1+6+8+4); writeU16(&reply[0], TOCLIENT_INIT); writeU8(&reply[2], deployed); - writeV3S16(&reply[2+1], floatToInt(playersao->getPlayer()->getPosition()+v3f(0,BS/2,0), BS)); + //send dummy pos for legacy reasons only + writeV3S16(&reply[2+1], floatToInt(v3f(0,0,0), BS)); writeU64(&reply[2+1+6], m_env->getServerMap().getSeed()); writeF1000(&reply[2+1+6+8], g_settings->getFloat("dedicated_server_step")); // Send as reliable - m_con.Send(peer_id, 0, reply, true); + m_clients.send(peer_id, 0, reply, true); + m_clients.event(peer_id, Init); } - /* - Send complete position information - */ - SendMovePlayer(peer_id); - return; } if(command == TOSERVER_INIT2) { + verbosestream<<"Server: Got TOSERVER_INIT2 from " <<peer_id<<std::endl; - Player *player = m_env->getPlayer(peer_id); - if(!player){ - verbosestream<<"Server: TOSERVER_INIT2: " - <<"Player not found; ignoring."<<std::endl; - return; - } - - RemoteClient *client = getClient(peer_id); - client->serialization_version = - getClient(peer_id)->pending_serialization_version; + m_clients.event(peer_id, GotInit2); + u16 protocol_version = m_clients.getProtocolVersion(peer_id); /* Send some initialization data @@ -2144,17 +1547,105 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) <<getPlayerName(peer_id)<<std::endl; // Send player movement settings - SendMovement(m_con, peer_id); + SendMovement(peer_id); // Send item definitions - SendItemDef(m_con, peer_id, m_itemdef, client->net_proto_version); + SendItemDef(peer_id, m_itemdef, protocol_version); // Send node definitions - SendNodeDef(m_con, peer_id, m_nodedef, client->net_proto_version); + SendNodeDef(peer_id, m_nodedef, protocol_version); + + m_clients.event(peer_id, SetDefinitionsSent); // Send media announcement sendMediaAnnouncement(peer_id); + // Send detached inventories + sendDetachedInventories(peer_id); + + // Send time of day + u16 time = m_env->getTimeOfDay(); + float time_speed = g_settings->getFloat("time_speed"); + SendTimeOfDay(peer_id, time, time_speed); + + // Warnings about protocol version can be issued here + if(getClient(peer_id)->net_proto_version < LATEST_PROTOCOL_VERSION) + { + SendChatMessage(peer_id, L"# Server: WARNING: YOUR CLIENT'S " + L"VERSION MAY NOT BE FULLY COMPATIBLE WITH THIS SERVER!"); + } + + return; + } + + u8 peer_ser_ver = getClient(peer_id,InitDone)->serialization_version; + + if(peer_ser_ver == SER_FMT_VER_INVALID) + { + errorstream<<"Server::ProcessData(): Cancelling: Peer" + " serialization format invalid or not initialized." + " Skipping incoming command="<<command<<std::endl; + return; + } + + /* Handle commands relate to client startup */ + if(command == TOSERVER_REQUEST_MEDIA) { + std::string datastring((char*)&data[2], datasize-2); + std::istringstream is(datastring, std::ios_base::binary); + + std::list<std::string> tosend; + u16 numfiles = readU16(is); + + infostream<<"Sending "<<numfiles<<" files to " + <<getPlayerName(peer_id)<<std::endl; + verbosestream<<"TOSERVER_REQUEST_MEDIA: "<<std::endl; + + for(int i = 0; i < numfiles; i++) { + std::string name = deSerializeString(is); + tosend.push_back(name); + verbosestream<<"TOSERVER_REQUEST_MEDIA: requested file " + <<name<<std::endl; + } + + sendRequestedMedia(peer_id, tosend); + return; + } + else if(command == TOSERVER_RECEIVED_MEDIA) { + std::string playername = ""; + PlayerSAO *playersao = NULL; + m_clients.Lock(); + RemoteClient* client = m_clients.lockedGetClientNoEx(peer_id,DefinitionsSent); + if (client != NULL) { + playername = client->getName(); + playersao = emergePlayer(playername.c_str(), peer_id); + } + 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 " + 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."); + } + return; + } + + /* + Send complete position information + */ + SendMovePlayer(peer_id); + // Send privileges SendPlayerPrivileges(peer_id); @@ -2172,19 +1663,9 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) // Send Breath SendPlayerBreath(peer_id); - // Send detached inventories - sendDetachedInventories(peer_id); - // Show death screen if necessary if(player->hp == 0) - SendDeathscreen(m_con, peer_id, false, v3f(0,0,0)); - - // Send time of day - { - u16 time = m_env->getTimeOfDay(); - float time_speed = g_settings->getFloat("time_speed"); - SendTimeOfDay(peer_id, time, time_speed); - } + SendDeathscreen(peer_id, false, v3f(0,0,0)); // Note things in chat if not in simple singleplayer mode if(!m_simple_singleplayer_mode) @@ -2203,56 +1684,74 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) message += L"*** "; message += name; message += L" joined the game."; - BroadcastChatMessage(message); + SendChatMessage(PEER_ID_INEXISTENT,message); } } - // Warnings about protocol version can be issued here - if(getClient(peer_id)->net_proto_version < LATEST_PROTOCOL_VERSION) - { - SendChatMessage(peer_id, L"# Server: WARNING: YOUR CLIENT'S " - L"VERSION MAY NOT BE FULLY COMPATIBLE WITH THIS SERVER!"); - } - + actionstream<<player->getName()<<" ["<<addr_s<<"] "<<"joins game. " << std::endl; /* Print out action */ { - std::ostringstream os(std::ios_base::binary); - for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); ++i) + std::vector<std::string> names = m_clients.getPlayerNames(); + + actionstream<<player->getName()<<" ["<<addr_s<<"] " + <<"joins game. List of players: "; + + for (std::vector<std::string>::iterator i = names.begin(); + i != names.end(); i++) { - RemoteClient *client = i->second; - assert(client->peer_id == i->first); - if(client->serialization_version == SER_FMT_VER_INVALID) - continue; - // Get player - Player *player = m_env->getPlayer(client->peer_id); - if(!player) - continue; - // Get name of player - os<<player->getName()<<" "; + actionstream << *i << " "; } - actionstream<<player->getName()<<" ["<<addr_s<<"] "<<"joins game. List of players: " - <<os.str()<<std::endl; + actionstream<<std::endl; } + m_clients.event(peer_id,SetMediaSent); + m_script->on_joinplayer(playersao); return; } + else if(command == TOSERVER_GOTBLOCKS) + { + if(datasize < 2+1) + return; - if(peer_ser_ver == SER_FMT_VER_INVALID) + /* + [0] u16 command + [2] u8 count + [3] v3s16 pos_0 + [3+6] v3s16 pos_1 + ... + */ + + u16 count = data[2]; + for(u16 i=0; i<count; i++) + { + if((s16)datasize < 2+1+(i+1)*6) + throw con::InvalidIncomingDataException + ("GOTBLOCKS length is too short"); + v3s16 p = readV3S16(&data[2+1+i*6]); + /*infostream<<"Server: GOTBLOCKS (" + <<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/ + RemoteClient *client = getClient(peer_id); + client->GotBlock(p); + } + return; + } + + if (m_clients.getClientState(peer_id) < Active) { - infostream<<"Server::ProcessData(): Cancelling: Peer" - " serialization format invalid or not initialized." - " Skipping incoming command="<<command<<std::endl; + if (command == TOSERVER_PLAYERPOS) return; + + errorstream<<"Got packet command: " << command << " for peer id " + << peer_id << " but client isn't active yet. Dropping packet " + <<std::endl; return; } Player *player = m_env->getPlayer(peer_id); if(player == NULL){ - infostream<<"Server::ProcessData(): Cancelling: " + errorstream<<"Server::ProcessData(): Cancelling: " "No player for peer_id="<<peer_id <<std::endl; return; @@ -2260,7 +1759,7 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) PlayerSAO *playersao = player->getPlayerSAO(); if(playersao == NULL){ - infostream<<"Server::ProcessData(): Cancelling: " + errorstream<<"Server::ProcessData(): Cancelling: " "No player object for peer_id="<<peer_id <<std::endl; return; @@ -2309,32 +1808,6 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) <<"("<<position.X<<","<<position.Y<<","<<position.Z<<")" <<" pitch="<<pitch<<" yaw="<<yaw<<std::endl;*/ } - else if(command == TOSERVER_GOTBLOCKS) - { - if(datasize < 2+1) - return; - - /* - [0] u16 command - [2] u8 count - [3] v3s16 pos_0 - [3+6] v3s16 pos_1 - ... - */ - - u16 count = data[2]; - for(u16 i=0; i<count; i++) - { - if((s16)datasize < 2+1+(i+1)*6) - throw con::InvalidIncomingDataException - ("GOTBLOCKS length is too short"); - v3s16 p = readV3S16(&data[2+1+i*6]); - /*infostream<<"Server: GOTBLOCKS (" - <<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/ - RemoteClient *client = getClient(peer_id); - client->GotBlock(p); - } - } else if(command == TOSERVER_DELETEDBLOCKS) { if(datasize < 2+1) @@ -2577,16 +2050,14 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) // Line to send to players std::wstring line; // Whether to send to the player that sent the line - bool send_to_sender = false; - // Whether to send to other players - bool send_to_others = false; + bool send_to_sender_only = false; // Commands are implemented in Lua, so only catch invalid // commands that were not "eaten" and send an error back if(message[0] == L'/') { message = message.substr(1); - send_to_sender = true; + send_to_sender_only = true; if(message.length() == 0) line += L"-!- Empty command"; else @@ -2599,39 +2070,37 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) line += name; line += L"> "; line += message; - send_to_others = true; } else { line += L"-!- You don't have permission to shout."; - send_to_sender = true; + send_to_sender_only = true; } } if(line != L"") { - if(send_to_others) - actionstream<<"CHAT: "<<wide_to_narrow(line)<<std::endl; - /* - Send the message to clients + Send the message to sender */ - for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); ++i) + if (send_to_sender_only) { - // Get client and check that it is valid - RemoteClient *client = i->second; - assert(client->peer_id == i->first); - if(client->serialization_version == SER_FMT_VER_INVALID) - continue; + SendChatMessage(peer_id, line); + } + /* + Send the message to others + */ + else + { + actionstream<<"CHAT: "<<wide_to_narrow(line)<<std::endl; - // Filter recipient - bool sender_selected = (peer_id == client->peer_id); - if(sender_selected == true && send_to_sender == false) - continue; - if(sender_selected == false && send_to_others == false) - continue; + std::list<u16> clients = m_clients.getClientIDs(); - SendChatMessage(client->peer_id, line); + for(std::list<u16>::iterator + i = clients.begin(); + i != clients.end(); ++i) + { + if (*i != peer_id) + SendChatMessage(*i, line); + } } } } @@ -2748,33 +2217,6 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) // ActiveObject is added to environment in AsyncRunStep after // the previous addition has been succesfully removed } - else if(command == TOSERVER_REQUEST_MEDIA) { - std::string datastring((char*)&data[2], datasize-2); - std::istringstream is(datastring, std::ios_base::binary); - - std::list<std::string> tosend; - u16 numfiles = readU16(is); - - infostream<<"Sending "<<numfiles<<" files to " - <<getPlayerName(peer_id)<<std::endl; - verbosestream<<"TOSERVER_REQUEST_MEDIA: "<<std::endl; - - for(int i = 0; i < numfiles; i++) { - std::string name = deSerializeString(is); - tosend.push_back(name); - verbosestream<<"TOSERVER_REQUEST_MEDIA: requested file " - <<name<<std::endl; - } - - sendRequestedMedia(peer_id, tosend); - - // Now the client should know about everything - // (definitions and files) - getClient(peer_id)->definitions_sent = true; - } - else if(command == TOSERVER_RECEIVED_MEDIA) { - getClient(peer_id)->definitions_sent = true; - } else if(command == TOSERVER_INTERACT) { std::string datastring((char*)&data[2], datasize-2); @@ -3313,7 +2755,7 @@ void Server::setInventoryModified(const InventoryLocation &loc) break; case InventoryLocation::DETACHED: { - sendDetachedInventoryToAll(loc.name); + sendDetachedInventory(loc.name,PEER_ID_INEXISTENT); } break; default: @@ -3321,14 +2763,29 @@ void Server::setInventoryModified(const InventoryLocation &loc) } } +void Server::SetBlocksNotSent(std::map<v3s16, MapBlock *>& block) +{ + std::list<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(); + i != clients.end(); ++i) { + RemoteClient *client = m_clients.lockedGetClientNoEx(*i); + if (client != NULL) + client->SetBlocksNotSent(block); + } + m_clients.Unlock(); +} + void Server::peerAdded(con::Peer *peer) { DSTACK(__FUNCTION_NAME); verbosestream<<"Server::peerAdded(): peer->id=" <<peer->id<<std::endl; - PeerChange c; - c.type = PEER_ADDED; + con::PeerChange c; + c.type = con::PEER_ADDED; c.peer_id = peer->id; c.timeout = false; m_peer_change_queue.push_back(c); @@ -3340,18 +2797,42 @@ void Server::deletingPeer(con::Peer *peer, bool timeout) verbosestream<<"Server::deletingPeer(): peer->id=" <<peer->id<<", timeout="<<timeout<<std::endl; - PeerChange c; - c.type = PEER_REMOVED; + m_clients.event(peer->id,Disconnect); + con::PeerChange c; + c.type = con::PEER_REMOVED; c.peer_id = peer->id; c.timeout = timeout; m_peer_change_queue.push_back(c); } -/* - Static send methods -*/ +void Server::handlePeerChanges() +{ + while(m_peer_change_queue.size() > 0) + { + con::PeerChange c = m_peer_change_queue.pop_front(); + + verbosestream<<"Server: Handling peer change: " + <<"id="<<c.peer_id<<", timeout="<<c.timeout + <<std::endl; + + switch(c.type) + { + case con::PEER_ADDED: + m_clients.CreateClient(c.peer_id); + break; + + case con::PEER_REMOVED: + DeleteClient(c.peer_id, c.timeout?CDR_TIMEOUT:CDR_LEAVE); + break; -void Server::SendMovement(con::Connection &con, u16 peer_id) + default: + assert("Invalid peer change event received!" == 0); + break; + } + } +} + +void Server::SendMovement(u16 peer_id) { DSTACK(__FUNCTION_NAME); std::ostringstream os(std::ios_base::binary); @@ -3374,10 +2855,10 @@ void Server::SendMovement(con::Connection &con, u16 peer_id) std::string s = os.str(); SharedBuffer<u8> data((u8*)s.c_str(), s.size()); // Send as reliable - con.Send(peer_id, 0, data, true); + m_clients.send(peer_id, 0, data, true); } -void Server::SendHP(con::Connection &con, u16 peer_id, u8 hp) +void Server::SendHP(u16 peer_id, u8 hp) { DSTACK(__FUNCTION_NAME); std::ostringstream os(std::ios_base::binary); @@ -3389,10 +2870,10 @@ void Server::SendHP(con::Connection &con, u16 peer_id, u8 hp) std::string s = os.str(); SharedBuffer<u8> data((u8*)s.c_str(), s.size()); // Send as reliable - con.Send(peer_id, 0, data, true); + m_clients.send(peer_id, 0, data, true); } -void Server::SendBreath(con::Connection &con, u16 peer_id, u16 breath) +void Server::SendBreath(u16 peer_id, u16 breath) { DSTACK(__FUNCTION_NAME); std::ostringstream os(std::ios_base::binary); @@ -3404,11 +2885,10 @@ void Server::SendBreath(con::Connection &con, u16 peer_id, u16 breath) std::string s = os.str(); SharedBuffer<u8> data((u8*)s.c_str(), s.size()); // Send as reliable - con.Send(peer_id, 0, data, true); + m_clients.send(peer_id, 0, data, true); } -void Server::SendAccessDenied(con::Connection &con, u16 peer_id, - const std::wstring &reason) +void Server::SendAccessDenied(u16 peer_id,const std::wstring &reason) { DSTACK(__FUNCTION_NAME); std::ostringstream os(std::ios_base::binary); @@ -3420,11 +2900,11 @@ void Server::SendAccessDenied(con::Connection &con, u16 peer_id, std::string s = os.str(); SharedBuffer<u8> data((u8*)s.c_str(), s.size()); // Send as reliable - con.Send(peer_id, 0, data, true); + m_clients.send(peer_id, 0, data, true); } -void Server::SendDeathscreen(con::Connection &con, u16 peer_id, - bool set_camera_point_target, v3f camera_point_target) +void Server::SendDeathscreen(u16 peer_id,bool set_camera_point_target, + v3f camera_point_target) { DSTACK(__FUNCTION_NAME); std::ostringstream os(std::ios_base::binary); @@ -3437,10 +2917,10 @@ void Server::SendDeathscreen(con::Connection &con, u16 peer_id, std::string s = os.str(); SharedBuffer<u8> data((u8*)s.c_str(), s.size()); // Send as reliable - con.Send(peer_id, 0, data, true); + m_clients.send(peer_id, 0, data, true); } -void Server::SendItemDef(con::Connection &con, u16 peer_id, +void Server::SendItemDef(u16 peer_id, IItemDefManager *itemdef, u16 protocol_version) { DSTACK(__FUNCTION_NAME); @@ -3464,10 +2944,10 @@ void Server::SendItemDef(con::Connection &con, u16 peer_id, <<"): size="<<s.size()<<std::endl; SharedBuffer<u8> data((u8*)s.c_str(), s.size()); // Send as reliable - con.Send(peer_id, 0, data, true); + m_clients.send(peer_id, 0, data, true); } -void Server::SendNodeDef(con::Connection &con, u16 peer_id, +void Server::SendNodeDef(u16 peer_id, INodeDefManager *nodedef, u16 protocol_version) { DSTACK(__FUNCTION_NAME); @@ -3491,7 +2971,7 @@ void Server::SendNodeDef(con::Connection &con, u16 peer_id, <<"): size="<<s.size()<<std::endl; SharedBuffer<u8> data((u8*)s.c_str(), s.size()); // Send as reliable - con.Send(peer_id, 0, data, true); + m_clients.send(peer_id, 0, data, true); } /* @@ -3521,7 +3001,7 @@ void Server::SendInventory(u16 peer_id) memcpy(&data[2], s.c_str(), s.size()); // Send as reliable - m_con.Send(peer_id, 0, data, true); + m_clients.send(peer_id, 0, data, true); } void Server::SendChatMessage(u16 peer_id, const std::wstring &message) @@ -3550,8 +3030,16 @@ void Server::SendChatMessage(u16 peer_id, const std::wstring &message) // Make data buffer std::string s = os.str(); SharedBuffer<u8> data((u8*)s.c_str(), s.size()); - // Send as reliable - m_con.Send(peer_id, 0, data, true); + + if (peer_id != PEER_ID_INEXISTENT) + { + // Send as reliable + m_clients.send(peer_id, 0, data, true); + } + else + { + m_clients.sendToAll(0,data,true); + } } void Server::SendShowFormspecMessage(u16 peer_id, const std::string formspec, @@ -3572,7 +3060,7 @@ void Server::SendShowFormspecMessage(u16 peer_id, const std::string formspec, std::string s = os.str(); SharedBuffer<u8> data((u8*)s.c_str(), s.size()); // Send as reliable - m_con.Send(peer_id, 0, data, true); + m_clients.send(peer_id, 0, data, true); } // Spawns a particle on peer with peer_id @@ -3596,27 +3084,15 @@ void Server::SendSpawnParticle(u16 peer_id, v3f pos, v3f velocity, v3f accelerat // Make data buffer std::string s = os.str(); SharedBuffer<u8> data((u8*)s.c_str(), s.size()); - // Send as reliable - m_con.Send(peer_id, 0, data, true); -} -// Spawns a particle on all peers -void Server::SendSpawnParticleAll(v3f pos, v3f velocity, v3f acceleration, - float expirationtime, float size, bool collisiondetection, - bool vertical, std::string texture) -{ - for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); i++) + if (peer_id != PEER_ID_INEXISTENT) { - // Get client and check that it is valid - RemoteClient *client = i->second; - assert(client->peer_id == i->first); - if(client->serialization_version == SER_FMT_VER_INVALID) - continue; - - SendSpawnParticle(client->peer_id, pos, velocity, acceleration, - expirationtime, size, collisiondetection, vertical, texture); + // Send as reliable + m_clients.send(peer_id, 0, data, true); + } + else + { + m_clients.sendToAll(0,data,true); } } @@ -3650,28 +3126,14 @@ void Server::SendAddParticleSpawner(u16 peer_id, u16 amount, float spawntime, v3 // Make data buffer std::string s = os.str(); SharedBuffer<u8> data((u8*)s.c_str(), s.size()); - // Send as reliable - m_con.Send(peer_id, 0, data, true); -} -// Adds a ParticleSpawner on all peers -void Server::SendAddParticleSpawnerAll(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) -{ - for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); i++) + if (peer_id != PEER_ID_INEXISTENT) { - // Get client and check that it is valid - RemoteClient *client = i->second; - assert(client->peer_id == i->first); - if(client->serialization_version == SER_FMT_VER_INVALID) - continue; - - SendAddParticleSpawner(client->peer_id, amount, spawntime, - minpos, maxpos, minvel, maxvel, minacc, maxacc, - minexptime, maxexptime, minsize, maxsize, collisiondetection, vertical, texture, id); + // Send as reliable + m_clients.send(peer_id, 0, data, true); + } + else { + m_clients.sendToAll(0,data,true); } } @@ -3687,24 +3149,15 @@ void Server::SendDeleteParticleSpawner(u16 peer_id, u32 id) // Make data buffer std::string s = os.str(); SharedBuffer<u8> data((u8*)s.c_str(), s.size()); - // Send as reliable - m_con.Send(peer_id, 0, data, true); -} -void Server::SendDeleteParticleSpawnerAll(u32 id) -{ - for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); i++) - { - // Get client and check that it is valid - RemoteClient *client = i->second; - assert(client->peer_id == i->first); - if(client->serialization_version == SER_FMT_VER_INVALID) - continue; - - SendDeleteParticleSpawner(client->peer_id, id); + if (peer_id != PEER_ID_INEXISTENT) { + // Send as reliable + m_clients.send(peer_id, 0, data, true); + } + else { + m_clients.sendToAll(0,data,true); } + } void Server::SendHUDAdd(u16 peer_id, u32 id, HudElement *form) @@ -3730,7 +3183,7 @@ void Server::SendHUDAdd(u16 peer_id, u32 id, HudElement *form) std::string s = os.str(); SharedBuffer<u8> data((u8*)s.c_str(), s.size()); // Send as reliable - m_con.Send(peer_id, 1, data, true); + m_clients.send(peer_id, 1, data, true); } void Server::SendHUDRemove(u16 peer_id, u32 id) @@ -3746,7 +3199,7 @@ void Server::SendHUDRemove(u16 peer_id, u32 id) SharedBuffer<u8> data((u8*)s.c_str(), s.size()); // Send as reliable - m_con.Send(peer_id, 1, data, true); + m_clients.send(peer_id, 1, data, true); } void Server::SendHUDChange(u16 peer_id, u32 id, HudElementStat stat, void *value) @@ -3783,7 +3236,7 @@ void Server::SendHUDChange(u16 peer_id, u32 id, HudElementStat stat, void *value std::string s = os.str(); SharedBuffer<u8> data((u8 *)s.c_str(), s.size()); // Send as reliable - m_con.Send(peer_id, 0, data, true); + m_clients.send(peer_id, 0, data, true); } void Server::SendHUDSetFlags(u16 peer_id, u32 flags, u32 mask) @@ -3799,7 +3252,7 @@ void Server::SendHUDSetFlags(u16 peer_id, u32 flags, u32 mask) std::string s = os.str(); SharedBuffer<u8> data((u8 *)s.c_str(), s.size()); // Send as reliable - m_con.Send(peer_id, 0, data, true); + m_clients.send(peer_id, 0, data, true); } void Server::SendHUDSetParam(u16 peer_id, u16 param, const std::string &value) @@ -3815,23 +3268,7 @@ void Server::SendHUDSetParam(u16 peer_id, u16 param, const std::string &value) std::string s = os.str(); SharedBuffer<u8> data((u8 *)s.c_str(), s.size()); // Send as reliable - m_con.Send(peer_id, 0, data, true); -} - -void Server::BroadcastChatMessage(const std::wstring &message) -{ - for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); ++i) - { - // Get client and check that it is valid - RemoteClient *client = i->second; - assert(client->peer_id == i->first); - if(client->serialization_version == SER_FMT_VER_INVALID) - continue; - - SendChatMessage(client->peer_id, message); - } + m_clients.send(peer_id, 0, data, true); } void Server::SendTimeOfDay(u16 peer_id, u16 time, f32 time_speed) @@ -3844,8 +3281,13 @@ void Server::SendTimeOfDay(u16 peer_id, u16 time, f32 time_speed) writeU16(&data[2], time); writeF1000(&data[4], time_speed); - // Send as reliable - m_con.Send(peer_id, 0, data, true); + if (peer_id == PEER_ID_INEXISTENT) { + m_clients.sendToAll(0,data,true); + } + else { + // Send as reliable + m_clients.send(peer_id, 0, data, true); + } } void Server::SendPlayerHP(u16 peer_id) @@ -3854,7 +3296,7 @@ void Server::SendPlayerHP(u16 peer_id) PlayerSAO *playersao = getPlayerSAO(peer_id); assert(playersao); playersao->m_hp_not_sent = false; - SendHP(m_con, peer_id, playersao->getHP()); + SendHP(peer_id, playersao->getHP()); // Send to other clients std::string str = gob_cmd_punched(playersao->readDamage(), playersao->getHP()); @@ -3868,7 +3310,7 @@ void Server::SendPlayerBreath(u16 peer_id) PlayerSAO *playersao = getPlayerSAO(peer_id); assert(playersao); playersao->m_breath_not_sent = false; - SendBreath(m_con, peer_id, playersao->getBreath()); + SendBreath(peer_id, playersao->getBreath()); } void Server::SendMovePlayer(u16 peer_id) @@ -3898,7 +3340,7 @@ void Server::SendMovePlayer(u16 peer_id) std::string s = os.str(); SharedBuffer<u8> data((u8*)s.c_str(), s.size()); // Send as reliable - m_con.Send(peer_id, 0, data, true); + m_clients.send(peer_id, 0, data, true); } void Server::SendPlayerPrivileges(u16 peer_id) @@ -3923,7 +3365,7 @@ void Server::SendPlayerPrivileges(u16 peer_id) std::string s = os.str(); SharedBuffer<u8> data((u8*)s.c_str(), s.size()); // Send as reliable - m_con.Send(peer_id, 0, data, true); + m_clients.send(peer_id, 0, data, true); } void Server::SendPlayerInventoryFormspec(u16 peer_id) @@ -3941,7 +3383,7 @@ void Server::SendPlayerInventoryFormspec(u16 peer_id) std::string s = os.str(); SharedBuffer<u8> data((u8*)s.c_str(), s.size()); // Send as reliable - m_con.Send(peer_id, 0, data, true); + m_clients.send(peer_id, 0, data, true); } s32 Server::playSound(const SimpleSoundSpec &spec, @@ -3953,8 +3395,9 @@ s32 Server::playSound(const SimpleSoundSpec &spec, // If position is not found while it should be, cancel sound if(pos_exists != (params.type != ServerSoundParams::SSP_LOCAL)) return -1; + // Filter destination clients - std::set<RemoteClient*> dst_clients; + std::list<u16> dst_clients; if(params.to_player != "") { Player *player = m_env->getPlayer(params.to_player.c_str()); @@ -3968,16 +3411,16 @@ s32 Server::playSound(const SimpleSoundSpec &spec, <<"\" not connected"<<std::endl; return -1; } - RemoteClient *client = getClient(player->peer_id); - dst_clients.insert(client); + dst_clients.push_back(player->peer_id); } else { - for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); i != m_clients.end(); ++i) + std::list<u16> clients = m_clients.getClientIDs(); + + for(std::list<u16>::iterator + i = clients.begin(); i != clients.end(); ++i) { - RemoteClient *client = i->second; - Player *player = m_env->getPlayer(client->peer_id); + Player *player = m_env->getPlayer(*i); if(!player) continue; if(pos_exists){ @@ -3985,20 +3428,21 @@ s32 Server::playSound(const SimpleSoundSpec &spec, params.max_hear_distance) continue; } - dst_clients.insert(client); + dst_clients.push_back(*i); } } if(dst_clients.size() == 0) return -1; + // Create the sound s32 id = m_next_sound_id++; // The sound will exist as a reference in m_playing_sounds m_playing_sounds[id] = ServerPlayingSound(); ServerPlayingSound &psound = m_playing_sounds[id]; psound.params = params; - for(std::set<RemoteClient*>::iterator i = dst_clients.begin(); + for(std::list<u16>::iterator i = dst_clients.begin(); i != dst_clients.end(); i++) - psound.clients.insert((*i)->peer_id); + psound.clients.insert(*i); // Create packet std::ostringstream os(std::ios_base::binary); writeU16(os, TOCLIENT_PLAY_SOUND); @@ -4013,10 +3457,10 @@ s32 Server::playSound(const SimpleSoundSpec &spec, std::string s = os.str(); SharedBuffer<u8> data((u8*)s.c_str(), s.size()); // Send - for(std::set<RemoteClient*>::iterator i = dst_clients.begin(); + for(std::list<u16>::iterator i = dst_clients.begin(); i != dst_clients.end(); i++){ // Send as reliable - m_con.Send((*i)->peer_id, 0, data, true); + m_clients.send(*i, 0, data, true); } return id; } @@ -4039,7 +3483,7 @@ void Server::stopSound(s32 handle) for(std::set<u16>::iterator i = psound.clients.begin(); i != psound.clients.end(); i++){ // Send as reliable - m_con.Send(*i, 0, data, true); + m_clients.send(*i, 0, data, true); } // Remove sound reference m_playing_sounds.erase(i); @@ -4059,38 +3503,29 @@ void Server::sendRemoveNode(v3s16 p, u16 ignore_id, writeS16(&reply[4], p.Y); writeS16(&reply[6], p.Z); - for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); ++i) + std::list<u16> clients = m_clients.getClientIDs(); + for(std::list<u16>::iterator + i = clients.begin(); + i != clients.end(); ++i) { - // Get client and check that it is valid - RemoteClient *client = i->second; - assert(client->peer_id == i->first); - if(client->serialization_version == SER_FMT_VER_INVALID) - continue; - - // Don't send if it's the same one - if(client->peer_id == ignore_id) - continue; - if(far_players) { // Get player - Player *player = m_env->getPlayer(client->peer_id); + Player *player = m_env->getPlayer(*i); if(player) { // If player is far away, only set modified blocks not sent v3f player_pos = player->getPosition(); if(player_pos.getDistanceFrom(p_f) > maxd) { - far_players->push_back(client->peer_id); + far_players->push_back(*i); continue; } } } // Send as reliable - m_con.Send(client->peer_id, 0, reply, true); + m_clients.send(*i, 0, reply, true); } } @@ -4101,69 +3536,71 @@ void Server::sendAddNode(v3s16 p, MapNode n, u16 ignore_id, float maxd = far_d_nodes*BS; v3f p_f = intToFloat(p, BS); - for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); ++i) - { - // Get client and check that it is valid - RemoteClient *client = i->second; - assert(client->peer_id == i->first); - if(client->serialization_version == SER_FMT_VER_INVALID) - continue; - - // Don't send if it's the same one - if(client->peer_id == ignore_id) - continue; + std::list<u16> clients = m_clients.getClientIDs(); + for(std::list<u16>::iterator + i = clients.begin(); + i != clients.end(); ++i) + { if(far_players) { // Get player - Player *player = m_env->getPlayer(client->peer_id); + Player *player = m_env->getPlayer(*i); if(player) { // If player is far away, only set modified blocks not sent v3f player_pos = player->getPosition(); if(player_pos.getDistanceFrom(p_f) > maxd) { - far_players->push_back(client->peer_id); + far_players->push_back(*i); continue; } } } - - // Create packet - u32 replysize = 9 + MapNode::serializedLength(client->serialization_version); - SharedBuffer<u8> reply(replysize); - writeU16(&reply[0], TOCLIENT_ADDNODE); - writeS16(&reply[2], p.X); - writeS16(&reply[4], p.Y); - writeS16(&reply[6], p.Z); - n.serialize(&reply[8], client->serialization_version); - u32 index = 8 + MapNode::serializedLength(client->serialization_version); - writeU8(&reply[index], remove_metadata ? 0 : 1); - - if (!remove_metadata) { - if (client->net_proto_version <= 21) { - // Old clients always clear metadata; fix it - // by sending the full block again. - client->SetBlockNotSent(p); + SharedBuffer<u8> reply(0); + m_clients.Lock(); + RemoteClient* client = m_clients.lockedGetClientNoEx(*i); + if (client != 0) + { + // Create packet + u32 replysize = 9 + MapNode::serializedLength(client->serialization_version); + reply = SharedBuffer<u8>(replysize); + writeU16(&reply[0], TOCLIENT_ADDNODE); + writeS16(&reply[2], p.X); + writeS16(&reply[4], p.Y); + writeS16(&reply[6], p.Z); + n.serialize(&reply[8], client->serialization_version); + u32 index = 8 + MapNode::serializedLength(client->serialization_version); + writeU8(&reply[index], remove_metadata ? 0 : 1); + + if (!remove_metadata) { + if (client->net_proto_version <= 21) { + // Old clients always clear metadata; fix it + // by sending the full block again. + client->SetBlockNotSent(p); + } } } + m_clients.Unlock(); // Send as reliable - m_con.Send(client->peer_id, 0, reply, true); + if (reply.getSize() > 0) + m_clients.send(*i, 0, reply, true); } } void Server::setBlockNotSent(v3s16 p) { - for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); ++i) + std::list<u16> clients = m_clients.getClientIDs(); + m_clients.Lock(); + for(std::list<u16>::iterator + i = clients.begin(); + i != clients.end(); ++i) { - RemoteClient *client = i->second; + RemoteClient *client = m_clients.lockedGetClientNoEx(*i); client->SetBlockNotSent(p); } + m_clients.Unlock(); } void Server::SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver, u16 net_proto_version) @@ -4217,7 +3654,7 @@ void Server::SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver, u16 net_proto /* Send packet */ - m_con.Send(peer_id, 2, reply, true); + m_clients.send(peer_id, 2, reply, true); } void Server::SendBlocks(float dtime) @@ -4225,7 +3662,7 @@ void Server::SendBlocks(float dtime) DSTACK(__FUNCTION_NAME); JMutexAutoLock envlock(m_env_mutex); - JMutexAutoLock conlock(m_con_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"); @@ -4236,25 +3673,22 @@ void Server::SendBlocks(float dtime) { ScopeProfiler sp(g_profiler, "Server: selecting blocks for sending"); - for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); ++i) + std::list<u16> clients = m_clients.getClientIDs(); + + m_clients.Lock(); + for(std::list<u16>::iterator + i = clients.begin(); + i != clients.end(); ++i) { - RemoteClient *client = i->second; - assert(client->peer_id == i->first); + RemoteClient *client = m_clients.lockedGetClientNoEx(*i,Active); - // If definitions and textures have not been sent, don't - // send MapBlocks either - if(!client->definitions_sent) - continue; + if (client == NULL) + return; total_sending += client->SendingCount(); - - if(client->serialization_version == SER_FMT_VER_INVALID) - continue; - - client->GetNextBlocks(this, dtime, queue); + client->GetNextBlocks(m_env,m_emerge, dtime, queue); } + m_clients.Unlock(); } // Sort. @@ -4262,6 +3696,7 @@ void Server::SendBlocks(float dtime) // Lowest is most important. std::sort(queue.begin(), queue.end()); + m_clients.Lock(); for(u32 i=0; i<queue.size(); i++) { //TODO: Calculate limit dynamically @@ -4281,18 +3716,17 @@ void Server::SendBlocks(float dtime) continue; } - RemoteClient *client = getClientNoEx(q.peer_id); + RemoteClient *client = m_clients.lockedGetClientNoEx(q.peer_id,Active); + if(!client) continue; - if(client->denied) - continue; SendBlockNoLock(q.peer_id, block, client->serialization_version, client->net_proto_version); client->SentBlock(q.pos); - total_sending++; } + m_clients.Unlock(); } void Server::fillMediaCache() @@ -4449,7 +3883,7 @@ void Server::sendMediaAnnouncement(u16 peer_id) SharedBuffer<u8> data((u8*)s.c_str(), s.size()); // Send as reliable - m_con.Send(peer_id, 0, data, true); + m_clients.send(peer_id, 0, data, true); } struct SendableMedia @@ -4579,7 +4013,7 @@ void Server::sendRequestedMedia(u16 peer_id, <<" size=" <<s.size()<<std::endl; SharedBuffer<u8> data((u8*)s.c_str(), s.size()); // Send as reliable - m_con.Send(peer_id, 2, data, true); + m_clients.send(peer_id, 2, data, true); } } @@ -4599,19 +4033,15 @@ void Server::sendDetachedInventory(const std::string &name, u16 peer_id) // Make data buffer std::string s = os.str(); SharedBuffer<u8> data((u8*)s.c_str(), s.size()); - // Send as reliable - m_con.Send(peer_id, 0, data, true); -} -void Server::sendDetachedInventoryToAll(const std::string &name) -{ - DSTACK(__FUNCTION_NAME); - - for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); ++i){ - RemoteClient *client = i->second; - sendDetachedInventory(name, client->peer_id); + if (peer_id != PEER_ID_INEXISTENT) + { + // Send as reliable + m_clients.send(peer_id, 0, data, true); + } + else + { + m_clients.sendToAll(0,data,true); } } @@ -4649,7 +4079,7 @@ void Server::DiePlayer(u16 peer_id) m_script->on_dieplayer(playersao); SendPlayerHP(peer_id); - SendDeathscreen(m_con, peer_id, false, v3f(0,0,0)); + SendDeathscreen(peer_id, false, v3f(0,0,0)); } void Server::RespawnPlayer(u16 peer_id) @@ -4676,132 +4106,93 @@ void Server::DenyAccess(u16 peer_id, const std::wstring &reason) { DSTACK(__FUNCTION_NAME); - SendAccessDenied(m_con, peer_id, reason); - - RemoteClient *client = getClientNoEx(peer_id); - if(client) - client->denied = true; - - // If there are way too many clients, get rid of denied new ones immediately - if((int)m_clients.size() > 2 * g_settings->getU16("max_users")){ - verbosestream<<"Server: DenyAccess: Too many clients; getting rid of " - <<"peer_id="<<peer_id<<" immediately"<<std::endl; - // Delete peer to stop sending it data - m_con.DeletePeer(peer_id); - // Delete client also to stop block sends and other stuff - DeleteClient(peer_id, CDR_DENY); - } + SendAccessDenied(peer_id, reason); + m_clients.event(peer_id,SetDenied); + m_con.DisconnectPeer(peer_id); } void Server::DeleteClient(u16 peer_id, ClientDeletionReason reason) { DSTACK(__FUNCTION_NAME); - - // Error check - std::map<u16, RemoteClient*>::iterator n; - n = m_clients.find(peer_id); - // The client may not exist; clients are immediately removed if their - // access is denied, and this event occurs later then. - if(n == m_clients.end()) - return; - - /* - Mark objects to be not known by the client - */ - RemoteClient *client = n->second; - // Handle objects - for(std::set<u16>::iterator - i = client->m_known_objects.begin(); - i != client->m_known_objects.end(); ++i) - { - // Get object - u16 id = *i; - ServerActiveObject* obj = m_env->getActiveObject(id); - - if(obj && obj->m_known_by_count > 0) - obj->m_known_by_count--; - } - - /* - Clear references to playing sounds - */ - for(std::map<s32, ServerPlayingSound>::iterator - i = m_playing_sounds.begin(); - i != m_playing_sounds.end();) + std::wstring message; { - ServerPlayingSound &psound = i->second; - psound.clients.erase(peer_id); - if(psound.clients.size() == 0) - m_playing_sounds.erase(i++); - else - i++; - } + /* + Clear references to playing sounds + */ + for(std::map<s32, ServerPlayingSound>::iterator + i = m_playing_sounds.begin(); + i != m_playing_sounds.end();) + { + ServerPlayingSound &psound = i->second; + psound.clients.erase(peer_id); + if(psound.clients.size() == 0) + m_playing_sounds.erase(i++); + else + i++; + } - Player *player = m_env->getPlayer(peer_id); + Player *player = m_env->getPlayer(peer_id); - // Collect information about leaving in chat - std::wstring message; - { - if(player != NULL && reason != CDR_DENY) + // Collect information about leaving in chat { - std::wstring name = narrow_to_wide(player->getName()); - message += L"*** "; - message += name; - message += L" left the game."; - if(reason == CDR_TIMEOUT) - message += L" (timed out)"; + if(player != NULL && reason != CDR_DENY) + { + std::wstring name = narrow_to_wide(player->getName()); + message += L"*** "; + message += name; + message += L" left the game."; + if(reason == CDR_TIMEOUT) + message += L" (timed out)"; + } } - } - /* Run scripts and remove from environment */ - { - if(player != NULL) + /* Run scripts and remove from environment */ { - PlayerSAO *playersao = player->getPlayerSAO(); - assert(playersao); + if(player != NULL) + { + PlayerSAO *playersao = player->getPlayerSAO(); + assert(playersao); - m_script->on_leaveplayer(playersao); + m_script->on_leaveplayer(playersao); - playersao->disconnected(); + playersao->disconnected(); + } } - } - /* - Print out action - */ - { - if(player != NULL && reason != CDR_DENY) + /* + Print out action + */ { - std::ostringstream os(std::ios_base::binary); - for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); ++i) + if(player != NULL && reason != CDR_DENY) { - RemoteClient *client = i->second; - assert(client->peer_id == i->first); - if(client->serialization_version == SER_FMT_VER_INVALID) - continue; - // Get player - Player *player = m_env->getPlayer(client->peer_id); - if(!player) - continue; - // Get name of player - os<<player->getName()<<" "; - } + std::ostringstream os(std::ios_base::binary); + std::list<u16> clients = m_clients.getClientIDs(); + + for(std::list<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()<<" "; + } - 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; + } } + m_env_mutex.Lock(); + m_clients.DeleteClient(peer_id); + m_env_mutex.Unlock(); } - // Delete client - delete m_clients[peer_id]; - m_clients.erase(peer_id); - // Send leave chat message to all remaining clients if(message.length() != 0) - BroadcastChatMessage(message); + SendChatMessage(PEER_ID_INEXISTENT,message); } void Server::UpdateCrafting(u16 peer_id) @@ -4825,22 +4216,17 @@ void Server::UpdateCrafting(u16 peer_id) plist->changeItem(0, preview); } -RemoteClient* Server::getClient(u16 peer_id) +RemoteClient* Server::getClient(u16 peer_id, ClientState state_min) { - RemoteClient *client = getClientNoEx(peer_id); + RemoteClient *client = getClientNoEx(peer_id,state_min); if(!client) throw ClientNotFoundException("Client not found"); + return client; } -RemoteClient* Server::getClientNoEx(u16 peer_id) +RemoteClient* Server::getClientNoEx(u16 peer_id, ClientState state_min) { - std::map<u16, RemoteClient*>::iterator n; - n = m_clients.find(peer_id); - // The client may not exist; clients are immediately removed if their - // access is denied, and this event occurs later then. - if(n == m_clients.end()) - return NULL; - return n->second; + return m_clients.getClientNoEx(peer_id, state_min); } std::string Server::getPlayerName(u16 peer_id) @@ -4870,19 +4256,14 @@ std::wstring Server::getStatusString() // Max lag estimate os<<L", max_lag="<<m_env->getMaxLagEstimate(); // Information about clients - std::map<u16, RemoteClient*>::iterator i; - bool first; + bool first = true; os<<L", clients={"; - for(i = m_clients.begin(), first = true; - i != m_clients.end(); ++i) + std::list<u16> clients = m_clients.getClientIDs(); + for(std::list<u16>::iterator i = clients.begin(); + i != clients.end(); ++i) { - // Get client and check that it is valid - RemoteClient *client = i->second; - assert(client->peer_id == i->first); - if(client->serialization_version == SER_FMT_VER_INVALID) - continue; // Get player - Player *player = m_env->getPlayer(client->peer_id); + Player *player = m_env->getPlayer(*i); // Get name of player std::wstring name = L"unknown"; if(player != NULL) @@ -4918,11 +4299,11 @@ bool Server::checkPriv(const std::string &name, const std::string &priv) void Server::reportPrivsModified(const std::string &name) { if(name == ""){ - for(std::map<u16, RemoteClient*>::iterator - i = m_clients.begin(); - i != m_clients.end(); ++i){ - RemoteClient *client = i->second; - Player *player = m_env->getPlayer(client->peer_id); + std::list<u16> clients = m_clients.getClientIDs(); + for(std::list<u16>::iterator + i = clients.begin(); + i != clients.end(); ++i){ + Player *player = m_env->getPlayer(*i); reportPrivsModified(player->getName()); } } else { @@ -5056,7 +4437,7 @@ void Server::hudSetHotbarSelectedImage(Player *player, std::string name) { void Server::notifyPlayers(const std::wstring msg) { - BroadcastChatMessage(msg); + SendChatMessage(PEER_ID_INEXISTENT,msg); } void Server::spawnParticle(const char *playername, v3f pos, @@ -5075,7 +4456,7 @@ void Server::spawnParticleAll(v3f pos, v3f velocity, v3f acceleration, float expirationtime, float size, bool collisiondetection, bool vertical, std::string texture) { - SendSpawnParticleAll(pos, velocity, acceleration, + SendSpawnParticle(PEER_ID_INEXISTENT,pos, velocity, acceleration, expirationtime, size, collisiondetection, vertical, texture); } @@ -5134,7 +4515,7 @@ u32 Server::addParticleSpawnerAll(u16 amount, float spawntime, } } - SendAddParticleSpawnerAll(amount, spawntime, + SendAddParticleSpawner(PEER_ID_INEXISTENT, amount, spawntime, minpos, maxpos, minvel, maxvel, minacc, maxacc, minexptime, maxexptime, minsize, maxsize, collisiondetection, vertical, texture, id); @@ -5161,7 +4542,7 @@ void Server::deleteParticleSpawnerAll(u32 id) std::remove(m_particlespawner_ids.begin(), m_particlespawner_ids.end(), id), m_particlespawner_ids.end()); - SendDeleteParticleSpawnerAll(id); + SendDeleteParticleSpawner(PEER_ID_INEXISTENT, id); } Inventory* Server::createDetachedInventory(const std::string &name) @@ -5175,7 +4556,8 @@ Inventory* Server::createDetachedInventory(const std::string &name) Inventory *inv = new Inventory(m_itemdef); assert(inv); m_detached_inventories[name] = inv; - sendDetachedInventoryToAll(name); + //TODO find a better way to do this + sendDetachedInventory(name,PEER_ID_INEXISTENT); return inv; } @@ -5444,63 +4826,9 @@ PlayerSAO* Server::emergePlayer(const char *name, u16 peer_id) if(newplayer) m_script->on_newplayer(playersao); - m_script->on_joinplayer(playersao); - return playersao; } -void Server::handlePeerChange(PeerChange &c) -{ - JMutexAutoLock envlock(m_env_mutex); - JMutexAutoLock conlock(m_con_mutex); - - if(c.type == PEER_ADDED) - { - /* - Add - */ - - // Error check - std::map<u16, RemoteClient*>::iterator n; - n = m_clients.find(c.peer_id); - // The client shouldn't already exist - assert(n == m_clients.end()); - - // Create client - RemoteClient *client = new RemoteClient(); - client->peer_id = c.peer_id; - m_clients[client->peer_id] = client; - - } // PEER_ADDED - else if(c.type == PEER_REMOVED) - { - /* - Delete - */ - - DeleteClient(c.peer_id, c.timeout?CDR_TIMEOUT:CDR_LEAVE); - - } // PEER_REMOVED - else - { - assert(0); - } -} - -void Server::handlePeerChanges() -{ - while(m_peer_change_queue.size() > 0) - { - PeerChange c = m_peer_change_queue.pop_front(); - - verbosestream<<"Server: Handling peer change: " - <<"id="<<c.peer_id<<", timeout="<<c.timeout - <<std::endl; - - handlePeerChange(c); - } -} - void dedicated_server_loop(Server &server, bool &kill) { DSTACK(__FUNCTION_NAME); diff --git a/src/server.h b/src/server.h index 1163400f7..94b0b6a2d 100644 --- a/src/server.h +++ b/src/server.h @@ -33,6 +33,7 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "util/numeric.h" #include "util/thread.h" #include "environment.h" +#include "clientiface.h" #include <string> #include <list> #include <map> @@ -53,14 +54,19 @@ class EmergeManager; class GameScripting; class ServerEnvironment; struct SimpleSoundSpec; +class ServerThread; +enum ClientDeletionReason { + CDR_LEAVE, + CDR_TIMEOUT, + CDR_DENY +}; /* Some random functions */ v3f findSpawnPos(ServerMap &map); - class MapEditEventIgnorer { public: @@ -111,31 +117,6 @@ private: VoxelArea *m_ignorevariable; }; -class Server; -class ServerThread; - -/* - Used for queueing and sorting block transfers in containers - - Lower priority number means higher priority. -*/ -struct PrioritySortedBlockTransfer -{ - PrioritySortedBlockTransfer(float a_priority, v3s16 a_pos, u16 a_peer_id) - { - priority = a_priority; - pos = a_pos; - peer_id = a_peer_id; - } - bool operator < (const PrioritySortedBlockTransfer &other) const - { - return priority < other.priority; - } - float priority; - v3s16 pos; - u16 peer_id; -}; - struct MediaInfo { std::string path; @@ -182,134 +163,6 @@ struct ServerPlayingSound std::set<u16> clients; // peer ids }; -class RemoteClient -{ -public: - // peer_id=0 means this client has no associated peer - // NOTE: If client is made allowed to exist while peer doesn't, - // this has to be set to 0 when there is no peer. - // Also, the client must be moved to some other container. - u16 peer_id; - // The serialization version to use with the client - u8 serialization_version; - // - u16 net_proto_version; - // Version is stored in here after INIT before INIT2 - u8 pending_serialization_version; - - bool definitions_sent; - - bool denied; - - RemoteClient(): - m_time_from_building(9999), - m_excess_gotblocks(0) - { - peer_id = 0; - serialization_version = SER_FMT_VER_INVALID; - net_proto_version = 0; - pending_serialization_version = SER_FMT_VER_INVALID; - definitions_sent = false; - denied = false; - m_nearest_unsent_d = 0; - m_nearest_unsent_reset_timer = 0.0; - m_nothing_to_send_counter = 0; - m_nothing_to_send_pause_timer = 0; - } - ~RemoteClient() - { - } - - /* - Finds block that should be sent next to the client. - Environment should be locked when this is called. - dtime is used for resetting send radius at slow interval - */ - void GetNextBlocks(Server *server, float dtime, - std::vector<PrioritySortedBlockTransfer> &dest); - - void GotBlock(v3s16 p); - - void SentBlock(v3s16 p); - - void SetBlockNotSent(v3s16 p); - void SetBlocksNotSent(std::map<v3s16, MapBlock*> &blocks); - - s32 SendingCount() - { - return m_blocks_sending.size(); - } - - // Increments timeouts and removes timed-out blocks from list - // NOTE: This doesn't fix the server-not-sending-block bug - // because it is related to emerging, not sending. - //void RunSendingTimeouts(float dtime, float timeout); - - void PrintInfo(std::ostream &o) - { - o<<"RemoteClient "<<peer_id<<": " - <<"m_blocks_sent.size()="<<m_blocks_sent.size() - <<", m_blocks_sending.size()="<<m_blocks_sending.size() - <<", m_nearest_unsent_d="<<m_nearest_unsent_d - <<", m_excess_gotblocks="<<m_excess_gotblocks - <<std::endl; - m_excess_gotblocks = 0; - } - - // Time from last placing or removing blocks - float m_time_from_building; - - /*JMutex m_dig_mutex; - float m_dig_time_remaining; - // -1 = not digging - s16 m_dig_tool_item; - v3s16 m_dig_position;*/ - - /* - List of active objects that the client knows of. - Value is dummy. - */ - std::set<u16> m_known_objects; - -private: - /* - Blocks that have been sent to client. - - These don't have to be sent again. - - A block is cleared from here when client says it has - deleted it from it's memory - - Key is position, value is dummy. - No MapBlock* is stored here because the blocks can get deleted. - */ - std::set<v3s16> m_blocks_sent; - s16 m_nearest_unsent_d; - v3s16 m_last_center; - float m_nearest_unsent_reset_timer; - - /* - Blocks that are currently on the line. - This is used for throttling the sending of blocks. - - The size of this list is limited to some value - Block is added when it is sent with BLOCKDATA. - Block is removed when GOTBLOCKS is received. - Value is time from sending. (not used at the moment) - */ - std::map<v3s16, float> m_blocks_sending; - - /* - Count of excess GotBlocks(). - There is an excess amount because the client sometimes - gets a block so late that the server sends it again, - and the client then sends two GOTBLOCKs. - This is resetted by PrintInfo() - */ - u32 m_excess_gotblocks; - - // CPU usage optimization - u32 m_nothing_to_send_counter; - float m_nothing_to_send_pause_timer; -}; - class Server : public con::PeerHandler, public MapEventReceiver, public InventoryManager, public IGameDef { @@ -337,11 +190,6 @@ public: // Environment must be locked when called void setTimeOfDay(u32 time); - bool getShutdownRequested() - { - return m_shutdown_requested; - } - /* Shall be called with the environment locked. This is accessed by the map, which is inside the environment, @@ -358,17 +206,20 @@ public: // Connection must be locked when called std::wstring getStatusString(); - void requestShutdown(void) - { - m_shutdown_requested = true; - } + // read shutdown state + inline bool getShutdownRequested() + { return m_shutdown_requested; } + + // request server to shutdown + inline void requestShutdown(void) + { m_shutdown_requested = true; } // Returns -1 if failed, sound handle on success - // Envlock + conlock + // Envlock s32 playSound(const SimpleSoundSpec &spec, const ServerSoundParams ¶ms); void stopSound(s32 handle); - // Envlock + conlock + // Envlock std::set<std::string> getPlayerEffectivePrivs(const std::string &name); bool checkPriv(const std::string &name, const std::string &priv); void reportPrivsModified(const std::string &name=""); // ""=all @@ -378,12 +229,6 @@ public: void unsetIpBanned(const std::string &ip_or_name); std::string getBanDescription(const std::string &ip_or_name); - Address getPeerAddress(u16 peer_id) - { - return m_con.GetPeerAddress(peer_id); - } - - // Envlock and conlock should be locked when calling this void notifyPlayer(const char *name, const std::wstring msg, const bool prepend); void notifyPlayers(const std::wstring msg); void spawnParticle(const char *playername, @@ -451,15 +296,14 @@ public: const ModSpec* getModSpec(const std::string &modname); void getModNames(std::list<std::string> &modlist); std::string getBuiltinLuaPath(); + inline std::string getWorldPath() + { return m_path_world; } - std::string getWorldPath(){ return m_path_world; } - - bool isSingleplayer(){ return m_simple_singleplayer_mode; } + inline bool isSingleplayer() + { return m_simple_singleplayer_mode; } - void setAsyncFatalError(const std::string &error) - { - m_async_fatal_error.set(error); - } + inline void setAsyncFatalError(const std::string &error) + { m_async_fatal_error.set(error); } bool showFormspec(const char *name, const std::string &formspec, const std::string &formname); Map & getMap() { return m_env->getMap(); } @@ -473,41 +317,32 @@ public: void hudSetHotbarImage(Player *player, std::string name); void hudSetHotbarSelectedImage(Player *player, std::string name); -private: + inline Address getPeerAddress(u16 peer_id) + { return m_con.GetPeerAddress(peer_id); } - // con::PeerHandler implementation. - // These queue stuff to be processed by handlePeerChanges(). - // As of now, these create and remove clients and players. + /* con::PeerHandler implementation. */ void peerAdded(con::Peer *peer); void deletingPeer(con::Peer *peer, bool timeout); - /* - Static send methods - */ +private: - static void SendMovement(con::Connection &con, u16 peer_id); - static void SendHP(con::Connection &con, u16 peer_id, u8 hp); - static void SendBreath(con::Connection &con, u16 peer_id, u16 breath); - static void SendAccessDenied(con::Connection &con, u16 peer_id, - const std::wstring &reason); - static void SendDeathscreen(con::Connection &con, u16 peer_id, - bool set_camera_point_target, v3f camera_point_target); - static void SendItemDef(con::Connection &con, u16 peer_id, - IItemDefManager *itemdef, u16 protocol_version); - static void SendNodeDef(con::Connection &con, u16 peer_id, - INodeDefManager *nodedef, u16 protocol_version); + friend class EmergeThread; + friend class RemoteClient; - /* - Non-static send methods. - Conlock should be always used. - Envlock usage is documented badly but it's easy to figure out - which ones access the environment. - */ + void SendMovement(u16 peer_id); + void SendHP(u16 peer_id, u8 hp); + void SendBreath(u16 peer_id, u16 breath); + void SendAccessDenied(u16 peer_id,const std::wstring &reason); + void SendDeathscreen(u16 peer_id,bool set_camera_point_target, v3f camera_point_target); + void SendItemDef(u16 peer_id,IItemDefManager *itemdef, u16 protocol_version); + void SendNodeDef(u16 peer_id,INodeDefManager *nodedef, u16 protocol_version); + + /* mark blocks not sent for all clients */ + void SetBlocksNotSent(std::map<v3s16, MapBlock *>& block); // Envlock and conlock should be locked when calling these void SendInventory(u16 peer_id); void SendChatMessage(u16 peer_id, const std::wstring &message); - void BroadcastChatMessage(const std::wstring &message); void SendTimeOfDay(u16 peer_id, u16 time, f32 time_speed); void SendPlayerHP(u16 peer_id); void SendPlayerBreath(u16 peer_id); @@ -546,10 +381,9 @@ private: const std::list<std::string> &tosend); void sendDetachedInventory(const std::string &name, u16 peer_id); - void sendDetachedInventoryToAll(const std::string &name); void sendDetachedInventories(u16 peer_id); - // Adds a ParticleSpawner on peer with peer_id + // Adds a ParticleSpawner on peer with peer_id (PEER_ID_INEXISTENT == all) void SendAddParticleSpawner(u16 peer_id, u16 amount, float spawntime, v3f minpos, v3f maxpos, v3f minvel, v3f maxvel, @@ -558,32 +392,14 @@ private: float minsize, float maxsize, bool collisiondetection, bool vertical, std::string texture, u32 id); - // Adds a ParticleSpawner on all peers - void SendAddParticleSpawnerAll(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); - - // Deletes ParticleSpawner on a single client void SendDeleteParticleSpawner(u16 peer_id, u32 id); - // Deletes ParticleSpawner on all clients - void SendDeleteParticleSpawnerAll(u32 id); - - // Spawns particle on single client + // Spawns particle on peer with peer_id (PEER_ID_INEXISTENT == all) void SendSpawnParticle(u16 peer_id, v3f pos, v3f velocity, v3f acceleration, float expirationtime, float size, bool collisiondetection, bool vertical, std::string texture); - // Spawns particle on all clients - void SendSpawnParticleAll(v3f pos, v3f velocity, v3f acceleration, - float expirationtime, float size, - bool collisiondetection, bool vertical, std::string texture); - /* Something random */ @@ -591,19 +407,12 @@ private: void DiePlayer(u16 peer_id); void RespawnPlayer(u16 peer_id); void DenyAccess(u16 peer_id, const std::wstring &reason); - - enum ClientDeletionReason { - CDR_LEAVE, - CDR_TIMEOUT, - CDR_DENY - }; void DeleteClient(u16 peer_id, ClientDeletionReason reason); - void UpdateCrafting(u16 peer_id); // When called, connection mutex should be locked - RemoteClient* getClient(u16 peer_id); - RemoteClient* getClientNoEx(u16 peer_id); + RemoteClient* getClient(u16 peer_id,ClientState state_min=Active); + RemoteClient* getClientNoEx(u16 peer_id,ClientState state_min=Active); // When called, environment mutex should be locked std::string getPlayerName(u16 peer_id); @@ -618,9 +427,6 @@ private: */ PlayerSAO *emergePlayer(const char *name, u16 peer_id); - // Locks environment and connection by its own - struct PeerChange; - void handlePeerChange(PeerChange &c); void handlePeerChanges(); /* @@ -648,19 +454,12 @@ private: float m_savemap_timer; IntervalLimiter m_map_timer_and_unload_interval; - // NOTE: If connection and environment are both to be locked, - // environment shall be locked first. - // Environment ServerEnvironment *m_env; JMutex m_env_mutex; - // Connection + // server connection con::Connection m_con; - JMutex m_con_mutex; - // Connected clients (behind the con mutex) - std::map<u16, RemoteClient*> m_clients; - std::vector<std::string> m_clients_names; //for announcing masterserver // Ban checking BanManager *m_banmanager; @@ -701,6 +500,7 @@ private: float m_step_dtime; JMutex m_step_dtime_mutex; + // current server step lag counter float m_lag; // The server mainly operates in this thread @@ -716,22 +516,16 @@ private: MutexedVariable<double> m_uptime; /* + Client interface + */ + ClientInterface m_clients; + + /* Peer change queue. Queues stuff from peerAdded() and deletingPeer() to handlePeerChanges() */ - enum PeerChangeType - { - PEER_ADDED, - PEER_REMOVED - }; - struct PeerChange - { - PeerChangeType type; - u16 peer_id; - bool timeout; - }; - Queue<PeerChange> m_peer_change_queue; + Queue<con::PeerChange> m_peer_change_queue; /* Random stuff @@ -776,9 +570,7 @@ private: */ u16 m_ignore_map_edit_events_peer_id; - friend class EmergeThread; - friend class RemoteClient; - + // media files known to server std::map<std::string,MediaInfo> m_media; /* |