diff --git a/sys/netlink/route/iface.c b/sys/netlink/route/iface.c index aae2cbefb325..976b485b3f56 100644 --- a/sys/netlink/route/iface.c +++ b/sys/netlink/route/iface.c @@ -1,1140 +1,1448 @@ /*- * SPDX-License-Identifier: BSD-2-Clause * * Copyright (c) 2022 Alexander V. Chernikov * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include "opt_netlink.h" #include __FBSDID("$FreeBSD$"); #include "opt_inet.h" #include "opt_inet6.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include +#include #include +#include /* scope deembedding */ #include #include #include #include -#include /* scope deembedding */ - #define DEBUG_MOD_NAME nl_iface #define DEBUG_MAX_LEVEL LOG_DEBUG3 #include _DECLARE_DEBUG(LOG_INFO); struct netlink_walkargs { struct nl_writer *nw; struct nlmsghdr hdr; struct nlpcb *so; struct ucred *cred; uint32_t fibnum; int family; int error; int count; int dumped; }; static eventhandler_tag ifdetach_event, ifattach_event, iflink_event, ifaddr_event; static SLIST_HEAD(, nl_cloner) nl_cloners = SLIST_HEAD_INITIALIZER(nl_cloners); static struct sx rtnl_cloner_lock; SX_SYSINIT(rtnl_cloner_lock, &rtnl_cloner_lock, "rtnl cloner lock"); /* These are external hooks for CARP. */ extern int (*carp_get_vhid_p)(struct ifaddr *); /* * RTM_GETLINK request * sendto(3, {{len=32, type=RTM_GETLINK, flags=NLM_F_REQUEST|NLM_F_DUMP, seq=1641940952, pid=0}, * {ifi_family=AF_INET, ifi_type=ARPHRD_NETROM, ifi_index=0, ifi_flags=0, ifi_change=0}}, 32, 0, NULL, 0) = 32 * * Reply: * {ifi_family=AF_UNSPEC, ifi_type=ARPHRD_ETHER, ifi_index=if_nametoindex("enp0s31f6"), ifi_flags=IFF_UP|IFF_BROADCAST|IFF_RUNNING|IFF_MULTICAST|IFF_LOWER_UP, ifi_change=0}, {{nla_len=10, nla_type=IFLA_ADDRESS}, "\xfe\x54\x00\x52\x3e\x90"} [ {{nla_len=14, nla_type=IFLA_IFNAME}, "enp0s31f6"}, {{nla_len=8, nla_type=IFLA_TXQLEN}, 1000}, {{nla_len=5, nla_type=IFLA_OPERSTATE}, 6}, {{nla_len=5, nla_type=IFLA_LINKMODE}, 0}, {{nla_len=8, nla_type=IFLA_MTU}, 1500}, {{nla_len=8, nla_type=IFLA_MIN_MTU}, 68}, {{nla_len=8, nla_type=IFLA_MAX_MTU}, 9000}, {{nla_len=8, nla_type=IFLA_GROUP}, 0}, {{nla_len=8, nla_type=IFLA_PROMISCUITY}, 0}, {{nla_len=8, nla_type=IFLA_NUM_TX_QUEUES}, 1}, {{nla_len=8, nla_type=IFLA_GSO_MAX_SEGS}, 65535}, {{nla_len=8, nla_type=IFLA_GSO_MAX_SIZE}, 65536}, {{nla_len=8, nla_type=IFLA_NUM_RX_QUEUES}, 1}, {{nla_len=5, nla_type=IFLA_CARRIER}, 1}, {{nla_len=13, nla_type=IFLA_QDISC}, "fq_codel"}, {{nla_len=8, nla_type=IFLA_CARRIER_CHANGES}, 2}, {{nla_len=5, nla_type=IFLA_PROTO_DOWN}, 0}, {{nla_len=8, nla_type=IFLA_CARRIER_UP_COUNT}, 1}, {{nla_len=8, nla_type=IFLA_CARRIER_DOWN_COUNT}, 1}, */ struct if_state { uint8_t ifla_operstate; uint8_t ifla_carrier; }; static void get_operstate_ether(struct ifnet *ifp, struct if_state *pstate) { struct ifmediareq ifmr = {}; int error; error = (*ifp->if_ioctl)(ifp, SIOCGIFMEDIA, (void *)&ifmr); if (error != 0) { NL_LOG(LOG_DEBUG, "error calling SIOCGIFMEDIA on %s: %d", if_name(ifp), error); return; } switch (IFM_TYPE(ifmr.ifm_active)) { case IFM_ETHER: if (ifmr.ifm_status & IFM_ACTIVE) { pstate->ifla_carrier = 1; if (ifp->if_flags & IFF_MONITOR) pstate->ifla_operstate = IF_OPER_DORMANT; else pstate->ifla_operstate = IF_OPER_UP; } else pstate->ifla_operstate = IF_OPER_DOWN; } } static bool get_stats(struct nl_writer *nw, struct ifnet *ifp) { struct rtnl_link_stats64 *stats; int nla_len = sizeof(struct nlattr) + sizeof(*stats); struct nlattr *nla = nlmsg_reserve_data(nw, nla_len, struct nlattr); if (nla == NULL) return (false); nla->nla_type = IFLA_STATS64; nla->nla_len = nla_len; stats = (struct rtnl_link_stats64 *)(nla + 1); stats->rx_packets = ifp->if_get_counter(ifp, IFCOUNTER_IPACKETS); stats->tx_packets = ifp->if_get_counter(ifp, IFCOUNTER_OPACKETS); stats->rx_bytes = ifp->if_get_counter(ifp, IFCOUNTER_IBYTES); stats->tx_bytes = ifp->if_get_counter(ifp, IFCOUNTER_OBYTES); stats->rx_errors = ifp->if_get_counter(ifp, IFCOUNTER_IERRORS); stats->tx_errors = ifp->if_get_counter(ifp, IFCOUNTER_OERRORS); stats->rx_dropped = ifp->if_get_counter(ifp, IFCOUNTER_IQDROPS); stats->tx_dropped = ifp->if_get_counter(ifp, IFCOUNTER_OQDROPS); stats->multicast = ifp->if_get_counter(ifp, IFCOUNTER_IMCASTS); stats->rx_nohandler = ifp->if_get_counter(ifp, IFCOUNTER_NOPROTO); return (true); } static void get_operstate(struct ifnet *ifp, struct if_state *pstate) { pstate->ifla_operstate = IF_OPER_UNKNOWN; pstate->ifla_carrier = 0; /* no carrier */ switch (ifp->if_type) { case IFT_ETHER: case IFT_L2VLAN: get_operstate_ether(ifp, pstate); break; default: /* Map admin state to the operstate */ if (ifp->if_flags & IFF_UP) { pstate->ifla_operstate = IF_OPER_UP; pstate->ifla_carrier = 1; } else pstate->ifla_operstate = IF_OPER_DOWN; break; } } static void get_hwaddr(struct nl_writer *nw, struct ifnet *ifp) { struct ifreq ifr = {}; if (if_gethwaddr(ifp, &ifr) == 0) { nlattr_add(nw, IFLAF_ORIG_HWADDR, if_getaddrlen(ifp), ifr.ifr_addr.sa_data); } } static unsigned ifp_flags_to_netlink(const struct ifnet *ifp) { return (ifp->if_flags | ifp->if_drv_flags); } #define LLADDR_CONST(s) ((const void *)((s)->sdl_data + (s)->sdl_nlen)) static bool dump_sa(struct nl_writer *nw, int attr, const struct sockaddr *sa) { uint32_t addr_len = 0; const void *addr_data = NULL; #ifdef INET6 struct in6_addr addr6; #endif if (sa == NULL) return (true); switch (sa->sa_family) { #ifdef INET case AF_INET: addr_len = sizeof(struct in_addr); addr_data = &((const struct sockaddr_in *)sa)->sin_addr; break; #endif #ifdef INET6 case AF_INET6: in6_splitscope(&((const struct sockaddr_in6 *)sa)->sin6_addr, &addr6, &addr_len); addr_len = sizeof(struct in6_addr); addr_data = &addr6; break; #endif case AF_LINK: addr_len = ((const struct sockaddr_dl *)sa)->sdl_alen; addr_data = LLADDR_CONST((const struct sockaddr_dl *)sa); break; + case AF_UNSPEC: + /* Ignore empty SAs without warning */ + return (true); default: NL_LOG(LOG_DEBUG2, "unsupported family: %d, skipping", sa->sa_family); return (true); } return (nlattr_add(nw, attr, addr_len, addr_data)); } /* * Dumps interface state, properties and metrics. * @nw: message writer * @ifp: target interface * @hdr: template header * @if_flags_mask: changed if_[drv]_flags bitmask * * This function is called without epoch and MAY sleep. */ static bool dump_iface(struct nl_writer *nw, struct ifnet *ifp, const struct nlmsghdr *hdr, int if_flags_mask) { struct ifinfomsg *ifinfo; NL_LOG(LOG_DEBUG3, "dumping interface %s data", if_name(ifp)); if (!nlmsg_reply(nw, hdr, sizeof(struct ifinfomsg))) goto enomem; ifinfo = nlmsg_reserve_object(nw, struct ifinfomsg); ifinfo->ifi_family = AF_UNSPEC; ifinfo->__ifi_pad = 0; ifinfo->ifi_type = ifp->if_type; ifinfo->ifi_index = ifp->if_index; ifinfo->ifi_flags = ifp_flags_to_netlink(ifp); ifinfo->ifi_change = if_flags_mask; struct if_state ifs = {}; get_operstate(ifp, &ifs); if (ifs.ifla_operstate == IF_OPER_UP) ifinfo->ifi_flags |= IFF_LOWER_UP; nlattr_add_string(nw, IFLA_IFNAME, if_name(ifp)); nlattr_add_u8(nw, IFLA_OPERSTATE, ifs.ifla_operstate); nlattr_add_u8(nw, IFLA_CARRIER, ifs.ifla_carrier); /* nlattr_add_u8(nw, IFLA_PROTO_DOWN, val); nlattr_add_u8(nw, IFLA_LINKMODE, val); */ if (if_getaddrlen(ifp) != 0) { struct ifaddr *ifa = if_getifaddr(ifp); dump_sa(nw, IFLA_ADDRESS, ifa->ifa_addr); } if ((ifp->if_broadcastaddr != NULL)) { nlattr_add(nw, IFLA_BROADCAST, ifp->if_addrlen, ifp->if_broadcastaddr); } nlattr_add_u32(nw, IFLA_MTU, ifp->if_mtu); /* nlattr_add_u32(nw, IFLA_MIN_MTU, 60); nlattr_add_u32(nw, IFLA_MAX_MTU, 9000); nlattr_add_u32(nw, IFLA_GROUP, 0); */ if (ifp->if_description != NULL) nlattr_add_string(nw, IFLA_IFALIAS, ifp->if_description); /* Store FreeBSD-specific attributes */ int off = nlattr_add_nested(nw, IFLA_FREEBSD); if (off != 0) { get_hwaddr(nw, ifp); nlattr_set_len(nw, off); } get_stats(nw, ifp); uint32_t val = (ifp->if_flags & IFF_PROMISC) != 0; nlattr_add_u32(nw, IFLA_PROMISCUITY, val); ifc_dump_ifp_nl(ifp, nw); if (nlmsg_end(nw)) return (true); enomem: NL_LOG(LOG_DEBUG, "unable to dump interface %s state (ENOMEM)", if_name(ifp)); nlmsg_abort(nw); return (false); } static bool check_ifmsg(void *hdr, struct nl_pstate *npt) { struct ifinfomsg *ifm = hdr; if (ifm->__ifi_pad != 0 || ifm->ifi_type != 0 || ifm->ifi_flags != 0 || ifm->ifi_change != 0) { nlmsg_report_err_msg(npt, "strict checking: non-zero values in ifinfomsg header"); return (false); } return (true); } #define _IN(_field) offsetof(struct ifinfomsg, _field) #define _OUT(_field) offsetof(struct nl_parsed_link, _field) static const struct nlfield_parser nlf_p_if[] = { { .off_in = _IN(ifi_type), .off_out = _OUT(ifi_type), .cb = nlf_get_u16 }, { .off_in = _IN(ifi_index), .off_out = _OUT(ifi_index), .cb = nlf_get_u32 }, { .off_in = _IN(ifi_flags), .off_out = _OUT(ifi_flags), .cb = nlf_get_u32 }, { .off_in = _IN(ifi_change), .off_out = _OUT(ifi_change), .cb = nlf_get_u32 }, }; static const struct nlattr_parser nla_p_linfo[] = { { .type = IFLA_INFO_KIND, .off = _OUT(ifla_cloner), .cb = nlattr_get_stringn }, { .type = IFLA_INFO_DATA, .off = _OUT(ifla_idata), .cb = nlattr_get_nla }, }; NL_DECLARE_ATTR_PARSER(linfo_parser, nla_p_linfo); static const struct nlattr_parser nla_p_if[] = { { .type = IFLA_IFNAME, .off = _OUT(ifla_ifname), .cb = nlattr_get_string }, { .type = IFLA_MTU, .off = _OUT(ifla_mtu), .cb = nlattr_get_uint32 }, { .type = IFLA_LINK, .off = _OUT(ifla_link), .cb = nlattr_get_uint32 }, { .type = IFLA_LINKINFO, .arg = &linfo_parser, .cb = nlattr_get_nested }, { .type = IFLA_IFALIAS, .off = _OUT(ifla_ifalias), .cb = nlattr_get_string }, { .type = IFLA_GROUP, .off = _OUT(ifla_group), .cb = nlattr_get_string }, { .type = IFLA_ALT_IFNAME, .off = _OUT(ifla_ifname), .cb = nlattr_get_string }, }; #undef _IN #undef _OUT NL_DECLARE_STRICT_PARSER(ifmsg_parser, struct ifinfomsg, check_ifmsg, nlf_p_if, nla_p_if); static bool match_iface(struct ifnet *ifp, void *_arg) { struct nl_parsed_link *attrs = (struct nl_parsed_link *)_arg; if (attrs->ifi_index != 0 && attrs->ifi_index != ifp->if_index) return (false); if (attrs->ifi_type != 0 && attrs->ifi_index != ifp->if_type) return (false); if (attrs->ifla_ifname != NULL && strcmp(attrs->ifla_ifname, if_name(ifp))) return (false); /* TODO: add group match */ return (true); } static int dump_cb(struct ifnet *ifp, void *_arg) { struct netlink_walkargs *wa = (struct netlink_walkargs *)_arg; if (!dump_iface(wa->nw, ifp, &wa->hdr, 0)) return (ENOMEM); return (0); } /* * {nlmsg_len=52, nlmsg_type=RTM_GETLINK, nlmsg_flags=NLM_F_REQUEST, nlmsg_seq=1662842818, nlmsg_pid=0}, * {ifi_family=AF_PACKET, ifi_type=ARPHRD_NETROM, ifi_index=0, ifi_flags=0, ifi_change=0}, * [ * [{nla_len=10, nla_type=IFLA_IFNAME}, "vnet9"], * [{nla_len=8, nla_type=IFLA_EXT_MASK}, RTEXT_FILTER_VF] * ] */ static int rtnl_handle_getlink(struct nlmsghdr *hdr, struct nlpcb *nlp, struct nl_pstate *npt) { struct epoch_tracker et; struct ifnet *ifp; int error = 0; struct nl_parsed_link attrs = {}; error = nl_parse_nlmsg(hdr, &ifmsg_parser, npt, &attrs); if (error != 0) return (error); struct netlink_walkargs wa = { .so = nlp, .nw = npt->nw, .hdr.nlmsg_pid = hdr->nlmsg_pid, .hdr.nlmsg_seq = hdr->nlmsg_seq, .hdr.nlmsg_flags = hdr->nlmsg_flags, .hdr.nlmsg_type = NL_RTM_NEWLINK, }; /* Fast track for an interface w/ explicit name or index match */ if ((attrs.ifi_index != 0) || (attrs.ifla_ifname != NULL)) { if (attrs.ifi_index != 0) { NLP_LOG(LOG_DEBUG3, nlp, "fast track -> searching index %u", attrs.ifi_index); NET_EPOCH_ENTER(et); ifp = ifnet_byindex_ref(attrs.ifi_index); NET_EPOCH_EXIT(et); } else { NLP_LOG(LOG_DEBUG3, nlp, "fast track -> searching name %s", attrs.ifla_ifname); ifp = ifunit_ref(attrs.ifla_ifname); } if (ifp != NULL) { if (match_iface(ifp, &attrs)) { if (!dump_iface(wa.nw, ifp, &wa.hdr, 0)) error = ENOMEM; } else error = ENODEV; if_rele(ifp); } else error = ENODEV; return (error); } /* Always treat non-direct-match as a multipart message */ wa.hdr.nlmsg_flags |= NLM_F_MULTI; /* * Fetching some link properties require performing ioctl's that may be blocking. * Address it by saving referenced pointers of the matching links, * exiting from epoch and going through the list one-by-one. */ NL_LOG(LOG_DEBUG2, "Start dump"); if_foreach_sleep(match_iface, &attrs, dump_cb, &wa); NL_LOG(LOG_DEBUG2, "End dump, iterated %d dumped %d", wa.count, wa.dumped); if (!nlmsg_end_dump(wa.nw, error, &wa.hdr)) { NL_LOG(LOG_DEBUG, "Unable to finalize the dump"); return (ENOMEM); } return (error); } /* * sendmsg(3, {msg_name={sa_family=AF_NETLINK, nl_pid=0, nl_groups=00000000}, msg_namelen=12, msg_iov=[{iov_base=[ * {nlmsg_len=60, nlmsg_type=RTM_NEWLINK, nlmsg_flags=NLM_F_REQUEST|NLM_F_ACK|NLM_F_EXCL|NLM_F_CREATE, nlmsg_seq=1662715618, nlmsg_pid=0}, * {ifi_family=AF_UNSPEC, ifi_type=ARPHRD_NETROM, ifi_index=0, ifi_flags=0, ifi_change=0}, * {nla_len=11, nla_type=IFLA_IFNAME}, "dummy0"], * [ * {nla_len=16, nla_type=IFLA_LINKINFO}, * [ * {nla_len=9, nla_type=IFLA_INFO_KIND}, "dummy"... * ] * ] */ static int rtnl_handle_dellink(struct nlmsghdr *hdr, struct nlpcb *nlp, struct nl_pstate *npt) { struct epoch_tracker et; struct ifnet *ifp; int error; struct nl_parsed_link attrs = {}; error = nl_parse_nlmsg(hdr, &ifmsg_parser, npt, &attrs); if (error != 0) return (error); NET_EPOCH_ENTER(et); ifp = ifnet_byindex_ref(attrs.ifi_index); NET_EPOCH_EXIT(et); if (ifp == NULL) { NLP_LOG(LOG_DEBUG, nlp, "unable to find interface %u", attrs.ifi_index); return (ENOENT); } NLP_LOG(LOG_DEBUG3, nlp, "mapped ifindex %u to %s", attrs.ifi_index, if_name(ifp)); sx_xlock(&ifnet_detach_sxlock); error = if_clone_destroy(if_name(ifp)); sx_xunlock(&ifnet_detach_sxlock); NLP_LOG(LOG_DEBUG2, nlp, "deleting interface %s returned %d", if_name(ifp), error); if_rele(ifp); return (error); } /* * New link: * type=RTM_NEWLINK, flags=NLM_F_REQUEST|NLM_F_ACK|NLM_F_EXCL|NLM_F_CREATE, seq=1668185590, pid=0}, * {ifi_family=AF_UNSPEC, ifi_type=ARPHRD_NETROM, ifi_index=0, ifi_flags=0, ifi_change=0} * [ * {{nla_len=8, nla_type=IFLA_MTU}, 123}, * {{nla_len=10, nla_type=IFLA_IFNAME}, "vlan1"}, * {{nla_len=24, nla_type=IFLA_LINKINFO}, * [ * {{nla_len=8, nla_type=IFLA_INFO_KIND}, "vlan"...}, * {{nla_len=12, nla_type=IFLA_INFO_DATA}, "\x06\x00\x01\x00\x7b\x00\x00\x00"}]}]} * * Update link: * type=RTM_NEWLINK, flags=NLM_F_REQUEST|NLM_F_ACK, seq=1668185923, pid=0}, * {ifi_family=AF_UNSPEC, ifi_type=ARPHRD_NETROM, ifi_index=if_nametoindex("lo"), ifi_flags=0, ifi_change=0}, * {{nla_len=8, nla_type=IFLA_MTU}, 123}} * * * Check command availability: * type=RTM_NEWLINK, flags=NLM_F_REQUEST|NLM_F_ACK, seq=0, pid=0}, * {ifi_family=AF_UNSPEC, ifi_type=ARPHRD_NETROM, ifi_index=0, ifi_flags=0, ifi_change=0} */ static int create_link(struct nlmsghdr *hdr, struct nl_parsed_link *lattrs, struct nlattr_bmask *bm, struct nlpcb *nlp, struct nl_pstate *npt) { if (lattrs->ifla_ifname == NULL || strlen(lattrs->ifla_ifname) == 0) { NLMSG_REPORT_ERR_MSG(npt, "empty IFLA_IFNAME attribute"); return (EINVAL); } if (lattrs->ifla_cloner == NULL || strlen(lattrs->ifla_cloner) == 0) { NLMSG_REPORT_ERR_MSG(npt, "empty IFLA_INFO_KIND attribute"); return (EINVAL); } struct ifc_data_nl ifd = { .flags = IFC_F_CREATE, .lattrs = lattrs, .bm = bm, .npt = npt, }; if (ifc_create_ifp_nl(lattrs->ifla_ifname, &ifd) && ifd.error == 0) nl_store_ifp_cookie(npt, ifd.ifp); return (ifd.error); } static int modify_link(struct nlmsghdr *hdr, struct nl_parsed_link *lattrs, struct nlattr_bmask *bm, struct nlpcb *nlp, struct nl_pstate *npt) { struct ifnet *ifp = NULL; struct epoch_tracker et; if (lattrs->ifi_index == 0 && lattrs->ifla_ifname == NULL) { /* * Applications like ip(8) verify RTM_NEWLINK command * existence by calling it with empty arguments. Always * return "innocent" error in that case. */ NLMSG_REPORT_ERR_MSG(npt, "empty ifi_index field"); return (EPERM); } if (lattrs->ifi_index != 0) { NET_EPOCH_ENTER(et); ifp = ifnet_byindex_ref(lattrs->ifi_index); NET_EPOCH_EXIT(et); if (ifp == NULL) { NLMSG_REPORT_ERR_MSG(npt, "unable to find interface #%u", lattrs->ifi_index); return (ENOENT); } } if (ifp == NULL && lattrs->ifla_ifname != NULL) { ifp = ifunit_ref(lattrs->ifla_ifname); if (ifp == NULL) { NLMSG_REPORT_ERR_MSG(npt, "unable to find interface %s", lattrs->ifla_ifname); return (ENOENT); } } MPASS(ifp != NULL); /* * Modification request can address either * 1) cloned interface, in which case we call the cloner-specific * modification routine * or * 2) non-cloned (e.g. "physical") interface, in which case we call * generic modification routine */ struct ifc_data_nl ifd = { .lattrs = lattrs, .bm = bm, .npt = npt }; if (!ifc_modify_ifp_nl(ifp, &ifd)) ifd.error = nl_modify_ifp_generic(ifp, lattrs, bm, npt); if_rele(ifp); return (ifd.error); } static int rtnl_handle_newlink(struct nlmsghdr *hdr, struct nlpcb *nlp, struct nl_pstate *npt) { struct nlattr_bmask bm; int error; struct nl_parsed_link attrs = {}; error = nl_parse_nlmsg(hdr, &ifmsg_parser, npt, &attrs); if (error != 0) return (error); nl_get_attrs_bmask_nlmsg(hdr, &ifmsg_parser, &bm); if (hdr->nlmsg_flags & NLM_F_CREATE) return (create_link(hdr, &attrs, &bm, nlp, npt)); else return (modify_link(hdr, &attrs, &bm, nlp, npt)); } +static void +set_scope6(struct sockaddr *sa, uint32_t ifindex) +{ +#ifdef INET6 + if (sa != NULL && sa->sa_family == AF_INET6) { + struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)sa; + + if (IN6_IS_ADDR_LINKLOCAL(&sa6->sin6_addr)) + in6_set_unicast_scopeid(&sa6->sin6_addr, ifindex); + } +#endif +} + +static bool +check_sa_family(const struct sockaddr *sa, int family, const char *attr_name, + struct nl_pstate *npt) +{ + if (sa == NULL || sa->sa_family == family) + return (true); + + nlmsg_report_err_msg(npt, "wrong family for %s attribute: %d != %d", + attr_name, family, sa->sa_family); + return (false); +} + struct nl_parsed_ifa { - uint8_t ifa_family; - uint8_t ifa_prefixlen; - uint8_t ifa_scope; - uint32_t ifa_index; - uint32_t ifa_flags; - struct sockaddr *ifa_address; - struct sockaddr *ifa_local; + uint8_t ifa_family; + uint8_t ifa_prefixlen; + uint8_t ifa_scope; + uint32_t ifa_index; + uint32_t ifa_flags; + uint32_t ifaf_vhid; + uint32_t ifaf_flags; + struct sockaddr *ifa_addr; + struct sockaddr *ifa_dst; + struct sockaddr *ifa_broadcast; + struct ifa_cacheinfo *ifa_cacheinfo; + struct sockaddr *f_ifa_addr; + struct sockaddr *f_ifa_dst; }; +static int +nlattr_get_cinfo(struct nlattr *nla, struct nl_pstate *npt, + const void *arg __unused, void *target) +{ + if (__predict_false(NLA_DATA_LEN(nla) != sizeof(struct ifa_cacheinfo))) { + NLMSG_REPORT_ERR_MSG(npt, "nla type %d size(%u) is not ifa_cacheinfo", + nla->nla_type, NLA_DATA_LEN(nla)); + return (EINVAL); + } + *((struct ifa_cacheinfo **)target) = (struct ifa_cacheinfo *)NL_RTA_DATA(nla); + return (0); +} + #define _IN(_field) offsetof(struct ifaddrmsg, _field) #define _OUT(_field) offsetof(struct nl_parsed_ifa, _field) static const struct nlfield_parser nlf_p_ifa[] = { { .off_in = _IN(ifa_family), .off_out = _OUT(ifa_family), .cb = nlf_get_u8 }, { .off_in = _IN(ifa_prefixlen), .off_out = _OUT(ifa_prefixlen), .cb = nlf_get_u8 }, { .off_in = _IN(ifa_scope), .off_out = _OUT(ifa_scope), .cb = nlf_get_u8 }, { .off_in = _IN(ifa_flags), .off_out = _OUT(ifa_flags), .cb = nlf_get_u8_u32 }, { .off_in = _IN(ifa_index), .off_out = _OUT(ifa_index), .cb = nlf_get_u32 }, }; +static const struct nlattr_parser nla_p_ifa_fbsd[] = { + { .type = IFAF_VHID, .off = _OUT(ifaf_vhid), .cb = nlattr_get_uint32 }, + { .type = IFAF_FLAGS, .off = _OUT(ifaf_flags), .cb = nlattr_get_uint32 }, +}; +NL_DECLARE_ATTR_PARSER(ifa_fbsd_parser, nla_p_ifa_fbsd); + static const struct nlattr_parser nla_p_ifa[] = { - { .type = IFA_ADDRESS, .off = _OUT(ifa_address), .cb = nlattr_get_ip }, - { .type = IFA_LOCAL, .off = _OUT(ifa_local), .cb = nlattr_get_ip }, + { .type = IFA_ADDRESS, .off = _OUT(ifa_addr), .cb = nlattr_get_ip }, + { .type = IFA_LOCAL, .off = _OUT(ifa_dst), .cb = nlattr_get_ip }, + { .type = IFA_BROADCAST, .off = _OUT(ifa_broadcast), .cb = nlattr_get_ip }, + { .type = IFA_CACHEINFO, .off = _OUT(ifa_cacheinfo), .cb = nlattr_get_cinfo }, { .type = IFA_FLAGS, .off = _OUT(ifa_flags), .cb = nlattr_get_uint32 }, + { .type = IFA_FREEBSD, .arg = &ifa_fbsd_parser, .cb = nlattr_get_nested }, }; #undef _IN #undef _OUT -NL_DECLARE_PARSER(ifaddrmsg_parser, struct ifaddrmsg, nlf_p_ifa, nla_p_ifa); + +static bool +post_p_ifa(void *_attrs, struct nl_pstate *npt) +{ + struct nl_parsed_ifa *attrs = (struct nl_parsed_ifa *)_attrs; + + if (!check_sa_family(attrs->ifa_addr, attrs->ifa_family, "IFA_ADDRESS", npt)) + return (false); + if (!check_sa_family(attrs->ifa_dst, attrs->ifa_family, "IFA_LOCAL", npt)) + return (false); + if (!check_sa_family(attrs->ifa_broadcast, attrs->ifa_family, "IFA_BROADADDR", npt)) + return (false); + + set_scope6(attrs->ifa_addr, attrs->ifa_index); + set_scope6(attrs->ifa_dst, attrs->ifa_index); + + /* + * Map the Netlink attributes to FreeBSD ifa layout. + * If only IFA_ADDRESS or IFA_LOCAL is set OR + * both are set to the same value => ifa is not broadcast + * and the attribute value contains interface address. + * + * Otherwise (both IFA_ADDRESS and IFA_LOCAL are set and + * different), IFA_LOCAL contains an interface address and + * IFA_ADDRESS contains peer address. + */ + struct sockaddr *addr, *dst; + + addr = attrs->ifa_addr; + if ((dst = attrs->ifa_dst) != NULL) { + if (addr != NULL && !sa_equal(addr, dst)) { + /* Ptp address */ + attrs->ifa_addr = dst; + attrs->ifa_dst = addr; + } else { + attrs->ifa_addr = dst; + attrs->ifa_dst = NULL; + } + } + + return (true); +} + +NL_DECLARE_PARSER_EXT(ifa_parser, struct ifaddrmsg, NULL, nlf_p_ifa, nla_p_ifa, post_p_ifa); /* {ifa_family=AF_INET, ifa_prefixlen=8, ifa_flags=IFA_F_PERMANENT, ifa_scope=RT_SCOPE_HOST, ifa_index=if_nametoindex("lo")}, [ {{nla_len=8, nla_type=IFA_ADDRESS}, inet_addr("127.0.0.1")}, {{nla_len=8, nla_type=IFA_LOCAL}, inet_addr("127.0.0.1")}, {{nla_len=7, nla_type=IFA_LABEL}, "lo"}, {{nla_len=8, nla_type=IFA_FLAGS}, IFA_F_PERMANENT}, {{nla_len=20, nla_type=IFA_CACHEINFO}, {ifa_prefered=4294967295, ifa_valid=4294967295, cstamp=3619, tstamp=3619}}]}, --- {{len=72, type=RTM_NEWADDR, flags=NLM_F_MULTI, seq=1642191126, pid=566735}, {ifa_family=AF_INET6, ifa_prefixlen=96, ifa_flags=IFA_F_PERMANENT, ifa_scope=RT_SCOPE_UNIVERSE, ifa_index=if_nametoindex("virbr0")}, [ {{nla_len=20, nla_type=IFA_ADDRESS}, inet_pton(AF_INET6, "2a01:4f8:13a:70c:ffff::1")}, {{nla_len=20, nla_type=IFA_CACHEINFO}, {ifa_prefered=4294967295, ifa_valid=4294967295, cstamp=4283, tstamp=4283}}, {{nla_len=8, nla_type=IFA_FLAGS}, IFA_F_PERMANENT}]}, */ static uint8_t ifa_get_scope(const struct ifaddr *ifa) { const struct sockaddr *sa; uint8_t addr_scope = RT_SCOPE_UNIVERSE; sa = ifa->ifa_addr; switch (sa->sa_family) { #ifdef INET case AF_INET: { struct in_addr addr; addr = ((const struct sockaddr_in *)sa)->sin_addr; if (IN_LOOPBACK(addr.s_addr)) addr_scope = RT_SCOPE_HOST; else if (IN_LINKLOCAL(addr.s_addr)) addr_scope = RT_SCOPE_LINK; break; } #endif #ifdef INET6 case AF_INET6: { const struct in6_addr *addr; addr = &((const struct sockaddr_in6 *)sa)->sin6_addr; if (IN6_IS_ADDR_LOOPBACK(addr)) addr_scope = RT_SCOPE_HOST; else if (IN6_IS_ADDR_LINKLOCAL(addr)) addr_scope = RT_SCOPE_LINK; break; } #endif } return (addr_scope); } #ifdef INET6 static uint8_t inet6_get_plen(const struct in6_addr *addr) { return (bitcount32(addr->s6_addr32[0]) + bitcount32(addr->s6_addr32[1]) + bitcount32(addr->s6_addr32[2]) + bitcount32(addr->s6_addr32[3])); } #endif static uint8_t get_sa_plen(const struct sockaddr *sa) { #ifdef INET const struct in_addr *paddr; #endif #ifdef INET6 const struct in6_addr *paddr6; #endif switch (sa->sa_family) { #ifdef INET case AF_INET: paddr = &(((const struct sockaddr_in *)sa)->sin_addr); return bitcount32(paddr->s_addr);; #endif #ifdef INET6 case AF_INET6: paddr6 = &(((const struct sockaddr_in6 *)sa)->sin6_addr); return inet6_get_plen(paddr6); #endif } return (0); } #ifdef INET6 static uint32_t in6_flags_to_nl(uint32_t flags) { uint32_t nl_flags = 0; if (flags & IN6_IFF_TEMPORARY) nl_flags |= IFA_F_TEMPORARY; if (flags & IN6_IFF_NODAD) nl_flags |= IFA_F_NODAD; if (flags & IN6_IFF_DEPRECATED) nl_flags |= IFA_F_DEPRECATED; if (flags & IN6_IFF_TENTATIVE) nl_flags |= IFA_F_TENTATIVE; if ((flags & (IN6_IFF_AUTOCONF|IN6_IFF_TEMPORARY)) == 0) flags |= IFA_F_PERMANENT; if (flags & IN6_IFF_DUPLICATED) flags |= IFA_F_DADFAILED; return (nl_flags); } +static uint32_t +nl_flags_to_in6(uint32_t flags) +{ + uint32_t in6_flags = 0; + + if (flags & IFA_F_TEMPORARY) + in6_flags |= IN6_IFF_TEMPORARY; + if (flags & IFA_F_NODAD) + in6_flags |= IN6_IFF_NODAD; + if (flags & IFA_F_DEPRECATED) + in6_flags |= IN6_IFF_DEPRECATED; + if (flags & IFA_F_TENTATIVE) + in6_flags |= IN6_IFF_TENTATIVE; + if (flags & IFA_F_DADFAILED) + in6_flags |= IN6_IFF_DUPLICATED; + + return (in6_flags); +} + static void export_cache_info6(struct nl_writer *nw, const struct in6_ifaddr *ia) { struct ifa_cacheinfo ci = { .cstamp = ia->ia6_createtime * 1000, .tstamp = ia->ia6_updatetime * 1000, .ifa_prefered = ia->ia6_lifetime.ia6t_pltime, .ifa_valid = ia->ia6_lifetime.ia6t_vltime, }; nlattr_add(nw, IFA_CACHEINFO, sizeof(ci), &ci); } #endif static void export_cache_info(struct nl_writer *nw, struct ifaddr *ifa) { switch (ifa->ifa_addr->sa_family) { #ifdef INET6 case AF_INET6: export_cache_info6(nw, (struct in6_ifaddr *)ifa); break; #endif } } /* * {'attrs': [('IFA_ADDRESS', '12.0.0.1'), ('IFA_LOCAL', '12.0.0.1'), ('IFA_LABEL', 'eth10'), ('IFA_FLAGS', 128), ('IFA_CACHEINFO', {'ifa_preferred': 4294967295, 'ifa_valid': 4294967295, 'cstamp': 63745746, 'tstamp': 63745746})], */ static bool dump_iface_addr(struct nl_writer *nw, struct ifnet *ifp, struct ifaddr *ifa, const struct nlmsghdr *hdr) { struct ifaddrmsg *ifamsg; struct sockaddr *sa = ifa->ifa_addr; + struct sockaddr *sa_dst = ifa->ifa_dstaddr; NL_LOG(LOG_DEBUG3, "dumping ifa %p type %s(%d) for interface %s", ifa, rib_print_family(sa->sa_family), sa->sa_family, if_name(ifp)); if (!nlmsg_reply(nw, hdr, sizeof(struct ifaddrmsg))) goto enomem; ifamsg = nlmsg_reserve_object(nw, struct ifaddrmsg); ifamsg->ifa_family = sa->sa_family; ifamsg->ifa_prefixlen = get_sa_plen(ifa->ifa_netmask); ifamsg->ifa_flags = 0; // ifa_flags is useless ifamsg->ifa_scope = ifa_get_scope(ifa); ifamsg->ifa_index = ifp->if_index; - if (ifp->if_flags & IFF_POINTOPOINT) { - dump_sa(nw, IFA_ADDRESS, ifa->ifa_dstaddr); + if ((ifp->if_flags & IFF_POINTOPOINT) && sa_dst != NULL && sa_dst->sa_family != 0) { + /* P2P interface may have IPv6 LL with no dst address */ + dump_sa(nw, IFA_ADDRESS, sa_dst); dump_sa(nw, IFA_LOCAL, sa); } else { dump_sa(nw, IFA_ADDRESS, sa); #ifdef INET /* * In most cases, IFA_ADDRESS == IFA_LOCAL * Skip IFA_LOCAL for anything except INET */ if (sa->sa_family == AF_INET) dump_sa(nw, IFA_LOCAL, sa); #endif } if (ifp->if_flags & IFF_BROADCAST) dump_sa(nw, IFA_BROADCAST, ifa->ifa_broadaddr); nlattr_add_string(nw, IFA_LABEL, if_name(ifp)); uint32_t nl_ifa_flags = 0; #ifdef INET6 if (sa->sa_family == AF_INET6) { struct in6_ifaddr *ia = (struct in6_ifaddr *)ifa; nl_ifa_flags = in6_flags_to_nl(ia->ia6_flags); } #endif nlattr_add_u32(nw, IFA_FLAGS, nl_ifa_flags); export_cache_info(nw, ifa); /* Store FreeBSD-specific attributes */ int off = nlattr_add_nested(nw, IFA_FREEBSD); if (off != 0) { if (ifa->ifa_carp != NULL && carp_get_vhid_p != NULL) { uint32_t vhid = (uint32_t)(*carp_get_vhid_p)(ifa); nlattr_add_u32(nw, IFAF_VHID, vhid); } #ifdef INET6 if (sa->sa_family == AF_INET6) { uint32_t ifa_flags = ((struct in6_ifaddr *)ifa)->ia6_flags; nlattr_add_u32(nw, IFAF_FLAGS, ifa_flags); } #endif nlattr_set_len(nw, off); } if (nlmsg_end(nw)) return (true); enomem: NL_LOG(LOG_DEBUG, "Failed to dump ifa type %s(%d) for interface %s", rib_print_family(sa->sa_family), sa->sa_family, if_name(ifp)); nlmsg_abort(nw); return (false); } static int dump_iface_addrs(struct netlink_walkargs *wa, struct ifnet *ifp) { struct ifaddr *ifa; CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { if (wa->family != 0 && wa->family != ifa->ifa_addr->sa_family) continue; if (ifa->ifa_addr->sa_family == AF_LINK) continue; if (prison_if(wa->cred, ifa->ifa_addr) != 0) continue; wa->count++; if (!dump_iface_addr(wa->nw, ifp, ifa, &wa->hdr)) return (ENOMEM); wa->dumped++; } return (0); } static int rtnl_handle_getaddr(struct nlmsghdr *hdr, struct nlpcb *nlp, struct nl_pstate *npt) { struct ifnet *ifp; int error = 0; struct nl_parsed_ifa attrs = {}; - error = nl_parse_nlmsg(hdr, &ifaddrmsg_parser, npt, &attrs); + error = nl_parse_nlmsg(hdr, &ifa_parser, npt, &attrs); if (error != 0) return (error); struct netlink_walkargs wa = { .so = nlp, .nw = npt->nw, .cred = nlp_get_cred(nlp), .family = attrs.ifa_family, .hdr.nlmsg_pid = hdr->nlmsg_pid, .hdr.nlmsg_seq = hdr->nlmsg_seq, .hdr.nlmsg_flags = hdr->nlmsg_flags | NLM_F_MULTI, .hdr.nlmsg_type = NL_RTM_NEWADDR, }; NL_LOG(LOG_DEBUG2, "Start dump"); if (attrs.ifa_index != 0) { ifp = ifnet_byindex(attrs.ifa_index); if (ifp == NULL) error = ENOENT; else error = dump_iface_addrs(&wa, ifp); } else { CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link) { error = dump_iface_addrs(&wa, ifp); if (error != 0) break; } } NL_LOG(LOG_DEBUG2, "End dump, iterated %d dumped %d", wa.count, wa.dumped); if (!nlmsg_end_dump(wa.nw, error, &wa.hdr)) { NL_LOG(LOG_DEBUG, "Unable to finalize the dump"); return (ENOMEM); } return (error); } +#ifdef INET +static int +handle_newaddr_inet(struct nlmsghdr *hdr, struct nl_parsed_ifa *attrs, + struct ifnet *ifp, struct nlpcb *nlp, struct nl_pstate *npt) +{ + if (attrs->ifa_prefixlen > 32) { + nlmsg_report_err_msg(npt, "invalid ifa_prefixlen"); + return (EINVAL); + }; + + int if_flags = if_getflags(ifp); + + if (if_flags & IFF_POINTOPOINT) { + if (attrs->ifa_addr == NULL || attrs->ifa_dst == NULL) { + nlmsg_report_err_msg(npt, "Empty IFA_LOCAL/IFA_ADDRESS"); + return (EINVAL); + } + } else { + if (attrs->ifa_addr == NULL) { + nlmsg_report_err_msg(npt, "Empty IFA_LOCAL/IFA_ADDRESS"); + return (EINVAL); + } + attrs->ifa_dst = attrs->ifa_broadcast; + + if (attrs->ifa_dst == NULL && !(if_flags & IFF_LOOPBACK)) { + nlmsg_report_err_msg(npt, "empty IFA_BROADCAST for BRD interface"); + return (EINVAL); + } + } + + int plen = attrs->ifa_prefixlen; + struct sockaddr_in mask = { + .sin_len = sizeof(struct sockaddr_in), + .sin_family = AF_INET, + .sin_addr.s_addr = htonl(plen ? ~((1 << (32 - plen)) - 1) : 0), + }; + struct in_aliasreq req = { + .ifra_addr = *((struct sockaddr_in *)attrs->ifa_addr), + .ifra_mask = mask, + .ifra_vhid = attrs->ifaf_vhid, + }; + if (attrs->ifa_dst != NULL) + req.ifra_dstaddr = *((struct sockaddr_in *)attrs->ifa_dst); + + return (in_control(NULL, SIOCAIFADDR, &req, ifp, curthread)); +} + +static int +handle_deladdr_inet(struct nlmsghdr *hdr, struct nl_parsed_ifa *attrs, + struct ifnet *ifp, struct nlpcb *nlp, struct nl_pstate *npt) +{ + if (attrs->ifa_addr == NULL) { + nlmsg_report_err_msg(npt, "empty IFA_ADDRESS/IFA_LOCAL"); + return (EINVAL); + } + + struct in_aliasreq req = { + .ifra_addr = *((struct sockaddr_in *)attrs->ifa_addr), + }; + + return (in_control(NULL, SIOCDIFADDR, &req, ifp, curthread)); +} +#endif + +#ifdef INET6 +static int +handle_newaddr_inet6(struct nlmsghdr *hdr, struct nl_parsed_ifa *attrs, + struct ifnet *ifp, struct nlpcb *nlp, struct nl_pstate *npt) +{ + if (attrs->ifa_prefixlen > 128) { + nlmsg_report_err_msg(npt, "invalid ifa_prefixlen"); + return (EINVAL); + } + + if (attrs->ifa_addr == NULL) { + nlmsg_report_err_msg(npt, "Empty IFA_LOCAL/IFA_ADDRESS"); + return (EINVAL); + } + + /* TODO: Clarify addition of prefixes on p2p interfaces w/o ifa_dst */ + + uint32_t flags = nl_flags_to_in6(attrs->ifa_flags) | attrs->ifaf_flags; + + uint32_t pltime = 0, vltime = 0; + if (attrs->ifa_cacheinfo != 0) { + pltime = attrs->ifa_cacheinfo->ifa_prefered; + vltime = attrs->ifa_cacheinfo->ifa_valid; + } + + struct sockaddr_in6 mask = { + .sin6_len = sizeof(struct sockaddr_in6), + .sin6_family = AF_INET6, + }; + ip6_writemask(&mask.sin6_addr, attrs->ifa_prefixlen); + + struct in6_aliasreq req = { + .ifra_addr = *((struct sockaddr_in6 *)attrs->ifa_addr), + .ifra_prefixmask = mask, + .ifra_flags = flags, + .ifra_lifetime = { .ia6t_vltime = vltime, .ia6t_pltime = pltime }, + .ifra_vhid = attrs->ifaf_vhid, + }; + if (attrs->ifa_dst != NULL) + req.ifra_dstaddr = *((struct sockaddr_in6 *)attrs->ifa_dst); + + return (in6_control(NULL, SIOCAIFADDR_IN6, &req, ifp, curthread)); +} + +static int +handle_deladdr_inet6(struct nlmsghdr *hdr, struct nl_parsed_ifa *attrs, + struct ifnet *ifp, struct nlpcb *nlp, struct nl_pstate *npt) +{ + if (attrs->ifa_addr == NULL) { + nlmsg_report_err_msg(npt, "Empty IFA_LOCAL/IFA_ADDRESS"); + return (EINVAL); + } + + struct in6_aliasreq req = { + .ifra_addr = *((struct sockaddr_in6 *)attrs->ifa_addr), + }; + + return (in6_control(NULL, SIOCDIFADDR_IN6, &req, ifp, curthread)); +} +#endif + + +static int +rtnl_handle_addr(struct nlmsghdr *hdr, struct nlpcb *nlp, struct nl_pstate *npt) +{ + struct epoch_tracker et; + int error; + + struct nl_parsed_ifa attrs = {}; + error = nl_parse_nlmsg(hdr, &ifa_parser, npt, &attrs); + if (error != 0) + return (error); + + NET_EPOCH_ENTER(et); + struct ifnet *ifp = ifnet_byindex_ref(attrs.ifa_index); + NET_EPOCH_EXIT(et); + + if (ifp == NULL) { + nlmsg_report_err_msg(npt, "Unable to find interface with index %u", + attrs.ifa_index); + return (ENOENT); + } + + bool new = hdr->nlmsg_type == NL_RTM_NEWADDR; + + /* + * TODO: Properly handle NLM_F_CREATE / NLM_F_EXCL. + * The current ioctl-based KPI always does an implicit create-or-replace. + * It is not possible to specify fine-grained options. + */ + + switch (attrs.ifa_family) { +#ifdef INET + case AF_INET: + if (new) + error = handle_newaddr_inet(hdr, &attrs, ifp, nlp, npt); + else + error = handle_deladdr_inet(hdr, &attrs, ifp, nlp, npt); + break; +#endif +#ifdef INET6 + case AF_INET6: + if (new) + error = handle_newaddr_inet6(hdr, &attrs, ifp, nlp, npt); + else + error = handle_deladdr_inet6(hdr, &attrs, ifp, nlp, npt); + break; +#endif + default: + error = EAFNOSUPPORT; + } + + if_rele(ifp); + + return (error); +} + + static void rtnl_handle_ifaddr(void *arg __unused, struct ifaddr *ifa, int cmd) { struct nlmsghdr hdr = {}; struct nl_writer nw = {}; uint32_t group = 0; switch (ifa->ifa_addr->sa_family) { #ifdef INET case AF_INET: group = RTNLGRP_IPV4_IFADDR; break; #endif #ifdef INET6 case AF_INET6: group = RTNLGRP_IPV6_IFADDR; break; #endif default: NL_LOG(LOG_DEBUG2, "ifa notification for unknown AF: %d", ifa->ifa_addr->sa_family); return; } if (!nl_has_listeners(NETLINK_ROUTE, group)) return; if (!nlmsg_get_group_writer(&nw, NLMSG_LARGE, NETLINK_ROUTE, group)) { NL_LOG(LOG_DEBUG, "error allocating group writer"); return; } hdr.nlmsg_type = (cmd == RTM_DELETE) ? NL_RTM_DELADDR : NL_RTM_NEWADDR; dump_iface_addr(&nw, ifa->ifa_ifp, ifa, &hdr); nlmsg_flush(&nw); } static void rtnl_handle_ifevent(struct ifnet *ifp, int nlmsg_type, int if_flags_mask) { struct nlmsghdr hdr = { .nlmsg_type = nlmsg_type }; struct nl_writer nw = {}; if (!nl_has_listeners(NETLINK_ROUTE, RTNLGRP_LINK)) return; if (!nlmsg_get_group_writer(&nw, NLMSG_LARGE, NETLINK_ROUTE, RTNLGRP_LINK)) { NL_LOG(LOG_DEBUG, "error allocating mbuf"); return; } dump_iface(&nw, ifp, &hdr, if_flags_mask); nlmsg_flush(&nw); } static void rtnl_handle_ifattach(void *arg, struct ifnet *ifp) { NL_LOG(LOG_DEBUG2, "ifnet %s", if_name(ifp)); rtnl_handle_ifevent(ifp, NL_RTM_NEWLINK, 0); } static void rtnl_handle_ifdetach(void *arg, struct ifnet *ifp) { NL_LOG(LOG_DEBUG2, "ifnet %s", if_name(ifp)); rtnl_handle_ifevent(ifp, NL_RTM_DELLINK, 0); } static void rtnl_handle_iflink(void *arg, struct ifnet *ifp) { NL_LOG(LOG_DEBUG2, "ifnet %s", if_name(ifp)); rtnl_handle_ifevent(ifp, NL_RTM_NEWLINK, 0); } void rtnl_handle_ifnet_event(struct ifnet *ifp, int if_flags_mask) { NL_LOG(LOG_DEBUG2, "ifnet %s", if_name(ifp)); rtnl_handle_ifevent(ifp, NL_RTM_NEWLINK, if_flags_mask); } static const struct rtnl_cmd_handler cmd_handlers[] = { { .cmd = NL_RTM_GETLINK, .name = "RTM_GETLINK", .cb = &rtnl_handle_getlink, .flags = RTNL_F_NOEPOCH | RTNL_F_ALLOW_NONVNET_JAIL, }, { .cmd = NL_RTM_DELLINK, .name = "RTM_DELLINK", .cb = &rtnl_handle_dellink, .priv = PRIV_NET_IFDESTROY, .flags = RTNL_F_NOEPOCH, }, { .cmd = NL_RTM_NEWLINK, .name = "RTM_NEWLINK", .cb = &rtnl_handle_newlink, .priv = PRIV_NET_IFCREATE, .flags = RTNL_F_NOEPOCH, }, { .cmd = NL_RTM_GETADDR, .name = "RTM_GETADDR", .cb = &rtnl_handle_getaddr, .flags = RTNL_F_ALLOW_NONVNET_JAIL, }, { .cmd = NL_RTM_NEWADDR, .name = "RTM_NEWADDR", - .cb = &rtnl_handle_getaddr, + .cb = &rtnl_handle_addr, + .priv = PRIV_NET_ADDIFADDR, + .flags = RTNL_F_NOEPOCH, }, { .cmd = NL_RTM_DELADDR, .name = "RTM_DELADDR", - .cb = &rtnl_handle_getaddr, + .cb = &rtnl_handle_addr, + .priv = PRIV_NET_DELIFADDR, + .flags = RTNL_F_NOEPOCH, }, }; -static const struct nlhdr_parser *all_parsers[] = { &ifmsg_parser, &ifaddrmsg_parser }; +static const struct nlhdr_parser *all_parsers[] = { + &ifmsg_parser, &ifa_parser, &ifa_fbsd_parser, +}; void rtnl_iface_add_cloner(struct nl_cloner *cloner) { sx_xlock(&rtnl_cloner_lock); SLIST_INSERT_HEAD(&nl_cloners, cloner, next); sx_xunlock(&rtnl_cloner_lock); } void rtnl_iface_del_cloner(struct nl_cloner *cloner) { sx_xlock(&rtnl_cloner_lock); SLIST_REMOVE(&nl_cloners, cloner, nl_cloner, next); sx_xunlock(&rtnl_cloner_lock); } void rtnl_ifaces_init(void) { ifattach_event = EVENTHANDLER_REGISTER( ifnet_arrival_event, rtnl_handle_ifattach, NULL, EVENTHANDLER_PRI_ANY); ifdetach_event = EVENTHANDLER_REGISTER( ifnet_departure_event, rtnl_handle_ifdetach, NULL, EVENTHANDLER_PRI_ANY); ifaddr_event = EVENTHANDLER_REGISTER( rt_addrmsg, rtnl_handle_ifaddr, NULL, EVENTHANDLER_PRI_ANY); iflink_event = EVENTHANDLER_REGISTER( ifnet_link_event, rtnl_handle_iflink, NULL, EVENTHANDLER_PRI_ANY); NL_VERIFY_PARSERS(all_parsers); rtnl_register_messages(cmd_handlers, NL_ARRAY_LEN(cmd_handlers)); } void rtnl_ifaces_destroy(void) { EVENTHANDLER_DEREGISTER(ifnet_arrival_event, ifattach_event); EVENTHANDLER_DEREGISTER(ifnet_departure_event, ifdetach_event); EVENTHANDLER_DEREGISTER(rt_addrmsg, ifaddr_event); EVENTHANDLER_DEREGISTER(ifnet_link_event, iflink_event); } diff --git a/sys/netlink/route/ifaddrs.h b/sys/netlink/route/ifaddrs.h index 29973d9768e5..88d776c3b925 100644 --- a/sys/netlink/route/ifaddrs.h +++ b/sys/netlink/route/ifaddrs.h @@ -1,99 +1,99 @@ /*- * SPDX-License-Identifier: BSD-2-Clause * * Copyright (c) 2022 Alexander V. Chernikov * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Interface address-related (RTM_ADDR) message header and attributes. */ #ifndef _NETLINK_ROUTE_IFADDRS_H_ #define _NETLINK_ROUTE_IFADDRS_H_ /* Base header for all of the relevant messages */ struct ifaddrmsg { uint8_t ifa_family; /* Address family */ uint8_t ifa_prefixlen; /* Prefix length */ uint8_t ifa_flags; /* Address-specific flags */ uint8_t ifa_scope; /* Address scope */ uint32_t ifa_index; /* Link ifindex */ }; #ifndef _KERNEL #define _NL_IFA_HDRLEN ((int)sizeof(struct ifaddrmsg)) #define IFA_RTA(_ifa) ((struct rtattr *)(NL_ITEM_DATA(_ifa, _NL_IFA_HDRLEN))) #define IFA_PAYLOAD(_hdr) NLMSG_PAYLOAD(_hdr, _NL_IFA_HDRLEN) #endif /* Defined attributes */ enum { IFA_UNSPEC, IFA_ADDRESS = 1, /* binary, prefix address (destination for p2p) */ IFA_LOCAL = 2, /* binary, interface address */ IFA_LABEL = 3, /* string, interface name */ IFA_BROADCAST = 4, /* binary, broadcast ifa */ IFA_ANYCAST = 5, /* not supported */ - IFA_CACHEINFO = 6, /* not supported */ + IFA_CACHEINFO = 6, /* binary, struct ifa_cacheinfo */ IFA_MULTICAST = 7, /* not supported */ - IFA_FLAGS = 8, /* not supported */ + IFA_FLAGS = 8, /* u32, IFA_F flags */ IFA_RT_PRIORITY = 9, /* not supported */ IFA_TARGET_NETNSID = 10, /* not supported */ IFA_FREEBSD = 11, /* nested, FreeBSD-specific */ __IFA_MAX, }; #define IFA_MAX (__IFA_MAX - 1) enum { IFAF_UNSPEC, IFAF_VHID = 1, /* u32: carp vhid */ IFAF_FLAGS = 2, /* u32: FreeBSD-specific ifa flags */ __IFAF_MAX, }; #define IFAF_MAX (__IFAF_MAX - 1) /* IFA_FLAGS attribute flags */ #define IFA_F_SECONDARY 0x0001 #define IFA_F_TEMPORARY IFA_F_SECONDARY #define IFA_F_NODAD 0x0002 #define IFA_F_OPTIMISTIC 0x0004 #define IFA_F_DADFAILED 0x0008 #define IFA_F_HOMEADDRESS 0x0010 #define IFA_F_DEPRECATED 0x0020 #define IFA_F_TENTATIVE 0x0040 #define IFA_F_PERMANENT 0x0080 #define IFA_F_MANAGETEMPADDR 0x0100 #define IFA_F_NOPREFIXROUTE 0x0200 #define IFA_F_MCAUTOJOIN 0x0400 #define IFA_F_STABLE_PRIVACY 0x0800 /* IFA_CACHEINFO value */ struct ifa_cacheinfo { uint32_t ifa_prefered; /* seconds till the end of the prefix considered preferred */ uint32_t ifa_valid; /* seconds till the end of the prefix considered valid */ uint32_t cstamp; /* creation time in 1ms intervals from the boot time */ uint32_t tstamp; /* update time in 1ms intervals from the boot time */ }; #endif diff --git a/tests/atf_python/sys/netlink/netlink_route.py b/tests/atf_python/sys/netlink/netlink_route.py index cd3ffbe31a00..2cfeb57da13f 100644 --- a/tests/atf_python/sys/netlink/netlink_route.py +++ b/tests/atf_python/sys/netlink/netlink_route.py @@ -1,739 +1,832 @@ import socket import struct from ctypes import c_int from ctypes import c_ubyte from ctypes import c_uint from ctypes import c_ushort from ctypes import sizeof from ctypes import Structure from enum import auto from enum import Enum from atf_python.sys.netlink.attrs import NlAttr from atf_python.sys.netlink.attrs import NlAttrIp from atf_python.sys.netlink.attrs import NlAttrNested from atf_python.sys.netlink.attrs import NlAttrStr from atf_python.sys.netlink.attrs import NlAttrU32 from atf_python.sys.netlink.attrs import NlAttrU8 from atf_python.sys.netlink.message import StdNetlinkMessage from atf_python.sys.netlink.message import NlMsgProps from atf_python.sys.netlink.message import NlMsgCategory from atf_python.sys.netlink.utils import AttrDescr from atf_python.sys.netlink.utils import get_bitmask_str from atf_python.sys.netlink.utils import prepare_attrs_map class RtattrType(Enum): RTA_UNSPEC = 0 RTA_DST = 1 RTA_SRC = 2 RTA_IIF = 3 RTA_OIF = 4 RTA_GATEWAY = 5 RTA_PRIORITY = 6 RTA_PREFSRC = 7 RTA_METRICS = 8 RTA_MULTIPATH = 9 # RTA_PROTOINFO = 10 RTA_KNH_ID = 10 RTA_FLOW = 11 RTA_CACHEINFO = 12 RTA_SESSION = 13 # RTA_MP_ALGO = 14 RTA_RTFLAGS = 14 RTA_TABLE = 15 RTA_MARK = 16 RTA_MFC_STATS = 17 RTA_VIA = 18 RTA_NEWDST = 19 RTA_PREF = 20 RTA_ENCAP_TYPE = 21 RTA_ENCAP = 22 RTA_EXPIRES = 23 RTA_PAD = 24 RTA_UID = 25 RTA_TTL_PROPAGATE = 26 RTA_IP_PROTO = 27 RTA_SPORT = 28 RTA_DPORT = 29 RTA_NH_ID = 30 class NlRtMsgType(Enum): RTM_NEWLINK = 16 RTM_DELLINK = 17 RTM_GETLINK = 18 RTM_SETLINK = 19 RTM_NEWADDR = 20 RTM_DELADDR = 21 RTM_GETADDR = 22 RTM_NEWROUTE = 24 RTM_DELROUTE = 25 RTM_GETROUTE = 26 RTM_NEWNEIGH = 28 RTM_DELNEIGH = 29 RTM_GETNEIGH = 30 RTM_NEWRULE = 32 RTM_DELRULE = 33 RTM_GETRULE = 34 RTM_NEWQDISC = 36 RTM_DELQDISC = 37 RTM_GETQDISC = 38 RTM_NEWTCLASS = 40 RTM_DELTCLASS = 41 RTM_GETTCLASS = 42 RTM_NEWTFILTER = 44 RTM_DELTFILTER = 45 RTM_GETTFILTER = 46 RTM_NEWACTION = 48 RTM_DELACTION = 49 RTM_GETACTION = 50 RTM_NEWPREFIX = 52 RTM_GETMULTICAST = 58 RTM_GETANYCAST = 62 RTM_NEWNEIGHTBL = 64 RTM_GETNEIGHTBL = 66 RTM_SETNEIGHTBL = 67 RTM_NEWNDUSEROPT = 68 RTM_NEWADDRLABEL = 72 RTM_DELADDRLABEL = 73 RTM_GETADDRLABEL = 74 RTM_GETDCB = 78 RTM_SETDCB = 79 RTM_NEWNETCONF = 80 RTM_GETNETCONF = 82 RTM_NEWMDB = 84 RTM_DELMDB = 85 RTM_GETMDB = 86 RTM_NEWNSID = 88 RTM_DELNSID = 89 RTM_GETNSID = 90 RTM_NEWSTATS = 92 RTM_GETSTATS = 94 class RtAttr(Structure): _fields_ = [ ("rta_len", c_ushort), ("rta_type", c_ushort), ] class RtMsgHdr(Structure): _fields_ = [ ("rtm_family", c_ubyte), ("rtm_dst_len", c_ubyte), ("rtm_src_len", c_ubyte), ("rtm_tos", c_ubyte), ("rtm_table", c_ubyte), ("rtm_protocol", c_ubyte), ("rtm_scope", c_ubyte), ("rtm_type", c_ubyte), ("rtm_flags", c_uint), ] class RtMsgFlags(Enum): RTM_F_NOTIFY = 0x100 RTM_F_CLONED = 0x200 RTM_F_EQUALIZE = 0x400 RTM_F_PREFIX = 0x800 RTM_F_LOOKUP_TABLE = 0x1000 RTM_F_FIB_MATCH = 0x2000 RTM_F_OFFLOAD = 0x4000 RTM_F_TRAP = 0x8000 RTM_F_OFFLOAD_FAILED = 0x20000000 class RtScope(Enum): RT_SCOPE_UNIVERSE = 0 RT_SCOPE_SITE = 200 RT_SCOPE_LINK = 253 RT_SCOPE_HOST = 254 RT_SCOPE_NOWHERE = 255 class RtType(Enum): RTN_UNSPEC = 0 RTN_UNICAST = auto() RTN_LOCAL = auto() RTN_BROADCAST = auto() RTN_ANYCAST = auto() RTN_MULTICAST = auto() RTN_BLACKHOLE = auto() RTN_UNREACHABLE = auto() RTN_PROHIBIT = auto() RTN_THROW = auto() RTN_NAT = auto() RTN_XRESOLVE = auto() class RtProto(Enum): RTPROT_UNSPEC = 0 RTPROT_REDIRECT = 1 RTPROT_KERNEL = 2 RTPROT_BOOT = 3 RTPROT_STATIC = 4 RTPROT_GATED = 8 RTPROT_RA = 9 RTPROT_MRT = 10 RTPROT_ZEBRA = 11 RTPROT_BIRD = 12 RTPROT_DNROUTED = 13 RTPROT_XORP = 14 RTPROT_NTK = 15 RTPROT_DHCP = 16 RTPROT_MROUTED = 17 RTPROT_KEEPALIVED = 18 RTPROT_BABEL = 42 RTPROT_OPENR = 99 RTPROT_BGP = 186 RTPROT_ISIS = 187 RTPROT_OSPF = 188 RTPROT_RIP = 189 RTPROT_EIGRP = 192 class NlRtaxType(Enum): RTAX_UNSPEC = 0 RTAX_LOCK = auto() RTAX_MTU = auto() RTAX_WINDOW = auto() RTAX_RTT = auto() RTAX_RTTVAR = auto() RTAX_SSTHRESH = auto() RTAX_CWND = auto() RTAX_ADVMSS = auto() RTAX_REORDERING = auto() RTAX_HOPLIMIT = auto() RTAX_INITCWND = auto() RTAX_FEATURES = auto() RTAX_RTO_MIN = auto() RTAX_INITRWND = auto() RTAX_QUICKACK = auto() RTAX_CC_ALGO = auto() RTAX_FASTOPEN_NO_COOKIE = auto() class RtFlagsBSD(Enum): RTF_UP = 0x1 RTF_GATEWAY = 0x2 RTF_HOST = 0x4 RTF_REJECT = 0x8 RTF_DYNAMIC = 0x10 RTF_MODIFIED = 0x20 RTF_DONE = 0x40 RTF_XRESOLVE = 0x200 RTF_LLINFO = 0x400 RTF_LLDATA = 0x400 RTF_STATIC = 0x800 RTF_BLACKHOLE = 0x1000 RTF_PROTO2 = 0x4000 RTF_PROTO1 = 0x8000 RTF_PROTO3 = 0x40000 RTF_FIXEDMTU = 0x80000 RTF_PINNED = 0x100000 RTF_LOCAL = 0x200000 RTF_BROADCAST = 0x400000 RTF_MULTICAST = 0x800000 RTF_STICKY = 0x10000000 RTF_RNH_LOCKED = 0x40000000 RTF_GWFLAG_COMPAT = 0x80000000 class NlRtGroup(Enum): RTNLGRP_NONE = 0 RTNLGRP_LINK = auto() RTNLGRP_NOTIFY = auto() RTNLGRP_NEIGH = auto() RTNLGRP_TC = auto() RTNLGRP_IPV4_IFADDR = auto() RTNLGRP_IPV4_MROUTE = auto() RTNLGRP_IPV4_ROUTE = auto() RTNLGRP_IPV4_RULE = auto() RTNLGRP_IPV6_IFADDR = auto() RTNLGRP_IPV6_MROUTE = auto() RTNLGRP_IPV6_ROUTE = auto() RTNLGRP_IPV6_IFINFO = auto() RTNLGRP_DECnet_IFADDR = auto() RTNLGRP_NOP2 = auto() RTNLGRP_DECnet_ROUTE = auto() RTNLGRP_DECnet_RULE = auto() RTNLGRP_NOP4 = auto() RTNLGRP_IPV6_PREFIX = auto() RTNLGRP_IPV6_RULE = auto() RTNLGRP_ND_USEROPT = auto() RTNLGRP_PHONET_IFADDR = auto() RTNLGRP_PHONET_ROUTE = auto() RTNLGRP_DCB = auto() RTNLGRP_IPV4_NETCONF = auto() RTNLGRP_IPV6_NETCONF = auto() RTNLGRP_MDB = auto() RTNLGRP_MPLS_ROUTE = auto() RTNLGRP_NSID = auto() RTNLGRP_MPLS_NETCONF = auto() RTNLGRP_IPV4_MROUTE_R = auto() RTNLGRP_IPV6_MROUTE_R = auto() RTNLGRP_NEXTHOP = auto() RTNLGRP_BRVLAN = auto() class IfinfoMsg(Structure): _fields_ = [ ("ifi_family", c_ubyte), ("__ifi_pad", c_ubyte), ("ifi_type", c_ushort), ("ifi_index", c_int), ("ifi_flags", c_uint), ("ifi_change", c_uint), ] class IflattrType(Enum): IFLA_UNSPEC = 0 - IFLA_ADDRESS = auto() - IFLA_BROADCAST = auto() - IFLA_IFNAME = auto() - IFLA_MTU = auto() - IFLA_LINK = auto() - IFLA_QDISC = auto() - IFLA_STATS = auto() - IFLA_COST = auto() - IFLA_PRIORITY = auto() - IFLA_MASTER = auto() - IFLA_WIRELESS = auto() - IFLA_PROTINFO = auto() - IFLA_TXQLEN = auto() - IFLA_MAP = auto() - IFLA_WEIGHT = auto() - IFLA_OPERSTATE = auto() - IFLA_LINKMODE = auto() - IFLA_LINKINFO = auto() - IFLA_NET_NS_PID = auto() - IFLA_IFALIAS = auto() - IFLA_NUM_VF = auto() - IFLA_VFINFO_LIST = auto() - IFLA_STATS64 = auto() - IFLA_VF_PORTS = auto() - IFLA_PORT_SELF = auto() - IFLA_AF_SPEC = auto() - IFLA_GROUP = auto() - IFLA_NET_NS_FD = auto() - IFLA_EXT_MASK = auto() - IFLA_PROMISCUITY = auto() - IFLA_NUM_TX_QUEUES = auto() - IFLA_NUM_RX_QUEUES = auto() - IFLA_CARRIER = auto() - IFLA_PHYS_PORT_ID = auto() - IFLA_CARRIER_CHANGES = auto() - IFLA_PHYS_SWITCH_ID = auto() - IFLA_LINK_NETNSID = auto() - IFLA_PHYS_PORT_NAME = auto() - IFLA_PROTO_DOWN = auto() - IFLA_GSO_MAX_SEGS = auto() - IFLA_GSO_MAX_SIZE = auto() - IFLA_PAD = auto() - IFLA_XDP = auto() - IFLA_EVENT = auto() - IFLA_NEW_NETNSID = auto() - IFLA_IF_NETNSID = auto() - IFLA_CARRIER_UP_COUNT = auto() - IFLA_CARRIER_DOWN_COUNT = auto() - IFLA_NEW_IFINDEX = auto() - IFLA_MIN_MTU = auto() - IFLA_MAX_MTU = auto() - IFLA_PROP_LIST = auto() - IFLA_ALT_IFNAME = auto() - IFLA_PERM_ADDRESS = auto() - IFLA_PROTO_DOWN_REASON = auto() + IFLA_ADDRESS = 1 + IFLA_BROADCAST = 2 + IFLA_IFNAME = 3 + IFLA_MTU = 4 + IFLA_LINK = 5 + IFLA_QDISC = 6 + IFLA_STATS = 7 + IFLA_COST = 8 + IFLA_PRIORITY = 9 + IFLA_MASTER = 10 + IFLA_WIRELESS = 11 + IFLA_PROTINFO = 12 + IFLA_TXQLEN = 13 + IFLA_MAP = 14 + IFLA_WEIGHT = 15 + IFLA_OPERSTATE = 16 + IFLA_LINKMODE = 17 + IFLA_LINKINFO = 18 + IFLA_NET_NS_PID = 19 + IFLA_IFALIAS = 20 + IFLA_NUM_VF = 21 + IFLA_VFINFO_LIST = 22 + IFLA_STATS64 = 23 + IFLA_VF_PORTS = 24 + IFLA_PORT_SELF = 25 + IFLA_AF_SPEC = 26 + IFLA_GROUP = 27 + IFLA_NET_NS_FD = 28 + IFLA_EXT_MASK = 29 + IFLA_PROMISCUITY = 30 + IFLA_NUM_TX_QUEUES = 31 + IFLA_NUM_RX_QUEUES = 32 + IFLA_CARRIER = 33 + IFLA_PHYS_PORT_ID = 34 + IFLA_CARRIER_CHANGES = 35 + IFLA_PHYS_SWITCH_ID = 36 + IFLA_LINK_NETNSID = 37 + IFLA_PHYS_PORT_NAME = 38 + IFLA_PROTO_DOWN = 39 + IFLA_GSO_MAX_SEGS = 40 + IFLA_GSO_MAX_SIZE = 41 + IFLA_PAD = 42 + IFLA_XDP = 43 + IFLA_EVENT = 44 + IFLA_NEW_NETNSID = 45 + IFLA_IF_NETNSID = 46 + IFLA_CARRIER_UP_COUNT = 47 + IFLA_CARRIER_DOWN_COUNT = 48 + IFLA_NEW_IFINDEX = 49 + IFLA_MIN_MTU = 50 + IFLA_MAX_MTU = 51 + IFLA_PROP_LIST = 52 + IFLA_ALT_IFNAME = 53 + IFLA_PERM_ADDRESS = 54 + IFLA_PROTO_DOWN_REASON = 55 + IFLA_PARENT_DEV_NAME = 56 + IFLA_PARENT_DEV_BUS_NAME = 57 + IFLA_GRO_MAX_SIZE = 58 + IFLA_TSO_MAX_SEGS = 59 + IFLA_ALLMULTI = 60 + IFLA_DEVLINK_PORT = 61 + IFLA_GSO_IPV4_MAX_SIZE = 62 + IFLA_GRO_IPV4_MAX_SIZE = 63 + IFLA_FREEBSD = 64 + + +class IflafAttrType(Enum): + IFLAF_UNSPEC = 0 + IFLAF_ORIG_IFNAME = 1 + IFLAF_ORIG_HWADDR = 2 class IflinkInfo(Enum): IFLA_INFO_UNSPEC = 0 IFLA_INFO_KIND = auto() IFLA_INFO_DATA = auto() IFLA_INFO_XSTATS = auto() IFLA_INFO_SLAVE_KIND = auto() IFLA_INFO_SLAVE_DATA = auto() class IfLinkInfoDataVlan(Enum): IFLA_VLAN_UNSPEC = 0 IFLA_VLAN_ID = auto() IFLA_VLAN_FLAGS = auto() IFLA_VLAN_EGRESS_QOS = auto() IFLA_VLAN_INGRESS_QOS = auto() IFLA_VLAN_PROTOCOL = auto() class IfaddrMsg(Structure): _fields_ = [ ("ifa_family", c_ubyte), ("ifa_prefixlen", c_ubyte), ("ifa_flags", c_ubyte), ("ifa_scope", c_ubyte), ("ifa_index", c_uint), ] class IfaAttrType(Enum): IFA_UNSPEC = 0 - IFA_ADDRESS = auto() - IFA_LOCAL = auto() - IFA_LABEL = auto() - IFA_BROADCAST = auto() - IFA_ANYCAST = auto() - IFA_CACHEINFO = auto() - IFA_MULTICAST = auto() - IFA_FLAGS = auto() - IFA_RT_PRIORITY = auto() - IFA_TARGET_NETNSID = auto() + IFA_ADDRESS = 1 + IFA_LOCAL = 2 + IFA_LABEL = 3 + IFA_BROADCAST = 4 + IFA_ANYCAST = 5 + IFA_CACHEINFO = 6 + IFA_MULTICAST = 7 + IFA_FLAGS = 8 + IFA_RT_PRIORITY = 9 + IFA_TARGET_NETNSID = 10 + IFA_FREEBSD = 11 + + +class IfafAttrType(Enum): + IFAF_UNSPEC = 0 + IFAF_VHID = 1 + IFAF_FLAGS = 2 + + +class IfaCacheInfo(Structure): + _fields_ = [ + ("ifa_prefered", c_uint), # seconds till the end of the prefix considered preferred + ("ifa_valid", c_uint), # seconds till the end of the prefix considered valid + ("cstamp", c_uint), # creation time in 1ms intervals from the boot time + ("tstamp", c_uint), # update time in 1ms intervals from the boot time + ] + + +class IfaFlags(Enum): + IFA_F_TEMPORARY = 0x01 + IFA_F_NODAD = 0x02 + IFA_F_OPTIMISTIC = 0x04 + IFA_F_DADFAILED = 0x08 + IFA_F_HOMEADDRESS = 0x10 + IFA_F_DEPRECATED = 0x20 + IFA_F_TENTATIVE = 0x40 + IFA_F_PERMANENT = 0x80 + IFA_F_MANAGETEMPADDR = 0x100 + IFA_F_NOPREFIXROUTE = 0x200 + IFA_F_MCAUTOJOIN = 0x400 + IFA_F_STABLE_PRIVACY = 0x800 + + +class IfafFlags6(Enum): + IN6_IFF_ANYCAST = 0x01 + IN6_IFF_TENTATIVE = 0x02 + IN6_IFF_DUPLICATED = 0x04 + IN6_IFF_DETACHED = 0x08 + IN6_IFF_DEPRECATED = 0x10 + IN6_IFF_NODAD = 0x20 + IN6_IFF_AUTOCONF = 0x40 + IN6_IFF_TEMPORARY = 0x80 + IN6_IFF_PREFER_SOURCE = 0x100 class NdMsg(Structure): _fields_ = [ ("ndm_family", c_ubyte), ("ndm_pad1", c_ubyte), ("ndm_pad2", c_ubyte), ("ndm_ifindex", c_uint), ("ndm_state", c_ushort), ("ndm_flags", c_ubyte), ("ndm_type", c_ubyte), ] class NdAttrType(Enum): NDA_UNSPEC = 0 NDA_DST = 1 NDA_LLADDR = 2 NDA_CACHEINFO = 3 NDA_PROBES = 4 NDA_VLAN = 5 NDA_PORT = 6 NDA_VNI = 7 NDA_IFINDEX = 8 NDA_MASTER = 9 NDA_LINK_NETNSID = 10 NDA_SRC_VNI = 11 NDA_PROTOCOL = 12 NDA_NH_ID = 13 NDA_FDB_EXT_ATTRS = 14 NDA_FLAGS_EXT = 15 NDA_NDM_STATE_MASK = 16 NDA_NDM_FLAGS_MASK = 17 class NlAttrRtFlags(NlAttrU32): def _print_attr_value(self): s = get_bitmask_str(RtFlagsBSD, self.u32) return " rtflags={}".format(s) class NlAttrIfindex(NlAttrU32): def _print_attr_value(self): try: ifname = socket.if_indextoname(self.u32) return " iface={}(#{})".format(ifname, self.u32) except OSError: pass return " iface=if#{}".format(self.u32) class NlAttrTable(NlAttrU32): def _print_attr_value(self): return " rtable={}".format(self.u32) class NlAttrNhId(NlAttrU32): def _print_attr_value(self): return " nh_id={}".format(self.u32) class NlAttrKNhId(NlAttrU32): def _print_attr_value(self): return " knh_id={}".format(self.u32) class NlAttrMac(NlAttr): def _print_attr_value(self): return ' mac="' + ":".join(["{:02X}".format(b) for b in self._data]) + '"' class NlAttrIfStats(NlAttr): def _print_attr_value(self): return " stats={...}" +class NlAttrCacheInfo(NlAttr): + def __init__(self, nla_type, data): + super().__init__(nla_type, data) + self.ci = IfaCacheInfo.from_buffer_copy(data) + + @staticmethod + def _validate(data): + nla_len, nla_type = struct.unpack("@HH", data[:4]) + data_len = nla_len - 4 + if data_len != sizeof(IfaCacheInfo): + raise ValueError( + "Error validating attr {}: wrong size".format(nla_type) + ) # noqa: E501 + + def _print_attr_value(self): + return " ifa_prefered={} ifa_valid={} cstamp={} tstamp={}".format( + self.ci.ifa_prefered, self.ci.ifa_valid, self.ci.cstamp, self.ci.tstamp) + + class NlAttrVia(NlAttr): def __init__(self, nla_type, family, addr: str): super().__init__(nla_type, b"") self.addr = addr self.family = family @staticmethod def _validate(data): nla_len, nla_type = struct.unpack("@HH", data[:4]) data_len = nla_len - 4 if data_len == 0: raise ValueError( "Error validating attr {}: empty data".format(nla_type) ) # noqa: E501 family = int(data_len[0]) if family not in (socket.AF_INET, socket.AF_INET6): raise ValueError( "Error validating attr {}: unsupported AF {}".format( # noqa: E501 nla_type, family ) ) if family == socket.AF_INET: expected_len = 1 + 4 else: expected_len = 1 + 16 if data_len != expected_len: raise ValueError( "Error validating attr {}: expected len {} got {}".format( # noqa: E501 nla_type, expected_len, data_len ) ) @property def nla_len(self): if self.family == socket.AF_INET6: return 21 else: return 9 @classmethod def _parse(cls, data): nla_len, nla_type, family = struct.unpack("@HHB", data[:5]) off = 5 if family == socket.AF_INET: addr = socket.inet_ntop(family, data[off:off + 4]) else: addr = socket.inet_ntop(family, data[off:off + 16]) return cls(nla_type, family, addr) def __bytes__(self): addr = socket.inet_pton(self.family, self.addr) return self._to_bytes(struct.pack("@B", self.family) + addr) def _print_attr_value(self): return " via={}".format(self.addr) rtnl_route_attrs = prepare_attrs_map( [ AttrDescr(RtattrType.RTA_DST, NlAttrIp), AttrDescr(RtattrType.RTA_SRC, NlAttrIp), AttrDescr(RtattrType.RTA_IIF, NlAttrIfindex), AttrDescr(RtattrType.RTA_OIF, NlAttrIfindex), AttrDescr(RtattrType.RTA_GATEWAY, NlAttrIp), AttrDescr(RtattrType.RTA_TABLE, NlAttrTable), AttrDescr(RtattrType.RTA_PRIORITY, NlAttrU32), AttrDescr(RtattrType.RTA_VIA, NlAttrVia), AttrDescr(RtattrType.RTA_NH_ID, NlAttrNhId), AttrDescr(RtattrType.RTA_KNH_ID, NlAttrKNhId), AttrDescr(RtattrType.RTA_RTFLAGS, NlAttrRtFlags), AttrDescr( RtattrType.RTA_METRICS, NlAttrNested, [ AttrDescr(NlRtaxType.RTAX_MTU, NlAttrU32), ], ), ] ) rtnl_ifla_attrs = prepare_attrs_map( [ AttrDescr(IflattrType.IFLA_ADDRESS, NlAttrMac), AttrDescr(IflattrType.IFLA_BROADCAST, NlAttrMac), AttrDescr(IflattrType.IFLA_IFNAME, NlAttrStr), AttrDescr(IflattrType.IFLA_MTU, NlAttrU32), AttrDescr(IflattrType.IFLA_LINK, NlAttrU32), AttrDescr(IflattrType.IFLA_PROMISCUITY, NlAttrU32), AttrDescr(IflattrType.IFLA_OPERSTATE, NlAttrU8), AttrDescr(IflattrType.IFLA_CARRIER, NlAttrU8), AttrDescr(IflattrType.IFLA_IFALIAS, NlAttrStr), AttrDescr(IflattrType.IFLA_STATS64, NlAttrIfStats), AttrDescr(IflattrType.IFLA_NEW_IFINDEX, NlAttrU32), AttrDescr( IflattrType.IFLA_LINKINFO, NlAttrNested, [ AttrDescr(IflinkInfo.IFLA_INFO_KIND, NlAttrStr), AttrDescr(IflinkInfo.IFLA_INFO_DATA, NlAttr), ], ), + AttrDescr( + IflattrType.IFLA_FREEBSD, + NlAttrNested, + [ + AttrDescr(IflafAttrType.IFLAF_ORIG_HWADDR, NlAttrMac), + ], + ), ] ) rtnl_ifa_attrs = prepare_attrs_map( [ AttrDescr(IfaAttrType.IFA_ADDRESS, NlAttrIp), AttrDescr(IfaAttrType.IFA_LOCAL, NlAttrIp), AttrDescr(IfaAttrType.IFA_LABEL, NlAttrStr), AttrDescr(IfaAttrType.IFA_BROADCAST, NlAttrIp), AttrDescr(IfaAttrType.IFA_ANYCAST, NlAttrIp), AttrDescr(IfaAttrType.IFA_FLAGS, NlAttrU32), + AttrDescr(IfaAttrType.IFA_CACHEINFO, NlAttrCacheInfo), + AttrDescr( + IfaAttrType.IFA_FREEBSD, + NlAttrNested, + [ + AttrDescr(IfafAttrType.IFAF_VHID, NlAttrU32), + AttrDescr(IfafAttrType.IFAF_FLAGS, NlAttrU32), + ], + ), ] ) rtnl_nd_attrs = prepare_attrs_map( [ AttrDescr(NdAttrType.NDA_DST, NlAttrIp), AttrDescr(NdAttrType.NDA_IFINDEX, NlAttrIfindex), AttrDescr(NdAttrType.NDA_FLAGS_EXT, NlAttrU32), AttrDescr(NdAttrType.NDA_LLADDR, NlAttrMac), ] ) class BaseNetlinkRtMessage(StdNetlinkMessage): pass class NetlinkRtMessage(BaseNetlinkRtMessage): messages = [ NlMsgProps(NlRtMsgType.RTM_NEWROUTE, NlMsgCategory.NEW), NlMsgProps(NlRtMsgType.RTM_DELROUTE, NlMsgCategory.DELETE), NlMsgProps(NlRtMsgType.RTM_GETROUTE, NlMsgCategory.GET), ] nl_attrs_map = rtnl_route_attrs def __init__(self, helper, nlm_type): super().__init__(helper, nlm_type) self.base_hdr = RtMsgHdr() def parse_base_header(self, data): if len(data) < sizeof(RtMsgHdr): raise ValueError("length less than rtmsg header") rtm_hdr = RtMsgHdr.from_buffer_copy(data) return (rtm_hdr, sizeof(RtMsgHdr)) def print_base_header(self, hdr, prepend=""): family = self.helper.get_af_name(hdr.rtm_family) print( "{}family={}, dst_len={}, src_len={}, tos={}, table={}, protocol={}({}), scope={}({}), type={}({}), flags={}({})".format( # noqa: E501 prepend, family, hdr.rtm_dst_len, hdr.rtm_src_len, hdr.rtm_tos, hdr.rtm_table, self.helper.get_attr_byval(RtProto, hdr.rtm_protocol), hdr.rtm_protocol, self.helper.get_attr_byval(RtScope, hdr.rtm_scope), hdr.rtm_scope, self.helper.get_attr_byval(RtType, hdr.rtm_type), hdr.rtm_type, self.helper.get_bitmask_str(RtMsgFlags, hdr.rtm_flags), hdr.rtm_flags, ) ) class NetlinkIflaMessage(BaseNetlinkRtMessage): messages = [ NlMsgProps(NlRtMsgType.RTM_NEWLINK, NlMsgCategory.NEW), NlMsgProps(NlRtMsgType.RTM_DELLINK, NlMsgCategory.DELETE), NlMsgProps(NlRtMsgType.RTM_GETLINK, NlMsgCategory.GET), ] nl_attrs_map = rtnl_ifla_attrs def __init__(self, helper, nlm_type): super().__init__(helper, nlm_type) self.base_hdr = IfinfoMsg() def parse_base_header(self, data): if len(data) < sizeof(IfinfoMsg): raise ValueError("length less than IfinfoMsg header") rtm_hdr = IfinfoMsg.from_buffer_copy(data) return (rtm_hdr, sizeof(IfinfoMsg)) def print_base_header(self, hdr, prepend=""): family = self.helper.get_af_name(hdr.ifi_family) print( "{}family={}, ifi_type={}, ifi_index={}, ifi_flags={}, ifi_change={}".format( # noqa: E501 prepend, family, hdr.ifi_type, hdr.ifi_index, hdr.ifi_flags, hdr.ifi_change, ) ) class NetlinkIfaMessage(BaseNetlinkRtMessage): messages = [ NlMsgProps(NlRtMsgType.RTM_NEWADDR, NlMsgCategory.NEW), NlMsgProps(NlRtMsgType.RTM_DELADDR, NlMsgCategory.DELETE), NlMsgProps(NlRtMsgType.RTM_GETADDR, NlMsgCategory.GET), ] nl_attrs_map = rtnl_ifa_attrs def __init__(self, helper, nlm_type): super().__init__(helper, nlm_type) self.base_hdr = IfaddrMsg() def parse_base_header(self, data): if len(data) < sizeof(IfaddrMsg): raise ValueError("length less than IfaddrMsg header") rtm_hdr = IfaddrMsg.from_buffer_copy(data) return (rtm_hdr, sizeof(IfaddrMsg)) def print_base_header(self, hdr, prepend=""): family = self.helper.get_af_name(hdr.ifa_family) print( "{}family={}, ifa_prefixlen={}, ifa_flags={}, ifa_scope={}, ifa_index={}".format( # noqa: E501 prepend, family, hdr.ifa_prefixlen, hdr.ifa_flags, hdr.ifa_scope, hdr.ifa_index, ) ) class NetlinkNdMessage(BaseNetlinkRtMessage): messages = [ NlMsgProps(NlRtMsgType.RTM_NEWNEIGH, NlMsgCategory.NEW), NlMsgProps(NlRtMsgType.RTM_DELNEIGH, NlMsgCategory.DELETE), NlMsgProps(NlRtMsgType.RTM_GETNEIGH, NlMsgCategory.GET), ] nl_attrs_map = rtnl_nd_attrs def __init__(self, helper, nlm_type): super().__init__(helper, nlm_type) self.base_hdr = NdMsg() def parse_base_header(self, data): if len(data) < sizeof(NdMsg): raise ValueError("length less than NdMsg header") nd_hdr = NdMsg.from_buffer_copy(data) return (nd_hdr, sizeof(NdMsg)) def print_base_header(self, hdr, prepend=""): family = self.helper.get_af_name(hdr.ndm_family) print( "{}family={}, ndm_ifindex={}, ndm_state={}, ndm_flags={}".format( # noqa: E501 prepend, family, hdr.ndm_ifindex, hdr.ndm_state, hdr.ndm_flags, ) ) handler_classes = { "netlink_route": [ NetlinkRtMessage, NetlinkIflaMessage, NetlinkIfaMessage, NetlinkNdMessage, ], } diff --git a/tests/sys/netlink/test_rtnl_ifaddr.py b/tests/sys/netlink/test_rtnl_ifaddr.py index 1e7d6ca62bd8..11c08b32674a 100644 --- a/tests/sys/netlink/test_rtnl_ifaddr.py +++ b/tests/sys/netlink/test_rtnl_ifaddr.py @@ -1,161 +1,717 @@ import ipaddress import socket import struct +import pytest from atf_python.sys.net.vnet import SingleVnetTestTemplate +from atf_python.sys.netlink.attrs import NlAttr +from atf_python.sys.netlink.attrs import NlAttrIp +from atf_python.sys.netlink.attrs import NlAttrNested +from atf_python.sys.netlink.attrs import NlAttrU32 from atf_python.sys.netlink.base_headers import NlmBaseFlags +from atf_python.sys.netlink.base_headers import NlmNewFlags from atf_python.sys.netlink.base_headers import Nlmsghdr +from atf_python.sys.netlink.message import NlMsgType from atf_python.sys.netlink.netlink import NetlinkTestTemplate +from atf_python.sys.netlink.netlink import Nlsock +from atf_python.sys.netlink.netlink_generic import CarpAttrType +from atf_python.sys.netlink.netlink_generic import CarpGenMessage +from atf_python.sys.netlink.netlink_generic import CarpMsgType from atf_python.sys.netlink.netlink_route import IfaAttrType +from atf_python.sys.netlink.netlink_route import IfaCacheInfo +from atf_python.sys.netlink.netlink_route import IfafAttrType +from atf_python.sys.netlink.netlink_route import IfafFlags6 +from atf_python.sys.netlink.netlink_route import IfaFlags from atf_python.sys.netlink.netlink_route import NetlinkIfaMessage from atf_python.sys.netlink.netlink_route import NlRtMsgType from atf_python.sys.netlink.netlink_route import RtScope +from atf_python.sys.netlink.utils import enum_or_int from atf_python.sys.netlink.utils import NlConst -class TestRtNlIfaddr(NetlinkTestTemplate, SingleVnetTestTemplate): +class TestRtNlIfaddrList(NetlinkTestTemplate, SingleVnetTestTemplate): def setup_method(self, method): method_name = method.__name__ if "4" in method_name: self.IPV4_PREFIXES = ["192.0.2.1/24"] if "6" in method_name: self.IPV6_PREFIXES = ["2001:db8::1/64"] super().setup_method(method) self.setup_netlink(NlConst.NETLINK_ROUTE) def test_46_nofilter(self): """Tests that listing outputs both IPv4/IPv6 and interfaces""" msg = NetlinkIfaMessage(self.helper, NlRtMsgType.RTM_GETADDR.value) - msg.nl_hdr.nlmsg_flags = ( - NlmBaseFlags.NLM_F_ACK.value | NlmBaseFlags.NLM_F_REQUEST.value - ) + msg.set_request() self.write_message(msg) ret = [] for rx_msg in self.read_msg_list(msg.nl_hdr.nlmsg_seq, NlRtMsgType.RTM_NEWADDR): ifname = socket.if_indextoname(rx_msg.base_hdr.ifa_index) family = rx_msg.base_hdr.ifa_family ret.append((ifname, family, rx_msg)) ifname = "lo0" assert len([r for r in ret if r[0] == ifname]) > 0 ifname = self.vnet.iface_alias_map["if1"].name assert len([r for r in ret if r[0] == ifname and r[1] == socket.AF_INET]) == 1 assert len([r for r in ret if r[0] == ifname and r[1] == socket.AF_INET6]) == 2 def test_46_filter_iface(self): """Tests that listing outputs both IPv4/IPv6 for the specific interface""" epair_ifname = self.vnet.iface_alias_map["if1"].name msg = NetlinkIfaMessage(self.helper, NlRtMsgType.RTM_GETADDR.value) - msg.nl_hdr.nlmsg_flags = ( - NlmBaseFlags.NLM_F_ACK.value | NlmBaseFlags.NLM_F_REQUEST.value - ) + msg.set_request() msg.base_hdr.ifa_index = socket.if_nametoindex(epair_ifname) self.write_message(msg) ret = [] for rx_msg in self.read_msg_list(msg.nl_hdr.nlmsg_seq, NlRtMsgType.RTM_NEWADDR): ifname = socket.if_indextoname(rx_msg.base_hdr.ifa_index) family = rx_msg.base_hdr.ifa_family ret.append((ifname, family, rx_msg)) ifname = epair_ifname assert len([r for r in ret if r[0] == ifname and r[1] == socket.AF_INET]) == 1 assert len([r for r in ret if r[0] == ifname and r[1] == socket.AF_INET6]) == 2 assert len(ret) == 3 def test_46_filter_family_compat(self): """Tests that family filtering works with the stripped header""" hdr = Nlmsghdr( - nlmsg_len=17, - nlmsg_type=NlRtMsgType.RTM_GETADDR.value, - nlmsg_flags=NlmBaseFlags.NLM_F_ACK.value | NlmBaseFlags.NLM_F_REQUEST.value, - nlmsg_seq=self.helper.get_seq() - ) + nlmsg_len=17, + nlmsg_type=NlRtMsgType.RTM_GETADDR.value, + nlmsg_flags=NlmBaseFlags.NLM_F_ACK.value | NlmBaseFlags.NLM_F_REQUEST.value, + nlmsg_seq=self.helper.get_seq(), + ) data = bytes(hdr) + struct.pack("@B", socket.AF_INET) self.nlsock.write_data(data) ret = [] for rx_msg in self.read_msg_list(hdr.nlmsg_seq, NlRtMsgType.RTM_NEWADDR): ifname = socket.if_indextoname(rx_msg.base_hdr.ifa_index) family = rx_msg.base_hdr.ifa_family ret.append((ifname, family, rx_msg)) assert len(ret) == 2 def filter_iface_family(self, family, num_items): """Tests that listing outputs IPv4 for the specific interface""" epair_ifname = self.vnet.iface_alias_map["if1"].name msg = NetlinkIfaMessage(self.helper, NlRtMsgType.RTM_GETADDR.value) - msg.nl_hdr.nlmsg_flags = ( - NlmBaseFlags.NLM_F_ACK.value | NlmBaseFlags.NLM_F_REQUEST.value - ) + msg.set_request() msg.base_hdr.ifa_family = family msg.base_hdr.ifa_index = socket.if_nametoindex(epair_ifname) self.write_message(msg) ret = [] for rx_msg in self.read_msg_list(msg.nl_hdr.nlmsg_seq, NlRtMsgType.RTM_NEWADDR): assert family == rx_msg.base_hdr.ifa_family assert epair_ifname == socket.if_indextoname(rx_msg.base_hdr.ifa_index) ret.append(rx_msg) assert len(ret) == num_items return ret def test_4_broadcast(self): """Tests header/attr output for listing IPv4 ifas on broadcast iface""" ret = self.filter_iface_family(socket.AF_INET, 1) # Should be 192.0.2.1/24 msg = ret[0] # Family and ifindex has been checked already assert msg.base_hdr.ifa_prefixlen == 24 # Ignore IFA_FLAGS for now assert msg.base_hdr.ifa_scope == RtScope.RT_SCOPE_UNIVERSE.value assert msg.get_nla(IfaAttrType.IFA_ADDRESS).addr == "192.0.2.1" assert msg.get_nla(IfaAttrType.IFA_LOCAL).addr == "192.0.2.1" assert msg.get_nla(IfaAttrType.IFA_BROADCAST).addr == "192.0.2.255" epair_ifname = self.vnet.iface_alias_map["if1"].name assert msg.get_nla(IfaAttrType.IFA_LABEL).text == epair_ifname def test_6_broadcast(self): """Tests header/attr output for listing IPv6 ifas on broadcast iface""" ret = self.filter_iface_family(socket.AF_INET6, 2) # Should be 192.0.2.1/24 if ret[0].base_hdr.ifa_scope == RtScope.RT_SCOPE_UNIVERSE.value: (gmsg, lmsg) = ret else: (lmsg, gmsg) = ret # Start with global ( 2001:db8::1/64 ) msg = gmsg # Family and ifindex has been checked already assert msg.base_hdr.ifa_prefixlen == 64 # Ignore IFA_FLAGS for now assert msg.base_hdr.ifa_scope == RtScope.RT_SCOPE_UNIVERSE.value assert msg.get_nla(IfaAttrType.IFA_ADDRESS).addr == "2001:db8::1" assert msg.get_nla(IfaAttrType.IFA_LOCAL) is None assert msg.get_nla(IfaAttrType.IFA_BROADCAST) is None epair_ifname = self.vnet.iface_alias_map["if1"].name assert msg.get_nla(IfaAttrType.IFA_LABEL).text == epair_ifname # Local: fe80::/64 msg = lmsg assert msg.base_hdr.ifa_prefixlen == 64 # Ignore IFA_FLAGS for now assert msg.base_hdr.ifa_scope == RtScope.RT_SCOPE_LINK.value addr = ipaddress.ip_address(msg.get_nla(IfaAttrType.IFA_ADDRESS).addr) assert addr.is_link_local # Verify that ifindex is not emmbedded assert struct.unpack("!H", addr.packed[2:4])[0] == 0 assert msg.get_nla(IfaAttrType.IFA_LOCAL) is None assert msg.get_nla(IfaAttrType.IFA_BROADCAST) is None epair_ifname = self.vnet.iface_alias_map["if1"].name assert msg.get_nla(IfaAttrType.IFA_LABEL).text == epair_ifname + + +class RtnlIfaOps(NetlinkTestTemplate, SingleVnetTestTemplate): + def setup_method(self, method): + super().setup_method(method) + self.setup_netlink(NlConst.NETLINK_ROUTE) + + def send_check_success(self, msg): + rx_msg = self.get_reply(msg) + assert rx_msg.is_type(NlMsgType.NLMSG_ERROR) + assert rx_msg.error_code == 0 + + @staticmethod + def get_family_from_ip(ip): + if ip.version == 4: + return socket.AF_INET + return socket.AF_INET6 + + def create_msg(self, ifa): + iface = self.vnet.iface_alias_map["if1"] + + msg = NetlinkIfaMessage(self.helper, NlRtMsgType.RTM_NEWADDR.value) + msg.set_request() + msg.nl_hdr.nlmsg_flags |= ( + NlmNewFlags.NLM_F_EXCL.value | NlmNewFlags.NLM_F_CREATE.value + ) + msg.base_hdr.ifa_family = self.get_family_from_ip(ifa.ip) + msg.base_hdr.ifa_index = iface.ifindex + msg.base_hdr.ifa_prefixlen = ifa.network.prefixlen + return msg + + def get_ifa_list(self, ifindex=0, family=0): + msg = NetlinkIfaMessage(self.helper, NlRtMsgType.RTM_GETADDR.value) + msg.set_request() + msg.base_hdr.ifa_family = family + msg.base_hdr.ifa_index = ifindex + self.write_message(msg) + return self.read_msg_list(msg.nl_hdr.nlmsg_seq, NlRtMsgType.RTM_NEWADDR) + + def find_msg_by_ifa(self, msg_list, ip): + for msg in msg_list: + if msg.get_nla(IfaAttrType.IFA_ADDRESS).addr == str(ip): + return msg + return None + + def setup_dummy_carp(self, ifindex: int, vhid: int): + self.require_module("carp") + + nlsock = Nlsock(NlConst.NETLINK_GENERIC, self.helper) + family_id = nlsock.get_genl_family_id("carp") + + msg = CarpGenMessage(self.helper, family_id, CarpMsgType.CARP_NL_CMD_SET) + msg.set_request() + msg.add_nla(NlAttrU32(CarpAttrType.CARP_NL_VHID, vhid)) + msg.add_nla(NlAttrU32(CarpAttrType.CARP_NL_IFINDEX, ifindex)) + rx_msg = nlsock.get_reply(msg) + + assert rx_msg.is_type(NlMsgType.NLMSG_ERROR) + assert rx_msg.error_code == 0 + + +class TestRtNlIfaddrOpsBroadcast(RtnlIfaOps): + def test_add_4(self): + """Tests IPv4 address addition to the standard broadcast interface""" + ifa = ipaddress.ip_interface("192.0.2.1/24") + ifa_brd = ifa.network.broadcast_address + iface = self.vnet.iface_alias_map["if1"] + + msg = self.create_msg(ifa) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_LOCAL, str(ifa.ip))) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_BROADCAST, str(ifa_brd))) + + self.send_check_success(msg) + + lst = self.get_ifa_list(iface.ifindex, self.get_family_from_ip(ifa.ip)) + assert len(lst) == 1 + rx_msg = lst[0] + + assert rx_msg.base_hdr.ifa_prefixlen == ifa.network.prefixlen + assert rx_msg.base_hdr.ifa_scope == RtScope.RT_SCOPE_UNIVERSE.value + + assert rx_msg.get_nla(IfaAttrType.IFA_ADDRESS).addr == str(ifa.ip) + assert rx_msg.get_nla(IfaAttrType.IFA_LOCAL).addr == str(ifa.ip) + assert rx_msg.get_nla(IfaAttrType.IFA_BROADCAST).addr == str(ifa_brd) + + def test_add_6(self): + ifa = ipaddress.ip_interface("2001:db8::1/64") + iface = self.vnet.iface_alias_map["if1"] + + msg = self.create_msg(ifa) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_LOCAL, str(ifa.ip))) + + self.send_check_success(msg) + + lst = self.get_ifa_list(iface.ifindex, self.get_family_from_ip(ifa.ip)) + assert len(lst) == 2 + rx_msg_gu = self.find_msg_by_ifa(lst, ifa.ip) + assert rx_msg_gu is not None + + assert rx_msg_gu.base_hdr.ifa_prefixlen == ifa.network.prefixlen + assert rx_msg_gu.base_hdr.ifa_scope == RtScope.RT_SCOPE_UNIVERSE.value + assert rx_msg_gu.get_nla(IfaAttrType.IFA_ADDRESS).addr == str(ifa.ip) + + def test_add_4_carp(self): + ifa = ipaddress.ip_interface("192.0.2.1/24") + ifa_brd = ifa.network.broadcast_address + iface = self.vnet.iface_alias_map["if1"] + vhid = 77 + + self.setup_dummy_carp(iface.ifindex, vhid) + + msg = self.create_msg(ifa) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_LOCAL, str(ifa.ip))) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_BROADCAST, str(ifa_brd))) + attrs_bsd = [NlAttrU32(IfafAttrType.IFAF_VHID, vhid)] + msg.add_nla(NlAttrNested(IfaAttrType.IFA_FREEBSD, attrs_bsd)) + + self.send_check_success(msg) + + lst = self.get_ifa_list(iface.ifindex, self.get_family_from_ip(ifa.ip)) + assert len(lst) == 1 + rx_msg = lst[0] + + assert rx_msg.base_hdr.ifa_prefixlen == ifa.network.prefixlen + assert rx_msg.base_hdr.ifa_scope == RtScope.RT_SCOPE_UNIVERSE.value + + assert rx_msg.get_nla(IfaAttrType.IFA_ADDRESS).addr == str(ifa.ip) + assert rx_msg.get_nla(IfaAttrType.IFA_LOCAL).addr == str(ifa.ip) + assert rx_msg.get_nla(IfaAttrType.IFA_BROADCAST).addr == str(ifa_brd) + ifa_bsd = rx_msg.get_nla(IfaAttrType.IFA_FREEBSD) + assert ifa_bsd.get_nla(IfafAttrType.IFAF_VHID).u32 == vhid + + def test_add_6_carp(self): + ifa = ipaddress.ip_interface("2001:db8::1/64") + iface = self.vnet.iface_alias_map["if1"] + vhid = 77 + + self.setup_dummy_carp(iface.ifindex, vhid) + + msg = self.create_msg(ifa) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_LOCAL, str(ifa.ip))) + attrs_bsd = [NlAttrU32(IfafAttrType.IFAF_VHID, vhid)] + msg.add_nla(NlAttrNested(IfaAttrType.IFA_FREEBSD, attrs_bsd)) + + self.send_check_success(msg) + + lst = self.get_ifa_list(iface.ifindex, self.get_family_from_ip(ifa.ip)) + assert len(lst) == 2 + rx_msg_gu = self.find_msg_by_ifa(lst, ifa.ip) + assert rx_msg_gu is not None + + assert rx_msg_gu.base_hdr.ifa_prefixlen == ifa.network.prefixlen + assert rx_msg_gu.base_hdr.ifa_scope == RtScope.RT_SCOPE_UNIVERSE.value + assert rx_msg_gu.get_nla(IfaAttrType.IFA_ADDRESS).addr == str(ifa.ip) + ifa_bsd = rx_msg_gu.get_nla(IfaAttrType.IFA_FREEBSD) + assert ifa_bsd.get_nla(IfafAttrType.IFAF_VHID).u32 == vhid + + def test_add_6_lifetime(self): + ifa = ipaddress.ip_interface("2001:db8::1/64") + iface = self.vnet.iface_alias_map["if1"] + pref_time = 43200 + valid_time = 86400 + + ci = IfaCacheInfo(ifa_prefered=pref_time, ifa_valid=valid_time) + + msg = self.create_msg(ifa) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_LOCAL, str(ifa.ip))) + msg.add_nla(NlAttr(IfaAttrType.IFA_CACHEINFO, bytes(ci))) + + self.send_check_success(msg) + + lst = self.get_ifa_list(iface.ifindex, self.get_family_from_ip(ifa.ip)) + assert len(lst) == 2 + rx_msg = self.find_msg_by_ifa(lst, ifa.ip) + assert rx_msg is not None + + ci = rx_msg.get_nla(IfaAttrType.IFA_CACHEINFO).ci + assert pref_time - 5 <= ci.ifa_prefered <= pref_time + assert valid_time - 5 <= ci.ifa_valid <= valid_time + assert ci.cstamp > 0 + assert ci.tstamp > 0 + assert ci.tstamp >= ci.cstamp + + @pytest.mark.parametrize( + "flags_str", + [ + "autoconf", + "deprecated", + "autoconf,deprecated", + "prefer_source", + ], + ) + def test_add_6_flags(self, flags_str): + ifa = ipaddress.ip_interface("2001:db8::1/64") + iface = self.vnet.iface_alias_map["if1"] + + flags_map = { + "autoconf": {"nl": 0, "f": IfafFlags6.IN6_IFF_AUTOCONF}, + "deprecated": { + "nl": IfaFlags.IFA_F_DEPRECATED, + "f": IfafFlags6.IN6_IFF_DEPRECATED, + }, + "prefer_source": {"nl": 0, "f": IfafFlags6.IN6_IFF_PREFER_SOURCE}, + } + nl_flags = 0 + f_flags = 0 + + for flag_str in flags_str.split(","): + d = flags_map.get(flag_str, {}) + nl_flags |= enum_or_int(d.get("nl", 0)) + f_flags |= enum_or_int(d.get("f", 0)) + + msg = self.create_msg(ifa) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_LOCAL, str(ifa.ip))) + msg.add_nla(NlAttrU32(IfaAttrType.IFA_FLAGS, nl_flags)) + attrs_bsd = [NlAttrU32(IfafAttrType.IFAF_FLAGS, f_flags)] + msg.add_nla(NlAttrNested(IfaAttrType.IFA_FREEBSD, attrs_bsd)) + + self.send_check_success(msg) + + lst = self.get_ifa_list(iface.ifindex, self.get_family_from_ip(ifa.ip)) + assert len(lst) == 2 + rx_msg = self.find_msg_by_ifa(lst, ifa.ip) + assert rx_msg is not None + + assert rx_msg.get_nla(IfaAttrType.IFA_FLAGS).u32 == nl_flags + ifa_bsd = rx_msg.get_nla(IfaAttrType.IFA_FREEBSD) + assert ifa_bsd.get_nla(IfafAttrType.IFAF_FLAGS).u32 == f_flags + + def test_add_4_empty_message(self): + """Tests correct failure w/ empty message""" + msg = NetlinkIfaMessage(self.helper, NlRtMsgType.RTM_NEWADDR.value) + msg.set_request() + msg.nl_hdr.nlmsg_flags |= ( + NlmNewFlags.NLM_F_EXCL.value | NlmNewFlags.NLM_F_CREATE.value + ) + + rx_msg = self.get_reply(msg) + assert rx_msg.is_type(NlMsgType.NLMSG_ERROR) + assert rx_msg.error_code != 0 + + def test_add_4_empty_ifindex(self): + """Tests correct failure w/ empty ifindex""" + ifa = ipaddress.ip_interface("192.0.2.1/24") + ifa_brd = ifa.network.broadcast_address + + msg = self.create_msg(ifa) + msg.base_hdr.ifa_index = 0 + msg.add_nla(NlAttrIp(IfaAttrType.IFA_LOCAL, str(ifa.ip))) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_BROADCAST, str(ifa_brd))) + + rx_msg = self.get_reply(msg) + assert rx_msg.is_type(NlMsgType.NLMSG_ERROR) + assert rx_msg.error_code != 0 + + def test_add_4_empty_addr(self): + """Tests correct failure w/ empty address""" + ifa = ipaddress.ip_interface("192.0.2.1/24") + ifa_brd = ifa.network.broadcast_address + + msg = self.create_msg(ifa) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_BROADCAST, str(ifa_brd))) + + rx_msg = self.get_reply(msg) + assert rx_msg.is_type(NlMsgType.NLMSG_ERROR) + assert rx_msg.error_code != 0 + + @pytest.mark.parametrize( + "ifa_str", + [ + pytest.param("192.0.2.1/32", id="ipv4_host"), + pytest.param("192.0.2.1/24", id="ipv4_prefix"), + pytest.param("2001:db8::1/64", id="ipv6_gu_prefix"), + pytest.param("2001:db8::1/128", id="ipv6_gu_host"), + ], + ) + @pytest.mark.parametrize( + "tlv", + [ + pytest.param("local", id="ifa_local"), + pytest.param("address", id="ifa_address"), + ], + ) + def test_del(self, tlv, ifa_str): + """Tests address deletion from the standard broadcast interface""" + ifa = ipaddress.ip_interface(ifa_str) + ifa_brd = ifa.network.broadcast_address + iface = self.vnet.iface_alias_map["if1"] + + msg = self.create_msg(ifa) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_LOCAL, str(ifa.ip))) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_BROADCAST, str(ifa_brd))) + + self.send_check_success(msg) + lst = self.get_ifa_list(iface.ifindex, self.get_family_from_ip(ifa.ip)) + rx_msg = self.find_msg_by_ifa(lst, ifa.ip) + assert rx_msg is not None + + msg = NetlinkIfaMessage(self.helper, NlRtMsgType.RTM_DELADDR.value) + msg.set_request() + msg.base_hdr.ifa_family = self.get_family_from_ip(ifa.ip) + msg.base_hdr.ifa_index = iface.ifindex + msg.base_hdr.ifa_prefixlen = ifa.network.prefixlen + + if tlv == "local": + msg.add_nla(NlAttrIp(IfaAttrType.IFA_LOCAL, str(ifa.ip))) + if tlv == "address": + msg.add_nla(NlAttrIp(IfaAttrType.IFA_ADDRESS, str(ifa.ip))) + + self.send_check_success(msg) + lst = self.get_ifa_list(iface.ifindex, self.get_family_from_ip(ifa.ip)) + rx_msg = self.find_msg_by_ifa(lst, ifa.ip) + assert rx_msg is None + + +class TestRtNlIfaddrOpsP2p(RtnlIfaOps): + IFTYPE = "gif" + + @pytest.mark.parametrize( + "ifa_pair", + [ + pytest.param(["192.0.2.1/24", "192.0.2.2"], id="dst_inside_24"), + pytest.param(["192.0.2.1/30", "192.0.2.2"], id="dst_inside_30"), + pytest.param(["192.0.2.1/31", "192.0.2.2"], id="dst_inside_31"), + pytest.param(["192.0.2.1/32", "192.0.2.2"], id="dst_outside_32"), + pytest.param(["192.0.2.1/30", "192.0.2.100"], id="dst_outside_30"), + ], + ) + def test_add_4(self, ifa_pair): + """Tests IPv4 address addition to the p2p interface""" + ifa = ipaddress.ip_interface(ifa_pair[0]) + peer_ip = ipaddress.ip_address(ifa_pair[1]) + iface = self.vnet.iface_alias_map["if1"] + + msg = self.create_msg(ifa) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_LOCAL, str(ifa.ip))) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_ADDRESS, str(peer_ip))) + + self.send_check_success(msg) + + lst = self.get_ifa_list(iface.ifindex, self.get_family_from_ip(ifa.ip)) + assert len(lst) == 1 + rx_msg = lst[0] + + assert rx_msg.base_hdr.ifa_prefixlen == ifa.network.prefixlen + assert rx_msg.base_hdr.ifa_scope == RtScope.RT_SCOPE_UNIVERSE.value + + assert rx_msg.get_nla(IfaAttrType.IFA_LOCAL).addr == str(ifa.ip) + assert rx_msg.get_nla(IfaAttrType.IFA_ADDRESS).addr == str(peer_ip) + + @pytest.mark.parametrize( + "ifa_pair", + [ + pytest.param( + ["2001:db8::1/64", "2001:db8::2"], + id="dst_inside_64", + marks=pytest.mark.xfail(reason="currently fails"), + ), + pytest.param( + ["2001:db8::1/127", "2001:db8::2"], + id="dst_inside_127", + marks=pytest.mark.xfail(reason="currently fails"), + ), + pytest.param(["2001:db8::1/128", "2001:db8::2"], id="dst_outside_128"), + pytest.param( + ["2001:db8::1/64", "2001:db8:2::2"], + id="dst_outside_64", + marks=pytest.mark.xfail(reason="currently fails"), + ), + ], + ) + def test_add_6(self, ifa_pair): + """Tests IPv6 address addition to the p2p interface""" + ifa = ipaddress.ip_interface(ifa_pair[0]) + peer_ip = ipaddress.ip_address(ifa_pair[1]) + iface = self.vnet.iface_alias_map["if1"] + + msg = self.create_msg(ifa) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_LOCAL, str(ifa.ip))) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_ADDRESS, str(peer_ip))) + + self.send_check_success(msg) + + lst = self.get_ifa_list(iface.ifindex, self.get_family_from_ip(ifa.ip)) + assert len(lst) == 2 + rx_msg_gu = self.find_msg_by_ifa(lst, peer_ip) + assert rx_msg_gu is not None + + assert rx_msg_gu.base_hdr.ifa_prefixlen == ifa.network.prefixlen + assert rx_msg_gu.base_hdr.ifa_scope == RtScope.RT_SCOPE_UNIVERSE.value + assert rx_msg_gu.get_nla(IfaAttrType.IFA_LOCAL).addr == str(ifa.ip) + assert rx_msg_gu.get_nla(IfaAttrType.IFA_ADDRESS).addr == str(peer_ip) + + @pytest.mark.parametrize( + "ifa_pair", + [ + pytest.param(["192.0.2.1/30", "192.0.2.2"], id="ipv4_dst_inside_30"), + pytest.param(["192.0.2.1/32", "192.0.2.2"], id="ipv4_dst_outside_32"), + pytest.param(["2001:db8::1/128", "2001:db8::2"], id="ip6_dst_outside_128"), + ], + ) + @pytest.mark.parametrize( + "tlv_pair", + [ + pytest.param(["a", ""], id="ifa_addr=addr"), + pytest.param(["", "a"], id="ifa_local=addr"), + pytest.param(["a", "a"], id="ifa_addr=addr,ifa_local=addr"), + ], + ) + def test_del(self, tlv_pair, ifa_pair): + """Tests address deletion from the P2P interface""" + ifa = ipaddress.ip_interface(ifa_pair[0]) + peer_ip = ipaddress.ip_address(ifa_pair[1]) + iface = self.vnet.iface_alias_map["if1"] + ifa_addr_str, ifa_local_str = tlv_pair + + msg = self.create_msg(ifa) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_LOCAL, str(ifa.ip))) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_ADDRESS, str(peer_ip))) + + self.send_check_success(msg) + lst = self.get_ifa_list(iface.ifindex, self.get_family_from_ip(ifa.ip)) + rx_msg = self.find_msg_by_ifa(lst, peer_ip) + assert rx_msg is not None + + msg = NetlinkIfaMessage(self.helper, NlRtMsgType.RTM_DELADDR.value) + msg.set_request() + msg.base_hdr.ifa_family = self.get_family_from_ip(ifa.ip) + msg.base_hdr.ifa_index = iface.ifindex + msg.base_hdr.ifa_prefixlen = ifa.network.prefixlen + + if "a" in ifa_addr_str: + msg.add_nla(NlAttrIp(IfaAttrType.IFA_ADDRESS, str(ifa.ip))) + if "p" in ifa_addr_str: + msg.add_nla(NlAttrIp(IfaAttrType.IFA_ADDRESS, str(peer_ip))) + if "a" in ifa_local_str: + msg.add_nla(NlAttrIp(IfaAttrType.IFA_LOCAL, str(ifa.ip))) + if "p" in ifa_local_str: + msg.add_nla(NlAttrIp(IfaAttrType.IFA_LOCAL, str(peer_ip))) + + self.send_check_success(msg) + lst = self.get_ifa_list(iface.ifindex, self.get_family_from_ip(ifa.ip)) + rx_msg = self.find_msg_by_ifa(lst, ifa.ip) + assert rx_msg is None + + +class TestRtNlAddIfaddrLo(RtnlIfaOps): + IFTYPE = "lo" + + @pytest.mark.parametrize( + "ifa_str", + [ + pytest.param("192.0.2.1/24", id="prefix"), + pytest.param("192.0.2.1/32", id="host"), + ], + ) + def test_add_4(self, ifa_str): + """Tests IPv4 address addition to the loopback interface""" + ifa = ipaddress.ip_interface(ifa_str) + iface = self.vnet.iface_alias_map["if1"] + + msg = self.create_msg(ifa) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_LOCAL, str(ifa.ip))) + + self.send_check_success(msg) + + lst = self.get_ifa_list(iface.ifindex, self.get_family_from_ip(ifa.ip)) + assert len(lst) == 1 + rx_msg = lst[0] + + assert rx_msg.base_hdr.ifa_prefixlen == ifa.network.prefixlen + assert rx_msg.base_hdr.ifa_scope == RtScope.RT_SCOPE_UNIVERSE.value + + assert rx_msg.get_nla(IfaAttrType.IFA_ADDRESS).addr == str(ifa.ip) + assert rx_msg.get_nla(IfaAttrType.IFA_LOCAL).addr == str(ifa.ip) + + @pytest.mark.parametrize( + "ifa_str", + [ + pytest.param("2001:db8::1/64", id="gu_prefix"), + pytest.param("2001:db8::1/128", id="gu_host"), + ], + ) + def test_add_6(self, ifa_str): + """Tests IPv6 address addition to the loopback interface""" + ifa = ipaddress.ip_interface(ifa_str) + iface = self.vnet.iface_alias_map["if1"] + + msg = self.create_msg(ifa) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_LOCAL, str(ifa.ip))) + + self.send_check_success(msg) + + lst = self.get_ifa_list(iface.ifindex, self.get_family_from_ip(ifa.ip)) + assert len(lst) == 1 + rx_msg = self.find_msg_by_ifa(lst, ifa.ip) + assert rx_msg is not None + + assert rx_msg.base_hdr.ifa_prefixlen == ifa.network.prefixlen + assert rx_msg.base_hdr.ifa_scope == RtScope.RT_SCOPE_UNIVERSE.value + assert rx_msg.get_nla(IfaAttrType.IFA_ADDRESS).addr == str(ifa.ip) + + @pytest.mark.parametrize( + "ifa_str", + [ + pytest.param("192.0.2.1/32", id="ipv4_host"), + pytest.param("192.0.2.1/24", id="ipv4_prefix"), + pytest.param("2001:db8::1/64", id="ipv6_gu_prefix"), + pytest.param("2001:db8::1/128", id="ipv6_gu_host"), + ], + ) + @pytest.mark.parametrize( + "tlv", + [ + pytest.param("local", id="ifa_local"), + pytest.param("address", id="ifa_address"), + ], + ) + def test_del(self, tlv, ifa_str): + """Tests address deletion from the loopback interface""" + ifa = ipaddress.ip_interface(ifa_str) + iface = self.vnet.iface_alias_map["if1"] + + msg = self.create_msg(ifa) + msg.add_nla(NlAttrIp(IfaAttrType.IFA_LOCAL, str(ifa.ip))) + + self.send_check_success(msg) + lst = self.get_ifa_list(iface.ifindex, self.get_family_from_ip(ifa.ip)) + rx_msg = self.find_msg_by_ifa(lst, ifa.ip) + assert rx_msg is not None + + msg = NetlinkIfaMessage(self.helper, NlRtMsgType.RTM_DELADDR.value) + msg.set_request() + msg.base_hdr.ifa_family = self.get_family_from_ip(ifa.ip) + msg.base_hdr.ifa_index = iface.ifindex + msg.base_hdr.ifa_prefixlen = ifa.network.prefixlen + + if tlv == "local": + msg.add_nla(NlAttrIp(IfaAttrType.IFA_LOCAL, str(ifa.ip))) + if tlv == "address": + msg.add_nla(NlAttrIp(IfaAttrType.IFA_ADDRESS, str(ifa.ip))) + + self.send_check_success(msg) + lst = self.get_ifa_list(iface.ifindex, self.get_family_from_ip(ifa.ip)) + rx_msg = self.find_msg_by_ifa(lst, ifa.ip) + assert rx_msg is None