Initial Commit

Norrath Server.rc

@@ -0,0 +1,71 @@
+// Microsoft Visual C++ generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "winres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (United Kingdom) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENG)
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_UK
+#pragma code_page(1252)
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE 
+BEGIN
+    "#include ""winres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+IDI_ICON1               ICON                    ".\icon.ico"
+
+#endif    // English (United Kingdom) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+

Norrath Server.sln

@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.28729.10
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Norrath Server", "Norrath Server.vcxproj", "{08A65603-4FF0-426E-9FF8-1772F199F49B}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{08A65603-4FF0-426E-9FF8-1772F199F49B}.Debug|x64.ActiveCfg = Debug|x64
+		{08A65603-4FF0-426E-9FF8-1772F199F49B}.Debug|x64.Build.0 = Debug|x64
+		{08A65603-4FF0-426E-9FF8-1772F199F49B}.Debug|x86.ActiveCfg = Debug|Win32
+		{08A65603-4FF0-426E-9FF8-1772F199F49B}.Debug|x86.Build.0 = Debug|Win32
+		{08A65603-4FF0-426E-9FF8-1772F199F49B}.Release|x64.ActiveCfg = Release|x64
+		{08A65603-4FF0-426E-9FF8-1772F199F49B}.Release|x64.Build.0 = Release|x64
+		{08A65603-4FF0-426E-9FF8-1772F199F49B}.Release|x86.ActiveCfg = Release|Win32
+		{08A65603-4FF0-426E-9FF8-1772F199F49B}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {E4DC2A1C-2002-45F5-9500-7301E66AC6FB}
+	EndGlobalSection
+EndGlobal

Norrath Server.vcxproj

@@ -0,0 +1,240 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{08A65603-4FF0-426E-9FF8-1772F199F49B}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>MasterServer</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+    <ProjectName>Norrath Server</ProjectName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <EnableManagedIncrementalBuild>true</EnableManagedIncrementalBuild>
+    <TargetName>NorrathServer</TargetName>
+    <OutDir>.\bin\</OutDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <OutDir>.\bin\</OutDir>
+    <TargetName>MasterServer</TargetName>
+    <EnableManagedIncrementalBuild>true</EnableManagedIncrementalBuild>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <OutDir>.\bin\</OutDir>
+    <TargetName>NorrathServer</TargetName>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <MinimalRebuild>false</MinimalRebuild>
+      <BrowseInformation>true</BrowseInformation>
+      <LanguageStandard>stdcpp20</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <OutputFile>$(OutDirFullPath)$(TargetFileName)</OutputFile>
+      <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <TargetMachine>MachineX86</TargetMachine>
+      <AdditionalOptions>/ignore:4099 %(AdditionalOptions)</AdditionalOptions>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>..\dependency\wolfssl;..\dependency\boost;..\dependency\json;..\dependency\clementine_ui\include;..\tools\src\;..\dependency\asio\include\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>odbc32.lib;ws2_32.lib;wolfssl.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>.\lib</AdditionalLibraryDirectories>
+      <OutputFile>.\bin\MasterServer64.exe</OutputFile>
+    </Link>
+    <PostBuildEvent>
+      <Command>echo F|xcopy /y /f "$(SolutionDir)../dependency/clementine_ui/bin/clementine_ui.dll" "$(TargetDir)/clementine_ui.dll"  </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>..\Dependency\json;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <OutputFile>$(OutDirFullPath)$(TargetFileName)</OutputFile>
+      <AdditionalDependencies>ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>..\dependency\wolfssl;..\dependency\boost;..\dependency\json;..\dependency\clementine_ui\include;..\tools\src\;..\dependency\asio\include\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+    <PostBuildEvent>
+      <Command>echo F|xcopy /y /f "$(SolutionDir)../dependency/clementine_ui/bin/clementine_ui.dll" "$(TargetDir)/clementine_ui.dll"  </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="configuration.h" />
+    <ClInclude Include="game\client.h" />
+    <ClInclude Include="game\client_manager.h" />
+    <ClInclude Include="global_define.h" />
+    <ClInclude Include="misc\AES.h" />
+    <ClInclude Include="misc\ByteStream.h" />
+    <ClInclude Include="misc\Encryptor.h" />
+    <ClInclude Include="misc\math.h" />
+    <ClInclude Include="misc\threadsafe_queue.hpp" />
+    <ClInclude Include="misc\Timer.h" />
+    <ClInclude Include="network\protocol_broker.h" />
+    <ClInclude Include="network\protocol_game.h" />
+    <ClInclude Include="network\packet.h" />
+    <ClInclude Include="network\protocol_gateway.h" />
+    <ClInclude Include="network\socket.h" />
+    <ClInclude Include="network\socket_manager.h" />
+    <ClInclude Include="resource.h" />
+    <ClInclude Include="stdafx.h" />
+    <ClInclude Include="targetver.h" />
+    <ClInclude Include="ui\logging.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="configuration.cpp" />
+    <ClCompile Include="game\client.cpp" />
+    <ClCompile Include="game\client_manager.cpp" />
+    <ClCompile Include="global_define.cpp" />
+    <ClCompile Include="misc\AES.cpp" />
+    <ClCompile Include="misc\ByteStream.cpp" />
+    <ClCompile Include="misc\Encryptor.cpp" />
+    <ClCompile Include="main.cpp" />
+    <ClCompile Include="misc\math.cpp" />
+    <ClCompile Include="misc\Timer.cpp" />
+    <ClCompile Include="network\protocol_broker.cpp" />
+    <ClCompile Include="network\protocol_game.cpp" />
+    <ClCompile Include="network\protocol_gateway.cpp" />
+    <ClCompile Include="network\packet.cpp" />
+    <ClCompile Include="network\socket.cpp" />
+    <ClCompile Include="network\socket_manager.cpp" />
+    <ClCompile Include="stdafx.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="ui\logging.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="Norrath Server.rc" />
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="C:\Users\Adam\Desktop\icon.ico" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

Norrath Server.vcxproj.filters

@@ -0,0 +1,161 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Header Files\network">
+      <UniqueIdentifier>{d03ff7f7-63d1-43a7-b2cc-4b585130f545}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\network">
+      <UniqueIdentifier>{d2399894-b1e4-4a31-86ac-a4fa3a1b7e76}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\game">
+      <UniqueIdentifier>{20330632-08bb-481a-bee5-3148c43dd451}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\ui">
+      <UniqueIdentifier>{767ee381-3651-4dd0-bc78-7037cefe7006}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\game">
+      <UniqueIdentifier>{cfe30c00-4a52-4659-94af-3ac2712690c6}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\misc">
+      <UniqueIdentifier>{8b5e9b37-079d-4c08-99b0-c05b88543b70}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\misc">
+      <UniqueIdentifier>{0ecae2be-b6b6-4ee2-bcb2-9252f189acca}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\ui">
+      <UniqueIdentifier>{4a905260-4faf-4748-be14-8971a80b46b5}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="stdafx.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="targetver.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="network\socket.h">
+      <Filter>Header Files\network</Filter>
+    </ClInclude>
+    <ClInclude Include="global_define.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="game\client.h">
+      <Filter>Header Files\game</Filter>
+    </ClInclude>
+    <ClInclude Include="configuration.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="misc\math.h">
+      <Filter>Header Files\misc</Filter>
+    </ClInclude>
+    <ClInclude Include="misc\Timer.h">
+      <Filter>Header Files\misc</Filter>
+    </ClInclude>
+    <ClInclude Include="game\client_manager.h">
+      <Filter>Header Files\game</Filter>
+    </ClInclude>
+    <ClInclude Include="network\socket_manager.h">
+      <Filter>Header Files\network</Filter>
+    </ClInclude>
+    <ClInclude Include="network\packet.h">
+      <Filter>Header Files\network</Filter>
+    </ClInclude>
+    <ClInclude Include="ui\logging.h">
+      <Filter>Header Files\ui</Filter>
+    </ClInclude>
+    <ClInclude Include="misc\threadsafe_queue.hpp">
+      <Filter>Header Files\misc</Filter>
+    </ClInclude>
+    <ClInclude Include="network\protocol_game.h">
+      <Filter>Header Files\network</Filter>
+    </ClInclude>
+    <ClInclude Include="resource.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="misc\Encryptor.h">
+      <Filter>Header Files\misc</Filter>
+    </ClInclude>
+    <ClInclude Include="network\protocol_gateway.h">
+      <Filter>Header Files\network</Filter>
+    </ClInclude>
+    <ClInclude Include="misc\ByteStream.h">
+      <Filter>Header Files\misc</Filter>
+    </ClInclude>
+    <ClInclude Include="misc\AES.h">
+      <Filter>Header Files\misc</Filter>
+    </ClInclude>
+    <ClInclude Include="network\protocol_broker.h">
+      <Filter>Header Files\network</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="stdafx.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="global_define.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="configuration.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="game\client.cpp">
+      <Filter>Source Files\game</Filter>
+    </ClCompile>
+    <ClCompile Include="misc\Timer.cpp">
+      <Filter>Source Files\misc</Filter>
+    </ClCompile>
+    <ClCompile Include="misc\math.cpp">
+      <Filter>Source Files\misc</Filter>
+    </ClCompile>
+    <ClCompile Include="game\client_manager.cpp">
+      <Filter>Source Files\game</Filter>
+    </ClCompile>
+    <ClCompile Include="network\socket_manager.cpp">
+      <Filter>Source Files\network</Filter>
+    </ClCompile>
+    <ClCompile Include="network\packet.cpp">
+      <Filter>Source Files\network</Filter>
+    </ClCompile>
+    <ClCompile Include="ui\logging.cpp">
+      <Filter>Source Files\ui</Filter>
+    </ClCompile>
+    <ClCompile Include="main.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="network\protocol_gateway.cpp">
+      <Filter>Source Files\network</Filter>
+    </ClCompile>
+    <ClCompile Include="misc\Encryptor.cpp">
+      <Filter>Source Files\misc</Filter>
+    </ClCompile>
+    <ClCompile Include="misc\ByteStream.cpp">
+      <Filter>Source Files\misc</Filter>
+    </ClCompile>
+    <ClCompile Include="network\protocol_game.cpp">
+      <Filter>Source Files\network</Filter>
+    </ClCompile>
+    <ClCompile Include="network\socket.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="misc\AES.cpp">
+      <Filter>Source Files\misc</Filter>
+    </ClCompile>
+    <ClCompile Include="network\protocol_broker.cpp">
+      <Filter>Source Files\network</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="Norrath Server.rc" />
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="C:\Users\Adam\Desktop\icon.ico" />
+  </ItemGroup>
+</Project>

Norrath Server.vcxproj.user

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LocalDebuggerWorkingDirectory>$(ProjectDir)bin</LocalDebuggerWorkingDirectory>
+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LocalDebuggerWorkingDirectory>$(ProjectDir)bin</LocalDebuggerWorkingDirectory>
+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
+  </PropertyGroup>
+</Project>

README.md

@@ -1 +1,4 @@
-# patch_server
+### Champions Emulated Server
+This is a replacement server intended to restore online game play for Champions of Norrath on the Playstation 2.
+
+The server is currently a work in progress.

configuration.cpp

@@ -0,0 +1,25 @@
+
+#include "global_define.h"
+#include "configuration.h"
+
+ServerConfig::ServerConfig()
+{
+	service_ip.clear();
+	gateway_port = 0;
+	session_port = 0;
+	broker_port = 0;
+}
+
+ServerConfig::~ServerConfig()
+{
+}
+
+bool ServerConfig::Load( std::string filename )
+{
+	service_ip = "192.168.1.248";
+	gateway_port = 40801;
+	session_port = 40802;
+	broker_port = 3000;	// The game uses 3000 as the default broker port, but also for local net play.
+
+	return true;
+}

configuration.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <fstream>
+#include <string>
+
+class ServerConfig
+{
+public:
+	static ServerConfig &Get()
+	{
+		static ServerConfig instance;
+		return instance;
+	}
+
+	ServerConfig();
+	~ServerConfig();
+
+	bool Load( std::string filename );
+
+	std::string service_ip;
+	uint16_t gateway_port;
+	uint16_t session_port;
+	uint16_t broker_port;
+};

game/client.cpp

@@ -0,0 +1,11 @@
+#include "..\global_define.h"
+
+CClient::CClient()
+{
+	
+}
+
+CClient::~CClient()
+{
+
+}

game/client.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "../misc/Encryptor.h"
+
+class CClient {
+public:
+	CClient();
+	~CClient();
+
+	sptr_socket	socket;
+
+	Encryptor encryptor;
+};
+
+typedef std::shared_ptr< CClient >	sptr_client;

game/client_manager.cpp

@@ -0,0 +1,48 @@
+#include "../global_define.h"
+
+// Spawn a new client
+bool CClientManager::spawn_new( sptr_socket socket, sptr_client &ret )
+{
+	sptr_client client = std::make_shared< CClient >();
+	client->socket = socket;
+
+	// The result if the 'insert'
+	std::pair< std::map< SOCKET, sptr_client >::iterator, bool > result;
+
+	// Insert the client into the map - keyed by its socket.
+	result = client_map.insert( std::make_pair( socket->fd, client ) );
+
+	ret = ( *result.first ).second;
+
+	return result.second;
+}
+
+// Find an existing client in the service
+bool CClientManager::get_client( sptr_socket socket, sptr_client &ret )
+{
+	std::map< SOCKET, sptr_client >::iterator it;
+	if( client_map.end() == ( it = client_map.find( socket->fd ) ) ) return false;
+
+	ret = ( *it ).second;
+	return true;
+}
+
+// Find and remove a client by its socket
+void CClientManager::remove_client( sptr_socket socket )
+{
+	std::map< SOCKET, sptr_client >::iterator it;
+	if( client_map.end() == ( it = client_map.find( socket->fd ) ) ) return;
+
+	client_map.erase( it );
+}
+
+// Remove a client and mark the socket for disconnection
+void CClientManager::disconnect( sptr_client c )
+{
+	std::map< SOCKET, sptr_client >::iterator it;
+	if( client_map.end() == ( it = client_map.find( c->socket->fd ) ) ) return;
+
+	c->socket->flag.disconnected = 1;
+
+	client_map.erase( it );
+}

game/client_manager.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <map>
+
+class CClientManager {
+public:
+	CClientManager()
+	{
+		client_map.clear();
+	}
+
+	~CClientManager()
+	{
+		client_map.clear();
+	}
+
+	// Add a new client
+	bool spawn_new( sptr_socket socket, sptr_client &ret );
+
+	// Fine an existing client in the service
+	bool get_client( sptr_socket socket, sptr_client &ret );
+	
+	// Remove an existing client in the service
+	void remove_client( sptr_socket socket );
+
+	void disconnect( sptr_client client );
+
+	std::map< SOCKET, sptr_client > client_map;
+};

global_define.cpp

@@ -0,0 +1,28 @@
+#include "global_define.h"
+
+CLogManager							logging;
+
+std::unique_ptr< CTimer >			server_time;
+std::unique_ptr< CClientManager >	client_manager;
+std::unique_ptr< CSocketManager >	socket_manager;
+
+void Initialize_Global()
+{
+	try
+	{
+		// Start Timer
+		server_time = std::make_unique< CTimer >();
+		server_time->Start();
+
+		// Start Client Manager
+		client_manager = std::make_unique < CClientManager >();
+
+		// Start Network
+		socket_manager = std::make_unique < CSocketManager >();
+		socket_manager->initialize();
+	}
+	catch( std::exception e )
+	{
+		logging.error( "%s\n", e.what() );
+	}
+}

global_define.h

@@ -0,0 +1,33 @@
+
+#define _WINSOCK_DEPRECATED_NO_WARNINGS
+#define FD_SETSIZE 1024
+#include <WinSock2.h>
+
+#include <Windows.h>
+#include <cstdint>
+
+#include "misc/math.h"
+#include "misc/Timer.h"
+
+#include "misc/threadsafe_queue.hpp"
+#include "misc/Encryptor.h"
+#include "misc/ByteStream.h"
+
+#include "ui/logging.h"
+#include "configuration.h"
+
+#include "network/socket.h"
+#include "network/packet.h"
+#include "network/socket_manager.h"
+
+#include "game/client.h"
+#include "game/client_manager.h"
+#include "network/protocol_gateway.h"
+#include "network/protocol_game.h"
+
+extern CLogManager							logging;
+extern std::unique_ptr< CTimer >			server_time;
+extern std::unique_ptr< CClientManager >	client_manager;
+extern std::unique_ptr< CSocketManager >	socket_manager;
+
+void Initialize_Global();

main.cpp

@@ -0,0 +1,38 @@
+#include "stdafx.h"
+#include "global_define.h"
+
+void ShowStartup()
+{
+	printf
+	(
+		"------------------------------------------------------\n"
+		"Norrath Server Build Version %s\n"
+		"------------------------------------------------------\n\n",
+		__DATE__
+	);
+}
+
+int main()
+{
+	ShowStartup();
+
+	if( false == ServerConfig::Get().Load( "config.json" ) )
+	{
+		return 0;
+	}
+
+	Initialize_Global();
+
+	logging.information( "Server Start..." );
+
+	while( true )
+	{
+		server_time->Tick();
+
+		process_networking();
+
+		std::this_thread::sleep_for( std::chrono::milliseconds( 1 ) );
+	}
+
+    return 0;
+}

misc/AES.cpp

