Linux——网络编程——UDP

于 2024-07-09 11:51:12 发布
阅读量1k 收藏 9
点赞数 21
文章标签： 网络 linux udp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71703182/article/details/140260269
版权

网络编程之 UDP  用户数据报

1、特性： 无链接  不可靠  大数据   

2、框架： C/S模式 

   server：socket() ===>bind()===>recvfrom()===>close()
   client：socket() ===>bind()===>sendto() ===>close()


注意：socket(）的参数需要调整。

      socket(PF_INET,SOCK_DGRAM,0);

      bind() 客户端是可选的，服务器端是比选的。

1、数据有边界，

2、发送数据和接受数据的次数使一致的，

同时长度要匹配，不然会产生数据丢弃的情况。

3、recvfrom会阻塞

4、  没有recvfrim 不会导致sendto阻塞 

一、发送接收函数：
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
             const struct sockaddr *dest_addr, socklen_t addrlen);

功能：用于UDP协议中向对方发送数据。
参数：sockfd  本地的套接字id
      buff    本地的数据存储，一般是要发送的数据。
      len     要发送的数据长度
      flags   要发送数据方式，0 表示阻塞发送。

      dest_addr: 必选，表示要发送到的目标主机信息结构体。
      addrlen ：目标地址长度。

返回值：成功  发送的数据长度
        失败   -1；


二ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                  struct sockaddr *src_addr, socklen_t *addrlen);

功能：用于UDP协议中获取对方发送的数据。
参数：sockfd 本地的套接字id
      buff   要存储数据的内存区，一般是数组或者动态内存。
      len    要获取的数据长度，一般是buff的大小。
      flags  获取方式，0 阻塞

      src_addr 可选，表示对方的地址信息结构体，
                  如果为NULL，表示不关心对方地址。
      addrlen  对方地址信息结构体大小。
                  如果对方地址是NULL，则该值也为NULL。
返回值：成功 接收到的数据长度
        失败  -1；

sever.c

#include <stdio.h>     // 标准输入输出库  
#include <stdlib.h>    // 标准库，包含exit等函数  
#include <unistd.h>    // UNIX标准函数定义，如sleep（但这里未使用）  
#include <string.h>    // 字符串操作函数，如bzero（注意：bzero已被弃用，建议使用memset）  
#include <sys/types.h> // 基本数据类型定义  
#include <sys/socket.h> // 套接字编程接口  
#include <netinet/in.h> // 定义IPv4地址  
#include <netinet/ip.h> // 虽然包含了，但在本程序中未直接使用到IP协议头  
#include <arpa/inet.h>  // 定义IP地址转换函数  
#include <time.h>       // 包含时间处理函数  

typedef struct sockaddr * (SA);  
  
int main(int argc, char *argv[])  
{  
    // 创建一个UDP套接字  
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);  
    if (-1 == sockfd) {  
        // 如果创建套接字失败，则打印错误信息并退出  
        perror("socket");  
        exit(1);  
    }  
  
    // 定义服务器和客户端地址结构体变量，并清零  
    struct sockaddr_in ser, cli;  
    bzero(&ser, sizeof(ser)); // 使用bzero函数清零结构体，注意bzero函数已被废弃，建议使用memset  
    bzero(&cli, sizeof(cli)); // 同样，建议使用memset  
  
    // 设置服务器地址信息  
    ser.sin_family = AF_INET;  
    ser.sin_port = htons(50000); // 设置服务器端口号，进行网络字节序转换  
    ser.sin_addr.s_addr = inet_addr("192.168.203.128"); // 设置服务器IP地址  
  
    // 将套接字绑定到服务器地址和端口上  
    // 注意：这通常是在服务器程序中完成的，而不是客户端  
    int ret = bind(sockfd, (SA)&ser, sizeof(ser));  
    if (-1 == ret) {  
        perror("bind");  
        exit(1);  
    }  
  
    // 初始化客户端地址长度变量  
    socklen_t len = sizeof(cli);  
  
    // 进入无限循环，接收数据并发送响应  
    while (1) {  
        char buf[512] = {0}; // 定义一个接收缓冲区，并初始化为空  
        // 接收数据，注意这里也更新了cli的地址和长度信息  
        recvfrom(sockfd, buf, sizeof(buf), 0, (SA)&cli, &len);  
  
        // 获取当前时间  
        time_t tm;  
        time(&tm);  
  
        // 将接收到的数据和当前时间追加到buf中（注意：这可能会导致缓冲区溢出）  
        // 更安全的做法是先检查buf中剩余的空间  
        sprintf(buf, "%s %s", buf, ctime(&tm));  
  
        // 发送响应给客户端  
        // 注意：这里使用了之前从recvfrom获取的cli地址和长度信息  
        sendto(sockfd, buf, strlen(buf), 0, (SA)&cli, len);  
        // 但注意：strlen(buf)可能不包含ctime返回的字符串的结束符'\n'  
        // 更安全的做法是使用snprintf来确保不会超出buf的大小  
  
        // 这里没有添加延时，程序会尽可能快地处理每一个接收到的数据包  
    }  
  
    // 注意：由于存在无限循环，这里的close和return语句实际上不会被执行  
    // 但为了代码的完整性，我还是保留了它们  
    // 如果需要退出程序，应该在循环内部添加适当的退出条件  
  
    // 关闭套接字（这行代码实际上不会被执行）  
    close(sockfd);  
    return 0; // 程序正常结束（这行代码实际上也不会被执行）  
}

 client.c

