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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 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 "TE_Socket.h"
  31. //需要ws2_32.lib库
  32. #pragma comment(lib,"ws2_32.lib")
  33.  
  34. //错误代号
  35. static __declspec(thread) int _iThreadedErrorNo = 0;
  37. // 辅助函数
  38. //获取最近一次操作的错误代码
  39. int TE_GetLastError()
  40. {
  41. return (_iThreadedErrorNo);
  42. }
  44. //设置错误代码
  45. void TE_SetLastError(int iErrorCode)
  46. {
  47. _iThreadedErrorNo = iErrorCode;
  48. }
  50. /////////////////////////////////////////////////////////////////////////
  51. // Winsock2 函数
  52. /////////////////////////////////////////////////////////////////////////
  53. //初始化Winsock2动态连接库
  54. int TE_InitLibrary()
  55. {
  56. WSADATA         WSD;
  57. WORD wVersionRequired = MAKEWORD( TE_SOCKET_MAJOR_VERSION,TE_SOCKET_MINOR_VERSION );
  59. ZeroMemory(&WSD,sizeof(WSADATA));
  61. int nErrorNo = WSAStartup(wVersionRequired, &WSD);
  63. if ( SOCKET_SUCCESS != nErrorNo )
  64. {
  65. TE_SetLastError( nErrorNo );
  66. return ( SOCKET_ERROR );
  67. }
  69. if ( LOBYTE( WSD.wVersion ) != TE_SOCKET_MINOR_VERSION ||
  70.  HIBYTE( WSD.wVersion ) != TE_SOCKET_MAJOR_VERSION ) 
  71. {
  72. WSACleanup( );
  73. TE_SetLastError( WSAVERNOTSUPPORTED );
  74. return (SOCKET_ERROR); 
  75. }
  76.  
  77. //成功初始化
  78. return (SOCKET_SUCCESS);
  79. }
  82. //释放Winsock2动态连接库
  83. void TE_CleanupLibrary(void)
  84. {
  85.     WSACleanup();
  86. }
  89. //设置套接字属性
  90. int TE_SetSocketOption(SOCKET hSocket)
  91. {
  93.     int             iActivate = 1;
  95. //允许地址重用
  96.     if (setsockopt(hSocket, SOL_SOCKET, SO_REUSEADDR, (const char *) &iActivate,sizeof(iActivate)) == SOCKET_ERROR )
  97.     {
  98.         TE_SetLastError( WSAGetLastError() );
  99.         return (SOCKET_ERROR);
  100.     }
  102. //  如果支持，设置KEEPALIVE属性 (这样做会带来其他不良后果)
  103. //setsockopt(hSocket, SOL_SOCKET, SO_KEEPALIVE, (const char *) &iActivate,sizeof(iActivate));
  105. return (SOCKET_SUCCESS);
  106. }
  108. //创建具有重叠IO能力的套接字
  109. SOCKET TE_CreateSocket(int iAddressFamily /*= AF_INET*/, int iType/*= SOCK_STREAM*/,int iProtocol/*= 0*/)
  110. {  
  111. // Microsoft Knowledge Base: WSA_FLAG_OVERLAPPED Is Needed for Non-Blocking Sockets
  112. // http://support.microsoft.com/default.aspx?scid=kb;EN-US;179942
  113. SOCKET hSocket = WSASocket(iAddressFamily, iType, iProtocol, NULL,0,WSA_FLAG_OVERLAPPED);
  115. if ( hSocket == INVALID_SOCKET )
  116. {
  117. TE_SetLastError( WSAGetLastError() );
  118. return (INVALID_SOCKET);
  119. }
  121. //设置套接字选项
  122. if ( SOCKET_ERROR == TE_SetSocketOption(hSocket) ) //设置属性失败
  123. {
  124. TE_CloseSocket(hSocket, TRUE);
  125. return (INVALID_SOCKET);
  126. }
  127. return (hSocket);
  128. }
  131. //关闭套接字
  132. void TE_CloseSocket(SOCKET hSocket, BOOL bHardClose)
  133. {
  134. // 不需要捕获错误
  135. if (!bHardClose) // 优雅关闭 Graceful close
  136. {
  137. // 不再发送数据，对于TCP套接字，在所有的数据都发送完毕之后，
  138. // 将发送一个 FIN ，通知接收方所有数据已经发送完毕。
  139. shutdown(hSocket, SD_SEND);
  142. // 接收缓冲区有可能还有未接收的数据，在关闭套接字之前应该先
  143. // 读取残留的数据。
  144. int iRecvResult;
  145. HANDLE hSocketEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  146. char szBuffer[256];
  147. do
  148. {
  149. if (hSocketEvent != NULL)
  150. {
  151. //注册网络事件
  152. WSAEventSelect(hSocket, (WSAEVENT) hSocketEvent, FD_READ | FD_CLOSE);
  153. WSAWaitForMultipleEvents(1, &hSocketEvent, TRUE,TE_SHUTDOWN_RECV_TIMEOUT, TRUE);
  154. //清除网络事件
  155. WSAEventSelect(hSocket, (WSAEVENT) hSocketEvent, 0);
  156. }
  157. ZeroMemory(szBuffer,256);
  158. iRecvResult = TE_RecvLL(hSocket, szBuffer, sizeof(szBuffer));
  159. } while (iRecvResult > 0);
  162. if (hSocketEvent != NULL)
  163. CloseHandle(hSocketEvent);
  165. //不再允许接收和发送
  166. shutdown(hSocket, SD_BOTH);
  167. }
  169. // 关闭套接字
  170. closesocket(hSocket);
  171. }
  174. // 一次性接收数据(重叠IO)
  175. int TE_RecvLL(SOCKET hSocket, char *pszBuffer, int iBufferSize)
  176. {
  177. DWORD dwRtxBytes = 0,
  178. dwRtxFlags = 0;
  179. WSABUF WSABuff;
  181. //清空缓冲
  182. ZeroMemory(&WSABuff,sizeof(WSABUF));
  184. WSABuff.len = iBufferSize;
  185. WSABuff.buf = pszBuffer;
  187. return ((WSARecv(hSocket, &WSABuff, 1, &dwRtxBytes, &dwRtxFlags,NULL, NULL) == SOCKET_SUCCESS) ? (int) dwRtxBytes : -WSAGetLastError());
  188. }
  190. // 接收数据(阻塞直至收到数据为止)
  191. int TE_RecvData(SOCKET hSocket, char *pszBuffer, int iBufferSize, DWORD dwTimeout)
  192. {
  193. HANDLE hReadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  195. if (hReadEvent == NULL)
  196. {
  197. TE_SetLastError( (int)GetLastError() );
  198. return ( SOCKET_ERROR );
  199. }
  201. int iRecvBytes = 0;
  202. DWORD dwWaitResult ;
  203. for (;;)
  204. {
  205. // 注册FD_READ | FD_CLOSE 事件 
  206. // (因为可能在等待FD_READ事件中，对方关闭套接字，所以要关注FD_CLOSE)
  207. if( WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, FD_READ | FD_CLOSE) == SOCKET_ERROR)
  208. {
  209. CloseHandle(hReadEvent);
  210. TE_SetLastError( WSAGetLastError() );
  211. return (SOCKET_ERROR);
  212. }
  214. // 等等FD_READ | FD_CLOSE事件的发生
  215. dwWaitResult = WSAWaitForMultipleEvents(1, &hReadEvent, TRUE,dwTimeout, TRUE);
  217. if (dwWaitResult != WSA_WAIT_EVENT_0)
  218. {
  219. // 清除事件
  220. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  221. CloseHandle(hReadEvent);
  222. TE_SetLastError( WSAGetLastError() );
  223. return (SOCKET_ERROR);
  224. }
  226. ////////////////////////////////////////////////////////////// 
  227. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  228. /// 进一步检查网络是否发生错误
  229. ///////////////////////////////////////////////////////////////
  230. WSANETWORKEVENTS NetEvent;
  231. if(WSAEnumNetworkEvents(hSocket,(WSAEVENT)hReadEvent,&NetEvent) == SOCKET_ERROR)
  232. {
  233. // 清除事件
  234. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  235. CloseHandle(hReadEvent);
  236. TE_SetLastError( WSAGetLastError() );
  237. return (SOCKET_ERROR);
  238. }
  239. //判断发生了什么事件 FD_READ 或 FD_CLOSE
  240. if( ( NetEvent.lNetworkEvents == FD_CLOSE ) ||
  241.  ( NetEvent.lNetworkEvents == FD_READ && 
  242.    NetEvent.iErrorCode[FD_READ_BIT] !=0 ) ) // 发生错误
  243. {
  244. // 清除事件
  245. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  246. CloseHandle(hReadEvent);
  247. TE_SetLastError(WSAGetLastError() );
  248. return (SOCKET_ERROR);
  249. }
  250. ////////////////////////////////////////////////////////////////
  251. // 清除事件
  252. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  254. // 接收数据
  255. if ((iRecvBytes = TE_RecvLL(hSocket, pszBuffer, iBufferSize)) >= 0)
  256. break; // 跳出循环
  258. int iErrorCode = -iRecvBytes;
  260. if ( iErrorCode != WSAEWOULDBLOCK ) //太多的未完成重叠操作
  261. {
  262. CloseHandle(hReadEvent);
  263. TE_SetLastError( iErrorCode );
  264. return (SOCKET_ERROR);
  265. }
  267. //阻塞住了
  268. ////////////////////////////////////////////////////////////////////////
  269. //  如果发生阻塞,就等待一定时间后重试,以免CPU轮询浪费时间
  270. ////////////////////////////////////////////////////////////////////////
  271. Sleep(TE_BLOCKED_SNDRCV_SLEEP);
  272.     }
  274.     CloseHandle(hReadEvent);
  275.     return (iRecvBytes);
  276. }
  279. // 接收数据直至达到规定的长度(缓冲区满)或超时或没有数据可读取时
  280. int TE_Recv(SOCKET hSocket, char *pszBuffer, int iBufferSize, DWORD dwTimeout)
  281. {
  282. int iRtxBytes = 0;
  283. int iRtxCurrent = 0;
  285. while (iRtxBytes < iBufferSize)
  286. {
  287. iRtxCurrent = TE_RecvData(hSocket, (pszBuffer + iRtxBytes),(iBufferSize - iRtxBytes), dwTimeout);
  289. if (iRtxCurrent < 0) //没有数据可读取
  290. return (iRtxBytes);
  292. iRtxBytes += iRtxCurrent;
  293. }
  295. return (iRtxBytes);
  296. }
  299. //一次性发送数据(重叠IO)
  300. int TE_SendLL(SOCKET hSocket, char const * pszBuffer, int iBufferSize)
  301. {
  302. DWORD dwRtxBytes = 0;
  303. WSABUF WSABuff;
  305. ZeroMemory(&WSABuff,sizeof(WSABUF));
  306. WSABuff.len = iBufferSize;
  307. WSABuff.buf = (char *) pszBuffer;
  308.     
  311. return ((WSASend(hSocket, &WSABuff, 1, &dwRtxBytes, 0,NULL, NULL) == SOCKET_SUCCESS) ? (int) dwRtxBytes : -WSAGetLastError());
  313. }
  315. // 发送数据
  316. int TE_SendData(SOCKET hSocket, char const * pszBuffer, int iBufferSize, DWORD dwTimeout)
  317. {
  319. HANDLE hWriteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  321. if (hWriteEvent == NULL)
  322. {
  323. TE_SetLastError( (int)GetLastError() );
  324. return (SOCKET_ERROR);
  325. }
  327. int iSendBytes = 0;
  329. for (;;)
  330. {
  331. ////////////////////////////////////////////////////////////////
  332. // 发送数据成功
  333. if ((iSendBytes = TE_SendLL(hSocket, pszBuffer, iBufferSize)) >= 0)
  334. break;
  336. int iErrorCode = -iSendBytes;
  338. if (iErrorCode != WSAEWOULDBLOCK)
  339. {
  340. CloseHandle(hWriteEvent);
  341. TE_SetLastError( WSAGetLastError() );
  342. return (SOCKET_ERROR);
  343. }
  346. ///////////////////////////////////////////////////////////////////////////////
  347. //  睡眠一段时间
  348. ///////////////////////////////////////////////////////////////////////////////
  349. Sleep(TE_BLOCKED_SNDRCV_SLEEP);
  352. // 注册FD_WRITE | FD_CLOSE 事件
  353. if( WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, FD_WRITE|FD_CLOSE) == SOCKET_ERROR)
  354. {
  355. CloseHandle(hWriteEvent);
  356. TE_SetLastError( WSAGetLastError() );
  357. return (SOCKET_ERROR);
  358. }
  360. // 等待事件发生
  361. DWORD dwWaitResult = WSAWaitForMultipleEvents(1, &hWriteEvent, TRUE,dwTimeout, TRUE);
  363. if (dwWaitResult != WSA_WAIT_EVENT_0)
  364. {
  365. // 清除网络事件
  366. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  367. CloseHandle(hWriteEvent);
  368. TE_SetLastError( WSAGetLastError() );
  369. return (SOCKET_ERROR);
  370. }
  372. ////////////////////////////////////////////////////////////// 
  373. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  374. /// 进一步检查网络是否发生错误
  375. ///////////////////////////////////////////////////////////////
  376. WSANETWORKEVENTS NetEvent;   
  377. if(WSAEnumNetworkEvents(hSocket,(WSAEVENT)hWriteEvent,&NetEvent) == SOCKET_ERROR)
  378. {
  379.    // 清除网络事件
  380. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  381. CloseHandle(hWriteEvent);
  382. TE_SetLastError( WSAGetLastError() );
  383. return (SOCKET_ERROR);
  384. }
  385. if( ( NetEvent.lNetworkEvents == FD_CLOSE ) ||
  386.  ( NetEvent.lNetworkEvents == FD_WRITE   &&
  387. NetEvent.iErrorCode[FD_WRITE_BIT] !=0 ) ) // 发生错误
  388. {
  389. // 清除网络事件
  390. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  391. CloseHandle(hWriteEvent);
  392. TE_SetLastError( WSAGetLastError() );
  393. return (SOCKET_ERROR);
  394. }
  395. // 清除网络事件
  396. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  397.    }
  399.     CloseHandle(hWriteEvent);
  400.     return (iSendBytes);
  401. }
  403. // 如果数据很大的话如实实现
  404. //发送完所有数据或超时
  405. int TE_Send(SOCKET hSocket, char const * pszBuffer, int iBufferSize, DWORD dwTimeout)
  406. {
  408. int iRtxBytes = 0;
  409. int iRtxCurrent = 0;
  411. while (iRtxBytes < iBufferSize)
  412. {
  413. iRtxCurrent = TE_SendData(hSocket, (pszBuffer + iRtxBytes),(iBufferSize - iRtxBytes), dwTimeout);
  414. if (iRtxCurrent < 0)
  415. return (iRtxBytes);
  417. iRtxBytes += iRtxCurrent;
  418. }
  419. return (iRtxBytes);
  420. }
  422. // 建立连接
  423. int TE_Connect(SOCKET hSocket, const struct sockaddr * pSocketAddress, int iNameLen,DWORD dwTimeout)
  424. {
  427. HANDLE hConnectEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  429. if (hConnectEvent == NULL)
  430. {
  431. TE_SetLastError( (int)GetLastError() );
  432. return (SOCKET_ERROR);
  433. }
  435. // 注册FD_CONNECT事件
  436. if( WSAEventSelect(hSocket, (WSAEVENT) hConnectEvent, FD_CONNECT) == SOCKET_ERROR)
  437. {
  438. CloseHandle(hConnectEvent);
  439. TE_SetLastError( WSAGetLastError() );
  440. return (SOCKET_ERROR);
  441. }
  444. int iConnectResult = WSAConnect(hSocket, pSocketAddress, iNameLen, NULL, NULL, NULL, NULL);
  445. int iConnectError  = WSAGetLastError();
  447. if ((iConnectResult == SOCKET_ERROR) && (iConnectError == WSAEWOULDBLOCK))
  448. {
  449. DWORD dwWaitResult = WSAWaitForMultipleEvents(1, &hConnectEvent, TRUE,dwTimeout, TRUE);
  451. if (dwWaitResult != WSA_WAIT_EVENT_0)
  452. {
  453. TE_SetLastError( WSAGetLastError() );
  454. iConnectResult = SOCKET_ERROR;
  455. }
  456. else
  457. {
  458. ////////////////////////////////////////////////////////////// 
  459. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  460. /// 进一步检查网络是否发生错误
  461. ///////////////////////////////////////////////////////////////
  462. WSANETWORKEVENTS NetEvent;
  463. if(WSAEnumNetworkEvents(hSocket,(WSAEVENT)hConnectEvent,&NetEvent) == SOCKET_ERROR)
  464. {
  465. TE_SetLastError( WSAGetLastError() );
  466. iConnectResult = SOCKET_ERROR;
  467. }
  468. else if(NetEvent.iErrorCode[FD_CONNECT_BIT] !=0 ) // 发生错误
  469. {
  470. TE_SetLastError( NetEvent.iErrorCode[FD_CONNECT_BIT] );
  471. iConnectResult = SOCKET_ERROR;
  472. }
  473. else
  474. iConnectResult = SOCKET_SUCCESS;
  475. ////////////////////////////////////////////////////////////////
  476. }
  477. }
  479. // 注销网络事件
  480. WSAEventSelect(hSocket, (WSAEVENT) hConnectEvent, 0);
  481. CloseHandle(hConnectEvent);
  482. return (iConnectResult);
  483. }
  486. ///////////////////////////////////////////////////////////
  487. //
  488. // 引入该函数的目的是为了避免NT下对域名解析的CACHE造成的问题
  489. //
  490. ///////////////////////////////////////////////////////////
  491. DWORD WINAPI DNSThread(  LPVOID pParam )
  492. {
  493. DWORD dwIP = INADDR_NONE;
  494. PHOSTENT pHost = gethostbyname( (char *)pParam );
  495. if(pHost == NULL)
  496. return INADDR_NONE;
  497. dwIP = inet_addr( inet_ntoa(*(IN_ADDR *)*pHost->h_addr_list) );
  498. return dwIP;
  499. }
  501. DWORD TE_GetIP(const char* name,BOOL fFixNtDNS /* = FALSE*/) // Used to Fix NT DNS Problem
  502. {
  503. DWORD dwIP = inet_addr(name);
  504. if( dwIP != INADDR_NONE )
  505. return dwIP;
  507. if( fFixNtDNS )
  508. {
  509. OSVERSIONINFO osVersion;
  510. osVersion.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
  511. if( GetVersionEx(&osVersion) )
  512. {
  513. if(osVersion.dwPlatformId == VER_PLATFORM_WIN32_NT)
  514. {
  515. DWORD dwThreadId = 0;
  516. HANDLE hThread = CreateThread(NULL,0,DNSThread,(LPVOID)name,0,&dwThreadId);
  517. if( hThread != NULL)
  518. {
  519. WaitForSingleObject(hThread,INFINITE);
  520. if( GetExitCodeThread(hThread,&dwIP))
  521. return dwIP;
  522. }
  523. }
  524. }
  525. }
  527. PHOSTENT pHost = gethostbyname(name);
  528. if(pHost == NULL)
  529. return INADDR_NONE;
  531. dwIP = inet_addr( inet_ntoa(*(IN_ADDR *)*pHost->h_addr_list) );
  532. return dwIP;
  533. }
  535. // 建立连接(扩展函数)
  536. int TE_ConnectEx(SOCKET hSocket, char const * pszServer, int nPort,DWORD dwTimeout,BOOL fFixNtDNS /*= FALSE*/)
  537. {
  538. /////////////////////////////////////////////////////////////////////////////
  539. SOCKADDR_IN sockAddr;
  540. ZeroMemory(&sockAddr,sizeof(sockAddr));
  542. sockAddr.sin_family = AF_INET;
  543. sockAddr.sin_port = htons((u_short)nPort);
  544. sockAddr.sin_addr.s_addr = TE_GetIP(pszServer,fFixNtDNS);
  546. if (sockAddr.sin_addr.s_addr == INADDR_NONE)
  547. {
  548. TE_SetLastError( WSAGetLastError() );
  549. return (SOCKET_ERROR);
  550. }
  551. //////////////////////////////////////////////////////////////////////
  553. return TE_Connect(hSocket, (SOCKADDR *)&sockAddr,sizeof(sockAddr),dwTimeout);
  554. }
  556. // 绑定套接字
  557. int TE_BindSocket(SOCKET hSocket, const struct sockaddr * SockName, int iNameLen)
  558. {
  560. if (bind(hSocket, SockName, iNameLen) == SOCKET_ERROR)
  561. {
  562. TE_SetLastError( WSAGetLastError() );
  563. return (SOCKET_ERROR);
  564. }
  566. return (SOCKET_SUCCESS);
  567. }
  569. // 绑定套接字
  570. int TE_BindSocketEx(SOCKET hSocket,int nPort)
  571. {
  572. SOCKADDR_IN sockAddr;
  573. ZeroMemory(&sockAddr,sizeof(sockAddr));
  575. sockAddr.sin_family = AF_INET;
  576. sockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  577. sockAddr.sin_port = htons((u_short)nPort);
  579. return TE_BindSocket(hSocket,(SOCKADDR *)&sockAddr, sizeof(sockAddr));
  580. }
  583. // 监听套接字
  584. int TE_ListenSocket(SOCKET hSocket, int iConnections)
  585. {
  586. if(listen(hSocket, iConnections) == SOCKET_ERROR)
  587. {
  588. TE_SetLastError( WSAGetLastError() );
  589. return (SOCKET_ERROR);
  590. }
  592. return (SOCKET_SUCCESS);
  593. }
  596. // 接受套接字连接
  597. SOCKET TE_Accept(SOCKET hSocket, struct sockaddr * pSocketAddress, int *iNameLen,DWORD dwTimeout)
  598. {
  600. HANDLE hAcceptEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  601. if (hAcceptEvent == NULL)
  602. {
  603. TE_SetLastError( (int)GetLastError() );
  604. return (INVALID_SOCKET);
  605. }
  607. // 注册FD_ACCEPT事件
  608. if( WSAEventSelect(hSocket, (WSAEVENT) hAcceptEvent, FD_ACCEPT) == SOCKET_ERROR)
  609. {
  610. CloseHandle(hAcceptEvent);
  611. TE_SetLastError( WSAGetLastError() );
  612. return (INVALID_SOCKET);
  613. }
  615. SOCKET hSocketAccept = WSAAccept(hSocket, pSocketAddress, iNameLen, NULL, 0);
  616. int    iConnectError = WSAGetLastError();
  618. if ((hSocketAccept == INVALID_SOCKET) && (iConnectError == WSAEWOULDBLOCK))
  619. {
  621. // 阻塞
  622. DWORD dwWaitResult = WSAWaitForMultipleEvents(1, &hAcceptEvent, TRUE,dwTimeout, TRUE);
  624. if (dwWaitResult == WSA_WAIT_EVENT_0)
  625. {
  627. ////////////////////////////////////////////////////////////// 
  628. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  629. /// 进一步检查网络是否发生错误
  630. ///////////////////////////////////////////////////////////////
  631. WSANETWORKEVENTS NetEvent;
  632. if(WSAEnumNetworkEvents(hSocket,hAcceptEvent,&NetEvent) == SOCKET_ERROR)
  633. TE_SetLastError( WSAGetLastError() );
  634. else if(NetEvent.iErrorCode[FD_ACCEPT_BIT] !=0 ) // 发生错误
  635. TE_SetLastError( NetEvent.iErrorCode[FD_ACCEPT_BIT] );
  636. else
  637. hSocketAccept = WSAAccept(hSocket, pSocketAddress, iNameLen, NULL, 0);
  638. }
  639. else
  640. TE_SetLastError( WSAGetLastError() );
  641. }
  643. // 注销网络事件
  644. WSAEventSelect(hSocket, (WSAEVENT) hAcceptEvent, 0);
  645. CloseHandle(hAcceptEvent);
  647. if (hSocketAccept != INVALID_SOCKET)
  648. {
  649. // 设置套接字的属性为地址可重用并且为非阻塞的
  650. if ( (TE_BlockSocket(hSocketAccept, 0)  == SOCKET_ERROR ) ||
  651. (TE_SetSocketOption(hSocketAccept) == SOCKET_ERROR ) )
  652. {
  653. TE_CloseSocket(hSocketAccept,TRUE);
  654. return (INVALID_SOCKET);
  655. }
  656. }
  657. return (hSocketAccept);
  658. }
  660. // 接受套接字连接(允许中断)
  661. SOCKET TE_AcceptEx(SOCKET hSocket, struct sockaddr * pSockName, int *iNameLen,HANDLE hEndEvent,DWORD dwTimeout /*= TE_DEFAULT_TIMEOUT*/)
  662. {
  663. if( hEndEvent == NULL)
  664. return TE_Accept(hSocket,pSockName,iNameLen,dwTimeout);
  666. HANDLE hAcceptEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  667. if (hAcceptEvent == NULL)
  668. {
  669. TE_SetLastError( (int)GetLastError() );
  670. return (INVALID_SOCKET);
  671. }
  673. WSAEVENT hEvent[2]; 
  674. hEvent[0] = (WSAEVENT)hAcceptEvent;
  675. hEvent[1] = (WSAEVENT)hEndEvent;
  677. // 注册FD_ACCEPT事件
  678. if( WSAEventSelect(hSocket, (WSAEVENT) hAcceptEvent, FD_ACCEPT) == SOCKET_ERROR)
  679. {
  680. CloseHandle(hAcceptEvent);
  681. TE_SetLastError( WSAGetLastError() );
  682. return (INVALID_SOCKET);
  683. }
  685. SOCKET hSocketAccept = WSAAccept(hSocket, pSockName, iNameLen, NULL, 0);
  686. int    iConnectError = WSAGetLastError();
  688. if ((hSocketAccept == INVALID_SOCKET) && (iConnectError == WSAEWOULDBLOCK))
  689. {
  690. // 阻塞
  691. DWORD dwWaitResult = WSAWaitForMultipleEvents(2, hEvent, FALSE,dwTimeout, TRUE);
  692. if (dwWaitResult == WSA_WAIT_EVENT_0)
  693. {
  694. ////////////////////////////////////////////////////////////// 
  695. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  696. /// 进一步检查网络是否发生错误
  697. ///////////////////////////////////////////////////////////////
  698. WSANETWORKEVENTS NetEvent;
  699. if(WSAEnumNetworkEvents(hSocket,hAcceptEvent,&NetEvent) == SOCKET_ERROR)
  700. TE_SetLastError( WSAGetLastError() );
  701. else if(NetEvent.iErrorCode[FD_ACCEPT_BIT] !=0 ) // 发生错误
  702. TE_SetLastError( NetEvent.iErrorCode[FD_ACCEPT_BIT] );
  703. else
  704. hSocketAccept = WSAAccept(hSocket, pSockName, iNameLen, NULL, 0);
  705. }
  706. else
  707. TE_SetLastError( WSAGetLastError() );
  708. }
  710. // 注销网络事件
  711. WSAEventSelect(hSocket, (WSAEVENT) hAcceptEvent, 0);
  712. CloseHandle(hAcceptEvent);
  714. if (hSocketAccept != INVALID_SOCKET)
  715. {
  716. // 设置套接字的属性为地址可重用并且为非阻塞的
  717. if ( (TE_BlockSocket(hSocketAccept, 0) < 0) ||
  718. (TE_SetSocketOption(hSocketAccept) < 0) )
  719. {
  720. TE_CloseSocket(hSocketAccept,TRUE);
  721. return (INVALID_SOCKET);
  723. }
  724. }
  725. return (hSocketAccept);
  727. }
  729. // 设置套接字是否为阻塞的
  730. int      TE_BlockSocket(SOCKET hSocket, BOOL bBlock)
  731. {
  732. u_long  IoctlLong = (bBlock) ? 0 : 1;
  734. if (ioctlsocket(hSocket, FIONBIO, &IoctlLong) == SOCKET_ERROR)
  735. {
  736. TE_SetLastError( WSAGetLastError() );
  737. return (SOCKET_ERROR);
  738.     }
  740. return (SOCKET_SUCCESS);
  742. }
  744. // 数据报接收函数
  745. int TE_RecvDataFrom( SOCKET hSocket, struct sockaddr * pFrom, int iFromlen,
  746.  char *pszBuffer, int iBufferSize, DWORD dwTimeout)
  747. {
  748. HANDLE hReadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  749. if (hReadEvent == NULL)
  750. {
  751. TE_SetLastError((int)GetLastError() );
  752. return (SOCKET_ERROR);
  753. }
  755. DWORD dwRtxBytes = 0,
  756. dwRtxFlags = 0;
  757. WSABUF WSABuff;
  759. ZeroMemory(&WSABuff,sizeof(WSABUF));
  760. WSABuff.len = iBufferSize;
  761. WSABuff.buf = pszBuffer;
  763. for (;;)
  764. {
  765. // 注册FD_READ事件
  766. if( WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, FD_READ) == SOCKET_ERROR)
  767. {
  768. CloseHandle(hReadEvent);
  769. TE_SetLastError(  WSAGetLastError() );
  770. return (SOCKET_ERROR);
  771. }
  772. DWORD dwWaitResult = WSAWaitForMultipleEvents(1, &hReadEvent, TRUE, dwTimeout, TRUE);
  774. if( dwWaitResult != WSA_WAIT_EVENT_0 )
  775. {
  776. // 注销事件
  777. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  778. CloseHandle(hReadEvent);
  779. TE_SetLastError( WSAGetLastError());
  780. return (SOCKET_ERROR);
  781. }
  783. ////////////////////////////////////////////////////////////// 
  784. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  785. /// 进一步检查网络是否发生错误
  786. ///////////////////////////////////////////////////////////////
  787. WSANETWORKEVENTS NetEvent;
  788. if(WSAEnumNetworkEvents(hSocket,(WSAEVENT)hReadEvent,&NetEvent) == SOCKET_ERROR)
  789. {
  790. // 注销事件
  791. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  792. CloseHandle(hReadEvent);
  793. TE_SetLastError( WSAGetLastError() );
  794. return (SOCKET_ERROR);
  795. }
  796. if(NetEvent.iErrorCode[FD_READ_BIT] !=0 ) // 发生错误
  797. {
  798. // 注销事件
  799. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  800. CloseHandle(hReadEvent);
  801. TE_SetLastError(NetEvent.iErrorCode[FD_READ_BIT]);
  802. return (SOCKET_ERROR);
  803. }
  804. ////////////////////////////////////////////////////////////////
  805. // 注销事件
  806. WSAEventSelect(hSocket, (WSAEVENT) hReadEvent, 0);
  808. int FromLen = iFromlen;
  809. if ( WSARecvFrom(hSocket, &WSABuff, 1, &dwRtxBytes, &dwRtxFlags,pFrom, &FromLen, NULL, NULL) == SOCKET_SUCCESS )
  810. break;
  812. if ( WSAGetLastError() != WSAEWOULDBLOCK)
  813. {
  814. CloseHandle(hReadEvent);
  815. TE_SetLastError( WSAGetLastError() );
  816. return (SOCKET_ERROR);
  817. }
  819. ///////////////////////////////////////////////////////////////////////////
  820. // 睡眠一段时间
  821. //////////////////////////////////////////////////////////////////////////
  822. Sleep(TE_BLOCKED_SNDRCV_SLEEP);
  823. }
  824. CloseHandle(hReadEvent);
  825. return ((int) dwRtxBytes);
  826. }
  828. // 数据报发送数据报
  829. int TE_SendDataTo(SOCKET hSocket, const struct sockaddr * pTo,int iToLen,
  830.   char const * pszBuffer, int iBufferSize, DWORD dwTimeout)
  831. {
  832. HANDLE hWriteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  833. if (hWriteEvent == NULL)
  834. {
  835. TE_SetLastError( (int)GetLastError() );
  836. return (SOCKET_ERROR);
  837. }
  839. DWORD dwRtxBytes = 0,
  840.             dwRtxFlags = 0;
  841. WSABUF WSABuff;
  843. ZeroMemory(&WSABuff,sizeof(WSABUF));
  844. WSABuff.len = iBufferSize;
  845. WSABuff.buf = (char *) pszBuffer;
  847. for (;;)
  848. {
  849. if (WSASendTo( hSocket, &WSABuff, 1, &dwRtxBytes, dwRtxFlags,pTo, iToLen, NULL, NULL) == SOCKET_SUCCESS)
  850. break;
  852. if (WSAGetLastError() != WSAEWOULDBLOCK)
  853. {
  854. CloseHandle(hWriteEvent);
  855. TE_SetLastError(  WSAGetLastError() );
  856. return (SOCKET_ERROR);
  857. }
  859. //////////////////////////////////////////////////////////////////////////
  860. // 睡眠一段时间
  861. /////////////////////////////////////////////////////////////////////////
  862. Sleep(TE_BLOCKED_SNDRCV_SLEEP);
  864. // 注册FD_WRITE事件  
  865. if( WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, FD_WRITE) == SOCKET_ERROR)
  866. {
  867. CloseHandle(hWriteEvent);
  868. TE_SetLastError( WSAGetLastError() );
  869. return (SOCKET_ERROR);
  870. }
  871. DWORD dwWaitResult = WSAWaitForMultipleEvents(1, &hWriteEvent, TRUE,dwTimeout, TRUE);
  873. if( dwWaitResult != WSA_WAIT_EVENT_0 )
  874. {
  875. // 注销事件
  876. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  877. CloseHandle(hWriteEvent);
  878. TE_SetLastError(  WSAGetLastError() );
  879. return (SOCKET_ERROR);
  880. }
  882. ////////////////////////////////////////////////////////////// 
  883. /// 注意：即使 dwWaitResult == WSA_WAIT_EVENT0 ，也应该 
  884. /// 进一步检查网络是否发生错误
  885. ///////////////////////////////////////////////////////////////
  886. WSANETWORKEVENTS NetEvent;
  887. if(WSAEnumNetworkEvents(hSocket,(WSAEVENT)hWriteEvent,&NetEvent) == SOCKET_ERROR)
  888. {
  889. // 注销事件
  890. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  891. CloseHandle(hWriteEvent);
  892. TE_SetLastError(  WSAGetLastError() );
  893. return (SOCKET_ERROR);
  894. }
  895. if(NetEvent.iErrorCode[FD_WRITE_BIT] !=0 ) // 发生错误
  896. {
  897. // 注销事件
  898. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  899. CloseHandle(hWriteEvent);
  900. TE_SetLastError(NetEvent.iErrorCode[FD_WRITE_BIT]);
  901. return (SOCKET_ERROR);
  902. }
  903. ////////////////////////////////////////////////////////////////
  904. // 注销事件
  905. WSAEventSelect(hSocket, (WSAEVENT) hWriteEvent, 0);
  906. }
  908. CloseHandle(hWriteEvent);
  909. return ((int) dwRtxBytes);
  910. }
  914. ////////////////////////////////////////////////////////////////////////////////
  915. //
  916. // BSocket函数
  917. //
  918. ////////////////////////////////////////////////////////////////////////////////
  920. ///////////////////////////////////////////////////////////////////////////////
  921. //
  922. // 功能: 绑定套接字
  923. // 参数: 
  924. // hSocket -- SOCKET(待绑定套接字)
  925. // iBufferSize -- 缓冲区长度(缺省为TE_SOCKET_BUFFER_SIZE)
  926. // 返回: 
  927. // 结构指针(失败时为NULL)
  928. //
  929. ////////////////////////////////////////////////////////////////////////////////
  930. PBSD TE_BSocketAttach(SOCKET hSocket, int iBufferSize /* = TE_SOCKET_BUFFER_SIZE */ )
  931. {
  933. if( hSocket == INVALID_SOCKET)
  934. return NULL;
  936. // 分配内存
  937. PBSD pBSD = (PBSD) malloc(sizeof(BSD));
  939. if (pBSD == NULL)
  940. return NULL;
  942. char *pszBuffer = (char *) malloc(iBufferSize);
  944. if (pszBuffer == NULL)
  945. {
  946. free(pBSD);
  947. return NULL;
  948. }
  950. // 设置结构成员
  951. ZeroMemory(pBSD,sizeof(BSD));
  952. ZeroMemory(pszBuffer,iBufferSize);
  954. pBSD->hSocket = hSocket;
  955. pBSD->iBufferSize = iBufferSize;
  956. pBSD->pszBuffer = pszBuffer;
  957. pBSD->iBytesInBuffer = 0;
  958. pBSD->iReadIndex = 0;
  959. pBSD->iBufferIndex = 0;
  961. return pBSD;
  962. }
  964. ////////////////////////////////////////////////////////////////////////////
  965. //
  966. // 功能: 解开套接字
  967. // 参数: 
  968. // pBSD -- BufSocketData结构指针
  969. // bCloseSocket -- 是否在解开套接字同时关闭套接字(缺省为FALSE)
  970. // 返回: 
  971. // 若bCloseSocket为FALSE,返回解开的套接字
  972. // 若bCloseSocket为TRUE ,返回INVALID_SOCKET
  973. //
  974. ///////////////////////////////////////////////////////////////////////////
  975. SOCKET TE_BSocketDetach(PBSD pBSD, BOOL bCloseSocket /* = FALSE */ )
  976. {
  977. SOCKET  hSocket = pBSD->hSocket;
  979. // 释放内存
  980. free(pBSD->pszBuffer);
  981. free(pBSD);
  983. // 是否关闭套接字
  984. if (bCloseSocket)
  985. {
  986. TE_CloseSocket(hSocket);
  987. return (INVALID_SOCKET);
  988. }
  989. return (hSocket);
  990. }
  993. ////////////////////////////////////////////////////////////////////
  994. //
  995. // 功能: 从缓冲区读取数据
  996. // 参数: 
  997. // pBSD  -- BufSocketData结构指针
  998. // dwTimeOut  -- 接收超时(缺省为TE_RECV_TIMEOUT)
  999. // 返回: 
  1000. //  0 --- 成功 (SOCKET_SUCCESS)
  1001. // -1 --- 失败 (SOCKET_ERROR)
  1002. //
  1003. ////////////////////////////////////////////////////////////////////
  1004. int TE_BSocketReadData(PBSD pBSD, DWORD dwTimeout /* = TE_RECV_TIMEOUT */ )
  1005. {
  1006. // 计算缓冲区空闲区域
  1007. int iMaxRead = pBSD->iBufferSize - pBSD->iBytesInBuffer;
  1008. char  *pszBuffer = (char *) malloc(iMaxRead + 1);
  1010. if (pszBuffer == NULL)
  1011. return (SOCKET_ERROR);
  1013. // 清空
  1014. ZeroMemory(pszBuffer,iMaxRead+1);
  1016. // 接收数据
  1017. int iReadedBytes = TE_RecvData(pBSD->hSocket, pszBuffer, iMaxRead, dwTimeout);
  1019. if (iReadedBytes > 0)
  1020. {
  1021. int iHeadSize = Min(pBSD->iBufferSize - pBSD->iBufferIndex, iReadedBytes);
  1023. if (iHeadSize > 0)
  1024. memcpy(pBSD->pszBuffer + pBSD->iBufferIndex, pszBuffer, iHeadSize);
  1026. pBSD->iBufferIndex += iHeadSize;
  1028. if (pBSD->iBufferIndex == pBSD->iBufferSize)
  1029. pBSD->iBufferIndex = 0;
  1031. int iBackSize = iReadedBytes - iHeadSize;
  1033. if (iBackSize > 0)
  1034. memcpy(pBSD->pszBuffer + pBSD->iBufferIndex, pszBuffer + iHeadSize, iBackSize);
  1036. pBSD->iBufferIndex += iBackSize;
  1037. pBSD->iBytesInBuffer += iReadedBytes;
  1038. }
  1040. free(pszBuffer);
  1041. return (iReadedBytes);
  1042. }
  1045. ////////////////////////////////////////////////////////////////////
  1046. //
  1047. // 功能: 从缓冲区读取一个字符
  1048. // 参数: 
  1049. // pBSD  -- BufSocketData结构指针
  1050. // dwTimeOut -- 接收超时(缺省为TE_RECV_TIMEOUT)
  1051. // 返回: 
  1052. // 一个字符(错误时返回TE_EOF)
  1053. //
  1054. ////////////////////////////////////////////////////////////////////
  1055. int TE_BSocketGetChar(PBSD pBSD, DWORD dwTimeout /* = TE_RECV_TIMEOUT */ )
  1056. {
  1057. if ((pBSD->iBytesInBuffer == 0) && (TE_BSocketReadData(pBSD, dwTimeout) <= 0))
  1058. return (TE_EOF);
  1060. int iChar =( (int) pBSD->pszBuffer[pBSD->iReadIndex]) & 0x000000ff;
  1062. pBSD->iReadIndex = INext(pBSD->iReadIndex, pBSD->iBufferSize);
  1064. --pBSD->iBytesInBuffer;
  1066. return (iChar);
  1067. }
  1070. ////////////////////////////////////////////////////////////////////////////
  1071. //
  1072. // 功能: 从缓冲区读取一行(注意，结尾的回车换行0x0D,0x0A并不包括在其中)
  1073. // 参数: 
  1074. // pBSD  -- BufSocketData结构指针
  1075. // pszBuffer  -- 接收缓冲区
  1076. // iBufferSize  -- 缓冲大小
  1077. // iStatus  -- 状态 (0:正常,1:缓冲不够,-1:错误)
  1078. // dwTimeOut  -- 接收超时(缺省为TE_RECV_TIMEOUT)
  1079. // 返回: 
  1080. //  0 --- 成功 (SOCKET_SUCCESS)
  1081. // -1 --- 失败 (SOCKET_ERROR)
  1082. //
  1083. ////////////////////////////////////////////////////////////////////////////
  1084. int TE_BSocketGetString(PBSD pBSD, char *pszBuffer, int iBufferSize, int* iStatus, DWORD dwTimeout /* = TE_RECV_TIMEOUT */ )
  1085. {
  1087. *iStatus = 1; //缓冲长度不足
  1089. int ii,iChar;
  1090. for (ii = 0; ii < (iBufferSize - 1);)
  1091. {
  1092. iChar = TE_BSocketGetChar(pBSD, dwTimeout);
  1093. if (iChar == TE_EOF)
  1094. {
  1095. *iStatus = (-1) ;
  1096. return SOCKET_ERROR;
  1097. }
  1099. if (iChar == 0x0D) // 回车符号
  1100. {
  1101. iChar = TE_BSocketGetChar(pBSD, dwTimeout);
  1102. if (iChar == TE_EOF)
  1103. {
  1104. *iStatus = (-1);
  1105. return (SOCKET_ERROR);
  1106. }
  1108. if (iChar == 0x0A) // 换行
  1109. {
  1110. *iStatus = 0; //正常情况
  1111. break;
  1112. }
  1113. else
  1114. pszBuffer[ii++] = 0x0D;
  1115. }
  1116. else
  1117. pszBuffer[ii++] = (char) iChar;
  1118. }
  1119. pszBuffer[ii] = '';
  1121. return (SOCKET_SUCCESS);
  1122. }
  1124. /////////////////////////////////////////////////////////////////////////////////////////
  1125. //
  1126. // 功能: 从缓冲区读取一行(包括单换行0x0A)(注意，结尾的回车换行不包括在其中)
  1127. // 参数: 
  1128. // pBSD -- BufSocketData结构指针
  1129. // pszBuffer  -- 接收缓冲区
  1130. // iBufferSize  -- 缓冲大小
  1131. // iStatus -- 状态 (0:正常,1:缓冲不够,-1:错误)
  1132. // dwTimeOut -- 接收超时(缺省为TE_RECV_TIMEOUT)
  1133. // 返回: 
  1134. //  0 --- 成功 (SOCKET_SUCCESS)
  1135. // -1 --- 失败 (SOCKET_ERROR)
  1136. //
  1137. //////////////////////////////////////////////////////////////////////////////////////////
  1138. int TE_BSocketGetStringEx(PBSD pBSD, char *pszBuffer, int iBufferSize, int* iStatus, DWORD dwTimeout /* = TE_RECV_TIMEOUT */ )
  1139. {
  1141. *iStatus = 1; //缓冲长度不足
  1143. int ii,iChar;
  1144. int LastChar = TE_EOF;
  1145. for (ii = 0; ii < (iBufferSize - 1);)
  1146. {
  1147. iChar = TE_BSocketGetChar(pBSD, dwTimeout);
  1149. if (iChar == TE_EOF)
  1150. {
  1151. *iStatus = (-1) ;
  1152. return SOCKET_ERROR;
  1153. }
  1155. if (iChar == 0x0A) // 换行符号
  1156. {
  1157. *iStatus = 0; //正常情况
  1158. if (LastChar == 0x0D)
  1159. ii-- ;
  1160. break;
  1161. }
  1162. else
  1163. pszBuffer[ii++] = (char) iChar;
  1165. LastChar = iChar;
  1167. }
  1168. pszBuffer[ii] = '';
  1170. return (SOCKET_SUCCESS);
  1171. }
  1175. ////////////////////////////////////////////////////////////////////
  1176. //
  1177. // 功能: 发送一行 : 自动在最后加上“回车换行符(0x0D,0x0A)”
  1178. // 参数: 
  1179. // pBSD -- BufSocketData结构指针
  1180. // pszBuffer -- 待发送字符串
  1181. // dwTimeOut -- 发送超时(缺省为TE_SEND_TIMEOUT)
  1182. // 返回: 
  1183. //  0 --- 成功 (SOCKET_SUCCESS)
  1184. // -1 --- 失败 (SOCKET_ERROR)
  1185. //
  1186. ////////////////////////////////////////////////////////////////////
  1187. int TE_BSocketSendString(PBSD pBSD, const char *pszBuffer, DWORD dwTimeout /* = TE_SEND_TIMEOUT */ )
  1188. {
  1190. char *pszSendBuffer = (char *) malloc(strlen(pszBuffer) + 3);
  1192. if (pszSendBuffer == NULL)
  1193. return (SOCKET_ERROR);
  1195. ZeroMemory( pszSendBuffer,strlen(pszBuffer) + 3);
  1196. sprintf(pszSendBuffer, "%srn", pszBuffer);
  1198. int iSendLength = strlen(pszSendBuffer);
  1199. if (TE_Send(pBSD->hSocket, pszSendBuffer, iSendLength, dwTimeout) != iSendLength)
  1200. {
  1201.         free(pszSendBuffer);
  1202. return (SOCKET_ERROR);
  1203.     }
  1204. free(pszSendBuffer);
  1205. return (iSendLength);
  1206. }
  1209. ////////////////////////////////////////////////////////////////////
  1210. //
  1211. // 功能: 获取套接字
  1212. // 参数: 
  1213. // pBSD -- BufSocketData结构指针
  1214. // 返回: 
  1215. // 与此结构绑定在一起的SOCKET
  1216. //
  1217. ////////////////////////////////////////////////////////////////////
  1218. SOCKET TE_BSocketGetAttachedSocket(PBSD pBSD)
  1219. {
  1220. return (pBSD->hSocket);
  1221. }
  1223. ////////////////////////////////////////////////////////////////////
  1224. //
  1225. // 功能: 从缓冲区读取一定数量的数据
  1226. // 参数: 
  1227. // pBSD  -- BufSocketData结构指针
  1228. // pszBuffer  -- 接收缓冲区
  1229. // iBufferSize  -- 缓冲大小
  1230. // dwTimeOut  -- 接收超时(缺省为TE_RECV_TIMEOUT)
  1231. // 返回: 
  1232. // 读的数据的字节数
  1233. ////////////////////////////////////////////////////////////////////
  1234. int TE_BSocketGetData(PBSD pBSD, char *pszBuffer, int iBufferSize,DWORD dwTimeout /*= TE_RECV_TIMEOUT*/)
  1235. {
  1236. int iReadBytes  = 0;
  1237. int iHeadSize,iBackSize;
  1239. if ((pBSD->iBytesInBuffer == 0) && (TE_BSocketReadData(pBSD, dwTimeout) <= 0))
  1240. return 0; 
  1242. if( pBSD->iBytesInBuffer < iBufferSize ) // 数据不够多
  1243. {
  1244. iHeadSize = Min( pBSD->iBufferSize - pBSD->iReadIndex ,pBSD->iBytesInBuffer );
  1245. memcpy(pszBuffer+iReadBytes,pBSD->pszBuffer+pBSD->iReadIndex,iHeadSize);
  1247. pBSD->iReadIndex += iHeadSize;
  1248. if( pBSD->iReadIndex == pBSD->iBufferSize )
  1249. pBSD->iReadIndex = 0;
  1251. iReadBytes += iHeadSize;
  1252. iBackSize = pBSD->iBytesInBuffer - iHeadSize;
  1254. if( iBackSize > 0)
  1255. memcpy(pszBuffer+iReadBytes,pBSD->pszBuffer+pBSD->iReadIndex,iBackSize);
  1257. iReadBytes  += iBackSize;
  1258. pBSD->iReadIndex  += iBackSize;
  1259. pBSD->iBytesInBuffer = 0; // 数据全部读完
  1260. }
  1261. else // 这次的数据足够多了
  1262. {
  1263. iHeadSize = Min( pBSD->iBufferSize - pBSD->iReadIndex,iBufferSize - iReadBytes );
  1264. memcpy(pszBuffer+iReadBytes,pBSD->pszBuffer+pBSD->iReadIndex,iHeadSize);
  1266. pBSD->iReadIndex += iHeadSize;
  1267. if( pBSD->iReadIndex == pBSD->iBufferSize )
  1268. pBSD->iReadIndex = 0;
  1270. iReadBytes += iHeadSize;
  1271. iBackSize = iBufferSize - iReadBytes;
  1273. if( iBackSize > 0)
  1274. memcpy(pszBuffer+iReadBytes,pBSD->pszBuffer+pBSD->iReadIndex,iBackSize);
  1276. iReadBytes  += iBackSize;
  1277. pBSD->iReadIndex  += iBackSize;
  1278. pBSD->iBytesInBuffer -= (iHeadSize+iBackSize);
  1279. }
  1280. return iReadBytes;
  1281. }