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

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

P2P编程

开发平台：

Visual C++

TCPConnWrapper.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "TCPConnWrapper.h"
  4. #pragma comment (lib, "Ws2_32.lib")
  6. namespace gaov
  7. {
  8. namespace chaos
  9. {
  11. int MySelect(SOCKET sock)
  12. {
  13. int n = (int)sock + 1;
  14. fd_set rfds, wfds;
  15. timeval tv = {10, 0}; // 设置超时时间为10s
  16. int err;
  18. while(true)
  19. {
  20. FD_ZERO(&rfds); //clear ReadSockSet to Zero
  21. FD_ZERO(&wfds); //clear WriteSockSet to Zero
  22. FD_SET(sock, &rfds); //add sock to ReadSockSet
  23. //FD_SET(sock, &wfds); //add sock to WriteSockSet
  25. err = select(n, &rfds, &wfds, NULL, &tv);
  26. switch (err)
  27. {
  28. case 0: // time limit expired
  29. return 0;
  30. case -1:// socket error.
  31. //error("select: %sn", strerror(errno));
  32. return -1;
  33. }
  35. if (FD_ISSET(sock, &rfds))
  36. return 1;
  37. else
  38. return 0;
  39. }
  40. }
  42. ////////////////////////////////
  43. /////////// TCPConn ////////////
  44. ////////////////////////////////
  45. bool TCPConn::InitNetwork()
  46. {
  47. WSADATA WsaData;
  49. if(WSAStartup(MAKEWORD(2, 2), &WsaData) != 0)
  50. return false;
  52. if(LOBYTE(WsaData.wVersion) != 2 || HIBYTE(WsaData.wVersion) != 2){
  53. WSACleanup();
  54. return false;
  55. }
  57. return true;
  58. }
  60. PSTREAM TCPConn::InitData(UINT maxlen)
  61. {
  62. if( !m_bNetworkInited ){
  63. if( !(m_bNetworkInited = InitNetwork()) )
  64. return NULL;
  65. }
  67. if (maxlen > out.size)
  68. {
  69. out.data = (UINT8 *) realloc(out.data, maxlen);
  70. if( ! out.data ) return NULL;
  72. out.size = maxlen;
  73. }
  75. out.p = out.data;
  76. out.end = out.data + out.size;
  77. return &out;
  78. }
  80. /* Send TCP transport data packet */
  81. int TCPConn::Send(PSTREAM s)
  82. {
  83. int length = int(s->end - s->data);
  84. int sent, total = 0;
  86. while (total < length)
  87. {
  88. sent = send(sock, (const char*)(s->data + total), length - total, 0);
  89. if (sent < 0) // socket error
  90. {
  91. closesocket(sock);
  92. return -1;
  93. }
  95. total += sent;
  96. }
  98. return 1;
  99. }
  101. /* Receive a message on the TCP layer */
  102. PSTREAM TCPConn::Recv(PSTREAM s, UINT length)
  103. {
  104. unsigned int new_length, end_offset, p_offset;
  105. int rcvd = 0;
  106. int err;
  108. if (s == NULL) /* read into "new" stream */
  109. {
  110. if (length > in.size)
  111. {
  112. in.data = (UINT8 *) realloc(in.data, length);
  113. if( ! in.data ) return NULL;
  115. in.size = length;
  116. }
  117. in.end = in.p = in.data;
  118. s = &in;
  119. }
  120. else /* append to existing stream */
  121. {
  122. new_length = int(s->end - s->data) + length;
  123. if (new_length > s->size)
  124. {
  125. p_offset = int(s->p - s->data);
  126. end_offset = int(s->end - s->data);
  127. s->data = (UINT8 *) realloc(s->data, new_length);
  128. if( ! s->data ) return NULL;
  130. s->size = new_length;
  131. s->p = s->data + p_offset;
  132. s->end = s->data + end_offset;
  133. }
  134. }
  136. while (length > 0)
  137. {
  138. err = MySelect(sock);
  139. if (err > 0)
  140. {
  141. rcvd = recv(sock, (char*)(s->end), length, 0);
  142. if (rcvd > 0)
  143. {
  144. s->end += rcvd;
  145. length -= rcvd;
  146. }
  147. else if(rcvd < 0) // socket error
  148. {
  149. closesocket(sock);
  150. sock = INVALID_SOCKET;
  151. return NULL;
  152. }
  153. else // Connection closed.
  154. return NULL;
  155. }
  156. else if( err < 0 ) // socket error
  157. {
  158. closesocket(sock);
  159. sock = INVALID_SOCKET;
  160. return NULL;
  161. }
  162. else
  163. return NULL;
  164. }
  166. return s;
  167. }
  169. ////////////////////////////////////////////////////
  170. /////////////////// TCPClient //////////////////////
  171. ////////////////////////////////////////////////////
  172. bool TCPClient::SendEx(UINT8 msgType, UINT8 subMsgType, PBYTE data, UINT dataLen)
  173. {
  174. PSTREAM s = InitData( dataLen + 6 );
  175. if( !s )
  176. return false;
  178. // Header: 6 bytes
  179. out_uint8(s, msgType);
  180. out_uint8(s, subMsgType);
  181. out_uint32_be(s, dataLen);
  182. // Data
  183. if( dataLen>0 && data ) 
  184. out_uint8p(s, data, dataLen);
  185. s_mark_end(s);
  186. if( Send(s) <= 0 )
  187. return false;
  189. return true;
  190. }
  192. bool TCPClient::SendEx2(UINT8 msgType, UINT8 subMsgType, PBYTE data1, UINT dataLen1, PBYTE data2, UINT dataLen2)
  193. {
  194. UINT dataLen = dataLen1 + dataLen2;
  195. PSTREAM s = InitData( dataLen + 4*2 + 6 );
  196. if( !s )
  197. return false;
  199. // Header: 6 bytes
  200. out_uint8(s, msgType);
  201. out_uint8(s, subMsgType);
  202. out_uint32_be(s, dataLen); // dataLen = dataLen1 + dataLen2
  204. if( dataLen > 0 )
  205. {
  206. // Data1
  207. out_uint32_be(s, dataLen1);
  208. if(dataLen1>0 && data1) 
  209. out_uint8p(s, data1, dataLen1);
  211. // Data2
  212. out_uint32_be(s, dataLen2);
  213. if(dataLen2>0 && data2) 
  214. out_uint8p(s, data2, dataLen2);
  215. }
  217. s_mark_end(s);
  219. if( Send(s) <= 0 )
  220. return false;
  222. return true;
  223. }
  225. bool TCPClient::RecvEx(UINT8& msgType, UINT8& subMsgType, PBYTE& data, UINT& dataLen, const bool bRecvData/*=true*/)
  226. {
  227. PSTREAM s = Recv(NULL, 6);
  228. if( ! s )
  229. return false;
  231. in_uint8(s, msgType);
  232. in_uint8(s, subMsgType);
  233. in_uint32_be(s, dataLen);
  235. if( dataLen>0 && bRecvData )
  236. {
  237. s = Recv(s, dataLen);
  238. if( ! s )
  239. return false;
  241. in_uint8p(s, data, dataLen);
  242. }
  244. return true;
  245. }
  247. bool TCPClient::RecvEx2(UINT8& msgType, UINT8& subMsgType, PBYTE& data1, UINT& dataLen1, 
  248. PBYTE& data2, UINT& dataLen2, const bool bRecvData/*=true*/ )
  249. {
  250. PSTREAM s = Recv(NULL, 6);
  251. if( ! s ) 
  252. return false;
  254. in_uint8(s, msgType);
  255. in_uint8(s, subMsgType);
  256. UINT totalLen;
  257. in_uint32_be(s, totalLen);  // totalLen: dataLen1 + dataLen2
  259. if( totalLen > 0 )
  260. {
  261. s = Recv(s, totalLen + 4*2);
  262. if( ! s )
  263. return false;
  265. // Data1
  266. in_uint32_be(s, dataLen1);
  267. if(dataLen1>0 && bRecvData) 
  268. in_uint8p(s, data1, dataLen1);
  270. // Data2
  271. in_uint32_be(s, dataLen2);
  272. if(dataLen2>0 && bRecvData) 
  273. in_uint8p(s, data2, dataLen2);
  274. }
  276. return true;
  277. }
  279. /* Establish a connection on the TCP layer */
  280. // -3 : init network failed
  281. // -2 : connection exists; 
  282. // -1 : sock error
  283. // 0 : mem error
  284. // 1 : success
  285. int TCPClient::Connect(const char* sIP, USHORT port)
  286. {
  287. if( !m_bNetworkInited ){
  288. if( !(m_bNetworkInited = InitNetwork()) )
  289. return -3;
  290. }
  292. if( sock!=INVALID_SOCKET ) // exists
  293. return -2;
  295. if ( (sock = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET ){
  296. int lastErr = WSAGetLastError();
  297. //error("socket: %sn", strerror(errno));
  298. return -1;
  299. }
  301. sockaddr_in addr;
  302. memset(&addr, 0, sizeof(addr));
  304. addr.sin_family = AF_INET;
  305. addr.sin_addr.s_addr = inet_addr(sIP);
  306. addr.sin_port = htons(port);
  308. if (connect(sock, (struct sockaddr *) &addr, sizeof(struct sockaddr)) < 0){
  309. //error("connect: %sn", strerror(errno));
  310. int lastErr = WSAGetLastError();
  311. closesocket(sock);
  312. sock = INVALID_SOCKET;
  313. return -1;
  314. }
  316. int true_value = 1;
  317. setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (const char *) &true_value, sizeof(true_value));
  319. in.size = 4096;
  320. in.data = (UINT8 *) malloc(in.size);
  321. if( ! in.data ) return 0;
  323. out.size = 4096;
  324. out.data = (UINT8 *) malloc(out.size);
  325. if( ! out.data ) return 0;
  327. return 1;
  328. }
  331. ////////////////////////////////////////////////////
  332. /////////////////// TCPServer //////////////////////
  333. ////////////////////////////////////////////////////
  335. bool TCPServer::Listen(const char* sIP, USHORT port)
  336. {
  337. if( !m_bNetworkInited ){
  338. if( !(m_bNetworkInited = InitNetwork()) )
  339. return false;
  340. }
  342. // already exists
  343. if( sock!=INVALID_SOCKET )
  344. return false;
  346. sock = socket(AF_INET, SOCK_STREAM, 0);
  347. if( INVALID_SOCKET==sock )
  348. return false;
  350. struct sockaddr_in addr;
  351. int addrLen = sizeof(addr);
  352. memset(&addr, 0, addrLen);
  354. addr.sin_family = AF_INET;
  355. addr.sin_addr.s_addr = inet_addr(sIP);
  356. addr.sin_port = htons(port);
  358. if( bind(sock, (sockaddr *)&addr, addrLen) == SOCKET_ERROR )
  359. return false;
  361. if( listen(sock, 5) == SOCKET_ERROR )
  362. return false;
  364. return true;
  365. }
  367. SOCKET TCPServer::Accept()
  368. {
  369. if( !m_bNetworkInited || sock==INVALID_SOCKET )
  370. return INVALID_SOCKET;
  372. return accept( sock, NULL, NULL );
  373. }
  375. };
  376. };