Branch data     Line data    Source code

       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                 :          0 : static inline void udp_tunnel_get_rx_info(struct net_device *dev)
     129                 :            : {
     130                 :          0 :         ASSERT_RTNL();
     131                 :            :         call_netdevice_notifiers(NETDEV_UDP_TUNNEL_PUSH_INFO, dev);
     132                 :          0 : }
     133                 :            : 
     134                 :          0 : static inline void udp_tunnel_drop_rx_info(struct net_device *dev)
     135                 :            : {
     136                 :          0 :         ASSERT_RTNL();
     137                 :            :         call_netdevice_notifiers(NETDEV_UDP_TUNNEL_DROP_INFO, dev);
     138                 :          0 : }
     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                 :          0 : static inline void udp_tunnel_encap_enable(struct socket *sock)
     171                 :            : {
     172                 :          0 :         struct udp_sock *up = udp_sk(sock->sk);
     173                 :            : 
     174                 :          0 :         if (up->encap_enabled)
     175                 :          0 :                 return;
     176                 :            : 
     177                 :          0 :         up->encap_enabled = 1;
     178                 :            : #if IS_ENABLED(CONFIG_IPV6)
     179                 :          0 :         if (sock->sk->sk_family == PF_INET6)
     180                 :          0 :                 ipv6_stub->udpv6_encap_enable();
     181                 :            :         else
     182                 :            : #endif
     183                 :            :                 udp_encap_enable();
     184                 :            : }
     185                 :            : 
     186                 :            : #endif