---

一、网络协议栈

如何实现网络协议栈，首先需要拿到网络数据，有以下几种方式
1）原生socket
2）netmap
3）dpdk

1、网络通信过程

物理网卡将模拟信号转化为数据信号包；
NIC为网卡过来的数据包分配一个数据结构sk_buffer，
指出数据包中以太网头、IP头等信息的位置；
协议栈根据sk_buffer解析、处理数据包；
VFS作为接口（如socket），便于应用对数据包进行读、写等操作。

2、dpdk

dpdk本质是接管网卡到驱动的通信，交由dbdk自己处理。
有两种处理方式：1、基于dbdk实现自己的用户态协议栈；2、将数据继续交与内核协议栈处理。

1）dpdk是否有助于提高网络并发量？
答案：否。回顾之前做百万并发的时候，主要在于网络连接的优化。因此并发主要跟协议栈有关。
2）能否通过dpdk解决低延迟的问题？
答案：否。延迟主要是业务引起的。

二、dpdk环境

1、dpdk环境开启

cd dpdk路径
sudo su
#export RTE_SDK=dpdk路径
export RTE_SDK=/home/king/share/dpdk/dpdk-stable-19.08.2/   
export RTE_TARGET=x86_64-native-linux-gcc

./usertools/dpdk-setup.sh

依次执行：
43（加载IGB UIO module，是一种drive，dpdk接管网卡的方式）
44（加载VFIO module，是一种driver，dpdk接管网卡的方式）
45（加载KNI module，是内核网络接口，将数据写回内核协议栈）
46（设置巨页，可以不需要频繁页交换），可输入512
47（设置巨页），可输入512
49（执行之前需要eth0 down掉，执行sudo ifconfig eth0 down）pci地址=对应eth0的（如0000:03:00.0）
60（退出）

至此，dpdk接管了物理网卡。

2、Windowe下配置IP和MAC地址的映射

以管理员权限运行cmd
1）查看静态表接口

arp -a

2）查看适配器

netsh i i show in

关注结果中的以太网对应得Idx=12

Idx     Met         MTU          状态                名称
---  ----------  ----------  ------------  ---------------------------
  1          75  4294967295  connected     Loopback Pseudo-Interface 1
 14          40        1500  connected     WLAN
 22          25        1500  disconnected  本地连接* 9
 17          25        1500  disconnected  本地连接* 10
 11          65        1500  disconnected  蓝牙网络连接
  2          35        1500  connected     VMware Network Adapter VMnet1
 21          35        1500  connected     VMware Network Adapter VMnet8
 12          25        1500  connected     以太网 3

3）新添静态IP

netsh -c i i add neighbors Idx IP地址 Mac地址
// netsh -c i i add neighbors 12 192.168.42.133 00-0c-29-54-10-bb

4）通过arp -a检查是否添加成功
5）清除静态表

netsh i i delete neighbors Idx

三、实现用户态协议栈ustack

接下来编写ustack，大致流程是
1）初始化：rte_eal_init（）
2）创建一个创建内存池mbuf_pool：rte_pktmbuf_pool_create（）
3）配置以太网设备，包括配置队列的个数、接口的配置信息：rte_eth_dev_configure（）
4）分配并设置以太网设备的接收队列：rte_eth_rx_queue_setup（）
5）分配并设置以太网设备的发送队列：rte_eth_tx_queue_setup（）
6）启动以太网设备：rte_eth_dev_start（）
7）从以太网接口接收数据包：rte_eth_rx_burst（）

1、UDP协议

用户层经过网络各层，分别会在数据包前面添加
（UDP）协议首部，用于支持UDP的无连接、高效传输
IP首部：用于使数据能在互联网中传输，也就是能被路由器转发
以太网帧首部：用于使帧能够在一段链路或者网络上传输，被相应的目的主机接收。

							dp pkt
-------------------------------------------------------------------
| rte_ether_hdr | rte_ipv4_hdr | rte_udp_hdr |        data        |

2、代码

#include <rte_eal.h>
#include <rte_ethdev.h>
#include <rte_mbuf.h>