#include <stdio.h>     // 标准输入输出库  
#include <stdlib.h>    // 标准库，包含exit等函数  
#include <unistd.h>    // UNIX标准函数定义，如sleep  
#include <string.h>    // 字符串操作函数，如strlen, bzero  
#include <sys/types.h> // 基本数据类型定义  
#include <sys/socket.h> // 套接字编程接口  
#include <netinet/in.h> // 定义IPv4地址  
#include <netinet/ip.h> // IP协议头  
#include <arpa/inet.h>  // 定义IP地址转换函数  
#include <time.h>       // 包含时间处理函数，但本程序中未使用  
  
// 注意：这里的typedef使用方式不正确，它应该是一个类型别名，而不是一个函数指针  
// 正确的写法应该是：typedef struct sockaddr *SA; 去掉了括号和多余的空格  
typedef struct sockaddr *SA;  
  
int main(int argc, char *argv[])  
{  
    // 创建一个UDP套接字  
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);  
    if (-1 == sockfd) {  
        // 如果创建套接字失败，则打印错误信息并退出  
        perror("socket");  
        exit(1);  
    }  
  
    // 定义服务器地址结构体变量，并清零  
    struct sockaddr_in ser;  
    bzero(&ser, sizeof(ser)); // 使用bzero函数清零结构体
  
    // 设置服务器地址族为IPv4  
    ser.sin_family = AF_INET;  
    // 设置服务器端口号，使用htons函数进行网络字节序转换  
    ser.sin_port = htons(50000);  
    // 设置服务器IP地址，通过inet_addr函数将点分十进制字符串转换为网络字节序  
    ser.sin_addr.s_addr = inet_addr("192.168.203.128");  
  
    // 进入无限循环，持续发送数据并接收响应  
    while (1) {  
        // 定义一个发送缓冲区，并初始化为测试消息  
        char buf[512] = "hello,this is udp test";  
        // 向服务器发送数据  
        sendto(sockfd, buf, strlen(buf), 0, (SA)&ser, sizeof(ser));  
  
        // 清零接收缓冲区，准备接收数据  
        bzero(buf, sizeof(buf));  
        // 接收服务器响应的数据，但注意这里传递了NULL作为地址和长度的参数，这是错误的  
        // 正确的做法应该是提供一个有效的sockaddr_in结构体变量和socklen_t类型的变量来接收客户端地址和长度  
        // 这里我们假设服务器和客户端在同一台机器上，且端口固定，因此可以省略这部分信息  
        // 但为了代码的健壮性和可移植性，建议总是检查来源地址  
        recvfrom(sockfd, buf, sizeof(buf), 0, NULL, NULL); // 这里需要修正  
  
        // 打印接收到的数据  
        printf("buf is %s\n", buf);  
  
        // 暂停一秒后再次发送  
        sleep(1);  
    }  
  
    // 注意：由于存在无限循环，这里的close和return语句实际上不会被执行  
    // 但为了代码的完整性，我还是保留了它们  
    // 如果需要退出程序，应该在循环内部添加适当的退出条件  
    close(sockfd); // 关闭套接字  
    return 0;      // 程序正常结束  
}

