// SPDX-License-Identifier: GPL-2.0-only
/*
 * Netlink interface for IEEE 802.15.4 stack
 *
 * Copyright 2007, 2008 Siemens AG
 *
 * Written by:
 * Sergey Lapin <slapin@ossfans.org>
 * Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
 * Maxim Osipov <maxim.osipov@siemens.com>
 */

#include <linux/gfp.h>
#include <linux/kernel.h>
#include <linux/if_arp.h>
#include <linux/netdevice.h>
#include <linux/ieee802154.h>
#include <net/netlink.h>
#include <net/genetlink.h>
#include <net/sock.h>
#include <linux/nl802154.h>
#include <linux/export.h>
#include <net/af_ieee802154.h>
#include <net/ieee802154_netdev.h>
#include <net/cfg802154.h>

#include "ieee802154.h"

static int nla_put_hwaddr(struct sk_buff *msg, int type, __le64 hwaddr,
                          int padattr)
{
        return nla_put_u64_64bit(msg, type, swab64((__force u64)hwaddr),
                                 padattr);
}

static __le64 nla_get_hwaddr(const struct nlattr *nla)
{
        return ieee802154_devaddr_from_raw(nla_data(nla));
}

static int nla_put_shortaddr(struct sk_buff *msg, int type, __le16 addr)
{
        return nla_put_u16(msg, type, le16_to_cpu(addr));
}

static __le16 nla_get_shortaddr(const struct nlattr *nla)
{
        return cpu_to_le16(nla_get_u16(nla));
}

static int ieee802154_nl_start_confirm(struct net_device *dev, u8 status)
{
        struct sk_buff *msg;

        pr_debug("%s\n", __func__);

        msg = ieee802154_nl_create(0, IEEE802154_START_CONF);
        if (!msg)
                return -ENOBUFS;

        if (nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name) ||
            nla_put_u32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex) ||
            nla_put(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
                    dev->dev_addr) ||
            nla_put_u8(msg, IEEE802154_ATTR_STATUS, status))
                goto nla_put_failure;
        return ieee802154_nl_mcast(msg, IEEE802154_COORD_MCGRP);

nla_put_failure:
        nlmsg_free(msg);
        return -ENOBUFS;
}

static int ieee802154_nl_fill_iface(struct sk_buff *msg, u32 portid,
                                    u32 seq, int flags, struct net_device *dev)
{
        void *hdr;
        struct wpan_phy *phy;
        struct ieee802154_mlme_ops *ops;
        __le16 short_addr, pan_id;

        pr_debug("%s\n", __func__);

        hdr = genlmsg_put(msg, 0, seq, &nl802154_family, flags,
                          IEEE802154_LIST_IFACE);
        if (!hdr)
                goto out;

        ops = ieee802154_mlme_ops(dev);
        phy = dev->ieee802154_ptr->wpan_phy;
        BUG_ON(!phy);
        get_device(&phy->dev);

        rtnl_lock();
        short_addr = dev->ieee802154_ptr->short_addr;
        pan_id = dev->ieee802154_ptr->pan_id;
        rtnl_unlock();

        if (nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name) ||
            nla_put_string(msg, IEEE802154_ATTR_PHY_NAME, wpan_phy_name(phy)) ||
            nla_put_u32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex) ||
            nla_put(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
                    dev->dev_addr) ||
            nla_put_shortaddr(msg, IEEE802154_ATTR_SHORT_ADDR, short_addr) ||
            nla_put_shortaddr(msg, IEEE802154_ATTR_PAN_ID, pan_id))
                goto nla_put_failure;

        if (ops->get_mac_params) {
                struct ieee802154_mac_params params;

                rtnl_lock();
                ops->get_mac_params(dev, &params);
                rtnl_unlock();

                if (nla_put_s8(msg, IEEE802154_ATTR_TXPOWER,
                               params.transmit_power / 100) ||
                    nla_put_u8(msg, IEEE802154_ATTR_LBT_ENABLED, params.lbt) ||
                    nla_put_u8(msg, IEEE802154_ATTR_CCA_MODE,
                               params.cca.mode) ||
                    nla_put_s32(msg, IEEE802154_ATTR_CCA_ED_LEVEL,
                                params.cca_ed_level / 100) ||
                    nla_put_u8(msg, IEEE802154_ATTR_CSMA_RETRIES,
                               params.csma_retries) ||
                    nla_put_u8(msg, IEEE802154_ATTR_CSMA_MIN_BE,
                               params.min_be) ||
                    nla_put_u8(msg, IEEE802154_ATTR_CSMA_MAX_BE,
                               params.max_be) ||
                    nla_put_s8(msg, IEEE802154_ATTR_FRAME_RETRIES,
                               params.frame_retries))
                        goto nla_put_failure;
        }

        wpan_phy_put(phy);
        genlmsg_end(msg, hdr);
        return 0;

nla_put_failure:
        wpan_phy_put(phy);
        genlmsg_cancel(msg, hdr);
out:
        return -EMSGSIZE;
}

/* Requests from userspace */
static struct net_device *ieee802154_nl_get_dev(struct genl_info *info)
{
        struct net_device *dev;

        if (info->attrs[IEEE802154_ATTR_DEV_NAME]) {
                char name[IFNAMSIZ + 1];

                nla_strscpy(name, info->attrs[IEEE802154_ATTR_DEV_NAME],
                            sizeof(name));
                dev = dev_get_by_name(&init_net, name);
        } else if (info->attrs[IEEE802154_ATTR_DEV_INDEX]) {
                dev = dev_get_by_index(&init_net,
                        nla_get_u32(info->attrs[IEEE802154_ATTR_DEV_INDEX]));
        } else {
                return NULL;
        }

        if (!dev)
                return NULL;

        if (dev->type != ARPHRD_IEEE802154) {
                dev_put(dev);
                return NULL;
        }

        return dev;
}