@@ -0,0 +1,454 @@
+#include "AES.h"
+
+AES::AES(const AESKeyLength keyLength) {
+  switch (keyLength) {
+    case AESKeyLength::AES_128:
+      this->Nk = 4;
+      this->Nr = 10;
+      break;
+    case AESKeyLength::AES_192:
+      this->Nk = 6;
+      this->Nr = 12;
+      break;
+    case AESKeyLength::AES_256:
+      this->Nk = 8;
+      this->Nr = 14;
+      break;
+  }
+}
+
+unsigned char *AES::EncryptECB(const unsigned char in[], unsigned int inLen,
+                               const unsigned char key[]) {
+  CheckLength(inLen);
+  unsigned char *out = new unsigned char[inLen];
+  unsigned char *roundKeys = new unsigned char[4 * Nb * (Nr + 1)];
+  KeyExpansion(key, roundKeys);
+  for (unsigned int i = 0; i < inLen; i += blockBytesLen) {
+    EncryptBlock(in + i, out + i, roundKeys);
+  }
+
+  delete[] roundKeys;
+
+  return out;
+}
+
+unsigned char *AES::DecryptECB(const unsigned char in[], unsigned int inLen,
+                               const unsigned char key[]) {
+  CheckLength(inLen);
+  unsigned char *out = new unsigned char[inLen];
+  unsigned char *roundKeys = new unsigned char[4 * Nb * (Nr + 1)];
+  KeyExpansion(key, roundKeys);
+  for (unsigned int i = 0; i < inLen; i += blockBytesLen) {
+    DecryptBlock(in + i, out + i, roundKeys);
+  }
+
+  delete[] roundKeys;
+
+  return out;
+}
+
+unsigned char *AES::EncryptCBC(const unsigned char in[], unsigned int inLen,
+                               const unsigned char key[],
+                               const unsigned char *iv) {
+  CheckLength(inLen);
+  unsigned char *out = new unsigned char[inLen];
+  unsigned char block[blockBytesLen];
+  unsigned char *roundKeys = new unsigned char[4 * Nb * (Nr + 1)];
+  KeyExpansion(key, roundKeys);
+  memcpy(block, iv, blockBytesLen);
+  for (unsigned int i = 0; i < inLen; i += blockBytesLen) {
+    XorBlocks(block, in + i, block, blockBytesLen);
+    EncryptBlock(block, out + i, roundKeys);
+    memcpy(block, out + i, blockBytesLen);
+  }
+
+  delete[] roundKeys;
+
+  return out;
+}
+
+unsigned char *AES::DecryptCBC(const unsigned char in[], unsigned int inLen,
+                               const unsigned char key[],
+                               const unsigned char *iv) {
+  CheckLength(inLen);
+  unsigned char *out = new unsigned char[inLen];
+  unsigned char block[blockBytesLen];
+  unsigned char *roundKeys = new unsigned char[4 * Nb * (Nr + 1)];
+  KeyExpansion(key, roundKeys);
+  memcpy(block, iv, blockBytesLen);
+  for (unsigned int i = 0; i < inLen; i += blockBytesLen) {
+    DecryptBlock(in + i, out + i, roundKeys);
+    XorBlocks(block, out + i, out + i, blockBytesLen);
+    memcpy(block, in + i, blockBytesLen);
+  }
+
+  delete[] roundKeys;
+
+  return out;
+}
+
+unsigned char *AES::EncryptCFB(const unsigned char in[], unsigned int inLen,
+                               const unsigned char key[],
+                               const unsigned char *iv) {
+  CheckLength(inLen);
+  unsigned char *out = new unsigned char[inLen];
+  unsigned char block[blockBytesLen];
+  unsigned char encryptedBlock[blockBytesLen];
+  unsigned char *roundKeys = new unsigned char[4 * Nb * (Nr + 1)];
+  KeyExpansion(key, roundKeys);
+  memcpy(block, iv, blockBytesLen);
+  for (unsigned int i = 0; i < inLen; i += blockBytesLen) {
+    EncryptBlock(block, encryptedBlock, roundKeys);
+    XorBlocks(in + i, encryptedBlock, out + i, blockBytesLen);
+    memcpy(block, out + i, blockBytesLen);
+  }
+
+  delete[] roundKeys;
+
+  return out;
+}
+
+unsigned char *AES::DecryptCFB(const unsigned char in[], unsigned int inLen,
+                               const unsigned char key[],
+                               const unsigned char *iv) {
+  CheckLength(inLen);
+  unsigned char *out = new unsigned char[inLen];
+  unsigned char block[blockBytesLen];
+  unsigned char encryptedBlock[blockBytesLen];
+  unsigned char *roundKeys = new unsigned char[4 * Nb * (Nr + 1)];
+  KeyExpansion(key, roundKeys);
+  memcpy(block, iv, blockBytesLen);
+  for (unsigned int i = 0; i < inLen; i += blockBytesLen) {
+    EncryptBlock(block, encryptedBlock, roundKeys);
+    XorBlocks(in + i, encryptedBlock, out + i, blockBytesLen);
+    memcpy(block, in + i, blockBytesLen);
+  }
+
+  delete[] roundKeys;
+
+  return out;
+}
+
+void AES::CheckLength(unsigned int len) {
+  if (len % blockBytesLen != 0) {
+    throw std::length_error("Plaintext length must be divisible by " +
+                            std::to_string(blockBytesLen));
+  }
+}
+
+void AES::EncryptBlock(const unsigned char in[], unsigned char out[],
+                       unsigned char *roundKeys) {
+  unsigned char state[4][Nb];
+  unsigned int i, j, round;
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < Nb; j++) {
+      state[i][j] = in[i + 4 * j];
+    }
+  }
+
+  AddRoundKey(state, roundKeys);
+
+  for (round = 1; round <= Nr - 1; round++) {
+    SubBytes(state);
+    ShiftRows(state);
+    MixColumns(state);
+    AddRoundKey(state, roundKeys + round * 4 * Nb);
+  }
+
+  SubBytes(state);
+  ShiftRows(state);
+  AddRoundKey(state, roundKeys + Nr * 4 * Nb);
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < Nb; j++) {
+      out[i + 4 * j] = state[i][j];
+    }
+  }
+}
+
+void AES::DecryptBlock(const unsigned char in[], unsigned char out[],
+                       unsigned char *roundKeys) {
+  unsigned char state[4][Nb];
+  unsigned int i, j, round;
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < Nb; j++) {
+      state[i][j] = in[i + 4 * j];
+    }
+  }
+
+  AddRoundKey(state, roundKeys + Nr * 4 * Nb);
+
+  for (round = Nr - 1; round >= 1; round--) {
+    InvSubBytes(state);
+    InvShiftRows(state);
+    AddRoundKey(state, roundKeys + round * 4 * Nb);
+    InvMixColumns(state);
+  }
+
+  InvSubBytes(state);
+  InvShiftRows(state);
+  AddRoundKey(state, roundKeys);
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < Nb; j++) {
+      out[i + 4 * j] = state[i][j];
+    }
+  }
+}
+
+void AES::SubBytes(unsigned char state[4][Nb]) {
+  unsigned int i, j;
+  unsigned char t;
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < Nb; j++) {
+      t = state[i][j];
+      state[i][j] = sbox[t / 16][t % 16];
+    }
+  }
+}
+
+void AES::ShiftRow(unsigned char state[4][Nb], unsigned int i,
+                   unsigned int n)  // shift row i on n write_positions
+{
+  unsigned char tmp[Nb];
+  for (unsigned int j = 0; j < Nb; j++) {
+    tmp[j] = state[i][(j + n) % Nb];
+  }
+  memcpy(state[i], tmp, Nb * sizeof(unsigned char));
+}
+
+void AES::ShiftRows(unsigned char state[4][Nb]) {
+  ShiftRow(state, 1, 1);
+  ShiftRow(state, 2, 2);
+  ShiftRow(state, 3, 3);
+}
+
+unsigned char AES::xtime(unsigned char b)  // multiply on x
+{
+  return (b << 1) ^ (((b >> 7) & 1) * 0x1b);
+}
+
+void AES::MixColumns(unsigned char state[4][Nb]) {
+  unsigned char temp_state[4][Nb];
+
+  for (size_t i = 0; i < 4; ++i) {
+    memset(temp_state[i], 0, 4);
+  }
+
+  for (size_t i = 0; i < 4; ++i) {
+    for (size_t k = 0; k < 4; ++k) {
+      for (size_t j = 0; j < 4; ++j) {
+        if (CMDS[i][k] == 1)
+          temp_state[i][j] ^= state[k][j];
+        else
+          temp_state[i][j] ^= GF_MUL_TABLE[CMDS[i][k]][state[k][j]];
+      }
+    }
+  }
+
+  for (size_t i = 0; i < 4; ++i) {
+    memcpy(state[i], temp_state[i], 4);
+  }
+}
+
+void AES::AddRoundKey(unsigned char state[4][Nb], unsigned char *key) {
+  unsigned int i, j;
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < Nb; j++) {
+      state[i][j] = state[i][j] ^ key[i + 4 * j];
+    }
+  }
+}
+
+void AES::SubWord(unsigned char *a) {
+  int i;
+  for (i = 0; i < 4; i++) {
+    a[i] = sbox[a[i] / 16][a[i] % 16];
+  }
+}
+
+void AES::RotWord(unsigned char *a) {
+  unsigned char c = a[0];
+  a[0] = a[1];
+  a[1] = a[2];
+  a[2] = a[3];
+  a[3] = c;
+}
+
+void AES::XorWords(unsigned char *a, unsigned char *b, unsigned char *c) {
+  int i;
+  for (i = 0; i < 4; i++) {
+    c[i] = a[i] ^ b[i];
+  }
+}
+
+void AES::Rcon(unsigned char *a, unsigned int n) {
+  unsigned int i;
+  unsigned char c = 1;
+  for (i = 0; i < n - 1; i++) {
+    c = xtime(c);
+  }
+
+  a[0] = c;
+  a[1] = a[2] = a[3] = 0;
+}
+
+void AES::KeyExpansion(const unsigned char key[], unsigned char w[]) {
+  unsigned char temp[4];
+  unsigned char rcon[4];
+
+  unsigned int i = 0;
+  while (i < 4 * Nk) {
+    w[i] = key[i];
+    i++;
+  }
+
+  i = 4 * Nk;
+  while (i < 4 * Nb * (Nr + 1)) {
+    temp[0] = w[i - 4 + 0];
+    temp[1] = w[i - 4 + 1];
+    temp[2] = w[i - 4 + 2];
+    temp[3] = w[i - 4 + 3];
+
+    if (i / 4 % Nk == 0) {
+      RotWord(temp);
+      SubWord(temp);
+      Rcon(rcon, i / (Nk * 4));
+      XorWords(temp, rcon, temp);
+    } else if (Nk > 6 && i / 4 % Nk == 4) {
+      SubWord(temp);
+    }
+
+    w[i + 0] = w[i - 4 * Nk] ^ temp[0];
+    w[i + 1] = w[i + 1 - 4 * Nk] ^ temp[1];
+    w[i + 2] = w[i + 2 - 4 * Nk] ^ temp[2];
+    w[i + 3] = w[i + 3 - 4 * Nk] ^ temp[3];
+    i += 4;
+  }
+}
+
+void AES::InvSubBytes(unsigned char state[4][Nb]) {
+  unsigned int i, j;
+  unsigned char t;
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < Nb; j++) {
+      t = state[i][j];
+      state[i][j] = inv_sbox[t / 16][t % 16];
+    }
+  }
+}
+
+void AES::InvMixColumns(unsigned char state[4][Nb]) {
+  unsigned char temp_state[4][Nb];
+
+  for (size_t i = 0; i < 4; ++i) {
+    memset(temp_state[i], 0, 4);
+  }
+
+  for (size_t i = 0; i < 4; ++i) {
+    for (size_t k = 0; k < 4; ++k) {
+      for (size_t j = 0; j < 4; ++j) {
+        temp_state[i][j] ^= GF_MUL_TABLE[INV_CMDS[i][k]][state[k][j]];
+      }
+    }
+  }
+
+  for (size_t i = 0; i < 4; ++i) {
+    memcpy(state[i], temp_state[i], 4);
+  }
+}
+
+void AES::InvShiftRows(unsigned char state[4][Nb]) {
+  ShiftRow(state, 1, Nb - 1);
+  ShiftRow(state, 2, Nb - 2);
+  ShiftRow(state, 3, Nb - 3);
+}
+
+void AES::XorBlocks(const unsigned char *a, const unsigned char *b,
+                    unsigned char *c, unsigned int len) {
+  for (unsigned int i = 0; i < len; i++) {
+    c[i] = a[i] ^ b[i];
+  }
+}
+
+void AES::printHexArray(unsigned char a[], unsigned int n) {
+  for (unsigned int i = 0; i < n; i++) {
+    printf("%02x ", a[i]);
+  }
+}
+
+void AES::printHexVector(std::vector<unsigned char> a) {
+  for (unsigned int i = 0; i < a.size(); i++) {
+    printf("%02x ", a[i]);
+  }
+}
+
+std::vector<unsigned char> AES::ArrayToVector(unsigned char *a,
+                                              unsigned int len) {
+  std::vector<unsigned char> v(a, a + len * sizeof(unsigned char));
+  return v;
+}
+
+unsigned char *AES::VectorToArray(std::vector<unsigned char> &a) {
+  return a.data();
+}
+
+std::vector<unsigned char> AES::EncryptECB(std::vector<unsigned char> in,
+                                           std::vector<unsigned char> key) {
+  unsigned char *out = EncryptECB(VectorToArray(in), (unsigned int)in.size(),
+                                  VectorToArray(key));
+  std::vector<unsigned char> v = ArrayToVector(out, in.size());
+  delete[] out;
+  return v;
+}
+
+std::vector<unsigned char> AES::DecryptECB(std::vector<unsigned char> in,
+                                           std::vector<unsigned char> key) {
+  unsigned char *out = DecryptECB(VectorToArray(in), (unsigned int)in.size(),
+                                  VectorToArray(key));
+  std::vector<unsigned char> v = ArrayToVector(out, (unsigned int)in.size());
+  delete[] out;
+  return v;
+}
+
+std::vector<unsigned char> AES::EncryptCBC(std::vector<unsigned char> in,
+                                           std::vector<unsigned char> key,
+                                           std::vector<unsigned char> iv) {
+  unsigned char *out = EncryptCBC(VectorToArray(in), (unsigned int)in.size(),
+                                  VectorToArray(key), VectorToArray(iv));
+  std::vector<unsigned char> v = ArrayToVector(out, in.size());
+  delete[] out;
+  return v;
+}
+
+std::vector<unsigned char> AES::DecryptCBC(std::vector<unsigned char> in,
+                                           std::vector<unsigned char> key,
+                                           std::vector<unsigned char> iv) {
+  unsigned char *out = DecryptCBC(VectorToArray(in), (unsigned int)in.size(),
+                                  VectorToArray(key), VectorToArray(iv));
+  std::vector<unsigned char> v = ArrayToVector(out, (unsigned int)in.size());
+  delete[] out;
+  return v;
+}
+
+std::vector<unsigned char> AES::EncryptCFB(std::vector<unsigned char> in,
+                                           std::vector<unsigned char> key,
+                                           std::vector<unsigned char> iv) {
+  unsigned char *out = EncryptCFB(VectorToArray(in), (unsigned int)in.size(),
+                                  VectorToArray(key), VectorToArray(iv));
+  std::vector<unsigned char> v = ArrayToVector(out, in.size());
+  delete[] out;
+  return v;
+}
+
+std::vector<unsigned char> AES::DecryptCFB(std::vector<unsigned char> in,
+                                           std::vector<unsigned char> key,
+                                           std::vector<unsigned char> iv) {
+  unsigned char *out = DecryptCFB(VectorToArray(in), (unsigned int)in.size(),
+                                  VectorToArray(key), VectorToArray(iv));
+  std::vector<unsigned char> v = ArrayToVector(out, (unsigned int)in.size());
+  delete[] out;
+  return v;
+}

misc/AES.h

