static void hsr_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[]) { SPRINT_BUF(b1); if (!tb) return; if (tb[IFLA_HSR_SLAVE1] && RTA_PAYLOAD(tb[IFLA_HSR_SLAVE1]) < sizeof(__u32)) return; if (tb[IFLA_HSR_SLAVE2] && RTA_PAYLOAD(tb[IFLA_HSR_SLAVE2]) < sizeof(__u32)) return; if (tb[IFLA_HSR_SEQ_NR] && RTA_PAYLOAD(tb[IFLA_HSR_SEQ_NR]) < sizeof(__u16)) return; if (tb[IFLA_HSR_SUPERVISION_ADDR] && RTA_PAYLOAD(tb[IFLA_HSR_SUPERVISION_ADDR]) < ETH_ALEN) return; if (tb[IFLA_HSR_SLAVE1]) print_string(PRINT_ANY, "slave1", "slave1 %s ", ll_index_to_name(rta_getattr_u32(tb[IFLA_HSR_SLAVE1]))); else print_null(PRINT_ANY, "slave1", "slave1 %s ", "<none>"); if (tb[IFLA_HSR_SLAVE2]) print_string(PRINT_ANY, "slave2", "slave2 %s ", ll_index_to_name(rta_getattr_u32(tb[IFLA_HSR_SLAVE2]))); else print_null(PRINT_ANY, "slave2", "slave2 %s ", "<none>"); if (tb[IFLA_HSR_SEQ_NR]) print_int(PRINT_ANY, "seq_nr", "sequence %d ", rta_getattr_u16(tb[IFLA_HSR_SEQ_NR])); if (tb[IFLA_HSR_SUPERVISION_ADDR]) print_string(PRINT_ANY, "supervision_addr", "supervision %s ", ll_addr_n2a(RTA_DATA(tb[IFLA_HSR_SUPERVISION_ADDR]), RTA_PAYLOAD(tb[IFLA_HSR_SUPERVISION_ADDR]), ARPHRD_VOID, b1, sizeof(b1))); }
static int rtnl_linkinfo_parse(struct rtattr *rta) { int index = -1; const char *kind; struct rtattr *linkinfo[IFLA_INFO_MAX]; struct rtattr *bond[IFLA_BOND_MAX]; if (rtnl_nested_rtattr_parse(linkinfo, IFLA_INFO_MAX, rta) < 0) return -1; if (linkinfo[IFLA_INFO_KIND]) { kind = rta_getattr_str(linkinfo[IFLA_INFO_KIND]); if (kind && !strncmp(kind, "bond", 4) && linkinfo[IFLA_INFO_DATA]) { if (rtnl_nested_rtattr_parse(bond, IFLA_BOND_MAX, linkinfo[IFLA_INFO_DATA]) < 0) return -1; if (bond[IFLA_BOND_ACTIVE_SLAVE]) { index = rta_getattr_u32(bond[IFLA_BOND_ACTIVE_SLAVE]); } } } return index; }
static int basic_print_opt(struct filter_util *qu, FILE *f, struct rtattr *opt, __u32 handle) { struct rtattr *tb[TCA_BASIC_MAX+1]; if (opt == NULL) return 0; parse_rtattr_nested(tb, TCA_BASIC_MAX, opt); if (handle) fprintf(f, "handle 0x%x ", handle); if (tb[TCA_BASIC_CLASSID]) { SPRINT_BUF(b1); fprintf(f, "flowid %s ", sprint_tc_classid(rta_getattr_u32(tb[TCA_BASIC_CLASSID]), b1)); } if (tb[TCA_BASIC_EMATCHES]) print_ematch(f, tb[TCA_BASIC_EMATCHES]); if (tb[TCA_BASIC_POLICE]) { fprintf(f, "\n"); tc_print_police(f, tb[TCA_BASIC_POLICE]); } if (tb[TCA_BASIC_ACT]) { tc_print_action(f, tb[TCA_BASIC_ACT]); } return 0; }
static inline int rtm_get_table(struct rtmsg *r, struct rtattr **tb) { __u32 table = r->rtm_table; if (tb[RTA_TABLE]) table = rta_getattr_u32(tb[RTA_TABLE]); return table; }
static void bond_slave_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[]) { SPRINT_BUF(b1); if (!tb) return; if (tb[IFLA_BOND_SLAVE_STATE]) print_slave_state(f, tb[IFLA_BOND_SLAVE_STATE]); if (tb[IFLA_BOND_SLAVE_MII_STATUS]) print_slave_mii_status(f, tb[IFLA_BOND_SLAVE_MII_STATUS]); if (tb[IFLA_BOND_SLAVE_LINK_FAILURE_COUNT]) fprintf(f, "link_failure_count %d ", rta_getattr_u32(tb[IFLA_BOND_SLAVE_LINK_FAILURE_COUNT])); if (tb[IFLA_BOND_SLAVE_PERM_HWADDR]) fprintf(f, "perm_hwaddr %s ", ll_addr_n2a(RTA_DATA(tb[IFLA_BOND_SLAVE_PERM_HWADDR]), RTA_PAYLOAD(tb[IFLA_BOND_SLAVE_PERM_HWADDR]), 0, b1, sizeof(b1))); if (tb[IFLA_BOND_SLAVE_QUEUE_ID]) fprintf(f, "queue_id %d ", rta_getattr_u16(tb[IFLA_BOND_SLAVE_QUEUE_ID])); if (tb[IFLA_BOND_SLAVE_AD_AGGREGATOR_ID]) fprintf(f, "ad_aggregator_id %d ", rta_getattr_u16(tb[IFLA_BOND_SLAVE_AD_AGGREGATOR_ID])); }
static int print_ila_mapping(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg) { FILE *fp = (FILE *)arg; struct genlmsghdr *ghdr; struct rtattr *tb[ILA_ATTR_MAX + 1]; int len = n->nlmsg_len; if (n->nlmsg_type != genl_family) return 0; len -= NLMSG_LENGTH(GENL_HDRLEN); if (len < 0) return -1; ghdr = NLMSG_DATA(n); parse_rtattr(tb, ILA_ATTR_MAX, (void *) ghdr + GENL_HDRLEN, len); print_ila_locid(fp, ILA_ATTR_LOCATOR_MATCH, tb, ADDR_BUF_SIZE); print_ila_locid(fp, ILA_ATTR_LOCATOR, tb, ADDR_BUF_SIZE); if (tb[ILA_ATTR_IFINDEX]) fprintf(fp, "%s", ll_index_to_name(rta_getattr_u32(tb[ILA_ATTR_IFINDEX]))); else fprintf(fp, "-"); fprintf(fp, "\n"); return 0; }
static void macvlan_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[]) { __u32 mode; __u16 flags; if (!tb) return; if (!tb[IFLA_MACVLAN_MODE] || RTA_PAYLOAD(tb[IFLA_MACVLAN_MODE]) < sizeof(__u32)) return; mode = rta_getattr_u32(tb[IFLA_MACVLAN_MODE]); fprintf(f, " mode %s ", mode == MACVLAN_MODE_PRIVATE ? "private" : mode == MACVLAN_MODE_VEPA ? "vepa" : mode == MACVLAN_MODE_BRIDGE ? "bridge" : mode == MACVLAN_MODE_PASSTHRU ? "passthru" : "unknown"); if (!tb[IFLA_MACVLAN_FLAGS] || RTA_PAYLOAD(tb[IFLA_MACVLAN_FLAGS]) < sizeof(__u16)) return; flags = rta_getattr_u16(tb[IFLA_MACVLAN_FLAGS]); if (flags & MACVLAN_FLAG_NOPROMISC) fprintf(f, "nopromisc "); }
static int atm_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) { struct rtattr *tb[TCA_ATM_MAX+1]; char buffer[MAX_ATM_ADDR_LEN+1]; if (opt == NULL) return 0; parse_rtattr_nested(tb, TCA_ATM_MAX, opt); if (tb[TCA_ATM_ADDR]) { if (RTA_PAYLOAD(tb[TCA_ATM_ADDR]) < sizeof(struct sockaddr_atmpvc)) fprintf(stderr,"ATM: address too short\n"); else { if (atm2text(buffer,MAX_ATM_ADDR_LEN, RTA_DATA(tb[TCA_ATM_ADDR]),A2T_PRETTY | A2T_NAME) < 0) fprintf(stderr,"atm2text error\n"); fprintf(f,"pvc %s ",buffer); } } if (tb[TCA_ATM_HDR]) { int i; const __u8 *hdr = RTA_DATA(tb[TCA_ATM_HDR]); fprintf(f,"hdr"); for (i = 0; i < RTA_PAYLOAD(tb[TCA_ATM_HDR]); i++) fprintf(f,"%c%02x", i ? '.' : ' ', hdr[i]); if (!i) fprintf(f," ."); fprintf(f," "); } if (tb[TCA_ATM_EXCESS]) { __u32 excess; if (RTA_PAYLOAD(tb[TCA_ATM_EXCESS]) < sizeof(excess)) fprintf(stderr,"ATM: excess class ID too short\n"); else { excess = rta_getattr_u32(tb[TCA_ATM_EXCESS]); if (!excess) fprintf(f,"excess clp "); else { char buf[64]; print_tc_classid(buf,sizeof(buf),excess); fprintf(f,"excess %s ",buf); } } } if (tb[TCA_ATM_STATE]) { static const char *map[] = { ATM_VS2TXT_MAP }; int state; if (RTA_PAYLOAD(tb[TCA_ATM_STATE]) < sizeof(state)) fprintf(stderr,"ATM: state field too short\n"); else { state = *(int *) RTA_DATA(tb[TCA_ATM_STATE]); fprintf(f,"%s ",map[state]); } } return 0; }
static int codel_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) { struct rtattr *tb[TCA_CODEL_MAX + 1]; unsigned int limit; unsigned int interval; unsigned int target; unsigned int ecn; unsigned int ce_threshold; SPRINT_BUF(b1); if (opt == NULL) return 0; parse_rtattr_nested(tb, TCA_CODEL_MAX, opt); if (tb[TCA_CODEL_LIMIT] && RTA_PAYLOAD(tb[TCA_CODEL_LIMIT]) >= sizeof(__u32)) { limit = rta_getattr_u32(tb[TCA_CODEL_LIMIT]); fprintf(f, "limit %up ", limit); } if (tb[TCA_CODEL_TARGET] && RTA_PAYLOAD(tb[TCA_CODEL_TARGET]) >= sizeof(__u32)) { target = rta_getattr_u32(tb[TCA_CODEL_TARGET]); fprintf(f, "target %s ", sprint_time(target, b1)); } if (tb[TCA_CODEL_CE_THRESHOLD] && RTA_PAYLOAD(tb[TCA_CODEL_CE_THRESHOLD]) >= sizeof(__u32)) { ce_threshold = rta_getattr_u32(tb[TCA_CODEL_CE_THRESHOLD]); fprintf(f, "ce_threshold %s ", sprint_time(ce_threshold, b1)); } if (tb[TCA_CODEL_INTERVAL] && RTA_PAYLOAD(tb[TCA_CODEL_INTERVAL]) >= sizeof(__u32)) { interval = rta_getattr_u32(tb[TCA_CODEL_INTERVAL]); fprintf(f, "interval %s ", sprint_time(interval, b1)); } if (tb[TCA_CODEL_ECN] && RTA_PAYLOAD(tb[TCA_CODEL_ECN]) >= sizeof(__u32)) { ecn = rta_getattr_u32(tb[TCA_CODEL_ECN]); if (ecn) fprintf(f, "ecn "); } return 0; }
static int pie_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) { struct rtattr *tb[TCA_PIE_MAX + 1]; unsigned int limit; unsigned int tupdate; unsigned int target; unsigned int alpha; unsigned int beta; unsigned ecn; unsigned bytemode; SPRINT_BUF(b1); if (opt == NULL) return 0; parse_rtattr_nested(tb, TCA_PIE_MAX, opt); if (tb[TCA_PIE_LIMIT] && RTA_PAYLOAD(tb[TCA_PIE_LIMIT]) >= sizeof(__u32)) { limit = rta_getattr_u32(tb[TCA_PIE_LIMIT]); fprintf(f, "limit %up ", limit); } if (tb[TCA_PIE_TARGET] && RTA_PAYLOAD(tb[TCA_PIE_TARGET]) >= sizeof(__u32)) { target = rta_getattr_u32(tb[TCA_PIE_TARGET]); fprintf(f, "target %s ", sprint_time(target, b1)); } if (tb[TCA_PIE_TUPDATE] && RTA_PAYLOAD(tb[TCA_PIE_TUPDATE]) >= sizeof(__u32)) { tupdate = rta_getattr_u32(tb[TCA_PIE_TUPDATE]); fprintf(f, "tupdate %s ", sprint_time(tupdate, b1)); } if (tb[TCA_PIE_ALPHA] && RTA_PAYLOAD(tb[TCA_PIE_ALPHA]) >= sizeof(__u32)) { alpha = rta_getattr_u32(tb[TCA_PIE_ALPHA]); fprintf(f, "alpha %u ", alpha); } if (tb[TCA_PIE_BETA] && RTA_PAYLOAD(tb[TCA_PIE_BETA]) >= sizeof(__u32)) { beta = rta_getattr_u32(tb[TCA_PIE_BETA]); fprintf(f, "beta %u ", beta); } if (tb[TCA_PIE_ECN] && RTA_PAYLOAD(tb[TCA_PIE_ECN]) >= sizeof(__u32)) { ecn = rta_getattr_u32(tb[TCA_PIE_ECN]); if (ecn) fprintf(f, "ecn "); } if (tb[TCA_PIE_BYTEMODE] && RTA_PAYLOAD(tb[TCA_PIE_BYTEMODE]) >= sizeof(__u32)) { bytemode = rta_getattr_u32(tb[TCA_PIE_BYTEMODE]); if (bytemode) fprintf(f, "bytemode "); } return 0; }
static void bridge_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[]) { if (!tb) return; if (tb[IFLA_BR_FORWARD_DELAY]) fprintf(f, "forward_delay %u ", rta_getattr_u32(tb[IFLA_BR_FORWARD_DELAY])); if (tb[IFLA_BR_HELLO_TIME]) fprintf(f, "hello_time %u ", rta_getattr_u32(tb[IFLA_BR_HELLO_TIME])); if (tb[IFLA_BR_MAX_AGE]) fprintf(f, "max_age %u ", rta_getattr_u32(tb[IFLA_BR_MAX_AGE])); if (tb[IFLA_BR_AGEING_TIME]) fprintf(f, "ageing_time %u ", rta_getattr_u32(tb[IFLA_BR_AGEING_TIME])); if (tb[IFLA_BR_STP_STATE]) fprintf(f, "stp_state %u ", rta_getattr_u32(tb[IFLA_BR_STP_STATE])); if (tb[IFLA_BR_PRIORITY]) fprintf(f, "priority %u ", rta_getattr_u16(tb[IFLA_BR_PRIORITY])); if (tb[IFLA_BR_VLAN_FILTERING]) fprintf(f, "vlan_filtering %u ", rta_getattr_u8(tb[IFLA_BR_VLAN_FILTERING])); if (tb[IFLA_BR_VLAN_PROTOCOL]) { SPRINT_BUF(b1); fprintf(f, "vlan_protocol %s ", ll_proto_n2a(rta_getattr_u16(tb[IFLA_BR_VLAN_PROTOCOL]), b1, sizeof(b1))); } }
static int qfq_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) { struct rtattr *tb[TCA_QFQ_MAX + 1]; if (opt == NULL) return 0; parse_rtattr_nested(tb, TCA_QFQ_MAX, opt); if (tb[TCA_QFQ_WEIGHT]) { fprintf(f, "weight %u ", rta_getattr_u32(tb[TCA_QFQ_WEIGHT])); } if (tb[TCA_QFQ_LMAX]) { fprintf(f, "maxpkt %u ", rta_getattr_u32(tb[TCA_QFQ_LMAX])); } return 0; }
int print_police(struct action_util *a, FILE *f, struct rtattr *arg) { SPRINT_BUF(b1); SPRINT_BUF(b2); struct tc_police *p; struct rtattr *tb[TCA_POLICE_MAX+1]; unsigned buffer; unsigned int linklayer; if (arg == NULL) return 0; parse_rtattr_nested(tb, TCA_POLICE_MAX, arg); if (tb[TCA_POLICE_TBF] == NULL) { fprintf(f, "[NULL police tbf]"); return 0; } #ifndef STOOPID_8BYTE if (RTA_PAYLOAD(tb[TCA_POLICE_TBF]) < sizeof(*p)) { fprintf(f, "[truncated police tbf]"); return -1; } #endif p = RTA_DATA(tb[TCA_POLICE_TBF]); fprintf(f, " police 0x%x ", p->index); fprintf(f, "rate %s ", sprint_rate(p->rate.rate, b1)); buffer = tc_calc_xmitsize(p->rate.rate, p->burst); fprintf(f, "burst %s ", sprint_size(buffer, b1)); fprintf(f, "mtu %s ", sprint_size(p->mtu, b1)); if (show_raw) fprintf(f, "[%08x] ", p->burst); if (p->peakrate.rate) fprintf(f, "peakrate %s ", sprint_rate(p->peakrate.rate, b1)); if (tb[TCA_POLICE_AVRATE]) fprintf(f, "avrate %s ", sprint_rate(rta_getattr_u32(tb[TCA_POLICE_AVRATE]), b1)); fprintf(f, "action %s", police_action_n2a(p->action, b1, sizeof(b1))); if (tb[TCA_POLICE_RESULT]) { fprintf(f, "/%s ", police_action_n2a(*(int*)RTA_DATA(tb[TCA_POLICE_RESULT]), b1, sizeof(b1))); } else fprintf(f, " "); fprintf(f, "overhead %ub ", p->rate.overhead); linklayer = (p->rate.linklayer & TC_LINKLAYER_MASK); if (linklayer > TC_LINKLAYER_ETHERNET || show_details) fprintf(f, "linklayer %s ", sprint_linklayer(linklayer, b2)); fprintf(f, "\nref %d bind %d\n",p->refcnt, p->bindcnt); return 0; }
static int fw_print_opt(struct filter_util *qu, FILE *f, struct rtattr *opt, __u32 handle) { struct rtattr *tb[TCA_FW_MAX+1]; if (opt == NULL) return 0; parse_rtattr_nested(tb, TCA_FW_MAX, opt); if (handle || tb[TCA_FW_MASK]) { __u32 mark = 0, mask = 0; if(handle) mark = handle; if(tb[TCA_FW_MASK] && (mask = rta_getattr_u32(tb[TCA_FW_MASK])) != 0xFFFFFFFF) fprintf(f, "handle 0x%x/0x%x ", mark, mask); else fprintf(f, "handle 0x%x ", handle); } if (tb[TCA_FW_CLASSID]) { SPRINT_BUF(b1); fprintf(f, "classid %s ", sprint_tc_classid(rta_getattr_u32(tb[TCA_FW_CLASSID]), b1)); } if (tb[TCA_FW_POLICE]) tc_print_police(f, tb[TCA_FW_POLICE]); if (tb[TCA_FW_INDEV]) { struct rtattr *idev = tb[TCA_FW_INDEV]; fprintf(f, "input dev %s ",rta_getattr_str(idev)); } if (tb[TCA_FW_ACT]) { fprintf(f, "\n"); tc_print_action(f, tb[TCA_FW_ACT]); } return 0; }
static int drr_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) { struct rtattr *tb[TCA_DRR_MAX + 1]; SPRINT_BUF(b1); if (opt == NULL) return 0; parse_rtattr_nested(tb, TCA_DRR_MAX, opt); if (tb[TCA_DRR_QUANTUM]) fprintf(f, "quantum %s ", sprint_size(rta_getattr_u32(tb[TCA_DRR_QUANTUM]), b1)); return 0; }
unsigned int print_name_and_link(const char *fmt, const char *name, struct rtattr *tb[]) { const char *link = NULL; unsigned int m_flag = 0; SPRINT_BUF(b1); if (tb[IFLA_LINK]) { int iflink = rta_getattr_u32(tb[IFLA_LINK]); if (iflink) { if (tb[IFLA_LINK_NETNSID]) { if (is_json_context()) { print_int(PRINT_JSON, "link_index", NULL, iflink); } else { link = ll_idx_n2a(iflink); } } else { link = ll_index_to_name(iflink); if (is_json_context()) { print_string(PRINT_JSON, "link", NULL, link); link = NULL; } m_flag = ll_index_to_flags(iflink); m_flag = !(m_flag & IFF_UP); } } else { if (is_json_context()) print_null(PRINT_JSON, "link", NULL, NULL); else link = "NONE"; } if (link) { snprintf(b1, sizeof(b1), "%s@%s", name, link); name = b1; } } print_color_string(PRINT_ANY, COLOR_IFNAME, "ifname", fmt, name); return m_flag; }
static int bpf_print_opt(struct action_util *au, FILE *f, struct rtattr *arg) { struct rtattr *tb[TCA_ACT_BPF_MAX + 1]; struct tc_act_bpf *parm; SPRINT_BUF(action_buf); if (arg == NULL) return -1; parse_rtattr_nested(tb, TCA_ACT_BPF_MAX, arg); if (!tb[TCA_ACT_BPF_PARMS]) { fprintf(f, "[NULL bpf parameters]"); return -1; } parm = RTA_DATA(tb[TCA_ACT_BPF_PARMS]); fprintf(f, "bpf "); if (tb[TCA_ACT_BPF_NAME]) fprintf(f, "%s ", rta_getattr_str(tb[TCA_ACT_BPF_NAME])); else if (tb[TCA_ACT_BPF_FD]) fprintf(f, "pfd %u ", rta_getattr_u32(tb[TCA_ACT_BPF_FD])); if (tb[TCA_ACT_BPF_OPS] && tb[TCA_ACT_BPF_OPS_LEN]) { bpf_print_ops(f, tb[TCA_ACT_BPF_OPS], rta_getattr_u16(tb[TCA_ACT_BPF_OPS_LEN])); fprintf(f, " "); } fprintf(f, "default-action %s\n", action_n2a(parm->action, action_buf, sizeof(action_buf))); fprintf(f, "\tindex %d ref %d bind %d", parm->index, parm->refcnt, parm->bindcnt); if (show_stats) { if (tb[TCA_ACT_BPF_TM]) { struct tcf_t *tm = RTA_DATA(tb[TCA_ACT_BPF_TM]); print_tm(f, tm); } } fprintf(f, "\n "); return 0; }
static __u64 getattr_u64(struct rtattr *stat) { switch (RTA_PAYLOAD(stat)) { case sizeof(__u64): return rta_getattr_u64(stat); case sizeof(__u32): return rta_getattr_u32(stat); case sizeof(__u16): return rta_getattr_u16(stat); case sizeof(__u8): return rta_getattr_u8(stat); default: fprintf(stderr, "invalid attribute length %lu\n", RTA_PAYLOAD(stat)); exit(-1); } }
static int red_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) { struct rtattr *tb[TCA_NRED_MAX + 1]; struct tc_nred_qopt *qopt; __u32 max_P = 0; SPRINT_BUF(b1); SPRINT_BUF(b2); SPRINT_BUF(b3); //SPRINT_BUF(b4); if (opt == NULL) return 0; parse_rtattr_nested(tb, TCA_NRED_MAX, opt); if (tb[TCA_NRED_PARMS] == NULL) return -1; qopt = RTA_DATA(tb[TCA_NRED_PARMS]); if (RTA_PAYLOAD(tb[TCA_NRED_PARMS]) < sizeof(*qopt)) return -1; if (tb[TCA_NRED_MAX_P] && RTA_PAYLOAD(tb[TCA_NRED_MAX_P]) >= sizeof(__u32)) max_P = rta_getattr_u32(tb[TCA_NRED_MAX_P]); fprintf(f, "limit %s min %s max %s ", sprint_size(qopt->limit, b1), sprint_size(qopt->qth_min, b2), sprint_size(qopt->qth_max, b3)); //sprint_size(qopt->decrement, b4)); if (qopt->flags & TC_RED_ECN) fprintf(f, "ecn "); if (qopt->flags & TC_RED_HARDDROP) fprintf(f, "harddrop "); if (qopt->flags & TC_RED_ADAPTATIVE) fprintf(f, "adaptive "); if (show_details) { fprintf(f, "ewma %u ", qopt->Wlog); if (max_P) fprintf(f, "probability %lg ", max_P / pow(2, 32)); else fprintf(f, "Plog %u ", qopt->Plog); fprintf(f, "Scell_log %u", qopt->Scell_log); } return 0; }
static void print_ila_locid(FILE *fp, int attr, struct rtattr *tb[], int space) { char abuf[256]; size_t blen; int i; if (tb[attr]) { blen = print_addr64(rta_getattr_u32(tb[attr]), abuf, sizeof(abuf)); fprintf(fp, "%s", abuf); } else { fprintf(fp, "-"); blen = 1; } for (i = 0; i < space - blen; i++) fprintf(fp, " "); }
static int get_netnsid_from_name(const char *name) { struct { struct nlmsghdr n; struct rtgenmsg g; char buf[1024]; } req, answer; struct rtattr *tb[NETNSA_MAX + 1]; struct rtgenmsg *rthdr; int len, fd; memset(&req, 0, sizeof(req)); req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtgenmsg)); req.n.nlmsg_flags = NLM_F_REQUEST; req.n.nlmsg_type = RTM_GETNSID; req.g.rtgen_family = AF_UNSPEC; fd = netns_get_fd(name); if (fd < 0) return fd; addattr32(&req.n, 1024, NETNSA_FD, fd); if (rtnl_talk(&rth, &req.n, 0, 0, &answer.n) < 0) { close(fd); return -2; } close(fd); /* Validate message and parse attributes */ if (answer.n.nlmsg_type == NLMSG_ERROR) return -1; rthdr = NLMSG_DATA(&answer.n); len = answer.n.nlmsg_len - NLMSG_SPACE(sizeof(*rthdr)); if (len < 0) return -1; parse_rtattr(tb, NETNSA_MAX, NETNS_RTA(rthdr), len); if (tb[NETNSA_NSID]) return rta_getattr_u32(tb[NETNSA_NSID]); return -1; }
static void macvtap_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[]) { __u32 mode; if (!tb) return; if (!tb[IFLA_MACVLAN_MODE] || RTA_PAYLOAD(tb[IFLA_MACVLAN_MODE]) < sizeof(__u32)) return; mode = rta_getattr_u32(tb[IFLA_VLAN_ID]); fprintf(f, " mode %s ", mode == MACVLAN_MODE_PRIVATE ? "private" : mode == MACVLAN_MODE_VEPA ? "vepa" : mode == MACVLAN_MODE_BRIDGE ? "bridge" : mode == MACVLAN_MODE_PASSTHRU ? "passthru" : "unknown"); }
static void print_tx_sc(const char *prefix, __u64 sci, __u8 encoding_sa, struct rtattr *txsc_stats, struct rtattr *secy_stats, struct rtattr *sa) { struct rtattr *sa_attr[MACSEC_SA_ATTR_MAX + 1]; struct rtattr *a; int rem; print_string(PRINT_FP, NULL, "%s", prefix); print_0xhex(PRINT_ANY, "sci", "TXSC: %016llx", ntohll(sci)); print_uint(PRINT_ANY, "encoding_sa", " on SA %d\n", encoding_sa); print_secy_stats(prefix, secy_stats); print_txsc_stats(prefix, txsc_stats); open_json_array(PRINT_JSON, "sa_list"); rem = RTA_PAYLOAD(sa); for (a = RTA_DATA(sa); RTA_OK(a, rem); a = RTA_NEXT(a, rem)) { bool state; open_json_object(NULL); parse_rtattr_nested(sa_attr, MACSEC_SA_ATTR_MAX + 1, a); state = rta_getattr_u8(sa_attr[MACSEC_SA_ATTR_ACTIVE]); print_string(PRINT_FP, NULL, "%s", prefix); print_string(PRINT_FP, NULL, "%s", prefix); print_uint(PRINT_ANY, "an", "%d:", rta_getattr_u8(sa_attr[MACSEC_SA_ATTR_AN])); print_uint(PRINT_ANY, "pn", " PN %u,", rta_getattr_u32(sa_attr[MACSEC_SA_ATTR_PN])); print_bool(PRINT_JSON, "active", NULL, state); print_string(PRINT_FP, NULL, " state %s,", state ? "on" : "off"); print_key(sa_attr[MACSEC_SA_ATTR_KEYID]); print_txsa_stats(prefix, sa_attr[MACSEC_SA_ATTR_STATS]); close_json_object(); } close_json_array(PRINT_JSON, NULL); }
static void print_rxsc_list(struct rtattr *sc) { int rem = RTA_PAYLOAD(sc); struct rtattr *c; open_json_array(PRINT_JSON, "rx_sc"); for (c = RTA_DATA(sc); RTA_OK(c, rem); c = RTA_NEXT(c, rem)) { struct rtattr *sc_attr[MACSEC_RXSC_ATTR_MAX + 1]; open_json_object(NULL); parse_rtattr_nested(sc_attr, MACSEC_RXSC_ATTR_MAX + 1, c); print_rx_sc(" ", rta_getattr_u64(sc_attr[MACSEC_RXSC_ATTR_SCI]), rta_getattr_u32(sc_attr[MACSEC_RXSC_ATTR_ACTIVE]), sc_attr[MACSEC_RXSC_ATTR_STATS], sc_attr[MACSEC_RXSC_ATTR_SA_LIST]); close_json_object(); } close_json_array(PRINT_JSON, NULL); }
static void print_attrs(struct rtattr *attrs[]) { print_flag(attrs, "protect", MACSEC_SECY_ATTR_PROTECT); if (attrs[MACSEC_SECY_ATTR_VALIDATE]) { __u8 val = rta_getattr_u8(attrs[MACSEC_SECY_ATTR_VALIDATE]); print_string(PRINT_ANY, "validate", "validate %s ", validate_str[val]); } print_flag(attrs, "sc", MACSEC_RXSC_ATTR_ACTIVE); print_flag(attrs, "sa", MACSEC_SA_ATTR_ACTIVE); print_flag(attrs, "encrypt", MACSEC_SECY_ATTR_ENCRYPT); print_flag(attrs, "send_sci", MACSEC_SECY_ATTR_INC_SCI); print_flag(attrs, "end_station", MACSEC_SECY_ATTR_ES); print_flag(attrs, "scb", MACSEC_SECY_ATTR_SCB); print_flag(attrs, "replay", MACSEC_SECY_ATTR_REPLAY); if (attrs[MACSEC_SECY_ATTR_WINDOW]) { __u32 win = rta_getattr_u32(attrs[MACSEC_SECY_ATTR_WINDOW]); print_uint(PRINT_ANY, "window", "window %u ", win); } if (attrs[MACSEC_SECY_ATTR_CIPHER_SUITE]) { __u64 cid = rta_getattr_u64(attrs[MACSEC_SECY_ATTR_CIPHER_SUITE]); print_string(PRINT_FP, NULL, "%s", _SL_); print_string(PRINT_ANY, "cipher_suite", " cipher suite: %s,", cs_id_to_name(cid)); } if (attrs[MACSEC_SECY_ATTR_ICV_LEN]) { __u8 icv_len = rta_getattr_u8(attrs[MACSEC_SECY_ATTR_ICV_LEN]); print_uint(PRINT_ANY, "icv_length", " using ICV length %u\n", icv_len); } }
static int print_object(FILE *fd, struct tcf_meta_val *obj, struct rtattr *rta) { int id = TCF_META_ID(obj->kind); int type = TCF_META_TYPE(obj->kind); struct meta_entry *entry; if (id == TCF_META_ID_VALUE) return print_value(fd, type, rta); entry = lookup_meta_entry_byid(id); if (entry == NULL) fprintf(fd, "[unknown meta id %d]", id); else fprintf(fd, "%s", entry->kind); if (obj->shift) fprintf(fd, " shift %d", obj->shift); switch (type) { case TCF_META_TYPE_INT: if (rta) { if (RTA_PAYLOAD(rta) < sizeof(__u32)) goto size_mismatch; fprintf(fd, " mask 0x%08x", rta_getattr_u32(rta)); } break; } return 0; size_mismatch: fprintf(stderr, "meta int type mask TLV size mismatch\n"); return -1; }
static int choke_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) { struct rtattr *tb[TCA_CHOKE_MAX+1]; const struct tc_red_qopt *qopt; __u32 max_P = 0; if (opt == NULL) return 0; parse_rtattr_nested(tb, TCA_CHOKE_MAX, opt); if (tb[TCA_CHOKE_PARMS] == NULL) return -1; qopt = RTA_DATA(tb[TCA_CHOKE_PARMS]); if (RTA_PAYLOAD(tb[TCA_CHOKE_PARMS]) < sizeof(*qopt)) return -1; if (tb[TCA_CHOKE_MAX_P] && RTA_PAYLOAD(tb[TCA_CHOKE_MAX_P]) >= sizeof(__u32)) max_P = rta_getattr_u32(tb[TCA_CHOKE_MAX_P]); fprintf(f, "limit %up min %up max %up ", qopt->limit, qopt->qth_min, qopt->qth_max); if (qopt->flags & TC_RED_ECN) fprintf(f, "ecn "); if (show_details) { fprintf(f, "ewma %u ", qopt->Wlog); if (max_P) fprintf(f, "probability %g ", max_P / pow(2, 32)); else fprintf(f, "Plog %u ", qopt->Plog); fprintf(f, "Scell_log %u", qopt->Scell_log); } return 0; }
static inline int print_value(FILE *fd, int type, struct rtattr *rta) { if (rta == NULL) { fprintf(stderr, "Missing value TLV\n"); return -1; } switch(type) { case TCF_META_TYPE_INT: if (RTA_PAYLOAD(rta) < sizeof(__u32)) { fprintf(stderr, "meta int type value TLV " \ "size mismatch.\n"); return -1; } fprintf(fd, "%d", rta_getattr_u32(rta)); break; case TCF_META_TYPE_VAR: print_binary(fd, RTA_DATA(rta), RTA_PAYLOAD(rta)); break; } return 0; }
static unsigned int get_ifa_flags(struct ifaddrmsg *ifa, struct rtattr *ifa_flags_attr) { return ifa_flags_attr ? rta_getattr_u32(ifa_flags_attr) : ifa->ifa_flags; }
static int gre_parse_opt(struct link_util *lu, int argc, char **argv, struct nlmsghdr *n) { struct { struct nlmsghdr n; struct ifinfomsg i; char buf[1024]; } req; struct ifinfomsg *ifi = (struct ifinfomsg *)(n + 1); struct rtattr *tb[IFLA_MAX + 1]; struct rtattr *linkinfo[IFLA_INFO_MAX+1]; struct rtattr *greinfo[IFLA_GRE_MAX + 1]; __u16 iflags = 0; __u16 oflags = 0; unsigned ikey = 0; unsigned okey = 0; struct in6_addr raddr = IN6ADDR_ANY_INIT; struct in6_addr laddr = IN6ADDR_ANY_INIT; unsigned link = 0; unsigned flowinfo = 0; unsigned flags = 0; __u8 hop_limit = DEFAULT_TNL_HOP_LIMIT; __u8 encap_limit = IPV6_DEFAULT_TNL_ENCAP_LIMIT; int len; if (!(n->nlmsg_flags & NLM_F_CREATE)) { memset(&req, 0, sizeof(req)); req.n.nlmsg_len = NLMSG_LENGTH(sizeof(*ifi)); req.n.nlmsg_flags = NLM_F_REQUEST; req.n.nlmsg_type = RTM_GETLINK; req.i.ifi_family = preferred_family; req.i.ifi_index = ifi->ifi_index; if (rtnl_talk(&rth, &req.n, 0, 0, &req.n) < 0) { get_failed: fprintf(stderr, "Failed to get existing tunnel info.\n"); return -1; } len = req.n.nlmsg_len; len -= NLMSG_LENGTH(sizeof(*ifi)); if (len < 0) goto get_failed; parse_rtattr(tb, IFLA_MAX, IFLA_RTA(&req.i), len); if (!tb[IFLA_LINKINFO]) goto get_failed; parse_rtattr_nested(linkinfo, IFLA_INFO_MAX, tb[IFLA_LINKINFO]); if (!linkinfo[IFLA_INFO_DATA]) goto get_failed; parse_rtattr_nested(greinfo, IFLA_GRE_MAX, linkinfo[IFLA_INFO_DATA]); if (greinfo[IFLA_GRE_IKEY]) ikey = rta_getattr_u32(greinfo[IFLA_GRE_IKEY]); if (greinfo[IFLA_GRE_OKEY]) okey = rta_getattr_u32(greinfo[IFLA_GRE_OKEY]); if (greinfo[IFLA_GRE_IFLAGS]) iflags = rta_getattr_u16(greinfo[IFLA_GRE_IFLAGS]); if (greinfo[IFLA_GRE_OFLAGS]) oflags = rta_getattr_u16(greinfo[IFLA_GRE_OFLAGS]); if (greinfo[IFLA_GRE_LOCAL]) memcpy(&laddr, RTA_DATA(greinfo[IFLA_GRE_LOCAL]), sizeof(laddr)); if (greinfo[IFLA_GRE_REMOTE]) memcpy(&raddr, RTA_DATA(greinfo[IFLA_GRE_REMOTE]), sizeof(raddr)); if (greinfo[IFLA_GRE_TTL]) hop_limit = rta_getattr_u8(greinfo[IFLA_GRE_TTL]); if (greinfo[IFLA_GRE_LINK]) link = rta_getattr_u32(greinfo[IFLA_GRE_LINK]); if (greinfo[IFLA_GRE_ENCAP_LIMIT]) encap_limit = rta_getattr_u8(greinfo[IFLA_GRE_ENCAP_LIMIT]); if (greinfo[IFLA_GRE_FLOWINFO]) flowinfo = rta_getattr_u32(greinfo[IFLA_GRE_FLOWINFO]); if (greinfo[IFLA_GRE_FLAGS]) flags = rta_getattr_u32(greinfo[IFLA_GRE_FLAGS]); } while (argc > 0) { if (!matches(*argv, "key")) { unsigned uval; NEXT_ARG(); iflags |= GRE_KEY; oflags |= GRE_KEY; if (strchr(*argv, '.')) uval = get_addr32(*argv); else { if (get_unsigned(&uval, *argv, 0) < 0) { fprintf(stderr, "Invalid value for \"key\"\n"); exit(-1); } uval = htonl(uval); } ikey = okey = uval; } else if (!matches(*argv, "ikey")) { unsigned uval; NEXT_ARG(); iflags |= GRE_KEY; if (strchr(*argv, '.')) uval = get_addr32(*argv); else { if (get_unsigned(&uval, *argv, 0)<0) { fprintf(stderr, "invalid value of \"ikey\"\n"); exit(-1); } uval = htonl(uval); } ikey = uval; } else if (!matches(*argv, "okey")) { unsigned uval; NEXT_ARG(); oflags |= GRE_KEY; if (strchr(*argv, '.')) uval = get_addr32(*argv); else { if (get_unsigned(&uval, *argv, 0)<0) { fprintf(stderr, "invalid value of \"okey\"\n"); exit(-1); } uval = htonl(uval); } okey = uval; } else if (!matches(*argv, "seq")) { iflags |= GRE_SEQ; oflags |= GRE_SEQ; } else if (!matches(*argv, "iseq")) { iflags |= GRE_SEQ; } else if (!matches(*argv, "oseq")) { oflags |= GRE_SEQ; } else if (!matches(*argv, "csum")) { iflags |= GRE_CSUM; oflags |= GRE_CSUM; } else if (!matches(*argv, "icsum")) { iflags |= GRE_CSUM; } else if (!matches(*argv, "ocsum")) { oflags |= GRE_CSUM; } else if (!matches(*argv, "remote")) { inet_prefix addr; NEXT_ARG(); get_prefix(&addr, *argv, preferred_family); if (addr.family == AF_UNSPEC) invarg("\"remote\" address family is AF_UNSPEC", *argv); memcpy(&raddr, &addr.data, sizeof(raddr)); } else if (!matches(*argv, "local")) { inet_prefix addr; NEXT_ARG(); get_prefix(&addr, *argv, preferred_family); if (addr.family == AF_UNSPEC) invarg("\"local\" address family is AF_UNSPEC", *argv); memcpy(&laddr, &addr.data, sizeof(laddr)); } else if (!matches(*argv, "dev")) { NEXT_ARG(); link = if_nametoindex(*argv); if (link == 0) { fprintf(stderr, "Cannot find device \"%s\"\n", *argv); exit(-1); } } else if (!matches(*argv, "ttl") || !matches(*argv, "hoplimit")) { __u8 uval; NEXT_ARG(); if (get_u8(&uval, *argv, 0)) invarg("invalid TTL", *argv); hop_limit = uval; } else if (!matches(*argv, "tos") || !matches(*argv, "tclass") || !matches(*argv, "dsfield")) { __u8 uval; NEXT_ARG(); if (strcmp(*argv, "inherit") == 0) flags |= IP6_TNL_F_USE_ORIG_TCLASS; else { if (get_u8(&uval, *argv, 16)) invarg("invalid TClass", *argv); flowinfo |= htonl((__u32)uval << 20) & IP6_FLOWINFO_TCLASS; flags &= ~IP6_TNL_F_USE_ORIG_TCLASS; } } else if (strcmp(*argv, "flowlabel") == 0 || strcmp(*argv, "fl") == 0) { __u32 uval; NEXT_ARG(); if (strcmp(*argv, "inherit") == 0) flags |= IP6_TNL_F_USE_ORIG_FLOWLABEL; else { if (get_u32(&uval, *argv, 16)) invarg("invalid Flowlabel", *argv); if (uval > 0xFFFFF) invarg("invalid Flowlabel", *argv); flowinfo |= htonl(uval) & IP6_FLOWINFO_FLOWLABEL; flags &= ~IP6_TNL_F_USE_ORIG_FLOWLABEL; } } else if (strcmp(*argv, "dscp") == 0) { NEXT_ARG(); if (strcmp(*argv, "inherit") != 0) invarg("not inherit", *argv); flags |= IP6_TNL_F_RCV_DSCP_COPY; } else usage(); argc--; argv++; } addattr32(n, 1024, IFLA_GRE_IKEY, ikey); addattr32(n, 1024, IFLA_GRE_OKEY, okey); addattr_l(n, 1024, IFLA_GRE_IFLAGS, &iflags, 2); addattr_l(n, 1024, IFLA_GRE_OFLAGS, &oflags, 2); addattr_l(n, 1024, IFLA_GRE_LOCAL, &laddr, sizeof(laddr)); addattr_l(n, 1024, IFLA_GRE_REMOTE, &raddr, sizeof(raddr)); if (link) addattr32(n, 1024, IFLA_GRE_LINK, link); addattr_l(n, 1024, IFLA_GRE_TTL, &hop_limit, 1); addattr_l(n, 1024, IFLA_GRE_ENCAP_LIMIT, &encap_limit, 1); addattr_l(n, 1024, IFLA_GRE_FLOWINFO, &flowinfo, 4); addattr_l(n, 1024, IFLA_GRE_FLAGS, &flowinfo, 4); return 0; }