nexmon – Rev 1
?pathlinks?
/*
* lib/utils.c Utility Functions
*
* 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-2008 Thomas Graf <tgraf@suug.ch>
*/
/**
* @ingroup core
* @defgroup utils Utilities
* @{
*/
#include <netlink-local.h>
#include <netlink/netlink.h>
#include <netlink/utils.h>
#include <linux/socket.h>
/**
* Debug level
*/
int nl_debug = 0;
struct nl_dump_params nl_debug_dp = {
.dp_type = NL_DUMP_DETAILS,
};
static void __init nl_debug_init(void)
{
char *nldbg, *end;
if ((nldbg = getenv("NLDBG"))) {
long level = strtol(nldbg, &end, 0);
if (nldbg != end)
nl_debug = level;
}
nl_debug_dp.dp_fd = stderr;
}
int __nl_read_num_str_file(const char *path, int (*cb)(long, const char *))
{
FILE *fd;
char buf[128];
fd = fopen(path, "r");
if (fd == NULL)
return -nl_syserr2nlerr(errno);
while (fgets(buf, sizeof(buf), fd)) {
int goodlen, err;
long num;
char *end;
if (*buf == '#' || *buf == '\n' || *buf == '\r')
continue;
num = strtol(buf, &end, 0);
if (end == buf)
return -NLE_INVAL;
if (num == LONG_MIN || num == LONG_MAX)
return -NLE_RANGE;
while (*end == ' ' || *end == '\t')
end++;
goodlen = strcspn(end, "#\r\n\t ");
if (goodlen == 0)
return -NLE_INVAL;
end[goodlen] = '\0';
err = cb(num, end);
if (err < 0)
return err;
}
fclose(fd);
return 0;
}
/**
* @name Unit Pretty-Printing
* @{
*/
/**
* Cancel down a byte counter
* @arg l byte counter
* @arg unit destination unit pointer
*
* Cancels down a byte counter until it reaches a reasonable
* unit. The chosen unit is assigned to \a unit.
*
* @return The cancelled down byte counter in the new unit.
*/
double nl_cancel_down_bytes(unsigned long long l, char **unit)
{
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;
}
}
/**
* Cancel down a bit counter
* @arg l bit counter
* @arg unit destination unit pointer
*
* Cancels downa bit counter until it reaches a reasonable
* unit. The chosen unit is assigned to \a unit.
*
* @return The cancelled down bit counter in the new unit.
*/
double nl_cancel_down_bits(unsigned long long l, char **unit)
{
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;
}
}
/**
* Cancel down a micro second value
* @arg l micro seconds
* @arg unit destination unit pointer
*
* Cancels down a microsecond counter until it reaches a
* reasonable unit. The chosen unit is assigned to \a unit.
*
* @return The cancelled down microsecond in the new unit
*/
double nl_cancel_down_us(uint32_t l, char **unit)
{
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;
}
}
/** @} */
/**
* @name Generic Unit Translations
* @{
*/
/**
* Convert a character string to a size
* @arg 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
*
* @return The number of bytes or -1 if the string is unparseable
*/
long nl_size2int(const char *str)
{
char *p;
long l = strtol(str, &p, 0);
if (p == str)
return -NLE_INVAL;
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 -NLE_INVAL;
}
return l;
}
/**
* Convert a character string to a probability
* @arg 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%
*
* @return The probability relative to NL_PROB_MIN and NL_PROB_MAX
*/
long nl_prob2int(const char *str)
{
char *p;
double d = strtod(str, &p);
if (p == str)
return -NLE_INVAL;
if (d > 1.0)
d /= 100.0f;
if (d > 1.0f || d < 0.0f)
return -NLE_RANGE;
if (*p && strcmp(p, "%") != 0)
return -NLE_INVAL;
return rint(d * NL_PROB_MAX);
}
/** @} */
/**
* @name Time Translations
* @{
*/
#ifdef USER_HZ
static uint32_t user_hz = USER_HZ;
#else
static uint32_t user_hz = 100;
#endif
static double ticks_per_usec = 1.0f;
/* Retrieves the configured HZ and ticks/us value in the kernel.
* The value is cached. Supported ways of getting it:
*
* 1) environment variable
* 2) /proc/net/psched and sysconf
*
* Supports the environment variables:
* PROC_NET_PSCHED - may point to psched file in /proc
* PROC_ROOT - may point to /proc fs */
static void __init get_psched_settings(void)
{
char name[FILENAME_MAX];
FILE *fd;
int got_hz = 0;
if (getenv("HZ")) {
long hz = strtol(getenv("HZ"), NULL, 0);
if (LONG_MIN != hz && LONG_MAX != hz) {
user_hz = hz;
got_hz = 1;
}
}
if (!got_hz)
user_hz = sysconf(_SC_CLK_TCK);
if (getenv("TICKS_PER_USEC")) {
double t = strtod(getenv("TICKS_PER_USEC"), NULL);
ticks_per_usec = t;
}
else {
if (getenv("PROC_NET_PSCHED"))
snprintf(name, sizeof(name), "%s", getenv("PROC_NET_PSCHED"));
else if (getenv("PROC_ROOT"))
snprintf(name, sizeof(name), "%s/net/psched",
getenv("PROC_ROOT"));
else
strncpy(name, "/proc/net/psched", sizeof(name) - 1);
if ((fd = fopen(name, "r"))) {
uint32_t tick, us;
/* the file contains 4 hexadecimals, but we just use
the first two of them */
fscanf(fd, "%08x %08x", &tick, &us);
ticks_per_usec = (double)tick/(double)us;
fclose(fd);
}
}
}
/**
* Return the value of HZ
*/
int nl_get_hz(void)
{
return user_hz;
}
/**
* Convert micro seconds to ticks
* @arg us micro seconds
* @return number of ticks
*/
uint32_t nl_us2ticks(uint32_t us)
{
return us * ticks_per_usec;
}
/**
* Convert ticks to micro seconds
* @arg ticks number of ticks
* @return microseconds
*/
uint32_t nl_ticks2us(uint32_t ticks)
{
return ticks / ticks_per_usec;
}
int nl_str2msec(const char *str, uint64_t *result)
{
uint64_t total = 0, l;
int plen;
char *p;
do {
l = strtoul(str, &p, 0);
if (p == str)
return -NLE_INVAL;
else if (*p) {
plen = strcspn(p, " \t");
if (!plen)
total += l;
else if (!strncasecmp(p, "sec", plen))
total += (l * 1000);
else if (!strncasecmp(p, "min", plen))
total += (l * 1000*60);
else if (!strncasecmp(p, "hour", plen))
total += (l * 1000*60*60);
else if (!strncasecmp(p, "day", plen))
total += (l * 1000*60*60*24);
else
return -NLE_INVAL;
str = p + plen;
} else
total += l;
} while (*str && *p);
*result = total;
return 0;
}
/**
* Convert milliseconds to a character string
* @arg msec number of milliseconds
* @arg buf destination buffer
* @arg 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.
*
* @return The destination buffer.
*/
char * nl_msec2str(uint64_t msec, char *buf, size_t len)
{
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;
}
/** @} */
/**
* @name Netlink Family Translations
* @{
*/
static struct trans_tbl nlfamilies[] = {
__ADD(NETLINK_ROUTE,route)
__ADD(NETLINK_USERSOCK,usersock)
__ADD(NETLINK_FIREWALL,firewall)
__ADD(NETLINK_INET_DIAG,inetdiag)
__ADD(NETLINK_NFLOG,nflog)
__ADD(NETLINK_XFRM,xfrm)
__ADD(NETLINK_SELINUX,selinux)
__ADD(NETLINK_ISCSI,iscsi)
__ADD(NETLINK_AUDIT,audit)
__ADD(NETLINK_FIB_LOOKUP,fib_lookup)
__ADD(NETLINK_CONNECTOR,connector)
__ADD(NETLINK_NETFILTER,netfilter)
__ADD(NETLINK_IP6_FW,ip6_fw)
__ADD(NETLINK_DNRTMSG,dnrtmsg)
__ADD(NETLINK_KOBJECT_UEVENT,kobject_uevent)
__ADD(NETLINK_GENERIC,generic)
__ADD(NETLINK_SCSITRANSPORT,scsitransport)
__ADD(NETLINK_ECRYPTFS,ecryptfs)
};
char * nl_nlfamily2str(int family, char *buf, size_t size)
{
return __type2str(family, buf, size, nlfamilies,
ARRAY_SIZE(nlfamilies));
}
int nl_str2nlfamily(const char *name)
{
return __str2type(name, nlfamilies, ARRAY_SIZE(nlfamilies));
}
/**
* @}
*/
/**
* @name Link Layer Protocol Translations
* @{
*/
static struct trans_tbl llprotos[] = {
{0, "generic"},
__ADD(ARPHRD_ETHER,ether)
__ADD(ARPHRD_EETHER,eether)
__ADD(ARPHRD_AX25,ax25)
__ADD(ARPHRD_PRONET,pronet)
__ADD(ARPHRD_CHAOS,chaos)
__ADD(ARPHRD_IEEE802,ieee802)
__ADD(ARPHRD_ARCNET,arcnet)
__ADD(ARPHRD_APPLETLK,atalk)
__ADD(ARPHRD_DLCI,dlci)
__ADD(ARPHRD_ATM,atm)
__ADD(ARPHRD_METRICOM,metricom)
__ADD(ARPHRD_IEEE1394,ieee1394)
#ifdef ARPHRD_EUI64
__ADD(ARPHRD_EUI64,eui64)
#endif
__ADD(ARPHRD_INFINIBAND,infiniband)
__ADD(ARPHRD_SLIP,slip)
__ADD(ARPHRD_CSLIP,cslip)
__ADD(ARPHRD_SLIP6,slip6)
__ADD(ARPHRD_CSLIP6,cslip6)
__ADD(ARPHRD_RSRVD,rsrvd)
__ADD(ARPHRD_ADAPT,adapt)
__ADD(ARPHRD_ROSE,rose)
__ADD(ARPHRD_X25,x25)
#ifdef ARPHRD_HWX25
__ADD(ARPHRD_HWX25,hwx25)
#endif
__ADD(ARPHRD_PPP,ppp)
__ADD(ARPHRD_HDLC,hdlc)
__ADD(ARPHRD_LAPB,lapb)
__ADD(ARPHRD_DDCMP,ddcmp)
__ADD(ARPHRD_RAWHDLC,rawhdlc)
__ADD(ARPHRD_TUNNEL,ipip)
__ADD(ARPHRD_TUNNEL6,tunnel6)
__ADD(ARPHRD_FRAD,frad)
__ADD(ARPHRD_SKIP,skip)
__ADD(ARPHRD_LOOPBACK,loopback)
__ADD(ARPHRD_LOCALTLK,localtlk)
__ADD(ARPHRD_FDDI,fddi)
__ADD(ARPHRD_BIF,bif)
__ADD(ARPHRD_SIT,sit)
__ADD(ARPHRD_IPDDP,ip/ddp)
__ADD(ARPHRD_IPGRE,gre)
__ADD(ARPHRD_PIMREG,pimreg)
__ADD(ARPHRD_HIPPI,hippi)
__ADD(ARPHRD_ASH,ash)
__ADD(ARPHRD_ECONET,econet)
__ADD(ARPHRD_IRDA,irda)
__ADD(ARPHRD_FCPP,fcpp)
__ADD(ARPHRD_FCAL,fcal)
__ADD(ARPHRD_FCPL,fcpl)
__ADD(ARPHRD_FCFABRIC,fcfb_0)
__ADD(ARPHRD_FCFABRIC+1,fcfb_1)
__ADD(ARPHRD_FCFABRIC+2,fcfb_2)
__ADD(ARPHRD_FCFABRIC+3,fcfb_3)
__ADD(ARPHRD_FCFABRIC+4,fcfb_4)
__ADD(ARPHRD_FCFABRIC+5,fcfb_5)
__ADD(ARPHRD_FCFABRIC+6,fcfb_6)
__ADD(ARPHRD_FCFABRIC+7,fcfb_7)
__ADD(ARPHRD_FCFABRIC+8,fcfb_8)
__ADD(ARPHRD_FCFABRIC+9,fcfb_9)
__ADD(ARPHRD_FCFABRIC+10,fcfb_10)
__ADD(ARPHRD_FCFABRIC+11,fcfb_11)
__ADD(ARPHRD_FCFABRIC+12,fcfb_12)
__ADD(ARPHRD_IEEE802_TR,tr)
__ADD(ARPHRD_IEEE80211,ieee802.11)
#ifdef ARPHRD_IEEE80211_PRISM
__ADD(ARPHRD_IEEE80211_PRISM, ieee802.11_prism)
#endif
#ifdef ARPHRD_VOID
__ADD(ARPHRD_VOID,void)
#endif
};
char * nl_llproto2str(int llproto, char *buf, size_t len)
{
return __type2str(llproto, buf, len, llprotos, ARRAY_SIZE(llprotos));
}
int nl_str2llproto(const char *name)
{
return __str2type(name, llprotos, ARRAY_SIZE(llprotos));
}
/** @} */
/**
* @name Ethernet Protocol Translations
* @{
*/
static struct trans_tbl ether_protos[] = {
__ADD(ETH_P_LOOP,loop)
__ADD(ETH_P_PUP,pup)
__ADD(ETH_P_PUPAT,pupat)
__ADD(ETH_P_IP,ip)
__ADD(ETH_P_X25,x25)
__ADD(ETH_P_ARP,arp)
__ADD(ETH_P_BPQ,bpq)
__ADD(ETH_P_IEEEPUP,ieeepup)
__ADD(ETH_P_IEEEPUPAT,ieeepupat)
__ADD(ETH_P_DEC,dec)
__ADD(ETH_P_DNA_DL,dna_dl)
__ADD(ETH_P_DNA_RC,dna_rc)
__ADD(ETH_P_DNA_RT,dna_rt)
__ADD(ETH_P_LAT,lat)
__ADD(ETH_P_DIAG,diag)
__ADD(ETH_P_CUST,cust)
__ADD(ETH_P_SCA,sca)
__ADD(ETH_P_RARP,rarp)
__ADD(ETH_P_ATALK,atalk)
__ADD(ETH_P_AARP,aarp)
#ifdef ETH_P_8021Q
__ADD(ETH_P_8021Q,802.1q)
#endif
__ADD(ETH_P_IPX,ipx)
__ADD(ETH_P_IPV6,ipv6)
#ifdef ETH_P_WCCP
__ADD(ETH_P_WCCP,wccp)
#endif
__ADD(ETH_P_PPP_DISC,ppp_disc)
__ADD(ETH_P_PPP_SES,ppp_ses)
__ADD(ETH_P_MPLS_UC,mpls_uc)
__ADD(ETH_P_MPLS_MC,mpls_mc)
__ADD(ETH_P_ATMMPOA,atmmpoa)
__ADD(ETH_P_ATMFATE,atmfate)
__ADD(ETH_P_EDP2,edp2)
__ADD(ETH_P_802_3,802.3)
__ADD(ETH_P_AX25,ax25)
__ADD(ETH_P_ALL,all)
__ADD(ETH_P_802_2,802.2)
__ADD(ETH_P_SNAP,snap)
__ADD(ETH_P_DDCMP,ddcmp)
__ADD(ETH_P_WAN_PPP,wan_ppp)
__ADD(ETH_P_PPP_MP,ppp_mp)
__ADD(ETH_P_LOCALTALK,localtalk)
__ADD(ETH_P_PPPTALK,ppptalk)
__ADD(ETH_P_TR_802_2,tr_802.2)
__ADD(ETH_P_MOBITEX,mobitex)
__ADD(ETH_P_CONTROL,control)
__ADD(ETH_P_IRDA,irda)
__ADD(ETH_P_ECONET,econet)
__ADD(ETH_P_HDLC,hdlc)
};
char *nl_ether_proto2str(int eproto, char *buf, size_t len)
{
return __type2str(eproto, buf, len, ether_protos,
ARRAY_SIZE(ether_protos));
}
int nl_str2ether_proto(const char *name)
{
return __str2type(name, ether_protos, ARRAY_SIZE(ether_protos));
}
/** @} */
/**
* @name IP Protocol Translations
* @{
*/
char *nl_ip_proto2str(int proto, char *buf, size_t len)
{
struct protoent *p = getprotobynumber(proto);
if (p) {
snprintf(buf, len, "%s", p->p_name);
return buf;
}
snprintf(buf, len, "0x%x", proto);
return buf;
}
int nl_str2ip_proto(const char *name)
{
struct protoent *p = getprotobyname(name);
unsigned long l;
char *end;
if (p)
return p->p_proto;
l = strtoul(name, &end, 0);
if (l == ULONG_MAX || *end != '\0')
return -NLE_OBJ_NOTFOUND;
return (int) l;
}
/** @} */
/**
* @name Dumping Helpers
* @{
*/
/**
* Handle a new line while dumping
* @arg params Dumping parameters
*
* 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
*/
void nl_new_line(struct nl_dump_params *params)
{
params->dp_line++;
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, params->dp_line);
}
static void dump_one(struct nl_dump_params *parms, const char *fmt,
va_list args)
{
if (parms->dp_fd)
vfprintf(parms->dp_fd, fmt, args);
else if (parms->dp_buf || parms->dp_cb) {
char *buf = NULL;
vasprintf(&buf, fmt, args);
if (parms->dp_cb)
parms->dp_cb(parms, buf);
else
strncat(parms->dp_buf, buf,
parms->dp_buflen - strlen(parms->dp_buf) - 1);
free(buf);
}
}
/**
* Dump a formatted character string
* @arg params Dumping parameters
* @arg fmt printf style formatting string
* @arg ... Arguments to formatting string
*
* Dumps a printf style formatting string to the output device
* as specified by the dumping parameters.
*/
void nl_dump(struct nl_dump_params *params, const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
dump_one(params, fmt, args);
va_end(args);
}
void nl_dump_line(struct nl_dump_params *parms, const char *fmt, ...)
{
va_list args;
nl_new_line(parms);
va_start(args, fmt);
dump_one(parms, fmt, args);
va_end(args);
}
/** @} */
/** @cond SKIP */
int __trans_list_add(int i, const char *a, struct nl_list_head *head)
{
struct trans_list *tl;
tl = calloc(1, sizeof(*tl));
if (!tl)
return -NLE_NOMEM;
tl->i = i;
tl->a = strdup(a);
nl_list_add_tail(&tl->list, head);
return 0;
}
void __trans_list_clear(struct nl_list_head *head)
{
struct trans_list *tl, *next;
nl_list_for_each_entry_safe(tl, next, head, list) {
free(tl->a);
free(tl);
}
}
char *__type2str(int type, char *buf, size_t len, struct trans_tbl *tbl,
size_t tbl_len)
{
int i;
for (i = 0; i < tbl_len; i++) {
if (tbl[i].i == type) {
snprintf(buf, len, "%s", tbl[i].a);
return buf;
}
}
snprintf(buf, len, "0x%x", type);
return buf;
}
char *__list_type2str(int type, char *buf, size_t len,
struct nl_list_head *head)
{
struct trans_list *tl;
nl_list_for_each_entry(tl, head, list) {
if (tl->i == type) {
snprintf(buf, len, "%s", tl->a);
return buf;
}
}
snprintf(buf, len, "0x%x", type);
return buf;
}
char *__flags2str(int flags, char *buf, size_t len,
struct trans_tbl *tbl, size_t tbl_len)
{
int i;
int tmp = flags;
memset(buf, 0, len);
for (i = 0; i < tbl_len; i++) {
if (tbl[i].i & tmp) {
tmp &= ~tbl[i].i;
strncat(buf, tbl[i].a, len - strlen(buf) - 1);
if ((tmp & flags))
strncat(buf, ",", len - strlen(buf) - 1);
}
}
return buf;
}
int __str2type(const char *buf, struct trans_tbl *tbl, size_t tbl_len)
{
unsigned long l;
char *end;
int i;
if (*buf == '\0')
return -NLE_INVAL;
for (i = 0; i < tbl_len; i++)
if (!strcasecmp(tbl[i].a, buf))
return tbl[i].i;
l = strtoul(buf, &end, 0);
if (l == ULONG_MAX || *end != '\0')
return -NLE_OBJ_NOTFOUND;
return (int) l;
}
int __list_str2type(const char *buf, struct nl_list_head *head)
{
struct trans_list *tl;
unsigned long l;
char *end;
if (*buf == '\0')
return -NLE_INVAL;
nl_list_for_each_entry(tl, head, list) {
if (!strcasecmp(tl->a, buf))
return tl->i;
}
l = strtoul(buf, &end, 0);
if (l == ULONG_MAX || *end != '\0')
return -NLE_OBJ_NOTFOUND;
return (int) l;
}
int __str2flags(const char *buf, struct trans_tbl *tbl, size_t tbl_len)
{
int i, flags = 0, len;
char *p = (char *) buf, *t;
for (;;) {
if (*p == ' ')
p++;
t = strchr(p, ',');
len = t ? t - p : strlen(p);
for (i = 0; i < tbl_len; i++)
if (!strncasecmp(tbl[i].a, p, len))
flags |= tbl[i].i;
if (!t)
return flags;
p = ++t;
}
return 0;
}
void dump_from_ops(struct nl_object *obj, struct nl_dump_params *params)
{
int type = params->dp_type;
if (type < 0 || type > NL_DUMP_MAX)
BUG();
params->dp_line = 0;
if (params->dp_dump_msgtype) {
#if 0
/* XXX */
char buf[64];
dp_dump_line(params, 0, "%s ",
nl_cache_mngt_type2name(obj->ce_ops,
obj->ce_ops->co_protocol,
obj->ce_msgtype,
buf, sizeof(buf)));
#endif
params->dp_pre_dump = 1;
}
if (obj->ce_ops->oo_dump[type])
obj->ce_ops->oo_dump[type](obj, params);
}
/** @endcond */
/** @} */