linux网络编程系列（三）--tcp和udp的基本函数调用过程及如何选择

1. socket编程

1.1 概述

TCP是TCP/IP体系中面向连接的传输层协议，它提供全双工和可靠交付的服务。它采用许多机制来确保端到端结点之间的可靠数据传输，如采用序列号、确认重传、滑动窗口等。

1.2 tcp服务端编程

1.2.1 TCP通信的基本步骤

服务端：socket---bind---listen---while(1){---accept---recv---send---close---}---close 客户端：socket----------------------------------connect---send---recv-----------------close

1.2.2 服务器端头文件包含

1. #include <sys/types.h>
2. #include <sys/socket.h>
3. #include <netinet/in.h>
4. #include <arpa/inet.h>
5. #include <unistd.h>
6. #include <string.h>
7. #include <stdio.h>
8. #include <stdlib.h>

1.2.3 socket函数

功能：生成一个套接口描述符 原型：int socket(int domain,int type,int protocol); 参数： domain{ AFINET：Ipv4网络协议 AFINET6：IPv6网络协议} type｛tcp：SOCKSTREAM udp：SOCKDGRAM} protocol 指定socket所使用的传输协议编号，常用的协议有：IPPROTOTCP、IPPROTOUDP、IPPROTOSCTP、IPPROTOTIPC等，他们分别对应TCP协议、UDP协议、STCP协议、TIPC协议，当protocol默认为0时，则根据type参数的值，自动选择协议类型； 返回值：成功则返回套接口描述符，失败返回-1。 常用实例：

1. int sfd = socket(AF_INET, SOCK_STREAM, 0);
2. if(sfd == -1)
3. {
4. perror("socket");
5. exit(-1);
6. }

1.2.4 bind函数

功能：用来绑定一个端口号和IP地址，使套接口与指定的端口号和IP地址相关联。 原型：int bind(int sockfd,struct sockaddr * myaddr,int addrlen); 参数： sockfd为前面socket的返回值 addrlen sockaddr的结构体长度。通常是计算sizeof(struct sockaddr); myaddr为结构体指针变量 对于不同的socket domain定义了一个通用的数据结构:

1. //此结构体不常用
2. struct sockaddr
3. {
4. unsigned short int sa_family; //调用socket（）时的domain参数，即AF_INET值。
5. char sa_data[14]; //最多使用14个字符长度
6. };
7. //此sockaddr结构会因使用不同的socket domain而有不同结构定义， 例如使用AF_INET domain，其socketaddr结构定义便为:
8. struct sockaddr_in //常用的结构体
9. {
10. unsigned short int sin_family; //即为sa_family AF_INET
11. uint16_t sin_port; //为使用的port编号
12. struct in_addr sin_addr; //为IP 地址
13. unsigned char sin_zero[8]; //未使用
14. };
16. struct in_addr
17. {
18. uint32_t s_addr;
19. };

返回值：成功则返回0，失败返回-1，并设置errno，最常见的errno有以下两种：

• EACCES,被绑定的地址是受保护的地址，仅超级用户能够访问，比如如果绑定在1-1023端口的时候，就会报该错误。
• EADDRINUSE，被绑定的地址正在使用中，比如将socket绑定在一个处于TIME_WAIT状态的socket地址。

常用实例：

1. struct sockaddr_in my_addr; //定义结构体变量
2. memset(&my_addr, 0, sizeof(struct sockaddr)); //将结构体清空
3. //或bzero(&my_addr, sizeof(struct sockaddr));
4. my_addr.sin_family = AF_INET; //表示采用Ipv4网络协议
5. my_addr.sin_port = htons(8888); //表示端口号为8888，通常是大于1024的一个值。
6. //htons()用来将参数指定的16位hostshort转换成网络字符顺序
7. my_addr.sin_addr.s_addr = inet_addr("192.168.0.101"); // //inet_addr()用来将IP地址字符串转换成网络所使用的二进制数字，如果为INADDR_ANY，这表示服务器自动填充本机IP地址。
8. if(bind(sfd, (struct sockaddr*)&my_str, sizeof(struct socketaddr)) == -1)
9. {perror("bind");close(sfd);exit(-1);}
10. /*通过将my_addr.sin_port置为0，函数会自动为你选择一个未占用的端口来使用。同样，通过将my_addr.sin_addr.s_addr置为INADDR_ANY，系统会自动填入本机IP地址*/

注意：如果myaddr.sinaddr.saddr = htonl(INADDRANY)时，INADDRANY就是指定地址为0.0.0.0的地址，它其实是表示不确定地址，一般是用于多网卡的机器上，也就是有多个IP地址，如果设置了INADDRANY，那么根据端口号，无论连接哪个IP地址，都是可以连接成功的。

1.2.5 listen函数

功能：使服务器的这个端口和IP处于监听状态，等待网络中某一客户机的连接请求。如果客户端有连接请求，端口就会接受这个连接。 原型：int listen(int sockfd, int backlog); 参数： sockfd为前面socket的返回值.即sfd backlog指定同时能处理的最大连接要求，通常为10或者5。 最大值可设至128 返回值：成功则返回0，失败返回-1 常用实例：

1. if(listen(sfd, 10) == -1)
2. {
3. perror("listen");
4. close(sfd);
5. exit(-1);
6. }

1.2.6 accept函数

