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