@@ -0,0 +1,348 @@
+#ifndef _AES_H_
+#define _AES_H_
+
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+enum class AESKeyLength { AES_128, AES_192, AES_256 };
+
+class AES {
+ private:
+  static constexpr unsigned int Nb = 4;
+  static constexpr unsigned int blockBytesLen = 4 * Nb * sizeof(unsigned char);
+
+  unsigned int Nk;
+  unsigned int Nr;
+
+  void SubBytes(unsigned char state[4][Nb]);
+
+  void ShiftRow(unsigned char state[4][Nb], unsigned int i,
+                unsigned int n);  // shift row i on n write_positions
+
+  void ShiftRows(unsigned char state[4][Nb]);
+
+  unsigned char xtime(unsigned char b);  // multiply on x
+
+  void MixColumns(unsigned char state[4][Nb]);
+
+  void AddRoundKey(unsigned char state[4][Nb], unsigned char *key);
+
+  void SubWord(unsigned char *a);
+
+  void RotWord(unsigned char *a);
+
+  void XorWords(unsigned char *a, unsigned char *b, unsigned char *c);
+
+  void Rcon(unsigned char *a, unsigned int n);
+
+  void InvSubBytes(unsigned char state[4][Nb]);
+
+  void InvMixColumns(unsigned char state[4][Nb]);
+
+  void InvShiftRows(unsigned char state[4][Nb]);
+
+  void CheckLength(unsigned int len);
+
+  void KeyExpansion(const unsigned char key[], unsigned char w[]);
+
+  void EncryptBlock(const unsigned char in[], unsigned char out[],
+                    unsigned char *roundKeys);
+
+  void DecryptBlock(const unsigned char in[], unsigned char out[],
+                    unsigned char *roundKeys);
+
+  void XorBlocks(const unsigned char *a, const unsigned char *b,
+                 unsigned char *c, unsigned int len);
+
+  std::vector<unsigned char> ArrayToVector(unsigned char *a, unsigned int len);
+
+  unsigned char *VectorToArray(std::vector<unsigned char> &a);
+
+ public:
+  explicit AES(const AESKeyLength keyLength = AESKeyLength::AES_256);
+
+  unsigned char *EncryptECB(const unsigned char in[], unsigned int inLen,
+                            const unsigned char key[]);
+
+  unsigned char *DecryptECB(const unsigned char in[], unsigned int inLen,
+                            const unsigned char key[]);
+
+  unsigned char *EncryptCBC(const unsigned char in[], unsigned int inLen,
+                            const unsigned char key[], const unsigned char *iv);
+
+  unsigned char *DecryptCBC(const unsigned char in[], unsigned int inLen,
+                            const unsigned char key[], const unsigned char *iv);
+
+  unsigned char *EncryptCFB(const unsigned char in[], unsigned int inLen,
+                            const unsigned char key[], const unsigned char *iv);
+
+  unsigned char *DecryptCFB(const unsigned char in[], unsigned int inLen,
+                            const unsigned char key[], const unsigned char *iv);
+
+  std::vector<unsigned char> EncryptECB(std::vector<unsigned char> in,
+                                        std::vector<unsigned char> key);
+
+  std::vector<unsigned char> DecryptECB(std::vector<unsigned char> in,
+                                        std::vector<unsigned char> key);
+
+  std::vector<unsigned char> EncryptCBC(std::vector<unsigned char> in,
+                                        std::vector<unsigned char> key,
+                                        std::vector<unsigned char> iv);
+
+  std::vector<unsigned char> DecryptCBC(std::vector<unsigned char> in,
+                                        std::vector<unsigned char> key,
+                                        std::vector<unsigned char> iv);
+
+  std::vector<unsigned char> EncryptCFB(std::vector<unsigned char> in,
+                                        std::vector<unsigned char> key,
+                                        std::vector<unsigned char> iv);
+
+  std::vector<unsigned char> DecryptCFB(std::vector<unsigned char> in,
+                                        std::vector<unsigned char> key,
+                                        std::vector<unsigned char> iv);
+
+  void printHexArray(unsigned char a[], unsigned int n);
+
+  void printHexVector(std::vector<unsigned char> a);
+};
+
+const unsigned char sbox[16][16] = {
+    {0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b,
+     0xfe, 0xd7, 0xab, 0x76},
+    {0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf,
+     0x9c, 0xa4, 0x72, 0xc0},
+    {0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1,
+     0x71, 0xd8, 0x31, 0x15},
+    {0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2,
+     0xeb, 0x27, 0xb2, 0x75},
+    {0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3,
+     0x29, 0xe3, 0x2f, 0x84},
+    {0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39,
+     0x4a, 0x4c, 0x58, 0xcf},
+    {0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f,
+     0x50, 0x3c, 0x9f, 0xa8},
+    {0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21,
+     0x10, 0xff, 0xf3, 0xd2},
+    {0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d,
+     0x64, 0x5d, 0x19, 0x73},
+    {0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14,
+     0xde, 0x5e, 0x0b, 0xdb},
+    {0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62,
+     0x91, 0x95, 0xe4, 0x79},
+    {0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea,
+     0x65, 0x7a, 0xae, 0x08},
+    {0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f,
+     0x4b, 0xbd, 0x8b, 0x8a},
+    {0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9,
+     0x86, 0xc1, 0x1d, 0x9e},
+    {0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9,
+     0xce, 0x55, 0x28, 0xdf},
+    {0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f,
+     0xb0, 0x54, 0xbb, 0x16}};
+
+const unsigned char inv_sbox[16][16] = {
+    {0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e,
+     0x81, 0xf3, 0xd7, 0xfb},
+    {0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44,
+     0xc4, 0xde, 0xe9, 0xcb},
+    {0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b,
+     0x42, 0xfa, 0xc3, 0x4e},
+    {0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49,
+     0x6d, 0x8b, 0xd1, 0x25},
+    {0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc,
+     0x5d, 0x65, 0xb6, 0x92},
+    {0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57,
+     0xa7, 0x8d, 0x9d, 0x84},
+    {0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05,
+     0xb8, 0xb3, 0x45, 0x06},
+    {0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03,
+     0x01, 0x13, 0x8a, 0x6b},
+    {0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce,
+     0xf0, 0xb4, 0xe6, 0x73},
+    {0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8,
+     0x1c, 0x75, 0xdf, 0x6e},
+    {0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e,
+     0xaa, 0x18, 0xbe, 0x1b},
+    {0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe,
+     0x78, 0xcd, 0x5a, 0xf4},
+    {0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59,
+     0x27, 0x80, 0xec, 0x5f},
+    {0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f,
+     0x93, 0xc9, 0x9c, 0xef},
+    {0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c,
+     0x83, 0x53, 0x99, 0x61},
+    {0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63,
+     0x55, 0x21, 0x0c, 0x7d}};
+
+/// Galois Multiplication lookup tables
+static const unsigned char GF_MUL_TABLE[15][256] = {
+    {},
+    {},
+
+    // mul 2
+    {0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14, 0x16,
+     0x18, 0x1a, 0x1c, 0x1e, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e,
+     0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x46,
+     0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e,
+     0x60, 0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c, 0x6e, 0x70, 0x72, 0x74, 0x76,
+     0x78, 0x7a, 0x7c, 0x7e, 0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e,
+     0x90, 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9c, 0x9e, 0xa0, 0xa2, 0xa4, 0xa6,
+     0xa8, 0xaa, 0xac, 0xae, 0xb0, 0xb2, 0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe,
+     0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce, 0xd0, 0xd2, 0xd4, 0xd6,
+     0xd8, 0xda, 0xdc, 0xde, 0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee,
+     0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe, 0x1b, 0x19, 0x1f, 0x1d,
+     0x13, 0x11, 0x17, 0x15, 0x0b, 0x09, 0x0f, 0x0d, 0x03, 0x01, 0x07, 0x05,
+     0x3b, 0x39, 0x3f, 0x3d, 0x33, 0x31, 0x37, 0x35, 0x2b, 0x29, 0x2f, 0x2d,
+     0x23, 0x21, 0x27, 0x25, 0x5b, 0x59, 0x5f, 0x5d, 0x53, 0x51, 0x57, 0x55,
+     0x4b, 0x49, 0x4f, 0x4d, 0x43, 0x41, 0x47, 0x45, 0x7b, 0x79, 0x7f, 0x7d,
+     0x73, 0x71, 0x77, 0x75, 0x6b, 0x69, 0x6f, 0x6d, 0x63, 0x61, 0x67, 0x65,
+     0x9b, 0x99, 0x9f, 0x9d, 0x93, 0x91, 0x97, 0x95, 0x8b, 0x89, 0x8f, 0x8d,
+     0x83, 0x81, 0x87, 0x85, 0xbb, 0xb9, 0xbf, 0xbd, 0xb3, 0xb1, 0xb7, 0xb5,
+     0xab, 0xa9, 0xaf, 0xad, 0xa3, 0xa1, 0xa7, 0xa5, 0xdb, 0xd9, 0xdf, 0xdd,
+     0xd3, 0xd1, 0xd7, 0xd5, 0xcb, 0xc9, 0xcf, 0xcd, 0xc3, 0xc1, 0xc7, 0xc5,
+     0xfb, 0xf9, 0xff, 0xfd, 0xf3, 0xf1, 0xf7, 0xf5, 0xeb, 0xe9, 0xef, 0xed,
+     0xe3, 0xe1, 0xe7, 0xe5},
+
+    // mul 3
+    {0x00, 0x03, 0x06, 0x05, 0x0c, 0x0f, 0x0a, 0x09, 0x18, 0x1b, 0x1e, 0x1d,
+     0x14, 0x17, 0x12, 0x11, 0x30, 0x33, 0x36, 0x35, 0x3c, 0x3f, 0x3a, 0x39,
+     0x28, 0x2b, 0x2e, 0x2d, 0x24, 0x27, 0x22, 0x21, 0x60, 0x63, 0x66, 0x65,
+     0x6c, 0x6f, 0x6a, 0x69, 0x78, 0x7b, 0x7e, 0x7d, 0x74, 0x77, 0x72, 0x71,
+     0x50, 0x53, 0x56, 0x55, 0x5c, 0x5f, 0x5a, 0x59, 0x48, 0x4b, 0x4e, 0x4d,
+     0x44, 0x47, 0x42, 0x41, 0xc0, 0xc3, 0xc6, 0xc5, 0xcc, 0xcf, 0xca, 0xc9,
+     0xd8, 0xdb, 0xde, 0xdd, 0xd4, 0xd7, 0xd2, 0xd1, 0xf0, 0xf3, 0xf6, 0xf5,
+     0xfc, 0xff, 0xfa, 0xf9, 0xe8, 0xeb, 0xee, 0xed, 0xe4, 0xe7, 0xe2, 0xe1,
+     0xa0, 0xa3, 0xa6, 0xa5, 0xac, 0xaf, 0xaa, 0xa9, 0xb8, 0xbb, 0xbe, 0xbd,
+     0xb4, 0xb7, 0xb2, 0xb1, 0x90, 0x93, 0x96, 0x95, 0x9c, 0x9f, 0x9a, 0x99,
+     0x88, 0x8b, 0x8e, 0x8d, 0x84, 0x87, 0x82, 0x81, 0x9b, 0x98, 0x9d, 0x9e,
+     0x97, 0x94, 0x91, 0x92, 0x83, 0x80, 0x85, 0x86, 0x8f, 0x8c, 0x89, 0x8a,
+     0xab, 0xa8, 0xad, 0xae, 0xa7, 0xa4, 0xa1, 0xa2, 0xb3, 0xb0, 0xb5, 0xb6,
+     0xbf, 0xbc, 0xb9, 0xba, 0xfb, 0xf8, 0xfd, 0xfe, 0xf7, 0xf4, 0xf1, 0xf2,
+     0xe3, 0xe0, 0xe5, 0xe6, 0xef, 0xec, 0xe9, 0xea, 0xcb, 0xc8, 0xcd, 0xce,
+     0xc7, 0xc4, 0xc1, 0xc2, 0xd3, 0xd0, 0xd5, 0xd6, 0xdf, 0xdc, 0xd9, 0xda,
+     0x5b, 0x58, 0x5d, 0x5e, 0x57, 0x54, 0x51, 0x52, 0x43, 0x40, 0x45, 0x46,
+     0x4f, 0x4c, 0x49, 0x4a, 0x6b, 0x68, 0x6d, 0x6e, 0x67, 0x64, 0x61, 0x62,
+     0x73, 0x70, 0x75, 0x76, 0x7f, 0x7c, 0x79, 0x7a, 0x3b, 0x38, 0x3d, 0x3e,
+     0x37, 0x34, 0x31, 0x32, 0x23, 0x20, 0x25, 0x26, 0x2f, 0x2c, 0x29, 0x2a,
+     0x0b, 0x08, 0x0d, 0x0e, 0x07, 0x04, 0x01, 0x02, 0x13, 0x10, 0x15, 0x16,
+     0x1f, 0x1c, 0x19, 0x1a},
+
+    {},
+    {},
+    {},
+    {},
+    {},
+
+    // mul 9
+    {0x00, 0x09, 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f, 0x48, 0x41, 0x5a, 0x53,
+     0x6c, 0x65, 0x7e, 0x77, 0x90, 0x99, 0x82, 0x8b, 0xb4, 0xbd, 0xa6, 0xaf,
+     0xd8, 0xd1, 0xca, 0xc3, 0xfc, 0xf5, 0xee, 0xe7, 0x3b, 0x32, 0x29, 0x20,
+     0x1f, 0x16, 0x0d, 0x04, 0x73, 0x7a, 0x61, 0x68, 0x57, 0x5e, 0x45, 0x4c,
+     0xab, 0xa2, 0xb9, 0xb0, 0x8f, 0x86, 0x9d, 0x94, 0xe3, 0xea, 0xf1, 0xf8,
+     0xc7, 0xce, 0xd5, 0xdc, 0x76, 0x7f, 0x64, 0x6d, 0x52, 0x5b, 0x40, 0x49,
+     0x3e, 0x37, 0x2c, 0x25, 0x1a, 0x13, 0x08, 0x01, 0xe6, 0xef, 0xf4, 0xfd,
+     0xc2, 0xcb, 0xd0, 0xd9, 0xae, 0xa7, 0xbc, 0xb5, 0x8a, 0x83, 0x98, 0x91,
+     0x4d, 0x44, 0x5f, 0x56, 0x69, 0x60, 0x7b, 0x72, 0x05, 0x0c, 0x17, 0x1e,
+     0x21, 0x28, 0x33, 0x3a, 0xdd, 0xd4, 0xcf, 0xc6, 0xf9, 0xf0, 0xeb, 0xe2,
+     0x95, 0x9c, 0x87, 0x8e, 0xb1, 0xb8, 0xa3, 0xaa, 0xec, 0xe5, 0xfe, 0xf7,
+     0xc8, 0xc1, 0xda, 0xd3, 0xa4, 0xad, 0xb6, 0xbf, 0x80, 0x89, 0x92, 0x9b,
+     0x7c, 0x75, 0x6e, 0x67, 0x58, 0x51, 0x4a, 0x43, 0x34, 0x3d, 0x26, 0x2f,
+     0x10, 0x19, 0x02, 0x0b, 0xd7, 0xde, 0xc5, 0xcc, 0xf3, 0xfa, 0xe1, 0xe8,
+     0x9f, 0x96, 0x8d, 0x84, 0xbb, 0xb2, 0xa9, 0xa0, 0x47, 0x4e, 0x55, 0x5c,
+     0x63, 0x6a, 0x71, 0x78, 0x0f, 0x06, 0x1d, 0x14, 0x2b, 0x22, 0x39, 0x30,
+     0x9a, 0x93, 0x88, 0x81, 0xbe, 0xb7, 0xac, 0xa5, 0xd2, 0xdb, 0xc0, 0xc9,
+     0xf6, 0xff, 0xe4, 0xed, 0x0a, 0x03, 0x18, 0x11, 0x2e, 0x27, 0x3c, 0x35,
+     0x42, 0x4b, 0x50, 0x59, 0x66, 0x6f, 0x74, 0x7d, 0xa1, 0xa8, 0xb3, 0xba,
+     0x85, 0x8c, 0x97, 0x9e, 0xe9, 0xe0, 0xfb, 0xf2, 0xcd, 0xc4, 0xdf, 0xd6,
+     0x31, 0x38, 0x23, 0x2a, 0x15, 0x1c, 0x07, 0x0e, 0x79, 0x70, 0x6b, 0x62,
+     0x5d, 0x54, 0x4f, 0x46},
+
+    {},
+
+    // mul 11
+    {0x00, 0x0b, 0x16, 0x1d, 0x2c, 0x27, 0x3a, 0x31, 0x58, 0x53, 0x4e, 0x45,
+     0x74, 0x7f, 0x62, 0x69, 0xb0, 0xbb, 0xa6, 0xad, 0x9c, 0x97, 0x8a, 0x81,
+     0xe8, 0xe3, 0xfe, 0xf5, 0xc4, 0xcf, 0xd2, 0xd9, 0x7b, 0x70, 0x6d, 0x66,
+     0x57, 0x5c, 0x41, 0x4a, 0x23, 0x28, 0x35, 0x3e, 0x0f, 0x04, 0x19, 0x12,
+     0xcb, 0xc0, 0xdd, 0xd6, 0xe7, 0xec, 0xf1, 0xfa, 0x93, 0x98, 0x85, 0x8e,
+     0xbf, 0xb4, 0xa9, 0xa2, 0xf6, 0xfd, 0xe0, 0xeb, 0xda, 0xd1, 0xcc, 0xc7,
+     0xae, 0xa5, 0xb8, 0xb3, 0x82, 0x89, 0x94, 0x9f, 0x46, 0x4d, 0x50, 0x5b,
+     0x6a, 0x61, 0x7c, 0x77, 0x1e, 0x15, 0x08, 0x03, 0x32, 0x39, 0x24, 0x2f,
+     0x8d, 0x86, 0x9b, 0x90, 0xa1, 0xaa, 0xb7, 0xbc, 0xd5, 0xde, 0xc3, 0xc8,
+     0xf9, 0xf2, 0xef, 0xe4, 0x3d, 0x36, 0x2b, 0x20, 0x11, 0x1a, 0x07, 0x0c,
+     0x65, 0x6e, 0x73, 0x78, 0x49, 0x42, 0x5f, 0x54, 0xf7, 0xfc, 0xe1, 0xea,
+     0xdb, 0xd0, 0xcd, 0xc6, 0xaf, 0xa4, 0xb9, 0xb2, 0x83, 0x88, 0x95, 0x9e,
+     0x47, 0x4c, 0x51, 0x5a, 0x6b, 0x60, 0x7d, 0x76, 0x1f, 0x14, 0x09, 0x02,
+     0x33, 0x38, 0x25, 0x2e, 0x8c, 0x87, 0x9a, 0x91, 0xa0, 0xab, 0xb6, 0xbd,
+     0xd4, 0xdf, 0xc2, 0xc9, 0xf8, 0xf3, 0xee, 0xe5, 0x3c, 0x37, 0x2a, 0x21,
+     0x10, 0x1b, 0x06, 0x0d, 0x64, 0x6f, 0x72, 0x79, 0x48, 0x43, 0x5e, 0x55,
+     0x01, 0x0a, 0x17, 0x1c, 0x2d, 0x26, 0x3b, 0x30, 0x59, 0x52, 0x4f, 0x44,
+     0x75, 0x7e, 0x63, 0x68, 0xb1, 0xba, 0xa7, 0xac, 0x9d, 0x96, 0x8b, 0x80,
+     0xe9, 0xe2, 0xff, 0xf4, 0xc5, 0xce, 0xd3, 0xd8, 0x7a, 0x71, 0x6c, 0x67,
+     0x56, 0x5d, 0x40, 0x4b, 0x22, 0x29, 0x34, 0x3f, 0x0e, 0x05, 0x18, 0x13,
+     0xca, 0xc1, 0xdc, 0xd7, 0xe6, 0xed, 0xf0, 0xfb, 0x92, 0x99, 0x84, 0x8f,
+     0xbe, 0xb5, 0xa8, 0xa3},
+
+    {},
+
+    // mul 13
+    {0x00, 0x0d, 0x1a, 0x17, 0x34, 0x39, 0x2e, 0x23, 0x68, 0x65, 0x72, 0x7f,
+     0x5c, 0x51, 0x46, 0x4b, 0xd0, 0xdd, 0xca, 0xc7, 0xe4, 0xe9, 0xfe, 0xf3,
+     0xb8, 0xb5, 0xa2, 0xaf, 0x8c, 0x81, 0x96, 0x9b, 0xbb, 0xb6, 0xa1, 0xac,
+     0x8f, 0x82, 0x95, 0x98, 0xd3, 0xde, 0xc9, 0xc4, 0xe7, 0xea, 0xfd, 0xf0,
+     0x6b, 0x66, 0x71, 0x7c, 0x5f, 0x52, 0x45, 0x48, 0x03, 0x0e, 0x19, 0x14,
+     0x37, 0x3a, 0x2d, 0x20, 0x6d, 0x60, 0x77, 0x7a, 0x59, 0x54, 0x43, 0x4e,
+     0x05, 0x08, 0x1f, 0x12, 0x31, 0x3c, 0x2b, 0x26, 0xbd, 0xb0, 0xa7, 0xaa,
+     0x89, 0x84, 0x93, 0x9e, 0xd5, 0xd8, 0xcf, 0xc2, 0xe1, 0xec, 0xfb, 0xf6,
+     0xd6, 0xdb, 0xcc, 0xc1, 0xe2, 0xef, 0xf8, 0xf5, 0xbe, 0xb3, 0xa4, 0xa9,
+     0x8a, 0x87, 0x90, 0x9d, 0x06, 0x0b, 0x1c, 0x11, 0x32, 0x3f, 0x28, 0x25,
+     0x6e, 0x63, 0x74, 0x79, 0x5a, 0x57, 0x40, 0x4d, 0xda, 0xd7, 0xc0, 0xcd,
+     0xee, 0xe3, 0xf4, 0xf9, 0xb2, 0xbf, 0xa8, 0xa5, 0x86, 0x8b, 0x9c, 0x91,
+     0x0a, 0x07, 0x10, 0x1d, 0x3e, 0x33, 0x24, 0x29, 0x62, 0x6f, 0x78, 0x75,
+     0x56, 0x5b, 0x4c, 0x41, 0x61, 0x6c, 0x7b, 0x76, 0x55, 0x58, 0x4f, 0x42,
+     0x09, 0x04, 0x13, 0x1e, 0x3d, 0x30, 0x27, 0x2a, 0xb1, 0xbc, 0xab, 0xa6,
+     0x85, 0x88, 0x9f, 0x92, 0xd9, 0xd4, 0xc3, 0xce, 0xed, 0xe0, 0xf7, 0xfa,
+     0xb7, 0xba, 0xad, 0xa0, 0x83, 0x8e, 0x99, 0x94, 0xdf, 0xd2, 0xc5, 0xc8,
+     0xeb, 0xe6, 0xf1, 0xfc, 0x67, 0x6a, 0x7d, 0x70, 0x53, 0x5e, 0x49, 0x44,
+     0x0f, 0x02, 0x15, 0x18, 0x3b, 0x36, 0x21, 0x2c, 0x0c, 0x01, 0x16, 0x1b,
+     0x38, 0x35, 0x22, 0x2f, 0x64, 0x69, 0x7e, 0x73, 0x50, 0x5d, 0x4a, 0x47,
+     0xdc, 0xd1, 0xc6, 0xcb, 0xe8, 0xe5, 0xf2, 0xff, 0xb4, 0xb9, 0xae, 0xa3,
+     0x80, 0x8d, 0x9a, 0x97},
+
+    // mul 14
+    {0x00, 0x0e, 0x1c, 0x12, 0x38, 0x36, 0x24, 0x2a, 0x70, 0x7e, 0x6c, 0x62,
+     0x48, 0x46, 0x54, 0x5a, 0xe0, 0xee, 0xfc, 0xf2, 0xd8, 0xd6, 0xc4, 0xca,
+     0x90, 0x9e, 0x8c, 0x82, 0xa8, 0xa6, 0xb4, 0xba, 0xdb, 0xd5, 0xc7, 0xc9,
+     0xe3, 0xed, 0xff, 0xf1, 0xab, 0xa5, 0xb7, 0xb9, 0x93, 0x9d, 0x8f, 0x81,
+     0x3b, 0x35, 0x27, 0x29, 0x03, 0x0d, 0x1f, 0x11, 0x4b, 0x45, 0x57, 0x59,
+     0x73, 0x7d, 0x6f, 0x61, 0xad, 0xa3, 0xb1, 0xbf, 0x95, 0x9b, 0x89, 0x87,
+     0xdd, 0xd3, 0xc1, 0xcf, 0xe5, 0xeb, 0xf9, 0xf7, 0x4d, 0x43, 0x51, 0x5f,
+     0x75, 0x7b, 0x69, 0x67, 0x3d, 0x33, 0x21, 0x2f, 0x05, 0x0b, 0x19, 0x17,
+     0x76, 0x78, 0x6a, 0x64, 0x4e, 0x40, 0x52, 0x5c, 0x06, 0x08, 0x1a, 0x14,
+     0x3e, 0x30, 0x22, 0x2c, 0x96, 0x98, 0x8a, 0x84, 0xae, 0xa0, 0xb2, 0xbc,
+     0xe6, 0xe8, 0xfa, 0xf4, 0xde, 0xd0, 0xc2, 0xcc, 0x41, 0x4f, 0x5d, 0x53,
+     0x79, 0x77, 0x65, 0x6b, 0x31, 0x3f, 0x2d, 0x23, 0x09, 0x07, 0x15, 0x1b,
+     0xa1, 0xaf, 0xbd, 0xb3, 0x99, 0x97, 0x85, 0x8b, 0xd1, 0xdf, 0xcd, 0xc3,
+     0xe9, 0xe7, 0xf5, 0xfb, 0x9a, 0x94, 0x86, 0x88, 0xa2, 0xac, 0xbe, 0xb0,
+     0xea, 0xe4, 0xf6, 0xf8, 0xd2, 0xdc, 0xce, 0xc0, 0x7a, 0x74, 0x66, 0x68,
+     0x42, 0x4c, 0x5e, 0x50, 0x0a, 0x04, 0x16, 0x18, 0x32, 0x3c, 0x2e, 0x20,
+     0xec, 0xe2, 0xf0, 0xfe, 0xd4, 0xda, 0xc8, 0xc6, 0x9c, 0x92, 0x80, 0x8e,
+     0xa4, 0xaa, 0xb8, 0xb6, 0x0c, 0x02, 0x10, 0x1e, 0x34, 0x3a, 0x28, 0x26,
+     0x7c, 0x72, 0x60, 0x6e, 0x44, 0x4a, 0x58, 0x56, 0x37, 0x39, 0x2b, 0x25,
+     0x0f, 0x01, 0x13, 0x1d, 0x47, 0x49, 0x5b, 0x55, 0x7f, 0x71, 0x63, 0x6d,
+     0xd7, 0xd9, 0xcb, 0xc5, 0xef, 0xe1, 0xf3, 0xfd, 0xa7, 0xa9, 0xbb, 0xb5,
+     0x9f, 0x91, 0x83, 0x8d}};
+
+/// circulant MDS matrix
+static const unsigned char CMDS[4][4] = {
+    {2, 3, 1, 1}, {1, 2, 3, 1}, {1, 1, 2, 3}, {3, 1, 1, 2}};
+
+/// Inverse circulant MDS matrix
+static const unsigned char INV_CMDS[4][4] = {
+    {14, 11, 13, 9}, {9, 14, 11, 13}, {13, 9, 14, 11}, {11, 13, 9, 14}};
+
+#endif

