[mirror_frr.git] / zebra / redistribute.c

/* Redistribution Handler
 * Copyright (C) 1998 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 "vector.h"
#include "vty.h"
#include "command.h"
#include "prefix.h"
#include "table.h"
#include "stream.h"
#include "zclient.h"
#include "linklist.h"
#include "log.h"

#include "zebra/rib.h"
#include "zebra/zserv.h"
#include "zebra/redistribute.h"
#include "zebra/debug.h"
#include "zebra/router-id.h"

/* master zebra server structure */
extern struct zebra_t zebrad;

static int
zebra_check_addr (struct prefix *p)
{
  if (p->family == AF_INET)
    {
      u_int32_t addr;

      addr = p->u.prefix4.s_addr;
      addr = ntohl (addr);

      if (IPV4_NET127 (addr) || IN_CLASSD (addr))
	return 0;
    }
#ifdef HAVE_IPV6
  if (p->family == AF_INET6)
    {
      if (IN6_IS_ADDR_LOOPBACK (&p->u.prefix6))
	return 0;
      if (IN6_IS_ADDR_LINKLOCAL(&p->u.prefix6))
	return 0;
    }
#endif /* HAVE_IPV6 */
  return 1;
}

static int
is_default (struct prefix *p)
{
  if (p->family == AF_INET)
    if (p->u.prefix4.s_addr == 0 && p->prefixlen == 0)
      return 1;
#ifdef HAVE_IPV6
#if 0  /* IPv6 default separation is now pending until protocol daemon
          can handle that. */
  if (p->family == AF_INET6)
    if (IN6_IS_ADDR_UNSPECIFIED (&p->u.prefix6) && p->prefixlen == 0)
      return 1;
#endif /* 0 */
#endif /* HAVE_IPV6 */
  return 0;
}

static void
zebra_redistribute_default (struct zserv *client)
{
  struct prefix_ipv4 p;
  struct route_table *table;
  struct route_node *rn;
  struct rib *newrib;
#ifdef HAVE_IPV6
  struct prefix_ipv6 p6;
#endif /* HAVE_IPV6 */


  /* Lookup default route. */
  memset (&p, 0, sizeof (struct prefix_ipv4));
  p.family = AF_INET;

  /* Lookup table.  */
  table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
  if (table)
    {
      rn = route_node_lookup (table, (struct prefix *)&p);
      if (rn)
	{
	  for (newrib = rn->info; newrib; newrib = newrib->next)
	    if (CHECK_FLAG (newrib->flags, ZEBRA_FLAG_SELECTED)
		&& newrib->distance != DISTANCE_INFINITY)
	      zsend_route_multipath (ZEBRA_IPV4_ROUTE_ADD, client, &rn->p, newrib);
	  route_unlock_node (rn);
	}
    }

#ifdef HAVE_IPV6
  /* Lookup default route. */
  memset (&p6, 0, sizeof (struct prefix_ipv6));
  p6.family = AF_INET6;

  /* Lookup table.  */
  table = vrf_table (AFI_IP6, SAFI_UNICAST, 0);
  if (table)
    {
      rn = route_node_lookup (table, (struct prefix *)&p6);
      if (rn)
	{
	  for (newrib = rn->info; newrib; newrib = newrib->next)
	    if (CHECK_FLAG (newrib->flags, ZEBRA_FLAG_SELECTED)
		&& newrib->distance != DISTANCE_INFINITY)
	      zsend_route_multipath (ZEBRA_IPV6_ROUTE_ADD, client, &rn->p, newrib);
	  route_unlock_node (rn);
	}
    }
#endif /* HAVE_IPV6 */
}

/* Redistribute routes. */
static void
zebra_redistribute (struct zserv *client, int type)
{
  struct rib *newrib;
  struct route_table *table;
  struct route_node *rn;

  table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
  if (table)
    for (rn = route_top (table); rn; rn = route_next (rn))
      for (newrib = rn->info; newrib; newrib = newrib->next)
	if (CHECK_FLAG (newrib->flags, ZEBRA_FLAG_SELECTED) 
	    && newrib->type == type 
	    && newrib->distance != DISTANCE_INFINITY
	    && zebra_check_addr (&rn->p))
	  zsend_route_multipath (ZEBRA_IPV4_ROUTE_ADD, client, &rn->p, newrib);
  
#ifdef HAVE_IPV6
  table = vrf_table (AFI_IP6, SAFI_UNICAST, 0);
  if (table)
    for (rn = route_top (table); rn; rn = route_next (rn))
      for (newrib = rn->info; newrib; newrib = newrib->next)
	if (CHECK_FLAG (newrib->flags, ZEBRA_FLAG_SELECTED)
	    && newrib->type == type 
	    && newrib->distance != DISTANCE_INFINITY
	    && zebra_check_addr (&rn->p))
	  zsend_route_multipath (ZEBRA_IPV6_ROUTE_ADD, client, &rn->p, newrib);
#endif /* HAVE_IPV6 */
}

