[linux-2.6-block.git] / net / ieee802154 / nl802154.c

/* This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * Authors:
 * Alexander Aring <aar@pengutronix.de>
 *
 * Based on: net/wireless/nl80211.c
 */

#include <linux/rtnetlink.h>

#include <net/cfg802154.h>
#include <net/genetlink.h>
#include <net/mac802154.h>
#include <net/netlink.h>
#include <net/nl802154.h>
#include <net/sock.h>

#include "nl802154.h"
#include "core.h"

static int nl802154_pre_doit(const struct genl_ops *ops, struct sk_buff *skb,
			     struct genl_info *info);

static void nl802154_post_doit(const struct genl_ops *ops, struct sk_buff *skb,
			       struct genl_info *info);

/* the netlink family */
static struct genl_family nl802154_fam = {
	.id = GENL_ID_GENERATE,		/* don't bother with a hardcoded ID */
	.name = NL802154_GENL_NAME,	/* have users key off the name instead */
	.hdrsize = 0,			/* no private header */
	.version = 1,			/* no particular meaning now */
	.maxattr = NL802154_ATTR_MAX,
	.netnsok = true,
	.pre_doit = nl802154_pre_doit,
	.post_doit = nl802154_post_doit,
};

/* multicast groups */
enum nl802154_multicast_groups {
	NL802154_MCGRP_CONFIG,
};

static const struct genl_multicast_group nl802154_mcgrps[] = {
	[NL802154_MCGRP_CONFIG] = { .name = "config", },
};

/* returns ERR_PTR values */
static struct wpan_dev *
__cfg802154_wpan_dev_from_attrs(struct net *netns, struct nlattr **attrs)
{
	struct cfg802154_registered_device *rdev;
	struct wpan_dev *result = NULL;
	bool have_ifidx = attrs[NL802154_ATTR_IFINDEX];
	bool have_wpan_dev_id = attrs[NL802154_ATTR_WPAN_DEV];
	u64 wpan_dev_id;
	int wpan_phy_idx = -1;
	int ifidx = -1;

	ASSERT_RTNL();

	if (!have_ifidx && !have_wpan_dev_id)
		return ERR_PTR(-EINVAL);

	if (have_ifidx)
		ifidx = nla_get_u32(attrs[NL802154_ATTR_IFINDEX]);
	if (have_wpan_dev_id) {
		wpan_dev_id = nla_get_u64(attrs[NL802154_ATTR_WPAN_DEV]);
		wpan_phy_idx = wpan_dev_id >> 32;
	}

	list_for_each_entry(rdev, &cfg802154_rdev_list, list) {
		struct wpan_dev *wpan_dev;

		/* TODO netns compare */

		if (have_wpan_dev_id && rdev->wpan_phy_idx != wpan_phy_idx)
			continue;

		list_for_each_entry(wpan_dev, &rdev->wpan_dev_list, list) {
			if (have_ifidx && wpan_dev->netdev &&
			    wpan_dev->netdev->ifindex == ifidx) {
				result = wpan_dev;
				break;
			}
			if (have_wpan_dev_id &&
			    wpan_dev->identifier == (u32)wpan_dev_id) {
				result = wpan_dev;
				break;
			}
		}

		if (result)
			break;
	}

	if (result)
		return result;

	return ERR_PTR(-ENODEV);
}

