netem.c

/*
 * lib/route/qdisc/netem.c              Network Emulator Qdisc
 *
 *      This library 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 version 2.1
 *      of the License.
 *
 * Copyright (c) 2003-2011 Thomas Graf <tgraf@suug.ch>
 */

/**
 * @ingroup qdisc
 * @defgroup qdisc_netem Network Emulator
 * @brief
 *
 * For further documentation see http://linux-net.osdl.org/index.php/Netem
 * @{
 */

#include <netlink-private/netlink.h>
#include <netlink-private/tc.h>
#include <netlink/netlink.h>
#include <netlink/utils.h>
#include <netlink-private/route/tc-api.h>
#include <netlink/route/qdisc.h>
#include <netlink/route/qdisc/netem.h>

/** @cond SKIP */
#define SCH_NETEM_ATTR_LATENCY          0x0001
#define SCH_NETEM_ATTR_LIMIT            0x0002
#define SCH_NETEM_ATTR_LOSS                     0x0004
#define SCH_NETEM_ATTR_GAP                      0x0008
#define SCH_NETEM_ATTR_DUPLICATE        0x0010
#define SCH_NETEM_ATTR_JITTER           0x0020
#define SCH_NETEM_ATTR_DELAY_CORR       0x0040
#define SCH_NETEM_ATTR_LOSS_CORR        0x0080
#define SCH_NETEM_ATTR_DUP_CORR         0x0100
#define SCH_NETEM_ATTR_RO_PROB          0x0200
#define SCH_NETEM_ATTR_RO_CORR          0x0400
#define SCH_NETEM_ATTR_CORRUPT_PROB     0x0800
#define SCH_NETEM_ATTR_CORRUPT_CORR     0x1000
#define SCH_NETEM_ATTR_DIST         0x2000
/** @endcond */

static struct nla_policy netem_policy[TCA_NETEM_MAX+1] = {
        [TCA_NETEM_CORR]        = { .minlen = sizeof(struct tc_netem_corr) },
        [TCA_NETEM_REORDER]     = { .minlen = sizeof(struct tc_netem_reorder) },
        [TCA_NETEM_CORRUPT]     = { .minlen = sizeof(struct tc_netem_corrupt) },
};

static int netem_msg_parser(struct rtnl_tc *tc, void *data)
{
        struct rtnl_netem *netem = data;
        struct tc_netem_qopt *opts;
        int len, err = 0;

        if (tc->tc_opts->d_size < sizeof(*opts))
                return -NLE_INVAL;

        opts = (struct tc_netem_qopt *) tc->tc_opts->d_data;
        netem->qnm_latency = opts->latency;
        netem->qnm_limit = opts->limit;
        netem->qnm_loss = opts->loss;
        netem->qnm_gap = opts->gap;
        netem->qnm_duplicate = opts->duplicate;
        netem->qnm_jitter = opts->jitter;

        netem->qnm_mask = (SCH_NETEM_ATTR_LATENCY | SCH_NETEM_ATTR_LIMIT |
                           SCH_NETEM_ATTR_LOSS | SCH_NETEM_ATTR_GAP |
                           SCH_NETEM_ATTR_DUPLICATE | SCH_NETEM_ATTR_JITTER);

        len = tc->tc_opts->d_size - sizeof(*opts);

        if (len > 0) {
                struct nlattr *tb[TCA_NETEM_MAX+1];

                err = nla_parse(tb, TCA_NETEM_MAX, (struct nlattr *)
                                (tc->tc_opts->d_data + sizeof(*opts)),
                                len, netem_policy);
                if (err < 0) {
                        free(netem);
                        return err;
                }

                if (tb[TCA_NETEM_CORR]) {
                        struct tc_netem_corr cor;

                        nla_memcpy(&cor, tb[TCA_NETEM_CORR], sizeof(cor));
                        netem->qnm_corr.nmc_delay = cor.delay_corr;
                        netem->qnm_corr.nmc_loss = cor.loss_corr;
                        netem->qnm_corr.nmc_duplicate = cor.dup_corr;

                        netem->qnm_mask |= (SCH_NETEM_ATTR_DELAY_CORR |
                                            SCH_NETEM_ATTR_LOSS_CORR |
                                        SCH_NETEM_ATTR_DUP_CORR);
                }

                if (tb[TCA_NETEM_REORDER]) {
                        struct tc_netem_reorder ro;

                        nla_memcpy(&ro, tb[TCA_NETEM_REORDER], sizeof(ro));
                        netem->qnm_ro.nmro_probability = ro.probability;
                        netem->qnm_ro.nmro_correlation = ro.correlation;

                        netem->qnm_mask |= (SCH_NETEM_ATTR_RO_PROB |
                                            SCH_NETEM_ATTR_RO_CORR);
                }
                        
                if (tb[TCA_NETEM_CORRUPT]) {
                        struct tc_netem_corrupt corrupt;
                                                
                        nla_memcpy(&corrupt, tb[TCA_NETEM_CORRUPT], sizeof(corrupt));
                        netem->qnm_crpt.nmcr_probability = corrupt.probability;
                        netem->qnm_crpt.nmcr_correlation = corrupt.correlation;
        
                        netem->qnm_mask |= (SCH_NETEM_ATTR_CORRUPT_PROB |
                                                SCH_NETEM_ATTR_CORRUPT_CORR);
                }
                
                /* sch_netem does not currently dump TCA_NETEM_DELAY_DIST */
                netem->qnm_dist.dist_data = NULL;
                netem->qnm_dist.dist_size = 0;
        }

        return 0;
}