int ieee802154_associate_req(struct sk_buff *skb, struct genl_info *info)
{
        struct net_device *dev;
        struct ieee802154_addr addr;
        u8 page;
        int ret = -EOPNOTSUPP;

        if (!info->attrs[IEEE802154_ATTR_CHANNEL] ||
            !info->attrs[IEEE802154_ATTR_COORD_PAN_ID] ||
            (!info->attrs[IEEE802154_ATTR_COORD_HW_ADDR] &&
                !info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR]) ||
            !info->attrs[IEEE802154_ATTR_CAPABILITY])
                return -EINVAL;

        dev = ieee802154_nl_get_dev(info);
        if (!dev)
                return -ENODEV;
        if (!ieee802154_mlme_ops(dev)->assoc_req)
                goto out;

        if (info->attrs[IEEE802154_ATTR_COORD_HW_ADDR]) {
                addr.mode = IEEE802154_ADDR_LONG;
                addr.extended_addr = nla_get_hwaddr(
                                info->attrs[IEEE802154_ATTR_COORD_HW_ADDR]);
        } else {
                addr.mode = IEEE802154_ADDR_SHORT;
                addr.short_addr = nla_get_shortaddr(
                                info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR]);
        }
        addr.pan_id = nla_get_shortaddr(
                        info->attrs[IEEE802154_ATTR_COORD_PAN_ID]);

        page = nla_get_u8_default(info->attrs[IEEE802154_ATTR_PAGE], 0);

        ret = ieee802154_mlme_ops(dev)->assoc_req(dev, &addr,
                        nla_get_u8(info->attrs[IEEE802154_ATTR_CHANNEL]),
                        page,
                        nla_get_u8(info->attrs[IEEE802154_ATTR_CAPABILITY]));

out:
        dev_put(dev);
        return ret;
}

int ieee802154_associate_resp(struct sk_buff *skb, struct genl_info *info)
{
        struct net_device *dev;
        struct ieee802154_addr addr;
        int ret = -EOPNOTSUPP;

        if (!info->attrs[IEEE802154_ATTR_STATUS] ||
            !info->attrs[IEEE802154_ATTR_DEST_HW_ADDR] ||
            !info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR])
                return -EINVAL;

        dev = ieee802154_nl_get_dev(info);
        if (!dev)
                return -ENODEV;
        if (!ieee802154_mlme_ops(dev)->assoc_resp)
                goto out;

        addr.mode = IEEE802154_ADDR_LONG;
        addr.extended_addr = nla_get_hwaddr(
                        info->attrs[IEEE802154_ATTR_DEST_HW_ADDR]);
        rtnl_lock();
        addr.pan_id = dev->ieee802154_ptr->pan_id;
        rtnl_unlock();

        ret = ieee802154_mlme_ops(dev)->assoc_resp(dev, &addr,
                nla_get_shortaddr(info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR]),
                nla_get_u8(info->attrs[IEEE802154_ATTR_STATUS]));

out:
        dev_put(dev);
        return ret;
}

int ieee802154_disassociate_req(struct sk_buff *skb, struct genl_info *info)
{
        struct net_device *dev;
        struct ieee802154_addr addr;
        int ret = -EOPNOTSUPP;

        if ((!info->attrs[IEEE802154_ATTR_DEST_HW_ADDR] &&
            !info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR]) ||
            !info->attrs[IEEE802154_ATTR_REASON])
                return -EINVAL;

        dev = ieee802154_nl_get_dev(info);
        if (!dev)
                return -ENODEV;
        if (!ieee802154_mlme_ops(dev)->disassoc_req)
                goto out;

        if (info->attrs[IEEE802154_ATTR_DEST_HW_ADDR]) {
                addr.mode = IEEE802154_ADDR_LONG;
                addr.extended_addr = nla_get_hwaddr(
                                info->attrs[IEEE802154_ATTR_DEST_HW_ADDR]);
        } else {
                addr.mode = IEEE802154_ADDR_SHORT;
                addr.short_addr = nla_get_shortaddr(
                                info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR]);
        }
        rtnl_lock();
        addr.pan_id = dev->ieee802154_ptr->pan_id;
        rtnl_unlock();

        ret = ieee802154_mlme_ops(dev)->disassoc_req(dev, &addr,
                        nla_get_u8(info->attrs[IEEE802154_ATTR_REASON]));

out:
        dev_put(dev);
        return ret;
}

/* PANid, channel, beacon_order = 15, superframe_order = 15,
 * PAN_coordinator, battery_life_extension = 0,
 * coord_realignment = 0, security_enable = 0
*/
int ieee802154_start_req(struct sk_buff *skb, struct genl_info *info)
{
        struct net_device *dev;
        struct ieee802154_addr addr;

        u8 channel, bcn_ord, sf_ord;
        u8 page;
        int pan_coord, blx, coord_realign;
        int ret = -EBUSY;

        if (!info->attrs[IEEE802154_ATTR_COORD_PAN_ID] ||
            !info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR] ||
            !info->attrs[IEEE802154_ATTR_CHANNEL] ||
            !info->attrs[IEEE802154_ATTR_BCN_ORD] ||
            !info->attrs[IEEE802154_ATTR_SF_ORD] ||
            !info->attrs[IEEE802154_ATTR_PAN_COORD] ||
            !info->attrs[IEEE802154_ATTR_BAT_EXT] ||
            !info->attrs[IEEE802154_ATTR_COORD_REALIGN]
         )
                return -EINVAL;

        dev = ieee802154_nl_get_dev(info);
        if (!dev)
                return -ENODEV;

        if (netif_running(dev))
                goto out;

        if (!ieee802154_mlme_ops(dev)->start_req) {
                ret = -EOPNOTSUPP;
                goto out;
        }

        addr.mode = IEEE802154_ADDR_SHORT;
        addr.short_addr = nla_get_shortaddr(
                        info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR]);
        addr.pan_id = nla_get_shortaddr(
                        info->attrs[IEEE802154_ATTR_COORD_PAN_ID]);

        channel = nla_get_u8(info->attrs[IEEE802154_ATTR_CHANNEL]);
        bcn_ord = nla_get_u8(info->attrs[IEEE802154_ATTR_BCN_ORD]);
        sf_ord = nla_get_u8(info->attrs[IEEE802154_ATTR_SF_ORD]);
        pan_coord = nla_get_u8(info->attrs[IEEE802154_ATTR_PAN_COORD]);
        blx = nla_get_u8(info->attrs[IEEE802154_ATTR_BAT_EXT]);
        coord_realign = nla_get_u8(info->attrs[IEEE802154_ATTR_COORD_REALIGN]);

        page = nla_get_u8_default(info->attrs[IEEE802154_ATTR_PAGE], 0);

        if (addr.short_addr == cpu_to_le16(IEEE802154_ADDR_BROADCAST)) {
                ieee802154_nl_start_confirm(dev, IEEE802154_NO_SHORT_ADDRESS);
                dev_put(dev);
                return -EINVAL;
        }

        rtnl_lock();
        ret = ieee802154_mlme_ops(dev)->start_req(dev, &addr, channel, page,
                bcn_ord, sf_ord, pan_coord, blx, coord_realign);
        rtnl_unlock();

        /* FIXME: add validation for unused parameters to be sane
         * for SoftMAC
         */
        ieee802154_nl_start_confirm(dev, IEEE802154_SUCCESS);

