1: /* zebra routemap.
2: * Copyright (C) 2006 IBM Corporation
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: #include <zebra.h>
23:
24: #include "memory.h"
25: #include "prefix.h"
26: #include "rib.h"
27: #include "routemap.h"
28: #include "command.h"
29: #include "filter.h"
30: #include "plist.h"
31:
32: #include "zebra/zserv.h"
33:
34: /* Add zebra route map rule */
35: static int
36: zebra_route_match_add(struct vty *vty, struct route_map_index *index,
37: const char *command, const char *arg)
38: {
39: int ret;
40:
41: ret = route_map_add_match (index, command, arg);
42: if (ret)
43: {
44: switch (ret)
45: {
46: case RMAP_RULE_MISSING:
47: vty_out (vty, "%% Can't find rule.%s", VTY_NEWLINE);
48: return CMD_WARNING;
49: case RMAP_COMPILE_ERROR:
50: vty_out (vty, "%% Argument is malformed.%s", VTY_NEWLINE);
51: return CMD_WARNING;
52: }
53: }
54: return CMD_SUCCESS;
55: }
56:
57: /* Delete zebra route map rule. */
58: static int
59: zebra_route_match_delete (struct vty *vty, struct route_map_index *index,
60: const char *command, const char *arg)
61: {
62: int ret;
63:
64: ret = route_map_delete_match (index, command, arg);
65: if (ret)
66: {
67: switch (ret)
68: {
69: case RMAP_RULE_MISSING:
70: vty_out (vty, "%% Can't find rule.%s", VTY_NEWLINE);
71: return CMD_WARNING;
72: case RMAP_COMPILE_ERROR:
73: vty_out (vty, "%% Argument is malformed.%s", VTY_NEWLINE);
74: return CMD_WARNING;
75: }
76: }
77: return CMD_SUCCESS;
78: }
79:
80: /* Add zebra route map rule. */
81: static int
82: zebra_route_set_add (struct vty *vty, struct route_map_index *index,
83: const char *command, const char *arg)
84: {
85: int ret;
86:
87: ret = route_map_add_set (index, command, arg);
88: if (ret)
89: {
90: switch (ret)
91: {
92: case RMAP_RULE_MISSING:
93: vty_out (vty, "%% Can't find rule.%s", VTY_NEWLINE);
94: return CMD_WARNING;
95: case RMAP_COMPILE_ERROR:
96: vty_out (vty, "%% Argument is malformed.%s", VTY_NEWLINE);
97: return CMD_WARNING;
98: }
99: }
100: return CMD_SUCCESS;
101: }
102:
103: /* Delete zebra route map rule. */
104: static int
105: zebra_route_set_delete (struct vty *vty, struct route_map_index *index,
106: const char *command, const char *arg)
107: {
108: int ret;
109:
110: ret = route_map_delete_set (index, command, arg);
111: if (ret)
112: {
113: switch (ret)
114: {
115: case RMAP_RULE_MISSING:
116: vty_out (vty, "%% Can't find rule.%s", VTY_NEWLINE);
117: return CMD_WARNING;
118: case RMAP_COMPILE_ERROR:
119: vty_out (vty, "%% Argument is malformed.%s", VTY_NEWLINE);
120: return CMD_WARNING;
121: }
122: }
123: return CMD_SUCCESS;
124: }
125:
126:
127: /* `match interface IFNAME' */
128: /* Match function return 1 if match is success else return zero. */
129: static route_map_result_t
130: route_match_interface (void *rule, struct prefix *prefix,
131: route_map_object_t type, void *object)
132: {
133: struct nexthop *nexthop;
134: char *ifname = rule;
135: unsigned int ifindex;
136:
137: if (type == RMAP_ZEBRA)
138: {
139: if (strcasecmp(ifname, "any") == 0)
140: return RMAP_MATCH;
141: ifindex = ifname2ifindex(ifname);
142: if (ifindex == 0)
143: return RMAP_NOMATCH;
144: nexthop = object;
145: if (!nexthop)
146: return RMAP_NOMATCH;
147: if (nexthop->ifindex == ifindex)
148: return RMAP_MATCH;
149: }
150: return RMAP_NOMATCH;
151: }
152:
153: /* Route map `match interface' match statement. `arg' is IFNAME value */
154: static void *
155: route_match_interface_compile (const char *arg)
156: {
157: return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
158: }
159:
160: /* Free route map's compiled `match interface' value. */
161: static void
162: route_match_interface_free (void *rule)
163: {
164: XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
165: }
166:
167: /* Route map commands for interface matching */
168: struct route_map_rule_cmd route_match_interface_cmd =
169: {
170: "interface",
171: route_match_interface,
172: route_match_interface_compile,
173: route_match_interface_free
174: };
175:
176: DEFUN (match_interface,
177: match_interface_cmd,
178: "match interface WORD",
179: MATCH_STR
180: "match first hop interface of route\n"
181: "Interface name\n")
182: {
183: return zebra_route_match_add (vty, vty->index, "interface", argv[0]);
184: }
185:
186: DEFUN (no_match_interface,
187: no_match_interface_cmd,
188: "no match interface",
189: NO_STR
190: MATCH_STR
191: "Match first hop interface of route\n")
192: {
193: if (argc == 0)
194: return zebra_route_match_delete (vty, vty->index, "interface", NULL);
195:
196: return zebra_route_match_delete (vty, vty->index, "interface", argv[0]);
197: }
198:
199: ALIAS (no_match_interface,
200: no_match_interface_val_cmd,
201: "no match interface WORD",
202: NO_STR
203: MATCH_STR
204: "Match first hop interface of route\n"
205: "Interface name\n")
206:
207: DEFUN (match_ip_next_hop,
208: match_ip_next_hop_cmd,
209: "match ip next-hop (<1-199>|<1300-2699>|WORD)",
210: MATCH_STR
211: IP_STR
212: "Match next-hop address of route\n"
213: "IP access-list number\n"
214: "IP access-list number (expanded range)\n"
215: "IP Access-list name\n")
216: {
217: return zebra_route_match_add (vty, vty->index, "ip next-hop", argv[0]);
218: }
219:
220: DEFUN (no_match_ip_next_hop,
221: no_match_ip_next_hop_cmd,
222: "no match ip next-hop",
223: NO_STR
224: MATCH_STR
225: IP_STR
226: "Match next-hop address of route\n")
227: {
228: if (argc == 0)
229: return zebra_route_match_delete (vty, vty->index, "ip next-hop", NULL);
230:
231: return zebra_route_match_delete (vty, vty->index, "ip next-hop", argv[0]);
232: }
233:
234: ALIAS (no_match_ip_next_hop,
235: no_match_ip_next_hop_val_cmd,
236: "no match ip next-hop (<1-199>|<1300-2699>|WORD)",
237: NO_STR
238: MATCH_STR
239: IP_STR
240: "Match next-hop address of route\n"
241: "IP access-list number\n"
242: "IP access-list number (expanded range)\n"
243: "IP Access-list name\n")
244:
245: DEFUN (match_ip_next_hop_prefix_list,
246: match_ip_next_hop_prefix_list_cmd,
247: "match ip next-hop prefix-list WORD",
248: MATCH_STR
249: IP_STR
250: "Match next-hop address of route\n"
251: "Match entries of prefix-lists\n"
252: "IP prefix-list name\n")
253: {
254: return zebra_route_match_add (vty, vty->index, "ip next-hop prefix-list", argv[0]);
255: }
256:
257: DEFUN (no_match_ip_next_hop_prefix_list,
258: no_match_ip_next_hop_prefix_list_cmd,
259: "no match ip next-hop prefix-list",
260: NO_STR
261: MATCH_STR
262: IP_STR
263: "Match next-hop address of route\n"
264: "Match entries of prefix-lists\n")
265: {
266: if (argc == 0)
267: return zebra_route_match_delete (vty, vty->index, "ip next-hop prefix-list", NULL);
268:
269: return zebra_route_match_delete (vty, vty->index, "ip next-hop prefix-list", argv[0]);
270: }
271:
272: ALIAS (no_match_ip_next_hop_prefix_list,
273: no_match_ip_next_hop_prefix_list_val_cmd,
274: "no match ip next-hop prefix-list WORD",
275: NO_STR
276: MATCH_STR
277: IP_STR
278: "Match next-hop address of route\n"
279: "Match entries of prefix-lists\n"
280: "IP prefix-list name\n")
281:
282: DEFUN (match_ip_address,
283: match_ip_address_cmd,
284: "match ip address (<1-199>|<1300-2699>|WORD)",
285: MATCH_STR
286: IP_STR
287: "Match address of route\n"
288: "IP access-list number\n"
289: "IP access-list number (expanded range)\n"
290: "IP Access-list name\n")
291:
292: {
293: return zebra_route_match_add (vty, vty->index, "ip address", argv[0]);
294: }
295:
296: DEFUN (no_match_ip_address,
297: no_match_ip_address_cmd,
298: "no match ip address",
299: NO_STR
300: MATCH_STR
301: IP_STR
302: "Match address of route\n")
303: {
304: if (argc == 0)
305: return zebra_route_match_delete (vty, vty->index, "ip address", NULL);
306:
307: return zebra_route_match_delete (vty, vty->index, "ip address", argv[0]);
308: }
309:
310: ALIAS (no_match_ip_address,
311: no_match_ip_address_val_cmd,
312: "no match ip address (<1-199>|<1300-2699>|WORD)",
313: NO_STR
314: MATCH_STR
315: IP_STR
316: "Match address of route\n"
317: "IP access-list number\n"
318: "IP access-list number (expanded range)\n"
319: "IP Access-list name\n")
320:
321: DEFUN (match_ip_address_prefix_list,
322: match_ip_address_prefix_list_cmd,
323: "match ip address prefix-list WORD",
324: MATCH_STR
325: IP_STR
326: "Match address of route\n"
327: "Match entries of prefix-lists\n"
328: "IP prefix-list name\n")
329: {
330: return zebra_route_match_add (vty, vty->index, "ip address prefix-list", argv[0]);
331: }
332:
333: DEFUN (no_match_ip_address_prefix_list,
334: no_match_ip_address_prefix_list_cmd,
335: "no match ip address prefix-list",
336: NO_STR
337: MATCH_STR
338: IP_STR
339: "Match address of route\n"
340: "Match entries of prefix-lists\n")
341: {
342: if (argc == 0)
343: return zebra_route_match_delete (vty, vty->index, "ip address prefix-list", NULL);
344:
345: return zebra_route_match_delete (vty, vty->index, "ip address prefix-list", argv[0]);
346: }
347:
348: ALIAS (no_match_ip_address_prefix_list,
349: no_match_ip_address_prefix_list_val_cmd,
350: "no match ip address prefix-list WORD",
351: NO_STR
352: MATCH_STR
353: IP_STR
354: "Match address of route\n"
355: "Match entries of prefix-lists\n"
356: "IP prefix-list name\n")
357:
358: /* set functions */
359:
360: DEFUN (set_src,
361: set_src_cmd,
362: "set src A.B.C.D",
363: SET_STR
364: "src address for route\n"
365: "src address\n")
366: {
367: struct in_addr src;
368: struct interface *pif;
369:
370: if (inet_pton(AF_INET, argv[0], &src) <= 0)
371: {
372: vty_out (vty, "%% not a local address%s", VTY_NEWLINE);
373: return CMD_WARNING;
374: }
375:
376: pif = if_lookup_exact_address (src);
377: if (!pif)
378: {
379: vty_out (vty, "%% not a local address%s", VTY_NEWLINE);
380: return CMD_WARNING;
381: }
382: return zebra_route_set_add (vty, vty->index, "src", argv[0]);
383: }
384:
385: DEFUN (no_set_src,
386: no_set_src_cmd,
387: "no set src",
388: NO_STR
389: SET_STR
390: "Source address for route\n")
391: {
392: if (argc == 0)
393: return zebra_route_set_delete (vty, vty->index, "src", NULL);
394:
395: return zebra_route_set_delete (vty, vty->index, "src", argv[0]);
396: }
397:
398: ALIAS (no_set_src,
399: no_set_src_val_cmd,
400: "no set src (A.B.C.D)",
401: NO_STR
402: SET_STR
403: "src address for route\n"
404: "src address\n")
405:
406: /*XXXXXXXXXXXXXXXXXXXXXXXXXXXX*/
407:
408: /* `match ip next-hop IP_ACCESS_LIST' */
409:
410: /* Match function return 1 if match is success else return zero. */
411: static route_map_result_t
412: route_match_ip_next_hop (void *rule, struct prefix *prefix,
413: route_map_object_t type, void *object)
414: {
415: struct access_list *alist;
416: struct nexthop *nexthop;
417: struct prefix_ipv4 p;
418:
419: if (type == RMAP_ZEBRA)
420: {
421: nexthop = object;
422: switch (nexthop->type) {
423: case NEXTHOP_TYPE_IFINDEX:
424: case NEXTHOP_TYPE_IFNAME:
425: case NEXTHOP_TYPE_IPV4_IFINDEX:
426: case NEXTHOP_TYPE_IPV4_IFNAME:
427: if (nexthop->rtype != NEXTHOP_TYPE_IPV4)
428: return RMAP_NOMATCH;
429: p.family = AF_INET;
430: p.prefix = nexthop->rgate.ipv4;
431: p.prefixlen = IPV4_MAX_BITLEN;
432: break;
433: case NEXTHOP_TYPE_IPV4:
434: p.family = AF_INET;
435: p.prefix = nexthop->gate.ipv4;
436: p.prefixlen = IPV4_MAX_BITLEN;
437: break;
438: default:
439: return RMAP_NOMATCH;
440: }
441: alist = access_list_lookup (AFI_IP, (char *) rule);
442: if (alist == NULL)
443: return RMAP_NOMATCH;
444:
445: return (access_list_apply (alist, &p) == FILTER_DENY ?
446: RMAP_NOMATCH : RMAP_MATCH);
447: }
448: return RMAP_NOMATCH;
449: }
450:
451: /* Route map `ip next-hop' match statement. `arg' should be
452: access-list name. */
453: static void *
454: route_match_ip_next_hop_compile (const char *arg)
455: {
456: return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
457: }
458:
459: /* Free route map's compiled `. */
460: static void
461: route_match_ip_next_hop_free (void *rule)
462: {
463: XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
464: }
465:
466: /* Route map commands for ip next-hop matching. */
467: static struct route_map_rule_cmd route_match_ip_next_hop_cmd =
468: {
469: "ip next-hop",
470: route_match_ip_next_hop,
471: route_match_ip_next_hop_compile,
472: route_match_ip_next_hop_free
473: };
474:
475: /* `match ip next-hop prefix-list PREFIX_LIST' */
476:
477: static route_map_result_t
478: route_match_ip_next_hop_prefix_list (void *rule, struct prefix *prefix,
479: route_map_object_t type, void *object)
480: {
481: struct prefix_list *plist;
482: struct nexthop *nexthop;
483: struct prefix_ipv4 p;
484:
485: if (type == RMAP_ZEBRA)
486: {
487: nexthop = object;
488: switch (nexthop->type) {
489: case NEXTHOP_TYPE_IFINDEX:
490: case NEXTHOP_TYPE_IFNAME:
491: case NEXTHOP_TYPE_IPV4_IFINDEX:
492: case NEXTHOP_TYPE_IPV4_IFNAME:
493: if (nexthop->rtype != NEXTHOP_TYPE_IPV4)
494: return RMAP_NOMATCH;
495: p.family = AF_INET;
496: p.prefix = nexthop->rgate.ipv4;
497: p.prefixlen = IPV4_MAX_BITLEN;
498: break;
499: case NEXTHOP_TYPE_IPV4:
500: p.family = AF_INET;
501: p.prefix = nexthop->gate.ipv4;
502: p.prefixlen = IPV4_MAX_BITLEN;
503: break;
504: default:
505: return RMAP_NOMATCH;
506: }
507: plist = prefix_list_lookup (AFI_IP, (char *) rule);
508: if (plist == NULL)
509: return RMAP_NOMATCH;
510:
511: return (prefix_list_apply (plist, &p) == PREFIX_DENY ?
512: RMAP_NOMATCH : RMAP_MATCH);
513: }
514: return RMAP_NOMATCH;
515: }
516:
517: static void *
518: route_match_ip_next_hop_prefix_list_compile (const char *arg)
519: {
520: return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
521: }
522:
523: static void
524: route_match_ip_next_hop_prefix_list_free (void *rule)
525: {
526: XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
527: }
528:
529: static struct route_map_rule_cmd route_match_ip_next_hop_prefix_list_cmd =
530: {
531: "ip next-hop prefix-list",
532: route_match_ip_next_hop_prefix_list,
533: route_match_ip_next_hop_prefix_list_compile,
534: route_match_ip_next_hop_prefix_list_free
535: };
536:
537: /* `match ip address IP_ACCESS_LIST' */
538:
539: /* Match function should return 1 if match is success else return
540: zero. */
541: static route_map_result_t
542: route_match_ip_address (void *rule, struct prefix *prefix,
543: route_map_object_t type, void *object)
544: {
545: struct access_list *alist;
546:
547: if (type == RMAP_ZEBRA)
548: {
549: alist = access_list_lookup (AFI_IP, (char *) rule);
550: if (alist == NULL)
551: return RMAP_NOMATCH;
552:
553: return (access_list_apply (alist, prefix) == FILTER_DENY ?
554: RMAP_NOMATCH : RMAP_MATCH);
555: }
556: return RMAP_NOMATCH;
557: }
558:
559: /* Route map `ip address' match statement. `arg' should be
560: access-list name. */
561: static void *
562: route_match_ip_address_compile (const char *arg)
563: {
564: return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
565: }
566:
567: /* Free route map's compiled `ip address' value. */
568: static void
569: route_match_ip_address_free (void *rule)
570: {
571: XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
572: }
573:
574: /* Route map commands for ip address matching. */
575: static struct route_map_rule_cmd route_match_ip_address_cmd =
576: {
577: "ip address",
578: route_match_ip_address,
579: route_match_ip_address_compile,
580: route_match_ip_address_free
581: };
582:
583: /* `match ip address prefix-list PREFIX_LIST' */
584:
585: static route_map_result_t
586: route_match_ip_address_prefix_list (void *rule, struct prefix *prefix,
587: route_map_object_t type, void *object)
588: {
589: struct prefix_list *plist;
590:
591: if (type == RMAP_ZEBRA)
592: {
593: plist = prefix_list_lookup (AFI_IP, (char *) rule);
594: if (plist == NULL)
595: return RMAP_NOMATCH;
596:
597: return (prefix_list_apply (plist, prefix) == PREFIX_DENY ?
598: RMAP_NOMATCH : RMAP_MATCH);
599: }
600: return RMAP_NOMATCH;
601: }
602:
603: static void *
604: route_match_ip_address_prefix_list_compile (const char *arg)
605: {
606: return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
607: }
608:
609: static void
610: route_match_ip_address_prefix_list_free (void *rule)
611: {
612: XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
613: }
614:
615: static struct route_map_rule_cmd route_match_ip_address_prefix_list_cmd =
616: {
617: "ip address prefix-list",
618: route_match_ip_address_prefix_list,
619: route_match_ip_address_prefix_list_compile,
620: route_match_ip_address_prefix_list_free
621: };
622:
623:
624: /* `set src A.B.C.D' */
625:
626: /* Set src. */
627: static route_map_result_t
628: route_set_src (void *rule, struct prefix *prefix,
629: route_map_object_t type, void *object)
630: {
631: if (type == RMAP_ZEBRA)
632: {
633: struct nexthop *nexthop;
634:
635: nexthop = object;
636: nexthop->src = *(union g_addr *)rule;
637: }
638: return RMAP_OKAY;
639: }
640:
641: /* set src compilation. */
642: static void *
643: route_set_src_compile (const char *arg)
644: {
645: union g_addr src, *psrc;
646:
647: if (inet_pton(AF_INET, arg, &src.ipv4) != 1
648: #ifdef HAVE_IPV6
649: && inet_pton(AF_INET6, arg, &src.ipv6) != 1
650: #endif /* HAVE_IPV6 */
651: )
652: return NULL;
653:
654: psrc = XMALLOC (MTYPE_ROUTE_MAP_COMPILED, sizeof (union g_addr));
655: *psrc = src;
656:
657: return psrc;
658: }
659:
660: /* Free route map's compiled `set src' value. */
661: static void
662: route_set_src_free (void *rule)
663: {
664: XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
665: }
666:
667: /* Set src rule structure. */
668: static struct route_map_rule_cmd route_set_src_cmd =
669: {
670: "src",
671: route_set_src,
672: route_set_src_compile,
673: route_set_src_free,
674: };
675:
676: void
677: zebra_route_map_init ()
678: {
679: route_map_init ();
680: route_map_init_vty ();
681:
682: route_map_install_match (&route_match_interface_cmd);
683: route_map_install_match (&route_match_ip_next_hop_cmd);
684: route_map_install_match (&route_match_ip_next_hop_prefix_list_cmd);
685: route_map_install_match (&route_match_ip_address_cmd);
686: route_map_install_match (&route_match_ip_address_prefix_list_cmd);
687: /* */
688: route_map_install_set (&route_set_src_cmd);
689: /* */
690: install_element (RMAP_NODE, &match_interface_cmd);
691: install_element (RMAP_NODE, &no_match_interface_cmd);
692: install_element (RMAP_NODE, &no_match_interface_val_cmd);
693: install_element (RMAP_NODE, &match_ip_next_hop_cmd);
694: install_element (RMAP_NODE, &no_match_ip_next_hop_cmd);
695: install_element (RMAP_NODE, &no_match_ip_next_hop_val_cmd);
696: install_element (RMAP_NODE, &match_ip_next_hop_prefix_list_cmd);
697: install_element (RMAP_NODE, &no_match_ip_next_hop_prefix_list_cmd);
698: install_element (RMAP_NODE, &no_match_ip_next_hop_prefix_list_val_cmd);
699: install_element (RMAP_NODE, &match_ip_address_cmd);
700: install_element (RMAP_NODE, &no_match_ip_address_cmd);
701: install_element (RMAP_NODE, &no_match_ip_address_val_cmd);
702: install_element (RMAP_NODE, &match_ip_address_prefix_list_cmd);
703: install_element (RMAP_NODE, &no_match_ip_address_prefix_list_cmd);
704: install_element (RMAP_NODE, &no_match_ip_address_prefix_list_val_cmd);
705: /* */
706: install_element (RMAP_NODE, &set_src_cmd);
707: install_element (RMAP_NODE, &no_set_src_cmd);
708: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to zebra_routemap.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / zebra