~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/tipc/udp_media.c

Version: ~ [ linux-6.0-rc1 ] ~ [ linux-5.19.1 ] ~ [ linux-5.18.17 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.60 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.136 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.210 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.255 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.290 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.325 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 
 52 /* IANA assigned UDP port */
 53 #define UDP_PORT_DEFAULT        6118
 54 
 55 #define UDP_MIN_HEADROOM        48
 56 
 57 static const struct nla_policy tipc_nl_udp_policy[TIPC_NLA_UDP_MAX + 1] = {
 58         [TIPC_NLA_UDP_UNSPEC]   = {.type = NLA_UNSPEC},
 59         [TIPC_NLA_UDP_LOCAL]    = {.type = NLA_BINARY,
 60                                    .len = sizeof(struct sockaddr_storage)},
 61         [TIPC_NLA_UDP_REMOTE]   = {.type = NLA_BINARY,
 62                                    .len = sizeof(struct sockaddr_storage)},
 63 };
 64 
 65 /**
 66  * struct udp_media_addr - IP/UDP addressing information
 67  *
 68  * This is the bearer level originating address used in neighbor discovery
 69  * messages, and all fields should be in network byte order
 70  */
 71 struct udp_media_addr {
 72         __be16  proto;
 73         __be16  udp_port;
 74         union {
 75                 struct in_addr ipv4;
 76                 struct in6_addr ipv6;
 77         };
 78 };
 79 
 80 /**
 81  * struct udp_bearer - ip/udp bearer data structure
 82  * @bearer:     associated generic tipc bearer
 83  * @ubsock:     bearer associated socket
 84  * @ifindex:    local address scope
 85  * @work:       used to schedule deferred work on a bearer
 86  */
 87 struct udp_bearer {
 88         struct tipc_bearer __rcu *bearer;
 89         struct socket *ubsock;
 90         u32 ifindex;
 91         struct work_struct work;
 92 };
 93 
 94 /* udp_media_addr_set - convert a ip/udp address to a TIPC media address */
 95 static void tipc_udp_media_addr_set(struct tipc_media_addr *addr,
 96                                     struct udp_media_addr *ua)
 97 {
 98         memset(addr, 0, sizeof(struct tipc_media_addr));
 99         addr->media_id = TIPC_MEDIA_TYPE_UDP;
100         memcpy(addr->value, ua, sizeof(struct udp_media_addr));
101         if (ntohs(ua->proto) == ETH_P_IP) {
102                 if (ipv4_is_multicast(ua->ipv4.s_addr))
103                         addr->broadcast = 1;
104         } else if (ntohs(ua->proto) == ETH_P_IPV6) {
105                 if (ipv6_addr_type(&ua->ipv6) & IPV6_ADDR_MULTICAST)
106                         addr->broadcast = 1;
107         } else {
108                 pr_err("Invalid UDP media address\n");
109         }
110 }
111 
112 /* tipc_udp_addr2str - convert ip/udp address to string */
113 static int tipc_udp_addr2str(struct tipc_media_addr *a, char *buf, int size)
114 {
115         struct udp_media_addr *ua = (struct udp_media_addr *)&a->value;
116 
117         if (ntohs(ua->proto) == ETH_P_IP)
118                 snprintf(buf, size, "%pI4:%u", &ua->ipv4, ntohs(ua->udp_port));
119         else if (ntohs(ua->proto) == ETH_P_IPV6)
120                 snprintf(buf, size, "%pI6:%u", &ua->ipv6, ntohs(ua->udp_port));
121         else
122                 pr_err("Invalid UDP media address\n");
123         return 0;
124 }
125 
126 /* tipc_udp_msg2addr - extract an ip/udp address from a TIPC ndisc message */
127 static int tipc_udp_msg2addr(struct tipc_bearer *b, struct tipc_media_addr *a,
128                              char *msg)
129 {
130         struct udp_media_addr *ua;
131 
132         ua = (struct udp_media_addr *) (msg + TIPC_MEDIA_ADDR_OFFSET);
133         if (msg[TIPC_MEDIA_TYPE_OFFSET] != TIPC_MEDIA_TYPE_UDP)
134                 return -EINVAL;
135         tipc_udp_media_addr_set(a, ua);
136         return 0;
137 }
138 
139 /* tipc_udp_addr2msg - write an ip/udp address to a TIPC ndisc message */
140 static int tipc_udp_addr2msg(char *msg, struct tipc_media_addr *a)
141 {
142         memset(msg, 0, TIPC_MEDIA_INFO_SIZE);
143         msg[TIPC_MEDIA_TYPE_OFFSET] = TIPC_MEDIA_TYPE_UDP;
144         memcpy(msg + TIPC_MEDIA_ADDR_OFFSET, a->value,
145                sizeof(struct udp_media_addr));
146         return 0;
147 }
148 
149 /* tipc_send_msg - enqueue a send request */
150 static int tipc_udp_send_msg(struct net *net, struct sk_buff *skb,
151                              struct tipc_bearer *b,
152                              struct tipc_media_addr *dest)
153 {
154         int ttl, err = 0;
155         struct udp_bearer *ub;
156         struct udp_media_addr *dst = (struct udp_media_addr *)&dest->value;
157         struct udp_media_addr *src = (struct udp_media_addr *)&b->addr.value;
158         struct rtable *rt;
159 
160         if (skb_headroom(skb) < UDP_MIN_HEADROOM) {
161                 err = pskb_expand_head(skb, UDP_MIN_HEADROOM, 0, GFP_ATOMIC);
162                 if (err)
163                         goto tx_error;
164         }
165 
166         skb_set_inner_protocol(skb, htons(ETH_P_TIPC));
167         ub = rcu_dereference_rtnl(b->media_ptr);
168         if (!ub) {
169                 err = -ENODEV;
170                 goto tx_error;
171         }
172         if (dst->proto == htons(ETH_P_IP)) {
173                 struct flowi4 fl = {
174                         .daddr = dst->ipv4.s_addr,
175                         .saddr = src->ipv4.s_addr,
176                         .flowi4_mark = skb->mark,
177                         .flowi4_proto = IPPROTO_UDP
178                 };
179                 rt = ip_route_output_key(net, &fl);
180                 if (IS_ERR(rt)) {
181                         err = PTR_ERR(rt);
182                         goto tx_error;
183                 }
184                 ttl = ip4_dst_hoplimit(&rt->dst);
185                 err = udp_tunnel_xmit_skb(rt, ub->ubsock->sk, skb,
186                                           src->ipv4.s_addr,
187                                           dst->ipv4.s_addr, 0, ttl, 0,
188                                           src->udp_port, dst->udp_port,
189                                           false, true);
190                 if (err < 0) {
191                         ip_rt_put(rt);
192                         goto tx_error;
193                 }
194 #if IS_ENABLED(CONFIG_IPV6)
195         } else {
196                 struct dst_entry *ndst;
197                 struct flowi6 fl6 = {
198                         .flowi6_oif = ub->ifindex,
199                         .daddr = dst->ipv6,
200                         .saddr = src->ipv6,
201                         .flowi6_proto = IPPROTO_UDP
202                 };
203                 ndst = ipv6_stub->ipv6_dst_lookup_flow(net,
204                                                        ub->ubsock->sk,
205                                                        &fl6, NULL);
206                 if (IS_ERR(ndst)) {
207                         err = PTR_ERR(ndst);
208                         goto tx_error;
209                 }
210                 ttl = ip6_dst_hoplimit(ndst);
211                 err = udp_tunnel6_xmit_skb(ndst, ub->ubsock->sk, skb,
212                                            ndst->dev, &src->ipv6,
213                                            &dst->ipv6, 0, ttl, src->udp_port,
214                                            dst->udp_port, false);
215 #endif
216         }
217         return err;
218 
219 tx_error:
220         kfree_skb(skb);
221         return err;
222 }
223 
224 /* tipc_udp_recv - read data from bearer socket */
225 static int tipc_udp_recv(struct sock *sk, struct sk_buff *skb)
226 {
227         struct udp_bearer *ub;
228         struct tipc_bearer *b;
229 
230         ub = rcu_dereference_sk_user_data(sk);
231         if (!ub) {
232                 pr_err_ratelimited("Failed to get UDP bearer reference");
233                 kfree_skb(skb);
234                 return 0;
235         }
236 
237         skb_pull(skb, sizeof(struct udphdr));
238         rcu_read_lock();
239         b = rcu_dereference_rtnl(ub->bearer);
240 
241         if (b) {
242                 tipc_rcv(sock_net(sk), skb, b);
243                 rcu_read_unlock();
244                 return 0;
245         }
246         rcu_read_unlock();
247         kfree_skb(skb);
248         return 0;
249 }
250 
251 static int enable_mcast(struct udp_bearer *ub, struct udp_media_addr *remote)
252 {
253         int err = 0;
254         struct ip_mreqn mreqn;
255         struct sock *sk = ub->ubsock->sk;
256 
257         if (ntohs(remote->proto) == ETH_P_IP) {
258                 if (!ipv4_is_multicast(remote->ipv4.s_addr))
259                         return 0;
260                 mreqn.imr_multiaddr = remote->ipv4;
261                 mreqn.imr_ifindex = ub->ifindex;
262                 err = ip_mc_join_group(sk, &mreqn);
263 #if IS_ENABLED(CONFIG_IPV6)
264         } else {
265                 if (!ipv6_addr_is_multicast(&remote->ipv6))
266                         return 0;
267                 err = ipv6_stub->ipv6_sock_mc_join(sk, ub->ifindex,
268                                                    &remote->ipv6);
269 #endif
270         }
271         return err;
272 }
273 
274 /**
275  * parse_options - build local/remote addresses from configuration
276  * @attrs:      netlink config data
277  * @ub:         UDP bearer instance
278  * @local:      local bearer IP address/port
279  * @remote:     peer or multicast IP/port
280  */
281 static int parse_options(struct nlattr *attrs[], struct udp_bearer *ub,
282                          struct udp_media_addr *local,
283                          struct udp_media_addr *remote)
284 {
285         struct nlattr *opts[TIPC_NLA_UDP_MAX + 1];
286         struct sockaddr_storage *sa_local, *sa_remote;
287 
288         if (!attrs[TIPC_NLA_BEARER_UDP_OPTS])
289                 goto err;
290         if (nla_parse_nested(opts, TIPC_NLA_UDP_MAX,
291                              attrs[TIPC_NLA_BEARER_UDP_OPTS],
292                              tipc_nl_udp_policy))
293                 goto err;
294         if (opts[TIPC_NLA_UDP_LOCAL] && opts[TIPC_NLA_UDP_REMOTE]) {
295                 sa_local = nla_data(opts[TIPC_NLA_UDP_LOCAL]);
296                 sa_remote = nla_data(opts[TIPC_NLA_UDP_REMOTE]);
297         } else {
298 err:
299                 pr_err("Invalid UDP bearer configuration");
300                 return -EINVAL;
301         }
302         if ((sa_local->ss_family & sa_remote->ss_family) == AF_INET) {
303                 struct sockaddr_in *ip4;
304 
305                 ip4 = (struct sockaddr_in *)sa_local;
306                 local->proto = htons(ETH_P_IP);
307                 local->udp_port = ip4->sin_port;
308                 local->ipv4.s_addr = ip4->sin_addr.s_addr;
309 
310                 ip4 = (struct sockaddr_in *)sa_remote;
311                 remote->proto = htons(ETH_P_IP);
312                 remote->udp_port = ip4->sin_port;
313                 remote->ipv4.s_addr = ip4->sin_addr.s_addr;
314                 return 0;
315 
316 #if IS_ENABLED(CONFIG_IPV6)
317         } else if ((sa_local->ss_family & sa_remote->ss_family) == AF_INET6) {
318                 struct sockaddr_in6 *ip6;
319 
320                 ip6 = (struct sockaddr_in6 *)sa_local;
321                 local->proto = htons(ETH_P_IPV6);
322                 local->udp_port = ip6->sin6_port;
323                 local->ipv6 = ip6->sin6_addr;
324                 ub->ifindex = ip6->sin6_scope_id;
325 
326                 ip6 = (struct sockaddr_in6 *)sa_remote;
327                 remote->proto = htons(ETH_P_IPV6);
328                 remote->udp_port = ip6->sin6_port;
329                 remote->ipv6 = ip6->sin6_addr;
330                 return 0;
331 #endif
332         }
333         return -EADDRNOTAVAIL;
334 }
335 
336 /**
337  * tipc_udp_enable - callback to create a new udp bearer instance
338  * @net:        network namespace
339  * @b:          pointer to generic tipc_bearer
340  * @attrs:      netlink bearer configuration
341  *
342  * validate the bearer parameters and initialize the udp bearer
343  * rtnl_lock should be held
344  */
345 static int tipc_udp_enable(struct net *net, struct tipc_bearer *b,
346                            struct nlattr *attrs[])
347 {
348         int err = -EINVAL;
349         struct udp_bearer *ub;
350         struct udp_media_addr *remote;
351         struct udp_media_addr local = {0};
352         struct udp_port_cfg udp_conf = {0};
353         struct udp_tunnel_sock_cfg tuncfg = {NULL};
354 
355         ub = kzalloc(sizeof(*ub), GFP_ATOMIC);
356         if (!ub)
357                 return -ENOMEM;
358 
359         remote = (struct udp_media_addr *)&b->bcast_addr.value;
360         memset(remote, 0, sizeof(struct udp_media_addr));
361         err = parse_options(attrs, ub, &local, remote);
362         if (err)
363                 goto err;
364 
365         b->bcast_addr.media_id = TIPC_MEDIA_TYPE_UDP;
366         b->bcast_addr.broadcast = 1;
367         rcu_assign_pointer(b->media_ptr, ub);
368         rcu_assign_pointer(ub->bearer, b);
369         tipc_udp_media_addr_set(&b->addr, &local);
370         if (local.proto == htons(ETH_P_IP)) {
371                 struct net_device *dev;
372 
373                 dev = __ip_dev_find(net, local.ipv4.s_addr, false);
374                 if (!dev) {
375                         err = -ENODEV;
376                         goto err;
377                 }
378                 udp_conf.family = AF_INET;
379                 udp_conf.local_ip.s_addr = htonl(INADDR_ANY);
380                 udp_conf.use_udp_checksums = false;
381                 ub->ifindex = dev->ifindex;
382                 if (tipc_mtu_bad(dev, sizeof(struct iphdr) +
383                                       sizeof(struct udphdr))) {
384                         err = -EINVAL;
385                         goto err;
386                 }
387                 b->mtu = dev->mtu - sizeof(struct iphdr)
388                         - sizeof(struct udphdr);
389 #if IS_ENABLED(CONFIG_IPV6)
390         } else if (local.proto == htons(ETH_P_IPV6)) {
391                 udp_conf.family = AF_INET6;
392                 udp_conf.use_udp6_tx_checksums = true;
393                 udp_conf.use_udp6_rx_checksums = true;
394                 udp_conf.local_ip6 = in6addr_any;
395                 b->mtu = 1280;
396 #endif
397         } else {
398                 err = -EAFNOSUPPORT;
399                 goto err;
400         }
401         udp_conf.local_udp_port = local.udp_port;
402         err = udp_sock_create(net, &udp_conf, &ub->ubsock);
403         if (err)
404                 goto err;
405         tuncfg.sk_user_data = ub;
406         tuncfg.encap_type = 1;
407         tuncfg.encap_rcv = tipc_udp_recv;
408         tuncfg.encap_destroy = NULL;
409         setup_udp_tunnel_sock(net, ub->ubsock, &tuncfg);
410 
411         err = enable_mcast(ub, remote);
412         if (err)
413                 goto err;
414         return 0;
415 err:
416         if (ub->ubsock)
417                 udp_tunnel_sock_release(ub->ubsock);
418         kfree(ub);
419         return err;
420 }
421 
422 /* cleanup_bearer - break the socket/bearer association */
423 static void cleanup_bearer(struct work_struct *work)
424 {
425         struct udp_bearer *ub = container_of(work, struct udp_bearer, work);
426 
427         if (ub->ubsock)
428                 udp_tunnel_sock_release(ub->ubsock);
429         synchronize_net();
430         kfree(ub);
431 }
432 
433 /* tipc_udp_disable - detach bearer from socket */
434 static void tipc_udp_disable(struct tipc_bearer *b)
435 {
436         struct udp_bearer *ub;
437 
438         ub = rcu_dereference_rtnl(b->media_ptr);
439         if (!ub) {
440                 pr_err("UDP bearer instance not found\n");
441                 return;
442         }
443         if (ub->ubsock)
444                 sock_set_flag(ub->ubsock->sk, SOCK_DEAD);
445         RCU_INIT_POINTER(ub->bearer, NULL);
446 
447         /* sock_release need to be done outside of rtnl lock */
448         INIT_WORK(&ub->work, cleanup_bearer);
449         schedule_work(&ub->work);
450 }
451 
452 struct tipc_media udp_media_info = {
453         .send_msg       = tipc_udp_send_msg,
454         .enable_media   = tipc_udp_enable,
455         .disable_media  = tipc_udp_disable,
456         .addr2str       = tipc_udp_addr2str,
457         .addr2msg       = tipc_udp_addr2msg,
458         .msg2addr       = tipc_udp_msg2addr,
459         .priority       = TIPC_DEF_LINK_PRI,
460         .tolerance      = TIPC_DEF_LINK_TOL,
461         .window         = TIPC_DEF_LINK_WIN,
462         .type_id        = TIPC_MEDIA_TYPE_UDP,
463         .hwaddr_len     = 0,
464         .name           = "udp"
465 };
466 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp