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