[mirror_frr.git] / ripd / rip_routemap.c

// SPDX-License-Identifier: GPL-2.0-or-later
/* RIPv2 routemap.
 * Copyright (C) 2005 6WIND <alain.ritoux@6wind.com>
 * Copyright (C) 1999 Kunihiro Ishiguro <kunihiro@zebra.org>
 */

#include <zebra.h>

#include "memory.h"
#include "prefix.h"
#include "vty.h"
#include "routemap.h"
#include "command.h"
#include "filter.h"
#include "log.h"
#include "sockunion.h" /* for inet_aton () */
#include "plist.h"
#include "vrf.h"

#include "ripd/ripd.h"

struct rip_metric_modifier {
	enum { metric_increment, metric_decrement, metric_absolute } type;
	bool used;
	uint8_t metric;
};

/* `match metric METRIC' */
/* Match function return 1 if match is success else return zero. */
static enum route_map_cmd_result_t
route_match_metric(void *rule, const struct prefix *prefix, void *object)
{
	uint32_t *metric;
	uint32_t check;
	struct rip_info *rinfo;

	metric = rule;
	rinfo = object;

	/* If external metric is available, the route-map should
	   work on this one (for redistribute purpose)  */
	check = (rinfo->external_metric) ? rinfo->external_metric
					 : rinfo->metric;
	if (check == *metric)
		return RMAP_MATCH;
	else
		return RMAP_NOMATCH;
}

/* Route map `match metric' match statement. `arg' is METRIC value */
static void *route_match_metric_compile(const char *arg)
{
	uint32_t *metric;

	metric = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
	*metric = atoi(arg);

	if (*metric > 0)
		return metric;

	XFREE(MTYPE_ROUTE_MAP_COMPILED, metric);
	return NULL;
}

/* Free route map's compiled `match metric' value. */
static void route_match_metric_free(void *rule)
{
	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
}

/* Route map commands for metric matching. */
static const struct route_map_rule_cmd route_match_metric_cmd = {
	"metric",
	route_match_metric,
	route_match_metric_compile,
	route_match_metric_free
};

/* `match interface IFNAME' */
/* Match function return 1 if match is success else return zero. */
static enum route_map_cmd_result_t
route_match_interface(void *rule, const struct prefix *prefix, void *object)
{
	struct rip_info *rinfo;
	struct interface *ifp;
	char *ifname;

	ifname = rule;
	ifp = if_lookup_by_name(ifname, VRF_DEFAULT);

	if (!ifp)
		return RMAP_NOMATCH;

	rinfo = object;

	if (rinfo->ifindex_out == ifp->ifindex
	    || rinfo->nh.ifindex == ifp->ifindex)
		return RMAP_MATCH;
	else
		return RMAP_NOMATCH;
}

/* Route map `match interface' match statement. `arg' is IFNAME value */
/* XXX I don`t know if I need to check does interface exist? */
static void *route_match_interface_compile(const char *arg)
{
	return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
}

/* Free route map's compiled `match interface' value. */
static void route_match_interface_free(void *rule)
{
	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
}

/* Route map commands for interface matching. */
static const struct route_map_rule_cmd route_match_interface_cmd = {
	"interface",
	route_match_interface,
	route_match_interface_compile,
	route_match_interface_free
};

/* `match ip next-hop IP_ACCESS_LIST' */

/* Match function return 1 if match is success else return zero. */
static enum route_map_cmd_result_t
route_match_ip_next_hop(void *rule, const struct prefix *prefix, void *object)
{
	struct access_list *alist;
	struct rip_info *rinfo;
	struct prefix_ipv4 p;

	rinfo = object;
	p.family = AF_INET;
	p.prefix = (rinfo->nh.gate.ipv4.s_addr != INADDR_ANY)
			   ? rinfo->nh.gate.ipv4
			   : rinfo->from;
	p.prefixlen = IPV4_MAX_BITLEN;

	alist = access_list_lookup(AFI_IP, (char *)rule);
	if (alist == NULL)
		return RMAP_NOMATCH;

	return (access_list_apply(alist, &p) == FILTER_DENY ? RMAP_NOMATCH
							    : RMAP_MATCH);
}

/* Route map `ip next-hop' match statement.  `arg' should be
   access-list name. */
static void *route_match_ip_next_hop_compile(const char *arg)
{
	return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
}

/* Free route map's compiled `. */
static void route_match_ip_next_hop_free(void *rule)
{
	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
}

/* Route map commands for ip next-hop matching. */
static const struct route_map_rule_cmd route_match_ip_next_hop_cmd = {
	"ip next-hop",
	route_match_ip_next_hop,
	route_match_ip_next_hop_compile,
	route_match_ip_next_hop_free
};

