[mirror_frr.git] / zebra / zebra_routemap_nb_config.c

#include <zebra.h>

#include "lib/command.h"
#include "lib/log.h"
#include "lib/northbound.h"
#include "lib/routemap.h"
#include "zebra/rib.h"
#include "zebra/zebra_routemap_nb.h"

/*
 * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-zebra-route-map:ipv4-prefix-length
 */
int
lib_route_map_entry_match_condition_rmap_match_condition_ipv4_prefix_length_modify(
	struct nb_cb_modify_args *args)
{
	struct routemap_hook_context *rhc;
	const char *length;
	int rv;
	const char *condition;

	switch (args->event) {
	case NB_EV_VALIDATE:
	case NB_EV_PREPARE:
	case NB_EV_ABORT:
		return NB_OK;
	case NB_EV_APPLY:
		/* Add configuration. */
		rhc = nb_running_get_entry(args->dnode, NULL, true);
		length = yang_dnode_get_string(args->dnode, NULL);
		condition = yang_dnode_get_string(args->dnode,
				"../../frr-route-map:condition");

		if (IS_MATCH_IPv4_PREFIX_LEN(condition))
			rhc->rhc_rule = "ip address prefix-len";
		else if (IS_MATCH_IPv4_NH_PREFIX_LEN(condition))
			rhc->rhc_rule = "ip next-hop prefix-len";

		rhc->rhc_mhook = generic_match_delete;
		rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;

		rv = generic_match_add(rhc->rhc_rmi, rhc->rhc_rule,
				       length, RMAP_EVENT_MATCH_ADDED,
				       args->errmsg, args->errmsg_len);
		if (rv != CMD_SUCCESS) {
			rhc->rhc_mhook = NULL;
			return NB_ERR_INCONSISTENCY;
		}
	}

	return NB_OK;
}

int
lib_route_map_entry_match_condition_rmap_match_condition_ipv4_prefix_length_destroy(
	struct nb_cb_destroy_args *args)
{
	switch (args->event) {
	case NB_EV_VALIDATE:
	case NB_EV_PREPARE:
	case NB_EV_ABORT:
		break;
	case NB_EV_APPLY:
		return lib_route_map_entry_match_destroy(args);
	}

	return NB_OK;
}

/*
 * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-zebra-route-map:ipv6-prefix-length
 */
int
lib_route_map_entry_match_condition_rmap_match_condition_ipv6_prefix_length_modify(
	struct nb_cb_modify_args *args)
{
	struct routemap_hook_context *rhc;
	const char *length;
	int rv;

	switch (args->event) {
	case NB_EV_VALIDATE:
	case NB_EV_PREPARE:
	case NB_EV_ABORT:
		return NB_OK;
	case NB_EV_APPLY:
		/* Add configuration. */
		rhc = nb_running_get_entry(args->dnode, NULL, true);
		length = yang_dnode_get_string(args->dnode, NULL);

		/* Set destroy information. */
		rhc->rhc_mhook = generic_match_delete;
		rhc->rhc_rule = "ipv6 address prefix-len";
		rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;

		rv = generic_match_add(rhc->rhc_rmi, "ipv6 address prefix-len",
				length, RMAP_EVENT_MATCH_ADDED,
				args->errmsg, args->errmsg_len);
		if (rv != CMD_SUCCESS) {
			rhc->rhc_mhook = NULL;
			return NB_ERR_INCONSISTENCY;
		}
	}

	return NB_OK;
}

int
lib_route_map_entry_match_condition_rmap_match_condition_ipv6_prefix_length_destroy(
	struct nb_cb_destroy_args *args)
{
	switch (args->event) {
	case NB_EV_VALIDATE:
	case NB_EV_PREPARE:
	case NB_EV_ABORT:
		break;
	case NB_EV_APPLY:
		return lib_route_map_entry_match_destroy(args);
	}

	return NB_OK;

}

/*
 * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-zebra-route-map:source-instance
 */