#include <stdio.h>
#include <arpa/inet.h>

//UDP协议发送
#define ENABLE_SEND		1  


#define NUM_MBUFS (4096-1)

#define BURST_SIZE	32


#if ENABLE_SEND

static uint32_t gSrcIp; //源 IP 地址
static uint32_t gDstIp; //目的 IP 地址

static uint8_t gSrcMac[RTE_ETHER_ADDR_LEN]; //源 MAC 地址
static uint8_t gDstMac[RTE_ETHER_ADDR_LEN];

static uint16_t gSrcPort;	//UDP 数据包的源端口号
static uint16_t gDstPort;

#endif


int gDpdkPortId = 0;


static const struct rte_eth_conf port_conf_default = {
	.rxmode = {.max_rx_pkt_len = RTE_ETHER_MAX_LEN }
};

//初始化以太网设备
static void ng_init_port(struct rte_mempool *mbuf_pool) {

    //返回可用的 Ethernet 设备数量
	uint16_t nb_sys_ports= rte_eth_dev_count_avail(); 
	if (nb_sys_ports == 0) {
		rte_exit(EXIT_FAILURE, "No Supported eth found\n");
	}

    //获取指定 Ethernet 设备的设备信息
	struct rte_eth_dev_info dev_info;
	rte_eth_dev_info_get(gDpdkPortId, &dev_info); //
	
    //配置以太网设备
	const int num_rx_queues = 1;    //接收队列数量
	const int num_tx_queues = 1;    //发送队列数量 
	struct rte_eth_conf port_conf = port_conf_default;	//struct rte_eth_conf 结构体包含了各种网卡相关的配置参数和属性
	rte_eth_dev_configure(gDpdkPortId, num_rx_queues, num_tx_queues, &port_conf);

	//分配并设置以太网设备的接收队列
	if (rte_eth_rx_queue_setup(gDpdkPortId, 0 , 1024, rte_eth_dev_socket_id(gDpdkPortId),NULL, mbuf_pool) < 0) {

		rte_exit(EXIT_FAILURE, "Could not setup RX queue\n");

	}
	
#if ENABLE_SEND

	struct rte_eth_txconf txq_conf = dev_info.default_txconf; //struct rte_eth_txconf 结构体中包含了各种发送队列相关的配置参数和属性
	txq_conf.offloads = port_conf.rxmode.offloads; //使用 port_conf.rxmode.offloads 来初始化 txq_conf.offloads，以便发送队列的属性和接收队列保持一致。

	//分配并设置以太网设备的传输队列
	if (rte_eth_tx_queue_setup(gDpdkPortId, 0 , 1024, rte_eth_dev_socket_id(gDpdkPortId), &txq_conf) < 0) {
		
		rte_exit(EXIT_FAILURE, "Could not setup TX queue\n");
		
	}
#endif

	//启动以太网设备。
	if (rte_eth_dev_start(gDpdkPortId) < 0 ) {
		rte_exit(EXIT_FAILURE, "Could not start\n");
	}

}