练习：
1、根据以上知识点编写UDP测试程序，验证UDP协议的无链接性质。

1、将照片传输到客户端：

注意要将ip地址改成想要发送的ip地址

     ip: ifconfig

server.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <time.h>
#include <fcntl.h>
typedef struct sockaddr * (SA);
int main(int argc, char *argv[])
{
    int sockfd = socket(AF_INET,SOCK_DGRAM,0);
    if(-1 == sockfd)
    {
        perror("socket");
        exit(1);
    }

    // man 7 ip 
    struct sockaddr_in ser,cli;
    bzero(&ser,sizeof(ser));
    bzero(&cli,sizeof(cli));
    ser.sin_family = AF_INET;
    // 大小端转化 host to net short 
    ser.sin_port = htons(50000);
    //ser.sin_addr.s_addr = inet_addr("127.0.0.1");
    ser.sin_addr.s_addr = INADDR_ANY;
    int ret = bind(sockfd,(SA)&ser,sizeof(ser));
    if(-1 == ret)
    {
        perror("bind");
        exit(1);
    }
    socklen_t len = sizeof(cli);
    int fd = open("2.png",O_WRONLY|O_CREAT|O_TRUNC,0666);
    if(-1 == fd)
    {
        perror("open");
        exit(1);
    }
    while(1)
    {
        char buf[512]={0};
        int rd_ret = recvfrom(sockfd,buf,sizeof(buf),0,(SA)&cli,&len);
        if(0 == strcmp(buf,"^_^"))
        {
            break;
        }
        write(fd,buf,rd_ret);
        bzero(buf,sizeof(buf));
        strcpy(buf,"go on");
        sendto(sockfd,buf,strlen(buf),0,(SA)&cli,len);
    }
    close(sockfd);
    close(fd);
    return 0;
}

clink.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <time.h>
#include <fcntl.h>
typedef struct sockaddr * (SA);


int main(int argc, char *argv[])
{
    int sockfd = socket(AF_INET,SOCK_DGRAM,0);
    if(-1 == sockfd)
    {
        perror("socket");
        exit(1);
    }
    struct sockaddr_in ser;
    bzero(&ser,sizeof(ser));
    ser.sin_family = AF_INET;
    // 大小端转化 host to net short 
    ser.sin_port = htons(50000);
    ser.sin_addr.s_addr = inet_addr("192.168.203.128");
    int fd = open("/home/linux/1.png",O_RDONLY);
    if(-1 == fd)
    {
        perror("open");
        exit(1);
    }
    char buf[512]={0};
    while(1)
    {
        bzero(buf,sizeof(buf));
        int rd_ret = read(fd,buf,sizeof(buf));
        if(0==rd_ret)
        {
            break;
        }
        sendto(sockfd,buf,rd_ret,0,(SA)&ser,sizeof(ser));
        bzero(buf,sizeof(buf));
        recvfrom(sockfd,buf,sizeof(buf),0,NULL,NULL);
    }
    
    bzero(buf,sizeof(buf));
    strcpy(buf,"^_^");
    sendto(sockfd,buf,3,0,(SA)&ser,sizeof(ser));
    close(sockfd);
    close(fd);
    return 0;
}

3、将以上知识点融合，考虑如何实现一个基于UDP的聊天室程序。
    要求如下：
    1、要有注册过程，每个客户端必须在服务器端有注册信息。
    2、任意客户端发送的消息必须由服务器转发给所有在线客户端。
    3、任意客户端下线必须通知其他在线用户主机。
    
    服务端：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <time.h>
typedef struct sockaddr * (SA);
typedef enum {CMD_LOGIN,CMD_CHAT,CMD_LOGOUT}TYPE;
typedef struct 
{
    TYPE type;
    char name[50];
    char context[128];

}MSG;
typedef struct 
{
    struct sockaddr_in cli;
    int flag; // 0  free 1 occu
}LIST;
#define MAX 10
LIST list[MAX]={0};
int do_login(int sockfd,MSG* msg,struct sockaddr_in* cli)
{
    int i = 0 ;
    for(i=0;i<MAX;i++)
    {
        if(1 == list[i].flag )
        {
            sendto(sockfd,msg,sizeof(MSG),0,(SA)&list[i].cli,sizeof(list[i].cli));
        }
    }
    for(i=0;i<MAX;i++)
    {
        if(0 == list[i].flag )
        {
            list[i].flag =1;
            //list[i].cli = *cli;
            memcpy(&list[i].cli,cli,sizeof(*cli));
            break;
        }
    }
    return 0;
}

