[mirror_frr.git] / ripngd / ripng_zebra.c

/*
 * RIPngd and zebra interface.
 * Copyright (C) 1998, 1999 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 "command.h"
#include "prefix.h"
#include "stream.h"
#include "routemap.h"
#include "zclient.h"
#include "log.h"

#include "ripngd/ripngd.h"

/* All information about zebra. */
struct zclient *zclient = NULL;

/* Callback prototypes for zebra client service. */
int ripng_interface_up (int, struct zclient *, zebra_size_t);
int ripng_interface_down (int, struct zclient *, zebra_size_t);
int ripng_interface_add (int, struct zclient *, zebra_size_t);
int ripng_interface_delete (int, struct zclient *, zebra_size_t);
int ripng_interface_address_add (int, struct zclient *, zebra_size_t);
int ripng_interface_address_delete (int, struct zclient *, zebra_size_t);
\f
void
ripng_zebra_ipv6_add (struct prefix_ipv6 *p, struct in6_addr *nexthop,
		      unsigned int ifindex, u_char metric)
{
  struct zapi_ipv6 api;

  if (zclient->redist[ZEBRA_ROUTE_RIPNG])
    {
      api.type = ZEBRA_ROUTE_RIPNG;
      api.flags = 0;
      api.message = 0;
      SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
      api.nexthop_num = 1;
      api.nexthop = &nexthop;
      SET_FLAG (api.message, ZAPI_MESSAGE_IFINDEX);
      api.ifindex_num = 1;
      api.ifindex = &ifindex;
      SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
      api.metric = metric;
      
      zapi_ipv6_route (ZEBRA_IPV6_ROUTE_ADD, zclient, p, &api);
    }
}

void
ripng_zebra_ipv6_delete (struct prefix_ipv6 *p, struct in6_addr *nexthop,
			 unsigned int ifindex)
{
  struct zapi_ipv6 api;

  if (zclient->redist[ZEBRA_ROUTE_RIPNG])
    {
      api.type = ZEBRA_ROUTE_RIPNG;
      api.flags = 0;
      api.message = 0;
      SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
      api.nexthop_num = 1;
      api.nexthop = &nexthop;
      SET_FLAG (api.message, ZAPI_MESSAGE_IFINDEX);
      api.ifindex_num = 1;
      api.ifindex = &ifindex;

      zapi_ipv6_route (ZEBRA_IPV6_ROUTE_DELETE, zclient, p, &api);
    }
}

/* Zebra route add and delete treatment. */
int
ripng_zebra_read_ipv6 (int command, struct zclient *zclient,
		       zebra_size_t length)
{
  struct stream *s;
  struct zapi_ipv6 api;
  unsigned long ifindex;
  struct in6_addr nexthop;
  struct prefix_ipv6 p;

  s = zclient->ibuf;
  ifindex = 0;
  memset (&nexthop, 0, sizeof (struct in6_addr));

  /* Type, flags, message. */
  api.type = stream_getc (s);
  api.flags = stream_getc (s);
  api.message = stream_getc (s);

  /* IPv6 prefix. */
  memset (&p, 0, sizeof (struct prefix_ipv6));
  p.family = AF_INET6;
  p.prefixlen = stream_getc (s);
  stream_get (&p.prefix, s, PSIZE (p.prefixlen));

  /* Nexthop, ifindex, distance, metric. */
  if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
    {
      api.nexthop_num = stream_getc (s);
      stream_get (&nexthop, s, 16);
    }
  if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX))
    {
      api.ifindex_num = stream_getc (s);
      ifindex = stream_getl (s);
    }
  if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
    api.distance = stream_getc (s);
  else
    api.distance = 0;
  if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
    api.metric = stream_getl (s);
  else
    api.metric = 0;

  if (command == ZEBRA_IPV6_ROUTE_ADD)
    ripng_redistribute_add (api.type, RIPNG_ROUTE_REDISTRIBUTE, &p, ifindex, &nexthop);
  else
    ripng_redistribute_delete (api.type, RIPNG_ROUTE_REDISTRIBUTE, &p, ifindex);

  return 0;
}

void
ripng_zclient_reset ()
{
  zclient_reset (zclient);
}

int
ripng_redistribute_unset (int type)
{
  if (! zclient->redist[type])
    return CMD_SUCCESS;

  zclient->redist[type] = 0;

  if (zclient->sock > 0)
    zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE, zclient, type);

  ripng_redistribute_withdraw (type);
  
  return CMD_SUCCESS;
}

int
ripng_redistribute_check (int type)
{
  return (zclient->redist[type]);
}

void
ripng_redistribute_metric_set (int type, int metric)
{
  ripng->route_map[type].metric_config = 1;
  ripng->route_map[type].metric = metric;
}

int
ripng_redistribute_metric_unset (int type)
{
  ripng->route_map[type].metric_config = 0;
  ripng->route_map[type].metric = 0;
  return 0;
}

void
ripng_redistribute_routemap_set (int type, const char *name)
{
  if (ripng->route_map[type].name)
    free (ripng->route_map[type].name);

  ripng->route_map[type].name = strdup (name);
  ripng->route_map[type].map = route_map_lookup_by_name (name);
}