/*将负载数据封装成UDP数据包 */
static int ng_encode_udp_pkt(uint8_t *msg, unsigned char *data, uint16_t total_len) {

	// 以太网头
	struct rte_ether_hdr *eth = (struct rte_ether_hdr *)msg;
	rte_memcpy(eth->s_addr.addr_bytes, gSrcMac, RTE_ETHER_ADDR_LEN);
	rte_memcpy(eth->d_addr.addr_bytes, gDstMac, RTE_ETHER_ADDR_LEN);
	eth->ether_type = htons(RTE_ETHER_TYPE_IPV4);
	

	// IPV4 头
	struct rte_ipv4_hdr *ip = (struct rte_ipv4_hdr *)(msg + sizeof(struct rte_ether_hdr));
	ip->version_ihl = 0x45;
	ip->type_of_service = 0;
	ip->total_length = htons(total_len - sizeof(struct rte_ether_hdr));
	ip->packet_id = 0;
	ip->fragment_offset = 0;
	ip->time_to_live = 64; // ttl = 64
	ip->next_proto_id = IPPROTO_UDP;
	ip->src_addr = gSrcIp;
	ip->dst_addr = gDstIp;
	
	ip->hdr_checksum = 0;
	ip->hdr_checksum = rte_ipv4_cksum(ip);

	// UDP 头
	struct rte_udp_hdr *udp = (struct rte_udp_hdr *)(msg + sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr));
	udp->src_port = gSrcPort;
	udp->dst_port = gDstPort;
	uint16_t udplen = total_len - sizeof(struct rte_ether_hdr) - sizeof(struct rte_ipv4_hdr);
	udp->dgram_len = htons(udplen);
	
	//要先填充 UDP 报文，再进行校验和计算
	rte_memcpy((uint8_t*)(udp+1), data, udplen);
	udp->dgram_cksum = 0;
	udp->dgram_cksum = rte_ipv4_udptcp_cksum(ip, udp);


	printf("````````````````````send````````````````````\n");

	struct in_addr addr;
	addr.s_addr = gSrcIp;
	printf("源IP和端口: %s:%d, ", inet_ntoa(addr), ntohs(gSrcPort));

	addr.s_addr = gDstIp;
	printf("目的IP和端口: %s:%d\n", inet_ntoa(addr), ntohs(gDstPort));

	return 0;
}

/*将待发送的负载数据封装成UDP数据包，存入rte_mbuf
参数；内存池、负载数据的指针、负载数据的大小 */
static struct rte_mbuf * ng_send(struct rte_mempool *mbuf_pool, uint8_t *data, uint16_t length) {

	//计算 UDP 数据包的总长度 = 以太网头部(14字节)+ IPv4头部(20字节) + UDP头部(8字节) + 负载数据
	// const unsigned total_len = length + 42;
	uint16_t total_len = length + sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr);

	//分配一个 rte_mbuf 数据包缓冲区
	struct rte_mbuf *mbuf = rte_pktmbuf_alloc(mbuf_pool);
	if (!mbuf) {
		rte_exit(EXIT_FAILURE, "rte_pktmbuf_alloc\n");
	}
	mbuf->pkt_len = total_len;
	mbuf->data_len = total_len;

	//将 mbuf 转换成一个 uint8_t* 类型的指针变量pktdata，并返回缓冲区数据的起始地址
	uint8_t *pktdata = rte_pktmbuf_mtod(mbuf, uint8_t*);

	//将负载数据封装成UDP数据包
	ng_encode_udp_pkt(pktdata, data, total_len);

	return mbuf;

}


int main(int argc, char *argv[]) {

	//初始化EAL环境
	if (rte_eal_init(argc, argv) < 0) {
		rte_exit(EXIT_FAILURE, "Error with EAL init\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 == NULL) {
		rte_exit(EXIT_FAILURE, "Could not create mbuf pool\n");
	}

	//初始化以太网设备
	ng_init_port(mbuf_pool);

	//rte_eth_macaddr_get(gDpdkPortId, (struct rte_ether_addr *)gSrcMac);

	while (1) {

		//从以太网接口的接收队列中读取数据包，存入mbufs
		struct rte_mbuf *mbufs[BURST_SIZE];
		unsigned num_recvd = rte_eth_rx_burst(gDpdkPortId, 0, mbufs, BURST_SIZE);
		if (num_recvd > BURST_SIZE) {
			rte_exit(EXIT_FAILURE, "Error receiving from eth\n");
		}

		unsigned i = 0;
		for (i = 0;i < num_recvd;i ++) {
			/*
							udp pkt

				-------------------------------------------------------------------
				| rte_ether_hdr | rte_ipv4_hdr | rte_udp_hdr |        data        |
				
			*/
			//获取以太网帧头部
			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)) { //判断以太网帧中的网络层协议是否为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) { //判断传输层协议是否为UDP，IPPROTO_UDP是一个常量，代表传输控制协议（UDP）的协议编号

				//获取udp头
				struct rte_udp_hdr *udphdr = (struct rte_udp_hdr *)(iphdr + 1);

				//在负载数据末尾插入了一个字符串结束符 '\0'
				uint16_t length = ntohs(udphdr->dgram_len);
				*((char*)udphdr + length) = '\0'; 

				printf("````````````````````receive````````````````````\n");

				struct in_addr addr;
				addr.s_addr = iphdr->src_addr; //源IP地址
				printf("源IP和端口: %s:%d, ", inet_ntoa(addr), ntohs(udphdr->src_port)); 

				addr.s_addr = iphdr->dst_addr; //目的IP地址
				printf("目的IP和端口: %s:%d,  接收数据: %s\n", inet_ntoa(addr), ntohs(udphdr->dst_port), 
					(char *)(udphdr+1));

#if ENABLE_SEND
				//接收和回传时候，源地址和目的地址，是相反的
				rte_memcpy(gSrcMac, ehdr->d_addr.addr_bytes, RTE_ETHER_ADDR_LEN);
				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));

				//待发送的负载数据封装成UDP数据包
				struct rte_mbuf *txbuf = ng_send(mbuf_pool, (uint8_t *)(udphdr+1), length - sizeof(struct rte_udp_hdr));

				//发送数据报
				rte_eth_tx_burst(gDpdkPortId, 0, &txbuf, 1);
				rte_pktmbuf_free(txbuf);
				
#endif

				rte_pktmbuf_free(mbufs[i]);
			}

			
		}

	}

}

