[mirror_frr.git] / zebra / if_ioctl_solaris.c

/*
 * Interface looking up by ioctl () on Solaris.
 * Copyright (C) 1997, 98 Kunihiro Ishiguro
 *
 * This file is part of GNU Zebra.
 *
 * GNU Zebra is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * GNU Zebra is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with GNU Zebra; see the file COPYING.  If not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.  
 */

#include <zebra.h>

#include "if.h"
#include "sockunion.h"
#include "prefix.h"
#include "ioctl.h"
#include "connected.h"
#include "memory.h"
#include "log.h"
#include "privs.h"
#include "vrf.h"

#include "zebra/interface.h"
#include "zebra/rib.h"

void lifreq_set_name (struct lifreq *, const char *);
int if_get_flags_direct (const char *, uint64_t *, unsigned int af);
static int if_get_addr (struct interface *, struct sockaddr *, const char *);
static void interface_info_ioctl (struct interface *);
extern struct zebra_privs_t zserv_privs;

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;
}

/* Get interface's index by ioctl. */
int
if_get_index (struct interface *ifp)
{
  int ret;
  struct lifreq lifreq;

  lifreq_set_name (&lifreq, ifp->name);

  if (ifp->flags & IFF_IPV4)
    ret = AF_IOCTL (AF_INET, SIOCGLIFINDEX, (caddr_t) & lifreq);
  else if (ifp->flags & IFF_IPV6)
    ret = AF_IOCTL (AF_INET6, SIOCGLIFINDEX, (caddr_t) & lifreq);
  else
    ret = -1;

  if (ret < 0)
    {
      zlog_warn ("SIOCGLIFINDEX(%s) failed", ifp->name);
      return ret;
    }

  /* OK we got interface index. */
#ifdef ifr_ifindex
  ifp->ifindex = lifreq.lifr_ifindex;
#else
  ifp->ifindex = lifreq.lifr_index;
#endif
  return ifp->ifindex;

}


/* Interface address lookup by ioctl.  This function only looks up
   IPv4 address. */
#define ADDRLEN(sa) (((sa)->sa_family == AF_INET ?  \
                sizeof (struct sockaddr_in) : sizeof (struct sockaddr_in6)))

#define SIN(s) ((struct sockaddr_in *)(s))
#define SIN6(s) ((struct sockaddr_in6 *)(s))

/* Retrieve address information for the given ifp */
static int
if_get_addr (struct interface *ifp, struct sockaddr *addr, const char *label)
{
  int ret;
  struct lifreq lifreq;
  struct sockaddr_storage mask, dest;
  char *dest_pnt = NULL;
  u_char prefixlen = 0;
  afi_t af;
  int flags = 0;

  /* Interface's name and address family.
   * We need to use the logical interface name / label, if we've been
   * given one, in order to get the right address
   */
  strncpy (lifreq.lifr_name, (label ? label : ifp->name), IFNAMSIZ);

  /* Interface's address. */
  memcpy (&lifreq.lifr_addr, addr, ADDRLEN (addr));
  af = addr->sa_family;

  /* Point to point or broad cast address pointer init. */
  dest_pnt = NULL;

  if (AF_IOCTL (af, SIOCGLIFDSTADDR, (caddr_t) & lifreq) >= 0)
    {
      memcpy (&dest, &lifreq.lifr_dstaddr, ADDRLEN (addr));
      if (af == AF_INET)
        dest_pnt = (char *) &(SIN (&dest)->sin_addr);
      else
        dest_pnt = (char *) &(SIN6 (&dest)->sin6_addr);
      flags = ZEBRA_IFA_PEER;
    }

  if (af == AF_INET)
    {
      ret = if_ioctl (SIOCGLIFNETMASK, (caddr_t) & lifreq);
      
      if (ret < 0)
        {
          if (errno != EADDRNOTAVAIL)
            {
              zlog_warn ("SIOCGLIFNETMASK (%s) fail: %s", ifp->name,
                         safe_strerror (errno));
              return ret;
            }
          return 0;
        }
      memcpy (&mask, &lifreq.lifr_addr, ADDRLEN (addr));

      prefixlen = ip_masklen (SIN (&mask)->sin_addr);
      if (!dest_pnt && (if_ioctl (SIOCGLIFBRDADDR, (caddr_t) & lifreq) >= 0))
	{
          memcpy (&dest, &lifreq.lifr_broadaddr, sizeof (struct sockaddr_in));
          dest_pnt = (char *) &SIN (&dest)->sin_addr;
        }
    }
#ifdef HAVE_IPV6
  else if (af == AF_INET6)
    {
      if (if_ioctl_ipv6 (SIOCGLIFSUBNET, (caddr_t) & lifreq) < 0)
	{
	  if (ifp->flags & IFF_POINTOPOINT)
	    prefixlen = IPV6_MAX_BITLEN;
	  else
	    zlog_warn ("SIOCGLIFSUBNET (%s) fail: %s",
		       ifp->name, safe_strerror (errno));
	}
      else
	{
	  prefixlen = lifreq.lifr_addrlen;
	}
    }
#endif /* HAVE_IPV6 */

  /* Set address to the interface. */
  if (af == AF_INET)
    connected_add_ipv4 (ifp, flags, &SIN (addr)->sin_addr, prefixlen,
                        (struct in_addr *) dest_pnt, label);
#ifdef HAVE_IPV6
  else if (af == AF_INET6)
    connected_add_ipv6 (ifp, flags, &SIN6 (addr)->sin6_addr, prefixlen,
                        (struct in6_addr *) dest_pnt, label);
#endif /* HAVE_IPV6 */

  return 0;
}

