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:
447: metric = XCALLOC (MTYPE_ROUTE_MAP_COMPILED, sizeof (u_int32_t));
448: *metric = atoi (arg);
449:
450: if (*metric >= 0)
451: return metric;
452:
453: XFREE (MTYPE_ROUTE_MAP_COMPILED, metric);
454: return NULL;
455: }
456:
457: /* Free route map's compiled `set metric' value. */
458: static void
459: route_set_metric_free (void *rule)
460: {
461: XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
462: }
463:
464: /* Set metric rule structure. */
465: struct route_map_rule_cmd route_set_metric_cmd =
466: {
467: "metric",
468: route_set_metric,
469: route_set_metric_compile,
470: route_set_metric_free,
471: };
472:
473: /* `set metric-type TYPE' */
474: /* Set metric-type to attribute. */
475: static route_map_result_t
476: route_set_metric_type (void *rule, struct prefix *prefix,
477: route_map_object_t type, void *object)
478: {
479: u_int32_t *metric_type;
480: struct external_info *ei;
481:
482: if (type == RMAP_OSPF)
483: {
484: /* Fetch routemap's rule information. */
485: metric_type = rule;
486: ei = object;
487:
488: /* Set metric out value. */
489: ei->route_map_set.metric_type = *metric_type;
490: }
491: return RMAP_OKAY;
492: }
493:
494: /* set metric-type compilation. */
495: static void *
496: route_set_metric_type_compile (const char *arg)
497: {
498: u_int32_t *metric_type;
499:
500: metric_type = XCALLOC (MTYPE_ROUTE_MAP_COMPILED, sizeof (u_int32_t));
501: if (strcmp (arg, "type-1") == 0)
502: *metric_type = EXTERNAL_METRIC_TYPE_1;
503: else if (strcmp (arg, "type-2") == 0)
504: *metric_type = EXTERNAL_METRIC_TYPE_2;
505:
506: if (*metric_type == EXTERNAL_METRIC_TYPE_1 ||
507: *metric_type == EXTERNAL_METRIC_TYPE_2)
508: return metric_type;
509:
510: XFREE (MTYPE_ROUTE_MAP_COMPILED, metric_type);
511: return NULL;
512: }
513:
514: /* Free route map's compiled `set metric-type' value. */
515: static void
516: route_set_metric_type_free (void *rule)
517: {
518: XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
519: }
520:
521: /* Set metric rule structure. */
522: struct route_map_rule_cmd route_set_metric_type_cmd =
523: {
524: "metric-type",
525: route_set_metric_type,
526: route_set_metric_type_compile,
527: route_set_metric_type_free,
528: };
529:
530: DEFUN (match_ip_nexthop,
531: match_ip_nexthop_cmd,
532: "match ip next-hop (<1-199>|<1300-2699>|WORD)",
533: MATCH_STR
534: IP_STR
535: "Match next-hop address of route\n"
536: "IP access-list number\n"
537: "IP access-list number (expanded range)\n"
538: "IP access-list name\n")
539: {
540: return ospf_route_match_add (vty, vty->index, "ip next-hop", argv[0]);
541: }
542:
543: DEFUN (no_match_ip_nexthop,
544: no_match_ip_nexthop_cmd,
545: "no match ip next-hop",
546: NO_STR
547: MATCH_STR
548: IP_STR
549: "Match next-hop address of route\n")
550: {
551: if (argc == 0)
552: return ospf_route_match_delete (vty, vty->index, "ip next-hop", NULL);
553:
554: return ospf_route_match_delete (vty, vty->index, "ip next-hop", argv[0]);
555: }
556:
557: ALIAS (no_match_ip_nexthop,
558: no_match_ip_nexthop_val_cmd,
559: "no match ip next-hop (<1-199>|<1300-2699>|WORD)",
560: NO_STR
561: MATCH_STR
562: IP_STR
563: "Match next-hop address of route\n"
564: "IP access-list number\n"
565: "IP access-list number (expanded range)\n"
566: "IP access-list name\n")
567:
568: DEFUN (match_ip_next_hop_prefix_list,
569: match_ip_next_hop_prefix_list_cmd,
570: "match ip next-hop prefix-list WORD",
571: MATCH_STR
572: IP_STR
573: "Match next-hop address of route\n"
574: "Match entries of prefix-lists\n"
575: "IP prefix-list name\n")
576: {
577: return ospf_route_match_add (vty, vty->index, "ip next-hop prefix-list",
578: argv[0]);
579: }
580:
581: DEFUN (no_match_ip_next_hop_prefix_list,
582: no_match_ip_next_hop_prefix_list_cmd,
583: "no match ip next-hop prefix-list",
584: NO_STR
585: MATCH_STR
586: IP_STR
587: "Match next-hop address of route\n"
588: "Match entries of prefix-lists\n")
589: {
590: if (argc == 0)
591: return ospf_route_match_delete (vty, vty->index, "ip next-hop prefix-list",
592: NULL);
593: return ospf_route_match_delete (vty, vty->index, "ip next-hop prefix-list",
594: argv[0]);
595: }
596:
597: ALIAS (no_match_ip_next_hop_prefix_list,
598: no_match_ip_next_hop_prefix_list_val_cmd,
599: "no match ip next-hop prefix-list WORD",
600: NO_STR
601: MATCH_STR
602: IP_STR
603: "Match next-hop address of route\n"
604: "Match entries of prefix-lists\n"
605: "IP prefix-list name\n")
606:
607: DEFUN (match_ip_address,
608: match_ip_address_cmd,
609: "match ip address (<1-199>|<1300-2699>|WORD)",
610: MATCH_STR
611: IP_STR
612: "Match address of route\n"
613: "IP access-list number\n"
614: "IP access-list number (expanded range)\n"
615: "IP access-list name\n")
616: {
617: return ospf_route_match_add (vty, vty->index, "ip address", argv[0]);
618: }
619:
620: DEFUN (no_match_ip_address,
621: no_match_ip_address_cmd,
622: "no match ip address",
623: NO_STR
624: MATCH_STR
625: IP_STR
626: "Match address of route\n")
627: {
628: if (argc == 0)
629: return ospf_route_match_delete (vty, vty->index, "ip address", NULL);
630:
631: return ospf_route_match_delete (vty, vty->index, "ip address", argv[0]);
632: }
633:
634: ALIAS (no_match_ip_address,
635: no_match_ip_address_val_cmd,
636: "no match ip address (<1-199>|<1300-2699>|WORD)",
637: NO_STR
638: MATCH_STR
639: IP_STR
640: "Match address of route\n"
641: "IP access-list number\n"
642: "IP access-list number (expanded range)\n"
643: "IP access-list name\n")
644:
645: DEFUN (match_ip_address_prefix_list,
646: match_ip_address_prefix_list_cmd,
647: "match ip address prefix-list WORD",
648: MATCH_STR
649: IP_STR
650: "Match address of route\n"
651: "Match entries of prefix-lists\n"
652: "IP prefix-list name\n")
653: {
654: return ospf_route_match_add (vty, vty->index, "ip address prefix-list",
655: argv[0]);
656: }
657:
658: DEFUN (no_match_ip_address_prefix_list,
659: no_match_ip_address_prefix_list_cmd,
660: "no match ip address prefix-list",
661: NO_STR
662: MATCH_STR
663: IP_STR
664: "Match address of route\n"
665: "Match entries of prefix-lists\n")
666: {
667: if (argc == 0)
668: return ospf_route_match_delete (vty, vty->index, "ip address prefix-list",
669: NULL);
670: return ospf_route_match_delete (vty, vty->index, "ip address prefix-list",
671: argv[0]);
672: }
673:
674: ALIAS (no_match_ip_address_prefix_list,
675: no_match_ip_address_prefix_list_val_cmd,
676: "no match ip address prefix-list WORD",
677: NO_STR
678: MATCH_STR
679: IP_STR
680: "Match address of route\n"
681: "Match entries of prefix-lists\n"
682: "IP prefix-list name\n")
683:
684: DEFUN (match_interface,
685: match_interface_cmd,
686: "match interface WORD",
687: MATCH_STR
688: "Match first hop interface of route\n"
689: "Interface name\n")
690: {
691: return ospf_route_match_add (vty, vty->index, "interface", argv[0]);
692: }
693:
694: DEFUN (no_match_interface,
695: no_match_interface_cmd,
696: "no match interface",
697: NO_STR
698: MATCH_STR
699: "Match first hop interface of route\n")
700: {
701: if (argc == 0)
702: return ospf_route_match_delete (vty, vty->index, "interface", NULL);
703:
704: return ospf_route_match_delete (vty, vty->index, "interface", argv[0]);
705: }
706:
707: ALIAS (no_match_interface,
708: no_match_interface_val_cmd,
709: "no match interface WORD",
710: NO_STR
711: MATCH_STR
712: "Match first hop interface of route\n"
713: "Interface name\n")
714:
715: DEFUN (set_metric,
716: set_metric_cmd,
717: "set metric <0-4294967295>",
718: SET_STR
719: "Metric value for destination routing protocol\n"
720: "Metric value\n")
721: {
722: return ospf_route_set_add (vty, vty->index, "metric", argv[0]);
723: }
724:
725: DEFUN (no_set_metric,
726: no_set_metric_cmd,
727: "no set metric",
728: NO_STR
729: SET_STR
730: "Metric value for destination routing protocol\n")
731: {
732: if (argc == 0)
733: return ospf_route_set_delete (vty, vty->index, "metric", NULL);
734:
735: return ospf_route_set_delete (vty, vty->index, "metric", argv[0]);
736: }
737:
738: ALIAS (no_set_metric,
739: no_set_metric_val_cmd,
740: "no set metric <0-4294967295>",
741: NO_STR
742: SET_STR
743: "Metric value for destination routing protocol\n"
744: "Metric value\n")
745:
746: DEFUN (set_metric_type,
747: set_metric_type_cmd,
748: "set metric-type (type-1|type-2)",
749: SET_STR
750: "Type of metric for destination routing protocol\n"
751: "OSPF[6] external type 1 metric\n"
752: "OSPF[6] external type 2 metric\n")
753: {
754: if (strcmp (argv[0], "1") == 0)
755: return ospf_route_set_add (vty, vty->index, "metric-type", "type-1");
756: if (strcmp (argv[0], "2") == 0)
757: return ospf_route_set_add (vty, vty->index, "metric-type", "type-2");
758:
759: return ospf_route_set_add (vty, vty->index, "metric-type", argv[0]);
760: }
761:
762: DEFUN (no_set_metric_type,
763: no_set_metric_type_cmd,
764: "no set metric-type",
765: NO_STR
766: SET_STR
767: "Type of metric for destination routing protocol\n")
768: {
769: if (argc == 0)
770: return ospf_route_set_delete (vty, vty->index, "metric-type", NULL);
771:
772: return ospf_route_set_delete (vty, vty->index, "metric-type", argv[0]);
773: }
774:
775: ALIAS (no_set_metric_type,
776: no_set_metric_type_val_cmd,
777: "no set metric-type (type-1|type-2)",
778: NO_STR
779: SET_STR
780: "Type of metric for destination routing protocol\n"
781: "OSPF[6] external type 1 metric\n"
782: "OSPF[6] external type 2 metric\n")
783:
784: /* Route-map init */
785: void
786: ospf_route_map_init (void)
787: {
788: route_map_init ();
789: route_map_init_vty ();
790:
791: route_map_add_hook (ospf_route_map_update);
792: route_map_delete_hook (ospf_route_map_update);
793: route_map_event_hook (ospf_route_map_event);
794:
795: route_map_install_match (&route_match_ip_nexthop_cmd);
796: route_map_install_match (&route_match_ip_next_hop_prefix_list_cmd);
797: route_map_install_match (&route_match_ip_address_cmd);
798: route_map_install_match (&route_match_ip_address_prefix_list_cmd);
799: route_map_install_match (&route_match_interface_cmd);
800:
801: route_map_install_set (&route_set_metric_cmd);
802: route_map_install_set (&route_set_metric_type_cmd);
803:
804: install_element (RMAP_NODE, &match_ip_nexthop_cmd);
805: install_element (RMAP_NODE, &no_match_ip_nexthop_cmd);
806: install_element (RMAP_NODE, &no_match_ip_nexthop_val_cmd);
807: install_element (RMAP_NODE, &match_ip_next_hop_prefix_list_cmd);
808: install_element (RMAP_NODE, &no_match_ip_next_hop_prefix_list_cmd);
809: install_element (RMAP_NODE, &no_match_ip_next_hop_prefix_list_val_cmd);
810: install_element (RMAP_NODE, &match_ip_address_cmd);
811: install_element (RMAP_NODE, &no_match_ip_address_cmd);
812: install_element (RMAP_NODE, &no_match_ip_address_val_cmd);
813: install_element (RMAP_NODE, &match_ip_address_prefix_list_cmd);
814: install_element (RMAP_NODE, &no_match_ip_address_prefix_list_cmd);
815: install_element (RMAP_NODE, &no_match_ip_address_prefix_list_val_cmd);
816: install_element (RMAP_NODE, &match_interface_cmd);
817: install_element (RMAP_NODE, &no_match_interface_cmd);
818: install_element (RMAP_NODE, &no_match_interface_val_cmd);
819:
820: install_element (RMAP_NODE, &set_metric_cmd);
821: install_element (RMAP_NODE, &no_set_metric_cmd);
822: install_element (RMAP_NODE, &no_set_metric_val_cmd);
823: install_element (RMAP_NODE, &set_metric_type_cmd);
824: install_element (RMAP_NODE, &no_set_metric_type_cmd);
825: install_element (RMAP_NODE, &no_set_metric_type_val_cmd);
826: }
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