void
redistribute_add (struct prefix *p, struct rib *rib)
{
  struct listnode *node;
  struct zserv *client;

  for (node = listhead (zebrad.client_list); node; nextnode (node))
    if ((client = getdata (node)) != NULL)
      {
	if (is_default (p))
	  {
	    if (client->redist_default || client->redist[rib->type])
	      {
		if (p->family == AF_INET)
		  zsend_route_multipath (ZEBRA_IPV4_ROUTE_ADD, client, p, rib);
#ifdef HAVE_IPV6
		if (p->family == AF_INET6)
		  zsend_route_multipath (ZEBRA_IPV6_ROUTE_ADD, client, p, rib);
#endif /* HAVE_IPV6 */	  
	      }
	  }
	else if (client->redist[rib->type])
	  {
	    if (p->family == AF_INET)
	      zsend_route_multipath (ZEBRA_IPV4_ROUTE_ADD, client, p, rib);
#ifdef HAVE_IPV6
	    if (p->family == AF_INET6)
	      zsend_route_multipath (ZEBRA_IPV6_ROUTE_ADD, client, p, rib);
#endif /* HAVE_IPV6 */	  
	  }
      }
}

void
redistribute_delete (struct prefix *p, struct rib *rib)
{
  struct listnode *node;
  struct zserv *client;

  /* Add DISTANCE_INFINITY check. */
  if (rib->distance == DISTANCE_INFINITY)
    return;

  for (node = listhead (zebrad.client_list); node; nextnode (node))
    if ((client = getdata (node)) != NULL)
      {
	if (is_default (p))
	  {
	    if (client->redist_default || client->redist[rib->type])
	      {
		if (p->family == AF_INET)
		  zsend_route_multipath (ZEBRA_IPV4_ROUTE_DELETE, client, p, rib);
#ifdef HAVE_IPV6
		if (p->family == AF_INET6)
		  zsend_route_multipath (ZEBRA_IPV6_ROUTE_DELETE, client, p, rib);
#endif /* HAVE_IPV6 */	  
	      }
	  }
	else if (client->redist[rib->type])
	  {
	    if (p->family == AF_INET)
	      zsend_route_multipath (ZEBRA_IPV4_ROUTE_DELETE, client, p, rib);
#ifdef HAVE_IPV6
	    if (p->family == AF_INET6)
	      zsend_route_multipath (ZEBRA_IPV6_ROUTE_DELETE, client, p, rib);
#endif /* HAVE_IPV6 */	  
	  }
      }
}

void
zebra_redistribute_add (int command, struct zserv *client, int length)
{
  int type;

  type = stream_getc (client->ibuf);

  switch (type)
    {
    case ZEBRA_ROUTE_KERNEL:
    case ZEBRA_ROUTE_CONNECT:
    case ZEBRA_ROUTE_STATIC:
    case ZEBRA_ROUTE_RIP:
    case ZEBRA_ROUTE_RIPNG:
    case ZEBRA_ROUTE_OSPF:
    case ZEBRA_ROUTE_OSPF6:
    case ZEBRA_ROUTE_BGP:
      if (! client->redist[type])
	{
	  client->redist[type] = 1;
	  zebra_redistribute (client, type);
	}
      break;
    default:
      break;
    }
}     

void
zebra_redistribute_delete (int command, struct zserv *client, int length)
{
  int type;

  type = stream_getc (client->ibuf);

  switch (type)
    {
    case ZEBRA_ROUTE_KERNEL:
    case ZEBRA_ROUTE_CONNECT:
    case ZEBRA_ROUTE_STATIC:
    case ZEBRA_ROUTE_RIP:
    case ZEBRA_ROUTE_RIPNG:
    case ZEBRA_ROUTE_OSPF:
    case ZEBRA_ROUTE_OSPF6:
    case ZEBRA_ROUTE_BGP:
      client->redist[type] = 0;
      break;
    default:
      break;
    }
}     