四、dpdk一些基本函数接口

rte_eal_init()

初始化环境抽象层，在DPDK应用程序中使用DPDK库之前，必须首先调用rte_eal_init函数进行初始化。

#include <rte_eal.h>
int rte_eal_init(int argc, char **argv);

argc和argv参数分别表示应用程序的命令行参数数量和参数列表
在初始化完成后，它会返回0以表示初始化成功，或返回负值以表示初始化失败。

rte_pktmbuf_pool_create()

创建和初始化一个内存池，用于管理mempool对象中的mempool元素，同时用于存储和分发网络数据包的缓冲区。

#include <rte_mbuf.h>

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 
);

其中，各参数的含义如下：
1）name: 内存池的名称
2）n: 内存池中最多可以包含的元素数量
3）cache_size: 每个CPU缓存队列的大小，用于提高缓存命中率和性能
4）priv_size: 每个元素的私有数据大小，通常为0或包含一些与网络协议相关的元数据
5）data_room_size: 每个元素中数据缓冲区的大小，用于存储接收到的网络数据包或构建要发送的数据包
6）socket_id: 内存池分配的NUMA节点，-1表示由系统自动选择

rte_socket_id()

获取当前线程或者任务所在的CPU socket的ID

int rte_socket_id(void);

获取当前线程或者任务所在的CPU socket的ID

rte_eth_dev_configure()

配置和初始化指定的以太网设备及其相关参数。

int rte_eth_dev_configure(	
	uint16_t 	port_id,
	uint16_t 	nb_rx_queue,
	uint16_t 	nb_tx_queue,
	const struct rte_eth_conf * 	eth_conf 
);

其中，各参数的含义如下：
1）port_id: 待配置的以太网设备端口号
2）nb_rx_queue: 接收队列数量
3）nb_tx_queue: 发送队列数量
4）eth_conf: 以太网设备配置参数，包括MAC地址、速率、MTU等

rte_eth_rx_queue_setup()

配置和启动指定以太网设备的接收队列.

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 
);

其中各参数的含义如下：
1）port_id：待配置的以太网设备端口号。
2）rx_queue_id：待配置的接收队列编号。
3）nb_rx_desc：接收队列中缓冲区描述符的数量，决定了队列的深度和性能。
4）socket_id：所属的NUMA节点，用于内存分配。如果为RTE_ETH_DEV_NO_NUMA_SOCKET，则表示不分配NUMA节点。
5）rx_conf：接收队列相关的配置参数。
6）mb_pool：接收队列使用的内存池，用于存储接收到的数据包。

rte_eth_tx_queue_setup ()

配置和启动指定以太网设备的发送队列

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 
);

