xref: /openbmc/linux/net/ieee802154/nl-mac.c (revision e2bd6bad) 
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 		goto out_free;
685 
686 	dev_put(dev);
687 
688 	return ieee802154_nl_reply(msg, info);
689 out_free:
690 	nlmsg_free(msg);
691 out_dev:
692 	dev_put(dev);
693 	return rc;
694 }
695 
696 int ieee802154_llsec_setparams(struct sk_buff *skb, struct genl_info *info)
697 {
698 	struct net_device *dev = NULL;
699 	int rc = -EINVAL;
700 	struct ieee802154_mlme_ops *ops;
701 	struct ieee802154_llsec_params params;
702 	int changed = 0;
703 
704 	pr_debug("%s\n", __func__);
705 
706 	dev = ieee802154_nl_get_dev(info);
707 	if (!dev)
708 		return -ENODEV;
709 
710 	if (!info->attrs[IEEE802154_ATTR_LLSEC_ENABLED] &&
711 	    !info->attrs[IEEE802154_ATTR_LLSEC_KEY_MODE] &&
712 	    !info->attrs[IEEE802154_ATTR_LLSEC_SECLEVEL])
713 		goto out;
714 
715 	ops = ieee802154_mlme_ops(dev);
716 	if (!ops->llsec) {
717 		rc = -EOPNOTSUPP;
718 		goto out;
719 	}
720 
721 	if (info->attrs[IEEE802154_ATTR_LLSEC_SECLEVEL] &&
722 	    nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_SECLEVEL]) > 7)
723 		goto out;
724 
725 	if (info->attrs[IEEE802154_ATTR_LLSEC_ENABLED]) {
726 		params.enabled = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_ENABLED]);
727 		changed |= IEEE802154_LLSEC_PARAM_ENABLED;
728 	}
729 
730 	if (info->attrs[IEEE802154_ATTR_LLSEC_KEY_MODE]) {
731 		if (ieee802154_llsec_parse_key_id(info, &params.out_key))
732 			goto out;
733 
734 		changed |= IEEE802154_LLSEC_PARAM_OUT_KEY;
735 	}
736 
737 	if (info->attrs[IEEE802154_ATTR_LLSEC_SECLEVEL]) {
738 		params.out_level = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_SECLEVEL]);
739 		changed |= IEEE802154_LLSEC_PARAM_OUT_LEVEL;
740 	}
741 
742 	if (info->attrs[IEEE802154_ATTR_LLSEC_FRAME_COUNTER]) {
743 		u32 fc = nla_get_u32(info->attrs[IEEE802154_ATTR_LLSEC_FRAME_COUNTER]);
744 
745 		params.frame_counter = cpu_to_be32(fc);
746 		changed |= IEEE802154_LLSEC_PARAM_FRAME_COUNTER;
747 	}
748 
749 	rc = ops->llsec->set_params(dev, &params, changed);
750 
751 	dev_put(dev);
752 
753 	return rc;
754 out:
755 	dev_put(dev);
756 	return rc;
757 }
758 
759 struct llsec_dump_data {
760 	struct sk_buff *skb;
761 	int s_idx, s_idx2;
762 	int portid;
763 	int nlmsg_seq;
764 	struct net_device *dev;
765 	struct ieee802154_mlme_ops *ops;
766 	struct ieee802154_llsec_table *table;
767 };
768 
769 static int
770 ieee802154_llsec_dump_table(struct sk_buff *skb, struct netlink_callback *cb,
771 			    int (*step)(struct llsec_dump_data *))
772 {
773 	struct net *net = sock_net(skb->sk);
774 	struct net_device *dev;
775 	struct llsec_dump_data data;
776 	int idx = 0;
777 	int first_dev = cb->args[0];
778 	int rc;
779 
780 	for_each_netdev(net, dev) {
781 		if (idx < first_dev || dev->type != ARPHRD_IEEE802154)
782 			goto skip;
783 
784 		data.ops = ieee802154_mlme_ops(dev);
785 		if (!data.ops->llsec)
786 			goto skip;
787 
788 		data.skb = skb;
789 		data.s_idx = cb->args[1];
790 		data.s_idx2 = cb->args[2];
791 		data.dev = dev;
792 		data.portid = NETLINK_CB(cb->skb).portid;
793 		data.nlmsg_seq = cb->nlh->nlmsg_seq;
794 
795 		data.ops->llsec->lock_table(dev);
796 		data.ops->llsec->get_table(data.dev, &data.table);
797 		rc = step(&data);
798 		data.ops->llsec->unlock_table(dev);
799 
800 		if (rc < 0)
801 			break;
802 
803 skip:
804 		idx++;
805 	}
806 	cb->args[0] = idx;
807 
808 	return skb->len;
809 }
810 
811 static int
812 ieee802154_nl_llsec_change(struct sk_buff *skb, struct genl_info *info,
813 			   int (*fn)(struct net_device*, struct genl_info*))
814 {
815 	struct net_device *dev = NULL;
816 	int rc = -EINVAL;
817 
818 	dev = ieee802154_nl_get_dev(info);
819 	if (!dev)
820 		return -ENODEV;
821 
822 	if (!ieee802154_mlme_ops(dev)->llsec)
823 		rc = -EOPNOTSUPP;
824 	else
825 		rc = fn(dev, info);
826 
827 	dev_put(dev);
828 	return rc;
829 }
830 
831 static int
832 ieee802154_llsec_parse_key(struct genl_info *info,
833 			   struct ieee802154_llsec_key *key)
834 {
835 	u8 frames;
836 	u32 commands[256 / 32];
837 
838 	memset(key, 0, sizeof(*key));
839 
840 	if (!info->attrs[IEEE802154_ATTR_LLSEC_KEY_USAGE_FRAME_TYPES] ||
841 	    !info->attrs[IEEE802154_ATTR_LLSEC_KEY_BYTES])
842 		return -EINVAL;
843 
844 	frames = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_KEY_USAGE_FRAME_TYPES]);
845 	if ((frames & BIT(IEEE802154_FC_TYPE_MAC_CMD)) &&
846 	    !info->attrs[IEEE802154_ATTR_LLSEC_KEY_USAGE_COMMANDS])
847 		return -EINVAL;
848 
849 	if (info->attrs[IEEE802154_ATTR_LLSEC_KEY_USAGE_COMMANDS]) {
850 		nla_memcpy(commands,
851 			   info->attrs[IEEE802154_ATTR_LLSEC_KEY_USAGE_COMMANDS],
852 			   256 / 8);
853 
854 		if (commands[0] || commands[1] || commands[2] || commands[3] ||
855 		    commands[4] || commands[5] || commands[6] ||
856 		    commands[7] >= BIT(IEEE802154_CMD_GTS_REQ + 1))
857 			return -EINVAL;
858 
859 		key->cmd_frame_ids = commands[7];
860 	}
861 
862 	key->frame_types = frames;
863 
864 	nla_memcpy(key->key, info->attrs[IEEE802154_ATTR_LLSEC_KEY_BYTES],
865 		   IEEE802154_LLSEC_KEY_SIZE);
866 
867 	return 0;
868 }
869 
870 static int llsec_add_key(struct net_device *dev, struct genl_info *info)
871 {
872 	struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
873 	struct ieee802154_llsec_key key;
874 	struct ieee802154_llsec_key_id id;
875 
876 	if (ieee802154_llsec_parse_key(info, &key) ||
877 	    ieee802154_llsec_parse_key_id(info, &id))
878 		return -EINVAL;
879 
880 	return ops->llsec->add_key(dev, &id, &key);
881 }
882 
883 int ieee802154_llsec_add_key(struct sk_buff *skb, struct genl_info *info)
884 {
885 	if ((info->nlhdr->nlmsg_flags & (NLM_F_CREATE | NLM_F_EXCL)) !=
886 	    (NLM_F_CREATE | NLM_F_EXCL))
887 		return -EINVAL;
888 
889 	return ieee802154_nl_llsec_change(skb, info, llsec_add_key);
890 }
891 
892 static int llsec_remove_key(struct net_device *dev, struct genl_info *info)
893 {
894 	struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
895 	struct ieee802154_llsec_key_id id;
896 
897 	if (ieee802154_llsec_parse_key_id(info, &id))
898 		return -EINVAL;
899 
900 	return ops->llsec->del_key(dev, &id);
901 }
902 
903 int ieee802154_llsec_del_key(struct sk_buff *skb, struct genl_info *info)
904 {
905 	return ieee802154_nl_llsec_change(skb, info, llsec_remove_key);
906 }
907 
908 static int
909 ieee802154_nl_fill_key(struct sk_buff *msg, u32 portid, u32 seq,
910 		       const struct ieee802154_llsec_key_entry *key,
911 		       const struct net_device *dev)
912 {
913 	void *hdr;
914 	u32 commands[256 / 32];
915 
916 	hdr = genlmsg_put(msg, 0, seq, &nl802154_family, NLM_F_MULTI,
917 			  IEEE802154_LLSEC_LIST_KEY);
918 	if (!hdr)
919 		goto out;
920 
921 	if (nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name) ||
922 	    nla_put_u32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex) ||
923 	    ieee802154_llsec_fill_key_id(msg, &key->id) ||
924 	    nla_put_u8(msg, IEEE802154_ATTR_LLSEC_KEY_USAGE_FRAME_TYPES,
925 		       key->key->frame_types))
926 		goto nla_put_failure;
927 
928 	if (key->key->frame_types & BIT(IEEE802154_FC_TYPE_MAC_CMD)) {
929 		memset(commands, 0, sizeof(commands));
930 		commands[7] = key->key->cmd_frame_ids;
931 		if (nla_put(msg, IEEE802154_ATTR_LLSEC_KEY_USAGE_COMMANDS,
932 			    sizeof(commands), commands))
933 			goto nla_put_failure;
934 	}
935 
936 	if (nla_put(msg, IEEE802154_ATTR_LLSEC_KEY_BYTES,
937 		    IEEE802154_LLSEC_KEY_SIZE, key->key->key))
938 		goto nla_put_failure;
939 
940 	genlmsg_end(msg, hdr);
941 	return 0;
942 
943 nla_put_failure:
944 	genlmsg_cancel(msg, hdr);
945 out:
946 	return -EMSGSIZE;
947 }
948 
949 static int llsec_iter_keys(struct llsec_dump_data *data)
950 {
951 	struct ieee802154_llsec_key_entry *pos;
952 	int rc = 0, idx = 0;
953 
954 	list_for_each_entry(pos, &data->table->keys, list) {
955 		if (idx++ < data->s_idx)
956 			continue;
957 
958 		if (ieee802154_nl_fill_key(data->skb, data->portid,
959 					   data->nlmsg_seq, pos, data->dev)) {
960 			rc = -EMSGSIZE;
961 			break;
962 		}
963 
964 		data->s_idx++;
965 	}
966 
967 	return rc;
968 }
969 
970 int ieee802154_llsec_dump_keys(struct sk_buff *skb, struct netlink_callback *cb)
971 {
972 	return ieee802154_llsec_dump_table(skb, cb, llsec_iter_keys);
973 }
974 
975 static int
976 llsec_parse_dev(struct genl_info *info,
977 		struct ieee802154_llsec_device *dev)
978 {
979 	memset(dev, 0, sizeof(*dev));
980 
981 	if (!info->attrs[IEEE802154_ATTR_LLSEC_FRAME_COUNTER] ||
982 	    !info->attrs[IEEE802154_ATTR_HW_ADDR] ||
983 	    !info->attrs[IEEE802154_ATTR_LLSEC_DEV_OVERRIDE] ||
984 	    !info->attrs[IEEE802154_ATTR_LLSEC_DEV_KEY_MODE] ||
985 	    (!!info->attrs[IEEE802154_ATTR_PAN_ID] !=
986 	     !!info->attrs[IEEE802154_ATTR_SHORT_ADDR]))
987 		return -EINVAL;
988 
989 	if (info->attrs[IEEE802154_ATTR_PAN_ID]) {
990 		dev->pan_id = nla_get_shortaddr(info->attrs[IEEE802154_ATTR_PAN_ID]);
991 		dev->short_addr = nla_get_shortaddr(info->attrs[IEEE802154_ATTR_SHORT_ADDR]);
992 	} else {
993 		dev->short_addr = cpu_to_le16(IEEE802154_ADDR_UNDEF);
994 	}
995 
996 	dev->hwaddr = nla_get_hwaddr(info->attrs[IEEE802154_ATTR_HW_ADDR]);
997 	dev->frame_counter = nla_get_u32(info->attrs[IEEE802154_ATTR_LLSEC_FRAME_COUNTER]);
998 	dev->seclevel_exempt = !!nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_DEV_OVERRIDE]);
999 	dev->key_mode = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_DEV_KEY_MODE]);
1000 
1001 	if (dev->key_mode >= __IEEE802154_LLSEC_DEVKEY_MAX)
1002 		return -EINVAL;
1003 
1004 	return 0;
1005 }
1006 
1007 static int llsec_add_dev(struct net_device *dev, struct genl_info *info)
1008 {
1009 	struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
1010 	struct ieee802154_llsec_device desc;
1011 
1012 	if (llsec_parse_dev(info, &desc))
1013 		return -EINVAL;
1014 
1015 	return ops->llsec->add_dev(dev, &desc);
1016 }
1017 
1018 int ieee802154_llsec_add_dev(struct sk_buff *skb, struct genl_info *info)
1019 {
1020 	if ((info->nlhdr->nlmsg_flags & (NLM_F_CREATE | NLM_F_EXCL)) !=
1021 	    (NLM_F_CREATE | NLM_F_EXCL))
1022 		return -EINVAL;
1023 
1024 	return ieee802154_nl_llsec_change(skb, info, llsec_add_dev);
1025 }
1026 
1027 static int llsec_del_dev(struct net_device *dev, struct genl_info *info)
1028 {
1029 	struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
1030 	__le64 devaddr;
1031 
1032 	if (!info->attrs[IEEE802154_ATTR_HW_ADDR])
1033 		return -EINVAL;
1034 
1035 	devaddr = nla_get_hwaddr(info->attrs[IEEE802154_ATTR_HW_ADDR]);
1036 
1037 	return ops->llsec->del_dev(dev, devaddr);
1038 }
1039 
1040 int ieee802154_llsec_del_dev(struct sk_buff *skb, struct genl_info *info)
1041 {
1042 	return ieee802154_nl_llsec_change(skb, info, llsec_del_dev);
1043 }
1044 
1045 static int
1046 ieee802154_nl_fill_dev(struct sk_buff *msg, u32 portid, u32 seq,
1047 		       const struct ieee802154_llsec_device *desc,
1048 		       const struct net_device *dev)
1049 {
1050 	void *hdr;
1051 
1052 	hdr = genlmsg_put(msg, 0, seq, &nl802154_family, NLM_F_MULTI,
1053 			  IEEE802154_LLSEC_LIST_DEV);
1054 	if (!hdr)
1055 		goto out;
1056 
1057 	if (nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name) ||
1058 	    nla_put_u32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex) ||
1059 	    nla_put_shortaddr(msg, IEEE802154_ATTR_PAN_ID, desc->pan_id) ||
1060 	    nla_put_shortaddr(msg, IEEE802154_ATTR_SHORT_ADDR,
1061 			      desc->short_addr) ||
1062 	    nla_put_hwaddr(msg, IEEE802154_ATTR_HW_ADDR, desc->hwaddr,
1063 			   IEEE802154_ATTR_PAD) ||
1064 	    nla_put_u32(msg, IEEE802154_ATTR_LLSEC_FRAME_COUNTER,
1065 			desc->frame_counter) ||
1066 	    nla_put_u8(msg, IEEE802154_ATTR_LLSEC_DEV_OVERRIDE,
1067 		       desc->seclevel_exempt) ||
1068 	    nla_put_u8(msg, IEEE802154_ATTR_LLSEC_DEV_KEY_MODE, desc->key_mode))
1069 		goto nla_put_failure;
1070 
1071 	genlmsg_end(msg, hdr);
1072 	return 0;
1073 
1074 nla_put_failure:
1075 	genlmsg_cancel(msg, hdr);
1076 out:
1077 	return -EMSGSIZE;
1078 }
1079 
1080 static int llsec_iter_devs(struct llsec_dump_data *data)
1081 {
1082 	struct ieee802154_llsec_device *pos;
1083 	int rc = 0, idx = 0;
1084 
1085 	list_for_each_entry(pos, &data->table->devices, list) {
1086 		if (idx++ < data->s_idx)
1087 			continue;
1088 
1089 		if (ieee802154_nl_fill_dev(data->skb, data->portid,
1090 					   data->nlmsg_seq, pos, data->dev)) {
1091 			rc = -EMSGSIZE;
1092 			break;
1093 		}
1094 
1095 		data->s_idx++;
1096 	}
1097 
1098 	return rc;
1099 }
1100 
1101 int ieee802154_llsec_dump_devs(struct sk_buff *skb, struct netlink_callback *cb)
1102 {
1103 	return ieee802154_llsec_dump_table(skb, cb, llsec_iter_devs);
1104 }
1105 
1106 static int llsec_add_devkey(struct net_device *dev, struct genl_info *info)
1107 {
1108 	struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
1109 	struct ieee802154_llsec_device_key key;
1110 	__le64 devaddr;
1111 
1112 	if (!info->attrs[IEEE802154_ATTR_LLSEC_FRAME_COUNTER] ||
1113 	    !info->attrs[IEEE802154_ATTR_HW_ADDR] ||
1114 	    ieee802154_llsec_parse_key_id(info, &key.key_id))
1115 		return -EINVAL;
1116 
1117 	devaddr = nla_get_hwaddr(info->attrs[IEEE802154_ATTR_HW_ADDR]);
1118 	key.frame_counter = nla_get_u32(info->attrs[IEEE802154_ATTR_LLSEC_FRAME_COUNTER]);
1119 
1120 	return ops->llsec->add_devkey(dev, devaddr, &key);
1121 }
1122 
1123 int ieee802154_llsec_add_devkey(struct sk_buff *skb, struct genl_info *info)
1124 {
1125 	if ((info->nlhdr->nlmsg_flags & (NLM_F_CREATE | NLM_F_EXCL)) !=
1126 	    (NLM_F_CREATE | NLM_F_EXCL))
1127 		return -EINVAL;
1128 
1129 	return ieee802154_nl_llsec_change(skb, info, llsec_add_devkey);
1130 }
1131 
1132 static int llsec_del_devkey(struct net_device *dev, struct genl_info *info)
1133 {
1134 	struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
1135 	struct ieee802154_llsec_device_key key;
1136 	__le64 devaddr;
1137 
1138 	if (!info->attrs[IEEE802154_ATTR_HW_ADDR] ||
1139 	    ieee802154_llsec_parse_key_id(info, &key.key_id))
1140 		return -EINVAL;
1141 
1142 	devaddr = nla_get_hwaddr(info->attrs[IEEE802154_ATTR_HW_ADDR]);
1143 
1144 	return ops->llsec->del_devkey(dev, devaddr, &key);
1145 }
1146 
1147 int ieee802154_llsec_del_devkey(struct sk_buff *skb, struct genl_info *info)
1148 {
1149 	return ieee802154_nl_llsec_change(skb, info, llsec_del_devkey);
1150 }
1151 
1152 static int
1153 ieee802154_nl_fill_devkey(struct sk_buff *msg, u32 portid, u32 seq,
1154 			  __le64 devaddr,
1155 			  const struct ieee802154_llsec_device_key *devkey,
1156 			  const struct net_device *dev)
1157 {
1158 	void *hdr;
1159 
1160 	hdr = genlmsg_put(msg, 0, seq, &nl802154_family, NLM_F_MULTI,
1161 			  IEEE802154_LLSEC_LIST_DEVKEY);
1162 	if (!hdr)
1163 		goto out;
1164 
1165 	if (nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name) ||
1166 	    nla_put_u32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex) ||
1167 	    nla_put_hwaddr(msg, IEEE802154_ATTR_HW_ADDR, devaddr,
1168 			   IEEE802154_ATTR_PAD) ||
1169 	    nla_put_u32(msg, IEEE802154_ATTR_LLSEC_FRAME_COUNTER,
1170 			devkey->frame_counter) ||
1171 	    ieee802154_llsec_fill_key_id(msg, &devkey->key_id))
1172 		goto nla_put_failure;
1173 
1174 	genlmsg_end(msg, hdr);
1175 	return 0;
1176 
1177 nla_put_failure:
1178 	genlmsg_cancel(msg, hdr);
1179 out:
1180 	return -EMSGSIZE;
1181 }
1182 
1183 static int llsec_iter_devkeys(struct llsec_dump_data *data)
1184 {
1185 	struct ieee802154_llsec_device *dpos;
1186 	struct ieee802154_llsec_device_key *kpos;
1187 	int rc = 0, idx = 0, idx2;
1188 
1189 	list_for_each_entry(dpos, &data->table->devices, list) {
1190 		if (idx++ < data->s_idx)
1191 			continue;
1192 
1193 		idx2 = 0;
1194 
1195 		list_for_each_entry(kpos, &dpos->keys, list) {
1196 			if (idx2++ < data->s_idx2)
1197 				continue;
1198 
1199 			if (ieee802154_nl_fill_devkey(data->skb, data->portid,
1200 						      data->nlmsg_seq,
1201 						      dpos->hwaddr, kpos,
1202 						      data->dev)) {
1203 				return rc = -EMSGSIZE;
1204 			}
1205 
1206 			data->s_idx2++;
1207 		}
1208 
1209 		data->s_idx++;
1210 	}
1211 
1212 	return rc;
1213 }
1214 
1215 int ieee802154_llsec_dump_devkeys(struct sk_buff *skb,
1216 				  struct netlink_callback *cb)
1217 {
1218 	return ieee802154_llsec_dump_table(skb, cb, llsec_iter_devkeys);
1219 }
1220 
1221 static int
1222 llsec_parse_seclevel(struct genl_info *info,
1223 		     struct ieee802154_llsec_seclevel *sl)
1224 {
1225 	memset(sl, 0, sizeof(*sl));
1226 
1227 	if (!info->attrs[IEEE802154_ATTR_LLSEC_FRAME_TYPE] ||
1228 	    !info->attrs[IEEE802154_ATTR_LLSEC_SECLEVELS] ||
1229 	    !info->attrs[IEEE802154_ATTR_LLSEC_DEV_OVERRIDE])
1230 		return -EINVAL;
1231 
1232 	sl->frame_type = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_FRAME_TYPE]);
1233 	if (sl->frame_type == IEEE802154_FC_TYPE_MAC_CMD) {
1234 		if (!info->attrs[IEEE802154_ATTR_LLSEC_CMD_FRAME_ID])
1235 			return -EINVAL;
1236 
1237 		sl->cmd_frame_id = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_CMD_FRAME_ID]);
1238 	}
1239 
1240 	sl->sec_levels = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_SECLEVELS]);
1241 	sl->device_override = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_DEV_OVERRIDE]);
1242 
1243 	return 0;
1244 }
1245 
1246 static int llsec_add_seclevel(struct net_device *dev, struct genl_info *info)
1247 {
1248 	struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
1249 	struct ieee802154_llsec_seclevel sl;
1250 
1251 	if (llsec_parse_seclevel(info, &sl))
1252 		return -EINVAL;
1253 
1254 	return ops->llsec->add_seclevel(dev, &sl);
1255 }
1256 
1257 int ieee802154_llsec_add_seclevel(struct sk_buff *skb, struct genl_info *info)
1258 {
1259 	if ((info->nlhdr->nlmsg_flags & (NLM_F_CREATE | NLM_F_EXCL)) !=
1260 	    (NLM_F_CREATE | NLM_F_EXCL))
1261 		return -EINVAL;
1262 
1263 	return ieee802154_nl_llsec_change(skb, info, llsec_add_seclevel);
1264 }
1265 
1266 static int llsec_del_seclevel(struct net_device *dev, struct genl_info *info)
1267 {
1268 	struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
1269 	struct ieee802154_llsec_seclevel sl;
1270 
1271 	if (llsec_parse_seclevel(info, &sl))
1272 		return -EINVAL;
1273 
1274 	return ops->llsec->del_seclevel(dev, &sl);
1275 }
1276 
1277 int ieee802154_llsec_del_seclevel(struct sk_buff *skb, struct genl_info *info)
1278 {
1279 	return ieee802154_nl_llsec_change(skb, info, llsec_del_seclevel);
1280 }
1281 
1282 static int
1283 ieee802154_nl_fill_seclevel(struct sk_buff *msg, u32 portid, u32 seq,
1284 			    const struct ieee802154_llsec_seclevel *sl,
1285 			    const struct net_device *dev)
1286 {
1287 	void *hdr;
1288 
1289 	hdr = genlmsg_put(msg, 0, seq, &nl802154_family, NLM_F_MULTI,
1290 			  IEEE802154_LLSEC_LIST_SECLEVEL);
1291 	if (!hdr)
1292 		goto out;
1293 
1294 	if (nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name) ||
1295 	    nla_put_u32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex) ||
1296 	    nla_put_u8(msg, IEEE802154_ATTR_LLSEC_FRAME_TYPE, sl->frame_type) ||
1297 	    nla_put_u8(msg, IEEE802154_ATTR_LLSEC_SECLEVELS, sl->sec_levels) ||
1298 	    nla_put_u8(msg, IEEE802154_ATTR_LLSEC_DEV_OVERRIDE,
1299 		       sl->device_override))
1300 		goto nla_put_failure;
1301 
1302 	if (sl->frame_type == IEEE802154_FC_TYPE_MAC_CMD &&
1303 	    nla_put_u8(msg, IEEE802154_ATTR_LLSEC_CMD_FRAME_ID,
1304 		       sl->cmd_frame_id))
1305 		goto nla_put_failure;
1306 
1307 	genlmsg_end(msg, hdr);
1308 	return 0;
1309 
1310 nla_put_failure:
1311 	genlmsg_cancel(msg, hdr);
1312 out:
1313 	return -EMSGSIZE;
1314 }
1315 
1316 static int llsec_iter_seclevels(struct llsec_dump_data *data)
1317 {
1318 	struct ieee802154_llsec_seclevel *pos;
1319 	int rc = 0, idx = 0;
1320 
1321 	list_for_each_entry(pos, &data->table->security_levels, list) {
1322 		if (idx++ < data->s_idx)
1323 			continue;
1324 
1325 		if (ieee802154_nl_fill_seclevel(data->skb, data->portid,
1326 						data->nlmsg_seq, pos,
1327 						data->dev)) {
1328 			rc = -EMSGSIZE;
1329 			break;
1330 		}
1331 
1332 		data->s_idx++;
1333 	}
1334 
1335 	return rc;
1336 }
1337 
1338 int ieee802154_llsec_dump_seclevels(struct sk_buff *skb,
1339 				    struct netlink_callback *cb)
1340 {
1341 	return ieee802154_llsec_dump_table(skb, cb, llsec_iter_seclevels);
1342 }
1343