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