static void netem_free_data(struct rtnl_tc *tc, void *data)
{
        struct rtnl_netem *netem = data;
        
        if (!netem)
                return;
        
        free(netem->qnm_dist.dist_data);
}

static void netem_dump_line(struct rtnl_tc *tc, void *data,
                            struct nl_dump_params *p)
{
        struct rtnl_netem *netem = data;

        if (netem)
                nl_dump(p, "limit %d", netem->qnm_limit);
}

static int netem_msg_fill_raw(struct rtnl_tc *tc, void *data,
                              struct nl_msg *msg)
{
        int err = 0;
        struct tc_netem_qopt opts;
        struct tc_netem_corr cor;
        struct tc_netem_reorder reorder;
        struct tc_netem_corrupt corrupt;
        struct rtnl_netem *netem = data;
        
        unsigned char set_correlation = 0, set_reorder = 0,
                set_corrupt = 0, set_dist = 0;

        if (!netem)
                BUG();

        memset(&opts, 0, sizeof(opts));
        memset(&cor, 0, sizeof(cor));
        memset(&reorder, 0, sizeof(reorder));
        memset(&corrupt, 0, sizeof(corrupt));

        msg->nm_nlh->nlmsg_flags |= NLM_F_REQUEST;
        
        if ( netem->qnm_ro.nmro_probability != 0 ) {
                if (netem->qnm_latency == 0) {
                        return -NLE_MISSING_ATTR;
                }
                if (netem->qnm_gap == 0) netem->qnm_gap = 1;
        }
        else if ( netem->qnm_gap ) { 
                return -NLE_MISSING_ATTR;
        }

        if ( netem->qnm_corr.nmc_delay != 0 ) {
                if ( netem->qnm_latency == 0 || netem->qnm_jitter == 0) {
                        return -NLE_MISSING_ATTR;
                }
                set_correlation = 1;
        }
        
        if ( netem->qnm_corr.nmc_loss != 0 ) {
                if ( netem->qnm_loss == 0 ) {
                        return -NLE_MISSING_ATTR;
                }
                set_correlation = 1;
        }

        if ( netem->qnm_corr.nmc_duplicate != 0 ) {
                if ( netem->qnm_duplicate == 0 ) {
                        return -NLE_MISSING_ATTR;
                }
                set_correlation = 1;
        }
        
