1/* net/tipc/udp_media.c: IP bearer support for TIPC
2 *
3 * Copyright (c) 2015, Ericsson AB
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 *    notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *    notice, this list of conditions and the following disclaimer in the
13 *    documentation and/or other materials provided with the distribution.
14 * 3. Neither the names of the copyright holders nor the names of its
15 *    contributors may be used to endorse or promote products derived from
16 *    this software without specific prior written permission.
17 *
18 * Alternatively, this software may be distributed under the terms of the
19 * GNU General Public License ("GPL") version 2 as published by the Free
20 * Software Foundation.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
26 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 * POSSIBILITY OF SUCH DAMAGE.
33 */
34
35#include <linux/socket.h>
36#include <linux/ip.h>
37#include <linux/udp.h>
38#include <linux/inet.h>
39#include <linux/inetdevice.h>
40#include <linux/igmp.h>
41#include <linux/kernel.h>
42#include <linux/workqueue.h>
43#include <linux/list.h>
44#include <net/sock.h>
45#include <net/ip.h>
46#include <net/udp_tunnel.h>
47#include <net/addrconf.h>
48#include <linux/tipc_netlink.h>
49#include "core.h"
50#include "bearer.h"
51#include "msg.h"
52
53/* IANA assigned UDP port */
54#define UDP_PORT_DEFAULT	6118
55
56#define UDP_MIN_HEADROOM        28
57
58static const struct nla_policy tipc_nl_udp_policy[TIPC_NLA_UDP_MAX + 1] = {
59	[TIPC_NLA_UDP_UNSPEC]	= {.type = NLA_UNSPEC},
60	[TIPC_NLA_UDP_LOCAL]	= {.type = NLA_BINARY,
61				   .len = sizeof(struct sockaddr_storage)},
62	[TIPC_NLA_UDP_REMOTE]	= {.type = NLA_BINARY,
63				   .len = sizeof(struct sockaddr_storage)},
64};
65
66/**
67 * struct udp_media_addr - IP/UDP addressing information
68 *
69 * This is the bearer level originating address used in neighbor discovery
70 * messages, and all fields should be in network byte order
71 */
72struct udp_media_addr {
73	__be16	proto;
74	__be16	udp_port;
75	union {
76		struct in_addr ipv4;
77		struct in6_addr ipv6;
78	};
79};
80
81/**
82 * struct udp_bearer - ip/udp bearer data structure
83 * @bearer:	associated generic tipc bearer
84 * @ubsock:	bearer associated socket
85 * @ifindex:	local address scope
86 * @work:	used to schedule deferred work on a bearer
87 */
88struct udp_bearer {
89	struct tipc_bearer __rcu *bearer;
90	struct socket *ubsock;
91	u32 ifindex;
92	struct work_struct work;
93};
94
95/* udp_media_addr_set - convert a ip/udp address to a TIPC media address */
96static void tipc_udp_media_addr_set(struct tipc_media_addr *addr,
97				    struct udp_media_addr *ua)
98{
99	memset(addr, 0, sizeof(struct tipc_media_addr));
100	addr->media_id = TIPC_MEDIA_TYPE_UDP;
101	memcpy(addr->value, ua, sizeof(struct udp_media_addr));
102	if (ntohs(ua->proto) == ETH_P_IP) {
103		if (ipv4_is_multicast(ua->ipv4.s_addr))
104			addr->broadcast = 1;
105	} else if (ntohs(ua->proto) == ETH_P_IPV6) {
106		if (ipv6_addr_type(&ua->ipv6) & IPV6_ADDR_MULTICAST)
107			addr->broadcast = 1;
108	} else {
109		pr_err("Invalid UDP media address\n");
110	}
111}
112
113/* tipc_udp_addr2str - convert ip/udp address to string */
114static int tipc_udp_addr2str(struct tipc_media_addr *a, char *buf, int size)
115{
116	struct udp_media_addr *ua = (struct udp_media_addr *)&a->value;
117
118	if (ntohs(ua->proto) == ETH_P_IP)
119		snprintf(buf, size, "%pI4:%u", &ua->ipv4, ntohs(ua->udp_port));
120	else if (ntohs(ua->proto) == ETH_P_IPV6)
121		snprintf(buf, size, "%pI6:%u", &ua->ipv6, ntohs(ua->udp_port));
122	else
123		pr_err("Invalid UDP media address\n");
124	return 0;
125}
126
127/* tipc_udp_msg2addr - extract an ip/udp address from a TIPC ndisc message */
128static int tipc_udp_msg2addr(struct tipc_bearer *b, struct tipc_media_addr *a,
129			     char *msg)
130{
131	struct udp_media_addr *ua;
132
133	ua = (struct udp_media_addr *) (msg + TIPC_MEDIA_ADDR_OFFSET);
134	if (msg[TIPC_MEDIA_TYPE_OFFSET] != TIPC_MEDIA_TYPE_UDP)
135		return -EINVAL;
136	tipc_udp_media_addr_set(a, ua);
137	return 0;
138}
139
140/* tipc_udp_addr2msg - write an ip/udp address to a TIPC ndisc message */
141static int tipc_udp_addr2msg(char *msg, struct tipc_media_addr *a)
142{
143	memset(msg, 0, TIPC_MEDIA_INFO_SIZE);
144	msg[TIPC_MEDIA_TYPE_OFFSET] = TIPC_MEDIA_TYPE_UDP;
145	memcpy(msg + TIPC_MEDIA_ADDR_OFFSET, a->value,
146	       sizeof(struct udp_media_addr));
147	return 0;
148}
149
150/* tipc_send_msg - enqueue a send request */
151static int tipc_udp_send_msg(struct net *net, struct sk_buff *skb,
152			     struct tipc_bearer *b,
153			     struct tipc_media_addr *dest)
154{
155	int ttl, err = 0;
156	struct udp_bearer *ub;
157	struct udp_media_addr *dst = (struct udp_media_addr *)&dest->value;
158	struct udp_media_addr *src = (struct udp_media_addr *)&b->addr.value;
159	struct rtable *rt;
160
161	if (skb_headroom(skb) < UDP_MIN_HEADROOM) {
162		err = pskb_expand_head(skb, UDP_MIN_HEADROOM, 0, GFP_ATOMIC);
163		if (err)
164			goto tx_error;
165	}
166
167	skb_set_inner_protocol(skb, htons(ETH_P_TIPC));
168	ub = rcu_dereference_rtnl(b->media_ptr);
169	if (!ub) {
170		err = -ENODEV;
171		goto tx_error;
172	}
173	if (dst->proto == htons(ETH_P_IP)) {
174		struct flowi4 fl = {
175			.daddr = dst->ipv4.s_addr,
176			.saddr = src->ipv4.s_addr,
177			.flowi4_mark = skb->mark,
178			.flowi4_proto = IPPROTO_UDP
179		};
180		rt = ip_route_output_key(net, &fl);
181		if (IS_ERR(rt)) {
182			err = PTR_ERR(rt);
183			goto tx_error;
184		}
185		ttl = ip4_dst_hoplimit(&rt->dst);
186		err = udp_tunnel_xmit_skb(rt, ub->ubsock->sk, skb,
187					  src->ipv4.s_addr,
188					  dst->ipv4.s_addr, 0, ttl, 0,
189					  src->udp_port, dst->udp_port,
190					  false, true);
191		if (err < 0) {
192			ip_rt_put(rt);
193			goto tx_error;
194		}
195#if IS_ENABLED(CONFIG_IPV6)
196	} else {
197		struct dst_entry *ndst;
198		struct flowi6 fl6 = {
199			.flowi6_oif = ub->ifindex,
200			.daddr = dst->ipv6,
201			.saddr = src->ipv6,
202			.flowi6_proto = IPPROTO_UDP
203		};
204		err = ipv6_stub->ipv6_dst_lookup(net, ub->ubsock->sk, &ndst,
205						 &fl6);
206		if (err)
207			goto tx_error;
208		ttl = ip6_dst_hoplimit(ndst);
209		err = udp_tunnel6_xmit_skb(ndst, ub->ubsock->sk, skb,
210					   ndst->dev, &src->ipv6,
211					   &dst->ipv6, 0, ttl, src->udp_port,
212					   dst->udp_port, false);
213#endif
214	}
215	return err;
216
217tx_error:
218	kfree_skb(skb);
219	return err;
220}
221
222/* tipc_udp_recv - read data from bearer socket */
223static int tipc_udp_recv(struct sock *sk, struct sk_buff *skb)
224{
225	struct udp_bearer *ub;
226	struct tipc_bearer *b;
227	int usr = msg_user(buf_msg(skb));
228
229	if ((usr == LINK_PROTOCOL) || (usr == NAME_DISTRIBUTOR))
230		skb_linearize(skb);
231
232	ub = rcu_dereference_sk_user_data(sk);
233	if (!ub) {
234		pr_err_ratelimited("Failed to get UDP bearer reference");
235		kfree_skb(skb);
236		return 0;
237	}
238
239	skb_pull(skb, sizeof(struct udphdr));
240	rcu_read_lock();
241	b = rcu_dereference_rtnl(ub->bearer);
242
243	if (b) {
244		tipc_rcv(sock_net(sk), skb, b);
245		rcu_read_unlock();
246		return 0;
247	}
248	rcu_read_unlock();
249	kfree_skb(skb);
250	return 0;
251}
252
253static int enable_mcast(struct udp_bearer *ub, struct udp_media_addr *remote)
254{
255	int err = 0;
256	struct ip_mreqn mreqn;
257	struct sock *sk = ub->ubsock->sk;
258
259	if (ntohs(remote->proto) == ETH_P_IP) {
260		if (!ipv4_is_multicast(remote->ipv4.s_addr))
261			return 0;
262		mreqn.imr_multiaddr = remote->ipv4;
263		mreqn.imr_ifindex = ub->ifindex;
264		err = ip_mc_join_group(sk, &mreqn);
265#if IS_ENABLED(CONFIG_IPV6)
266	} else {
267		if (!ipv6_addr_is_multicast(&remote->ipv6))
268			return 0;
269		err = ipv6_stub->ipv6_sock_mc_join(sk, ub->ifindex,
270						   &remote->ipv6);
271#endif
272	}
273	return err;
274}
275
276/**
277 * parse_options - build local/remote addresses from configuration
278 * @attrs:	netlink config data
279 * @ub:		UDP bearer instance
280 * @local:	local bearer IP address/port
281 * @remote:	peer or multicast IP/port
282 */
283static int parse_options(struct nlattr *attrs[], struct udp_bearer *ub,
284			 struct udp_media_addr *local,
285			 struct udp_media_addr *remote)
286{
287	struct nlattr *opts[TIPC_NLA_UDP_MAX + 1];
288	struct sockaddr_storage *sa_local, *sa_remote;
289
290	if (!attrs[TIPC_NLA_BEARER_UDP_OPTS])
291		goto err;
292	if (nla_parse_nested(opts, TIPC_NLA_UDP_MAX,
293			     attrs[TIPC_NLA_BEARER_UDP_OPTS],
294			     tipc_nl_udp_policy))
295		goto err;
296	if (opts[TIPC_NLA_UDP_LOCAL] && opts[TIPC_NLA_UDP_REMOTE]) {
297		sa_local = nla_data(opts[TIPC_NLA_UDP_LOCAL]);
298		sa_remote = nla_data(opts[TIPC_NLA_UDP_REMOTE]);
299	} else {
300err:
301		pr_err("Invalid UDP bearer configuration");
302		return -EINVAL;
303	}
304	if ((sa_local->ss_family & sa_remote->ss_family) == AF_INET) {
305		struct sockaddr_in *ip4;
306
307		ip4 = (struct sockaddr_in *)sa_local;
308		local->proto = htons(ETH_P_IP);
309		local->udp_port = ip4->sin_port;
310		local->ipv4.s_addr = ip4->sin_addr.s_addr;
311
312		ip4 = (struct sockaddr_in *)sa_remote;
313		remote->proto = htons(ETH_P_IP);
314		remote->udp_port = ip4->sin_port;
315		remote->ipv4.s_addr = ip4->sin_addr.s_addr;
316		return 0;
317
318#if IS_ENABLED(CONFIG_IPV6)
319	} else if ((sa_local->ss_family & sa_remote->ss_family) == AF_INET6) {
320		struct sockaddr_in6 *ip6;
321
322		ip6 = (struct sockaddr_in6 *)sa_local;
323		local->proto = htons(ETH_P_IPV6);
324		local->udp_port = ip6->sin6_port;
325		local->ipv6 = ip6->sin6_addr;
326		ub->ifindex = ip6->sin6_scope_id;
327
328		ip6 = (struct sockaddr_in6 *)sa_remote;
329		remote->proto = htons(ETH_P_IPV6);
330		remote->udp_port = ip6->sin6_port;
331		remote->ipv6 = ip6->sin6_addr;
332		return 0;
333#endif
334	}
335	return -EADDRNOTAVAIL;
336}
337
338/**
339 * tipc_udp_enable - callback to create a new udp bearer instance
340 * @net:	network namespace
341 * @b:		pointer to generic tipc_bearer
342 * @attrs:	netlink bearer configuration
343 *
344 * validate the bearer parameters and initialize the udp bearer
345 * rtnl_lock should be held
346 */
347static int tipc_udp_enable(struct net *net, struct tipc_bearer *b,
348			   struct nlattr *attrs[])
349{
350	int err = -EINVAL;
351	struct udp_bearer *ub;
352	struct udp_media_addr *remote;
353	struct udp_media_addr local = {0};
354	struct udp_port_cfg udp_conf = {0};
355	struct udp_tunnel_sock_cfg tuncfg = {NULL};
356
357	ub = kzalloc(sizeof(*ub), GFP_ATOMIC);
358	if (!ub)
359		return -ENOMEM;
360
361	remote = (struct udp_media_addr *)&b->bcast_addr.value;
362	memset(remote, 0, sizeof(struct udp_media_addr));
363	err = parse_options(attrs, ub, &local, remote);
364	if (err)
365		goto err;
366
367	b->bcast_addr.media_id = TIPC_MEDIA_TYPE_UDP;
368	b->bcast_addr.broadcast = 1;
369	rcu_assign_pointer(b->media_ptr, ub);
370	rcu_assign_pointer(ub->bearer, b);
371	tipc_udp_media_addr_set(&b->addr, &local);
372	if (local.proto == htons(ETH_P_IP)) {
373		struct net_device *dev;
374
375		dev = __ip_dev_find(net, local.ipv4.s_addr, false);
376		if (!dev) {
377			err = -ENODEV;
378			goto err;
379		}
380		udp_conf.family = AF_INET;
381		udp_conf.local_ip.s_addr = htonl(INADDR_ANY);
382		udp_conf.use_udp_checksums = false;
383		ub->ifindex = dev->ifindex;
384		b->mtu = dev->mtu - sizeof(struct iphdr)
385			- sizeof(struct udphdr);
386#if IS_ENABLED(CONFIG_IPV6)
387	} else if (local.proto == htons(ETH_P_IPV6)) {
388		udp_conf.family = AF_INET6;
389		udp_conf.use_udp6_tx_checksums = true;
390		udp_conf.use_udp6_rx_checksums = true;
391		udp_conf.local_ip6 = in6addr_any;
392		b->mtu = 1280;
393#endif
394	} else {
395		err = -EAFNOSUPPORT;
396		goto err;
397	}
398	udp_conf.local_udp_port = local.udp_port;
399	err = udp_sock_create(net, &udp_conf, &ub->ubsock);
400	if (err)
401		goto err;
402	tuncfg.sk_user_data = ub;
403	tuncfg.encap_type = 1;
404	tuncfg.encap_rcv = tipc_udp_recv;
405	tuncfg.encap_destroy = NULL;
406	setup_udp_tunnel_sock(net, ub->ubsock, &tuncfg);
407
408	if (enable_mcast(ub, remote))
409		goto err;
410	return 0;
411err:
412	kfree(ub);
413	return err;
414}
415
416/* cleanup_bearer - break the socket/bearer association */
417static void cleanup_bearer(struct work_struct *work)
418{
419	struct udp_bearer *ub = container_of(work, struct udp_bearer, work);
420
421	if (ub->ubsock)
422		udp_tunnel_sock_release(ub->ubsock);
423	synchronize_net();
424	kfree(ub);
425}
426
427/* tipc_udp_disable - detach bearer from socket */
428static void tipc_udp_disable(struct tipc_bearer *b)
429{
430	struct udp_bearer *ub;
431
432	ub = rcu_dereference_rtnl(b->media_ptr);
433	if (!ub) {
434		pr_err("UDP bearer instance not found\n");
435		return;
436	}
437	if (ub->ubsock)
438		sock_set_flag(ub->ubsock->sk, SOCK_DEAD);
439	RCU_INIT_POINTER(ub->bearer, NULL);
440
441	/* sock_release need to be done outside of rtnl lock */
442	INIT_WORK(&ub->work, cleanup_bearer);
443	schedule_work(&ub->work);
444}
445
446struct tipc_media udp_media_info = {
447	.send_msg	= tipc_udp_send_msg,
448	.enable_media	= tipc_udp_enable,
449	.disable_media	= tipc_udp_disable,
450	.addr2str	= tipc_udp_addr2str,
451	.addr2msg	= tipc_udp_addr2msg,
452	.msg2addr	= tipc_udp_msg2addr,
453	.priority	= TIPC_DEF_LINK_PRI,
454	.tolerance	= TIPC_DEF_LINK_TOL,
455	.window		= TIPC_DEF_LINK_WIN,
456	.type_id	= TIPC_MEDIA_TYPE_UDP,
457	.hwaddr_len	= 0,
458	.name		= "udp"
459};
460