out:
        dev_put(dev);
        return ret;
}

int ieee802154_scan_req(struct sk_buff *skb, struct genl_info *info)
{
        struct net_device *dev;
        int ret = -EOPNOTSUPP;
        u8 type;
        u32 channels;
        u8 duration;
        u8 page;

        if (!info->attrs[IEEE802154_ATTR_SCAN_TYPE] ||
            !info->attrs[IEEE802154_ATTR_CHANNELS] ||
            !info->attrs[IEEE802154_ATTR_DURATION])
                return -EINVAL;

        dev = ieee802154_nl_get_dev(info);
        if (!dev)
                return -ENODEV;
        if (!ieee802154_mlme_ops(dev)->scan_req)
                goto out;

        type = nla_get_u8(info->attrs[IEEE802154_ATTR_SCAN_TYPE]);
        channels = nla_get_u32(info->attrs[IEEE802154_ATTR_CHANNELS]);
        duration = nla_get_u8(info->attrs[IEEE802154_ATTR_DURATION]);

        page = nla_get_u8_default(info->attrs[IEEE802154_ATTR_PAGE], 0);

        ret = ieee802154_mlme_ops(dev)->scan_req(dev, type, channels,
                                                 page, duration);

out:
        dev_put(dev);
        return ret;
}

int ieee802154_list_iface(struct sk_buff *skb, struct genl_info *info)
{
        /* Request for interface name, index, type, IEEE address,
         * PAN Id, short address
         */
        struct sk_buff *msg;
        struct net_device *dev = NULL;
        int rc = -ENOBUFS;

        pr_debug("%s\n", __func__);

        dev = ieee802154_nl_get_dev(info);
        if (!dev)
                return -ENODEV;

        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
        if (!msg)
                goto out_dev;

        rc = ieee802154_nl_fill_iface(msg, info->snd_portid, info->snd_seq,
                                      0, dev);
        if (rc < 0)
                goto out_free;

        dev_put(dev);

        return genlmsg_reply(msg, info);
out_free:
        nlmsg_free(msg);
out_dev:
        dev_put(dev);
        return rc;
}

int ieee802154_dump_iface(struct sk_buff *skb, struct netlink_callback *cb)
{
        struct net *net = sock_net(skb->sk);
        struct net_device *dev;
        int idx;
        int s_idx = cb->args[0];

        pr_debug("%s\n", __func__);

        idx = 0;
        for_each_netdev(net, dev) {
                if (idx < s_idx || dev->type != ARPHRD_IEEE802154)
                        goto cont;

                if (ieee802154_nl_fill_iface(skb, NETLINK_CB(cb->skb).portid,
                                             cb->nlh->nlmsg_seq,
                                             NLM_F_MULTI, dev) < 0)
                        break;
cont:
                idx++;
        }
        cb->args[0] = idx;

        return skb->len;
}

int ieee802154_set_macparams(struct sk_buff *skb, struct genl_info *info)
{
        struct net_device *dev = NULL;
        struct ieee802154_mlme_ops *ops;
        struct ieee802154_mac_params params;
        struct wpan_phy *phy;
        int rc = -EINVAL;

        pr_debug("%s\n", __func__);

        dev = ieee802154_nl_get_dev(info);
        if (!dev)
                return -ENODEV;

        ops = ieee802154_mlme_ops(dev);

        if (!ops->get_mac_params || !ops->set_mac_params) {
                rc = -EOPNOTSUPP;
                goto out;
        }

        if (netif_running(dev)) {
                rc = -EBUSY;
                goto out;
        }

        if (!info->attrs[IEEE802154_ATTR_LBT_ENABLED] &&
            !info->attrs[IEEE802154_ATTR_CCA_MODE] &&
            !info->attrs[IEEE802154_ATTR_CCA_ED_LEVEL] &&
            !info->attrs[IEEE802154_ATTR_CSMA_RETRIES] &&
            !info->attrs[IEEE802154_ATTR_CSMA_MIN_BE] &&
            !info->attrs[IEEE802154_ATTR_CSMA_MAX_BE] &&
            !info->attrs[IEEE802154_ATTR_FRAME_RETRIES])
                goto out;

        phy = dev->ieee802154_ptr->wpan_phy;
        get_device(&phy->dev);

        rtnl_lock();
        ops->get_mac_params(dev, &params);

        if (info->attrs[IEEE802154_ATTR_TXPOWER])
                params.transmit_power = nla_get_s8(info->attrs[IEEE802154_ATTR_TXPOWER]) * 100;

        if (info->attrs[IEEE802154_ATTR_LBT_ENABLED])
                params.lbt = nla_get_u8(info->attrs[IEEE802154_ATTR_LBT_ENABLED]);

        if (info->attrs[IEEE802154_ATTR_CCA_MODE])
                params.cca.mode = nla_get_u8(info->attrs[IEEE802154_ATTR_CCA_MODE]);

        if (info->attrs[IEEE802154_ATTR_CCA_ED_LEVEL])
                params.cca_ed_level = nla_get_s32(info->attrs[IEEE802154_ATTR_CCA_ED_LEVEL]) * 100;

        if (info->attrs[IEEE802154_ATTR_CSMA_RETRIES])
                params.csma_retries = nla_get_u8(info->attrs[IEEE802154_ATTR_CSMA_RETRIES]);

        if (info->attrs[IEEE802154_ATTR_CSMA_MIN_BE])
                params.min_be = nla_get_u8(info->attrs[IEEE802154_ATTR_CSMA_MIN_BE]);

        if (info->attrs[IEEE802154_ATTR_CSMA_MAX_BE])
                params.max_be = nla_get_u8(info->attrs[IEEE802154_ATTR_CSMA_MAX_BE]);

        if (info->attrs[IEEE802154_ATTR_FRAME_RETRIES])
                params.frame_retries = nla_get_s8(info->attrs[IEEE802154_ATTR_FRAME_RETRIES]);

        rc = ops->set_mac_params(dev, &params);
        rtnl_unlock();

        wpan_phy_put(phy);
        dev_put(dev);

        return 0;

out:
        dev_put(dev);
        return rc;
}

