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.
46 #define MAX_ADDR_STR 60
48 static struct tipc_media
* const media_info_array
[] = {
50 #ifdef CONFIG_TIPC_MEDIA_IB
53 #ifdef CONFIG_TIPC_MEDIA_UDP
59 static void bearer_disable(struct net
*net
, struct tipc_bearer
*b
);
62 * tipc_media_find - locates specified media object by name
64 struct tipc_media
*tipc_media_find(const char *name
)
68 for (i
= 0; media_info_array
[i
] != NULL
; i
++) {
69 if (!strcmp(media_info_array
[i
]->name
, name
))
72 return media_info_array
[i
];
76 * media_find_id - locates specified media object by type identifier
78 static struct tipc_media
*media_find_id(u8 type
)
82 for (i
= 0; media_info_array
[i
] != NULL
; i
++) {
83 if (media_info_array
[i
]->type_id
== type
)
86 return media_info_array
[i
];
90 * tipc_media_addr_printf - record media address in print buffer
92 void tipc_media_addr_printf(char *buf
, int len
, struct tipc_media_addr
*a
)
94 char addr_str
[MAX_ADDR_STR
];
98 m
= media_find_id(a
->media_id
);
100 if (m
&& !m
->addr2str(a
, addr_str
, sizeof(addr_str
)))
101 ret
= scnprintf(buf
, len
, "%s(%s)", m
->name
, addr_str
);
105 ret
= scnprintf(buf
, len
, "UNKNOWN(%u)", a
->media_id
);
106 for (i
= 0; i
< sizeof(a
->value
); i
++)
107 ret
+= scnprintf(buf
- ret
, len
+ ret
,
108 "-%02x", a
->value
[i
]);
113 * bearer_name_validate - validate & (optionally) deconstruct bearer name
114 * @name: ptr to bearer name string
115 * @name_parts: ptr to area for bearer name components (or NULL if not needed)
117 * Returns 1 if bearer name is valid, otherwise 0.
119 static int bearer_name_validate(const char *name
,
120 struct tipc_bearer_names
*name_parts
)
122 char name_copy
[TIPC_MAX_BEARER_NAME
];
128 /* copy bearer name & ensure length is OK */
129 name_copy
[TIPC_MAX_BEARER_NAME
- 1] = 0;
130 /* need above in case non-Posix strncpy() doesn't pad with nulls */
131 strncpy(name_copy
, name
, TIPC_MAX_BEARER_NAME
);
132 if (name_copy
[TIPC_MAX_BEARER_NAME
- 1] != 0)
135 /* ensure all component parts of bearer name are present */
136 media_name
= name_copy
;
137 if_name
= strchr(media_name
, ':');
141 media_len
= if_name
- media_name
;
142 if_len
= strlen(if_name
) + 1;
144 /* validate component parts of bearer name */
145 if ((media_len
<= 1) || (media_len
> TIPC_MAX_MEDIA_NAME
) ||
146 (if_len
<= 1) || (if_len
> TIPC_MAX_IF_NAME
))
149 /* return bearer name components, if necessary */
151 strcpy(name_parts
->media_name
, media_name
);
152 strcpy(name_parts
->if_name
, if_name
);
158 * tipc_bearer_find - locates bearer object with matching bearer name
160 struct tipc_bearer
*tipc_bearer_find(struct net
*net
, const char *name
)
162 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
163 struct tipc_bearer
*b
;
166 for (i
= 0; i
< MAX_BEARERS
; i
++) {
167 b
= rtnl_dereference(tn
->bearer_list
[i
]);
168 if (b
&& (!strcmp(b
->name
, name
)))
174 void tipc_bearer_add_dest(struct net
*net
, u32 bearer_id
, u32 dest
)
176 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
177 struct tipc_bearer
*b
;
180 b
= rcu_dereference_rtnl(tn
->bearer_list
[bearer_id
]);
182 tipc_disc_add_dest(b
->link_req
);
186 void tipc_bearer_remove_dest(struct net
*net
, u32 bearer_id
, u32 dest
)
188 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
189 struct tipc_bearer
*b
;
192 b
= rcu_dereference_rtnl(tn
->bearer_list
[bearer_id
]);
194 tipc_disc_remove_dest(b
->link_req
);
199 * tipc_enable_bearer - enable bearer with the given name
201 static int tipc_enable_bearer(struct net
*net
, const char *name
,
202 u32 disc_domain
, u32 priority
,
203 struct nlattr
*attr
[])
205 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
206 struct tipc_bearer
*b
;
207 struct tipc_media
*m
;
208 struct tipc_bearer_names b_names
;
210 char addr_string
[16];
217 pr_warn("Bearer <%s> rejected, not supported in standalone mode\n",
221 if (!bearer_name_validate(name
, &b_names
)) {
222 pr_warn("Bearer <%s> rejected, illegal name\n", name
);
225 if (tipc_addr_domain_valid(disc_domain
) &&
226 (disc_domain
!= tn
->own_addr
)) {
227 if (tipc_in_scope(disc_domain
, tn
->own_addr
)) {
228 disc_domain
= tn
->own_addr
& TIPC_ZONE_CLUSTER_MASK
;
229 res
= 0; /* accept any node in own cluster */
230 } else if (in_own_cluster_exact(net
, disc_domain
))
231 res
= 0; /* accept specified node in own cluster */
234 pr_warn("Bearer <%s> rejected, illegal discovery domain\n",
238 if ((priority
> TIPC_MAX_LINK_PRI
) &&
239 (priority
!= TIPC_MEDIA_LINK_PRI
)) {
240 pr_warn("Bearer <%s> rejected, illegal priority\n", name
);
244 m
= tipc_media_find(b_names
.media_name
);
246 pr_warn("Bearer <%s> rejected, media <%s> not registered\n",
247 name
, b_names
.media_name
);
251 if (priority
== TIPC_MEDIA_LINK_PRI
)
252 priority
= m
->priority
;
255 bearer_id
= MAX_BEARERS
;
257 for (i
= MAX_BEARERS
; i
-- != 0; ) {
258 b
= rtnl_dereference(tn
->bearer_list
[i
]);
263 if (!strcmp(name
, b
->name
)) {
264 pr_warn("Bearer <%s> rejected, already enabled\n",
268 if ((b
->priority
== priority
) &&
269 (++with_this_prio
> 2)) {
270 if (priority
-- == 0) {
271 pr_warn("Bearer <%s> rejected, duplicate priority\n",
275 pr_warn("Bearer <%s> priority adjustment required %u->%u\n",
276 name
, priority
+ 1, priority
);
280 if (bearer_id
>= MAX_BEARERS
) {
281 pr_warn("Bearer <%s> rejected, bearer limit reached (%u)\n",
286 b
= kzalloc(sizeof(*b
), GFP_ATOMIC
);
290 strcpy(b
->name
, name
);
292 res
= m
->enable_media(net
, b
, attr
);
294 pr_warn("Bearer <%s> rejected, enable failure (%d)\n",
299 b
->identity
= bearer_id
;
300 b
->tolerance
= m
->tolerance
;
301 b
->window
= m
->window
;
302 b
->domain
= disc_domain
;
303 b
->net_plane
= bearer_id
+ 'A';
304 b
->priority
= priority
;
306 res
= tipc_disc_create(net
, b
, &b
->bcast_addr
, &skb
);
308 bearer_disable(net
, b
);
309 pr_warn("Bearer <%s> rejected, discovery object creation failed\n",
314 rcu_assign_pointer(tn
->bearer_list
[bearer_id
], b
);
316 tipc_bearer_xmit_skb(net
, bearer_id
, skb
, &b
->bcast_addr
);
318 if (tipc_mon_create(net
, bearer_id
))
321 pr_info("Enabled bearer <%s>, discovery domain %s, priority %u\n",
323 tipc_addr_string_fill(addr_string
, disc_domain
), priority
);
328 * tipc_reset_bearer - Reset all links established over this bearer
330 static int tipc_reset_bearer(struct net
*net
, struct tipc_bearer
*b
)
332 pr_info("Resetting bearer <%s>\n", b
->name
);
333 tipc_node_delete_links(net
, b
->identity
);
334 tipc_disc_reset(net
, b
);
338 /* tipc_bearer_reset_all - reset all links on all bearers
340 void tipc_bearer_reset_all(struct net
*net
)
342 struct tipc_net
*tn
= tipc_net(net
);
343 struct tipc_bearer
*b
;
346 for (i
= 0; i
< MAX_BEARERS
; i
++) {
347 b
= rcu_dereference_rtnl(tn
->bearer_list
[i
]);
349 tipc_reset_bearer(net
, b
);
356 * Note: This routine assumes caller holds RTNL lock.
358 static void bearer_disable(struct net
*net
, struct tipc_bearer
*b
)
360 struct tipc_net
*tn
= tipc_net(net
);
361 int bearer_id
= b
->identity
;
363 pr_info("Disabling bearer <%s>\n", b
->name
);
364 b
->media
->disable_media(b
);
365 tipc_node_delete_links(net
, bearer_id
);
366 RCU_INIT_POINTER(b
->media_ptr
, NULL
);
368 tipc_disc_delete(b
->link_req
);
369 RCU_INIT_POINTER(tn
->bearer_list
[bearer_id
], NULL
);
371 tipc_mon_delete(net
, bearer_id
);
374 int tipc_enable_l2_media(struct net
*net
, struct tipc_bearer
*b
,
375 struct nlattr
*attr
[])
377 struct net_device
*dev
;
378 char *driver_name
= strchr((const char *)b
->name
, ':') + 1;
380 /* Find device with specified name */
381 dev
= dev_get_by_name(net
, driver_name
);
385 /* Associate TIPC bearer with L2 bearer */
386 rcu_assign_pointer(b
->media_ptr
, dev
);
387 memset(&b
->bcast_addr
, 0, sizeof(b
->bcast_addr
));
388 memcpy(b
->bcast_addr
.value
, dev
->broadcast
, b
->media
->hwaddr_len
);
389 b
->bcast_addr
.media_id
= b
->media
->type_id
;
390 b
->bcast_addr
.broadcast
= 1;
392 b
->media
->raw2addr(b
, &b
->addr
, (char *)dev
->dev_addr
);
393 rcu_assign_pointer(dev
->tipc_ptr
, b
);
397 /* tipc_disable_l2_media - detach TIPC bearer from an L2 interface
399 * Mark L2 bearer as inactive so that incoming buffers are thrown away
401 void tipc_disable_l2_media(struct tipc_bearer
*b
)
403 struct net_device
*dev
;
405 dev
= (struct net_device
*)rtnl_dereference(b
->media_ptr
);
406 RCU_INIT_POINTER(dev
->tipc_ptr
, NULL
);
412 * tipc_l2_send_msg - send a TIPC packet out over an L2 interface
413 * @skb: the packet to be sent
414 * @b: the bearer through which the packet is to be sent
415 * @dest: peer destination address
417 int tipc_l2_send_msg(struct net
*net
, struct sk_buff
*skb
,
418 struct tipc_bearer
*b
, struct tipc_media_addr
*dest
)
420 struct net_device
*dev
;
424 dev
= (struct net_device
*)rcu_dereference_rtnl(b
->media_ptr
);
428 /* Send RESET message even if bearer is detached from device */
429 tipc_ptr
= rcu_dereference_rtnl(dev
->tipc_ptr
);
430 if (unlikely(!tipc_ptr
&& !msg_is_reset(buf_msg(skb
))))
433 delta
= dev
->hard_header_len
- skb_headroom(skb
);
435 pskb_expand_head(skb
, SKB_DATA_ALIGN(delta
), 0, GFP_ATOMIC
))
438 skb_reset_network_header(skb
);
440 skb
->protocol
= htons(ETH_P_TIPC
);
441 dev_hard_header(skb
, dev
, ETH_P_TIPC
, dest
->value
,
442 dev
->dev_addr
, skb
->len
);
450 int tipc_bearer_mtu(struct net
*net
, u32 bearer_id
)
453 struct tipc_bearer
*b
;
456 b
= rcu_dereference_rtnl(tipc_net(net
)->bearer_list
[bearer_id
]);
463 /* tipc_bearer_xmit_skb - sends buffer to destination over bearer
465 void tipc_bearer_xmit_skb(struct net
*net
, u32 bearer_id
,
467 struct tipc_media_addr
*dest
)
469 struct tipc_net
*tn
= tipc_net(net
);
470 struct tipc_bearer
*b
;
473 b
= rcu_dereference_rtnl(tn
->bearer_list
[bearer_id
]);
475 b
->media
->send_msg(net
, skb
, b
, dest
);
481 /* tipc_bearer_xmit() -send buffer to destination over bearer
483 void tipc_bearer_xmit(struct net
*net
, u32 bearer_id
,
484 struct sk_buff_head
*xmitq
,
485 struct tipc_media_addr
*dst
)
487 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
488 struct tipc_bearer
*b
;
489 struct sk_buff
*skb
, *tmp
;
491 if (skb_queue_empty(xmitq
))
495 b
= rcu_dereference_rtnl(tn
->bearer_list
[bearer_id
]);
497 __skb_queue_purge(xmitq
);
498 skb_queue_walk_safe(xmitq
, skb
, tmp
) {
499 __skb_dequeue(xmitq
);
500 b
->media
->send_msg(net
, skb
, b
, dst
);
505 /* tipc_bearer_bc_xmit() - broadcast buffers to all destinations
507 void tipc_bearer_bc_xmit(struct net
*net
, u32 bearer_id
,
508 struct sk_buff_head
*xmitq
)
510 struct tipc_net
*tn
= tipc_net(net
);
511 int net_id
= tn
->net_id
;
512 struct tipc_bearer
*b
;
513 struct sk_buff
*skb
, *tmp
;
514 struct tipc_msg
*hdr
;
517 b
= rcu_dereference_rtnl(tn
->bearer_list
[bearer_id
]);
519 __skb_queue_purge(xmitq
);
520 skb_queue_walk_safe(xmitq
, skb
, tmp
) {
522 msg_set_non_seq(hdr
, 1);
523 msg_set_mc_netid(hdr
, net_id
);
524 __skb_dequeue(xmitq
);
525 b
->media
->send_msg(net
, skb
, b
, &b
->bcast_addr
);
531 * tipc_l2_rcv_msg - handle incoming TIPC message from an interface
532 * @buf: the received packet
533 * @dev: the net device that the packet was received on
534 * @pt: the packet_type structure which was used to register this handler
535 * @orig_dev: the original receive net device in case the device is a bond
537 * Accept only packets explicitly sent to this node, or broadcast packets;
538 * ignores packets sent using interface multicast, and traffic sent to other
539 * nodes (which can happen if interface is running in promiscuous mode).
541 static int tipc_l2_rcv_msg(struct sk_buff
*skb
, struct net_device
*dev
,
542 struct packet_type
*pt
, struct net_device
*orig_dev
)
544 struct tipc_bearer
*b
;
547 b
= rcu_dereference_rtnl(dev
->tipc_ptr
);
548 if (likely(b
&& (skb
->pkt_type
<= PACKET_BROADCAST
))) {
550 tipc_rcv(dev_net(dev
), skb
, b
);
552 return NET_RX_SUCCESS
;
560 * tipc_l2_device_event - handle device events from network device
561 * @nb: the context of the notification
562 * @evt: the type of event
563 * @ptr: the net device that the event was on
565 * This function is called by the Ethernet driver in case of link
568 static int tipc_l2_device_event(struct notifier_block
*nb
, unsigned long evt
,
571 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
572 struct net
*net
= dev_net(dev
);
573 struct tipc_net
*tn
= tipc_net(net
);
574 struct tipc_bearer
*b
;
577 b
= rtnl_dereference(dev
->tipc_ptr
);
579 for (i
= 0; i
< MAX_BEARERS
; b
= NULL
, i
++) {
580 b
= rtnl_dereference(tn
->bearer_list
[i
]);
581 if (b
&& (b
->media_ptr
== dev
))
592 if (netif_carrier_ok(dev
))
595 rcu_assign_pointer(dev
->tipc_ptr
, b
);
597 case NETDEV_GOING_DOWN
:
598 RCU_INIT_POINTER(dev
->tipc_ptr
, NULL
);
600 tipc_reset_bearer(net
, b
);
602 case NETDEV_CHANGEMTU
:
603 tipc_reset_bearer(net
, b
);
605 case NETDEV_CHANGEADDR
:
606 b
->media
->raw2addr(b
, &b
->addr
,
607 (char *)dev
->dev_addr
);
608 tipc_reset_bearer(net
, b
);
610 case NETDEV_UNREGISTER
:
611 case NETDEV_CHANGENAME
:
612 bearer_disable(dev_net(dev
), b
);
618 static struct packet_type tipc_packet_type __read_mostly
= {
619 .type
= htons(ETH_P_TIPC
),
620 .func
= tipc_l2_rcv_msg
,
623 static struct notifier_block notifier
= {
624 .notifier_call
= tipc_l2_device_event
,
628 int tipc_bearer_setup(void)
632 err
= register_netdevice_notifier(¬ifier
);
635 dev_add_pack(&tipc_packet_type
);
639 void tipc_bearer_cleanup(void)
641 unregister_netdevice_notifier(¬ifier
);
642 dev_remove_pack(&tipc_packet_type
);
645 void tipc_bearer_stop(struct net
*net
)
647 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
648 struct tipc_bearer
*b
;
651 for (i
= 0; i
< MAX_BEARERS
; i
++) {
652 b
= rtnl_dereference(tn
->bearer_list
[i
]);
654 bearer_disable(net
, b
);
655 tn
->bearer_list
[i
] = NULL
;
660 /* Caller should hold rtnl_lock to protect the bearer */
661 static int __tipc_nl_add_bearer(struct tipc_nl_msg
*msg
,
662 struct tipc_bearer
*bearer
, int nlflags
)
665 struct nlattr
*attrs
;
668 hdr
= genlmsg_put(msg
->skb
, msg
->portid
, msg
->seq
, &tipc_genl_family
,
669 nlflags
, TIPC_NL_BEARER_GET
);
673 attrs
= nla_nest_start(msg
->skb
, TIPC_NLA_BEARER
);
677 if (nla_put_string(msg
->skb
, TIPC_NLA_BEARER_NAME
, bearer
->name
))
680 prop
= nla_nest_start(msg
->skb
, TIPC_NLA_BEARER_PROP
);
683 if (nla_put_u32(msg
->skb
, TIPC_NLA_PROP_PRIO
, bearer
->priority
))
685 if (nla_put_u32(msg
->skb
, TIPC_NLA_PROP_TOL
, bearer
->tolerance
))
687 if (nla_put_u32(msg
->skb
, TIPC_NLA_PROP_WIN
, bearer
->window
))
690 nla_nest_end(msg
->skb
, prop
);
691 nla_nest_end(msg
->skb
, attrs
);
692 genlmsg_end(msg
->skb
, hdr
);
697 nla_nest_cancel(msg
->skb
, prop
);
699 nla_nest_cancel(msg
->skb
, attrs
);
701 genlmsg_cancel(msg
->skb
, hdr
);
706 int tipc_nl_bearer_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
710 struct tipc_bearer
*bearer
;
711 struct tipc_nl_msg msg
;
712 struct net
*net
= sock_net(skb
->sk
);
713 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
715 if (i
== MAX_BEARERS
)
719 msg
.portid
= NETLINK_CB(cb
->skb
).portid
;
720 msg
.seq
= cb
->nlh
->nlmsg_seq
;
723 for (i
= 0; i
< MAX_BEARERS
; i
++) {
724 bearer
= rtnl_dereference(tn
->bearer_list
[i
]);
728 err
= __tipc_nl_add_bearer(&msg
, bearer
, NLM_F_MULTI
);
738 int tipc_nl_bearer_get(struct sk_buff
*skb
, struct genl_info
*info
)
743 struct tipc_bearer
*bearer
;
744 struct tipc_nl_msg msg
;
745 struct nlattr
*attrs
[TIPC_NLA_BEARER_MAX
+ 1];
746 struct net
*net
= genl_info_net(info
);
748 if (!info
->attrs
[TIPC_NLA_BEARER
])
751 err
= nla_parse_nested(attrs
, TIPC_NLA_BEARER_MAX
,
752 info
->attrs
[TIPC_NLA_BEARER
],
753 tipc_nl_bearer_policy
);
757 if (!attrs
[TIPC_NLA_BEARER_NAME
])
759 name
= nla_data(attrs
[TIPC_NLA_BEARER_NAME
]);
761 rep
= nlmsg_new(NLMSG_GOODSIZE
, GFP_KERNEL
);
766 msg
.portid
= info
->snd_portid
;
767 msg
.seq
= info
->snd_seq
;
770 bearer
= tipc_bearer_find(net
, name
);
776 err
= __tipc_nl_add_bearer(&msg
, bearer
, 0);
781 return genlmsg_reply(rep
, info
);
789 int tipc_nl_bearer_disable(struct sk_buff
*skb
, struct genl_info
*info
)
793 struct tipc_bearer
*bearer
;
794 struct nlattr
*attrs
[TIPC_NLA_BEARER_MAX
+ 1];
795 struct net
*net
= sock_net(skb
->sk
);
797 if (!info
->attrs
[TIPC_NLA_BEARER
])
800 err
= nla_parse_nested(attrs
, TIPC_NLA_BEARER_MAX
,
801 info
->attrs
[TIPC_NLA_BEARER
],
802 tipc_nl_bearer_policy
);
806 if (!attrs
[TIPC_NLA_BEARER_NAME
])
809 name
= nla_data(attrs
[TIPC_NLA_BEARER_NAME
]);
812 bearer
= tipc_bearer_find(net
, name
);
818 bearer_disable(net
, bearer
);
824 int tipc_nl_bearer_enable(struct sk_buff
*skb
, struct genl_info
*info
)
828 struct nlattr
*attrs
[TIPC_NLA_BEARER_MAX
+ 1];
829 struct net
*net
= sock_net(skb
->sk
);
830 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
834 prio
= TIPC_MEDIA_LINK_PRI
;
835 domain
= tn
->own_addr
& TIPC_ZONE_CLUSTER_MASK
;
837 if (!info
->attrs
[TIPC_NLA_BEARER
])
840 err
= nla_parse_nested(attrs
, TIPC_NLA_BEARER_MAX
,
841 info
->attrs
[TIPC_NLA_BEARER
],
842 tipc_nl_bearer_policy
);
846 if (!attrs
[TIPC_NLA_BEARER_NAME
])
849 bearer
= nla_data(attrs
[TIPC_NLA_BEARER_NAME
]);
851 if (attrs
[TIPC_NLA_BEARER_DOMAIN
])
852 domain
= nla_get_u32(attrs
[TIPC_NLA_BEARER_DOMAIN
]);
854 if (attrs
[TIPC_NLA_BEARER_PROP
]) {
855 struct nlattr
*props
[TIPC_NLA_PROP_MAX
+ 1];
857 err
= tipc_nl_parse_link_prop(attrs
[TIPC_NLA_BEARER_PROP
],
862 if (props
[TIPC_NLA_PROP_PRIO
])
863 prio
= nla_get_u32(props
[TIPC_NLA_PROP_PRIO
]);
867 err
= tipc_enable_bearer(net
, bearer
, domain
, prio
, attrs
);
877 int tipc_nl_bearer_set(struct sk_buff
*skb
, struct genl_info
*info
)
881 struct tipc_bearer
*b
;
882 struct nlattr
*attrs
[TIPC_NLA_BEARER_MAX
+ 1];
883 struct net
*net
= sock_net(skb
->sk
);
885 if (!info
->attrs
[TIPC_NLA_BEARER
])
888 err
= nla_parse_nested(attrs
, TIPC_NLA_BEARER_MAX
,
889 info
->attrs
[TIPC_NLA_BEARER
],
890 tipc_nl_bearer_policy
);
894 if (!attrs
[TIPC_NLA_BEARER_NAME
])
896 name
= nla_data(attrs
[TIPC_NLA_BEARER_NAME
]);
899 b
= tipc_bearer_find(net
, name
);
905 if (attrs
[TIPC_NLA_BEARER_PROP
]) {
906 struct nlattr
*props
[TIPC_NLA_PROP_MAX
+ 1];
908 err
= tipc_nl_parse_link_prop(attrs
[TIPC_NLA_BEARER_PROP
],
915 if (props
[TIPC_NLA_PROP_TOL
])
916 b
->tolerance
= nla_get_u32(props
[TIPC_NLA_PROP_TOL
]);
917 if (props
[TIPC_NLA_PROP_PRIO
])
918 b
->priority
= nla_get_u32(props
[TIPC_NLA_PROP_PRIO
]);
919 if (props
[TIPC_NLA_PROP_WIN
])
920 b
->window
= nla_get_u32(props
[TIPC_NLA_PROP_WIN
]);
927 static int __tipc_nl_add_media(struct tipc_nl_msg
*msg
,
928 struct tipc_media
*media
, int nlflags
)
931 struct nlattr
*attrs
;
934 hdr
= genlmsg_put(msg
->skb
, msg
->portid
, msg
->seq
, &tipc_genl_family
,
935 nlflags
, TIPC_NL_MEDIA_GET
);
939 attrs
= nla_nest_start(msg
->skb
, TIPC_NLA_MEDIA
);
943 if (nla_put_string(msg
->skb
, TIPC_NLA_MEDIA_NAME
, media
->name
))
946 prop
= nla_nest_start(msg
->skb
, TIPC_NLA_MEDIA_PROP
);
949 if (nla_put_u32(msg
->skb
, TIPC_NLA_PROP_PRIO
, media
->priority
))
951 if (nla_put_u32(msg
->skb
, TIPC_NLA_PROP_TOL
, media
->tolerance
))
953 if (nla_put_u32(msg
->skb
, TIPC_NLA_PROP_WIN
, media
->window
))
956 nla_nest_end(msg
->skb
, prop
);
957 nla_nest_end(msg
->skb
, attrs
);
958 genlmsg_end(msg
->skb
, hdr
);
963 nla_nest_cancel(msg
->skb
, prop
);
965 nla_nest_cancel(msg
->skb
, attrs
);
967 genlmsg_cancel(msg
->skb
, hdr
);
972 int tipc_nl_media_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
976 struct tipc_nl_msg msg
;
982 msg
.portid
= NETLINK_CB(cb
->skb
).portid
;
983 msg
.seq
= cb
->nlh
->nlmsg_seq
;
986 for (; media_info_array
[i
] != NULL
; i
++) {
987 err
= __tipc_nl_add_media(&msg
, media_info_array
[i
],
998 int tipc_nl_media_get(struct sk_buff
*skb
, struct genl_info
*info
)
1002 struct tipc_nl_msg msg
;
1003 struct tipc_media
*media
;
1004 struct sk_buff
*rep
;
1005 struct nlattr
*attrs
[TIPC_NLA_BEARER_MAX
+ 1];
1007 if (!info
->attrs
[TIPC_NLA_MEDIA
])
1010 err
= nla_parse_nested(attrs
, TIPC_NLA_MEDIA_MAX
,
1011 info
->attrs
[TIPC_NLA_MEDIA
],
1012 tipc_nl_media_policy
);
1016 if (!attrs
[TIPC_NLA_MEDIA_NAME
])
1018 name
= nla_data(attrs
[TIPC_NLA_MEDIA_NAME
]);
1020 rep
= nlmsg_new(NLMSG_GOODSIZE
, GFP_KERNEL
);
1025 msg
.portid
= info
->snd_portid
;
1026 msg
.seq
= info
->snd_seq
;
1029 media
= tipc_media_find(name
);
1035 err
= __tipc_nl_add_media(&msg
, media
, 0);
1040 return genlmsg_reply(rep
, info
);
1048 int tipc_nl_media_set(struct sk_buff
*skb
, struct genl_info
*info
)
1052 struct tipc_media
*m
;
1053 struct nlattr
*attrs
[TIPC_NLA_BEARER_MAX
+ 1];
1055 if (!info
->attrs
[TIPC_NLA_MEDIA
])
1058 err
= nla_parse_nested(attrs
, TIPC_NLA_MEDIA_MAX
,
1059 info
->attrs
[TIPC_NLA_MEDIA
],
1060 tipc_nl_media_policy
);
1062 if (!attrs
[TIPC_NLA_MEDIA_NAME
])
1064 name
= nla_data(attrs
[TIPC_NLA_MEDIA_NAME
]);
1067 m
= tipc_media_find(name
);
1073 if (attrs
[TIPC_NLA_MEDIA_PROP
]) {
1074 struct nlattr
*props
[TIPC_NLA_PROP_MAX
+ 1];
1076 err
= tipc_nl_parse_link_prop(attrs
[TIPC_NLA_MEDIA_PROP
],
1083 if (props
[TIPC_NLA_PROP_TOL
])
1084 m
->tolerance
= nla_get_u32(props
[TIPC_NLA_PROP_TOL
]);
1085 if (props
[TIPC_NLA_PROP_PRIO
])
1086 m
->priority
= nla_get_u32(props
[TIPC_NLA_PROP_PRIO
]);
1087 if (props
[TIPC_NLA_PROP_WIN
])
1088 m
->window
= nla_get_u32(props
[TIPC_NLA_PROP_WIN
]);