使用socket实现TCP和UDP传输

转载自：https://blog.csdn.net/timmiy/article/details/51946093

https://blog.csdn.net/timmiy/article/details/52016946

socket由IP地址和端口号组成，可以通过TCP，UDP，IP协议实现不同虚拟机或不同计算机之间的通信，效率较高。

（一）运用TCP协议进行socket通信

TCP是面向连接的，它在进行通信之前，需要双方先进行沟通，然后才能进行通信。而且TCP是以数据流的方式进行数据传递，会自动的进行拆包和组包的过程。所以TCP的连接是比较可靠的，但是它的传输速度也因此相对较慢。接下来分别介绍服务端和客户端，看下如何在windows系统中用C++语言实现TCP通信。

在windows中，要想进行socket网络操作，必须包含一个名叫做WinSock2.h(或者WinSock.h)，如果包含的是WinSock2.h则必须在windows.h之前，否则会产生一些重定义的编译错误。包含完头文件之后，还要链接一个库文件ws2_32.lib，完成之后，我们就可以开始进行TCP服务端和客户端的编写了。（如果使用Visual Studio编译器运行，VS会自动生成.h文件，不需要自己手动包含和链接库文件。）

1.1 服务端

首先给出服务端的实现思路：

1.初始化socket环境 -> 2.创建服务器socket -> 3.初始化端口和ip地址调用bind进行绑定 -> 4.调用listen进行监听 -> 5.调用accept接收客户端的请求 -> 6.调用recv和send与客户端进行通信 -> 7.调用WSACleanup及closesocket关闭网络环境和socket

下面是具体的实现示例程序：

1. #include <stdio.h>
2. #include <winsock2.h> // 必须包含windwos.h之前
3. #include <Windows.h>
5. #pragma comment(lib,"ws2_32.lib")
7. #define PORT 6000
8. DWORD WINAPI clientProc(LPARAM lparam) //通信接收和发送数据过程函数(recv、send)
9. {
10. SOCKET sockClient = (SOCKET)lparam;
11. char buf[1024];
12. while (TRUE)
13. {
14. memset(buf, 0, sizeof(buf));
16. // 接收客户端的一条数据
17. int ret = recv(sockClient, buf, sizeof(buf), 0);
18. //检查是否接收失败
19. if (SOCKET_ERROR == ret)
20. {
21. printf("socket recv failed\n");
22. closesocket(sockClient);
23. return -1;
24. }
25. else
26. {
27. printf("%s\r\n", buf);
28. }
29. // 0 代表客户端主动断开连接
30. if (ret == 0)
31. {
32. printf("client close connection\n");
33. closesocket(sockClient);
34. return -1;
35. }
37. // 发送数据
38. char *p = "hello client";
39. ret = send(sockClient, p, strlen(p), 0);
40. //检查是否发送失败
41. if (SOCKET_ERROR == ret)
42. {
43. printf("socket send failed\n");
44. closesocket(sockClient);
45. return -1;
46. }
47. }
48. closesocket(sockClient);
49. return 0;
50. }
51. bool InitNetEnv() //网络环境初始化函数
52. {
53. // 进行网络环境的初始化操作
54. WSADATA wsa;
55. if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0)
56. {
57. printf("WSAStartup failed\n");
58. return false;
59. }
60. return true;
61. }
63. int main(int argc, char * argv[])
64. {
65. if (!InitNetEnv()) //Step1：初始化网络环境
66. {
67. return -1;
68. }
70. // Step2：初始化完成，创建一个TCP的socket
71. //socket(协议域，指定socket类型，指定协议)
72. SOCKET sServer = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
73. //检查是否创建失败
74. if (sServer == INVALID_SOCKET)
75. {
76. printf("socket failed\n");
77. return -1;
78. }
79. printf("Create socket OK\n");
81. //Step3：进行绑定操作(bind)
82. SOCKADDR_IN addrServ;
83. addrServ.sin_family = AF_INET; // 协议簇为IPV4的
84. addrServ.sin_port = htons(PORT); // 端口 因为本机是小端模式，网络是大端模式，调用htons把本机字节序转为网络字节序
85. addrServ.sin_addr.S_un.S_addr = INADDR_ANY; // ip地址，INADDR_ANY表示绑定电脑上所有网卡IP
86. //完成绑定操作
87. //bind(socket描述字， 绑定给listenfd的协议地址，地址长度)
88. int ret = bind(sServer, (sockaddr *)&addrServ, sizeof(sockaddr));
89. //检查绑定是否成功
90. if (SOCKET_ERROR == ret)
91. {
92. printf("socket bind failed\n");
93. WSACleanup(); // 释放网络环境
94. closesocket(sServer); // 关闭网络连接
95. return -1;
96. }
97. printf("socket bind OK\n");
99. // Stpe4：绑定成功，进行监听(listen)
100. //listen(socket描述字, socket可以排队的最大连接个数)
101. ret = listen(sServer, 10);
102. //检查是否监听成功
103. if (SOCKET_ERROR == ret)
104. {
105. printf("socket listen failed\n");
106. WSACleanup();
107. closesocket(sServer);
108. return -1;
109. }
110. printf("socket listen OK\n");
112. // 监听成功
113. sockaddr_in addrClient; // 用于保存客户端的网络节点的信息
114. int addrClientLen = sizeof(sockaddr_in);
115. while (TRUE)
116. {
117. //新建一个socket，用于客户端
118. SOCKET *sClient = new SOCKET;
119. //Step5：等待客户端的连接(accept)
120. //accept(服务器的描述字，指向客户端的协议地址， 协议地址的长度)
121. *sClient = accept(sServer, (sockaddr*)&addrClient, &addrClientLen);
122. if (INVALID_SOCKET == *sClient)
123. {
124. printf("socket accept failed\n");
125. WSACleanup();
126. closesocket(sServer);
127. delete sClient;
128. return -1;
129. }
130. //Step6：创建线程为客户端做数据收发
131. CreateThread(0, 0, (LPTHREAD_START_ROUTINE)clientProc, (LPVOID)*sClient, 0, 0);
132. }
134. closesocket(sServer); //关闭网络环境和socket
135. WSACleanup();
136. return 0;
137. }