misc/ByteStream.cpp

@@ -0,0 +1,265 @@
+
+#include "ByteStream.h"
+
+
+ByteStream::ByteStream( const std::vector< uint8_t > &data )
+{
+	this->data = data;
+	this->write_position = 0;
+}
+
+ByteStream::ByteStream( const std::string &data )
+{
+	this->data = std::vector< uint8_t >( data.begin(), data.end() );
+	this->write_position = 0;
+}
+
+ByteStream::ByteStream( const uint8_t *data, size_t length )
+{
+	this->data = std::vector< uint8_t >( data, data + length );
+	this->write_position = 0;
+}
+
+ByteStream::ByteStream( size_t length )
+{
+	this->data = std::vector< uint8_t >( length, 0 );
+	this->write_position = 0;
+}
+
+ByteStream::ByteStream()
+{
+	this->write_position = 0;
+}
+
+ByteStream::~ByteStream()
+{
+}
+
+void ByteStream::resize( size_t size )
+{
+	data.resize( size );
+}
+
+void ByteStream::shrink_to_fit()
+{
+	data.shrink_to_fit();
+}
+
+template < typename T >
+void ByteStream::write( T value )
+{
+	write_bytes( ( uint8_t * )&value, sizeof( T ) );
+}
+
+template < typename T >
+T ByteStream::read()
+{
+	T value = *( T * )&data[ write_position ];
+	write_position += sizeof( T );
+
+	return value;
+}
+
+void ByteStream::write_utf8( const std::string &value )
+{
+	write_bytes( std::vector< uint8_t >( value.begin(), value.end() ) );
+}
+
+void ByteStream::write_utf16( const std::wstring &value )
+{
+	std::vector< uint8_t > utf16;
+	for( auto c : value )
+	{
+		utf16.push_back( c & 0xFF );
+		utf16.push_back( ( c >> 8 ) & 0xFF );
+	}
+
+	write_bytes( utf16 );
+}
+
+void ByteStream::write_sz_utf8( const std::string &value )
+{
+	write_utf8( value );
+	write< uint8_t >( 0 );
+}
+
+void ByteStream::write_sz_utf16( const std::wstring &value )
+{
+	write_utf16( value );
+	write<uint16_t>( 0 );
+}
+
+uint8_t ByteStream::read_u8()
+{
+	return read< uint8_t >();
+}
+
+uint16_t ByteStream::read_u16()
+{
+	return read< uint16_t >();
+}
+
+uint32_t ByteStream::read_u32()
+{
+	return read< uint32_t >();
+}
+
+int8_t ByteStream::read_i8()
+{
+	return read< int8_t >();
+}
+
+int16_t ByteStream::read_i16()
+{
+	return read< int16_t >();
+}
+
+int32_t ByteStream::read_i32()
+{
+	return read< int32_t >();
+}
+
+float_t ByteStream::read_f32()
+{
+	return read< float_t >();
+}
+
+std::string ByteStream::read_utf8()
+{
+	uint32_t length = read_u32();
+	std::string value;
+	for( size_t i = 0; i < length; i++ )
+	{
+		value.push_back( data[ write_position + i ] );
+	}
+
+	write_position += length;
+
+	return value;
+}
+
+std::wstring ByteStream::read_utf16()
+{
+	std::wstring value;
+	uint32_t length = read_u32() * 2;
+
+	for( size_t i = 0; i < length; i += 2 )
+	{
+		value.push_back( data[ write_position + i ] | ( data[ write_position + i + 1 ] << 8 ) );
+	}
+
+	write_position += length;
+
+	return value;
+}
+
+std::string ByteStream::read_sz_utf8()
+{
+	std::string value;
+	while( data[ write_position ] != 0 )
+	{
+		value.push_back( data[ write_position ] );
+		write_position++;
+	}
+
+	write_position++;
+
+	return value;
+}
+
+std::wstring ByteStream::read_sz_utf16()
+{
+	std::wstring value;
+	while( data[ write_position ] != 0 || data[ write_position + 1 ] != 0 )
+	{
+		value.push_back( data[ write_position ] | ( data[ write_position + 1 ] << 8 ) );
+		write_position += 2;
+	}
+
+	write_position += 2;
+
+	return value;
+}
+
+void ByteStream::write_bytes( const std::vector< uint8_t > &value )
+{
+	std::copy( value.begin(), value.end(), std::back_inserter( data ) );
+	write_position += value.size();
+}
+
+void ByteStream::write_bytes( const uint8_t *value, size_t length )
+{
+	std::copy( value, value + length, std::back_inserter( data ) );
+	write_position += length;
+}
+
+std::vector<uint8_t> ByteStream::read_bytes( size_t length )
+{
+	std::vector<uint8_t> value( length, 0 );
+
+	std::copy( data.begin() + write_position, data.begin() + write_position + length, value.begin() );
+
+	write_position += length;
+
+	return value;
+}
+
+std::vector<uint8_t> ByteStream::get_data() const
+{
+	return data;
+}
+
+size_t ByteStream::get_length() const
+{
+	return data.size();
+}
+
+void ByteStream::set_write_position( size_t write_position )
+{
+	if( write_position > data.size() )
+	{
+		write_position = data.size();
+	}
+
+	this->write_position = write_position;
+}
+
+size_t ByteStream::get_write_position() const
+{
+	return this->write_position;
+}
+
+void ByteStream::write_u8( uint8_t value )
+{
+	write< uint8_t >( value );
+}
+
+void ByteStream::write_u16( uint16_t value )
+{
+	write< uint16_t >( value );
+}
+
+void ByteStream::write_u32( uint32_t value )
+{
+	write< uint32_t >( value );
+}
+
+void ByteStream::write_i8( int8_t value )
+{
+	write< int8_t >( value );
+}
+
+void ByteStream::write_i16( int16_t value )
+{
+	write< int16_t >( value );
+}
+
+void ByteStream::write_i32( int32_t value )
+{
+	write< int32_t >( value );
+}
+
+void ByteStream::write_f32( float_t value )
+{
+	write< float_t >( value );
+}

misc/ByteStream.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <vector>
+#include <string>
+#include <memory>
+#include <iterator>
+
+class ByteStream
+{
+public:
+	ByteStream( const std::vector< uint8_t > &data );
+	ByteStream( const std::string &data );
+	ByteStream( const uint8_t *data, size_t length );
+	ByteStream( size_t length );
+	ByteStream();
+
+	~ByteStream();
+
+	void resize( size_t size );
+	void shrink_to_fit();
+
+	template < typename T >
+	void write( T value );
+
+	template < typename T >
+	T read();
+
+	void write_u8( uint8_t value );
+	void write_u16( uint16_t value );
+	void write_u32( uint32_t value );
+	void write_i8( int8_t value );
+	void write_i16( int16_t value );
+	void write_i32( int32_t value );
+	void write_f32( float_t value );
+
+	void write_utf8( const std::string &value );
+	void write_utf16( const std::wstring &value );
+	void write_sz_utf8( const std::string &value );
+	void write_sz_utf16( const std::wstring &value );
+
+	uint8_t read_u8();
+	uint16_t read_u16();
+	uint32_t read_u32();
+	int8_t read_i8();
+	int16_t read_i16();
+	int32_t read_i32();
+	float_t read_f32();
+
+	std::string read_utf8();
+	std::wstring read_utf16();
+	std::string read_sz_utf8();
+	std::wstring read_sz_utf16();
+
+	void write_bytes( const std::vector< uint8_t > &value );
+	void write_bytes( const uint8_t *value, size_t length );
+
+	std::vector< uint8_t > read_bytes( size_t length );
+	std::vector< uint8_t > get_data() const;
+
+	size_t get_length() const;
+
+	void set_write_position( size_t write_position );
+	size_t get_write_position() const;
+
+	std::vector< uint8_t > data;
+	size_t write_position;
+};

misc/Encryptor.cpp

@@ -0,0 +1,153 @@
+#include "Encryptor.h"
+#include <ctime>
+#include <array>
+
+#include "AES.h"
+
+bool Encryptor::ms_initialized = false;
+
+Encryptor::Encryptor()
+{
+	// Initialize the private key
+	m_privateKey = ""; // Default initialization
+
+	// Initialize basic_str_b
+	basic_str_b = "";
+
+	// Initialize the symmetric key
+	m_symmetricKey.assign( default_sym_key );
+
+	// Static initialization logic
+	if( !ms_initialized )
+	{
+		ms_initialized = true;
+		std::srand( static_cast< unsigned >( std::time( nullptr ) ) );
+		Encryptor::test();
+	}
+}
+
+std::string Encryptor::generateSymmetricKey( void )
+{
+	constexpr size_t KEY_LENGTH = 32;
+
+	std::array<unsigned char, KEY_LENGTH> keyData{ 0 };
+
+	// Generate 32 random bytes
+	for( size_t i = 0; i < KEY_LENGTH; ++i )
+	{
+		keyData[ i ] = static_cast< unsigned char >( rand() % 255 );
+	}
+	
+	// Replace the symmetric key with the generated key
+	m_symmetricKey.assign( reinterpret_cast< char * >( keyData.data() ), KEY_LENGTH );
+
+	return m_symmetricKey;
+}
+
+std::string Encryptor::generatePrivateSymKey( void )
+{
+	constexpr size_t KEY_LENGTH = 32;
+
+	std::array<unsigned char, KEY_LENGTH> keyData{ 0 };
+
+	// Generate 32 random bytes
+	for( size_t i = 0; i < KEY_LENGTH; ++i )
+	{
+		keyData[ i ] = static_cast< unsigned char >( rand() % 255 );
+	}
+
+	// Replace the symmetric key with the generated key
+	m_privateKey.assign( reinterpret_cast< char * >( keyData.data() ), KEY_LENGTH );
+
+	// Print the private key as bytes
+	printf( "Private Sym Key: " );
+	for( auto c : m_privateKey )
+	{
+		printf( "%02X", (uint8_t)c );
+	}
+	printf( "\n" );
+
+	// Encrypt the private key
+	AES aes( AESKeyLength::AES_128 );
+
+	auto c = aes.EncryptECB(
+		reinterpret_cast< const uint8_t * >( m_privateKey.c_str() ),
+		m_privateKey.size(),
+		reinterpret_cast< const uint8_t * >( default_public_key.c_str() ) );
+
+	m_encryptedPrivateKey = std::string( reinterpret_cast< const char * >( c ), m_privateKey.size() );
+
+	// Print the encrypted key as bytes
+	printf( "Encrypted Sym Key: " );
+	for( auto c : m_encryptedPrivateKey )
+	{
+		printf( "%02X", ( uint8_t )c );
+	}
+	printf( "\n" );
+
+	return m_encryptedPrivateKey;
+}
+
+std::string Encryptor::encryptSymmetric( const std::string &input )
+{
+	AES aes( AESKeyLength::AES_128 );
+
+	auto result = aes.EncryptECB( reinterpret_cast< const uint8_t * >( input.c_str() ), input.size(), reinterpret_cast< const uint8_t * >( m_privateKey.c_str() ) );
+
+	return std::string( reinterpret_cast< const char * >( result ), input.size() );
+}
+
+std::string Encryptor::decryptSymmetric( const std::string &input )
+{
+	AES aes( AESKeyLength::AES_128 );
+
+	auto result = aes.DecryptECB( reinterpret_cast< const uint8_t * >( input.c_str() ), input.size(), reinterpret_cast< const uint8_t * >( m_privateKey.c_str() ) );
+
+	return std::string( reinterpret_cast< const char * >( result ), input.size() );
+}
+
+void Encryptor::test()
+{
+	/*std::string inputStr = "HelloWorld";        // Input string to encrypt and decrypt
+	std::string intermediateEncryptedStr;      // Encrypted intermediate result
+	std::string intermediateDecryptedStr;      // Decrypted intermediate result
+
+	// Generate symmetric key
+	std::string symmetricKey;
+	generateSymmetricKey( symmetricKey );
+
+	// Encrypt the input string using the symmetric key
+	encryptor.encryptSymmetric( intermediateEncryptedStr, inputStr );
+
+	// Log intermediate encryption result
+	std::cout << "Encrypted string: " << intermediateEncryptedStr << std::endl;
+
+	// Decrypt the encrypted string using the symmetric key
+	encryptor.decryptSymmetric( intermediateDecryptedStr, intermediateEncryptedStr );
+
+	// Log final decryption result
+	std::cout << "Decrypted string: " << intermediateDecryptedStr << std::endl;
+
+	// Check if decryption matches the original input
+	if( inputStr == intermediateDecryptedStr )
+	{
+		std::cout << "Test passed: Decryption matches original input." << std::endl;
+	}
+	else
+	{
+		std::cout << "Test failed: Decryption does not match original input." << std::endl;
+	}*/
+}
+
+int decryptBuffer( const uint8_t *input, int32_t dataSize, uint8_t *output, const uint8_t *symKey )
+{
+	if( dataSize <= 0 )
+	{
+		return false; // No data to decrypt
+	}
+
+	AES aes( AESKeyLength::AES_128 );
+	output = aes.DecryptECB( input, dataSize, symKey );
+
+	return true;
+}

