ospfd/ospf_zebra.c

   1 /*
   2  * Zebra connect library for OSPFd
   3  * Copyright (C) 1997, 98, 99, 2000 Kunihiro Ishiguro, Toshiaki Takada
   4  *
   5  * This file is part of GNU Zebra.
   6  *
   7  * GNU Zebra is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; either version 2, or (at your option) any
  10  * later version.
  11  *
  12  * GNU Zebra is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with GNU Zebra; see the file COPYING.  If not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #include <zebra.h>
  24
  25 #include "thread.h"
  26 #include "command.h"
  27 #include "network.h"
  28 #include "prefix.h"
  29 #include "routemap.h"
  30 #include "table.h"
  31 #include "stream.h"
  32 #include "memory.h"
  33 #include "zclient.h"
  34 #include "filter.h"
  35 #include "plist.h"
  36 #include "log.h"
  37
  38 #include "ospfd/ospfd.h"
  39 #include "ospfd/ospf_interface.h"
  40 #include "ospfd/ospf_ism.h"
  41 #include "ospfd/ospf_asbr.h"
  42 #include "ospfd/ospf_asbr.h"
  43 #include "ospfd/ospf_abr.h"
  44 #include "ospfd/ospf_lsa.h"
  45 #include "ospfd/ospf_dump.h"
  46 #include "ospfd/ospf_route.h"
  47 #include "ospfd/ospf_zebra.h"
  48 #ifdef HAVE_SNMP
  49 #include "ospfd/ospf_snmp.h"
  50 #endif /* HAVE_SNMP */
  51
  52 /* Zebra structure to hold current status. */
  53 struct zclient *zclient = NULL;
  54
  55 /* For registering threads. */
  56 extern struct thread_master *master;
  57 struct in_addr router_id_zebra;
  58
  59 /* Router-id update message from zebra. */
  60 int
  61 ospf_router_id_update_zebra (int command, struct zclient *zclient,
  62                              zebra_size_t length)
  63 {
  64   struct ospf *ospf;
  65   struct prefix router_id;
  66   zebra_router_id_update_read(zclient->ibuf,&router_id);
  67
  68   router_id_zebra = router_id.u.prefix4;
  69
  70   ospf = ospf_lookup ();
  71   if (ospf != NULL)
  72     {
  73       if (ospf->t_router_id_update == NULL)
  74         OSPF_TIMER_ON (ospf->t_router_id_update, ospf_router_id_update_timer,
  75                        OSPF_ROUTER_ID_UPDATE_DELAY);
  76     }
  77   return 0;
  78 }
  79
  80 /* Inteface addition message from zebra. */
  81 int
  82 ospf_interface_add (int command, struct zclient *zclient, zebra_size_t length)
  83 {
  84   struct interface *ifp;
  85   struct ospf *ospf;
  86
  87   ifp = zebra_interface_add_read (zclient->ibuf);
  88
  89   if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
  90     zlog_debug ("Zebra: interface add %s index %d flags %ld metric %d mtu %d",
  91                ifp->name, ifp->ifindex, ifp->flags, ifp->metric, ifp->mtu);
  92
  93   assert (ifp->info);
  94
  95   if (!OSPF_IF_PARAM_CONFIGURED (IF_DEF_PARAMS (ifp), type))
  96     {
  97       SET_IF_PARAM (IF_DEF_PARAMS (ifp), type);
  98       IF_DEF_PARAMS (ifp)->type = ospf_default_iftype(ifp);
  99     }
 100
 101   ospf = ospf_lookup ();
 102   if (ospf != NULL)
 103     ospf_if_update (ospf);
 104
 105 #ifdef HAVE_SNMP
 106   ospf_snmp_if_update (ifp);
 107 #endif /* HAVE_SNMP */
 108
 109   return 0;
 110 }
 111
 112 int
 113 ospf_interface_delete (int command, struct zclient *zclient,
 114                        zebra_size_t length)
 115 {
 116   struct interface *ifp;
 117   struct stream *s;
 118   struct route_node *rn;
 119
 120   s = zclient->ibuf;
 121   /* zebra_interface_state_read() updates interface structure in iflist */
 122   ifp = zebra_interface_state_read (s);
 123
 124   if (ifp == NULL)
 125     return 0;
 126
 127   if (if_is_up (ifp))
 128     zlog_warn ("Zebra: got delete of %s, but interface is still up",
 129                ifp->name);
 130
 131   if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
 132     zlog_debug
 133       ("Zebra: interface delete %s index %d flags %ld metric %d mtu %d",
 134        ifp->name, ifp->ifindex, ifp->flags, ifp->metric, ifp->mtu);
 135
 136 #ifdef HAVE_SNMP
 137   ospf_snmp_if_delete (ifp);
 138 #endif /* HAVE_SNMP */
 139
 140   for (rn = route_top (IF_OIFS (ifp)); rn; rn = route_next (rn))
 141     if (rn->info)
 142       ospf_if_free ((struct ospf_interface *) rn->info);
 143
 144   ifp->ifindex = IFINDEX_INTERNAL;
 145   return 0;
 146 }
 147
 148 static struct interface *
 149 zebra_interface_if_lookup (struct stream *s)
 150 {
 151   char ifname_tmp[INTERFACE_NAMSIZ];
 152
 153   /* Read interface name. */
 154   stream_get (ifname_tmp, s, INTERFACE_NAMSIZ);
 155
 156   /* And look it up. */
 157   return if_lookup_by_name_len(ifname_tmp,
 158                                strnlen(ifname_tmp, INTERFACE_NAMSIZ));
 159 }
 160
 161 int
 162 ospf_interface_state_up (int command, struct zclient *zclient,
 163                          zebra_size_t length)
 164 {
 165   struct interface *ifp;
 166   struct ospf_interface *oi;
 167   struct route_node *rn;
 168
 169   ifp = zebra_interface_if_lookup (zclient->ibuf);
 170
 171   if (ifp == NULL)
 172     return 0;
 173
 174   /* Interface is already up. */
 175   if (if_is_operative (ifp))
 176     {
 177       /* Temporarily keep ifp values. */
 178       struct interface if_tmp;
 179       memcpy (&if_tmp, ifp, sizeof (struct interface));
 180
 181       zebra_interface_if_set_value (zclient->ibuf, ifp);
 182
 183       if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
 184         zlog_debug ("Zebra: Interface[%s] state update.", ifp->name);
 185
 186       if (if_tmp.bandwidth != ifp->bandwidth)
 187         {
 188           if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
 189             zlog_debug ("Zebra: Interface[%s] bandwidth change %d -> %d.",
 190                        ifp->name, if_tmp.bandwidth, ifp->bandwidth);
 191
 192           ospf_if_recalculate_output_cost (ifp);
 193         }
 194
 195       if (if_tmp.mtu != ifp->mtu)
 196         {
 197           if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
 198             zlog_debug ("Zebra: Interface[%s] MTU change %u -> %u.",
 199                        ifp->name, if_tmp.mtu, ifp->mtu);
 200
 201           /* Must reset the interface (simulate down/up) when MTU changes. */
 202           ospf_if_reset(ifp);
 203         }
 204       return 0;
 205     }
 206
 207   zebra_interface_if_set_value (zclient->ibuf, ifp);
 208
 209   if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
 210     zlog_debug ("Zebra: Interface[%s] state change to up.", ifp->name);
 211
 212   for (rn = route_top (IF_OIFS (ifp)); rn; rn = route_next (rn))
 213     {
 214       if ((oi = rn->info) == NULL)
 215         continue;
 216
 217       ospf_if_up (oi);
 218     }
 219
 220   return 0;
 221 }
 222
 223 int
 224 ospf_interface_state_down (int command, struct zclient *zclient,
 225                            zebra_size_t length)
 226 {
 227   struct interface *ifp;
 228   struct ospf_interface *oi;
 229   struct route_node *node;
 230
 231   ifp = zebra_interface_state_read (zclient->ibuf);
 232
 233   if (ifp == NULL)
 234     return 0;
 235
 236   if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
 237     zlog_debug ("Zebra: Interface[%s] state change to down.", ifp->name);
 238
 239   for (node = route_top (IF_OIFS (ifp)); node; node = route_next (node))
 240     {
 241       if ((oi = node->info) == NULL)
 242         continue;
 243       ospf_if_down (oi);
 244     }
 245
 246   return 0;
 247 }
 248
 249 int
 250 ospf_interface_address_add (int command, struct zclient *zclient,
 251                             zebra_size_t length)
 252 {
 253   struct ospf *ospf;
 254   struct connected *c;
 255
 256   c = zebra_interface_address_read (command, zclient->ibuf);
 257
 258   if (c == NULL)
 259     return 0;
 260
 261   ospf = ospf_lookup ();
 262   if (ospf != NULL)
 263     ospf_if_update (ospf);
 264
 265 #ifdef HAVE_SNMP
 266   ospf_snmp_if_update (c->ifp);
 267 #endif /* HAVE_SNMP */
 268
 269   return 0;
 270 }
 271
 272 int
 273 ospf_interface_address_delete (int command, struct zclient *zclient,
 274                                zebra_size_t length)
 275 {
 276   struct ospf *ospf;
 277   struct connected *c;
 278   struct interface *ifp;
 279   struct ospf_interface *oi;
 280   struct route_node *rn;
 281   struct prefix p;
 282
 283   c = zebra_interface_address_read (command, zclient->ibuf);
 284
 285   if (c == NULL)
 286     return 0;
 287
 288   ifp = c->ifp;
 289   p = *c->address;
 290   p.prefixlen = IPV4_MAX_PREFIXLEN;
 291
 292   rn = route_node_lookup (IF_OIFS (ifp), &p);
 293   if (!rn)
 294     return 0;
 295
 296   assert (rn->info);
 297   oi = rn->info;
 298
 299   /* Call interface hook functions to clean up */
 300   ospf_if_free (oi);
 301
 302 #ifdef HAVE_SNMP
 303   ospf_snmp_if_update (c->ifp);
 304 #endif /* HAVE_SNMP */
 305
 306   connected_free (c);
 307
 308   ospf = ospf_lookup ();
 309   if (ospf != NULL)
 310     ospf_if_update (ospf);
 311
 312   return 0;
 313 }
 314
 315 void
 316 ospf_zebra_add (struct prefix_ipv4 *p, struct ospf_route *or)
 317 {
 318   u_char message;
 319   u_char distance;
 320   u_char flags;
 321   int psize;
 322   struct stream *s;
 323   struct ospf_path *path;
 324   struct listnode *node;
 325
 326   if (zclient->redist[ZEBRA_ROUTE_OSPF])
 327     {
 328       message = 0;
 329       flags = 0;
 330
 331       /* OSPF pass nexthop and metric */
 332       SET_FLAG (message, ZAPI_MESSAGE_NEXTHOP);
 333       SET_FLAG (message, ZAPI_MESSAGE_METRIC);
 334
 335       /* Distance value. */
 336       distance = ospf_distance_apply (p, or);
 337       if (distance)
 338         SET_FLAG (message, ZAPI_MESSAGE_DISTANCE);
 339
 340       /* Make packet. */
 341       s = zclient->obuf;
 342       stream_reset (s);
 343
 344       /* Length place holder. */
 345       stream_putw (s, 0);
 346
 347       /* Put command, type, flags, message. */
 348       stream_putc (s, ZEBRA_IPV4_ROUTE_ADD);
 349       stream_putc (s, ZEBRA_ROUTE_OSPF);
 350       stream_putc (s, flags);
 351       stream_putc (s, message);
 352
 353       /* Put prefix information. */
 354       psize = PSIZE (p->prefixlen);
 355       stream_putc (s, p->prefixlen);
 356       stream_write (s, (u_char *) & p->prefix, psize);
 357
 358       /* Nexthop count. */
 359       stream_putc (s, or->paths->count);
 360
 361       /* Nexthop, ifindex, distance and metric information. */
 362       for (ALL_LIST_ELEMENTS_RO (or->paths, node, path))
 363         {
 364           if (path->nexthop.s_addr != INADDR_ANY)
 365             {
 366               stream_putc (s, ZEBRA_NEXTHOP_IPV4);
 367               stream_put_in_addr (s, &path->nexthop);
 368             }
 369           else
 370             {
 371               stream_putc (s, ZEBRA_NEXTHOP_IFINDEX);
 372               if (path->oi)
 373                 stream_putl (s, path->oi->ifp->ifindex);
 374               else
 375                 stream_putl (s, 0);
 376             }
 377
 378           if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
 379             {
 380               zlog_debug ("Zebra: Route add %s/%d nexthop %s",
 381                          inet_ntoa (p->prefix),
 382                          p->prefixlen, inet_ntoa (path->nexthop));
 383             }
 384         }
 385
 386       if (CHECK_FLAG (message, ZAPI_MESSAGE_DISTANCE))
 387         stream_putc (s, distance);
 388       if (CHECK_FLAG (message, ZAPI_MESSAGE_METRIC))
 389         {
 390           if (or->path_type == OSPF_PATH_TYPE1_EXTERNAL)
 391             stream_putl (s, or->cost + or->u.ext.type2_cost);
 392           else if (or->path_type == OSPF_PATH_TYPE2_EXTERNAL)
 393             stream_putl (s, or->u.ext.type2_cost);
 394           else
 395             stream_putl (s, or->cost);
 396         }
 397
 398       stream_putw_at (s, 0, stream_get_endp (s));
 399
 400       writen (zclient->sock, s->data, stream_get_endp (s));
 401     }
 402 }
 403
 404 void
 405 ospf_zebra_delete (struct prefix_ipv4 *p, struct ospf_route *or)
 406 {
 407   struct zapi_ipv4 api;
 408   struct ospf_path *path;
 409   struct in_addr *nexthop;
 410   struct listnode *node, *nnode;
 411
 412   if (zclient->redist[ZEBRA_ROUTE_OSPF])
 413     {
 414       api.type = ZEBRA_ROUTE_OSPF;
 415       api.flags = 0;
 416       api.message = 0;
 417       api.ifindex_num = 0;
 418       api.nexthop_num = 0;
 419
 420       for (ALL_LIST_ELEMENTS (or->paths, node, nnode, path))
 421         {
 422           if (path->nexthop.s_addr != INADDR_ANY)
 423             {
 424               SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
 425               api.nexthop_num = 1;
 426               nexthop = &path->nexthop;
 427               api.nexthop = &nexthop;
 428             }
 429           else if (ospf_if_exists(path->oi) && (path->oi->ifp))
 430             {
 431               SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
 432               api.ifindex_num = 1;
 433               api.ifindex = &path->oi->ifp->ifindex;
 434             }
 435           else if ( IS_DEBUG_OSPF(zebra,ZEBRA_REDISTRIBUTE) )
 436             {
 437               zlog_debug("Zebra: no ifp %s %d",
 438                          inet_ntoa(p->prefix),
 439                          p->prefixlen);
 440             }
 441
 442           zapi_ipv4_route (ZEBRA_IPV4_ROUTE_DELETE, zclient, p, &api);
 443
 444           if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE) && api.nexthop_num)
 445             {
 446               zlog_debug ("Zebra: Route delete %s/%d nexthop %s",
 447                          inet_ntoa (p->prefix),
 448                          p->prefixlen, inet_ntoa (**api.nexthop));
 449             }
 450           if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE) && api.ifindex_num)
 451             {
 452               zlog_debug ("Zebra: Route delete %s/%d ifindex %d",
 453                          inet_ntoa (p->prefix),
 454                          p->prefixlen, *api.ifindex);
 455             }
 456         }
 457     }
 458 }
 459
 460 void
 461 ospf_zebra_add_discard (struct prefix_ipv4 *p)
 462 {
 463   struct zapi_ipv4 api;
 464
 465   if (zclient->redist[ZEBRA_ROUTE_OSPF])
 466     {
 467       api.type = ZEBRA_ROUTE_OSPF;
 468       api.flags = ZEBRA_FLAG_BLACKHOLE;
 469       api.message = 0;
 470       SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
 471       api.nexthop_num = 0;
 472       api.ifindex_num = 0;
 473
 474       zapi_ipv4_route (ZEBRA_IPV4_ROUTE_ADD, zclient, p, &api);
 475     }
 476 }
 477
 478 void
 479 ospf_zebra_delete_discard (struct prefix_ipv4 *p)
 480 {
 481   struct zapi_ipv4 api;
 482
 483   if (zclient->redist[ZEBRA_ROUTE_OSPF])
 484     {
 485       api.type = ZEBRA_ROUTE_OSPF;
 486       api.flags = ZEBRA_FLAG_BLACKHOLE;
 487       api.message = 0;
 488       SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
 489       api.nexthop_num = 0;
 490       api.ifindex_num = 0;
 491
 492       zapi_ipv4_route (ZEBRA_IPV4_ROUTE_DELETE, zclient, p, &api);
 493
 494       if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
 495         zlog_debug ("Zebra: Route delete discard %s/%d",
 496                    inet_ntoa (p->prefix), p->prefixlen);
 497
 498     }
 499 }
 500
 501 int
 502 ospf_is_type_redistributed (int type)
 503 {
 504   return (DEFAULT_ROUTE_TYPE (type)) ?
 505     zclient->default_information : zclient->redist[type];
 506 }
 507
 508 int
 509 ospf_redistribute_set (struct ospf *ospf, int type, int mtype, int mvalue)
 510 {
 511   int force = 0;
 512
 513   if (ospf_is_type_redistributed (type))
 514     {
 515       if (mtype != ospf->dmetric[type].type)
 516         {
 517           ospf->dmetric[type].type = mtype;
 518           force = LSA_REFRESH_FORCE;
 519         }
 520       if (mvalue != ospf->dmetric[type].value)
 521         {
 522           ospf->dmetric[type].value = mvalue;
 523           force = LSA_REFRESH_FORCE;
 524         }
 525
 526       ospf_external_lsa_refresh_type (ospf, type, force);
 527
 528       if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
 529         zlog_debug ("Redistribute[%s]: Refresh  Type[%d], Metric[%d]",
 530                    LOOKUP (ospf_redistributed_proto, type),
 531                    metric_type (ospf, type), metric_value (ospf, type));
 532
 533       return CMD_SUCCESS;
 534     }
 535
 536   ospf->dmetric[type].type = mtype;
 537   ospf->dmetric[type].value = mvalue;
 538
 539   zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, type);
 540
 541   if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
 542     zlog_debug ("Redistribute[%s]: Start  Type[%d], Metric[%d]",
 543                LOOKUP (ospf_redistributed_proto, type),
 544                metric_type (ospf, type), metric_value (ospf, type));
 545
 546   ospf_asbr_status_update (ospf, ++ospf->redistribute);
 547
 548   return CMD_SUCCESS;
 549 }
 550
 551 int
 552 ospf_redistribute_unset (struct ospf *ospf, int type)
 553 {
 554   if (type == zclient->redist_default)
 555     return CMD_SUCCESS;
 556
 557   if (!ospf_is_type_redistributed (type))
 558     return CMD_SUCCESS;
 559
 560   zclient_redistribute (ZEBRA_REDISTRIBUTE_DELETE, zclient, type);
 561
 562   if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
 563     zlog_debug ("Redistribute[%s]: Stop",
 564                LOOKUP (ospf_redistributed_proto, type));
 565
 566   ospf->dmetric[type].type = -1;
 567   ospf->dmetric[type].value = -1;
 568
 569   /* Remove the routes from OSPF table. */
 570   ospf_redistribute_withdraw (type);
 571
 572   ospf_asbr_status_update (ospf, --ospf->redistribute);
 573
 574   return CMD_SUCCESS;
 575 }
 576
 577 int
 578 ospf_redistribute_default_set (struct ospf *ospf, int originate,
 579                                int mtype, int mvalue)
 580 {
 581   int force = 0;
 582
 583   if (ospf_is_type_redistributed (DEFAULT_ROUTE))
 584     {
 585       if (mtype != ospf->dmetric[DEFAULT_ROUTE].type)
 586         {
 587           ospf->dmetric[DEFAULT_ROUTE].type = mtype;
 588           force = 1;
 589         }
 590       if (mvalue != ospf->dmetric[DEFAULT_ROUTE].value)
 591         {
 592           force = 1;
 593           ospf->dmetric[DEFAULT_ROUTE].value = mvalue;
 594         }
 595
 596       ospf_external_lsa_refresh_default (ospf);
 597
 598       if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
 599         zlog_debug ("Redistribute[%s]: Refresh  Type[%d], Metric[%d]",
 600                    LOOKUP (ospf_redistributed_proto, DEFAULT_ROUTE),
 601                    metric_type (ospf, DEFAULT_ROUTE),
 602                    metric_value (ospf, DEFAULT_ROUTE));
 603       return CMD_SUCCESS;
 604     }
 605
 606   ospf->default_originate = originate;
 607   ospf->dmetric[DEFAULT_ROUTE].type = mtype;
 608   ospf->dmetric[DEFAULT_ROUTE].value = mvalue;
 609
 610   zclient_redistribute_default (ZEBRA_REDISTRIBUTE_DEFAULT_ADD, zclient);
 611
 612   if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
 613     zlog_debug ("Redistribute[DEFAULT]: Start  Type[%d], Metric[%d]",
 614                metric_type (ospf, DEFAULT_ROUTE),
 615                metric_value (ospf, DEFAULT_ROUTE));
 616
 617   if (ospf->router_id.s_addr == 0)
 618     ospf->external_origin |= (1 << DEFAULT_ROUTE);
 619   else
 620     thread_add_timer (master, ospf_default_originate_timer,
 621                       &ospf->default_originate, 1);
 622
 623   ospf_asbr_status_update (ospf, ++ospf->redistribute);
 624
 625   return CMD_SUCCESS;
 626 }
 627
 628 int
 629 ospf_redistribute_default_unset (struct ospf *ospf)
 630 {
 631   if (!ospf_is_type_redistributed (DEFAULT_ROUTE))
 632     return CMD_SUCCESS;
 633
 634   ospf->default_originate = DEFAULT_ORIGINATE_NONE;
 635   ospf->dmetric[DEFAULT_ROUTE].type = -1;
 636   ospf->dmetric[DEFAULT_ROUTE].value = -1;
 637
 638   zclient_redistribute_default (ZEBRA_REDISTRIBUTE_DEFAULT_DELETE, zclient);
 639
 640   if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
 641     zlog_debug ("Redistribute[DEFAULT]: Stop");
 642
 643   ospf_asbr_status_update (ospf, --ospf->redistribute);
 644
 645   return CMD_SUCCESS;
 646 }
 647
 648 int
 649 ospf_external_lsa_originate_check (struct ospf *ospf,
 650                                    struct external_info *ei)
 651 {
 652   /* If prefix is multicast, then do not originate LSA. */
 653   if (IN_MULTICAST (htonl (ei->p.prefix.s_addr)))
 654     {
 655       zlog_info ("LSA[Type5:%s]: Not originate AS-external-LSA, "
 656                  "Prefix belongs multicast", inet_ntoa (ei->p.prefix));
 657       return 0;
 658     }
 659
 660   /* Take care of default-originate. */
 661   if (is_prefix_default (&ei->p))
 662     if (ospf->default_originate == DEFAULT_ORIGINATE_NONE)
 663       {
 664         zlog_info ("LSA[Type5:0.0.0.0]: Not originate AS-exntenal-LSA "
 665                    "for default");
 666         return 0;
 667       }
 668
 669   return 1;
 670 }
 671
 672 /* If connected prefix is OSPF enable interface, then do not announce. */
 673 int
 674 ospf_distribute_check_connected (struct ospf *ospf, struct external_info *ei)
 675 {
 676   struct route_node *rn;
 677
 678   for (rn = route_top (ospf->networks); rn; rn = route_next (rn))
 679     if (rn->info != NULL)
 680       if (prefix_match (&rn->p, (struct prefix *) &ei->p))
 681         {
 682           route_unlock_node (rn);
 683           return 0;
 684         }
 685
 686   return 1;
 687 }
 688
 689 /* return 1 if external LSA must be originated, 0 otherwise */
 690 int
 691 ospf_redistribute_check (struct ospf *ospf,
 692                          struct external_info *ei, int *changed)
 693 {
 694   struct route_map_set_values save_values;
 695   struct prefix_ipv4 *p = &ei->p;
 696   u_char type = is_prefix_default (&ei->p) ? DEFAULT_ROUTE : ei->type;
 697
 698   if (changed)
 699     *changed = 0;
 700
 701   if (!ospf_external_lsa_originate_check (ospf, ei))
 702     return 0;
 703
 704   /* Take care connected route. */
 705   if (type == ZEBRA_ROUTE_CONNECT &&
 706       !ospf_distribute_check_connected (ospf, ei))
 707     return 0;
 708
 709   if (!DEFAULT_ROUTE_TYPE (type) && DISTRIBUTE_NAME (ospf, type))
 710     /* distirbute-list exists, but access-list may not? */
 711     if (DISTRIBUTE_LIST (ospf, type))
 712       if (access_list_apply (DISTRIBUTE_LIST (ospf, type), p) == FILTER_DENY)
 713         {
 714           if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
 715             zlog_debug ("Redistribute[%s]: %s/%d filtered by ditribute-list.",
 716                        LOOKUP (ospf_redistributed_proto, type),
 717                        inet_ntoa (p->prefix), p->prefixlen);
 718           return 0;
 719         }
 720
 721   save_values = ei->route_map_set;
 722   ospf_reset_route_map_set_values (&ei->route_map_set);
 723
 724   /* apply route-map if needed */
 725   if (ROUTEMAP_NAME (ospf, type))
 726     {
 727       int ret;
 728
 729       ret = route_map_apply (ROUTEMAP (ospf, type), (struct prefix *) p,
 730                              RMAP_OSPF, ei);
 731
 732       if (ret == RMAP_DENYMATCH)
 733         {
 734           ei->route_map_set = save_values;
 735           if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
 736             zlog_debug ("Redistribute[%s]: %s/%d filtered by route-map.",
 737                        LOOKUP (ospf_redistributed_proto, type),
 738                        inet_ntoa (p->prefix), p->prefixlen);
 739           return 0;
 740         }
 741
 742       /* check if 'route-map set' changed something */
 743       if (changed)
 744         *changed = !ospf_route_map_set_compare (&ei->route_map_set,
 745                                                 &save_values);
 746     }
 747
 748   return 1;
 749 }
 750
 751 /* OSPF route-map set for redistribution */
 752 void
 753 ospf_routemap_set (struct ospf *ospf, int type, const char *name)
 754 {
 755   if (ROUTEMAP_NAME (ospf, type))
 756     free (ROUTEMAP_NAME (ospf, type));
 757
 758   ROUTEMAP_NAME (ospf, type) = strdup (name);
 759   ROUTEMAP (ospf, type) = route_map_lookup_by_name (name);
 760 }
 761
 762 void
 763 ospf_routemap_unset (struct ospf *ospf, int type)
 764 {
 765   if (ROUTEMAP_NAME (ospf, type))
 766     free (ROUTEMAP_NAME (ospf, type));
 767
 768   ROUTEMAP_NAME (ospf, type) = NULL;
 769   ROUTEMAP (ospf, type) = NULL;
 770 }
 771
 772 /* Zebra route add and delete treatment. */
 773 int
 774 ospf_zebra_read_ipv4 (int command, struct zclient *zclient,
 775                       zebra_size_t length)
 776 {
 777   struct stream *s;
 778   struct zapi_ipv4 api;
 779   unsigned long ifindex;
 780   struct in_addr nexthop;
 781   struct prefix_ipv4 p;
 782   struct external_info *ei;
 783   struct ospf *ospf;
 784
 785   s = zclient->ibuf;
 786   ifindex = 0;
 787   nexthop.s_addr = 0;
 788
 789   /* Type, flags, message. */
 790   api.type = stream_getc (s);
 791   api.flags = stream_getc (s);
 792   api.message = stream_getc (s);
 793
 794   /* IPv4 prefix. */
 795   memset (&p, 0, sizeof (struct prefix_ipv4));
 796   p.family = AF_INET;
 797   p.prefixlen = stream_getc (s);
 798   stream_get (&p.prefix, s, PSIZE (p.prefixlen));
 799
 800   if (IPV4_NET127(ntohl(p.prefix.s_addr)))
 801     return 0;
 802
 803   /* Nexthop, ifindex, distance, metric. */
 804   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
 805     {
 806       api.nexthop_num = stream_getc (s);
 807       nexthop.s_addr = stream_get_ipv4 (s);
 808     }
 809   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX))
 810     {
 811       api.ifindex_num = stream_getc (s);
 812       /* XXX assert(api.ifindex_num == 1); */
 813       ifindex = stream_getl (s);
 814     }
 815   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
 816     api.distance = stream_getc (s);
 817   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
 818     api.metric = stream_getl (s);
 819
 820   ospf = ospf_lookup ();
 821   if (ospf == NULL)
 822     return 0;
 823
 824   if (command == ZEBRA_IPV4_ROUTE_ADD)
 825     {
 826       /* XXX|HACK|TODO|FIXME:
 827        * Maybe we should ignore reject/blackhole routes? Testing shows that
 828        * there is no problems though and this is only way to "summarize"
 829        * routes in ASBR at the moment. Maybe we need just a better generalised
 830        * solution for these types?
 831        *
 832        * if ( CHECK_FLAG (api.flags, ZEBRA_FLAG_BLACKHOLE)
 833        *     || CHECK_FLAG (api.flags, ZEBRA_FLAG_REJECT))
 834        * return 0;
 835        */
 836
 837       ei = ospf_external_info_add (api.type, p, ifindex, nexthop);
 838
 839       if (ospf->router_id.s_addr == 0)
 840         /* Set flags to generate AS-external-LSA originate event
 841            for each redistributed protocols later. */
 842         ospf->external_origin |= (1 << api.type);
 843       else
 844         {
 845           if (ei)
 846             {
 847               if (is_prefix_default (&p))
 848                 ospf_external_lsa_refresh_default (ospf);
 849               else
 850                 {
 851                   struct ospf_lsa *current;
 852
 853                   current = ospf_external_info_find_lsa (ospf, &ei->p);
 854                   if (!current)
 855                     ospf_external_lsa_originate (ospf, ei);
 856                   else if (IS_LSA_MAXAGE (current))
 857                     ospf_external_lsa_refresh (ospf, current,
 858                                                ei, LSA_REFRESH_FORCE);
 859                   else
 860                     zlog_warn ("ospf_zebra_read_ipv4() : %s already exists",
 861                                inet_ntoa (p.prefix));
 862                 }
 863             }
 864         }
 865     }
 866   else                          /* if (command == ZEBRA_IPV4_ROUTE_DELETE) */
 867     {
 868       ospf_external_info_delete (api.type, p);
 869       if (is_prefix_default (&p))
 870         ospf_external_lsa_refresh_default (ospf);
 871       else
 872         ospf_external_lsa_flush (ospf, api.type, &p, ifindex, nexthop);
 873     }
 874
 875   return 0;
 876 }
 877 \f
 878
 879 int
 880 ospf_distribute_list_out_set (struct ospf *ospf, int type, const char *name)
 881 {
 882   /* Lookup access-list for distribute-list. */
 883   DISTRIBUTE_LIST (ospf, type) = access_list_lookup (AFI_IP, name);
 884
 885   /* Clear previous distribute-name. */
 886   if (DISTRIBUTE_NAME (ospf, type))
 887     free (DISTRIBUTE_NAME (ospf, type));
 888
 889   /* Set distribute-name. */
 890   DISTRIBUTE_NAME (ospf, type) = strdup (name);
 891
 892   /* If access-list have been set, schedule update timer. */
 893   if (DISTRIBUTE_LIST (ospf, type))
 894     ospf_distribute_list_update (ospf, type);
 895
 896   return CMD_SUCCESS;
 897 }
 898
 899 int
 900 ospf_distribute_list_out_unset (struct ospf *ospf, int type, const char *name)
 901 {
 902   /* Schedule update timer. */
 903   if (DISTRIBUTE_LIST (ospf, type))
 904     ospf_distribute_list_update (ospf, type);
 905
 906   /* Unset distribute-list. */
 907   DISTRIBUTE_LIST (ospf, type) = NULL;
 908
 909   /* Clear distribute-name. */
 910   if (DISTRIBUTE_NAME (ospf, type))
 911     free (DISTRIBUTE_NAME (ospf, type));
 912
 913   DISTRIBUTE_NAME (ospf, type) = NULL;
 914
 915   return CMD_SUCCESS;
 916 }
 917
 918 /* distribute-list update timer. */
 919 int
 920 ospf_distribute_list_update_timer (struct thread *thread)
 921 {
 922   struct route_node *rn;
 923   struct external_info *ei;
 924   struct route_table *rt;
 925   struct ospf_lsa *lsa;
 926   int type;
 927   struct ospf *ospf;
 928
 929   type = (int) THREAD_ARG (thread);
 930   assert (type < ZEBRA_ROUTE_MAX);
 931
 932   rt = EXTERNAL_INFO (type);
 933
 934   ospf = ospf_lookup ();
 935   if (ospf == NULL)
 936     return 0;
 937
 938   ospf->t_distribute_update = NULL;
 939
 940   zlog_info ("Zebra[Redistribute]: distribute-list update timer fired!");
 941
 942   /* foreach all external info. */
 943   if (rt)
 944     for (rn = route_top (rt); rn; rn = route_next (rn))
 945       if ((ei = rn->info) != NULL)
 946         {
 947           if (is_prefix_default (&ei->p))
 948             ospf_external_lsa_refresh_default (ospf);
 949           else if ((lsa = ospf_external_info_find_lsa (ospf, &ei->p)))
 950             ospf_external_lsa_refresh (ospf, lsa, ei, LSA_REFRESH_IF_CHANGED);
 951           else
 952             ospf_external_lsa_originate (ospf, ei);
 953         }
 954   return 0;
 955 }
 956
 957 #define OSPF_DISTRIBUTE_UPDATE_DELAY 5
 958
 959 /* Update distribute-list and set timer to apply access-list. */
 960 void
 961 ospf_distribute_list_update (struct ospf *ospf, int type)
 962 {
 963   struct route_table *rt;
 964
 965   /* External info does not exist. */
 966   if (!(rt = EXTERNAL_INFO (type)))
 967     return;
 968
 969   /* If exists previously invoked thread, then cancel it. */
 970   if (ospf->t_distribute_update)
 971     OSPF_TIMER_OFF (ospf->t_distribute_update);
 972
 973   /* Set timer. */
 974   ospf->t_distribute_update =
 975     thread_add_timer (master, ospf_distribute_list_update_timer,
 976                       (void *) type, OSPF_DISTRIBUTE_UPDATE_DELAY);
 977 }
 978
 979 /* If access-list is updated, apply some check. */
 980 void
 981 ospf_filter_update (struct access_list *access)
 982 {
 983   struct ospf *ospf;
 984   int type;
 985   int abr_inv = 0;
 986   struct ospf_area *area;
 987   struct listnode *node;
 988
 989   /* If OSPF instatnce does not exist, return right now. */
 990   ospf = ospf_lookup ();
 991   if (ospf == NULL)
 992     return;
 993
 994   /* Update distribute-list, and apply filter. */
 995   for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
 996     {
 997       if (ROUTEMAP (ospf, type) != NULL)
 998         {
 999           /* if route-map is not NULL it may be using this access list */
1000           ospf_distribute_list_update (ospf, type);
1001           continue;
1002         }
1003
1004
1005       if (DISTRIBUTE_NAME (ospf, type))
1006         {
1007           /* Keep old access-list for distribute-list. */
1008           struct access_list *old = DISTRIBUTE_LIST (ospf, type);
1009
1010           /* Update access-list for distribute-list. */
1011           DISTRIBUTE_LIST (ospf, type) =
1012             access_list_lookup (AFI_IP, DISTRIBUTE_NAME (ospf, type));
1013
1014           /* No update for this distribute type. */
1015           if (old == NULL && DISTRIBUTE_LIST (ospf, type) == NULL)
1016             continue;
1017
1018           /* Schedule distribute-list update timer. */
1019           if (DISTRIBUTE_LIST (ospf, type) == NULL ||
1020               strcmp (DISTRIBUTE_NAME (ospf, type), access->name) == 0)
1021             ospf_distribute_list_update (ospf, type);
1022         }
1023     }
1024
1025   /* Update Area access-list. */
1026   for (ALL_LIST_ELEMENTS_RO (ospf->areas, node, area))
1027     {
1028       if (EXPORT_NAME (area))
1029         {
1030           EXPORT_LIST (area) = NULL;
1031           abr_inv++;
1032         }
1033
1034       if (IMPORT_NAME (area))
1035         {
1036           IMPORT_LIST (area) = NULL;
1037           abr_inv++;
1038         }
1039     }
1040
1041   /* Schedule ABR tasks -- this will be changed -- takada. */
1042   if (IS_OSPF_ABR (ospf) && abr_inv)
1043     ospf_schedule_abr_task (ospf);
1044 }
1045
1046 /* If prefix-list is updated, do some updates. */
1047 void
1048 ospf_prefix_list_update (struct prefix_list *plist)
1049 {
1050   struct ospf *ospf;
1051   int type;
1052   int abr_inv = 0;
1053   struct ospf_area *area;
1054   struct listnode *node;
1055
1056   /* If OSPF instatnce does not exist, return right now. */
1057   ospf = ospf_lookup ();
1058   if (ospf == NULL)
1059     return;
1060
1061   /* Update all route-maps which are used as redistribution filters.
1062    * They might use prefix-list.
1063    */
1064   for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
1065     {
1066       if (ROUTEMAP (ospf, type) != NULL)
1067         {
1068           /* If route-map is not NULL it may be using this prefix list */
1069           ospf_distribute_list_update (ospf, type);
1070           continue;
1071         }
1072     }
1073
1074   /* Update area filter-lists. */
1075   for (ALL_LIST_ELEMENTS_RO (ospf->areas, node, area))
1076     {
1077       /* Update filter-list in. */
1078       if (PREFIX_NAME_IN (area))
1079         if (strcmp (PREFIX_NAME_IN (area), plist->name) == 0)
1080           {
1081             PREFIX_LIST_IN (area) =
1082               prefix_list_lookup (AFI_IP, PREFIX_NAME_IN (area));
1083             abr_inv++;
1084           }
1085
1086       /* Update filter-list out. */
1087       if (PREFIX_NAME_OUT (area))
1088         if (strcmp (PREFIX_NAME_OUT (area), plist->name) == 0)
1089           {
1090             PREFIX_LIST_IN (area) =
1091               prefix_list_lookup (AFI_IP, PREFIX_NAME_OUT (area));
1092             abr_inv++;
1093           }
1094     }
1095
1096   /* Schedule ABR task. */
1097   if (IS_OSPF_ABR (ospf) && abr_inv)
1098     ospf_schedule_abr_task (ospf);
1099 }
1100
1101 struct ospf_distance *
1102 ospf_distance_new ()
1103 {
1104   struct ospf_distance *new;
1105   new = XMALLOC (MTYPE_OSPF_DISTANCE, sizeof (struct ospf_distance));
1106   memset (new, 0, sizeof (struct ospf_distance));
1107   return new;
1108 }
1109
1110 void
1111 ospf_distance_free (struct ospf_distance *odistance)
1112 {
1113   XFREE (MTYPE_OSPF_DISTANCE, odistance);
1114 }
1115
1116 int
1117 ospf_distance_set (struct vty *vty, struct ospf *ospf,
1118                    const char *distance_str,
1119                    const char *ip_str,
1120                    const char *access_list_str)
1121 {
1122   int ret;
1123   struct prefix_ipv4 p;
1124   u_char distance;
1125   struct route_node *rn;
1126   struct ospf_distance *odistance;
1127
1128   ret = str2prefix_ipv4 (ip_str, &p);
1129   if (ret == 0)
1130     {
1131       vty_out (vty, "Malformed prefix%s", VTY_NEWLINE);
1132       return CMD_WARNING;
1133     }
1134
1135   distance = atoi (distance_str);
1136
1137   /* Get OSPF distance node. */
1138   rn = route_node_get (ospf->distance_table, (struct prefix *) &p);
1139   if (rn->info)
1140     {
1141       odistance = rn->info;
1142       route_unlock_node (rn);
1143     }
1144   else
1145     {
1146       odistance = ospf_distance_new ();
1147       rn->info = odistance;
1148     }
1149
1150   /* Set distance value. */
1151   odistance->distance = distance;
1152
1153   /* Reset access-list configuration. */
1154   if (odistance->access_list)
1155     {
1156       free (odistance->access_list);
1157       odistance->access_list = NULL;
1158     }
1159   if (access_list_str)
1160     odistance->access_list = strdup (access_list_str);
1161
1162   return CMD_SUCCESS;
1163 }
1164
1165 int
1166 ospf_distance_unset (struct vty *vty, struct ospf *ospf,
1167                      const char *distance_str,
1168                      const char *ip_str, char
1169                      const *access_list_str)
1170 {
1171   int ret;
1172   struct prefix_ipv4 p;
1173   u_char distance;
1174   struct route_node *rn;
1175   struct ospf_distance *odistance;
1176
1177   ret = str2prefix_ipv4 (ip_str, &p);
1178   if (ret == 0)
1179     {
1180       vty_out (vty, "Malformed prefix%s", VTY_NEWLINE);
1181       return CMD_WARNING;
1182     }
1183
1184   distance = atoi (distance_str);
1185
1186   rn = route_node_lookup (ospf->distance_table, (struct prefix *) &p);
1187   if (!rn)
1188     {
1189       vty_out (vty, "Can't find specified prefix%s", VTY_NEWLINE);
1190       return CMD_WARNING;
1191     }
1192
1193   odistance = rn->info;
1194
1195   if (odistance->access_list)
1196     free (odistance->access_list);
1197   ospf_distance_free (odistance);
1198
1199   rn->info = NULL;
1200   route_unlock_node (rn);
1201   route_unlock_node (rn);
1202
1203   return CMD_SUCCESS;
1204 }
1205
1206 void
1207 ospf_distance_reset (struct ospf *ospf)
1208 {
1209   struct route_node *rn;
1210   struct ospf_distance *odistance;
1211
1212   for (rn = route_top (ospf->distance_table); rn; rn = route_next (rn))
1213     if ((odistance = rn->info) != NULL)
1214       {
1215         if (odistance->access_list)
1216           free (odistance->access_list);
1217         ospf_distance_free (odistance);
1218         rn->info = NULL;
1219         route_unlock_node (rn);
1220       }
1221 }
1222
1223 u_char
1224 ospf_distance_apply (struct prefix_ipv4 *p, struct ospf_route *or)
1225 {
1226   struct ospf *ospf;
1227
1228   ospf = ospf_lookup ();
1229   if (ospf == NULL)
1230     return 0;
1231
1232   if (ospf->distance_intra)
1233     if (or->path_type == OSPF_PATH_INTRA_AREA)
1234       return ospf->distance_intra;
1235
1236   if (ospf->distance_inter)
1237     if (or->path_type == OSPF_PATH_INTER_AREA)
1238       return ospf->distance_inter;
1239
1240   if (ospf->distance_external)
1241     if (or->path_type == OSPF_PATH_TYPE1_EXTERNAL
1242         || or->path_type == OSPF_PATH_TYPE2_EXTERNAL)
1243       return ospf->distance_external;
1244
1245   if (ospf->distance_all)
1246     return ospf->distance_all;
1247
1248   return 0;
1249 }
1250
1251 void
1252 ospf_zebra_init ()
1253 {
1254   /* Allocate zebra structure. */
1255   zclient = zclient_new ();
1256   zclient_init (zclient, ZEBRA_ROUTE_OSPF);
1257   zclient->router_id_update = ospf_router_id_update_zebra;
1258   zclient->interface_add = ospf_interface_add;
1259   zclient->interface_delete = ospf_interface_delete;
1260   zclient->interface_up = ospf_interface_state_up;
1261   zclient->interface_down = ospf_interface_state_down;
1262   zclient->interface_address_add = ospf_interface_address_add;
1263   zclient->interface_address_delete = ospf_interface_address_delete;
1264   zclient->ipv4_route_add = ospf_zebra_read_ipv4;
1265   zclient->ipv4_route_delete = ospf_zebra_read_ipv4;
1266
1267   access_list_add_hook (ospf_filter_update);
1268   access_list_delete_hook (ospf_filter_update);
1269   prefix_list_add_hook (ospf_prefix_list_update);
1270   prefix_list_delete_hook (ospf_prefix_list_update);
1271 }