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