root/luci2/libunl/unl/msg.h @ 6262

/**
 *   unl - Minimalistic netlink library
 *   Copyright (C) 2010 Steven Barth <steven@midlink.org>
 *   Copyright (C) 2010 John Crispin <blogic@openwrt.org>
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
 *
 */

#ifndef UNL_MSG_H_
#define UNL_MSG_H_

#include <stdint.h>
#include <string.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#include <linux/genetlink.h>


/* Basic NLA_ macros inspired by rtnetlink RTA_ macros from linux kernel headers */
#define NLA_DATA(nla)   ((void*)(((uint8_t*)(nla)) + NLA_HDRLEN))
#define NLA_PAYLOAD(nla) ((ssize_t)((nla)->nla_len) - NLA_HDRLEN)
#define NLA_OK(nla,len) ((len) >= (ssize_t)sizeof(struct nlattr) && \
                         (nla)->nla_len >= sizeof(struct nlattr) && \
                         (nla)->nla_len <= (len))
#define NLA_NEXT(nla,attrlen)   ((attrlen) -= NLA_ALIGN((nla)->nla_len), \
                                 (struct nlattr*)(((uint8_t*)(nla)) + NLA_ALIGN((nla)->nla_len)))

/**
 * Checks whether given netlink attribute's payload has given length and if so
 * returns its value after casting it it to a given type otherwise returns a
 * default value.
 *
 * nla:     netlink attribute
 * type:    type to cast to
 * def:     default value if attribute is invalid
 */
#define NLA_CAST_NUMBER(nla, type, def) (((nla) && NLA_PAYLOAD(nla) == sizeof(type)) \
    ? *((type*)NLA_DATA(nla)) : (def))

/**
 * Same as NLA_CAST_NUMBER, but verifies that the attribute
 * carries a zero terminated string.
 */
#define NLA_CAST_STRING(nla, def) (((nla) && memchr(NLA_DATA(nla), 0, NLA_PAYLOAD(nla))) \
    ? (char*)NLA_DATA(nla) : (def))

/**
 * Same as NLA_CAST_NUMBER but only checks whether the attribute has
 * given length.
 */
#define NLA_CAST_FIXED(nla, len, def) (((nla) && NLA_PAYLOAD(nla) == len) ? NLA_DATA(nla) : (def))



/* Compiler magic */
#define UNL_FORCE_ALIGNMENT(n) __attribute__((packed,aligned(n)))
#define UNL_ALIGNED UNL_FORCE_ALIGNMENT(NLMSG_ALIGNTO)



/****** NETLINK loop helpers ******/

/**
 * Iterates over each valid netlink message in buffer, using nh as entry pointer
 * Use NLMSG_DATA(nh) to get a pointer to the payload data
 * Use NLMSG_PAYLOAD(nh, 0) to get the size of the payload data
 *
 * nh:      entry pointer pointing to current struct nlmsghdr
 * buffer:  the message buffer
 * len:     the message buffer length
 */
#define unl_foreach_msg(nh, buffer, len) \
    (nh) = (struct nlmsghdr*)(buffer); \
    for (size_t _blen = (len); NLMSG_OK((nh), _blen); (nh) = NLMSG_NEXT((nh), _blen))

/**
 * Iterates over each valid netlink attribute using nla as entry pointer
 * Use NLA_DATA(nla) to get a pointer to the payload data
 * Use NLA_PAYLOAD(nla) to get the size of the payload data
 *
 * nla:     entry pointer pointing to current struct nlmsghdr
 * buffer:  buffer containing attributes
 * len:     buffer length
 */
#define unl_foreach_attr(nla, buffer, len) \
    (nla) = (struct nlattr*)(buffer); \
    for (size_t _rlen = (len); NLA_OK((nla), _rlen); (nla) = NLA_NEXT((nla), _rlen))


/**
 * Iterates over each valid netlink attribute in a netlink message, using nla as entry pointer
 * Use NLA_DATA(nla) to get a pointer to the payload data
 * Use NLA_PAYLOAD(nla) to get the size of the payload data
 *
 * nla:     entry pointer pointing to current struct nlmsghdr
 * nh:      netlink message
 * skip:    the length of the fixed message part - if any - to skip
 */