功能：接受远程计算机的连接请求，建立起与客户机之间的通信连接。服务器处于监听状态时，如果某时刻获得客户机的连接请求，此时并不是立即处理这个请求，而是将这个请求放在等待队列中，当系统空闲时再处理客户机的连接请求。当accept函数接受一个连接时，会返回一个新的socket标识符，以后的数据传输和读取就要通过这个新的socket编号来处理，原来参数中的socket也可以继续使用，继续监听其它客户机的连接请求。

原型：int accept(int s,struct sockaddr * addr,int * addrlen);

参数： s为前面socket的返回值，即sfd addr为结构体指针变量，和bind的结构体是同种类型的，系统会把远程主机的信息（远程主机的地址和端口号信息）保存到这个指针所指的结构体中。 addrlen表示结构体的长度，为整型指针

返回值：成功则返回新的文件描述符new_fd，失败返回-1 常用实例：

1. struct sockaddr_in clientaddr;
2. memset(&clientaddr, 0, sizeof(struct sockaddr));
3. int addrlen = sizeof(struct sockaddr);
4. int new_fd = accept(sfd, (struct sockaddr*)&clientaddr, &addrlen);
5. if(new_fd == -1)
6. {
7. perror("accept");
8. close(sfd);
9. exit(-1);
10. }
11. printf("%s %d success connect\n",inet_ntoa(clientaddr.sin_addr),ntohs(clientaddr.sin_port));

注意：accept函数只是从监听队列中取出连接，而不论连接处于什么状态，网络状况有什么变化。

1.2.7 recv函数

功能：接收远端主机传来的数据，并把数据存到由参数buf 指向的内存空间

原型：int recv(int sockfd,void *buf,int len,unsigned int flags);

参数：sockfd为前面accept的返回值.即new_fd，也就是新的套接字。 buf表示缓冲区 len表示缓冲区的长度 flags通常为0

返回值：

>0 成功，返回实际接收到的字符数；

=0 连接关闭，说明recv在等待接收数据时网络中断了；

-1 表示出错； 常用实例：

1. char buf[512] = {0};
2. if(recv(new_fd, buf, sizeof(buf), 0) == -1)
3. {
4. perror("recv");
5. close(new_fd);
6. close(sfd);
7. exit(-1);
8. }
9. puts(buf);

注意：read函数返回值不一样，大于0 是返回字节数，等于0是读到文件末尾了，小于0则表示出现了错误，如果错误为EINTR说明是由中断引起的，如果是ECONNNERST则表示网络连接出现了问题。

1.2.8 send函数

功能：发送数据给指定的远端主机

原型：int send(int s,const void * msg,int len,unsigned int flags);

参数：s为前面accept的返回值.即new_fd msg一般为常量字符串 len表示长度 flags通常为0

返回值： >0 成功，返回实际传送出去的字符数，可能会少于你所指定的发送长度； =0 连接关闭，网络中断了； -1 表示出错； 常用实例：

1. if(send(new_fd, "hello", 6, 0) == -1)
2. {
3. perror("send");
4. close(new_fd);
5. close(sfd);
6. exit(-1);
7. }

注意：write函数返回小于0时，如果为EPIPE，则表示网络连接出现了问题。

1.2.9 close函数

功能：当使用完文件后若已不再需要则可使用close()关闭该文件，并且close()会让数据写回磁盘，并释放该文件所占用的资源

原型：int close(int fd);

参数：fd为前面的sfd,newfd

返回值：若文件顺利关闭则返回0，发生错误时返回-1 常用实例：close(newfd); close(sfd);

注意：在多进程并发服务器中，父子进程共享套接字，有多少个进程共享该套接字，该套接字就有多少个引用计数，此时其中一个进程调用close只是关闭了当前进程的这个文件描述符，但并没有发生四次挥手，直到这个套接字的引用计数为0时，才会发生四次挥手

1.2.10 sockatmark函数

功能：判断sockfd是否处于带外标记，即判断下一个读取的数据是否含有带外数据，若含有，则调用带MSGOOB标志的recv来读取带外数据 原型：int sockatmark(int sockfd); 参数：fd为前面的sfd,newfd 返回值：返回1则说明下一个数据时带外数据，若返回0，则不是

1.3 tcp客户端编程

1.3.1 connect函数

功能：用来请求连接远程服务器，将参数sockfd 的socket 连至参数servaddr 指定的服务器IP和端口号上去。 原型：int connect (int sockfd,struct sockaddr * servaddr,int addrlen); 参数：sockfdà为前面socket的返回值，即sfd serv_addrà为结构体指针变量，存储着远程服务器的IP与端口号信息。 addrlenà表示结构体变量的长度 返回值：成功则返回0，失败返回-1 常用实例：

1. struct sockaddr_in seraddr;//请求连接服务器
2. memset(&seraddr, 0, sizeof(struct sockaddr));
3. seraddr.sin_family = AF_INET;
4. seraddr.sin_port = htons(8888); //服务器的端口号
5. seraddr.sin_addr.s_addr = inet_addr("192.168.0.101"); //服务器的ip
6. if(connect(sfd, (struct sockaddr*)&seraddr, sizeof(struct sockaddr)) == -1)
7. {perror("connect");close(sfd);exit(-1);}

将上面的头文件以及各个函数中的代码全部拷贝就可以形成一个完整的例子，此处省略。 还可以不写客户端程序，使用telnet远程登录来检测我们的服务器端程序。比如我们的服务器程序在监听8888端口，我们可以用telnet 192.168.0.101 8888来查看服务端的状况。

2. tcp编程实现

