net/tipc/udp_media.c

   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/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 /* IANA assigned UDP port */
  58 #define UDP_PORT_DEFAULT        6118
  59
  60 #define UDP_MIN_HEADROOM        48
  61
  62 /**
  63  * struct udp_media_addr - IP/UDP addressing information
  64  *
  65  * This is the bearer level originating address used in neighbor discovery
  66  * messages, and all fields should be in network byte order
  67  */
  68 struct 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 /* struct udp_replicast - container for UDP remote addresses */
  78 struct 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  * struct udp_bearer - ip/udp bearer data structure
  87  * @bearer:     associated generic tipc bearer
  88  * @ubsock:     bearer associated socket
  89  * @ifindex:    local address scope
  90  * @work:       used to schedule deferred work on a bearer
  91  */
  92 struct 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
 100 static 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 /* udp_media_addr_set - convert a ip/udp address to a TIPC media address */
 112 static 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 /* tipc_udp_addr2str - convert ip/udp address to string */
 124 static 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 /* tipc_udp_msg2addr - extract an ip/udp address from a TIPC ndisc message */
 138 static 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 /* tipc_udp_addr2msg - write an ip/udp address to a TIPC ndisc message */
 151 static 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 /* tipc_send_msg - enqueue a send request */
 161 static 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
 219 tx_error:
 220         local_bh_enable();
 221         kfree_skb(skb);
 222         return err;
 223 }
 224
 225 static 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         /* Replicast, send an skb to each configured IP address */
 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;
 268 out:
 269         kfree_skb(skb);
 270         return err;
 271 }
 272
 273 static 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
 293 static 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
 325 static 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 /* tipc_udp_recv - read data from bearer socket */
 363 static 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
 394 out:
 395         kfree_skb(skb);
 396         return 0;
 397 }
 398
 399 static 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
 418 static 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
 447 int 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);
 522 count:
 523                 i++;
 524         }
 525 done:
 526         rtnl_unlock();
 527         cb->args[0] = bid;
 528         cb->args[1] = i;
 529
 530         return skb->len;
 531 }
 532
 533 int 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;
 562 msg_full:
 563         nla_nest_cancel(msg->skb, nest);
 564         return -EMSGSIZE;
 565 }
 566
 567 /**
 568  * tipc_parse_udp_addr - build udp media address from netlink data
 569  * @nla:        netlink attribute containing sockaddr storage aligned address
 570  * @addr:       tipc media address to fill with address, port and protocol type
 571  * @scope_id:   IPv6 scope id pointer, not NULL indicates it's required
 572  */
 573
 574 static 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                 /* Scope ID is only interesting for local addresses */
 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
 615 int 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  * tipc_udp_enable - callback to create a new udp bearer instance
 646  * @net:        network namespace
 647  * @b:          pointer to generic tipc_bearer
 648  * @attrs:      netlink bearer configuration
 649  *
 650  * validate the bearer parameters and initialize the udp bearer
 651  * rtnl_lock should be held
 652  */
 653 static 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         /* Checking remote ip address */
 700         rmcast = tipc_udp_is_mcast_addr(&remote);
 701
 702         /* Autoconfigure own node identity if needed */
 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                 /* Switch to use ANY to receive packets from group */
 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          * The bcast media address port is used for all peers and the ip
 777          * is used if it's a multicast address.
 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
 789 free:
 790         dst_cache_destroy(&ub->rcast.dst_cache);
 791         udp_tunnel_sock_release(ub->ubsock);
 792 err:
 793         kfree(ub);
 794         return err;
 795 }
 796
 797 /* cleanup_bearer - break the socket/bearer association */
 798 static 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         dst_cache_destroy(&ub->rcast.dst_cache);
 810         udp_tunnel_sock_release(ub->ubsock);
 811         synchronize_net();
 812         kfree(ub);
 813 }
 814
 815 /* tipc_udp_disable - detach bearer from socket */
 816 static void tipc_udp_disable(struct tipc_bearer *b)
 817 {
 818         struct udp_bearer *ub;
 819
 820         ub = rtnl_dereference(b->media_ptr);
 821         if (!ub) {
 822                 pr_err("UDP bearer instance not found\n");
 823                 return;
 824         }
 825         sock_set_flag(ub->ubsock->sk, SOCK_DEAD);
 826         RCU_INIT_POINTER(ub->bearer, NULL);
 827
 828         /* sock_release need to be done outside of rtnl lock */
 829         INIT_WORK(&ub->work, cleanup_bearer);
 830         schedule_work(&ub->work);
 831 }
 832
 833 struct tipc_media udp_media_info = {
 834         .send_msg       = tipc_udp_send_msg,
 835         .enable_media   = tipc_udp_enable,
 836         .disable_media  = tipc_udp_disable,
 837         .addr2str       = tipc_udp_addr2str,
 838         .addr2msg       = tipc_udp_addr2msg,
 839         .msg2addr       = tipc_udp_msg2addr,
 840         .priority       = TIPC_DEF_LINK_PRI,
 841         .tolerance      = TIPC_DEF_LINK_TOL,
 842         .min_win        = TIPC_DEF_LINK_WIN,
 843         .max_win        = TIPC_DEF_LINK_WIN,
 844         .mtu            = TIPC_DEF_LINK_UDP_MTU,
 845         .type_id        = TIPC_MEDIA_TYPE_UDP,
 846         .hwaddr_len     = 0,
 847         .name           = "udp"
 848 };