        if ( netem->qnm_ro.nmro_probability != 0 ) set_reorder = 1;
        else if ( netem->qnm_ro.nmro_correlation != 0 ) {
                        return -NLE_MISSING_ATTR;
        }
        
        if ( netem->qnm_crpt.nmcr_probability != 0 ) set_corrupt = 1;
        else if ( netem->qnm_crpt.nmcr_correlation != 0 ) {
                        return -NLE_MISSING_ATTR;
        }
        
        if ( netem->qnm_dist.dist_data && netem->qnm_dist.dist_size ) {
                if (netem->qnm_latency == 0 || netem->qnm_jitter == 0) {
                        return -NLE_MISSING_ATTR;
        }
        else {
                /* Resize to accomodate the large distribution table */
                int new_msg_len = msg->nm_size + netem->qnm_dist.dist_size *
                        sizeof(netem->qnm_dist.dist_data[0]);
                
                msg->nm_nlh = (struct nlmsghdr *) realloc(msg->nm_nlh, new_msg_len);
                if ( msg->nm_nlh == NULL )
                        return -NLE_NOMEM;
                msg->nm_size = new_msg_len;
                        set_dist = 1;
                }
        }
        
        opts.latency = netem->qnm_latency;
        opts.limit = netem->qnm_limit ? netem->qnm_limit : 1000;
        opts.loss = netem->qnm_loss;
        opts.gap = netem->qnm_gap;
        opts.duplicate = netem->qnm_duplicate;
        opts.jitter = netem->qnm_jitter;
        
        NLA_PUT(msg, TCA_OPTIONS, sizeof(opts), &opts);
        
        if ( set_correlation ) {
                cor.delay_corr = netem->qnm_corr.nmc_delay;
                cor.loss_corr = netem->qnm_corr.nmc_loss;
                cor.dup_corr = netem->qnm_corr.nmc_duplicate;

                NLA_PUT(msg, TCA_NETEM_CORR, sizeof(cor), &cor);
        }
        
        if ( set_reorder ) {
                reorder.probability = netem->qnm_ro.nmro_probability;
                reorder.correlation = netem->qnm_ro.nmro_correlation;

                NLA_PUT(msg, TCA_NETEM_REORDER, sizeof(reorder), &reorder);
        }
        
        if ( set_corrupt ) {
                corrupt.probability = netem->qnm_crpt.nmcr_probability;
                corrupt.correlation = netem->qnm_crpt.nmcr_correlation;

                NLA_PUT(msg, TCA_NETEM_CORRUPT, sizeof(corrupt), &corrupt);
        }
        
        if ( set_dist ) {
                NLA_PUT(msg, TCA_NETEM_DELAY_DIST,
                        netem->qnm_dist.dist_size * sizeof(netem->qnm_dist.dist_data[0]),
                        netem->qnm_dist.dist_data);
        }

        /* Length specified in the TCA_OPTIONS section must span the entire
         * remainder of the message. That's just the way that sch_netem expects it.
         * Maybe there's a more succinct way to do this at a higher level.
         */
        struct nlattr* head = (struct nlattr *)(NLMSG_DATA(msg->nm_nlh) +
                NLMSG_LENGTH(sizeof(struct tcmsg)) - NLMSG_ALIGNTO);
                
        struct nlattr* tail = (struct nlattr *)(((void *) (msg->nm_nlh)) +
                NLMSG_ALIGN(msg->nm_nlh->nlmsg_len));
        
        int old_len = head->nla_len;
        head->nla_len = (void *)tail - (void *)head;
        msg->nm_nlh->nlmsg_len += (head->nla_len - old_len);
        
        return err;
nla_put_failure:
        return -NLE_MSGSIZE;
}

/**
 * @name Queue Limit
 * @{
 */

/**
 * Set limit of netem qdisc.
 * @arg qdisc           Netem qdisc to be modified.
 * @arg limit           New limit in bytes.
 * @return 0 on success or a negative error code.
 */
