EventHorizonStudio/EHS
EventHorizonStudio/EHS
3
0
Fork 0
Code Issues 8 Pull Requests Actions Packages Projects 1 Releases 7 Wiki Activity

Added the capability for custom encryption's to be added to EHC.

Browse Source
This commit is contained in:
Arron David Nelson 2024-10-06 22:54:29 -07:00
parent 1feff0a25c
commit 8b01ee3c46
15 changed files with 392 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
CMakeLists.txt
View File

@ -132,11 +132,11 @@ set(EHS_SOURCES
include/ehs/io/socket/TCP.h include/ehs/io/socket/TCP.h
src/io/socket/SSL.cpp include/ehs/io/socket/SSL.h src/io/socket/SSL.cpp include/ehs/io/socket/SSL.h
include/ehs/io/socket/ehc/Utils.h include/ehs/io/socket/ehc/NetUtils.h
src/io/socket/EHC.cpp include/ehs/io/socket/EHC.h src/io/socket/EHC.cpp include/ehs/io/socket/EHC.h
src/io/socket/ehc/Fragments.cpp include/ehs/io/socket/ehc/Fragments.h src/io/socket/ehc/NetFrags.cpp include/ehs/io/socket/ehc/NetFrags.h
src/io/socket/ehc/NetEnd.cpp include/ehs/io/socket/ehc/NetEnd.h src/io/socket/ehc/NetEnd.cpp include/ehs/io/socket/ehc/NetEnd.h
src/io/socket/ehc/NetSystem.cpp include/ehs/io/socket/ehc/NetSystem.h src/io/socket/ehc/NetSys.cpp include/ehs/io/socket/ehc/NetSys.h
src/io/socket/ehc/NetOp.cpp include/ehs/io/socket/ehc/NetOp.h src/io/socket/ehc/NetOp.cpp include/ehs/io/socket/ehc/NetOp.h
src/io/socket/rest/Twitch.cpp include/ehs/io/socket/rest/Twitch.h src/io/socket/rest/Twitch.cpp include/ehs/io/socket/rest/Twitch.h
@ -185,6 +185,8 @@ set(EHS_SOURCES
include/ehs/io/BaseDirectory.h include/ehs/io/BaseDirectory.h
src/io/BaseDirectory.cpp src/io/BaseDirectory.cpp
include/ehs/io/Directory.h include/ehs/io/Directory.h
include/ehs/io/socket/ehc/NetEnc.h
src/io/socket/ehc/NetEnc.cpp
) )
if (IS_OS_WINDOWS) if (IS_OS_WINDOWS)

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

