[mirror_frr.git] / ripngd / ripng_offset.c

/* RIPng offset-list
 * Copyright (C) 2000 Kunihiro Ishiguro <kunihiro@zebra.org>
 *
 * 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.  
 */

 /* RIPng support by Vincent Jardin <vincent.jardin@6wind.com>
  * Copyright (C) 2002 6WIND
  */

#include <zebra.h>

#include "if.h"
#include "prefix.h"
#include "filter.h"
#include "command.h"
#include "linklist.h"
#include "memory.h"

#include "ripngd/ripngd.h"

#define RIPNG_OFFSET_LIST_IN  0
#define RIPNG_OFFSET_LIST_OUT 1
#define RIPNG_OFFSET_LIST_MAX 2

struct ripng_offset_list
{
  char *ifname;

  struct 
  {
    char *alist_name;
    /* struct access_list *alist; */
    int metric;
  } direct[RIPNG_OFFSET_LIST_MAX];
};

static struct list *ripng_offset_list_master;

static int
strcmp_safe (const char *s1, const char *s2)
{
  if (s1 == NULL && s2 == NULL)
    return 0;
  if (s1 == NULL)
    return -1;
  if (s2 == NULL)
    return 1;
  return strcmp (s1, s2);
}

static struct ripng_offset_list *
ripng_offset_list_new (void)
{
  struct ripng_offset_list *new;

  new = XCALLOC (MTYPE_RIPNG_OFFSET_LIST, sizeof (struct ripng_offset_list));
  return new;
}

static void
ripng_offset_list_free (struct ripng_offset_list *offset)
{
  XFREE (MTYPE_RIPNG_OFFSET_LIST, offset);
}

static struct ripng_offset_list *
ripng_offset_list_lookup (const char *ifname)
{
  struct ripng_offset_list *offset;
  struct listnode *node, *nnode;

  for (ALL_LIST_ELEMENTS (ripng_offset_list_master, node, nnode, offset))
    {
      if (strcmp_safe (offset->ifname, ifname) == 0)
	return offset;
    }
  return NULL;
}

static struct ripng_offset_list *
ripng_offset_list_get (const char *ifname)
{
  struct ripng_offset_list *offset;
  
  offset = ripng_offset_list_lookup (ifname);
  if (offset)
    return offset;

  offset = ripng_offset_list_new ();
  if (ifname)
    offset->ifname = strdup (ifname);
  listnode_add_sort (ripng_offset_list_master, offset);

  return offset;
}

static int
ripng_offset_list_set (struct vty *vty, const char *alist,
		       const char *direct_str, const char *metric_str,
		       const char *ifname)
{
  int direct;
  int metric;
  struct ripng_offset_list *offset;

  /* Check direction. */
  if (strncmp (direct_str, "i", 1) == 0)
    direct = RIPNG_OFFSET_LIST_IN;
  else if (strncmp (direct_str, "o", 1) == 0)
    direct = RIPNG_OFFSET_LIST_OUT;
  else
    {
      vty_out (vty, "Invalid direction: %s%s", direct_str, VTY_NEWLINE);
      return CMD_WARNING;
    }

  /* Check metric. */
  metric = atoi (metric_str);
  if (metric < 0 || metric > 16)
    {
      vty_out (vty, "Invalid metric: %s%s", metric_str, VTY_NEWLINE);
      return CMD_WARNING;
    }

  /* Get offset-list structure with interface name. */
  offset = ripng_offset_list_get (ifname);

  if (offset->direct[direct].alist_name)
    free (offset->direct[direct].alist_name);
  offset->direct[direct].alist_name = strdup (alist);
  offset->direct[direct].metric = metric;

  return CMD_SUCCESS;
}

