AI 助理
备案控制台
开发者社区 云计算 文章 正文

用户态协议栈01-udp收发

2024-08-15 18
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 用户态协议栈01-udp收发

用户态协议栈01-udp收发

实现用户态协议栈最最简单的就是实现Udp的收发，下面逐步完成一个基于dpdk的Udp协议栈，达到收发的目的。

前期准备

  • 以太网协议（ether）

  • IPv4协议（ip）

  • UDP协议（udp）

这些协议的图解会在后面我们拆解和拼接数据包的时候用到，先放在这里。

DPDK初始化

DPDK初始化分为以下两个部分：

  1. 启动dpdk

参考我之前的博客

  1. 配置dpdk端口和收发队列

开始搓udp协议栈

配置dpdk

int gDpdkPortId = 0;
    if(rte_eal_init(argc, argv) < 0) {
        rte_exit(EXIT_FAILURE, "Error with EAL init\n");//退出，退出提示
    }
    uint16_t nb_dev_ports = rte_eth_dev_count_avail();//获取可用网卡数量
    if(nb_dev_ports == 0) {
        rte_exit(EXIT_FAILURE, "Error with dev count\n");
    }
    struct rte_mempool* mbuf_pool = rte_pktmbuf_pool_create("mbuf_pool", NUM_MBUFS, 0, 0, 
        RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());//初始化一个内存池
    if(!mbuf_pool) {
        rte_exit(EXIT_FAILURE, "Error with mbuf init\n");
    }
    struct rte_eth_dev_info dev_info;
    rte_eth_dev_info_get(gDpdkPortId, &dev_info);//获取网卡信息
    const int num_rx_queue = 1;//定义接受队列数量
    const int num_tx_queue = 1;//定义发送队列数量
    struct rte_eth_conf port_conf = port_conf_default;
    //设置网卡队列参数
    if(rte_eth_dev_configure(gDpdkPortId, num_rx_queue, num_tx_queue, &port_conf) < 0) {
        rte_exit(EXIT_FAILURE, "Error with dev configure");
    }
  //配置接受队列参数
    if(rte_eth_rx_queue_setup(gDpdkPortId, 0, 1024, rte_eth_dev_socket_id(gDpdkPortId), NULL, mbuf_pool) < 0) {
        rte_exit(EXIT_FAILURE, "Error with rx queue setup\n");
    }
  //配置发送队列参数
    struct rte_eth_txconf txq_conf = dev_info.default_txconf;
    txq_conf.offloads = port_conf.rxmode.offloads;
    if(rte_eth_tx_queue_setup(gDpdkPortId, 0, 1024, rte_eth_dev_socket_id(gDpdkPortId), &txq_conf) < 0) {
        rte_exit(EXIT_FAILURE, "Error with tx queue setup\n");
    }
  //启动发送和接收服务
    if(rte_eth_dev_start(gDpdkPortId) < 0) {
        rte_exit(EXIT_FAILURE, "Error with dev start\n");
    }

这里首先是配置了一下dpdk并且启动他。我们需要网卡（gDpdkPort）、发送队列、接收队列和一个内存池，后面我们发送和接收数据包都要用到这个内存池。这里需要说一下一些函数的参数。

int rte_eth_rx_queue_setup(uint16_t port_id, uint16_t rx_queue_id, uint16_t nb_rx_desc, unsigned int socket_id ,const struct rte_eth_rxconf *rx_conf, struct rte_mempool *mb_pool);

  • port_id：以太网端口的ID。
  • rx_queue_id：接收队列的ID。
  • nb_rx_desc：接收队列中描述符（descriptor）的数量。
  • socket_id：指定内存分配所使用的套接字ID。
  • rx_conf：一个指向结构体rte_eth_rxconf的指针，包含了一些接收配置参数，如处理函数、杂项模式等。
  • mb_pool：一个指向内存池（mempool）对象的指针，用于分配接收缓冲区。

int rte_eth_tx_queue_setup(uint16_t port_id, uint16_t tx_queue_id, uint16_t nb_tx_desc, unsigned int socket_id, const struct rte_eth_txconf *tx_conf);

port_id：要配置的以太网端口标识符。

