Data Structures
struct	nl_dump_params
	Dumping parameters. More...
Modules
	Abstract Address
	Abstract Data
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.
void	nl_perror (const char *s)
	Print a libnl error message.
Unit Pretty-Printing
double	nl_cancel_down_bytes (unsigned long long l, char **unit)
	Cancel down a byte counter.
double	nl_cancel_down_bits (unsigned long long l, char **unit)
	Cancel down a bit counter.
double	nl_cancel_down_us (uint32_t l, char **unit)
	Cancel down a micro second value.
Generic Unit Translations
long	nl_size2int (const char *str)
	Convert a character string to a size.
long	nl_prob2int (const char *str)
	Convert a character string to a probability.
Time Translations
int	nl_get_hz (void)
	Return the value of HZ.
uint32_t	nl_us2ticks (uint32_t us)
	Convert micro seconds to ticks.
uint32_t	nl_ticks2us (uint32_t ticks)
	Convert ticks to micro seconds.
long	nl_time2int (const char *str)
char *	nl_msec2str (uint64_t msec, char *buf, size_t len)
	Convert milliseconds to a character string.
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.
void	nl_dump (struct nl_dump_params params, const char fmt,...)
	Dump a formatted character string.
Probability Constants
#define	NL_PROB_MIN 0x0
	Lower probability limit.
#define	NL_PROB_MAX 0xffffffff
	Upper probability limit.

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.

Returns:: The cancelled down byte counter in the new unit.

Definition at line 188 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 downa bit counter until it reaches a reasonable unit. The chosen unit is assigned to unit.

Returns:: The cancelled down bit counter in the new unit.

Definition at line 218 of file utils.c.

{
        if (l >= 1099511627776ULL) {
                *unit = "Tbit";
                return ((double) l) / 1099511627776ULL;
        } else if (l >= 1073741824) {
                *unit = "Gbit";
                return ((double) l) / 1073741824;
        } else if (l >= 1048576) {
                *unit = "Mbit";
                return ((double) l) / 1048576;
        } else if (l >= 1024) {
                *unit = "Kbit";
                return ((double) l) / 1024;
        } else {
                *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 249 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

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

Definition at line 283 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 *= 1024*1024*1024/8;
                else if (!strcasecmp(p, "mb") || !strcasecmp(p, "m"))
                        l *= 1024*1024;
                else if (!strcasecmp(p, "mbit"))
                        l *= 1024*1024/8;
                else if (!strcasecmp(p, "kbit"))
                        l *= 1024/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 325 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 429 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 440 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 478 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 725 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 752 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.

Utilities

Data Structures

Modules

Enumerations

Variables

Error Code Helpers

Unit Pretty-Printing

Generic Unit Translations

Time Translations

Link Layer Protocol Translations

Ethernet Protocol Translations

IP Protocol Translations

Dumping Helpers

Probability Constants

Enumeration Type Documentation

Function Documentation

Variable Documentation