Line data Source code
1 : /* BGP routing table
2 : * Copyright (C) 1998, 2001 Kunihiro Ishiguro
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 : #ifndef _QUAGGA_BGP_TABLE_H
22 : #define _QUAGGA_BGP_TABLE_H
23 :
24 : /* XXX BEGIN TEMPORARY COMPAT */
25 : #define bgp_dest bgp_node
26 : /* XXX END TEMPORARY COMPAT */
27 :
28 : #include "mpls.h"
29 : #include "table.h"
30 : #include "queue.h"
31 : #include "linklist.h"
32 : #include "bgpd.h"
33 : #include "bgp_advertise.h"
34 :
35 : struct bgp_table {
36 : /* table belongs to this instance */
37 : struct bgp *bgp;
38 :
39 : /* afi/safi of this table */
40 : afi_t afi;
41 : safi_t safi;
42 :
43 : int lock;
44 :
45 : /* soft_reconfig_table in progress */
46 : bool soft_reconfig_init;
47 : struct thread *soft_reconfig_thread;
48 :
49 : /* list of peers on which soft_reconfig_table has to run */
50 : struct list *soft_reconfig_peers;
51 :
52 : struct route_table *route_table;
53 : uint64_t version;
54 : };
55 :
56 : enum bgp_path_selection_reason {
57 : bgp_path_selection_none,
58 : bgp_path_selection_first,
59 : bgp_path_selection_evpn_sticky_mac,
60 : bgp_path_selection_evpn_seq,
61 : bgp_path_selection_evpn_local_path,
62 : bgp_path_selection_evpn_non_proxy,
63 : bgp_path_selection_evpn_lower_ip,
64 : bgp_path_selection_weight,
65 : bgp_path_selection_local_pref,
66 : bgp_path_selection_accept_own,
67 : bgp_path_selection_local_route,
68 : bgp_path_selection_aigp,
69 : bgp_path_selection_confed_as_path,
70 : bgp_path_selection_as_path,
71 : bgp_path_selection_origin,
72 : bgp_path_selection_med,
73 : bgp_path_selection_peer,
74 : bgp_path_selection_confed,
75 : bgp_path_selection_igp_metric,
76 : bgp_path_selection_older,
77 : bgp_path_selection_router_id,
78 : bgp_path_selection_cluster_length,
79 : bgp_path_selection_stale,
80 : bgp_path_selection_local_configured,
81 : bgp_path_selection_neighbor_ip,
82 : bgp_path_selection_default,
83 : };
84 :
85 : struct bgp_node {
86 : /*
87 : * CAUTION
88 : *
89 : * These fields must be the very first fields in this structure.
90 : *
91 : * @see bgp_node_to_rnode
92 : * @see bgp_node_from_rnode
93 : */
94 : ROUTE_NODE_FIELDS
95 :
96 : struct bgp_adj_out_rb adj_out;
97 :
98 : struct bgp_adj_in *adj_in;
99 :
100 : struct bgp_dest *pdest;
101 :
102 : STAILQ_ENTRY(bgp_dest) pq;
103 :
104 : uint64_t version;
105 :
106 : mpls_label_t local_label;
107 :
108 : uint16_t flags;
109 : #define BGP_NODE_PROCESS_SCHEDULED (1 << 0)
110 : #define BGP_NODE_USER_CLEAR (1 << 1)
111 : #define BGP_NODE_LABEL_CHANGED (1 << 2)
112 : #define BGP_NODE_REGISTERED_FOR_LABEL (1 << 3)
113 : #define BGP_NODE_SELECT_DEFER (1 << 4)
114 : #define BGP_NODE_FIB_INSTALL_PENDING (1 << 5)
115 : #define BGP_NODE_FIB_INSTALLED (1 << 6)
116 : #define BGP_NODE_LABEL_REQUESTED (1 << 7)
117 : #define BGP_NODE_SOFT_RECONFIG (1 << 8)
118 :
119 : struct bgp_addpath_node_data tx_addpath;
120 :
121 : enum bgp_path_selection_reason reason;
122 : };
123 :
124 : extern void bgp_delete_listnode(struct bgp_dest *dest);
125 : /*
126 : * bgp_table_iter_t
127 : *
128 : * Structure that holds state for iterating over a bgp table.
129 : */
130 : typedef struct bgp_table_iter_t_ {
131 : struct bgp_table *table;
132 : route_table_iter_t rt_iter;
133 : } bgp_table_iter_t;
134 :
135 : extern struct bgp_table *bgp_table_init(struct bgp *bgp, afi_t, safi_t);
136 : extern void bgp_table_lock(struct bgp_table *);
137 : extern void bgp_table_unlock(struct bgp_table *);
138 : extern void bgp_table_finish(struct bgp_table **);
139 : extern void bgp_dest_unlock_node(struct bgp_dest *dest);
140 : extern struct bgp_dest *bgp_dest_lock_node(struct bgp_dest *dest);
141 : extern const char *bgp_dest_get_prefix_str(struct bgp_dest *dest);
142 :
143 :
144 : /*
145 : * bgp_dest_from_rnode
146 : *
147 : * Returns the bgp_dest structure corresponding to a route_node.
148 : */
149 : static inline struct bgp_dest *bgp_dest_from_rnode(struct route_node *rnode)
150 : {
151 : return (struct bgp_dest *)rnode;
152 : }
153 :
154 : /*
155 : * bgp_dest_to_rnode
156 : *
157 : * Returns the route_node structure corresponding to a bgp_dest.
158 : */
159 : static inline struct route_node *bgp_dest_to_rnode(const struct bgp_dest *dest)
160 : {
161 : return (struct route_node *)dest;
162 : }
163 :
164 : /*
165 : * bgp_dest_table
166 : *
167 : * Returns the bgp_table that the given dest is in.
168 : */
169 22 : static inline struct bgp_table *bgp_dest_table(struct bgp_dest *dest)
170 : {
171 26 : return route_table_get_info(bgp_dest_to_rnode(dest)->table);
172 : }
173 :
174 : /*
175 : * bgp_dest_parent_nolock
176 : *
177 : * Gets the parent dest of the given node without locking it.
178 : */
179 0 : static inline struct bgp_dest *bgp_dest_parent_nolock(struct bgp_dest *dest)
180 : {
181 0 : struct route_node *rn = bgp_dest_to_rnode(dest)->parent;
182 :
183 0 : return bgp_dest_from_rnode(rn);
184 : }
185 :
186 : /*
187 : * bgp_table_top_nolock
188 : *
189 : * Gets the top dest in the table without locking it.
190 : *
191 : * @see bgp_table_top
192 : */
193 : static inline struct bgp_dest *
194 6 : bgp_table_top_nolock(const struct bgp_table *const table)
195 : {
196 6 : return bgp_dest_from_rnode(table->route_table->top);
197 : }
198 :
199 : /*
200 : * bgp_table_top
201 : */
202 : static inline struct bgp_dest *
203 227 : bgp_table_top(const struct bgp_table *const table)
204 : {
205 227 : return bgp_dest_from_rnode(route_top(table->route_table));
206 : }
207 :
208 : /*
209 : * bgp_route_next
210 : */
211 24 : static inline struct bgp_dest *bgp_route_next(struct bgp_dest *dest)
212 : {
213 24 : return bgp_dest_from_rnode(route_next(bgp_dest_to_rnode(dest)));
214 : }
215 :
216 : /*
217 : * bgp_route_next_until
218 : */
219 0 : static inline struct bgp_dest *bgp_route_next_until(struct bgp_dest *dest,
220 : struct bgp_dest *limit)
221 : {
222 0 : struct route_node *rnode;
223 :
224 0 : rnode = route_next_until(bgp_dest_to_rnode(dest),
225 : bgp_dest_to_rnode(limit));
226 :
227 0 : return bgp_dest_from_rnode(rnode);
228 : }
229 :
230 : /*
231 : * bgp_node_get
232 : */
233 26 : static inline struct bgp_dest *bgp_node_get(struct bgp_table *const table,
234 : const struct prefix *p)
235 : {
236 26 : return bgp_dest_from_rnode(route_node_get(table->route_table, p));
237 : }
238 :
239 : /*
240 : * bgp_node_lookup
241 : */
242 : static inline struct bgp_dest *
243 14 : bgp_node_lookup(const struct bgp_table *const table, const struct prefix *p)
244 : {
245 14 : struct route_node *rn = route_node_lookup(table->route_table, p);
246 :
247 14 : return bgp_dest_from_rnode(rn);
248 : }
249 :
250 : /*
251 : * bgp_node_match
252 : */
253 6 : static inline struct bgp_dest *bgp_node_match(const struct bgp_table *table,
254 : const struct prefix *p)
255 : {
256 6 : struct route_node *rn = route_node_match(table->route_table, p);
257 :
258 6 : return bgp_dest_from_rnode(rn);
259 : }
260 :
261 0 : static inline unsigned long bgp_table_count(const struct bgp_table *const table)
262 : {
263 0 : return route_table_count(table->route_table);
264 : }
265 :
266 : /*
267 : * bgp_table_get_next
268 : */
269 : static inline struct bgp_dest *bgp_table_get_next(const struct bgp_table *table,
270 : const struct prefix *p)
271 : {
272 : return bgp_dest_from_rnode(route_table_get_next(table->route_table, p));
273 : }
274 :
275 : /* This would benefit from a real atomic operation...
276 : * until then. */
277 4 : static inline uint64_t bgp_table_next_version(struct bgp_table *table)
278 : {
279 4 : return ++table->version;
280 : }
281 :
282 0 : static inline uint64_t bgp_table_version(struct bgp_table *table)
283 : {
284 0 : return table->version;
285 : }
286 :
287 : /* Find the subtree of the prefix p
288 : *
289 : * This will return the first node that belongs the the subtree of p. Including
290 : * p itself, if it is in the tree.
291 : *
292 : * If the subtree is not present in the table, NULL is returned.
293 : */
294 : struct bgp_dest *bgp_table_subtree_lookup(const struct bgp_table *table,
295 : const struct prefix *p);
296 :
297 : static inline struct bgp_aggregate *
298 0 : bgp_dest_get_bgp_aggregate_info(struct bgp_dest *dest)
299 : {
300 0 : return dest ? dest->info : NULL;
301 : }
302 :
303 : static inline void
304 0 : bgp_dest_set_bgp_aggregate_info(struct bgp_dest *dest,
305 : struct bgp_aggregate *aggregate)
306 : {
307 0 : dest->info = aggregate;
308 : }
309 :
310 : static inline struct bgp_distance *
311 0 : bgp_dest_get_bgp_distance_info(struct bgp_dest *dest)
312 : {
313 0 : return dest ? dest->info : NULL;
314 : }
315 :
316 0 : static inline void bgp_dest_set_bgp_distance_info(struct bgp_dest *dest,
317 : struct bgp_distance *distance)
318 : {
319 0 : dest->info = distance;
320 0 : }
321 :
322 : static inline struct bgp_static *
323 0 : bgp_dest_get_bgp_static_info(struct bgp_dest *dest)
324 : {
325 0 : return dest ? dest->info : NULL;
326 : }
327 :
328 0 : static inline void bgp_dest_set_bgp_static_info(struct bgp_dest *dest,
329 : struct bgp_static *bgp_static)
330 : {
331 0 : dest->info = bgp_static;
332 0 : }
333 :
334 : static inline struct bgp_connected_ref *
335 38 : bgp_dest_get_bgp_connected_ref_info(struct bgp_dest *dest)
336 : {
337 38 : return dest ? dest->info : NULL;
338 : }
339 :
340 : static inline void
341 18 : bgp_dest_set_bgp_connected_ref_info(struct bgp_dest *dest,
342 : struct bgp_connected_ref *bc)
343 : {
344 18 : dest->info = bc;
345 18 : }
346 :
347 : static inline struct bgp_nexthop_cache *
348 : bgp_dest_get_bgp_nexthop_info(struct bgp_dest *dest)
349 : {
350 : return dest ? dest->info : NULL;
351 : }
352 :
353 : static inline void bgp_dest_set_bgp_nexthop_info(struct bgp_dest *dest,
354 : struct bgp_nexthop_cache *bnc)
355 : {
356 : dest->info = bnc;
357 : }
358 :
359 : static inline struct bgp_path_info *
360 46 : bgp_dest_get_bgp_path_info(struct bgp_dest *dest)
361 : {
362 50 : return dest ? dest->info : NULL;
363 : }
364 :
365 8 : static inline void bgp_dest_set_bgp_path_info(struct bgp_dest *dest,
366 : struct bgp_path_info *bi)
367 : {
368 4 : dest->info = bi;
369 4 : }
370 :
371 : static inline struct bgp_table *
372 0 : bgp_dest_get_bgp_table_info(struct bgp_dest *dest)
373 : {
374 0 : return dest->info;
375 : }
376 :
377 0 : static inline void bgp_dest_set_bgp_table_info(struct bgp_dest *dest,
378 : struct bgp_table *table)
379 : {
380 0 : dest->info = table;
381 0 : }
382 :
383 0 : static inline bool bgp_dest_has_bgp_path_info_data(struct bgp_dest *dest)
384 : {
385 0 : return !!dest->info;
386 : }
387 :
388 27 : static inline const struct prefix *bgp_dest_get_prefix(const struct bgp_dest *dest)
389 : {
390 31 : return &dest->p;
391 : }
392 :
393 0 : static inline unsigned int bgp_dest_get_lock_count(const struct bgp_dest *dest)
394 : {
395 0 : return dest->lock;
396 : }
397 :
398 : #ifdef _FRR_ATTRIBUTE_PRINTFRR
399 : #pragma FRR printfrr_ext "%pRN" (struct bgp_node *)
400 : #pragma FRR printfrr_ext "%pBD" (struct bgp_dest *)
401 : #endif
402 :
403 : #endif /* _QUAGGA_BGP_TABLE_H */
|