static int
ripng_offset_list_unset (struct vty *vty, const char *alist,
			 const char *direct_str, const char *metric_str,
			 const char *ifname)
{
  int direct;
  int metric;
  struct ripng_offset_list *offset;

  /* Check direction. */
  if (strncmp (direct_str, "i", 1) == 0)
    direct = RIPNG_OFFSET_LIST_IN;
  else if (strncmp (direct_str, "o", 1) == 0)
    direct = RIPNG_OFFSET_LIST_OUT;
  else
    {
      vty_out (vty, "Invalid direction: %s%s", direct_str, VTY_NEWLINE);
      return CMD_WARNING;
    }

  /* Check metric. */
  metric = atoi (metric_str);
  if (metric < 0 || metric > 16)
    {
      vty_out (vty, "Invalid metric: %s%s", metric_str, VTY_NEWLINE);
      return CMD_WARNING;
    }

  /* Get offset-list structure with interface name. */
  offset = ripng_offset_list_lookup (ifname);

  if (offset)
    {
      if (offset->direct[direct].alist_name)
	free (offset->direct[direct].alist_name);
      offset->direct[direct].alist_name = NULL;

      if (offset->direct[RIPNG_OFFSET_LIST_IN].alist_name == NULL &&
	  offset->direct[RIPNG_OFFSET_LIST_OUT].alist_name == NULL)
	{
	  listnode_delete (ripng_offset_list_master, offset);
	  if (offset->ifname)
	    free (offset->ifname);
	  ripng_offset_list_free (offset);
	}
    }
  else
    {
      vty_out (vty, "Can't find offset-list%s", VTY_NEWLINE);
      return CMD_WARNING;
    }
  return CMD_SUCCESS;
}

#define OFFSET_LIST_IN_NAME(O)  ((O)->direct[RIPNG_OFFSET_LIST_IN].alist_name)
#define OFFSET_LIST_IN_METRIC(O)  ((O)->direct[RIPNG_OFFSET_LIST_IN].metric)

#define OFFSET_LIST_OUT_NAME(O)  ((O)->direct[RIPNG_OFFSET_LIST_OUT].alist_name)
#define OFFSET_LIST_OUT_METRIC(O)  ((O)->direct[RIPNG_OFFSET_LIST_OUT].metric)

/* If metric is modifed return 1. */
int
ripng_offset_list_apply_in (struct prefix_ipv6 *p, struct interface *ifp,
			    u_char *metric)
{
  struct ripng_offset_list *offset;
  struct access_list *alist;

  /* Look up offset-list with interface name. */
  offset = ripng_offset_list_lookup (ifp->name);
  if (offset && OFFSET_LIST_IN_NAME (offset))
    {
      alist = access_list_lookup (AFI_IP6, OFFSET_LIST_IN_NAME (offset));

      if (alist 
	  && access_list_apply (alist, (struct prefix *)p) == FILTER_PERMIT)
	{
	  *metric += OFFSET_LIST_IN_METRIC (offset);
	  return 1;
	}
      return 0;
    }
  /* Look up offset-list without interface name. */
  offset = ripng_offset_list_lookup (NULL);
  if (offset && OFFSET_LIST_IN_NAME (offset))
    {
      alist = access_list_lookup (AFI_IP6, OFFSET_LIST_IN_NAME (offset));

      if (alist 
	  && access_list_apply (alist, (struct prefix *)p) == FILTER_PERMIT)
	{
	  *metric += OFFSET_LIST_IN_METRIC (offset);
	  return 1;
	}
      return 0;
    }
  return 0;
}

