1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef __NET_UDP_TUNNEL_H 3 #define __NET_UDP_TUNNEL_H 4 5 #include <net/ip_tunnels.h> 6 #include <net/udp.h> 7 8 #if IS_ENABLED(CONFIG_IPV6) 9 #include <net/ipv6.h> 10 #include <net/ipv6_stubs.h> 11 #endif 12 13 struct udp_port_cfg { 14 u8 family; 15 16 /* Used only for kernel-created sockets */ 17 union { 18 struct in_addr local_ip; 19 #if IS_ENABLED(CONFIG_IPV6) 20 struct in6_addr local_ip6; 21 #endif 22 }; 23 24 union { 25 struct in_addr peer_ip; 26 #if IS_ENABLED(CONFIG_IPV6) 27 struct in6_addr peer_ip6; 28 #endif 29 }; 30 31 __be16 local_udp_port; 32 __be16 peer_udp_port; 33 int bind_ifindex; 34 unsigned int use_udp_checksums:1, 35 use_udp6_tx_checksums:1, 36 use_udp6_rx_checksums:1, 37 ipv6_v6only:1; 38 }; 39 40 int udp_sock_create4(struct net *net, struct udp_port_cfg *cfg, 41 struct socket **sockp); 42 43 #if IS_ENABLED(CONFIG_IPV6) 44 int udp_sock_create6(struct net *net, struct udp_port_cfg *cfg, 45 struct socket **sockp); 46 #else 47 static inline int udp_sock_create6(struct net *net, struct udp_port_cfg *cfg, 48 struct socket **sockp) 49 { 50 return 0; 51 } 52 #endif 53 54 static inline int udp_sock_create(struct net *net, 55 struct udp_port_cfg *cfg, 56 struct socket **sockp) 57 { 58 if (cfg->family == AF_INET) 59 return udp_sock_create4(net, cfg, sockp); 60 61 if (cfg->family == AF_INET6) 62 return udp_sock_create6(net, cfg, sockp); 63 64 return -EPFNOSUPPORT; 65 } 66 67 typedef int (*udp_tunnel_encap_rcv_t)(struct sock *sk, struct sk_buff *skb); 68 typedef int (*udp_tunnel_encap_err_lookup_t)(struct sock *sk, 69 struct sk_buff *skb); 70 typedef void (*udp_tunnel_encap_destroy_t)(struct sock *sk); 71 typedef struct sk_buff *(*udp_tunnel_gro_receive_t)(struct sock *sk, 72 struct list_head *head, 73 struct sk_buff *skb); 74 typedef int (*udp_tunnel_gro_complete_t)(struct sock *sk, struct sk_buff *skb, 75 int nhoff); 76 77 struct udp_tunnel_sock_cfg { 78 void *sk_user_data; /* user data used by encap_rcv call back */ 79 /* Used for setting up udp_sock fields, see udp.h for details */ 80 __u8 encap_type; 81 udp_tunnel_encap_rcv_t encap_rcv; 82 udp_tunnel_encap_err_lookup_t encap_err_lookup; 83 udp_tunnel_encap_destroy_t encap_destroy; 84 udp_tunnel_gro_receive_t gro_receive; 85 udp_tunnel_gro_complete_t gro_complete; 86 }; 87 88 /* Setup the given (UDP) sock to receive UDP encapsulated packets */ 89 void setup_udp_tunnel_sock(struct net *net, struct socket *sock, 90 struct udp_tunnel_sock_cfg *sock_cfg); 91 92 /* -- List of parsable UDP tunnel types -- 93 * 94 * Adding to this list will result in serious debate. The main issue is 95 * that this list is essentially a list of workarounds for either poorly 96 * designed tunnels, or poorly designed device offloads. 97 * 98 * The parsing supported via these types should really be used for Rx 99 * traffic only as the network stack will have already inserted offsets for 100 * the location of the headers in the skb. In addition any ports that are 101 * pushed should be kept within the namespace without leaking to other 102 * devices such as VFs or other ports on the same device. 103 * 104 * It is strongly encouraged to use CHECKSUM_COMPLETE for Rx to avoid the 105 * need to use this for Rx checksum offload. It should not be necessary to 106 * call this function to perform Tx offloads on outgoing traffic. 107 */ 108 enum udp_parsable_tunnel_type { 109 UDP_TUNNEL_TYPE_VXLAN, /* RFC 7348 */ 110 UDP_TUNNEL_TYPE_GENEVE, /* draft-ietf-nvo3-geneve */ 111 UDP_TUNNEL_TYPE_VXLAN_GPE, /* draft-ietf-nvo3-vxlan-gpe */ 112 }; 113 114 struct udp_tunnel_info { 115 unsigned short type; 116 sa_family_t sa_family; 117 __be16 port; 118 }; 119 120 /* Notify network devices of offloadable types */ 121 void udp_tunnel_push_rx_port(struct net_device *dev, struct socket *sock, 122 unsigned short type); 123 void udp_tunnel_drop_rx_port(struct net_device *dev, struct socket *sock, 124 unsigned short type); 125 void udp_tunnel_notify_add_rx_port(struct socket *sock, unsigned short type); 126 void udp_tunnel_notify_del_rx_port(struct socket *sock, unsigned short type); 127 128 static inline void udp_tunnel_get_rx_info(struct net_device *dev) 129 { 130 ASSERT_RTNL(); 131 call_netdevice_notifiers(NETDEV_UDP_TUNNEL_PUSH_INFO, dev); 132 } 133 134 static inline void udp_tunnel_drop_rx_info(struct net_device *dev) 135 { 136 ASSERT_RTNL(); 137 call_netdevice_notifiers(NETDEV_UDP_TUNNEL_DROP_INFO, dev); 138 } 139 140 /* Transmit the skb using UDP encapsulation. */ 141 void udp_tunnel_xmit_skb(struct rtable *rt, struct sock *sk, struct sk_buff *skb, 142 __be32 src, __be32 dst, __u8 tos, __u8 ttl, 143 __be16 df, __be16 src_port, __be16 dst_port, 144 bool xnet, bool nocheck); 145 146 #if IS_ENABLED(CONFIG_IPV6) 147 int udp_tunnel6_xmit_skb(struct dst_entry *dst, struct sock *sk, 148 struct sk_buff *skb, 149 struct net_device *dev, struct in6_addr *saddr, 150 struct in6_addr *daddr, 151 __u8 prio, __u8 ttl, __be32 label, 152 __be16 src_port, __be16 dst_port, bool nocheck); 153 #endif 154 155 void udp_tunnel_sock_release(struct socket *sock); 156 157 struct metadata_dst *udp_tun_rx_dst(struct sk_buff *skb, unsigned short family, 158 __be16 flags, __be64 tunnel_id, 159 int md_size); 160 161 #ifdef CONFIG_INET 162 static inline int udp_tunnel_handle_offloads(struct sk_buff *skb, bool udp_csum) 163 { 164 int type = udp_csum ? SKB_GSO_UDP_TUNNEL_CSUM : SKB_GSO_UDP_TUNNEL; 165 166 return iptunnel_handle_offloads(skb, type); 167 } 168 #endif 169 170 static inline void udp_tunnel_encap_enable(struct socket *sock) 171 { 172 struct udp_sock *up = udp_sk(sock->sk); 173 174 if (up->encap_enabled) 175 return; 176 177 up->encap_enabled = 1; 178 #if IS_ENABLED(CONFIG_IPV6) 179 if (sock->sk->sk_family == PF_INET6) 180 ipv6_stub->udpv6_encap_enable(); 181 else 182 #endif 183 udp_encap_enable(); 184 } 185 186 #endif 187