[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
acddc0ed	1	// SPDX-License-Identifier: GPL-2.0-or-later
718e3744	2	/* RIPv2 routemap.
fbf5d033	3	* Copyright (C) 2005 6WIND <alain.ritoux@6wind.com>
718e3744	4	* Copyright (C) 1999 Kunihiro Ishiguro <kunihiro@zebra.org>
718e3744	5	*/
	6
	7	#include <zebra.h>
	8
	9	#include "memory.h"
	10	#include "prefix.h"
82f97584	11	#include "vty.h"
718e3744	12	#include "routemap.h"
	13	#include "command.h"
	14	#include "filter.h"
	15	#include "log.h"
d62a17ae	16	#include "sockunion.h" /* for inet_aton () */
718e3744	17	#include "plist.h"
1306c09a	18	#include "vrf.h"
718e3744	19
718e3744	20	#include "ripd/ripd.h"
6b0655a2	21
d62a17ae	22	struct rip_metric_modifier {
d62a17ae	23	enum { metric_increment, metric_decrement, metric_absolute } type;
6a74c5f9	24	bool used;
d7c0a89a	25	uint8_t metric;
16705130	26	};
718e3744	27
718e3744	28	/* `match metric METRIC' */
718e3744	29	/* Match function return 1 if match is success else return zero. */
b68885f9	30	static enum route_map_cmd_result_t
1782514f	31	route_match_metric(void rule, const struct prefix prefix, void *object)
d62a17ae	32	{
d7c0a89a QY	33	uint32_t *metric;
d7c0a89a QY	34	uint32_t check;
d62a17ae	35	struct rip_info *rinfo;
d62a17ae	36
1782514f DS	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;
718e3744	48	}
	49
	50	/* Route map `match metric' match statement. `arg' is METRIC value */
d62a17ae	51	static void route_match_metric_compile(const char arg)
718e3744	52	{
d7c0a89a	53	uint32_t *metric;
718e3744	54
d7c0a89a	55	metric = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
d62a17ae	56	*metric = atoi(arg);
718e3744	57
d62a17ae	58	if (*metric > 0)
d62a17ae	59	return metric;
718e3744	60
d62a17ae	61	XFREE(MTYPE_ROUTE_MAP_COMPILED, metric);
d62a17ae	62	return NULL;
718e3744	63	}
	64
	65	/* Free route map's compiled `match metric' value. */
d62a17ae	66	static void route_match_metric_free(void *rule)
718e3744	67	{
d62a17ae	68	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
718e3744	69	}
	70
	71	/* Route map commands for metric matching. */
364deb04 DL	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	};
718e3744	78
	79	/* `match interface IFNAME' */
	80	/* Match function return 1 if match is success else return zero. */
b68885f9	81	static enum route_map_cmd_result_t
1782514f	82	route_match_interface(void rule, const struct prefix prefix, void *object)
718e3744	83	{
d62a17ae	84	struct rip_info *rinfo;
	85	struct interface *ifp;
	86	char *ifname;
718e3744	87
1782514f DS	88	ifname = rule;
1782514f DS	89	ifp = if_lookup_by_name(ifname, VRF_DEFAULT);
718e3744	90
1782514f DS	91	if (!ifp)
1782514f DS	92	return RMAP_NOMATCH;
718e3744	93
1782514f	94	rinfo = object;
718e3744	95
1782514f DS	96	if (rinfo->ifindex_out == ifp->ifindex
	97	\|\| rinfo->nh.ifindex == ifp->ifindex)
	98	return RMAP_MATCH;
	99	else
	100	return RMAP_NOMATCH;
718e3744	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? */
d62a17ae	105	static void route_match_interface_compile(const char arg)
718e3744	106	{
d62a17ae	107	return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
718e3744	108	}
	109
	110	/* Free route map's compiled `match interface' value. */
d62a17ae	111	static void route_match_interface_free(void *rule)
718e3744	112	{
d62a17ae	113	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
718e3744	114	}
	115
	116	/* Route map commands for interface matching. */
364deb04 DL	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	};
718e3744	123
	124	/* `match ip next-hop IP_ACCESS_LIST' */
	125
	126	/* Match function return 1 if match is success else return zero. */