/* Fetch interface information via ioctl(). */
static void
interface_info_ioctl (struct interface *ifp)
{
  if_get_index (ifp);
  if_get_flags (ifp);
  if_get_mtu (ifp);
  if_get_metric (ifp);
}

/* Lookup all interface information. */
void
interface_list (struct zebra_vrf *zvrf)
{
  if (zvrf->vrf_id != VRF_DEFAULT)
    {
      zlog_warn ("interface_list: ignore VRF %u", zvrf->vrf_id);
      return;
    }
  interface_list_ioctl (AF_INET);
  interface_list_ioctl (AF_INET6);
  interface_list_ioctl (AF_UNSPEC);
}

struct connected *
if_lookup_linklocal (struct interface *ifp)
{
#ifdef HAVE_IPV6
  struct listnode *node;
  struct connected *ifc;

  if (ifp == NULL)
    return NULL;

  for (ALL_LIST_ELEMENTS_RO(ifp->connected, node, ifc))
    {
      if ((ifc->address->family == AF_INET6) &&
          (IN6_IS_ADDR_LINKLOCAL (&ifc->address->u.prefix6)))
        return ifc;
    }
#endif /* HAVE_IPV6 */

  return NULL;
}
Commit	Line	Data
8842468c	1	/*
	2	* Interface looking up by ioctl () on Solaris.
	3	* Copyright (C) 1997, 98 Kunihiro Ishiguro
	4	*
	5	* This file is part of GNU Zebra.
	6	*
	7	* GNU Zebra is free software; you can redistribute it and/or modify it
	8	* under the terms of the GNU General Public License as published by the
	9	* Free Software Foundation; either version 2, or (at your option) any
	10	* later version.
	11	*
	12	* GNU Zebra is distributed in the hope that it will be useful, but
	13	* WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with GNU Zebra; see the file COPYING. If not, write to the Free
	19	* Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
	20	* 02111-1307, USA.
	21	*/
	22
	23	#include <zebra.h>
	24
	25	#include "if.h"
	26	#include "sockunion.h"
	27	#include "prefix.h"
	28	#include "ioctl.h"
	29	#include "connected.h"
	30	#include "memory.h"
	31	#include "log.h"
