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 along
  18  * with this program; see the file COPYING; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <zebra.h>
  23
  24 #include "thread.h"
  25 #include "command.h"
  26 #include "network.h"
  27 #include "prefix.h"
  28 #include "routemap.h"
  29 #include "table.h"
  30 #include "stream.h"
  31 #include "memory.h"
  32 #include "zclient.h"
  33 #include "filter.h"
  34 #include "plist.h"
  35 #include "log.h"
  36 #include "lib/bfd.h"
  37 #include "nexthop.h"
  38
  39 #include "ospfd/ospfd.h"
  40 #include "ospfd/ospf_interface.h"
  41 #include "ospfd/ospf_ism.h"
  42 #include "ospfd/ospf_asbr.h"
  43 #include "ospfd/ospf_asbr.h"
  44 #include "ospfd/ospf_abr.h"
  45 #include "ospfd/ospf_lsa.h"
  46 #include "ospfd/ospf_dump.h"
  47 #include "ospfd/ospf_route.h"
  48 #include "ospfd/ospf_lsdb.h"
  49 #include "ospfd/ospf_neighbor.h"
  50 #include "ospfd/ospf_nsm.h"
  51 #include "ospfd/ospf_zebra.h"
  52 #include "ospfd/ospf_te.h"
  53
  54 DEFINE_MTYPE_STATIC(OSPFD, OSPF_EXTERNAL, "OSPF External route table")
  55 DEFINE_MTYPE_STATIC(OSPFD, OSPF_REDISTRIBUTE, "OSPF Redistriute")
  56 DEFINE_MTYPE_STATIC(OSPFD, OSPF_DIST_ARGS, "OSPF Distribute arguments")
  57
  58 DEFINE_HOOK(ospf_if_update, (struct interface * ifp), (ifp))
  59 DEFINE_HOOK(ospf_if_delete, (struct interface * ifp), (ifp))
  60
  61 /* Zebra structure to hold current status. */
  62 struct zclient *zclient = NULL;
  63
  64 /* For registering threads. */
  65 extern struct thread_master *master;
  66
  67 /* Router-id update message from zebra. */
  68 static int ospf_router_id_update_zebra(int command, struct zclient *zclient,
  69                                        zebra_size_t length, vrf_id_t vrf_id)
  70 {
  71         struct ospf *ospf = NULL;
  72         struct prefix router_id;
  73         zebra_router_id_update_read(zclient->ibuf, &router_id);
  74
  75         if (IS_DEBUG_OSPF(zebra, ZEBRA_INTERFACE)) {
  76                 char buf[PREFIX2STR_BUFFER];
  77                 prefix2str(&router_id, buf, sizeof(buf));
  78                 zlog_debug("Zebra rcvd: router id update %s vrf %s id %u", buf,
  79                            ospf_vrf_id_to_name(vrf_id), vrf_id);
  80         }
  81
  82         ospf = ospf_lookup_by_vrf_id(vrf_id);
  83
  84         if (ospf != NULL) {
  85                 ospf->router_id_zebra = router_id.u.prefix4;
  86                 ospf_router_id_update(ospf);
  87         } else {
  88                 if (IS_DEBUG_OSPF_EVENT) {
  89                         char buf[PREFIX2STR_BUFFER];
  90
  91                         prefix2str(&router_id, buf, sizeof(buf));
  92                         zlog_debug(
  93                                 "%s: ospf instance not found for vrf %s id %u router_id %s",
  94                                 __PRETTY_FUNCTION__,
  95                                 ospf_vrf_id_to_name(vrf_id), vrf_id, buf);
  96                 }
  97         }
  98         return 0;
  99 }
 100
 101 /* Inteface addition message from zebra. */
 102 static int ospf_interface_add(int command, struct zclient *zclient,
 103                               zebra_size_t length, vrf_id_t vrf_id)
 104 {
 105         struct interface *ifp = NULL;
 106         struct ospf *ospf = NULL;
 107
 108         ifp = zebra_interface_add_read(zclient->ibuf, vrf_id);
 109         if (ifp == NULL)
 110                 return 0;
 111
 112         if (IS_DEBUG_OSPF(zebra, ZEBRA_INTERFACE))
 113                 zlog_debug(
 114                         "Zebra: interface add %s vrf %s[%u] index %d flags %llx metric %d mtu %d",
 115                         ifp->name, ospf_vrf_id_to_name(ifp->vrf_id),
 116                         ifp->vrf_id, ifp->ifindex,
 117                         (unsigned long long)ifp->flags, ifp->metric, ifp->mtu);
 118
 119         assert(ifp->info);
 120
 121         if (IF_DEF_PARAMS(ifp)
 122             && !OSPF_IF_PARAM_CONFIGURED(IF_DEF_PARAMS(ifp), type)) {
 123                 SET_IF_PARAM(IF_DEF_PARAMS(ifp), type);
 124                 IF_DEF_PARAMS(ifp)->type = ospf_default_iftype(ifp);
 125         }
 126
 127         ospf = ospf_lookup_by_vrf_id(vrf_id);
 128         if (!ospf)
 129                 return 0;
 130
 131         ospf_if_update(ospf, ifp);
 132
 133         hook_call(ospf_if_update, ifp);
 134
 135         return 0;
 136 }
 137
 138 static int ospf_interface_delete(int command, struct zclient *zclient,
 139                                  zebra_size_t length, vrf_id_t vrf_id)
 140 {
 141         struct interface *ifp;
 142         struct stream *s;
 143         struct route_node *rn;
 144
 145         s = zclient->ibuf;
 146         /* zebra_interface_state_read() updates interface structure in iflist */
 147         ifp = zebra_interface_state_read(s, vrf_id);
 148
 149         if (ifp == NULL)
 150                 return 0;
 151
 152         if (if_is_up(ifp))
 153                 zlog_warn("Zebra: got delete of %s, but interface is still up",
 154                           ifp->name);
 155
 156         if (IS_DEBUG_OSPF(zebra, ZEBRA_INTERFACE))
 157                 zlog_debug(
 158                         "Zebra: interface delete %s vrf %s[%u] index %d flags %llx metric %d mtu %d",
 159                         ifp->name, ospf_vrf_id_to_name(ifp->vrf_id),
 160                         ifp->vrf_id, ifp->ifindex,
 161                         (unsigned long long)ifp->flags, ifp->metric, ifp->mtu);
 162
 163         hook_call(ospf_if_delete, ifp);
 164
 165         for (rn = route_top(IF_OIFS(ifp)); rn; rn = route_next(rn))
 166                 if (rn->info)
 167                         ospf_if_free((struct ospf_interface *)rn->info);
 168
 169         if_set_index(ifp, IFINDEX_INTERNAL);
 170         return 0;
 171 }
 172
 173 static struct interface *zebra_interface_if_lookup(struct stream *s,
 174                                                    vrf_id_t vrf_id)
 175 {
 176         char ifname_tmp[INTERFACE_NAMSIZ];
 177
 178         /* Read interface name. */
 179         stream_get(ifname_tmp, s, INTERFACE_NAMSIZ);
 180
 181         /* And look it up. */
 182         return if_lookup_by_name(ifname_tmp, vrf_id);
 183 }
 184
 185 static int ospf_interface_state_up(int command, struct zclient *zclient,
 186                                    zebra_size_t length, vrf_id_t vrf_id)
 187 {
 188         struct interface *ifp;
 189         struct ospf_interface *oi;
 190         struct route_node *rn;
 191
 192         ifp = zebra_interface_if_lookup(zclient->ibuf, vrf_id);
 193
 194         if (ifp == NULL)
 195                 return 0;
 196
 197         /* Interface is already up. */
 198         if (if_is_operative(ifp)) {
 199                 /* Temporarily keep ifp values. */
 200                 struct interface if_tmp;
 201                 memcpy(&if_tmp, ifp, sizeof(struct interface));
 202
 203                 zebra_interface_if_set_value(zclient->ibuf, ifp);
 204
 205                 if (IS_DEBUG_OSPF(zebra, ZEBRA_INTERFACE))
 206                         zlog_debug(
 207                                 "Zebra: Interface[%s] state update speed %u -> %u, bw  %d -> %d",
 208                                 ifp->name, if_tmp.speed, ifp->speed,
 209                                 if_tmp.bandwidth, ifp->bandwidth);
 210
 211                 ospf_if_recalculate_output_cost(ifp);
 212
 213                 if (if_tmp.mtu != ifp->mtu) {
 214                         if (IS_DEBUG_OSPF(zebra, ZEBRA_INTERFACE))
 215                                 zlog_debug(
 216                                         "Zebra: Interface[%s] MTU change %u -> %u.",
 217                                         ifp->name, if_tmp.mtu, ifp->mtu);
 218
 219                         /* Must reset the interface (simulate down/up) when MTU
 220                          * changes. */
 221                         ospf_if_reset(ifp);
 222                 }
 223                 return 0;
 224         }
 225
 226         zebra_interface_if_set_value(zclient->ibuf, ifp);
 227
 228         if (IS_DEBUG_OSPF(zebra, ZEBRA_INTERFACE))
 229                 zlog_debug("Zebra: Interface[%s] state change to up.",
 230                            ifp->name);
 231
 232         for (rn = route_top(IF_OIFS(ifp)); rn; rn = route_next(rn)) {
 233                 if ((oi = rn->info) == NULL)
 234                         continue;
 235
 236                 ospf_if_up(oi);
 237         }
 238
 239         return 0;
 240 }
 241
 242 static int ospf_interface_state_down(int command, struct zclient *zclient,
 243                                      zebra_size_t length, vrf_id_t vrf_id)
 244 {
 245         struct interface *ifp;
 246         struct ospf_interface *oi;
 247         struct route_node *node;
 248
 249         ifp = zebra_interface_state_read(zclient->ibuf, vrf_id);
 250
 251         if (ifp == NULL)
 252                 return 0;
 253
 254         if (IS_DEBUG_OSPF(zebra, ZEBRA_INTERFACE))
 255                 zlog_debug("Zebra: Interface[%s] state change to down.",
 256                            ifp->name);
 257
 258         for (node = route_top(IF_OIFS(ifp)); node; node = route_next(node)) {
 259                 if ((oi = node->info) == NULL)
 260                         continue;
 261                 ospf_if_down(oi);
 262         }
 263
 264         return 0;
 265 }
 266
 267 static int ospf_interface_address_add(int command, struct zclient *zclient,
 268                                       zebra_size_t length, vrf_id_t vrf_id)
 269 {
 270         struct connected *c;
 271         struct ospf *ospf = NULL;
 272
 273
 274         c = zebra_interface_address_read(command, zclient->ibuf, vrf_id);
 275
 276         if (c == NULL)
 277                 return 0;
 278
 279         if (IS_DEBUG_OSPF(zebra, ZEBRA_INTERFACE)) {
 280                 char buf[PREFIX2STR_BUFFER];
 281                 prefix2str(c->address, buf, sizeof(buf));
 282                 zlog_debug("Zebra: interface %s address add %s vrf %s id %u",
 283                            c->ifp->name, buf, ospf_vrf_id_to_name(vrf_id),
 284                            vrf_id);
 285         }
 286
 287         ospf = ospf_lookup_by_vrf_id(vrf_id);
 288         if (!ospf)
 289                 return 0;
 290
 291         ospf_if_update(ospf, c->ifp);
 292
 293         hook_call(ospf_if_update, c->ifp);
 294
 295         return 0;
 296 }
 297
 298 static int ospf_interface_address_delete(int command, struct zclient *zclient,
 299                                          zebra_size_t length, vrf_id_t vrf_id)
 300 {
 301         struct connected *c;
 302         struct interface *ifp;
 303         struct ospf_interface *oi;
 304         struct route_node *rn;
 305         struct prefix p;
 306
 307         c = zebra_interface_address_read(command, zclient->ibuf, vrf_id);
 308
 309         if (c == NULL)
 310                 return 0;
 311
 312         if (IS_DEBUG_OSPF(zebra, ZEBRA_INTERFACE)) {
 313                 char buf[PREFIX2STR_BUFFER];
 314                 prefix2str(c->address, buf, sizeof(buf));
 315                 zlog_debug("Zebra: interface %s address delete %s",
 316                            c->ifp->name, buf);
 317         }
 318
 319         ifp = c->ifp;
 320         p = *c->address;
 321         p.prefixlen = IPV4_MAX_PREFIXLEN;
 322
 323         rn = route_node_lookup(IF_OIFS(ifp), &p);
 324         if (!rn) {
 325                 connected_free(c);
 326                 return 0;
 327         }
 328
 329         assert(rn->info);
 330         oi = rn->info;
 331         route_unlock_node(rn);
 332
 333         /* Call interface hook functions to clean up */
 334         ospf_if_free(oi);
 335
 336         hook_call(ospf_if_update, c->ifp);
 337
 338         connected_free(c);
 339
 340         return 0;
 341 }
 342
 343 static int ospf_interface_link_params(int command, struct zclient *zclient,
 344                                       zebra_size_t length)
 345 {
 346         struct interface *ifp;
 347
 348         ifp = zebra_interface_link_params_read(zclient->ibuf);
 349
 350         if (ifp == NULL)
 351                 return 0;
 352
 353         /* Update TE TLV */
 354         ospf_mpls_te_update_if(ifp);
 355
 356         return 0;
 357 }
 358
 359 /* VRF update for an interface. */
 360 static int ospf_interface_vrf_update(int command, struct zclient *zclient,
 361                                      zebra_size_t length, vrf_id_t vrf_id)
 362 {
 363         struct interface *ifp = NULL;
 364         vrf_id_t new_vrf_id;
 365
 366         ifp = zebra_interface_vrf_update_read(zclient->ibuf, vrf_id,
 367                                               &new_vrf_id);
 368         if (!ifp)
 369                 return 0;
 370
 371         if (IS_DEBUG_OSPF_EVENT)
 372                 zlog_debug(
 373                         "%s: Rx Interface %s VRF change vrf_id %u New vrf %s id %u",
 374                         __PRETTY_FUNCTION__, ifp->name, vrf_id,
 375                         ospf_vrf_id_to_name(new_vrf_id), new_vrf_id);
 376
 377         /*if_update(ifp, ifp->name, strlen(ifp->name), new_vrf_id);*/
 378         if_update_to_new_vrf(ifp, new_vrf_id);
 379
 380         return 0;
 381 }
 382
 383 void ospf_zebra_add(struct ospf *ospf, struct prefix_ipv4 *p,
 384                     struct ospf_route * or)
 385 {
 386         struct zapi_route api;
 387         struct zapi_nexthop *api_nh;
 388         uint8_t distance;
 389         struct ospf_path *path;
 390         struct listnode *node;
 391         int count = 0;
 392
 393         memset(&api, 0, sizeof(api));
 394         api.vrf_id = ospf->vrf_id;
 395         api.type = ZEBRA_ROUTE_OSPF;
 396         api.instance = ospf->instance;
 397         api.safi = SAFI_UNICAST;
 398
 399         memcpy(&api.prefix, p, sizeof(*p));
 400         SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
 401
 402         /* Metric value. */
 403         SET_FLAG(api.message, ZAPI_MESSAGE_METRIC);
 404         if (or->path_type == OSPF_PATH_TYPE1_EXTERNAL)
 405                 api.metric = or->cost + or->u.ext.type2_cost;
 406         else if (or->path_type == OSPF_PATH_TYPE2_EXTERNAL)
 407                 api.metric = or->u.ext.type2_cost;
 408         else
 409                 api.metric = or->cost;
 410
 411         /* Check if path type is ASE */
 412         if (((or->path_type == OSPF_PATH_TYPE1_EXTERNAL)
 413              || (or->path_type == OSPF_PATH_TYPE2_EXTERNAL))
 414             && (or->u.ext.tag > 0) && (or->u.ext.tag <= ROUTE_TAG_MAX)) {
 415                 SET_FLAG(api.message, ZAPI_MESSAGE_TAG);
 416                 api.tag = or->u.ext.tag;
 417         }
 418
 419         /* Distance value. */
 420         distance = ospf_distance_apply(ospf, p, or);
 421         if (distance) {
 422                 SET_FLAG(api.message, ZAPI_MESSAGE_DISTANCE);
 423                 api.distance = distance;
 424         }
 425
 426         /* Nexthop, ifindex, distance and metric information. */
 427         for (ALL_LIST_ELEMENTS_RO(or->paths, node, path)) {
 428                 if (count >= MULTIPATH_NUM)
 429                         break;
 430                 api_nh = &api.nexthops[count];
 431 #ifdef HAVE_NETLINK
 432                 if (path->unnumbered || (path->nexthop.s_addr != INADDR_ANY
 433                                          && path->ifindex != 0)) {
 434 #else  /* HAVE_NETLINK */
 435                 if (path->nexthop.s_addr != INADDR_ANY && path->ifindex != 0) {
 436 #endif /* HAVE_NETLINK */
 437                         api_nh->gate.ipv4 = path->nexthop;
 438                         api_nh->ifindex = path->ifindex;
 439                         api_nh->type = NEXTHOP_TYPE_IPV4_IFINDEX;
 440                 } else if (path->nexthop.s_addr != INADDR_ANY) {
 441                         api_nh->gate.ipv4 = path->nexthop;
 442                         api_nh->type = NEXTHOP_TYPE_IPV4;
 443                 } else {
 444                         api_nh->ifindex = path->ifindex;
 445                         api_nh->type = NEXTHOP_TYPE_IFINDEX;
 446                 }
 447                 api_nh->vrf_id = ospf->vrf_id;
 448                 count++;
 449
 450                 if (IS_DEBUG_OSPF(zebra, ZEBRA_REDISTRIBUTE)) {
 451                         char buf[2][PREFIX2STR_BUFFER];
 452
 453                         zlog_debug(
 454                                 "Zebra: Route add %s nexthop %s, ifindex=%d",
 455                                 prefix2str(p, buf[0], sizeof(buf[0])),
 456                                 inet_ntop(AF_INET, &path->nexthop,
 457                                           buf[1], sizeof(buf[1])),
 458                                 path->ifindex);
 459                 }
 460         }
 461         api.nexthop_num = count;
 462
 463         zclient_route_send(ZEBRA_ROUTE_ADD, zclient, &api);
 464 }
 465
 466 void ospf_zebra_delete(struct ospf *ospf, struct prefix_ipv4 *p,
 467                        struct ospf_route * or)
 468 {
 469         struct zapi_route api;
 470
 471         memset(&api, 0, sizeof(api));
 472         api.vrf_id = ospf->vrf_id;
 473         api.type = ZEBRA_ROUTE_OSPF;
 474         api.instance = ospf->instance;
 475         api.safi = SAFI_UNICAST;
 476         memcpy(&api.prefix, p, sizeof(*p));
 477
 478         if (IS_DEBUG_OSPF(zebra, ZEBRA_REDISTRIBUTE)) {
 479                 char buf[PREFIX2STR_BUFFER];
 480                 zlog_debug("Zebra: Route delete %s",
 481                            prefix2str(p, buf, sizeof(buf)));
 482         }
 483
 484         zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
 485 }
 486
 487 void ospf_zebra_add_discard(struct ospf *ospf, struct prefix_ipv4 *p)
 488 {
 489         struct zapi_route api;
 490
 491         memset(&api, 0, sizeof(api));
 492         api.vrf_id = ospf->vrf_id;
 493         api.type = ZEBRA_ROUTE_OSPF;
 494         api.instance = ospf->instance;
 495         api.safi = SAFI_UNICAST;
 496         memcpy(&api.prefix, p, sizeof(*p));
 497         zapi_route_set_blackhole(&api, BLACKHOLE_NULL);
 498
 499         zclient_route_send(ZEBRA_ROUTE_ADD, zclient, &api);
 500
 501         if (IS_DEBUG_OSPF(zebra, ZEBRA_REDISTRIBUTE)) {
 502                 char buf[PREFIX2STR_BUFFER];
 503                 zlog_debug("Zebra: Route add discard %s",
 504                            prefix2str(p, buf, sizeof(buf)));
 505         }
 506 }
 507
 508 void ospf_zebra_delete_discard(struct ospf *ospf, struct prefix_ipv4 *p)
 509 {
 510         struct zapi_route api;
 511
 512         memset(&api, 0, sizeof(api));
 513         api.vrf_id = ospf->vrf_id;
 514         api.type = ZEBRA_ROUTE_OSPF;
 515         api.instance = ospf->instance;
 516         api.safi = SAFI_UNICAST;
 517         memcpy(&api.prefix, p, sizeof(*p));
 518         zapi_route_set_blackhole(&api, BLACKHOLE_NULL);
 519
 520         zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
 521
 522         if (IS_DEBUG_OSPF(zebra, ZEBRA_REDISTRIBUTE)) {
 523                 char buf[PREFIX2STR_BUFFER];
 524                 zlog_debug("Zebra: Route delete discard %s",
 525                            prefix2str(p, buf, sizeof(buf)));
 526         }
 527 }
 528
 529 struct ospf_external *ospf_external_lookup(struct ospf *ospf, uint8_t type,
 530                                            unsigned short instance)
 531 {
 532         struct list *ext_list;
 533         struct listnode *node;
 534         struct ospf_external *ext;
 535
 536         ext_list = ospf->external[type];
 537         if (!ext_list)
 538                 return (NULL);
 539
 540         for (ALL_LIST_ELEMENTS_RO(ext_list, node, ext))
 541                 if (ext->instance == instance)
 542                         return ext;
 543
 544         return NULL;
 545 }
 546
 547 struct ospf_external *ospf_external_add(struct ospf *ospf, uint8_t type,
 548                                         unsigned short instance)
 549 {
 550         struct list *ext_list;
 551         struct ospf_external *ext;
 552
 553         ext = ospf_external_lookup(ospf, type, instance);
 554         if (ext)
 555                 return ext;
 556
 557         if (!ospf->external[type])
 558                 ospf->external[type] = list_new();
 559
 560         ext_list = ospf->external[type];
 561         ext = (struct ospf_external *)XCALLOC(MTYPE_OSPF_EXTERNAL,
 562                                               sizeof(struct ospf_external));
 563         ext->instance = instance;
 564         EXTERNAL_INFO(ext) = route_table_init();
 565
 566         listnode_add(ext_list, ext);
 567
 568         return ext;
 569 }
 570
 571 void ospf_external_del(struct ospf *ospf, uint8_t type, unsigned short instance)
 572 {
 573         struct ospf_external *ext;
 574
 575         ext = ospf_external_lookup(ospf, type, instance);
 576
 577         if (ext) {
 578                 if (EXTERNAL_INFO(ext))
 579                         route_table_finish(EXTERNAL_INFO(ext));
 580
 581                 listnode_delete(ospf->external[type], ext);
 582
 583                 if (!ospf->external[type]->count)
 584                         list_delete_and_null(&ospf->external[type]);
 585
 586                 XFREE(MTYPE_OSPF_EXTERNAL, ext);
 587         }
 588 }
 589
 590 struct ospf_redist *ospf_redist_lookup(struct ospf *ospf, uint8_t type,
 591                                        unsigned short instance)
 592 {
 593         struct list *red_list;
 594         struct listnode *node;
 595         struct ospf_redist *red;
 596
 597         red_list = ospf->redist[type];
 598         if (!red_list)
 599                 return (NULL);
 600
 601         for (ALL_LIST_ELEMENTS_RO(red_list, node, red))
 602                 if (red->instance == instance)
 603                         return red;
 604
 605         return NULL;
 606 }
 607
 608 struct ospf_redist *ospf_redist_add(struct ospf *ospf, uint8_t type,
 609                                     unsigned short instance)
 610 {
 611         struct list *red_list;
 612         struct ospf_redist *red;
 613
 614         red = ospf_redist_lookup(ospf, type, instance);
 615         if (red)
 616                 return red;
 617
 618         if (!ospf->redist[type])
 619                 ospf->redist[type] = list_new();
 620
 621         red_list = ospf->redist[type];
 622         red = (struct ospf_redist *)XCALLOC(MTYPE_OSPF_REDISTRIBUTE,
 623                                             sizeof(struct ospf_redist));
 624         red->instance = instance;
 625         red->dmetric.type = -1;
 626         red->dmetric.value = -1;
 627
 628         listnode_add(red_list, red);
 629
 630         return red;
 631 }
 632
 633 void ospf_redist_del(struct ospf *ospf, uint8_t type, unsigned short instance)
 634 {
 635         struct ospf_redist *red;
 636
 637         red = ospf_redist_lookup(ospf, type, instance);
 638
 639         if (red) {
 640                 listnode_delete(ospf->redist[type], red);
 641                 if (!ospf->redist[type]->count) {
 642                         list_delete_and_null(&ospf->redist[type]);
 643                 }
 644                 ospf_routemap_unset(red);
 645                 XFREE(MTYPE_OSPF_REDISTRIBUTE, red);
 646         }
 647 }
 648
 649
 650 int ospf_is_type_redistributed(struct ospf *ospf, int type,
 651                                unsigned short instance)
 652 {
 653         return (DEFAULT_ROUTE_TYPE(type)
 654                         ? vrf_bitmap_check(zclient->default_information,
 655                                            ospf->vrf_id)
 656                         : ((instance
 657                             && redist_check_instance(
 658                                        &zclient->mi_redist[AFI_IP][type],
 659                                        instance))
 660                            || (!instance
 661                                && vrf_bitmap_check(
 662                                           zclient->redist[AFI_IP][type],
 663                                           ospf->vrf_id))));
 664 }
 665
 666 int ospf_redistribute_set(struct ospf *ospf, int type, unsigned short instance,
 667                           int mtype, int mvalue)
 668 {
 669         int force = 0;
 670         struct ospf_redist *red;
 671
 672         red = ospf_redist_lookup(ospf, type, instance);
 673
 674         if (red == NULL) {
 675                 zlog_err(
 676                          "Redistribute[%s][%d]: Lookup failed  Type[%d] , Metric[%d]",
 677                          ospf_redist_string(type), instance,
 678                          metric_type(ospf, type, instance),
 679                          metric_value(ospf, type, instance));
 680                 return CMD_WARNING_CONFIG_FAILED;
 681         }
 682
 683         if (ospf_is_type_redistributed(ospf, type, instance)) {
 684                 if (mtype != red->dmetric.type) {
 685                         red->dmetric.type = mtype;
 686                         force = LSA_REFRESH_FORCE;
 687                 }
 688                 if (mvalue != red->dmetric.value) {
 689                         red->dmetric.value = mvalue;
 690                         force = LSA_REFRESH_FORCE;
 691                 }
 692
 693                 ospf_external_lsa_refresh_type(ospf, type, instance, force);
 694
 695                 if (IS_DEBUG_OSPF(zebra, ZEBRA_REDISTRIBUTE))
 696                         zlog_debug(
 697                                 "Redistribute[%s][%d]: Refresh  Type[%d], Metric[%d]",
 698                                 ospf_redist_string(type), instance,
 699                                 metric_type(ospf, type, instance),
 700                                 metric_value(ospf, type, instance));
 701
 702                 return CMD_SUCCESS;
 703         }
 704
 705         red->dmetric.type = mtype;
 706         red->dmetric.value = mvalue;
 707
 708         ospf_external_add(ospf, type, instance);
 709
 710         zclient_redistribute(ZEBRA_REDISTRIBUTE_ADD, zclient, AFI_IP, type,
 711                              instance, ospf->vrf_id);
 712
 713         if (IS_DEBUG_OSPF(zebra, ZEBRA_REDISTRIBUTE))
 714                 zlog_debug(
 715                         "Redistribute[%s][%d] vrf id %u: Start  Type[%d], Metric[%d]",
 716                         ospf_redist_string(type), instance, ospf->vrf_id,
 717                         metric_type(ospf, type, instance),
 718                         metric_value(ospf, type, instance));
 719
 720         ospf_asbr_status_update(ospf, ++ospf->redistribute);
 721
 722         return CMD_SUCCESS;
 723 }
 724
 725 int ospf_redistribute_unset(struct ospf *ospf, int type,
 726                             unsigned short instance)
 727 {
 728         if (type == zclient->redist_default && instance == zclient->instance)
 729                 return CMD_SUCCESS;
 730
 731         if (!ospf_is_type_redistributed(ospf, type, instance))
 732                 return CMD_SUCCESS;
 733
 734         zclient_redistribute(ZEBRA_REDISTRIBUTE_DELETE, zclient, AFI_IP, type,
 735                              instance, ospf->vrf_id);
 736
 737         if (IS_DEBUG_OSPF(zebra, ZEBRA_REDISTRIBUTE))
 738                 zlog_debug("Redistribute[%s][%d] vrf id %u: Stop",
 739                            ospf_redist_string(type), instance, ospf->vrf_id);
 740
 741         ospf_redist_del(ospf, type, instance);
 742
 743         /* Remove the routes from OSPF table. */
 744         ospf_redistribute_withdraw(ospf, type, instance);
 745
 746         ospf_external_del(ospf, type, instance);
 747
 748         ospf_asbr_status_update(ospf, --ospf->redistribute);
 749
 750         return CMD_SUCCESS;
 751 }
 752
 753 int ospf_redistribute_default_set(struct ospf *ospf, int originate, int mtype,
 754                                   int mvalue)
 755 {
 756         struct ospf_redist *red;
 757
 758         ospf->default_originate = originate;
 759
 760         red = ospf_redist_add(ospf, DEFAULT_ROUTE, 0);
 761         red->dmetric.type = mtype;
 762         red->dmetric.value = mvalue;
 763
 764         ospf_external_add(ospf, DEFAULT_ROUTE, 0);
 765
 766         if (ospf_is_type_redistributed(ospf, DEFAULT_ROUTE, 0)) {
 767                 /* if ospf->default_originate changes value, is calling
 768                    ospf_external_lsa_refresh_default sufficient to implement
 769                    the change? */
 770                 ospf_external_lsa_refresh_default(ospf);
 771
 772                 if (IS_DEBUG_OSPF(zebra, ZEBRA_REDISTRIBUTE))
 773                         zlog_debug(
 774                                 "Redistribute[%s]: Refresh  Type[%d], Metric[%d]",
 775                                 ospf_redist_string(DEFAULT_ROUTE),
 776                                 metric_type(ospf, DEFAULT_ROUTE, 0),
 777                                 metric_value(ospf, DEFAULT_ROUTE, 0));
 778                 return CMD_SUCCESS;
 779         }
 780
 781         zclient_redistribute_default(ZEBRA_REDISTRIBUTE_DEFAULT_ADD, zclient,
 782                                      ospf->vrf_id);
 783
 784         if (IS_DEBUG_OSPF(zebra, ZEBRA_REDISTRIBUTE))
 785                 zlog_debug("Redistribute[DEFAULT]: Start  Type[%d], Metric[%d]",
 786                            metric_type(ospf, DEFAULT_ROUTE, 0),
 787                            metric_value(ospf, DEFAULT_ROUTE, 0));
 788
 789         if (ospf->router_id.s_addr == 0)
 790                 ospf->external_origin |= (1 << DEFAULT_ROUTE);
 791         else
 792                 thread_add_timer(master, ospf_default_originate_timer, ospf, 1,
 793                                  NULL);
 794
 795         ospf_asbr_status_update(ospf, ++ospf->redistribute);
 796
 797         return CMD_SUCCESS;
 798 }
 799
 800 int ospf_redistribute_default_unset(struct ospf *ospf)
 801 {
 802         if (!ospf_is_type_redistributed(ospf, DEFAULT_ROUTE, 0))
 803                 return CMD_SUCCESS;
 804
 805         ospf->default_originate = DEFAULT_ORIGINATE_NONE;
 806         ospf_redist_del(ospf, DEFAULT_ROUTE, 0);
 807
 808         zclient_redistribute_default(ZEBRA_REDISTRIBUTE_DEFAULT_DELETE, zclient,
 809                                      ospf->vrf_id);
 810
 811         if (IS_DEBUG_OSPF(zebra, ZEBRA_REDISTRIBUTE))
 812                 zlog_debug("Redistribute[DEFAULT]: Stop");
 813
 814         // Pending: how does the external_info cleanup work in this case?
 815
 816         ospf_asbr_status_update(ospf, --ospf->redistribute);
 817
 818         return CMD_SUCCESS;
 819 }
 820
 821 static int ospf_external_lsa_originate_check(struct ospf *ospf,
 822                                              struct external_info *ei)
 823 {
 824         /* If prefix is multicast, then do not originate LSA. */
 825         if (IN_MULTICAST(htonl(ei->p.prefix.s_addr))) {
 826                 zlog_info(
 827                         "LSA[Type5:%s]: Not originate AS-external-LSA, "
 828                         "Prefix belongs multicast",
 829                         inet_ntoa(ei->p.prefix));
 830                 return 0;
 831         }
 832
 833         /* Take care of default-originate. */
 834         if (is_prefix_default(&ei->p))
 835                 if (ospf->default_originate == DEFAULT_ORIGINATE_NONE) {
 836                         zlog_info(
 837                                 "LSA[Type5:0.0.0.0]: Not originate AS-external-LSA "
 838                                 "for default");
 839                         return 0;
 840                 }
 841
 842         return 1;
 843 }
 844
 845 /* If connected prefix is OSPF enable interface, then do not announce. */
 846 int ospf_distribute_check_connected(struct ospf *ospf, struct external_info *ei)
 847 {
 848         struct listnode *node;
 849         struct ospf_interface *oi;
 850
 851
 852         for (ALL_LIST_ELEMENTS_RO(ospf->oiflist, node, oi))
 853                 if (prefix_match(oi->address, (struct prefix *)&ei->p))
 854                         return 0;
 855         return 1;
 856 }
 857
 858 /* return 1 if external LSA must be originated, 0 otherwise */
 859 int ospf_redistribute_check(struct ospf *ospf, struct external_info *ei,
 860                             int *changed)
 861 {
 862         struct route_map_set_values save_values;
 863         struct prefix_ipv4 *p = &ei->p;
 864         struct ospf_redist *red;
 865         uint8_t type = is_prefix_default(&ei->p) ? DEFAULT_ROUTE : ei->type;
 866         unsigned short instance = is_prefix_default(&ei->p) ? 0 : ei->instance;
 867
 868         if (changed)
 869                 *changed = 0;
 870
 871         if (!ospf_external_lsa_originate_check(ospf, ei))
 872                 return 0;
 873
 874         /* Take care connected route. */
 875         if (type == ZEBRA_ROUTE_CONNECT
 876             && !ospf_distribute_check_connected(ospf, ei))
 877                 return 0;
 878
 879         if (!DEFAULT_ROUTE_TYPE(type) && DISTRIBUTE_NAME(ospf, type))
 880                 /* distirbute-list exists, but access-list may not? */
 881                 if (DISTRIBUTE_LIST(ospf, type))
 882                         if (access_list_apply(DISTRIBUTE_LIST(ospf, type), p)
 883                             == FILTER_DENY) {
 884                                 if (IS_DEBUG_OSPF(zebra, ZEBRA_REDISTRIBUTE)) {
 885                                         char buf[PREFIX2STR_BUFFER];
 886                                         zlog_debug(
 887                                                 "Redistribute[%s]: %s filtered by distribute-list.",
 888                                                 ospf_redist_string(type),
 889                                                 prefix2str(p, buf, sizeof(buf)));
 890                                 }
 891                                 return 0;
 892                         }
 893
 894         save_values = ei->route_map_set;
 895         ospf_reset_route_map_set_values(&ei->route_map_set);
 896
 897         /* apply route-map if needed */
 898         red = ospf_redist_lookup(ospf, type, instance);
 899         if (red && ROUTEMAP_NAME(red)) {
 900                 int ret;
 901
 902                 ret = route_map_apply(ROUTEMAP(red), (struct prefix *)p,
 903                                       RMAP_OSPF, ei);
 904
 905                 if (ret == RMAP_DENYMATCH) {
 906                         ei->route_map_set = save_values;
 907                         if (IS_DEBUG_OSPF(zebra, ZEBRA_REDISTRIBUTE)) {
 908                                 char buf[PREFIX2STR_BUFFER];
 909                                 zlog_debug(
 910                                         "Redistribute[%s]: %s filtered by route-map.",
 911                                         ospf_redist_string(type),
 912                                         prefix2str(p, buf, sizeof(buf)));
 913                         }
 914                         return 0;
 915                 }
 916
 917                 /* check if 'route-map set' changed something */
 918                 if (changed)
 919                         *changed = !ospf_route_map_set_compare(
 920                                 &ei->route_map_set, &save_values);
 921         }
 922
 923         return 1;
 924 }
 925
 926 /* OSPF route-map set for redistribution */
 927 void ospf_routemap_set(struct ospf_redist *red, const char *name)
 928 {
 929         if (ROUTEMAP_NAME(red))
 930                 free(ROUTEMAP_NAME(red));
 931
 932         ROUTEMAP_NAME(red) = strdup(name);
 933         ROUTEMAP(red) = route_map_lookup_by_name(name);
 934 }
 935
 936 void ospf_routemap_unset(struct ospf_redist *red)
 937 {
 938         if (ROUTEMAP_NAME(red))
 939                 free(ROUTEMAP_NAME(red));
 940
 941         ROUTEMAP_NAME(red) = NULL;
 942         ROUTEMAP(red) = NULL;
 943 }
 944
 945 /* Zebra route add and delete treatment. */
 946 static int ospf_zebra_read_route(int command, struct zclient *zclient,
 947                                  zebra_size_t length, vrf_id_t vrf_id)
 948 {
 949         struct zapi_route api;
 950         struct prefix_ipv4 p;
 951         unsigned long ifindex;
 952         struct in_addr nexthop;
 953         struct external_info *ei;
 954         struct ospf *ospf;
 955         int i;
 956
 957         ospf = ospf_lookup_by_vrf_id(vrf_id);
 958         if (ospf == NULL)
 959                 return 0;
 960
 961         if (zapi_route_decode(zclient->ibuf, &api) < 0)
 962                 return -1;
 963
 964         ifindex = api.nexthops[0].ifindex;
 965         nexthop = api.nexthops[0].gate.ipv4;
 966
 967         memcpy(&p, &api.prefix, sizeof(p));
 968         if (IPV4_NET127(ntohl(p.prefix.s_addr)))
 969                 return 0;
 970
 971         if (IS_DEBUG_OSPF(zebra, ZEBRA_REDISTRIBUTE)) {
 972                 char buf_prefix[PREFIX_STRLEN];
 973                 prefix2str(&api.prefix, buf_prefix, sizeof(buf_prefix));
 974
 975                 zlog_debug("%s: from client %s: vrf_id %d, p %s", __func__,
 976                            zebra_route_string(api.type), vrf_id, buf_prefix);
 977         }
 978
 979         if (command == ZEBRA_REDISTRIBUTE_ROUTE_ADD) {
 980                 /* XXX|HACK|TODO|FIXME:
 981                  * Maybe we should ignore reject/blackhole routes? Testing
 982                  * shows that there is no problems though and this is only way
 983                  * to "summarize" routes in ASBR at the moment. Maybe we need
 984                  * just a better generalised solution for these types?
 985                  */
 986
 987                 /* Protocol tag overwrites all other tag value sent by zebra */
 988                 if (ospf->dtag[api.type] > 0)
 989                         api.tag = ospf->dtag[api.type];
 990
 991                 /*
 992                  * Given zebra sends update for a prefix via ADD message, it
 993                  * should
 994                  * be considered as an implicit DEL for that prefix with other
 995                  * source
 996                  * types.
 997                  */
 998                 for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
 999                         if (i != api.type)
1000                                 ospf_external_info_delete(ospf, i, api.instance,
1001                                                           p);
1002
1003                 ei = ospf_external_info_add(ospf, api.type, api.instance, p,
1004                                             ifindex, nexthop, api.tag);
1005                 if (ei == NULL) {
1006                         /* Nothing has changed, so nothing to do; return */
1007                         return 0;
1008                 }
1009                 if (ospf->router_id.s_addr == 0)
1010                         /* Set flags to generate AS-external-LSA originate event
1011                            for each redistributed protocols later. */
1012                         ospf->external_origin |= (1 << api.type);
1013                 else {
1014                         if (ei) {
1015                                 if (is_prefix_default(&p))
1016                                         ospf_external_lsa_refresh_default(ospf);
1017                                 else {
1018                                         struct ospf_lsa *current;
1019
1020                                         current = ospf_external_info_find_lsa(
1021                                                 ospf, &ei->p);
1022                                         if (!current)
1023                                                 ospf_external_lsa_originate(
1024                                                         ospf, ei);
1025                                         else {
1026                                                 if (IS_DEBUG_OSPF(
1027                                                             zebra,
1028                                                             ZEBRA_REDISTRIBUTE))
1029                                                         zlog_debug(
1030                                                                 "ospf_zebra_read_route() : %s refreshing LSA",
1031                                                                 inet_ntoa(
1032                                                                         p.prefix));
1033                                                 ospf_external_lsa_refresh(
1034                                                         ospf, current, ei,
1035                                                         LSA_REFRESH_FORCE);
1036                                         }
1037                                 }
1038                         }
1039                 }
1040         } else /* if (command == ZEBRA_REDISTRIBUTE_ROUTE_DEL) */
1041         {
1042                 ospf_external_info_delete(ospf, api.type, api.instance, p);
1043                 if (is_prefix_default(&p))
1044                         ospf_external_lsa_refresh_default(ospf);
1045                 else
1046                         ospf_external_lsa_flush(ospf, api.type, &p,
1047                                                 ifindex /*, nexthop */);
1048         }
1049
1050         return 0;
1051 }
1052
1053
1054 int ospf_distribute_list_out_set(struct ospf *ospf, int type, const char *name)
1055 {
1056         /* Lookup access-list for distribute-list. */
1057         DISTRIBUTE_LIST(ospf, type) = access_list_lookup(AFI_IP, name);
1058
1059         /* Clear previous distribute-name. */
1060         if (DISTRIBUTE_NAME(ospf, type))
1061                 free(DISTRIBUTE_NAME(ospf, type));
1062
1063         /* Set distribute-name. */
1064         DISTRIBUTE_NAME(ospf, type) = strdup(name);
1065
1066         /* If access-list have been set, schedule update timer. */
1067         if (DISTRIBUTE_LIST(ospf, type))
1068                 ospf_distribute_list_update(ospf, type, 0);
1069
1070         return CMD_SUCCESS;
1071 }
1072
1073 int ospf_distribute_list_out_unset(struct ospf *ospf, int type,
1074                                    const char *name)
1075 {
1076         /* Schedule update timer. */
1077         if (DISTRIBUTE_LIST(ospf, type))
1078                 ospf_distribute_list_update(ospf, type, 0);
1079
1080         /* Unset distribute-list. */
1081         DISTRIBUTE_LIST(ospf, type) = NULL;
1082
1083         /* Clear distribute-name. */
1084         if (DISTRIBUTE_NAME(ospf, type))
1085                 free(DISTRIBUTE_NAME(ospf, type));
1086
1087         DISTRIBUTE_NAME(ospf, type) = NULL;
1088
1089         return CMD_SUCCESS;
1090 }
1091
1092 /* distribute-list update timer. */
1093 static int ospf_distribute_list_update_timer(struct thread *thread)
1094 {
1095         struct route_node *rn;
1096         struct external_info *ei;
1097         struct route_table *rt;
1098         struct ospf_lsa *lsa;
1099         int type, default_refresh = 0, arg_type;
1100         struct ospf *ospf = NULL;
1101         void **arg = THREAD_ARG(thread);
1102
1103         ospf = (struct ospf *)arg[0];
1104         arg_type = (int)(intptr_t)arg[1];
1105
1106         if (ospf == NULL)
1107                 return 0;
1108
1109         ospf->t_distribute_update = NULL;
1110
1111         zlog_info("Zebra[Redistribute]: distribute-list update timer fired!");
1112
1113         if (IS_DEBUG_OSPF_EVENT) {
1114                 zlog_debug(
1115                         "%s: ospf distribute-list update arg_type %d vrf %s id %d",
1116                         __PRETTY_FUNCTION__, arg_type,
1117                         ospf_vrf_id_to_name(ospf->vrf_id), ospf->vrf_id);
1118         }
1119
1120         /* foreach all external info. */
1121         for (type = 0; type <= ZEBRA_ROUTE_MAX; type++) {
1122                 struct list *ext_list;
1123                 struct listnode *node;
1124                 struct ospf_external *ext;
1125
1126                 ext_list = ospf->external[type];
1127                 if (!ext_list)
1128                         continue;
1129
1130                 for (ALL_LIST_ELEMENTS_RO(ext_list, node, ext)) {
1131                         rt = ext->external_info;
1132                         if (!rt)
1133                                 continue;
1134                         for (rn = route_top(rt); rn; rn = route_next(rn))
1135                                 if ((ei = rn->info) != NULL) {
1136                                         if (is_prefix_default(&ei->p))
1137                                                 default_refresh = 1;
1138                                         else if (
1139                                                 (lsa = ospf_external_info_find_lsa(
1140                                                          ospf, &ei->p)))
1141                                                 ospf_external_lsa_refresh(
1142                                                         ospf, lsa, ei,
1143                                                         LSA_REFRESH_IF_CHANGED);
1144                                         else
1145                                                 ospf_external_lsa_originate(
1146                                                         ospf, ei);
1147                                 }
1148                 }
1149         }
1150         if (default_refresh)
1151                 ospf_external_lsa_refresh_default(ospf);
1152
1153         XFREE(MTYPE_OSPF_DIST_ARGS, arg);
1154         return 0;
1155 }
1156
1157 /* Update distribute-list and set timer to apply access-list. */
1158 void ospf_distribute_list_update(struct ospf *ospf, int type,
1159                                  unsigned short instance)
1160 {
1161         struct route_table *rt;
1162         struct ospf_external *ext;
1163         void **args = XCALLOC(MTYPE_OSPF_DIST_ARGS, sizeof(void *) * 2);
1164
1165         args[0] = ospf;
1166         args[1] = (void *)((ptrdiff_t)type);
1167
1168         /* External info does not exist. */
1169         ext = ospf_external_lookup(ospf, type, instance);
1170         if (!ext || !(rt = EXTERNAL_INFO(ext))) {
1171                 XFREE(MTYPE_OSPF_DIST_ARGS, args);
1172                 return;
1173         }
1174
1175         /* If exists previously invoked thread, then let it continue. */
1176         if (ospf->t_distribute_update) {
1177                 XFREE(MTYPE_OSPF_DIST_ARGS, args);
1178                 return;
1179         }
1180
1181         /* Set timer. */
1182         ospf->t_distribute_update = NULL;
1183         thread_add_timer_msec(master, ospf_distribute_list_update_timer,
1184                               (void **)args, ospf->min_ls_interval,
1185                               &ospf->t_distribute_update);
1186 }
1187
1188 /* If access-list is updated, apply some check. */
1189 static void ospf_filter_update(struct access_list *access)
1190 {
1191         struct ospf *ospf;
1192         int type;
1193         int abr_inv = 0;
1194         struct ospf_area *area;
1195         struct listnode *node, *n1;
1196
1197         /* If OSPF instance does not exist, return right now. */
1198         if (listcount(om->ospf) == 0)
1199                 return;
1200
1201         /* Iterate all ospf [VRF] instances */
1202         for (ALL_LIST_ELEMENTS_RO(om->ospf, n1, ospf)) {
1203                 /* Update distribute-list, and apply filter. */
1204                 for (type = 0; type <= ZEBRA_ROUTE_MAX; type++) {
1205                         struct list *red_list;
1206                         struct listnode *node;
1207                         struct ospf_redist *red;
1208
1209                         red_list = ospf->redist[type];
1210                         if (red_list)
1211                                 for (ALL_LIST_ELEMENTS_RO(red_list, node,
1212                                                           red)) {
1213                                         if (ROUTEMAP(red)) {
1214                                                 /* if route-map is not NULL it
1215                                                  * may be
1216                                                  * using this access list */
1217                                                 ospf_distribute_list_update(
1218                                                         ospf, type,
1219                                                         red->instance);
1220                                         }
1221                                 }
1222
1223                         /* There is place for route-map for default-information
1224                          * (ZEBRA_ROUTE_MAX),
1225                          * but no distribute list. */
1226                         if (type == ZEBRA_ROUTE_MAX)
1227                                 break;
1228
1229                         if (DISTRIBUTE_NAME(ospf, type)) {
1230                                 /* Keep old access-list for distribute-list. */
1231                                 struct access_list *old =
1232                                         DISTRIBUTE_LIST(ospf, type);
1233
1234                                 /* Update access-list for distribute-list. */
1235                                 DISTRIBUTE_LIST(ospf, type) =
1236                                         access_list_lookup(
1237                                                 AFI_IP,
1238                                                 DISTRIBUTE_NAME(ospf, type));
1239
1240                                 /* No update for this distribute type. */
1241                                 if (old == NULL
1242                                     && DISTRIBUTE_LIST(ospf, type) == NULL)
1243                                         continue;
1244
1245                                 /* Schedule distribute-list update timer. */
1246                                 if (DISTRIBUTE_LIST(ospf, type) == NULL
1247                                     || strcmp(DISTRIBUTE_NAME(ospf, type),
1248                                               access->name)
1249                                                == 0)
1250                                         ospf_distribute_list_update(ospf, type,
1251                                                                     0);
1252                         }
1253                 }
1254
1255                 /* Update Area access-list. */
1256                 for (ALL_LIST_ELEMENTS_RO(ospf->areas, node, area)) {
1257                         if (EXPORT_NAME(area)) {
1258                                 EXPORT_LIST(area) = NULL;
1259                                 abr_inv++;
1260                         }
1261
1262                         if (IMPORT_NAME(area)) {
1263                                 IMPORT_LIST(area) = NULL;
1264                                 abr_inv++;
1265                         }
1266                 }
1267
1268                 /* Schedule ABR tasks -- this will be changed -- takada. */
1269                 if (IS_OSPF_ABR(ospf) && abr_inv)
1270                         ospf_schedule_abr_task(ospf);
1271         }
1272 }
1273
1274 /* If prefix-list is updated, do some updates. */
1275 void ospf_prefix_list_update(struct prefix_list *plist)
1276 {
1277         struct ospf *ospf = NULL;
1278         int type;
1279         int abr_inv = 0;
1280         struct ospf_area *area;
1281         struct listnode *node, *n1;
1282
1283         /* If OSPF instatnce does not exist, return right now. */
1284         if (listcount(om->ospf) == 0)
1285                 return;
1286
1287         /* Iterate all ospf [VRF] instances */
1288         for (ALL_LIST_ELEMENTS_RO(om->ospf, n1, ospf)) {
1289
1290                 /* Update all route-maps which are used
1291                  * as redistribution filters.
1292                  * They might use prefix-list.
1293                  */
1294                 for (type = 0; type <= ZEBRA_ROUTE_MAX; type++) {
1295                         struct list *red_list;
1296                         struct listnode *node;
1297                         struct ospf_redist *red;
1298
1299                         red_list = ospf->redist[type];
1300                         if (red_list) {
1301                                 for (ALL_LIST_ELEMENTS_RO(red_list, node,
1302                                                           red)) {
1303                                         if (ROUTEMAP(red)) {
1304                                                 /* if route-map is not NULL
1305                                                  * it may be using
1306                                                  * this prefix list */
1307                                                 ospf_distribute_list_update(
1308                                                         ospf, type,
1309                                                         red->instance);
1310                                         }
1311                                 }
1312                         }
1313                 }
1314
1315                 /* Update area filter-lists. */
1316                 for (ALL_LIST_ELEMENTS_RO(ospf->areas, node, area)) {
1317                         /* Update filter-list in. */
1318                         if (PREFIX_NAME_IN(area))
1319                                 if (strcmp(PREFIX_NAME_IN(area),
1320                                            prefix_list_name(plist))
1321                                     == 0) {
1322                                         PREFIX_LIST_IN(area) =
1323                                                 prefix_list_lookup(
1324                                                         AFI_IP,
1325                                                         PREFIX_NAME_IN(area));
1326                                         abr_inv++;
1327                                 }
1328
1329                         /* Update filter-list out. */
1330                         if (PREFIX_NAME_OUT(area))
1331                                 if (strcmp(PREFIX_NAME_OUT(area),
1332                                            prefix_list_name(plist))
1333                                     == 0) {
1334                                         PREFIX_LIST_IN(area) =
1335                                                 prefix_list_lookup(
1336                                                         AFI_IP,
1337                                                         PREFIX_NAME_OUT(area));
1338                                         abr_inv++;
1339                                 }
1340                 }
1341
1342                 /* Schedule ABR task. */
1343                 if (IS_OSPF_ABR(ospf) && abr_inv)
1344                         ospf_schedule_abr_task(ospf);
1345         }
1346 }
1347
1348 static struct ospf_distance *ospf_distance_new(void)
1349 {
1350         return XCALLOC(MTYPE_OSPF_DISTANCE, sizeof(struct ospf_distance));
1351 }
1352
1353 static void ospf_distance_free(struct ospf_distance *odistance)
1354 {
1355         XFREE(MTYPE_OSPF_DISTANCE, odistance);
1356 }
1357
1358 int ospf_distance_set(struct vty *vty, struct ospf *ospf,
1359                       const char *distance_str, const char *ip_str,
1360                       const char *access_list_str)
1361 {
1362         int ret;
1363         struct prefix_ipv4 p;
1364         uint8_t distance;
1365         struct route_node *rn;
1366         struct ospf_distance *odistance;
1367
1368         ret = str2prefix_ipv4(ip_str, &p);
1369         if (ret == 0) {
1370                 vty_out(vty, "Malformed prefix\n");
1371                 return CMD_WARNING_CONFIG_FAILED;
1372         }
1373
1374         distance = atoi(distance_str);
1375
1376         /* Get OSPF distance node. */
1377         rn = route_node_get(ospf->distance_table, (struct prefix *)&p);
1378         if (rn->info) {
1379                 odistance = rn->info;
1380                 route_unlock_node(rn);
1381         } else {
1382                 odistance = ospf_distance_new();
1383                 rn->info = odistance;
1384         }
1385
1386         /* Set distance value. */
1387         odistance->distance = distance;
1388
1389         /* Reset access-list configuration. */
1390         if (odistance->access_list) {
1391                 free(odistance->access_list);
1392                 odistance->access_list = NULL;
1393         }
1394         if (access_list_str)
1395                 odistance->access_list = strdup(access_list_str);
1396
1397         return CMD_SUCCESS;
1398 }
1399
1400 int ospf_distance_unset(struct vty *vty, struct ospf *ospf,
1401                         const char *distance_str, const char *ip_str,
1402                         char const *access_list_str)
1403 {
1404         int ret;
1405         struct prefix_ipv4 p;
1406         struct route_node *rn;
1407         struct ospf_distance *odistance;
1408
1409         ret = str2prefix_ipv4(ip_str, &p);
1410         if (ret == 0) {
1411                 vty_out(vty, "Malformed prefix\n");
1412                 return CMD_WARNING_CONFIG_FAILED;
1413         }
1414
1415         rn = route_node_lookup(ospf->distance_table, (struct prefix *)&p);
1416         if (!rn) {
1417                 vty_out(vty, "Can't find specified prefix\n");
1418                 return CMD_WARNING_CONFIG_FAILED;
1419         }
1420
1421         odistance = rn->info;
1422
1423         if (odistance->access_list)
1424                 free(odistance->access_list);
1425         ospf_distance_free(odistance);
1426
1427         rn->info = NULL;
1428         route_unlock_node(rn);
1429         route_unlock_node(rn);
1430
1431         return CMD_SUCCESS;
1432 }
1433
1434 void ospf_distance_reset(struct ospf *ospf)
1435 {
1436         struct route_node *rn;
1437         struct ospf_distance *odistance;
1438
1439         for (rn = route_top(ospf->distance_table); rn; rn = route_next(rn))
1440                 if ((odistance = rn->info) != NULL) {
1441                         if (odistance->access_list)
1442                                 free(odistance->access_list);
1443                         ospf_distance_free(odistance);
1444                         rn->info = NULL;
1445                         route_unlock_node(rn);
1446                 }
1447 }
1448
1449 uint8_t ospf_distance_apply(struct ospf *ospf, struct prefix_ipv4 *p,
1450                             struct ospf_route * or)
1451 {
1452
1453         if (ospf == NULL)
1454                 return 0;
1455
1456         if (ospf->distance_intra)
1457                 if (or->path_type == OSPF_PATH_INTRA_AREA)
1458                         return ospf->distance_intra;
1459
1460         if (ospf->distance_inter)
1461                 if (or->path_type == OSPF_PATH_INTER_AREA)
1462                         return ospf->distance_inter;
1463
1464         if (ospf->distance_external)
1465                 if (or->path_type == OSPF_PATH_TYPE1_EXTERNAL ||
1466                     or->path_type == OSPF_PATH_TYPE2_EXTERNAL)
1467                         return ospf->distance_external;
1468
1469         if (ospf->distance_all)
1470                 return ospf->distance_all;
1471
1472         return 0;
1473 }
1474
1475 void ospf_zebra_vrf_register(struct ospf *ospf)
1476 {
1477         if (!zclient || zclient->sock < 0 || !ospf)
1478                 return;
1479
1480         if (ospf->vrf_id != VRF_UNKNOWN) {
1481                 if (IS_DEBUG_OSPF_EVENT)
1482                         zlog_debug("%s: Register VRF %s id %u",
1483                                    __PRETTY_FUNCTION__,
1484                                    ospf_vrf_id_to_name(ospf->vrf_id),
1485                                    ospf->vrf_id);
1486                 zclient_send_reg_requests(zclient, ospf->vrf_id);
1487         }
1488 }
1489
1490 void ospf_zebra_vrf_deregister(struct ospf *ospf)
1491 {
1492         if (!zclient || zclient->sock < 0 || !ospf)
1493                 return;
1494
1495         if (ospf->vrf_id != VRF_DEFAULT && ospf->vrf_id != VRF_UNKNOWN) {
1496                 if (IS_DEBUG_OSPF_EVENT)
1497                         zlog_debug("%s: De-Register VRF %s id %u to Zebra.",
1498                                    __PRETTY_FUNCTION__,
1499                                    ospf_vrf_id_to_name(ospf->vrf_id),
1500                                    ospf->vrf_id);
1501                 /* Deregister for router-id, interfaces,
1502                  * redistributed routes. */
1503                 zclient_send_dereg_requests(zclient, ospf->vrf_id);
1504         }
1505 }
1506 static void ospf_zebra_connected(struct zclient *zclient)
1507 {
1508         /* Send the client registration */
1509         bfd_client_sendmsg(zclient, ZEBRA_BFD_CLIENT_REGISTER);
1510
1511         zclient_send_reg_requests(zclient, VRF_DEFAULT);
1512 }
1513
1514 void ospf_zebra_init(struct thread_master *master, unsigned short instance)
1515 {
1516         /* Allocate zebra structure. */
1517         zclient = zclient_new_notify(master, &zclient_options_default);
1518         zclient_init(zclient, ZEBRA_ROUTE_OSPF, instance, &ospfd_privs);
1519         zclient->zebra_connected = ospf_zebra_connected;
1520         zclient->router_id_update = ospf_router_id_update_zebra;
1521         zclient->interface_add = ospf_interface_add;
1522         zclient->interface_delete = ospf_interface_delete;
1523         zclient->interface_up = ospf_interface_state_up;
1524         zclient->interface_down = ospf_interface_state_down;
1525         zclient->interface_address_add = ospf_interface_address_add;
1526         zclient->interface_address_delete = ospf_interface_address_delete;
1527         zclient->interface_link_params = ospf_interface_link_params;
1528         zclient->interface_vrf_update = ospf_interface_vrf_update;
1529
1530         zclient->redistribute_route_add = ospf_zebra_read_route;
1531         zclient->redistribute_route_del = ospf_zebra_read_route;
1532
1533         access_list_add_hook(ospf_filter_update);
1534         access_list_delete_hook(ospf_filter_update);
1535         prefix_list_add_hook(ospf_prefix_list_update);
1536         prefix_list_delete_hook(ospf_prefix_list_update);
1537 }