tx_queue_id：要配置的发送队列标识符。

nb_tx_desc：发送队列中的描述符数量。

socket_id：用于内存分配的套接字标识符。

tx_conf：指向rte_eth_txconf结构体的指针，包含有关发送队列配置的详细信息

struct rte_mempool *rte_pktmbuf_pool_create(const char *name, unsigned n, unsigned cache_size, uint16_t priv_size, uint16_t data_room_size, int socket_id);

name：缓冲池的名称。

n：缓冲池中缓冲区的数量。

cache_size：每个CPU核心的本地缓存大小。如果设为0，则禁用本地缓存。

priv_size：每个数据包缓冲区保留的私有数据大小。

data_room_size：每个数据包缓冲区可用于存储数据的空间大小。

socket_id：用于内存分配的套接字标识符。

定义udp相关变量

//udp
uint8_t gSrcMac[RTE_ETHER_ADDR_LEN];
uint8_t gDstMac[RTE_ETHER_ADDR_LEN];
uint32_t gSrcIp;
uint32_t gDstIp;
uint16_t gSrcPort;
uint16_t gDstPort;

这些是我们使用UDP协议发送数据包时需要的参数，当我们接收到一个udp数据包的时候，我们从数据包中读取数据，然后保存到这些变量中；在创建新的数据包时使用这些变量来构建发回的数据包。

接受udp数据&&读取包内容

while(1) {
        struct rte_mbuf* mbufs[BURST_SIZE];
        //从uio/ufio中读取一个数据包
        unsigned nb_recvd = rte_eth_rx_burst(gDpdkPortId, 0, mbufs, BURST_SIZE);
        if(nb_recvd > BURST_SIZE) {
            rte_exit(EXIT_FAILURE, "Error with rx burst\n");
        }
        unsigned i = 0;
        for(i = 0; i < nb_recvd; i++) {
      //获取以太网头
            struct rte_ether_hdr* ehdr = rte_pktmbuf_mtod(mbufs[i], struct rte_ether_hdr*);
            if(ehdr->ether_type != rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4)) {
                    continue;
            }
      //获取IP头
            struct rte_ipv4_hdr* iphdr = rte_pktmbuf_mtod_offset(mbufs[i], struct rte_ipv4_hdr*, sizeof(struct rte_ether_hdr));
            if(iphdr->next_proto_id == IPPROTO_UDP) {
                printf("get udp\n");
                struct rte_udp_hdr* udphdr = (struct rte_udp_hdr*)(iphdr + 1);
                //拷贝所需变量
        rte_memcpy(gDstMac, ehdr->s_addr.addr_bytes, RTE_ETHER_ADDR_LEN);
        rte_memcpy(&gSrcIp, &iphdr->dst_addr, sizeof(uint32_t));
        rte_memcpy(&gDstIp, &iphdr->src_addr, sizeof(uint32_t));
        rte_memcpy(&gSrcPort, &udphdr->dst_port, sizeof(uint16_t));
        rte_memcpy(&gDstPort, &udphdr->src_port, sizeof(uint16_t));
                // uint16_t length = ntohs(udphdr->dgram_len) - sizeof(struct rte_udp_hdr);
                uint16_t length = ntohs(udphdr->dgram_len);
                
                // printf("length: %d, content: %s\n", length, (char*)(udphdr + 1));
                //打印数据
                struct in_addr addr;
                addr.s_addr = iphdr->src_addr;
                printf("src: %s:%d, ", inet_ntoa(addr), ntohs(udphdr->src_port));
                addr.s_addr = iphdr->dst_addr;
                printf("dst: %s:%d\n", inet_ntoa(addr), ntohs(udphdr->dst_port));
        //调用数据包拼接函数（下文实现）
                struct rte_mbuf* txbuf = ustack_send(mbuf_pool, (char*)(udphdr + 1), length);
                uint16_t res = rte_eth_tx_burst(gDpdkPortId, 0, &txbuf, 1);
                printf("send res: %d\n", res);
                rte_pktmbuf_free(txbuf);
                rte_pktmbuf_free(mbufs[i]);
            }
            else if(iphdr->next_proto_id = IPPROTO_TCP) {
                
                printf("get tcp\n");
                size_t length = 0;
                void* hostinfo = get_hostinfo_from_fd()
            }
        }
    }

