使用socket实现TCP和UDP传输

最新推荐文章于 2024-07-31 08:15:00 发布
最新推荐文章于 2024-07-31 08:15:00 发布
阅读量569 收藏 3
点赞数 1
原文链接：https://my.oschina.net/u/1777508/blog/3100868
版权

转载自：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通信结果如下：

转载于:https://my.oschina.net/u/1777508/blog/3100868

chengqian7320
关注
socket编程（基于TCP/UDP协议的通信）
GLH_2236504154的博客
08-30 527
基于tcp的通信 TCP把连接作为最基本的对象，每一条TCP连接都有两个端点，这种断点我们叫作套接字（socket） 服务端： import socket # 1. 创建一个socket对象; # family指定使用IP协议的版本: IPV4:AF_INET; ipv6: AF_INET6 # type指定传输层使用的协议类型:TCP(SOCKET.SOCK_STREAM), UDP(SOCK...
socket实现UDP数据传输
无敌海盗的博客
01-01 1126
UDP： User Datagram Protocol的简称， 中文名是用户数据包协议，是 OSI 参考模型中一种无连接的传输层协议，提供面向事务的简单不可靠信息传送服务。 特点：每个数据报中都给出了完整的地址信息，因此无需要建立发送方和接收方的连接。 UDP传输数据时是有大小限制的，每个被传输的数据报必须限定在64KB之内。 UDP是一个不可靠的协议，发送方所发送的数据报并不一定以相同的次
基于Socket的UDP和TCP编程介绍
华清远见 | 程序员的学习天堂
11-30 1878
作者：王珊珊，华清远见嵌入式学院讲师。一、概述TCP（传输控制协议）和UDP（用户数据报协议是网络体系结构TCP/IP模型中传输层一层中的两个不同的通信协议。TCP：传输控制协议，一种面向连接的协议，给用户进程提供可靠的全双工的字节流，TCP套接口是字节流套接口(stream socket)的一种。UDP：用户数据报协议。UDP是一种无连接协议。UDP套接口是数据报套接口(da
UDP协议详解——使用Socket通信
最新发布
qq_3517289697的博客
07-31 1325
UDP（UserDatagramProtocol）是一个简单的面向消息的传输层协议，尽管UDP提供标头和有效负载的完整性验证（通过校验和），但它不保证向上层协议提供消息传递，并且UDP层在发送后不会保留UDP 消息的状态。因此，UDP有时被称为不可靠的数据报协议。如果需要传输可靠性，则必须在用户应用程序中实现。UDP使用具有最小协议机制的简单无连接通信模型。UDP提供数据完整性的校验和，以及用于在数据报的源和目标寻址不同函数的端口号。它没有握手对话，因此将用户的程序暴露在底层网络的任何不可靠的方面。
Python网络编程之socket编程（一）--使用TCP和UDP客户端和服务器通信
FreeeLinux's blog
07-30 7147
本文用python进行socket编程，实现客户端和服务器互相发送字符串，并在标准输出打印。 下面是客户端程序： #!/usr/bin/python import socket HOST = 'localhost' PORT = 6666 s=socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((HOST, PORT))
Python使用套接字(socket)实现UDP与TCP通信 Ｏ(≧▽≦)Ｏ Python小知识
寻觅的博客
01-14 1296
文章目录开放式系统互联模型IP端口 开放式系统互联模型 官方的模型分为七层，但在实际使用中大多数公司会把这个模型分为四层或者五层。 而在python建立一个简单的主机间的通信，我们需要了解IP、TCP与UDP IP 相比IP对大多数人来说都并不陌生，IP是什么,在Windows下,我们可以通过ipconfig来查看自己的IP等相关网络配置,而在linux下我们可以通过ifconfig来查看自己的...
socket实现TCP、UDP连接
qq_37002901的博客
01-25 423
转载自简单理解socket 什么是socket 我们经常把socket翻译为套接字，socket是在应用层和传输层之间的一个抽象层，它把TCP/IP层复杂的操作抽象为几个简单的接口供应用层调用已实现进程在网络中通信。 socket通信流程 socket是"打开—读/写—关闭"模式的实现，以使用TCP协议通讯的socket为例，其交互流程大概是这样子的 主要流程： 服务器根据地址类型（ipv4,...
C语言编写基于TCP和UDP协议的Socket通信程序示例
09-02
在本文中，我们将深入探讨如何使用C语言编写基于TCP和UDP协议的Socket通信程序。首先，我们来看TCP协议的客户端和服务器端。 TCP（Transmission Control Protocol）是一种面向连接的、可靠的传输协议，它确保了数据...
TCP&UDP调试工具 SocketTool
10-31
同时，配合TCP&UDP SocketTool调试教程，开发者可以更深入地学习如何使用该工具，提升开发和调试技能。例如，CSDN博客和道客巴巴上的相关教程可能涵盖如何设置参数、发送不同类型的请求、解析响应以及处理异常情况等...
Android中实现TCP和UDP传输实例
09-03
对于TCP，使用`Socket`类进行连接，而UDP则使用`DatagramPacket`进行数据封装和发送。 TCP适合于需要保证数据完整性和顺序的场景，如文件传输、网页浏览等。UDP则适用于实时性要求高但可以容忍部分数据丢失的场景，...
WebSocket Socket TCP/UDP
11-24
WebSocket Socket通信源码例子，TCP/UDP都有，适合网络通信入门的练习与学习，有一个在线的聊天室系统
SuperSocket-master_Socket基于TCP、UDP
06-27
Socket分为两种类型：流式Socket（TCP）和数据报Socket（UDP）。 1. **TCP（Transmission Control Protocol）** - TCP是一种面向连接的、可靠的传输层协议，它通过三次握手建立连接，并在数据传输前确保连接的可靠...
使用Socket实现TCP和UDP网络程序设计
ma2622595880的博客
04-28 4270
1、传输控制协议（TCP）和用户数据报协议（UDP）（1）TCP协议是一种以固线连线为基础的协议，它提供两台计算机间可靠的数据传送。TCP可以保证从一端数据送至连接的另一端时，数据能够确实送达，而且抵达的数据的排列顺序和送出时的顺序相同。因此，TCP协议适合可靠性要求比较高的场合。（2）UDP是无连接通信协议，不保证可靠数据的传输，但能够向若干个目标发送数据，接收发自若干个源的数据。UDP是以独立...
Socket TCP/UDP
晓谈物联的专栏
01-27 601
这篇博客，主要是用来记录我在TCP/UDP编程上的一些笔记，有些资料是在网络上搜索的。 struct sockaddr_in { shortsin_family; //Addressfamily一般来说AF_INET（地址族）PF_INET（协议族） unsignedshortsin_port;       /*Portnumber(必须要采用网络数据格式,普通数字可以用htons
Socket，TCP，UDP
weixin_46987432的博客
08-23 633
Socket，TCP，UDP
Socket/TCP/UDP
m0_59489141的博客
11-22 245
Socket套接字是网络通信的编程接口，而TCP是一种面向连接的、可靠的传输协议。在使用TCP进行网络通信时，应用程序可以使用Socket套接字来建立连接、发送和接收数据。Socket套接字是实现TCP协议的一种方式。socket可以看作实现网络传输的对象Socket套接字可以用于实现不同的网络协议，包括TCP、UDP等使用创建了一个Socket对象。Socket类通常用于TCP、UDP通信。Socket套接字是用于网络通信的编程接口，它提供了一种机制，使得应用程序能够通过网络进行数据传输。
使用 python socket 执行远程服务器程序
rongDang的博客
07-30 2155
参考：https://www.runoob.com/python/python-socket.html Socket又称"套接字"，应用程序通常通过"套接字"向网络发出请求或者应答网络请求，使主机间或者一台计算机上的进程间可以通讯。 socket函数 python中使用socket()函数创建套接字，如下所示 import socket # 参数1:family, 套接字家族可以使用AF...
Socket套接字编程(实现TCP和UDP的通信)
热门推荐
书生-w的博客
04-12 1万+
​ Socket（套接字），是网络上两个程序之间实现数据交换的一端，它既可以发送请求，也可以接受请求，一个Socket由一个IP地址和一个端口号唯一确定，利用Socket能比较方便的实现两端（服务端和客户端）的网络通信。 ​ 在Java中，有专门的Socket类来处理用户请求和响应，学习使用Socket类方法，就可以实现两台机器之间通信。
Java实现TCP与UDP文件传输及Socket编程
"TCPUDP文件传输的Java实现，利用Socket进行信息传递，涉及TCP和UDP两种协议的简单Client/Server程序设计，包括字符串传输、文件传输及可能的扩展功能。实验要求学生熟悉Socket编程的基本步骤，理解TCP与UDP的主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值