/* Interface adding function */
int
ifan_read (struct if_announcemsghdr *ifan)
{
struct interface *ifp;
ifp = if_lookup_by_index (ifan->ifan_index);
if (ifp == NULL && ifan->ifan_what == IFAN_ARRIVAL)
{
/* Create Interface */
ifp = if_get_by_name (ifan->ifan_name);
ifp->ifindex = ifan->ifan_index;
if_add_update (ifp);
}
else if (ifp != NULL && ifan->ifan_what == IFAN_DEPARTURE)
{
if_delete_update (ifp);
if_delete (ifp);
}
if_get_flags (ifp);
if_get_mtu (ifp);
if_get_metric (ifp);
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_info ("interface %s index %d", ifp->name, ifp->ifindex);
return 0;
}
/* Interface structure allocation by proc filesystem. */
int
interface_list_proc ()
{
FILE *fp;
char buf[PROCBUFSIZ];
struct interface *ifp;
char *name;
/* Open /proc/net/dev. */
fp = fopen (_PATH_PROC_NET_DEV, "r");
if (fp == NULL)
{
zlog_warn ("Can't open proc file %s: %s",
_PATH_PROC_NET_DEV, strerror (errno));
return -1;
}
/* Drop header lines. */
fgets (buf, PROCBUFSIZ, fp);
fgets (buf, PROCBUFSIZ, fp);
/* Only allocate interface structure. Other jobs will be done in
if_ioctl.c. */
while (fgets (buf, PROCBUFSIZ, fp) != NULL)
{
interface_name_cut (buf, &name);
ifp = if_get_by_name (name);
if_add_update (ifp);
}
return 0;
}
/* Called from interface_lookup_netlink(). This function is only used
during bootstrap. */
static int
netlink_interface (struct sockaddr_nl *snl, struct nlmsghdr *h)
{
int len;
struct ifinfomsg *ifi;
struct rtattr *tb[IFLA_MAX + 1];
struct interface *ifp;
char *name;
ifi = NLMSG_DATA (h);
if (h->nlmsg_type != RTM_NEWLINK)
return 0;
len = h->nlmsg_len - NLMSG_LENGTH (sizeof (struct ifinfomsg));
if (len < 0)
return -1;
/* Looking up interface name. */
memset (tb, 0, sizeof tb);
netlink_parse_rtattr (tb, IFLA_MAX, IFLA_RTA (ifi), len);
#ifdef IFLA_WIRELESS
/* check for wireless messages to ignore */
if ((tb[IFLA_WIRELESS] != NULL) && (ifi->ifi_change == 0))
{
if (IS_DEBUG_HA(kroute, KROUTE))
zlog_debug ("%s: ignoring IFLA_WIRELESS message", __func__);
return 0;
}
#endif /* IFLA_WIRELESS */
if (tb[IFLA_IFNAME] == NULL)
return -1;
name = (char *) RTA_DATA (tb[IFLA_IFNAME]);
/* Add interface. */
ifp = if_get_by_name (name);
set_ifindex(ifp, ifi->ifi_index);
ifp->flags = ifi->ifi_flags & 0x0000fffff;
ifp->mtu6 = ifp->mtu = *(uint32_t *) RTA_DATA (tb[IFLA_MTU]);
ifp->metric = 1;
/* Hardware type and address. */
ifp->hw_type = ifi->ifi_type;
netlink_interface_update_hw_addr (tb, ifp);
if_add_update (ifp);
return 0;
}
/* Interface adding function */
static int
ifan_read (struct if_announcemsghdr *ifan)
{
struct interface *ifp;
ifp = if_lookup_by_index (ifan->ifan_index);
if (ifp)
assert ( (ifp->ifindex == ifan->ifan_index)
|| (ifp->ifindex == IFINDEX_INTERNAL) );
if ( (ifp == NULL)
|| ((ifp->ifindex == IFINDEX_INTERNAL)
&& (ifan->ifan_what == IFAN_ARRIVAL)) )
{
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug ("%s: creating interface for ifindex %d, name %s",
__func__, ifan->ifan_index, ifan->ifan_name);
/* Create Interface */
ifp = if_get_by_name_len(ifan->ifan_name,
strnlen(ifan->ifan_name,
sizeof(ifan->ifan_name)));
ifp->ifindex = ifan->ifan_index;
if_add_update (ifp);
}
else if (ifp != NULL && ifan->ifan_what == IFAN_DEPARTURE)
if_delete_update (ifp);
if_get_flags (ifp);
if_get_mtu (ifp);
if_get_metric (ifp);
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug ("%s: interface %s index %d",
__func__, ifan->ifan_name, ifan->ifan_index);
return 0;
}
/* Interface adding function called from interface_list. */
int
ifm_read (struct if_msghdr *ifm)
{
struct interface *ifp;
struct sockaddr_dl *sdl = NULL;
sdl = (struct sockaddr_dl *)(ifm + 1);
/* Use sdl index. */
ifp = if_lookup_by_index (ifm->ifm_index);
if (ifp == NULL)
{
/* Check interface's address.*/
if (! (ifm->ifm_addrs & RTA_IFP))
{
zlog_warn ("There must be RTA_IFP address for ifindex %d\n",
ifm->ifm_index);
return -1;
}
ifp = if_create ();
strncpy (ifp->name, sdl->sdl_data, sdl->sdl_nlen);
ifp->ifindex = ifm->ifm_index;
ifp->flags = ifm->ifm_flags;
#if defined(__bsdi__)
if_kvm_get_mtu (ifp);
#else
if_get_mtu (ifp);
#endif /* __bsdi__ */
if_get_metric (ifp);
/* Fetch hardware address. */
if (sdl->sdl_family != AF_LINK)
{
zlog_warn ("sockaddr_dl->sdl_family is not AF_LINK");
return -1;
}
memcpy (&ifp->sdl, sdl, sizeof (struct sockaddr_dl));
if_add_update (ifp);
}
else
{
/* There is a case of promisc, allmulti flag modification. */
if (if_is_up (ifp))
{
ifp->flags = ifm->ifm_flags;
if (! if_is_up (ifp))
if_down (ifp);
}
else
{
ifp->flags = ifm->ifm_flags;
if (if_is_up (ifp))
if_up (ifp);
}
}
#ifdef HAVE_NET_RT_IFLIST
ifp->stats = ifm->ifm_data;
#endif /* HAVE_NET_RT_IFLIST */
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_info ("interface %s index %d", ifp->name, ifp->ifindex);
return 0;
}
/*
* 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
netlink_link_change (struct sockaddr_nl *snl, struct nlmsghdr *h)
{
int len;
struct ifinfomsg *ifi;
struct rtattr *tb[IFLA_MAX + 1];
struct interface *ifp;
char *name;
ifi = NLMSG_DATA (h);
if (!(h->nlmsg_type == RTM_NEWLINK || h->nlmsg_type == RTM_DELLINK))
{
/* If this is not link add/delete message so print warning. */
zlog_warn ("netlink_link_change: wrong kernel message %d\n",
h->nlmsg_type);
return 0;
}
len = h->nlmsg_len - NLMSG_LENGTH (sizeof (struct ifinfomsg));
if (len < 0)
return -1;
/* Looking up interface name. */
memset (tb, 0, sizeof tb);
netlink_parse_rtattr (tb, IFLA_MAX, IFLA_RTA (ifi), len);
#ifdef IFLA_WIRELESS
/* check for wireless messages to ignore */
if ((tb[IFLA_WIRELESS] != NULL) && (ifi->ifi_change == 0))
{
if (IS_DEBUG_HA(kroute, KROUTE))
zlog_debug ("%s: ignoring IFLA_WIRELESS message", __func__);
return 0;
}
#endif /* IFLA_WIRELESS */
if (tb[IFLA_IFNAME] == NULL)
return -1;
name = (char *) RTA_DATA (tb[IFLA_IFNAME]);
/* Add interface. */
if (h->nlmsg_type == RTM_NEWLINK)
{
ifp = if_lookup_by_name (name);
if (ifp == NULL || !CHECK_FLAG (ifp->status, KROUTE_INTERFACE_ACTIVE))
{
if (ifp == NULL)
ifp = if_get_by_name (name);
set_ifindex(ifp, ifi->ifi_index);
ifp->flags = ifi->ifi_flags & 0x0000fffff;
ifp->mtu6 = ifp->mtu = *(int *) RTA_DATA (tb[IFLA_MTU]);
ifp->metric = 1;
netlink_interface_update_hw_addr (tb, ifp);
/* If new link is added. */
if_add_update (ifp);
}
else
{
/* Interface status change. */
set_ifindex(ifp, ifi->ifi_index);
ifp->mtu6 = ifp->mtu = *(int *) RTA_DATA (tb[IFLA_MTU]);
ifp->metric = 1;
netlink_interface_update_hw_addr (tb, ifp);
if (if_is_operative (ifp))
{
ifp->flags = ifi->ifi_flags & 0x0000fffff;
if (!if_is_operative (ifp))
if_down (ifp);
else
/* Must notify client daemons of new interface status. */
kroute_interface_up_update (ifp);
}
else
{
ifp->flags = ifi->ifi_flags & 0x0000fffff;
if (if_is_operative (ifp))
if_up (ifp);
}
}
}
else
{
/* RTM_DELLINK. */
ifp = if_lookup_by_name (name);
if (ifp == NULL)
{
zlog (NULL, LOG_WARNING, "interface %s is deleted but can't find",
name);
return 0;
}
if_delete_update (ifp);
}
return 0;
}
/* Interface looking up using infamous SIOCGIFCONF. */
static int
interface_list_ioctl (void)
{
int ret;
int sock;
#define IFNUM_BASE 32
int ifnum;
struct ifreq *ifreq;
struct ifconf ifconf;
struct interface *ifp;
int n;
int lastlen;
/* Normally SIOCGIFCONF works with AF_INET socket. */
sock = socket (AF_INET, SOCK_DGRAM, 0);
if (sock < 0)
{
zlog_warn ("Can't make AF_INET socket stream: %s", safe_strerror (errno));
return -1;
}
/* Set initial ifreq count. This will be double when SIOCGIFCONF
fail. Solaris has SIOCGIFNUM. */
#ifdef SIOCGIFNUM
ret = ioctl (sock, SIOCGIFNUM, &ifnum);
if (ret < 0)
ifnum = IFNUM_BASE;
else
ifnum++;
#else
ifnum = IFNUM_BASE;
#endif /* SIOCGIFNUM */
ifconf.ifc_buf = NULL;
lastlen = 0;
/* Loop until SIOCGIFCONF success. */
for (;;)
{
ifconf.ifc_len = sizeof (struct ifreq) * ifnum;
ifconf.ifc_buf = XREALLOC(MTYPE_TMP, ifconf.ifc_buf, ifconf.ifc_len);
ret = ioctl(sock, SIOCGIFCONF, &ifconf);
if (ret < 0)
{
zlog_warn ("SIOCGIFCONF: %s", safe_strerror(errno));
goto end;
}
/* Repeatedly get info til buffer fails to grow. */
if (ifconf.ifc_len > lastlen)
{
lastlen = ifconf.ifc_len;
ifnum += 10;
continue;
}
/* Success. */
break;
}
/* Allocate interface. */
ifreq = ifconf.ifc_req;
#ifdef OPEN_BSD
for (n = 0; n < ifconf.ifc_len; )
{
int size;
ifreq = (struct ifreq *)((caddr_t) ifconf.ifc_req + n);
ifp = if_get_by_name_len(ifreq->ifr_name,
strnlen(ifreq->ifr_name,
sizeof(ifreq->ifr_name)));
if_add_update (ifp);
size = ifreq->ifr_addr.sa_len;
if (size < sizeof (ifreq->ifr_addr))
size = sizeof (ifreq->ifr_addr);
size += sizeof (ifreq->ifr_name);
n += size;
}
#else
for (n = 0; n < ifconf.ifc_len; n += sizeof(struct ifreq))
{
ifp = if_get_by_name_len(ifreq->ifr_name,
strnlen(ifreq->ifr_name,
sizeof(ifreq->ifr_name)));
if_add_update (ifp);
ifreq++;
}
#endif /* OPEN_BSD */
end:
close (sock);
XFREE (MTYPE_TMP, ifconf.ifc_buf);
return ret;
}
int
netlink_link_change (struct sockaddr_nl *snl, struct nlmsghdr *h)
{
int len;
struct ifinfomsg *ifi;
struct rtattr *tb [IFLA_MAX + 1];
struct interface *ifp;
char *name;
ifi = NLMSG_DATA (h);
if (! (h->nlmsg_type == RTM_NEWLINK || h->nlmsg_type == RTM_DELLINK))
{
/* If this is not link add/delete message so print warning. */
zlog_warn ("netlink_link_change: wrong kernel message %d\n",
h->nlmsg_type);
return 0;
}
len = h->nlmsg_len - NLMSG_LENGTH (sizeof (struct ifinfomsg));
if (len < 0)
return -1;
/* Looking up interface name. */
memset (tb, 0, sizeof tb);
netlink_parse_rtattr (tb, IFLA_MAX, IFLA_RTA (ifi), len);
if (tb[IFLA_IFNAME] == NULL)
return -1;
name = (char *)RTA_DATA(tb[IFLA_IFNAME]);
/* Add interface. */
if (h->nlmsg_type == RTM_NEWLINK)
{
ifp = if_lookup_by_name (name);
if (ifp == NULL || ! CHECK_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE))
{
if (ifp == NULL)
ifp = if_get_by_name (name);
ifp->ifindex = ifi->ifi_index;
ifp->flags = ifi->ifi_flags & 0x0000fffff;
ifp->mtu = *(int *)RTA_DATA (tb[IFLA_MTU]);
ifp->metric = 1;
/* If new link is added. */
if_add_update(ifp);
}
else
{
/* Interface status change. */
ifp->ifindex = ifi->ifi_index;
ifp->mtu = *(int *)RTA_DATA (tb[IFLA_MTU]);
ifp->metric = 1;
if (if_is_up (ifp))
{
ifp->flags = ifi->ifi_flags & 0x0000fffff;
if (! if_is_up (ifp))
if_down (ifp);
}
else
{
ifp->flags = ifi->ifi_flags & 0x0000fffff;
if (if_is_up (ifp))
if_up (ifp);
}
}
}
else
{
/* RTM_DELLINK. */
ifp = if_lookup_by_name (name);
if (ifp == NULL)
{
zlog (NULL, LOG_WARNING, "interface %s is deleted but can't find",
ifp->name);
return 0;
}
if_delete_update (ifp);
}
return 0;
}
/* Called from interface_lookup_netlink(). This function is only used
during bootstrap. */
int
netlink_interface (struct sockaddr_nl *snl, struct nlmsghdr *h)
{
int len;
struct ifinfomsg *ifi;
struct rtattr *tb[IFLA_MAX + 1];
struct interface *ifp;
char *name;
int i;
ifi = NLMSG_DATA (h);
if (h->nlmsg_type != RTM_NEWLINK)
return 0;
len = h->nlmsg_len - NLMSG_LENGTH (sizeof (struct ifinfomsg));
if (len < 0)
return -1;
/* Looking up interface name. */
memset (tb, 0, sizeof tb);
netlink_parse_rtattr (tb, IFLA_MAX, IFLA_RTA (ifi), len);
if (tb[IFLA_IFNAME] == NULL)
return -1;
name = (char *)RTA_DATA(tb[IFLA_IFNAME]);
/* Add interface. */
ifp = if_get_by_name (name);
ifp->ifindex = ifi->ifi_index;
ifp->flags = ifi->ifi_flags & 0x0000fffff;
ifp->mtu = *(int *)RTA_DATA (tb[IFLA_MTU]);
ifp->metric = 1;
/* Hardware type and address. */
ifp->hw_type = ifi->ifi_type;
if (tb[IFLA_ADDRESS])
{
int hw_addr_len;
hw_addr_len = RTA_PAYLOAD(tb[IFLA_ADDRESS]);
if (hw_addr_len > INTERFACE_HWADDR_MAX)
zlog_warn ("Hardware address is too large: %d", hw_addr_len);
else
{
ifp->hw_addr_len = hw_addr_len;
memcpy (ifp->hw_addr, RTA_DATA(tb[IFLA_ADDRESS]), hw_addr_len);
for (i = 0; i < hw_addr_len; i++)
if (ifp->hw_addr[i] != 0)
break;
if (i == hw_addr_len)
ifp->hw_addr_len = 0;
else
ifp->hw_addr_len = hw_addr_len;
}
}
if_add_update (ifp);
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;
}
/*
* Called from interface_lookup_netlink(). This function is only used
* during bootstrap.
*/
static int netlink_interface(struct nlmsghdr *h, ns_id_t ns_id, int startup)
{
int len;
struct ifinfomsg *ifi;
struct rtattr *tb[IFLA_MAX + 1];
struct rtattr *linkinfo[IFLA_MAX + 1];
struct interface *ifp;
char *name = NULL;
char *kind = NULL;
char *desc = NULL;
char *slave_kind = NULL;
struct zebra_ns *zns;
vrf_id_t vrf_id = VRF_DEFAULT;
zebra_iftype_t zif_type = ZEBRA_IF_OTHER;
zebra_slave_iftype_t zif_slave_type = ZEBRA_IF_SLAVE_NONE;
ifindex_t bridge_ifindex = IFINDEX_INTERNAL;
ifindex_t link_ifindex = IFINDEX_INTERNAL;
zns = zebra_ns_lookup(ns_id);
ifi = NLMSG_DATA(h);
if (h->nlmsg_type != RTM_NEWLINK)
return 0;
len = h->nlmsg_len - NLMSG_LENGTH(sizeof(struct ifinfomsg));
if (len < 0) {
zlog_err("%s: Message received from netlink is of a broken size: %d %zu",
__PRETTY_FUNCTION__,
h->nlmsg_len,
(size_t)NLMSG_LENGTH(sizeof(struct ifinfomsg)));
return -1;
}
/* We are interested in some AF_BRIDGE notifications. */
if (ifi->ifi_family == AF_BRIDGE)
return netlink_bridge_interface(h, len, ns_id, startup);
/* Looking up interface name. */
memset(tb, 0, sizeof tb);
memset(linkinfo, 0, sizeof linkinfo);
netlink_parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), len);
/* check for wireless messages to ignore */
if ((tb[IFLA_WIRELESS] != NULL) && (ifi->ifi_change == 0)) {
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug("%s: ignoring IFLA_WIRELESS message",
__func__);
return 0;
}
if (tb[IFLA_IFNAME] == NULL)
return -1;
name = (char *)RTA_DATA(tb[IFLA_IFNAME]);
if (tb[IFLA_IFALIAS])
desc = (char *)RTA_DATA(tb[IFLA_IFALIAS]);
if (tb[IFLA_LINKINFO]) {
parse_rtattr_nested(linkinfo, IFLA_INFO_MAX, tb[IFLA_LINKINFO]);
if (linkinfo[IFLA_INFO_KIND])
kind = RTA_DATA(linkinfo[IFLA_INFO_KIND]);
if (linkinfo[IFLA_INFO_SLAVE_KIND])
slave_kind = RTA_DATA(linkinfo[IFLA_INFO_SLAVE_KIND]);
netlink_determine_zebra_iftype(kind, &zif_type);
}
/* If VRF, create the VRF structure itself. */
if (zif_type == ZEBRA_IF_VRF && !vrf_is_backend_netns()) {
netlink_vrf_change(h, tb[IFLA_LINKINFO], name);
vrf_id = (vrf_id_t)ifi->ifi_index;
}
if (tb[IFLA_MASTER]) {
if (slave_kind && (strcmp(slave_kind, "vrf") == 0)
&& !vrf_is_backend_netns()) {
zif_slave_type = ZEBRA_IF_SLAVE_VRF;
vrf_id = *(uint32_t *)RTA_DATA(tb[IFLA_MASTER]);
} else if (slave_kind && (strcmp(slave_kind, "bridge") == 0)) {
zif_slave_type = ZEBRA_IF_SLAVE_BRIDGE;
bridge_ifindex =
*(ifindex_t *)RTA_DATA(tb[IFLA_MASTER]);
} else
zif_slave_type = ZEBRA_IF_SLAVE_OTHER;
}
if (vrf_is_backend_netns())
vrf_id = (vrf_id_t)ns_id;
/* If linking to another interface, note it. */
if (tb[IFLA_LINK])
link_ifindex = *(ifindex_t *)RTA_DATA(tb[IFLA_LINK]);
/* Add interface. */
ifp = if_get_by_name(name, vrf_id, 0);
set_ifindex(ifp, ifi->ifi_index, zns);
ifp->flags = ifi->ifi_flags & 0x0000fffff;
ifp->mtu6 = ifp->mtu = *(uint32_t *)RTA_DATA(tb[IFLA_MTU]);
ifp->metric = 0;
ifp->speed = get_iflink_speed(ifp);
ifp->ptm_status = ZEBRA_PTM_STATUS_UNKNOWN;
if (desc)
ifp->desc = XSTRDUP(MTYPE_TMP, desc);
/* Set zebra interface type */
zebra_if_set_ziftype(ifp, zif_type, zif_slave_type);
if (IS_ZEBRA_IF_VRF(ifp))
SET_FLAG(ifp->status, ZEBRA_INTERFACE_VRF_LOOPBACK);
/* Update link. */
zebra_if_update_link(ifp, link_ifindex);
/* Hardware type and address. */
ifp->ll_type = netlink_to_zebra_link_type(ifi->ifi_type);
netlink_interface_update_hw_addr(tb, ifp);
if_add_update(ifp);
/* Extract and save L2 interface information, take additional actions.
*/
netlink_interface_update_l2info(ifp, linkinfo[IFLA_INFO_DATA], 1);
if (IS_ZEBRA_IF_BRIDGE_SLAVE(ifp))
zebra_l2if_update_bridge_slave(ifp, bridge_ifindex);
return 0;
}
int netlink_link_change(struct nlmsghdr *h, ns_id_t ns_id, int startup)
{
int len;
struct ifinfomsg *ifi;
struct rtattr *tb[IFLA_MAX + 1];
struct rtattr *linkinfo[IFLA_MAX + 1];
struct interface *ifp;
char *name = NULL;
char *kind = NULL;
char *desc = NULL;
char *slave_kind = NULL;
struct zebra_ns *zns;
vrf_id_t vrf_id = VRF_DEFAULT;
zebra_iftype_t zif_type = ZEBRA_IF_OTHER;
zebra_slave_iftype_t zif_slave_type = ZEBRA_IF_SLAVE_NONE;
ifindex_t bridge_ifindex = IFINDEX_INTERNAL;
ifindex_t link_ifindex = IFINDEX_INTERNAL;
zns = zebra_ns_lookup(ns_id);
ifi = NLMSG_DATA(h);
/* assume if not default zns, then new VRF */
if (!(h->nlmsg_type == RTM_NEWLINK || h->nlmsg_type == RTM_DELLINK)) {
/* If this is not link add/delete message so print warning. */
zlog_warn("netlink_link_change: wrong kernel message %d",
h->nlmsg_type);
return 0;
}
if (!(ifi->ifi_family == AF_UNSPEC || ifi->ifi_family == AF_BRIDGE
|| ifi->ifi_family == AF_INET6)) {
zlog_warn(
"Invalid address family: %u received from kernel link change: %u",
ifi->ifi_family, h->nlmsg_type);
return 0;
}
len = h->nlmsg_len - NLMSG_LENGTH(sizeof(struct ifinfomsg));
if (len < 0) {
zlog_err("%s: Message received from netlink is of a broken size %d %zu",
__PRETTY_FUNCTION__, h->nlmsg_len,
(size_t)NLMSG_LENGTH(sizeof(struct ifinfomsg)));
return -1;
}
/* We are interested in some AF_BRIDGE notifications. */
if (ifi->ifi_family == AF_BRIDGE)
return netlink_bridge_interface(h, len, ns_id, startup);
/* Looking up interface name. */
memset(tb, 0, sizeof tb);
memset(linkinfo, 0, sizeof linkinfo);
netlink_parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), len);
/* check for wireless messages to ignore */
if ((tb[IFLA_WIRELESS] != NULL) && (ifi->ifi_change == 0)) {
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug("%s: ignoring IFLA_WIRELESS message",
__func__);
return 0;
}
if (tb[IFLA_IFNAME] == NULL)
return -1;
name = (char *)RTA_DATA(tb[IFLA_IFNAME]);
if (tb[IFLA_LINKINFO]) {
parse_rtattr_nested(linkinfo, IFLA_INFO_MAX, tb[IFLA_LINKINFO]);
if (linkinfo[IFLA_INFO_KIND])
kind = RTA_DATA(linkinfo[IFLA_INFO_KIND]);
if (linkinfo[IFLA_INFO_SLAVE_KIND])
slave_kind = RTA_DATA(linkinfo[IFLA_INFO_SLAVE_KIND]);
netlink_determine_zebra_iftype(kind, &zif_type);
}
/* If linking to another interface, note it. */
if (tb[IFLA_LINK])
link_ifindex = *(ifindex_t *)RTA_DATA(tb[IFLA_LINK]);
if (tb[IFLA_IFALIAS]) {
desc = (char *)RTA_DATA(tb[IFLA_IFALIAS]);
}
/* If VRF, create or update the VRF structure itself. */
if (zif_type == ZEBRA_IF_VRF && !vrf_is_backend_netns()) {
netlink_vrf_change(h, tb[IFLA_LINKINFO], name);
vrf_id = (vrf_id_t)ifi->ifi_index;
}
/* See if interface is present. */
ifp = if_lookup_by_name_per_ns(zns, name);
if (ifp) {
if (ifp->desc)
XFREE(MTYPE_TMP, ifp->desc);
if (desc)
ifp->desc = XSTRDUP(MTYPE_TMP, desc);
}
if (h->nlmsg_type == RTM_NEWLINK) {
if (tb[IFLA_MASTER]) {
if (slave_kind && (strcmp(slave_kind, "vrf") == 0)
&& !vrf_is_backend_netns()) {
zif_slave_type = ZEBRA_IF_SLAVE_VRF;
vrf_id = *(uint32_t *)RTA_DATA(tb[IFLA_MASTER]);
} else if (slave_kind
&& (strcmp(slave_kind, "bridge") == 0)) {
zif_slave_type = ZEBRA_IF_SLAVE_BRIDGE;
bridge_ifindex =
*(ifindex_t *)RTA_DATA(tb[IFLA_MASTER]);
} else
zif_slave_type = ZEBRA_IF_SLAVE_OTHER;
}
if (vrf_is_backend_netns())
vrf_id = (vrf_id_t)ns_id;
if (ifp == NULL
|| !CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_ACTIVE)) {
/* Add interface notification from kernel */
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug(
"RTM_NEWLINK ADD for %s(%u) vrf_id %u type %d "
"sl_type %d master %u flags 0x%x",
name, ifi->ifi_index, vrf_id, zif_type,
zif_slave_type, bridge_ifindex,
ifi->ifi_flags);
if (ifp == NULL) {
/* unknown interface */
ifp = if_get_by_name(name, vrf_id, 0);
} else {
/* pre-configured interface, learnt now */
if (ifp->vrf_id != vrf_id)
if_update_to_new_vrf(ifp, vrf_id);
}
/* Update interface information. */
set_ifindex(ifp, ifi->ifi_index, zns);
ifp->flags = ifi->ifi_flags & 0x0000fffff;
if (!tb[IFLA_MTU]) {
zlog_warn(
"RTM_NEWLINK for interface %s(%u) without MTU set",
name, ifi->ifi_index);
return 0;
}
ifp->mtu6 = ifp->mtu = *(int *)RTA_DATA(tb[IFLA_MTU]);
ifp->metric = 0;
ifp->ptm_status = ZEBRA_PTM_STATUS_UNKNOWN;
/* Set interface type */
zebra_if_set_ziftype(ifp, zif_type, zif_slave_type);
if (IS_ZEBRA_IF_VRF(ifp))
SET_FLAG(ifp->status,
ZEBRA_INTERFACE_VRF_LOOPBACK);
/* Update link. */
zebra_if_update_link(ifp, link_ifindex);
netlink_interface_update_hw_addr(tb, ifp);
/* Inform clients, install any configured addresses. */
if_add_update(ifp);
/* Extract and save L2 interface information, take
* additional actions. */
netlink_interface_update_l2info(
ifp, linkinfo[IFLA_INFO_DATA], 1);
if (IS_ZEBRA_IF_BRIDGE_SLAVE(ifp))
zebra_l2if_update_bridge_slave(ifp,
bridge_ifindex);
if_netlink_check_ifp_instance_consistency(RTM_NEWLINK,
ifp, ns_id);
} else if (ifp->vrf_id != vrf_id) {
/* VRF change for an interface. */
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug(
"RTM_NEWLINK vrf-change for %s(%u) "
"vrf_id %u -> %u flags 0x%x",
name, ifp->ifindex, ifp->vrf_id, vrf_id,
ifi->ifi_flags);
if_handle_vrf_change(ifp, vrf_id);
} else {
int was_bridge_slave;
/* Interface update. */
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug(
"RTM_NEWLINK update for %s(%u) "
"sl_type %d master %u flags 0x%x",
name, ifp->ifindex, zif_slave_type,
bridge_ifindex, ifi->ifi_flags);
set_ifindex(ifp, ifi->ifi_index, zns);
if (!tb[IFLA_MTU]) {
zlog_warn(
"RTM_NEWLINK for interface %s(%u) without MTU set",
name, ifi->ifi_index);
return 0;
}
ifp->mtu6 = ifp->mtu = *(int *)RTA_DATA(tb[IFLA_MTU]);
ifp->metric = 0;
/* Update interface type - NOTE: Only slave_type can
* change. */
was_bridge_slave = IS_ZEBRA_IF_BRIDGE_SLAVE(ifp);
zebra_if_set_ziftype(ifp, zif_type, zif_slave_type);
netlink_interface_update_hw_addr(tb, ifp);
if (if_is_no_ptm_operative(ifp)) {
ifp->flags = ifi->ifi_flags & 0x0000fffff;
if (!if_is_no_ptm_operative(ifp)) {
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug(
"Intf %s(%u) has gone DOWN",
name, ifp->ifindex);
if_down(ifp);
} else if (if_is_operative(ifp)) {
/* Must notify client daemons of new
* interface status. */
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug(
"Intf %s(%u) PTM up, notifying clients",
name, ifp->ifindex);
zebra_interface_up_update(ifp);
}
} else {
ifp->flags = ifi->ifi_flags & 0x0000fffff;
if (if_is_operative(ifp)) {
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug(
"Intf %s(%u) has come UP",
name, ifp->ifindex);
if_up(ifp);
}
}
/* Extract and save L2 interface information, take
* additional actions. */
netlink_interface_update_l2info(
ifp, linkinfo[IFLA_INFO_DATA], 0);
if (IS_ZEBRA_IF_BRIDGE_SLAVE(ifp) || was_bridge_slave)
zebra_l2if_update_bridge_slave(ifp,
bridge_ifindex);
if_netlink_check_ifp_instance_consistency(RTM_NEWLINK,
ifp, ns_id);
}
} else {
/* Delete interface notification from kernel */
if (ifp == NULL) {
zlog_warn("RTM_DELLINK for unknown interface %s(%u)",
name, ifi->ifi_index);
return 0;
}
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug("RTM_DELLINK for %s(%u)", name,
ifp->ifindex);
UNSET_FLAG(ifp->status, ZEBRA_INTERFACE_VRF_LOOPBACK);
/* Special handling for bridge or VxLAN interfaces. */
if (IS_ZEBRA_IF_BRIDGE(ifp))
zebra_l2_bridge_del(ifp);
else if (IS_ZEBRA_IF_VXLAN(ifp))
zebra_l2_vxlanif_del(ifp);
if (!IS_ZEBRA_IF_VRF(ifp))
if_delete_update(ifp);
if_netlink_check_ifp_instance_consistency(RTM_DELLINK,
ifp, ns_id);
}
return 0;
}
