2 * net/tipc/bearer.c: TIPC bearer code
4 * Copyright (c) 1996-2006, 2013-2014, 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.
44 #define MAX_ADDR_STR 60
46 static struct tipc_media
* const media_info_array
[] = {
48 #ifdef CONFIG_TIPC_MEDIA_IB
54 static const struct nla_policy
55 tipc_nl_bearer_policy
[TIPC_NLA_BEARER_MAX
+ 1] = {
56 [TIPC_NLA_BEARER_UNSPEC
] = { .type
= NLA_UNSPEC
},
57 [TIPC_NLA_BEARER_NAME
] = {
59 .len
= TIPC_MAX_BEARER_NAME
61 [TIPC_NLA_BEARER_PROP
] = { .type
= NLA_NESTED
},
62 [TIPC_NLA_BEARER_DOMAIN
] = { .type
= NLA_U32
}
65 static const struct nla_policy tipc_nl_media_policy
[TIPC_NLA_MEDIA_MAX
+ 1] = {
66 [TIPC_NLA_MEDIA_UNSPEC
] = { .type
= NLA_UNSPEC
},
67 [TIPC_NLA_MEDIA_NAME
] = { .type
= NLA_STRING
},
68 [TIPC_NLA_MEDIA_PROP
] = { .type
= NLA_NESTED
}
71 static void bearer_disable(struct net
*net
, struct tipc_bearer
*b_ptr
,
75 * tipc_media_find - locates specified media object by name
77 struct tipc_media
*tipc_media_find(const char *name
)
81 for (i
= 0; media_info_array
[i
] != NULL
; i
++) {
82 if (!strcmp(media_info_array
[i
]->name
, name
))
85 return media_info_array
[i
];
89 * media_find_id - locates specified media object by type identifier
91 static struct tipc_media
*media_find_id(u8 type
)
95 for (i
= 0; media_info_array
[i
] != NULL
; i
++) {
96 if (media_info_array
[i
]->type_id
== type
)
99 return media_info_array
[i
];
103 * tipc_media_addr_printf - record media address in print buffer
105 void tipc_media_addr_printf(char *buf
, int len
, struct tipc_media_addr
*a
)
107 char addr_str
[MAX_ADDR_STR
];
108 struct tipc_media
*m_ptr
;
111 m_ptr
= media_find_id(a
->media_id
);
113 if (m_ptr
&& !m_ptr
->addr2str(a
, addr_str
, sizeof(addr_str
)))
114 ret
= tipc_snprintf(buf
, len
, "%s(%s)", m_ptr
->name
, addr_str
);
118 ret
= tipc_snprintf(buf
, len
, "UNKNOWN(%u)", a
->media_id
);
119 for (i
= 0; i
< sizeof(a
->value
); i
++)
120 ret
+= tipc_snprintf(buf
- ret
, len
+ ret
,
121 "-%02x", a
->value
[i
]);
126 * tipc_media_get_names - record names of registered media in buffer
128 struct sk_buff
*tipc_media_get_names(void)
133 buf
= tipc_cfg_reply_alloc(MAX_MEDIA
* TLV_SPACE(TIPC_MAX_MEDIA_NAME
));
137 for (i
= 0; media_info_array
[i
] != NULL
; i
++) {
138 tipc_cfg_append_tlv(buf
, TIPC_TLV_MEDIA_NAME
,
139 media_info_array
[i
]->name
,
140 strlen(media_info_array
[i
]->name
) + 1);
146 * bearer_name_validate - validate & (optionally) deconstruct bearer name
147 * @name: ptr to bearer name string
148 * @name_parts: ptr to area for bearer name components (or NULL if not needed)
150 * Returns 1 if bearer name is valid, otherwise 0.
152 static int bearer_name_validate(const char *name
,
153 struct tipc_bearer_names
*name_parts
)
155 char name_copy
[TIPC_MAX_BEARER_NAME
];
161 /* copy bearer name & ensure length is OK */
162 name_copy
[TIPC_MAX_BEARER_NAME
- 1] = 0;
163 /* need above in case non-Posix strncpy() doesn't pad with nulls */
164 strncpy(name_copy
, name
, TIPC_MAX_BEARER_NAME
);
165 if (name_copy
[TIPC_MAX_BEARER_NAME
- 1] != 0)
168 /* ensure all component parts of bearer name are present */
169 media_name
= name_copy
;
170 if_name
= strchr(media_name
, ':');
174 media_len
= if_name
- media_name
;
175 if_len
= strlen(if_name
) + 1;
177 /* validate component parts of bearer name */
178 if ((media_len
<= 1) || (media_len
> TIPC_MAX_MEDIA_NAME
) ||
179 (if_len
<= 1) || (if_len
> TIPC_MAX_IF_NAME
))
182 /* return bearer name components, if necessary */
184 strcpy(name_parts
->media_name
, media_name
);
185 strcpy(name_parts
->if_name
, if_name
);
191 * tipc_bearer_find - locates bearer object with matching bearer name
193 struct tipc_bearer
*tipc_bearer_find(struct net
*net
, const char *name
)
195 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
196 struct tipc_bearer
*b_ptr
;
199 for (i
= 0; i
< MAX_BEARERS
; i
++) {
200 b_ptr
= rtnl_dereference(tn
->bearer_list
[i
]);
201 if (b_ptr
&& (!strcmp(b_ptr
->name
, name
)))
208 * tipc_bearer_get_names - record names of bearers in buffer
210 struct sk_buff
*tipc_bearer_get_names(struct net
*net
)
212 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
214 struct tipc_bearer
*b
;
217 buf
= tipc_cfg_reply_alloc(MAX_BEARERS
* TLV_SPACE(TIPC_MAX_BEARER_NAME
));
221 for (i
= 0; media_info_array
[i
] != NULL
; i
++) {
222 for (j
= 0; j
< MAX_BEARERS
; j
++) {
223 b
= rtnl_dereference(tn
->bearer_list
[j
]);
226 if (b
->media
== media_info_array
[i
]) {
227 tipc_cfg_append_tlv(buf
, TIPC_TLV_BEARER_NAME
,
229 strlen(b
->name
) + 1);
236 void tipc_bearer_add_dest(struct net
*net
, u32 bearer_id
, u32 dest
)
238 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
239 struct tipc_bearer
*b_ptr
;
242 b_ptr
= rcu_dereference_rtnl(tn
->bearer_list
[bearer_id
]);
244 tipc_bcbearer_sort(net
, &b_ptr
->nodes
, dest
, true);
245 tipc_disc_add_dest(b_ptr
->link_req
);
250 void tipc_bearer_remove_dest(struct net
*net
, u32 bearer_id
, u32 dest
)
252 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
253 struct tipc_bearer
*b_ptr
;
256 b_ptr
= rcu_dereference_rtnl(tn
->bearer_list
[bearer_id
]);
258 tipc_bcbearer_sort(net
, &b_ptr
->nodes
, dest
, false);
259 tipc_disc_remove_dest(b_ptr
->link_req
);
265 * tipc_enable_bearer - enable bearer with the given name
267 int tipc_enable_bearer(struct net
*net
, const char *name
, u32 disc_domain
,
270 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
271 struct tipc_bearer
*b_ptr
;
272 struct tipc_media
*m_ptr
;
273 struct tipc_bearer_names b_names
;
274 char addr_string
[16];
280 if (!tipc_own_addr
) {
281 pr_warn("Bearer <%s> rejected, not supported in standalone mode\n",
285 if (!bearer_name_validate(name
, &b_names
)) {
286 pr_warn("Bearer <%s> rejected, illegal name\n", name
);
289 if (tipc_addr_domain_valid(disc_domain
) &&
290 (disc_domain
!= tipc_own_addr
)) {
291 if (tipc_in_scope(disc_domain
, tipc_own_addr
)) {
292 disc_domain
= tipc_own_addr
& TIPC_CLUSTER_MASK
;
293 res
= 0; /* accept any node in own cluster */
294 } else if (in_own_cluster_exact(disc_domain
))
295 res
= 0; /* accept specified node in own cluster */
298 pr_warn("Bearer <%s> rejected, illegal discovery domain\n",
302 if ((priority
> TIPC_MAX_LINK_PRI
) &&
303 (priority
!= TIPC_MEDIA_LINK_PRI
)) {
304 pr_warn("Bearer <%s> rejected, illegal priority\n", name
);
308 m_ptr
= tipc_media_find(b_names
.media_name
);
310 pr_warn("Bearer <%s> rejected, media <%s> not registered\n",
311 name
, b_names
.media_name
);
315 if (priority
== TIPC_MEDIA_LINK_PRI
)
316 priority
= m_ptr
->priority
;
319 bearer_id
= MAX_BEARERS
;
321 for (i
= MAX_BEARERS
; i
-- != 0; ) {
322 b_ptr
= rtnl_dereference(tn
->bearer_list
[i
]);
327 if (!strcmp(name
, b_ptr
->name
)) {
328 pr_warn("Bearer <%s> rejected, already enabled\n",
332 if ((b_ptr
->priority
== priority
) &&
333 (++with_this_prio
> 2)) {
334 if (priority
-- == 0) {
335 pr_warn("Bearer <%s> rejected, duplicate priority\n",
339 pr_warn("Bearer <%s> priority adjustment required %u->%u\n",
340 name
, priority
+ 1, priority
);
344 if (bearer_id
>= MAX_BEARERS
) {
345 pr_warn("Bearer <%s> rejected, bearer limit reached (%u)\n",
350 b_ptr
= kzalloc(sizeof(*b_ptr
), GFP_ATOMIC
);
354 strcpy(b_ptr
->name
, name
);
355 b_ptr
->media
= m_ptr
;
356 res
= m_ptr
->enable_media(net
, b_ptr
);
358 pr_warn("Bearer <%s> rejected, enable failure (%d)\n",
363 b_ptr
->identity
= bearer_id
;
364 b_ptr
->tolerance
= m_ptr
->tolerance
;
365 b_ptr
->window
= m_ptr
->window
;
366 b_ptr
->domain
= disc_domain
;
367 b_ptr
->net_plane
= bearer_id
+ 'A';
368 b_ptr
->priority
= priority
;
370 res
= tipc_disc_create(net
, b_ptr
, &b_ptr
->bcast_addr
);
372 bearer_disable(net
, b_ptr
, false);
373 pr_warn("Bearer <%s> rejected, discovery object creation failed\n",
378 rcu_assign_pointer(tn
->bearer_list
[bearer_id
], b_ptr
);
380 pr_info("Enabled bearer <%s>, discovery domain %s, priority %u\n",
382 tipc_addr_string_fill(addr_string
, disc_domain
), priority
);
387 * tipc_reset_bearer - Reset all links established over this bearer
389 static int tipc_reset_bearer(struct net
*net
, struct tipc_bearer
*b_ptr
)
391 pr_info("Resetting bearer <%s>\n", b_ptr
->name
);
392 tipc_link_reset_list(net
, b_ptr
->identity
);
393 tipc_disc_reset(net
, b_ptr
);
400 * Note: This routine assumes caller holds RTNL lock.
402 static void bearer_disable(struct net
*net
, struct tipc_bearer
*b_ptr
,
405 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
408 pr_info("Disabling bearer <%s>\n", b_ptr
->name
);
409 b_ptr
->media
->disable_media(b_ptr
);
411 tipc_link_delete_list(net
, b_ptr
->identity
, shutting_down
);
413 tipc_disc_delete(b_ptr
->link_req
);
415 for (i
= 0; i
< MAX_BEARERS
; i
++) {
416 if (b_ptr
== rtnl_dereference(tn
->bearer_list
[i
])) {
417 RCU_INIT_POINTER(tn
->bearer_list
[i
], NULL
);
421 kfree_rcu(b_ptr
, rcu
);
424 int tipc_disable_bearer(struct net
*net
, const char *name
)
426 struct tipc_bearer
*b_ptr
;
429 b_ptr
= tipc_bearer_find(net
, name
);
431 pr_warn("Attempt to disable unknown bearer <%s>\n", name
);
434 bearer_disable(net
, b_ptr
, false);
440 int tipc_enable_l2_media(struct net
*net
, struct tipc_bearer
*b
)
442 struct net_device
*dev
;
443 char *driver_name
= strchr((const char *)b
->name
, ':') + 1;
445 /* Find device with specified name */
446 dev
= dev_get_by_name(net
, driver_name
);
450 /* Associate TIPC bearer with L2 bearer */
451 rcu_assign_pointer(b
->media_ptr
, dev
);
452 memset(&b
->bcast_addr
, 0, sizeof(b
->bcast_addr
));
453 memcpy(b
->bcast_addr
.value
, dev
->broadcast
, b
->media
->hwaddr_len
);
454 b
->bcast_addr
.media_id
= b
->media
->type_id
;
455 b
->bcast_addr
.broadcast
= 1;
457 b
->media
->raw2addr(b
, &b
->addr
, (char *)dev
->dev_addr
);
458 rcu_assign_pointer(dev
->tipc_ptr
, b
);
462 /* tipc_disable_l2_media - detach TIPC bearer from an L2 interface
464 * Mark L2 bearer as inactive so that incoming buffers are thrown away,
465 * then get worker thread to complete bearer cleanup. (Can't do cleanup
466 * here because cleanup code needs to sleep and caller holds spinlocks.)
468 void tipc_disable_l2_media(struct tipc_bearer
*b
)
470 struct net_device
*dev
;
472 dev
= (struct net_device
*)rtnl_dereference(b
->media_ptr
);
473 RCU_INIT_POINTER(b
->media_ptr
, NULL
);
474 RCU_INIT_POINTER(dev
->tipc_ptr
, NULL
);
480 * tipc_l2_send_msg - send a TIPC packet out over an L2 interface
481 * @buf: the packet to be sent
482 * @b_ptr: the bearer through which the packet is to be sent
483 * @dest: peer destination address
485 int tipc_l2_send_msg(struct sk_buff
*buf
, struct tipc_bearer
*b
,
486 struct tipc_media_addr
*dest
)
488 struct sk_buff
*clone
;
489 struct net_device
*dev
;
492 dev
= (struct net_device
*)rcu_dereference_rtnl(b
->media_ptr
);
496 clone
= skb_clone(buf
, GFP_ATOMIC
);
500 delta
= dev
->hard_header_len
- skb_headroom(buf
);
502 pskb_expand_head(clone
, SKB_DATA_ALIGN(delta
), 0, GFP_ATOMIC
)) {
507 skb_reset_network_header(clone
);
509 clone
->protocol
= htons(ETH_P_TIPC
);
510 dev_hard_header(clone
, dev
, ETH_P_TIPC
, dest
->value
,
511 dev
->dev_addr
, clone
->len
);
512 dev_queue_xmit(clone
);
516 /* tipc_bearer_send- sends buffer to destination over bearer
519 * The media send routine must not alter the buffer being passed in
520 * as it may be needed for later retransmission!
522 void tipc_bearer_send(struct net
*net
, u32 bearer_id
, struct sk_buff
*buf
,
523 struct tipc_media_addr
*dest
)
525 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
526 struct tipc_bearer
*b_ptr
;
529 b_ptr
= rcu_dereference_rtnl(tn
->bearer_list
[bearer_id
]);
531 b_ptr
->media
->send_msg(buf
, b_ptr
, dest
);
536 * tipc_l2_rcv_msg - handle incoming TIPC message from an interface
537 * @buf: the received packet
538 * @dev: the net device that the packet was received on
539 * @pt: the packet_type structure which was used to register this handler
540 * @orig_dev: the original receive net device in case the device is a bond
542 * Accept only packets explicitly sent to this node, or broadcast packets;
543 * ignores packets sent using interface multicast, and traffic sent to other
544 * nodes (which can happen if interface is running in promiscuous mode).
546 static int tipc_l2_rcv_msg(struct sk_buff
*buf
, struct net_device
*dev
,
547 struct packet_type
*pt
, struct net_device
*orig_dev
)
549 struct tipc_bearer
*b_ptr
;
552 b_ptr
= rcu_dereference_rtnl(dev
->tipc_ptr
);
554 if (likely(buf
->pkt_type
<= PACKET_BROADCAST
)) {
556 tipc_rcv(dev_net(dev
), buf
, b_ptr
);
558 return NET_RX_SUCCESS
;
568 * tipc_l2_device_event - handle device events from network device
569 * @nb: the context of the notification
570 * @evt: the type of event
571 * @ptr: the net device that the event was on
573 * This function is called by the Ethernet driver in case of link
576 static int tipc_l2_device_event(struct notifier_block
*nb
, unsigned long evt
,
579 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
580 struct net
*net
= dev_net(dev
);
581 struct tipc_bearer
*b_ptr
;
583 b_ptr
= rtnl_dereference(dev
->tipc_ptr
);
587 b_ptr
->mtu
= dev
->mtu
;
591 if (netif_carrier_ok(dev
))
594 case NETDEV_CHANGEMTU
:
595 tipc_reset_bearer(net
, b_ptr
);
597 case NETDEV_CHANGEADDR
:
598 b_ptr
->media
->raw2addr(b_ptr
, &b_ptr
->addr
,
599 (char *)dev
->dev_addr
);
600 tipc_reset_bearer(net
, b_ptr
);
602 case NETDEV_UNREGISTER
:
603 case NETDEV_CHANGENAME
:
604 bearer_disable(dev_net(dev
), b_ptr
, false);
610 static struct packet_type tipc_packet_type __read_mostly
= {
611 .type
= htons(ETH_P_TIPC
),
612 .func
= tipc_l2_rcv_msg
,
615 static struct notifier_block notifier
= {
616 .notifier_call
= tipc_l2_device_event
,
620 int tipc_bearer_setup(void)
624 err
= register_netdevice_notifier(¬ifier
);
627 dev_add_pack(&tipc_packet_type
);
631 void tipc_bearer_cleanup(void)
633 unregister_netdevice_notifier(¬ifier
);
634 dev_remove_pack(&tipc_packet_type
);
637 void tipc_bearer_stop(struct net
*net
)
639 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
640 struct tipc_bearer
*b_ptr
;
643 for (i
= 0; i
< MAX_BEARERS
; i
++) {
644 b_ptr
= rtnl_dereference(tn
->bearer_list
[i
]);
646 bearer_disable(net
, b_ptr
, true);
647 tn
->bearer_list
[i
] = NULL
;
652 /* Caller should hold rtnl_lock to protect the bearer */
653 static int __tipc_nl_add_bearer(struct tipc_nl_msg
*msg
,
654 struct tipc_bearer
*bearer
)
657 struct nlattr
*attrs
;
660 hdr
= genlmsg_put(msg
->skb
, msg
->portid
, msg
->seq
, &tipc_genl_v2_family
,
661 NLM_F_MULTI
, TIPC_NL_BEARER_GET
);
665 attrs
= nla_nest_start(msg
->skb
, TIPC_NLA_BEARER
);
669 if (nla_put_string(msg
->skb
, TIPC_NLA_BEARER_NAME
, bearer
->name
))
672 prop
= nla_nest_start(msg
->skb
, TIPC_NLA_BEARER_PROP
);
675 if (nla_put_u32(msg
->skb
, TIPC_NLA_PROP_PRIO
, bearer
->priority
))
677 if (nla_put_u32(msg
->skb
, TIPC_NLA_PROP_TOL
, bearer
->tolerance
))
679 if (nla_put_u32(msg
->skb
, TIPC_NLA_PROP_WIN
, bearer
->window
))
682 nla_nest_end(msg
->skb
, prop
);
683 nla_nest_end(msg
->skb
, attrs
);
684 genlmsg_end(msg
->skb
, hdr
);
689 nla_nest_cancel(msg
->skb
, prop
);
691 nla_nest_cancel(msg
->skb
, attrs
);
693 genlmsg_cancel(msg
->skb
, hdr
);
698 int tipc_nl_bearer_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
702 struct tipc_bearer
*bearer
;
703 struct tipc_nl_msg msg
;
704 struct net
*net
= sock_net(skb
->sk
);
705 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
707 if (i
== MAX_BEARERS
)
711 msg
.portid
= NETLINK_CB(cb
->skb
).portid
;
712 msg
.seq
= cb
->nlh
->nlmsg_seq
;
715 for (i
= 0; i
< MAX_BEARERS
; i
++) {
716 bearer
= rtnl_dereference(tn
->bearer_list
[i
]);
720 err
= __tipc_nl_add_bearer(&msg
, bearer
);
730 int tipc_nl_bearer_get(struct sk_buff
*skb
, struct genl_info
*info
)
735 struct tipc_bearer
*bearer
;
736 struct tipc_nl_msg msg
;
737 struct nlattr
*attrs
[TIPC_NLA_BEARER_MAX
+ 1];
738 struct net
*net
= genl_info_net(info
);
740 if (!info
->attrs
[TIPC_NLA_BEARER
])
743 err
= nla_parse_nested(attrs
, TIPC_NLA_BEARER_MAX
,
744 info
->attrs
[TIPC_NLA_BEARER
],
745 tipc_nl_bearer_policy
);
749 if (!attrs
[TIPC_NLA_BEARER_NAME
])
751 name
= nla_data(attrs
[TIPC_NLA_BEARER_NAME
]);
753 rep
= nlmsg_new(NLMSG_GOODSIZE
, GFP_KERNEL
);
758 msg
.portid
= info
->snd_portid
;
759 msg
.seq
= info
->snd_seq
;
762 bearer
= tipc_bearer_find(net
, name
);
768 err
= __tipc_nl_add_bearer(&msg
, bearer
);
773 return genlmsg_reply(rep
, info
);
781 int tipc_nl_bearer_disable(struct sk_buff
*skb
, struct genl_info
*info
)
785 struct tipc_bearer
*bearer
;
786 struct nlattr
*attrs
[TIPC_NLA_BEARER_MAX
+ 1];
787 struct net
*net
= genl_info_net(info
);
789 if (!info
->attrs
[TIPC_NLA_BEARER
])
792 err
= nla_parse_nested(attrs
, TIPC_NLA_BEARER_MAX
,
793 info
->attrs
[TIPC_NLA_BEARER
],
794 tipc_nl_bearer_policy
);
798 if (!attrs
[TIPC_NLA_BEARER_NAME
])
801 name
= nla_data(attrs
[TIPC_NLA_BEARER_NAME
]);
804 bearer
= tipc_bearer_find(net
, name
);
810 bearer_disable(net
, bearer
, false);
816 int tipc_nl_bearer_enable(struct sk_buff
*skb
, struct genl_info
*info
)
818 struct net
*net
= genl_info_net(info
);
821 struct nlattr
*attrs
[TIPC_NLA_BEARER_MAX
+ 1];
825 prio
= TIPC_MEDIA_LINK_PRI
;
826 domain
= tipc_own_addr
& TIPC_CLUSTER_MASK
;
828 if (!info
->attrs
[TIPC_NLA_BEARER
])
831 err
= nla_parse_nested(attrs
, TIPC_NLA_BEARER_MAX
,
832 info
->attrs
[TIPC_NLA_BEARER
],
833 tipc_nl_bearer_policy
);
837 if (!attrs
[TIPC_NLA_BEARER_NAME
])
840 bearer
= nla_data(attrs
[TIPC_NLA_BEARER_NAME
]);
842 if (attrs
[TIPC_NLA_BEARER_DOMAIN
])
843 domain
= nla_get_u32(attrs
[TIPC_NLA_BEARER_DOMAIN
]);
845 if (attrs
[TIPC_NLA_BEARER_PROP
]) {
846 struct nlattr
*props
[TIPC_NLA_PROP_MAX
+ 1];
848 err
= tipc_nl_parse_link_prop(attrs
[TIPC_NLA_BEARER_PROP
],
853 if (props
[TIPC_NLA_PROP_PRIO
])
854 prio
= nla_get_u32(props
[TIPC_NLA_PROP_PRIO
]);
858 err
= tipc_enable_bearer(net
, bearer
, domain
, prio
);
868 int tipc_nl_bearer_set(struct sk_buff
*skb
, struct genl_info
*info
)
872 struct tipc_bearer
*b
;
873 struct nlattr
*attrs
[TIPC_NLA_BEARER_MAX
+ 1];
874 struct net
*net
= genl_info_net(info
);
876 if (!info
->attrs
[TIPC_NLA_BEARER
])
879 err
= nla_parse_nested(attrs
, TIPC_NLA_BEARER_MAX
,
880 info
->attrs
[TIPC_NLA_BEARER
],
881 tipc_nl_bearer_policy
);
885 if (!attrs
[TIPC_NLA_BEARER_NAME
])
887 name
= nla_data(attrs
[TIPC_NLA_BEARER_NAME
]);
890 b
= tipc_bearer_find(net
, name
);
896 if (attrs
[TIPC_NLA_BEARER_PROP
]) {
897 struct nlattr
*props
[TIPC_NLA_PROP_MAX
+ 1];
899 err
= tipc_nl_parse_link_prop(attrs
[TIPC_NLA_BEARER_PROP
],
906 if (props
[TIPC_NLA_PROP_TOL
])
907 b
->tolerance
= nla_get_u32(props
[TIPC_NLA_PROP_TOL
]);
908 if (props
[TIPC_NLA_PROP_PRIO
])
909 b
->priority
= nla_get_u32(props
[TIPC_NLA_PROP_PRIO
]);
910 if (props
[TIPC_NLA_PROP_WIN
])
911 b
->window
= nla_get_u32(props
[TIPC_NLA_PROP_WIN
]);
918 static int __tipc_nl_add_media(struct tipc_nl_msg
*msg
,
919 struct tipc_media
*media
)
922 struct nlattr
*attrs
;
925 hdr
= genlmsg_put(msg
->skb
, msg
->portid
, msg
->seq
, &tipc_genl_v2_family
,
926 NLM_F_MULTI
, TIPC_NL_MEDIA_GET
);
930 attrs
= nla_nest_start(msg
->skb
, TIPC_NLA_MEDIA
);
934 if (nla_put_string(msg
->skb
, TIPC_NLA_MEDIA_NAME
, media
->name
))
937 prop
= nla_nest_start(msg
->skb
, TIPC_NLA_MEDIA_PROP
);
940 if (nla_put_u32(msg
->skb
, TIPC_NLA_PROP_PRIO
, media
->priority
))
942 if (nla_put_u32(msg
->skb
, TIPC_NLA_PROP_TOL
, media
->tolerance
))
944 if (nla_put_u32(msg
->skb
, TIPC_NLA_PROP_WIN
, media
->window
))
947 nla_nest_end(msg
->skb
, prop
);
948 nla_nest_end(msg
->skb
, attrs
);
949 genlmsg_end(msg
->skb
, hdr
);
954 nla_nest_cancel(msg
->skb
, prop
);
956 nla_nest_cancel(msg
->skb
, attrs
);
958 genlmsg_cancel(msg
->skb
, hdr
);
963 int tipc_nl_media_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
967 struct tipc_nl_msg msg
;
973 msg
.portid
= NETLINK_CB(cb
->skb
).portid
;
974 msg
.seq
= cb
->nlh
->nlmsg_seq
;
977 for (; media_info_array
[i
] != NULL
; i
++) {
978 err
= __tipc_nl_add_media(&msg
, media_info_array
[i
]);
988 int tipc_nl_media_get(struct sk_buff
*skb
, struct genl_info
*info
)
992 struct tipc_nl_msg msg
;
993 struct tipc_media
*media
;
995 struct nlattr
*attrs
[TIPC_NLA_BEARER_MAX
+ 1];
997 if (!info
->attrs
[TIPC_NLA_MEDIA
])
1000 err
= nla_parse_nested(attrs
, TIPC_NLA_MEDIA_MAX
,
1001 info
->attrs
[TIPC_NLA_MEDIA
],
1002 tipc_nl_media_policy
);
1006 if (!attrs
[TIPC_NLA_MEDIA_NAME
])
1008 name
= nla_data(attrs
[TIPC_NLA_MEDIA_NAME
]);
1010 rep
= nlmsg_new(NLMSG_GOODSIZE
, GFP_KERNEL
);
1015 msg
.portid
= info
->snd_portid
;
1016 msg
.seq
= info
->snd_seq
;
1019 media
= tipc_media_find(name
);
1025 err
= __tipc_nl_add_media(&msg
, media
);
1030 return genlmsg_reply(rep
, info
);
1038 int tipc_nl_media_set(struct sk_buff
*skb
, struct genl_info
*info
)
1042 struct tipc_media
*m
;
1043 struct nlattr
*attrs
[TIPC_NLA_BEARER_MAX
+ 1];
1045 if (!info
->attrs
[TIPC_NLA_MEDIA
])
1048 err
= nla_parse_nested(attrs
, TIPC_NLA_MEDIA_MAX
,
1049 info
->attrs
[TIPC_NLA_MEDIA
],
1050 tipc_nl_media_policy
);
1052 if (!attrs
[TIPC_NLA_MEDIA_NAME
])
1054 name
= nla_data(attrs
[TIPC_NLA_MEDIA_NAME
]);
1057 m
= tipc_media_find(name
);
1063 if (attrs
[TIPC_NLA_MEDIA_PROP
]) {
1064 struct nlattr
*props
[TIPC_NLA_PROP_MAX
+ 1];
1066 err
= tipc_nl_parse_link_prop(attrs
[TIPC_NLA_MEDIA_PROP
],
1073 if (props
[TIPC_NLA_PROP_TOL
])
1074 m
->tolerance
= nla_get_u32(props
[TIPC_NLA_PROP_TOL
]);
1075 if (props
[TIPC_NLA_PROP_PRIO
])
1076 m
->priority
= nla_get_u32(props
[TIPC_NLA_PROP_PRIO
]);
1077 if (props
[TIPC_NLA_PROP_WIN
])
1078 m
->window
= nla_get_u32(props
[TIPC_NLA_PROP_WIN
]);