void
ripng_redistribute_routemap_unset (int type)
{
  if (ripng->route_map[type].name)
    free (ripng->route_map[type].name);

  ripng->route_map[type].name = NULL;
  ripng->route_map[type].map = NULL;
}
\f
/* Redistribution types */
static struct {
  int type;
  int str_min_len;
  const char *str;
} redist_type[] = {
  {ZEBRA_ROUTE_KERNEL,  1, "kernel"},
  {ZEBRA_ROUTE_CONNECT, 1, "connected"},
  {ZEBRA_ROUTE_STATIC,  1, "static"},
  {ZEBRA_ROUTE_OSPF6,   1, "ospf6"},
  {ZEBRA_ROUTE_BGP,     1, "bgp"},
  {0, 0, NULL}
};

void
ripng_redistribute_clean ()
{
  int i;

  for (i = 0; redist_type[i].str; i++)
    {
      if (zclient->redist[redist_type[i].type])
        {
          if (zclient->sock > 0)
            zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE,
                                     zclient, redist_type[i].type);

          zclient->redist[redist_type[i].type] = 0;

          /* Remove the routes from RIPng table. */
          ripng_redistribute_withdraw (redist_type[i].type);
        }
    }
}

DEFUN (router_zebra,
       router_zebra_cmd,
       "router zebra",
       "Enable a routing process\n"
       "Make connection to zebra daemon\n")
{
  vty->node = ZEBRA_NODE;
  zclient->enable = 1;
  zclient_start (zclient);
  return CMD_SUCCESS;
}

DEFUN (no_router_zebra,
       no_router_zebra_cmd,
       "no router zebra",
       NO_STR
       "Disable a routing process\n"
       "Stop connection to zebra daemon\n")
{
  zclient->enable = 0;
  zclient_stop (zclient);
  return CMD_SUCCESS;
}

DEFUN (ripng_redistribute_ripng,
       ripng_redistribute_ripng_cmd,
       "redistribute ripng",
       "Redistribute information from another routing protocol\n"
       "RIPng route\n")
{
  zclient->redist[ZEBRA_ROUTE_RIPNG] = 1;
  return CMD_SUCCESS;
}

DEFUN (no_ripng_redistribute_ripng,
       no_ripng_redistribute_ripng_cmd,
       "no redistribute ripng",
       NO_STR
       "Redistribute information from another routing protocol\n"
       "RIPng route\n")
{
  zclient->redist[ZEBRA_ROUTE_RIPNG] = 0;
  return CMD_SUCCESS;
}

DEFUN (ripng_redistribute_type,
       ripng_redistribute_type_cmd,
       "redistribute (kernel|connected|static|ospf6|bgp)",
       "Redistribute information from another routing protocol\n"
       "Kernel routes\n"
       "Connected\n"
       "Static routes\n"
       "Open Shortest Path First (OSPFv3)\n"
       "Border Gateway Protocol (BGP)\n")
{
  int i;

  for(i = 0; redist_type[i].str; i++) 
    {
      if (strncmp (redist_type[i].str, argv[0], 
		   redist_type[i].str_min_len) == 0) 
	{
	  zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, redist_type[i].type);
	  return CMD_SUCCESS;
	}
    }

  vty_out(vty, "Invalid type %s%s", argv[0],
	  VTY_NEWLINE);

  return CMD_WARNING;
}

DEFUN (no_ripng_redistribute_type,
       no_ripng_redistribute_type_cmd,
       "no redistribute (kernel|connected|static|ospf6|bgp)",
       NO_STR
       "Redistribute information from another routing protocol\n"
       "Kernel routes\n"
       "Connected\n"
       "Static routes\n"
       "Open Shortest Path First (OSPFv3)\n"
       "Border Gateway Protocol (BGP)\n")
{
  int i;

  for (i = 0; redist_type[i].str; i++) 
    {
      if (strncmp(redist_type[i].str, argv[0], 
		  redist_type[i].str_min_len) == 0) 
	{
	  ripng_redistribute_metric_unset (redist_type[i].type);
	  ripng_redistribute_routemap_unset (redist_type[i].type);
	  return ripng_redistribute_unset (redist_type[i].type);
        }
    }

  vty_out(vty, "Invalid type %s%s", argv[0],
	  VTY_NEWLINE);

  return CMD_WARNING;
}


DEFUN (ripng_redistribute_type_metric,
       ripng_redistribute_type_metric_cmd,
       "redistribute (kernel|connected|static|ospf6|bgp) metric <0-16>",
       "Redistribute information from another routing protocol\n"
       "Kernel routes\n"
       "Connected\n"
       "Static routes\n"
       "Open Shortest Path First (OSPFv3)\n"
       "Border Gateway Protocol (BGP)\n"
       "Metric\n"
       "Metric value\n")
{
  int i;
  int metric;

  metric = atoi (argv[1]);

  for (i = 0; redist_type[i].str; i++) {
    if (strncmp(redist_type[i].str, argv[0],
		redist_type[i].str_min_len) == 0) 
      {
	ripng_redistribute_metric_set (redist_type[i].type, metric);
	zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, redist_type[i].type);
	return CMD_SUCCESS;
      }
  }

  vty_out(vty, "Invalid type %s%s", argv[0],
	  VTY_NEWLINE);

  return CMD_WARNING;
}