void rtnl_netem_set_limit(struct rtnl_qdisc *qdisc, int limit)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();
        
        netem->qnm_limit = limit;
        netem->qnm_mask |= SCH_NETEM_ATTR_LIMIT;
}

/**
 * Get limit of netem qdisc.
 * @arg qdisc           Netem qdisc.
 * @return Limit in bytes or a negative error code.
 */
int rtnl_netem_get_limit(struct rtnl_qdisc *qdisc)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                return -NLE_NOMEM;

        if (netem->qnm_mask & SCH_NETEM_ATTR_LIMIT)
                return netem->qnm_limit;
        else
                return -NLE_NOATTR;
}

/** @} */

/**
 * @name Packet Re-ordering
 * @{
 */

/**
 * Set re-ordering gap of netem qdisc.
 * @arg qdisc           Netem qdisc to be modified.
 * @arg gap             New gap in number of packets.
 * @return 0 on success or a negative error code.
 */
void rtnl_netem_set_gap(struct rtnl_qdisc *qdisc, int gap)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        netem->qnm_gap = gap;
        netem->qnm_mask |= SCH_NETEM_ATTR_GAP;
}

/**
 * Get re-ordering gap of netem qdisc.
 * @arg qdisc           Netem qdisc.
 * @return Re-ordering gap in packets or a negative error code.
 */
int rtnl_netem_get_gap(struct rtnl_qdisc *qdisc)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                return -NLE_NOMEM;

        if (netem->qnm_mask & SCH_NETEM_ATTR_GAP)
                return netem->qnm_gap;
        else
                return -NLE_NOATTR;
}

/**
 * Set re-ordering probability of netem qdisc.
 * @arg qdisc           Netem qdisc to be modified.
 * @arg prob            New re-ordering probability.
 * @return 0 on success or a negative error code.
 */
void rtnl_netem_set_reorder_probability(struct rtnl_qdisc *qdisc, int prob)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        netem->qnm_ro.nmro_probability = prob;
        netem->qnm_mask |= SCH_NETEM_ATTR_RO_PROB;
}

/**
 * Get re-ordering probability of netem qdisc.
 * @arg qdisc           Netem qdisc.
 * @return Re-ordering probability or a negative error code.
 */
int rtnl_netem_get_reorder_probability(struct rtnl_qdisc *qdisc)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                return -NLE_NOMEM;

        if (netem->qnm_mask & SCH_NETEM_ATTR_RO_PROB)
                return netem->qnm_ro.nmro_probability;
        else
                return -NLE_NOATTR;
}

/**
 * Set re-order correlation probability of netem qdisc.
 * @arg qdisc           Netem qdisc to be modified.
 * @arg prob            New re-ordering correlation probability.
 * @return 0 on success or a negative error code.
 */
void rtnl_netem_set_reorder_correlation(struct rtnl_qdisc *qdisc, int prob)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        netem->qnm_ro.nmro_correlation = prob;
        netem->qnm_mask |= SCH_NETEM_ATTR_RO_CORR;
}

/**
 * Get re-ordering correlation probability of netem qdisc.
 * @arg qdisc           Netem qdisc.
 * @return Re-ordering correlation probability or a negative error code.
 */
int rtnl_netem_get_reorder_correlation(struct rtnl_qdisc *qdisc)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                return -NLE_NOMEM;

        if (netem->qnm_mask & SCH_NETEM_ATTR_RO_CORR)
                return netem->qnm_ro.nmro_correlation;
        else
                return -NLE_NOATTR;
}

/** @} */

/**
 * @name Corruption
 * @{
 */
 
/**
 * Set corruption probability of netem qdisc.
 * @arg qdisc           Netem qdisc to be modified.
 * @arg prob            New corruption probability.
 * @return 0 on success or a negative error code.
 */
