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         test_and_set_bit_lock(0, &b->up);
 356         rcu_assign_pointer(tn->bearer_list[bearer_id], b);
 357         if (skb)
 358                 tipc_bearer_xmit_skb(net, bearer_id, skb, &b->bcast_addr);
 359
 360         if (tipc_mon_create(net, bearer_id)) {
 361                 bearer_disable(net, b);
 362                 return -ENOMEM;
 363         }
 364
 365         pr_info("Enabled bearer <%s>, priority %u\n", name, prio);
 366
 367         return res;
 368 rejected:
 369         pr_warn("Enabling of bearer <%s> rejected, %s\n", name, errstr);
 370         return res;
 371 }
 372
 373 /**
 374  * tipc_reset_bearer - Reset all links established over this bearer
 375  * @net: the applicable net namespace
 376  * @b: the target bearer
 377  */
 378 static int tipc_reset_bearer(struct net *net, struct tipc_bearer *b)
 379 {
 380         pr_info("Resetting bearer <%s>\n", b->name);
 381         tipc_node_delete_links(net, b->identity);
 382         tipc_disc_reset(net, b);
 383         return 0;
 384 }
 385
 386 bool tipc_bearer_hold(struct tipc_bearer *b)
 387 {
 388         return (b && refcount_inc_not_zero(&b->refcnt));
 389 }
 390
 391 void tipc_bearer_put(struct tipc_bearer *b)
 392 {
 393         if (b && refcount_dec_and_test(&b->refcnt))
 394                 kfree_rcu(b, rcu);
 395 }
 396
 397 /**
 398  * bearer_disable - disable this bearer
 399  * @net: the applicable net namespace
 400  * @b: the bearer to disable
 401  *
 402  * Note: This routine assumes caller holds RTNL lock.
 403  */
 404 static void bearer_disable(struct net *net, struct tipc_bearer *b)
 405 {
 406         struct tipc_net *tn = tipc_net(net);
 407         int bearer_id = b->identity;
 408
 409         pr_info("Disabling bearer <%s>\n", b->name);
 410         clear_bit_unlock(0, &b->up);
 411         tipc_node_delete_links(net, bearer_id);
 412         b->media->disable_media(b);
 413         RCU_INIT_POINTER(b->media_ptr, NULL);
 414         if (b->disc)
 415                 tipc_disc_delete(b->disc);
 416         RCU_INIT_POINTER(tn->bearer_list[bearer_id], NULL);
 417         tipc_bearer_put(b);
 418         tipc_mon_delete(net, bearer_id);
 419 }
 420
 421 int tipc_enable_l2_media(struct net *net, struct tipc_bearer *b,
 422                          struct nlattr *attr[])
 423 {
 424         char *dev_name = strchr((const char *)b->name, ':') + 1;
 425         int hwaddr_len = b->media->hwaddr_len;
 426         u8 node_id[NODE_ID_LEN] = {0,};
 427         struct net_device *dev;
 428
 429         /* Find device with specified name */
 430         dev = dev_get_by_name(net, dev_name);
 431         if (!dev)
 432                 return -ENODEV;
 433         if (tipc_mtu_bad(dev, 0)) {
 434                 dev_put(dev);
 435                 return -EINVAL;
 436         }
 437         if (dev == net->loopback_dev) {
 438                 dev_put(dev);
 439                 pr_info("Enabling <%s> not permitted\n", b->name);
 440                 return -EINVAL;
 441         }
 442
 443         /* Autoconfigure own node identity if needed */
 444         if (!tipc_own_id(net) && hwaddr_len <= NODE_ID_LEN) {
 445                 memcpy(node_id, dev->dev_addr, hwaddr_len);
 446                 tipc_net_init(net, node_id, 0);
 447         }
 448         if (!tipc_own_id(net)) {
 449                 dev_put(dev);
 450                 pr_warn("Failed to obtain node identity\n");
 451                 return -EINVAL;
 452         }
 453
 454         /* Associate TIPC bearer with L2 bearer */
 455         rcu_assign_pointer(b->media_ptr, dev);
 456         b->pt.dev = dev;
 457         b->pt.type = htons(ETH_P_TIPC);
 458         b->pt.func = tipc_l2_rcv_msg;
 459         dev_add_pack(&b->pt);
 460         memset(&b->bcast_addr, 0, sizeof(b->bcast_addr));
 461         memcpy(b->bcast_addr.value, dev->broadcast, hwaddr_len);
 462         b->bcast_addr.media_id = b->media->type_id;
 463         b->bcast_addr.broadcast = TIPC_BROADCAST_SUPPORT;
 464         b->mtu = dev->mtu;
 465         b->media->raw2addr(b, &b->addr, (char *)dev->dev_addr);
 466         rcu_assign_pointer(dev->tipc_ptr, b);
 467         return 0;
 468 }
 469
 470 /* tipc_disable_l2_media - detach TIPC bearer from an L2 interface
 471  * @b: the target bearer
 472  *
 473  * Mark L2 bearer as inactive so that incoming buffers are thrown away
 474  */
 475 void tipc_disable_l2_media(struct tipc_bearer *b)
 476 {
 477         struct net_device *dev;
 478
 479         dev = (struct net_device *)rtnl_dereference(b->media_ptr);
 480         dev_remove_pack(&b->pt);
 481         RCU_INIT_POINTER(dev->tipc_ptr, NULL);
 482         synchronize_net();
 483         dev_put(dev);
 484 }
 485
 486 /**
 487  * tipc_l2_send_msg - send a TIPC packet out over an L2 interface
 488  * @net: the associated network namespace
 489  * @skb: the packet to be sent
 490  * @b: the bearer through which the packet is to be sent
 491  * @dest: peer destination address
 492  */
 493 int tipc_l2_send_msg(struct net *net, struct sk_buff *skb,
 494                      struct tipc_bearer *b, struct tipc_media_addr *dest)
 495 {
 496         struct net_device *dev;
 497         int delta;
 498
 499         dev = (struct net_device *)rcu_dereference(b->media_ptr);
 500         if (!dev)
 501                 return 0;
 502
 503         delta = SKB_DATA_ALIGN(dev->hard_header_len - skb_headroom(skb));
 504         if ((delta > 0) && pskb_expand_head(skb, delta, 0, GFP_ATOMIC)) {
 505                 kfree_skb(skb);
 506                 return 0;
 507         }
 508         skb_reset_network_header(skb);
 509         skb->dev = dev;
 510         skb->protocol = htons(ETH_P_TIPC);
 511         dev_hard_header(skb, dev, ETH_P_TIPC, dest->value,
 512                         dev->dev_addr, skb->len);
 513         dev_queue_xmit(skb);
 514         return 0;
 515 }
 516
 517 bool tipc_bearer_bcast_support(struct net *net, u32 bearer_id)
 518 {
 519         bool supp = false;
 520         struct tipc_bearer *b;
 521
 522         rcu_read_lock();
 523         b = bearer_get(net, bearer_id);
 524         if (b)
 525                 supp = (b->bcast_addr.broadcast == TIPC_BROADCAST_SUPPORT);
 526         rcu_read_unlock();
 527         return supp;
 528 }
 529
 530 int tipc_bearer_mtu(struct net *net, u32 bearer_id)
 531 {
 532         int mtu = 0;
 533         struct tipc_bearer *b;
 534
 535         rcu_read_lock();
 536         b = rcu_dereference(tipc_net(net)->bearer_list[bearer_id]);
 537         if (b)
 538                 mtu = b->mtu;
 539         rcu_read_unlock();
 540         return mtu;
 541 }
 542
 543 /* tipc_bearer_xmit_skb - sends buffer to destination over bearer
 544  */
 545 void tipc_bearer_xmit_skb(struct net *net, u32 bearer_id,
 546                           struct sk_buff *skb,
 547                           struct tipc_media_addr *dest)
 548 {
 549         struct tipc_msg *hdr = buf_msg(skb);
 550         struct tipc_bearer *b;
 551
 552         rcu_read_lock();
 553         b = bearer_get(net, bearer_id);
 554         if (likely(b && (test_bit(0, &b->up) || msg_is_reset(hdr)))) {
 555 #ifdef CONFIG_TIPC_CRYPTO
 556                 tipc_crypto_xmit(net, &skb, b, dest, NULL);
 557                 if (skb)
 558 #endif
 559                         b->media->send_msg(net, skb, b, dest);
 560         } else {
 561                 kfree_skb(skb);
 562         }
 563         rcu_read_unlock();
 564 }
 565
 566 /* tipc_bearer_xmit() -send buffer to destination over bearer
 567  */
 568 void tipc_bearer_xmit(struct net *net, u32 bearer_id,
 569                       struct sk_buff_head *xmitq,
 570                       struct tipc_media_addr *dst,
 571                       struct tipc_node *__dnode)
 572 {
 573         struct tipc_bearer *b;
 574         struct sk_buff *skb, *tmp;
 575
 576         if (skb_queue_empty(xmitq))
 577                 return;
 578
 579         rcu_read_lock();
 580         b = bearer_get(net, bearer_id);
 581         if (unlikely(!b))
 582                 __skb_queue_purge(xmitq);
 583         skb_queue_walk_safe(xmitq, skb, tmp) {
 584                 __skb_dequeue(xmitq);
 585                 if (likely(test_bit(0, &b->up) || msg_is_reset(buf_msg(skb)))) {
 586 #ifdef CONFIG_TIPC_CRYPTO
 587                         tipc_crypto_xmit(net, &skb, b, dst, __dnode);
 588                         if (skb)
 589 #endif
 590                                 b->media->send_msg(net, skb, b, dst);
 591                 } else {
 592                         kfree_skb(skb);
 593                 }
 594         }
 595         rcu_read_unlock();
 596 }
 597
 598 /* tipc_bearer_bc_xmit() - broadcast buffers to all destinations
 599  */
 600 void tipc_bearer_bc_xmit(struct net *net, u32 bearer_id,
 601                          struct sk_buff_head *xmitq)
 602 {
 603         struct tipc_net *tn = tipc_net(net);
 604         struct tipc_media_addr *dst;
 605         int net_id = tn->net_id;
 606         struct tipc_bearer *b;
 607         struct sk_buff *skb, *tmp;
 608         struct tipc_msg *hdr;
 609
 610         rcu_read_lock();
 611         b = bearer_get(net, bearer_id);
 612         if (unlikely(!b || !test_bit(0, &b->up)))
 613                 __skb_queue_purge(xmitq);
 614         skb_queue_walk_safe(xmitq, skb, tmp) {
 615                 hdr = buf_msg(skb);
 616                 msg_set_non_seq(hdr, 1);
 617                 msg_set_mc_netid(hdr, net_id);
 618                 __skb_dequeue(xmitq);
 619                 dst = &b->bcast_addr;
 620 #ifdef CONFIG_TIPC_CRYPTO
 621                 tipc_crypto_xmit(net, &skb, b, dst, NULL);
 622                 if (skb)
 623 #endif
 624                         b->media->send_msg(net, skb, b, dst);
 625         }
 626         rcu_read_unlock();
 627 }
 628
 629 /**
 630  * tipc_l2_rcv_msg - handle incoming TIPC message from an interface
 631  * @skb: the received message
 632  * @dev: the net device that the packet was received on
 633  * @pt: the packet_type structure which was used to register this handler
 634  * @orig_dev: the original receive net device in case the device is a bond
 635  *
 636  * Accept only packets explicitly sent to this node, or broadcast packets;
 637  * ignores packets sent using interface multicast, and traffic sent to other
 638  * nodes (which can happen if interface is running in promiscuous mode).
 639  */
 640 static int tipc_l2_rcv_msg(struct sk_buff *skb, struct net_device *dev,
 641                            struct packet_type *pt, struct net_device *orig_dev)
 642 {
 643         struct tipc_bearer *b;
 644
 645         rcu_read_lock();
 646         b = rcu_dereference(dev->tipc_ptr) ?:
 647                 rcu_dereference(orig_dev->tipc_ptr);
 648         if (likely(b && test_bit(0, &b->up) &&
 649                    (skb->pkt_type <= PACKET_MULTICAST))) {
 650                 skb_mark_not_on_list(skb);
 651                 TIPC_SKB_CB(skb)->flags = 0;
 652                 tipc_rcv(dev_net(b->pt.dev), skb, b);
 653                 rcu_read_unlock();
 654                 return NET_RX_SUCCESS;
 655         }
 656         rcu_read_unlock();
 657         kfree_skb(skb);
 658         return NET_RX_DROP;
 659 }
 660
 661 /**
 662  * tipc_l2_device_event - handle device events from network device
 663  * @nb: the context of the notification
 664  * @evt: the type of event
 665  * @ptr: the net device that the event was on
 666  *
 667  * This function is called by the Ethernet driver in case of link
 668  * change event.
 669  */
 670 static int tipc_l2_device_event(struct notifier_block *nb, unsigned long evt,
 671                                 void *ptr)
 672 {
 673         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 674         struct net *net = dev_net(dev);
 675         struct tipc_bearer *b;
 676
 677         b = rtnl_dereference(dev->tipc_ptr);
 678         if (!b)
 679                 return NOTIFY_DONE;
 680
 681         trace_tipc_l2_device_event(dev, b, evt);
 682         switch (evt) {
 683         case NETDEV_CHANGE:
 684                 if (netif_carrier_ok(dev) && netif_oper_up(dev)) {
 685                         test_and_set_bit_lock(0, &b->up);
 686                         break;
 687                 }
 688                 fallthrough;
 689         case NETDEV_GOING_DOWN:
 690                 clear_bit_unlock(0, &b->up);
 691                 tipc_reset_bearer(net, b);
 692                 break;
 693         case NETDEV_UP:
 694                 test_and_set_bit_lock(0, &b->up);
 695                 break;
 696         case NETDEV_CHANGEMTU:
 697                 if (tipc_mtu_bad(dev, 0)) {
 698                         bearer_disable(net, b);
 699                         break;
 700                 }
 701                 b->mtu = dev->mtu;
 702                 tipc_reset_bearer(net, b);
 703                 break;
 704         case NETDEV_CHANGEADDR:
 705                 b->media->raw2addr(b, &b->addr,
 706                                    (char *)dev->dev_addr);
 707                 tipc_reset_bearer(net, b);
 708                 break;
 709         case NETDEV_UNREGISTER:
 710         case NETDEV_CHANGENAME:
 711                 bearer_disable(net, b);
 712                 break;
 713         }
 714         return NOTIFY_OK;
 715 }
 716
 717 static struct notifier_block notifier = {
 718         .notifier_call  = tipc_l2_device_event,
 719         .priority       = 0,
 720 };
 721
 722 int tipc_bearer_setup(void)
 723 {
 724         return register_netdevice_notifier(&notifier);
 725 }
 726
 727 void tipc_bearer_cleanup(void)
 728 {
 729         unregister_netdevice_notifier(&notifier);
 730 }
 731
 732 void tipc_bearer_stop(struct net *net)
 733 {
 734         struct tipc_net *tn = net_generic(net, tipc_net_id);
 735         struct tipc_bearer *b;
 736         u32 i;
 737
 738         for (i = 0; i < MAX_BEARERS; i++) {
 739                 b = rtnl_dereference(tn->bearer_list[i]);
 740                 if (b) {
 741                         bearer_disable(net, b);
 742                         tn->bearer_list[i] = NULL;
 743                 }
 744         }
 745 }
 746
 747 void tipc_clone_to_loopback(struct net *net, struct sk_buff_head *pkts)
 748 {
 749         struct net_device *dev = net->loopback_dev;
 750         struct sk_buff *skb, *_skb;
 751         int exp;
 752
 753         skb_queue_walk(pkts, _skb) {
 754                 skb = pskb_copy(_skb, GFP_ATOMIC);
 755                 if (!skb)
 756                         continue;
 757
 758                 exp = SKB_DATA_ALIGN(dev->hard_header_len - skb_headroom(skb));
 759                 if (exp > 0 && pskb_expand_head(skb, exp, 0, GFP_ATOMIC)) {
 760                         kfree_skb(skb);
 761                         continue;
 762                 }
 763
 764                 skb_reset_network_header(skb);
 765                 dev_hard_header(skb, dev, ETH_P_TIPC, dev->dev_addr,
 766                                 dev->dev_addr, skb->len);
 767                 skb->dev = dev;
 768                 skb->pkt_type = PACKET_HOST;
 769                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 770                 skb->protocol = eth_type_trans(skb, dev);
 771                 netif_rx_ni(skb);
 772         }
 773 }
 774
 775 static int tipc_loopback_rcv_pkt(struct sk_buff *skb, struct net_device *dev,
 776                                  struct packet_type *pt, struct net_device *od)
 777 {
 778         consume_skb(skb);
 779         return NET_RX_SUCCESS;
 780 }
 781
 782 int tipc_attach_loopback(struct net *net)
 783 {
 784         struct net_device *dev = net->loopback_dev;
 785         struct tipc_net *tn = tipc_net(net);
 786
 787         if (!dev)
 788                 return -ENODEV;
 789
 790         dev_hold(dev);
 791         tn->loopback_pt.dev = dev;
 792         tn->loopback_pt.type = htons(ETH_P_TIPC);
 793         tn->loopback_pt.func = tipc_loopback_rcv_pkt;
 794         dev_add_pack(&tn->loopback_pt);
 795         return 0;
 796 }
 797
 798 void tipc_detach_loopback(struct net *net)
 799 {
 800         struct tipc_net *tn = tipc_net(net);
 801
 802         dev_remove_pack(&tn->loopback_pt);
 803         dev_put(net->loopback_dev);
 804 }
 805
 806 /* Caller should hold rtnl_lock to protect the bearer */
 807 static int __tipc_nl_add_bearer(struct tipc_nl_msg *msg,
 808                                 struct tipc_bearer *bearer, int nlflags)
 809 {
 810         void *hdr;
 811         struct nlattr *attrs;
 812         struct nlattr *prop;
 813
 814         hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
 815                           nlflags, TIPC_NL_BEARER_GET);
 816         if (!hdr)
 817                 return -EMSGSIZE;
 818
 819         attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_BEARER);
 820         if (!attrs)
 821                 goto msg_full;
 822
 823         if (nla_put_string(msg->skb, TIPC_NLA_BEARER_NAME, bearer->name))
 824                 goto attr_msg_full;
 825
 826         prop = nla_nest_start_noflag(msg->skb, TIPC_NLA_BEARER_PROP);
 827         if (!prop)
 828                 goto prop_msg_full;
 829         if (nla_put_u32(msg->skb, TIPC_NLA_PROP_PRIO, bearer->priority))
 830                 goto prop_msg_full;
 831         if (nla_put_u32(msg->skb, TIPC_NLA_PROP_TOL, bearer->tolerance))
 832                 goto prop_msg_full;
 833         if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN, bearer->max_win))
 834                 goto prop_msg_full;
 835         if (bearer->media->type_id == TIPC_MEDIA_TYPE_UDP)
 836                 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_MTU, bearer->mtu))
 837                         goto prop_msg_full;
 838
 839         nla_nest_end(msg->skb, prop);
 840
 841 #ifdef CONFIG_TIPC_MEDIA_UDP
 842         if (bearer->media->type_id == TIPC_MEDIA_TYPE_UDP) {
 843                 if (tipc_udp_nl_add_bearer_data(msg, bearer))
 844                         goto attr_msg_full;
 845         }
 846 #endif
 847
 848         nla_nest_end(msg->skb, attrs);
 849         genlmsg_end(msg->skb, hdr);
 850
 851         return 0;
 852
 853 prop_msg_full:
 854         nla_nest_cancel(msg->skb, prop);
 855 attr_msg_full:
 856         nla_nest_cancel(msg->skb, attrs);
 857 msg_full:
 858         genlmsg_cancel(msg->skb, hdr);
 859
 860         return -EMSGSIZE;
 861 }
 862
 863 int tipc_nl_bearer_dump(struct sk_buff *skb, struct netlink_callback *cb)
 864 {
 865         int err;
 866         int i = cb->args[0];
 867         struct tipc_bearer *bearer;
 868         struct tipc_nl_msg msg;
 869         struct net *net = sock_net(skb->sk);
 870         struct tipc_net *tn = net_generic(net, tipc_net_id);
 871
 872         if (i == MAX_BEARERS)
 873                 return 0;
 874
 875         msg.skb = skb;
 876         msg.portid = NETLINK_CB(cb->skb).portid;
 877         msg.seq = cb->nlh->nlmsg_seq;
 878
 879         rtnl_lock();
 880         for (i = 0; i < MAX_BEARERS; i++) {
 881                 bearer = rtnl_dereference(tn->bearer_list[i]);
 882                 if (!bearer)
 883                         continue;
 884
 885                 err = __tipc_nl_add_bearer(&msg, bearer, NLM_F_MULTI);
 886                 if (err)
 887                         break;
 888         }
 889         rtnl_unlock();
 890
 891         cb->args[0] = i;
 892         return skb->len;
 893 }
 894
 895 int tipc_nl_bearer_get(struct sk_buff *skb, struct genl_info *info)
 896 {
 897         int err;
 898         char *name;
 899         struct sk_buff *rep;
 900         struct tipc_bearer *bearer;
 901         struct tipc_nl_msg msg;
 902         struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
 903         struct net *net = genl_info_net(info);
 904
 905         if (!info->attrs[TIPC_NLA_BEARER])
 906                 return -EINVAL;
 907
 908         err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
 909                                           info->attrs[TIPC_NLA_BEARER],
 910                                           tipc_nl_bearer_policy, info->extack);
 911         if (err)
 912                 return err;
 913
 914         if (!attrs[TIPC_NLA_BEARER_NAME])
 915                 return -EINVAL;
 916         name = nla_data(attrs[TIPC_NLA_BEARER_NAME]);
 917
 918         rep = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 919         if (!rep)
 920                 return -ENOMEM;
 921
 922         msg.skb = rep;
 923         msg.portid = info->snd_portid;
 924         msg.seq = info->snd_seq;
 925
 926         rtnl_lock();
 927         bearer = tipc_bearer_find(net, name);
 928         if (!bearer) {
 929                 err = -EINVAL;
 930                 NL_SET_ERR_MSG(info->extack, "Bearer not found");
 931                 goto err_out;
 932         }
 933
 934         err = __tipc_nl_add_bearer(&msg, bearer, 0);
 935         if (err)
 936                 goto err_out;
 937         rtnl_unlock();
 938
 939         return genlmsg_reply(rep, info);
 940 err_out:
 941         rtnl_unlock();
 942         nlmsg_free(rep);
 943
 944         return err;
 945 }
 946
 947 int __tipc_nl_bearer_disable(struct sk_buff *skb, struct genl_info *info)
 948 {
 949         int err;
 950         char *name;
 951         struct tipc_bearer *bearer;
 952         struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
 953         struct net *net = sock_net(skb->sk);
 954
 955         if (!info->attrs[TIPC_NLA_BEARER])
 956                 return -EINVAL;
 957
 958         err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
 959                                           info->attrs[TIPC_NLA_BEARER],
 960                                           tipc_nl_bearer_policy, info->extack);
 961         if (err)
 962                 return err;
 963
 964         if (!attrs[TIPC_NLA_BEARER_NAME])
 965                 return -EINVAL;
 966
 967         name = nla_data(attrs[TIPC_NLA_BEARER_NAME]);
 968
 969         bearer = tipc_bearer_find(net, name);
 970         if (!bearer) {
 971                 NL_SET_ERR_MSG(info->extack, "Bearer not found");
 972                 return -EINVAL;
 973         }
 974
 975         bearer_disable(net, bearer);
 976
 977         return 0;
 978 }
 979
 980 int tipc_nl_bearer_disable(struct sk_buff *skb, struct genl_info *info)
 981 {
 982         int err;
 983
 984         rtnl_lock();
 985         err = __tipc_nl_bearer_disable(skb, info);
 986         rtnl_unlock();
 987
 988         return err;
 989 }
 990
 991 int __tipc_nl_bearer_enable(struct sk_buff *skb, struct genl_info *info)
 992 {
 993         int err;
 994         char *bearer;
 995         struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
 996         struct net *net = sock_net(skb->sk);
 997         u32 domain = 0;
 998         u32 prio;
 999
1000         prio = TIPC_MEDIA_LINK_PRI;
1001
1002         if (!info->attrs[TIPC_NLA_BEARER])
1003                 return -EINVAL;
1004
1005         err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
1006                                           info->attrs[TIPC_NLA_BEARER],
1007                                           tipc_nl_bearer_policy, info->extack);
1008         if (err)
1009                 return err;
1010
1011         if (!attrs[TIPC_NLA_BEARER_NAME])
1012                 return -EINVAL;
1013
1014         bearer = nla_data(attrs[TIPC_NLA_BEARER_NAME]);
1015
1016         if (attrs[TIPC_NLA_BEARER_DOMAIN])
1017                 domain = nla_get_u32(attrs[TIPC_NLA_BEARER_DOMAIN]);
1018
1019         if (attrs[TIPC_NLA_BEARER_PROP]) {
1020                 struct nlattr *props[TIPC_NLA_PROP_MAX + 1];
1021
1022                 err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_BEARER_PROP],
1023                                               props);
1024                 if (err)
1025                         return err;
1026
1027                 if (props[TIPC_NLA_PROP_PRIO])
1028                         prio = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
1029         }
1030
1031         return tipc_enable_bearer(net, bearer, domain, prio, attrs,
1032                                   info->extack);
1033 }
1034
1035 int tipc_nl_bearer_enable(struct sk_buff *skb, struct genl_info *info)
1036 {
1037         int err;
1038
1039         rtnl_lock();
1040         err = __tipc_nl_bearer_enable(skb, info);
1041         rtnl_unlock();
1042
1043         return err;
1044 }
1045
1046 int tipc_nl_bearer_add(struct sk_buff *skb, struct genl_info *info)
1047 {
1048         int err;
1049         char *name;
1050         struct tipc_bearer *b;
1051         struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
1052         struct net *net = sock_net(skb->sk);
1053
1054         if (!info->attrs[TIPC_NLA_BEARER])
1055                 return -EINVAL;
1056
1057         err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
1058                                           info->attrs[TIPC_NLA_BEARER],
1059                                           tipc_nl_bearer_policy, info->extack);
1060         if (err)
1061                 return err;
1062
1063         if (!attrs[TIPC_NLA_BEARER_NAME])
1064                 return -EINVAL;
1065         name = nla_data(attrs[TIPC_NLA_BEARER_NAME]);
1066
1067         rtnl_lock();
1068         b = tipc_bearer_find(net, name);
1069         if (!b) {
1070                 rtnl_unlock();
1071                 NL_SET_ERR_MSG(info->extack, "Bearer not found");
1072                 return -EINVAL;
1073         }
1074
1075 #ifdef CONFIG_TIPC_MEDIA_UDP
1076         if (attrs[TIPC_NLA_BEARER_UDP_OPTS]) {
1077                 err = tipc_udp_nl_bearer_add(b,
1078                                              attrs[TIPC_NLA_BEARER_UDP_OPTS]);
1079                 if (err) {
1080                         rtnl_unlock();
1081                         return err;
1082                 }
1083         }
1084 #endif
1085         rtnl_unlock();
1086
1087         return 0;
1088 }
1089
1090 int __tipc_nl_bearer_set(struct sk_buff *skb, struct genl_info *info)
1091 {
1092         struct tipc_bearer *b;
1093         struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
1094         struct net *net = sock_net(skb->sk);
1095         char *name;
1096         int err;
1097
1098         if (!info->attrs[TIPC_NLA_BEARER])
1099                 return -EINVAL;
1100
1101         err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
1102                                           info->attrs[TIPC_NLA_BEARER],
1103                                           tipc_nl_bearer_policy, info->extack);
1104         if (err)
1105                 return err;
1106
1107         if (!attrs[TIPC_NLA_BEARER_NAME])
1108                 return -EINVAL;
1109         name = nla_data(attrs[TIPC_NLA_BEARER_NAME]);
1110
1111         b = tipc_bearer_find(net, name);
1112         if (!b) {
1113                 NL_SET_ERR_MSG(info->extack, "Bearer not found");
1114                 return -EINVAL;
1115         }
1116
1117         if (attrs[TIPC_NLA_BEARER_PROP]) {
1118                 struct nlattr *props[TIPC_NLA_PROP_MAX + 1];
1119
1120                 err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_BEARER_PROP],
1121                                               props);
1122                 if (err)
1123                         return err;
1124
1125                 if (props[TIPC_NLA_PROP_TOL]) {
1126                         b->tolerance = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
1127                         tipc_node_apply_property(net, b, TIPC_NLA_PROP_TOL);
1128                 }
1129                 if (props[TIPC_NLA_PROP_PRIO])
1130                         b->priority = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
1131                 if (props[TIPC_NLA_PROP_WIN])
1132                         b->max_win = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
1133                 if (props[TIPC_NLA_PROP_MTU]) {
1134                         if (b->media->type_id != TIPC_MEDIA_TYPE_UDP) {
1135                                 NL_SET_ERR_MSG(info->extack,
1136                                                "MTU property is unsupported");
1137                                 return -EINVAL;
1138                         }
1139 #ifdef CONFIG_TIPC_MEDIA_UDP
1140                         if (tipc_udp_mtu_bad(nla_get_u32
1141                                              (props[TIPC_NLA_PROP_MTU]))) {
1142                                 NL_SET_ERR_MSG(info->extack,
1143                                                "MTU value is out-of-range");
1144                                 return -EINVAL;
1145                         }
1146                         b->mtu = nla_get_u32(props[TIPC_NLA_PROP_MTU]);
1147                         tipc_node_apply_property(net, b, TIPC_NLA_PROP_MTU);
1148 #endif
1149                 }
1150         }
1151
1152         return 0;
1153 }
1154
1155 int tipc_nl_bearer_set(struct sk_buff *skb, struct genl_info *info)
1156 {
1157         int err;
1158
1159         rtnl_lock();
1160         err = __tipc_nl_bearer_set(skb, info);
1161         rtnl_unlock();
1162
1163         return err;
1164 }
1165
1166 static int __tipc_nl_add_media(struct tipc_nl_msg *msg,
1167                                struct tipc_media *media, int nlflags)
1168 {
1169         void *hdr;
1170         struct nlattr *attrs;
1171         struct nlattr *prop;
1172
1173         hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
1174                           nlflags, TIPC_NL_MEDIA_GET);
1175         if (!hdr)
1176                 return -EMSGSIZE;
1177
1178         attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_MEDIA);
1179         if (!attrs)
1180                 goto msg_full;
1181
1182         if (nla_put_string(msg->skb, TIPC_NLA_MEDIA_NAME, media->name))
1183                 goto attr_msg_full;
1184
1185         prop = nla_nest_start_noflag(msg->skb, TIPC_NLA_MEDIA_PROP);
1186         if (!prop)
1187                 goto prop_msg_full;
1188         if (nla_put_u32(msg->skb, TIPC_NLA_PROP_PRIO, media->priority))
1189                 goto prop_msg_full;
1190         if (nla_put_u32(msg->skb, TIPC_NLA_PROP_TOL, media->tolerance))
1191                 goto prop_msg_full;
1192         if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN, media->max_win))
1193                 goto prop_msg_full;
1194         if (media->type_id == TIPC_MEDIA_TYPE_UDP)
1195                 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_MTU, media->mtu))
1196                         goto prop_msg_full;
1197
1198         nla_nest_end(msg->skb, prop);
1199         nla_nest_end(msg->skb, attrs);
1200         genlmsg_end(msg->skb, hdr);
1201
1202         return 0;
1203
1204 prop_msg_full:
1205         nla_nest_cancel(msg->skb, prop);
1206 attr_msg_full:
1207         nla_nest_cancel(msg->skb, attrs);
1208 msg_full:
1209         genlmsg_cancel(msg->skb, hdr);
1210
1211         return -EMSGSIZE;
1212 }
1213
1214 int tipc_nl_media_dump(struct sk_buff *skb, struct netlink_callback *cb)
1215 {
1216         int err;
1217         int i = cb->args[0];
1218         struct tipc_nl_msg msg;
1219
1220         if (i == MAX_MEDIA)
1221                 return 0;
1222
1223         msg.skb = skb;
1224         msg.portid = NETLINK_CB(cb->skb).portid;
1225         msg.seq = cb->nlh->nlmsg_seq;
1226
1227         rtnl_lock();
1228         for (; media_info_array[i] != NULL; i++) {
1229                 err = __tipc_nl_add_media(&msg, media_info_array[i],
1230                                           NLM_F_MULTI);
1231                 if (err)
1232                         break;
1233         }
1234         rtnl_unlock();
1235
1236         cb->args[0] = i;
1237         return skb->len;
1238 }
1239
1240 int tipc_nl_media_get(struct sk_buff *skb, struct genl_info *info)
1241 {
1242         int err;
1243         char *name;
1244         struct tipc_nl_msg msg;
1245         struct tipc_media *media;
1246         struct sk_buff *rep;
1247         struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
1248
1249         if (!info->attrs[TIPC_NLA_MEDIA])
1250                 return -EINVAL;
1251
1252         err = nla_parse_nested_deprecated(attrs, TIPC_NLA_MEDIA_MAX,
1253                                           info->attrs[TIPC_NLA_MEDIA],
1254                                           tipc_nl_media_policy, info->extack);
1255         if (err)
1256                 return err;
1257
1258         if (!attrs[TIPC_NLA_MEDIA_NAME])
1259                 return -EINVAL;
1260         name = nla_data(attrs[TIPC_NLA_MEDIA_NAME]);
1261
1262         rep = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
1263         if (!rep)
1264                 return -ENOMEM;
1265
1266         msg.skb = rep;
1267         msg.portid = info->snd_portid;
1268         msg.seq = info->snd_seq;
1269
1270         rtnl_lock();
1271         media = tipc_media_find(name);
1272         if (!media) {
1273                 NL_SET_ERR_MSG(info->extack, "Media not found");
1274                 err = -EINVAL;
1275                 goto err_out;
1276         }
1277
1278         err = __tipc_nl_add_media(&msg, media, 0);
1279         if (err)
1280                 goto err_out;
1281         rtnl_unlock();
1282
1283         return genlmsg_reply(rep, info);
1284 err_out:
1285         rtnl_unlock();
1286         nlmsg_free(rep);
1287
1288         return err;
1289 }
1290
1291 int __tipc_nl_media_set(struct sk_buff *skb, struct genl_info *info)
1292 {
1293         int err;
1294         char *name;
1295         struct tipc_media *m;
1296         struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
1297
1298         if (!info->attrs[TIPC_NLA_MEDIA])
1299                 return -EINVAL;
1300
1301         err = nla_parse_nested_deprecated(attrs, TIPC_NLA_MEDIA_MAX,
1302                                           info->attrs[TIPC_NLA_MEDIA],
1303                                           tipc_nl_media_policy, info->extack);
1304
1305         if (!attrs[TIPC_NLA_MEDIA_NAME])
1306                 return -EINVAL;
1307         name = nla_data(attrs[TIPC_NLA_MEDIA_NAME]);
1308
1309         m = tipc_media_find(name);
1310         if (!m) {
1311                 NL_SET_ERR_MSG(info->extack, "Media not found");
1312                 return -EINVAL;
1313         }
1314         if (attrs[TIPC_NLA_MEDIA_PROP]) {
1315                 struct nlattr *props[TIPC_NLA_PROP_MAX + 1];
1316
1317                 err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_MEDIA_PROP],
1318                                               props);
1319                 if (err)
1320                         return err;
1321
1322                 if (props[TIPC_NLA_PROP_TOL])
1323                         m->tolerance = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
1324                 if (props[TIPC_NLA_PROP_PRIO])
1325                         m->priority = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
1326                 if (props[TIPC_NLA_PROP_WIN])
1327                         m->max_win = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
1328                 if (props[TIPC_NLA_PROP_MTU]) {
1329                         if (m->type_id != TIPC_MEDIA_TYPE_UDP) {
1330                                 NL_SET_ERR_MSG(info->extack,
1331                                                "MTU property is unsupported");
1332                                 return -EINVAL;
1333                         }
1334 #ifdef CONFIG_TIPC_MEDIA_UDP
1335                         if (tipc_udp_mtu_bad(nla_get_u32
1336                                              (props[TIPC_NLA_PROP_MTU]))) {
1337                                 NL_SET_ERR_MSG(info->extack,
1338                                                "MTU value is out-of-range");
1339                                 return -EINVAL;
1340                         }
1341                         m->mtu = nla_get_u32(props[TIPC_NLA_PROP_MTU]);
1342 #endif
1343                 }
1344         }
1345
1346         return 0;
1347 }
1348
1349 int tipc_nl_media_set(struct sk_buff *skb, struct genl_info *info)
1350 {
1351         int err;
1352
1353         rtnl_lock();
1354         err = __tipc_nl_media_set(skb, info);
1355         rtnl_unlock();
1356
1357         return err;
1358 }