48a46fa0	32	#include "privs.h"
8f7d9fc0	33	#include "vrf.h"
8842468c	34
8842468c	35	#include "zebra/interface.h"
8f7d9fc0	36	#include "zebra/rib.h"
8842468c	37
5c78b3d0	38	void lifreq_set_name (struct lifreq , const char );
5c78b3d0	39	int if_get_flags_direct (const char , uint64_t , unsigned int af);
0752ef0b	40	static int if_get_addr (struct interface , struct sockaddr , const char *);
8842468c	41	static void interface_info_ioctl (struct interface *);
48a46fa0	42	extern struct zebra_privs_t zserv_privs;
8842468c	43
	44	int
	45	interface_list_ioctl (int af)
	46	{
	47	int ret;
	48	int sock;
	49	#define IFNUM_BASE 32
	50	struct lifnum lifn;
	51	int ifnum;
	52	struct lifreq *lifreq;
	53	struct lifconf lifconf;
	54	struct interface *ifp;
	55	int n;
4460e7a4	56	int save_errno;
8842468c	57	size_t needed, lastneeded = 0;
	58	char *buf = NULL;
	59
	60	if (zserv_privs.change(ZPRIVS_RAISE))
	61	zlog (NULL, LOG_ERR, "Can't raise privileges");
	62
	63	sock = socket (af, SOCK_DGRAM, 0);
	64	if (sock < 0)
	65	{
	66	zlog_warn ("Can't make %s socket stream: %s",
6099b3b5	67	(af == AF_INET ? "AF_INET" : "AF_INET6"), safe_strerror (errno));
8842468c	68
	69	if (zserv_privs.change(ZPRIVS_LOWER))
	70	zlog (NULL, LOG_ERR, "Can't lower privileges");
	71
	72	return -1;
	73	}
	74
	75	calculate_lifc_len: /* must hold privileges to enter here */
	76	lifn.lifn_family = af;
0752ef0b	77	lifn.lifn_flags = LIFC_NOXMIT; /* we want NOXMIT interfaces too */
8842468c	78	ret = ioctl (sock, SIOCGLIFNUM, &lifn);
4460e7a4	79	save_errno = errno;
8842468c	80
	81	if (zserv_privs.change(ZPRIVS_LOWER))
	82	zlog (NULL, LOG_ERR, "Can't lower privileges");
	83
	84	if (ret < 0)
	85	{
	86	zlog_warn ("interface_list_ioctl: SIOCGLIFNUM failed %s",
4460e7a4	87	safe_strerror (save_errno));
8842468c	88	close (sock);
	89	return -1;
	90	}
	91	ifnum = lifn.lifn_count;
	92
	93	/*
	94	* When calculating the buffer size needed, add a small number
	95	* of interfaces to those we counted. We do this to capture
	96	* the interface status of potential interfaces which may have
	97	* been plumbed between the SIOCGLIFNUM and the SIOCGLIFCONF.
	98	*/
	99	needed = (ifnum + 4) * sizeof (struct lifreq);
	100	if (needed > lastneeded \|\| needed < lastneeded / 2)
	101	{
	102	if (buf != NULL)
	103	XFREE (MTYPE_TMP, buf);
	104	if ((buf = XMALLOC (MTYPE_TMP, needed)) == NULL)
	105	{
	106	zlog_warn ("interface_list_ioctl: malloc failed");
	107	close (sock);
	108	return -1;
	109	}
	110	}
	111	lastneeded = needed;
	112
	113	lifconf.lifc_family = af;
0752ef0b	114	lifconf.lifc_flags = LIFC_NOXMIT;
8842468c	115	lifconf.lifc_len = needed;
	116	lifconf.lifc_buf = buf;
	117
	118	if (zserv_privs.change(ZPRIVS_RAISE))
	119	zlog (NULL, LOG_ERR, "Can't raise privileges");
	120
	121	ret = ioctl (sock, SIOCGLIFCONF, &lifconf);
	122
	123	if (ret < 0)
	124	{
	125	if (errno == EINVAL)
	126	goto calculate_lifc_len; /* deliberately hold privileges */
	127
6099b3b5	128	zlog_warn ("SIOCGLIFCONF: %s", safe_strerror (errno));
8842468c	129
	130	if (zserv_privs.change(ZPRIVS_LOWER))
	131	zlog (NULL, LOG_ERR, "Can't lower privileges");
	132
	133	goto end;
	134	}
	135
	136	if (zserv_privs.change(ZPRIVS_LOWER))
	137	zlog (NULL, LOG_ERR, "Can't lower privileges");
	138
	139	/* Allocate interface. */
	140	lifreq = lifconf.lifc_req;
	141
	142	for (n = 0; n < lifconf.lifc_len; n += sizeof (struct lifreq))
	143	{
0752ef0b	144	/* we treat Solaris logical interfaces as addresses, because that is
	145	* how PF_ROUTE on Solaris treats them. Hence we can not directly use
	146	* the lifreq_name to get the ifp. We need to normalise the name
	147	* before attempting get.
	148	*
	149	* Solaris logical interface names are in the form of:
	150	* <interface name>:<logical interface id>
	151	*/
	152	unsigned int normallen = 0;
5c78b3d0	153	uint64_t lifflags;
0752ef0b	154
5c78b3d0	155	/* We should exclude ~IFF_UP interfaces, as we'll find out about them
	156	* coming up later through RTM_NEWADDR message on the route socket.
	157	*/
	158	if (if_get_flags_direct (lifreq->lifr_name, &lifflags,
	159	lifreq->lifr_addr.ss_family)
	160	\|\| !CHECK_FLAG (lifflags, IFF_UP))
	161	{
	162	lifreq++;
	163	continue;
	164	}
	165
	166	/* Find the normalised name */
0752ef0b	167	while ( (normallen < sizeof(lifreq->lifr_name))
	168	&& ( *(lifreq->lifr_name + normallen) != '\0')
	169	&& ( *(lifreq->lifr_name + normallen) != ':') )
	170	normallen++;
	171
	172	ifp = if_get_by_name_len(lifreq->lifr_name, normallen);
5b73a671	173
8842468c	174	if (lifreq->lifr_addr.ss_family == AF_INET)
8842468c	175	ifp->flags \|= IFF_IPV4;
5b73a671	176
8842468c	177	if (lifreq->lifr_addr.ss_family == AF_INET6)
5b73a671	178	{
	179	#ifdef HAVE_IPV6
	180	ifp->flags \|= IFF_IPV6;
	181	#else
	182	lifreq++;
	183	continue;
	184	#endif /* HAVE_IPV6 */
	185	}
	186
8842468c	187	if_add_update (ifp);
5b73a671	188
8842468c	189	interface_info_ioctl (ifp);
0752ef0b	190
	191	/* If a logical interface pass the full name so it can be
	192	* as a label on the address
	193	*/
	194	if ( *(lifreq->lifr_name + normallen) != '\0')
	195	if_get_addr (ifp, (struct sockaddr *) &lifreq->lifr_addr,
	196	lifreq->lifr_name);
	197	else
	198	if_get_addr (ifp, (struct sockaddr *) &lifreq->lifr_addr, NULL);
5c78b3d0	199
	200	/* Poke the interface flags. Lets IFF_UP mangling kick in */
	201	if_flags_update (ifp, ifp->flags);
	202
8842468c	203	lifreq++;
	204	}
	205
	206	end:
	207	close (sock);
	208	XFREE (MTYPE_TMP, lifconf.lifc_buf);
	209	return ret;
	210	}
	211
	212	/* Get interface's index by ioctl. */
	213	int
	214	if_get_index (struct interface *ifp)
	215	{
	216	int ret;
	217	struct lifreq lifreq;
	218
e8eb8340	219	lifreq_set_name (&lifreq, ifp->name);
8842468c	220
8842468c	221	if (ifp->flags & IFF_IPV4)
	222	ret = AF_IOCTL (AF_INET, SIOCGLIFINDEX, (caddr_t) & lifreq);
	223	else if (ifp->flags & IFF_IPV6)
	224	ret = AF_IOCTL (AF_INET6, SIOCGLIFINDEX, (caddr_t) & lifreq);
	225	else
	226	ret = -1;
	227
8842468c	228	if (ret < 0)
	229	{
	230	zlog_warn ("SIOCGLIFINDEX(%s) failed", ifp->name);
	231	return ret;
	232	}
	233
	234	/* OK we got interface index. */
	235	#ifdef ifr_ifindex
	236	ifp->ifindex = lifreq.lifr_ifindex;
	237	#else
	238	ifp->ifindex = lifreq.lifr_index;
	239	#endif
	240	return ifp->ifindex;
	241
	242	}
	243
	244
	245	/* Interface address lookup by ioctl. This function only looks up
	246	IPv4 address. */
	247	#define ADDRLEN(sa) (((sa)->sa_family == AF_INET ? \
	248	sizeof (struct sockaddr_in) : sizeof (struct sockaddr_in6)))
	249
	250	#define SIN(s) ((struct sockaddr_in *)(s))
	251	#define SIN6(s) ((struct sockaddr_in6 *)(s))
	252
