2 * net/tipc/bearer.c: TIPC bearer code
4 * Copyright (c) 1996-2006, 2013-2016, Ericsson AB
5 * Copyright (c) 2004-2006, 2010-2013, Wind River Systems
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
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.
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.
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.
45 #include "udp_media.h"
48 #define MAX_ADDR_STR 60
50 static struct tipc_media
* const media_info_array
[] = {
52 #ifdef CONFIG_TIPC_MEDIA_IB
55 #ifdef CONFIG_TIPC_MEDIA_UDP
61 static struct tipc_bearer
*bearer_get(struct net
*net
, int bearer_id
)
63 struct tipc_net
*tn
= tipc_net(net
);
65 return rcu_dereference(tn
->bearer_list
[bearer_id
]);
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
);
73 * tipc_media_find - locates specified media object by name
75 struct tipc_media
*tipc_media_find(const char *name
)
79 for (i
= 0; media_info_array
[i
] != NULL
; i
++) {
80 if (!strcmp(media_info_array
[i
]->name
, name
))
83 return media_info_array
[i
];
87 * media_find_id - locates specified media object by type identifier
89 static struct tipc_media
*media_find_id(u8 type
)
93 for (i
= 0; media_info_array
[i
] != NULL
; i
++) {
94 if (media_info_array
[i
]->type_id
== type
)
97 return media_info_array
[i
];
101 * tipc_media_addr_printf - record media address in print buffer
103 int tipc_media_addr_printf(char *buf
, int len
, struct tipc_media_addr
*a
)
105 char addr_str
[MAX_ADDR_STR
];
106 struct tipc_media
*m
;
109 m
= media_find_id(a
->media_id
);
111 if (m
&& !m
->addr2str(a
, addr_str
, sizeof(addr_str
)))
112 ret
= scnprintf(buf
, len
, "%s(%s)", m
->name
, addr_str
);
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
,
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)
129 * Returns 1 if bearer name is valid, otherwise 0.
131 static int bearer_name_validate(const char *name
,
132 struct tipc_bearer_names
*name_parts
)
134 char name_copy
[TIPC_MAX_BEARER_NAME
];
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)
147 /* ensure all component parts of bearer name are present */
148 media_name
= name_copy
;
149 if_name
= strchr(media_name
, ':');
153 media_len
= if_name
- media_name
;
154 if_len
= strlen(if_name
) + 1;
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
))
161 /* return bearer name components, if necessary */
163 strcpy(name_parts
->media_name
, media_name
);
164 strcpy(name_parts
->if_name
, if_name
);
170 * tipc_bearer_find - locates bearer object with matching bearer name
172 struct tipc_bearer
*tipc_bearer_find(struct net
*net
, const char *name
)
174 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
175 struct tipc_bearer
*b
;
178 for (i
= 0; i
< MAX_BEARERS
; i
++) {
179 b
= rtnl_dereference(tn
->bearer_list
[i
]);
180 if (b
&& (!strcmp(b
->name
, name
)))
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.
191 int tipc_bearer_get_name(struct net
*net
, char *name
, u32 bearer_id
)
193 struct tipc_net
*tn
= tipc_net(net
);
194 struct tipc_bearer
*b
;
196 if (bearer_id
>= MAX_BEARERS
)
199 b
= rtnl_dereference(tn
->bearer_list
[bearer_id
]);
203 strcpy(name
, b
->name
);
207 void tipc_bearer_add_dest(struct net
*net
, u32 bearer_id
, u32 dest
)
209 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
210 struct tipc_bearer
*b
;
213 b
= rcu_dereference(tn
->bearer_list
[bearer_id
]);
215 tipc_disc_add_dest(b
->disc
);
219 void tipc_bearer_remove_dest(struct net
*net
, u32 bearer_id
, u32 dest
)
221 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
222 struct tipc_bearer
*b
;
225 b
= rcu_dereference(tn
->bearer_list
[bearer_id
]);
227 tipc_disc_remove_dest(b
->disc
);
232 * tipc_enable_bearer - enable bearer with the given name
234 static int tipc_enable_bearer(struct net
*net
, const char *name
,
235 u32 disc_domain
, u32 prio
,
236 struct nlattr
*attr
[])
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
;
248 if (!bearer_name_validate(name
, &b_names
)) {
249 errstr
= "illegal name";
253 if (prio
> TIPC_MAX_LINK_PRI
&& prio
!= TIPC_MEDIA_LINK_PRI
) {
254 errstr
= "illegal priority";
258 m
= tipc_media_find(b_names
.media_name
);
260 errstr
= "media not registered";
264 if (prio
== TIPC_MEDIA_LINK_PRI
)
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
]);
272 if (!strcmp(name
, b
->name
)) {
273 errstr
= "already enabled";
277 if (b
->priority
!= prio
)
279 if (++with_this_prio
<= 2)
281 pr_warn("Bearer <%s>: already 2 bearers with priority %u\n",
283 if (prio
== TIPC_MIN_LINK_PRI
) {
284 errstr
= "cannot adjust to lower";
287 pr_warn("Bearer <%s>: trying with adjusted priority\n", name
);
293 if (bearer_id
>= MAX_BEARERS
) {
294 errstr
= "max 3 bearers permitted";
298 b
= kzalloc(sizeof(*b
), GFP_ATOMIC
);
302 strcpy(b
->name
, name
);
304 res
= m
->enable_media(net
, b
, attr
);
307 errstr
= "failed to enable media";
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';
317 test_and_set_bit_lock(0, &b
->up
);
319 res
= tipc_disc_create(net
, b
, &b
->bcast_addr
, &skb
);
321 bearer_disable(net
, b
);
322 errstr
= "failed to create discoverer";
326 rcu_assign_pointer(tn
->bearer_list
[bearer_id
], b
);
328 tipc_bearer_xmit_skb(net
, bearer_id
, skb
, &b
->bcast_addr
);
330 if (tipc_mon_create(net
, bearer_id
)) {
331 bearer_disable(net
, b
);
335 pr_info("Enabled bearer <%s>, priority %u\n", name
, prio
);
339 pr_warn("Enabling of bearer <%s> rejected, %s\n", name
, errstr
);
344 * tipc_reset_bearer - Reset all links established over this bearer
346 static int tipc_reset_bearer(struct net
*net
, struct tipc_bearer
*b
)
348 pr_info("Resetting bearer <%s>\n", b
->name
);
349 tipc_node_delete_links(net
, b
->identity
);
350 tipc_disc_reset(net
, b
);
357 * Note: This routine assumes caller holds RTNL lock.
359 static void bearer_disable(struct net
*net
, struct tipc_bearer
*b
)
361 struct tipc_net
*tn
= tipc_net(net
);
362 int bearer_id
= b
->identity
;
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
);
370 tipc_disc_delete(b
->disc
);
371 RCU_INIT_POINTER(tn
->bearer_list
[bearer_id
], NULL
);
373 tipc_mon_delete(net
, bearer_id
);
376 int tipc_enable_l2_media(struct net
*net
, struct tipc_bearer
*b
,
377 struct nlattr
*attr
[])
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
;
384 /* Find device with specified name */
385 dev
= dev_get_by_name(net
, dev_name
);
388 if (tipc_mtu_bad(dev
, 0)) {
392 if (dev
== net
->loopback_dev
) {
394 pr_info("Enabling <%s> not permitted\n", b
->name
);
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);
403 if (!tipc_own_id(net
)) {
405 pr_warn("Failed to obtain node identity\n");
409 /* Associate TIPC bearer with L2 bearer */
410 rcu_assign_pointer(b
->media_ptr
, 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
;
420 b
->media
->raw2addr(b
, &b
->addr
, (char *)dev
->dev_addr
);
421 rcu_assign_pointer(dev
->tipc_ptr
, b
);
425 /* tipc_disable_l2_media - detach TIPC bearer from an L2 interface
427 * Mark L2 bearer as inactive so that incoming buffers are thrown away
429 void tipc_disable_l2_media(struct tipc_bearer
*b
)
431 struct net_device
*dev
;
433 dev
= (struct net_device
*)rtnl_dereference(b
->media_ptr
);
434 dev_remove_pack(&b
->pt
);
435 RCU_INIT_POINTER(dev
->tipc_ptr
, NULL
);
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
446 int tipc_l2_send_msg(struct net
*net
, struct sk_buff
*skb
,
447 struct tipc_bearer
*b
, struct tipc_media_addr
*dest
)
449 struct net_device
*dev
;
452 dev
= (struct net_device
*)rcu_dereference(b
->media_ptr
);
456 delta
= SKB_DATA_ALIGN(dev
->hard_header_len
- skb_headroom(skb
));
457 if ((delta
> 0) && pskb_expand_head(skb
, delta
, 0, GFP_ATOMIC
)) {
461 skb_reset_network_header(skb
);
463 skb
->protocol
= htons(ETH_P_TIPC
);
464 dev_hard_header(skb
, dev
, ETH_P_TIPC
, dest
->value
,
465 dev
->dev_addr
, skb
->len
);
470 bool tipc_bearer_bcast_support(struct net
*net
, u32 bearer_id
)
473 struct tipc_bearer
*b
;
476 b
= bearer_get(net
, bearer_id
);
478 supp
= (b
->bcast_addr
.broadcast
== TIPC_BROADCAST_SUPPORT
);
483 int tipc_bearer_mtu(struct net
*net
, u32 bearer_id
)
486 struct tipc_bearer
*b
;
489 b
= rcu_dereference(tipc_net(net
)->bearer_list
[bearer_id
]);
496 /* tipc_bearer_xmit_skb - sends buffer to destination over bearer
498 void tipc_bearer_xmit_skb(struct net
*net
, u32 bearer_id
,
500 struct tipc_media_addr
*dest
)
502 struct tipc_msg
*hdr
= buf_msg(skb
);
503 struct tipc_bearer
*b
;
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
);
514 /* tipc_bearer_xmit() -send buffer to destination over bearer
516 void tipc_bearer_xmit(struct net
*net
, u32 bearer_id
,
517 struct sk_buff_head
*xmitq
,
518 struct tipc_media_addr
*dst
)
520 struct tipc_bearer
*b
;
521 struct sk_buff
*skb
, *tmp
;
523 if (skb_queue_empty(xmitq
))
527 b
= bearer_get(net
, bearer_id
);
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
);
540 /* tipc_bearer_bc_xmit() - broadcast buffers to all destinations
542 void tipc_bearer_bc_xmit(struct net
*net
, u32 bearer_id
,
543 struct sk_buff_head
*xmitq
)
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
;
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
) {
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
);
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
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).
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
)
579 struct tipc_bearer
*b
;
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
);
589 return NET_RX_SUCCESS
;
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
602 * This function is called by the Ethernet driver in case of link
605 static int tipc_l2_device_event(struct notifier_block
*nb
, unsigned long evt
,
608 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
609 struct net
*net
= dev_net(dev
);
610 struct tipc_bearer
*b
;
612 b
= rtnl_dereference(dev
->tipc_ptr
);
616 trace_tipc_l2_device_event(dev
, b
, evt
);
619 if (netif_carrier_ok(dev
) && netif_oper_up(dev
)) {
620 test_and_set_bit_lock(0, &b
->up
);
624 case NETDEV_GOING_DOWN
:
625 clear_bit_unlock(0, &b
->up
);
626 tipc_reset_bearer(net
, b
);
629 test_and_set_bit_lock(0, &b
->up
);
631 case NETDEV_CHANGEMTU
:
632 if (tipc_mtu_bad(dev
, 0)) {
633 bearer_disable(net
, b
);
637 tipc_reset_bearer(net
, b
);
639 case NETDEV_CHANGEADDR
:
640 b
->media
->raw2addr(b
, &b
->addr
,
641 (char *)dev
->dev_addr
);
642 tipc_reset_bearer(net
, b
);
644 case NETDEV_UNREGISTER
:
645 case NETDEV_CHANGENAME
:
646 bearer_disable(net
, b
);
652 static struct notifier_block notifier
= {
653 .notifier_call
= tipc_l2_device_event
,
657 int tipc_bearer_setup(void)
659 return register_netdevice_notifier(¬ifier
);
662 void tipc_bearer_cleanup(void)
664 unregister_netdevice_notifier(¬ifier
);
667 void tipc_bearer_stop(struct net
*net
)
669 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
670 struct tipc_bearer
*b
;
673 for (i
= 0; i
< MAX_BEARERS
; i
++) {
674 b
= rtnl_dereference(tn
->bearer_list
[i
]);
676 bearer_disable(net
, b
);
677 tn
->bearer_list
[i
] = NULL
;
682 void tipc_clone_to_loopback(struct net
*net
, struct sk_buff_head
*pkts
)
684 struct net_device
*dev
= net
->loopback_dev
;
685 struct sk_buff
*skb
, *_skb
;
688 skb_queue_walk(pkts
, _skb
) {
689 skb
= pskb_copy(_skb
, GFP_ATOMIC
);
693 exp
= SKB_DATA_ALIGN(dev
->hard_header_len
- skb_headroom(skb
));
694 if (exp
> 0 && pskb_expand_head(skb
, exp
, 0, GFP_ATOMIC
)) {
699 skb_reset_network_header(skb
);
700 dev_hard_header(skb
, dev
, ETH_P_TIPC
, dev
->dev_addr
,
701 dev
->dev_addr
, skb
->len
);
703 skb
->pkt_type
= PACKET_HOST
;
704 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
705 skb
->protocol
= eth_type_trans(skb
, dev
);
710 static int tipc_loopback_rcv_pkt(struct sk_buff
*skb
, struct net_device
*dev
,
711 struct packet_type
*pt
, struct net_device
*od
)
714 return NET_RX_SUCCESS
;
717 int tipc_attach_loopback(struct net
*net
)
719 struct net_device
*dev
= net
->loopback_dev
;
720 struct tipc_net
*tn
= tipc_net(net
);
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
);
733 void tipc_detach_loopback(struct net
*net
)
735 struct tipc_net
*tn
= tipc_net(net
);
737 dev_remove_pack(&tn
->loopback_pt
);
738 dev_put(net
->loopback_dev
);
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
)
746 struct nlattr
*attrs
;
749 hdr
= genlmsg_put(msg
->skb
, msg
->portid
, msg
->seq
, &tipc_genl_family
,
750 nlflags
, TIPC_NL_BEARER_GET
);
754 attrs
= nla_nest_start_noflag(msg
->skb
, TIPC_NLA_BEARER
);
758 if (nla_put_string(msg
->skb
, TIPC_NLA_BEARER_NAME
, bearer
->name
))
761 prop
= nla_nest_start_noflag(msg
->skb
, TIPC_NLA_BEARER_PROP
);
764 if (nla_put_u32(msg
->skb
, TIPC_NLA_PROP_PRIO
, bearer
->priority
))
766 if (nla_put_u32(msg
->skb
, TIPC_NLA_PROP_TOL
, bearer
->tolerance
))
768 if (nla_put_u32(msg
->skb
, TIPC_NLA_PROP_WIN
, bearer
->window
))
770 if (bearer
->media
->type_id
== TIPC_MEDIA_TYPE_UDP
)
771 if (nla_put_u32(msg
->skb
, TIPC_NLA_PROP_MTU
, bearer
->mtu
))
774 nla_nest_end(msg
->skb
, prop
);
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
))
783 nla_nest_end(msg
->skb
, attrs
);
784 genlmsg_end(msg
->skb
, hdr
);
789 nla_nest_cancel(msg
->skb
, prop
);
791 nla_nest_cancel(msg
->skb
, attrs
);
793 genlmsg_cancel(msg
->skb
, hdr
);
798 int tipc_nl_bearer_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
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
);
807 if (i
== MAX_BEARERS
)
811 msg
.portid
= NETLINK_CB(cb
->skb
).portid
;
812 msg
.seq
= cb
->nlh
->nlmsg_seq
;
815 for (i
= 0; i
< MAX_BEARERS
; i
++) {
816 bearer
= rtnl_dereference(tn
->bearer_list
[i
]);
820 err
= __tipc_nl_add_bearer(&msg
, bearer
, NLM_F_MULTI
);
830 int tipc_nl_bearer_get(struct sk_buff
*skb
, struct genl_info
*info
)
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
);
840 if (!info
->attrs
[TIPC_NLA_BEARER
])
843 err
= nla_parse_nested_deprecated(attrs
, TIPC_NLA_BEARER_MAX
,
844 info
->attrs
[TIPC_NLA_BEARER
],
845 tipc_nl_bearer_policy
, info
->extack
);
849 if (!attrs
[TIPC_NLA_BEARER_NAME
])
851 name
= nla_data(attrs
[TIPC_NLA_BEARER_NAME
]);
853 rep
= nlmsg_new(NLMSG_GOODSIZE
, GFP_KERNEL
);
858 msg
.portid
= info
->snd_portid
;
859 msg
.seq
= info
->snd_seq
;
862 bearer
= tipc_bearer_find(net
, name
);
868 err
= __tipc_nl_add_bearer(&msg
, bearer
, 0);
873 return genlmsg_reply(rep
, info
);
881 int __tipc_nl_bearer_disable(struct sk_buff
*skb
, struct genl_info
*info
)
885 struct tipc_bearer
*bearer
;
886 struct nlattr
*attrs
[TIPC_NLA_BEARER_MAX
+ 1];
887 struct net
*net
= sock_net(skb
->sk
);
889 if (!info
->attrs
[TIPC_NLA_BEARER
])
892 err
= nla_parse_nested_deprecated(attrs
, TIPC_NLA_BEARER_MAX
,
893 info
->attrs
[TIPC_NLA_BEARER
],
894 tipc_nl_bearer_policy
, info
->extack
);
898 if (!attrs
[TIPC_NLA_BEARER_NAME
])
901 name
= nla_data(attrs
[TIPC_NLA_BEARER_NAME
]);
903 bearer
= tipc_bearer_find(net
, name
);
907 bearer_disable(net
, bearer
);
912 int tipc_nl_bearer_disable(struct sk_buff
*skb
, struct genl_info
*info
)
917 err
= __tipc_nl_bearer_disable(skb
, info
);
923 int __tipc_nl_bearer_enable(struct sk_buff
*skb
, struct genl_info
*info
)
927 struct nlattr
*attrs
[TIPC_NLA_BEARER_MAX
+ 1];
928 struct net
*net
= sock_net(skb
->sk
);
932 prio
= TIPC_MEDIA_LINK_PRI
;
934 if (!info
->attrs
[TIPC_NLA_BEARER
])
937 err
= nla_parse_nested_deprecated(attrs
, TIPC_NLA_BEARER_MAX
,
938 info
->attrs
[TIPC_NLA_BEARER
],
939 tipc_nl_bearer_policy
, info
->extack
);
943 if (!attrs
[TIPC_NLA_BEARER_NAME
])
946 bearer
= nla_data(attrs
[TIPC_NLA_BEARER_NAME
]);
948 if (attrs
[TIPC_NLA_BEARER_DOMAIN
])
949 domain
= nla_get_u32(attrs
[TIPC_NLA_BEARER_DOMAIN
]);
951 if (attrs
[TIPC_NLA_BEARER_PROP
]) {
952 struct nlattr
*props
[TIPC_NLA_PROP_MAX
+ 1];
954 err
= tipc_nl_parse_link_prop(attrs
[TIPC_NLA_BEARER_PROP
],
959 if (props
[TIPC_NLA_PROP_PRIO
])
960 prio
= nla_get_u32(props
[TIPC_NLA_PROP_PRIO
]);
963 return tipc_enable_bearer(net
, bearer
, domain
, prio
, attrs
);
966 int tipc_nl_bearer_enable(struct sk_buff
*skb
, struct genl_info
*info
)
971 err
= __tipc_nl_bearer_enable(skb
, info
);
977 int tipc_nl_bearer_add(struct sk_buff
*skb
, struct genl_info
*info
)
981 struct tipc_bearer
*b
;
982 struct nlattr
*attrs
[TIPC_NLA_BEARER_MAX
+ 1];
983 struct net
*net
= sock_net(skb
->sk
);
985 if (!info
->attrs
[TIPC_NLA_BEARER
])
988 err
= nla_parse_nested_deprecated(attrs
, TIPC_NLA_BEARER_MAX
,
989 info
->attrs
[TIPC_NLA_BEARER
],
990 tipc_nl_bearer_policy
, info
->extack
);
994 if (!attrs
[TIPC_NLA_BEARER_NAME
])
996 name
= nla_data(attrs
[TIPC_NLA_BEARER_NAME
]);
999 b
= tipc_bearer_find(net
, name
);
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
]);
1020 int __tipc_nl_bearer_set(struct sk_buff
*skb
, struct genl_info
*info
)
1022 struct tipc_bearer
*b
;
1023 struct nlattr
*attrs
[TIPC_NLA_BEARER_MAX
+ 1];
1024 struct net
*net
= sock_net(skb
->sk
);
1028 if (!info
->attrs
[TIPC_NLA_BEARER
])
1031 err
= nla_parse_nested_deprecated(attrs
, TIPC_NLA_BEARER_MAX
,
1032 info
->attrs
[TIPC_NLA_BEARER
],
1033 tipc_nl_bearer_policy
, info
->extack
);
1037 if (!attrs
[TIPC_NLA_BEARER_NAME
])
1039 name
= nla_data(attrs
[TIPC_NLA_BEARER_NAME
]);
1041 b
= tipc_bearer_find(net
, name
);
1045 if (attrs
[TIPC_NLA_BEARER_PROP
]) {
1046 struct nlattr
*props
[TIPC_NLA_PROP_MAX
+ 1];
1048 err
= tipc_nl_parse_link_prop(attrs
[TIPC_NLA_BEARER_PROP
],
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
);
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
)
1064 #ifdef CONFIG_TIPC_MEDIA_UDP
1065 if (tipc_udp_mtu_bad(nla_get_u32
1066 (props
[TIPC_NLA_PROP_MTU
])))
1068 b
->mtu
= nla_get_u32(props
[TIPC_NLA_PROP_MTU
]);
1069 tipc_node_apply_property(net
, b
, TIPC_NLA_PROP_MTU
);
1077 int tipc_nl_bearer_set(struct sk_buff
*skb
, struct genl_info
*info
)
1082 err
= __tipc_nl_bearer_set(skb
, info
);
1088 static int __tipc_nl_add_media(struct tipc_nl_msg
*msg
,
1089 struct tipc_media
*media
, int nlflags
)
1092 struct nlattr
*attrs
;
1093 struct nlattr
*prop
;
1095 hdr
= genlmsg_put(msg
->skb
, msg
->portid
, msg
->seq
, &tipc_genl_family
,
1096 nlflags
, TIPC_NL_MEDIA_GET
);
1100 attrs
= nla_nest_start_noflag(msg
->skb
, TIPC_NLA_MEDIA
);
1104 if (nla_put_string(msg
->skb
, TIPC_NLA_MEDIA_NAME
, media
->name
))
1107 prop
= nla_nest_start_noflag(msg
->skb
, TIPC_NLA_MEDIA_PROP
);
1110 if (nla_put_u32(msg
->skb
, TIPC_NLA_PROP_PRIO
, media
->priority
))
1112 if (nla_put_u32(msg
->skb
, TIPC_NLA_PROP_TOL
, media
->tolerance
))
1114 if (nla_put_u32(msg
->skb
, TIPC_NLA_PROP_WIN
, media
->window
))
1116 if (media
->type_id
== TIPC_MEDIA_TYPE_UDP
)
1117 if (nla_put_u32(msg
->skb
, TIPC_NLA_PROP_MTU
, media
->mtu
))
1120 nla_nest_end(msg
->skb
, prop
);
1121 nla_nest_end(msg
->skb
, attrs
);
1122 genlmsg_end(msg
->skb
, hdr
);
1127 nla_nest_cancel(msg
->skb
, prop
);
1129 nla_nest_cancel(msg
->skb
, attrs
);
1131 genlmsg_cancel(msg
->skb
, hdr
);
1136 int tipc_nl_media_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1139 int i
= cb
->args
[0];
1140 struct tipc_nl_msg msg
;
1146 msg
.portid
= NETLINK_CB(cb
->skb
).portid
;
1147 msg
.seq
= cb
->nlh
->nlmsg_seq
;
1150 for (; media_info_array
[i
] != NULL
; i
++) {
1151 err
= __tipc_nl_add_media(&msg
, media_info_array
[i
],
1162 int tipc_nl_media_get(struct sk_buff
*skb
, struct genl_info
*info
)
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];
1171 if (!info
->attrs
[TIPC_NLA_MEDIA
])
1174 err
= nla_parse_nested_deprecated(attrs
, TIPC_NLA_MEDIA_MAX
,
1175 info
->attrs
[TIPC_NLA_MEDIA
],
1176 tipc_nl_media_policy
, info
->extack
);
1180 if (!attrs
[TIPC_NLA_MEDIA_NAME
])
1182 name
= nla_data(attrs
[TIPC_NLA_MEDIA_NAME
]);
1184 rep
= nlmsg_new(NLMSG_GOODSIZE
, GFP_KERNEL
);
1189 msg
.portid
= info
->snd_portid
;
1190 msg
.seq
= info
->snd_seq
;
1193 media
= tipc_media_find(name
);
1199 err
= __tipc_nl_add_media(&msg
, media
, 0);
1204 return genlmsg_reply(rep
, info
);
1212 int __tipc_nl_media_set(struct sk_buff
*skb
, struct genl_info
*info
)
1216 struct tipc_media
*m
;
1217 struct nlattr
*attrs
[TIPC_NLA_BEARER_MAX
+ 1];
1219 if (!info
->attrs
[TIPC_NLA_MEDIA
])
1222 err
= nla_parse_nested_deprecated(attrs
, TIPC_NLA_MEDIA_MAX
,
1223 info
->attrs
[TIPC_NLA_MEDIA
],
1224 tipc_nl_media_policy
, info
->extack
);
1226 if (!attrs
[TIPC_NLA_MEDIA_NAME
])
1228 name
= nla_data(attrs
[TIPC_NLA_MEDIA_NAME
]);
1230 m
= tipc_media_find(name
);
1234 if (attrs
[TIPC_NLA_MEDIA_PROP
]) {
1235 struct nlattr
*props
[TIPC_NLA_PROP_MAX
+ 1];
1237 err
= tipc_nl_parse_link_prop(attrs
[TIPC_NLA_MEDIA_PROP
],
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
)
1251 #ifdef CONFIG_TIPC_MEDIA_UDP
1252 if (tipc_udp_mtu_bad(nla_get_u32
1253 (props
[TIPC_NLA_PROP_MTU
])))
1255 m
->mtu
= nla_get_u32(props
[TIPC_NLA_PROP_MTU
]);
1263 int tipc_nl_media_set(struct sk_buff
*skb
, struct genl_info
*info
)
1268 err
= __tipc_nl_media_set(skb
, info
);