netlib

Author: jwcpp

premake.bat

@@ -0,0 +1,2 @@
+@echo off
+premake5.exe --file=premake.lua vs2019

premake.lua

@@ -0,0 +1,43 @@
+workspace "network"
+configurations { "Debug", "Release" }
+platforms {'x32', 'x64'}
+--If no system is specified, Premake will identify and target the current operating system.
+--system { "windows", "linux" }
+
+filter "system:windows"
+	defines {'_CRT_SECURE_NO_WARNINGS'}
+	characterset ("MBCS") --Multi-byte Character Set; currently Visual Studio only
+	
+
+-- Debug and Release
+filter { "configurations:Debug" }
+	defines { "DEBUG", "_DEBUG" }
+	symbols "On"
+filter { "configurations:Release" }
+	defines { "NDEBUG" }
+    optimize "On"
+
+-- x32 and x64
+filter { "platforms:x32" }
+	architecture "x86"
+filter { "platforms:x64" }
+	architecture "x86_64"
+
+
+project "net"
+	location "src"
+	language "C++"
+	buildoptions {"-std=c++17"}
+	cppdialect "c++17"
+	kind "ConsoleApp"
+	targetdir "bin"
+	objdir "obj/net"
+	local codedir = "src";
+	files { codedir.."/*.h",codedir.."/*.cpp"}
+	targetname "net"
+	filter "system:windows"
+		local codedir = "src/iocp";
+		files { codedir.."/*.h",codedir.."/*.cpp"}
+	filter "system:linux"
+		local codedir = "src/epoll";
+		files { codedir.."/*.h",codedir.."/*.cpp"}

premake.sh

@@ -0,0 +1,2 @@
+./premake5 --file=premake.lua --cc=gcc gmake
+../make config=release_x64

premake5

@@ -0,0 +1,68 @@
+#pragma once
+#include "Platform.h"
+
+namespace net {
+    extern bool is_ipv4(const char* host);
+    extern bool is_ipv6(const char* host);
+    inline bool is_ipaddr(const char* host) {
+        return is_ipv4(host) || is_ipv6(host);
+    }
+
+    class IPAddres
+    {
+    public:
+        IPAddres(bool isv6 = false);
+        IPAddres(const char * addr, uint16_t port);
+        IPAddres(const sockaddr* addr);
+        IPAddres(const IPAddres& addr);
+
+        void operator = (const sockaddr* addr);
+        void operator = (const IPAddres& addr);
+
+        inline void setIpv6(bool b)
+        {
+            mbIpv6 = b;
+        }
+
+        inline bool isIpv6()const
+        {
+            return mbIpv6;
+        }
+
+        char const* getAddr(void) const;
+        uint16_t    getPort(void) const;
+
+        operator sockaddr& ()
+        {
+            return mbIpv6 ? *(sockaddr*)&mAddr6 : *(sockaddr*)&mAddr4;
+        }
+
+        operator const sockaddr& (void) const
+        {
+            return mbIpv6 ? *(sockaddr*)&mAddr6 : *(sockaddr*)&mAddr4;
+        }
+
+        operator sockaddr* ()
+        {
+            return mbIpv6 ? (sockaddr*)&mAddr6 : (sockaddr*)&mAddr4;
+        }
+
+        operator const sockaddr* (void) const
+        {
+            return mbIpv6 ? (sockaddr*)&mAddr6 : (sockaddr*)&mAddr4;
+        }
+
+        int addrSizeof() const
+        {
+            return mbIpv6 ? sizeof(sockaddr_in6) : sizeof(sockaddr_in);
+        }
+
+    private:
+        bool mbIpv6 = false;
+        union
+        {
+            sockaddr_in     mAddr4;
+            sockaddr_in6    mAddr6;
+        };
+    };
+}

premake5.exe

@@ -0,0 +1,11 @@
+#pragma once
+#include "Platform.h"
+
+#ifdef _SET_LOG
+	extern void writeLog(char const* const _Format, ...);
+	#define WRITE_LOG writeLog
+
+#else
+	#define WRITE_LOG printf
+
+#endif

src/IPAddres.h

@@ -0,0 +1,8 @@
+#pragma once
+#include "Platform.h"
+
+#ifdef WIN_OS
+	#include "iocp/Accept.h"
+#else
+	#include "epoll/Accept.h"
+#endif

src/NetDef.h