关于rte_pktmbuf_mtod(m, t)这个宏，在源代码中的实现是这样的:

#define rte_pktmbuf_mtod(m, t) rte_pktmbuf_mtod_offset(m, t, 0)
#define rte_pktmbuf_mtod_offset(m, t, o)  \
((t)((char *)(m)->buf_addr + (m)->data_off + (o)))
它的底层实现是对一个地址进行偏移，当我们获取一个udp/ip协议的以太网数据包的时候，如果偏移值为0，那就可以获得以太网头，如果偏移值为sizeof(以太网头长度)就可以获取IP数据包头。从下面这张图可以看出来。
![在这里插入图片描述](https://ucc.alicdn.com/images/user-upload-01/direct/1cd5249f24de4c29ac2ae83da5613b18.png#pic_center)

接口层

static struct rte_mbuf* ustack_send(struct rte_mempool* mbuf_pool, char* data, uint16_t length) {
    // uint16_t total_length = length + sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr);
    //整个udp/ip数据包的长度
    uint16_t total_length = length + 42;
    //从内存池中申请一块内存
    struct rte_mbuf* mbuf = rte_pktmbuf_alloc(mbuf_pool);
    if(!mbuf) {
        rte_exit(EXIT_FAILURE, "Error with EAL init\n");
    }
    mbuf->data_len = total_length;
    mbuf->pkt_len = total_length;
  
    uint8_t* pktdata = rte_pktmbuf_mtod(mbuf, uint8_t*);
  //拼接函数
    ustack_encode_udp_pkt(pktdata, data, total_length);
    return mbuf;
}

这里是一个封装的中间层，方便后续其他协议实现的时候接口一样方便使用。他会返回udp数据包的地址，方便我们将他拷贝到uio/ufio中发送。

拼接udp数据包

static int ustack_encode_udp_pkt(uint8_t* msg, char* data, uint32_t total_len) {
  
  //以太网头
    struct rte_ether_hdr* eth = (struct rte_ether_hdr*)msg;
    rte_memcpy(eth->d_addr.addr_bytes, gDstMac, RTE_ETHER_ADDR_LEN);
    rte_memcpy(eth->s_addr.addr_bytes, gSrcMac, RTE_ETHER_ADDR_LEN);
    eth->ether_type = htons(RTE_ETHER_TYPE_IPV4);
  //ip头
    struct rte_ipv4_hdr* iphdr = (struct rte_ipv4_hdr*)(msg + sizeof(struct rte_ether_hdr));
    iphdr->version_ihl = 0x45;
    iphdr->type_of_service = 0x00;
    iphdr->total_length = htons(total_len - sizeof(struct rte_ether_hdr));
    iphdr->packet_id = 0;
    iphdr->fragment_offset = 0;
    iphdr->time_to_live = 64;
    iphdr->next_proto_id = IPPROTO_UDP;
    iphdr->src_addr = gSrcIp;
    iphdr->dst_addr = gDstIp;
    iphdr->hdr_checksum = 0;
    iphdr->hdr_checksum = rte_ipv4_cksum(iphdr);
    struct rte_udp_hdr* udphdr = (struct rte_udp_hdr*)(msg + sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr));
    uint16_t udplen = total_len - sizeof(struct rte_ether_hdr) - sizeof(struct rte_ipv4_hdr);
    udphdr->dst_port = gDstPort;
    udphdr->src_port = gSrcPort;
    udphdr->dgram_len = htons(udplen);
    rte_memcpy((uint8_t*)(udphdr + 1), data, udplen);
    udphdr->dgram_cksum = 0;
    udphdr->dgram_cksum = rte_ipv4_udptcp_cksum(iphdr, udphdr);
    struct in_addr addr;
  addr.s_addr = gSrcIp;
  printf(" --> src: %s:%d, ", inet_ntoa(addr), ntohs(gSrcPort));
  addr.s_addr = gDstIp;
  printf("dst: %s:%d\n", inet_ntoa(addr), ntohs(gDstPort));
    return total_len;
}

