开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
CChannel.h
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：21k
源码类别：

模拟服务器

开发平台：

C/C++

CChannel.h：源码内容
  1. /****************************************************************************/
  2. /* Header:    cchannel.h                                                    */
  3. /*                                                                          */
  4. /* Purpose:   Virtual Channel Client API                                    */
  5. /*                                                                          */
  6. /* Copyright(C) Microsoft Corporation 1999                                  */
  7. /*                                                                          */
  8. /****************************************************************************/
  10. #ifndef H_CCHANNEL
  11. #define H_CCHANNEL
  13. /****************************************************************************/
  14. /* Include Virtual Channel Protocol header                                  */
  15. /****************************************************************************/
  16. #include <pchannel.h>
  18. #ifdef _WIN32 
  19. #define VCAPITYPE _stdcall
  20. #define VCEXPORT
  21. #else // _WIN32
  22. #define VCAPITYPE CALLBACK
  23. #define VCEXPORT  __export
  24. #endif // _WIN32
  26. /****************************************************************************/
  27. /* Name: CHANNEL_INIT_EVENT_FN                                              */
  28. /*                                                                          */
  29. /* Purpose:                                                                 */
  30. /*                                                                          */
  31. /* This function is passed to MSTSC on VirtualChannelInit.  It is called by */
  32. /* MSTSC to tell the application about interesting events.                  */
  33. /*                                                                          */
  34. /* Returns:                                                                 */
  35. /*                                                                          */
  36. /* none                                                                     */
  37. /*                                                                          */
  38. /* Params:                                                                  */
  39. /*                                                                          */
  40. /* - pInitHandle - a handle uniquely identifying this connection            */
  41. /* - event - the event that has occurred - see CHANNEL_EVENT_XXX below      */
  42. /* - pData - data associated with the event - see CHANNEL_EVENT_XXX below   */
  43. /* - dataLength - length of the data.                                       */
  44. /*                                                                          */
  45. /****************************************************************************/
  46. typedef VOID VCAPITYPE CHANNEL_INIT_EVENT_FN(LPVOID pInitHandle,
  47.                                              UINT   event,
  48.                                              LPVOID pData,
  49.                                              UINT   dataLength);
  51. typedef CHANNEL_INIT_EVENT_FN FAR * PCHANNEL_INIT_EVENT_FN;
  53. /****************************************************************************/
  54. /* Events passed to VirtualChannelInitEvent                                 */
  55. /****************************************************************************/
  56. /* Client initialized (no data)                                             */
  57. #define CHANNEL_EVENT_INITIALIZED       0
  59. /* Connection established (data = name of Server)                           */
  60. #define CHANNEL_EVENT_CONNECTED         1
  62. /* Connection established with old Server, so no channel support            */
  63. #define CHANNEL_EVENT_V1_CONNECTED      2
  65. /* Connection ended (no data)                                               */
  66. #define CHANNEL_EVENT_DISCONNECTED      3
  68. /* Client terminated (no data)                                              */
  69. #define CHANNEL_EVENT_TERMINATED        4
  71. /****************************************************************************/
  72. /* Name: CHANNEL_OPEN_EVENT_FN                                              */
  73. /*                                                                          */
  74. /* Purpose:                                                                 */
  75. /*                                                                          */
  76. /* This function is passed to MSTSC on VirtualChannelOpen.  It is called by */
  77. /* MSTSC when data is available on the channel.                             */
  78. /*                                                                          */
  79. /* Returns:                                                                 */
  80. /*                                                                          */
  81. /* none                                                                     */
  82. /*                                                                          */
  83. /* Params:                                                                  */
  84. /*                                                                          */
  85. /* - openHandle - a handle uniquely identifying this channel                */
  86. /* - event - event that has occurred - see CHANNEL_EVENT_XXX below          */
  87. /* - pData - data received                                                  */
  88. /* - dataLength - length of the data                                        */
  89. /* - totalLength - total length of data written by the Server               */
  90. /* - dataFlags - flags, zero, one or more of:                               */
  91. /*   - 0x01 - beginning of data from a single write operation at the Server */
  92. /*   - 0x02 - end of data from a single write operation at the Server.      */
  93. /*                                                                          */
  94. /****************************************************************************/
  95. typedef VOID VCAPITYPE CHANNEL_OPEN_EVENT_FN(DWORD  openHandle,
  96.                                              UINT   event,
  97.                                              LPVOID pData,
  98.                                              UINT32 dataLength,
  99.                                              UINT32 totalLength,
  100.                                              UINT32 dataFlags);
  102. typedef CHANNEL_OPEN_EVENT_FN FAR * PCHANNEL_OPEN_EVENT_FN;
  105. /****************************************************************************/
  106. /* Events passed to VirtualChannelOpenEvent                                 */
  107. /****************************************************************************/
  108. /* Data received from Server (data = incoming data)                         */
  109. #define CHANNEL_EVENT_DATA_RECEIVED     10
  111. /* VirtualChannelWrite completed (pData - pUserData passed on
  112.    VirtualChannelWrite)                                                     */
  113. #define CHANNEL_EVENT_WRITE_COMPLETE    11
  115. /* VirtualChannelWrite cancelled (pData - pUserData passed on
  116.    VirtualChannelWrite)                                                     */
  117. #define CHANNEL_EVENT_WRITE_CANCELLED   12
  120. /****************************************************************************/
  121. /* Return codes from VirtualChannelXxx functions                            */
  122. /****************************************************************************/
  123. #define CHANNEL_RC_OK                             0
  124. #define CHANNEL_RC_ALREADY_INITIALIZED            1
  125. #define CHANNEL_RC_NOT_INITIALIZED                2
  126. #define CHANNEL_RC_ALREADY_CONNECTED              3
  127. #define CHANNEL_RC_NOT_CONNECTED                  4
  128. #define CHANNEL_RC_TOO_MANY_CHANNELS              5
  129. #define CHANNEL_RC_BAD_CHANNEL                    6
  130. #define CHANNEL_RC_BAD_CHANNEL_HANDLE             7
  131. #define CHANNEL_RC_NO_BUFFER                      8
  132. #define CHANNEL_RC_BAD_INIT_HANDLE                9
  133. #define CHANNEL_RC_NOT_OPEN                      10
  134. #define CHANNEL_RC_BAD_PROC                      11
  135. #define CHANNEL_RC_NO_MEMORY                     12
  136. #define CHANNEL_RC_UNKNOWN_CHANNEL_NAME          13
  137. #define CHANNEL_RC_ALREADY_OPEN                  14
  138. #define CHANNEL_RC_NOT_IN_VIRTUALCHANNELENTRY    15
  139. #define CHANNEL_RC_NULL_DATA                     16
  140. #define CHANNEL_RC_ZERO_LENGTH                   17
  142. /****************************************************************************/
  143. /* Levels of Virtual Channel Support                                        */
  144. /****************************************************************************/
  145. #define VIRTUAL_CHANNEL_VERSION_WIN2000         1
  147. #ifdef __cplusplus
  148. extern "C" {
  149. #endif /* __cplusplus */
  150. /****************************************************************************/
  151. /* Name: VirtualChannelInit                                                 */
  152. /*                                                                          */
  153. /* Purpose:                                                                 */
  154. /*                                                                          */
  155. /* This function is called by the application to register the virtual       */
  156. /* channels it wants to have access to.  Note that this does not open the   */
  157. /* channels, merely reserves the names for use by this application.  This   */
  158. /* function must be called before the Client connects to the Server, hence  */
  159. /* it is recommended that it is called from the DLL's initialization        */
  160. /* procedure.                                                               */
  161. /*                                                                          */
  162. /*                                                                          */
  163. /* On_return, the channels requested have been registered.  However, other  */
  164. /* MSTSC initialization may not yet have completed.  The application        */
  165. /* receives a VirtualChannelInitEvent callback with the "Client             */
  166. /* initialized" event when all MSTSC initialization is complete.            */
  167. /*                                                                          */
  168. /* Returns:                                                                 */
  169. /*                                                                          */
  170. /* CHANNEL_RC_OK                                                            */
  171. /* CHANNEL_RC_ALREADY_INITIALIZED                                           */
  172. /* CHANNEL_RC_ALREADY_CONNECTED                                             */
  173. /* CHANNEL_RC_TOO_MANY_CHANNELS                                             */
  174. /* CHANNEL_RC_NOT_IN_VIRTUALCHANNELENTRY                                    */
  175. /*                                                                          */
  176. /* Parameters                                                               */
  177. /*                                                                          */
  178. /* - ppInitHandle (returned) - handle to pass to subsequent                 */
  179. /*                             VirtualChannelXxx calls                      */
  180. /* - pChannel - list of names registered by this application                */
  181. /* - channelCount - number of channels registered.                          */
  182. /* - versionRequested - level of virtual channel support requested (one of  */
  183. /*                      the VIRTUAL_CHANNEL_LEVEL_XXX parameters)           */
  184. /* - pChannelInitEventProc - address of VirtualChannelInitEvent procedure   */
  185. /*                                                                          */
  186. /****************************************************************************/
  187. typedef UINT VCAPITYPE VIRTUALCHANNELINIT(
  188.                 LPVOID FAR *           ppInitHandle,
  189.                 PCHANNEL_DEF           pChannel,
  190.                 INT                    channelCount,
  191.                 ULONG                  versionRequested,
  192.                 PCHANNEL_INIT_EVENT_FN pChannelInitEventProc);
  194. typedef VIRTUALCHANNELINIT FAR * PVIRTUALCHANNELINIT;
  197. /****************************************************************************/
  198. /* Name: VirtualChannelOpen                                                 */
  199. /*                                                                          */
  200. /* Purpose:                                                                 */
  201. /*                                                                          */
  202. /* This function is called by the application to open a channel.  It cannot */
  203. /* be called until a connection is established with a Server.               */
  204. /*                                                                          */
  205. /* Returns:                                                                 */
  206. /*                                                                          */
  207. /* CHANNEL_RC_OK                                                            */
  208. /* CHANNEL_RC_NOT_INITIALIZED                                               */
  209. /* CHANNEL_RC_NOT_CONNECTED                                                 */
  210. /* CHANNEL_RC_BAD_CHANNEL_NAME                                              */
  211. /* CHANNEL_RC_BAD_INIT_HANDLE                                               */
  212. /*                                                                          */
  213. /* Params:                                                                  */
  214. /*                                                                          */
  215. /* - pInitHandle - handle from VirtualChannelInit                           */
  216. /*                                                                          */
  217. /* - pOpenHandle (returned) - handle to pass to subsequent                  */
  218. /*                            VirtualChannelXxx calls                       */
  219. /* - pChannelName - name of channel to open                                 */
  220. /* - pChannelOpenEventProc - address of VirtualChannelOpenEvent procedure   */
  221. /*                                                                          */
  222. /****************************************************************************/
  223. typedef UINT VCAPITYPE VIRTUALCHANNELOPEN(
  224.                                 LPVOID                 pInitHandle,
  225.                                 LPDWORD                pOpenHandle,
  226.                                 PCHAR                  pChannelName,
  227.                                 PCHANNEL_OPEN_EVENT_FN pChannelOpenEventProc);
  229. typedef VIRTUALCHANNELOPEN FAR * PVIRTUALCHANNELOPEN;
  232. /****************************************************************************/
  233. /* Name: VirtualChannelClose                                                */
  234. /*                                                                          */
  235. /* Purpose:                                                                 */
  236. /*                                                                          */
  237. /* This function is called to close a previously opened channel.            */
  238. /*                                                                          */
  239. /* Returns:                                                                 */
  240. /*                                                                          */
  241. /* CHANNEL_RC_OK                                                            */
  242. /* CHANNEL_RC_BAD_CHANNEL_HANDLE                                            */
  243. /*                                                                          */
  244. /* Params:                                                                  */
  245. /*                                                                          */
  246. /* - openHandle - handle returned on VirtualChannelOpen                     */
  247. /*                                                                          */
  248. /****************************************************************************/
  249. typedef UINT VCAPITYPE VIRTUALCHANNELCLOSE(DWORD openHandle);
  251. typedef VIRTUALCHANNELCLOSE FAR * PVIRTUALCHANNELCLOSE;
  254. /****************************************************************************/
  255. /* Name: VirtualChannelWrite                                                */
  256. /*                                                                          */
  257. /* Purpose:                                                                 */
  258. /*                                                                          */
  259. /* This function is used to send data to the partner app on the Server.     */
  260. /*                                                                          */
  261. /* VirtualChannelWrite copies the data to one or more network buffers as    */
  262. /* necessary.  VirtualChannelWrite ensures that data is sent to the Server  */
  263. /* on the right context.  It sends all data on MS TC's Sender thread.       */
  264. /*                                                                          */
  265. /* VirtualChannelWrite is asynchronous - the VirtualChannelOpenEvent        */
  266. /* procedure is called when the write completes.  Until that callback is    */
  267. /* made, the caller must not free or reuse the buffer passed on             */
  268. /* VirtualChannelWrite.  The caller passes a piece of data (pUserData) to   */
  269. /* VirtualChannelWrite, which is returned on the VirtualChannelOpenEvent    */
  270. /* callback.  The caller can use this data to identify the write which has  */
  271. /* completed.                                                               */
  272. /*                                                                          */
  273. /*                                                                          */
  274. /* Returns:                                                                 */
  275. /*                                                                          */
  276. /* CHANNEL_RC_OK                                                            */
  277. /* CHANNEL_RC_NOT_INITIALIZED                                               */
  278. /* CHANNEL_RC_NOT_CONNECTED                                                 */
  279. /* CHANNEL_RC_BAD_CHANNEL_HANDLE                                            */
  280. /*                                                                          */
  281. /* Params:                                                                  */
  282. /* - openHandle - handle from VirtualChannelOpen                            */
  283. /* - pData - data to write                                                  */
  284. /* - datalength - length of data to write                                   */
  285. /* - pUserData - user supplied data, returned on VirtualChannelOpenEvent    */
  286. /*               when the write completes                                   */
  287. /*                                                                          */
  288. /****************************************************************************/
  289. typedef UINT VCAPITYPE VIRTUALCHANNELWRITE(DWORD  openHandle,
  290.                                            LPVOID pData,
  291.                                            ULONG  dataLength,
  292.                                            LPVOID pUserData);
  294. typedef VIRTUALCHANNELWRITE FAR * PVIRTUALCHANNELWRITE;
  297. /****************************************************************************/
  298. /* Structure: CHANNEL_ENTRY_POINTS                                          */
  299. /*                                                                          */
  300. /* Description: Virtual Channel entry points passed to VirtualChannelEntry  */
  301. /****************************************************************************/
  302. typedef struct tagCHANNEL_ENTRY_POINTS
  303. {
  304.     DWORD cbSize;
  305.     DWORD protocolVersion;
  306.     PVIRTUALCHANNELINIT  pVirtualChannelInit;
  307.     PVIRTUALCHANNELOPEN  pVirtualChannelOpen;
  308.     PVIRTUALCHANNELCLOSE pVirtualChannelClose;
  309.     PVIRTUALCHANNELWRITE pVirtualChannelWrite;
  310. } CHANNEL_ENTRY_POINTS, FAR * PCHANNEL_ENTRY_POINTS;
  313. /****************************************************************************/
  314. /* Name: VirtualChannelEntry                                                */
  315. /*                                                                          */
  316. /* Purpose:                                                                 */
  317. /*                                                                          */
  318. /* This function is provided by addin DLLS.  It is called by MSTSC at       */
  319. /* initialization to tell the addin DLL the addresses of the                */
  320. /* VirtualChannelXxx functions.                                             */
  321. /*                                                                          */
  322. /* Returns:                                                                 */
  323. /*                                                                          */
  324. /* TRUE - everything OK                                                     */
  325. /* FALSE - error, unload the DLL                                            */
  326. /*                                                                          */
  327. /* Parameters:                                                              */
  328. /*                                                                          */
  329. /* - pVirtualChannelInit - pointers to VirtualChannelXxx functions          */
  330. /* - pVirtualChannelOpen                                                    */
  331. /* - pVirtualChannelClose                                                   */
  332. /* - pVirtualChannelWrite                                                   */
  333. /*                                                                          */
  334. /****************************************************************************/
  335. typedef BOOL VCAPITYPE VIRTUALCHANNELENTRY(
  336.                                           PCHANNEL_ENTRY_POINTS pEntryPoints);
  338. typedef VIRTUALCHANNELENTRY FAR * PVIRTUALCHANNELENTRY;
  341. #ifdef __cplusplus
  342. }
  343. #endif  /* __cplusplus */
  345. #endif /* H_CCHANNEL */