[mirror_ubuntu-jammy-kernel.git] / net / ieee802154 / netlink.c

/*
 * Netlink inteface for IEEE 802.15.4 stack
 *
 * Copyright 2007, 2008 Siemens AG
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Written by:
 * Sergey Lapin <slapin@ossfans.org>
 * Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
 */

#include <linux/kernel.h>
#include <linux/if_arp.h>
#include <linux/netdevice.h>
#include <net/netlink.h>
#include <net/genetlink.h>
#include <linux/nl802154.h>
#include <net/ieee802154/af_ieee802154.h>
#include <net/ieee802154/nl802154.h>
#include <net/ieee802154/netdevice.h>

static unsigned int ieee802154_seq_num;

static struct genl_family ieee802154_coordinator_family = {
	.id		= GENL_ID_GENERATE,
	.hdrsize	= 0,
	.name		= IEEE802154_NL_NAME,
	.version	= 1,
	.maxattr	= IEEE802154_ATTR_MAX,
};

static struct genl_multicast_group ieee802154_coord_mcgrp = {
	.name		= IEEE802154_MCAST_COORD_NAME,
};

static struct genl_multicast_group ieee802154_beacon_mcgrp = {
	.name		= IEEE802154_MCAST_BEACON_NAME,
};

/* Requests to userspace */
static struct sk_buff *ieee802154_nl_create(int flags, u8 req)
{
	void *hdr;
	struct sk_buff *msg = nlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);

	if (!msg)
		return NULL;

	hdr = genlmsg_put(msg, 0, ieee802154_seq_num++,
			&ieee802154_coordinator_family, flags, req);
	if (!hdr) {
		nlmsg_free(msg);
		return NULL;
	}

	return msg;
}

static int ieee802154_nl_finish(struct sk_buff *msg)
{
	/* XXX: nlh is right at the start of msg */
	void *hdr = genlmsg_data(NLMSG_DATA(msg->data));

	if (!genlmsg_end(msg, hdr))
		goto out;

	return genlmsg_multicast(msg, 0, ieee802154_coord_mcgrp.id,
			GFP_ATOMIC);
out:
	nlmsg_free(msg);
	return -ENOBUFS;
}

int ieee802154_nl_assoc_indic(struct net_device *dev,
		struct ieee802154_addr *addr, u8 cap)
{
	struct sk_buff *msg;

	pr_debug("%s\n", __func__);

	if (addr->addr_type != IEEE802154_ADDR_LONG) {
		pr_err("%s: received non-long source address!\n", __func__);
		return -EINVAL;
	}

	msg = ieee802154_nl_create(0, IEEE802154_ASSOCIATE_INDIC);
	if (!msg)
		return -ENOBUFS;

	NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
	NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
	NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
			dev->dev_addr);

	NLA_PUT(msg, IEEE802154_ATTR_SRC_HW_ADDR, IEEE802154_ADDR_LEN,
			addr->hwaddr);

	NLA_PUT_U8(msg, IEEE802154_ATTR_CAPABILITY, cap);

	return ieee802154_nl_finish(msg);

nla_put_failure:
	nlmsg_free(msg);
	return -ENOBUFS;
}
EXPORT_SYMBOL(ieee802154_nl_assoc_indic);

int ieee802154_nl_assoc_confirm(struct net_device *dev, u16 short_addr,
		u8 status)
{
	struct sk_buff *msg;

	pr_debug("%s\n", __func__);

	msg = ieee802154_nl_create(0, IEEE802154_ASSOCIATE_CONF);
	if (!msg)
		return -ENOBUFS;

	NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
	NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
	NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
			dev->dev_addr);

	NLA_PUT_U16(msg, IEEE802154_ATTR_SHORT_ADDR, short_addr);
	NLA_PUT_U8(msg, IEEE802154_ATTR_STATUS, status);

	return ieee802154_nl_finish(msg);

nla_put_failure:
	nlmsg_free(msg);
	return -ENOBUFS;
}
EXPORT_SYMBOL(ieee802154_nl_assoc_confirm);

int ieee802154_nl_disassoc_indic(struct net_device *dev,
		struct ieee802154_addr *addr, u8 reason)
{
	struct sk_buff *msg;

	pr_debug("%s\n", __func__);

	msg = ieee802154_nl_create(0, IEEE802154_DISASSOCIATE_INDIC);
	if (!msg)
		return -ENOBUFS;

	NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
	NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
	NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
			dev->dev_addr);

	if (addr->addr_type == IEEE802154_ADDR_LONG)
		NLA_PUT(msg, IEEE802154_ATTR_SRC_HW_ADDR, IEEE802154_ADDR_LEN,
				addr->hwaddr);
	else
		NLA_PUT_U16(msg, IEEE802154_ATTR_SRC_SHORT_ADDR,
				addr->short_addr);

	NLA_PUT_U8(msg, IEEE802154_ATTR_REASON, reason);

	return ieee802154_nl_finish(msg);

