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