From baec86e39bd67d50183d1f3c832c527eae3f68e5 Mon Sep 17 00:00:00 2001 From: TheLastRar Date: Wed, 19 Jun 2024 23:31:10 +0100 Subject: [PATCH] DEV9: Return sender IP alongside payload Also return payload in a unique_ptr, --- pcsx2/DEV9/Sessions/BaseSession.h | 9 +++- .../Sessions/ICMP_Session/ICMP_Session.cpp | 19 ++++--- .../DEV9/Sessions/ICMP_Session/ICMP_Session.h | 2 +- .../DEV9/Sessions/TCP_Session/TCP_Session.cpp | 16 +++--- pcsx2/DEV9/Sessions/TCP_Session/TCP_Session.h | 16 +++--- .../Sessions/TCP_Session/TCP_Session_In.cpp | 54 +++++++++---------- .../Sessions/TCP_Session/TCP_Session_Out.cpp | 16 +++--- .../Sessions/UDP_Session/UDP_FixedPort.cpp | 19 ++++--- .../DEV9/Sessions/UDP_Session/UDP_FixedPort.h | 2 +- .../DEV9/Sessions/UDP_Session/UDP_Session.cpp | 14 ++--- pcsx2/DEV9/Sessions/UDP_Session/UDP_Session.h | 2 +- pcsx2/DEV9/sockets.cpp | 8 +-- 12 files changed, 90 insertions(+), 87 deletions(-) diff --git a/pcsx2/DEV9/Sessions/BaseSession.h b/pcsx2/DEV9/Sessions/BaseSession.h index 804dcdf3bd..f6dd827754 100644 --- a/pcsx2/DEV9/Sessions/BaseSession.h +++ b/pcsx2/DEV9/Sessions/BaseSession.h @@ -5,6 +5,7 @@ #include "DEV9/PacketReader/IP/IP_Packet.h" #include +#include #include namespace Sessions @@ -24,6 +25,12 @@ namespace Sessions bool operator!=(const ConnectionKey& other) const; }; + struct ReceivedPayload + { + PacketReader::IP::IP_Address sourceIP; + std::unique_ptr payload; + }; + class BaseSession { public: @@ -42,7 +49,7 @@ namespace Sessions void AddConnectionClosedHandler(ConnectionClosedEventHandler handler); - virtual PacketReader::IP::IP_Payload* Recv() = 0; + virtual std::optional Recv() = 0; virtual bool Send(PacketReader::IP::IP_Payload* payload) = 0; virtual void Reset() = 0; diff --git a/pcsx2/DEV9/Sessions/ICMP_Session/ICMP_Session.cpp b/pcsx2/DEV9/Sessions/ICMP_Session/ICMP_Session.cpp index 29c3463c05..9beb8b260f 100644 --- a/pcsx2/DEV9/Sessions/ICMP_Session/ICMP_Session.cpp +++ b/pcsx2/DEV9/Sessions/ICMP_Session/ICMP_Session.cpp @@ -659,7 +659,7 @@ namespace Sessions connections = parConnections; } - IP_Payload* ICMP_Session::Recv() + std::optional ICMP_Session::Recv() { std::unique_lock lock(ping_mutex); @@ -675,7 +675,7 @@ namespace Sessions lock.unlock(); //Create return ICMP packet - ICMP_Packet* ret = nullptr; + std::optional ret; if (pingRet->type >= 0) { PayloadData* data; @@ -704,13 +704,12 @@ namespace Sessions delete[] temp; } - ret = new ICMP_Packet(data); - ret->type = pingRet->type; - ret->code = pingRet->code; - memcpy(ret->headerData, ping->headerData, 4); + std::unique_ptr pRet = std::make_unique(data); + pRet->type = pingRet->type; + pRet->code = pingRet->code; + memcpy(pRet->headerData, ping->headerData, 4); - if (destIP != pingRet->address) - destIP = pingRet->address; + ret = {pingRet->address, std::move(pRet)}; } else if (pingRet->type == -1) Console.Error("DEV9: ICMP: Unexpected ICMP status %d", pingRet->code); @@ -723,7 +722,7 @@ namespace Sessions if (--open == 0) RaiseEventConnectionClosed(); - if (ret != nullptr) + if (ret.has_value()) DevCon.WriteLn("DEV9: ICMP: Return Ping"); //Return packet @@ -732,7 +731,7 @@ namespace Sessions } lock.unlock(); - return nullptr; + return std::nullopt; } bool ICMP_Session::Send(PacketReader::IP::IP_Payload* payload) diff --git a/pcsx2/DEV9/Sessions/ICMP_Session/ICMP_Session.h b/pcsx2/DEV9/Sessions/ICMP_Session/ICMP_Session.h index a03ca71847..8952e29dab 100644 --- a/pcsx2/DEV9/Sessions/ICMP_Session/ICMP_Session.h +++ b/pcsx2/DEV9/Sessions/ICMP_Session/ICMP_Session.h @@ -78,7 +78,7 @@ namespace Sessions public: ICMP_Session(ConnectionKey parKey, PacketReader::IP::IP_Address parAdapterIP, ThreadSafeMap* parConnections); - virtual PacketReader::IP::IP_Payload* Recv(); + virtual std::optional Recv(); virtual bool Send(PacketReader::IP::IP_Payload* payload); bool Send(PacketReader::IP::IP_Payload* payload, PacketReader::IP::IP_Packet* packet); virtual void Reset(); diff --git a/pcsx2/DEV9/Sessions/TCP_Session/TCP_Session.cpp b/pcsx2/DEV9/Sessions/TCP_Session/TCP_Session.cpp index 4619c24e57..e3dc2d96b3 100644 --- a/pcsx2/DEV9/Sessions/TCP_Session/TCP_Session.cpp +++ b/pcsx2/DEV9/Sessions/TCP_Session/TCP_Session.cpp @@ -18,13 +18,13 @@ using namespace PacketReader::IP::TCP; namespace Sessions { - void TCP_Session::PushRecvBuff(TCP_Packet* tcp) + void TCP_Session::PushRecvBuff(std::unique_ptr tcp) { - _recvBuff.Enqueue(tcp); + _recvBuff.Enqueue(std::move(tcp)); } - TCP_Packet* TCP_Session::PopRecvBuff() + std::unique_ptr TCP_Session::PopRecvBuff() { - TCP_Packet* ret; + std::unique_ptr ret; if (_recvBuff.Dequeue(&ret)) return ret; else @@ -102,13 +102,13 @@ namespace Sessions return delta; } - TCP_Packet* TCP_Session::CreateBasePacket(PayloadData* data) + std::unique_ptr TCP_Session::CreateBasePacket(PayloadData* data) { //DevCon.WriteLn("Creating base packet"); if (data == nullptr) data = new PayloadData(0); - TCP_Packet* ret = new TCP_Packet(data); + std::unique_ptr ret = std::make_unique(data); // Setup common packet infomation ret->sourcePort = destPort; @@ -159,15 +159,13 @@ namespace Sessions // Clear out _recvBuff while (!_recvBuff.IsQueueEmpty()) { - TCP_Packet* retPay; + std::unique_ptr retPay; if (!_recvBuff.Dequeue(&retPay)) { using namespace std::chrono_literals; std::this_thread::sleep_for(1ms); continue; } - - delete retPay; } } } // namespace Sessions diff --git a/pcsx2/DEV9/Sessions/TCP_Session/TCP_Session.h b/pcsx2/DEV9/Sessions/TCP_Session/TCP_Session.h index 28a68d42c5..9043267354 100644 --- a/pcsx2/DEV9/Sessions/TCP_Session/TCP_Session.h +++ b/pcsx2/DEV9/Sessions/TCP_Session/TCP_Session.h @@ -42,7 +42,7 @@ namespace Sessions Bad }; - SimpleQueue _recvBuff; + SimpleQueue> _recvBuff; #ifdef _WIN32 SOCKET client = INVALID_SOCKET; @@ -77,7 +77,7 @@ namespace Sessions public: TCP_Session(ConnectionKey parKey, PacketReader::IP::IP_Address parAdapterIP); - virtual PacketReader::IP::IP_Payload* Recv(); + virtual std::optional Recv(); virtual bool Send(PacketReader::IP::IP_Payload* payload); virtual void Reset(); @@ -85,8 +85,8 @@ namespace Sessions private: // Async functions - void PushRecvBuff(PacketReader::IP::TCP::TCP_Packet* tcp); - PacketReader::IP::TCP::TCP_Packet* PopRecvBuff(); + void PushRecvBuff(std::unique_ptr tcp); + std::unique_ptr PopRecvBuff(); void IncrementMyNumber(u32 amount); void UpdateReceivedAckNumber(u32 ack); @@ -104,7 +104,7 @@ namespace Sessions bool ValidateEmptyPacket(PacketReader::IP::TCP::TCP_Packet* tcp, bool ignoreOld = true); // PS2 sent SYN - PacketReader::IP::TCP::TCP_Packet* ConnectTCPComplete(bool success); + std::unique_ptr ConnectTCPComplete(bool success); bool SendConnect(PacketReader::IP::TCP::TCP_Packet* tcp); bool SendConnected(PacketReader::IP::TCP::TCP_Packet* tcp); @@ -120,7 +120,7 @@ namespace Sessions * S4: PS2 then Sends ACK */ bool CloseByPS2Stage1_2(PacketReader::IP::TCP::TCP_Packet* tcp); - PacketReader::IP::TCP::TCP_Packet* CloseByPS2Stage3(); + std::unique_ptr CloseByPS2Stage3(); bool CloseByPS2Stage4(PacketReader::IP::TCP::TCP_Packet* tcp); /* @@ -132,7 +132,7 @@ namespace Sessions * Closing_ClosedByRemoteThenPS2_WaitingForAck * we then check if S3 has been completed */ - PacketReader::IP::TCP::TCP_Packet* CloseByRemoteStage1(); + std::unique_ptr CloseByRemoteStage1(); bool CloseByRemoteStage2_ButAfter4(PacketReader::IP::TCP::TCP_Packet* tcp); bool CloseByRemoteStage3_4(PacketReader::IP::TCP::TCP_Packet* tcp); @@ -140,7 +140,7 @@ namespace Sessions void CloseByRemoteRST(); // Returned TCP_Packet takes ownership of data - PacketReader::IP::TCP::TCP_Packet* CreateBasePacket(PacketReader::PayloadData* data = nullptr); + std::unique_ptr CreateBasePacket(PacketReader::PayloadData* data = nullptr); void CloseSocket(); }; diff --git a/pcsx2/DEV9/Sessions/TCP_Session/TCP_Session_In.cpp b/pcsx2/DEV9/Sessions/TCP_Session/TCP_Session_In.cpp index ff0b712a6b..ee41dc2163 100644 --- a/pcsx2/DEV9/Sessions/TCP_Session/TCP_Session_In.cpp +++ b/pcsx2/DEV9/Sessions/TCP_Session/TCP_Session_In.cpp @@ -20,11 +20,11 @@ using namespace PacketReader::IP::TCP; namespace Sessions { - PacketReader::IP::IP_Payload* TCP_Session::Recv() + std::optional TCP_Session::Recv() { - TCP_Packet* ret = PopRecvBuff(); + std::unique_ptr ret = PopRecvBuff(); if (ret != nullptr) - return ret; + return ReceivedPayload{destIP, std::move(ret)}; switch (state) { @@ -43,15 +43,15 @@ namespace Sessions select(client + 1, nullptr, &writeSet, &exceptSet, &nowait); if (FD_ISSET(client, &writeSet)) - return ConnectTCPComplete(true); + return ReceivedPayload{destIP, ConnectTCPComplete(true)}; if (FD_ISSET(client, &exceptSet)) - return ConnectTCPComplete(false); + return ReceivedPayload{destIP, ConnectTCPComplete(false)}; - return nullptr; + return std::nullopt; } case TCP_State::SentSYN_ACK: // Don't read data untill PS2 ACKs connection - return nullptr; + return std::nullopt; case TCP_State::CloseCompletedFlushBuffer: /* * When TCP connection is closed by the server @@ -60,17 +60,17 @@ namespace Sessions */ state = TCP_State::CloseCompleted; RaiseEventConnectionClosed(); - return nullptr; + return std::nullopt; case TCP_State::Connected: case TCP_State::Closing_ClosedByPS2: // Only accept data in above two states break; default: - return nullptr; + return std::nullopt; } if (ShouldWaitForAck()) - return nullptr; + return std::nullopt; // Note, windowSize will be updated before _ReceivedAckNumber, potential race condition // in practice, we just get a smaller or -ve maxSize @@ -118,24 +118,24 @@ namespace Sessions // In theory, this should only occur when the PS2 has RST the connection // and the call to TCPSession.Recv() occurs at just the right time. //Console.WriteLn("DEV9: TCP: Recv() on shutdown socket"); - return nullptr; + return std::nullopt; case WSAEWOULDBLOCK: - return nullptr; + return std::nullopt; #elif defined(__POSIX__) case EINVAL: case ESHUTDOWN: // See WSAESHUTDOWN //Console.WriteLn("DEV9: TCP: Recv() on shutdown socket"); - return nullptr; + return std::nullopt; case EWOULDBLOCK: - return nullptr; + return std::nullopt; #endif case 0: break; default: CloseByRemoteRST(); Console.Error("DEV9: TCP: Recv error: %d", err); - return nullptr; + return std::nullopt; } // Server closed the Socket @@ -153,22 +153,22 @@ namespace Sessions switch (state) { case TCP_State::Connected: - return CloseByRemoteStage1(); + return ReceivedPayload{destIP, CloseByRemoteStage1()}; case TCP_State::Closing_ClosedByPS2: - return CloseByPS2Stage3(); + return ReceivedPayload{destIP, CloseByPS2Stage3()}; default: CloseByRemoteRST(); Console.Error("DEV9: TCP: Remote close occured with invalid TCP state"); break; } - return nullptr; + return std::nullopt; } DevCon.WriteLn("DEV9: TCP: [SRV] Sending %d bytes", recived); PayloadData* recivedData = new PayloadData(recived); memcpy(recivedData->data.get(), buffer.get(), recived); - TCP_Packet* iRet = CreateBasePacket(recivedData); + std::unique_ptr iRet = CreateBasePacket(recivedData); IncrementMyNumber((u32)recived); iRet->SetACK(true); @@ -176,20 +176,20 @@ namespace Sessions myNumberACKed.store(false); //DevCon.WriteLn("DEV9: TCP: myNumberACKed reset"); - return iRet; + return ReceivedPayload{destIP, std::move(iRet)}; } } - return nullptr; + return std::nullopt; } - TCP_Packet* TCP_Session::ConnectTCPComplete(bool success) + std::unique_ptr TCP_Session::ConnectTCPComplete(bool success) { if (success) { state = TCP_State::SentSYN_ACK; - TCP_Packet* ret = new TCP_Packet(new PayloadData(0)); + std::unique_ptr ret = std::make_unique(new PayloadData(0)); // Send packet to say we connected ret->sourcePort = destPort; ret->destinationPort = srcPort; @@ -240,11 +240,11 @@ namespace Sessions } } - PacketReader::IP::TCP::TCP_Packet* TCP_Session::CloseByPS2Stage3() + std::unique_ptr TCP_Session::CloseByPS2Stage3() { //Console.WriteLn("DEV9: TCP: Remote has closed connection after PS2"); - TCP_Packet* ret = CreateBasePacket(); + std::unique_ptr ret = CreateBasePacket(); IncrementMyNumber(1); ret->SetACK(true); @@ -257,11 +257,11 @@ namespace Sessions return ret; } - PacketReader::IP::TCP::TCP_Packet* TCP_Session::CloseByRemoteStage1() + std::unique_ptr TCP_Session::CloseByRemoteStage1() { //Console.WriteLn("DEV9: TCP: Remote has closed connection"); - TCP_Packet* ret = CreateBasePacket(); + std::unique_ptr ret = CreateBasePacket(); IncrementMyNumber(1); ret->SetACK(true); diff --git a/pcsx2/DEV9/Sessions/TCP_Session/TCP_Session_Out.cpp b/pcsx2/DEV9/Sessions/TCP_Session/TCP_Session_Out.cpp index e0fcf6222f..fb5c2d34b2 100644 --- a/pcsx2/DEV9/Sessions/TCP_Session/TCP_Session_Out.cpp +++ b/pcsx2/DEV9/Sessions/TCP_Session/TCP_Session_Out.cpp @@ -363,10 +363,10 @@ namespace Sessions } // ACK data //DevCon.WriteLn("[SRV] ACK data: %u", expectedSeqNumber); - TCP_Packet* ret = CreateBasePacket(); + std::unique_ptr ret = CreateBasePacket(); ret->SetACK(true); - PushRecvBuff(ret); + PushRecvBuff(std::move(ret)); } return true; } @@ -521,10 +521,10 @@ namespace Sessions #endif // Connection close part 2, send ACK to PS2 - TCP_Packet* ret = CreateBasePacket(); + std::unique_ptr ret = CreateBasePacket(); ret->SetACK(true); - PushRecvBuff(ret); + PushRecvBuff(std::move(ret)); return true; } @@ -587,11 +587,11 @@ namespace Sessions errno); #endif - TCP_Packet* ret = CreateBasePacket(); + std::unique_ptr ret = CreateBasePacket(); ret->SetACK(true); - PushRecvBuff(ret); + PushRecvBuff(std::move(ret)); if (myNumberACKed.load()) { @@ -609,9 +609,9 @@ namespace Sessions // Error on sending data void TCP_Session::CloseByRemoteRST() { - TCP_Packet* reterr = CreateBasePacket(); + std::unique_ptr reterr = CreateBasePacket(); reterr->SetRST(true); - PushRecvBuff(reterr); + PushRecvBuff(std::move(reterr)); CloseSocket(); state = TCP_State::CloseCompletedFlushBuffer; diff --git a/pcsx2/DEV9/Sessions/UDP_Session/UDP_FixedPort.cpp b/pcsx2/DEV9/Sessions/UDP_Session/UDP_FixedPort.cpp index ee48284d46..e2369d1144 100644 --- a/pcsx2/DEV9/Sessions/UDP_Session/UDP_FixedPort.cpp +++ b/pcsx2/DEV9/Sessions/UDP_Session/UDP_FixedPort.cpp @@ -109,10 +109,10 @@ namespace Sessions open.store(true); } - IP_Payload* UDP_FixedPort::Recv() + std::optional UDP_FixedPort::Recv() { if (!open.load()) - return nullptr; + return std::nullopt; int ret; fd_set sReady; @@ -191,31 +191,30 @@ namespace Sessions errno); #endif RaiseEventConnectionClosed(); - return nullptr; + return std::nullopt; } recived = new PayloadData(ret); memcpy(recived->data.get(), buffer.get(), ret); - UDP_Packet* iRet = new UDP_Packet(recived); + std::unique_ptr iRet = std::make_unique(recived); iRet->destinationPort = port; - - destIP = std::bit_cast(endpoint.sin_addr); iRet->sourcePort = ntohs(endpoint.sin_port); + + IP_Address srvIP = std::bit_cast(endpoint.sin_addr); { std::lock_guard numberlock(connectionSentry); for (size_t i = 0; i < connections.size(); i++) { UDP_BaseSession* s = connections[i]; - if (s->WillRecive(destIP)) - return iRet; + if (s->WillRecive(srvIP)) + return ReceivedPayload{srvIP, std::move(iRet)}; } } Console.Error("DEV9: UDP: Unexpected packet, dropping"); - delete iRet; } - return nullptr; + return std::nullopt; } bool UDP_FixedPort::Send(PacketReader::IP::IP_Payload* payload) diff --git a/pcsx2/DEV9/Sessions/UDP_Session/UDP_FixedPort.h b/pcsx2/DEV9/Sessions/UDP_Session/UDP_FixedPort.h index 58b46e9240..e1efe67aed 100644 --- a/pcsx2/DEV9/Sessions/UDP_Session/UDP_FixedPort.h +++ b/pcsx2/DEV9/Sessions/UDP_Session/UDP_FixedPort.h @@ -40,7 +40,7 @@ namespace Sessions void Init(); - virtual PacketReader::IP::IP_Payload* Recv(); + virtual std::optional Recv(); virtual bool Send(PacketReader::IP::IP_Payload* payload); virtual void Reset(); diff --git a/pcsx2/DEV9/Sessions/UDP_Session/UDP_Session.cpp b/pcsx2/DEV9/Sessions/UDP_Session/UDP_Session.cpp index 007e3c92f9..95e2aa1e85 100644 --- a/pcsx2/DEV9/Sessions/UDP_Session/UDP_Session.cpp +++ b/pcsx2/DEV9/Sessions/UDP_Session/UDP_Session.cpp @@ -59,10 +59,10 @@ namespace Sessions { } - IP_Payload* UDP_Session::Recv() + std::optional UDP_Session::Recv() { if (!open.load()) - return nullptr; + return std::nullopt; if (isFixedPort) { @@ -72,7 +72,7 @@ namespace Sessions open.store(false); RaiseEventConnectionClosed(); } - return nullptr; + return std::nullopt; } int ret; @@ -152,19 +152,19 @@ namespace Sessions errno); #endif RaiseEventConnectionClosed(); - return nullptr; + return std::nullopt; } recived = new PayloadData(ret); memcpy(recived->data.get(), buffer.get(), ret); - UDP_Packet* iRet = new UDP_Packet(recived); + std::unique_ptr iRet = std::make_unique(recived); iRet->destinationPort = srcPort; iRet->sourcePort = destPort; deathClockStart.store(std::chrono::steady_clock::now()); - return iRet; + return ReceivedPayload{destIP, std::move(iRet)}; } if (std::chrono::steady_clock::now() - deathClockStart.load() > MAX_IDLE) @@ -173,7 +173,7 @@ namespace Sessions RaiseEventConnectionClosed(); } - return nullptr; + return std::nullopt; } bool UDP_Session::WillRecive(IP_Address parDestIP) diff --git a/pcsx2/DEV9/Sessions/UDP_Session/UDP_Session.h b/pcsx2/DEV9/Sessions/UDP_Session/UDP_Session.h index 9efd11644f..67b91ab283 100644 --- a/pcsx2/DEV9/Sessions/UDP_Session/UDP_Session.h +++ b/pcsx2/DEV9/Sessions/UDP_Session/UDP_Session.h @@ -46,7 +46,7 @@ namespace Sessions UDP_Session(ConnectionKey parKey, PacketReader::IP::IP_Address parAdapterIP, bool parIsBroadcast, bool parIsMulticast, int parClient); #endif - virtual PacketReader::IP::IP_Payload* Recv(); + virtual std::optional Recv(); virtual bool WillRecive(PacketReader::IP::IP_Address parDestIP); virtual bool Send(PacketReader::IP::IP_Payload* payload); virtual void Reset(); diff --git a/pcsx2/DEV9/sockets.cpp b/pcsx2/DEV9/sockets.cpp index d791bef3dc..45f59e0bb3 100644 --- a/pcsx2/DEV9/sockets.cpp +++ b/pcsx2/DEV9/sockets.cpp @@ -220,13 +220,13 @@ bool SocketAdapter::recv(NetPacket* pkt) if (!connections.TryGetValue(key, &session)) continue; - IP_Payload* pl = session->Recv(); + std::optional pl = session->Recv(); - if (pl != nullptr) + if (pl.has_value()) { - IP_Packet* ipPkt = new IP_Packet(pl); + IP_Packet* ipPkt = new IP_Packet(pl->payload.release()); ipPkt->destinationIP = session->sourceIP; - ipPkt->sourceIP = session->destIP; + ipPkt->sourceIP = pl->sourceIP; EthernetFrame frame(ipPkt); frame.sourceMAC = internalMAC;