static struct cfg802154_registered_device *
__cfg802154_rdev_from_attrs(struct net *netns, struct nlattr **attrs)
{
	struct cfg802154_registered_device *rdev = NULL, *tmp;
	struct net_device *netdev;

	ASSERT_RTNL();

	if (!attrs[NL802154_ATTR_WPAN_PHY] &&
	    !attrs[NL802154_ATTR_IFINDEX] &&
	    !attrs[NL802154_ATTR_WPAN_DEV])
		return ERR_PTR(-EINVAL);

	if (attrs[NL802154_ATTR_WPAN_PHY])
		rdev = cfg802154_rdev_by_wpan_phy_idx(
				nla_get_u32(attrs[NL802154_ATTR_WPAN_PHY]));

	if (attrs[NL802154_ATTR_WPAN_DEV]) {
		u64 wpan_dev_id = nla_get_u64(attrs[NL802154_ATTR_WPAN_DEV]);
		struct wpan_dev *wpan_dev;
		bool found = false;

		tmp = cfg802154_rdev_by_wpan_phy_idx(wpan_dev_id >> 32);
		if (tmp) {
			/* make sure wpan_dev exists */
			list_for_each_entry(wpan_dev, &tmp->wpan_dev_list, list) {
				if (wpan_dev->identifier != (u32)wpan_dev_id)
					continue;
				found = true;
				break;
			}

			if (!found)
				tmp = NULL;

			if (rdev && tmp != rdev)
				return ERR_PTR(-EINVAL);
			rdev = tmp;
		}
	}

	if (attrs[NL802154_ATTR_IFINDEX]) {
		int ifindex = nla_get_u32(attrs[NL802154_ATTR_IFINDEX]);

		netdev = __dev_get_by_index(netns, ifindex);
		if (netdev) {
			if (netdev->ieee802154_ptr)
				tmp = wpan_phy_to_rdev(
						netdev->ieee802154_ptr->wpan_phy);
			else
				tmp = NULL;

			/* not wireless device -- return error */
			if (!tmp)
				return ERR_PTR(-EINVAL);

			/* mismatch -- return error */
			if (rdev && tmp != rdev)
				return ERR_PTR(-EINVAL);

			rdev = tmp;
		}
	}

	if (!rdev)
		return ERR_PTR(-ENODEV);

	/* TODO netns compare */

	return rdev;
}

/* This function returns a pointer to the driver
 * that the genl_info item that is passed refers to.
 *
 * The result of this can be a PTR_ERR and hence must
 * be checked with IS_ERR() for errors.
 */
static struct cfg802154_registered_device *
cfg802154_get_dev_from_info(struct net *netns, struct genl_info *info)
{
	return __cfg802154_rdev_from_attrs(netns, info->attrs);
}

/* policy for the attributes */
static const struct nla_policy nl802154_policy[NL802154_ATTR_MAX+1] = {
};

/* message building helper */
static inline void *nl802154hdr_put(struct sk_buff *skb, u32 portid, u32 seq,
				    int flags, u8 cmd)
{
	/* since there is no private header just add the generic one */
	return genlmsg_put(skb, portid, seq, &nl802154_fam, flags, cmd);
}

#define NL802154_FLAG_NEED_WPAN_PHY	0x01
#define NL802154_FLAG_NEED_NETDEV	0x02
#define NL802154_FLAG_NEED_RTNL		0x04
#define NL802154_FLAG_CHECK_NETDEV_UP	0x08
#define NL802154_FLAG_NEED_NETDEV_UP	(NL802154_FLAG_NEED_NETDEV |\
					 NL802154_FLAG_CHECK_NETDEV_UP)
#define NL802154_FLAG_NEED_WPAN_DEV	0x10
#define NL802154_FLAG_NEED_WPAN_DEV_UP	(NL802154_FLAG_NEED_WPAN_DEV |\
					 NL802154_FLAG_CHECK_NETDEV_UP)

static int nl802154_pre_doit(const struct genl_ops *ops, struct sk_buff *skb,
			     struct genl_info *info)
{
	struct cfg802154_registered_device *rdev;
	struct wpan_dev *wpan_dev;
	struct net_device *dev;
	bool rtnl = ops->internal_flags & NL802154_FLAG_NEED_RTNL;

	if (rtnl)
		rtnl_lock();

	if (ops->internal_flags & NL802154_FLAG_NEED_WPAN_PHY) {
		rdev = cfg802154_get_dev_from_info(genl_info_net(info), info);
		if (IS_ERR(rdev)) {
			if (rtnl)
				rtnl_unlock();
			return PTR_ERR(rdev);
		}
		info->user_ptr[0] = rdev;
	} else if (ops->internal_flags & NL802154_FLAG_NEED_NETDEV ||
		   ops->internal_flags & NL802154_FLAG_NEED_WPAN_DEV) {
		ASSERT_RTNL();
		wpan_dev = __cfg802154_wpan_dev_from_attrs(genl_info_net(info),
							   info->attrs);
		if (IS_ERR(wpan_dev)) {
			if (rtnl)
				rtnl_unlock();
			return PTR_ERR(wpan_dev);
		}

		dev = wpan_dev->netdev;
		rdev = wpan_phy_to_rdev(wpan_dev->wpan_phy);

		if (ops->internal_flags & NL802154_FLAG_NEED_NETDEV) {
			if (!dev) {
				if (rtnl)
					rtnl_unlock();
				return -EINVAL;
			}

			info->user_ptr[1] = dev;
		} else {
			info->user_ptr[1] = wpan_dev;
		}

		if (dev) {
			if (ops->internal_flags & NL802154_FLAG_CHECK_NETDEV_UP &&
			    !netif_running(dev)) {
				if (rtnl)
					rtnl_unlock();
				return -ENETDOWN;
			}

			dev_hold(dev);
		}

		info->user_ptr[0] = rdev;
	}