nla_put_failure:
	nlmsg_free(msg);
	return -ENOBUFS;
}
EXPORT_SYMBOL(ieee802154_nl_disassoc_indic);

int ieee802154_nl_disassoc_confirm(struct net_device *dev, u8 status)
{
	struct sk_buff *msg;

	pr_debug("%s\n", __func__);

	msg = ieee802154_nl_create(0, IEEE802154_DISASSOCIATE_CONF);
	if (!msg)
		return -ENOBUFS;

	NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
	NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
	NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
			dev->dev_addr);

	NLA_PUT_U8(msg, IEEE802154_ATTR_STATUS, status);

	return ieee802154_nl_finish(msg);

nla_put_failure:
	nlmsg_free(msg);
	return -ENOBUFS;
}
EXPORT_SYMBOL(ieee802154_nl_disassoc_confirm);

int ieee802154_nl_beacon_indic(struct net_device *dev,
		u16 panid, u16 coord_addr)
{
	struct sk_buff *msg;

	pr_debug("%s\n", __func__);

	msg = ieee802154_nl_create(0, IEEE802154_BEACON_NOTIFY_INDIC);
	if (!msg)
		return -ENOBUFS;

	NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
	NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
	NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
			dev->dev_addr);
	NLA_PUT_U16(msg, IEEE802154_ATTR_COORD_SHORT_ADDR, coord_addr);
	NLA_PUT_U16(msg, IEEE802154_ATTR_COORD_PAN_ID, panid);

	return ieee802154_nl_finish(msg);

nla_put_failure:
	nlmsg_free(msg);
	return -ENOBUFS;
}
EXPORT_SYMBOL(ieee802154_nl_beacon_indic);

int ieee802154_nl_scan_confirm(struct net_device *dev,
		u8 status, u8 scan_type, u32 unscanned,
		u8 *edl/* , struct list_head *pan_desc_list */)
{
	struct sk_buff *msg;

	pr_debug("%s\n", __func__);

	msg = ieee802154_nl_create(0, IEEE802154_SCAN_CONF);
	if (!msg)
		return -ENOBUFS;

	NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
	NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
	NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
			dev->dev_addr);

	NLA_PUT_U8(msg, IEEE802154_ATTR_STATUS, status);
	NLA_PUT_U8(msg, IEEE802154_ATTR_SCAN_TYPE, scan_type);
	NLA_PUT_U32(msg, IEEE802154_ATTR_CHANNELS, unscanned);

	if (edl)
		NLA_PUT(msg, IEEE802154_ATTR_ED_LIST, 27, edl);

	return ieee802154_nl_finish(msg);

nla_put_failure:
	nlmsg_free(msg);
	return -ENOBUFS;
}
EXPORT_SYMBOL(ieee802154_nl_scan_confirm);

/* Requests from userspace */
static struct net_device *ieee802154_nl_get_dev(struct genl_info *info)
{
	struct net_device *dev;

	if (info->attrs[IEEE802154_ATTR_DEV_NAME]) {
		char name[IFNAMSIZ + 1];
		nla_strlcpy(name, info->attrs[IEEE802154_ATTR_DEV_NAME],
				sizeof(name));
		dev = dev_get_by_name(&init_net, name);
	} else if (info->attrs[IEEE802154_ATTR_DEV_INDEX])
		dev = dev_get_by_index(&init_net,
				nla_get_u32(info->attrs[IEEE802154_ATTR_DEV_INDEX]));
	else
		return NULL;

	if (!dev)
		return NULL;

	if (dev->type != ARPHRD_IEEE802154) {
		dev_put(dev);
		return NULL;
	}

	return dev;
}

static int ieee802154_associate_req(struct sk_buff *skb,
		struct genl_info *info)
{
	struct net_device *dev;
	struct ieee802154_addr addr;
	int ret = -EINVAL;

