summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/ClientHandle.cpp365
-rw-r--r--src/ClientHandle.h32
2 files changed, 229 insertions, 168 deletions
diff --git a/src/ClientHandle.cpp b/src/ClientHandle.cpp
index 1badbdaf7..a4b176efa 100644
--- a/src/ClientHandle.cpp
+++ b/src/ClientHandle.cpp
@@ -160,30 +160,34 @@ void cClientHandle::Destroy(void)
m_Link.reset();
}
{
- cCSLock Lock(m_CSDestroyingState);
+ cCSLock Lock(m_CSState);
if (m_State >= csDestroying)
{
// Already called
+ LOGD("%s: client %p, \"%s\" already destroyed, bailing out", __FUNCTION__, static_cast<void *>(this), m_Username.c_str());
return;
}
m_State = csDestroying;
}
- LOGD("%s: client %p, \"%s\"", __FUNCTION__, static_cast<void *>(this), m_Username.c_str());
+ LOGD("%s: destroying client %p, \"%s\" @ %s", __FUNCTION__, static_cast<void *>(this), m_Username.c_str(), m_IPString.c_str());
+ {
+ cCSLock lock(m_CSState);
+ m_State = csDestroyed;
+ }
- if (m_Player != nullptr)
+ auto player = m_Player;
+ if (player != nullptr)
{
- cWorld * World = m_Player->GetWorld();
- if (World != nullptr)
+ auto world = player->GetWorld();
+ if (world != nullptr)
{
- m_Player->StopEveryoneFromTargetingMe();
- m_Player->SetIsTicking(false);
- World->RemovePlayer(m_Player, true);
+ player->StopEveryoneFromTargetingMe();
+ player->SetIsTicking(false);
+ world->RemovePlayer(player, true);
}
- m_Player->RemoveClientHandle();
+ player->RemoveClientHandle();
}
-
- m_State = csDestroyed;
}
@@ -318,84 +322,100 @@ void cClientHandle::Kick(const AString & a_Reason)
void cClientHandle::Authenticate(const AString & a_Name, const AString & a_UUID, const Json::Value & a_Properties)
{
- if (m_State != csAuthenticating)
+ cWorld * World;
{
- return;
- }
+ cCSLock lock(m_CSState);
+ /*
+ LOGD("Processing authentication for client %s @ %s (%p), state = %d",
+ m_Username.c_str(), m_IPString.c_str(), static_cast<void *>(this), m_State.load()
+ );
+ //*/
- ASSERT(m_Player == nullptr);
+ if (m_State != csAuthenticating)
+ {
+ return;
+ }
- m_Username = a_Name;
+ ASSERT(m_Player == nullptr);
- // Only assign UUID and properties if not already pre-assigned (BungeeCord sends those in the Handshake packet):
- if (m_UUID.empty())
- {
- m_UUID = a_UUID;
- }
- if (m_Properties.empty())
- {
- m_Properties = a_Properties;
- }
+ m_Username = a_Name;
- // Send login success (if the protocol supports it):
- m_Protocol->SendLoginSuccess();
+ // Only assign UUID and properties if not already pre-assigned (BungeeCord sends those in the Handshake packet):
+ if (m_UUID.empty())
+ {
+ m_UUID = a_UUID;
+ }
+ if (m_Properties.empty())
+ {
+ m_Properties = a_Properties;
+ }
- // Spawn player (only serversided, so data is loaded)
- m_Player = new cPlayer(m_Self, GetUsername());
- InvalidateCachedSentChunk();
- m_Self.reset();
+ // Send login success (if the protocol supports it):
+ m_Protocol->SendLoginSuccess();
- cWorld * World = cRoot::Get()->GetWorld(m_Player->GetLoadedWorldName());
- if (World == nullptr)
- {
- World = cRoot::Get()->GetDefaultWorld();
- m_Player->SetPosition(World->GetSpawnX(), World->GetSpawnY(), World->GetSpawnZ());
- }
+ // Spawn player (only serversided, so data is loaded)
+ m_Player = new cPlayer(m_Self, GetUsername());
+ /*
+ LOGD("Created a new cPlayer object at %p for client %s @ %s (%p)",
+ static_cast<void *>(m_Player),
+ m_Username.c_str(), m_IPString.c_str(), static_cast<void *>(this)
+ );
+ //*/
+ InvalidateCachedSentChunk();
+ m_Self.reset();
- if (m_Player->GetGameMode() == eGameMode_NotSet)
- {
- m_Player->LoginSetGameMode(World->GetGameMode());
- }
+ World = cRoot::Get()->GetWorld(m_Player->GetLoadedWorldName());
+ if (World == nullptr)
+ {
+ World = cRoot::Get()->GetDefaultWorld();
+ m_Player->SetPosition(World->GetSpawnX(), World->GetSpawnY(), World->GetSpawnZ());
+ }
- m_Player->SetIP (m_IPString);
+ if (m_Player->GetGameMode() == eGameMode_NotSet)
+ {
+ m_Player->LoginSetGameMode(World->GetGameMode());
+ }
- if (!cRoot::Get()->GetPluginManager()->CallHookPlayerJoined(*m_Player))
- {
- cRoot::Get()->BroadcastChatJoin(Printf("%s has joined the game", GetUsername().c_str()));
- LOGINFO("Player %s has joined the game", m_Username.c_str());
- }
+ m_Player->SetIP (m_IPString);
- m_ConfirmPosition = m_Player->GetPosition();
+ if (!cRoot::Get()->GetPluginManager()->CallHookPlayerJoined(*m_Player))
+ {
+ cRoot::Get()->BroadcastChatJoin(Printf("%s has joined the game", GetUsername().c_str()));
+ LOGINFO("Player %s has joined the game", m_Username.c_str());
+ }
- // Return a server login packet
- m_Protocol->SendLogin(*m_Player, *World);
- m_LastSentDimension = World->GetDimension();
+ m_ConfirmPosition = m_Player->GetPosition();
- // Send Weather if raining:
- if ((World->GetWeather() == 1) || (World->GetWeather() == 2))
- {
- m_Protocol->SendWeather(World->GetWeather());
- }
+ // Return a server login packet
+ m_Protocol->SendLogin(*m_Player, *World);
+ m_LastSentDimension = World->GetDimension();
- // Send time:
- m_Protocol->SendTimeUpdate(World->GetWorldAge(), World->GetTimeOfDay(), World->IsDaylightCycleEnabled());
+ // Send Weather if raining:
+ if ((World->GetWeather() == 1) || (World->GetWeather() == 2))
+ {
+ m_Protocol->SendWeather(World->GetWeather());
+ }
- // Send contents of the inventory window
- m_Protocol->SendWholeInventory(*m_Player->GetWindow());
+ // Send time:
+ m_Protocol->SendTimeUpdate(World->GetWorldAge(), World->GetTimeOfDay(), World->IsDaylightCycleEnabled());
- // Send health
- m_Player->SendHealth();
+ // Send contents of the inventory window
+ m_Protocol->SendWholeInventory(*m_Player->GetWindow());
- // Send experience
- m_Player->SendExperience();
+ // Send health
+ m_Player->SendHealth();
- // Send player list items
- SendPlayerListAddPlayer(*m_Player);
- cRoot::Get()->BroadcastPlayerListsAddPlayer(*m_Player);
- cRoot::Get()->SendPlayerLists(m_Player);
+ // Send experience
+ m_Player->SendExperience();
- m_Player->SetWorld(World);
- m_State = csAuthenticated;
+ // Send player list items
+ SendPlayerListAddPlayer(*m_Player);
+ cRoot::Get()->BroadcastPlayerListsAddPlayer(*m_Player);
+ cRoot::Get()->SendPlayerLists(m_Player);
+
+ m_Player->SetWorld(World);
+ m_State = csAuthenticated;
+ }
// Query player team
m_Player->UpdateTeam();
@@ -411,6 +431,7 @@ void cClientHandle::Authenticate(const AString & a_Name, const AString & a_UUID,
m_PingStartTime = std::chrono::steady_clock::now() + std::chrono::seconds(3); // Send the first KeepAlive packet in 3 seconds
cRoot::Get()->GetPluginManager()->CallHookPlayerSpawned(*m_Player);
+ // LOGD("Client %s @ %s (%p) has been fully authenticated", m_Username.c_str(), m_IPString.c_str(), static_cast<void *>(this));
}
@@ -661,23 +682,38 @@ void cClientHandle::HandlePing(void)
bool cClientHandle::HandleLogin(UInt32 a_ProtocolVersion, const AString & a_Username)
{
- // If the protocol version hasn't been set yet, set it now:
- if (m_ProtocolVersion == 0)
{
- m_ProtocolVersion = a_ProtocolVersion;
- }
+ cCSLock lock(m_CSState);
+ if (m_State != csConnected)
+ {
+ /*
+ LOGD("Client %s @ %s (%p, state %d) has disconnected before logging in, bailing out of login",
+ a_Username.c_str(), m_IPString.c_str(), static_cast<void *>(this), m_State.load()
+ );
+ //*/
+ return false;
+ }
- m_Username = a_Username;
+ // LOGD("Handling login for client %s @ %s (%p), state = %d", a_Username.c_str(), m_IPString.c_str(), static_cast<void *>(this), m_State.load());
- // Let the plugins know about this event, they may refuse the player:
- if (cRoot::Get()->GetPluginManager()->CallHookLogin(*this, a_ProtocolVersion, a_Username))
- {
- Destroy();
- return false;
- }
+ // If the protocol version hasn't been set yet, set it now:
+ if (m_ProtocolVersion == 0)
+ {
+ m_ProtocolVersion = a_ProtocolVersion;
+ }
+
+ m_Username = a_Username;
+
+ // Let the plugins know about this event, they may refuse the player:
+ if (cRoot::Get()->GetPluginManager()->CallHookLogin(*this, a_ProtocolVersion, a_Username))
+ {
+ Destroy();
+ return false;
+ }
+ m_State = csAuthenticating;
+ } // lock(m_CSState)
// Schedule for authentication; until then, let the player wait (but do not block)
- m_State = csAuthenticating;
cRoot::Get()->GetAuthenticator().Authenticate(GetUniqueID(), GetUsername(), m_Protocol->GetAuthServerID());
return true;
}
@@ -2007,31 +2043,7 @@ void cClientHandle::Tick(float a_Dt)
m_BreakProgress += m_Player->GetPlayerRelativeBlockHardness(Block);
}
- // Process received network data:
- AString IncomingData;
- {
- cCSLock Lock(m_CSIncomingData);
- std::swap(IncomingData, m_IncomingData);
- }
- if (!IncomingData.empty())
- {
- m_Protocol->DataReceived(IncomingData.data(), IncomingData.size());
- }
-
- // Send any queued outgoing data:
- AString OutgoingData;
- {
- cCSLock Lock(m_CSOutgoingData);
- std::swap(OutgoingData, m_OutgoingData);
- }
- if (!OutgoingData.empty())
- {
- cTCPLinkPtr Link(m_Link); // Grab a copy of the link in a multithread-safe way
- if ((Link != nullptr))
- {
- Link->Send(OutgoingData.data(), OutgoingData.size());
- }
- }
+ ProcessProtocolInOut();
m_TicksSinceLastPacket += 1;
if (m_TicksSinceLastPacket > 600) // 30 seconds time-out
@@ -2040,17 +2052,27 @@ void cClientHandle::Tick(float a_Dt)
return;
}
- if (m_Player == nullptr)
+ // If destruction is queued, destroy now:
+ if (m_State == csQueuedForDestruction)
{
+ LOGD("Client %s @ %s (%p) has been queued for destruction, destroying now.",
+ m_Username.c_str(), m_IPString.c_str(), static_cast<void *>(this)
+ );
+ Destroy();
return;
}
+ // Only process further if the player object is valid:
+ if (m_Player == nullptr)
+ {
+ return;
+ }
- // Freeze the player if it is standing on a chunk not yet sent to the client
+ // Freeze the player if they are standing in a chunk not yet sent to the client
m_HasSentPlayerChunk = false;
if (m_Player->GetParentChunk() != nullptr)
{
- // If the chunk is invalid, do not bother checking if it's sent to the client, it is definitely not
+ // If the chunk is invalid, it has definitely not been sent to the client yet
if (m_Player->GetParentChunk()->IsValid())
{
// Before iterating m_SentChunks, see if the player's coords equal m_CachedSentChunk
@@ -2075,11 +2097,14 @@ void cClientHandle::Tick(float a_Dt)
}
// If the chunk the player's in was just sent, spawn the player:
- if (m_HasSentPlayerChunk && (m_State == csDownloadingWorld))
{
- m_Protocol->SendPlayerMoveLook();
- m_State = csPlaying;
- }
+ cCSLock lock(m_CSState);
+ if (m_HasSentPlayerChunk && (m_State == csDownloadingWorld))
+ {
+ m_Protocol->SendPlayerMoveLook();
+ m_State = csPlaying;
+ }
+ } // lock(m_CSState)
// Send a ping packet:
if (m_State == csPlaying)
@@ -2092,7 +2117,7 @@ void cClientHandle::Tick(float a_Dt)
}
}
- if ((m_State >= csAuthenticated) && (m_State < csDestroying))
+ if ((m_State >= csAuthenticated) && (m_State < csQueuedForDestruction))
{
// Stream 4 chunks per tick
for (int i = 0; i < 4; i++)
@@ -2138,40 +2163,33 @@ void cClientHandle::Tick(float a_Dt)
void cClientHandle::ServerTick(float a_Dt)
{
- // Process received network data:
- AString IncomingData;
- {
- cCSLock Lock(m_CSIncomingData);
- std::swap(IncomingData, m_IncomingData);
- }
- if (!IncomingData.empty())
- {
- m_Protocol->DataReceived(IncomingData.data(), IncomingData.size());
- }
+ ProcessProtocolInOut();
- // Send any queued outgoing data:
- AString OutgoingData;
- {
- cCSLock Lock(m_CSOutgoingData);
- std::swap(OutgoingData, m_OutgoingData);
- }
- if ((m_Link != nullptr) && !OutgoingData.empty())
+ // If destruction is queued, destroy now:
+ if (m_State == csQueuedForDestruction)
{
- m_Link->Send(OutgoingData.data(), OutgoingData.size());
+ LOGD("Client %s @ %s (%p) has been queued for destruction, destroying now.",
+ m_Username.c_str(), m_IPString.c_str(), static_cast<void *>(this)
+ );
+ Destroy();
+ return;
}
- if (m_State == csAuthenticated)
{
- StreamNextChunk();
+ cCSLock lock(m_CSState);
+ if (m_State == csAuthenticated)
+ {
+ StreamNextChunk();
- // Remove the client handle from the server, it will be ticked from its cPlayer object from now on
- cRoot::Get()->GetServer()->ClientMovedToWorld(this);
+ // Remove the client handle from the server, it will be ticked from its cPlayer object from now on
+ cRoot::Get()->GetServer()->ClientMovedToWorld(this);
- // Add the player to the world (start ticking from there):
- m_State = csDownloadingWorld;
- m_Player->Initialize(*(m_Player->GetWorld()));
- return;
- }
+ // Add the player to the world (start ticking from there):
+ m_State = csDownloadingWorld;
+ m_Player->Initialize(*(m_Player->GetWorld()));
+ return;
+ }
+ } // lock(m_CSState)
m_TicksSinceLastPacket += 1;
if (m_TicksSinceLastPacket > 600) // 30 seconds
@@ -3138,7 +3156,7 @@ bool cClientHandle::HasPluginChannel(const AString & a_PluginChannel)
bool cClientHandle::WantsSendChunk(int a_ChunkX, int a_ChunkZ)
{
- if (m_State >= csDestroying)
+ if (m_State >= csQueuedForDestruction)
{
return false;
}
@@ -3153,7 +3171,7 @@ bool cClientHandle::WantsSendChunk(int a_ChunkX, int a_ChunkZ)
void cClientHandle::AddWantedChunk(int a_ChunkX, int a_ChunkZ)
{
- if (m_State >= csDestroying)
+ if (m_State >= csQueuedForDestruction)
{
return;
}
@@ -3207,24 +3225,22 @@ void cClientHandle::PacketError(UInt32 a_PacketType)
void cClientHandle::SocketClosed(void)
{
// The socket has been closed for any reason
+ /*
+ LOGD("SocketClosed for client %s @ %s (%p), state = %d, m_Player = %p",
+ m_Username.c_str(), m_IPString.c_str(), static_cast<void *>(this), m_State.load(), static_cast<void *>(m_Player)
+ );
+ //*/
- if (!m_Username.empty()) // Ignore client pings
+ // Log into console, unless it's a client ping:
+ if (!m_Username.empty())
{
LOGD("Client %s @ %s disconnected", m_Username.c_str(), m_IPString.c_str());
cRoot::Get()->GetPluginManager()->CallHookDisconnect(*this, "Player disconnected");
}
- if (m_Player != nullptr)
- {
- m_Player->GetWorld()->QueueTask([this](cWorld & World)
- {
- UNUSED(World);
- Destroy();
- });
- }
- else
- {
- Destroy();
- }
+
+ // Queue self for destruction:
+ cCSLock lock(m_CSState);
+ m_State = csQueuedForDestruction;
}
@@ -3241,6 +3257,36 @@ void cClientHandle::SetSelf(cClientHandlePtr a_Self)
+void cClientHandle::ProcessProtocolInOut(void)
+{
+ // Process received network data:
+ AString IncomingData;
+ {
+ cCSLock Lock(m_CSIncomingData);
+ std::swap(IncomingData, m_IncomingData);
+ }
+ if (!IncomingData.empty())
+ {
+ m_Protocol->DataReceived(IncomingData.data(), IncomingData.size());
+ }
+
+ // Send any queued outgoing data:
+ AString OutgoingData;
+ {
+ cCSLock Lock(m_CSOutgoingData);
+ std::swap(OutgoingData, m_OutgoingData);
+ }
+ auto link = m_Link;
+ if ((link != nullptr) && !OutgoingData.empty())
+ {
+ link->Send(OutgoingData.data(), OutgoingData.size());
+ }
+}
+
+
+
+
+
void cClientHandle::OnLinkCreated(cTCPLinkPtr a_Link)
{
m_Link = a_Link;
@@ -3266,6 +3312,11 @@ void cClientHandle::OnReceivedData(const char * a_Data, size_t a_Length)
void cClientHandle::OnRemoteClosed(void)
{
+ /*
+ LOGD("Client socket for %s @ %s has been closed.",
+ m_Username.c_str(), m_IPString.c_str()
+ );
+ //*/
{
cCSLock Lock(m_CSOutgoingData);
m_Link.reset();
diff --git a/src/ClientHandle.h b/src/ClientHandle.h
index a361a0fb5..e6982d546 100644
--- a/src/ClientHandle.h
+++ b/src/ClientHandle.h
@@ -465,22 +465,28 @@ private:
enum eState
{
- csConnected, ///< The client has just connected, waiting for their handshake / login
- csAuthenticating, ///< The client has logged in, waiting for external authentication
- csAuthenticated, ///< The client has been authenticated, will start streaming chunks in the next tick
- csDownloadingWorld, ///< The client is waiting for chunks, we're waiting for the loader to provide and send them
- csConfirmingPos, ///< The client has been sent the position packet, waiting for them to repeat the position back
- csPlaying, ///< Normal gameplay
- csDestroying, ///< The client is being destroyed, don't queue any more packets / don't add to chunks
- csDestroyed, ///< The client has been destroyed, the destructor is to be called from the owner thread
+ csConnected, ///< The client has just connected, waiting for their handshake / login
+ csAuthenticating, ///< The client has logged in, waiting for external authentication
+ csAuthenticated, ///< The client has been authenticated, will start streaming chunks in the next tick
+ csDownloadingWorld, ///< The client is waiting for chunks, we're waiting for the loader to provide and send them
+ csConfirmingPos, ///< The client has been sent the position packet, waiting for them to repeat the position back
+ csPlaying, ///< Normal gameplay
+ csQueuedForDestruction, ///< The client will be destroyed in the next tick (flag set when socket closed)
+ csDestroying, ///< The client is being destroyed, don't queue any more packets / don't add to chunks
+ csDestroyed, ///< The client has been destroyed, the destructor is to be called from the owner thread
// TODO: Add Kicking here as well
} ;
- std::atomic<eState> m_State;
+ /* Mutex protecting m_State from concurrent writes. */
+ cCriticalSection m_CSState;
- /** m_State needs to be locked in the Destroy() function so that the destruction code doesn't run twice on two different threads */
- cCriticalSection m_CSDestroyingState;
+ /** The current (networking) state of the client.
+ Protected from concurrent writes by m_CSState; but may be read by other threads concurrently.
+ If a function depends on m_State or wants to change m_State, it needs to lock m_CSState.
+ However, if it only uses m_State for a quick bail out, or it doesn't break if the client disconnects in the middle of it,
+ it may just read m_State without locking m_CSState. */
+ std::atomic<eState> m_State;
/** If set to true during csDownloadingWorld, the tick thread calls CheckIfWorldDownloaded() */
bool m_ShouldCheckDownloaded;
@@ -556,6 +562,10 @@ private:
/** Called right after the instance is created to store its SharedPtr inside. */
void SetSelf(cClientHandlePtr a_Self);
+ /** Processes the data in the network input and output buffers.
+ Called by both Tick() and ServerTick(). */
+ void ProcessProtocolInOut(void);
+
// cTCPLink::cCallbacks overrides:
virtual void OnLinkCreated(cTCPLinkPtr a_Link) override;
virtual void OnReceivedData(const char * a_Data, size_t a_Length) override;