1 /* SPDX-License-Identifier: GPL-2.0 2 * Copyright (c) 2018 Facebook 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of version 2 of the GNU General Public 6 * License as published by the Free Software Foundation. 7 * 8 * This program shows how to use bpf_xdp_adjust_tail() by 9 * generating ICMPv4 "packet to big" (unreachable/ df bit set frag needed 10 * to be more preice in case of v4)" where receiving packets bigger then 11 * 600 bytes. 12 */ 13 #define KBUILD_MODNAME "foo" 14 #include <uapi/linux/bpf.h> 15 #include <linux/in.h> 16 #include <linux/if_ether.h> 17 #include <linux/if_packet.h> 18 #include <linux/if_vlan.h> 19 #include <linux/ip.h> 20 #include <linux/icmp.h> 21 #include <bpf/bpf_helpers.h> 22 23 #define DEFAULT_TTL 64 24 #define MAX_PCKT_SIZE 600 25 #define ICMP_TOOBIG_SIZE 98 26 #define ICMP_TOOBIG_PAYLOAD_SIZE 92 27 28 /* volatile to prevent compiler optimizations */ 29 static volatile __u32 max_pcktsz = MAX_PCKT_SIZE; 30 31 struct { 32 __uint(type, BPF_MAP_TYPE_ARRAY); 33 __type(key, __u32); 34 __type(value, __u64); 35 __uint(max_entries, 1); 36 } icmpcnt SEC(".maps"); 37 38 static __always_inline void count_icmp(void) 39 { 40 u64 key = 0; 41 u64 *icmp_count; 42 43 icmp_count = bpf_map_lookup_elem(&icmpcnt, &key); 44 if (icmp_count) 45 *icmp_count += 1; 46 } 47 48 static __always_inline void swap_mac(void *data, struct ethhdr *orig_eth) 49 { 50 struct ethhdr *eth; 51 52 eth = data; 53 memcpy(eth->h_source, orig_eth->h_dest, ETH_ALEN); 54 memcpy(eth->h_dest, orig_eth->h_source, ETH_ALEN); 55 eth->h_proto = orig_eth->h_proto; 56 } 57 58 static __always_inline __u16 csum_fold_helper(__u32 csum) 59 { 60 csum = (csum & 0xffff) + (csum >> 16); 61 return ~((csum & 0xffff) + (csum >> 16)); 62 } 63 64 static __always_inline void ipv4_csum(void *data_start, int data_size, 65 __u32 *csum) 66 { 67 *csum = bpf_csum_diff(0, 0, data_start, data_size, *csum); 68 *csum = csum_fold_helper(*csum); 69 } 70 71 static __always_inline int send_icmp4_too_big(struct xdp_md *xdp) 72 { 73 int headroom = (int)sizeof(struct iphdr) + (int)sizeof(struct icmphdr); 74 75 if (bpf_xdp_adjust_head(xdp, 0 - headroom)) 76 return XDP_DROP; 77 void *data = (void *)(long)xdp->data; 78 void *data_end = (void *)(long)xdp->data_end; 79 80 if (data + (ICMP_TOOBIG_SIZE + headroom) > data_end) 81 return XDP_DROP; 82 83 struct iphdr *iph, *orig_iph; 84 struct icmphdr *icmp_hdr; 85 struct ethhdr *orig_eth; 86 __u32 csum = 0; 87 __u64 off = 0; 88 89 orig_eth = data + headroom; 90 swap_mac(data, orig_eth); 91 off += sizeof(struct ethhdr); 92 iph = data + off; 93 off += sizeof(struct iphdr); 94 icmp_hdr = data + off; 95 off += sizeof(struct icmphdr); 96 orig_iph = data + off; 97 icmp_hdr->type = ICMP_DEST_UNREACH; 98 icmp_hdr->code = ICMP_FRAG_NEEDED; 99 icmp_hdr->un.frag.mtu = htons(max_pcktsz - sizeof(struct ethhdr)); 100 icmp_hdr->checksum = 0; 101 ipv4_csum(icmp_hdr, ICMP_TOOBIG_PAYLOAD_SIZE, &csum); 102 icmp_hdr->checksum = csum; 103 iph->ttl = DEFAULT_TTL; 104 iph->daddr = orig_iph->saddr; 105 iph->saddr = orig_iph->daddr; 106 iph->version = 4; 107 iph->ihl = 5; 108 iph->protocol = IPPROTO_ICMP; 109 iph->tos = 0; 110 iph->tot_len = htons( 111 ICMP_TOOBIG_SIZE + headroom - sizeof(struct ethhdr)); 112 iph->check = 0; 113 csum = 0; 114 ipv4_csum(iph, sizeof(struct iphdr), &csum); 115 iph->check = csum; 116 count_icmp(); 117 return XDP_TX; 118 } 119 120 121 static __always_inline int handle_ipv4(struct xdp_md *xdp) 122 { 123 void *data_end = (void *)(long)xdp->data_end; 124 void *data = (void *)(long)xdp->data; 125 int pckt_size = data_end - data; 126 int offset; 127 128 if (pckt_size > max(max_pcktsz, ICMP_TOOBIG_SIZE)) { 129 offset = pckt_size - ICMP_TOOBIG_SIZE; 130 if (bpf_xdp_adjust_tail(xdp, 0 - offset)) 131 return XDP_PASS; 132 return send_icmp4_too_big(xdp); 133 } 134 return XDP_PASS; 135 } 136 137 SEC("xdp_icmp") 138 int _xdp_icmp(struct xdp_md *xdp) 139 { 140 void *data_end = (void *)(long)xdp->data_end; 141 void *data = (void *)(long)xdp->data; 142 struct ethhdr *eth = data; 143 __u16 h_proto; 144 145 if (eth + 1 > data_end) 146 return XDP_DROP; 147 148 h_proto = eth->h_proto; 149 150 if (h_proto == htons(ETH_P_IP)) 151 return handle_ipv4(xdp); 152 else 153 return XDP_PASS; 154 } 155 156 char _license[] SEC("license") = "GPL"; 157