2 Copyright (C) 1998, 2001 Kunihiro Ishiguro
4 This file is part of GNU Zebra.
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
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.
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
21 #ifndef _QUAGGA_BGP_TABLE_H
22 #define _QUAGGA_BGP_TABLE_H
28 /* afi/safi of this table */
34 /* The owner of this 'bgp_table' structure. */
37 struct route_table
*route_table
;
46 * These fields must be the very first fields in this structure.
48 * @see bgp_node_to_rnode
49 * @see bgp_node_from_rnode
53 struct bgp_adj_out
*adj_out
;
55 struct bgp_adj_in
*adj_in
;
61 #define BGP_NODE_PROCESS_SCHEDULED (1 << 0)
62 #define BGP_NODE_USER_CLEAR (1 << 1)
68 * Structure that holds state for iterating over a bgp table.
70 typedef struct bgp_table_iter_t_
72 struct bgp_table
*table
;
73 route_table_iter_t rt_iter
;
76 extern struct bgp_table
*bgp_table_init (afi_t
, safi_t
);
77 extern void bgp_table_lock (struct bgp_table
*);
78 extern void bgp_table_unlock (struct bgp_table
*);
79 extern void bgp_table_finish (struct bgp_table
**);
85 * Returns the bgp_node structure corresponding to a route_node.
87 static inline struct bgp_node
*
88 bgp_node_from_rnode (struct route_node
*rnode
)
90 return (struct bgp_node
*) rnode
;
96 * Returns the route_node structure corresponding to a bgp_node.
98 static inline struct route_node
*
99 bgp_node_to_rnode (struct bgp_node
*node
)
101 return (struct route_node
*) node
;
107 * Returns the bgp_table that the given node is in.
109 static inline struct bgp_table
*
110 bgp_node_table (struct bgp_node
*node
)
112 return bgp_node_to_rnode (node
)->table
->info
;
116 * bgp_node_parent_nolock
118 * Gets the parent node of the given node without locking it.
120 static inline struct bgp_node
*
121 bgp_node_parent_nolock (struct bgp_node
*node
)
123 return bgp_node_from_rnode (node
->parent
);
130 bgp_unlock_node (struct bgp_node
*node
)
132 route_unlock_node (bgp_node_to_rnode (node
));
136 * bgp_table_top_nolock
138 * Gets the top node in the table without locking it.
142 static inline struct bgp_node
*
143 bgp_table_top_nolock (const struct bgp_table
*const table
)
145 return bgp_node_from_rnode (table
->route_table
->top
);
151 static inline struct bgp_node
*
152 bgp_table_top (const struct bgp_table
*const table
)
154 return bgp_node_from_rnode (route_top (table
->route_table
));
160 static inline struct bgp_node
*
161 bgp_route_next (struct bgp_node
*node
)
163 return bgp_node_from_rnode (route_next (bgp_node_to_rnode (node
)));
167 * bgp_route_next_until
169 static inline struct bgp_node
*
170 bgp_route_next_until (struct bgp_node
*node
, struct bgp_node
*limit
)
172 struct route_node
*rnode
;
174 rnode
= route_next_until (bgp_node_to_rnode (node
),
175 bgp_node_to_rnode (limit
));
176 return bgp_node_from_rnode (rnode
);
182 static inline struct bgp_node
*
183 bgp_node_get (struct bgp_table
*const table
, struct prefix
*p
)
185 return bgp_node_from_rnode (route_node_get (table
->route_table
, p
));
191 static inline struct bgp_node
*
192 bgp_node_lookup (const struct bgp_table
*const table
, struct prefix
*p
)
194 return bgp_node_from_rnode (route_node_lookup (table
->route_table
, p
));
200 static inline struct bgp_node
*
201 bgp_lock_node (struct bgp_node
*node
)
203 return bgp_node_from_rnode (route_lock_node (bgp_node_to_rnode (node
)));
209 static inline struct bgp_node
*
210 bgp_node_match (const struct bgp_table
*table
, struct prefix
*p
)
212 return bgp_node_from_rnode (route_node_match (table
->route_table
, p
));
216 * bgp_node_match_ipv4
218 static inline struct bgp_node
*
219 bgp_node_match_ipv4 (const struct bgp_table
*table
, struct in_addr
*addr
)
221 return bgp_node_from_rnode (route_node_match_ipv4 (table
->route_table
,
226 * bgp_node_match_ipv6
228 static inline struct bgp_node
*
229 bgp_node_match_ipv6 (const struct bgp_table
*table
, struct in6_addr
*addr
)
231 return bgp_node_from_rnode (route_node_match_ipv6 (table
->route_table
,
235 static inline unsigned long
236 bgp_table_count (const struct bgp_table
*const table
)
238 return route_table_count (table
->route_table
);
244 static inline struct bgp_node
*
245 bgp_table_get_next (const struct bgp_table
*table
, struct prefix
*p
)
247 return bgp_node_from_rnode (route_table_get_next (table
->route_table
, p
));
251 * bgp_table_iter_init
254 bgp_table_iter_init (bgp_table_iter_t
* iter
, struct bgp_table
*table
)
256 bgp_table_lock (table
);
258 route_table_iter_init (&iter
->rt_iter
, table
->route_table
);
262 * bgp_table_iter_next
264 static inline struct bgp_node
*
265 bgp_table_iter_next (bgp_table_iter_t
* iter
)
267 return bgp_node_from_rnode (route_table_iter_next (&iter
->rt_iter
));
271 * bgp_table_iter_cleanup
274 bgp_table_iter_cleanup (bgp_table_iter_t
* iter
)
276 route_table_iter_cleanup (&iter
->rt_iter
);
277 bgp_table_unlock (iter
->table
);
282 * bgp_table_iter_pause
285 bgp_table_iter_pause (bgp_table_iter_t
* iter
)
287 route_table_iter_pause (&iter
->rt_iter
);
291 * bgp_table_iter_is_done
294 bgp_table_iter_is_done (bgp_table_iter_t
* iter
)
296 return route_table_iter_is_done (&iter
->rt_iter
);
300 * bgp_table_iter_started
303 bgp_table_iter_started (bgp_table_iter_t
* iter
)
305 return route_table_iter_started (&iter
->rt_iter
);
308 /* This would benefit from a real atomic operation...
310 static inline uint64_t
311 bgp_table_next_version (struct bgp_table
*table
)
313 return ++table
->version
;
316 static inline uint64_t
317 bgp_table_version (struct bgp_table
*table
)
319 return table
->version
;
322 #endif /* _QUAGGA_BGP_TABLE_H */