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

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)
          || IPV4_LINKLOCAL(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, *nnode;
  struct zserv *client;

  for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
    {
      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, *nnode;
  struct zserv *client;

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

  for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
    {
      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, *nnode;
  struct zserv *client;

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

  for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
    zsend_interface_update (ZEBRA_INTERFACE_UP, client, ifp);
}

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

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

  for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
    zsend_interface_update (ZEBRA_INTERFACE_DOWN, client, ifp);
}

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

  if (IS_ZEBRA_DEBUG_EVENT)
    zlog_debug ("MESSAGE: ZEBRA_INTERFACE_ADD %s", ifp->name);
    
  for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
    if (client->ifinfo)
      zsend_interface_add (client, ifp);
}

void
zebra_interface_delete_update (struct interface *ifp)
{
  struct listnode *node, *nnode;
  struct zserv *client;

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

  for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
    if (client->ifinfo)
      zsend_interface_delete (client, ifp);
}

/* Interface address addition. */
void
zebra_interface_address_add_update (struct interface *ifp,
				    struct connected *ifc)
{
  struct listnode *node, *nnode;
  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 (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
    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, *nnode;
  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 (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
    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
6dc686a2	43	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
6dc686a2 PJ	53	if (IPV4_NET127 (addr)
	54	\|\| IN_CLASSD (addr)
	55	\|\| IPV4_LINKLOCAL(addr))
718e3744	56	return 0;
	57	}
	58	#ifdef HAVE_IPV6
	59	if (p->family == AF_INET6)
	60	{
	61	if (IN6_IS_ADDR_LOOPBACK (&p->u.prefix6))
	62	return 0;
	63	if (IN6_IS_ADDR_LINKLOCAL(&p->u.prefix6))
	64	return 0;
	65	}
	66	#endif /* HAVE_IPV6 */
	67	return 1;
	68	}
	69
27da3988	70	static int
718e3744	71	is_default (struct prefix *p)
	72	{
	73	if (p->family == AF_INET)
	74	if (p->u.prefix4.s_addr == 0 && p->prefixlen == 0)
	75	return 1;
	76	#ifdef HAVE_IPV6
	77	#if 0 /* IPv6 default separation is now pending until protocol daemon
	78	can handle that. */
	79	if (p->family == AF_INET6)
	80	if (IN6_IS_ADDR_UNSPECIFIED (&p->u.prefix6) && p->prefixlen == 0)
	81	return 1;
	82	#endif /* 0 */
	83	#endif /* HAVE_IPV6 */
	84	return 0;
	85	}
	86
27da3988	87	static void
718e3744	88	zebra_redistribute_default (struct zserv *client)
	89	{
	90	struct prefix_ipv4 p;
	91	struct route_table *table;
	92	struct route_node *rn;
	93	struct rib *newrib;
	94	#ifdef HAVE_IPV6
	95	struct prefix_ipv6 p6;
	96	#endif /* HAVE_IPV6 */
	97
	98
	99	/* Lookup default route. */
	100	memset (&p, 0, sizeof (struct prefix_ipv4));
	101	p.family = AF_INET;
	102
	103	/* Lookup table. */
	104	table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
	105	if (table)
	106	{
	107	rn = route_node_lookup (table, (struct prefix *)&p);
	108	if (rn)
	109	{
	110	for (newrib = rn->info; newrib; newrib = newrib->next)
	111	if (CHECK_FLAG (newrib->flags, ZEBRA_FLAG_SELECTED)
	112	&& newrib->distance != DISTANCE_INFINITY)
b9df2d25	113	zsend_route_multipath (ZEBRA_IPV4_ROUTE_ADD, client, &rn->p, newrib);
718e3744	114	route_unlock_node (rn);
	115	}
	116	}
	117
	118	#ifdef HAVE_IPV6
	119	/* Lookup default route. */
	120	memset (&p6, 0, sizeof (struct prefix_ipv6));
	121	p6.family = AF_INET6;
	122
	123	/* Lookup table. */
	124	table = vrf_table (AFI_IP6, SAFI_UNICAST, 0);
	125	if (table)
	126	{
	127	rn = route_node_lookup (table, (struct prefix *)&p6);
	128	if (rn)
	129	{
	130	for (newrib = rn->info; newrib; newrib = newrib->next)
	131	if (CHECK_FLAG (newrib->flags, ZEBRA_FLAG_SELECTED)
	132	&& newrib->distance != DISTANCE_INFINITY)
b9df2d25	133	zsend_route_multipath (ZEBRA_IPV6_ROUTE_ADD, client, &rn->p, newrib);
718e3744	134	route_unlock_node (rn);
	135	}
	136	}
	137	#endif /* HAVE_IPV6 */
	138	}
	139
	140	/* Redistribute routes. */
27da3988	141	static void
718e3744	142	zebra_redistribute (struct zserv *client, int type)
	143	{
	144	struct rib *newrib;
	145	struct route_table *table;
	146	struct route_node *rn;
	147
	148	table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
	149	if (table)
	150	for (rn = route_top (table); rn; rn = route_next (rn))
	151	for (newrib = rn->info; newrib; newrib = newrib->next)
	152	if (CHECK_FLAG (newrib->flags, ZEBRA_FLAG_SELECTED)
	153	&& newrib->type == type
	154	&& newrib->distance != DISTANCE_INFINITY
	155	&& zebra_check_addr (&rn->p))
b9df2d25	156	zsend_route_multipath (ZEBRA_IPV4_ROUTE_ADD, client, &rn->p, newrib);
718e3744	157
	158	#ifdef HAVE_IPV6
	159	table = vrf_table (AFI_IP6, SAFI_UNICAST, 0);
	160	if (table)
	161	for (rn = route_top (table); rn; rn = route_next (rn))
	162	for (newrib = rn->info; newrib; newrib = newrib->next)
	163	if (CHECK_FLAG (newrib->flags, ZEBRA_FLAG_SELECTED)
	164	&& newrib->type == type
	165	&& newrib->distance != DISTANCE_INFINITY
	166	&& zebra_check_addr (&rn->p))
b9df2d25	167	zsend_route_multipath (ZEBRA_IPV6_ROUTE_ADD, client, &rn->p, newrib);
718e3744	168	#endif /* HAVE_IPV6 */
	169	}
	170
718e3744	171	void
	172	redistribute_add (struct prefix p, struct rib rib)
	173	{
1eb8ef25	174	struct listnode node, nnode;
718e3744	175	struct zserv *client;
718e3744	176
1eb8ef25	177	for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
	178	{
	179	if (is_default (p))
	180	{
	181	if (client->redist_default \|\| client->redist[rib->type])
	182	{
	183	if (p->family == AF_INET)
	184	zsend_route_multipath (ZEBRA_IPV4_ROUTE_ADD, client, p, rib);
718e3744	185	#ifdef HAVE_IPV6
1eb8ef25	186	if (p->family == AF_INET6)
1eb8ef25	187	zsend_route_multipath (ZEBRA_IPV6_ROUTE_ADD, client, p, rib);
718e3744	188	#endif /* HAVE_IPV6 */
1eb8ef25	189	}
	190	}
	191	else if (client->redist[rib->type])
	192	{
	193	if (p->family == AF_INET)
	194	zsend_route_multipath (ZEBRA_IPV4_ROUTE_ADD, client, p, rib);
718e3744	195	#ifdef HAVE_IPV6
1eb8ef25	196	if (p->family == AF_INET6)
1eb8ef25	197	zsend_route_multipath (ZEBRA_IPV6_ROUTE_ADD, client, p, rib);
718e3744	198	#endif /* HAVE_IPV6 */
1eb8ef25	199	}
1eb8ef25	200	}
718e3744	201	}
	202
	203	void
	204	redistribute_delete (struct prefix p, struct rib rib)
	205	{
1eb8ef25	206	struct listnode node, nnode;
718e3744	207	struct zserv *client;
	208
	209	/* Add DISTANCE_INFINITY check. */
	210	if (rib->distance == DISTANCE_INFINITY)
	211	return;
	212
1eb8ef25	213	for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
	214	{
	215	if (is_default (p))
	216	{
	217	if (client->redist_default \|\| client->redist[rib->type])
	218	{
	219	if (p->family == AF_INET)
	220	zsend_route_multipath (ZEBRA_IPV4_ROUTE_DELETE, client, p,
	221	rib);
718e3744	222	#ifdef HAVE_IPV6
1eb8ef25	223	if (p->family == AF_INET6)
	224	zsend_route_multipath (ZEBRA_IPV6_ROUTE_DELETE, client, p,
	225	rib);
	226	#endif /* HAVE_IPV6 */
	227	}
	228	}
	229	else if (client->redist[rib->type])
	230	{
	231	if (p->family == AF_INET)
	232	zsend_route_multipath (ZEBRA_IPV4_ROUTE_DELETE, client, p, rib);
718e3744	233	#ifdef HAVE_IPV6
1eb8ef25	234	if (p->family == AF_INET6)
	235	zsend_route_multipath (ZEBRA_IPV6_ROUTE_DELETE, client, p, rib);
	236	#endif /* HAVE_IPV6 */
	237	}
	238	}
718e3744	239	}
	240
	241	void
	242	zebra_redistribute_add (int command, struct zserv *client, int length)
	243	{
	244	int type;
	245
	246	type = stream_getc (client->ibuf);
	247
	248	switch (type)
	249	{
	250	case ZEBRA_ROUTE_KERNEL:
	251	case ZEBRA_ROUTE_CONNECT:
	252	case ZEBRA_ROUTE_STATIC:
	253	case ZEBRA_ROUTE_RIP:
	254	case ZEBRA_ROUTE_RIPNG:
	255	case ZEBRA_ROUTE_OSPF:
	256	case ZEBRA_ROUTE_OSPF6:
	257	case ZEBRA_ROUTE_BGP:
	258	if (! client->redist[type])
	259	{
	260	client->redist[type] = 1;
	261	zebra_redistribute (client, type);
	262	}
	263	break;
	264	default:
	265	break;
	266	}
	267	}
	268
	269	void
	270	zebra_redistribute_delete (int command, struct zserv *client, int length)
	271	{
	272	int type;
	273
	274	type = stream_getc (client->ibuf);
	275
	276	switch (type)
	277	{
	278	case ZEBRA_ROUTE_KERNEL:
	279	case ZEBRA_ROUTE_CONNECT:
	280	case ZEBRA_ROUTE_STATIC:
	281	case ZEBRA_ROUTE_RIP:
	282	case ZEBRA_ROUTE_RIPNG:
	283	case ZEBRA_ROUTE_OSPF:
	284	case ZEBRA_ROUTE_OSPF6:
	285	case ZEBRA_ROUTE_BGP:
	286	client->redist[type] = 0;
	287	break;
	288	default:
	289	break;
	290	}
	291	}
	292
	293	void
	294	zebra_redistribute_default_add (int command, struct zserv *client, int length)
	295	{
	296	client->redist_default = 1;
	297	zebra_redistribute_default (client);
	298	}
	299
	300	void
	301	zebra_redistribute_default_delete (int command, struct zserv *client,
	302	int length)
303	{
304	client->redist_default = 0;;
305	}
306
307	/* Interface up information. */
308	void
309	zebra_interface_up_update (struct interface *ifp)
310	{
1eb8ef25	311	struct listnode node, nnode;
718e3744	312	struct zserv *client;
	313
	314	if (IS_ZEBRA_DEBUG_EVENT)
b6178002	315	zlog_debug ("MESSAGE: ZEBRA_INTERFACE_UP %s", ifp->name);
718e3744	316
1eb8ef25	317	for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
1eb8ef25	318	zsend_interface_update (ZEBRA_INTERFACE_UP, client, ifp);
718e3744	319	}
	320
	321	/* Interface down information. */
	322	void
	323	zebra_interface_down_update (struct interface *ifp)
	324	{
1eb8ef25	325	struct listnode node, nnode;
718e3744	326	struct zserv *client;
	327
	328	if (IS_ZEBRA_DEBUG_EVENT)
b6178002	329	zlog_debug ("MESSAGE: ZEBRA_INTERFACE_DOWN %s", ifp->name);
718e3744	330
1eb8ef25	331	for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
1eb8ef25	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	{
1eb8ef25	339	struct listnode node, nnode;
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
1eb8ef25	345	for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
	346	if (client->ifinfo)
	347	zsend_interface_add (client, ifp);
718e3744	348	}
	349
	350	void
	351	zebra_interface_delete_update (struct interface *ifp)
	352	{
1eb8ef25	353	struct listnode node, nnode;
718e3744	354	struct zserv *client;
	355
	356	if (IS_ZEBRA_DEBUG_EVENT)
b6178002	357	zlog_debug ("MESSAGE: ZEBRA_INTERFACE_DELETE %s", ifp->name);
718e3744	358
1eb8ef25	359	for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
	360	if (client->ifinfo)
	361	zsend_interface_delete (client, ifp);
718e3744	362	}
	363
	364	/* Interface address addition. */
	365	void
	366	zebra_interface_address_add_update (struct interface *ifp,
	367	struct connected *ifc)
	368	{
1eb8ef25	369	struct listnode node, nnode;
718e3744	370	struct zserv *client;
	371	struct prefix *p;
	372	char buf[BUFSIZ];
	373
	374	if (IS_ZEBRA_DEBUG_EVENT)
	375	{
	376	p = ifc->address;
b6178002	377	zlog_debug ("MESSAGE: ZEBRA_INTERFACE_ADDRESS_ADD %s/%d on %s",
	378	inet_ntop (p->family, &p->u.prefix, buf, BUFSIZ),
	379	p->prefixlen, ifc->ifp->name);
718e3744	380	}
718e3744	381
18a6dce6	382	router_id_add_address(ifc);
18a6dce6	383
1eb8ef25	384	for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
	385	if (client->ifinfo && CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL))
	386	zsend_interface_address (ZEBRA_INTERFACE_ADDRESS_ADD, client, ifp, ifc);
718e3744	387	}
	388
	389	/* Interface address deletion. */
	390	void
	391	zebra_interface_address_delete_update (struct interface *ifp,
	392	struct connected *ifc)
	393	{
1eb8ef25	394	struct listnode node, nnode;
718e3744	395	struct zserv *client;
	396	struct prefix *p;
	397	char buf[BUFSIZ];
	398
	399	if (IS_ZEBRA_DEBUG_EVENT)
	400	{
	401	p = ifc->address;
b6178002	402	zlog_debug ("MESSAGE: ZEBRA_INTERFACE_ADDRESS_DELETE %s/%d on %s",
b6178002	403	inet_ntop (p->family, &p->u.prefix, buf, BUFSIZ),
718e3744	404	p->prefixlen, ifc->ifp->name);
	405	}
	406
18a6dce6	407	router_id_del_address(ifc);
18a6dce6	408
1eb8ef25	409	for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
	410	if (client->ifinfo && CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL))
	411	zsend_interface_address (ZEBRA_INTERFACE_ADDRESS_DELETE, client, ifp, ifc);
718e3744	412	}