2.1 使用类封装tcp的基本操作

1. //头文件 SxTcp.h
2. #ifndef __SXTCP_H__
3. #define __SXTCP_H__
5. #include <stdio.h>
7. #define TIMEOUT_SEC 1
8. #define MAX_READ_SIZE BUFSIZ
9. #define DEFAULT_EPOLL_FD_NUM 1024
11. //Tcp类
12. class CTcp
13. {
15. //构造函数
16. public:
17. CTcp ();
18. CTcp (int nSock);
19. virtual ~CTcp ();
21. //重载操作符
22. public:
23. int operator = (int);//赋值
24. int operator != (int) const;//不等于操作符
25. int operator == (int) const;//等于操作符
27. //公有成员函数
28. public:
29. int GetHandle () const;//取出m_nSock
30. int Open ();//创建socket
31. int Close ();//关闭监听socket
32. int Connect (const char *, int) const;//连接（未设置超时）
33. int Bind (const char *, int) const;//绑定
34. int Listen (int nNum) const;//监听
35. int Accept () const;//接受连接
36. int Recv(int nFd, char* buf, int nBufLen);//服务端接收
37. int Send(int nFd, char* buf, int nBufLen);//服务端发送
38. void Close (int nFd);//服务端关闭连接socket
39. int Send (const void *, int, int = TCP_TIMEOUT) const;//客户端发送数据
40. int Recv (void *, int, int = TCP_TIMEOUT) const;//客户端接收数据
42. static const int SOCK_ERROR;
43. static const int SOCK_TIMEOUT;
44. static const long TCP_TIMEOUT;
46. //私有成员变量
47. private:
48. int m_nSock;
49. };
51. #endif