static int
ieee802154_llsec_parse_key_id(struct genl_info *info,
                              struct ieee802154_llsec_key_id *desc)
{
        memset(desc, 0, sizeof(*desc));

        if (!info->attrs[IEEE802154_ATTR_LLSEC_KEY_MODE])
                return -EINVAL;

        desc->mode = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_KEY_MODE]);

        if (desc->mode == IEEE802154_SCF_KEY_IMPLICIT) {
                if (!info->attrs[IEEE802154_ATTR_PAN_ID])
                        return -EINVAL;

                desc->device_addr.pan_id = nla_get_shortaddr(info->attrs[IEEE802154_ATTR_PAN_ID]);

                if (info->attrs[IEEE802154_ATTR_SHORT_ADDR]) {
                        desc->device_addr.mode = IEEE802154_ADDR_SHORT;
                        desc->device_addr.short_addr = nla_get_shortaddr(info->attrs[IEEE802154_ATTR_SHORT_ADDR]);
                } else {
                        if (!info->attrs[IEEE802154_ATTR_HW_ADDR])
                                return -EINVAL;

                        desc->device_addr.mode = IEEE802154_ADDR_LONG;
                        desc->device_addr.extended_addr = nla_get_hwaddr(info->attrs[IEEE802154_ATTR_HW_ADDR]);
                }
        }

        if (desc->mode != IEEE802154_SCF_KEY_IMPLICIT &&
            !info->attrs[IEEE802154_ATTR_LLSEC_KEY_ID])
                return -EINVAL;

        if (desc->mode == IEEE802154_SCF_KEY_SHORT_INDEX &&
            !info->attrs[IEEE802154_ATTR_LLSEC_KEY_SOURCE_SHORT])
                return -EINVAL;

        if (desc->mode == IEEE802154_SCF_KEY_HW_INDEX &&
            !info->attrs[IEEE802154_ATTR_LLSEC_KEY_SOURCE_EXTENDED])
                return -EINVAL;

        if (desc->mode != IEEE802154_SCF_KEY_IMPLICIT)
                desc->id = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_KEY_ID]);

        switch (desc->mode) {
        case IEEE802154_SCF_KEY_SHORT_INDEX:
        {
                u32 source = nla_get_u32(info->attrs[IEEE802154_ATTR_LLSEC_KEY_SOURCE_SHORT]);

                desc->short_source = cpu_to_le32(source);
                break;
        }
        case IEEE802154_SCF_KEY_HW_INDEX:
                desc->extended_source = nla_get_hwaddr(info->attrs[IEEE802154_ATTR_LLSEC_KEY_SOURCE_EXTENDED]);
                break;
        }

        return 0;
}

static int
ieee802154_llsec_fill_key_id(struct sk_buff *msg,
                             const struct ieee802154_llsec_key_id *desc)
{
        if (nla_put_u8(msg, IEEE802154_ATTR_LLSEC_KEY_MODE, desc->mode))
                return -EMSGSIZE;

        if (desc->mode == IEEE802154_SCF_KEY_IMPLICIT) {
                if (nla_put_shortaddr(msg, IEEE802154_ATTR_PAN_ID,
                                      desc->device_addr.pan_id))
                        return -EMSGSIZE;

                if (desc->device_addr.mode == IEEE802154_ADDR_SHORT &&
                    nla_put_shortaddr(msg, IEEE802154_ATTR_SHORT_ADDR,
                                      desc->device_addr.short_addr))
                        return -EMSGSIZE;

                if (desc->device_addr.mode == IEEE802154_ADDR_LONG &&
                    nla_put_hwaddr(msg, IEEE802154_ATTR_HW_ADDR,
                                   desc->device_addr.extended_addr,
                                   IEEE802154_ATTR_PAD))
                        return -EMSGSIZE;
        }

        if (desc->mode != IEEE802154_SCF_KEY_IMPLICIT &&
            nla_put_u8(msg, IEEE802154_ATTR_LLSEC_KEY_ID, desc->id))
                return -EMSGSIZE;

        if (desc->mode == IEEE802154_SCF_KEY_SHORT_INDEX &&
            nla_put_u32(msg, IEEE802154_ATTR_LLSEC_KEY_SOURCE_SHORT,
                        le32_to_cpu(desc->short_source)))
                return -EMSGSIZE;

        if (desc->mode == IEEE802154_SCF_KEY_HW_INDEX &&
            nla_put_hwaddr(msg, IEEE802154_ATTR_LLSEC_KEY_SOURCE_EXTENDED,
                           desc->extended_source, IEEE802154_ATTR_PAD))
                return -EMSGSIZE;

        return 0;
}