@ -1,7 +1,7 @@
#pragma once #pragma once
#include "ehs/io/socket/ehc/Utils.h" #include "ehs/io/socket/ehc/NetUtils.h"
#include "ehs/io/socket/ehc/NetEnc.h"
#include "ehs/Serializer.h" #include "ehs/Serializer.h"
#include "ehs/Vector.h" #include "ehs/Vector.h"
#include "ehs/Array.h" #include "ehs/Array.h"
@ -10,7 +10,7 @@
namespace ehs namespace ehs
{ {
class NetSystem; class NetSys;
class NetEnd; class NetEnd;
class EHC; class EHC;
@ -24,6 +24,7 @@ namespace ehs
class EHC class EHC
{ {
private: private:
friend class NetEnc;
friend class NetEnd; friend class NetEnd;
static const Version version; static const Version version;
@ -47,7 +48,8 @@ namespace ehs
bool dropPackets; bool dropPackets;
Byte* buffer; Byte* buffer;
UInt_32 bufferSize; UInt_32 bufferSize;
Array<NetSystem *> systems; Array<NetEnc *> encryptions;
Array<NetSys *> systems;
UInt_32 maxEndpoints; UInt_32 maxEndpoints;
UInt_64 lastTSC; UInt_64 lastTSC;
float delta; float delta;
@ -90,13 +92,13 @@ namespace ehs
bool Disconnect(EndDisp endDisp, const Char_8 token[64], const Str_8& msg); bool Disconnect(EndDisp endDisp, const Char_8 token[64], const Str_8& msg);
void Broadcast(EndDisp endDisp, Status endStatus, bool deltaLocked, bool encrypted, void Broadcast(EndDisp endDisp, Status endStatus, bool deltaLocked, UInt_64 encHashId,
bool ensure, UInt_64 sysHashId, UInt_64 opHashId, bool ensure, UInt_64 sysHashId, UInt_64 opHashId,
const Serializer<>& payload); const Serializer<UInt_64> &payload);
void Broadcast(EndDisp endDisp, Status endStatus, bool deltaLocked, bool encrypted, void Broadcast(EndDisp endDisp, Status endStatus, bool deltaLocked, const Str_8 &encId,
bool ensure, const Str_8& sysId, const Str_8& opId, bool ensure, const Str_8 &sysId, const Str_8 &opId,
const Serializer<>& payload); const Serializer<UInt_64> &payload);
void Poll(); void Poll();
@ -124,15 +126,25 @@ namespace ehs
bool IsDropPacketsEnabled() const; bool IsDropPacketsEnabled() const;
bool HasEncryption(UInt_64 encHashId) const;
bool HasEncryption(const Str_8& encId) const;
bool AddEncryption(NetEnc *enc);
NetEnc* GetEncryption(UInt_64 encHashId) const;
NetEnc* GetEncryption(const Str_8& encId) const;
bool HasSystem(UInt_64 sysHashId) const; bool HasSystem(UInt_64 sysHashId) const;
bool HasSystem(const Str_8& sysId) const; bool HasSystem(const Str_8& sysId) const;
bool AddSystem(NetSystem *sys); bool AddSystem(NetSys *sys);
NetSystem* GetSystem(UInt_64 sysHashId) const; NetSys* GetSystem(UInt_64 sysHashId) const;
NetSystem* GetSystem(const Str_8& sysId) const; NetSys* GetSystem(const Str_8& sysId) const;
bool HasEndpoint(EndDisp endDisp, Status endStatus, const Char_8 token[64]) const; bool HasEndpoint(EndDisp endDisp, Status endStatus, const Char_8 token[64]) const;

43
include/ehs/io/socket/ehc/Fragments.h
View File

@ -1,43 +0,0 @@
#pragma once
#include "Utils.h"
#include <ehs/Serializer.h>
namespace ehs
{
class Fragments
{
private:
Header header;
Serializer<UInt_64>* data;
UInt_64 size;
public:
~Fragments();
Fragments();
Fragments(const Header &header, const Serializer<UInt_64> &payload);
Fragments(const Header &header, UInt_64 size);
Fragments(Fragments &&frags) noexcept;
Fragments(const Fragments &frags);
Fragments &operator=(Fragments &&frags) noexcept;
Fragments &operator=(const Fragments &frags);
operator Serializer<UInt_64> *() const;
Header GetHeader() const;
UInt_64 Size() const;
bool IsComplete() const;
Packet Combine() const;
};
}

43
include/ehs/io/socket/ehc/NetEnc.h Normal file
View File

@ -0,0 +1,43 @@
#pragma once
#include "ehs/Str.h"
namespace ehs
{
class EHC;
class NetEnc
{
private:
friend class EHC;
EHC *owner;
UInt_64 hashId;
Str_8 id;
public:
virtual ~NetEnc() = default;
NetEnc();
NetEnc(Str_8 id);
NetEnc(NetEnc &&enc) noexcept;
NetEnc(const NetEnc &enc);
NetEnc &operator=(NetEnc &&enc) noexcept;
NetEnc &operator=(const NetEnc &enc);
EHC *GetOwner() const;
UInt_64 GetHashId() const;
Str_8 GetId() const;
virtual void Encrypt(Byte *data, UInt_64 size) const;
virtual void Decrypt(Byte *data, UInt_64 size) const;
};
}

26
include/ehs/io/socket/ehc/NetEnd.h
View File

@ -1,12 +1,12 @@
#pragma once #pragma once
#include "Utils.h" #include "NetUtils.h"
#include "Fragments.h" #include "NetFrags.h"
#include <ehs/Str.h> #include "ehs/Str.h"
#include <ehs/Vector.h> #include "ehs/Vector.h"
#include <ehs/Serializer.h> #include "ehs/Serializer.h"
#include <ehs/io/socket/Socket.h> #include "ehs/io/socket/Socket.h"
namespace ehs namespace ehs
{ {
@ -27,7 +27,7 @@ namespace ehs
UInt_64 nextSendId; UInt_64 nextSendId;
Vector<Insurance> sent; Vector<Insurance> sent;
UInt_64 nextRecvId; UInt_64 nextRecvId;
Vector<Fragments> received; Vector<NetFrags> received;
AddrType type; AddrType type;
Str_8 address; Str_8 address;
UInt_16 port; UInt_16 port;
@ -68,21 +68,21 @@ namespace ehs
/// Sends data to the remote endpoint. /// Sends data to the remote endpoint.
/// @param [in] deltaLocked Whether or not to match the remote endpoint's delta time to prevent overloading the client. This will drop data if delta time does not match. /// @param [in] deltaLocked Whether or not to match the remote endpoint's delta time to prevent overloading the client. This will drop data if delta time does not match.
/// @param [in] encrypted Whether or not to encrypt this data before sending to the remote endpoint. /// @param [in] encHashId The hash id of the encryption to use. Can be zero for none.
/// @param [in] ensure Whether or not to ensure the data was received by the remote endpoint. /// @param [in] ensure Whether or not to ensure the data was received by the remote endpoint.
/// @param [in] sys The system hash id to execute an operation from. /// @param [in] sys The system hash id to execute an operation from.
/// @param [in] op The operation hash id in the system to execute. /// @param [in] op The operation hash id in the system to execute.
/// @param [in] payload Additional parameters and data to send to the remote endpoint. /// @param [in] payload Additional parameters and data to send to the remote endpoint.
void Send(bool deltaLocked, bool encrypted, bool ensure, UInt_64 sys, UInt_64 op, const Serializer<UInt_64>& payload); void Send(bool deltaLocked, UInt_64 encHashId, bool ensure, UInt_64 sys, UInt_64 op, const Serializer<UInt_64>& payload);
/// Sends data to the remote endpoint. /// Sends data to the remote endpoint.
/// @param [in] deltaLocked Whether or not to match the remote endpoint's delta time to prevent overloading the client. This will drop data if delta time does not match. /// @param [in] deltaLocked Whether or not to match the remote endpoint's delta time to prevent overloading the client. This will drop data if delta time does not match.
/// @param [in] encrypted Whether or not to encrypt this data before sending to the remote endpoint. /// @param [in] encId The id of the encryption to use. Can be empty for none.
/// @param [in] ensure Whether or not to ensure the data was received by the remote endpoint. /// @param [in] ensure Whether or not to ensure the data was received by the remote endpoint.
/// @param [in] sys The system string id to execute an operation from. /// @param [in] sys The system string id to execute an operation from.
/// @param [in] op The operation string id in the system to execute. /// @param [in] op The operation string id in the system to execute.
/// @param [in] payload Additional parameters and data to send to the remote endpoint. /// @param [in] payload Additional parameters and data to send to the remote endpoint.
void Send(bool deltaLocked, bool encrypted, bool ensure, const Str_8& sys, const Str_8& op, const Serializer<UInt_64>& payload); void Send(bool deltaLocked, const Str_8 &encID, bool ensure, const Str_8& sys, const Str_8& op, const Serializer<UInt_64>& payload);
UInt_64 GetNextRecvId() const; UInt_64 GetNextRecvId() const;
@ -113,7 +113,7 @@ namespace ehs
void AddReceived(const Header& header, const Serializer<>& payload); void AddReceived(const Header& header, const Serializer<>& payload);
Vector<Fragments>* GetReceived(); Vector<NetFrags>* GetReceived();
void Ping(float delta); void Ping(float delta);
@ -123,7 +123,7 @@ namespace ehs
void SetQueueSlot(UInt_64 slot); void SetQueueSlot(UInt_64 slot);
Fragments FragmentData(const Header& header, const Serializer<>& data); NetFrags FragmentData(const Header& header, const Serializer<>& data);
void Send(const Header& header, const Serializer<>& payload); void Send(const Header& header, const Serializer<>& payload);

43
include/ehs/io/socket/ehc/NetFrags.h Normal file
View File

@ -0,0 +1,43 @@
#pragma once
#include "NetUtils.h"
#include <ehs/Serializer.h>
namespace ehs
{
class NetFrags
{
private:
Header header;
Serializer<UInt_64>* data;
UInt_64 size;
public:
~NetFrags();
NetFrags();
NetFrags(const Header &header, const Serializer<UInt_64> &payload);
NetFrags(const Header &header, UInt_64 size);
NetFrags(NetFrags &&frags) noexcept;
NetFrags(const NetFrags &frags);
NetFrags &operator=(NetFrags &&frags) noexcept;
NetFrags &operator=(const NetFrags &frags);
operator Serializer<UInt_64> *() const;
Header GetHeader() const;
UInt_64 Size() const;
bool IsComplete() const;
Packet Combine() const;
};
}

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

@ -1,18 +1,18 @@
#pragma once #pragma once
#include <ehs/Str.h> #include "ehs/Str.h"
#include <ehs/Serializer.h> #include "ehs/Serializer.h"
namespace ehs namespace ehs
{ {
class EHC; class EHC;
class NetSystem; class NetSys;
class NetEnd; class NetEnd;
class NetOp class NetOp
{ {
private: private:
friend class NetSystem; friend class NetSys;
UInt_64 hashId; UInt_64 hashId;
Str_8 id; Str_8 id;
@ -37,6 +37,6 @@ namespace ehs
UInt_64 GetHashId() const; UInt_64 GetHashId() const;
private: private:
virtual void Process(EHC *ehc, NetEnd *endpoint, NetSystem *sys, Serializer<UInt_64> &payload); virtual void Process(EHC *ehc, NetEnd *endpoint, NetSys *sys, Serializer<UInt_64> &payload);
}; };
} }

22
include/ehs/io/socket/ehc/NetSystem.h → include/ehs/io/socket/ehc/NetSys.h
View File

@ -1,8 +1,8 @@
#pragma once #pragma once
#include <ehs/Str.h> #include "ehs/Str.h"
#include <ehs/Array.h> #include "ehs/Array.h"
#include <ehs/Serializer.h> #include "ehs/Serializer.h"
namespace ehs namespace ehs
{ {
@ -10,7 +10,7 @@ namespace ehs
class NetEnd; class NetEnd;
class NetOp; class NetOp;
class NetSystem class NetSys
{ {
private: private:
friend class EHC; friend class EHC;
@ -20,19 +20,19 @@ namespace ehs
Array<NetOp*> ops; Array<NetOp*> ops;
public: public:
virtual ~NetSystem(); virtual ~NetSys();
NetSystem(); NetSys();
NetSystem(Str_8 id); NetSys(Str_8 id);
NetSystem(NetSystem &&sys) noexcept; NetSys(NetSys &&sys) noexcept;
NetSystem(const NetSystem &sys); NetSys(const NetSys &sys);
NetSystem &operator=(NetSystem &&sys) noexcept; NetSys &operator=(NetSys &&sys) noexcept;
NetSystem &operator=(const NetSystem &sys); NetSys &operator=(const NetSys &sys);
Str_8 GetId() const; Str_8 GetId() const;

12
include/ehs/io/socket/ehc/Utils.h → include/ehs/io/socket/ehc/NetUtils.h
View File

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <ehs/Serializer.h> #include "ehs/Serializer.h"
namespace ehs namespace ehs
{ {
@ -20,7 +20,7 @@ namespace ehs
struct Header struct Header
{ {
bool encrypted = true; UInt_64 encHashId = 0;
UInt_64 id = 0; UInt_64 id = 0;
UInt_64 fragments = 0; UInt_64 fragments = 0;
UInt_64 fragment = 0; UInt_64 fragment = 0;
@ -45,10 +45,10 @@ namespace ehs
}; };
} }
#ifndef COMMS_IPV4_PAYLOAD #ifndef EHC_IPV4_PAYLOAD
#define COMMS_IPV4_PAYLOAD (EHS_IPV4_UDP_PAYLOAD - (UInt_16)sizeof(Header)) #define EHC_IPV4_PAYLOAD (EHS_IPV4_UDP_PAYLOAD - (UInt_16)sizeof(Header))
#endif #endif
#ifndef COMMS_IPV6_PAYLOAD #ifndef EHC_IPV6_PAYLOAD
#define COMMS_IPV6_PAYLOAD (EHS_IPV6_UDP_PAYLOAD - (UInt_16)sizeof(Header)) #define EHC_IPV6_PAYLOAD (EHS_IPV6_UDP_PAYLOAD - (UInt_16)sizeof(Header))
#endif #endif

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

@ -1,10 +1,10 @@
#include "ehs/io/socket/EHC.h" #include "ehs/io/socket/EHC.h"
#include "ehs/io/socket/ehc/NetSystem.h" #include "ehs/io/socket/ehc/NetEnc.h"
#include "ehs/io/socket/ehc/NetSys.h"
#include "ehs/io/socket/ehc/NetEnd.h" #include "ehs/io/socket/ehc/NetEnd.h"
#include "ehs/Log.h" #include "ehs/Log.h"
#include "ehs/PRNG.h" #include "ehs/PRNG.h"
#include <ehe/Encryption.h>
namespace ehs namespace ehs
{ {
@ -54,11 +54,15 @@ namespace ehs
EHC::EHC(EHC &&sock) noexcept EHC::EHC(EHC &&sock) noexcept
: udp((UDP&&)sock.udp), appVer(sock.appVer), disposition(sock.disposition), hashName(sock.hashName), : udp((UDP&&)sock.udp), appVer(sock.appVer), disposition(sock.disposition), hashName(sock.hashName),
name((Str_8&&)sock.name), dropPackets(sock.dropPackets), buffer(sock.buffer), bufferSize(sock.bufferSize), name((Str_8&&)sock.name), dropPackets(sock.dropPackets), buffer(sock.buffer), bufferSize(sock.bufferSize),
systems((Array<NetSystem *> &&)sock.systems), maxEndpoints(sock.maxEndpoints), lastTSC(sock.lastTSC), encryptions((Array<NetEnc *> &&)sock.encryptions), systems((Array<NetSys *> &&)sock.systems),
delta(sock.delta), maxTimeout(sock.maxTimeout), resendRate(sock.resendRate), connectCb(sock.connectCb), maxEndpoints(sock.maxEndpoints), lastTSC(sock.lastTSC), delta(sock.delta), maxTimeout(sock.maxTimeout),
connectedCb(sock.connectedCb), activeCb(sock.activeCb), disconnectCb(sock.disconnectCb), resendRate(sock.resendRate), connectCb(sock.connectCb), connectedCb(sock.connectedCb), activeCb(sock.activeCb),
disconnectedCb(sock.disconnectedCb), timeoutCb(sock.timeoutCb), endpoints((Vector<NetEnd *> &&)sock.endpoints) disconnectCb(sock.disconnectCb), disconnectedCb(sock.disconnectedCb), timeoutCb(sock.timeoutCb),
endpoints((Vector<NetEnd *> &&)sock.endpoints)
{ {
for (UInt_64 i = 0; i < encryptions.Size(); ++i)
endpoints[i]->owner = this;
for (UInt_64 i = 0; i < endpoints.Size(); ++i) for (UInt_64 i = 0; i < endpoints.Size(); ++i)
endpoints[i]->owner = this; endpoints[i]->owner = this;
@ -107,7 +111,12 @@ namespace ehs
buffer = sock.buffer; buffer = sock.buffer;
bufferSize = sock.bufferSize; bufferSize = sock.bufferSize;
systems = (Array<NetSystem *> &&)sock.systems;
encryptions = (Array<NetEnc *> &&)sock.encryptions;
for (UInt_64 i = 0; i < encryptions.Size(); ++i)
encryptions[i]->owner = this;
systems = (Array<NetSys *> &&)sock.systems;
maxEndpoints = sock.maxEndpoints; maxEndpoints = sock.maxEndpoints;
lastTSC = sock.lastTSC; lastTSC = sock.lastTSC;
delta = sock.delta; delta = sock.delta;
@ -161,7 +170,7 @@ namespace ehs
buffer = nullptr; buffer = nullptr;
bufferSize = 0; bufferSize = 0;
systems = Array<NetSystem *>(); systems = Array<NetSys *>();
maxEndpoints = sock.maxEndpoints; maxEndpoints = sock.maxEndpoints;
lastTSC = 0; lastTSC = 0;
delta = 0.0f; delta = 0.0f;
@ -273,7 +282,7 @@ namespace ehs
return true; return true;
} }
void EHC::Broadcast(const EndDisp endDisp, const Status endStatus, const bool deltaLocked, const bool encrypted, void EHC::Broadcast(const EndDisp endDisp, const Status endStatus, const bool deltaLocked, const UInt_64 encHashId,
const bool ensure, const UInt_64 sysHashId, const UInt_64 opHashId, const Serializer<UInt_64> &payload) const bool ensure, const UInt_64 sysHashId, const UInt_64 opHashId, const Serializer<UInt_64> &payload)
{ {
if (!udp.IsValid()) if (!udp.IsValid())
@ -285,15 +294,15 @@ namespace ehs
continue; continue;
if (endpoints[i]->GetStatus() == endStatus) if (endpoints[i]->GetStatus() == endStatus)
endpoints[i]->Send(deltaLocked, encrypted, ensure, sysHashId, opHashId, payload); endpoints[i]->Send(deltaLocked, encHashId, ensure, sysHashId, opHashId, payload);
} }
} }
void EHC::Broadcast(const EndDisp endDisp, const Status endStatus, const bool deltaLocked, const bool encrypted, void EHC::Broadcast(const EndDisp endDisp, const Status endStatus, const bool deltaLocked, const Str_8 &encId,
const bool ensure, const Str_8 &sysId, const Str_8 &opId, const bool ensure, const Str_8 &sysId, const Str_8 &opId,
const Serializer<UInt_64> &payload) const Serializer<UInt_64> &payload)
{ {
Broadcast(endDisp, endStatus, deltaLocked, encrypted, ensure, sysId.Hash_64(), opId.Hash_64(), payload); Broadcast(endDisp, endStatus, deltaLocked, encId.Hash_64(), ensure, sysId.Hash_64(), opId.Hash_64(), payload);
} }
void EHC::Poll() void EHC::Poll()
@ -315,9 +324,15 @@ namespace ehs
{ {
Serializer<> payload(Endianness::LE, buffer, received); Serializer<> payload(Endianness::LE, buffer, received);
bool encrypted = payload.Read<bool>(); UInt_64 encHashId = payload.Read<UInt_64>();
if (encrypted) if (encHashId)
Encryption::Encrypt_64(payload.Size() - payload.GetOffset(), &payload[payload.GetOffset()]); {
NetEnc* enc = GetEncryption(encHashId);
if (!enc)
continue;
enc->Encrypt(&payload[payload.GetOffset()], payload.Size() - payload.GetOffset());
}
payload.SetOffset(0); payload.SetOffset(0);
@ -609,6 +624,45 @@ namespace ehs
return dropPackets; return dropPackets;
} }
bool EHC::HasEncryption(UInt_64 encHashId) const
{
for (UInt_64 i = 0; i < encryptions.Size(); ++i)
if (encryptions[i]->GetHashId() == encHashId)
return true;
return false;
}
bool EHC::HasEncryption(const Str_8& encId) const
{
return HasEncryption(encId.Hash_64());
}
bool EHC::AddEncryption(NetEnc* enc)
{
if (HasEncryption(enc->GetHashId()))
return false;
enc->owner = this;
encryptions.Push(enc);
return true;
}
NetEnc* EHC::GetEncryption(UInt_64 encHashId) const
{
for (UInt_64 i = 0; i < encryptions.Size(); ++i)
if (encryptions[i]->GetHashId() == encHashId)
return encryptions[i];
return nullptr;
}
NetEnc* EHC::GetEncryption(const Str_8& encId) const
{
return GetEncryption(encId.Hash_64());
}
bool EHC::HasSystem(const UInt_64 sysHashId) const bool EHC::HasSystem(const UInt_64 sysHashId) const
{ {
if (internalSys == sysHashId) if (internalSys == sysHashId)
@ -626,7 +680,7 @@ namespace ehs
return HasSystem(sysId.Hash_64()); return HasSystem(sysId.Hash_64());
} }
bool EHC::AddSystem(NetSystem *sys) bool EHC::AddSystem(NetSys *sys)
{ {
if (HasSystem(sys->GetHashId())) if (HasSystem(sys->GetHashId()))
return false; return false;
@ -636,7 +690,7 @@ namespace ehs
return true; return true;
} }
NetSystem* EHC::GetSystem(const UInt_64 sysHashId) const NetSys* EHC::GetSystem(const UInt_64 sysHashId) const
{ {
for (UInt_64 i = 0; i < systems.Size(); ++i) for (UInt_64 i = 0; i < systems.Size(); ++i)
if (systems[i]->GetHashId() == sysHashId) if (systems[i]->GetHashId() == sysHashId)
@ -645,7 +699,7 @@ namespace ehs
return nullptr; return nullptr;
} }
NetSystem* EHC::GetSystem(const Str_8& sysId) const NetSys* EHC::GetSystem(const Str_8& sysId) const
{ {
return GetSystem(sysId.Hash_64()); return GetSystem(sysId.Hash_64());
} }
@ -1121,7 +1175,7 @@ namespace ehs
continue; continue;
} }
Vector<Fragments>* frags = endpoints[i]->GetReceived(); Vector<NetFrags>* frags = endpoints[i]->GetReceived();
UInt_64 f = 0; UInt_64 f = 0;
while (f < frags->Size()) while (f < frags->Size())
@ -1134,7 +1188,7 @@ namespace ehs
Packet packet = (*frags)[f].Combine(); Packet packet = (*frags)[f].Combine();
NetSystem* sys = GetSystem(packet.header.system); NetSys* sys = GetSystem(packet.header.system);
if (!sys) if (!sys)
{ {
++f; ++f;

76
src/io/socket/ehc/NetEnc.cpp Normal file
View File

@ -0,0 +1,76 @@
#include "ehs/io/socket/ehc/NetEnc.h"
namespace ehs
{
NetEnc::NetEnc()
: owner(nullptr), hashId(0)
{
}
NetEnc::NetEnc(Str_8 id)
: owner(nullptr), hashId(id.Hash_64()), id((Str_8 &&)id)
{
}
NetEnc::NetEnc(NetEnc&& enc) noexcept
: owner(enc.owner), hashId(enc.hashId), id((Str_8 &&)enc.id)
{
enc.owner = nullptr;
enc.hashId = 0;
}
NetEnc::NetEnc(const NetEnc& enc)
: owner(nullptr), hashId(enc.hashId), id(enc.id)
{
}
NetEnc& NetEnc::operator=(NetEnc&& enc) noexcept
{
if (this == &enc)
return *this;
owner = enc.owner;
hashId = enc.hashId;
id = (Str_8 &&)enc.id;
enc.owner = nullptr;
enc.hashId = 0;
return *this;
}
NetEnc& NetEnc::operator=(const NetEnc& enc)
{
if (this == &enc)
return *this;
owner = nullptr;
hashId = enc.hashId;
id = enc.id;
return *this;
}
EHC* NetEnc::GetOwner() const
{
return owner;
}
UInt_64 NetEnc::GetHashId() const
{
return hashId;
}
Str_8 NetEnc::GetId() const
{
return id;
}
void NetEnc::Encrypt(Byte *data, UInt_64 size) const
{
}
void NetEnc::Decrypt(Byte *data, UInt_64 size) const
{
}
}

101
src/io/socket/ehc/NetEnd.cpp
View File

@ -1,8 +1,7 @@
#include "ehs/io/socket/ehc/NetEnd.h" #include "ehs/io/socket/ehc/NetEnd.h"
#include "ehs/io/socket/EHC.h" #include "ehs/io/socket/EHC.h"
#include "ehs/io/socket/ehc/NetEnc.h"
#include <ehs/system/CPU.h> #include "ehs/system/CPU.h"
#include <ehe/Encryption.h>
namespace ehs namespace ehs
{ {
@ -33,10 +32,10 @@ namespace ehs
NetEnd::NetEnd(NetEnd &&end) noexcept NetEnd::NetEnd(NetEnd &&end) noexcept
: owner(end.owner), disposition(end.disposition), hashName(end.hashName), name((Str_8&&)end.name), status(end.status), arch(end.arch), token{}, : owner(end.owner), disposition(end.disposition), hashName(end.hashName), name((Str_8&&)end.name), status(end.status), arch(end.arch), token{},
nextSendId(end.nextSendId), sent((Vector<Insurance>&&)end.sent), nextRecvId(end.nextRecvId), nextSendId(end.nextSendId), sent((Vector<Insurance>&&)end.sent), nextRecvId(end.nextRecvId),
received((Vector<Fragments>&&)end.received), type(end.type), address((Str_8&&)end.address), port(end.port), received((Vector<NetFrags>&&)end.received), type(end.type), address((Str_8&&)end.address), port(end.port),
deltaDuration(end.deltaDuration), deltaRate(end.deltaRate), timeout(end.timeout), lastPing(end.lastPing), deltaDuration(end.deltaDuration), deltaRate(end.deltaRate), timeout(end.timeout), lastPing(end.lastPing),
oldLatency(end.oldLatency), latency(end.latency), queueSlot(end.queueSlot) oldLatency(end.oldLatency), latency(end.latency), queueSlot(end.queueSlot)
{ {
end.owner = nullptr; end.owner = nullptr;
end.disposition = EndDisp::ENDPOINT; end.disposition = EndDisp::ENDPOINT;
@ -80,7 +79,7 @@ namespace ehs
nextSendId = end.nextSendId; nextSendId = end.nextSendId;
sent = (Vector<Insurance>&&)end.sent; sent = (Vector<Insurance>&&)end.sent;
nextRecvId = end.nextRecvId; nextRecvId = end.nextRecvId;
received = (Vector<Fragments>&&)end.received; received = (Vector<NetFrags>&&)end.received;
type = end.type; type = end.type;
address = (Str_8&&)end.address; address = (Str_8&&)end.address;
port = end.port; port = end.port;
@ -173,14 +172,14 @@ namespace ehs
return nextSendId; return nextSendId;
} }
void NetEnd::Send(const bool deltaLocked, const bool encrypted, const bool ensure, const UInt_64 sys, void NetEnd::Send(const bool deltaLocked, const UInt_64 encHashId, const bool ensure, const UInt_64 sys,
const UInt_64 op, const Serializer<>& payload) const UInt_64 op, const Serializer<UInt_64> &payload)
{ {
if (deltaLocked && deltaDuration < deltaRate) if (deltaLocked && deltaDuration < deltaRate)
return; return;
Header header = { Header header = {
encrypted, encHashId,
nextSendId++, nextSendId++,
1, 1,
0, 0,
@ -193,9 +192,9 @@ namespace ehs
Util::Copy(header.token, token, 64); Util::Copy(header.token, token, 64);
if ((owner->GetLocalAddressType() == AddrType::IPV6 && payload.Size() > COMMS_IPV6_PAYLOAD) || (owner->GetLocalAddressType() == AddrType::IPV4 && payload.Size() > COMMS_IPV4_PAYLOAD)) if ((owner->GetLocalAddressType() == AddrType::IPV6 && payload.Size() > EHC_IPV6_PAYLOAD) || (owner->GetLocalAddressType() == AddrType::IPV4 && payload.Size() > EHC_IPV4_PAYLOAD))
{ {
Fragments frags = FragmentData(header, payload); NetFrags frags = FragmentData(header, payload);
for (UInt_64 i = 0; i < frags.Size(); ++i) for (UInt_64 i = 0; i < frags.Size(); ++i)
{ {
Header newHeader = frags.GetHeader(); Header newHeader = frags.GetHeader();
@ -210,10 +209,10 @@ namespace ehs
} }
} }
void NetEnd::Send(const bool deltaLocked, const bool encrypted, const bool ensure, const Str_8& sys, void NetEnd::Send(const bool deltaLocked, const Str_8 &encId, const bool ensure, const Str_8& sys,
const Str_8& op, const Serializer<>& payload) const Str_8& op, const Serializer<>& payload)
{ {
Send(deltaLocked, encrypted, ensure, sys.Hash_64(), op.Hash_64(), payload); Send(deltaLocked, encId.Hash_64(), ensure, sys.Hash_64(), op.Hash_64(), payload);
} }
UInt_64 NetEnd::GetNextRecvId() const UInt_64 NetEnd::GetNextRecvId() const
@ -278,8 +277,19 @@ namespace ehs
result.Write(sent[i].header); result.Write(sent[i].header);
result.WriteSer(sent[i].payload); result.WriteSer(sent[i].payload);
if (sent[i].header.encrypted) if (sent[i].header.encHashId)
Encryption::Encrypt_64(result.Size() - sizeof(bool), &result[sizeof(bool)]); {
NetEnc *enc = owner->GetEncryption(sent[i].header.encHashId);
if (!enc)
{
EHS_LOG_INT(LogType::WARN, 0, "The network encryption with the hash id " +
Str_8::FromNum(sent[i].header.encHashId) + ", does not exist.");
continue;
}
enc->Encrypt(&result[sizeof(bool)], result.Size() - sizeof(bool));
}
owner->udp.Send(type, address, port, result, result.Size()); owner->udp.Send(type, address, port, result, result.Size());
@ -294,6 +304,8 @@ namespace ehs
if (lastPing >= 1.0f) if (lastPing >= 1.0f)
Ping(delta); Ping(delta);
} }
EHS_LOG_SUCCESS();
} }
void NetEnd::SetStatus(const Status newStatus) void NetEnd::SetStatus(const Status newStatus)
@ -317,7 +329,7 @@ namespace ehs
void NetEnd::AddReceived(const Header& header, const Serializer<>& payload) void NetEnd::AddReceived(const Header& header, const Serializer<>& payload)
{ {
Fragments* frags = nullptr; NetFrags* frags = nullptr;
for (UInt_64 i = 0; i < received.Size(); ++i) for (UInt_64 i = 0; i < received.Size(); ++i)
{ {
@ -342,7 +354,7 @@ namespace ehs
timeout = 0.0f; timeout = 0.0f;
} }
Vector<Fragments>* NetEnd::GetReceived() Vector<NetFrags>* NetEnd::GetReceived()
{ {
return &received; return &received;
} }
@ -395,46 +407,46 @@ namespace ehs
queueSlot = slot; queueSlot = slot;
} }
Fragments NetEnd::FragmentData(const Header& header, const Serializer<>& data) NetFrags NetEnd::FragmentData(const Header& header, const Serializer<>& data)
{ {
Fragments result; NetFrags result;
if (owner->GetLocalAddressType() == AddrType::IPV6) if (owner->GetLocalAddressType() == AddrType::IPV6)
{ {
UInt_64 frags = data.Size() / COMMS_IPV6_PAYLOAD; UInt_64 frags = data.Size() / EHC_IPV6_PAYLOAD;
if (data.Size() % COMMS_IPV6_PAYLOAD) if (data.Size() % EHC_IPV6_PAYLOAD)
++frags; ++frags;
result = Fragments(header, frags); result = NetFrags(header, frags);
UInt_64 size = COMMS_IPV6_PAYLOAD; UInt_64 size = EHC_IPV6_PAYLOAD;
for (UInt_64 i = 0; i < result.Size(); ++i) for (UInt_64 i = 0; i < result.Size(); ++i)
{ {
size = COMMS_IPV6_PAYLOAD; size = EHC_IPV6_PAYLOAD;
if (i == result.Size() - 1) if (i == result.Size() - 1)
size = data.Size() % COMMS_IPV6_PAYLOAD; size = data.Size() % EHC_IPV6_PAYLOAD;
result[i] = {data.GetEndianness(), &data[i * COMMS_IPV6_PAYLOAD], size}; result[i] = {data.GetEndianness(), &data[i * EHC_IPV6_PAYLOAD], size};
} }
} }
else if (owner->GetLocalAddressType() == AddrType::IPV4) else if (owner->GetLocalAddressType() == AddrType::IPV4)
{ {
UInt_64 frags = data.Size() / COMMS_IPV4_PAYLOAD; UInt_64 frags = data.Size() / EHC_IPV4_PAYLOAD;
if (data.Size() % COMMS_IPV4_PAYLOAD) if (data.Size() % EHC_IPV4_PAYLOAD)
++frags; ++frags;
result = Fragments(header, frags); result = NetFrags(header, frags);
UInt_64 size = COMMS_IPV4_PAYLOAD; UInt_64 size = EHC_IPV4_PAYLOAD;
for (UInt_64 i = 0; i < result.Size(); ++i) for (UInt_64 i = 0; i < result.Size(); ++i)
{ {
size = COMMS_IPV4_PAYLOAD; size = EHC_IPV4_PAYLOAD;
if (i == result.Size() - 1) if (i == result.Size() - 1)
size = data.Size() % COMMS_IPV4_PAYLOAD; size = data.Size() % EHC_IPV4_PAYLOAD;
result[i] = {data.GetEndianness(), &data[i * COMMS_IPV4_PAYLOAD], size}; result[i] = {data.GetEndianness(), &data[i * EHC_IPV4_PAYLOAD], size};
} }
} }
@ -447,8 +459,19 @@ namespace ehs
result.Write(header); result.Write(header);
result.WriteSer(payload); result.WriteSer(payload);
if (header.encrypted) if (header.encHashId)
Encryption::Encrypt_64(result.Size() - sizeof(bool), &result[sizeof(bool)]); {
NetEnc *enc = owner->GetEncryption(header.encHashId);
if (!enc)
{
EHS_LOG_INT(LogType::WARN, 0, "The network encryption with the hash id " +
Str_8::FromNum(header.encHashId) + ", does not exist.");
return;
}
enc->Encrypt(&result[sizeof(bool)], result.Size() - sizeof(bool));
}
if (header.ensure) if (header.ensure)
sent.Push({header, payload}); sent.Push({header, payload});
@ -476,7 +499,7 @@ namespace ehs
if (!SortingNeeded()) if (!SortingNeeded())
return; return;
Vector<Fragments> sorted(0, received.Stride()); Vector<NetFrags> sorted(0, received.Stride());
for (UInt_64 a = 0; a < received.Size(); ++a) for (UInt_64 a = 0; a < received.Size(); ++a)
{ {

28
src/io/socket/ehc/Fragments.cpp → src/io/socket/ehc/NetFrags.cpp
View File

@ -1,32 +1,32 @@
#include "ehs/io/socket/ehc/Fragments.h" #include "ehs/io/socket/ehc/NetFrags.h"
namespace ehs namespace ehs
{ {
Fragments::~Fragments() NetFrags::~NetFrags()
{ {
delete[] data; delete[] data;
} }
Fragments::Fragments() NetFrags::NetFrags()
: data(nullptr), size(0) : data(nullptr), size(0)
{ {
} }
Fragments::Fragments(const Header &header, const Serializer<UInt_64> &payload) NetFrags::NetFrags(const Header &header, const Serializer<UInt_64> &payload)
: header(header), data(new Serializer<UInt_64>[header.fragments]), size(header.fragments) : header(header), data(new Serializer<UInt_64>[header.fragments]), size(header.fragments)
{ {
this->header.fragment = 0; this->header.fragment = 0;
data[header.fragment] = payload; data[header.fragment] = payload;
} }
Fragments::Fragments(const Header &header, const UInt_64 size) NetFrags::NetFrags(const Header &header, const UInt_64 size)
: header(header), data(new Serializer<UInt_64>[size]), size(size) : header(header), data(new Serializer<UInt_64>[size]), size(size)
{ {
this->header.fragments = size; this->header.fragments = size;
this->header.fragment = 0; this->header.fragment = 0;
} }
Fragments::Fragments(Fragments &&frags) noexcept NetFrags::NetFrags(NetFrags &&frags) noexcept
: header(frags.header), data(frags.data), size(frags.size) : header(frags.header), data(frags.data), size(frags.size)
{ {
frags.header = {}; frags.header = {};
@ -34,14 +34,14 @@ namespace ehs
frags.size = 0; frags.size = 0;
} }
Fragments::Fragments(const Fragments &frags) NetFrags::NetFrags(const NetFrags &frags)
: header(frags.header), data(new Serializer<UInt_64>[frags.size]), size(frags.size) : header(frags.header), data(new Serializer<UInt_64>[frags.size]), size(frags.size)
{ {
for (UInt_64 i = 0; i < size; ++i) for (UInt_64 i = 0; i < size; ++i)
data[i] = frags.data[i]; data[i] = frags.data[i];
} }
Fragments &Fragments::operator=(Fragments &&frags) noexcept NetFrags &NetFrags::operator=(NetFrags &&frags) noexcept
{ {
if (this == &frags) if (this == &frags)
return *this; return *this;
@ -60,7 +60,7 @@ namespace ehs
return *this; return *this;
} }
Fragments &Fragments::operator=(const Fragments &frags) NetFrags &NetFrags::operator=(const NetFrags &frags)
{ {
if (this == &frags) if (this == &frags)
return *this; return *this;
@ -75,22 +75,22 @@ namespace ehs
return *this; return *this;
} }
Fragments::operator Serializer<UInt_64> *() const NetFrags::operator Serializer<UInt_64> *() const
{ {
return data; return data;
} }
Header Fragments::GetHeader() const Header NetFrags::GetHeader() const
{ {
return header; return header;
} }
UInt_64 Fragments::Size() const UInt_64 NetFrags::Size() const
{ {
return size; return size;
} }
bool Fragments::IsComplete() const bool NetFrags::IsComplete() const
{ {
for (UInt_64 i = 0; i < size; ++i) for (UInt_64 i = 0; i < size; ++i)
if (!data[i].Size()) if (!data[i].Size())
@ -99,7 +99,7 @@ namespace ehs
return true; return true;
} }
Packet Fragments::Combine() const Packet NetFrags::Combine() const
{ {
UInt_64 rSize = 0; UInt_64 rSize = 0;
for (UInt_64 i = 0; i < size; ++i) for (UInt_64 i = 0; i < size; ++i)

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

@ -1,7 +1,7 @@
#include "ehs/io/socket/ehc/NetOp.h" #include "ehs/io/socket/ehc/NetOp.h"
#include "ehs/io/socket/EHC.h" #include "ehs/io/socket/EHC.h"
#include "ehs/io/socket/ehc/NetEnd.h" #include "ehs/io/socket/ehc/NetEnd.h"
#include "ehs/io/socket/ehc/NetSystem.h" #include "ehs/io/socket/ehc/NetSys.h"
namespace ehs namespace ehs
{ {
@ -60,7 +60,7 @@ namespace ehs
return hashId; return hashId;
} }
void NetOp::Process(EHC *ehc, NetEnd *endpoint, NetSystem *sys, Serializer<UInt_64> &payload) void NetOp::Process(EHC *ehc, NetEnd *endpoint, NetSys *sys, Serializer<UInt_64> &payload)
{ {
} }
} }

26
src/io/socket/ehc/NetSystem.cpp → src/io/socket/ehc/NetSys.cpp
View File

@ -1,11 +1,11 @@
#include "ehs/io/socket/ehc/NetSystem.h" #include "ehs/io/socket/ehc/NetSys.h"
#include "ehs/io/socket/EHC.h" #include "ehs/io/socket/EHC.h"
#include "ehs/io/socket/ehc/NetEnd.h" #include "ehs/io/socket/ehc/NetEnd.h"
#include "ehs/io/socket/ehc/NetOp.h" #include "ehs/io/socket/ehc/NetOp.h"
namespace ehs namespace ehs
{ {
NetSystem::~NetSystem() NetSys::~NetSys()
{ {
for (UInt_64 i = 0; i < ops.Size(); ++i) for (UInt_64 i = 0; i < ops.Size(); ++i)
delete ops[i]; delete ops[i];
@ -13,28 +13,28 @@ namespace ehs
ops.Clear(); ops.Clear();
} }
NetSystem::NetSystem() NetSys::NetSys()
: hashId(0) : hashId(0)
{ {
} }
NetSystem::NetSystem(Str_8 id) NetSys::NetSys(Str_8 id)
: hashId(id.Hash_64()), id((Str_8&&)id) : hashId(id.Hash_64()), id((Str_8&&)id)
{ {
} }
NetSystem::NetSystem(NetSystem&& sys) noexcept NetSys::NetSys(NetSys&& sys) noexcept
: hashId(sys.hashId), id((Str_8&&)sys.id), ops((Array<NetOp*>&&)sys.ops) : hashId(sys.hashId), id((Str_8&&)sys.id), ops((Array<NetOp*>&&)sys.ops)
{ {
sys.hashId = 0; sys.hashId = 0;
} }
NetSystem::NetSystem(const NetSystem& sys) NetSys::NetSys(const NetSys& sys)
: hashId(sys.hashId), id(sys.id) : hashId(sys.hashId), id(sys.id)
{ {
} }
NetSystem& NetSystem::operator=(NetSystem&& sys) noexcept NetSys& NetSys::operator=(NetSys&& sys) noexcept
{ {
if (this == &sys) if (this == &sys)
return *this; return *this;
@ -48,7 +48,7 @@ namespace ehs
return *this; return *this;
} }
NetSystem& NetSystem::operator=(const NetSystem& sys) NetSys& NetSys::operator=(const NetSys& sys)
{ {
if (this == &sys) if (this == &sys)
return *this; return *this;
@ -60,17 +60,17 @@ namespace ehs
return *this; return *this;
} }
Str_8 NetSystem::GetId() const Str_8 NetSys::GetId() const
{ {
return id; return id;
} }
UInt_64 NetSystem::GetHashId() const UInt_64 NetSys::GetHashId() const
{ {
return hashId; return hashId;
} }
bool NetSystem::HasOperation(const UInt_64 hashId) const bool NetSys::HasOperation(const UInt_64 hashId) const
{ {
for (UInt_64 i = 0; i < ops.Size(); ++i) for (UInt_64 i = 0; i < ops.Size(); ++i)
if (ops[i]->GetHashId() == hashId) if (ops[i]->GetHashId() == hashId)
@ -79,7 +79,7 @@ namespace ehs
return false; return false;
} }
bool NetSystem::AddOperation(NetOp* op) bool NetSys::AddOperation(NetOp* op)
{ {
if (HasOperation(op->GetHashId())) if (HasOperation(op->GetHashId()))
return false; return false;
@ -89,7 +89,7 @@ namespace ehs
return true; return true;
} }
void NetSystem::Execute(EHC *ehc, NetEnd *endpoint, const UInt_64 hashId, Serializer<UInt_64> &payload) void NetSys::Execute(EHC *ehc, NetEnd *endpoint, const UInt_64 hashId, Serializer<UInt_64> &payload)
{ {
for (UInt_64 i = 0; i < ops.Size(); ++i) for (UInt_64 i = 0; i < ops.Size(); ++i)
{ {