Utilities

Modules
	Abstract Address
	Abstract Data

Data Structures
struct	nl_dump_params
	Dumping parameters. More...

Enumerations
enum	nl_dump_type {   NL_DUMP_BRIEF, NL_DUMP_FULL, NL_DUMP_STATS, NL_DUMP_XML,   NL_DUMP_ENV, NL_DUMP_EVENTS, __NL_DUMP_MAX }
	Dumping types (dp_type) More...

Variables
int	nl_debug = 0
	Debug level.
struct nl_dump_params	nl_debug_dp

Error Code Helpers
int	nl_get_errno (void)
char *	nl_geterror (void)
	Return error message for an error code. More...
void	nl_perror (const char *s)
	Print a libnl error message. More...

Unit Pretty-Printing
double	nl_cancel_down_bytes (unsigned long long l, char **unit)
	Cancel down a byte counter. More...
double	nl_cancel_down_bits (unsigned long long l, char **unit)
	Cancel down a bit counter. More...
double	nl_cancel_down_us (uint32_t l, char **unit)
	Cancel down a micro second value. More...

Generic Unit Translations
long	nl_size2int (const char *str)
	Convert a character string to a size. More...
long	nl_prob2int (const char *str)
	Convert a character string to a probability. More...

Time Translations
int	nl_get_hz (void)
	Return the value of HZ.
uint32_t	nl_us2ticks (uint32_t us)
	Convert micro seconds to ticks. More...
uint32_t	nl_ticks2us (uint32_t ticks)
	Convert ticks to micro seconds. More...
long	nl_time2int (const char *str)
char *	nl_msec2str (uint64_t msec, char *buf, size_t len)
	Convert milliseconds to a character string. More...

Link Layer Protocol Translations
char *	nl_llproto2str (int llproto, char *buf, size_t len)
int	nl_str2llproto (const char *name)

Ethernet Protocol Translations
char *	nl_ether_proto2str (int eproto, char *buf, size_t len)
int	nl_str2ether_proto (const char *name)

IP Protocol Translations
char *	nl_ip_proto2str (int proto, char *buf, size_t len)
int	nl_str2ip_proto (const char *name)

Dumping Helpers
void	nl_new_line (struct nl_dump_params *params, int line)
	Handle a new line while dumping. More...
void	nl_dump (struct nl_dump_params *params, const char *fmt,...)
	Dump a formatted character string. More...

Probability Constants
#define	NL_PROB_MIN   0x0
	Lower probability limit.
#define	NL_PROB_MAX   0xffffffff
	Upper probability limit.

Detailed Description

Enumeration Type Documentation

enum nl_dump_type

Enumerator
NL_DUMP_BRIEF	Dump object in a brief one-liner.
NL_DUMP_FULL	Dump all attributes but no statistics.
NL_DUMP_STATS	Dump all attributes including statistics.
NL_DUMP_XML	Dump all attribtes in XML format.
NL_DUMP_ENV	Dump all attribtues as env variables.
NL_DUMP_EVENTS	Dump event.

Definition at line 21 of file types.h.

                  {
        NL_DUMP_BRIEF,          /**< Dump object in a brief one-liner */
        NL_DUMP_FULL,           /**< Dump all attributes but no statistics */
        NL_DUMP_STATS,          /**< Dump all attributes including statistics */
        NL_DUMP_XML,            /**< Dump all attribtes in XML format */
        NL_DUMP_ENV,            /**< Dump all attribtues as env variables */
        NL_DUMP_EVENTS,         /**< Dump event */
        __NL_DUMP_MAX,
};

Function Documentation

char* nl_geterror

(

void

)

Returns

error message

Definition at line 142 of file utils.c.

Referenced by nl_perror().

{
        if (errbuf)
                return errbuf;

        if (nlerrno)
                return strerror(nlerrno);

        return "Sucess\n";
}

void nl_perror

(

const char *

s

)

Parameters

s	error message prefix

Prints the error message of the call that failed last.

If s is not NULL and *s is not a null byte the argument string is printed, followed by a colon and a blank. Then the error message and a new-line.

