]> git.proxmox.com Git - mirror_frr.git/blob - ospfd/ospfd.c
projects / mirror_frr.git / blob
? search:


eda0fd477312c2bdbb2d7839498d7406aca8e11e
[mirror_frr.git] / ospfd / ospfd.c
1 /* OSPF version 2 daemon program.
2 * Copyright (C) 1999, 2000 Toshiaki Takada
3 *
4 * This file is part of GNU Zebra.
5 *
6 * GNU Zebra is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2, or (at your option) any
9 * later version.
10 *
11 * GNU Zebra is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include <zebra.h>
22
23 #include "thread.h"
24 #include "vty.h"
25 #include "command.h"
26 #include "linklist.h"
27 #include "prefix.h"
28 #include "table.h"
29 #include "if.h"
30 #include "memory.h"
31 #include "stream.h"
32 #include "log.h"
33 #include "sockunion.h" /* for inet_aton () */
34 #include "zclient.h"
35 #include "routemap.h"
36 #include "plist.h"
37 #include "sockopt.h"
38 #include "bfd.h"
39 #include "libfrr.h"
40 #include "defaults.h"
41
42 #include "ospfd/ospfd.h"
43 #include "ospfd/ospf_network.h"
44 #include "ospfd/ospf_interface.h"
45 #include "ospfd/ospf_ism.h"
46 #include "ospfd/ospf_asbr.h"
47 #include "ospfd/ospf_lsa.h"
48 #include "ospfd/ospf_lsdb.h"
49 #include "ospfd/ospf_neighbor.h"
50 #include "ospfd/ospf_nsm.h"
51 #include "ospfd/ospf_spf.h"
52 #include "ospfd/ospf_packet.h"
53 #include "ospfd/ospf_dump.h"
54 #include "ospfd/ospf_zebra.h"
55 #include "ospfd/ospf_abr.h"
56 #include "ospfd/ospf_flood.h"
57 #include "ospfd/ospf_route.h"
58 #include "ospfd/ospf_ase.h"
59
60
61 DEFINE_QOBJ_TYPE(ospf)
62
63 /* OSPF process wide configuration. */
64 static struct ospf_master ospf_master;
65
66 /* OSPF process wide configuration pointer to export. */
67 struct ospf_master *om;
68
69 extern struct zclient *zclient;
70
71
72 static void ospf_remove_vls_through_area(struct ospf *, struct ospf_area *);
73 static void ospf_network_free(struct ospf *, struct ospf_network *);
74 static void ospf_area_free(struct ospf_area *);
75 static void ospf_network_run(struct prefix *, struct ospf_area *);
76 static void ospf_network_run_interface(struct ospf *, struct interface *,
77 struct prefix *, struct ospf_area *);
78 static void ospf_network_run_subnet(struct ospf *, struct connected *,
79 struct prefix *, struct ospf_area *);
80 static int ospf_network_match_iface(const struct connected *,
81 const struct prefix *);
82 static void ospf_finish_final(struct ospf *);
83
84 #define OSPF_EXTERNAL_LSA_ORIGINATE_DELAY 1
85
86 void ospf_router_id_update(struct ospf *ospf)
87 {
88 struct vrf *vrf = vrf_lookup_by_id(ospf->vrf_id);
89 struct in_addr router_id, router_id_old;
90 struct ospf_interface *oi;
91 struct interface *ifp;
92 struct listnode *node;
93 int type;
94
95 if (!ospf->oi_running) {
96 if (IS_DEBUG_OSPF_EVENT)
97 zlog_debug(
98 "Router ospf not configured -- Router-ID update postponed");
99 return;
100 }
101
102 if (IS_DEBUG_OSPF_EVENT)
103 zlog_debug("Router-ID[OLD:%s]: Update",
104 inet_ntoa(ospf->router_id));
105
106 router_id_old = ospf->router_id;
107
108 /* Select the router ID based on these priorities:
109 1. Statically assigned router ID is always the first choice.
110 2. If there is no statically assigned router ID, then try to stick
111 with the most recent value, since changing router ID's is very
112 disruptive.
113 3. Last choice: just go with whatever the zebra daemon recommends.
114 */
115 if (ospf->router_id_static.s_addr != 0)
116 router_id = ospf->router_id_static;
117 else if (ospf->router_id.s_addr != 0)
118 router_id = ospf->router_id;
119 else
120 router_id = ospf->router_id_zebra;
121
122 if (IS_DEBUG_OSPF_EVENT)
123 zlog_debug("Router-ID[OLD:%s]: Update to %s",
124 inet_ntoa(ospf->router_id),
125 inet_ntoa(router_id));
126
127 if (!IPV4_ADDR_SAME(&router_id_old, &router_id)) {
128
129 for (ALL_LIST_ELEMENTS_RO(ospf->oiflist, node, oi)) {
130 /* Some nbrs are identified by router_id, these needs
131 * to be rebuilt. Possible optimization would be to do
132 * oi->nbr_self->router_id = router_id for
133 * !(virtual | ptop) links
134 */
135 ospf_nbr_self_reset(oi, router_id);
136 }
137
138 /* If AS-external-LSA is queued, then flush those LSAs. */
139 if (router_id_old.s_addr == 0 && ospf->external_origin) {
140 /* Originate each redistributed external route. */
141 for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
142 if (ospf->external_origin & (1 << type))
143 thread_add_event(
144 master,
145 ospf_external_lsa_originate_timer,
146 ospf, type, NULL);
147 /* Originate Deafult. */
148 if (ospf->external_origin & (1 << ZEBRA_ROUTE_MAX))
149 thread_add_event(master,
150 ospf_default_originate_timer,
151 ospf, 0, NULL);
152
153 ospf->external_origin = 0;
154 }
155
156 /* Flush (inline) all external LSAs based on the OSPF_LSA_SELF
157 * flag */
158 if (ospf->lsdb) {
159 struct route_node *rn;
160 struct ospf_lsa *lsa;
161
162 LSDB_LOOP(EXTERNAL_LSDB(ospf), rn, lsa)
163 if (IS_LSA_SELF(lsa))
164 ospf_lsa_flush_schedule(ospf, lsa);
165 }
166
167 ospf->router_id = router_id;
168 if (IS_DEBUG_OSPF_EVENT)
169 zlog_debug("Router-ID[NEW:%s]: Update",
170 inet_ntoa(ospf->router_id));
171
172 /* Flush (inline) all external LSAs which now match the new
173 router-id,
174 need to adjust the OSPF_LSA_SELF flag, so the flush doesnt
175 hit
176 asserts in ospf_refresher_unregister_lsa(). This step is
177 needed
178 because the current quagga code does look-up for
179 self-originated LSAs
180 based on the self router-id alone but expects OSPF_LSA_SELF
181 to be
182 properly set */
183 if (ospf->lsdb) {
184 struct route_node *rn;
185 struct ospf_lsa *lsa;
186
187 LSDB_LOOP (EXTERNAL_LSDB(ospf), rn, lsa) {
188 /* AdvRouter and Router ID is the same. */
189 if (IPV4_ADDR_SAME(&lsa->data->adv_router,
190 &ospf->router_id)) {
191 SET_FLAG(lsa->flags,
192 OSPF_LSA_SELF_CHECKED);
193 SET_FLAG(lsa->flags, OSPF_LSA_SELF);
194 ospf_lsa_flush_schedule(ospf, lsa);
195 }
196 }
197 }
198
199 /* Originate each redistributed external route. */
200 for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
201 thread_add_event(master,
202 ospf_external_lsa_originate_timer,
203 ospf, type, NULL);
204 thread_add_event(master, ospf_default_originate_timer, ospf, 0,
205 NULL);
206
207 /* update router-lsa's for each area */
208 ospf_router_lsa_update(ospf);
209
210 /* update ospf_interface's */
211 FOR_ALL_INTERFACES (vrf, ifp)
212 ospf_if_update(ospf, ifp);
213 }
214 }
215
216 /* For OSPF area sort by area id. */
217 static int ospf_area_id_cmp(struct ospf_area *a1, struct ospf_area *a2)
218 {
219 if (ntohl(a1->area_id.s_addr) > ntohl(a2->area_id.s_addr))
220 return 1;
221 if (ntohl(a1->area_id.s_addr) < ntohl(a2->area_id.s_addr))
222 return -1;
223 return 0;
224 }
225
226 /* Allocate new ospf structure. */
227 static struct ospf *ospf_new(u_short instance, const char *name)
228 {
229 int i;
230 struct vrf *vrf = NULL;
231
232 struct ospf *new = XCALLOC(MTYPE_OSPF_TOP, sizeof(struct ospf));
233
234 new->instance = instance;
235 new->router_id.s_addr = htonl(0);
236 new->router_id_static.s_addr = htonl(0);
237
238 if (name) {
239 new->vrf_id = VRF_UNKNOWN;
240 /* Freed in ospf_finish_final */
241 new->name = XSTRDUP(MTYPE_OSPF_TOP, name);
242 vrf = vrf_lookup_by_name(new->name);
243 if (IS_DEBUG_OSPF_EVENT)
244 zlog_debug("%s: Create new ospf instance with vrf_name %s vrf_id %u",
245 __PRETTY_FUNCTION__, name, new->vrf_id);
246 if (vrf)
247 ospf_vrf_link(new, vrf);
248 } else {
249 new->vrf_id = VRF_DEFAULT;
250 vrf = vrf_lookup_by_id(VRF_DEFAULT);
251 ospf_vrf_link(new, vrf);
252 }
253 ospf_zebra_vrf_register(new);
254
255 new->abr_type = OSPF_ABR_DEFAULT;
256 new->oiflist = list_new();
257 new->vlinks = list_new();
258 new->areas = list_new();
259 new->areas->cmp = (int (*)(void *, void *))ospf_area_id_cmp;
260 new->networks = route_table_init();
261 new->nbr_nbma = route_table_init();
262
263 new->lsdb = ospf_lsdb_new();
264
265 new->default_originate = DEFAULT_ORIGINATE_NONE;
266
267 new->passive_interface_default = OSPF_IF_ACTIVE;
268
269 new->new_external_route = route_table_init();
270 new->old_external_route = route_table_init();
271 new->external_lsas = route_table_init();
272
273 new->stub_router_startup_time = OSPF_STUB_ROUTER_UNCONFIGURED;
274 new->stub_router_shutdown_time = OSPF_STUB_ROUTER_UNCONFIGURED;
275 new->stub_router_admin_set = OSPF_STUB_ROUTER_ADMINISTRATIVE_UNSET;
276
277 /* Distribute parameter init. */
278 for (i = 0; i <= ZEBRA_ROUTE_MAX; i++) {
279 new->dtag[i] = 0;
280 }
281 new->default_metric = -1;
282 new->ref_bandwidth = OSPF_DEFAULT_REF_BANDWIDTH;
283
284 /* LSA timers */
285 new->min_ls_interval = OSPF_MIN_LS_INTERVAL;
286 new->min_ls_arrival = OSPF_MIN_LS_ARRIVAL;
287
288 /* SPF timer value init. */
289 new->spf_delay = OSPF_SPF_DELAY_DEFAULT;
290 new->spf_holdtime = OSPF_SPF_HOLDTIME_DEFAULT;
291 new->spf_max_holdtime = OSPF_SPF_MAX_HOLDTIME_DEFAULT;
292 new->spf_hold_multiplier = 1;
293
294 /* MaxAge init. */
295 new->maxage_delay = OSPF_LSA_MAXAGE_REMOVE_DELAY_DEFAULT;
296 new->maxage_lsa = route_table_init();
297 new->t_maxage_walker = NULL;
298 thread_add_timer(master, ospf_lsa_maxage_walker, new,
299 OSPF_LSA_MAXAGE_CHECK_INTERVAL, &new->t_maxage_walker);
300
301 /* Distance table init. */
302 new->distance_table = route_table_init();
303
304 new->lsa_refresh_queue.index = 0;
305 new->lsa_refresh_interval = OSPF_LSA_REFRESH_INTERVAL_DEFAULT;
306 new->t_lsa_refresher = NULL;
307 thread_add_timer(master, ospf_lsa_refresh_walker, new,
308 new->lsa_refresh_interval, &new->t_lsa_refresher);
309 new->lsa_refresher_started = monotime(NULL);
310
311 if ((ospf_sock_init(new)) < 0) {
312 zlog_err(
313 "ospf_new: fatal error: ospf_sock_init was unable to open "
314 "a socket");
315 exit(1);
316 }
317 if ((new->ibuf = stream_new(OSPF_MAX_PACKET_SIZE + 1)) == NULL) {
318 zlog_err(
319 "ospf_new: fatal error: stream_new(%u) failed allocating ibuf",
320 OSPF_MAX_PACKET_SIZE + 1);
321 exit(1);
322 }
323 new->t_read = NULL;
324 thread_add_read(master, ospf_read, new, new->fd, &new->t_read);
325 new->oi_write_q = list_new();
326 new->write_oi_count = OSPF_WRITE_INTERFACE_COUNT_DEFAULT;
327
328 /* Enable "log-adjacency-changes" */
329 #if DFLT_OSPF_LOG_ADJACENCY_CHANGES
330 SET_FLAG(new->config, OSPF_LOG_ADJACENCY_CHANGES);
331 #endif
332
333 QOBJ_REG(new, ospf);
334
335 return new;
336 }
337
338 struct ospf *ospf_lookup_instance(u_short instance)
339 {
340 struct ospf *ospf;
341 struct listnode *node, *nnode;
342
343 if (listcount(om->ospf) == 0)
344 return NULL;
345
346 for (ALL_LIST_ELEMENTS(om->ospf, node, nnode, ospf))
347 if ((ospf->instance == 0 && instance == 0)
348 || (ospf->instance && instance
349 && ospf->instance == instance))
350 return ospf;
351
352 return NULL;
353 }
354
355 static int ospf_is_ready(struct ospf *ospf)
356 {
357 /* OSPF must be on and Router-ID must be configured. */
358 if (!ospf || ospf->router_id.s_addr == 0)
359 return 0;
360
361 return 1;
362 }
363
364 static void ospf_add(struct ospf *ospf)
365 {
366 listnode_add(om->ospf, ospf);
367 }
368
369 static void ospf_delete(struct ospf *ospf)
370 {
371 listnode_delete(om->ospf, ospf);
372 }
373
374 struct ospf *ospf_lookup_by_inst_name(u_short instance, const char *name)
375 {
376 struct ospf *ospf = NULL;
377 struct listnode *node, *nnode;
378
379 for (ALL_LIST_ELEMENTS(om->ospf, node, nnode, ospf)) {
380 if ((ospf->instance == instance) &&
381 ((ospf->name == NULL && name == NULL) ||
382 (ospf->name && name && strcmp(ospf->name, name) == 0)))
383 return ospf;
384 }
385 return NULL;
386 }
387
388 struct ospf *ospf_get(u_short instance, const char *name)
389 {
390 struct ospf *ospf;
391
392 /* vrf name provided call inst and name based api
393 * in case of no name pass default ospf instance */
394 if (name)
395 ospf = ospf_lookup_by_inst_name(instance, name);
396 else
397 ospf = ospf_lookup_by_vrf_id(VRF_DEFAULT);
398
399 if (ospf == NULL) {
400 ospf = ospf_new(instance, name);
401 ospf_add(ospf);
402
403 if (ospf->router_id_static.s_addr == 0)
404 ospf_router_id_update(ospf);
405
406 ospf_opaque_type11_lsa_init(ospf);
407 }
408
409 return ospf;
410 }
411
412 struct ospf *ospf_get_instance(u_short instance)
413 {
414 struct ospf *ospf;
415
416 ospf = ospf_lookup_instance(instance);
417 if (ospf == NULL) {
418 ospf = ospf_new(instance, NULL /* VRF_DEFAULT*/);
419 ospf_add(ospf);
420
421 if (ospf->router_id_static.s_addr == 0) {
422 if (vrf_lookup_by_id(ospf->vrf_id))
423 ospf_router_id_update(ospf);
424 else {
425 if (IS_DEBUG_OSPF_EVENT)
426 zlog_debug("%s: ospf VRF (id %d) is not active yet, skip router id update"
427 , __PRETTY_FUNCTION__,
428 ospf->vrf_id);
429 }
430 ospf_router_id_update(ospf);
431 }
432
433 ospf_opaque_type11_lsa_init(ospf);
434 }
435
436 return ospf;
437 }
438
439 struct ospf *ospf_lookup_by_vrf_id(vrf_id_t vrf_id)
440 {
441 struct vrf *vrf = NULL;
442
443 vrf = vrf_lookup_by_id(vrf_id);
444 if (!vrf)
445 return NULL;
446 return (vrf->info) ? (struct ospf *)vrf->info : NULL;
447
448 }
449
450 /* It should only be used when processing incoming info update from zebra.
451 * Other situations, it is not sufficient to lookup the ospf instance by
452 * vrf_name only without using the instance number.
453 */
454 static struct ospf *ospf_lookup_by_name(const char *vrf_name)
455 {
456 struct ospf *ospf = NULL;
457 struct listnode *node, *nnode;
458
459 for (ALL_LIST_ELEMENTS(om->ospf, node, nnode, ospf))
460 if ((ospf->name == NULL && vrf_name == NULL)
461 || (ospf->name && vrf_name &&
462 strcmp(ospf->name, vrf_name) == 0))
463 return ospf;
464 return NULL;
465 }
466
467 /* Handle the second half of deferred shutdown. This is called either
468 * from the deferred-shutdown timer thread, or directly through
469 * ospf_deferred_shutdown_check.
470 *
471 * Function is to cleanup G-R state, if required then call ospf_finish_final
472 * to complete shutdown of this ospf instance. Possibly exit if the
473 * whole process is being shutdown and this was the last OSPF instance.
474 */
475 static void ospf_deferred_shutdown_finish(struct ospf *ospf)
476 {
477 ospf->stub_router_shutdown_time = OSPF_STUB_ROUTER_UNCONFIGURED;
478 OSPF_TIMER_OFF(ospf->t_deferred_shutdown);
479
480 ospf_finish_final(ospf);
481
482 /* *ospf is now invalid */
483
484 /* ospfd being shut-down? If so, was this the last ospf instance? */
485 if (CHECK_FLAG(om->options, OSPF_MASTER_SHUTDOWN)
486 && (listcount(om->ospf) == 0)) {
487 exit(0);
488 }
489
490 return;
491 }
492
493 /* Timer thread for G-R */
494 static int ospf_deferred_shutdown_timer(struct thread *t)
495 {
496 struct ospf *ospf = THREAD_ARG(t);
497
498 ospf_deferred_shutdown_finish(ospf);
499
500 return 0;
501 }
502
503 /* Check whether deferred-shutdown must be scheduled, otherwise call
504 * down directly into second-half of instance shutdown.
505 */
506 static void ospf_deferred_shutdown_check(struct ospf *ospf)
507 {
508 unsigned long timeout;
509 struct listnode *ln;
510 struct ospf_area *area;
511
512 /* deferred shutdown already running? */
513 if (ospf->t_deferred_shutdown)
514 return;
515
516 /* Should we try push out max-metric LSAs? */
517 if (ospf->stub_router_shutdown_time != OSPF_STUB_ROUTER_UNCONFIGURED) {
518 for (ALL_LIST_ELEMENTS_RO(ospf->areas, ln, area)) {
519 SET_FLAG(area->stub_router_state,
520 OSPF_AREA_ADMIN_STUB_ROUTED);
521
522 if (!CHECK_FLAG(area->stub_router_state,
523 OSPF_AREA_IS_STUB_ROUTED))
524 ospf_router_lsa_update_area(area);
525 }
526 timeout = ospf->stub_router_shutdown_time;
527 } else {
528 /* No timer needed */
529 ospf_deferred_shutdown_finish(ospf);
530 return;
531 }
532
533 OSPF_TIMER_ON(ospf->t_deferred_shutdown, ospf_deferred_shutdown_timer,
534 timeout);
535 return;
536 }
537
538 /* Shut down the entire process */
539 void ospf_terminate(void)
540 {
541 struct ospf *ospf;
542 struct listnode *node, *nnode;
543
544 /* shutdown already in progress */
545 if (CHECK_FLAG(om->options, OSPF_MASTER_SHUTDOWN))
546 return;
547
548 SET_FLAG(om->options, OSPF_MASTER_SHUTDOWN);
549
550 /* exit immediately if OSPF not actually running */
551 if (listcount(om->ospf) == 0)
552 exit(0);
553
554 bfd_gbl_exit();
555 for (ALL_LIST_ELEMENTS(om->ospf, node, nnode, ospf))
556 ospf_finish(ospf);
557
558 /* Cleanup route maps */
559 route_map_add_hook(NULL);
560 route_map_delete_hook(NULL);
561 route_map_event_hook(NULL);
562 route_map_finish();
563
564 /* reverse prefix_list_init */
565 prefix_list_add_hook(NULL);
566 prefix_list_delete_hook(NULL);
567 prefix_list_reset();
568
569 /* Cleanup vrf info */
570 ospf_vrf_terminate();
571
572 /* Deliberately go back up, hopefully to thread scheduler, as
573 * One or more ospf_finish()'s may have deferred shutdown to a timer
574 * thread
575 */
576 zclient_stop(zclient);
577 zclient_free(zclient);
578
579 frr_fini();
580 }
581
582 void ospf_finish(struct ospf *ospf)
583 {
584 /* let deferred shutdown decide */
585 ospf_deferred_shutdown_check(ospf);
586
587 /* if ospf_deferred_shutdown returns, then ospf_finish_final is
588 * deferred to expiry of G-S timer thread. Return back up, hopefully
589 * to thread scheduler.
590 */
591 return;
592 }
593
594 /* Final cleanup of ospf instance */
595 static void ospf_finish_final(struct ospf *ospf)
596 {
597 struct vrf *vrf = vrf_lookup_by_id(ospf->vrf_id);
598 struct route_node *rn;
599 struct ospf_nbr_nbma *nbr_nbma;
600 struct ospf_lsa *lsa;
601 struct interface *ifp;
602 struct ospf_interface *oi;
603 struct ospf_area *area;
604 struct ospf_vl_data *vl_data;
605 struct listnode *node, *nnode;
606 int i;
607 u_short instance = 0;
608
609 QOBJ_UNREG(ospf);
610
611 ospf_opaque_type11_lsa_term(ospf);
612
613 ospf_opaque_finish();
614
615 ospf_flush_self_originated_lsas_now(ospf);
616
617 /* Unregister redistribution */
618 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
619 struct list *red_list;
620 struct ospf_redist *red;
621
622 red_list = ospf->redist[i];
623 if (!red_list)
624 continue;
625
626 for (ALL_LIST_ELEMENTS(red_list, node, nnode, red))
627 ospf_redistribute_unset(ospf, i, red->instance);
628 }
629 ospf_redistribute_default_unset(ospf);
630
631 for (ALL_LIST_ELEMENTS(ospf->areas, node, nnode, area))
632 ospf_remove_vls_through_area(ospf, area);
633
634 for (ALL_LIST_ELEMENTS(ospf->vlinks, node, nnode, vl_data))
635 ospf_vl_delete(ospf, vl_data);
636
637 list_delete_and_null(&ospf->vlinks);
638
639 /* Remove any ospf interface config params */
640 FOR_ALL_INTERFACES (vrf, ifp) {
641 struct ospf_if_params *params;
642
643 params = IF_DEF_PARAMS(ifp);
644 if (OSPF_IF_PARAM_CONFIGURED(params, if_area))
645 UNSET_IF_PARAM(params, if_area);
646 }
647
648 /* Reset interface. */
649 for (ALL_LIST_ELEMENTS(ospf->oiflist, node, nnode, oi))
650 ospf_if_free(oi);
651 list_delete_and_null(&ospf->oiflist);
652
653 /* De-Register VRF */
654 ospf_zebra_vrf_deregister(ospf);
655
656 /* Clear static neighbors */
657 for (rn = route_top(ospf->nbr_nbma); rn; rn = route_next(rn))
658 if ((nbr_nbma = rn->info)) {
659 OSPF_POLL_TIMER_OFF(nbr_nbma->t_poll);
660
661 if (nbr_nbma->nbr) {
662 nbr_nbma->nbr->nbr_nbma = NULL;
663 nbr_nbma->nbr = NULL;
664 }
665
666 if (nbr_nbma->oi) {
667 listnode_delete(nbr_nbma->oi->nbr_nbma,
668 nbr_nbma);
669 nbr_nbma->oi = NULL;
670 }
671
672 XFREE(MTYPE_OSPF_NEIGHBOR_STATIC, nbr_nbma);
673 }
674
675 route_table_finish(ospf->nbr_nbma);
676
677 /* Clear networks and Areas. */
678 for (rn = route_top(ospf->networks); rn; rn = route_next(rn)) {
679 struct ospf_network *network;
680
681 if ((network = rn->info) != NULL) {
682 ospf_network_free(ospf, network);
683 rn->info = NULL;
684 route_unlock_node(rn);
685 }
686 }
687 route_table_finish(ospf->networks);
688
689 for (ALL_LIST_ELEMENTS(ospf->areas, node, nnode, area)) {
690 listnode_delete(ospf->areas, area);
691 ospf_area_free(area);
692 }
693
694 /* Cancel all timers. */
695 OSPF_TIMER_OFF(ospf->t_external_lsa);
696 OSPF_TIMER_OFF(ospf->t_spf_calc);
697 OSPF_TIMER_OFF(ospf->t_ase_calc);
698 OSPF_TIMER_OFF(ospf->t_maxage);
699 OSPF_TIMER_OFF(ospf->t_maxage_walker);
700 OSPF_TIMER_OFF(ospf->t_abr_task);
701 OSPF_TIMER_OFF(ospf->t_asbr_check);
702 OSPF_TIMER_OFF(ospf->t_distribute_update);
703 OSPF_TIMER_OFF(ospf->t_lsa_refresher);
704 OSPF_TIMER_OFF(ospf->t_read);
705 OSPF_TIMER_OFF(ospf->t_write);
706 OSPF_TIMER_OFF(ospf->t_opaque_lsa_self);
707 OSPF_TIMER_OFF(ospf->t_sr_update);
708
709 close(ospf->fd);
710 stream_free(ospf->ibuf);
711
712 LSDB_LOOP(OPAQUE_AS_LSDB(ospf), rn, lsa)
713 ospf_discard_from_db(ospf, ospf->lsdb, lsa);
714 LSDB_LOOP(EXTERNAL_LSDB(ospf), rn, lsa)
715 ospf_discard_from_db(ospf, ospf->lsdb, lsa);
716
717 ospf_lsdb_delete_all(ospf->lsdb);
718 ospf_lsdb_free(ospf->lsdb);
719
720 for (rn = route_top(ospf->maxage_lsa); rn; rn = route_next(rn)) {
721 struct ospf_lsa *lsa;
722
723 if ((lsa = rn->info) != NULL) {
724 ospf_lsa_unlock(&lsa);
725 rn->info = NULL;
726 }
727 route_unlock_node(rn);
728 }
729 route_table_finish(ospf->maxage_lsa);
730
731 if (ospf->old_table)
732 ospf_route_table_free(ospf->old_table);
733 if (ospf->new_table) {
734 ospf_route_delete(ospf, ospf->new_table);
735 ospf_route_table_free(ospf->new_table);
736 }
737 if (ospf->old_rtrs)
738 ospf_rtrs_free(ospf->old_rtrs);
739 if (ospf->new_rtrs)
740 ospf_rtrs_free(ospf->new_rtrs);
741 if (ospf->new_external_route) {
742 ospf_route_delete(ospf, ospf->new_external_route);
743 ospf_route_table_free(ospf->new_external_route);
744 }
745 if (ospf->old_external_route) {
746 ospf_route_delete(ospf, ospf->old_external_route);
747 ospf_route_table_free(ospf->old_external_route);
748 }
749 if (ospf->external_lsas) {
750 ospf_ase_external_lsas_finish(ospf->external_lsas);
751 }
752
753 list_delete_and_null(&ospf->areas);
754 list_delete_and_null(&ospf->oi_write_q);
755
756 for (i = ZEBRA_ROUTE_SYSTEM; i <= ZEBRA_ROUTE_MAX; i++) {
757 struct list *ext_list;
758 struct listnode *node;
759 struct ospf_external *ext;
760
761 ext_list = ospf->external[i];
762 if (!ext_list)
763 continue;
764
765 for (ALL_LIST_ELEMENTS_RO(ext_list, node, ext)) {
766 if (ext->external_info)
767 for (rn = route_top(ext->external_info); rn;
768 rn = route_next(rn)) {
769 if (rn->info == NULL)
770 continue;
771
772 XFREE(MTYPE_OSPF_EXTERNAL_INFO,
773 rn->info);
774 rn->info = NULL;
775 route_unlock_node(rn);
776 }
777 }
778 }
779
780 ospf_distance_reset(ospf);
781 route_table_finish(ospf->distance_table);
782
783 if (!CHECK_FLAG(om->options, OSPF_MASTER_SHUTDOWN))
784 instance = ospf->instance;
785
786 ospf_delete(ospf);
787
788 if (ospf->name) {
789 vrf = vrf_lookup_by_name(ospf->name);
790 if (vrf)
791 ospf_vrf_unlink(ospf, vrf);
792 XFREE(MTYPE_OSPF_TOP, ospf->name);
793 } else {
794 vrf = vrf_lookup_by_id(VRF_DEFAULT);
795 if (vrf)
796 ospf_vrf_unlink(ospf, vrf);
797 }
798
799 XFREE(MTYPE_OSPF_TOP, ospf);
800
801 if (!CHECK_FLAG(om->options, OSPF_MASTER_SHUTDOWN))
802 ospf_get_instance(instance);
803 }
804
805
806 /* allocate new OSPF Area object */
807 static struct ospf_area *ospf_area_new(struct ospf *ospf,
808 struct in_addr area_id)
809 {
810 struct ospf_area *new;
811
812 /* Allocate new config_network. */
813 new = XCALLOC(MTYPE_OSPF_AREA, sizeof(struct ospf_area));
814
815 new->ospf = ospf;
816
817 new->area_id = area_id;
818 new->area_id_fmt = OSPF_AREA_ID_FMT_DOTTEDQUAD;
819
820 new->external_routing = OSPF_AREA_DEFAULT;
821 new->default_cost = 1;
822 new->auth_type = OSPF_AUTH_NULL;
823
824 /* New LSDB init. */
825 new->lsdb = ospf_lsdb_new();
826
827 /* Self-originated LSAs initialize. */
828 new->router_lsa_self = NULL;
829
830 ospf_opaque_type10_lsa_init(new);
831
832 new->oiflist = list_new();
833 new->ranges = route_table_init();
834
835 if (area_id.s_addr == OSPF_AREA_BACKBONE)
836 ospf->backbone = new;
837
838 return new;
839 }
840
841 static void ospf_area_free(struct ospf_area *area)
842 {
843 struct route_node *rn;
844 struct ospf_lsa *lsa;
845
846 ospf_opaque_type10_lsa_term(area);
847
848 /* Free LSDBs. */
849 LSDB_LOOP(ROUTER_LSDB(area), rn, lsa)
850 ospf_discard_from_db(area->ospf, area->lsdb, lsa);
851 LSDB_LOOP(NETWORK_LSDB(area), rn, lsa)
852 ospf_discard_from_db(area->ospf, area->lsdb, lsa);
853 LSDB_LOOP(SUMMARY_LSDB(area), rn, lsa)
854 ospf_discard_from_db(area->ospf, area->lsdb, lsa);
855 LSDB_LOOP(ASBR_SUMMARY_LSDB(area), rn, lsa)
856 ospf_discard_from_db(area->ospf, area->lsdb, lsa);
857
858 LSDB_LOOP(NSSA_LSDB(area), rn, lsa)
859 ospf_discard_from_db(area->ospf, area->lsdb, lsa);
860 LSDB_LOOP(OPAQUE_AREA_LSDB(area), rn, lsa)
861 ospf_discard_from_db(area->ospf, area->lsdb, lsa);
862 LSDB_LOOP(OPAQUE_LINK_LSDB(area), rn, lsa)
863 ospf_discard_from_db(area->ospf, area->lsdb, lsa);
864
865 ospf_lsdb_delete_all(area->lsdb);
866 ospf_lsdb_free(area->lsdb);
867
868 ospf_lsa_unlock(&area->router_lsa_self);
869
870 route_table_finish(area->ranges);
871 list_delete_and_null(&area->oiflist);
872
873 if (EXPORT_NAME(area))
874 free(EXPORT_NAME(area));
875
876 if (IMPORT_NAME(area))
877 free(IMPORT_NAME(area));
878
879 /* Cancel timer. */
880 OSPF_TIMER_OFF(area->t_stub_router);
881 OSPF_TIMER_OFF(area->t_opaque_lsa_self);
882
883 if (OSPF_IS_AREA_BACKBONE(area))
884 area->ospf->backbone = NULL;
885
886 XFREE(MTYPE_OSPF_AREA, area);
887 }
888
889 void ospf_area_check_free(struct ospf *ospf, struct in_addr area_id)
890 {
891 struct ospf_area *area;
892
893 area = ospf_area_lookup_by_area_id(ospf, area_id);
894 if (area && listcount(area->oiflist) == 0 && area->ranges->top == NULL
895 && area->shortcut_configured == OSPF_SHORTCUT_DEFAULT
896 && area->external_routing == OSPF_AREA_DEFAULT
897 && area->no_summary == 0 && area->default_cost == 1
898 && EXPORT_NAME(area) == NULL && IMPORT_NAME(area) == NULL
899 && area->auth_type == OSPF_AUTH_NULL) {
900 listnode_delete(ospf->areas, area);
901 ospf_area_free(area);
902 }
903 }
904
905 struct ospf_area *ospf_area_get(struct ospf *ospf, struct in_addr area_id)
906 {
907 struct ospf_area *area;
908
909 area = ospf_area_lookup_by_area_id(ospf, area_id);
910 if (!area) {
911 area = ospf_area_new(ospf, area_id);
912 listnode_add_sort(ospf->areas, area);
913 ospf_check_abr_status(ospf);
914 if (ospf->stub_router_admin_set
915 == OSPF_STUB_ROUTER_ADMINISTRATIVE_SET) {
916 SET_FLAG(area->stub_router_state,
917 OSPF_AREA_ADMIN_STUB_ROUTED);
918 }
919 }
920
921 return area;
922 }
923
924 struct ospf_area *ospf_area_lookup_by_area_id(struct ospf *ospf,
925 struct in_addr area_id)
926 {
927 struct ospf_area *area;
928 struct listnode *node;
929
930 for (ALL_LIST_ELEMENTS_RO(ospf->areas, node, area))
931 if (IPV4_ADDR_SAME(&area->area_id, &area_id))
932 return area;
933
934 return NULL;
935 }
936
937 void ospf_area_add_if(struct ospf_area *area, struct ospf_interface *oi)
938 {
939 listnode_add(area->oiflist, oi);
940 }
941
942 void ospf_area_del_if(struct ospf_area *area, struct ospf_interface *oi)
943 {
944 listnode_delete(area->oiflist, oi);
945 }
946
947
948 static void add_ospf_interface(struct connected *co, struct ospf_area *area)
949 {
950 struct ospf_interface *oi;
951
952 oi = ospf_if_new(area->ospf, co->ifp, co->address);
953 oi->connected = co;
954
955 oi->area = area;
956
957 oi->params = ospf_lookup_if_params(co->ifp, oi->address->u.prefix4);
958 oi->output_cost = ospf_if_get_output_cost(oi);
959
960 /* Relate ospf interface to ospf instance. */
961 oi->ospf = area->ospf;
962
963 /* update network type as interface flag */
964 /* If network type is specified previously,
965 skip network type setting. */
966 oi->type = IF_DEF_PARAMS(co->ifp)->type;
967
968 /* Add pseudo neighbor. */
969 ospf_nbr_self_reset(oi, oi->ospf->router_id);
970
971 ospf_area_add_if(oi->area, oi);
972
973 /*
974 * if router_id is not configured, dont bring up
975 * interfaces.
976 * ospf_router_id_update() will call ospf_if_update
977 * whenever r-id is configured instead.
978 */
979 if ((area->ospf->router_id.s_addr != 0) && if_is_operative(co->ifp))
980 ospf_if_up(oi);
981 }
982
983 static void update_redistributed(struct ospf *ospf, int add_to_ospf)
984 {
985 struct route_node *rn;
986 struct external_info *ei;
987 struct ospf_external *ext;
988
989 if (ospf_is_type_redistributed(ospf, ZEBRA_ROUTE_CONNECT, 0)) {
990 ext = ospf_external_lookup(ospf, ZEBRA_ROUTE_CONNECT, 0);
991 if ((ext) && EXTERNAL_INFO(ext)) {
992 for (rn = route_top(EXTERNAL_INFO(ext)); rn;
993 rn = route_next(rn)) {
994 ei = rn->info;
995 if (ei == NULL)
996 continue;
997
998 if (add_to_ospf) {
999 if (ospf_external_info_find_lsa(
1000 ospf, &ei->p))
1001 if (!ospf_distribute_check_connected(
1002 ospf, ei))
1003 ospf_external_lsa_flush(
1004 ospf,
1005 ei->type,
1006 &ei->p,
1007 ei->ifindex /*, ei->nexthop */);
1008 } else {
1009 if (!ospf_external_info_find_lsa(
1010 ospf, &ei->p))
1011 if (ospf_distribute_check_connected(
1012 ospf, ei))
1013 ospf_external_lsa_originate(
1014 ospf,
1015 ei);
1016 }
1017 }
1018 }
1019 }
1020 }
1021
1022 /* Config network statement related functions. */
1023 static struct ospf_network *ospf_network_new(struct in_addr area_id)
1024 {
1025 struct ospf_network *new;
1026 new = XCALLOC(MTYPE_OSPF_NETWORK, sizeof(struct ospf_network));
1027
1028 new->area_id = area_id;
1029 new->area_id_fmt = OSPF_AREA_ID_FMT_DOTTEDQUAD;
1030
1031 return new;
1032 }
1033
1034 static void ospf_network_free(struct ospf *ospf, struct ospf_network *network)
1035 {
1036 ospf_area_check_free(ospf, network->area_id);
1037 ospf_schedule_abr_task(ospf);
1038 XFREE(MTYPE_OSPF_NETWORK, network);
1039 }
1040
1041 int ospf_network_set(struct ospf *ospf, struct prefix_ipv4 *p,
1042 struct in_addr area_id, int df)
1043 {
1044 struct ospf_network *network;
1045 struct ospf_area *area;
1046 struct route_node *rn;
1047
1048 rn = route_node_get(ospf->networks, (struct prefix *)p);
1049 if (rn->info) {
1050 network = rn->info;
1051 route_unlock_node(rn);
1052
1053 if (IPV4_ADDR_SAME(&area_id, &network->area_id)) {
1054 return 1;
1055 } else {
1056 /* There is already same network statement. */
1057 return 0;
1058 }
1059 }
1060
1061 rn->info = network = ospf_network_new(area_id);
1062 network->area_id_fmt = df;
1063 area = ospf_area_get(ospf, area_id);
1064 ospf_area_display_format_set(ospf, area, df);
1065
1066 /* Run network config now. */
1067 ospf_network_run((struct prefix *)p, area);
1068
1069 /* Update connected redistribute. */
1070 update_redistributed(ospf, 1); /* interfaces possibly added */
1071
1072 ospf_area_check_free(ospf, area_id);
1073
1074 return 1;
1075 }
1076
1077 int ospf_network_unset(struct ospf *ospf, struct prefix_ipv4 *p,
1078 struct in_addr area_id)
1079 {
1080 struct route_node *rn;
1081 struct ospf_network *network;
1082 struct listnode *node, *nnode;
1083 struct ospf_interface *oi;
1084
1085 rn = route_node_lookup(ospf->networks, (struct prefix *)p);
1086 if (rn == NULL)
1087 return 0;
1088
1089 network = rn->info;
1090 route_unlock_node(rn);
1091 if (!IPV4_ADDR_SAME(&area_id, &network->area_id))
1092 return 0;
1093
1094 ospf_network_free(ospf, rn->info);
1095 rn->info = NULL;
1096 route_unlock_node(rn); /* initial reference */
1097
1098 /* Find interfaces that are not configured already. */
1099 for (ALL_LIST_ELEMENTS(ospf->oiflist, node, nnode, oi)) {
1100
1101 if (oi->type == OSPF_IFTYPE_VIRTUALLINK)
1102 continue;
1103
1104 ospf_network_run_subnet(ospf, oi->connected, NULL, NULL);
1105 }
1106
1107 /* Update connected redistribute. */
1108 update_redistributed(ospf, 0); /* interfaces possibly removed */
1109 ospf_area_check_free(ospf, area_id);
1110
1111 return 1;
1112 }
1113
1114 /* Ensure there's an OSPF instance, as "ip ospf area" enabled OSPF means
1115 * there might not be any 'router ospf' config.
1116 *
1117 * Otherwise, doesn't do anything different to ospf_if_update for now
1118 */
1119 void ospf_interface_area_set(struct ospf *ospf, struct interface *ifp)
1120 {
1121 if (!ospf)
1122 return;
1123
1124 ospf_if_update(ospf, ifp);
1125 /* if_update does a update_redistributed */
1126
1127 return;
1128 }
1129
1130 void ospf_interface_area_unset(struct ospf *ospf, struct interface *ifp)
1131 {
1132 struct route_node *rn_oi;
1133
1134 if (!ospf)
1135 return; /* Ospf not ready yet */
1136
1137 /* Find interfaces that may need to be removed. */
1138 for (rn_oi = route_top(IF_OIFS(ifp)); rn_oi;
1139 rn_oi = route_next(rn_oi)) {
1140 struct ospf_interface *oi = NULL;
1141
1142 if ((oi = rn_oi->info) == NULL)
1143 continue;
1144
1145 if (oi->type == OSPF_IFTYPE_VIRTUALLINK)
1146 continue;
1147
1148 ospf_network_run_subnet(ospf, oi->connected, NULL, NULL);
1149 }
1150
1151 /* Update connected redistribute. */
1152 update_redistributed(ospf, 0); /* interfaces possibly removed */
1153 }
1154
1155 /* Check whether interface matches given network
1156 * returns: 1, true. 0, false
1157 */
1158 static int ospf_network_match_iface(const struct connected *co,
1159 const struct prefix *net)
1160 {
1161 /* new approach: more elegant and conceptually clean */
1162 return prefix_match_network_statement(net, CONNECTED_PREFIX(co));
1163 }
1164
1165 static void ospf_update_interface_area(struct connected *co,
1166 struct ospf_area *area)
1167 {
1168 struct ospf_interface *oi = ospf_if_table_lookup(co->ifp, co->address);
1169
1170 /* nothing to be done case */
1171 if (oi && oi->area == area) {
1172 return;
1173 }
1174
1175 if (oi)
1176 ospf_if_free(oi);
1177
1178 add_ospf_interface(co, area);
1179 }
1180
1181 /* Run OSPF for the given subnet, taking into account the following
1182 * possible sources of area configuration, in the given order of preference:
1183 *
1184 * - Whether there is interface+address specific area configuration
1185 * - Whether there is a default area for the interface
1186 * - Whether there is an area given as a parameter.
1187 * - If no specific network prefix/area is supplied, whether there's
1188 * a matching network configured.
1189 */
1190 static void ospf_network_run_subnet(struct ospf *ospf, struct connected *co,
1191 struct prefix *p,
1192 struct ospf_area *given_area)
1193 {
1194 struct ospf_interface *oi;
1195 struct ospf_if_params *params;
1196 struct ospf_area *area = NULL;
1197 struct route_node *rn;
1198 int configed = 0;
1199
1200 if (CHECK_FLAG(co->flags, ZEBRA_IFA_SECONDARY))
1201 return;
1202
1203 if (co->address->family != AF_INET)
1204 return;
1205
1206 /* Try determine the appropriate area for this interface + address
1207 * Start by checking interface config
1208 */
1209 params = ospf_lookup_if_params(co->ifp, co->address->u.prefix4);
1210 if (params && OSPF_IF_PARAM_CONFIGURED(params, if_area))
1211 area = ospf_area_get(ospf, params->if_area);
1212 else {
1213 params = IF_DEF_PARAMS(co->ifp);
1214 if (OSPF_IF_PARAM_CONFIGURED(params, if_area))
1215 area = ospf_area_get(ospf, params->if_area);
1216 }
1217
1218 /* If we've found an interface and/or addr specific area, then we're
1219 * done
1220 */
1221 if (area) {
1222 ospf_update_interface_area(co, area);
1223 return;
1224 }
1225
1226 /* Otherwise, only remaining possibility is a matching network statement
1227 */
1228 if (p) {
1229 assert(given_area != NULL);
1230
1231 /* Which either was supplied as a parameter.. (e.g. cause a new
1232 * network/area was just added)..
1233 */
1234 if (p->family == co->address->family
1235 && ospf_network_match_iface(co, p))
1236 ospf_update_interface_area(co, given_area);
1237
1238 return;
1239 }
1240
1241 /* Else we have to search the existing network/area config to see
1242 * if any match..
1243 */
1244 for (rn = route_top(ospf->networks); rn; rn = route_next(rn))
1245 if (rn->info != NULL && ospf_network_match_iface(co, &rn->p)) {
1246 struct ospf_network *network =
1247 (struct ospf_network *)rn->info;
1248 area = ospf_area_get(ospf, network->area_id);
1249 ospf_update_interface_area(co, area);
1250 configed = 1;
1251 }
1252
1253 /* If the subnet isn't in any area, deconfigure */
1254 if (!configed && (oi = ospf_if_table_lookup(co->ifp, co->address)))
1255 ospf_if_free(oi);
1256 }
1257
1258 static void ospf_network_run_interface(struct ospf *ospf, struct interface *ifp,
1259 struct prefix *p,
1260 struct ospf_area *given_area)
1261 {
1262 struct listnode *cnode;
1263 struct connected *co;
1264
1265 if (memcmp(ifp->name, "VLINK", 5) == 0)
1266 return;
1267
1268 /* Network prefix without area is nonsensical */
1269 if (p)
1270 assert(given_area != NULL);
1271
1272 /* if interface prefix is match specified prefix,
1273 then create socket and join multicast group. */
1274 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, co))
1275 ospf_network_run_subnet(ospf, co, p, given_area);
1276 }
1277
1278 static void ospf_network_run(struct prefix *p, struct ospf_area *area)
1279 {
1280 struct vrf *vrf = vrf_lookup_by_id(area->ospf->vrf_id);
1281 struct interface *ifp;
1282
1283 /* Schedule Router ID Update. */
1284 if (area->ospf->router_id.s_addr == 0)
1285 ospf_router_id_update(area->ospf);
1286
1287 /* Get target interface. */
1288 FOR_ALL_INTERFACES (vrf, ifp)
1289 ospf_network_run_interface(area->ospf, ifp, p, area);
1290 }
1291
1292 void ospf_ls_upd_queue_empty(struct ospf_interface *oi)
1293 {
1294 struct route_node *rn;
1295 struct listnode *node, *nnode;
1296 struct list *lst;
1297 struct ospf_lsa *lsa;
1298
1299 /* empty ls update queue */
1300 for (rn = route_top(oi->ls_upd_queue); rn; rn = route_next(rn))
1301 if ((lst = (struct list *)rn->info)) {
1302 for (ALL_LIST_ELEMENTS(lst, node, nnode, lsa))
1303 ospf_lsa_unlock(&lsa); /* oi->ls_upd_queue */
1304 list_delete_and_null(&lst);
1305 rn->info = NULL;
1306 }
1307
1308 /* remove update event */
1309 if (oi->t_ls_upd_event) {
1310 thread_cancel(oi->t_ls_upd_event);
1311 oi->t_ls_upd_event = NULL;
1312 }
1313 }
1314
1315 void ospf_if_update(struct ospf *ospf, struct interface *ifp)
1316 {
1317
1318 if (!ospf)
1319 return;
1320
1321 if (IS_DEBUG_OSPF_EVENT)
1322 zlog_debug("%s: interface %s ifp->vrf_id %u ospf vrf %s vrf_id %u router_id %s",
1323 __PRETTY_FUNCTION__, ifp->name, ifp->vrf_id,
1324 ospf_vrf_id_to_name(ospf->vrf_id), ospf->vrf_id,
1325 inet_ntoa(ospf->router_id));
1326
1327 /* OSPF must be ready. */
1328 if (!ospf_is_ready(ospf))
1329 return;
1330
1331 ospf_network_run_interface(ospf, ifp, NULL, NULL);
1332
1333 /* Update connected redistribute. */
1334 update_redistributed(ospf, 1);
1335 }
1336
1337 void ospf_remove_vls_through_area(struct ospf *ospf, struct ospf_area *area)
1338 {
1339 struct listnode *node, *nnode;
1340 struct ospf_vl_data *vl_data;
1341
1342 for (ALL_LIST_ELEMENTS(ospf->vlinks, node, nnode, vl_data))
1343 if (IPV4_ADDR_SAME(&vl_data->vl_area_id, &area->area_id))
1344 ospf_vl_delete(ospf, vl_data);
1345 }
1346
1347
1348 static const struct message ospf_area_type_msg[] = {
1349 {OSPF_AREA_DEFAULT, "Default"},
1350 {OSPF_AREA_STUB, "Stub"},
1351 {OSPF_AREA_NSSA, "NSSA"},
1352 {0}};
1353
1354 static void ospf_area_type_set(struct ospf_area *area, int type)
1355 {
1356 struct listnode *node;
1357 struct ospf_interface *oi;
1358
1359 if (area->external_routing == type) {
1360 if (IS_DEBUG_OSPF_EVENT)
1361 zlog_debug("Area[%s]: Types are the same, ignored.",
1362 inet_ntoa(area->area_id));
1363 return;
1364 }
1365
1366 area->external_routing = type;
1367
1368 if (IS_DEBUG_OSPF_EVENT)
1369 zlog_debug("Area[%s]: Configured as %s",
1370 inet_ntoa(area->area_id),
1371 lookup_msg(ospf_area_type_msg, type, NULL));
1372
1373 switch (area->external_routing) {
1374 case OSPF_AREA_DEFAULT:
1375 for (ALL_LIST_ELEMENTS_RO(area->oiflist, node, oi))
1376 if (oi->nbr_self != NULL) {
1377 UNSET_FLAG(oi->nbr_self->options,
1378 OSPF_OPTION_NP);
1379 SET_FLAG(oi->nbr_self->options, OSPF_OPTION_E);
1380 }
1381 break;
1382 case OSPF_AREA_STUB:
1383 for (ALL_LIST_ELEMENTS_RO(area->oiflist, node, oi))
1384 if (oi->nbr_self != NULL) {
1385 if (IS_DEBUG_OSPF_EVENT)
1386 zlog_debug(
1387 "setting options on %s accordingly",
1388 IF_NAME(oi));
1389 UNSET_FLAG(oi->nbr_self->options,
1390 OSPF_OPTION_NP);
1391 UNSET_FLAG(oi->nbr_self->options,
1392 OSPF_OPTION_E);
1393 if (IS_DEBUG_OSPF_EVENT)
1394 zlog_debug("options set on %s: %x",
1395 IF_NAME(oi), OPTIONS(oi));
1396 }
1397 break;
1398 case OSPF_AREA_NSSA:
1399 for (ALL_LIST_ELEMENTS_RO(area->oiflist, node, oi))
1400 if (oi->nbr_self != NULL) {
1401 zlog_debug(
1402 "setting nssa options on %s accordingly",
1403 IF_NAME(oi));
1404 UNSET_FLAG(oi->nbr_self->options,
1405 OSPF_OPTION_E);
1406 SET_FLAG(oi->nbr_self->options, OSPF_OPTION_NP);
1407 zlog_debug("options set on %s: %x", IF_NAME(oi),
1408 OPTIONS(oi));
1409 }
1410 break;
1411 default:
1412 break;
1413 }
1414
1415 ospf_router_lsa_update_area(area);
1416 ospf_schedule_abr_task(area->ospf);
1417 }
1418
1419 int ospf_area_shortcut_set(struct ospf *ospf, struct ospf_area *area, int mode)
1420 {
1421 if (area->shortcut_configured == mode)
1422 return 0;
1423
1424 area->shortcut_configured = mode;
1425 ospf_router_lsa_update_area(area);
1426 ospf_schedule_abr_task(ospf);
1427
1428 ospf_area_check_free(ospf, area->area_id);
1429
1430 return 1;
1431 }
1432
1433 int ospf_area_shortcut_unset(struct ospf *ospf, struct ospf_area *area)
1434 {
1435 area->shortcut_configured = OSPF_SHORTCUT_DEFAULT;
1436 ospf_router_lsa_update_area(area);
1437 ospf_area_check_free(ospf, area->area_id);
1438 ospf_schedule_abr_task(ospf);
1439
1440 return 1;
1441 }
1442
1443 static int ospf_area_vlink_count(struct ospf *ospf, struct ospf_area *area)
1444 {
1445 struct ospf_vl_data *vl;
1446 struct listnode *node;
1447 int count = 0;
1448
1449 for (ALL_LIST_ELEMENTS_RO(ospf->vlinks, node, vl))
1450 if (IPV4_ADDR_SAME(&vl->vl_area_id, &area->area_id))
1451 count++;
1452
1453 return count;
1454 }
1455
1456 int ospf_area_display_format_set(struct ospf *ospf, struct ospf_area *area,
1457 int df)
1458 {
1459 area->area_id_fmt = df;
1460
1461 return 1;
1462 }
1463
1464 int ospf_area_stub_set(struct ospf *ospf, struct in_addr area_id)
1465 {
1466 struct ospf_area *area;
1467
1468 area = ospf_area_get(ospf, area_id);
1469 if (ospf_area_vlink_count(ospf, area))
1470 return 0;
1471
1472 if (area->external_routing != OSPF_AREA_STUB)
1473 ospf_area_type_set(area, OSPF_AREA_STUB);
1474
1475 return 1;
1476 }
1477
1478 int ospf_area_stub_unset(struct ospf *ospf, struct in_addr area_id)
1479 {
1480 struct ospf_area *area;
1481
1482 area = ospf_area_lookup_by_area_id(ospf, area_id);
1483 if (area == NULL)
1484 return 1;
1485
1486 if (area->external_routing == OSPF_AREA_STUB)
1487 ospf_area_type_set(area, OSPF_AREA_DEFAULT);
1488
1489 ospf_area_check_free(ospf, area_id);
1490
1491 return 1;
1492 }
1493
1494 int ospf_area_no_summary_set(struct ospf *ospf, struct in_addr area_id)
1495 {
1496 struct ospf_area *area;
1497
1498 area = ospf_area_get(ospf, area_id);
1499 area->no_summary = 1;
1500
1501 return 1;
1502 }
1503
1504 int ospf_area_no_summary_unset(struct ospf *ospf, struct in_addr area_id)
1505 {
1506 struct ospf_area *area;
1507
1508 area = ospf_area_lookup_by_area_id(ospf, area_id);
1509 if (area == NULL)
1510 return 0;
1511
1512 area->no_summary = 0;
1513 ospf_area_check_free(ospf, area_id);
1514
1515 return 1;
1516 }
1517
1518 int ospf_area_nssa_no_summary_set(struct ospf *ospf, struct in_addr area_id)
1519 {
1520 struct ospf_area *area;
1521
1522 area = ospf_area_get(ospf, area_id);
1523 if (ospf_area_vlink_count(ospf, area))
1524 return 0;
1525
1526 if (area->external_routing != OSPF_AREA_NSSA) {
1527 ospf_area_type_set(area, OSPF_AREA_NSSA);
1528 ospf->anyNSSA++;
1529 area->NSSATranslatorRole = OSPF_NSSA_ROLE_CANDIDATE;
1530 }
1531
1532 ospf_area_no_summary_set(ospf, area_id);
1533
1534 return 1;
1535 }
1536
1537 int ospf_area_nssa_set(struct ospf *ospf, struct in_addr area_id)
1538 {
1539 struct ospf_area *area;
1540
1541 area = ospf_area_get(ospf, area_id);
1542 if (ospf_area_vlink_count(ospf, area))
1543 return 0;
1544
1545 if (area->external_routing != OSPF_AREA_NSSA) {
1546 ospf_area_type_set(area, OSPF_AREA_NSSA);
1547 ospf->anyNSSA++;
1548
1549 /* set NSSA area defaults */
1550 area->no_summary = 0;
1551 area->NSSATranslatorRole = OSPF_NSSA_ROLE_CANDIDATE;
1552 area->NSSATranslatorState = OSPF_NSSA_TRANSLATE_DISABLED;
1553 area->NSSATranslatorStabilityInterval =
1554 OSPF_NSSA_TRANS_STABLE_DEFAULT;
1555 }
1556 return 1;
1557 }
1558
1559 int ospf_area_nssa_unset(struct ospf *ospf, struct in_addr area_id, int argc)
1560 {
1561 struct ospf_area *area;
1562
1563 area = ospf_area_lookup_by_area_id(ospf, area_id);
1564 if (area == NULL)
1565 return 0;
1566
1567 /* argc < 5 -> 'no area x nssa' */
1568 if (argc < 5 && area->external_routing == OSPF_AREA_NSSA) {
1569 ospf->anyNSSA--;
1570 /* set NSSA area defaults */
1571 area->no_summary = 0;
1572 area->NSSATranslatorRole = OSPF_NSSA_ROLE_CANDIDATE;
1573 area->NSSATranslatorState = OSPF_NSSA_TRANSLATE_DISABLED;
1574 area->NSSATranslatorStabilityInterval =
1575 OSPF_NSSA_TRANS_STABLE_DEFAULT;
1576 ospf_area_type_set(area, OSPF_AREA_DEFAULT);
1577 } else {
1578 area->NSSATranslatorRole = OSPF_NSSA_ROLE_CANDIDATE;
1579 }
1580
1581 ospf_area_check_free(ospf, area_id);
1582
1583 return 1;
1584 }
1585
1586 int ospf_area_nssa_translator_role_set(struct ospf *ospf,
1587 struct in_addr area_id, int role)
1588 {
1589 struct ospf_area *area;
1590
1591 area = ospf_area_lookup_by_area_id(ospf, area_id);
1592 if (area == NULL)
1593 return 0;
1594
1595 area->NSSATranslatorRole = role;
1596
1597 return 1;
1598 }
1599
1600 #if 0
1601 /* XXX: unused? Leave for symmetry? */
1602 static int
1603 ospf_area_nssa_translator_role_unset (struct ospf *ospf,
1604 struct in_addr area_id)
1605 {
1606 struct ospf_area *area;
1607
1608 area = ospf_area_lookup_by_area_id (ospf, area_id);
1609 if (area == NULL)
1610 return 0;
1611
1612 area->NSSATranslatorRole = OSPF_NSSA_ROLE_CANDIDATE;
1613
1614 ospf_area_check_free (ospf, area_id);
1615
1616 return 1;
1617 }
1618 #endif
1619
1620 int ospf_area_export_list_set(struct ospf *ospf, struct ospf_area *area,
1621 const char *list_name)
1622 {
1623 struct access_list *list;
1624 list = access_list_lookup(AFI_IP, list_name);
1625
1626 EXPORT_LIST(area) = list;
1627
1628 if (EXPORT_NAME(area))
1629 free(EXPORT_NAME(area));
1630
1631 EXPORT_NAME(area) = strdup(list_name);
1632 ospf_schedule_abr_task(ospf);
1633
1634 return 1;
1635 }
1636
1637 int ospf_area_export_list_unset(struct ospf *ospf, struct ospf_area *area)
1638 {
1639
1640 EXPORT_LIST(area) = 0;
1641
1642 if (EXPORT_NAME(area))
1643 free(EXPORT_NAME(area));
1644
1645 EXPORT_NAME(area) = NULL;
1646
1647 ospf_area_check_free(ospf, area->area_id);
1648
1649 ospf_schedule_abr_task(ospf);
1650
1651 return 1;
1652 }
1653
1654 int ospf_area_import_list_set(struct ospf *ospf, struct ospf_area *area,
1655 const char *name)
1656 {
1657 struct access_list *list;
1658 list = access_list_lookup(AFI_IP, name);
1659
1660 IMPORT_LIST(area) = list;
1661
1662 if (IMPORT_NAME(area))
1663 free(IMPORT_NAME(area));
1664
1665 IMPORT_NAME(area) = strdup(name);
1666 ospf_schedule_abr_task(ospf);
1667
1668 return 1;
1669 }
1670
1671 int ospf_area_import_list_unset(struct ospf *ospf, struct ospf_area *area)
1672 {
1673 IMPORT_LIST(area) = 0;
1674
1675 if (IMPORT_NAME(area))
1676 free(IMPORT_NAME(area));
1677
1678 IMPORT_NAME(area) = NULL;
1679 ospf_area_check_free(ospf, area->area_id);
1680
1681 ospf_schedule_abr_task(ospf);
1682
1683 return 1;
1684 }
1685
1686 int ospf_timers_refresh_set(struct ospf *ospf, int interval)
1687 {
1688 int time_left;
1689
1690 if (ospf->lsa_refresh_interval == interval)
1691 return 1;
1692
1693 time_left = ospf->lsa_refresh_interval
1694 - (monotime(NULL) - ospf->lsa_refresher_started);
1695
1696 if (time_left > interval) {
1697 OSPF_TIMER_OFF(ospf->t_lsa_refresher);
1698 thread_add_timer(master, ospf_lsa_refresh_walker, ospf,
1699 interval, &ospf->t_lsa_refresher);
1700 }
1701 ospf->lsa_refresh_interval = interval;
1702
1703 return 1;
1704 }
1705
1706 int ospf_timers_refresh_unset(struct ospf *ospf)
1707 {
1708 int time_left;
1709
1710 time_left = ospf->lsa_refresh_interval
1711 - (monotime(NULL) - ospf->lsa_refresher_started);
1712
1713 if (time_left > OSPF_LSA_REFRESH_INTERVAL_DEFAULT) {
1714 OSPF_TIMER_OFF(ospf->t_lsa_refresher);
1715 ospf->t_lsa_refresher = NULL;
1716 thread_add_timer(master, ospf_lsa_refresh_walker, ospf,
1717 OSPF_LSA_REFRESH_INTERVAL_DEFAULT,
1718 &ospf->t_lsa_refresher);
1719 }
1720
1721 ospf->lsa_refresh_interval = OSPF_LSA_REFRESH_INTERVAL_DEFAULT;
1722
1723 return 1;
1724 }
1725
1726
1727 static struct ospf_nbr_nbma *ospf_nbr_nbma_new(void)
1728 {
1729 struct ospf_nbr_nbma *nbr_nbma;
1730
1731 nbr_nbma = XCALLOC(MTYPE_OSPF_NEIGHBOR_STATIC,
1732 sizeof(struct ospf_nbr_nbma));
1733
1734 nbr_nbma->priority = OSPF_NEIGHBOR_PRIORITY_DEFAULT;
1735 nbr_nbma->v_poll = OSPF_POLL_INTERVAL_DEFAULT;
1736
1737 return nbr_nbma;
1738 }
1739
1740 static void ospf_nbr_nbma_free(struct ospf_nbr_nbma *nbr_nbma)
1741 {
1742 XFREE(MTYPE_OSPF_NEIGHBOR_STATIC, nbr_nbma);
1743 }
1744
1745 static void ospf_nbr_nbma_delete(struct ospf *ospf,
1746 struct ospf_nbr_nbma *nbr_nbma)
1747 {
1748 struct route_node *rn;
1749 struct prefix_ipv4 p;
1750
1751 p.family = AF_INET;
1752 p.prefix = nbr_nbma->addr;
1753 p.prefixlen = IPV4_MAX_BITLEN;
1754
1755 rn = route_node_lookup(ospf->nbr_nbma, (struct prefix *)&p);
1756 if (rn) {
1757 ospf_nbr_nbma_free(rn->info);
1758 rn->info = NULL;
1759 route_unlock_node(rn);
1760 route_unlock_node(rn);
1761 }
1762 }
1763
1764 static void ospf_nbr_nbma_down(struct ospf_nbr_nbma *nbr_nbma)
1765 {
1766 OSPF_TIMER_OFF(nbr_nbma->t_poll);
1767
1768 if (nbr_nbma->nbr) {
1769 nbr_nbma->nbr->nbr_nbma = NULL;
1770 OSPF_NSM_EVENT_EXECUTE(nbr_nbma->nbr, NSM_KillNbr);
1771 }
1772
1773 if (nbr_nbma->oi)
1774 listnode_delete(nbr_nbma->oi->nbr_nbma, nbr_nbma);
1775 }
1776
1777 static void ospf_nbr_nbma_add(struct ospf_nbr_nbma *nbr_nbma,
1778 struct ospf_interface *oi)
1779 {
1780 struct ospf_neighbor *nbr;
1781 struct route_node *rn;
1782 struct prefix p;
1783
1784 if (oi->type != OSPF_IFTYPE_NBMA)
1785 return;
1786
1787 if (nbr_nbma->nbr != NULL)
1788 return;
1789
1790 if (IPV4_ADDR_SAME(&oi->nbr_self->address.u.prefix4, &nbr_nbma->addr))
1791 return;
1792
1793 nbr_nbma->oi = oi;
1794 listnode_add(oi->nbr_nbma, nbr_nbma);
1795
1796 /* Get neighbor information from table. */
1797 p.family = AF_INET;
1798 p.prefixlen = IPV4_MAX_BITLEN;
1799 p.u.prefix4 = nbr_nbma->addr;
1800
1801 rn = route_node_get(oi->nbrs, (struct prefix *)&p);
1802 if (rn->info) {
1803 nbr = rn->info;
1804 nbr->nbr_nbma = nbr_nbma;
1805 nbr_nbma->nbr = nbr;
1806
1807 route_unlock_node(rn);
1808 } else {
1809 nbr = rn->info = ospf_nbr_new(oi);
1810 nbr->state = NSM_Down;
1811 nbr->src = nbr_nbma->addr;
1812 nbr->nbr_nbma = nbr_nbma;
1813 nbr->priority = nbr_nbma->priority;
1814 nbr->address = p;
1815
1816 nbr_nbma->nbr = nbr;
1817
1818 OSPF_NSM_EVENT_EXECUTE(nbr, NSM_Start);
1819 }
1820 }
1821
1822 void ospf_nbr_nbma_if_update(struct ospf *ospf, struct ospf_interface *oi)
1823 {
1824 struct ospf_nbr_nbma *nbr_nbma;
1825 struct route_node *rn;
1826 struct prefix_ipv4 p;
1827
1828 if (oi->type != OSPF_IFTYPE_NBMA)
1829 return;
1830
1831 for (rn = route_top(ospf->nbr_nbma); rn; rn = route_next(rn))
1832 if ((nbr_nbma = rn->info))
1833 if (nbr_nbma->oi == NULL && nbr_nbma->nbr == NULL) {
1834 p.family = AF_INET;
1835 p.prefix = nbr_nbma->addr;
1836 p.prefixlen = IPV4_MAX_BITLEN;
1837
1838 if (prefix_match(oi->address,
1839 (struct prefix *)&p))
1840 ospf_nbr_nbma_add(nbr_nbma, oi);
1841 }
1842 }
1843
1844 struct ospf_nbr_nbma *ospf_nbr_nbma_lookup(struct ospf *ospf,
1845 struct in_addr nbr_addr)
1846 {
1847 struct route_node *rn;
1848 struct prefix_ipv4 p;
1849
1850 p.family = AF_INET;
1851 p.prefix = nbr_addr;
1852 p.prefixlen = IPV4_MAX_BITLEN;
1853
1854 rn = route_node_lookup(ospf->nbr_nbma, (struct prefix *)&p);
1855 if (rn) {
1856 route_unlock_node(rn);
1857 return rn->info;
1858 }
1859 return NULL;
1860 }
1861
1862 struct ospf_nbr_nbma *ospf_nbr_nbma_lookup_next(struct ospf *ospf,
1863 struct in_addr *addr, int first)
1864 {
1865 #if 0
1866 struct ospf_nbr_nbma *nbr_nbma;
1867 struct listnode *node;
1868 #endif
1869
1870 if (ospf == NULL)
1871 return NULL;
1872
1873 #if 0
1874 for (ALL_LIST_ELEMENTS_RO (ospf->nbr_nbma, node, nbr_nbma))
1875 {
1876 if (first)
1877 {
1878 *addr = nbr_nbma->addr;
1879 return nbr_nbma;
1880 }
1881 else if (ntohl (nbr_nbma->addr.s_addr) > ntohl (addr->s_addr))
1882 {
1883 *addr = nbr_nbma->addr;
1884 return nbr_nbma;
1885 }
1886 }
1887 #endif
1888 return NULL;
1889 }
1890
1891 int ospf_nbr_nbma_set(struct ospf *ospf, struct in_addr nbr_addr)
1892 {
1893 struct ospf_nbr_nbma *nbr_nbma;
1894 struct ospf_interface *oi;
1895 struct prefix_ipv4 p;
1896 struct route_node *rn;
1897 struct listnode *node;
1898
1899 nbr_nbma = ospf_nbr_nbma_lookup(ospf, nbr_addr);
1900 if (nbr_nbma)
1901 return 0;
1902
1903 nbr_nbma = ospf_nbr_nbma_new();
1904 nbr_nbma->addr = nbr_addr;
1905
1906 p.family = AF_INET;
1907 p.prefix = nbr_addr;
1908 p.prefixlen = IPV4_MAX_BITLEN;
1909
1910 rn = route_node_get(ospf->nbr_nbma, (struct prefix *)&p);
1911 if (rn->info)
1912 route_unlock_node(rn);
1913 rn->info = nbr_nbma;
1914
1915 for (ALL_LIST_ELEMENTS_RO(ospf->oiflist, node, oi)) {
1916 if (oi->type == OSPF_IFTYPE_NBMA)
1917 if (prefix_match(oi->address, (struct prefix *)&p)) {
1918 ospf_nbr_nbma_add(nbr_nbma, oi);
1919 break;
1920 }
1921 }
1922
1923 return 1;
1924 }
1925
1926 int ospf_nbr_nbma_unset(struct ospf *ospf, struct in_addr nbr_addr)
1927 {
1928 struct ospf_nbr_nbma *nbr_nbma;
1929
1930 nbr_nbma = ospf_nbr_nbma_lookup(ospf, nbr_addr);
1931 if (nbr_nbma == NULL)
1932 return 0;
1933
1934 ospf_nbr_nbma_down(nbr_nbma);
1935 ospf_nbr_nbma_delete(ospf, nbr_nbma);
1936
1937 return 1;
1938 }
1939
1940 int ospf_nbr_nbma_priority_set(struct ospf *ospf, struct in_addr nbr_addr,
1941 u_char priority)
1942 {
1943 struct ospf_nbr_nbma *nbr_nbma;
1944
1945 nbr_nbma = ospf_nbr_nbma_lookup(ospf, nbr_addr);
1946 if (nbr_nbma == NULL)
1947 return 0;
1948
1949 if (nbr_nbma->priority != priority)
1950 nbr_nbma->priority = priority;
1951
1952 return 1;
1953 }
1954
1955 int ospf_nbr_nbma_priority_unset(struct ospf *ospf, struct in_addr nbr_addr)
1956 {
1957 struct ospf_nbr_nbma *nbr_nbma;
1958
1959 nbr_nbma = ospf_nbr_nbma_lookup(ospf, nbr_addr);
1960 if (nbr_nbma == NULL)
1961 return 0;
1962
1963 if (nbr_nbma != OSPF_NEIGHBOR_PRIORITY_DEFAULT)
1964 nbr_nbma->priority = OSPF_NEIGHBOR_PRIORITY_DEFAULT;
1965
1966 return 1;
1967 }
1968
1969 int ospf_nbr_nbma_poll_interval_set(struct ospf *ospf, struct in_addr nbr_addr,
1970 unsigned int interval)
1971 {
1972 struct ospf_nbr_nbma *nbr_nbma;
1973
1974 nbr_nbma = ospf_nbr_nbma_lookup(ospf, nbr_addr);
1975 if (nbr_nbma == NULL)
1976 return 0;
1977
1978 if (nbr_nbma->v_poll != interval) {
1979 nbr_nbma->v_poll = interval;
1980 if (nbr_nbma->oi && ospf_if_is_up(nbr_nbma->oi)) {
1981 OSPF_TIMER_OFF(nbr_nbma->t_poll);
1982 OSPF_POLL_TIMER_ON(nbr_nbma->t_poll, ospf_poll_timer,
1983 nbr_nbma->v_poll);
1984 }
1985 }
1986
1987 return 1;
1988 }
1989
1990 int ospf_nbr_nbma_poll_interval_unset(struct ospf *ospf, struct in_addr addr)
1991 {
1992 struct ospf_nbr_nbma *nbr_nbma;
1993
1994 nbr_nbma = ospf_nbr_nbma_lookup(ospf, addr);
1995 if (nbr_nbma == NULL)
1996 return 0;
1997
1998 if (nbr_nbma->v_poll != OSPF_POLL_INTERVAL_DEFAULT)
1999 nbr_nbma->v_poll = OSPF_POLL_INTERVAL_DEFAULT;
2000
2001 return 1;
2002 }
2003
2004 void ospf_master_init(struct thread_master *master)
2005 {
2006 memset(&ospf_master, 0, sizeof(struct ospf_master));
2007
2008 om = &ospf_master;
2009 om->ospf = list_new();
2010 om->master = master;
2011 }
2012
2013 /* Link OSPF instance to VRF. */
2014 void ospf_vrf_link(struct ospf *ospf, struct vrf *vrf)
2015 {
2016 ospf->vrf_id = vrf->vrf_id;
2017 if (vrf->info != (void *)ospf)
2018 vrf->info = (void *)ospf;
2019 }
2020
2021 /* Unlink OSPF instance from VRF. */
2022 void ospf_vrf_unlink(struct ospf *ospf, struct vrf *vrf)
2023 {
2024 if (vrf->info == (void *)ospf)
2025 vrf->info = NULL;
2026 ospf->vrf_id = VRF_UNKNOWN;
2027 }
2028
2029 /* This is hook function for vrf create called as part of vrf_init */
2030 static int ospf_vrf_new(struct vrf *vrf)
2031 {
2032 if (IS_DEBUG_OSPF_EVENT)
2033 zlog_debug("%s: VRF Created: %s(%u)", __PRETTY_FUNCTION__,
2034 vrf->name, vrf->vrf_id);
2035
2036 return 0;
2037 }
2038
2039 /* This is hook function for vrf delete call as part of vrf_init */
2040 static int ospf_vrf_delete(struct vrf *vrf)
2041 {
2042 if (IS_DEBUG_OSPF_EVENT)
2043 zlog_debug("%s: VRF Deletion: %s(%u)", __PRETTY_FUNCTION__,
2044 vrf->name, vrf->vrf_id);
2045
2046 return 0;
2047 }
2048
2049 /* Enable OSPF VRF instance */
2050 static int ospf_vrf_enable(struct vrf *vrf)
2051 {
2052 struct ospf *ospf = NULL;
2053 vrf_id_t old_vrf_id = VRF_DEFAULT;
2054
2055 if (IS_DEBUG_OSPF_EVENT)
2056 zlog_debug("%s: VRF %s id %u enabled",
2057 __PRETTY_FUNCTION__, vrf->name, vrf->vrf_id);
2058
2059 ospf = ospf_lookup_by_name(vrf->name);
2060 if (ospf) {
2061 old_vrf_id = ospf->vrf_id;
2062 /* We have instance configured, link to VRF and make it "up". */
2063 ospf_vrf_link(ospf, vrf);
2064 if (IS_DEBUG_OSPF_EVENT)
2065 zlog_debug("%s: ospf linked to vrf %s vrf_id %u (old id %u)",
2066 __PRETTY_FUNCTION__, vrf->name, ospf->vrf_id,
2067 old_vrf_id);
2068
2069 if (old_vrf_id != ospf->vrf_id) {
2070 if (ospfd_privs.change(ZPRIVS_RAISE)) {
2071 zlog_err("ospf_sock_init: could not raise privs, %s",
2072 safe_strerror(errno));
2073 }
2074 if (ospf_bind_vrfdevice(ospf, ospf->fd) < 0)
2075 return 0;
2076 if (ospfd_privs.change(ZPRIVS_LOWER)) {
2077 zlog_err("ospf_sock_init: could not lower privs, %s",
2078 safe_strerror(errno));
2079 }
2080
2081 ospf->oi_running = 1;
2082 ospf_zebra_vrf_register(ospf);
2083 ospf_router_id_update(ospf);
2084 }
2085 }
2086
2087 return 0;
2088 }
2089
2090 /* Disable OSPF VRF instance */
2091 static int ospf_vrf_disable(struct vrf *vrf)
2092 {
2093 struct ospf *ospf = NULL;
2094 vrf_id_t old_vrf_id = VRF_UNKNOWN;
2095
2096 if (vrf->vrf_id == VRF_DEFAULT)
2097 return 0;
2098
2099 if (IS_DEBUG_OSPF_EVENT)
2100 zlog_debug("%s: VRF %s id %d disabled.",
2101 __PRETTY_FUNCTION__, vrf->name, vrf->vrf_id);
2102
2103 ospf = ospf_lookup_by_name(vrf->name);
2104 if (ospf) {
2105 old_vrf_id = ospf->vrf_id;
2106
2107 /* We have instance configured, unlink
2108 * from VRF and make it "down".
2109 */
2110 ospf_vrf_unlink(ospf, vrf);
2111 ospf->oi_running = 0;
2112 if (IS_DEBUG_OSPF_EVENT)
2113 zlog_debug("%s: ospf old_vrf_id %d unlinked",
2114 __PRETTY_FUNCTION__, old_vrf_id);
2115 }
2116
2117 /* Note: This is a callback, the VRF will be deleted by the caller. */
2118 return 0;
2119 }
2120
2121 void ospf_vrf_init(void)
2122 {
2123 vrf_init(ospf_vrf_new, ospf_vrf_enable,
2124 ospf_vrf_disable, ospf_vrf_delete);
2125 }
2126
2127 void ospf_vrf_terminate(void)
2128 {
2129 vrf_terminate();
2130 }
2131
2132 const char *ospf_vrf_id_to_name(vrf_id_t vrf_id)
2133 {
2134 struct vrf *vrf = vrf_lookup_by_id(vrf_id);
2135
2136 return vrf ? vrf->name : "NIL";
2137 }
FRRouting mirror