From a2114009645b2b06ca4e1cc377b49c7e08fbb327 Mon Sep 17 00:00:00 2001 From: xX-TheDoctor-Xx Date: Mon, 18 Jul 2016 01:13:20 +0100 Subject: [PATCH] Added Development information for me to dont forget things xD Added AllAndMe DistributionType Added a ThreadPool class Added VoidNetClientAPI --- DEV_INFO | 5 ++ .../Release/VoidNetVS.tlog/CL.command.1.tlog | Bin 1734 -> 6526 bytes .../Release/VoidNetVS.tlog/CL.read.1.tlog | Bin 234 -> 204974 bytes .../Release/VoidNetVS.tlog/CL.write.1.tlog | Bin 2836 -> 7380 bytes .../VoidNetVS.tlog/Lib-link.write.1.tlog | Bin 1066 -> 1288 bytes .../Release/VoidNetVS.tlog/Lib.read.1.tlog | Bin 2606 -> 3054 bytes .../Release/VoidNetVS.tlog/lib.command.1.tlog | Bin 1506 -> 1822 bytes .../Release/VoidNetVS.tlog/unsuccessfulbuild | 0 VoidNetVS/VoidNetVS/VoidNetVS.vcxproj | 4 + VoidNetVS/VoidNetVS/VoidNetVS.vcxproj.filters | 10 +++ include/Callbacks.hpp | 4 + include/Defs.hpp | 3 +- include/NetworkMessage.hpp | 14 ++-- include/Serializer.hpp | 3 +- {src => include}/Tags.hpp | 2 +- include/TcpClient.hpp | 16 +++- include/ThreadPool.hpp | 33 ++++++++ include/VoidNetClient.hpp | 36 ++++++++ src/NetworkMessage.cpp | 46 ++++++++-- src/Serializer.cpp | 4 +- src/TcpClientWindows.cpp | 39 ++++++--- src/ThreadPool.cpp | 57 +++++++++++++ src/VoidNetClient.cpp | 79 ++++++++++++++++++ 23 files changed, 323 insertions(+), 32 deletions(-) create mode 100644 DEV_INFO delete mode 100644 VoidNetVS/VoidNetVS/Release/VoidNetVS.tlog/unsuccessfulbuild rename {src => include}/Tags.hpp (78%) create mode 100644 include/ThreadPool.hpp create mode 100644 src/ThreadPool.cpp create mode 100644 src/VoidNetClient.cpp diff --git a/DEV_INFO b/DEV_INFO new file mode 100644 index 0000000..ee5e530 --- /dev/null +++ b/DEV_INFO @@ -0,0 +1,5 @@ +id -1 is server / valid message if other parameters are valid as well +id -2 is invalid network message + + +currently working on: TcpClient::SendMessage \ No newline at end of file diff --git a/VoidNetVS/VoidNetVS/Release/VoidNetVS.tlog/CL.command.1.tlog b/VoidNetVS/VoidNetVS/Release/VoidNetVS.tlog/CL.command.1.tlog index cf2b1b35e436e6458604c95a28a5f58c59bd7fec..f06a63fa254e7c937b785dd3dd427df9030af7c0 100644 GIT binary patch delta 394 zcmX@c`_E{@F}BH7EDEBY41Nrr3?U5RK+=!Fg~1=l3f`#uml3#+Cx%c4Hz0In2mJ)R6c zU>8P$RHBN2)CdQIYzC@u1gndJxdWRxNWCwSUhgMrYI!JWYsWCK2VpniK^jF6f< gi$w@k6zujepzl0^{sh~%c|Hp#6EBL;h($ delta 7 Ocmexobc}byF*X1X*#m$8 diff --git a/VoidNetVS/VoidNetVS/Release/VoidNetVS.tlog/CL.read.1.tlog b/VoidNetVS/VoidNetVS/Release/VoidNetVS.tlog/CL.read.1.tlog index 3c4f5f069bcf4f892dc719c7437295dbdc4e488a..72e3d4332fb22ddfdbbdce046571e1c119f23191 100644 GIT binary patch literal 204974 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 diff --git a/VoidNetVS/VoidNetVS/Release/VoidNetVS.tlog/Lib-link.write.1.tlog b/VoidNetVS/VoidNetVS/Release/VoidNetVS.tlog/Lib-link.write.1.tlog index 167002130468e31320f25ebc0fe2d50730a5976e..bd81a639ce591b353e6399f36980fa407f5b4827 100644 GIT binary patch delta 59 zcmZ3*(ZRK02eWVpg9k$pgDZn0g9}3dgFg`ZOcrE{oVYY_b$n0B;yj#1kmz2UHU> gc{YdSWHT1A%`cdzuwvD!$XPmBkJAr}wrQL*02+N7fdBvi delta 32 jcmaDSzD{Jr4(7=xxTGfUV-wqajAaTdl*2YThI9> delta 25 ecmbQo_lSGL4(7=!EMlA2u>4{KF<5vRxEKI-DF+|` diff --git a/VoidNetVS/VoidNetVS/Release/VoidNetVS.tlog/unsuccessfulbuild b/VoidNetVS/VoidNetVS/Release/VoidNetVS.tlog/unsuccessfulbuild deleted file mode 100644 index e69de29..0000000 diff --git a/VoidNetVS/VoidNetVS/VoidNetVS.vcxproj b/VoidNetVS/VoidNetVS/VoidNetVS.vcxproj index 1314c09..788028c 100644 --- a/VoidNetVS/VoidNetVS/VoidNetVS.vcxproj +++ b/VoidNetVS/VoidNetVS/VoidNetVS.vcxproj @@ -27,6 +27,7 @@ + @@ -41,9 +42,12 @@ + + + diff --git a/VoidNetVS/VoidNetVS/VoidNetVS.vcxproj.filters b/VoidNetVS/VoidNetVS/VoidNetVS.vcxproj.filters index 6e2ac58..11506fe 100644 --- a/VoidNetVS/VoidNetVS/VoidNetVS.vcxproj.filters +++ b/VoidNetVS/VoidNetVS/VoidNetVS.vcxproj.filters @@ -45,6 +45,9 @@ include + + include + @@ -74,8 +77,15 @@ src + + src + + + src + + \ No newline at end of file diff --git a/include/Callbacks.hpp b/include/Callbacks.hpp index bd3a456..e751357 100644 --- a/include/Callbacks.hpp +++ b/include/Callbacks.hpp @@ -8,10 +8,14 @@ #include "Defs.hpp" #include "Serializer.hpp" +/*Client Callbacks begin*/ + void OnMessage(uint16 sender, uint16 tag, uint16 subject, void *data); void OnDisconnect(uint16 id); void OnConnect(uint16 id); +/*Client Callbacks end*/ + #endif \ No newline at end of file diff --git a/include/Defs.hpp b/include/Defs.hpp index 1822fd7..0a47b54 100644 --- a/include/Defs.hpp +++ b/include/Defs.hpp @@ -185,11 +185,12 @@ enum VoidCode enum DistributionType { All, + AllAndMe, Server, Others, ID, Reply, Custom, -} +}; #endif // DEFS_HPP \ No newline at end of file diff --git a/include/NetworkMessage.hpp b/include/NetworkMessage.hpp index 0f59eb2..ca9f8d3 100644 --- a/include/NetworkMessage.hpp +++ b/include/NetworkMessage.hpp @@ -15,20 +15,22 @@ struct NetworkMessage NetworkMessage(uint16 sender, byte distribution_mode, uint16 destination_id, byte tag, uint16 subject, NetworkBuffer buffer); ~NetworkMessage(); - const NetworkMessage &EncodeMessage(); + static const NetworkBuffer &EncodeMessage(const NetworkMessage &message); const NetworkMessage &NetworkMessage::DecodeMessage(const NetworkBuffer &buffer); - const NetworkMessage &NetworkMessage::DecodeMessageHeader(const NetworkBuffer &buffer); - void *DecodeMessageData(const NetworkBuffer &buffer); - uint16 sender; - uint16 destination_id; + uint16 sender = -2; byte distribution_mode; - uint16 tag; + uint16 destination_id; + byte tag; uint16 subject; void *data; + + bool valid = false; private: + const NetworkMessage &NetworkMessage::DecodeMessageHeader(const NetworkBuffer &buffer); + void *DecodeMessageData(const NetworkBuffer &buffer); NetworkBuffer buffer; }; diff --git a/include/Serializer.hpp b/include/Serializer.hpp index 58a740a..989470d 100644 --- a/include/Serializer.hpp +++ b/include/Serializer.hpp @@ -6,11 +6,12 @@ #endif #include "Defs.hpp" +#include struct Serializer { template static const std::vector &to_bytes(const T &object); - template static const T &from_bytes(byte *bytes, T &object); + template static const T& from_bytes(byte *bytes, T& object); }; #endif \ No newline at end of file diff --git a/src/Tags.hpp b/include/Tags.hpp similarity index 78% rename from src/Tags.hpp rename to include/Tags.hpp index 154ef10..482d99d 100644 --- a/src/Tags.hpp +++ b/include/Tags.hpp @@ -5,7 +5,7 @@ #pragma once #endif -enum InternalTags : uint16 +enum InternalTags { CONNECT = 65534, DISCONNECT = 65535, diff --git a/include/TcpClient.hpp b/include/TcpClient.hpp index aff0048..1d890a8 100644 --- a/include/TcpClient.hpp +++ b/include/TcpClient.hpp @@ -3,6 +3,7 @@ #include "Defs.hpp" #include "NetworkMessage.hpp" +#include "ThreadPool.hpp" #include @@ -10,6 +11,8 @@ #pragma once #endif +#undef SendMessage + class TcpClient { public: @@ -27,21 +30,30 @@ public: NetworkBuffer ReceiveDataArray(); const NetworkMessage &ReceiveData(); - bool SendData(const NetworkMessage &message); + VoidCode SendMessage(const NetworkMessage &message); private: + static VoidCode SendNetworkMessage(const NetworkMessage &message, TcpClient *client); VoidCode Initialize(const std::string &ip, uint16 port = default_port); std::string ip; uint16 port = 0; bool initialized; + ThreadPool thread_pool; + #ifdef _MSC_VER - SOCKET socket = INVALID_SOCKET; + SOCKET tcp_socket = INVALID_SOCKET; struct addrinfo *result = nullptr; struct addrinfo *ptr = nullptr; struct addrinfo hints; #endif }; +#ifdef UNICODE +#define SendMessage SendMessageW +#else +#define SendMessage SendMessageA +#endif // !UNICODE + #endif \ No newline at end of file diff --git a/include/ThreadPool.hpp b/include/ThreadPool.hpp new file mode 100644 index 0000000..6cfc0be --- /dev/null +++ b/include/ThreadPool.hpp @@ -0,0 +1,33 @@ +#ifndef THREAD_POOL_HPP +#define THREAD_POOL_HPP + +#ifdef _MSC_VER +#pragma once +#endif + +#include +#include +#include +#include +#include + +class ThreadPool +{ +public: + ThreadPool(int threads); + ~ThreadPool(); + void Enqueue(std::function f); + void Shutdown(); + const ThreadPool &operator=(ThreadPool &pool); + +private: + std::vector threadPool; + std::queue> tasks; + std::mutex tasksMutex; + std::condition_variable condition; + bool terminate; + bool stopped; + void Invoke(); +}; + +#endif \ No newline at end of file diff --git a/include/VoidNetClient.hpp b/include/VoidNetClient.hpp index 7a74481..c425648 100644 --- a/include/VoidNetClient.hpp +++ b/include/VoidNetClient.hpp @@ -11,5 +11,41 @@ #include "Callbacks.hpp" #include "NetworkBuffer.hpp" #include "NetworkMessage.hpp" +#include "ThreadPool.hpp" + +#include +#include + +#undef SendMessage + +struct VoidNetClientAPI +{ + static bool Connect(const std::string &ip, uint16 port = default_port); + static void Disconnect(); + + static bool SendMessageToServer(byte tag, byte subject, void *data); + static bool SendMessageToID(uint16 id, byte tag, byte subject, void *data); + static bool SendMessageToOthers(byte tag, byte subject, void *data); + static bool SendMessageToAll(byte tag, byte subject, void *data); + static bool SendMessageToAllAndMe(byte tag, byte subject, void *data); + + static bool SendMessage(byte distribution_mode, uint16 destination_id, byte tag, byte subject, void *data); + + static void Receive(); + +private: + static void ProcessAllData(); + + static TcpClient *client; + static uint16 id; + static std::thread receive_thread; + static bool receive; +}; + +#ifdef UNICODE +#define SendMessage SendMessageW +#else +#define SendMessage SendMessageA +#endif // !UNICODE #endif diff --git a/src/NetworkMessage.cpp b/src/NetworkMessage.cpp index 6b79e2b..c81ef15 100644 --- a/src/NetworkMessage.cpp +++ b/src/NetworkMessage.cpp @@ -1,6 +1,8 @@ #include "NetworkMessage.hpp" #include "Utility.hpp" #include "Serializer.hpp" +#include "Tags.hpp" + #include NetworkMessage::NetworkMessage() @@ -12,13 +14,41 @@ NetworkMessage::NetworkMessage(uint16 sender, byte distribution_mode, uint16 des { } +NetworkMessage::NetworkMessage(const NetworkBuffer &buffer) +{ + *this = DecodeMessage(buffer); +} + NetworkMessage::~NetworkMessage() { } -const NetworkMessage &NetworkMessage::EncodeMessage() +const NetworkBuffer &NetworkMessage::EncodeMessage(const NetworkMessage &message) { - return NetworkMessage(); + NetworkBuffer buffer; + uint16 size = buffer.body_size + 1; + byte *encoded_message = new byte[size](); + buffer.body_size = size; + + byte *encoded_sender = &encoded_message[1]; + encoded_sender = Utility::BitConverter::FromUint16(message.sender); + + encoded_message[3] = message.distribution_mode; + + byte *encoded_destination_id = &encoded_message[4]; + encoded_destination_id = Utility::BitConverter::FromUint16(message.destination_id); + + encoded_message[6] = message.tag; + + byte *encoded_subject = &encoded_message[7]; + encoded_subject = Utility::BitConverter::FromUint16(message.subject); + + byte *encoded_data = &encoded_message[9]; + std::vector serialized_data = Serializer::to_bytes(message.data); + encoded_data = &serialized_data[0]; + + buffer.body = encoded_message; + return buffer; } const NetworkMessage &NetworkMessage::DecodeMessage(const NetworkBuffer &buffer) @@ -38,7 +68,7 @@ void *NetworkMessage::DecodeMessageData(const NetworkBuffer &buffer) case 0: { void *object; - return Serializer::from_bytes(buffer.body, object); + return Serializer::from_bytes(buffer.body + 9, object); } default: { @@ -50,6 +80,12 @@ void *NetworkMessage::DecodeMessageData(const NetworkBuffer &buffer) const NetworkMessage &NetworkMessage::DecodeMessageHeader(const NetworkBuffer &buffer) { - return NetworkMessage(Utility::BitConverter::ToUint16(buffer.body, 1), buffer.body[3], Utility::BitConverter::ToUint16(buffer.body, 4), - buffer.body[6], Utility::BitConverter::ToUint16(buffer.body, 7), buffer); + sender = Utility::BitConverter::ToUint16(buffer.body, 1); + distribution_mode = buffer.body[3]; + destination_id = Utility::BitConverter::ToUint16(buffer.body, 4); + tag = buffer.body[6]; + subject = Utility::BitConverter::ToUint16(buffer.body, 7); + this->buffer = buffer; + valid = sender != -2 && tag != CONNECT && tag != DISCONNECT; + return *this; } diff --git a/src/Serializer.cpp b/src/Serializer.cpp index 7a877c6..4505087 100644 --- a/src/Serializer.cpp +++ b/src/Serializer.cpp @@ -1,7 +1,5 @@ #include "Serializer.hpp" -#include - template const std::vector &Serializer::to_bytes(const T& object) { std::vector bytes; @@ -13,7 +11,7 @@ template const std::vector &Serializer::to_bytes(const T& obje return bytes; } -template T& Serializer::from_bytes(byte *bytes, T& object) +template const T& Serializer::from_bytes(byte *bytes, T& object) { static_assert(std::is_trivially_copyable::value, "not a TriviallyCopyable type"); diff --git a/src/TcpClientWindows.cpp b/src/TcpClientWindows.cpp index 7dd1b33..eb367da 100644 --- a/src/TcpClientWindows.cpp +++ b/src/TcpClientWindows.cpp @@ -7,6 +7,8 @@ #include +#undef SendMessage + VoidCode TcpClient::Initialize(const std::string &ip, uint16 port) { if (ip.size() == 0 || std::count(ip.begin(), ip.end(), '.') != 4) @@ -28,9 +30,9 @@ VoidCode TcpClient::Initialize(const std::string &ip, uint16 port) } ptr = result; - socket = ::socket(ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol); + tcp_socket = ::socket(ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol); - if (socket == INVALID_SOCKET) + if (tcp_socket == INVALID_SOCKET) { if (Config::GetUsingConsole()) std::cerr << WSAGetLastError() << std::endl; // display more info @@ -43,12 +45,12 @@ VoidCode TcpClient::Initialize(const std::string &ip, uint16 port) return VOID_SUCCESS; } -TcpClient::TcpClient() +TcpClient::TcpClient() : port(default_port), thread_pool(50) { } TcpClient::TcpClient(const std::string &ip, uint16 port) : - ip(ip), port(port) + ip(ip), port(port), thread_pool(50) { } @@ -92,7 +94,7 @@ VoidCode TcpClient::Connect() if (code != VOID_SUCCESS) return code; } - uint16 connect_code = ::connect(socket, ptr->ai_addr, ptr->ai_addrlen); + uint16 connect_code = ::connect(tcp_socket, ptr->ai_addr, ptr->ai_addrlen); if (connect_code == SOCKET_ERROR) return VOID_COULDNT_CONNECT; } @@ -101,16 +103,19 @@ NetworkBuffer TcpClient::ReceiveDataArray() { NetworkBuffer buffer; - if (recv(socket, reinterpret_cast(buffer.body_size), 4, 0) != 4 || WSAGetLastError() != 0) + int32 header_received = recv(tcp_socket, reinterpret_cast(buffer.body_size), 4, 0); + + if (header_received != 4 || WSAGetLastError() != 0) // this header is completely unrelated to the network message header - this header is the body size of the network message { - // there was a problem receiving the body size of the message + // there was a problem receiving the body size of the message or theres no header to receive return NetworkBuffer(); } buffer.body = new byte[buffer.body_size](); - if (recv(socket, reinterpret_cast(buffer.body), buffer.body_size, 0) != buffer.body_size || WSAGetLastError() != 0) + int32 body_received = recv(tcp_socket, reinterpret_cast(buffer.body), buffer.body_size, 0); + if (body_received != buffer.body_size || WSAGetLastError() != 0) { - //there was a problem receiving the body of the message + //there was a problem receiving the body of the message or theres no body to receive return NetworkBuffer(); } @@ -119,8 +124,7 @@ NetworkBuffer TcpClient::ReceiveDataArray() const NetworkMessage &TcpClient::ReceiveData() { - NetworkBuffer received_data = ReceiveDataArray(); - NetworkMessage message = NetworkMessage(received_data); + NetworkMessage message(ReceiveDataArray()); if (message.tag == CONNECT) OnConnect(message.sender); else if (message.tag == DISCONNECT) @@ -130,7 +134,16 @@ const NetworkMessage &TcpClient::ReceiveData() return message; } -bool TcpClient::SendData(const NetworkMessage &message) +VoidCode TcpClient::SendNetworkMessage(const NetworkMessage &message, TcpClient *client) { - return false; + NetworkBuffer buffer = message.EncodeMessage(message); + int32 sent_bytes = send(client->tcp_socket, reinterpret_cast(buffer.body), buffer.body_size, 0); } + +VoidCode TcpClient::SendMessage(const NetworkMessage &message) +{ + thread_pool.Enqueue([]() + { + //SendNetworkMessage(message, this); + }); +} \ No newline at end of file diff --git a/src/ThreadPool.cpp b/src/ThreadPool.cpp new file mode 100644 index 0000000..3d59a85 --- /dev/null +++ b/src/ThreadPool.cpp @@ -0,0 +1,57 @@ +#include "ThreadPool.hpp" + +ThreadPool::ThreadPool(int threads) : + terminate(false), + stopped(false) +{ + for (int i = 0; i < threads; i++) + threadPool.emplace_back(std::thread(&ThreadPool::Invoke, this)); +} + +void ThreadPool::Enqueue(std::function f) +{ + std::unique_lock lock(tasksMutex); + tasks.push(f); + condition.notify_one(); +} + +void ThreadPool::Invoke() { + + std::function task; + while (true) + { + std::unique_lock lock(tasksMutex); + condition.wait(lock, [this] { return !tasks.empty() || terminate; }); + if (terminate && tasks.empty()) + { + return; + } + task = tasks.front(); + tasks.pop(); + task(); + } +} + +void ThreadPool::Shutdown() +{ + std::unique_lock lock(tasksMutex); + terminate = true; + condition.notify_all(); + + for (std::thread &thread : threadPool) + thread.join(); + + threadPool.empty(); + stopped = true; +} + +const ThreadPool &ThreadPool::operator=(ThreadPool &pool) +{ + return pool; +} + +ThreadPool::~ThreadPool() +{ + if (!stopped) + Shutdown(); +} \ No newline at end of file diff --git a/src/VoidNetClient.cpp b/src/VoidNetClient.cpp new file mode 100644 index 0000000..9ddc1f0 --- /dev/null +++ b/src/VoidNetClient.cpp @@ -0,0 +1,79 @@ +#include "VoidNetClient.hpp" +#include "Utility.hpp" +#include "Tags.hpp" + +#undef SendMessage + +bool VoidNetClientAPI::Connect(const std::string &ip, uint16 port) +{ + client->SetIP(ip); + client->SetPort(port); + return client->Connect() == VOID_SUCCESS; +} + +bool VoidNetClientAPI::SendMessageToServer(byte tag, byte subject, void *data) +{ + return SendMessage(Server, 0, tag, subject, data); +} + +bool VoidNetClientAPI::SendMessageToID(uint16 destination_id, byte tag, byte subject, void *data) +{ + return SendMessage(ID, destination_id, tag, subject, data); +} + +bool VoidNetClientAPI::SendMessageToOthers(byte tag, byte subject, void *data) +{ + return SendMessage(Others, 0, tag, subject, data); +} + +bool VoidNetClientAPI::SendMessageToAll(byte tag, byte subject, void *data) +{ + return SendMessage(All, 0, tag, subject, data); +} + +bool VoidNetClientAPI::SendMessageToAllAndMe(byte tag, byte subject, void *data) +{ + return SendMessage(AllAndMe, 0, tag, subject, data); +} + +bool VoidNetClientAPI::SendMessage(byte distribution_mode, uint16 destination_id, byte tag, byte subject, void *data) +{ + NetworkMessage message; + message.tag = tag; + message.subject = subject; + message.data = data; + message.distribution_mode = distribution_mode; + message.sender = id; + message.destination_id = destination_id; + return client->SendMessage(message) == VOID_SUCCESS; +} + +void VoidNetClientAPI::Receive() +{ + receive_thread = std::thread(ProcessAllData); + receive_thread.detach(); +} + +void VoidNetClientAPI::ProcessAllData() +{ + while (receive) + { + NetworkMessage message = client->ReceiveDataArray(); + if (message.valid) + { + if (message.tag == CONNECT) + OnConnect(message.sender); + else if (message.tag == DISCONNECT) + OnDisconnect(message.sender); + else + OnMessage(message.sender, message.tag, message.subject, message.data); + } + } +} + +void VoidNetClientAPI::Disconnect() +{ + Utility::Delete(client); + receive = false; + receive_thread.join(); +}