ALIAS (no_ripng_redistribute_type,
       no_ripng_redistribute_type_metric_cmd,
       "no redistribute (kernel|connected|static|ospf6|bgp) metric <0-16>",
       NO_STR
       "Redistribute information from another routing protocol\n"
       "Kernel routes\n"
       "Connected\n"
       "Static routes\n"
       "Open Shortest Path First (OSPFv3)\n"
       "Border Gateway Protocol (BGP)\n"
       "Metric\n"
       "Metric value\n")

DEFUN (ripng_redistribute_type_routemap,
       ripng_redistribute_type_routemap_cmd,
       "redistribute (kernel|connected|static|ospf6|bgp) route-map WORD",
       "Redistribute information from another routing protocol\n"
       "Kernel routes\n"
       "Connected\n"
       "Static routes\n"
       "Open Shortest Path First (OSPFv3)\n"
       "Border Gateway Protocol (BGP)\n"
       "Route map reference\n"
       "Pointer to route-map entries\n")
{
  int i;

  for (i = 0; redist_type[i].str; i++) {
    if (strncmp(redist_type[i].str, argv[0],
		redist_type[i].str_min_len) == 0) 
      {
	ripng_redistribute_routemap_set (redist_type[i].type, argv[1]);
	zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, redist_type[i].type);
	return CMD_SUCCESS;
      }
  }

  vty_out(vty, "Invalid type %s%s", argv[0],
	  VTY_NEWLINE);

  return CMD_WARNING;
}

ALIAS (no_ripng_redistribute_type,
       no_ripng_redistribute_type_routemap_cmd,
       "no redistribute (kernel|connected|static|ospf6|bgp) route-map WORD",
       NO_STR
       "Redistribute information from another routing protocol\n"
       "Kernel routes\n"
       "Connected\n"
       "Static routes\n"
       "Open Shortest Path First (OSPFv3)\n"
       "Border Gateway Protocol (BGP)\n"
       "Route map reference\n"
       "Pointer to route-map entries\n")

DEFUN (ripng_redistribute_type_metric_routemap,
       ripng_redistribute_type_metric_routemap_cmd,
       "redistribute (kernel|connected|static|ospf6|bgp) metric <0-16> route-map WORD",
       "Redistribute information from another routing protocol\n"
       "Kernel routes\n"
       "Connected\n"
       "Static routes\n"
       "Open Shortest Path First (OSPFv3)\n"
       "Border Gateway Protocol (BGP)\n"
       "Metric\n"
       "Metric value\n"
       "Route map reference\n"
       "Pointer to route-map entries\n")
{
  int i;
  int metric;

  metric = atoi (argv[1]);

  for (i = 0; redist_type[i].str; i++) {
    if (strncmp(redist_type[i].str, argv[0],
		redist_type[i].str_min_len) == 0) 
      {
	ripng_redistribute_metric_set (redist_type[i].type, metric);
	ripng_redistribute_routemap_set (redist_type[i].type, argv[2]);
	zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, redist_type[i].type);
	return CMD_SUCCESS;
      }
  }

  vty_out(vty, "Invalid type %s%s", argv[0],
	  VTY_NEWLINE);

  return CMD_WARNING;
}

ALIAS (no_ripng_redistribute_type,
       no_ripng_redistribute_type_metric_routemap_cmd,
       "no redistribute (kernel|connected|static|ospf6|bgp) metric <0-16> route-map WORD",
       NO_STR
       "Redistribute information from another routing protocol\n"
       "Kernel routes\n"
       "Connected\n"
       "Static routes\n"
       "Open Shortest Path First (OSPFv3)\n"
       "Border Gateway Protocol (BGP)\n"
       "Route map reference\n"
       "Pointer to route-map entries\n")

void
ripng_redistribute_write (struct vty *vty, int config_mode)
{
  int i;

  for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
    if (i != zclient->redist_default && zclient->redist[i])
      {
      if (config_mode)
	{
	  if (ripng->route_map[i].metric_config)
	    {
	      if (ripng->route_map[i].name)
		vty_out (vty, " redistribute %s metric %d route-map %s%s",
			 zebra_route_string(i), ripng->route_map[i].metric,
			ripng->route_map[i].name, VTY_NEWLINE);
	      else
		vty_out (vty, " redistribute %s metric %d%s",
			zebra_route_string(i), ripng->route_map[i].metric,
			VTY_NEWLINE);
	    }
	  else
	    {
	      if (ripng->route_map[i].name)
		vty_out (vty, " redistribute %s route-map %s%s",
			 zebra_route_string(i), ripng->route_map[i].name,
			 VTY_NEWLINE);
	      else
		vty_out (vty, " redistribute %s%s", zebra_route_string(i),
			 VTY_NEWLINE);
	    }
	}
      else
	vty_out (vty, "    %s", zebra_route_string(i));
      }
}