int ieee802154_llsec_getparams(struct sk_buff *skb, struct genl_info *info)
{
        struct sk_buff *msg;
        struct net_device *dev = NULL;
        int rc = -ENOBUFS;
        struct ieee802154_mlme_ops *ops;
        void *hdr;
        struct ieee802154_llsec_params params;

        pr_debug("%s\n", __func__);

        dev = ieee802154_nl_get_dev(info);
        if (!dev)
                return -ENODEV;

        ops = ieee802154_mlme_ops(dev);
        if (!ops->llsec) {
                rc = -EOPNOTSUPP;
                goto out_dev;
        }

        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
        if (!msg)
                goto out_dev;

        hdr = genlmsg_put(msg, 0, info->snd_seq, &nl802154_family, 0,
                          IEEE802154_LLSEC_GETPARAMS);
        if (!hdr)
                goto out_free;

        rc = ops->llsec->get_params(dev, &params);
        if (rc < 0)
                goto out_free;

        if (nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name) ||
            nla_put_u32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex) ||
            nla_put_u8(msg, IEEE802154_ATTR_LLSEC_ENABLED, params.enabled) ||
            nla_put_u8(msg, IEEE802154_ATTR_LLSEC_SECLEVEL, params.out_level) ||
            nla_put_u32(msg, IEEE802154_ATTR_LLSEC_FRAME_COUNTER,
                        be32_to_cpu(params.frame_counter)) ||
            ieee802154_llsec_fill_key_id(msg, &params.out_key)) {
                rc = -ENOBUFS;
                goto out_free;
        }

        dev_put(dev);

        return ieee802154_nl_reply(msg, info);
out_free:
        nlmsg_free(msg);
out_dev:
        dev_put(dev);
        return rc;
}

int ieee802154_llsec_setparams(struct sk_buff *skb, struct genl_info *info)
{
        struct net_device *dev = NULL;
        int rc = -EINVAL;
        struct ieee802154_mlme_ops *ops;
        struct ieee802154_llsec_params params;
        int changed = 0;

        pr_debug("%s\n", __func__);

        dev = ieee802154_nl_get_dev(info);
        if (!dev)
                return -ENODEV;

        if (!info->attrs[IEEE802154_ATTR_LLSEC_ENABLED] &&
            !info->attrs[IEEE802154_ATTR_LLSEC_KEY_MODE] &&
            !info->attrs[IEEE802154_ATTR_LLSEC_SECLEVEL])
                goto out;

        ops = ieee802154_mlme_ops(dev);
        if (!ops->llsec) {
                rc = -EOPNOTSUPP;
                goto out;
        }

        if (info->attrs[IEEE802154_ATTR_LLSEC_SECLEVEL] &&
            nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_SECLEVEL]) > 7)
                goto out;

        if (info->attrs[IEEE802154_ATTR_LLSEC_ENABLED]) {
                params.enabled = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_ENABLED]);
                changed |= IEEE802154_LLSEC_PARAM_ENABLED;
        }

        if (info->attrs[IEEE802154_ATTR_LLSEC_KEY_MODE]) {
                if (ieee802154_llsec_parse_key_id(info, &params.out_key))
                        goto out;

                changed |= IEEE802154_LLSEC_PARAM_OUT_KEY;
        }

        if (info->attrs[IEEE802154_ATTR_LLSEC_SECLEVEL]) {
                params.out_level = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_SECLEVEL]);
                changed |= IEEE802154_LLSEC_PARAM_OUT_LEVEL;
        }

        if (info->attrs[IEEE802154_ATTR_LLSEC_FRAME_COUNTER]) {
                u32 fc = nla_get_u32(info->attrs[IEEE802154_ATTR_LLSEC_FRAME_COUNTER]);

                params.frame_counter = cpu_to_be32(fc);
                changed |= IEEE802154_LLSEC_PARAM_FRAME_COUNTER;
        }

        rc = ops->llsec->set_params(dev, &params, changed);

        dev_put(dev);

        return rc;
out:
        dev_put(dev);
        return rc;
}

struct llsec_dump_data {
        struct sk_buff *skb;
        int s_idx, s_idx2;
        int portid;
        int nlmsg_seq;
        struct net_device *dev;
        struct ieee802154_mlme_ops *ops;
        struct ieee802154_llsec_table *table;
};

static int
ieee802154_llsec_dump_table(struct sk_buff *skb, struct netlink_callback *cb,
                            int (*step)(struct llsec_dump_data *))
{
        struct net *net = sock_net(skb->sk);
        struct net_device *dev;
        struct llsec_dump_data data;
        int idx = 0;
        int first_dev = cb->args[0];
        int rc;

        for_each_netdev(net, dev) {
                if (idx < first_dev || dev->type != ARPHRD_IEEE802154)
                        goto skip;

                data.ops = ieee802154_mlme_ops(dev);
                if (!data.ops->llsec)
                        goto skip;

                data.skb = skb;
                data.s_idx = cb->args[1];
                data.s_idx2 = cb->args[2];
                data.dev = dev;
                data.portid = NETLINK_CB(cb->skb).portid;
                data.nlmsg_seq = cb->nlh->nlmsg_seq;

                data.ops->llsec->lock_table(dev);
                data.ops->llsec->get_table(data.dev, &data.table);
                rc = step(&data);
                data.ops->llsec->unlock_table(dev);

                if (rc < 0)
                        break;

skip:
                idx++;
        }
        cb->args[0] = idx;

        return skb->len;
}

static int
ieee802154_nl_llsec_change(struct sk_buff *skb, struct genl_info *info,
                           int (*fn)(struct net_device*, struct genl_info*))
{
        struct net_device *dev = NULL;
        int rc = -EINVAL;

        dev = ieee802154_nl_get_dev(info);
        if (!dev)
                return -ENODEV;

        if (!ieee802154_mlme_ops(dev)->llsec)
                rc = -EOPNOTSUPP;
        else
                rc = fn(dev, info);

        dev_put(dev);
        return rc;
}

static int
ieee802154_llsec_parse_key(struct genl_info *info,
                           struct ieee802154_llsec_key *key)
{
        u8 frames;
        u32 commands[256 / 32];

        memset(key, 0, sizeof(*key));

        if (!info->attrs[IEEE802154_ATTR_LLSEC_KEY_USAGE_FRAME_TYPES] ||
            !info->attrs[IEEE802154_ATTR_LLSEC_KEY_BYTES])
                return -EINVAL;

