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
17 : along with GNU Zebra; see the file COPYING. If not, write to the Free
18 : Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
19 : 02111-1307, USA. */
20 :
21 : #ifndef _QUAGGA_BGP_TABLE_H
22 : #define _QUAGGA_BGP_TABLE_H
23 :
24 : #include "table.h"
25 :
26 : typedef enum
27 : {
28 : BGP_TABLE_MAIN,
29 : BGP_TABLE_RSCLIENT,
30 : } bgp_table_t;
31 :
32 : struct bgp_table
33 : {
34 : bgp_table_t type;
35 :
36 : /* afi/safi of this table */
37 : afi_t afi;
38 : safi_t safi;
39 :
40 : int lock;
41 :
42 : /* The owner of this 'bgp_table' structure. */
43 : struct peer *owner;
44 :
45 : struct route_table *route_table;
46 : };
47 :
48 : struct bgp_node
49 : {
50 : /*
51 : * CAUTION
52 : *
53 : * These fields must be the very first fields in this structure.
54 : *
55 : * @see bgp_node_to_rnode
56 : * @see bgp_node_from_rnode
57 : */
58 : ROUTE_NODE_FIELDS;
59 :
60 : struct bgp_adj_out *adj_out;
61 :
62 : struct bgp_adj_in *adj_in;
63 :
64 : struct bgp_node *prn;
65 :
66 : u_char flags;
67 : #define BGP_NODE_PROCESS_SCHEDULED (1 << 0)
68 : };
69 :
70 : /*
71 : * bgp_table_iter_t
72 : *
73 : * Structure that holds state for iterating over a bgp table.
74 : */
75 : typedef struct bgp_table_iter_t_
76 : {
77 : struct bgp_table *table;
78 : route_table_iter_t rt_iter;
79 : } bgp_table_iter_t;
80 :
81 : extern struct bgp_table *bgp_table_init (afi_t, safi_t);
82 : extern void bgp_table_lock (struct bgp_table *);
83 : extern void bgp_table_unlock (struct bgp_table *);
84 : extern void bgp_table_finish (struct bgp_table **);
85 :
86 :
87 : /*
88 : * bgp_node_from_rnode
89 : *
90 : * Returns the bgp_node structure corresponding to a route_node.
91 : */
92 : static inline struct bgp_node *
93 17 : bgp_node_from_rnode (struct route_node *rnode)
94 : {
95 17 : return (struct bgp_node *) rnode;
96 : }
97 :
98 : /*
99 : * bgp_node_to_rnode
100 : *
101 : * Returns the route_node structure corresponding to a bgp_node.
102 : */
103 : static inline struct route_node *
104 5 : bgp_node_to_rnode (struct bgp_node *node)
105 : {
106 5 : return (struct route_node *) node;
107 : }
108 :
109 : /*
110 : * bgp_node_table
111 : *
112 : * Returns the bgp_table that the given node is in.
113 : */
114 : static inline struct bgp_table *
115 0 : bgp_node_table (struct bgp_node *node)
116 : {
117 0 : return bgp_node_to_rnode (node)->table->info;
118 : }
119 :
120 : /*
121 : * bgp_node_info
122 : *
123 : * Returns the 'info' pointer corresponding to a bgp node.
124 : */
125 : static inline void *
126 : bgp_node_info (const struct bgp_node *node)
127 : {
128 : return node->info;
129 : }
130 :
131 : /*
132 : * bgp_node_set_info
133 : */
134 : static inline void
135 : bgp_node_set_info (struct bgp_node *node, void *info)
136 : {
137 : node->info = info;
138 : }
139 :
140 : /*
141 : * bgp_node_prefix
142 : */
143 : static inline struct prefix *
144 : bgp_node_prefix (struct bgp_node *node)
145 : {
146 : return &node->p;
147 : }
148 :
149 : /*
150 : * bgp_node_prefixlen
151 : */
152 : static inline u_char
153 : bgp_node_prefixlen (struct bgp_node *node)
154 : {
155 : return bgp_node_prefix (node)->prefixlen;
156 : }
157 :
158 : /*
159 : * bgp_node_parent_nolock
160 : *
161 : * Gets the parent node of the given node without locking it.
162 : */
163 : static inline struct bgp_node *
164 0 : bgp_node_parent_nolock (struct bgp_node *node)
165 : {
166 0 : return bgp_node_from_rnode (node->parent);
167 : }
168 :
169 : /*
170 : * bgp_unlock_node
171 : */
172 : static inline void
173 0 : bgp_unlock_node (struct bgp_node *node)
174 : {
175 0 : route_unlock_node (bgp_node_to_rnode (node));
176 0 : }
177 :
178 : /*
179 : * bgp_table_top_nolock
180 : *
181 : * Gets the top node in the table without locking it.
182 : *
183 : * @see bgp_table_top
184 : */
185 : static inline struct bgp_node *
186 0 : bgp_table_top_nolock (const struct bgp_table *const table)
187 : {
188 0 : return bgp_node_from_rnode (table->route_table->top);
189 : }
190 :
191 : /*
192 : * bgp_table_top
193 : */
194 : static inline struct bgp_node *
195 12 : bgp_table_top (const struct bgp_table *const table)
196 : {
197 12 : return bgp_node_from_rnode (route_top (table->route_table));
198 : }
199 :
200 : /*
201 : * bgp_route_next
202 : */
203 : static inline struct bgp_node *
204 0 : bgp_route_next (struct bgp_node *node)
205 : {
206 0 : return bgp_node_from_rnode (route_next (bgp_node_to_rnode (node)));
207 : }
208 :
209 : /*
210 : * bgp_route_next_until
211 : */
212 : static inline struct bgp_node *
213 0 : bgp_route_next_until (struct bgp_node *node, struct bgp_node *limit)
214 : {
215 : struct route_node *rnode;
216 :
217 0 : rnode = route_next_until (bgp_node_to_rnode (node),
218 : bgp_node_to_rnode (limit));
219 0 : return bgp_node_from_rnode (rnode);
220 : }
221 :
222 : /*
223 : * bgp_node_get
224 : */
225 : static inline struct bgp_node *
226 0 : bgp_node_get (struct bgp_table *const table, struct prefix *p)
227 : {
228 0 : return bgp_node_from_rnode (route_node_get (table->route_table, p));
229 : }
230 :
231 : /*
232 : * bgp_node_lookup
233 : */
234 : static inline struct bgp_node *
235 0 : bgp_node_lookup (const struct bgp_table *const table, struct prefix *p)
236 : {
237 0 : return bgp_node_from_rnode (route_node_lookup (table->route_table, p));
238 : }
239 :
240 : /*
241 : * bgp_lock_node
242 : */
243 : static inline struct bgp_node *
244 5 : bgp_lock_node (struct bgp_node *node)
245 : {
246 5 : return bgp_node_from_rnode (route_lock_node (bgp_node_to_rnode (node)));
247 : }
248 :
249 : /*
250 : * bgp_node_match
251 : */
252 : static inline struct bgp_node *
253 0 : bgp_node_match (const struct bgp_table *table, struct prefix *p)
254 : {
255 0 : return bgp_node_from_rnode (route_node_match (table->route_table, p));
256 : }
257 :
258 : /*
259 : * bgp_node_match_ipv4
260 : */
261 : static inline struct bgp_node *
262 0 : bgp_node_match_ipv4 (const struct bgp_table *table, struct in_addr *addr)
263 : {
264 0 : return bgp_node_from_rnode (route_node_match_ipv4 (table->route_table,
265 : addr));
266 : }
267 :
268 : #ifdef HAVE_IPV6
269 :
270 : /*
271 : * bgp_node_match_ipv6
272 : */
273 : static inline struct bgp_node *
274 0 : bgp_node_match_ipv6 (const struct bgp_table *table, struct in6_addr *addr)
275 : {
276 0 : return bgp_node_from_rnode (route_node_match_ipv6 (table->route_table,
277 : addr));
278 : }
279 :
280 : #endif /* HAVE_IPV6 */
281 :
282 : static inline unsigned long
283 0 : bgp_table_count (const struct bgp_table *const table)
284 : {
285 0 : return route_table_count (table->route_table);
286 : }
287 :
288 : /*
289 : * bgp_table_get_next
290 : */
291 : static inline struct bgp_node *
292 : bgp_table_get_next (const struct bgp_table *table, struct prefix *p)
293 : {
294 : return bgp_node_from_rnode (route_table_get_next (table->route_table, p));
295 : }
296 :
297 : /*
298 : * bgp_table_iter_init
299 : */
300 : static inline void
301 : bgp_table_iter_init (bgp_table_iter_t * iter, struct bgp_table *table)
302 : {
303 : bgp_table_lock (table);
304 : iter->table = table;
305 : route_table_iter_init (&iter->rt_iter, table->route_table);
306 : }
307 :
308 : /*
309 : * bgp_table_iter_next
310 : */
311 : static inline struct bgp_node *
312 : bgp_table_iter_next (bgp_table_iter_t * iter)
313 : {
314 : return bgp_node_from_rnode (route_table_iter_next (&iter->rt_iter));
315 : }
316 :
317 : /*
318 : * bgp_table_iter_cleanup
319 : */
320 : static inline void
321 : bgp_table_iter_cleanup (bgp_table_iter_t * iter)
322 : {
323 : route_table_iter_cleanup (&iter->rt_iter);
324 : bgp_table_unlock (iter->table);
325 : iter->table = NULL;
326 : }
327 :
328 : /*
329 : * bgp_table_iter_pause
330 : */
331 : static inline void
332 : bgp_table_iter_pause (bgp_table_iter_t * iter)
333 : {
334 : route_table_iter_pause (&iter->rt_iter);
335 : }
336 :
337 : /*
338 : * bgp_table_iter_is_done
339 : */
340 : static inline int
341 : bgp_table_iter_is_done (bgp_table_iter_t * iter)
342 : {
343 : return route_table_iter_is_done (&iter->rt_iter);
344 : }
345 :
346 : /*
347 : * bgp_table_iter_started
348 : */
349 : static inline int
350 : bgp_table_iter_started (bgp_table_iter_t * iter)
351 : {
352 : return route_table_iter_started (&iter->rt_iter);
353 : }
354 :
355 : #endif /* _QUAGGA_BGP_TABLE_H */
|
