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

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

P2P编程

开发平台：

Visual C++

TCPConnWrapper.cpp：源码内容
  1. /*
  2.  *  Openmysee
  3.  *
  4.  *  This program is free software; you can redistribute it and/or modify
  5.  *  it under the terms of the GNU General Public License as published by
  6.  *  the Free Software Foundation; either version 2 of the License, or
  7.  *  (at your option) any later version.
  8.  *
  9.  *  This program is distributed in the hope that it will be useful,
  10.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  *  GNU General Public License for more details.
  13.  *
  14.  *  You should have received a copy of the GNU General Public License
  15.  *  along with this program; if not, write to the Free Software
  16.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17.  *
  18.  */
  19. #include "stdafx.h"
  20. #include "TCPConnWrapper.h"
  22. #pragma comment (lib, "Ws2_32.lib")
  24. namespace gaov
  25. {
  26. namespace chaos
  27. {
  29. int MySelect(SOCKET sock)
  30. {
  31. int n = (int)sock + 1;
  32. fd_set rfds, wfds;
  33. timeval tv = {10, 0}; // 设置超时时间为10s
  34. int err;
  36. while(true)
  37. {
  38. FD_ZERO(&rfds); //clear ReadSockSet to Zero
  39. FD_ZERO(&wfds); //clear WriteSockSet to Zero
  40. FD_SET(sock, &rfds); //add sock to ReadSockSet
  41. //FD_SET(sock, &wfds); //add sock to WriteSockSet
  43. err = select(n, &rfds, &wfds, NULL, &tv);
  44. switch (err)
  45. {
  46. case 0: // time limit expired
  47. return 0;
  48. case -1:// socket error.
  49. //error("select: %sn", strerror(errno));
  50. return -1;
  51. }
  53. if (FD_ISSET(sock, &rfds))
  54. return 1;
  55. else
  56. return -1;
  57. }
  58. }
  60. ////////////////////////////////
  61. /////////// TCPConn ////////////
  62. ////////////////////////////////
  63. bool TCPConn::InitNetwork()
  64. {
  65. WSADATA WsaData;
  67. if(WSAStartup(MAKEWORD(2, 2), &WsaData) != 0)
  68. return false;
  70. if(LOBYTE(WsaData.wVersion) != 2 || HIBYTE(WsaData.wVersion) != 2){
  71. WSACleanup();
  72. return false;
  73. }
  75. return true;
  76. }
  78. PSTREAM TCPConn::InitData(UINT maxlen)
  79. {
  80. if( !m_bNetworkInited ){
  81. if( !(m_bNetworkInited = InitNetwork()) )
  82. return NULL;
  83. }
  85. if (maxlen > out.size)
  86. {
  87. out.data = (UINT8 *) realloc(out.data, maxlen);
  88. if( ! out.data ) return NULL;
  90. out.size = maxlen;
  91. }
  93. out.p = out.data;
  94. out.end = out.data + out.size;
  95. return &out;
  96. }
  98. /* Send TCP transport data packet */
  99. int TCPConn::Send(PSTREAM s)
  100. {
  101. int length = int(s->end - s->data);
  102. int sent, total = 0;
  104. while (total < length)
  105. {
  106. sent = send(sock, (const char*)(s->data + total), length - total, 0);
  107. if (sent < 0) // socket error
  108. {
  109. closesocket(sock);
  110. return -1;
  111. }
  113. total += sent;
  114. }
  116. return 1;
  117. }
  119. /* Receive a message on the TCP layer */
  120. PSTREAM TCPConn::Recv(PSTREAM s, UINT length)
  121. {
  122. unsigned int new_length, end_offset, p_offset;
  123. int rcvd = 0;
  124. int err;
  126. if (s == NULL) /* read into "new" stream */
  127. {
  128. if (length > in.size)
  129. {
  130. in.data = (UINT8 *) realloc(in.data, length);
  131. if( ! in.data ) return NULL;
  133. in.size = length;
  134. }
  135. in.end = in.p = in.data;
  136. s = &in;
  137. }
  138. else /* append to existing stream */
  139. {
  140. new_length = int(s->end - s->data) + length;
  141. if (new_length > s->size)
  142. {
  143. p_offset = int(s->p - s->data);
  144. end_offset = int(s->end - s->data);
  145. s->data = (UINT8 *) realloc(s->data, new_length);
  146. if( ! s->data ) return NULL;
  148. s->size = new_length;
  149. s->p = s->data + p_offset;
  150. s->end = s->data + end_offset;
  151. }
  152. }
  154. while (length > 0)
  155. {
  156. err = MySelect(sock);
  157. if (err > 0)
  158. {
  159. rcvd = recv(sock, (char*)(s->end), length, 0);
  160. if (rcvd > 0)
  161. {
  162. s->end += rcvd;
  163. length -= rcvd;
  164. }
  165. else if(rcvd < 0) // socket error
  166. {
  167. closesocket(sock);
  168. sock = INVALID_SOCKET;
  169. return NULL;
  170. }
  171. else // Connection closed.
  172. return NULL;
  173. }
  174. else if( err < 0 ) // socket error
  175. {
  176. closesocket(sock);
  177. sock = INVALID_SOCKET;
  178. return NULL;
  179. }
  180. // else 超时继续等待
  181. // return NULL;
  182. }
  184. return s;
  185. }
  187. ////////////////////////////////////////////////////
  188. /////////////////// TCPClient //////////////////////
  189. ////////////////////////////////////////////////////
  190. bool TCPClient::SendEx(UINT8 msgType, UINT8 subMsgType, PBYTE data, UINT dataLen)
  191. {
  192. PSTREAM s = InitData( dataLen + 6 );
  193. if( !s )
  194. return false;
  196. // Header: 6 bytes
  197. out_uint8(s, msgType);
  198. out_uint8(s, subMsgType);
  199. out_uint32_be(s, dataLen);
  200. // Data
  201. if( dataLen>0 && data ) 
  202. out_uint8p(s, data, dataLen);
  203. s_mark_end(s);
  204. if( Send(s) <= 0 )
  205. return false;
  207. return true;
  208. }
  210. bool TCPClient::SendEx2(UINT8 msgType, UINT8 subMsgType, PBYTE data1, UINT dataLen1, PBYTE data2, UINT dataLen2)
  211. {
  212. UINT dataLen = dataLen1 + dataLen2;
  213. PSTREAM s = InitData( dataLen + 4*2 + 6 );
  214. if( !s )
  215. return false;
  217. // Header: 6 bytes
  218. out_uint8(s, msgType);
  219. out_uint8(s, subMsgType);
  220. out_uint32_be(s, dataLen); // dataLen = dataLen1 + dataLen2
  222. if( dataLen > 0 )
  223. {
  224. // Data1
  225. out_uint32_be(s, dataLen1);
  226. if(dataLen1>0 && data1) 
  227. out_uint8p(s, data1, dataLen1);
  229. // Data2
  230. out_uint32_be(s, dataLen2);
  231. if(dataLen2>0 && data2) 
  232. out_uint8p(s, data2, dataLen2);
  233. }
  235. s_mark_end(s);
  237. if( Send(s) <= 0 )
  238. return false;
  240. return true;
  241. }
  243. bool TCPClient::RecvEx(UINT8& msgType, UINT8& subMsgType, PBYTE& data, UINT& dataLen, const bool bRecvData/*=true*/)
  244. {
  245. PSTREAM s = Recv(NULL, 6);
  246. if( ! s )
  247. return false;
  249. in_uint8(s, msgType);
  250. in_uint8(s, subMsgType);
  251. in_uint32_be(s, dataLen);
  253. if( dataLen>0 && bRecvData )
  254. {
  255. s = Recv(s, dataLen);
  256. if( ! s )
  257. return false;
  259. in_uint8p(s, data, dataLen);
  260. }
  262. return true;
  263. }
  265. bool TCPClient::RecvEx2(UINT8& msgType, UINT8& subMsgType, PBYTE& data1, UINT& dataLen1, 
  266. PBYTE& data2, UINT& dataLen2, const bool bRecvData/*=true*/ )
  267. {
  268. PSTREAM s = Recv(NULL, 6);
  269. if( ! s ) 
  270. return false;
  272. in_uint8(s, msgType);
  273. in_uint8(s, subMsgType);
  274. UINT totalLen;
  275. in_uint32_be(s, totalLen);  // totalLen: dataLen1 + dataLen2
  277. if( totalLen > 0 )
  278. {
  279. s = Recv(s, totalLen + 4*2);
  280. if( ! s )
  281. return false;
  283. // Data1
  284. in_uint32_be(s, dataLen1);
  285. if(dataLen1>0 && bRecvData) 
  286. in_uint8p(s, data1, dataLen1);
  288. // Data2
  289. in_uint32_be(s, dataLen2);
  290. if(dataLen2>0 && bRecvData) 
  291. in_uint8p(s, data2, dataLen2);
  292. }
  294. return true;
  295. }
  297. /* Establish a connection on the TCP layer */
  298. // -3 : init network failed
  299. // -2 : connection exists;
  300. // -1 : sock error
  301. // 0 : mem error
  302. // 1 : success
  303. int TCPClient::Connect(const char* sIP, USHORT port)
  304. {
  305. if( !m_bNetworkInited ){
  306. if( !(m_bNetworkInited = InitNetwork()) )
  307. return -3;
  308. }
  310. if( sock!=INVALID_SOCKET ) // exists
  311. return -2;
  313. if ( (sock = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET ){
  314. int lastErr = WSAGetLastError();
  315. //error("socket: %sn", strerror(errno));
  316. return -1;
  317. }
  319. sockaddr_in addr;
  320. memset(&addr, 0, sizeof(addr));
  322. addr.sin_family = AF_INET;
  323. addr.sin_addr.s_addr = inet_addr(sIP);
  324. addr.sin_port = htons(port);
  326. if (connect(sock, (struct sockaddr *) &addr, sizeof(struct sockaddr)) < 0){
  327. //error("connect: %sn", strerror(errno));
  328. int lastErr = WSAGetLastError();
  329. closesocket(sock);
  330. sock = INVALID_SOCKET;
  331. return -1;
  332. }
  334. int true_value = 1;
  335. setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (const char *) &true_value, sizeof(true_value));
  337. in.size = 4096;
  338. in.data = (UINT8 *) malloc(in.size);
  339. if( ! in.data ) return 0;
  341. out.size = 4096;
  342. out.data = (UINT8 *) malloc(out.size);
  343. if( ! out.data ) return 0;
  345. return 1;
  346. }
  349. ////////////////////////////////////////////////////
  350. /////////////////// TCPServer //////////////////////
  351. ////////////////////////////////////////////////////
  353. bool TCPServer::Listen(const char* sIP, USHORT port)
  354. {
  355. if( !m_bNetworkInited ){
  356. if( !(m_bNetworkInited = InitNetwork()) )
  357. return false;
  358. }
  360. // already exists
  361. if( sock!=INVALID_SOCKET )
  362. return false;
  364. sock = socket(AF_INET, SOCK_STREAM, 0);
  365. if( INVALID_SOCKET==sock )
  366. return false;
  368. struct sockaddr_in addr;
  369. int addrLen = sizeof(addr);
  370. memset(&addr, 0, addrLen);
  372. addr.sin_family = AF_INET;
  373. addr.sin_addr.s_addr = inet_addr(sIP);
  374. addr.sin_port = htons(port);
  376. if( bind(sock, (sockaddr *)&addr, addrLen) == SOCKET_ERROR )
  377. return false;
  379. if( listen(sock, 5) == SOCKET_ERROR )
  380. return false;
  382. return true;
  383. }
  385. SOCKET TCPServer::Accept()
  386. {
  387. if( !m_bNetworkInited || sock==INVALID_SOCKET )
  388. return INVALID_SOCKET;
  390. return accept( sock, NULL, NULL );
  391. }
  393. };
  394. };