void rtnl_netem_set_corruption_probability(struct rtnl_qdisc *qdisc, int prob)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        netem->qnm_crpt.nmcr_probability = prob;
        netem->qnm_mask |= SCH_NETEM_ATTR_CORRUPT_PROB;
}

/**
 * Get corruption probability of netem qdisc.
 * @arg qdisc           Netem qdisc.
 * @return Corruption probability or a negative error code.
 */
int rtnl_netem_get_corruption_probability(struct rtnl_qdisc *qdisc)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        if (netem->qnm_mask & SCH_NETEM_ATTR_CORRUPT_PROB)
                return netem->qnm_crpt.nmcr_probability;
        else
                return -NLE_NOATTR;
}

/**
 * Set corruption correlation probability of netem qdisc.
 * @arg qdisc           Netem qdisc to be modified.
 * @arg prob            New corruption correlation probability.
 * @return 0 on success or a negative error code.
 */
void rtnl_netem_set_corruption_correlation(struct rtnl_qdisc *qdisc, int prob)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        netem->qnm_crpt.nmcr_correlation = prob;
        netem->qnm_mask |= SCH_NETEM_ATTR_CORRUPT_CORR;
}

/**
 * Get corruption correlation probability of netem qdisc.
 * @arg qdisc           Netem qdisc.
 * @return Corruption correlation probability or a negative error code.
 */
int rtnl_netem_get_corruption_correlation(struct rtnl_qdisc *qdisc)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        if (netem->qnm_mask & SCH_NETEM_ATTR_CORRUPT_CORR)
                return netem->qnm_crpt.nmcr_correlation;
        else
                return -NLE_NOATTR;
}

/** @} */

/**
 * @name Packet Loss
 * @{
 */

/**
 * Set packet loss probability of netem qdisc.
 * @arg qdisc           Netem qdisc to be modified.
 * @arg prob            New packet loss probability.
 * @return 0 on success or a negative error code.
 */
void rtnl_netem_set_loss(struct rtnl_qdisc *qdisc, int prob)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        netem->qnm_loss = prob;
        netem->qnm_mask |= SCH_NETEM_ATTR_LOSS;
}

/**
 * Get packet loss probability of netem qdisc.
 * @arg qdisc           Netem qdisc.
 * @return Packet loss probability or a negative error code.
 */
int rtnl_netem_get_loss(struct rtnl_qdisc *qdisc)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        if (netem->qnm_mask & SCH_NETEM_ATTR_LOSS)
                return netem->qnm_loss;
        else
                return -NLE_NOATTR;
}

/**
 * Set packet loss correlation probability of netem qdisc.
 * @arg qdisc           Netem qdisc to be modified.
 * @arg prob    New packet loss correlation.
 * @return 0 on success or a negative error code.
 */
void rtnl_netem_set_loss_correlation(struct rtnl_qdisc *qdisc, int prob)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        netem->qnm_corr.nmc_loss = prob;
        netem->qnm_mask |= SCH_NETEM_ATTR_LOSS_CORR;
}

/**
 * Get packet loss correlation probability of netem qdisc.
 * @arg qdisc           Netem qdisc.
 * @return Packet loss correlation probability or a negative error code.
 */
int rtnl_netem_get_loss_correlation(struct rtnl_qdisc *qdisc)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        if (netem->qnm_mask & SCH_NETEM_ATTR_LOSS_CORR)
                return netem->qnm_corr.nmc_loss;
        else
                return -NLE_NOATTR;
}

/** @} */

/**
 * @name Packet Duplication
 * @{
 */

/**
 * Set packet duplication probability of netem qdisc.
 * @arg qdisc           Netem qdisc to be modified.
 * @arg prob    New packet duplication probability.
 * @return 0 on success or a negative error code.
 */
void rtnl_netem_set_duplicate(struct rtnl_qdisc *qdisc, int prob)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        netem->qnm_duplicate = prob;
        netem->qnm_mask |= SCH_NETEM_ATTR_DUPLICATE;
}