@@ -0,0 +1,134 @@
+#pragma once
+
+#include <stdio.h>
+#include <string.h>
+
+#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+	#define WIN_OS
+	#include <ws2tcpip.h>
+	#include <windows.h>
+#else
+	#define LINUX_OS
+	#include <errno.h>
+	#include <sys/socket.h>
+	#include <netinet/in.h>
+	#include <netinet/tcp.h>
+	#include <arpa/inet.h>
+	#include <netdb.h>
+	#include <sys/time.h>
+	#include <unistd.h>
+	#include <sys/epoll.h>
+	#include <fcntl.h>
+
+	typedef int	SOCKET;
+	#define INVALID_SOCKET -1
+#endif
+
+#include <stdint.h>
+#include <chrono>
+
+typedef int8_t int8;
+typedef uint8_t uint8;
+
+typedef int16_t int16;
+typedef uint16_t uint16;
+
+typedef int32_t int32;
+typedef uint32_t uint32;
+
+typedef int64_t int64;
+typedef uint64_t uint64;
+
+namespace base {
+	inline int32 getProcessPID()
+	{
+#ifdef WIN_OS
+		return (int32)GetCurrentProcessId();
+#else
+		return getpid();
+#endif
+	}
+
+	inline char* strerror(int ierrorno = 0)
+	{
+#ifdef WIN_OS
+		if (ierrorno == 0)
+			ierrorno = GetLastError();
+
+		static char lpMsgBuf[256] = { 0 };
+
+		/*
+		FormatMessage(
+			FORMAT_MESSAGE_FROM_SYSTEM |
+			FORMAT_MESSAGE_IGNORE_INSERTS,
+			NULL,
+			ierrorno,
+			MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
+			(LPTSTR) &lpMsgBuf,
+			1024,
+			NULL
+		);
+		*/
+		snprintf(lpMsgBuf, 256, "errorno=%d", ierrorno);
+		return lpMsgBuf;
+#else
+		if (ierrorno != 0)
+			return strerror(ierrorno);
+		return strerror(errno);
+#endif
+	}
+
+	inline int lasterror()
+	{
+#ifdef WIN_OS
+		return GetLastError();
+#else
+		return errno;
+#endif
+	}
+
+	/** 获取系统时间(精确到毫秒) */
+#ifdef WIN_OS
+	inline uint32 getSystemTime()
+	{
+		// 注意这个函数windows上只能正确维持49天。
+		return ::GetTickCount();
+	};
+#else
+	inline uint32 getSystemTime()
+	{
+		struct timeval tv;
+		struct timezone tz;
+		gettimeofday(&tv, &tz);
+		return (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
+	};
+#endif
+
+	/* get time in millisecond 64 */
+	inline uint64 getTimeMs()
+	{
+#ifdef WIN_OS
+		auto timeNow = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch());
+		return timeNow.count();
+#else
+		timeval time;
+		gettimeofday(&time, NULL);
+		return (uint64)((time.tv_sec * 1000) + (time.tv_usec / 1000));
+#endif
+	}
+
+#ifdef WIN_OS
+	inline void sleep(uint32 ms)
+	{
+		::Sleep(ms);
+	}
+#else
+	inline void sleep(uint32 ms)
+	{
+		struct timeval tval;
+		tval.tv_sec = ms / 1000;
+		tval.tv_usec = (ms * 1000) % 1000000;
+		select(0, NULL, NULL, NULL, &tval);
+	}
+#endif
+};//namespace

src/Network.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <tuple>
+
+struct PostBase
+{
+	virtual void call() = 0;
+};
+
+template<typename FUNC>
+struct PostNone : public PostBase
+{
+	PostNone(FUNC&& func) :
+		m_func(std::forward<FUNC>(func)) {
+	}
+	virtual void call() {
+		(m_func)();
+	}
+
+	FUNC m_func;
+};
+
+template<typename FUNC, typename... ARGS>
+struct PostArge : public PostBase
+{
+public:
+	PostArge(FUNC&& func, ARGS &&...args) :
+		m_func(std::forward<FUNC>(func)),
+		m_tuple(std::forward<ARGS>(args)...) {
+	}
+	virtual void call() {
+		std::apply(std::move(m_func), std::move(m_tuple));
+	}
+
+private:
+	FUNC m_func;
+	std::tuple<ARGS...> m_tuple;
+};
+
+#if 0
+template<typename FUNC, typename... ARGS>
+void post(FUNC&& func, ARGS &&...args)
+{
+	auto ptr = new PostArge<FUNC, ARGS...>(std::forward<FUNC>(func), std::forward<ARGS>(args)...);
+	ptr->call();
+
+	delete ptr;
+}
+
+template<typename FUNC>
+void post(FUNC&& func)
+{
+	auto ptr = new PostNone<FUNC>(std::forward<FUNC>(func));
+	ptr->call();
+
+	delete ptr;
+}
+
+#endif