text: ﻿/*
   * Copyright: JessMA Open Source (ldcsaa@gmail.com)
   *
   * Author	: Bruce Liang
   * Website	: https://github.com/ldcsaa
   * Project	: https://github.com/ldcsaa/HP-Socket
   * Blog		: http://www.cnblogs.com/ldcsaa
   * Wiki		: http://www.oschina.net/p/hp-socket
   * QQ Group	: 44636872, 75375912
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  /******************************************************************************
  Module:  HPSocket for C
  
  Desc: 导出纯 C 函数，让其它语言（如：C / C# / Delphi 等）能方便地使用 HPSocket
  
  Usage:
  		方法一：
  		--------------------------------------------------------------------------------------
  		0. （C/C++ 程序）包含 HPTypeDef.h / HPSocket4C.h 头文件
  		1. 调用 ::Create_HP_XxxListener() 函数创建监听器对象
  		2. 调用 ::Create_HP_Xxx(pListener) 函数创建 HPSocket 对象
  		3. 调用 ::HP_Set_FN_Xxx_OnYyy(pListener, ...) 函数设置监听器的回调函数
  		4. 调用相关导出函数操作 HPSocket 对象
  		5. ...... ......
  		6. 调用 ::Destroy_HP_Xxx(pSocket) 函数销毁 HPSocket 对象
  		7. 调用 ::Destroy_HP_XxxListener(pListener) 函数销毁监听器对象
  
  		方法二：
  		--------------------------------------------------------------------------------------
  		1. 应用程序把需要用到的导出函数封装到特定语言的包装类中
  		2. 通过包装类封装后，以面向对象的方式使用 HPSocket
  
  Release:
  		<-- 动态链接库 -->
  		1. x86/HPSocket4C.dll			- (32位/MBCS/Release)
  		2. x86/HPSocket4C_D.dll			- (32位/MBCS/DeBug)
  		3. x86/HPSocket4C_U.dll			- (32位/UNICODE/Release)
  		4. x86/HPSocket4C_UD.dll		- (32位/UNICODE/DeBug)
  		5. x64/HPSocket4C.dll			- (64位/MBCS/Release)
  		6. x64/HPSocket4C_D.dll			- (64位/MBCS/DeBug)
  		7. x64/HPSocket4C_U.dll			- (64位/UNICODE/Release)
  		8. x64/HPSocket4C_UD.dll		- (64位/UNICODE/DeBug)
  
  		<-- 静态链接库 -->
  		!!注意!!：使用 HPSocket 静态库时，需要在工程属性中定义预处理宏 -> HPSOCKET_STATIC_LIB
  		1. x86/static/HPSocket4C.lib	- (32位/MBCS/Release)
  		2. x86/static/HPSocket4C_D.lib	- (32位/MBCS/DeBug)
  		3. x86/static/HPSocket4C_U.lib	- (32位/UNICODE/Release)
  		4. x86/static/HPSocket4C_UD.lib	- (32位/UNICODE/DeBug)
  		5. x64/static/HPSocket4C.lib	- (64位/MBCS/Release)
  		6. x64/static/HPSocket4C_D.lib	- (64位/MBCS/DeBug)
  		7. x64/static/HPSocket4C_U.lib	- (64位/UNICODE/Release)
  		8. x64/static/HPSocket4C_UD.lib	- (64位/UNICODE/DeBug)
  
  ******************************************************************************/
  
  #pragma once
  
  #include <winsock2.h>
  
  #include "HPTypeDef.h"
  
  /************************************************************************
  名称：定义 Socket 对象指针类型别名
  描述：把 Socket 对象指针定义为更直观的别名
  ************************************************************************/
  
  typedef PVOID		HP_Object;
  
  typedef HP_Object	HP_Server;
  typedef HP_Object	HP_Agent;
  typedef HP_Object	HP_Client;
  typedef HP_Object	HP_Node;
  typedef HP_Object	HP_TcpServer;
  typedef HP_Object	HP_TcpAgent;
  typedef HP_Object	HP_TcpClient;
  typedef HP_Object	HP_PullSocket;
  typedef HP_Object	HP_PullClient;
  typedef HP_Object	HP_TcpPullServer;
  typedef HP_Object	HP_TcpPullAgent;
  typedef HP_Object	HP_TcpPullClient;
  typedef HP_Object	HP_PackSocket;
  typedef HP_Object	HP_PackClient;
  typedef HP_Object	HP_TcpPackServer;
  typedef HP_Object	HP_TcpPackAgent;
  typedef HP_Object	HP_TcpPackClient;
  
  typedef HP_Object	HP_Listener;
  typedef HP_Object	HP_ServerListener;
  typedef HP_Object	HP_AgentListener;
  typedef HP_Object	HP_ClientListener;
  typedef HP_Object	HP_TcpServerListener;
  typedef HP_Object	HP_TcpAgentListener;
  typedef HP_Object	HP_TcpClientListener;
  typedef HP_Object	HP_PullSocketListener;
  typedef HP_Object	HP_PullClientListener;
  typedef HP_Object	HP_TcpPullServerListener;
  typedef HP_Object	HP_TcpPullAgentListener;
  typedef HP_Object	HP_TcpPullClientListener;
  typedef HP_Object	HP_PackSocketListener;
  typedef HP_Object	HP_PackClientListener;
  typedef HP_Object	HP_TcpPackServerListener;
  typedef HP_Object	HP_TcpPackAgentListener;
  typedef HP_Object	HP_TcpPackClientListener;
  
  #ifdef _UDP_SUPPORT
  
  typedef HP_Object	HP_UdpServer;
  typedef HP_Object	HP_UdpClient;
  typedef HP_Object	HP_UdpCast;
  typedef HP_Object	HP_UdpNode;
  typedef HP_Object	HP_UdpArqServer;
  typedef HP_Object	HP_UdpArqClient;
  
  typedef HP_Object	HP_UdpServerListener;
  typedef HP_Object	HP_UdpClientListener;
  typedef HP_Object	HP_UdpCastListener;
  typedef HP_Object	HP_UdpNodeListener;
  typedef HP_Object	HP_UdpArqServerListener;
  typedef HP_Object	HP_UdpArqClientListener;
  
  #endif
  
  typedef HP_Object	HP_Http;
  typedef HP_Object	HP_HttpServer;
  typedef HP_Object	HP_HttpAgent;
  typedef HP_Object	HP_HttpClient;
  typedef HP_Object	HP_HttpSyncClient;
  
  typedef HP_Object	HP_HttpServerListener;
  typedef HP_Object	HP_HttpAgentListener;
  typedef HP_Object	HP_HttpClientListener;
  
  typedef HP_Object	HP_ThreadPool;
  
  /*****************************************************************************************************************************************************/
  /****************************************************************** TCP/UDP Exports ******************************************************************/
  /*****************************************************************************************************************************************************/
  
  /****************************************************/
  /***************** TCP/UDP 回调函数 ******************/
  
  /* Server 回调函数 */
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Server_OnPrepareListen)	(HP_Server pSender, UINT_PTR soListen);
  // 如果为 TCP 连接，pClient为 SOCKET 句柄；如果为 UDP 连接，pClient为 SOCKADDR 指针；
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Server_OnAccept)			(HP_Server pSender, HP_CONNID dwConnID, UINT_PTR pClient);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Server_OnHandShake)		(HP_Server pSender, HP_CONNID dwConnID);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Server_OnSend)				(HP_Server pSender, HP_CONNID dwConnID, const BYTE* pData, int iLength);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Server_OnReceive)			(HP_Server pSender, HP_CONNID dwConnID, const BYTE* pData, int iLength);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Server_OnPullReceive)		(HP_Server pSender, HP_CONNID dwConnID, int iLength);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Server_OnClose)			(HP_Server pSender, HP_CONNID dwConnID, En_HP_SocketOperation enOperation, int iErrorCode);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Server_OnShutdown)			(HP_Server pSender);
  
  /* Agent 回调函数 */
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Agent_OnPrepareConnect)	(HP_Agent pSender, HP_CONNID dwConnID, UINT_PTR socket);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Agent_OnConnect)			(HP_Agent pSender, HP_CONNID dwConnID);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Agent_OnHandShake)			(HP_Agent pSender, HP_CONNID dwConnID);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Agent_OnSend)				(HP_Agent pSender, HP_CONNID dwConnID, const BYTE* pData, int iLength);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Agent_OnReceive)			(HP_Agent pSender, HP_CONNID dwConnID, const BYTE* pData, int iLength);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Agent_OnPullReceive)		(HP_Agent pSender, HP_CONNID dwConnID, int iLength);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Agent_OnClose)				(HP_Agent pSender, HP_CONNID dwConnID, En_HP_SocketOperation enOperation, int iErrorCode);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Agent_OnShutdown)			(HP_Agent pSender);
  
  /* Client 回调函数 */
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Client_OnPrepareConnect)	(HP_Client pSender, HP_CONNID dwConnID, UINT_PTR socket);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Client_OnConnect)			(HP_Client pSender, HP_CONNID dwConnID);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Client_OnHandShake)		(HP_Client pSender, HP_CONNID dwConnID);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Client_OnSend)				(HP_Client pSender, HP_CONNID dwConnID, const BYTE* pData, int iLength);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Client_OnReceive)			(HP_Client pSender, HP_CONNID dwConnID, const BYTE* pData, int iLength);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Client_OnPullReceive)		(HP_Client pSender, HP_CONNID dwConnID, int iLength);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_Client_OnClose)			(HP_Client pSender, HP_CONNID dwConnID, En_HP_SocketOperation enOperation, int iErrorCode);
  
  #ifdef _UDP_SUPPORT
  
  /* UdpNode 回调函数 */
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_UdpNode_OnPrepareListen)	(HP_UdpNode pSender, UINT_PTR soListen);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_UdpNode_OnSend)			(HP_UdpNode pSender, LPCTSTR lpszRemoteAddress, USHORT usRemotePort, const BYTE* pData, int iLength);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_UdpNode_OnReceive)			(HP_UdpNode pSender, LPCTSTR lpszRemoteAddress, USHORT usRemotePort, const BYTE* pData, int iLength);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_UdpNode_OnError)			(HP_UdpNode pSender, En_HP_SocketOperation enOperation, int iErrorCode, LPCTSTR lpszRemoteAddress, USHORT usRemotePort, const BYTE* pData, int iLength);
  typedef En_HP_HandleResult (__HP_CALL *HP_FN_UdpNode_OnShutdown)		(HP_UdpNode pSender);
  
  #endif
  
  /****************************************************/
  /*************** TCP/UDP 对象创建函数 ****************/
  
  // 创建 HP_TcpServer 对象
  HPSOCKET_API HP_TcpServer __HP_CALL Create_HP_TcpServer(HP_TcpServerListener pListener);
  // 创建 HP_TcpAgent 对象
  HPSOCKET_API HP_TcpAgent __HP_CALL Create_HP_TcpAgent(HP_TcpAgentListener pListener);
  // 创建 HP_TcpClient 对象
  HPSOCKET_API HP_TcpClient __HP_CALL Create_HP_TcpClient(HP_TcpClientListener pListener);
  // 创建 HP_TcpPullServer 对象
  HPSOCKET_API HP_TcpPullServer __HP_CALL Create_HP_TcpPullServer(HP_TcpPullServerListener pListener);
  // 创建 HP_TcpPullAgent 对象
  HPSOCKET_API HP_TcpPullAgent __HP_CALL Create_HP_TcpPullAgent(HP_TcpPullAgentListener pListener);
  // 创建 HP_TcpPullClient 对象
  HPSOCKET_API HP_TcpPullClient __HP_CALL Create_HP_TcpPullClient(HP_TcpPullClientListener pListener);
  // 创建 HP_TcpPackServer 对象
  HPSOCKET_API HP_TcpPackServer __HP_CALL Create_HP_TcpPackServer(HP_TcpServerListener pListener);
  // 创建 HP_TcpPackAgent 对象
  HPSOCKET_API HP_TcpPackAgent __HP_CALL Create_HP_TcpPackAgent(HP_TcpAgentListener pListener);
  // 创建 HP_TcpPackClient 对象
  HPSOCKET_API HP_TcpPackClient __HP_CALL Create_HP_TcpPackClient(HP_TcpClientListener pListener);
  
  // 销毁 HP_TcpServer 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_TcpServer(HP_TcpServer pServer);
  // 销毁 HP_TcpAgent 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_TcpAgent(HP_TcpAgent pAgent);
  // 销毁 HP_TcpClient 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_TcpClient(HP_TcpClient pClient);
  // 销毁 HP_TcpPullServer 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_TcpPullServer(HP_TcpPullServer pServer);
  // 销毁 HP_TcpPullAgent 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_TcpPullAgent(HP_TcpPullAgent pAgent);
  // 销毁 HP_TcpPullClient 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_TcpPullClient(HP_TcpPullClient pClient);
  // 销毁 HP_TcpPackServer 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_TcpPackServer(HP_TcpPackServer pServer);
  // 销毁 HP_TcpPackAgent 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_TcpPackAgent(HP_TcpPackAgent pAgent);
  // 销毁 HP_TcpPackClient 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_TcpPackClient(HP_TcpPackClient pClient);
  
  // 创建 HP_TcpServerListener 对象
  HPSOCKET_API HP_TcpServerListener __HP_CALL Create_HP_TcpServerListener();
  // 创建 HP_TcpAgentListener 对象
  HPSOCKET_API HP_TcpAgentListener __HP_CALL Create_HP_TcpAgentListener();
  // 创建 HP_TcpClientListener 对象
  HPSOCKET_API HP_TcpClientListener __HP_CALL Create_HP_TcpClientListener();
  // 创建 HP_TcpPullServerListener 对象
  HPSOCKET_API HP_TcpPullServerListener __HP_CALL Create_HP_TcpPullServerListener();
  // 创建 HP_TcpPullAgentListener 对象
  HPSOCKET_API HP_TcpPullAgentListener __HP_CALL Create_HP_TcpPullAgentListener();
  // 创建 HP_TcpPullClientListener 对象
  HPSOCKET_API HP_TcpPullClientListener __HP_CALL Create_HP_TcpPullClientListener();
  // 创建 HP_TcpPackServerListener 对象
  HPSOCKET_API HP_TcpPackServerListener __HP_CALL Create_HP_TcpPackServerListener();
  // 创建 HP_TcpPackAgentListener 对象
  HPSOCKET_API HP_TcpPackAgentListener __HP_CALL Create_HP_TcpPackAgentListener();
  // 创建 HP_TcpPackClientListener 对象
  HPSOCKET_API HP_TcpPackClientListener __HP_CALL Create_HP_TcpPackClientListener();
  
  // 销毁 HP_TcpServerListener 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_TcpServerListener(HP_TcpServerListener pListener);
  // 销毁 HP_TcpAgentListener 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_TcpAgentListener(HP_TcpAgentListener pListener);
  // 销毁 HP_TcpClientListener 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_TcpClientListener(HP_TcpClientListener pListener);
  // 销毁 HP_TcpPullServerListener 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_TcpPullServerListener(HP_TcpPullServerListener pListener);
  // 销毁 HP_TcpPullAgentListener 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_TcpPullAgentListener(HP_TcpPullAgentListener pListener);
  // 销毁 HP_TcpPullClientListener 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_TcpPullClientListener(HP_TcpPullClientListener pListener);
  // 销毁 HP_TcpPackServerListener 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_TcpPackServerListener(HP_TcpPackServerListener pListener);
  // 销毁 HP_TcpPackAgentListener 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_TcpPackAgentListener(HP_TcpPackAgentListener pListener);
  // 销毁 HP_TcpPackClientListener 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_TcpPackClientListener(HP_TcpPackClientListener pListener);
  
  #ifdef _UDP_SUPPORT
  
  // 创建 HP_UdpServer 对象
  HPSOCKET_API HP_UdpServer __HP_CALL Create_HP_UdpServer(HP_UdpServerListener pListener);
  // 创建 HP_UdpClient 对象
  HPSOCKET_API HP_UdpClient __HP_CALL Create_HP_UdpClient(HP_UdpClientListener pListener);
  // 创建 HP_UdpCast 对象
  HPSOCKET_API HP_UdpCast __HP_CALL Create_HP_UdpCast(HP_UdpCastListener pListener);
  // 创建 HP_UdpNode 对象
  HPSOCKET_API HP_UdpNode __HP_CALL Create_HP_UdpNode(HP_UdpNodeListener pListener);
  // 创建 HP_UdpArqServer 对象
  HPSOCKET_API HP_UdpArqServer __HP_CALL Create_HP_UdpArqServer(HP_UdpServerListener pListener);
  // 创建 HP_UdpArqClient 对象
  HPSOCKET_API HP_UdpArqClient __HP_CALL Create_HP_UdpArqClient(HP_UdpClientListener pListener);
  
  // 销毁 HP_UdpServer 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_UdpServer(HP_UdpServer pServer);
  // 销毁 HP_UdpClient 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_UdpClient(HP_UdpClient pClient);
  // 销毁 HP_UdpCast 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_UdpCast(HP_UdpCast pCast);
  // 销毁 HP_UdpNode 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_UdpNode(HP_UdpNode pNode);
  // 销毁 HP_UdpArqServer 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_UdpArqServer(HP_UdpArqServer pServer);
  // 销毁 HP_UdpArqClient 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_UdpArqClient(HP_UdpArqClient pClient);
  
  // 创建 HP_UdpServerListener 对象
  HPSOCKET_API HP_UdpServerListener __HP_CALL Create_HP_UdpServerListener();
  // 创建 HP_UdpClientListener 对象
  HPSOCKET_API HP_UdpClientListener __HP_CALL Create_HP_UdpClientListener();
  // 创建 HP_UdpCastListener 对象
  HPSOCKET_API HP_UdpCastListener __HP_CALL Create_HP_UdpCastListener();
  // 创建 HP_UdpNodeListener 对象
  HPSOCKET_API HP_UdpNodeListener __HP_CALL Create_HP_UdpNodeListener();
  // 创建 HP_UdpArqServerListener 对象
  HPSOCKET_API HP_UdpArqServerListener __HP_CALL Create_HP_UdpArqServerListener();
  // 创建 HP_UdpArqClientListener 对象
  HPSOCKET_API HP_UdpArqClientListener __HP_CALL Create_HP_UdpArqClientListener();
  
  // 销毁 HP_UdpServerListener 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_UdpServerListener(HP_UdpServerListener pListener);
  // 销毁 HP_UdpClientListener 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_UdpClientListener(HP_UdpClientListener pListener);
  // 销毁 HP_UdpCastListener 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_UdpCastListener(HP_UdpCastListener pListener);
  // 销毁 HP_UdpNodeListener 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_UdpNodeListener(HP_UdpNodeListener pListener);
  // 销毁 HP_UdpArqServerListener 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_UdpArqServerListener(HP_UdpArqServerListener pListener);
  // 销毁 HP_UdpArqClientListener 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_UdpArqClientListener(HP_UdpArqClientListener pListener);
  
  #endif
  
  /**********************************************************************************/
  /***************************** Server 回调函数设置方法 *****************************/
  
  HPSOCKET_API void __HP_CALL HP_Set_FN_Server_OnPrepareListen(HP_ServerListener pListener	, HP_FN_Server_OnPrepareListen fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_Server_OnAccept(HP_ServerListener pListener			, HP_FN_Server_OnAccept fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_Server_OnHandShake(HP_ServerListener pListener		, HP_FN_Server_OnHandShake fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_Server_OnSend(HP_ServerListener pListener				, HP_FN_Server_OnSend fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_Server_OnReceive(HP_ServerListener pListener			, HP_FN_Server_OnReceive fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_Server_OnPullReceive(HP_ServerListener pListener		, HP_FN_Server_OnPullReceive fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_Server_OnClose(HP_ServerListener pListener			, HP_FN_Server_OnClose fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_Server_OnShutdown(HP_ServerListener pListener			, HP_FN_Server_OnShutdown fn);
  
  /**********************************************************************************/
  /****************************** Agent 回调函数设置方法 *****************************/
  
  HPSOCKET_API void __HP_CALL HP_Set_FN_Agent_OnPrepareConnect(HP_AgentListener pListener		, HP_FN_Agent_OnPrepareConnect fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_Agent_OnConnect(HP_AgentListener pListener			, HP_FN_Agent_OnConnect fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_Agent_OnHandShake(HP_AgentListener pListener			, HP_FN_Agent_OnHandShake fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_Agent_OnSend(HP_AgentListener pListener				, HP_FN_Agent_OnSend fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_Agent_OnReceive(HP_AgentListener pListener			, HP_FN_Agent_OnReceive fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_Agent_OnPullReceive(HP_AgentListener pListener		, HP_FN_Agent_OnPullReceive fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_Agent_OnClose(HP_AgentListener pListener				, HP_FN_Agent_OnClose fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_Agent_OnShutdown(HP_AgentListener pListener			, HP_FN_Agent_OnShutdown fn);
  
  /**********************************************************************************/
  /***************************** Client 回调函数设置方法 *****************************/
  
  HPSOCKET_API void __HP_CALL HP_Set_FN_Client_OnPrepareConnect(HP_ClientListener pListener	, HP_FN_Client_OnPrepareConnect fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_Client_OnConnect(HP_ClientListener pListener			, HP_FN_Client_OnConnect fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_Client_OnHandShake(HP_ClientListener pListener		, HP_FN_Client_OnHandShake fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_Client_OnSend(HP_ClientListener pListener				, HP_FN_Client_OnSend fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_Client_OnReceive(HP_ClientListener pListener			, HP_FN_Client_OnReceive fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_Client_OnPullReceive(HP_ClientListener pListener		, HP_FN_Client_OnPullReceive fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_Client_OnClose(HP_ClientListener pListener			, HP_FN_Client_OnClose fn);
  
  #ifdef _UDP_SUPPORT
  
  /**********************************************************************************/
  /***************************** UdpNode 回调函数设置方法 *****************************/
  
  HPSOCKET_API void __HP_CALL HP_Set_FN_UdpNode_OnPrepareListen(HP_UdpNodeListener pListener	, HP_FN_UdpNode_OnPrepareListen fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_UdpNode_OnSend(HP_UdpNodeListener pListener			, HP_FN_UdpNode_OnSend fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_UdpNode_OnReceive(HP_UdpNodeListener pListener		, HP_FN_UdpNode_OnReceive fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_UdpNode_OnError(HP_UdpNodeListener pListener			, HP_FN_UdpNode_OnError fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_UdpNode_OnShutdown(HP_UdpNodeListener pListener		, HP_FN_UdpNode_OnShutdown fn);
  
  #endif
  
  /**************************************************************************/
  /***************************** Server 操作方法 *****************************/
  
  /*
  * 名称：启动通信组件
  * 描述：启动服务端通信组件，启动完成后可开始接收客户端连接并收发数据
  *		
  * 参数：		lpszBindAddress	-- 监听地址
  *			usPort			-- 监听端口
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 HP_Server_GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Server_Start(HP_Server pServer, LPCTSTR lpszBindAddress, USHORT usPort);
  
  /*
  * 名称：关闭通信组件
  * 描述：关闭服务端通信组件，关闭完成后断开所有客户端连接并释放所有资源
  *		
  * 参数：	
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 HP_Server_GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Server_Stop(HP_Server pServer);
  
  /*
  * 名称：等待
  * 描述：等待通信组件停止运行
  *		
  * 参数：		dwMilliseconds	-- 超时时间（毫秒，默认：-1，永不超时）
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Server_Wait(HP_Server pServer, DWORD dwMilliseconds);
  
  /*
  * 名称：发送数据
  * 描述：向指定连接发送数据
  *		
  * 参数：		dwConnID	-- 连接 ID
  *			pBuffer		-- 发送缓冲区
  *			iLength		-- 发送缓冲区长度
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取 Windows 错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Server_Send(HP_Server pServer, HP_CONNID dwConnID, const BYTE* pBuffer, int iLength);
  
  /*
  * 名称：发送数据
  * 描述：向指定连接发送数据
  *		
  * 参数：		dwConnID	-- 连接 ID
  *			pBuffer		-- 发送缓冲区
  *			iLength		-- 发送缓冲区长度
  *			iOffset		-- 发送缓冲区指针偏移量
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取 Windows 错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Server_SendPart(HP_Server pServer, HP_CONNID dwConnID, const BYTE* pBuffer, int iLength, int iOffset);
  
  /*
  * 名称：发送多组数据
  * 描述：向指定连接发送多组数据
  *		TCP - 顺序发送所有数据包 
  *		UDP - 把所有数据包组合成一个数据包发送（数据包的总长度不能大于设置的 UDP 包最大长度） 
  *		
  * 参数：		dwConnID	-- 连接 ID
  *			pBuffers	-- 发送缓冲区数组
  *			iCount		-- 发送缓冲区数目
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取 Windows 错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Server_SendPackets(HP_Server pServer, HP_CONNID dwConnID, const WSABUF pBuffers[], int iCount);
  
  /*
  * 名称：暂停/恢复接收
  * 描述：暂停/恢复某个连接的数据接收工作
  *		
  * 参数：		dwConnID	-- 连接 ID
  *			bPause		-- TRUE - 暂停, FALSE - 恢复
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_Server_PauseReceive(HP_Server pServer, HP_CONNID dwConnID, BOOL bPause);
  
  /*
  * 名称：断开连接
  * 描述：断开与某个客户端的连接
  *		
  * 参数：		dwConnID	-- 连接 ID
  *			bForce		-- 是否强制断开连接
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_Server_Disconnect(HP_Server pServer, HP_CONNID dwConnID, BOOL bForce);
  
  /*
  * 名称：断开超时连接
  * 描述：断开超过指定时长的连接
  *		
  * 参数：		dwPeriod	-- 时长（毫秒）
  *			bForce		-- 是否强制断开连接
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_Server_DisconnectLongConnections(HP_Server pServer, DWORD dwPeriod, BOOL bForce);
  
  /*
  * 名称：断开静默连接
  * 描述：断开超过指定时长的静默连接
  *		
  * 参数：		dwPeriod	-- 时长（毫秒）
  *			bForce		-- 是否强制断开连接
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_Server_DisconnectSilenceConnections(HP_Server pServer, DWORD dwPeriod, BOOL bForce);
  
  /******************************************************************************/
  /***************************** Server 属性访问方法 *****************************/
  
  /*
  * 名称：设置连接的附加数据
  * 描述：是否为连接绑定附加数据或者绑定什么样的数据，均由应用程序只身决定
  *		
  * 参数：		dwConnID	-- 连接 ID
  *			pv			-- 数据
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败（无效的连接 ID）
  */
  HPSOCKET_API BOOL __HP_CALL HP_Server_SetConnectionExtra(HP_Server pServer, HP_CONNID dwConnID, PVOID pExtra);
  
  /*
  * 名称：获取连接的附加数据
  * 描述：是否为连接绑定附加数据或者绑定什么样的数据，均由应用程序只身决定
  *		
  * 参数：		dwConnID	-- 连接 ID
  *			ppv			-- 数据指针
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败（无效的连接 ID）
  */
  HPSOCKET_API BOOL __HP_CALL HP_Server_GetConnectionExtra(HP_Server pServer, HP_CONNID dwConnID, PVOID* ppExtra);
  
  /* 检测是否为安全连接（SSL/HTTPS） */
  HPSOCKET_API BOOL __HP_CALL HP_Server_IsSecure(HP_Server pServer);
  /* 检查通信组件是否已启动 */
  HPSOCKET_API BOOL __HP_CALL HP_Server_HasStarted(HP_Server pServer);
  /* 查看通信组件当前状态 */
  HPSOCKET_API En_HP_ServiceState __HP_CALL HP_Server_GetState(HP_Server pServer);
  /* 获取最近一次失败操作的错误代码 */
  HPSOCKET_API En_HP_SocketError __HP_CALL HP_Server_GetLastError(HP_Server pServer);
  /* 获取最近一次失败操作的错误描述 */
  HPSOCKET_API LPCTSTR __HP_CALL HP_Server_GetLastErrorDesc(HP_Server pServer);
  /* 获取连接中未发出数据的长度 */
  HPSOCKET_API BOOL __HP_CALL HP_Server_GetPendingDataLength(HP_Server pServer, HP_CONNID dwConnID, int* piPending);
  /* 获取连接的数据接收状态 */
  HPSOCKET_API BOOL __HP_CALL HP_Server_IsPauseReceive(HP_Server pServer, HP_CONNID dwConnID, BOOL* pbPaused);
  /* 检测是否有效连接 */
  HPSOCKET_API BOOL __HP_CALL HP_Server_IsConnected(HP_Server pServer, HP_CONNID dwConnID);
  /* 获取客户端连接数 */
  HPSOCKET_API DWORD __HP_CALL HP_Server_GetConnectionCount(HP_Server pServer);
  /* 获取所有连接的 HP_CONNID */
  HPSOCKET_API BOOL __HP_CALL HP_Server_GetAllConnectionIDs(HP_Server pServer, HP_CONNID pIDs[], DWORD* pdwCount);
  /* 获取某个客户端连接时长（毫秒） */
  HPSOCKET_API BOOL __HP_CALL HP_Server_GetConnectPeriod(HP_Server pServer, HP_CONNID dwConnID, DWORD* pdwPeriod);
  /* 获取某个连接静默时间（毫秒） */
  HPSOCKET_API BOOL __HP_CALL HP_Server_GetSilencePeriod(HP_Server pServer, HP_CONNID dwConnID, DWORD* pdwPeriod);
  /* 获取监听 Socket 的地址信息 */
  HPSOCKET_API BOOL __HP_CALL HP_Server_GetListenAddress(HP_Server pServer, TCHAR lpszAddress[], int* piAddressLen, USHORT* pusPort);
  /* 获取某个连接的本地地址信息 */
  HPSOCKET_API BOOL __HP_CALL HP_Server_GetLocalAddress(HP_Server pServer, HP_CONNID dwConnID, TCHAR lpszAddress[], int* piAddressLen, USHORT* pusPort);
  /* 获取某个连接的远程地址信息 */
  HPSOCKET_API BOOL __HP_CALL HP_Server_GetRemoteAddress(HP_Server pServer, HP_CONNID dwConnID, TCHAR lpszAddress[], int* piAddressLen, USHORT* pusPort);
  
  /* 设置地址重用选项 */
  HPSOCKET_API void __HP_CALL HP_Server_SetReuseAddressPolicy(HP_Server pServer, En_HP_ReuseAddressPolicy enReusePolicy);
  /* 设置数据发送策略 */
  HPSOCKET_API void __HP_CALL HP_Server_SetSendPolicy(HP_Server pServer, En_HP_SendPolicy enSendPolicy);
  /* 设置 OnSend 事件同步策略（默认：OSSP_NONE，不同步） */
  HPSOCKET_API void __HP_CALL HP_Server_SetOnSendSyncPolicy(HP_Server pServer, En_HP_OnSendSyncPolicy enSyncPolicy);
  /* 设置 Socket 缓存对象锁定时间（毫秒，在锁定期间该 Socket 缓存对象不能被获取使用） */
  HPSOCKET_API void __HP_CALL HP_Server_SetFreeSocketObjLockTime(HP_Server pServer, DWORD dwFreeSocketObjLockTime);
  /* 设置 Socket 缓存池大小（通常设置为平均并发连接数量的 1/3 - 1/2） */
  HPSOCKET_API void __HP_CALL HP_Server_SetFreeSocketObjPool(HP_Server pServer, DWORD dwFreeSocketObjPool);
  /* 设置内存块缓存池大小（通常设置为 Socket 缓存池大小的 2 - 3 倍） */
  HPSOCKET_API void __HP_CALL HP_Server_SetFreeBufferObjPool(HP_Server pServer, DWORD dwFreeBufferObjPool);
  /* 设置 Socket 缓存池回收阀值（通常设置为 Socket 缓存池大小的 3 倍） */
  HPSOCKET_API void __HP_CALL HP_Server_SetFreeSocketObjHold(HP_Server pServer, DWORD dwFreeSocketObjHold);
  /* 设置内存块缓存池回收阀值（通常设置为内存块缓存池大小的 3 倍） */
  HPSOCKET_API void __HP_CALL HP_Server_SetFreeBufferObjHold(HP_Server pServer, DWORD dwFreeBufferObjHold);
  /* 设置最大连接数（组件会根据设置值预分配内存，因此需要根据实际情况设置，不宜过大）*/
  HPSOCKET_API void __HP_CALL HP_Server_SetMaxConnectionCount(HP_Server pServer, DWORD dwMaxConnectionCount);
  /* 设置工作线程数量（通常设置为 2 * CPU + 2） */
  HPSOCKET_API void __HP_CALL HP_Server_SetWorkerThreadCount(HP_Server pServer, DWORD dwWorkerThreadCount);
  /* 设置是否标记静默时间（设置为 TRUE 时 DisconnectSilenceConnections() 和 GetSilencePeriod() 才有效，默认：TRUE） */
  HPSOCKET_API void __HP_CALL HP_Server_SetMarkSilence(HP_Server pServer, BOOL bMarkSilence);
  
  /* 获取地址重用选项 */
  HPSOCKET_API En_HP_ReuseAddressPolicy __HP_CALL HP_Server_GetReuseAddressPolicy(HP_Server pServer);
  /* 获取数据发送策略 */
  HPSOCKET_API En_HP_SendPolicy __HP_CALL HP_Server_GetSendPolicy(HP_Server pServer);
  /* 获取 OnSend 事件同步策略 */
  HPSOCKET_API En_HP_OnSendSyncPolicy __HP_CALL HP_Server_GetOnSendSyncPolicy(HP_Server pServer);
  /* 获取 Socket 缓存对象锁定时间 */
  HPSOCKET_API DWORD __HP_CALL HP_Server_GetFreeSocketObjLockTime(HP_Server pServer);
  /* 获取 Socket 缓存池大小 */
  HPSOCKET_API DWORD __HP_CALL HP_Server_GetFreeSocketObjPool(HP_Server pServer);
  /* 获取内存块缓存池大小 */
  HPSOCKET_API DWORD __HP_CALL HP_Server_GetFreeBufferObjPool(HP_Server pServer);
  /* 获取 Socket 缓存池回收阀值 */
  HPSOCKET_API DWORD __HP_CALL HP_Server_GetFreeSocketObjHold(HP_Server pServer);
  /* 获取内存块缓存池回收阀值 */
  HPSOCKET_API DWORD __HP_CALL HP_Server_GetFreeBufferObjHold(HP_Server pServer);
  /* 获取最大连接数 */
  HPSOCKET_API DWORD __HP_CALL HP_Server_GetMaxConnectionCount(HP_Server pServer);
  /* 获取工作线程数量 */
  HPSOCKET_API DWORD __HP_CALL HP_Server_GetWorkerThreadCount(HP_Server pServer);
  /* 检测是否标记静默时间 */
  HPSOCKET_API BOOL __HP_CALL HP_Server_IsMarkSilence(HP_Server pServer);
  
  /**********************************************************************************/
  /******************************* TCP Server 操作方法 *******************************/
  
  /*
  * 名称：发送小文件
  * 描述：向指定连接发送 4096 KB 以下的小文件
  *		
  * 参数：		dwConnID		-- 连接 ID
  *			lpszFileName	-- 文件路径
  *			pHead			-- 头部附加数据
  *			pTail			-- 尾部附加数据
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取 Windows 错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_TcpServer_SendSmallFile(HP_Server pServer, HP_CONNID dwConnID, LPCTSTR lpszFileName, const LPWSABUF pHead, const LPWSABUF pTail);
  
  /**********************************************************************************/
  /***************************** TCP Server 属性访问方法 *****************************/
  
  /* 设置监听 Socket 的等候队列大小（根据并发连接数量调整设置） */
  HPSOCKET_API void __HP_CALL HP_TcpServer_SetSocketListenQueue(HP_TcpServer pServer, DWORD dwSocketListenQueue);
  /* 设置 Accept 预投递数量（根据负载调整设置，Accept 预投递数量越大则支持的并发连接请求越多） */
  HPSOCKET_API void __HP_CALL HP_TcpServer_SetAcceptSocketCount(HP_TcpServer pServer, DWORD dwAcceptSocketCount);
  /* 设置通信数据缓冲区大小（根据平均通信数据包大小调整设置，通常设置为 1024 的倍数） */
  HPSOCKET_API void __HP_CALL HP_TcpServer_SetSocketBufferSize(HP_TcpServer pServer, DWORD dwSocketBufferSize);
  /* 设置正常心跳包间隔（毫秒，0 则不发送心跳包，默认：60 * 1000） */
  HPSOCKET_API void __HP_CALL HP_TcpServer_SetKeepAliveTime(HP_TcpServer pServer, DWORD dwKeepAliveTime);
  /* 设置异常心跳包间隔（毫秒，0 不发送心跳包，，默认：20 * 1000，如果超过若干次 [默认：WinXP 5 次, Win7 10 次] 检测不到心跳确认包则认为已断线） */
  HPSOCKET_API void __HP_CALL HP_TcpServer_SetKeepAliveInterval(HP_TcpServer pServer, DWORD dwKeepAliveInterval);
  /* 设置是否开启 nodelay 模式（默认：FALSE，不开启） */
  HPSOCKET_API void __HP_CALL HP_TcpServer_SetNoDelay(HP_TcpServer pServer, BOOL bNoDelay);
  
  /* 获取 Accept 预投递数量 */
  HPSOCKET_API DWORD __HP_CALL HP_TcpServer_GetAcceptSocketCount(HP_TcpServer pServer);
  /* 获取通信数据缓冲区大小 */
  HPSOCKET_API DWORD __HP_CALL HP_TcpServer_GetSocketBufferSize(HP_TcpServer pServer);
  /* 获取监听 Socket 的等候队列大小 */
  HPSOCKET_API DWORD __HP_CALL HP_TcpServer_GetSocketListenQueue(HP_TcpServer pServer);
  /* 获取正常心跳包间隔 */
  HPSOCKET_API DWORD __HP_CALL HP_TcpServer_GetKeepAliveTime(HP_TcpServer pServer);
  /* 获取异常心跳包间隔 */
  HPSOCKET_API DWORD __HP_CALL HP_TcpServer_GetKeepAliveInterval(HP_TcpServer pServer);
  /* 检查是否开启 nodelay 模式 */
  HPSOCKET_API BOOL __HP_CALL HP_TcpServer_IsNoDelay(HP_TcpServer pServer);
  
  #ifdef _UDP_SUPPORT
  
  /**********************************************************************************/
  /***************************** UDP Server 属性访问方法 *****************************/
  
  /* 设置数据报文最大长度（建议在局域网环境下不超过 1432 字节，在广域网环境下不超过 548 字节） */
  HPSOCKET_API void __HP_CALL HP_UdpServer_SetMaxDatagramSize(HP_UdpServer pServer, DWORD dwMaxDatagramSize);
  /* 获取数据报文最大长度 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpServer_GetMaxDatagramSize(HP_UdpServer pServer);
  
  /* 设置 Receive 预投递数量（根据负载调整设置，Receive 预投递数量越大则丢包概率越小） */
  HPSOCKET_API void __HP_CALL HP_UdpServer_SetPostReceiveCount(HP_UdpServer pServer, DWORD dwPostReceiveCount);
  /* 获取 Receive 预投递数量 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpServer_GetPostReceiveCount(HP_UdpServer pServer);
  
  /* 设置监测包尝试次数（0 则不发送监测跳包，如果超过最大尝试次数则认为已断线） */
  HPSOCKET_API void __HP_CALL HP_UdpServer_SetDetectAttempts(HP_UdpServer pServer, DWORD dwDetectAttempts);
  /* 设置监测包发送间隔（毫秒，0 不发送监测包） */
  HPSOCKET_API void __HP_CALL HP_UdpServer_SetDetectInterval(HP_UdpServer pServer, DWORD dwDetectInterval);
  /* 获取心跳检查次数 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpServer_GetDetectAttempts(HP_UdpServer pServer);
  /* 获取心跳检查间隔 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpServer_GetDetectInterval(HP_UdpServer pServer);
  
  /**********************************************************************************/
  /*************************** UDP ARQ Server 属性访问方法 ***************************/
  
  /* 设置是否开启 nodelay 模式（默认：FALSE，不开启） */
  HPSOCKET_API void __HP_CALL HP_UdpArqServer_SetNoDelay(HP_UdpArqServer pServer, BOOL bNoDelay);
  /* 设置是否关闭拥塞控制（默认：FALSE，不关闭） */
  HPSOCKET_API void __HP_CALL HP_UdpArqServer_SetTurnoffCongestCtrl(HP_UdpArqServer pServer, BOOL bTurnOff);
  /* 设置数据刷新间隔（毫秒，默认：60） */
  HPSOCKET_API void __HP_CALL HP_UdpArqServer_SetFlushInterval(HP_UdpArqServer pServer, DWORD dwFlushInterval);
  /* 设置快速重传 ACK 跨越次数（默认：0，关闭快速重传） */
  HPSOCKET_API void __HP_CALL HP_UdpArqServer_SetResendByAcks(HP_UdpArqServer pServer, DWORD dwResendByAcks);
  /* 设置发送窗口大小（数据包数量，默认：128） */
  HPSOCKET_API void __HP_CALL HP_UdpArqServer_SetSendWndSize(HP_UdpArqServer pServer, DWORD dwSendWndSize);
  /* 设置接收窗口大小（数据包数量，默认：512） */
  HPSOCKET_API void __HP_CALL HP_UdpArqServer_SetRecvWndSize(HP_UdpArqServer pServer, DWORD dwRecvWndSize);
  /* 设置最小重传超时时间（毫秒，默认：30） */
  HPSOCKET_API void __HP_CALL HP_UdpArqServer_SetMinRto(HP_UdpArqServer pServer, DWORD dwMinRto);
  /* 设置快速握手次数限制（默认：5，如果为 0 则不限制） */
  HPSOCKET_API void __HP_CALL HP_UdpArqServer_SetFastLimit(HP_UdpArqServer pServer, DWORD dwFastLimit);
  /* 设置最大传输单元（默认：0，与 SetMaxDatagramSize() 一致） */
  HPSOCKET_API void __HP_CALL HP_UdpArqServer_SetMaxTransUnit(HP_UdpArqServer pServer, DWORD dwMaxTransUnit);
  /* 设置最大数据包大小（默认：4096） */
  HPSOCKET_API void __HP_CALL HP_UdpArqServer_SetMaxMessageSize(HP_UdpArqServer pServer, DWORD dwMaxMessageSize);
  /* 设置握手超时时间（毫秒，默认：5000） */
  HPSOCKET_API void __HP_CALL HP_UdpArqServer_SetHandShakeTimeout(HP_UdpArqServer pServer, DWORD dwHandShakeTimeout);
  
  /* 检测是否开启 nodelay 模式 */
  HPSOCKET_API BOOL __HP_CALL HP_UdpArqServer_IsNoDelay(HP_UdpArqServer pServer);
  /* 检测是否关闭拥塞控制 */
  HPSOCKET_API BOOL __HP_CALL HP_UdpArqServer_IsTurnoffCongestCtrl(HP_UdpArqServer pServer);
  /* 获取数据刷新间隔 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpArqServer_GetFlushInterval(HP_UdpArqServer pServer);
  /* 获取快速重传 ACK 跨越次数 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpArqServer_GetResendByAcks(HP_UdpArqServer pServer);
  /* 获取发送窗口大小 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpArqServer_GetSendWndSize(HP_UdpArqServer pServer);
  /* 获取接收窗口大小 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpArqServer_GetRecvWndSize(HP_UdpArqServer pServer);
  /* 获取最小重传超时时间 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpArqServer_GetMinRto(HP_UdpArqServer pServer);
  /* 获取快速握手次数限制 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpArqServer_GetFastLimit(HP_UdpArqServer pServer);
  /* 获取最大传输单元 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpArqServer_GetMaxTransUnit(HP_UdpArqServer pServer);
  /* 获取最大数据包大小 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpArqServer_GetMaxMessageSize(HP_UdpArqServer pServer);
  /* 获取握手超时时间 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpArqServer_GetHandShakeTimeout(HP_UdpArqServer pServer);
  
  /* 获取等待发送包数量 */
  HPSOCKET_API BOOL __HP_CALL HP_UdpArqServer_GetWaitingSendMessageCount(HP_UdpArqServer pServer, HP_CONNID dwConnID, int* piCount);
  
  #endif
  
  /**************************************************************************/
  /***************************** Agent 操作方法 *****************************/
  
  /*
  * 名称：启动通信组件
  * 描述：启动通信代理组件，启动完成后可开始连接远程服务器
  *		
  * 参数：		lpszBindAddress	-- 绑定地址（默认：nullptr，绑定任意地址）
  *			bAsyncConnect	-- 是否采用异步 Connect
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 HP_Agent_GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_Start(HP_Agent pAgent, LPCTSTR lpszBindAddress, BOOL bAsyncConnect);
  
  /*
  * 名称：关闭通信组件
  * 描述：关闭通信组件，关闭完成后断开所有连接并释放所有资源
  *		
  * 参数：	
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 HP_Agent_GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_Stop(HP_Agent pAgent);
  
  /*
  * 名称：等待
  * 描述：等待通信组件停止运行
  *		
  * 参数：		dwMilliseconds	-- 超时时间（毫秒，默认：-1，永不超时）
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_Wait(HP_Agent pAgent, DWORD dwMilliseconds);
  
  /*
  * 名称：连接服务器
  * 描述：连接服务器，连接成功后 IAgentListener 会接收到 OnConnect() / OnHandShake() 事件
  *		
  * 参数：		lpszRemoteAddress	-- 服务端地址
  *			usPort				-- 服务端端口
  *			pdwConnID			-- 连接 ID（默认：nullptr，不获取连接 ID）
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过函数 SYS_GetLastError() 获取 Windows 错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_Connect(HP_Agent pAgent, LPCTSTR lpszRemoteAddress, USHORT usPort, HP_CONNID* pdwConnID);
  
  /*
  * 名称：连接服务器
  * 描述：连接服务器，连接成功后 IAgentListener 会接收到 OnConnect() / OnHandShake() 事件
  *		
  * 参数：		lpszRemoteAddress	-- 服务端地址
  *			usPort				-- 服务端端口
  *			pdwConnID			-- 连接 ID（默认：nullptr，不获取连接 ID）
  *			pExtra				-- 连接附加数据（默认：nullptr）
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过函数 SYS_GetLastError() 获取 Windows 错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_ConnectWithExtra(HP_Agent pAgent, LPCTSTR lpszRemoteAddress, USHORT usPort, HP_CONNID* pdwConnID, PVOID pExtra);
  
  /*
  * 名称：连接服务器
  * 描述：连接服务器，连接成功后 IAgentListener 会接收到 OnConnect() / OnHandShake() 事件
  *		
  * 参数：		lpszRemoteAddress	-- 服务端地址
  *			usPort				-- 服务端端口
  *			pdwConnID			-- 连接 ID（默认：nullptr，不获取连接 ID）
  *			usLocalPort			-- 本地端口（默认：0）
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过函数 SYS_GetLastError() 获取 Windows 错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_ConnectWithLocalPort(HP_Agent pAgent, LPCTSTR lpszRemoteAddress, USHORT usPort, HP_CONNID* pdwConnID, USHORT usLocalPort);
  
  /*
  * 名称：连接服务器
  * 描述：连接服务器，连接成功后 IAgentListener 会接收到 OnConnect() / OnHandShake() 事件
  *		
  * 参数：		lpszRemoteAddress	-- 服务端地址
  *			usPort				-- 服务端端口
  *			pdwConnID			-- 连接 ID（默认：nullptr，不获取连接 ID）
  *			lpszLocalAddress	-- 本地地址（默认：nullptr，使用 Start() 方法中绑定的地址）
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过函数 SYS_GetLastError() 获取 Windows 错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_ConnectWithLocalAddress(HP_Agent pAgent, LPCTSTR lpszRemoteAddress, USHORT usPort, HP_CONNID* pdwConnID, LPCTSTR lpszLocalAddress);
  
  /* 
  * 名称：连接服务器
  * 描述：连接服务器，连接成功后 IAgentListener 会接收到 OnConnect() / OnHandShake() 事件
  *		
  * 参数：		lpszRemoteAddress	-- 服务端地址
  *			usPort				-- 服务端端口
  *			pdwConnID			-- 连接 ID（默认：nullptr，不获取连接 ID）
  *			pExtra				-- 连接附加数据（默认：nullptr）
  *			usLocalPort			-- 本地端口（默认：0）
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过函数 SYS_GetLastError() 获取 Windows 错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_ConnectWithExtraAndLocalPort(HP_Agent pAgent, LPCTSTR lpszRemoteAddress, USHORT usPort, HP_CONNID* pdwConnID, PVOID pExtra, USHORT usLocalPort);
  
  /* 
  * 名称：连接服务器
  * 描述：连接服务器，连接成功后 IAgentListener 会接收到 OnConnect() / OnHandShake() 事件
  *		
  * 参数：		lpszRemoteAddress	-- 服务端地址
  *			usPort				-- 服务端端口
  *			pdwConnID			-- 连接 ID（默认：nullptr，不获取连接 ID）
  *			pExtra				-- 连接附加数据（默认：nullptr）
  *			usLocalPort			-- 本地端口（默认：0）
  *			lpszLocalAddress	-- 本地地址（默认：nullptr，使用 Start() 方法中绑定的地址）
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过函数 SYS_GetLastError() 获取 Windows 错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_ConnectWithExtraAndLocalAddressPort(HP_Agent pAgent, LPCTSTR lpszRemoteAddress, USHORT usPort, HP_CONNID* pdwConnID, PVOID pExtra, USHORT usLocalPort, LPCTSTR lpszLocalAddress);
  
  /*
  * 名称：发送数据
  * 描述：向指定连接发送数据
  *		
  * 参数：		dwConnID	-- 连接 ID
  *			pBuffer		-- 发送缓冲区
  *			iLength		-- 发送缓冲区长度
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取 Windows 错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_Send(HP_Agent pAgent, HP_CONNID dwConnID, const BYTE* pBuffer, int iLength);
  
  /*
  * 名称：发送数据
  * 描述：向指定连接发送数据
  *		
  * 参数：		dwConnID	-- 连接 ID
  *			pBuffer		-- 发送缓冲区
  *			iLength		-- 发送缓冲区长度
  *			iOffset		-- 发送缓冲区指针偏移量
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取 Windows 错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_SendPart(HP_Agent pAgent, HP_CONNID dwConnID, const BYTE* pBuffer, int iLength, int iOffset);
  
  /*
  * 名称：发送多组数据
  * 描述：向指定连接发送多组数据
  *		TCP - 顺序发送所有数据包 
  *		UDP - 把所有数据包组合成一个数据包发送（数据包的总长度不能大于设置的 UDP 包最大长度） 
  *		
  * 参数：		dwConnID	-- 连接 ID
  *			pBuffers	-- 发送缓冲区数组
  *			iCount		-- 发送缓冲区数目
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取 Windows 错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_SendPackets(HP_Agent pAgent, HP_CONNID dwConnID, const WSABUF pBuffers[], int iCount);
  
  /*
  * 名称：暂停/恢复接收
  * 描述：暂停/恢复某个连接的数据接收工作
  *		
  * 参数：		dwConnID	-- 连接 ID
  *			bPause		-- TRUE - 暂停, FALSE - 恢复
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_PauseReceive(HP_Agent pAgent, HP_CONNID dwConnID, BOOL bPause);
  
  /*
  * 名称：断开连接
  * 描述：断开某个连接
  *		
  * 参数：		dwConnID	-- 连接 ID
  *			bForce		-- 是否强制断开连接
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_Disconnect(HP_Agent pAgent, HP_CONNID dwConnID, BOOL bForce);
  
  /*
  * 名称：断开超时连接
  * 描述：断开超过指定时长的连接
  *		
  * 参数：		dwPeriod	-- 时长（毫秒）
  *			bForce		-- 是否强制断开连接
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_DisconnectLongConnections(HP_Agent pAgent, DWORD dwPeriod, BOOL bForce);
  
  /*
  * 名称：断开静默连接
  * 描述：断开超过指定时长的静默连接
  *		
  * 参数：		dwPeriod	-- 时长（毫秒）
  *			bForce		-- 是否强制断开连接
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_DisconnectSilenceConnections(HP_Agent pAgent, DWORD dwPeriod, BOOL bForce);
  
  /******************************************************************************/
  /***************************** Agent 属性访问方法 *****************************/
  
  /*
  * 名称：设置连接的附加数据
  * 描述：是否为连接绑定附加数据或者绑定什么样的数据，均由应用程序只身决定
  *		
  * 参数：		dwConnID	-- 连接 ID
  *			pv			-- 数据
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败（无效的连接 ID）
  */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_SetConnectionExtra(HP_Agent pAgent, HP_CONNID dwConnID, PVOID pExtra);
  
  /*
  * 名称：获取连接的附加数据
  * 描述：是否为连接绑定附加数据或者绑定什么样的数据，均由应用程序只身决定
  *		
  * 参数：		dwConnID	-- 连接 ID
  *			ppv			-- 数据指针
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败（无效的连接 ID）
  */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_GetConnectionExtra(HP_Agent pAgent, HP_CONNID dwConnID, PVOID* ppExtra);
  
  /* 检测是否为安全连接（SSL/HTTPS） */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_IsSecure(HP_Agent pAgent);
  /* 检查通信组件是否已启动 */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_HasStarted(HP_Agent pAgent);
  /* 查看通信组件当前状态 */
  HPSOCKET_API En_HP_ServiceState __HP_CALL HP_Agent_GetState(HP_Agent pAgent);
  /* 获取连接数 */
  HPSOCKET_API DWORD __HP_CALL HP_Agent_GetConnectionCount(HP_Agent pAgent);
  /* 获取所有连接的 HP_CONNID */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_GetAllConnectionIDs(HP_Agent pAgent, HP_CONNID pIDs[], DWORD* pdwCount);
  /* 获取某个连接时长（毫秒） */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_GetConnectPeriod(HP_Agent pAgent, HP_CONNID dwConnID, DWORD* pdwPeriod);
  /* 获取某个连接静默时间（毫秒） */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_GetSilencePeriod(HP_Agent pAgent, HP_CONNID dwConnID, DWORD* pdwPeriod);
  /* 获取某个连接的本地地址信息 */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_GetLocalAddress(HP_Agent pAgent, HP_CONNID dwConnID, TCHAR lpszAddress[], int* piAddressLen, USHORT* pusPort);
  /* 获取某个连接的远程地址信息 */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_GetRemoteAddress(HP_Agent pAgent, HP_CONNID dwConnID, TCHAR lpszAddress[], int* piAddressLen, USHORT* pusPort);
  /* 获取某个连接的远程主机信息 */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_GetRemoteHost(HP_Agent pAgent, HP_CONNID dwConnID, TCHAR lpszHost[], int* piHostLen, USHORT* pusPort);
  /* 获取最近一次失败操作的错误代码 */
  HPSOCKET_API En_HP_SocketError __HP_CALL HP_Agent_GetLastError(HP_Agent pAgent);
  /* 获取最近一次失败操作的错误描述 */
  HPSOCKET_API LPCTSTR __HP_CALL HP_Agent_GetLastErrorDesc(HP_Agent pAgent);
  /* 获取连接中未发出数据的长度 */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_GetPendingDataLength(HP_Agent pAgent, HP_CONNID dwConnID, int* piPending);
  /* 获取连接的数据接收状态 */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_IsPauseReceive(HP_Agent pAgent, HP_CONNID dwConnID, BOOL* pbPaused);
  /* 检测是否有效连接 */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_IsConnected(HP_Agent pAgent, HP_CONNID dwConnID);
  
  /* 设置地址重用选项 */
  HPSOCKET_API void __HP_CALL HP_Agent_SetReuseAddressPolicy(HP_Agent pAgent, En_HP_ReuseAddressPolicy enReusePolicy);
  /* 设置数据发送策略 */
  HPSOCKET_API void __HP_CALL HP_Agent_SetSendPolicy(HP_Agent pAgent, En_HP_SendPolicy enSendPolicy);
  /* 设置 OnSend 事件同步策略（默认：OSSP_NONE，不同步） */
  HPSOCKET_API void __HP_CALL HP_Agent_SetOnSendSyncPolicy(HP_Agent pAgent, En_HP_OnSendSyncPolicy enSyncPolicy);
  /* 设置 Socket 缓存对象锁定时间（毫秒，在锁定期间该 Socket 缓存对象不能被获取使用） */
  HPSOCKET_API void __HP_CALL HP_Agent_SetFreeSocketObjLockTime(HP_Agent pAgent, DWORD dwFreeSocketObjLockTime);
  /* 设置 Socket 缓存池大小（通常设置为平均并发连接数量的 1/3 - 1/2） */
  HPSOCKET_API void __HP_CALL HP_Agent_SetFreeSocketObjPool(HP_Agent pAgent, DWORD dwFreeSocketObjPool);
  /* 设置内存块缓存池大小（通常设置为 Socket 缓存池大小的 2 - 3 倍） */
  HPSOCKET_API void __HP_CALL HP_Agent_SetFreeBufferObjPool(HP_Agent pAgent, DWORD dwFreeBufferObjPool);
  /* 设置 Socket 缓存池回收阀值（通常设置为 Socket 缓存池大小的 3 倍） */
  HPSOCKET_API void __HP_CALL HP_Agent_SetFreeSocketObjHold(HP_Agent pAgent, DWORD dwFreeSocketObjHold);
  /* 设置内存块缓存池回收阀值（通常设置为内存块缓存池大小的 3 倍） */
  HPSOCKET_API void __HP_CALL HP_Agent_SetFreeBufferObjHold(HP_Agent pAgent, DWORD dwFreeBufferObjHold);
  /* 设置最大连接数（组件会根据设置值预分配内存，因此需要根据实际情况设置，不宜过大）*/
  HPSOCKET_API void __HP_CALL HP_Agent_SetMaxConnectionCount(HP_Agent pAgent, DWORD dwMaxConnectionCount);
  /* 设置工作线程数量（通常设置为 2 * CPU + 2） */
  HPSOCKET_API void __HP_CALL HP_Agent_SetWorkerThreadCount(HP_Agent pAgent, DWORD dwWorkerThreadCount);
  /* 设置是否标记静默时间（设置为 TRUE 时 DisconnectSilenceConnections() 和 GetSilencePeriod() 才有效，默认：TRUE） */
  HPSOCKET_API void __HP_CALL HP_Agent_SetMarkSilence(HP_Agent pAgent, BOOL bMarkSilence);
  
  /* 获取地址重用选项 */
  HPSOCKET_API En_HP_ReuseAddressPolicy __HP_CALL HP_Agent_GetReuseAddressPolicy(HP_Agent pAgent);
  /* 获取数据发送策略 */
  HPSOCKET_API En_HP_SendPolicy __HP_CALL HP_Agent_GetSendPolicy(HP_Agent pAgent);
  /* 获取 OnSend 事件同步策略 */
  HPSOCKET_API En_HP_OnSendSyncPolicy __HP_CALL HP_Agent_GetOnSendSyncPolicy(HP_Agent pAgent);
  /* 获取 Socket 缓存对象锁定时间 */
  HPSOCKET_API DWORD __HP_CALL HP_Agent_GetFreeSocketObjLockTime(HP_Agent pAgent);
  /* 获取 Socket 缓存池大小 */
  HPSOCKET_API DWORD __HP_CALL HP_Agent_GetFreeSocketObjPool(HP_Agent pAgent);
  /* 获取内存块缓存池大小 */
  HPSOCKET_API DWORD __HP_CALL HP_Agent_GetFreeBufferObjPool(HP_Agent pAgent);
  /* 获取 Socket 缓存池回收阀值 */
  HPSOCKET_API DWORD __HP_CALL HP_Agent_GetFreeSocketObjHold(HP_Agent pAgent);
  /* 获取内存块缓存池回收阀值 */
  HPSOCKET_API DWORD __HP_CALL HP_Agent_GetFreeBufferObjHold(HP_Agent pAgent);
  /* 获取最大连接数 */
  HPSOCKET_API DWORD __HP_CALL HP_Agent_GetMaxConnectionCount(HP_Agent pAgent);
  /* 获取工作线程数量 */
  HPSOCKET_API DWORD __HP_CALL HP_Agent_GetWorkerThreadCount(HP_Agent pAgent);
  /* 检测是否标记静默时间 */
  HPSOCKET_API BOOL __HP_CALL HP_Agent_IsMarkSilence(HP_Agent pAgent);
  
  /**********************************************************************************/
  /******************************* TCP Agent 操作方法 *******************************/
  
  /*
  * 名称：发送小文件
  * 描述：向指定连接发送 4096 KB 以下的小文件
  *		
  * 参数：		dwConnID		-- 连接 ID
  *			lpszFileName	-- 文件路径
  *			pHead			-- 头部附加数据
  *			pTail			-- 尾部附加数据
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取 Windows 错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_TcpAgent_SendSmallFile(HP_Agent pAgent, HP_CONNID dwConnID, LPCTSTR lpszFileName, const LPWSABUF pHead, const LPWSABUF pTail);
  
  /**********************************************************************************/
  /***************************** TCP Agent 属性访问方法 *****************************/
  
  /* 设置通信数据缓冲区大小（根据平均通信数据包大小调整设置，通常设置为 1024 的倍数） */
  HPSOCKET_API void __HP_CALL HP_TcpAgent_SetSocketBufferSize(HP_TcpAgent pAgent, DWORD dwSocketBufferSize);
  /* 设置正常心跳包间隔（毫秒，0 则不发送心跳包，默认：60 * 1000） */
  HPSOCKET_API void __HP_CALL HP_TcpAgent_SetKeepAliveTime(HP_TcpAgent pAgent, DWORD dwKeepAliveTime);
  /* 设置异常心跳包间隔（毫秒，0 不发送心跳包，，默认：20 * 1000，如果超过若干次 [默认：WinXP 5 次, Win7 10 次] 检测不到心跳确认包则认为已断线） */
  HPSOCKET_API void __HP_CALL HP_TcpAgent_SetKeepAliveInterval(HP_TcpAgent pAgent, DWORD dwKeepAliveInterval);
  /* 设置是否开启 nodelay 模式（默认：FALSE，不开启） */
  HPSOCKET_API void __HP_CALL HP_TcpAgent_SetNoDelay(HP_TcpAgent pAgent, BOOL bNoDelay);
  
  /* 获取通信数据缓冲区大小 */
  HPSOCKET_API DWORD __HP_CALL HP_TcpAgent_GetSocketBufferSize(HP_TcpAgent pAgent);
  /* 获取正常心跳包间隔 */
  HPSOCKET_API DWORD __HP_CALL HP_TcpAgent_GetKeepAliveTime(HP_TcpAgent pAgent);
  /* 获取异常心跳包间隔 */
  HPSOCKET_API DWORD __HP_CALL HP_TcpAgent_GetKeepAliveInterval(HP_TcpAgent pAgent);
  /* 检查是否开启 nodelay 模式 */
  HPSOCKET_API BOOL __HP_CALL HP_TcpAgent_IsNoDelay(HP_TcpAgent pAgent);
  
  /******************************************************************************/
  /***************************** Client 组件操作方法 *****************************/
  
  /*
  * 名称：启动通信组件
  * 描述：启动客户端通信组件并连接服务端，启动完成后可开始收发数据
  *		
  * 参数：		lpszRemoteAddress	-- 服务端地址
  *			usPort				-- 服务端端口
  *			bAsyncConnect		-- 是否采用异步 Connect
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 HP_Client_GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Client_Start(HP_Client pClient, LPCTSTR lpszRemoteAddress, USHORT usPort, BOOL bAsyncConnect);
  
  /*
  * 名称：启动通信组件（并指定绑定地址）
  * 描述：启动客户端通信组件并连接服务端，启动完成后可开始收发数据
  *		
  * 参数：		lpszRemoteAddress	-- 服务端地址
  *			usPort				-- 服务端端口
  *			bAsyncConnect		-- 是否采用异步 Connect
  *			lpszBindAddress		-- 绑定地址（默认：nullptr，TcpClient/UdpClient -> 不执行绑定操作，UdpCast 绑定 -> 任意地址）
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 HP_Client_GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Client_StartWithBindAddress(HP_Client pClient, LPCTSTR lpszRemoteAddress, USHORT usPort, BOOL bAsyncConnect, LPCTSTR lpszBindAddress);
  
  /*
  * 名称：启动通信组件（并指定绑定地址）
  * 描述：启动客户端通信组件并连接服务端，启动完成后可开始收发数据
  *		
  * 参数：		lpszRemoteAddress	-- 服务端地址
  *			usPort				-- 服务端端口
  *			bAsyncConnect		-- 是否采用异步 Connect
  *			lpszBindAddress		-- 绑定地址（默认：nullptr，TcpClient/UdpClient -> 不执行绑定操作，UdpCast 绑定 -> 任意地址）
  *			usLocalPort			-- 本地端口（默认：0）
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 HP_Client_GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Client_StartWithBindAddressAndLocalPort(HP_Client pClient, LPCTSTR lpszRemoteAddress, USHORT usPort, BOOL bAsyncConnect, LPCTSTR lpszBindAddress, USHORT usLocalPort);
  
  /*
  * 名称：关闭通信组件
  * 描述：关闭客户端通信组件，关闭完成后断开与服务端的连接并释放所有资源
  *		
  * 参数：	
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 HP_Client_GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Client_Stop(HP_Client pClient);
  
  /*
  * 名称：发送数据
  * 描述：向服务端发送数据
  *		
  * 参数：		pBuffer		-- 发送缓冲区
  *			iLength		-- 发送缓冲区长度
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取 Windows 错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Client_Send(HP_Client pClient, const BYTE* pBuffer, int iLength);
  
  /*
  * 名称：发送数据
  * 描述：向服务端发送数据
  *		
  * 参数：		pBuffer		-- 发送缓冲区
  *			iLength		-- 发送缓冲区长度
  *			iOffset		-- 发送缓冲区指针偏移量
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取 Windows 错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Client_SendPart(HP_Client pClient, const BYTE* pBuffer, int iLength, int iOffset);
  
  /*
  * 名称：发送多组数据
  * 描述：向服务端发送多组数据
  *		TCP - 顺序发送所有数据包 
  *		UDP - 把所有数据包组合成一个数据包发送（数据包的总长度不能大于设置的 UDP 包最大长度） 
  *		
  * 参数：		pBuffers	-- 发送缓冲区数组
  *			iCount		-- 发送缓冲区数目
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取 Windows 错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Client_SendPackets(HP_Client pClient, const WSABUF pBuffers[], int iCount);
  
  /*
  * 名称：暂停/恢复接收
  * 描述：暂停/恢复某个连接的数据接收工作
  *		
  *			bPause	-- TRUE - 暂停, FALSE - 恢复
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_Client_PauseReceive(HP_Client pClient, BOOL bPause);
  
  /*
  * 名称：等待
  * 描述：等待通信组件停止运行
  *		
  * 参数：		dwMilliseconds	-- 超时时间（毫秒，默认：-1，永不超时）
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_Client_Wait(HP_Client pClient, DWORD dwMilliseconds);
  
  /******************************************************************************/
  /***************************** Client 属性访问方法 *****************************/
  
  /* 设置连接的附加数据 */
  HPSOCKET_API void __HP_CALL HP_Client_SetExtra(HP_Client pClient, PVOID pExtra);
  /* 获取连接的附加数据 */
  HPSOCKET_API PVOID __HP_CALL HP_Client_GetExtra(HP_Client pClient);
  
  /* 检测是否为安全连接（SSL/HTTPS） */
  HPSOCKET_API BOOL __HP_CALL HP_Client_IsSecure(HP_Client pClient);
  /* 检查通信组件是否已启动 */
  HPSOCKET_API BOOL __HP_CALL HP_Client_HasStarted(HP_Client pClient);
  /* 查看通信组件当前状态 */
  HPSOCKET_API En_HP_ServiceState	__HP_CALL HP_Client_GetState(HP_Client pClient);
  /* 获取最近一次失败操作的错误代码 */
  HPSOCKET_API En_HP_SocketError	__HP_CALL HP_Client_GetLastError(HP_Client pClient);
  /* 获取最近一次失败操作的错误描述 */
  HPSOCKET_API LPCTSTR __HP_CALL HP_Client_GetLastErrorDesc(HP_Client pClient);
  /* 获取该组件对象的连接 ID */
  HPSOCKET_API HP_CONNID __HP_CALL HP_Client_GetConnectionID(HP_Client pClient);
  /* 获取 Client Socket 的地址信息 */
  HPSOCKET_API BOOL __HP_CALL HP_Client_GetLocalAddress(HP_Client pClient, TCHAR lpszAddress[], int* piAddressLen, USHORT* pusPort);
  /* 获取连接的远程主机信息 */
  HPSOCKET_API BOOL __HP_CALL HP_Client_GetRemoteHost(HP_Client pClient, TCHAR lpszHost[], int* piHostLen, USHORT* pusPort);
  /* 获取连接中未发出数据的长度 */
  HPSOCKET_API BOOL __HP_CALL HP_Client_GetPendingDataLength(HP_Client pClient, int* piPending);
  /* 获取连接的数据接收状态 */
  HPSOCKET_API BOOL __HP_CALL HP_Client_IsPauseReceive(HP_Client pClient, BOOL* pbPaused);
  /* 检测是否有效连接 */
  HPSOCKET_API BOOL __HP_CALL HP_Client_IsConnected(HP_Client pClient);
  
  /* 设置地址重用选项 */
  HPSOCKET_API void __HP_CALL HP_Client_SetReuseAddressPolicy(HP_Client pClient, En_HP_ReuseAddressPolicy enReusePolicy);
  /* 设置内存块缓存池大小（通常设置为 -> PUSH 模型：5 - 10；PULL 模型：10 - 20 ） */
  HPSOCKET_API void __HP_CALL HP_Client_SetFreeBufferPoolSize(HP_Client pClient, DWORD dwFreeBufferPoolSize);
  /* 设置内存块缓存池回收阀值（通常设置为内存块缓存池大小的 3 倍） */
  HPSOCKET_API void __HP_CALL HP_Client_SetFreeBufferPoolHold(HP_Client pClient, DWORD dwFreeBufferPoolHold);
  
  /* 获取地址重用选项 */
  HPSOCKET_API En_HP_ReuseAddressPolicy __HP_CALL HP_Client_GetReuseAddressPolicy(HP_Client pClient);
  /* 获取内存块缓存池大小 */
  HPSOCKET_API DWORD __HP_CALL HP_Client_GetFreeBufferPoolSize(HP_Client pClient);
  /* 获取内存块缓存池回收阀值 */
  HPSOCKET_API DWORD __HP_CALL HP_Client_GetFreeBufferPoolHold(HP_Client pClient);
  
  /**********************************************************************************/
  /******************************* TCP Client 操作方法 *******************************/
  
  /*
  * 名称：发送小文件
  * 描述：向服务端发送 4096 KB 以下的小文件
  *		
  * 参数：		lpszFileName	-- 文件路径
  *			pHead			-- 头部附加数据
  *			pTail			-- 尾部附加数据
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取 Windows 错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_TcpClient_SendSmallFile(HP_Client pClient, LPCTSTR lpszFileName, const LPWSABUF pHead, const LPWSABUF pTail);
  
  /**********************************************************************************/
  /***************************** TCP Client 属性访问方法 *****************************/
  
  /* 设置通信数据缓冲区大小（根据平均通信数据包大小调整设置，通常设置为：(N * 1024) - sizeof(TBufferObj)） */
  HPSOCKET_API void __HP_CALL HP_TcpClient_SetSocketBufferSize(HP_TcpClient pClient, DWORD dwSocketBufferSize);
  /* 设置正常心跳包间隔（毫秒，0 则不发送心跳包，默认：60 * 1000） */
  HPSOCKET_API void __HP_CALL HP_TcpClient_SetKeepAliveTime(HP_TcpClient pClient, DWORD dwKeepAliveTime);
  /* 设置异常心跳包间隔（毫秒，0 不发送心跳包，，默认：20 * 1000，如果超过若干次 [默认：WinXP 5 次, Win7 10 次] 检测不到心跳确认包则认为已断线） */
  HPSOCKET_API void __HP_CALL HP_TcpClient_SetKeepAliveInterval(HP_TcpClient pClient, DWORD dwKeepAliveInterval);
  /* 设置是否开启 nodelay 模式（默认：FALSE，不开启） */
  HPSOCKET_API void __HP_CALL HP_TcpClient_SetNoDelay(HP_TcpClient pClient, BOOL bNoDelay);
  
  /* 获取通信数据缓冲区大小 */
  HPSOCKET_API DWORD __HP_CALL HP_TcpClient_GetSocketBufferSize(HP_TcpClient pClient);
  /* 获取正常心跳包间隔 */
  HPSOCKET_API DWORD __HP_CALL HP_TcpClient_GetKeepAliveTime(HP_TcpClient pClient);
  /* 获取异常心跳包间隔 */
  HPSOCKET_API DWORD __HP_CALL HP_TcpClient_GetKeepAliveInterval(HP_TcpClient pClient);
  /* 检查是否开启 nodelay 模式 */
  HPSOCKET_API BOOL __HP_CALL HP_TcpClient_IsNoDelay(HP_TcpClient pClient);
  
  #ifdef _UDP_SUPPORT
  
  /**********************************************************************************/
  /***************************** UDP Client 属性访问方法 *****************************/
  
  /* 设置数据报文最大长度（建议在局域网环境下不超过 1432 字节，在广域网环境下不超过 548 字节） */
  HPSOCKET_API void __HP_CALL HP_UdpClient_SetMaxDatagramSize(HP_UdpClient pClient, DWORD dwMaxDatagramSize);
  /* 获取数据报文最大长度 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpClient_GetMaxDatagramSize(HP_UdpClient pClient);
  
  /* 设置监测包尝试次数（0 则不发送监测跳包，如果超过最大尝试次数则认为已断线） */
  HPSOCKET_API void __HP_CALL HP_UdpClient_SetDetectAttempts(HP_UdpClient pClient, DWORD dwDetectAttempts);
  /* 设置监测包发送间隔（毫秒，0 不发送监测包） */
  HPSOCKET_API void __HP_CALL HP_UdpClient_SetDetectInterval(HP_UdpClient pClient, DWORD dwDetectInterval);
  /* 获取心跳检查次数 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpClient_GetDetectAttempts(HP_UdpClient pClient);
  /* 获取心跳检查间隔 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpClient_GetDetectInterval(HP_UdpClient pClient);
  
  /**********************************************************************************/
  /*************************** UDP ARQ Client 属性访问方法 ***************************/
  
  /* 设置是否开启 nodelay 模式（默认：FALSE，不开启） */
  HPSOCKET_API void __HP_CALL HP_UdpArqClient_SetNoDelay(HP_UdpArqClient pClient, BOOL bNoDelay);
  /* 设置是否关闭拥塞控制（默认：FALSE，不关闭） */
  HPSOCKET_API void __HP_CALL HP_UdpArqClient_SetTurnoffCongestCtrl(HP_UdpArqClient pClient, BOOL bTurnOff);
  /* 设置数据刷新间隔（毫秒，默认：60） */
  HPSOCKET_API void __HP_CALL HP_UdpArqClient_SetFlushInterval(HP_UdpArqClient pClient, DWORD dwFlushInterval);
  /* 设置快速重传 ACK 跨越次数（默认：0，关闭快速重传） */
  HPSOCKET_API void __HP_CALL HP_UdpArqClient_SetResendByAcks(HP_UdpArqClient pClient, DWORD dwResendByAcks);
  /* 设置发送窗口大小（数据包数量，默认：128） */
  HPSOCKET_API void __HP_CALL HP_UdpArqClient_SetSendWndSize(HP_UdpArqClient pClient, DWORD dwSendWndSize);
  /* 设置接收窗口大小（数据包数量，默认：512） */
  HPSOCKET_API void __HP_CALL HP_UdpArqClient_SetRecvWndSize(HP_UdpArqClient pClient, DWORD dwRecvWndSize);
  /* 设置最小重传超时时间（毫秒，默认：30） */
  HPSOCKET_API void __HP_CALL HP_UdpArqClient_SetMinRto(HP_UdpArqClient pClient, DWORD dwMinRto);
  /* 设置快速握手次数限制（默认：5，如果为 0 则不限制） */
  HPSOCKET_API void __HP_CALL HP_UdpArqClient_SetFastLimit(HP_UdpArqClient pClient, DWORD dwFastLimit);
  /* 设置最大传输单元（默认：0，与 SetMaxDatagramSize() 一致） */
  HPSOCKET_API void __HP_CALL HP_UdpArqClient_SetMaxTransUnit(HP_UdpArqClient pClient, DWORD dwMaxTransUnit);
  /* 设置最大数据包大小（默认：4096） */
  HPSOCKET_API void __HP_CALL HP_UdpArqClient_SetMaxMessageSize(HP_UdpArqClient pClient, DWORD dwMaxMessageSize);
  /* 设置握手超时时间（毫秒，默认：5000） */
  HPSOCKET_API void __HP_CALL HP_UdpArqClient_SetHandShakeTimeout(HP_UdpArqClient pClient, DWORD dwHandShakeTimeout);
  
  /* 检测是否开启 nodelay 模式 */
  HPSOCKET_API BOOL __HP_CALL HP_UdpArqClient_IsNoDelay(HP_UdpArqClient pClient);
  /* 检测是否关闭拥塞控制 */
  HPSOCKET_API BOOL __HP_CALL HP_UdpArqClient_IsTurnoffCongestCtrl(HP_UdpArqClient pClient);
  /* 获取数据刷新间隔 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpArqClient_GetFlushInterval(HP_UdpArqClient pClient);
  /* 获取快速重传 ACK 跨越次数 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpArqClient_GetResendByAcks(HP_UdpArqClient pClient);
  /* 获取发送窗口大小 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpArqClient_GetSendWndSize(HP_UdpArqClient pClient);
  /* 获取接收窗口大小 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpArqClient_GetRecvWndSize(HP_UdpArqClient pClient);
  /* 获取最小重传超时时间 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpArqClient_GetMinRto(HP_UdpArqClient pClient);
  /* 获取快速握手次数限制 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpArqClient_GetFastLimit(HP_UdpArqClient pClient);
  /* 获取最大传输单元 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpArqClient_GetMaxTransUnit(HP_UdpArqClient pClient);
  /* 获取最大数据包大小 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpArqClient_GetMaxMessageSize(HP_UdpArqClient pClient);
  /* 获取握手超时时间 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpArqClient_GetHandShakeTimeout(HP_UdpArqClient pClient);
  
  /* 获取等待发送包数量 */
  HPSOCKET_API BOOL __HP_CALL HP_UdpArqClient_GetWaitingSendMessageCount(HP_UdpArqClient pClient, int* piCount);
  
  /**********************************************************************************/
  /****************************** UDP Cast 属性访问方法 ******************************/
  
  /* 设置数据报文最大长度（建议在局域网环境下不超过 1432 字节，在广域网环境下不超过 548 字节） */
  HPSOCKET_API void __HP_CALL HP_UdpCast_SetMaxDatagramSize(HP_UdpCast pCast, DWORD dwMaxDatagramSize);
  /* 获取数据报文最大长度 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpCast_GetMaxDatagramSize(HP_UdpCast pCast);
  /* 获取当前数据报的远程地址信息（通常在 OnReceive 事件中调用） */
  HPSOCKET_API BOOL __HP_CALL HP_UdpCast_GetRemoteAddress(HP_UdpCast pCast, TCHAR lpszAddress[], int* piAddressLen, USHORT* pusPort);
  /* 设置传播模式（组播或广播） */
  HPSOCKET_API void __HP_CALL HP_UdpCast_SetCastMode(HP_UdpCast pCast, En_HP_CastMode enCastMode);
  /* 获取传播模式 */
  HPSOCKET_API En_HP_CastMode __HP_CALL HP_UdpCast_GetCastMode(HP_UdpCast pCast);
  /* 设置组播报文的 TTL（0 - 255） */
  HPSOCKET_API void __HP_CALL HP_UdpCast_SetMultiCastTtl(HP_UdpCast pCast, int iMCTtl);
  /* 获取组播报文的 TTL */
  HPSOCKET_API int __HP_CALL HP_UdpCast_GetMultiCastTtl(HP_UdpCast pCast);
  /* 设置是否启用组播环路（TRUE or FALSE） */
  HPSOCKET_API void __HP_CALL HP_UdpCast_SetMultiCastLoop(HP_UdpCast pCast, BOOL bMCLoop);
  /* 检测是否启用组播环路 */
  HPSOCKET_API BOOL __HP_CALL HP_UdpCast_IsMultiCastLoop(HP_UdpCast pCast);
  
  /**********************************************************************************/
  /****************************** UDP Node 组件操作方法 ******************************/
  
  /*
  * 名称：启动通信组件
  * 描述：启动 UDP 节点通信组件，启动完成后可开始收发数据
  *		
  * 参数：		lpszBindAddress		-- 绑定地址（默认：nullptr，绑定任意地址）
  *			usPort				-- 本地端口（默认：0）
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_UdpNode_Start(HP_UdpNode pNode, LPCTSTR lpszBindAddress, USHORT usPort);
  
  /*
  * 名称：启动通信组件
  * 描述：启动 UDP 节点通信组件，启动完成后可开始收发数据
  *		
  * 参数：		lpszBindAddress		-- 绑定地址（默认：nullptr，绑定任意地址）
  *			usPort				-- 本地端口（默认：0）
  *			enCastMode			-- 传播模式（默认：CM_UNICAST）
  *			lpszCastAddress		-- 传播地址（默认：nullptr，当 enCaseMode 为 CM_MULTICAST 或 CM_BROADCAST 时有效）
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_UdpNode_StartWithCast(HP_UdpNode pNode, LPCTSTR lpszBindAddress, USHORT usPort, En_HP_CastMode enCastMode, LPCTSTR lpszCastAddress);
  
  /*
  * 名称：关闭通信组件
  * 描述：关闭 UDP 节点通信组件，关闭完成后释放所有资源
  *		
  * 参数：	
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_UdpNode_Stop(HP_UdpNode pNode);
  
  /*
  * 名称：等待
  * 描述：等待通信组件停止运行
  *		
  * 参数：		dwMilliseconds	-- 超时时间（毫秒，默认：-1，永不超时）
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_UdpNode_Wait(HP_UdpNode pNode, DWORD dwMilliseconds);
  
  /*
  * 名称：发送数据
  * 描述：向指定地址发送数据
  *		
  * 参数：		lpszRemoteAddress	-- 远程地址
  *			usRemotePort		-- 远程端口
  *			pBuffer				-- 发送缓冲区
  *			iLength				-- 发送缓冲区长度
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_UdpNode_Send(HP_UdpNode pNode, LPCTSTR lpszRemoteAddress, USHORT usRemotePort, const BYTE* pBuffer, int iLength);
  
  /*
  * 名称：发送数据
  * 描述：向指定地址发送数据
  *		
  * 参数：		lpszRemoteAddress	-- 远程地址
  *			usRemotePort		-- 远程端口
  *			pBuffer				-- 发送缓冲区
  *			iLength				-- 发送缓冲区长度
  *			iOffset				-- 发送缓冲区指针偏移量
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_UdpNode_SendPart(HP_UdpNode pNode, LPCTSTR lpszRemoteAddress, USHORT usRemotePort, const BYTE* pBuffer, int iLength, int iOffset);
  
  /*
  * 名称：发送多组数据
  * 描述：向指定地址发送多组数据，把所有数据包组合成一个数据包发送（数据包的总长度不能大于设置的 UDP 包最大长度） 
  *		
  * 参数：		lpszRemoteAddress	-- 远程地址
  *			usRemotePort		-- 远程端口
  *			pBuffers			-- 发送缓冲区数组
  *			iCount				-- 发送缓冲区数目
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_UdpNode_SendPackets(HP_UdpNode pNode, LPCTSTR lpszRemoteAddress, USHORT usRemotePort, const WSABUF pBuffers[], int iCount);
  
  /*
  * 名称：发送数据
  * 描述：向传播地址发送数据
  *		
  * 参数：		pBuffer		-- 发送缓冲区
  *			iLength		-- 发送缓冲区长度
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_UdpNode_SendCast(HP_UdpNode pNode, const BYTE* pBuffer, int iLength);
  
  /*
  * 名称：发送数据
  * 描述：向传播地址发送数据
  *		
  * 参数：		pBuffer		-- 发送缓冲区
  *			iLength		-- 发送缓冲区长度
  *			iOffset		-- 发送缓冲区指针偏移量
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_UdpNode_SendCastPart(HP_UdpNode pNode, const BYTE* pBuffer, int iLength, int iOffset);
  
  /*
  * 名称：发送多组数据
  * 描述：向传播地址发送多组数据，把所有数据包组合成一个数据包发送（数据包的总长度不能大于设置的 UDP 包最大长度） 
  *		
  * 参数：		pBuffers	-- 发送缓冲区数组
  *			iCount		-- 发送缓冲区数目
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_UdpNode_SendCastPackets(HP_UdpNode pNode, const WSABUF pBuffers[], int iCount);
  
  /**********************************************************************************/
  /****************************** UDP Node 属性访问方法 ******************************/
  
  /* 设置附加数据 */
  HPSOCKET_API void __HP_CALL HP_UdpNode_SetExtra(HP_UdpNode pNode, PVOID pExtra);
  
  /* 获取附加数据 */
  HPSOCKET_API PVOID __HP_CALL HP_UdpNode_GetExtra(HP_UdpNode pNode);
  
  /* 检查通信组件是否已启动 */
  HPSOCKET_API BOOL __HP_CALL HP_UdpNode_HasStarted(HP_UdpNode pNode);
  /* 查看通信组件当前状态 */
  HPSOCKET_API En_HP_ServiceState __HP_CALL HP_UdpNode_GetState(HP_UdpNode pNode);
  /* 获取最近一次失败操作的错误代码 */
  HPSOCKET_API En_HP_SocketError __HP_CALL HP_UdpNode_GetLastError(HP_UdpNode pNode);
  /* 获取最近一次失败操作的错误描述 */
  HPSOCKET_API LPCTSTR __HP_CALL HP_UdpNode_GetLastErrorDesc(HP_UdpNode pNode);
  /* 获取本节点地址 */
  HPSOCKET_API BOOL __HP_CALL HP_UdpNode_GetLocalAddress(HP_UdpNode pNode, TCHAR lpszAddress[], int* piAddressLen, USHORT* pusPort);
  /* 获取本节点传播地址 */
  HPSOCKET_API BOOL __HP_CALL HP_UdpNode_GetCastAddress(HP_UdpNode pNode, TCHAR lpszAddress[], int* piAddressLen, USHORT* pusPort);
  /* 获取传播模式 */
  HPSOCKET_API En_HP_CastMode __HP_CALL HP_UdpNode_GetCastMode(HP_UdpNode pNode);
  /* 获取未发出数据的长度 */
  HPSOCKET_API BOOL __HP_CALL HP_UdpNode_GetPendingDataLength(HP_UdpNode pNode, int* piPending);
  
  /* 设置数据报文最大长度（建议在局域网环境下不超过 1432 字节，在广域网环境下不超过 548 字节） */
  HPSOCKET_API void __HP_CALL HP_UdpNode_SetMaxDatagramSize(HP_UdpNode pNode, DWORD dwMaxDatagramSize);
  /* 获取数据报文最大长度 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpNode_GetMaxDatagramSize(HP_UdpNode pNode);
  
  /* 设置组播报文的 TTL（0 - 255） */
  HPSOCKET_API void __HP_CALL HP_UdpNode_SetMultiCastTtl(HP_UdpNode pNode, int iMCTtl);
  /* 获取组播报文的 TTL */
  HPSOCKET_API int __HP_CALL HP_UdpNode_GetMultiCastTtl(HP_UdpNode pNode);
  
  /* 设置是否启用组播环路（TRUE or FALSE） */
  HPSOCKET_API void __HP_CALL HP_UdpNode_SetMultiCastLoop(HP_UdpNode pNode, BOOL bMCLoop);
  /* 检测是否启用组播环路 */
  HPSOCKET_API BOOL __HP_CALL HP_UdpNode_IsMultiCastLoop(HP_UdpNode pNode);
  
  /* 设置地址重用选项 */
  HPSOCKET_API void __HP_CALL HP_UdpNode_SetReuseAddressPolicy(HP_UdpNode pNode, En_HP_ReuseAddressPolicy enReusePolicy);
  /* 设置工作线程数量（通常设置为 2 * CPU + 2） */
  HPSOCKET_API void __HP_CALL HP_UdpNode_SetWorkerThreadCount(HP_UdpNode pNode, DWORD dwWorkerThreadCount);
  /* 设置 Receive 预投递数量（根据负载调整设置，Receive 预投递数量越大则丢包概率越小） */
  HPSOCKET_API void __HP_CALL HP_UdpNode_SetPostReceiveCount(HP_UdpNode pNode, DWORD dwPostReceiveCount);
  /* 设置内存块缓存池大小 */
  HPSOCKET_API void __HP_CALL HP_UdpNode_SetFreeBufferPoolSize(HP_UdpNode pNode, DWORD dwFreeBufferPoolSize);
  /* 设置内存块缓存池回收阀值 */
  HPSOCKET_API void __HP_CALL HP_UdpNode_SetFreeBufferPoolHold(HP_UdpNode pNode, DWORD dwFreeBufferPoolHold);
  
  /* 获取地址重用选项 */
  HPSOCKET_API En_HP_ReuseAddressPolicy __HP_CALL HP_UdpNode_GetReuseAddressPolicy(HP_UdpNode pNode);
  /* 获取工作线程数量 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpNode_GetWorkerThreadCount(HP_UdpNode pNode);
  /* 获取 Receive 预投递数量 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpNode_GetPostReceiveCount(HP_UdpNode pNode);
  /* 获取内存块缓存池大小 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpNode_GetFreeBufferPoolSize(HP_UdpNode pNode);
  /* 获取内存块缓存池回收阀值 */
  HPSOCKET_API DWORD __HP_CALL HP_UdpNode_GetFreeBufferPoolHold(HP_UdpNode pNode);
  
  #endif
  
  /***************************************************************************************/
  /***************************** TCP Pull Server 组件操作方法 *****************************/
  
  /*
  * 名称：抓取数据
  * 描述：用户通过该方法从 Socket 组件中抓取数据
  *		
  * 参数：		dwConnID	-- 连接 ID
  *			pData		-- 抓取缓冲区
  *			iLength		-- 抓取数据长度
  * 返回值：	En_HP_FetchResult
  */
  HPSOCKET_API En_HP_FetchResult __HP_CALL HP_TcpPullServer_Fetch(HP_TcpPullServer pServer, HP_CONNID dwConnID, BYTE* pData, int iLength);
  
  /*
  * 名称：窥探数据（不会移除缓冲区数据）
  * 描述：用户通过该方法从 Socket 组件中窥探数据
  *		
  * 参数：		dwConnID	-- 连接 ID
  *			pData		-- 窥探缓冲区
  *			iLength		-- 窥探数据长度
  * 返回值：	En_HP_FetchResult
  */
  HPSOCKET_API En_HP_FetchResult __HP_CALL HP_TcpPullServer_Peek(HP_TcpPullServer pServer, HP_CONNID dwConnID, BYTE* pData, int iLength);
  
  /***************************************************************************************/
  /***************************** TCP Pull Server 属性访问方法 *****************************/
  
  /***************************************************************************************/
  /***************************** TCP Pull Agent 组件操作方法 *****************************/
  
  /*
  * 名称：抓取数据
  * 描述：用户通过该方法从 Socket 组件中抓取数据
  *		
  * 参数：		dwConnID	-- 连接 ID
  *			pData		-- 抓取缓冲区
  *			iLength		-- 抓取数据长度
  * 返回值：	En_HP_FetchResult
  */
  HPSOCKET_API En_HP_FetchResult __HP_CALL HP_TcpPullAgent_Fetch(HP_TcpPullAgent pAgent, HP_CONNID dwConnID, BYTE* pData, int iLength);
  
  /*
  * 名称：窥探数据（不会移除缓冲区数据）
  * 描述：用户通过该方法从 Socket 组件中窥探数据
  *		
  * 参数：		dwConnID	-- 连接 ID
  *			pData		-- 窥探缓冲区
  *			iLength		-- 窥探数据长度
  * 返回值：	En_HP_FetchResult
  */
  HPSOCKET_API En_HP_FetchResult __HP_CALL HP_TcpPullAgent_Peek(HP_TcpPullAgent pAgent, HP_CONNID dwConnID, BYTE* pData, int iLength);
  
  /***************************************************************************************/
  /***************************** TCP Pull Agent 属性访问方法 *****************************/
  
  /***************************************************************************************/
  /***************************** TCP Pull Client 组件操作方法 *****************************/
  
  /*
  * 名称：抓取数据
  * 描述：用户通过该方法从 Socket 组件中抓取数据
  *		
  * 参数：		dwConnID	-- 连接 ID
  *			pData		-- 抓取缓冲区
  *			iLength		-- 抓取数据长度
  * 返回值：	En_HP_FetchResult
  */
  HPSOCKET_API En_HP_FetchResult __HP_CALL HP_TcpPullClient_Fetch(HP_TcpPullClient pClient, BYTE* pData, int iLength);
  
  /*
  * 名称：窥探数据（不会移除缓冲区数据）
  * 描述：用户通过该方法从 Socket 组件中窥探数据
  *		
  * 参数：		dwConnID	-- 连接 ID
  *			pData		-- 窥探缓冲区
  *			iLength		-- 窥探数据长度
  * 返回值：	En_HP_FetchResult
  */
  HPSOCKET_API En_HP_FetchResult __HP_CALL HP_TcpPullClient_Peek(HP_TcpPullClient pClient, BYTE* pData, int iLength);
  
  /***************************************************************************************/
  /***************************** TCP Pull Client 属性访问方法 *****************************/
  
  /***************************************************************************************/
  /***************************** TCP Pack Server 组件操作方法 *****************************/
  
  /***************************************************************************************/
  /***************************** TCP Pack Server 属性访问方法 *****************************/
  
  /* 设置数据包最大长度（有效数据包最大长度不能超过 4194303/0x3FFFFF 字节，默认：262144/0x40000） */
  HPSOCKET_API void __HP_CALL HP_TcpPackServer_SetMaxPackSize(HP_TcpPackServer pServer, DWORD dwMaxPackSize);
  /* 设置包头标识（有效包头标识取值范围 0 ~ 1023/0x3FF，当包头标识为 0 时不校验包头，默认：0） */
  HPSOCKET_API void __HP_CALL HP_TcpPackServer_SetPackHeaderFlag(HP_TcpPackServer pServer, USHORT usPackHeaderFlag);
  
  /* 获取数据包最大长度 */
  HPSOCKET_API DWORD __HP_CALL HP_TcpPackServer_GetMaxPackSize(HP_TcpPackServer pServer);
  /* 获取包头标识 */
  HPSOCKET_API USHORT __HP_CALL HP_TcpPackServer_GetPackHeaderFlag(HP_TcpPackServer pServer);
  
  /***************************************************************************************/
  /***************************** TCP Pack Agent 组件操作方法 *****************************/
  
  /***************************************************************************************/
  /***************************** TCP Pack Agent 属性访问方法 *****************************/
  
  /* 设置数据包最大长度（有效数据包最大长度不能超过 4194303/0x3FFFFF 字节，默认：262144/0x40000） */
  HPSOCKET_API void __HP_CALL HP_TcpPackAgent_SetMaxPackSize(HP_TcpPackAgent pAgent, DWORD dwMaxPackSize);
  /* 设置包头标识（有效包头标识取值范围 0 ~ 1023/0x3FF，当包头标识为 0 时不校验包头，默认：0） */
  HPSOCKET_API void __HP_CALL HP_TcpPackAgent_SetPackHeaderFlag(HP_TcpPackAgent pAgent, USHORT usPackHeaderFlag);
  
  /* 获取数据包最大长度 */
  HPSOCKET_API DWORD __HP_CALL HP_TcpPackAgent_GetMaxPackSize(HP_TcpPackAgent pAgent);
  /* 获取包头标识 */
  HPSOCKET_API USHORT __HP_CALL HP_TcpPackAgent_GetPackHeaderFlag(HP_TcpPackAgent pAgent);
  
  /***************************************************************************************/
  /***************************** TCP Pack Client 组件操作方法 *****************************/
  
  /***************************************************************************************/
  /***************************** TCP Pack Client 属性访问方法 *****************************/
  
  /* 设置数据包最大长度（有效数据包最大长度不能超过 4194303/0x3FFFFF 字节，默认：262144/0x40000） */
  HPSOCKET_API void __HP_CALL HP_TcpPackClient_SetMaxPackSize(HP_TcpPackClient pClient, DWORD dwMaxPackSize);
  /* 设置包头标识（有效包头标识取值范围 0 ~ 1023/0x3FF，当包头标识为 0 时不校验包头，默认：0） */
  HPSOCKET_API void __HP_CALL HP_TcpPackClient_SetPackHeaderFlag(HP_TcpPackClient pClient, USHORT usPackHeaderFlag);
  
  /* 获取数据包最大长度 */
  HPSOCKET_API DWORD __HP_CALL HP_TcpPackClient_GetMaxPackSize(HP_TcpPackClient pClient);
  /* 获取包头标识 */
  HPSOCKET_API USHORT __HP_CALL HP_TcpPackClient_GetPackHeaderFlag(HP_TcpPackClient pClient);
  
  /*****************************************************************************************************************************************************/
  /*************************************************************** Global Function Exports *************************************************************/
  /*****************************************************************************************************************************************************/
  
  // 获取 HPSocket 版本号（4 个字节分别为：主版本号，子版本号，修正版本号，构建编号）
  HPSOCKET_API DWORD __HP_CALL HP_GetHPSocketVersion();
  
  /* 获取错误描述文本 */
  HPSOCKET_API LPCTSTR __HP_CALL HP_GetSocketErrorDesc(En_HP_SocketError enCode);
  /* 调用系统的 GetLastError() 方法获取系统错误代码 */
  HPSOCKET_API DWORD __HP_CALL SYS_GetLastError();
  // 调用系统的 WSAGetLastError() 方法获取系统错误代码
  HPSOCKET_API int __HP_CALL SYS_WSAGetLastError();
  // 调用系统的 setsockopt()
  HPSOCKET_API int __HP_CALL SYS_SetSocketOption(SOCKET sock, int level, int name, LPVOID val, int len);
  // 调用系统的 getsockopt()
  HPSOCKET_API int __HP_CALL SYS_GetSocketOption(SOCKET sock, int level, int name, LPVOID val, int* len);
  // 调用系统的 ioctlsocket()
  HPSOCKET_API int __HP_CALL SYS_IoctlSocket(SOCKET sock, long cmd, u_long* arg);
  // 调用系统的 WSAIoctl()
  HPSOCKET_API int __HP_CALL SYS_WSAIoctl(SOCKET sock, DWORD dwIoControlCode, LPVOID lpvInBuffer, DWORD cbInBuffer, LPVOID lpvOutBuffer, DWORD cbOutBuffer, LPDWORD lpcbBytesReturned);
  
  // 设置 socket 选项：IPPROTO_TCP -> TCP_NODELAY
  HPSOCKET_API int __HP_CALL SYS_SSO_NoDelay(SOCKET sock, BOOL bNoDelay);
  // 设置 socket 选项：SOL_SOCKET -> SO_DONTLINGER
  HPSOCKET_API int __HP_CALL SYS_SSO_DontLinger(SOCKET sock, BOOL bDont);
  // 设置 socket 选项：SOL_SOCKET -> SO_LINGER
  HPSOCKET_API int __HP_CALL SYS_SSO_Linger(SOCKET sock, USHORT l_onoff, USHORT l_linger);
  // 设置 socket 选项：SOL_SOCKET -> SO_RCVBUF
  HPSOCKET_API int __HP_CALL SYS_SSO_RecvBuffSize(SOCKET sock, int size);
  // 设置 socket 选项：SOL_SOCKET -> SO_SNDBUF
  HPSOCKET_API int __HP_CALL SYS_SSO_SendBuffSize(SOCKET sock, int size);
  // 设置 socket 选项：SOL_SOCKET -> SO_RCVTIMEO
  HPSOCKET_API int __HP_CALL SYS_SSO_RecvTimeOut(SOCKET sock, int ms);
  // 设置 socket 选项：SOL_SOCKET -> SO_SNDTIMEO
  HPSOCKET_API int __HP_CALL SYS_SSO_SendTimeOut(SOCKET sock, int ms);
  // 设置 socket 选项：SOL_SOCKET -> SO_EXCLUSIVEADDRUSE / SO_REUSEADDR
  HPSOCKET_API int __HP_CALL SYS_SSO_ReuseAddress(SOCKET sock, En_HP_ReuseAddressPolicy opt);
  // 设置 socket 选项：SOL_SOCKET -> SO_EXCLUSIVEADDRUSE
  HPSOCKET_API int __HP_CALL SYS_SSO_ExclusiveAddressUse(SOCKET sock, BOOL bExclusive);
  
  // 获取 SOCKET 本地地址信息
  HPSOCKET_API BOOL __HP_CALL SYS_GetSocketLocalAddress(SOCKET socket, TCHAR lpszAddress[], int* piAddressLen, USHORT* pusPort);
  // 获取 SOCKET 远程地址信息
  HPSOCKET_API BOOL __HP_CALL SYS_GetSocketRemoteAddress(SOCKET socket, TCHAR lpszAddress[], int* piAddressLen, USHORT* pusPort);
  
  /* 枚举主机 IP 地址 */
  HPSOCKET_API BOOL __HP_CALL SYS_EnumHostIPAddresses(LPCTSTR lpszHost, En_HP_IPAddrType enType, HP_LPTIPAddr** lpppIPAddr, int* piIPAddrCount);
  /* 释放 HP_LPTIPAddr* */
  HPSOCKET_API BOOL __HP_CALL SYS_FreeHostIPAddresses(HP_LPTIPAddr* lppIPAddr);
  /* 检查字符串是否符合 IP 地址格式 */
  HPSOCKET_API BOOL __HP_CALL SYS_IsIPAddress(LPCTSTR lpszAddress, En_HP_IPAddrType* penType);
  /* 通过主机名获取 IP 地址 */
  HPSOCKET_API BOOL __HP_CALL SYS_GetIPAddress(LPCTSTR lpszHost, TCHAR lpszIP[], int* piIPLenth, En_HP_IPAddrType* penType);
  
  /* 64 位网络字节序转主机字节序 */
  HPSOCKET_API ULONGLONG __HP_CALL SYS_NToH64(ULONGLONG value);
  /* 64 位主机字节序转网络字节序 */
  HPSOCKET_API ULONGLONG __HP_CALL SYS_HToN64(ULONGLONG value);
  /* 短整型高低字节交换 */
  HPSOCKET_API USHORT __HP_CALL SYS_SwapEndian16(USHORT value);
  /* 长整型高低字节交换 */
  HPSOCKET_API DWORD __HP_CALL SYS_SwapEndian32(DWORD value);
  /* 检查是否小端字节序 */
  HPSOCKET_API BOOL __HP_CALL SYS_IsLittleEndian();
  
  /* 分配内存 */
  HPSOCKET_API LPBYTE __HP_CALL SYS_Malloc(int size);
  /* 重新分配内存 */
  HPSOCKET_API LPBYTE __HP_CALL SYS_Realloc(LPBYTE p, int size);
  /* 释放内存 */
  HPSOCKET_API VOID __HP_CALL SYS_Free(LPBYTE p);
  /* 分配内存块 */
  HPSOCKET_API LPVOID __HP_CALL SYS_Calloc(int number, int size);
  /* 分配栈内存 */
  HPSOCKET_API LPBYTE __HP_CALL SYS_Alloca(int size);
  
  // CP_XXX -> UNICODE
  HPSOCKET_API BOOL __HP_CALL SYS_CodePageToUnicode(int iCodePage, const char szSrc[], WCHAR szDest[], int* piDestLength);
  // UNICODE -> CP_XXX
  HPSOCKET_API BOOL __HP_CALL SYS_UnicodeToCodePage(int iCodePage, const WCHAR szSrc[], char szDest[], int* piDestLength);
  // GBK -> UNICODE
  HPSOCKET_API BOOL __HP_CALL SYS_GbkToUnicode(const char szSrc[], WCHAR szDest[], int* piDestLength);
  // UNICODE -> GBK
  HPSOCKET_API BOOL __HP_CALL SYS_UnicodeToGbk(const WCHAR szSrc[], char szDest[], int* piDestLength);
  // UTF8 -> UNICODE
  HPSOCKET_API BOOL __HP_CALL SYS_Utf8ToUnicode(const char szSrc[], WCHAR szDest[], int* piDestLength);
  // UNICODE -> UTF8
  HPSOCKET_API BOOL __HP_CALL SYS_UnicodeToUtf8(const WCHAR szSrc[], char szDest[], int* piDestLength);
  // GBK -> UTF8
  HPSOCKET_API BOOL __HP_CALL SYS_GbkToUtf8(const char szSrc[], char szDest[], int* piDestLength);
  // UTF8 -> GBK
  HPSOCKET_API BOOL __HP_CALL SYS_Utf8ToGbk(const char szSrc[], char szDest[], int* piDestLength);
  
  // 计算 Base64 编码后长度
  HPSOCKET_API DWORD __HP_CALL SYS_GuessBase64EncodeBound(DWORD dwSrcLen);
  // 计算 Base64 解码后长度
  HPSOCKET_API DWORD __HP_CALL SYS_GuessBase64DecodeBound(const BYTE* lpszSrc, DWORD dwSrcLen);
  // Base64 编码（返回值：0 -> 成功，-3 -> 输入数据不正确，-5 -> 输出缓冲区不足）
  HPSOCKET_API int __HP_CALL SYS_Base64Encode(const BYTE* lpszSrc, DWORD dwSrcLen, BYTE* lpszDest, DWORD* pdwDestLen);
  // Base64 解码（返回值：0 -> 成功，-3 -> 输入数据不正确，-5 -> 输出缓冲区不足）
  HPSOCKET_API int __HP_CALL SYS_Base64Decode(const BYTE* lpszSrc, DWORD dwSrcLen, BYTE* lpszDest, DWORD* pdwDestLen);
  
  // 计算 URL 编码后长度
  HPSOCKET_API DWORD __HP_CALL SYS_GuessUrlEncodeBound(const BYTE* lpszSrc, DWORD dwSrcLen);
  // 计算 URL 解码后长度
  HPSOCKET_API DWORD __HP_CALL SYS_GuessUrlDecodeBound(const BYTE* lpszSrc, DWORD dwSrcLen);
  // URL 编码（返回值：0 -> 成功，-3 -> 输入数据不正确，-5 -> 输出缓冲区不足）
  HPSOCKET_API int __HP_CALL SYS_UrlEncode(BYTE* lpszSrc, DWORD dwSrcLen, BYTE* lpszDest, DWORD* pdwDestLen);
  // URL 解码（返回值：0 -> 成功，-3 -> 输入数据不正确，-5 -> 输出缓冲区不足）
  HPSOCKET_API int __HP_CALL SYS_UrlDecode(BYTE* lpszSrc, DWORD dwSrcLen, BYTE* lpszDest, DWORD* pdwDestLen);
  
  #ifdef _ZLIB_SUPPORT
  
  // 普通压缩（返回值：0 -> 成功，-3 -> 输入数据不正确，-5 -> 输出缓冲区不足）
  HPSOCKET_API int __HP_CALL SYS_Compress(const BYTE* lpszSrc, DWORD dwSrcLen, BYTE* lpszDest, DWORD* pdwDestLen);
  // 高级压缩（返回值：0 -> 成功，-3 -> 输入数据不正确，-5 -> 输出缓冲区不足）
  //（默认参数：iLevel -> -1，iMethod -> 8，iWindowBits -> 15，iMemLevel -> 8，iStrategy -> 0）
  HPSOCKET_API int __HP_CALL SYS_CompressEx(const BYTE* lpszSrc, DWORD dwSrcLen, BYTE* lpszDest, DWORD* pdwDestLen, int iLevel, int iMethod, int iWindowBits, int iMemLevel, int iStrategy);
  // 普通解压（返回值：0 -> 成功，-3 -> 输入数据不正确，-5 -> 输出缓冲区不足）
  HPSOCKET_API int __HP_CALL SYS_Uncompress(const BYTE* lpszSrc, DWORD dwSrcLen, BYTE* lpszDest, DWORD* pdwDestLen);
  // 高级解压（返回值：0 -> 成功，-3 -> 输入数据不正确，-5 -> 输出缓冲区不足）
  //（默认参数：iWindowBits -> 15）
  HPSOCKET_API int __HP_CALL SYS_UncompressEx(const BYTE* lpszSrc, DWORD dwSrcLen, BYTE* lpszDest, DWORD* pdwDestLen, int iWindowBits);
  // 推测压缩结果长度
  HPSOCKET_API DWORD __HP_CALL SYS_GuessCompressBound(DWORD dwSrcLen, BOOL bGZip);
  
  // Gzip 压缩（返回值：0 -> 成功，-3 -> 输入数据不正确，-5 -> 输出缓冲区不足）
  HPSOCKET_API int __HP_CALL SYS_GZipCompress(const BYTE* lpszSrc, DWORD dwSrcLen, BYTE* lpszDest, DWORD* pdwDestLen);
  // Gzip 解压（返回值：0 -> 成功，-3 -> 输入数据不正确，-5 -> 输出缓冲区不足）
  HPSOCKET_API int __HP_CALL SYS_GZipUncompress(const BYTE* lpszSrc, DWORD dwSrcLen, BYTE* lpszDest, DWORD* pdwDestLen);
  // 推测 Gzip 解压结果长度（如果返回 0 或不合理值则说明输入内容并非有效的 Gzip 格式）
  HPSOCKET_API DWORD __HP_CALL SYS_GZipGuessUncompressBound(const BYTE* lpszSrc, DWORD dwSrcLen);
  
  #endif
  
  #ifdef _BROTLI_SUPPORT
  
  // Brotli 压缩（返回值：0 -> 成功，-3 -> 输入数据不正确，-5 -> 输出缓冲区不足）
  HPSOCKET_API int __HP_CALL SYS_BrotliCompress(const BYTE* lpszSrc, DWORD dwSrcLen, BYTE* lpszDest, DWORD* pdwDestLen);
  // Brotli 高级压缩（返回值：0 -> 成功，-3 -> 输入数据不正确，-5 -> 输出缓冲区不足）
  //（默认参数：iQuality -> 11，iWindow -> 22，iMode -> 0）
  HPSOCKET_API int __HP_CALL SYS_BrotliCompressEx(const BYTE* lpszSrc, DWORD dwSrcLen, BYTE* lpszDest, DWORD* pdwDestLen, int iQuality, int iWindow, int iMode);
  // Brotli 解压（返回值：0 -> 成功，-3 -> 输入数据不正确，-5 -> 输出缓冲区不足）
  HPSOCKET_API int __HP_CALL SYS_BrotliUncompress(const BYTE* lpszSrc, DWORD dwSrcLen, BYTE* lpszDest, DWORD* pdwDestLen);
  // Brotli 推测压缩结果长度
  HPSOCKET_API DWORD __HP_CALL SYS_BrotliGuessCompressBound(DWORD dwSrcLen);
  
  #endif
  
  /*****************************************************************************************************************************************************/
  /******************************************************************** HTTP Exports *******************************************************************/
  /*****************************************************************************************************************************************************/
  
  #ifdef _HTTP_SUPPORT
  
  /****************************************************/
  /******************* HTTP 回调函数 *******************/
  
  /* HTTP 回调函数 */
  typedef En_HP_HttpParseResult (__HP_CALL *HP_FN_Http_OnMessageBegin)	(HP_Http pSender, HP_CONNID dwConnID);
  typedef En_HP_HttpParseResult (__HP_CALL *HP_FN_Http_OnRequestLine)		(HP_Http pSender, HP_CONNID dwConnID, LPCSTR lpszMethod, LPCSTR lpszUrl);
  typedef En_HP_HttpParseResult (__HP_CALL *HP_FN_Http_OnStatusLine)		(HP_Http pSender, HP_CONNID dwConnID, USHORT usStatusCode, LPCSTR lpszDesc);
  typedef En_HP_HttpParseResult (__HP_CALL *HP_FN_Http_OnHeader)			(HP_Http pSender, HP_CONNID dwConnID, LPCSTR lpszName, LPCSTR lpszValue);
  typedef En_HP_HttpParseResult (__HP_CALL *HP_FN_Http_OnHeadersComplete)	(HP_Http pSender, HP_CONNID dwConnID);
  typedef En_HP_HttpParseResult (__HP_CALL *HP_FN_Http_OnBody)			(HP_Http pSender, HP_CONNID dwConnID, const BYTE* pData, int iLength);
  typedef En_HP_HttpParseResult (__HP_CALL *HP_FN_Http_OnChunkHeader)		(HP_Http pSender, HP_CONNID dwConnID, int iLength);
  typedef En_HP_HttpParseResult (__HP_CALL *HP_FN_Http_OnChunkComplete)	(HP_Http pSender, HP_CONNID dwConnID);
  typedef En_HP_HttpParseResult (__HP_CALL *HP_FN_Http_OnMessageComplete)	(HP_Http pSender, HP_CONNID dwConnID);
  typedef En_HP_HttpParseResult (__HP_CALL *HP_FN_Http_OnUpgrade)			(HP_Http pSender, HP_CONNID dwConnID, En_HP_HttpUpgradeType enUpgradeType);
  typedef En_HP_HttpParseResult (__HP_CALL *HP_FN_Http_OnParseError)		(HP_Http pSender, HP_CONNID dwConnID, int iErrorCode, LPCSTR lpszErrorDesc);
  
  typedef En_HP_HandleResult	 (__HP_CALL *HP_FN_Http_OnWSMessageHeader)	(HP_Http pSender, HP_CONNID dwConnID, BOOL bFinal, BYTE iReserved, BYTE iOperationCode, const BYTE lpszMask[4], ULONGLONG ullBodyLen);
  typedef En_HP_HandleResult	 (__HP_CALL *HP_FN_Http_OnWSMessageBody)	(HP_Http pSender, HP_CONNID dwConnID, const BYTE* pData, int iLength);
  typedef En_HP_HandleResult	 (__HP_CALL *HP_FN_Http_OnWSMessageComplete)(HP_Http pSender, HP_CONNID dwConnID);
  
  /* HTTP Server 回调函数 */
  typedef HP_FN_Http_OnMessageBegin			HP_FN_HttpServer_OnMessageBegin;
  typedef HP_FN_Http_OnRequestLine			HP_FN_HttpServer_OnRequestLine;
  typedef HP_FN_Http_OnHeader					HP_FN_HttpServer_OnHeader;
  typedef HP_FN_Http_OnHeadersComplete		HP_FN_HttpServer_OnHeadersComplete;
  typedef HP_FN_Http_OnBody					HP_FN_HttpServer_OnBody;
  typedef HP_FN_Http_OnChunkHeader			HP_FN_HttpServer_OnChunkHeader;
  typedef HP_FN_Http_OnChunkComplete			HP_FN_HttpServer_OnChunkComplete;
  typedef HP_FN_Http_OnMessageComplete		HP_FN_HttpServer_OnMessageComplete;
  typedef HP_FN_Http_OnUpgrade				HP_FN_HttpServer_OnUpgrade;
  typedef HP_FN_Http_OnParseError				HP_FN_HttpServer_OnParseError;
  
  typedef HP_FN_Http_OnWSMessageHeader		HP_FN_HttpServer_OnWSMessageHeader;
  typedef HP_FN_Http_OnWSMessageBody			HP_FN_HttpServer_OnWSMessageBody;
  typedef HP_FN_Http_OnWSMessageComplete		HP_FN_HttpServer_OnWSMessageComplete;
  
  typedef HP_FN_Server_OnPrepareListen		HP_FN_HttpServer_OnPrepareListen;
  typedef HP_FN_Server_OnAccept				HP_FN_HttpServer_OnAccept;
  typedef HP_FN_Server_OnHandShake			HP_FN_HttpServer_OnHandShake;
  typedef HP_FN_Server_OnReceive				HP_FN_HttpServer_OnReceive;
  typedef HP_FN_Server_OnSend					HP_FN_HttpServer_OnSend;
  typedef HP_FN_Server_OnClose				HP_FN_HttpServer_OnClose;
  typedef HP_FN_Server_OnShutdown				HP_FN_HttpServer_OnShutdown;
  
  /* HTTP Agent 回调函数 */
  typedef HP_FN_Http_OnMessageBegin			HP_FN_HttpAgent_OnMessageBegin;
  typedef HP_FN_Http_OnStatusLine				HP_FN_HttpAgent_OnStatusLine;
  typedef HP_FN_Http_OnHeader					HP_FN_HttpAgent_OnHeader;
  typedef HP_FN_Http_OnHeadersComplete		HP_FN_HttpAgent_OnHeadersComplete;
  typedef HP_FN_Http_OnBody					HP_FN_HttpAgent_OnBody;
  typedef HP_FN_Http_OnChunkHeader			HP_FN_HttpAgent_OnChunkHeader;
  typedef HP_FN_Http_OnChunkComplete			HP_FN_HttpAgent_OnChunkComplete;
  typedef HP_FN_Http_OnMessageComplete		HP_FN_HttpAgent_OnMessageComplete;
  typedef HP_FN_Http_OnUpgrade				HP_FN_HttpAgent_OnUpgrade;
  typedef HP_FN_Http_OnParseError				HP_FN_HttpAgent_OnParseError;
  
  typedef HP_FN_Http_OnWSMessageHeader		HP_FN_HttpAgent_OnWSMessageHeader;
  typedef HP_FN_Http_OnWSMessageBody			HP_FN_HttpAgent_OnWSMessageBody;
  typedef HP_FN_Http_OnWSMessageComplete		HP_FN_HttpAgent_OnWSMessageComplete;
  
  typedef HP_FN_Agent_OnPrepareConnect		HP_FN_HttpAgent_OnPrepareConnect;
  typedef HP_FN_Agent_OnConnect				HP_FN_HttpAgent_OnConnect;
  typedef HP_FN_Agent_OnHandShake				HP_FN_HttpAgent_OnHandShake;
  typedef HP_FN_Agent_OnReceive				HP_FN_HttpAgent_OnReceive;
  typedef HP_FN_Agent_OnSend					HP_FN_HttpAgent_OnSend;
  typedef HP_FN_Agent_OnClose					HP_FN_HttpAgent_OnClose;
  typedef HP_FN_Agent_OnShutdown				HP_FN_HttpAgent_OnShutdown;
  
  /* HTTP Client 回调函数 */
  typedef HP_FN_Http_OnMessageBegin			HP_FN_HttpClient_OnMessageBegin;
  typedef HP_FN_Http_OnStatusLine				HP_FN_HttpClient_OnStatusLine;
  typedef HP_FN_Http_OnHeader					HP_FN_HttpClient_OnHeader;
  typedef HP_FN_Http_OnHeadersComplete		HP_FN_HttpClient_OnHeadersComplete;
  typedef HP_FN_Http_OnBody					HP_FN_HttpClient_OnBody;
  typedef HP_FN_Http_OnChunkHeader			HP_FN_HttpClient_OnChunkHeader;
  typedef HP_FN_Http_OnChunkComplete			HP_FN_HttpClient_OnChunkComplete;
  typedef HP_FN_Http_OnMessageComplete		HP_FN_HttpClient_OnMessageComplete;
  typedef HP_FN_Http_OnUpgrade				HP_FN_HttpClient_OnUpgrade;
  typedef HP_FN_Http_OnParseError				HP_FN_HttpClient_OnParseError;
  
  typedef HP_FN_Http_OnWSMessageHeader		HP_FN_HttpClient_OnWSMessageHeader;
  typedef HP_FN_Http_OnWSMessageBody			HP_FN_HttpClient_OnWSMessageBody;
  typedef HP_FN_Http_OnWSMessageComplete		HP_FN_HttpClient_OnWSMessageComplete;
  
  typedef HP_FN_Client_OnPrepareConnect		HP_FN_HttpClient_OnPrepareConnect;
  typedef HP_FN_Client_OnConnect				HP_FN_HttpClient_OnConnect;
  typedef HP_FN_Client_OnHandShake			HP_FN_HttpClient_OnHandShake;
  typedef HP_FN_Client_OnReceive				HP_FN_HttpClient_OnReceive;
  typedef HP_FN_Client_OnSend					HP_FN_HttpClient_OnSend;
  typedef HP_FN_Client_OnClose				HP_FN_HttpClient_OnClose;
  
  /****************************************************/
  /***************** HTTP 对象创建函数 *****************/
  
  // 创建 HP_HttpServer 对象
  HPSOCKET_API HP_HttpServer __HP_CALL Create_HP_HttpServer(HP_HttpServerListener pListener);
  // 创建 HP_HttpAgent 对象
  HPSOCKET_API HP_HttpAgent __HP_CALL Create_HP_HttpAgent(HP_HttpAgentListener pListener);
  // 创建 HP_HttpClient 对象
  HPSOCKET_API HP_HttpClient __HP_CALL Create_HP_HttpClient(HP_HttpClientListener pListener);
  // 创建 HP_HttpSyncClient 对象
  HPSOCKET_API HP_HttpSyncClient __HP_CALL Create_HP_HttpSyncClient(HP_HttpClientListener pListener);
  
  // 销毁 HP_HttpServer 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_HttpServer(HP_HttpServer pServer);
  // 销毁 HP_HttpAgent 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_HttpAgent(HP_HttpAgent pAgent);
  // 销毁 HP_HttpClient 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_HttpClient(HP_HttpClient pClient);
  // 销毁 HP_HttpSyncClient 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_HttpSyncClient(HP_HttpSyncClient pClient);
  
  // 创建 HP_HttpServerListener 对象
  HPSOCKET_API HP_HttpServerListener __HP_CALL Create_HP_HttpServerListener();
  // 创建 HP_HttpAgentListener 对象
  HPSOCKET_API HP_HttpAgentListener __HP_CALL Create_HP_HttpAgentListener();
  // 创建 HP_HttpClientListener 对象
  HPSOCKET_API HP_HttpClientListener __HP_CALL Create_HP_HttpClientListener();
  
  // 销毁 HP_HttpServerListener 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_HttpServerListener(HP_HttpServerListener pListener);
  // 销毁 HP_HttpAgentListener 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_HttpAgentListener(HP_HttpAgentListener pListener);
  // 销毁 HP_HttpClientListener 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_HttpClientListener(HP_HttpClientListener pListener);
  
  /**********************************************************************************/
  /*************************** HTTP Server 回调函数设置方法 **************************/
  
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpServer_OnMessageBegin(HP_HttpServerListener pListener		, HP_FN_HttpServer_OnMessageBegin fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpServer_OnRequestLine(HP_HttpServerListener pListener		, HP_FN_HttpServer_OnRequestLine fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpServer_OnHeader(HP_HttpServerListener pListener			, HP_FN_HttpServer_OnHeader fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpServer_OnHeadersComplete(HP_HttpServerListener pListener	, HP_FN_HttpServer_OnHeadersComplete fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpServer_OnBody(HP_HttpServerListener pListener				, HP_FN_HttpServer_OnBody fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpServer_OnChunkHeader(HP_HttpServerListener pListener		, HP_FN_HttpServer_OnChunkHeader fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpServer_OnChunkComplete(HP_HttpServerListener pListener	, HP_FN_HttpServer_OnChunkComplete fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpServer_OnMessageComplete(HP_HttpServerListener pListener	, HP_FN_HttpServer_OnMessageComplete fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpServer_OnUpgrade(HP_HttpServerListener pListener			, HP_FN_HttpServer_OnUpgrade fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpServer_OnParseError(HP_HttpServerListener pListener		, HP_FN_HttpServer_OnParseError fn);
  
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpServer_OnWSMessageHeader(HP_HttpServerListener pListener	, HP_FN_HttpServer_OnWSMessageHeader fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpServer_OnWSMessageBody(HP_HttpServerListener pListener	, HP_FN_HttpServer_OnWSMessageBody fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpServer_OnWSMessageComplete(HP_HttpServerListener pListener, HP_FN_HttpServer_OnWSMessageComplete fn);
  
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpServer_OnPrepareListen(HP_HttpServerListener pListener	, HP_FN_HttpServer_OnPrepareListen fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpServer_OnAccept(HP_HttpServerListener pListener			, HP_FN_HttpServer_OnAccept fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpServer_OnHandShake(HP_HttpServerListener pListener		, HP_FN_HttpServer_OnHandShake fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpServer_OnReceive(HP_HttpServerListener pListener			, HP_FN_HttpServer_OnReceive fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpServer_OnSend(HP_HttpServerListener pListener				, HP_FN_HttpServer_OnSend fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpServer_OnClose(HP_HttpServerListener pListener			, HP_FN_HttpServer_OnClose fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpServer_OnShutdown(HP_HttpServerListener pListener			, HP_FN_HttpServer_OnShutdown fn);
  
  /**********************************************************************************/
  /**************************** HTTP Agent 回调函数设置方法 **************************/
  
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpAgent_OnMessageBegin(HP_HttpAgentListener pListener		, HP_FN_HttpAgent_OnMessageBegin fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpAgent_OnStatusLine(HP_HttpAgentListener pListener			, HP_FN_HttpAgent_OnStatusLine fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpAgent_OnHeader(HP_HttpAgentListener pListener				, HP_FN_HttpAgent_OnHeader fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpAgent_OnHeadersComplete(HP_HttpAgentListener pListener	, HP_FN_HttpAgent_OnHeadersComplete fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpAgent_OnBody(HP_HttpAgentListener pListener				, HP_FN_HttpAgent_OnBody fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpAgent_OnChunkHeader(HP_HttpAgentListener pListener		, HP_FN_HttpAgent_OnChunkHeader fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpAgent_OnChunkComplete(HP_HttpAgentListener pListener		, HP_FN_HttpAgent_OnChunkComplete fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpAgent_OnMessageComplete(HP_HttpAgentListener pListener	, HP_FN_HttpAgent_OnMessageComplete fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpAgent_OnUpgrade(HP_HttpAgentListener pListener			, HP_FN_HttpAgent_OnUpgrade fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpAgent_OnParseError(HP_HttpAgentListener pListener			, HP_FN_HttpAgent_OnParseError fn);
  
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpAgent_OnWSMessageHeader(HP_HttpAgentListener pListener	, HP_FN_HttpAgent_OnWSMessageHeader fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpAgent_OnWSMessageBody(HP_HttpAgentListener pListener		, HP_FN_HttpAgent_OnWSMessageBody fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpAgent_OnWSMessageComplete(HP_HttpAgentListener pListener	, HP_FN_HttpAgent_OnWSMessageComplete fn);
  
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpAgent_OnPrepareConnect(HP_HttpAgentListener pListener		, HP_FN_HttpAgent_OnPrepareConnect fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpAgent_OnConnect(HP_HttpAgentListener pListener			, HP_FN_HttpAgent_OnConnect fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpAgent_OnHandShake(HP_HttpAgentListener pListener			, HP_FN_HttpAgent_OnHandShake fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpAgent_OnReceive(HP_HttpAgentListener pListener			, HP_FN_HttpAgent_OnReceive fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpAgent_OnSend(HP_HttpAgentListener pListener				, HP_FN_HttpAgent_OnSend fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpAgent_OnClose(HP_HttpAgentListener pListener				, HP_FN_HttpAgent_OnClose fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpAgent_OnShutdown(HP_HttpAgentListener pListener			, HP_FN_HttpAgent_OnShutdown fn);
  
  /**********************************************************************************/
  /*************************** HTTP Client 回调函数设置方法 **************************/
  
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpClient_OnMessageBegin(HP_HttpClientListener pListener		, HP_FN_HttpClient_OnMessageBegin fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpClient_OnStatusLine(HP_HttpClientListener pListener		, HP_FN_HttpClient_OnStatusLine fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpClient_OnHeader(HP_HttpClientListener pListener			, HP_FN_HttpClient_OnHeader fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpClient_OnHeadersComplete(HP_HttpClientListener pListener	, HP_FN_HttpClient_OnHeadersComplete fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpClient_OnBody(HP_HttpClientListener pListener				, HP_FN_HttpClient_OnBody fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpClient_OnChunkHeader(HP_HttpClientListener pListener		, HP_FN_HttpClient_OnChunkHeader fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpClient_OnChunkComplete(HP_HttpClientListener pListener	, HP_FN_HttpClient_OnChunkComplete fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpClient_OnMessageComplete(HP_HttpClientListener pListener	, HP_FN_HttpClient_OnMessageComplete fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpClient_OnUpgrade(HP_HttpClientListener pListener			, HP_FN_HttpClient_OnUpgrade fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpClient_OnParseError(HP_HttpClientListener pListener		, HP_FN_HttpClient_OnParseError fn);
  
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpClient_OnWSMessageHeader(HP_HttpClientListener pListener	, HP_FN_HttpClient_OnWSMessageHeader fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpClient_OnWSMessageBody(HP_HttpClientListener pListener	, HP_FN_HttpClient_OnWSMessageBody fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpClient_OnWSMessageComplete(HP_HttpClientListener pListener, HP_FN_HttpClient_OnWSMessageComplete fn);
  
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpClient_OnPrepareConnect(HP_HttpClientListener pListener	, HP_FN_HttpClient_OnPrepareConnect fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpClient_OnConnect(HP_HttpClientListener pListener			, HP_FN_HttpClient_OnConnect fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpClient_OnHandShake(HP_HttpClientListener pListener		, HP_FN_HttpClient_OnHandShake fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpClient_OnReceive(HP_HttpClientListener pListener			, HP_FN_HttpClient_OnReceive fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpClient_OnSend(HP_HttpClientListener pListener				, HP_FN_HttpClient_OnSend fn);
  HPSOCKET_API void __HP_CALL HP_Set_FN_HttpClient_OnClose(HP_HttpClientListener pListener			, HP_FN_HttpClient_OnClose fn);
  
  /**************************************************************************/
  /*************************** HTTP Server 操作方法 **************************/
  
  /*
  * 名称：回复请求
  * 描述：向客户端回复 HTTP 请求
  *		
  * 参数：		dwConnID		-- 连接 ID
  *			usStatusCode	-- HTTP 状态码
  *			lpszDesc		-- HTTP 状态描述
  *			lpHeaders		-- 回复请求头
  *			iHeaderCount	-- 回复请求头数量
  *			pData			-- 回复请求体
  *			iLength			-- 回复请求体长度
  * 返回值：	TRUE			-- 成功
  *			FALSE			-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_HttpServer_SendResponse(HP_HttpServer pServer, HP_CONNID dwConnID, USHORT usStatusCode, LPCSTR lpszDesc, const HP_THeader lpHeaders[], int iHeaderCount, const BYTE* pData, int iLength);
  
  /*
  * 名称：发送本地文件
  * 描述：向指定连接发送 4096 KB 以下的小文件
  *		
  * 参数：		dwConnID		-- 连接 ID
  *			lpszFileName	-- 文件路径
  *			usStatusCode	-- HTTP 状态码
  *			lpszDesc		-- HTTP 状态描述
  *			lpHeaders		-- 回复请求头
  *			iHeaderCount	-- 回复请求头数量
  * 返回值：	TRUE			-- 成功
  *			FALSE			-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_HttpServer_SendLocalFile(HP_HttpServer pServer, HP_CONNID dwConnID, LPCSTR lpszFileName, USHORT usStatusCode, LPCSTR lpszDesc, const HP_THeader lpHeaders[], int iHeaderCount);
  
  /*
  * 名称：发送 Chunked 数据分片
  * 描述：向对端发送 Chunked 数据分片
  *		
  * 参数：		dwConnID		-- 连接 ID
  *			pData			-- Chunked 数据分片
  *			iLength			-- 数据分片长度（为 0 表示结束分片）
  *			lpszExtensions	-- 扩展属性（默认：nullptr）
  * 返回值：	TRUE			-- 成功
  *			FALSE			-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_HttpServer_SendChunkData(HP_HttpServer pServer, HP_CONNID dwConnID, const BYTE* pData /*= nullptr*/, int iLength /*= 0*/, LPCSTR lpszExtensions /*= nullptr*/);
  
  /*
  * 名称：发送 WebSocket 消息
  * 描述：向对端端发送 WebSocket 消息
  *		
  * 参数：		dwConnID		-- 连接 ID
  *			bFinal			-- 是否结束帧
  *			iReserved		-- RSV1/RSV2/RSV3 各 1 位
  *			iOperationCode	-- 操作码：0x0 - 0xF
  *			pData			-- 消息体数据缓冲区
  *			iLength			-- 消息体数据长度
  *			ullBodyLen		-- 消息总长度
  * 								ullBodyLen = 0		 -> 消息总长度为 iLength
  * 								ullBodyLen = iLength -> 消息总长度为 ullBodyLen
  * 								ullBodyLen > iLength -> 消息总长度为 ullBodyLen，后续消息体长度为 ullBOdyLen - iLength，后续消息体通过底层方法 Send() / SendPackets() 发送
  * 								ullBodyLen < iLength -> 错误参数，发送失败
  * 返回值：	TRUE			-- 成功
  *			FALSE			-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_HttpServer_SendWSMessage(HP_HttpServer pServer, HP_CONNID dwConnID, BOOL bFinal, BYTE iReserved, BYTE iOperationCode, const BYTE* pData, int iLength, ULONGLONG ullBodyLen);
  
  /*
  * 名称：释放连接
  * 描述：把连接放入释放队列，等待某个时间（通过 SetReleaseDelay() 设置）关闭连接
  *		
  * 参数：		dwConnID		-- 连接 ID
  * 返回值：	TRUE			-- 成功
  *			FALSE			-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_HttpServer_Release(HP_HttpServer pServer, HP_CONNID dwConnID);
  
  /*
  * 名称：启动 HTTP 通信
  * 描述：当通信组件设置为非自动启动 HTTP 通信时，需要调用本方法启动 HTTP 通信
  *		
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取失败原因
  */
  HPSOCKET_API BOOL __HP_CALL HP_HttpServer_StartHttp(HP_HttpServer pServer, HP_CONNID dwConnID);
  
  /******************************************************************************/
  /*************************** HTTP Server 属性访问方法 **************************/
  
  /* 设置连接释放延时（默认：3000 毫秒） */
  HPSOCKET_API void __HP_CALL HP_HttpServer_SetReleaseDelay(HP_HttpServer pServer, DWORD dwReleaseDelay);
  /* 获取连接释放延时 */
  HPSOCKET_API DWORD __HP_CALL HP_HttpServer_GetReleaseDelay(HP_HttpServer pServer);
  /* 获取请求行 URL 域掩码（URL 域参考：EnHttpUrlField） */
  HPSOCKET_API USHORT __HP_CALL HP_HttpServer_GetUrlFieldSet(HP_HttpServer pServer, HP_CONNID dwConnID);
  /* 获取某个 URL 域值 */
  HPSOCKET_API LPCSTR __HP_CALL HP_HttpServer_GetUrlField(HP_HttpServer pServer, HP_CONNID dwConnID, En_HP_HttpUrlField enField);
  /* 获取请求方法 */
  HPSOCKET_API LPCSTR __HP_CALL HP_HttpServer_GetMethod(HP_HttpServer pServer, HP_CONNID dwConnID);
  
  /* 设置本地协议版本 */
  HPSOCKET_API void __HP_CALL HP_HttpServer_SetLocalVersion(HP_HttpServer pServer, En_HP_HttpVersion usVersion);
  /* 获取本地协议版本 */
  HPSOCKET_API En_HP_HttpVersion __HP_CALL HP_HttpServer_GetLocalVersion(HP_HttpServer pServer);
  
  /* 检查是否升级协议 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpServer_IsUpgrade(HP_HttpServer pServer, HP_CONNID dwConnID);
  /* 检查是否有 Keep-Alive 标识 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpServer_IsKeepAlive(HP_HttpServer pServer, HP_CONNID dwConnID);
  /* 获取协议版本 */
  HPSOCKET_API USHORT __HP_CALL HP_HttpServer_GetVersion(HP_HttpServer pServer, HP_CONNID dwConnID);
  /* 获取主机 */
  HPSOCKET_API LPCSTR __HP_CALL HP_HttpServer_GetHost(HP_HttpServer pServer, HP_CONNID dwConnID);
  /* 获取内容长度 */
  HPSOCKET_API ULONGLONG __HP_CALL HP_HttpServer_GetContentLength(HP_HttpServer pServer, HP_CONNID dwConnID);
  /* 获取内容类型 */
  HPSOCKET_API LPCSTR __HP_CALL HP_HttpServer_GetContentType(HP_HttpServer pServer, HP_CONNID dwConnID);
  /* 获取内容编码 */
  HPSOCKET_API LPCSTR __HP_CALL HP_HttpServer_GetContentEncoding(HP_HttpServer pServer, HP_CONNID dwConnID);
  /* 获取传输编码 */
  HPSOCKET_API LPCSTR __HP_CALL HP_HttpServer_GetTransferEncoding(HP_HttpServer pServer, HP_CONNID dwConnID);
  /* 获取协议升级类型 */
  HPSOCKET_API En_HP_HttpUpgradeType __HP_CALL HP_HttpServer_GetUpgradeType(HP_HttpServer pServer, HP_CONNID dwConnID);
  /* 获取解析错误代码 */
  HPSOCKET_API USHORT __HP_CALL HP_HttpServer_GetParseErrorCode(HP_HttpServer pServer, HP_CONNID dwConnID, LPCSTR* lpszErrorDesc);
  
  /* 获取某个请求头（单值） */
  HPSOCKET_API BOOL __HP_CALL HP_HttpServer_GetHeader(HP_HttpServer pServer, HP_CONNID dwConnID, LPCSTR lpszName, LPCSTR* lpszValue);
  /* 获取某个请求头（多值） */
  HPSOCKET_API BOOL __HP_CALL HP_HttpServer_GetHeaders(HP_HttpServer pServer, HP_CONNID dwConnID, LPCSTR lpszName, LPCSTR lpszValue[], DWORD* pdwCount);
  /* 获取所有请求头 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpServer_GetAllHeaders(HP_HttpServer pServer, HP_CONNID dwConnID, HP_THeader lpHeaders[], DWORD* pdwCount);
  /* 获取所有请求头名称 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpServer_GetAllHeaderNames(HP_HttpServer pServer, HP_CONNID dwConnID, LPCSTR lpszName[], DWORD* pdwCount);
  
  /* 获取 Cookie */
  HPSOCKET_API BOOL __HP_CALL HP_HttpServer_GetCookie(HP_HttpServer pServer, HP_CONNID dwConnID, LPCSTR lpszName, LPCSTR* lpszValue);
  /* 获取所有 Cookie */
  HPSOCKET_API BOOL __HP_CALL HP_HttpServer_GetAllCookies(HP_HttpServer pServer, HP_CONNID dwConnID, HP_TCookie lpCookies[], DWORD* pdwCount);
  
  /* 获取当前 WebSocket 消息状态，传入 nullptr 则不获取相应字段 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpServer_GetWSMessageState(HP_HttpServer pServer, HP_CONNID dwConnID, BOOL* lpbFinal, BYTE* lpiReserved, BYTE* lpiOperationCode, LPCBYTE* lpszMask, ULONGLONG* lpullBodyLen, ULONGLONG* lpullBodyRemain);
  
  /* 设置 HTTP 启动方式（默认：TRUE，自动启动） */
  HPSOCKET_API void __HP_CALL HP_HttpServer_SetHttpAutoStart(HP_HttpServer pServer, BOOL bAutoStart);
  /* 获取 HTTP 启动方式 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpServer_IsHttpAutoStart(HP_HttpServer pServer);
  
  /**************************************************************************/
  /*************************** HTTP Agent 操作方法 ***************************/
  
  /*
  * 名称：发送请求
  * 描述：向服务端发送 HTTP 请求
  *		
  * 参数：		dwConnID		-- 连接 ID
  *			lpszMethod		-- 请求方法
  *			lpszPath		-- 请求路径
  *			lpHeaders		-- 请求头
  *			iHeaderCount	-- 请求头数量
  *			pBody			-- 请求体
  *			iLength			-- 请求体长度
  * 返回值：	TRUE			-- 成功
  *			FALSE			-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_SendRequest(HP_HttpAgent pAgent, HP_CONNID dwConnID, LPCSTR lpszMethod, LPCSTR lpszPath, const HP_THeader lpHeaders[], int iHeaderCount, const BYTE* pData, int iLength);
  
  /*
  * 名称：发送本地文件
  * 描述：向指定连接发送 4096 KB 以下的小文件
  *		
  * 参数：		dwConnID		-- 连接 ID
  *			lpszFileName	-- 文件路径
  *			lpszMethod		-- 请求方法
  *			lpszPath		-- 请求路径
  *			lpHeaders		-- 请求头
  *			iHeaderCount	-- 请求头数量
  * 返回值：	TRUE			-- 成功
  *			FALSE			-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_SendLocalFile(HP_HttpAgent pAgent, HP_CONNID dwConnID, LPCSTR lpszFileName, LPCSTR lpszMethod, LPCSTR lpszPath, const HP_THeader lpHeaders[], int iHeaderCount);
  
  /*
  * 名称：发送 Chunked 数据分片
  * 描述：向对端发送 Chunked 数据分片
  *		
  * 参数：		dwConnID		-- 连接 ID
  *			pData			-- Chunked 数据分片
  *			iLength			-- 数据分片长度（为 0 表示结束分片）
  *			lpszExtensions	-- 扩展属性（默认：nullptr）
  * 返回值：	TRUE			-- 成功
  *			FALSE			-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_SendChunkData(HP_HttpAgent pAgent, HP_CONNID dwConnID, const BYTE* pData /*= nullptr*/, int iLength /*= 0*/, LPCSTR lpszExtensions /*= nullptr*/);
  
  /* 发送 POST 请求 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_SendPost(HP_HttpAgent pAgent, HP_CONNID dwConnID, LPCSTR lpszPath, const HP_THeader lpHeaders[], int iHeaderCount, const BYTE* pBody, int iLength);
  /* 发送 PUT 请求 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_SendPut(HP_HttpAgent pAgent, HP_CONNID dwConnID, LPCSTR lpszPath, const HP_THeader lpHeaders[], int iHeaderCount, const BYTE* pBody, int iLength);
  /* 发送 PATCH 请求 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_SendPatch(HP_HttpAgent pAgent, HP_CONNID dwConnID, LPCSTR lpszPath, const HP_THeader lpHeaders[], int iHeaderCount, const BYTE* pBody, int iLength);
  /* 发送 GET 请求 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_SendGet(HP_HttpAgent pAgent, HP_CONNID dwConnID, LPCSTR lpszPath, const HP_THeader lpHeaders[], int iHeaderCount);
  /* 发送 DELETE 请求 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_SendDelete(HP_HttpAgent pAgent, HP_CONNID dwConnID, LPCSTR lpszPath, const HP_THeader lpHeaders[], int iHeaderCount);
  /* 发送 HEAD 请求 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_SendHead(HP_HttpAgent pAgent, HP_CONNID dwConnID, LPCSTR lpszPath, const HP_THeader lpHeaders[], int iHeaderCount);
  /* 发送 TRACE 请求 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_SendTrace(HP_HttpAgent pAgent, HP_CONNID dwConnID, LPCSTR lpszPath, const HP_THeader lpHeaders[], int iHeaderCount);
  /* 发送 OPTIONS 请求 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_SendOptions(HP_HttpAgent pAgent, HP_CONNID dwConnID, LPCSTR lpszPath, const HP_THeader lpHeaders[], int iHeaderCount);
  /* 发送 CONNECT 请求 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_SendConnect(HP_HttpAgent pAgent, HP_CONNID dwConnID, LPCSTR lpszHost, const HP_THeader lpHeaders[], int iHeaderCount);
  
  /*
  * 名称：发送 WebSocket 消息
  * 描述：向对端端发送 WebSocket 消息
  *		
  * 参数：		dwConnID		-- 连接 ID
  *			bFinal			-- 是否结束帧
  *			iReserved		-- RSV1/RSV2/RSV3 各 1 位
  *			iOperationCode	-- 操作码：0x0 - 0xF
  *			lpszMask		-- 掩码（nullptr 或 4 字节掩码，如果为 nullptr 则没有掩码）
  *			pData			-- 消息体数据缓冲区
  *			iLength			-- 消息体数据长度
  *			ullBodyLen		-- 消息总长度
  * 								ullBodyLen = 0		 -> 消息总长度为 iLength
  * 								ullBodyLen = iLength -> 消息总长度为 ullBodyLen
  * 								ullBodyLen > iLength -> 消息总长度为 ullBodyLen，后续消息体长度为 ullBOdyLen - iLength，后续消息体通过底层方法 Send() / SendPackets() 发送
  * 								ullBodyLen < iLength -> 错误参数，发送失败
  * 返回值：	TRUE			-- 成功
  *			FALSE			-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_SendWSMessage(HP_HttpAgent pAgent, HP_CONNID dwConnID, BOOL bFinal, BYTE iReserved, BYTE iOperationCode, const BYTE lpszMask[4], const BYTE* pData, int iLength, ULONGLONG ullBodyLen);
  
  /*
  * 名称：启动 HTTP 通信
  * 描述：当通信组件设置为非自动启动 HTTP 通信时，需要调用本方法启动 HTTP 通信
  *		
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取失败原因
  */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_StartHttp(HP_HttpAgent pAgent, HP_CONNID dwConnID);
  
  /******************************************************************************/
  /*************************** HTTP Agent 属性访问方法 ***************************/
  
  /* 获取 HTTP 状态码 */
  HPSOCKET_API USHORT __HP_CALL HP_HttpAgent_GetStatusCode(HP_HttpAgent pAgent, HP_CONNID dwConnID);
  
  /* 设置本地协议版本 */
  HPSOCKET_API void __HP_CALL HP_HttpAgent_SetLocalVersion(HP_HttpAgent pAgent, En_HP_HttpVersion usVersion);
  /* 获取本地协议版本 */
  HPSOCKET_API En_HP_HttpVersion __HP_CALL HP_HttpAgent_GetLocalVersion(HP_HttpAgent pAgent);
  
  /* 检查是否升级协议 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_IsUpgrade(HP_HttpAgent pAgent, HP_CONNID dwConnID);
  /* 检查是否有 Keep-Alive 标识 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_IsKeepAlive(HP_HttpAgent pAgent, HP_CONNID dwConnID);
  /* 获取协议版本 */
  HPSOCKET_API USHORT __HP_CALL HP_HttpAgent_GetVersion(HP_HttpAgent pAgent, HP_CONNID dwConnID);
  /* 获取内容长度 */
  HPSOCKET_API ULONGLONG __HP_CALL HP_HttpAgent_GetContentLength(HP_HttpAgent pAgent, HP_CONNID dwConnID);
  /* 获取内容类型 */
  HPSOCKET_API LPCSTR __HP_CALL HP_HttpAgent_GetContentType(HP_HttpAgent pAgent, HP_CONNID dwConnID);
  /* 获取内容编码 */
  HPSOCKET_API LPCSTR __HP_CALL HP_HttpAgent_GetContentEncoding(HP_HttpAgent pAgent, HP_CONNID dwConnID);
  /* 获取传输编码 */
  HPSOCKET_API LPCSTR __HP_CALL HP_HttpAgent_GetTransferEncoding(HP_HttpAgent pAgent, HP_CONNID dwConnID);
  /* 获取协议升级类型 */
  HPSOCKET_API En_HP_HttpUpgradeType __HP_CALL HP_HttpAgent_GetUpgradeType(HP_HttpAgent pAgent, HP_CONNID dwConnID);
  /* 获取解析错误代码 */
  HPSOCKET_API USHORT __HP_CALL HP_HttpAgent_GetParseErrorCode(HP_HttpAgent pAgent, HP_CONNID dwConnID, LPCSTR* lpszErrorDesc);
  
  /* 获取某个请求头（单值） */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_GetHeader(HP_HttpAgent pAgent, HP_CONNID dwConnID, LPCSTR lpszName, LPCSTR* lpszValue);
  /* 获取某个请求头（多值） */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_GetHeaders(HP_HttpAgent pAgent, HP_CONNID dwConnID, LPCSTR lpszName, LPCSTR lpszValue[], DWORD* pdwCount);
  /* 获取所有请求头 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_GetAllHeaders(HP_HttpAgent pAgent, HP_CONNID dwConnID, HP_THeader lpHeaders[], DWORD* pdwCount);
  /* 获取所有请求头名称 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_GetAllHeaderNames(HP_HttpAgent pAgent, HP_CONNID dwConnID, LPCSTR lpszName[], DWORD* pdwCount);
  
  /* 设置是否使用 Cookie */
  HPSOCKET_API void __HP_CALL HP_HttpAgent_SetUseCookie(HP_HttpAgent pAgent, BOOL bUseCookie);
  /* 检查是否使用 Cookie */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_IsUseCookie(HP_HttpAgent pAgent);
  /* 获取 Cookie */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_GetCookie(HP_HttpAgent pAgent, HP_CONNID dwConnID, LPCSTR lpszName, LPCSTR* lpszValue);
  /* 获取所有 Cookie */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_GetAllCookies(HP_HttpAgent pAgent, HP_CONNID dwConnID, HP_TCookie lpCookies[], DWORD* pdwCount);
  
  /* 获取当前 WebSocket 消息状态，传入 nullptr 则不获取相应字段 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_GetWSMessageState(HP_HttpAgent pAgent, HP_CONNID dwConnID, BOOL* lpbFinal, BYTE* lpiReserved, BYTE* lpiOperationCode, LPCBYTE* lpszMask, ULONGLONG* lpullBodyLen, ULONGLONG* lpullBodyRemain);
  
  /* 设置 HTTP 启动方式（默认：TRUE，自动启动） */
  HPSOCKET_API void __HP_CALL HP_HttpAgent_SetHttpAutoStart(HP_HttpAgent pAgent, BOOL bAutoStart);
  /* 获取 HTTP 启动方式 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpAgent_IsHttpAutoStart(HP_HttpAgent pAgent);
  
  /**************************************************************************/
  /*************************** HTTP Client 操作方法 **************************/
  
  /*
  * 名称：发送请求
  * 描述：向服务端发送 HTTP 请求
  *		
  * 参数：		lpszMethod		-- 请求方法
  *			lpszPath		-- 请求路径
  *			lpHeaders		-- 请求头
  *			iHeaderCount	-- 请求头数量
  *			pBody			-- 请求体
  *			iLength			-- 请求体长度
  * 返回值：	TRUE			-- 成功
  *			FALSE			-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_SendRequest(HP_HttpClient pClient, LPCSTR lpszMethod, LPCSTR lpszPath, const HP_THeader lpHeaders[], int iHeaderCount, const BYTE* pBody, int iLength);
  
  /*
  * 名称：发送本地文件
  * 描述：向指定连接发送 4096 KB 以下的小文件
  *		
  * 参数：		dwConnID		-- 连接 ID
  *			lpszFileName	-- 文件路径
  *			lpszMethod		-- 请求方法
  *			lpszPath		-- 请求路径
  *			lpHeaders		-- 请求头
  *			iHeaderCount	-- 请求头数量
  * 返回值：	TRUE			-- 成功
  *			FALSE			-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_SendLocalFile(HP_HttpClient pClient, LPCSTR lpszFileName, LPCSTR lpszMethod, LPCSTR lpszPath, const HP_THeader lpHeaders[], int iHeaderCount);
  
  /*
  * 名称：发送 Chunked 数据分片
  * 描述：向对端发送 Chunked 数据分片
  *		
  * 参数：		pData			-- Chunked 数据分片
  *			iLength			-- 数据分片长度（为 0 表示结束分片）
  *			lpszExtensions	-- 扩展属性（默认：nullptr）
  * 返回值：	TRUE			-- 成功
  *			FALSE			-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_SendChunkData(HP_HttpClient pClient, const BYTE* pData /*= nullptr*/, int iLength /*= 0*/, LPCSTR lpszExtensions /*= nullptr*/);
  
  /* 发送 POST 请求 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_SendPost(HP_HttpClient pClient, LPCSTR lpszPath, const HP_THeader lpHeaders[], int iHeaderCount, const BYTE* pBody, int iLength);
  /* 发送 PUT 请求 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_SendPut(HP_HttpClient pClient, LPCSTR lpszPath, const HP_THeader lpHeaders[], int iHeaderCount, const BYTE* pBody, int iLength);
  /* 发送 PATCH 请求 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_SendPatch(HP_HttpClient pClient, LPCSTR lpszPath, const HP_THeader lpHeaders[], int iHeaderCount, const BYTE* pBody, int iLength);
  /* 发送 GET 请求 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_SendGet(HP_HttpClient pClient, LPCSTR lpszPath, const HP_THeader lpHeaders[], int iHeaderCount);
  /* 发送 DELETE 请求 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_SendDelete(HP_HttpClient pClient, LPCSTR lpszPath, const HP_THeader lpHeaders[], int iHeaderCount);
  /* 发送 HEAD 请求 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_SendHead(HP_HttpClient pClient, LPCSTR lpszPath, const HP_THeader lpHeaders[], int iHeaderCount);
  /* 发送 TRACE 请求 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_SendTrace(HP_HttpClient pClient, LPCSTR lpszPath, const HP_THeader lpHeaders[], int iHeaderCount);
  /* 发送 OPTIONS 请求 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_SendOptions(HP_HttpClient pClient, LPCSTR lpszPath, const HP_THeader lpHeaders[], int iHeaderCount);
  /* 发送 CONNECT 请求 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_SendConnect(HP_HttpClient pClient, LPCSTR lpszHost, const HP_THeader lpHeaders[], int iHeaderCount);
  
  /*
  * 名称：发送 WebSocket 消息
  * 描述：向对端端发送 WebSocket 消息
  *		
  * 参数：		bFinal			-- 是否结束帧
  *			iReserved		-- RSV1/RSV2/RSV3 各 1 位
  *			iOperationCode	-- 操作码：0x0 - 0xF
  *			lpszMask		-- 掩码（nullptr 或 4 字节掩码，如果为 nullptr 则没有掩码）
  *			pData			-- 消息体数据缓冲区
  *			iLength			-- 消息体数据长度
  *			ullBodyLen		-- 消息总长度
  * 								ullBodyLen = 0		 -> 消息总长度为 iLength
  * 								ullBodyLen = iLength -> 消息总长度为 ullBodyLen
  * 								ullBodyLen > iLength -> 消息总长度为 ullBodyLen，后续消息体长度为 ullBOdyLen - iLength，后续消息体通过底层方法 Send() / SendPackets() 发送
  * 								ullBodyLen < iLength -> 错误参数，发送失败
  * 返回值：	TRUE			-- 成功
  *			FALSE			-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_SendWSMessage(HP_HttpClient pClient, BOOL bFinal, BYTE iReserved, BYTE iOperationCode, const BYTE lpszMask[4], const BYTE* pData, int iLength, ULONGLONG ullBodyLen);
  
  /*
  * 名称：启动 HTTP 通信
  * 描述：当通信组件设置为非自动启动 HTTP 通信时，需要调用本方法启动 HTTP 通信
  *		
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取失败原因
  */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_StartHttp(HP_HttpClient pClient);
  
  /******************************************************************************/
  /*************************** HTTP Client 属性访问方法 **************************/
  
  /* 获取 HTTP 状态码 */
  HPSOCKET_API USHORT __HP_CALL HP_HttpClient_GetStatusCode(HP_HttpClient pClient);
  
  /* 设置本地协议版本 */
  HPSOCKET_API void __HP_CALL HP_HttpClient_SetLocalVersion(HP_HttpClient pClient, En_HP_HttpVersion usVersion);
  /* 获取本地协议版本 */
  HPSOCKET_API En_HP_HttpVersion __HP_CALL HP_HttpClient_GetLocalVersion(HP_HttpClient pClient);
  
  /* 检查是否升级协议 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_IsUpgrade(HP_HttpClient pClient);
  /* 检查是否有 Keep-Alive 标识 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_IsKeepAlive(HP_HttpClient pClient);
  /* 获取协议版本 */
  HPSOCKET_API USHORT __HP_CALL HP_HttpClient_GetVersion(HP_HttpClient pClient);
  /* 获取内容长度 */
  HPSOCKET_API ULONGLONG __HP_CALL HP_HttpClient_GetContentLength(HP_HttpClient pClient);
  /* 获取内容类型 */
  HPSOCKET_API LPCSTR __HP_CALL HP_HttpClient_GetContentType(HP_HttpClient pClient);
  /* 获取内容编码 */
  HPSOCKET_API LPCSTR __HP_CALL HP_HttpClient_GetContentEncoding(HP_HttpClient pClient);
  /* 获取传输编码 */
  HPSOCKET_API LPCSTR __HP_CALL HP_HttpClient_GetTransferEncoding(HP_HttpClient pClient);
  /* 获取协议升级类型 */
  HPSOCKET_API En_HP_HttpUpgradeType __HP_CALL HP_HttpClient_GetUpgradeType(HP_HttpClient pClient);
  /* 获取解析错误代码 */
  HPSOCKET_API USHORT __HP_CALL HP_HttpClient_GetParseErrorCode(HP_HttpClient pClient, LPCSTR* lpszErrorDesc);
  
  /* 获取某个请求头（单值） */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_GetHeader(HP_HttpClient pClient, LPCSTR lpszName, LPCSTR* lpszValue);
  /* 获取某个请求头（多值） */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_GetHeaders(HP_HttpClient pClient, LPCSTR lpszName, LPCSTR lpszValue[], DWORD* pdwCount);
  /* 获取所有请求头 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_GetAllHeaders(HP_HttpClient pClient, HP_THeader lpHeaders[], DWORD* pdwCount);
  /* 获取所有请求头名称 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_GetAllHeaderNames(HP_HttpClient pClient, LPCSTR lpszName[], DWORD* pdwCount);
  
  /* 设置是否使用 Cookie */
  HPSOCKET_API void __HP_CALL HP_HttpClient_SetUseCookie(HP_HttpClient pClient, BOOL bUseCookie);
  /* 检查是否使用 Cookie */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_IsUseCookie(HP_HttpClient pClient);
  /* 获取 Cookie */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_GetCookie(HP_HttpClient pClient, LPCSTR lpszName, LPCSTR* lpszValue);
  /* 获取所有 Cookie */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_GetAllCookies(HP_HttpClient pClient, HP_TCookie lpCookies[], DWORD* pdwCount);
  
  /* 获取当前 WebSocket 消息状态，传入 nullptr 则不获取相应字段 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_GetWSMessageState(HP_HttpClient pClient, BOOL* lpbFinal, BYTE* lpiReserved, BYTE* lpiOperationCode, LPCBYTE* lpszMask, ULONGLONG* lpullBodyLen, ULONGLONG* lpullBodyRemain);
  
  /* 设置 HTTP 启动方式（默认：TRUE，自动启动） */
  HPSOCKET_API void __HP_CALL HP_HttpClient_SetHttpAutoStart(HP_HttpClient pClient, BOOL bAutoStart);
  /* 获取 HTTP 启动方式 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpClient_IsHttpAutoStart(HP_HttpClient pClient);
  
  /**************************************************************************/
  /************************ HTTP Sync Client 操作方法 ************************/
  
  /*
  * 名称：发送 URL 请求
  * 描述：向服务端发送 HTTP URL 请求
  *		
  * 参数：		lpszMethod		-- 请求方法
  *			lpszUrl			-- 请求 URL
  *			lpHeaders		-- 请求头
  *			iHeaderCount	-- 请求头数量
  *			pBody			-- 请求体
  *			iLength			-- 请求体长度
  *			bForceReconnect	-- 强制重新连接（默认：FALSE，当请求 URL 的主机和端口与现有连接一致时，重用现有连接）
  * 返回值：	TRUE			-- 成功
  *			FALSE			-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_HttpSyncClient_OpenUrl(HP_HttpSyncClient pClient, LPCSTR lpszMethod, LPCSTR lpszUrl, const HP_THeader lpHeaders[], int iHeaderCount, const BYTE* pBody, int iLength, BOOL bForceReconnect);
  
  /*
  * 名称：清除请求结果
  * 描述：清除上一次请求的响应头和响应体等结果信息（该方法会在每次发送请求前自动调用）
  *
  * 参数：		
  * 返回值：	TRUE			-- 成功
  *			FALSE			-- 失败
  */
  HPSOCKET_API BOOL __HP_CALL HP_HttpSyncClient_CleanupRequestResult(HP_HttpSyncClient pClient);
  
  /******************************************************************************/
  /************************ HTTP Sync Client 属性访问方法 ************************/
  
  /* 设置连接超时（毫秒，0：系统默认超时，默认：5000） */
  HPSOCKET_API void __HP_CALL HP_HttpSyncClient_SetConnectTimeout(HP_HttpSyncClient pClient, DWORD dwConnectTimeout);
  /* 设置请求超时（毫秒，0：无限等待，默认：10000） */
  HPSOCKET_API void __HP_CALL HP_HttpSyncClient_SetRequestTimeout(HP_HttpSyncClient pClient, DWORD dwRequestTimeout);
  
  /* 获取连接超时 */
  HPSOCKET_API DWORD __HP_CALL HP_HttpSyncClient_GetConnectTimeout(HP_HttpSyncClient pClient);
  /* 获取请求超时 */
  HPSOCKET_API DWORD __HP_CALL HP_HttpSyncClient_GetRequestTimeout(HP_HttpSyncClient pClient);
  
  /* 获取响应体 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpSyncClient_GetResponseBody(HP_HttpSyncClient pClient, LPCBYTE* lpszBody, int* piLength);
  
  /**************************************************************************/
  /*************************** HTTP Cookie 管理方法 **************************/
  
  /* 从文件加载 Cookie */
  HPSOCKET_API BOOL __HP_CALL HP_HttpCookie_MGR_LoadFromFile(LPCSTR lpszFile, BOOL bKeepExists /*= TRUE*/);
  /* 保存 Cookie 到文件 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpCookie_MGR_SaveToFile(LPCSTR lpszFile, BOOL bKeepExists /*= TRUE*/);
  /* 清理 Cookie */
  HPSOCKET_API BOOL __HP_CALL HP_HttpCookie_MGR_ClearCookies(LPCSTR lpszDomain /*= nullptr*/, LPCSTR lpszPath /*= nullptr*/);
  /* 清理过期 Cookie */
  HPSOCKET_API BOOL __HP_CALL HP_HttpCookie_MGR_RemoveExpiredCookies(LPCSTR lpszDomain /*= nullptr*/, LPCSTR lpszPath /*= nullptr*/);
  /* 设置 Cookie */
  HPSOCKET_API BOOL __HP_CALL HP_HttpCookie_MGR_SetCookie(LPCSTR lpszName, LPCSTR lpszValue, LPCSTR lpszDomain, LPCSTR lpszPath, int iMaxAge /*= -1*/, BOOL bHttpOnly /*= FALSE*/, BOOL bSecure /*= FALSE*/, int enSameSite /*= 0*/, BOOL bOnlyUpdateValueIfExists /*= TRUE*/);
  /* 删除 Cookie */
  HPSOCKET_API BOOL __HP_CALL HP_HttpCookie_MGR_DeleteCookie(LPCSTR lpszDomain, LPCSTR lpszPath, LPCSTR lpszName);
  /* 设置是否允许第三方 Cookie */
  HPSOCKET_API void __HP_CALL HP_HttpCookie_MGR_SetEnableThirdPartyCookie(BOOL bEnableThirdPartyCookie /*= TRUE*/);
  /* 检查是否允许第三方 Cookie */
  HPSOCKET_API BOOL __HP_CALL HP_HttpCookie_MGR_IsEnableThirdPartyCookie();
  
  /* Cookie expires 字符串转换为整数 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpCookie_HLP_ParseExpires(LPCSTR lpszExpires, __time64_t* ptmExpires);
  /* 整数转换为 Cookie expires 字符串 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpCookie_HLP_MakeExpiresStr(char lpszBuff[], int* piBuffLen, __time64_t tmExpires);
  /* 生成 Cookie 字符串 */
  HPSOCKET_API BOOL __HP_CALL HP_HttpCookie_HLP_ToString(char lpszBuff[], int* piBuffLen, LPCSTR lpszName, LPCSTR lpszValue, LPCSTR lpszDomain, LPCSTR lpszPath, int iMaxAge /*= -1*/, BOOL bHttpOnly /*= FALSE*/, BOOL bSecure /*= FALSE*/, int enSameSite /*= 0*/);
  /* 获取当前 UTC 时间 */
  HPSOCKET_API __time64_t __HP_CALL HP_HttpCookie_HLP_CurrentUTCTime();
  /* Max-Age -> expires */
  HPSOCKET_API __time64_t __HP_CALL HP_HttpCookie_HLP_MaxAgeToExpires(int iMaxAge);
  /* expires -> Max-Age */
  HPSOCKET_API int __HP_CALL HP_HttpCookie_HLP_ExpiresToMaxAge(__time64_t tmExpires);
  
  /*****************************************************************************************************************************************************/
  /************************************************************* HTTP Global Function Exports **********************************************************/
  /*****************************************************************************************************************************************************/
  
  #endif
  
  /*****************************************************************************************************************************************************/
  /**************************************************************** Thread Pool Exports ****************************************************************/
  /*****************************************************************************************************************************************************/
  
  /****************************************************/
  /******************* 对象创建函数 ********************/
  
  // 创建 IHPThreadPool 对象
  HPSOCKET_API HP_ThreadPool __HP_CALL Create_HP_ThreadPool();
  // 销毁 IHPThreadPool 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_ThreadPool(HP_ThreadPool pThreadPool);
  
  /*
  * 名称：创建 TSocketTask 对象
  * 描述：创建任务对象，该对象最终需由 HP_Destroy_SocketTaskObj() 销毁
  *		
  * 参数：		fnTaskProc	-- 任务处理函数
  *			pSender		-- 发起对象
  *			dwConnID	-- 连接 ID
  *			pBuffer		-- 数据缓冲区
  *			iBuffLen	-- 数据缓冲区长度
  *			enBuffType	-- 数据缓冲区类型（默认：TBT_COPY）
  *							TBT_COPY	：（深拷贝）pBuffer 复制到 TSocketTask 对象。此后 TSocketTask 对象与 pBuffer 不再有任何关联
  *											-> 适用于 pBuffer 不大或 pBuffer 生命周期不受控的场景
  *							TBT_REFER	：（浅拷贝）pBuffer 不复制到 TSocketTask 对象，需确保 TSocketTask 对象生命周期内 pBuffer 必须有效
  *											-> 适用于 pBuffer 较大或 pBuffer 可重用，并且 pBuffer 生命周期受控的场景
  *							TBT_ATTACH	：（附属）执行浅拷贝，但 TSocketTask 对象会获得 pBuffer 的所有权，并负责释放 pBuffer，避免多次缓冲区拷贝
  *											-> 注意：pBuffer 必须由 SYS_Malloc()/SYS_Calloc() 函数分配才能使用本类型，否则可能会发生内存访问错误
  *			wParam		-- 自定义参数
  *			lParam		-- 自定义参数
  * 返回值：	HP_LPTSocketTask
  */
  HPSOCKET_API HP_LPTSocketTask __HP_CALL Create_HP_SocketTaskObj(Fn_SocketTaskProc fnTaskProc, PVOID pSender, HP_CONNID dwConnID, LPCBYTE pBuffer, INT iBuffLen, En_HP_TaskBufferType enBuffType /*= TBT_COPY*/, WPARAM wParam /*= 0*/, LPARAM lParam /*= 0*/);
  
  // 销毁 TSocketTask 对象
  HPSOCKET_API void __HP_CALL Destroy_HP_SocketTaskObj(HP_LPTSocketTask pTask);
  
  /***********************************************************************/
  /***************************** 组件操作方法 *****************************/
  
  /*
  * 名称：启动线程池组件
  * 描述：
  *		
  * 参数：		dwThreadCount		-- 线程数量，（默认：0）
  *									>0 -> dwThreadCount
  *									=0 -> (CPU核数 * 2 + 2)
  *									<0 -> (CPU核数 * (-dwThreadCount))
  *			dwMaxQueueSize		-- 任务队列最大容量（默认：0，不限制）
  *			enRejectedPolicy	-- 任务拒绝处理策略
  *									TRP_CALL_FAIL（默认）	：立刻返回失败
  *									TRP_WAIT_FOR			：等待（直到成功、超时或线程池关闭等原因导致失败）
  *									TRP_CALLER_RUN			：调用者线程直接执行
  *			dwStackSize			-- 线程堆栈空间大小（默认：0 -> 操作系统默认）
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取系统错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_ThreadPool_Start(HP_ThreadPool pThreadPool, DWORD dwThreadCount /*= 0*/, DWORD dwMaxQueueSize /*= 0*/, En_HP_RejectedPolicy enRejectedPolicy /*= TRP_CALL_FAIL*/, DWORD dwStackSize /*= 0*/);
  
  /*
  * 名称：关闭线程池组件
  * 描述：在规定时间内关闭线程池组件，如果工作线程在最大等待时间内未能正常关闭，会尝试强制关闭，这种情况下很可能会造成系统资源泄漏
  *		
  * 参数：		dwMaxWait	-- 最大等待时间（毫秒，默认：INFINITE，一直等待）
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取系统错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_ThreadPool_Stop(HP_ThreadPool pThreadPool, DWORD dwMaxWait /*= INFINITE*/);
  
  /*
  * 名称：提交任务
  * 描述：向线程池提交异步任务
  *		
  * 参数：		fnTaskProc	-- 任务处理函数
  *			pvArg		-- 任务参数
  *			dwMaxWait	-- 任务提交最大等待时间（仅对 TRP_WAIT_FOR 类型线程池生效，默认：INFINITE，一直等待）
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取系统错误代码
  *							其中，错误码 ERROR_DESTINATION_ELEMENT_FULL 表示任务队列已满
  */
  HPSOCKET_API BOOL __HP_CALL HP_ThreadPool_Submit(HP_ThreadPool pThreadPool, HP_Fn_TaskProc fnTaskProc, PVOID pvArg, DWORD dwMaxWait /*= INFINITE*/);
  
  /*
  * 名称：提交 Socket 任务
  * 描述：向线程池提交异步 Socket 任务
  *		
  * 参数：		pTask		-- 任务参数
  *			dwMaxWait	-- 任务提交最大等待时间（仅对 TRP_WAIT_FOR 类型线程池生效，默认：INFINITE，一直等待）
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取系统错误代码
  *							其中，错误码 ERROR_DESTINATION_ELEMENT_FULL 表示任务队列已满
  *							注意：如果提交失败，需要手工调用 Destroy_HP_SocketTaskObj() 销毁 TSocketTask 对象
  */
  HPSOCKET_API BOOL __HP_CALL HP_ThreadPool_Submit_Task(HP_ThreadPool pThreadPool, HP_LPTSocketTask pTask, DWORD dwMaxWait /*= INFINITE*/);
  
  /*
  * 名称：调整线程池大小
  * 描述：增加或减少线程池的工作线程数量
  *		
  * 参数：		dwNewThreadCount	-- 线程数量
  *									>0 -> dwNewThreadCount
  *									=0 -> (CPU核数 * 2 + 2)
  *									<0 -> (CPU核数 * (-dwNewThreadCount))
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取系统错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_ThreadPool_AdjustThreadCount(HP_ThreadPool pThreadPool, DWORD dwNewThreadCount);
  
  /*
  * 名称：等待
  * 描述：等待线程池组件停止运行
  *		
  * 参数：		dwMilliseconds	-- 超时时间（毫秒，默认：-1，永不超时）
  * 返回值：	TRUE	-- 成功
  *			FALSE	-- 失败，可通过 SYS_GetLastError() 获取错误代码
  */
  HPSOCKET_API BOOL __HP_CALL HP_ThreadPool_Wait(HP_ThreadPool pThreadPool, DWORD dwMilliseconds);
  
  /***********************************************************************/
  /***************************** 属性访问方法 *****************************/
  
  /* 检查线程池组件是否已启动 */
  HPSOCKET_API BOOL __HP_CALL HP_ThreadPool_HasStarted(HP_ThreadPool pThreadPool);
  /* 查看线程池组件当前状态 */
  HPSOCKET_API En_HP_ServiceState	__HP_CALL HP_ThreadPool_GetState(HP_ThreadPool pThreadPool);
  /* 获取当前任务等待队列大小 */
  HPSOCKET_API DWORD __HP_CALL HP_ThreadPool_GetQueueSize(HP_ThreadPool pThreadPool);
  /* 获取当前正在执行的任务数量 */
  HPSOCKET_API DWORD __HP_CALL HP_ThreadPool_GetTaskCount(HP_ThreadPool pThreadPool);
  /* 获取工作线程数量 */
  HPSOCKET_API DWORD __HP_CALL HP_ThreadPool_GetThreadCount(HP_ThreadPool pThreadPool);
  /* 获取任务队列最大容量 */
  HPSOCKET_API DWORD __HP_CALL HP_ThreadPool_GetMaxQueueSize(HP_ThreadPool pThreadPool);
  /* 获取任务拒绝处理策略 */
  HPSOCKET_API EnRejectedPolicy __HP_CALL HP_ThreadPool_GetRejectedPolicy(HP_ThreadPool pThreadPool);
  