21 #include <netlink-private/netlink.h> 22 #include <netlink/netlink.h> 23 #include <netlink/attr.h> 24 #include <netlink/utils.h> 25 #include <netlink/object.h> 26 #include <netlink/hashtable.h> 27 #include <netlink/data.h> 28 #include <netlink/route/rtnl.h> 29 #include <netlink/route/link.h> 30 #include <netlink-private/route/link/api.h> 33 #define LINK_ATTR_MTU (1 << 0) 34 #define LINK_ATTR_LINK (1 << 1) 35 #define LINK_ATTR_TXQLEN (1 << 2) 36 #define LINK_ATTR_WEIGHT (1 << 3) 37 #define LINK_ATTR_MASTER (1 << 4) 38 #define LINK_ATTR_QDISC (1 << 5) 39 #define LINK_ATTR_MAP (1 << 6) 40 #define LINK_ATTR_ADDR (1 << 7) 41 #define LINK_ATTR_BRD (1 << 8) 42 #define LINK_ATTR_FLAGS (1 << 9) 43 #define LINK_ATTR_IFNAME (1 << 10) 44 #define LINK_ATTR_IFINDEX (1 << 11) 45 #define LINK_ATTR_FAMILY (1 << 12) 46 #define LINK_ATTR_ARPTYPE (1 << 13) 47 #define LINK_ATTR_STATS (1 << 14) 48 #define LINK_ATTR_CHANGE (1 << 15) 49 #define LINK_ATTR_OPERSTATE (1 << 16) 50 #define LINK_ATTR_LINKMODE (1 << 17) 51 #define LINK_ATTR_LINKINFO (1 << 18) 52 #define LINK_ATTR_IFALIAS (1 << 19) 53 #define LINK_ATTR_NUM_VF (1 << 20) 54 #define LINK_ATTR_PROMISCUITY (1 << 21) 55 #define LINK_ATTR_NUM_TX_QUEUES (1 << 22) 56 #define LINK_ATTR_NUM_RX_QUEUES (1 << 23) 57 #define LINK_ATTR_GROUP (1 << 24) 58 #define LINK_ATTR_CARRIER (1 << 25) 59 #define LINK_ATTR_PROTINFO (1 << 26) 60 #define LINK_ATTR_AF_SPEC (1 << 27) 61 #define LINK_ATTR_PHYS_PORT_ID (1 << 28) 62 #define LINK_ATTR_NS_FD (1 << 29) 63 #define LINK_ATTR_NS_PID (1 << 30) 65 #define LINK_ATTR_LINK_NETNSID ((uint64_t) 1 << 32) 67 static struct nl_cache_ops rtnl_link_ops;
68 static struct nl_object_ops link_obj_ops;
71 struct rtnl_link *link_lookup(
struct nl_cache *cache,
int ifindex)
74 cache = __nl_cache_mngt_require(
"route/link");
82 static struct rtnl_link_af_ops *af_lookup_and_alloc(
struct rtnl_link *link,
85 struct rtnl_link_af_ops *af_ops;
100 static int af_free(
struct rtnl_link *link,
struct rtnl_link_af_ops *ops,
101 void *data,
void *arg)
104 ops->ao_free(link, data);
111 static int af_clone(
struct rtnl_link *link,
struct rtnl_link_af_ops *ops,
112 void *data,
void *arg)
117 !(dst->l_af_data[ops->ao_family] = ops->ao_clone(dst, data)))
123 static int af_fill(
struct rtnl_link *link,
struct rtnl_link_af_ops *ops,
124 void *data,
void *arg)
126 struct nl_msg *msg = arg;
127 struct nlattr *af_attr;
130 if (!ops->ao_fill_af)
136 if ((err = ops->ao_fill_af(link, arg, data)) < 0)
144 static int af_dump_line(
struct rtnl_link *link,
struct rtnl_link_af_ops *ops,
145 void *data,
void *arg)
155 static int af_dump_details(
struct rtnl_link *link,
struct rtnl_link_af_ops *ops,
156 void *data,
void *arg)
166 static int af_dump_stats(
struct rtnl_link *link,
struct rtnl_link_af_ops *ops,
167 void *data,
void *arg)
177 static int do_foreach_af(
struct rtnl_link *link,
179 struct rtnl_link_af_ops *,
void *,
void *),
184 for (i = 0; i < AF_MAX; i++) {
185 if (link->l_af_data[i]) {
186 struct rtnl_link_af_ops *ops;
191 err = cb(link, ops, link->l_af_data[i], arg);
203 static void release_link_info(
struct rtnl_link *link)
205 struct rtnl_link_info_ops *io = link->l_info_ops;
212 BUG_ON(link->l_info);
215 link->l_info_ops = NULL;
219 static void link_free_data(
struct nl_object *c)
221 struct rtnl_link *link = nl_object_priv(c);
224 release_link_info(link);
232 free(link->l_ifalias);
233 free(link->l_info_kind);
235 do_foreach_af(link, af_free, NULL);
241 static int link_clone(
struct nl_object *_dst,
struct nl_object *_src)
243 struct rtnl_link *dst = nl_object_priv(_dst);
244 struct rtnl_link *src = nl_object_priv(_src);
256 if (!(dst->l_ifalias = strdup(src->l_ifalias)))
259 if (src->l_info_kind)
260 if (!(dst->l_info_kind = strdup(src->l_info_kind)))
263 if (src->l_info_ops && src->l_info_ops->io_clone) {
264 err = src->l_info_ops->io_clone(dst, src);
269 if ((err = do_foreach_af(src, af_clone, dst)) < 0)
272 if (src->l_phys_port_id)
273 if (!(dst->l_phys_port_id =
nl_data_clone(src->l_phys_port_id)))
279 struct nla_policy rtln_link_policy[IFLA_MAX+1] = {
281 .maxlen = IFNAMSIZ },
282 [IFLA_MTU] = { .type =
NLA_U32 },
283 [IFLA_TXQLEN] = { .type =
NLA_U32 },
284 [IFLA_LINK] = { .type =
NLA_U32 },
285 [IFLA_WEIGHT] = { .type =
NLA_U32 },
286 [IFLA_MASTER] = { .type =
NLA_U32 },
287 [IFLA_OPERSTATE] = { .type =
NLA_U8 },
288 [IFLA_LINKMODE] = { .type =
NLA_U8 },
291 .maxlen = IFQDISCSIZ },
292 [IFLA_STATS] = { .minlen =
sizeof(
struct rtnl_link_stats) },
293 [IFLA_STATS64] = { .minlen =
sizeof(
struct rtnl_link_stats64)},
294 [IFLA_MAP] = { .minlen =
sizeof(
struct rtnl_link_ifmap) },
295 [IFLA_IFALIAS] = { .type =
NLA_STRING, .maxlen = IFALIASZ },
296 [IFLA_NUM_VF] = { .type =
NLA_U32 },
298 [IFLA_PROMISCUITY] = { .type =
NLA_U32 },
299 [IFLA_NUM_TX_QUEUES] = { .type =
NLA_U32 },
300 [IFLA_NUM_RX_QUEUES] = { .type =
NLA_U32 },
301 [IFLA_GROUP] = { .type =
NLA_U32 },
302 [IFLA_CARRIER] = { .type =
NLA_U8 },
304 [IFLA_NET_NS_PID] = { .type =
NLA_U32 },
305 [IFLA_NET_NS_FD] = { .type =
NLA_U32 },
308 static struct nla_policy link_info_policy[IFLA_INFO_MAX+1] = {
314 int rtnl_link_info_parse(
struct rtnl_link *link,
struct nlattr **tb)
316 if (tb[IFLA_IFNAME] == NULL)
317 return -NLE_MISSING_ATTR;
319 nla_strlcpy(link->l_name, tb[IFLA_IFNAME], IFNAMSIZ);
322 if (tb[IFLA_STATS]) {
323 struct rtnl_link_stats *st =
nla_data(tb[IFLA_STATS]);
352 link->ce_mask |= LINK_ATTR_STATS;
355 if (tb[IFLA_STATS64]) {
363 struct rtnl_link_stats64 st;
366 sizeof(
struct rtnl_link_stats64));
395 link->ce_mask |= LINK_ATTR_STATS;
398 if (tb[IFLA_TXQLEN]) {
400 link->ce_mask |= LINK_ATTR_TXQLEN;
405 link->ce_mask |= LINK_ATTR_MTU;
408 if (tb[IFLA_ADDRESS]) {
410 if (link->l_addr == NULL)
414 link->ce_mask |= LINK_ATTR_ADDR;
417 if (tb[IFLA_BROADCAST]) {
420 if (link->l_bcast == NULL)
424 link->ce_mask |= LINK_ATTR_BRD;
429 link->ce_mask |= LINK_ATTR_LINK;
432 if (tb[IFLA_LINK_NETNSID]) {
433 link->l_link_netnsid =
nla_get_s32(tb[IFLA_LINK_NETNSID]);
434 link->ce_mask |= LINK_ATTR_LINK_NETNSID;
437 if (tb[IFLA_WEIGHT]) {
439 link->ce_mask |= LINK_ATTR_WEIGHT;
442 if (tb[IFLA_QDISC]) {
443 nla_strlcpy(link->l_qdisc, tb[IFLA_QDISC], IFQDISCSIZ);
444 link->ce_mask |= LINK_ATTR_QDISC;
449 sizeof(
struct rtnl_link_ifmap));
450 link->ce_mask |= LINK_ATTR_MAP;
453 if (tb[IFLA_MASTER]) {
455 link->ce_mask |= LINK_ATTR_MASTER;
458 if (tb[IFLA_CARRIER]) {
459 link->l_carrier =
nla_get_u8(tb[IFLA_CARRIER]);
460 link->ce_mask |= LINK_ATTR_CARRIER;
463 if (tb[IFLA_OPERSTATE]) {
464 link->l_operstate =
nla_get_u8(tb[IFLA_OPERSTATE]);
465 link->ce_mask |= LINK_ATTR_OPERSTATE;
468 if (tb[IFLA_LINKMODE]) {
469 link->l_linkmode =
nla_get_u8(tb[IFLA_LINKMODE]);
470 link->ce_mask |= LINK_ATTR_LINKMODE;
473 if (tb[IFLA_IFALIAS]) {
474 link->l_ifalias = nla_strdup(tb[IFLA_IFALIAS]);
475 if (link->l_ifalias == NULL)
477 link->ce_mask |= LINK_ATTR_IFALIAS;
480 if (tb[IFLA_NET_NS_FD]) {
482 link->ce_mask |= LINK_ATTR_NS_FD;
485 if (tb[IFLA_NET_NS_PID]) {
487 link->ce_mask |= LINK_ATTR_NS_PID;
493 static int link_msg_parser(
struct nl_cache_ops *ops,
struct sockaddr_nl *who,
494 struct nlmsghdr *n,
struct nl_parser_param *pp)
497 struct ifinfomsg *ifi;
498 struct nlattr *tb[IFLA_MAX+1];
499 struct rtnl_link_af_ops *af_ops = NULL;
500 struct rtnl_link_af_ops *af_ops_family;
502 struct nla_policy real_link_policy[IFLA_MAX+1];
504 memcpy(&real_link_policy, rtln_link_policy,
sizeof(rtln_link_policy));
512 link->ce_msgtype = n->nlmsg_type;
514 if (!nlmsg_valid_hdr(n,
sizeof(*ifi))) {
515 err = -NLE_MSG_TOOSHORT;
520 link->l_family = family = ifi->ifi_family;
521 link->l_arptype = ifi->ifi_type;
522 link->l_index = ifi->ifi_index;
523 link->l_flags = ifi->ifi_flags;
524 link->l_change = ifi->ifi_change;
525 link->ce_mask = (LINK_ATTR_IFNAME | LINK_ATTR_FAMILY |
526 LINK_ATTR_ARPTYPE| LINK_ATTR_IFINDEX |
527 LINK_ATTR_FLAGS | LINK_ATTR_CHANGE);
529 if ((af_ops_family = af_ops = af_lookup_and_alloc(link, family))) {
530 if (af_ops->ao_protinfo_policy) {
531 memcpy(&real_link_policy[IFLA_PROTINFO],
532 af_ops->ao_protinfo_policy,
536 link->l_af_ops = af_ops;
539 err =
nlmsg_parse(n,
sizeof(*ifi), tb, IFLA_MAX, real_link_policy);
543 err = rtnl_link_info_parse(link, tb);
547 if (tb[IFLA_NUM_VF]) {
549 link->ce_mask |= LINK_ATTR_NUM_VF;
552 if (tb[IFLA_LINKINFO]) {
553 struct nlattr *li[IFLA_INFO_MAX+1];
560 if (li[IFLA_INFO_KIND]) {
561 struct rtnl_link_info_ops *ops;
569 if ((af = nl_str2af(kind)) >= 0 &&
570 !af_ops && (af_ops = af_lookup_and_alloc(link, af))) {
572 if (af_ops->ao_protinfo_policy) {
573 tb[IFLA_PROTINFO] = (
struct nlattr *)af_ops->ao_protinfo_policy;
576 link->l_af_ops = af_ops;
580 link->l_info_ops = ops;
584 (li[IFLA_INFO_DATA] || li[IFLA_INFO_XSTATS])) {
585 err = ops->io_parse(link, li[IFLA_INFO_DATA],
586 li[IFLA_INFO_XSTATS]);
594 link->ce_mask |= LINK_ATTR_LINKINFO;
597 if (tb[IFLA_PROTINFO] && af_ops && af_ops->ao_parse_protinfo) {
598 err = af_ops->ao_parse_protinfo(link, tb[IFLA_PROTINFO],
599 link->l_af_data[link->l_family]);
602 link->ce_mask |= LINK_ATTR_PROTINFO;
605 if (tb[IFLA_AF_SPEC]) {
609 if (af_ops_family && af_ops_family->ao_parse_af_full) {
610 err = af_ops_family->ao_parse_af_full(link,
612 link->l_af_data[af_ops_family->ao_family]);
615 link->ce_mask |= LINK_ATTR_AF_SPEC;
616 }
else if (family == AF_UNSPEC) {
617 struct nlattr *af_attr;
621 af_ops = af_lookup_and_alloc(link,
nla_type(af_attr));
622 if (af_ops && af_ops->ao_parse_af) {
623 char *af_data = link->l_af_data[
nla_type(af_attr)];
625 err = af_ops->ao_parse_af(link, af_attr, af_data);
630 link->ce_mask |= LINK_ATTR_AF_SPEC;
632 NL_DBG(3,
"IFLA_AF_SPEC parsing not implemented for family %d\n",
637 if (tb[IFLA_PROMISCUITY]) {
638 link->l_promiscuity =
nla_get_u32(tb[IFLA_PROMISCUITY]);
639 link->ce_mask |= LINK_ATTR_PROMISCUITY;
642 if (tb[IFLA_NUM_TX_QUEUES]) {
643 link->l_num_tx_queues =
nla_get_u32(tb[IFLA_NUM_TX_QUEUES]);
644 link->ce_mask |= LINK_ATTR_NUM_TX_QUEUES;
647 if (tb[IFLA_NUM_RX_QUEUES]) {
648 link->l_num_rx_queues =
nla_get_u32(tb[IFLA_NUM_RX_QUEUES]);
649 link->ce_mask |= LINK_ATTR_NUM_RX_QUEUES;
652 if (tb[IFLA_GROUP]) {
654 link->ce_mask |= LINK_ATTR_GROUP;
657 if (tb[IFLA_PHYS_PORT_ID]) {
659 if (link->l_phys_port_id == NULL) {
663 link->ce_mask |= LINK_ATTR_PHYS_PORT_ID;
666 err = pp->pp_cb((
struct nl_object *) link, pp);
673 static int link_request_update(
struct nl_cache *cache,
struct nl_sock *sk)
675 int family = cache->c_iarg1;
676 struct ifinfomsg hdr = { .ifi_family = family };
677 struct rtnl_link_af_ops *ops;
680 __u32 ext_filter_mask = RTEXT_FILTER_VF;
687 if (
nlmsg_append(msg, &hdr,
sizeof(hdr), NLMSG_ALIGNTO) < 0)
688 goto nla_put_failure;
691 if (ops && ops->ao_get_af) {
692 err = ops->ao_get_af(msg, &ext_filter_mask);
694 goto nla_put_failure;
697 if (ext_filter_mask) {
698 err =
nla_put(msg, IFLA_EXT_MASK,
sizeof(ext_filter_mask), &ext_filter_mask);
700 goto nla_put_failure;
712 static void link_dump_line(
struct nl_object *obj,
struct nl_dump_params *p)
715 struct nl_cache *cache = obj->ce_cache;
717 int fetched_cache = 0;
724 nl_dump_line(p,
"%s %s ", link->l_name,
725 nl_llproto2str(link->l_arptype, buf,
sizeof(buf)));
730 if (link->ce_mask & LINK_ATTR_MASTER) {
733 nl_dump(p,
"master %s ", master ? master->l_name :
"inv");
737 nl_dump(p,
"master %d ", link->l_master);
740 rtnl_link_flags2str(link->l_flags, buf,
sizeof(buf));
744 if (link->ce_mask & LINK_ATTR_LINK) {
746 && !(link->ce_mask & LINK_ATTR_LINK_NETNSID)) {
748 nl_dump(p,
"slave-of %s ", ll ? ll->l_name :
"NONE");
752 nl_dump(p,
"slave-of %d ", link->l_link);
754 if (link->ce_mask & LINK_ATTR_LINK_NETNSID)
755 nl_dump(p,
"link-netnsid %d ", link->l_link_netnsid);
757 if (link->ce_mask & LINK_ATTR_GROUP)
758 nl_dump(p,
"group %u ", link->l_group);
760 if (link->l_info_ops && link->l_info_ops->io_dump[
NL_DUMP_LINE])
763 do_foreach_af(link, af_dump_line, p);
771 static void link_dump_details(
struct nl_object *obj,
struct nl_dump_params *p)
776 link_dump_line(obj, p);
778 nl_dump_line(p,
" mtu %u ", link->l_mtu);
779 nl_dump(p,
"txqlen %u weight %u ", link->l_txqlen, link->l_weight);
781 if (link->ce_mask & LINK_ATTR_QDISC)
782 nl_dump(p,
"qdisc %s ", link->l_qdisc);
784 if (link->ce_mask & LINK_ATTR_MAP && link->l_map.lm_irq)
785 nl_dump(p,
"irq %u ", link->l_map.lm_irq);
787 if (link->ce_mask & LINK_ATTR_IFINDEX)
788 nl_dump(p,
"index %u ", link->l_index);
790 if (link->ce_mask & LINK_ATTR_PROMISCUITY && link->l_promiscuity > 0)
791 nl_dump(p,
"promisc-mode (%u users) ", link->l_promiscuity);
795 if (link->ce_mask & LINK_ATTR_IFALIAS)
796 nl_dump_line(p,
" alias %s\n", link->l_ifalias);
798 nl_dump_line(p,
" ");
800 if (link->ce_mask & LINK_ATTR_NUM_TX_QUEUES)
801 nl_dump(p,
"txq %u ", link->l_num_tx_queues);
803 if (link->ce_mask & LINK_ATTR_NUM_RX_QUEUES)
804 nl_dump(p,
"rxq %u ", link->l_num_rx_queues);
806 if (link->ce_mask & LINK_ATTR_BRD)
810 if ((link->ce_mask & LINK_ATTR_OPERSTATE) &&
811 link->l_operstate != IF_OPER_UNKNOWN) {
812 rtnl_link_operstate2str(link->l_operstate, buf,
sizeof(buf));
816 if (link->ce_mask & LINK_ATTR_NUM_VF)
817 nl_dump(p,
"num-vf %u ", link->l_num_vf);
820 rtnl_link_mode2str(link->l_linkmode, buf,
sizeof(buf)));
823 rtnl_link_carrier2str(link->l_carrier, buf,
sizeof(buf)));
830 do_foreach_af(link, af_dump_details, p);
833 static void link_dump_stats(
struct nl_object *obj,
struct nl_dump_params *p)
839 link_dump_details(obj, p);
841 nl_dump_line(p,
" Stats: bytes packets errors " 842 " dropped fifo-err compressed\n");
846 strcpy(fmt,
" RX %X.2f %s %10" PRIu64
" %10" PRIu64
" %10" PRIu64
" %10" PRIu64
" %10" PRIu64
"\n");
847 fmt[9] = *unit ==
'B' ?
'9' :
'7';
849 nl_dump_line(p, fmt, res, unit,
858 strcpy(fmt,
" TX %X.2f %s %10" PRIu64
" %10" PRIu64
" %10" PRIu64
" %10" PRIu64
" %10" PRIu64
"\n");
859 fmt[9] = *unit ==
'B' ?
'9' :
'7';
861 nl_dump_line(p, fmt, res, unit,
868 nl_dump_line(p,
" Errors: length over crc " 869 " frame missed multicast\n");
871 nl_dump_line(p,
" RX %10" PRIu64
" %10" PRIu64
" %10" 872 PRIu64
" %10" PRIu64
" %10" PRIu64
" %10" 881 nl_dump_line(p,
" aborted carrier heartbeat " 882 " window collision\n");
884 nl_dump_line(p,
" TX %10" PRIu64
" %10" PRIu64
" %10" 885 PRIu64
" %10" PRIu64
" %10" PRIu64
"\n",
892 if (link->l_info_ops && link->l_info_ops->io_dump[
NL_DUMP_STATS])
895 do_foreach_af(link, af_dump_stats, p);
899 static int link_handle_event(
struct nl_object *a,
struct rtnl_link_event_cb *cb)
902 struct nl_cache *c = dp_cache(a);
905 if (l->l_change == ~0U) {
906 if (l->ce_msgtype == RTM_NEWLINK)
909 cb->le_unregister(l);
914 if (l->l_change & IFF_SLAVE) {
915 if (l->l_flags & IFF_SLAVE) {
917 cb->le_new_bonding(l, m);
921 cb->le_cancel_bonding(l);
925 if (l->l_change & IFF_UP && l->l_change & IFF_RUNNING)
926 dp_dump_line(p, line++,
"link %s changed state to %s.\n",
927 l->l_name, l->l_flags & IFF_UP ?
"up" :
"down");
929 if (l->l_change & IFF_PROMISC) {
930 dp_new_line(p, line++);
931 dp_dump(p,
"link %s %s promiscuous mode.\n",
932 l->l_name, l->l_flags & IFF_PROMISC ?
"entered" :
"left");
936 dp_dump_line(p, line++,
"link %s sent unknown event.\n",
945 static void link_keygen(
struct nl_object *obj, uint32_t *hashkey,
949 unsigned int lkey_sz;
950 struct link_hash_key {
953 } __attribute__((packed)) lkey;
955 lkey_sz = sizeof(lkey);
956 lkey.l_index = link->l_index;
957 lkey.l_family = link->l_family;
959 *hashkey = nl_hash(&lkey, lkey_sz, 0) % table_sz;
961 NL_DBG(5, "link %p key (dev %d fam %d) keysz %d, hash 0x%x\n",
962 link, lkey.l_index, lkey.l_family, lkey_sz, *hashkey);
967 static uint64_t link_compare(struct nl_object *_a, struct nl_object *_b,
968 uint64_t attrs,
int flags)
974 #define LINK_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, LINK_ATTR_##ATTR, a, b, EXPR) 976 diff |= LINK_DIFF(IFINDEX, a->l_index != b->l_index);
977 diff |= LINK_DIFF(MTU, a->l_mtu != b->l_mtu);
978 diff |= LINK_DIFF(LINK, a->l_link != b->l_link);
979 diff |= LINK_DIFF(LINK_NETNSID, a->l_link_netnsid != b->l_link_netnsid);
980 diff |= LINK_DIFF(TXQLEN, a->l_txqlen != b->l_txqlen);
981 diff |= LINK_DIFF(WEIGHT, a->l_weight != b->l_weight);
982 diff |= LINK_DIFF(MASTER, a->l_master != b->l_master);
983 diff |= LINK_DIFF(FAMILY, a->l_family != b->l_family);
984 diff |= LINK_DIFF(OPERSTATE, a->l_operstate != b->l_operstate);
985 diff |= LINK_DIFF(LINKMODE, a->l_linkmode != b->l_linkmode);
986 diff |= LINK_DIFF(QDISC, strcmp(a->l_qdisc, b->l_qdisc));
987 diff |= LINK_DIFF(IFNAME, strcmp(a->l_name, b->l_name));
988 diff |= LINK_DIFF(ADDR,
nl_addr_cmp(a->l_addr, b->l_addr));
989 diff |= LINK_DIFF(BRD,
nl_addr_cmp(a->l_bcast, b->l_bcast));
990 diff |= LINK_DIFF(IFALIAS, strcmp(a->l_ifalias, b->l_ifalias));
991 diff |= LINK_DIFF(NUM_VF, a->l_num_vf != b->l_num_vf);
992 diff |= LINK_DIFF(PROMISCUITY, a->l_promiscuity != b->l_promiscuity);
993 diff |= LINK_DIFF(NUM_TX_QUEUES,a->l_num_tx_queues != b->l_num_tx_queues);
994 diff |= LINK_DIFF(NUM_RX_QUEUES,a->l_num_rx_queues != b->l_num_rx_queues);
995 diff |= LINK_DIFF(GROUP, a->l_group != b->l_group);
997 if (flags & LOOSE_COMPARISON)
998 diff |= LINK_DIFF(FLAGS,
999 (a->l_flags ^ b->l_flags) & b->l_flag_mask);
1001 diff |= LINK_DIFF(FLAGS, a->l_flags != b->l_flags);
1006 if (a->l_family == b->l_family) {
1008 goto protinfo_mismatch;
1016 diff |= LINK_DIFF(PROTINFO, 1);
1022 static const struct trans_tbl link_attrs[] = {
1023 __ADD(LINK_ATTR_MTU, mtu),
1024 __ADD(LINK_ATTR_LINK, link),
1025 __ADD(LINK_ATTR_TXQLEN, txqlen),
1026 __ADD(LINK_ATTR_WEIGHT, weight),
1027 __ADD(LINK_ATTR_MASTER, master),
1028 __ADD(LINK_ATTR_QDISC, qdisc),
1029 __ADD(LINK_ATTR_MAP, map),
1030 __ADD(LINK_ATTR_ADDR, address),
1031 __ADD(LINK_ATTR_BRD, broadcast),
1032 __ADD(LINK_ATTR_FLAGS, flags),
1033 __ADD(LINK_ATTR_IFNAME, name),
1034 __ADD(LINK_ATTR_IFINDEX, ifindex),
1035 __ADD(LINK_ATTR_FAMILY, family),
1036 __ADD(LINK_ATTR_ARPTYPE, arptype),
1037 __ADD(LINK_ATTR_STATS, stats),
1038 __ADD(LINK_ATTR_CHANGE, change),
1039 __ADD(LINK_ATTR_OPERSTATE, operstate),
1040 __ADD(LINK_ATTR_LINKMODE, linkmode),
1041 __ADD(LINK_ATTR_IFALIAS, ifalias),
1042 __ADD(LINK_ATTR_NUM_VF, num_vf),
1043 __ADD(LINK_ATTR_PROMISCUITY, promiscuity),
1044 __ADD(LINK_ATTR_NUM_TX_QUEUES, num_tx_queues),
1045 __ADD(LINK_ATTR_NUM_RX_QUEUES, num_rx_queues),
1046 __ADD(LINK_ATTR_GROUP, group),
1047 __ADD(LINK_ATTR_CARRIER, carrier),
1048 __ADD(LINK_ATTR_PHYS_PORT_ID, phys_port_id),
1049 __ADD(LINK_ATTR_NS_FD, ns_fd),
1050 __ADD(LINK_ATTR_NS_PID, ns_pid),
1051 __ADD(LINK_ATTR_LINK_NETNSID, link_netnsid),
1054 static char *link_attrs2str(
int attrs,
char *buf,
size_t len)
1056 return __flags2str(attrs, buf, len, link_attrs,
1057 ARRAY_SIZE(link_attrs));
1092 struct nl_cache **result,
unsigned int flags)
1094 struct nl_cache * cache;
1101 cache->c_iarg1 = family;
1164 if (cache->c_ops != &rtnl_link_ops)
1167 nl_list_for_each_entry(link, &cache->c_items, ce_list) {
1168 if (link->l_index == ifindex) {
1197 if (cache->c_ops != &rtnl_link_ops)
1200 nl_list_for_each_entry(link, &cache->c_items, ce_list) {
1201 if (!strcmp(name, link->l_name)) {
1225 struct nl_msg **result)
1227 struct ifinfomsg ifi;
1229 __u32 vf_mask = RTEXT_FILTER_VF;
1230 int err = -NLE_MSGSIZE;
1232 if (ifindex <= 0 && !name) {
1233 APPBUG(
"ifindex or name must be specified");
1234 return -NLE_MISSING_ATTR;
1237 memset(&ifi, 0,
sizeof(ifi));
1243 ifi.ifi_index = ifindex;
1245 if (
nlmsg_append(msg, &ifi,
sizeof(ifi), NLMSG_ALIGNTO) < 0) {
1247 goto nla_put_failure;
1253 err =
nla_put(msg, IFLA_EXT_MASK,
sizeof(vf_mask), &vf_mask);
1255 goto nla_put_failure;
1289 struct nl_msg *msg = NULL;
1290 struct nl_object *obj;
1303 if (syserr == -EINVAL &&
1310 return -NLE_OPNOTSUPP;
1319 if (err == 0 && obj)
1345 strncpy(dst, link->l_name, len - 1);
1369 ifindex = link->l_index;
1378 int rtnl_link_fill_info(
struct nl_msg *msg,
struct rtnl_link *link)
1380 if (link->ce_mask & LINK_ATTR_ADDR)
1383 if (link->ce_mask & LINK_ATTR_BRD)
1386 if (link->ce_mask & LINK_ATTR_MTU)
1389 if (link->ce_mask & LINK_ATTR_TXQLEN)
1392 if (link->ce_mask & LINK_ATTR_WEIGHT)
1395 if (link->ce_mask & LINK_ATTR_IFNAME)
1398 if (link->ce_mask & LINK_ATTR_OPERSTATE)
1399 NLA_PUT_U8(msg, IFLA_OPERSTATE, link->l_operstate);
1401 if (link->ce_mask & LINK_ATTR_CARRIER)
1402 NLA_PUT_U8(msg, IFLA_CARRIER, link->l_carrier);
1404 if (link->ce_mask & LINK_ATTR_LINKMODE)
1405 NLA_PUT_U8(msg, IFLA_LINKMODE, link->l_linkmode);
1407 if (link->ce_mask & LINK_ATTR_IFALIAS)
1410 if (link->ce_mask & LINK_ATTR_LINK)
1413 if (link->ce_mask & LINK_ATTR_LINK_NETNSID)
1414 NLA_PUT_S32(msg, IFLA_LINK_NETNSID, link->l_link_netnsid);
1416 if (link->ce_mask & LINK_ATTR_MASTER)
1419 if (link->ce_mask & LINK_ATTR_NUM_TX_QUEUES)
1420 NLA_PUT_U32(msg, IFLA_NUM_TX_QUEUES, link->l_num_tx_queues);
1422 if (link->ce_mask & LINK_ATTR_NUM_RX_QUEUES)
1423 NLA_PUT_U32(msg, IFLA_NUM_RX_QUEUES, link->l_num_rx_queues);
1425 if (link->ce_mask & LINK_ATTR_NS_FD)
1428 if (link->ce_mask & LINK_ATTR_NS_PID)
1429 NLA_PUT_U32(msg, IFLA_NET_NS_PID, link->l_ns_pid);
1434 return -NLE_MSGSIZE;
1437 static int build_link_msg(
int cmd,
struct ifinfomsg *hdr,
1438 struct rtnl_link *link,
int flags,
struct nl_msg **result)
1441 struct nlattr *af_spec;
1447 if (
nlmsg_append(msg, hdr,
sizeof(*hdr), NLMSG_ALIGNTO) < 0)
1448 goto nla_put_failure;
1450 if (rtnl_link_fill_info(msg, link))
1451 goto nla_put_failure;
1453 if (link->ce_mask & LINK_ATTR_GROUP)
1456 if (link->ce_mask & LINK_ATTR_LINKINFO) {
1457 struct nlattr *info;
1460 goto nla_put_failure;
1464 if (link->l_info_ops) {
1465 if (link->l_info_ops->io_put_attrs &&
1466 link->l_info_ops->io_put_attrs(msg, link) < 0)
1467 goto nla_put_failure;
1474 goto nla_put_failure;
1476 if (do_foreach_af(link, af_fill, msg) < 0)
1477 goto nla_put_failure;
1486 return -NLE_MSGSIZE;
1511 struct nl_msg **result)
1513 struct ifinfomsg ifi = {
1514 .ifi_family = link->l_family,
1515 .ifi_index = link->l_index,
1516 .ifi_flags = link->l_flags,
1519 return build_link_msg(RTM_NEWLINK, &ifi, link, flags, result);
1573 struct nl_msg **result)
1575 struct ifinfomsg ifi = {
1576 .ifi_family = orig->l_family,
1577 .ifi_index = orig->l_index,
1581 if (changes->ce_mask & LINK_ATTR_FLAGS) {
1582 ifi.ifi_flags = orig->l_flags & ~changes->l_flag_mask;
1583 ifi.ifi_flags |= changes->l_flags;
1584 ifi.ifi_change = changes->l_flag_mask;
1587 if (changes->l_family && changes->l_family != orig->l_family) {
1588 APPBUG(
"link change: family is immutable");
1589 return -NLE_IMMUTABLE;
1593 if (orig->ce_mask & LINK_ATTR_IFINDEX &&
1594 orig->ce_mask & LINK_ATTR_IFNAME &&
1595 changes->ce_mask & LINK_ATTR_IFNAME &&
1596 !strcmp(orig->l_name, changes->l_name))
1597 changes->ce_mask &= ~LINK_ATTR_IFNAME;
1599 if ((err = build_link_msg(RTM_NEWLINK, &ifi, changes, flags, result)) < 0)
1654 err = wait_for_ack(sk);
1655 if (err == -NLE_OPNOTSUPP && msg->nm_nlh->nlmsg_type == RTM_NEWLINK) {
1656 msg->nm_nlh->nlmsg_type = RTM_SETLINK;
1686 struct nl_msg **result)
1689 struct ifinfomsg ifi = {
1690 .ifi_index = link->l_index,
1693 if (!(link->ce_mask & (LINK_ATTR_IFINDEX | LINK_ATTR_IFNAME))) {
1694 APPBUG(
"ifindex or name must be specified");
1695 return -NLE_MISSING_ATTR;
1701 if (
nlmsg_append(msg, &ifi,
sizeof(ifi), NLMSG_ALIGNTO) < 0)
1702 goto nla_put_failure;
1704 if (link->ce_mask & LINK_ATTR_IFNAME)
1712 return -NLE_MSGSIZE;
1793 strncpy(link->l_name, name,
sizeof(link->l_name) - 1);
1794 link->ce_mask |= LINK_ATTR_IFNAME;
1807 return link->ce_mask & LINK_ATTR_IFNAME ? link->l_name : NULL;
1817 link->l_group = group;
1818 link->ce_mask |= LINK_ATTR_GROUP;
1829 return link->l_group;
1832 static inline void __assign_addr(
struct rtnl_link *link,
struct nl_addr **pos,
1833 struct nl_addr *
new,
int flag)
1841 link->ce_mask |= flag;
1857 __assign_addr(link, &link->l_addr, addr, LINK_ATTR_ADDR);
1871 return link->ce_mask & LINK_ATTR_ADDR ? link->l_addr : NULL;
1888 __assign_addr(link, &link->l_bcast, addr, LINK_ATTR_BRD);
1902 return link->ce_mask & LINK_ATTR_BRD ? link->l_bcast : NULL;
1915 link->l_flag_mask |= flags;
1916 link->l_flags |= flags;
1917 link->ce_mask |= LINK_ATTR_FLAGS;
1930 link->l_flag_mask |= flags;
1931 link->l_flags &= ~flags;
1932 link->ce_mask |= LINK_ATTR_FLAGS;
1946 return link->l_flags;
1956 link->l_family = family;
1957 link->ce_mask |= LINK_ATTR_FAMILY;
1959 if (link->l_af_ops) {
1960 af_free(link, link->l_af_ops,
1961 link->l_af_data[link->l_af_ops->ao_family], NULL);
1962 link->l_af_data[link->l_af_ops->ao_family] = NULL;
1965 link->l_af_ops = af_lookup_and_alloc(link, family);
1977 return link->ce_mask & LINK_ATTR_FAMILY ? link->l_family : AF_UNSPEC;
1991 link->l_arptype = arptype;
1992 link->ce_mask |= LINK_ATTR_ARPTYPE;
2005 if (link->ce_mask & LINK_ATTR_ARPTYPE)
2006 return link->l_arptype;
2021 link->l_index = ifindex;
2022 link->ce_mask |= LINK_ATTR_IFINDEX;
2036 return link->l_index;
2050 link->ce_mask |= LINK_ATTR_MTU;
2078 link->l_txqlen = txqlen;
2079 link->ce_mask |= LINK_ATTR_TXQLEN;
2094 return link->ce_mask & LINK_ATTR_TXQLEN ? link->l_txqlen : 0;
2097 void rtnl_link_set_link(
struct rtnl_link *link,
int ifindex)
2099 link->l_link = ifindex;
2100 link->ce_mask |= LINK_ATTR_LINK;
2103 int rtnl_link_get_link(
struct rtnl_link *link)
2105 return link->l_link;
2118 link->l_link_netnsid = link_netnsid;
2119 link->ce_mask |= LINK_ATTR_LINK_NETNSID;
2135 if (!(link->ce_mask & LINK_ATTR_LINK_NETNSID))
2138 *out_link_netnsid = link->l_link_netnsid;
2151 link->l_master = ifindex;
2152 link->ce_mask |= LINK_ATTR_MASTER;
2164 return link->l_master;
2176 link->l_carrier = status;
2177 link->ce_mask |= LINK_ATTR_CARRIER;
2189 return link->l_carrier;
2202 link->l_operstate = status;
2203 link->ce_mask |= LINK_ATTR_OPERSTATE;
2216 return link->l_operstate;
2229 link->l_linkmode = mode;
2230 link->ce_mask |= LINK_ATTR_LINKMODE;
2243 return link->l_linkmode;
2256 return link->l_ifalias;
2273 free(link->l_ifalias);
2276 link->l_ifalias = strdup(alias);
2277 link->ce_mask |= LINK_ATTR_IFALIAS;
2279 link->l_ifalias = NULL;
2280 link->ce_mask &= ~LINK_ATTR_IFALIAS;
2299 strncpy(link->l_qdisc, name,
sizeof(link->l_qdisc) - 1);
2300 link->ce_mask |= LINK_ATTR_QDISC;
2313 return link->ce_mask & LINK_ATTR_QDISC ? link->l_qdisc : NULL;
2326 if (link->ce_mask & LINK_ATTR_NUM_VF) {
2327 *num_vf = link->l_num_vf;
2330 return -NLE_OPNOTSUPP;
2342 if (
id > RTNL_LINK_STATS_MAX)
2345 return link->l_stats[id];
2360 const uint64_t value)
2362 if (
id > RTNL_LINK_STATS_MAX)
2365 link->l_stats[id] = value;
2384 struct rtnl_link_info_ops *io;
2388 free(link->l_info_kind);
2389 link->ce_mask &= ~LINK_ATTR_LINKINFO;
2390 release_link_info(link);
2395 kind = strdup(type);
2401 if (io->io_alloc && (err = io->io_alloc(link)) < 0)
2404 link->l_info_ops = io;
2407 link->l_info_kind = kind;
2408 link->ce_mask |= LINK_ATTR_LINKINFO;
2426 return link->l_info_kind;
2440 link->l_promiscuity = count;
2441 link->ce_mask |= LINK_ATTR_PROMISCUITY;
2453 return link->l_promiscuity;
2472 link->l_num_tx_queues = nqueues;
2473 link->ce_mask |= LINK_ATTR_NUM_TX_QUEUES;
2484 return link->l_num_tx_queues;
2503 link->l_num_rx_queues = nqueues;
2504 link->ce_mask |= LINK_ATTR_NUM_RX_QUEUES;
2515 return link->l_num_rx_queues;
2526 return link->l_phys_port_id;
2529 void rtnl_link_set_ns_fd(
struct rtnl_link *link,
int fd)
2532 link->ce_mask |= LINK_ATTR_NS_FD;
2535 int rtnl_link_get_ns_fd(
struct rtnl_link *link)
2537 return link->l_ns_fd;
2540 void rtnl_link_set_ns_pid(
struct rtnl_link *link, pid_t pid)
2542 link->l_ns_pid = pid;
2543 link->ce_mask |= LINK_ATTR_NS_PID;
2546 pid_t rtnl_link_get_ns_pid(
struct rtnl_link *link)
2548 return link->l_ns_pid;
2598 err = -NLE_OPNOTSUPP;
2681 static const struct trans_tbl link_flags[] = {
2682 __ADD(IFF_LOOPBACK, loopback),
2683 __ADD(IFF_BROADCAST, broadcast),
2684 __ADD(IFF_POINTOPOINT, pointopoint),
2685 __ADD(IFF_MULTICAST, multicast),
2686 __ADD(IFF_NOARP, noarp),
2687 __ADD(IFF_ALLMULTI, allmulti),
2688 __ADD(IFF_PROMISC, promisc),
2689 __ADD(IFF_MASTER, master),
2690 __ADD(IFF_SLAVE, slave),
2691 __ADD(IFF_DEBUG, debug),
2692 __ADD(IFF_DYNAMIC, dynamic),
2693 __ADD(IFF_AUTOMEDIA, automedia),
2694 __ADD(IFF_PORTSEL, portsel),
2695 __ADD(IFF_NOTRAILERS, notrailers),
2697 __ADD(IFF_RUNNING, running),
2698 __ADD(IFF_LOWER_UP, lowerup),
2699 __ADD(IFF_DORMANT, dormant),
2700 __ADD(IFF_ECHO, echo),
2703 char *rtnl_link_flags2str(
int flags,
char *buf,
size_t len)
2705 return __flags2str(flags, buf, len, link_flags,
2706 ARRAY_SIZE(link_flags));
2709 int rtnl_link_str2flags(
const char *name)
2711 return __str2flags(name, link_flags, ARRAY_SIZE(link_flags));
2714 static const struct trans_tbl link_stats[] = {
2780 char *rtnl_link_stat2str(
int st,
char *buf,
size_t len)
2782 return __type2str(st, buf, len, link_stats, ARRAY_SIZE(link_stats));
2785 int rtnl_link_str2stat(
const char *name)
2787 return __str2type(name, link_stats, ARRAY_SIZE(link_stats));
2790 static const struct trans_tbl link_operstates[] = {
2791 __ADD(IF_OPER_UNKNOWN, unknown),
2792 __ADD(IF_OPER_NOTPRESENT, notpresent),
2793 __ADD(IF_OPER_DOWN, down),
2794 __ADD(IF_OPER_LOWERLAYERDOWN, lowerlayerdown),
2795 __ADD(IF_OPER_TESTING, testing),
2796 __ADD(IF_OPER_DORMANT, dormant),
2797 __ADD(IF_OPER_UP, up),
2800 char *rtnl_link_operstate2str(uint8_t st,
char *buf,
size_t len)
2802 return __type2str(st, buf, len, link_operstates,
2803 ARRAY_SIZE(link_operstates));
2806 int rtnl_link_str2operstate(
const char *name)
2808 return __str2type(name, link_operstates,
2809 ARRAY_SIZE(link_operstates));
2812 static const struct trans_tbl link_modes[] = {
2813 __ADD(IF_LINK_MODE_DEFAULT,
default),
2814 __ADD(IF_LINK_MODE_DORMANT, dormant),
2817 static const struct trans_tbl carrier_states[] = {
2818 __ADD(IF_CARRIER_DOWN, down),
2819 __ADD(IF_CARRIER_UP, up),
2822 char *rtnl_link_mode2str(uint8_t st,
char *buf,
size_t len)
2824 return __type2str(st, buf, len, link_modes, ARRAY_SIZE(link_modes));
2827 int rtnl_link_str2mode(
const char *name)
2829 return __str2type(name, link_modes, ARRAY_SIZE(link_modes));
2832 char *rtnl_link_carrier2str(uint8_t st,
char *buf,
size_t len)
2834 return __type2str(st, buf, len, carrier_states,
2835 ARRAY_SIZE(carrier_states));
2838 int rtnl_link_str2carrier(
const char *name)
2840 return __str2type(name, carrier_states, ARRAY_SIZE(carrier_states));
2870 link->l_weight = weight;
2871 link->ce_mask |= LINK_ATTR_WEIGHT;
2879 return link->l_weight;
2884 static struct nl_object_ops link_obj_ops = {
2885 .oo_name =
"route/link",
2887 .oo_free_data = link_free_data,
2888 .oo_clone = link_clone,
2894 .oo_compare = link_compare,
2895 .oo_keygen = link_keygen,
2896 .oo_attrs2str = link_attrs2str,
2897 .oo_id_attrs = LINK_ATTR_IFINDEX | LINK_ATTR_FAMILY,
2900 static struct nl_af_group link_groups[] = {
2901 { AF_UNSPEC, RTNLGRP_LINK },
2902 { AF_BRIDGE, RTNLGRP_LINK },
2903 { END_OF_GROUP_LIST },
2906 static struct nl_cache_ops rtnl_link_ops = {
2907 .co_name =
"route/link",
2908 .co_hdrsize =
sizeof(
struct ifinfomsg),
2910 { RTM_NEWLINK, NL_ACT_NEW,
"new" },
2911 { RTM_DELLINK, NL_ACT_DEL,
"del" },
2912 { RTM_GETLINK, NL_ACT_GET,
"get" },
2913 { RTM_SETLINK, NL_ACT_CHANGE,
"set" },
2914 END_OF_MSGTYPES_LIST,
2916 .co_protocol = NETLINK_ROUTE,
2917 .co_groups = link_groups,
2918 .co_request_update = link_request_update,
2919 .co_msg_parser = link_msg_parser,
2920 .co_obj_ops = &link_obj_ops,
2923 static void __init link_init(
void)
2928 static void __exit link_exit(
void)
int nl_send_auto_complete(struct nl_sock *sk, struct nl_msg *msg)
struct nl_addr * nl_addr_clone(const struct nl_addr *addr)
Clone existing abstract address object.
Dump object briefly on one line.
int rtnl_link_get_link_netnsid(const struct rtnl_link *link, int32_t *out_link_netnsid)
Get the netnsid of the link.
uint32_t rtnl_link_get_group(struct rtnl_link *link)
Return the group identifier of link object.
int32_t nla_get_s32(const struct nlattr *nla)
Return payload of 32 bit signed integer attribute.
int rtnl_link_info_data_compare(struct rtnl_link *a, struct rtnl_link *b, int flags)
Compare link info data.
void nlmsg_free(struct nl_msg *msg)
Release a reference from an netlink message.
struct rtnl_link * rtnl_link_get_by_name(struct nl_cache *cache, const char *name)
Lookup link in cache by link name.
int nl_addr_cmp(const struct nl_addr *a, const struct nl_addr *b)
Compare abstract addresses.
int nl_addr_guess_family(const struct nl_addr *addr)
Guess address family of abstract address based on address size.
int rtnl_link_alloc_cache_flags(struct nl_sock *sk, int family, struct nl_cache **result, unsigned int flags)
Allocate link cache and fill in all configured links.
void * nlmsg_data(const struct nlmsghdr *nlh)
Return pointer to message payload.
void rtnl_link_set_master(struct rtnl_link *link, int ifindex)
Set master link of link object.
void rtnl_link_set_ifindex(struct rtnl_link *link, int ifindex)
Set interface index of link object.
void rtnl_link_unset_flags(struct rtnl_link *link, unsigned int flags)
Unset flags of link object.
#define NLA_PUT_ADDR(msg, attrtype, addr)
Add address attribute to netlink message.
int rtnl_link_set_info_type(struct rtnl_link *link, const char *type)
void rtnl_link_set_arptype(struct rtnl_link *link, unsigned int arptype)
Set hardware type of link object.
char * rtnl_link_get_qdisc(struct rtnl_link *link)
Return name of queueing discipline of link object.
struct rtnl_link * rtnl_link_get(struct nl_cache *cache, int ifindex)
Lookup link in cache by interface index.
struct nl_object * nl_object_alloc(struct nl_object_ops *ops)
Allocate a new object of kind specified by the operations handle.
int nl_cache_mngt_unregister(struct nl_cache_ops *ops)
Unregister a set of cache operations.
Attribute validation policy.
uint8_t nla_get_u8(const struct nlattr *nla)
Return value of 8 bit integer attribute.
struct rtnl_link * rtnl_link_alloc(void)
Allocate link object.
Unspecified type, binary data chunk.
struct nl_cache * nl_cache_mngt_require_safe(const char *name)
Return cache previously provided via nl_cache_mngt_provide()
void nl_object_get(struct nl_object *obj)
Acquire a reference on a object.
int nl_send_sync(struct nl_sock *sk, struct nl_msg *msg)
Finalize and transmit Netlink message and wait for ACK or error message.
char * nla_get_string(const struct nlattr *nla)
Return payload of string attribute.
uint32_t nla_get_u32(const struct nlattr *nla)
Return payload of 32 bit integer attribute.
int rtnl_link_get_kernel(struct nl_sock *sk, int ifindex, const char *name, struct rtnl_link **result)
Get a link object directly from kernel.
int rtnl_link_build_get_request(int ifindex, const char *name, struct nl_msg **result)
Construct RTM_GETLINK netlink message.
int rtnl_link_build_add_request(struct rtnl_link *link, int flags, struct nl_msg **result)
Build a netlink message requesting the addition of new virtual link.
int rtnl_link_build_delete_request(const struct rtnl_link *link, struct nl_msg **result)
Build a netlink message requesting the deletion of a link.
int nlmsg_parse(struct nlmsghdr *nlh, int hdrlen, struct nlattr *tb[], int maxtype, struct nla_policy *policy)
parse attributes of a netlink message
struct nl_data * nl_data_alloc_attr(const struct nlattr *nla)
Allocate abstract data object based on netlink attribute.
void rtnl_link_set_carrier(struct rtnl_link *link, uint8_t status)
Set carrier of link object.
void rtnl_link_set_broadcast(struct rtnl_link *link, struct nl_addr *addr)
Set link layer broadcast address of link object.
struct nl_addr * nl_addr_get(struct nl_addr *addr)
Increase the reference counter of an abstract address.
void nl_addr_set_family(struct nl_addr *addr, int family)
Set address family.
struct nl_addr * nl_addr_alloc_attr(const struct nlattr *nla, int family)
Allocate abstract address based on Netlink attribute.
int rtnl_link_set_stat(struct rtnl_link *link, rtnl_link_stat_id_t id, const uint64_t value)
Set value of link statistics counter.
struct rtnl_link_af_ops * rtnl_link_af_ops_lookup(const unsigned int family)
Return operations of a specific link address family.
#define NLA_PUT_U8(msg, attrtype, value)
Add 8 bit integer attribute to netlink message.
uint64_t rtnl_link_get_stat(struct rtnl_link *link, rtnl_link_stat_id_t id)
Return value of link statistics counter.
NUL terminated character string.
Dump all attributes but no statistics.
char * rtnl_link_get_name(struct rtnl_link *link)
Return name of link object.
uint8_t rtnl_link_get_linkmode(struct rtnl_link *link)
Return link mode of link object.
uint32_t rtnl_link_get_num_tx_queues(struct rtnl_link *link)
Return number of TX queues.
int nl_addr_iszero(const struct nl_addr *addr)
Returns true if the address consists of all zeros.
void rtnl_link_set_num_tx_queues(struct rtnl_link *link, uint32_t nqueues)
Set number of TX queues.
struct nl_data * rtnl_link_get_phys_port_id(struct rtnl_link *link)
Return physical port id of link object.
struct nl_addr * rtnl_link_get_addr(struct rtnl_link *link)
Return link layer address of link object.
void rtnl_link_set_promiscuity(struct rtnl_link *link, uint32_t count)
Set link promiscuity count.
int rtnl_link_delete(struct nl_sock *sk, const struct rtnl_link *link)
Delete link.
unsigned int rtnl_link_get_flags(struct rtnl_link *link)
Return flags of link object.
uint8_t rtnl_link_get_operstate(struct rtnl_link *link)
Return operational status of link object.
int rtnl_link_get_num_vf(struct rtnl_link *link, uint32_t *num_vf)
Return number of PCI virtual functions of link object.
void nl_cache_free(struct nl_cache *cache)
Free a cache.
int nla_nest_end(struct nl_msg *msg, struct nlattr *start)
Finalize nesting of attributes.
int nl_cache_mngt_register(struct nl_cache_ops *ops)
Register a set of cache operations.
int rtnl_link_enslave(struct nl_sock *sock, struct rtnl_link *master, struct rtnl_link *slave)
Enslave slave link to master link.
unsigned int rtnl_link_get_weight(struct rtnl_link *link)
unsigned int rtnl_link_get_arptype(struct rtnl_link *link)
Get hardware type of link object.
int rtnl_link_get_master(struct rtnl_link *link)
Return master link of link object.
double nl_cancel_down_bytes(unsigned long long l, char **unit)
Cancel down a byte counter.
int nla_memcpy(void *dest, const struct nlattr *src, int count)
Copy attribute payload to another memory area.
uint8_t rtnl_link_get_carrier(struct rtnl_link *link)
Return carrier status of link object.
int nla_parse_nested(struct nlattr *tb[], int maxtype, struct nlattr *nla, struct nla_policy *policy)
Create attribute index based on nested attribute.
int nla_type(const struct nlattr *nla)
Return type of the attribute.
void rtnl_link_set_ifalias(struct rtnl_link *link, const char *alias)
Set alias name of link object (SNMP IfAlias)
void rtnl_link_set_addr(struct rtnl_link *link, struct nl_addr *addr)
Set link layer address of link object.
void rtnl_link_set_family(struct rtnl_link *link, int family)
Set address family of link object.
void rtnl_link_set_name(struct rtnl_link *link, const char *name)
Set name of link object.
void * nla_data(const struct nlattr *nla)
Return pointer to the payload section.
unsigned int rtnl_link_get_mtu(struct rtnl_link *link)
Return maximum transmission unit of link object.
int rtnl_link_set_type(struct rtnl_link *link, const char *type)
Set type of link object.
#define NLA_PUT_U32(msg, attrtype, value)
Add 32 bit integer attribute to netlink message.
void * rtnl_link_af_alloc(struct rtnl_link *link, const struct rtnl_link_af_ops *ops)
Allocate and return data buffer for link address family modules.
struct nl_data * nl_data_clone(const struct nl_data *src)
Clone an abstract data object.
int rtnl_link_get_family(struct rtnl_link *link)
Return address family of link object.
uint32_t rtnl_link_get_num_rx_queues(struct rtnl_link *link)
Return number of RX queues.
int rtnl_link_change(struct nl_sock *sk, struct rtnl_link *orig, struct rtnl_link *changes, int flags)
Change link.
int rtnl_link_af_data_compare(struct rtnl_link *a, struct rtnl_link *b, int family)
Compare af data for a link address family.
#define nla_for_each_nested(pos, nla, rem)
Iterate over a stream of nested attributes.
int rtnl_link_set_link_netnsid(struct rtnl_link *link, int32_t link_netnsid)
Set the netnsid of the link.
void rtnl_link_set_num_rx_queues(struct rtnl_link *link, uint32_t nqueues)
Set number of RX queues.
int rtnl_link_alloc_cache(struct nl_sock *sk, int family, struct nl_cache **result)
Allocate link cache and fill in all configured links.
void rtnl_link_set_linkmode(struct rtnl_link *link, uint8_t mode)
Set link mode of link object.
const char * rtnl_link_get_ifalias(struct rtnl_link *link)
Return alias name of link object (SNMP IfAlias)
int nlmsg_append(struct nl_msg *n, void *data, size_t len, int pad)
Append data to tail of a netlink message.
int nl_cache_refill(struct nl_sock *sk, struct nl_cache *cache)
(Re)fill a cache with the contents in the kernel.
void nl_object_put(struct nl_object *obj)
Release a reference from an object.
#define NLA_PUT_STRING(msg, attrtype, value)
Add string attribute to netlink message.
int rtnl_link_release(struct nl_sock *sock, struct rtnl_link *slave)
Release slave link from its master.
void nl_addr_put(struct nl_addr *addr)
Decrease the reference counter of an abstract address.
uint16_t type
Type of attribute or NLA_UNSPEC.
unsigned int rtnl_link_get_txqlen(struct rtnl_link *link)
Return transmission queue length.
struct nl_msg * nlmsg_alloc_simple(int nlmsgtype, int flags)
Allocate a new netlink message.
char * rtnl_link_i2name(struct nl_cache *cache, int ifindex, char *dst, size_t len)
Translate interface index to corresponding link name.
int rtnl_link_get_ifindex(struct rtnl_link *link)
Return interface index of link object.
void nl_cache_set_flags(struct nl_cache *cache, unsigned int flags)
Set cache flags.
uint32_t rtnl_link_get_promiscuity(struct rtnl_link *link)
Return link promiscuity count.
void rtnl_link_set_flags(struct rtnl_link *link, unsigned int flags)
Set flags of link object.
void rtnl_link_set_mtu(struct rtnl_link *link, unsigned int mtu)
Set Maximum Transmission Unit of link object.
void rtnl_link_set_qdisc(struct rtnl_link *link, const char *name)
Set queueing discipline name of link object.
void nl_dump(struct nl_dump_params *params, const char *fmt,...)
Dump a formatted character string.
void rtnl_link_set_weight(struct rtnl_link *link, unsigned int weight)
char * rtnl_link_get_type(struct rtnl_link *link)
Return type of link.
void rtnl_link_put(struct rtnl_link *link)
Return a link object reference.
void rtnl_link_af_ops_put(struct rtnl_link_af_ops *ops)
Give back reference to a set of operations.
int rtnl_link_name2i(struct nl_cache *cache, const char *name)
Translate link name to corresponding interface index.
struct nl_addr * rtnl_link_get_broadcast(struct rtnl_link *link)
Return link layer broadcast address of link object.
void rtnl_link_set_txqlen(struct rtnl_link *link, unsigned int txqlen)
Set transmission queue length.
int rtnl_link_build_change_request(struct rtnl_link *orig, struct rtnl_link *changes, int flags, struct nl_msg **result)
Build a netlink message requesting the modification of link.
int nl_send_auto(struct nl_sock *sk, struct nl_msg *msg)
Finalize and transmit Netlink message.
char * rtnl_link_get_info_type(struct rtnl_link *link)
void rtnl_link_set_operstate(struct rtnl_link *link, uint8_t status)
Set operational status of link object.
int nla_put(struct nl_msg *msg, int attrtype, int datalen, const void *data)
Add a unspecific attribute to netlink message.
int rtnl_link_add(struct nl_sock *sk, struct rtnl_link *link, int flags)
Add virtual link.
void rtnl_link_set_group(struct rtnl_link *link, uint32_t group)
Set the group identifier of a link object.
#define NLA_PUT_S32(msg, attrtype, value)
Add 32 bit signed integer attribute to netlink message.
Dump all attributes including statistics.
int rtnl_link_release_ifindex(struct nl_sock *sock, int slave)
Release slave link from its master.
void rtnl_link_info_ops_put(struct rtnl_link_info_ops *ops)
Give back reference to a set of operations.
size_t nla_strlcpy(char *dst, const struct nlattr *nla, size_t dstsize)
Copy string attribute payload to a buffer.
struct nl_cache * nl_cache_alloc(struct nl_cache_ops *ops)
Allocate new cache.
int rtnl_link_enslave_ifindex(struct nl_sock *sock, int master, int slave)
Enslave slave link to master link.
struct rtnl_link_info_ops * rtnl_link_info_ops_lookup(const char *name)
Return operations of a specific link info type.
struct nlattr * nla_nest_start(struct nl_msg *msg, int attrtype)
Start a new level of nested attributes.
void nl_data_free(struct nl_data *data)
Free an abstract data object.
char * nl_addr2str(const struct nl_addr *addr, char *buf, size_t size)
Convert abstract address object to character string.
int nl_pickup_keep_syserr(struct nl_sock *sk, int(*parser)(struct nl_cache_ops *, struct sockaddr_nl *, struct nlmsghdr *, struct nl_parser_param *), struct nl_object **result, int *syserror)
Pickup netlink answer, parse is and return object with preserving system error.