这里需要参考上文的几张图，我再放一下：

这里需要分开看，首先是以太网部分

以太网协议作为链路层协议，他的主要信息就是MAC地址。我们只要将准备好的MAC地址拷贝到数据包中即可，最后设置一下协议类型。

IP部分

这里需要比价细致的解读：

  • version_ihl如何计算：从上面的IP数据包图可以看出：长方形的长度为32为，首部长度（宽）为20字节，注意32和20的单位是不一样的。32位是4字节；20 / 4 = 5；所以长度是5。
  • time_to_live：我们可以做一个实验，ping一下baidu.com

    得到的结果如上图，ttl就是数据包的生命周期，我这里的ttl=48,64-48=16，说明数据包从我这里到百度服务器，经历了16个网关。
  • checksum：在计算校验和之前，首先将hdr_checksum字段设置为0的目的是确保不会将旧的校验和值包含在计算中。因为校验和是通过对报文头部进行累加求和得到的，如果不将其初始值设置为0，则可能会导致计算结果与实际期望的校验和不一致。

UDP部分

和上面原理一样，拷贝一下数据。

完整代码

#include <rte_eal.h>
#include <rte_ethdev.h>
#include <stdio.h>
#include <unistd.h>
#include <arpa/inet.h>
#define NUM_MBUFS   (4096-1)
#define BURST_SIZE  128
#define ENABLE_SEND     1
int gDpdkPortId = 0;
//udp
uint8_t gSrcMac[RTE_ETHER_ADDR_LEN];
uint8_t gDstMac[RTE_ETHER_ADDR_LEN];
uint32_t gSrcIp;
uint32_t gDstIp;
uint16_t gSrcPort;
uint16_t gDstPort;
static int ustack_encode_udp_pkt(uint8_t* msg, char* data, uint32_t total_len) {
    struct rte_ether_hdr* eth = (struct rte_ether_hdr*)msg;
    rte_memcpy(eth->d_addr.addr_bytes, gDstMac, RTE_ETHER_ADDR_LEN);
    rte_memcpy(eth->s_addr.addr_bytes, gSrcMac, RTE_ETHER_ADDR_LEN);
    eth->ether_type = htons(RTE_ETHER_TYPE_IPV4);
    struct rte_ipv4_hdr* iphdr = (struct rte_ipv4_hdr*)(msg + sizeof(struct rte_ether_hdr));
    iphdr->version_ihl = 0x45;
    iphdr->type_of_service = 0x00;
    iphdr->total_length = htons(total_len - sizeof(struct rte_ether_hdr));
    iphdr->packet_id = 0;
    iphdr->fragment_offset = 0;
    iphdr->time_to_live = 64;
    iphdr->next_proto_id = IPPROTO_UDP;
    iphdr->src_addr = gSrcIp;
    iphdr->dst_addr = gDstIp;
    iphdr->hdr_checksum = 0;
    iphdr->hdr_checksum = rte_ipv4_cksum(iphdr);
    struct rte_udp_hdr* udphdr = (struct rte_udp_hdr*)(msg + sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr));
    uint16_t udplen = total_len - sizeof(struct rte_ether_hdr) - sizeof(struct rte_ipv4_hdr);
    udphdr->dst_port = gDstPort;
    udphdr->src_port = gSrcPort;
    udphdr->dgram_len = htons(udplen);
    rte_memcpy((uint8_t*)(udphdr + 1), data, udplen);
    udphdr->dgram_cksum = 0;
    udphdr->dgram_cksum = rte_ipv4_udptcp_cksum(iphdr, udphdr);
    struct in_addr addr;
  addr.s_addr = gSrcIp;
  printf(" --> src: %s:%d, ", inet_ntoa(addr), ntohs(gSrcPort));
  addr.s_addr = gDstIp;
  printf("dst: %s:%d\n", inet_ntoa(addr), ntohs(gDstPort));
    return total_len;
}
static struct rte_mbuf* ustack_send(struct rte_mempool* mbuf_pool, char* data, uint16_t length) {
    // uint16_t total_length = length + sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr);
    uint16_t total_length = length + 42;
    struct rte_mbuf* mbuf = rte_pktmbuf_alloc(mbuf_pool);
    if(!mbuf) {
        rte_exit(EXIT_FAILURE, "Error with EAL init\n");
    }
    mbuf->data_len = total_length;
    mbuf->pkt_len = total_length;
    uint8_t* pktdata = rte_pktmbuf_mtod(mbuf, uint8_t*);
    ustack_encode_udp_pkt(pktdata, data, total_length);
    return mbuf;
}
static const struct rte_eth_conf port_conf_default = {
    .rxmode = {.max_rx_pkt_len = RTE_ETHER_MAX_LEN}
};
int main(int argc, char** argv) {
    if(rte_eal_init(argc, argv) < 0) {
        rte_exit(EXIT_FAILURE, "Error with EAL init\n");
    }
    uint16_t nb_dev_ports = rte_eth_dev_count_avail();
    if(nb_dev_ports == 0) {
        rte_exit(EXIT_FAILURE, "Error with dev count\n");
    }
    struct rte_mempool* mbuf_pool = rte_pktmbuf_pool_create("mbuf_pool", NUM_MBUFS, 0, 0, 
        RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
    if(!mbuf_pool) {
        rte_exit(EXIT_FAILURE, "Error with mbuf init\n");
    }
    struct rte_eth_dev_info dev_info;
    rte_eth_dev_info_get(gDpdkPortId, &dev_info);
    const int num_rx_queue = 1;
    const int num_tx_queue = 1;
    struct rte_eth_conf port_conf = port_conf_default;
    if(rte_eth_dev_configure(gDpdkPortId, num_rx_queue, num_tx_queue, &port_conf) < 0) {
        rte_exit(EXIT_FAILURE, "Error with dev configure");
    }
    if(rte_eth_rx_queue_setup(gDpdkPortId, 0, 1024, rte_eth_dev_socket_id(gDpdkPortId), NULL, mbuf_pool) < 0) {
        rte_exit(EXIT_FAILURE, "Error with rx queue setup\n");
    }
    struct rte_eth_txconf txq_conf = dev_info.default_txconf;
    txq_conf.offloads = port_conf.rxmode.offloads;
    if(rte_eth_tx_queue_setup(gDpdkPortId, 0, 1024, rte_eth_dev_socket_id(gDpdkPortId), &txq_conf) < 0) {
        rte_exit(EXIT_FAILURE, "Error with tx queue setup\n");
    }
    if(rte_eth_dev_start(gDpdkPortId) < 0) {
        rte_exit(EXIT_FAILURE, "Error with dev start\n");
    }
    rte_eth_macaddr_get(gDpdkPortId, (struct rte_ether_addr*)gSrcMac);
    printf("dev start success\n");
    while(1) {
        struct rte_mbuf* mbufs[BURST_SIZE];
        unsigned nb_recvd = rte_eth_rx_burst(gDpdkPortId, 0, mbufs, BURST_SIZE);
        if(nb_recvd > BURST_SIZE) {
            rte_exit(EXIT_FAILURE, "Error with rx burst\n");
        }
        unsigned i = 0;
        for(i = 0; i < nb_recvd; i++) {
            struct rte_ether_hdr* ehdr = rte_pktmbuf_mtod(mbufs[i], struct rte_ether_hdr*);
            if(ehdr->ether_type != rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4)) {
                    continue;
            }
            struct rte_ipv4_hdr* iphdr = rte_pktmbuf_mtod_offset(mbufs[i], struct rte_ipv4_hdr*, sizeof(struct rte_ether_hdr));
            if(iphdr->next_proto_id == IPPROTO_UDP) {
                printf("get udp\n");
                struct rte_udp_hdr* udphdr = (struct rte_udp_hdr*)(iphdr + 1);
        rte_memcpy(gDstMac, ehdr->s_addr.addr_bytes, RTE_ETHER_ADDR_LEN);
        rte_memcpy(&gSrcIp, &iphdr->dst_addr, sizeof(uint32_t));
        rte_memcpy(&gDstIp, &iphdr->src_addr, sizeof(uint32_t));
        rte_memcpy(&gSrcPort, &udphdr->dst_port, sizeof(uint16_t));
        rte_memcpy(&gDstPort, &udphdr->src_port, sizeof(uint16_t));
                // uint16_t length = ntohs(udphdr->dgram_len) - sizeof(struct rte_udp_hdr);
                uint16_t length = ntohs(udphdr->dgram_len);
                // printf("length: %d, content: %s\n", length, (char*)(udphdr + 1));
                struct in_addr addr;
                addr.s_addr = iphdr->src_addr;
                printf("src: %s:%d, ", inet_ntoa(addr), ntohs(udphdr->src_port));
                addr.s_addr = iphdr->dst_addr;
                printf("dst: %s:%d\n", inet_ntoa(addr), ntohs(udphdr->dst_port));
                struct rte_mbuf* txbuf = ustack_send(mbuf_pool, (char*)(udphdr + 1), length);
                uint16_t res = rte_eth_tx_burst(gDpdkPortId, 0, &txbuf, 1);
                printf("send res: %d\n", res);
                rte_pktmbuf_free(txbuf);
                rte_pktmbuf_free(mbufs[i]);
            }
        }
    }
}