b68885f9	127	static enum route_map_cmd_result_t
1782514f	128	route_match_ip_next_hop(void rule, const struct prefix prefix, void *object)
d62a17ae	129	{
	130	struct access_list *alist;
	131	struct rip_info *rinfo;
	132	struct prefix_ipv4 p;
	133
1782514f DS	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;
d62a17ae	140
1782514f DS	141	alist = access_list_lookup(AFI_IP, (char *)rule);
	142	if (alist == NULL)
	143	return RMAP_NOMATCH;
d62a17ae	144
1782514f DS	145	return (access_list_apply(alist, &p) == FILTER_DENY ? RMAP_NOMATCH
1782514f DS	146	: RMAP_MATCH);
718e3744	147	}
	148
	149	/* Route map `ip next-hop' match statement. `arg' should be
	150	access-list name. */
d62a17ae	151	static void route_match_ip_next_hop_compile(const char arg)
718e3744	152	{
d62a17ae	153	return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
718e3744	154	}
	155
	156	/* Free route map's compiled `. */
d62a17ae	157	static void route_match_ip_next_hop_free(void *rule)
718e3744	158	{
d62a17ae	159	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
718e3744	160	}
	161
	162	/* Route map commands for ip next-hop matching. */
364deb04 DL	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	};
6b0655a2	169
718e3744	170	/* `match ip next-hop prefix-list PREFIX_LIST' */
718e3744	171
b68885f9	172	static enum route_map_cmd_result_t
123214ef	173	route_match_ip_next_hop_prefix_list(void rule, const struct prefix prefix,
1782514f	174	void *object)
718e3744	175	{
d62a17ae	176	struct prefix_list *plist;
	177	struct rip_info *rinfo;
	178	struct prefix_ipv4 p;
	179
1782514f DS	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;
d62a17ae	186
1782514f DS	187	plist = prefix_list_lookup(AFI_IP, (char *)rule);
	188	if (plist == NULL)
	189	return RMAP_NOMATCH;
d62a17ae	190
1782514f DS	191	return (prefix_list_apply(plist, &p) == PREFIX_DENY ? RMAP_NOMATCH
1782514f DS	192	: RMAP_MATCH);
718e3744	193	}
718e3744	194
d62a17ae	195	static void route_match_ip_next_hop_prefix_list_compile(const char arg)
718e3744	196	{
d62a17ae	197	return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
718e3744	198	}
718e3744	199
d62a17ae	200	static void route_match_ip_next_hop_prefix_list_free(void *rule)
718e3744	201	{
d62a17ae	202	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
718e3744	203	}
718e3744	204
364deb04 DL	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,
d62a17ae	209	route_match_ip_next_hop_prefix_list_compile,
364deb04 DL	210	route_match_ip_next_hop_prefix_list_free
364deb04 DL	211	};
6b0655a2	212
b6c0e913 DA	213	/* `match ip next-hop type <blackhole>' */
b6c0e913 DA	214
b68885f9	215	static enum route_map_cmd_result_t
b6c0e913	216	route_match_ip_next_hop_type(void rule, const struct prefix prefix,
1782514f	217	void *object)
b6c0e913 DA	218	{
	219	struct rip_info *rinfo;
	220
1782514f	221	if (prefix->family == AF_INET) {
b6c0e913 DA	222	rinfo = (struct rip_info *)object;
b6c0e913 DA	223	if (!rinfo)
b68885f9	224	return RMAP_NOMATCH;
b6c0e913 DA	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
364deb04 DL	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,
b6c0e913	246	route_match_ip_next_hop_type_compile,
364deb04 DL	247	route_match_ip_next_hop_type_free
364deb04 DL	248	};
b6c0e913	249
718e3744	250	/* `match ip address IP_ACCESS_LIST' */
	251
	252	/* Match function should return 1 if match is success else return
	253	zero. */
b68885f9	254	static enum route_map_cmd_result_t
1782514f	255	route_match_ip_address(void rule, const struct prefix prefix, void *object)
718e3744	256	{
d62a17ae	257	struct access_list *alist;
718e3744	258
1782514f DS	259	alist = access_list_lookup(AFI_IP, (char *)rule);
	260	if (alist == NULL)
	261	return RMAP_NOMATCH;
d62a17ae	262
1782514f DS	263	return (access_list_apply(alist, prefix) == FILTER_DENY ? RMAP_NOMATCH
1782514f DS	264	: RMAP_MATCH);
718e3744	265	}
	266
	267	/* Route map `ip address' match statement. `arg' should be
	268	access-list name. */
d62a17ae	269	static void route_match_ip_address_compile(const char arg)
718e3744	270	{
d62a17ae	271	return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
718e3744	272	}
	273
	274	/* Free route map's compiled `ip address' value. */
d62a17ae	275	static void route_match_ip_address_free(void *rule)
718e3744	276	{
d62a17ae	277	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
718e3744	278	}
	279
	280	/* Route map commands for ip address matching. */
364deb04 DL	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	};
6b0655a2	287
718e3744	288	/* `match ip address prefix-list PREFIX_LIST' */
718e3744	289
b68885f9	290	static enum route_map_cmd_result_t
123214ef	291	route_match_ip_address_prefix_list(void rule, const struct prefix prefix,
1782514f	292	void *object)
718e3744	293	{
d62a17ae	294	struct prefix_list *plist;
718e3744	295
1782514f DS	296	plist = prefix_list_lookup(AFI_IP, (char *)rule);
	297	if (plist == NULL)
	298	return RMAP_NOMATCH;
d62a17ae	299
1782514f DS	300	return (prefix_list_apply(plist, prefix) == PREFIX_DENY ? RMAP_NOMATCH
1782514f DS	301	: RMAP_MATCH);
718e3744	302	}
718e3744	303
d62a17ae	304	static void route_match_ip_address_prefix_list_compile(const char arg)
718e3744	305	{
d62a17ae	306	return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
718e3744	307	}
718e3744	308
d62a17ae	309	static void route_match_ip_address_prefix_list_free(void *rule)
718e3744	310	{
d62a17ae	311	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
718e3744	312	}
718e3744	313
364deb04 DL	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,
d62a17ae	318	route_match_ip_address_prefix_list_compile,
364deb04 DL	319	route_match_ip_address_prefix_list_free
364deb04 DL	320	};
16705130	321
	322	/* `match tag TAG' */
	323	/* Match function return 1 if match is success else return zero. */