	if (!info->attrs[IEEE802154_ATTR_CHANNEL] ||
	    !info->attrs[IEEE802154_ATTR_COORD_PAN_ID] ||
	    (!info->attrs[IEEE802154_ATTR_COORD_HW_ADDR] &&
		!info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR]) ||
	    !info->attrs[IEEE802154_ATTR_CAPABILITY])
		return -EINVAL;

	dev = ieee802154_nl_get_dev(info);
	if (!dev)
		return -ENODEV;

	if (info->attrs[IEEE802154_ATTR_COORD_HW_ADDR]) {
		addr.addr_type = IEEE802154_ADDR_LONG;
		nla_memcpy(addr.hwaddr,
				info->attrs[IEEE802154_ATTR_COORD_HW_ADDR],
				IEEE802154_ADDR_LEN);
	} else {
		addr.addr_type = IEEE802154_ADDR_SHORT;
		addr.short_addr = nla_get_u16(
				info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR]);
	}
	addr.pan_id = nla_get_u16(info->attrs[IEEE802154_ATTR_COORD_PAN_ID]);

	ret = ieee802154_mlme_ops(dev)->assoc_req(dev, &addr,
			nla_get_u8(info->attrs[IEEE802154_ATTR_CHANNEL]),
			nla_get_u8(info->attrs[IEEE802154_ATTR_CAPABILITY]));

	dev_put(dev);
	return ret;
}

static int ieee802154_associate_resp(struct sk_buff *skb,
		struct genl_info *info)
{
	struct net_device *dev;
	struct ieee802154_addr addr;
	int ret = -EINVAL;

	if (!info->attrs[IEEE802154_ATTR_STATUS] ||
	    !info->attrs[IEEE802154_ATTR_DEST_HW_ADDR] ||
	    !info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR])
		return -EINVAL;

	dev = ieee802154_nl_get_dev(info);
	if (!dev)
		return -ENODEV;

	addr.addr_type = IEEE802154_ADDR_LONG;
	nla_memcpy(addr.hwaddr, info->attrs[IEEE802154_ATTR_DEST_HW_ADDR],
			IEEE802154_ADDR_LEN);
	addr.pan_id = ieee802154_mlme_ops(dev)->get_pan_id(dev);


	ret = ieee802154_mlme_ops(dev)->assoc_resp(dev, &addr,
		nla_get_u16(info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR]),
		nla_get_u8(info->attrs[IEEE802154_ATTR_STATUS]));

	dev_put(dev);
	return ret;
}

static int ieee802154_disassociate_req(struct sk_buff *skb,
		struct genl_info *info)
{
	struct net_device *dev;
	struct ieee802154_addr addr;
	int ret = -EINVAL;

	if ((!info->attrs[IEEE802154_ATTR_DEST_HW_ADDR] &&
		!info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR]) ||
	    !info->attrs[IEEE802154_ATTR_REASON])
		return -EINVAL;

	dev = ieee802154_nl_get_dev(info);
	if (!dev)
		return -ENODEV;

	if (info->attrs[IEEE802154_ATTR_DEST_HW_ADDR]) {
		addr.addr_type = IEEE802154_ADDR_LONG;
		nla_memcpy(addr.hwaddr,
				info->attrs[IEEE802154_ATTR_DEST_HW_ADDR],
				IEEE802154_ADDR_LEN);
	} else {
		addr.addr_type = IEEE802154_ADDR_SHORT;
		addr.short_addr = nla_get_u16(
				info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR]);
	}
	addr.pan_id = ieee802154_mlme_ops(dev)->get_pan_id(dev);

	ret = ieee802154_mlme_ops(dev)->disassoc_req(dev, &addr,
			nla_get_u8(info->attrs[IEEE802154_ATTR_REASON]));

	dev_put(dev);
	return ret;
}

/*
 * PANid, channel, beacon_order = 15, superframe_order = 15,
 * PAN_coordinator, battery_life_extension = 0,
 * coord_realignment = 0, security_enable = 0
*/
static int ieee802154_start_req(struct sk_buff *skb, struct genl_info *info)
{
	struct net_device *dev;
	struct ieee802154_addr addr;

	u8 channel, bcn_ord, sf_ord;
	int pan_coord, blx, coord_realign;
	int ret;

	if (!info->attrs[IEEE802154_ATTR_COORD_PAN_ID] ||
	    !info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR] ||
	    !info->attrs[IEEE802154_ATTR_CHANNEL] ||
	    !info->attrs[IEEE802154_ATTR_BCN_ORD] ||
	    !info->attrs[IEEE802154_ATTR_SF_ORD] ||
	    !info->attrs[IEEE802154_ATTR_PAN_COORD] ||
	    !info->attrs[IEEE802154_ATTR_BAT_EXT] ||
	    !info->attrs[IEEE802154_ATTR_COORD_REALIGN]
	 )
		return -EINVAL;

	dev = ieee802154_nl_get_dev(info);
	if (!dev)
		return -ENODEV;

	addr.addr_type = IEEE802154_ADDR_SHORT;
	addr.short_addr = nla_get_u16(
			info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR]);
	addr.pan_id = nla_get_u16(info->attrs[IEEE802154_ATTR_COORD_PAN_ID]);

	channel = nla_get_u8(info->attrs[IEEE802154_ATTR_CHANNEL]);
	bcn_ord = nla_get_u8(info->attrs[IEEE802154_ATTR_BCN_ORD]);
	sf_ord = nla_get_u8(info->attrs[IEEE802154_ATTR_SF_ORD]);
	pan_coord = nla_get_u8(info->attrs[IEEE802154_ATTR_PAN_COORD]);
	blx = nla_get_u8(info->attrs[IEEE802154_ATTR_BAT_EXT]);
	coord_realign = nla_get_u8(info->attrs[IEEE802154_ATTR_COORD_REALIGN]);

	ret = ieee802154_mlme_ops(dev)->start_req(dev, &addr, channel,
		bcn_ord, sf_ord, pan_coord, blx, coord_realign);

	dev_put(dev);
	return ret;
}

