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