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