void
zebra_redistribute_default_add (int command, struct zserv *client, int length)
{
  client->redist_default = 1;
  zebra_redistribute_default (client);
}     

void
zebra_redistribute_default_delete (int command, struct zserv *client,
				   int length)
{
  client->redist_default = 0;;
}     

/* Interface up information. */
void
zebra_interface_up_update (struct interface *ifp)
{
  struct listnode *node;
  struct zserv *client;

  if (IS_ZEBRA_DEBUG_EVENT)
    zlog_debug ("MESSAGE: ZEBRA_INTERFACE_UP %s", ifp->name);

  for (node = listhead (zebrad.client_list); node; nextnode (node))
    if ((client = getdata (node)) != NULL)
      zsend_interface_update (ZEBRA_INTERFACE_UP, client, ifp);
}

/* Interface down information. */
void
zebra_interface_down_update (struct interface *ifp)
{
  struct listnode *node;
  struct zserv *client;

  if (IS_ZEBRA_DEBUG_EVENT)
    zlog_debug ("MESSAGE: ZEBRA_INTERFACE_DOWN %s", ifp->name);

  for (node = listhead (zebrad.client_list); node; nextnode (node))
    if ((client = getdata (node)) != NULL)
      zsend_interface_update (ZEBRA_INTERFACE_DOWN, client, ifp);
}

/* Interface information update. */
void
zebra_interface_add_update (struct interface *ifp)
{
  struct listnode *node;
  struct zserv *client;

  if (IS_ZEBRA_DEBUG_EVENT)
    zlog_debug ("MESSAGE: ZEBRA_INTERFACE_ADD %s", ifp->name);
    
  for (node = listhead (zebrad.client_list); node; nextnode (node))
    if ((client = getdata (node)) != NULL)
      if (client->ifinfo)
	zsend_interface_add (client, ifp);
}

/*
 * This function is only called  when support for 
 * RTM_IFANNOUNCE or AF_NETLINK sockets (RTM_DELLINK message)
 * is available. It is not called on Solaris.
 */
#if (defined(RTM_IFANNOUNCE) || defined(HAVE_NETLINK))
void
zebra_interface_delete_update (struct interface *ifp)
{
  struct listnode *node;
  struct zserv *client;

  if (IS_ZEBRA_DEBUG_EVENT)
    zlog_debug ("MESSAGE: ZEBRA_INTERFACE_DELETE %s", ifp->name);

  for (node = listhead (zebrad.client_list); node; nextnode (node))
    if ((client = getdata (node)) != NULL)
      if (client->ifinfo)
	zsend_interface_delete (client, ifp);
}
#endif /* defined(RTM_IFANNOUNCE) || defined(HAVE_NETLINK) */

/* Interface address addition. */
void
zebra_interface_address_add_update (struct interface *ifp,
				    struct connected *ifc)
{
  struct listnode *node;
  struct zserv *client;
  struct prefix *p;
  char buf[BUFSIZ];

  if (IS_ZEBRA_DEBUG_EVENT)
    {
      p = ifc->address;
      zlog_debug ("MESSAGE: ZEBRA_INTERFACE_ADDRESS_ADD %s/%d on %s",
		  inet_ntop (p->family, &p->u.prefix, buf, BUFSIZ),
		  p->prefixlen, ifc->ifp->name);
    }

  router_id_add_address(ifc);

  for (node = listhead (zebrad.client_list); node; nextnode (node))
    if ((client = getdata (node)) != NULL)
      if (client->ifinfo && CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL))
	zsend_interface_address (ZEBRA_INTERFACE_ADDRESS_ADD, client, ifp, ifc);
}

/* Interface address deletion. */
void
zebra_interface_address_delete_update (struct interface *ifp,
				       struct connected *ifc)
{
  struct listnode *node;
  struct zserv *client;
  struct prefix *p;
  char buf[BUFSIZ];

  if (IS_ZEBRA_DEBUG_EVENT)
    {
      p = ifc->address;
      zlog_debug ("MESSAGE: ZEBRA_INTERFACE_ADDRESS_DELETE %s/%d on %s",
		  inet_ntop (p->family, &p->u.prefix, buf, BUFSIZ),
		 p->prefixlen, ifc->ifp->name);
    }

  router_id_del_address(ifc);