/* RIPng configuration write function. */
int
zebra_config_write (struct vty *vty)
{
  if (! zclient->enable)
    {
      vty_out (vty, "no router zebra%s", VTY_NEWLINE);
      return 1;
    }
  else if (! zclient->redist[ZEBRA_ROUTE_RIPNG])
    {
      vty_out (vty, "router zebra%s", VTY_NEWLINE);
      vty_out (vty, " no redistribute ripng%s", VTY_NEWLINE);
      return 1;
    }
  return 0;
}

/* Zebra node structure. */
struct cmd_node zebra_node =
{
  ZEBRA_NODE,
  "%s(config-router)# ",
};

/* Initialize zebra structure and it's commands. */
void
zebra_init ()
{
  /* Allocate zebra structure. */
  zclient = zclient_new ();
  zclient_init (zclient, ZEBRA_ROUTE_RIPNG);

  zclient->interface_up = ripng_interface_up;
  zclient->interface_down = ripng_interface_down;
  zclient->interface_add = ripng_interface_add;
  zclient->interface_delete = ripng_interface_delete;
  zclient->interface_address_add = ripng_interface_address_add;
  zclient->interface_address_delete = ripng_interface_address_delete;
  zclient->ipv6_route_add = ripng_zebra_read_ipv6;
  zclient->ipv6_route_delete = ripng_zebra_read_ipv6;
  
  /* Install zebra node. */
  install_node (&zebra_node, zebra_config_write);

  /* Install command element for zebra node. */ 
  install_element (CONFIG_NODE, &router_zebra_cmd);
  install_element (CONFIG_NODE, &no_router_zebra_cmd);
  install_default (ZEBRA_NODE);
  install_element (ZEBRA_NODE, &ripng_redistribute_ripng_cmd);
  install_element (ZEBRA_NODE, &no_ripng_redistribute_ripng_cmd);

  /* Install command elements to ripng node */
  install_element (RIPNG_NODE, &ripng_redistribute_type_cmd);
  install_element (RIPNG_NODE, &ripng_redistribute_type_routemap_cmd);
  install_element (RIPNG_NODE, &ripng_redistribute_type_metric_cmd);
  install_element (RIPNG_NODE, &ripng_redistribute_type_metric_routemap_cmd);
  install_element (RIPNG_NODE, &no_ripng_redistribute_type_cmd);
  install_element (RIPNG_NODE, &no_ripng_redistribute_type_routemap_cmd);
  install_element (RIPNG_NODE, &no_ripng_redistribute_type_metric_cmd);
  install_element (RIPNG_NODE, &no_ripng_redistribute_type_metric_routemap_cmd);
}
Commit	Line	Data
718e3744	1	/*
	2	* RIPngd and zebra interface.
	3	* Copyright (C) 1998, 1999 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 "command.h"
	26	#include "prefix.h"
	27	#include "stream.h"
	28	#include "routemap.h"
	29	#include "zclient.h"
	30	#include "log.h"
	31
	32	#include "ripngd/ripngd.h"
	33
	34	/* All information about zebra. */
	35	struct zclient *zclient = NULL;
	36
	37	/* Callback prototypes for zebra client service. */
	38	int ripng_interface_up (int, struct zclient *, zebra_size_t);
	39	int ripng_interface_down (int, struct zclient *, zebra_size_t);
	40	int ripng_interface_add (int, struct zclient *, zebra_size_t);
	41	int ripng_interface_delete (int, struct zclient *, zebra_size_t);
	42	int ripng_interface_address_add (int, struct zclient *, zebra_size_t);
	43	int ripng_interface_address_delete (int, struct zclient *, zebra_size_t);
	44	\f
	45	void
	46	ripng_zebra_ipv6_add (struct prefix_ipv6 p, struct in6_addr nexthop,
deba3550	47	unsigned int ifindex, u_char metric)
718e3744	48	{
	49	struct zapi_ipv6 api;
	50
	51	if (zclient->redist[ZEBRA_ROUTE_RIPNG])
	52	{
	53	api.type = ZEBRA_ROUTE_RIPNG;
	54	api.flags = 0;
	55	api.message = 0;
	56	SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
	57	api.nexthop_num = 1;
	58	api.nexthop = &nexthop;
	59	SET_FLAG (api.message, ZAPI_MESSAGE_IFINDEX);
	60	api.ifindex_num = 1;
	61	api.ifindex = &ifindex;
deba3550	62	SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
	63	api.metric = metric;
	64
0a589359	65	zapi_ipv6_route (ZEBRA_IPV6_ROUTE_ADD, zclient, p, &api);
718e3744	66	}
	67	}
	68
	69	void
	70	ripng_zebra_ipv6_delete (struct prefix_ipv6 p, struct in6_addr nexthop,
	71	unsigned int ifindex)
	72	{
	73	struct zapi_ipv6 api;
	74
	75	if (zclient->redist[ZEBRA_ROUTE_RIPNG])
	76	{
	77	api.type = ZEBRA_ROUTE_RIPNG;
	78	api.flags = 0;
	79	api.message = 0;
	80	SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
	81	api.nexthop_num = 1;
	82	api.nexthop = &nexthop;
	83	SET_FLAG (api.message, ZAPI_MESSAGE_IFINDEX);
	84	api.ifindex_num = 1;
	85	api.ifindex = &ifindex;
	86
0a589359	87	zapi_ipv6_route (ZEBRA_IPV6_ROUTE_DELETE, zclient, p, &api);
718e3744	88	}
	89	}
	90
	91	/* Zebra route add and delete treatment. */
	92	int
	93	ripng_zebra_read_ipv6 (int command, struct zclient *zclient,
	94	zebra_size_t length)
	95	{
	96	struct stream *s;
	97	struct zapi_ipv6 api;
	98	unsigned long ifindex;
	99	struct in6_addr nexthop;
	100	struct prefix_ipv6 p;
	101
	102	s = zclient->ibuf;
	103	ifindex = 0;
	104	memset (&nexthop, 0, sizeof (struct in6_addr));
	105
	106	/* Type, flags, message. */
	107	api.type = stream_getc (s);
	108	api.flags = stream_getc (s);
	109	api.message = stream_getc (s);
	110
	111	/* IPv6 prefix. */
	112	memset (&p, 0, sizeof (struct prefix_ipv6));
	113	p.family = AF_INET6;
	114	p.prefixlen = stream_getc (s);
	115	stream_get (&p.prefix, s, PSIZE (p.prefixlen));
	116
	117	/* Nexthop, ifindex, distance, metric. */
	118	if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
	119	{
	120	api.nexthop_num = stream_getc (s);
	121	stream_get (&nexthop, s, 16);
	122	}
	123	if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX))
	124	{
	125	api.ifindex_num = stream_getc (s);
	126	ifindex = stream_getl (s);
	127	}
	128	if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
	129	api.distance = stream_getc (s);
	130	else
	131	api.distance = 0;
	132	if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
	133	api.metric = stream_getl (s);
	134	else
	135	api.metric = 0;
	136
	137	if (command == ZEBRA_IPV6_ROUTE_ADD)
