1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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/ipv6_stubs.h>
48#include <linux/tipc_netlink.h>
49#include "core.h"
50#include "addr.h"
51#include "net.h"
52#include "bearer.h"
53#include "netlink.h"
54#include "msg.h"
55#include "udp_media.h"
56
57
58#define UDP_PORT_DEFAULT 6118
59
60#define UDP_MIN_HEADROOM 48
61
62
63
64
65
66
67
68struct udp_media_addr {
69 __be16 proto;
70 __be16 port;
71 union {
72 struct in_addr ipv4;
73 struct in6_addr ipv6;
74 };
75};
76
77
78struct udp_replicast {
79 struct udp_media_addr addr;
80 struct dst_cache dst_cache;
81 struct rcu_head rcu;
82 struct list_head list;
83};
84
85
86
87
88
89
90
91
92struct udp_bearer {
93 struct tipc_bearer __rcu *bearer;
94 struct socket *ubsock;
95 u32 ifindex;
96 struct work_struct work;
97 struct udp_replicast rcast;
98};
99
100static int tipc_udp_is_mcast_addr(struct udp_media_addr *addr)
101{
102 if (ntohs(addr->proto) == ETH_P_IP)
103 return ipv4_is_multicast(addr->ipv4.s_addr);
104#if IS_ENABLED(CONFIG_IPV6)
105 else
106 return ipv6_addr_is_multicast(&addr->ipv6);
107#endif
108 return 0;
109}
110
111
112static void tipc_udp_media_addr_set(struct tipc_media_addr *addr,
113 struct udp_media_addr *ua)
114{
115 memset(addr, 0, sizeof(struct tipc_media_addr));
116 addr->media_id = TIPC_MEDIA_TYPE_UDP;
117 memcpy(addr->value, ua, sizeof(struct udp_media_addr));
118
119 if (tipc_udp_is_mcast_addr(ua))
120 addr->broadcast = TIPC_BROADCAST_SUPPORT;
121}
122
123
124static int tipc_udp_addr2str(struct tipc_media_addr *a, char *buf, int size)
125{
126 struct udp_media_addr *ua = (struct udp_media_addr *)&a->value;
127
128 if (ntohs(ua->proto) == ETH_P_IP)
129 snprintf(buf, size, "%pI4:%u", &ua->ipv4, ntohs(ua->port));
130 else if (ntohs(ua->proto) == ETH_P_IPV6)
131 snprintf(buf, size, "%pI6:%u", &ua->ipv6, ntohs(ua->port));
132 else
133 pr_err("Invalid UDP media address\n");
134 return 0;
135}
136
137
138static int tipc_udp_msg2addr(struct tipc_bearer *b, struct tipc_media_addr *a,
139 char *msg)
140{
141 struct udp_media_addr *ua;
142
143 ua = (struct udp_media_addr *) (msg + TIPC_MEDIA_ADDR_OFFSET);
144 if (msg[TIPC_MEDIA_TYPE_OFFSET] != TIPC_MEDIA_TYPE_UDP)
145 return -EINVAL;
146 tipc_udp_media_addr_set(a, ua);
147 return 0;
148}
149
150
151static int tipc_udp_addr2msg(char *msg, struct tipc_media_addr *a)
152{
153 memset(msg, 0, TIPC_MEDIA_INFO_SIZE);
154 msg[TIPC_MEDIA_TYPE_OFFSET] = TIPC_MEDIA_TYPE_UDP;
155 memcpy(msg + TIPC_MEDIA_ADDR_OFFSET, a->value,
156 sizeof(struct udp_media_addr));
157 return 0;
158}
159
160
161static int tipc_udp_xmit(struct net *net, struct sk_buff *skb,
162 struct udp_bearer *ub, struct udp_media_addr *src,
163 struct udp_media_addr *dst, struct dst_cache *cache)
164{
165 struct dst_entry *ndst;
166 int ttl, err = 0;
167
168 local_bh_disable();
169 ndst = dst_cache_get(cache);
170 if (dst->proto == htons(ETH_P_IP)) {
171 struct rtable *rt = (struct rtable *)ndst;
172
173 if (!rt) {
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 dst_cache_set_ip4(cache, &rt->dst, fl.saddr);
186 }
187
188 ttl = ip4_dst_hoplimit(&rt->dst);
189 udp_tunnel_xmit_skb(rt, ub->ubsock->sk, skb, src->ipv4.s_addr,
190 dst->ipv4.s_addr, 0, ttl, 0, src->port,
191 dst->port, false, true);
192#if IS_ENABLED(CONFIG_IPV6)
193 } else {
194 if (!ndst) {
195 struct flowi6 fl6 = {
196 .flowi6_oif = ub->ifindex,
197 .daddr = dst->ipv6,
198 .saddr = src->ipv6,
199 .flowi6_proto = IPPROTO_UDP
200 };
201 ndst = ipv6_stub->ipv6_dst_lookup_flow(net,
202 ub->ubsock->sk,
203 &fl6, NULL);
204 if (IS_ERR(ndst)) {
205 err = PTR_ERR(ndst);
206 goto tx_error;
207 }
208 dst_cache_set_ip6(cache, ndst, &fl6.saddr);
209 }
210 ttl = ip6_dst_hoplimit(ndst);
211 err = udp_tunnel6_xmit_skb(ndst, ub->ubsock->sk, skb, NULL,
212 &src->ipv6, &dst->ipv6, 0, ttl, 0,
213 src->port, dst->port, false);
214#endif
215 }
216 local_bh_enable();
217 return err;
218
219tx_error:
220 local_bh_enable();
221 kfree_skb(skb);
222 return err;
223}
224
225static int tipc_udp_send_msg(struct net *net, struct sk_buff *skb,
226 struct tipc_bearer *b,
227 struct tipc_media_addr *addr)
228{
229 struct udp_media_addr *src = (struct udp_media_addr *)&b->addr.value;
230 struct udp_media_addr *dst = (struct udp_media_addr *)&addr->value;
231 struct udp_replicast *rcast;
232 struct udp_bearer *ub;
233 int err = 0;
234
235 if (skb_headroom(skb) < UDP_MIN_HEADROOM) {
236 err = pskb_expand_head(skb, UDP_MIN_HEADROOM, 0, GFP_ATOMIC);
237 if (err)
238 goto out;
239 }
240
241 skb_set_inner_protocol(skb, htons(ETH_P_TIPC));
242 ub = rcu_dereference(b->media_ptr);
243 if (!ub) {
244 err = -ENODEV;
245 goto out;
246 }
247
248 if (addr->broadcast != TIPC_REPLICAST_SUPPORT)
249 return tipc_udp_xmit(net, skb, ub, src, dst,
250 &ub->rcast.dst_cache);
251
252
253 list_for_each_entry_rcu(rcast, &ub->rcast.list, list) {
254 struct sk_buff *_skb;
255
256 _skb = pskb_copy(skb, GFP_ATOMIC);
257 if (!_skb) {
258 err = -ENOMEM;
259 goto out;
260 }
261
262 err = tipc_udp_xmit(net, _skb, ub, src, &rcast->addr,
263 &rcast->dst_cache);
264 if (err)
265 goto out;
266 }
267 err = 0;
268out:
269 kfree_skb(skb);
270 return err;
271}
272
273static bool tipc_udp_is_known_peer(struct tipc_bearer *b,
274 struct udp_media_addr *addr)
275{
276 struct udp_replicast *rcast, *tmp;
277 struct udp_bearer *ub;
278
279 ub = rcu_dereference_rtnl(b->media_ptr);
280 if (!ub) {
281 pr_err_ratelimited("UDP bearer instance not found\n");
282 return false;
283 }
284
285 list_for_each_entry_safe(rcast, tmp, &ub->rcast.list, list) {
286 if (!memcmp(&rcast->addr, addr, sizeof(struct udp_media_addr)))
287 return true;
288 }
289
290 return false;
291}
292
293static int tipc_udp_rcast_add(struct tipc_bearer *b,
294 struct udp_media_addr *addr)
295{
296 struct udp_replicast *rcast;
297 struct udp_bearer *ub;
298
299 ub = rcu_dereference_rtnl(b->media_ptr);
300 if (!ub)
301 return -ENODEV;
302
303 rcast = kmalloc(sizeof(*rcast), GFP_ATOMIC);
304 if (!rcast)
305 return -ENOMEM;
306
307 if (dst_cache_init(&rcast->dst_cache, GFP_ATOMIC)) {
308 kfree(rcast);
309 return -ENOMEM;
310 }
311
312 memcpy(&rcast->addr, addr, sizeof(struct udp_media_addr));
313
314 if (ntohs(addr->proto) == ETH_P_IP)
315 pr_info("New replicast peer: %pI4\n", &rcast->addr.ipv4);
316#if IS_ENABLED(CONFIG_IPV6)
317 else if (ntohs(addr->proto) == ETH_P_IPV6)
318 pr_info("New replicast peer: %pI6\n", &rcast->addr.ipv6);
319#endif
320 b->bcast_addr.broadcast = TIPC_REPLICAST_SUPPORT;
321 list_add_rcu(&rcast->list, &ub->rcast.list);
322 return 0;
323}
324
325static int tipc_udp_rcast_disc(struct tipc_bearer *b, struct sk_buff *skb)
326{
327 struct udp_media_addr src = {0};
328 struct udp_media_addr *dst;
329
330 dst = (struct udp_media_addr *)&b->bcast_addr.value;
331 if (tipc_udp_is_mcast_addr(dst))
332 return 0;
333
334 src.port = udp_hdr(skb)->source;
335
336 if (ip_hdr(skb)->version == 4) {
337 struct iphdr *iphdr = ip_hdr(skb);
338
339 src.proto = htons(ETH_P_IP);
340 src.ipv4.s_addr = iphdr->saddr;
341 if (ipv4_is_multicast(iphdr->daddr))
342 return 0;
343#if IS_ENABLED(CONFIG_IPV6)
344 } else if (ip_hdr(skb)->version == 6) {
345 struct ipv6hdr *iphdr = ipv6_hdr(skb);
346
347 src.proto = htons(ETH_P_IPV6);
348 src.ipv6 = iphdr->saddr;
349 if (ipv6_addr_is_multicast(&iphdr->daddr))
350 return 0;
351#endif
352 } else {
353 return 0;
354 }
355
356 if (likely(tipc_udp_is_known_peer(b, &src)))
357 return 0;
358
359 return tipc_udp_rcast_add(b, &src);
360}
361
362
363static int tipc_udp_recv(struct sock *sk, struct sk_buff *skb)
364{
365 struct udp_bearer *ub;
366 struct tipc_bearer *b;
367 struct tipc_msg *hdr;
368 int err;
369
370 ub = rcu_dereference_sk_user_data(sk);
371 if (!ub) {
372 pr_err_ratelimited("Failed to get UDP bearer reference");
373 goto out;
374 }
375 skb_pull(skb, sizeof(struct udphdr));
376 hdr = buf_msg(skb);
377
378 b = rcu_dereference(ub->bearer);
379 if (!b)
380 goto out;
381
382 if (b && test_bit(0, &b->up)) {
383 TIPC_SKB_CB(skb)->flags = 0;
384 tipc_rcv(sock_net(sk), skb, b);
385 return 0;
386 }
387
388 if (unlikely(msg_user(hdr) == LINK_CONFIG)) {
389 err = tipc_udp_rcast_disc(b, skb);
390 if (err)
391 goto out;
392 }
393
394out:
395 kfree_skb(skb);
396 return 0;
397}
398
399static int enable_mcast(struct udp_bearer *ub, struct udp_media_addr *remote)
400{
401 int err = 0;
402 struct ip_mreqn mreqn;
403 struct sock *sk = ub->ubsock->sk;
404
405 if (ntohs(remote->proto) == ETH_P_IP) {
406 mreqn.imr_multiaddr = remote->ipv4;
407 mreqn.imr_ifindex = ub->ifindex;
408 err = ip_mc_join_group(sk, &mreqn);
409#if IS_ENABLED(CONFIG_IPV6)
410 } else {
411 err = ipv6_stub->ipv6_sock_mc_join(sk, ub->ifindex,
412 &remote->ipv6);
413#endif
414 }
415 return err;
416}
417
418static int __tipc_nl_add_udp_addr(struct sk_buff *skb,
419 struct udp_media_addr *addr, int nla_t)
420{
421 if (ntohs(addr->proto) == ETH_P_IP) {
422 struct sockaddr_in ip4;
423
424 memset(&ip4, 0, sizeof(ip4));
425 ip4.sin_family = AF_INET;
426 ip4.sin_port = addr->port;
427 ip4.sin_addr.s_addr = addr->ipv4.s_addr;
428 if (nla_put(skb, nla_t, sizeof(ip4), &ip4))
429 return -EMSGSIZE;
430
431#if IS_ENABLED(CONFIG_IPV6)
432 } else if (ntohs(addr->proto) == ETH_P_IPV6) {
433 struct sockaddr_in6 ip6;
434
435 memset(&ip6, 0, sizeof(ip6));
436 ip6.sin6_family = AF_INET6;
437 ip6.sin6_port = addr->port;
438 memcpy(&ip6.sin6_addr, &addr->ipv6, sizeof(struct in6_addr));
439 if (nla_put(skb, nla_t, sizeof(ip6), &ip6))
440 return -EMSGSIZE;
441#endif
442 }
443
444 return 0;
445}
446
447int tipc_udp_nl_dump_remoteip(struct sk_buff *skb, struct netlink_callback *cb)
448{
449 u32 bid = cb->args[0];
450 u32 skip_cnt = cb->args[1];
451 u32 portid = NETLINK_CB(cb->skb).portid;
452 struct udp_replicast *rcast, *tmp;
453 struct tipc_bearer *b;
454 struct udp_bearer *ub;
455 void *hdr;
456 int err;
457 int i;
458
459 if (!bid && !skip_cnt) {
460 struct nlattr **attrs = genl_dumpit_info(cb)->attrs;
461 struct net *net = sock_net(skb->sk);
462 struct nlattr *battrs[TIPC_NLA_BEARER_MAX + 1];
463 char *bname;
464
465 if (!attrs[TIPC_NLA_BEARER])
466 return -EINVAL;
467
468 err = nla_parse_nested_deprecated(battrs, TIPC_NLA_BEARER_MAX,
469 attrs[TIPC_NLA_BEARER],
470 tipc_nl_bearer_policy, NULL);
471 if (err)
472 return err;
473
474 if (!battrs[TIPC_NLA_BEARER_NAME])
475 return -EINVAL;
476
477 bname = nla_data(battrs[TIPC_NLA_BEARER_NAME]);
478
479 rtnl_lock();
480 b = tipc_bearer_find(net, bname);
481 if (!b) {
482 rtnl_unlock();
483 return -EINVAL;
484 }
485 bid = b->identity;
486 } else {
487 struct net *net = sock_net(skb->sk);
488 struct tipc_net *tn = net_generic(net, tipc_net_id);
489
490 rtnl_lock();
491 b = rtnl_dereference(tn->bearer_list[bid]);
492 if (!b) {
493 rtnl_unlock();
494 return -EINVAL;
495 }
496 }
497
498 ub = rtnl_dereference(b->media_ptr);
499 if (!ub) {
500 rtnl_unlock();
501 return -EINVAL;
502 }
503
504 i = 0;
505 list_for_each_entry_safe(rcast, tmp, &ub->rcast.list, list) {
506 if (i < skip_cnt)
507 goto count;
508
509 hdr = genlmsg_put(skb, portid, cb->nlh->nlmsg_seq,
510 &tipc_genl_family, NLM_F_MULTI,
511 TIPC_NL_BEARER_GET);
512 if (!hdr)
513 goto done;
514
515 err = __tipc_nl_add_udp_addr(skb, &rcast->addr,
516 TIPC_NLA_UDP_REMOTE);
517 if (err) {
518 genlmsg_cancel(skb, hdr);
519 goto done;
520 }
521 genlmsg_end(skb, hdr);
522count:
523 i++;
524 }
525done:
526 rtnl_unlock();
527 cb->args[0] = bid;
528 cb->args[1] = i;
529
530 return skb->len;
531}
532
533int tipc_udp_nl_add_bearer_data(struct tipc_nl_msg *msg, struct tipc_bearer *b)
534{
535 struct udp_media_addr *src = (struct udp_media_addr *)&b->addr.value;
536 struct udp_media_addr *dst;
537 struct udp_bearer *ub;
538 struct nlattr *nest;
539
540 ub = rtnl_dereference(b->media_ptr);
541 if (!ub)
542 return -ENODEV;
543
544 nest = nla_nest_start_noflag(msg->skb, TIPC_NLA_BEARER_UDP_OPTS);
545 if (!nest)
546 goto msg_full;
547
548 if (__tipc_nl_add_udp_addr(msg->skb, src, TIPC_NLA_UDP_LOCAL))
549 goto msg_full;
550
551 dst = (struct udp_media_addr *)&b->bcast_addr.value;
552 if (__tipc_nl_add_udp_addr(msg->skb, dst, TIPC_NLA_UDP_REMOTE))
553 goto msg_full;
554
555 if (!list_empty(&ub->rcast.list)) {
556 if (nla_put_flag(msg->skb, TIPC_NLA_UDP_MULTI_REMOTEIP))
557 goto msg_full;
558 }
559
560 nla_nest_end(msg->skb, nest);
561 return 0;
562msg_full:
563 nla_nest_cancel(msg->skb, nest);
564 return -EMSGSIZE;
565}
566
567
568
569
570
571
572
573
574static int tipc_parse_udp_addr(struct nlattr *nla, struct udp_media_addr *addr,
575 u32 *scope_id)
576{
577 struct sockaddr_storage sa;
578
579 nla_memcpy(&sa, nla, sizeof(sa));
580 if (sa.ss_family == AF_INET) {
581 struct sockaddr_in *ip4 = (struct sockaddr_in *)&sa;
582
583 addr->proto = htons(ETH_P_IP);
584 addr->port = ip4->sin_port;
585 addr->ipv4.s_addr = ip4->sin_addr.s_addr;
586 return 0;
587
588#if IS_ENABLED(CONFIG_IPV6)
589 } else if (sa.ss_family == AF_INET6) {
590 struct sockaddr_in6 *ip6 = (struct sockaddr_in6 *)&sa;
591
592 addr->proto = htons(ETH_P_IPV6);
593 addr->port = ip6->sin6_port;
594 memcpy(&addr->ipv6, &ip6->sin6_addr, sizeof(struct in6_addr));
595
596
597 if (scope_id) {
598 int atype;
599
600 atype = ipv6_addr_type(&ip6->sin6_addr);
601 if (__ipv6_addr_needs_scope_id(atype) &&
602 !ip6->sin6_scope_id) {
603 return -EINVAL;
604 }
605
606 *scope_id = ip6->sin6_scope_id ? : 0;
607 }
608
609 return 0;
610#endif
611 }
612 return -EADDRNOTAVAIL;
613}
614
615int tipc_udp_nl_bearer_add(struct tipc_bearer *b, struct nlattr *attr)
616{
617 int err;
618 struct udp_media_addr addr = {0};
619 struct nlattr *opts[TIPC_NLA_UDP_MAX + 1];
620 struct udp_media_addr *dst;
621
622 if (nla_parse_nested_deprecated(opts, TIPC_NLA_UDP_MAX, attr, tipc_nl_udp_policy, NULL))
623 return -EINVAL;
624
625 if (!opts[TIPC_NLA_UDP_REMOTE])
626 return -EINVAL;
627
628 err = tipc_parse_udp_addr(opts[TIPC_NLA_UDP_REMOTE], &addr, NULL);
629 if (err)
630 return err;
631
632 dst = (struct udp_media_addr *)&b->bcast_addr.value;
633 if (tipc_udp_is_mcast_addr(dst)) {
634 pr_err("Can't add remote ip to TIPC UDP multicast bearer\n");
635 return -EINVAL;
636 }
637
638 if (tipc_udp_is_known_peer(b, &addr))
639 return 0;
640
641 return tipc_udp_rcast_add(b, &addr);
642}
643
644
645
646
647
648
649
650
651
652
653static int tipc_udp_enable(struct net *net, struct tipc_bearer *b,
654 struct nlattr *attrs[])
655{
656 int err = -EINVAL;
657 struct udp_bearer *ub;
658 struct udp_media_addr remote = {0};
659 struct udp_media_addr local = {0};
660 struct udp_port_cfg udp_conf = {0};
661 struct udp_tunnel_sock_cfg tuncfg = {NULL};
662 struct nlattr *opts[TIPC_NLA_UDP_MAX + 1];
663 u8 node_id[NODE_ID_LEN] = {0,};
664 struct net_device *dev;
665 int rmcast = 0;
666
667 ub = kzalloc(sizeof(*ub), GFP_ATOMIC);
668 if (!ub)
669 return -ENOMEM;
670
671 INIT_LIST_HEAD(&ub->rcast.list);
672
673 if (!attrs[TIPC_NLA_BEARER_UDP_OPTS])
674 goto err;
675
676 if (nla_parse_nested_deprecated(opts, TIPC_NLA_UDP_MAX, attrs[TIPC_NLA_BEARER_UDP_OPTS], tipc_nl_udp_policy, NULL))
677 goto err;
678
679 if (!opts[TIPC_NLA_UDP_LOCAL] || !opts[TIPC_NLA_UDP_REMOTE]) {
680 pr_err("Invalid UDP bearer configuration");
681 err = -EINVAL;
682 goto err;
683 }
684
685 err = tipc_parse_udp_addr(opts[TIPC_NLA_UDP_LOCAL], &local,
686 &ub->ifindex);
687 if (err)
688 goto err;
689
690 err = tipc_parse_udp_addr(opts[TIPC_NLA_UDP_REMOTE], &remote, NULL);
691 if (err)
692 goto err;
693
694 if (remote.proto != local.proto) {
695 err = -EINVAL;
696 goto err;
697 }
698
699
700 rmcast = tipc_udp_is_mcast_addr(&remote);
701
702
703 if (!tipc_own_id(net)) {
704 memcpy(node_id, local.ipv6.in6_u.u6_addr8, 16);
705 tipc_net_init(net, node_id, 0);
706 }
707 if (!tipc_own_id(net)) {
708 pr_warn("Failed to set node id, please configure manually\n");
709 err = -EINVAL;
710 goto err;
711 }
712
713 b->bcast_addr.media_id = TIPC_MEDIA_TYPE_UDP;
714 b->bcast_addr.broadcast = TIPC_BROADCAST_SUPPORT;
715 rcu_assign_pointer(b->media_ptr, ub);
716 rcu_assign_pointer(ub->bearer, b);
717 tipc_udp_media_addr_set(&b->addr, &local);
718 if (local.proto == htons(ETH_P_IP)) {
719 dev = __ip_dev_find(net, local.ipv4.s_addr, false);
720 if (!dev) {
721 err = -ENODEV;
722 goto err;
723 }
724 udp_conf.family = AF_INET;
725
726
727 if (rmcast)
728 udp_conf.local_ip.s_addr = htonl(INADDR_ANY);
729 else
730 udp_conf.local_ip.s_addr = local.ipv4.s_addr;
731 udp_conf.use_udp_checksums = false;
732 ub->ifindex = dev->ifindex;
733 if (tipc_mtu_bad(dev, sizeof(struct iphdr) +
734 sizeof(struct udphdr))) {
735 err = -EINVAL;
736 goto err;
737 }
738 b->mtu = b->media->mtu;
739#if IS_ENABLED(CONFIG_IPV6)
740 } else if (local.proto == htons(ETH_P_IPV6)) {
741 dev = ub->ifindex ? __dev_get_by_index(net, ub->ifindex) : NULL;
742 dev = ipv6_dev_find(net, &local.ipv6, dev);
743 if (!dev) {
744 err = -ENODEV;
745 goto err;
746 }
747 udp_conf.family = AF_INET6;
748 udp_conf.use_udp6_tx_checksums = true;
749 udp_conf.use_udp6_rx_checksums = true;
750 if (rmcast)
751 udp_conf.local_ip6 = in6addr_any;
752 else
753 udp_conf.local_ip6 = local.ipv6;
754 ub->ifindex = dev->ifindex;
755 b->mtu = 1280;
756#endif
757 } else {
758 err = -EAFNOSUPPORT;
759 goto err;
760 }
761 udp_conf.local_udp_port = local.port;
762 err = udp_sock_create(net, &udp_conf, &ub->ubsock);
763 if (err)
764 goto err;
765 tuncfg.sk_user_data = ub;
766 tuncfg.encap_type = 1;
767 tuncfg.encap_rcv = tipc_udp_recv;
768 tuncfg.encap_destroy = NULL;
769 setup_udp_tunnel_sock(net, ub->ubsock, &tuncfg);
770
771 err = dst_cache_init(&ub->rcast.dst_cache, GFP_ATOMIC);
772 if (err)
773 goto free;
774
775
776
777
778
779 memcpy(&b->bcast_addr.value, &remote, sizeof(remote));
780 if (rmcast)
781 err = enable_mcast(ub, &remote);
782 else
783 err = tipc_udp_rcast_add(b, &remote);
784 if (err)
785 goto free;
786
787 return 0;
788
789free:
790 dst_cache_destroy(&ub->rcast.dst_cache);
791 udp_tunnel_sock_release(ub->ubsock);
792err:
793 kfree(ub);
794 return err;
795}
796
797
798static void cleanup_bearer(struct work_struct *work)
799{
800 struct udp_bearer *ub = container_of(work, struct udp_bearer, work);
801 struct udp_replicast *rcast, *tmp;
802
803 list_for_each_entry_safe(rcast, tmp, &ub->rcast.list, list) {
804 dst_cache_destroy(&rcast->dst_cache);
805 list_del_rcu(&rcast->list);
806 kfree_rcu(rcast, rcu);
807 }
808
809 atomic_dec(&tipc_net(sock_net(ub->ubsock->sk))->wq_count);
810 dst_cache_destroy(&ub->rcast.dst_cache);
811 udp_tunnel_sock_release(ub->ubsock);
812 synchronize_net();
813 kfree(ub);
814}
815
816
817static void tipc_udp_disable(struct tipc_bearer *b)
818{
819 struct udp_bearer *ub;
820
821 ub = rtnl_dereference(b->media_ptr);
822 if (!ub) {
823 pr_err("UDP bearer instance not found\n");
824 return;
825 }
826 sock_set_flag(ub->ubsock->sk, SOCK_DEAD);
827 RCU_INIT_POINTER(ub->bearer, NULL);
828
829
830 atomic_inc(&tipc_net(sock_net(ub->ubsock->sk))->wq_count);
831 INIT_WORK(&ub->work, cleanup_bearer);
832 schedule_work(&ub->work);
833}
834
835struct tipc_media udp_media_info = {
836 .send_msg = tipc_udp_send_msg,
837 .enable_media = tipc_udp_enable,
838 .disable_media = tipc_udp_disable,
839 .addr2str = tipc_udp_addr2str,
840 .addr2msg = tipc_udp_addr2msg,
841 .msg2addr = tipc_udp_msg2addr,
842 .priority = TIPC_DEF_LINK_PRI,
843 .tolerance = TIPC_DEF_LINK_TOL,
844 .min_win = TIPC_DEF_LINK_WIN,
845 .max_win = TIPC_DEF_LINK_WIN,
846 .mtu = TIPC_DEF_LINK_UDP_MTU,
847 .type_id = TIPC_MEDIA_TYPE_UDP,
848 .hwaddr_len = 0,
849 .name = "udp"
850};
851