  for (node = listhead (zebrad.client_list); node; nextnode (node))
    if ((client = getdata (node)) != NULL)
      if (client->ifinfo && CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL))
	zsend_interface_address (ZEBRA_INTERFACE_ADDRESS_DELETE, client, ifp, ifc);
}
Commit	Line	Data
718e3744	1	/* Redistribution Handler
	2	* Copyright (C) 1998 Kunihiro Ishiguro
	3	*
	4	* This file is part of GNU Zebra.
	5	*
	6	* GNU Zebra is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the
	8	* Free Software Foundation; either version 2, or (at your option) any
	9	* later version.
	10	*
	11	* GNU Zebra is distributed in the hope that it will be useful, but
	12	* WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with GNU Zebra; see the file COPYING. If not, write to the Free
	18	* Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
	19	* 02111-1307, USA.
	20	*/
	21
	22	#include <zebra.h>
	23
	24	#include "vector.h"
	25	#include "vty.h"
	26	#include "command.h"
	27	#include "prefix.h"
	28	#include "table.h"
	29	#include "stream.h"
	30	#include "zclient.h"
	31	#include "linklist.h"
	32	#include "log.h"
	33
	34	#include "zebra/rib.h"
	35	#include "zebra/zserv.h"
	36	#include "zebra/redistribute.h"
	37	#include "zebra/debug.h"
18a6dce6	38	#include "zebra/router-id.h"
718e3744	39
b21b19c5	40	/* master zebra server structure */
	41	extern struct zebra_t zebrad;
	42
27da3988	43	static int
718e3744	44	zebra_check_addr (struct prefix *p)
	45	{
	46	if (p->family == AF_INET)
	47	{
	48	u_int32_t addr;
	49
	50	addr = p->u.prefix4.s_addr;
	51	addr = ntohl (addr);
	52
	53	if (IPV4_NET127 (addr) \|\| IN_CLASSD (addr))
	54	return 0;
	55	}
	56	#ifdef HAVE_IPV6
	57	if (p->family == AF_INET6)
	58	{
	59	if (IN6_IS_ADDR_LOOPBACK (&p->u.prefix6))
	60	return 0;
	61	if (IN6_IS_ADDR_LINKLOCAL(&p->u.prefix6))
	62	return 0;
	63	}
	64	#endif /* HAVE_IPV6 */
	65	return 1;
	66	}
	67
27da3988	68	static int
718e3744	69	is_default (struct prefix *p)
	70	{
	71	if (p->family == AF_INET)
	72	if (p->u.prefix4.s_addr == 0 && p->prefixlen == 0)
	73	return 1;
	74	#ifdef HAVE_IPV6
	75	#if 0 /* IPv6 default separation is now pending until protocol daemon
	76	can handle that. */
	77	if (p->family == AF_INET6)
	78	if (IN6_IS_ADDR_UNSPECIFIED (&p->u.prefix6) && p->prefixlen == 0)
	79	return 1;
	80	#endif /* 0 */
	81	#endif /* HAVE_IPV6 */
	82	return 0;
	83	}
	84
27da3988	85	static void
718e3744	86	zebra_redistribute_default (struct zserv *client)
	87	{
	88	struct prefix_ipv4 p;
	89	struct route_table *table;
	90	struct route_node *rn;
	91	struct rib *newrib;
	92	#ifdef HAVE_IPV6
	93	struct prefix_ipv6 p6;
	94	#endif /* HAVE_IPV6 */
	95
	96
	97	/* Lookup default route. */
	98	memset (&p, 0, sizeof (struct prefix_ipv4));
	99	p.family = AF_INET;
	100
	101	/* Lookup table. */
	102	table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
	103	if (table)
	104	{
	105	rn = route_node_lookup (table, (struct prefix *)&p);
	106	if (rn)
	107	{
	108	for (newrib = rn->info; newrib; newrib = newrib->next)
	109	if (CHECK_FLAG (newrib->flags, ZEBRA_FLAG_SELECTED)
	110	&& newrib->distance != DISTANCE_INFINITY)
b9df2d25	111	zsend_route_multipath (ZEBRA_IPV4_ROUTE_ADD, client, &rn->p, newrib);
718e3744	112	route_unlock_node (rn);
	113	}
	114	}
	115
	116	#ifdef HAVE_IPV6
	117	/* Lookup default route. */
	118	memset (&p6, 0, sizeof (struct prefix_ipv6));
	119	p6.family = AF_INET6;
	120
	121	/* Lookup table. */
	122	table = vrf_table (AFI_IP6, SAFI_UNICAST, 0);
	123	if (table)
	124	{
	125	rn = route_node_lookup (table, (struct prefix *)&p6);
	126	if (rn)
	127	{
	128	for (newrib = rn->info; newrib; newrib = newrib->next)
	129	if (CHECK_FLAG (newrib->flags, ZEBRA_FLAG_SELECTED)
	130	&& newrib->distance != DISTANCE_INFINITY)
b9df2d25	131	zsend_route_multipath (ZEBRA_IPV6_ROUTE_ADD, client, &rn->p, newrib);
718e3744	132	route_unlock_node (rn);
	133	}
	134	}
	135	#endif /* HAVE_IPV6 */
	136	}
	137
	138	/* Redistribute routes. */