/* `match ip next-hop prefix-list PREFIX_LIST' */

static enum route_map_cmd_result_t
route_match_ip_next_hop_prefix_list(void *rule, const struct prefix *prefix,
				    void *object)
{
	struct prefix_list *plist;
	struct rip_info *rinfo;
	struct prefix_ipv4 p;

	rinfo = object;
	p.family = AF_INET;
	p.prefix = (rinfo->nh.gate.ipv4.s_addr != INADDR_ANY)
			   ? rinfo->nh.gate.ipv4
			   : rinfo->from;
	p.prefixlen = IPV4_MAX_BITLEN;

	plist = prefix_list_lookup(AFI_IP, (char *)rule);
	if (plist == NULL)
		return RMAP_NOMATCH;

	return (prefix_list_apply(plist, &p) == PREFIX_DENY ? RMAP_NOMATCH
							    : RMAP_MATCH);
}

static void *route_match_ip_next_hop_prefix_list_compile(const char *arg)
{
	return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
}

static void route_match_ip_next_hop_prefix_list_free(void *rule)
{
	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
}

static const struct route_map_rule_cmd
		route_match_ip_next_hop_prefix_list_cmd = {
	"ip next-hop prefix-list",
	route_match_ip_next_hop_prefix_list,
	route_match_ip_next_hop_prefix_list_compile,
	route_match_ip_next_hop_prefix_list_free
};

/* `match ip next-hop type <blackhole>' */

static enum route_map_cmd_result_t
route_match_ip_next_hop_type(void *rule, const struct prefix *prefix,
			     void *object)
{
	struct rip_info *rinfo;

	if (prefix->family == AF_INET) {
		rinfo = (struct rip_info *)object;
		if (!rinfo)
			return RMAP_NOMATCH;

		if (rinfo->nh.type == NEXTHOP_TYPE_BLACKHOLE)
			return RMAP_MATCH;
	}
	return RMAP_NOMATCH;
}

static void *route_match_ip_next_hop_type_compile(const char *arg)
{
	return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
}

static void route_match_ip_next_hop_type_free(void *rule)
{
	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
}

static const struct route_map_rule_cmd
		route_match_ip_next_hop_type_cmd = {
	"ip next-hop type",
	route_match_ip_next_hop_type,
	route_match_ip_next_hop_type_compile,
	route_match_ip_next_hop_type_free
};

/* `match ip address IP_ACCESS_LIST' */

/* Match function should return 1 if match is success else return
   zero. */
static enum route_map_cmd_result_t
route_match_ip_address(void *rule, const struct prefix *prefix, void *object)
{
	struct access_list *alist;

	alist = access_list_lookup(AFI_IP, (char *)rule);
	if (alist == NULL)
		return RMAP_NOMATCH;

	return (access_list_apply(alist, prefix) == FILTER_DENY ? RMAP_NOMATCH
								: RMAP_MATCH);
}

/* Route map `ip address' match statement.  `arg' should be
   access-list name. */
static void *route_match_ip_address_compile(const char *arg)
{
	return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
}

/* Free route map's compiled `ip address' value. */
static void route_match_ip_address_free(void *rule)
{
	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
}

/* Route map commands for ip address matching. */
static const struct route_map_rule_cmd route_match_ip_address_cmd = {
	"ip address",
	route_match_ip_address,
	route_match_ip_address_compile,
	route_match_ip_address_free
};

/* `match ip address prefix-list PREFIX_LIST' */

static enum route_map_cmd_result_t
route_match_ip_address_prefix_list(void *rule, const struct prefix *prefix,
				   void *object)
{
	struct prefix_list *plist;

	plist = prefix_list_lookup(AFI_IP, (char *)rule);
	if (plist == NULL)
		return RMAP_NOMATCH;

	return (prefix_list_apply(plist, prefix) == PREFIX_DENY ? RMAP_NOMATCH
								: RMAP_MATCH);
}

static void *route_match_ip_address_prefix_list_compile(const char *arg)
{
	return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
}

static void route_match_ip_address_prefix_list_free(void *rule)
{
	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
}

static const struct route_map_rule_cmd
		route_match_ip_address_prefix_list_cmd = {
	"ip address prefix-list",
	route_match_ip_address_prefix_list,
	route_match_ip_address_prefix_list_compile,
	route_match_ip_address_prefix_list_free
};