#define unl_msg_foreach_attr(nla, nh, skip) \
    unl_foreach_attr(nla, ((uint8_t*)NLMSG_DATA((nh))) + NLMSG_ALIGN((skip)), NLMSG_PAYLOAD((nh), (skip)))


/**
 * Same as unl_msg_foreace_attr but skips generic netlink header automatically
 */
#define unl_genlmsg_foreach_attr(nla, nh, skip) \
    unl_msg_foreach_attr(nla, nh, NLMSG_ALIGN(sizeof(struct genlmsghdr)) + skip)


/**
 * Same as unl_foreach_attr but more convenient for nested attributes
 *
 * nla:     entry pointer pointing to current struct nlmsghdr
 * outer:   outer netlink nlattribute
 */
#define unl_attr_foreach_attr(nla, outer) \
    unl_foreach_attr(nla, NLA_DATA((outer)), NLA_PAYLOAD((outer)))




/****** NETLINK message helpers ******/

/**
 * Initializes a buffer for use as a netlink message and sets type and flags.
 *
 * buf:     your buffer (must be at least sizeof(struct nlmsghdr))
 * type:    netlink message type
 * flags:   netlink message flags
 *
 * Returns a pointer to buf as a nlmsghdr.
 */
static inline struct nlmsghdr* unl_msg_init
(void *buf, uint16_t type, uint16_t flags) {
    struct nlmsghdr *nh = buf;
    nh->nlmsg_seq = nh->nlmsg_pid = 0;
    nh->nlmsg_len = sizeof(*nh);
    nh->nlmsg_type = type;
    nh->nlmsg_flags = flags;
    return nh;
}


/**
 * Claims an aligned amount of data from the message buffer
 *
 * buf:     your buffer
 * len:     length of your buffer
 * datalen: data length
 *
 * Returns a pointer to the claimed memory
 */
static inline void* unl_msg_claim
(struct nlmsghdr *nh, uint32_t datalen) {
    void *data = ((uint8_t*)nh) + NLMSG_ALIGN(nh->nlmsg_len);
    nh->nlmsg_len = NLMSG_ALIGN(nh->nlmsg_len) + datalen;
    return data;
}


/**
 * Same as unl_msg_claim but inserts a netlink attribute header before the pointer
 * type: netlink attribute type
 */
static inline void* unl_msg_claim_attr
(struct nlmsghdr *nh, uint16_t type, uint32_t datalen) {
    struct nlattr *nla = unl_msg_claim(nh, NLA_HDRLEN + datalen);
    nla->nla_type = type;
    nla->nla_len = NLA_HDRLEN + datalen;
    return ((uint8_t*)nla) + NLA_HDRLEN;
}


/**
 * Appends a pack of data to the netlink message taking care of alignment, size etc.
 *
 * buf:     your buffer
 * len:     length of your buffer
 * data:    data to append
 * datalen: data length
 *
 * Returns a pointer to the appended data.
 */
static inline void* unl_msg_append
(struct nlmsghdr *nh, const void *data, uint32_t datalen) {
    return memcpy(unl_msg_claim(nh, datalen), data, datalen);
}


/**
 * Same as unl_msg_append but prepends a netlink attribute header
 * type: netlink attribute type
 */
static inline void* unl_msg_append_attr
(struct nlmsghdr *nh, uint16_t type, const void *data, uint16_t datalen) {
    return memcpy(unl_msg_claim_attr(nh, type, datalen), data, datalen);
}


/**
 * Same as unl_msg_append_attr but appends a zero-terminated string
 */
static inline void* unl_msg_append_string
(struct nlmsghdr *nh, uint16_t type, const char *data) {
    return unl_msg_append_attr(nh, type, data, strlen(data) + 1);
}

#define unl_msg_append_number(nh, type, datatype, value) \
    (*((datatype*)unl_msg_claim_attr(nla, type, sizeof(datatype))) = value)


/**
 * Searches a netlink message for a netlink attribute with given type
 *
 * nh:      netlink message
 * skip:    the length of the fixed message part - if any - to skip
 * type:    attribute type
 *
 */
struct nlattr* unl_msg_find(struct nlmsghdr *nh, size_t skip, uint16_t type);

