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