Definition at line 163 of file utils.c.

References nl_geterror().

{
        if (s && *s)
                fprintf(stderr, "%s: %s\n", s, nl_geterror());
        else
                fprintf(stderr, "%s\n", nl_geterror());
}

double nl_cancel_down_bytes	(	unsigned long long	l,
		char **	unit
	)

Parameters

l	byte counter
unit	destination unit pointer

Cancels down a byte counter until it reaches a reasonable unit. The chosen unit is assigned to unit. This function assume 1024 bytes in one kilobyte

Returns

The cancelled down byte counter in the new unit.

Definition at line 189 of file utils.c.

{
        if (l >= 1099511627776LL) {
                *unit = "TiB";
                return ((double) l) / 1099511627776LL;
        } else if (l >= 1073741824) {
                *unit = "GiB";
                return ((double) l) / 1073741824;
        } else if (l >= 1048576) {
                *unit = "MiB";
                return ((double) l) / 1048576;
        } else if (l >= 1024) {
                *unit = "KiB";
                return ((double) l) / 1024;
        } else {
                *unit = "B";
                return (double) l;
        }
}

double nl_cancel_down_bits	(	unsigned long long	l,
		char **	unit
	)

Parameters

l	bit counter
unit	destination unit pointer

Cancels down bit counter until it reaches a reasonable unit. The chosen unit is assigned to unit. This function assume 1000 bits in one kilobit

Returns

The cancelled down bit counter in the new unit.

Definition at line 220 of file utils.c.

{
        if (l >= 1000000000000ULL) {
                *unit = "Tbit";
                return ((double) l) / 1000000000000ULL;
        }

        if (l >= 1000000000) {
                *unit = "Gbit";
                return ((double) l) / 1000000000;
        }

        if (l >= 1000000) {
                *unit = "Mbit";
                return ((double) l) / 1000000;
        }

        if (l >= 1000) {
                *unit = "Kbit";
                return ((double) l) / 1000;
        }

        *unit = "bit";
        return (double) l;
}

double nl_cancel_down_us	(	uint32_t	l,
		char **	unit
	)

Parameters

l	micro seconds
unit	destination unit pointer

Cancels down a microsecond counter until it reaches a reasonable unit. The chosen unit is assigned to unit.

Returns

The cancelled down microsecond in the new unit

Definition at line 256 of file utils.c.

{
        if (l >= 1000000) {
                *unit = "s";
                return ((double) l) / 1000000;
        } else if (l >= 1000) {
                *unit = "ms";
                return ((double) l) / 1000;
        } else {
                *unit = "us";
                return (double) l;
        }
}

long nl_size2int

(

const char *

str

)

Parameters

str	size encoded as character string

Converts the specified size as character to the corresponding number of bytes.

Supported formats are:

• b,kb/k,m/mb,gb/g for bytes
• bit,kbit/mbit/gbit

This function assume 1000 bits in one kilobit and 1024 bytes in one kilobyte

Returns

The number of bytes or -1 if the string is unparseable

Definition at line 293 of file utils.c.

{
        char *p;
        long l = strtol(str, &p, 0);
        if (p == str)
                return -1;

        if (*p) {
                if (!strcasecmp(p, "kb") || !strcasecmp(p, "k"))
                        l *= 1024;
                else if (!strcasecmp(p, "gb") || !strcasecmp(p, "g"))
                        l *= 1024*1024*1024;
                else if (!strcasecmp(p, "gbit"))
                        l *= 1000000000L/8;
                else if (!strcasecmp(p, "mb") || !strcasecmp(p, "m"))
                        l *= 1024*1024;
                else if (!strcasecmp(p, "mbit"))
                        l *= 1000000/8;
                else if (!strcasecmp(p, "kbit"))
                        l *= 1000/8;
                else if (!strcasecmp(p, "bit"))
                        l /= 8;
                else if (strcasecmp(p, "b") != 0)
                        return -1;
        }

        return l;
}

long nl_prob2int

(

const char *

str

)

Parameters

str	probability encoded as character string

