Z991239-527 #comment feature: 不依赖winpr编译 mod_pinpad

Module/mod_ScannerSet/mod_ScannerSet.vcxproj

@@ -1,103 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.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>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{1E7F0A40-3BA2-489F-8D7D-FAEE61D343E9}</ProjectGuid>
-    <Keyword>Win32Proj</Keyword>
-    <RootNamespace>mod_HSPScanner</RootNamespace>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>Windows7.1SDK</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </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>
-  <PropertyGroup Label="UserMacros" />
-  <Import Project="..\modmake.setting" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <LinkIncremental>true</LinkIncremental>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <LinkIncremental>false</LinkIncremental>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <PrecompiledHeader>Create</PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;MOD_HSPSCANNER_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>$(FrameworkHeadRoot)\Common;$(DevHeadPath);$(ModuleCommonHeadPath);..\mod_PortableScanner;..\mod_heartbeat;$(FrameworkHeadRoot)\libtoolkit;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalDependencies>$(FrameworkLib)\SpBase.lib;$(FrameworkLib)\libtoolkit.lib;$(ThirdPartyLib)\avutil.lib;$(ThirdPartyLib)\swscale.lib;%(AdditionalDependencies)</AdditionalDependencies>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;MOD_HSPSCANNER_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <None Include="ReadMe.txt" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="CameraImpl.h" />
-    <ClInclude Include="EventRevWnd.h" />
-    <ClInclude Include="mod_ScannerSet.h" />
-    <ClInclude Include="ScannerSetFSM.h" />
-    <ClInclude Include="ScannerSet_def_g.h" />
-    <ClInclude Include="ScannerSet_msg_g.h" />
-    <ClInclude Include="ScannerSet_server_g.h" />
-    <ClInclude Include="targetver.h" />
-  </ItemGroup>
-  <ItemGroup>
-    <ResourceCompile Include="..\..\Version.rc" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="CameraImpl.cpp" />
-    <ClCompile Include="EventRevWnd.cpp" />
-    <ClCompile Include="mod_ScannerSet.cpp" />
-    <ClCompile Include="ScannerSetFSM.cpp" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

Module/mod_ScannerSet/mod_ScannerSet.vcxproj.filters

@@ -1,65 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="源文件">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="头文件">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
-    </Filter>
-    <Filter Include="资源文件">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="ReadMe.txt" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="targetver.h">
-      <Filter>头文件</Filter>
-    </ClInclude>
-    <ClInclude Include="mod_ScannerSet.h">
-      <Filter>头文件</Filter>
-    </ClInclude>
-    <ClInclude Include="ScannerSet_def_g.h">
-      <Filter>头文件</Filter>
-    </ClInclude>
-    <ClInclude Include="ScannerSet_server_g.h">
-      <Filter>头文件</Filter>
-    </ClInclude>
-    <ClInclude Include="ScannerSetFSM.h">
-      <Filter>头文件</Filter>
-    </ClInclude>
-    <ClInclude Include="CameraImpl.h">
-      <Filter>头文件</Filter>
-    </ClInclude>
-    <ClInclude Include="EventRevWnd.h">
-      <Filter>头文件</Filter>
-    </ClInclude>
-    <ClInclude Include="ScannerSet_msg_g.h">
-      <Filter>头文件</Filter>
-    </ClInclude>
-  </ItemGroup>
-  <ItemGroup>
-    <ResourceCompile Include="..\..\Version.rc">
-      <Filter>资源文件</Filter>
-    </ResourceCompile>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="mod_ScannerSet.cpp">
-      <Filter>源文件</Filter>
-    </ClCompile>
-    <ClCompile Include="ScannerSetFSM.cpp">
-      <Filter>源文件</Filter>
-    </ClCompile>
-    <ClCompile Include="CameraImpl.cpp">
-      <Filter>源文件</Filter>
-    </ClCompile>
-    <ClCompile Include="EventRevWnd.cpp">
-      <Filter>源文件</Filter>
-    </ClCompile>
-  </ItemGroup>
-</Project>

Module/mod_pinpad/PinPadFSM.cpp

@@ -9,11 +9,6 @@
 #include "mod_DevAdptEntityBase.hpp"
 #include <map>
 #include <thread>
-#include "path.h"
-
-#include <winpr/library.h>
-#include <winpr/sysinfo.h>
-#include <winpr/thread.h>
 
 using namespace std;
 
