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, ¶ms);
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, ¶ms);
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, ¶ms);
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, ¶ms);
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, ¶ms.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, ¶ms.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, ¶ms, 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
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.