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"); }