ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #12559 from sepalani/bba-refactor 

BBA/HLE: Code refactoring
This commit is contained in:
Admiral H. Curtiss 2024-04-16 22:43:04 +02:00 committed by GitHub
parent e757d5ea9c 07a2429367
commit 83b5124d40
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
3 changed files with 115 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

187
Source/Core/Core/HW/EXI/BBA/BuiltIn.cpp
View File

@ -26,12 +26,7 @@ u64 GetTickCountStd()
using namespace std::chrono;
return duration_cast<milliseconds>(steady_clock::now().time_since_epoch()).count();
}
} // namespace
namespace ExpansionInterface
{
namespace
{
std::vector<u8> BuildFINFrame(StackRef* ref)
{
const Common::TCPPacket result(ref->bba_mac, ref->my_mac, ref->from, ref->to, ref->seq_num,
@ -70,6 +65,8 @@ void SetIPIdentification(u8* ptr, std::size_t size, u16 value)
}
} // namespace
namespace ExpansionInterface
{
bool CEXIETHERNET::BuiltInBBAInterface::Activate()
{
if (IsActivated())
@ -91,11 +88,7 @@ bool CEXIETHERNET::BuiltInBBAInterface::Activate()
m_router_mac = Common::GenerateMacAddress(Common::MACConsumer::BBA);
m_arp_table[m_router_ip] = m_router_mac;
// clear all ref
for (auto& ref : network_ref)
{
ref.ip = 0;
}
m_network_ref.Clear();
m_upnp_httpd.listen(Common::SSDP_PORT, sf::IpAddress(ip));
m_upnp_httpd.setBlocking(false);
@ -113,16 +106,7 @@ void CEXIETHERNET::BuiltInBBAInterface::Deactivate()
m_read_thread_shutdown.Set();
m_active = false;
// kill all active socket
for (auto& ref : network_ref)
{
if (ref.ip != 0)
{
ref.type == IPPROTO_TCP ? ref.tcp_socket.disconnect() : ref.udp_socket.unbind();
}
ref.ip = 0;
}
m_network_ref.Clear();
m_arp_table.clear();
m_upnp_httpd.close();
@ -144,6 +128,40 @@ void CEXIETHERNET::BuiltInBBAInterface::WriteToQueue(const std::vector<u8>& data
m_queue_write = next_write_index;
}
void CEXIETHERNET::BuiltInBBAInterface::PollData(std::size_t* datasize)
{
for (auto& net_ref : m_network_ref)
{
if (net_ref.ip == 0)
continue;
// Check for sleeping TCP data
if (net_ref.type == IPPROTO_TCP)
{
for (auto& tcp_buf : net_ref.tcp_buffers)
{
if (!tcp_buf.used || (GetTickCountStd() - tcp_buf.tick) <= 1000)
continue;
tcp_buf.tick = GetTickCountStd();
// Timed out packet, resend
if (((m_queue_write + 1) & 15) != m_queue_read)
WriteToQueue(tcp_buf.data);
}
}
// Check for connection data
if (*datasize != 0)
continue;
const auto socket_data = TryGetDataFromSocket(&net_ref);
if (socket_data.has_value())
{
*datasize = socket_data->size();
std::memcpy(m_eth_ref->mRecvBuffer.get(), socket_data->data(), *datasize);
}
}
}
void CEXIETHERNET::BuiltInBBAInterface::HandleARP(const Common::ARPPacket& packet)
{
const auto& [hwdata, arpdata] = packet;
@ -203,36 +221,6 @@ void CEXIETHERNET::BuiltInBBAInterface::HandleDHCP(const Common::UDPPacket& pack
WriteToQueue(response.Build());
}
StackRef* CEXIETHERNET::BuiltInBBAInterface::GetAvailableSlot(u16 port)
{
if (port > 0) // existing connection?
{
for (auto& ref : network_ref)
{
if (ref.ip != 0 && ref.local == port)
return &ref;
}
}
for (auto& ref : network_ref)
{
if (ref.ip == 0)
return &ref;
}
return nullptr;
}
StackRef* CEXIETHERNET::BuiltInBBAInterface::GetTCPSlot(u16 src_port, u16 dst_port, u32 ip)
{
for (auto& ref : network_ref)
{
if (ref.ip == ip && ref.remote == dst_port && ref.local == src_port)
{
return &ref;
}
}
return nullptr;
}
std::optional<std::vector<u8>>
CEXIETHERNET::BuiltInBBAInterface::TryGetDataFromSocket(StackRef* ref)
{
@ -314,8 +302,8 @@ void CEXIETHERNET::BuiltInBBAInterface::HandleTCPFrame(const Common::TCPPacket&
{
const auto& [hwdata, ip_header, tcp_header, ip_options, tcp_options, data] = packet;
sf::IpAddress target;
StackRef* ref = GetTCPSlot(tcp_header.source_port, tcp_header.destination_port,
Common::BitCast<u32>(ip_header.destination_addr));
StackRef* ref = m_network_ref.GetTCPSlot(tcp_header.source_port, tcp_header.destination_port,
Common::BitCast<u32>(ip_header.destination_addr));
const u16 flags = ntohs(tcp_header.properties) & 0xfff;
if (flags & (TCP_FLAG_FIN | TCP_FLAG_RST))
{
@ -344,7 +332,7 @@ void CEXIETHERNET::BuiltInBBAInterface::HandleTCPFrame(const Common::TCPPacket&
// new connection
if (ref != nullptr)
return;
ref = GetAvailableSlot(0);
ref = m_network_ref.GetAvailableSlot(0);
ref->delay = GetTickCountStd();
ref->local = tcp_header.source_port;
@ -434,7 +422,7 @@ void CEXIETHERNET::BuiltInBBAInterface::HandleTCPFrame(const Common::TCPPacket&
// and listen to it. We open it on our side manually.
void CEXIETHERNET::BuiltInBBAInterface::InitUDPPort(u16 port)
{
StackRef* ref = GetAvailableSlot(htons(port));
StackRef* ref = m_network_ref.GetAvailableSlot(htons(port));
if (ref == nullptr || ref->ip != 0)
return;
ref->ip = m_router_ip; // change for ip
@ -464,7 +452,7 @@ void CEXIETHERNET::BuiltInBBAInterface::HandleUDPFrame(const Common::UDPPacket&
m_router_ip : // dns request
Common::BitCast<u32>(ip_header.destination_addr);
StackRef* ref = GetAvailableSlot(udp_header.source_port);
StackRef* ref = m_network_ref.GetAvailableSlot(udp_header.source_port);
if (ref->ip == 0)
{
ref->ip = destination_addr; // change for ip
@ -509,7 +497,7 @@ void CEXIETHERNET::BuiltInBBAInterface::HandleUDPFrame(const Common::UDPPacket&
void CEXIETHERNET::BuiltInBBAInterface::HandleUPnPClient()
{
StackRef* ref = GetAvailableSlot(0);
StackRef* ref = m_network_ref.GetAvailableSlot(0);
if (ref == nullptr || m_upnp_httpd.accept(ref->tcp_socket) != sf::Socket::Done)
return;
@ -701,41 +689,9 @@ void CEXIETHERNET::BuiltInBBAInterface::ReadThreadHandler(CEXIETHERNET::BuiltInB
self->m_queue_read++;
self->m_queue_read &= 15;
}
else
{
// test connections data
for (auto& net_ref : self->network_ref)
{
if (net_ref.ip == 0)
continue;
const auto socket_data = self->TryGetDataFromSocket(&net_ref);
if (socket_data.has_value())
{
datasize = socket_data->size();
std::memcpy(self->m_eth_ref->mRecvBuffer.get(), socket_data->data(), datasize);
break;
}
}
}
// test and add any sleeping tcp data
for (auto& net_ref : self->network_ref)
{
if (net_ref.ip == 0 || net_ref.type != IPPROTO_TCP)
continue;
for (auto& tcp_buf : net_ref.tcp_buffers)
{
if (!tcp_buf.used || (GetTickCountStd() - tcp_buf.tick) <= 1000)
continue;
tcp_buf.tick = GetTickCountStd();
// timmed out packet, resend
if (((self->m_queue_write + 1) & 15) != self->m_queue_read)
{
self->WriteToQueue(tcp_buf.data);
}
}
}
// Check network stack references
self->PollData(&datasize);
// Check for new UPnP client
self->HandleUPnPClient();
@ -778,14 +734,7 @@ void CEXIETHERNET::BuiltInBBAInterface::RecvStart()
void CEXIETHERNET::BuiltInBBAInterface::RecvStop()
{
m_read_enabled.Clear();
for (auto& net_ref : network_ref)
{
if (net_ref.ip != 0)
{
net_ref.type == IPPROTO_TCP ? net_ref.tcp_socket.disconnect() : net_ref.udp_socket.unbind();
}
net_ref.ip = 0;
}
m_network_ref.Clear();
m_queue_read = 0;
m_queue_write = 0;
}
@ -986,3 +935,45 @@ sf::Socket::Status BbaUdpSocket::Bind(u16 port, u32 net_ip)
INFO_LOG_FMT(SP1, "SSDP multicast membership successful");
return sf::Socket::Status::Done;
}
StackRef* NetworkRef::GetAvailableSlot(u16 port)
{
if (port > 0) // existing connection?
{
for (auto& ref : m_stacks)
{
if (ref.ip != 0 && ref.local == port)
return &ref;
}
}
for (auto& ref : m_stacks)
{
if (ref.ip == 0)
return &ref;
}
return nullptr;
}
StackRef* NetworkRef::GetTCPSlot(u16 src_port, u16 dst_port, u32 ip)
{
for (auto& ref : m_stacks)
{
if (ref.ip == ip && ref.remote == dst_port && ref.local == src_port)
{
return &ref;
}
}
return nullptr;
}
void NetworkRef::Clear()
{
for (auto& ref : m_stacks)
{
if (ref.ip != 0)
{
ref.type == IPPROTO_TCP ? ref.tcp_socket.disconnect() : ref.udp_socket.unbind();
}
ref.ip = 0;
}
}

25
Source/Core/Core/HW/EXI/BBA/BuiltIn.h
View File

@ -72,7 +72,7 @@ public:
struct StackRef
{
u32 ip;
u32 ip = 0;
u16 local;
u16 remote;
u16 type;
@ -92,3 +92,26 @@ struct StackRef
BbaTcpSocket tcp_socket;
u64 poke_time;
};
// Max 10 at same time, I think most gc game had a
// limit of 8 in the GC framework
using StackRefs = std::array<StackRef, 10>;
class NetworkRef
{
public:
StackRefs& data() { return m_stacks; }
const StackRefs& data() const { return m_stacks; }
auto begin() { return m_stacks.begin(); }
auto begin() const { return m_stacks.cbegin(); }
auto end() { return m_stacks.end(); }
auto end() const { return m_stacks.cend(); }
StackRef* GetAvailableSlot(u16 port);
StackRef* GetTCPSlot(u16 src_port, u16 dst_port, u32 ip);
void Clear();
private:
StackRefs m_stacks;
};

6
Source/Core/Core/HW/EXI/EXI_DeviceEthernet.h
View File

@ -456,16 +456,14 @@ private:
sf::TcpListener m_upnp_httpd;
#if defined(WIN32) || defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || \
defined(__OpenBSD__) || defined(__NetBSD__) || defined(__HAIKU__)
std::array<StackRef, 10> network_ref{}; // max 10 at same time, i think most gc game had a
// limit of 8 in the gc framework
NetworkRef m_network_ref;
std::thread m_read_thread;
Common::Flag m_read_enabled;
Common::Flag m_read_thread_shutdown;
static void ReadThreadHandler(BuiltInBBAInterface* self);
#endif
void WriteToQueue(const std::vector<u8>& data);
StackRef* GetAvailableSlot(u16 port);
StackRef* GetTCPSlot(u16 src_port, u16 dst_port, u32 ip);
void PollData(std::size_t* datasize);
std::optional<std::vector<u8>> TryGetDataFromSocket(StackRef* ref);
void HandleARP(const Common::ARPPacket& packet);