int
lib_route_map_entry_match_condition_rmap_match_condition_source_instance_modify(
	struct nb_cb_modify_args *args)
{
	struct routemap_hook_context *rhc;
	const char *type;
	int rv;

	switch (args->event) {
	case NB_EV_VALIDATE:
	case NB_EV_PREPARE:
	case NB_EV_ABORT:
		break;
	case NB_EV_APPLY:
		/* Add configuration. */
		rhc = nb_running_get_entry(args->dnode, NULL, true);
		type = yang_dnode_get_string(args->dnode, NULL);

		/* Set destroy information. */
		rhc->rhc_mhook = generic_match_delete;
		rhc->rhc_rule = "source-instance";
		rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;

		rv = generic_match_add(rhc->rhc_rmi, "source-instance",
				       type, RMAP_EVENT_MATCH_ADDED,
				       args->errmsg, args->errmsg_len);
		if (rv != CMD_SUCCESS) {
			rhc->rhc_mhook = NULL;
			return NB_ERR_INCONSISTENCY;
		}
	}

	return NB_OK;
}

int
lib_route_map_entry_match_condition_rmap_match_condition_source_instance_destroy(
	struct nb_cb_destroy_args *args)
{
	switch (args->event) {
	case NB_EV_VALIDATE:
	case NB_EV_PREPARE:
	case NB_EV_ABORT:
		break;
	case NB_EV_APPLY:
		return lib_route_map_entry_match_destroy(args);
	}

	return NB_OK;
}

/*
 * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-zebra-route-map:source-protocol
 */
int
lib_route_map_entry_match_condition_rmap_match_condition_source_protocol_modify(
	struct nb_cb_modify_args *args)
{
	struct routemap_hook_context *rhc;
	const char *type;
	int rv;

	switch (args->event) {
	case NB_EV_VALIDATE:
		type = yang_dnode_get_string(args->dnode, NULL);
		if (proto_name2num(type) == -1) {
			zlog_warn("%s: invalid protocol: %s", __func__, type);
			return NB_ERR_VALIDATION;
		}
		return NB_OK;
	case NB_EV_PREPARE:
	case NB_EV_ABORT:
		return NB_OK;
	case NB_EV_APPLY:
		/* NOTHING */
		break;
	}

	/* Add configuration. */
	rhc = nb_running_get_entry(args->dnode, NULL, true);
	type = yang_dnode_get_string(args->dnode, NULL);

	/* Set destroy information. */
	rhc->rhc_mhook = generic_match_delete;
	rhc->rhc_rule = "source-protocol";
	rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;

	rv = generic_match_add(rhc->rhc_rmi, "source-protocol", type,
			       RMAP_EVENT_MATCH_ADDED,
			       args->errmsg, args->errmsg_len);
	if (rv != CMD_SUCCESS) {
		rhc->rhc_mhook = NULL;
		return NB_ERR_INCONSISTENCY;
	}

	return NB_OK;
}

int
lib_route_map_entry_match_condition_rmap_match_condition_source_protocol_destroy(
	struct nb_cb_destroy_args *args)
{
	switch (args->event) {
	case NB_EV_VALIDATE:
	case NB_EV_PREPARE:
	case NB_EV_ABORT:
		break;
	case NB_EV_APPLY:
		return lib_route_map_entry_match_destroy(args);
	}

	return NB_OK;
}

/*
 * XPath: /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-zebra-route-map:ipv4-src-address
 */
int
lib_route_map_entry_set_action_rmap_set_action_ipv4_src_address_modify(
	struct nb_cb_modify_args *args)
{
	struct routemap_hook_context *rhc;
	const char *source;
	struct prefix p;
	int rv;

	switch (args->event) {
	case NB_EV_VALIDATE:
		memset(&p, 0, sizeof(p));
		yang_dnode_get_ipv4p(&p, args->dnode, NULL);
		if (zebra_check_addr(&p) == 0) {
			zlog_warn("%s: invalid IPv4 address: %s", __func__,
				  yang_dnode_get_string(args->dnode, NULL));
			return NB_ERR_VALIDATION;
		}
		return NB_OK;
	case NB_EV_PREPARE:
	case NB_EV_ABORT:
		return NB_OK;
	case NB_EV_APPLY:
		/* NOTHING */
		break;
	}

