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