使用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>
4.  
    
5.  
   #pragma comment(lib,"ws2_32.lib")
6.  
    
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));
15.  
     
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.  
    }
36.  
     
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.  
    }
62.  
     
63.  
    int main(int argc, char * argv[])
64.  
    {
65.  
    if (!InitNetEnv()) //Step1：初始化网络环境
66.  
    {
67.  
    return -1;
68.  
    }
69.  
     
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");
80.  
     
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");
98.  
     
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");
111.  
      
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.  
     }
133.  
      
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.  
   );
7.  
    
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);
2.  
    
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>
4.  
    
5.  
   #pragma comment(lib,"ws2_32.lib")
6.  
   #define PORT 6000
7.  
    
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.  
    }
17.  
     
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.  
    }
26.  
     
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");
33.  
     
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.  
    }
44.  
     
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.  
    }
57.  
     
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);
66.  
     
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>
4.  
    
5.  
   #pragma comment(lib,"ws2_32.lib")
6.  
   #define PORT 6000
7.  
    
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.  
    }
17.  
     
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.  
    }
26.  
     
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
32.  
     
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));
43.  
     
44.  
    int clientAddrLen = sizeof(sockaddr);
45.  
    //接收客户端发来的数据
46.  
    //recvfrom参数：socket名称，接收数据的缓冲区，缓冲区大小，标志位（调用操做方式），sockaddr结构地址，sockaddr结构大小地址
47.  
    //sockaddr地址用来保存从哪里发来，和发送到哪里的地址信息
48.  
    int ret = recvfrom(sock, buf, 512, 0, (sockaddr*)&clientAddr, &clientAddrLen);
49.  
     
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));
52.  
     
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>
4.  
    
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.  
    }
16.  
     
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.  
    }
25.  
     
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);
42.  
     
43.  
    char recvBuf[512];
44.  
    memset(recvBuf, 0, 512);
45.  
     
46.  
    sockaddr_in addrSever = { 0 };
47.  
    int nServerAddrLen = sizeof(sockaddr_in);
48.  
     
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);
53.  
     
54.  
    //Step4：关闭SOCKET链接
55.  
    closesocket(sockClient);
56.  
     
57.  
    //清理网络环境
58.  
    WSACleanup();
59.  
    system("pause");
60.  
    return 0;
61.  
    }

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