UDP协议_udp协议栈-CSDN博客

本文链接：https://blog.csdn.net/2301_79126818/article/details/149144498

1 UDP协议解析

1.1 UDP协议功能介绍

UDP是一个简单的面向消息的传输层协议，是一种无连接的传输层协议，提供了一种简单的不可靠的数据传输服务。
UDP提供了不面向连接的通信，且不对传送的数据报进行可靠地保证，适用于一次传送少量的数据，不适用于传送大量的数据。
UDP属于网络协议栈中的传输层协议，直接负责数据的传输和接收。

1.2 UDP协议的特点

无连接：两台主机在使用UDP进行数据传输时，不需要建立连接，只需知道对端的IP和端口号，即可把数据发送过去。
不可靠：UDP协议没有确认重传机制，如果因为网络故障导致报文无法发送给对方，或者对方收到了报文，但是传输过程中乱序了，对方校验失败后把乱序的包丢了，UDP协议层也不会给应用层任何错误的信息反馈
面向数据报：UDP传输数据时，是以数据报文为单位一个个地发出去，然后一个个地接收，这导致应用层无法灵活控制数据的读写次数和数量。比如说使用UDP传输100个字节的数据，如果发送端调用一次发送，发送100字节，那么接收端也必须调用对应的一次接收去全部接收者100个字节，而不能循环调用10接收，每次接受10个字节。

1.3 UDP端口

端口号标识了一个主机上进行通信的不同应用程序（进程）。利用ip地址+端口号可以定位全球上唯一一个进程。知道了IP地址，就知道了对方主机的位置，置于传送给那个应用程序处理，则是由端口号决定，每个应用程序都会有一个或者多个端口号
在TCP/IP协议中，使用源IP，源端口，目的IP，目的端口号，协议号，五元组表示一个通信。
端口的划分：0 - 1023: 知名端口号, HTTP, FTP, SSH等这些广为使用的应用层协议, 他们的端口号都是固定的。ssh服务器, 使用22端口；ftp服务器, 使用21端口telnet服务器, 使用23端口；http服务器, 使用80端口，https服务器, 使用443等等。1024-65535：操作系统动态从这个范围内分配。

1.4 UDP报文格式

源端口：表示发送方的端口，取值范围0-65535，如果不需要回复，可以设置为0
目标端口：标识接收方的端口号，取值范围0-65535，将数据包路由到正确的应用程序。
长度：表示UDP报头加上数据部分的总长度，最小是为8（只有包头，无数据）
校验和：用于检测UDP包头和数据的传输错误。可选字段，如果不计算校验和则设为0
数据（有效载荷）是上一层应用层的数据，上面8个字节便是UDP的报头。16为UDP长度，是UDP报头的长度和数据的长度之和，所以提取数据的时候，要将16为UDP长度-8字节就是数据的长度

1.5 UDP的适用场景

UDP协议一般作为流媒体应用、语音交流、视频会议所使用的传输层协议，还有许多基于互联网的电话服务使用的VOIP（基于IP的语音）也是基于UDP运行的，实时视频和音频流协议旨在处理偶尔丢失的数据包，因此，如果重新传输丢失的数据包，则只会发生质量略有下降，而不是出现较大的延迟。
我们大家都知道的DNS 协议底层也使用了UDP 协议，这些应用或协议之所以选择UDP 主要是因为以下这几点
速度快，采用 UDP 协议时，只要应用进程将数据传给 UDP，UDP 就会将此数据打包进 UDP 报文段并立刻传递给网络层，然而TCP有拥塞控制的功能，它会在发送前判断互联网的拥堵情况，如果互联网极度阻塞，那么就会抑制 TCP 的发送方。使用 UDP 的目的就是希望实时性。
无须建立连接，TCP 在数据传输之前需要经过三次握手的操作，而 UDP 则无须任何准备即可进行数据传输。因此 UDP 没有建立连接的时延。
无连接状态，TCP 需要在端系统中维护连接状态，连接状态包括接收和发送缓存、拥塞控制参数以及序号和确认号的参数，在 UDP 中没有这些参数，也没有发送缓存和接受缓存。因此，某些专门用于某种特定应用的服务器当应用程序运行在 UDP 上，一般能支持更多的活跃用户
分组首部开销小，每个 TCP 报文段都有 20 字节的首部开销，而 UDP 仅仅只有 8 字节的开销