	/* Add configuration. */
	rhc = nb_running_get_entry(args->dnode, NULL, true);
	source = yang_dnode_get_string(args->dnode, NULL);

	/* Set destroy information. */
	rhc->rhc_shook = generic_set_delete;
	rhc->rhc_rule = "src";

	rv = generic_set_add(rhc->rhc_rmi, "src", source,
			     args->errmsg, args->errmsg_len);
	if (rv != CMD_SUCCESS) {
		rhc->rhc_shook = NULL;
		return NB_ERR_INCONSISTENCY;
	}

	return NB_OK;
}

int
lib_route_map_entry_set_action_rmap_set_action_ipv4_src_address_destroy(
	struct nb_cb_destroy_args *args)
{
	switch (args->event) {
	case NB_EV_VALIDATE:
	case NB_EV_PREPARE:
	case NB_EV_ABORT:
		break;
	case NB_EV_APPLY:
		return lib_route_map_entry_set_destroy(args);
	}

	return NB_OK;
}

/*
 * XPath: /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-zebra-route-map:ipv6-src-address
 */
int
lib_route_map_entry_set_action_rmap_set_action_ipv6_src_address_modify(
	struct nb_cb_modify_args *args)
{
	struct routemap_hook_context *rhc;
	const char *source;
	struct prefix p;
	int rv;

	switch (args->event) {
	case NB_EV_VALIDATE:
		memset(&p, 0, sizeof(p));
		yang_dnode_get_ipv6p(&p, args->dnode, NULL);
		if (zebra_check_addr(&p) == 0) {
			zlog_warn("%s: invalid IPv6 address: %s", __func__,
				  yang_dnode_get_string(args->dnode, NULL));
			return NB_ERR_VALIDATION;
		}
		return NB_OK;
	case NB_EV_PREPARE:
	case NB_EV_ABORT:
		return NB_OK;
	case NB_EV_APPLY:
		/* NOTHING */
		break;
	}

	/* Add configuration. */
	rhc = nb_running_get_entry(args->dnode, NULL, true);
	source = yang_dnode_get_string(args->dnode, NULL);

	/* Set destroy information. */
	rhc->rhc_shook = generic_set_delete;
	rhc->rhc_rule = "src";

	rv = generic_set_add(rhc->rhc_rmi, "src", source,
			     args->errmsg, args->errmsg_len);
	if (rv != CMD_SUCCESS) {
		rhc->rhc_shook = NULL;
		return NB_ERR_INCONSISTENCY;
	}

	return NB_OK;
}

int
lib_route_map_entry_set_action_rmap_set_action_ipv6_src_address_destroy(
	struct nb_cb_destroy_args *args)
{
	switch (args->event) {
	case NB_EV_VALIDATE:
	case NB_EV_PREPARE:
	case NB_EV_ABORT:
		break;
	case NB_EV_APPLY:
		return lib_route_map_entry_set_destroy(args);
	}

