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