如何启动实验

**这一步还是比较重要的，建议看一下**

在我之前写的配置过程的基础上，我们需要将我们的虚拟机网卡添加到我们物理机的arp表中。

这是我的arp表，他现在已经添加过了，框出来的就是我添加的。

首先你要注意dpdk接管网卡的ip和mac地址，然后查看一下你的网络数据：

我这里是WIFI的局域网所以是插入到8-WLAN里面，你可能是以太网（一般直接插网线就是）。

netsh -c i i add neighbors 23 192.168.0.120 00-0c-29-85-2e-88

按照以上格式将dpdk控制的网卡的ip和mac添加到arp表中。

如何编译

我们这里选择MakeFile来编译我们的文件，如果你有别的库或者包含目录，自行添加。

# SPDX-License-Identifier: BSD-3-Clause
# Copyright(c) 2010-2014 Intel Corporation
# binary name 编译出二进制文件的名字（可执行文件）
APP = ustack
# all source are stored in SRCS-y 填写你的源文件
SRCS-y := main.c
# Build using pkg-config variables if possible
ifeq ($(shell pkg-config --exists libdpdk && echo 0),0)
all: shared
.PHONY: shared static
shared: build/$(APP)-shared
  ln -sf $(APP)-shared build/$(APP)
static: build/$(APP)-static
  ln -sf $(APP)-static build/$(APP)