1.6 UDP洪水

是一种拒绝服务攻击，攻击者将大量的UDP数据包发送到目标服务器，让该设备的处理和响应能力无力承担。由于UDP的洪水攻击，保护目标服务器的防火墙可能也不堪重负，导致对正常流量拒绝服务。
UDP洪水攻击的工作原理
1. 利用服务器响应发送到其端口之一的UDP数据包时所采取的步骤。在正常情况下，服务器在特定端口上收到UDP数据包时，将通过一下两个步骤进行响应3
2. 服务器首先检查是否有任何当前侦听指定端口请求的程序正在运行。如果该端口上没有程序正在接受数据包，则服务器将以（ICMP）数据包作为响应，告诉发送方目标不可达。
3. 由于目标服务器利用资源来检查并响应每个接受到的UDP数据包，当收到大量UDP数据包时，目标资源会很快耗尽，从而导致对正常流量拒绝服务。

1.7 代码实现

1.UDP包头

typedef struct _xudp_hdr_t {
    uint16_t src_port, dest_port;   // 源端口 + 目标端口
    uint16_t total_len;                    // 整个数据包的长度
    uint16_t checksum;                        // 校验和
}xudp_hdr_t;

2.udp控制结构

struct _xudp_t {
    enum {
        XUDP_STATE_FREE,            // UDP未使用
        XUDP_STATE_USED,            // UDP已使用
    } state;                        // 状态

    uint16_t local_port;            // 本地端口
    xudp_handler_t handler;         // 事件处理回调
};

3.udp伪校验和计算

为什么需要加上伪首部：因为UDP本身是传输层的协议，只负责端到端的数据传输，但是数据包在网络中传输，IP层负责路由，如果只校验UDP包头和数据，无法检测IP层的路由错误
防止误投递：例如数据包原本是从本机A发送到本机B的，但是由于IP层出错，就会导致发送到本机C，如果UDP校验不包含IP地址，C主机就会认为数据包是正确的。包含了伪首部，就可以正确校验。
伪首部的UDP长度是UDP头和数据部分的长度

/**
 * 计算UDP伪校验和
 * @param src_ip 源IP
 * @param dest_ip 目标IP
 * @param protocol 协议
 * @param buf 数据区
 * @param len 数据长度
 * @return 校验和结果
 */
static uint16_t checksum_peso(const xipaddr_t *src_ip, const xipaddr_t *dest_ip,
                              uint8_t protocol, uint16_t *buf, uint16_t len) {
    uint8_t zero_protocol[2] = {0, protocol};
    uint16_t c_len = swap_order16(len);

    uint32_t sum = checksum16((uint16_t *)src_ip->array, XNET_IPV4_ADDR_SIZE, 0, 0);
    sum = checksum16((uint16_t *)dest_ip->array, XNET_IPV4_ADDR_SIZE, sum, 0);
    sum = checksum16((uint16_t *)zero_protocol, 2, sum, 0);
    sum = checksum16((uint16_t *)&c_len, 2, sum, 0);
    return checksum16(buf, len, sum, 1);
}

/**
 * 校验和计算
 * @param buf 校验数据区的起始地址
 * @param len 数据区的长度，以字节为单位
 * @param pre_sum 累加的之前的值，用于多次调用checksum对不同的的数据区计算出一个校验和
 * @param complement 是否对累加和的结果进行取反
 * @return 校验和结果
 */
static uint16_t checksum16(uint16_t * buf, uint16_t len, uint16_t pre_sum, int complement) {
    uint32_t checksum = pre_sum;
    uint16_t high;

    while (len > 1) {
        checksum += *buf++;
        len -= 2;
    }
    if (len > 0) {
        checksum += *(uint8_t *)buf;
    }

    // 注意，这里要不断累加。不然结果在某些情况下计算不正确
    while ((high = checksum >> 16) != 0) {
        checksum = high + (checksum & 0xffff);
    }
    return complement ? (uint16_t)~checksum : (uint16_t)checksum;
}

4.udp输入处理

/**
实际就是想实现回调函数
 * UDP输入处理
 * @param udp 待处理的UDP
 * @param src_ip 数据包来源
 * @param packet 数据包结构
 */