a94434b6	138	ripng_redistribute_add (api.type, RIPNG_ROUTE_REDISTRIBUTE, &p, ifindex, &nexthop);
718e3744	139	else
a94434b6	140	ripng_redistribute_delete (api.type, RIPNG_ROUTE_REDISTRIBUTE, &p, ifindex);
718e3744	141
	142	return 0;
	143	}
	144
a94434b6	145	void
	146	ripng_zclient_reset ()
	147	{
	148	zclient_reset (zclient);
	149	}
	150
718e3744	151	int
	152	ripng_redistribute_unset (int type)
	153	{
	154	if (! zclient->redist[type])
	155	return CMD_SUCCESS;
	156
	157	zclient->redist[type] = 0;
	158
	159	if (zclient->sock > 0)
634f9ea2	160	zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE, zclient, type);
718e3744	161
	162	ripng_redistribute_withdraw (type);
	163
	164	return CMD_SUCCESS;
	165	}
	166
a94434b6	167	int
	168	ripng_redistribute_check (int type)
	169	{
	170	return (zclient->redist[type]);
	171	}
	172
718e3744	173	void
	174	ripng_redistribute_metric_set (int type, int metric)
	175	{
	176	ripng->route_map[type].metric_config = 1;
	177	ripng->route_map[type].metric = metric;
	178	}
	179
a94434b6	180	int
718e3744	181	ripng_redistribute_metric_unset (int type)
	182	{
	183	ripng->route_map[type].metric_config = 0;
	184	ripng->route_map[type].metric = 0;
a94434b6	185	return 0;
718e3744	186	}
	187
	188	void
98b718a9	189	ripng_redistribute_routemap_set (int type, const char *name)
718e3744	190	{
	191	if (ripng->route_map[type].name)
	192	free (ripng->route_map[type].name);
	193
	194	ripng->route_map[type].name = strdup (name);
	195	ripng->route_map[type].map = route_map_lookup_by_name (name);
	196	}
	197
	198	void
	199	ripng_redistribute_routemap_unset (int type)
	200	{
	201	if (ripng->route_map[type].name)
	202	free (ripng->route_map[type].name);
	203
	204	ripng->route_map[type].name = NULL;
	205	ripng->route_map[type].map = NULL;
	206	}
718e3744	207	\f
a94434b6	208	/* Redistribution types */
	209	static struct {
	210	int type;
	211	int str_min_len;
7a1d583c	212	const char *str;
a94434b6	213	} redist_type[] = {
	214	{ZEBRA_ROUTE_KERNEL, 1, "kernel"},
	215	{ZEBRA_ROUTE_CONNECT, 1, "connected"},
	216	{ZEBRA_ROUTE_STATIC, 1, "static"},
	217	{ZEBRA_ROUTE_OSPF6, 1, "ospf6"},
	218	{ZEBRA_ROUTE_BGP, 1, "bgp"},
	219	{0, 0, NULL}
	220	};
	221
	222	void
	223	ripng_redistribute_clean ()
	224	{
	225	int i;
	226
	227	for (i = 0; redist_type[i].str; i++)
	228	{
	229	if (zclient->redist[redist_type[i].type])
	230	{
	231	if (zclient->sock > 0)
	232	zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE,
634f9ea2	233	zclient, redist_type[i].type);
a94434b6	234
	235	zclient->redist[redist_type[i].type] = 0;
	236
	237	/* Remove the routes from RIPng table. */
	238	ripng_redistribute_withdraw (redist_type[i].type);
	239	}
	240	}
	241	}
	242