1. //sxTcp.cpp
2. #include <stdio.h>
3. #include <sys/socket.h>
4. #include <unistd.h>
5. #include <sys/types.h>
6. #include <netinet/in.h>
7. #include <stdlib.h>
8. #include <time.h>
9. #include <string.h>
10. #include <stdarg.h>
11. #include <arpa/inet.h>
12. #include <iostream>
13. #include <pthread.h>
14. #include <sys/stat.h>
15. #include <fcntl.h>
16. #include <netdb.h>
17. #include <errno.h>
18. #include <assert.h>
19. #include <sys/epoll.h>
20. #include <signal.h>
21. #include "SxTcp.h"
23. const int CTcp::SOCK_ERROR = -100;
24. const int CTcp::SOCK_TIMEOUT = -101;
25. const long CTcp::TCP_TIMEOUT = 500000;
27. //构造函数
28. CTcp::CTcp ()
29. {
30. m_nSock = -1;
31. }
33. //构造函数
34. CTcp::CTcp (int p_iSock)
35. {
36. m_nSock = p_iSock;
37. }
39. //析构函数
40. CTcp::~CTcp ()
41. {
42. Close ();
43. }
45. /*赋值
46. 入参：nSockfd - socket句柄
47. 出参：赋值后的socket句柄
48. */
49. int CTcp::operator = (int p_iSockfd)
50. {
51. //isfdtype判断nSockfd是否为指定类型，S_IFSOCK判断是否为套接字描述符，返回1是，0不是，-1出错
52. assert ((m_nSock == -1) && (p_iSockfd > -1) && (isfdtype (p_iSockfd, S_IFSOCK) == 1));
53. m_nSock = p_iSockfd;
55. return m_nSock;
56. }
58. /*判断两个socket句柄是否不相等
59. 入参：n - "!="右边的socket句柄
60. 出参：1：不相等；0：相等
61. */
62. int CTcp::operator != (int p_iSockfd) const
63. {
64. return (m_nSock != p_iSockfd);
65. }
67. /*判断两个socket句柄是否相等
68. 入参：n - "=="右边的socket句柄
69. 出参：1：相等；0：不相等
70. */
71. int CTcp::operator == (int p_iSockfd) const
72. {
73. return (m_nSock == p_iSockfd);
74. }
76. /*取出socket句柄
77. 入参：无
78. 出参：取出的socket句柄
79. */
80. int CTcp::GetHandle () const
81. {
82. return m_nSock;
83. }
85. /*创建socket
86. 入参：无
87. 出参：1: 成功 ; 0: 失败
88. */
89. int CTcp::Open ()
90. {
91. assert (m_nSock == -1);
93. //获取tcp套接字
94. m_nSock = socket (AF_INET, SOCK_STREAM, 0);
96. return (m_nSock != -1);
97. }
99. /*关闭socket
100. 入参：无
101. 出参：1: 成功 ; 0: 失败
102. */
103. int CTcp::Close ()
104. {
105. if (m_nSock != -1)
106. {
107. close (m_nSock);
108. m_nSock = -1;
109. }
110. return 1;
111. }
113. /*连接（未设置超时），默认为阻塞IO
114. 入参：pHost - IP地址或主机名
115. nPort - 端口
116. 出参：1: 成功 ; 0: 失败
117. */
118. int CTcp::Connect (const char *p_szHost, int p_iPort) const
119. {
120. assert ((m_nSock != -1) && p_szHost && (p_iPort > 0));
121. struct sockaddr_in addr;
122. struct hostent *phe = NULL;
124. memset ((void*)&addr, 0, sizeof (addr));
125. addr.sin_family = AF_INET;
126. addr.sin_port = htons (p_iPort);
128. if ((addr.sin_addr.s_addr = inet_addr (p_szHost)) == -1)
129. {
130. if ((phe = gethostbyname (p_szHost)) == NULL)
131. return 0;
133. memcpy ((char *)&addr.sin_addr, phe->h_addr, phe->h_length);
134. }
136. return (connect (m_nSock, (struct sockaddr *)&addr, sizeof (addr)) == 0);
137. }
139. /*绑定
140. 入参：pIP - IP地址
141. nPort - 端口
142. 出参：1: 成功 ; 0: 失败
143. */
144. int CTcp::Bind (const char *pIP, int nPort) const
145. {
146. assert ((m_nSock != -1) && (nPort > 0));
147. struct sockaddr_in addr;
148. struct hostent *phe = NULL;
149. int opt=1;
151. if (setsockopt (m_nSock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int)) == -1)
152. {
153. return 0;
154. }
156. memset (&addr, 0, sizeof (addr));
157. addr.sin_family = AF_INET;
158. addr.sin_port = htons (nPort);
160. if (!pIP)
161. {
163. addr.sin_addr.s_addr = htonl (INADDR_ANY);
164. }
165. else
166. {
167. if ((addr.sin_addr.s_addr = inet_addr (pIP)) == -1)
168. {
169. if ((phe = gethostbyname (pIP)) == NULL)
170. return 0;
172. memcpy ((char *)&addr.sin_addr, phe->h_addr, phe->h_length);
173. }
174. }
176. return (bind (m_nSock, (struct sockaddr *)&addr, sizeof (addr)) == 0);
177. }
179. /*监听
180. 入参：nNum - 监听数目
181. 出参：1: 成功 ; 0: 失败
182. */
183. int CTcp::Listen (int nNum) const
184. {
185. assert ((m_nSock != -1) && (nNum > 0));
187. return (listen (m_nSock, nNum) == 0);
188. }
190. /*接受连接
191. 入参：无
192. 出参：其他: 连接套接字句柄 ; -1: 失败
193. */
194. int CTcp::Accept () const
195. {
196. assert (m_nSock != -1);
198. return (accept (m_nSock, (struct sockaddr *)NULL, NULL));
199. }
201. /*服务端接收数据
202. 入参：pBuf - 接收缓存
203. nCount - 需接收字节数
204. 出参：实际接收字节数 ，如果接收失败，返回负数，如果对方关闭，返回0
205. */
206. int CTcp::Recv(int nFd, char* buf, int nBufLen)
207. {
208. assert(nFd != -1 );
209. return recv(nFd, buf, nBufLen, 0);
210. }
212. /*客户端接收数据
213. 入参：pBuf - 接收缓存
214. nCount - 需接收字节数
215. nMicsec - socket超时值，单位：微妙，缺省：500000微妙
216. 出参：实际接收字节数 ，如果接收失败，返回负数，如果对方关闭，返回0
217. */
218. int CTcp::Recv (void *pBuf, int nCount, int nMicsec) const
219. {
220. assert ((m_nSock != -1) && pBuf && (nCount > 0));
221. int sn = 0, rn = 0;
222. struct timeval tvlTime;
223. fd_set rdfdset;
225. if (nMicsec >= 0)
226. {
227. tvlTime.tv_sec = nMicsec / 1000000;
228. tvlTime.tv_usec = abs (nMicsec - tvlTime.tv_sec * 1000000);
229. }
231. FD_ZERO (&rdfdset);
232. FD_SET (m_nSock, &rdfdset);
234. if (nMicsec > 0)
235. sn = select (m_nSock + 1, &rdfdset, NULL, NULL, &tvlTime);
236. else
237. sn = select (m_nSock + 1, &rdfdset, NULL, NULL, NULL);
239. switch (sn)
240. {
241. case -1:
242. return SOCK_ERROR;
244. case 0:
245. return SOCK_TIMEOUT;
246. }
248. if ((rn = read (m_nSock, pBuf, nCount)) < 0)
249. return SOCK_ERROR;
251. return rn;
252. }
256. /*服务端发送数据
257. 入参：pBuf - 发送缓存
258. nCount - 需发送字节数
259. 出参：实际发送字节数 ，如果发送失败，返回负数
260. */
261. int CTcp::Send(int nFd, char* buf, int nBufLen)
262. {
263. assert(nFd != -1 );
264. return send(nFd, buf, nBufLen, 0);
265. }
267. /*客户端发送数据
268. 入参：pBuf - 发送缓存
269. nCount - 需发送字节数
270. nMicsec - socket超时值，单位：微妙，缺省：500000微妙
271. 出参：实际发送字节数 ，如果发送失败，返回负数
272. */
273. int CTcp::Send (const void *pBuf, int nCount, int nMicsec) const
274. {
275. assert ((m_nSock != -1) && pBuf && (nCount > 0));
276. int sn = 0, wn = 0;
277. struct timeval tvlTime;
278. fd_set wtfdset;
281. if (nMicsec >= 0)
282. {
283. tvlTime.tv_sec = nMicsec / 1000000;
284. tvlTime.tv_usec = abs (nMicsec - tvlTime.tv_sec * 1000000);
285. }
287. FD_ZERO (&wtfdset);
288. FD_SET (m_nSock, &wtfdset);
290. if (nMicsec >= 0)
291. sn = select (m_nSock + 1, NULL, &wtfdset, NULL, &tvlTime);
292. else
293. sn = select (m_nSock + 1, NULL, &wtfdset, NULL, NULL);
295. switch (sn)
296. {
297. case -1:
298. return SOCK_ERROR;
300. case 0:
301. return SOCK_TIMEOUT;
302. }
304. if ((wn = send (m_nSock, pBuf, nCount, 0)) <= 0)
305. return SOCK_ERROR;
307. return wn;
308. }
311. void CTcp::Close (int nFd)
312. {
313. if (nFd != -1 )
314. {
315. close(nFd);
316. nFd = -1;
317. }
318. }

