static void ct_dump_stats(struct nl_object *a, struct nl_dump_params *p)
{
struct nfnl_ct *ct = (struct nfnl_ct *) a;
double res;
char *unit;
uint64_t packets;
const char * const names[] = {"rx", "tx"};
int i;
ct_dump_details(a, p);
if (!nfnl_ct_test_bytes(ct, 0) ||
!nfnl_ct_test_packets(ct, 0) ||
!nfnl_ct_test_bytes(ct, 1) ||
!nfnl_ct_test_packets(ct, 1))
{
nl_dump_line(p, " Statistics are not available.\n");
nl_dump_line(p, " Please set sysctl net.netfilter.nf_conntrack_acct=1\n");
nl_dump_line(p, " (Require kernel 2.6.27)\n");
return;
}
nl_dump_line(p, " # packets volume\n");
for (i=0; i<=1; i++) {
res = nl_cancel_down_bytes(nfnl_ct_get_bytes(ct, i), &unit);
packets = nfnl_ct_get_packets(ct, i);
nl_dump_line(p, " %s %10" PRIu64 " %7.2f %s\n", names[i], packets, res, unit);
}
}
void tca_dump_stats(struct rtnl_tc *g, struct nl_dump_params *p)
{
char *unit, fmt[64];
float res;
strcpy(fmt, " %7.2f %s %10u %10u %10u %10u %10u\n");
nl_dump_line(p,
" Stats: bytes packets drops overlimits" \
" qlen backlog\n");
res = nl_cancel_down_bytes(g->tc_stats[RTNL_TC_BYTES], &unit);
if (*unit == 'B')
fmt[11] = '9';
nl_dump_line(p, fmt, res, unit,
g->tc_stats[RTNL_TC_PACKETS],
g->tc_stats[RTNL_TC_DROPS],
g->tc_stats[RTNL_TC_OVERLIMITS],
g->tc_stats[RTNL_TC_QLEN],
g->tc_stats[RTNL_TC_BACKLOG]);
res = nl_cancel_down_bytes(g->tc_stats[RTNL_TC_RATE_BPS], &unit);
strcpy(fmt, " %7.2f %s/s%9u pps");
if (*unit == 'B')
fmt[11] = '9';
nl_dump_line(p, fmt, res, unit, g->tc_stats[RTNL_TC_RATE_PPS]);
}
static void veth_dump_details(struct rtnl_link *link, struct nl_dump_params *p)
{
struct rtnl_link *peer = link->l_info;
char *name;
name = rtnl_link_get_name(peer);
nl_dump(p, " peer ");
if (name)
nl_dump_line(p, "%s\n", name);
else
nl_dump_line(p, "%u\n", peer->l_index);
}
static void result_dump_line(struct nl_object *obj, struct nl_dump_params *p)
{
struct flnl_result *res = (struct flnl_result *) obj;
char buf[256];
nl_dump_line(p, "table %s prefixlen %u next-hop-selector %u\n",
rtnl_route_table2str(res->fr_table_id, buf, sizeof(buf)),
res->fr_prefixlen, res->fr_nh_sel);
nl_dump_line(p, "type %s ",
nl_rtntype2str(res->fr_type, buf, sizeof(buf)));
nl_dump(p, "scope %s error %s (%d)\n",
rtnl_scope2str(res->fr_scope, buf, sizeof(buf)),
strerror_r(-res->fr_error, buf, sizeof(buf)), res->fr_error);
}
static void vlan_dump_details(struct rtnl_link *link, struct nl_dump_params *p)
{
struct vlan_info *vi = link->l_info;
int i, printed;
char buf[64];
rtnl_link_vlan_flags2str(vi->vi_flags, buf, sizeof(buf));
nl_dump_line(p, " vlan-info id %d <%s>\n", vi->vi_vlan_id, buf);
if (vi->vi_mask & VLAN_HAS_INGRESS_QOS) {
nl_dump_line(p,
" ingress vlan prio -> qos/socket prio mapping:\n");
for (i = 0, printed = 0; i <= VLAN_PRIO_MAX; i++) {
if (vi->vi_ingress_qos[i]) {
if (printed == 0)
nl_dump_line(p, " ");
nl_dump(p, "%x -> %#08x, ",
i, vi->vi_ingress_qos[i]);
if (printed++ == 3) {
nl_dump(p, "\n");
printed = 0;
}
}
}
if (printed > 0 && printed != 4)
nl_dump(p, "\n");
}
if (vi->vi_mask & VLAN_HAS_EGRESS_QOS) {
nl_dump_line(p,
" egress qos/socket prio -> vlan prio mapping:\n");
for (i = 0, printed = 0; i < vi->vi_negress; i++) {
if (printed == 0)
nl_dump_line(p, " ");
nl_dump(p, "%#08x -> %x, ",
vi->vi_egress_qos[i].vm_from,
vi->vi_egress_qos[i].vm_to);
if (printed++ == 3) {
nl_dump(p, "\n");
printed = 0;
}
}
if (printed > 0 && printed != 4)
nl_dump(p, "\n");
}
}
static void bridge_dump_details(struct rtnl_link *link,
struct nl_dump_params *p, void *data)
{
struct bridge_data *bd = data;
nl_dump_line(p, " bridge: ");
if (bd->ce_mask & BRIDGE_ATTR_PORT_STATE)
nl_dump(p, "port-state %u ", bd->b_port_state);
if (bd->ce_mask & BRIDGE_ATTR_PRIORITY)
nl_dump(p, "prio %u ", bd->b_priority);
if (bd->ce_mask & BRIDGE_ATTR_COST)
nl_dump(p, "cost %u ", bd->b_cost);
if (bd->ce_mask & BRIDGE_ATTR_PORT_VLAN)
rtnl_link_bridge_dump_vlans(p, bd);
if (bd->ce_mask & BRIDGE_ATTR_FLAGS) {
char buf[256];
rtnl_link_bridge_flags2str(bd->b_flags & bd->b_flags_mask,
buf, sizeof(buf));
nl_dump(p, "%s", buf);
}
nl_dump(p, "\n");
}
static void print_selector(struct nl_dump_params *p, struct tc_u32_sel *sel,
struct rtnl_u32 *u)
{
int i;
struct tc_u32_key *key;
if (sel->hmask || sel->hoff) {
/* I guess this will never be used since the kernel only
* exports the selector if no divisor is set but hash offset
* and hash mask make only sense in hash filters with divisor
* set */
nl_dump(p, " hash at %u & 0x%x", sel->hoff, sel->hmask);
}
if (sel->flags & (TC_U32_OFFSET | TC_U32_VAROFFSET)) {
nl_dump(p, " offset at %u", sel->off);
if (sel->flags & TC_U32_VAROFFSET)
nl_dump(p, " variable (at %u & 0x%x) >> %u",
sel->offoff, ntohs(sel->offmask), sel->offshift);
}
if (sel->flags) {
int flags = sel->flags;
nl_dump(p, " <");
#define PRINT_FLAG(f) if (flags & TC_U32_##f) { \
flags &= ~TC_U32_##f; nl_dump(p, #f "%s", flags ? "," : ""); }
PRINT_FLAG(TERMINAL);
PRINT_FLAG(OFFSET);
PRINT_FLAG(VAROFFSET);
PRINT_FLAG(EAT);
#undef PRINT_FLAG
nl_dump(p, ">");
}
for (i = 0; i < sel->nkeys; i++) {
key = &sel->keys[i];
nl_dump(p, "\n");
nl_dump_line(p, " match key at %s%u ",
key->offmask ? "nexthdr+" : "", key->off);
if (key->offmask)
nl_dump(p, "[0x%u] ", key->offmask);
nl_dump(p, "& 0x%08x == 0x%08x", ntohl(key->mask), ntohl(key->val));
if (p->dp_type == NL_DUMP_STATS &&
(u->cu_mask & U32_ATTR_PCNT)) {
struct tc_u32_pcnt *pcnt = u->cu_pcnt->d_data;
nl_dump(p, " successful %" PRIu64, pcnt->kcnts[i]);
}
}
}
static void cgroup_dump_details(struct rtnl_cls *cls, struct nl_dump_params *p)
{
struct rtnl_cgroup *c = rtnl_cls_data(cls);
if (c->cg_mask & CGROUP_ATTR_EMATCH) {
nl_dump_line(p, " ematch ");
rtnl_ematch_tree_dump(c->cg_ematch, p);
} else
nl_dump(p, "no options.\n");
}
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 rule_dump_details(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_rule *rule = (struct rtnl_rule *) obj;
char buf[128];
rule_dump_line(obj, p);
if (rule->ce_mask & RULE_ATTR_SRCMAP)
nl_dump_line(p, " srcmap %s\n",
nl_addr2str(rule->r_srcmap, buf, sizeof(buf)));
}
static void u32_dump_stats(struct rtnl_cls *cls, struct nl_dump_params *p)
{
struct rtnl_u32 *u = rtnl_cls_data(cls);
if (u->cu_mask & U32_ATTR_PCNT) {
struct tc_u32_pcnt *pc = u->cu_pcnt->d_data;
nl_dump(p, "\n");
nl_dump_line(p, " hit %8llu count %8llu\n",
pc->rhit, pc->rcnt);
}
}
static void idiag_msg_dump_line(struct nl_object *a, struct nl_dump_params *p)
{
struct idiagnl_msg *msg = (struct idiagnl_msg *) a;
char buf[64] = { 0 };
nl_dump_line(p, "family: %s ", nl_af2str(msg->idiag_family, buf, sizeof(buf)));
nl_dump(p, "src: %s:%d ", nl_addr2str(msg->idiag_src, buf, sizeof(buf)),
ntohs(msg->idiag_sport));
nl_dump(p, "dst: %s:%d ", nl_addr2str(msg->idiag_dst, buf, sizeof(buf)),
ntohs(msg->idiag_dport));
nl_dump(p, "iif: %d ", msg->idiag_ifindex);
nl_dump(p, "\n");
}
void tca_dump_details(struct rtnl_tc *tc, struct nl_dump_params *p)
{
nl_dump_line(p, " ");
if (tc->ce_mask & TCA_ATTR_MTU)
nl_dump(p, " mtu %u", tc->tc_mtu);
if (tc->ce_mask & TCA_ATTR_MPU)
nl_dump(p, " mput %u", tc->tc_mpu);
if (tc->ce_mask & TCA_ATTR_OVERHEAD)
nl_dump(p, " overhead %u", tc->tc_overhead);
}
static void u32_dump_stats(struct rtnl_tc *tc, void *data,
struct nl_dump_params *p)
{
struct rtnl_u32 *u = data;
if (!u)
return;
if (u->cu_mask & U32_ATTR_PCNT) {
struct tc_u32_pcnt *pc = u->cu_pcnt->d_data;
nl_dump(p, "\n");
nl_dump_line(p, " hit %8" PRIu64 " count %8" PRIu64 "\n",
pc->rhit, pc->rcnt);
}
}
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 void rule_dump_line(struct nl_object *o, struct nl_dump_params *p)
{
struct rtnl_rule *r = (struct rtnl_rule *) o;
char buf[128];
nl_dump_line(p, "%8d ", (r->ce_mask & RULE_ATTR_PRIO) ? r->r_prio : 0);
nl_dump(p, "%s ", nl_af2str(r->r_family, buf, sizeof(buf)));
if (r->ce_mask & RULE_ATTR_SRC)
nl_dump(p, "from %s ",
nl_addr2str(r->r_src, buf, sizeof(buf)));
if (r->ce_mask & RULE_ATTR_DST)
nl_dump(p, "to %s ",
nl_addr2str(r->r_dst, buf, sizeof(buf)));
if (r->ce_mask & RULE_ATTR_DSFIELD)
nl_dump(p, "tos %u ", r->r_dsfield);
if (r->ce_mask & (RULE_ATTR_MARK | RULE_ATTR_MASK))
nl_dump(p, "mark %#x/%#x", r->r_mark, r->r_mask);
if (r->ce_mask & RULE_ATTR_IIFNAME)
nl_dump(p, "iif %s ", r->r_iifname);
if (r->ce_mask & RULE_ATTR_OIFNAME)
nl_dump(p, "oif %s ", r->r_oifname);
if (r->ce_mask & RULE_ATTR_TABLE)
nl_dump(p, "lookup %s ",
rtnl_route_table2str(r->r_table, buf, sizeof(buf)));
if (r->ce_mask & RULE_ATTR_FLOW)
nl_dump(p, "flow %s ",
rtnl_realms2str(r->r_flow, buf, sizeof(buf)));
if (r->ce_mask & RULE_ATTR_GOTO)
nl_dump(p, "goto %u ", r->r_goto);
if (r->ce_mask & RULE_ATTR_ACTION)
nl_dump(p, "action %s",
nl_rtntype2str(r->r_action, buf, sizeof(buf)));
nl_dump(p, "\n");
}
static void bridge_dump_details(struct rtnl_link *link,
struct nl_dump_params *p, void *data)
{
struct bridge_data *bd = data;
nl_dump_line(p, " bridge: ");
if (bd->ce_mask & BRIDGE_ATTR_PORT_STATE)
nl_dump(p, "port-state %u ", bd->b_port_state);
if (bd->ce_mask & BRIDGE_ATTR_PRIORITY)
nl_dump(p, "prio %u ", bd->b_priority);
if (bd->ce_mask & BRIDGE_ATTR_COST)
nl_dump(p, "cost %u ", bd->b_cost);
nl_dump(p, "\n");
}
static void cgroup_dump_details(struct rtnl_tc *tc, void *data,
struct nl_dump_params *p)
{
struct rtnl_cgroup *c = data;
if (!c)
return;
if (c->cg_mask & CGROUP_ATTR_EMATCH) {
nl_dump_line(p, " ematch ");
if (c->cg_ematch)
rtnl_ematch_tree_dump(c->cg_ematch, p);
else
nl_dump(p, "<no tree>");
} else
nl_dump(p, "no options");
}
static void rule_dump_line(struct nl_object *o, struct nl_dump_params *p)
{
struct rtnl_rule *r = (struct rtnl_rule *) o;
char buf[128];
nl_dump_line(p, "%8d ", (r->ce_mask & RULE_ATTR_PRIO) ? r->r_prio : 0);
nl_dump(p, "%s ", nl_af2str(r->r_family, buf, sizeof(buf)));
if (r->ce_mask & RULE_ATTR_SRC)
nl_dump(p, "from %s ",
nl_addr2str(r->r_src, buf, sizeof(buf)));
else if (r->ce_mask & RULE_ATTR_SRC_LEN && r->r_src_len)
nl_dump(p, "from 0/%d ", r->r_src_len);
if (r->ce_mask & RULE_ATTR_DST)
nl_dump(p, "to %s ",
nl_addr2str(r->r_dst, buf, sizeof(buf)));
else if (r->ce_mask & RULE_ATTR_DST_LEN && r->r_dst_len)
nl_dump(p, "to 0/%d ", r->r_dst_len);
if (r->ce_mask & RULE_ATTR_DSFIELD && r->r_dsfield)
nl_dump(p, "tos %d ", r->r_dsfield);
if (r->ce_mask & RULE_ATTR_MARK)
nl_dump(p, "mark %" PRIx64 , r->r_mark);
if (r->ce_mask & RULE_ATTR_IIF)
nl_dump(p, "iif %s ", r->r_iif);
if (r->ce_mask & RULE_ATTR_TABLE)
nl_dump(p, "lookup %s ",
rtnl_route_table2str(r->r_table, buf, sizeof(buf)));
if (r->ce_mask & RULE_ATTR_REALMS)
nl_dump(p, "realms %s ",
rtnl_realms2str(r->r_realms, buf, sizeof(buf)));
nl_dump(p, "action %s\n",
nl_rtntype2str(r->r_type, buf, sizeof(buf)));
}
void tca_dump_line(struct rtnl_tc *g, const char *type,
struct nl_dump_params *p)
{
char handle[32], parent[32];
struct nl_cache *link_cache;
link_cache = nl_cache_mngt_require("route/link");
nl_dump_line(p, "%s %s ", type, g->tc_kind);
if (link_cache) {
char buf[32];
nl_dump(p, "dev %s ",
rtnl_link_i2name(link_cache, g->tc_ifindex,
buf, sizeof(buf)));
} else
nl_dump(p, "dev %u ", g->tc_ifindex);
nl_dump(p, "id %s parent %s",
rtnl_tc_handle2str(g->tc_handle, handle, sizeof(handle)),
rtnl_tc_handle2str(g->tc_parent, parent, sizeof(parent)));
}
static void tbf_dump_details(struct rtnl_tc *tc, void *data,
struct nl_dump_params *p)
{
struct rtnl_tbf *tbf = data;
if (!tbf)
return;
if (1) {
char *bu, *cu;
double bs = nl_cancel_down_bytes(tbf->qt_rate_bucket, &bu);
double cl = nl_cancel_down_bytes(1 << tbf->qt_rate.rs_cell_log,
&cu);
nl_dump(p, "rate-bucket-size %1.f%s "
"rate-cell-size %.1f%s\n",
bs, bu, cl, cu);
}
if (tbf->qt_mask & TBF_ATTR_PEAKRATE) {
char *pru, *prbu, *bsu, *clu;
double pr, prb, bs, cl;
pr = nl_cancel_down_bytes(tbf->qt_peakrate.rs_rate, &pru);
prb = nl_cancel_down_bits(tbf->qt_peakrate.rs_rate * 8, &prbu);
bs = nl_cancel_down_bits(tbf->qt_peakrate_bucket, &bsu);
cl = nl_cancel_down_bits(1 << tbf->qt_peakrate.rs_cell_log,
&clu);
nl_dump_line(p, " peak-rate %.2f%s/s (%.0f%s) "
"bucket-size %.1f%s cell-size %.1f%s"
"latency %.1f%s",
pr, pru, prb, prbu, bs, bsu, cl, clu);
}
}
static void nh_dump_env(struct rtnl_nexthop *nh, struct nl_dump_params *dp)
{
struct nl_cache *link_cache;
char buf[128];
link_cache = nl_cache_mngt_require("route/link");
if (nh->ce_mask & NH_ATTR_GATEWAY)
nl_dump_line(dp, "ROUTE_NH%d_VIA=%s\n", dp->dp_ivar,
nl_addr2str(nh->rtnh_gateway, buf, sizeof(buf)));
if(nh->ce_mask & NH_ATTR_IFINDEX) {
if (link_cache) {
nl_dump_line(dp, "ROUTE_NH%d_DEV=%s\n", dp->dp_ivar,
rtnl_link_i2name(link_cache,
nh->rtnh_ifindex,
buf, sizeof(buf)));
} else
nl_dump_line(dp, "ROUTE_NH%d_DEV=%d\n", dp->dp_ivar,
nh->rtnh_ifindex);
}
if (nh->ce_mask & NH_ATTR_WEIGHT)
nl_dump_line(dp, "ROUTE_NH%d_WEIGHT=%u\n", dp->dp_ivar,
nh->rtnh_weight);
if (nh->ce_mask & NH_ATTR_REALMS)
nl_dump_line(dp, "ROUTE_NH%d_REALM=%04x:%04x\n", dp->dp_ivar,
RTNL_REALM_FROM(nh->rtnh_realms),
RTNL_REALM_TO(nh->rtnh_realms));
if (nh->ce_mask & NH_ATTR_FLAGS)
nl_dump_line(dp, "ROUTE_NH%d_FLAGS=<%s>\n", dp->dp_ivar,
rtnl_route_nh_flags2str(nh->rtnh_flags,
buf, sizeof(buf)));
}
/**
* Print information about cache manager
* @arg mngr Cache manager
* @arg p Dumping parameters
*
* Prints information about the cache manager including all managed caches.
*
* @note This is a debugging function.
*/
void nl_cache_mngr_info(struct nl_cache_mngr *mngr, struct nl_dump_params *p)
{
char buf[128];
int i;
nl_dump_line(p, "cache-manager <%p>\n", mngr);
nl_dump_line(p, " .protocol = %s\n",
nl_nlfamily2str(mngr->cm_protocol, buf, sizeof(buf)));
nl_dump_line(p, " .flags = %#x\n", mngr->cm_flags);
nl_dump_line(p, " .nassocs = %u\n", mngr->cm_nassocs);
nl_dump_line(p, " .sock = <%p>\n", mngr->cm_sock);
for (i = 0; i < mngr->cm_nassocs; i++) {
struct nl_cache_assoc *assoc = &mngr->cm_assocs[i];
if (assoc->ca_cache) {
nl_dump_line(p, " .cache[%d] = <%p> {\n", i, assoc->ca_cache);
nl_dump_line(p, " .name = %s\n", assoc->ca_cache->c_ops->co_name);
nl_dump_line(p, " .change_func = <%p>\n", assoc->ca_change);
nl_dump_line(p, " .change_data = <%p>\n", assoc->ca_change_data);
nl_dump_line(p, " .nitems = %u\n", nl_cache_nitems(assoc->ca_cache));
nl_dump_line(p, " .objects = {\n");
p->dp_prefix += 6;
nl_cache_dump(assoc->ca_cache, p);
p->dp_prefix -= 6;
nl_dump_line(p, " }\n");
nl_dump_line(p, " }\n");
}
}
}
static void rule_dump_env(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_rule *rule = (struct rtnl_rule *) obj;
char buf[128];
nl_dump_line(p, "RULE_PRIORITY=%u\n", rule->r_prio);
nl_dump_line(p, "RULE_FAMILY=%s\n",
nl_af2str(rule->r_family, buf, sizeof(buf)));
if (rule->ce_mask & RULE_ATTR_DST)
nl_dump_line(p, "RULE_DST=%s\n",
nl_addr2str(rule->r_dst, buf, sizeof(buf)));
if (rule->ce_mask & RULE_ATTR_DST_LEN)
nl_dump_line(p, "RULE_DSTLEN=%u\n", rule->r_dst_len);
if (rule->ce_mask & RULE_ATTR_SRC)
nl_dump_line(p, "RULE_SRC=%s\n",
nl_addr2str(rule->r_src, buf, sizeof(buf)));
if (rule->ce_mask & RULE_ATTR_SRC_LEN)
nl_dump_line(p, "RULE_SRCLEN=%u\n", rule->r_src_len);
if (rule->ce_mask & RULE_ATTR_IIF)
nl_dump_line(p, "RULE_IIF=%s\n", rule->r_iif);
if (rule->ce_mask & RULE_ATTR_TABLE)
nl_dump_line(p, "RULE_TABLE=%u\n", rule->r_table);
if (rule->ce_mask & RULE_ATTR_REALMS)
nl_dump_line(p, "RULE_REALM=%u\n", rule->r_realms);
if (rule->ce_mask & RULE_ATTR_MARK)
nl_dump_line(p, "RULE_MARK=0x%" PRIx64 "\n", rule->r_mark);
if (rule->ce_mask & RULE_ATTR_DSFIELD)
nl_dump_line(p, "RULE_DSFIELD=%u\n", rule->r_dsfield);
if (rule->ce_mask & RULE_ATTR_TYPE)
nl_dump_line(p, "RULE_TYPE=%s\n",
nl_rtntype2str(rule->r_type, buf, sizeof(buf)));
if (rule->ce_mask & RULE_ATTR_SRCMAP)
nl_dump_line(p, "RULE_SRCMAP=%s\n",
nl_addr2str(rule->r_srcmap, buf, sizeof(buf)));
}
static void xfrm_ae_dump_line(struct nl_object *a, struct nl_dump_params *p)
{
char dst[INET6_ADDRSTRLEN+5], src[INET6_ADDRSTRLEN+5];
struct xfrmnl_ae* ae = (struct xfrmnl_ae *) a;
char flags[128], buf[128];
time_t add_time, use_time;
struct tm *add_time_tm, *use_time_tm;
nl_dump_line(p, "src %s dst %s \n", nl_addr2str(ae->saddr, src, sizeof(src)),
nl_addr2str(ae->sa_id.daddr, dst, sizeof(dst)));
nl_dump_line(p, "\tproto %s spi 0x%x reqid %u ",
nl_ip_proto2str (ae->sa_id.proto, buf, sizeof (buf)),
ae->sa_id.spi, ae->reqid);
xfrmnl_ae_flags2str(ae->flags, flags, sizeof (flags));
nl_dump_line(p, "flags %s(0x%x) mark mask/value 0x%x/0x%x \n", flags,
ae->flags, ae->mark.m, ae->mark.v);
nl_dump_line(p, "\tlifetime current: \n");
nl_dump_line(p, "\t\tbytes %llu packets %llu \n", ae->lifetime_cur.bytes,
ae->lifetime_cur.packets);
if (ae->lifetime_cur.add_time != 0)
{
add_time = ae->lifetime_cur.add_time;
add_time_tm = gmtime (&add_time);
strftime (flags, 128, "%Y-%m-%d %H-%M-%S", add_time_tm);
}
else
{
sprintf (flags, "%s", "-");
}
if (ae->lifetime_cur.use_time != 0)
{
use_time = ae->lifetime_cur.use_time;
use_time_tm = gmtime (&use_time);
strftime (buf, 128, "%Y-%m-%d %H-%M-%S", use_time_tm);
}
else
{
sprintf (buf, "%s", "-");
}
nl_dump_line(p, "\t\tadd_time: %s, use_time: %s\n", flags, buf);
nl_dump_line(p, "\treplay info: \n");
nl_dump_line(p, "\t\tmax age %u max diff %u \n", ae->replay_maxage, ae->replay_maxdiff);
nl_dump_line(p, "\treplay state info: \n");
if (ae->replay_state_esn)
{
nl_dump_line(p, "\t\toseq %u seq %u oseq_hi %u seq_hi %u replay window: %u \n",
ae->replay_state_esn->oseq, ae->replay_state_esn->seq,
ae->replay_state_esn->oseq_hi, ae->replay_state_esn->seq_hi,
ae->replay_state_esn->replay_window);
}
else
{
nl_dump_line(p, "\t\toseq %u seq %u bitmap: %u \n", ae->replay_state.oseq,
ae->replay_state.seq, ae->replay_state.bitmap);
}
nl_dump(p, "\n");
}
static void env_dump(struct nl_object *obj, void *arg)
{
struct nl_dump_params *p = arg;
struct rtnl_addr *addr = (struct rtnl_addr *) obj;
struct nl_cache *link_cache;
struct nl_addr *a;
static int index = 0;
char buf[128], pfx[32], *s;
snprintf(pfx, sizeof(pfx), "ADDR%d", index++);
nl_dump_line(p, "%s_FAMILY=%s\n", pfx,
nl_af2str(rtnl_addr_get_family(addr), buf, sizeof(buf)));
nl_dump_line(p, "%s_LOCAL=%s\n", pfx,
nl_addr2str(rtnl_addr_get_local(addr), buf, sizeof(buf)));
nl_dump_line(p, "%s_IFINDEX=%u\n", pfx, rtnl_addr_get_ifindex(addr));
link_cache = nl_cache_mngt_require_safe("route/link");
if (link_cache)
nl_dump_line(p, "%s_IFNAME=%s\n", pfx,
rtnl_link_i2name(link_cache,
rtnl_addr_get_ifindex(addr),
buf, sizeof(buf)));
if ((a = rtnl_addr_get_peer(addr)))
nl_dump_line(p, "%s_PEER=%s\n", pfx,
nl_addr2str(a, buf, sizeof(buf)));
if ((a = rtnl_addr_get_broadcast(addr)))
nl_dump_line(p, "%s_BROADCAST=%s\n", pfx,
nl_addr2str(a, buf, sizeof(buf)));
nl_dump_line(p, "%s_SCOPE=%s\n", pfx,
rtnl_scope2str(rtnl_addr_get_scope(addr),
buf, sizeof(buf)));
if ((s = rtnl_addr_get_label(addr)))
nl_dump_line(p, "%s_LABEL=%s\n", pfx, s);
rtnl_addr_flags2str(rtnl_addr_get_flags(addr), buf, sizeof(buf));
if (buf[0])
nl_dump_line(p, "%s_FLAGS=%s\n", pfx, buf);
nl_dump_line(p, "%s_CACHEINFO_VALID=%u\n", pfx,
rtnl_addr_get_valid_lifetime(addr));
if (link_cache)
nl_cache_put(link_cache);
#if 0
if (addr->ce_mask & ADDR_ATTR_CACHEINFO) {
struct rtnl_addr_cacheinfo *ci = &addr->a_cacheinfo;
nl_dump_line(p, "ADDR_CACHEINFO_PREFERRED=%u\n",
ci->aci_prefered);
nl_dump_line(p, "ADDR_CACHEINFO_CREATED=%u\n", ci->aci_cstamp);
nl_dump_line(p, "ADDR_CACHEINFO_LASTUPDATE=%u\n",
ci->aci_tstamp);
}
#endif
}
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");
}