@@ -862,8 +857,8 @@ ErrorCodeEnum CPinPadFSM::GetEncryptText(SpReqAnsContext<PinPadService_GetInput_
 	memset(buf,0,len+1);
 	int readed = 0;
 	DWORD elapsed = 0;
-	DWORD dwStart = GetTickCount();
-	DWORD dwEnd = GetTickCount();
+	DWORD dwStart = get_tick_count();
+	DWORD dwEnd = get_tick_count();
 	bool bCancelInput = false;
 	Dbg("reqqqq(pin)[%d][%d][%d]",len,timeout,confirm);
 	Dbg("bExit(%d)",m_bExit);
@@ -874,7 +869,7 @@ ErrorCodeEnum CPinPadFSM::GetEncryptText(SpReqAnsContext<PinPadService_GetInput_
 			break;
 		if (m_bWaitingMore)
 		{
-			dwStart = GetTickCount();
+			dwStart = get_tick_count();
 			elapsed = 0;
 			m_bWaitingMore = false;
 			continue;
@@ -901,14 +896,14 @@ ErrorCodeEnum CPinPadFSM::GetEncryptText(SpReqAnsContext<PinPadService_GetInput_
 				}
 				else
 				{
-					dwEnd = GetTickCount();
+					dwEnd = get_tick_count();
 					elapsed = dwEnd - dwStart;
 					continue;
 				}
 			} else if (btCh == 0x08) { // back
 				if (confirm)
 				{
-					dwEnd = GetTickCount();
+					dwEnd = get_tick_count();
 					elapsed = dwEnd - dwStart;
 					continue;
 				}
@@ -931,7 +926,7 @@ ErrorCodeEnum CPinPadFSM::GetEncryptText(SpReqAnsContext<PinPadService_GetInput_
 			} else if (btCh == 0x3f){
 				if (confirm)
 				{
-					dwEnd = GetTickCount();
+					dwEnd = get_tick_count();
 					elapsed = dwEnd - dwStart;
 					continue;
 				}
@@ -943,7 +938,7 @@ ErrorCodeEnum CPinPadFSM::GetEncryptText(SpReqAnsContext<PinPadService_GetInput_
 			
 		} else {
 		}
-		dwEnd = GetTickCount();
+		dwEnd = get_tick_count();
 		elapsed = dwEnd - dwStart;
 	}
 	buf[readed] = 0;
@@ -1143,9 +1138,9 @@ void CPinPadFSM::OpenInputText(void *pUserdata)
 
 
 	BYTE btCh;
-	INT64 i64Start = GetTickCount64();
+	INT64 i64Start = get_tick_count();
 	err = m_pPinPad->KeyRead(btCh);
-	INT64 i64End = GetTickCount64();
+	INT64 i64End = get_tick_count();
 	if ((i64End - i64Start) > 3000)//more than 3 seconds
 		Dbg("KeyRead cost more than %d seconds.", (i64End - i64Start)/1000);
 	if (err == Error_Succeed) {
@@ -1187,8 +1182,8 @@ ErrorCodeEnum CPinPadFSM::GetText(SpReqAnsContext<PinPadService_GetInput_Req, Pi
 	memset(buf,0,len+1);
 	int readed = 0;
 	DWORD elapsed = 0;
-	DWORD dwStart = GetTickCount();
-	DWORD dwEnd = GetTickCount();
+	DWORD dwStart = get_tick_count();
+	DWORD dwEnd = get_tick_count();
 	bool bCancelInput = false;
 	//Dbg("reqqqq[%d][%d][%d]",len,timeout,confirm);
 	//bool bPlainOpen = false;
@@ -1211,7 +1206,7 @@ ErrorCodeEnum CPinPadFSM::GetText(SpReqAnsContext<PinPadService_GetInput_Req, Pi
 		if (m_bWaitingMore)
 		{
 			Dbg("WaitMore");
-			dwStart = GetTickCount();
+			dwStart = get_tick_count();
 			elapsed = 0;
 			m_bWaitingMore = false;
 			continue;
@@ -1255,14 +1250,14 @@ ErrorCodeEnum CPinPadFSM::GetText(SpReqAnsContext<PinPadService_GetInput_Req, Pi
 				}
 				else
 				{
-					dwEnd = GetTickCount();
+					dwEnd = get_tick_count();
 					elapsed = dwEnd - dwStart;
 					continue;
 				}
 			} else if (btCh == 0x08) { // back
 				if (confirm)
 				{
-					dwEnd = GetTickCount();
+					dwEnd = get_tick_count();
 					elapsed = dwEnd - dwStart;
 					continue;
 				}
@@ -1285,7 +1280,7 @@ ErrorCodeEnum CPinPadFSM::GetText(SpReqAnsContext<PinPadService_GetInput_Req, Pi
 			} else {
 				if (confirm)
 				{
-					dwEnd = GetTickCount();
+					dwEnd = get_tick_count();
 					elapsed = dwEnd - dwStart;
 					continue;
 				}
@@ -1312,7 +1307,7 @@ ErrorCodeEnum CPinPadFSM::GetText(SpReqAnsContext<PinPadService_GetInput_Req, Pi
 		} else {
 			//Dbg("else[%s]", buf);
 		}
-		dwEnd = GetTickCount();
+		dwEnd = get_tick_count();
 		elapsed = dwEnd - dwStart;
 	}
 

Module/mod_pinpad/PinPadFSM.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include "SpFSM.h"
+#include "toolkit.h"
 
 enum EvtType
 {
@@ -363,6 +364,7 @@ protected:
 	
 private:
 	HANDLE m_hInputEvt,m_hInitEvt;
+
 	HMODULE m_hVerdorDll;
 	SpReqAnsContext<PinPadService_GetInput_Req, PinPadService_GetInput_Ans>::Pointer m_ctx;
 	SpReqAnsContext<PinPadService_GetInput_Req, PinPadService_GetInput_Ans>::Pointer m_inputCtx;

libtoolkit/CMakeLists.txt

@@ -29,6 +29,8 @@ if(NOT WIN32)
             unix/core.c
             unix/mutex.c
             unix/thread.c
+            unix/library.c
+            unix/misc.c
         )
 else()
     list(APPEND ${MODULE_PREFIX}_SRCS
@@ -38,6 +40,10 @@ else()
         win/process_monitor.c
         win/mutex.c
         win/thread.c
+        win/library.c
+        win/misc.c
+        win/error.c
+        win/util.c
         )
 endif()
 
@@ -114,6 +120,7 @@ if (WITH_DEBUG_SYMBOLS AND MSVC AND BUILD_SHARED_LIBS)
     install(FILES ${CMAKE_PDB_BINARY_DIR}/${MODULE_NAME}.pdb DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT symbols)
 endif()
 
-#file(GLOB PUBLIC_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/*.h")
-#install( FILES ${PUBLIC_HEADERS} DESTINATION "${RVC_INCLUDE_PATH}/${MODULE_NAME}" COMPONENT headers)
-
+if(INSTALL_DEVELOP_FILES)
+file(GLOB PUBLIC_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/*.h")
+install( FILES ${PUBLIC_HEADERS} DESTINATION "${RVC_INCLUDE_PATH}/${MODULE_NAME}" COMPONENT headers)
+endif()

libtoolkit/errorno.h

@@ -0,0 +1,448 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef TOOLKIT_ERRNO_H_
+#define TOOLKIT_ERRNO_H_
+
+#include <errno.h>
+#if EDOM > 0
+# define TOOLKIT__ERR(x) (-(x))
+#else
+# define TOOLKIT__ERR(x) (x)
+#endif
+
+#define TOOLKIT__EOF     (-4095)
+#define TOOLKIT__UNKNOWN (-4094)
+
+#define TOOLKIT__EAI_ADDRFAMILY  (-3000)
+#define TOOLKIT__EAI_AGAIN       (-3001)
+#define TOOLKIT__EAI_BADFLAGS    (-3002)
+#define TOOLKIT__EAI_CANCELED    (-3003)
+#define TOOLKIT__EAI_FAIL        (-3004)
+#define TOOLKIT__EAI_FAMILY      (-3005)
+#define TOOLKIT__EAI_MEMORY      (-3006)
+#define TOOLKIT__EAI_NODATA      (-3007)
+#define TOOLKIT__EAI_NONAME      (-3008)
+#define TOOLKIT__EAI_OVERFLOW    (-3009)
+#define TOOLKIT__EAI_SERVICE     (-3010)
+#define TOOLKIT__EAI_SOCKTYPE    (-3011)
+#define TOOLKIT__EAI_BADHINTS    (-3013)
+#define TOOLKIT__EAI_PROTOCOL    (-3014)
+
+/* Only map to the system errno on non-Windows platforms. It's apparently
+ * a fairly common practice for Windows programmers to redefine errno codes.
+ */
+#if defined(E2BIG) && !defined(_WIN32)
+# define TOOLKIT__E2BIG TOOLKIT__ERR(E2BIG)
+#else
+# define TOOLKIT__E2BIG (-4093)
+#endif
+
+#if defined(EACCES) && !defined(_WIN32)
+# define TOOLKIT__EACCES TOOLKIT__ERR(EACCES)
+#else
+# define TOOLKIT__EACCES (-4092)
+#endif
+
+#if defined(EADDRINUSE) && !defined(_WIN32)
+# define TOOLKIT__EADDRINUSE TOOLKIT__ERR(EADDRINUSE)
+#else
+# define TOOLKIT__EADDRINUSE (-4091)
+#endif
+
+#if defined(EADDRNOTAVAIL) && !defined(_WIN32)
+# define TOOLKIT__EADDRNOTAVAIL TOOLKIT__ERR(EADDRNOTAVAIL)
+#else
+# define TOOLKIT__EADDRNOTAVAIL (-4090)
+#endif
+
+#if defined(EAFNOSUPPORT) && !defined(_WIN32)
+# define TOOLKIT__EAFNOSUPPORT TOOLKIT__ERR(EAFNOSUPPORT)
+#else
+# define TOOLKIT__EAFNOSUPPORT (-4089)
+#endif
+
+#if defined(EAGAIN) && !defined(_WIN32)
+# define TOOLKIT__EAGAIN TOOLKIT__ERR(EAGAIN)
+#else
+# define TOOLKIT__EAGAIN (-4088)
+#endif
+
+#if defined(EALREADY) && !defined(_WIN32)
+# define TOOLKIT__EALREADY TOOLKIT__ERR(EALREADY)
+#else
+# define TOOLKIT__EALREADY (-4084)
+#endif
+
+#if defined(EBADF) && !defined(_WIN32)
+# define TOOLKIT__EBADF TOOLKIT__ERR(EBADF)
+#else
+# define TOOLKIT__EBADF (-4083)
+#endif
+
+#if defined(EBUSY) && !defined(_WIN32)
+# define TOOLKIT__EBUSY TOOLKIT__ERR(EBUSY)
+#else
+# define TOOLKIT__EBUSY (-4082)
+#endif
+
+#if defined(ECANCELED) && !defined(_WIN32)
+# define TOOLKIT__ECANCELED TOOLKIT__ERR(ECANCELED)
+#else
+# define TOOLKIT__ECANCELED (-4081)
+#endif
+
+#if defined(ECHARSET) && !defined(_WIN32)
+# define TOOLKIT__ECHARSET TOOLKIT__ERR(ECHARSET)
+#else
+# define TOOLKIT__ECHARSET (-4080)
+#endif
+
+#if defined(ECONNABORTED) && !defined(_WIN32)
+# define TOOLKIT__ECONNABORTED TOOLKIT__ERR(ECONNABORTED)
+#else
+# define TOOLKIT__ECONNABORTED (-4079)
+#endif
+
+#if defined(ECONNREFUSED) && !defined(_WIN32)
+# define TOOLKIT__ECONNREFUSED TOOLKIT__ERR(ECONNREFUSED)
+#else
+# define TOOLKIT__ECONNREFUSED (-4078)
+#endif
+
+#if defined(ECONNRESET) && !defined(_WIN32)
+# define TOOLKIT__ECONNRESET TOOLKIT__ERR(ECONNRESET)
+#else
+# define TOOLKIT__ECONNRESET (-4077)
+#endif
+
+#if defined(EDESTADDRREQ) && !defined(_WIN32)
+# define TOOLKIT__EDESTADDRREQ TOOLKIT__ERR(EDESTADDRREQ)
+#else
+# define TOOLKIT__EDESTADDRREQ (-4076)
+#endif
+
+#if defined(EEXIST) && !defined(_WIN32)
+# define TOOLKIT__EEXIST TOOLKIT__ERR(EEXIST)
+#else
+# define TOOLKIT__EEXIST (-4075)
+#endif
+
+#if defined(EFAULT) && !defined(_WIN32)
+# define TOOLKIT__EFAULT TOOLKIT__ERR(EFAULT)
+#else
+# define TOOLKIT__EFAULT (-4074)
+#endif
+
+#if defined(EHOSTUNREACH) && !defined(_WIN32)
+# define TOOLKIT__EHOSTUNREACH TOOLKIT__ERR(EHOSTUNREACH)
+#else
+# define TOOLKIT__EHOSTUNREACH (-4073)
+#endif
+
+#if defined(EINTR) && !defined(_WIN32)
+# define TOOLKIT__EINTR TOOLKIT__ERR(EINTR)
+#else
+# define TOOLKIT__EINTR (-4072)
+#endif
+
+#if defined(EINVAL) && !defined(_WIN32)
+# define TOOLKIT__EINVAL TOOLKIT__ERR(EINVAL)
+#else
+# define TOOLKIT__EINVAL (-4071)
+#endif
+
+#if defined(EIO) && !defined(_WIN32)
+# define TOOLKIT__EIO TOOLKIT__ERR(EIO)
+#else
+# define TOOLKIT__EIO (-4070)
+#endif
+
+#if defined(EISCONN) && !defined(_WIN32)
+# define TOOLKIT__EISCONN TOOLKIT__ERR(EISCONN)
+#else
+# define TOOLKIT__EISCONN (-4069)
+#endif
+
+#if defined(EISDIR) && !defined(_WIN32)
+# define TOOLKIT__EISDIR TOOLKIT__ERR(EISDIR)
+#else
+# define TOOLKIT__EISDIR (-4068)
+#endif
+
+#if defined(ELOOP) && !defined(_WIN32)
+# define TOOLKIT__ELOOP TOOLKIT__ERR(ELOOP)
+#else
+# define TOOLKIT__ELOOP (-4067)
+#endif
+
+#if defined(EMFILE) && !defined(_WIN32)
+# define TOOLKIT__EMFILE TOOLKIT__ERR(EMFILE)
+#else
+# define TOOLKIT__EMFILE (-4066)
+#endif
+
+#if defined(EMSGSIZE) && !defined(_WIN32)
+# define TOOLKIT__EMSGSIZE TOOLKIT__ERR(EMSGSIZE)
+#else
+# define TOOLKIT__EMSGSIZE (-4065)
+#endif
+
+#if defined(ENAMETOOLONG) && !defined(_WIN32)
+# define TOOLKIT__ENAMETOOLONG TOOLKIT__ERR(ENAMETOOLONG)
+#else
+# define TOOLKIT__ENAMETOOLONG (-4064)
+#endif
+
+#if defined(ENETDOWN) && !defined(_WIN32)
+# define TOOLKIT__ENETDOWN TOOLKIT__ERR(ENETDOWN)
+#else
+# define TOOLKIT__ENETDOWN (-4063)
+#endif
+
+#if defined(ENETUNREACH) && !defined(_WIN32)
+# define TOOLKIT__ENETUNREACH TOOLKIT__ERR(ENETUNREACH)
+#else
+# define TOOLKIT__ENETUNREACH (-4062)
+#endif
+
+#if defined(ENFILE) && !defined(_WIN32)
+# define TOOLKIT__ENFILE TOOLKIT__ERR(ENFILE)
+#else
+# define TOOLKIT__ENFILE (-4061)
+#endif
+
+#if defined(ENOBUFS) && !defined(_WIN32)
+# define TOOLKIT__ENOBUFS TOOLKIT__ERR(ENOBUFS)
+#else
+# define TOOLKIT__ENOBUFS (-4060)
+#endif
+
+#if defined(ENODEV) && !defined(_WIN32)
+# define TOOLKIT__ENODEV TOOLKIT__ERR(ENODEV)
+#else
+# define TOOLKIT__ENODEV (-4059)
+#endif
+
+#if defined(ENOENT) && !defined(_WIN32)
+# define TOOLKIT__ENOENT TOOLKIT__ERR(ENOENT)
+#else
+# define TOOLKIT__ENOENT (-4058)
+#endif
+
+#if defined(ENOMEM) && !defined(_WIN32)
+# define TOOLKIT__ENOMEM TOOLKIT__ERR(ENOMEM)
+#else
+# define TOOLKIT__ENOMEM (-4057)
+#endif
+
+#if defined(ENONET) && !defined(_WIN32)
+# define TOOLKIT__ENONET TOOLKIT__ERR(ENONET)
+#else
+# define TOOLKIT__ENONET (-4056)
+#endif
+
+#if defined(ENOSPC) && !defined(_WIN32)
+# define TOOLKIT__ENOSPC TOOLKIT__ERR(ENOSPC)
+#else
+# define TOOLKIT__ENOSPC (-4055)
+#endif
+
+#if defined(ENOSYS) && !defined(_WIN32)
+# define TOOLKIT__ENOSYS TOOLKIT__ERR(ENOSYS)
+#else
+# define TOOLKIT__ENOSYS (-4054)
+#endif
+
+#if defined(ENOTCONN) && !defined(_WIN32)
+# define TOOLKIT__ENOTCONN TOOLKIT__ERR(ENOTCONN)
+#else
+# define TOOLKIT__ENOTCONN (-4053)
+#endif
+
+#if defined(ENOTDIR) && !defined(_WIN32)
+# define TOOLKIT__ENOTDIR TOOLKIT__ERR(ENOTDIR)
+#else
+# define TOOLKIT__ENOTDIR (-4052)
+#endif
+
+#if defined(ENOTEMPTY) && !defined(_WIN32)
+# define TOOLKIT__ENOTEMPTY TOOLKIT__ERR(ENOTEMPTY)
+#else
+# define TOOLKIT__ENOTEMPTY (-4051)
+#endif
+
+#if defined(ENOTSOCK) && !defined(_WIN32)
+# define TOOLKIT__ENOTSOCK TOOLKIT__ERR(ENOTSOCK)
+#else
+# define TOOLKIT__ENOTSOCK (-4050)
+#endif
+
+#if defined(ENOTSUP) && !defined(_WIN32)
+# define TOOLKIT__ENOTSUP TOOLKIT__ERR(ENOTSUP)
+#else
+# define TOOLKIT__ENOTSUP (-4049)
+#endif
+
+#if defined(EPERM) && !defined(_WIN32)
+# define TOOLKIT__EPERM TOOLKIT__ERR(EPERM)
+#else
+# define TOOLKIT__EPERM (-4048)
+#endif
+
+#if defined(EPIPE) && !defined(_WIN32)
+# define TOOLKIT__EPIPE TOOLKIT__ERR(EPIPE)
+#else
+# define TOOLKIT__EPIPE (-4047)
+#endif
+
+#if defined(EPROTO) && !defined(_WIN32)
+# define TOOLKIT__EPROTO TOOLKIT__ERR(EPROTO)
+#else
+# define TOOLKIT__EPROTO TOOLKIT__ERR(4046)
+#endif
+
+#if defined(EPROTONOSUPPORT) && !defined(_WIN32)
+# define TOOLKIT__EPROTONOSUPPORT TOOLKIT__ERR(EPROTONOSUPPORT)
+#else
+# define TOOLKIT__EPROTONOSUPPORT (-4045)
+#endif
+
+#if defined(EPROTOTYPE) && !defined(_WIN32)
+# define TOOLKIT__EPROTOTYPE TOOLKIT__ERR(EPROTOTYPE)
+#else
+# define TOOLKIT__EPROTOTYPE (-4044)
+#endif
+
+#if defined(EROFS) && !defined(_WIN32)
+# define TOOLKIT__EROFS TOOLKIT__ERR(EROFS)
+#else
+# define TOOLKIT__EROFS (-4043)
+#endif
+
+#if defined(ESHUTDOWN) && !defined(_WIN32)
+# define TOOLKIT__ESHUTDOWN TOOLKIT__ERR(ESHUTDOWN)
+#else
+# define TOOLKIT__ESHUTDOWN (-4042)
+#endif
+
+#if defined(ESPIPE) && !defined(_WIN32)
+# define TOOLKIT__ESPIPE TOOLKIT__ERR(ESPIPE)
+#else
+# define TOOLKIT__ESPIPE (-4041)
+#endif
+
+#if defined(ESRCH) && !defined(_WIN32)
+# define TOOLKIT__ESRCH TOOLKIT__ERR(ESRCH)
+#else
+# define TOOLKIT__ESRCH (-4040)
+#endif
+
+#if defined(ETIMEDOUT) && !defined(_WIN32)
+# define TOOLKIT__ETIMEDOUT TOOLKIT__ERR(ETIMEDOUT)
+#else
+# define TOOLKIT__ETIMEDOUT (-4039)
+#endif
+
+#if defined(ETXTBSY) && !defined(_WIN32)
+# define TOOLKIT__ETXTBSY TOOLKIT__ERR(ETXTBSY)
+#else
+# define TOOLKIT__ETXTBSY (-4038)
+#endif
+
+#if defined(EXDEV) && !defined(_WIN32)
+# define TOOLKIT__EXDEV TOOLKIT__ERR(EXDEV)
+#else
+# define TOOLKIT__EXDEV (-4037)
+#endif
+
+#if defined(EFBIG) && !defined(_WIN32)
+# define TOOLKIT__EFBIG TOOLKIT__ERR(EFBIG)
+#else
+# define TOOLKIT__EFBIG (-4036)
+#endif
+
+#if defined(ENOPROTOOPT) && !defined(_WIN32)
+# define TOOLKIT__ENOPROTOOPT TOOLKIT__ERR(ENOPROTOOPT)
+#else
+# define TOOLKIT__ENOPROTOOPT (-4035)
+#endif
+
+#if defined(ERANGE) && !defined(_WIN32)
+# define TOOLKIT__ERANGE TOOLKIT__ERR(ERANGE)
+#else
+# define TOOLKIT__ERANGE (-4034)
+#endif
+
+#if defined(ENXIO) && !defined(_WIN32)
+# define TOOLKIT__ENXIO TOOLKIT__ERR(ENXIO)
+#else
+# define TOOLKIT__ENXIO (-4033)
+#endif
+
+#if defined(EMLINK) && !defined(_WIN32)
+# define TOOLKIT__EMLINK TOOLKIT__ERR(EMLINK)
+#else
+# define TOOLKIT__EMLINK (-4032)
+#endif
+
+/* EHOSTDOWN is not visible on BSD-like systems when _POSIX_C_SOURCE is
+ * defined. Fortunately, its value is always 64 so it's possible albeit
+ * icky to hard-code it.
+ */
+#if defined(EHOSTDOWN) && !defined(_WIN32)
+# define TOOLKIT__EHOSTDOWN TOOLKIT__ERR(EHOSTDOWN)
+#elif defined(__APPLE__) || \
+      defined(__DragonFly__) || \
+      defined(__FreeBSD__) || \
+      defined(__FreeBSD_kernel__) || \
+      defined(__NetBSD__) || \
+      defined(__OpenBSD__)
+# define TOOLKIT__EHOSTDOWN (-64)
+#else
+# define TOOLKIT__EHOSTDOWN (-4031)
+#endif
+
+#if defined(EREMOTEIO) && !defined(_WIN32)
+# define TOOLKIT__EREMOTEIO TOOLKIT__ERR(EREMOTEIO)
+#else
+# define TOOLKIT__EREMOTEIO (-4030)
+#endif
+
+#if defined(ENOTTY) && !defined(_WIN32)
+# define TOOLKIT__ENOTTY TOOLKIT__ERR(ENOTTY)
+#else
+# define TOOLKIT__ENOTTY (-4029)
+#endif
+
+#if defined(EFTYPE) && !defined(_WIN32)
+# define TOOLKIT__EFTYPE TOOLKIT__ERR(EFTYPE)
+#else
+# define TOOLKIT__EFTYPE (-4028)
+#endif
+
+#if defined(EILSEQ) && !defined(_WIN32)
+# define TOOLKIT__EILSEQ TOOLKIT__ERR(EILSEQ)
+#else
+# define TOOLKIT__EILSEQ (-4027)
+#endif
+
+#endif /* TOOLKIT_ERRNO_H_ */

libtoolkit/test/test_timetick.cpp

@@ -0,0 +1,9 @@
+#include <gtest/gtest.h>
+#include "toolkit.h"
+
+
+TEST(TickCountTick, hrtimeTest)
+{
+	uint64_t th = toolkit_hrtime();
+
+}

libtoolkit/toolkit.c

@@ -0,0 +1,10 @@
+#include "toolkit.h"
+
+void toolkit_os_free_environ(toolkit_env_item_t* envitems, int count)
+{
+	int i;
+	for (i = 0; i < count; i++) {
+		FREE(envitems[i].name);
+	}
+	FREE(envitems);
+}

libtoolkit/toolkit.h

@@ -11,18 +11,114 @@
 
 #include "config.h"
 #include <stdint.h>
+#include "errorno.h"
 #include "memutil.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #ifndef _WIN32
 #include "unix.h"
 #else
 #include "win.h"
 #endif //NOT _WIN32
 
-#ifdef __cplusplus
-extern "C" {
-#endif
 
+    /** errno compoent*/
+
+#define TOOLKIT_ERRNO_MAP(XX)                                                      \
+  XX(E2BIG, "argument list too long")                                         \
+  XX(EACCES, "permission denied")                                             \
+  XX(EADDRINUSE, "address already in use")                                    \
+  XX(EADDRNOTAVAIL, "address not available")                                  \
+  XX(EAFNOSUPPORT, "address family not supported")                            \
+  XX(EAGAIN, "resource temporarily unavailable")                              \
+  XX(EAI_ADDRFAMILY, "address family not supported")                          \
+  XX(EAI_AGAIN, "temporary failure")                                          \
+  XX(EAI_BADFLAGS, "bad ai_flags value")                                      \
+  XX(EAI_BADHINTS, "invalid value for hints")                                 \
+  XX(EAI_CANCELED, "request canceled")                                        \
+  XX(EAI_FAIL, "permanent failure")                                           \
+  XX(EAI_FAMILY, "ai_family not supported")                                   \
+  XX(EAI_MEMORY, "out of memory")                                             \
+  XX(EAI_NODATA, "no address")                                                \
+  XX(EAI_NONAME, "unknown node or service")                                   \
+  XX(EAI_OVERFLOW, "argument buffer overflow")                                \
+  XX(EAI_PROTOCOL, "resolved protocol is unknown")                            \
+  XX(EAI_SERVICE, "service not available for socket type")                    \
+  XX(EAI_SOCKTYPE, "socket type not supported")                               \
+  XX(EALREADY, "connection already in progress")                              \
+  XX(EBADF, "bad file descriptor")                                            \
+  XX(EBUSY, "resource busy or locked")                                        \
+  XX(ECANCELED, "operation canceled")                                         \
+  XX(ECHARSET, "invalid Unicode character")                                   \
+  XX(ECONNABORTED, "software caused connection abort")                        \
+  XX(ECONNREFUSED, "connection refused")                                      \
+  XX(ECONNRESET, "connection reset by peer")                                  \
+  XX(EDESTADDRREQ, "destination address required")                            \
+  XX(EEXIST, "file already exists")                                           \
+  XX(EFAULT, "bad address in system call argument")                           \
+  XX(EFBIG, "file too large")                                                 \
+  XX(EHOSTUNREACH, "host is unreachable")                                     \
+  XX(EINTR, "interrupted system call")                                        \
+  XX(EINVAL, "invalid argument")                                              \
+  XX(EIO, "i/o error")                                                        \
+  XX(EISCONN, "socket is already connected")                                  \
+  XX(EISDIR, "illegal operation on a directory")                              \
+  XX(ELOOP, "too many symbolic links encountered")                            \
+  XX(EMFILE, "too many open files")                                           \
+  XX(EMSGSIZE, "message too long")                                            \
+  XX(ENAMETOOLONG, "name too long")                                           \
+  XX(ENETDOWN, "network is down")                                             \
+  XX(ENETUNREACH, "network is unreachable")                                   \
+  XX(ENFILE, "file table overflow")                                           \
+  XX(ENOBUFS, "no buffer space available")                                    \
+  XX(ENODEV, "no such device")                                                \
+  XX(ENOENT, "no such file or directory")                                     \
+  XX(ENOMEM, "not enough memory")                                             \
+  XX(ENONET, "machine is not on the network")                                 \
+  XX(ENOPROTOOPT, "protocol not available")                                   \
+  XX(ENOSPC, "no space left on device")                                       \
+  XX(ENOSYS, "function not implemented")                                      \
+  XX(ENOTCONN, "socket is not connected")                                     \
+  XX(ENOTDIR, "not a directory")                                              \
+  XX(ENOTEMPTY, "directory not empty")                                        \
+  XX(ENOTSOCK, "socket operation on non-socket")                              \
+  XX(ENOTSUP, "operation not supported on socket")                            \
+  XX(EPERM, "operation not permitted")                                        \
+  XX(EPIPE, "broken pipe")                                                    \
+  XX(EPROTO, "protocol error")                                                \
+  XX(EPROTONOSUPPORT, "protocol not supported")                               \
+  XX(EPROTOTYPE, "protocol wrong type for socket")                            \
+  XX(ERANGE, "result too large")                                              \
+  XX(EROFS, "read-only file system")                                          \
+  XX(ESHUTDOWN, "cannot send after transport endpoint shutdown")              \
+  XX(ESPIPE, "invalid seek")                                                  \
+  XX(ESRCH, "no such process")                                                \
+  XX(ETIMEDOUT, "connection timed out")                                       \
+  XX(ETXTBSY, "text file is busy")                                            \
+  XX(EXDEV, "cross-device link not permitted")                                \
+  XX(UNKNOWN, "unknown error")                                                \
+  XX(EOF, "end of file")                                                      \
+  XX(ENXIO, "no such device or address")                                      \
+  XX(EMLINK, "too many links")                                                \
+  XX(EHOSTDOWN, "host is down")                                               \
+  XX(EREMOTEIO, "remote I/O error")                                           \
+  XX(ENOTTY, "inappropriate ioctl for device")                                \
+  XX(EFTYPE, "inappropriate file type or format")                             \
+  XX(EILSEQ, "illegal byte sequence")                                         \
+
+	typedef enum {
+#define XX(code, _) TOOLKIT_ ## code = TOOLKIT__ ## code,
+        TOOLKIT_ERRNO_MAP(XX)
+#undef XX
+        TOOLKIT_ERRNO_MAX = TOOLKIT__EOF - 1
+	} toolkit_errno_t;
+
+    TOOLKIT_API int toolkit_translate_sys_error(int sys_errno);
+
+    /*version component*/
 	TOOLKIT_API unsigned int toolkit_version(void);
 	TOOLKIT_API const char* toolkit_version_string(void);
 
@@ -59,15 +155,10 @@ extern "C" {
     TOOLKIT_API bool process_exist_or_not(int pid);
 
 	TOOLKIT_API int toolkit_key_create(toolkit_key_t* key);
-
 	TOOLKIT_API void toolkit_key_delete(toolkit_key_t* key);
-
 	TOOLKIT_API void* toolkit_key_get(toolkit_key_t* key);
-
 	TOOLKIT_API void toolkit_key_set(toolkit_key_t* key, void* value);
 
-
-
 	/** thread component*/
     
     typedef struct toolkit_thread_option_s {
@@ -82,16 +173,41 @@ extern "C" {
 		toolkit_thread_cb entry,
 		void* arg);
 	TOOLKIT_API toolkit_thread_t toolkit_thread_self(void);
-
 	TOOLKIT_API int toolkit_thread_join(toolkit_thread_t* tid);
-
 	TOOLKIT_API int toolkit_thread_equal(const toolkit_thread_t* t1, const toolkit_thread_t* t2);
 
 
+    /** library component*/
+
+    TOOLKIT_API int toolkit_dlopen(const char* filename, toolkit_lib_t* lib);
+    TOOLKIT_API void toolkit_dlclose(toolkit_lib_t* lib);
+    TOOLKIT_API int toolkit_dlsym(toolkit_lib_t* lib, const char* name, void** ptr);
+    TOOLKIT_API const char* toolkit_dlerror(const toolkit_lib_t* lib);
+
+    /** environment variable component*/
+
+	typedef struct toolkit_env_item_s {
+		char* name;
+		char* value;
+	} toolkit_env_item_t;
+
+    TOOLKIT_API int toolkit_os_environ(toolkit_env_item_t** envitems, int* count);
+	TOOLKIT_API void toolkit_os_free_environ(toolkit_env_item_t* envitems, int count);
+	TOOLKIT_API int toolkit_os_getenv(const char* name, char* buffer, size_t* size);
+	TOOLKIT_API int toolkit_os_setenv(const char* name, const char* value);
+	TOOLKIT_API int toolkit_os_unsetenv(const char* name);
+
+
+    /** time component*/
+
+    /** high resolution time*/
+    TOOLKIT_API uint64_t toolkit_hrtime();
 
 
 #ifdef __cplusplus
 } // extern "C" {
 #endif
 
+#include "winfit.h"
+
 #endif //__TOOLKIT_GLOBAL_H__

libtoolkit/unix.h

@@ -20,6 +20,11 @@ extern "C" {
 #define TOOLKIT_ONCE_INIT PTHREAD_ONCE_INIT
 
 
+	typedef struct {
+		void* handle;
+		char* errmsg;
+	} toolkit_lib_t;
+
 #ifdef __cplusplus
 } // extern "C" {
 #endif

libtoolkit/unix/library.c

@@ -0,0 +1,60 @@
+#include "toolkit.h"
+
+#include <dlfcn.h>
+#include <errno.h>
+#include <string.h>
+#include <locale.h>
+
+static int toolkit__dlerror(toolkit_lib_t* lib);
+
+int toolkit_dlopen(const char* filename, toolkit_lib_t* lib) 
+{
+	dlerror(); /* Reset error status. */
+	lib->errmsg = NULL;
+	lib->handle = dlopen(filename, RTLD_LAZY);
+	return lib->handle ? 0 : toolkit__dlerror(lib);
+}
+
+void toolkit_dlclose(toolkit_lib_t* lib) 
+{
+	FREE(lib->errmsg);
+
+	if (lib->handle) {
+		/* Ignore errors. No good way to signal them without leaking memory. */
+		dlclose(lib->handle);
+		lib->handle = NULL;
+	}
+}
+
+int toolkit_dlsym(toolkit_lib_t* lib, const char* name, void** ptr) 
+{
+	dlerror(); /* Reset error status. */
+	*ptr = dlsym(lib->handle, name);
+	return toolkit__dlerror(lib);
+}
+
+const char* toolkit_dlerror(const toolkit_lib_t* lib) 
+{
+	return lib->errmsg ? lib->errmsg : "no error";
+}
+
+static int toolkit__dlerror(toolkit_lib_t* lib) 
+{
+	const char* errmsg;
+	FREE(lib->errmsg);
+
+	errmsg = dlerror();
+
+	if (errmsg) {
+		lib->errmsg = STRDUP(errmsg);
+		return -1;
+	}
+	else {
+		lib->errmsg = NULL;
+		return 0;
+	}
+}
+
+
+
+

libtoolkit/unix/misc.c

@@ -0,0 +1,135 @@
+#include "toolkit.h"
+#include <stdlib.h>
+
+#include <stdint.h>
+#include <time.h>
+
+#undef NANOSEC
+#define NANOSEC ((uint64_t) 1e9)
+
+extern char** environ;
+
+int toolkit_translate_sys_error(int sys_errno)
+{
+	return sys_errno <= 0 ? sys_errno : -sys_errno;
+}
+
+
+int toolkit_os_environ(toolkit_env_item_t** envitems, int* count) 
+{
+	int i, j, cnt;
+	toolkit_env_item_t* envitem;
+
+	*envitems = NULL;
+	*count = 0;
+
+	for (i = 0; environ[i] != NULL; i++);
+
+	*envitems = ZCALLOC(i, sizeof(**envitems));
+
+	if (envitems == NULL)
+		return TOOLKIT_ENOMEM;
+
+	for (j = 0, cnt = 0; j < i; j++) {
+		char* buf;
+		char* ptr;
+
+		if (environ[j] == NULL)
+			break;
+
+		buf = STRDUP(environ[j]);
+		if (buf == NULL)
+			goto fail;
+
+		ptr = strchr(buf, '=');
+		if (ptr == NULL) {
+			FREE(buf);
+			continue;
+		}
+
+		*ptr = '\0';
+
+		envitem = &(*envitems)[cnt];
+		envitem->name = buf;
+		envitem->value = ptr + 1;
+
+		cnt++;
+	}
+
+	*count = cnt;
+	return 0;
+
+fail:
+	for (i = 0; i < cnt; i++) {
+		envitem = &(*envitems)[cnt];
+		FREE(envitem->name);
+	}
+	FREE(*envitems);
+
+	*envitems = NULL;
+	*count = 0;
+	return TOOLKIT_ENOMEM;
+}
+
+
+int toolkit_os_getenv(const char* name, char* buffer, size_t* size) 
+{
+	char* var;
+	size_t len;
+
+	if (name == NULL || buffer == NULL || size == NULL || *size == 0)
+		return TOOLKIT_EINVAL;
+
+	var = getenv(name);
+
+	if (var == NULL)
+		return TOOLKIT_ENOENT;
+
+	len = strlen(var);
+
+	if (len >= *size) {
+		*size = len + 1;
+		return TOOLKIT_ENOBUFS;
+	}
+
+	memcpy(buffer, var, len + 1);
+	*size = len;
+
+	return 0;
+}
+
+
+int toolkit_os_setenv(const char* name, const char* value)
+{
+	if (name == NULL || value == NULL)
+		return TOOLKIT_EINVAL;
+
+	if (setenv(name, value, 1) != 0)
+		return TOOLKIT__ERR(errno);
+
+	return 0;
+}
+
+
+int toolkit_os_unsetenv(const char* name) {
+	if (name == NULL)
+		return TOOLKIT_EINVAL;
+
+	if (unsetenv(name) != 0)
+		return TOOLKIT__ERR(errno);
+
+	return 0;
+}
+
+uint64_t toolkit__hrtime()
+{
+	struct timespec ts;
+	clock_gettime(CLOCK_MONOTONIC, &ts);
+	return (((uint64_t)ts.tv_sec) * NANOSEC + ts.tv_nsec);
+}
+
+uint64_t toolkit_hrtime(void)
+{
+	return toolkit__hrtime();
+}
+

libtoolkit/win.h

@@ -3,6 +3,11 @@
 
 #ifdef _WIN32
 
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct {
 	DWORD tls_index;
 } toolkit_key_t;
@@ -18,6 +23,17 @@ typedef struct toolkit_once_s {
 
 typedef HANDLE toolkit_thread_t;
 
+
+typedef struct {
+	HMODULE handle;
+	char* errmsg;
+} toolkit_lib_t;
+
+
+#ifdef __cplusplus
+} // extern "C" {
+#endif
+
 #endif //_WIN32
 
 #endif //_TOOLKIT_WIN_HEADER_H_

libtoolkit/win/error.c

@@ -0,0 +1,109 @@
+#include "toolkit.h"
+
+int toolkit_translate_sys_error(int sys_errno) {
+	if (sys_errno <= 0) {
+		return sys_errno;  /* If < 0 then it's already a libuv error. */
+	}
+
+	switch (sys_errno) {
+	case ERROR_NOACCESS:                                      return TOOLKIT_EACCES;
+	case WSAEACCES:                                                 return TOOLKIT_EACCES;
+	case ERROR_ELEVATION_REQUIRED:                    return TOOLKIT_EACCES;
+	case ERROR_ADDRESS_ALREADY_ASSOCIATED:  return TOOLKIT_EADDRINUSE;
+	case WSAEADDRINUSE:                     return TOOLKIT_EADDRINUSE;
+	case WSAEADDRNOTAVAIL:                  return TOOLKIT_EADDRNOTAVAIL;
+	case WSAEAFNOSUPPORT:                   return TOOLKIT_EAFNOSUPPORT;
+	case WSAEWOULDBLOCK:                    return TOOLKIT_EAGAIN;
+	case WSAEALREADY:                       return TOOLKIT_EALREADY;
+	case ERROR_INVALID_FLAGS:               return TOOLKIT_EBADF;
+	case ERROR_INVALID_HANDLE:              return TOOLKIT_EBADF;
+	case ERROR_LOCK_VIOLATION:              return TOOLKIT_EBUSY;
+	case ERROR_PIPE_BUSY:                   return TOOLKIT_EBUSY;
+	case ERROR_SHARING_VIOLATION:           return TOOLKIT_EBUSY;
+	case ERROR_OPERATION_ABORTED:           return TOOLKIT_ECANCELED;
+	case WSAEINTR:                          return TOOLKIT_ECANCELED;
+	case ERROR_NO_UNICODE_TRANSLATION:      return TOOLKIT_ECHARSET;
+	case ERROR_CONNECTION_ABORTED:          return TOOLKIT_ECONNABORTED;
+	case WSAECONNABORTED:                   return TOOLKIT_ECONNABORTED;
+	case ERROR_CONNECTION_REFUSED:          return TOOLKIT_ECONNREFUSED;
+	case WSAECONNREFUSED:                   return TOOLKIT_ECONNREFUSED;
+	case ERROR_NETNAME_DELETED:             return TOOLKIT_ECONNRESET;
+	case WSAECONNRESET:                     return TOOLKIT_ECONNRESET;
+	case ERROR_ALREADY_EXISTS:              return TOOLKIT_EEXIST;
+	case ERROR_FILE_EXISTS:                 return TOOLKIT_EEXIST;
+	case ERROR_BUFFER_OVERFLOW:             return TOOLKIT_EFAULT;
+	case WSAEFAULT:                         return TOOLKIT_EFAULT;
+	case ERROR_HOST_UNREACHABLE:            return TOOLKIT_EHOSTUNREACH;
+	case WSAEHOSTUNREACH:                   return TOOLKIT_EHOSTUNREACH;
+	case ERROR_INSUFFICIENT_BUFFER:         return TOOLKIT_EINVAL;
+	case ERROR_INVALID_DATA:                return TOOLKIT_EINVAL;
+	case ERROR_INVALID_PARAMETER:           return TOOLKIT_EINVAL;
+	case ERROR_SYMLINK_NOT_SUPPORTED:       return TOOLKIT_EINVAL;
+	case WSAEINVAL:                         return TOOLKIT_EINVAL;
+	case WSAEPFNOSUPPORT:                   return TOOLKIT_EINVAL;
+	case WSAESOCKTNOSUPPORT:                return TOOLKIT_EINVAL;
+	case ERROR_BEGINNING_OF_MEDIA:          return TOOLKIT_EIO;
+	case ERROR_BUS_RESET:                   return TOOLKIT_EIO;
+	case ERROR_CRC:                         return TOOLKIT_EIO;
+	case ERROR_DEVICE_DOOR_OPEN:            return TOOLKIT_EIO;
+	case ERROR_DEVICE_REQUIRES_CLEANING:    return TOOLKIT_EIO;
+	case ERROR_DISK_CORRUPT:                return TOOLKIT_EIO;
+	case ERROR_EOM_OVERFLOW:                return TOOLKIT_EIO;
+	case ERROR_FILEMARK_DETECTED:           return TOOLKIT_EIO;
+	case ERROR_GEN_FAILURE:                 return TOOLKIT_EIO;
+	case ERROR_INVALID_BLOCK_LENGTH:        return TOOLKIT_EIO;
+	case ERROR_IO_DEVICE:                   return TOOLKIT_EIO;
+	case ERROR_NO_DATA_DETECTED:            return TOOLKIT_EIO;
+	case ERROR_NO_SIGNAL_SENT:              return TOOLKIT_EIO;
+	case ERROR_OPEN_FAILED:                 return TOOLKIT_EIO;
+	case ERROR_SETMARK_DETECTED:            return TOOLKIT_EIO;
+	case ERROR_SIGNAL_REFUSED:              return TOOLKIT_EIO;
+	case WSAEISCONN:                        return TOOLKIT_EISCONN;
+	case ERROR_CANT_RESOLVE_FILENAME:       return TOOLKIT_ELOOP;
+	case ERROR_TOO_MANY_OPEN_FILES:         return TOOLKIT_EMFILE;
+	case WSAEMFILE:                         return TOOLKIT_EMFILE;
+	case WSAEMSGSIZE:                       return TOOLKIT_EMSGSIZE;
+	case ERROR_FILENAME_EXCED_RANGE:        return TOOLKIT_ENAMETOOLONG;
+	case ERROR_NETWORK_UNREACHABLE:         return TOOLKIT_ENETUNREACH;
+	case WSAENETUNREACH:                    return TOOLKIT_ENETUNREACH;
+	case WSAENOBUFS:                        return TOOLKIT_ENOBUFS;
+	case ERROR_BAD_PATHNAME:                return TOOLKIT_ENOENT;
+	case ERROR_DIRECTORY:                   return TOOLKIT_ENOENT;
+	case ERROR_ENVVAR_NOT_FOUND:            return TOOLKIT_ENOENT;
+	case ERROR_FILE_NOT_FOUND:              return TOOLKIT_ENOENT;
+	case ERROR_INVALID_NAME:                return TOOLKIT_ENOENT;
+	case ERROR_INVALID_DRIVE:               return TOOLKIT_ENOENT;
+	case ERROR_INVALID_REPARSE_DATA:        return TOOLKIT_ENOENT;
+	case ERROR_MOD_NOT_FOUND:               return TOOLKIT_ENOENT;
+	case ERROR_PATH_NOT_FOUND:              return TOOLKIT_ENOENT;
+	case WSAHOST_NOT_FOUND:                 return TOOLKIT_ENOENT;
+	case WSANO_DATA:                        return TOOLKIT_ENOENT;
+	case ERROR_NOT_ENOUGH_MEMORY:           return TOOLKIT_ENOMEM;
+	case ERROR_OUTOFMEMORY:                 return TOOLKIT_ENOMEM;
+	case ERROR_CANNOT_MAKE:                 return TOOLKIT_ENOSPC;
+	case ERROR_DISK_FULL:                   return TOOLKIT_ENOSPC;
+	case ERROR_EA_TABLE_FULL:               return TOOLKIT_ENOSPC;
+	case ERROR_END_OF_MEDIA:                return TOOLKIT_ENOSPC;
+	case ERROR_HANDLE_DISK_FULL:            return TOOLKIT_ENOSPC;
+	case ERROR_NOT_CONNECTED:               return TOOLKIT_ENOTCONN;
+	case WSAENOTCONN:                       return TOOLKIT_ENOTCONN;
+	case ERROR_DIR_NOT_EMPTY:               return TOOLKIT_ENOTEMPTY;
+	case WSAENOTSOCK:                       return TOOLKIT_ENOTSOCK;
+	case ERROR_NOT_SUPPORTED:               return TOOLKIT_ENOTSUP;
+	case ERROR_BROKEN_PIPE:                 return TOOLKIT_EOF;
+	case ERROR_ACCESS_DENIED:               return TOOLKIT_EPERM;
+	case ERROR_PRIVILEGE_NOT_HELD:          return TOOLKIT_EPERM;
+	case ERROR_BAD_PIPE:                    return TOOLKIT_EPIPE;
+	case ERROR_NO_DATA:                     return TOOLKIT_EPIPE;
+	case ERROR_PIPE_NOT_CONNECTED:          return TOOLKIT_EPIPE;
+	case WSAESHUTDOWN:                      return TOOLKIT_EPIPE;
+	case WSAEPROTONOSUPPORT:                return TOOLKIT_EPROTONOSUPPORT;
+	case ERROR_WRITE_PROTECT:               return TOOLKIT_EROFS;
+	case ERROR_SEM_TIMEOUT:                 return TOOLKIT_ETIMEDOUT;
+	case WSAETIMEDOUT:                      return TOOLKIT_ETIMEDOUT;
+	case ERROR_NOT_SAME_DEVICE:             return TOOLKIT_EXDEV;
+	case ERROR_INVALID_FUNCTION:            return TOOLKIT_EISDIR;
+	case ERROR_META_EXPANSION_TOO_LONG:     return TOOLKIT_E2BIG;
+	default:                                return TOOLKIT_UNKNOWN;
+	}
+}

libtoolkit/win/internal.h

@@ -0,0 +1,10 @@
+#ifndef _TOOLKIT_INTERNAL_H_
+#define _TOOLKIT_INTERNAL_H_
+
+int toolkit__convert_utf16_to_utf8(const WCHAR* utf16, int utf16len, char** utf8);
+int toolkit__convert_utf8_to_utf16(const char* utf8, int utf8len, WCHAR** utf16);
+
+
+uint64_t toolkit__hrtime(double scale);
+
+#endif /*_TOOLKIT_INTERNAL_H_*/

libtoolkit/win/library.c

@@ -0,0 +1,111 @@
+#include "toolkit.h"
+
+static int toolkit__dlerror(toolkit_lib_t* lib, const char* filename, DWORD errorno);
+
+int toolkit_dlopen(const char* filename, toolkit_lib_t* lib) 
+{
+	WCHAR filename_w[32768];
+
+	lib->handle = NULL;
+	lib->errmsg = NULL;
+
+	if (!MultiByteToWideChar(CP_UTF8,
+		0,
+		filename,
+		-1,
+		filename_w,
+		array_size(filename_w))) {
+		return toolkit__dlerror(lib, filename, GetLastError());
+	}
+
+	lib->handle = LoadLibraryExW(filename_w, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
+	if (lib->handle == NULL) {
+		return toolkit__dlerror(lib, filename, GetLastError());
+	}
+
+	return 0;
+}
+
+void toolkit_dlclose(toolkit_lib_t* lib) {
+	if (lib->errmsg) {
+		LocalFree((void*)lib->errmsg);
+		lib->errmsg = NULL;
+	}
+
+	if (lib->handle) {
+		/* Ignore errors. No good way to signal them without leaking memory. */
+		FreeLibrary(lib->handle);
+		lib->handle = NULL;
+	}
+}
+
+int toolkit_dlsym(toolkit_lib_t* lib, const char* name, void** ptr) 
+{
+	*ptr = (void*)(uintptr_t)GetProcAddress(lib->handle, name);
+	return toolkit__dlerror(lib, "", *ptr ? 0 : GetLastError());
+}
+
+const char* toolkit_dlerror(const toolkit_lib_t* lib)
+{
+	return lib->errmsg ? lib->errmsg : "no error";
+}
+
+static void toolkit__format_fallback_error(toolkit_lib_t* lib, int errorno) 
+{
+	static const CHAR fallback_error[] = "error: %1!d!";
+	DWORD_PTR args[1];
+	args[0] = (DWORD_PTR)errorno;
+
+	FormatMessageA(FORMAT_MESSAGE_FROM_STRING |
+		FORMAT_MESSAGE_ARGUMENT_ARRAY |
+		FORMAT_MESSAGE_ALLOCATE_BUFFER,
+		fallback_error, 0, 0,
+		(LPSTR)&lib->errmsg,
+		0, (va_list*)args);
+}
+
+static int toolkit__dlerror(toolkit_lib_t* lib, const char* filename, DWORD errorno) 
+{
+	DWORD_PTR arg;
+	DWORD res;
+	char* msg;
+
+	if (lib->errmsg) {
+		LocalFree(lib->errmsg);
+		lib->errmsg = NULL;
+	}
+
+	if (errorno == 0)
+		return 0;
+
+	res = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+		FORMAT_MESSAGE_FROM_SYSTEM |
+		FORMAT_MESSAGE_IGNORE_INSERTS, NULL, errorno,
+		MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
+		(LPSTR)&lib->errmsg, 0, NULL);
+
+	if (!res && (GetLastError() == ERROR_MUI_FILE_NOT_FOUND ||
+		GetLastError() == ERROR_RESOURCE_TYPE_NOT_FOUND)) {
+		res = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+			FORMAT_MESSAGE_FROM_SYSTEM |
+			FORMAT_MESSAGE_IGNORE_INSERTS, NULL, errorno,
+			0, (LPSTR)&lib->errmsg, 0, NULL);
+	}
+
+	if (res && errorno == ERROR_BAD_EXE_FORMAT && strstr(lib->errmsg, "%1")) {
+		msg = lib->errmsg;
+		lib->errmsg = NULL;
+		arg = (DWORD_PTR)filename;
+		res = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+			FORMAT_MESSAGE_ARGUMENT_ARRAY |
+			FORMAT_MESSAGE_FROM_STRING,
+			msg,
+			0, 0, (LPSTR)&lib->errmsg, 0, (va_list*)&arg);
+		LocalFree(msg);
+	}
+
+	if (!res)
+		toolkit__format_fallback_error(lib, errorno);
+
+	return -1;
+}

libtoolkit/win/misc.c

@@ -0,0 +1,237 @@
+#include "toolkit.h"
+#include "internal.h"
+#include <assert.h>
+
+/* Maximum environment variable size, including the terminating null */
+#define MAX_ENV_VAR_LENGTH 6092
+
+#define TOOLKIT__NANOSEC 1000000000
+
+static toolkit_once_t toolkit_init_guard_ = TOOLKIT_ONCE_INIT;
+
+/* Interval (in seconds) of the high-resolution clock. */
+static double hrtime_interval_ = 0;
+
+void toolkit__misc_init(void) 
+{
+    LARGE_INTEGER perf_frequency;
+    /* Retrieve high-resolution timer frequency
+     * and precompute its reciprocal.
+     */
+    if (QueryPerformanceFrequency(&perf_frequency)) {
+        hrtime_interval_ = 1.0 / perf_frequency.QuadPart;
+    }
+    else {
+        hrtime_interval_ = 0;
+    }
+}
+
+void toolkit__once_init(void) 
+{
+	toolkit_once(&toolkit_init_guard_, toolkit__misc_init);
+}
+
+int toolkit_os_environ(toolkit_env_item_t** envitems, int* count)
+{
+    wchar_t* env;
+    wchar_t* penv;
+    int i, cnt;
+    toolkit_env_item_t* envitem;
+
+    *envitems = NULL;
+    *count = 0;
+
+    env = GetEnvironmentStringsW();
+    if (env == NULL)
+        return 0;
+
+    for (penv = env, i = 0; *penv != L'\0'; penv += wcslen(penv) + 1, i++);
+
+    *envitems = ZCALLOC(i, sizeof(**envitems));
+    if (envitems == NULL) {
+        FreeEnvironmentStringsW(env);
+        return TOOLKIT_ENOMEM;
+    }
+
+    penv = env;
+    cnt = 0;
+
+    while (*penv != L'\0' && cnt < i) {
+        char* buf;
+        char* ptr;
+
+        if (toolkit__convert_utf16_to_utf8(penv, -1, &buf) != 0)
+            goto fail;
+
+        /* Using buf + 1 here because we know that `buf` has length at least 1,
+         * and some special environment variables on Windows start with a = sign. */
+        ptr = strchr(buf + 1, '=');
+        if (ptr == NULL) {
+            FREE(buf);
+            goto do_continue;
+        }
+
+        *ptr = '\0';
+
+        envitem = &(*envitems)[cnt];
+        envitem->name = buf;
+        envitem->value = ptr + 1;
+
+        cnt++;
+
+    do_continue:
+        penv += wcslen(penv) + 1;
+    }
+
+    FreeEnvironmentStringsW(env);
+
+    *count = cnt;
+    return 0;
+
+fail:
+    FreeEnvironmentStringsW(env);
+
+    for (i = 0; i < cnt; i++) {
+        envitem = &(*envitems)[cnt];
+        FREE(envitem->name);
+    }
+    FREE(*envitems);
+
+    *envitems = NULL;
+    *count = 0;
+    return TOOLKIT_ENOMEM;
+}
+
+int toolkit_os_getenv(const char* name, char* buffer, size_t* size) 
+{
+    wchar_t var[MAX_ENV_VAR_LENGTH];
+    wchar_t* name_w;
+    DWORD bufsize;
+    size_t len;
+    int r;
+
+    if (name == NULL || buffer == NULL || size == NULL || *size == 0)
+        return TOOLKIT_EINVAL;
+
+    r = toolkit__convert_utf8_to_utf16(name, -1, &name_w);
+
+    if (r != 0)
+        return r;
+
+    SetLastError(ERROR_SUCCESS);
+    len = GetEnvironmentVariableW(name_w, var, MAX_ENV_VAR_LENGTH);
+    FREE(name_w);
+    assert(len < MAX_ENV_VAR_LENGTH); /* len does not include the null */
+
+    if (len == 0) {
+        r = GetLastError();
+        if (r != ERROR_SUCCESS)
+            return toolkit_translate_sys_error(r);
+    }
+
+    /* Check how much space we need */
+    bufsize = WideCharToMultiByte(CP_UTF8, 0, var, -1, NULL, 0, NULL, NULL);
+
+    if (bufsize == 0) {
+        return toolkit_translate_sys_error(GetLastError());
+    }
+    else if (bufsize > * size) {
+        *size = bufsize;
+        return TOOLKIT_ENOBUFS;
+    }
+
+    /* Convert to UTF-8 */
+    bufsize = WideCharToMultiByte(CP_UTF8,
+        0,
+        var,
+        -1,
+        buffer,
+        *size,
+        NULL,
+        NULL);
+
+    if (bufsize == 0)
+        return toolkit_translate_sys_error(GetLastError());
+
+    *size = bufsize - 1;
+    return 0;
+}
+
+
+int toolkit_os_setenv(const char* name, const char* value) {
+    wchar_t* name_w;
+    wchar_t* value_w;
+    int r;
+
+    if (name == NULL || value == NULL)
+        return TOOLKIT_EINVAL;
+
+    r = toolkit__convert_utf8_to_utf16(name, -1, &name_w);
+
+    if (r != 0)
+        return r;
+
+    r = toolkit__convert_utf8_to_utf16(value, -1, &value_w);
+
+    if (r != 0) {
+        FREE(name_w);
+        return r;
+    }
+
+    r = SetEnvironmentVariableW(name_w, value_w);
+    FREE(name_w);
+    FREE(value_w);
+
+    if (r == 0)
+        return toolkit_translate_sys_error(GetLastError());
+
+    return 0;
+}
+
+
+int toolkit_os_unsetenv(const char* name) {
+    wchar_t* name_w;
+    int r;
+
+    if (name == NULL)
+        return TOOLKIT_EINVAL;
+
+    r = toolkit__convert_utf8_to_utf16(name, -1, &name_w);
+
+    if (r != 0)
+        return r;
+
+    r = SetEnvironmentVariableW(name_w, NULL);
+    FREE(name_w);
+
+    if (r == 0)
+        return toolkit_translate_sys_error(GetLastError());
+
+    return 0;
+}
+
+uint64_t toolkit_hrtime()
+{
+    toolkit__once_init();
+    return toolkit__hrtime(TOOLKIT__NANOSEC);
+}
+
+uint64_t toolkit__hrtime(double scale) 
+{
+    LARGE_INTEGER counter;
+
+    /* If the performance interval is zero, there's no support. */
+    if (hrtime_interval_ == 0) {
+        return 0;
+    }
+
+    if (!QueryPerformanceCounter(&counter)) {
+        return 0;
+    }
+
+    /* Because we have no guarantee about the order of magnitude of the
+     * performance counter interval, integer math could cause this computation
+     * to overflow. Therefore we resort to floating point math.
+     */
+    return (uint64_t)((double)counter.QuadPart * hrtime_interval_ * scale);
+}

libtoolkit/win/util.c

@@ -0,0 +1,99 @@
+#include "toolkit.h"
+#include "internal.h"
+
+/*
+ * Converts a UTF-16 string into a UTF-8 one. The resulting string is
+ * null-terminated.
+ *
+ * If utf16 is null terminated, utf16len can be set to -1, otherwise it must
+ * be specified.
+ */
+int toolkit__convert_utf16_to_utf8(const WCHAR* utf16, int utf16len, char** utf8) 
+{
+    DWORD bufsize;
+
+    if (utf16 == NULL)
+        return TOOLKIT_EINVAL;
+
+    /* Check how much space we need */
+    bufsize = WideCharToMultiByte(CP_UTF8,
+        0,
+        utf16,
+        utf16len,
+        NULL,
+        0,
+        NULL,
+        NULL);
+
+    if (bufsize == 0)
+        return toolkit_translate_sys_error(GetLastError());
+
+    /* Allocate the destination buffer adding an extra byte for the terminating
+     * NULL. If utf16len is not -1 WideCharToMultiByte will not add it, so
+     * we do it ourselves always, just in case. */
+    *utf8 = ZALLOC(bufsize + 1);
+
+    if (*utf8 == NULL)
+        return TOOLKIT_ENOMEM;
+
+    /* Convert to UTF-8 */
+    bufsize = WideCharToMultiByte(CP_UTF8,
+        0,
+        utf16,
+        utf16len,
+        *utf8,
+        bufsize,
+        NULL,
+        NULL);
+
+    if (bufsize == 0) {
+        FREE(*utf8);
+        *utf8 = NULL;
+        return toolkit_translate_sys_error(GetLastError());
+    }
+
+    (*utf8)[bufsize] = '\0';
+    return 0;
+}
+
+
+/*
+ * Converts a UTF-8 string into a UTF-16 one. The resulting string is
+ * null-terminated.
+ *
+ * If utf8 is null terminated, utf8len can be set to -1, otherwise it must
+ * be specified.
+ */
+int toolkit__convert_utf8_to_utf16(const char* utf8, int utf8len, WCHAR** utf16)
+{
+    int bufsize;
+
+    if (utf8 == NULL)
+        return TOOLKIT_EINVAL;
+
+    /* Check how much space we need */
+    bufsize = MultiByteToWideChar(CP_UTF8, 0, utf8, utf8len, NULL, 0);
+
+    if (bufsize == 0)
+        return toolkit_translate_sys_error(GetLastError());
+
+    /* Allocate the destination buffer adding an extra byte for the terminating
+     * NULL. If utf8len is not -1 MultiByteToWideChar will not add it, so
+     * we do it ourselves always, just in case. */
+    *utf16 = ZALLOC(sizeof(WCHAR) * (bufsize + 1));
+
+    if (*utf16 == NULL)
+        return TOOLKIT_ENOMEM;
+
+    /* Convert to UTF-16 */
+    bufsize = MultiByteToWideChar(CP_UTF8, 0, utf8, utf8len, *utf16, bufsize);
+
+    if (bufsize == 0) {
+        FREE(*utf16);
+        *utf16 = NULL;
+        return toolkit_translate_sys_error(GetLastError());
+    }
+
+    (*utf16)[bufsize] = L'\0';
+    return 0;
+}

libtoolkit/winfit.h

@@ -0,0 +1,20 @@
+#ifndef _TOOLKIT_WIN_FIT_H_
+#define _TOOLKIT_WIN_FIT_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+	static inline uint64_t get_tick_count() 
+	{
+		
+		/** nano sec to sec*/
+		return toolkit_hrtime() / 1000000;
+
+	}
+
+#ifdef __cplusplus
+} // extern "C" {
+#endif
+
+#endif // !_TOOLKIT_WIN_FIT_H_

module/include/mod_DevAdptEntityBase.hpp

@@ -8,9 +8,8 @@
 #include "DeviceBaseClass.h"
 #include "SimpleString.h"
 #include "path.h"
+#include "toolkit.h"
 #include <regex>
-#include <winpr/file.h>
-#include <winpr/environment.h>
 
 #define SAFE_FREE_LIBRARY(hModule)	\
 	do {							\
@@ -221,7 +220,7 @@ public:
 	}
 
 	ErrorCodeEnum ExtractVendorLibFullPath(CSimpleStringA& csLibFullPath);
-	ErrorCodeEnum InitializeVendorLogSwitch();
+	void InitializeVendorLogSwitch();
 private:
 
 	ErrorCodeEnum ExtractVendorLibName();
@@ -261,7 +260,7 @@ inline ErrorCodeEnum CDevAdptEntityBase::ExtractVendorLibFullPath(CSimpleStringA
 	return Error_Succeed;
 }
 
-inline ErrorCodeEnum CDevAdptEntityBase::InitializeVendorLogSwitch()
+inline void CDevAdptEntityBase::InitializeVendorLogSwitch()
 {
 	CSystemStaticInfo sysInfo;
 	GetFunction()->GetSystemStaticInfo(sysInfo);
@@ -275,10 +274,10 @@ inline ErrorCodeEnum CDevAdptEntityBase::InitializeVendorLogSwitch()
 		CSimpleStringA strLogPath;
 
 		void Settle() {
-			SetEnvironmentVariableA("VENDOR_RECODE_LEVEL", strLevel);
-			SetEnvironmentVariableA("VENDOR_RECODE_TYPE", strType);
-			SetEnvironmentVariableA("VENDOR_DLL_NAME", strDllName);
-			SetEnvironmentVariableA("VENDOR_LOG_PATH", strLogPath);
+			toolkit_os_setenv("VENDOR_RECODE_LEVEL", strLevel);
+			toolkit_os_setenv("VENDOR_RECODE_TYPE", strType);
+			toolkit_os_setenv("VENDOR_DLL_NAME", strDllName);
+			toolkit_os_setenv("VENDOR_LOG_PATH", strLogPath);
 		}
 
 	} stLogConfig = { "OFF" "FILE", m_libInfo.toLibNameString(), ""};