/* If metric is modifed return 1. */
int
ripng_offset_list_apply_out (struct prefix_ipv6 *p, struct interface *ifp,
			     u_char *metric)
{
  struct ripng_offset_list *offset;
  struct access_list *alist;

  /* Look up offset-list with interface name. */
  offset = ripng_offset_list_lookup (ifp->name);
  if (offset && OFFSET_LIST_OUT_NAME (offset))
    {
      alist = access_list_lookup (AFI_IP6, OFFSET_LIST_OUT_NAME (offset));

      if (alist 
	  && access_list_apply (alist, (struct prefix *)p) == FILTER_PERMIT)
	{
	  *metric += OFFSET_LIST_OUT_METRIC (offset);
	  return 1;
	}
      return 0;
    }

  /* Look up offset-list without interface name. */
  offset = ripng_offset_list_lookup (NULL);
  if (offset && OFFSET_LIST_OUT_NAME (offset))
    {
      alist = access_list_lookup (AFI_IP6, OFFSET_LIST_OUT_NAME (offset));

      if (alist 
	  && access_list_apply (alist, (struct prefix *)p) == FILTER_PERMIT)
	{
	  *metric += OFFSET_LIST_OUT_METRIC (offset);
	  return 1;
	}
      return 0;
    }
  return 0;
}

DEFUN (ripng_offset_list,
       ripng_offset_list_cmd,
       "offset-list WORD <in|out> (0-16)",
       "Modify RIPng metric\n"
       "Access-list name\n"
       "For incoming updates\n"
       "For outgoing updates\n"
       "Metric value\n")
{
  int idx_word = 1;
  int idx_in_out = 2;
  int idx_number = 3;
  return ripng_offset_list_set (vty, argv[idx_word]->arg, argv[idx_in_out]->arg, argv[idx_number]->arg, NULL);
}

DEFUN (ripng_offset_list_ifname,
       ripng_offset_list_ifname_cmd,
       "offset-list WORD <in|out> (0-16) IFNAME",
       "Modify RIPng metric\n"
       "Access-list name\n"
       "For incoming updates\n"
       "For outgoing updates\n"
       "Metric value\n"
       "Interface to match\n")
{
  int idx_word = 1;
  int idx_in_out = 2;
  int idx_number = 3;
  int idx_ifname = 4;
  return ripng_offset_list_set (vty, argv[idx_word]->arg, argv[idx_in_out]->arg, argv[idx_number]->arg, argv[idx_ifname]->arg);
}

DEFUN (no_ripng_offset_list,
       no_ripng_offset_list_cmd,
       "no offset-list WORD <in|out> (0-16)",
       NO_STR
       "Modify RIPng metric\n"
       "Access-list name\n"
       "For incoming updates\n"
       "For outgoing updates\n"
       "Metric value\n")
{
  int idx_word = 2;
  int idx_in_out = 3;
  int idx_number = 4;
  return ripng_offset_list_unset (vty, argv[idx_word]->arg, argv[idx_in_out]->arg, argv[idx_number]->arg, NULL);
}

DEFUN (no_ripng_offset_list_ifname,
       no_ripng_offset_list_ifname_cmd,
       "no offset-list WORD <in|out> (0-16) IFNAME",
       NO_STR
       "Modify RIPng metric\n"
       "Access-list name\n"
       "For incoming updates\n"
       "For outgoing updates\n"
       "Metric value\n"
       "Interface to match\n")
{
  int idx_word = 2;
  int idx_in_out = 3;
  int idx_number = 4;
  int idx_ifname = 5;
  return ripng_offset_list_unset (vty, argv[idx_word]->arg, argv[idx_in_out]->arg, argv[idx_number]->arg, argv[idx_ifname]->arg);
}

static int
offset_list_cmp (struct ripng_offset_list *o1, struct ripng_offset_list *o2)
{
  return strcmp_safe (o1->ifname, o2->ifname);
}

static void
offset_list_del (struct ripng_offset_list *offset)
{
  if (OFFSET_LIST_IN_NAME (offset))
    free (OFFSET_LIST_IN_NAME (offset));
  if (OFFSET_LIST_OUT_NAME (offset))
    free (OFFSET_LIST_OUT_NAME (offset));
  if (offset->ifname)
    free (offset->ifname);
  ripng_offset_list_free (offset);
}