int do_chat(int sockfd, MSG* msg,struct sockaddr_in*cli)
{
     int i = 0 ;
    for(i=0;i<MAX;i++)
    {
        if(1 == list[i].flag && 0!=memcmp(&list[i].cli,cli,sizeof(*cli)) )
        {
            sendto(sockfd,msg,sizeof(MSG),0,(SA)&list[i].cli,sizeof(list[i].cli));
        }
    }
}
int do_logout(int sockfd, MSG* msg,struct sockaddr_in*cli)
{
    return 0;
}
int main(int argc, char *argv[])
{
    int sockfd = socket(AF_INET,SOCK_DGRAM,0);
    if(-1 == sockfd)
    {
        perror("socket");
        exit(1);
    }

    // man 7 ip 
    struct sockaddr_in ser,cli;
    bzero(&ser,sizeof(ser));
    bzero(&cli,sizeof(cli));
    ser.sin_family = AF_INET;
    // 大小端转化 host to net short 
    ser.sin_port = htons(50000);
    ser.sin_addr.s_addr = inet_addr("127.0.0.1");
    int ret = bind(sockfd,(SA)&ser,sizeof(ser));
    if(-1 == ret)
    {
        perror("bind");
        exit(1);
    }
    socklen_t len = sizeof(cli);
    MSG msg;
    while(1)
    {
        bzero(&msg,sizeof(msg));
        recvfrom(sockfd,&msg,sizeof(msg),0,(SA)&cli,&len);
        switch(msg.type)
        {
            case CMD_LOGIN:
                do_login(sockfd,&msg,&cli);
                break;
            case CMD_LOGOUT:
                do_logout(sockfd,&msg,&cli);
                break;
            case CMD_CHAT:
                do_chat(sockfd,&msg,&cli);
                break;
        
        }
    }
    close(sockfd);
    return 0;
}


    客户端

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <time.h>
typedef struct sockaddr * (SA);
typedef enum {CMD_LOGIN,CMD_CHAT,CMD_LOGOUT}TYPE;
typedef struct 
{
    TYPE type;
    char name[50];
    char context[128];

}MSG;
int main(int argc, char *argv[])
{
    int sockfd = socket(AF_INET,SOCK_DGRAM,0);
    if(-1 == sockfd)
    {
        perror("socket");
        exit(1);
    }

    // man 7 ip 
    struct sockaddr_in ser,cli;
    bzero(&ser,sizeof(ser));
    ser.sin_family = AF_INET;
    // 大小端转化 host to net short 
    ser.sin_port = htons(50000);
    ser.sin_addr.s_addr = inet_addr("127.0.0.1");
    socklen_t len = sizeof(cli);
    MSG msg;
    char name[50]={0};
    printf("input name:");
    fgets(name,sizeof(name),stdin);
    name[strlen(name)-1]='\0';

    msg.type = CMD_LOGIN;
    strcpy(msg.name ,name);
    strcpy(msg.context,"login");

    sendto(sockfd,&msg,sizeof(msg),0,(SA)&ser,sizeof(ser));

    pid_t pid = fork();
    if(pid>0)
    {
        while(1)
        {
            bzero(&msg,sizeof(msg));
            recvfrom(sockfd,&msg,sizeof(msg),0,NULL,NULL);    
            printf("%s:%s\n",msg.name,msg.context);
        }
    }
    else if(0==pid)
    {
        while(1)
        {
            printf("to all");    
            char buf[128]={0};
            strcpy(msg.name,name);
            msg.type = CMD_CHAT;
            fgets(msg.context,sizeof(msg.context),stdin);//#quit
            msg.context[strlen(msg.context)-1]='\0';
            if(0==strcmp(msg.context,"#quit"))
            {
                msg.type = CMD_LOGOUT;
                strcpy(msg.context,"CMD_LOGOUT");
            }
            sendto(sockfd,&msg,sizeof(msg),0,(SA)&ser,sizeof(ser));
        }
    }
    else 
    {
        perror("fork");
        exit(1);
    }
    close(sockfd);
    return 0;
}


    
    

