]> git.sommitrealweird.co.uk Git - quagga-debian.git/blob - ospf6d/ospf6_asbr.c
New upstream version 1.2.4
[quagga-debian.git] / ospf6d / ospf6_asbr.c
1 /*
2  * Copyright (C) 2003 Yasuhiro Ohara
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 
18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 
19  * Boston, MA 02111-1307, USA.  
20  */
21
22 #include <zebra.h>
23
24 #include "log.h"
25 #include "memory.h"
26 #include "prefix.h"
27 #include "command.h"
28 #include "vty.h"
29 #include "routemap.h"
30 #include "table.h"
31 #include "plist.h"
32 #include "thread.h"
33 #include "linklist.h"
34
35 #include "ospf6_proto.h"
36 #include "ospf6_lsa.h"
37 #include "ospf6_lsdb.h"
38 #include "ospf6_route.h"
39 #include "ospf6_zebra.h"
40 #include "ospf6_message.h"
41
42 #include "ospf6_top.h"
43 #include "ospf6_area.h"
44 #include "ospf6_interface.h"
45 #include "ospf6_neighbor.h"
46 #include "ospf6_asbr.h"
47 #include "ospf6_intra.h"
48 #include "ospf6_flood.h"
49 #include "ospf6d.h"
50
51 unsigned char conf_debug_ospf6_asbr = 0;
52
53 #define ZROUTE_NAME(x) zebra_route_string(x)
54
55 /* AS External LSA origination */
56 static void
57 ospf6_as_external_lsa_originate (struct ospf6_route *route)
58 {
59   char buffer[OSPF6_MAX_LSASIZE];
60   struct ospf6_lsa_header *lsa_header;
61   struct ospf6_lsa *lsa;
62   struct ospf6_external_info *info = route->route_option;
63
64   struct ospf6_as_external_lsa *as_external_lsa;
65   char buf[64];
66   caddr_t p;
67
68   if (IS_OSPF6_DEBUG_ASBR || IS_OSPF6_DEBUG_ORIGINATE (AS_EXTERNAL))
69     {
70       prefix2str (&route->prefix, buf, sizeof (buf));
71       zlog_debug ("Originate AS-External-LSA for %s", buf);
72     }
73
74   /* prepare buffer */
75   memset (buffer, 0, sizeof (buffer));
76   lsa_header = (struct ospf6_lsa_header *) buffer;
77   as_external_lsa = (struct ospf6_as_external_lsa *)
78     ((caddr_t) lsa_header + sizeof (struct ospf6_lsa_header));
79   p = (caddr_t)
80     ((caddr_t) as_external_lsa + sizeof (struct ospf6_as_external_lsa));
81
82   /* Fill AS-External-LSA */
83   /* Metric type */
84   if (route->path.metric_type == 2)
85     SET_FLAG (as_external_lsa->bits_metric, OSPF6_ASBR_BIT_E);
86   else
87     UNSET_FLAG (as_external_lsa->bits_metric, OSPF6_ASBR_BIT_E);
88
89   /* forwarding address */
90   if (! IN6_IS_ADDR_UNSPECIFIED (&info->forwarding))
91     SET_FLAG (as_external_lsa->bits_metric, OSPF6_ASBR_BIT_F);
92   else
93     UNSET_FLAG (as_external_lsa->bits_metric, OSPF6_ASBR_BIT_F);
94
95   /* external route tag */
96   if (info->tag)
97     SET_FLAG (as_external_lsa->bits_metric, OSPF6_ASBR_BIT_T);
98   else
99     UNSET_FLAG (as_external_lsa->bits_metric, OSPF6_ASBR_BIT_T);
100
101   /* Set metric */
102   OSPF6_ASBR_METRIC_SET (as_external_lsa, route->path.cost);
103
104   /* prefixlen */
105   as_external_lsa->prefix.prefix_length = route->prefix.prefixlen;
106
107   /* PrefixOptions */
108   as_external_lsa->prefix.prefix_options = route->path.prefix_options;
109
110   /* don't use refer LS-type */
111   as_external_lsa->prefix.prefix_refer_lstype = htons (0);
112
113   /* set Prefix */
114   memcpy (p, &route->prefix.u.prefix6,
115           OSPF6_PREFIX_SPACE (route->prefix.prefixlen));
116   ospf6_prefix_apply_mask (&as_external_lsa->prefix);
117   p += OSPF6_PREFIX_SPACE (route->prefix.prefixlen);
118
119   /* Forwarding address */
120   if (CHECK_FLAG (as_external_lsa->bits_metric, OSPF6_ASBR_BIT_F))
121     {
122       memcpy (p, &info->forwarding, sizeof (struct in6_addr));
123       p += sizeof (struct in6_addr);
124     }
125
126   /* External Route Tag */
127   if (CHECK_FLAG (as_external_lsa->bits_metric, OSPF6_ASBR_BIT_T))
128     {
129       route_tag_t network_order = htonl(info->tag);
130
131       memcpy (p, &network_order, sizeof(network_order));
132       p += sizeof(network_order);
133     }
134
135   /* Fill LSA Header */
136   lsa_header->age = 0;
137   lsa_header->type = htons (OSPF6_LSTYPE_AS_EXTERNAL);
138   lsa_header->id = route->path.origin.id;
139   lsa_header->adv_router = ospf6->router_id;
140   lsa_header->seqnum =
141     ospf6_new_ls_seqnum (lsa_header->type, lsa_header->id,
142                          lsa_header->adv_router, ospf6->lsdb);
143   lsa_header->length = htons ((caddr_t) p - (caddr_t) lsa_header);
144
145   /* LSA checksum */
146   ospf6_lsa_checksum (lsa_header);
147
148   /* create LSA */
149   lsa = ospf6_lsa_create (lsa_header);
150
151   /* Originate */
152   ospf6_lsa_originate_process (lsa, ospf6);
153 }
154
155 static route_tag_t
156 ospf6_as_external_lsa_get_tag (struct ospf6_lsa *lsa)
157 {
158   struct ospf6_as_external_lsa *external;
159   ptrdiff_t tag_offset;
160   route_tag_t network_order;
161
162   if (!lsa)
163     return 0;
164
165   external = (struct ospf6_as_external_lsa *)
166     OSPF6_LSA_HEADER_END (lsa->header);
167
168   if (!CHECK_FLAG (external->bits_metric, OSPF6_ASBR_BIT_T))
169     return 0;
170
171   tag_offset = sizeof(*external) + OSPF6_PREFIX_SPACE(external->prefix.prefix_length);
172   if (CHECK_FLAG (external->bits_metric, OSPF6_ASBR_BIT_F))
173     tag_offset += sizeof(struct in6_addr);
174
175   memcpy(&network_order, (caddr_t)external + tag_offset, sizeof(network_order));
176   return ntohl(network_order);
177 }
178
179 void
180 ospf6_asbr_lsa_add (struct ospf6_lsa *lsa)
181 {
182   struct ospf6_as_external_lsa *external;
183   struct prefix asbr_id;
184   struct ospf6_route *asbr_entry, *route;
185   char buf[64];
186   int i;
187
188   external = (struct ospf6_as_external_lsa *)
189     OSPF6_LSA_HEADER_END (lsa->header);
190
191   if (IS_OSPF6_DEBUG_EXAMIN (AS_EXTERNAL))
192     zlog_debug ("Calculate AS-External route for %s", lsa->name);
193
194   if (lsa->header->adv_router == ospf6->router_id)
195     {
196       if (IS_OSPF6_DEBUG_EXAMIN (AS_EXTERNAL))
197         zlog_debug ("Ignore self-originated AS-External-LSA");
198       return;
199     }
200
201   if (OSPF6_ASBR_METRIC (external) == OSPF_LS_INFINITY)
202     {
203       if (IS_OSPF6_DEBUG_EXAMIN (AS_EXTERNAL))
204         zlog_debug ("Ignore LSA with LSInfinity Metric");
205       return;
206     }
207
208   if (CHECK_FLAG(external->prefix.prefix_options, OSPF6_PREFIX_OPTION_NU))
209     {
210       if (IS_OSPF6_DEBUG_EXAMIN (AS_EXTERNAL))
211         zlog_debug ("Ignore LSA with NU bit set Metric");
212       return;
213     }
214
215   ospf6_linkstate_prefix (lsa->header->adv_router, htonl (0), &asbr_id);
216   asbr_entry = ospf6_route_lookup (&asbr_id, ospf6->brouter_table);
217   if (asbr_entry == NULL ||
218       ! CHECK_FLAG (asbr_entry->path.router_bits, OSPF6_ROUTER_BIT_E))
219     {
220       if (IS_OSPF6_DEBUG_EXAMIN (AS_EXTERNAL))
221         {
222           prefix2str (&asbr_id, buf, sizeof (buf));
223           zlog_debug ("ASBR entry not found: %s", buf);
224         }
225       return;
226     }
227
228   route = ospf6_route_create ();
229   route->type = OSPF6_DEST_TYPE_NETWORK;
230   route->prefix.family = AF_INET6;
231   route->prefix.prefixlen = external->prefix.prefix_length;
232   ospf6_prefix_in6_addr (&route->prefix.u.prefix6, &external->prefix);
233
234   route->path.area_id = asbr_entry->path.area_id;
235   route->path.origin.type = lsa->header->type;
236   route->path.origin.id = lsa->header->id;
237   route->path.origin.adv_router = lsa->header->adv_router;
238
239   route->path.prefix_options = external->prefix.prefix_options;
240   if (CHECK_FLAG (external->bits_metric, OSPF6_ASBR_BIT_E))
241     {
242       route->path.type = OSPF6_PATH_TYPE_EXTERNAL2;
243       route->path.metric_type = 2;
244       route->path.cost = asbr_entry->path.cost;
245       route->path.cost_e2 = OSPF6_ASBR_METRIC (external);
246     }
247   else
248     {
249       route->path.type = OSPF6_PATH_TYPE_EXTERNAL1;
250       route->path.metric_type = 1;
251       route->path.cost = asbr_entry->path.cost + OSPF6_ASBR_METRIC (external);
252       route->path.cost_e2 = 0;
253     }
254
255   route->path.tag = ospf6_as_external_lsa_get_tag (lsa);
256   
257   for (i = 0; i < OSPF6_MULTI_PATH_LIMIT; i++)
258     ospf6_nexthop_copy (&route->nexthop[i], &asbr_entry->nexthop[i]);
259
260   if (IS_OSPF6_DEBUG_EXAMIN (AS_EXTERNAL))
261     {
262       prefix2str (&route->prefix, buf, sizeof (buf));
263       zlog_debug ("AS-External route add: %s", buf);
264     }
265
266   ospf6_route_add (route, ospf6->route_table);
267 }
268
269 void
270 ospf6_asbr_lsa_remove (struct ospf6_lsa *lsa)
271 {
272   struct ospf6_as_external_lsa *external;
273   struct prefix prefix;
274   struct ospf6_route *route, *nroute;
275   char buf[64];
276
277   external = (struct ospf6_as_external_lsa *)
278     OSPF6_LSA_HEADER_END (lsa->header);
279
280   if (IS_OSPF6_DEBUG_EXAMIN (AS_EXTERNAL))
281     zlog_debug ("Withdraw AS-External route for %s", lsa->name);
282
283   if (lsa->header->adv_router == ospf6->router_id)
284     {
285       if (IS_OSPF6_DEBUG_EXAMIN (AS_EXTERNAL))
286         zlog_debug ("Ignore self-originated AS-External-LSA");
287       return;
288     }
289
290   memset (&prefix, 0, sizeof (struct prefix));
291   prefix.family = AF_INET6;
292   prefix.prefixlen = external->prefix.prefix_length;
293   ospf6_prefix_in6_addr (&prefix.u.prefix6, &external->prefix);
294
295   route = ospf6_route_lookup (&prefix, ospf6->route_table);
296   if (route == NULL)
297     {
298       if (IS_OSPF6_DEBUG_EXAMIN (AS_EXTERNAL))
299         {
300           prefix2str (&prefix, buf, sizeof (buf));
301           zlog_debug ("AS-External route %s not found", buf);
302         }
303       return;
304     }
305
306   for (ospf6_route_lock (route);
307        route && ospf6_route_is_prefix (&prefix, route);
308        route = nroute)
309     {
310       nroute = ospf6_route_next (route);
311       if (route->type != OSPF6_DEST_TYPE_NETWORK)
312         continue;
313       if (route->path.origin.type != lsa->header->type)
314         continue;
315       if (route->path.origin.id != lsa->header->id)
316         continue;
317       if (route->path.origin.adv_router != lsa->header->adv_router)
318         continue;
319
320       if (IS_OSPF6_DEBUG_EXAMIN (AS_EXTERNAL))
321         {
322           prefix2str (&route->prefix, buf, sizeof (buf));
323           zlog_debug ("AS-External route remove: %s", buf);
324         }
325       ospf6_route_remove (route, ospf6->route_table);
326     }
327   if (route != NULL)
328     ospf6_route_unlock (route);
329 }
330
331 void
332 ospf6_asbr_lsentry_add (struct ospf6_route *asbr_entry)
333 {
334   struct ospf6_lsa *lsa;
335   u_int16_t type;
336   u_int32_t router;
337
338   if (! CHECK_FLAG (asbr_entry->flag, OSPF6_ROUTE_BEST))
339     {
340       char buf[16];
341       inet_ntop (AF_INET, &ADV_ROUTER_IN_PREFIX (&asbr_entry->prefix),
342                  buf, sizeof (buf));
343        zlog_info ("ignore non-best path: lsentry %s add", buf);
344       return;
345     }
346
347   type = htons (OSPF6_LSTYPE_AS_EXTERNAL);
348   router = ospf6_linkstate_prefix_adv_router (&asbr_entry->prefix);
349   for (lsa = ospf6_lsdb_type_router_head (type, router, ospf6->lsdb); lsa;
350        lsa = ospf6_lsdb_type_router_next (type, router, lsa))
351     {
352       if (! OSPF6_LSA_IS_MAXAGE (lsa))
353         ospf6_asbr_lsa_add (lsa);
354     }
355 }
356
357 void
358 ospf6_asbr_lsentry_remove (struct ospf6_route *asbr_entry)
359 {
360   struct ospf6_lsa *lsa;
361   u_int16_t type;
362   u_int32_t router;
363
364   type = htons (OSPF6_LSTYPE_AS_EXTERNAL);
365   router = ospf6_linkstate_prefix_adv_router (&asbr_entry->prefix);
366   for (lsa = ospf6_lsdb_type_router_head (type, router, ospf6->lsdb);
367        lsa; lsa = ospf6_lsdb_type_router_next (type, router, lsa))
368     ospf6_asbr_lsa_remove (lsa);
369 }
370
371
372
373 /* redistribute function */
374
375 static void
376 ospf6_asbr_routemap_set (int type, const char *mapname)
377 {
378   if (ospf6->rmap[type].name)
379     free (ospf6->rmap[type].name);
380   ospf6->rmap[type].name = strdup (mapname);
381   ospf6->rmap[type].map = route_map_lookup_by_name (mapname);
382 }
383
384 static void
385 ospf6_asbr_routemap_unset (int type)
386 {
387   if (ospf6->rmap[type].name)
388     free (ospf6->rmap[type].name);
389   ospf6->rmap[type].name = NULL;
390   ospf6->rmap[type].map = NULL;
391 }
392
393 static void
394 ospf6_asbr_routemap_update (const char *mapname)
395 {
396   int type;
397
398   if (ospf6 == NULL)
399     return;
400
401   for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
402     {
403       if (ospf6->rmap[type].name)
404         ospf6->rmap[type].map =
405           route_map_lookup_by_name (ospf6->rmap[type].name);
406       else
407         ospf6->rmap[type].map = NULL;
408     }
409 }
410
411 int
412 ospf6_asbr_is_asbr (struct ospf6 *o)
413 {
414   return o->external_table->count;
415 }
416
417 static void
418 ospf6_asbr_redistribute_set (int type)
419 {
420   ospf6_zebra_redistribute (type);
421 }
422
423 static void
424 ospf6_asbr_redistribute_unset (int type)
425 {
426   struct ospf6_route *route;
427   struct ospf6_external_info *info;
428
429   ospf6_zebra_no_redistribute (type);
430
431   for (route = ospf6_route_head (ospf6->external_table); route;
432        route = ospf6_route_next (route))
433     {
434       info = route->route_option;
435       if (info->type != type)
436         continue;
437
438       ospf6_asbr_redistribute_remove (info->type, route->nexthop[0].ifindex,
439                                       &route->prefix);
440     }
441
442   ospf6_asbr_routemap_unset (type);
443 }
444
445 void
446 ospf6_asbr_redistribute_add (int type, ifindex_t ifindex, struct prefix *prefix,
447                              u_int nexthop_num, struct in6_addr *nexthop, route_tag_t tag)
448 {
449   int ret;
450   struct ospf6_route troute;
451   struct ospf6_external_info tinfo;
452   struct ospf6_route *route, *match;
453   struct ospf6_external_info *info;
454   struct prefix prefix_id;
455   struct route_node *node;
456   char pbuf[64], ibuf[16];
457   struct listnode *lnode, *lnnode;
458   struct ospf6_area *oa;
459
460   if (! ospf6_zebra_is_redistribute (type))
461     return;
462
463   if (IS_OSPF6_DEBUG_ASBR)
464     {
465       prefix2str (prefix, pbuf, sizeof (pbuf));
466       zlog_debug ("Redistribute %s (%s)", pbuf, ZROUTE_NAME (type));
467     }
468
469   /* if route-map was specified but not found, do not advertise */
470   if (ospf6->rmap[type].name)
471     {
472       if (ospf6->rmap[type].map == NULL)
473         ospf6_asbr_routemap_update (NULL);
474       if (ospf6->rmap[type].map == NULL)
475         {
476           zlog_warn ("route-map \"%s\" not found, suppress redistributing",
477                      ospf6->rmap[type].name);
478           return;
479         }
480     }
481
482   /* apply route-map */
483   if (ospf6->rmap[type].map)
484     {
485       memset (&troute, 0, sizeof (troute));
486       memset (&tinfo, 0, sizeof (tinfo));
487       troute.route_option = &tinfo;
488       tinfo.ifindex = ifindex;
489       tinfo.tag = tag;
490
491       ret = route_map_apply (ospf6->rmap[type].map, prefix,
492                              RMAP_OSPF6, &troute);
493       if (ret == RMAP_DENYMATCH)
494         {
495           if (IS_OSPF6_DEBUG_ASBR)
496             zlog_debug ("Denied by route-map \"%s\"", ospf6->rmap[type].name);
497           return;
498         }
499     }
500
501   match = ospf6_route_lookup (prefix, ospf6->external_table);
502   if (match)
503     {
504       info = match->route_option;
505
506       /* copy result of route-map */
507       if (ospf6->rmap[type].map)
508         {
509           if (troute.path.metric_type)
510             match->path.metric_type = troute.path.metric_type;
511           if (troute.path.cost)
512             match->path.cost = troute.path.cost;
513           if (! IN6_IS_ADDR_UNSPECIFIED (&tinfo.forwarding))
514             memcpy (&info->forwarding, &tinfo.forwarding,
515                     sizeof (struct in6_addr));
516           info->tag = tinfo.tag;
517         }
518       else
519         {
520           /* If there is no route-map, simply update the tag */
521           info->tag = tag;
522         }
523
524       info->type = type;
525       match->nexthop[0].ifindex = ifindex;
526       if (nexthop_num && nexthop)
527         memcpy (&match->nexthop[0].address, nexthop, sizeof (struct in6_addr));
528
529       /* create/update binding in external_id_table */
530       prefix_id.family = AF_INET;
531       prefix_id.prefixlen = 32;
532       prefix_id.u.prefix4.s_addr = htonl (info->id);
533       node = route_node_get (ospf6->external_id_table, &prefix_id);
534       node->info = match;
535
536       if (IS_OSPF6_DEBUG_ASBR)
537         {
538           inet_ntop (AF_INET, &prefix_id.u.prefix4, ibuf, sizeof (ibuf));
539           zlog_debug ("Advertise as AS-External Id:%s", ibuf);
540         }
541
542       match->path.origin.id = htonl (info->id);
543       ospf6_as_external_lsa_originate (match);
544       return;
545     }
546
547   /* create new entry */
548   route = ospf6_route_create ();
549   route->type = OSPF6_DEST_TYPE_NETWORK;
550   memcpy (&route->prefix, prefix, sizeof (struct prefix));
551
552   info = (struct ospf6_external_info *)
553     XCALLOC (MTYPE_OSPF6_EXTERNAL_INFO, sizeof (struct ospf6_external_info));
554   route->route_option = info;
555   info->id = ospf6->external_id++;
556
557   /* copy result of route-map */
558   if (ospf6->rmap[type].map)
559     {
560       if (troute.path.metric_type)
561         route->path.metric_type = troute.path.metric_type;
562       if (troute.path.cost)
563         route->path.cost = troute.path.cost;
564       if (! IN6_IS_ADDR_UNSPECIFIED (&tinfo.forwarding))
565         memcpy (&info->forwarding, &tinfo.forwarding,
566                 sizeof (struct in6_addr));
567       info->tag = tinfo.tag;
568     }
569   else
570     {
571       /* If there is no route-map, simply set the tag */
572       info->tag = tag;
573     }
574
575   info->type = type;
576   route->nexthop[0].ifindex = ifindex;
577   if (nexthop_num && nexthop)
578     memcpy (&route->nexthop[0].address, nexthop, sizeof (struct in6_addr));
579
580   /* create/update binding in external_id_table */
581   prefix_id.family = AF_INET;
582   prefix_id.prefixlen = 32;
583   prefix_id.u.prefix4.s_addr = htonl (info->id);
584   node = route_node_get (ospf6->external_id_table, &prefix_id);
585   node->info = route;
586
587   route = ospf6_route_add (route, ospf6->external_table);
588   route->route_option = info;
589
590   if (IS_OSPF6_DEBUG_ASBR)
591     {
592       inet_ntop (AF_INET, &prefix_id.u.prefix4, ibuf, sizeof (ibuf));
593       zlog_debug ("Advertise as AS-External Id:%s", ibuf);
594     }
595
596   route->path.origin.id = htonl (info->id);
597   ospf6_as_external_lsa_originate (route);
598
599   /* Router-Bit (ASBR Flag) may have to be updated */
600   for (ALL_LIST_ELEMENTS (ospf6->area_list, lnode, lnnode, oa))
601     OSPF6_ROUTER_LSA_SCHEDULE (oa);
602 }
603
604 void
605 ospf6_asbr_redistribute_remove (int type, ifindex_t ifindex,
606                                 struct prefix *prefix)
607 {
608   struct ospf6_route *match;
609   struct ospf6_external_info *info = NULL;
610   struct route_node *node;
611   struct ospf6_lsa *lsa;
612   struct prefix prefix_id;
613   char pbuf[64], ibuf[16];
614   struct listnode *lnode, *lnnode;
615   struct ospf6_area *oa;
616
617   match = ospf6_route_lookup (prefix, ospf6->external_table);
618   if (match == NULL)
619     {
620       if (IS_OSPF6_DEBUG_ASBR)
621         {
622           prefix2str (prefix, pbuf, sizeof (pbuf));
623           zlog_debug ("No such route %s to withdraw", pbuf);
624         }
625       return;
626     }
627
628   info = match->route_option;
629   assert (info);
630
631   if (info->type != type)
632     {
633       if (IS_OSPF6_DEBUG_ASBR)
634         {
635           prefix2str (prefix, pbuf, sizeof (pbuf));
636           zlog_debug ("Original protocol mismatch: %s", pbuf);
637         }
638       return;
639     }
640
641   if (IS_OSPF6_DEBUG_ASBR)
642     {
643       prefix2str (prefix, pbuf, sizeof (pbuf));
644       inet_ntop (AF_INET, &prefix_id.u.prefix4, ibuf, sizeof (ibuf));
645       zlog_debug ("Withdraw %s (AS-External Id:%s)", pbuf, ibuf);
646     }
647
648   lsa = ospf6_lsdb_lookup (htons (OSPF6_LSTYPE_AS_EXTERNAL),
649                            htonl (info->id), ospf6->router_id, ospf6->lsdb);
650   if (lsa)
651     ospf6_lsa_purge (lsa);
652
653   /* remove binding in external_id_table */
654   prefix_id.family = AF_INET;
655   prefix_id.prefixlen = 32;
656   prefix_id.u.prefix4.s_addr = htonl (info->id);
657   node = route_node_lookup (ospf6->external_id_table, &prefix_id);
658   assert (node);
659   node->info = NULL;
660   route_unlock_node (node);
661
662   ospf6_route_remove (match, ospf6->external_table);
663   XFREE (MTYPE_OSPF6_EXTERNAL_INFO, info);
664
665   /* Router-Bit (ASBR Flag) may have to be updated */
666   for (ALL_LIST_ELEMENTS (ospf6->area_list, lnode, lnnode, oa))
667     OSPF6_ROUTER_LSA_SCHEDULE (oa);
668 }
669
670 DEFUN (ospf6_redistribute,
671        ospf6_redistribute_cmd,
672        "redistribute " QUAGGA_REDIST_STR_OSPF6D,
673        "Redistribute\n"
674        QUAGGA_REDIST_HELP_STR_OSPF6D
675       )
676 {
677   int type;
678
679   type = proto_redistnum(AFI_IP6, argv[0]);
680   if (type < 0 || type == ZEBRA_ROUTE_OSPF6)
681     return CMD_WARNING;
682
683   ospf6_asbr_redistribute_unset (type);
684   ospf6_asbr_redistribute_set (type);
685   return CMD_SUCCESS;
686 }
687
688 DEFUN (ospf6_redistribute_routemap,
689        ospf6_redistribute_routemap_cmd,
690        "redistribute " QUAGGA_REDIST_STR_OSPF6D " route-map WORD",
691        "Redistribute\n"
692        QUAGGA_REDIST_HELP_STR_OSPF6D
693        "Route map reference\n"
694        "Route map name\n"
695       )
696 {
697   int type;
698
699   type = proto_redistnum(AFI_IP6, argv[0]);
700   if (type < 0 || type == ZEBRA_ROUTE_OSPF6)
701     return CMD_WARNING;
702
703   ospf6_asbr_redistribute_unset (type);
704   ospf6_asbr_routemap_set (type, argv[1]);
705   ospf6_asbr_redistribute_set (type);
706   return CMD_SUCCESS;
707 }
708
709 DEFUN (no_ospf6_redistribute,
710        no_ospf6_redistribute_cmd,
711        "no redistribute " QUAGGA_REDIST_STR_OSPF6D,
712        NO_STR
713        "Redistribute\n"
714        QUAGGA_REDIST_HELP_STR_OSPF6D
715       )
716 {
717   int type;
718
719   type = proto_redistnum(AFI_IP6, argv[0]);
720   if (type < 0 || type == ZEBRA_ROUTE_OSPF6)
721     return CMD_WARNING;
722
723   ospf6_asbr_redistribute_unset (type);
724
725   return CMD_SUCCESS;
726 }
727
728 ALIAS (no_ospf6_redistribute,
729        no_ospf6_redistribute_route_map_cmd,
730        "no redistribute " QUAGGA_REDIST_STR_OSPF6D " route-map WORD",
731        NO_STR
732        "Redistribute\n"
733        QUAGGA_REDIST_HELP_STR_OSPF6D
734        "Route map reference\n"
735        "Route map name\n")
736
737 int
738 ospf6_redistribute_config_write (struct vty *vty)
739 {
740   int type;
741
742   for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
743     {
744       if (type == ZEBRA_ROUTE_OSPF6)
745         continue;
746       if (! ospf6_zebra_is_redistribute (type))
747         continue;
748
749       if (ospf6->rmap[type].name)
750         vty_out (vty, " redistribute %s route-map %s%s",
751                  ZROUTE_NAME (type), ospf6->rmap[type].name, VNL);
752       else
753         vty_out (vty, " redistribute %s%s",
754                  ZROUTE_NAME (type), VNL);
755     }
756
757   return 0;
758 }
759
760 static void
761 ospf6_redistribute_show_config (struct vty *vty)
762 {
763   int type;
764   int nroute[ZEBRA_ROUTE_MAX];
765   int total;
766   struct ospf6_route *route;
767   struct ospf6_external_info *info;
768
769   total = 0;
770   for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
771     nroute[type] = 0;
772   for (route = ospf6_route_head (ospf6->external_table); route;
773        route = ospf6_route_next (route))
774     {
775       info = route->route_option;
776       nroute[info->type]++;
777       total++;
778     }
779
780   vty_out (vty, "Redistributing External Routes from:%s", VNL);
781   for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
782     {
783       if (type == ZEBRA_ROUTE_OSPF6)
784         continue;
785       if (! ospf6_zebra_is_redistribute (type))
786         continue;
787
788       if (ospf6->rmap[type].name)
789         vty_out (vty, "    %d: %s with route-map \"%s\"%s%s", nroute[type],
790                  ZROUTE_NAME (type), ospf6->rmap[type].name,
791                  (ospf6->rmap[type].map ? "" : " (not found !)"),
792                  VNL);
793       else
794         vty_out (vty, "    %d: %s%s", nroute[type],
795                  ZROUTE_NAME (type), VNL);
796     }
797   vty_out (vty, "Total %d routes%s", total, VNL);
798 }
799
800
801
802 /* Routemap Functions */
803 static route_map_result_t
804 ospf6_routemap_rule_match_address_prefixlist (void *rule,
805                                               struct prefix *prefix,
806                                               route_map_object_t type,
807                                               void *object)
808 {
809   struct prefix_list *plist;
810
811   if (type != RMAP_OSPF6)
812     return RMAP_NOMATCH;
813
814   plist = prefix_list_lookup (AFI_IP6, (char *) rule);
815   if (plist == NULL)
816     return RMAP_NOMATCH;
817
818   return (prefix_list_apply (plist, prefix) == PREFIX_DENY ?
819           RMAP_NOMATCH : RMAP_MATCH);
820 }
821
822 static void *
823 ospf6_routemap_rule_match_address_prefixlist_compile (const char *arg)
824 {
825   return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
826 }
827
828 static void
829 ospf6_routemap_rule_match_address_prefixlist_free (void *rule)
830 {
831   XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
832 }
833
834 struct route_map_rule_cmd
835 ospf6_routemap_rule_match_address_prefixlist_cmd =
836 {
837   "ipv6 address prefix-list",
838   ospf6_routemap_rule_match_address_prefixlist,
839   ospf6_routemap_rule_match_address_prefixlist_compile,
840   ospf6_routemap_rule_match_address_prefixlist_free,
841 };
842
843 /* `match interface IFNAME' */
844 /* Match function should return 1 if match is success else return
845    zero. */
846 static route_map_result_t
847 ospf6_routemap_rule_match_interface (void *rule, struct prefix *prefix,
848                        route_map_object_t type, void *object)
849 {
850   struct interface   *ifp;
851   struct ospf6_external_info *ei;
852
853   if (type == RMAP_OSPF6)
854     {
855       ei = ((struct ospf6_route *) object)->route_option;
856       ifp = if_lookup_by_name ((char *)rule);
857
858       if (ifp != NULL
859       &&  ei->ifindex == ifp->ifindex)
860           return RMAP_MATCH;
861     }
862
863   return RMAP_NOMATCH;
864 }
865
866 /* Route map `interface' match statement.  `arg' should be
867    interface name. */
868 static void *
869 ospf6_routemap_rule_match_interface_compile (const char *arg)
870 {
871   return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
872 }
873
874 /* Free route map's compiled `interface' value. */
875 static void
876 ospf6_routemap_rule_match_interface_free (void *rule)
877 {
878   XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
879 }
880
881 /* Route map commands for interface matching. */
882 struct route_map_rule_cmd
883 ospf6_routemap_rule_match_interface_cmd =
884 {
885   "interface",
886   ospf6_routemap_rule_match_interface,
887   ospf6_routemap_rule_match_interface_compile,
888   ospf6_routemap_rule_match_interface_free
889 };
890
891 /* Match function for matching route tags */
892 static route_map_result_t
893 ospf6_routemap_rule_match_tag (void *rule, struct prefix *prefix,
894                                route_map_object_t type, void *object)
895 {
896   route_tag_t *tag = rule;
897   struct ospf6_route *route = object;
898   struct ospf6_external_info *info = route->route_option;
899
900   if (type == RMAP_OSPF6 && info->tag == *tag)
901     return RMAP_MATCH;
902
903   return RMAP_NOMATCH;
904 }
905
906 static struct route_map_rule_cmd
907 ospf6_routemap_rule_match_tag_cmd =
908 {
909   "tag",
910   ospf6_routemap_rule_match_tag,
911   route_map_rule_tag_compile,
912   route_map_rule_tag_free,
913 };
914
915 static route_map_result_t
916 ospf6_routemap_rule_set_metric_type (void *rule, struct prefix *prefix,
917                                      route_map_object_t type, void *object)
918 {
919   char *metric_type = rule;
920   struct ospf6_route *route = object;
921
922   if (type != RMAP_OSPF6)
923     return RMAP_OKAY;
924
925   if (strcmp (metric_type, "type-2") == 0)
926     route->path.metric_type = 2;
927   else
928     route->path.metric_type = 1;
929
930   return RMAP_OKAY;
931 }
932
933 static void *
934 ospf6_routemap_rule_set_metric_type_compile (const char *arg)
935 {
936   if (strcmp (arg, "type-2") && strcmp (arg, "type-1"))
937     return NULL;
938   return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
939 }
940
941 static void
942 ospf6_routemap_rule_set_metric_type_free (void *rule)
943 {
944   XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
945 }
946
947 struct route_map_rule_cmd
948 ospf6_routemap_rule_set_metric_type_cmd =
949 {
950   "metric-type",
951   ospf6_routemap_rule_set_metric_type,
952   ospf6_routemap_rule_set_metric_type_compile,
953   ospf6_routemap_rule_set_metric_type_free,
954 };
955
956 static route_map_result_t
957 ospf6_routemap_rule_set_metric (void *rule, struct prefix *prefix,
958                                 route_map_object_t type, void *object)
959 {
960   char *metric = rule;
961   struct ospf6_route *route = object;
962
963   if (type != RMAP_OSPF6)
964     return RMAP_OKAY;
965
966   route->path.cost = atoi (metric);
967   return RMAP_OKAY;
968 }
969
970 static void *
971 ospf6_routemap_rule_set_metric_compile (const char *arg)
972 {
973   u_int32_t metric;
974   char *endp;
975   metric = strtoul (arg, &endp, 0);
976   if (metric > OSPF_LS_INFINITY || *endp != '\0')
977     return NULL;
978   return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
979 }
980
981 static void
982 ospf6_routemap_rule_set_metric_free (void *rule)
983 {
984   XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
985 }
986
987 struct route_map_rule_cmd
988 ospf6_routemap_rule_set_metric_cmd =
989 {
990   "metric",
991   ospf6_routemap_rule_set_metric,
992   ospf6_routemap_rule_set_metric_compile,
993   ospf6_routemap_rule_set_metric_free,
994 };
995
996 static route_map_result_t
997 ospf6_routemap_rule_set_forwarding (void *rule, struct prefix *prefix,
998                                     route_map_object_t type, void *object)
999 {
1000   char *forwarding = rule;
1001   struct ospf6_route *route = object;
1002   struct ospf6_external_info *info = route->route_option;
1003
1004   if (type != RMAP_OSPF6)
1005     return RMAP_OKAY;
1006
1007   if (inet_pton (AF_INET6, forwarding, &info->forwarding) != 1)
1008     {
1009       memset (&info->forwarding, 0, sizeof (struct in6_addr));
1010       return RMAP_ERROR;
1011     }
1012
1013   return RMAP_OKAY;
1014 }
1015
1016 static void *
1017 ospf6_routemap_rule_set_forwarding_compile (const char *arg)
1018 {
1019   struct in6_addr a;
1020   if (inet_pton (AF_INET6, arg, &a) != 1)
1021     return NULL;
1022   return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
1023 }
1024
1025 static void
1026 ospf6_routemap_rule_set_forwarding_free (void *rule)
1027 {
1028   XFREE (MTYPE_ROUTE_MAP_COMPILED, rule);
1029 }
1030
1031 struct route_map_rule_cmd
1032 ospf6_routemap_rule_set_forwarding_cmd =
1033 {
1034   "forwarding-address",
1035   ospf6_routemap_rule_set_forwarding,
1036   ospf6_routemap_rule_set_forwarding_compile,
1037   ospf6_routemap_rule_set_forwarding_free,
1038 };
1039
1040 static route_map_result_t
1041 ospf6_routemap_rule_set_tag (void *rule, struct prefix *prefix,
1042                              route_map_object_t type, void *object)
1043 {
1044   route_tag_t *tag = rule;
1045   struct ospf6_route *route = object;
1046   struct ospf6_external_info *info = route->route_option;
1047
1048   if (type != RMAP_OSPF6)
1049     return RMAP_OKAY;
1050
1051   info->tag = *tag;
1052   return RMAP_OKAY;
1053 }
1054
1055 static struct route_map_rule_cmd
1056 ospf6_routemap_rule_set_tag_cmd =
1057 {
1058   "tag",
1059   ospf6_routemap_rule_set_tag,
1060   route_map_rule_tag_compile,
1061   route_map_rule_tag_free,
1062 };
1063
1064 static int
1065 route_map_command_status (struct vty *vty, int ret)
1066 {
1067   if (! ret)
1068     return CMD_SUCCESS;
1069
1070   switch (ret)
1071     {
1072     case RMAP_RULE_MISSING:
1073       vty_out (vty, "OSPF6 Can't find rule.%s", VNL);
1074       break;
1075     case RMAP_COMPILE_ERROR:
1076       vty_out (vty, "OSPF6 Argument is malformed.%s", VNL);
1077       break;
1078     default:
1079       vty_out (vty, "OSPF6 route-map add set failed.%s", VNL);
1080       break;
1081     }
1082   return CMD_WARNING;
1083 }
1084
1085 /* add "match address" */
1086 DEFUN (ospf6_routemap_match_address_prefixlist,
1087        ospf6_routemap_match_address_prefixlist_cmd,
1088        "match ipv6 address prefix-list WORD",
1089        "Match values\n"
1090        IPV6_STR
1091        "Match address of route\n"
1092        "Match entries of prefix-lists\n"
1093        "IPv6 prefix-list name\n")
1094 {
1095   int ret = route_map_add_match ((struct route_map_index *) vty->index,
1096                                  "ipv6 address prefix-list", argv[0]);
1097   return route_map_command_status (vty, ret);
1098 }
1099
1100 /* delete "match address" */
1101 DEFUN (ospf6_routemap_no_match_address_prefixlist,
1102        ospf6_routemap_no_match_address_prefixlist_cmd,
1103        "no match ipv6 address prefix-list WORD",
1104        NO_STR
1105        "Match values\n"
1106        IPV6_STR
1107        "Match address of route\n"
1108        "Match entries of prefix-lists\n"
1109        "IPv6 prefix-list name\n")
1110 {
1111   int ret = route_map_delete_match ((struct route_map_index *) vty->index,
1112                                     "ipv6 address prefix-list", argv[0]);
1113   return route_map_command_status (vty, ret);
1114 }
1115
1116 /* "match interface" */
1117 DEFUN (ospf6_routemap_match_interface,
1118        ospf6_routemap_match_interface_cmd,
1119        "match interface WORD",
1120        MATCH_STR
1121        "Match first hop interface of route\n"
1122        "Interface name\n")
1123 {
1124   return route_map_add_match ((struct route_map_index *) vty->index,
1125                               "interface", argv[0]);
1126 }
1127
1128 /* "no match interface WORD" */
1129 DEFUN (ospf6_routemap_no_match_interface,
1130        ospf6_routemap_no_match_interface_cmd,
1131        "no match interface",
1132        NO_STR
1133        MATCH_STR
1134        "Match first hop interface of route\n")
1135 {
1136   int ret = route_map_delete_match ((struct route_map_index *) vty->index,
1137                                     "interface", (argc == 0) ? NULL : argv[0]);
1138   return route_map_command_status (vty, ret);
1139 }
1140
1141 ALIAS (ospf6_routemap_no_match_interface,
1142        ospf6_routemap_no_match_interface_val_cmd,
1143        "no match interface WORD",
1144        NO_STR
1145        MATCH_STR
1146        "Match first hop interface of route\n"
1147        "Interface name\n")
1148
1149 /* add "match tag" */
1150 DEFUN (ospf6_routemap_match_tag,
1151        ospf6_routemap_match_tag_cmd,
1152        "match tag <1-4294967295>",
1153        MATCH_STR
1154        "Tag value for routing protocol\n"
1155        "Tag value\n")
1156 {
1157   int ret = route_map_add_match ((struct route_map_index *) vty->index,
1158                                "tag", argv[0]);
1159   return route_map_command_status (vty, ret);
1160 }
1161
1162 /* delete "match tag" */
1163 DEFUN (ospf6_routemap_no_match_tag,
1164        ospf6_routemap_no_match_tag_cmd,
1165        "no match tag",
1166        NO_STR
1167        MATCH_STR
1168        "Tag value for routing protocol\n")
1169 {
1170   int ret = route_map_delete_match ((struct route_map_index *) vty->index,
1171                                   "tag", argc ? argv[0] : NULL);
1172   return route_map_command_status (vty, ret);
1173 }
1174
1175 ALIAS (ospf6_routemap_no_match_tag,
1176        ospf6_routemap_no_match_tag_val_cmd,
1177        "no match tag <1-4294967295>",
1178        NO_STR
1179        MATCH_STR
1180        "Tag value for routing protocol\n"
1181        "Tag value\n")
1182
1183 /* add "set metric-type" */
1184 DEFUN (ospf6_routemap_set_metric_type,
1185        ospf6_routemap_set_metric_type_cmd,
1186        "set metric-type (type-1|type-2)",
1187        "Set value\n"
1188        "Type of metric\n"
1189        "OSPF6 external type 1 metric\n"
1190        "OSPF6 external type 2 metric\n")
1191 {
1192   int ret = route_map_add_set ((struct route_map_index *) vty->index,
1193                                "metric-type", argv[0]);
1194   return route_map_command_status (vty, ret);
1195 }
1196
1197 /* delete "set metric-type" */
1198 DEFUN (ospf6_routemap_no_set_metric_type,
1199        ospf6_routemap_no_set_metric_type_cmd,
1200        "no set metric-type (type-1|type-2)",
1201        NO_STR
1202        "Set value\n"
1203        "Type of metric\n"
1204        "OSPF6 external type 1 metric\n"
1205        "OSPF6 external type 2 metric\n")
1206 {
1207   int ret = route_map_delete_set ((struct route_map_index *) vty->index,
1208                                   "metric-type", argv[0]);
1209   return route_map_command_status (vty, ret);
1210 }
1211
1212 /* add "set metric" */
1213 DEFUN (set_metric,
1214        set_metric_cmd,
1215        "set metric <0-4294967295>",
1216        "Set value\n"
1217        "Metric value\n"
1218        "Metric value\n")
1219 {
1220   int ret = route_map_add_set ((struct route_map_index *) vty->index,
1221                                "metric", argv[0]);
1222   return route_map_command_status (vty, ret);
1223 }
1224
1225 /* delete "set metric" */
1226 DEFUN (no_set_metric,
1227        no_set_metric_cmd,
1228        "no set metric",
1229        NO_STR
1230        SET_STR
1231        "Metric value for destination routing protocol\n")
1232 {
1233   int ret = 0;
1234
1235   if (argc == 0)
1236     ret = route_map_delete_set ((struct route_map_index *) vty->index,
1237                                 "metric", NULL);
1238   else
1239     ret = route_map_delete_set ((struct route_map_index *) vty->index,
1240                                 "metric", argv[0]);
1241   return route_map_command_status (vty, ret);
1242 }
1243
1244 ALIAS (no_set_metric,
1245        no_set_metric_val_cmd,
1246        "no set metric <0-4294967295>",
1247        NO_STR
1248        SET_STR
1249        "Metric value for destination routing protocol\n"
1250        "Metric value\n")
1251
1252 /* add "set forwarding-address" */
1253 DEFUN (ospf6_routemap_set_forwarding,
1254        ospf6_routemap_set_forwarding_cmd,
1255        "set forwarding-address X:X::X:X",
1256        "Set value\n"
1257        "Forwarding Address\n"
1258        "IPv6 Address\n")
1259 {
1260   int ret = route_map_add_set ((struct route_map_index *) vty->index,
1261                                "forwarding-address", argv[0]);
1262   return route_map_command_status (vty, ret);
1263 }
1264
1265 /* delete "set forwarding-address" */
1266 DEFUN (ospf6_routemap_no_set_forwarding,
1267        ospf6_routemap_no_set_forwarding_cmd,
1268        "no set forwarding-address X:X::X:X",
1269        NO_STR
1270        "Set value\n"
1271        "Forwarding Address\n"
1272        "IPv6 Address\n")
1273 {
1274   int ret = route_map_delete_set ((struct route_map_index *) vty->index,
1275                                   "forwarding-address", argv[0]);
1276   return route_map_command_status (vty, ret);
1277 }
1278
1279 /* add "set tag" */
1280 DEFUN (ospf6_routemap_set_tag,
1281        ospf6_routemap_set_tag_cmd,
1282        "set tag <1-4294967295>",
1283        "Set value\n"
1284        "Tag value for routing protocol\n"
1285        "Tag value\n")
1286 {
1287   int ret = route_map_add_set ((struct route_map_index *) vty->index,
1288                                "tag", argv[0]);
1289   return route_map_command_status (vty, ret);
1290 }
1291
1292 /* delete "set tag" */
1293 DEFUN (ospf6_routemap_no_set_tag,
1294        ospf6_routemap_no_set_tag_cmd,
1295        "no set tag",
1296        NO_STR
1297        "Set value\n"
1298        "Tag value for routing protocol\n")
1299 {
1300   int ret = route_map_delete_set ((struct route_map_index *) vty->index,
1301                                   "tag", argc ? argv[0] : NULL);
1302   return route_map_command_status (vty, ret);
1303 }
1304
1305 ALIAS (ospf6_routemap_no_set_tag,
1306        ospf6_routemap_no_set_tag_val_cmd,
1307        "no set tag <1-4294967295>",
1308        NO_STR
1309        "Set value\n"
1310        "Tag value for routing protocol\n"
1311        "Tag value\n")
1312
1313 static void
1314 ospf6_routemap_init (void)
1315 {
1316   route_map_init ();
1317   route_map_init_vty ();
1318   route_map_add_hook (ospf6_asbr_routemap_update);
1319   route_map_delete_hook (ospf6_asbr_routemap_update);
1320
1321   route_map_install_match (&ospf6_routemap_rule_match_address_prefixlist_cmd);
1322   route_map_install_match (&ospf6_routemap_rule_match_interface_cmd);
1323   route_map_install_match (&ospf6_routemap_rule_match_tag_cmd);
1324
1325   route_map_install_set (&ospf6_routemap_rule_set_metric_type_cmd);
1326   route_map_install_set (&ospf6_routemap_rule_set_metric_cmd);
1327   route_map_install_set (&ospf6_routemap_rule_set_forwarding_cmd);
1328   route_map_install_set (&ospf6_routemap_rule_set_tag_cmd);
1329
1330   /* Match address prefix-list */
1331   install_element (RMAP_NODE, &ospf6_routemap_match_address_prefixlist_cmd);
1332   install_element (RMAP_NODE, &ospf6_routemap_no_match_address_prefixlist_cmd);
1333
1334   /* Match interface */
1335   install_element (RMAP_NODE, &ospf6_routemap_match_interface_cmd);
1336   install_element (RMAP_NODE, &ospf6_routemap_no_match_interface_cmd);
1337   install_element (RMAP_NODE, &ospf6_routemap_no_match_interface_val_cmd);
1338
1339   /* Match tag */
1340   install_element (RMAP_NODE, &ospf6_routemap_match_tag_cmd);
1341   install_element (RMAP_NODE, &ospf6_routemap_no_match_tag_cmd);
1342   install_element (RMAP_NODE, &ospf6_routemap_no_match_tag_val_cmd);
1343
1344   /* ASE Metric Type (e.g. Type-1/Type-2) */
1345   install_element (RMAP_NODE, &ospf6_routemap_set_metric_type_cmd);
1346   install_element (RMAP_NODE, &ospf6_routemap_no_set_metric_type_cmd);
1347
1348   /* ASE Metric */
1349   install_element (RMAP_NODE, &set_metric_cmd);
1350   install_element (RMAP_NODE, &no_set_metric_cmd);
1351   install_element (RMAP_NODE, &no_set_metric_val_cmd);
1352
1353   /* Forwarding address */
1354   install_element (RMAP_NODE, &ospf6_routemap_set_forwarding_cmd);
1355   install_element (RMAP_NODE, &ospf6_routemap_no_set_forwarding_cmd);
1356
1357   /* Tag */
1358   install_element (RMAP_NODE, &ospf6_routemap_set_tag_cmd);
1359   install_element (RMAP_NODE, &ospf6_routemap_no_set_tag_cmd);
1360   install_element (RMAP_NODE, &ospf6_routemap_no_set_tag_val_cmd);
1361 }
1362
1363
1364 /* Display functions */
1365 static char *
1366 ospf6_as_external_lsa_get_prefix_str (struct ospf6_lsa *lsa, char *buf,
1367                                       int buflen, int pos)
1368 {
1369   struct ospf6_as_external_lsa *external;
1370   struct in6_addr in6;
1371   int prefix_length = 0;
1372
1373   if (lsa)
1374     {
1375         external = (struct ospf6_as_external_lsa *)
1376           OSPF6_LSA_HEADER_END (lsa->header);
1377
1378         if (pos == 0)
1379           {
1380             ospf6_prefix_in6_addr (&in6, &external->prefix);
1381             prefix_length = external->prefix.prefix_length;
1382           }
1383         else {
1384           in6 = *((struct in6_addr *)
1385                   ((caddr_t) external + sizeof (struct ospf6_as_external_lsa) +
1386                    OSPF6_PREFIX_SPACE (external->prefix.prefix_length)));
1387         }
1388         if (buf)
1389           {
1390             inet_ntop (AF_INET6, &in6, buf, buflen);
1391             if (prefix_length)
1392               sprintf (&buf[strlen(buf)], "/%d", prefix_length);
1393           }
1394     }
1395   return (buf);
1396 }
1397
1398 static int
1399 ospf6_as_external_lsa_show (struct vty *vty, struct ospf6_lsa *lsa)
1400 {
1401   struct ospf6_as_external_lsa *external;
1402   char buf[64];
1403
1404   assert (lsa->header);
1405   external = (struct ospf6_as_external_lsa *)
1406     OSPF6_LSA_HEADER_END (lsa->header);
1407   
1408   /* bits */
1409   snprintf (buf, sizeof (buf), "%c%c%c",
1410     (CHECK_FLAG (external->bits_metric, OSPF6_ASBR_BIT_E) ? 'E' : '-'),
1411     (CHECK_FLAG (external->bits_metric, OSPF6_ASBR_BIT_F) ? 'F' : '-'),
1412     (CHECK_FLAG (external->bits_metric, OSPF6_ASBR_BIT_T) ? 'T' : '-'));
1413
1414   vty_out (vty, "     Bits: %s%s", buf, VNL);
1415   vty_out (vty, "     Metric: %5lu%s", (u_long) OSPF6_ASBR_METRIC (external),
1416            VNL);
1417
1418   ospf6_prefix_options_printbuf (external->prefix.prefix_options,
1419                                  buf, sizeof (buf));
1420   vty_out (vty, "     Prefix Options: %s%s", buf,
1421            VNL);
1422
1423   vty_out (vty, "     Referenced LSType: %d%s",
1424            ntohs (external->prefix.prefix_refer_lstype),
1425            VNL);
1426
1427   vty_out (vty, "     Prefix: %s%s",
1428            ospf6_as_external_lsa_get_prefix_str (lsa, buf, sizeof(buf), 0), VNL);
1429
1430   /* Forwarding-Address */
1431   if (CHECK_FLAG (external->bits_metric, OSPF6_ASBR_BIT_F))
1432     {
1433       vty_out (vty, "     Forwarding-Address: %s%s",
1434                ospf6_as_external_lsa_get_prefix_str (lsa, buf, sizeof(buf), 1),
1435                VNL);
1436     }
1437
1438   /* Tag */
1439   if (CHECK_FLAG (external->bits_metric, OSPF6_ASBR_BIT_T))
1440     {
1441       vty_out (vty, "     Tag: %u%s",
1442                ospf6_as_external_lsa_get_tag (lsa), VNL);
1443     }
1444
1445   return 0;
1446 }
1447
1448 static void
1449 ospf6_asbr_external_route_show (struct vty *vty, struct ospf6_route *route)
1450 {
1451   struct ospf6_external_info *info = route->route_option;
1452   char prefix[64], id[16], forwarding[64];
1453   u_int32_t tmp_id;
1454
1455   prefix2str (&route->prefix, prefix, sizeof (prefix));
1456   tmp_id = ntohl (info->id);
1457   inet_ntop (AF_INET, &tmp_id, id, sizeof (id));
1458   if (! IN6_IS_ADDR_UNSPECIFIED (&info->forwarding))
1459     inet_ntop (AF_INET6, &info->forwarding, forwarding, sizeof (forwarding));
1460   else
1461     snprintf (forwarding, sizeof (forwarding), ":: (ifindex %d)",
1462               route->nexthop[0].ifindex);
1463
1464   vty_out (vty, "%c %-32s %-15s type-%d %5lu %s%s",
1465            zebra_route_char(info->type),
1466            prefix, id, route->path.metric_type,
1467            (u_long) (route->path.metric_type == 2 ?
1468                      route->path.cost_e2 : route->path.cost),
1469            forwarding, VNL);
1470 }
1471
1472 DEFUN (show_ipv6_ospf6_redistribute,
1473        show_ipv6_ospf6_redistribute_cmd,
1474        "show ipv6 ospf6 redistribute",
1475        SHOW_STR
1476        IP6_STR
1477        OSPF6_STR
1478        "redistributing External information\n"
1479        )
1480 {
1481   struct ospf6_route *route;
1482
1483   OSPF6_CMD_CHECK_RUNNING ();
1484
1485   ospf6_redistribute_show_config (vty);
1486
1487   for (route = ospf6_route_head (ospf6->external_table); route;
1488        route = ospf6_route_next (route))
1489     ospf6_asbr_external_route_show (vty, route);
1490
1491   return CMD_SUCCESS;
1492 }
1493
1494 struct ospf6_lsa_handler as_external_handler =
1495 {
1496   OSPF6_LSTYPE_AS_EXTERNAL,
1497   "AS-External",
1498   "ASE",
1499   ospf6_as_external_lsa_show,
1500   ospf6_as_external_lsa_get_prefix_str
1501 };
1502
1503 void
1504 ospf6_asbr_init (void)
1505 {
1506   ospf6_routemap_init ();
1507
1508   ospf6_install_lsa_handler (&as_external_handler);
1509
1510   install_element (VIEW_NODE, &show_ipv6_ospf6_redistribute_cmd);
1511
1512   install_element (OSPF6_NODE, &ospf6_redistribute_cmd);
1513   install_element (OSPF6_NODE, &ospf6_redistribute_routemap_cmd);
1514   install_element (OSPF6_NODE, &no_ospf6_redistribute_cmd);
1515   install_element (OSPF6_NODE, &no_ospf6_redistribute_route_map_cmd);
1516 }
1517
1518 void
1519 ospf6_asbr_redistribute_reset (void)
1520 {
1521   int type;
1522
1523   for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
1524     {
1525       if (type == ZEBRA_ROUTE_OSPF6)
1526         continue;
1527       if (ospf6_zebra_is_redistribute (type))
1528         ospf6_asbr_redistribute_unset(type);
1529     }
1530 }
1531
1532 void
1533 ospf6_asbr_terminate (void)
1534 {
1535   route_map_finish ();
1536 }
1537
1538 DEFUN (debug_ospf6_asbr,
1539        debug_ospf6_asbr_cmd,
1540        "debug ospf6 asbr",
1541        DEBUG_STR
1542        OSPF6_STR
1543        "Debug OSPFv3 ASBR function\n"
1544       )
1545 {
1546   OSPF6_DEBUG_ASBR_ON ();
1547   return CMD_SUCCESS;
1548 }
1549
1550 DEFUN (no_debug_ospf6_asbr,
1551        no_debug_ospf6_asbr_cmd,
1552        "no debug ospf6 asbr",
1553        NO_STR
1554        DEBUG_STR
1555        OSPF6_STR
1556        "Debug OSPFv3 ASBR function\n"
1557       )
1558 {
1559   OSPF6_DEBUG_ASBR_OFF ();
1560   return CMD_SUCCESS;
1561 }
1562
1563 int
1564 config_write_ospf6_debug_asbr (struct vty *vty)
1565 {
1566   if (IS_OSPF6_DEBUG_ASBR)
1567     vty_out (vty, "debug ospf6 asbr%s", VNL);
1568   return 0;
1569 }
1570
1571 void
1572 install_element_ospf6_debug_asbr ()
1573 {
1574   install_element (ENABLE_NODE, &debug_ospf6_asbr_cmd);
1575   install_element (ENABLE_NODE, &no_debug_ospf6_asbr_cmd);
1576   install_element (CONFIG_NODE, &debug_ospf6_asbr_cmd);
1577   install_element (CONFIG_NODE, &no_debug_ospf6_asbr_cmd);
1578 }
1579
1580