0752ef0b	253	/* Retrieve address information for the given ifp */
8842468c	254	static int
0752ef0b	255	if_get_addr (struct interface ifp, struct sockaddr addr, const char *label)
8842468c	256	{
	257	int ret;
	258	struct lifreq lifreq;
	259	struct sockaddr_storage mask, dest;
	260	char *dest_pnt = NULL;
	261	u_char prefixlen = 0;
	262	afi_t af;
e4529636	263	int flags = 0;
8842468c	264
0752ef0b	265	/* Interface's name and address family.
	266	* We need to use the logical interface name / label, if we've been
	267	* given one, in order to get the right address
	268	*/
11967e92	269	strncpy (lifreq.lifr_name, (label ? label : ifp->name), IFNAMSIZ);
8842468c	270
	271	/* Interface's address. */
	272	memcpy (&lifreq.lifr_addr, addr, ADDRLEN (addr));
	273	af = addr->sa_family;
	274
	275	/* Point to point or broad cast address pointer init. */
	276	dest_pnt = NULL;
	277
e4529636	278	if (AF_IOCTL (af, SIOCGLIFDSTADDR, (caddr_t) & lifreq) >= 0)
8842468c	279	{
8842468c	280	memcpy (&dest, &lifreq.lifr_dstaddr, ADDRLEN (addr));
	281	if (af == AF_INET)
	282	dest_pnt = (char *) &(SIN (&dest)->sin_addr);
	283	else
	284	dest_pnt = (char *) &(SIN6 (&dest)->sin6_addr);
e4529636	285	flags = ZEBRA_IFA_PEER;
8842468c	286	}
	287
	288	if (af == AF_INET)
	289	{
	290	ret = if_ioctl (SIOCGLIFNETMASK, (caddr_t) & lifreq);
	291
	292	if (ret < 0)
	293	{
	294	if (errno != EADDRNOTAVAIL)
	295	{
	296	zlog_warn ("SIOCGLIFNETMASK (%s) fail: %s", ifp->name,
6099b3b5	297	safe_strerror (errno));
8842468c	298	return ret;
	299	}
	300	return 0;
	301	}
	302	memcpy (&mask, &lifreq.lifr_addr, ADDRLEN (addr));
	303
	304	prefixlen = ip_masklen (SIN (&mask)->sin_addr);
e4529636 AS	305	if (!dest_pnt && (if_ioctl (SIOCGLIFBRDADDR, (caddr_t) & lifreq) >= 0))
e4529636 AS	306	{
8842468c	307	memcpy (&dest, &lifreq.lifr_broadaddr, sizeof (struct sockaddr_in));
	308	dest_pnt = (char *) &SIN (&dest)->sin_addr;
	309	}
	310	}
5b73a671	311	#ifdef HAVE_IPV6
5b73a671	312	else if (af == AF_INET6)
8842468c	313	{
fb6724a6 AS	314	if (if_ioctl_ipv6 (SIOCGLIFSUBNET, (caddr_t) & lifreq) < 0)
	315	{
	316	if (ifp->flags & IFF_POINTOPOINT)
	317	prefixlen = IPV6_MAX_BITLEN;
	318	else
	319	zlog_warn ("SIOCGLIFSUBNET (%s) fail: %s",
	320	ifp->name, safe_strerror (errno));
	321	}
8842468c	322	else
fb6724a6 AS	323	{
	324	prefixlen = lifreq.lifr_addrlen;
	325	}
8842468c	326	}
5b73a671	327	#endif /* HAVE_IPV6 */
8842468c	328
	329	/* Set address to the interface. */
	330	if (af == AF_INET)
e4529636	331	connected_add_ipv4 (ifp, flags, &SIN (addr)->sin_addr, prefixlen,
0752ef0b	332	(struct in_addr *) dest_pnt, label);
5b73a671	333	#ifdef HAVE_IPV6
5b73a671	334	else if (af == AF_INET6)
e4529636	335	connected_add_ipv6 (ifp, flags, &SIN6 (addr)->sin6_addr, prefixlen,
0752ef0b	336	(struct in6_addr *) dest_pnt, label);
5b73a671	337	#endif /* HAVE_IPV6 */
8842468c	338
	339	return 0;
	340	}
	341
	342	/* Fetch interface information via ioctl(). */
	343	static void
	344	interface_info_ioctl (struct interface *ifp)
	345	{
	346	if_get_index (ifp);
	347	if_get_flags (ifp);
	348	if_get_mtu (ifp);
	349	if_get_metric (ifp);
	350	}
	351
	352	/* Lookup all interface information. */
	353	void