下面对代码中的实现函数进行说明。

1）首先，要进行网络操作，我们先要进行一下网络环境的初始化。WSAStartup函数就是用来初始化网络环境的。其声明如下：

1. int WSAStartup(
2. WORD wVersionRequested, //版本号，一般使用2.2版本
3. LPWSADATA lpWSAData <span style="white-space:pre"> </span>//WSAData地址
4. );

函数的第二个参数，接收一个WSAData结构的指针，该结构里边包含了版本号，我们传递的版本号会对该结构里边的版本号进行初始化。

2）初始化完成之后，我们需要创建一个socket(套接字)，这个套接字相当于管道，用于客户端和服务端的连接。调用socket函数我们可以创建一个套接字，声明如下：

1. SOCKET socket(
2. int af, //IP协议簇
3. int type, //套接字类型，TCP应该用SOCK_STREAM
4. int protocol<span style="white-space:pre"> </span> //协议
5. );

其实，socket也是一个内核对象，但是它没有内核对象所拥有的明显标志，安全属性。

3）创建好套接字后呢，我们需要告诉操作系统需要在哪个地址和端口上进行网络操作，相当于管道通信中绑定到标准输入输出口上。绑定的时候，需要有一个SOCKADDR_IN这个结构体，声明如下：

1. struct sockaddr_in{
2. short sin_family;//协议簇
3. unsigned short sin_port;//端口
4. struct in_addr sin_addr;//ip地址
5. char sin_zero[8];//为了设置和SOCKADDR结构等长的补充字节
6. };

还有一个SOCKADDR结构和上面这个的功能完全一样，但是SOCKADDR这个结构里边只有两个成员，一个是协议簇，一个是14个字节的char数组，为了让我们更好的编写代码，于是将char数组拆解成SOCKADDR_IN 中后三个成员。

初始化完端口，地址等信息后，需要调用bind函数，来完成绑定操作，声明如下：

1. int bind(
2. SOCKET s, //我们创建的那个socket
3. const struct sockaddr FAR *name, //sockaddr结构指针
4. int namelen //sockaddr长度
5. );

4）绑定之后，我们还需要调用listen函数来进行监听操作，这个操作呢，就相当于门卫一样了，如果有人来，就告诉你一声，这就是监听。该函数声明如下：

1. int listen(
2. SOCKET s, //我们创建的socket
3. int backlog //最大连接的队列长度
4. );

第二个参数backlog呢，我们一般不要给的太大，这就好比你去交电费，还要进行排队等候，如果排队的人多了，这就会给你留下不好的体验，因此随便给个10，100的就行了。

5）监听完成之后，我们就可以进行接收客户端的连接了，我们需要调用accept这个函数来进行接客。声明如下：

1. SOCKET accept(
2. SOCKET s, //我们监听的那个socket
3. struct sockaddr FAR *addr, //我们需要传递一个sockaddr的地址，用于保存客户端的地址
4. int FAR *addrlen //sockaddr的长度指针
5. );