将该类编译成动态库：

1. g++ -g -c SxTcp.cpp -fPIC
2. g++ -g -o libnetwork.so SxTcp.o -shared

2.2 利用类CTcp实现基本服务端和客户端

//服务端TestServer.cpp

1. //TestServer.cpp
2. #include <stdio.h>
3. #include <string.h>
4. #include "../../network/SxTcp.h"
6. int main()
7. {
8. CTcp tcp;
9. int iRet = 0;
10. int iFd = 0;
11. char buf[128] = {0};
13. iRet = tcp.Open();
14. if (iRet == 0)
15. {
16. perror("socket create failed");
17. return -1;
18. }
20. iRet = tcp.Bind("192.168.233.250", 6666);
21. if (iRet == 0)
22. {
23. perror("socket bind failed");
24. return -1;
25. }
27. iRet = tcp.Listen(10);
28. if (iRet == 0)
29. {
30. perror("socket listen failed");
31. return -1;
32. }
34. while(1)
35. {
36. memset(buf, 0, sizeof(buf));
38. iFd = tcp.Accept();
39. if (iFd == -1 )
40. {
41. perror("socket accept failed");
42. return -1;
43. }
45. iRet = tcp.Recv(iFd, buf, sizeof(buf));
46. if (iRet < 0 )
47. {
48. perror("recv failed");
49. tcp.Close(iFd);
50. return -1;
51. }
52. else if(iRet == 0)
53. {
54. perror("socket not connect");
55. tcp.Close(iFd);
56. return -1;
57. }
59. fprintf(stdout, "recv data is:%s\n", buf);
60. memset(buf, 0, sizeof(buf));
61. strncpy(buf, "I have redv your data,over!", sizeof(buf)-1);
63. iRet = tcp.Send(iFd, buf, strlen(buf));
64. if (iRet < 0)
65. {
66. perror("send failed");
67. tcp.Close(iFd);
68. return -1;
69. }
70. else if(iRet == 0)
71. {
72. perror("socket not connect");
73. tcp.Close(iFd);
74. return -1;
75. }
76. }
78. return 0;
79. }

//客户端

1. //TestClient.cpp
2. #include <stdio.h>
3. #include <iostream>
4. #include <string.h>
5. #include "../../network/SxTcp.h"
6. using namespace std;
8. int main()
9. {
10. CTcp tcp;
11. int iRet = 0;
12. int iFd = 0;
13. char buf[128] = {0};
15. iRet = tcp.Open();
16. if (iRet == 0)
17. {
18. perror("socket create failed");
19. return -1;
20. }
22. iRet = tcp.Connect("192.168.233.250", 6666);
23. if (iRet == 0)
24. {
25. perror("socket connect failed");
26. return -1;
27. }
29. while(1)
30. {
31. memset(buf, 0, sizeof(buf));
32. cout << "please input some string:";
33. cin >> buf;
34. iRet = tcp.Send(buf, strlen(buf));
35. if (iRet < 0 && errno != EAGAIN)
36. {
37. perror("send failed");
38. return -1;
39. }
40. else if(iRet == 0)
41. {
42. perror("connect is closed");
43. return -1;
44. }
46. memset(buf, 0, sizeof(buf));
47. iRet = tcp.Recv(buf, sizeof(buf));
48. if (iRet < 0 && errno != EAGAIN)
49. {
50. perror("recv failed");
51. return -1;
52. }
53. else if(iRet == 0)
54. {
55. perror("socket not connect");
56. return -1;
57. }
59. fprintf(stdout, "recv data is:%s\n", buf);
60. }
62. return 0;
63. }

分别编译服务端和客户端，然后发送数据，会发现客户端发送完第一次后，再第二次循环中会报recv failed。 这是因为服务端阻塞在accept了，没办法第二次接收和发送数据，那么客户端超时以后就会报错，返回负数，导致客户端退出。 当然也可以在服务端的recv和send外再加一个循环，如下：

1. //TestServer.cpp
2. #include <stdio.h>
3. #include <string.h>
4. #include "../../network/SxTcp.h"
6. int main()
7. {
8. CTcp tcp;
9. int iRet = 0;
10. int iFd = 0;
11. char buf[128] = {0};
13. iRet = tcp.Open();
14. if (iRet == 0)
15. {
16. perror("socket create failed");
17. return -1;
18. }
20. iRet = tcp.Bind("192.168.233.250", 6666);
21. if (iRet == 0)
22. {
23. perror("socket bind failed");
24. return -1;
25. }
27. iRet = tcp.Listen(10);
28. if (iRet == 0)
29. {
30. perror("socket listen failed");
31. return -1;
32. }
34. while(1)
35. {
36. memset(buf, 0, sizeof(buf));
38. iFd = tcp.Accept();
39. if (iFd == -1 )
40. {
41. perror("socket accept failed");
42. return -1;
43. }
44. while(1){
45. memset(buf, 0, sizeof(buf));
46. iRet = tcp.Recv(iFd, buf, sizeof(buf));
47. if (iRet < 0 )
48. {
49. perror("recv failed");
50. tcp.Close(iFd);
51. return -1;
52. }
53. else if(iRet == 0)
54. {
55. perror("socket not connect");
56. tcp.Close(iFd);
57. return -1;
58. }
60. fprintf(stdout, "recv data is:%s\n", buf);
61. memset(buf, 0, sizeof(buf));
62. strncpy(buf, "I have redv your data,over!", sizeof(buf)-1);
64. iRet = tcp.Send(iFd, buf, strlen(buf));
65. if (iRet < 0)
66. {
67. perror("send failed");
68. tcp.Close(iFd);
69. return -1;
70. }
71. else if(iRet == 0)
72. {
73. perror("socket not connect");
74. tcp.Close(iFd);
75. return -1;
76. }
77. }
78. }
80. return 0;
81. }