misc/Encryptor.h

@@ -0,0 +1,39 @@
+
+#pragma once
+
+#include <string>
+
+int decryptBuffer( const uint8_t *input, int64_t dataSize, uint8_t *output, const uint8_t *symKey );
+
+class Encryptor
+{
+public:
+	const static inline std::string default_public_key = "25B946EBC0B361734A63910E1FF3C9E1";
+	const static inline std::string default_sym_key = "dlfk qs';r+t iqe4t9ueerjKDJ wdaj";
+
+    Encryptor(); // Constructor
+
+    std::string generateSymmetricKey( void );
+	std::string generatePrivateSymKey( void );
+
+	std::string encryptSymmetric( const std::string &input );
+	std::string decryptSymmetric( const std::string &input );
+
+	void setSymmetricKey( const std::string &key );
+	std::string getSymmetricKey( void ) const;
+
+	void setPublicKey( const std::string &key );
+	std::string getPublicKey( void ) const;
+
+	void setPrivateKey( const std::string &key );
+	std::string getPrivateKey( void ) const;
+
+    static void test();
+
+	std::string m_privateKey, m_encryptedPrivateKey;
+    std::string m_symmetricKey;
+    std::string basic_str_b;
+
+    static bool ms_initialized;
+};
+

misc/Timer.cpp

@@ -0,0 +1,210 @@
+
+#include "Timer.h"
+
+CTimer::CTimer()
+{
+	m_stopped = true;
+	m_inited = false;
+	m_usingQPF = false;
+
+	m_lastElapsedTime = 0.0;
+	m_baseTime = 0.0;
+	m_stopTime = 0.0;
+	m_currSysTime = 0.0;
+	m_currElapsedTime = 0.0;
+
+	m_baseMilliTime = 0.0;
+	m_currSysMilliTime = 0.0;
+	m_currElapsedMilliTime = 0.0;
+
+	m_QPFTicksPerSec = 0;
+	m_QPFStopTime = 0;
+	m_QPFLastElapsedTime = 0;
+	m_QPFBaseTime = 0;
+}
+
+CTimer::~CTimer()
+{
+}
+
+void CTimer::Start()
+{
+	if( !m_inited )
+	{
+		LARGE_INTEGER qwTicksPerSec;
+		m_usingQPF = QueryPerformanceFrequency( &qwTicksPerSec );
+		if( m_usingQPF )
+			m_QPFTicksPerSec = qwTicksPerSec.QuadPart;
+
+		if( m_usingQPF )
+		{
+			QueryPerformanceCounter( &m_QPFTime );
+			m_QPFBaseTime = m_QPFTime.QuadPart;
+			m_currSysTime = m_QPFBaseTime / ( double )m_QPFTicksPerSec;
+			m_baseTime = m_currSysTime;
+
+			m_currSysMilliTime = m_currSysTime * 1000.0;
+			m_baseMilliTime = m_baseTime * 1000.0;
+		}
+		else
+		{
+			m_currSysTime = GetTickCount() * 0.001;
+			m_baseTime = m_currSysTime;
+
+			m_currSysMilliTime = m_currSysTime * 1000.0;
+			m_baseMilliTime = m_baseTime * 1000.0;
+		}
+
+		m_inited = true;
+	}
+
+	if( m_usingQPF )
+	{
+		QueryPerformanceCounter( &m_QPFTime );
+		m_currSysTime = m_QPFTime.QuadPart / ( double )m_QPFTicksPerSec;
+		m_currSysMilliTime = m_currSysTime * 1000.0;
+
+		m_QPFStopTime = 0;
+		m_QPFLastElapsedTime = m_QPFTime.QuadPart;
+	}
+	else
+	{
+		m_currSysTime = GetTickCount() * 0.001;
+		m_currSysMilliTime = m_currSysTime * 1000.0;
+
+		m_stopTime = 0.0f;
+		m_lastElapsedTime = m_currSysTime;
+	}
+
+	m_stopped = false;
+}
+
+void CTimer::Stop()
+{
+	if( m_stopped ) return;
+
+	if( m_usingQPF )
+	{
+		QueryPerformanceCounter( &m_QPFTime );
+		m_currSysTime = m_QPFTime.QuadPart / ( double )m_QPFTicksPerSec;
+		m_currSysMilliTime = m_currSysTime * 1000.0;
+
+		m_QPFStopTime = m_QPFTime.QuadPart;
+		m_QPFLastElapsedTime = m_QPFTime.QuadPart;
+	}
+	else
+	{
+		m_currSysTime = GetTickCount() * 0.001;
+		m_currSysMilliTime = m_currSysTime * 1000.0;
+
+		m_stopTime = m_currSysTime;
+		m_lastElapsedTime = m_currSysTime;
+	}
+
+	m_stopped = true;
+}
+
+void CTimer::Advance()
+{
+	if( m_usingQPF )
+		m_QPFStopTime += m_QPFTicksPerSec / 10;
+	else
+		m_stopTime += 0.1f;
+}
+
+void CTimer::Reset()
+{
+	if( m_usingQPF )
+	{
+		QueryPerformanceCounter( &m_QPFTime );
+		m_currSysTime = m_QPFTime.QuadPart / ( double )m_QPFTicksPerSec;
+		m_currSysMilliTime = m_currSysTime * 1000.0;
+
+		m_QPFBaseTime = m_QPFTime.QuadPart;
+		m_QPFLastElapsedTime = m_QPFTime.QuadPart;
+		m_QPFStopTime = 0;
+
+		m_baseTime = m_QPFBaseTime / ( double )m_QPFTicksPerSec;
+	}
+	else
+	{
+		m_currSysTime = GetTickCount() * 0.001;
+		m_currSysMilliTime = m_currSysTime * 1000.0;
+
+		m_baseTime = m_currSysTime;
+		m_lastElapsedTime = m_currSysTime;
+		m_stopTime = 0.0;
+	}
+
+	m_stopped = false;
+}
+
+double CTimer::Tick()
+{
+	if( m_stopped )
+	{
+		if( m_usingQPF )
+		{
+			m_currSysTime = m_QPFStopTime / ( double )m_QPFTicksPerSec;
+			m_currSysMilliTime = m_currSysTime * 1000.0;
+		}
+		else
+		{
+			m_currSysTime = m_stopTime;
+			m_currSysMilliTime = m_currSysTime * 1000.0;
+		}
+	}
+	else
+	{
+		if( m_usingQPF )
+		{
+			QueryPerformanceCounter( &m_QPFTime );
+			m_currSysTime = m_QPFTime.QuadPart / ( double )m_QPFTicksPerSec;
+			m_currSysMilliTime = m_currSysTime * 1000.0;
+
+			m_currElapsedTime = ( double )( m_QPFTime.QuadPart - m_QPFLastElapsedTime ) / ( double )m_QPFTicksPerSec;
+			m_QPFLastElapsedTime = m_QPFTime.QuadPart;
+
+			m_currElapsedMilliTime = m_currElapsedTime * 1000.0;
+		}
+		else
+		{
+			m_currSysTime = GetTickCount() * 0.001;
+			m_currSysMilliTime = m_currSysTime * 1000.0;
+
+			m_currElapsedTime = ( double )( m_currSysTime - m_lastElapsedTime );
+			m_lastElapsedTime = m_currSysTime;
+
+			m_currElapsedMilliTime = m_currElapsedTime * 1000.0;
+		}
+	}
+	return ( float )m_currElapsedTime;
+}
+
+double CTimer::GetAbsoluteTime()
+{
+	if( m_stopped )
+	{
+		if( m_usingQPF )
+		{
+			return ( m_QPFStopTime / ( double )m_QPFTicksPerSec );
+		}
+		else
+		{
+			return ( m_stopTime );
+		}
+	}
+	else
+	{
+		if( m_usingQPF )
+		{
+			QueryPerformanceCounter( &m_QPFTime );
+
+			return ( m_QPFTime.QuadPart / ( double )m_QPFTicksPerSec );
+		}
+		else
+		{
+			return ( GetTickCount() * 0.001 );
+		}
+	}
+}

misc/Timer.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <Windows.h>
+
+class CTimer {
+	int  m_stopped;
+	int  m_inited;
+	int  m_usingQPF;
+
+	double  m_lastElapsedTime;
+	double  m_baseTime;
+	double  m_stopTime;
+	double  m_currSysTime;
+	double  m_currElapsedTime;
+	double  m_baseMilliTime;
+	double  m_currSysMilliTime;
+	double  m_currElapsedMilliTime;
+
+	long long  m_QPFTicksPerSec;
+	long long  m_QPFStopTime;
+	long long  m_QPFLastElapsedTime;
+	long long  m_QPFBaseTime;
+
+	LARGE_INTEGER m_QPFTime;
+
+public:
+
+	CTimer();
+	 ~CTimer();
+
+	void  Start();
+	void  Stop();
+	void  Advance();
+	void  Reset();
+	double Tick();
+	inline double GetAppTime()
+	{
+		return ( m_currSysTime - m_baseTime );
+	}
+	inline double GetElapsedTime()
+	{
+		return m_currElapsedTime;
+	}
+	inline double GetSysTime()
+	{
+		return m_currSysTime;
+	}
+	inline double GetAppMilliTime()
+	{
+		return ( m_currSysMilliTime - m_baseMilliTime );
+	}
+	inline double GetElapsedMilliTime()
+	{
+		return m_currElapsedMilliTime;
+	}
+
+	double GetAbsoluteTime();
+};

misc/math.cpp

@@ -0,0 +1,44 @@
+#include "..\global_define.h"
+
+int32_t Math::round_up( int32_t numToRound, int32_t multiple )
+{
+	if( multiple == 0 )
+		return numToRound;
+
+	int32_t remainder = abs( numToRound ) % multiple;
+	if( remainder == 0 )
+		return numToRound;
+
+	if( numToRound < 0 )
+		return -( abs( numToRound ) - remainder );
+	else
+		return numToRound + multiple - remainder;
+}
+
+int32_t Math::round_down( int32_t numToRound, int32_t multiple )
+{
+	if( multiple == 0 )
+		return numToRound;
+
+	int32_t remainder = abs( numToRound ) % multiple;
+	if( remainder == 0 )
+		return numToRound;
+
+	if( numToRound < 0 )
+		return -( abs( numToRound ) + remainder );
+	else
+		return numToRound - remainder;
+}
+
+uint16_t Math::swap_endian( uint16_t val )
+{
+	return ( val << 8 ) | ( val >> 8 );
+}
+
+uint32_t Math::swap_endian( uint32_t val )
+{
+	return ( ( val << 24 ) & 0xFF000000 ) |
+		( ( val << 8 ) & 0x00FF0000 ) |
+		( ( val >> 8 ) & 0x0000FF00 ) |
+		( ( val >> 24 ) & 0x000000FF );
+}

misc/math.h

@@ -0,0 +1,10 @@
+#pragma once
+
+namespace Math
+{
+	int32_t round_up( int32_t numToRound, int32_t multiple );
+	int32_t round_down( int32_t numToRound, int32_t multiple );
+
+	uint16_t swap_endian( uint16_t val );
+	uint32_t swap_endian( uint32_t val );
+}

misc/threadsafe_queue.hpp

@@ -0,0 +1,87 @@
+#pragma once
+
+#include <list>
+#include <mutex>
+
+template< typename T >
+class threadsafe_queue
+{
+public:
+    using value_type = T;
+
+	threadsafe_queue() : mutex_(), list_()
+	{
+
+	}
+
+	~threadsafe_queue()
+	{
+
+	}
+
+	size_t size()
+	{
+		return list_.size();
+	}
+
+	bool empty()
+	{
+		return list_.empty();
+	}
+
+	void push( T t )
+	{
+		mutex_.lock();
+		list_.push_back( t );
+		mutex_.unlock();
+	}
+
+	void pop()
+	{
+		mutex_.lock();
+		if( !list_.empty() )
+		{
+			list_.pop_front();
+		}
+		mutex_.unlock();
+	}
+
+	bool front( T& result )
+	{
+		bool ret = false;
+		mutex_.lock();
+		if( !list_.empty() )
+		{
+			result = list_.front();
+			ret = true;
+		}
+		mutex_.unlock();
+		return ret;
+	}
+
+	// Saves time by poping in the same lock that we get front. Only one lock.
+	bool front_and_pop( T& result )
+	{
+		bool ret = false;
+		mutex_.lock();
+		if( !list_.empty() )
+		{
+			result = list_.front();
+			list_.pop_front();
+			ret = true;
+		}
+		mutex_.unlock();
+		return ret;
+	}
+
+	void clear()
+	{
+		mutex_.lock();
+		list_.clear();
+		mutex_.unlock();
+	}
+
+private:
+	std::mutex mutex_;
+	std::list< T > list_;
+};

network/events/Gateway/ReqGetServerAddress.h

@@ -0,0 +1 @@
+#pragma once

network/events/GenericRequest.h

@@ -0,0 +1,53 @@
+#pragma once
+/*
+#include "../network/socket.h"
+#include "../network/packet.h"
+#include "../misc/ByteStream.h"
+
+class GenericRequest
+{
+public:
+	uint16_t ProtocolID;
+	uint32_t EventID;
+	uint32_t State;
+	ByteStream stream;
+
+public:
+	GenericRequest()
+	{
+		ProtocolID = 0;
+		EventID = 0;
+		State = 0;
+	}
+
+	~GenericRequest()
+	{
+	};
+
+	GenericRequest( sptr_packet request )
+	{
+		ProtocolID = request->read_u16();
+		EventID = request->read_u32();
+		State = request->read_u32();
+
+		stream = ByteStream( request->raw );
+	}
+
+	GenericRequest( ByteStream stream )
+	{
+		ProtocolID = stream.read_u16();
+		EventID = stream.read_u32();
+		State = stream.read_u32();
+
+		this->stream = stream;
+	}
+
+	GenericRequest( const GenericRequest & ) = delete;
+	GenericRequest &operator=( const GenericRequest & ) = delete;
+
+	virtual void unpack() = 0;
+	virtual void process( sptr_socket s, sptr_packet r ) = 0;
+};
+
+typedef std::shared_ptr< GenericRequest > sptr_request;
+*/

network/events/GenericResponse.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "../misc/ByteStream.h"
+#include "../network/packet.h"
+
+class GenericResponse
+{
+public:
+	uint16_t ProtocolID;
+	uint32_t EventID;
+	uint32_t State;
+	ByteStream stream;
+
+public:
+	GenericResponse()
+	{
+		ProtocolID = 0;
+		EventID = 0;
+		State = 0;
+	}
+
+	~GenericResponse()
+	{
+
+	}
+
+	virtual void pack()
+	{
+	};
+};
+
+typedef std::shared_ptr< GenericResponse > sptr_response;

network/packet.cpp

