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

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

游戏

开发平台：

Visual C++

ServerSocket.cpp：源码内容
  1. #include "StdAfx.h"
  2. #include "serversocket.h"
  3. #include "process.h"
  5. #define DATA_BUFSIZE 4096
  8. // 监听线程
  9. UINT ServerListenThread(LPVOID lParam)
  10. {
  11. LOGMESSAGE("服务器端监听中.....n");
  13. CServerSocket* pServer = (CServerSocket*)lParam;
  15. SOCKADDR_IN ClientAddr;                   // 定义一个客户端得地址结构作为参数
  16. int addr_length=sizeof(ClientAddr);
  18. while(TRUE)
  19. {
  20. if(pServer->dwEventTotal>=WSA_MAXIMUM_WAIT_EVENTS)  // 因为超出了Windows的最大等待事件数量
  21. {
  22. LOGMESSAGE("已达到最大连接数！");
  23. continue;
  24. }
  26. SOCKET sockTemp = WSAAccept(pServer->sockListen,(SOCKADDR*)&ClientAddr,&addr_length, NULL, 0); 
  27. if(sockTemp  == INVALID_SOCKET)
  28. {
  29. LOGMESSAGE("Accept Connection failed！");
  30. continue;
  31. }
  33. pServer->nSockIndex = pServer->GetEmptySocket();    // 从Socket数组中获得一个空闲的socket
  34. pServer->sockAcceptArray[pServer->nSockIndex] = sockTemp;
  36. // 这里可以取得客户端的IP和端口，但是我们只取其中的SOCKET编号
  37. LPCTSTR lpIP =  inet_ntoa(ClientAddr.sin_addr);
  38. UINT nPort = ClientAddr.sin_port;
  39. char strSock[80];
  40. sprintf(strSock,"New Client,SOCKET编号:%drn",pServer->sockAcceptArray[pServer->nSockIndex] );
  41. LOGMESSAGE(strSock);
  44. // 接收客户端连接以后，为每一个连入的SOCKET都初始化建立一个重叠结构
  45. pServer->Flags = 0;
  46. pServer->EventArray[pServer->nSockIndex] = WSACreateEvent();
  48. ZeroMemory(&pServer->AcceptOverlapped[pServer->nSockIndex],sizeof(WSAOVERLAPPED));
  50. char buffer[DATA_BUFSIZE];
  51. ZeroMemory(buffer,DATA_BUFSIZE);
  53. pServer->AcceptOverlapped[pServer->nSockIndex].hEvent = pServer->EventArray[pServer->nSockIndex]; // 关联事件
  55. pServer->DataBuf[pServer->nSockIndex].len = DATA_BUFSIZE;
  56. pServer->DataBuf[pServer->nSockIndex].buf = buffer;
  60. // 投递第一个WSARecv请求，以便开始在套接字上接受数据
  61. if(WSARecv(pServer->sockAcceptArray[pServer->nSockIndex] ,&pServer->DataBuf[pServer->nSockIndex],1,&pServer->dwRecvBytes,&pServer->Flags,
  62. & pServer->AcceptOverlapped[pServer->nSockIndex] ,NULL) == SOCKET_ERROR)
  63. {
  64. if(WSAGetLastError() != WSA_IO_PENDING)    
  65. {
  66. // 返回WSA_IO_PENDING是正常情况，表示IO操作正在进行，不能立即完成
  67. // 如果不是WSA_IO_PENDING错误，就表示操作失败了
  68. LOGMESSAGE("错误：第一次投递Recv操作失败！！此套接字将被关闭!");
  69. closesocket(pServer->sockAcceptArray[pServer->nSockIndex]);
  70. pServer->sockAcceptArray[pServer->nSockIndex] = INVALID_SOCKET;
  72. WSACloseEvent(pServer->EventArray[pServer->nSockIndex]);
  74. continue;
  75. }
  76. }
  78. pServer->dwEventTotal ++;
  79. }
  81. return 0;
  82. }
  84. // 重叠I/O处理线程
  85. UINT OverlappedThread(LPVOID lParam)
  86. {
  87. CServerSocket* pServer = (CServerSocket*)lParam;
  89. while(pServer->bOverlapped)                    // 循环检测事件数组中的事件，并对接收的数据进行处理:)
  90. {
  91. DWORD dwIndex;
  93. // 等候重叠I/O调用结束
  94. // 因为我们把事件和Overlapped绑定在一起，重叠操作完成后我们会接到事件通知
  95. dwIndex = WSAWaitForMultipleEvents(pServer->dwEventTotal,pServer->EventArray,FALSE,INFINITE,FALSE);
  97. if(dwIndex == WSA_WAIT_TIMEOUT)
  98. continue;
  100. if(dwIndex == WSA_WAIT_FAILED)  // 出现监听错误
  101. {
  102. Sleep(200);
  103. continue;
  104. }
  106. // 取得索引值，得知事件的索引号
  107. dwIndex = dwIndex - WSA_WAIT_EVENT_0;
  109. // 获得索引号以后，这个事件已经没有利用价值，重置之
  110. WSAResetEvent(pServer->EventArray[dwIndex]);
  112. // 然后确定当前索引号的SOCKET的重叠请求状态
  113. DWORD dwBytesTransferred;
  114. WSAOVERLAPPED& CurrentOverlapped = pServer->AcceptOverlapped[dwIndex]; // 这里纯粹为了减少代码长度，付给了一个临时变量
  115. SOCKET& sockCurrent = pServer->sockAcceptArray[dwIndex] ;  // 同上
  117. WSAGetOverlappedResult(sockCurrent,&CurrentOverlapped ,
  118. &dwBytesTransferred,FALSE,&pServer->Flags);
  120. // 先检查通信对方是否已经关闭连接
  121. // 如果==0则表示连接已经，则关闭套接字
  122. if(dwBytesTransferred == 0)
  123. {
  124. char strSock[80];
  125. sprintf(strSock,"Client disconnect:SOCKET编号:%drn",pServer->sockAcceptArray[dwIndex] );
  126. LOGMESSAGE(strSock);
  128. closesocket(sockCurrent);
  129. sockCurrent = INVALID_SOCKET;
  130. //WSACloseEvent( EventArray[dwIndex] );
  132. pServer->dwEventTotal--;
  133. continue;
  134. }
  137. // DataBuf中包含接收到的数据，我们发到对话框中给予显示
  138. char strSock[80];
  139. sprintf(strSock,"Socket data SOCKET编号:%d,%srn",sockCurrent,pServer->DataBuf[dwIndex].buf);
  140. LOGMESSAGE(strSock);
  142. // 然后在套接字上投递另一个WSARecv请求(不要晕，注意看，代码和前面第一次WSARecv一样^_^)
  143. pServer->Flags = 0;
  144. ZeroMemory(&CurrentOverlapped,sizeof(WSAOVERLAPPED));
  146. char buffer[DATA_BUFSIZE];
  147. ZeroMemory(buffer,DATA_BUFSIZE);
  149. CurrentOverlapped.hEvent = pServer->EventArray[dwIndex];
  150. pServer->DataBuf[dwIndex].len = DATA_BUFSIZE;
  151. pServer->DataBuf[dwIndex].buf = buffer;
  153. // 开始另外一个WSARecv
  154. if(WSARecv(sockCurrent,&pServer->DataBuf[dwIndex],1,&pServer->dwRecvBytes,&pServer->Flags,
  155. &CurrentOverlapped ,NULL) == SOCKET_ERROR)
  156. {
  157. if(WSAGetLastError() != WSA_IO_PENDING) 
  158. {
  159. LOGMESSAGE("错误：投递Recv操作失败！！此套接字将被关闭!");
  161. closesocket(sockCurrent);
  162. sockCurrent = INVALID_SOCKET;
  164. WSACloseEvent(pServer->EventArray[dwIndex]);
  166. pServer->dwEventTotal--;
  168. continue;
  169. }
  170. }
  171. }
  173. return 0;
  174. }
  176. CServerSocket::CServerSocket(void)
  177. {
  178. for(int i=0;i<WSA_MAXIMUM_WAIT_EVENTS;i++)   // 初始化SOCKET
  179. {
  180. sockAcceptArray[i] = INVALID_SOCKET;
  181. }
  182. dwEventTotal=0;
  183. dwRecvBytes=0;
  184. Flags=0;
  185. nSockIndex = 0;
  186. bOverlapped = FALSE;
  188. }
  190. CServerSocket::~CServerSocket(void)
  191. {
  192. LOGMESSAGE("CServerSocket 析构！");
  193. WSACleanup();
  194. }
  195. int CServerSocket::InitWSASocket()
  196. {
  197. //init socket
  198. WSADATA     WSD;
  199. WORD wVersionRequired = MAKEWORD( 2,2 );
  200. ZeroMemory(&WSD,sizeof(WSADATA));
  201. int nErrorNo = WSAStartup(wVersionRequired, &WSD);
  202. return nErrorNo;
  203. }
  204. // 这些都是固定套路了，没有区别
  205. int CServerSocket::StartListening(const UINT& port)
  206. {
  207. m_nPort = port;
  209. int nRet;
  210. InitWSASocket();
  212. sockListen = WSASocket(AF_INET,SOCK_STREAM,0, NULL, 0,WSA_FLAG_OVERLAPPED);         //创建服务套接字(流式)
  213. //server_socket = WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0,WSA_FLAG_OVERLAPPED);
  215. SOCKADDR_IN ServerAddr;                                       //分配端口及协议族并绑定
  217. ServerAddr.sin_family=AF_INET;                                
  218. ServerAddr.sin_addr.S_un.S_addr  =htonl(INADDR_ANY);          
  219. ServerAddr.sin_port=htons(port);
  221. nRet=bind(sockListen,(LPSOCKADDR)&ServerAddr,sizeof(ServerAddr)); // 绑定套接字
  223. if(nRet==SOCKET_ERROR)
  224. {
  225. LOGMESSAGE("Bind Socket Fail!");
  226. closesocket(sockListen);
  227. return -1;
  228. }
  230. nRet=listen(sockListen,5);                                   //开始监听，并设置监听客户端数量
  231. if(nRet==SOCKET_ERROR)     
  232. {
  233. LOGMESSAGE("Listening Fail!");
  234. return -1;
  235. }
  237. StartupAcceptThread();
  238. StartupWorkThread();
  239. bOverlapped = TRUE;
  240. return 0;
  241. }
  243. int CServerSocket::StopListening()
  244. {
  245. bOverlapped = FALSE;
  247. return 0;
  248. }
  250. // 返回一个空闲的SOCKET，
  251. int CServerSocket::GetEmptySocket()
  252. {
  253. for(int i=0;i<WSA_MAXIMUM_WAIT_EVENTS;i++)
  254. {
  255. if(sockAcceptArray[i]==INVALID_SOCKET)
  256. {
  257. return i;
  258. }
  259. }
  261. return -1;
  262. }
  264. bool   CServerSocket::StartupAcceptThread()
  265. {
  266. HANDLE  hAcceptThread;
  267. DWORD  dwThreadId;
  268. hAcceptThread = (HANDLE)_beginthreadex(NULL,0,(PBEGINTHREADEX_THREADFUNC)ServerListenThread,
  269. (LPVOID)this,0,(PBEGINTHREADEX_THREADID)&dwThreadId);
  271. if(hAcceptThread==NULL)
  272. {
  273. return false;
  274. }
  275. else
  276. {
  277. m_hAcceptThread=hAcceptThread;
  278. return  true;
  279. }
  280. }
  282. bool   CServerSocket::StartupWorkThread()
  283. {
  285. HANDLE hThread;
  286.         DWORD  dwThreadId;
  287.         //启动服务器工作线程
  288. hThread = (HANDLE)_beginthreadex(NULL,0,(PBEGINTHREADEX_THREADFUNC)OverlappedThread,
  289. (LPVOID)this,0,(PBEGINTHREADEX_THREADID)&dwThreadId);
  290.         if(hThread==NULL)
  291. {
  292. return false;
  293. }
  294. else
  295. m_hWorkThread=hThread;
  297.     return  true;
  298. }