但很显然，这样就没办法接收到第二个连接了，那么怎么解决呢？往下面看。

3. 网络编程模式

上面的虽然可以实现多个客户端访问，但是仍然是阻塞模式（即一个客户访问的时候会阻塞不让另外的客户访问）。解决办法有三种，分别是多进程、多线程、异步IO。

3.1 多进程

//因为开销比较大，所以不常用

1. #include <stdio.h>
2. #include <string.h>
3. #include <sys/types.h>
4. #include <unistd.h>
5. #include "../../network/SxTcp.h"
7. int main()
8. {
9. CTcp tcp;
10. int iRet = 0;
11. int iFd = 0;
12. char buf[128] = {0};
14. iRet = tcp.Open();
15. if (iRet == 0)
16. {
17. perror("socket create failed");
18. return -1;
19. }
21. iRet = tcp.Bind("192.168.233.250", 6666);
22. if (iRet == 0)
23. {
24. perror("socket bind failed");
25. return -1;
26. }
28. iRet = tcp.Listen(10);
29. if (iRet == 0)
30. {
31. perror("socket listen failed");
32. return -1;
33. }
35. while(1)
36. {
37. memset(buf, 0, sizeof(buf));
39. iFd = tcp.Accept();
40. if (iFd == -1 )
41. {
42. perror("socket accept failed");
43. return -1;
44. }
46. if (fork() == 0)
47. {
48. while(1){
49. memset(buf, 0, sizeof(buf));
50. iRet = tcp.Recv(iFd, buf, sizeof(buf));
51. if (iRet < 0 )
52. {
53. perror("recv failed");
54. tcp.Close(iFd);
55. return -1;
56. }
57. else if(iRet == 0)
58. {
59. perror("socket not connect");
60. tcp.Close(iFd);
61. return -1;
62. }
64. fprintf(stdout, "recv data is:%s\n", buf);
65. memset(buf, 0, sizeof(buf));
66. strncpy(buf, "I have redv your data,over!", sizeof(buf)-1);
68. iRet = tcp.Send(iFd, buf, strlen(buf));
69. if (iRet < 0)
70. {
71. perror("send failed");
72. tcp.Close(iFd);
73. return -1;
74. }
75. else if(iRet == 0)
76. {
77. perror("socket not connect");
78. tcp.Close(iFd);
79. return -1;
80. }
81. }
82. }
83. else
84. {
85. tcp.Close(iFd);
86. }
88. }
90. return 0;
91. }

3.2 多线程

1. #include <stdio.h>
2. #include <string.h>
3. #include <sys/types.h>
4. #include <unistd.h>
5. #include <thread>
6. #include "../../network/SxTcp.h"
8. CTcp tcp;
10. void ReadThread(void* arg)
11. {
12. int *pFd = (int*)arg;
13. int iFd = *pFd;
15. char buf[128] = {0};
16. int iRet = 0;
17. while(1){
18. memset(buf, 0, sizeof(buf));
19. iRet = tcp.Recv(iFd, buf, sizeof(buf));
20. if (iRet < 0 )
21. {
22. perror("recv failed");
23. tcp.Close(iFd);
24. break;
25. }
26. else if(iRet == 0)
27. {
28. perror("socket not connect");
29. tcp.Close(iFd);
30. break;
31. }
33. fprintf(stdout, "recv data is:%s\n", buf);
34. memset(buf, 0, sizeof(buf));
35. strncpy(buf, "I have redv your data,over!", sizeof(buf)-1);
37. iRet = tcp.Send(iFd, buf, strlen(buf));
38. if (iRet < 0)
39. {
40. perror("send failed");
41. tcp.Close(iFd);
42. break;
43. }
44. else if(iRet == 0)
45. {
46. perror("socket not connect");
47. tcp.Close(iFd);
48. break;
49. }
50. }
52. }
54. int main()
55. {
56. int iRet = 0;
57. int iFd = 0;
58. char buf[128] = {0};
60. iRet = tcp.Open();
61. if (iRet == 0)
62. {
63. perror("socket create failed");
64. return -1;
65. }
67. iRet = tcp.Bind("192.168.233.250", 6666);
68. if (iRet == 0)
69. {
70. perror("socket bind failed");
71. return -1;
72. }
74. iRet = tcp.Listen(10);
75. if (iRet == 0)
76. {
77. perror("socket listen failed");
78. return -1;
79. }
81. while(1)
82. {
83. memset(buf, 0, sizeof(buf));
85. iFd = tcp.Accept();
86. if (iFd == -1 )
87. {
88. perror("socket accept failed");
89. return -1;
90. }
92. std::thread t_read(ReadThread, (void*)&iFd);
93. t_read.detach();
95. }
97. return 0;
98. }