        frames = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_KEY_USAGE_FRAME_TYPES]);
        if ((frames & BIT(IEEE802154_FC_TYPE_MAC_CMD)) &&
            !info->attrs[IEEE802154_ATTR_LLSEC_KEY_USAGE_COMMANDS])
                return -EINVAL;

        if (info->attrs[IEEE802154_ATTR_LLSEC_KEY_USAGE_COMMANDS]) {
                nla_memcpy(commands,
                           info->attrs[IEEE802154_ATTR_LLSEC_KEY_USAGE_COMMANDS],
                           256 / 8);

                if (commands[0] || commands[1] || commands[2] || commands[3] ||
                    commands[4] || commands[5] || commands[6] ||
                    commands[7] >= BIT(IEEE802154_CMD_GTS_REQ + 1))
                        return -EINVAL;

                key->cmd_frame_ids = commands[7];
        }

        key->frame_types = frames;

        nla_memcpy(key->key, info->attrs[IEEE802154_ATTR_LLSEC_KEY_BYTES],
                   IEEE802154_LLSEC_KEY_SIZE);

        return 0;
}

static int llsec_add_key(struct net_device *dev, struct genl_info *info)
{
        struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
        struct ieee802154_llsec_key key;
        struct ieee802154_llsec_key_id id;

        if (ieee802154_llsec_parse_key(info, &key) ||
            ieee802154_llsec_parse_key_id(info, &id))
                return -EINVAL;

        return ops->llsec->add_key(dev, &id, &key);
}

int ieee802154_llsec_add_key(struct sk_buff *skb, struct genl_info *info)
{
        if ((info->nlhdr->nlmsg_flags & (NLM_F_CREATE | NLM_F_EXCL)) !=
            (NLM_F_CREATE | NLM_F_EXCL))
                return -EINVAL;

        return ieee802154_nl_llsec_change(skb, info, llsec_add_key);
}

static int llsec_remove_key(struct net_device *dev, struct genl_info *info)
{
        struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
        struct ieee802154_llsec_key_id id;

        if (ieee802154_llsec_parse_key_id(info, &id))
                return -EINVAL;

        return ops->llsec->del_key(dev, &id);
}

int ieee802154_llsec_del_key(struct sk_buff *skb, struct genl_info *info)
{
        return ieee802154_nl_llsec_change(skb, info, llsec_remove_key);
}

static int
ieee802154_nl_fill_key(struct sk_buff *msg, u32 portid, u32 seq,
                       const struct ieee802154_llsec_key_entry *key,
                       const struct net_device *dev)
{
        void *hdr;
        u32 commands[256 / 32];

        hdr = genlmsg_put(msg, 0, seq, &nl802154_family, NLM_F_MULTI,
                          IEEE802154_LLSEC_LIST_KEY);
        if (!hdr)
                goto out;

        if (nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name) ||
            nla_put_u32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex) ||
            ieee802154_llsec_fill_key_id(msg, &key->id) ||
            nla_put_u8(msg, IEEE802154_ATTR_LLSEC_KEY_USAGE_FRAME_TYPES,
                       key->key->frame_types))
                goto nla_put_failure;

        if (key->key->frame_types & BIT(IEEE802154_FC_TYPE_MAC_CMD)) {
                memset(commands, 0, sizeof(commands));
                commands[7] = key->key->cmd_frame_ids;
                if (nla_put(msg, IEEE802154_ATTR_LLSEC_KEY_USAGE_COMMANDS,
                            sizeof(commands), commands))
                        goto nla_put_failure;
        }

        if (nla_put(msg, IEEE802154_ATTR_LLSEC_KEY_BYTES,
                    IEEE802154_LLSEC_KEY_SIZE, key->key->key))
                goto nla_put_failure;

        genlmsg_end(msg, hdr);
        return 0;

nla_put_failure:
        genlmsg_cancel(msg, hdr);
out:
        return -EMSGSIZE;
}

static int llsec_iter_keys(struct llsec_dump_data *data)
{
        struct ieee802154_llsec_key_entry *pos;
        int rc = 0, idx = 0;

        list_for_each_entry(pos, &data->table->keys, list) {
                if (idx++ < data->s_idx)
                        continue;

                if (ieee802154_nl_fill_key(data->skb, data->portid,
                                           data->nlmsg_seq, pos, data->dev)) {
                        rc = -EMSGSIZE;
                        break;
                }

                data->s_idx++;
        }

        return rc;
}

int ieee802154_llsec_dump_keys(struct sk_buff *skb, struct netlink_callback *cb)
{
        return ieee802154_llsec_dump_table(skb, cb, llsec_iter_keys);
}

static int
llsec_parse_dev(struct genl_info *info,
                struct ieee802154_llsec_device *dev)
{
        memset(dev, 0, sizeof(*dev));

        if (!info->attrs[IEEE802154_ATTR_LLSEC_FRAME_COUNTER] ||
            !info->attrs[IEEE802154_ATTR_HW_ADDR] ||
            !info->attrs[IEEE802154_ATTR_LLSEC_DEV_OVERRIDE] ||
            !info->attrs[IEEE802154_ATTR_LLSEC_DEV_KEY_MODE] ||
            (!!info->attrs[IEEE802154_ATTR_PAN_ID] !=
             !!info->attrs[IEEE802154_ATTR_SHORT_ADDR]))
                return -EINVAL;

        if (info->attrs[IEEE802154_ATTR_PAN_ID]) {
                dev->pan_id = nla_get_shortaddr(info->attrs[IEEE802154_ATTR_PAN_ID]);
                dev->short_addr = nla_get_shortaddr(info->attrs[IEEE802154_ATTR_SHORT_ADDR]);
        } else {
                dev->short_addr = cpu_to_le16(IEEE802154_ADDR_UNDEF);
        }

