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_unsized *)&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_unsized *)&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 sock *sk, 72 struct udp_tunnel_sock_cfg *cfg) 73 { 74 /* Disable multicast loopback */ 75 inet_clear_bit(MC_LOOP, sk); 76 77 /* Enable CHECKSUM_UNNECESSARY to CHECKSUM_COMPLETE conversion */ 78 inet_inc_convert_csum(sk); 79 80 rcu_assign_sk_user_data(sk, cfg->sk_user_data); 81 82 udp_sk(sk)->encap_type = cfg->encap_type; 83 udp_sk(sk)->encap_rcv = cfg->encap_rcv; 84 udp_sk(sk)->encap_err_rcv = cfg->encap_err_rcv; 85 udp_sk(sk)->encap_err_lookup = cfg->encap_err_lookup; 86 udp_sk(sk)->encap_destroy = cfg->encap_destroy; 87 udp_sk(sk)->gro_receive = cfg->gro_receive; 88 udp_sk(sk)->gro_complete = cfg->gro_complete; 89 90 udp_tunnel_encap_enable(sk); 91 92 udp_tunnel_update_gro_rcv(sk, true); 93 94 if (!sk->sk_dport && !sk->sk_bound_dev_if && sk_saddr_any(sk) && 95 sk->sk_kern_sock) 96 udp_tunnel_update_gro_lookup(net, sk, true); 97 } 98 EXPORT_SYMBOL_GPL(setup_udp_tunnel_sock); 99 100 void udp_tunnel_push_rx_port(struct net_device *dev, struct sock *sk, 101 unsigned short type) 102 { 103 struct udp_tunnel_info ti; 104 105 ti.type = type; 106 ti.sa_family = sk->sk_family; 107 ti.port = inet_sk(sk)->inet_sport; 108 109 udp_tunnel_nic_add_port(dev, &ti); 110 } 111 EXPORT_SYMBOL_GPL(udp_tunnel_push_rx_port); 112 113 void udp_tunnel_drop_rx_port(struct net_device *dev, struct sock *sk, 114 unsigned short type) 115 { 116 struct udp_tunnel_info ti; 117 118 ti.type = type; 119 ti.sa_family = sk->sk_family; 120 ti.port = inet_sk(sk)->inet_sport; 121 122 udp_tunnel_nic_del_port(dev, &ti); 123 } 124 EXPORT_SYMBOL_GPL(udp_tunnel_drop_rx_port); 125 126 /* Notify netdevs that UDP port started listening */ 127 void udp_tunnel_notify_add_rx_port(struct sock *sk, unsigned short type) 128 { 129 struct net *net = sock_net(sk); 130 struct udp_tunnel_info ti; 131 struct net_device *dev; 132 133 ASSERT_RTNL(); 134 135 ti.type = type; 136 ti.sa_family = sk->sk_family; 137 ti.port = inet_sk(sk)->inet_sport; 138 139 for_each_netdev(net, dev) { 140 udp_tunnel_nic_lock(dev); 141 udp_tunnel_nic_add_port(dev, &ti); 142 udp_tunnel_nic_unlock(dev); 143 } 144 } 145 EXPORT_SYMBOL_GPL(udp_tunnel_notify_add_rx_port); 146 147 /* Notify netdevs that UDP port is no more listening */ 148 void udp_tunnel_notify_del_rx_port(struct sock *sk, unsigned short type) 149 { 150 struct net *net = sock_net(sk); 151 struct udp_tunnel_info ti; 152 struct net_device *dev; 153 154 ASSERT_RTNL(); 155 156 ti.type = type; 157 ti.sa_family = sk->sk_family; 158 ti.port = inet_sk(sk)->inet_sport; 159 160 for_each_netdev(net, dev) { 161 udp_tunnel_nic_lock(dev); 162 udp_tunnel_nic_del_port(dev, &ti); 163 udp_tunnel_nic_unlock(dev); 164 } 165 } 166 EXPORT_SYMBOL_GPL(udp_tunnel_notify_del_rx_port); 167 168 void udp_tunnel_xmit_skb(struct rtable *rt, struct sock *sk, struct sk_buff *skb, 169 __be32 src, __be32 dst, __u8 tos, __u8 ttl, 170 __be16 df, __be16 src_port, __be16 dst_port, 171 bool xnet, bool nocheck, u16 ipcb_flags) 172 { 173 struct udphdr *uh; 174 175 __skb_push(skb, sizeof(*uh)); 176 skb_reset_transport_header(skb); 177 uh = udp_hdr(skb); 178 179 uh->dest = dst_port; 180 uh->source = src_port; 181 uh->len = htons(skb->len); 182 183 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt)); 184 185 udp_set_csum(nocheck, skb, src, dst, skb->len); 186 187 iptunnel_xmit(sk, rt, skb, src, dst, IPPROTO_UDP, tos, ttl, df, xnet, 188 ipcb_flags); 189 } 190 EXPORT_SYMBOL_GPL(udp_tunnel_xmit_skb); 191 192 void udp_tunnel_sock_release(struct sock *sk) 193 { 194 struct socket *sock = sk->sk_socket; 195 196 rcu_assign_sk_user_data(sk, NULL); 197 kernel_sock_shutdown(sock, SHUT_RDWR); 198 sock_release(sock); 199 } 200 EXPORT_SYMBOL_GPL(udp_tunnel_sock_release); 201 202 struct metadata_dst *udp_tun_rx_dst(struct sk_buff *skb, unsigned short family, 203 const unsigned long *flags, 204 __be64 tunnel_id, int md_size) 205 { 206 struct metadata_dst *tun_dst; 207 struct ip_tunnel_info *info; 208 209 if (family == AF_INET) 210 tun_dst = ip_tun_rx_dst(skb, flags, tunnel_id, md_size); 211 else 212 tun_dst = ipv6_tun_rx_dst(skb, flags, tunnel_id, md_size); 213 if (!tun_dst) 214 return NULL; 215 216 info = &tun_dst->u.tun_info; 217 info->key.tp_src = udp_hdr(skb)->source; 218 info->key.tp_dst = udp_hdr(skb)->dest; 219 if (udp_hdr(skb)->check) 220 __set_bit(IP_TUNNEL_CSUM_BIT, info->key.tun_flags); 221 return tun_dst; 222 } 223 EXPORT_SYMBOL_GPL(udp_tun_rx_dst); 224 225 struct rtable *udp_tunnel_dst_lookup(struct sk_buff *skb, 226 struct net_device *dev, 227 struct net *net, int oif, 228 __be32 *saddr, 229 const struct ip_tunnel_key *key, 230 __be16 sport, __be16 dport, u8 tos, 231 struct dst_cache *dst_cache) 232 { 233 struct rtable *rt = NULL; 234 struct flowi4 fl4; 235 236 #ifdef CONFIG_DST_CACHE 237 if (dst_cache) { 238 rt = dst_cache_get_ip4(dst_cache, saddr); 239 if (rt) 240 return rt; 241 } 242 #endif 243 244 memset(&fl4, 0, sizeof(fl4)); 245 fl4.flowi4_mark = skb->mark; 246 fl4.flowi4_proto = IPPROTO_UDP; 247 fl4.flowi4_oif = oif; 248 fl4.daddr = key->u.ipv4.dst; 249 fl4.saddr = key->u.ipv4.src; 250 fl4.fl4_dport = dport; 251 fl4.fl4_sport = sport; 252 fl4.flowi4_dscp = inet_dsfield_to_dscp(tos); 253 fl4.flowi4_flags = key->flow_flags; 254 255 rt = ip_route_output_key(net, &fl4); 256 if (IS_ERR(rt)) { 257 netdev_dbg(dev, "no route to %pI4\n", &fl4.daddr); 258 return ERR_PTR(-ENETUNREACH); 259 } 260 if (rt->dst.dev == dev) { /* is this necessary? */ 261 netdev_dbg(dev, "circular route to %pI4\n", &fl4.daddr); 262 ip_rt_put(rt); 263 return ERR_PTR(-ELOOP); 264 } 265 #ifdef CONFIG_DST_CACHE 266 if (dst_cache) 267 dst_cache_set_ip4(dst_cache, &rt->dst, fl4.saddr); 268 #endif 269 *saddr = fl4.saddr; 270 return rt; 271 } 272 EXPORT_SYMBOL_GPL(udp_tunnel_dst_lookup); 273 274 MODULE_DESCRIPTION("IPv4 Foo over UDP tunnel driver"); 275 MODULE_LICENSE("GPL"); 276