xref: /linux/net/ieee802154/nl-mac.c (revision 0be3ff0c) 
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Netlink interface for IEEE 802.15.4 stack
4  *
5  * Copyright 2007, 2008 Siemens AG
6  *
7  * Written by:
8  * Sergey Lapin <slapin@ossfans.org>
9  * Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
10  * Maxim Osipov <maxim.osipov@siemens.com>
11  */
12 
13 #include <linux/gfp.h>
14 #include <linux/kernel.h>
15 #include <linux/if_arp.h>
16 #include <linux/netdevice.h>
17 #include <linux/ieee802154.h>
18 #include <net/netlink.h>
19 #include <net/genetlink.h>
20 #include <net/sock.h>
21 #include <linux/nl802154.h>
22 #include <linux/export.h>
23 #include <net/af_ieee802154.h>
24 #include <net/ieee802154_netdev.h>
25 #include <net/cfg802154.h>
26 
27 #include "ieee802154.h"
28 
29 static int nla_put_hwaddr(struct sk_buff *msg, int type, __le64 hwaddr,
30 			  int padattr)
31 {
32 	return nla_put_u64_64bit(msg, type, swab64((__force u64)hwaddr),
33 				 padattr);
34 }
35 
36 static __le64 nla_get_hwaddr(const struct nlattr *nla)
37 {
38 	return ieee802154_devaddr_from_raw(nla_data(nla));
39 }
40 
41 static int nla_put_shortaddr(struct sk_buff *msg, int type, __le16 addr)
42 {
43 	return nla_put_u16(msg, type, le16_to_cpu(addr));
44 }
45 
46 static __le16 nla_get_shortaddr(const struct nlattr *nla)
47 {
48 	return cpu_to_le16(nla_get_u16(nla));
49 }
50 
51 static int ieee802154_nl_start_confirm(struct net_device *dev, u8 status)
52 {
53 	struct sk_buff *msg;
54 
55 	pr_debug("%s\n", __func__);
56 
57 	msg = ieee802154_nl_create(0, IEEE802154_START_CONF);
58 	if (!msg)
59 		return -ENOBUFS;
60 
61 	if (nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name) ||
62 	    nla_put_u32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex) ||
63 	    nla_put(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
64 		    dev->dev_addr) ||
65 	    nla_put_u8(msg, IEEE802154_ATTR_STATUS, status))
66 		goto nla_put_failure;
67 	return ieee802154_nl_mcast(msg, IEEE802154_COORD_MCGRP);
68 
69 nla_put_failure:
70 	nlmsg_free(msg);
71 	return -ENOBUFS;
72 }
73 
74 static int ieee802154_nl_fill_iface(struct sk_buff *msg, u32 portid,
75 				    u32 seq, int flags, struct net_device *dev)
76 {
77 	void *hdr;
78 	struct wpan_phy *phy;
79 	struct ieee802154_mlme_ops *ops;
80 	__le16 short_addr, pan_id;
81 
82 	pr_debug("%s\n", __func__);
83 
84 	hdr = genlmsg_put(msg, 0, seq, &nl802154_family, flags,
85 			  IEEE802154_LIST_IFACE);
86 	if (!hdr)
87 		goto out;
88 
89 	ops = ieee802154_mlme_ops(dev);
90 	phy = dev->ieee802154_ptr->wpan_phy;
91 	BUG_ON(!phy);
92 	get_device(&phy->dev);
93 
94 	rtnl_lock();
95 	short_addr = dev->ieee802154_ptr->short_addr;
96 	pan_id = dev->ieee802154_ptr->pan_id;
97 	rtnl_unlock();
98 
99 	if (nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name) ||
100 	    nla_put_string(msg, IEEE802154_ATTR_PHY_NAME, wpan_phy_name(phy)) ||
101 	    nla_put_u32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex) ||
102 	    nla_put(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
103 		    dev->dev_addr) ||
104 	    nla_put_shortaddr(msg, IEEE802154_ATTR_SHORT_ADDR, short_addr) ||
105 	    nla_put_shortaddr(msg, IEEE802154_ATTR_PAN_ID, pan_id))
106 		goto nla_put_failure;
107 
108 	if (ops->get_mac_params) {
109 		struct ieee802154_mac_params params;
110 
111 		rtnl_lock();
112 		ops->get_mac_params(dev, &params);
113 		rtnl_unlock();
114 
115 		if (nla_put_s8(msg, IEEE802154_ATTR_TXPOWER,
116 			       params.transmit_power / 100) ||
117 		    nla_put_u8(msg, IEEE802154_ATTR_LBT_ENABLED, params.lbt) ||
118 		    nla_put_u8(msg, IEEE802154_ATTR_CCA_MODE,
119 			       params.cca.mode) ||
120 		    nla_put_s32(msg, IEEE802154_ATTR_CCA_ED_LEVEL,
121 				params.cca_ed_level / 100) ||
122 		    nla_put_u8(msg, IEEE802154_ATTR_CSMA_RETRIES,
123 			       params.csma_retries) ||
124 		    nla_put_u8(msg, IEEE802154_ATTR_CSMA_MIN_BE,
125 			       params.min_be) ||
126 		    nla_put_u8(msg, IEEE802154_ATTR_CSMA_MAX_BE,
127 			       params.max_be) ||
128 		    nla_put_s8(msg, IEEE802154_ATTR_FRAME_RETRIES,
129 			       params.frame_retries))
130 			goto nla_put_failure;
131 	}
132 
133 	wpan_phy_put(phy);
134 	genlmsg_end(msg, hdr);
135 	return 0;
136 
137 nla_put_failure:
138 	wpan_phy_put(phy);
139 	genlmsg_cancel(msg, hdr);
140 out:
141 	return -EMSGSIZE;
142 }
143 
144 /* Requests from userspace */
145 static struct net_device *ieee802154_nl_get_dev(struct genl_info *info)
146 {
147 	struct net_device *dev;
148 
149 	if (info->attrs[IEEE802154_ATTR_DEV_NAME]) {
150 		char name[IFNAMSIZ + 1];
151 
152 		nla_strscpy(name, info->attrs[IEEE802154_ATTR_DEV_NAME],
153 			    sizeof(name));
154 		dev = dev_get_by_name(&init_net, name);
155 	} else if (info->attrs[IEEE802154_ATTR_DEV_INDEX]) {
156 		dev = dev_get_by_index(&init_net,
157 			nla_get_u32(info->attrs[IEEE802154_ATTR_DEV_INDEX]));
158 	} else {
159 		return NULL;
160 	}
161 
162 	if (!dev)
163 		return NULL;
164 
165 	if (dev->type != ARPHRD_IEEE802154) {
166 		dev_put(dev);
167 		return NULL;
168 	}
169 
170 	return dev;
171 }
172 
173 int ieee802154_associate_req(struct sk_buff *skb, struct genl_info *info)
174 {
175 	struct net_device *dev;
176 	struct ieee802154_addr addr;
177 	u8 page;
178 	int ret = -EOPNOTSUPP;
179 
180 	if (!info->attrs[IEEE802154_ATTR_CHANNEL] ||
181 	    !info->attrs[IEEE802154_ATTR_COORD_PAN_ID] ||
182 	    (!info->attrs[IEEE802154_ATTR_COORD_HW_ADDR] &&
183 		!info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR]) ||
184 	    !info->attrs[IEEE802154_ATTR_CAPABILITY])
185 		return -EINVAL;
186 
187 	dev = ieee802154_nl_get_dev(info);
188 	if (!dev)
189 		return -ENODEV;
190 	if (!ieee802154_mlme_ops(dev)->assoc_req)
191 		goto out;
192 
193 	if (info->attrs[IEEE802154_ATTR_COORD_HW_ADDR]) {
194 		addr.mode = IEEE802154_ADDR_LONG;
195 		addr.extended_addr = nla_get_hwaddr(
196 				info->attrs[IEEE802154_ATTR_COORD_HW_ADDR]);
197 	} else {
198 		addr.mode = IEEE802154_ADDR_SHORT;
199 		addr.short_addr = nla_get_shortaddr(
200 				info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR]);
201 	}
202 	addr.pan_id = nla_get_shortaddr(
203 			info->attrs[IEEE802154_ATTR_COORD_PAN_ID]);
204 
205 	if (info->attrs[IEEE802154_ATTR_PAGE])
206 		page = nla_get_u8(info->attrs[IEEE802154_ATTR_PAGE]);
207 	else
208 		page = 0;
209 
210 	ret = ieee802154_mlme_ops(dev)->assoc_req(dev, &addr,
211 			nla_get_u8(info->attrs[IEEE802154_ATTR_CHANNEL]),
212 			page,
213 			nla_get_u8(info->attrs[IEEE802154_ATTR_CAPABILITY]));
214 
215 out:
216 	dev_put(dev);
217 	return ret;
218 }
219 
220 int ieee802154_associate_resp(struct sk_buff *skb, struct genl_info *info)
221 {
222 	struct net_device *dev;
223 	struct ieee802154_addr addr;
224 	int ret = -EOPNOTSUPP;
225 
226 	if (!info->attrs[IEEE802154_ATTR_STATUS] ||
227 	    !info->attrs[IEEE802154_ATTR_DEST_HW_ADDR] ||
228 	    !info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR])
229 		return -EINVAL;
230 
231 	dev = ieee802154_nl_get_dev(info);
232 	if (!dev)
233 		return -ENODEV;
234 	if (!ieee802154_mlme_ops(dev)->assoc_resp)
235 		goto out;
236 
237 	addr.mode = IEEE802154_ADDR_LONG;
238 	addr.extended_addr = nla_get_hwaddr(
239 			info->attrs[IEEE802154_ATTR_DEST_HW_ADDR]);
240 	rtnl_lock();
241 	addr.pan_id = dev->ieee802154_ptr->pan_id;
242 	rtnl_unlock();
243 
244 	ret = ieee802154_mlme_ops(dev)->assoc_resp(dev, &addr,
245 		nla_get_shortaddr(info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR]),
246 		nla_get_u8(info->attrs[IEEE802154_ATTR_STATUS]));
247 
248 out:
249 	dev_put(dev);
250 	return ret;
251 }
252 
253 int ieee802154_disassociate_req(struct sk_buff *skb, struct genl_info *info)
254 {
255 	struct net_device *dev;
256 	struct ieee802154_addr addr;
257 	int ret = -EOPNOTSUPP;
258 
259 	if ((!info->attrs[IEEE802154_ATTR_DEST_HW_ADDR] &&
260 	    !info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR]) ||
261 	    !info->attrs[IEEE802154_ATTR_REASON])
262 		return -EINVAL;
263 
264 	dev = ieee802154_nl_get_dev(info);
265 	if (!dev)
266 		return -ENODEV;
267 	if (!ieee802154_mlme_ops(dev)->disassoc_req)
268 		goto out;
269 
270 	if (info->attrs[IEEE802154_ATTR_DEST_HW_ADDR]) {
271 		addr.mode = IEEE802154_ADDR_LONG;
272 		addr.extended_addr = nla_get_hwaddr(
273 				info->attrs[IEEE802154_ATTR_DEST_HW_ADDR]);
274 	} else {
275 		addr.mode = IEEE802154_ADDR_SHORT;
276 		addr.short_addr = nla_get_shortaddr(
277 				info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR]);
278 	}
279 	rtnl_lock();
280 	addr.pan_id = dev->ieee802154_ptr->pan_id;
281 	rtnl_unlock();
282 
283 	ret = ieee802154_mlme_ops(dev)->disassoc_req(dev, &addr,
284 			nla_get_u8(info->attrs[IEEE802154_ATTR_REASON]));
285 
286 out:
287 	dev_put(dev);
288 	return ret;
289 }
290 
291 /* PANid, channel, beacon_order = 15, superframe_order = 15,
292  * PAN_coordinator, battery_life_extension = 0,
293  * coord_realignment = 0, security_enable = 0
294 */
295 int ieee802154_start_req(struct sk_buff *skb, struct genl_info *info)
296 {
297 	struct net_device *dev;
298 	struct ieee802154_addr addr;
299 
300 	u8 channel, bcn_ord, sf_ord;
301 	u8 page;
302 	int pan_coord, blx, coord_realign;
303 	int ret = -EBUSY;
304 
305 	if (!info->attrs[IEEE802154_ATTR_COORD_PAN_ID] ||
306 	    !info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR] ||
307 	    !info->attrs[IEEE802154_ATTR_CHANNEL] ||
308 	    !info->attrs[IEEE802154_ATTR_BCN_ORD] ||
309 	    !info->attrs[IEEE802154_ATTR_SF_ORD] ||
310 	    !info->attrs[IEEE802154_ATTR_PAN_COORD] ||
311 	    !info->attrs[IEEE802154_ATTR_BAT_EXT] ||
312 	    !info->attrs[IEEE802154_ATTR_COORD_REALIGN]
313 	 )
314 		return -EINVAL;
315 
316 	dev = ieee802154_nl_get_dev(info);
317 	if (!dev)
318 		return -ENODEV;
319 
320 	if (netif_running(dev))
321 		goto out;
322 
323 	if (!ieee802154_mlme_ops(dev)->start_req) {
324 		ret = -EOPNOTSUPP;
325 		goto out;
326 	}
327 
328 	addr.mode = IEEE802154_ADDR_SHORT;
329 	addr.short_addr = nla_get_shortaddr(
330 			info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR]);
331 	addr.pan_id = nla_get_shortaddr(
332 			info->attrs[IEEE802154_ATTR_COORD_PAN_ID]);
333 
334 	channel = nla_get_u8(info->attrs[IEEE802154_ATTR_CHANNEL]);
335 	bcn_ord = nla_get_u8(info->attrs[IEEE802154_ATTR_BCN_ORD]);
336 	sf_ord = nla_get_u8(info->attrs[IEEE802154_ATTR_SF_ORD]);
337 	pan_coord = nla_get_u8(info->attrs[IEEE802154_ATTR_PAN_COORD]);
338 	blx = nla_get_u8(info->attrs[IEEE802154_ATTR_BAT_EXT]);
339 	coord_realign = nla_get_u8(info->attrs[IEEE802154_ATTR_COORD_REALIGN]);
340 
341 	if (info->attrs[IEEE802154_ATTR_PAGE])
342 		page = nla_get_u8(info->attrs[IEEE802154_ATTR_PAGE]);
343 	else
344 		page = 0;
345 
346 	if (addr.short_addr == cpu_to_le16(IEEE802154_ADDR_BROADCAST)) {
347 		ieee802154_nl_start_confirm(dev, IEEE802154_NO_SHORT_ADDRESS);
348 		dev_put(dev);
349 		return -EINVAL;
350 	}
351 
352 	rtnl_lock();
353 	ret = ieee802154_mlme_ops(dev)->start_req(dev, &addr, channel, page,
354 		bcn_ord, sf_ord, pan_coord, blx, coord_realign);
355 	rtnl_unlock();
356 
357 	/* FIXME: add validation for unused parameters to be sane
358 	 * for SoftMAC
359 	 */
360 	ieee802154_nl_start_confirm(dev, IEEE802154_SUCCESS);
361 
362 out:
363 	dev_put(dev);
364 	return ret;
365 }
366 
367 int ieee802154_scan_req(struct sk_buff *skb, struct genl_info *info)
368 {
369 	struct net_device *dev;
370 	int ret = -EOPNOTSUPP;
371 	u8 type;
372 	u32 channels;
373 	u8 duration;
374 	u8 page;
375 
376 	if (!info->attrs[IEEE802154_ATTR_SCAN_TYPE] ||
377 	    !info->attrs[IEEE802154_ATTR_CHANNELS] ||
378 	    !info->attrs[IEEE802154_ATTR_DURATION])
379 		return -EINVAL;
380 
381 	dev = ieee802154_nl_get_dev(info);
382 	if (!dev)
383 		return -ENODEV;
384 	if (!ieee802154_mlme_ops(dev)->scan_req)
385 		goto out;
386 
387 	type = nla_get_u8(info->attrs[IEEE802154_ATTR_SCAN_TYPE]);
388 	channels = nla_get_u32(info->attrs[IEEE802154_ATTR_CHANNELS]);
389 	duration = nla_get_u8(info->attrs[IEEE802154_ATTR_DURATION]);
390 
391 	if (info->attrs[IEEE802154_ATTR_PAGE])
392 		page = nla_get_u8(info->attrs[IEEE802154_ATTR_PAGE]);
393 	else
394 		page = 0;
395 
396 	ret = ieee802154_mlme_ops(dev)->scan_req(dev, type, channels,
397 						 page, duration);
398 
399 out:
400 	dev_put(dev);
401 	return ret;
402 }
403 
404 int ieee802154_list_iface(struct sk_buff *skb, struct genl_info *info)
405 {
406 	/* Request for interface name, index, type, IEEE address,
407 	 * PAN Id, short address
408 	 */
409 	struct sk_buff *msg;
410 	struct net_device *dev = NULL;
411 	int rc = -ENOBUFS;
412 
413 	pr_debug("%s\n", __func__);
414 
415 	dev = ieee802154_nl_get_dev(info);
416 	if (!dev)
417 		return -ENODEV;
418 
419 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
420 	if (!msg)
421 		goto out_dev;
422 
423 	rc = ieee802154_nl_fill_iface(msg, info->snd_portid, info->snd_seq,
424 				      0, dev);
425 	if (rc < 0)
426 		goto out_free;
427 
428 	dev_put(dev);
429 
430 	return genlmsg_reply(msg, info);
431 out_free:
432 	nlmsg_free(msg);
433 out_dev:
434 	dev_put(dev);
435 	return rc;
436 }
437 
438 int ieee802154_dump_iface(struct sk_buff *skb, struct netlink_callback *cb)
439 {
440 	struct net *net = sock_net(skb->sk);
441 	struct net_device *dev;
442 	int idx;
443 	int s_idx = cb->args[0];
444 
445 	pr_debug("%s\n", __func__);
446 
447 	idx = 0;
448 	for_each_netdev(net, dev) {
449 		if (idx < s_idx || dev->type != ARPHRD_IEEE802154)
450 			goto cont;
451 
452 		if (ieee802154_nl_fill_iface(skb, NETLINK_CB(cb->skb).portid,
453 					     cb->nlh->nlmsg_seq,
454 					     NLM_F_MULTI, dev) < 0)
455 			break;
456 cont:
457 		idx++;
458 	}
459 	cb->args[0] = idx;
460 
461 	return skb->len;
462 }
463 
464 int ieee802154_set_macparams(struct sk_buff *skb, struct genl_info *info)
465 {
466 	struct net_device *dev = NULL;
467 	struct ieee802154_mlme_ops *ops;
468 	struct ieee802154_mac_params params;
469 	struct wpan_phy *phy;
470 	int rc = -EINVAL;
471 
472 	pr_debug("%s\n", __func__);
473 
474 	dev = ieee802154_nl_get_dev(info);
475 	if (!dev)
476 		return -ENODEV;
477 
478 	ops = ieee802154_mlme_ops(dev);
479 
480 	if (!ops->get_mac_params || !ops->set_mac_params) {
481 		rc = -EOPNOTSUPP;
482 		goto out;
483 	}
484 
485 	if (netif_running(dev)) {
486 		rc = -EBUSY;
487 		goto out;
488 	}
489 
490 	if (!info->attrs[IEEE802154_ATTR_LBT_ENABLED] &&
491 	    !info->attrs[IEEE802154_ATTR_CCA_MODE] &&
492 	    !info->attrs[IEEE802154_ATTR_CCA_ED_LEVEL] &&
493 	    !info->attrs[IEEE802154_ATTR_CSMA_RETRIES] &&
494 	    !info->attrs[IEEE802154_ATTR_CSMA_MIN_BE] &&
495 	    !info->attrs[IEEE802154_ATTR_CSMA_MAX_BE] &&
496 	    !info->attrs[IEEE802154_ATTR_FRAME_RETRIES])
497 		goto out;
498 
499 	phy = dev->ieee802154_ptr->wpan_phy;
500 	get_device(&phy->dev);
501 
502 	rtnl_lock();
503 	ops->get_mac_params(dev, &params);
504 
505 	if (info->attrs[IEEE802154_ATTR_TXPOWER])
506 		params.transmit_power = nla_get_s8(info->attrs[IEEE802154_ATTR_TXPOWER]) * 100;
507 
508 	if (info->attrs[IEEE802154_ATTR_LBT_ENABLED])
509 		params.lbt = nla_get_u8(info->attrs[IEEE802154_ATTR_LBT_ENABLED]);
510 
511 	if (info->attrs[IEEE802154_ATTR_CCA_MODE])
512 		params.cca.mode = nla_get_u8(info->attrs[IEEE802154_ATTR_CCA_MODE]);
513 
514 	if (info->attrs[IEEE802154_ATTR_CCA_ED_LEVEL])
515 		params.cca_ed_level = nla_get_s32(info->attrs[IEEE802154_ATTR_CCA_ED_LEVEL]) * 100;
516 
517 	if (info->attrs[IEEE802154_ATTR_CSMA_RETRIES])
518 		params.csma_retries = nla_get_u8(info->attrs[IEEE802154_ATTR_CSMA_RETRIES]);
519 
520 	if (info->attrs[IEEE802154_ATTR_CSMA_MIN_BE])
521 		params.min_be = nla_get_u8(info->attrs[IEEE802154_ATTR_CSMA_MIN_BE]);
522 
523 	if (info->attrs[IEEE802154_ATTR_CSMA_MAX_BE])
524 		params.max_be = nla_get_u8(info->attrs[IEEE802154_ATTR_CSMA_MAX_BE]);
525 
526 	if (info->attrs[IEEE802154_ATTR_FRAME_RETRIES])
527 		params.frame_retries = nla_get_s8(info->attrs[IEEE802154_ATTR_FRAME_RETRIES]);
528 
529 	rc = ops->set_mac_params(dev, &params);
530 	rtnl_unlock();
531 
532 	wpan_phy_put(phy);
533 	dev_put(dev);
534 
535 	return 0;
536 
537 out:
538 	dev_put(dev);
539 	return rc;
540 }
541 
542 static int
543 ieee802154_llsec_parse_key_id(struct genl_info *info,
544 			      struct ieee802154_llsec_key_id *desc)
545 {
546 	memset(desc, 0, sizeof(*desc));
547 
548 	if (!info->attrs[IEEE802154_ATTR_LLSEC_KEY_MODE])
549 		return -EINVAL;
550 
551 	desc->mode = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_KEY_MODE]);
552 
553 	if (desc->mode == IEEE802154_SCF_KEY_IMPLICIT) {
554 		if (!info->attrs[IEEE802154_ATTR_PAN_ID])
555 			return -EINVAL;
556 
557 		desc->device_addr.pan_id = nla_get_shortaddr(info->attrs[IEEE802154_ATTR_PAN_ID]);
558 
559 		if (info->attrs[IEEE802154_ATTR_SHORT_ADDR]) {
560 			desc->device_addr.mode = IEEE802154_ADDR_SHORT;
561 			desc->device_addr.short_addr = nla_get_shortaddr(info->attrs[IEEE802154_ATTR_SHORT_ADDR]);
562 		} else {
563 			if (!info->attrs[IEEE802154_ATTR_HW_ADDR])
564 				return -EINVAL;
565 
566 			desc->device_addr.mode = IEEE802154_ADDR_LONG;
567 			desc->device_addr.extended_addr = nla_get_hwaddr(info->attrs[IEEE802154_ATTR_HW_ADDR]);
568 		}
569 	}
570 
571 	if (desc->mode != IEEE802154_SCF_KEY_IMPLICIT &&
572 	    !info->attrs[IEEE802154_ATTR_LLSEC_KEY_ID])
573 		return -EINVAL;
574 
575 	if (desc->mode == IEEE802154_SCF_KEY_SHORT_INDEX &&
576 	    !info->attrs[IEEE802154_ATTR_LLSEC_KEY_SOURCE_SHORT])
577 		return -EINVAL;
578 
579 	if (desc->mode == IEEE802154_SCF_KEY_HW_INDEX &&
580 	    !info->attrs[IEEE802154_ATTR_LLSEC_KEY_SOURCE_EXTENDED])
581 		return -EINVAL;
582 
583 	if (desc->mode != IEEE802154_SCF_KEY_IMPLICIT)
584 		desc->id = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_KEY_ID]);
585 
586 	switch (desc->mode) {
587 	case IEEE802154_SCF_KEY_SHORT_INDEX:
588 	{
589 		u32 source = nla_get_u32(info->attrs[IEEE802154_ATTR_LLSEC_KEY_SOURCE_SHORT]);
590 
591 		desc->short_source = cpu_to_le32(source);
592 		break;
593 	}
594 	case IEEE802154_SCF_KEY_HW_INDEX:
595 		desc->extended_source = nla_get_hwaddr(info->attrs[IEEE802154_ATTR_LLSEC_KEY_SOURCE_EXTENDED]);
596 		break;
597 	}
598 
599 	return 0;
600 }
601 
602 static int
603 ieee802154_llsec_fill_key_id(struct sk_buff *msg,
604 			     const struct ieee802154_llsec_key_id *desc)
605 {
606 	if (nla_put_u8(msg, IEEE802154_ATTR_LLSEC_KEY_MODE, desc->mode))
607 		return -EMSGSIZE;
608 
609 	if (desc->mode == IEEE802154_SCF_KEY_IMPLICIT) {
610 		if (nla_put_shortaddr(msg, IEEE802154_ATTR_PAN_ID,
611 				      desc->device_addr.pan_id))
612 			return -EMSGSIZE;
613 
614 		if (desc->device_addr.mode == IEEE802154_ADDR_SHORT &&
615 		    nla_put_shortaddr(msg, IEEE802154_ATTR_SHORT_ADDR,
616 				      desc->device_addr.short_addr))
617 			return -EMSGSIZE;
618 
619 		if (desc->device_addr.mode == IEEE802154_ADDR_LONG &&
620 		    nla_put_hwaddr(msg, IEEE802154_ATTR_HW_ADDR,
621 				   desc->device_addr.extended_addr,
622 				   IEEE802154_ATTR_PAD))
623 			return -EMSGSIZE;
624 	}
625 
626 	if (desc->mode != IEEE802154_SCF_KEY_IMPLICIT &&
627 	    nla_put_u8(msg, IEEE802154_ATTR_LLSEC_KEY_ID, desc->id))
628 		return -EMSGSIZE;
629 
630 	if (desc->mode == IEEE802154_SCF_KEY_SHORT_INDEX &&
631 	    nla_put_u32(msg, IEEE802154_ATTR_LLSEC_KEY_SOURCE_SHORT,
632 			le32_to_cpu(desc->short_source)))
633 		return -EMSGSIZE;
634 
635 	if (desc->mode == IEEE802154_SCF_KEY_HW_INDEX &&
636 	    nla_put_hwaddr(msg, IEEE802154_ATTR_LLSEC_KEY_SOURCE_EXTENDED,
637 			   desc->extended_source, IEEE802154_ATTR_PAD))
638 		return -EMSGSIZE;
639 
640 	return 0;
641 }
642 
643 int ieee802154_llsec_getparams(struct sk_buff *skb, struct genl_info *info)
644 {
645 	struct sk_buff *msg;
646 	struct net_device *dev = NULL;
647 	int rc = -ENOBUFS;
648 	struct ieee802154_mlme_ops *ops;
649 	void *hdr;
650 	struct ieee802154_llsec_params params;
651 
652 	pr_debug("%s\n", __func__);
653 
654 	dev = ieee802154_nl_get_dev(info);
655 	if (!dev)
656 		return -ENODEV;
657 
658 	ops = ieee802154_mlme_ops(dev);
659 	if (!ops->llsec) {
660 		rc = -EOPNOTSUPP;
661 		goto out_dev;
662 	}
663 
664 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
665 	if (!msg)
666 		goto out_dev;
667 
668 	hdr = genlmsg_put(msg, 0, info->snd_seq, &nl802154_family, 0,
669 			  IEEE802154_LLSEC_GETPARAMS);
670 	if (!hdr)
671 		goto out_free;
672 
673 	rc = ops->llsec->get_params(dev, &params);
674 	if (rc < 0)
675 		goto out_free;
676 
677 	if (nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name) ||
678 	    nla_put_u32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex) ||
679 	    nla_put_u8(msg, IEEE802154_ATTR_LLSEC_ENABLED, params.enabled) ||
680 	    nla_put_u8(msg, IEEE802154_ATTR_LLSEC_SECLEVEL, params.out_level) ||
681 	    nla_put_u32(msg, IEEE802154_ATTR_LLSEC_FRAME_COUNTER,
682 			be32_to_cpu(params.frame_counter)) ||
683 	    ieee802154_llsec_fill_key_id(msg, &params.out_key)) {
684 		rc = -ENOBUFS;
685 		goto out_free;
686 	}
687 
688 	dev_put(dev);
689 
690 	return ieee802154_nl_reply(msg, info);
691 out_free:
692 	nlmsg_free(msg);
693 out_dev:
694 	dev_put(dev);
695 	return rc;
696 }
697 
698 int ieee802154_llsec_setparams(struct sk_buff *skb, struct genl_info *info)
699 {
700 	struct net_device *dev = NULL;
701 	int rc = -EINVAL;
702 	struct ieee802154_mlme_ops *ops;
703 	struct ieee802154_llsec_params params;
704 	int changed = 0;
705 
706 	pr_debug("%s\n", __func__);
707 
708 	dev = ieee802154_nl_get_dev(info);
709 	if (!dev)
710 		return -ENODEV;
711 
712 	if (!info->attrs[IEEE802154_ATTR_LLSEC_ENABLED] &&
713 	    !info->attrs[IEEE802154_ATTR_LLSEC_KEY_MODE] &&
714 	    !info->attrs[IEEE802154_ATTR_LLSEC_SECLEVEL])
715 		goto out;
716 
717 	ops = ieee802154_mlme_ops(dev);
718 	if (!ops->llsec) {
719 		rc = -EOPNOTSUPP;
720 		goto out;
721 	}
722 
723 	if (info->attrs[IEEE802154_ATTR_LLSEC_SECLEVEL] &&
724 	    nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_SECLEVEL]) > 7)
725 		goto out;
726 
727 	if (info->attrs[IEEE802154_ATTR_LLSEC_ENABLED]) {
728 		params.enabled = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_ENABLED]);
729 		changed |= IEEE802154_LLSEC_PARAM_ENABLED;
730 	}
731 
732 	if (info->attrs[IEEE802154_ATTR_LLSEC_KEY_MODE]) {
733 		if (ieee802154_llsec_parse_key_id(info, &params.out_key))
734 			goto out;
735 
736 		changed |= IEEE802154_LLSEC_PARAM_OUT_KEY;
737 	}
738 
739 	if (info->attrs[IEEE802154_ATTR_LLSEC_SECLEVEL]) {
740 		params.out_level = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_SECLEVEL]);
741 		changed |= IEEE802154_LLSEC_PARAM_OUT_LEVEL;
742 	}
743 
744 	if (info->attrs[IEEE802154_ATTR_LLSEC_FRAME_COUNTER]) {
745 		u32 fc = nla_get_u32(info->attrs[IEEE802154_ATTR_LLSEC_FRAME_COUNTER]);
746 
747 		params.frame_counter = cpu_to_be32(fc);
748 		changed |= IEEE802154_LLSEC_PARAM_FRAME_COUNTER;
749 	}
750 
751 	rc = ops->llsec->set_params(dev, &params, changed);
752 
753 	dev_put(dev);
754 
755 	return rc;
756 out:
757 	dev_put(dev);
758 	return rc;
759 }
760 
761 struct llsec_dump_data {
762 	struct sk_buff *skb;
763 	int s_idx, s_idx2;
764 	int portid;
765 	int nlmsg_seq;
766 	struct net_device *dev;
767 	struct ieee802154_mlme_ops *ops;
768 	struct ieee802154_llsec_table *table;
769 };
770 
771 static int
772 ieee802154_llsec_dump_table(struct sk_buff *skb, struct netlink_callback *cb,
773 			    int (*step)(struct llsec_dump_data *))
774 {
775 	struct net *net = sock_net(skb->sk);
776 	struct net_device *dev;
777 	struct llsec_dump_data data;
778 	int idx = 0;
779 	int first_dev = cb->args[0];
780 	int rc;
781 
782 	for_each_netdev(net, dev) {
783 		if (idx < first_dev || dev->type != ARPHRD_IEEE802154)
784 			goto skip;
785 
786 		data.ops = ieee802154_mlme_ops(dev);
787 		if (!data.ops->llsec)
788 			goto skip;
789 
790 		data.skb = skb;
791 		data.s_idx = cb->args[1];
792 		data.s_idx2 = cb->args[2];
793 		data.dev = dev;
794 		data.portid = NETLINK_CB(cb->skb).portid;
795 		data.nlmsg_seq = cb->nlh->nlmsg_seq;
796 
797 		data.ops->llsec->lock_table(dev);
798 		data.ops->llsec->get_table(data.dev, &data.table);
799 		rc = step(&data);
800 		data.ops->llsec->unlock_table(dev);
801 
802 		if (rc < 0)
803 			break;
804 
805 skip:
806 		idx++;
807 	}
808 	cb->args[0] = idx;
809 
810 	return skb->len;
811 }
812 
813 static int
814 ieee802154_nl_llsec_change(struct sk_buff *skb, struct genl_info *info,
815 			   int (*fn)(struct net_device*, struct genl_info*))
816 {
817 	struct net_device *dev = NULL;
818 	int rc = -EINVAL;
819 
820 	dev = ieee802154_nl_get_dev(info);
821 	if (!dev)
822 		return -ENODEV;
823 
824 	if (!ieee802154_mlme_ops(dev)->llsec)
825 		rc = -EOPNOTSUPP;
826 	else
827 		rc = fn(dev, info);
828 
829 	dev_put(dev);
830 	return rc;
831 }
832 
833 static int
834 ieee802154_llsec_parse_key(struct genl_info *info,
835 			   struct ieee802154_llsec_key *key)
836 {
837 	u8 frames;
838 	u32 commands[256 / 32];
839 
840 	memset(key, 0, sizeof(*key));
841 
842 	if (!info->attrs[IEEE802154_ATTR_LLSEC_KEY_USAGE_FRAME_TYPES] ||
843 	    !info->attrs[IEEE802154_ATTR_LLSEC_KEY_BYTES])
844 		return -EINVAL;
845 
846 	frames = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_KEY_USAGE_FRAME_TYPES]);
847 	if ((frames & BIT(IEEE802154_FC_TYPE_MAC_CMD)) &&
848 	    !info->attrs[IEEE802154_ATTR_LLSEC_KEY_USAGE_COMMANDS])
849 		return -EINVAL;
850 
851 	if (info->attrs[IEEE802154_ATTR_LLSEC_KEY_USAGE_COMMANDS]) {
852 		nla_memcpy(commands,
853 			   info->attrs[IEEE802154_ATTR_LLSEC_KEY_USAGE_COMMANDS],
854 			   256 / 8);
855 
856 		if (commands[0] || commands[1] || commands[2] || commands[3] ||
857 		    commands[4] || commands[5] || commands[6] ||
858 		    commands[7] >= BIT(IEEE802154_CMD_GTS_REQ + 1))
859 			return -EINVAL;
860 
861 		key->cmd_frame_ids = commands[7];
862 	}
863 
864 	key->frame_types = frames;
865 
866 	nla_memcpy(key->key, info->attrs[IEEE802154_ATTR_LLSEC_KEY_BYTES],
867 		   IEEE802154_LLSEC_KEY_SIZE);
868 
869 	return 0;
870 }
871 
872 static int llsec_add_key(struct net_device *dev, struct genl_info *info)
873 {
874 	struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
875 	struct ieee802154_llsec_key key;
876 	struct ieee802154_llsec_key_id id;
877 
878 	if (ieee802154_llsec_parse_key(info, &key) ||
879 	    ieee802154_llsec_parse_key_id(info, &id))
880 		return -EINVAL;
881 
882 	return ops->llsec->add_key(dev, &id, &key);
883 }
884 
885 int ieee802154_llsec_add_key(struct sk_buff *skb, struct genl_info *info)
886 {
887 	if ((info->nlhdr->nlmsg_flags & (NLM_F_CREATE | NLM_F_EXCL)) !=
888 	    (NLM_F_CREATE | NLM_F_EXCL))
889 		return -EINVAL;
890 
891 	return ieee802154_nl_llsec_change(skb, info, llsec_add_key);
892 }
893 
894 static int llsec_remove_key(struct net_device *dev, struct genl_info *info)
895 {
896 	struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
897 	struct ieee802154_llsec_key_id id;
898 
899 	if (ieee802154_llsec_parse_key_id(info, &id))
900 		return -EINVAL;
901 
902 	return ops->llsec->del_key(dev, &id);
903 }
904 
905 int ieee802154_llsec_del_key(struct sk_buff *skb, struct genl_info *info)
906 {
907 	return ieee802154_nl_llsec_change(skb, info, llsec_remove_key);
908 }
909 
910 static int
911 ieee802154_nl_fill_key(struct sk_buff *msg, u32 portid, u32 seq,
912 		       const struct ieee802154_llsec_key_entry *key,
913 		       const struct net_device *dev)
914 {
915 	void *hdr;
916 	u32 commands[256 / 32];
917 
918 	hdr = genlmsg_put(msg, 0, seq, &nl802154_family, NLM_F_MULTI,
919 			  IEEE802154_LLSEC_LIST_KEY);
920 	if (!hdr)
921 		goto out;
922 
923 	if (nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name) ||
924 	    nla_put_u32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex) ||
925 	    ieee802154_llsec_fill_key_id(msg, &key->id) ||
926 	    nla_put_u8(msg, IEEE802154_ATTR_LLSEC_KEY_USAGE_FRAME_TYPES,
927 		       key->key->frame_types))
928 		goto nla_put_failure;
929 
930 	if (key->key->frame_types & BIT(IEEE802154_FC_TYPE_MAC_CMD)) {
931 		memset(commands, 0, sizeof(commands));
932 		commands[7] = key->key->cmd_frame_ids;
933 		if (nla_put(msg, IEEE802154_ATTR_LLSEC_KEY_USAGE_COMMANDS,
934 			    sizeof(commands), commands))
935 			goto nla_put_failure;
936 	}
937 
938 	if (nla_put(msg, IEEE802154_ATTR_LLSEC_KEY_BYTES,
939 		    IEEE802154_LLSEC_KEY_SIZE, key->key->key))
940 		goto nla_put_failure;
941 
942 	genlmsg_end(msg, hdr);
943 	return 0;
944 
945 nla_put_failure:
946 	genlmsg_cancel(msg, hdr);
947 out:
948 	return -EMSGSIZE;
949 }
950 
951 static int llsec_iter_keys(struct llsec_dump_data *data)
952 {
953 	struct ieee802154_llsec_key_entry *pos;
954 	int rc = 0, idx = 0;
955 
956 	list_for_each_entry(pos, &data->table->keys, list) {
957 		if (idx++ < data->s_idx)
958 			continue;
959 
960 		if (ieee802154_nl_fill_key(data->skb, data->portid,
961 					   data->nlmsg_seq, pos, data->dev)) {
962 			rc = -EMSGSIZE;
963 			break;
964 		}
965 
966 		data->s_idx++;
967 	}
968 
969 	return rc;
970 }
971 
972 int ieee802154_llsec_dump_keys(struct sk_buff *skb, struct netlink_callback *cb)
973 {
974 	return ieee802154_llsec_dump_table(skb, cb, llsec_iter_keys);
975 }
976 
977 static int
978 llsec_parse_dev(struct genl_info *info,
979 		struct ieee802154_llsec_device *dev)
980 {
981 	memset(dev, 0, sizeof(*dev));
982 
983 	if (!info->attrs[IEEE802154_ATTR_LLSEC_FRAME_COUNTER] ||
984 	    !info->attrs[IEEE802154_ATTR_HW_ADDR] ||
985 	    !info->attrs[IEEE802154_ATTR_LLSEC_DEV_OVERRIDE] ||
986 	    !info->attrs[IEEE802154_ATTR_LLSEC_DEV_KEY_MODE] ||
987 	    (!!info->attrs[IEEE802154_ATTR_PAN_ID] !=
988 	     !!info->attrs[IEEE802154_ATTR_SHORT_ADDR]))
989 		return -EINVAL;
990 
991 	if (info->attrs[IEEE802154_ATTR_PAN_ID]) {
992 		dev->pan_id = nla_get_shortaddr(info->attrs[IEEE802154_ATTR_PAN_ID]);
993 		dev->short_addr = nla_get_shortaddr(info->attrs[IEEE802154_ATTR_SHORT_ADDR]);
994 	} else {
995 		dev->short_addr = cpu_to_le16(IEEE802154_ADDR_UNDEF);
996 	}
997 
998 	dev->hwaddr = nla_get_hwaddr(info->attrs[IEEE802154_ATTR_HW_ADDR]);
999 	dev->frame_counter = nla_get_u32(info->attrs[IEEE802154_ATTR_LLSEC_FRAME_COUNTER]);
1000 	dev->seclevel_exempt = !!nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_DEV_OVERRIDE]);
1001 	dev->key_mode = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_DEV_KEY_MODE]);
1002 
1003 	if (dev->key_mode >= __IEEE802154_LLSEC_DEVKEY_MAX)
1004 		return -EINVAL;
1005 
1006 	return 0;
1007 }
1008 
1009 static int llsec_add_dev(struct net_device *dev, struct genl_info *info)
1010 {
1011 	struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
1012 	struct ieee802154_llsec_device desc;
1013 
1014 	if (llsec_parse_dev(info, &desc))
1015 		return -EINVAL;
1016 
1017 	return ops->llsec->add_dev(dev, &desc);
1018 }
1019 
1020 int ieee802154_llsec_add_dev(struct sk_buff *skb, struct genl_info *info)
1021 {
1022 	if ((info->nlhdr->nlmsg_flags & (NLM_F_CREATE | NLM_F_EXCL)) !=
1023 	    (NLM_F_CREATE | NLM_F_EXCL))
1024 		return -EINVAL;
1025 
1026 	return ieee802154_nl_llsec_change(skb, info, llsec_add_dev);
1027 }
1028 
1029 static int llsec_del_dev(struct net_device *dev, struct genl_info *info)
1030 {
1031 	struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
1032 	__le64 devaddr;
1033 
1034 	if (!info->attrs[IEEE802154_ATTR_HW_ADDR])
1035 		return -EINVAL;
1036 
1037 	devaddr = nla_get_hwaddr(info->attrs[IEEE802154_ATTR_HW_ADDR]);
1038 
1039 	return ops->llsec->del_dev(dev, devaddr);
1040 }
1041 
1042 int ieee802154_llsec_del_dev(struct sk_buff *skb, struct genl_info *info)
1043 {
1044 	return ieee802154_nl_llsec_change(skb, info, llsec_del_dev);
1045 }
1046 
1047 static int
1048 ieee802154_nl_fill_dev(struct sk_buff *msg, u32 portid, u32 seq,
1049 		       const struct ieee802154_llsec_device *desc,
1050 		       const struct net_device *dev)
1051 {
1052 	void *hdr;
1053 
1054 	hdr = genlmsg_put(msg, 0, seq, &nl802154_family, NLM_F_MULTI,
1055 			  IEEE802154_LLSEC_LIST_DEV);
1056 	if (!hdr)
1057 		goto out;
1058 
1059 	if (nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name) ||
1060 	    nla_put_u32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex) ||
1061 	    nla_put_shortaddr(msg, IEEE802154_ATTR_PAN_ID, desc->pan_id) ||
1062 	    nla_put_shortaddr(msg, IEEE802154_ATTR_SHORT_ADDR,
1063 			      desc->short_addr) ||
1064 	    nla_put_hwaddr(msg, IEEE802154_ATTR_HW_ADDR, desc->hwaddr,
1065 			   IEEE802154_ATTR_PAD) ||
1066 	    nla_put_u32(msg, IEEE802154_ATTR_LLSEC_FRAME_COUNTER,
1067 			desc->frame_counter) ||
1068 	    nla_put_u8(msg, IEEE802154_ATTR_LLSEC_DEV_OVERRIDE,
1069 		       desc->seclevel_exempt) ||
1070 	    nla_put_u8(msg, IEEE802154_ATTR_LLSEC_DEV_KEY_MODE, desc->key_mode))
1071 		goto nla_put_failure;
1072 
1073 	genlmsg_end(msg, hdr);
1074 	return 0;
1075 
1076 nla_put_failure:
1077 	genlmsg_cancel(msg, hdr);
1078 out:
1079 	return -EMSGSIZE;
1080 }
1081 
1082 static int llsec_iter_devs(struct llsec_dump_data *data)
1083 {
1084 	struct ieee802154_llsec_device *pos;
1085 	int rc = 0, idx = 0;
1086 
1087 	list_for_each_entry(pos, &data->table->devices, list) {
1088 		if (idx++ < data->s_idx)
1089 			continue;
1090 
1091 		if (ieee802154_nl_fill_dev(data->skb, data->portid,
1092 					   data->nlmsg_seq, pos, data->dev)) {
1093 			rc = -EMSGSIZE;
1094 			break;
1095 		}
1096 
1097 		data->s_idx++;
1098 	}
1099 
1100 	return rc;
1101 }
1102 
1103 int ieee802154_llsec_dump_devs(struct sk_buff *skb, struct netlink_callback *cb)
1104 {
1105 	return ieee802154_llsec_dump_table(skb, cb, llsec_iter_devs);
1106 }
1107 
1108 static int llsec_add_devkey(struct net_device *dev, struct genl_info *info)
1109 {
1110 	struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
1111 	struct ieee802154_llsec_device_key key;
1112 	__le64 devaddr;
1113 
1114 	if (!info->attrs[IEEE802154_ATTR_LLSEC_FRAME_COUNTER] ||
1115 	    !info->attrs[IEEE802154_ATTR_HW_ADDR] ||
1116 	    ieee802154_llsec_parse_key_id(info, &key.key_id))
1117 		return -EINVAL;
1118 
1119 	devaddr = nla_get_hwaddr(info->attrs[IEEE802154_ATTR_HW_ADDR]);
1120 	key.frame_counter = nla_get_u32(info->attrs[IEEE802154_ATTR_LLSEC_FRAME_COUNTER]);
1121 
1122 	return ops->llsec->add_devkey(dev, devaddr, &key);
1123 }
1124 
1125 int ieee802154_llsec_add_devkey(struct sk_buff *skb, struct genl_info *info)
1126 {
1127 	if ((info->nlhdr->nlmsg_flags & (NLM_F_CREATE | NLM_F_EXCL)) !=
1128 	    (NLM_F_CREATE | NLM_F_EXCL))
1129 		return -EINVAL;
1130 
1131 	return ieee802154_nl_llsec_change(skb, info, llsec_add_devkey);
1132 }
1133 
1134 static int llsec_del_devkey(struct net_device *dev, struct genl_info *info)
1135 {
1136 	struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
1137 	struct ieee802154_llsec_device_key key;
1138 	__le64 devaddr;
1139 
1140 	if (!info->attrs[IEEE802154_ATTR_HW_ADDR] ||
1141 	    ieee802154_llsec_parse_key_id(info, &key.key_id))
1142 		return -EINVAL;
1143 
1144 	devaddr = nla_get_hwaddr(info->attrs[IEEE802154_ATTR_HW_ADDR]);
1145 
1146 	return ops->llsec->del_devkey(dev, devaddr, &key);
1147 }
1148 
1149 int ieee802154_llsec_del_devkey(struct sk_buff *skb, struct genl_info *info)
1150 {
1151 	return ieee802154_nl_llsec_change(skb, info, llsec_del_devkey);
1152 }
1153 
1154 static int
1155 ieee802154_nl_fill_devkey(struct sk_buff *msg, u32 portid, u32 seq,
1156 			  __le64 devaddr,
1157 			  const struct ieee802154_llsec_device_key *devkey,
1158 			  const struct net_device *dev)
1159 {
1160 	void *hdr;
1161 
1162 	hdr = genlmsg_put(msg, 0, seq, &nl802154_family, NLM_F_MULTI,
1163 			  IEEE802154_LLSEC_LIST_DEVKEY);
1164 	if (!hdr)
1165 		goto out;
1166 
1167 	if (nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name) ||
1168 	    nla_put_u32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex) ||
1169 	    nla_put_hwaddr(msg, IEEE802154_ATTR_HW_ADDR, devaddr,
1170 			   IEEE802154_ATTR_PAD) ||
1171 	    nla_put_u32(msg, IEEE802154_ATTR_LLSEC_FRAME_COUNTER,
1172 			devkey->frame_counter) ||
1173 	    ieee802154_llsec_fill_key_id(msg, &devkey->key_id))
1174 		goto nla_put_failure;
1175 
1176 	genlmsg_end(msg, hdr);
1177 	return 0;
1178 
1179 nla_put_failure:
1180 	genlmsg_cancel(msg, hdr);
1181 out:
1182 	return -EMSGSIZE;
1183 }
1184 
1185 static int llsec_iter_devkeys(struct llsec_dump_data *data)
1186 {
1187 	struct ieee802154_llsec_device *dpos;
1188 	struct ieee802154_llsec_device_key *kpos;
1189 	int idx = 0, idx2;
1190 
1191 	list_for_each_entry(dpos, &data->table->devices, list) {
1192 		if (idx++ < data->s_idx)
1193 			continue;
1194 
1195 		idx2 = 0;
1196 
1197 		list_for_each_entry(kpos, &dpos->keys, list) {
1198 			if (idx2++ < data->s_idx2)
1199 				continue;
1200 
1201 			if (ieee802154_nl_fill_devkey(data->skb, data->portid,
1202 						      data->nlmsg_seq,
1203 						      dpos->hwaddr, kpos,
1204 						      data->dev)) {
1205 				return -EMSGSIZE;
1206 			}
1207 
1208 			data->s_idx2++;
1209 		}
1210 
1211 		data->s_idx++;
1212 	}
1213 
1214 	return 0;
1215 }
1216 
1217 int ieee802154_llsec_dump_devkeys(struct sk_buff *skb,
1218 				  struct netlink_callback *cb)
1219 {
1220 	return ieee802154_llsec_dump_table(skb, cb, llsec_iter_devkeys);
1221 }
1222 
1223 static int
1224 llsec_parse_seclevel(struct genl_info *info,
1225 		     struct ieee802154_llsec_seclevel *sl)
1226 {
1227 	memset(sl, 0, sizeof(*sl));
1228 
1229 	if (!info->attrs[IEEE802154_ATTR_LLSEC_FRAME_TYPE] ||
1230 	    !info->attrs[IEEE802154_ATTR_LLSEC_SECLEVELS] ||
1231 	    !info->attrs[IEEE802154_ATTR_LLSEC_DEV_OVERRIDE])
1232 		return -EINVAL;
1233 
1234 	sl->frame_type = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_FRAME_TYPE]);
1235 	if (sl->frame_type == IEEE802154_FC_TYPE_MAC_CMD) {
1236 		if (!info->attrs[IEEE802154_ATTR_LLSEC_CMD_FRAME_ID])
1237 			return -EINVAL;
1238 
1239 		sl->cmd_frame_id = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_CMD_FRAME_ID]);
1240 	}
1241 
1242 	sl->sec_levels = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_SECLEVELS]);
1243 	sl->device_override = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_DEV_OVERRIDE]);
1244 
1245 	return 0;
1246 }
1247 
1248 static int llsec_add_seclevel(struct net_device *dev, struct genl_info *info)
1249 {
1250 	struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
1251 	struct ieee802154_llsec_seclevel sl;
1252 
1253 	if (llsec_parse_seclevel(info, &sl))
1254 		return -EINVAL;
1255 
1256 	return ops->llsec->add_seclevel(dev, &sl);
1257 }
1258 
1259 int ieee802154_llsec_add_seclevel(struct sk_buff *skb, struct genl_info *info)
1260 {
1261 	if ((info->nlhdr->nlmsg_flags & (NLM_F_CREATE | NLM_F_EXCL)) !=
1262 	    (NLM_F_CREATE | NLM_F_EXCL))
1263 		return -EINVAL;
1264 
1265 	return ieee802154_nl_llsec_change(skb, info, llsec_add_seclevel);
1266 }
1267 
1268 static int llsec_del_seclevel(struct net_device *dev, struct genl_info *info)
1269 {
1270 	struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
1271 	struct ieee802154_llsec_seclevel sl;
1272 
1273 	if (llsec_parse_seclevel(info, &sl))
1274 		return -EINVAL;
1275 
1276 	return ops->llsec->del_seclevel(dev, &sl);
1277 }
1278 
1279 int ieee802154_llsec_del_seclevel(struct sk_buff *skb, struct genl_info *info)
1280 {
1281 	return ieee802154_nl_llsec_change(skb, info, llsec_del_seclevel);
1282 }
1283 
1284 static int
1285 ieee802154_nl_fill_seclevel(struct sk_buff *msg, u32 portid, u32 seq,
1286 			    const struct ieee802154_llsec_seclevel *sl,
1287 			    const struct net_device *dev)
1288 {
1289 	void *hdr;
1290 
1291 	hdr = genlmsg_put(msg, 0, seq, &nl802154_family, NLM_F_MULTI,
1292 			  IEEE802154_LLSEC_LIST_SECLEVEL);
1293 	if (!hdr)
1294 		goto out;
1295 
1296 	if (nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name) ||
1297 	    nla_put_u32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex) ||
1298 	    nla_put_u8(msg, IEEE802154_ATTR_LLSEC_FRAME_TYPE, sl->frame_type) ||
1299 	    nla_put_u8(msg, IEEE802154_ATTR_LLSEC_SECLEVELS, sl->sec_levels) ||
1300 	    nla_put_u8(msg, IEEE802154_ATTR_LLSEC_DEV_OVERRIDE,
1301 		       sl->device_override))
1302 		goto nla_put_failure;
1303 
1304 	if (sl->frame_type == IEEE802154_FC_TYPE_MAC_CMD &&
1305 	    nla_put_u8(msg, IEEE802154_ATTR_LLSEC_CMD_FRAME_ID,
1306 		       sl->cmd_frame_id))
1307 		goto nla_put_failure;
1308 
1309 	genlmsg_end(msg, hdr);
1310 	return 0;
1311 
1312 nla_put_failure:
1313 	genlmsg_cancel(msg, hdr);
1314 out:
1315 	return -EMSGSIZE;
1316 }
1317 
1318 static int llsec_iter_seclevels(struct llsec_dump_data *data)
1319 {
1320 	struct ieee802154_llsec_seclevel *pos;
1321 	int rc = 0, idx = 0;
1322 
1323 	list_for_each_entry(pos, &data->table->security_levels, list) {
1324 		if (idx++ < data->s_idx)
1325 			continue;
1326 
1327 		if (ieee802154_nl_fill_seclevel(data->skb, data->portid,
1328 						data->nlmsg_seq, pos,
1329 						data->dev)) {
1330 			rc = -EMSGSIZE;
1331 			break;
1332 		}
1333 
1334 		data->s_idx++;
1335 	}
1336 
1337 	return rc;
1338 }
1339 
1340 int ieee802154_llsec_dump_seclevels(struct sk_buff *skb,
1341 				    struct netlink_callback *cb)
1342 {
1343 	return ieee802154_llsec_dump_table(skb, cb, llsec_iter_seclevels);
1344 }
1345