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