@@ -0,0 +1,261 @@
+#include "../global_define.h"
+
+PacketBuffer::PacketBuffer( uint16_t command, uint32_t event_seq, uint32_t hint_size )
+{
+	if( hint_size < PACKET_HEADER_SIZE ) hint_size = PACKET_HEADER_SIZE;
+	buffer.resize( Math::round_up( hint_size, 0x02 ) );
+
+	write_position = PACKET_HEADER_SIZE;
+	read_position = PACKET_HEADER_SIZE;
+
+	*( PacketHeader * )&buffer[ 0 ] = { PACKET_HEADER_SIZE, htons( command ), event_seq, 0 };
+}
+
+PacketBuffer::PacketBuffer( std::vector< uint8_t > &data, size_t length )
+{
+	buffer.resize( length );
+	std::copy( data.begin(), data.begin() + length, buffer.begin() );
+
+	write_position = length;
+	read_position = PACKET_HEADER_SIZE;
+}
+
+template < typename T >
+void PacketBuffer::write( const T i )
+{
+	if( ( write_position + sizeof( T ) ) >= buffer.size() )
+	{
+		buffer.resize( Math::round_up( ( write_position + sizeof( T ) ) + 1, 1024 ) );
+	}
+
+	memcpy( &buffer.data()[ write_position ], &i, sizeof( i ) );
+	write_position += sizeof( i );
+}
+
+void PacketBuffer::skip( const uint32_t size )
+{
+	write_position += size;
+	read_position += size;
+}
+
+void PacketBuffer::write_buffer( const uint8_t *in_buffer, size_t size )
+{
+	resize( size );
+
+	memcpy( &buffer.data()[ write_position ], &in_buffer[ 0 ], size );
+	write_position += size;
+}
+
+void PacketBuffer::write_u8( const uint8_t i )
+{
+	write<uint8_t>( i );
+}
+
+void PacketBuffer::write_u16( const uint16_t i )
+{
+	write<uint16_t>( i );
+}
+
+void PacketBuffer::write_u32( const uint32_t i )
+{
+	write<uint32_t>( i );
+}
+
+void PacketBuffer::write_float( const float f )
+{
+	write<float_t>( f );
+}
+
+void PacketBuffer::write_utf8( std::string s )
+{
+	auto length = static_cast< int16_t >( s.length() );
+	write_u32( length );
+
+	if( ( write_position + length ) >= buffer.size() )
+	{
+		buffer.resize( Math::round_up( ( write_position + length ) + 1, 1024 ) );
+	}
+
+	memcpy( &buffer.data()[ write_position ], &s.data()[ 0 ], s.length() );
+	write_position += length;
+}
+
+void PacketBuffer::write_sz_utf8( std::string s )
+{
+	auto length = static_cast< int16_t >( s.length() );
+
+	if( ( write_position + length ) >= buffer.size() )
+	{
+		buffer.resize( Math::round_up( ( write_position + length ) + 1, 1024 ) );
+	}
+
+	memcpy( &buffer.data()[ write_position ], &s.data()[ 0 ], s.length() );
+	write_position += length;
+
+	// Null-Terminator
+	write_u8( 0 );
+}
+
+void PacketBuffer::write_utf16( std::wstring ws )
+{
+	auto length = ws.length();
+	write_u32( length );
+
+	length = length * sizeof( std::wstring::value_type );
+
+	if( ( write_position + length ) >= buffer.size() )
+	{
+		buffer.resize( Math::round_up( ( write_position + length ) + 1, 1024 ) );
+	}
+
+	memcpy( &buffer.data()[ write_position ], &ws.data()[ 0 ], length );
+	write_position += length;
+
+	write_u16( 0 );
+}
+
+void PacketBuffer::write_sz_utf16( std::wstring ws )
+{
+	auto length = ws.length() * sizeof( std::wstring::value_type );
+
+	if( ( write_position + length ) >= buffer.size() )
+	{
+		buffer.resize( Math::round_up( ( write_position + length ) + 1, 1024 ) );
+	}
+
+	memcpy( &buffer.data()[ write_position ], &ws.data()[ 0 ], length );
+	write_position += length;
+
+	// Null-Terminator
+	write_u16( 0 );
+}
+
+template<typename T>
+T PacketBuffer::read()
+{
+	T ret = *( T * )&buffer.data()[ read_position ];
+	read_position += sizeof( T );
+
+	return ret;
+}
+
+uint8_t PacketBuffer::read_u8()
+{
+	return read< uint8_t >();
+}
+
+uint16_t PacketBuffer::read_u16()
+{
+	return read< uint16_t >();
+}
+
+uint32_t PacketBuffer::read_u32()
+{
+	return read< uint32_t >();
+}
+
+float_t PacketBuffer::read_float()
+{
+	return read< float_t >();
+}
+
+std::string PacketBuffer::read_utf8( size_t forced_size )
+{
+	uint32_t length = read_u32();
+
+	if( forced_size != ~0 )
+	{
+		length = forced_size;
+	}
+
+	auto l = buffer.begin() + read_position;
+	auto r = buffer.begin() + ( read_position += length );
+
+	return std::string( l, r );
+}
+
+std::string PacketBuffer::read_sz_utf8()
+{
+	std::string str;
+
+	while( auto c = read_u8() )
+	{
+		str.push_back( c );
+		read_position++;
+	}
+
+	read_position++;
+	return str;
+}
+
+std::wstring PacketBuffer::read_utf16( size_t forced_size )
+{
+	//std::wstring wstr; wstr.resize( length + 1 );
+	//memcpy( &wstr[ 0 ], &buffer.data()[ write_position ], length * sizeof( wchar_t ) );
+	//write_position += length * sizeof( wchar_t );
+
+	uint32_t length = read_u32() * 2;
+
+	if( forced_size != ~0 )
+	{
+		length = forced_size * 2;
+	}
+
+	auto l = buffer.begin() + read_position;
+	auto r = buffer.begin() + ( read_position += length );
+
+	return std::wstring( l, r );
+}
+
+std::wstring PacketBuffer::read_sz_utf16()
+{
+	std::wstring wstr;
+
+	while( auto c = read_u16() )
+	{
+		wstr.push_back( c );
+		read_position += 2;
+	}
+
+	read_position += 2;
+	return wstr;
+}
+
+sptr_packet make_packet( uint16_t command, uint32_t event_id, uint32_t hint_size )
+{
+	auto p = std::make_shared< PacketBuffer >( command, event_id, hint_size );
+	return p;
+}
+
+sptr_packet make_packet( sptr_packet request )
+{
+	auto p = std::make_shared< PacketBuffer >( request->get_command(), request->get_event_id() );
+	return p;
+
+}
+
+void process_networking()
+{
+	sptr_socket s;
+	sptr_packet p;
+
+	if( !socket_manager->get_message( s, p ) )
+	{
+		return;
+	}
+
+	switch( s->channel )
+	{
+		case RealmChannelType::GATEWAY:
+		{
+			Protocol::Gateway::process_request( s, p );
+			break;
+		}
+
+		case RealmChannelType::GAME:
+		{
+			Protocol::Game::process_request( s, p );
+			break;
+		}
+	}
+}

network/packet.h

@@ -0,0 +1,85 @@
+#pragma once
+
+#include <memory>
+#include "socket.h"
+
+#pragma pack( push, 2 )
+struct PacketHeader
+{
+	uint32_t length;	// The length of the buffer + header
+	uint16_t command;	// The command protocol ID
+	uint32_t event_id;	// The event ID that we must respond to (this is assigned by the client).
+	uint32_t state;		// Connection State (Must be 0, else force reconnect to gateway server)
+};
+#pragma pack(pop)
+
+constexpr int32_t PACKET_HEADER_SIZE = 14;
+static_assert( sizeof( PacketHeader ) == PACKET_HEADER_SIZE, "PacketHeader size mismatch" );
+
+class PacketBuffer
+{
+public:
+	PacketBuffer( uint16_t command, uint32_t event_seq, uint32_t hint_size = 0x4000 );
+	PacketBuffer( std::vector< uint8_t > &data, size_t length );
+
+	~PacketBuffer()
+	{
+	}
+
+	uint16_t get_command()
+	{
+		return ntohs( ( ( PacketHeader * )&buffer[ 0 ] )->command );
+	}
+
+	uint32_t get_event_id()
+	{
+		return ( ( PacketHeader * )&buffer[ 0 ] )->event_id;
+	}
+
+	// Resizes buffer buffer to nearest 1024 when needed
+	inline void resize( size_t write_size )
+	{
+		if( write_position + write_size > buffer.size() )
+		{
+			buffer.resize( Math::round_up( write_position + write_size + 1, 1024 ) );
+		}
+	}
+
+	// Write Data
+	template < typename T >
+	void write( const T i );
+	void write_buffer( const uint8_t *buffer, size_t size );
+	void write_u8( const uint8_t i );
+	void write_u16( const uint16_t i );
+	void write_u32( const uint32_t i );
+	void write_float( const float f );
+	void write_utf8( std::string s );
+	void write_sz_utf8( std::string s );
+	void write_utf16( std::wstring ws );
+	void write_sz_utf16( std::wstring ws );
+
+	// Read Data
+	template < typename T >
+	T read();
+
+	uint8_t read_u8();
+	uint16_t read_u16();
+	uint32_t read_u32();
+	float_t read_float();
+	std::string read_utf8( size_t forced_size = ~0 );
+	std::string read_sz_utf8();
+	std::wstring read_utf16( size_t forced_size = ~0 );
+	std::wstring read_sz_utf16();
+
+	void skip( uint32_t size );
+
+	std::vector< uint8_t > buffer;
+	uint32_t write_position;
+	uint32_t read_position;
+};
+
+typedef std::shared_ptr< PacketBuffer > sptr_packet;
+
+sptr_packet make_packet( uint16_t command, uint32_t event_id, uint32_t hint_size );
+sptr_packet make_packet( sptr_packet request );
+void process_networking();

network/protocol_broker.cpp

@@ -0,0 +1,48 @@
+
+#include "../global_define.h"
+
+#include "protocol_broker.h"
+
+using namespace Protocol::Broker;
+
+typedef void( *FunctionPointer )( sptr_socket, sptr_packet );
+const std::map< uint16_t, FunctionPointer >	BROKER_PROTOCOL =
+{
+
+};
+
+void Protocol::Broker::process_request( sptr_socket socket, sptr_packet request )
+{
+	if( request->get_command() == 0xFFFF )
+	{
+		process_notice( socket, request );
+		return;
+	}
+	
+	auto protocol_iter = BROKER_PROTOCOL.find( request->get_command() );
+	if( protocol_iter == BROKER_PROTOCOL.end() )
+	{
+		logging.error( "UNDEFINED PROTOCOL: %02X", request->get_command() );
+		logging.packet( request->buffer, false );
+		return;
+	}
+
+	( *protocol_iter->second )( socket, request );
+}
+
+void Protocol::Broker::process_notice( sptr_socket s, sptr_packet r )
+{
+	SocketNotice notice_id = ( SocketNotice )r->read_u32();
+	sptr_client client;
+
+	switch( notice_id )
+	{
+		case SocketNotice::NEW_CONNECTION:
+		{
+		} break;
+
+		case SocketNotice::DISCONNECTED:
+		{
+		} break;
+	}
+}

network/protocol_broker.h

@@ -0,0 +1,17 @@
+#pragma once
+
+// ╔═╗╦ ╦╔═╗╔╦╗╔═╗╦╔═╗╔╗╔╔═╗                   
+// ║  ╠═╣╠═╣║║║╠═╝║║ ║║║║╚═╗                   
+// ╚═╝╩ ╩╩ ╩╩ ╩╩  ╩╚═╝╝╚╝╚═╝                   
+// ╔╗ ╦═╗╔═╗╦╔═╔═╗╦═╗  ╔═╗╦═╗╔═╗╔╦╗╔═╗╔═╗╔═╗╦  
+// ╠╩╗╠╦╝║ ║╠╩╗║╣ ╠╦╝  ╠═╝╠╦╝║ ║ ║ ║ ║║  ║ ║║  
+// ╚═╝╩╚═╚═╝╩ ╩╚═╝╩╚═  ╩  ╩╚═╚═╝ ╩ ╚═╝╚═╝╚═╝╩═╝
+
+#include "packet.h"
+#include "socket.h"
+
+namespace Protocol::Broker
+{
+	void process_request( sptr_socket socket, sptr_packet r );		// Process incoming packets
+	void process_notice( sptr_socket socket, sptr_packet r );		// Process socket notices
+}

network/protocol_game.cpp

@@ -0,0 +1,212 @@
+
+#include "../global_define.h"
+
+using namespace Protocol::Game;
+
+typedef void( *FunctionPointer )( sptr_client, sptr_packet );
+const std::map< uint16_t, FunctionPointer >	GAME_PROTOCOL =
+{
+	{ 0x0500, &ReqCancelGame },
+	{ 0x0800, &ReqCreatePrivateGame },
+	{ 0x0A00, &ReqCreatePublicGame },
+	{ 0x0D00, &ReqGetRoom },
+	{ 0x1600, &ReqLogin },
+	{ 0x2400, &ReqTouchSession },
+	{ 0x2500, &ReqDoClientDiscovery },
+	{ 0x2700, &ReqGetEncryptionKey },
+	{ 0x4200, &ReqGetRules },
+	{ 0x4400, &ReqUpdateGameData }
+};
+
+void Protocol::Game::process_request( sptr_socket socket, sptr_packet request )
+{
+	if( request->get_command() == 0xFFFF )
+	{
+		process_notice( socket, request );
+	}
+	else
+	{
+		sptr_client client;
+
+		if( false == client_manager->get_client( socket, client ) )
+		{
+			socket->flag.disconnected = 1;
+			socket.reset();
+			return;
+		}
+
+		auto protocol_iter = GAME_PROTOCOL.find( request->get_command() );
+		if( protocol_iter == GAME_PROTOCOL.end() )
+		{
+			logging.error( "UNDEFINED PROTOCOL: %02X", request->get_command() );
+			logging.packet( request->buffer, false );
+			return;
+		}
+
+		( *protocol_iter->second )( client, request );
+	}
+}
+
+void Protocol::Game::process_notice( sptr_socket socket, sptr_packet request )
+{
+	SocketNotice notice_id = ( SocketNotice )request->read_u32();
+	sptr_client client;
+
+	switch( notice_id )
+	{
+		// A new client connected
+		case SocketNotice::NEW_CONNECTION:
+		{
+			if( false == client_manager->spawn_new( socket, client ) )
+			{
+				socket->flag.disconnected = 1;
+				socket.reset();
+				return;
+			}
+		} break;
+
+		// A client disconnected or a socket error occured
+		case SocketNotice::DISCONNECTED:
+		{
+			if( false == client_manager->get_client( socket, client ) )
+			{
+				return;
+			}
+
+			client_manager->remove_client( client->socket );
+		} break;
+	}
+}
+
+void Protocol::Game::ReqCancelGame( sptr_client client, sptr_packet request )
+{
+	// TODO: here we would notify everyone else in the room, probably on the UDP socket bound to this room?
+
+	auto res = make_packet( request );
+	{
+	}
+	client->socket->send( res );
+}
+
+void Protocol::Game::ReqCreatePrivateGame( sptr_client client, sptr_packet request )
+{
+	uint32_t total_size = request->read_u32() * 2;
+	uint32_t exp_size = request->read_u32();
+	request->skip( total_size - 4 );
+
+	std::wstring room_name = request->read_sz_utf16();
+
+	// TODO: Create Discovery Host and Port for the Broker Server
+
+	auto res = make_packet( request );
+	{
+		res->write_sz_utf8( ServerConfig::Get().service_ip );		// Discovery Host
+		res->write_u32( ServerConfig::Get().broker_port );			// Discovery Port
+	}
+	client->socket->send( res );
+}
+
+void Protocol::Game::ReqCreatePublicGame( sptr_client client, sptr_packet request )
+{
+}
+
+void Protocol::Game::ReqGetRoom( sptr_client client, sptr_packet request )
+{
+	uint32_t total_size = request->read_u32();
+	uint32_t exp_size = request->read_u32();
+
+	//std::array< uint8_t, 16 > game_id = request->read< std::array< uint8_t, 16 > >();
+	request->skip( 16 );
+
+	std::wstring room_name = request->read_utf16();
+
+	auto res = make_packet( request );
+	{
+		res->write_utf16( L"Room Name" );
+		res->write_utf16( L"Room Banner" );
+
+		res->write_u32( 4 );	// Num Members
+
+		res->write_utf8( "Name 1" );
+		res->write_utf8( "Name 2" );
+		res->write_utf8( "Name 3" );
+		res->write_utf8( "Name 4" );
+
+		res->write_u32( 4 );	// Num Moderators
+
+		res->write_utf8( "Moderator 1" );
+		res->write_utf8( "Moderator 2" );
+		res->write_utf8( "Moderator 3" );
+		res->write_utf8( "Moderator 4" );
+	}
+	client->socket->send( res );
+}
+
+void Protocol::Game::ReqLogin( sptr_client, sptr_packet request )
+{
+
+}
+
+void Protocol::Game::ReqTouchSession( sptr_client client, sptr_packet request )
+{
+	std::string session_key = request->read_utf8();
+
+	auto res = make_packet( request );
+	{
+	}
+	client->socket->send( res );
+}
+
+void Protocol::Game::ReqDoClientDiscovery( sptr_client client, sptr_packet request )
+{
+	auto res = make_packet( request );
+	{
+		res->write_sz_utf8( ServerConfig::Get().service_ip );
+		res->write_u32( ServerConfig::Get().broker_port );
+	}
+	client->socket->send( res );
+}
+
+void Protocol::Game::ReqGetEncryptionKey( sptr_client client, sptr_packet request )
+{
+	std::string public_key = request->read_utf8();
+	uint32_t unknown = request->read_u32();
+
+	Encryptor &encryptor = client->encryptor;
+
+	auto privateKey = encryptor.generatePrivateSymKey();
+
+	auto res = make_packet( request );
+	{
+		res->write_u32( 20 ); // Buffer Length (16 + 4)
+		res->write_u32( 0 );// encryptor.m_encryptedPrivateKey.length() );
+		res->write_utf8( "" );// encryptor.m_encryptedPrivateKey);
+	}
+	client->socket->send( res );
+}
+
+void Protocol::Game::ReqGetRules( sptr_client client, sptr_packet request )
+{
+	std::wstring message = L"This is a test message sent from the server!\n\nHurray!";
+
+	auto res = make_packet( request );
+	{
+		res->write_utf16( message );
+	}
+	client->socket->send( res );
+}
+
+void Protocol::Game::ReqUpdateGameData( sptr_client client, sptr_packet request )
+{
+	uint32_t total_size = request->read_u32() * 2;
+	uint32_t exp_size = request->read_u32();
+	request->skip( total_size - 4 );
+
+	std::string game_data = request->read_utf8();	// Seems to be one long string "1 / 4: <description> etc etc". Probably fixed length data structure.
+
+	auto res = make_packet( request );
+	{
+
+	}
+	client->socket->send( res );
+}

