net/tipc/bearer.c

   1 /*
   2  * net/tipc/bearer.c: TIPC bearer code
   3  *
   4  * Copyright (c) 1996-2006, 2013-2016, Ericsson AB
   5  * Copyright (c) 2004-2006, 2010-2013, Wind River Systems
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the names of the copyright holders nor the names of its
  17  *    contributors may be used to endorse or promote products derived from
  18  *    this software without specific prior written permission.
  19  *
  20  * Alternatively, this software may be distributed under the terms of the
  21  * GNU General Public License ("GPL") version 2 as published by the Free
  22  * Software Foundation.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  25  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  28  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  29  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  30  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  32  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  33  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  34  * POSSIBILITY OF SUCH DAMAGE.
  35  */
  36
  37 #include <net/sock.h>
  38 #include "core.h"
  39 #include "bearer.h"
  40 #include "link.h"
  41 #include "discover.h"
  42 #include "monitor.h"
  43 #include "bcast.h"
  44 #include "netlink.h"
  45 #include "udp_media.h"
  46 #include "trace.h"
  47 #include "crypto.h"
  48
  49 #define MAX_ADDR_STR 60
  50
  51 static struct tipc_media * const media_info_array[] = {
  52         &eth_media_info,
  53 #ifdef CONFIG_TIPC_MEDIA_IB
  54         &ib_media_info,
  55 #endif
  56 #ifdef CONFIG_TIPC_MEDIA_UDP
  57         &udp_media_info,
  58 #endif
  59         NULL
  60 };
  61
  62 static struct tipc_bearer *bearer_get(struct net *net, int bearer_id)
  63 {
  64         struct tipc_net *tn = tipc_net(net);
  65
  66         return rcu_dereference(tn->bearer_list[bearer_id]);
  67 }
  68
  69 static void bearer_disable(struct net *net, struct tipc_bearer *b);
  70 static int tipc_l2_rcv_msg(struct sk_buff *skb, struct net_device *dev,
  71                            struct packet_type *pt, struct net_device *orig_dev);
  72
  73 /**
  74  * tipc_media_find - locates specified media object by name
  75  * @name: name to locate
  76  */
  77 struct tipc_media *tipc_media_find(const char *name)
  78 {
  79         u32 i;
  80
  81         for (i = 0; media_info_array[i] != NULL; i++) {
  82                 if (!strcmp(media_info_array[i]->name, name))
  83                         break;
  84         }
  85         return media_info_array[i];
  86 }
  87
  88 /**
  89  * media_find_id - locates specified media object by type identifier
  90  * @type: type identifier to locate
  91  */
  92 static struct tipc_media *media_find_id(u8 type)
  93 {
  94         u32 i;
  95
  96         for (i = 0; media_info_array[i] != NULL; i++) {
  97                 if (media_info_array[i]->type_id == type)
  98                         break;
  99         }
 100         return media_info_array[i];
 101 }
 102
 103 /**
 104  * tipc_media_addr_printf - record media address in print buffer
 105  * @buf: output buffer
 106  * @len: output buffer size remaining
 107  * @a: input media address
 108  */
 109 int tipc_media_addr_printf(char *buf, int len, struct tipc_media_addr *a)
 110 {
 111         char addr_str[MAX_ADDR_STR];
 112         struct tipc_media *m;
 113         int ret;
 114
 115         m = media_find_id(a->media_id);
 116
 117         if (m && !m->addr2str(a, addr_str, sizeof(addr_str)))
 118                 ret = scnprintf(buf, len, "%s(%s)", m->name, addr_str);
 119         else {
 120                 u32 i;
 121
 122                 ret = scnprintf(buf, len, "UNKNOWN(%u)", a->media_id);
 123                 for (i = 0; i < sizeof(a->value); i++)
 124                         ret += scnprintf(buf + ret, len - ret,
 125                                             "-%x", a->value[i]);
 126         }
 127         return ret;
 128 }
 129
 130 /**
 131  * bearer_name_validate - validate & (optionally) deconstruct bearer name
 132  * @name: ptr to bearer name string
 133  * @name_parts: ptr to area for bearer name components (or NULL if not needed)
 134  *
 135  * Return: 1 if bearer name is valid, otherwise 0.
 136  */
 137 static int bearer_name_validate(const char *name,
 138                                 struct tipc_bearer_names *name_parts)
 139 {
 140         char name_copy[TIPC_MAX_BEARER_NAME];
 141         char *media_name;
 142         char *if_name;
 143         u32 media_len;
 144         u32 if_len;
 145
 146         /* copy bearer name & ensure length is OK */
 147         if (strscpy(name_copy, name, TIPC_MAX_BEARER_NAME) < 0)
 148                 return 0;
 149
 150         /* ensure all component parts of bearer name are present */
 151         media_name = name_copy;
 152         if_name = strchr(media_name, ':');
 153         if (if_name == NULL)
 154                 return 0;
 155         *(if_name++) = 0;
 156         media_len = if_name - media_name;
 157         if_len = strlen(if_name) + 1;
 158
 159         /* validate component parts of bearer name */
 160         if ((media_len <= 1) || (media_len > TIPC_MAX_MEDIA_NAME) ||
 161             (if_len <= 1) || (if_len > TIPC_MAX_IF_NAME))
 162                 return 0;
 163
 164         /* return bearer name components, if necessary */
 165         if (name_parts) {
 166                 strcpy(name_parts->media_name, media_name);
 167                 strcpy(name_parts->if_name, if_name);
 168         }
 169         return 1;
 170 }
 171
 172 /**
 173  * tipc_bearer_find - locates bearer object with matching bearer name
 174  * @net: the applicable net namespace
 175  * @name: bearer name to locate
 176  */
 177 struct tipc_bearer *tipc_bearer_find(struct net *net, const char *name)
 178 {
 179         struct tipc_net *tn = net_generic(net, tipc_net_id);
 180         struct tipc_bearer *b;
 181         u32 i;
 182
 183         for (i = 0; i < MAX_BEARERS; i++) {
 184                 b = rtnl_dereference(tn->bearer_list[i]);
 185                 if (b && (!strcmp(b->name, name)))
 186                         return b;
 187         }
 188         return NULL;
 189 }
 190
 191 /*     tipc_bearer_get_name - get the bearer name from its id.
 192  *     @net: network namespace
 193  *     @name: a pointer to the buffer where the name will be stored.
 194  *     @bearer_id: the id to get the name from.
 195  */
 196 int tipc_bearer_get_name(struct net *net, char *name, u32 bearer_id)
 197 {
 198         struct tipc_net *tn = tipc_net(net);
 199         struct tipc_bearer *b;
 200
 201         if (bearer_id >= MAX_BEARERS)
 202                 return -EINVAL;
 203
 204         b = rtnl_dereference(tn->bearer_list[bearer_id]);
 205         if (!b)
 206                 return -EINVAL;
 207
 208         strcpy(name, b->name);
 209         return 0;
 210 }
 211
 212 void tipc_bearer_add_dest(struct net *net, u32 bearer_id, u32 dest)
 213 {
 214         struct tipc_net *tn = net_generic(net, tipc_net_id);
 215         struct tipc_bearer *b;
 216
 217         rcu_read_lock();
 218         b = rcu_dereference(tn->bearer_list[bearer_id]);
 219         if (b)
 220                 tipc_disc_add_dest(b->disc);
 221         rcu_read_unlock();
 222 }
 223
 224 void tipc_bearer_remove_dest(struct net *net, u32 bearer_id, u32 dest)
 225 {
 226         struct tipc_net *tn = net_generic(net, tipc_net_id);
 227         struct tipc_bearer *b;
 228
 229         rcu_read_lock();
 230         b = rcu_dereference(tn->bearer_list[bearer_id]);
 231         if (b)
 232                 tipc_disc_remove_dest(b->disc);
 233         rcu_read_unlock();
 234 }
 235
 236 /**
 237  * tipc_enable_bearer - enable bearer with the given name
 238  * @net: the applicable net namespace
 239  * @name: bearer name to enable
 240  * @disc_domain: bearer domain
 241  * @prio: bearer priority
 242  * @attr: nlattr array
 243  * @extack: netlink extended ack
 244  */
 245 static int tipc_enable_bearer(struct net *net, const char *name,
 246                               u32 disc_domain, u32 prio,
 247                               struct nlattr *attr[],
 248                               struct netlink_ext_ack *extack)
 249 {
 250         struct tipc_net *tn = tipc_net(net);
 251         struct tipc_bearer_names b_names;
 252         int with_this_prio = 1;
 253         struct tipc_bearer *b;
 254         struct tipc_media *m;
 255         struct sk_buff *skb;
 256         int bearer_id = 0;
 257         int res = -EINVAL;
 258         char *errstr = "";
 259         u32 i;
 260
 261         if (!bearer_name_validate(name, &b_names)) {
 262                 errstr = "illegal name";
 263                 NL_SET_ERR_MSG(extack, "Illegal name");
 264                 goto rejected;
 265         }
 266
 267         if (prio > TIPC_MAX_LINK_PRI && prio != TIPC_MEDIA_LINK_PRI) {
 268                 errstr = "illegal priority";
 269                 NL_SET_ERR_MSG(extack, "Illegal priority");
 270                 goto rejected;
 271         }
 272
 273         m = tipc_media_find(b_names.media_name);
 274         if (!m) {
 275                 errstr = "media not registered";
 276                 NL_SET_ERR_MSG(extack, "Media not registered");
 277                 goto rejected;
 278         }
 279
 280         if (prio == TIPC_MEDIA_LINK_PRI)
 281                 prio = m->priority;
 282
 283         /* Check new bearer vs existing ones and find free bearer id if any */
 284         bearer_id = MAX_BEARERS;
 285         i = MAX_BEARERS;
 286         while (i-- != 0) {
 287                 b = rtnl_dereference(tn->bearer_list[i]);
 288                 if (!b) {
 289                         bearer_id = i;
 290                         continue;
 291                 }
 292                 if (!strcmp(name, b->name)) {
 293                         errstr = "already enabled";
 294                         NL_SET_ERR_MSG(extack, "Already enabled");
 295                         goto rejected;
 296                 }
 297
 298                 if (b->priority == prio &&
 299                     (++with_this_prio > 2)) {
 300                         pr_warn("Bearer <%s>: already 2 bearers with priority %u\n",
 301                                 name, prio);
 302
 303                         if (prio == TIPC_MIN_LINK_PRI) {
 304                                 errstr = "cannot adjust to lower";
 305                                 NL_SET_ERR_MSG(extack, "Cannot adjust to lower");
 306                                 goto rejected;
 307                         }
 308
 309                         pr_warn("Bearer <%s>: trying with adjusted priority\n",
 310                                 name);
 311                         prio--;
 312                         bearer_id = MAX_BEARERS;
 313                         i = MAX_BEARERS;
 314                         with_this_prio = 1;
 315                 }
 316         }
 317
 318         if (bearer_id >= MAX_BEARERS) {
 319                 errstr = "max 3 bearers permitted";
 320                 NL_SET_ERR_MSG(extack, "Max 3 bearers permitted");
 321                 goto rejected;
 322         }
 323
 324         b = kzalloc(sizeof(*b), GFP_ATOMIC);
 325         if (!b)
 326                 return -ENOMEM;
 327
 328         strcpy(b->name, name);
 329         b->media = m;
 330         res = m->enable_media(net, b, attr);
 331         if (res) {
 332                 kfree(b);
 333                 errstr = "failed to enable media";
 334                 NL_SET_ERR_MSG(extack, "Failed to enable media");
 335                 goto rejected;
 336         }
 337
 338         b->identity = bearer_id;
 339         b->tolerance = m->tolerance;
 340         b->min_win = m->min_win;
 341         b->max_win = m->max_win;
 342         b->domain = disc_domain;
 343         b->net_plane = bearer_id + 'A';
 344         b->priority = prio;
 345         refcount_set(&b->refcnt, 1);
 346
 347         res = tipc_disc_create(net, b, &b->bcast_addr, &skb);
 348         if (res) {
 349                 bearer_disable(net, b);
 350                 errstr = "failed to create discoverer";
 351                 NL_SET_ERR_MSG(extack, "Failed to create discoverer");
 352                 goto rejected;
 353         }
 354
 355         /* Create monitoring data before accepting activate messages */
 356         if (tipc_mon_create(net, bearer_id)) {
 357                 bearer_disable(net, b);
 358                 kfree_skb(skb);
 359                 return -ENOMEM;
 360         }
 361
 362         test_and_set_bit_lock(0, &b->up);
 363         rcu_assign_pointer(tn->bearer_list[bearer_id], b);
 364         if (skb)
 365                 tipc_bearer_xmit_skb(net, bearer_id, skb, &b->bcast_addr);
 366
 367         pr_info("Enabled bearer <%s>, priority %u\n", name, prio);
 368
 369         return res;
 370 rejected:
 371         pr_warn("Enabling of bearer <%s> rejected, %s\n", name, errstr);
 372         return res;
 373 }
 374
 375 /**
 376  * tipc_reset_bearer - Reset all links established over this bearer
 377  * @net: the applicable net namespace
 378  * @b: the target bearer
 379  */
 380 static int tipc_reset_bearer(struct net *net, struct tipc_bearer *b)
 381 {
 382         pr_info("Resetting bearer <%s>\n", b->name);
 383         tipc_node_delete_links(net, b->identity);
 384         tipc_disc_reset(net, b);
 385         return 0;
 386 }
 387
 388 bool tipc_bearer_hold(struct tipc_bearer *b)
 389 {
 390         return (b && refcount_inc_not_zero(&b->refcnt));
 391 }
 392
 393 void tipc_bearer_put(struct tipc_bearer *b)
 394 {
 395         if (b && refcount_dec_and_test(&b->refcnt))
 396                 kfree_rcu(b, rcu);
 397 }
 398
 399 /**
 400  * bearer_disable - disable this bearer
 401  * @net: the applicable net namespace
 402  * @b: the bearer to disable
 403  *
 404  * Note: This routine assumes caller holds RTNL lock.
 405  */
 406 static void bearer_disable(struct net *net, struct tipc_bearer *b)
 407 {
 408         struct tipc_net *tn = tipc_net(net);
 409         int bearer_id = b->identity;
 410
 411         pr_info("Disabling bearer <%s>\n", b->name);
 412         clear_bit_unlock(0, &b->up);
 413         tipc_node_delete_links(net, bearer_id);
 414         b->media->disable_media(b);
 415         RCU_INIT_POINTER(b->media_ptr, NULL);
 416         if (b->disc)
 417                 tipc_disc_delete(b->disc);
 418         RCU_INIT_POINTER(tn->bearer_list[bearer_id], NULL);
 419         tipc_bearer_put(b);
 420         tipc_mon_delete(net, bearer_id);
 421 }
 422
 423 int tipc_enable_l2_media(struct net *net, struct tipc_bearer *b,
 424                          struct nlattr *attr[])
 425 {
 426         char *dev_name = strchr((const char *)b->name, ':') + 1;
 427         int hwaddr_len = b->media->hwaddr_len;
 428         u8 node_id[NODE_ID_LEN] = {0,};
 429         struct net_device *dev;
 430
 431         /* Find device with specified name */
 432         dev = dev_get_by_name(net, dev_name);
 433         if (!dev)
 434                 return -ENODEV;
 435         if (tipc_mtu_bad(dev, 0)) {
 436                 dev_put(dev);
 437                 return -EINVAL;
 438         }
 439         if (dev == net->loopback_dev) {
 440                 dev_put(dev);
 441                 pr_info("Enabling <%s> not permitted\n", b->name);
 442                 return -EINVAL;
 443         }
 444
 445         /* Autoconfigure own node identity if needed */
 446         if (!tipc_own_id(net) && hwaddr_len <= NODE_ID_LEN) {
 447                 memcpy(node_id, dev->dev_addr, hwaddr_len);
 448                 tipc_net_init(net, node_id, 0);
 449         }
 450         if (!tipc_own_id(net)) {
 451                 dev_put(dev);
 452                 pr_warn("Failed to obtain node identity\n");
 453                 return -EINVAL;
 454         }
 455
 456         /* Associate TIPC bearer with L2 bearer */
 457         rcu_assign_pointer(b->media_ptr, dev);
 458         b->pt.dev = dev;
 459         b->pt.type = htons(ETH_P_TIPC);
 460         b->pt.func = tipc_l2_rcv_msg;
 461         dev_add_pack(&b->pt);
 462         memset(&b->bcast_addr, 0, sizeof(b->bcast_addr));
 463         memcpy(b->bcast_addr.value, dev->broadcast, hwaddr_len);
 464         b->bcast_addr.media_id = b->media->type_id;
 465         b->bcast_addr.broadcast = TIPC_BROADCAST_SUPPORT;
 466         b->mtu = dev->mtu;
 467         b->media->raw2addr(b, &b->addr, (const char *)dev->dev_addr);
 468         rcu_assign_pointer(dev->tipc_ptr, b);
 469         return 0;
 470 }
 471
 472 /* tipc_disable_l2_media - detach TIPC bearer from an L2 interface
 473  * @b: the target bearer
 474  *
 475  * Mark L2 bearer as inactive so that incoming buffers are thrown away
 476  */
 477 void tipc_disable_l2_media(struct tipc_bearer *b)
 478 {
 479         struct net_device *dev;
 480
 481         dev = (struct net_device *)rtnl_dereference(b->media_ptr);
 482         dev_remove_pack(&b->pt);
 483         RCU_INIT_POINTER(dev->tipc_ptr, NULL);
 484         synchronize_net();
 485         dev_put(dev);
 486 }
 487
 488 /**
 489  * tipc_l2_send_msg - send a TIPC packet out over an L2 interface
 490  * @net: the associated network namespace
 491  * @skb: the packet to be sent
 492  * @b: the bearer through which the packet is to be sent
 493  * @dest: peer destination address
 494  */
 495 int tipc_l2_send_msg(struct net *net, struct sk_buff *skb,
 496                      struct tipc_bearer *b, struct tipc_media_addr *dest)
 497 {
 498         struct net_device *dev;
 499         int delta;
 500
 501         dev = (struct net_device *)rcu_dereference(b->media_ptr);
 502         if (!dev)
 503                 return 0;
 504
 505         delta = SKB_DATA_ALIGN(dev->hard_header_len - skb_headroom(skb));
 506         if ((delta > 0) && pskb_expand_head(skb, delta, 0, GFP_ATOMIC)) {
 507                 kfree_skb(skb);
 508                 return 0;
 509         }
 510         skb_reset_network_header(skb);
 511         skb->dev = dev;
 512         skb->protocol = htons(ETH_P_TIPC);
 513         dev_hard_header(skb, dev, ETH_P_TIPC, dest->value,
 514                         dev->dev_addr, skb->len);
 515         dev_queue_xmit(skb);
 516         return 0;
 517 }
 518
 519 bool tipc_bearer_bcast_support(struct net *net, u32 bearer_id)
 520 {
 521         bool supp = false;
 522         struct tipc_bearer *b;
 523
 524         rcu_read_lock();
 525         b = bearer_get(net, bearer_id);
 526         if (b)
 527                 supp = (b->bcast_addr.broadcast == TIPC_BROADCAST_SUPPORT);
 528         rcu_read_unlock();
 529         return supp;
 530 }
 531
 532 int tipc_bearer_mtu(struct net *net, u32 bearer_id)
 533 {
 534         int mtu = 0;
 535         struct tipc_bearer *b;
 536
 537         rcu_read_lock();
 538         b = rcu_dereference(tipc_net(net)->bearer_list[bearer_id]);
 539         if (b)
 540                 mtu = b->mtu;
 541         rcu_read_unlock();
 542         return mtu;
 543 }
 544
 545 /* tipc_bearer_xmit_skb - sends buffer to destination over bearer
 546  */
 547 void tipc_bearer_xmit_skb(struct net *net, u32 bearer_id,
 548                           struct sk_buff *skb,
 549                           struct tipc_media_addr *dest)
 550 {
 551         struct tipc_msg *hdr = buf_msg(skb);
 552         struct tipc_bearer *b;
 553
 554         rcu_read_lock();
 555         b = bearer_get(net, bearer_id);
 556         if (likely(b && (test_bit(0, &b->up) || msg_is_reset(hdr)))) {
 557 #ifdef CONFIG_TIPC_CRYPTO
 558                 tipc_crypto_xmit(net, &skb, b, dest, NULL);
 559                 if (skb)
 560 #endif
 561                         b->media->send_msg(net, skb, b, dest);
 562         } else {
 563                 kfree_skb(skb);
 564         }
 565         rcu_read_unlock();
 566 }
 567
 568 /* tipc_bearer_xmit() -send buffer to destination over bearer
 569  */
 570 void tipc_bearer_xmit(struct net *net, u32 bearer_id,
 571                       struct sk_buff_head *xmitq,
 572                       struct tipc_media_addr *dst,
 573                       struct tipc_node *__dnode)
 574 {
 575         struct tipc_bearer *b;
 576         struct sk_buff *skb, *tmp;
 577
 578         if (skb_queue_empty(xmitq))
 579                 return;
 580
 581         rcu_read_lock();
 582         b = bearer_get(net, bearer_id);
 583         if (unlikely(!b))
 584                 __skb_queue_purge(xmitq);
 585         skb_queue_walk_safe(xmitq, skb, tmp) {
 586                 __skb_dequeue(xmitq);
 587                 if (likely(test_bit(0, &b->up) || msg_is_reset(buf_msg(skb)))) {
 588 #ifdef CONFIG_TIPC_CRYPTO
 589                         tipc_crypto_xmit(net, &skb, b, dst, __dnode);
 590                         if (skb)
 591 #endif
 592                                 b->media->send_msg(net, skb, b, dst);
 593                 } else {
 594                         kfree_skb(skb);
 595                 }
 596         }
 597         rcu_read_unlock();
 598 }
 599
 600 /* tipc_bearer_bc_xmit() - broadcast buffers to all destinations
 601  */
 602 void tipc_bearer_bc_xmit(struct net *net, u32 bearer_id,
 603                          struct sk_buff_head *xmitq)
 604 {
 605         struct tipc_net *tn = tipc_net(net);
 606         struct tipc_media_addr *dst;
 607         int net_id = tn->net_id;
 608         struct tipc_bearer *b;
 609         struct sk_buff *skb, *tmp;
 610         struct tipc_msg *hdr;
 611
 612         rcu_read_lock();
 613         b = bearer_get(net, bearer_id);
 614         if (unlikely(!b || !test_bit(0, &b->up)))
 615                 __skb_queue_purge(xmitq);
 616         skb_queue_walk_safe(xmitq, skb, tmp) {
 617                 hdr = buf_msg(skb);
 618                 msg_set_non_seq(hdr, 1);
 619                 msg_set_mc_netid(hdr, net_id);
 620                 __skb_dequeue(xmitq);
 621                 dst = &b->bcast_addr;
 622 #ifdef CONFIG_TIPC_CRYPTO
 623                 tipc_crypto_xmit(net, &skb, b, dst, NULL);
 624                 if (skb)
 625 #endif
 626                         b->media->send_msg(net, skb, b, dst);
 627         }
 628         rcu_read_unlock();
 629 }
 630
 631 /**
 632  * tipc_l2_rcv_msg - handle incoming TIPC message from an interface
 633  * @skb: the received message
 634  * @dev: the net device that the packet was received on
 635  * @pt: the packet_type structure which was used to register this handler
 636  * @orig_dev: the original receive net device in case the device is a bond
 637  *
 638  * Accept only packets explicitly sent to this node, or broadcast packets;
 639  * ignores packets sent using interface multicast, and traffic sent to other
 640  * nodes (which can happen if interface is running in promiscuous mode).
 641  */
 642 static int tipc_l2_rcv_msg(struct sk_buff *skb, struct net_device *dev,
 643                            struct packet_type *pt, struct net_device *orig_dev)
 644 {
 645         struct tipc_bearer *b;
 646
 647         rcu_read_lock();
 648         b = rcu_dereference(dev->tipc_ptr) ?:
 649                 rcu_dereference(orig_dev->tipc_ptr);
 650         if (likely(b && test_bit(0, &b->up) &&
 651                    (skb->pkt_type <= PACKET_MULTICAST))) {
 652                 skb_mark_not_on_list(skb);
 653                 TIPC_SKB_CB(skb)->flags = 0;
 654                 tipc_rcv(dev_net(b->pt.dev), skb, b);
 655                 rcu_read_unlock();
 656                 return NET_RX_SUCCESS;
 657         }
 658         rcu_read_unlock();
 659         kfree_skb(skb);
 660         return NET_RX_DROP;
 661 }
 662
 663 /**
 664  * tipc_l2_device_event - handle device events from network device
 665  * @nb: the context of the notification
 666  * @evt: the type of event
 667  * @ptr: the net device that the event was on
 668  *
 669  * This function is called by the Ethernet driver in case of link
 670  * change event.
 671  */
 672 static int tipc_l2_device_event(struct notifier_block *nb, unsigned long evt,
 673                                 void *ptr)
 674 {
 675         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 676         struct net *net = dev_net(dev);
 677         struct tipc_bearer *b;
 678
 679         b = rtnl_dereference(dev->tipc_ptr);
 680         if (!b)
 681                 return NOTIFY_DONE;
 682
 683         trace_tipc_l2_device_event(dev, b, evt);
 684         switch (evt) {
 685         case NETDEV_CHANGE:
 686                 if (netif_carrier_ok(dev) && netif_oper_up(dev)) {
 687                         test_and_set_bit_lock(0, &b->up);
 688                         break;
 689                 }
 690                 fallthrough;
 691         case NETDEV_GOING_DOWN:
 692                 clear_bit_unlock(0, &b->up);
 693                 tipc_reset_bearer(net, b);
 694                 break;
 695         case NETDEV_UP:
 696                 test_and_set_bit_lock(0, &b->up);
 697                 break;
 698         case NETDEV_CHANGEMTU:
 699                 if (tipc_mtu_bad(dev, 0)) {
 700                         bearer_disable(net, b);
 701                         break;
 702                 }
 703                 b->mtu = dev->mtu;
 704                 tipc_reset_bearer(net, b);
 705                 break;
 706         case NETDEV_CHANGEADDR:
 707                 b->media->raw2addr(b, &b->addr,
 708                                    (const char *)dev->dev_addr);
 709                 tipc_reset_bearer(net, b);
 710                 break;
 711         case NETDEV_UNREGISTER:
 712         case NETDEV_CHANGENAME:
 713                 bearer_disable(net, b);
 714                 break;
 715         }
 716         return NOTIFY_OK;
 717 }
 718
 719 static struct notifier_block notifier = {
 720         .notifier_call  = tipc_l2_device_event,
 721         .priority       = 0,
 722 };
 723
 724 int tipc_bearer_setup(void)
 725 {
 726         return register_netdevice_notifier(&notifier);
 727 }
 728
 729 void tipc_bearer_cleanup(void)
 730 {
 731         unregister_netdevice_notifier(&notifier);
 732 }
 733
 734 void tipc_bearer_stop(struct net *net)
 735 {
 736         struct tipc_net *tn = net_generic(net, tipc_net_id);
 737         struct tipc_bearer *b;
 738         u32 i;
 739
 740         for (i = 0; i < MAX_BEARERS; i++) {
 741                 b = rtnl_dereference(tn->bearer_list[i]);
 742                 if (b) {
 743                         bearer_disable(net, b);
 744                         tn->bearer_list[i] = NULL;
 745                 }
 746         }
 747 }
 748
 749 void tipc_clone_to_loopback(struct net *net, struct sk_buff_head *pkts)
 750 {
 751         struct net_device *dev = net->loopback_dev;
 752         struct sk_buff *skb, *_skb;
 753         int exp;
 754
 755         skb_queue_walk(pkts, _skb) {
 756                 skb = pskb_copy(_skb, GFP_ATOMIC);
 757                 if (!skb)
 758                         continue;
 759
 760                 exp = SKB_DATA_ALIGN(dev->hard_header_len - skb_headroom(skb));
 761                 if (exp > 0 && pskb_expand_head(skb, exp, 0, GFP_ATOMIC)) {
 762                         kfree_skb(skb);
 763                         continue;
 764                 }
 765
 766                 skb_reset_network_header(skb);
 767                 dev_hard_header(skb, dev, ETH_P_TIPC, dev->dev_addr,
 768                                 dev->dev_addr, skb->len);
 769                 skb->dev = dev;
 770                 skb->pkt_type = PACKET_HOST;
 771                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 772                 skb->protocol = eth_type_trans(skb, dev);
 773                 netif_rx_ni(skb);
 774         }
 775 }
 776
 777 static int tipc_loopback_rcv_pkt(struct sk_buff *skb, struct net_device *dev,
 778                                  struct packet_type *pt, struct net_device *od)
 779 {
 780         consume_skb(skb);
 781         return NET_RX_SUCCESS;
 782 }
 783
 784 int tipc_attach_loopback(struct net *net)
 785 {
 786         struct net_device *dev = net->loopback_dev;
 787         struct tipc_net *tn = tipc_net(net);
 788
 789         if (!dev)
 790                 return -ENODEV;
 791
 792         dev_hold_track(dev, &tn->loopback_pt.dev_tracker, GFP_KERNEL);
 793         tn->loopback_pt.dev = dev;
 794         tn->loopback_pt.type = htons(ETH_P_TIPC);
 795         tn->loopback_pt.func = tipc_loopback_rcv_pkt;
 796         dev_add_pack(&tn->loopback_pt);
 797         return 0;
 798 }
 799
 800 void tipc_detach_loopback(struct net *net)
 801 {
 802         struct tipc_net *tn = tipc_net(net);
 803
 804         dev_remove_pack(&tn->loopback_pt);
 805         dev_put_track(net->loopback_dev, &tn->loopback_pt.dev_tracker);
 806 }
 807
 808 /* Caller should hold rtnl_lock to protect the bearer */
 809 static int __tipc_nl_add_bearer(struct tipc_nl_msg *msg,
 810                                 struct tipc_bearer *bearer, int nlflags)
 811 {
 812         void *hdr;
 813         struct nlattr *attrs;
 814         struct nlattr *prop;
 815
 816         hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
 817                           nlflags, TIPC_NL_BEARER_GET);
 818         if (!hdr)
 819                 return -EMSGSIZE;
 820
 821         attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_BEARER);
 822         if (!attrs)
 823                 goto msg_full;
 824
 825         if (nla_put_string(msg->skb, TIPC_NLA_BEARER_NAME, bearer->name))
 826                 goto attr_msg_full;
 827
 828         prop = nla_nest_start_noflag(msg->skb, TIPC_NLA_BEARER_PROP);
 829         if (!prop)
 830                 goto prop_msg_full;
 831         if (nla_put_u32(msg->skb, TIPC_NLA_PROP_PRIO, bearer->priority))
 832                 goto prop_msg_full;
 833         if (nla_put_u32(msg->skb, TIPC_NLA_PROP_TOL, bearer->tolerance))
 834                 goto prop_msg_full;
 835         if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN, bearer->max_win))
 836                 goto prop_msg_full;
 837         if (bearer->media->type_id == TIPC_MEDIA_TYPE_UDP)
 838                 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_MTU, bearer->mtu))
 839                         goto prop_msg_full;
 840
 841         nla_nest_end(msg->skb, prop);
 842
 843 #ifdef CONFIG_TIPC_MEDIA_UDP
 844         if (bearer->media->type_id == TIPC_MEDIA_TYPE_UDP) {
 845                 if (tipc_udp_nl_add_bearer_data(msg, bearer))
 846                         goto attr_msg_full;
 847         }
 848 #endif
 849
 850         nla_nest_end(msg->skb, attrs);
 851         genlmsg_end(msg->skb, hdr);
 852
 853         return 0;
 854
 855 prop_msg_full:
 856         nla_nest_cancel(msg->skb, prop);
 857 attr_msg_full:
 858         nla_nest_cancel(msg->skb, attrs);
 859 msg_full:
 860         genlmsg_cancel(msg->skb, hdr);
 861
 862         return -EMSGSIZE;
 863 }
 864
 865 int tipc_nl_bearer_dump(struct sk_buff *skb, struct netlink_callback *cb)
 866 {
 867         int err;
 868         int i = cb->args[0];
 869         struct tipc_bearer *bearer;
 870         struct tipc_nl_msg msg;
 871         struct net *net = sock_net(skb->sk);
 872         struct tipc_net *tn = net_generic(net, tipc_net_id);
 873
 874         if (i == MAX_BEARERS)
 875                 return 0;
 876
 877         msg.skb = skb;
 878         msg.portid = NETLINK_CB(cb->skb).portid;
 879         msg.seq = cb->nlh->nlmsg_seq;
 880
 881         rtnl_lock();
 882         for (i = 0; i < MAX_BEARERS; i++) {
 883                 bearer = rtnl_dereference(tn->bearer_list[i]);
 884                 if (!bearer)
 885                         continue;
 886
 887                 err = __tipc_nl_add_bearer(&msg, bearer, NLM_F_MULTI);
 888                 if (err)
 889                         break;
 890         }
 891         rtnl_unlock();
 892
 893         cb->args[0] = i;
 894         return skb->len;
 895 }
 896
 897 int tipc_nl_bearer_get(struct sk_buff *skb, struct genl_info *info)
 898 {
 899         int err;
 900         char *name;
 901         struct sk_buff *rep;
 902         struct tipc_bearer *bearer;
 903         struct tipc_nl_msg msg;
 904         struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
 905         struct net *net = genl_info_net(info);
 906
 907         if (!info->attrs[TIPC_NLA_BEARER])
 908                 return -EINVAL;
 909
 910         err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
 911                                           info->attrs[TIPC_NLA_BEARER],
 912                                           tipc_nl_bearer_policy, info->extack);
 913         if (err)
 914                 return err;
 915
 916         if (!attrs[TIPC_NLA_BEARER_NAME])
 917                 return -EINVAL;
 918         name = nla_data(attrs[TIPC_NLA_BEARER_NAME]);
 919
 920         rep = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 921         if (!rep)
 922                 return -ENOMEM;
 923
 924         msg.skb = rep;
 925         msg.portid = info->snd_portid;
 926         msg.seq = info->snd_seq;
 927
 928         rtnl_lock();
 929         bearer = tipc_bearer_find(net, name);
 930         if (!bearer) {
 931                 err = -EINVAL;
 932                 NL_SET_ERR_MSG(info->extack, "Bearer not found");
 933                 goto err_out;
 934         }
 935
 936         err = __tipc_nl_add_bearer(&msg, bearer, 0);
 937         if (err)
 938                 goto err_out;
 939         rtnl_unlock();
 940
 941         return genlmsg_reply(rep, info);
 942 err_out:
 943         rtnl_unlock();
 944         nlmsg_free(rep);
 945
 946         return err;
 947 }
 948
 949 int __tipc_nl_bearer_disable(struct sk_buff *skb, struct genl_info *info)
 950 {
 951         int err;
 952         char *name;
 953         struct tipc_bearer *bearer;
 954         struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
 955         struct net *net = sock_net(skb->sk);
 956
 957         if (!info->attrs[TIPC_NLA_BEARER])
 958                 return -EINVAL;
 959
 960         err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
 961                                           info->attrs[TIPC_NLA_BEARER],
 962                                           tipc_nl_bearer_policy, info->extack);
 963         if (err)
 964                 return err;
 965
 966         if (!attrs[TIPC_NLA_BEARER_NAME])
 967                 return -EINVAL;
 968
 969         name = nla_data(attrs[TIPC_NLA_BEARER_NAME]);
 970
 971         bearer = tipc_bearer_find(net, name);
 972         if (!bearer) {
 973                 NL_SET_ERR_MSG(info->extack, "Bearer not found");
 974                 return -EINVAL;
 975         }
 976
 977         bearer_disable(net, bearer);
 978
 979         return 0;
 980 }
 981
 982 int tipc_nl_bearer_disable(struct sk_buff *skb, struct genl_info *info)
 983 {
 984         int err;
 985
 986         rtnl_lock();
 987         err = __tipc_nl_bearer_disable(skb, info);
 988         rtnl_unlock();
 989
 990         return err;
 991 }
 992
 993 int __tipc_nl_bearer_enable(struct sk_buff *skb, struct genl_info *info)
 994 {
 995         int err;
 996         char *bearer;
 997         struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
 998         struct net *net = sock_net(skb->sk);
 999         u32 domain = 0;
1000         u32 prio;
1001
1002         prio = TIPC_MEDIA_LINK_PRI;
1003
1004         if (!info->attrs[TIPC_NLA_BEARER])
1005                 return -EINVAL;
1006
1007         err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
1008                                           info->attrs[TIPC_NLA_BEARER],
1009                                           tipc_nl_bearer_policy, info->extack);
1010         if (err)
1011                 return err;
1012
1013         if (!attrs[TIPC_NLA_BEARER_NAME])
1014                 return -EINVAL;
1015
1016         bearer = nla_data(attrs[TIPC_NLA_BEARER_NAME]);
1017
1018         if (attrs[TIPC_NLA_BEARER_DOMAIN])
1019                 domain = nla_get_u32(attrs[TIPC_NLA_BEARER_DOMAIN]);
1020
1021         if (attrs[TIPC_NLA_BEARER_PROP]) {
1022                 struct nlattr *props[TIPC_NLA_PROP_MAX + 1];
1023
1024                 err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_BEARER_PROP],
1025                                               props);
1026                 if (err)
1027                         return err;
1028
1029                 if (props[TIPC_NLA_PROP_PRIO])
1030                         prio = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
1031         }
1032
1033         return tipc_enable_bearer(net, bearer, domain, prio, attrs,
1034                                   info->extack);
1035 }
1036
1037 int tipc_nl_bearer_enable(struct sk_buff *skb, struct genl_info *info)
1038 {
1039         int err;
1040
1041         rtnl_lock();
1042         err = __tipc_nl_bearer_enable(skb, info);
1043         rtnl_unlock();
1044
1045         return err;
1046 }
1047
1048 int tipc_nl_bearer_add(struct sk_buff *skb, struct genl_info *info)
1049 {
1050         int err;
1051         char *name;
1052         struct tipc_bearer *b;
1053         struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
1054         struct net *net = sock_net(skb->sk);
1055
1056         if (!info->attrs[TIPC_NLA_BEARER])
1057                 return -EINVAL;
1058
1059         err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
1060                                           info->attrs[TIPC_NLA_BEARER],
1061                                           tipc_nl_bearer_policy, info->extack);
1062         if (err)
1063                 return err;
1064
1065         if (!attrs[TIPC_NLA_BEARER_NAME])
1066                 return -EINVAL;
1067         name = nla_data(attrs[TIPC_NLA_BEARER_NAME]);
1068
1069         rtnl_lock();
1070         b = tipc_bearer_find(net, name);
1071         if (!b) {
1072                 rtnl_unlock();
1073                 NL_SET_ERR_MSG(info->extack, "Bearer not found");
1074                 return -EINVAL;
1075         }
1076
1077 #ifdef CONFIG_TIPC_MEDIA_UDP
1078         if (attrs[TIPC_NLA_BEARER_UDP_OPTS]) {
1079                 err = tipc_udp_nl_bearer_add(b,
1080                                              attrs[TIPC_NLA_BEARER_UDP_OPTS]);
1081                 if (err) {
1082                         rtnl_unlock();
1083                         return err;
1084                 }
1085         }
1086 #endif
1087         rtnl_unlock();
1088
1089         return 0;
1090 }
1091
1092 int __tipc_nl_bearer_set(struct sk_buff *skb, struct genl_info *info)
1093 {
1094         struct tipc_bearer *b;
1095         struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
1096         struct net *net = sock_net(skb->sk);
1097         char *name;
1098         int err;
1099
1100         if (!info->attrs[TIPC_NLA_BEARER])
1101                 return -EINVAL;
1102
1103         err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
1104                                           info->attrs[TIPC_NLA_BEARER],
1105                                           tipc_nl_bearer_policy, info->extack);
1106         if (err)
1107                 return err;
1108
1109         if (!attrs[TIPC_NLA_BEARER_NAME])
1110                 return -EINVAL;
1111         name = nla_data(attrs[TIPC_NLA_BEARER_NAME]);
1112
1113         b = tipc_bearer_find(net, name);
1114         if (!b) {
1115                 NL_SET_ERR_MSG(info->extack, "Bearer not found");
1116                 return -EINVAL;
1117         }
1118
1119         if (attrs[TIPC_NLA_BEARER_PROP]) {
1120                 struct nlattr *props[TIPC_NLA_PROP_MAX + 1];
1121
1122                 err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_BEARER_PROP],
1123                                               props);
1124                 if (err)
1125                         return err;
1126
1127                 if (props[TIPC_NLA_PROP_TOL]) {
1128                         b->tolerance = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
1129                         tipc_node_apply_property(net, b, TIPC_NLA_PROP_TOL);
1130                 }
1131                 if (props[TIPC_NLA_PROP_PRIO])
1132                         b->priority = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
1133                 if (props[TIPC_NLA_PROP_WIN])
1134                         b->max_win = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
1135                 if (props[TIPC_NLA_PROP_MTU]) {
1136                         if (b->media->type_id != TIPC_MEDIA_TYPE_UDP) {
1137                                 NL_SET_ERR_MSG(info->extack,
1138                                                "MTU property is unsupported");
1139                                 return -EINVAL;
1140                         }
1141 #ifdef CONFIG_TIPC_MEDIA_UDP
1142                         if (tipc_udp_mtu_bad(nla_get_u32
1143                                              (props[TIPC_NLA_PROP_MTU]))) {
1144                                 NL_SET_ERR_MSG(info->extack,
1145                                                "MTU value is out-of-range");
1146                                 return -EINVAL;
1147                         }
1148                         b->mtu = nla_get_u32(props[TIPC_NLA_PROP_MTU]);
1149                         tipc_node_apply_property(net, b, TIPC_NLA_PROP_MTU);
1150 #endif
1151                 }
1152         }
1153
1154         return 0;
1155 }
1156
1157 int tipc_nl_bearer_set(struct sk_buff *skb, struct genl_info *info)
1158 {
1159         int err;
1160
1161         rtnl_lock();
1162         err = __tipc_nl_bearer_set(skb, info);
1163         rtnl_unlock();
1164
1165         return err;
1166 }
1167
1168 static int __tipc_nl_add_media(struct tipc_nl_msg *msg,
1169                                struct tipc_media *media, int nlflags)
1170 {
1171         void *hdr;
1172         struct nlattr *attrs;
1173         struct nlattr *prop;
1174
1175         hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
1176                           nlflags, TIPC_NL_MEDIA_GET);
1177         if (!hdr)
1178                 return -EMSGSIZE;
1179
1180         attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_MEDIA);
1181         if (!attrs)
1182                 goto msg_full;
1183
1184         if (nla_put_string(msg->skb, TIPC_NLA_MEDIA_NAME, media->name))
1185                 goto attr_msg_full;
1186
1187         prop = nla_nest_start_noflag(msg->skb, TIPC_NLA_MEDIA_PROP);
1188         if (!prop)
1189                 goto prop_msg_full;
1190         if (nla_put_u32(msg->skb, TIPC_NLA_PROP_PRIO, media->priority))
1191                 goto prop_msg_full;
1192         if (nla_put_u32(msg->skb, TIPC_NLA_PROP_TOL, media->tolerance))
1193                 goto prop_msg_full;
1194         if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN, media->max_win))
1195                 goto prop_msg_full;
1196         if (media->type_id == TIPC_MEDIA_TYPE_UDP)
1197                 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_MTU, media->mtu))
1198                         goto prop_msg_full;
1199
1200         nla_nest_end(msg->skb, prop);
1201         nla_nest_end(msg->skb, attrs);
1202         genlmsg_end(msg->skb, hdr);
1203
1204         return 0;
1205
1206 prop_msg_full:
1207         nla_nest_cancel(msg->skb, prop);
1208 attr_msg_full:
1209         nla_nest_cancel(msg->skb, attrs);
1210 msg_full:
1211         genlmsg_cancel(msg->skb, hdr);
1212
1213         return -EMSGSIZE;
1214 }
1215
1216 int tipc_nl_media_dump(struct sk_buff *skb, struct netlink_callback *cb)
1217 {
1218         int err;
1219         int i = cb->args[0];
1220         struct tipc_nl_msg msg;
1221
1222         if (i == MAX_MEDIA)
1223                 return 0;
1224
1225         msg.skb = skb;
1226         msg.portid = NETLINK_CB(cb->skb).portid;
1227         msg.seq = cb->nlh->nlmsg_seq;
1228
1229         rtnl_lock();
1230         for (; media_info_array[i] != NULL; i++) {
1231                 err = __tipc_nl_add_media(&msg, media_info_array[i],
1232                                           NLM_F_MULTI);
1233                 if (err)
1234                         break;
1235         }
1236         rtnl_unlock();
1237
1238         cb->args[0] = i;
1239         return skb->len;
1240 }
1241
1242 int tipc_nl_media_get(struct sk_buff *skb, struct genl_info *info)
1243 {
1244         int err;
1245         char *name;
1246         struct tipc_nl_msg msg;
1247         struct tipc_media *media;
1248         struct sk_buff *rep;
1249         struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
1250
1251         if (!info->attrs[TIPC_NLA_MEDIA])
1252                 return -EINVAL;
1253
1254         err = nla_parse_nested_deprecated(attrs, TIPC_NLA_MEDIA_MAX,
1255                                           info->attrs[TIPC_NLA_MEDIA],
1256                                           tipc_nl_media_policy, info->extack);
1257         if (err)
1258                 return err;
1259
1260         if (!attrs[TIPC_NLA_MEDIA_NAME])
1261                 return -EINVAL;
1262         name = nla_data(attrs[TIPC_NLA_MEDIA_NAME]);
1263
1264         rep = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
1265         if (!rep)
1266                 return -ENOMEM;
1267
1268         msg.skb = rep;
1269         msg.portid = info->snd_portid;
1270         msg.seq = info->snd_seq;
1271
1272         rtnl_lock();
1273         media = tipc_media_find(name);
1274         if (!media) {
1275                 NL_SET_ERR_MSG(info->extack, "Media not found");
1276                 err = -EINVAL;
1277                 goto err_out;
1278         }
1279
1280         err = __tipc_nl_add_media(&msg, media, 0);
1281         if (err)
1282                 goto err_out;
1283         rtnl_unlock();
1284
1285         return genlmsg_reply(rep, info);
1286 err_out:
1287         rtnl_unlock();
1288         nlmsg_free(rep);
1289
1290         return err;
1291 }
1292
1293 int __tipc_nl_media_set(struct sk_buff *skb, struct genl_info *info)
1294 {
1295         int err;
1296         char *name;
1297         struct tipc_media *m;
1298         struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
1299
1300         if (!info->attrs[TIPC_NLA_MEDIA])
1301                 return -EINVAL;
1302
1303         err = nla_parse_nested_deprecated(attrs, TIPC_NLA_MEDIA_MAX,
1304                                           info->attrs[TIPC_NLA_MEDIA],
1305                                           tipc_nl_media_policy, info->extack);
1306
1307         if (!attrs[TIPC_NLA_MEDIA_NAME])
1308                 return -EINVAL;
1309         name = nla_data(attrs[TIPC_NLA_MEDIA_NAME]);
1310
1311         m = tipc_media_find(name);
1312         if (!m) {
1313                 NL_SET_ERR_MSG(info->extack, "Media not found");
1314                 return -EINVAL;
1315         }
1316         if (attrs[TIPC_NLA_MEDIA_PROP]) {
1317                 struct nlattr *props[TIPC_NLA_PROP_MAX + 1];
1318
1319                 err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_MEDIA_PROP],
1320                                               props);
1321                 if (err)
1322                         return err;
1323
1324                 if (props[TIPC_NLA_PROP_TOL])
1325                         m->tolerance = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
1326                 if (props[TIPC_NLA_PROP_PRIO])
1327                         m->priority = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
1328                 if (props[TIPC_NLA_PROP_WIN])
1329                         m->max_win = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
1330                 if (props[TIPC_NLA_PROP_MTU]) {
1331                         if (m->type_id != TIPC_MEDIA_TYPE_UDP) {
1332                                 NL_SET_ERR_MSG(info->extack,
1333                                                "MTU property is unsupported");
1334                                 return -EINVAL;
1335                         }
1336 #ifdef CONFIG_TIPC_MEDIA_UDP
1337                         if (tipc_udp_mtu_bad(nla_get_u32
1338                                              (props[TIPC_NLA_PROP_MTU]))) {
1339                                 NL_SET_ERR_MSG(info->extack,
1340                                                "MTU value is out-of-range");
1341                                 return -EINVAL;
1342                         }
1343                         m->mtu = nla_get_u32(props[TIPC_NLA_PROP_MTU]);
1344 #endif
1345                 }
1346         }
1347
1348         return 0;
1349 }
1350
1351 int tipc_nl_media_set(struct sk_buff *skb, struct genl_info *info)
1352 {
1353         int err;
1354
1355         rtnl_lock();
1356         err = __tipc_nl_media_set(skb, info);
1357         rtnl_unlock();
1358
1359         return err;
1360 }