datapath/linux/compat/udp_tunnel.c

   1 #include <linux/version.h>
   2
   3 #ifndef USE_UPSTREAM_TUNNEL
   4
   5 #include <linux/module.h>
   6 #include <linux/errno.h>
   7 #include <linux/socket.h>
   8 #include <linux/udp.h>
   9 #include <linux/types.h>
  10 #include <linux/kernel.h>
  11 #include <net/ip_tunnels.h>
  12 #include <net/udp.h>
  13 #include <net/udp_tunnel.h>
  14 #include <net/net_namespace.h>
  15 #include <net/ip6_checksum.h>
  16 #include <net/ip6_tunnel.h>
  17
  18 #include "gso.h"
  19
  20 int rpl_udp_sock_create4(struct net *net, struct udp_port_cfg *cfg,
  21                          struct socket **sockp)
  22 {
  23         int err;
  24         struct socket *sock = NULL;
  25         struct sockaddr_in udp_addr;
  26
  27         err = sock_create_kern(net, AF_INET, SOCK_DGRAM, 0, &sock);
  28         if (err < 0)
  29                 goto error;
  30
  31         udp_addr.sin_family = AF_INET;
  32         udp_addr.sin_addr = cfg->local_ip;
  33         udp_addr.sin_port = cfg->local_udp_port;
  34         err = kernel_bind(sock, (struct sockaddr *)&udp_addr,
  35                         sizeof(udp_addr));
  36         if (err < 0)
  37                 goto error;
  38
  39         if (cfg->peer_udp_port) {
  40                 udp_addr.sin_family = AF_INET;
  41                 udp_addr.sin_addr = cfg->peer_ip;
  42                 udp_addr.sin_port = cfg->peer_udp_port;
  43                 err = kernel_connect(sock, (struct sockaddr *)&udp_addr,
  44                                 sizeof(udp_addr), 0);
  45                 if (err < 0)
  46                         goto error;
  47         }
  48 #ifdef HAVE_SK_NO_CHECK_TX
  49         sock->sk->sk_no_check_tx = !cfg->use_udp_checksums;
  50 #endif
  51         *sockp = sock;
  52         return 0;
  53
  54 error:
  55         if (sock) {
  56                 kernel_sock_shutdown(sock, SHUT_RDWR);
  57                 sock_release(sock);
  58         }
  59         *sockp = NULL;
  60         return err;
  61 }
  62 EXPORT_SYMBOL(rpl_udp_sock_create4);
  63
  64 int rpl_udp_sock_create6(struct net *net, struct udp_port_cfg *cfg,
  65                          struct socket **sockp)
  66 {
  67         struct sockaddr_in6 udp6_addr;
  68         int err;
  69         struct socket *sock = NULL;
  70
  71         err = sock_create_kern(net, AF_INET6, SOCK_DGRAM, 0, &sock);
  72         if (err < 0)
  73                 goto error;
  74
  75         if (cfg->ipv6_v6only) {
  76                 int val = 1;
  77
  78                 err = kernel_setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY,
  79                                 (char *) &val, sizeof(val));
  80                 if (err < 0)
  81                         goto error;
  82         }
  83
  84         udp6_addr.sin6_family = AF_INET6;
  85         memcpy(&udp6_addr.sin6_addr, &cfg->local_ip6,
  86                         sizeof(udp6_addr.sin6_addr));
  87         udp6_addr.sin6_port = cfg->local_udp_port;
  88         err = kernel_bind(sock, (struct sockaddr *)&udp6_addr,
  89                         sizeof(udp6_addr));
  90         if (err < 0)
  91                 goto error;
  92
  93         if (cfg->peer_udp_port) {
  94                 udp6_addr.sin6_family = AF_INET6;
  95                 memcpy(&udp6_addr.sin6_addr, &cfg->peer_ip6,
  96                                 sizeof(udp6_addr.sin6_addr));
  97                 udp6_addr.sin6_port = cfg->peer_udp_port;
  98                 err = kernel_connect(sock,
  99                                 (struct sockaddr *)&udp6_addr,
 100                                 sizeof(udp6_addr), 0);
 101         }
 102         if (err < 0)
 103                 goto error;
 104
 105         udp_set_no_check6_tx(sock->sk, !cfg->use_udp6_tx_checksums);
 106         udp_set_no_check6_rx(sock->sk, !cfg->use_udp6_rx_checksums);
 107
 108         *sockp = sock;
 109         return 0;
 110
 111 error:
 112         if (sock) {
 113                 kernel_sock_shutdown(sock, SHUT_RDWR);
 114                 sock_release(sock);
 115         }
 116         *sockp = NULL;
 117         return err;
 118 }
 119 EXPORT_SYMBOL_GPL(rpl_udp_sock_create6);
 120
 121 void rpl_setup_udp_tunnel_sock(struct net *net, struct socket *sock,
 122                                struct udp_tunnel_sock_cfg *cfg)
 123 {
 124         struct sock *sk = sock->sk;
 125
 126         /* Disable multicast loopback */
 127         inet_sk(sk)->mc_loop = 0;
 128
 129         rcu_assign_sk_user_data(sk, cfg->sk_user_data);
 130
 131         udp_sk(sk)->encap_type = cfg->encap_type;
 132         udp_sk(sk)->encap_rcv = cfg->encap_rcv;
 133 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0)
 134         udp_sk(sk)->encap_destroy = cfg->encap_destroy;
 135 #endif
 136 #ifdef HAVE_UDP_TUNNEL_SOCK_CFG_GRO_RECEIVE
 137         udp_sk(sk)->gro_receive = cfg->gro_receive;
 138         udp_sk(sk)->gro_complete = cfg->gro_complete;
 139 #endif
 140
 141         udp_tunnel_encap_enable(sock);
 142 }
 143 EXPORT_SYMBOL_GPL(rpl_setup_udp_tunnel_sock);
 144
 145 void rpl_udp_tunnel_xmit_skb(struct rtable *rt, struct sock *sk,
 146                             struct sk_buff *skb, __be32 src, __be32 dst,
 147                             __u8 tos, __u8 ttl, __be16 df, __be16 src_port,
 148                             __be16 dst_port, bool xnet, bool nocheck)
 149 {
 150         struct udphdr *uh;
 151
 152         __skb_push(skb, sizeof(*uh));
 153         skb_reset_transport_header(skb);
 154         uh = udp_hdr(skb);
 155
 156         uh->dest = dst_port;
 157         uh->source = src_port;
 158         uh->len = htons(skb->len);
 159
 160         udp_set_csum(nocheck, skb, src, dst, skb->len);
 161
 162         iptunnel_xmit(sk, rt, skb, src, dst, IPPROTO_UDP, tos, ttl, df, xnet);
 163 }
 164 EXPORT_SYMBOL_GPL(rpl_udp_tunnel_xmit_skb);
 165
 166 void rpl_udp_tunnel_sock_release(struct socket *sock)
 167 {
 168         rcu_assign_sk_user_data(sock->sk, NULL);
 169         kernel_sock_shutdown(sock, SHUT_RDWR);
 170         sock_release(sock);
 171 }
 172 EXPORT_SYMBOL_GPL(rpl_udp_tunnel_sock_release);
 173
 174 #if IS_ENABLED(CONFIG_IPV6)
 175
 176 #define udp_v6_check rpl_udp_v6_check
 177 static __sum16 udp_v6_check(int len,
 178                                    const struct in6_addr *saddr,
 179                                    const struct in6_addr *daddr,
 180                                    __wsum base)
 181 {
 182         return csum_ipv6_magic(saddr, daddr, len, IPPROTO_UDP, base);
 183 }
 184
 185 #define udp6_set_csum rpl_udp6_set_csum
 186 static void udp6_set_csum(bool nocheck, struct sk_buff *skb,
 187                           const struct in6_addr *saddr,
 188                           const struct in6_addr *daddr, int len)
 189 {
 190         struct udphdr *uh = udp_hdr(skb);
 191
 192         if (nocheck)
 193                 uh->check = 0;
 194         else if (skb_is_gso(skb))
 195                 uh->check = ~udp_v6_check(len, saddr, daddr, 0);
 196         else if (skb_dst(skb) && skb_dst(skb)->dev &&
 197                  (skb_dst(skb)->dev->features & NETIF_F_IPV6_CSUM)) {
 198
 199                 BUG_ON(skb->ip_summed == CHECKSUM_PARTIAL);
 200
 201                 skb->ip_summed = CHECKSUM_PARTIAL;
 202                 skb->csum_start = skb_transport_header(skb) - skb->head;
 203                 skb->csum_offset = offsetof(struct udphdr, check);
 204                 uh->check = ~udp_v6_check(len, saddr, daddr, 0);
 205         } else {
 206                 __wsum csum;
 207
 208                 BUG_ON(skb->ip_summed == CHECKSUM_PARTIAL);
 209
 210                 uh->check = 0;
 211                 csum = skb_checksum(skb, 0, len, 0);
 212                 uh->check = udp_v6_check(len, saddr, daddr, csum);
 213                 if (uh->check == 0)
 214                         uh->check = CSUM_MANGLED_0;
 215
 216                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 217         }
 218 }
 219
 220 #define ip6_flow_hdr rpl_ip6_flow_hdr
 221 static inline void ip6_flow_hdr(struct ipv6hdr *hdr, unsigned int tclass,
 222                 __be32 flowlabel)
 223 {
 224         *(__be32 *)hdr = htonl(0x60000000 | (tclass << 20)) | flowlabel;
 225 }
 226
 227 int rpl_udp_tunnel6_xmit_skb(struct dst_entry *dst, struct sock *sk,
 228                          struct sk_buff *skb,
 229                          struct net_device *dev, struct in6_addr *saddr,
 230                          struct in6_addr *daddr,
 231                          __u8 prio, __u8 ttl, __be32 label, __be16 src_port,
 232                          __be16 dst_port, bool nocheck)
 233 {
 234         struct udphdr *uh;
 235         struct ipv6hdr *ip6h;
 236
 237         __skb_push(skb, sizeof(*uh));
 238         skb_reset_transport_header(skb);
 239         uh = udp_hdr(skb);
 240
 241         uh->dest = dst_port;
 242         uh->source = src_port;
 243
 244         uh->len = htons(skb->len);
 245
 246         memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
 247         IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED
 248                             | IPSKB_REROUTED);
 249         skb_dst_set(skb, dst);
 250
 251         udp6_set_csum(nocheck, skb, saddr, daddr, skb->len);
 252
 253         __skb_push(skb, sizeof(*ip6h));
 254         skb_reset_network_header(skb);
 255         ip6h              = ipv6_hdr(skb);
 256         ip6_flow_hdr(ip6h, prio, label);
 257         ip6h->payload_len = htons(skb->len);
 258         ip6h->nexthdr     = IPPROTO_UDP;
 259         ip6h->hop_limit   = ttl;
 260         ip6h->daddr       = *daddr;
 261         ip6h->saddr       = *saddr;
 262
 263         ip6tunnel_xmit(sk, skb, dev);
 264         return 0;
 265 }
 266 #endif
 267
 268 void ovs_udp_gso(struct sk_buff *skb)
 269 {
 270         int udp_offset = skb_transport_offset(skb);
 271         struct udphdr *uh;
 272
 273         uh = udp_hdr(skb);
 274         uh->len = htons(skb->len - udp_offset);
 275 }
 276 EXPORT_SYMBOL_GPL(ovs_udp_gso);
 277
 278 void ovs_udp_csum_gso(struct sk_buff *skb)
 279 {
 280         int udp_offset = skb_transport_offset(skb);
 281
 282         ovs_udp_gso(skb);
 283
 284         if (!OVS_GSO_CB(skb)->ipv6) {
 285                 struct iphdr *iph = ip_hdr(skb);
 286
 287                 /* csum segment if tunnel sets skb with csum. The cleanest way
 288                  * to do this just to set it up from scratch. */
 289                 udp_set_csum(false, skb, iph->saddr, iph->daddr,
 290                                 skb->len - udp_offset);
 291 #if IS_ENABLED(CONFIG_IPV6)
 292         } else {
 293                 struct ipv6hdr *ip6h;
 294
 295                 ip6h = ipv6_hdr(skb);
 296                 udp6_set_csum(false, skb, &ip6h->saddr, &ip6h->daddr,
 297                               skb->len - udp_offset);
 298 #endif
 299         }
 300 }
 301 EXPORT_SYMBOL_GPL(ovs_udp_csum_gso);
 302
 303 #endif