8f7d9fc0	354	interface_list (struct zebra_vrf *zvrf)
8842468c	355	{
8f7d9fc0 FL	356	if (zvrf->vrf_id != VRF_DEFAULT)
	357	{
	358	zlog_warn ("interface_list: ignore VRF %u", zvrf->vrf_id);
	359	return;
	360	}
8842468c	361	interface_list_ioctl (AF_INET);
8842468c	362	interface_list_ioctl (AF_INET6);
0752ef0b	363	interface_list_ioctl (AF_UNSPEC);
8842468c	364	}
	365
	366	struct connected *
	367	if_lookup_linklocal (struct interface *ifp)
	368	{
5b73a671	369	#ifdef HAVE_IPV6
0c0f9112	370	struct listnode *node;
8842468c	371	struct connected *ifc;
	372
	373	if (ifp == NULL)
	374	return NULL;
	375
cf460ef9	376	for (ALL_LIST_ELEMENTS_RO(ifp->connected, node, ifc))
8842468c	377	{
8842468c	378	if ((ifc->address->family == AF_INET6) &&
	379	(IN6_IS_ADDR_LINKLOCAL (&ifc->address->u.prefix6)))
	380	return ifc;
	381	}
5b73a671	382	#endif /* HAVE_IPV6 */
5b73a671	383
8842468c	384	return NULL;
8842468c	385	}