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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > P2P编程 > 查看源码
TE_Socket.cpp
资源名称：p2p_vod.rar　[点击查看]
上传用户：liguizhu
上传日期：2015-11-01
资源大小：2422k
文件大小：35k
源码类别：

P2P编程

开发平台：

Visual C++

TE_Socket.cpp：源码内容
  1. ////////////////////////////////////////////////////////////////////////////////
  2. // Copyright (C) 2000-2001 Softelf Inc. All rights reserved.
  3. ////////////////////////////////////////////////////////////////////////////////
  4. //
  5. // Author : Telan 
  6. // Date : 2000-10-04
  7. // Purpose : Encapsulate winsock2 functions to make it more easily used 
  8. // History : 
  9. // 1.0 : 2000-03-10 - First Edition of this source code ( called:FE_SOCKET )
  10. // 2.0 : 2000-06-25 - Second Edition ( name changed to TE_SOCKET )
  11. //  - Add Error Control
  12. // 3.0 : 2000-09-21 - Third Edition ( name changed to TE_SOCKET )
  13. //  - Change the errors' process mechanism
  14. //  - Add BufSocket Model
  15. //  - Add TE_ConnectEx(...)
  16. //  - Add TE_BSocketGetData(...) for specail usage
  17. // 3.1 : 2000-10-04 - Add TE_AcceptEx(...)
  18. //  - Add TE_GetIP(...) to fix NT DNS resolve cache problem
  19. //  - Modify TE_ConnectEx
  20. //  - Fix several bugs in NetEvent process
  21. //
  22. // Mailto : telan@263.net ( Bugs' Report or Comments )
  23. // Notes : This source code may be used in any form in any way you desire. It is
  24. //   provided "as is" without express or implied warranty. Use it at your own
  25. //   risk! The author accepts no liability for any damage/loss of business 
  26. //   that this product may cause.
  27. //
  28. ////////////////////////////////////////////////////////////////////////////////
  29. #include "stdafx.h"
  30. #include "TE_Socket.h"
  32. //需要ws2_32.lib库
  33. #pragma comment(lib,"ws2_32.lib")
  35. //错误代号
  36. static /*__declspec(thread)*/ int _iThreadedErrorNo = 0;
  38. // 辅助函数
  39. //获取最近一次操作的错误代码
  40. int TE_GetLastError()
  41. {
  42. return (_iThreadedErrorNo);
  43. }
  45. //设置错误代码
  46. void TE_SetLastError(int iErrorCode)
  47. {
  48. _iThreadedErrorNo = iErrorCode;
  49. }
  51. /////////////////////////////////////////////////////////////////////////
  52. // Winsock2 函数
  53. /////////////////////////////////////////////////////////////////////////
  54. //初始化Winsock2动态连接库
  55. int TE_InitLibrary()
  56. {
  57. WSADATA         WSD;
  58. WORD wVersionRequired = MAKEWORD( TE_SOCKET_MAJOR_VERSION,TE_SOCKET_MINOR_VERSION );
  60. ZeroMemory(&WSD,sizeof(WSADATA));
  62. int nErrorNo = WSAStartup(wVersionRequired, &WSD);
  64. if ( SOCKET_SUCCESS != nErrorNo )
  65. {
  66. TE_SetLastError( nErrorNo );
  67. return ( SOCKET_ERROR );
  68. }
  70. if ( LOBYTE( WSD.wVersion ) != TE_SOCKET_MINOR_VERSION ||
  71.  HIBYTE( WSD.wVersion ) != TE_SOCKET_MAJOR_VERSION ) 
  72. {
  73. WSACleanup( );
  74. TE_SetLastError( WSAVERNOTSUPPORTED );
  75. return (SOCKET_ERROR); 
  76. }
  77.  
  78. //成功初始化
  79. return (SOCKET_SUCCESS);
  80. }
  83. //释放Winsock2动态连接库
  84. void TE_CleanupLibrary(void)
  85. {
  86.     WSACleanup();
  87. }
  90. //设置套接字属性
  91. int TE_SetSocketOption(SOCKET hSocket)
  92. {
  94.     int             iActivate = 1;
  96. //允许地址重用
  97.     if (setsockopt(hSocket, SOL_SOCKET, SO_REUSEADDR, (const char *) &iActivate,sizeof(iActivate)) == SOCKET_ERROR )
  98.     {
  99.         TE_SetLastError( WSAGetLastError() );
  100.         return (SOCKET_ERROR);
  101.     }
  103. //  如果支持，设置KEEPALIVE属性 (这样做会带来其他不良后果)
  104. //setsockopt(hSocket, SOL_SOCKET, SO_KEEPALIVE, (const char *) &iActivate,sizeof(iActivate));
  106. return (SOCKET_SUCCESS);
  107. }
  109. //创建具有重叠IO能力的套接字
  110. SOCKET TE_CreateSocket(int iAddressFamily /*= AF_INET*/, int iType/*= SOCK_STREAM*/,int iProtocol/*= 0*/)
  111. {
  112. SOCKET hSocket = WSASocket(iAddressFamily, iType, iProtocol, NULL,0,WSA_FLAG_OVERLAPPED);
  113. if ( hSocket == INVALID_SOCKET )
  114. {
  115. TE_SetLastError( WSAGetLastError() );
  116. return (INVALID_SOCKET);
  117. }
  119. //设置套接字选项
  120. if ( SOCKET_ERROR == TE_SetSocketOption(hSocket) ) //设置属性失败
  121. {
  122. TE_CloseSocket(hSocket, TRUE);
  123. return (INVALID_SOCKET);
  124. }
  125. return (hSocket);
  126. }
  129. //关闭套接字
  130. void TE_CloseSocket(SOCKET hSocket, BOOL bHardClose)
  131. {
  132. // 不需要捕获错误
  133. if (!bHardClose) // 优雅关闭 Graceful close
  134. {
  135. // 不再发送数据，对于TCP套接字，在所有的数据都发送完毕之后，
  136. // 将发送一个 FIN ，通知接收方所有数据已经发送完毕。
  137. shutdown(hSocket, SD_SEND);
  139. // 接收缓冲区有可能还有未接收的数据，在关闭套接字之前应该先
  140. // 读取残留的数据。
  141. int iRecvResult;
  142. HANDLE hSocketEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  143. char szBuffer[256];
  144. do
  145. {
  146. if (hSocketEvent != NULL)
  147. {
  148. //注册网络事件
  149. WSAEventSelect(hSocket, (WSAEVENT) hSocketEvent, FD_READ | FD_CLOSE);
  150. WSAWaitForMultipleEvents(1, &hSocketEvent, TRUE,TE_SHUTDOWN_RECV_TIMEOUT, TRUE);
  151. //清除网络事件
  152. WSAEventSelect(hSocket, (WSAEVENT) hSocketEvent, 0);
  153. }
  154. ZeroMemory(szBuffer,256);
  155. iRecvResult = TE_RecvLL(hSocket, szBuffer, sizeof(szBuffer));
  156. } while (iRecvResult > 0);
  158. if (hSocketEvent != NULL)
  159. CloseHandle(hSocketEvent);
  161. //不再允许接收和发送
  162. shutdown(hSocket, SD_BOTH);
  163. }
  165. // 关闭套接字
  166. closesocket(hSocket);
  167. }
  170. // 一次性接收数据(重叠IO)
  171. int TE_RecvLL(SOCKET hSocket, char *pszBuffer, int iBufferSize)
  172. {
  173. DWORD dwRtxBytes = 0,
  174. dwRtxFlags = 0;
  175. WSABUF WSABuff;
  177. //清空缓冲
  178. ZeroMemory(&WSABuff,sizeof(WSABUF));
  180. WSABuff.len = iBufferSize;
  181. WSABuff.buf = pszBuffer;
  183. return ((WSARecv(hSocket, &WSABuff, 1, &dwRtxBytes, &dwRtxFlags,NULL, NULL) == SOCKET_SUCCESS) ? (int) dwRtxBytes : -WSAGetLastError());
  184. }
  186. // 接收数据(阻塞直至收到数据为止)
  187. int TE_RecvData(SOCKET hSocket, char *pszBuffer, int iBufferSize, DWORD dwTimeout)
  188. {
  189. HANDLE hReadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  191. if (hReadEvent == NULL)
  192. {
  193. TE_SetLastError( (int)GetLastError() );
  194. return ( SOCKET_ERROR );
  195. }
  197. int iRecvBytes = 0;
  198. DWORD dwWaitResult ;
  199. for (;;)
  200. {
  201. // 注册FD_READ | FD_CLOSE 事件 
  202. // (因为可能在等待FD_READ事件中，对方关闭套接字，所以要关注FD_CLOSE)
  203. if( WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, FD_READ | FD_CLOSE) == SOCKET_ERROR)
  204. {
  205. CloseHandle(hReadEvent);
  206. TE_SetLastError( WSAGetLastError() );
  207. return (SOCKET_ERROR);
  208. }
  210. // 等等FD_READ | FD_CLOSE事件的发生
  211. dwWaitResult = WSAWaitForMultipleEvents(1, &hReadEvent, TRUE,dwTimeout, TRUE);
  213. if (dwWaitResult != WSA_WAIT_EVENT_0)
  214. {
  215. // 清除事件
  216. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  217. CloseHandle(hReadEvent);
  218. TE_SetLastError( WSAGetLastError() );
  219. return (SOCKET_ERROR);
  220. }
  222. ////////////////////////////////////////////////////////////// 
  223. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  224. /// 进一步检查网络是否发生错误
  225. ///////////////////////////////////////////////////////////////
  226. WSANETWORKEVENTS NetEvent;
  227. if(WSAEnumNetworkEvents(hSocket,(WSAEVENT)hReadEvent,&NetEvent) == SOCKET_ERROR)
  228. {
  229. // 清除事件
  230. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  231. CloseHandle(hReadEvent);
  232. TE_SetLastError( WSAGetLastError() );
  233. return (SOCKET_ERROR);
  234. }
  235. //判断发生了什么事件 FD_READ 或 FD_CLOSE
  236. if( ( NetEvent.lNetworkEvents == FD_CLOSE ) ||
  237.  ( NetEvent.lNetworkEvents == FD_READ && 
  238.    NetEvent.iErrorCode[FD_READ_BIT] !=0 ) ) // 发生错误
  239. {
  240. // 清除事件
  241. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  242. CloseHandle(hReadEvent);
  243. TE_SetLastError(WSAGetLastError() );
  244. return (SOCKET_ERROR);
  245. }
  246. ////////////////////////////////////////////////////////////////
  247. // 清除事件
  248. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  250. // 接收数据
  251. if ((iRecvBytes = TE_RecvLL(hSocket, pszBuffer, iBufferSize)) >= 0)
  252. break; // 跳出循环
  254. int iErrorCode = -iRecvBytes;
  256. if ( iErrorCode != WSAEWOULDBLOCK ) //太多的未完成重叠操作
  257. {
  258. CloseHandle(hReadEvent);
  259. TE_SetLastError( iErrorCode );
  260. return (SOCKET_ERROR);
  261. }
  263. //阻塞住了
  264. ////////////////////////////////////////////////////////////////////////
  265. //  如果发生阻塞,就等待一定时间后重试,以免CPU轮询浪费时间
  266. ////////////////////////////////////////////////////////////////////////
  267. Sleep(TE_BLOCKED_SNDRCV_SLEEP);
  268.     }
  270.     CloseHandle(hReadEvent);
  271.     return (iRecvBytes);
  272. }
  275. // 接收数据直至达到规定的长度(缓冲区满)或超时或没有数据可读取时
  276. int TE_Recv(SOCKET hSocket, char *pszBuffer, int iBufferSize, DWORD dwTimeout)
  277. {
  278. int iRtxBytes = 0;
  279. int iRtxCurrent = 0;
  281. while (iRtxBytes < iBufferSize)
  282. {
  283. iRtxCurrent = TE_RecvData(hSocket, (pszBuffer + iRtxBytes),(iBufferSize - iRtxBytes), dwTimeout);
  285. if (iRtxCurrent < 0) //没有数据可读取
  286. return (iRtxBytes);
  288. iRtxBytes += iRtxCurrent;
  289. }
  291. return (iRtxBytes);
  292. }
  295. //一次性发送数据(重叠IO)
  296. int TE_SendLL(SOCKET hSocket, char const * pszBuffer, int iBufferSize)
  297. {
  298. DWORD dwRtxBytes = 0;
  299. WSABUF WSABuff;
  301. ZeroMemory(&WSABuff,sizeof(WSABUF));
  302. WSABuff.len = iBufferSize;
  303. WSABuff.buf = (char *) pszBuffer;
  305. return ((WSASend(hSocket, &WSABuff, 1, &dwRtxBytes, 0,NULL, NULL) == SOCKET_SUCCESS) ? (int) dwRtxBytes : -WSAGetLastError());
  307. }
  309. // 发送数据
  310. int TE_SendData(SOCKET hSocket, char const * pszBuffer, int iBufferSize, DWORD dwTimeout)
  311. {
  313. HANDLE hWriteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  315. if (hWriteEvent == NULL)
  316. {
  317. TE_SetLastError( (int)GetLastError() );
  318. return (SOCKET_ERROR);
  319. }
  321. int iSendBytes = 0;
  323. for (;;)
  324. {
  325. ////////////////////////////////////////////////////////////////
  326. // 发送数据成功
  327. if ((iSendBytes = TE_SendLL(hSocket, pszBuffer, iBufferSize)) >= 0)
  328. break;
  330. int iErrorCode = -iSendBytes;
  332. if (iErrorCode != WSAEWOULDBLOCK)
  333. {
  334. CloseHandle(hWriteEvent);
  335. TE_SetLastError( WSAGetLastError() );
  336. return (SOCKET_ERROR);
  337. }
  340. ///////////////////////////////////////////////////////////////////////////////
  341. //  睡眠一段时间
  342. ///////////////////////////////////////////////////////////////////////////////
  343. Sleep(TE_BLOCKED_SNDRCV_SLEEP);
  346. // 注册FD_WRITE | FD_CLOSE 事件
  347. if( WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, FD_WRITE|FD_CLOSE) == SOCKET_ERROR)
  348. {
  349. CloseHandle(hWriteEvent);
  350. TE_SetLastError( WSAGetLastError() );
  351. return (SOCKET_ERROR);
  352. }
  354. // 等待事件发生
  355. DWORD dwWaitResult = WSAWaitForMultipleEvents(1, &hWriteEvent, TRUE,dwTimeout, TRUE);
  357. if (dwWaitResult != WSA_WAIT_EVENT_0)
  358. {
  359. // 清除网络事件
  360. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  361. CloseHandle(hWriteEvent);
  362. TE_SetLastError( WSAGetLastError() );
  363. return (SOCKET_ERROR);
  364. }
  366. ////////////////////////////////////////////////////////////// 
  367. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  368. /// 进一步检查网络是否发生错误
  369. ///////////////////////////////////////////////////////////////
  370. WSANETWORKEVENTS NetEvent;
  371. if(WSAEnumNetworkEvents(hSocket,(WSAEVENT)hWriteEvent,&NetEvent) == SOCKET_ERROR)
  372. {
  373.    // 清除网络事件
  374. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  375. CloseHandle(hWriteEvent);
  376. TE_SetLastError( WSAGetLastError() );
  377. return (SOCKET_ERROR);
  378. }
  379. if( ( NetEvent.lNetworkEvents == FD_CLOSE ) ||
  380.  ( NetEvent.lNetworkEvents == FD_WRITE   &&
  381. NetEvent.iErrorCode[FD_WRITE_BIT] !=0 ) ) // 发生错误
  382. {
  383. // 清除网络事件
  384. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  385. CloseHandle(hWriteEvent);
  386. TE_SetLastError( WSAGetLastError() );
  387. return (SOCKET_ERROR);
  388. }
  389. // 清除网络事件
  390. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  391.    }
  393.     CloseHandle(hWriteEvent);
  394.     return (iSendBytes);
  395. }
  397. //发送完所有数据或超时
  398. int TE_Send(SOCKET hSocket, char const * pszBuffer, int iBufferSize, DWORD dwTimeout)
  399. {
  401. int iRtxBytes = 0;
  402. int iRtxCurrent = 0;
  404. while (iRtxBytes < iBufferSize)
  405. {
  406. iRtxCurrent = TE_SendData(hSocket, (pszBuffer + iRtxBytes),(iBufferSize - iRtxBytes), dwTimeout);
  407. if (iRtxCurrent < 0)
  408. return (iRtxBytes);
  410. iRtxBytes += iRtxCurrent;
  411. }
  412. return (iRtxBytes);
  413. }
  415. // 建立连接
  416. int TE_Connect(SOCKET hSocket, const struct sockaddr * pSocketAddress, int iNameLen,DWORD dwTimeout)
  417. {
  419. HANDLE hConnectEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  421. if (hConnectEvent == NULL)
  422. {
  423. TE_SetLastError( (int)GetLastError() );
  424. return (SOCKET_ERROR);
  425. }
  427. // 注册FD_CONNECT事件
  428. if( WSAEventSelect(hSocket, (WSAEVENT) hConnectEvent, FD_CONNECT) == SOCKET_ERROR)
  429. {
  430. CloseHandle(hConnectEvent);
  431. TE_SetLastError( WSAGetLastError() );
  432. return (SOCKET_ERROR);
  433. }
  435. int iConnectResult = WSAConnect(hSocket, pSocketAddress, iNameLen, NULL, NULL, NULL, NULL);
  436. int iConnectError  = WSAGetLastError();
  438. if ((iConnectResult == SOCKET_ERROR) && (iConnectError == WSAEWOULDBLOCK))
  439. {
  440. DWORD dwWaitResult = WSAWaitForMultipleEvents(1, &hConnectEvent, TRUE,dwTimeout, TRUE);
  442. if (dwWaitResult != WSA_WAIT_EVENT_0)
  443. {
  444. TE_SetLastError( WSAGetLastError() );
  445. iConnectResult = SOCKET_ERROR;
  446. }
  447. else
  448. {
  449. ////////////////////////////////////////////////////////////// 
  450. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  451. /// 进一步检查网络是否发生错误
  452. ///////////////////////////////////////////////////////////////
  453. WSANETWORKEVENTS NetEvent;
  454. if(WSAEnumNetworkEvents(hSocket,(WSAEVENT)hConnectEvent,&NetEvent) == SOCKET_ERROR)
  455. {
  456. TE_SetLastError( WSAGetLastError() );
  457. iConnectResult = SOCKET_ERROR;
  458. }
  459. else if(NetEvent.iErrorCode[FD_CONNECT_BIT] !=0 ) // 发生错误
  460. {
  461. TE_SetLastError( NetEvent.iErrorCode[FD_CONNECT_BIT] );
  462. iConnectResult = SOCKET_ERROR;
  463. }
  464. else
  465. iConnectResult = SOCKET_SUCCESS;
  466. ////////////////////////////////////////////////////////////////
  467. }
  468. }
  470. // 注销网络事件
  471. WSAEventSelect(hSocket, (WSAEVENT) hConnectEvent, 0);
  472. CloseHandle(hConnectEvent);
  473. return (iConnectResult);
  474. }
  477. ///////////////////////////////////////////////////////////
  478. //
  479. // 引入该函数的目的是为了避免NT下对域名解析的CACHE造成的问题
  480. //
  481. ///////////////////////////////////////////////////////////
  482. DWORD WINAPI DNSThread(  LPVOID pParam )
  483. {
  484. DWORD dwIP = INADDR_NONE;
  485. PHOSTENT pHost = gethostbyname( (char *)pParam );
  486. if(pHost == NULL)
  487. return INADDR_NONE;
  488. dwIP = inet_addr( inet_ntoa(*(IN_ADDR *)*pHost->h_addr_list) );
  489. return dwIP;
  490. }
  492. DWORD TE_GetIP(const char* name,BOOL fFixNtDNS /* = FALSE*/) // Used to Fix NT DNS Problem
  493. {
  494. DWORD dwIP = inet_addr(name);
  495. if( dwIP != INADDR_NONE )
  496. return dwIP;
  498. if( fFixNtDNS )
  499. {
  500. OSVERSIONINFO osVersion;
  501. osVersion.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
  502. if( GetVersionEx(&osVersion) )
  503. {
  504. if(osVersion.dwPlatformId == VER_PLATFORM_WIN32_NT)
  505. {
  506. DWORD dwThreadId = 0;
  507. HANDLE hThread = CreateThread(NULL,0,DNSThread,(LPVOID)name,0,&dwThreadId);
  508. if( hThread != NULL)
  509. {
  510. WaitForSingleObject(hThread,INFINITE);
  511. if( GetExitCodeThread(hThread,&dwIP))
  512. return dwIP;
  513. }
  514. }
  515. }
  516. }
  518. PHOSTENT pHost = gethostbyname(name);
  519. if(pHost == NULL)
  520. return INADDR_NONE;
  522. dwIP = inet_addr( inet_ntoa(*(IN_ADDR *)*pHost->h_addr_list) );
  523. return dwIP;
  524. }
  526. // 建立连接(扩展函数)
  527. int TE_ConnectEx(SOCKET hSocket, char const * pszServer, int nPort,DWORD dwTimeout,BOOL fFixNtDNS /*= FALSE*/)
  528. {
  529. /////////////////////////////////////////////////////////////////////////////
  530. SOCKADDR_IN sockAddr;
  531. ZeroMemory(&sockAddr,sizeof(sockAddr));
  533. sockAddr.sin_family = AF_INET;
  534. sockAddr.sin_port = htons((u_short)nPort);
  535. sockAddr.sin_addr.s_addr = TE_GetIP(pszServer,fFixNtDNS);
  537. if (sockAddr.sin_addr.s_addr == INADDR_NONE)
  538. {
  539. TE_SetLastError( WSAGetLastError() );
  540. return (SOCKET_ERROR);
  541. }
  542. //////////////////////////////////////////////////////////////////////
  544. return TE_Connect(hSocket, (SOCKADDR *)&sockAddr,sizeof(sockAddr),dwTimeout);
  545. }
  547. // 绑定套接字
  548. int TE_BindSocket(SOCKET hSocket, const struct sockaddr * SockName, int iNameLen)
  549. {
  551. if (bind(hSocket, SockName, iNameLen) == SOCKET_ERROR)
  552. {
  553. TE_SetLastError( WSAGetLastError() );
  554. return (SOCKET_ERROR);
  555. }
  557. return (SOCKET_SUCCESS);
  558. }
  560. // 绑定套接字
  561. int TE_BindSocketEx(SOCKET hSocket,int nPort)
  562. {
  563. SOCKADDR_IN sockAddr;
  564. ZeroMemory(&sockAddr,sizeof(sockAddr));
  566. sockAddr.sin_family = AF_INET;
  567. sockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  568. sockAddr.sin_port = htons((u_short)nPort);
  570. return TE_BindSocket(hSocket,(SOCKADDR *)&sockAddr, sizeof(sockAddr));
  571. }
  574. // 监听套接字
  575. int TE_ListenSocket(SOCKET hSocket, int iConnections)
  576. {
  577. if(listen(hSocket, iConnections) == SOCKET_ERROR)
  578. {
  579. TE_SetLastError( WSAGetLastError() );
  580. return (SOCKET_ERROR);
  581. }
  583. return (SOCKET_SUCCESS);
  584. }
  587. // 接受套接字连接
  588. SOCKET TE_Accept(SOCKET hSocket, struct sockaddr * pSocketAddress, int *iNameLen,DWORD dwTimeout)
  589. {
  591. HANDLE hAcceptEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  592. if (hAcceptEvent == NULL)
  593. {
  594. TE_SetLastError( (int)GetLastError() );
  595. return (INVALID_SOCKET);
  596. }
  598. // 注册FD_ACCEPT事件
  599. if( WSAEventSelect(hSocket, (WSAEVENT) hAcceptEvent, FD_ACCEPT) == SOCKET_ERROR)
  600. {
  601. CloseHandle(hAcceptEvent);
  602. TE_SetLastError( WSAGetLastError() );
  603. return (INVALID_SOCKET);
  604. }
  606. SOCKET hSocketAccept = WSAAccept(hSocket, pSocketAddress, iNameLen, NULL, 0);
  607. int    iConnectError = WSAGetLastError();
  609. if ((hSocketAccept == INVALID_SOCKET) && (iConnectError == WSAEWOULDBLOCK))
  610. {
  612. // 阻塞
  613. DWORD dwWaitResult = WSAWaitForMultipleEvents(1, &hAcceptEvent, TRUE,dwTimeout, TRUE);
  615. if (dwWaitResult == WSA_WAIT_EVENT_0)
  616. {
  617. ////////////////////////////////////////////////////////////// 
  618. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  619. /// 进一步检查网络是否发生错误
  620. ///////////////////////////////////////////////////////////////
  621. WSANETWORKEVENTS NetEvent;
  622. if(WSAEnumNetworkEvents(hSocket,hAcceptEvent,&NetEvent) == SOCKET_ERROR)
  623. TE_SetLastError( WSAGetLastError() );
  624. else if(NetEvent.iErrorCode[FD_ACCEPT_BIT] !=0 ) // 发生错误
  625. TE_SetLastError( NetEvent.iErrorCode[FD_ACCEPT_BIT] );
  626. else
  627. hSocketAccept = WSAAccept(hSocket, pSocketAddress, iNameLen, NULL, 0);
  628. }
  629. else
  630. TE_SetLastError( WSAGetLastError() );
  631. }
  633. // 注销网络事件
  634. WSAEventSelect(hSocket, (WSAEVENT) hAcceptEvent, 0);
  635. CloseHandle(hAcceptEvent);
  637. if (hSocketAccept != INVALID_SOCKET)
  638. {
  639. // 设置套接字的属性为地址可重用并且为非阻塞的
  640. if ( (TE_BlockSocket(hSocketAccept, 0)  == SOCKET_ERROR ) ||
  641. (TE_SetSocketOption(hSocketAccept) == SOCKET_ERROR ) )
  642. {
  643. TE_CloseSocket(hSocketAccept,TRUE);
  644. return (INVALID_SOCKET);
  645. }
  646. }
  647. return (hSocketAccept);
  648. }
  650. // 接受套接字连接(允许中断)
  651. SOCKET TE_AcceptEx(SOCKET hSocket, struct sockaddr * pSockName, int *iNameLen,HANDLE hEndEvent,DWORD dwTimeout /*= TE_DEFAULT_TIMEOUT*/)
  652. {
  653. if( hEndEvent == NULL)
  654. return TE_Accept(hSocket,pSockName,iNameLen,dwTimeout);
  656. HANDLE hAcceptEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  657. if (hAcceptEvent == NULL)
  658. {
  659. TE_SetLastError( (int)GetLastError() );
  660. return (INVALID_SOCKET);
  661. }
  663. WSAEVENT hEvent[2]; 
  664. hEvent[0] = (WSAEVENT)hAcceptEvent;
  665. hEvent[1] = (WSAEVENT)hEndEvent;
  667. // 注册FD_ACCEPT事件
  668. if( WSAEventSelect(hSocket, (WSAEVENT) hAcceptEvent, FD_ACCEPT) == SOCKET_ERROR)
  669. {
  670. CloseHandle(hAcceptEvent);
  671. TE_SetLastError( WSAGetLastError() );
  672. return (INVALID_SOCKET);
  673. }
  675. SOCKET hSocketAccept = WSAAccept(hSocket, pSockName, iNameLen, NULL, 0);
  676. int    iConnectError = WSAGetLastError();
  678. if ((hSocketAccept == INVALID_SOCKET) && (iConnectError == WSAEWOULDBLOCK))
  679. {
  680. // 阻塞
  681. DWORD dwWaitResult = WSAWaitForMultipleEvents(2, hEvent, FALSE,dwTimeout, TRUE);
  682. if (dwWaitResult == WSA_WAIT_EVENT_0)
  683. {
  684. ////////////////////////////////////////////////////////////// 
  685. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  686. /// 进一步检查网络是否发生错误
  687. ///////////////////////////////////////////////////////////////
  688. WSANETWORKEVENTS NetEvent;
  689. if(WSAEnumNetworkEvents(hSocket,hAcceptEvent,&NetEvent) == SOCKET_ERROR)
  690. TE_SetLastError( WSAGetLastError() );
  691. else if(NetEvent.iErrorCode[FD_ACCEPT_BIT] !=0 ) // 发生错误
  692. TE_SetLastError( NetEvent.iErrorCode[FD_ACCEPT_BIT] );
  693. else
  694. hSocketAccept = WSAAccept(hSocket, pSockName, iNameLen, NULL, 0);
  695. }
  696. else
  697. TE_SetLastError( WSAGetLastError() );
  698. }
  700. // 注销网络事件
  701. WSAEventSelect(hSocket, (WSAEVENT) hAcceptEvent, 0);
  702. CloseHandle(hAcceptEvent);
  704. if (hSocketAccept != INVALID_SOCKET)
  705. {
  706. // 设置套接字的属性为地址可重用并且为非阻塞的
  707. if ( (TE_BlockSocket(hSocketAccept, 0) < 0) ||
  708. (TE_SetSocketOption(hSocketAccept) < 0) )
  709. {
  710. TE_CloseSocket(hSocketAccept,TRUE);
  711. return (INVALID_SOCKET);
  713. }
  714. }
  715. return (hSocketAccept);
  717. }
  719. // 设置套接字是否为阻塞的
  720. int      TE_BlockSocket(SOCKET hSocket, BOOL bBlock)
  721. {
  722. u_long  IoctlLong = (bBlock) ? 0 : 1;
  724. if (ioctlsocket(hSocket, FIONBIO, &IoctlLong) == SOCKET_ERROR)
  725. {
  726. TE_SetLastError( WSAGetLastError() );
  727. return (SOCKET_ERROR);
  728.     }
  730. return (SOCKET_SUCCESS);
  732. }
  734. // 数据报接收函数
  735. int TE_RecvDataFrom( SOCKET hSocket, struct sockaddr * pFrom, int iFromlen,
  736.  char *pszBuffer, int iBufferSize, DWORD dwTimeout)
  737. {
  738. HANDLE hReadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  739. if (hReadEvent == NULL)
  740. {
  741. TE_SetLastError((int)GetLastError() );
  742. return (SOCKET_ERROR);
  743. }
  745. DWORD dwRtxBytes = 0,
  746. dwRtxFlags = 0;
  747. WSABUF WSABuff;
  749. ZeroMemory(&WSABuff,sizeof(WSABUF));
  750. WSABuff.len = iBufferSize;
  751. WSABuff.buf = pszBuffer;
  753. for (;;)
  754. {
  755. // 注册FD_READ事件
  756. if( WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, FD_READ) == SOCKET_ERROR)
  757. {
  758. CloseHandle(hReadEvent);
  759. TE_SetLastError(  WSAGetLastError() );
  760. return (SOCKET_ERROR);
  761. }
  762. DWORD dwWaitResult = WSAWaitForMultipleEvents(1, &hReadEvent, TRUE, dwTimeout, TRUE);
  764. if( dwWaitResult != WSA_WAIT_EVENT_0 )
  765. {
  766. // 注销事件
  767. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  768. CloseHandle(hReadEvent);
  769. TE_SetLastError( WSAGetLastError());
  770. return (SOCKET_ERROR);
  771. }
  773. ////////////////////////////////////////////////////////////// 
  774. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  775. /// 进一步检查网络是否发生错误
  776. ///////////////////////////////////////////////////////////////
  777. WSANETWORKEVENTS NetEvent;
  778. if(WSAEnumNetworkEvents(hSocket,(WSAEVENT)hReadEvent,&NetEvent) == SOCKET_ERROR)
  779. {
  780. // 注销事件
  781. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  782. CloseHandle(hReadEvent);
  783. TE_SetLastError( WSAGetLastError() );
  784. return (SOCKET_ERROR);
  785. }
  786. if(NetEvent.iErrorCode[FD_READ_BIT] !=0 ) // 发生错误
  787. {
  788. // 注销事件
  789. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  790. CloseHandle(hReadEvent);
  791. TE_SetLastError(NetEvent.iErrorCode[FD_READ_BIT]);
  792. return (SOCKET_ERROR);
  793. }
  794. ////////////////////////////////////////////////////////////////
  795. // 注销事件
  796. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  798. int FromLen = iFromlen;
  799. if ( WSARecvFrom(hSocket, &WSABuff, 1, &dwRtxBytes, &dwRtxFlags,pFrom, &FromLen, NULL, NULL) == SOCKET_SUCCESS )
  800. break;
  802. if ( WSAGetLastError() != WSAEWOULDBLOCK)
  803. {
  804. CloseHandle(hReadEvent);
  805. TE_SetLastError( WSAGetLastError() );
  806. return (SOCKET_ERROR);
  807. }
  809. ///////////////////////////////////////////////////////////////////////////
  810. // 睡眠一段时间
  811. //////////////////////////////////////////////////////////////////////////
  812. Sleep(TE_BLOCKED_SNDRCV_SLEEP);
  813. }
  814. CloseHandle(hReadEvent);
  815. return ((int) dwRtxBytes);
  816. }
  818. // 数据报发送数据报
  819. int TE_SendDataTo(SOCKET hSocket, const struct sockaddr * pTo,int iToLen,
  820.   char const * pszBuffer, int iBufferSize, DWORD dwTimeout)
  821. {
  822. HANDLE hWriteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  823. if (hWriteEvent == NULL)
  824. {
  825. TE_SetLastError( (int)GetLastError() );
  826. return (SOCKET_ERROR);
  827. }
  829. DWORD dwRtxBytes = 0,
  830.             dwRtxFlags = 0;
  831. WSABUF WSABuff;
  833. ZeroMemory(&WSABuff,sizeof(WSABUF));
  834. WSABuff.len = iBufferSize;
  835. WSABuff.buf = (char *) pszBuffer;
  837. for (;;)
  838. {
  839. if (WSASendTo( hSocket, &WSABuff, 1, &dwRtxBytes, dwRtxFlags,pTo, iToLen, NULL, NULL) == SOCKET_SUCCESS)
  840. break;
  842. if (WSAGetLastError() != WSAEWOULDBLOCK)
  843. {
  844. CloseHandle(hWriteEvent);
  845. TE_SetLastError(  WSAGetLastError() );
  846. return (SOCKET_ERROR);
  847. }
  849. //////////////////////////////////////////////////////////////////////////
  850. // 睡眠一段时间
  851. /////////////////////////////////////////////////////////////////////////
  852. Sleep(TE_BLOCKED_SNDRCV_SLEEP);
  854. // 注册FD_WRITE事件  
  855. if( WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, FD_WRITE) == SOCKET_ERROR)
  856. {
  857. CloseHandle(hWriteEvent);
  858. TE_SetLastError( WSAGetLastError() );
  859. return (SOCKET_ERROR);
  860. }
  861. DWORD dwWaitResult = WSAWaitForMultipleEvents(1, &hWriteEvent, TRUE,dwTimeout, TRUE);
  863. if( dwWaitResult != WSA_WAIT_EVENT_0 )
  864. {
  865. // 注销事件
  866. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  867. CloseHandle(hWriteEvent);
  868. TE_SetLastError(  WSAGetLastError() );
  869. return (SOCKET_ERROR);
  870. }
  872. ////////////////////////////////////////////////////////////// 
  873. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  874. /// 进一步检查网络是否发生错误
  875. ///////////////////////////////////////////////////////////////
  876. WSANETWORKEVENTS NetEvent;
  877. if(WSAEnumNetworkEvents(hSocket,(WSAEVENT)hWriteEvent,&NetEvent) == SOCKET_ERROR)
  878. {
  879. // 注销事件
  880. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  881. CloseHandle(hWriteEvent);
  882. TE_SetLastError(  WSAGetLastError() );
  883. return (SOCKET_ERROR);
  884. }
  885. if(NetEvent.iErrorCode[FD_WRITE_BIT] !=0 ) // 发生错误
  886. {
  887. // 注销事件
  888. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  889. CloseHandle(hWriteEvent);
  890. TE_SetLastError(NetEvent.iErrorCode[FD_WRITE_BIT]);
  891. return (SOCKET_ERROR);
  892. }
  893. ////////////////////////////////////////////////////////////////
  894. // 注销事件
  895. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  896. }
  898. CloseHandle(hWriteEvent);
  899. return ((int) dwRtxBytes);
  900. }
  904. ////////////////////////////////////////////////////////////////////////////////
  905. //
  906. // BSocket函数
  907. //
  908. ////////////////////////////////////////////////////////////////////////////////
  910. ///////////////////////////////////////////////////////////////////////////////
  911. //
  912. // 功能: 绑定套接字
  913. // 参数: 
  914. // hSocket -- SOCKET(待绑定套接字)
  915. // iBufferSize -- 缓冲区长度(缺省为TE_SOCKET_BUFFER_SIZE)
  916. // 返回: 
  917. // 结构指针(失败时为NULL)
  918. //
  919. ////////////////////////////////////////////////////////////////////////////////
  920. PBSD TE_BSocketAttach(SOCKET hSocket, int iBufferSize /* = TE_SOCKET_BUFFER_SIZE */ )
  921. {
  923. if( hSocket == INVALID_SOCKET)
  924. return NULL;
  926. // 分配内存
  927. PBSD pBSD = (PBSD) malloc(sizeof(BSD));
  929. if (pBSD == NULL)
  930. return NULL;
  932. char *pszBuffer = (char *) malloc(iBufferSize);
  934. if (pszBuffer == NULL)
  935. {
  936. free(pBSD);
  937. return NULL;
  938. }
  940. // 设置结构成员
  941. ZeroMemory(pBSD,sizeof(BSD));
  942. ZeroMemory(pszBuffer,iBufferSize);
  944. pBSD->hSocket = hSocket;
  945. pBSD->iBufferSize = iBufferSize;
  946. pBSD->pszBuffer = pszBuffer;
  947. pBSD->iBytesInBuffer = 0;
  948. pBSD->iReadIndex = 0;
  949. pBSD->iBufferIndex = 0;
  951. return pBSD;
  952. }
  954. ////////////////////////////////////////////////////////////////////////////
  955. //
  956. // 功能: 解开套接字
  957. // 参数: 
  958. // pBSD -- BufSocketData结构指针
  959. // bCloseSocket -- 是否在解开套接字同时关闭套接字(缺省为FALSE)
  960. // 返回: 
  961. // 若bCloseSocket为FALSE,返回解开的套接字
  962. // 若bCloseSocket为TRUE ,返回INVALID_SOCKET
  963. //
  964. ///////////////////////////////////////////////////////////////////////////
  965. SOCKET TE_BSocketDetach(PBSD pBSD, BOOL bCloseSocket /* = FALSE */ )
  966. {
  967. SOCKET  hSocket = pBSD->hSocket;
  969. // 释放内存
  970. free(pBSD->pszBuffer);
  971. free(pBSD);
  973. // 是否关闭套接字
  974. if (bCloseSocket)
  975. {
  976. TE_CloseSocket(hSocket);
  977. return (INVALID_SOCKET);
  978. }
  979. return (hSocket);
  980. }
  983. ////////////////////////////////////////////////////////////////////
  984. //
  985. // 功能: 从缓冲区读取数据
  986. // 参数: 
  987. // pBSD  -- BufSocketData结构指针
  988. // dwTimeOut  -- 接收超时(缺省为TE_RECV_TIMEOUT)
  989. // 返回: 
  990. //  0 --- 成功 (SOCKET_SUCCESS)
  991. // -1 --- 失败 (SOCKET_ERROR)
  992. //
  993. ////////////////////////////////////////////////////////////////////
  994. int TE_BSocketReadData(PBSD pBSD, DWORD dwTimeout /* = TE_RECV_TIMEOUT */ )
  995. {
  996. // 计算缓冲区空闲区域
  997. int iMaxRead = pBSD->iBufferSize - pBSD->iBytesInBuffer;
  998. char  *pszBuffer = (char *) malloc(iMaxRead + 1);
  1000. if (pszBuffer == NULL)
  1001. return (SOCKET_ERROR);
  1003. // 清空
  1004. ZeroMemory(pszBuffer,iMaxRead+1);
  1006. // 接收数据
  1007. int iReadedBytes = TE_RecvData(pBSD->hSocket, pszBuffer, iMaxRead, dwTimeout);
  1009. if (iReadedBytes > 0)
  1010. {
  1011. int iHeadSize = Min(pBSD->iBufferSize - pBSD->iBufferIndex, iReadedBytes);
  1013. if (iHeadSize > 0)
  1014. memcpy(pBSD->pszBuffer + pBSD->iBufferIndex, pszBuffer, iHeadSize);
  1016. pBSD->iBufferIndex += iHeadSize;
  1018. if (pBSD->iBufferIndex == pBSD->iBufferSize)
  1019. pBSD->iBufferIndex = 0;
  1021. int iBackSize = iReadedBytes - iHeadSize;
  1023. if (iBackSize > 0)
  1024. memcpy(pBSD->pszBuffer + pBSD->iBufferIndex, pszBuffer + iHeadSize, iBackSize);
  1026. pBSD->iBufferIndex += iBackSize;
  1027. pBSD->iBytesInBuffer += iReadedBytes;
  1028. }
  1030. free(pszBuffer);
  1031. return (iReadedBytes);
  1032. }
  1035. ////////////////////////////////////////////////////////////////////
  1036. //
  1037. // 功能: 从缓冲区读取一个字符
  1038. // 参数: 
  1039. // pBSD  -- BufSocketData结构指针
  1040. // dwTimeOut -- 接收超时(缺省为TE_RECV_TIMEOUT)
  1041. // 返回: 
  1042. // 一个字符(错误时返回TE_EOF)
  1043. //
  1044. ////////////////////////////////////////////////////////////////////
  1045. int TE_BSocketGetChar(PBSD pBSD, DWORD dwTimeout /* = TE_RECV_TIMEOUT */ )
  1046. {
  1047. if ((pBSD->iBytesInBuffer == 0) && (TE_BSocketReadData(pBSD, dwTimeout) <= 0))
  1048. return (TE_EOF);
  1050. int iChar =( (int) pBSD->pszBuffer[pBSD->iReadIndex]) & 0x000000ff;
  1052. pBSD->iReadIndex = INext(pBSD->iReadIndex, pBSD->iBufferSize);
  1054. --pBSD->iBytesInBuffer;
  1056. return (iChar);
  1057. }
  1060. ////////////////////////////////////////////////////////////////////////////
  1061. //
  1062. // 功能: 从缓冲区读取一行(注意，结尾的回车换行0x0D,0x0A并不包括在其中)
  1063. // 参数: 
  1064. // pBSD  -- BufSocketData结构指针
  1065. // pszBuffer  -- 接收缓冲区
  1066. // iBufferSize  -- 缓冲大小
  1067. // iStatus  -- 状态 (0:正常,1:缓冲不够,-1:错误)
  1068. // dwTimeOut  -- 接收超时(缺省为TE_RECV_TIMEOUT)
  1069. // 返回: 
  1070. //  0 --- 成功 (SOCKET_SUCCESS)
  1071. // -1 --- 失败 (SOCKET_ERROR)
  1072. //
  1073. ////////////////////////////////////////////////////////////////////////////
  1074. int TE_BSocketGetString(PBSD pBSD, char *pszBuffer, int iBufferSize, int* iStatus, DWORD dwTimeout /* = TE_RECV_TIMEOUT */ )
  1075. {
  1077. *iStatus = 1; //缓冲长度不足
  1079. int ii,iChar;
  1080. for (ii = 0; ii < (iBufferSize - 1);)
  1081. {
  1082. iChar = TE_BSocketGetChar(pBSD, dwTimeout);
  1083. if (iChar == TE_EOF)
  1084. {
  1085. *iStatus = (-1) ;
  1086. return SOCKET_ERROR;
  1087. }
  1089. if (iChar == 0x0D) // 回车符号
  1090. {
  1091. iChar = TE_BSocketGetChar(pBSD, dwTimeout);
  1092. if (iChar == TE_EOF)
  1093. {
  1094. *iStatus = (-1);
  1095. return (SOCKET_ERROR);
  1096. }
  1098. if (iChar == 0x0A) // 换行
  1099. {
  1100. *iStatus = 0; //正常情况
  1101. break;
  1102. }
  1103. else
  1104. pszBuffer[ii++] = 0x0D;
  1105. }
  1106. else
  1107. pszBuffer[ii++] = (char) iChar;
  1108. }
  1109. pszBuffer[ii] = '';
  1111. return (SOCKET_SUCCESS);
  1112. }
  1114. /////////////////////////////////////////////////////////////////////////////////////////
  1115. //
  1116. // 功能: 从缓冲区读取一行(包括单换行0x0A)(注意，结尾的回车换行不包括在其中)
  1117. // 参数: 
  1118. // pBSD -- BufSocketData结构指针
  1119. // pszBuffer  -- 接收缓冲区
  1120. // iBufferSize  -- 缓冲大小
  1121. // iStatus -- 状态 (0:正常,1:缓冲不够,-1:错误)
  1122. // dwTimeOut -- 接收超时(缺省为TE_RECV_TIMEOUT)
  1123. // 返回: 
  1124. //  0 --- 成功 (SOCKET_SUCCESS)
  1125. // -1 --- 失败 (SOCKET_ERROR)
  1126. //
  1127. //////////////////////////////////////////////////////////////////////////////////////////
  1128. int TE_BSocketGetStringEx(PBSD pBSD, char *pszBuffer, int iBufferSize, int* iStatus, DWORD dwTimeout /* = TE_RECV_TIMEOUT */ )
  1129. {
  1131. *iStatus = 1; //缓冲长度不足
  1133. int ii,iChar;
  1134. int LastChar = TE_EOF;
  1135. for (ii = 0; ii < (iBufferSize - 1);)
  1136. {
  1137. iChar = TE_BSocketGetChar(pBSD, dwTimeout);
  1139. if (iChar == TE_EOF)
  1140. {
  1141. *iStatus = (-1) ;
  1142. return SOCKET_ERROR;
  1143. }
  1145. if (iChar == 0x0A) // 换行符号
  1146. {
  1147. *iStatus = 0; //正常情况
  1148. if (LastChar == 0x0D)
  1149. ii-- ;
  1150. break;
  1151. }
  1152. else
  1153. pszBuffer[ii++] = (char) iChar;
  1155. LastChar = iChar;
  1157. }
  1158. pszBuffer[ii] = '';
  1160. return (SOCKET_SUCCESS);
  1161. }
  1165. ////////////////////////////////////////////////////////////////////
  1166. //
  1167. // 功能: 发送一行 : 自动在最后加上“回车换行符(0x0D,0x0A)”
  1168. // 参数: 
  1169. // pBSD -- BufSocketData结构指针
  1170. // pszBuffer -- 待发送字符串
  1171. // dwTimeOut -- 发送超时(缺省为TE_SEND_TIMEOUT)
  1172. // 返回: 
  1173. //  0 --- 成功 (SOCKET_SUCCESS)
  1174. // -1 --- 失败 (SOCKET_ERROR)
  1175. //
  1176. ////////////////////////////////////////////////////////////////////
  1177. int TE_BSocketSendString(PBSD pBSD, const char *pszBuffer, DWORD dwTimeout /* = TE_SEND_TIMEOUT */ )
  1178. {
  1180. char *pszSendBuffer = (char *) malloc(strlen(pszBuffer) + 3);
  1182. if (pszSendBuffer == NULL)
  1183. return (SOCKET_ERROR);
  1185. ZeroMemory( pszSendBuffer,strlen(pszBuffer) + 3);
  1186. sprintf(pszSendBuffer, "%srn", pszBuffer);
  1188. int iSendLength = strlen(pszSendBuffer);
  1189. if (TE_Send(pBSD->hSocket, pszSendBuffer, iSendLength, dwTimeout) != iSendLength)
  1190. {
  1191.         free(pszSendBuffer);
  1192. return (SOCKET_ERROR);
  1193.     }
  1194. free(pszSendBuffer);
  1195. return (iSendLength);
  1196. }
  1199. ////////////////////////////////////////////////////////////////////
  1200. //
  1201. // 功能: 获取套接字
  1202. // 参数: 
  1203. // pBSD -- BufSocketData结构指针
  1204. // 返回: 
  1205. // 与此结构绑定在一起的SOCKET
  1206. //
  1207. ////////////////////////////////////////////////////////////////////
  1208. SOCKET TE_BSocketGetAttachedSocket(PBSD pBSD)
  1209. {
  1210. return (pBSD->hSocket);
  1211. }
  1213. ////////////////////////////////////////////////////////////////////
  1214. //
  1215. // 功能: 从缓冲区读取一定数量的数据
  1216. // 参数: 
  1217. // pBSD  -- BufSocketData结构指针
  1218. // pszBuffer  -- 接收缓冲区
  1219. // iBufferSize  -- 缓冲大小
  1220. // dwTimeOut  -- 接收超时(缺省为TE_RECV_TIMEOUT)
  1221. // 返回: 
  1222. // 读的数据的字节数
  1223. ////////////////////////////////////////////////////////////////////
  1224. int TE_BSocketGetData(PBSD pBSD, char *pszBuffer, int iBufferSize,DWORD dwTimeout /*= TE_RECV_TIMEOUT*/)
  1225. {
  1226. int iReadBytes  = 0;
  1227. int iHeadSize,iBackSize;
  1229. if ((pBSD->iBytesInBuffer == 0) && (TE_BSocketReadData(pBSD, dwTimeout) <= 0))
  1230. return 0; 
  1232. if( pBSD->iBytesInBuffer < iBufferSize ) // 数据不够多
  1233. {
  1234. iHeadSize = Min( pBSD->iBufferSize - pBSD->iReadIndex ,pBSD->iBytesInBuffer );
  1235. memcpy(pszBuffer+iReadBytes,pBSD->pszBuffer+pBSD->iReadIndex,iHeadSize);
  1237. pBSD->iReadIndex += iHeadSize;
  1238. if( pBSD->iReadIndex == pBSD->iBufferSize )
  1239. pBSD->iReadIndex = 0;
  1241. iReadBytes += iHeadSize;
  1242. iBackSize = pBSD->iBytesInBuffer - iHeadSize;
  1244. if( iBackSize > 0)
  1245. memcpy(pszBuffer+iReadBytes,pBSD->pszBuffer+pBSD->iReadIndex,iBackSize);
  1247. iReadBytes  += iBackSize;
  1248. pBSD->iReadIndex  += iBackSize;
  1249. pBSD->iBytesInBuffer = 0; // 数据全部读完
  1250. }
  1251. else // 这次的数据足够多了
  1252. {
  1253. iHeadSize = Min( pBSD->iBufferSize - pBSD->iReadIndex,iBufferSize - iReadBytes );
  1254. memcpy(pszBuffer+iReadBytes,pBSD->pszBuffer+pBSD->iReadIndex,iHeadSize);
  1256. pBSD->iReadIndex += iHeadSize;
  1257. if( pBSD->iReadIndex == pBSD->iBufferSize )
  1258. pBSD->iReadIndex = 0;
  1260. iReadBytes += iHeadSize;
  1261. iBackSize = iBufferSize - iReadBytes;
  1263. if( iBackSize > 0)
  1264. memcpy(pszBuffer+iReadBytes,pBSD->pszBuffer+pBSD->iReadIndex,iBackSize);
  1266. iReadBytes  += iBackSize;
  1267. pBSD->iReadIndex  += iBackSize;
  1268. pBSD->iBytesInBuffer -= (iHeadSize+iBackSize);
  1269. }
  1270. return iReadBytes;
  1271. }