static int ieee802154_scan_req(struct sk_buff *skb, struct genl_info *info)
{
	struct net_device *dev;
	int ret;
	u8 type;
	u32 channels;
	u8 duration;

	if (!info->attrs[IEEE802154_ATTR_SCAN_TYPE] ||
	    !info->attrs[IEEE802154_ATTR_CHANNELS] ||
	    !info->attrs[IEEE802154_ATTR_DURATION])
		return -EINVAL;

	dev = ieee802154_nl_get_dev(info);
	if (!dev)
		return -ENODEV;

	type = nla_get_u8(info->attrs[IEEE802154_ATTR_SCAN_TYPE]);
	channels = nla_get_u32(info->attrs[IEEE802154_ATTR_CHANNELS]);
	duration = nla_get_u8(info->attrs[IEEE802154_ATTR_DURATION]);

	ret = ieee802154_mlme_ops(dev)->scan_req(dev, type, channels,
			duration);

	dev_put(dev);
	return ret;
}

#define IEEE802154_OP(_cmd, _func)			\
	{						\
		.cmd	= _cmd,				\
		.policy	= ieee802154_policy,		\
		.doit	= _func,			\
		.dumpit	= NULL,				\
		.flags	= GENL_ADMIN_PERM,		\
	}

static struct genl_ops ieee802154_coordinator_ops[] = {
	IEEE802154_OP(IEEE802154_ASSOCIATE_REQ, ieee802154_associate_req),
	IEEE802154_OP(IEEE802154_ASSOCIATE_RESP, ieee802154_associate_resp),
	IEEE802154_OP(IEEE802154_DISASSOCIATE_REQ, ieee802154_disassociate_req),
	IEEE802154_OP(IEEE802154_SCAN_REQ, ieee802154_scan_req),
	IEEE802154_OP(IEEE802154_START_REQ, ieee802154_start_req),
};

static int __init ieee802154_nl_init(void)
{
	int rc;
	int i;

	rc = genl_register_family(&ieee802154_coordinator_family);
	if (rc)
		goto fail;

	rc = genl_register_mc_group(&ieee802154_coordinator_family,
			&ieee802154_coord_mcgrp);
	if (rc)
		goto fail;

	rc = genl_register_mc_group(&ieee802154_coordinator_family,
			&ieee802154_beacon_mcgrp);
	if (rc)
		goto fail;


	for (i = 0; i < ARRAY_SIZE(ieee802154_coordinator_ops); i++) {
		rc = genl_register_ops(&ieee802154_coordinator_family,
				&ieee802154_coordinator_ops[i]);
		if (rc)
			goto fail;
	}

	return 0;

fail:
	genl_unregister_family(&ieee802154_coordinator_family);
	return rc;
}
module_init(ieee802154_nl_init);

