]>
git.ipfire.org Git - thirdparty/bird.git/blob - proto/ospf/ospf.c
3cb40283426aa4de740ceba27ccb113d3fc5b766
4 * (c) 1999--2004 Ondrej Filip <feela@network.cz>
5 * (c) 2009--2014 Ondrej Zajicek <santiago@crfreenet.org>
6 * (c) 2009--2014 CZ.NIC z.s.p.o.
8 * Can be freely distributed and used under the terms of the GNU GPL.
12 * DOC: Open Shortest Path First (OSPF)
14 * The OSPF protocol is quite complicated and its complex implemenation is split
15 * to many files. In |ospf.c|, you will find mainly the interface for
16 * communication with the core (e.g., reconfiguration hooks, shutdown and
17 * initialisation and so on). File |iface.c| contains the interface state
18 * machine and functions for allocation and deallocation of OSPF's interface
19 * data structures. Source |neighbor.c| includes the neighbor state machine and
20 * functions for election of Designated Router and Backup Designated router. In
21 * |packet.c|, you will find various functions for sending and receiving generic
22 * OSPF packets. There are also routines for authentication and checksumming.
23 * In |hello.c|, there are routines for sending and receiving of hello packets
24 * as well as functions for maintaining wait times and the inactivity timer.
25 * Files |lsreq.c|, |lsack.c|, |dbdes.c| contain functions for sending and
26 * receiving of link-state requests, link-state acknowledgements and database
27 * descriptions respectively. In |lsupd.c|, there are functions for sending and
28 * receiving of link-state updates and also the flooding algorithm. Source
29 * |topology.c| is a place where routines for searching LSAs in the link-state
30 * database, adding and deleting them reside, there also are functions for
31 * originating of various types of LSAs (router LSA, net LSA, external LSA).
32 * File |rt.c| contains routines for calculating the routing table. |lsalib.c|
33 * is a set of various functions for working with the LSAs (endianity
34 * conversions, calculation of checksum etc.).
36 * One instance of the protocol is able to hold LSA databases for multiple OSPF
37 * areas, to exchange routing information between multiple neighbors and to
38 * calculate the routing tables. The core structure is &ospf_proto to which
39 * multiple &ospf_area and &ospf_iface structures are connected. &ospf_proto is
40 * also connected to &top_hash_graph which is a dynamic hashing structure that
41 * describes the link-state database. It allows fast search, addition and
42 * deletion. Each LSA is kept in two pieces: header and body. Both of them are
43 * kept in the endianity of the CPU.
45 * In OSPFv2 specification, it is implied that there is one IP prefix for each
46 * physical network/interface (unless it is an ptp link). But in modern systems,
47 * there might be more independent IP prefixes associated with an interface. To
48 * handle this situation, we have one &ospf_iface for each active IP prefix
49 * (instead for each active iface); This behaves like virtual interface for the
50 * purpose of OSPF. If we receive packet, we associate it with a proper virtual
51 * interface mainly according to its source address.
53 * OSPF keeps one socket per &ospf_iface. This allows us (compared to one socket
54 * approach) to evade problems with a limit of multicast groups per socket and
55 * with sending multicast packets to appropriate interface in a portable way.
56 * The socket is associated with underlying physical iface and should not
57 * receive packets received on other ifaces (unfortunately, this is not true on
58 * BSD). Generally, one packet can be received by more sockets (for example, if
59 * there are more &ospf_iface on one physical iface), therefore we explicitly
60 * filter received packets according to src/dst IP address and received iface.
62 * Vlinks are implemented using particularly degenerate form of &ospf_iface,
63 * which has several exceptions: it does not have its iface or socket (it copies
64 * these from 'parent' &ospf_iface) and it is present in iface list even when
65 * down (it is not freed in ospf_iface_down()).
67 * The heart beat of ospf is ospf_disp(). It is called at regular intervals
68 * (&ospf_proto->tick). It is responsible for aging and flushing of LSAs in the
69 * database, updating topology information in LSAs and for routing table
72 * To every &ospf_iface, we connect one or more &ospf_neighbor's -- a structure
73 * containing many timers and queues for building adjacency and for exchange of
76 * BIRD's OSPF implementation respects RFC2328 in every detail, but some of
77 * internal algorithms do differ. The RFC recommends making a snapshot of the
78 * link-state database when a new adjacency is forming and sending the database
79 * description packets based on the information in this snapshot. The database
80 * can be quite large in some networks, so rather we walk through a &slist
81 * structure which allows us to continue even if the actual LSA we were working
82 * with is deleted. New LSAs are added at the tail of this &slist.
84 * We also do not keep a separate OSPF routing table, because the core helps us
85 * by being able to recognize when a route is updated to an identical one and it
86 * suppresses the update automatically. Due to this, we can flush all the routes
87 * we have recalculated and also those we have deleted to the core's routing
88 * table and the core will take care of the rest. This simplifies the process
89 * and conserves memory.
91 * Supported standards:
92 * - RFC 2328 - main OSPFv2 standard
93 * - RFC 5340 - main OSPFv3 standard
94 * - RFC 3101 - OSPFv2 NSSA areas
95 * - RFC 3623 - OSPFv2 Graceful Restart
96 * - RFC 4576 - OSPFv2 VPN loop prevention
97 * - RFC 5187 - OSPFv3 Graceful Restart
98 * - RFC 5250 - OSPFv2 Opaque LSAs
99 * - RFC 5709 - OSPFv2 HMAC-SHA Cryptographic Authentication
100 * - RFC 5838 - OSPFv3 Support of Address Families
101 * - RFC 6549 - OSPFv2 Multi-Instance Extensions
102 * - RFC 6987 - OSPF Stub Router Advertisement
103 * - RFC 7166 - OSPFv3 Authentication Trailer
104 * - RFC 7770 - OSPF Router Information LSA
110 static int ospf_preexport(struct proto
*P
, rte
**new, struct linpool
*pool
);
111 static void ospf_make_tmp_attrs(struct rte
*rt
, struct linpool
*pool
);
112 static void ospf_store_tmp_attrs(struct rte
*rt
, struct linpool
*pool
);
113 static void ospf_reload_routes(struct channel
*C
);
114 static int ospf_rte_better(struct rte
*new, struct rte
*old
);
115 static int ospf_rte_same(struct rte
*new, struct rte
*old
);
116 static void ospf_disp(timer
*timer
);
120 add_area_nets(struct ospf_area
*oa
, struct ospf_area_config
*ac
)
122 struct ospf_proto
*p
= oa
->po
;
123 struct area_net_config
*anc
;
126 fib_init(&oa
->net_fib
, p
->p
.pool
, ospf_get_af(p
),
127 sizeof(struct area_net
), OFFSETOF(struct area_net
, fn
), 0, NULL
);
128 fib_init(&oa
->enet_fib
, p
->p
.pool
, ospf_get_af(p
),
129 sizeof(struct area_net
), OFFSETOF(struct area_net
, fn
), 0, NULL
);
131 WALK_LIST(anc
, ac
->net_list
)
133 an
= fib_get(&oa
->net_fib
, &anc
->prefix
);
134 an
->hidden
= anc
->hidden
;
137 WALK_LIST(anc
, ac
->enet_list
)
139 an
= fib_get(&oa
->enet_fib
, &anc
->prefix
);
140 an
->hidden
= anc
->hidden
;
146 ospf_opts(struct ospf_proto
*p
)
151 return ((ospf_is_ip6(p
) && !p
->af_mc
) ? OPT_V6
: 0) |
152 (!p
->stub_router
? OPT_R
: 0) | (p
->af_ext
? OPT_AF
: 0);
156 ospf_area_add(struct ospf_proto
*p
, struct ospf_area_config
*ac
)
158 struct ospf_area
*oa
;
160 OSPF_TRACE(D_EVENTS
, "Adding area %R", ac
->areaid
);
162 oa
= mb_allocz(p
->p
.pool
, sizeof(struct ospf_area
));
163 add_tail(&p
->area_list
, NODE oa
);
167 oa
->areaid
= ac
->areaid
;
170 fib_init(&oa
->rtr
, p
->p
.pool
, NET_IP4
, sizeof(ort
), OFFSETOF(ort
, fn
), 0, NULL
);
171 add_area_nets(oa
, ac
);
176 oa
->options
= ac
->type
| ospf_opts(p
);
178 ospf_notify_rt_lsa(oa
);
182 ospf_flush_area(struct ospf_proto
*p
, u32 areaid
)
184 struct top_hash_entry
*en
;
186 WALK_SLIST(en
, p
->lsal
)
187 if ((LSA_SCOPE(en
->lsa_type
) == LSA_SCOPE_AREA
) && (en
->domain
== areaid
))
188 ospf_flush_lsa(p
, en
);
192 ospf_area_remove(struct ospf_area
*oa
)
194 struct ospf_proto
*p
= oa
->po
;
195 OSPF_TRACE(D_EVENTS
, "Removing area %R", oa
->areaid
);
197 /* We suppose that interfaces are already removed */
198 ospf_flush_area(p
, oa
->areaid
);
201 fib_free(&oa
->net_fib
);
202 fib_free(&oa
->enet_fib
);
204 if (oa
->translator_timer
)
205 rfree(oa
->translator_timer
);
213 ospf_find_area(struct ospf_proto
*p
, u32 aid
)
215 struct ospf_area
*oa
;
216 WALK_LIST(oa
, p
->area_list
)
217 if (((struct ospf_area
*) oa
)->areaid
== aid
)
222 static struct ospf_iface
*
223 ospf_find_vlink(struct ospf_proto
*p
, u32 voa
, u32 vid
)
225 struct ospf_iface
*ifa
;
226 WALK_LIST(ifa
, p
->iface_list
)
227 if ((ifa
->type
== OSPF_IT_VLINK
) && (ifa
->voa
->areaid
== voa
) && (ifa
->vid
== vid
))
233 ospf_start_gr_recovery(struct ospf_proto
*p
)
235 OSPF_TRACE(D_EVENTS
, "Graceful restart started");
238 p
->gr_timeout
= current_time() + (p
->gr_time S
);
239 channel_graceful_restart_lock(p
->p
.main_channel
);
240 p
->p
.main_channel
->gr_wait
= 1;
242 /* NOTE: We should get end of grace period from non-volatile storage */
246 ospf_stop_gr_recovery(struct ospf_proto
*p
)
252 /* Reorigination of router/network LSAs is already scheduled */
254 /* Rest is done in ospf_cleanup_gr_recovery() */
258 ospf_cleanup_gr_recovery(struct ospf_proto
*p
)
260 struct top_hash_entry
*en
;
262 /* Flush dirty LSAa except external ones, these will be handled by feed */
263 WALK_SLIST(en
, p
->lsal
)
266 if ((en
->lsa_type
== LSA_T_EXT
) || (en
->lsa_type
== LSA_T_NSSA
))
267 en
->mode
= LSA_M_EXPORT
;
269 ospf_flush_lsa(p
, en
);
272 /* End graceful restart on channel, will also schedule feed */
273 channel_graceful_restart_unlock(p
->p
.main_channel
);
279 ospf_start(struct proto
*P
)
281 struct ospf_proto
*p
= (struct ospf_proto
*) P
;
282 struct ospf_config
*c
= (struct ospf_config
*) (P
->cf
);
283 struct ospf_area_config
*ac
;
285 p
->router_id
= proto_get_router_id(P
->cf
);
287 p
->af_ext
= c
->af_ext
;
289 p
->rfc1583
= c
->rfc1583
;
290 p
->stub_router
= c
->stub_router
;
291 p
->merge_external
= c
->merge_external
;
292 p
->instance_id
= c
->instance_id
;
294 p
->vpn_pe
= c
->vpn_pe
;
296 p
->gr_mode
= c
->gr_mode
;
297 p
->gr_time
= c
->gr_time
;
299 p
->disp_timer
= tm_new_init(P
->pool
, ospf_disp
, p
, p
->tick S
, 0);
300 tm_start(p
->disp_timer
, 100 MS
);
303 p
->lsab
= mb_alloc(P
->pool
, p
->lsab_size
);
304 p
->nhpool
= lp_new(P
->pool
, 12*sizeof(struct nexthop
));
305 init_list(&(p
->iface_list
));
306 init_list(&(p
->area_list
));
307 fib_init(&p
->rtf
, P
->pool
, ospf_get_af(p
), sizeof(ort
), OFFSETOF(ort
, fn
), 0, NULL
);
309 idm_init(&p
->idm
, P
->pool
, 16);
311 p
->gr
= ospf_top_new(p
, P
->pool
);
312 s_init_list(&(p
->lsal
));
314 p
->flood_event
= ev_new_init(P
->pool
, ospf_flood_event
, p
);
316 p
->log_pkt_tbf
= (struct tbf
){ .rate
= 1, .burst
= 5 };
317 p
->log_lsa_tbf
= (struct tbf
){ .rate
= 4, .burst
= 20 };
319 /* Lock the channel when in GR recovery mode */
320 if (p
->p
.gr_recovery
&& (p
->gr_mode
== OSPF_GR_ABLE
))
321 ospf_start_gr_recovery(p
);
323 WALK_LIST(ac
, c
->area_list
)
324 ospf_area_add(p
, ac
);
327 ospf_open_vlink_sk(p
);
329 /* Add all virtual links */
330 struct ospf_iface_patt
*ic
;
331 WALK_LIST(ic
, c
->vlink_list
)
332 ospf_iface_new_vlink(p
, ic
);
338 ospf_dump(struct proto
*P
)
340 struct ospf_proto
*p
= (struct ospf_proto
*) P
;
341 struct ospf_iface
*ifa
;
342 struct ospf_neighbor
*n
;
344 OSPF_TRACE(D_EVENTS
, "Area number: %d", p
->areano
);
346 WALK_LIST(ifa
, p
->iface_list
)
348 OSPF_TRACE(D_EVENTS
, "Interface: %s", ifa
->ifname
);
349 OSPF_TRACE(D_EVENTS
, "state: %u", ifa
->state
);
350 OSPF_TRACE(D_EVENTS
, "DR: %R", ifa
->drid
);
351 OSPF_TRACE(D_EVENTS
, "BDR: %R", ifa
->bdrid
);
352 WALK_LIST(n
, ifa
->neigh_list
)
354 OSPF_TRACE(D_EVENTS
, " neighbor %R in state %u", n
->rid
, n
->state
);
359 OSPF_TRACE(D_EVENTS, "LSA graph dump start:");
360 ospf_top_dump(p->gr, p);
361 OSPF_TRACE(D_EVENTS, "LSA graph dump finished");
366 static struct proto
*
367 ospf_init(struct proto_config
*CF
)
369 struct ospf_config
*cf
= (struct ospf_config
*) CF
;
370 struct proto
*P
= proto_new(CF
);
372 P
->main_channel
= proto_add_channel(P
, proto_cf_main_channel(CF
));
374 P
->rt_notify
= ospf_rt_notify
;
375 P
->if_notify
= ospf_if_notify
;
376 P
->ifa_notify
= cf
->ospf2
? ospf_ifa_notify2
: ospf_ifa_notify3
;
377 P
->preexport
= ospf_preexport
;
378 P
->reload_routes
= ospf_reload_routes
;
379 P
->feed_begin
= ospf_feed_begin
;
380 P
->feed_end
= ospf_feed_end
;
381 P
->make_tmp_attrs
= ospf_make_tmp_attrs
;
382 P
->store_tmp_attrs
= ospf_store_tmp_attrs
;
383 P
->rte_better
= ospf_rte_better
;
384 P
->rte_same
= ospf_rte_same
;
389 /* If new is better return 1 */
391 ospf_rte_better(struct rte
*new, struct rte
*old
)
393 if (new->u
.ospf
.metric1
== LSINFINITY
)
396 if(new->attrs
->source
< old
->attrs
->source
) return 1;
397 if(new->attrs
->source
> old
->attrs
->source
) return 0;
399 if(new->attrs
->source
== RTS_OSPF_EXT2
)
401 if(new->u
.ospf
.metric2
< old
->u
.ospf
.metric2
) return 1;
402 if(new->u
.ospf
.metric2
> old
->u
.ospf
.metric2
) return 0;
405 if (new->u
.ospf
.metric1
< old
->u
.ospf
.metric1
)
408 return 0; /* Old is shorter or same */
412 ospf_rte_same(struct rte
*new, struct rte
*old
)
414 /* new->attrs == old->attrs always */
416 new->u
.ospf
.metric1
== old
->u
.ospf
.metric1
&&
417 new->u
.ospf
.metric2
== old
->u
.ospf
.metric2
&&
418 new->u
.ospf
.tag
== old
->u
.ospf
.tag
&&
419 new->u
.ospf
.router_id
== old
->u
.ospf
.router_id
;
424 ospf_schedule_rtcalc(struct ospf_proto
*p
)
429 OSPF_TRACE(D_EVENTS
, "Scheduling routing table calculation");
434 ospf_reload_routes(struct channel
*C
)
436 struct ospf_proto
*p
= (struct ospf_proto
*) C
->proto
;
441 OSPF_TRACE(D_EVENTS
, "Scheduling routing table calculation with route reload");
447 * ospf_disp - invokes routing table calculation, aging and also area_disp()
448 * @timer: timer usually called every @ospf_proto->tick second, @timer->data
449 * point to @ospf_proto
452 ospf_disp(timer
* timer
)
454 struct ospf_proto
*p
= timer
->data
;
456 /* Check for end of graceful restart */
458 ospf_update_gr_recovery(p
);
460 /* Originate or flush local topology LSAs */
461 ospf_update_topology(p
);
464 ospf_update_lsadb(p
);
466 /* Calculate routing table */
470 /* Cleanup after graceful restart */
472 ospf_cleanup_gr_recovery(p
);
477 * ospf_preexport - accept or reject new route from nest's routing table
478 * @P: OSPF protocol instance
479 * @new: the new route
480 * @attrs: list of attributes
481 * @pool: pool for allocation of attributes
483 * Its quite simple. It does not accept our own routes and leaves the decision on
484 * import to the filters.
487 ospf_preexport(struct proto
*P
, rte
**new, struct linpool
*pool UNUSED
)
489 struct ospf_proto
*p
= (struct ospf_proto
*) P
;
490 struct ospf_area
*oa
= ospf_main_area(p
);
493 /* Reject our own routes */
494 if (e
->attrs
->src
->proto
== P
)
497 /* Do not export routes to stub areas */
505 ospf_make_tmp_attrs(struct rte
*rt
, struct linpool
*pool
)
507 rte_init_tmp_attrs(rt
, pool
, 4);
508 rte_make_tmp_attr(rt
, EA_OSPF_METRIC1
, EAF_TYPE_INT
, rt
->u
.ospf
.metric1
);
509 rte_make_tmp_attr(rt
, EA_OSPF_METRIC2
, EAF_TYPE_INT
, rt
->u
.ospf
.metric2
);
510 rte_make_tmp_attr(rt
, EA_OSPF_TAG
, EAF_TYPE_INT
, rt
->u
.ospf
.tag
);
511 rte_make_tmp_attr(rt
, EA_OSPF_ROUTER_ID
, EAF_TYPE_ROUTER_ID
, rt
->u
.ospf
.router_id
);
515 ospf_store_tmp_attrs(struct rte
*rt
, struct linpool
*pool
)
517 rte_init_tmp_attrs(rt
, pool
, 4);
518 rt
->u
.ospf
.metric1
= rte_store_tmp_attr(rt
, EA_OSPF_METRIC1
);
519 rt
->u
.ospf
.metric2
= rte_store_tmp_attr(rt
, EA_OSPF_METRIC2
);
520 rt
->u
.ospf
.tag
= rte_store_tmp_attr(rt
, EA_OSPF_TAG
);
521 rt
->u
.ospf
.router_id
= rte_store_tmp_attr(rt
, EA_OSPF_ROUTER_ID
);
525 * ospf_shutdown - Finish of OSPF instance
526 * @P: OSPF protocol instance
528 * RFC does not define any action that should be taken before router
529 * shutdown. To make my neighbors react as fast as possible, I send
530 * them hello packet with empty neighbor list. They should start
531 * their neighbor state machine with event %NEIGHBOR_1WAY.
534 ospf_shutdown(struct proto
*P
)
536 struct ospf_proto
*p
= (struct ospf_proto
*) P
;
537 struct ospf_iface
*ifa
;
539 OSPF_TRACE(D_EVENTS
, "Shutdown requested");
541 if ((P
->down_code
== PDC_CMD_GR_DOWN
) && (p
->gr_mode
== OSPF_GR_ABLE
))
543 /* Originate Grace LSAs */
544 WALK_LIST(ifa
, p
->iface_list
)
545 ospf_originate_gr_lsa(p
, ifa
);
549 /* Send to all my neighbors 1WAY */
550 WALK_LIST(ifa
, p
->iface_list
)
551 ospf_iface_shutdown(ifa
);
554 /* Cleanup locked rta entries */
555 FIB_WALK(&p
->rtf
, ort
, nf
)
557 rta_free(nf
->old_rta
);
565 ospf_get_status(struct proto
*P
, byte
* buf
)
567 struct ospf_proto
*p
= (struct ospf_proto
*) P
;
569 if (p
->p
.proto_state
== PS_DOWN
)
573 struct ospf_iface
*ifa
;
574 struct ospf_neighbor
*n
;
577 WALK_LIST(ifa
, p
->iface_list
)
578 WALK_LIST(n
, ifa
->neigh_list
) if (n
->state
== NEIGHBOR_FULL
)
582 strcpy(buf
, "Alone");
584 strcpy(buf
, "Running");
589 ospf_get_route_info(rte
* rte
, byte
* buf
)
591 char *type
= "<bug>";
593 switch (rte
->attrs
->source
)
609 buf
+= bsprintf(buf
, " %s", type
);
610 buf
+= bsprintf(buf
, " (%d/%d", rte
->pref
, rte
->u
.ospf
.metric1
);
611 if (rte
->attrs
->source
== RTS_OSPF_EXT2
)
612 buf
+= bsprintf(buf
, "/%d", rte
->u
.ospf
.metric2
);
613 buf
+= bsprintf(buf
, ")");
614 if ((rte
->attrs
->source
== RTS_OSPF_EXT1
|| rte
->attrs
->source
== RTS_OSPF_EXT2
) && rte
->u
.ospf
.tag
)
616 buf
+= bsprintf(buf
, " [%x]", rte
->u
.ospf
.tag
);
618 if (rte
->u
.ospf
.router_id
)
619 buf
+= bsprintf(buf
, " [%R]", rte
->u
.ospf
.router_id
);
623 ospf_get_attr(eattr
* a
, byte
* buf
, int buflen UNUSED
)
627 case EA_OSPF_METRIC1
:
628 bsprintf(buf
, "metric1");
630 case EA_OSPF_METRIC2
:
631 bsprintf(buf
, "metric2");
634 bsprintf(buf
, "tag: 0x%08x", a
->u
.data
);
636 case EA_OSPF_ROUTER_ID
:
637 bsprintf(buf
, "router_id");
645 ospf_area_reconfigure(struct ospf_area
*oa
, struct ospf_area_config
*nac
)
647 struct ospf_proto
*p
= oa
->po
;
648 struct ospf_area_config
*oac
= oa
->ac
;
649 struct ospf_iface
*ifa
, *ifx
;
652 oa
->options
= nac
->type
| ospf_opts(p
);
654 if (nac
->type
!= oac
->type
)
656 log(L_INFO
"%s: Restarting area %R", p
->p
.name
, oa
->areaid
);
658 /* Remove area interfaces, will be re-added later */
659 WALK_LIST_DELSAFE(ifa
, ifx
, p
->iface_list
)
662 ospf_iface_shutdown(ifa
);
663 ospf_iface_remove(ifa
);
666 /* Flush area LSAs */
667 ospf_flush_area(p
, oa
->areaid
);
670 /* Handle net_list */
671 fib_free(&oa
->net_fib
);
672 fib_free(&oa
->enet_fib
);
673 add_area_nets(oa
, nac
);
675 /* No need to handle stubnet_list */
678 ospf_notify_rt_lsa(oa
);
682 * ospf_reconfigure - reconfiguration hook
683 * @P: current instance of protocol (with old configuration)
684 * @c: new configuration requested by user
686 * This hook tries to be a little bit intelligent. Instance of OSPF
687 * will survive change of many constants like hello interval,
688 * password change, addition or deletion of some neighbor on
689 * nonbroadcast network, cost of interface, etc.
692 ospf_reconfigure(struct proto
*P
, struct proto_config
*CF
)
694 struct ospf_proto
*p
= (struct ospf_proto
*) P
;
695 struct ospf_config
*old
= (struct ospf_config
*) (P
->cf
);
696 struct ospf_config
*new = (struct ospf_config
*) CF
;
697 struct ospf_area_config
*oac
, *nac
;
698 struct ospf_area
*oa
, *oax
;
699 struct ospf_iface
*ifa
, *ifx
;
700 struct ospf_iface_patt
*ip
;
702 if (proto_get_router_id(CF
) != p
->router_id
)
705 if (p
->ospf2
!= new->ospf2
)
708 if (p
->rfc1583
!= new->rfc1583
)
711 if (p
->instance_id
!= new->instance_id
)
714 if (old
->abr
!= new->abr
)
719 oac
= HEAD(old
->area_list
);
720 nac
= HEAD(new->area_list
);
722 if (oac
->type
!= nac
->type
)
726 if (old
->vpn_pe
!= new->vpn_pe
)
729 if ((p
->af_ext
!= new->af_ext
) || (p
->af_mc
!= new->af_mc
))
732 if (!proto_configure_channel(P
, &P
->main_channel
, proto_cf_main_channel(CF
)))
735 p
->stub_router
= new->stub_router
;
736 p
->merge_external
= new->merge_external
;
739 p
->gr_mode
= new->gr_mode
;
740 p
->gr_time
= new->gr_time
;
742 p
->disp_timer
->recurrent
= p
->tick S
;
743 tm_start(p
->disp_timer
, 10 MS
);
745 /* Mark all areas and ifaces */
746 WALK_LIST(oa
, p
->area_list
)
749 WALK_LIST(ifa
, p
->iface_list
)
752 /* Add and update areas */
753 WALK_LIST(nac
, new->area_list
)
755 oa
= ospf_find_area(p
, nac
->areaid
);
757 ospf_area_reconfigure(oa
, nac
);
759 ospf_area_add(p
, nac
);
762 /* Add and update interfaces */
763 ospf_reconfigure_ifaces(p
);
765 /* Add and update vlinks */
766 WALK_LIST(ip
, new->vlink_list
)
768 ifa
= ospf_find_vlink(p
, ip
->voa
, ip
->vid
);
770 ospf_iface_reconfigure(ifa
, ip
);
772 ospf_iface_new_vlink(p
, ip
);
775 /* Delete remaining ifaces and areas */
776 WALK_LIST_DELSAFE(ifa
, ifx
, p
->iface_list
)
779 ospf_iface_shutdown(ifa
);
780 ospf_iface_remove(ifa
);
783 WALK_LIST_DELSAFE(oa
, oax
, p
->area_list
)
785 ospf_area_remove(oa
);
787 ospf_schedule_rtcalc(p
);
794 ospf_sh_neigh(struct proto
*P
, const char *iff
)
796 struct ospf_proto
*p
= (struct ospf_proto
*) P
;
797 struct ospf_iface
*ifa
= NULL
;
798 struct ospf_neighbor
*n
;
800 if (p
->p
.proto_state
!= PS_UP
)
802 cli_msg(-1013, "%s: is not up", p
->p
.name
);
807 cli_msg(-1013, "%s:", p
->p
.name
);
808 cli_msg(-1013, "%-12s\t%3s\t%-15s\t%-5s\t%-10s %s", "Router ID", "Pri",
809 " State", "DTime", "Interface", "Router IP");
810 WALK_LIST(ifa
, p
->iface_list
)
811 if ((iff
== NULL
) || patmatch(iff
, ifa
->ifname
))
812 WALK_LIST(n
, ifa
->neigh_list
)
813 ospf_sh_neigh_info(n
);
818 ospf_sh(struct proto
*P
)
820 struct ospf_proto
*p
= (struct ospf_proto
*) P
;
821 struct ospf_area
*oa
;
822 struct ospf_iface
*ifa
;
823 struct ospf_neighbor
*n
;
824 int ifano
, nno
, adjno
, firstfib
;
826 if (p
->p
.proto_state
!= PS_UP
)
828 cli_msg(-1014, "%s: is not up", p
->p
.name
);
833 cli_msg(-1014, "%s:", p
->p
.name
);
834 cli_msg(-1014, "RFC1583 compatibility: %s", (p
->rfc1583
? "enabled" : "disabled"));
835 cli_msg(-1014, "Stub router: %s", (p
->stub_router
? "Yes" : "No"));
836 cli_msg(-1014, "RT scheduler tick: %d", p
->tick
);
837 cli_msg(-1014, "Number of areas: %u", p
->areano
);
838 cli_msg(-1014, "Number of LSAs in DB:\t%u", p
->gr
->hash_entries
);
840 WALK_LIST(oa
, p
->area_list
)
842 cli_msg(-1014, "\tArea: %R (%u) %s", oa
->areaid
, oa
->areaid
,
843 oa
->areaid
== 0 ? "[BACKBONE]" : "");
847 WALK_LIST(ifa
, p
->iface_list
)
852 WALK_LIST(n
, ifa
->neigh_list
)
855 if (n
->state
== NEIGHBOR_FULL
)
861 cli_msg(-1014, "\t\tStub:\t%s", oa_is_stub(oa
) ? "Yes" : "No");
862 cli_msg(-1014, "\t\tNSSA:\t%s", oa_is_nssa(oa
) ? "Yes" : "No");
863 cli_msg(-1014, "\t\tTransit:\t%s", oa
->trcap
? "Yes" : "No");
866 cli_msg(-1014, "\t\tNSSA translation:\t%s%s", oa
->translate
? "Yes" : "No",
867 oa
->translate
== TRANS_WAIT
? " (run down)" : "");
868 cli_msg(-1014, "\t\tNumber of interfaces:\t%u", ifano
);
869 cli_msg(-1014, "\t\tNumber of neighbors:\t%u", nno
);
870 cli_msg(-1014, "\t\tNumber of adjacent neighbors:\t%u", adjno
);
873 FIB_WALK(&oa
->net_fib
, struct area_net
, anet
)
877 cli_msg(-1014, "\t\tArea networks:");
880 cli_msg(-1014, "\t\t\t%1N\t%s\t%s", anet
->fn
.addr
,
881 anet
->hidden
? "Hidden" : "Advertise", anet
->active
? "Active" : "");
886 FIB_WALK(&oa
->enet_fib
, struct area_net
, anet
)
890 cli_msg(-1014, "\t\tArea external networks:");
893 cli_msg(-1014, "\t\t\t%1N\t%s\t%s", anet
->fn
.addr
,
894 anet
->hidden
? "Hidden" : "Advertise", anet
->active
? "Active" : "");
903 ospf_sh_iface(struct proto
*P
, const char *iff
)
905 struct ospf_proto
*p
= (struct ospf_proto
*) P
;
906 struct ospf_iface
*ifa
= NULL
;
908 if (p
->p
.proto_state
!= PS_UP
)
910 cli_msg(-1015, "%s: is not up", p
->p
.name
);
915 cli_msg(-1015, "%s:", p
->p
.name
);
916 WALK_LIST(ifa
, p
->iface_list
)
917 if ((iff
== NULL
) || patmatch(iff
, ifa
->ifname
))
918 ospf_iface_info(ifa
);
922 /* lsa_compare_for_state() - Compare function for 'show ospf state'
924 * First we want to separate network-LSAs and other LSAs (because network-LSAs
925 * will be presented as network nodes and other LSAs together as router nodes)
926 * Network-LSAs are sorted according to network prefix, other LSAs are sorted
927 * according to originating router id (to get all LSA needed to represent one
928 * router node together). Then, according to LSA type, ID and age.
930 * For OSPFv3, we have to handle also Prefix-LSAs. We would like to put each
931 * immediately after the referenced LSA. We will make faked LSA based on ref_
935 static struct ospf_lsa_header
*
936 fake_lsa_from_prefix_lsa(struct ospf_lsa_header
*dst
, struct ospf_lsa_header
*src
,
937 struct ospf_lsa_prefix
*px
)
940 dst
->type_raw
= px
->ref_type
;
941 dst
->id
= px
->ref_id
;
942 dst
->rt
= px
->ref_rt
;
949 static int lsa_compare_ospf3
;
952 lsa_compare_for_state(const void *p1
, const void *p2
)
954 struct top_hash_entry
*he1
= * (struct top_hash_entry
**) p1
;
955 struct top_hash_entry
*he2
= * (struct top_hash_entry
**) p2
;
956 struct ospf_lsa_header
*lsa1
= &(he1
->lsa
);
957 struct ospf_lsa_header
*lsa2
= &(he2
->lsa
);
958 struct ospf_lsa_header lsatmp1
, lsatmp2
;
959 u16 lsa1_type
= he1
->lsa_type
;
960 u16 lsa2_type
= he2
->lsa_type
;
962 if (he1
->domain
< he2
->domain
)
964 if (he1
->domain
> he2
->domain
)
968 /* px1 or px2 assumes OSPFv3 */
969 int px1
= (lsa1_type
== LSA_T_PREFIX
);
970 int px2
= (lsa2_type
== LSA_T_PREFIX
);
974 lsa1
= fake_lsa_from_prefix_lsa(&lsatmp1
, lsa1
, he1
->lsa_body
);
975 lsa1_type
= lsa1
->type_raw
; /* FIXME: handle unknown ref_type */
980 lsa2
= fake_lsa_from_prefix_lsa(&lsatmp2
, lsa2
, he2
->lsa_body
);
981 lsa2_type
= lsa2
->type_raw
;
985 int nt1
= (lsa1_type
== LSA_T_NET
);
986 int nt2
= (lsa2_type
== LSA_T_NET
);
993 /* In OSPFv3, networks are named based on ID of DR */
994 if (lsa_compare_ospf3
)
996 if (lsa1
->rt
< lsa2
->rt
)
998 if (lsa1
->rt
> lsa2
->rt
)
1002 /* For OSPFv2, this is IP of the network,
1003 for OSPFv3, this is interface ID */
1004 if (lsa1
->id
< lsa2
->id
)
1006 if (lsa1
->id
> lsa2
->id
)
1012 return lsa1
->sn
- lsa2
->sn
;
1016 if (lsa1
->rt
< lsa2
->rt
)
1018 if (lsa1
->rt
> lsa2
->rt
)
1021 if (lsa1_type
< lsa2_type
)
1023 if (lsa1_type
> lsa2_type
)
1026 if (lsa1
->id
< lsa2
->id
)
1028 if (lsa1
->id
> lsa2
->id
)
1034 return lsa1
->sn
- lsa2
->sn
;
1039 ext_compare_for_state(const void *p1
, const void *p2
)
1041 struct top_hash_entry
* he1
= * (struct top_hash_entry
**) p1
;
1042 struct top_hash_entry
* he2
= * (struct top_hash_entry
**) p2
;
1043 struct ospf_lsa_header
*lsa1
= &(he1
->lsa
);
1044 struct ospf_lsa_header
*lsa2
= &(he2
->lsa
);
1046 if (lsa1
->rt
< lsa2
->rt
)
1048 if (lsa1
->rt
> lsa2
->rt
)
1051 if (lsa1
->id
< lsa2
->id
)
1053 if (lsa1
->id
> lsa2
->id
)
1056 return lsa1
->sn
- lsa2
->sn
;
1060 show_lsa_distance(struct top_hash_entry
*he
)
1062 if (he
->color
== INSPF
)
1063 cli_msg(-1016, "\t\tdistance %u", he
->dist
);
1065 cli_msg(-1016, "\t\tunreachable");
1069 show_lsa_router(struct ospf_proto
*p
, struct top_hash_entry
*he
, int verbose
)
1071 struct ospf_lsa_rt_walk rtl
;
1074 cli_msg(-1016, "\trouter %R", he
->lsa
.rt
);
1075 show_lsa_distance(he
);
1077 lsa_walk_rt_init(p
, he
, &rtl
);
1078 while (lsa_walk_rt(&rtl
))
1079 if (rtl
.type
== LSART_VLNK
)
1080 cli_msg(-1016, "\t\tvlink %R metric %u", rtl
.id
, rtl
.metric
);
1082 lsa_walk_rt_init(p
, he
, &rtl
);
1083 while (lsa_walk_rt(&rtl
))
1084 if (rtl
.type
== LSART_PTP
)
1085 cli_msg(-1016, "\t\trouter %R metric %u", rtl
.id
, rtl
.metric
);
1087 lsa_walk_rt_init(p
, he
, &rtl
);
1088 while (lsa_walk_rt(&rtl
))
1089 if (rtl
.type
== LSART_NET
)
1093 /* In OSPFv2, we try to find network-LSA to get prefix/pxlen */
1094 struct top_hash_entry
*net_he
= ospf_hash_find_net2(p
->gr
, he
->domain
, rtl
.id
);
1096 if (net_he
&& (net_he
->lsa
.age
< LSA_MAXAGE
))
1098 struct ospf_lsa_header
*net_lsa
= &(net_he
->lsa
);
1099 struct ospf_lsa_net
*net_ln
= net_he
->lsa_body
;
1101 cli_msg(-1016, "\t\tnetwork %I/%d metric %u",
1102 ipa_from_u32(net_lsa
->id
& net_ln
->optx
),
1103 u32_masklen(net_ln
->optx
), rtl
.metric
);
1106 cli_msg(-1016, "\t\tnetwork [%R] metric %u", rtl
.id
, rtl
.metric
);
1109 cli_msg(-1016, "\t\tnetwork [%R-%u] metric %u", rtl
.id
, rtl
.nif
, rtl
.metric
);
1112 if (ospf_is_v2(p
) && verbose
)
1114 lsa_walk_rt_init(p
, he
, &rtl
);
1115 while (lsa_walk_rt(&rtl
))
1116 if (rtl
.type
== LSART_STUB
)
1117 cli_msg(-1016, "\t\tstubnet %I/%d metric %u",
1118 ipa_from_u32(rtl
.id
), u32_masklen(rtl
.data
), rtl
.metric
);
1123 show_lsa_network(struct top_hash_entry
*he
, int ospf2
)
1125 struct ospf_lsa_header
*lsa
= &(he
->lsa
);
1126 struct ospf_lsa_net
*ln
= he
->lsa_body
;
1132 cli_msg(-1016, "\tnetwork %I/%d", ipa_from_u32(lsa
->id
& ln
->optx
), u32_masklen(ln
->optx
));
1133 cli_msg(-1016, "\t\tdr %R", lsa
->rt
);
1138 cli_msg(-1016, "\tnetwork [%R-%u]", lsa
->rt
, lsa
->id
);
1141 show_lsa_distance(he
);
1143 for (i
= 0; i
< lsa_net_count(lsa
); i
++)
1144 cli_msg(-1016, "\t\trouter %R", ln
->routers
[i
]);
1148 show_lsa_sum_net(struct top_hash_entry
*he
, int ospf2
, int af
)
1154 lsa_parse_sum_net(he
, ospf2
, af
, &net
, &pxopts
, &metric
);
1155 cli_msg(-1016, "\t\txnetwork %N metric %u", &net
, metric
);
1159 show_lsa_sum_rt(struct top_hash_entry
*he
, int ospf2
)
1165 lsa_parse_sum_rt(he
, ospf2
, &dst_rid
, &metric
, &options
);
1166 cli_msg(-1016, "\t\txrouter %R metric %u", dst_rid
, metric
);
1171 show_lsa_external(struct top_hash_entry
*he
, int ospf2
, int af
)
1173 struct ospf_lsa_ext_local rt
;
1174 char str_via
[IPA_MAX_TEXT_LENGTH
+ 8] = "";
1175 char str_tag
[16] = "";
1177 if (he
->lsa_type
== LSA_T_EXT
)
1178 he
->domain
= 0; /* Unmark the LSA */
1180 lsa_parse_ext(he
, ospf2
, af
, &rt
);
1183 bsprintf(str_via
, " via %I", rt
.fwaddr
);
1186 bsprintf(str_tag
, " tag %08x", rt
.tag
);
1188 cli_msg(-1016, "\t\t%s %N metric%s %u%s%s",
1189 (he
->lsa_type
== LSA_T_NSSA
) ? "nssa-ext" : "external",
1190 &rt
.net
, rt
.ebit
? "2" : "", rt
.metric
, str_via
, str_tag
);
1194 show_lsa_prefix(struct top_hash_entry
*he
, struct top_hash_entry
*cnode
, int af
)
1196 struct ospf_lsa_prefix
*px
= he
->lsa_body
;
1200 /* We check whether given prefix-LSA is related to the current node */
1201 if ((px
->ref_type
!= cnode
->lsa
.type_raw
) || (px
->ref_rt
!= cnode
->lsa
.rt
))
1204 if ((px
->ref_type
== LSA_T_RT
) && (px
->ref_id
!= 0))
1207 if ((px
->ref_type
== LSA_T_NET
) && (px
->ref_id
!= cnode
->lsa
.id
))
1211 for (i
= 0; i
< px
->pxcount
; i
++)
1217 buf
= ospf3_get_prefix(buf
, af
, &net
, &pxopts
, &metric
);
1219 if (px
->ref_type
== LSA_T_RT
)
1220 cli_msg(-1016, "\t\tstubnet %N metric %u", &net
, metric
);
1222 cli_msg(-1016, "\t\taddress %N", &net
);
1227 ospf_sh_state(struct proto
*P
, int verbose
, int reachable
)
1229 struct ospf_proto
*p
= (struct ospf_proto
*) P
;
1230 int ospf2
= ospf_is_v2(p
);
1231 int af
= ospf_get_af(p
);
1233 u32 last_area
= 0xFFFFFFFF;
1235 if (p
->p
.proto_state
!= PS_UP
)
1237 cli_msg(-1016, "%s: is not up", p
->p
.name
);
1242 /* We store interesting area-scoped LSAs in array hea and
1243 global-scoped (LSA_T_EXT) LSAs in array hex */
1245 uint num
= p
->gr
->hash_entries
;
1246 struct top_hash_entry
*hea
[num
];
1247 struct top_hash_entry
**hex
= verbose
? alloca(num
* sizeof(struct top_hash_entry
*)) : NULL
;
1248 struct top_hash_entry
*he
;
1249 struct top_hash_entry
*cnode
= NULL
;
1252 WALK_SLIST(he
, p
->lsal
)
1256 if (he
->lsa
.age
== LSA_MAXAGE
)
1259 switch (he
->lsa_type
)
1276 he
->domain
= 1; /* Abuse domain field to mark the LSA */
1288 ASSERT(j1
<= num
&& jx
<= num
);
1290 lsa_compare_ospf3
= !ospf2
;
1291 qsort(hea
, j1
, sizeof(struct top_hash_entry
*), lsa_compare_for_state
);
1294 qsort(hex
, jx
, sizeof(struct top_hash_entry
*), ext_compare_for_state
);
1297 * This code is a bit tricky, we have a primary LSAs (router and
1298 * network) that are presented as a node, and secondary LSAs that
1299 * are presented as a part of a primary node. cnode represents an
1300 * currently opened node (whose header was presented). The LSAs are
1301 * sorted to get secondary LSAs just after related primary LSA (if
1302 * available). We present secondary LSAs only when related primary
1305 * AS-external LSAs are stored separately as they might be presented
1306 * several times (for each area when related ASBR is opened). When
1307 * the node is closed, related external routes are presented. We
1308 * also have to take into account that in OSPFv3, there might be
1309 * more router-LSAs and only the first should be considered as a
1310 * primary. This is handled by not closing old router-LSA when next
1311 * one is processed (which is not opened because there is already
1316 for (i
= 0; i
< j1
; i
++)
1320 /* If there is no opened node, we open the LSA (if appropriate) or skip to the next one */
1323 if (((he
->lsa_type
== LSA_T_RT
) || (he
->lsa_type
== LSA_T_NET
))
1324 && ((he
->color
== INSPF
) || !reachable
))
1328 if (he
->domain
!= last_area
)
1331 cli_msg(-1016, "area %R", he
->domain
);
1332 last_area
= he
->domain
;
1340 ASSERT(cnode
&& (he
->domain
== last_area
) && (he
->lsa
.rt
== cnode
->lsa
.rt
));
1342 switch (he
->lsa_type
)
1345 if (he
->lsa
.id
== cnode
->lsa
.id
)
1346 show_lsa_router(p
, he
, verbose
);
1350 show_lsa_network(he
, ospf2
);
1354 if (cnode
->lsa_type
== LSA_T_RT
)
1355 show_lsa_sum_net(he
, ospf2
, af
);
1359 if (cnode
->lsa_type
== LSA_T_RT
)
1360 show_lsa_sum_rt(he
, ospf2
);
1365 show_lsa_external(he
, ospf2
, af
);
1369 show_lsa_prefix(he
, cnode
, af
);
1373 /* In these cases, we close the current node */
1375 || (hea
[i
+1]->domain
!= last_area
)
1376 || (hea
[i
+1]->lsa
.rt
!= cnode
->lsa
.rt
)
1377 || (hea
[i
+1]->lsa_type
== LSA_T_NET
))
1379 while ((ix
< jx
) && (hex
[ix
]->lsa
.rt
< cnode
->lsa
.rt
))
1382 while ((ix
< jx
) && (hex
[ix
]->lsa
.rt
== cnode
->lsa
.rt
))
1383 show_lsa_external(hex
[ix
++], ospf2
, af
);
1390 u32 last_rt
= 0xFFFFFFFF;
1391 for (ix
= 0; ix
< jx
; ix
++)
1395 /* If it is still marked, we show it now. */
1400 if ((he
->color
!= INSPF
) && reachable
)
1406 cli_msg(-1016, "other ASBRs");
1410 if (he
->lsa
.rt
!= last_rt
)
1413 cli_msg(-1016, "\trouter %R", he
->lsa
.rt
);
1414 last_rt
= he
->lsa
.rt
;
1417 show_lsa_external(he
, ospf2
, af
);
1426 lsa_compare_for_lsadb(const void *p1
, const void *p2
)
1428 struct top_hash_entry
* he1
= * (struct top_hash_entry
**) p1
;
1429 struct top_hash_entry
* he2
= * (struct top_hash_entry
**) p2
;
1430 struct ospf_lsa_header
*lsa1
= &(he1
->lsa
);
1431 struct ospf_lsa_header
*lsa2
= &(he2
->lsa
);
1432 int sc1
= LSA_SCOPE(he1
->lsa_type
);
1433 int sc2
= LSA_SCOPE(he2
->lsa_type
);
1438 if (he1
->domain
!= he2
->domain
)
1439 return he1
->domain
- he2
->domain
;
1441 if (lsa1
->rt
!= lsa2
->rt
)
1442 return lsa1
->rt
- lsa2
->rt
;
1444 if (lsa1
->id
!= lsa2
->id
)
1445 return lsa1
->id
- lsa2
->id
;
1447 if (he1
->lsa_type
!= he2
->lsa_type
)
1448 return he1
->lsa_type
- he2
->lsa_type
;
1450 return lsa1
->sn
- lsa2
->sn
;
1454 ospf_sh_lsadb(struct lsadb_show_data
*ld
)
1456 struct ospf_proto
*p
= ld
->proto
;
1457 uint num
= p
->gr
->hash_entries
;
1459 int last_dscope
= -1;
1460 u32 last_domain
= 0;
1461 u16 type_mask
= ospf_is_v2(p
) ? 0x00ff : 0xffff; /* see lsa_etype() */
1463 if (p
->p
.proto_state
!= PS_UP
)
1465 cli_msg(-1017, "%s: is not up", p
->p
.name
);
1470 if (ld
->router
== SH_ROUTER_SELF
)
1471 ld
->router
= p
->router_id
;
1473 struct top_hash_entry
*hea
[num
];
1474 struct top_hash_entry
*he
;
1477 WALK_SLIST(he
, p
->lsal
)
1483 qsort(hea
, j
, sizeof(struct top_hash_entry
*), lsa_compare_for_lsadb
);
1485 for (i
= 0; i
< j
; i
++)
1487 struct ospf_lsa_header
*lsa
= &(hea
[i
]->lsa
);
1488 u16 lsa_type
= lsa
->type_raw
& type_mask
;
1489 u16 dscope
= LSA_SCOPE(hea
[i
]->lsa_type
);
1491 /* Hack: 1 is used for LSA_SCOPE_LINK, fixed by & 0xf000 */
1492 if (ld
->scope
&& (dscope
!= (ld
->scope
& 0xf000)))
1495 if ((ld
->scope
== LSA_SCOPE_AREA
) && (hea
[i
]->domain
!= ld
->area
))
1498 /* For user convenience ignore high nibble */
1499 if (ld
->type
&& ((lsa_type
& 0x0fff) != (ld
->type
& 0x0fff)))
1502 if (ld
->lsid
&& (lsa
->id
!= ld
->lsid
))
1505 if (ld
->router
&& (lsa
->rt
!= ld
->router
))
1508 if ((dscope
!= last_dscope
) || (hea
[i
]->domain
!= last_domain
))
1514 cli_msg(-1017, "Global");
1517 case LSA_SCOPE_AREA
:
1518 cli_msg(-1017, "Area %R", hea
[i
]->domain
);
1521 case LSA_SCOPE_LINK
:
1523 struct iface
*ifa
= if_find_by_index(hea
[i
]->domain
);
1524 cli_msg(-1017, "Link %s", (ifa
!= NULL
) ? ifa
->name
: "?");
1529 cli_msg(-1017," Type LS ID Router Sequence Age Checksum");
1531 last_dscope
= dscope
;
1532 last_domain
= hea
[i
]->domain
;
1535 cli_msg(-1017," %04x %-15R %-15R %08x %5u %04x",
1536 lsa_type
, lsa
->id
, lsa
->rt
, lsa
->sn
, lsa
->age
, lsa
->checksum
);
1542 struct protocol proto_ospf
= {
1544 .template = "ospf%d",
1545 .class = PROTOCOL_OSPF
,
1546 .preference
= DEF_PREF_OSPF
,
1547 .channel_mask
= NB_IP
,
1548 .proto_size
= sizeof(struct ospf_proto
),
1549 .config_size
= sizeof(struct ospf_config
),
1552 .start
= ospf_start
,
1553 .shutdown
= ospf_shutdown
,
1554 .reconfigure
= ospf_reconfigure
,
1555 .get_status
= ospf_get_status
,
1556 .get_attr
= ospf_get_attr
,
1557 .get_route_info
= ospf_get_route_info