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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
socketmodel.cpp
资源名称：1731.rar　[点击查看]
上传用户：swkcbjrc
上传日期：2016-04-02
资源大小：45277k
文件大小：30k
源码类别：

游戏

开发平台：

Visual C++

socketmodel.cpp：源码内容
  1. // DPEventSocket.cpp: implementation of the CSocketModel class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "SocketModel.h"
  8. #ifdef _DEBUG
  9. #undef THIS_FILE
  10. static char THIS_FILE[]=__FILE__;
  11. #define new DEBUG_NEW
  12. #endif
  14. //////////////////////////////////////////////////////////////////////
  15. // Construction/Destruction
  16. //////////////////////////////////////////////////////////////////////
  18. CSocketModel::CSocketModel()
  19. {
  20. ::InitializeCriticalSection(&m_csErrorNo);
  21. }
  23. CSocketModel::~CSocketModel()
  24. {
  25. ::DeleteCriticalSection(&m_csErrorNo);
  26. }
  28. // 设置套接字是否为阻塞的
  29. //入口:套接字,是否需要阻塞的
  30. //出口:如果正确那么返回0，错误返回-1
  31. int CSocketModel::BlockSocket(SOCKET hSocket, BOOL bBlock/*FALSE*/)
  32. {
  33. u_long IoctlLong = (bBlock) ? 0 : 1;
  35. if (ioctlsocket(hSocket, FIONBIO, &IoctlLong) == SOCKET_ERROR)
  36. {
  37. SetLastError( WSAGetLastError() );
  38. return (SOCKET_ERROR);
  39.     }
  40. return (SOCKET_SUCCESS);
  41. }
  43. //设置套接字属性
  44. //入口:套接字
  45. //出口:如果正确那么返回0，错误返回-1
  46. int CSocketModel::SetSocketOption(SOCKET hSocket)
  47. {
  49.     int nActivate = 1;
  51. //允许地址重用
  52.     if (setsockopt(hSocket, SOL_SOCKET, SO_REUSEADDR, (const char *) &nActivate,
  53. sizeof(nActivate)) == SOCKET_ERROR )
  54.     {
  55.         SetLastError( WSAGetLastError() );
  56.         return (SOCKET_ERROR);//return (-1)
  57.     }
  59. //  如果支持，设置KEEPALIVE属性 (这样做会带来其他不良后果)
  60. //setsockopt(hSocket, SOL_SOCKET, SO_KEEPALIVE, (const char *) &nActivate,sizeof(iActivate));
  62. return (SOCKET_SUCCESS);
  63. }
  65. //接收所有数据，注意在这个函数调用之前必须确认是否有接收消息到来
  66. //入口:套接字,数据缓冲区,缓冲区大小
  67. //出口:如果正确那么返回接收的字节数量，错误返回错误代码
  68. //注意:这里使用的是WINSOCK2的专有WSARecv()函数进行接收,所以为非阻塞模式
  69. //     所以调用此函数前必须确认有数据到来的消息，否则返回错误
  70. int CSocketModel::RecvLL(SOCKET hSocket, char *pszBuffer, int nBufferSize)
  71. {
  72. DWORD dwRtxBytes = 0,
  73. dwRtxFlags = 0;
  74. WSABUF WSABuff;
  76. //清空缓冲
  77. ZeroMemory(&WSABuff,sizeof(WSABUF));
  79. WSABuff.len = nBufferSize;
  80. WSABuff.buf = pszBuffer;
  81. //如果正确就返回本次接收的字节个数，如果错误返回错误号码(负数)
  82. return ((WSARecv(hSocket, &WSABuff, 1, &dwRtxBytes, &dwRtxFlags,NULL, NULL) 
  83. == SOCKET_SUCCESS) ? (int) dwRtxBytes : -WSAGetLastError());
  84. }
  86. int CSocketModel::RecvData_Block(SOCKET hSocket, char *pszBuffer, int nBufferSize, 
  87. DWORD dwTimeout)
  88. {
  89. ASSERT(hSocket != NULL);
  90. if(hSocket==NULL)
  91. return ( SOCKET_ERROR );
  92. FD_SET fd = {1, hSocket};
  93. TIMEVAL tv = {dwTimeout, 0};
  94. int nBytesReceived=0;
  95. if(select(0, &fd, NULL, NULL, &tv) == 0) 
  96. goto CLEAR;
  97. if((nBytesReceived = recv(hSocket, pszBuffer, nBufferSize, 0)) == SOCKET_ERROR)
  98. goto CLEAR;
  99. return nBytesReceived;
  101. CLEAR:
  102. SetLastError(WSAGetLastError());//超时
  103. return(SOCKET_ERROR);
  104. }
  106. // 接收数据(阻塞直至收到数据为止)
  107. //入口:套接字,缓冲区,缓冲区大小,超时
  108. //注意:这个函数只管理一个端口的接收信息需求，所以这里的EventSelect不能一起管理64
  109. //     个端口的信息
  110. int CSocketModel::RecvData_Event(SOCKET hSocket, char *pszBuffer, 
  111.    int nBufferSize, DWORD dwTimeout)
  112. {
  113. HANDLE hReadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  114. if (hReadEvent == NULL)
  115. {
  116. SetLastError( (int)GetLastError() );
  117. return ( SOCKET_ERROR );
  118. }
  120. int nRecvBytes = 0;
  121. DWORD dwWaitResult ;
  122. for (;;)
  123. {
  124. // 注册FD_READ | FD_CLOSE 事件 
  125. // (因为可能在等待FD_READ事件中，对方关闭套接字，所以要关注FD_CLOSE)
  126. if( WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, FD_READ | FD_CLOSE) 
  127. == SOCKET_ERROR)
  128. {
  129. CloseHandle(hReadEvent);
  130. SetLastError( WSAGetLastError() );
  131. return (SOCKET_ERROR);
  132. }
  134. // 等等FD_READ | FD_CLOSE事件的发生
  135. dwWaitResult = WSAWaitForMultipleEvents(1, &hReadEvent, TRUE,dwTimeout, TRUE);
  137. if (dwWaitResult != WSA_WAIT_EVENT_0)
  138. {
  139. // 清除事件
  140. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  141. CloseHandle(hReadEvent);
  142. SetLastError( WSAGetLastError() );
  143. return (SOCKET_ERROR);
  144. }
  146. ////////////////////////////////////////////////////////////// 
  147. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  148. /// 进一步检查网络是否发生错误
  149. ///////////////////////////////////////////////////////////////
  150. WSANETWORKEVENTS NetEvent;
  151. if(WSAEnumNetworkEvents(hSocket,(WSAEVENT)hReadEvent,&NetEvent) == SOCKET_ERROR)
  152. {
  153. // 清除事件
  154. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  155. CloseHandle(hReadEvent);
  156. SetLastError( WSAGetLastError() );
  157. return (SOCKET_ERROR);
  158. }
  159. //判断发生了什么事件 FD_READ 或 FD_CLOSE
  160. if( ( NetEvent.lNetworkEvents == FD_CLOSE ) ||
  161.  ( NetEvent.lNetworkEvents == FD_READ && 
  162.    NetEvent.iErrorCode[FD_READ_BIT] !=0 ) ) // 发生错误
  163. {
  164. // 清除事件
  165. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  166. CloseHandle(hReadEvent);
  167. SetLastError(WSAGetLastError() );
  168. return (SOCKET_ERROR);
  169. }
  170. ////////////////////////////////////////////////////////////////
  171. // 清除事件
  172. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  174. // 接收数据
  175. if ((nRecvBytes = RecvLL(hSocket, pszBuffer, nBufferSize)) >= 0)
  176. break; // 跳出循环
  178. //Recv返回的是错误代码的负数，所以需要调转过来
  179. int nErrorCode = -nRecvBytes;
  181. if ( nErrorCode != WSAEWOULDBLOCK ) //太多的未完成重叠操作
  182. {
  183. CloseHandle(hReadEvent);
  184. SetLastError( nErrorCode );
  185. return (SOCKET_ERROR);
  186. }
  187. //阻塞住了
  188. ////////////////////////////////////////////////////////////////////////
  189. //  如果发生阻塞,就等待一定时间后重试,以免CPU轮询浪费时间
  190. ////////////////////////////////////////////////////////////////////////
  191. Sleep(_BLOCKED_SNDRCV_SLEEP);
  192.     }
  193.     CloseHandle(hReadEvent);
  194.     return (nRecvBytes);
  195. }
  197. int CSocketModel::RecvDataFrom_Block( SOCKET hSocket, struct sockaddr * pFrom, 
  198. int nAddrlen,char *pszBuffer, int nBufferSize,
  199. DWORD dwTimeout)
  200. {
  201. ASSERT(hSocket != NULL);
  202. if(hSocket==NULL)
  203. return (SOCKET_ERROR);
  204. FD_SET fd = {1, hSocket};
  205. TIMEVAL tv = {dwTimeout, 0};
  206. int nFromSize=0;
  207. int nBytesReceived=0;
  208. if(select(0, &fd, NULL, NULL, &tv) == 0) 
  209. goto CLEAR;
  210. nFromSize = nAddrlen;
  211. nBytesReceived = recvfrom(hSocket, pszBuffer, nBufferSize, 0, pFrom, &nFromSize);
  212. if(nBytesReceived == SOCKET_ERROR) 
  213. goto CLEAR;
  214. return nBytesReceived;
  216. CLEAR:
  217. SetLastError(WSAGetLastError());//超时
  218. return(SOCKET_ERROR);
  219. }
  222. // 数据报接收函数
  223. int CSocketModel::RecvDataFrom_Event( SOCKET hSocket, struct sockaddr * pFrom, 
  224.    int nAddrlen,char *pszBuffer, 
  225.    int nBufferSize,DWORD dwTimeout)
  226. {
  227. HANDLE hReadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  228. if (hReadEvent == NULL)
  229. {
  230. SetLastError((int)GetLastError() );
  231. return (SOCKET_ERROR);
  232. }
  234. DWORD dwRtxBytes = 0,
  235. dwRtxFlags = 0;
  236. WSABUF WSABuff;
  238. ZeroMemory(&WSABuff,sizeof(WSABUF));
  239. WSABuff.len = nBufferSize;
  240. WSABuff.buf = pszBuffer;
  242. for (;;)
  243. {
  244. // 注册FD_READ事件
  245. if( WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, FD_READ) 
  246. == SOCKET_ERROR)
  247. {
  248. CloseHandle(hReadEvent);
  249. SetLastError(  WSAGetLastError() );
  250. return (SOCKET_ERROR);
  251. }
  252. DWORD dwWaitResult = WSAWaitForMultipleEvents(1, &hReadEvent, 
  253. TRUE,dwTimeout, TRUE);
  255. if( dwWaitResult != WSA_WAIT_EVENT_0 )
  256. {
  257. // 注销事件
  258. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  259. CloseHandle(hReadEvent);
  260. SetLastError( WSAGetLastError());
  261. return (SOCKET_ERROR);
  262. }
  264. ////////////////////////////////////////////////////////////// 
  265. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  266. /// 进一步检查网络是否发生错误
  267. ///////////////////////////////////////////////////////////////
  268. WSANETWORKEVENTS NetEvent;
  269. if(WSAEnumNetworkEvents(hSocket,(WSAEVENT)hReadEvent,&NetEvent)
  270. == SOCKET_ERROR)
  271. {
  272. // 注销事件
  273. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  274. CloseHandle(hReadEvent);
  275. SetLastError( WSAGetLastError() );
  276. return (SOCKET_ERROR);
  277. }
  278. if(NetEvent.iErrorCode[FD_READ_BIT] !=0 ) // 发生错误
  279. {
  280. // 注销事件
  281. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  282. CloseHandle(hReadEvent);
  283. SetLastError(NetEvent.iErrorCode[FD_READ_BIT]);
  284. return (SOCKET_ERROR);
  285. }
  286. ////////////////////////////////////////////////////////////////
  287. // 注销事件
  288. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  290. int FromLen = nAddrlen;
  291. if ( WSARecvFrom(hSocket, &WSABuff, 1, &dwRtxBytes, 
  292. &dwRtxFlags,pFrom, &FromLen, NULL, NULL) == SOCKET_SUCCESS )
  293. break;
  295. if ( WSAGetLastError() != WSAEWOULDBLOCK)
  296. {
  297. CloseHandle(hReadEvent);
  298. SetLastError( WSAGetLastError() );
  299. return (SOCKET_ERROR);
  300. }
  302. ///////////////////////////////////////////////////////////////////////////
  303. // 睡眠一段时间
  304. //////////////////////////////////////////////////////////////////////////
  305. Sleep(_BLOCKED_SNDRCV_SLEEP);
  306. }
  307. CloseHandle(hReadEvent);
  308. return ((int) dwRtxBytes);
  309. }
  311. //发送数据，阻塞
  312. //入口:套接字，发送的字串,字串长度，超时值
  313. //出口:正确返回发送的字节数量，错误返回SOCKET_ERROR
  314. int CSocketModel::Send_Block(SOCKET hSocket,char const * pszBuffer, 
  315. int nBufferSize, DWORD dwTimeout)
  316. {
  317. ASSERT(hSocket!=NULL);
  318. if(hSocket==NULL||pszBuffer==NULL)
  319. return (SOCKET_ERROR);
  320. FD_SET fd = {1, hSocket};
  321. TIMEVAL tv = {dwTimeout, 0};
  322. int nBytesSent=0;
  323. if(select(0, NULL, &fd, NULL, &tv) == 0)
  324. goto CLEAR;//选择发送超时
  325. if((nBytesSent = send(hSocket, pszBuffer, nBufferSize, 0)) == SOCKET_ERROR) 
  326. goto CLEAR;//发送出错误
  327. return nBytesSent;
  329. CLEAR:
  330. SetLastError(WSAGetLastError());//超时
  331. return(SOCKET_ERROR);
  332. }
  334. //发送全部缓冲区中数据，阻塞
  335. //入口:套接字，发送的字串,字串长度，超时值
  336. //出口:正确返回发送的字节数量，错误返回SOCKET_ERROR
  337. int CSocketModel::SendData_Block(SOCKET hSocket,char const * pszBuffer, 
  338. int nBufferSize, DWORD dwTimeout)
  340. {
  341. if(hSocket==NULL)
  342. return(SOCKET_ERROR);
  343. int nBytesSent = 0;
  344. int nBytesThisTime;
  345. const char* pszTemp = pszBuffer;
  346. do {
  347. nBytesThisTime = Send_Block(hSocket,pszTemp, nBufferSize-nBytesSent, dwTimeout);
  348. if(nBytesThisTime<0)
  349. return(SOCKET_ERROR);
  350. //如果一次没有发送成功
  351. nBytesSent += nBytesThisTime;
  352. //改变当前字符指针
  353. pszTemp += nBytesThisTime;
  354. } while(nBytesSent < nBufferSize);
  355. return nBytesSent;
  356. }
  358. // 发送数据
  359. //入口:套接字，发送缓冲区，大小，超时
  360. //出口:返回一次发送数据的字节数量，如果错误返回SOCKET_ERROR
  361. int CSocketModel::Send_Event(SOCKET hSocket, char const * pszBuffer, 
  362.    int nBufferSize, DWORD dwTimeout)
  363. {
  365. HANDLE hWriteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  367. if (hWriteEvent == NULL)
  368. {
  369. SetLastError( (int)GetLastError() );
  370. return (SOCKET_ERROR);
  371. }
  373. int nSendBytes = 0;
  375. for (;;)
  376. {
  377. ////////////////////////////////////////////////////////////////
  378. // 发送数据成功
  379. if ((nSendBytes = SendLL(hSocket, pszBuffer, nBufferSize)) >= 0)
  380. break;
  382. //如果发送的字节数量小于0证明出错
  383. int nErrorCode = -nSendBytes;
  384. //如果是WSAEWOULDBLOCK错误，证明在该端口上仍然进行着其他I/O操作
  385. //所以我们下面进行必要的等待循环处理
  386. if (nErrorCode != WSAEWOULDBLOCK)
  387. {
  388. CloseHandle(hWriteEvent);
  389. SetLastError( WSAGetLastError() );
  390. return (SOCKET_ERROR);
  391. }
  393. ///////////////////////////////////////////////////////////////////////////////
  394. //  睡眠一段时间
  395. ///////////////////////////////////////////////////////////////////////////////
  396. Sleep(_BLOCKED_SNDRCV_SLEEP);
  398. // 注册FD_WRITE | FD_CLOSE 事件
  399. if( WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, FD_WRITE|FD_CLOSE) 
  400. == SOCKET_ERROR)
  401. {
  402. CloseHandle(hWriteEvent);
  403. SetLastError( WSAGetLastError() );
  404. return (SOCKET_ERROR);
  405. }
  407. // 等待事件发生
  408. DWORD dwWaitResult = WSAWaitForMultipleEvents(1, 
  409. &hWriteEvent, TRUE,dwTimeout, TRUE);
  411. if (dwWaitResult != WSA_WAIT_EVENT_0)
  412. {
  413. // 清除网络事件
  414. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  415. CloseHandle(hWriteEvent);
  416. SetLastError( WSAGetLastError() );
  417. return (SOCKET_ERROR);
  418. }
  420. ////////////////////////////////////////////////////////////// 
  421. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  422. /// 进一步检查网络是否发生错误
  423. ///////////////////////////////////////////////////////////////
  424. WSANETWORKEVENTS NetEvent;
  425. if(WSAEnumNetworkEvents(hSocket,(WSAEVENT)hWriteEvent,&NetEvent) == SOCKET_ERROR)
  426. {
  427.    // 清除网络事件
  428. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  429. CloseHandle(hWriteEvent);
  430. SetLastError( WSAGetLastError() );
  431. return (SOCKET_ERROR);
  432. }
  433. if( ( NetEvent.lNetworkEvents == FD_CLOSE ) ||
  434.  ( NetEvent.lNetworkEvents == FD_WRITE   &&
  435. NetEvent.iErrorCode[FD_WRITE_BIT] !=0 ) ) // 发生错误
  436. {
  437. // 清除网络事件
  438. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  439. CloseHandle(hWriteEvent);
  440. SetLastError( WSAGetLastError() );
  441. return (SOCKET_ERROR);
  442. }
  443. // 清除网络事件
  444. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  445.    }
  447.     CloseHandle(hWriteEvent);
  448.     return (nSendBytes);
  449. }
  451. //发送完所有数据或超时
  452. //入口:套接字，缓冲区，缓冲区大小，超时
  453. //出口:返回已经发送的字节个数或SOCKET_ERROR
  454. int CSocketModel::SendData_Event(SOCKET hSocket, char const * pszBuffer, 
  455.  int nBufferSize, DWORD dwTimeout)
  456. {
  458. int nRtxBytes = 0;
  459. int nRtxCurrent = 0;
  461. while (nRtxBytes < nBufferSize)
  462. {
  463. nRtxCurrent = Send_Event(hSocket, (pszBuffer + nRtxBytes),
  464. (nBufferSize - nRtxBytes), dwTimeout);
  465. if (nRtxCurrent < 0)
  466. return (nRtxBytes);
  467. nRtxBytes += nRtxCurrent;
  468. }
  469. return (nRtxBytes);
  470. }
  472. //一次发送数据，但不一定全部都发送
  473. //入口:套接字，接收方地址信息,地址结构，结构长度，缓冲区，缓冲区长度，超时
  474. //出口:正确返回发送字节数量，错误返回SOCKET_ERROR
  475. int CSocketModel::SendTo_Block(SOCKET hSocket, const struct sockaddr * pTo,
  476. int nAddrLen,char const * pszBuffer, int nBufferSize, DWORD dwTimeout)
  477. {
  478. if(hSocket==NULL||pszBuffer==NULL)
  479. return SOCKET_ERROR;
  480. FD_SET fd = {1, hSocket};
  481. TIMEVAL tv = {dwTimeout, 0};
  482. int nBytesSent=0;
  483. if(select(0, NULL, &fd, NULL, &tv) == 0) 
  484. goto CLEAR;
  485. nBytesSent = sendto(hSocket, pszBuffer, nBufferSize, 0, pTo, nAddrLen);
  486. if(nBytesSent == SOCKET_ERROR)
  487. goto CLEAR;
  488. return nBytesSent;
  490. CLEAR:
  491. SetLastError(WSAGetLastError());//超时
  492. return(SOCKET_ERROR);
  493. }
  495. // 数据报发送数据报
  496. int CSocketModel::SendTo_Event(SOCKET hSocket, const struct sockaddr * pTo,
  497.  int nAddrLen,char const * pszBuffer, 
  498.  int nBufferSize, DWORD dwTimeout)
  499. {
  500. HANDLE hWriteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  501. if (hWriteEvent == NULL)
  502. {
  503. SetLastError( (int)GetLastError() );
  504. return (SOCKET_ERROR);
  505. }
  507. DWORD dwRtxBytes = 0,
  508.             dwRtxFlags = 0;
  509. WSABUF WSABuff;
  511. ZeroMemory(&WSABuff,sizeof(WSABUF));
  512. WSABuff.len = nBufferSize;
  513. WSABuff.buf = (char *) pszBuffer;
  515. for (;;)
  516. {
  517. if (WSASendTo( hSocket, &WSABuff, 1, &dwRtxBytes, dwRtxFlags,
  518. pTo, nAddrLen, NULL, NULL) == SOCKET_SUCCESS)
  519. break;
  521. if (WSAGetLastError() != WSAEWOULDBLOCK)
  522. {
  523. CloseHandle(hWriteEvent);
  524. SetLastError(  WSAGetLastError() );
  525. return (SOCKET_ERROR);
  526. }
  528. //////////////////////////////////////////////////////////////////////////
  529. // 睡眠一段时间
  530. /////////////////////////////////////////////////////////////////////////
  531. Sleep(_BLOCKED_SNDRCV_SLEEP);
  533. // 注册FD_WRITE事件  
  534. if( WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, FD_WRITE) 
  535. == SOCKET_ERROR)
  536. {
  537. CloseHandle(hWriteEvent);
  538. SetLastError( WSAGetLastError() );
  539. return (SOCKET_ERROR);
  540. }
  541. DWORD dwWaitResult = WSAWaitForMultipleEvents
  542. (1, &hWriteEvent, TRUE,dwTimeout, TRUE);
  544. if( dwWaitResult != WSA_WAIT_EVENT_0 )
  545. {
  546. // 注销事件
  547. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  548. CloseHandle(hWriteEvent);
  549. SetLastError(  WSAGetLastError() );
  550. return (SOCKET_ERROR);
  551. }
  553. ////////////////////////////////////////////////////////////// 
  554. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  555. /// 进一步检查网络是否发生错误
  556. ///////////////////////////////////////////////////////////////
  557. WSANETWORKEVENTS NetEvent;
  558. if(WSAEnumNetworkEvents(hSocket,(WSAEVENT)hWriteEvent,&NetEvent) 
  559. == SOCKET_ERROR)
  560. {
  561. // 注销事件
  562. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  563. CloseHandle(hWriteEvent);
  564. SetLastError(  WSAGetLastError() );
  565. return (SOCKET_ERROR);
  566. }
  567. if(NetEvent.iErrorCode[FD_WRITE_BIT] !=0 ) // 发生错误
  568. {
  569. // 注销事件
  570. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  571. CloseHandle(hWriteEvent);
  572. SetLastError(NetEvent.iErrorCode[FD_WRITE_BIT]);
  573. return (SOCKET_ERROR);
  574. }
  575. ////////////////////////////////////////////////////////////////
  576. // 注销事件
  577. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  578. }
  580. CloseHandle(hWriteEvent);
  581. return ((int) dwRtxBytes);
  582. }
  586. //一次性发送数据(事件IO)
  587. //入口:套接字,缓冲区，缓冲区长度
  588. //出口:正确-返回发送的字节数量，错误-返回错误代码的负数
  589. int CSocketModel::SendLL(SOCKET hSocket, char const * pszBuffer, 
  590.  int nBufferSize)
  591. {
  592. DWORD dwRtxBytes = 0;
  593. WSABUF WSABuff;
  595. ZeroMemory(&WSABuff,sizeof(WSABUF));
  596. WSABuff.len = nBufferSize;
  597. WSABuff.buf = (char *) pszBuffer;
  599. return ((WSASend(hSocket, &WSABuff, 1, &dwRtxBytes, 0,NULL, NULL)
  600. == SOCKET_SUCCESS) ? (int) dwRtxBytes : -WSAGetLastError());
  601. }
  603. //关闭套接字
  604. //入口:套接字,是否强行关闭(如果bHardClose==FALSE,那么接收剩余的数据后关闭连接)
  605. //注意:这里的接收剩余数据只是为了让SERVER将数据发送操作执行完毕
  606. //     所以接收的剩余数据不可用
  607. void CSocketModel::CloseSocket(SOCKET hSocket, BOOL bHardClose)
  608. {
  609. // 不需要捕获错误
  610. if (!bHardClose) // 优雅关闭 Graceful close
  611. {
  612. // 不再发送数据，对于TCP套接字，在所有的数据都发送完毕之后，
  613. // 将发送一个 FIN ，通知接收方所有数据已经发送完毕。
  614. shutdown(hSocket, SD_SEND);
  616. // 接收缓冲区有可能还有未接收的数据，在关闭套接字之前应该先
  617. // 读取残留的数据。
  618. int nRecvResult;
  619. HANDLE hSocketEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  620. //为残留数据提供的缓冲区
  621. char szBuffer[256];
  622. do
  623. {
  624. if (hSocketEvent != NULL)
  625. {
  626. //注册网络事件
  627. WSAEventSelect(hSocket, (WSAEVENT) hSocketEvent, FD_READ | FD_CLOSE);
  628. WSAWaitForMultipleEvents(1, &hSocketEvent, TRUE,_SHUTDOWN_RECV_TIMEOUT, TRUE);
  629. //清除网络事件
  630. WSAEventSelect(hSocket, (WSAEVENT) hSocketEvent, 0);
  631. }
  632. ZeroMemory(szBuffer,256);
  633. //接收残留数据
  634. nRecvResult = RecvLL(hSocket, szBuffer, sizeof(szBuffer));
  635. } while (nRecvResult > 0);
  637. if (hSocketEvent != NULL)
  638. CloseHandle(hSocketEvent);
  639. //不再允许接收和发送
  640. shutdown(hSocket, SD_BOTH);
  641. }
  642. // 关闭套接字
  643. closesocket(hSocket);
  644. }
  646. //接受套接字连接
  647. //入口:侦听端口号,本地地址
  648. //出口:返回一个可用的套接字或INVALID_SOCKET
  649. //注意:如果为阻塞等待，就是在DWTIMEOUT的时间设置为无限的时候
  650. //     如果我们关闭该套接字会出现的问题
  651. SOCKET CSocketModel::Accept_Event(SOCKET hSocket, struct sockaddr * pSocketAddress, 
  652.    int *nAddrLen,DWORD dwTimeout
  653.    /*= DP_DEFAULT_TIMEOUT*/)
  654. {
  655. HANDLE hAcceptEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  656. if (hAcceptEvent == NULL)
  657. {
  658. SetLastError( (int)GetLastError() );
  659. return (INVALID_SOCKET);
  660. }
  662. //异步事件选择
  663. // 注册FD_ACCEPT事件
  664. if( WSAEventSelect(hSocket, (WSAEVENT) hAcceptEvent, FD_ACCEPT) == SOCKET_ERROR)
  665. {
  666. CloseHandle(hAcceptEvent);
  667. SetLastError( WSAGetLastError() );
  668. return (INVALID_SOCKET);
  669. }
  671. //进行非阻塞接收
  672. SOCKET hSocketAccept = WSAAccept(hSocket, pSocketAddress, nAddrLen, NULL, 0);
  673. int nConnectError = WSAGetLastError();
  674. //如果返回的端口是没有定义的，并且接收的错误码为"代决"状态
  675. if ((hSocketAccept == INVALID_SOCKET) && (nConnectError == WSAEWOULDBLOCK))
  676. {
  678. //阻塞，这个函数如果正确返回那么我们在使用WSAACCEPT重新接收一次，
  679. //就可以获得用户的SOCKET
  680. //因为这个函数返回代表ACCPETEVENT成为传信状态，如果网络没有错误那么
  681. //代表有用户的正确端口接入
  682. DWORD dwWaitResult = WSAWaitForMultipleEvents
  683. (1,&hAcceptEvent,TRUE,dwTimeout,TRUE);
  684. if (dwWaitResult == WSA_WAIT_EVENT_0)
  685. {
  686. ////////////////////////////////////////////////////////////// 
  687. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  688. /// 进一步检查网络是否发生错误
  689. ///////////////////////////////////////////////////////////////
  690. WSANETWORKEVENTS NetEvent;
  691. if(WSAEnumNetworkEvents(hSocket,hAcceptEvent,&NetEvent) == SOCKET_ERROR)
  692. SetLastError( WSAGetLastError() );
  693. else if(NetEvent.iErrorCode[FD_ACCEPT_BIT] !=0 ) // 发生错误
  694. SetLastError( NetEvent.iErrorCode[FD_ACCEPT_BIT] );
  695. else
  696. //接收到真正的用户SOCKET
  697. hSocketAccept = WSAAccept(hSocket, pSocketAddress, nAddrLen, NULL, 0);
  698. }
  699. else
  700. SetLastError(WSAGetLastError());
  701. }
  703. // 注销网络事件
  704. WSAEventSelect(hSocket, (WSAEVENT) hAcceptEvent, 0);
  705. CloseHandle(hAcceptEvent);
  707. if (hSocketAccept != INVALID_SOCKET)
  708. {
  709. // 设置套接字的属性为地址可重用并且为非阻塞的
  710. if ((BlockSocket(hSocketAccept, 0)  == SOCKET_ERROR ) ||
  711. (SetSocketOption(hSocketAccept) == SOCKET_ERROR ) )
  712. {
  713. CloseSocket(hSocketAccept,TRUE);
  714. return (INVALID_SOCKET);
  715. }
  716. }
  717. return (hSocketAccept);
  718. }
  720. // 接受套接字连接(允许中断)
  721. //入口:结束事件，其他入口都和Accept一样
  722. //出口:返回一个可用的套接字或INVALID_SOCKET
  723. //注意:超时值默认为DP_DEFAULT_TIMEOUT，如果结束事件没有的话，
  724. //     那么跟调用上面的函数没有区别
  725. SOCKET CSocketModel::AcceptEx_Event(SOCKET hSocket, struct sockaddr * pSocketAddress, 
  726.   int *nAddrLen,HANDLE hEndEvent,DWORD dwTimeout 
  727.   /*= DP_DEFAULT_TIMEOUT*/)
  728. {
  729. if( hEndEvent == NULL)
  730. return Accept_Event(hSocket,pSocketAddress,nAddrLen,dwTimeout);
  732. HANDLE hAcceptEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  733. if (hAcceptEvent == NULL)
  734. {
  735. SetLastError( (int)GetLastError() );
  736. return (INVALID_SOCKET);
  737. }
  739. WSAEVENT hEvent[2]; 
  740. hEvent[0] = (WSAEVENT)hAcceptEvent;
  741. hEvent[1] = (WSAEVENT)hEndEvent;
  743. // 注册FD_ACCEPT事件
  744. if( WSAEventSelect(hSocket, (WSAEVENT) hAcceptEvent, FD_ACCEPT) == SOCKET_ERROR)
  745. {
  746. CloseHandle(hAcceptEvent);
  747. SetLastError( WSAGetLastError() );
  748. return (INVALID_SOCKET);
  749. }
  751. SOCKET hSocketAccept = WSAAccept(hSocket, pSocketAddress, nAddrLen, NULL, 0);
  752. int    nConnectError = WSAGetLastError();
  754. if ((hSocketAccept == INVALID_SOCKET) && (nConnectError == WSAEWOULDBLOCK))
  755. {
  756. // 阻塞,等待两个事件，如果其中一个发生那么我们向下继续执行
  757. //所以这意味着指定结束事件后，如果程序想中断ACCEPT的执行
  758. //那么就激活该结束事件，程序将按照错误一样的处理
  759. DWORD dwWaitResult = WSAWaitForMultipleEvents(2, hEvent, FALSE,dwTimeout, TRUE);
  760. if (dwWaitResult == WSA_WAIT_EVENT_0)
  761. {
  762. ////////////////////////////////////////////////////////////// 
  763. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  764. /// 进一步检查网络是否发生错误
  765. ///////////////////////////////////////////////////////////////
  766. WSANETWORKEVENTS NetEvent;
  767. if(WSAEnumNetworkEvents(hSocket,hAcceptEvent,&NetEvent) == SOCKET_ERROR)
  768. SetLastError(WSAGetLastError());
  769. else if(NetEvent.iErrorCode[FD_ACCEPT_BIT] !=0 ) // 发生错误
  770. SetLastError( NetEvent.iErrorCode[FD_ACCEPT_BIT] );
  771. else
  772. hSocketAccept = WSAAccept(hSocket, pSocketAddress, nAddrLen, NULL, 0);
  773. }
  774. else
  775. SetLastError( WSAGetLastError() );
  776. }
  778. // 注销网络事件
  779. WSAEventSelect(hSocket, (WSAEVENT) hAcceptEvent, 0);
  780. CloseHandle(hAcceptEvent);
  782. if (hSocketAccept != INVALID_SOCKET)
  783. {
  784. // 设置套接字的属性为地址可重用并且为非阻塞的
  785. if ((BlockSocket(hSocketAccept, 0) < 0) ||
  786. (SetSocketOption(hSocketAccept) < 0) )
  787. {
  788. CloseSocket(hSocketAccept,TRUE);
  789. return (INVALID_SOCKET);
  790. }
  791. }
  792. return (hSocketAccept);
  793. }
  795. //阻塞ACCEPT，没有响应不返回
  796. //入口:套接字，主机地址，长度
  797. //出口:正确返回端口号，否则返回INVALID_SOCKET
  798. SOCKET CSocketModel::Accept_Block(SOCKET hSocket, struct sockaddr * pSocketAddress,
  799. int *nAddrLen)
  800. {
  801. ASSERT(hSocket!=NULL);
  802. //int nLengthAddr = sizeof(SOCKADDR);
  803. SOCKET hAccept = accept(hSocket, pSocketAddress, nAddrLen);
  804. //如果该端口错误
  805. if(hAccept == INVALID_SOCKET) {
  806. SetLastError(WSAGetLastError());
  807. }
  808. return hAccept;
  809. }
  811. // 绑定套接字
  812. //入口:套接字,绑定的地址信息,长度
  813. //出口:正确0，错误-1
  814. int CSocketModel::BindSocket(SOCKET hSocket, struct sockaddr * pSocketAddress, 
  815. int nAddrLen)
  816. {
  817. if (bind(hSocket, pSocketAddress, nAddrLen) == SOCKET_ERROR)
  818. {
  819. SetLastError( WSAGetLastError() );
  820. return (SOCKET_ERROR);
  821. }
  822. return (SOCKET_SUCCESS);
  823. }
  825. // 绑定套接字
  826. //入口:套接字,端口号
  827. //出口:正确0,错误-1
  828. //注意:这个函数不同于上个函数,调用这个函数只需要给定一个端口号
  829. //     至于地址信息在函数内部默认处理(本机IP的该端口)
  830. int CSocketModel::BindSocketEx(SOCKET hSocket,int nPort)
  831. {
  832. SOCKADDR_IN sockAddr;
  833. ZeroMemory(&sockAddr,sizeof(sockAddr));
  835. sockAddr.sin_family = AF_INET;
  836. sockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  837. sockAddr.sin_port = htons((u_short)nPort);
  839. return BindSocket(hSocket,(SOCKADDR *)&sockAddr, sizeof(sockAddr));
  840. }
  842. //释放Winsock2动态连接库
  843. //入口:无
  844. //出口:无
  845. void CSocketModel::CleanupLibrary(void)
  846. {
  847.     WSACleanup();
  848. }
  850. //注册WINSOCK2.2DLL
  851. //入口:无
  852. //出口:无
  853. int CSocketModel::InitLibrary(void)
  854. {
  855. WSADATA         WSD;
  856. WORD wVersionRequired = MAKEWORD( _SOCKET_MAJOR_VERSION,_SOCKET_MINOR_VERSION );
  858. ZeroMemory(&WSD,sizeof(WSADATA));
  860. int nErrorNo = WSAStartup(wVersionRequired, &WSD);
  862. if ( SOCKET_SUCCESS != nErrorNo )
  863. {
  864. SetLastError( nErrorNo );
  865. return ( SOCKET_ERROR );
  866. }
  867. if ( LOBYTE( WSD.wVersion ) != _SOCKET_MINOR_VERSION ||
  868.  HIBYTE( WSD.wVersion ) != _SOCKET_MAJOR_VERSION ) 
  869. {
  870. WSACleanup( );
  871. SetLastError( WSAVERNOTSUPPORTED );
  872. return (SOCKET_ERROR); 
  873. }
  874. //成功初始化
  875. return (SOCKET_SUCCESS);
  876. }
  879. // 建立连接
  880. //入口:套接字,地址结构,结构长度,超时
  881. //出口:SOCKET_SUCCESS/SOCKET_ERROR
  882. int CSocketModel::Connect_Event(SOCKET hSocket, const struct sockaddr * pSocketAddress, 
  883.   int nAddrLen,DWORD dwTimeout)
  884. {
  886. HANDLE hConnectEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  888. if (hConnectEvent == NULL)
  889. {
  890. SetLastError( (int)GetLastError() );
  891. return (SOCKET_ERROR);
  892. }
  894. // 注册FD_CONNECT事件
  895. if( WSAEventSelect(hSocket, (WSAEVENT) hConnectEvent, FD_CONNECT) == SOCKET_ERROR)
  896. {
  897. CloseHandle(hConnectEvent);
  898. SetLastError( WSAGetLastError() );
  899. return (SOCKET_ERROR);
  900. }
  902. int nConnectResult = WSAConnect(hSocket, pSocketAddress, nAddrLen, 
  903. NULL, NULL, NULL, NULL);
  904. int nConnectError  = WSAGetLastError();
  906. if ((nConnectResult == SOCKET_ERROR) && (nConnectError == WSAEWOULDBLOCK))
  907. {
  908. DWORD dwWaitResult = WSAWaitForMultipleEvents(1, &hConnectEvent, 
  909. TRUE,dwTimeout, TRUE);
  911. if (dwWaitResult != WSA_WAIT_EVENT_0)
  912. {
  913. SetLastError( WSAGetLastError() );
  914. nConnectResult = SOCKET_ERROR;
  915. }
  916. else
  917. {
  918. ////////////////////////////////////////////////////////////// 
  919. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  920. /// 进一步检查网络是否发生错误
  921. ///////////////////////////////////////////////////////////////
  922. WSANETWORKEVENTS NetEvent;
  923. if(WSAEnumNetworkEvents(hSocket,(WSAEVENT)hConnectEvent,&NetEvent) 
  924. == SOCKET_ERROR)
  925. {
  926. SetLastError( WSAGetLastError() );
  927. nConnectResult = SOCKET_ERROR;
  928. }
  929. else if(NetEvent.iErrorCode[FD_CONNECT_BIT] !=0 ) // 发生错误
  930. {
  931. SetLastError( NetEvent.iErrorCode[FD_CONNECT_BIT] );
  932. nConnectResult = SOCKET_ERROR;
  933. }
  934. else
  935. nConnectResult = SOCKET_SUCCESS;
  936. ////////////////////////////////////////////////////////////////
  937. }
  938. }
  940. // 注销网络事件
  941. WSAEventSelect(hSocket, (WSAEVENT) hConnectEvent, 0);
  942. CloseHandle(hConnectEvent);
  943. return (nConnectResult);
  944. }
  946. int CSocketModel::Connect_Block(SOCKET hSocket, const struct sockaddr * pSocketAddress, 
  947. int nAddrLen)
  948. {
  949. ASSERT(hSocket!=NULL);
  950. if(hSocket==NULL)
  951. return SOCKET_ERROR;
  952. if(connect(hSocket, pSocketAddress, nAddrLen) == SOCKET_ERROR) 
  953. return SOCKET_ERROR;
  954. return SOCKET_SUCCESS;
  955. }
  957. //创建具有重叠IO能力的套接字
  958. //入口:协议，协议类型(TCP/UDP),协议
  959. //出口:返回创建的重叠IO SOCKET
  960. //注意:使用SOCKET()函数创建的套接字默认具有重叠IO能力
  961. SOCKET CSocketModel::CreateSocket(int nAddressFamily /*= AF_INET*/, 
  962.   int nType/*= SOCK_STREAM*/,
  963.   int nProtocol/*= 0*/)
  964. {
  965. SOCKET hSocket = WSASocket(nAddressFamily, nType, nProtocol, 
  966. NULL,0,WSA_FLAG_OVERLAPPED);
  967. if ( hSocket == INVALID_SOCKET )
  968. {
  969. SetLastError( WSAGetLastError() );
  970. return (INVALID_SOCKET);
  971. }
  973. //设置套接字选项
  974. if ( SOCKET_ERROR == SetSocketOption(hSocket) ) //设置属性失败
  975. {
  976. CloseSocket(hSocket, TRUE);
  977. return (INVALID_SOCKET);
  978. }
  979. return (hSocket);
  980. }
  983. //引入该函数的目的是为了避免NT下对域名解析的CACHE造成的问题
  984. //入口:无
  985. //出口:返回主机IP,或者INADDR_NONE
  986. DWORD WINAPI DNSThread(  LPVOID pParam )
  987. {
  988. DWORD dwIP = INADDR_NONE;
  989. PHOSTENT pHost = gethostbyname( (char *)pParam );
  990. if(pHost == NULL)
  991. return INADDR_NONE;
  992. dwIP = inet_addr( inet_ntoa(*(IN_ADDR *)*pHost->h_addr_list) );
  993. return dwIP;
  994. }
  996. //取得一个指定名字或者IP字串的DWORD IP表示
  997. //入口:主机IP或者域名,是否启动新线程进行查找IP
  998. //出口:返回IP，或者INADDR_NONE
  999. DWORD CSocketModel::GetIP(const char* name,BOOL bFixNtDNS /* = FALSE*/)// Used to Fix NT DNS Problem
  1000. {
  1001. //这里是为了将字串IP直接转换成DWORD的形式
  1002. DWORD dwIP = inet_addr(name);
  1003. if( dwIP != INADDR_NONE )
  1004. return dwIP;
  1005. //如果传入的是服务器的域名则进行向下程序
  1006. //如果NT的CATCH有问题，那么进入下面的模块，主要是启动新线程进行域名解析
  1007. if( bFixNtDNS )
  1008. {
  1009. OSVERSIONINFO osVersion;
  1010. osVersion.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
  1011. if( GetVersionEx(&osVersion) )
  1012. {
  1013. if(osVersion.dwPlatformId == VER_PLATFORM_WIN32_NT)
  1014. {
  1015. DWORD dwThreadId = 0;
  1016. HANDLE hThread = CreateThread(NULL,0,DNSThread,(LPVOID)name,0,&dwThreadId);
  1017. if( hThread != NULL)
  1018. {
  1019. //注意这里在等待的不是一个事件，而是线程句柄
  1020. WaitForSingleObject(hThread,INFINITE);
  1021. //注意这里取得线程退出码就是我们需要的IP
  1022. if( GetExitCodeThread(hThread,&dwIP))
  1023. return dwIP;
  1024. }
  1025. }
  1026. }
  1027. }
  1028. //取得主机信息
  1029. PHOSTENT pHost = gethostbyname(name);
  1030. if(pHost == NULL)
  1031. return INADDR_NONE;
  1033. dwIP = inet_addr( inet_ntoa(*(IN_ADDR *)*pHost->h_addr_list) );
  1034. return dwIP;
  1035. }
  1037. // 监听套接字
  1038. //入口:套接字,接入的等待队列长度
  1039. //出口:SOCKET_ERROR/SOCKET_SUCCESS
  1040. int CSocketModel::ListenSocket(SOCKET hSocket, int nConnections)
  1041. {
  1042. if(listen(hSocket, nConnections) == SOCKET_ERROR)
  1043. {
  1044. SetLastError( WSAGetLastError() );
  1045. return (SOCKET_ERROR);
  1046. }
  1047. return (SOCKET_SUCCESS);
  1048. }