PKGCONF=pkg-config --define-prefix
PC_FILE := $(shell $(PKGCONF) --path libdpdk)
CFLAGS += -O3 -g $(shell $(PKGCONF) --cflags libdpdk)
LDFLAGS_SHARED = $(shell $(PKGCONF) --libs libdpdk)
LDFLAGS_STATIC = -Wl,-Bstatic $(shell $(PKGCONF) --static --libs libdpdk)
build/$(APP)-shared: $(SRCS-y) Makefile $(PC_FILE) | build
  $(CC) $(CFLAGS) $(SRCS-y) -o $@ $(LDFLAGS) $(LDFLAGS_SHARED)
build/$(APP)-static: $(SRCS-y) Makefile $(PC_FILE) | build
  $(CC) $(CFLAGS) $(SRCS-y) -o $@ $(LDFLAGS) $(LDFLAGS_STATIC)
build:
  @mkdir -p $@
.PHONY: clean
clean:
  rm -f build/$(APP) build/$(APP)-static build/$(APP)-shared
  test -d build && rmdir -p build || true
else
ifeq ($(RTE_SDK),)
$(error "Please define RTE_SDK environment variable")
endif
# Default target, detect a build directory, by looking for a path with a .config
RTE_TARGET ?= $(notdir $(abspath $(dir $(firstword $(wildcard $(RTE_SDK)/*/.config)))))
include $(RTE_SDK)/mk/rte.vars.mk
CFLAGS += -O3
CFLAGS += $(WERROR_FLAGS)
include $(RTE_SDK)/mk/rte.extapp.mk
endif

使用效果

文章标签：
混合云容灾服务
网络协议
缓存
存储
关键词：
协议UDP
协议栈UDP
小狮子安度因1
目录
相关文章
2的n次方_
|
13天前
|
存储 网络协议 算法
UDP 协议和 TCP 协议
本文介绍了UDP和TCP协议的基本结构与特性。UDP协议具有简单的报文结构，包括报头和载荷，报头由源端口、目的端口、报文长度和校验和组成。UDP使用CRC校验和来检测传输错误。相比之下，TCP协议提供更可靠的传输服务，其结构复杂，包含序列号、确认序号和标志位等字段。TCP通过确认应答和超时重传来保证数据传输的可靠性，并采用三次握手建立连接，四次挥手断开连接，确保通信的稳定性和完整性。
2的n次方_
46 1
UDP 协议和 TCP 协议
游客xusvbxsoy3qma
|
11天前
|
监控 网络协议 网络性能优化
如何办理支持UDP协议的网络
在当今网络环境中，UDP（用户数据报协议）因传输速度快、延迟低而广泛应用于在线游戏、视频流媒体、VoIP等实时服务。本文详细介绍了办理支持UDP协议网络的方法，包括了解UDP应用场景、选择合适的ISP及网络套餐、购买支持UDP的设备并进行优化设置，以及解决常见问题的策略，帮助用户确保网络稳定性和速度满足实际需求。
游客xusvbxsoy3qma
27 6
游客xusvbxsoy3qma
|
21天前
|
网络协议
UDP协议在网络通信中的独特应用与优势
UDP（用户数据报协议）作为关键的传输层协议，在网络通信中展现出独特优势。本文探讨UDP的无连接性及低开销特性，使其在实时性要求高的场景如视频流、在线游戏中表现优异；其不保证可靠交付的特性赋予应用程序自定义传输策略的灵活性；面向报文的高效处理能力及短小的包头设计进一步提升了数据传输效率。总之，UDP适用于高速、实时性强且对可靠性要求不高的应用场景，为网络通信提供了多样化的选择。
游客xusvbxsoy3qma
39 3
可能只会写BUG
|
1月前
|
网络协议 视频直播 C语言
C语言 网络编程(三)UDP 协议
UDP（用户数据报协议）是一种无需建立连接的通信协议，适用于高效率的数据传输，但不保证数据的可靠性。其特点是无连接、尽力交付且面向报文，具备较高的实时性。UDP广泛应用于视频会议、实时多媒体通信、直播及DNS查询等场景，并被许多即时通讯软件和服务（如MSN/QQ/Skype、流媒体、VoIP等）采用进行实时数据传输。UDP报文由首部和数据部分组成，首部包含源端口、目的端口、长度和校验和字段。相比TCP，UDP具有更高的传输效率和更低的资源消耗。
可能只会写BUG
46 1
sunyalei
|
21天前
|
网络协议
UDP 协议
UDP 协议
sunyalei
27 0
GG2020gg
|
2月前
|
网络协议 视频直播 SDN
计算机网络：TCP协议的三次握手和四次挥手与UDP协议区别.
计算机网络：TCP协议的三次握手和四次挥手与UDP协议区别.
GG2020gg
42 1
游客mldfis24krfue
|
2月前
|
域名解析 网络协议 Linux
在Linux中，我们都知道，dns采用了tcp协议，又采用了udp协议，什么时候采用tcp协议？什么 时候采用udp协议？为什么要这么设计？
在Linux中，我们都知道，dns采用了tcp协议，又采用了udp协议，什么时候采用tcp协议？什么 时候采用udp协议？为什么要这么设计？
游客mldfis24krfue
45 0
GG2020gg
|
2月前
|
网络协议
计算机网络：TCP协议的三次握手和四次挥手与UDP协议区别.
计算机网络：TCP协议的三次握手和四次挥手与UDP协议区别.
GG2020gg
45 0
wljslmz
|
2月前
|
域名解析 网络协议 物联网
深度解析：UDP协议及其工作机制与优点
【8月更文挑战第20天】
wljslmz
68 0
wljslmz
|
2月前
|
消息中间件 网络协议 算法
UDP 和 TCP 哪个更好？
【8月更文挑战第23天】
wljslmz
100 0