b68885f9	324	static enum route_map_cmd_result_t
1782514f	325	route_match_tag(void rule, const struct prefix p, void *object)
d62a17ae	326	{
	327	route_tag_t *tag;
	328	struct rip_info *rinfo;
	329	route_tag_t rinfo_tag;
	330
1782514f DS	331	tag = rule;
1782514f DS	332	rinfo = object;
d62a17ae	333
1782514f DS	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;
16705130	340	}
16705130	341
16705130	342	/* Route map commands for tag matching. */
364deb04 DL	343	static const struct route_map_rule_cmd route_match_tag_cmd = {
	344	"tag",
	345	route_match_tag,
	346	route_map_rule_tag_compile,
d62a17ae	347	route_map_rule_tag_free,
16705130	348	};
6b0655a2	349
718e3744	350	/* `set metric METRIC' */
	351
	352	/* Set metric to attribute. */
b68885f9	353	static enum route_map_cmd_result_t
1782514f	354	route_set_metric(void rule, const struct prefix prefix, void *object)
d62a17ae	355	{
1782514f DS	356	struct rip_metric_modifier *mod;
1782514f DS	357	struct rip_info *rinfo;
d62a17ae	358
1782514f DS	359	mod = rule;
1782514f DS	360	rinfo = object;
d62a17ae	361
1782514f DS	362	if (!mod->used)
1782514f DS	363	return RMAP_OKAY;
6a74c5f9	364
1782514f DS	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;
d62a17ae	371
1782514f DS	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;
d62a17ae	376
1782514f	377	rinfo->metric_set = 1;
d62a17ae	378	return RMAP_OKAY;
718e3744	379	}
	380
	381	/* set metric compilation. */