network/protocol_game.h

@@ -0,0 +1,28 @@
+#pragma once
+
+// ╔═╗╦ ╦╔═╗╔╦╗╔═╗╦╔═╗╔╗╔╔═╗             
+// ║  ╠═╣╠═╣║║║╠═╝║║ ║║║║╚═╗             
+// ╚═╝╩ ╩╩ ╩╩ ╩╩  ╩╚═╝╝╚╝╚═╝             
+// ╔═╗╔═╗╔╦╗╔═╗  ╔═╗╦═╗╔═╗╔╦╗╔═╗╔═╗╔═╗╦  
+// ║ ╦╠═╣║║║║╣   ╠═╝╠╦╝║ ║ ║ ║ ║║  ║ ║║  
+// ╚═╝╩ ╩╩ ╩╚═╝  ╩  ╩╚═╚═╝ ╩ ╚═╝╚═╝╚═╝╩═╝
+
+#include "packet.h"
+#include "socket.h"
+
+namespace Protocol::Game
+{
+	void process_request( sptr_socket s, sptr_packet r );	// Process incoming packets
+	void process_notice( sptr_socket s, sptr_packet r );	// Process socket notices
+
+	void ReqCancelGame( sptr_client client, sptr_packet request );			// 0500
+	void ReqCreatePrivateGame( sptr_client client, sptr_packet request );	// 0800
+	void ReqCreatePublicGame( sptr_client client, sptr_packet request );	// 0A00
+	void ReqGetRoom( sptr_client client, sptr_packet request );				// 0D00
+	void ReqLogin( sptr_client client, sptr_packet request );				// 1600
+	void ReqTouchSession( sptr_client client, sptr_packet request );		// 2400
+	void ReqDoClientDiscovery( sptr_client client, sptr_packet request );	// 2500
+	void ReqGetEncryptionKey( sptr_client client, sptr_packet request );	// 2700
+	void ReqGetRules( sptr_client client, sptr_packet request );			// 4200
+	void ReqUpdateGameData( sptr_client client, sptr_packet request );		// 4400
+}

network/protocol_gateway.cpp

@@ -0,0 +1,59 @@
+
+#include "../global_define.h"
+
+#include "protocol_gateway.h"
+#include "events/Gateway/ReqGetServerAddress.h"
+
+using namespace Protocol::Gateway;
+
+typedef void( *FunctionPointer )( sptr_socket, sptr_packet );
+const std::map< uint16_t, FunctionPointer >	GATEWAY_PROTOCOL =
+{
+	{ 0x4300, &ReqGetServerAddress },
+};
+
+void Protocol::Gateway::process_request( sptr_socket socket, sptr_packet request )
+{
+	if( request->get_command() == 0xFFFF )
+	{
+		process_notice( socket, request );
+		return;
+	}
+	
+	auto protocol_iter = GATEWAY_PROTOCOL.find( request->get_command() );
+	if( protocol_iter == GATEWAY_PROTOCOL.end() )
+	{
+		logging.error( "UNDEFINED PROTOCOL: %02X", request->get_command() );
+		logging.packet( request->buffer, false );
+		return;
+	}
+
+	( *protocol_iter->second )( socket, request );
+}
+
+void Protocol::Gateway::process_notice( sptr_socket s, sptr_packet r )
+{
+	SocketNotice notice_id = ( SocketNotice )r->read_u32();
+	sptr_client client;
+
+	switch( notice_id )
+	{
+		case SocketNotice::NEW_CONNECTION:
+		{
+		} break;
+
+		case SocketNotice::DISCONNECTED:
+		{
+		} break;
+	}
+}
+
+void Protocol::Gateway::ReqGetServerAddress( sptr_socket socket, sptr_packet request )
+{
+	auto res = std::make_shared< PacketBuffer >( 0x4300, request->get_event_id(), 64 );
+	{
+		res->write_sz_utf8( ServerConfig::Get().service_ip );
+		res->write_u32( ServerConfig::Get().session_port );
+	}
+	socket->send( res );
+}

network/protocol_gateway.h

@@ -0,0 +1,19 @@
+#pragma once
+
+// ╔═╗╦ ╦╔═╗╔╦╗╔═╗╦╔═╗╔╗╔╔═╗                      
+// ║  ╠═╣╠═╣║║║╠═╝║║ ║║║║╚═╗                      
+// ╚═╝╩ ╩╩ ╩╩ ╩╩  ╩╚═╝╝╚╝╚═╝                      
+// ╔═╗╔═╗╔╦╗╔═╗╦ ╦╔═╗╦ ╦  ╔═╗╦═╗╔═╗╔╦╗╔═╗╔═╗╔═╗╦  
+// ║ ╦╠═╣ ║ ║╣ ║║║╠═╣╚╦╝  ╠═╝╠╦╝║ ║ ║ ║ ║║  ║ ║║  
+// ╚═╝╩ ╩ ╩ ╚═╝╚╩╝╩ ╩ ╩   ╩  ╩╚═╚═╝ ╩ ╚═╝╚═╝╚═╝╩═╝
+
+#include "packet.h"
+#include "socket.h"
+
+namespace Protocol::Gateway
+{
+	void process_request( sptr_socket socket, sptr_packet r );		// Process incoming packets
+	void process_notice( sptr_socket socket, sptr_packet r );		// Process socket notices
+
+	void ReqGetServerAddress( sptr_socket socket, sptr_packet r );	// 4300
+}

network/socket.cpp

@@ -0,0 +1,66 @@
+
+#include "../global_define.h"
+#include "socket.h"
+
+CRealmSocket::CRealmSocket()
+{
+	fd = INVALID_SOCKET;
+
+	memset( &local_address, 0, sizeof( local_address ) );
+	memset( &remote_address, 0, sizeof( remote_address ) );
+	port = 0;
+
+	type = RealmSocketType::TCP;
+	channel = RealmChannelType::INVALID;
+
+	flag.disconnected = 0;
+	flag.is_listener = 0;
+	flag.want_more_read_data = 0;
+	flag.want_more_write_data = 0;
+
+	last_write_position = 0;
+
+	latency = 0;
+	last_recv_time = 0.0;
+	last_send_time = 0.0;
+}
+
+CRealmSocket::~CRealmSocket()
+{
+	if( INVALID_SOCKET != fd )
+	{
+		closesocket( fd );
+	}
+
+	fd = INVALID_SOCKET;
+
+	memset( &local_address, 0, sizeof( local_address ) );
+	memset( &remote_address, 0, sizeof( remote_address ) );
+	port = 0;
+
+	type = RealmSocketType::TCP;
+	channel = RealmChannelType::INVALID;
+
+	flag.disconnected = 0;
+	flag.is_listener = 0;
+	flag.want_more_read_data = 0;
+	flag.want_more_write_data = 0;
+
+	last_write_position = 0;
+
+	latency = 0;
+	last_recv_time = 0.0;
+	last_send_time = 0.0;
+}
+
+void CRealmSocket::send( const sptr_packet p )
+{
+	// TODO: UDP sockets probably need to be handled differently
+	// 
+	// Swap the packet size to network byte order
+	*( uint32_t * )&p->buffer[ 0 ] = Math::swap_endian( p->write_position );
+
+	logging.packet( p->buffer, true );
+	std::lock_guard< std::mutex > lock( write_mutex );
+	write_queue.push_back( p );
+}

network/socket.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <mutex>
+#include <vector>
+#include <memory>
+
+#include "packet.h"
+
+enum class RealmSocketType
+{
+	TCP = 0,
+	UDP,
+};
+
+enum class RealmChannelType
+{
+	INVALID = 0,
+	GATEWAY,
+	GAME,
+	DISCOVERY,
+};
+
+class CRealmSocket
+{
+public:
+	CRealmSocket();
+	~CRealmSocket();
+
+	void send( const sptr_packet p );
+
+	struct s_flag
+	{
+		bool disconnected;
+		bool is_listener;
+		bool want_more_read_data;
+		bool want_more_write_data;
+	} flag;
+
+	RealmSocketType type;
+	RealmChannelType channel;
+
+	SOCKET fd;
+	uint16_t port;
+	sockaddr_in local_address;
+	sockaddr_in remote_address;
+	std::string peer_ip_address;
+
+	uint32_t last_write_position;
+
+	double_t latency;
+	double_t last_recv_time;
+	double_t last_send_time;
+
+	std::mutex write_mutex;
+	std::mutex read_mutex;
+
+	std::vector< uint8_t >		read_buffer;
+	std::list< sptr_packet >	read_queue;
+	std::list< sptr_packet >	write_queue;
+};
+
+typedef std::shared_ptr< CRealmSocket > sptr_socket;

network/socket_manager.cpp

@@ -0,0 +1,467 @@
+
+#include "../global_define.h"
+#include "socket_manager.h"
+
+CSocketManager::CSocketManager()
+{
+	run_worker = true;
+	wait_end = true;
+	max_fd = 0;
+
+	dirty_read_buffer.resize( 0xFFFF );
+	socket_list.clear();
+}
+
+CSocketManager::~CSocketManager()
+{
+	run_worker = false;
+	max_fd = 0;
+
+	while( wait_end )
+	{
+		std::this_thread::sleep_for( std::chrono::milliseconds( 100 ) );
+	}
+
+	socket_list.clear();
+}
+
+bool CSocketManager::initialize()
+{
+	WORD wVersionRequest = MAKEWORD( 2, 2 );
+	WSADATA wsaData;
+
+	if( WSAStartup( wVersionRequest, &wsaData ) != 0 )
+		return false;
+
+	net_time.Start();
+
+	auto &config = ServerConfig::Get();
+
+	open_tcp_listener( config.service_ip, config.gateway_port, RealmChannelType::GATEWAY );
+	open_tcp_listener( config.service_ip, config.session_port, RealmChannelType::GAME );
+	open_udp_listener( config.service_ip, config.broker_port, RealmChannelType::DISCOVERY );
+
+	// Start network thread
+	std::thread socket_thread( &CSocketManager::net_worker, this );
+	socket_thread.detach();
+
+	return true;
+}
+
+bool CSocketManager::open_tcp_listener( std::string ip, uint16_t port, RealmChannelType channel )
+{
+	struct sockaddr_in addr;
+	auto socket = std::make_shared< CRealmSocket >();
+
+	if( INVALID_SOCKET == ( socket->fd = ::socket( PF_INET, SOCK_STREAM, IPPROTO_TCP ) ) )
+	{
+		return false;
+	}
+
+	memset( &addr, 0, sizeof( addr ) );
+	addr.sin_family = AF_INET;
+	addr.sin_port = htons( port );
+	addr.sin_addr.s_addr = ( "0.0.0.0" != ip )
+		? inet_addr( ip.c_str() )
+		: htonl( INADDR_ANY );
+
+	if( bind( socket->fd, ( LPSOCKADDR )&addr, sizeof( addr ) ) != 0 )
+	{
+		logging.error( "Could not open socket on %s:%d", ip.c_str(), port );
+		return false;
+	}
+
+	listen( socket->fd, 0xFFFF );
+
+	socket->port = port;
+	socket->channel = channel;
+	socket->type = RealmSocketType::TCP;
+	socket->flag.is_listener = true;
+
+	// Set the socket to non-blocking
+	u_long non_blocking = 1;
+	ioctlsocket( socket->fd, FIONBIO, &non_blocking );
+
+	socket_list.push_back( socket );
+
+	logging.information( "Open TCP Listener on %s:%d", ip.c_str(), port );
+
+	return true;
+}
+
+bool CSocketManager::open_udp_listener( std::string ip, uint16_t port, RealmChannelType channel )
+{
+	struct sockaddr_in addr;
+	auto socket = std::make_shared< CRealmSocket >();
+
+	if( INVALID_SOCKET == ( socket->fd = ::socket( PF_INET, SOCK_DGRAM, IPPROTO_UDP ) ) )
+	{
+		return false;
+	}
+
+	memset( &addr, 0, sizeof( addr ) );
+	addr.sin_family = AF_INET;
+	addr.sin_port = htons( port );
+	addr.sin_addr.s_addr = ( "0.0.0.0" != ip )
+		? inet_addr( ip.c_str() )
+		: htonl( INADDR_ANY );
+
+	if( bind( socket->fd, ( LPSOCKADDR )&addr, sizeof( addr ) ) != 0 )
+	{
+		logging.error( "Could not open socket on %s:%d", ip.c_str(), port );
+		return false;
+	}
+
+	socket->port = port;
+	socket->channel = channel;
+	socket->type = RealmSocketType::UDP;
+	socket->flag.is_listener = true;
+
+	// Set the socket to non-blocking
+	u_long non_blocking = 1;
+	ioctlsocket( socket->fd, FIONBIO, &non_blocking );
+
+	socket_list.push_back( socket );
+
+	logging.information( "Open UDP Listener on %s:%d", ip.c_str(), port );
+
+	return false;
+}
+
+bool CSocketManager::get_message( sptr_socket &s, sptr_packet &p )
+{
+    std::pair< sptr_socket, sptr_packet > pair;
+	
+    if( !pending_packets.front_and_pop( pair ) )
+    {
+        return false;
+    }
+	
+	s = pair.first;
+	p = std::move( pair.second );
+
+	return true;
+}
+
+void CSocketManager::accept_new_tcp( sptr_socket from_socket )
+{
+	struct sockaddr_in listen_in;
+	int listenLen = sizeof( listen_in );
+	SOCKET receive_socket = INVALID_SOCKET;
+	std::string connection_ip;
+	bool is_friendly_connection = false;
+
+	if( ( receive_socket = accept( from_socket->fd, ( struct sockaddr* ) &listen_in, &listenLen ) ) == -1 )
+	{
+		return;
+	}
+
+	connection_ip = inet_ntoa( listen_in.sin_addr );
+
+	auto new_socket = std::make_shared< CRealmSocket >();
+	new_socket->fd = receive_socket;
+	new_socket->peer_ip_address = inet_ntoa( listen_in.sin_addr );
+	new_socket->port = ntohs( listen_in.sin_port );
+	new_socket->channel = from_socket->channel;
+
+	if( from_socket->channel == RealmChannelType::GATEWAY )
+	{
+		logging.information( "[GATEWAY] : New connection from %s", ( *new_socket ).peer_ip_address.c_str() );
+	}
+	else if( from_socket->channel == RealmChannelType::GAME )
+	{
+		logging.information( "[GAME] : New connection from %s", ( *new_socket ).peer_ip_address.c_str() );
+	}
+	
+	new_socket->last_recv_time = net_time.GetAppMilliTime();
+	new_socket->last_send_time = net_time.GetAppMilliTime();
+
+	accept_list.push_back( new_socket );
+}
+
+void CSocketManager::accept_new_udp( sptr_socket s, sockaddr_in addr )
+{
+	auto new_socket = std::make_shared< CRealmSocket >();
+	new_socket->fd = s->fd;
+	new_socket->remote_address = addr;
+	new_socket->channel = s->channel;
+	new_socket->type = RealmSocketType::UDP;
+
+	accept_list.push_back( new_socket );
+}
+
+void CSocketManager::notify_socket( sptr_socket s, SocketNotice command )
+{
+	auto p = std::make_unique< PacketBuffer >( 0xFFFF, 0, 18 );
+	p->write_u32( (int)command );
+	pending_packets.push( std::make_pair( s, std::move( p ) ) );
+}
+
+void CSocketManager::check_socket_problem( sptr_socket sock )
+{
+	if( sock->flag.disconnected ) return;
+	if( sock->flag.is_listener ) return;
+
+	auto now_time = net_time.GetAppMilliTime();
+
+	if( ( now_time - sock->last_recv_time ) > 60000.0 )
+	{
+		sock->flag.disconnected = 1;
+		notify_socket( sock, SocketNotice::DISCONNECTED );
+	}
+}
+
+void CSocketManager::net_worker()
+{
+	struct timeval timeout = { 0, 0 };
+	FD_SET readfd, writefd;
+
+	while( run_worker )
+	{
+		net_time.Tick();
+		max_fd = 0;
+		FD_ZERO( &readfd );
+		FD_ZERO( &writefd );
+
+		// Check for any new connections
+		for( auto &s : accept_list )
+		{
+			socket_list.push_back( s );
+			notify_socket( s, SocketNotice::NEW_CONNECTION );
+		}
+
+		accept_list.clear();
+
+		auto socket = socket_list.begin();
+
+		while( socket != socket_list.end() )
+		{
+			if( ( *socket )->fd == INVALID_SOCKET || ( *socket )->flag.disconnected )
+			{
+				socket = socket_list.erase( socket );
+				continue;
+			}
+
+			FD_SET( ( *socket )->fd, &readfd );
+			FD_SET( ( *socket )->fd, &writefd );
+			
+			max_fd = std::max< SOCKET >( max_fd, ( *socket )->fd + 1 );
+
+			socket++;
+		}
+
+		if( select( max_fd, &readfd, &writefd, NULL, &timeout ) <= 0 )
+		{
+			std::this_thread::sleep_for( std::chrono::milliseconds( 1 ) );
+			continue;
+		}
+
+		for( auto &s : socket_list )
+		{
+			if( s->type == RealmSocketType::TCP )
+			{
+				if( FD_ISSET( s->fd, &readfd ) )
+				{
+					TCP_TryReadData( s );
+				}
+				else if( FD_ISSET( s->fd, &writefd ) )
+				{
+					TCP_TryWriteData( s );
+				}
+			}
+			else if( s->type == RealmSocketType::UDP )
+			{
+				if( FD_ISSET( s->fd, &readfd ) )
+				{
+					UDP_TryReadData( s );
+				}
+				else if( FD_ISSET( s->fd, &writefd ) )
+				{
+					UDP_TryWriteData( s );
+				}
+			}
+		}
+	}
+}
+
+void CSocketManager::TCP_TryReadData( sptr_socket socket )
+{
+	// This socket is a listener, so we want to accept a connection
+	if( socket->flag.is_listener )
+	{
+		accept_new_tcp( socket );
+		return;
+	}
+
+	if( socket->read_buffer.size() >= MAX_READ_SIZE )
+	{
+		return;
+	}
+
+	int32_t read_size = 0;
+
+	if( ( read_size = recv( socket->fd, reinterpret_cast< char* >( &dirty_read_buffer[ 0 ] ), MAX_READ_SIZE, 0 ) ) <= 0 )
+	{
+		switch( WSAGetLastError() )
+		{
+			case WSAECONNRESET:
+			{
+				logging.information( "Connection %s reset by peer.", socket->peer_ip_address.c_str() );
+			} break;
+		}
+
+		socket->flag.disconnected = 1;
+		notify_socket( socket, SocketNotice::DISCONNECTED );
+		return;
+	}
+
+	// TODO: Parse the data from 'dirty_read_buffer' directly if 'socket->read_buffer' is empty.
+	// Otherwise merge them and parse the data.
+	std::copy( std::begin( dirty_read_buffer ), std::begin( dirty_read_buffer ) + read_size, std::back_inserter( socket->read_buffer ) );
+
+	// Parse packets out from the incoming data.
+	while( !socket->read_buffer.empty() )
+	{
+		// Read the packet length from the first 4 bytes and flip it
+		uint32_t length = _byteswap_ulong( *( uint32_t * )&socket->read_buffer[ 0x00 ] );
+
+		if( length > socket->read_buffer.size() )
+		{
+			socket->flag.want_more_read_data = 1;
+			break;
+		}
+
+		if( length == 0x04 )
+		{
+			// This is a keep alive packet, I think.
+			// The client drops them as well.
+			socket->read_buffer.erase( socket->read_buffer.begin(), socket->read_buffer.begin() + length );
+			continue;
+		}
+
+		auto p = std::make_shared< PacketBuffer >( socket->read_buffer, length );
+
+		logging.packet( p->buffer, false );
+
+		socket->read_buffer.erase(
+			socket->read_buffer.begin(),
+			socket->read_buffer.begin() + length );
+
+		pending_packets.push( std::make_pair( socket, std::move( p ) ) );
+	}
+
+	socket->last_recv_time = net_time.GetAppMilliTime();
+	socket->latency = abs( socket->last_recv_time - socket->last_send_time );
+}
+
+void CSocketManager::TCP_TryWriteData( sptr_socket socket )
+{
+	if( socket->write_queue.empty() )
+	{
+		return;
+	}
+
+	if( false == socket->write_mutex.try_lock() )
+	{
+		return;
+	}
+
+	size_t write_offset = 0;
+
+	while( !socket->write_queue.empty() )
+	{
+		auto &packet = socket->write_queue.front();
+		auto total_length = packet->write_position - socket->last_write_position;
+
+		auto chunk_size = std::min< int32_t >( total_length, MAX_TCP_SEND_SIZE );
+		auto write_size = send( socket->fd, reinterpret_cast< char * >( &packet->buffer[ socket->last_write_position ] ), chunk_size, 0 );
+
+		// Socket Error
+		if( write_size == SOCKET_ERROR )
+		{
+			socket->flag.disconnected = 1;
+			break;
+		}
+
+		// Not all data sent
+		if( write_size < total_length )
+		{
+			socket->flag.want_more_write_data = 1;
+			socket->last_write_position += write_size;
+			break;
+		}
+
+		socket->write_queue.pop_front();
+
+		socket->flag.want_more_write_data = 0;
+		socket->last_write_position = 0;
+
+	}
+
+	socket->write_mutex.unlock();
+
+	socket->last_send_time = net_time.GetAppMilliTime();
+	socket->latency = abs( socket->last_recv_time - socket->last_send_time );
+}
+
+void CSocketManager::UDP_TryReadData( sptr_socket socket )
+{
+	if( socket->read_buffer.size() >= MAX_READ_SIZE )
+	{
+		return;
+	}
+
+	int32_t read_size = 0;
+	SOCKADDR_IN addr;
+	int addrLen = sizeof( addr );
+
+	read_size = recvfrom( socket->fd, reinterpret_cast< char * >( &dirty_read_buffer[ 0 ] ), MAX_READ_SIZE, 0, ( SOCKADDR * )&addr, &addrLen );
+
+	if( read_size <= 0 )
+	{
+		return;
+	}
+
+	if( socket->flag.is_listener )
+	{
+		accept_new_udp( socket, addr );
+	}
+
+	logging.packet( dirty_read_buffer, read_size, false );
+
+	auto packet = std::make_shared< PacketBuffer >( dirty_read_buffer, read_size );
+
+	logging.packet( packet->buffer, false );
+
+	pending_packets.push( std::make_pair( socket, std::move( packet ) ) );
+}
+
+void CSocketManager::UDP_TryWriteData( sptr_socket s )
+{
+	if( s->write_queue.empty() )
+	{
+		return;
+	}
+
+	if( false == s->write_mutex.try_lock() )
+	{
+		return;
+	}
+
+
+	auto &packet = s->write_queue.front();
+	auto total_length = packet->write_position;
+
+	auto chunk_size = std::min< int32_t >( total_length, MAX_UDP_SEND_SIZE );
+	auto write_size = sendto( s->fd, reinterpret_cast< char * >( &packet->buffer[ 0 ] ), chunk_size, 0, ( SOCKADDR * )&s->remote_address, sizeof( s->remote_address ) );
+
+	// Socket Error
+	if( write_size == SOCKET_ERROR )
+	{
+		s->flag.disconnected = 1;
+	}
+
+	s->write_queue.pop_front();
+
+	s->write_mutex.unlock();
+}