其中各参数的含义如下：
1）port_id：待配置的以太网设备端口号。
2）tx_queue_id：待配置的发送队列编号。
3）nb_tx_desc：发送队列中缓冲区描述符的数量，决定了队列的深度和性能。
4）socket_id：所属的NUMA节点，用于内存分配。如果为RTE_ETH_DEV_NO_NUMA_SOCKET，则表示不分配NUMA节点。
5）tx_conf：发送队列相关的配置参数。

rte_eth_dev_socket_id()

获取指定以太网设备所使用的 NUMA节点编号

int rte_eth_dev_socket_id( uint16_t 	port_id	)	

rte_eth_dev_start()

启动以太网设备。

int rte_eth_dev_start(uint16_t port_id);

rte_eth_rx_burst()

从指定的以太网设备的接收队列中获取数据包。

static uint16_t rte_eth_rx_burst	(	
	uint16_t 			port_id,
	uint16_t 			queue_id,
	struct rte_mbuf ** 	rx_pkts,
	const uint16_t 		nb_pkts 
);

其中各参数的含义如下：
1）port_id：待读取数据包的以太网设备端口号。
2）queue_id：待读取数据包的接收队列编号。
3）rx_pkts：用于存储读取数据包的缓冲区数组指针。
4）nb_pkts：缓冲区数组中可存储的最大数据包数量。
返回实际检索到的数据包数

rte_eth_tx_burst()

用于发送数据报.

static uint16_t rte_eth_tx_burst(	
	uint16_t 	port_id,
	uint16_t 	queue_id,
	struct rte_mbuf ** 	tx_pkts,
	uint16_t 	nb_pkts 
);

1）port_id: 要发送数据报的端口 ID。
2）queue_id: 要发送数据报的队列 ID。
3）tx_pkts: 一个指向 rte_mbuf 结构体指针数组的指针，数组中包含要发送的数据报。
4）nb_pkts: 要发送的数据报的数量。
返回实际发送的数据包数

rte_pktmbuf_mtod_offset()

将struct rte_mbuf类型的数据包缓冲区对象转换为指向偏移量处的缓冲区数据的指针。

#define rte_pktmbuf_mtod_offset	(m,t,o)	  ((t)(void *)((char *)(m)->buf_addr + (m)->data_off + (o)))

其中各参数的含义如下：
1）m：待转换为指针的rte_mbuf结构体对象。
2）t：指向缓冲区数据的指针类型，即要强制转换的类型。
3）o：偏移量。

rte_pktmbuf_mtod()

#define rte_pktmbuf_mtod(m,t ) rte_pktmbuf_mtod_offset(m, t, 0)

rte_pktmbuf_alloc()

用于分配一个rte_mbuf类型的缓冲区，可以用来存储网络数据包。需要注意的是，rte_mbuf缓冲区分为两部分：一个是元数据，主要用于存储关于包的信息，比如包的长度、IP地址等；另一个是包的实际数据，主要用于存储网络数据包的内容。

static struct rte_mbuf* rte_pktmbuf_alloc(struct rte_mempool *mp);

rte_memcpy()

用于将一个内存区域的数据内容复制到另一个内存区域。该函数与标准库函数 memcpy() 的语义相同，但是对于 DPDK 的应用场景做了一定的优化，可以提高拷贝性能。

void *rte_memcpy(void *dst, const void *src, size_t n);

其中，dst 是目标内存区域的指针，src 是源内存区域的指针，n 是拷贝的字节数。

rte_eth_dev_info_get()

获取指定 Ethernet 设备的设备信息。

void rte_eth_dev_info_get(uint16_t port_id, struct rte_eth_dev_info *dev_info);

该函数需要两个参数：
1）port_id：表示需要获取设备信息的端口 ID。
2）dev_info：一个指向 rte_eth_dev_info 结构体的指针。rte_eth_dev_info 结构体中包含了各种设备信息的字段，例如设备名称、设备类型、最大传输单元（MTU）大小等。

