1: /* Route map function.
2: Copyright (C) 1998, 1999 Kunihiro Ishiguro
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: #include <zebra.h>
22:
23: #include "linklist.h"
24: #include "memory.h"
25: #include "vector.h"
26: #include "prefix.h"
27: #include "routemap.h"
28: #include "command.h"
29: #include "vty.h"
30: #include "log.h"
31:
32: /* Vector for route match rules. */
33: static vector route_match_vec;
34:
35: /* Vector for route set rules. */
36: static vector route_set_vec;
37:
38: /* Route map rule. This rule has both `match' rule and `set' rule. */
39: struct route_map_rule
40: {
41: /* Rule type. */
42: struct route_map_rule_cmd *cmd;
43:
44: /* For pretty printing. */
45: char *rule_str;
46:
47: /* Pre-compiled match rule. */
48: void *value;
49:
50: /* Linked list. */
51: struct route_map_rule *next;
52: struct route_map_rule *prev;
53: };
54:
55: /* Making route map list. */
56: struct route_map_list
57: {
58: struct route_map *head;
59: struct route_map *tail;
60:
61: void (*add_hook) (const char *);
62: void (*delete_hook) (const char *);
63: void (*event_hook) (route_map_event_t, const char *);
64: };
65:
66: /* Master list of route map. */
67: static struct route_map_list route_map_master = { NULL, NULL, NULL, NULL };
68:
69: static void
70: route_map_rule_delete (struct route_map_rule_list *,
71: struct route_map_rule *);
72:
73: static void
74: route_map_index_delete (struct route_map_index *, int);
75:
76: /* New route map allocation. Please note route map's name must be
77: specified. */
78: static struct route_map *
79: route_map_new (const char *name)
80: {
81: struct route_map *new;
82:
83: new = XCALLOC (MTYPE_ROUTE_MAP, sizeof (struct route_map));
84: new->name = XSTRDUP (MTYPE_ROUTE_MAP_NAME, name);
85: return new;
86: }
87:
88: /* Add new name to route_map. */
89: static struct route_map *
90: route_map_add (const char *name)
91: {
92: struct route_map *map;
93: struct route_map_list *list;
94:
95: map = route_map_new (name);
96: list = &route_map_master;
97:
98: map->next = NULL;
99: map->prev = list->tail;
100: if (list->tail)
101: list->tail->next = map;
102: else
103: list->head = map;
104: list->tail = map;
105:
106: /* Execute hook. */
107: if (route_map_master.add_hook)
108: (*route_map_master.add_hook) (name);
109:
110: return map;
111: }
112:
113: /* Route map delete from list. */
114: static void
115: route_map_delete (struct route_map *map)
116: {
117: struct route_map_list *list;
118: struct route_map_index *index;
119: char *name;
120:
121: while ((index = map->head) != NULL)
122: route_map_index_delete (index, 0);
123:
124: name = map->name;
125:
126: list = &route_map_master;
127:
128: if (map->next)
129: map->next->prev = map->prev;
130: else
131: list->tail = map->prev;
132:
133: if (map->prev)
134: map->prev->next = map->next;
135: else
136: list->head = map->next;
137:
138: XFREE (MTYPE_ROUTE_MAP, map);
139:
140: /* Execute deletion hook. */
141: if (route_map_master.delete_hook)
142: (*route_map_master.delete_hook) (name);
143:
144: if (name)
145: XFREE (MTYPE_ROUTE_MAP_NAME, name);
146:
147: }
148:
149: /* Lookup route map by route map name string. */
150: struct route_map *
151: route_map_lookup_by_name (const char *name)
152: {
153: struct route_map *map;
154:
155: for (map = route_map_master.head; map; map = map->next)
156: if (strcmp (map->name, name) == 0)
157: return map;
158: return NULL;
159: }
160:
161: /* Lookup route map. If there isn't route map create one and return
162: it. */
163: static struct route_map *
164: route_map_get (const char *name)
165: {
166: struct route_map *map;
167:
168: map = route_map_lookup_by_name (name);
169: if (map == NULL)
170: map = route_map_add (name);
171: return map;
172: }
173:
174: /* Return route map's type string. */
175: static const char *
176: route_map_type_str (enum route_map_type type)
177: {
178: switch (type)
179: {
180: case RMAP_PERMIT:
181: return "permit";
182: break;
183: case RMAP_DENY:
184: return "deny";
185: break;
186: default:
187: return "";
188: break;
189: }
190: }
191:
192: static int
193: route_map_empty (struct route_map *map)
194: {
195: if (map->head == NULL && map->tail == NULL)
196: return 1;
197: else
198: return 0;
199: }
200:
201: /* show route-map */
202: static void
203: vty_show_route_map_entry (struct vty *vty, struct route_map *map)
204: {
205: struct route_map_index *index;
206: struct route_map_rule *rule;
207:
208: /* Print the name of the protocol */
209: if (zlog_default)
210: vty_out (vty, "%s:%s", zlog_proto_names[zlog_default->protocol],
211: VTY_NEWLINE);
212:
213: for (index = map->head; index; index = index->next)
214: {
215: vty_out (vty, "route-map %s, %s, sequence %d%s",
216: map->name, route_map_type_str (index->type),
217: index->pref, VTY_NEWLINE);
218:
219: /* Description */
220: if (index->description)
221: vty_out (vty, " Description:%s %s%s", VTY_NEWLINE,
222: index->description, VTY_NEWLINE);
223:
224: /* Match clauses */
225: vty_out (vty, " Match clauses:%s", VTY_NEWLINE);
226: for (rule = index->match_list.head; rule; rule = rule->next)
227: vty_out (vty, " %s %s%s",
228: rule->cmd->str, rule->rule_str, VTY_NEWLINE);
229:
230: vty_out (vty, " Set clauses:%s", VTY_NEWLINE);
231: for (rule = index->set_list.head; rule; rule = rule->next)
232: vty_out (vty, " %s %s%s",
233: rule->cmd->str, rule->rule_str, VTY_NEWLINE);
234:
235: /* Call clause */
236: vty_out (vty, " Call clause:%s", VTY_NEWLINE);
237: if (index->nextrm)
238: vty_out (vty, " Call %s%s", index->nextrm, VTY_NEWLINE);
239:
240: /* Exit Policy */
241: vty_out (vty, " Action:%s", VTY_NEWLINE);
242: if (index->exitpolicy == RMAP_GOTO)
243: vty_out (vty, " Goto %d%s", index->nextpref, VTY_NEWLINE);
244: else if (index->exitpolicy == RMAP_NEXT)
245: vty_out (vty, " Continue to next entry%s", VTY_NEWLINE);
246: else if (index->exitpolicy == RMAP_EXIT)
247: vty_out (vty, " Exit routemap%s", VTY_NEWLINE);
248: }
249: }
250:
251: static int
252: vty_show_route_map (struct vty *vty, const char *name)
253: {
254: struct route_map *map;
255:
256: if (name)
257: {
258: map = route_map_lookup_by_name (name);
259:
260: if (map)
261: {
262: vty_show_route_map_entry (vty, map);
263: return CMD_SUCCESS;
264: }
265: else
266: {
267: vty_out (vty, "%%route-map %s not found%s", name, VTY_NEWLINE);
268: return CMD_WARNING;
269: }
270: }
271: else
272: {
273: for (map = route_map_master.head; map; map = map->next)
274: vty_show_route_map_entry (vty, map);
275: }
276: return CMD_SUCCESS;
277: }
278:
279:
280: /* New route map allocation. Please note route map's name must be
281: specified. */
282: static struct route_map_index *
283: route_map_index_new (void)
284: {
285: struct route_map_index *new;
286:
287: new = XCALLOC (MTYPE_ROUTE_MAP_INDEX, sizeof (struct route_map_index));
288: new->exitpolicy = RMAP_EXIT; /* Default to Cisco-style */
289: return new;
290: }
291:
292: /* Free route map index. */
293: static void
294: route_map_index_delete (struct route_map_index *index, int notify)
295: {
296: struct route_map_rule *rule;
297:
298: /* Free route match. */
299: while ((rule = index->match_list.head) != NULL)
300: route_map_rule_delete (&index->match_list, rule);
301:
302: /* Free route set. */
303: while ((rule = index->set_list.head) != NULL)
304: route_map_rule_delete (&index->set_list, rule);
305:
306: /* Remove index from route map list. */
307: if (index->next)
308: index->next->prev = index->prev;
309: else
310: index->map->tail = index->prev;
311:
312: if (index->prev)
313: index->prev->next = index->next;
314: else
315: index->map->head = index->next;
316:
317: /* Free 'char *nextrm' if not NULL */
318: if (index->nextrm)
319: XFREE (MTYPE_ROUTE_MAP_NAME, index->nextrm);
320:
321: /* Execute event hook. */
322: if (route_map_master.event_hook && notify)
323: (*route_map_master.event_hook) (RMAP_EVENT_INDEX_DELETED,
324: index->map->name);
325:
326: XFREE (MTYPE_ROUTE_MAP_INDEX, index);
327: }
328:
329: /* Lookup index from route map. */
330: static struct route_map_index *
331: route_map_index_lookup (struct route_map *map, enum route_map_type type,
332: int pref)
333: {
334: struct route_map_index *index;
335:
336: for (index = map->head; index; index = index->next)
337: if ((index->type == type || type == RMAP_ANY)
338: && index->pref == pref)
339: return index;
340: return NULL;
341: }
342:
343: /* Add new index to route map. */
344: static struct route_map_index *
345: route_map_index_add (struct route_map *map, enum route_map_type type,
346: int pref)
347: {
348: struct route_map_index *index;
349: struct route_map_index *point;
350:
351: /* Allocate new route map inex. */
352: index = route_map_index_new ();
353: index->map = map;
354: index->type = type;
355: index->pref = pref;
356:
357: /* Compare preference. */
358: for (point = map->head; point; point = point->next)
359: if (point->pref >= pref)
360: break;
361:
362: if (map->head == NULL)
363: {
364: map->head = map->tail = index;
365: }
366: else if (point == NULL)
367: {
368: index->prev = map->tail;
369: map->tail->next = index;
370: map->tail = index;
371: }
372: else if (point == map->head)
373: {
374: index->next = map->head;
375: map->head->prev = index;
376: map->head = index;
377: }
378: else
379: {
380: index->next = point;
381: index->prev = point->prev;
382: if (point->prev)
383: point->prev->next = index;
384: point->prev = index;
385: }
386:
387: /* Execute event hook. */
388: if (route_map_master.event_hook)
389: (*route_map_master.event_hook) (RMAP_EVENT_INDEX_ADDED,
390: map->name);
391:
392: return index;
393: }
394:
395: /* Get route map index. */
396: static struct route_map_index *
397: route_map_index_get (struct route_map *map, enum route_map_type type,
398: int pref)
399: {
400: struct route_map_index *index;
401:
402: index = route_map_index_lookup (map, RMAP_ANY, pref);
403: if (index && index->type != type)
404: {
405: /* Delete index from route map. */
406: route_map_index_delete (index, 1);
407: index = NULL;
408: }
409: if (index == NULL)
410: index = route_map_index_add (map, type, pref);
411: return index;
412: }
413:
414: /* New route map rule */
415: static struct route_map_rule *
416: route_map_rule_new (void)
417: {
418: struct route_map_rule *new;
419:
420: new = XCALLOC (MTYPE_ROUTE_MAP_RULE, sizeof (struct route_map_rule));
421: return new;
422: }
423:
424: /* Install rule command to the match list. */
425: void
426: route_map_install_match (struct route_map_rule_cmd *cmd)
427: {
428: vector_set (route_match_vec, cmd);
429: }
430:
431: /* Install rule command to the set list. */
432: void
433: route_map_install_set (struct route_map_rule_cmd *cmd)
434: {
435: vector_set (route_set_vec, cmd);
436: }
437:
438: /* Lookup rule command from match list. */
439: static struct route_map_rule_cmd *
440: route_map_lookup_match (const char *name)
441: {
442: unsigned int i;
443: struct route_map_rule_cmd *rule;
444:
445: for (i = 0; i < vector_active (route_match_vec); i++)
446: if ((rule = vector_slot (route_match_vec, i)) != NULL)
447: if (strcmp (rule->str, name) == 0)
448: return rule;
449: return NULL;
450: }
451:
452: /* Lookup rule command from set list. */
453: static struct route_map_rule_cmd *
454: route_map_lookup_set (const char *name)
455: {
456: unsigned int i;
457: struct route_map_rule_cmd *rule;
458:
459: for (i = 0; i < vector_active (route_set_vec); i++)
460: if ((rule = vector_slot (route_set_vec, i)) != NULL)
461: if (strcmp (rule->str, name) == 0)
462: return rule;
463: return NULL;
464: }
465:
466: /* Add match and set rule to rule list. */
467: static void
468: route_map_rule_add (struct route_map_rule_list *list,
469: struct route_map_rule *rule)
470: {
471: rule->next = NULL;
472: rule->prev = list->tail;
473: if (list->tail)
474: list->tail->next = rule;
475: else
476: list->head = rule;
477: list->tail = rule;
478: }
479:
480: /* Delete rule from rule list. */
481: static void
482: route_map_rule_delete (struct route_map_rule_list *list,
483: struct route_map_rule *rule)
484: {
485: if (rule->cmd->func_free)
486: (*rule->cmd->func_free) (rule->value);
487:
488: if (rule->rule_str)
489: XFREE (MTYPE_ROUTE_MAP_RULE_STR, rule->rule_str);
490:
491: if (rule->next)
492: rule->next->prev = rule->prev;
493: else
494: list->tail = rule->prev;
495: if (rule->prev)
496: rule->prev->next = rule->next;
497: else
498: list->head = rule->next;
499:
500: XFREE (MTYPE_ROUTE_MAP_RULE, rule);
501: }
502:
503: /* strcmp wrapper function which don't crush even argument is NULL. */
504: static int
505: rulecmp (const char *dst, const char *src)
506: {
507: if (dst == NULL)
508: {
509: if (src == NULL)
510: return 0;
511: else
512: return 1;
513: }
514: else
515: {
516: if (src == NULL)
517: return 1;
518: else
519: return strcmp (dst, src);
520: }
521: return 1;
522: }
523:
524: /* Add match statement to route map. */
525: int
526: route_map_add_match (struct route_map_index *index, const char *match_name,
527: const char *match_arg)
528: {
529: struct route_map_rule *rule;
530: struct route_map_rule *next;
531: struct route_map_rule_cmd *cmd;
532: void *compile;
533: int replaced = 0;
534:
535: /* First lookup rule for add match statement. */
536: cmd = route_map_lookup_match (match_name);
537: if (cmd == NULL)
538: return RMAP_RULE_MISSING;
539:
540: /* Next call compile function for this match statement. */
541: if (cmd->func_compile)
542: {
543: compile= (*cmd->func_compile)(match_arg);
544: if (compile == NULL)
545: return RMAP_COMPILE_ERROR;
546: }
547: else
548: compile = NULL;
549:
550: /* If argument is completely same ignore it. */
551: for (rule = index->match_list.head; rule; rule = next)
552: {
553: next = rule->next;
554: if (rule->cmd == cmd)
555: {
556: route_map_rule_delete (&index->match_list, rule);
557: replaced = 1;
558: }
559: }
560:
561: /* Add new route map match rule. */
562: rule = route_map_rule_new ();
563: rule->cmd = cmd;
564: rule->value = compile;
565: if (match_arg)
566: rule->rule_str = XSTRDUP (MTYPE_ROUTE_MAP_RULE_STR, match_arg);
567: else
568: rule->rule_str = NULL;
569:
570: /* Add new route match rule to linked list. */
571: route_map_rule_add (&index->match_list, rule);
572:
573: /* Execute event hook. */
574: if (route_map_master.event_hook)
575: (*route_map_master.event_hook) (replaced ?
576: RMAP_EVENT_MATCH_REPLACED:
577: RMAP_EVENT_MATCH_ADDED,
578: index->map->name);
579:
580: return 0;
581: }
582:
583: /* Delete specified route match rule. */
584: int
585: route_map_delete_match (struct route_map_index *index, const char *match_name,
586: const char *match_arg)
587: {
588: struct route_map_rule *rule;
589: struct route_map_rule_cmd *cmd;
590:
591: cmd = route_map_lookup_match (match_name);
592: if (cmd == NULL)
593: return 1;
594:
595: for (rule = index->match_list.head; rule; rule = rule->next)
596: if (rule->cmd == cmd &&
597: (rulecmp (rule->rule_str, match_arg) == 0 || match_arg == NULL))
598: {
599: route_map_rule_delete (&index->match_list, rule);
600: /* Execute event hook. */
601: if (route_map_master.event_hook)
602: (*route_map_master.event_hook) (RMAP_EVENT_MATCH_DELETED,
603: index->map->name);
604: return 0;
605: }
606: /* Can't find matched rule. */
607: return 1;
608: }
609:
610: /* Add route-map set statement to the route map. */
611: int
612: route_map_add_set (struct route_map_index *index, const char *set_name,
613: const char *set_arg)
614: {
615: struct route_map_rule *rule;
616: struct route_map_rule *next;
617: struct route_map_rule_cmd *cmd;
618: void *compile;
619: int replaced = 0;
620:
621: cmd = route_map_lookup_set (set_name);
622: if (cmd == NULL)
623: return RMAP_RULE_MISSING;
624:
625: /* Next call compile function for this match statement. */
626: if (cmd->func_compile)
627: {
628: compile= (*cmd->func_compile)(set_arg);
629: if (compile == NULL)
630: return RMAP_COMPILE_ERROR;
631: }
632: else
633: compile = NULL;
634:
635: /* Add by WJL. if old set command of same kind exist, delete it first
636: to ensure only one set command of same kind exist under a
637: route_map_index. */
638: for (rule = index->set_list.head; rule; rule = next)
639: {
640: next = rule->next;
641: if (rule->cmd == cmd)
642: {
643: route_map_rule_delete (&index->set_list, rule);
644: replaced = 1;
645: }
646: }
647:
648: /* Add new route map match rule. */
649: rule = route_map_rule_new ();
650: rule->cmd = cmd;
651: rule->value = compile;
652: if (set_arg)
653: rule->rule_str = XSTRDUP (MTYPE_ROUTE_MAP_RULE_STR, set_arg);
654: else
655: rule->rule_str = NULL;
656:
657: /* Add new route match rule to linked list. */
658: route_map_rule_add (&index->set_list, rule);
659:
660: /* Execute event hook. */
661: if (route_map_master.event_hook)
662: (*route_map_master.event_hook) (replaced ?
663: RMAP_EVENT_SET_REPLACED:
664: RMAP_EVENT_SET_ADDED,
665: index->map->name);
666: return 0;
667: }
668:
669: /* Delete route map set rule. */
670: int
671: route_map_delete_set (struct route_map_index *index, const char *set_name,
672: const char *set_arg)
673: {
674: struct route_map_rule *rule;
675: struct route_map_rule_cmd *cmd;
676:
677: cmd = route_map_lookup_set (set_name);
678: if (cmd == NULL)
679: return 1;
680:
681: for (rule = index->set_list.head; rule; rule = rule->next)
682: if ((rule->cmd == cmd) &&
683: (rulecmp (rule->rule_str, set_arg) == 0 || set_arg == NULL))
684: {
685: route_map_rule_delete (&index->set_list, rule);
686: /* Execute event hook. */
687: if (route_map_master.event_hook)
688: (*route_map_master.event_hook) (RMAP_EVENT_SET_DELETED,
689: index->map->name);
690: return 0;
691: }
692: /* Can't find matched rule. */
693: return 1;
694: }
695:
696: /* Apply route map's each index to the object.
697:
698: The matrix for a route-map looks like this:
699: (note, this includes the description for the "NEXT"
700: and "GOTO" frobs now
701:
702: Match | No Match
703: |
704: permit action | cont
705: |
706: ------------------+---------------
707: |
708: deny deny | cont
709: |
710:
711: action)
712: -Apply Set statements, accept route
713: -If Call statement is present jump to the specified route-map, if it
714: denies the route we finish.
715: -If NEXT is specified, goto NEXT statement
716: -If GOTO is specified, goto the first clause where pref > nextpref
717: -If nothing is specified, do as Cisco and finish
718: deny)
719: -Route is denied by route-map.
720: cont)
721: -Goto Next index
722:
723: If we get no matches after we've processed all updates, then the route
724: is dropped too.
725:
726: Some notes on the new "CALL", "NEXT" and "GOTO"
727: call WORD - If this clause is matched, then the set statements
728: are executed and then we jump to route-map 'WORD'. If
729: this route-map denies the route, we finish, in other case we
730: do whatever the exit policy (EXIT, NEXT or GOTO) tells.
731: on-match next - If this clause is matched, then the set statements
732: are executed and then we drop through to the next clause
733: on-match goto n - If this clause is matched, then the set statments
734: are executed and then we goto the nth clause, or the
735: first clause greater than this. In order to ensure
736: route-maps *always* exit, you cannot jump backwards.
737: Sorry ;)
738:
739: We need to make sure our route-map processing matches the above
740: */
741:
742: static route_map_result_t
743: route_map_apply_match (struct route_map_rule_list *match_list,
744: struct prefix *prefix, route_map_object_t type,
745: void *object)
746: {
747: route_map_result_t ret = RMAP_NOMATCH;
748: struct route_map_rule *match;
749:
750:
751: /* Check all match rule and if there is no match rule, go to the
752: set statement. */
753: if (!match_list->head)
754: ret = RMAP_MATCH;
755: else
756: {
757: for (match = match_list->head; match; match = match->next)
758: {
759: /* Try each match statement in turn, If any do not return
760: RMAP_MATCH, return, otherwise continue on to next match
761: statement. All match statements must match for end-result
762: to be a match. */
763: ret = (*match->cmd->func_apply) (match->value, prefix,
764: type, object);
765: if (ret != RMAP_MATCH)
766: return ret;
767: }
768: }
769: return ret;
770: }
771:
772: /* Apply route map to the object. */
773: route_map_result_t
774: route_map_apply (struct route_map *map, struct prefix *prefix,
775: route_map_object_t type, void *object)
776: {
777: static int recursion = 0;
778: int ret = 0;
779: struct route_map_index *index;
780: struct route_map_rule *set;
781:
782: if (recursion > RMAP_RECURSION_LIMIT)
783: {
784: zlog (NULL, LOG_WARNING,
785: "route-map recursion limit (%d) reached, discarding route",
786: RMAP_RECURSION_LIMIT);
787: recursion = 0;
788: return RMAP_DENYMATCH;
789: }
790:
791: if (map == NULL)
792: return RMAP_DENYMATCH;
793:
794: for (index = map->head; index; index = index->next)
795: {
796: /* Apply this index. */
797: ret = route_map_apply_match (&index->match_list, prefix, type, object);
798:
799: /* Now we apply the matrix from above */
800: if (ret == RMAP_NOMATCH)
801: /* 'cont' from matrix - continue to next route-map sequence */
802: continue;
803: else if (ret == RMAP_MATCH)
804: {
805: if (index->type == RMAP_PERMIT)
806: /* 'action' */
807: {
808: /* permit+match must execute sets */
809: for (set = index->set_list.head; set; set = set->next)
810: ret = (*set->cmd->func_apply) (set->value, prefix,
811: type, object);
812:
813: /* Call another route-map if available */
814: if (index->nextrm)
815: {
816: struct route_map *nextrm =
817: route_map_lookup_by_name (index->nextrm);
818:
819: if (nextrm) /* Target route-map found, jump to it */
820: {
821: recursion++;
822: ret = route_map_apply (nextrm, prefix, type, object);
823: recursion--;
824: }
825:
826: /* If nextrm returned 'deny', finish. */
827: if (ret == RMAP_DENYMATCH)
828: return ret;
829: }
830:
831: switch (index->exitpolicy)
832: {
833: case RMAP_EXIT:
834: return ret;
835: case RMAP_NEXT:
836: continue;
837: case RMAP_GOTO:
838: {
839: /* Find the next clause to jump to */
840: struct route_map_index *next = index->next;
841: int nextpref = index->nextpref;
842:
843: while (next && next->pref < nextpref)
844: {
845: index = next;
846: next = next->next;
847: }
848: if (next == NULL)
849: {
850: /* No clauses match! */
851: return ret;
852: }
853: }
854: }
855: }
856: else if (index->type == RMAP_DENY)
857: /* 'deny' */
858: {
859: return RMAP_DENYMATCH;
860: }
861: }
862: }
863: /* Finally route-map does not match at all. */
864: return RMAP_DENYMATCH;
865: }
866:
867: void
868: route_map_add_hook (void (*func) (const char *))
869: {
870: route_map_master.add_hook = func;
871: }
872:
873: void
874: route_map_delete_hook (void (*func) (const char *))
875: {
876: route_map_master.delete_hook = func;
877: }
878:
879: void
880: route_map_event_hook (void (*func) (route_map_event_t, const char *))
881: {
882: route_map_master.event_hook = func;
883: }
884:
885: void
886: route_map_init (void)
887: {
888: /* Make vector for match and set. */
889: route_match_vec = vector_init (1);
890: route_set_vec = vector_init (1);
891: }
892:
893: void
894: route_map_finish (void)
895: {
896: vector_free (route_match_vec);
897: route_match_vec = NULL;
898: vector_free (route_set_vec);
899: route_set_vec = NULL;
900: /* cleanup route_map */
901: while (route_map_master.head)
902: route_map_delete (route_map_master.head);
903: }
904:
905: /* VTY related functions. */
906: DEFUN (route_map,
907: route_map_cmd,
908: "route-map WORD (deny|permit) <1-65535>",
909: "Create route-map or enter route-map command mode\n"
910: "Route map tag\n"
911: "Route map denies set operations\n"
912: "Route map permits set operations\n"
913: "Sequence to insert to/delete from existing route-map entry\n")
914: {
915: int permit;
916: unsigned long pref;
917: struct route_map *map;
918: struct route_map_index *index;
919: char *endptr = NULL;
920:
921: /* Permit check. */
922: if (strncmp (argv[1], "permit", strlen (argv[1])) == 0)
923: permit = RMAP_PERMIT;
924: else if (strncmp (argv[1], "deny", strlen (argv[1])) == 0)
925: permit = RMAP_DENY;
926: else
927: {
928: vty_out (vty, "the third field must be [permit|deny]%s", VTY_NEWLINE);
929: return CMD_WARNING;
930: }
931:
932: /* Preference check. */
933: pref = strtoul (argv[2], &endptr, 10);
934: if (pref == ULONG_MAX || *endptr != '\0')
935: {
936: vty_out (vty, "the fourth field must be positive integer%s",
937: VTY_NEWLINE);
938: return CMD_WARNING;
939: }
940: if (pref == 0 || pref > 65535)
941: {
942: vty_out (vty, "the fourth field must be <1-65535>%s", VTY_NEWLINE);
943: return CMD_WARNING;
944: }
945:
946: /* Get route map. */
947: map = route_map_get (argv[0]);
948: index = route_map_index_get (map, permit, pref);
949:
950: vty->index = index;
951: vty->node = RMAP_NODE;
952: return CMD_SUCCESS;
953: }
954:
955: DEFUN (no_route_map_all,
956: no_route_map_all_cmd,
957: "no route-map WORD",
958: NO_STR
959: "Create route-map or enter route-map command mode\n"
960: "Route map tag\n")
961: {
962: struct route_map *map;
963:
964: map = route_map_lookup_by_name (argv[0]);
965: if (map == NULL)
966: {
967: vty_out (vty, "%% Could not find route-map %s%s",
968: argv[0], VTY_NEWLINE);
969: return CMD_WARNING;
970: }
971:
972: route_map_delete (map);
973:
974: return CMD_SUCCESS;
975: }
976:
977: DEFUN (no_route_map,
978: no_route_map_cmd,
979: "no route-map WORD (deny|permit) <1-65535>",
980: NO_STR
981: "Create route-map or enter route-map command mode\n"
982: "Route map tag\n"
983: "Route map denies set operations\n"
984: "Route map permits set operations\n"
985: "Sequence to insert to/delete from existing route-map entry\n")
986: {
987: int permit;
988: unsigned long pref;
989: struct route_map *map;
990: struct route_map_index *index;
991: char *endptr = NULL;
992:
993: /* Permit check. */
994: if (strncmp (argv[1], "permit", strlen (argv[1])) == 0)
995: permit = RMAP_PERMIT;
996: else if (strncmp (argv[1], "deny", strlen (argv[1])) == 0)
997: permit = RMAP_DENY;
998: else
999: {
1000: vty_out (vty, "the third field must be [permit|deny]%s", VTY_NEWLINE);
1001: return CMD_WARNING;
1002: }
1003:
1004: /* Preference. */
1005: pref = strtoul (argv[2], &endptr, 10);
1006: if (pref == ULONG_MAX || *endptr != '\0')
1007: {
1008: vty_out (vty, "the fourth field must be positive integer%s",
1009: VTY_NEWLINE);
1010: return CMD_WARNING;
1011: }
1012: if (pref == 0 || pref > 65535)
1013: {
1014: vty_out (vty, "the fourth field must be <1-65535>%s", VTY_NEWLINE);
1015: return CMD_WARNING;
1016: }
1017:
1018: /* Existence check. */
1019: map = route_map_lookup_by_name (argv[0]);
1020: if (map == NULL)
1021: {
1022: vty_out (vty, "%% Could not find route-map %s%s",
1023: argv[0], VTY_NEWLINE);
1024: return CMD_WARNING;
1025: }
1026:
1027: /* Lookup route map index. */
1028: index = route_map_index_lookup (map, permit, pref);
1029: if (index == NULL)
1030: {
1031: vty_out (vty, "%% Could not find route-map entry %s %s%s",
1032: argv[0], argv[2], VTY_NEWLINE);
1033: return CMD_WARNING;
1034: }
1035:
1036: /* Delete index from route map. */
1037: route_map_index_delete (index, 1);
1038:
1039: /* If this route rule is the last one, delete route map itself. */
1040: if (route_map_empty (map))
1041: route_map_delete (map);
1042:
1043: return CMD_SUCCESS;
1044: }
1045:
1046: DEFUN (rmap_onmatch_next,
1047: rmap_onmatch_next_cmd,
1048: "on-match next",
1049: "Exit policy on matches\n"
1050: "Next clause\n")
1051: {
1052: struct route_map_index *index;
1053:
1054: index = vty->index;
1055:
1056: if (index)
1057: index->exitpolicy = RMAP_NEXT;
1058:
1059: return CMD_SUCCESS;
1060: }
1061:
1062: DEFUN (no_rmap_onmatch_next,
1063: no_rmap_onmatch_next_cmd,
1064: "no on-match next",
1065: NO_STR
1066: "Exit policy on matches\n"
1067: "Next clause\n")
1068: {
1069: struct route_map_index *index;
1070:
1071: index = vty->index;
1072:
1073: if (index)
1074: index->exitpolicy = RMAP_EXIT;
1075:
1076: return CMD_SUCCESS;
1077: }
1078:
1079: DEFUN (rmap_onmatch_goto,
1080: rmap_onmatch_goto_cmd,
1081: "on-match goto <1-65535>",
1082: "Exit policy on matches\n"
1083: "Goto Clause number\n"
1084: "Number\n")
1085: {
1086: struct route_map_index *index = vty->index;
1087: int d = 0;
1088:
1089: if (index)
1090: {
1091: if (argc == 1 && argv[0])
1092: VTY_GET_INTEGER_RANGE("route-map index", d, argv[0], 1, 65536);
1093: else
1094: d = index->pref + 1;
1095:
1096: if (d <= index->pref)
1097: {
1098: /* Can't allow you to do that, Dave */
1099: vty_out (vty, "can't jump backwards in route-maps%s",
1100: VTY_NEWLINE);
1101: return CMD_WARNING;
1102: }
1103: else
1104: {
1105: index->exitpolicy = RMAP_GOTO;
1106: index->nextpref = d;
1107: }
1108: }
1109: return CMD_SUCCESS;
1110: }
1111:
1112: DEFUN (no_rmap_onmatch_goto,
1113: no_rmap_onmatch_goto_cmd,
1114: "no on-match goto",
1115: NO_STR
1116: "Exit policy on matches\n"
1117: "Goto Clause number\n")
1118: {
1119: struct route_map_index *index;
1120:
1121: index = vty->index;
1122:
1123: if (index)
1124: index->exitpolicy = RMAP_EXIT;
1125:
1126: return CMD_SUCCESS;
1127: }
1128:
1129: /* Cisco/GNU Zebra compatible ALIASes for on-match next */
1130: ALIAS (rmap_onmatch_goto,
1131: rmap_continue_cmd,
1132: "continue",
1133: "Continue on a different entry within the route-map\n")
1134:
1135: ALIAS (no_rmap_onmatch_goto,
1136: no_rmap_continue_cmd,
1137: "no continue",
1138: NO_STR
1139: "Continue on a different entry within the route-map\n")
1140:
1141: /* GNU Zebra compatible */
1142: ALIAS (rmap_onmatch_goto,
1143: rmap_continue_seq_cmd,
1144: "continue <1-65535>",
1145: "Continue on a different entry within the route-map\n"
1146: "Route-map entry sequence number\n")
1147:
1148: ALIAS (no_rmap_onmatch_goto,
1149: no_rmap_continue_seq,
1150: "no continue <1-65535>",
1151: NO_STR
1152: "Continue on a different entry within the route-map\n"
1153: "Route-map entry sequence number\n")
1154:
1155: DEFUN (rmap_show_name,
1156: rmap_show_name_cmd,
1157: "show route-map [WORD]",
1158: SHOW_STR
1159: "route-map information\n"
1160: "route-map name\n")
1161: {
1162: const char *name = NULL;
1163: if (argc)
1164: name = argv[0];
1165: return vty_show_route_map (vty, name);
1166: }
1167:
1168: ALIAS (rmap_onmatch_goto,
1169: rmap_continue_index_cmd,
1170: "continue <1-65536>",
1171: "Exit policy on matches\n"
1172: "Goto Clause number\n")
1173:
1174: DEFUN (rmap_call,
1175: rmap_call_cmd,
1176: "call WORD",
1177: "Jump to another Route-Map after match+set\n"
1178: "Target route-map name\n")
1179: {
1180: struct route_map_index *index;
1181:
1182: index = vty->index;
1183: if (index)
1184: {
1185: if (index->nextrm)
1186: XFREE (MTYPE_ROUTE_MAP_NAME, index->nextrm);
1187: index->nextrm = XSTRDUP (MTYPE_ROUTE_MAP_NAME, argv[0]);
1188: }
1189: return CMD_SUCCESS;
1190: }
1191:
1192: DEFUN (no_rmap_call,
1193: no_rmap_call_cmd,
1194: "no call",
1195: NO_STR
1196: "Jump to another Route-Map after match+set\n")
1197: {
1198: struct route_map_index *index;
1199:
1200: index = vty->index;
1201:
1202: if (index->nextrm)
1203: {
1204: XFREE (MTYPE_ROUTE_MAP_NAME, index->nextrm);
1205: index->nextrm = NULL;
1206: }
1207:
1208: return CMD_SUCCESS;
1209: }
1210:
1211: DEFUN (rmap_description,
1212: rmap_description_cmd,
1213: "description .LINE",
1214: "Route-map comment\n"
1215: "Comment describing this route-map rule\n")
1216: {
1217: struct route_map_index *index;
1218:
1219: index = vty->index;
1220: if (index)
1221: {
1222: if (index->description)
1223: XFREE (MTYPE_TMP, index->description);
1224: index->description = argv_concat (argv, argc, 0);
1225: }
1226: return CMD_SUCCESS;
1227: }
1228:
1229: DEFUN (no_rmap_description,
1230: no_rmap_description_cmd,
1231: "no description",
1232: NO_STR
1233: "Route-map comment\n")
1234: {
1235: struct route_map_index *index;
1236:
1237: index = vty->index;
1238: if (index)
1239: {
1240: if (index->description)
1241: XFREE (MTYPE_TMP, index->description);
1242: index->description = NULL;
1243: }
1244: return CMD_SUCCESS;
1245: }
1246:
1247: /* Configuration write function. */
1248: static int
1249: route_map_config_write (struct vty *vty)
1250: {
1251: struct route_map *map;
1252: struct route_map_index *index;
1253: struct route_map_rule *rule;
1254: int first = 1;
1255: int write = 0;
1256:
1257: for (map = route_map_master.head; map; map = map->next)
1258: for (index = map->head; index; index = index->next)
1259: {
1260: if (!first)
1261: vty_out (vty, "!%s", VTY_NEWLINE);
1262: else
1263: first = 0;
1264:
1265: vty_out (vty, "route-map %s %s %d%s",
1266: map->name,
1267: route_map_type_str (index->type),
1268: index->pref, VTY_NEWLINE);
1269:
1270: if (index->description)
1271: vty_out (vty, " description %s%s", index->description, VTY_NEWLINE);
1272:
1273: for (rule = index->match_list.head; rule; rule = rule->next)
1274: vty_out (vty, " match %s %s%s", rule->cmd->str,
1275: rule->rule_str ? rule->rule_str : "",
1276: VTY_NEWLINE);
1277:
1278: for (rule = index->set_list.head; rule; rule = rule->next)
1279: vty_out (vty, " set %s %s%s", rule->cmd->str,
1280: rule->rule_str ? rule->rule_str : "",
1281: VTY_NEWLINE);
1282: if (index->nextrm)
1283: vty_out (vty, " call %s%s", index->nextrm, VTY_NEWLINE);
1284: if (index->exitpolicy == RMAP_GOTO)
1285: vty_out (vty, " on-match goto %d%s", index->nextpref, VTY_NEWLINE);
1286: if (index->exitpolicy == RMAP_NEXT)
1287: vty_out (vty," on-match next%s", VTY_NEWLINE);
1288:
1289: write++;
1290: }
1291: return write;
1292: }
1293:
1294: /* Route map node structure. */
1295: static struct cmd_node rmap_node =
1296: {
1297: RMAP_NODE,
1298: "%s(config-route-map)# ",
1299: 1
1300: };
1301:
1302: /* Initialization of route map vector. */
1303: void
1304: route_map_init_vty (void)
1305: {
1306: /* Install route map top node. */
1307: install_node (&rmap_node, route_map_config_write);
1308:
1309: /* Install route map commands. */
1310: install_default (RMAP_NODE);
1311: install_element (CONFIG_NODE, &route_map_cmd);
1312: install_element (CONFIG_NODE, &no_route_map_cmd);
1313: install_element (CONFIG_NODE, &no_route_map_all_cmd);
1314:
1315: /* Install the on-match stuff */
1316: install_element (RMAP_NODE, &route_map_cmd);
1317: install_element (RMAP_NODE, &rmap_onmatch_next_cmd);
1318: install_element (RMAP_NODE, &no_rmap_onmatch_next_cmd);
1319: install_element (RMAP_NODE, &rmap_onmatch_goto_cmd);
1320: install_element (RMAP_NODE, &no_rmap_onmatch_goto_cmd);
1321:
1322: /* Install the continue stuff (ALIAS of on-match). */
1323: install_element (RMAP_NODE, &rmap_continue_cmd);
1324: install_element (RMAP_NODE, &no_rmap_continue_cmd);
1325: install_element (RMAP_NODE, &rmap_continue_index_cmd);
1326:
1327: /* Install the call stuff. */
1328: install_element (RMAP_NODE, &rmap_call_cmd);
1329: install_element (RMAP_NODE, &no_rmap_call_cmd);
1330:
1331: /* Install description commands. */
1332: install_element (RMAP_NODE, &rmap_description_cmd);
1333: install_element (RMAP_NODE, &no_rmap_description_cmd);
1334:
1335: /* Install show command */
1336: install_element (ENABLE_NODE, &rmap_show_name_cmd);
1337: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to 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 / lib