void xudp_in(xudp_t *udp, xipaddr_t *src_ip,xnet_packet_t * packet) {
    xudp_hdr_t * udp_hdr = (xudp_hdr_t *)packet->data;
    uint16_t pre_checksum;
    uint16_t src_port;

    if ((packet->size < sizeof(xudp_hdr_t)) || (packet->size < swap_order16(udp_hdr->total_len))) {
        return;
    }

    pre_checksum = udp_hdr->checksum;
    udp_hdr->checksum = 0;
    if (pre_checksum != 0) {
        uint16_t checksum = checksum_peso(src_ip, &netif_ipaddr, XNET_PROTOCOL_UDP,
                                          (uint16_t *) udp_hdr, swap_order16(udp_hdr->total_len));
        checksum = (checksum == 0) ? 0xFFFF : checksum;
        if (checksum != pre_checksum) {
            return;
        }
    }

    src_port = swap_order16(udp_hdr->src_port);
    remove_header(packet, sizeof(xudp_hdr_t));
    if (udp->handler) {
        udp->handler(udp, src_ip, src_port, packet);

5.发送一个UDP数据包

/**
 * 发送一个UDP数据包
 * @param udp udp结构
 * @param dest_ip 目标ip
 * @param dest_port 目标端口
 * @param packet 待发送的包
 * @return 发送结果
 */
int xudp_out(xudp_t* udp, xipaddr_t * dest_ip, uint16_t dest_port, xnet_packet_t * packet) {
    xudp_hdr_t* udp_hdr;
    uint16_t checksum;

    add_header(packet, sizeof(xudp_hdr_t));
    udp_hdr = (xudp_hdr_t*)packet->data;
    udp_hdr->src_port = swap_order16(udp->local_port);
    udp_hdr->dest_port = swap_order16(dest_port);
    udp_hdr->total_len = swap_order16(packet->size);
    udp_hdr->checksum = 0;
    checksum = checksum_peso(&netif_ipaddr, dest_ip, XNET_PROTOCOL_UDP, (uint16_t *) udp_hdr, packet->size);
    udp_hdr->checksum = (checksum == 0) ? 0xFFFF : checksum;
    return xip_out(XNET_PROTOCOL_UDP, dest_ip, packet);
}

6.针对UDP控制块的函数，打开，关闭，绑定和查找

/**
 * 打开UDP结构
 * @param handler 事件处理回调函数
 * @return 打开的xudp_t结构
 */
xudp_t* xudp_open(xudp_handler_t handler) {
    xudp_t * udp, * end;

    for (udp = udp_socket, end = &udp_socket[XUDP_CFG_MAX_UDP]; udp < end; udp++) {
        if (udp->state == XUDP_STATE_FREE) {
            udp->state = XUDP_STATE_USED;
            udp->local_port = 0;
            udp->handler = handler;
            return udp;
        }
    }
    return (xudp_t *)0;
}

/**
 * 关闭UDP连接
 * @param udp 待关闭的xudp_t结构
 */
void xudp_close(xudp_t *udp) {
    udp->state = XUDP_STATE_FREE;
}

/**
 * 查找指定端口对应的udp结构
 * @param port 待查找的端口
 * @return 找到的xudp_t结构
 */
xudp_t* xudp_find(uint16_t port) {
    xudp_t * udp, * end = &udp_socket[XUDP_CFG_MAX_UDP];

    for (udp = udp_socket; udp < end; udp++) {
        if ((udp->state != XUDP_STATE_FREE) && (udp->local_port == port)) {
            return udp;
        }
    }

    return (xudp_t *)0;
}

/**
 * 绑定xudp_t结构到指定端口
 * @param udp 待绑定的结构
 * @param local_port 目标端口
 * @return 绑定结果
 */
xnet_err_t xudp_bind(xudp_t *udp, uint16_t local_port) {
    xudp_t * curr, * end;

    if (local_port == 0) {
        return XNET_ERR_PARAM;
    }

    for (curr = udp_socket, end = &udp_socket[XUDP_CFG_MAX_UDP]; curr < end; curr++) {
        if ((curr != udp) && (curr->local_port == local_port)) {
            return XNET_ERR_BINDED;
        }
    }

    udp->local_port = local_port;
    return XNET_ERR_OK;
}