BeamMP/BeamMP-Server
1
0
Fork 0
mirror of https://github.com/BeamMP/BeamMP-Server.git synced 2025-07-01 15:26:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

remove usages of weak_ptr

Browse Source
This commit is contained in:
Lion Kortlepel 2024-01-11 14:30:25 +01:00
parent 130e1acdb3
commit 443871ec0f
No known key found for this signature in database
GPG Key ID: 4322FF2B4C71259B
5 changed files with 27 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/TNetwork.h
View File

@ -44,8 +44,8 @@ private:
std::vector<uint8_t> UDPRcvFromClient(ip::udp::endpoint& ClientEndpoint);
void HandleDownload(TConnection&& TCPSock);
void OnConnect(const std::weak_ptr<TClient>& c);
void TCPClient(const std::weak_ptr<TClient>& c);
void Looper(const std::weak_ptr<TClient>& c);
void TCPClient(const std::shared_ptr<TClient>& c);
void Looper(const std::shared_ptr<TClient>& c);
void Parse(TClient& c, const std::vector<uint8_t>& Packet);
void SendFile(TClient& c, const std::string& Name);
bool TCPSendRaw(TClient& C, ip::tcp::socket& socket, const uint8_t* Data, size_t Size);

2
include/TServer.h
View File

@ -27,7 +27,7 @@ public:
void ForEachClient(const std::function<bool(const std::shared_ptr<TClient>&)> Fn);
size_t ClientCount() const;
void GlobalParser(const std::weak_ptr<TClient>& Client, std::vector<uint8_t>&& Packet, TPPSMonitor& PPSMonitor, TNetwork& Network);
void GlobalParser(const std::shared_ptr<TClient>& Client, std::vector<uint8_t>&& Packet, TPPSMonitor& PPSMonitor, TNetwork& Network);
static void HandleEvent(TClient& c, const std::string& Data);
RWMutex& GetClientMutex() const { return mClientsMutex; }

2
src/Client.cpp
View File

@ -144,8 +144,6 @@ std::optional<std::shared_ptr<TClient>> GetClient(TServer& Server, int ID) {
MaybeClient = Client;
return false;
}
} else {
beammp_debugf("Found an expired client while looking for id {}", ID);
return true;
});
return MaybeClient;

38
src/TNetwork.cpp
View File

