SilverMoonStudio/EHS
3
0
Fork 0
Code Issues 8 Pull Requests Actions Projects 1 Releases 2 Wiki Activity

Merge remote-tracking branch 'origin/NetChannels' into NetChannels
Some checks failed
Build & Release / Windows-AMD64-Build (push) Failing after 9m34s
Details
Build & Release / Linux-AMD64-Build (push) Failing after 1m58s
Details
Build & Release / Linux-AARCH64-Build (push) Failing after 5m21s
Details

Browse Source
This commit is contained in:
Karutoh 2025-03-23 03:11:24 -07:00
commit 53d86eb539
11 changed files with 173 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
include/ehs/io/socket/EHC.h
View File

@ -63,23 +63,12 @@ namespace ehs
bool AddEncryption(NetEnc *enc);
bool AddServer(NetServerCh *server);
bool AddClient(NetClientCh *channel);
private:
bool HasEncryption(UInt_64 encId) const;
bool HasEncryption(const Str_8& encName) const;
NetEnc* GetEncryption(UInt_64 encId) const;
NetEnc* GetEncryption(const Str_8& encName) const;
bool HasServer(UInt_64 serverId) const;
bool HasServer(const Str_8& serverName) const;
bool AddServer(NetServerCh *server);
NetServerCh *GetServer(UInt_64 serverId) const;
NetServerCh *GetServer(const Str_8& serverName) const;
@ -88,8 +77,19 @@ namespace ehs
bool HasClient(const Str_8& clientName) const;
bool AddClient(NetClientCh *channel);
NetClientCh *GetClient(UInt_64 clientId) const;
NetClientCh *GetClient(const Str_8& clientName) const;
private:
bool HasEncryption(UInt_64 encId) const;
bool HasEncryption(const Str_8& encName) const;
NetEnc* GetEncryption(UInt_64 encId) const;
NetEnc* GetEncryption(const Str_8& encName) const;
};
}

6
include/ehs/io/socket/UDP_W32.h
View File

@ -41,7 +41,7 @@ namespace ehs
/// @param [in] address The local IPv4 or IPv6 address to bind to. Resolves domain names. The given address can be empty, "127.0.0.1", or "localhost" to automatically find the appropriate device.
/// @param [in] port The port to bind to.
/// @note Requires the port given to be forwarded if this is called.
void Bind(IP type, const Str_8& address, UInt_16 port) override;
void Bind(const Endpoint &endpoint) override;
/// Sends data using a C-style byte array.
/// @param [in] addr The remote Ipv4 or Ipv6 address to send to. Resolves domain names. The given address can be empty, "127.0.0.1", or "localhost" to automatically find the appropriate device.
@ -49,7 +49,7 @@ namespace ehs
/// @param [in] data The C-style byte array to send.
/// @param [in] size The size of the C-style byte array.
/// @note The size of data to be sent cannot exceed "UDP::maxPayloadIpv4" or "UDP::maxPayloadIpv6".
UInt_64 Send(IP type, const Str_8& addr, UInt_16 port, const Byte* data, UInt_64 size) override;
UInt_64 Send(const Endpoint &endpoint, const Byte* data, UInt_64 size) override;
/// Receives data using the packet helper class.
/// @param [out] addr The Ipv4 or Ipv6 address of the sender.
@ -58,7 +58,7 @@ namespace ehs
/// @param [in] size The size of the pre-allocated C-style byte array.
/// @returns The size of the data received.
/// @warning The provided C-style byte array must be freed when finished using.
UInt_64 Receive(IP* type, Str_8* addr, UInt_16* port, Byte* data, UInt_64 size) override;
UInt_64 Receive(Endpoint *endpoint, Byte* data, UInt_64 size) override;
/// Sets whether or not receiving data blocks the next task.
/// @param [in] blocking Whether or not to block.

8
include/ehs/io/socket/ehc/NetChannel.h
View File

@ -83,12 +83,12 @@ namespace ehs
virtual void Poll(const float &delta);
protected:
bool HasSystem(UInt_64 sysHashId) const;
bool HasSystem(UInt_64 sysId) const;
bool HasSystem(const Str_8& sysId) const;
bool HasSystem(const Str_8& sysName) const;
NetSys* GetSystem(UInt_64 sysHashId) const;
NetSys* GetSystem(UInt_64 sysId) const;
NetSys* GetSystem(const Str_8& sysId) const;
NetSys* GetSystem(const Str_8& sysName) const;
};
}

