udp_tunnel_core.c

  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
 12int 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
 52error:
 53	if (sock) {
 54		kernel_sock_shutdown(sock, SHUT_RDWR);
 55		sock_release(sock);
 56	}
 57	*sockp = NULL;
 58	return err;
 59}
 60EXPORT_SYMBOL(udp_sock_create4);
 61
 62static 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
 71void 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}
100EXPORT_SYMBOL_GPL(setup_udp_tunnel_sock);
101
102void 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}
114EXPORT_SYMBOL_GPL(udp_tunnel_push_rx_port);
115
116void 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}
128EXPORT_SYMBOL_GPL(udp_tunnel_drop_rx_port);
129
130/* Notify netdevs that UDP port started listening */
131void 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}
150EXPORT_SYMBOL_GPL(udp_tunnel_notify_add_rx_port);
151
152/* Notify netdevs that UDP port is no more listening */
153void 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}
172EXPORT_SYMBOL_GPL(udp_tunnel_notify_del_rx_port);
173
174void 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}
196EXPORT_SYMBOL_GPL(udp_tunnel_xmit_skb);
197
198void 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}
205EXPORT_SYMBOL_GPL(udp_tunnel_sock_release);
206
207struct 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}
228EXPORT_SYMBOL_GPL(udp_tun_rx_dst);
229
230struct 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}
277EXPORT_SYMBOL_GPL(udp_tunnel_dst_lookup);
278
279MODULE_DESCRIPTION("IPv4 Foo over UDP tunnel driver");
280MODULE_LICENSE("GPL");