1: /*
2: * Route map function of ospfd.
3: * Copyright (C) 2000 IP Infusion Inc.
4: *
5: * Written by Toshiaki Takada.
6: *
7: * This file is part of GNU Zebra.
8: *
9: * GNU Zebra is free software; you can redistribute it and/or modify it
10: * under the terms of the GNU General Public License as published by the
11: * Free Software Foundation; either version 2, or (at your option) any
12: * later version.
13: *
14: * GNU Zebra is distributed in the hope that it will be useful, but
15: * WITHOUT ANY WARRANTY; without even the implied warranty of
16: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17: * General Public License for more details.
18: *
19: * You should have received a copy of the GNU General Public License
20: * along with GNU Zebra; see the file COPYING. If not, write to the Free
21: * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
22: * 02111-1307, USA.
23: */
24:
25: #include <zebra.h>
26:
27: #include "memory.h"
28: #include "prefix.h"
29: #include "table.h"
30: #include "routemap.h"
31: #include "command.h"
32: #include "log.h"
33: #include "plist.h"
34:
35: #include "ospfd/ospfd.h"
36: #include "ospfd/ospf_asbr.h"
37: #include "ospfd/ospf_interface.h"
38: #include "ospfd/ospf_lsa.h"
39: #include "ospfd/ospf_route.h"
40: #include "ospfd/ospf_zebra.h"
41:
42: /* Hook function for updating route_map assignment. */
43: static void
44: ospf_route_map_update (const char *name)
45: {
46: struct ospf *ospf;
47: int type;
48:
49: /* If OSPF instatnce does not exist, return right now. */
50: ospf = ospf_lookup ();
51: if (ospf == NULL)
52: return;
53:
54: /* Update route-map */
55: for (type = 0; type <= ZEBRA_ROUTE_MAX; type++)
56: {
57: if (ROUTEMAP_NAME (ospf, type)
58: && strcmp (ROUTEMAP_NAME (ospf, type), name) == 0)
59: {
60: /* Keep old route-map. */
61: struct route_map *old = ROUTEMAP (ospf, type);
62:
63: /* Update route-map. */
64: ROUTEMAP (ospf, type) =
65: route_map_lookup_by_name (ROUTEMAP_NAME (ospf, type));
66:
67: /* No update for this distribute type. */
68: if (old == NULL && ROUTEMAP (ospf, type) == NULL)
69: continue;
70:
71: ospf_distribute_list_update (ospf, type);
72: }
73: }
74: }
75:
76: static void
77: ospf_route_map_event (route_map_event_t event, const char *name)
78: {
79: struct ospf *ospf;
80: int type;
81:
82: /* If OSPF instatnce does not exist, return right now. */
83: ospf = ospf_lookup ();
84: if (ospf == NULL)
85: return;
86:
87: /* Update route-map. */
88: for (type = 0; type <= ZEBRA_ROUTE_MAX; type++)
89: {
90: if (ROUTEMAP_NAME (ospf, type) && ROUTEMAP (ospf, type)
91: && !strcmp (ROUTEMAP_NAME (ospf, type), name))
92: {
93: ospf_distribute_list_update (ospf, type);
94: }
95: }
96: }
97:
98: /* Delete rip route map rule. */
99: static int
100: ospf_route_match_delete (struct vty *vty, struct route_map_index *index,
101: const char *command, const char *arg)
102: {
103: int ret;
104:
105: ret = route_map_delete_match (index, command, arg);
106: if (ret)
107: {
108: switch (ret)
109: {
110: case RMAP_RULE_MISSING:
111: vty_out (vty, "%% Can't find rule.%s", VTY_NEWLINE);
112: return CMD_WARNING;
113: case RMAP_COMPILE_ERROR:
114: vty_out (vty, "%% Argument is malformed.%s", VTY_NEWLINE);
115: return CMD_WARNING;
116: }
117: }
118:
119: return CMD_SUCCESS;
120: }
121:
122: static int
123: ospf_route_match_add (struct vty *vty, struct route_map_index *index,
124: const char *command, const char *arg)
125: {
126: int ret;
127:
128: ret = route_map_add_match (index, command, arg);
129: if (ret)
130: {
131: switch (ret)
132: {
133: case RMAP_RULE_MISSING:
134: vty_out (vty, "%% Can't find rule.%s", VTY_NEWLINE);
135: return CMD_WARNING;
136: case RMAP_COMPILE_ERROR:
137: vty_out (vty, "%% Argument is malformed.%s", VTY_NEWLINE);
138: return CMD_WARNING;
139: }
140: }
141:
142: return CMD_SUCCESS;
143: }
144:
145: static int
146: ospf_route_set_add (struct vty *vty, struct route_map_index *index,
147: const char *command, const char *arg)
148: {
149: int ret;
150:
151: ret = route_map_add_set (index, command, arg);
152: if (ret)
153: {
154: switch (ret)
155: {
156: case RMAP_RULE_MISSING:
157: vty_out (vty, "%% Can't find rule.%s", VTY_NEWLINE);
158: return CMD_WARNING;
159: case RMAP_COMPILE_ERROR:
160: vty_out (vty, "%% Argument is malformed.%s", VTY_NEWLINE);
161: return CMD_WARNING;
162: }
163: }
164:
165: return CMD_SUCCESS;
166: }
167:
168: /* Delete rip route map rule. */
169: static int
170: ospf_route_set_delete (struct vty *vty, struct route_map_index *index,
171: const char *command, const char *arg)
172: {
173: int ret;
174:
175: ret = route_map_delete_set (index, command, arg);
176: if (ret)
177: {
178: switch (ret)
179: {
180: case RMAP_RULE_MISSING:
181: vty_out (vty, "%% Can't find rule.%s", VTY_NEWLINE);
182: return CMD_WARNING;
183: case RMAP_COMPILE_ERROR:
184: vty_out (vty, "%% Argument is malformed.%s", VTY_NEWLINE);
185: return CMD_WARNING;
186: }
187: }
188:
189: return CMD_SUCCESS;
190: }
191:
192: /* `match ip netxthop ' */
193: /* Match function return 1 if match is success else return zero. */
194: static route_map_result_t
195: route_match_ip_nexthop (void *rule, struct prefix *prefix,
196: route_map_object_t type, void *object)
197: {
198: struct access_list *alist;
199: struct external_info *ei = object;
200: struct prefix_ipv4 p;
201:
202: if (type == RMAP_OSPF)
203: {
204: p.family = AF_INET;
205: p.prefix = ei->nexthop;
206: p.prefixlen = IPV4_MAX_BITLEN;
207:
208: alist = access_list_lookup (AFI_IP, (char *) rule);
209: if (alist == NULL)
210: return RMAP_NOMATCH;
211:
212: return (access_list_apply (alist, &p) == FILTER_DENY ?
213: RMAP_NOMATCH : RMAP_MATCH);
214: }
215: return RMAP_NOMATCH;
216: }
217:
218: /* Route map `ip next-hop' match statement. `arg' should be
219: access-list name. */
220: static void *
221: route_match_ip_nexthop_compile (const char *arg)
222: {
223: return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
224: }
225:
226: /* Free route map's compiled `ip address' value. */
227: static void
228: route_match_ip_nexthop_free (void *rule)
229: {
230: XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
231: }
232:
233: /* Route map commands for metric matching. */
234: struct route_map_rule_cmd route_match_ip_nexthop_cmd =
235: {
236: "ip next-hop",
237: route_match_ip_nexthop,
238: route_match_ip_nexthop_compile,
239: route_match_ip_nexthop_free
240: };
241:
242: /* `match ip next-hop prefix-list PREFIX_LIST' */
243:
244: static route_map_result_t
245: route_match_ip_next_hop_prefix_list (void *rule, struct prefix *prefix,
246: route_map_object_t type, void *object)
247: {
248: struct prefix_list *plist;
249: struct external_info *ei = object;
250: struct prefix_ipv4 p;
251:
252: if (type == RMAP_OSPF)
253: {
254: p.family = AF_INET;
255: p.prefix = ei->nexthop;
256: p.prefixlen = IPV4_MAX_BITLEN;
257:
258: plist = prefix_list_lookup (AFI_IP, (char *) rule);
259: if (plist == NULL)
260: return RMAP_NOMATCH;
261:
262: return (prefix_list_apply (plist, &p) == PREFIX_DENY ?
263: RMAP_NOMATCH : RMAP_MATCH);
264: }
265: return RMAP_NOMATCH;
266: }
267:
268: static void *
269: route_match_ip_next_hop_prefix_list_compile (const char *arg)
270: {
271: return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
272: }
273:
274: static void
275: route_match_ip_next_hop_prefix_list_free (void *rule)
276: {
277: XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
278: }
279:
280: struct route_map_rule_cmd route_match_ip_next_hop_prefix_list_cmd =
281: {
282: "ip next-hop prefix-list",
283: route_match_ip_next_hop_prefix_list,
284: route_match_ip_next_hop_prefix_list_compile,
285: route_match_ip_next_hop_prefix_list_free
286: };
287:
288: /* `match ip address IP_ACCESS_LIST' */
289: /* Match function should return 1 if match is success else return
290: zero. */
291: static route_map_result_t
292: route_match_ip_address (void *rule, struct prefix *prefix,
293: route_map_object_t type, void *object)
294: {
295: struct access_list *alist;
296: /* struct prefix_ipv4 match; */
297:
298: if (type == RMAP_OSPF)
299: {
300: alist = access_list_lookup (AFI_IP, (char *) rule);
301: if (alist == NULL)
302: return RMAP_NOMATCH;
303:
304: return (access_list_apply (alist, prefix) == FILTER_DENY ?
305: RMAP_NOMATCH : RMAP_MATCH);
306: }
307: return RMAP_NOMATCH;
308: }
309:
310: /* Route map `ip address' match statement. `arg' should be
311: access-list name. */
312: static void *
313: route_match_ip_address_compile (const char *arg)
314: {
315: return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
316: }
317:
318: /* Free route map's compiled `ip address' value. */
319: static void
320: route_match_ip_address_free (void *rule)
321: {
322: XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
323: }
324:
325: /* Route map commands for ip address matching. */
326: struct route_map_rule_cmd route_match_ip_address_cmd =
327: {
328: "ip address",
329: route_match_ip_address,
330: route_match_ip_address_compile,
331: route_match_ip_address_free
332: };
333:
334: /* `match ip address prefix-list PREFIX_LIST' */
335: static route_map_result_t
336: route_match_ip_address_prefix_list (void *rule, struct prefix *prefix,
337: route_map_object_t type, void *object)
338: {
339: struct prefix_list *plist;
340:
341: if (type == RMAP_OSPF)
342: {
343: plist = prefix_list_lookup (AFI_IP, (char *) rule);
344: if (plist == NULL)
345: return RMAP_NOMATCH;
346:
347: return (prefix_list_apply (plist, prefix) == PREFIX_DENY ?
348: RMAP_NOMATCH : RMAP_MATCH);
349: }
350: return RMAP_NOMATCH;
351: }
352:
353: static void *
354: route_match_ip_address_prefix_list_compile (const char *arg)
355: {
356: return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
357: }
358:
359: static void
360: route_match_ip_address_prefix_list_free (void *rule)
361: {
362: XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
363: }
364:
365: struct route_map_rule_cmd route_match_ip_address_prefix_list_cmd =
366: {
367: "ip address prefix-list",
368: route_match_ip_address_prefix_list,
369: route_match_ip_address_prefix_list_compile,
370: route_match_ip_address_prefix_list_free
371: };
372:
373: /* `match interface IFNAME' */
374: /* Match function should return 1 if match is success else return
375: zero. */
376: static route_map_result_t
377: route_match_interface (void *rule, struct prefix *prefix,
378: route_map_object_t type, void *object)
379: {
380: struct interface *ifp;
381: struct external_info *ei;
382:
383: if (type == RMAP_OSPF)
384: {
385: ei = object;
386: ifp = if_lookup_by_name ((char *)rule);
387:
388: if (ifp == NULL || ifp->ifindex != ei->ifindex)
389: return RMAP_NOMATCH;
390:
391: return RMAP_MATCH;
392: }
393: return RMAP_NOMATCH;
394: }
395:
396: /* Route map `interface' match statement. `arg' should be
397: interface name. */
398: static void *
399: route_match_interface_compile (const char *arg)
400: {
401: return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
402: }
403:
404: /* Free route map's compiled `interface' value. */
405: static void
406: route_match_interface_free (void *rule)
407: {
408: XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
409: }
410:
411: /* Route map commands for ip address matching. */
412: struct route_map_rule_cmd route_match_interface_cmd =
413: {
414: "interface",
415: route_match_interface,
416: route_match_interface_compile,
417: route_match_interface_free
418: };
419:
420: /* `set metric METRIC' */
421: /* Set metric to attribute. */
422: static route_map_result_t
423: route_set_metric (void *rule, struct prefix *prefix,
424: route_map_object_t type, void *object)
425: {
426: u_int32_t *metric;
427: struct external_info *ei;
428:
429: if (type == RMAP_OSPF)
430: {
431: /* Fetch routemap's rule information. */
432: metric = rule;
433: ei = object;
434:
435: /* Set metric out value. */
436: ei->route_map_set.metric = *metric;
437: }
438: return RMAP_OKAY;
439: }
440:
441: /* set metric compilation. */
442: static void *
443: route_set_metric_compile (const char *arg)
444: {
445: u_int32_t *metric;
446: int32_t ret;
447:
448: metric = XCALLOC (MTYPE_ROUTE_MAP_COMPILED, sizeof (u_int32_t));
449: ret = atoi (arg);
450:
451: if (ret >= 0)
452: {
453: *metric = (u_int32_t)ret;
454: return metric;
455: }
456:
457: XFREE (MTYPE_ROUTE_MAP_COMPILED, metric);
458: return NULL;
459: }
460:
461: /* Free route map's compiled `set metric' value. */
462: static void
463: route_set_metric_free (void *rule)
464: {
465: XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
466: }
467:
468: /* Set metric rule structure. */
469: struct route_map_rule_cmd route_set_metric_cmd =
470: {
471: "metric",
472: route_set_metric,
473: route_set_metric_compile,
474: route_set_metric_free,
475: };
476:
477: /* `set metric-type TYPE' */
478: /* Set metric-type to attribute. */
479: static route_map_result_t
480: route_set_metric_type (void *rule, struct prefix *prefix,
481: route_map_object_t type, void *object)
482: {
483: u_int32_t *metric_type;
484: struct external_info *ei;
485:
486: if (type == RMAP_OSPF)
487: {
488: /* Fetch routemap's rule information. */
489: metric_type = rule;
490: ei = object;
491:
492: /* Set metric out value. */
493: ei->route_map_set.metric_type = *metric_type;
494: }
495: return RMAP_OKAY;
496: }
497:
498: /* set metric-type compilation. */
499: static void *
500: route_set_metric_type_compile (const char *arg)
501: {
502: u_int32_t *metric_type;
503:
504: metric_type = XCALLOC (MTYPE_ROUTE_MAP_COMPILED, sizeof (u_int32_t));
505: if (strcmp (arg, "type-1") == 0)
506: *metric_type = EXTERNAL_METRIC_TYPE_1;
507: else if (strcmp (arg, "type-2") == 0)
508: *metric_type = EXTERNAL_METRIC_TYPE_2;
509:
510: if (*metric_type == EXTERNAL_METRIC_TYPE_1 ||
511: *metric_type == EXTERNAL_METRIC_TYPE_2)
512: return metric_type;
513:
514: XFREE (MTYPE_ROUTE_MAP_COMPILED, metric_type);
515: return NULL;
516: }
517:
518: /* Free route map's compiled `set metric-type' value. */
519: static void
520: route_set_metric_type_free (void *rule)
521: {
522: XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
523: }
524:
525: /* Set metric rule structure. */
526: struct route_map_rule_cmd route_set_metric_type_cmd =
527: {
528: "metric-type",
529: route_set_metric_type,
530: route_set_metric_type_compile,
531: route_set_metric_type_free,
532: };
533:
534: DEFUN (match_ip_nexthop,
535: match_ip_nexthop_cmd,
536: "match ip next-hop (<1-199>|<1300-2699>|WORD)",
537: MATCH_STR
538: IP_STR
539: "Match next-hop address of route\n"
540: "IP access-list number\n"
541: "IP access-list number (expanded range)\n"
542: "IP access-list name\n")
543: {
544: return ospf_route_match_add (vty, vty->index, "ip next-hop", argv[0]);
545: }
546:
547: DEFUN (no_match_ip_nexthop,
548: no_match_ip_nexthop_cmd,
549: "no match ip next-hop",
550: NO_STR
551: MATCH_STR
552: IP_STR
553: "Match next-hop address of route\n")
554: {
555: if (argc == 0)
556: return ospf_route_match_delete (vty, vty->index, "ip next-hop", NULL);
557:
558: return ospf_route_match_delete (vty, vty->index, "ip next-hop", argv[0]);
559: }
560:
561: ALIAS (no_match_ip_nexthop,
562: no_match_ip_nexthop_val_cmd,
563: "no match ip next-hop (<1-199>|<1300-2699>|WORD)",
564: NO_STR
565: MATCH_STR
566: IP_STR
567: "Match next-hop address of route\n"
568: "IP access-list number\n"
569: "IP access-list number (expanded range)\n"
570: "IP access-list name\n")
571:
572: DEFUN (match_ip_next_hop_prefix_list,
573: match_ip_next_hop_prefix_list_cmd,
574: "match ip next-hop prefix-list WORD",
575: MATCH_STR
576: IP_STR
577: "Match next-hop address of route\n"
578: "Match entries of prefix-lists\n"
579: "IP prefix-list name\n")
580: {
581: return ospf_route_match_add (vty, vty->index, "ip next-hop prefix-list",
582: argv[0]);
583: }
584:
585: DEFUN (no_match_ip_next_hop_prefix_list,
586: no_match_ip_next_hop_prefix_list_cmd,
587: "no match ip next-hop prefix-list",
588: NO_STR
589: MATCH_STR
590: IP_STR
591: "Match next-hop address of route\n"
592: "Match entries of prefix-lists\n")
593: {
594: if (argc == 0)
595: return ospf_route_match_delete (vty, vty->index, "ip next-hop prefix-list",
596: NULL);
597: return ospf_route_match_delete (vty, vty->index, "ip next-hop prefix-list",
598: argv[0]);
599: }
600:
601: ALIAS (no_match_ip_next_hop_prefix_list,
602: no_match_ip_next_hop_prefix_list_val_cmd,
603: "no match ip next-hop prefix-list WORD",
604: NO_STR
605: MATCH_STR
606: IP_STR
607: "Match next-hop address of route\n"
608: "Match entries of prefix-lists\n"
609: "IP prefix-list name\n")
610:
611: DEFUN (match_ip_address,
612: match_ip_address_cmd,
613: "match ip address (<1-199>|<1300-2699>|WORD)",
614: MATCH_STR
615: IP_STR
616: "Match address of route\n"
617: "IP access-list number\n"
618: "IP access-list number (expanded range)\n"
619: "IP access-list name\n")
620: {
621: return ospf_route_match_add (vty, vty->index, "ip address", argv[0]);
622: }
623:
624: DEFUN (no_match_ip_address,
625: no_match_ip_address_cmd,
626: "no match ip address",
627: NO_STR
628: MATCH_STR
629: IP_STR
630: "Match address of route\n")
631: {
632: if (argc == 0)
633: return ospf_route_match_delete (vty, vty->index, "ip address", NULL);
634:
635: return ospf_route_match_delete (vty, vty->index, "ip address", argv[0]);
636: }
637:
638: ALIAS (no_match_ip_address,
639: no_match_ip_address_val_cmd,
640: "no match ip address (<1-199>|<1300-2699>|WORD)",
641: NO_STR
642: MATCH_STR
643: IP_STR
644: "Match address of route\n"
645: "IP access-list number\n"
646: "IP access-list number (expanded range)\n"
647: "IP access-list name\n")
648:
649: DEFUN (match_ip_address_prefix_list,
650: match_ip_address_prefix_list_cmd,
651: "match ip address prefix-list WORD",
652: MATCH_STR
653: IP_STR
654: "Match address of route\n"
655: "Match entries of prefix-lists\n"
656: "IP prefix-list name\n")
657: {
658: return ospf_route_match_add (vty, vty->index, "ip address prefix-list",
659: argv[0]);
660: }
661:
662: DEFUN (no_match_ip_address_prefix_list,
663: no_match_ip_address_prefix_list_cmd,
664: "no match ip address prefix-list",
665: NO_STR
666: MATCH_STR
667: IP_STR
668: "Match address of route\n"
669: "Match entries of prefix-lists\n")
670: {
671: if (argc == 0)
672: return ospf_route_match_delete (vty, vty->index, "ip address prefix-list",
673: NULL);
674: return ospf_route_match_delete (vty, vty->index, "ip address prefix-list",
675: argv[0]);
676: }
677:
678: ALIAS (no_match_ip_address_prefix_list,
679: no_match_ip_address_prefix_list_val_cmd,
680: "no match ip address prefix-list WORD",
681: NO_STR
682: MATCH_STR
683: IP_STR
684: "Match address of route\n"
685: "Match entries of prefix-lists\n"
686: "IP prefix-list name\n")
687:
688: DEFUN (match_interface,
689: match_interface_cmd,
690: "match interface WORD",
691: MATCH_STR
692: "Match first hop interface of route\n"
693: "Interface name\n")
694: {
695: return ospf_route_match_add (vty, vty->index, "interface", argv[0]);
696: }
697:
698: DEFUN (no_match_interface,
699: no_match_interface_cmd,
700: "no match interface",
701: NO_STR
702: MATCH_STR
703: "Match first hop interface of route\n")
704: {
705: if (argc == 0)
706: return ospf_route_match_delete (vty, vty->index, "interface", NULL);
707:
708: return ospf_route_match_delete (vty, vty->index, "interface", argv[0]);
709: }
710:
711: ALIAS (no_match_interface,
712: no_match_interface_val_cmd,
713: "no match interface WORD",
714: NO_STR
715: MATCH_STR
716: "Match first hop interface of route\n"
717: "Interface name\n")
718:
719: DEFUN (set_metric,
720: set_metric_cmd,
721: "set metric <0-4294967295>",
722: SET_STR
723: "Metric value for destination routing protocol\n"
724: "Metric value\n")
725: {
726: return ospf_route_set_add (vty, vty->index, "metric", argv[0]);
727: }
728:
729: DEFUN (no_set_metric,
730: no_set_metric_cmd,
731: "no set metric",
732: NO_STR
733: SET_STR
734: "Metric value for destination routing protocol\n")
735: {
736: if (argc == 0)
737: return ospf_route_set_delete (vty, vty->index, "metric", NULL);
738:
739: return ospf_route_set_delete (vty, vty->index, "metric", argv[0]);
740: }
741:
742: ALIAS (no_set_metric,
743: no_set_metric_val_cmd,
744: "no set metric <0-4294967295>",
745: NO_STR
746: SET_STR
747: "Metric value for destination routing protocol\n"
748: "Metric value\n")
749:
750: DEFUN (set_metric_type,
751: set_metric_type_cmd,
752: "set metric-type (type-1|type-2)",
753: SET_STR
754: "Type of metric for destination routing protocol\n"
755: "OSPF[6] external type 1 metric\n"
756: "OSPF[6] external type 2 metric\n")
757: {
758: if (strcmp (argv[0], "1") == 0)
759: return ospf_route_set_add (vty, vty->index, "metric-type", "type-1");
760: if (strcmp (argv[0], "2") == 0)
761: return ospf_route_set_add (vty, vty->index, "metric-type", "type-2");
762:
763: return ospf_route_set_add (vty, vty->index, "metric-type", argv[0]);
764: }
765:
766: DEFUN (no_set_metric_type,
767: no_set_metric_type_cmd,
768: "no set metric-type",
769: NO_STR
770: SET_STR
771: "Type of metric for destination routing protocol\n")
772: {
773: if (argc == 0)
774: return ospf_route_set_delete (vty, vty->index, "metric-type", NULL);
775:
776: return ospf_route_set_delete (vty, vty->index, "metric-type", argv[0]);
777: }
778:
779: ALIAS (no_set_metric_type,
780: no_set_metric_type_val_cmd,
781: "no set metric-type (type-1|type-2)",
782: NO_STR
783: SET_STR
784: "Type of metric for destination routing protocol\n"
785: "OSPF[6] external type 1 metric\n"
786: "OSPF[6] external type 2 metric\n")
787:
788: /* Route-map init */
789: void
790: ospf_route_map_init (void)
791: {
792: route_map_init ();
793: route_map_init_vty ();
794:
795: route_map_add_hook (ospf_route_map_update);
796: route_map_delete_hook (ospf_route_map_update);
797: route_map_event_hook (ospf_route_map_event);
798:
799: route_map_install_match (&route_match_ip_nexthop_cmd);
800: route_map_install_match (&route_match_ip_next_hop_prefix_list_cmd);
801: route_map_install_match (&route_match_ip_address_cmd);
802: route_map_install_match (&route_match_ip_address_prefix_list_cmd);
803: route_map_install_match (&route_match_interface_cmd);
804:
805: route_map_install_set (&route_set_metric_cmd);
806: route_map_install_set (&route_set_metric_type_cmd);
807:
808: install_element (RMAP_NODE, &match_ip_nexthop_cmd);
809: install_element (RMAP_NODE, &no_match_ip_nexthop_cmd);
810: install_element (RMAP_NODE, &no_match_ip_nexthop_val_cmd);
811: install_element (RMAP_NODE, &match_ip_next_hop_prefix_list_cmd);
812: install_element (RMAP_NODE, &no_match_ip_next_hop_prefix_list_cmd);
813: install_element (RMAP_NODE, &no_match_ip_next_hop_prefix_list_val_cmd);
814: install_element (RMAP_NODE, &match_ip_address_cmd);
815: install_element (RMAP_NODE, &no_match_ip_address_cmd);
816: install_element (RMAP_NODE, &no_match_ip_address_val_cmd);
817: install_element (RMAP_NODE, &match_ip_address_prefix_list_cmd);
818: install_element (RMAP_NODE, &no_match_ip_address_prefix_list_cmd);
819: install_element (RMAP_NODE, &no_match_ip_address_prefix_list_val_cmd);
820: install_element (RMAP_NODE, &match_interface_cmd);
821: install_element (RMAP_NODE, &no_match_interface_cmd);
822: install_element (RMAP_NODE, &no_match_interface_val_cmd);
823:
824: install_element (RMAP_NODE, &set_metric_cmd);
825: install_element (RMAP_NODE, &no_set_metric_cmd);
826: install_element (RMAP_NODE, &no_set_metric_val_cmd);
827: install_element (RMAP_NODE, &set_metric_type_cmd);
828: install_element (RMAP_NODE, &no_set_metric_type_cmd);
829: install_element (RMAP_NODE, &no_set_metric_type_val_cmd);
830: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ospf_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 / ospfd