718e3744	243	DEFUN (router_zebra,
	244	router_zebra_cmd,
	245	"router zebra",
	246	"Enable a routing process\n"
	247	"Make connection to zebra daemon\n")
	248	{
	249	vty->node = ZEBRA_NODE;
	250	zclient->enable = 1;
	251	zclient_start (zclient);
	252	return CMD_SUCCESS;
	253	}
	254
	255	DEFUN (no_router_zebra,
	256	no_router_zebra_cmd,
	257	"no router zebra",
	258	NO_STR
	259	"Disable a routing process\n"
	260	"Stop connection to zebra daemon\n")
	261	{
	262	zclient->enable = 0;
	263	zclient_stop (zclient);
	264	return CMD_SUCCESS;
	265	}
	266
	267	DEFUN (ripng_redistribute_ripng,
	268	ripng_redistribute_ripng_cmd,
	269	"redistribute ripng",
	270	"Redistribute information from another routing protocol\n"
	271	"RIPng route\n")
	272	{
	273	zclient->redist[ZEBRA_ROUTE_RIPNG] = 1;
	274	return CMD_SUCCESS;
	275	}
	276
	277	DEFUN (no_ripng_redistribute_ripng,
	278	no_ripng_redistribute_ripng_cmd,
	279	"no redistribute ripng",
	280	NO_STR
	281	"Redistribute information from another routing protocol\n"
	282	"RIPng route\n")
	283	{
	284	zclient->redist[ZEBRA_ROUTE_RIPNG] = 0;
	285	return CMD_SUCCESS;
	286	}
	287
a94434b6	288	DEFUN (ripng_redistribute_type,
	289	ripng_redistribute_type_cmd,
	290	"redistribute (kernel\|connected\|static\|ospf6\|bgp)",
718e3744	291	"Redistribute information from another routing protocol\n"
a94434b6	292	"Kernel routes\n"
	293	"Connected\n"
	294	"Static routes\n"
	295	"Open Shortest Path First (OSPFv3)\n"
	296	"Border Gateway Protocol (BGP)\n")
718e3744	297	{
a94434b6	298	int i;
718e3744	299
a94434b6	300	for(i = 0; redist_type[i].str; i++)
	301	{
	302	if (strncmp (redist_type[i].str, argv[0],
	303	redist_type[i].str_min_len) == 0)
	304	{
0a589359	305	zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, redist_type[i].type);
a94434b6	306	return CMD_SUCCESS;
	307	}
	308	}
718e3744	309
a94434b6	310	vty_out(vty, "Invalid type %s%s", argv[0],
a94434b6	311	VTY_NEWLINE);
718e3744	312
a94434b6	313	return CMD_WARNING;
718e3744	314	}
718e3744	315
a94434b6	316	DEFUN (no_ripng_redistribute_type,
	317	no_ripng_redistribute_type_cmd,
	318	"no redistribute (kernel\|connected\|static\|ospf6\|bgp)",
718e3744	319	NO_STR
718e3744	320	"Redistribute information from another routing protocol\n"
a94434b6	321	"Kernel routes\n"
	322	"Connected\n"
	323	"Static routes\n"
	324	"Open Shortest Path First (OSPFv3)\n"
718e3744	325	"Border Gateway Protocol (BGP)\n")
718e3744	326	{
a94434b6	327	int i;
718e3744	328
a94434b6	329	for (i = 0; redist_type[i].str; i++)
	330	{
	331	if (strncmp(redist_type[i].str, argv[0],
	332	redist_type[i].str_min_len) == 0)
	333	{
	334	ripng_redistribute_metric_unset (redist_type[i].type);
	335	ripng_redistribute_routemap_unset (redist_type[i].type);
	336	return ripng_redistribute_unset (redist_type[i].type);
	337	}
	338	}
718e3744	339
a94434b6	340	vty_out(vty, "Invalid type %s%s", argv[0],
a94434b6	341	VTY_NEWLINE);
718e3744	342
a94434b6	343	return CMD_WARNING;
718e3744	344	}
718e3744	345
718e3744	346
a94434b6	347	DEFUN (ripng_redistribute_type_metric,
	348	ripng_redistribute_type_metric_cmd,
	349	"redistribute (kernel\|connected\|static\|ospf6\|bgp) metric <0-16>",
718e3744	350	"Redistribute information from another routing protocol\n"
718e3744	351	"Kernel routes\n"
718e3744	352	"Connected\n"
718e3744	353	"Static routes\n"
a94434b6	354	"Open Shortest Path First (OSPFv3)\n"
a94434b6	355	"Border Gateway Protocol (BGP)\n"
718e3744	356	"Metric\n"
	357	"Metric value\n")
	358	{
a94434b6	359	int i;
a94434b6	360	int metric;
718e3744	361
a94434b6	362	metric = atoi (argv[1]);
718e3744	363
a94434b6	364	for (i = 0; redist_type[i].str; i++) {
	365	if (strncmp(redist_type[i].str, argv[0],
	366	redist_type[i].str_min_len) == 0)
	367	{
	368	ripng_redistribute_metric_set (redist_type[i].type, metric);
0a589359	369	zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, redist_type[i].type);
a94434b6	370	return CMD_SUCCESS;
	371	}
	372	}
