1 // SPDX-License-Identifier: GPL-2.0-only 2 #include <linux/module.h> 3 #include <linux/errno.h> 4 #include <linux/socket.h> 5 #include <linux/kernel.h> 6 #include <net/dst_metadata.h> 7 #include <net/flow.h> 8 #include <net/udp.h> 9 #include <net/udp_tunnel.h> 10 #include <net/inet_dscp.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 if (cfg->bind_ifindex) { 24 err = sock_bindtoindex(sock->sk, cfg->bind_ifindex, true); 25 if (err < 0) 26 goto error; 27 } 28 29 udp_addr.sin_family = AF_INET; 30 udp_addr.sin_addr = cfg->local_ip; 31 udp_addr.sin_port = cfg->local_udp_port; 32 err = kernel_bind(sock, (struct sockaddr *)&udp_addr, 33 sizeof(udp_addr)); 34 if (err < 0) 35 goto error; 36 37 if (cfg->peer_udp_port) { 38 udp_addr.sin_family = AF_INET; 39 udp_addr.sin_addr = cfg->peer_ip; 40 udp_addr.sin_port = cfg->peer_udp_port; 41 err = kernel_connect(sock, (struct sockaddr *)&udp_addr, 42 sizeof(udp_addr), 0); 43 if (err < 0) 44 goto error; 45 } 46 47 sock->sk->sk_no_check_tx = !cfg->use_udp_checksums; 48 49 *sockp = sock; 50 return 0; 51 52 error: 53 if (sock) { 54 kernel_sock_shutdown(sock, SHUT_RDWR); 55 sock_release(sock); 56 } 57 *sockp = NULL; 58 return err; 59 } 60 EXPORT_SYMBOL(udp_sock_create4); 61 62 static bool sk_saddr_any(struct sock *sk) 63 { 64 #if IS_ENABLED(CONFIG_IPV6) 65 return ipv6_addr_any(&sk->sk_v6_rcv_saddr); 66 #else 67 return !sk->sk_rcv_saddr; 68 #endif 69 } 70 71 void setup_udp_tunnel_sock(struct net *net, struct socket *sock, 72 struct udp_tunnel_sock_cfg *cfg) 73 { 74 struct sock *sk = sock->sk; 75 76 /* Disable multicast loopback */ 77 inet_clear_bit(MC_LOOP, sk); 78 79 /* Enable CHECKSUM_UNNECESSARY to CHECKSUM_COMPLETE conversion */ 80 inet_inc_convert_csum(sk); 81 82 rcu_assign_sk_user_data(sk, cfg->sk_user_data); 83 84 udp_sk(sk)->encap_type = cfg->encap_type; 85 udp_sk(sk)->encap_rcv = cfg->encap_rcv; 86 udp_sk(sk)->encap_err_rcv = cfg->encap_err_rcv; 87 udp_sk(sk)->encap_err_lookup = cfg->encap_err_lookup; 88 udp_sk(sk)->encap_destroy = cfg->encap_destroy; 89 udp_sk(sk)->gro_receive = cfg->gro_receive; 90 udp_sk(sk)->gro_complete = cfg->gro_complete; 91 92 udp_tunnel_encap_enable(sk); 93 94 udp_tunnel_update_gro_rcv(sk, true); 95 96 if (!sk->sk_dport && !sk->sk_bound_dev_if && sk_saddr_any(sk) && 97 sk->sk_kern_sock) 98 udp_tunnel_update_gro_lookup(net, sk, true); 99 } 100 EXPORT_SYMBOL_GPL(setup_udp_tunnel_sock); 101 102 void udp_tunnel_push_rx_port(struct net_device *dev, struct socket *sock, 103 unsigned short type) 104 { 105 struct sock *sk = sock->sk; 106 struct udp_tunnel_info ti; 107 108 ti.type = type; 109 ti.sa_family = sk->sk_family; 110 ti.port = inet_sk(sk)->inet_sport; 111 112 udp_tunnel_nic_add_port(dev, &ti); 113 } 114 EXPORT_SYMBOL_GPL(udp_tunnel_push_rx_port); 115 116 void udp_tunnel_drop_rx_port(struct net_device *dev, struct socket *sock, 117 unsigned short type) 118 { 119 struct sock *sk = sock->sk; 120 struct udp_tunnel_info ti; 121 122 ti.type = type; 123 ti.sa_family = sk->sk_family; 124 ti.port = inet_sk(sk)->inet_sport; 125 126 udp_tunnel_nic_del_port(dev, &ti); 127 } 128 EXPORT_SYMBOL_GPL(udp_tunnel_drop_rx_port); 129 130 /* Notify netdevs that UDP port started listening */ 131 void udp_tunnel_notify_add_rx_port(struct socket *sock, unsigned short type) 132 { 133 struct sock *sk = sock->sk; 134 struct net *net = sock_net(sk); 135 struct udp_tunnel_info ti; 136 struct net_device *dev; 137 138 ASSERT_RTNL(); 139 140 ti.type = type; 141 ti.sa_family = sk->sk_family; 142 ti.port = inet_sk(sk)->inet_sport; 143 144 for_each_netdev(net, dev) { 145 udp_tunnel_nic_lock(dev); 146 udp_tunnel_nic_add_port(dev, &ti); 147 udp_tunnel_nic_unlock(dev); 148 } 149 } 150 EXPORT_SYMBOL_GPL(udp_tunnel_notify_add_rx_port); 151 152 /* Notify netdevs that UDP port is no more listening */ 153 void udp_tunnel_notify_del_rx_port(struct socket *sock, unsigned short type) 154 { 155 struct sock *sk = sock->sk; 156 struct net *net = sock_net(sk); 157 struct udp_tunnel_info ti; 158 struct net_device *dev; 159 160 ASSERT_RTNL(); 161 162 ti.type = type; 163 ti.sa_family = sk->sk_family; 164 ti.port = inet_sk(sk)->inet_sport; 165 166 for_each_netdev(net, dev) { 167 udp_tunnel_nic_lock(dev); 168 udp_tunnel_nic_del_port(dev, &ti); 169 udp_tunnel_nic_unlock(dev); 170 } 171 } 172 EXPORT_SYMBOL_GPL(udp_tunnel_notify_del_rx_port); 173 174 void udp_tunnel_xmit_skb(struct rtable *rt, struct sock *sk, struct sk_buff *skb, 175 __be32 src, __be32 dst, __u8 tos, __u8 ttl, 176 __be16 df, __be16 src_port, __be16 dst_port, 177 bool xnet, bool nocheck, u16 ipcb_flags) 178 { 179 struct udphdr *uh; 180 181 __skb_push(skb, sizeof(*uh)); 182 skb_reset_transport_header(skb); 183 uh = udp_hdr(skb); 184 185 uh->dest = dst_port; 186 uh->source = src_port; 187 uh->len = htons(skb->len); 188 189 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt)); 190 191 udp_set_csum(nocheck, skb, src, dst, skb->len); 192 193 iptunnel_xmit(sk, rt, skb, src, dst, IPPROTO_UDP, tos, ttl, df, xnet, 194 ipcb_flags); 195 } 196 EXPORT_SYMBOL_GPL(udp_tunnel_xmit_skb); 197 198 void udp_tunnel_sock_release(struct socket *sock) 199 { 200 rcu_assign_sk_user_data(sock->sk, NULL); 201 synchronize_rcu(); 202 kernel_sock_shutdown(sock, SHUT_RDWR); 203 sock_release(sock); 204 } 205 EXPORT_SYMBOL_GPL(udp_tunnel_sock_release); 206 207 struct metadata_dst *udp_tun_rx_dst(struct sk_buff *skb, unsigned short family, 208 const unsigned long *flags, 209 __be64 tunnel_id, int md_size) 210 { 211 struct metadata_dst *tun_dst; 212 struct ip_tunnel_info *info; 213 214 if (family == AF_INET) 215 tun_dst = ip_tun_rx_dst(skb, flags, tunnel_id, md_size); 216 else 217 tun_dst = ipv6_tun_rx_dst(skb, flags, tunnel_id, md_size); 218 if (!tun_dst) 219 return NULL; 220 221 info = &tun_dst->u.tun_info; 222 info->key.tp_src = udp_hdr(skb)->source; 223 info->key.tp_dst = udp_hdr(skb)->dest; 224 if (udp_hdr(skb)->check) 225 __set_bit(IP_TUNNEL_CSUM_BIT, info->key.tun_flags); 226 return tun_dst; 227 } 228 EXPORT_SYMBOL_GPL(udp_tun_rx_dst); 229 230 struct rtable *udp_tunnel_dst_lookup(struct sk_buff *skb, 231 struct net_device *dev, 232 struct net *net, int oif, 233 __be32 *saddr, 234 const struct ip_tunnel_key *key, 235 __be16 sport, __be16 dport, u8 tos, 236 struct dst_cache *dst_cache) 237 { 238 struct rtable *rt = NULL; 239 struct flowi4 fl4; 240 241 #ifdef CONFIG_DST_CACHE 242 if (dst_cache) { 243 rt = dst_cache_get_ip4(dst_cache, saddr); 244 if (rt) 245 return rt; 246 } 247 #endif 248 249 memset(&fl4, 0, sizeof(fl4)); 250 fl4.flowi4_mark = skb->mark; 251 fl4.flowi4_proto = IPPROTO_UDP; 252 fl4.flowi4_oif = oif; 253 fl4.daddr = key->u.ipv4.dst; 254 fl4.saddr = key->u.ipv4.src; 255 fl4.fl4_dport = dport; 256 fl4.fl4_sport = sport; 257 fl4.flowi4_dscp = inet_dsfield_to_dscp(tos); 258 fl4.flowi4_flags = key->flow_flags; 259 260 rt = ip_route_output_key(net, &fl4); 261 if (IS_ERR(rt)) { 262 netdev_dbg(dev, "no route to %pI4\n", &fl4.daddr); 263 return ERR_PTR(-ENETUNREACH); 264 } 265 if (rt->dst.dev == dev) { /* is this necessary? */ 266 netdev_dbg(dev, "circular route to %pI4\n", &fl4.daddr); 267 ip_rt_put(rt); 268 return ERR_PTR(-ELOOP); 269 } 270 #ifdef CONFIG_DST_CACHE 271 if (dst_cache) 272 dst_cache_set_ip4(dst_cache, &rt->dst, fl4.saddr); 273 #endif 274 *saddr = fl4.saddr; 275 return rt; 276 } 277 EXPORT_SYMBOL_GPL(udp_tunnel_dst_lookup); 278 279 MODULE_DESCRIPTION("IPv4 Foo over UDP tunnel driver"); 280 MODULE_LICENSE("GPL"); 281