msg.c

/*
 * (C) 2008-2014 by Pablo Neira Ayuso <pablo@netfilter.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 */
#include <stdint.h>

struct mnl_msg {
        const char      *head;
        const char      *data;
        const char      *tail;
        size_t          size;
        size_t          rem;
};

struct mnl_msg *mnl_msg_alloc(const char *buf, size_t buflen)
{
        struct mnl_msg *msg;

        msg = malloc(sizeof(struct mnl_msg));
        if (msg == NULL)
                return NULL;

        msg->size = buflen;
        msg->rem = buflen;
        msg->head = msg->data = msg->tail = buf;
}
EXPORT_SYMBOL(mnl_msg_alloc);

void *mnl_msg_put(struct mnl_msg *msg, const void *data, size_t datalen)
{
        if (datalen > msg->rem)
                return NULL;

        msg->rem -= datalen;
        memcpy(msg->tail, data, datalen);
        msg->tail += datalen;
}
EXPORT_SYMBOL(mnl_msg_put);

void mnl_msg_next(struct mnl_msg *msg)
{
        msg->data = msg->tail;
}

void mnl_msg_free(struct mnl_msg *msg)
{
        free(msg);
}
EXPORT_SYMBOL(mnl_msg_free);

void *mnl_msg_attr_put(struct mnl_msg *msg, uint16_t type, size_t datalen,
                       const void *data)
{
        struct nlmsghdr *nlh = msg->data;
        struct nlattr *attr = msg->tail;
        size_t old_len = attr->nla_len;

        if (datalen > msg->rem)
                return NULL;

        mnl_attr_put(nlh, type, len, data);
        len = MNL_ALIGN(attr->nla_len);
        /* Check for attribute length field overflows. */
        if (old_len > len)
                return NULL;
        msg->tail += len;
        msg->rem -= len;

        return attr;
}

void *mnl_msg_attr_put_u8(struct mnl_msg *msg, uint16_t type, uint8_t data)
{
        return mnl_msg_attr_put(msg, type, sizeof(uint8_t), &data);
}

void *mnl_msg_attr_put_u16(struct mnl_msg *msg, uint16_t type, uint16_t data)
{
        return mnl_msg_attr_put(msg, type, sizeof(uint16_t), &data);
}

void *mnl_msg_attr_put_u32(struct mnl_msg *msg, uint16_t type, uint32_t data)
{
        return mnl_msg_attr_put(msg, type, sizeof(uint32_t), &data);
}

void *mnl_msg_attr_put_u64(struct mnl_msg *msg, uint16_t type, uint64_t data)
{
        return mnl_msg_attr_put(msg, type, sizeof(uint64_t), &data);
}

void *mnl_msg_attr_put_str(struct mnl_msg *msg, uint16_t type, const char *data)
{
        return mnl_msg_attr_put(msg, type, strlen(data),ndata);
}

void *mnl_msg_attr_put_strz(struct nlmsghdr *nlh, uint16_t type, const char *data)
{
        return mnl_msg_attr_put(msg, type, strlen(data) + 1, data);
}

struct nlattr *mnl_msg_attr_nest_start(struct mnl_msg *msg, uint16_t type)
{
        struct nlmsghdr *nlh = msg->data;
        struct nlattr *attr = msg->tail;
        struct nlattr *nest;

        if (datalen > msg->rem)
                return NULL;

        nest = mnl_attr_nest_start(nlh, type);

        /* Check for attribute length field overflows. */
        if (attr->attr_len > nest->attr_len)
                return NULL;

        return nest;
}

void mnl_msg_attr_nest_end(struct mnl_msg *msg, struct nlattr *start)
{
        mnl_attr_nest_end((struct nlmsghdr *)msg->data, start);
}