718e3744	373
a94434b6	374	vty_out(vty, "Invalid type %s%s", argv[0],
a94434b6	375	VTY_NEWLINE);
718e3744	376
a94434b6	377	return CMD_WARNING;
718e3744	378	}
718e3744	379
a94434b6	380	ALIAS (no_ripng_redistribute_type,
	381	no_ripng_redistribute_type_metric_cmd,
	382	"no redistribute (kernel\|connected\|static\|ospf6\|bgp) metric <0-16>",
718e3744	383	NO_STR
718e3744	384	"Redistribute information from another routing protocol\n"
a94434b6	385	"Kernel routes\n"
	386	"Connected\n"
	387	"Static routes\n"
	388	"Open Shortest Path First (OSPFv3)\n"
718e3744	389	"Border Gateway Protocol (BGP)\n"
	390	"Metric\n"
	391	"Metric value\n")
	392
a94434b6	393	DEFUN (ripng_redistribute_type_routemap,
	394	ripng_redistribute_type_routemap_cmd,
	395	"redistribute (kernel\|connected\|static\|ospf6\|bgp) route-map WORD",
718e3744	396	"Redistribute information from another routing protocol\n"
718e3744	397	"Kernel routes\n"
718e3744	398	"Connected\n"
718e3744	399	"Static routes\n"
a94434b6	400	"Open Shortest Path First (OSPFv3)\n"
718e3744	401	"Border Gateway Protocol (BGP)\n"
	402	"Route map reference\n"
	403	"Pointer to route-map entries\n")
	404	{
a94434b6	405	int i;
718e3744	406
a94434b6	407	for (i = 0; redist_type[i].str; i++) {
	408	if (strncmp(redist_type[i].str, argv[0],
	409	redist_type[i].str_min_len) == 0)
	410	{
	411	ripng_redistribute_routemap_set (redist_type[i].type, argv[1]);
0a589359	412	zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, redist_type[i].type);
a94434b6	413	return CMD_SUCCESS;
	414	}
	415	}
718e3744	416
a94434b6	417	vty_out(vty, "Invalid type %s%s", argv[0],
	418	VTY_NEWLINE);
	419
	420	return CMD_WARNING;
718e3744	421	}
718e3744	422
a94434b6	423	ALIAS (no_ripng_redistribute_type,
	424	no_ripng_redistribute_type_routemap_cmd,
	425	"no redistribute (kernel\|connected\|static\|ospf6\|bgp) route-map WORD",
718e3744	426	NO_STR
	427	"Redistribute information from another routing protocol\n"
	428	"Kernel routes\n"
718e3744	429	"Connected\n"
a94434b6	430	"Static routes\n"
	431	"Open Shortest Path First (OSPFv3)\n"
	432	"Border Gateway Protocol (BGP)\n"
718e3744	433	"Route map reference\n"
718e3744	434	"Pointer to route-map entries\n")
718e3744	435
a94434b6	436	DEFUN (ripng_redistribute_type_metric_routemap,
	437	ripng_redistribute_type_metric_routemap_cmd,
	438	"redistribute (kernel\|connected\|static\|ospf6\|bgp) metric <0-16> route-map WORD",
718e3744	439	"Redistribute information from another routing protocol\n"
a94434b6	440	"Kernel routes\n"
718e3744	441	"Connected\n"
718e3744	442	"Static routes\n"
a94434b6	443	"Open Shortest Path First (OSPFv3)\n"
a94434b6	444	"Border Gateway Protocol (BGP)\n"
718e3744	445	"Metric\n"
	446	"Metric value\n"
	447	"Route map reference\n"
	448	"Pointer to route-map entries\n")
	449	{
a94434b6	450	int i;
a94434b6	451	int metric;
718e3744	452
a94434b6	453	metric = atoi (argv[1]);
718e3744	454
a94434b6	455	for (i = 0; redist_type[i].str; i++) {
	456	if (strncmp(redist_type[i].str, argv[0],
	457	redist_type[i].str_min_len) == 0)
	458	{
	459	ripng_redistribute_metric_set (redist_type[i].type, metric);
	460	ripng_redistribute_routemap_set (redist_type[i].type, argv[2]);
0a589359	461	zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, redist_type[i].type);
a94434b6	462	return CMD_SUCCESS;
	463	}
	464	}
