net/ipv4/udp_tunnel.c

   1 #include <linux/module.h>
   2 #include <linux/errno.h>
   3 #include <linux/socket.h>
   4 #include <linux/udp.h>
   5 #include <linux/types.h>
   6 #include <linux/kernel.h>
   7 #include <net/dst_metadata.h>
   8 #include <net/net_namespace.h>
   9 #include <net/udp.h>
  10 #include <net/udp_tunnel.h>
  11
  12 int udp_sock_create4(struct net *net, struct udp_port_cfg *cfg,
  13                      struct socket **sockp)
  14 {
  15         int err;
  16         struct socket *sock = NULL;
  17         struct sockaddr_in udp_addr;
  18
  19         err = sock_create_kern(net, AF_INET, SOCK_DGRAM, 0, &sock);
  20         if (err < 0)
  21                 goto error;
  22
  23         udp_addr.sin_family = AF_INET;
  24         udp_addr.sin_addr = cfg->local_ip;
  25         udp_addr.sin_port = cfg->local_udp_port;
  26         err = kernel_bind(sock, (struct sockaddr *)&udp_addr,
  27                           sizeof(udp_addr));
  28         if (err < 0)
  29                 goto error;
  30
  31         if (cfg->peer_udp_port) {
  32                 udp_addr.sin_family = AF_INET;
  33                 udp_addr.sin_addr = cfg->peer_ip;
  34                 udp_addr.sin_port = cfg->peer_udp_port;
  35                 err = kernel_connect(sock, (struct sockaddr *)&udp_addr,
  36                                      sizeof(udp_addr), 0);
  37                 if (err < 0)
  38                         goto error;
  39         }
  40
  41         sock->sk->sk_no_check_tx = !cfg->use_udp_checksums;
  42
  43         *sockp = sock;
  44         return 0;
  45
  46 error:
  47         if (sock) {
  48                 kernel_sock_shutdown(sock, SHUT_RDWR);
  49                 sock_release(sock);
  50         }
  51         *sockp = NULL;
  52         return err;
  53 }
  54 EXPORT_SYMBOL(udp_sock_create4);
  55
  56 void setup_udp_tunnel_sock(struct net *net, struct socket *sock,
  57                            struct udp_tunnel_sock_cfg *cfg)
  58 {
  59         struct sock *sk = sock->sk;
  60
  61         /* Disable multicast loopback */
  62         inet_sk(sk)->mc_loop = 0;
  63
  64         /* Enable CHECKSUM_UNNECESSARY to CHECKSUM_COMPLETE conversion */
  65         inet_inc_convert_csum(sk);
  66
  67         rcu_assign_sk_user_data(sk, cfg->sk_user_data);
  68
  69         udp_sk(sk)->encap_type = cfg->encap_type;
  70         udp_sk(sk)->encap_rcv = cfg->encap_rcv;
  71         udp_sk(sk)->encap_destroy = cfg->encap_destroy;
  72         udp_sk(sk)->gro_receive = cfg->gro_receive;
  73         udp_sk(sk)->gro_complete = cfg->gro_complete;
  74
  75         udp_tunnel_encap_enable(sock);
  76 }
  77 EXPORT_SYMBOL_GPL(setup_udp_tunnel_sock);
  78
  79 static void __udp_tunnel_push_rx_port(struct net_device *dev,
  80                                       struct udp_tunnel_info *ti)
  81 {
  82         if (dev->netdev_ops->ndo_udp_tunnel_add) {
  83                 dev->netdev_ops->ndo_udp_tunnel_add(dev, ti);
  84                 return;
  85         }
  86
  87         switch (ti->type) {
  88         case UDP_TUNNEL_TYPE_VXLAN:
  89                 if (!dev->netdev_ops->ndo_add_vxlan_port)
  90                         break;
  91
  92                 dev->netdev_ops->ndo_add_vxlan_port(dev,
  93                                                     ti->sa_family,
  94                                                     ti->port);
  95                 break;
  96         case UDP_TUNNEL_TYPE_GENEVE:
  97                 if (!dev->netdev_ops->ndo_add_geneve_port)
  98                         break;
  99
 100                 dev->netdev_ops->ndo_add_geneve_port(dev,
 101                                                      ti->sa_family,
 102                                                      ti->port);
 103                 break;
 104         default:
 105                 break;
 106         }
 107 }
 108
 109 void udp_tunnel_push_rx_port(struct net_device *dev, struct socket *sock,
 110                              unsigned short type)
 111 {
 112         struct sock *sk = sock->sk;
 113         struct udp_tunnel_info ti;
 114
 115         ti.type = type;
 116         ti.sa_family = sk->sk_family;
 117         ti.port = inet_sk(sk)->inet_sport;
 118
 119         __udp_tunnel_push_rx_port(dev, &ti);
 120 }
 121 EXPORT_SYMBOL_GPL(udp_tunnel_push_rx_port);
 122
 123 /* Notify netdevs that UDP port started listening */
 124 void udp_tunnel_notify_add_rx_port(struct socket *sock, unsigned short type)
 125 {
 126         struct sock *sk = sock->sk;
 127         struct net *net = sock_net(sk);
 128         struct udp_tunnel_info ti;
 129         struct net_device *dev;
 130
 131         ti.type = type;
 132         ti.sa_family = sk->sk_family;
 133         ti.port = inet_sk(sk)->inet_sport;
 134
 135         rcu_read_lock();
 136         for_each_netdev_rcu(net, dev)
 137                 __udp_tunnel_push_rx_port(dev, &ti);
 138         rcu_read_unlock();
 139 }
 140 EXPORT_SYMBOL_GPL(udp_tunnel_notify_add_rx_port);
 141
 142 static void __udp_tunnel_pull_rx_port(struct net_device *dev,
 143                                       struct udp_tunnel_info *ti)
 144 {
 145         if (dev->netdev_ops->ndo_udp_tunnel_del) {
 146                 dev->netdev_ops->ndo_udp_tunnel_del(dev, ti);
 147                 return;
 148         }
 149
 150         switch (ti->type) {
 151         case UDP_TUNNEL_TYPE_VXLAN:
 152                 if (!dev->netdev_ops->ndo_del_vxlan_port)
 153                         break;
 154
 155                 dev->netdev_ops->ndo_del_vxlan_port(dev,
 156                                                     ti->sa_family,
 157                                                     ti->port);
 158                 break;
 159         case UDP_TUNNEL_TYPE_GENEVE:
 160                 if (!dev->netdev_ops->ndo_del_geneve_port)
 161                         break;
 162
 163                 dev->netdev_ops->ndo_del_geneve_port(dev,
 164                                                      ti->sa_family,
 165                                                      ti->port);
 166                 break;
 167         default:
 168                 break;
 169         }
 170 }
 171
 172 /* Notify netdevs that UDP port is no more listening */
 173 void udp_tunnel_notify_del_rx_port(struct socket *sock, unsigned short type)
 174 {
 175         struct sock *sk = sock->sk;
 176         struct net *net = sock_net(sk);
 177         struct udp_tunnel_info ti;
 178         struct net_device *dev;
 179
 180         ti.type = type;
 181         ti.sa_family = sk->sk_family;
 182         ti.port = inet_sk(sk)->inet_sport;
 183
 184         rcu_read_lock();
 185         for_each_netdev_rcu(net, dev)
 186                 __udp_tunnel_pull_rx_port(dev, &ti);
 187         rcu_read_unlock();
 188 }
 189 EXPORT_SYMBOL_GPL(udp_tunnel_notify_del_rx_port);
 190
 191 void udp_tunnel_xmit_skb(struct rtable *rt, struct sock *sk, struct sk_buff *skb,
 192                          __be32 src, __be32 dst, __u8 tos, __u8 ttl,
 193                          __be16 df, __be16 src_port, __be16 dst_port,
 194                          bool xnet, bool nocheck)
 195 {
 196         struct udphdr *uh;
 197
 198         __skb_push(skb, sizeof(*uh));
 199         skb_reset_transport_header(skb);
 200         uh = udp_hdr(skb);
 201
 202         uh->dest = dst_port;
 203         uh->source = src_port;
 204         uh->len = htons(skb->len);
 205
 206         memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
 207
 208         udp_set_csum(nocheck, skb, src, dst, skb->len);
 209
 210         iptunnel_xmit(sk, rt, skb, src, dst, IPPROTO_UDP, tos, ttl, df, xnet);
 211 }
 212 EXPORT_SYMBOL_GPL(udp_tunnel_xmit_skb);
 213
 214 void udp_tunnel_sock_release(struct socket *sock)
 215 {
 216         rcu_assign_sk_user_data(sock->sk, NULL);
 217         kernel_sock_shutdown(sock, SHUT_RDWR);
 218         sock_release(sock);
 219 }
 220 EXPORT_SYMBOL_GPL(udp_tunnel_sock_release);
 221
 222 struct metadata_dst *udp_tun_rx_dst(struct sk_buff *skb,  unsigned short family,
 223                                     __be16 flags, __be64 tunnel_id, int md_size)
 224 {
 225         struct metadata_dst *tun_dst;
 226         struct ip_tunnel_info *info;
 227
 228         if (family == AF_INET)
 229                 tun_dst = ip_tun_rx_dst(skb, flags, tunnel_id, md_size);
 230         else
 231                 tun_dst = ipv6_tun_rx_dst(skb, flags, tunnel_id, md_size);
 232         if (!tun_dst)
 233                 return NULL;
 234
 235         info = &tun_dst->u.tun_info;
 236         info->key.tp_src = udp_hdr(skb)->source;
 237         info->key.tp_dst = udp_hdr(skb)->dest;
 238         if (udp_hdr(skb)->check)
 239                 info->key.tun_flags |= TUNNEL_CSUM;
 240         return tun_dst;
 241 }
 242 EXPORT_SYMBOL_GPL(udp_tun_rx_dst);
 243
 244 MODULE_LICENSE("GPL");