/* get interface flags */
void if_get_flags(struct interface *ifp)
{
int ret4 = 0, ret6 = 0;
uint64_t newflags = 0;
uint64_t tmpflags;
if (ifp->flags & IFF_IPV4) {
ret4 = if_get_flags_direct(ifp->name, &tmpflags, AF_INET);
if (!ret4)
newflags |= tmpflags;
else if (errno == ENXIO) {
/* it's gone */
UNSET_FLAG(ifp->flags, IFF_UP);
if_flags_update(ifp, ifp->flags);
}
}
if (ifp->flags & IFF_IPV6) {
ret6 = if_get_flags_direct(ifp->name, &tmpflags, AF_INET6);
if (!ret6)
newflags |= tmpflags;
else if (errno == ENXIO) {
/* it's gone */
UNSET_FLAG(ifp->flags, IFF_UP);
if_flags_update(ifp, ifp->flags);
}
}
/* only update flags if one of above succeeded */
if (!(ret4 && ret6))
if_flags_update(ifp, newflags);
}
/* get interface flags */
void if_get_flags (struct interface *ifp)
{
int ret = 0;
struct ifreq ifreq;
ifreq_set_name (&ifreq, ifp);
ret = if_ioctl (SIOCGIFFLAGS, (caddr_t) &ifreq);
if (ret < 0)
{
zlog_err("if_ioctl(SIOCGIFFLAGS) failed: %s", safe_strerror(errno));
return;
}
if_flags_update (ifp, (ifreq.ifr_flags & 0x0000ffff));
}
/* get interface flags */
void if_get_flags(struct interface *ifp)
{
int ret;
struct ifreq ifreq;
#ifdef HAVE_BSD_LINK_DETECT
struct ifmediareq ifmr;
#endif /* HAVE_BSD_LINK_DETECT */
ifreq_set_name(&ifreq, ifp);
ret = vrf_if_ioctl(SIOCGIFFLAGS, (caddr_t)&ifreq, ifp->vrf_id);
if (ret < 0) {
flog_err_sys(EC_LIB_SYSTEM_CALL,
"vrf_if_ioctl(SIOCGIFFLAGS) failed: %s",
safe_strerror(errno));
return;
}
#ifdef HAVE_BSD_LINK_DETECT /* Detect BSD link-state at start-up */
/* Per-default, IFF_RUNNING is held high, unless link-detect says
* otherwise - we abuse IFF_RUNNING inside zebra as a link-state flag,
* following practice on Linux and Solaris kernels
*/
SET_FLAG(ifreq.ifr_flags, IFF_RUNNING);
if (CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_LINKDETECTION)) {
(void)memset(&ifmr, 0, sizeof(ifmr));
strlcpy(ifmr.ifm_name, ifp->name, sizeof(ifmr.ifm_name));
/* Seems not all interfaces implement this ioctl */
if (if_ioctl(SIOCGIFMEDIA, (caddr_t)&ifmr) == -1 &&
errno != EINVAL)
flog_err_sys(EC_LIB_SYSTEM_CALL,
"if_ioctl(SIOCGIFMEDIA) failed: %s",
safe_strerror(errno));
else if (ifmr.ifm_status & IFM_AVALID) /* Link state is valid */
{
if (ifmr.ifm_status & IFM_ACTIVE)
SET_FLAG(ifreq.ifr_flags, IFF_RUNNING);
else
UNSET_FLAG(ifreq.ifr_flags, IFF_RUNNING);
}
}
#endif /* HAVE_BSD_LINK_DETECT */
if_flags_update(ifp, (ifreq.ifr_flags & 0x0000ffff));
}
/*
* Handle struct if_msghdr obtained from reading routing socket or
* sysctl (from interface_list). There may or may not be sockaddrs
* present after the header.
*/
int
ifm_read (struct if_msghdr *ifm)
{
struct interface *ifp = NULL;
char ifname[IFNAMSIZ];
short ifnlen = 0;
caddr_t *cp;
/* terminate ifname at head (for strnlen) and tail (for safety) */
ifname[IFNAMSIZ - 1] = '\0';
/* paranoia: sanity check structure */
if (ifm->ifm_msglen < sizeof(struct if_msghdr))
{
zlog_err ("ifm_read: ifm->ifm_msglen %d too short\n",
ifm->ifm_msglen);
return -1;
}
/*
* Check for a sockaddr_dl following the message. First, point to
* where a socakddr might be if one follows the message.
*/
cp = (void *)(ifm + 1);
#ifdef SUNOS_5
/*
* XXX This behavior should be narrowed to only the kernel versions
* for which the structures returned do not match the headers.
*
* if_msghdr_t on 64 bit kernels in Solaris 9 and earlier versions
* is 12 bytes larger than the 32 bit version.
*/
if (((struct sockaddr *) cp)->sa_family == AF_UNSPEC)
cp = cp + 12;
#endif
RTA_ADDR_GET (NULL, RTA_DST, ifm->ifm_addrs, cp);
RTA_ADDR_GET (NULL, RTA_GATEWAY, ifm->ifm_addrs, cp);
RTA_ATTR_GET (NULL, RTA_NETMASK, ifm->ifm_addrs, cp);
RTA_ADDR_GET (NULL, RTA_GENMASK, ifm->ifm_addrs, cp);
RTA_NAME_GET (ifname, RTA_IFP, ifm->ifm_addrs, cp, ifnlen);
RTA_ADDR_GET (NULL, RTA_IFA, ifm->ifm_addrs, cp);
RTA_ADDR_GET (NULL, RTA_AUTHOR, ifm->ifm_addrs, cp);
RTA_ADDR_GET (NULL, RTA_BRD, ifm->ifm_addrs, cp);
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug ("%s: sdl ifname %s", __func__, (ifnlen ? ifname : "(nil)"));
/*
* Look up on ifindex first, because ifindices are the primary handle for
* interfaces across the user/kernel boundary, for most systems. (Some
* messages, such as up/down status changes on NetBSD, do not include a
* sockaddr_dl).
*/
if ( (ifp = if_lookup_by_index (ifm->ifm_index)) != NULL )
{
/* we have an ifp, verify that the name matches as some systems,
* eg Solaris, have a 1:many association of ifindex:ifname
* if they dont match, we dont have the correct ifp and should
* set it back to NULL to let next check do lookup by name
*/
if (ifnlen && (strncmp (ifp->name, ifname, IFNAMSIZ) != 0) )
{
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug ("%s: ifp name %s doesnt match sdl name %s",
__func__, ifp->name, ifname);
ifp = NULL;
}
}
/*
* If we dont have an ifp, try looking up by name. Particularly as some
* systems (Solaris) have a 1:many mapping of ifindex:ifname - the ifname
* is therefore our unique handle to that interface.
*
* Interfaces specified in the configuration file for which the ifindex
* has not been determined will have ifindex == IFINDEX_INTERNAL, and such
* interfaces are found by this search, and then their ifindex values can
* be filled in.
*/
if ( (ifp == NULL) && ifnlen)
ifp = if_lookup_by_name (ifname);
/*
* If ifp still does not exist or has an invalid index (IFINDEX_INTERNAL),
* create or fill in an interface.
*/
if ((ifp == NULL) || (ifp->ifindex == IFINDEX_INTERNAL))
{
/*
* To create or fill in an interface, a sockaddr_dl (via
* RTA_IFP) is required.
*/
if (!ifnlen)
{
zlog_warn ("Interface index %d (new) missing ifname\n",
ifm->ifm_index);
return -1;
}
#ifndef RTM_IFANNOUNCE
/* Down->Down interface should be ignored here.
* See further comment below.
*/
if (!CHECK_FLAG (ifm->ifm_flags, IFF_UP))
return 0;
#endif /* !RTM_IFANNOUNCE */
if (ifp == NULL)
{
/* Interface that zebra was not previously aware of, so create. */
ifp = if_create (ifname, ifnlen);
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug ("%s: creating ifp for ifindex %d",
__func__, ifm->ifm_index);
}
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug ("%s: updated/created ifp, ifname %s, ifindex %d",
__func__, ifp->name, ifp->ifindex);
/*
* Fill in newly created interface structure, or larval
* structure with ifindex IFINDEX_INTERNAL.
*/
ifp->ifindex = ifm->ifm_index;
#ifdef HAVE_BSD_LINK_DETECT /* translate BSD kernel msg for link-state */
bsd_linkdetect_translate(ifm);
#endif /* HAVE_BSD_LINK_DETECT */
if_flags_update (ifp, ifm->ifm_flags);
#if defined(__bsdi__)
if_kvm_get_mtu (ifp);
#else
if_get_mtu (ifp);
#endif /* __bsdi__ */
if_get_metric (ifp);
if_add_update (ifp);
}
else
/*
* Interface structure exists. Adjust stored flags from
* notification. If interface has up->down or down->up
* transition, call state change routines (to adjust routes,
* notify routing daemons, etc.). (Other flag changes are stored
* but apparently do not trigger action.)
*/
{
if (ifp->ifindex != ifm->ifm_index)
{
zlog_warn ("%s: index mismatch, ifname %s, ifp index %d, "
"ifm index %d",
__func__, ifp->name, ifp->ifindex, ifm->ifm_index);
return -1;
}
#ifdef HAVE_BSD_LINK_DETECT /* translate BSD kernel msg for link-state */
bsd_linkdetect_translate(ifm);
#endif /* HAVE_BSD_LINK_DETECT */
/* update flags and handle operative->inoperative transition, if any */
if_flags_update (ifp, ifm->ifm_flags);
#ifndef RTM_IFANNOUNCE
if (!if_is_up (ifp))
{
/* No RTM_IFANNOUNCE on this platform, so we can never
* distinguish between ~IFF_UP and delete. We must presume
* it has been deleted.
* Eg, Solaris will not notify us of unplumb.
*
* XXX: Fixme - this should be runtime detected
* So that a binary compiled on a system with IFANNOUNCE
* will still behave correctly if run on a platform without
*/
if_delete_update (ifp);
}
#endif /* RTM_IFANNOUNCE */
if (if_is_up (ifp))
{
#if defined(__bsdi__)
if_kvm_get_mtu (ifp);
#else
if_get_mtu (ifp);
#endif /* __bsdi__ */
if_get_metric (ifp);
}
}
#ifdef HAVE_NET_RT_IFLIST
ifp->stats = ifm->ifm_data;
#endif /* HAVE_NET_RT_IFLIST */
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug ("%s: interface %s index %d",
__func__, ifp->name, ifp->ifindex);
return 0;
}
static int
interface_list_ioctl (int af)
{
int ret;
int sock;
#define IFNUM_BASE 32
struct lifnum lifn;
int ifnum;
struct lifreq *lifreq;
struct lifconf lifconf;
struct interface *ifp;
int n;
int save_errno;
size_t needed, lastneeded = 0;
char *buf = NULL;
if (zserv_privs.change(ZPRIVS_RAISE))
zlog (NULL, LOG_ERR, "Can't raise privileges");
sock = socket (af, SOCK_DGRAM, 0);
if (sock < 0)
{
zlog_warn ("Can't make %s socket stream: %s",
(af == AF_INET ? "AF_INET" : "AF_INET6"), safe_strerror (errno));
if (zserv_privs.change(ZPRIVS_LOWER))
zlog (NULL, LOG_ERR, "Can't lower privileges");
return -1;
}
calculate_lifc_len: /* must hold privileges to enter here */
lifn.lifn_family = af;
lifn.lifn_flags = LIFC_NOXMIT; /* we want NOXMIT interfaces too */
ret = ioctl (sock, SIOCGLIFNUM, &lifn);
save_errno = errno;
if (zserv_privs.change(ZPRIVS_LOWER))
zlog (NULL, LOG_ERR, "Can't lower privileges");
if (ret < 0)
{
zlog_warn ("interface_list_ioctl: SIOCGLIFNUM failed %s",
safe_strerror (save_errno));
close (sock);
return -1;
}
ifnum = lifn.lifn_count;
/*
* When calculating the buffer size needed, add a small number
* of interfaces to those we counted. We do this to capture
* the interface status of potential interfaces which may have
* been plumbed between the SIOCGLIFNUM and the SIOCGLIFCONF.
*/
needed = (ifnum + 4) * sizeof (struct lifreq);
if (needed > lastneeded || needed < lastneeded / 2)
{
if (buf != NULL)
XFREE (MTYPE_TMP, buf);
if ((buf = XMALLOC (MTYPE_TMP, needed)) == NULL)
{
zlog_warn ("interface_list_ioctl: malloc failed");
close (sock);
return -1;
}
}
lastneeded = needed;
lifconf.lifc_family = af;
lifconf.lifc_flags = LIFC_NOXMIT;
lifconf.lifc_len = needed;
lifconf.lifc_buf = buf;
if (zserv_privs.change(ZPRIVS_RAISE))
zlog (NULL, LOG_ERR, "Can't raise privileges");
ret = ioctl (sock, SIOCGLIFCONF, &lifconf);
if (ret < 0)
{
if (errno == EINVAL)
goto calculate_lifc_len; /* deliberately hold privileges */
zlog_warn ("SIOCGLIFCONF: %s", safe_strerror (errno));
if (zserv_privs.change(ZPRIVS_LOWER))
zlog (NULL, LOG_ERR, "Can't lower privileges");
goto end;
}
if (zserv_privs.change(ZPRIVS_LOWER))
zlog (NULL, LOG_ERR, "Can't lower privileges");
/* Allocate interface. */
lifreq = lifconf.lifc_req;
for (n = 0; n < lifconf.lifc_len; n += sizeof (struct lifreq))
{
/* we treat Solaris logical interfaces as addresses, because that is
* how PF_ROUTE on Solaris treats them. Hence we can not directly use
* the lifreq_name to get the ifp. We need to normalise the name
* before attempting get.
*
* Solaris logical interface names are in the form of:
* <interface name>:<logical interface id>
*/
unsigned int normallen = 0;
uint64_t lifflags;
/* We should exclude ~IFF_UP interfaces, as we'll find out about them
* coming up later through RTM_NEWADDR message on the route socket.
*/
if (if_get_flags_direct (lifreq->lifr_name, &lifflags,
lifreq->lifr_addr.ss_family)
|| !CHECK_FLAG (lifflags, IFF_UP))
{
lifreq++;
continue;
}
/* Find the normalised name */
while ( (normallen < sizeof(lifreq->lifr_name))
&& ( *(lifreq->lifr_name + normallen) != '\0')
&& ( *(lifreq->lifr_name + normallen) != ':') )
normallen++;
ifp = if_get_by_name_len(lifreq->lifr_name, normallen);
if (lifreq->lifr_addr.ss_family == AF_INET)
ifp->flags |= IFF_IPV4;
if (lifreq->lifr_addr.ss_family == AF_INET6)
{
#ifdef HAVE_IPV6
ifp->flags |= IFF_IPV6;
#else
lifreq++;
continue;
#endif /* HAVE_IPV6 */
}
if_add_update (ifp);
interface_info_ioctl (ifp);
/* If a logical interface pass the full name so it can be
* as a label on the address
*/
if ( *(lifreq->lifr_name + normallen) != '\0')
if_get_addr (ifp, (struct sockaddr *) &lifreq->lifr_addr,
lifreq->lifr_name);
else
if_get_addr (ifp, (struct sockaddr *) &lifreq->lifr_addr, NULL);
/* Poke the interface flags. Lets IFF_UP mangling kick in */
if_flags_update (ifp, ifp->flags);
lifreq++;
}
end:
close (sock);
XFREE (MTYPE_TMP, lifconf.lifc_buf);
return ret;
}