27da3988	139	static void
718e3744	140	zebra_redistribute (struct zserv *client, int type)
	141	{
	142	struct rib *newrib;
	143	struct route_table *table;
	144	struct route_node *rn;
	145
	146	table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
	147	if (table)
	148	for (rn = route_top (table); rn; rn = route_next (rn))
	149	for (newrib = rn->info; newrib; newrib = newrib->next)
	150	if (CHECK_FLAG (newrib->flags, ZEBRA_FLAG_SELECTED)
	151	&& newrib->type == type
	152	&& newrib->distance != DISTANCE_INFINITY
	153	&& zebra_check_addr (&rn->p))
b9df2d25	154	zsend_route_multipath (ZEBRA_IPV4_ROUTE_ADD, client, &rn->p, newrib);
718e3744	155
	156	#ifdef HAVE_IPV6
	157	table = vrf_table (AFI_IP6, SAFI_UNICAST, 0);
	158	if (table)
	159	for (rn = route_top (table); rn; rn = route_next (rn))
	160	for (newrib = rn->info; newrib; newrib = newrib->next)
	161	if (CHECK_FLAG (newrib->flags, ZEBRA_FLAG_SELECTED)
	162	&& newrib->type == type
	163	&& newrib->distance != DISTANCE_INFINITY
	164	&& zebra_check_addr (&rn->p))
b9df2d25	165	zsend_route_multipath (ZEBRA_IPV6_ROUTE_ADD, client, &rn->p, newrib);
718e3744	166	#endif /* HAVE_IPV6 */
	167	}
	168
