datapath/linux/compat/udp_tunnel.c

   1 #include <linux/version.h>
   2
   3 #ifndef HAVE_METADATA_DST
   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_create(struct net *net, struct udp_port_cfg *cfg,
  20                         struct socket **sockp)
  21 {
  22         int err;
  23         struct socket *sock = NULL;
  24
  25 #if IS_ENABLED(CONFIG_IPV6)
  26         if (cfg->family == AF_INET6) {
  27                 struct sockaddr_in6 udp6_addr;
  28
  29                 err = sock_create_kern(net, AF_INET6, SOCK_DGRAM, 0, &sock);
  30                 if (err < 0)
  31                         goto error;
  32
  33                 udp6_addr.sin6_family = AF_INET6;
  34                 memcpy(&udp6_addr.sin6_addr, &cfg->local_ip6,
  35                        sizeof(udp6_addr.sin6_addr));
  36                 udp6_addr.sin6_port = cfg->local_udp_port;
  37                 err = kernel_bind(sock, (struct sockaddr *)&udp6_addr,
  38                                   sizeof(udp6_addr));
  39                 if (err < 0)
  40                         goto error;
  41
  42                 if (cfg->peer_udp_port) {
  43                         udp6_addr.sin6_family = AF_INET6;
  44                         memcpy(&udp6_addr.sin6_addr, &cfg->peer_ip6,
  45                                sizeof(udp6_addr.sin6_addr));
  46                         udp6_addr.sin6_port = cfg->peer_udp_port;
  47                         err = kernel_connect(sock,
  48                                              (struct sockaddr *)&udp6_addr,
  49                                              sizeof(udp6_addr), 0);
  50                 }
  51                 if (err < 0)
  52                         goto error;
  53         } else
  54 #endif
  55         if (cfg->family == AF_INET) {
  56                 struct sockaddr_in udp_addr;
  57
  58                 err = sock_create_kern(net, AF_INET, SOCK_DGRAM, 0, &sock);
  59                 if (err < 0)
  60                         goto error;
  61
  62                 udp_addr.sin_family = AF_INET;
  63                 udp_addr.sin_addr = cfg->local_ip;
  64                 udp_addr.sin_port = cfg->local_udp_port;
  65                 err = kernel_bind(sock, (struct sockaddr *)&udp_addr,
  66                                   sizeof(udp_addr));
  67                 if (err < 0)
  68                         goto error;
  69
  70                 if (cfg->peer_udp_port) {
  71                         udp_addr.sin_family = AF_INET;
  72                         udp_addr.sin_addr = cfg->peer_ip;
  73                         udp_addr.sin_port = cfg->peer_udp_port;
  74                         err = kernel_connect(sock,
  75                                              (struct sockaddr *)&udp_addr,
  76                                              sizeof(udp_addr), 0);
  77                         if (err < 0)
  78                                 goto error;
  79                 }
  80         } else {
  81                 return -EPFNOSUPPORT;
  82         }
  83
  84
  85         *sockp = sock;
  86
  87         return 0;
  88
  89 error:
  90         if (sock) {
  91                 kernel_sock_shutdown(sock, SHUT_RDWR);
  92                 sock_release(sock);
  93         }
  94         *sockp = NULL;
  95         return err;
  96 }
  97 EXPORT_SYMBOL_GPL(rpl_udp_sock_create);
  98
  99 void rpl_setup_udp_tunnel_sock(struct net *net, struct socket *sock,
 100                                struct udp_tunnel_sock_cfg *cfg)
 101 {
 102         struct sock *sk = sock->sk;
 103
 104         /* Disable multicast loopback */
 105         inet_sk(sk)->mc_loop = 0;
 106
 107         rcu_assign_sk_user_data(sk, cfg->sk_user_data);
 108
 109         udp_sk(sk)->encap_type = cfg->encap_type;
 110         udp_sk(sk)->encap_rcv = cfg->encap_rcv;
 111 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0)
 112         udp_sk(sk)->encap_destroy = cfg->encap_destroy;
 113 #endif
 114
 115         udp_tunnel_encap_enable(sock);
 116 }
 117 EXPORT_SYMBOL_GPL(rpl_setup_udp_tunnel_sock);
 118
 119 void ovs_udp_gso(struct sk_buff *skb)
 120 {
 121         int udp_offset = skb_transport_offset(skb);
 122         struct udphdr *uh;
 123
 124         uh = udp_hdr(skb);
 125         uh->len = htons(skb->len - udp_offset);
 126 }
 127 EXPORT_SYMBOL_GPL(ovs_udp_gso);
 128
 129 void ovs_udp_csum_gso(struct sk_buff *skb)
 130 {
 131         struct iphdr *iph = ip_hdr(skb);
 132         int udp_offset = skb_transport_offset(skb);
 133
 134         ovs_udp_gso(skb);
 135
 136         /* csum segment if tunnel sets skb with csum. The cleanest way
 137          * to do this just to set it up from scratch. */
 138         skb->ip_summed = CHECKSUM_NONE;
 139         udp_set_csum(false, skb, iph->saddr, iph->daddr,
 140                      skb->len - udp_offset);
 141 }
 142 EXPORT_SYMBOL_GPL(ovs_udp_csum_gso);
 143
 144 int 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         return iptunnel_xmit(sk, rt, skb, src, dst, IPPROTO_UDP,
 162                              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, __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, htonl(0));
 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 #endif