6）接完客之后，我们就可以进行通信了，需要调用recv和send两个函数来进行收发数据，它们的声明如下：

1. int recv(
2. SOCKET s, //客户端的socket
3. char FAR *buf, //接收的缓冲区
4. int len, //缓冲区的大小
5. int flags //标志位，一般为0
6. );
8. int send(
9. SOCKET s, //客户端的socket
10. const char FAR *buf, //发送数据的缓冲区
11. int len, //缓冲区的大小
12. int flags //标志位，一般为0
13. );

7）当我们传输完数据后，应该调用WSACleanup和closesocket来进行关闭网络环境和套接字。声明如下：

1. int WSACleanup (void);
3. int closesocket(
4. SOCKET s //要关闭的套接字
5. );

1.2 客户端

首先给出使用TCP协议在客户端的思路：

1.初始化socket环境 -> 2.创建客户端socket -> 3.调用connect连接指定的服务器 -> 4.调用recv和send与服务端进行通信 -> 5.调用WSACleanup及closesocket关闭网络环境和socket

下面是具体的实现程序：

1. #include <stdio.h>
2. #include <winsock2.h>
3. #include <Windows.h>
5. #pragma comment(lib,"ws2_32.lib")
6. #define PORT 6000
8. int main(int argc, char * argv[])
9. {
10. //Step1：初始化网络环境
11. WSADATA wsa;
12. if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0)
13. {
14. printf("WSAStartup failed\n");
15. return -1;
16. }
18. // Step2：初始化完成，创建一个TCP的socket
19. //socket(协议域，指定socket类型，指定协议)
20. SOCKET sServer = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
21. if (sServer == INVALID_SOCKET)
22. {
23. printf("socket failed\n");
24. return -1;
25. }
27. //Step3：指定连接的服务端信息(bind)
28. SOCKADDR_IN addrServ;
29. addrServ.sin_family = AF_INET;
30. addrServ.sin_port = htons(PORT);
31. //客户端只需要连接指定的服务器地址，127.0.0.1是本机的回环地址
32. addrServ.sin_addr.S_un.S_addr = inet_addr("10.170.54.98");
34. // 服务器Bind 客户端是进行连接
35. //connect(客户端的socket描述字, 服务器的socket地址, 服务器地址长度)
36. int ret = connect(sServer, (SOCKADDR*)&addrServ, sizeof(SOCKADDR));//开始连接
37. if (SOCKET_ERROR == ret)
38. {
39. printf("socket connect failed\n");
40. WSACleanup();
41. closesocket(sServer);
42. return -1;
43. }
45. //Step4：连接成功后，就可以进行通信了(send,recv)
46. char szBuf[1024];
47. memset(szBuf, 0, sizeof(szBuf));
48. sprintf_s(szBuf, sizeof(szBuf), "Hello server");
49. //当服务端是recv的时候，客户端就需要send，若两端同时进行收发则会卡在这里，因为recv和send都是阻塞的
50. ret = send(sServer, szBuf, strlen(szBuf), 0);
51. if (SOCKET_ERROR == ret)
52. {
53. printf("socket send failed\n");
54. closesocket(sServer);
55. return -1;
56. }
58. ret = recv(sServer, szBuf, sizeof(szBuf), 0);
59. if (SOCKET_ERROR == ret)
60. {
61. printf("socket recv failed\n");
62. closesocket(sServer);
63. return -1;
64. }
65. printf("%s\n", szBuf);
67. closesocket(sServer); //Step5：关闭已连接socket描述字
68. WSACleanup();
69. system("pause");
70. return 0;
71. }

下面对代码中的函数进行解释。

（1-2）客户端比较简单，前面的部分和服务端都基本相同（初始化、建立socket）

（3）在绑定操作上会有所差别。服务端绑定的IP地址是本机所有网卡的IP，而客户端只需要绑定一个即可，因为对客户端来说，我们只需连接指定的服务器。赋值完SOCKADDR_IN结构之后，服务端会调用bind函数，而客户端呢，需要调用connect函数，其声明如下：

1. int connect(
2. SOCKET s, //要进行连接的socket
3. const struct sockaddr FAR *name, //SOCKADDR结构地址
4. int namelen //SOKADDR大小
5. );

（4）连接成功后，就可以和服务端进行通信了，调用recv和send来进行收发数据。需要注意的是，如果服务端程序先进行recv操作，则我们应该在客户端先进行send操作，若两个同时进行相同的操作的话，则会卡在当前的位置，因为recv和send都是阻塞型的函数。

