• 用户态协议栈设计实现

    目录

    1. 网络模式

    2. 获取原始数据

    3. UDP数据帧格式

    以太网协议头(数据链路层) -- 14byte

    IP数据头(网络层) -- 20byte

    UDP协议的数据格式(传输层) -- 8byte

    4. 封装协议头

    协议头代码

    柔性数组

    5.Netmap和API介绍

    5.1 netmap原理介绍

    5.2 nm_open 函数

    5.3 nm_nextpkt函数

    5.4 nm_close 函数

    6. 测试用户态协议栈

    完整代码

    结果显示

    7. arp协议实现

    报文格式

    完整代码

    结果显示

    8. icmp协议实现

    完整代码

    结果显示

    1. 网络模式

     在物理层上，双绞线传的是电信号，光纤传的是光信号。

    网卡即不在物理层，也不在数据链路层，是在这两层之间做转换。

    数据传输的流程

    网卡将物理层的光电信号转换为数字信号（0101010）。给到网卡驱动，然后把这个数据(通过sk_buff（搬运工)) 拷贝迁移到协议栈。 然后协议栈解析完数据之后将数据拷贝放入recv buffer，然后应用程序通过系统调用就能得到这个数据。

    2. 获取原始数据

    获取原始数据的三种方法介绍

    不经过网络协议栈解析，拿到原始数据sk_buff；

    1. 使用原始套接字raw socket ， tcpdump和wireshark就是使用这个做的，raw socket主要用来抓包。
    2. dbdk
    3. netmap是用于用户层应用程序收发原始网络数据的高性能框架，本文使用netmap进行数据的收发。

    3. UDP数据帧格式

    以太网协议头(数据链路层) -- 14byte

    目地MAC地址（6字节）
    源MAC地址（6字节）
    类型（2字节）：IP协议=0x0800

    数据段的长度为46到1500字节


    以太网数据帧并没有表示长度的字段。主机确定以太网数据帧接收完毕依靠的是主机接收器感受不到电压变换。当接收器感受不到电压的变化时，表明这一帧数据已经接收完成。

    IP数据头(网络层) -- 20byte

     

     字节和数字的存储顺序是从右到左，依次是从低位到高位，而网络存储顺序是从左到右，依次从低位到高位。

    1. 版本：占第一个字节的高四位。IPV4 = 0100, IPV4 = 0110。
    2. 首部长度：占第一个字节的低四位。4位能最表示15字节的长度。
    3. 服务类型：前3位为优先字段权，现在已经被忽略。接着4位用来表示最小延迟、最大吞吐量、最高可靠性和最小费用。
    4. 总长度：整个IP报的长度，单位为字节。16位范围为65535，最大发64k。MTU=1500是最大传输单元，发送需要分片。
    5. 16位标识：分片后的所有的包有同样的标识。比如15k数据分割成如干个1500字节的包有同样的标识。
    6. 3位标志：缺省。
    7. 13位片偏移：分片后的所有的包基于原来的整包的偏移。
    8. 生存时间（TTL）：就是封包的生存时间。通常用通过的路由器的个数来衡量，比如初始值设置为32，则每通过一个路由器处理就会被减一，当这个值为0的时候就会丢掉这个包，并用ICMP消息通知源主机。
    9. 协议：定义了数据的协议，分别为：TCP、UDP、ICMP和IGMP。定义为：

            ＃define PROTOCOL_TCP    0x06

            ＃define PROTOCOL_UDP    0x11

            ＃define PROTOCOL_ICMP   0x06

            ＃define PROTOCOL_IGMP   0x06

    1. 首部检验和：校验的首先将该字段设置为0，然后将IP头的每16位进行二进制取反求和，将结果保存在校验和字段。
    2. 源IP地址：将IP地址看作是32位数值则需要将网络字节序转化位主机字节序。转化的方法是：将每4个字节首尾互换，将2、3字节互换。
    3. 目的IP地址：转换方法和来源IP地址一样。

    UDP协议的数据格式(传输层) -- 8byte

    （1）源端口（Source Port）：16位的源端口域包含初始化通信的端口号。源端口和IP地址的作用是标识报文的返回地址。

    （2）目的端口（Destination Port）：16位的目的端口域定义传输的目的。这个端口指明报文接收计算机上的应用程序地址接口。

    （3）封包长度（Length）：UDP头和数据的总长度。

    （4）校验和（Check Sum）：和TCP和校验和一样，不仅对头数据进行校验，还对包的内容进行校验。

    4. 封装协议头

    协议头代码

    1. #define ETHER_ADDR_LEN 6
    2.  
    3. //以太网首部
    4. struct ether_hdr{
    5. 	unsigned char dst_mac[ETHER_ADDR_LEN]; 	//目地MAC地址
    6. 	unsigned char src_mac[ETHER_ADDR_LEN];	//源MAC地址
    7. 	unsigned shor protocol;					//类型
    8. };
    9.  
    10. //IP数据头
    11. struct ip_hdr{
    12. 	unsigned char version:4,	//版本
    13. 				  hdrlen:4;		//首部长度
    14. 	unsigned char tos;			//服务类型
    15. 	unsigned short totlen;		//总长度
    16.  
    17. 	unsigned short id;			//标识
    18. 	unsigned short flag:3,		//标志 缺省
    19. 				   offset:13;	//片偏移
    20.  
    21. 	unsigned char ttl;			//生存时间（TTL）
    22. 	unsigned char protocol;		//协议
    23. 	unsigned short check;		//首部检验和
    24.  
    25. 	unsigned int sip;			//源IP地址
    26. 	unsigned int dip;			//目的IP地址
    27. };
    28.  
    29. //UDP协议头
    30. struct udp_hdr{
    31. 	unsigned short sport;		//源端口
    32. 	unsigned short dport;		//目的端口
    33. 	
    34. 	unsigned short length;		//封包长度
    35. 	unsigned short check;		//校验和
    36. };
    37.  
    38. struct udp_pkt {
    39. 	struct ether_hdr eh;
    40. 	struct ip_hdr ip;
    41. 	struct udp_hdr udp;
    42. 	unsigned char payload[0]; 	//柔性数组
    43. };

    柔性数组

    长度为0的数组的主要用途是为了满足需要变长度的结构体

    1. 用法 : 在一个结构体的最后, 申明一个长度为0的数组, 就可以使得这个结构体是可变长的。
    2. 对于编译器而言, 数组名仅仅是一个符号, 它不会占用任何空间, 它在结构体中, 只是代表了一个偏移量, 代表一个不可修改的地址常量。

    两个情况下是可以使用柔性数组的:

    1：内存是已经分配好的。

    2：这个柔性数组的长度不确定但是我们是可以通过其他方法计算出来的。

    5.Netmap和API介绍

    5.1 netmap原理介绍

            内核协议栈的数据到应用层的数据会经历两次拷贝，而netmap采用mmap的方式，直接将网卡的数据映射到一块内存中，应用程序可以直接通过mmap操作相应内存的数据。

     

     

             DMA方式，将网卡映射到内存中去(mmap)。 应用程序是可以在内存中间直接读取这块映射过来的数据的。（DMA的方式不需要通过CPU去执行指令，直接将数据放入内存）这就叫零拷贝。

    5.2 nm_open 函数

    1.调用 nm_open 函数时，如：nmr = nm_open("netmap:eth0", NULL, 0, NULL); nm_open()会
    对传递的 ifname 指针里面的字符串进行分析，提取出网络接口名。
    2.nm_open() 会 对 struct nm_desc *d 申 请 内 存 空 间 ， 并 通 过 d->fd =
    open(NETMAP_DEVICE_NAME, O_RDWR);打开一个特殊的设备/dev/netmap 来创建文件描述
    符 d->fd。
    3.通过 ioctl(d->fd, NIOCREGIF, &d->req)语句，将 d->fd 绑定到一个特殊的接口，并对 d->req
    结构体里面的成员做初始化，包括 a.在共享内存区域中 nifp 的偏移，b.共享区域的大小
    nr_memsize，c.tx/rx 环的大小 nr_tx_slots/nr_rx_slots(大小为 256)，d.tx/rx 环的数量 nr_tx_rings、nr_rx_rings(视硬件性能而定)等。
    4.接着在 if ((!(new_flags & NM_OPEN_NO_MMAP) || parent) && nm_mmap(d, parent))语句
    中调用 nm_mmap 函数，继续给d指针指向的内存赋值。

    5.3 nm_nextpkt函数

    1. nm_nextpkt()是用来接收网卡上到来的数据包的函数。
    2. nm_nextpkt()会将所有 rx 环都检查一遍，当发现有一个 rx 环有需要接收的数据包时，
    得到这个数据包的地址，并返回。所以 nm_nextpkt()每次只能取一个数据包。
    nm_nextpkt()源代码：

    1. static u_char *nm_nextpkt(struct nm_desc *d, struct nm_pkthdr *hdr)
    2. {
    3. int ri = d->cur_rx_ring; //当前的接收环的编号
    4. do
    5. {
    6. /* compute current ring to use */
    7. struct netmap_ring *ring = NETMAP_RXRING(d->nifp, ri); //得
    8. 到当前 rx 环的地址
    9. if (!nm_ring_empty(ring)) //判断环里是否有新到的包
    10. {
    11. u_int i = ring->cur; //当前该访问哪个槽(buffer)了
    12. u_int idx = ring->slot[i].buf_idx; //得到第 i 个 buffer 的
    13. 下标
    14. //printf("%d\n", idx);
    15. u_char *buf = (u_char *) NETMAP_BUF(ring, idx); //得到存
    16. 有到来数据包的地址
    17. // __builtin_prefetch(buf);
    18. hdr->ts = ring->ts;
    19. hdr->len = hdr->caplen = ring->slot[i].len;
    20. ring->cur = nm_ring_next(ring, i); //ring->cur 向后移动
    21. 一位
    22. /* we could postpone advancing head if we want
    23. * to hold the buffer. This can be supported in
    24. * the future.
    25. */
    26. ring->head = ring->cur;
    27. d->cur_rx_ring = ri; //将当前环(d->cur_rx_ring)指向第 ri
    28. 个(因为可能有多个环)。
    29. return buf; //将数据包地址返回
    30. }
    31. ri++;
    32. if (ri > d->last_rx_ring) //如果 ri 超过了 rx 环的数量，则再从
    33. 第一个 rx 环开始检测是否有包到来。
    34. ri = d->first_rx_ring;
    35. } while (ri != d->cur_rx_ring);
    36. return NULL; /* 什么也没发现 */
    37. }

    5.4 nm_close 函数

    源代码： 

    1.nm_close 函数就是回收动态内存，回收共享内存，关闭文件描述符什么的了。 

    1. static int nm_close(struct nm_desc *d)
    2. {
    3. /*
    4. * ugly trick to avoid unused warnings
    5. */
    6. static void *__xxzt[] __attribute__ ((unused)) =
    7. { (void *) nm_open, (void *) nm_inject, (void *) nm_dispatch,
    8. (void *) nm_nextpkt };
    9. if (d == NULL || d->self != d)
    10. return EINVAL;
    11. if (d->done_mmap && d->mem)
    12. munmap(d->mem, d->memsize); //释放申请的共享内存
    13. if (d->fd != -1)
    14. {
    15. close(d->fd); //关闭文件描述符
    16. }
    17. bzero(d, sizeof(*d)); //将 d 指向的空间全部置 0
    18. free(d); //释放指针 d 指向的空间
    19. return 0;
    20. }

    6. 测试用户态协议栈

    需要insmod netmap.ko ，然后我们查看ls /dev/netmap -l

    完整代码

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. #include 
    7. #include 
    8.  
    9.  
    10. #define NETMAP_WITH_LIBS	//开启netmap
    11.  
    12. #include  
    13.  
    14.  
    15.  
    16.  
    17. #pragma pack(1) 	//1字节对齐
    18.  
    19. //#define NETMAP_WITH_LIBS 
    20.  
    21. #define ETHER_ADDR_LEN 6
    22. #define PROTOT_IP 	0x0800	//IP协议
    23. #define PROTOT_UDP 	0x11		//UDP协议
    24.  
    25. //以太网首部
    26. struct ether_hdr{
    27. 	unsigned char dst_mac[ETHER_ADDR_LEN]; 	//目地MAC地址
    28. 	unsigned char src_mac[ETHER_ADDR_LEN];	//源MAC地址
    29. 	unsigned short protocol;					//类型
    30. };
    31.  
    32. //IP数据头
    33. struct ip_hdr{
    34. 	unsigned char version:4,	//版本
    35. 				  hdrlen:4;		//首部长度
    36. 	unsigned char tos;			//服务类型
    37. 	unsigned short totlen;		//总长度
    38.  
    39. 	unsigned short id;			//标识
    40. 	unsigned short flag:3,		//标志 缺省
    41. 				   offset:13;	//片偏移
    42.  
    43. 	unsigned char ttl;			//生存时间（TTL）
    44. 	unsigned char protocol;		//协议
    45. 	unsigned short check;		//首部检验和
    46.  
    47. 	unsigned int sip;			//源IP地址
    48. 	unsigned int dip;			//目的IP地址
    49. };
    50.  
    51. //UDP协议头
    52. struct udp_hdr{
    53. 	unsigned short sport;		//源端口
    54. 	unsigned short dport;		//目的端口
    55. 	
    56. 	unsigned short length;		//封包长度
    57. 	unsigned short check;		//校验和
    58. };
    59.  
    60. struct udp_pkt {
    61. 	struct ether_hdr eh;
    62. 	struct ip_hdr ip;
    63. 	struct udp_hdr udp;
    64. 	unsigned char payload[0]; 	//柔性数组
    65. };
    66.  
    67.  
    68. // netmap -- > personal
    69.  
    70. int main()
    71. {
    72. 	struct nm_pkthdr h;
    73. 	struct nm_desc *nmr = nm_open("netmap:ens38", NULL, 0, NULL);
    74. 	if(nmr == NULL)return -1;
    75.  
    76. 	//加入poll监控IO
    77. 	struct pollfd pfd = {0};
    78. 	pfd.fd = nmr->fd;
    79. 	pfd.events = POLLIN;
    80.  
    81. 	while(1){
    82. 		int ret = poll(&pfd, 1, -1);
    83. 		if(ret < 0)continue;
    84.  
    85. 		if(pfd.revents & POLLIN){
    86. 			unsigned char* stream = nm_nextpkt(nmr, &h); //接收网卡上到来的数据包
    87.  
    88. 			struct ether_hdr* eh = (struct ether_hdr*)stream;
    89.  
    90. 			if(ntohs(eh->protocol) == PROTOT_IP){ //是IP数据
    91. 				struct udp_pkt* pkt = (struct udp_pkt*)stream;
    92. 				if(pkt->ip.protocol == PROTOT_UDP){ //UDP协议
    93. 					int length = ntohs(pkt->udp.length);
    94.  
    95. 					pkt->payload[length - 8] = '\0';
    96. 					printf("pkt: %s\n", pkt->payload);
    97. 				}
    98. 			}
    99. 		}
    100. 	}
    101. }
    102.

    结果显示

            当客户端（windows）向服务端（windows下的linux虚拟机）发送信息的时候，发现发送了一段时间后就没法发送了

    在windows下cmd里面输入arp -a
    可以看到里面有arp表，里面有我测试的服务端的地址192.168.240.130，因此此时可以发送udp数据成功

    但是由于是动态arp，可能此arp项会消失，因此会导致udp数据发送失败。
    主要是因为客户端这边的arp表内没有 服务器的arp信息。

    当客户端发送数据包的时候，如果arp表内没有相应的信息，就会发送arp请求，因此服务端还要具有相应arp请求的功能。

    7. arp协议实现

    arp协议是在网络层的，所以我们先解析ether，再解析arp

    报文格式

     

    1. 硬件类型：16位字段，用来定义运行ARP的网络类型。每个局域网基于其类型被指派一个整数。例如：以太网的类型为1。ARP可用在任何物理网络上。
    2. 协议类型：16位字段，用来定义使用的协议。例如：对IPv4协议这个字段是0800。ARP可用于任何高层协议
    3. 硬件长度：8位字段，用来定义物理地址的长度，以字节为单位。例如：对于以太网的值为6。
    4. 协议长度：8位字段，用来定义逻辑地址的长度，以字节为单位。例如：对于IPv4协议的值为4。
    5. 操作码：16位字段，用来定义报文的类型。已定义的分组类型有两种：ARP请求（1），ARP响应（2）。
    6. 源硬件地址：这是一个可变长度字段，用来定义发送方的物理地址。例如：对于以太网这个字段的长度是6字节。
    7. 源逻辑地址：这是一个可变长度字段，用来定义发送方的逻辑（IP）地址。例如：对于IP协议这个字段的长度是4字节。
    8. 目的硬件地址：这是一个可变长度字段，用来定义目标的物理地址，例如，对以太网来说这个字段位6字节。对于ARP请求报文，这个字段为全0，因为发送方并不知道目标的硬件地址。

            9. 目的逻辑地址：这是一个可变长度字段，用来定义目标的逻辑（IP）地址，对于IPv4协议这个字段的长度为4个字节。

    完整代码

    udp+arp测试代码

    1. //insmod netmap.ko
    2. //gcc -o arp_netmap arp_netmap.c
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #define NETMAP_WITH_LIBS	//开启netmap
    8. #include 
    9. #include 
    10.  
    11. #pragma pack(1)
    12. #define ETH_ADDR_LENGTH 6
    13. #define PROTO_IP 0x0800
    14. #define PROTO_ARP 0x0806
    15. #define PROTO_RARP	0x0835
    16. #define PROTP_UDP 17
    17.  
    18. struct ethhdr {
    19.     unsigned char h_dst[ETH_ADDR_LENGTH];//目地MAC地址
    20.     unsigned char h_src[ETH_ADDR_LENGTH];//源MAC地址
    21.     unsigned short h_proto;//类型
    22. };
    23.  
    24. struct iphdr {
    25.     unsigned char hdrlen: 4,	//版本
    26.             version: 4;			//首部长度
    27.     unsigned char tos;			//服务类型
    28.     unsigned short totlen;		//总长度
    29.     unsigned short id;			//标识
    30.     unsigned short flag_offset;  //片偏移
    31.     unsigned char ttl;			//生存时间（TTL）
    32.     unsigned char type;			//协议
    33.     unsigned short check;		//首部检验和
    34.     unsigned int sip;			//源IP地址
    35.     unsigned int dip;			//目的IP地址
    36. };
    37.  
    38. struct ippkt {
    39.     struct ethhdr eh; //14
    40.     struct iphdr ip; //20
    41. };
    42.  
    43. struct udphdr {
    44.     unsigned short sport;		//源端口
    45.     unsigned short dport;		//目的端口
    46.     unsigned short length;		//封包长度
    47.     unsigned short check;		//校验和
    48. };
    49.  
    50. struct udppkt {	
    51.     struct ethhdr eh; //14
    52.     struct iphdr ip; //20
    53.     struct udphdr udp;//8
    54.     unsigned char data[0];
    55. };
    56.  
    57. struct arphdr {
    58.     unsigned short h_type;		//硬件类型
    59.     unsigned short h_proto;		//协议类型
    60.  
    61.     unsigned char h_addrlen;	//硬件长度
    62.     unsigned char h_protolen;	//协议长度
    63.  
    64.     unsigned short oper;		//操作码 ARP请求（1），ARP响应（2）
    65.  
    66.     unsigned char smac[ETH_ADDR_LENGTH];	//源硬件地址
    67.     unsigned int sip;						//源逻辑地址
    68.     unsigned char dmac[ETH_ADDR_LENGTH];	//目的硬件地址
    69.     unsigned int dip;						//目的逻辑地址
    70. };
    71.  
    72. struct arppkt {
    73.     struct ethhdr eh;
    74.     struct arphdr arp;
    75. };
    76.  
    77.  
    78. int str2mac(char *mac, char *str) {
    79.     char *p = str;
    80.     unsigned char value = 0x0;
    81.     int i = 0;
    82.     while (p != '\0') {
    83.         if (*p == ':') {
    84.             mac[i++] = value;
    85.             value = 0x0;
    86.         }
    87.         else {
    88.             unsigned char temp = *p;
    89.             if (temp <= '9' && temp >= '0') {
    90.                 temp -= '0';
    91.             }
    92.             else if (temp <= 'f' && temp >= 'a') {
    93.                 temp -= 'a';
    94.                 temp += 10;
    95.             }
    96.             else if (temp <= 'F' && temp >= 'A') {
    97.                 temp -= 'A';
    98.                 temp += 10;
    99.             }
    100.             else {
    101.                 break;
    102.             }
    103.             value <<= 4;
    104.             value |= temp;
    105.         }
    106.         p++;
    107.     }
    108.     mac[i] = value;
    109.     return 0;
    110. }
    111.  
    112. void echo_udp_pkt(struct udppkt *udp, struct udppkt *udp_rt) {
    113.     memcpy(udp_rt, udp, sizeof(struct udppkt));
    114.     memcpy(udp_rt->eh.h_dst, udp->eh.h_src, ETH_ADDR_LENGTH);
    115.     memcpy(udp_rt->eh.h_src, udp->eh.h_dst, ETH_ADDR_LENGTH);
    116.     udp_rt->ip.sip = udp->ip.dip;
    117.     udp_rt->ip.dip = udp->ip.sip;
    118.     udp_rt->udp.sport = udp->udp.dport;
    119.     udp_rt->udp.dport = udp->udp.sport;
    120. }
    121.  
    122.  
    123. void echo_arp_pkt(struct arppkt *arp, struct arppkt *arp_rt, char *mac) {
    124.     memcpy(arp_rt, arp, sizeof(struct arppkt));
    125.     memcpy(arp_rt->eh.h_dst, arp->eh.h_src, ETH_ADDR_LENGTH);//以太网首部填入目的 mac
    126.     str2mac(arp_rt->eh.h_src, mac);//以太网首部填入源mac
    127.     arp_rt->eh.h_proto = arp->eh.h_proto;//以太网协议还是arp协议
    128.     arp_rt->arp.h_addrlen = 6;
    129.     arp_rt->arp.h_protolen = 4;
    130.     arp_rt->arp.oper = htons(2); // ARP响应
    131.     str2mac(arp_rt->arp.smac, mac);//arp报文填入源mac 
    132.     arp_rt->arp.sip = arp->arp.dip; // arp报文填入发送端 ip
    133.     memcpy(arp_rt->arp.dmac, arp->arp.smac, ETH_ADDR_LENGTH);//arp报文填入目的 mac 
    134.     arp_rt->arp.dip = arp->arp.sip; // arp报文填入目的 ip
    135. }
    136.  
    137.  
    138. int main() {
    139.     struct nm_pkthdr h;
    140.     struct nm_desc *nmr = nm_open("netmap:ens38", NULL, 0, NULL);
    141.     if (nmr == NULL) {
    142.         return -1;
    143.     }
    144.     printf("open ens33 seccess\n");
    145.     struct pollfd pfd = {0};
    146.     pfd.fd = nmr->fd;
    147.     pfd.events = POLLIN;
    148. 	
    149.     while (1) {
    150.         printf("new data coming!\n");
    151.         int ret = poll(&pfd, 1, -1);
    152.         if (ret < 0) {
    153.             continue;
    154.         }
    155. 		
    156.         if (pfd.revents & POLLIN) {
    157.             unsigned char *stream = nm_nextpkt(nmr, &h);
    158.             struct ethhdr *eh = (struct ethhdr *) stream;
    159.             if (ntohs(eh->h_proto) == PROTO_IP) {
    160.                 struct ippkt *iph=(struct ippkt *)stream;
    161.                 if (iph->ip.type == PROTP_UDP) {
    162.                     struct udppkt *udp = (struct udppkt *) stream;
    163.                     int udplength = ntohs(udp->udp.length);
    164.                     udp->data[udplength - 8] = '\0';
    165.                     printf("udp ---> %s\n", udp->data);
    166.                     struct udppkt udp_rt;
    167.                     echo_udp_pkt(udp, &udp_rt);
    168.                     nm_inject(nmr, &udp_rt, sizeof(struct udppkt));
    169.                 }
    170.             }
    171.             else if (ntohs(eh->h_proto) == PROTO_ARP) {
    172.                 struct arppkt *arp = (struct arppkt *) stream;
    173.                 struct arppkt arp_rt;
    174.                 if (arp->arp.dip == inet_addr("192.168.240.130")) {
    175.                     echo_arp_pkt(arp, &arp_rt, "00:0c:29:7b:e4:67");
    176.                     nm_inject(nmr, &arp_rt, sizeof(arp_rt));
    177.                     printf("arp ret\n");
    178.                 }
    179.             }
    180.         }
    181.     }
    182.     nm_close(nmr);
    183. }
    184.

    结果显示

    响应了arp请求

             调用 nm_open 函数，网卡的数据就不从内核协议栈走了，不能ping通，ping是icmp协议。发现ping不同，但是我们是接收到数据包了的，下面就来实现icmp协议

    8. icmp协议实现

    ICMP协议是IP的一个组成部分，负责传递 。

    类型（Type）：4位，标明ICMP报文的作用及格式。ping请求是8，ping回应是0

    代码（Code）：4位，标明报文的类型。ping的代码为0

    校验和：8位，检验报文是否有误。

    完整代码

    1. //insmod netmap.ko
    2. //gcc -o icmp_netmap icmp_netmap.c
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. #define NETMAP_WITH_LIBS
    9.  
    10. #include 
    11. #include 
    12.  
    13. #pragma pack(1)
    14. #define ETH_ADDR_LENGTH 6
    15. #define PROTO_IP 0x0800
    16. #define PROTO_ARP 0x0806
    17. #define PROTO_RARP    0x0835
    18. #define PROTP_UDP 17
    19. #define PROTO_ICMP    1
    20.  
    21. struct ethhdr {
    22.     unsigned char h_dst[ETH_ADDR_LENGTH];//目地MAC地址
    23.     unsigned char h_src[ETH_ADDR_LENGTH];//源MAC地址
    24.     unsigned short h_proto;//类型
    25. };
    26.  
    27. struct iphdr {
    28.     unsigned char hdrlen: 4,	//版本
    29.             version: 4;			//首部长度
    30.     unsigned char tos;			//服务类型
    31.     unsigned short totlen;		//总长度
    32.     unsigned short id;			//标识
    33.     unsigned short flag_offset;  //片偏移
    34.     unsigned char ttl;			//生存时间（TTL）
    35.     unsigned char type;			//协议
    36.     unsigned short check;		//首部检验和
    37.     unsigned int sip;			//源IP地址
    38.     unsigned int dip;			//目的IP地址
    39. };
    40.  
    41. struct ippkt {
    42.     struct ethhdr eh; //14
    43.     struct iphdr ip; //20
    44. };
    45.  
    46. struct udphdr {
    47.     unsigned short sport;		//源端口
    48.     unsigned short dport;		//目的端口
    49.     unsigned short length;		//封包长度
    50.     unsigned short check;		//校验和
    51. };
    52.  
    53. struct udppkt {	
    54.     struct ethhdr eh; //14
    55.     struct iphdr ip; //20
    56.     struct udphdr udp;//8
    57.     unsigned char data[0];
    58. };
    59.  
    60. struct arphdr {
    61.     unsigned short h_type;		//硬件类型
    62.     unsigned short h_proto;		//协议类型
    63.  
    64.     unsigned char h_addrlen;	//硬件长度
    65.     unsigned char h_protolen;	//协议长度
    66.  
    67.     unsigned short oper;		//操作码 ARP请求（1），ARP响应（2）
    68.  
    69.     unsigned char smac[ETH_ADDR_LENGTH];	//源硬件地址
    70.     unsigned int sip;						//源逻辑地址
    71.     unsigned char dmac[ETH_ADDR_LENGTH];	//目的硬件地址
    72.     unsigned int dip;						//目的逻辑地址
    73. };
    74.  
    75. struct arppkt {
    76.     struct ethhdr eh;
    77.     struct arphdr arp;
    78. };
    79.  
    80.  
    81. int str2mac(char *mac, char *str) {
    82.     char *p = str;
    83.     unsigned char value = 0x0;
    84.     int i = 0;
    85.     while (p != '\0') {
    86.         if (*p == ':') {
    87.             mac[i++] = value;
    88.             value = 0x0;
    89.         }
    90.         else {
    91.             unsigned char temp = *p;
    92.             if (temp <= '9' && temp >= '0') {
    93.                 temp -= '0';
    94.             }
    95.             else if (temp <= 'f' && temp >= 'a') {
    96.                 temp -= 'a';
    97.                 temp += 10;
    98.             }
    99.             else if (temp <= 'F' && temp >= 'A') {
    100.                 temp -= 'A';
    101.                 temp += 10;
    102.             }
    103.             else {
    104.                 break;
    105.             }
    106.             value <<= 4;
    107.             value |= temp;
    108.         }
    109.         p++;
    110.     }
    111.     mac[i] = value;
    112.     return 0;
    113. }
    114.  
    115. void echo_udp_pkt(struct udppkt *udp, struct udppkt *udp_rt) {
    116.     memcpy(udp_rt, udp, sizeof(struct udppkt));
    117.     memcpy(udp_rt->eh.h_dst, udp->eh.h_src, ETH_ADDR_LENGTH);
    118.     memcpy(udp_rt->eh.h_src, udp->eh.h_dst, ETH_ADDR_LENGTH);
    119.     udp_rt->ip.sip = udp->ip.dip;
    120.     udp_rt->ip.dip = udp->ip.sip;
    121.     udp_rt->udp.sport = udp->udp.dport;
    122.     udp_rt->udp.dport = udp->udp.sport;
    123. }
    124.  
    125.  
    126. void echo_arp_pkt(struct arppkt *arp, struct arppkt *arp_rt, char *mac) {
    127.     memcpy(arp_rt, arp, sizeof(struct arppkt));
    128.     memcpy(arp_rt->eh.h_dst, arp->eh.h_src, ETH_ADDR_LENGTH);//以太网首部填入目的 mac
    129.     str2mac(arp_rt->eh.h_src, mac);//以太网首部填入源mac
    130.     arp_rt->eh.h_proto = arp->eh.h_proto;//以太网协议还是arp协议
    131.     arp_rt->arp.h_addrlen = 6;
    132.     arp_rt->arp.h_protolen = 4;
    133.     arp_rt->arp.oper = htons(2); // ARP响应
    134.     str2mac(arp_rt->arp.smac, mac);//arp报文填入源mac 
    135.     arp_rt->arp.sip = arp->arp.dip; // arp报文填入发送端 ip
    136.     memcpy(arp_rt->arp.dmac, arp->arp.smac, ETH_ADDR_LENGTH);//arp报文填入目的 mac 
    137.     arp_rt->arp.dip = arp->arp.sip; // arp报文填入目的 ip
    138. }
    139.  
    140.  
    141. struct icmphdr {
    142.     unsigned char type;	//类型 ping请求是8，ping回应是0
    143.     unsigned char code;	//代码（Code）：4位，标明报文的类型。ping的代码为0
    144.     unsigned short check; //校验和
    145.     unsigned short identifier;	//标识符
    146.     unsigned short seq;			//序号
    147.     unsigned char data[32];		//选项数据
    148. };
    149.  
    150. struct icmppkt {
    151.     struct ethhdr eh;
    152.     struct iphdr ip;
    153.     struct icmphdr icmp;
    154. };
    155.  
    156. unsigned short in_cksum(unsigned short *addr, int len) {
    157.     register int nleft = len;
    158.     register unsigned short *w = addr;
    159.     register int sum = 0;
    160.     unsigned short answer = 0;
    161.     while (nleft > 1) {
    162.         sum += *w++;
    163.         nleft -= 2;
    164.     }
    165.     if (nleft == 1) {
    166.         *(u_char *) (&answer) = *(u_char *) w;
    167.         sum += answer;
    168.     }
    169.     sum = (sum >> 16) + (sum & 0xffff);
    170.     sum += (sum >> 16);
    171.     answer = ~sum;
    172.     return (answer);
    173. }
    174.  
    175. void echo_icmp_pkt(struct icmppkt *icmp, struct icmppkt *icmp_rt) {
    176.     memcpy(icmp_rt, icmp, sizeof(struct icmppkt));
    177.     icmp_rt->icmp.type = 0x0; //
    178.     icmp_rt->icmp.code = 0x0; //
    179.     icmp_rt->icmp.check = 0x0;
    180.     icmp_rt->ip.sip = icmp->ip.dip;
    181.     icmp_rt->ip.dip = icmp->ip.sip;
    182.     memcpy(icmp_rt->eh.h_dst, icmp->eh.h_src, ETH_ADDR_LENGTH);
    183.     memcpy(icmp_rt->eh.h_src, icmp->eh.h_dst, ETH_ADDR_LENGTH);
    184.     icmp_rt->icmp.check = in_cksum((unsigned short *) &icmp_rt->icmp, sizeof(struct icmphdr));
    185. }
    186.  
    187. int main() {
    188.     struct nm_pkthdr h;
    189.     struct nm_desc *nmr = nm_open("netmap:ens38", NULL, 0, NULL);
    190.     if (nmr == NULL) {
    191.         return -1;
    192.     }
    193.     printf("open ens33 seccess\n");
    194.     struct pollfd pfd = {0};
    195.     pfd.fd = nmr->fd;
    196.     pfd.events = POLLIN;
    197. 	
    198.     while (1) {
    199.         printf("new data coming!\n");
    200.         int ret = poll(&pfd, 1, -1);
    201.         if (ret < 0) {
    202.             continue;
    203.         }
    204. 		
    205.         if (pfd.revents & POLLIN) {
    206.             unsigned char *stream = nm_nextpkt(nmr, &h);
    207.             struct ethhdr *eh = (struct ethhdr *) stream;
    208.             if (ntohs(eh->h_proto) == PROTO_IP) {
    209.                 struct ippkt *iph=(struct ippkt *)stream;
    210.                 if (iph->ip.type == PROTP_UDP) {
    211.                     struct udppkt *udp = (struct udppkt *) stream;
    212.                     int udplength = ntohs(udp->udp.length);
    213.                     udp->data[udplength - 8] = '\0';
    214.                     printf("udp ---> %s\n", udp->data);
    215.                     struct udppkt udp_rt;
    216.                     echo_udp_pkt(udp, &udp_rt);
    217.                     nm_inject(nmr, &udp_rt, sizeof(struct udppkt));
    218.                 }
    219. 				else if (iph->ip.type == PROTO_ICMP) {
    220.                     struct icmppkt *icmp = (struct icmppkt *) stream;
    221.                     printf("icmp ---------- --> %d, %x\n", icmp->icmp.type, icmp->icmp.check);
    222.                     if (icmp->icmp.type == 0x08) {
    223.                         struct icmppkt icmp_rt = {0};
    224.                         echo_icmp_pkt(icmp, &icmp_rt);
    225.                         nm_inject(nmr, &icmp_rt, sizeof(struct icmppkt));
    226.                     }
    227.                 }
    228.             }
    229.             else if (ntohs(eh->h_proto) == PROTO_ARP) {
    230.                 struct arppkt *arp = (struct arppkt *) stream;
    231.                 struct arppkt arp_rt;
    232.                 if (arp->arp.dip == inet_addr("192.168.240.130")) {
    233.                     echo_arp_pkt(arp, &arp_rt, "00:0c:29:7b:e4:67");
    234.                     nm_inject(nmr, &arp_rt, sizeof(arp_rt));
    235.                     printf("arp ret\n");
    236.                 }
    237.             }
    238. 			
    239.         }
    240.     }
    241.     nm_close(nmr);
    242. }
    243.

    结果显示

    运行上面的代码，发现udp，arp，icmp都可以正常解析和发送

     

    推荐一个不错的学习网站 C/C++后台高级服务器icon-default.png?t=M85Bhttps://ke.qq.com/course/417774?flowToken=1010783。

  • 相关阅读:
    大语言模型黑盒被打破；Meta 元宇宙硬件亏损可能高于市场共识丨 RTE 开发者日报 Vol.60
    python的小作业
    P7961 [NOIP2021] 数列
    【vue】0到1的常规vue3项目起步
    什么是单域名SSL安全证书？
    【MM32F5270开发板试用】基于MindSDK实现水深度数据采集
    深入理解数据结构（1）—用链表实现栈
    [原创]基于Jsp+Servlet的疫苗接种管理系统的设计与实现（Web设计源代码）
    用了CDN就一定比不用更快吗？
    进度条、git常见指令以及gdb的常用指令
  • 原文地址：https://blog.csdn.net/kakaka666/article/details/126688456