718e3744	169	void
	170	redistribute_add (struct prefix p, struct rib rib)
	171	{
52dc7ee6	172	struct listnode *node;
718e3744	173	struct zserv *client;
718e3744	174
b21b19c5	175	for (node = listhead (zebrad.client_list); node; nextnode (node))
718e3744	176	if ((client = getdata (node)) != NULL)
	177	{
	178	if (is_default (p))
	179	{
	180	if (client->redist_default \|\| client->redist[rib->type])
	181	{
	182	if (p->family == AF_INET)
b9df2d25	183	zsend_route_multipath (ZEBRA_IPV4_ROUTE_ADD, client, p, rib);
718e3744	184	#ifdef HAVE_IPV6
718e3744	185	if (p->family == AF_INET6)
b9df2d25	186	zsend_route_multipath (ZEBRA_IPV6_ROUTE_ADD, client, p, rib);
718e3744	187	#endif /* HAVE_IPV6 */
	188	}
	189	}
	190	else if (client->redist[rib->type])
	191	{
	192	if (p->family == AF_INET)
b9df2d25	193	zsend_route_multipath (ZEBRA_IPV4_ROUTE_ADD, client, p, rib);
718e3744	194	#ifdef HAVE_IPV6
718e3744	195	if (p->family == AF_INET6)
b9df2d25	196	zsend_route_multipath (ZEBRA_IPV6_ROUTE_ADD, client, p, rib);
718e3744	197	#endif /* HAVE_IPV6 */
	198	}
	199	}
	200	}
	201
	202	void
	203	redistribute_delete (struct prefix p, struct rib rib)
	204	{
52dc7ee6	205	struct listnode *node;
718e3744	206	struct zserv *client;
	207
	208	/* Add DISTANCE_INFINITY check. */
	209	if (rib->distance == DISTANCE_INFINITY)
	210	return;
	211
b21b19c5	212	for (node = listhead (zebrad.client_list); node; nextnode (node))
718e3744	213	if ((client = getdata (node)) != NULL)
	214	{
	215	if (is_default (p))
	216	{
	217	if (client->redist_default \|\| client->redist[rib->type])
	218	{
	219	if (p->family == AF_INET)
b9df2d25	220	zsend_route_multipath (ZEBRA_IPV4_ROUTE_DELETE, client, p, rib);
718e3744	221	#ifdef HAVE_IPV6
718e3744	222	if (p->family == AF_INET6)
b9df2d25	223	zsend_route_multipath (ZEBRA_IPV6_ROUTE_DELETE, client, p, rib);
718e3744	224	#endif /* HAVE_IPV6 */
	225	}
	226	}
	227	else if (client->redist[rib->type])
	228	{
	229	if (p->family == AF_INET)
b9df2d25	230	zsend_route_multipath (ZEBRA_IPV4_ROUTE_DELETE, client, p, rib);
718e3744	231	#ifdef HAVE_IPV6
718e3744	232	if (p->family == AF_INET6)
b9df2d25	233	zsend_route_multipath (ZEBRA_IPV6_ROUTE_DELETE, client, p, rib);
718e3744	234	#endif /* HAVE_IPV6 */
	235	}
	236	}
	237	}
	238
	239	void
	240	zebra_redistribute_add (int command, struct zserv *client, int length)
	241	{
	242	int type;
	243
	244	type = stream_getc (client->ibuf);
	245
	246	switch (type)
	247	{
	248	case ZEBRA_ROUTE_KERNEL:
	249	case ZEBRA_ROUTE_CONNECT:
	250	case ZEBRA_ROUTE_STATIC:
	251	case ZEBRA_ROUTE_RIP:
	252	case ZEBRA_ROUTE_RIPNG:
	253	case ZEBRA_ROUTE_OSPF:
	254	case ZEBRA_ROUTE_OSPF6:
	255	case ZEBRA_ROUTE_BGP:
	256	if (! client->redist[type])
	257	{
	258	client->redist[type] = 1;
	259	zebra_redistribute (client, type);
	260	}
	261	break;
	262	default:
	263	break;
	264	}
	265	}
	266
	267	void
	268	zebra_redistribute_delete (int command, struct zserv *client, int length)
	269	{
	270	int type;
	271
	272	type = stream_getc (client->ibuf);
	273
	274	switch (type)
	275	{
	276	case ZEBRA_ROUTE_KERNEL:
	277	case ZEBRA_ROUTE_CONNECT:
	278	case ZEBRA_ROUTE_STATIC:
	279	case ZEBRA_ROUTE_RIP:
	280	case ZEBRA_ROUTE_RIPNG:
	281	case ZEBRA_ROUTE_OSPF:
	282	case ZEBRA_ROUTE_OSPF6:
	283	case ZEBRA_ROUTE_BGP:
	284	client->redist[type] = 0;
	285	break;
	286	default:
	287	break;
	288	}
	289	}
	290
	291	void
	292	zebra_redistribute_default_add (int command, struct zserv *client, int length)
	293	{
	294	client->redist_default = 1;
	295	zebra_redistribute_default (client);
	296	}
	297
298	void
299	zebra_redistribute_default_delete (int command, struct zserv *client,
300	int length)
301	{
302	client->redist_default = 0;;
303	}
304
305	/* Interface up information. */
306	void
307	zebra_interface_up_update (struct interface *ifp)
308	{
52dc7ee6	309	struct listnode *node;
718e3744	310	struct zserv *client;
	311
	312	if (IS_ZEBRA_DEBUG_EVENT)
b6178002	313	zlog_debug ("MESSAGE: ZEBRA_INTERFACE_UP %s", ifp->name);
718e3744	314
b21b19c5	315	for (node = listhead (zebrad.client_list); node; nextnode (node))
718e3744	316	if ((client = getdata (node)) != NULL)
b9df2d25	317	zsend_interface_update (ZEBRA_INTERFACE_UP, client, ifp);
718e3744	318	}
	319
	320	/* Interface down information. */
	321	void
	322	zebra_interface_down_update (struct interface *ifp)
	323	{
52dc7ee6	324	struct listnode *node;
718e3744	325	struct zserv *client;
	326
	327	if (IS_ZEBRA_DEBUG_EVENT)
b6178002	328	zlog_debug ("MESSAGE: ZEBRA_INTERFACE_DOWN %s", ifp->name);
718e3744	329
b21b19c5	330	for (node = listhead (zebrad.client_list); node; nextnode (node))
718e3744	331	if ((client = getdata (node)) != NULL)
b9df2d25	332	zsend_interface_update (ZEBRA_INTERFACE_DOWN, client, ifp);
718e3744	333	}
	334
	335	/* Interface information update. */
	336	void
	337	zebra_interface_add_update (struct interface *ifp)
	338	{
52dc7ee6	339	struct listnode *node;
718e3744	340	struct zserv *client;
	341
	342	if (IS_ZEBRA_DEBUG_EVENT)
b6178002	343	zlog_debug ("MESSAGE: ZEBRA_INTERFACE_ADD %s", ifp->name);
718e3744	344
b21b19c5	345	for (node = listhead (zebrad.client_list); node; nextnode (node))
718e3744	346	if ((client = getdata (node)) != NULL)
	347	if (client->ifinfo)
	348	zsend_interface_add (client, ifp);
	349	}
	350