Converts the specified probability as character to the corresponding probability number.

Supported formats are:

• 0.0-1.0
• 0%-100%

Returns

The probability relative to NL_PROB_MIN and NL_PROB_MAX

Definition at line 335 of file utils.c.

References NL_PROB_MAX.

{
        char *p;
        double d = strtod(str, &p);

        if (p == str)
                return -1;

        if (d > 1.0)
                d /= 100.0f;

        if (d > 1.0f || d < 0.0f)
                return -1;

        if (*p && strcmp(p, "%") != 0)
                return -1;

        return rint(d * NL_PROB_MAX);
}

uint32_t nl_us2ticks

(

uint32_t

us

)

Parameters

us	micro seconds

Returns

number of ticks

Definition at line 439 of file utils.c.

Referenced by rtnl_netem_set_delay(), and rtnl_netem_set_jitter().

{
        return us * ticks_per_usec;
}

uint32_t nl_ticks2us

(

uint32_t

ticks

)

Parameters

ticks

number of ticks

Returns

microseconds

Definition at line 450 of file utils.c.

Referenced by rtnl_netem_get_delay(), and rtnl_netem_get_jitter().

{
        return ticks / ticks_per_usec;
}

char* nl_msec2str	(	uint64_t	msec,
		char *	buf,
		size_t	len
	)

Parameters

msec	number of milliseconds
buf	destination buffer
len	buffer length

Converts milliseconds to a character string split up in days, hours, minutes, seconds, and milliseconds and stores it in the specified destination buffer.

Returns

The destination buffer.

Definition at line 488 of file utils.c.

{
        int i, split[5];
        char *units[] = {"d", "h", "m", "s", "msec"};

#define _SPLIT(idx, unit) if ((split[idx] = msec / unit) > 0) msec %= unit
        _SPLIT(0, 86400000);    /* days */
        _SPLIT(1, 3600000);     /* hours */
        _SPLIT(2, 60000);       /* minutes */
        _SPLIT(3, 1000);        /* seconds */
#undef  _SPLIT
        split[4] = msec;

        memset(buf, 0, len);

        for (i = 0; i < ARRAY_SIZE(split); i++) {
                if (split[i] > 0) {
                        char t[64];
                        snprintf(t, sizeof(t), "%s%d%s",
                                 strlen(buf) ? " " : "", split[i], units[i]);
                        strncat(buf, t, len - strlen(buf) - 1);
                }
        }

        return buf;
}

void nl_new_line	(	struct nl_dump_params *	params,
		int	line
	)

Parameters

params	Dumping parameters
line	Number of lines dumped already.

This function must be called before dumping any onto a new line. It will ensure proper prefixing as specified by the dumping parameters.

Note

This function will NOT dump any newlines itself

Definition at line 735 of file utils.c.

References nl_dump_params::dp_buf, nl_dump_params::dp_buflen, nl_dump_params::dp_fd, nl_dump_params::dp_nl_cb, and nl_dump_params::dp_prefix.

{
        if (params->dp_prefix) {
                int i;
                for (i = 0; i < params->dp_prefix; i++) {
                        if (params->dp_fd)
                                fprintf(params->dp_fd, " ");
                        else if (params->dp_buf)
                                strncat(params->dp_buf, " ",
                                        params->dp_buflen -
                                        sizeof(params->dp_buf) - 1);
                }
        }

        if (params->dp_nl_cb)
                params->dp_nl_cb(params, line);
}

void nl_dump	(	struct nl_dump_params *	params,
		const char *	fmt,
			...
	)

Parameters

params	Dumping parameters
fmt	printf style formatting string
...	Arguments to formatting string

Dumps a printf style formatting string to the output device as specified by the dumping parameters.

Definition at line 762 of file utils.c.

{
        va_list args;

        va_start(args, fmt);
        __dp_dump(params, fmt, args);
        va_end(args);
}

Variable Documentation

struct nl_dump_params nl_debug_dp

Initial value:

= {
        .dp_type = NL_DUMP_FULL,
}

Definition at line 27 of file utils.c.