3.3 异步IO

异步其实就是epoll和select模式，可以看另外的两篇专门讲epoll和select的文章。

4. 使用UDP编程

4.1 UDP协议

4.1.1 概述

UDP即用户数据报协议，它是一种无连接协议，因此不需要像TCP那样通过三次握手来建立一个连接。同时，一个UDP应用可同时作为应用的客户或服务器方。由于UDP协议并不需要建立一个明确的连接，因此建立UDP应用要比建立TCP应用简单得多。

它比TCP协议更为高效，也能更好地解决实时性的问题。如今，包括网络视频会议系统在内的众多的客户/服务器模式的网络应用都使用UDP协议。

4.1.2 Udp数据包头格式

源端口占用16bit，表示应用程序通过哪个端口来发送数据包； 目的端口占用16bit，表示数据包发送给对方应用程序的哪个端口； 长度占用16bit，表示包含头部在内的udp数据包的长度； 校验占用16bit，用来检查数据包是否存在差错；

4.1.3 udp基本通信流程及函数

UDP通信流程图如下： 服务端：socket---bind---recvfrom---sendto---close 客户端：socket----------sendto---recvfrom---close sendto()函数原型： int sendto(int sockfd, const void *msg,int len,unsigned int flags,const struct sockaddr *to, int tolen); 该函数比send()函数多了两个参数，to表示目地机的IP地址和端口号信息，而tolen常常被赋值为sizeof (struct sockaddr)。sendto 函数也返回实际发送的数据字节长度或在出现发送错误时返回-1。 recvfrom()函数原型： int recvfrom(int sockfd,void *buf,int len,unsigned int flags,struct sockaddr *from,int *fromlen); from是一个struct sockaddr类型的变量，该变量保存连接机的IP地址及端口号。fromlen常置为sizeof (struct sockaddr)。当recvfrom()返回时，fromlen包含实际存入from中的数据字节数。Recvfrom()函数返回接收到的字节数或 当出现错误时返回-1，并置相应的errno。 注意：socket编程还提供了一对函数sendmsg/recvmsg用于读写数据，该对函数既可用于tcp报文，也可用于udp报文，是通用的。

4.2 UDP编程实现

Example:

1. //UDP的基本操作
2. //服务器端：
3. #include <sys/types.h>
4. #include <sys/socket.h>
5. #include <netinet/in.h>
6. #include <arpa/inet.h>
7. #include <unistd.h>
8. #include <string.h>
9. #include <stdio.h>
10. #include <stdlib.h>
11. main()
12. {
13. int sfd = socket(AF_INET, SOCK_DGRAM, 0);
14. if(sfd == -1)
15. {
16. perror("socket");
17. exit(-1);
18. }
20. struct sockaddr_in saddr;
21. bzero(&saddr, sizeof(saddr));
22. saddr.sin_family = AF_INET;
23. saddr.sin_port = htons(8888);
24. saddr.sin_addr.s_addr = INADDR_ANY;
25. if(bind(sfd, (struct sockaddr*)&saddr, sizeof(struct sockaddr)) == -1)
26. {
27. perror("bind");
28. close(sfd);
29. exit(-1);
30. }
32. char buf[512] = {0};
33. while(1)
34. {
35. struct sockaddr_in fromaddr;
36. bzero(&fromaddr, sizeof(fromaddr));
37. int fromaddrlen = sizeof(struct sockaddr);
38. if(recvfrom(sfd, buf, sizeof(buf), 0, (struct sockaddr*)&fromaddr, &fromaddrlen) == -1)
39. {
40. perror("recvfrom");
41. close(sfd);
42. exit(-1);
43. }
44. printf("receive from %s %d,the message is:%s\n", inet_ntoa(fromaddr.sin_addr), ntohs(fromaddr.sin_port), buf);
46. sendto(sfd, "world", 6, 0, (struct sockaddr*)&fromaddr, sizeof(struct sockaddr));
47. }
49. close(sfd);
50. }

1. //客户端：
2. #include <sys/types.h>
3. #include <sys/socket.h>
4. #include <netinet/in.h>
5. #include <arpa/inet.h>
6. #include <unistd.h>
7. #include <string.h>
8. #include <stdio.h>
9. #include <stdlib.h>
10. int main(int argc, char* argv[])
11. {
12. int sfd = socket(AF_INET, SOCK_DGRAM, 0);
13. if(sfd == -1)
14. {
15. perror("socket");
16. exit(-1);
17. }
19. struct sockaddr_in toaddr;
20. bzero(&toaddr, sizeof(toaddr));
21. toaddr.sin_family = AF_INET;
22. toaddr.sin_port = htons(atoi(argv[2])); //此处的端口号要跟服务器一样
23. toaddr.sin_addr.s_addr = inet_addr(argv[1]); //此处为服务器的ip
24. sendto(sfd, "hello", 6, 0, (struct sockaddr*)&toaddr, sizeof(struct sockaddr));
26. char buf[512] = {0};
27. struct sockaddr_in fromaddr;
28. bzero(&fromaddr, sizeof(fromaddr));
29. int fromaddrlen = sizeof(struct sockaddr);
30. if(recvfrom(sfd, buf, sizeof(buf), 0, (struct sockaddr*)&fromaddr, &fromaddrlen) == -1)
31. {
32. perror("recvfrom");
33. close(sfd);
34. exit(-1);
35. }
36. printf("receive from %s %d,the message is:%s\n", inet_ntoa(fromaddr.sin_addr), ntohs(fromaddr.sin_port), buf);
38. close(sfd);
39. }