        dev->hwaddr = nla_get_hwaddr(info->attrs[IEEE802154_ATTR_HW_ADDR]);
        dev->frame_counter = nla_get_u32(info->attrs[IEEE802154_ATTR_LLSEC_FRAME_COUNTER]);
        dev->seclevel_exempt = !!nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_DEV_OVERRIDE]);
        dev->key_mode = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_DEV_KEY_MODE]);

        if (dev->key_mode >= __IEEE802154_LLSEC_DEVKEY_MAX)
                return -EINVAL;

        return 0;
}

static int llsec_add_dev(struct net_device *dev, struct genl_info *info)
{
        struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
        struct ieee802154_llsec_device desc;

        if (llsec_parse_dev(info, &desc))
                return -EINVAL;

        return ops->llsec->add_dev(dev, &desc);
}

int ieee802154_llsec_add_dev(struct sk_buff *skb, struct genl_info *info)
{
        if ((info->nlhdr->nlmsg_flags & (NLM_F_CREATE | NLM_F_EXCL)) !=
            (NLM_F_CREATE | NLM_F_EXCL))
                return -EINVAL;

        return ieee802154_nl_llsec_change(skb, info, llsec_add_dev);
}

static int llsec_del_dev(struct net_device *dev, struct genl_info *info)
{
        struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
        __le64 devaddr;

        if (!info->attrs[IEEE802154_ATTR_HW_ADDR])
                return -EINVAL;

        devaddr = nla_get_hwaddr(info->attrs[IEEE802154_ATTR_HW_ADDR]);

        return ops->llsec->del_dev(dev, devaddr);
}

int ieee802154_llsec_del_dev(struct sk_buff *skb, struct genl_info *info)
{
        return ieee802154_nl_llsec_change(skb, info, llsec_del_dev);
}

static int
ieee802154_nl_fill_dev(struct sk_buff *msg, u32 portid, u32 seq,
                       const struct ieee802154_llsec_device *desc,
                       const struct net_device *dev)
{
        void *hdr;

        hdr = genlmsg_put(msg, 0, seq, &nl802154_family, NLM_F_MULTI,
                          IEEE802154_LLSEC_LIST_DEV);
        if (!hdr)
                goto out;

        if (nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name) ||
            nla_put_u32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex) ||
            nla_put_shortaddr(msg, IEEE802154_ATTR_PAN_ID, desc->pan_id) ||
            nla_put_shortaddr(msg, IEEE802154_ATTR_SHORT_ADDR,
                              desc->short_addr) ||
            nla_put_hwaddr(msg, IEEE802154_ATTR_HW_ADDR, desc->hwaddr,
                           IEEE802154_ATTR_PAD) ||
            nla_put_u32(msg, IEEE802154_ATTR_LLSEC_FRAME_COUNTER,
                        desc->frame_counter) ||
            nla_put_u8(msg, IEEE802154_ATTR_LLSEC_DEV_OVERRIDE,
                       desc->seclevel_exempt) ||
            nla_put_u8(msg, IEEE802154_ATTR_LLSEC_DEV_KEY_MODE, desc->key_mode))
                goto nla_put_failure;

        genlmsg_end(msg, hdr);
        return 0;

nla_put_failure:
        genlmsg_cancel(msg, hdr);
out:
        return -EMSGSIZE;
}

static int llsec_iter_devs(struct llsec_dump_data *data)
{
        struct ieee802154_llsec_device *pos;
        int rc = 0, idx = 0;

        list_for_each_entry(pos, &data->table->devices, list) {
                if (idx++ < data->s_idx)
                        continue;

                if (ieee802154_nl_fill_dev(data->skb, data->portid,
                                           data->nlmsg_seq, pos, data->dev)) {
                        rc = -EMSGSIZE;
                        break;
                }

                data->s_idx++;
        }

        return rc;
}

int ieee802154_llsec_dump_devs(struct sk_buff *skb, struct netlink_callback *cb)
{
        return ieee802154_llsec_dump_table(skb, cb, llsec_iter_devs);
}

static int llsec_add_devkey(struct net_device *dev, struct genl_info *info)
{
        struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
        struct ieee802154_llsec_device_key key;
        __le64 devaddr;

        if (!info->attrs[IEEE802154_ATTR_LLSEC_FRAME_COUNTER] ||
            !info->attrs[IEEE802154_ATTR_HW_ADDR] ||
            ieee802154_llsec_parse_key_id(info, &key.key_id))
                return -EINVAL;

        devaddr = nla_get_hwaddr(info->attrs[IEEE802154_ATTR_HW_ADDR]);
        key.frame_counter = nla_get_u32(info->attrs[IEEE802154_ATTR_LLSEC_FRAME_COUNTER]);

        return ops->llsec->add_devkey(dev, devaddr, &key);
}

int ieee802154_llsec_add_devkey(struct sk_buff *skb, struct genl_info *info)
{
        if ((info->nlhdr->nlmsg_flags & (NLM_F_CREATE | NLM_F_EXCL)) !=
            (NLM_F_CREATE | NLM_F_EXCL))
                return -EINVAL;

        return ieee802154_nl_llsec_change(skb, info, llsec_add_devkey);
}

static int llsec_del_devkey(struct net_device *dev, struct genl_info *info)
{
        struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
        struct ieee802154_llsec_device_key key;
        __le64 devaddr;

        if (!info->attrs[IEEE802154_ATTR_HW_ADDR] ||
            ieee802154_llsec_parse_key_id(info, &key.key_id))
                return -EINVAL;

        devaddr = nla_get_hwaddr(info->attrs[IEEE802154_ATTR_HW_ADDR]);

        return ops->llsec->del_devkey(dev, devaddr, &key);
}

int ieee802154_llsec_del_devkey(struct sk_buff *skb, struct genl_info *info)
{
        return ieee802154_nl_llsec_change(skb, info, llsec_del_devkey);
}