static void __exit ieee802154_nl_exit(void)
{
	genl_unregister_family(&ieee802154_coordinator_family);
}
module_exit(ieee802154_nl_exit);
Commit	Line	Data
2c21d115 SL	1	/*
	2	* Netlink inteface for IEEE 802.15.4 stack
	3	*
	4	* Copyright 2007, 2008 Siemens AG
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2
	8	* as published by the Free Software Foundation.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License along
	16	* with this program; if not, write to the Free Software Foundation, Inc.,
	17	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	18	*
	19	* Written by:
	20	* Sergey Lapin <slapin@ossfans.org>
	21	* Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
	22	*/
	23
	24	#include <linux/kernel.h>
	25	#include <linux/if_arp.h>
	26	#include <linux/netdevice.h>
	27	#include <net/netlink.h>
	28	#include <net/genetlink.h>
	29	#include <linux/nl802154.h>
	30	#include <net/ieee802154/af_ieee802154.h>
	31	#include <net/ieee802154/nl802154.h>
	32	#include <net/ieee802154/netdevice.h>
	33
	34	static unsigned int ieee802154_seq_num;
	35
	36	static struct genl_family ieee802154_coordinator_family = {
	37	.id = GENL_ID_GENERATE,
	38	.hdrsize = 0,
	39	.name = IEEE802154_NL_NAME,
	40	.version = 1,
	41	.maxattr = IEEE802154_ATTR_MAX,
	42	};
	43
	44	static struct genl_multicast_group ieee802154_coord_mcgrp = {
	45	.name = IEEE802154_MCAST_COORD_NAME,
	46	};
	47
	48	static struct genl_multicast_group ieee802154_beacon_mcgrp = {
	49	.name = IEEE802154_MCAST_BEACON_NAME,
	50	};
	51
	52	/* Requests to userspace */
	53	static struct sk_buff *ieee802154_nl_create(int flags, u8 req)
	54	{
	55	void *hdr;
	56	struct sk_buff *msg = nlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
	57
	58	if (!msg)
	59	return NULL;
	60
	61	hdr = genlmsg_put(msg, 0, ieee802154_seq_num++,
	62	&ieee802154_coordinator_family, flags, req);
	63	if (!hdr) {
	64	nlmsg_free(msg);
65	return NULL;
66	}
67
68	return msg;
69	}
70
71	static int ieee802154_nl_finish(struct sk_buff *msg)
72	{
73	/* XXX: nlh is right at the start of msg */
74	void *hdr = genlmsg_data(NLMSG_DATA(msg->data));
75
76	if (!genlmsg_end(msg, hdr))
77	goto out;
78
79	return genlmsg_multicast(msg, 0, ieee802154_coord_mcgrp.id,
80	GFP_ATOMIC);
81	out:
82	nlmsg_free(msg);
83	return -ENOBUFS;
84	}
85
86	int ieee802154_nl_assoc_indic(struct net_device *dev,
87	struct ieee802154_addr *addr, u8 cap)
88	{
89	struct sk_buff *msg;
90
91	pr_debug("%s\n", __func__);
92
93	if (addr->addr_type != IEEE802154_ADDR_LONG) {
94	pr_err("%s: received non-long source address!\n", __func__);
95	return -EINVAL;
96	}
97
98	msg = ieee802154_nl_create(0, IEEE802154_ASSOCIATE_INDIC);
99	if (!msg)
100	return -ENOBUFS;
101
102	NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
103	NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
104	NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
105	dev->dev_addr);
106
107	NLA_PUT(msg, IEEE802154_ATTR_SRC_HW_ADDR, IEEE802154_ADDR_LEN,
108	addr->hwaddr);
109
110	NLA_PUT_U8(msg, IEEE802154_ATTR_CAPABILITY, cap);
111
112	return ieee802154_nl_finish(msg);
113
114	nla_put_failure:
115	nlmsg_free(msg);
116	return -ENOBUFS;
117	}
118	EXPORT_SYMBOL(ieee802154_nl_assoc_indic);
119
120	int ieee802154_nl_assoc_confirm(struct net_device *dev, u16 short_addr,
121	u8 status)
122	{
123	struct sk_buff *msg;
124
125	pr_debug("%s\n", __func__);
126
127	msg = ieee802154_nl_create(0, IEEE802154_ASSOCIATE_CONF);
128	if (!msg)
129	return -ENOBUFS;
130
131	NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
132	NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
133	NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
134	dev->dev_addr);
135
136	NLA_PUT_U16(msg, IEEE802154_ATTR_SHORT_ADDR, short_addr);
137	NLA_PUT_U8(msg, IEEE802154_ATTR_STATUS, status);
138
139	return ieee802154_nl_finish(msg);
140
141	nla_put_failure:
142	nlmsg_free(msg);
143	return -ENOBUFS;
144	}
145	EXPORT_SYMBOL(ieee802154_nl_assoc_confirm);
146
147	int ieee802154_nl_disassoc_indic(struct net_device *dev,
148	struct ieee802154_addr *addr, u8 reason)
149	{
150	struct sk_buff *msg;
151
152	pr_debug("%s\n", __func__);
153
154	msg = ieee802154_nl_create(0, IEEE802154_DISASSOCIATE_INDIC);
155	if (!msg)
156	return -ENOBUFS;
157
158	NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
159	NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
160	NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
161	dev->dev_addr);
162
163	if (addr->addr_type == IEEE802154_ADDR_LONG)
164	NLA_PUT(msg, IEEE802154_ATTR_SRC_HW_ADDR, IEEE802154_ADDR_LEN,
165	addr->hwaddr);
166	else
167	NLA_PUT_U16(msg, IEEE802154_ATTR_SRC_SHORT_ADDR,
168	addr->short_addr);
169
170	NLA_PUT_U8(msg, IEEE802154_ATTR_REASON, reason);
171
172	return ieee802154_nl_finish(msg);
173
174	nla_put_failure:
175	nlmsg_free(msg);
176	return -ENOBUFS;
177	}
178	EXPORT_SYMBOL(ieee802154_nl_disassoc_indic);
179
180	int ieee802154_nl_disassoc_confirm(struct net_device *dev, u8 status)
181	{
182	struct sk_buff *msg;
183
184	pr_debug("%s\n", __func__);
185
186	msg = ieee802154_nl_create(0, IEEE802154_DISASSOCIATE_CONF);
187	if (!msg)
188	return -ENOBUFS;
189
190	NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
191	NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
192	NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
193	dev->dev_addr);
194
195	NLA_PUT_U8(msg, IEEE802154_ATTR_STATUS, status);
196
197	return ieee802154_nl_finish(msg);
198
199	nla_put_failure:
200	nlmsg_free(msg);
201	return -ENOBUFS;
202	}
203	EXPORT_SYMBOL(ieee802154_nl_disassoc_confirm);
204
205	int ieee802154_nl_beacon_indic(struct net_device *dev,
206	u16 panid, u16 coord_addr)
207	{
208	struct sk_buff *msg;
209
210	pr_debug("%s\n", __func__);
211
212	msg = ieee802154_nl_create(0, IEEE802154_BEACON_NOTIFY_INDIC);
213	if (!msg)
214	return -ENOBUFS;
215
216	NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
217	NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
218	NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
219	dev->dev_addr);
220	NLA_PUT_U16(msg, IEEE802154_ATTR_COORD_SHORT_ADDR, coord_addr);
221	NLA_PUT_U16(msg, IEEE802154_ATTR_COORD_PAN_ID, panid);
222
223	return ieee802154_nl_finish(msg);
224
225	nla_put_failure:
226	nlmsg_free(msg);
227	return -ENOBUFS;
228	}
229	EXPORT_SYMBOL(ieee802154_nl_beacon_indic);
230
231	int ieee802154_nl_scan_confirm(struct net_device *dev,
232	u8 status, u8 scan_type, u32 unscanned,
233	u8 edl/ , struct list_head pan_desc_list /)
234	{
235	struct sk_buff *msg;
236
237	pr_debug("%s\n", __func__);
238
239	msg = ieee802154_nl_create(0, IEEE802154_SCAN_CONF);
240	if (!msg)
241	return -ENOBUFS;
242
243	NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
244	NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
245	NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
246	dev->dev_addr);
247
248	NLA_PUT_U8(msg, IEEE802154_ATTR_STATUS, status);
249	NLA_PUT_U8(msg, IEEE802154_ATTR_SCAN_TYPE, scan_type);
250	NLA_PUT_U32(msg, IEEE802154_ATTR_CHANNELS, unscanned);
251
252	if (edl)
253	NLA_PUT(msg, IEEE802154_ATTR_ED_LIST, 27, edl);
254
255	return ieee802154_nl_finish(msg);
256
257	nla_put_failure:
258	nlmsg_free(msg);
259	return -ENOBUFS;
260	}
261	EXPORT_SYMBOL(ieee802154_nl_scan_confirm);
262
263	/* Requests from userspace */
264	static struct net_device ieee802154_nl_get_dev(struct genl_info info)
265	{
266	struct net_device *dev;
267
268	if (info->attrs[IEEE802154_ATTR_DEV_NAME]) {
269	char name[IFNAMSIZ + 1];
270	nla_strlcpy(name, info->attrs[IEEE802154_ATTR_DEV_NAME],
271	sizeof(name));
272	dev = dev_get_by_name(&init_net, name);
273	} else if (info->attrs[IEEE802154_ATTR_DEV_INDEX])
274	dev = dev_get_by_index(&init_net,
275	nla_get_u32(info->attrs[IEEE802154_ATTR_DEV_INDEX]));
276	else
277	return NULL;
278
932c1329 DB	279	if (!dev)
	280	return NULL;
	281
2c21d115 SL	282	if (dev->type != ARPHRD_IEEE802154) {
	283	dev_put(dev);
	284	return NULL;
	285	}
	286
	287	return dev;
	288	}
	289
	290	static int ieee802154_associate_req(struct sk_buff *skb,
	291	struct genl_info *info)
	292	{
	293	struct net_device *dev;
	294	struct ieee802154_addr addr;
	295	int ret = -EINVAL;
	296
	297	if (!info->attrs[IEEE802154_ATTR_CHANNEL] \|\|
	298	!info->attrs[IEEE802154_ATTR_COORD_PAN_ID] \|\|
	299	(!info->attrs[IEEE802154_ATTR_COORD_HW_ADDR] &&
	300	!info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR]) \|\|
	301	!info->attrs[IEEE802154_ATTR_CAPABILITY])
	302	return -EINVAL;
	303
	304	dev = ieee802154_nl_get_dev(info);
	305	if (!dev)
	306	return -ENODEV;
	307
	308	if (info->attrs[IEEE802154_ATTR_COORD_HW_ADDR]) {
	309	addr.addr_type = IEEE802154_ADDR_LONG;
	310	nla_memcpy(addr.hwaddr,
	311	info->attrs[IEEE802154_ATTR_COORD_HW_ADDR],
	312	IEEE802154_ADDR_LEN);
	313	} else {
	314	addr.addr_type = IEEE802154_ADDR_SHORT;
	315	addr.short_addr = nla_get_u16(
	316	info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR]);
	317	}
	318	addr.pan_id = nla_get_u16(info->attrs[IEEE802154_ATTR_COORD_PAN_ID]);
	319
	320	ret = ieee802154_mlme_ops(dev)->assoc_req(dev, &addr,
	321	nla_get_u8(info->attrs[IEEE802154_ATTR_CHANNEL]),
	322	nla_get_u8(info->attrs[IEEE802154_ATTR_CAPABILITY]));
	323
	324	dev_put(dev);
	325	return ret;
	326	}
	327
	328	static int ieee802154_associate_resp(struct sk_buff *skb,
	329	struct genl_info *info)
	330	{
	331	struct net_device *dev;
	332	struct ieee802154_addr addr;
	333	int ret = -EINVAL;
	334
	335	if (!info->attrs[IEEE802154_ATTR_STATUS] \|\|
	336	!info->attrs[IEEE802154_ATTR_DEST_HW_ADDR] \|\|
	337	!info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR])
	338	return -EINVAL;
	339
	340	dev = ieee802154_nl_get_dev(info);
	341	if (!dev)
	342	return -ENODEV;
	343
	344	addr.addr_type = IEEE802154_ADDR_LONG;
	345	nla_memcpy(addr.hwaddr, info->attrs[IEEE802154_ATTR_DEST_HW_ADDR],
346	IEEE802154_ADDR_LEN);
347	addr.pan_id = ieee802154_mlme_ops(dev)->get_pan_id(dev);
348
349
350	ret = ieee802154_mlme_ops(dev)->assoc_resp(dev, &addr,
351	nla_get_u16(info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR]),
352	nla_get_u8(info->attrs[IEEE802154_ATTR_STATUS]));
353
354	dev_put(dev);
355	return ret;
356	}
357
358	static int ieee802154_disassociate_req(struct sk_buff *skb,
359	struct genl_info *info)
360	{
361	struct net_device *dev;
362	struct ieee802154_addr addr;
363	int ret = -EINVAL;
364
365	if ((!info->attrs[IEEE802154_ATTR_DEST_HW_ADDR] &&
366	!info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR]) \|\|
367	!info->attrs[IEEE802154_ATTR_REASON])
368	return -EINVAL;
369
370	dev = ieee802154_nl_get_dev(info);
371	if (!dev)
372	return -ENODEV;
373
374	if (info->attrs[IEEE802154_ATTR_DEST_HW_ADDR]) {
375	addr.addr_type = IEEE802154_ADDR_LONG;
376	nla_memcpy(addr.hwaddr,
377	info->attrs[IEEE802154_ATTR_DEST_HW_ADDR],
378	IEEE802154_ADDR_LEN);
379	} else {
380	addr.addr_type = IEEE802154_ADDR_SHORT;
381	addr.short_addr = nla_get_u16(
382	info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR]);
383	}
384	addr.pan_id = ieee802154_mlme_ops(dev)->get_pan_id(dev);
385
386	ret = ieee802154_mlme_ops(dev)->disassoc_req(dev, &addr,
387	nla_get_u8(info->attrs[IEEE802154_ATTR_REASON]));
388
389	dev_put(dev);
390	return ret;
391	}
392
393	/*
394	* PANid, channel, beacon_order = 15, superframe_order = 15,
395	* PAN_coordinator, battery_life_extension = 0,
396	* coord_realignment = 0, security_enable = 0
397	*/
398	static int ieee802154_start_req(struct sk_buff skb, struct genl_info info)
399	{
400	struct net_device *dev;
401	struct ieee802154_addr addr;
402
403	u8 channel, bcn_ord, sf_ord;
404	int pan_coord, blx, coord_realign;
405	int ret;
406
407	if (!info->attrs[IEEE802154_ATTR_COORD_PAN_ID] \|\|
408	!info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR] \|\|
409	!info->attrs[IEEE802154_ATTR_CHANNEL] \|\|
410	!info->attrs[IEEE802154_ATTR_BCN_ORD] \|\|
411	!info->attrs[IEEE802154_ATTR_SF_ORD] \|\|
412	!info->attrs[IEEE802154_ATTR_PAN_COORD] \|\|
413	!info->attrs[IEEE802154_ATTR_BAT_EXT] \|\|
414	!info->attrs[IEEE802154_ATTR_COORD_REALIGN]
415	)
416	return -EINVAL;
417
418	dev = ieee802154_nl_get_dev(info);
419	if (!dev)
420	return -ENODEV;
421
422	addr.addr_type = IEEE802154_ADDR_SHORT;
423	addr.short_addr = nla_get_u16(
424	info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR]);
425	addr.pan_id = nla_get_u16(info->attrs[IEEE802154_ATTR_COORD_PAN_ID]);
426
427	channel = nla_get_u8(info->attrs[IEEE802154_ATTR_CHANNEL]);
428	bcn_ord = nla_get_u8(info->attrs[IEEE802154_ATTR_BCN_ORD]);
429	sf_ord = nla_get_u8(info->attrs[IEEE802154_ATTR_SF_ORD]);
430	pan_coord = nla_get_u8(info->attrs[IEEE802154_ATTR_PAN_COORD]);
431	blx = nla_get_u8(info->attrs[IEEE802154_ATTR_BAT_EXT]);
432	coord_realign = nla_get_u8(info->attrs[IEEE802154_ATTR_COORD_REALIGN]);
433
434	ret = ieee802154_mlme_ops(dev)->start_req(dev, &addr, channel,
435	bcn_ord, sf_ord, pan_coord, blx, coord_realign);
436
437	dev_put(dev);
438	return ret;
439	}
440
441	static int ieee802154_scan_req(struct sk_buff skb, struct genl_info info)
442	{
443	struct net_device *dev;
444	int ret;
445	u8 type;
446	u32 channels;
447	u8 duration;
448
449	if (!info->attrs[IEEE802154_ATTR_SCAN_TYPE] \|\|
450	!info->attrs[IEEE802154_ATTR_CHANNELS] \|\|
451	!info->attrs[IEEE802154_ATTR_DURATION])
452	return -EINVAL;
453
454	dev = ieee802154_nl_get_dev(info);
455	if (!dev)
456	return -ENODEV;
457
458	type = nla_get_u8(info->attrs[IEEE802154_ATTR_SCAN_TYPE]);
459	channels = nla_get_u32(info->attrs[IEEE802154_ATTR_CHANNELS]);
460	duration = nla_get_u8(info->attrs[IEEE802154_ATTR_DURATION]);
461
462	ret = ieee802154_mlme_ops(dev)->scan_req(dev, type, channels,
463	duration);
464
465	dev_put(dev);
466	return ret;
467	}
468
469	#define IEEE802154_OP(_cmd, _func) \
470	{ \
471	.cmd = _cmd, \
472	.policy = ieee802154_policy, \
473	.doit = _func, \
474	.dumpit = NULL, \
475	.flags = GENL_ADMIN_PERM, \
476	}
477
478	static struct genl_ops ieee802154_coordinator_ops[] = {
479	IEEE802154_OP(IEEE802154_ASSOCIATE_REQ, ieee802154_associate_req),
480	IEEE802154_OP(IEEE802154_ASSOCIATE_RESP, ieee802154_associate_resp),
481	IEEE802154_OP(IEEE802154_DISASSOCIATE_REQ, ieee802154_disassociate_req),
482	IEEE802154_OP(IEEE802154_SCAN_REQ, ieee802154_scan_req),
483	IEEE802154_OP(IEEE802154_START_REQ, ieee802154_start_req),
484	};
485
486	static int __init ieee802154_nl_init(void)
487	{
488	int rc;
489	int i;
490
491	rc = genl_register_family(&ieee802154_coordinator_family);
492	if (rc)
493	goto fail;
494
495	rc = genl_register_mc_group(&ieee802154_coordinator_family,
496	&ieee802154_coord_mcgrp);
497	if (rc)
498	goto fail;
499
500	rc = genl_register_mc_group(&ieee802154_coordinator_family,
501	&ieee802154_beacon_mcgrp);
502	if (rc)
503	goto fail;
504
505
506	for (i = 0; i < ARRAY_SIZE(ieee802154_coordinator_ops); i++) {
507	rc = genl_register_ops(&ieee802154_coordinator_family,
508	&ieee802154_coordinator_ops[i]);
509	if (rc)
510	goto fail;
511	}
512
513	return 0;
514
515	fail:
516	genl_unregister_family(&ieee802154_coordinator_family);
517	return rc;
518	}
519	module_init(ieee802154_nl_init);
520
521	static void __exit ieee802154_nl_exit(void)
522	{
523	genl_unregister_family(&ieee802154_coordinator_family);
524	}
525	module_exit(ieee802154_nl_exit);
526