/**
 * Get packet duplication probability of netem qdisc.
 * @arg qdisc           Netem qdisc.
 * @return Packet duplication probability or a negative error code.
 */
int rtnl_netem_get_duplicate(struct rtnl_qdisc *qdisc)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        if (netem->qnm_mask & SCH_NETEM_ATTR_DUPLICATE)
                return netem->qnm_duplicate;
        else
                return -NLE_NOATTR;
}

/**
 * Set packet duplication correlation probability of netem qdisc.
 * @arg qdisc           Netem qdisc to be modified.
 * @arg prob            New packet duplication correlation probability.
 * @return 0 on sucess or a negative error code.
 */
void rtnl_netem_set_duplicate_correlation(struct rtnl_qdisc *qdisc, int prob)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        netem->qnm_corr.nmc_duplicate = prob;
        netem->qnm_mask |= SCH_NETEM_ATTR_DUP_CORR;
}

/**
 * Get packet duplication correlation probability of netem qdisc.
 * @arg qdisc           Netem qdisc.
 * @return Packet duplication correlation probability or a negative error code.
 */
int rtnl_netem_get_duplicate_correlation(struct rtnl_qdisc *qdisc)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        if (netem->qnm_mask & SCH_NETEM_ATTR_DUP_CORR)
                return netem->qnm_corr.nmc_duplicate;
        else
                return -NLE_NOATTR;
}

/** @} */

/**
 * @name Packet Delay
 * @{
 */

/**
 * Set packet delay of netem qdisc.
 * @arg qdisc           Netem qdisc to be modified.
 * @arg delay           New packet delay in micro seconds.
 * @return 0 on success or a negative error code.
 */
void rtnl_netem_set_delay(struct rtnl_qdisc *qdisc, int delay)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        netem->qnm_latency = nl_us2ticks(delay);
        netem->qnm_mask |= SCH_NETEM_ATTR_LATENCY;
}

/**
 * Get packet delay of netem qdisc.
 * @arg qdisc           Netem qdisc.
 * @return Packet delay in micro seconds or a negative error code.
 */
int rtnl_netem_get_delay(struct rtnl_qdisc *qdisc)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        if (netem->qnm_mask & SCH_NETEM_ATTR_LATENCY)
                return nl_ticks2us(netem->qnm_latency);
        else
                return -NLE_NOATTR;
}

/**
 * Set packet delay jitter of netem qdisc.
 * @arg qdisc           Netem qdisc to be modified.
 * @arg jitter          New packet delay jitter in micro seconds.
 * @return 0 on success or a negative error code.
 */
void rtnl_netem_set_jitter(struct rtnl_qdisc *qdisc, int jitter)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        netem->qnm_jitter = nl_us2ticks(jitter);
        netem->qnm_mask |= SCH_NETEM_ATTR_JITTER;
}

/**
 * Get packet delay jitter of netem qdisc.
 * @arg qdisc           Netem qdisc.
 * @return Packet delay jitter in micro seconds or a negative error code.
 */
int rtnl_netem_get_jitter(struct rtnl_qdisc *qdisc)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        if (netem->qnm_mask & SCH_NETEM_ATTR_JITTER)
                return nl_ticks2us(netem->qnm_jitter);
        else
                return -NLE_NOATTR;
}

/**
 * Set packet delay correlation probability of netem qdisc.
 * @arg qdisc           Netem qdisc to be modified.
 * @arg prob            New packet delay correlation probability.
 */
void rtnl_netem_set_delay_correlation(struct rtnl_qdisc *qdisc, int prob)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        netem->qnm_corr.nmc_delay = prob;
        netem->qnm_mask |= SCH_NETEM_ATTR_DELAY_CORR;
}

/**
 * Get packet delay correlation probability of netem qdisc.
 * @arg qdisc           Netem qdisc.
 * @return Packet delay correlation probability or a negative error code.
 */