static int
ieee802154_nl_fill_devkey(struct sk_buff *msg, u32 portid, u32 seq,
                          __le64 devaddr,
                          const struct ieee802154_llsec_device_key *devkey,
                          const struct net_device *dev)
{
        void *hdr;

        hdr = genlmsg_put(msg, 0, seq, &nl802154_family, NLM_F_MULTI,
                          IEEE802154_LLSEC_LIST_DEVKEY);
        if (!hdr)
                goto out;

        if (nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name) ||
            nla_put_u32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex) ||
            nla_put_hwaddr(msg, IEEE802154_ATTR_HW_ADDR, devaddr,
                           IEEE802154_ATTR_PAD) ||
            nla_put_u32(msg, IEEE802154_ATTR_LLSEC_FRAME_COUNTER,
                        devkey->frame_counter) ||
            ieee802154_llsec_fill_key_id(msg, &devkey->key_id))
                goto nla_put_failure;

        genlmsg_end(msg, hdr);
        return 0;

nla_put_failure:
        genlmsg_cancel(msg, hdr);
out:
        return -EMSGSIZE;
}

static int llsec_iter_devkeys(struct llsec_dump_data *data)
{
        struct ieee802154_llsec_device *dpos;
        struct ieee802154_llsec_device_key *kpos;
        int idx = 0, idx2;

        list_for_each_entry(dpos, &data->table->devices, list) {
                if (idx++ < data->s_idx)
                        continue;

                idx2 = 0;

                list_for_each_entry(kpos, &dpos->keys, list) {
                        if (idx2++ < data->s_idx2)
                                continue;

                        if (ieee802154_nl_fill_devkey(data->skb, data->portid,
                                                      data->nlmsg_seq,
                                                      dpos->hwaddr, kpos,
                                                      data->dev)) {
                                return -EMSGSIZE;
                        }

                        data->s_idx2++;
                }

                data->s_idx++;
        }

        return 0;
}

int ieee802154_llsec_dump_devkeys(struct sk_buff *skb,
                                  struct netlink_callback *cb)
{
        return ieee802154_llsec_dump_table(skb, cb, llsec_iter_devkeys);
}

static int
llsec_parse_seclevel(struct genl_info *info,
                     struct ieee802154_llsec_seclevel *sl)
{
        memset(sl, 0, sizeof(*sl));

        if (!info->attrs[IEEE802154_ATTR_LLSEC_FRAME_TYPE] ||
            !info->attrs[IEEE802154_ATTR_LLSEC_SECLEVELS] ||
            !info->attrs[IEEE802154_ATTR_LLSEC_DEV_OVERRIDE])
                return -EINVAL;

        sl->frame_type = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_FRAME_TYPE]);
        if (sl->frame_type == IEEE802154_FC_TYPE_MAC_CMD) {
                if (!info->attrs[IEEE802154_ATTR_LLSEC_CMD_FRAME_ID])
                        return -EINVAL;

                sl->cmd_frame_id = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_CMD_FRAME_ID]);
        }

        sl->sec_levels = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_SECLEVELS]);
        sl->device_override = nla_get_u8(info->attrs[IEEE802154_ATTR_LLSEC_DEV_OVERRIDE]);

        return 0;
}

static int llsec_add_seclevel(struct net_device *dev, struct genl_info *info)
{
        struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
        struct ieee802154_llsec_seclevel sl;

        if (llsec_parse_seclevel(info, &sl))
                return -EINVAL;

        return ops->llsec->add_seclevel(dev, &sl);
}

int ieee802154_llsec_add_seclevel(struct sk_buff *skb, struct genl_info *info)
{
        if ((info->nlhdr->nlmsg_flags & (NLM_F_CREATE | NLM_F_EXCL)) !=
            (NLM_F_CREATE | NLM_F_EXCL))
                return -EINVAL;

        return ieee802154_nl_llsec_change(skb, info, llsec_add_seclevel);
}

static int llsec_del_seclevel(struct net_device *dev, struct genl_info *info)
{
        struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
        struct ieee802154_llsec_seclevel sl;

        if (llsec_parse_seclevel(info, &sl))
                return -EINVAL;

        return ops->llsec->del_seclevel(dev, &sl);
}

int ieee802154_llsec_del_seclevel(struct sk_buff *skb, struct genl_info *info)
{
        return ieee802154_nl_llsec_change(skb, info, llsec_del_seclevel);
}

static int
ieee802154_nl_fill_seclevel(struct sk_buff *msg, u32 portid, u32 seq,
                            const struct ieee802154_llsec_seclevel *sl,
                            const struct net_device *dev)
{
        void *hdr;

        hdr = genlmsg_put(msg, 0, seq, &nl802154_family, NLM_F_MULTI,
                          IEEE802154_LLSEC_LIST_SECLEVEL);
        if (!hdr)
                goto out;

        if (nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name) ||
            nla_put_u32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex) ||
            nla_put_u8(msg, IEEE802154_ATTR_LLSEC_FRAME_TYPE, sl->frame_type) ||
            nla_put_u8(msg, IEEE802154_ATTR_LLSEC_SECLEVELS, sl->sec_levels) ||
            nla_put_u8(msg, IEEE802154_ATTR_LLSEC_DEV_OVERRIDE,
                       sl->device_override))
                goto nla_put_failure;

        if (sl->frame_type == IEEE802154_FC_TYPE_MAC_CMD &&
            nla_put_u8(msg, IEEE802154_ATTR_LLSEC_CMD_FRAME_ID,
                       sl->cmd_frame_id))
                goto nla_put_failure;

        genlmsg_end(msg, hdr);
        return 0;

nla_put_failure:
        genlmsg_cancel(msg, hdr);
out:
        return -EMSGSIZE;
}

static int llsec_iter_seclevels(struct llsec_dump_data *data)
{
        struct ieee802154_llsec_seclevel *pos;
        int rc = 0, idx = 0;

        list_for_each_entry(pos, &data->table->security_levels, list) {
                if (idx++ < data->s_idx)
                        continue;

                if (ieee802154_nl_fill_seclevel(data->skb, data->portid,
                                                data->nlmsg_seq, pos,
                                                data->dev)) {
                        rc = -EMSGSIZE;
                        break;
                }

                data->s_idx++;
        }

        return rc;
}

int ieee802154_llsec_dump_seclevels(struct sk_buff *skb,
                                    struct netlink_callback *cb)
{
        return ieee802154_llsec_dump_table(skb, cb, llsec_iter_seclevels);
}