（5）当通信完之后，就可以关闭连接了。文章开头讲过，当客户端和服务端刚开始连接的时候呢，两者会先进行沟通，这个沟通需要3个步骤来完成，我们称之为3次握手，同样的关闭连接的时候，需要进行4个步骤来完成，我们称之为4次握手。如果你是粗暴型的，直接拔网线呢，它也会完成其中的两次步骤，作为应用层开发，并不需要深究其中的原理，若感兴趣，可自行查找资料。

在两个Visual Studio中依次运行服务端及客户端程序，得到socket通信结果如下：

（二）运用UDP协议进行socket通信

相比TCP来说，UDP相对比较简单，刚开始的时候，和TCP一样都需要先进行网络环境的初始化，即调用WSAStartup函数。然后呢，我们也需要创建一个socket，这个socket和TCP的那个socket不同，上篇提过TCP创建一个socket调用socket函数时，第二个参数为SOCK_STREAM，而UDP则需要给定一个SOCK_DGRAM，然后在第三个参数上给一个IPPROTO_UDP，这样我们就创建好了一个UDP的socket。

接下来，也和TCP一样，指定SOCKADDR_IN的地址信息（端口，ip），指定完之后呢，若是客户端，则可以直接就进行通信了，若是服务端，则还需要增加一步bind操作，当我们调用bind函数，进行绑定后，服务端就可以和客户端进行通信了。而TCP的服务端还有两个步骤，一个是listen，一个是accept，UDP省略了这两个步骤。

2.1 服务端

首先给出使用UDP协议实现socket通信的服务端的实现思路：

1.初始化socket环境 -> 2.创建服务器socket -> 3.初始化端口和ip地址调用bind进行绑定 -> 4.调用recvfrom和sendto与客户端进行通信 -> 5.调用WSACleanup及closesocket关闭网络环境和socket

下面是具体的实现代码：

1. #include <stdio.h>
2. #include <winsock2.h>
3. #include <Windows.h>
5. #pragma comment(lib,"ws2_32.lib")
6. #define PORT 6000
8. int main(int argc, char* argv[])
9. {
10. //Step1：初始化网络环境
11. WSADATA wsa;
12. if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0)
13. {
14. printf("WSAStartup failed\n");
15. return -1;
16. }
18. //Step2：建立一个UDP的socket
19. //建立socket参数：socket(协议域，指定socket类型，指定协议)（和TCP协议后两个参数不同，都为IP协议族）
20. SOCKET sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
21. if (sock == SOCKET_ERROR)
22. {
23. printf("create socket failed\n");
24. return -1;
25. }
27. //Step3：绑定地址信息
28. sockaddr_in serverAddr;
29. serverAddr.sin_family = AF_INET; // 协议簇为IPV4的
30. serverAddr.sin_port = htons(PORT); // 端口 因为本机是小端模式，网络是大端模式，调用htons把本机字节序转为网络字节序
31. serverAddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY); // ip地址，INADDR_ANY表示绑定电脑上所有网卡IP
33. //bind(socket描述字， 绑定给listenfd的协议地址，地址长度)
34. bind(sock, (sockaddr*)&serverAddr, sizeof(sockaddr));
35. //Step5：与客户端进行通信
36. char buf[512];
37. while (TRUE)
38. {
39. memset(buf, 0, 512);
40. // 网络节点的信息，用来保存客户端的网络信息
41. sockaddr_in clientAddr;
42. memset(&clientAddr, 0, sizeof(sockaddr_in));
44. int clientAddrLen = sizeof(sockaddr);
45. //接收客户端发来的数据
46. //recvfrom参数：socket名称，接收数据的缓冲区，缓冲区大小，标志位（调用操作方式），sockaddr结构地址，sockaddr结构大小地址
47. //sockaddr地址用来保存从哪里发来，和发送到哪里的地址信息
48. int ret = recvfrom(sock, buf, 512, 0, (sockaddr*)&clientAddr, &clientAddrLen);
50. //inet_ntoa函数转化为ip，ntohs函数转化为端口号
51. printf("Recv msg:%s from IP:[%s] Port:[%d]\n", buf, inet_ntoa(clientAddr.sin_addr), ntohs(clientAddr.sin_port));
53. // 发一个数据包返回给客户
54. //sendto参数：socket名称，发送数据的缓冲区，缓冲区大小，标志位（调用操作方式），sockaddr结构地址，sockaddr结构大小地址
55. sendto(sock, "Hello World!", strlen("Hello World!"), 0, (sockaddr*)&clientAddr, clientAddrLen);
56. printf("Send msg back to IP:[%s] Port:[%d]\n", inet_ntoa(clientAddr.sin_addr), ntohs(clientAddr.sin_port));
57. }
58. return 0;
59. }