Example2：

1. //UDP发送文件,先发文件大小,再发文件内容
2. //服务器端：
3. #include <sys/types.h>
4. #include <sys/socket.h>
5. #include <netinet/in.h>
6. #include <arpa/inet.h>
7. #include <unistd.h>
8. #include <fcntl.h>
9. #include <sys/stat.h>
10. #include <string.h>
11. #include <stdio.h>
12. #include <stdlib.h>
13. main()
14. {
15. int sfd = socket(AF_INET, SOCK_DGRAM, 0);
16. if(sfd == -1)
17. {
18. perror("socket");
19. exit(-1);
20. }
22. struct sockaddr_in saddr;
23. bzero(&saddr, sizeof(saddr));
24. saddr.sin_family = AF_INET;
25. saddr.sin_port = htons(8888);
26. saddr.sin_addr.s_addr = INADDR_ANY;
27. if(bind(sfd, (struct sockaddr*)&saddr, sizeof(struct sockaddr)) == -1)
28. {
29. perror("bind");
30. close(sfd);
31. exit(-1);
32. }
34. char buf[512] = {0};
35. struct sockaddr_in fromaddr;
36. bzero(&fromaddr, sizeof(fromaddr));
37. int fromaddrlen = sizeof(struct sockaddr);
38. if(recvfrom(sfd, buf, sizeof(buf), 0, (struct sockaddr*)&fromaddr, &fromaddrlen) == -1)
39. {
40. perror("recvfrom");
41. close(sfd);
42. exit(-1);
43. }
44. printf("receive from %s %d,the message is:%s\n", inet_ntoa(fromaddr.sin_addr), ntohs(fromaddr.sin_port), buf);
45. FILE* fp = fopen("1.txt","rb");
46. struct stat st; //用于获取文件内容的大小
47. stat("1.txt", &st);
48. int filelen = st.st_size;
49. sendto(sfd, (void*)&filelen, sizeof(int), 0, (struct sockaddr*)&fromaddr, sizeof(struct sockaddr));
50. while(!feof(fp)) //表示没有到文件尾
51. {
52. int len = fread(buf,1,sizeof(buf),fp);
53. sendto(sfd, buf, len, 0, (struct sockaddr*)&fromaddr, sizeof(struct sockaddr));
54. }
56. close(sfd);
57. }

1. //客户端：
2. #include <sys/types.h>
3. #include <sys/socket.h>
4. #include <netinet/in.h>
5. #include <arpa/inet.h>
6. #include <unistd.h>
7. #include <string.h>
8. #include <stdio.h>
9. #include <stdlib.h>
10. #define BUFSIZE 512
11. int main(int argc, char* argv[])
12. {
13. int sfd = socket(AF_INET, SOCK_DGRAM, 0);
14. if(sfd == -1)
15. {
16. perror("socket");
17. exit(-1);
18. }
20. struct sockaddr_in toaddr;
21. bzero(&toaddr, sizeof(toaddr));
22. toaddr.sin_family = AF_INET;
23. toaddr.sin_port = htons(atoi(argv[2]));
24. toaddr.sin_addr.s_addr = inet_addr(argv[1]);
25. sendto(sfd, "hello", 6, 0, (struct sockaddr*)&toaddr, sizeof(struct sockaddr));
27. char buf[BUFSIZE] = {0};
28. struct sockaddr_in fromaddr;
29. bzero(&fromaddr, sizeof(fromaddr));
30. int fromaddrlen = sizeof(struct sockaddr);
31. int filelen = 0; //用于保存文件长度
32. FILE* fp = fopen("2.txt","w+b");
33. //接收文件的长度
34. recvfrom(sfd, (void*)&filelen, sizeof(int), 0, (struct sockaddr*)&fromaddr, &fromaddrlen);
35. printf("the length of file is %d\n",filelen);
36. printf("Create a new file!\n");
37. printf("begin to reveive file content!\n");
38. //接收文件的内容
39. while(1)
40. {
41. int len = recvfrom(sfd, buf, sizeof(buf), 0, (struct sockaddr*)&fromaddr, &fromaddrlen);
42. if(len < BUFSIZE)
43. //如果接收的长度小于BUFSIZE，则表示最后一次接收，此时要用break退出循环
44. {
45. fwrite(buf,sizeof(char),len,fp);
46. break;
47. }
48. fwrite(buf,sizeof(char),len,fp);
49. }
50. printf("receive file finished!\n");
51. close(sfd);
52. }

5. 协议的选择

• 对数据要求高可靠性的应用需选择TCP协议，如验证、密码字段的传送都是不允许出错的，而对数据的可靠性要求不那么高的应用可选择UDP传送；
• TCP协议在传送过程中要使用三次握手、重传确认等手段来保证数据传输的可靠性。使用TCP协议会有较大的时延，因此不适合对实时性要求较高的应用，如VOIP、视频监控等。相反，UDP协议则在这些应用中能发挥很好的作用；
• 由于TCP协议的提出主要是解决网络的可靠性问题，它通过各种机制来减少错误发生的概率。因此，在网络状况不是很好的情况下需选用TCP协议（如在广域网等情况），但是若在网络状况很好的情况下（如局域网等）就不需要再采用TCP协议，而建议选择UDP协议来减少网络负荷；