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