在调用 rte_eth_dev_info_get 函数之前，需要先声明一个 struct rte_eth_dev_info 类型的变量，以便将获取到的设备信息存储在其中。在调用函数时，需要将该变量的指针作为第二个参数传递给函数，以便函数可以将获取到的信息存储在该结构体中。

以太网协议的头部 rte_ether_hdr

#define RTE_ETHER_ADDR_LEN   6

typedef uint16_t rte_be16_t

struct rte_ether_addr{
	uint8_t 	addr_bytes [RTE_ETHER_ADDR_LEN];
};

struct rte_ether_hdr{
struct rte_ether_addr 	dst_addr;
struct rte_ether_addr 	src_addr;
rte_be16_t 				ether_type;
};

1）src_addr：一个长度为 6 字节的数组，表示源 MAC 地址；
2）dst_addr：一个长度为 6 字节的数组，表示目的 MAC 地址；
3）ether_type：一个 16 位无符号整数，表示以太网数据帧的类型，常见的有 IP 数据包、ARP 请求和响应等。

IPv4 协议的头部 rte_ipv4_hdr

/**
 * An IPv4 header.
 */
struct rte_ipv4_hdr {
    uint8_t version_ihl;    /**< version and header length */
    uint8_t type_of_service;/**< type of service */
    uint16_t total_length;  /**< length of packet including header */
    uint16_t packet_id;     /**< unique packet ID */
    uint16_t fragment_offset;/**< fragment offset field */
    uint8_t time_to_live;   /**< time to live */
    uint8_t next_proto_id;  /**< protocol ID */
    uint16_t hdr_checksum;  /**< header checksum */
    uint32_t src_addr;      /**< source address */
    uint32_t dst_addr;      /**< destination address */
} __attribute__((__packed__));

1）version_ihl：一个 8 位无符号整数，表示 IPv4 头部的版本和长度信息；
2）type_of_service：一个 8 位无符号整数，表示服务类型信息；
3）total_length：一个 16 位无符号整数，表示整个 IPv4 数据包的长度；
4）packet_id：一个 16 位无符号整数，表示数据包的唯一标识符；
5）fragment_offset：一个 16 位无符号整数，表示分段信息，常用于分片后的数据包重组；
6）time_to_live：一个 8 位无符号整数，表示数据包的生存时间；
7）next_proto_id：一个 8 位无符号整数，表示下一层协议的 ID，例如 TCP、UDP 等；
8）hdr_checksum：一个 16 位无符号整数，表示 IPv4 头部的校验和；
9）src_addr：一个 32 位无符号整数，表示源 IP 地址；
10）dst_addr：一个 32 位无符号整数，表示目的 IP 地址。

UDP协议的头部 rte_udp_hdr

 /**
 * A UDP header.
 */
struct rte_udp_hdr {
    uint16_t src_port;  /**< UDP source port. */
    uint16_t dst_port;  /**< UDP destination port. */
    uint16_t dgram_len; /**< Length of UDP datagram including header. */
    uint16_t dgram_cksum; /**< UDP datagram checksum (0 if not used). */
} __attribute__((__packed__));

1）src_port：一个 16 位无符号整数，表示 UDP 数据包的源端口号。
2）dst_port：一个 16 位无符号整数，表示 UDP 数据包的目的端口号。
3）dgram_len：一个 16 位无符号整数，表示 UDP 数据报的总长度（包括头部和负载数据）。
4）dgram_cksum：一个 16 位无符号整数，用于存储 UDP 数据包的校验和。如果该字段为 0，则表示数据包没有启用校验和。

小问题

uint8_t *和char *的区别和适用场景

uint8_t * 和 char * 都是 C 语言中常用的指针类型，它们之间的主要区别在于指向的对象类型。uint8_t * 表示一个指向 unsigned char 类型数据的指针，而 char * 则表示一个指向 char 类型数据的指针。两者都占用1个字节（即8位）的内存空间，因此可以将它们视为等价的数据类型。
char * 指针适用于字符串操作、文件读写等普遍场景，而 uint8_t * 指针则适用于二进制数据处理、网络编程、加密解密等专用领域。