718e3744	465
a94434b6	466	vty_out(vty, "Invalid type %s%s", argv[0],
a94434b6	467	VTY_NEWLINE);
718e3744	468
a94434b6	469	return CMD_WARNING;
718e3744	470	}
718e3744	471
a94434b6	472	ALIAS (no_ripng_redistribute_type,
	473	no_ripng_redistribute_type_metric_routemap_cmd,
	474	"no redistribute (kernel\|connected\|static\|ospf6\|bgp) metric <0-16> route-map WORD",
718e3744	475	NO_STR
718e3744	476	"Redistribute information from another routing protocol\n"
a94434b6	477	"Kernel routes\n"
	478	"Connected\n"
	479	"Static routes\n"
	480	"Open Shortest Path First (OSPFv3)\n"
718e3744	481	"Border Gateway Protocol (BGP)\n"
718e3744	482	"Route map reference\n"
	483	"Pointer to route-map entries\n")
	484
	485	void
a94434b6	486	ripng_redistribute_write (struct vty *vty, int config_mode)
718e3744	487	{
718e3744	488	int i;
718e3744	489
	490	for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
	491	if (i != zclient->redist_default && zclient->redist[i])
	492	{
a94434b6	493	if (config_mode)
	494	{
	495	if (ripng->route_map[i].metric_config)
	496	{
	497	if (ripng->route_map[i].name)
	498	vty_out (vty, " redistribute %s metric %d route-map %s%s",
f52d13cb	499	zebra_route_string(i), ripng->route_map[i].metric,
a94434b6	500	ripng->route_map[i].name, VTY_NEWLINE);
	501	else
	502	vty_out (vty, " redistribute %s metric %d%s",
f52d13cb	503	zebra_route_string(i), ripng->route_map[i].metric,
f52d13cb	504	VTY_NEWLINE);
a94434b6	505	}
	506	else
	507	{
	508	if (ripng->route_map[i].name)
	509	vty_out (vty, " redistribute %s route-map %s%s",
f52d13cb	510	zebra_route_string(i), ripng->route_map[i].name,
f52d13cb	511	VTY_NEWLINE);
a94434b6	512	else
f52d13cb	513	vty_out (vty, " redistribute %s%s", zebra_route_string(i),
f52d13cb	514	VTY_NEWLINE);
a94434b6	515	}
	516	}
	517	else
f52d13cb	518	vty_out (vty, " %s", zebra_route_string(i));
718e3744	519	}
	520	}
	521
	522	/* RIPng configuration write function. */
	523	int
	524	zebra_config_write (struct vty *vty)
	525	{
	526	if (! zclient->enable)
	527	{
	528	vty_out (vty, "no router zebra%s", VTY_NEWLINE);
	529	return 1;
	530	}
	531	else if (! zclient->redist[ZEBRA_ROUTE_RIPNG])
	532	{
	533	vty_out (vty, "router zebra%s", VTY_NEWLINE);
	534	vty_out (vty, " no redistribute ripng%s", VTY_NEWLINE);
	535	return 1;
	536	}
	537	return 0;
	538	}
	539
	540	/* Zebra node structure. */
	541	struct cmd_node zebra_node =
	542	{
	543	ZEBRA_NODE,
	544	"%s(config-router)# ",
	545	};
	546
	547	/* Initialize zebra structure and it's commands. */
	548	void
	549	zebra_init ()
	550	{
	551	/* Allocate zebra structure. */
	552	zclient = zclient_new ();
	553	zclient_init (zclient, ZEBRA_ROUTE_RIPNG);
	554
	555	zclient->interface_up = ripng_interface_up;
	556	zclient->interface_down = ripng_interface_down;
	557	zclient->interface_add = ripng_interface_add;
	558	zclient->interface_delete = ripng_interface_delete;
	559	zclient->interface_address_add = ripng_interface_address_add;
	560	zclient->interface_address_delete = ripng_interface_address_delete;
	561	zclient->ipv6_route_add = ripng_zebra_read_ipv6;
	562	zclient->ipv6_route_delete = ripng_zebra_read_ipv6;
	563
	564	/* Install zebra node. */
	565	install_node (&zebra_node, zebra_config_write);
	566
	567	/* Install command element for zebra node. */
	568	install_element (CONFIG_NODE, &router_zebra_cmd);
	569	install_element (CONFIG_NODE, &no_router_zebra_cmd);
	570	install_default (ZEBRA_NODE);
	571	install_element (ZEBRA_NODE, &ripng_redistribute_ripng_cmd);
	572	install_element (ZEBRA_NODE, &no_ripng_redistribute_ripng_cmd);
a94434b6	573
	574	/* Install command elements to ripng node */
	575	install_element (RIPNG_NODE, &ripng_redistribute_type_cmd);
	576	install_element (RIPNG_NODE, &ripng_redistribute_type_routemap_cmd);
	577	install_element (RIPNG_NODE, &ripng_redistribute_type_metric_cmd);
	578	install_element (RIPNG_NODE, &ripng_redistribute_type_metric_routemap_cmd);
	579	install_element (RIPNG_NODE, &no_ripng_redistribute_type_cmd);
	580	install_element (RIPNG_NODE, &no_ripng_redistribute_type_routemap_cmd);
	581	install_element (RIPNG_NODE, &no_ripng_redistribute_type_metric_cmd);
	582	install_element (RIPNG_NODE, &no_ripng_redistribute_type_metric_routemap_cmd);
718e3744	583	}