/* `match tag TAG' */
/* Match function return 1 if match is success else return zero. */
static enum route_map_cmd_result_t
route_match_tag(void *rule, const struct prefix *p, void *object)
{
	route_tag_t *tag;
	struct rip_info *rinfo;
	route_tag_t rinfo_tag;

	tag = rule;
	rinfo = object;

	/* The information stored by rinfo is host ordered. */
	rinfo_tag = rinfo->tag;
	if (rinfo_tag == *tag)
		return RMAP_MATCH;
	else
		return RMAP_NOMATCH;
}

/* Route map commands for tag matching. */
static const struct route_map_rule_cmd route_match_tag_cmd = {
	"tag",
	route_match_tag,
	route_map_rule_tag_compile,
	route_map_rule_tag_free,
};

/* `set metric METRIC' */

/* Set metric to attribute. */
static enum route_map_cmd_result_t
route_set_metric(void *rule, const struct prefix *prefix, void *object)
{
	struct rip_metric_modifier *mod;
	struct rip_info *rinfo;

	mod = rule;
	rinfo = object;

	if (!mod->used)
		return RMAP_OKAY;

	if (mod->type == metric_increment)
		rinfo->metric_out += mod->metric;
	else if (mod->type == metric_decrement)
		rinfo->metric_out -= mod->metric;
	else if (mod->type == metric_absolute)
		rinfo->metric_out = mod->metric;

	if ((signed int)rinfo->metric_out < 1)
		rinfo->metric_out = 1;
	if (rinfo->metric_out > RIP_METRIC_INFINITY)
		rinfo->metric_out = RIP_METRIC_INFINITY;

	rinfo->metric_set = 1;
	return RMAP_OKAY;
}

/* set metric compilation. */
static void *route_set_metric_compile(const char *arg)
{
	int len;
	const char *pnt;
	long metric;
	char *endptr = NULL;
	struct rip_metric_modifier *mod;

	mod = XMALLOC(MTYPE_ROUTE_MAP_COMPILED,
		      sizeof(struct rip_metric_modifier));
	mod->used = false;

	len = strlen(arg);
	pnt = arg;

	if (len == 0)
		return mod;

	/* Examine first character. */
	if (arg[0] == '+') {
		mod->type = metric_increment;
		pnt++;
	} else if (arg[0] == '-') {
		mod->type = metric_decrement;
		pnt++;
	} else
		mod->type = metric_absolute;

	/* Check beginning with digit string. */
	if (*pnt < '0' || *pnt > '9')
		return mod;

	/* Convert string to integer. */
	metric = strtol(pnt, &endptr, 10);

	if (*endptr != '\0' || metric < 0) {
		return mod;
	}
	if (metric > RIP_METRIC_INFINITY) {
		zlog_info(
			"%s: Metric specified: %ld is greater than RIP_METRIC_INFINITY, using INFINITY instead",
			__func__, metric);
		mod->metric = RIP_METRIC_INFINITY;
	} else
		mod->metric = metric;

	mod->used = true;

	return mod;
}

/* Free route map's compiled `set metric' value. */
static void route_set_metric_free(void *rule)
{
	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
}

/* Set metric rule structure. */
static const struct route_map_rule_cmd route_set_metric_cmd = {
	"metric",
	route_set_metric,
	route_set_metric_compile,
	route_set_metric_free,
};

/* `set ip next-hop IP_ADDRESS' */

/* Set nexthop to object.  object must be pointer to struct attr. */
static enum route_map_cmd_result_t
route_set_ip_nexthop(void *rule, const struct prefix *prefix,

		     void *object)
{
	struct in_addr *address;
	struct rip_info *rinfo;

	/* Fetch routemap's rule information. */
	address = rule;
	rinfo = object;

	/* Set next hop value. */
	rinfo->nexthop_out = *address;

	return RMAP_OKAY;
}

/* Route map `ip nexthop' compile function.  Given string is converted
   to struct in_addr structure. */
static void *route_set_ip_nexthop_compile(const char *arg)
{
	int ret;
	struct in_addr *address;

	address = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct in_addr));

	ret = inet_aton(arg, address);

	if (ret == 0) {
		XFREE(MTYPE_ROUTE_MAP_COMPILED, address);
		return NULL;
	}

	return address;
}

/* Free route map's compiled `ip nexthop' value. */
static void route_set_ip_nexthop_free(void *rule)
{
	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
}

/* Route map commands for ip nexthop set. */
static const struct route_map_rule_cmd route_set_ip_nexthop_cmd = {
	"ip next-hop",
	route_set_ip_nexthop,
	route_set_ip_nexthop_compile,
	route_set_ip_nexthop_free
};

/* `set tag TAG' */