/**
 * Searches a netlink message for all netlink attribute upto a given type
 * id and put them into an array.
 *
 * nh:      netlink message
 * skip:    the length of the fixed message part - if any - to skip
 * nlatbl:  an array where pointers to the attributes
 * maxtype: the highest attribute type id to parse
 *
 * NOTE: nlatbl must have space for at least max + 1 entries
 *
 */
int unl_msg_parse
(struct nlmsghdr *nh, size_t skip, struct nlattr *nlatbl[], uint16_t maxtype);


/****** Generic netlink helpers *******/

/**
 * Drop in replacement for unl_msg_init for generic netlink.
 *
 * buf:     your buffer
 * family:  generic netlink family id
 * flags:   netlink message flags
 * cmd:     generic netlink commands
 * version: generic netlink command version
 */
static inline struct nlmsghdr* unl_genlmsg_init
(void *buf, uint16_t family, uint16_t flags, uint8_t cmd, uint8_t version) {
    struct nlmsghdr *nh = unl_msg_init(buf, family, flags);
    struct genlmsghdr *gmh = unl_msg_claim(nh, sizeof(*gmh));
    gmh->cmd = cmd;
    gmh->version = version;
    return nh;
}

/**
 * Drop in replacement for unl_msg_find for generic netlink.
 * Automatically skips the generic netlink header.
 */
static inline struct nlattr* unl_genlmsg_find(struct nlmsghdr *nh, size_t skip, uint16_t type) {
    return unl_msg_find(nh, NLMSG_ALIGN(sizeof(struct genlmsghdr)) + skip, type);
}


/****** NETLINK attribute helpers ******/




/**
 * Same as unl_msg_init but initializes a netlink attribute
 */
static inline struct nlattr* unl_attr_init
(void *buf, uint16_t type) {
    struct nlattr *nla = buf;
    nla->nla_len = sizeof(*nla);
    nla->nla_type = type;
    return nla;
}


/**
 * Same as unl_msg_claim but claims from a netlink buffer
 */
static inline void* unl_attr_claim
(struct nlattr *nla, size_t datalen) {
    void *data = ((uint8_t*)nla) + NLMSG_ALIGN(nla->nla_len);
    nla->nla_len = NLMSG_ALIGN(nla->nla_len) + datalen;
    return data;
}


/**
 * Same as unl_msg_claim but claims from a netlink buffer
 */
static inline void* unl_attr_claim_attr
(struct nlattr *nla, uint16_t type, size_t datalen) {
    nla = (struct nlattr*)unl_attr_claim(nla, NLA_HDRLEN + datalen);
    nla->nla_type = type;
    nla->nla_len = NLA_HDRLEN + datalen;
    return ((uint8_t*)nla) + NLA_HDRLEN;
}


/**
 * Same as unl_msg_append but appends to a netlink attribute
 */
static inline void* unl_attr_append
(struct nlattr *nla, const void *data, size_t datalen) {
    return memcpy(unl_attr_claim(nla, datalen), data, datalen);
}


/**
 * Same as unl_attr_append but prepends a netlink attribute header
 * type: netlink attribute type
 */
static inline void* unl_attr_append_attr
(struct nlattr *nla, uint16_t type, const void *data, size_t datalen) {
    return memcpy(unl_attr_claim_attr(nla, type, datalen), data, datalen);
}


/**
 * Same as unl_attr_append_nested but appends a zero-terminated string
 */
static inline void* unl_attr_append_string
(struct nlattr *nla, uint16_t type, const char *data) {
    return unl_attr_append_attr(nla, type, data, strlen(data) + 1);
}

#define unl_attr_append_number(nla, type, datatype, value) \
    (*((datatype*)unl_attr_claim_attr(nla, type, sizeof(datatype))) = value)


/**
 * Same as unl_msg_find but searches inside a netlink attribute
 */
struct nlattr* unl_attr_find(struct nlattr *nla, uint16_t type);

/**
 * Same as unl_msg_parse but searches inside a netlink attribute
 */
int unl_attr_parse(struct nlattr *nla, struct nlattr *nlatbl[], uint16_t maxtype);

#endif /* UNL_MSG_H_ */