void
ripng_offset_init (void)
{
  ripng_offset_list_master = list_new ();
  ripng_offset_list_master->cmp = (int (*)(void *, void *)) offset_list_cmp;
  ripng_offset_list_master->del = (void (*)(void *)) offset_list_del;

  install_element (RIPNG_NODE, &ripng_offset_list_cmd);
  install_element (RIPNG_NODE, &ripng_offset_list_ifname_cmd);
  install_element (RIPNG_NODE, &no_ripng_offset_list_cmd);
  install_element (RIPNG_NODE, &no_ripng_offset_list_ifname_cmd);
}

void
ripng_offset_clean (void)
{
  list_delete (ripng_offset_list_master);

  ripng_offset_list_master = list_new ();
  ripng_offset_list_master->cmp = (int (*)(void *, void *)) offset_list_cmp;
  ripng_offset_list_master->del = (void (*)(void *)) offset_list_del;
}

int
config_write_ripng_offset_list (struct vty *vty)
{
  struct listnode *node, *nnode;
  struct ripng_offset_list *offset;

  for (ALL_LIST_ELEMENTS (ripng_offset_list_master, node, nnode, offset))
    {
      if (! offset->ifname)
	{
	  if (offset->direct[RIPNG_OFFSET_LIST_IN].alist_name)
	    vty_out (vty, " offset-list %s in %d%s",
		     offset->direct[RIPNG_OFFSET_LIST_IN].alist_name,
		     offset->direct[RIPNG_OFFSET_LIST_IN].metric,
		     VTY_NEWLINE);
	  if (offset->direct[RIPNG_OFFSET_LIST_OUT].alist_name)
	    vty_out (vty, " offset-list %s out %d%s",
		     offset->direct[RIPNG_OFFSET_LIST_OUT].alist_name,
		     offset->direct[RIPNG_OFFSET_LIST_OUT].metric,
		     VTY_NEWLINE);
	}
      else
	{
	  if (offset->direct[RIPNG_OFFSET_LIST_IN].alist_name)
	    vty_out (vty, " offset-list %s in %d %s%s",
		     offset->direct[RIPNG_OFFSET_LIST_IN].alist_name,
		     offset->direct[RIPNG_OFFSET_LIST_IN].metric,
		     offset->ifname, VTY_NEWLINE);
	  if (offset->direct[RIPNG_OFFSET_LIST_OUT].alist_name)
	    vty_out (vty, " offset-list %s out %d %s%s",
		     offset->direct[RIPNG_OFFSET_LIST_OUT].alist_name,
		     offset->direct[RIPNG_OFFSET_LIST_OUT].metric,
		     offset->ifname, VTY_NEWLINE);
	}
    }

  return 0;
}
Commit	Line	Data
a94434b6	1	/* RIPng offset-list
	2	* Copyright (C) 2000 Kunihiro Ishiguro <kunihiro@zebra.org>
	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	/* RIPng support by Vincent Jardin <vincent.jardin@6wind.com>
	23	* Copyright (C) 2002 6WIND
	24	*/
	25
	26	#include <zebra.h>
	27
	28	#include "if.h"
	29	#include "prefix.h"
	30	#include "filter.h"
	31	#include "command.h"
	32	#include "linklist.h"
	33	#include "memory.h"
	34