	return NB_OK;
}
Commit	Line	Data
e71627cb SP	1	#include <zebra.h>
	2
	3	#include "lib/command.h"
	4	#include "lib/log.h"
	5	#include "lib/northbound.h"
	6	#include "lib/routemap.h"
	7	#include "zebra/rib.h"
	8	#include "zebra/zebra_routemap_nb.h"
	9
	10	/*
	11	* XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-zebra-route-map:ipv4-prefix-length
	12	*/
	13	int
	14	lib_route_map_entry_match_condition_rmap_match_condition_ipv4_prefix_length_modify(
	15	struct nb_cb_modify_args *args)
	16	{
	17	struct routemap_hook_context *rhc;
	18	const char *length;
	19	int rv;
	20	const char *condition;
	21
	22	switch (args->event) {
	23	case NB_EV_VALIDATE:
	24	case NB_EV_PREPARE:
	25	case NB_EV_ABORT:
	26	return NB_OK;
	27	case NB_EV_APPLY:
	28	/* Add configuration. */
	29	rhc = nb_running_get_entry(args->dnode, NULL, true);
	30	length = yang_dnode_get_string(args->dnode, NULL);
	31	condition = yang_dnode_get_string(args->dnode,
	32	"../../frr-route-map:condition");
	33
	34	if (IS_MATCH_IPv4_PREFIX_LEN(condition))
	35	rhc->rhc_rule = "ip address prefix-len";
	36	else if (IS_MATCH_IPv4_NH_PREFIX_LEN(condition))
	37	rhc->rhc_rule = "ip next-hop prefix-len";
	38
	39	rhc->rhc_mhook = generic_match_delete;
	40	rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
	41
	42	rv = generic_match_add(rhc->rhc_rmi, rhc->rhc_rule,
	43	length, RMAP_EVENT_MATCH_ADDED,
	44	args->errmsg, args->errmsg_len);
	45	if (rv != CMD_SUCCESS) {
	46	rhc->rhc_mhook = NULL;
	47	return NB_ERR_INCONSISTENCY;
	48	}
	49	}
	50
	51	return NB_OK;
	52	}
	53
	54	int
	55	lib_route_map_entry_match_condition_rmap_match_condition_ipv4_prefix_length_destroy(
	56	struct nb_cb_destroy_args *args)
	57	{
	58	switch (args->event) {
	59	case NB_EV_VALIDATE:
	60	case NB_EV_PREPARE:
	61	case NB_EV_ABORT:
	62	break;
	63	case NB_EV_APPLY:
	64	return lib_route_map_entry_match_destroy(args);
65	}
66
67	return NB_OK;
68	}
69
70	/*
71	* XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-zebra-route-map:ipv6-prefix-length
72	*/
73	int
74	lib_route_map_entry_match_condition_rmap_match_condition_ipv6_prefix_length_modify(
75	struct nb_cb_modify_args *args)
76	{
77	struct routemap_hook_context *rhc;
78	const char *length;
79	int rv;
80
81	switch (args->event) {
82	case NB_EV_VALIDATE:
83	case NB_EV_PREPARE:
84	case NB_EV_ABORT:
85	return NB_OK;
86	case NB_EV_APPLY:
87	/* Add configuration. */
88	rhc = nb_running_get_entry(args->dnode, NULL, true);
89	length = yang_dnode_get_string(args->dnode, NULL);
90
91	/* Set destroy information. */
92	rhc->rhc_mhook = generic_match_delete;
93	rhc->rhc_rule = "ipv6 address prefix-len";
94	rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
95
96	rv = generic_match_add(rhc->rhc_rmi, "ipv6 address prefix-len",
97	length, RMAP_EVENT_MATCH_ADDED,
98	args->errmsg, args->errmsg_len);
99	if (rv != CMD_SUCCESS) {
100	rhc->rhc_mhook = NULL;
101	return NB_ERR_INCONSISTENCY;
102	}
103	}
104
105	return NB_OK;
106	}
107
108	int
109	lib_route_map_entry_match_condition_rmap_match_condition_ipv6_prefix_length_destroy(
110	struct nb_cb_destroy_args *args)
111	{
112	switch (args->event) {
113	case NB_EV_VALIDATE:
114	case NB_EV_PREPARE:
115	case NB_EV_ABORT:
116	break;
117	case NB_EV_APPLY:
118	return lib_route_map_entry_match_destroy(args);
119	}
120
121	return NB_OK;
122
123	}
124
125	/*
126	* XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-zebra-route-map:source-instance
127	*/
128	int
129	lib_route_map_entry_match_condition_rmap_match_condition_source_instance_modify(
130	struct nb_cb_modify_args *args)
131	{
132	struct routemap_hook_context *rhc;
133	const char *type;
134	int rv;
135
136	switch (args->event) {
137	case NB_EV_VALIDATE:
138	case NB_EV_PREPARE:
139	case NB_EV_ABORT:
140	break;
141	case NB_EV_APPLY:
142	/* Add configuration. */
143	rhc = nb_running_get_entry(args->dnode, NULL, true);
144	type = yang_dnode_get_string(args->dnode, NULL);
145
146	/* Set destroy information. */
147	rhc->rhc_mhook = generic_match_delete;
148	rhc->rhc_rule = "source-instance";
149	rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
150
151	rv = generic_match_add(rhc->rhc_rmi, "source-instance",
152	type, RMAP_EVENT_MATCH_ADDED,
153	args->errmsg, args->errmsg_len);
154	if (rv != CMD_SUCCESS) {
155	rhc->rhc_mhook = NULL;
156	return NB_ERR_INCONSISTENCY;
157	}
158	}
159
160	return NB_OK;
161	}
162
163	int
164	lib_route_map_entry_match_condition_rmap_match_condition_source_instance_destroy(
165	struct nb_cb_destroy_args *args)
166	{
167	switch (args->event) {
168	case NB_EV_VALIDATE:
169	case NB_EV_PREPARE:
170	case NB_EV_ABORT:
171	break;
172	case NB_EV_APPLY:
173	return lib_route_map_entry_match_destroy(args);
174	}
175
176	return NB_OK;
177	}
178
179	/*
180	* XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-zebra-route-map:source-protocol
181	*/
182	int
183	lib_route_map_entry_match_condition_rmap_match_condition_source_protocol_modify(
184	struct nb_cb_modify_args *args)
185	{
186	struct routemap_hook_context *rhc;
187	const char *type;
188	int rv;
189
190	switch (args->event) {
191	case NB_EV_VALIDATE:
192	type = yang_dnode_get_string(args->dnode, NULL);
193	if (proto_name2num(type) == -1) {
194	zlog_warn("%s: invalid protocol: %s", __func__, type);
195	return NB_ERR_VALIDATION;
196	}
197	return NB_OK;
198	case NB_EV_PREPARE:
199	case NB_EV_ABORT:
200	return NB_OK;
201	case NB_EV_APPLY:
202	/* NOTHING */
203	break;
204	}
205
206	/* Add configuration. */
207	rhc = nb_running_get_entry(args->dnode, NULL, true);
208	type = yang_dnode_get_string(args->dnode, NULL);
209
210	/* Set destroy information. */
211	rhc->rhc_mhook = generic_match_delete;
212	rhc->rhc_rule = "source-protocol";
213	rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
214
215	rv = generic_match_add(rhc->rhc_rmi, "source-protocol", type,
216	RMAP_EVENT_MATCH_ADDED,
217	args->errmsg, args->errmsg_len);
218	if (rv != CMD_SUCCESS) {
219	rhc->rhc_mhook = NULL;
220	return NB_ERR_INCONSISTENCY;
221	}
222
223	return NB_OK;
224	}
225
226	int
227	lib_route_map_entry_match_condition_rmap_match_condition_source_protocol_destroy(
228	struct nb_cb_destroy_args *args)
229	{
230	switch (args->event) {
231	case NB_EV_VALIDATE:
232	case NB_EV_PREPARE:
233	case NB_EV_ABORT:
234	break;
235	case NB_EV_APPLY:
236	return lib_route_map_entry_match_destroy(args);
237	}
238
239	return NB_OK;
240	}
241
242	/*
243	* XPath: /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-zebra-route-map:ipv4-src-address
244	*/
245	int
246	lib_route_map_entry_set_action_rmap_set_action_ipv4_src_address_modify(
247	struct nb_cb_modify_args *args)
248	{
249	struct routemap_hook_context *rhc;
e71627cb	250	const char *source;
e71627cb SP	251	struct prefix p;
	252	int rv;
	253
	254	switch (args->event) {
	255	case NB_EV_VALIDATE:
	256	memset(&p, 0, sizeof(p));
	257	yang_dnode_get_ipv4p(&p, args->dnode, NULL);
	258	if (zebra_check_addr(&p) == 0) {
	259	zlog_warn("%s: invalid IPv4 address: %s", __func__,
	260	yang_dnode_get_string(args->dnode, NULL));
	261	return NB_ERR_VALIDATION;
	262	}
e71627cb SP	263	return NB_OK;
	264	case NB_EV_PREPARE:
	265	case NB_EV_ABORT:
	266	return NB_OK;
	267	case NB_EV_APPLY:
	268	/* NOTHING */
	269	break;
	270	}
	271
	272	/* Add configuration. */
	273	rhc = nb_running_get_entry(args->dnode, NULL, true);
	274	source = yang_dnode_get_string(args->dnode, NULL);
	275
	276	/* Set destroy information. */
	277	rhc->rhc_shook = generic_set_delete;
	278	rhc->rhc_rule = "src";
	279
	280	rv = generic_set_add(rhc->rhc_rmi, "src", source,
	281	args->errmsg, args->errmsg_len);
	282	if (rv != CMD_SUCCESS) {
	283	rhc->rhc_shook = NULL;
	284	return NB_ERR_INCONSISTENCY;
	285	}
	286
	287	return NB_OK;
	288	}
	289
	290	int
	291	lib_route_map_entry_set_action_rmap_set_action_ipv4_src_address_destroy(
	292	struct nb_cb_destroy_args *args)
	293	{
	294	switch (args->event) {
	295	case NB_EV_VALIDATE:
	296	case NB_EV_PREPARE:
	297	case NB_EV_ABORT:
	298	break;
	299	case NB_EV_APPLY:
	300	return lib_route_map_entry_set_destroy(args);
	301	}
	302
	303	return NB_OK;
	304	}
	305
	306	/*
	307	* XPath: /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-zebra-route-map:ipv6-src-address
	308	*/
	309	int
	310	lib_route_map_entry_set_action_rmap_set_action_ipv6_src_address_modify(
	311	struct nb_cb_modify_args *args)
	312	{
	313	struct routemap_hook_context *rhc;
e71627cb	314	const char *source;
e71627cb SP	315	struct prefix p;
	316	int rv;
	317
	318	switch (args->event) {
	319	case NB_EV_VALIDATE:
	320	memset(&p, 0, sizeof(p));
	321	yang_dnode_get_ipv6p(&p, args->dnode, NULL);
	322	if (zebra_check_addr(&p) == 0) {
	323	zlog_warn("%s: invalid IPv6 address: %s", __func__,
	324	yang_dnode_get_string(args->dnode, NULL));
	325	return NB_ERR_VALIDATION;
	326	}
e71627cb SP	327	return NB_OK;
	328	case NB_EV_PREPARE:
	329	case NB_EV_ABORT:
	330	return NB_OK;
	331	case NB_EV_APPLY:
	332	/* NOTHING */
	333	break;
	334	}
	335
	336	/* Add configuration. */
	337	rhc = nb_running_get_entry(args->dnode, NULL, true);
	338	source = yang_dnode_get_string(args->dnode, NULL);
	339
	340	/* Set destroy information. */
	341	rhc->rhc_shook = generic_set_delete;
	342	rhc->rhc_rule = "src";
	343
	344	rv = generic_set_add(rhc->rhc_rmi, "src", source,
	345	args->errmsg, args->errmsg_len);
	346	if (rv != CMD_SUCCESS) {
	347	rhc->rhc_shook = NULL;
	348	return NB_ERR_INCONSISTENCY;
	349	}
	350
	351	return NB_OK;
	352	}
	353
	354	int
	355	lib_route_map_entry_set_action_rmap_set_action_ipv6_src_address_destroy(
	356	struct nb_cb_destroy_args *args)
	357	{
	358	switch (args->event) {
	359	case NB_EV_VALIDATE:
	360	case NB_EV_PREPARE:
	361	case NB_EV_ABORT:
	362	break;
	363	case NB_EV_APPLY:
	364	return lib_route_map_entry_set_destroy(args);
	365	}
	366
	367	return NB_OK;
	368	}