	return 0;
}

static void nl802154_post_doit(const struct genl_ops *ops, struct sk_buff *skb,
			       struct genl_info *info)
{
	if (info->user_ptr[1]) {
		if (ops->internal_flags & NL802154_FLAG_NEED_WPAN_DEV) {
			struct wpan_dev *wpan_dev = info->user_ptr[1];

			if (wpan_dev->netdev)
				dev_put(wpan_dev->netdev);
		} else {
			dev_put(info->user_ptr[1]);
		}
	}

	if (ops->internal_flags & NL802154_FLAG_NEED_RTNL)
		rtnl_unlock();
}

static const struct genl_ops nl802154_ops[] = {
};

/* initialisation/exit functions */
int nl802154_init(void)
{
	return genl_register_family_with_ops_groups(&nl802154_fam, nl802154_ops,
						    nl802154_mcgrps);
}

void nl802154_exit(void)
{
	genl_unregister_family(&nl802154_fam);
}
Commit	Line	Data
79fe1a2a AA	1	/* This program is free software; you can redistribute it and/or modify
	2	* it under the terms of the GNU General Public License version 2
	3	* as published by the Free Software Foundation.
	4	*
	5	* This program is distributed in the hope that it will be useful,
	6	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	7	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	8	* GNU General Public License for more details.
	9	*
	10	* Authors:
	11	* Alexander Aring <aar@pengutronix.de>
	12	*
	13	* Based on: net/wireless/nl80211.c
	14	*/
	15
	16	#include <linux/rtnetlink.h>
	17
	18	#include <net/cfg802154.h>
	19	#include <net/genetlink.h>
	20	#include <net/mac802154.h>
	21	#include <net/netlink.h>
	22	#include <net/nl802154.h>
	23	#include <net/sock.h>
	24
	25	#include "nl802154.h"
	26	#include "core.h"
	27
	28	static int nl802154_pre_doit(const struct genl_ops ops, struct sk_buff skb,
	29	struct genl_info *info);
	30
	31	static void nl802154_post_doit(const struct genl_ops ops, struct sk_buff skb,
	32	struct genl_info *info);
	33
	34	/* the netlink family */
	35	static struct genl_family nl802154_fam = {
	36	.id = GENL_ID_GENERATE, /* don't bother with a hardcoded ID */
	37	.name = NL802154_GENL_NAME, /* have users key off the name instead */
	38	.hdrsize = 0, /* no private header */
	39	.version = 1, /* no particular meaning now */
	40	.maxattr = NL802154_ATTR_MAX,
	41	.netnsok = true,
	42	.pre_doit = nl802154_pre_doit,
	43	.post_doit = nl802154_post_doit,
	44	};
	45
	46	/* multicast groups */
	47	enum nl802154_multicast_groups {
	48	NL802154_MCGRP_CONFIG,
	49	};
	50
	51	static const struct genl_multicast_group nl802154_mcgrps[] = {
	52	[NL802154_MCGRP_CONFIG] = { .name = "config", },
	53	};
	54
	55	/* returns ERR_PTR values */
	56	static struct wpan_dev *
	57	__cfg802154_wpan_dev_from_attrs(struct net netns, struct nlattr *attrs)
	58	{
	59	struct cfg802154_registered_device *rdev;
	60	struct wpan_dev *result = NULL;
	61	bool have_ifidx = attrs[NL802154_ATTR_IFINDEX];
	62	bool have_wpan_dev_id = attrs[NL802154_ATTR_WPAN_DEV];
	63	u64 wpan_dev_id;
	64	int wpan_phy_idx = -1;
65	int ifidx = -1;
66
67	ASSERT_RTNL();
68
69	if (!have_ifidx && !have_wpan_dev_id)
70	return ERR_PTR(-EINVAL);
71
72	if (have_ifidx)
73	ifidx = nla_get_u32(attrs[NL802154_ATTR_IFINDEX]);
74	if (have_wpan_dev_id) {
75	wpan_dev_id = nla_get_u64(attrs[NL802154_ATTR_WPAN_DEV]);
76	wpan_phy_idx = wpan_dev_id >> 32;
77	}
78
79	list_for_each_entry(rdev, &cfg802154_rdev_list, list) {
80	struct wpan_dev *wpan_dev;
81
82	/* TODO netns compare */
83
84	if (have_wpan_dev_id && rdev->wpan_phy_idx != wpan_phy_idx)
85	continue;
86
87	list_for_each_entry(wpan_dev, &rdev->wpan_dev_list, list) {
88	if (have_ifidx && wpan_dev->netdev &&
89	wpan_dev->netdev->ifindex == ifidx) {
90	result = wpan_dev;
91	break;
92	}
93	if (have_wpan_dev_id &&
94	wpan_dev->identifier == (u32)wpan_dev_id) {
95	result = wpan_dev;
96	break;
97	}
98	}
99
100	if (result)
101	break;
102	}
103
104	if (result)
105	return result;
106
107	return ERR_PTR(-ENODEV);
108	}
109
110	static struct cfg802154_registered_device *
111	__cfg802154_rdev_from_attrs(struct net netns, struct nlattr *attrs)
112	{
113	struct cfg802154_registered_device rdev = NULL, tmp;
114	struct net_device *netdev;
115
116	ASSERT_RTNL();
117
118	if (!attrs[NL802154_ATTR_WPAN_PHY] &&
119	!attrs[NL802154_ATTR_IFINDEX] &&
120	!attrs[NL802154_ATTR_WPAN_DEV])
121	return ERR_PTR(-EINVAL);
122
123	if (attrs[NL802154_ATTR_WPAN_PHY])
124	rdev = cfg802154_rdev_by_wpan_phy_idx(
125	nla_get_u32(attrs[NL802154_ATTR_WPAN_PHY]));
126
127	if (attrs[NL802154_ATTR_WPAN_DEV]) {
128	u64 wpan_dev_id = nla_get_u64(attrs[NL802154_ATTR_WPAN_DEV]);
129	struct wpan_dev *wpan_dev;
130	bool found = false;
131
132	tmp = cfg802154_rdev_by_wpan_phy_idx(wpan_dev_id >> 32);
133	if (tmp) {
134	/* make sure wpan_dev exists */
135	list_for_each_entry(wpan_dev, &tmp->wpan_dev_list, list) {
136	if (wpan_dev->identifier != (u32)wpan_dev_id)
137	continue;
138	found = true;
139	break;
140	}
141
142	if (!found)
143	tmp = NULL;
144
145	if (rdev && tmp != rdev)
146	return ERR_PTR(-EINVAL);
147	rdev = tmp;
148	}
149	}
150
151	if (attrs[NL802154_ATTR_IFINDEX]) {
152	int ifindex = nla_get_u32(attrs[NL802154_ATTR_IFINDEX]);
153
154	netdev = __dev_get_by_index(netns, ifindex);
155	if (netdev) {
156	if (netdev->ieee802154_ptr)
157	tmp = wpan_phy_to_rdev(
158	netdev->ieee802154_ptr->wpan_phy);
159	else
160	tmp = NULL;
161
162	/* not wireless device -- return error */
163	if (!tmp)
164	return ERR_PTR(-EINVAL);
165
166	/* mismatch -- return error */
167	if (rdev && tmp != rdev)
168	return ERR_PTR(-EINVAL);
169
170	rdev = tmp;
171	}
172	}
173
174	if (!rdev)
175	return ERR_PTR(-ENODEV);
176
177	/* TODO netns compare */
178
179	return rdev;
180	}
181
182	/* This function returns a pointer to the driver
183	* that the genl_info item that is passed refers to.
184	*
185	* The result of this can be a PTR_ERR and hence must
186	* be checked with IS_ERR() for errors.
187	*/
188	static struct cfg802154_registered_device *
189	cfg802154_get_dev_from_info(struct net netns, struct genl_info info)
190	{
191	return __cfg802154_rdev_from_attrs(netns, info->attrs);
192	}
193
194	/* policy for the attributes */
195	static const struct nla_policy nl802154_policy[NL802154_ATTR_MAX+1] = {
196	};
197
198	/* message building helper */
199	static inline void nl802154hdr_put(struct sk_buff skb, u32 portid, u32 seq,
200	int flags, u8 cmd)
201	{
202	/* since there is no private header just add the generic one */
203	return genlmsg_put(skb, portid, seq, &nl802154_fam, flags, cmd);
204	}
205
206	#define NL802154_FLAG_NEED_WPAN_PHY 0x01
207	#define NL802154_FLAG_NEED_NETDEV 0x02
208	#define NL802154_FLAG_NEED_RTNL 0x04
209	#define NL802154_FLAG_CHECK_NETDEV_UP 0x08
210	#define NL802154_FLAG_NEED_NETDEV_UP (NL802154_FLAG_NEED_NETDEV \|\
211	NL802154_FLAG_CHECK_NETDEV_UP)
212	#define NL802154_FLAG_NEED_WPAN_DEV 0x10
213	#define NL802154_FLAG_NEED_WPAN_DEV_UP (NL802154_FLAG_NEED_WPAN_DEV \|\
214	NL802154_FLAG_CHECK_NETDEV_UP)
215
216	static int nl802154_pre_doit(const struct genl_ops ops, struct sk_buff skb,
217	struct genl_info *info)
218	{
219	struct cfg802154_registered_device *rdev;
220	struct wpan_dev *wpan_dev;
221	struct net_device *dev;
222	bool rtnl = ops->internal_flags & NL802154_FLAG_NEED_RTNL;
223
224	if (rtnl)
225	rtnl_lock();
226
227	if (ops->internal_flags & NL802154_FLAG_NEED_WPAN_PHY) {
228	rdev = cfg802154_get_dev_from_info(genl_info_net(info), info);
229	if (IS_ERR(rdev)) {
230	if (rtnl)
231	rtnl_unlock();
232	return PTR_ERR(rdev);
233	}
234	info->user_ptr[0] = rdev;
235	} else if (ops->internal_flags & NL802154_FLAG_NEED_NETDEV \|\|
236	ops->internal_flags & NL802154_FLAG_NEED_WPAN_DEV) {
237	ASSERT_RTNL();
238	wpan_dev = __cfg802154_wpan_dev_from_attrs(genl_info_net(info),
239	info->attrs);
240	if (IS_ERR(wpan_dev)) {
241	if (rtnl)
242	rtnl_unlock();
243	return PTR_ERR(wpan_dev);
244	}
245
246	dev = wpan_dev->netdev;
247	rdev = wpan_phy_to_rdev(wpan_dev->wpan_phy);
248
249	if (ops->internal_flags & NL802154_FLAG_NEED_NETDEV) {
250	if (!dev) {
251	if (rtnl)
252	rtnl_unlock();
253	return -EINVAL;
254	}
255
256	info->user_ptr[1] = dev;
257	} else {
258	info->user_ptr[1] = wpan_dev;
259	}
260
261	if (dev) {
262	if (ops->internal_flags & NL802154_FLAG_CHECK_NETDEV_UP &&
263	!netif_running(dev)) {
264	if (rtnl)
265	rtnl_unlock();
266	return -ENETDOWN;
267	}
268
269	dev_hold(dev);
270	}
271
272	info->user_ptr[0] = rdev;
273	}
274
275	return 0;
276	}
277
278	static void nl802154_post_doit(const struct genl_ops ops, struct sk_buff skb,
279	struct genl_info *info)
280	{
281	if (info->user_ptr[1]) {
282	if (ops->internal_flags & NL802154_FLAG_NEED_WPAN_DEV) {
283	struct wpan_dev *wpan_dev = info->user_ptr[1];
284
285	if (wpan_dev->netdev)
286	dev_put(wpan_dev->netdev);
287	} else {
288	dev_put(info->user_ptr[1]);
289	}
290	}
291
292	if (ops->internal_flags & NL802154_FLAG_NEED_RTNL)
293	rtnl_unlock();
294	}
295
296	static const struct genl_ops nl802154_ops[] = {
297	};
298
299	/* initialisation/exit functions */
300	int nl802154_init(void)
301	{
302	return genl_register_family_with_ops_groups(&nl802154_fam, nl802154_ops,
303	nl802154_mcgrps);
304	}
305
306	void nl802154_exit(void)
307	{
308	genl_unregister_family(&nl802154_fam);
309	}