network/socket_manager.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <vector>
+#include <set>
+#include <thread>
+#include <string>
+#include <memory>
+#include "packet.h"
+#include "socket.h"
+#include "../misc/Timer.h"
+#include "../misc/threadsafe_queue.hpp"
+
+enum class SocketNotice
+{
+	NEW_CONNECTION = 1,
+	DISCONNECTED = 2,
+};
+
+class CSocketManager
+{
+private:
+	const uint32_t MAX_TCP_SEND_SIZE = 65535;
+	const uint32_t MAX_UDP_SEND_SIZE = 1024;
+	const uint32_t MAX_READ_SIZE = 65535;
+	const uint32_t MAX_SOCKETS = 1024;
+
+	CTimer	net_time;
+	std::vector< uint8_t > dirty_read_buffer;
+	std::vector< sptr_socket > accept_list;
+	std::vector< sptr_socket > socket_list;
+	threadsafe_queue< std::pair< sptr_socket, sptr_packet > > pending_packets;
+
+	bool run_worker, wait_end;
+	SOCKET max_fd;
+public:
+	CSocketManager();
+	~CSocketManager();
+
+	bool initialize();
+	bool open_tcp_listener( std::string ip, uint16_t port, RealmChannelType channel );
+	bool open_udp_listener( std::string ip, uint16_t port, RealmChannelType channel );
+	bool get_message( sptr_socket &s, sptr_packet &p );
+	
+private:
+	void net_worker();
+	void accept_new_tcp( sptr_socket s );
+	void accept_new_udp( sptr_socket s, sockaddr_in addr );
+	void notify_socket( sptr_socket s, SocketNotice notice );
+	void check_socket_problem( sptr_socket s );
+
+	void TCP_TryReadData( sptr_socket s );
+	void TCP_TryWriteData( sptr_socket s );
+
+	void UDP_TryReadData( sptr_socket s );
+	void UDP_TryWriteData( sptr_socket s );
+};

resource.h

@@ -0,0 +1,15 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+//
+#define IDI_ICON1                       101
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        102
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1001
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif

stdafx.cpp

@@ -0,0 +1,8 @@
+// stdafx.cpp : source file that includes just the standard includes
+// Master Server.pch will be the pre-compiled header
+// stdafx.obj will contain the pre-compiled type information
+
+#include "stdafx.h"
+
+// TODO: reference any additional headers you need in STDAFX.H
+// and not in this file

stdafx.h

@@ -0,0 +1,15 @@
+// stdafx.h : include file for standard system include files,
+// or project specific include files that are used frequently, but
+// are changed infrequently
+//
+
+#pragma once
+
+#include "targetver.h"
+
+#include <stdio.h>
+#include <tchar.h>
+
+
+
+// TODO: reference additional headers your program requires here

targetver.h

@@ -0,0 +1,8 @@
+#pragma once
+
+// Including SDKDDKVer.h defines the highest available Windows platform.
+
+// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and
+// set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h.
+
+#include <SDKDDKVer.h>

ui/logging.cpp

@@ -0,0 +1,257 @@
+#include "../global_define.h"
+
+static const char* LOG_PATH[] = {
+	"./generic",
+	"./debug",
+	"./error"
+};
+
+#include <mutex>
+static std::mutex log_lock;
+
+void command_callback( void* ptr, size_t len )
+{
+	const wchar_t* p = reinterpret_cast< const wchar_t* >( ptr );
+	std::wstring command( p, p + len );
+
+	// Temp
+	logging.information( "Server command: %S", command.c_str() );
+}
+
+const char* CLogManager::get_time_stamp()
+{
+	static char timestamp[ 64 ] = "";
+
+	time_t t; time( &t );
+	struct tm date_tm;
+	localtime_s( &date_tm, &t );
+
+	_snprintf_s( timestamp, _TRUNCATE, 63,
+				 "[%4d-%02d-%02d %02d:%02d:%02d]: ",
+				 ( date_tm.tm_year + 1900 ),
+				 ( date_tm.tm_mon + 1 ),
+				 date_tm.tm_mday,
+				 date_tm.tm_hour,
+				 date_tm.tm_min,
+				 date_tm.tm_sec );
+
+	return timestamp;
+}
+
+void CLogManager::check_file_status( LOG_TYPE type )
+{
+	time_t t; time( &t );
+	struct tm date_tm;
+	localtime_s( &date_tm, &t );
+
+	if( current_open_hour != date_tm.tm_hour )
+	{
+		current_open_hour = date_tm.tm_hour;
+		if( file_stream[ type ].is_open() )
+		{
+			file_stream[ type ].close();
+		}
+	}
+
+	if( !file_stream[ type ].is_open() )
+	{
+		char szFileName[ 256 ] = "";
+
+		_snprintf_s( szFileName, _TRUNCATE, 255, "./log/%s/log_%04d.%02d.%02d_%02d.log",
+					 LOG_PATH[ type ],
+					 ( date_tm.tm_year + 1900 ),
+					 ( date_tm.tm_mon + 1 ),
+					 date_tm.tm_mday,
+					 date_tm.tm_hour );
+
+		file_stream[ type ].open( szFileName, std::fstream::out | std::fstream::app );
+	}
+}
+
+void CLogManager::write_log( LOG_TYPE type, std::string format )
+{
+	log_lock.lock();
+
+	HANDLE hConsole = GetStdHandle( STD_OUTPUT_HANDLE );
+	SetConsoleTextAttribute( hConsole, type + 10 );
+
+	switch( type )
+	{
+		case LOG_TYPE::log_generic: printf( "[INFO]: " ); break;
+		case LOG_TYPE::log_debug: printf( "[DEBUG]: " ); break;
+		case LOG_TYPE::log_error: printf( "[ERROR]: " ); break;
+	}
+	
+	SetConsoleTextAttribute( hConsole, 15 );
+
+	printf( "%s\n", format.c_str() );
+
+	check_file_status( type );
+	file_stream[ type ] << get_time_stamp() << format << '\n';
+	file_stream[ type ].close();
+	log_lock.unlock();
+}
+
+void CLogManager::information( std::string format, ... )
+{
+	std::vector< char > buf( 512 );
+	va_list args;
+	va_start( args, format );
+	vsnprintf_s( &buf[ 0 ], buf.size(), buf.size() + strlen( format.c_str() ), format.c_str(), args );
+	va_end( args );
+
+	write_log( log_generic, &buf[ 0 ] );
+}
+
+void CLogManager::debug( std::string format, ... )
+{
+	std::vector< char > buf( 512 );
+	va_list args;
+	va_start( args, format );
+	vsnprintf_s( &buf[ 0 ], buf.size(), buf.size() + strlen( format.c_str() ), format.c_str(), args );
+	va_end( args );
+
+	write_log( log_debug, &buf[ 0 ] );
+}
+
+void CLogManager::error( std::string format, ... )
+{
+	std::vector< char > buf( 512 );
+	va_list args;
+	va_start( args, format );
+	vsnprintf_s( &buf[ 0 ], buf.size(), buf.size() + strlen( format.c_str() ), format.c_str(), args );
+	va_end( args );
+
+	write_log( log_error, &buf[ 0 ] );
+}
+
+void CLogManager::packet( std::vector< uint8_t > p, bool send )
+{
+	log_lock.lock();
+
+	HANDLE hConsole = GetStdHandle( STD_OUTPUT_HANDLE );
+
+	uint32_t size = _byteswap_ulong( *( uint32_t * )&p[ 0 ] );
+
+	SetConsoleTextAttribute( hConsole, 15 );
+
+	uint16_t i = 0;
+	uint16_t r = 0;
+
+	if( send )
+	{
+		SetConsoleTextAttribute( hConsole, 11 );
+		printf( "(SEND)(00|01|02|03|04|05|06|07|08|09|0A|0B|0C|0D|0E|0F)\n" );
+		SetConsoleTextAttribute( hConsole, 15 );
+	}
+	else
+	{
+		SetConsoleTextAttribute( hConsole, 10 );
+		printf( "(RECV)(00|01|02|03|04|05|06|07|08|09|0A|0B|0C|0D|0E|0F)\n" );
+		SetConsoleTextAttribute( hConsole, 15 );
+	}
+
+	while( i < size )
+	{
+		if( r == 16 )
+		{
+			uint8_t *c = &p[ ( i - 16 ) ];
+			for( r = 0; r < 16; r++, c++ )
+			{
+				if( ( ( *c ) >= 0x20 && ( *c ) <= 127 ) && ( isprint( ( *c ) ) ) )
+					printf( "%c", ( *c ) );
+				else
+					printf( "%c", 0x2E );
+			}
+			r = 0;
+		}
+
+		if( i % 16 == 0 )
+		{
+			SetConsoleTextAttribute( hConsole, ( send ) ? 11 : 10 );
+			if( i > 0 ) printf( "\n" );
+			printf( "(%04X) ", i );
+			SetConsoleTextAttribute( hConsole, 15 );
+		}
+
+		if( i == 4 || i == 5 )
+		{
+			SetConsoleTextAttribute( hConsole, ( send ) ? 11 : 10 );
+			printf( "%02X ", p[ i ] );
+			SetConsoleTextAttribute( hConsole, 15 );
+		}
+		else
+			printf( "%02X ", p[ i ] );
+
+		i++;
+		r++;
+	}
+	printf( "\n\n" );
+
+	log_lock.unlock();
+}
+
+void CLogManager::packet( std::vector<uint8_t> p, uint32_t size, bool send )
+{
+	log_lock.lock();
+
+	HANDLE hConsole = GetStdHandle( STD_OUTPUT_HANDLE );
+
+	SetConsoleTextAttribute( hConsole, 15 );
+
+	uint16_t i = 0;
+	uint16_t r = 0;
+
+	if( send )
+	{
+		SetConsoleTextAttribute( hConsole, 11 );
+		printf( "(SEND)(00|01|02|03|04|05|06|07|08|09|0A|0B|0C|0D|0E|0F)\n" );
+		SetConsoleTextAttribute( hConsole, 15 );
+	}
+	else
+	{
+		SetConsoleTextAttribute( hConsole, 10 );
+		printf( "(RECV)(00|01|02|03|04|05|06|07|08|09|0A|0B|0C|0D|0E|0F)\n" );
+		SetConsoleTextAttribute( hConsole, 15 );
+	}
+
+	while( i < size )
+	{
+		if( r == 16 )
+		{
+			uint8_t *c = &p[ ( i - 16 ) ];
+			for( r = 0; r < 16; r++, c++ )
+			{
+				if( ( ( *c ) >= 0x20 && ( *c ) <= 127 ) && ( isprint( ( *c ) ) ) )
+					printf( "%c", ( *c ) );
+				else
+					printf( "%c", 0x2E );
+			}
+			r = 0;
+		}
+
+		if( i % 16 == 0 )
+		{
+			SetConsoleTextAttribute( hConsole, ( send ) ? 11 : 10 );
+			if( i > 0 ) printf( "\n" );
+			printf( "(%04X) ", i );
+			SetConsoleTextAttribute( hConsole, 15 );
+		}
+
+		if( i == 4 || i == 5 )
+		{
+			SetConsoleTextAttribute( hConsole, ( send ) ? 11 : 10 );
+			printf( "%02X ", p[ i ] );
+			SetConsoleTextAttribute( hConsole, 15 );
+		}
+		else
+			printf( "%02X ", p[ i ] );
+
+		i++;
+		r++;
+	}
+	printf( "\n\n" );
+
+	log_lock.unlock();
+
+}

ui/logging.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <fstream>
+
+class CLogManager {
+private:
+	enum LOG_TYPE {
+		log_generic = 0,
+		log_debug,
+		log_error,
+		num_log_type
+	};
+
+	uint8_t current_open_hour;
+	std::fstream file_stream[ num_log_type ];
+
+	const char* get_time_stamp();
+	void check_file_status( LOG_TYPE type );
+	void write_log( LOG_TYPE type, std::string format );
+public:
+	CLogManager()
+	{
+
+	}
+
+	~CLogManager()
+	{
+		for( uint8_t i = 0; i < num_log_type; i++ )
+		{
+			if( file_stream[ i ].is_open() )
+			{
+				file_stream[ i ].close();
+			}
+		}
+	}
+
+	void information( std::string format, ... );
+	void debug( std::string format, ... );
+	void error( std::string format, ... );
+	void packet( std::vector< uint8_t > p, bool send );
+	void packet( std::vector< uint8_t > p, uint32_t size, bool send );
+};