d62a17ae	382	static void route_set_metric_compile(const char arg)
	383	{
	384	int len;
	385	const char *pnt;
d62a17ae	386	long metric;
	387	char *endptr = NULL;
	388	struct rip_metric_modifier *mod;
	389
6a74c5f9 DS	390	mod = XMALLOC(MTYPE_ROUTE_MAP_COMPILED,
	391	sizeof(struct rip_metric_modifier));
	392	mod->used = false;
	393
d62a17ae	394	len = strlen(arg);
	395	pnt = arg;
	396
	397	if (len == 0)
6a74c5f9	398	return mod;
d62a17ae	399
	400	/* Examine first character. */
	401	if (arg[0] == '+') {
6a74c5f9	402	mod->type = metric_increment;
d62a17ae	403	pnt++;
d62a17ae	404	} else if (arg[0] == '-') {
6a74c5f9	405	mod->type = metric_decrement;
d62a17ae	406	pnt++;
d62a17ae	407	} else
6a74c5f9	408	mod->type = metric_absolute;
d62a17ae	409
	410	/* Check beginning with digit string. */
	411	if (pnt < '0' \|\| pnt > '9')
6a74c5f9	412	return mod;
d62a17ae	413
	414	/* Convert string to integer. */
	415	metric = strtol(pnt, &endptr, 10);
	416
3679c9fa	417	if (*endptr != '\0' \|\| metric < 0) {
6a74c5f9 DS	418	return mod;
	419	}
	420	if (metric > RIP_METRIC_INFINITY) {
996c9314 LB	421	zlog_info(
996c9314 LB	422	"%s: Metric specified: %ld is greater than RIP_METRIC_INFINITY, using INFINITY instead",
15569c58	423	__func__, metric);
6a74c5f9 DS	424	mod->metric = RIP_METRIC_INFINITY;
	425	} else
	426	mod->metric = metric;
d62a17ae	427
6a74c5f9	428	mod->used = true;
d62a17ae	429
d62a17ae	430	return mod;
718e3744	431	}
	432
	433	/* Free route map's compiled `set metric' value. */
d62a17ae	434	static void route_set_metric_free(void *rule)
718e3744	435	{
d62a17ae	436	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
718e3744	437	}
	438
	439	/* Set metric rule structure. */
364deb04 DL	440	static const struct route_map_rule_cmd route_set_metric_cmd = {
	441	"metric",
	442	route_set_metric,
	443	route_set_metric_compile,
d62a17ae	444	route_set_metric_free,
718e3744	445	};
	446
	447	/* `set ip next-hop IP_ADDRESS' */
	448
581776fa	449	/* Set nexthop to object. object must be pointer to struct attr. */
1782514f DS	450	static enum route_map_cmd_result_t
	451	route_set_ip_nexthop(void rule, const struct prefix prefix,
	452
	453	void *object)
718e3744	454	{
d62a17ae	455	struct in_addr *address;
	456	struct rip_info *rinfo;
	457
1782514f DS	458	/* Fetch routemap's rule information. */
	459	address = rule;
	460	rinfo = object;
d62a17ae	461
1782514f DS	462	/* Set next hop value. */
1782514f DS	463	rinfo->nexthop_out = *address;
d62a17ae	464
d62a17ae	465	return RMAP_OKAY;
718e3744	466	}
	467
	468	/* Route map `ip nexthop' compile function. Given string is converted
	469	to struct in_addr structure. */
