2 * Zebra connect library for OSPFd
3 * Copyright (C) 1997, 98, 99, 2000 Kunihiro Ishiguro, Toshiaki Takada
5 * This file is part of GNU Zebra.
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
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.
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
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"
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")
58 DEFINE_HOOK(ospf_if_update
, (struct interface
* ifp
), (ifp
))
59 DEFINE_HOOK(ospf_if_delete
, (struct interface
* ifp
), (ifp
))
61 /* Zebra structure to hold current status. */
62 struct zclient
*zclient
= NULL
;
64 /* For registering threads. */
65 extern struct thread_master
*master
;
67 /* Router-id update message from zebra. */
68 static int ospf_router_id_update_zebra(ZAPI_CALLBACK_ARGS
)
70 struct ospf
*ospf
= NULL
;
71 struct prefix router_id
;
72 zebra_router_id_update_read(zclient
->ibuf
, &router_id
);
74 if (IS_DEBUG_OSPF(zebra
, ZEBRA_INTERFACE
)) {
75 char buf
[PREFIX2STR_BUFFER
];
76 prefix2str(&router_id
, buf
, sizeof(buf
));
77 zlog_debug("Zebra rcvd: router id update %s vrf %s id %u", buf
,
78 ospf_vrf_id_to_name(vrf_id
), vrf_id
);
81 ospf
= ospf_lookup_by_vrf_id(vrf_id
);
84 ospf
->router_id_zebra
= router_id
.u
.prefix4
;
85 ospf_router_id_update(ospf
);
87 if (IS_DEBUG_OSPF_EVENT
) {
88 char buf
[PREFIX2STR_BUFFER
];
90 prefix2str(&router_id
, buf
, sizeof(buf
));
92 "%s: ospf instance not found for vrf %s id %u router_id %s",
94 ospf_vrf_id_to_name(vrf_id
), vrf_id
, buf
);
100 /* Inteface addition message from zebra. */
101 static int ospf_interface_add(ZAPI_CALLBACK_ARGS
)
103 struct interface
*ifp
= NULL
;
104 struct ospf
*ospf
= NULL
;
106 ifp
= zebra_interface_add_read(zclient
->ibuf
, vrf_id
);
110 if (IS_DEBUG_OSPF(zebra
, ZEBRA_INTERFACE
))
112 "Zebra: interface add %s vrf %s[%u] index %d flags %llx metric %d mtu %d speed %u",
113 ifp
->name
, ospf_vrf_id_to_name(ifp
->vrf_id
),
114 ifp
->vrf_id
, ifp
->ifindex
,
115 (unsigned long long)ifp
->flags
, ifp
->metric
, ifp
->mtu
,
120 if (IF_DEF_PARAMS(ifp
)
121 && !OSPF_IF_PARAM_CONFIGURED(IF_DEF_PARAMS(ifp
), type
)) {
122 SET_IF_PARAM(IF_DEF_PARAMS(ifp
), type
);
123 IF_DEF_PARAMS(ifp
)->type
= ospf_default_iftype(ifp
);
126 ospf
= ospf_lookup_by_vrf_id(vrf_id
);
130 ospf_if_recalculate_output_cost(ifp
);
132 ospf_if_update(ospf
, ifp
);
134 hook_call(ospf_if_update
, ifp
);
139 static int ospf_interface_delete(ZAPI_CALLBACK_ARGS
)
141 struct interface
*ifp
;
143 struct route_node
*rn
;
146 /* zebra_interface_state_read() updates interface structure in iflist */
147 ifp
= zebra_interface_state_read(s
, vrf_id
);
152 if (IS_DEBUG_OSPF(zebra
, ZEBRA_INTERFACE
))
154 "Zebra: interface delete %s vrf %s[%u] index %d flags %llx metric %d mtu %d",
155 ifp
->name
, ospf_vrf_id_to_name(ifp
->vrf_id
),
156 ifp
->vrf_id
, ifp
->ifindex
,
157 (unsigned long long)ifp
->flags
, ifp
->metric
, ifp
->mtu
);
159 hook_call(ospf_if_delete
, ifp
);
161 for (rn
= route_top(IF_OIFS(ifp
)); rn
; rn
= route_next(rn
))
163 ospf_if_free((struct ospf_interface
*)rn
->info
);
165 if_set_index(ifp
, IFINDEX_INTERNAL
);
169 static struct interface
*zebra_interface_if_lookup(struct stream
*s
,
172 char ifname_tmp
[INTERFACE_NAMSIZ
];
174 /* Read interface name. */
175 stream_get(ifname_tmp
, s
, INTERFACE_NAMSIZ
);
177 /* And look it up. */
178 return if_lookup_by_name(ifname_tmp
, vrf_id
);
181 static int ospf_interface_state_up(ZAPI_CALLBACK_ARGS
)
183 struct interface
*ifp
;
184 struct ospf_interface
*oi
;
185 struct route_node
*rn
;
187 ifp
= zebra_interface_if_lookup(zclient
->ibuf
, vrf_id
);
192 /* Interface is already up. */
193 if (if_is_operative(ifp
)) {
194 /* Temporarily keep ifp values. */
195 struct interface if_tmp
;
196 memcpy(&if_tmp
, ifp
, sizeof(struct interface
));
198 zebra_interface_if_set_value(zclient
->ibuf
, ifp
);
200 if (IS_DEBUG_OSPF(zebra
, ZEBRA_INTERFACE
))
202 "Zebra: Interface[%s] state update speed %u -> %u, bw %d -> %d",
203 ifp
->name
, if_tmp
.speed
, ifp
->speed
,
204 if_tmp
.bandwidth
, ifp
->bandwidth
);
206 ospf_if_recalculate_output_cost(ifp
);
208 if (if_tmp
.mtu
!= ifp
->mtu
) {
209 if (IS_DEBUG_OSPF(zebra
, ZEBRA_INTERFACE
))
211 "Zebra: Interface[%s] MTU change %u -> %u.",
212 ifp
->name
, if_tmp
.mtu
, ifp
->mtu
);
214 /* Must reset the interface (simulate down/up) when MTU
221 zebra_interface_if_set_value(zclient
->ibuf
, ifp
);
223 if (IS_DEBUG_OSPF(zebra
, ZEBRA_INTERFACE
))
224 zlog_debug("Zebra: Interface[%s] state change to up.",
227 for (rn
= route_top(IF_OIFS(ifp
)); rn
; rn
= route_next(rn
)) {
228 if ((oi
= rn
->info
) == NULL
)
237 static int ospf_interface_state_down(ZAPI_CALLBACK_ARGS
)
239 struct interface
*ifp
;
240 struct ospf_interface
*oi
;
241 struct route_node
*node
;
243 ifp
= zebra_interface_state_read(zclient
->ibuf
, vrf_id
);
248 if (IS_DEBUG_OSPF(zebra
, ZEBRA_INTERFACE
))
249 zlog_debug("Zebra: Interface[%s] state change to down.",
252 for (node
= route_top(IF_OIFS(ifp
)); node
; node
= route_next(node
)) {
253 if ((oi
= node
->info
) == NULL
)
261 static int ospf_interface_address_add(ZAPI_CALLBACK_ARGS
)
264 struct ospf
*ospf
= NULL
;
267 c
= zebra_interface_address_read(cmd
, zclient
->ibuf
, vrf_id
);
272 if (IS_DEBUG_OSPF(zebra
, ZEBRA_INTERFACE
)) {
273 char buf
[PREFIX2STR_BUFFER
];
274 prefix2str(c
->address
, buf
, sizeof(buf
));
275 zlog_debug("Zebra: interface %s address add %s vrf %s id %u",
276 c
->ifp
->name
, buf
, ospf_vrf_id_to_name(vrf_id
),
280 ospf
= ospf_lookup_by_vrf_id(vrf_id
);
284 ospf_if_update(ospf
, c
->ifp
);
286 hook_call(ospf_if_update
, c
->ifp
);
291 static int ospf_interface_address_delete(ZAPI_CALLBACK_ARGS
)
294 struct interface
*ifp
;
295 struct ospf_interface
*oi
;
296 struct route_node
*rn
;
299 c
= zebra_interface_address_read(cmd
, zclient
->ibuf
, vrf_id
);
304 if (IS_DEBUG_OSPF(zebra
, ZEBRA_INTERFACE
)) {
305 char buf
[PREFIX2STR_BUFFER
];
306 prefix2str(c
->address
, buf
, sizeof(buf
));
307 zlog_debug("Zebra: interface %s address delete %s",
313 p
.prefixlen
= IPV4_MAX_PREFIXLEN
;
315 rn
= route_node_lookup(IF_OIFS(ifp
), &p
);
323 route_unlock_node(rn
);
325 /* Call interface hook functions to clean up */
328 hook_call(ospf_if_update
, c
->ifp
);
335 static int ospf_interface_link_params(ZAPI_CALLBACK_ARGS
)
337 struct interface
*ifp
;
339 ifp
= zebra_interface_link_params_read(zclient
->ibuf
, vrf_id
);
345 ospf_mpls_te_update_if(ifp
);
350 /* VRF update for an interface. */
351 static int ospf_interface_vrf_update(ZAPI_CALLBACK_ARGS
)
353 struct interface
*ifp
= NULL
;
356 ifp
= zebra_interface_vrf_update_read(zclient
->ibuf
, vrf_id
,
361 if (IS_DEBUG_OSPF_EVENT
)
363 "%s: Rx Interface %s VRF change vrf_id %u New vrf %s id %u",
364 __PRETTY_FUNCTION__
, ifp
->name
, vrf_id
,
365 ospf_vrf_id_to_name(new_vrf_id
), new_vrf_id
);
367 /*if_update(ifp, ifp->name, strlen(ifp->name), new_vrf_id);*/
368 if_update_to_new_vrf(ifp
, new_vrf_id
);
373 void ospf_zebra_add(struct ospf
*ospf
, struct prefix_ipv4
*p
,
374 struct ospf_route
* or)
376 struct zapi_route api
;
377 struct zapi_nexthop
*api_nh
;
379 struct ospf_path
*path
;
380 struct listnode
*node
;
383 memset(&api
, 0, sizeof(api
));
384 api
.vrf_id
= ospf
->vrf_id
;
385 api
.type
= ZEBRA_ROUTE_OSPF
;
386 api
.instance
= ospf
->instance
;
387 api
.safi
= SAFI_UNICAST
;
389 memcpy(&api
.prefix
, p
, sizeof(*p
));
390 SET_FLAG(api
.message
, ZAPI_MESSAGE_NEXTHOP
);
393 SET_FLAG(api
.message
, ZAPI_MESSAGE_METRIC
);
394 if (or->path_type
== OSPF_PATH_TYPE1_EXTERNAL
)
395 api
.metric
= or->cost
+ or->u
.ext
.type2_cost
;
396 else if (or->path_type
== OSPF_PATH_TYPE2_EXTERNAL
)
397 api
.metric
= or->u
.ext
.type2_cost
;
399 api
.metric
= or->cost
;
401 /* Check if path type is ASE */
402 if (((or->path_type
== OSPF_PATH_TYPE1_EXTERNAL
)
403 || (or->path_type
== OSPF_PATH_TYPE2_EXTERNAL
))
404 && (or->u
.ext
.tag
> 0) && (or->u
.ext
.tag
<= ROUTE_TAG_MAX
)) {
405 SET_FLAG(api
.message
, ZAPI_MESSAGE_TAG
);
406 api
.tag
= or->u
.ext
.tag
;
409 /* Distance value. */
410 distance
= ospf_distance_apply(ospf
, p
, or);
412 SET_FLAG(api
.message
, ZAPI_MESSAGE_DISTANCE
);
413 api
.distance
= distance
;
416 /* Nexthop, ifindex, distance and metric information. */
417 for (ALL_LIST_ELEMENTS_RO(or->paths
, node
, path
)) {
418 if (count
>= MULTIPATH_NUM
)
420 api_nh
= &api
.nexthops
[count
];
422 if (path
->unnumbered
|| (path
->nexthop
.s_addr
!= INADDR_ANY
423 && path
->ifindex
!= 0)) {
424 #else /* HAVE_NETLINK */
425 if (path
->nexthop
.s_addr
!= INADDR_ANY
&& path
->ifindex
!= 0) {
426 #endif /* HAVE_NETLINK */
427 api_nh
->gate
.ipv4
= path
->nexthop
;
428 api_nh
->ifindex
= path
->ifindex
;
429 api_nh
->type
= NEXTHOP_TYPE_IPV4_IFINDEX
;
430 } else if (path
->nexthop
.s_addr
!= INADDR_ANY
) {
431 api_nh
->gate
.ipv4
= path
->nexthop
;
432 api_nh
->type
= NEXTHOP_TYPE_IPV4
;
434 api_nh
->ifindex
= path
->ifindex
;
435 api_nh
->type
= NEXTHOP_TYPE_IFINDEX
;
437 api_nh
->vrf_id
= ospf
->vrf_id
;
440 if (IS_DEBUG_OSPF(zebra
, ZEBRA_REDISTRIBUTE
)) {
441 char buf
[2][INET_ADDRSTRLEN
];
442 struct interface
*ifp
;
444 ifp
= if_lookup_by_index(path
->ifindex
, ospf
->vrf_id
);
447 "Zebra: Route add %s nexthop %s, ifindex=%d %s",
448 prefix2str(p
, buf
[0], sizeof(buf
[0])),
449 inet_ntop(AF_INET
, &path
->nexthop
,
450 buf
[1], sizeof(buf
[1])),
451 path
->ifindex
, ifp
? ifp
->name
: " ");
454 api
.nexthop_num
= count
;
456 zclient_route_send(ZEBRA_ROUTE_ADD
, zclient
, &api
);
459 void ospf_zebra_delete(struct ospf
*ospf
, struct prefix_ipv4
*p
,
460 struct ospf_route
* or)
462 struct zapi_route api
;
464 memset(&api
, 0, sizeof(api
));
465 api
.vrf_id
= ospf
->vrf_id
;
466 api
.type
= ZEBRA_ROUTE_OSPF
;
467 api
.instance
= ospf
->instance
;
468 api
.safi
= SAFI_UNICAST
;
469 memcpy(&api
.prefix
, p
, sizeof(*p
));
471 if (IS_DEBUG_OSPF(zebra
, ZEBRA_REDISTRIBUTE
)) {
472 char buf
[PREFIX2STR_BUFFER
];
473 zlog_debug("Zebra: Route delete %s",
474 prefix2str(p
, buf
, sizeof(buf
)));
477 zclient_route_send(ZEBRA_ROUTE_DELETE
, zclient
, &api
);
480 void ospf_zebra_add_discard(struct ospf
*ospf
, struct prefix_ipv4
*p
)
482 struct zapi_route api
;
484 memset(&api
, 0, sizeof(api
));
485 api
.vrf_id
= ospf
->vrf_id
;
486 api
.type
= ZEBRA_ROUTE_OSPF
;
487 api
.instance
= ospf
->instance
;
488 api
.safi
= SAFI_UNICAST
;
489 memcpy(&api
.prefix
, p
, sizeof(*p
));
490 zapi_route_set_blackhole(&api
, BLACKHOLE_NULL
);
492 zclient_route_send(ZEBRA_ROUTE_ADD
, zclient
, &api
);
494 if (IS_DEBUG_OSPF(zebra
, ZEBRA_REDISTRIBUTE
)) {
495 char buf
[PREFIX2STR_BUFFER
];
496 zlog_debug("Zebra: Route add discard %s",
497 prefix2str(p
, buf
, sizeof(buf
)));
501 void ospf_zebra_delete_discard(struct ospf
*ospf
, struct prefix_ipv4
*p
)
503 struct zapi_route api
;
505 memset(&api
, 0, sizeof(api
));
506 api
.vrf_id
= ospf
->vrf_id
;
507 api
.type
= ZEBRA_ROUTE_OSPF
;
508 api
.instance
= ospf
->instance
;
509 api
.safi
= SAFI_UNICAST
;
510 memcpy(&api
.prefix
, p
, sizeof(*p
));
511 zapi_route_set_blackhole(&api
, BLACKHOLE_NULL
);
513 zclient_route_send(ZEBRA_ROUTE_DELETE
, zclient
, &api
);
515 if (IS_DEBUG_OSPF(zebra
, ZEBRA_REDISTRIBUTE
)) {
516 char buf
[PREFIX2STR_BUFFER
];
517 zlog_debug("Zebra: Route delete discard %s",
518 prefix2str(p
, buf
, sizeof(buf
)));
522 struct ospf_external
*ospf_external_lookup(struct ospf
*ospf
, uint8_t type
,
523 unsigned short instance
)
525 struct list
*ext_list
;
526 struct listnode
*node
;
527 struct ospf_external
*ext
;
529 ext_list
= ospf
->external
[type
];
533 for (ALL_LIST_ELEMENTS_RO(ext_list
, node
, ext
))
534 if (ext
->instance
== instance
)
540 struct ospf_external
*ospf_external_add(struct ospf
*ospf
, uint8_t type
,
541 unsigned short instance
)
543 struct list
*ext_list
;
544 struct ospf_external
*ext
;
546 ext
= ospf_external_lookup(ospf
, type
, instance
);
550 if (!ospf
->external
[type
])
551 ospf
->external
[type
] = list_new();
553 ext_list
= ospf
->external
[type
];
554 ext
= XCALLOC(MTYPE_OSPF_EXTERNAL
, sizeof(struct ospf_external
));
555 ext
->instance
= instance
;
556 EXTERNAL_INFO(ext
) = route_table_init();
558 listnode_add(ext_list
, ext
);
563 void ospf_external_del(struct ospf
*ospf
, uint8_t type
, unsigned short instance
)
565 struct ospf_external
*ext
;
567 ext
= ospf_external_lookup(ospf
, type
, instance
);
570 if (EXTERNAL_INFO(ext
))
571 route_table_finish(EXTERNAL_INFO(ext
));
573 listnode_delete(ospf
->external
[type
], ext
);
575 if (!ospf
->external
[type
]->count
)
576 list_delete(&ospf
->external
[type
]);
578 XFREE(MTYPE_OSPF_EXTERNAL
, ext
);
582 struct ospf_redist
*ospf_redist_lookup(struct ospf
*ospf
, uint8_t type
,
583 unsigned short instance
)
585 struct list
*red_list
;
586 struct listnode
*node
;
587 struct ospf_redist
*red
;
589 red_list
= ospf
->redist
[type
];
593 for (ALL_LIST_ELEMENTS_RO(red_list
, node
, red
))
594 if (red
->instance
== instance
)
600 struct ospf_redist
*ospf_redist_add(struct ospf
*ospf
, uint8_t type
,
601 unsigned short instance
)
603 struct list
*red_list
;
604 struct ospf_redist
*red
;
606 red
= ospf_redist_lookup(ospf
, type
, instance
);
610 if (!ospf
->redist
[type
])
611 ospf
->redist
[type
] = list_new();
613 red_list
= ospf
->redist
[type
];
614 red
= XCALLOC(MTYPE_OSPF_REDISTRIBUTE
, sizeof(struct ospf_redist
));
615 red
->instance
= instance
;
616 red
->dmetric
.type
= -1;
617 red
->dmetric
.value
= -1;
618 ROUTEMAP_NAME(red
) = NULL
;
619 ROUTEMAP(red
) = NULL
;
621 listnode_add(red_list
, red
);
626 void ospf_redist_del(struct ospf
*ospf
, uint8_t type
, unsigned short instance
)
628 struct ospf_redist
*red
;
630 red
= ospf_redist_lookup(ospf
, type
, instance
);
633 listnode_delete(ospf
->redist
[type
], red
);
634 if (!ospf
->redist
[type
]->count
) {
635 list_delete(&ospf
->redist
[type
]);
637 ospf_routemap_unset(red
);
638 XFREE(MTYPE_OSPF_REDISTRIBUTE
, red
);
643 int ospf_is_type_redistributed(struct ospf
*ospf
, int type
,
644 unsigned short instance
)
646 return (DEFAULT_ROUTE_TYPE(type
)
647 ? vrf_bitmap_check(zclient
->default_information
[AFI_IP
],
650 && redist_check_instance(
651 &zclient
->mi_redist
[AFI_IP
][type
],
655 zclient
->redist
[AFI_IP
][type
],
659 int ospf_redistribute_set(struct ospf
*ospf
, int type
, unsigned short instance
,
660 int mtype
, int mvalue
)
663 struct ospf_redist
*red
;
665 red
= ospf_redist_lookup(ospf
, type
, instance
);
669 "Redistribute[%s][%d]: Lookup failed Type[%d] , Metric[%d]",
670 ospf_redist_string(type
), instance
,
671 metric_type(ospf
, type
, instance
),
672 metric_value(ospf
, type
, instance
));
673 return CMD_WARNING_CONFIG_FAILED
;
676 if (ospf_is_type_redistributed(ospf
, type
, instance
)) {
677 if (mtype
!= red
->dmetric
.type
) {
678 red
->dmetric
.type
= mtype
;
679 force
= LSA_REFRESH_FORCE
;
681 if (mvalue
!= red
->dmetric
.value
) {
682 red
->dmetric
.value
= mvalue
;
683 force
= LSA_REFRESH_FORCE
;
686 ospf_external_lsa_refresh_type(ospf
, type
, instance
, force
);
688 if (IS_DEBUG_OSPF(zebra
, ZEBRA_REDISTRIBUTE
))
690 "Redistribute[%s][%d]: Refresh Type[%d], Metric[%d]",
691 ospf_redist_string(type
), instance
,
692 metric_type(ospf
, type
, instance
),
693 metric_value(ospf
, type
, instance
));
698 red
->dmetric
.type
= mtype
;
699 red
->dmetric
.value
= mvalue
;
701 ospf_external_add(ospf
, type
, instance
);
703 zclient_redistribute(ZEBRA_REDISTRIBUTE_ADD
, zclient
, AFI_IP
, type
,
704 instance
, ospf
->vrf_id
);
706 if (IS_DEBUG_OSPF(zebra
, ZEBRA_REDISTRIBUTE
))
708 "Redistribute[%s][%d] vrf id %u: Start Type[%d], Metric[%d]",
709 ospf_redist_string(type
), instance
, ospf
->vrf_id
,
710 metric_type(ospf
, type
, instance
),
711 metric_value(ospf
, type
, instance
));
713 ospf_asbr_status_update(ospf
, ++ospf
->redistribute
);
718 int ospf_redistribute_unset(struct ospf
*ospf
, int type
,
719 unsigned short instance
)
721 if (type
== zclient
->redist_default
&& instance
== zclient
->instance
)
724 if (!ospf_is_type_redistributed(ospf
, type
, instance
))
727 zclient_redistribute(ZEBRA_REDISTRIBUTE_DELETE
, zclient
, AFI_IP
, type
,
728 instance
, ospf
->vrf_id
);
730 if (IS_DEBUG_OSPF(zebra
, ZEBRA_REDISTRIBUTE
))
731 zlog_debug("Redistribute[%s][%d] vrf id %u: Stop",
732 ospf_redist_string(type
), instance
, ospf
->vrf_id
);
734 /* Remove the routes from OSPF table. */
735 ospf_redistribute_withdraw(ospf
, type
, instance
);
737 ospf_external_del(ospf
, type
, instance
);
739 ospf_asbr_status_update(ospf
, --ospf
->redistribute
);
744 int ospf_redistribute_default_set(struct ospf
*ospf
, int originate
, int mtype
,
747 struct ospf_external
*ext
;
748 struct prefix_ipv4 p
;
749 struct in_addr nexthop
;
750 int cur_originate
= ospf
->default_originate
;
757 ospf
->default_originate
= originate
;
759 ospf_external_add(ospf
, DEFAULT_ROUTE
, 0);
761 if (cur_originate
== DEFAULT_ORIGINATE_NONE
) {
762 /* First time configuration */
763 if (IS_DEBUG_OSPF(zebra
, ZEBRA_REDISTRIBUTE
))
764 zlog_debug("Redistribute[DEFAULT]: Start Type[%d], Metric[%d]",
765 metric_type(ospf
, DEFAULT_ROUTE
, 0),
766 metric_value(ospf
, DEFAULT_ROUTE
, 0));
768 if (ospf
->router_id
.s_addr
== 0)
769 ospf
->external_origin
|= (1 << DEFAULT_ROUTE
);
770 if ((originate
== DEFAULT_ORIGINATE_ALWAYS
)
771 && (ospf
->router_id
.s_addr
)) {
773 /* always , so originate lsa even it doesn't
776 ospf_external_info_add(ospf
, DEFAULT_ROUTE
, 0,
778 ospf_external_lsa_refresh_default(ospf
);
780 } else if (originate
== DEFAULT_ORIGINATE_ZEBRA
) {
781 /* Send msg to Zebra to validate default route
784 zclient_redistribute_default(
785 ZEBRA_REDISTRIBUTE_DEFAULT_ADD
, zclient
, AFI_IP
,
789 ospf_asbr_status_update(ospf
, ++ospf
->redistribute
);
793 } else if (originate
== cur_originate
) {
794 /* Refresh the lsa since metric might different */
795 if (IS_DEBUG_OSPF(zebra
, ZEBRA_REDISTRIBUTE
))
797 "Redistribute[%s]: Refresh Type[%d], Metric[%d]",
798 ospf_redist_string(DEFAULT_ROUTE
),
799 metric_type(ospf
, DEFAULT_ROUTE
, 0),
800 metric_value(ospf
, DEFAULT_ROUTE
, 0));
802 ospf_external_lsa_refresh_default(ospf
);
805 /* "default-info originate always" configured now,
806 * where "default-info originate" configured previoulsly.
808 if (originate
== DEFAULT_ORIGINATE_ALWAYS
) {
810 zclient_redistribute_default(
811 ZEBRA_REDISTRIBUTE_DEFAULT_DELETE
,
812 zclient
, AFI_IP
, ospf
->vrf_id
);
813 /* here , ex-info should be added since ex-info might
814 * have not updated earlier if def route is not exist.
815 * If ex-iinfo ex-info already exist , it will return
818 ospf_external_info_add(ospf
, DEFAULT_ROUTE
, 0,
820 ospf_external_lsa_refresh_default(ospf
);
823 /* "default-info originate" configured now,where
824 * "default-info originate always" configured
828 ospf_external_lsa_flush(ospf
, DEFAULT_ROUTE
, &p
, 0);
830 ext
= ospf_external_lookup(ospf
, DEFAULT_ROUTE
, 0);
831 if (ext
&& EXTERNAL_INFO(ext
))
832 ospf_external_info_delete(ospf
,
833 DEFAULT_ROUTE
, 0, p
);
835 zclient_redistribute_default(
836 ZEBRA_REDISTRIBUTE_DEFAULT_ADD
,
837 zclient
, AFI_IP
, ospf
->vrf_id
);
843 int ospf_redistribute_default_unset(struct ospf
*ospf
)
845 if (ospf
->default_originate
== DEFAULT_ORIGINATE_ZEBRA
) {
846 if (!ospf_is_type_redistributed(ospf
, DEFAULT_ROUTE
, 0))
848 zclient_redistribute_default(ZEBRA_REDISTRIBUTE_DEFAULT_DELETE
,
849 zclient
, AFI_IP
, ospf
->vrf_id
);
852 ospf
->default_originate
= DEFAULT_ORIGINATE_NONE
;
854 if (IS_DEBUG_OSPF(zebra
, ZEBRA_REDISTRIBUTE
))
855 zlog_debug("Redistribute[DEFAULT]: Stop");
857 // Pending: how does the external_info cleanup work in this case?
859 ospf_asbr_status_update(ospf
, --ospf
->redistribute
);
861 /* clean up maxage default originate external lsa */
862 ospf_default_originate_lsa_update(ospf
);
867 static int ospf_external_lsa_originate_check(struct ospf
*ospf
,
868 struct external_info
*ei
)
870 /* If prefix is multicast, then do not originate LSA. */
871 if (IN_MULTICAST(htonl(ei
->p
.prefix
.s_addr
))) {
873 "LSA[Type5:%s]: Not originate AS-external-LSA, "
874 "Prefix belongs multicast",
875 inet_ntoa(ei
->p
.prefix
));
879 /* Take care of default-originate. */
880 if (is_prefix_default(&ei
->p
))
881 if (ospf
->default_originate
== DEFAULT_ORIGINATE_NONE
) {
883 "LSA[Type5:0.0.0.0]: Not originate AS-external-LSA "
891 /* If connected prefix is OSPF enable interface, then do not announce. */
892 int ospf_distribute_check_connected(struct ospf
*ospf
, struct external_info
*ei
)
894 struct listnode
*node
;
895 struct ospf_interface
*oi
;
898 for (ALL_LIST_ELEMENTS_RO(ospf
->oiflist
, node
, oi
))
899 if (prefix_match(oi
->address
, (struct prefix
*)&ei
->p
))
904 /* return 1 if external LSA must be originated, 0 otherwise */
905 int ospf_redistribute_check(struct ospf
*ospf
, struct external_info
*ei
,
908 struct route_map_set_values save_values
;
909 struct prefix_ipv4
*p
= &ei
->p
;
910 struct ospf_redist
*red
;
911 uint8_t type
= is_prefix_default(&ei
->p
) ? DEFAULT_ROUTE
: ei
->type
;
912 unsigned short instance
= is_prefix_default(&ei
->p
) ? 0 : ei
->instance
;
917 if (!ospf_external_lsa_originate_check(ospf
, ei
))
920 /* Take care connected route. */
921 if (type
== ZEBRA_ROUTE_CONNECT
922 && !ospf_distribute_check_connected(ospf
, ei
))
925 if (!DEFAULT_ROUTE_TYPE(type
) && DISTRIBUTE_NAME(ospf
, type
))
926 /* distirbute-list exists, but access-list may not? */
927 if (DISTRIBUTE_LIST(ospf
, type
))
928 if (access_list_apply(DISTRIBUTE_LIST(ospf
, type
), p
)
930 if (IS_DEBUG_OSPF(zebra
, ZEBRA_REDISTRIBUTE
)) {
931 char buf
[PREFIX2STR_BUFFER
];
933 "Redistribute[%s]: %s filtered by distribute-list.",
934 ospf_redist_string(type
),
935 prefix2str(p
, buf
, sizeof(buf
)));
940 save_values
= ei
->route_map_set
;
941 ospf_reset_route_map_set_values(&ei
->route_map_set
);
943 /* apply route-map if needed */
944 red
= ospf_redist_lookup(ospf
, type
, instance
);
945 if (red
&& ROUTEMAP_NAME(red
)) {
948 ret
= route_map_apply(ROUTEMAP(red
), (struct prefix
*)p
,
951 if (ret
== RMAP_DENYMATCH
) {
952 ei
->route_map_set
= save_values
;
953 if (IS_DEBUG_OSPF(zebra
, ZEBRA_REDISTRIBUTE
)) {
954 char buf
[PREFIX2STR_BUFFER
];
956 "Redistribute[%s]: %s filtered by route-map.",
957 ospf_redist_string(type
),
958 prefix2str(p
, buf
, sizeof(buf
)));
963 /* check if 'route-map set' changed something */
965 *changed
= !ospf_route_map_set_compare(
966 &ei
->route_map_set
, &save_values
);
972 /* OSPF route-map set for redistribution */
973 void ospf_routemap_set(struct ospf_redist
*red
, const char *name
)
975 if (ROUTEMAP_NAME(red
)) {
976 route_map_counter_decrement(ROUTEMAP(red
));
977 free(ROUTEMAP_NAME(red
));
980 ROUTEMAP_NAME(red
) = strdup(name
);
981 ROUTEMAP(red
) = route_map_lookup_by_name(name
);
982 route_map_counter_increment(ROUTEMAP(red
));
985 void ospf_routemap_unset(struct ospf_redist
*red
)
987 if (ROUTEMAP_NAME(red
)) {
988 route_map_counter_decrement(ROUTEMAP(red
));
989 free(ROUTEMAP_NAME(red
));
992 ROUTEMAP_NAME(red
) = NULL
;
993 ROUTEMAP(red
) = NULL
;
996 /* Zebra route add and delete treatment. */
997 static int ospf_zebra_read_route(ZAPI_CALLBACK_ARGS
)
999 struct zapi_route api
;
1000 struct prefix_ipv4 p
;
1001 unsigned long ifindex
;
1002 struct in_addr nexthop
;
1003 struct external_info
*ei
;
1008 ospf
= ospf_lookup_by_vrf_id(vrf_id
);
1012 if (zapi_route_decode(zclient
->ibuf
, &api
) < 0)
1015 ifindex
= api
.nexthops
[0].ifindex
;
1016 nexthop
= api
.nexthops
[0].gate
.ipv4
;
1019 memcpy(&p
, &api
.prefix
, sizeof(p
));
1020 if (IPV4_NET127(ntohl(p
.prefix
.s_addr
)))
1023 /* Re-destributed route is default route.
1024 * Here, route type is used as 'ZEBRA_ROUTE_KERNEL' for
1025 * updating ex-info. But in resetting (no default-info
1026 * originate)ZEBRA_ROUTE_MAX is used to delete the ex-info.
1027 * Resolved this inconsistency by maintaining same route type.
1029 if (is_prefix_default(&p
))
1030 rt_type
= DEFAULT_ROUTE
;
1032 if (IS_DEBUG_OSPF(zebra
, ZEBRA_REDISTRIBUTE
)) {
1033 char buf_prefix
[PREFIX_STRLEN
];
1034 prefix2str(&api
.prefix
, buf_prefix
, sizeof(buf_prefix
));
1036 zlog_debug("%s: from client %s: vrf_id %d, p %s", __func__
,
1037 zebra_route_string(api
.type
), vrf_id
, buf_prefix
);
1040 if (cmd
== ZEBRA_REDISTRIBUTE_ROUTE_ADD
) {
1041 /* XXX|HACK|TODO|FIXME:
1042 * Maybe we should ignore reject/blackhole routes? Testing
1043 * shows that there is no problems though and this is only way
1044 * to "summarize" routes in ASBR at the moment. Maybe we need
1045 * just a better generalised solution for these types?
1048 /* Protocol tag overwrites all other tag value sent by zebra */
1049 if (ospf
->dtag
[rt_type
] > 0)
1050 api
.tag
= ospf
->dtag
[rt_type
];
1053 * Given zebra sends update for a prefix via ADD message, it
1055 * be considered as an implicit DEL for that prefix with other
1059 for (i
= 0; i
<= ZEBRA_ROUTE_MAX
; i
++)
1061 ospf_external_info_delete(ospf
, i
, api
.instance
,
1064 ei
= ospf_external_info_add(ospf
, rt_type
, api
.instance
, p
,
1065 ifindex
, nexthop
, api
.tag
);
1067 /* Nothing has changed, so nothing to do; return */
1070 if (ospf
->router_id
.s_addr
== 0)
1071 /* Set flags to generate AS-external-LSA originate event
1072 for each redistributed protocols later. */
1073 ospf
->external_origin
|= (1 << rt_type
);
1076 if (is_prefix_default(&p
))
1077 ospf_external_lsa_refresh_default(ospf
);
1079 struct ospf_lsa
*current
;
1081 current
= ospf_external_info_find_lsa(
1084 ospf_external_lsa_originate(
1089 ZEBRA_REDISTRIBUTE
))
1091 "ospf_zebra_read_route() : %s refreshing LSA",
1094 ospf_external_lsa_refresh(
1101 } else /* if (cmd == ZEBRA_REDISTRIBUTE_ROUTE_DEL) */
1103 ospf_external_info_delete(ospf
, rt_type
, api
.instance
, p
);
1104 if (is_prefix_default(&p
))
1105 ospf_external_lsa_refresh_default(ospf
);
1107 ospf_external_lsa_flush(ospf
, rt_type
, &p
,
1108 ifindex
/*, nexthop */);
1115 int ospf_distribute_list_out_set(struct ospf
*ospf
, int type
, const char *name
)
1117 /* Lookup access-list for distribute-list. */
1118 DISTRIBUTE_LIST(ospf
, type
) = access_list_lookup(AFI_IP
, name
);
1120 /* Clear previous distribute-name. */
1121 if (DISTRIBUTE_NAME(ospf
, type
))
1122 free(DISTRIBUTE_NAME(ospf
, type
));
1124 /* Set distribute-name. */
1125 DISTRIBUTE_NAME(ospf
, type
) = strdup(name
);
1127 /* If access-list have been set, schedule update timer. */
1128 if (DISTRIBUTE_LIST(ospf
, type
))
1129 ospf_distribute_list_update(ospf
, type
, 0);
1134 int ospf_distribute_list_out_unset(struct ospf
*ospf
, int type
,
1137 /* Schedule update timer. */
1138 if (DISTRIBUTE_LIST(ospf
, type
))
1139 ospf_distribute_list_update(ospf
, type
, 0);
1141 /* Unset distribute-list. */
1142 DISTRIBUTE_LIST(ospf
, type
) = NULL
;
1144 /* Clear distribute-name. */
1145 if (DISTRIBUTE_NAME(ospf
, type
))
1146 free(DISTRIBUTE_NAME(ospf
, type
));
1148 DISTRIBUTE_NAME(ospf
, type
) = NULL
;
1153 /* distribute-list update timer. */
1154 static int ospf_distribute_list_update_timer(struct thread
*thread
)
1156 struct route_node
*rn
;
1157 struct external_info
*ei
;
1158 struct route_table
*rt
;
1159 struct ospf_lsa
*lsa
;
1160 int type
, default_refresh
= 0, arg_type
;
1161 struct ospf
*ospf
= NULL
;
1162 void **arg
= THREAD_ARG(thread
);
1164 ospf
= (struct ospf
*)arg
[0];
1165 arg_type
= (int)(intptr_t)arg
[1];
1170 ospf
->t_distribute_update
= NULL
;
1172 zlog_info("Zebra[Redistribute]: distribute-list update timer fired!");
1174 if (IS_DEBUG_OSPF_EVENT
) {
1176 "%s: ospf distribute-list update arg_type %d vrf %s id %d",
1177 __PRETTY_FUNCTION__
, arg_type
,
1178 ospf_vrf_id_to_name(ospf
->vrf_id
), ospf
->vrf_id
);
1181 /* foreach all external info. */
1182 for (type
= 0; type
<= ZEBRA_ROUTE_MAX
; type
++) {
1183 struct list
*ext_list
;
1184 struct listnode
*node
;
1185 struct ospf_external
*ext
;
1187 ext_list
= ospf
->external
[type
];
1191 for (ALL_LIST_ELEMENTS_RO(ext_list
, node
, ext
)) {
1192 rt
= ext
->external_info
;
1195 for (rn
= route_top(rt
); rn
; rn
= route_next(rn
))
1196 if ((ei
= rn
->info
) != NULL
) {
1197 if (is_prefix_default(&ei
->p
))
1198 default_refresh
= 1;
1200 (lsa
= ospf_external_info_find_lsa(
1202 ospf_external_lsa_refresh(
1204 LSA_REFRESH_IF_CHANGED
);
1206 ospf_external_lsa_originate(
1211 if (default_refresh
)
1212 ospf_external_lsa_refresh_default(ospf
);
1214 XFREE(MTYPE_OSPF_DIST_ARGS
, arg
);
1218 /* Update distribute-list and set timer to apply access-list. */
1219 void ospf_distribute_list_update(struct ospf
*ospf
, int type
,
1220 unsigned short instance
)
1222 struct route_table
*rt
;
1223 struct ospf_external
*ext
;
1224 void **args
= XCALLOC(MTYPE_OSPF_DIST_ARGS
, sizeof(void *) * 2);
1227 args
[1] = (void *)((ptrdiff_t)type
);
1229 /* External info does not exist. */
1230 ext
= ospf_external_lookup(ospf
, type
, instance
);
1231 if (!ext
|| !(rt
= EXTERNAL_INFO(ext
))) {
1232 XFREE(MTYPE_OSPF_DIST_ARGS
, args
);
1236 /* If exists previously invoked thread, then let it continue. */
1237 if (ospf
->t_distribute_update
) {
1238 XFREE(MTYPE_OSPF_DIST_ARGS
, args
);
1243 ospf
->t_distribute_update
= NULL
;
1244 thread_add_timer_msec(master
, ospf_distribute_list_update_timer
,
1245 (void **)args
, ospf
->min_ls_interval
,
1246 &ospf
->t_distribute_update
);
1249 /* If access-list is updated, apply some check. */
1250 static void ospf_filter_update(struct access_list
*access
)
1255 struct ospf_area
*area
;
1256 struct listnode
*node
, *n1
;
1258 /* If OSPF instance does not exist, return right now. */
1259 if (listcount(om
->ospf
) == 0)
1262 /* Iterate all ospf [VRF] instances */
1263 for (ALL_LIST_ELEMENTS_RO(om
->ospf
, n1
, ospf
)) {
1264 /* Update distribute-list, and apply filter. */
1265 for (type
= 0; type
<= ZEBRA_ROUTE_MAX
; type
++) {
1266 struct list
*red_list
;
1267 struct ospf_redist
*red
;
1269 red_list
= ospf
->redist
[type
];
1271 for (ALL_LIST_ELEMENTS_RO(red_list
, node
,
1273 if (ROUTEMAP(red
)) {
1274 /* if route-map is not NULL it
1276 * using this access list */
1277 ospf_distribute_list_update(
1283 /* There is place for route-map for default-information
1284 * (ZEBRA_ROUTE_MAX),
1285 * but no distribute list. */
1286 if (type
== ZEBRA_ROUTE_MAX
)
1289 if (DISTRIBUTE_NAME(ospf
, type
)) {
1290 /* Keep old access-list for distribute-list. */
1291 struct access_list
*old
=
1292 DISTRIBUTE_LIST(ospf
, type
);
1294 /* Update access-list for distribute-list. */
1295 DISTRIBUTE_LIST(ospf
, type
) =
1298 DISTRIBUTE_NAME(ospf
, type
));
1300 /* No update for this distribute type. */
1302 && DISTRIBUTE_LIST(ospf
, type
) == NULL
)
1305 /* Schedule distribute-list update timer. */
1306 if (DISTRIBUTE_LIST(ospf
, type
) == NULL
1307 || strcmp(DISTRIBUTE_NAME(ospf
, type
),
1310 ospf_distribute_list_update(ospf
, type
,
1315 /* Update Area access-list. */
1316 for (ALL_LIST_ELEMENTS_RO(ospf
->areas
, node
, area
)) {
1317 if (EXPORT_NAME(area
)) {
1318 EXPORT_LIST(area
) = NULL
;
1322 if (IMPORT_NAME(area
)) {
1323 IMPORT_LIST(area
) = NULL
;
1328 /* Schedule ABR tasks -- this will be changed -- takada. */
1329 if (IS_OSPF_ABR(ospf
) && abr_inv
)
1330 ospf_schedule_abr_task(ospf
);
1334 /* If prefix-list is updated, do some updates. */
1335 void ospf_prefix_list_update(struct prefix_list
*plist
)
1337 struct ospf
*ospf
= NULL
;
1340 struct ospf_area
*area
;
1341 struct listnode
*node
, *n1
;
1343 /* If OSPF instatnce does not exist, return right now. */
1344 if (listcount(om
->ospf
) == 0)
1347 /* Iterate all ospf [VRF] instances */
1348 for (ALL_LIST_ELEMENTS_RO(om
->ospf
, n1
, ospf
)) {
1350 /* Update all route-maps which are used
1351 * as redistribution filters.
1352 * They might use prefix-list.
1354 for (type
= 0; type
<= ZEBRA_ROUTE_MAX
; type
++) {
1355 struct list
*red_list
;
1356 struct ospf_redist
*red
;
1358 red_list
= ospf
->redist
[type
];
1360 for (ALL_LIST_ELEMENTS_RO(red_list
, node
,
1362 if (ROUTEMAP(red
)) {
1363 /* if route-map is not NULL
1365 * this prefix list */
1366 ospf_distribute_list_update(
1374 /* Update area filter-lists. */
1375 for (ALL_LIST_ELEMENTS_RO(ospf
->areas
, node
, area
)) {
1376 /* Update filter-list in. */
1377 if (PREFIX_NAME_IN(area
))
1378 if (strcmp(PREFIX_NAME_IN(area
),
1379 prefix_list_name(plist
))
1381 PREFIX_LIST_IN(area
) =
1384 PREFIX_NAME_IN(area
));
1388 /* Update filter-list out. */
1389 if (PREFIX_NAME_OUT(area
))
1390 if (strcmp(PREFIX_NAME_OUT(area
),
1391 prefix_list_name(plist
))
1393 PREFIX_LIST_IN(area
) =
1396 PREFIX_NAME_OUT(area
));
1401 /* Schedule ABR task. */
1402 if (IS_OSPF_ABR(ospf
) && abr_inv
)
1403 ospf_schedule_abr_task(ospf
);
1407 static struct ospf_distance
*ospf_distance_new(void)
1409 return XCALLOC(MTYPE_OSPF_DISTANCE
, sizeof(struct ospf_distance
));
1412 static void ospf_distance_free(struct ospf_distance
*odistance
)
1414 XFREE(MTYPE_OSPF_DISTANCE
, odistance
);
1417 int ospf_distance_set(struct vty
*vty
, struct ospf
*ospf
,
1418 const char *distance_str
, const char *ip_str
,
1419 const char *access_list_str
)
1422 struct prefix_ipv4 p
;
1424 struct route_node
*rn
;
1425 struct ospf_distance
*odistance
;
1427 ret
= str2prefix_ipv4(ip_str
, &p
);
1429 vty_out(vty
, "Malformed prefix\n");
1430 return CMD_WARNING_CONFIG_FAILED
;
1433 distance
= atoi(distance_str
);
1435 /* Get OSPF distance node. */
1436 rn
= route_node_get(ospf
->distance_table
, (struct prefix
*)&p
);
1438 odistance
= rn
->info
;
1439 route_unlock_node(rn
);
1441 odistance
= ospf_distance_new();
1442 rn
->info
= odistance
;
1445 /* Set distance value. */
1446 odistance
->distance
= distance
;
1448 /* Reset access-list configuration. */
1449 if (odistance
->access_list
) {
1450 free(odistance
->access_list
);
1451 odistance
->access_list
= NULL
;
1453 if (access_list_str
)
1454 odistance
->access_list
= strdup(access_list_str
);
1459 int ospf_distance_unset(struct vty
*vty
, struct ospf
*ospf
,
1460 const char *distance_str
, const char *ip_str
,
1461 char const *access_list_str
)
1464 struct prefix_ipv4 p
;
1465 struct route_node
*rn
;
1466 struct ospf_distance
*odistance
;
1468 ret
= str2prefix_ipv4(ip_str
, &p
);
1470 vty_out(vty
, "Malformed prefix\n");
1471 return CMD_WARNING_CONFIG_FAILED
;
1474 rn
= route_node_lookup(ospf
->distance_table
, (struct prefix
*)&p
);
1476 vty_out(vty
, "Can't find specified prefix\n");
1477 return CMD_WARNING_CONFIG_FAILED
;
1480 odistance
= rn
->info
;
1482 if (odistance
->access_list
)
1483 free(odistance
->access_list
);
1484 ospf_distance_free(odistance
);
1487 route_unlock_node(rn
);
1488 route_unlock_node(rn
);
1493 void ospf_distance_reset(struct ospf
*ospf
)
1495 struct route_node
*rn
;
1496 struct ospf_distance
*odistance
;
1498 for (rn
= route_top(ospf
->distance_table
); rn
; rn
= route_next(rn
))
1499 if ((odistance
= rn
->info
) != NULL
) {
1500 if (odistance
->access_list
)
1501 free(odistance
->access_list
);
1502 ospf_distance_free(odistance
);
1504 route_unlock_node(rn
);
1508 uint8_t ospf_distance_apply(struct ospf
*ospf
, struct prefix_ipv4
*p
,
1509 struct ospf_route
* or)
1515 if (ospf
->distance_intra
)
1516 if (or->path_type
== OSPF_PATH_INTRA_AREA
)
1517 return ospf
->distance_intra
;
1519 if (ospf
->distance_inter
)
1520 if (or->path_type
== OSPF_PATH_INTER_AREA
)
1521 return ospf
->distance_inter
;
1523 if (ospf
->distance_external
)
1524 if (or->path_type
== OSPF_PATH_TYPE1_EXTERNAL
||
1525 or->path_type
== OSPF_PATH_TYPE2_EXTERNAL
)
1526 return ospf
->distance_external
;
1528 if (ospf
->distance_all
)
1529 return ospf
->distance_all
;
1534 void ospf_zebra_vrf_register(struct ospf
*ospf
)
1536 if (!zclient
|| zclient
->sock
< 0 || !ospf
)
1539 if (ospf
->vrf_id
!= VRF_UNKNOWN
) {
1540 if (IS_DEBUG_OSPF_EVENT
)
1541 zlog_debug("%s: Register VRF %s id %u",
1542 __PRETTY_FUNCTION__
,
1543 ospf_vrf_id_to_name(ospf
->vrf_id
),
1545 zclient_send_reg_requests(zclient
, ospf
->vrf_id
);
1549 void ospf_zebra_vrf_deregister(struct ospf
*ospf
)
1551 if (!zclient
|| zclient
->sock
< 0 || !ospf
)
1554 if (ospf
->vrf_id
!= VRF_DEFAULT
&& ospf
->vrf_id
!= VRF_UNKNOWN
) {
1555 if (IS_DEBUG_OSPF_EVENT
)
1556 zlog_debug("%s: De-Register VRF %s id %u to Zebra.",
1557 __PRETTY_FUNCTION__
,
1558 ospf_vrf_id_to_name(ospf
->vrf_id
),
1560 /* Deregister for router-id, interfaces,
1561 * redistributed routes. */
1562 zclient_send_dereg_requests(zclient
, ospf
->vrf_id
);
1565 static void ospf_zebra_connected(struct zclient
*zclient
)
1567 /* Send the client registration */
1568 bfd_client_sendmsg(zclient
, ZEBRA_BFD_CLIENT_REGISTER
, VRF_DEFAULT
);
1570 zclient_send_reg_requests(zclient
, VRF_DEFAULT
);
1573 void ospf_zebra_init(struct thread_master
*master
, unsigned short instance
)
1575 /* Allocate zebra structure. */
1576 zclient
= zclient_new(master
, &zclient_options_default
);
1577 zclient_init(zclient
, ZEBRA_ROUTE_OSPF
, instance
, &ospfd_privs
);
1578 zclient
->zebra_connected
= ospf_zebra_connected
;
1579 zclient
->router_id_update
= ospf_router_id_update_zebra
;
1580 zclient
->interface_add
= ospf_interface_add
;
1581 zclient
->interface_delete
= ospf_interface_delete
;
1582 zclient
->interface_up
= ospf_interface_state_up
;
1583 zclient
->interface_down
= ospf_interface_state_down
;
1584 zclient
->interface_address_add
= ospf_interface_address_add
;
1585 zclient
->interface_address_delete
= ospf_interface_address_delete
;
1586 zclient
->interface_link_params
= ospf_interface_link_params
;
1587 zclient
->interface_vrf_update
= ospf_interface_vrf_update
;
1589 zclient
->redistribute_route_add
= ospf_zebra_read_route
;
1590 zclient
->redistribute_route_del
= ospf_zebra_read_route
;
1592 access_list_add_hook(ospf_filter_update
);
1593 access_list_delete_hook(ospf_filter_update
);
1594 prefix_list_add_hook(ospf_prefix_list_update
);
1595 prefix_list_delete_hook(ospf_prefix_list_update
);