.gitmodules

@@ -0,0 +1,6 @@
+[submodule "vendor/spdlog"]
+	path = vendor/spdlog
+	url = https://github.com/gabime/spdlog
+[submodule "vendor/bakatools"]
+	path = vendor/bakatools
+	url = https://github.com/anulax1225/bakatools

README.md

@@ -1 +0,0 @@
-# Baka net module

bakanet/premake5.lua

@@ -0,0 +1,82 @@
+project "bakanet"
+	kind "StaticLib"
+    language "C++"
+    cppdialect "C++20"
+    systemversion "latest"
+    staticruntime "on"
+
+    targetdir("%{wks.location}/bin/" .. outputdir .. "/%{prj.name}")
+    objdir("%{wks.location}/bin-int/" .. outputdir .. "/%{prj.name}")
+
+    defines
+    {
+        "BKMOD_ALL"
+    }
+
+    includedirs 
+    {
+        "%{IncludeDirs.spdlog}",
+        "%{IncludeDirs.bakanet}",
+        "%{IncludeDirs.bakatools}"
+    }
+
+    files 
+    {
+        "%{prj.location}/src/bakanet/**.h",
+        "%{prj.location}/src/bakanet/**.cpp",
+        "%{prj.location}/src/baknetpch.h",
+    }
+
+    links 
+    {
+        "bakatools"
+    }
+
+    filter "system:windows"
+		buildoptions "/MDd"
+        defines
+        {
+            "BK_PLATFORM_WINDOWS"
+        }
+
+        files
+        {
+            "%{prj.location}/src/platform/windows/**.h",
+            "%{prj.location}/src/platform/windows/**.cpp",
+        }
+
+        links
+        {
+            "WS2_32.lib"
+        }
+    
+    filter "system:linux"
+        defines
+        {
+            "BK_PLATFORM_LINUX"
+        }
+
+        files
+        {
+            "%{prj.location}/src/platform/linux/**.h",
+            "%{prj.location}/src/platform/linux/**.cpp",
+        }
+    
+    filter "configurations:Debug"
+        defines 
+        { 
+            "BK_DEBUG",
+            "DEBUG"
+        }
+        runtime "Debug"
+        symbols "on"
+
+
+    filter "configurations:Release"
+        defines 
+        { 
+            "BK_RELEASE",
+            "NDEBUG"
+        }
+        runtime "Release"
+        optimize "on"

bakanet/src/bakanet/core/socket.h

@@ -16,10 +16,9 @@ namespace Bk::Net {
 
 			virtual bool init() = 0;
 			virtual bool start(int cpt_conn) = 0;
-			virtual Socket* ack() = 0;
+			virtual std::unique_ptr<Socket> ack() = 0;
 			virtual bool conn() = 0;
 
-			virtual bool isConnected() = 0;
 
 			virtual int get_raw_socket() = 0;
 			virtual const std::string get_ip() = 0;
@@ -30,8 +29,8 @@ namespace Bk::Net {
 			template<typename T>
 			static bool set_option(Socket& socket, OptionLayer level, SocketOption option_name, const T* option_value) { return setsockopt(socket.get_raw_socket(), (int)level, (int)option_name, (void*)option_value, sizeof(T)) == 0 ? true : false; }
 
-			static Socket* create(IpAddress ip, int port, IpProtocol proto);
+			static std::unique_ptr<Socket> create(IpAddress ip, int port, IpProtocol proto);
 		protected:	
-			static Socket* create(int id, IpVersion ver, IpProtocol proto);
+			static std::unique_ptr<Socket> create(int id, IpVersion ver, IpProtocol proto);
 	};
 }

bakanet/src/bakanet/http/packet.h

@@ -15,8 +15,6 @@
 #define HTTP_RES_406 "406 Not Acceptable"
 #define HTTP_RES_408 "408 Request Timeout"
 