d62a17ae	470	static void route_set_ip_nexthop_compile(const char arg)
718e3744	471	{
d62a17ae	472	int ret;
d62a17ae	473	struct in_addr *address;
718e3744	474
d62a17ae	475	address = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct in_addr));
718e3744	476
d62a17ae	477	ret = inet_aton(arg, address);
718e3744	478
d62a17ae	479	if (ret == 0) {
	480	XFREE(MTYPE_ROUTE_MAP_COMPILED, address);
	481	return NULL;
	482	}
718e3744	483
d62a17ae	484	return address;
718e3744	485	}
	486
	487	/* Free route map's compiled `ip nexthop' value. */
d62a17ae	488	static void route_set_ip_nexthop_free(void *rule)
718e3744	489	{
d62a17ae	490	XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
718e3744	491	}
	492
	493	/* Route map commands for ip nexthop set. */
364deb04 DL	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	};
16705130	500
	501	/* `set tag TAG' */
	502
581776fa	503	/* Set tag to object. object must be pointer to struct attr. */
b68885f9	504	static enum route_map_cmd_result_t
1782514f	505	route_set_tag(void rule, const struct prefix prefix, void *object)
16705130	506	{
d62a17ae	507	route_tag_t *tag;
	508	struct rip_info *rinfo;
	509
1782514f DS	510	/* Fetch routemap's rule information. */
	511	tag = rule;
	512	rinfo = object;
d62a17ae	513
1782514f DS	514	/* Set next hop value. */
1782514f DS	515	rinfo->tag_out = *tag;
d62a17ae	516
d62a17ae	517	return RMAP_OKAY;
16705130	518	}
16705130	519
16705130	520	/* Route map commands for tag set. */
364deb04 DL	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	};
6b0655a2	527
718e3744	528	#define MATCH_STR "Match values from routing table\n"
	529	#define SET_STR "Set values in destination routing protocol\n"
	530
718e3744	531	/* Route-map init */
4d762f26	532	void rip_route_map_init(void)
718e3744	533	{
d62a17ae	534	route_map_init();
718e3744	535
d62a17ae	536	route_map_match_interface_hook(generic_match_add);
d62a17ae	537	route_map_no_match_interface_hook(generic_match_delete);
82f97584	538
d62a17ae	539	route_map_match_ip_address_hook(generic_match_add);
d62a17ae	540	route_map_no_match_ip_address_hook(generic_match_delete);
82f97584	541
d62a17ae	542	route_map_match_ip_address_prefix_list_hook(generic_match_add);
d62a17ae	543	route_map_no_match_ip_address_prefix_list_hook(generic_match_delete);
82f97584	544
d62a17ae	545	route_map_match_ip_next_hop_hook(generic_match_add);
d62a17ae	546	route_map_no_match_ip_next_hop_hook(generic_match_delete);
82f97584	547
d62a17ae	548	route_map_match_ip_next_hop_prefix_list_hook(generic_match_add);
d62a17ae	549	route_map_no_match_ip_next_hop_prefix_list_hook(generic_match_delete);
82f97584	550
b6c0e913 DA	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
d62a17ae	554	route_map_match_metric_hook(generic_match_add);
d62a17ae	555	route_map_no_match_metric_hook(generic_match_delete);
82f97584	556
d62a17ae	557	route_map_match_tag_hook(generic_match_add);
d62a17ae	558	route_map_no_match_tag_hook(generic_match_delete);
82f97584	559
d62a17ae	560	route_map_set_ip_nexthop_hook(generic_set_add);
d62a17ae	561	route_map_no_set_ip_nexthop_hook(generic_set_delete);
82f97584	562
d62a17ae	563	route_map_set_metric_hook(generic_set_add);
d62a17ae	564	route_map_no_set_metric_hook(generic_set_delete);
82f97584	565
d62a17ae	566	route_map_set_tag_hook(generic_set_add);
d62a17ae	567	route_map_no_set_tag_hook(generic_set_delete);
82f97584	568
d62a17ae	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);
b6c0e913	573	route_map_install_match(&route_match_ip_next_hop_type_cmd);
d62a17ae	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);
718e3744	577
d62a17ae	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);
718e3744	581	}