12
include/ehs/io/socket/ehc/NetOp.h
View File

@ -14,15 +14,15 @@ namespace ehs
private:
friend class NetSys;
UInt_64 hashId;
Str_8 id;
UInt_64 id;
Str_8 name;
public:
virtual ~NetOp() = default;
NetOp();
NetOp(Str_8 id);
NetOp(Str_8 name);
NetOp(NetOp &&op) noexcept;
@ -32,11 +32,11 @@ namespace ehs
NetOp &operator=(const NetOp &op);
Str_8 GetId() const;
UInt_64 GetId() const;
UInt_64 GetHashId() const;
Str_8 GetName() const;
private:
virtual void Process(NetChannel *channel, NetEnd *endpoint, NetSys *sys, Serializer<UInt_64> &payload);
virtual void Execute(NetChannel *channel, NetEnd *issuer, NetSys *sys, Serializer<UInt_64> &payload);
};
}

14
include/ehs/io/socket/ehc/NetSys.h
View File

@ -17,8 +17,8 @@ namespace ehs
friend class NetServerCh;
friend class NetClientCh;
UInt_64 hashId;
Str_8 id;
UInt_64 id;
Str_8 name;
Array<NetOp*> ops;
public:
@ -26,7 +26,7 @@ namespace ehs
NetSys();
NetSys(Str_8 id);
NetSys(Str_8 name);
NetSys(NetSys &&sys) noexcept;
@ -36,15 +36,15 @@ namespace ehs
NetSys &operator=(const NetSys &sys);
Str_8 GetId() const;
UInt_64 GetId() const;
UInt_64 GetHashId() const;
Str_8 GetName() const;
bool HasOperation(UInt_64 hashId) const;
bool HasOperation(UInt_64 id) const;
bool AddOperation(NetOp *op);
private:
void Execute(NetChannel *channel, NetEnd *endpoint, UInt_64 hashId, Serializer<UInt_64> &payload);
void Execute(NetChannel *channel, NetEnd *issuer, UInt_64 opId, Serializer<UInt_64> &payload);
};
}

104
src/io/socket/EHC.cpp
View File

@ -270,58 +270,6 @@ namespace ehs
return true;
}
bool EHC::AddServer(NetServerCh *server)
{
if (HasServer(server->GetId()))
return false;
server->owner = this;
servers.Push(server);
return true;
}
bool EHC::AddClient(NetClientCh *client)
{
if (HasServer(client->GetId()))
return false;
client->owner = this;
clients.Push(client);
return true;
}
bool EHC::HasEncryption(UInt_64 encId) const
{
for (UInt_64 i = 0; i < encryptions.Size(); ++i)
if (encryptions[i]->GetId() == encId)
return true;
return false;
}
bool EHC::HasEncryption(const Str_8& encName) const
{
return HasEncryption(encName.Hash_64());
}
NetEnc* EHC::GetEncryption(UInt_64 encId) const
{
for (UInt_64 i = 0; i < encryptions.Size(); ++i)
if (encryptions[i]->GetId() == encId)
return encryptions[i];
return nullptr;
}
NetEnc* EHC::GetEncryption(const Str_8& encName) const
{
return GetEncryption(encName.Hash_64());
}
bool EHC::HasServer(const UInt_64 serverId) const
{
for (UInt_64 i = 0; i < servers.Size(); ++i)
@ -336,6 +284,18 @@ namespace ehs
return HasServer(serverName.Hash_64());
}
bool EHC::AddServer(NetServerCh *server)
{
if (HasServer(server->GetId()))
return false;
server->owner = this;
servers.Push(server);
return true;
}
NetServerCh *EHC::GetServer(const UInt_64 serverId) const
{
for (UInt_64 i = 0; i < servers.Size(); ++i)
@ -364,6 +324,18 @@ namespace ehs
return HasClient(clientName.Hash_64());
}
bool EHC::AddClient(NetClientCh *client)
{
if (HasServer(client->GetId()))
return false;
client->owner = this;
clients.Push(client);
return true;
}
NetClientCh *EHC::GetClient(const UInt_64 clientId) const
{
for (UInt_64 i = 0; i < clients.Size(); ++i)
@ -377,4 +349,32 @@ namespace ehs
{
return GetClient(clientName.Hash_64());
}
bool EHC::HasEncryption(UInt_64 encId) const
{
for (UInt_64 i = 0; i < encryptions.Size(); ++i)
if (encryptions[i]->GetId() == encId)
return true;
return false;
}
bool EHC::HasEncryption(const Str_8& encName) const
{
return HasEncryption(encName.Hash_64());
}
NetEnc* EHC::GetEncryption(UInt_64 encId) const
{
for (UInt_64 i = 0; i < encryptions.Size(); ++i)
if (encryptions[i]->GetId() == encId)
return encryptions[i];
return nullptr;
}
NetEnc* EHC::GetEncryption(const Str_8& encName) const
{
return GetEncryption(encName.Hash_64());
}
}

