1/*
2 *	Bridge netlink control interface
3 *
4 *	Authors:
5 *	Stephen Hemminger		<shemminger@osdl.org>
6 *
7 *	This program is free software; you can redistribute it and/or
8 *	modify it under the terms of the GNU General Public License
9 *	as published by the Free Software Foundation; either version
10 *	2 of the License, or (at your option) any later version.
11 */
12
13#include <linux/kernel.h>
14#include <linux/slab.h>
15#include <linux/etherdevice.h>
16#include <net/rtnetlink.h>
17#include <net/net_namespace.h>
18#include <net/sock.h>
19#include <uapi/linux/if_bridge.h>
20
21#include "br_private.h"
22#include "br_private_stp.h"
23
24static inline size_t br_port_info_size(void)
25{
26	return nla_total_size(1)	/* IFLA_BRPORT_STATE  */
27		+ nla_total_size(2)	/* IFLA_BRPORT_PRIORITY */
28		+ nla_total_size(4)	/* IFLA_BRPORT_COST */
29		+ nla_total_size(1)	/* IFLA_BRPORT_MODE */
30		+ nla_total_size(1)	/* IFLA_BRPORT_GUARD */
31		+ nla_total_size(1)	/* IFLA_BRPORT_PROTECT */
32		+ nla_total_size(1)	/* IFLA_BRPORT_FAST_LEAVE */
33		+ 0;
34}
35
36static inline size_t br_nlmsg_size(void)
37{
38	return NLMSG_ALIGN(sizeof(struct ifinfomsg))
39		+ nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
40		+ nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
41		+ nla_total_size(4) /* IFLA_MASTER */
42		+ nla_total_size(4) /* IFLA_MTU */
43		+ nla_total_size(4) /* IFLA_LINK */
44		+ nla_total_size(1) /* IFLA_OPERSTATE */
45		+ nla_total_size(br_port_info_size()); /* IFLA_PROTINFO */
46}
47
48static int br_port_fill_attrs(struct sk_buff *skb,
49			      const struct net_bridge_port *p)
50{
51	u8 mode = !!(p->flags & BR_HAIRPIN_MODE);
52
53	if (nla_put_u8(skb, IFLA_BRPORT_STATE, p->state) ||
54	    nla_put_u16(skb, IFLA_BRPORT_PRIORITY, p->priority) ||
55	    nla_put_u32(skb, IFLA_BRPORT_COST, p->path_cost) ||
56	    nla_put_u8(skb, IFLA_BRPORT_MODE, mode) ||
57	    nla_put_u8(skb, IFLA_BRPORT_GUARD, !!(p->flags & BR_BPDU_GUARD)) ||
58	    nla_put_u8(skb, IFLA_BRPORT_PROTECT, !!(p->flags & BR_ROOT_BLOCK)) ||
59	    nla_put_u8(skb, IFLA_BRPORT_FAST_LEAVE, !!(p->flags & BR_MULTICAST_FAST_LEAVE)))
60		return -EMSGSIZE;
61
62	return 0;
63}
64
65/*
66 * Create one netlink message for one interface
67 * Contains port and master info as well as carrier and bridge state.
68 */
69static int br_fill_ifinfo(struct sk_buff *skb,
70			  const struct net_bridge_port *port,
71			  u32 pid, u32 seq, int event, unsigned int flags,
72			  u32 filter_mask, const struct net_device *dev)
73{
74	const struct net_bridge *br;
75	struct ifinfomsg *hdr;
76	struct nlmsghdr *nlh;
77	u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN;
78
79	if (port)
80		br = port->br;
81	else
82		br = netdev_priv(dev);
83
84	br_debug(br, "br_fill_info event %d port %s master %s\n",
85		     event, dev->name, br->dev->name);
86
87	nlh = nlmsg_put(skb, pid, seq, event, sizeof(*hdr), flags);
88	if (nlh == NULL)
89		return -EMSGSIZE;
90
91	hdr = nlmsg_data(nlh);
92	hdr->ifi_family = AF_BRIDGE;
93	hdr->__ifi_pad = 0;
94	hdr->ifi_type = dev->type;
95	hdr->ifi_index = dev->ifindex;
96	hdr->ifi_flags = dev_get_flags(dev);
97	hdr->ifi_change = 0;
98
99	if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
100	    nla_put_u32(skb, IFLA_MASTER, br->dev->ifindex) ||
101	    nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
102	    nla_put_u8(skb, IFLA_OPERSTATE, operstate) ||
103	    (dev->addr_len &&
104	     nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
105	    (dev->ifindex != dev->iflink &&
106	     nla_put_u32(skb, IFLA_LINK, dev->iflink)))
107		goto nla_put_failure;
108
109	if (event == RTM_NEWLINK && port) {
110		struct nlattr *nest
111			= nla_nest_start(skb, IFLA_PROTINFO | NLA_F_NESTED);
112
113		if (nest == NULL || br_port_fill_attrs(skb, port) < 0)
114			goto nla_put_failure;
115		nla_nest_end(skb, nest);
116	}
117
118	/* Check if  the VID information is requested */
119	if (filter_mask & RTEXT_FILTER_BRVLAN) {
120		struct nlattr *af;
121		const struct net_port_vlans *pv;
122		struct bridge_vlan_info vinfo;
123		u16 vid;
124		u16 pvid;
125
126		if (port)
127			pv = nbp_get_vlan_info(port);
128		else
129			pv = br_get_vlan_info(br);
130
131		if (!pv || bitmap_empty(pv->vlan_bitmap, BR_VLAN_BITMAP_LEN))
132			goto done;
133
134		af = nla_nest_start(skb, IFLA_AF_SPEC);
135		if (!af)
136			goto nla_put_failure;
137
138		pvid = br_get_pvid(pv);
139		for_each_set_bit(vid, pv->vlan_bitmap, BR_VLAN_BITMAP_LEN) {
140			vinfo.vid = vid;
141			vinfo.flags = 0;
142			if (vid == pvid)
143				vinfo.flags |= BRIDGE_VLAN_INFO_PVID;
144
145			if (test_bit(vid, pv->untagged_bitmap))
146				vinfo.flags |= BRIDGE_VLAN_INFO_UNTAGGED;
147
148			if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
149				    sizeof(vinfo), &vinfo))
150				goto nla_put_failure;
151		}
152
153		nla_nest_end(skb, af);
154	}
155
156done:
157	return nlmsg_end(skb, nlh);
158
159nla_put_failure:
160	nlmsg_cancel(skb, nlh);
161	return -EMSGSIZE;
162}
163
164/*
165 * Notify listeners of a change in port information
166 */
167void br_ifinfo_notify(int event, struct net_bridge_port *port)
168{
169	struct net *net;
170	struct sk_buff *skb;
171	int err = -ENOBUFS;
172
173	if (!port)
174		return;
175
176	net = dev_net(port->dev);
177	br_debug(port->br, "port %u(%s) event %d\n",
178		 (unsigned int)port->port_no, port->dev->name, event);
179
180	skb = nlmsg_new(br_nlmsg_size(), GFP_ATOMIC);
181	if (skb == NULL)
182		goto errout;
183
184	err = br_fill_ifinfo(skb, port, 0, 0, event, 0, 0, port->dev);
185	if (err < 0) {
186		/* -EMSGSIZE implies BUG in br_nlmsg_size() */
187		WARN_ON(err == -EMSGSIZE);
188		kfree_skb(skb);
189		goto errout;
190	}
191	rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC);
192	return;
193errout:
194	if (err < 0)
195		rtnl_set_sk_err(net, RTNLGRP_LINK, err);
196}
197
198
199/*
200 * Dump information about all ports, in response to GETLINK
201 */
202int br_getlink(struct sk_buff *skb, u32 pid, u32 seq,
203	       struct net_device *dev, u32 filter_mask)
204{
205	int err = 0;
206	struct net_bridge_port *port = br_port_get_rcu(dev);
207
208	/* not a bridge port and  */
209	if (!port && !(filter_mask & RTEXT_FILTER_BRVLAN))
210		goto out;
211
212	err = br_fill_ifinfo(skb, port, pid, seq, RTM_NEWLINK, NLM_F_MULTI,
213			     filter_mask, dev);
214out:
215	return err;
216}
217
218static const struct nla_policy ifla_br_policy[IFLA_MAX+1] = {
219	[IFLA_BRIDGE_FLAGS]	= { .type = NLA_U16 },
220	[IFLA_BRIDGE_MODE]	= { .type = NLA_U16 },
221	[IFLA_BRIDGE_VLAN_INFO]	= { .type = NLA_BINARY,
222				    .len = sizeof(struct bridge_vlan_info), },
223};
224
225static int br_afspec(struct net_bridge *br,
226		     struct net_bridge_port *p,
227		     struct nlattr *af_spec,
228		     int cmd)
229{
230	struct nlattr *tb[IFLA_BRIDGE_MAX+1];
231	int err = 0;
232
233	err = nla_parse_nested(tb, IFLA_BRIDGE_MAX, af_spec, ifla_br_policy);
234	if (err)
235		return err;
236
237	if (tb[IFLA_BRIDGE_VLAN_INFO]) {
238		struct bridge_vlan_info *vinfo;
239
240		vinfo = nla_data(tb[IFLA_BRIDGE_VLAN_INFO]);
241
242		if (vinfo->vid >= VLAN_N_VID)
243			return -EINVAL;
244
245		switch (cmd) {
246		case RTM_SETLINK:
247			if (p) {
248				err = nbp_vlan_add(p, vinfo->vid, vinfo->flags);
249				if (err)
250					break;
251
252				if (vinfo->flags & BRIDGE_VLAN_INFO_MASTER)
253					err = br_vlan_add(p->br, vinfo->vid,
254							  vinfo->flags);
255			} else
256				err = br_vlan_add(br, vinfo->vid, vinfo->flags);
257
258			if (err)
259				break;
260
261			break;
262
263		case RTM_DELLINK:
264			if (p) {
265				nbp_vlan_delete(p, vinfo->vid);
266				if (vinfo->flags & BRIDGE_VLAN_INFO_MASTER)
267					br_vlan_delete(p->br, vinfo->vid);
268			} else
269				br_vlan_delete(br, vinfo->vid);
270			break;
271		}
272	}
273
274	return err;
275}
276
277static const struct nla_policy ifla_brport_policy[IFLA_BRPORT_MAX + 1] = {
278	[IFLA_BRPORT_STATE]	= { .type = NLA_U8 },
279	[IFLA_BRPORT_COST]	= { .type = NLA_U32 },
280	[IFLA_BRPORT_PRIORITY]	= { .type = NLA_U16 },
281	[IFLA_BRPORT_MODE]	= { .type = NLA_U8 },
282	[IFLA_BRPORT_GUARD]	= { .type = NLA_U8 },
283	[IFLA_BRPORT_PROTECT]	= { .type = NLA_U8 },
284};
285
286/* Change the state of the port and notify spanning tree */
287static int br_set_port_state(struct net_bridge_port *p, u8 state)
288{
289	if (state > BR_STATE_BLOCKING)
290		return -EINVAL;
291
292	/* if kernel STP is running, don't allow changes */
293	if (p->br->stp_enabled == BR_KERNEL_STP)
294		return -EBUSY;
295
296	/* if device is not up, change is not allowed
297	 * if link is not present, only allowable state is disabled
298	 */
299	if (!netif_running(p->dev) ||
300	    (!netif_oper_up(p->dev) && state != BR_STATE_DISABLED))
301		return -ENETDOWN;
302
303	p->state = state;
304	br_log_state(p);
305	br_port_state_selection(p->br);
306	return 0;
307}
308
309/* Set/clear or port flags based on attribute */
310static void br_set_port_flag(struct net_bridge_port *p, struct nlattr *tb[],
311			   int attrtype, unsigned long mask)
312{
313	if (tb[attrtype]) {
314		u8 flag = nla_get_u8(tb[attrtype]);
315		if (flag)
316			p->flags |= mask;
317		else
318			p->flags &= ~mask;
319	}
320}
321
322/* Process bridge protocol info on port */
323static int br_setport(struct net_bridge_port *p, struct nlattr *tb[])
324{
325	int err;
326
327	br_set_port_flag(p, tb, IFLA_BRPORT_MODE, BR_HAIRPIN_MODE);
328	br_set_port_flag(p, tb, IFLA_BRPORT_GUARD, BR_BPDU_GUARD);
329	br_set_port_flag(p, tb, IFLA_BRPORT_FAST_LEAVE, BR_MULTICAST_FAST_LEAVE);
330	br_set_port_flag(p, tb, IFLA_BRPORT_PROTECT, BR_ROOT_BLOCK);
331
332	if (tb[IFLA_BRPORT_COST]) {
333		err = br_stp_set_path_cost(p, nla_get_u32(tb[IFLA_BRPORT_COST]));
334		if (err)
335			return err;
336	}
337
338	if (tb[IFLA_BRPORT_PRIORITY]) {
339		err = br_stp_set_port_priority(p, nla_get_u16(tb[IFLA_BRPORT_PRIORITY]));
340		if (err)
341			return err;
342	}
343
344	if (tb[IFLA_BRPORT_STATE]) {
345		err = br_set_port_state(p, nla_get_u8(tb[IFLA_BRPORT_STATE]));
346		if (err)
347			return err;
348	}
349	return 0;
350}
351
352/* Change state and parameters on port. */
353int br_setlink(struct net_device *dev, struct nlmsghdr *nlh)
354{
355	struct nlattr *protinfo;
356	struct nlattr *afspec;
357	struct net_bridge_port *p;
358	struct nlattr *tb[IFLA_BRPORT_MAX + 1];
359	int err = 0;
360
361	protinfo = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_PROTINFO);
362	afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
363	if (!protinfo && !afspec)
364		return 0;
365
366	p = br_port_get_rtnl(dev);
367	/* We want to accept dev as bridge itself if the AF_SPEC
368	 * is set to see if someone is setting vlan info on the brigde
369	 */
370	if (!p && !afspec)
371		return -EINVAL;
372
373	if (p && protinfo) {
374		if (protinfo->nla_type & NLA_F_NESTED) {
375			err = nla_parse_nested(tb, IFLA_BRPORT_MAX,
376					       protinfo, ifla_brport_policy);
377			if (err)
378				return err;
379
380			spin_lock_bh(&p->br->lock);
381			err = br_setport(p, tb);
382			spin_unlock_bh(&p->br->lock);
383		} else {
384			/* Binary compatability with old RSTP */
385			if (nla_len(protinfo) < sizeof(u8))
386				return -EINVAL;
387
388			spin_lock_bh(&p->br->lock);
389			err = br_set_port_state(p, nla_get_u8(protinfo));
390			spin_unlock_bh(&p->br->lock);
391		}
392		if (err)
393			goto out;
394	}
395
396	if (afspec) {
397		err = br_afspec((struct net_bridge *)netdev_priv(dev), p,
398				afspec, RTM_SETLINK);
399	}
400
401	if (err == 0)
402		br_ifinfo_notify(RTM_NEWLINK, p);
403
404out:
405	return err;
406}
407
408/* Delete port information */
409int br_dellink(struct net_device *dev, struct nlmsghdr *nlh)
410{
411	struct nlattr *afspec;
412	struct net_bridge_port *p;
413	int err;
414
415	afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
416	if (!afspec)
417		return 0;
418
419	p = br_port_get_rtnl(dev);
420	/* We want to accept dev as bridge itself as well */
421	if (!p && !(dev->priv_flags & IFF_EBRIDGE))
422		return -EINVAL;
423
424	err = br_afspec((struct net_bridge *)netdev_priv(dev), p,
425			afspec, RTM_DELLINK);
426
427	return err;
428}
429static int br_validate(struct nlattr *tb[], struct nlattr *data[])
430{
431	if (tb[IFLA_ADDRESS]) {
432		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
433			return -EINVAL;
434		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
435			return -EADDRNOTAVAIL;
436	}
437
438	return 0;
439}
440
441static size_t br_get_link_af_size(const struct net_device *dev)
442{
443	struct net_port_vlans *pv;
444
445	if (br_port_exists(dev))
446		pv = nbp_get_vlan_info(br_port_get_rcu(dev));
447	else if (dev->priv_flags & IFF_EBRIDGE)
448		pv = br_get_vlan_info((struct net_bridge *)netdev_priv(dev));
449	else
450		return 0;
451
452	if (!pv)
453		return 0;
454
455	/* Each VLAN is returned in bridge_vlan_info along with flags */
456	return pv->num_vlans * nla_total_size(sizeof(struct bridge_vlan_info));
457}
458
459static struct rtnl_af_ops br_af_ops = {
460	.family			= AF_BRIDGE,
461	.get_link_af_size	= br_get_link_af_size,
462};
463
464struct rtnl_link_ops br_link_ops __read_mostly = {
465	.kind		= "bridge",
466	.priv_size	= sizeof(struct net_bridge),
467	.setup		= br_dev_setup,
468	.validate	= br_validate,
469	.dellink	= br_dev_delete,
470};
471
472int __init br_netlink_init(void)
473{
474	int err;
475
476	br_mdb_init();
477	err = rtnl_af_register(&br_af_ops);
478	if (err)
479		goto out;
480
481	err = rtnl_link_register(&br_link_ops);
482	if (err)
483		goto out_af;
484
485	return 0;
486
487out_af:
488	rtnl_af_unregister(&br_af_ops);
489out:
490	br_mdb_uninit();
491	return err;
492}
493
494void __exit br_netlink_fini(void)
495{
496	br_mdb_uninit();
497	rtnl_af_unregister(&br_af_ops);
498	rtnl_link_unregister(&br_link_ops);
499}
500