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