Cleaned code

.gitmodules

@@ -1,6 +0,0 @@
-[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

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

bakanet/premake5.lua

@@ -1,82 +0,0 @@
-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/platform/linux/linux_socket.cpp

@@ -1,95 +0,0 @@
-#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));
-	}
-}

build

@@ -1,23 +0,0 @@
-
-
-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

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

examples/httpserver.cpp

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

package.json

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

premake5.lua

@@ -1,27 +1,77 @@
-workspace "BakaraNet"
+project "bakanet"
-   	architecture "x64"
+	kind "StaticLib"
-    configurations { "Debug", "Release" }
+    language "C++"
-    startproject "server"
+    cppdialect "C++20"
-    flags
+    systemversion "latest"
-	{
+    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["bakanet"] = "%{wks.location}/bakanet/src/"
+        "%{IncludeDirs.spdlog}",
-IncludeDirs["bakatools"] = "%{wks.location}/vendor/bakatools/src/"
+        "%{IncludeDirs.bakanet}",
-IncludeDirs["spdlog"] = "%{wks.location}/vendor/spdlog/include"
+        "%{IncludeDirs.bakatools}"
-
+    }
-group "BakaModules"
+
-	include "vendor/bakatools"
+    files 
-group ""
+    {
-
+        "%{prj.location}/src/bakanet/**.h",
-group "NetCore"
+        "%{prj.location}/src/bakanet/**.cpp",
-	include "bakanet"
+        "%{prj.location}/src/baknetpch.h",
-group ""
+    }
-
+
-group "Sandbox"
+    links 
-	include "sandbox"
+    {
-group ""
+        "bakatools"
+    }
+
+    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

@@ -1,66 +0,0 @@
-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"
-
-

src/bakanet/core/socket.h

@@ -16,9 +16,10 @@ namespace Bk::Net {
 
 			virtual bool init() = 0;
 			virtual bool start(int cpt_conn) = 0;
-			virtual std::unique_ptr<Socket> ack() = 0;
+			virtual Socket* ack() = 0;
 			virtual bool conn() = 0;
 
+			virtual bool isConnected() = 0;
 
 			virtual int get_raw_socket() = 0;
 			virtual const std::string get_ip() = 0;
@@ -29,8 +30,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 std::unique_ptr<Socket> create(IpAddress ip, int port, IpProtocol proto);
+			static Socket* create(IpAddress ip, int port, IpProtocol proto);
 		protected:	
-			static std::unique_ptr<Socket> create(int id, IpVersion ver, IpProtocol proto);
+			static Socket* create(int id, IpVersion ver, IpProtocol proto);
 	};
 }

src/bakanet/http/packet.h

@@ -15,6 +15,8 @@
 #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>;
 

src/bakanet/http/server.cpp

@@ -1,23 +1,30 @@
 #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)
         {
-            std::unique_ptr<Socket> conn = socket->ack();
+            Socket* conn = socket->ack();
-            threads.push_back(std::thread([this](std::unique_ptr<Socket> conn) 
+            pool.queue([this, conn]() 
             {
-                route_request(*conn, recv_request(*conn));
+                route_request(conn, recv_request(conn));
-            }, std::move(conn)));
+                delete conn;
+            });
         } 
+        pool.stop();
     }
     
     void HttpServer::get(std::string url, RequestHandler req_handler)
@@ -25,7 +32,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 }}));
     }
 
@@ -34,7 +41,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 }}));
     }
 
@@ -43,7 +50,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 }}));
     }
 
@@ -52,17 +59,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();
@@ -70,15 +77,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, " /");

src/bakanet/http/server.h

@@ -2,6 +2,7 @@
 
 #include <bakanetpch.h>
 #include <bakanet/core/ip_address.h>
+#include <bakatools/thread/task_pool.h>
 #include <bakanet/core/socket.h>
 #include "packet.h"
 
@@ -9,13 +10,12 @@ 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() = default;
+            ~HttpServer();
             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:
-            std::unique_ptr<Socket> socket;
+            Socket* socket;
-            ThreadPool threads;
+            ThreadPool pool;
             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);
     };
 }

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)

src/platform/linux/linux_ip_address.cpp

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

src/platform/linux/linux_socket.cpp

@@ -0,0 +1,104 @@
+#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/linux/linux_socket.h

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

src/platform/windows/windows_dns_lookup.cpp

@@ -0,0 +1,40 @@
+#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;
+	}
+}

src/platform/windows/windows_ip_adress.cpp

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

src/platform/windows/windows_socket.cpp

@@ -66,10 +66,10 @@ namespace Bk::Net {
 		return true;
 	}
 
-	std::unique_ptr<Socket> WindowsSocket::ack()
+	Socket* WindowsSocket::ack()
 	{
 		socklen_t addrlen = sizeof(addr);
-		return Socket::create(accept((SOCKET)id, (struct sockaddr*)&addr, &addrlen), ip_addr.version, ip_proto);
+		return new WindowsSocket(accept((SOCKET)id, (struct sockaddr*)&addr, &addrlen), ip_addr.version, ip_proto));
 	}
 
 	bool WindowsSocket::conn()
@@ -78,6 +78,14 @@ 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);
@@ -92,13 +100,8 @@ namespace Bk::Net {
 		return buffer;
 	}
 
-	std::unique_ptr<Socket> Socket::create(IpAddress ip, int port, IpProtocol proto)
+	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 std::unique_ptr<Socket>(new WindowsSocket(id, ver, proto));
+		return new WindowsSocket(ip, port, proto);
 	}
 }

src/platform/windows/windows_socket.h

@@ -14,8 +14,9 @@ namespace Bk::Net {
 
         bool init() override;
         bool start(int cpt_conn) override;
-        std::unique_ptr<Socket> ack() override;
+        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; }

vendor/bakatools

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

vendor/spdlog

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