include/net/udp_tunnel.h

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