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