Lines Matching refs:link
2 * lib/route/link.c Links (Interfaces)
14 * @defgroup link Links (Interfaces)
18 * A link can be identified by either its interface index or by its
48 * IFF_UP Status of link (up|down)
49 * IFF_BROADCAST Indicates this link allows broadcasting
50 * IFF_MULTICAST Indicates this link allows multicasting
51 * IFF_ALLMULTI Indicates this link is doing multicast routing
53 * IFF_LOOPBACK This is the loopback link
54 * IFF_POINTOPOINT Point-to-point link
59 * IFF_PORTSEL Indicates this link allows port selection
60 * IFF_AUTOMEDIA Indicates this link selects port automatically
61 * IFF_DYNAMIC Indicates the address of this link is dynamic
69 * whether the flag has been enabled/disabled by userspace. The link
70 * may be in promiscious mode even if IFF_PROMISC is not set in a link
75 * link type, a common unit is \a packets.
83 * // In a second step, a specific link may be looked up by either interface
85 * struct rtnl_link *link = rtnl_link_get_by_name(cache, "lo");
90 * struct rtnl_link *link = rtnl_link_get(cache, ifindex);
93 * rtnl_link_put(link);
96 * @par 2) Changing link attributes
98 * // In order to change any attributes of an existing link, we must allocate
99 * // a new link to hold the change requests:
109 * // Actually, we should know which link to change, so let's look it up
123 * // Don't forget to give back the link object ;->
129 * // Some link types offer additional parameters and statistics specific
130 * // to their type. F.e. a VLAN link can be configured like this:
132 * // Allocate a new link and set the info type to "vlan". This is required
133 * // to prepare the link to hold vlan specific attributes.
143 * char *type = rtnl_link_get_info_type(link);
145 * int id = rtnl_link_vlan_get_id(link);
156 #include <netlink/route/link.h>
157 #include <netlink/route/link/info-api.h>
184 static void release_link_info(struct rtnl_link *link)
186 struct rtnl_link_info_ops *io = link->l_info_ops;
190 io->io_free(link);
191 link->l_info_ops = NULL;
197 struct rtnl_link *link = nl_object_priv(c);
199 if (link) {
202 if ((io = link->l_info_ops) != NULL)
203 release_link_info(link);
205 nl_addr_put(link->l_addr);
206 nl_addr_put(link->l_bcast);
259 struct rtnl_link *link;
264 link = rtnl_link_alloc();
265 if (link == NULL) {
270 link->ce_msgtype = n->nlmsg_type;
281 nla_strlcpy(link->l_name, tb[IFLA_IFNAME], IFNAMSIZ);
284 link->l_family = ifi->ifi_family;
285 link->l_arptype = ifi->ifi_type;
286 link->l_index = ifi->ifi_index;
287 link->l_flags = ifi->ifi_flags;
288 link->l_change = ifi->ifi_change;
289 link->ce_mask = (LINK_ATTR_IFNAME | LINK_ATTR_FAMILY |
296 link->l_stats[RTNL_LINK_RX_PACKETS] = st->rx_packets;
297 link->l_stats[RTNL_LINK_RX_BYTES] = st->rx_bytes;
298 link->l_stats[RTNL_LINK_RX_ERRORS] = st->rx_errors;
299 link->l_stats[RTNL_LINK_RX_DROPPED] = st->rx_dropped;
300 link->l_stats[RTNL_LINK_RX_COMPRESSED] = st->rx_compressed;
301 link->l_stats[RTNL_LINK_RX_FIFO_ERR] = st->rx_fifo_errors;
302 link->l_stats[RTNL_LINK_TX_PACKETS] = st->tx_packets;
303 link->l_stats[RTNL_LINK_TX_BYTES] = st->tx_bytes;
304 link->l_stats[RTNL_LINK_TX_ERRORS] = st->tx_errors;
305 link->l_stats[RTNL_LINK_TX_DROPPED] = st->tx_dropped;
306 link->l_stats[RTNL_LINK_TX_COMPRESSED] = st->tx_compressed;
307 link->l_stats[RTNL_LINK_TX_FIFO_ERR] = st->tx_fifo_errors;
308 link->l_stats[RTNL_LINK_RX_LEN_ERR] = st->rx_length_errors;
309 link->l_stats[RTNL_LINK_RX_OVER_ERR] = st->rx_over_errors;
310 link->l_stats[RTNL_LINK_RX_CRC_ERR] = st->rx_crc_errors;
311 link->l_stats[RTNL_LINK_RX_FRAME_ERR] = st->rx_frame_errors;
312 link->l_stats[RTNL_LINK_RX_MISSED_ERR] = st->rx_missed_errors;
313 link->l_stats[RTNL_LINK_TX_ABORT_ERR] = st->tx_aborted_errors;
314 link->l_stats[RTNL_LINK_TX_CARRIER_ERR] = st->tx_carrier_errors;
315 link->l_stats[RTNL_LINK_TX_HBEAT_ERR] = st->tx_heartbeat_errors;
316 link->l_stats[RTNL_LINK_TX_WIN_ERR] = st->tx_window_errors;
317 link->l_stats[RTNL_LINK_MULTICAST] = st->multicast;
319 link->ce_mask |= LINK_ATTR_STATS;
323 link->l_txqlen = nla_get_u32(tb[IFLA_TXQLEN]);
324 link->ce_mask |= LINK_ATTR_TXQLEN;
328 link->l_mtu = nla_get_u32(tb[IFLA_MTU]);
329 link->ce_mask |= LINK_ATTR_MTU;
333 link->l_addr = nl_addr_alloc_attr(tb[IFLA_ADDRESS], AF_UNSPEC);
334 if (link->l_addr == NULL) {
338 nl_addr_set_family(link->l_addr,
339 nl_addr_guess_family(link->l_addr));
340 link->ce_mask |= LINK_ATTR_ADDR;
344 link->l_bcast = nl_addr_alloc_attr(tb[IFLA_BROADCAST],
346 if (link->l_bcast == NULL) {
350 nl_addr_set_family(link->l_bcast,
351 nl_addr_guess_family(link->l_bcast));
352 link->ce_mask |= LINK_ATTR_BRD;
356 link->l_link = nla_get_u32(tb[IFLA_LINK]);
357 link->ce_mask |= LINK_ATTR_LINK;
361 link->l_weight = nla_get_u32(tb[IFLA_WEIGHT]);
362 link->ce_mask |= LINK_ATTR_WEIGHT;
366 nla_strlcpy(link->l_qdisc, tb[IFLA_QDISC], IFQDISCSIZ);
367 link->ce_mask |= LINK_ATTR_QDISC;
371 nla_memcpy(&link->l_map, tb[IFLA_MAP],
373 link->ce_mask |= LINK_ATTR_MAP;
377 link->l_master = nla_get_u32(tb[IFLA_MASTER]);
378 link->ce_mask |= LINK_ATTR_MASTER;
382 link->l_operstate = nla_get_u8(tb[IFLA_OPERSTATE]);
383 link->ce_mask |= LINK_ATTR_OPERSTATE;
387 link->l_linkmode = nla_get_u8(tb[IFLA_LINKMODE]);
388 link->ce_mask |= LINK_ATTR_LINKMODE;
408 link->l_info_ops = ops;
409 err = ops->io_parse(link, li[IFLA_INFO_DATA],
419 err = pp->pp_cb((struct nl_object *) link, pp);
421 rtnl_link_put(link);
434 struct rtnl_link *link = (struct rtnl_link *) obj;
436 nl_dump_line(p, "%s %s ", link->l_name,
437 nl_llproto2str(link->l_arptype, buf, sizeof(buf)));
439 if (link->l_addr && !nl_addr_iszero(link->l_addr))
440 nl_dump(p, "%s ", nl_addr2str(link->l_addr, buf, sizeof(buf)));
442 if (link->ce_mask & LINK_ATTR_MASTER) {
443 struct rtnl_link *master = rtnl_link_get(cache, link->l_master);
449 rtnl_link_flags2str(link->l_flags, buf, sizeof(buf));
453 if (link->ce_mask & LINK_ATTR_LINK) {
454 struct rtnl_link *ll = rtnl_link_get(cache, link->l_link);
460 if (link->l_info_ops && link->l_info_ops->io_dump[NL_DUMP_LINE])
461 link->l_info_ops->io_dump[NL_DUMP_LINE](link, p);
468 struct rtnl_link *link = (struct rtnl_link *) obj;
473 nl_dump_line(p, " mtu %u ", link->l_mtu);
474 nl_dump(p, "txqlen %u weight %u ", link->l_txqlen, link->l_weight);
476 if (link->ce_mask & LINK_ATTR_QDISC)
477 nl_dump(p, "qdisc %s ", link->l_qdisc);
479 if (link->ce_mask & LINK_ATTR_MAP && link->l_map.lm_irq)
480 nl_dump(p, "irq %u ", link->l_map.lm_irq);
482 if (link->ce_mask & LINK_ATTR_IFINDEX)
483 nl_dump(p, "index %u ", link->l_index);
489 if (link->ce_mask & LINK_ATTR_BRD)
490 nl_dump(p, "brd %s ", nl_addr2str(link->l_bcast, buf,
493 if ((link->ce_mask & LINK_ATTR_OPERSTATE) &&
494 link->l_operstate != IF_OPER_UNKNOWN) {
495 rtnl_link_operstate2str(link->l_operstate, buf, sizeof(buf));
500 rtnl_link_mode2str(link->l_linkmode, buf, sizeof(buf)));
502 if (link->l_info_ops && link->l_info_ops->io_dump[NL_DUMP_DETAILS])
503 link->l_info_ops->io_dump[NL_DUMP_DETAILS](link, p);
508 struct rtnl_link *link = (struct rtnl_link *) obj;
517 res = nl_cancel_down_bytes(link->l_stats[RTNL_LINK_RX_BYTES], &unit);
523 link->l_stats[RTNL_LINK_RX_PACKETS],
524 link->l_stats[RTNL_LINK_RX_ERRORS],
525 link->l_stats[RTNL_LINK_RX_DROPPED],
526 link->l_stats[RTNL_LINK_RX_FIFO_ERR],
527 link->l_stats[RTNL_LINK_RX_COMPRESSED]);
529 res = nl_cancel_down_bytes(link->l_stats[RTNL_LINK_TX_BYTES], &unit);
535 link->l_stats[RTNL_LINK_TX_PACKETS],
536 link->l_stats[RTNL_LINK_TX_ERRORS],
537 link->l_stats[RTNL_LINK_TX_DROPPED],
538 link->l_stats[RTNL_LINK_TX_FIFO_ERR],
539 link->l_stats[RTNL_LINK_TX_COMPRESSED]);
547 link->l_stats[RTNL_LINK_RX_LEN_ERR],
548 link->l_stats[RTNL_LINK_RX_OVER_ERR],
549 link->l_stats[RTNL_LINK_RX_CRC_ERR],
550 link->l_stats[RTNL_LINK_RX_FRAME_ERR],
551 link->l_stats[RTNL_LINK_RX_MISSED_ERR],
552 link->l_stats[RTNL_LINK_MULTICAST]);
559 link->l_stats[RTNL_LINK_TX_ABORT_ERR],
560 link->l_stats[RTNL_LINK_TX_CARRIER_ERR],
561 link->l_stats[RTNL_LINK_TX_HBEAT_ERR],
562 link->l_stats[RTNL_LINK_TX_WIN_ERR],
563 link->l_stats[RTNL_LINK_TX_COLLISIONS]);
565 if (link->l_info_ops && link->l_info_ops->io_dump[NL_DUMP_STATS])
566 link->l_info_ops->io_dump[NL_DUMP_STATS](link, p);
571 struct rtnl_link *link = (struct rtnl_link *) obj;
576 nl_dump_line(p, "LINK_NAME=%s\n", link->l_name);
577 nl_dump_line(p, "LINK_IFINDEX=%u\n", link->l_index);
579 nl_af2str(link->l_family, buf, sizeof(buf)));
581 nl_llproto2str(link->l_arptype, buf, sizeof(buf)));
582 if (link->ce_mask & LINK_ATTR_ADDR)
584 nl_addr2str(link->l_addr, buf, sizeof(buf)));
585 nl_dump_line(p, "LINK_MTU=%u\n", link->l_mtu);
586 nl_dump_line(p, "LINK_TXQUEUELEN=%u\n", link->l_txqlen);
587 nl_dump_line(p, "LINK_WEIGHT=%u\n", link->l_weight);
589 rtnl_link_flags2str(link->l_flags & ~IFF_RUNNING, buf, sizeof(buf));
593 if (link->ce_mask & LINK_ATTR_QDISC)
594 nl_dump_line(p, "LINK_QDISC=%s\n", link->l_qdisc);
596 if (link->ce_mask & LINK_ATTR_LINK) {
597 struct rtnl_link *ll = rtnl_link_get(cache, link->l_link);
599 nl_dump_line(p, "LINK_LINK_IFINDEX=%d\n", link->l_link);
606 if (link->ce_mask & LINK_ATTR_MASTER) {
607 struct rtnl_link *master = rtnl_link_get(cache, link->l_master);
614 if (link->ce_mask & LINK_ATTR_BRD)
616 nl_addr2str(link->l_bcast, buf, sizeof(buf)));
618 if (link->ce_mask & LINK_ATTR_STATS) {
628 nl_dump_line(p, "%s=%" PRIu64 "\n", buf, link->l_stats[i]);
632 if (link->l_info_ops && link->l_info_ops->io_dump[NL_DUMP_ENV])
633 link->l_info_ops->io_dump[NL_DUMP_ENV](link, p);
664 dp_dump_line(p, line++, "link %s changed state to %s.\n",
669 dp_dump(p, "link %s %s promiscuous mode.\n",
674 dp_dump_line(p, line++, "link %s sent unknown event.\n",
718 __ADD(LINK_ATTR_LINK, link)
753 void rtnl_link_put(struct rtnl_link *link)
755 nl_object_put((struct nl_object *) link);
767 * Allocate link cache and fill in all configured links.
771 * Allocates a new link cache, initializes it properly and updates it
782 * Look up link by interface index in the provided cache
783 * @arg cache link cache
784 * @arg ifindex link interface index
789 * @return pointer to link inside the cache or NULL if no match was found.
793 struct rtnl_link *link;
798 nl_list_for_each_entry(link, &cache->c_items, ce_list) {
799 if (link->l_index == ifindex) {
800 nl_object_get((struct nl_object *) link);
801 return link;
809 * Look up link by link name in the provided cache
810 * @arg cache link cache
811 * @arg name link name
816 * @return pointer to link inside the cache or NULL if no match was found.
821 struct rtnl_link *link;
826 nl_list_for_each_entry(link, &cache->c_items, ce_list) {
827 if (!strcmp(name, link->l_name)) {
828 nl_object_get((struct nl_object *) link);
829 return link;
844 * Builds a netlink change request message to change link attributes
845 * @arg old link to be changed
849 * Builds a new netlink message requesting a change of link attributes.
853 * \a old must point to a link currently configured in the kernel
931 * Change link attributes
933 * @arg old link to be changed
970 * Translate an interface index to the corresponding link name
971 * @arg cache link cache
972 * @arg ifindex link interface index
977 * link name and stores the name in the destination buffer.
979 * @return link name or NULL if no match was found.
984 struct rtnl_link *link = rtnl_link_get(cache, ifindex);
986 if (link) {
987 strncpy(dst, link->l_name, len - 1);
988 rtnl_link_put(link);
996 * Translate a link name to the corresponding interface index
997 * @arg cache link cache
998 * @arg name link name
1005 struct rtnl_link *link;
1007 link = rtnl_link_get_by_name(cache, name);
1008 if (link) {
1009 ifindex = link->l_index;
1010 rtnl_link_put(link);
1157 void rtnl_link_set_qdisc(struct rtnl_link *link, const char *qdisc)
1159 strncpy(link->l_qdisc, qdisc, sizeof(link->l_qdisc) - 1);
1160 link->ce_mask |= LINK_ATTR_QDISC;
1163 char *rtnl_link_get_qdisc(struct rtnl_link *link)
1165 if (link->ce_mask & LINK_ATTR_QDISC)
1166 return link->l_qdisc;
1171 void rtnl_link_set_name(struct rtnl_link *link, const char *name)
1173 strncpy(link->l_name, name, sizeof(link->l_name) - 1);
1174 link->ce_mask |= LINK_ATTR_IFNAME;
1177 char *rtnl_link_get_name(struct rtnl_link *link)
1179 if (link->ce_mask & LINK_ATTR_IFNAME)
1180 return link->l_name;
1185 static inline void __assign_addr(struct rtnl_link *link, struct nl_addr **pos,
1194 link->ce_mask |= flag;
1197 void rtnl_link_set_addr(struct rtnl_link *link, struct nl_addr *addr)
1199 __assign_addr(link, &link->l_addr, addr, LINK_ATTR_ADDR);
1202 struct nl_addr *rtnl_link_get_addr(struct rtnl_link *link)
1204 if (link->ce_mask & LINK_ATTR_ADDR)
1205 return link->l_addr;
1210 void rtnl_link_set_broadcast(struct rtnl_link *link, struct nl_addr *brd)
1212 __assign_addr(link, &link->l_bcast, brd, LINK_ATTR_BRD);
1215 struct nl_addr *rtnl_link_get_broadcast(struct rtnl_link *link)
1217 if (link->ce_mask & LINK_ATTR_BRD)
1218 return link->l_bcast;
1223 void rtnl_link_set_flags(struct rtnl_link *link, unsigned int flags)
1225 link->l_flag_mask |= flags;
1226 link->l_flags |= flags;
1227 link->ce_mask |= LINK_ATTR_FLAGS;
1230 void rtnl_link_unset_flags(struct rtnl_link *link, unsigned int flags)
1232 link->l_flag_mask |= flags;
1233 link->l_flags &= ~flags;
1234 link->ce_mask |= LINK_ATTR_FLAGS;
1237 unsigned int rtnl_link_get_flags(struct rtnl_link *link)
1239 return link->l_flags;
1242 void rtnl_link_set_family(struct rtnl_link *link, int family)
1244 link->l_family = family;
1245 link->ce_mask |= LINK_ATTR_FAMILY;
1248 int rtnl_link_get_family(struct rtnl_link *link)
1250 if (link->l_family & LINK_ATTR_FAMILY)
1251 return link->l_family;
1256 void rtnl_link_set_arptype(struct rtnl_link *link, unsigned int arptype)
1258 link->l_arptype = arptype;
1261 unsigned int rtnl_link_get_arptype(struct rtnl_link *link)
1263 return link->l_arptype;
1266 void rtnl_link_set_ifindex(struct rtnl_link *link, int ifindex)
1268 link->l_index = ifindex;
1269 link->ce_mask |= LINK_ATTR_IFINDEX;
1272 int rtnl_link_get_ifindex(struct rtnl_link *link)
1274 return link->l_index;
1277 void rtnl_link_set_mtu(struct rtnl_link *link, unsigned int mtu)
1279 link->l_mtu = mtu;
1280 link->ce_mask |= LINK_ATTR_MTU;
1283 unsigned int rtnl_link_get_mtu(struct rtnl_link *link)
1285 if (link->ce_mask & LINK_ATTR_MTU)
1286 return link->l_mtu;
1291 void rtnl_link_set_txqlen(struct rtnl_link *link, unsigned int txqlen)
1293 link->l_txqlen = txqlen;
1294 link->ce_mask |= LINK_ATTR_TXQLEN;
1297 unsigned int rtnl_link_get_txqlen(struct rtnl_link *link)
1299 if (link->ce_mask & LINK_ATTR_TXQLEN)
1300 return link->l_txqlen;
1305 void rtnl_link_set_weight(struct rtnl_link *link, unsigned int weight)
1307 link->l_weight = weight;
1308 link->ce_mask |= LINK_ATTR_WEIGHT;
1311 unsigned int rtnl_link_get_weight(struct rtnl_link *link)
1313 if (link->ce_mask & LINK_ATTR_WEIGHT)
1314 return link->l_weight;
1319 void rtnl_link_set_link(struct rtnl_link *link, int ifindex)
1321 link->l_link = ifindex;
1322 link->ce_mask |= LINK_ATTR_LINK;
1325 int rtnl_link_get_link(struct rtnl_link *link)
1327 return link->l_link;
1330 void rtnl_link_set_master(struct rtnl_link *link, int ifindex)
1332 link->l_master = ifindex;
1333 link->ce_mask |= LINK_ATTR_MASTER;
1336 int rtnl_link_get_master(struct rtnl_link *link)
1338 return link->l_master;
1341 void rtnl_link_set_operstate(struct rtnl_link *link, uint8_t operstate)
1343 link->l_operstate = operstate;
1344 link->ce_mask |= LINK_ATTR_OPERSTATE;
1347 uint8_t rtnl_link_get_operstate(struct rtnl_link *link)
1349 if (link->ce_mask & LINK_ATTR_OPERSTATE)
1350 return link->l_operstate;
1355 void rtnl_link_set_linkmode(struct rtnl_link *link, uint8_t linkmode)
1357 link->l_linkmode = linkmode;
1358 link->ce_mask |= LINK_ATTR_LINKMODE;
1361 uint8_t rtnl_link_get_linkmode(struct rtnl_link *link)
1363 if (link->ce_mask & LINK_ATTR_LINKMODE)
1364 return link->l_linkmode;
1369 uint64_t rtnl_link_get_stat(struct rtnl_link *link, int id)
1374 return link->l_stats[id];
1378 * Specify the info type of a link
1379 * @arg link link object
1382 * Looks up the info type and prepares the link to store info type
1388 int rtnl_link_set_info_type(struct rtnl_link *link, const char *type)
1396 if (link->l_info_ops)
1397 release_link_info(link);
1399 if ((err = io->io_alloc(link)) < 0)
1402 link->l_info_ops = io;
1408 * Return info type of a link
1409 * @arg link link object
1411 * @note The returned pointer is only valid as long as the link exists
1414 char *rtnl_link_get_info_type(struct rtnl_link *link)
1416 if (link->l_info_ops)
1417 return link->l_info_ops->io_name;
1425 .oo_name = "route/link",
1446 .co_name = "route/link",