前面提到TCP进行数据的收发是通过recv和send两个API来进行数据的收发的。而UDP也需要两个函数，叫做recvfrom和sendto，这两个和TCP那两个有点不同，其声明如下：

1. int recvfrom(
2. SOCKET s, //socket
3. char FAR* buf, <span style="white-space:pre"> </span>//接收数据的缓冲区
4. int len, //缓冲区的大小
5. int flags, //标志位，调用操作方式
6. struct sockaddr FAR *from, //sockaddr结构地址
7. int FAR *fromlen //sockaddr结构大小地址
8. );
9. int sendto(
10. SOCKET s, //socket
11. const char FAR *buf, //发送数据的缓冲区
12. int len, //缓冲区大小
13. int flags, //标志位，调用操作方式
14. const struct sockaddr FAR *to, //sockaddr结构地址
15. int tolen //sockaddr结构大小地址
16. );

注意，这两个函数里边有一个sockaddr结构地址，它是用来保存该数据发送者的信息的。上篇提过，TCP是面向连接的，它在通信之前需要进行三次握手来确定双方是否已经准备好了。因此，双方很清楚数据是从哪里来的。而UDP是面向数据包的，因此就好像寄快递一样，你必须在快递上写一张纸条，上面填好姓名，地址等信息，填好之后，接收者才知道该东西是由谁寄过来的。因此，上面两个函数提供了sockaddr结构的地址，用于保存从哪里发来的和发送到哪里的地址信息。

2.2 客户端

给出使用UDP协议实现socket通信的客户端的示例代码：

1.初始化socket环境 -> 2.创建客户端socket -> 3.调用recvfrom和sendto与服务端进行通信 -> 4.WSACleanup及closesocket关闭网络环境和socket

下面是具体的实现程序：

1. #include <stdio.h>
2. #include <winsock2.h>
3. #include <Windows.h>
5. #pragma comment(lib,"ws2_32.lib")
6. #define PORT 6000
7. int main(int argc, char* argv[])
8. {
9. //Step1：初始化网络环境
10. WSADATA wsa;
11. if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0)
12. {
13. printf("WSAStartup failed\n");
14. return -1;
15. }
17. //Step2：建立一个UDP的socket
18. //建立socket参数：socket(协议域，指定socket类型，指定协议)（和TCP协议后两个参数不同，都为IP协议族）
19. SOCKET sockClient = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
20. if (sockClient == INVALID_SOCKET)
21. {
22. printf("create socket failed\n");
23. return -1;
24. }
26. // 申明一个网络地址信息的结构体，保存服务器的地址信息
27. sockaddr_in addr = { 0 };
28. addr.sin_family = AF_INET; // 协议簇为IPV4的
29. addr.sin_port = htons(PORT); // 端口 因为本机是小端模式，网络是大端模式，调用htons把本机字节序转为网络字节序
30. addr.sin_addr.S_un.S_addr = inet_addr("10.170.54.98"); // 服务器的ip地址
31. //Step3：与服务端进行通信
32. char buf[] = "client test!";
33. //发送数据
34. //sendto参数：socket名称，接收数据的缓冲区，缓冲区大小，标志位（调用操作方式），sockaddr结构地址，sockaddr结构大小地址
35. int dwSent = sendto(sockClient, buf, strlen(buf), 0, (SOCKADDR *)&addr, sizeof(SOCKADDR));
36. if (dwSent == 0)
37. {
38. printf("send %s failed\n", buf);
39. return -1;
40. }
41. printf("send msg:%s\n", buf);
43. char recvBuf[512];
44. memset(recvBuf, 0, 512);
46. sockaddr_in addrSever = { 0 };
47. int nServerAddrLen = sizeof(sockaddr_in);
49. // 接收数据
50. //recvfrom参数：socket名称，接收数据的缓冲区，缓冲区大小，标志位（调用操作方式），sockaddr结构地址，sockaddr结构大小地址
51. int dwRecv = recvfrom(sockClient, recvBuf, 512, 0, (SOCKADDR *)&addrSever, &nServerAddrLen);
52. printf("Recv msg from server : %s\n", recvBuf);
54. //Step4：关闭SOCKET连接
55. closesocket(sockClient);
57. //清理网络环境
58. WSACleanup();
59. system("pause");
60. return 0;
61. }

在两个Visual Studio中依次运行服务端及客户端程序，得到socket通信结果如下：