pin️‍灼灼灼灼
关注
Linux网络编程之UDP
weixin_44027897的博客
06-23 803
1. UDP 的 特点 无连接：内部不维护链接状态，也不需要三次握手。 基于消息的数据传输服务：不会有 粘包问题，数据包之间是有边界的 不可靠：数据包可能丢失，重复，乱序，缺少流量控制。 一般情况下比TCP更高效： 2. UDP 客户/服务器模型 3. UDP 的 特点 UDP 报文可能丢失，重复 UDP报文可能乱序 UDP缺乏流量控制 UDP 协议报文可能被截断。如果发送的...
Linux下UDP编程
最新发布
热土程序园，利他愉己~
08-28 2103
Linux下UDP编程 socket（套接字）本质上是一个抽象的概念，它是一组用于网络通信的 API，提供了一种统一的接口，使得应用程序可以通过网络进行通信。在不同的操作系统中，socket 的实现方式可能不同，但它们都遵循相同的规范和协议，可以实现跨平台的网络通信。
Linux 网络编程——UDP编程
热门推荐
秋叶原 && Mike || 麦克
04-16 4万+
概述UDP 是 User Datagram Protocol 的简称， 中文名是用户数据报协议，是一个简单的面向数据报的运输层协议，在网络中用于处理数据包，是一种无连接的协议。UDP 不提供可靠性的传输，它只是把应用程序传给 IP 层的数据报发送出去，但是并不能保证它们能到达目的地。由于 UDP 在传输数据报前不用在客户和服务器之间建立一个连接，且没有超时重发等机制，故而传输速度很快。UDP 有如...
Linux下网络编程实现UDP
nigulasi_dawei的博客
06-24 661
一、引言        UDP是TCP/IP协议中的传输层协议的一种，本文介绍了在Linux下编写基于UDP协议的Client/Server模型的程序的方法，并给出了一个echo Client/Server例子程序。       二、UDP协议简介        UDP是一种简单的传输层协议，在RFC768中有详细描述。UDP协议是一种非连接的、不可靠的数据报文协议，完全不同于提供面向连接的、可靠的
Linux网络编程-UDP
Silence_Fall的博客
12-06 422
1.UDP协议
Linux：网络编程——UDP编程的前期准备
qq_43825377的博客
03-21 438
Linux：网络编程——UDP编程的前期准备字节序TCP与UDP的区别UDP编程的流程1.创建套接字创建套接字的意义2.绑定地址信息（1）绑定ip和端口（2）函数3.UDP发送数据4.UDP接收数据5.关闭套接字 字节序 字节序是一个处理器架构特性，用于指示像整数这样的大数据类型内部的字节如何排序。分为大端字节序和小端字节序，对应大端机器和小端机器。 大端字节序：即把数据的高字节放到低地址中 小段字节序：高字节放到高地址中 我们可以使用一串简单的代码来确定我们的机器是小端机器还是大端机器： #includ
【Linux】网络编程套接字（一）—— UDP编程
丁丁逗的博客
12-26 2856
文章目录1. 预备知识1.1 源IP地址和目的IP地址1.2 认识端口号1.3 理解 "端口号" 和 "进程ID"1.4 源端口号和目的端口号1.5 认识UDP协议1.6 认识TCP协议1.7 网络字节序2. socket编程接口2.1 socket 常见API2.1.1 创建2.1.2 绑定2.1.3 关闭2.2 sockaddr结构2.2.1 sockaddr 结构2.2.2 sockaddr_in 结构2.2.3 in_addr 结构2.2.4 小结2.3 地址转换函数2.4 例子3. 简单的UDP网
Linux网络编程——UDP Socket
Xinyue_Lu的博客
12-04 795
UDP socket编程的知识点总结 Udp是无连接的、不可靠的传输协议，面向消息的数据传输协议 与TCP相比，有两个致命的缺点，一是数据包容易丢失，二是数据包无序 建立在udp上层的协议，需要自己定义流控制、超时、重传等。 进行udp传输有两个问题，一个是数据包大小，一个是发数据时间间隔，这两个因素是发送端影响udp丢包率的主要因素，而丢包率直接影响了传输效率 UDP没有真正的发送缓冲区，因为它是不可靠无连接的，不需要保存应用进程的数据备份，应用进程的数据沿着协议栈往下传递，拷贝到内核...
Linux——网络编程套接字
m0_46657980的博客
01-11 272
1.UDP协议 UDP：用户数据报协议，不可靠的传输通信协议，应用于实时性要求大于安全性的场景——视频/音频数据传输 特点：无连接，不可靠，面向数据报 简单的UDP网络程序实现以及接口 网络通信程序的编写都使用的是套接字接口——socket接口 客户端：主动发起请求的一方，用户的一端 服务端：被动接受请求的一方，向用户提供服务的一端 在通信时，客户端的主要工作为： （1）创建套接字，使进程与网卡之间建立联系 （2）为套接字绑定地址信息，每条数据中都有源端地址和对端地址，绑定的地址信息就是源
Linux：网络编程——UDP代码及其封装
qq_43825377的博客
03-23 928
Linux：网络编程——UDP代码及其封装UDP代码二级目录三级目录 UDP代码 客户端： #include <arpa/inet.h> #include <iostream> #include <string> using namespace std; int main() { int sockfd = socket(AF_INET,
Linux网络编程【UDP】
wuyou的博客
04-26 1314
UDP通信
LINUX网络编程（UDP）
Fifty Shades Of Black
06-10 345
udp 用户数据报协议-无连接，不可靠，面向数据报 面向数据报：每条数据有长度标记,整条发，整条收，传输不够灵活，但是不会存在粘包问题 视使用场景：对数据实时要求高，输出视频——保证传输速度 优点：传输速度快 ，无粘包情况 缺点：不可靠 如果使用场景对文件的安全性要求比较高（文件传输），尽量使用tcp，保证数据的可靠；像音乐视频这种对安全性要求不是很高（视频传输），但是实时性，速度快的用udp socket套接字编程： 网络编程涉及到对网卡的操作，而我们用户无法直接操作，因此操作系统就提供了一套接口来供
Linux网络编程——UDP编程
weixin_52109967的博客
08-15 2902
UDP通信的相关函数和实际案例代码。
linux网络编程之UDP编程
happyguys12345的博客
06-10 416
在网络传输协议中，TCP协议提供的是一种可靠的，复杂的，面向连接的数据流（SOCK_STREAM）传输服务，它通过三段式握手过程建立连接。TCP有一种“重传确认”机制，即接收端收到数据后要发出一个肯定确认的信号，发送端如果收到接收端肯定确认的信号，就会继续发送其他的数据，如果没有，它就会重新发送。 相对而言，UDP协议则是一种无连接的，不可靠的数据报（SOCK_DGRAM）传输服务。使用UD
Linux网络编程 | UDP编程
大柳_的博客。
06-01 2978
浅谈UDP。UDP是一种不可靠的、无连接的、数据报服务。发送端应用程序每执行一次写操作，UDP 模块就将其封装成一个 UDP 数据报发送。接收端必须及时针对每一个 UDP 数据报执行读操作，否则就会丢包。并且，如果用户没有指定足够的应用程序缓冲区来读取 UDP 数据，则 UDP 数据将被截断。 因此，采用UDP协议时必须要求接收端可以一次性收取完发送端一次发送的数据，不然就会造成数据丢失。 2.客户端 3.输出结果 UDP是一种无连接的传输方式，所以可以多个客户端同时发送。 服务器端关闭立马重启，客户
Linux网络编程之UDP编程
y_q_m的博客
03-05 302
1 TCP网络编程与UDP网络编程对比 1.1 相同点 一、都采用CS模式：客户端（Client）和服务器（Serve）模式。客户端是主动的，服务器是被动的。一般情况下，一定服务器会响应多个客户端。 二、TCP网络编程与UDP网络编程都使用套接字创建函数Socket（）、关闭套接字函数close () 和IP地址与端口号绑定函数bind () 。 1.2 不同点 一、TCP网络编程需要连接（三次握...
《Linux网络编程》： UDP编程
yexiangCSDN的专栏
01-03 496
UDP编程 1. UDP 编程的 C/S 架构 2.UDP 客户端程序 ssize_t sendto( int sockfd，const void *buf,size_t nbytes,int flags,const struct sockaddr *to,socklen_t addrlen ); 功能：向 to 结构体指针中指定的 ip，发送 UDP 数据，可以发送 0 长度...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值