static int addr_dump_full(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_addr *addr = (struct rtnl_addr *) obj;
int line = addr_dump_brief(obj, p);
char buf[128];
if (addr->a_mask & (ADDR_ATTR_LABEL | ADDR_ATTR_BROADCAST |
ADDR_ATTR_ANYCAST | ADDR_ATTR_MULTICAST)) {
dp_dump_line(p, line++, " ");
if (addr->a_mask & ADDR_ATTR_LABEL)
dp_dump(p, " label %s", addr->a_label);
if (addr->a_mask & ADDR_ATTR_BROADCAST)
dp_dump(p, " broadcast %s",
nl_addr2str(addr->a_bcast, buf, sizeof(buf)));
if (addr->a_mask & ADDR_ATTR_ANYCAST)
dp_dump(p, " anycast %s",
nl_addr2str(addr->a_anycast, buf,
sizeof(buf)));
if (addr->a_mask & ADDR_ATTR_MULTICAST)
dp_dump(p, " multicast %s",
nl_addr2str(addr->a_multicast, buf,
sizeof(buf)));
dp_dump(p, "\n");
}
if (addr->a_mask & ADDR_ATTR_CACHEINFO) {
struct rtnl_addr_cacheinfo *ci = &addr->a_cacheinfo;
dp_dump_line(p, line++, " valid-lifetime %s",
ci->aci_valid == 0xFFFFFFFFU ? "forever" :
nl_msec2str(ci->aci_valid * 1000,
buf, sizeof(buf)));
dp_dump(p, " preferred-lifetime %s\n",
ci->aci_prefered == 0xFFFFFFFFU ? "forever" :
nl_msec2str(ci->aci_prefered * 1000,
buf, sizeof(buf)));
dp_dump_line(p, line++, " created boot-time+%s ",
nl_msec2str(addr->a_cacheinfo.aci_cstamp * 10,
buf, sizeof(buf)));
dp_dump(p, "last-updated boot-time+%s\n",
nl_msec2str(addr->a_cacheinfo.aci_tstamp * 10,
buf, sizeof(buf)));
}
return line;
}
static void netem_dump_details(struct rtnl_tc *tc, void *data,
struct nl_dump_params *p)
{
struct rtnl_netem *netem = data;
char buf[32];
if (netem) {
if (netem->qnm_mask & SCH_NETEM_ATTR_LATENCY && netem->qnm_latency > 0) {
nl_msec2str(nl_ticks2us(netem->qnm_latency) / 1000, buf, sizeof(buf));
nl_dump(p, " latency %s", buf);
if (netem->qnm_mask & SCH_NETEM_ATTR_JITTER && netem->qnm_jitter > 0) {
nl_msec2str(nl_ticks2us(netem->qnm_jitter) / 1000, buf, sizeof(buf));
nl_dump(p, " jitter %s", buf);
if (netem->qnm_mask & SCH_NETEM_ATTR_DELAY_CORR && netem->qnm_corr.nmc_delay > 0)
nl_dump(p, " %d%", netem->qnm_corr.nmc_delay);
}
}
if (netem->qnm_mask & SCH_NETEM_ATTR_LOSS && netem->qnm_loss > 0) {
nl_dump(p, " loss %d%", netem->qnm_loss);
if (netem->qnm_mask & SCH_NETEM_ATTR_LOSS_CORR && netem->qnm_corr.nmc_loss > 0)
nl_dump(p, " %d%", netem->qnm_corr.nmc_loss);
}
if (netem->qnm_mask & SCH_NETEM_ATTR_DUPLICATE && netem->qnm_duplicate > 0) {
nl_dump(p, " duplicate %d%", netem->qnm_duplicate);
if (netem->qnm_mask & SCH_NETEM_ATTR_DUP_CORR && netem->qnm_corr.nmc_duplicate > 0)
nl_dump(p, " %d%", netem->qnm_corr.nmc_duplicate);
}
if (netem->qnm_mask & SCH_NETEM_ATTR_RO_PROB && netem->qnm_ro.nmro_probability > 0) {
nl_dump(p, " reorder %d%", netem->qnm_ro.nmro_probability);
if (netem->qnm_mask & SCH_NETEM_ATTR_RO_CORR && netem->qnm_ro.nmro_correlation > 0)
nl_dump(p, " %d%", netem->qnm_ro.nmro_correlation);
if (netem->qnm_mask & SCH_NETEM_ATTR_GAP && netem->qnm_gap > 0)
nl_dump(p, " gap %d", netem->qnm_gap);
}
if (netem->qnm_mask & SCH_NETEM_ATTR_CORRUPT_PROB && netem->qnm_crpt.nmcr_probability > 0) {
nl_dump(p, " reorder %d%", netem->qnm_crpt.nmcr_probability);
if (netem->qnm_mask & SCH_NETEM_ATTR_CORRUPT_CORR && netem->qnm_crpt.nmcr_correlation > 0)
nl_dump(p, " %d%", netem->qnm_crpt.nmcr_correlation);
}
}
}
static void idiag_msg_dump_details(struct nl_object *a, struct nl_dump_params *p)
{
struct idiagnl_msg *msg = (struct idiagnl_msg *) a;
char buf[64], buf2[64];
nl_dump(p, "\nfamily: %s\n", nl_af2str(msg->idiag_family, buf, sizeof(buf)));
nl_dump(p, "state: %s\n",
idiagnl_state2str(msg->idiag_state, buf, sizeof(buf)));
nl_dump(p, "timer (%s, %s, retransmits: %d)\n",
idiagnl_timer2str(msg->idiag_timer, buf, sizeof(buf)),
nl_msec2str(msg->idiag_expires, buf2, sizeof(buf2)),
msg->idiag_retrans);
nl_dump(p, "source: %s:%d\n", nl_addr2str(msg->idiag_src, buf, sizeof(buf)),
ntohs(msg->idiag_sport));
nl_dump(p, "destination: %s:%d\n", nl_addr2str(msg->idiag_dst, buf, sizeof(buf)),
ntohs(msg->idiag_dport));
nl_dump(p, "ifindex: %d\n", msg->idiag_ifindex);
nl_dump(p, "rqueue: %-6d wqueue: %-6d\n", msg->idiag_rqueue, msg->idiag_wqueue);
nl_dump(p, "uid %d\n", msg->idiag_uid);
nl_dump(p, "inode %d\n", msg->idiag_inode);
if (msg->idiag_shutdown) {
nl_dump(p, "socket shutdown: %s\n",
idiagnl_shutdown2str(msg->idiag_shutdown,
buf, sizeof(buf)));
}
nl_dump(p, "tos: 0x%x\n", msg->idiag_tos);
nl_dump(p, "traffic class: %d\n", msg->idiag_tclass);
nl_dump(p, "congestion algorithm: %s\n", msg->idiag_cong);
}
static void ct_dump_details(struct nl_object *a, struct nl_dump_params *p)
{
struct nfnl_ct *ct = (struct nfnl_ct *) a;
char buf[64];
int fp = 0;
ct_dump_line(a, p);
nl_dump(p, " id 0x%x ", ct->ct_id);
nl_dump_line(p, "family %s ",
nl_af2str(ct->ct_family, buf, sizeof(buf)));
if (nfnl_ct_test_use(ct))
nl_dump(p, "refcnt %u ", nfnl_ct_get_use(ct));
if (nfnl_ct_test_timeout(ct)) {
uint64_t timeout_ms = nfnl_ct_get_timeout(ct) * 1000UL;
nl_dump(p, "timeout %s ",
nl_msec2str(timeout_ms, buf, sizeof(buf)));
}
if (ct->ct_status)
nl_dump(p, "<");
#define PRINT_FLAG(str) \
{ nl_dump(p, "%s%s", fp++ ? "," : "", (str)); }
if (ct->ct_status & IPS_EXPECTED)
PRINT_FLAG("EXPECTED");
if (!(ct->ct_status & IPS_SEEN_REPLY))
PRINT_FLAG("NOREPLY");
if (ct->ct_status & IPS_ASSURED)
PRINT_FLAG("ASSURED");
if (!(ct->ct_status & IPS_CONFIRMED))
PRINT_FLAG("NOTSENT");
if (ct->ct_status & IPS_SRC_NAT)
PRINT_FLAG("SNAT");
if (ct->ct_status & IPS_DST_NAT)
PRINT_FLAG("DNAT");
if (ct->ct_status & IPS_SEQ_ADJUST)
PRINT_FLAG("SEQADJUST");
if (!(ct->ct_status & IPS_SRC_NAT_DONE))
PRINT_FLAG("SNAT_INIT");
if (!(ct->ct_status & IPS_DST_NAT_DONE))
PRINT_FLAG("DNAT_INIT");
if (ct->ct_status & IPS_DYING)
PRINT_FLAG("DYING");
if (ct->ct_status & IPS_FIXED_TIMEOUT)
PRINT_FLAG("FIXED_TIMEOUT");
#undef PRINT_FLAG
if (ct->ct_status)
nl_dump(p, ">");
nl_dump(p, "\n");
}
static void exp_dump_details(struct nl_object *a, struct nl_dump_params *p)
{
struct nfnl_exp *exp = (struct nfnl_exp *) a;
char buf[64];
int fp = 0;
exp_dump_line(a, p);
nl_dump(p, " id 0x%x ", exp->exp_id);
nl_dump_line(p, "family %s ",
nl_af2str(exp->exp_family, buf, sizeof(buf)));
if (nfnl_exp_test_timeout(exp)) {
uint64_t timeout_ms = nfnl_exp_get_timeout(exp) * 1000UL;
nl_dump(p, "timeout %s ",
nl_msec2str(timeout_ms, buf, sizeof(buf)));
}
if (nfnl_exp_test_helper_name(exp))
nl_dump(p, "helper %s ", exp->exp_helper_name);
if (nfnl_exp_test_fn(exp))
nl_dump(p, "fn %s ", exp->exp_fn);
if (nfnl_exp_test_class(exp))
nl_dump(p, "class %u ", nfnl_exp_get_class(exp));
if (nfnl_exp_test_zone(exp))
nl_dump(p, "zone %u ", nfnl_exp_get_zone(exp));
if (nfnl_exp_test_flags(exp))
nl_dump(p, "<");
#define PRINT_FLAG(str) \
{ nl_dump(p, "%s%s", fp++ ? "," : "", (str)); }
if (exp->exp_flags & NF_CT_EXPECT_PERMANENT)
PRINT_FLAG("PERMANENT");
if (exp->exp_flags & NF_CT_EXPECT_INACTIVE)
PRINT_FLAG("INACTIVE");
if (exp->exp_flags & NF_CT_EXPECT_USERSPACE)
PRINT_FLAG("USERSPACE");
#undef PRINT_FLAG
if (nfnl_exp_test_flags(exp))
nl_dump(p, ">");
nl_dump(p, "\n");
}
static int addr_dump_xml(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_addr *addr = (struct rtnl_addr *) obj;
struct nl_cache *link_cache;
char buf[128];
int line = 0;
dp_dump_line(p, line++, "<address>\n");
dp_dump_line(p, line++, " <family>%s</family>\n",
nl_af2str(addr->a_family, buf, sizeof(buf)));
if (addr->a_mask & ADDR_ATTR_LOCAL)
dp_dump_line(p, line++, " <local>%s</local>\n",
nl_addr2str(addr->a_local, buf, sizeof(buf)));
if (addr->a_mask & ADDR_ATTR_PEER)
dp_dump_line(p, line++, " <peer>%s</peer>\n",
nl_addr2str(addr->a_peer, buf, sizeof(buf)));
if (addr->a_mask & ADDR_ATTR_BROADCAST)
dp_dump_line(p, line++, " <broadcast>%s</broadcast>\n",
nl_addr2str(addr->a_bcast, buf, sizeof(buf)));
if (addr->a_mask & ADDR_ATTR_ANYCAST)
dp_dump_line(p, line++, " <anycast>%s</anycast>\n",
nl_addr2str(addr->a_anycast, buf, sizeof(buf)));
if (addr->a_mask & ADDR_ATTR_MULTICAST)
dp_dump_line(p, line++, " <multicast>%s</multicast>\n",
nl_addr2str(addr->a_multicast, buf,
sizeof(buf)));
if (addr->a_mask & ADDR_ATTR_PREFIXLEN)
dp_dump_line(p, line++, " <prefixlen>%u</prefixlen>\n",
addr->a_prefixlen);
link_cache = nl_cache_mngt_require("route/link");
if (link_cache)
dp_dump_line(p, line++, " <device>%s</device>\n",
rtnl_link_i2name(link_cache, addr->a_ifindex,
buf, sizeof(buf)));
else
dp_dump_line(p, line++, " <device>%u</device>\n",
addr->a_ifindex);
if (addr->a_mask & ADDR_ATTR_SCOPE)
dp_dump_line(p, line++, " <scope>%s</scope>\n",
rtnl_scope2str(addr->a_scope, buf, sizeof(buf)));
if (addr->a_mask & ADDR_ATTR_LABEL)
dp_dump_line(p, line++, " <label>%s</label>\n", addr->a_label);
rtnl_addr_flags2str(addr->a_flags, buf, sizeof(buf));
if (buf[0])
dp_dump_line(p, line++, " <flags>%s</flags>\n", buf);
if (addr->a_mask & ADDR_ATTR_CACHEINFO) {
struct rtnl_addr_cacheinfo *ci = &addr->a_cacheinfo;
dp_dump_line(p, line++, " <cacheinfo>\n");
dp_dump_line(p, line++, " <valid>%s</valid>\n",
ci->aci_valid == 0xFFFFFFFFU ? "forever" :
nl_msec2str(ci->aci_valid * 1000,
buf, sizeof(buf)));
dp_dump_line(p, line++, " <prefered>%s</prefered>\n",
ci->aci_prefered == 0xFFFFFFFFU ? "forever" :
nl_msec2str(ci->aci_prefered * 1000,
buf, sizeof(buf)));
dp_dump_line(p, line++, " <created>%s</created>\n",
nl_msec2str(addr->a_cacheinfo.aci_cstamp * 10,
buf, sizeof(buf)));
dp_dump_line(p, line++, " <last-update>%s</last-update>\n",
nl_msec2str(addr->a_cacheinfo.aci_tstamp * 10,
buf, sizeof(buf)));
dp_dump_line(p, line++, " </cacheinfo>\n");
}
dp_dump_line(p, line++, "</address>\n");
return line;
}
static void idiag_msg_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
{
struct idiagnl_msg *msg = (struct idiagnl_msg *) obj;
char buf[64];
idiag_msg_dump_details(obj, p);
nl_dump(p, "tcp info: [\n");
nl_dump(p, "\tsocket state: %s\n",
idiagnl_state2str(msg->idiag_tcpinfo.tcpi_state,
buf, sizeof(buf)));
nl_dump(p, "\ttcp state: %s\n",
idiagnl_tcpstate2str(msg->idiag_tcpinfo.tcpi_ca_state,
buf, sizeof(buf)));
nl_dump(p, "\tretransmits: %d\n",
msg->idiag_tcpinfo.tcpi_retransmits);
nl_dump(p, "\tprobes: %d\n",
msg->idiag_tcpinfo.tcpi_probes);
nl_dump(p, "\tbackoff: %d\n",
msg->idiag_tcpinfo.tcpi_backoff);
nl_dump(p, "\toptions: %s\n",
idiagnl_tcpopts2str(msg->idiag_tcpinfo.tcpi_options,
buf, sizeof(buf)));
nl_dump(p, "\tsnd_wscale: %d\n", msg->idiag_tcpinfo.tcpi_snd_wscale);
nl_dump(p, "\trcv_wscale: %d\n", msg->idiag_tcpinfo.tcpi_rcv_wscale);
nl_dump(p, "\trto: %d\n", msg->idiag_tcpinfo.tcpi_rto);
nl_dump(p, "\tato: %d\n", msg->idiag_tcpinfo.tcpi_ato);
nl_dump(p, "\tsnd_mss: %s\n", nl_size2str(msg->idiag_tcpinfo.tcpi_snd_mss,
buf, sizeof(buf)));
nl_dump(p, "\trcv_mss: %s\n", nl_size2str(msg->idiag_tcpinfo.tcpi_rcv_mss,
buf, sizeof(buf)));
nl_dump(p, "\tunacked: %d\n", msg->idiag_tcpinfo.tcpi_unacked);
nl_dump(p, "\tsacked: %d\n", msg->idiag_tcpinfo.tcpi_sacked);
nl_dump(p, "\tlost: %d\n", msg->idiag_tcpinfo.tcpi_lost);
nl_dump(p, "\tretransmit segments: %d\n",
msg->idiag_tcpinfo.tcpi_retrans);
nl_dump(p, "\tfackets: %d\n",
msg->idiag_tcpinfo.tcpi_fackets);
nl_dump(p, "\tlast data sent: %s\n",
nl_msec2str(msg->idiag_tcpinfo.tcpi_last_data_sent, buf,
sizeof(buf)));
nl_dump(p, "\tlast ack sent: %s\n",
nl_msec2str(msg->idiag_tcpinfo.tcpi_last_ack_sent, buf, sizeof(buf)));
nl_dump(p, "\tlast data recv: %s\n",
nl_msec2str(msg->idiag_tcpinfo.tcpi_last_data_recv, buf,
sizeof(buf)));
nl_dump(p, "\tlast ack recv: %s\n",
nl_msec2str(msg->idiag_tcpinfo.tcpi_last_ack_recv, buf,
sizeof(buf)));
nl_dump(p, "\tpath mtu: %s\n",
nl_size2str(msg->idiag_tcpinfo.tcpi_pmtu, buf,
sizeof(buf)));
nl_dump(p, "\trcv ss threshold: %d\n",
msg->idiag_tcpinfo.tcpi_rcv_ssthresh);
nl_dump(p, "\tsmoothed round trip time: %d\n",
msg->idiag_tcpinfo.tcpi_rtt);
nl_dump(p, "\tround trip time variation: %d\n",
msg->idiag_tcpinfo.tcpi_rttvar);
nl_dump(p, "\tsnd ss threshold: %s\n",
nl_size2str(msg->idiag_tcpinfo.tcpi_snd_ssthresh, buf,
sizeof(buf)));
nl_dump(p, "\tsend congestion window: %d\n",
msg->idiag_tcpinfo.tcpi_snd_cwnd);
nl_dump(p, "\tadvertised mss: %s\n",
nl_size2str(msg->idiag_tcpinfo.tcpi_advmss, buf,
sizeof(buf)));
nl_dump(p, "\treordering: %d\n",
msg->idiag_tcpinfo.tcpi_reordering);
nl_dump(p, "\trcv rround trip time: %d\n",
msg->idiag_tcpinfo.tcpi_rcv_rtt);
nl_dump(p, "\treceive queue space: %s\n",
nl_size2str(msg->idiag_tcpinfo.tcpi_rcv_space, buf,
sizeof(buf)));
nl_dump(p, "\ttotal retransmits: %d\n",
msg->idiag_tcpinfo.tcpi_total_retrans);
nl_dump(p, "]\n");
if (msg->idiag_meminfo) {
nl_dump(p, "meminfo: [\n");
nl_dump(p, "\trmem: %s\n",
nl_size2str(msg->idiag_meminfo->idiag_rmem,
buf,
sizeof(buf)));
nl_dump(p, "\twmem: %s\n",
nl_size2str(msg->idiag_meminfo->idiag_wmem,
buf,
sizeof(buf)));
nl_dump(p, "\tfmem: %s\n",
nl_size2str(msg->idiag_meminfo->idiag_fmem,
buf,
sizeof(buf)));
nl_dump(p, "\ttmem: %s\n",
nl_size2str(msg->idiag_meminfo->idiag_tmem,
buf,
sizeof(buf)));
nl_dump(p, "]\n");
}
if (msg->idiag_vegasinfo) {
nl_dump(p, "vegasinfo: [\n");
nl_dump(p, "\tvegas enabled: %d\n",
msg->idiag_vegasinfo->tcpv_enabled);
if (msg->idiag_vegasinfo->tcpv_enabled) {
nl_dump(p, "\trtt cnt: %d",
msg->idiag_vegasinfo->tcpv_rttcnt);
nl_dump(p, "\trtt (propagation delay): %d",
msg->idiag_vegasinfo->tcpv_rtt);
nl_dump(p, "\tmin rtt: %d",
msg->idiag_vegasinfo->tcpv_minrtt);
}
nl_dump(p, "]\n");
}
nl_dump(p, "skmeminfo: [\n");
nl_dump(p, "\trmem alloc: %d\n",
msg->idiag_skmeminfo[SK_MEMINFO_RMEM_ALLOC]);
nl_dump(p, "\trcv buf: %s\n",
nl_size2str(msg->idiag_skmeminfo[SK_MEMINFO_RCVBUF],
buf, sizeof(buf)));
nl_dump(p, "\twmem alloc: %d\n",
msg->idiag_skmeminfo[SK_MEMINFO_WMEM_ALLOC]);
nl_dump(p, "\tsnd buf: %s\n",
nl_size2str(msg->idiag_skmeminfo[SK_MEMINFO_SNDBUF],
buf, sizeof(buf)));
nl_dump(p, "\tfwd alloc: %d\n",
msg->idiag_skmeminfo[SK_MEMINFO_FWD_ALLOC]);
nl_dump(p, "\twmem queued: %s\n",
nl_size2str(msg->idiag_skmeminfo[SK_MEMINFO_WMEM_QUEUED],
buf, sizeof(buf)));
nl_dump(p, "\topt mem: %d\n",
msg->idiag_skmeminfo[SK_MEMINFO_OPTMEM]);
nl_dump(p, "\tbacklog: %d\n",
msg->idiag_skmeminfo[SK_MEMINFO_BACKLOG]);
nl_dump(p, "]\n\n");
}
static int addr_dump_env(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_addr *addr = (struct rtnl_addr *) obj;
struct nl_cache *link_cache;
char buf[128];
int line = 0;
dp_dump_line(p, line++, "ADDR_FAMILY=%s\n",
nl_af2str(addr->a_family, buf, sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_LOCAL)
dp_dump_line(p, line++, "ADDR_LOCAL=%s\n",
nl_addr2str(addr->a_local, buf, sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_PEER)
dp_dump_line(p, line++, "ADDR_PEER=%s\n",
nl_addr2str(addr->a_peer, buf, sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_BROADCAST)
dp_dump_line(p, line++, "ADDR_BROADCAST=%s\n",
nl_addr2str(addr->a_bcast, buf, sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_ANYCAST)
dp_dump_line(p, line++, "ADDR_ANYCAST=%s\n",
nl_addr2str(addr->a_anycast, buf, sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_MULTICAST)
dp_dump_line(p, line++, "ADDR_MULTICAST=%s\n",
nl_addr2str(addr->a_multicast, buf,
sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_PREFIXLEN)
dp_dump_line(p, line++, "ADDR_PREFIXLEN=%u\n",
addr->a_prefixlen);
link_cache = nl_cache_mngt_require("route/link");
dp_dump_line(p, line++, "ADDR_IFINDEX=%u\n", addr->a_ifindex);
if (link_cache)
dp_dump_line(p, line++, "ADDR_IFNAME=%s\n",
rtnl_link_i2name(link_cache, addr->a_ifindex,
buf, sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_SCOPE)
dp_dump_line(p, line++, "ADDR_SCOPE=%s\n",
rtnl_scope2str(addr->a_scope, buf, sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_LABEL)
dp_dump_line(p, line++, "ADDR_LABEL=%s\n", addr->a_label);
rtnl_addr_flags2str(addr->a_flags, buf, sizeof(buf));
if (buf[0])
dp_dump_line(p, line++, "ADDR_FLAGS=%s\n", buf);
if (addr->ce_mask & ADDR_ATTR_CACHEINFO) {
struct rtnl_addr_cacheinfo *ci = &addr->a_cacheinfo;
dp_dump_line(p, line++, "ADDR_CACHEINFO_VALID=%s\n",
ci->aci_valid == 0xFFFFFFFFU ? "forever" :
nl_msec2str(ci->aci_valid * 1000,
buf, sizeof(buf)));
dp_dump_line(p, line++, "ADDR_CACHEINFO_PREFERED=%s\n",
ci->aci_prefered == 0xFFFFFFFFU ? "forever" :
nl_msec2str(ci->aci_prefered * 1000,
buf, sizeof(buf)));
dp_dump_line(p, line++, "ADDR_CACHEINFO_CREATED=%s\n",
nl_msec2str(addr->a_cacheinfo.aci_cstamp * 10,
buf, sizeof(buf)));
dp_dump_line(p, line++, "ADDR_CACHEINFO_LASTUPDATE=%s\n",
nl_msec2str(addr->a_cacheinfo.aci_tstamp * 10,
buf, sizeof(buf)));
}
return line;
}
static void inet6_dump_details(struct rtnl_link *link,
struct nl_dump_params *p, void *data)
{
struct inet6_data *i6 = data;
char buf[64], buf2[64];
int i, n = 0;
nl_dump_line(p, " ipv6 max-reasm-len %s",
nl_size2str(i6->i6_cacheinfo.max_reasm_len, buf, sizeof(buf)));
nl_dump(p, " <%s>\n",
inet6_flags2str(i6->i6_flags, buf, sizeof(buf)));
nl_dump_line(p, " create-stamp %.2fs reachable-time %s",
(double) i6->i6_cacheinfo.tstamp / 100.,
nl_msec2str(i6->i6_cacheinfo.reachable_time, buf, sizeof(buf)));
nl_dump(p, " retrans-time %s\n",
nl_msec2str(i6->i6_cacheinfo.retrans_time, buf, sizeof(buf)));
nl_dump_line(p, " devconf:\n");
nl_dump_line(p, " ");
for (i = 0; i < DEVCONF_MAX; i++) {
uint32_t value = i6->i6_conf[i];
int x, offset;
switch (i) {
case DEVCONF_TEMP_VALID_LFT:
case DEVCONF_TEMP_PREFERED_LFT:
nl_msec2str((uint64_t) value * 1000., buf2, sizeof(buf2));
break;
case DEVCONF_RTR_PROBE_INTERVAL:
case DEVCONF_RTR_SOLICIT_INTERVAL:
case DEVCONF_RTR_SOLICIT_DELAY:
nl_msec2str(value, buf2, sizeof(buf2));
break;
default:
snprintf(buf2, sizeof(buf2), "%u", value);
break;
}
inet6_devconf2str(i, buf, sizeof(buf));
offset = 23 - strlen(buf2);
if (offset < 0)
offset = 0;
for (x = strlen(buf); x < offset; x++)
buf[x] = ' ';
strncpy(&buf[offset], buf2, strlen(buf2));
nl_dump_line(p, "%s", buf);
if (++n == 3) {
nl_dump(p, "\n");
nl_dump_line(p, " ");
n = 0;
} else
nl_dump(p, " ");
}
if (n != 0)
nl_dump(p, "\n");
}