18
src/io/socket/TCP_W32.cpp
View File

@ -90,9 +90,9 @@ namespace ehs
return;
}
if (IP == IP::V6)
if (ip == IP::V6)
hdl = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
else if (IP == IP::V4)
else if (ip == IP::V4)
hdl = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
else
return;
@ -142,9 +142,9 @@ namespace ehs
if (!IsValid() || bound || connection)
return;
if (IP == IP::V6)
if (ip == IP::V6)
Bind_v6(address, port);
else if (IP == IP::V4)
else if (ip == IP::V4)
Bind_v4(address, port);
this->localAddr = address;
@ -178,7 +178,7 @@ namespace ehs
UInt_32 addrLen = sizeof(sockaddr_in6);
TCP* client = new TCP();
client->IP = IP;
client->ip = ip;
client->localAddr = localAddr;
client->localPort = localPort;
client->connection = true;
@ -244,7 +244,7 @@ namespace ehs
remoteHostName = address;
remotePort = port;
if (IP == IP::V6)
if (ip == IP::V6)
{
if (IsIPv6Only())
remoteAddr = DNS::Resolve(IP::V6, address);
@ -253,7 +253,7 @@ namespace ehs
Connect_v6(remoteAddr, port);
}
else if (IP == IP::V4)
else if (ip == IP::V4)
{
remoteAddr = DNS::Resolve(IP::V4, address);
@ -359,7 +359,7 @@ namespace ehs
void TCP::SetIPv6Only(const bool value)
{
if (IP != IP::V6)
if (ip != IP::V6)
{
EHS_LOG_INT(LogType::WARN, 0, "Cannot set IPv6 only mode while socket is not using IPv6.");
return;
@ -383,7 +383,7 @@ namespace ehs
bool TCP::IsIPv6Only() const
{
if (IP != IP::V6)
if (ip != IP::V6)
return false;
if (!IsValid())

49
src/io/socket/UDP_W32.cpp
View File

@ -110,33 +110,32 @@ namespace ehs
bound = false;
}
void UDP::Bind(const IP type, const Str_8& address, const UInt_16 port)
void UDP::Bind(const Endpoint &endpoint)
{
if (!IsValid() || bound)
return;
if (type == IP::V6)
Bind_v6(address, port);
else if (type == IP::V4)
Bind_v4(address, port);
if (endpoint.version == IP::V6)
Bind_v6(endpoint.address, endpoint.port);
else if (endpoint.version == IP::V4)
Bind_v4(endpoint.address, endpoint.port);
this->address = address;
this->port = port;
localEndpoint = endpoint;
bound = true;
}
UInt_64 UDP::Send(const IP type, const Str_8& address, const UInt_16 port, const Byte *const data, const UInt_64 size)
UInt_64 UDP::Send(const Endpoint &endpoint, const Byte *const data, const UInt_64 size)
{
if (type == IP::V6)
return Send_v6(address, port, data, size);
else if (type == IP::V4)
return Send_v4(address, port, data, size);
if (endpoint.version == IP::V6)
return Send_v6(endpoint.address, endpoint.port, data, size);
else if (endpoint.version == IP::V4)
return Send_v4(endpoint.address, endpoint.port, data, size);
return 0;
}
UInt_64 UDP::Receive(IP* type, Str_8* const address, UInt_16* const port, Byte* const data, const UInt_64 size)
UInt_64 UDP::Receive(Endpoint *endpoint, Byte* const data, const UInt_64 size)
{
if (!IsValid())
{
@ -174,9 +173,11 @@ namespace ehs
return received;
}
*type = IP::V6;
*address = tmpAddr;
*port = ntohs(remote.sin6_port);
*endpoint = {
IP::V6,
tmpAddr,
ntohs(remote.sin6_port)
};
}
else if (addrLen == sizeof(sockaddr_in))
{
@ -191,9 +192,11 @@ namespace ehs
return received;
}
*type = IP::V4;
*address = tmpAddr;
*port = ntohs(((sockaddr_in*)&remote)->sin_port);
*endpoint = {
IP::V4,
tmpAddr,
ntohs(((sockaddr_in*)&remote)->sin_port)
};
}
return received;
@ -225,7 +228,7 @@ namespace ehs
void UDP::SetIPv6Only(const bool value)
{
if (type != IP::V6)
if (localEndpoint.version != IP::V6)
{
EHS_LOG_INT(LogType::WARN, 0, "Cannot set IPv6 only mode while socket is not using IPv6.");
return;
@ -249,7 +252,7 @@ namespace ehs
bool UDP::IsIPv6Only() const
{
if (type != IP::V6)
if (localEndpoint.version != IP::V6)
return false;
if (!IsValid())
@ -362,7 +365,7 @@ namespace ehs
Int_32 code = inet_pton(AF_INET6, addr, &result.sin6_addr);
if (!code)
{
EHS_LOG_INT(LogType::ERR, 1, "The given address, \"" + address + "\" is not valid.");
EHS_LOG_INT(LogType::ERR, 1, "The given address, \"" + addr + "\" is not valid.");
return 0;
}
else if (code == -1)
@ -403,7 +406,7 @@ namespace ehs
int code = inet_pton(AF_INET, addr, &result.sin_addr);
if (!code)
{
EHS_LOG_INT(LogType::ERR, 1, "The given address, \"" + address + "\" is not valid.");
EHS_LOG_INT(LogType::ERR, 1, "The given address, \"" + addr + "\" is not valid.");
return 0;
}
else if (code == -1)

30
src/io/socket/ehc/NetChannel.cpp
View File

@ -7,6 +7,16 @@
namespace ehs
{
const UInt_64 NetChannel::internalSys = Str_8::Hash_64("Internal");
const UInt_64 NetChannel::connectOp = Str_8::Hash_64("Connect");
const UInt_64 NetChannel::connectedOp = Str_8::Hash_64("Connected");
const UInt_64 NetChannel::rejectedOp = Str_8::Hash_64("Rejected");
const UInt_64 NetChannel::disconnectOp = Str_8::Hash_64("Disconnect");
const UInt_64 NetChannel::disconnectedOp = Str_8::Hash_64("Disconnected");
const UInt_64 NetChannel::statusUpdateOp = Str_8::Hash_64("StatusUpdate");
const UInt_64 NetChannel::pingOp = Str_8::Hash_64("Ping");
const UInt_64 NetChannel::pongOp = Str_8::Hash_64("Pong");
const UInt_64 NetChannel::latencyOp = Str_8::Hash_64("Latency");
const UInt_64 NetChannel::receivedOp = Str_8::Hash_64("Received");
NetChannel::~NetChannel()
{
@ -128,10 +138,10 @@ namespace ehs
bool NetChannel::AddSystem(NetSys *sys)
{
if (sys->GetHashId() == internalSys)
if (sys->GetId() == internalSys)
return false;
if (HasSystem(sys->GetHashId()))
if (HasSystem(sys->GetId()))
return false;
systems.Push(sys);
@ -153,31 +163,31 @@ namespace ehs
{
}
bool NetChannel::HasSystem(const UInt_64 sysHashId) const
bool NetChannel::HasSystem(const UInt_64 sysId) const
{
for (UInt_64 i = 0; i < systems.Size(); ++i)
if (systems[i]->GetHashId() == sysHashId)
if (systems[i]->GetId() == sysId)
return true;
return false;
}
bool NetChannel::HasSystem(const Str_8& sysId) const
bool NetChannel::HasSystem(const Str_8& sysName) const
{
return HasSystem(sysId.Hash_64());
return HasSystem(sysName.Hash_64());
}
NetSys* NetChannel::GetSystem(const UInt_64 sysHashId) const
NetSys* NetChannel::GetSystem(const UInt_64 sysId) const
{
for (UInt_64 i = 0; i < systems.Size(); ++i)
if (systems[i]->GetHashId() == sysHashId)
if (systems[i]->GetId() == sysId)
return systems[i];
return nullptr;
}
NetSys* NetChannel::GetSystem(const Str_8& sysId) const
NetSys* NetChannel::GetSystem(const Str_8& sysName) const
{
return GetSystem(sysId.Hash_64());
return GetSystem(sysName.Hash_64());
}
}

28
src/io/socket/ehc/NetOp.cpp
View File

@ -5,23 +5,23 @@
namespace ehs
{
NetOp::NetOp()
: hashId(0)
: id(0)
{
}
NetOp::NetOp(Str_8 id)
: hashId(id.Hash_64()), id((Str_8 &&)id)
NetOp::NetOp(Str_8 name)
: id(name.Hash_64()), name((Str_8 &&)name)
{
}
NetOp::NetOp(NetOp&& op) noexcept
: hashId(op.hashId), id((Str_8 &&)op.id)
: id(op.id), name((Str_8 &&)op.name)
{
op.hashId = 0;
op.id = 0;
}
NetOp::NetOp(const NetOp &op)
: hashId(op.hashId), id(op.id)
: id(op.id), name(op.name)
{
}
@ -30,10 +30,10 @@ namespace ehs
if (this == &op)
return *this;
hashId = op.hashId;
id = (Str_8 &&)op.id;
id = op.id;
name = (Str_8 &&)op.name;
op.hashId = 0;
op.id = 0;
return *this;
}
@ -43,23 +43,23 @@ namespace ehs
if (this == &op)
return *this;
hashId = op.hashId;
id = op.id;
name = op.name;
return *this;
}
Str_8 NetOp::GetId() const
UInt_64 NetOp::GetId() const
{
return id;
}
UInt_64 NetOp::GetHashId() const
Str_8 NetOp::GetName() const
{
return hashId;
return name;
}
void NetOp::Process(NetChannel *channel, NetEnd *endpoint, NetSys *sys, Serializer<UInt_64> &payload)
void NetOp::Execute(NetChannel *channel, NetEnd *endpoint, NetSys *sys, Serializer<UInt_64> &payload)
{
}
}

37
src/io/socket/ehc/NetSys.cpp
View File

@ -2,6 +2,7 @@
#include "ehs/io/socket/EHC.h"
#include "ehs/io/socket/ehc/NetEnd.h"
#include "ehs/io/socket/ehc/NetOp.h"
#include "ehs/io/socket/ehc/NetChannel.h"
namespace ehs
{
@ -14,23 +15,23 @@ namespace ehs
}
NetSys::NetSys()
: hashId(0)
: id(0)
{
}
NetSys::NetSys(Str_8 id)
: hashId(id.Hash_64()), id((Str_8&&)id)
NetSys::NetSys(Str_8 name)
: id(name.Hash_64()), name((Str_8&&)name)
{
}
NetSys::NetSys(NetSys&& sys) noexcept
: hashId(sys.hashId), id((Str_8&&)sys.id), ops((Array<NetOp*>&&)sys.ops)
: id(sys.id), name((Str_8&&)sys.name), ops((Array<NetOp*>&&)sys.ops)
{
sys.hashId = 0;
sys.id = 0;
}
NetSys::NetSys(const NetSys& sys)
: hashId(sys.hashId), id(sys.id)
: id(sys.id), name(sys.name)
{
}
@ -39,11 +40,11 @@ namespace ehs
if (this == &sys)
return *this;
hashId = sys.hashId;
id = (Str_8&&)sys.id;
id = sys.id;
name = (Str_8&&)sys.name;
ops = (Array<NetOp*>&&)sys.ops;
sys.hashId = 0;
sys.id = 0;
return *this;
}
@ -53,27 +54,27 @@ namespace ehs
if (this == &sys)
return *this;
hashId = sys.hashId;
id = sys.id;
name = sys.name;
ops = Array<NetOp*>();
return *this;
}
Str_8 NetSys::GetId() const
UInt_64 NetSys::GetId() const
{
return id;
}
UInt_64 NetSys::GetHashId() const
Str_8 NetSys::GetName() const
{
return hashId;
return name;
}
bool NetSys::HasOperation(const UInt_64 hashId) const
bool NetSys::HasOperation(const UInt_64 id) const
{
for (UInt_64 i = 0; i < ops.Size(); ++i)
if (ops[i]->GetHashId() == hashId)
if (ops[i]->GetId() == id)
return true;
return false;
@ -81,7 +82,7 @@ namespace ehs
bool NetSys::AddOperation(NetOp* op)
{
if (HasOperation(op->GetHashId()))
if (HasOperation(op->GetId()))
return false;
ops.Push(op);
@ -93,9 +94,9 @@ namespace ehs
{
for (UInt_64 i = 0; i < ops.Size(); ++i)
{
if (ops[i]->GetHashId() == hashId)
if (ops[i]->GetId() == hashId)
{
ops[i]->Process(channel, endpoint, this, payload);
ops[i]->Execute(channel, endpoint, this, payload);
return;
}
}