/* Set tag to object.  object must be pointer to struct attr. */
static enum route_map_cmd_result_t
route_set_tag(void *rule, const struct prefix *prefix, void *object)
{
	route_tag_t *tag;
	struct rip_info *rinfo;

	/* Fetch routemap's rule information. */
	tag = rule;
	rinfo = object;

	/* Set next hop value. */
	rinfo->tag_out = *tag;

	return RMAP_OKAY;
}

/* Route map commands for tag set. */
static const struct route_map_rule_cmd route_set_tag_cmd = {
	"tag",
	route_set_tag,
	route_map_rule_tag_compile,
	route_map_rule_tag_free
};

#define MATCH_STR "Match values from routing table\n"
#define SET_STR "Set values in destination routing protocol\n"

/* Route-map init */
void rip_route_map_init(void)
{
	route_map_init();

	route_map_match_interface_hook(generic_match_add);
	route_map_no_match_interface_hook(generic_match_delete);

	route_map_match_ip_address_hook(generic_match_add);
	route_map_no_match_ip_address_hook(generic_match_delete);

	route_map_match_ip_address_prefix_list_hook(generic_match_add);
	route_map_no_match_ip_address_prefix_list_hook(generic_match_delete);

	route_map_match_ip_next_hop_hook(generic_match_add);
	route_map_no_match_ip_next_hop_hook(generic_match_delete);

	route_map_match_ip_next_hop_prefix_list_hook(generic_match_add);
	route_map_no_match_ip_next_hop_prefix_list_hook(generic_match_delete);

	route_map_match_ip_next_hop_type_hook(generic_match_add);
	route_map_no_match_ip_next_hop_type_hook(generic_match_delete);

	route_map_match_metric_hook(generic_match_add);
	route_map_no_match_metric_hook(generic_match_delete);

	route_map_match_tag_hook(generic_match_add);
	route_map_no_match_tag_hook(generic_match_delete);

	route_map_set_ip_nexthop_hook(generic_set_add);
	route_map_no_set_ip_nexthop_hook(generic_set_delete);

	route_map_set_metric_hook(generic_set_add);
	route_map_no_set_metric_hook(generic_set_delete);

	route_map_set_tag_hook(generic_set_add);
	route_map_no_set_tag_hook(generic_set_delete);

	route_map_install_match(&route_match_metric_cmd);
	route_map_install_match(&route_match_interface_cmd);
	route_map_install_match(&route_match_ip_next_hop_cmd);
	route_map_install_match(&route_match_ip_next_hop_prefix_list_cmd);
	route_map_install_match(&route_match_ip_next_hop_type_cmd);
	route_map_install_match(&route_match_ip_address_cmd);
	route_map_install_match(&route_match_ip_address_prefix_list_cmd);
	route_map_install_match(&route_match_tag_cmd);

	route_map_install_set(&route_set_metric_cmd);
	route_map_install_set(&route_set_ip_nexthop_cmd);
	route_map_install_set(&route_set_tag_cmd);
}
Commit	Line	Data
	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/* RIPv2 routemap.
	3	* Copyright (C) 2005 6WIND <alain.ritoux@6wind.com>
	4	* Copyright (C) 1999 Kunihiro Ishiguro <kunihiro@zebra.org>
	5	*/
	6
	7	#include <zebra.h>
	8
	9	#include "memory.h"
	10	#include "prefix.h"
	11	#include "vty.h"
	12	#include "routemap.h"
	13	#include "command.h"
	14	#include "filter.h"
	15	#include "log.h"
	16	#include "sockunion.h" /* for inet_aton () */
	17	#include "plist.h"
	18	#include "vrf.h"
	19
	20	#include "ripd/ripd.h"
	21
	22	struct rip_metric_modifier {
	23	enum { metric_increment, metric_decrement, metric_absolute } type;
	24	bool used;
	25	uint8_t metric;
	26	};
	27
	28	/* `match metric METRIC' */
	29	/* Match function return 1 if match is success else return zero. */
	30	static enum route_map_cmd_result_t
	31	route_match_metric(void rule, const struct prefix prefix, void *object)
	32	{
	33	uint32_t *metric;
	34	uint32_t check;
	35	struct rip_info *rinfo;
	36
	37	metric = rule;
	38	rinfo = object;
	39
	40	/* If external metric is available, the route-map should
	41	work on this one (for redistribute purpose) */
	42	check = (rinfo->external_metric) ? rinfo->external_metric
	43	: rinfo->metric;
	44	if (check == *metric)
	45	return RMAP_MATCH;
	46	else
	47	return RMAP_NOMATCH;
	48	}
	49
	50	/* Route map `match metric' match statement. `arg' is METRIC value */
	51	static void route_match_metric_compile(const char arg)
	52	{
	53	uint32_t *metric;
	54
	55	metric = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
	56	*metric = atoi(arg);
	57
	58	if (*metric > 0)
	59	return metric;
	60
	61	XFREE(MTYPE_ROUTE_MAP_COMPILED, metric);
	62	return NULL;
	63	}
	64
	65	/* Free route map's compiled `match metric' value. */
	66	static void route_match_metric_free(void *rule)
	67	{
	68	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
	69	}
	70
	71	/* Route map commands for metric matching. */
	72	static const struct route_map_rule_cmd route_match_metric_cmd = {
	73	"metric",
	74	route_match_metric,
	75	route_match_metric_compile,
	76	route_match_metric_free
	77	};
	78
	79	/* `match interface IFNAME' */
	80	/* Match function return 1 if match is success else return zero. */
	81	static enum route_map_cmd_result_t
	82	route_match_interface(void rule, const struct prefix prefix, void *object)
	83	{
	84	struct rip_info *rinfo;
	85	struct interface *ifp;
	86	char *ifname;
	87
	88	ifname = rule;
	89	ifp = if_lookup_by_name(ifname, VRF_DEFAULT);
	90
	91	if (!ifp)
	92	return RMAP_NOMATCH;
	93
	94	rinfo = object;
	95
	96	if (rinfo->ifindex_out == ifp->ifindex
	97	\|\| rinfo->nh.ifindex == ifp->ifindex)
	98	return RMAP_MATCH;
	99	else
	100	return RMAP_NOMATCH;
	101	}
	102
	103	/* Route map `match interface' match statement. `arg' is IFNAME value */
	104	/* XXX I don`t know if I need to check does interface exist? */
	105	static void route_match_interface_compile(const char arg)
	106	{
	107	return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
	108	}
	109
	110	/* Free route map's compiled `match interface' value. */
	111	static void route_match_interface_free(void *rule)
	112	{
	113	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
	114	}
	115
	116	/* Route map commands for interface matching. */
	117	static const struct route_map_rule_cmd route_match_interface_cmd = {
	118	"interface",
	119	route_match_interface,
	120	route_match_interface_compile,
	121	route_match_interface_free
	122	};
	123
	124	/* `match ip next-hop IP_ACCESS_LIST' */
	125
	126	/* Match function return 1 if match is success else return zero. */
	127	static enum route_map_cmd_result_t
	128	route_match_ip_next_hop(void rule, const struct prefix prefix, void *object)
	129	{
	130	struct access_list *alist;
	131	struct rip_info *rinfo;
	132	struct prefix_ipv4 p;
	133
	134	rinfo = object;
	135	p.family = AF_INET;
	136	p.prefix = (rinfo->nh.gate.ipv4.s_addr != INADDR_ANY)
	137	? rinfo->nh.gate.ipv4
	138	: rinfo->from;
	139	p.prefixlen = IPV4_MAX_BITLEN;
	140
	141	alist = access_list_lookup(AFI_IP, (char *)rule);
	142	if (alist == NULL)
	143	return RMAP_NOMATCH;
	144
	145	return (access_list_apply(alist, &p) == FILTER_DENY ? RMAP_NOMATCH
	146	: RMAP_MATCH);
	147	}
	148
	149	/* Route map `ip next-hop' match statement. `arg' should be
	150	access-list name. */
	151	static void route_match_ip_next_hop_compile(const char arg)
	152	{
	153	return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
	154	}
	155
	156	/* Free route map's compiled `. */
	157	static void route_match_ip_next_hop_free(void *rule)
	158	{
	159	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
	160	}
	161
	162	/* Route map commands for ip next-hop matching. */
	163	static const struct route_map_rule_cmd route_match_ip_next_hop_cmd = {
	164	"ip next-hop",
	165	route_match_ip_next_hop,
	166	route_match_ip_next_hop_compile,
	167	route_match_ip_next_hop_free
	168	};
	169
	170	/* `match ip next-hop prefix-list PREFIX_LIST' */
	171
	172	static enum route_map_cmd_result_t
	173	route_match_ip_next_hop_prefix_list(void rule, const struct prefix prefix,
	174	void *object)
	175	{
	176	struct prefix_list *plist;
	177	struct rip_info *rinfo;
	178	struct prefix_ipv4 p;
	179
	180	rinfo = object;
	181	p.family = AF_INET;
	182	p.prefix = (rinfo->nh.gate.ipv4.s_addr != INADDR_ANY)
	183	? rinfo->nh.gate.ipv4
	184	: rinfo->from;
	185	p.prefixlen = IPV4_MAX_BITLEN;
	186
	187	plist = prefix_list_lookup(AFI_IP, (char *)rule);
	188	if (plist == NULL)
	189	return RMAP_NOMATCH;
	190
	191	return (prefix_list_apply(plist, &p) == PREFIX_DENY ? RMAP_NOMATCH
	192	: RMAP_MATCH);
	193	}
	194
	195	static void route_match_ip_next_hop_prefix_list_compile(const char arg)
	196	{
	197	return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
	198	}
	199
	200	static void route_match_ip_next_hop_prefix_list_free(void *rule)
	201	{
	202	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
	203	}
	204
	205	static const struct route_map_rule_cmd
	206	route_match_ip_next_hop_prefix_list_cmd = {
	207	"ip next-hop prefix-list",
	208	route_match_ip_next_hop_prefix_list,
	209	route_match_ip_next_hop_prefix_list_compile,
	210	route_match_ip_next_hop_prefix_list_free
	211	};
	212
	213	/* `match ip next-hop type <blackhole>' */
	214
	215	static enum route_map_cmd_result_t
	216	route_match_ip_next_hop_type(void rule, const struct prefix prefix,
	217	void *object)
	218	{
	219	struct rip_info *rinfo;
	220
	221	if (prefix->family == AF_INET) {
	222	rinfo = (struct rip_info *)object;
	223	if (!rinfo)
	224	return RMAP_NOMATCH;
	225
	226	if (rinfo->nh.type == NEXTHOP_TYPE_BLACKHOLE)
	227	return RMAP_MATCH;
	228	}
	229	return RMAP_NOMATCH;
	230	}
	231
	232	static void route_match_ip_next_hop_type_compile(const char arg)
	233	{
	234	return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
	235	}
	236
	237	static void route_match_ip_next_hop_type_free(void *rule)
	238	{
	239	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
	240	}
	241
	242	static const struct route_map_rule_cmd
	243	route_match_ip_next_hop_type_cmd = {
	244	"ip next-hop type",
	245	route_match_ip_next_hop_type,
	246	route_match_ip_next_hop_type_compile,
	247	route_match_ip_next_hop_type_free
	248	};
	249
	250	/* `match ip address IP_ACCESS_LIST' */
	251
	252	/* Match function should return 1 if match is success else return
	253	zero. */
	254	static enum route_map_cmd_result_t
	255	route_match_ip_address(void rule, const struct prefix prefix, void *object)
	256	{
	257	struct access_list *alist;
	258
	259	alist = access_list_lookup(AFI_IP, (char *)rule);
	260	if (alist == NULL)
	261	return RMAP_NOMATCH;
	262
	263	return (access_list_apply(alist, prefix) == FILTER_DENY ? RMAP_NOMATCH
	264	: RMAP_MATCH);
	265	}
	266
	267	/* Route map `ip address' match statement. `arg' should be
	268	access-list name. */
	269	static void route_match_ip_address_compile(const char arg)
	270	{
	271	return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
	272	}
	273
	274	/* Free route map's compiled `ip address' value. */
	275	static void route_match_ip_address_free(void *rule)
	276	{
	277	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
	278	}
	279
	280	/* Route map commands for ip address matching. */
	281	static const struct route_map_rule_cmd route_match_ip_address_cmd = {
	282	"ip address",
	283	route_match_ip_address,
	284	route_match_ip_address_compile,
	285	route_match_ip_address_free
	286	};
	287
	288	/* `match ip address prefix-list PREFIX_LIST' */
	289
	290	static enum route_map_cmd_result_t
	291	route_match_ip_address_prefix_list(void rule, const struct prefix prefix,
	292	void *object)
	293	{
	294	struct prefix_list *plist;
	295
	296	plist = prefix_list_lookup(AFI_IP, (char *)rule);
	297	if (plist == NULL)
	298	return RMAP_NOMATCH;
	299
	300	return (prefix_list_apply(plist, prefix) == PREFIX_DENY ? RMAP_NOMATCH
	301	: RMAP_MATCH);
	302	}
	303
	304	static void route_match_ip_address_prefix_list_compile(const char arg)
	305	{
	306	return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
	307	}
	308
	309	static void route_match_ip_address_prefix_list_free(void *rule)
	310	{
	311	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
	312	}
	313
	314	static const struct route_map_rule_cmd
	315	route_match_ip_address_prefix_list_cmd = {
	316	"ip address prefix-list",
	317	route_match_ip_address_prefix_list,
	318	route_match_ip_address_prefix_list_compile,
	319	route_match_ip_address_prefix_list_free
	320	};
	321
	322	/* `match tag TAG' */
	323	/* Match function return 1 if match is success else return zero. */
	324	static enum route_map_cmd_result_t
	325	route_match_tag(void rule, const struct prefix p, void *object)
	326	{
	327	route_tag_t *tag;
	328	struct rip_info *rinfo;
	329	route_tag_t rinfo_tag;
	330
	331	tag = rule;
	332	rinfo = object;
	333
	334	/* The information stored by rinfo is host ordered. */
	335	rinfo_tag = rinfo->tag;
	336	if (rinfo_tag == *tag)
	337	return RMAP_MATCH;
	338	else
	339	return RMAP_NOMATCH;
	340	}
	341
	342	/* Route map commands for tag matching. */
	343	static const struct route_map_rule_cmd route_match_tag_cmd = {
	344	"tag",
	345	route_match_tag,
	346	route_map_rule_tag_compile,
	347	route_map_rule_tag_free,
	348	};
	349
	350	/* `set metric METRIC' */
	351
	352	/* Set metric to attribute. */
	353	static enum route_map_cmd_result_t
	354	route_set_metric(void rule, const struct prefix prefix, void *object)
	355	{
	356	struct rip_metric_modifier *mod;
	357	struct rip_info *rinfo;
	358
	359	mod = rule;
	360	rinfo = object;
	361
	362	if (!mod->used)
	363	return RMAP_OKAY;
	364
	365	if (mod->type == metric_increment)
	366	rinfo->metric_out += mod->metric;
	367	else if (mod->type == metric_decrement)
	368	rinfo->metric_out -= mod->metric;
	369	else if (mod->type == metric_absolute)
	370	rinfo->metric_out = mod->metric;
	371
	372	if ((signed int)rinfo->metric_out < 1)
	373	rinfo->metric_out = 1;
	374	if (rinfo->metric_out > RIP_METRIC_INFINITY)
	375	rinfo->metric_out = RIP_METRIC_INFINITY;
	376
	377	rinfo->metric_set = 1;
	378	return RMAP_OKAY;
	379	}
	380
	381	/* set metric compilation. */
	382	static void route_set_metric_compile(const char arg)
	383	{
	384	int len;
	385	const char *pnt;
	386	long metric;
	387	char *endptr = NULL;
	388	struct rip_metric_modifier *mod;
	389
	390	mod = XMALLOC(MTYPE_ROUTE_MAP_COMPILED,
	391	sizeof(struct rip_metric_modifier));
	392	mod->used = false;
	393
	394	len = strlen(arg);
	395	pnt = arg;
	396
	397	if (len == 0)
	398	return mod;
	399
	400	/* Examine first character. */
	401	if (arg[0] == '+') {
	402	mod->type = metric_increment;
	403	pnt++;
	404	} else if (arg[0] == '-') {
	405	mod->type = metric_decrement;
	406	pnt++;
	407	} else
	408	mod->type = metric_absolute;
	409
	410	/* Check beginning with digit string. */
	411	if (pnt < '0' \|\| pnt > '9')
	412	return mod;
	413
	414	/* Convert string to integer. */
	415	metric = strtol(pnt, &endptr, 10);
	416
	417	if (*endptr != '\0' \|\| metric < 0) {
	418	return mod;
	419	}
	420	if (metric > RIP_METRIC_INFINITY) {
	421	zlog_info(
	422	"%s: Metric specified: %ld is greater than RIP_METRIC_INFINITY, using INFINITY instead",
	423	__func__, metric);
	424	mod->metric = RIP_METRIC_INFINITY;
	425	} else
	426	mod->metric = metric;
	427
	428	mod->used = true;
	429
	430	return mod;
	431	}
	432
	433	/* Free route map's compiled `set metric' value. */
	434	static void route_set_metric_free(void *rule)
	435	{
	436	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
	437	}
	438
	439	/* Set metric rule structure. */
	440	static const struct route_map_rule_cmd route_set_metric_cmd = {
	441	"metric",
	442	route_set_metric,
	443	route_set_metric_compile,
	444	route_set_metric_free,
	445	};
	446
	447	/* `set ip next-hop IP_ADDRESS' */
	448
	449	/* Set nexthop to object. object must be pointer to struct attr. */
	450	static enum route_map_cmd_result_t
	451	route_set_ip_nexthop(void rule, const struct prefix prefix,
	452
	453	void *object)
	454	{
	455	struct in_addr *address;
	456	struct rip_info *rinfo;
	457
	458	/* Fetch routemap's rule information. */
	459	address = rule;
	460	rinfo = object;
	461
	462	/* Set next hop value. */
	463	rinfo->nexthop_out = *address;
	464
	465	return RMAP_OKAY;
	466	}
	467
	468	/* Route map `ip nexthop' compile function. Given string is converted
	469	to struct in_addr structure. */
	470	static void route_set_ip_nexthop_compile(const char arg)
	471	{
	472	int ret;
	473	struct in_addr *address;
	474
	475	address = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct in_addr));
	476
	477	ret = inet_aton(arg, address);
	478
	479	if (ret == 0) {
	480	XFREE(MTYPE_ROUTE_MAP_COMPILED, address);
	481	return NULL;
	482	}
	483
	484	return address;
	485	}
	486
	487	/* Free route map's compiled `ip nexthop' value. */
	488	static void route_set_ip_nexthop_free(void *rule)
	489	{
	490	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
	491	}
	492
	493	/* Route map commands for ip nexthop set. */
	494	static const struct route_map_rule_cmd route_set_ip_nexthop_cmd = {
	495	"ip next-hop",
	496	route_set_ip_nexthop,
	497	route_set_ip_nexthop_compile,
	498	route_set_ip_nexthop_free
	499	};
	500
	501	/* `set tag TAG' */
	502
	503	/* Set tag to object. object must be pointer to struct attr. */
	504	static enum route_map_cmd_result_t
	505	route_set_tag(void rule, const struct prefix prefix, void *object)
	506	{
	507	route_tag_t *tag;
	508	struct rip_info *rinfo;
	509
	510	/* Fetch routemap's rule information. */
	511	tag = rule;
	512	rinfo = object;
	513
	514	/* Set next hop value. */
	515	rinfo->tag_out = *tag;
	516
	517	return RMAP_OKAY;
	518	}
	519
	520	/* Route map commands for tag set. */
	521	static const struct route_map_rule_cmd route_set_tag_cmd = {
	522	"tag",
	523	route_set_tag,
	524	route_map_rule_tag_compile,
	525	route_map_rule_tag_free
	526	};
	527
	528	#define MATCH_STR "Match values from routing table\n"
	529	#define SET_STR "Set values in destination routing protocol\n"
	530
	531	/* Route-map init */
	532	void rip_route_map_init(void)
	533	{
	534	route_map_init();
	535
	536	route_map_match_interface_hook(generic_match_add);
	537	route_map_no_match_interface_hook(generic_match_delete);
	538
	539	route_map_match_ip_address_hook(generic_match_add);
	540	route_map_no_match_ip_address_hook(generic_match_delete);
	541
	542	route_map_match_ip_address_prefix_list_hook(generic_match_add);
	543	route_map_no_match_ip_address_prefix_list_hook(generic_match_delete);
	544
	545	route_map_match_ip_next_hop_hook(generic_match_add);
	546	route_map_no_match_ip_next_hop_hook(generic_match_delete);
	547
	548	route_map_match_ip_next_hop_prefix_list_hook(generic_match_add);
	549	route_map_no_match_ip_next_hop_prefix_list_hook(generic_match_delete);
	550
	551	route_map_match_ip_next_hop_type_hook(generic_match_add);
	552	route_map_no_match_ip_next_hop_type_hook(generic_match_delete);
	553
	554	route_map_match_metric_hook(generic_match_add);
	555	route_map_no_match_metric_hook(generic_match_delete);
	556
	557	route_map_match_tag_hook(generic_match_add);
	558	route_map_no_match_tag_hook(generic_match_delete);
	559
	560	route_map_set_ip_nexthop_hook(generic_set_add);
	561	route_map_no_set_ip_nexthop_hook(generic_set_delete);
	562
	563	route_map_set_metric_hook(generic_set_add);
	564	route_map_no_set_metric_hook(generic_set_delete);
	565
	566	route_map_set_tag_hook(generic_set_add);
	567	route_map_no_set_tag_hook(generic_set_delete);
	568
	569	route_map_install_match(&route_match_metric_cmd);
	570	route_map_install_match(&route_match_interface_cmd);
	571	route_map_install_match(&route_match_ip_next_hop_cmd);
	572	route_map_install_match(&route_match_ip_next_hop_prefix_list_cmd);
	573	route_map_install_match(&route_match_ip_next_hop_type_cmd);
	574	route_map_install_match(&route_match_ip_address_cmd);
	575	route_map_install_match(&route_match_ip_address_prefix_list_cmd);
	576	route_map_install_match(&route_match_tag_cmd);
	577
	578	route_map_install_set(&route_set_metric_cmd);
	579	route_map_install_set(&route_set_ip_nexthop_cmd);
	580	route_map_install_set(&route_set_tag_cmd);
	581	}