6ac29a51 PJ	35	#include "ripngd/ripngd.h"
6ac29a51 PJ	36
a94434b6	37	#define RIPNG_OFFSET_LIST_IN 0
	38	#define RIPNG_OFFSET_LIST_OUT 1
	39	#define RIPNG_OFFSET_LIST_MAX 2
	40
	41	struct ripng_offset_list
	42	{
	43	char *ifname;
	44
	45	struct
	46	{
	47	char *alist_name;
	48	/* struct access_list alist; /
	49	int metric;
	50	} direct[RIPNG_OFFSET_LIST_MAX];
	51	};
	52
	53	static struct list *ripng_offset_list_master;
	54
6ac29a51	55	static int
98b718a9	56	strcmp_safe (const char s1, const char s2)
a94434b6	57	{
	58	if (s1 == NULL && s2 == NULL)
	59	return 0;
	60	if (s1 == NULL)
	61	return -1;
	62	if (s2 == NULL)
	63	return 1;
	64	return strcmp (s1, s2);
	65	}
	66
6ac29a51	67	static struct ripng_offset_list *
35dece84	68	ripng_offset_list_new (void)
a94434b6	69	{
	70	struct ripng_offset_list *new;
	71
	72	new = XCALLOC (MTYPE_RIPNG_OFFSET_LIST, sizeof (struct ripng_offset_list));
	73	return new;
	74	}
	75
6ac29a51	76	static void
a94434b6	77	ripng_offset_list_free (struct ripng_offset_list *offset)
	78	{
	79	XFREE (MTYPE_RIPNG_OFFSET_LIST, offset);
	80	}
	81
6ac29a51	82	static struct ripng_offset_list *
98b718a9	83	ripng_offset_list_lookup (const char *ifname)
a94434b6	84	{
a94434b6	85	struct ripng_offset_list *offset;
1eb8ef25	86	struct listnode node, nnode;
a94434b6	87
1eb8ef25	88	for (ALL_LIST_ELEMENTS (ripng_offset_list_master, node, nnode, offset))
a94434b6	89	{
	90	if (strcmp_safe (offset->ifname, ifname) == 0)
	91	return offset;
	92	}
	93	return NULL;
	94	}
	95
6ac29a51	96	static struct ripng_offset_list *
98b718a9	97	ripng_offset_list_get (const char *ifname)
a94434b6	98	{
	99	struct ripng_offset_list *offset;
	100
	101	offset = ripng_offset_list_lookup (ifname);
	102	if (offset)
	103	return offset;
	104
	105	offset = ripng_offset_list_new ();
	106	if (ifname)
	107	offset->ifname = strdup (ifname);
	108	listnode_add_sort (ripng_offset_list_master, offset);
	109
	110	return offset;
	111	}
	112
6ac29a51	113	static int
98b718a9	114	ripng_offset_list_set (struct vty vty, const char alist,
	115	const char direct_str, const char metric_str,
	116	const char *ifname)
a94434b6	117	{
	118	int direct;
	119	int metric;
	120	struct ripng_offset_list *offset;
	121
	122	/* Check direction. */
	123	if (strncmp (direct_str, "i", 1) == 0)
	124	direct = RIPNG_OFFSET_LIST_IN;
	125	else if (strncmp (direct_str, "o", 1) == 0)
	126	direct = RIPNG_OFFSET_LIST_OUT;
	127	else
	128	{
	129	vty_out (vty, "Invalid direction: %s%s", direct_str, VTY_NEWLINE);
	130	return CMD_WARNING;
	131	}
	132
	133	/* Check metric. */
	134	metric = atoi (metric_str);
	135	if (metric < 0 \|\| metric > 16)
	136	{
	137	vty_out (vty, "Invalid metric: %s%s", metric_str, VTY_NEWLINE);
	138	return CMD_WARNING;
	139	}
	140
	141	/* Get offset-list structure with interface name. */
	142	offset = ripng_offset_list_get (ifname);
	143
	144	if (offset->direct[direct].alist_name)
	145	free (offset->direct[direct].alist_name);
	146	offset->direct[direct].alist_name = strdup (alist);
	147	offset->direct[direct].metric = metric;
	148
	149	return CMD_SUCCESS;
	150	}
	151
6ac29a51	152	static int
98b718a9	153	ripng_offset_list_unset (struct vty vty, const char alist,
	154	const char direct_str, const char metric_str,
	155	const char *ifname)
a94434b6	156	{
	157	int direct;
	158	int metric;
	159	struct ripng_offset_list *offset;
	160
	161	/* Check direction. */
	162	if (strncmp (direct_str, "i", 1) == 0)
	163	direct = RIPNG_OFFSET_LIST_IN;
	164	else if (strncmp (direct_str, "o", 1) == 0)
	165	direct = RIPNG_OFFSET_LIST_OUT;
	166	else
	167	{
	168	vty_out (vty, "Invalid direction: %s%s", direct_str, VTY_NEWLINE);
	169	return CMD_WARNING;
	170	}
	171
	172	/* Check metric. */
	173	metric = atoi (metric_str);
	174	if (metric < 0 \|\| metric > 16)
	175	{
	176	vty_out (vty, "Invalid metric: %s%s", metric_str, VTY_NEWLINE);
	177	return CMD_WARNING;
	178	}
	179
	180	/* Get offset-list structure with interface name. */
	181	offset = ripng_offset_list_lookup (ifname);
	182
	183	if (offset)
	184	{
	185	if (offset->direct[direct].alist_name)
	186	free (offset->direct[direct].alist_name);
	187	offset->direct[direct].alist_name = NULL;
	188
	189	if (offset->direct[RIPNG_OFFSET_LIST_IN].alist_name == NULL &&
	190	offset->direct[RIPNG_OFFSET_LIST_OUT].alist_name == NULL)
	191	{
	192	listnode_delete (ripng_offset_list_master, offset);
	193	if (offset->ifname)
	194	free (offset->ifname);
	195	ripng_offset_list_free (offset);
	196	}
	197	}
	198	else
	199	{
	200	vty_out (vty, "Can't find offset-list%s", VTY_NEWLINE);
	201	return CMD_WARNING;
	202	}
	203	return CMD_SUCCESS;
	204	}
	205
	206	#define OFFSET_LIST_IN_NAME(O) ((O)->direct[RIPNG_OFFSET_LIST_IN].alist_name)
	207	#define OFFSET_LIST_IN_METRIC(O) ((O)->direct[RIPNG_OFFSET_LIST_IN].metric)
	208
	209	#define OFFSET_LIST_OUT_NAME(O) ((O)->direct[RIPNG_OFFSET_LIST_OUT].alist_name)
	210	#define OFFSET_LIST_OUT_METRIC(O) ((O)->direct[RIPNG_OFFSET_LIST_OUT].metric)
	211
	212	/* If metric is modifed return 1. */
	213	int
	214	ripng_offset_list_apply_in (struct prefix_ipv6 p, struct interface ifp,
	215	u_char *metric)
	216	{
	217	struct ripng_offset_list *offset;
	218	struct access_list *alist;
	219
220	/* Look up offset-list with interface name. */
221	offset = ripng_offset_list_lookup (ifp->name);
222	if (offset && OFFSET_LIST_IN_NAME (offset))
223	{
224	alist = access_list_lookup (AFI_IP6, OFFSET_LIST_IN_NAME (offset));
225
226	if (alist
227	&& access_list_apply (alist, (struct prefix *)p) == FILTER_PERMIT)
228	{
229	*metric += OFFSET_LIST_IN_METRIC (offset);
230	return 1;
231	}
232	return 0;
233	}
234	/* Look up offset-list without interface name. */
235	offset = ripng_offset_list_lookup (NULL);
236	if (offset && OFFSET_LIST_IN_NAME (offset))
237	{
238	alist = access_list_lookup (AFI_IP6, OFFSET_LIST_IN_NAME (offset));
239
240	if (alist
241	&& access_list_apply (alist, (struct prefix *)p) == FILTER_PERMIT)
242	{
243	*metric += OFFSET_LIST_IN_METRIC (offset);
244	return 1;
245	}
246	return 0;
247	}
248	return 0;
249	}
250
251	/* If metric is modifed return 1. */
252	int
253	ripng_offset_list_apply_out (struct prefix_ipv6 p, struct interface ifp,
254	u_char *metric)
255	{
256	struct ripng_offset_list *offset;
257	struct access_list *alist;
258
259	/* Look up offset-list with interface name. */
260	offset = ripng_offset_list_lookup (ifp->name);
261	if (offset && OFFSET_LIST_OUT_NAME (offset))
262	{
263	alist = access_list_lookup (AFI_IP6, OFFSET_LIST_OUT_NAME (offset));
264
265	if (alist
266	&& access_list_apply (alist, (struct prefix *)p) == FILTER_PERMIT)
267	{
268	*metric += OFFSET_LIST_OUT_METRIC (offset);
269	return 1;
270	}
271	return 0;
272	}
273
274	/* Look up offset-list without interface name. */
275	offset = ripng_offset_list_lookup (NULL);
276	if (offset && OFFSET_LIST_OUT_NAME (offset))
277	{
278	alist = access_list_lookup (AFI_IP6, OFFSET_LIST_OUT_NAME (offset));
279
280	if (alist
281	&& access_list_apply (alist, (struct prefix *)p) == FILTER_PERMIT)
282	{
283	*metric += OFFSET_LIST_OUT_METRIC (offset);
284	return 1;
285	}
286	return 0;
287	}
288	return 0;
289	}
290
291	DEFUN (ripng_offset_list,
292	ripng_offset_list_cmd,
6147e2c6	293	"offset-list WORD <in\|out> (0-16)",
a94434b6	294	"Modify RIPng metric\n"
	295	"Access-list name\n"
	296	"For incoming updates\n"
	297	"For outgoing updates\n"
	298	"Metric value\n")
	299	{
ab34a28a DW	300	int idx_word = 1;
	301	int idx_in_out = 2;
	302	int idx_number = 3;
	303	return ripng_offset_list_set (vty, argv[idx_word]->arg, argv[idx_in_out]->arg, argv[idx_number]->arg, NULL);
a94434b6	304	}
	305
	306	DEFUN (ripng_offset_list_ifname,
	307	ripng_offset_list_ifname_cmd,
6147e2c6	308	"offset-list WORD <in\|out> (0-16) IFNAME",
a94434b6	309	"Modify RIPng metric\n"
	310	"Access-list name\n"
	311	"For incoming updates\n"
	312	"For outgoing updates\n"
	313	"Metric value\n"
	314	"Interface to match\n")
	315	{
ab34a28a DW	316	int idx_word = 1;
	317	int idx_in_out = 2;
	318	int idx_number = 3;
	319	int idx_ifname = 4;
	320	return ripng_offset_list_set (vty, argv[idx_word]->arg, argv[idx_in_out]->arg, argv[idx_number]->arg, argv[idx_ifname]->arg);
a94434b6	321	}
	322
	323	DEFUN (no_ripng_offset_list,
	324	no_ripng_offset_list_cmd,
6147e2c6	325	"no offset-list WORD <in\|out> (0-16)",
a94434b6	326	NO_STR
	327	"Modify RIPng metric\n"
	328	"Access-list name\n"
	329	"For incoming updates\n"
	330	"For outgoing updates\n"
	331	"Metric value\n")
	332	{
ab34a28a DW	333	int idx_word = 2;
	334	int idx_in_out = 3;
	335	int idx_number = 4;
	336	return ripng_offset_list_unset (vty, argv[idx_word]->arg, argv[idx_in_out]->arg, argv[idx_number]->arg, NULL);
a94434b6	337	}
	338
	339	DEFUN (no_ripng_offset_list_ifname,
	340	no_ripng_offset_list_ifname_cmd,
6147e2c6	341	"no offset-list WORD <in\|out> (0-16) IFNAME",
a94434b6	342	NO_STR
	343	"Modify RIPng metric\n"
	344	"Access-list name\n"
	345	"For incoming updates\n"
	346	"For outgoing updates\n"
	347	"Metric value\n"
	348	"Interface to match\n")
	349	{
ab34a28a DW	350	int idx_word = 2;
	351	int idx_in_out = 3;
	352	int idx_number = 4;
	353	int idx_ifname = 5;
	354	return ripng_offset_list_unset (vty, argv[idx_word]->arg, argv[idx_in_out]->arg, argv[idx_number]->arg, argv[idx_ifname]->arg);
a94434b6	355	}
a94434b6	356
6ac29a51	357	static int
a94434b6	358	offset_list_cmp (struct ripng_offset_list o1, struct ripng_offset_list o2)
	359	{
	360	return strcmp_safe (o1->ifname, o2->ifname);
	361	}
	362
6ac29a51	363	static void
a94434b6	364	offset_list_del (struct ripng_offset_list *offset)
	365	{
	366	if (OFFSET_LIST_IN_NAME (offset))
	367	free (OFFSET_LIST_IN_NAME (offset));
	368	if (OFFSET_LIST_OUT_NAME (offset))
	369	free (OFFSET_LIST_OUT_NAME (offset));
	370	if (offset->ifname)
	371	free (offset->ifname);
	372	ripng_offset_list_free (offset);
	373	}
	374
	375	void
6ac29a51	376	ripng_offset_init (void)
a94434b6	377	{
	378	ripng_offset_list_master = list_new ();
	379	ripng_offset_list_master->cmp = (int ()(void , void *)) offset_list_cmp;
	380	ripng_offset_list_master->del = (void ()(void )) offset_list_del;
	381
	382	install_element (RIPNG_NODE, &ripng_offset_list_cmd);
	383	install_element (RIPNG_NODE, &ripng_offset_list_ifname_cmd);
	384	install_element (RIPNG_NODE, &no_ripng_offset_list_cmd);
	385	install_element (RIPNG_NODE, &no_ripng_offset_list_ifname_cmd);
	386	}
	387
	388	void
6ac29a51	389	ripng_offset_clean (void)
a94434b6	390	{
	391	list_delete (ripng_offset_list_master);
	392
	393	ripng_offset_list_master = list_new ();
	394	ripng_offset_list_master->cmp = (int ()(void , void *)) offset_list_cmp;
	395	ripng_offset_list_master->del = (void ()(void )) offset_list_del;
	396	}
	397
	398	int
	399	config_write_ripng_offset_list (struct vty *vty)
	400	{
1eb8ef25	401	struct listnode node, nnode;
a94434b6	402	struct ripng_offset_list *offset;
a94434b6	403
1eb8ef25	404	for (ALL_LIST_ELEMENTS (ripng_offset_list_master, node, nnode, offset))
a94434b6	405	{
	406	if (! offset->ifname)
	407	{
	408	if (offset->direct[RIPNG_OFFSET_LIST_IN].alist_name)
	409	vty_out (vty, " offset-list %s in %d%s",
	410	offset->direct[RIPNG_OFFSET_LIST_IN].alist_name,
	411	offset->direct[RIPNG_OFFSET_LIST_IN].metric,
	412	VTY_NEWLINE);
	413	if (offset->direct[RIPNG_OFFSET_LIST_OUT].alist_name)
	414	vty_out (vty, " offset-list %s out %d%s",
	415	offset->direct[RIPNG_OFFSET_LIST_OUT].alist_name,
	416	offset->direct[RIPNG_OFFSET_LIST_OUT].metric,
	417	VTY_NEWLINE);
	418	}
	419	else
	420	{
	421	if (offset->direct[RIPNG_OFFSET_LIST_IN].alist_name)
	422	vty_out (vty, " offset-list %s in %d %s%s",
	423	offset->direct[RIPNG_OFFSET_LIST_IN].alist_name,
	424	offset->direct[RIPNG_OFFSET_LIST_IN].metric,
	425	offset->ifname, VTY_NEWLINE);
	426	if (offset->direct[RIPNG_OFFSET_LIST_OUT].alist_name)
	427	vty_out (vty, " offset-list %s out %d %s%s",
	428	offset->direct[RIPNG_OFFSET_LIST_OUT].alist_name,
	429	offset->direct[RIPNG_OFFSET_LIST_OUT].metric,
	430	offset->ifname, VTY_NEWLINE);
	431	}
	432	}
	433
	434	return 0;
	435	}