int rtnl_netem_get_delay_correlation(struct rtnl_qdisc *qdisc)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        if (netem->qnm_mask & SCH_NETEM_ATTR_DELAY_CORR)
                return netem->qnm_corr.nmc_delay;
        else
                return -NLE_NOATTR;
}

/**
 * Get the size of the distribution table.
 * @arg qdisc           Netem qdisc.
 * @return Distribution table size or a negative error code.
 */
int rtnl_netem_get_delay_distribution_size(struct rtnl_qdisc *qdisc)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        if (netem->qnm_mask & SCH_NETEM_ATTR_DIST)
                return netem->qnm_dist.dist_size;
        else
                return -NLE_NOATTR;
}

/**
 * Get a pointer to the distribution table.
 * @arg qdisc           Netem qdisc.
 * @arg dist_ptr        The pointer to set.
 * @return Negative error code on failure or 0 on success.
 */
int rtnl_netem_get_delay_distribution(struct rtnl_qdisc *qdisc, int16_t **dist_ptr)
{
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();

        if (netem->qnm_mask & SCH_NETEM_ATTR_DIST) {
                *dist_ptr = netem->qnm_dist.dist_data;
                return 0;
        } else
                return -NLE_NOATTR;
}

/**
 * Set the delay distribution. Latency/jitter must be set before applying.
 * @arg qdisc Netem qdisc.
 * @arg dist_type The name of the distribution (type, file, path/file).
 * @return 0 on success, error code on failure.
 */
int rtnl_netem_set_delay_distribution(struct rtnl_qdisc *qdisc, const char *dist_type) {
        struct rtnl_netem *netem;

        if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
                BUG();
                
        FILE *f;
        int n = 0;
        size_t i;
        size_t len = 2048;
        char *line;
        char name[NAME_MAX];
        char dist_suffix[] = ".dist";
        
        /* If the given filename already ends in .dist, don't append it later */
        char *test_suffix = strstr(dist_type, dist_suffix);
        if (test_suffix != NULL && strlen(test_suffix) == 5)
                strcpy(dist_suffix, "");
        
        /* Check several locations for the dist file */
        char *test_path[] = { "", "./", "/usr/lib/tc/", "/usr/local/lib/tc/" };
        
        for (i = 0; i < ARRAY_SIZE(test_path); i++) {
                snprintf(name, NAME_MAX, "%s%s%s", test_path[i], dist_type, dist_suffix);
                if ((f = fopen(name, "r")))
                        break;
        }
        
        if ( f == NULL )
                return -nl_syserr2nlerr(errno);
        
        netem->qnm_dist.dist_data = (int16_t *) calloc (MAXDIST, sizeof(int16_t));
        
        line = (char *) calloc (sizeof(char), len + 1);
        
        while (getline(&line, &len, f) != -1) {
                char *p, *endp;
                
                if (*line == '\n' || *line == '#')
                        continue;

                for (p = line; ; p = endp) {
                        long x = strtol(p, &endp, 0);
                        if (endp == p) break;

                        if (n >= MAXDIST) {
                                free(line);
                                fclose(f);
                                return -NLE_INVAL;
                        }
                        netem->qnm_dist.dist_data[n++] = x;
                }               
        }
        
        free(line);
        
        netem->qnm_dist.dist_size = n;
        netem->qnm_mask |= SCH_NETEM_ATTR_DIST;
        
        fclose(f);
        return 0;       
}

/** @} */

static struct rtnl_tc_ops netem_ops = {
        .to_kind                = "netem",
        .to_type                = RTNL_TC_TYPE_QDISC,
        .to_size                = sizeof(struct rtnl_netem),
        .to_msg_parser          = netem_msg_parser,
        .to_free_data           = netem_free_data,
        .to_dump[NL_DUMP_LINE]  = netem_dump_line,
        .to_msg_fill_raw        = netem_msg_fill_raw,
};

static void __init netem_init(void)
{
        rtnl_tc_register(&netem_ops);
}

static void __exit netem_exit(void)
{
        rtnl_tc_unregister(&netem_ops);
}

/** @} */