@ -91,9 +91,8 @@ void TNetwork::UDPServerMain() {
Client->UDPAddress = client;
Client->IsConnected = true;
Data.erase(Data.begin(), Data.begin() + 2);
mServer.GlobalParser(ClientPtr, std::move(Data), mPPSMonitor, *this);
mServer.GlobalParser(Client, std::move(Data), mPPSMonitor, *this);
}
return true;
});
} catch (const std::exception& e) {
@ -471,16 +470,10 @@ void TNetwork::ClientKick(TClient& c, const std::string& R) {
Disconnect(c);
}
void TNetwork::Looper(const std::weak_ptr<TClient>& c) {
void TNetwork::Looper(const std::shared_ptr<TClient>& Client) {
RegisterThreadAuto();
while (!c.expired()) {
auto Client = c.lock();
if (Client->IsDisconnected()) {
beammp_debug("client is disconnected, breaking client loop");
break;
}
while (!Client->IsDisconnected()) {
if (!Client->IsSyncing.get() && Client->IsSynced.get() && Client->MissedPacketsQueue->size() != 0) {
// debug("sending " + std::to_string(Client->MissedPacketQueueSize()) + " queued packets");
while (Client->MissedPacketsQueue->size() > 0) {
std::vector<uint8_t> QData {};
{ // locked context
@ -491,7 +484,6 @@ void TNetwork::Looper(const std::weak_ptr<TClient>& c) {
QData = Lock->front();
Lock->pop();
} // end locked context
// beammp_debug("sending a missed packet: " + QData);
if (!TCPSend(*Client, QData, true)) {
Disconnect(Client);
auto Lock = Client->MissedPacketsQueue;
@ -507,30 +499,22 @@ void TNetwork::Looper(const std::weak_ptr<TClient>& c) {
}
}
void TNetwork::TCPClient(const std::weak_ptr<TClient>& c) {
// TODO: the c.expired() might cause issues here, remove if you end up here with your debugger
if (c.expired() || !c.lock()->TCPSocket->is_open()) {
mServer.RemoveClient(c);
return;
}
void TNetwork::TCPClient(const std::shared_ptr<TClient>& c) {
OnConnect(c);
RegisterThread("(" + std::to_string(c.lock()->ID.get()) + ") \"" + c.lock()->Name.get() + "\"");
RegisterThread("(" + std::to_string(c->ID.get()) + ") \"" + c->Name.get() + "\"");
std::thread QueueSync(&TNetwork::Looper, this, c);
while (true) {
if (c.expired())
break;
auto Client = c.lock();
if (Client->IsDisconnected()) {
if (c->IsDisconnected()) {
beammp_debug("client status < 0, breaking client loop");
break;
}
auto res = TCPRcv(*Client);
auto res = TCPRcv(*c);
if (res.empty()) {
beammp_debug("TCPRcv empty");
Disconnect(Client);
Disconnect(c);
break;
}
mServer.GlobalParser(c, std::move(res), mPPSMonitor, *this);
@ -539,13 +523,7 @@ void TNetwork::TCPClient(const std::weak_ptr<TClient>& c) {
if (QueueSync.joinable())
QueueSync.join();
if (!c.expired()) {
auto Client = c.lock();
Disconnect(c);
return;
} else {
beammp_warn("client expired in TCPClient, should never happen");
}
}
void TNetwork::UpdatePlayer(TClient& Client) {

35
src/TServer.cpp
View File

@ -176,7 +176,7 @@ size_t TServer::ClientCount() const {
return mClients.size();
}
void TServer::GlobalParser(const std::weak_ptr<TClient>& Client, std::vector<uint8_t>&& Packet, TPPSMonitor& PPSMonitor, TNetwork& Network) {
void TServer::GlobalParser(const std::shared_ptr<TClient>& Client, std::vector<uint8_t>&& Packet, TPPSMonitor& PPSMonitor, TNetwork& Network) {
constexpr std::string_view ABG = "ABG:";
if (Packet.size() >= ABG.size() && std::equal(Packet.begin(), Packet.begin() + ABG.size(), ABG.begin(), ABG.end())) {
Packet.erase(Packet.begin(), Packet.begin() + ABG.size());
@ -186,11 +186,6 @@ void TServer::GlobalParser(const std::weak_ptr<TClient>& Client, std::vector<uin
return;
}
if (Client.expired()) {
return;
}
auto LockedClient = Client.lock();
std::any Res;
char Code = Packet.at(0);
@ -199,7 +194,7 @@ void TServer::GlobalParser(const std::weak_ptr<TClient>& Client, std::vector<uin
// V to Y
if (Code <= 89 && Code >= 86) {
PPSMonitor.IncrementInternalPPS();
Network.SendToAll(LockedClient.get(), Packet, false, false);
Network.SendToAll(Client.get(), Packet, false, false);
return;
}
switch (Code) {
@ -209,18 +204,18 @@ void TServer::GlobalParser(const std::weak_ptr<TClient>& Client, std::vector<uin
}
return;
case 'p':
if (!Network.Respond(*LockedClient, StringToVector("p"), false)) {
if (!Network.Respond(*Client, StringToVector("p"), false)) {
// failed to send
Disconnect(LockedClient);
Network.Disconnect(Client);
} else {
Network.UpdatePlayer(*LockedClient);
Network.UpdatePlayer(*Client);
}
return;
case 'O':
if (Packet.size() > 1000) {
beammp_debug(("Received data from: ") + LockedClient->Name.get() + (" Size: ") + std::to_string(Packet.size()));
beammp_debug(("Received data from: ") + Client->Name.get() + (" Size: ") + std::to_string(Packet.size()));
}
ParseVehicle(*LockedClient, StringPacket, Network);
ParseVehicle(*Client, StringPacket, Network);
return;
case 'C': {
if (Packet.size() < 4 || std::find(Packet.begin() + 3, Packet.end(), ':') == Packet.end())
@ -232,12 +227,12 @@ void TServer::GlobalParser(const std::weak_ptr<TClient>& Client, std::vector<uin
Message = PacketAsString.substr(ColonPos + 2);
}
if (Message.empty()) {
beammp_debugf("Empty chat message received from '{}' ({}), ignoring it", LockedClient->Name.get(), LockedClient->ID.get());
beammp_debugf("Empty chat message received from '{}' ({}), ignoring it", Client->Name.get(), Client->ID.get());
return;
}
auto Futures = LuaAPI::MP::Engine->TriggerEvent("onChatMessage", "", LockedClient->ID.get(), LockedClient->Name.get(), Message);
auto Futures = LuaAPI::MP::Engine->TriggerEvent("onChatMessage", "", Client->ID.get(), Client->Name.get(), Message);
TLuaEngine::WaitForAll(Futures);
LogChatMessage(LockedClient->Name.get(), LockedClient->ID.get(), PacketAsString.substr(PacketAsString.find(':', 3) + 1));
LogChatMessage(Client->Name.get(), Client->ID.get(), PacketAsString.substr(PacketAsString.find(':', 3) + 1));
if (std::any_of(Futures.begin(), Futures.end(),
[](const std::shared_ptr<TLuaResult>& Elem) {
return !Elem->Error
@ -246,21 +241,21 @@ void TServer::GlobalParser(const std::weak_ptr<TClient>& Client, std::vector<uin
})) {
break;
}
std::string SanitizedPacket = fmt::format("C:{}: {}", LockedClient->Name.get(), Message);
std::string SanitizedPacket = fmt::format("C:{}: {}", Client->Name.get(), Message);
Network.SendToAll(nullptr, StringToVector(SanitizedPacket), true, true);
return;
}
case 'E':
HandleEvent(*LockedClient, StringPacket);
HandleEvent(*Client, StringPacket);
return;
case 'N':
beammp_trace("got 'N' packet (" + std::to_string(Packet.size()) + ")");
Network.SendToAll(LockedClient.get(), Packet, false, true);
Network.SendToAll(Client.get(), Packet, false, true);
return;
case 'Z': // position packet
PPSMonitor.IncrementInternalPPS();
Network.SendToAll(LockedClient.get(), Packet, false, false);
HandlePosition(*LockedClient, StringPacket);
Network.SendToAll(Client.get(), Packet, false, false);
HandlePosition(*Client, StringPacket);
return;
default:
return;