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