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 <kernel|connected|static|ripng|isis|bgp|table>",
 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 <kernel|connected|static|ripng|isis|bgp|table> 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 <kernel|connected|static|ripng|isis|bgp|table> [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);
 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 "match address" */
1099 DEFUN (ospf6_routemap_match_address_prefixlist,
1100        ospf6_routemap_match_address_prefixlist_cmd,
1101        "match ipv6 address prefix-list WORD",
1102        "Match values\n"
1103        IPV6_STR
1104        "Match address of route\n"
1105        "Match entries of prefix-lists\n"
1106        "IPv6 prefix-list name\n")
1107 {
1108   VTY_DECLVAR_CONTEXT(route_map_index, route_map_index);
1109   int idx_word = 4;
1110   int ret = route_map_add_match (route_map_index,
1111                                  "ipv6 address prefix-list", argv[idx_word]->arg);
1112   return route_map_command_status (vty, ret);
1113 }
1114
1115 /* delete "match address" */
1116 DEFUN (ospf6_routemap_no_match_address_prefixlist,
1117        ospf6_routemap_no_match_address_prefixlist_cmd,
1118        "no match ipv6 address prefix-list WORD",
1119        NO_STR
1120        "Match values\n"
1121        IPV6_STR
1122        "Match address of route\n"
1123        "Match entries of prefix-lists\n"
1124        "IPv6 prefix-list name\n")
1125 {
1126   VTY_DECLVAR_CONTEXT(route_map_index, route_map_index);
1127   int idx_word = 5;
1128   int ret = route_map_delete_match (route_map_index,
1129                                     "ipv6 address prefix-list", argv[idx_word]->arg);
1130   return route_map_command_status (vty, ret);
1131 }
1132
1133 /* "match interface" */
1134 DEFUN (ospf6_routemap_match_interface,
1135        ospf6_routemap_match_interface_cmd,
1136        "match interface WORD",
1137        MATCH_STR
1138        "Match first hop interface of route\n"
1139        "Interface name\n")
1140 {
1141   VTY_DECLVAR_CONTEXT(route_map_index, route_map_index);
1142   int idx_word = 2;
1143   return route_map_add_match (route_map_index,
1144                               "interface", argv[idx_word]->arg);
1145 }
1146
1147 /* "no match interface WORD" */
1148 DEFUN (ospf6_routemap_no_match_interface,
1149        ospf6_routemap_no_match_interface_cmd,
1150        "no match interface [WORD]",
1151        NO_STR
1152        MATCH_STR
1153        "Match first hop interface of route\n"
1154        "Interface name\n")
1155 {
1156   VTY_DECLVAR_CONTEXT(route_map_index, route_map_index);
1157   int idx_word = 3;
1158   int ret;
1159
1160   if (argc == 4)
1161     ret  = route_map_delete_match (route_map_index,
1162                                     "interface", argv[idx_word]->arg);
1163   else
1164     ret  = route_map_delete_match (route_map_index,
1165                                     "interface", NULL);
1166   return route_map_command_status (vty, ret);
1167 }
1168
1169 /* add "set metric-type" */
1170 DEFUN (ospf6_routemap_set_metric_type,
1171        ospf6_routemap_set_metric_type_cmd,
1172        "set metric-type <type-1|type-2>",
1173        "Set value\n"
1174        "Type of metric\n"
1175        "OSPF6 external type 1 metric\n"
1176        "OSPF6 external type 2 metric\n")
1177 {
1178   VTY_DECLVAR_CONTEXT(route_map_index, route_map_index);
1179   int idx_external = 2;
1180   int ret = route_map_add_set (route_map_index,
1181                                "metric-type", argv[idx_external]->arg);
1182   return route_map_command_status (vty, ret);
1183 }
1184
1185 /* delete "set metric-type" */
1186 DEFUN (ospf6_routemap_no_set_metric_type,
1187        ospf6_routemap_no_set_metric_type_cmd,
1188        "no set metric-type <type-1|type-2>",
1189        NO_STR
1190        "Set value\n"
1191        "Type of metric\n"
1192        "OSPF6 external type 1 metric\n"
1193        "OSPF6 external type 2 metric\n")
1194 {
1195   VTY_DECLVAR_CONTEXT(route_map_index, route_map_index);
1196   int idx_external = 3;
1197   int ret = route_map_delete_set (route_map_index,
1198                                   "metric-type", argv[idx_external]->arg);
1199   return route_map_command_status (vty, ret);
1200 }
1201
1202 /* add "set forwarding-address" */
1203 DEFUN (ospf6_routemap_set_forwarding,
1204        ospf6_routemap_set_forwarding_cmd,
1205        "set forwarding-address X:X::X:X",
1206        "Set value\n"
1207        "Forwarding Address\n"
1208        "IPv6 Address\n")
1209 {
1210   VTY_DECLVAR_CONTEXT(route_map_index, route_map_index);
1211   int idx_ipv6 = 2;
1212   int ret = route_map_add_set (route_map_index,
1213                                "forwarding-address", argv[idx_ipv6]->arg);
1214   return route_map_command_status (vty, ret);
1215 }
1216
1217 /* delete "set forwarding-address" */
1218 DEFUN (ospf6_routemap_no_set_forwarding,
1219        ospf6_routemap_no_set_forwarding_cmd,
1220        "no set forwarding-address X:X::X:X",
1221        NO_STR
1222        "Set value\n"
1223        "Forwarding Address\n"
1224        "IPv6 Address\n")
1225 {
1226   VTY_DECLVAR_CONTEXT(route_map_index, route_map_index);
1227   int idx_ipv6 = 3;
1228   int ret = route_map_delete_set (route_map_index,
1229                                   "forwarding-address", argv[idx_ipv6]->arg);
1230   return route_map_command_status (vty, ret);
1231 }
1232
1233 /* add "set tag" */
1234 DEFUN (ospf6_routemap_set_tag,
1235        ospf6_routemap_set_tag_cmd,
1236        "set tag (1-4294967295)",
1237        "Set value\n"
1238        "Tag value for routing protocol\n"
1239        "Tag value\n")
1240 {
1241   VTY_DECLVAR_CONTEXT(route_map_index, route_map_index);
1242   int ret = route_map_add_set (route_map_index,
1243                                "tag", argv[2]->arg);
1244   return route_map_command_status (vty, ret);
1245 }
1246
1247 /* delete "set tag" */
1248 DEFUN (ospf6_routemap_no_set_tag,
1249        ospf6_routemap_no_set_tag_cmd,
1250        "no set tag [(1-4294967295)]",
1251        NO_STR
1252        "Set value\n"
1253        "Tag value for routing protocol\n"
1254        "Tag value\n")
1255 {
1256   char *tag = (argc == 4) ? argv[3]->arg : NULL;
1257   VTY_DECLVAR_CONTEXT (route_map_index, index);
1258   int ret = route_map_delete_set (index, "tag", tag);
1259   return route_map_command_status (vty, ret);
1260 }
1261
1262 static void
1263 ospf6_routemap_init (void)
1264 {
1265   route_map_init ();
1266
1267   route_map_add_hook (ospf6_asbr_routemap_update);
1268   route_map_delete_hook (ospf6_asbr_routemap_update);
1269
1270   route_map_set_metric_hook (generic_set_add);
1271   route_map_no_set_metric_hook (generic_set_delete);
1272
1273   route_map_install_match (&ospf6_routemap_rule_match_address_prefixlist_cmd);
1274   route_map_install_match (&ospf6_routemap_rule_match_interface_cmd);
1275   route_map_install_match (&ospf6_routemap_rule_match_tag_cmd);
1276
1277   route_map_install_set (&ospf6_routemap_rule_set_metric_type_cmd);
1278   route_map_install_set (&ospf6_routemap_rule_set_metric_cmd);
1279   route_map_install_set (&ospf6_routemap_rule_set_forwarding_cmd);
1280   route_map_install_set (&ospf6_routemap_rule_set_tag_cmd);
1281
1282   /* Match address prefix-list */
1283   install_element (RMAP_NODE, &ospf6_routemap_match_address_prefixlist_cmd);
1284   install_element (RMAP_NODE, &ospf6_routemap_no_match_address_prefixlist_cmd);
1285
1286   /* Match interface */
1287   install_element (RMAP_NODE, &ospf6_routemap_match_interface_cmd);
1288   install_element (RMAP_NODE, &ospf6_routemap_no_match_interface_cmd);
1289
1290   /* ASE Metric Type (e.g. Type-1/Type-2) */
1291   install_element (RMAP_NODE, &ospf6_routemap_set_metric_type_cmd);
1292   install_element (RMAP_NODE, &ospf6_routemap_no_set_metric_type_cmd);
1293
1294   /* ASE Metric */
1295   install_element (RMAP_NODE, &ospf6_routemap_set_forwarding_cmd);
1296   install_element (RMAP_NODE, &ospf6_routemap_no_set_forwarding_cmd);
1297
1298   /* Tag */
1299   install_element (RMAP_NODE, &ospf6_routemap_set_tag_cmd);
1300   install_element (RMAP_NODE, &ospf6_routemap_no_set_tag_cmd);
1301 }
1302
1303
1304 /* Display functions */
1305 static char *
1306 ospf6_as_external_lsa_get_prefix_str (struct ospf6_lsa *lsa, char *buf,
1307                                       int buflen, int pos)
1308 {
1309   struct ospf6_as_external_lsa *external;
1310   struct in6_addr in6;
1311   int prefix_length = 0;
1312
1313   if (lsa)
1314     {
1315         external = (struct ospf6_as_external_lsa *)
1316           OSPF6_LSA_HEADER_END (lsa->header);
1317
1318         if (pos == 0)
1319           {
1320             ospf6_prefix_in6_addr (&in6, &external->prefix);
1321             prefix_length = external->prefix.prefix_length;
1322           }
1323         else {
1324           in6 = *((struct in6_addr *)
1325                   ((caddr_t) external + sizeof (struct ospf6_as_external_lsa) +
1326                    OSPF6_PREFIX_SPACE (external->prefix.prefix_length)));
1327         }
1328         if (buf)
1329           {
1330             inet_ntop (AF_INET6, &in6, buf, buflen);
1331             if (prefix_length)
1332               sprintf (&buf[strlen(buf)], "/%d", prefix_length);
1333           }
1334     }
1335   return (buf);
1336 }
1337
1338 static int
1339 ospf6_as_external_lsa_show (struct vty *vty, struct ospf6_lsa *lsa)
1340 {
1341   struct ospf6_as_external_lsa *external;
1342   char buf[64];
1343
1344   assert (lsa->header);
1345   external = (struct ospf6_as_external_lsa *)
1346     OSPF6_LSA_HEADER_END (lsa->header);
1347
1348   /* bits */
1349   snprintf (buf, sizeof (buf), "%c%c%c",
1350     (CHECK_FLAG (external->bits_metric, OSPF6_ASBR_BIT_E) ? 'E' : '-'),
1351     (CHECK_FLAG (external->bits_metric, OSPF6_ASBR_BIT_F) ? 'F' : '-'),
1352     (CHECK_FLAG (external->bits_metric, OSPF6_ASBR_BIT_T) ? 'T' : '-'));
1353
1354   vty_out (vty, "     Bits: %s%s", buf, VNL);
1355   vty_out (vty, "     Metric: %5lu%s", (u_long) OSPF6_ASBR_METRIC (external),
1356            VNL);
1357
1358   ospf6_prefix_options_printbuf (external->prefix.prefix_options,
1359                                  buf, sizeof (buf));
1360   vty_out (vty, "     Prefix Options: %s%s", buf,
1361            VNL);
1362
1363   vty_out (vty, "     Referenced LSType: %d%s",
1364            ntohs (external->prefix.prefix_refer_lstype),
1365            VNL);
1366
1367   vty_out (vty, "     Prefix: %s%s",
1368            ospf6_as_external_lsa_get_prefix_str (lsa, buf, sizeof(buf), 0), VNL);
1369
1370   /* Forwarding-Address */
1371   if (CHECK_FLAG (external->bits_metric, OSPF6_ASBR_BIT_F))
1372     {
1373       vty_out (vty, "     Forwarding-Address: %s%s",
1374                ospf6_as_external_lsa_get_prefix_str (lsa, buf, sizeof(buf), 1),
1375                VNL);
1376     }
1377
1378   /* Tag */
1379   if (CHECK_FLAG (external->bits_metric, OSPF6_ASBR_BIT_T))
1380     {
1381       vty_out (vty, "     Tag: %"ROUTE_TAG_PRI"%s",
1382                ospf6_as_external_lsa_get_tag (lsa), VNL);
1383     }
1384
1385   return 0;
1386 }
1387
1388 static void
1389 ospf6_asbr_external_route_show (struct vty *vty, struct ospf6_route *route)
1390 {
1391   struct ospf6_external_info *info = route->route_option;
1392   char prefix[PREFIX2STR_BUFFER], id[16], forwarding[64];
1393   u_int32_t tmp_id;
1394
1395   prefix2str (&route->prefix, prefix, sizeof (prefix));
1396   tmp_id = ntohl (info->id);
1397   inet_ntop (AF_INET, &tmp_id, id, sizeof (id));
1398   if (! IN6_IS_ADDR_UNSPECIFIED (&info->forwarding))
1399     inet_ntop (AF_INET6, &info->forwarding, forwarding, sizeof (forwarding));
1400   else
1401     snprintf (forwarding, sizeof (forwarding), ":: (ifindex %d)",
1402               ospf6_route_get_first_nh_index (route));
1403
1404   vty_out (vty, "%c %-32s %-15s type-%d %5lu %s%s",
1405            zebra_route_char(info->type),
1406            prefix, id, route->path.metric_type,
1407            (u_long) (route->path.metric_type == 2 ?
1408                      route->path.u.cost_e2 : route->path.cost),
1409            forwarding, VNL);
1410 }
1411
1412 DEFUN (show_ipv6_ospf6_redistribute,
1413        show_ipv6_ospf6_redistribute_cmd,
1414        "show ipv6 ospf6 redistribute",
1415        SHOW_STR
1416        IP6_STR
1417        OSPF6_STR
1418        "redistributing External information\n"
1419        )
1420 {
1421   struct ospf6_route *route;
1422
1423   OSPF6_CMD_CHECK_RUNNING ();
1424
1425   ospf6_redistribute_show_config (vty);
1426
1427   for (route = ospf6_route_head (ospf6->external_table); route;
1428        route = ospf6_route_next (route))
1429     ospf6_asbr_external_route_show (vty, route);
1430
1431   return CMD_SUCCESS;
1432 }
1433
1434 struct ospf6_lsa_handler as_external_handler =
1435 {
1436   OSPF6_LSTYPE_AS_EXTERNAL,
1437   "AS-External",
1438   "ASE",
1439   ospf6_as_external_lsa_show,
1440   ospf6_as_external_lsa_get_prefix_str
1441 };
1442
1443 void
1444 ospf6_asbr_init (void)
1445 {
1446   ospf6_routemap_init ();
1447
1448   ospf6_install_lsa_handler (&as_external_handler);
1449
1450   install_element (VIEW_NODE, &show_ipv6_ospf6_redistribute_cmd);
1451
1452   install_element (OSPF6_NODE, &ospf6_redistribute_cmd);
1453   install_element (OSPF6_NODE, &ospf6_redistribute_routemap_cmd);
1454   install_element (OSPF6_NODE, &no_ospf6_redistribute_cmd);
1455 }
1456
1457 void
1458 ospf6_asbr_redistribute_reset (void)
1459 {
1460   int type;
1461
1462   for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
1463     {
1464       if (type == ZEBRA_ROUTE_OSPF6)
1465         continue;
1466       if (ospf6_zebra_is_redistribute (type))
1467         ospf6_asbr_redistribute_unset(type);
1468     }
1469 }
1470
1471 void
1472 ospf6_asbr_terminate (void)
1473 {
1474   route_map_finish ();
1475 }
1476
1477 DEFUN (debug_ospf6_asbr,
1478        debug_ospf6_asbr_cmd,
1479        "debug ospf6 asbr",
1480        DEBUG_STR
1481        OSPF6_STR
1482        "Debug OSPFv3 ASBR function\n"
1483       )
1484 {
1485   OSPF6_DEBUG_ASBR_ON ();
1486   return CMD_SUCCESS;
1487 }
1488
1489 DEFUN (no_debug_ospf6_asbr,
1490        no_debug_ospf6_asbr_cmd,
1491        "no debug ospf6 asbr",
1492        NO_STR
1493        DEBUG_STR
1494        OSPF6_STR
1495        "Debug OSPFv3 ASBR function\n"
1496       )
1497 {
1498   OSPF6_DEBUG_ASBR_OFF ();
1499   return CMD_SUCCESS;
1500 }
1501
1502 int
1503 config_write_ospf6_debug_asbr (struct vty *vty)
1504 {
1505   if (IS_OSPF6_DEBUG_ASBR)
1506     vty_out (vty, "debug ospf6 asbr%s", VNL);
1507   return 0;
1508 }
1509
1510 void
1511 install_element_ospf6_debug_asbr ()
1512 {
1513   install_element (ENABLE_NODE, &debug_ospf6_asbr_cmd);
1514   install_element (ENABLE_NODE, &no_debug_ospf6_asbr_cmd);
1515   install_element (CONFIG_NODE, &debug_ospf6_asbr_cmd);
1516   install_element (CONFIG_NODE, &no_debug_ospf6_asbr_cmd);
1517 }