cocos2dx3.x利用sokcet创建客户端和服务端 (二)

服务端:

初始化服务端

向指定客户端发送消息

void sendMessage(HSocket socket, const char* data, int count);

向所有客户端发送消息

void sendMessage(const char* data, int count);

当服务端开启后的回调函数

std::function<void(const char* ip)> onStart;

当有新连接时的回调函数

std::function<void(HSocket socket)> onNewConnection;

当有消息时的回调函数

std::function<void(const char* data, int count)> onRecv;

当有客户端断开连接时的回调函数

std::function<void(HSocket socket)> onDisconnect;

SocketServer.h

[cpp]  view plain copy

1. #ifndef __SOCKET_SERVER_H__  
2. #define __SOCKET_SERVER_H__  
3.   
4. #include "SocketBase.h"  
5.   
6. class SocketServer : public SocketBase  
7. {  
8. public:  
9.     static SocketServer* create();  
10.   
11.     SocketServer();  
12.     ~SocketServer();  
13.   
14.     bool startServer();  
15.     void sendMessage(HSocket socket, const char* data, int count);  
16.     void sendMessage(const char* data, int count);  
17.   
18.     std::function<void(const char* ip)> onStart;  
19.     std::function<void(HSocket socket)> onNewConnection;  
20.     std::function<void(const char* data, int count)> onRecv;  
21.     std::function<void(HSocket socket)> onDisconnect;  
22.   
23. private:  
24.     bool initServer();  
25.     void acceptClient();  
26.     void acceptFunc();  
27.     void newClientConnected(HSocket socket);  
28.     void recvMessage(HSocket socket);  
29.       
30. private:  
31.     HSocket _socketServer;  
32.   
33. private:  
34.     std::list<HSocket> _clientSockets;  
35.   
36. };  
37.   
38. #endif  

SocketServer.cpp

[cpp]  view plain copy

1. #include "SocketServer.h"  
2.   
3. SocketServer* SocketServer::create()  
4. {  
5.     auto server = new SocketServer;  
6.   
7.     return server;  
8. }  
9.   
10. SocketServer::SocketServer() :  
11.     _socketServer(0),  
12.     onRecv(nullptr),  
13.     onStart(nullptr),  
14.     onNewConnection(nullptr)  
15. {  
16.   
17. }  
18.   
19. SocketServer::~SocketServer()  
20. {  
21.     _clientSockets.clear();  
22.   
23.     if (_socketServer)  
24.     {  
25.         this->closeConnect(_socketServer);  
26.     }  
27. };  
28.   
29. bool SocketServer::startServer()  
30. {  
31.     if (!initServer())  
32.     {  
33.         return false;  
34.     }  
35.   
36.     return true;  
37. }  
38.   
39. bool SocketServer::initServer()  
40. {  
41.     if (_socketServer != 0)  
42.     {  
43.         this->closeConnect(_socketServer);  
44.     }  
45.     _socketServer = socket(AF_INET, SOCK_STREAM, 0);  
46.     if (error(_socketServer))  
47.     {  
48.         log("socket error!");  
49.         _socketServer = 0;  
50.         return false;  
51.     }  
52.     do   
53.     {  
54.         struct sockaddr_in sockAddr;  
55.         memset(&sockAddr, 0, sizeof(sockAddr));  
56.   
57.         sockAddr.sin_family = AF_INET;  
58.         sockAddr.sin_port = htons(8000);  
59.         sockAddr.sin_addr.s_addr = htonl(INADDR_ANY);  
60.         int ret = 0;  
61.         ret = bind(_socketServer, (const sockaddr*)&sockAddr, sizeof(sockAddr));  
62.         if (ret < 0)  
63.         {  
64.             log("bind error!");  
65.             break;  
66.         }  
67.       
68.         ret = listen(_socketServer, 5);  
69.         if (ret < 0)  
70.         {  
71.             log("listen error!");  
72.             break;  
73.         }  
74.         // start   
75.         char hostName[256];  
76.         gethostname(hostName, sizeof(hostName));  
77.         struct hostent* hostInfo = gethostbyname(hostName);  
78.         char* ip = inet_ntoa(*(struct in_addr *)*hostInfo->h_addr_list);  
79.         this->acceptClient();  
80.   
81.         if (onStart != nullptr)  
82.         {  
83.             log("start server!");  
84.             onStart(ip);  
85.         }  
86.   
87.         return true;  
88.   
89.     } while (false);  
90.       
91.     this->closeConnect(_socketServer);  
92.     _socketServer = 0;  
93.     return false;  
94. }  
95.   
96. void SocketServer::acceptClient()  
97. {  
98.     std::thread th(&SocketServer::acceptFunc, this);  
99.     th.detach();  
100. }  
101.   
102. void SocketServer::acceptFunc()  
103. {  
104.     int len = sizeof(sockaddr);  
105.     struct sockaddr_in sockAddr;  
106.     while (true)  
107.     {     
108.         HSocket clientSock = accept(_socketServer, (sockaddr*)&sockAddr, &len);  
109.         if (error(clientSock))  
110.         {  
111.             log("accept error!");  
112.             break;  
113.         }  
114.   
115.         this->newClientConnected(clientSock);  
116.     }  
117. }  
118.   
119. void SocketServer::newClientConnected(HSocket socket)  
120. {  
121.     log("new connect!");  
122.   
123.     _clientSockets.push_back(socket);  
124.     std::thread th(&SocketServer::recvMessage, this, socket);  
125.     th.detach();  
126.   
127.     if (onNewConnection != nullptr)  
128.     {  
129.         onNewConnection(socket);  
130.     }  
131. }  
132.   
133. void SocketServer::recvMessage(HSocket socket)  
134. {  
135.     char buff[1024];  
136.     int ret = 0;  
137.   
138.     while (true)  
139.     {  
140.         ret = recv(socket, buff, sizeof(buff), 0);  
141.         if (ret < 0)  
142.         {  
143.             log("recv(%d) error!", socket);  
144.             _mutex.lock();  
145.             this->closeConnect(socket);  
146.             _clientSockets.remove(socket);  
147.             if (onDisconnect != nullptr)  
148.             {  
149.                 onDisconnect(socket);  
150.             }  
151.             _mutex.unlock();  
152.   
153.             break;  
154.         }  
155.         else  
156.         {  
157.             buff[ret] = 0;  
158.             log("recv msg : %s", buff);  
159.             if (ret > 0 && onRecv != nullptr)  
160.             {  
161.                 onRecv(buff, ret);  
162.             }  
163.         }  
164.     }  
165. }  
166.   
167. void SocketServer::sendMessage(HSocket socket, const char* data, int count)  
168. {  
169.     for (auto& sock : _clientSockets)  
170.     {  
171.         if (sock == socket)  
172.         {  
173.             int ret = send(socket, data, count, 0);  
174.             if (ret < 0)  
175.             {  
176.                 log("send error!");  
177.             }  
178.             break;  
179.         }  
180.     }  
181.   
182. }  
183.   
184. void SocketServer::sendMessage(const char* data, int count)  
185. {  
186.     for (auto& socket : _clientSockets)  
187.     {  
188.         int ret = send(socket, data, count, 0);  
189.         if (ret < 0)  
190.         {  
191.             log("send error!");  
192.         }  
193.   
194.     }  
195.   
196. }