-#define HTTPv1_1 "HTTP/1.1"
-
 namespace Bk::Net {
     using HttpParams = std::unordered_map<std::string, std::string>;
 

bakanet/src/bakanet/http/server.cpp

@@ -1,30 +1,23 @@
 #include "server.h"
-
 namespace Bk::Net {
     HttpServer::HttpServer(IpAddress ip, int port) 
     {
+        BK_CORE_INFO("NEW SERVER");
         socket = Socket::create(ip, port, IpProtocol::TCP);
         radix = RadixTree();
     }
 
-    HttpServer::~HttpServer()
-    {
-        delete socket;
-    }
-
     void HttpServer::start()
     {
         bool running = socket->init() && socket->start(5);
         while (running)
         {
-            Socket* conn = socket->ack();
+            std::unique_ptr<Socket> conn = socket->ack();
-            pool.queue([this, conn]() 
+            threads.push_back(std::thread([this](std::unique_ptr<Socket> conn) 
             {
-                route_request(conn, recv_request(conn));
+                route_request(*conn, recv_request(*conn));
-                delete conn;
+            }, std::move(conn)));
-            });
         } 
-        pool.stop();
     }
     
     void HttpServer::get(std::string url, RequestHandler req_handler)
@@ -32,7 +25,7 @@ namespace Bk::Net {
         RadixTree* tree;
         Tools::string_trim(url, " /");
         auto splits = Tools::string_split(url, "/");
-        if ((tree = radix.get_node(splits->data(), splits->size()))) tree->value["GET"] = req_handler;
+        if (tree = radix.get_node(splits->data(), splits->size())) tree->value["GET"] = req_handler;
         else radix.add_nodes(splits->data(), splits->size(), HttpMethodArray({{ "GET", req_handler }}));
     }
 
@@ -41,7 +34,7 @@ namespace Bk::Net {
         RadixTree* tree;
         Tools::string_trim(url, " /");
         auto splits = Tools::string_split(url, "/");
-        if ((tree = radix.get_node(splits->data(), splits->size()))) tree->value["POST"] = req_handler;
+        if (tree = radix.get_node(splits->data(), splits->size())) tree->value["POST"] = req_handler;
         else radix.add_nodes(splits->data(), splits->size(), HttpMethodArray({{ "POST", req_handler }}));
     }
 
@@ -50,7 +43,7 @@ namespace Bk::Net {
         RadixTree* tree;
         Tools::string_trim(url, " /");
         auto splits = Tools::string_split(url, "/");
-        if ((tree = radix.get_node(splits->data(), splits->size()))) tree->value["DELETE"] = req_handler;
+        if (tree = radix.get_node(splits->data(), splits->size())) tree->value["DELETE"] = req_handler;
         else radix.add_nodes(splits->data(), splits->size(), HttpMethodArray({{ "DELETE", req_handler }}));
     }
 
@@ -59,17 +52,17 @@ namespace Bk::Net {
         RadixTree* tree;
         Tools::string_trim(url, " /");
         auto splits = Tools::string_split(url, "/");
-        if ((tree = radix.get_node(splits->data(), splits->size()))) tree->value["PUT"] = req_handler;
+        if (tree = radix.get_node(splits->data(), splits->size())) tree->value["PUT"] = req_handler;
         else radix.add_nodes(splits->data(), splits->size(), HttpMethodArray({{ "PUT", req_handler }}));
     }
 
-    HttpRequest HttpServer::recv_request(Socket* conn)
+    HttpRequest HttpServer::recv_request(Socket& conn)
     {
         Type::DataStream req;
         std::vector<char> data;
         do
         {
-            data = conn->obtain(1024);
+            data = conn.obtain(1024);
             req.append_data(data);
         } while(data.size() >= 1024);
         int req_size = req.size();
@@ -77,15 +70,15 @@ namespace Bk::Net {
         return HttpRequest("", "", "");
     }
 
-    void HttpServer::send_reponse(Socket* conn, HttpReponse res)
+    void HttpServer::send_reponse(Socket& conn, HttpReponse res)
     {
         Type::DataStream res_packet;
         std::string str_res = res.to_string();
         res_packet.push<char>(str_res.c_str(), str_res.length());
-        conn->emit(res_packet.payload);
+        conn.emit(res_packet.payload);
     }
 
-    void HttpServer::route_request(Socket* conn, HttpRequest req)
+    void HttpServer::route_request(Socket& conn, HttpRequest req)
     {
         std::string url = std::string(req.url);
         Tools::string_trim(url, " /");

bakanet/src/bakanet/http/server.h

@@ -2,7 +2,6 @@
 
 #include <bakanetpch.h>
 #include <bakanet/core/ip_address.h>
-#include <bakatools/thread/task_pool.h>
 #include <bakanet/core/socket.h>
 #include "packet.h"
 
@@ -10,12 +9,13 @@ namespace Bk::Net {
     using RequestHandler = std::function<HttpReponse(HttpRequest& req)>;
     using HttpMethodArray = std::unordered_map<std::string, RequestHandler>;
     using RadixTree = Type::Trie<std::string, HttpMethodArray>;
+    using ThreadPool = std::vector<std::thread>;
     
     class HttpServer 
     {
         public:
             HttpServer(IpAddress ip, int port);
-            ~HttpServer();
+            ~HttpServer() = default;
             void start();
             void get(std::string url, RequestHandler req_handler);
             void post(std::string url, RequestHandler req_handler);
@@ -23,12 +23,12 @@ namespace Bk::Net {
             void put(std::string url, RequestHandler req_handler);
 
         private:
-            Socket* socket;
+            std::unique_ptr<Socket> socket;
-            ThreadPool pool;
+            ThreadPool threads;
             RadixTree radix;
 
-            HttpRequest recv_request(Socket* conn);
+            HttpRequest recv_request(Socket& conn);
-            void send_reponse(Socket* conn, HttpReponse res);
+            void send_reponse(Socket& conn, HttpReponse res);
-            void route_request(Socket* conn, HttpRequest req);
+            void route_request(Socket& conn, HttpRequest req);
     };
 }

bakanet/src/bakanetpch.h

@@ -15,8 +15,8 @@
 #include <bakatools.h>
 
 #if defined(BK_PLATFORM_WINDOWS)
-    #include <ws2tcpip.h>
+    #include <Ws2tcpip.h>
-    #include <winsock2.h>
+    #include <WinSock2.h>
     #include <tchar.h>
     #pragma comment(lib,"WS2_32.lib")
 #elif defined(BK_PLATFORM_LINUX)

bakanet/src/platform/linux/linux_ip_address.cpp

@@ -1,4 +1,6 @@
 #include <bakanet/core/ip_address.h>
+#include <string.h>
+
 namespace Bk::Net {
     struct in_addr IpAddress::get_data() 
     {
@@ -7,7 +9,7 @@ namespace Bk::Net {
             addr.s_addr = INADDR_ANY;
             return addr;
         }
-        else if (inet_pton(AF_INET, str.c_str(), &addr) <= 0) BK_CORE_ERROR("IP processing failed ({0})", str);
+        else if (inet_pton(AF_INET, str.c_str(), &addr) <= 0) perror("Bad IP");
         return addr; 
     }
 }

bakanet/src/platform/linux/linux_socket.cpp

@@ -0,0 +1,95 @@
+#include "linux_socket.h"
+
+namespace Bk::Net {
+	LinuxSocket::LinuxSocket(int id, IpVersion ver, IpProtocol proto)
+	: id(id), ip_proto(proto)
+	{
+		char myIP[16] = "               ";
+		socklen_t len = sizeof(addr);
+    	getsockname(id, (struct sockaddr*)&addr, &len);
+		inet_ntop((int)ver, &addr, myIP, sizeof(myIP));
+		ip_addr = IpAddress(std::string(myIP, 16), ver);
+	}
+
+	LinuxSocket::LinuxSocket(IpAddress ip, int port, IpProtocol proto)
+	: ip_addr(ip), ip_proto(proto)
+	{
+		//LinuxSocket creation step
+		if ((id = socket((int)ip_addr.version, (int)ip_proto, 0)) < 0) 
+		{
+	        BK_CORE_ERROR("Socket failed");
+	        exit(EXIT_FAILURE);
+	    }
+	    addr.sin_addr = ip_addr.get_data();
+		addr.sin_family = (int)ip_addr.version;
+    	addr.sin_port = htons(port);
+	}
+
+	LinuxSocket::~LinuxSocket()
+	{
+		close(id);
+	}
+
+	bool LinuxSocket::init()
+	{
+	    //Binding step
+		int status;
+	    if ((status = bind(id, (struct sockaddr*)&addr, sizeof(addr)) < 0)) 
+	    {
+			BK_CORE_ERROR("Binding failed");
+	      	return false;
+	    }
+	    return true;
+	}
+
+	bool LinuxSocket::start(int cpt_conn)
+	{
+	    //Listening step
+	    if (listen(id, cpt_conn) < 0) 
+	    {
+			BK_CORE_ERROR("Listening failed");
+	    	return false;
+	    }
+	    return true;
+	}
+
+	std::unique_ptr<Socket> LinuxSocket::ack()
+	{
+		socklen_t addrlen = sizeof(addr);
+		return std::unique_ptr<Socket>(Socket::create(accept(id, (struct sockaddr*)&addr, &addrlen), ip_addr.version, ip_proto));
+	}
+
+	bool LinuxSocket::conn()
+	{
+		if (connect(id, (struct sockaddr*)&addr, sizeof(addr)) < 0) 
+		{
+			BK_CORE_ERROR("Connection failed");
+	        return false;
+    	}
+    	return true;
+	}
+
+	void LinuxSocket::emit(std::vector<char> packet)
+	{
+		write(id, packet.data(), packet.size());
+	}
+
+	std::vector<char> LinuxSocket::obtain(int size)
+	{
+		std::vector<char> buffer;
+		buffer.resize(size);
+		int read_size = read(id, buffer.data(), buffer.size() - 1);
+		buffer.resize(read_size);
+		return buffer;
+	}
+	
+	std::unique_ptr<Socket> Socket::create(IpAddress ip, int port, IpProtocol proto)
+	{
+		return std::unique_ptr<Socket>(new LinuxSocket(ip, port, proto));
+	}
+
+	std::unique_ptr<Socket> Socket::create(int id, IpVersion ver, IpProtocol proto)
+	{
+		return std::unique_ptr<Socket>(new LinuxSocket(id, ver, proto));
+	}
+}

bakanet/src/platform/linux/linux_socket.h

@@ -8,16 +8,14 @@ namespace Bk::Net {
 	{
         public:
             LinuxSocket(IpAddress ip, int port, IpProtocol proto);
-            LinuxSocket(int id, struct sockaddr_in client_addr, IpVersion ver, IpProtocol proto);
+            LinuxSocket(int id, IpVersion ver, IpProtocol proto);
             virtual ~LinuxSocket();
 
             bool init() override;
             bool start(int cpt_conn) override;
-            Socket* ack() override;
+            std::unique_ptr<Socket> ack() override;
             bool conn() override;
 
-            bool isConnected() override;
-
             int get_raw_socket() override { return id; }
             const std::string get_ip() override { return ip_addr.str; }
 
@@ -26,8 +24,6 @@ namespace Bk::Net {
 
         private:
             Connection id;
-            int size = 1024;
-            char* buffer = new char[size];
             struct sockaddr_in addr;
             IpAddress ip_addr;
             IpProtocol ip_proto;

bakanet/src/platform/windows/windows_ip_adress.cpp

@@ -9,8 +9,7 @@ namespace Bk::Net {
             addr.s_addr = INADDR_ANY;
             return addr;
         }
-        int result = InetPtonW(AF_INET, std::wstring(str.begin(), str.end()).c_str(), &addr);
+        else if (InetPton(AF_INET, (PWSTR)str.c_str(), &addr) <= 0) perror("Bad IP");
-        if (result <= 0) BK_CORE_ERROR("Bad IP {0}", result);
         return addr; 
     }
 }

bakanet/src/platform/windows/windows_socket.cpp

@@ -66,10 +66,10 @@ namespace Bk::Net {
 		return true;
 	}
 
-	Socket* WindowsSocket::ack()
+	std::unique_ptr<Socket> WindowsSocket::ack()
 	{
 		socklen_t addrlen = sizeof(addr);
-		return new WindowsSocket(accept((SOCKET)id, (struct sockaddr*)&addr, &addrlen), ip_addr.version, ip_proto));
+		return Socket::create(accept((SOCKET)id, (struct sockaddr*)&addr, &addrlen), ip_addr.version, ip_proto);
 	}
 
 	bool WindowsSocket::conn()
@@ -78,14 +78,6 @@ namespace Bk::Net {
 		return true;
 	}
 
-	bool WindowsSocket::hasConnection(int seconds, int microseconds) {
-		struct timeval tv = { seconds, microseconds };
-		fd_set rfds;
-		FD_ZERO(&rfds);
-		FD_SET(id, &rfds);
-		return select(id + 1, &rfds, (fd_set*)0, (fd_set*)0, &tv) > 0;
-	};
-
 	void WindowsSocket::emit(std::vector<char> packet)
 	{
 		send((SOCKET)id, packet.data(), packet.size(), 0);
@@ -100,8 +92,13 @@ namespace Bk::Net {
 		return buffer;
 	}
 
-	Socket* Socket::create(IpAddress ip, int port, IpProtocol proto)
+	std::unique_ptr<Socket> Socket::create(IpAddress ip, int port, IpProtocol proto)
+	{
+		return std::unique_ptr<Socket>(new WindowsSocket(ip, port, proto));
+	}
+
+	std::unique_ptr<Socket> Socket::create(int id, IpVersion ver, IpProtocol proto)
 	{
-		return new WindowsSocket(ip, port, proto);
+		return std::unique_ptr<Socket>(new WindowsSocket(id, ver, proto));
 	}
 }

bakanet/src/platform/windows/windows_socket.h

@@ -14,9 +14,8 @@ namespace Bk::Net {
 
         bool init() override;
         bool start(int cpt_conn) override;
-        Socket* ack() override;
+        std::unique_ptr<Socket> ack() override;
         bool conn() override;
-        bool hasConnection(int seconds = 0, int microseconds = 0) override;
 
         int get_raw_socket() override { return id; }
         const std::string get_ip() override { return ip_addr.str; }

build

@@ -0,0 +1,23 @@
+
+
+handle_error() {
+    echo "An error occurred on line $1"
+    exit 1
+}
+trap 'handle_error $LINENO' ERR
+
+if [ "-clear" == "$1" ]; then
+    rm -rf bin bin-int
+fi
+
+if [ "-clear" == "$2" ]; then
+    rm -rf bin bin-int
+fi
+
+clear 
+premake5 gmake2
+make
+
+if [ "-exec" == "$1" ]; then
+    ./bin/linux-x86_64-Debug/server/server
+fi

dependencies

@@ -1,5 +0,0 @@
-IncludeDirs["bakanet"] = "%{wks.location}/vendor/bakanet/src/"
-
-group "Bakanet"
-    include "vendor/bakanet"
-group ""

package.json

@@ -1,20 +0,0 @@
-{
-    "name": "Bakanet",
-    "author": "Anulax",
-    "git": "https://github.com/anulax1225/bakanet",
-    "links": 
-    [
-        "bakanet"
-    ],
-    "includes":
-    [
-        "bakanet"
-    ],
-    "packages": 
-    [
-        {
-            "author": "anulax",
-            "name": "bakatools"
-        }
-    ]
-}

premake5.lua

@@ -1,77 +1,27 @@
-project "bakanet"
+workspace "BakaraNet"
-	kind "StaticLib"
+   	architecture "x64"
-    language "C++"
+    configurations { "Debug", "Release" }
-    cppdialect "C++20"
+    startproject "server"
-    systemversion "latest"
+    flags
-    staticruntime "on"
+	{
-
+		"MultiProcessorCompile"
-    targetdir("%{wks.location}/bin/" .. outputdir .. "/%{prj.name}")
+	}
-    objdir("%{wks.location}/bin-int/" .. outputdir .. "/%{prj.name}")
+
-
+outputdir = "%{cfg.system}-%{cfg.architecture}-%{cfg.buildcfg}"
-    includedirs 
+
-    {
+IncludeDirs = {}
-        "%{IncludeDirs.spdlog}",
+IncludeDirs["bakanet"] = "%{wks.location}/bakanet/src/"
-        "%{IncludeDirs.bakanet}",
+IncludeDirs["bakatools"] = "%{wks.location}/vendor/bakatools/src/"
-        "%{IncludeDirs.bakatools}"
+IncludeDirs["spdlog"] = "%{wks.location}/vendor/spdlog/include"
-    }
+
-
+group "BakaModules"
-    files 
+	include "vendor/bakatools"
-    {
+group ""
-        "%{prj.location}/src/bakanet/**.h",
+
-        "%{prj.location}/src/bakanet/**.cpp",
+group "NetCore"
-        "%{prj.location}/src/baknetpch.h",
+	include "bakanet"
-    }
+group ""
-
+
-    links 
+group "Sandbox"
-    {
+	include "sandbox"
-        "bakatools"
+group ""
-    }
-
-    filter "system:windows"
-		buildoptions { "/MT", "/utf-8" }
-        defines
-        {
-            "BK_PLATFORM_WINDOWS"
-        }
-
-        files
-        {
-            "%{prj.location}/src/platform/windows/**.h",
-            "%{prj.location}/src/platform/windows/**.cpp",
-        }
-
-        links
-        {
-            "WS2_32.lib"
-        }
-    
-    filter "system:linux"
-        defines
-        {
-            "BK_PLATFORM_LINUX"
-        }
-
-        files
-        {
-            "%{prj.location}/src/platform/linux/**.h",
-            "%{prj.location}/src/platform/linux/**.cpp",
-        }
-    
-    filter "configurations:Debug"
-        defines 
-        { 
-            "BK_DEBUG",
-            "DEBUG"
-        }
-        runtime "Debug"
-        symbols "on"
-
-
-    filter "configurations:Release"
-        defines 
-        { 
-            "BK_RELEASE",
-            "NDEBUG"
-        }
-        runtime "Release"
-        optimize "on"

sandbox/premake5.lua

@@ -0,0 +1,66 @@
+project "server"
+    location "./server"
+    kind "ConsoleApp"
+    language "C++"
+    cppdialect "C++20"
+    systemversion "latest"
+
+    targetdir("%{wks.location}/bin/" .. outputdir .. "/%{prj.name}")
+    objdir("%{wks.location}/bin-int/" .. outputdir .. "/%{prj.name}")
+
+    defines
+    {
+        "BKMOD_ALL"
+    }
+    
+    includedirs 
+    {
+        "%{IncludeDirs.spdlog}",
+        "%{IncludeDirs.bakanet}",
+        "%{IncludeDirs.bakatools}"
+    }
+
+    files 
+    {
+        "%{prj.location}/**.h",
+        "%{prj.location}/**.cpp",
+    }
+
+    links
+    {
+        "bakanet",
+        "bakatools"
+    }
+
+    filter "system:linux"
+        defines
+        {
+            "BK_PLATFORM_LINUX"
+        }
+
+    filter "system:windows"
+        buildoptions "/MDd"
+        defines
+        {
+            "BK_PLATFORM_WINDOWS"
+        }
+
+    filter "configurations:Debug"
+        defines 
+        { 
+            "BK_DEBUG",
+            "DEBUG"
+        }
+        runtime "Debug"
+        symbols "on"
+
+    filter "configurations:Release"
+        defines 
+        { 
+            "BK_RELEASE",
+            "NDEBUG"
+        }
+        runtime "Release"
+        optimize "on"
+
+

sandbox/server/main.cpp

@@ -1,7 +1,7 @@
 #include <bakatools.h>
 #include <bakanet.h>
 
-#define PORT 80
+#define PORT 8080
 
 using namespace Bk::Net;
 
@@ -12,12 +12,21 @@ int main()
     HttpServer server(ip, PORT);
     server.get("/", [](HttpRequest& req)
     {
+        BK_INFO("URL /");
         HttpReponse res(HTTP_RES_200, req.version);
-        res.body = "<h1>Bakanet</h1>";
+        res.body = "<p>Coucou de /</p>";
-        res.body += "<p>Working http server</p>";
+        return res;
-        res.body += "\n<p>URL /</p>";
+    });
+    server.post("/home/", [](HttpRequest& req)
+    {
+        HttpReponse res(HTTP_RES_200, "HTTP/1.1");
+        res.body = "Success";
+        BK_INFO("\n{0}\n{1}", req.body, res.to_string());
         return res;
     });
     server.start();
     return 0;
-}
+}
+
+
+

src/platform/linux/linux_socket.cpp

@@ -1,104 +0,0 @@
-#include "linux_socket.h"
-#include <cstddef>
-#include <unistd.h>
-#include <netinet/in.h>
-#include <sys/socket.h>
-
-namespace Bk::Net {
-	LinuxSocket::LinuxSocket(int id, struct sockaddr_in client_addr, IpVersion ver, IpProtocol proto)
-	: id(id), ip_proto(proto), addr(client_addr)
-	{
-		char* myIP = inet_ntoa(addr.sin_addr);
-		ip_addr = IpAddress(std::string(myIP), ver);
-	}
-
-	LinuxSocket::LinuxSocket(IpAddress ip, int port, IpProtocol proto)
-	: ip_addr(ip), ip_proto(proto)
-	{
-		//LinuxSocket creation step
-		if ((id = socket((int)ip_addr.version, (int)ip_proto, 0)) < 0) 
-		{
-	        BK_CORE_ERROR("Socket failed");
-	        exit(EXIT_FAILURE);
-	    }
-	    addr.sin_addr = ip_addr.get_data();
-		addr.sin_family = (int)ip_addr.version;
-    	addr.sin_port = htons(port);
-	}
-
-	LinuxSocket::~LinuxSocket()
-	{
-		if(id > 0) close(id);
-	}
-
-	bool LinuxSocket::init()
-	{
-	    //Binding step
-		int status;
-	    if ((status = bind(id, (struct sockaddr*)&addr, sizeof(addr)) < 0)) 
-	    {
-			BK_CORE_ERROR("Binding failed");
-	      	return false;
-	    }
-	    return true;
-	}
-
-	bool LinuxSocket::start(int cpt_conn)
-	{
-	    //Listening step
-	    if (listen(id, cpt_conn) < 0) 
-	    {
-			BK_CORE_ERROR("Listening failed");
-	    	return false;
-	    }
-	    return true;
-	}
-
-	Socket* LinuxSocket::ack()
-	{
-		struct sockaddr_in client_addr;
-		socklen_t addrlen = sizeof(client_addr);
-		return new LinuxSocket(accept(id, (struct sockaddr*)&client_addr, &addrlen), client_addr, ip_addr.version, ip_proto);
-	}
-
-	bool LinuxSocket::conn()
-	{
-		if (connect(id, (struct sockaddr*)&addr, sizeof(addr)) != 0) 
-		{
-			BK_CORE_ERROR("Connection failed");
-	        return false;
-    	}
-    	return true;
-	}
-
-	bool LinuxSocket::isConnected()
-	{
-		char data = 0;
-		int read_size = recv(id, &data, 1, MSG_PEEK);
-		return (bool)read_size;
-	}
-
-	void LinuxSocket::emit(std::vector<char> packet)
-	{
-		size_t size = send(id, packet.data(), packet.size(), 0);
-	}
-
-	std::vector<char> LinuxSocket::obtain(int size)
-	{
-		if(size > this->size)
-		{
-			delete [] buffer;
-			buffer = new char[size];
-			this->size = size;
-		}
-		int read_size = recv(id, buffer, this->size - 1, 0);
-		if(read_size == -1) return std::vector<char>(0);
-		std::vector<char> packet(buffer, buffer + read_size);
-		return packet;
-	}
-	
-	Socket* Socket::create(IpAddress ip, int port, IpProtocol proto)
-	{
-		return new LinuxSocket(ip, port, proto);
-	}
-}

src/platform/windows/windows_dns_lookup.cpp

@@ -1,40 +0,0 @@
-#include <bakanet/core/dns_lookup.h>
-
-namespace Bk::Net {
-	std::vector<std::string> dns_lookup(const std::string& host_name, IpVersion ipv)
-	{
-		std::vector<std::string> output;
-		struct addrinfo hints, *res, *p;
-		char ip_address[INET6_ADDRSTRLEN];
-		memset(&hints, 0, sizeof hints);
-		hints.ai_family = (int)ipv;
-		hints.ai_socktype = SOCK_STREAM;
-
-		if (getaddrinfo(host_name.c_str(), NULL, &hints, &res) != 0)
-		{
-			output.push_back("");
-			return output;
-		}
-
-		for (p = res;p != NULL; p = p->ai_next)
-		{
-			void* addr;
-			if (p->ai_family == AF_INET)
-			{
-				struct sockaddr_in* ipv4 = (struct sockaddr_in*)p->ai_addr;
-				addr = &(ipv4->sin_addr);
-			}
-			else
-			{
-				struct sockaddr_in6* ipv6 = (struct sockaddr_in6*)p->ai_addr;
-				addr = &(ipv6->sin6_addr);
-			}
-			inet_ntop(p->ai_family, addr, ip_address, sizeof ip_address);
-			output.push_back(ip_address);
-		}
-
-		freeaddrinfo(res); // free the linked list
-
-		return output;
-	}
-}

vendor/bakatools

@@ -0,0 +1 @@
+Subproject commit 40d24e39a7a7b39a056418d78162103036e6534a

vendor/spdlog

@@ -0,0 +1 @@
+Subproject commit 23587b0d9aebad231d7ba4f16873d70edd2b9dee