c50ae8ba	351	/*
	352	* This function is only called when support for
	353	* RTM_IFANNOUNCE or AF_NETLINK sockets (RTM_DELLINK message)
	354	* is available. It is not called on Solaris.
	355	*/
	356	#if (defined(RTM_IFANNOUNCE) \|\| defined(HAVE_NETLINK))
718e3744	357	void
	358	zebra_interface_delete_update (struct interface *ifp)
	359	{
52dc7ee6	360	struct listnode *node;
718e3744	361	struct zserv *client;
	362
	363	if (IS_ZEBRA_DEBUG_EVENT)
b6178002	364	zlog_debug ("MESSAGE: ZEBRA_INTERFACE_DELETE %s", ifp->name);
718e3744	365
b21b19c5	366	for (node = listhead (zebrad.client_list); node; nextnode (node))
718e3744	367	if ((client = getdata (node)) != NULL)
	368	if (client->ifinfo)
	369	zsend_interface_delete (client, ifp);
	370	}
c50ae8ba	371	#endif /* defined(RTM_IFANNOUNCE) \|\| defined(HAVE_NETLINK) */
718e3744	372
	373	/* Interface address addition. */
	374	void
	375	zebra_interface_address_add_update (struct interface *ifp,
	376	struct connected *ifc)
	377	{
52dc7ee6	378	struct listnode *node;
718e3744	379	struct zserv *client;
	380	struct prefix *p;
	381	char buf[BUFSIZ];
	382
	383	if (IS_ZEBRA_DEBUG_EVENT)
	384	{
	385	p = ifc->address;
b6178002	386	zlog_debug ("MESSAGE: ZEBRA_INTERFACE_ADDRESS_ADD %s/%d on %s",
	387	inet_ntop (p->family, &p->u.prefix, buf, BUFSIZ),
	388	p->prefixlen, ifc->ifp->name);
718e3744	389	}
718e3744	390
18a6dce6	391	router_id_add_address(ifc);
18a6dce6	392
b21b19c5	393	for (node = listhead (zebrad.client_list); node; nextnode (node))
718e3744	394	if ((client = getdata (node)) != NULL)
718e3744	395	if (client->ifinfo && CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL))
b9df2d25	396	zsend_interface_address (ZEBRA_INTERFACE_ADDRESS_ADD, client, ifp, ifc);
718e3744	397	}
	398
	399	/* Interface address deletion. */
	400	void
	401	zebra_interface_address_delete_update (struct interface *ifp,
	402	struct connected *ifc)
	403	{
52dc7ee6	404	struct listnode *node;
718e3744	405	struct zserv *client;
	406	struct prefix *p;
	407	char buf[BUFSIZ];
	408
	409	if (IS_ZEBRA_DEBUG_EVENT)
	410	{
	411	p = ifc->address;
b6178002	412	zlog_debug ("MESSAGE: ZEBRA_INTERFACE_ADDRESS_DELETE %s/%d on %s",
b6178002	413	inet_ntop (p->family, &p->u.prefix, buf, BUFSIZ),
718e3744	414	p->prefixlen, ifc->ifp->name);
	415	}
	416
18a6dce6	417	router_id_del_address(ifc);
18a6dce6	418
b21b19c5	419	for (node = listhead (zebrad.client_list); node; nextnode (node))
718e3744	420	if ((client = getdata (node)) != NULL)
718e3744	421	if (client->ifinfo && CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL))
b9df2d25	422	zsend_interface_address (ZEBRA_INTERFACE_ADDRESS_DELETE, client, ifp, ifc);
718e3744	423	}