bgpd/bgp_table.h

   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 #include "mpls.h"
  25 #include "table.h"
  26 #include "queue.h"
  27
  28 struct bgp_table {
  29         /* afi/safi of this table */
  30         afi_t afi;
  31         safi_t safi;
  32
  33         int lock;
  34
  35         struct route_table *route_table;
  36         uint64_t version;
  37 };
  38
  39 struct bgp_node {
  40         /*
  41          * CAUTION
  42          *
  43          * These fields must be the very first fields in this structure.
  44          *
  45          * @see bgp_node_to_rnode
  46          * @see bgp_node_from_rnode
  47          */
  48         ROUTE_NODE_FIELDS
  49
  50         struct bgp_adj_out *adj_out;
  51
  52         struct bgp_adj_in *adj_in;
  53
  54         struct bgp_node *prn;
  55
  56         STAILQ_ENTRY(bgp_node) pq;
  57
  58         mpls_label_t local_label;
  59
  60         uint64_t version;
  61         u_char flags;
  62 #define BGP_NODE_PROCESS_SCHEDULED      (1 << 0)
  63 #define BGP_NODE_USER_CLEAR             (1 << 1)
  64 #define BGP_NODE_LABEL_CHANGED          (1 << 2)
  65 #define BGP_NODE_REGISTERED_FOR_LABEL   (1 << 3)
  66 };
  67
  68 /*
  69  * bgp_table_iter_t
  70  *
  71  * Structure that holds state for iterating over a bgp table.
  72  */
  73 typedef struct bgp_table_iter_t_ {
  74         struct bgp_table *table;
  75         route_table_iter_t rt_iter;
  76 } bgp_table_iter_t;
  77
  78 extern struct bgp_table *bgp_table_init(afi_t, safi_t);
  79 extern void bgp_table_lock(struct bgp_table *);
  80 extern void bgp_table_unlock(struct bgp_table *);
  81 extern void bgp_table_finish(struct bgp_table **);
  82
  83
  84 /*
  85  * bgp_node_from_rnode
  86  *
  87  * Returns the bgp_node structure corresponding to a route_node.
  88  */
  89 static inline struct bgp_node *bgp_node_from_rnode(struct route_node *rnode)
  90 {
  91         return (struct bgp_node *)rnode;
  92 }
  93
  94 /*
  95  * bgp_node_to_rnode
  96  *
  97  * Returns the route_node structure corresponding to a bgp_node.
  98  */
  99 static inline struct route_node *bgp_node_to_rnode(struct bgp_node *node)
 100 {
 101         return (struct route_node *)node;
 102 }
 103
 104 /*
 105  * bgp_node_table
 106  *
 107  * Returns the bgp_table that the given node is in.
 108  */
 109 static inline struct bgp_table *bgp_node_table(struct bgp_node *node)
 110 {
 111         return bgp_node_to_rnode(node)->table->info;
 112 }
 113
 114 /*
 115  * bgp_node_parent_nolock
 116  *
 117  * Gets the parent node of the given node without locking it.
 118  */
 119 static inline struct bgp_node *bgp_node_parent_nolock(struct bgp_node *node)
 120 {
 121         return bgp_node_from_rnode(node->parent);
 122 }
 123
 124 /*
 125  * bgp_unlock_node
 126  */
 127 static inline void bgp_unlock_node(struct bgp_node *node)
 128 {
 129         route_unlock_node(bgp_node_to_rnode(node));
 130 }
 131
 132 /*
 133  * bgp_table_top_nolock
 134  *
 135  * Gets the top node in the table without locking it.
 136  *
 137  * @see bgp_table_top
 138  */
 139 static inline struct bgp_node *
 140 bgp_table_top_nolock(const struct bgp_table *const table)
 141 {
 142         return bgp_node_from_rnode(table->route_table->top);
 143 }
 144
 145 /*
 146  * bgp_table_top
 147  */
 148 static inline struct bgp_node *
 149 bgp_table_top(const struct bgp_table *const table)
 150 {
 151         return bgp_node_from_rnode(route_top(table->route_table));
 152 }
 153
 154 /*
 155  * bgp_route_next
 156  */
 157 static inline struct bgp_node *bgp_route_next(struct bgp_node *node)
 158 {
 159         return bgp_node_from_rnode(route_next(bgp_node_to_rnode(node)));
 160 }
 161
 162 /*
 163  * bgp_route_next_until
 164  */
 165 static inline struct bgp_node *bgp_route_next_until(struct bgp_node *node,
 166                                                     struct bgp_node *limit)
 167 {
 168         struct route_node *rnode;
 169
 170         rnode = route_next_until(bgp_node_to_rnode(node),
 171                                  bgp_node_to_rnode(limit));
 172         return bgp_node_from_rnode(rnode);
 173 }
 174
 175 /*
 176  * bgp_node_get
 177  */
 178 static inline struct bgp_node *bgp_node_get(struct bgp_table *const table,
 179                                             struct prefix *p)
 180 {
 181         return bgp_node_from_rnode(route_node_get(table->route_table, p));
 182 }
 183
 184 /*
 185  * bgp_node_lookup
 186  */
 187 static inline struct bgp_node *
 188 bgp_node_lookup(const struct bgp_table *const table, struct prefix *p)
 189 {
 190         return bgp_node_from_rnode(route_node_lookup(table->route_table, p));
 191 }
 192
 193 /*
 194  * bgp_lock_node
 195  */
 196 static inline struct bgp_node *bgp_lock_node(struct bgp_node *node)
 197 {
 198         return bgp_node_from_rnode(route_lock_node(bgp_node_to_rnode(node)));
 199 }
 200
 201 /*
 202  * bgp_node_match
 203  */
 204 static inline struct bgp_node *bgp_node_match(const struct bgp_table *table,
 205                                               struct prefix *p)
 206 {
 207         return bgp_node_from_rnode(route_node_match(table->route_table, p));
 208 }
 209
 210 /*
 211  * bgp_node_match_ipv4
 212  */
 213 static inline struct bgp_node *
 214 bgp_node_match_ipv4(const struct bgp_table *table, struct in_addr *addr)
 215 {
 216         return bgp_node_from_rnode(
 217                 route_node_match_ipv4(table->route_table, addr));
 218 }
 219
 220 /*
 221  * bgp_node_match_ipv6
 222  */
 223 static inline struct bgp_node *
 224 bgp_node_match_ipv6(const struct bgp_table *table, struct in6_addr *addr)
 225 {
 226         return bgp_node_from_rnode(
 227                 route_node_match_ipv6(table->route_table, addr));
 228 }
 229
 230 static inline unsigned long bgp_table_count(const struct bgp_table *const table)
 231 {
 232         return route_table_count(table->route_table);
 233 }
 234
 235 /*
 236  * bgp_table_get_next
 237  */
 238 static inline struct bgp_node *bgp_table_get_next(const struct bgp_table *table,
 239                                                   struct prefix *p)
 240 {
 241         return bgp_node_from_rnode(route_table_get_next(table->route_table, p));
 242 }
 243
 244 /*
 245  * bgp_table_iter_init
 246  */
 247 static inline void bgp_table_iter_init(bgp_table_iter_t *iter,
 248                                        struct bgp_table *table)
 249 {
 250         bgp_table_lock(table);
 251         iter->table = table;
 252         route_table_iter_init(&iter->rt_iter, table->route_table);
 253 }
 254
 255 /*
 256  * bgp_table_iter_next
 257  */
 258 static inline struct bgp_node *bgp_table_iter_next(bgp_table_iter_t *iter)
 259 {
 260         return bgp_node_from_rnode(route_table_iter_next(&iter->rt_iter));
 261 }
 262
 263 /*
 264  * bgp_table_iter_cleanup
 265  */
 266 static inline void bgp_table_iter_cleanup(bgp_table_iter_t *iter)
 267 {
 268         route_table_iter_cleanup(&iter->rt_iter);
 269         bgp_table_unlock(iter->table);
 270         iter->table = NULL;
 271 }
 272
 273 /*
 274  * bgp_table_iter_pause
 275  */
 276 static inline void bgp_table_iter_pause(bgp_table_iter_t *iter)
 277 {
 278         route_table_iter_pause(&iter->rt_iter);
 279 }
 280
 281 /*
 282  * bgp_table_iter_is_done
 283  */
 284 static inline int bgp_table_iter_is_done(bgp_table_iter_t *iter)
 285 {
 286         return route_table_iter_is_done(&iter->rt_iter);
 287 }
 288
 289 /*
 290  * bgp_table_iter_started
 291  */
 292 static inline int bgp_table_iter_started(bgp_table_iter_t *iter)
 293 {
 294         return route_table_iter_started(&iter->rt_iter);
 295 }
 296
 297 /* This would benefit from a real atomic operation...
 298  * until then. */
 299 static inline uint64_t bgp_table_next_version(struct bgp_table *table)
 300 {
 301         return ++table->version;
 302 }
 303
 304 static inline uint64_t bgp_table_version(struct bgp_table *table)
 305 {
 306         return table->version;
 307 }
 308
 309 #endif /* _QUAGGA_BGP_TABLE_H */